{"metadata":{"kernelspec":{"language":"python","display_name":"Python 3","name":"python3"},"language_info":{"pygments_lexer":"ipython3","nbconvert_exporter":"python","version":"3.6.4","file_extension":".py","codemirror_mode":{"name":"ipython","version":3},"name":"python","mimetype":"text/x-python"}},"nbformat_minor":4,"nbformat":4,"cells":[{"cell_type":"markdown","source":"> # ***Quora Insincere Questions Classification***\n\n#### BÁO CÁO ĐỀ TÀI CUỐI KỲ  \n   **Họ và tên**: Lê Tiến Phát  \n   **MSSV**: 18020993  \n   **Lớp học phần**: INT_3405_1  \n   **Giảng viên**: Trần Quốc Long  ","metadata":{}},{"cell_type":"markdown","source":"# **1. Mô tả bài toán**\n\n[Quora](https://www.quora.com) là một diễn đàn mở với mục đích trao đổi kiến thức giữa người với người. Trên diễn đàn mọi người sẽ đưa ra những thắc mắc và nhận lại những câu trả lời mang tính chuyên sâu và chất lượng. Vấn đề cần giải quyết lúc này là tìm và loại bỏ những câu hỏi thiếu thành thật hay thiếu tế nhị (insincere) mang tính phát biểu thể hiện hơn là cần tìm kiếm câu trả lời. \n\n* **Input:** Câu hỏi bằng tiếng Anh\n* **Output:** Xác nhận TRUE/FALSE rằng câu hỏi có insincere hay không, bằng cách đánh label 0 cho *sincere* và 1 cho *insincere* ","metadata":{}},{"cell_type":"markdown","source":"# **2. Phân tích dữ liệu** ","metadata":{}},{"cell_type":"code","source":"# Khởi tạo môi trường\nimport numpy as np # linear algebra\nimport pandas as pd # data processing, CSV file I/O\nimport os\nimport time\nimport matplotlib.pyplot as plt\nimport gc\n\nfrom sklearn.model_selection import train_test_split\nfrom sklearn import metrics\n\nfrom unidecode import unidecode\nfrom nltk.corpus import stopwords\nfrom nltk.stem import PorterStemmer, WordNetLemmatizer\nimport string\n\nfrom keras import initializers, regularizers, constraints, optimizers, layers, callbacks\nfrom keras.preprocessing.text import Tokenizer, text_to_word_sequence\nfrom keras.preprocessing.sequence import pad_sequences\nfrom keras.layers import Bidirectional, GlobalMaxPool1D, Input, Embedding, Dropout, Dense, CuDNNLSTM, BatchNormalization,SpatialDropout1D \nfrom keras.models import Model, Sequential\nfrom keras.callbacks import ModelCheckpoint, Callback, EarlyStopping\n\nimport zipfile\nfrom gensim.models.keyedvectors import KeyedVectors","metadata":{"_uuid":"8f2839f25d086af736a60e9eeb907d3b93b6e0e5","_cell_guid":"b1076dfc-b9ad-4769-8c92-a6c4dae69d19","_kg_hide-input":false,"execution":{"iopub.status.busy":"2022-01-09T01:52:41.646130Z","iopub.execute_input":"2022-01-09T01:52:41.646566Z","iopub.status.idle":"2022-01-09T01:52:47.587555Z","shell.execute_reply.started":"2022-01-09T01:52:41.646442Z","shell.execute_reply":"2022-01-09T01:52:47.586831Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"Một câu hỏi cho là *insincere* khi có các yếu tố:  \n* Tông giọng khác biệt: \n * Phóng đại, khoa trương về một góc nhìn hay phát biểu hướng tới một nhóm người nhất định  \n* Có tính miệt thị hay kích động:  \n * Phân biệt đối xử hay miệt thị với một nhóm người một cá nhân hoặc một đám người  \n * Miệt thị một tính cách hay tính chất khác thường  \n* Không đúng sự thật: thông tin sai / giả định vô lý  \n* Chứa quan hệ tình dục để gây sốc  \n\n## 2.1. Các tập dữ liệu","metadata":{}},{"cell_type":"code","source":"# Load dữ liệu từ file csv\ntrain_df = pd.read_csv(\"/kaggle/input/quora-insincere-questions-classification/train.csv\")\ntest_df = pd.read_csv(\"/kaggle/input/quora-insincere-questions-classification/test.csv\")","metadata":{"execution":{"iopub.status.busy":"2022-01-09T01:52:47.589214Z","iopub.execute_input":"2022-01-09T01:52:47.589480Z","iopub.status.idle":"2022-01-09T01:52:53.102784Z","shell.execute_reply.started":"2022-01-09T01:52:47.589445Z","shell.execute_reply":"2022-01-09T01:52:53.100714Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"Dứ liệu đầu vào gồm 2 tệp `train.csv` và `test.csv`.  \n\n* Tệp `train`: Gồm 1306122 dòng và 3 cột (`qid`, `question_text`, `target`)","metadata":{}},{"cell_type":"code","source":"print(\"Kích thước bảng file 'train':\", train_df.shape)\nprint(\"Mẫu dữ liệu file 'train':\")\ntrain_df.head()","metadata":{"execution":{"iopub.status.busy":"2022-01-09T01:52:53.107633Z","iopub.execute_input":"2022-01-09T01:52:53.109791Z","iopub.status.idle":"2022-01-09T01:52:53.144171Z","shell.execute_reply.started":"2022-01-09T01:52:53.109750Z","shell.execute_reply":"2022-01-09T01:52:53.143530Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"* Tệp `test`: Gồm 375806 dòng và 2 cột (`qid`, `question_text`)","metadata":{}},{"cell_type":"code","source":"print(\"Kích thước bảng file 'test':\", test_df.shape)\nprint(\"Mẫu dữ liệu file 'test':\")\ntest_df.head()","metadata":{"execution":{"iopub.status.busy":"2022-01-09T01:52:53.146877Z","iopub.execute_input":"2022-01-09T01:52:53.149867Z","iopub.status.idle":"2022-01-09T01:52:53.168593Z","shell.execute_reply.started":"2022-01-09T01:52:53.149825Z","shell.execute_reply":"2022-01-09T01:52:53.167976Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"Ngoài ra còn chứa tệp nén `embeddings.zip` chứa danh sách các từ đã vector hóa có thể được dùng trong model  ","metadata":{}},{"cell_type":"markdown","source":"## 2.2. Phân tích dữ liệu\n\nCó 3 trường cần phải xử lý:  \n* **Trường `qid`**: là ID đặc trưng cho từng câu hỏi, không tồn tại 2 câu hỏi nào trùng ID.  \n* **Trường `question_text`**: là các câu hỏi bằng tiếng Anh, cần được xử lý trước khi đưa vào model.  \n* **Trường `target`**: là label kết quả được đánh giá, 0/1 tương ứng với *sincere/insincere*.\n\n#### **Kiểm tra phân bố tập dữ liệu theo `target`:** ","metadata":{}},{"cell_type":"code","source":"# Lấy số câu hỏi, số câu sincere/insincere\nsincere_qt = train_df[train_df.target == 0]\ninsincere_qt = train_df[train_df.target == 1]\n\nprint(\"Số câu hỏi: \", train_df.shape[0])\nprint(\"Sincere: \", sincere_qt.shape[0])\nprint(\"Insincere: \", insincere_qt.shape[0])\n\n# Biểu diễn qua đồ thị hình tròn\nlabel = 'Sincere', 'Insincere'\nsize = [(sincere_qt.shape[0] / train_df.shape[0]) * 100, (insincere_qt.shape[0] / train_df.shape[0]) * 100]\nplt.pie(size, labels = label, colors=[\"c\", \"y\"], autopct=\"%.2f%%\")\nplt.show()\n","metadata":{"execution":{"iopub.status.busy":"2022-01-09T01:52:53.173042Z","iopub.execute_input":"2022-01-09T01:52:53.173321Z","iopub.status.idle":"2022-01-09T01:52:53.426829Z","shell.execute_reply.started":"2022-01-09T01:52:53.173287Z","shell.execute_reply":"2022-01-09T01:52:53.425955Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"Phân bố trong tập `train` cho thấy tỉ lệ thấp câu hỏi được đánh nhãn *insincere* hay tập dữ liệu rất mất cân bằng, dẫn đến những vấn đề như mô hình hoạt động kếm hiệu quả với những trường hợp `target` = 1, hay metric accuracy không thể hiện rõ chất lượng mô hình.\n\n=> Cần sử dụng metric thay thế như *F1_score* ","metadata":{}},{"cell_type":"markdown","source":"#### **Kiểm tra các từ trong `question_text`**: ","metadata":{}},{"cell_type":"code","source":"# Kiểm tra tệp train\nprint('Số từ trung bình mỗi câu hỏi: {0:.0f}.'.format(np.mean(train_df['question_text'].apply(lambda x: len(x.split())))))\nprint('Số từ tối đa trong câu hỏi: {0:.0f}.'.format(np.max(train_df['question_text'].apply(lambda x: len(x.split())))))\nprint('Số ký tự trung bình mỗi câu hỏi: {0:.0f}.'.format(np.mean(train_df['question_text'].apply(lambda x: len(x)))))\n\n# Phân bố độ dài `question_text` theo số từ\nplt.figure(figsize=(16,5))\nplt.hist(train_df['question_text'].apply(lambda x: len(x.split())), bins=60)\nplt.yscale('log')\nplt.xlabel('Số từ/câu')\nplt.title('Phân bố độ dài `question_text` theo số từ')\nplt.xticks(range(0,140,5))\nplt.show()","metadata":{"execution":{"iopub.status.busy":"2022-01-09T01:52:53.428514Z","iopub.execute_input":"2022-01-09T01:52:53.428815Z","iopub.status.idle":"2022-01-09T01:52:59.911373Z","shell.execute_reply.started":"2022-01-09T01:52:53.428775Z","shell.execute_reply":"2022-01-09T01:52:59.910638Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"* Các câu hỏi trong tệp `train` có độ dài trung bình không quá lớn, phần lớn dưới 70 từ, nhưng cũng có một số câu khá dài. \n\n* Tần xuất các từ trong tệp `train` tương ứng với `target`:  \n * Cần loại bỏ đi các từ lặp lại nhiều nhưng ít tác động đến đánh giá *sincere/insincere* (gọi là stop-word, được thêm vào bằng bộ công cụ ngôn ngữ tự nhiên NLTK), gây cản trở và làm giảm tốc độ xử lý. ","metadata":{}},{"cell_type":"code","source":"from collections import defaultdict\n\n# Thiết lập stop-words\nstop_words = set(stopwords.words('english'))\n\n# Tạo dictionary để đếm từ\nsin_freq_dict = defaultdict(int)\nins_freq_dict = defaultdict(int)\n\n# Hàm tách câu thành từ, loại bỏ stop-words \ndef tokens(text):\n    tokens = [token for token in text.lower().split(\" \") if token != \"\" if token not in stop_words]\n    return tokens\n\n# Đếm từ\nfor qt in sincere_qt[\"question_text\"]:\n    for word in tokens(qt):\n        sin_freq_dict[word] += 1\nsfd_sorted = pd.DataFrame(sorted(sin_freq_dict.items(), key=lambda x: x[1], reverse=True)[::-1])\nsfd_sorted.columns = [\"word\", \"frequency\"]\n\nfor qt in insincere_qt[\"question_text\"]:\n    for word in tokens(qt):\n        ins_freq_dict[word] += 1\nifd_sorted = pd.DataFrame(sorted(ins_freq_dict.items(), key=lambda x: x[1], reverse=True)[::-1])\nifd_sorted.columns = [\"word\", \"frequency\"]\n\n# Biểu diễn bằng đồ thị\nfig, (ax1, ax2) = plt.subplots(1, 2, figsize=(16,8))\n\nsfd_sorted.tail(20).plot(x= 'word', kind = \"barh\", title=\"Top 20 từ trong câu hỏi label 'sincere'\", ax=ax1)\nifd_sorted.tail(20).plot(x= 'word', kind = \"barh\", title=\"Top 20 từ trong câu hỏi label 'insincere'\", ax=ax2)","metadata":{"execution":{"iopub.status.busy":"2022-01-09T01:52:59.912841Z","iopub.execute_input":"2022-01-09T01:52:59.913867Z","iopub.status.idle":"2022-01-09T01:53:08.590179Z","shell.execute_reply.started":"2022-01-09T01:52:59.913823Z","shell.execute_reply":"2022-01-09T01:53:08.589465Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"* Các từ trong các câu có nhãn `sincere` thường là các từ chung chung và thông dụng, trong khi đó các từ trong câu có nhãn `insincere` thường có xu hướng nhắm vào các đối tượng, lĩnh vực riêng như chủng tộc, tôn giáo hay giới tính","metadata":{}},{"cell_type":"markdown","source":"## 2.3. Tối ưu dữ liệu\n\n**Các bước tiền xử lý dữ liệu `question_text` bao gồm:**\n* Chuyển về unicode và chữ thường để loại bỏ các ký tự đặc biệt\n* Loại bỏ các ký tự (punctuation), chữ số do không nhiều tác dụng trong việc huấn luyện model\n* Tách rời từng câu thành các mảng chứa từ (tokens)\n* Rút gọn từ loại (đưa các từ cùng dạng về thành 1 từ, như các động từ từ các dạng về nguyên thể, hay các từ cùng ngữ pháp sẽ đưa về từ loại gốc - [Stemming / Lemmatization](https://nlp.stanford.edu/IR-book/html/htmledition/stemming-and-lemmatization-1.html))\n* Loại bỏ stop-words (các từ lặp lại nhiều nhưng ít tác động đến đánh giá, gây cản trở và làm giảm tốc độ xử lý)  \n##### => Thu gọn dữ liệu `question_text` trở thành các chuỗi gồm các từ khóa mang gần như toàn bộ ý nghĩa của câu   ","metadata":{}},{"cell_type":"code","source":"# Tách file `train` thành 2 phần `train` và `validate` để huấn luyện\ntrain_df, val_df = train_test_split(train_df, test_size=0.25, random_state=40)\n\n# Tách đầu vào 'question_text' từ file 'train'\ntrain_X = train_df[\"question_text\"]\nval_X = val_df[\"question_text\"]\ntest_X = test_df[\"question_text\"]\n\n# Tách đầu ra 'target' từ file 'train'\ntrain_y = train_df['target'].values\nval_y = val_df['target'].values\n\n# Load model rút gọn từ loại\nlemmatizer = WordNetLemmatizer();\n\n# Hàm xử lý các chuỗi 'question text' thành các mảng chứa từ \ndef clean_qt(question_text):\n    q_text = str(unidecode(question_text.lower()).encode(\"ascii\"),\"ascii\")           # Chuyển về unicode và chữ thường\n    q_text = q_text.translate(str.maketrans('', '', string.punctuation + string.digits)) # Loại bỏ ký tự và chữ số\n    q_tokens = text_to_word_sequence(q_text)                                         # Tách từng câu thành mảng chứa từ\n    q_tokens_simplify = [lemmatizer.lemmatize(token) for token in q_tokens]          # Rút gọn từ loại\n    q_tokens_min = [token for token in q_tokens_simplify if token not in stop_words] # Loại bỏ stop-word\n    return q_tokens_min\n    \ntrain_X = train_X.apply(clean_qt)\nval_X = val_X.apply(clean_qt)\ntest_X = test_X.apply(clean_qt)","metadata":{"execution":{"iopub.status.busy":"2022-01-09T01:53:08.591616Z","iopub.execute_input":"2022-01-09T01:53:08.592090Z","iopub.status.idle":"2022-01-09T01:55:18.666469Z","shell.execute_reply.started":"2022-01-09T01:53:08.592036Z","shell.execute_reply":"2022-01-09T01:55:18.665741Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"# Test kết quả\nprint(train_df[\"question_text\"].head(5), \"\\n\", train_X[0:5])","metadata":{"execution":{"iopub.status.busy":"2022-01-09T01:55:18.667861Z","iopub.execute_input":"2022-01-09T01:55:18.668117Z","iopub.status.idle":"2022-01-09T01:55:18.675793Z","shell.execute_reply.started":"2022-01-09T01:55:18.668083Z","shell.execute_reply":"2022-01-09T01:55:18.674931Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"## 2.4. Biến đổi dữ liệu huấn luyện  \n\nĐể việc huấn luyện đạt hiệu quả, ta cần phải đưa dữ liệu từ các từ khóa thành dạng mà máy tính có thể hiểu.  \nCác quá trình biến đổi dữ liệu báo gồm:\n  * **Mã hóa từ**: gồm việc thay thế từ bằng một ID là số tự nhiên và ghi lại từ điển đối chiếu giữa từ và ID, mảng từ sẽ thay bằng chuỗi số. Việc này có tác dụng thống kê số từ đặc trưng (có bao nhiêu từ, từ nào xuất hiện nhiều, ...) và giảm bộ nhớ khi các từ xuất hiện nhiều thì sẽ biểu diễn bởi số nhỏ\n  * **Cân bằng chuỗi**: là việc kéo dài chuỗi lên độ dài MAX_LEN là 70 với những chuỗi ngắn hơn và bổ sung vào chuỗi là những ID 0, hoặc cắt ngắn chuỗi dài hơn về 70 (Do như thống kê phía trên, đa phần độ dài câu khi chưa tối ưu thường dài dưới 70 từ). Cân bằng chuỗi giúp huấn luyện tốt hơn do độ dài input là như nhau\n","metadata":{}},{"cell_type":"code","source":"# Thiết lập các hắng số\nEMBED_SIZE = 300 # Kích thước hay số chiều của vector từ\nMAX_FEATURES  = 100000 # Số lượng từ đặc trưng tối đa, hay số lượng vector tôi đa \nMAX_LEN = 70 # Số lượng từ tối đa trong một câu\n\n# Lập từ điển mã hóa từ thành các ID\ntokenizer = Tokenizer(filters='', num_words=MAX_FEATURES)\ntokenizer.fit_on_texts(train_X)\n\n# Chuyển các chuỗi từ thành chuỗi ID\ntrain_X = tokenizer.texts_to_sequences(train_X)\nval_X = tokenizer.texts_to_sequences(val_X)\ntest_X = tokenizer.texts_to_sequences(test_X)\n\n# Cân bằng đọ dài chuỗi bằng với MAX_LEN  \ntrain_X = pad_sequences(train_X, maxlen=MAX_LEN)\nval_X = pad_sequences(val_X, maxlen=MAX_LEN)\ntest_X = pad_sequences(test_X, maxlen=MAX_LEN)","metadata":{"execution":{"iopub.status.busy":"2022-01-09T01:55:18.677224Z","iopub.execute_input":"2022-01-09T01:55:18.677685Z","iopub.status.idle":"2022-01-09T01:55:45.586748Z","shell.execute_reply.started":"2022-01-09T01:55:18.677644Z","shell.execute_reply":"2022-01-09T01:55:45.586000Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"   * **Vector hóa từ**: là việc thay thể từ bằng một vector số thực nhiều chiều, nói cách khác là mã hóa biểu diễn từ lên không gian đa chiều, với mục đích giúp máy tính hiểu được ý nghĩa của từ theo cách các từ đồng nghĩa, gần nghĩa sẽ có biểu diễn vector gần giống nhau. Đông thời việc sử dụng các model pretrained giúp tăng độ chuẩn xác cũng như giảm thời gian xử lý.  \n  \nỞ đây ta dùng pretrained weights cung cấp bởi Google ([Word2Vec](https://code.google.com/archive/p/word2vec)) và Stanford NLP ([GloVe](https://nlp.stanford.edu/projects/glove/)), kết hợp từ điển word - ID tạo ở phía trên có thể tạo ra ma trận liên hệ giữa ID - vector, đưa vào model","metadata":{}},{"cell_type":"code","source":"# Load pre-trained weights từ tệp nén chứa các từ và vector tương ứng  \narchive = zipfile.ZipFile('../input/quora-insincere-questions-classification/embeddings.zip', 'r')\n\n# Hàm chuyển weights pretrained cho vector từ thành weights cho model \ndef loadEmbeddingMatrix(typeToLoad): # typetoLoad = 'glove' | 'word2vec' \n    # GloVe\n    embeddings_index = dict()\n    if (typeToLoad == \"glove\"):\n        # Load file\n        EMB_FILE =  archive.open('glove.840B.300d/glove.840B.300d.txt')\n        # Chuyển weights thành từ điển qua việc đọc từng dòng trong file\n        for embd in EMB_FILE:\n            # Ngắt dòng thành mảng\n            word2vec = embd.decode().split(' ')\n            # Vị trí đầu tiên trong mảng là từ\n            word = word2vec[0]\n            # Tạo mảng chứa các vị trí còn lại thành vector tương ứng với từ\n            embeddings_index[word] = np.asarray(word2vec[1:EMBED_SIZE+1], dtype='float32')\n        EMB_FILE.close()\n        gc.collect()\n        print('GloVe - Loaded %s vector từ.' % len(embeddings_index))\n        \n    # Google Word2vec \n    elif (typeToLoad == \"word2vec\"):\n        # Load file \n        EMB_FILE =  archive.open('GoogleNews-vectors-negative300/GoogleNews-vectors-negative300.bin')\n        # Chuyển thành từ điển bằng module được implement sẵn  \n        emb_google_word2vec = KeyedVectors.load_word2vec_format(EMB_FILE, binary=True, limit=1000000)\n        for word in emb_google_word2vec.index_to_key:\n                embeddings_index[word] = emb_google_word2vec.get_vector(word)\n        EMB_FILE.close()\n        gc.collect()\n        print('Word2Vec - Loaded %s vector từ.' % len(embeddings_index))\n    \n    # Tạo ma trận kích thước (số từ x kích thước vector) hay (MAX_FEATURES x EMBED_SIZE)\n    all_embs = np.stack(list(embeddings_index.values()))\n    emb_mean,emb_std = all_embs.mean(), all_embs.std()\n    nb_words = min(MAX_FEATURES, len(tokenizer.word_index))\n    embedding_matrix = np.random.normal(emb_mean, emb_std, (nb_words, EMBED_SIZE))\n    \n    # Nhập từng vector tương ứng với word ID\n    embeddedCount = 0\n    for word, i in tokenizer.word_index.items():\n        if i >= MAX_FEATURES: continue\n        # Load vector \n        embedding_vector = embeddings_index.get(word)\n        # Lưu vào ma trận\n        if embedding_vector is not None: \n            embedding_matrix[i] = embedding_vector\n            embeddedCount+=1\n    print('Nhập vào %d vector' % embeddedCount)\n    \n    del(embeddings_index)\n    gc.collect()\n    \n    return embedding_matrix\n\nemb_glove_matrix = loadEmbeddingMatrix(\"glove\")\nemb_google_matrix = loadEmbeddingMatrix(\"word2vec\")\n# Gộp 2 ma trận để tăng hiệu quả\nembd_total_matrix = np.mean([emb_glove_matrix, emb_google_matrix], axis = 0)","metadata":{"execution":{"iopub.status.busy":"2022-01-09T01:55:45.588175Z","iopub.execute_input":"2022-01-09T01:55:45.588437Z","iopub.status.idle":"2022-01-09T02:03:09.871245Z","shell.execute_reply.started":"2022-01-09T01:55:45.588404Z","shell.execute_reply":"2022-01-09T02:03:09.870377Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"# **3. Huấn luyện**\n\n## 3.1. Kiến trúc của mô hình\n\n  Mô hình mạng **RNN** (Recurrent Neural Network) được sử dụng nhiều ở các bài toán xử lý ngôn ngữ, do việc xử lý thông tin dưới dạng chuỗi hiệu quả vì ngoài đầu vào thông thường của một mạng neural, trạng thái ẩn bước trước cũng được thêm vào thành đầu vào bước sau. Trong bài này sẽ sử dụng mô hình phát triển dựa trên RNN là mạng **LTSM 2 chiều** (Bi-directional LSTM).  \n![image.png](attachment:20ea8955-fff7-47dc-9dfb-035038729aca.png)\n  Mạng LTSM sinh ra để khắc phục việc mạng RNN không học được từ chuỗi quá dài do triệt tiêu đạo hàm bằng cách thêm một biến trạng thái ô cùng với trạng thái ẩn làm đầu vào bước sau, những thông tin cần lưu trữ sẽ được cập nhật qua trạng thái ô. Khi dùng mạng LTSM 2 chiều, thông tin lưu trữ được không chỉ ở các bước quá khứ mà còn có cả các bước tương lai, làm tăng tính hiệu quả vì dự đoán cần cả ngữ cảnh phía trước và sau.  \n  \n  Cấu trúc mạng bao gồm:\n* Lớp Embedding là bộ pre-trained embedding được tính toán phía trên. Đầu ra có sử dụng Dropout để tránh overfit.  \n* Lớp LSTM với 2 tầng và mỗi tầng 128 units.   \n* Mạng MLP với hàm kích hoạt là ReLU, có sử dụng Batchnorm và Dropout, cuối cùng là 1 lớp hàm sigmoid.  ","metadata":{},"attachments":{"20ea8955-fff7-47dc-9dfb-035038729aca.png":{"image/png":"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"}}},{"cell_type":"code","source":"model = Sequential()\n\nmodel.add(Input(shape=(MAX_LEN,)))\n# Lớp Embedding\nmodel.add(Embedding(MAX_FEATURES, EMBED_SIZE, weights=[embd_total_matrix]))\nmodel.add(SpatialDropout1D(0.5)) \n\n# Lớp Bi-directional LTSM\nmodel.add(Bidirectional(CuDNNLSTM(128, return_sequences=True)))\nmodel.add(GlobalMaxPool1D())\n\n# Mạng MLP\nmodel.add(Dense(16, activation=\"relu\"))\nmodel.add(Dropout(0.1))\nmodel.add(BatchNormalization())\nmodel.add(Dense(1, activation=\"sigmoid\"))\n\n# Model hoàn chỉnh\nmodel.compile(loss = 'binary_crossentropy', \n              optimizer = 'adam', \n              metrics = ['accuracy'])\nprint(model.summary())","metadata":{"execution":{"iopub.status.busy":"2022-01-09T02:03:09.872530Z","iopub.execute_input":"2022-01-09T02:03:09.872826Z","iopub.status.idle":"2022-01-09T02:03:12.172644Z","shell.execute_reply.started":"2022-01-09T02:03:09.872791Z","shell.execute_reply":"2022-01-09T02:03:12.171911Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"## 3.2. Huấn luyện và đánh giá\nHuấn luyện với hàm loss là **binary cross entropy**, hàm tối ưu là **Adam**.","metadata":{}},{"cell_type":"code","source":"# Thực hiện train\n# Tạo chekpoint\nfile_path = \"model_b128_val0.2_e10.hdf5\"\ncheck_point = ModelCheckpoint(file_path, monitor = \"val_loss\", verbose = 1, save_best_only = False, mode = \"min\")\n\n# Huấn luyện và ghi lại thống kê\nhistory = model.fit(train_X, train_y, batch_size=128, epochs=10, validation_data=(val_X, val_y)) #, callbacks=[check_point])","metadata":{"execution":{"iopub.status.busy":"2022-01-09T02:03:12.173961Z","iopub.execute_input":"2022-01-09T02:03:12.174217Z","iopub.status.idle":"2022-01-09T02:36:35.812231Z","shell.execute_reply.started":"2022-01-09T02:03:12.174189Z","shell.execute_reply":"2022-01-09T02:36:35.811428Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"#### Model loss qua mỗi epoch:","metadata":{}},{"cell_type":"code","source":"# Đồ thì model loss\nepochRange = np.arange(1,11,1)\nplt.plot(epochRange, history.history['loss'])\nplt.plot(epochRange, history.history['val_loss'])\nplt.xticks(np.arange(1,11,1))\nplt.yticks(np.arange(0,0.5,0.05))\nplt.title('Model loss')\nplt.ylabel('loss')\nplt.xlabel('epoch')\nplt.legend(['Training', 'Validation'], loc='upper left')\nplt.show()","metadata":{"execution":{"iopub.status.busy":"2022-01-09T02:36:35.815361Z","iopub.execute_input":"2022-01-09T02:36:35.816316Z","iopub.status.idle":"2022-01-09T02:36:35.964427Z","shell.execute_reply.started":"2022-01-09T02:36:35.816272Z","shell.execute_reply":"2022-01-09T02:36:35.963766Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"#### Đánh giá F1_score\n\nBình thường ở các mô hình phân lớp nhị phân kết quả dự đoán luôn thuộc đoạn (0,1) với ngưỡng (threshold) là 0.5, tức là nếu kết quả dưới ngưỡng 0.5 thì phân lớp là 0, ngược lại thì là 1.\n\nNhưng trong một số trường hợp, giá trị ngưỡng 0.5 này có thể không phải là tốt nhất. Trong bài toán này cần chọn threshold sao cho F1_score là cao nhất, làm tăng tỉ lệ dự đoán ","metadata":{}},{"cell_type":"code","source":"pred_train_y = model.predict([train_X], batch_size=128, verbose=1)\nthreshs = np.arange(0.1, 0.5, 0.01, dtype=float)\nf1 = np.zeros_like(threshs, dtype=float)\ni = 0\nfor thresh in threshs:\n    f1[i]=(metrics.f1_score(train_y, (pred_train_y>thresh).astype(int)))\n    i+=1\nplt.plot(threshs, f1)","metadata":{"execution":{"iopub.status.busy":"2022-01-09T02:57:58.606274Z","iopub.execute_input":"2022-01-09T02:57:58.606957Z","iopub.status.idle":"2022-01-09T02:58:48.587013Z","shell.execute_reply.started":"2022-01-09T02:57:58.606914Z","shell.execute_reply":"2022-01-09T02:58:48.586391Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"f1_max = np.amax(f1)\nindex = np.where(f1==f1_max)\nthresh_f1_max = threshs[index]\n\nprint('F1-score tối đa là %.2f tại ngưỡng %.2f' % (f1_max, thresh_f1_max))","metadata":{"execution":{"iopub.status.busy":"2022-01-09T02:58:59.480517Z","iopub.execute_input":"2022-01-09T02:58:59.480792Z","iopub.status.idle":"2022-01-09T02:58:59.486044Z","shell.execute_reply.started":"2022-01-09T02:58:59.480760Z","shell.execute_reply":"2022-01-09T02:58:59.485140Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"## 4. Áp dụng ","metadata":{}},{"cell_type":"code","source":"pred_test_y = model.predict([test_X], batch_size=256, verbose=1)\npred_test_y = np.where(pred_test_y>thresh_f1_max,1,0)                                \nout_df = pd.DataFrame({\"qid\":test_df[\"qid\"].values})\nout_df['prediction'] = pred_test_y\nout_df.to_csv(\"submission.csv\", index=False)","metadata":{"execution":{"iopub.status.busy":"2022-01-09T02:37:17.591176Z","iopub.status.idle":"2022-01-09T02:37:17.591898Z","shell.execute_reply.started":"2022-01-09T02:37:17.591603Z","shell.execute_reply":"2022-01-09T02:37:17.591630Z"},"trusted":true},"execution_count":null,"outputs":[]}]}