{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 162,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "import numpy as np\n",
    "import re\n",
    "import string\n",
    "import nltk\n",
    "from nltk.corpus import stopwords\n",
    "from nltk.tokenize import word_tokenize\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "from tensorflow.keras.preprocessing.text import Tokenizer\n",
    "from tensorflow.keras.preprocessing.sequence import pad_sequences\n",
    "from tensorflow.keras.models import Model\n",
    "from tensorflow.keras.layers import Input, Embedding, LSTM, Dense\n",
    "\n",
    "from Sastrawi.Stemmer.StemmerFactory import StemmerFactory\n",
    "from sklearn.model_selection import train_test_split\n",
    "import pickle\n",
    "\n",
    "from sklearn.metrics import classification_report, accuracy_score, precision_score, recall_score\n",
    "import nltk"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 163,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "[nltk_data] Downloading package stopwords to /home/akeon/nltk_data...\n",
      "[nltk_data]   Package stopwords is already up-to-date!\n",
      "[nltk_data] Downloading package punkt to /home/akeon/nltk_data...\n",
      "[nltk_data]   Package punkt is already up-to-date!\n",
      "[nltk_data] Downloading package punkt_tab to /home/akeon/nltk_data...\n",
      "[nltk_data]   Package punkt_tab is already up-to-date!\n",
      "[nltk_data] Downloading package wordnet to /home/akeon/nltk_data...\n",
      "[nltk_data]   Package wordnet is already up-to-date!\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 163,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# download assets\n",
    "nltk.download(\"stopwords\")\n",
    "nltk.download(\"punkt\")\n",
    "nltk.download(\"punkt_tab\")\n",
    "nltk.download(\"wordnet\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 164,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Total Context: 54\n",
      "Total Possibility Questions: 97\n",
      "Total Fill in the Blank Questions: 24\n",
      "Total Multiple Choice Questions: 29\n",
      "Total True/False Questions: 44\n"
     ]
    }
   ],
   "source": [
    "import json\n",
    "from collections import defaultdict\n",
    "\n",
    "# path dataset\n",
    "file_path = \"dataset/training_dataset.json\"\n",
    "\n",
    "with open(file_path, \"r\", encoding=\"utf-8\") as file:\n",
    "    dataset = json.load(file)\n",
    "\n",
    "total_context = len(dataset)\n",
    "\n",
    "total_question_posibility = sum(len(entry[\"question_posibility\"]) for entry in dataset)\n",
    "\n",
    "question_type_counts = defaultdict(int)\n",
    "for entry in dataset:\n",
    "    for question in entry[\"question_posibility\"]:\n",
    "        question_type_counts[question[\"type\"]] += 1\n",
    "\n",
    "print(f\"Total Context: {total_context}\")\n",
    "print(f\"Total Possibility Questions: {total_question_posibility}\")\n",
    "print(f\"Total Fill in the Blank Questions: {question_type_counts.get('fill_in_the_blank', 0)}\")\n",
    "print(f\"Total Multiple Choice Questions: {question_type_counts.get('multiple_choice', 0)}\")\n",
    "print(f\"Total True/False Questions: {question_type_counts.get('true_false', 0)}\")\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Data processing complete!\n",
      "Samples: 97\n"
     ]
    }
   ],
   "source": [
    "# Text Preprocessing\n",
    "stop_words = set(stopwords.words(\"indonesian\"))                                                                                                                                                                                                                                                                             \n",
    "factory = StemmerFactory()\n",
    "stemmer = factory.create_stemmer()\n",
    "\n",
    "with open(\"normalize_text/normalize.json\", \"r\", encoding=\"utf-8\") as file:\n",
    "    normalization_dict = json.load(file)\n",
    "\n",
    "\n",
    "def text_preprocessing(text):\n",
    "    #doing lower case \n",
    "    text = text.lower()\n",
    "    \n",
    "    # remove symbol and read mark\n",
    "    text = text.translate(str.maketrans(\"\", \"\", string.punctuation))\n",
    "    \n",
    "    # remove blank space\n",
    "    text = re.sub(r\"\\s+\", \" \", text).strip()\n",
    "    \n",
    "    # word tokenize \n",
    "    tokens = word_tokenize(text)\n",
    "    \n",
    "    \n",
    "    # normalassi kata\n",
    "    tokens = [normalization_dict[word] if word in normalization_dict else word for word in tokens] \n",
    "    \n",
    "    \n",
    "    # Lemmatization using Sastrawi (stemming in Indonesian)\n",
    "    tokens = [stemmer.stem(word) for word in tokens]\n",
    "    \n",
    "    # stopword removal\n",
    "    tokens = [word for word in tokens if word not in stop_words]  \n",
    "    \n",
    "    return tokens\n",
    "\n",
    "# text processing all data training\n",
    "contexts = []\n",
    "questions = []\n",
    "correct_answers = []\n",
    "wrong_answers = []\n",
    "question_types = []\n",
    "\n",
    "for entry in dataset:\n",
    "    processed_context = text_preprocessing(entry[\"context\"])\n",
    "    \n",
    "    for qa in entry[\"question_posibility\"]:\n",
    "        processed_question = text_preprocessing(qa[\"question\"])\n",
    "        processed_answer = text_preprocessing(qa[\"answer\"])\n",
    "    \n",
    "        contexts.append(processed_context)\n",
    "        questions.append(processed_question)\n",
    "        correct_answers.append(processed_answer)\n",
    "        question_types.append(qa[\"type\"])\n",
    "\n",
    "        if qa[\"type\"] == \"multiple_choice\":\n",
    "            incorrect_options = [opt for opt in qa[\"options\"] if opt != qa[\"answer\"]]\n",
    "            wrong_answers.append(incorrect_options)\n",
    "        else:\n",
    "            wrong_answers.append([])\n",
    "\n",
    "tokenizer = Tokenizer(oov_token=\"<OOV>\")\n",
    "tokenizer.fit_on_texts(contexts + questions + correct_answers)\n",
    "\n",
    "context_sequences = tokenizer.texts_to_sequences(contexts)\n",
    "question_sequences = tokenizer.texts_to_sequences(questions)\n",
    "answer_sequences = tokenizer.texts_to_sequences(correct_answers)\n",
    "\n",
    "MAX_LENGTH = 100\n",
    "context_padded = pad_sequences(context_sequences, maxlen=MAX_LENGTH, padding=\"post\", truncating=\"post\")\n",
    "question_padded = pad_sequences(question_sequences, maxlen=MAX_LENGTH, padding=\"post\", truncating=\"post\")\n",
    "answer_padded = pad_sequences(answer_sequences, maxlen=MAX_LENGTH, padding=\"post\", truncating=\"post\")\n",
    "\n",
    "question_type_dict = {\"fill_in_the_blank\": 0, \"true_false\": 1, \"multiple_choice\": 2}\n",
    "question_type_labels = np.array([question_type_dict[q_type] for q_type in question_types])\n",
    "\n",
    "print(\"Data processing complete!\")\n",
    "print(\"Samples:\", context_padded.shape[0])  \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 166,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Training samples: 77\n",
      "Testing samples: 10\n",
      "Validation samples: 10\n"
     ]
    }
   ],
   "source": [
    "# split text for testing 8:2\n",
    "context_train, context_temp, question_train, question_temp, answer_train, answer_temp, qtype_train, qtype_temp = train_test_split(\n",
    "    context_padded, question_padded, answer_padded, question_type_labels, test_size=0.2, random_state=42\n",
    ")\n",
    "\n",
    "# split dataset testing and validation 5:5\n",
    "context_test, context_val, question_test, question_val, answer_test, answer_val, qtype_test, qtype_val = train_test_split(\n",
    "    context_temp, question_temp, answer_temp, qtype_temp, test_size=0.5, random_state=42\n",
    ")\n",
    "\n",
    "print(\"Training samples:\", context_train.shape[0])\n",
    "print(\"Testing samples:\", context_test.shape[0])\n",
    "print(\"Validation samples:\", context_val.shape[0])\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 167,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 1/20\n",
      "\u001b[1m2/2\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m4s\u001b[0m 752ms/step - answer_output_accuracy: 0.0239 - answer_output_loss: 6.2109 - loss: 13.5254 - question_output_accuracy: 4.3716e-04 - question_output_loss: 6.2153 - question_type_output_accuracy: 0.3332 - question_type_output_loss: 1.0988 - val_answer_output_accuracy: 0.1931 - val_answer_output_loss: 6.1791 - val_loss: 13.4936 - val_question_output_accuracy: 0.0056 - val_question_output_loss: 6.2104 - val_question_type_output_accuracy: 0.3125 - val_question_type_output_loss: 1.1042\n",
      "Epoch 2/20\n",
      "\u001b[1m2/2\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 329ms/step - answer_output_accuracy: 0.1947 - answer_output_loss: 6.1534 - loss: 13.4319 - question_output_accuracy: 0.0122 - question_output_loss: 6.1985 - question_type_output_accuracy: 0.6445 - question_type_output_loss: 1.0791 - val_answer_output_accuracy: 0.9856 - val_answer_output_loss: 6.0885 - val_loss: 13.4025 - val_question_output_accuracy: 0.0112 - val_question_output_loss: 6.2026 - val_question_type_output_accuracy: 0.3125 - val_question_type_output_loss: 1.1115\n",
      "Epoch 3/20\n",
      "\u001b[1m2/2\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 316ms/step - answer_output_accuracy: 0.9831 - answer_output_loss: 6.0118 - loss: 13.2454 - question_output_accuracy: 0.0183 - question_output_loss: 6.1792 - question_type_output_accuracy: 0.6341 - question_type_output_loss: 1.0521 - val_answer_output_accuracy: 0.9856 - val_answer_output_loss: 5.7557 - val_loss: 13.0783 - val_question_output_accuracy: 0.0106 - val_question_output_loss: 6.1923 - val_question_type_output_accuracy: 0.3125 - val_question_type_output_loss: 1.1303\n",
      "Epoch 4/20\n",
      "\u001b[1m2/2\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 318ms/step - answer_output_accuracy: 0.9831 - answer_output_loss: 5.4126 - loss: 12.5932 - question_output_accuracy: 0.0159 - question_output_loss: 6.1526 - question_type_output_accuracy: 0.6132 - question_type_output_loss: 1.0133 - val_answer_output_accuracy: 0.9856 - val_answer_output_loss: 4.0785 - val_loss: 11.4385 - val_question_output_accuracy: 0.0087 - val_question_output_loss: 6.1729 - val_question_type_output_accuracy: 0.4375 - val_question_type_output_loss: 1.1871\n",
      "Epoch 5/20\n",
      "\u001b[1m2/2\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 321ms/step - answer_output_accuracy: 0.9833 - answer_output_loss: 3.5350 - loss: 10.6302 - question_output_accuracy: 0.0109 - question_output_loss: 6.0941 - question_type_output_accuracy: 0.5482 - question_type_output_loss: 0.9777 - val_answer_output_accuracy: 0.9856 - val_answer_output_loss: 1.4486 - val_loss: 9.1339 - val_question_output_accuracy: 0.0069 - val_question_output_loss: 6.1108 - val_question_type_output_accuracy: 0.5000 - val_question_type_output_loss: 1.5745\n",
      "Epoch 6/20\n",
      "\u001b[1m2/2\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 324ms/step - answer_output_accuracy: 0.9830 - answer_output_loss: 1.3763 - loss: 8.3790 - question_output_accuracy: 0.0050 - question_output_loss: 5.8928 - question_type_output_accuracy: 0.5596 - question_type_output_loss: 1.0961 - val_answer_output_accuracy: 0.9856 - val_answer_output_loss: 0.6301 - val_loss: 8.8752 - val_question_output_accuracy: 0.0050 - val_question_output_loss: 6.0297 - val_question_type_output_accuracy: 0.1250 - val_question_type_output_loss: 2.2154\n",
      "Epoch 7/20\n",
      "\u001b[1m2/2\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 320ms/step - answer_output_accuracy: 0.9827 - answer_output_loss: 0.8154 - loss: 7.6408 - question_output_accuracy: 0.0030 - question_output_loss: 5.5596 - question_type_output_accuracy: 0.5596 - question_type_output_loss: 1.2471 - val_answer_output_accuracy: 0.9856 - val_answer_output_loss: 0.5587 - val_loss: 7.8821 - val_question_output_accuracy: 0.0044 - val_question_output_loss: 6.0440 - val_question_type_output_accuracy: 0.5000 - val_question_type_output_loss: 1.2793\n",
      "Epoch 8/20\n",
      "\u001b[1m2/2\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 315ms/step - answer_output_accuracy: 0.9845 - answer_output_loss: 0.6699 - loss: 7.0558 - question_output_accuracy: 0.0025 - question_output_loss: 5.2922 - question_type_output_accuracy: 0.5159 - question_type_output_loss: 1.0964 - val_answer_output_accuracy: 0.9856 - val_answer_output_loss: 0.5644 - val_loss: 7.7566 - val_question_output_accuracy: 0.0044 - val_question_output_loss: 6.1598 - val_question_type_output_accuracy: 0.4375 - val_question_type_output_loss: 1.0324\n",
      "Epoch 9/20\n",
      "\u001b[1m2/2\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 319ms/step - answer_output_accuracy: 0.9837 - answer_output_loss: 0.7007 - loss: 6.7585 - question_output_accuracy: 0.0021 - question_output_loss: 5.0688 - question_type_output_accuracy: 0.5804 - question_type_output_loss: 0.9895 - val_answer_output_accuracy: 0.9856 - val_answer_output_loss: 0.5536 - val_loss: 8.3754 - val_question_output_accuracy: 0.0044 - val_question_output_loss: 6.3426 - val_question_type_output_accuracy: 0.1250 - val_question_type_output_loss: 1.4793\n",
      "Epoch 10/20\n",
      "\u001b[1m2/2\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 316ms/step - answer_output_accuracy: 0.9841 - answer_output_loss: 0.6571 - loss: 6.6996 - question_output_accuracy: 0.0020 - question_output_loss: 4.9654 - question_type_output_accuracy: 0.3769 - question_type_output_loss: 1.0726 - val_answer_output_accuracy: 0.9856 - val_answer_output_loss: 0.5333 - val_loss: 8.2096 - val_question_output_accuracy: 0.0044 - val_question_output_loss: 6.5258 - val_question_type_output_accuracy: 0.5000 - val_question_type_output_loss: 1.1504\n",
      "Epoch 11/20\n",
      "\u001b[1m2/2\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 313ms/step - answer_output_accuracy: 0.9846 - answer_output_loss: 0.5896 - loss: 6.3947 - question_output_accuracy: 0.0029 - question_output_loss: 4.8274 - question_type_output_accuracy: 0.5367 - question_type_output_loss: 0.9851 - val_answer_output_accuracy: 0.9856 - val_answer_output_loss: 0.5115 - val_loss: 8.4411 - val_question_output_accuracy: 0.0050 - val_question_output_loss: 6.6733 - val_question_type_output_accuracy: 0.5000 - val_question_type_output_loss: 1.2564\n",
      "Epoch 12/20\n",
      "\u001b[1m2/2\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 287ms/step - answer_output_accuracy: 0.9832 - answer_output_loss: 0.6274 - loss: 6.3656 - question_output_accuracy: 0.0030 - question_output_loss: 4.7141 - question_type_output_accuracy: 0.4950 - question_type_output_loss: 1.0145 - val_answer_output_accuracy: 0.9856 - val_answer_output_loss: 0.5007 - val_loss: 8.7380 - val_question_output_accuracy: 0.0037 - val_question_output_loss: 6.7743 - val_question_type_output_accuracy: 0.1875 - val_question_type_output_loss: 1.4630\n",
      "Epoch 13/20\n",
      "\u001b[1m2/2\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 294ms/step - answer_output_accuracy: 0.9841 - answer_output_loss: 0.5365 - loss: 6.0931 - question_output_accuracy: 0.0028 - question_output_loss: 4.6340 - question_type_output_accuracy: 0.6330 - question_type_output_loss: 0.9268 - val_answer_output_accuracy: 0.9856 - val_answer_output_loss: 0.5095 - val_loss: 8.8004 - val_question_output_accuracy: 0.0050 - val_question_output_loss: 6.8402 - val_question_type_output_accuracy: 0.1875 - val_question_type_output_loss: 1.4508\n",
      "Epoch 14/20\n",
      "\u001b[1m2/2\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 293ms/step - answer_output_accuracy: 0.9839 - answer_output_loss: 0.5214 - loss: 5.9535 - question_output_accuracy: 0.0038 - question_output_loss: 4.5068 - question_type_output_accuracy: 0.6023 - question_type_output_loss: 0.9284 - val_answer_output_accuracy: 0.9856 - val_answer_output_loss: 0.5292 - val_loss: 8.5136 - val_question_output_accuracy: 0.0050 - val_question_output_loss: 6.8903 - val_question_type_output_accuracy: 0.5000 - val_question_type_output_loss: 1.0940\n",
      "Epoch 15/20\n",
      "\u001b[1m2/2\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 294ms/step - answer_output_accuracy: 0.9838 - answer_output_loss: 0.5345 - loss: 5.8897 - question_output_accuracy: 0.0041 - question_output_loss: 4.4544 - question_type_output_accuracy: 0.5596 - question_type_output_loss: 0.9003 - val_answer_output_accuracy: 0.9856 - val_answer_output_loss: 0.5447 - val_loss: 8.5770 - val_question_output_accuracy: 0.0056 - val_question_output_loss: 6.9331 - val_question_type_output_accuracy: 0.3125 - val_question_type_output_loss: 1.0993\n",
      "Epoch 16/20\n",
      "\u001b[1m2/2\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 292ms/step - answer_output_accuracy: 0.9832 - answer_output_loss: 0.5705 - loss: 5.8373 - question_output_accuracy: 0.0048 - question_output_loss: 4.3814 - question_type_output_accuracy: 0.6351 - question_type_output_loss: 0.8800 - val_answer_output_accuracy: 0.9856 - val_answer_output_loss: 0.5496 - val_loss: 8.8434 - val_question_output_accuracy: 0.0062 - val_question_output_loss: 6.9745 - val_question_type_output_accuracy: 0.2500 - val_question_type_output_loss: 1.3193\n",
      "Epoch 17/20\n",
      "\u001b[1m2/2\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 288ms/step - answer_output_accuracy: 0.9832 - answer_output_loss: 0.5433 - loss: 5.6367 - question_output_accuracy: 0.0053 - question_output_loss: 4.2834 - question_type_output_accuracy: 0.6773 - question_type_output_loss: 0.8080 - val_answer_output_accuracy: 0.9856 - val_answer_output_loss: 0.5488 - val_loss: 8.9683 - val_question_output_accuracy: 0.0062 - val_question_output_loss: 7.0182 - val_question_type_output_accuracy: 0.1875 - val_question_type_output_loss: 1.4014\n",
      "Epoch 18/20\n",
      "\u001b[1m2/2\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 292ms/step - answer_output_accuracy: 0.9843 - answer_output_loss: 0.4771 - loss: 5.4290 - question_output_accuracy: 0.0060 - question_output_loss: 4.1923 - question_type_output_accuracy: 0.6877 - question_type_output_loss: 0.7646 - val_answer_output_accuracy: 0.9856 - val_answer_output_loss: 0.5510 - val_loss: 9.0373 - val_question_output_accuracy: 0.0062 - val_question_output_loss: 7.0739 - val_question_type_output_accuracy: 0.2500 - val_question_type_output_loss: 1.4124\n",
      "Epoch 19/20\n",
      "\u001b[1m2/2\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 305ms/step - answer_output_accuracy: 0.9846 - answer_output_loss: 0.4586 - loss: 5.3489 - question_output_accuracy: 0.0053 - question_output_loss: 4.1443 - question_type_output_accuracy: 0.6668 - question_type_output_loss: 0.7466 - val_answer_output_accuracy: 0.9856 - val_answer_output_loss: 0.5583 - val_loss: 9.1426 - val_question_output_accuracy: 0.0062 - val_question_output_loss: 7.1137 - val_question_type_output_accuracy: 0.1875 - val_question_type_output_loss: 1.4707\n",
      "Epoch 20/20\n",
      "\u001b[1m2/2\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 305ms/step - answer_output_accuracy: 0.9830 - answer_output_loss: 0.5251 - loss: 5.2352 - question_output_accuracy: 0.0066 - question_output_loss: 4.0488 - question_type_output_accuracy: 0.7298 - question_type_output_loss: 0.6596 - val_answer_output_accuracy: 0.9856 - val_answer_output_loss: 0.5674 - val_loss: 9.4190 - val_question_output_accuracy: 0.0062 - val_question_output_loss: 7.1243 - val_question_type_output_accuracy: 0.1250 - val_question_type_output_loss: 1.7272\n"
     ]
    }
   ],
   "source": [
    "\n",
    "VOCAB_SIZE = len(tokenizer.word_index) + 1\n",
    "EMBEDDING_DIM = 300\n",
    "LSTM_UNITS = 256\n",
    "BATCH_SIZE = 32\n",
    "EPOCHS = 20\n",
    "\n",
    "context_input = Input(shape=(MAX_LENGTH,), name=\"context_input\")\n",
    "context_embedding = Embedding(input_dim=VOCAB_SIZE, output_dim=EMBEDDING_DIM, mask_zero=True, name=\"context_embedding\")(context_input)\n",
    "encoder_lstm = LSTM(LSTM_UNITS, return_state=True, name=\"encoder_lstm\")\n",
    "encoder_output, state_h, state_c = encoder_lstm(context_embedding)\n",
    "\n",
    "# Question Decoder\n",
    "question_decoder_input = Input(shape=(MAX_LENGTH,), name=\"question_decoder_input\")\n",
    "question_embedding = Embedding(input_dim=VOCAB_SIZE, output_dim=EMBEDDING_DIM, mask_zero=True, name=\"question_embedding\")(question_decoder_input)\n",
    "question_lstm = LSTM(LSTM_UNITS, return_sequences=True, return_state=True, name=\"question_lstm\")\n",
    "question_output, _, _ = question_lstm(question_embedding, initial_state=[state_h, state_c])\n",
    "question_dense = Dense(VOCAB_SIZE, activation=\"softmax\", name=\"question_output\")(question_output)\n",
    "\n",
    "# Answer Decoder\n",
    "answer_lstm = LSTM(LSTM_UNITS, return_sequences=True, return_state=True, name=\"answer_lstm\")\n",
    "answer_output, _, _ = answer_lstm(context_embedding, initial_state=[state_h, state_c])\n",
    "answer_dense = Dense(VOCAB_SIZE, activation=\"softmax\", name=\"answer_output\")(answer_output)\n",
    "\n",
    "type_dense = Dense(128, activation=\"relu\")(encoder_output)\n",
    "question_type_output = Dense(3, activation=\"softmax\", name=\"question_type_output\")(type_dense)\n",
    "\n",
    "model = Model(\n",
    "    inputs=[context_input, question_decoder_input],\n",
    "    outputs=[question_dense, answer_dense, question_type_output]\n",
    ")\n",
    "\n",
    "model.compile(\n",
    "    optimizer=\"adam\",\n",
    "    loss={\"question_output\": \"sparse_categorical_crossentropy\",\n",
    "          \"answer_output\": \"sparse_categorical_crossentropy\",\n",
    "          \"question_type_output\": \"sparse_categorical_crossentropy\"},\n",
    "    metrics={\"question_output\": [\"accuracy\"],\n",
    "             \"answer_output\": [\"accuracy\"],\n",
    "             \"question_type_output\": [\"accuracy\"]}\n",
    ")\n",
    "\n",
    "data_model = model.fit(\n",
    "    [context_train, question_train],\n",
    "    {\"question_output\": question_train, \"answer_output\": answer_train, \"question_type_output\": qtype_train},\n",
    "    batch_size=BATCH_SIZE,\n",
    "    epochs=EPOCHS,\n",
    "    validation_split=0.2\n",
    ")\n",
    "\n",
    "model.save(\"lstm_multi_output_model.keras\")\n",
    "with open(\"tokenizer.pkl\", \"wb\") as handle:\n",
    "    pickle.dump(tokenizer, handle, protocol=pickle.HIGHEST_PROTOCOL)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 168,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1200x600 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "\n",
    "# data epoch\n",
    "\n",
    "plt.figure(figsize=(12, 6))\n",
    "\n",
    "plt.subplot(1, 2, 1)\n",
    "plt.plot(data_model.history['question_output_accuracy'], label='Question Train Accuracy')\n",
    "plt.plot(data_model.history['val_question_output_accuracy'], label='Question Val Accuracy')\n",
    "plt.plot(data_model.history['answer_output_accuracy'], label='Answer Train Accuracy')\n",
    "plt.plot(data_model.history['val_answer_output_accuracy'], label='Answer Val Accuracy')\n",
    "plt.plot(data_model.history['question_type_output_accuracy'], label='Question Type Train Accuracy')\n",
    "plt.plot(data_model.history['val_question_type_output_accuracy'], label='Question Type Val Accuracy')\n",
    "plt.title('Model Accuracy')\n",
    "plt.xlabel('Epoch')\n",
    "plt.ylabel('Accuracy')\n",
    "plt.legend()\n",
    "\n",
    "plt.subplot(1, 2, 2)\n",
    "plt.plot(data_model.history['question_output_loss'], label='Question Train Loss')\n",
    "plt.plot(data_model.history['val_question_output_loss'], label='Question Val Loss')\n",
    "plt.plot(data_model.history['answer_output_loss'], label='Answer Train Loss')\n",
    "plt.plot(data_model.history['val_answer_output_loss'], label='Answer Val Loss')\n",
    "plt.plot(data_model.history['question_type_output_loss'], label='Question Type Train Loss')\n",
    "plt.plot(data_model.history['val_question_type_output_loss'], label='Question Type Val Loss')\n",
    "plt.title('Model Loss')\n",
    "plt.xlabel('Epoch')\n",
    "plt.ylabel('Loss')\n",
    "plt.legend()\n",
    "\n",
    "plt.tight_layout()\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "=== Evaluation on Test Data ===\n"
     ]
    }
   ],
   "source": [
    "\n",
    "\n",
    "\n",
    "def sequence_to_text(sequence, tokenizer):\n",
    "    \"\"\" Converts a tokenized sequence back into readable text. \"\"\"\n",
    "    return \" \".join([tokenizer.index_word.get(idx, \"<OOV>\") for idx in sequence if idx != 0])\n",
    "\n",
    "print(\"\\n=== Evaluation on Test Data ===\")\n",
    "pred_question_test, pred_answer_test, pred_qtype_test = model.predict([context_test, question_test])\n",
    "pred_qtype_labels_test = np.argmax(pred_qtype_test, axis=1)\n",
    "\n",
    "print(\"Classification Report for Question Type (Test Set):\")\n",
    "print(classification_report(qtype_test, pred_qtype_labels_test))\n",
    "print(\"Test Accuracy:\", accuracy_score(qtype_test, pred_qtype_labels_test))\n",
    "print(\"Test Precision:\", precision_score(qtype_test, pred_qtype_labels_test, average='weighted'))\n",
    "print(\"Test Recall:\", recall_score(qtype_test, pred_qtype_labels_test, average='weighted'))\n",
    "\n",
    "reference_question_test = [sequence_to_text(question_test[0], tokenizer)]\n",
    "candidate_question_test = sequence_to_text(np.argmax(pred_question_test[0], axis=-1), tokenizer)\n",
    "bleu_score_question_test = nltk.translate.bleu_score.sentence_bleu(reference_question_test, candidate_question_test)\n",
    "print(\"BLEU Score for first test sample (question generation):\", bleu_score_question_test)\n",
    "\n",
    "reference_answer_test = [sequence_to_text(answer_test[0], tokenizer)]\n",
    "candidate_answer_test = sequence_to_text(np.argmax(pred_answer_test[0], axis=-1), tokenizer)\n",
    "bleu_score_answer_test = nltk.translate.bleu_score.sentence_bleu(reference_answer_test, candidate_answer_test)\n",
    "print(\"BLEU Score for first test sample (answer generation):\", bleu_score_answer_test)\n",
    "\n",
    "print(\"\\n=== Evaluation on Validation Data ===\")\n",
    "pred_question_val, pred_answer_val, pred_qtype_val = model.predict([context_val, question_val])\n",
    "pred_qtype_labels_val = np.argmax(pred_qtype_val, axis=1)\n",
    "\n",
    "print(\"Classification Report for Question Type (Validation Set):\")\n",
    "print(classification_report(qtype_val, pred_qtype_labels_val))\n",
    "print(\"Validation Accuracy:\", accuracy_score(qtype_val, pred_qtype_labels_val))\n",
    "print(\"Validation Precision:\", precision_score(qtype_val, pred_qtype_labels_val, average='weighted'))\n",
    "print(\"Validation Recall:\", recall_score(qtype_val, pred_qtype_labels_val, average='weighted'))\n",
    "\n",
    "reference_question_val = [sequence_to_text(question_val[0], tokenizer)]\n",
    "candidate_question_val = sequence_to_text(np.argmax(pred_question_val[0], axis=-1), tokenizer)\n",
    "bleu_score_question_val = nltk.translate.bleu_score.sentence_bleu(reference_question_val, candidate_question_val)\n",
    "print(\"BLEU Score for first validation sample (question generation):\", bleu_score_question_val)\n",
    "\n",
    "reference_answer_val = [sequence_to_text(answer_val[0], tokenizer)]\n",
    "candidate_answer_val = sequence_to_text(np.argmax(pred_answer_val[0], axis=-1), tokenizer)\n",
    "bleu_score_answer_val = nltk.translate.bleu_score.sentence_bleu(reference_answer_val, candidate_answer_val)\n",
    "print(\"BLEU Score for first validation sample (answer generation):\", bleu_score_answer_val)\n"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "myenv",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.10.16"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}