TIF_E41211115_lstm-quiz-generator/NER_SRL/new_lstm_ner_srl.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 41,
   "id": "fb106e20",
   "metadata": {},
   "outputs": [],
   "source": [
    "import json, pickle\n",
    "import numpy as np\n",
    "from keras.models import Model\n",
    "from keras.layers import Input, Embedding, Bidirectional, LSTM, TimeDistributed, Dense\n",
    "from keras.preprocessing.sequence import pad_sequences\n",
    "from keras.utils import to_categorical\n",
    "from seqeval.metrics import classification_report\n",
    "from sklearn.model_selection import train_test_split\n",
    "from tensorflow.keras.metrics import CategoricalAccuracy\n",
    "from sklearn.metrics import confusion_matrix, ConfusionMatrixDisplay\n",
    "import matplotlib.pyplot as plt\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "id": "00347a5f",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Total kalimat: 159\n",
      "Total token: 1891\n"
     ]
    }
   ],
   "source": [
    "\n",
    "data = []\n",
    "\n",
    "with open(\"../dataset/dataset_ner_srl.tsv\", encoding=\"utf-8\") as f:\n",
    "    tokens, ner_labels, srl_labels = [], [], []\n",
    "    \n",
    "    for line in f:\n",
    "        line = line.strip()\n",
    "        if not line:\n",
    "            if tokens:\n",
    "                data.append({\n",
    "                    \"tokens\": tokens,\n",
    "                    \"labels_ner\": ner_labels,\n",
    "                    \"labels_srl\": srl_labels\n",
    "                })\n",
    "                tokens, ner_labels, srl_labels = [], [], []\n",
    "        else:\n",
    "            token, ner, srl = line.split(\"\\t\")\n",
    "            tokens.append(token)\n",
    "            ner_labels.append(ner)\n",
    "            srl_labels.append(srl)\n",
    "\n",
    "# Preprocessing sama seperti sebelumnya\n",
    "sentences = [[tok.lower() for tok in item[\"tokens\"]] for item in data]\n",
    "labels_ner = [item[\"labels_ner\"] for item in data]\n",
    "labels_srl = [item[\"labels_srl\"] for item in data]\n",
    "\n",
    "total_kalimat = len(data)\n",
    "total_token = sum(len(item[\"tokens\"]) for item in data)\n",
    "\n",
    "print(\"Total kalimat:\", total_kalimat)\n",
    "print(\"Total token:\", total_token)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "3793950a",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "id": "ac8eb374",
   "metadata": {},
   "outputs": [],
   "source": [
    "# tagging \n",
    "words = sorted({w for s in sentences for w in s})\n",
    "ner_tags = sorted({t for seq in labels_ner for t in seq})\n",
    "srl_tags = sorted({t for seq in labels_srl for t in seq})\n",
    "\n",
    "word2idx = {w: i + 2 for i, w in enumerate(words)}\n",
    "word2idx[\"PAD\"], word2idx[\"UNK\"] = 0, 1\n",
    "\n",
    "tag2idx_ner = {t: i for i, t in enumerate(ner_tags)}\n",
    "tag2idx_srl = {t: i for i, t in enumerate(srl_tags)}\n",
    "idx2tag_ner = {i: t for t, i in tag2idx_ner.items()}\n",
    "idx2tag_srl = {i: t for t, i in tag2idx_srl.items()}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "id": "80356f1f",
   "metadata": {},
   "outputs": [],
   "source": [
    "# encoding\n",
    "\n",
    "X = [[word2idx.get(w, word2idx[\"UNK\"]) for w in s] for s in sentences]\n",
    "y_ner = [[tag2idx_ner[t] for t in seq] for seq in labels_ner]\n",
    "y_srl = [[tag2idx_srl[t] for t in seq] for seq in labels_srl]\n",
    "\n",
    "maxlen = 50 \n",
    "\n",
    "X = pad_sequences(X, maxlen=maxlen, padding=\"post\", value=word2idx[\"PAD\"])\n",
    "y_ner = pad_sequences(y_ner, maxlen=maxlen, padding=\"post\", value=tag2idx_ner[\"O\"])\n",
    "y_srl = pad_sequences(y_srl, maxlen=maxlen, padding=\"post\", value=tag2idx_srl[\"O\"])\n",
    "\n",
    "y_ner = [to_categorical(seq, num_classes=len(tag2idx_ner)) for seq in y_ner]\n",
    "y_srl = [to_categorical(seq, num_classes=len(tag2idx_srl)) for seq in y_srl]\n",
    "\n",
    "X = np.array(X)\n",
    "y_ner = np.array(y_ner)\n",
    "y_srl = np.array(y_srl)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "id": "fe219c96",
   "metadata": {},
   "outputs": [],
   "source": [
    "X_train, X_test, y_ner_train, y_ner_test, y_srl_train, y_srl_test = train_test_split(\n",
    "    X, y_ner, y_srl,            \n",
    "    test_size=0.20,             \n",
    "    random_state=42,\n",
    "    shuffle=True            \n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "id": "7a9636b6",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<pre style=\"white-space:pre;overflow-x:auto;line-height:normal;font-family:Menlo,'DejaVu Sans Mono',consolas,'Courier New',monospace\"><span style=\"font-weight: bold\">Model: \"functional_4\"</span>\n",
       "</pre>\n"
      ],
      "text/plain": [
       "\u001b[1mModel: \"functional_4\"\u001b[0m\n"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/html": [
       "<pre style=\"white-space:pre;overflow-x:auto;line-height:normal;font-family:Menlo,'DejaVu Sans Mono',consolas,'Courier New',monospace\">┏━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━┓\n",
       "┃<span style=\"font-weight: bold\"> Layer (type)        </span>┃<span style=\"font-weight: bold\"> Output Shape      </span>┃<span style=\"font-weight: bold\">    Param # </span>┃<span style=\"font-weight: bold\"> Connected to      </span>┃\n",
       "┡━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━┩\n",
       "│ input_layer_4       │ (<span style=\"color: #00d7ff; text-decoration-color: #00d7ff\">None</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">50</span>)        │          <span style=\"color: #00af00; text-decoration-color: #00af00\">0</span> │ -                 │\n",
       "│ (<span style=\"color: #0087ff; text-decoration-color: #0087ff\">InputLayer</span>)        │                   │            │                   │\n",
       "├─────────────────────┼───────────────────┼────────────┼───────────────────┤\n",
       "│ embedding_4         │ (<span style=\"color: #00d7ff; text-decoration-color: #00d7ff\">None</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">50</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">64</span>)    │     <span style=\"color: #00af00; text-decoration-color: #00af00\">46,016</span> │ input_layer_4[<span style=\"color: #00af00; text-decoration-color: #00af00\">0</span>]… │\n",
       "│ (<span style=\"color: #0087ff; text-decoration-color: #0087ff\">Embedding</span>)         │                   │            │                   │\n",
       "├─────────────────────┼───────────────────┼────────────┼───────────────────┤\n",
       "│ bidirectional_4     │ (<span style=\"color: #00d7ff; text-decoration-color: #00d7ff\">None</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">50</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">128</span>)   │     <span style=\"color: #00af00; text-decoration-color: #00af00\">66,048</span> │ embedding_4[<span style=\"color: #00af00; text-decoration-color: #00af00\">0</span>][<span style=\"color: #00af00; text-decoration-color: #00af00\">0</span>] │\n",
       "│ (<span style=\"color: #0087ff; text-decoration-color: #0087ff\">Bidirectional</span>)     │                   │            │                   │\n",
       "├─────────────────────┼───────────────────┼────────────┼───────────────────┤\n",
       "│ ner_output          │ (<span style=\"color: #00d7ff; text-decoration-color: #00d7ff\">None</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">50</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">25</span>)    │      <span style=\"color: #00af00; text-decoration-color: #00af00\">3,225</span> │ bidirectional_4[<span style=\"color: #00af00; text-decoration-color: #00af00\">…</span> │\n",
       "│ (<span style=\"color: #0087ff; text-decoration-color: #0087ff\">TimeDistributed</span>)   │                   │            │                   │\n",
       "├─────────────────────┼───────────────────┼────────────┼───────────────────┤\n",
       "│ srl_output          │ (<span style=\"color: #00d7ff; text-decoration-color: #00d7ff\">None</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">50</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">18</span>)    │      <span style=\"color: #00af00; text-decoration-color: #00af00\">2,322</span> │ bidirectional_4[<span style=\"color: #00af00; text-decoration-color: #00af00\">…</span> │\n",
       "│ (<span style=\"color: #0087ff; text-decoration-color: #0087ff\">TimeDistributed</span>)   │                   │            │                   │\n",
       "└─────────────────────┴───────────────────┴────────────┴───────────────────┘\n",
       "</pre>\n"
      ],
      "text/plain": [
       "┏━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━┓\n",
       "┃\u001b[1m \u001b[0m\u001b[1mLayer (type)       \u001b[0m\u001b[1m \u001b[0m┃\u001b[1m \u001b[0m\u001b[1mOutput Shape     \u001b[0m\u001b[1m \u001b[0m┃\u001b[1m \u001b[0m\u001b[1m   Param #\u001b[0m\u001b[1m \u001b[0m┃\u001b[1m \u001b[0m\u001b[1mConnected to     \u001b[0m\u001b[1m \u001b[0m┃\n",
       "┡━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━┩\n",
       "│ input_layer_4       │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m50\u001b[0m)        │          \u001b[38;5;34m0\u001b[0m │ -                 │\n",
       "│ (\u001b[38;5;33mInputLayer\u001b[0m)        │                   │            │                   │\n",
       "├─────────────────────┼───────────────────┼────────────┼───────────────────┤\n",
       "│ embedding_4         │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m50\u001b[0m, \u001b[38;5;34m64\u001b[0m)    │     \u001b[38;5;34m46,016\u001b[0m │ input_layer_4[\u001b[38;5;34m0\u001b[0m]… │\n",
       "│ (\u001b[38;5;33mEmbedding\u001b[0m)         │                   │            │                   │\n",
       "├─────────────────────┼───────────────────┼────────────┼───────────────────┤\n",
       "│ bidirectional_4     │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m50\u001b[0m, \u001b[38;5;34m128\u001b[0m)   │     \u001b[38;5;34m66,048\u001b[0m │ embedding_4[\u001b[38;5;34m0\u001b[0m][\u001b[38;5;34m0\u001b[0m] │\n",
       "│ (\u001b[38;5;33mBidirectional\u001b[0m)     │                   │            │                   │\n",
       "├─────────────────────┼───────────────────┼────────────┼───────────────────┤\n",
       "│ ner_output          │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m50\u001b[0m, \u001b[38;5;34m25\u001b[0m)    │      \u001b[38;5;34m3,225\u001b[0m │ bidirectional_4[\u001b[38;5;34m…\u001b[0m │\n",
       "│ (\u001b[38;5;33mTimeDistributed\u001b[0m)   │                   │            │                   │\n",
       "├─────────────────────┼───────────────────┼────────────┼───────────────────┤\n",
       "│ srl_output          │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m50\u001b[0m, \u001b[38;5;34m18\u001b[0m)    │      \u001b[38;5;34m2,322\u001b[0m │ bidirectional_4[\u001b[38;5;34m…\u001b[0m │\n",
       "│ (\u001b[38;5;33mTimeDistributed\u001b[0m)   │                   │            │                   │\n",
       "└─────────────────────┴───────────────────┴────────────┴───────────────────┘\n"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/html": [
       "<pre style=\"white-space:pre;overflow-x:auto;line-height:normal;font-family:Menlo,'DejaVu Sans Mono',consolas,'Courier New',monospace\"><span style=\"font-weight: bold\"> Total params: </span><span style=\"color: #00af00; text-decoration-color: #00af00\">117,611</span> (459.42 KB)\n",
       "</pre>\n"
      ],
      "text/plain": [
       "\u001b[1m Total params: \u001b[0m\u001b[38;5;34m117,611\u001b[0m (459.42 KB)\n"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/html": [
       "<pre style=\"white-space:pre;overflow-x:auto;line-height:normal;font-family:Menlo,'DejaVu Sans Mono',consolas,'Courier New',monospace\"><span style=\"font-weight: bold\"> Trainable params: </span><span style=\"color: #00af00; text-decoration-color: #00af00\">117,611</span> (459.42 KB)\n",
       "</pre>\n"
      ],
      "text/plain": [
       "\u001b[1m Trainable params: \u001b[0m\u001b[38;5;34m117,611\u001b[0m (459.42 KB)\n"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/html": [
       "<pre style=\"white-space:pre;overflow-x:auto;line-height:normal;font-family:Menlo,'DejaVu Sans Mono',consolas,'Courier New',monospace\"><span style=\"font-weight: bold\"> Non-trainable params: </span><span style=\"color: #00af00; text-decoration-color: #00af00\">0</span> (0.00 B)\n",
       "</pre>\n"
      ],
      "text/plain": [
       "\u001b[1m Non-trainable params: \u001b[0m\u001b[38;5;34m0\u001b[0m (0.00 B)\n"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 1/10\n",
      "\u001b[1m64/64\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m6s\u001b[0m 31ms/step - loss: 3.2183 - ner_output_accuracy: 0.8700 - ner_output_loss: 1.5503 - srl_output_accuracy: 0.7278 - srl_output_loss: 1.6679 - val_loss: 0.7435 - val_ner_output_accuracy: 0.9488 - val_ner_output_loss: 0.2671 - val_srl_output_accuracy: 0.8413 - val_srl_output_loss: 0.4764\n",
      "Epoch 2/10\n",
      "\u001b[1m64/64\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 17ms/step - loss: 0.7484 - ner_output_accuracy: 0.9476 - ner_output_loss: 0.2574 - srl_output_accuracy: 0.8292 - srl_output_loss: 0.4911 - val_loss: 0.6928 - val_ner_output_accuracy: 0.9488 - val_ner_output_loss: 0.2566 - val_srl_output_accuracy: 0.8538 - val_srl_output_loss: 0.4362\n",
      "Epoch 3/10\n",
      "\u001b[1m64/64\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 17ms/step - loss: 0.7115 - ner_output_accuracy: 0.9501 - ner_output_loss: 0.2363 - srl_output_accuracy: 0.8392 - srl_output_loss: 0.4751 - val_loss: 0.6501 - val_ner_output_accuracy: 0.9488 - val_ner_output_loss: 0.2476 - val_srl_output_accuracy: 0.8556 - val_srl_output_loss: 0.4026\n",
      "Epoch 4/10\n",
      "\u001b[1m64/64\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 17ms/step - loss: 0.6596 - ner_output_accuracy: 0.9499 - ner_output_loss: 0.2149 - srl_output_accuracy: 0.8501 - srl_output_loss: 0.4448 - val_loss: 0.6068 - val_ner_output_accuracy: 0.9488 - val_ner_output_loss: 0.2321 - val_srl_output_accuracy: 0.8888 - val_srl_output_loss: 0.3746\n",
      "Epoch 5/10\n",
      "\u001b[1m64/64\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 18ms/step - loss: 0.6708 - ner_output_accuracy: 0.9500 - ner_output_loss: 0.2116 - srl_output_accuracy: 0.8565 - srl_output_loss: 0.4591 - val_loss: 0.5745 - val_ner_output_accuracy: 0.9488 - val_ner_output_loss: 0.2257 - val_srl_output_accuracy: 0.8969 - val_srl_output_loss: 0.3489\n",
      "Epoch 6/10\n",
      "\u001b[1m64/64\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 16ms/step - loss: 0.5632 - ner_output_accuracy: 0.9518 - ner_output_loss: 0.1934 - srl_output_accuracy: 0.8837 - srl_output_loss: 0.3702 - val_loss: 0.5507 - val_ner_output_accuracy: 0.9488 - val_ner_output_loss: 0.2125 - val_srl_output_accuracy: 0.8981 - val_srl_output_loss: 0.3382\n",
      "Epoch 7/10\n",
      "\u001b[1m64/64\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 16ms/step - loss: 0.5163 - ner_output_accuracy: 0.9542 - ner_output_loss: 0.1730 - srl_output_accuracy: 0.8909 - srl_output_loss: 0.3432 - val_loss: 0.5265 - val_ner_output_accuracy: 0.9494 - val_ner_output_loss: 0.2101 - val_srl_output_accuracy: 0.9031 - val_srl_output_loss: 0.3165\n",
      "Epoch 8/10\n",
      "\u001b[1m64/64\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 16ms/step - loss: 0.4597 - ner_output_accuracy: 0.9560 - ner_output_loss: 0.1609 - srl_output_accuracy: 0.9077 - srl_output_loss: 0.2989 - val_loss: 0.5069 - val_ner_output_accuracy: 0.9506 - val_ner_output_loss: 0.1971 - val_srl_output_accuracy: 0.9063 - val_srl_output_loss: 0.3097\n",
      "Epoch 9/10\n",
      "\u001b[1m64/64\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 16ms/step - loss: 0.4826 - ner_output_accuracy: 0.9573 - ner_output_loss: 0.1635 - srl_output_accuracy: 0.9079 - srl_output_loss: 0.3192 - val_loss: 0.4902 - val_ner_output_accuracy: 0.9506 - val_ner_output_loss: 0.1912 - val_srl_output_accuracy: 0.9125 - val_srl_output_loss: 0.2990\n",
      "Epoch 10/10\n",
      "\u001b[1m64/64\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 17ms/step - loss: 0.4266 - ner_output_accuracy: 0.9513 - ner_output_loss: 0.1734 - srl_output_accuracy: 0.9242 - srl_output_loss: 0.2531 - val_loss: 0.4749 - val_ner_output_accuracy: 0.9550 - val_ner_output_loss: 0.1855 - val_srl_output_accuracy: 0.9138 - val_srl_output_loss: 0.2895\n"
     ]
    }
   ],
   "source": [
    "input_layer = Input(shape=(maxlen,))\n",
    "embed = Embedding(len(word2idx), 64)(input_layer)\n",
    "bilstm = Bidirectional(LSTM(64, return_sequences=True))(embed)\n",
    "\n",
    "ner_output = TimeDistributed(\n",
    "    Dense(len(tag2idx_ner), activation=\"softmax\"), name=\"ner_output\"\n",
    ")(bilstm)\n",
    "srl_output = TimeDistributed(\n",
    "    Dense(len(tag2idx_srl), activation=\"softmax\"), name=\"srl_output\"\n",
    ")(bilstm)\n",
    "\n",
    "model = Model(inputs=input_layer, outputs=[ner_output, srl_output])\n",
    "model.compile(\n",
    "    optimizer=\"adam\",\n",
    "    loss={\n",
    "        \"ner_output\": \"categorical_crossentropy\",\n",
    "        \"srl_output\": \"categorical_crossentropy\",\n",
    "    },\n",
    "    metrics={\n",
    "        \"ner_output\": [CategoricalAccuracy(name=\"accuracy\")],\n",
    "        \"srl_output\": [CategoricalAccuracy(name=\"accuracy\")],\n",
    "    },\n",
    ")\n",
    "\n",
    "model.summary()\n",
    "model.fit(\n",
    "    X_train, {\"ner_output\": y_ner_train, \"srl_output\": y_srl_train}, \n",
    "    validation_data=(X_test, {\"ner_output\": y_ner_test, \"srl_output\": y_srl_test}),\n",
    "    batch_size=2,\n",
    "    epochs=10,\n",
    "    verbose=1\n",
    ")\n",
    "\n",
    "# ---------- 6. Simpan artefak ----------\n",
    "model.save(\"multi_task_lstm_ner_srl_model.keras\")\n",
    "with open(\"word2idx.pkl\", \"wb\") as f:\n",
    "    pickle.dump(word2idx, f)\n",
    "with open(\"tag2idx_ner.pkl\", \"wb\") as f:\n",
    "    pickle.dump(tag2idx_ner, f)\n",
    "with open(\"tag2idx_srl.pkl\", \"wb\") as f:\n",
    "    pickle.dump(tag2idx_srl, f)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "id": "3a55990b",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Metrics names: ['loss', 'compile_metrics', 'ner_output_loss', 'srl_output_loss']\n",
      "loss: 0.47491562366485596\n",
      "compile_metrics: 0.18545177578926086\n",
      "ner_output_loss: 0.2894638478755951\n",
      "srl_output_loss: 0.9550000429153442\n",
      "WARNING:tensorflow:5 out of the last 8 calls to <function TensorFlowTrainer.make_predict_function.<locals>.one_step_on_data_distributed at 0x7f1ed50939a0> triggered tf.function retracing. Tracing is expensive and the excessive number of tracings could be due to (1) creating @tf.function repeatedly in a loop, (2) passing tensors with different shapes, (3) passing Python objects instead of tensors. For (1), please define your @tf.function outside of the loop. For (2), @tf.function has reduce_retracing=True option that can avoid unnecessary retracing. For (3), please refer to https://www.tensorflow.org/guide/function#controlling_retracing and https://www.tensorflow.org/api_docs/python/tf/function for  more details.\n",
      "[NER] Token-level Accuracy: 1.0\n",
      "[SRL] Token-level Accuracy: 0.9\n",
      "[NER] Classification Report (test set):\n",
      "              precision    recall  f1-score   support\n",
      "\n",
      "        DATE       0.33      0.09      0.14        11\n",
      "       EVENT       0.00      0.00      0.00         1\n",
      "         LOC       1.00      0.19      0.32        21\n",
      "         MIN       0.00      0.00      0.00         3\n",
      "        MISC       0.00      0.00      0.00         1\n",
      "         ORG       0.00      0.00      0.00         3\n",
      "         PER       0.00      0.00      0.00         2\n",
      "         RES       0.00      0.00      0.00         2\n",
      "        TIME       0.00      0.00      0.00         8\n",
      "\n",
      "   micro avg       0.42      0.10      0.16        52\n",
      "   macro avg       0.15      0.03      0.05        52\n",
      "weighted avg       0.47      0.10      0.16        52\n",
      "\n"
     ]
    }
   ],
   "source": [
    "# evaluation\n",
    "\n",
    "print(\"Metrics names:\", model.metrics_names)\n",
    "\n",
    "\n",
    "results = model.evaluate(\n",
    "    X_test,\n",
    "    {\"ner_output\": y_ner_test, \"srl_output\": y_srl_test},\n",
    "    verbose=0\n",
    ")\n",
    "for name, value in zip(model.metrics_names, results):\n",
    "    print(f\"{name}: {value}\")\n",
    "    \n",
    "def token_level_accuracy(y_true, y_pred):\n",
    "    total, correct = 0, 0\n",
    "    for true_seq, pred_seq in zip(y_true, y_pred):\n",
    "        for t, p in zip(true_seq, pred_seq):\n",
    "            if t.sum() == 0:  # skip PAD\n",
    "                continue\n",
    "            total += 1\n",
    "            if t.argmax() == p.argmax():\n",
    "                correct += 1\n",
    "    return correct / total\n",
    "\n",
    "\n",
    "def decode(pred, true, idx2tag):\n",
    "    out_true, out_pred = [], []\n",
    "    for p_seq, t_seq in zip(pred, true):\n",
    "        t_labels, p_labels = [], []\n",
    "        for p_tok, t_tok in zip(p_seq, t_seq):\n",
    "            if t_tok.sum() == 0:          # token PAD → lewati\n",
    "                continue\n",
    "            t_labels.append(idx2tag[t_tok.argmax()])\n",
    "            p_labels.append(idx2tag[p_tok.argmax()])\n",
    "        out_true.append(t_labels)\n",
    "        out_pred.append(p_labels)\n",
    "    return out_true, out_pred\n",
    "\n",
    "# prediksi hanya pada test set\n",
    "y_pred_ner, y_pred_srl = model.predict(X_test, verbose=0)\n",
    "\n",
    "true_ner, pred_ner = decode(y_pred_ner, y_ner_test, idx2tag_ner)\n",
    "\n",
    "acc_ner = token_level_accuracy(y_ner_test, y_pred_ner)\n",
    "acc_srl = token_level_accuracy(y_srl_test, y_pred_srl)\n",
    "\n",
    "print(f\"[NER] Token-level Accuracy: {acc_ner:.1f}\")\n",
    "print(f\"[SRL] Token-level Accuracy: {acc_srl:.1f}\")\n",
    "# print(idx2tag_ner)\n",
    "print(\"[NER] Classification Report (test set):\")\n",
    "print(classification_report(true_ner, pred_ner, digits=2))\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "id": "547d1533",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[SRL] Classification Report (test set):\n",
      "              precision    recall  f1-score   support\n",
      "\n",
      "         FRQ       0.00      0.00      0.00         1\n",
      "         LOC       0.21      0.43      0.29         7\n",
      "         MNR       0.00      0.00      0.00         3\n",
      "         PRP       0.00      0.00      0.00         1\n",
      "         RG0       0.20      0.24      0.22        17\n",
      "         RG1       0.20      0.19      0.19        47\n",
      "         RG2       0.25      0.45      0.32        11\n",
      "         RG3       0.00      0.00      0.00         3\n",
      "         TMP       0.59      0.72      0.65        18\n",
      "           _       0.50      0.12      0.20        33\n",
      "\n",
      "   micro avg       0.29      0.27      0.28       141\n",
      "   macro avg       0.20      0.22      0.19       141\n",
      "weighted avg       0.31      0.27      0.26       141\n",
      "\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/mnt/disc1/code/thesis_quiz_project/lstm-quiz/myenv/lib64/python3.10/site-packages/seqeval/metrics/sequence_labeling.py:171: UserWarning: ARG1 seems not to be NE tag.\n",
      "  warnings.warn('{} seems not to be NE tag.'.format(chunk))\n",
      "/mnt/disc1/code/thesis_quiz_project/lstm-quiz/myenv/lib64/python3.10/site-packages/seqeval/metrics/sequence_labeling.py:171: UserWarning: ARG0 seems not to be NE tag.\n",
      "  warnings.warn('{} seems not to be NE tag.'.format(chunk))\n",
      "/mnt/disc1/code/thesis_quiz_project/lstm-quiz/myenv/lib64/python3.10/site-packages/seqeval/metrics/sequence_labeling.py:171: UserWarning: V seems not to be NE tag.\n",
      "  warnings.warn('{} seems not to be NE tag.'.format(chunk))\n",
      "/mnt/disc1/code/thesis_quiz_project/lstm-quiz/myenv/lib64/python3.10/site-packages/seqeval/metrics/sequence_labeling.py:171: UserWarning: ARGM-TMP seems not to be NE tag.\n",
      "  warnings.warn('{} seems not to be NE tag.'.format(chunk))\n",
      "/mnt/disc1/code/thesis_quiz_project/lstm-quiz/myenv/lib64/python3.10/site-packages/seqeval/metrics/sequence_labeling.py:171: UserWarning: ARGM-PRP seems not to be NE tag.\n",
      "  warnings.warn('{} seems not to be NE tag.'.format(chunk))\n",
      "/mnt/disc1/code/thesis_quiz_project/lstm-quiz/myenv/lib64/python3.10/site-packages/seqeval/metrics/sequence_labeling.py:171: UserWarning: ARGM-LOC seems not to be NE tag.\n",
      "  warnings.warn('{} seems not to be NE tag.'.format(chunk))\n",
      "/mnt/disc1/code/thesis_quiz_project/lstm-quiz/myenv/lib64/python3.10/site-packages/seqeval/metrics/sequence_labeling.py:171: UserWarning: ARG2 seems not to be NE tag.\n",
      "  warnings.warn('{} seems not to be NE tag.'.format(chunk))\n",
      "/mnt/disc1/code/thesis_quiz_project/lstm-quiz/myenv/lib64/python3.10/site-packages/seqeval/metrics/sequence_labeling.py:171: UserWarning: ARGM-MNR seems not to be NE tag.\n",
      "  warnings.warn('{} seems not to be NE tag.'.format(chunk))\n",
      "/mnt/disc1/code/thesis_quiz_project/lstm-quiz/myenv/lib64/python3.10/site-packages/seqeval/metrics/sequence_labeling.py:171: UserWarning: ARGM-FRQ seems not to be NE tag.\n",
      "  warnings.warn('{} seems not to be NE tag.'.format(chunk))\n",
      "/mnt/disc1/code/thesis_quiz_project/lstm-quiz/myenv/lib64/python3.10/site-packages/seqeval/metrics/sequence_labeling.py:171: UserWarning: ARG3 seems not to be NE tag.\n",
      "  warnings.warn('{} seems not to be NE tag.'.format(chunk))\n"
     ]
    }
   ],
   "source": [
    "true_srl, pred_srl = decode(y_pred_srl, y_srl_test, idx2tag_srl)\n",
    "# print(idx2tag_srl)\n",
    "print(\"[SRL] Classification Report (test set):\")\n",
    "print(classification_report(true_srl, pred_srl, digits=2))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "id": "8d44d51e",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "flat_true_ner = [t for seq in true_ner for t in seq]\n",
    "flat_pred_ner = [p for seq in pred_ner for p in seq]\n",
    "\n",
    "labels_ner = sorted(list(set(flat_true_ner + flat_pred_ner)))\n",
    "cm_ner = confusion_matrix(flat_true_ner, flat_pred_ner, labels=labels_ner)\n",
    "\n",
    "disp = ConfusionMatrixDisplay(confusion_matrix=cm_ner, display_labels=labels_ner)\n",
    "disp.plot(xticks_rotation=45, cmap=plt.cm.Blues)\n",
    "plt.title(\"Confusion Matrix NER\")\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "id": "918dbefb",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "flat_true_srl = [t for seq in true_srl for t in seq]\n",
    "flat_pred_srl = [p for seq in pred_srl for p in seq]\n",
    "\n",
    "labels_srl = sorted(list(set(flat_true_srl + flat_pred_srl)))\n",
    "cm_srl = confusion_matrix(flat_true_srl, flat_pred_srl, labels=labels_srl)\n",
    "\n",
    "disp = ConfusionMatrixDisplay(confusion_matrix=cm_srl, display_labels=labels_srl)\n",
    "disp.plot(xticks_rotation=45, cmap=plt.cm.Blues)\n",
    "plt.title(\"Confusion Matrix srl\")\n",
    "plt.show()"
   ]
  }
 ],
 "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": 5
}