modeling.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas as pd\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "import seaborn as sns\n",
    "from datetime import datetime"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Load the dataset\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "df = pd.read_csv('data.csv')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Null/Empty counts for each column:\n",
      "timestamp_call_key                        0\n",
      "retailer_code                             0\n",
      "serial                                    0\n",
      "reason                                    0\n",
      "mos                                       0\n",
      "resolved                                  0\n",
      "no_of_accounts_with_syf_13_march       3400\n",
      "account_balance_13_march             113782\n",
      "delinquency_history_13_march              0\n",
      "account_open_date_13_march                0\n",
      "account_status_13_march                   0\n",
      "card_activation_status_13_march           0\n",
      "eservice_ind_13_march                     0\n",
      "ebill_enrolled_status_13_march            0\n",
      "auto_pay_enrolled_status_13_march         0\n",
      "no_of_accounts_with_syf_18_march       3402\n",
      "account_balance_18_march             101829\n",
      "delinquency_history_18_march              0\n",
      "account_open_date_18_march                0\n",
      "account_status_18_march                   0\n",
      "card_activation_status_18_march           0\n",
      "eservice_ind_18_march                     0\n",
      "ebill_enrolled_status_18_march            0\n",
      "auto_pay_enrolled_status_18_march         0\n",
      "date_of_call                              0\n",
      "time_of_call                              0\n",
      "dtype: int64\n"
     ]
    }
   ],
   "source": [
    "null_counts = df.isnull().sum()\n",
    "print(\"Null/Empty counts for each column:\")\n",
    "print(null_counts)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Analyzing MOS Sequences\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We observe the paths which occur most commonly in MOS Sequences.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "from collections import Counter\n",
    "\n",
    "mos_sequences = df['mos'].str.split().apply(tuple)\n",
    "most_common_paths = Counter(mos_sequences).most_common()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 600x400 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "\n",
    "mos_labels = [' '.join(mos) for mos, count in most_common_paths[:10]]\n",
    "counts = [count for mos, count in most_common_paths[:10]]\n",
    "\n",
    "plt.figure(figsize=(6, 4))\n",
    "plt.barh(mos_labels, counts)\n",
    "plt.xlabel('Frequency')\n",
    "plt.ylabel('MOS Sequence')\n",
    "plt.title('Top 10 Most Common MOS Paths')\n",
    "plt.gca().invert_yaxis()\n",
    "plt.show()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[(('IA', 'PP', 'TR'), 466412), (('mn', 'IA', 'PP', 'TR'), 137569), (('IA', 'BA'), 116279), (('IA', 'IA', 'PP', 'TR'), 46700), (('IA', 'BA', 'TS', 'nl', 'PT', 'TR'), 43145), (('IA', 'BA', 'TS'), 30003), (('IA', 'PP', 'BA'), 29874), (('IA', 'PI', 'BA'), 28304), (('mn', 'IA', 'BA'), 24763), (('IA', 'PP', 'BA', 'TS', 'nl', 'PT', 'TR'), 15463)]\n"
     ]
    }
   ],
   "source": [
    "print(most_common_paths[:10])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As a deep-dive, we group by all unique MOS Sequence combinations. Next, we identify the respective number of times each of them has had a resolution status of \"resolved\" and \"floor\", and, accordingly, calculate a Floor Percentage, given by:\n",
    "(Number of occurrences of Floor for a given MOS Sequence/Total occurrences of the MOS Sequence) \\* 100%\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "mos_sequences_df = df['mos'].str.split().apply(tuple).to_frame(name='mos_sequence_tuple').copy()\n",
    "mos_sequences_df['resolved_status'] = df['resolved']\n",
    "\n",
    "grouped_counts = mos_sequences_df.groupby(['mos_sequence_tuple', 'resolved_status']).size().unstack(fill_value=0)\n",
    "\n",
    "grouped_counts['total_occurrences'] = grouped_counts['resolved'] + grouped_counts['floor']\n",
    "\n",
    "grouped_counts['floor_percentage'] = (grouped_counts['floor'] / grouped_counts['total_occurrences']) * 100\n",
    "\n",
    "sorted_grouped_counts = grouped_counts.sort_values(by='floor_percentage', ascending=False)\n",
    "\n",
    "sorted_grouped_counts.reset_index(inplace=True)\n",
    "\n",
    "sorted_grouped_counts['mos_sequence'] = sorted_grouped_counts['mos_sequence_tuple'].apply(lambda x: ' '.join(x))\n",
    "\n",
    "mos_df = sorted_grouped_counts[['mos_sequence', 'floor_percentage', 'total_occurrences', 'resolved', 'floor']].copy()\n",
    "\n",
    "mos_df.rename(columns={\n",
    "    'mos_sequence': 'MOS Sequence',\n",
    "    'floor_percentage': 'Floor Call Percentage',\n",
    "    'total_occurrences': 'Total Occurrences',\n",
    "    'resolved': 'Number of Resolved Calls',\n",
    "    'floor': 'Number of Floor Calls'\n",
    "}, inplace=True)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We calculate a weighted score for each of the previously obtained unique MOS Sequence.\n",
    "The score is calculated as a Weighted Harmonic Mean, given by:\n",
    "\n",
    "Weighted Score = w_fp + w_to / ((w_fp/fp +1) + (w_to/to+1))\n",
    "\n",
    "Where, w_fp = 0.6, w_to = 0.4\n",
    "\n",
    "fp denotes \"Floor Percentage\"\n",
    "to denotes \"Total Occurrences\"\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "resolved_status             MOS Sequence  Floor Call Percentage  \\\n",
      "22516               IA BA TS nl mt RS TR              99.669754   \n",
      "22497                  IA BA nl mt RS TR              99.768188   \n",
      "22492               IA PP BA nl mt RS TR              99.798894   \n",
      "22598                        IA BA nl TR              99.088624   \n",
      "22512            IA PP BA TS nl mt RS TR              99.698417   \n",
      "22513            IA PI BA TS nl mt RS TR              99.690482   \n",
      "22676                     IA BA TS nl TR              98.465335   \n",
      "22504            mn IA BA TS nl mt RS TR              99.727438   \n",
      "22559            IA BA TS nl nl mt RS TR              99.375170   \n",
      "22611                     mn IA BA nl TR              98.999090   \n",
      "\n",
      "resolved_status  Total Occurrences  weighted_score  \n",
      "22516                        12415      166.880870  \n",
      "22497                         5608      165.959292  \n",
      "22492                         3978      165.208044  \n",
      "22598                         6364      165.083762  \n",
      "22512                         3979      165.046783  \n",
      "22513                         3877      164.962029  \n",
      "22676                        12967      164.932199  \n",
      "22504                         3302      164.534005  \n",
      "22559                         3681      164.305850  \n",
      "22611                         4396      164.175961  \n"
     ]
    }
   ],
   "source": [
    "w_fp = 0.6 \n",
    "w_to = 0.4\n",
    "\n",
    "mos_df['weighted_score'] = (w_fp + w_to) / ((w_fp / (mos_df['Floor Call Percentage'] + 1)) + (w_to / (mos_df['Total Occurrences'] + 1)))\n",
    "\n",
    "mos_df_sorted = mos_df.sort_values(by='weighted_score', ascending=False)\n",
    "\n",
    "print(mos_df_sorted[['MOS Sequence', 'Floor Call Percentage', 'Total Occurrences', 'weighted_score']].head(10))\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Ensuring the counts obtained above are accurate, by comparing manually against the Excel.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Counts for MOS sequence 'IA BA TS nl CT mt RS TR':\n",
      "resolved\n",
      "floor       1455\n",
      "resolved       5\n",
      "Name: count, dtype: int64\n"
     ]
    }
   ],
   "source": [
    "specific_mos_df = df[df['mos'] == 'IA BA TS nl CT mt RS TR']\n",
    "\n",
    "resolved_counts = specific_mos_df['resolved'].value_counts()\n",
    "\n",
    "print(f\"Counts for MOS sequence 'IA BA TS nl CT mt RS TR':\\n{resolved_counts}\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Saving the unique MOS sequences along with their weighted scores.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "mos_df_sorted.to_csv('mos_analysis.csv', index=False)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Using Deep Learning\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### Model Training and Testing\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Using a Long short-term memory (LSTM) recurrent neural network.\n",
    "\n",
    "We tokenize all the MOS sequences, as our aim is to capture not just the significance of a sequence, but also the signifiance of the codes which make up a sequence.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "from tensorflow.keras.preprocessing.text import Tokenizer\n",
    "from tensorflow.keras.preprocessing.sequence import pad_sequences\n",
    "from tensorflow.keras.models import Sequential\n",
    "from tensorflow.keras.layers import Embedding, LSTM, Dense, Dropout\n",
    "from sklearn.model_selection import train_test_split\n",
    "import numpy as np\n",
    "\n",
    "sequences = mos_df_sorted['MOS Sequence']\n",
    "\n",
    "tokenizer = Tokenizer()\n",
    "tokenizer.fit_on_texts(sequences)\n",
    "seqs = tokenizer.texts_to_sequences(sequences)\n",
    "seqs_padded = pad_sequences(seqs, padding='post')\n",
    "\n",
    "# Prepare labels (1 for floor, 0 for resolved)\n",
    "labels = np.where(mos_df_sorted['Floor Call Percentage'] > 50, 1, 0)\n",
    "\n",
    "# Splitting the data 80:20\n",
    "X_train, X_test, y_train, y_test = train_test_split(seqs_padded, labels, test_size=0.2, random_state=42)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Next, we build the model and set it to training.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "model = Sequential()\n",
    "model.add(Embedding(input_dim=len(tokenizer.word_index) + 1, output_dim=128))\n",
    "model.add(LSTM(128, return_sequences=True))\n",
    "model.add(Dropout(0.2))\n",
    "model.add(LSTM(64))\n",
    "model.add(Dense(1, activation='sigmoid'))\n",
    "\n",
    "model.compile(optimizer='adam', loss='binary_crossentropy', metrics=['accuracy'])\n",
    "\n",
    "# Training\n",
    "model.fit(X_train, y_train, epochs=5, validation_data=(X_test, y_test))\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Due to resource constraints, we settled at 5 Epochs of training, but we realize it doesn't take the model long to reach a high level of accuracy.\n",
    "But there's obviously room for improvement, especially with the loss.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Having obtained our model, we test prediction manually by providing an input MOS sequence string.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\u001b[1m1/1\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 355ms/step\n",
      "Resolved\n"
     ]
    }
   ],
   "source": [
    "def predict_mos_sequence(sequence, model, tokenizer):\n",
    "    tokenized_seq = tokenizer.texts_to_sequences([sequence])\n",
    "    padded_seq = pad_sequences(tokenized_seq, maxlen=seqs_padded.shape[1], padding='post')\n",
    "    \n",
    "    prediction = model.predict(padded_seq)\n",
    "    return \"Floor\" if prediction[0][0] >= 0.5 else \"Resolved\"\n",
    "\n",
    "# Testing prediction manually with an input\n",
    "new_mos = \"mn IA PI BA MR\"\n",
    "print(predict_mos_sequence(new_mos, model, tokenizer))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.metrics import classification_report, confusion_matrix\n",
    "import matplotlib.pyplot as plt\n",
    "import seaborn as sns\n",
    "\n",
    "# Generate predictions on test data\n",
    "predictions = model.predict(X_test)\n",
    "# Convert predictions to binary values (0 or 1)\n",
    "predictions = (predictions > 0.5).astype(int)\n",
    "\n",
    "# Assuming y_test and predictions are available\n",
    "print(classification_report(y_test, predictions))\n",
    "\n",
    "# Confusion Matrix\n",
    "conf_matrix = confusion_matrix(y_test, predictions)\n",
    "plt.figure(figsize=(10, 7))\n",
    "sns.heatmap(conf_matrix, annot=True, fmt='g', cmap='Blues')\n",
    "plt.xlabel('Predicted')\n",
    "plt.ylabel('True')\n",
    "plt.title('Confusion Matrix')\n",
    "plt.show()\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Using Transformers.\n",
    "\n",
    "They can capture long-range dependencies more effectively than LSTMs, ideally leading to better performance in understanding context of mos sequences.\n",
    "\n",
    "We note that the self-attention mechanism present in a Transformer will aid us in weighing the importance of an individual code in a given sequence.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Again, we tokenize all the MOS sequences, and prepare labels.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.model_selection import train_test_split\n",
    "from tensorflow.keras.preprocessing.text import Tokenizer\n",
    "from tensorflow.keras.preprocessing.sequence import pad_sequences\n",
    "\n",
    "tokenizer = Tokenizer()\n",
    "tokenizer.fit_on_texts(df['mos'])\n",
    "sequences = tokenizer.texts_to_sequences(df['mos'])\n",
    "max_seq_length = max([len(seq) for seq in sequences])  # Or choose a fixed length\n",
    "seqs_padded = pad_sequences(sequences, maxlen=max_seq_length, padding='post')\n",
    "\n",
    "labels = df['resolved'].apply(lambda x: 1 if x == 'floor' else 0)\n",
    "\n",
    "X_train, X_test, y_train, y_test = train_test_split(seqs_padded, labels, test_size=0.2, random_state=42)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Building the Transformer\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [],
   "source": [
    "from tensorflow.keras.models import Model\n",
    "from tensorflow.keras.layers import Input, Dense, Embedding, GlobalAveragePooling1D\n",
    "from tensorflow.keras.layers import MultiHeadAttention, Dropout, LayerNormalization\n",
    "\n",
    "def transformer_encoder(inputs):\n",
    "    attention_output = MultiHeadAttention(num_heads=2, key_dim=64)(inputs, inputs)\n",
    "    attention_output = Dropout(0.1)(attention_output)\n",
    "    attention_output = LayerNormalization(epsilon=1e-6)(inputs + attention_output)\n",
    "    \n",
    "    ffn_output = Dense(64, activation='relu')(attention_output)\n",
    "    ffn_output = Dense(inputs.shape[-1])(ffn_output)\n",
    "    ffn_output = Dropout(0.1)(ffn_output)\n",
    "    return LayerNormalization(epsilon=1e-6)(attention_output + ffn_output)\n",
    "\n",
    "inputs = Input(shape=(max_seq_length,))\n",
    "embedding_layer = Embedding(input_dim=len(tokenizer.word_index)+1, output_dim=64)(inputs)\n",
    "transformer_block = transformer_encoder(embedding_layer)\n",
    "x = GlobalAveragePooling1D()(transformer_block)\n",
    "x = Dropout(0.1)(x)\n",
    "outputs = Dense(1, activation='sigmoid')(x)\n",
    "\n",
    "model = Model(inputs=inputs, outputs=outputs)\n",
    "model.compile(optimizer='adam', loss='binary_crossentropy', metrics=['accuracy'])\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now, we train the model\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 1/3\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\u001b[1m44970/44970\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m348s\u001b[0m 8ms/step - accuracy: 0.9600 - loss: 0.1439 - val_accuracy: 0.9638 - val_loss: 0.1333\n",
      "Epoch 2/3\n",
      "\u001b[1m44970/44970\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m371s\u001b[0m 8ms/step - accuracy: 0.9632 - loss: 0.1334 - val_accuracy: 0.9637 - val_loss: 0.1334\n",
      "Epoch 3/3\n",
      "\u001b[1m44970/44970\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m388s\u001b[0m 9ms/step - accuracy: 0.9636 - loss: 0.1323 - val_accuracy: 0.9634 - val_loss: 0.1335\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<keras.src.callbacks.history.History at 0x201437206e0>"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "model.fit(X_train, y_train, batch_size=32, epochs=3, validation_data=(X_test, y_test))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We notice, our model immediately shows a marked improvement over the results obtained by the LSTM\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Again, we run predictions with the model on a sample MOS sequence\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\u001b[1m1/1\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 32ms/step\n",
      "Resolved\n"
     ]
    }
   ],
   "source": [
    "def predict_mos_transformer(sequence, model, tokenizer, max_seq_length):\n",
    "    tokenized_seq = tokenizer.texts_to_sequences([sequence])\n",
    "    padded_seq = pad_sequences(tokenized_seq, maxlen=max_seq_length, padding='post')\n",
    "    prediction = model.predict(padded_seq)\n",
    "    return \"Floor\" if prediction[0][0] >= 0.5 else \"Resolved\"\n",
    "\n",
    "# Example usage\n",
    "print(predict_mos_transformer(\"IA AA Ta BA BA BA nl nl\", model, tokenizer, max_seq_length))\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Next, we leverage some metrics, in F-1, AUC, precision, and recall to analyze our model. As we're dealing with binary classification (floor vs resolved), these metrics can provide good insights about the performance of the model.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\u001b[1m11243/11243\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m35s\u001b[0m 3ms/step\n",
      "F1 Score: 0.9057281199264764\n",
      "AUC Score: 0.9622250819456424\n",
      "Precision: 0.9516645374614864\n",
      "Recall: 0.8640221603624256\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 600x400 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\tansw\\AppData\\Local\\Temp\\ipykernel_12648\\4071259958.py:36: FutureWarning: \n",
      "\n",
      "Passing `palette` without assigning `hue` is deprecated and will be removed in v0.14.0. Assign the `x` variable to `hue` and set `legend=False` for the same effect.\n",
      "\n",
      "  sns.barplot(x=metrics, y=values, palette='muted')\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 600x400 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "import seaborn as sns\n",
    "from sklearn.metrics import f1_score, roc_auc_score, precision_score, recall_score, roc_curve, auc\n",
    "\n",
    "predictions_prob = model.predict(X_test)\n",
    "predictions = (predictions_prob > 0.5).astype(\"int32\")\n",
    "\n",
    "f1 = f1_score(y_test, predictions)\n",
    "auc_score = roc_auc_score(y_test, predictions_prob)\n",
    "precision = precision_score(y_test, predictions)\n",
    "recall = recall_score(y_test, predictions)\n",
    "\n",
    "print(f\"F1 Score: {f1}\")\n",
    "print(f\"AUC Score: {auc_score}\")\n",
    "print(f\"Precision: {precision}\")\n",
    "print(f\"Recall: {recall}\")\n",
    "\n",
    "fpr, tpr, thresholds = roc_curve(y_test, predictions_prob)\n",
    "roc_auc = auc(fpr, tpr)\n",
    "\n",
    "plt.figure(figsize=(6, 4))\n",
    "plt.plot(fpr, tpr, color='darkorange', lw=2, label=f'ROC curve (area = {roc_auc:.2f})')\n",
    "plt.plot([0, 1], [0, 1], color='navy', lw=2, linestyle='--')\n",
    "plt.xlim([0.0, 1.0])\n",
    "plt.ylim([0.0, 1.05])\n",
    "plt.xlabel('False Positive Rate')\n",
    "plt.ylabel('True Positive Rate')\n",
    "plt.title('Receiver Operating Characteristic (ROC) Curve')\n",
    "plt.legend(loc=\"lower right\")\n",
    "plt.show()\n",
    "\n",
    "metrics = ['F1 Score', 'AUC Score', 'Precision', 'Recall']\n",
    "values = [f1, auc_score, precision, recall]\n",
    "\n",
    "plt.figure(figsize=(6, 4))\n",
    "sns.barplot(x=metrics, y=values, palette='muted')\n",
    "plt.title('Model Performance Metrics')\n",
    "plt.ylabel('Score')\n",
    "plt.ylim(0, 1)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We observe great F-1 and AUC Scores, even highlighting good precision and recall.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Finally, we save our model\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [],
   "source": [
    "model.save('model.keras')  # Saves the model to a single HDF5 file"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Lest we need to load our model for future reference.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from tensorflow.keras.models import load_model\n",
    "\n",
    "model = load_model('model.keras')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Enriching our model\n",
    "\n",
    "Having trained our Transformer, we look into adding additional features: specifically, highlighting the significance of MOS sequences which contribute to calls that go to the floor. We reiterate, our aim is to minimize the number of floor calls, and for this purpose, it's essential to put an emphasis on what makes calls go to the floor.\n",
    "\n",
    "Thus, we leverage the weighted scores we'd calculated previously for unique MOS sequences, and we add those scores to our existing dataset.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [],
   "source": [
    "mos_weighted_df = pd.read_csv('mos_weighted.csv')\n",
    "\n",
    "df_enriched = pd.merge(df, mos_weighted_df[['MOS Sequence', 'weighted_score']], left_on='mos', right_on='MOS Sequence', how='left')\n",
    "\n",
    "df_enriched.drop('MOS Sequence', axis=1, inplace=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>timestamp_call_key</th>\n",
       "      <th>retailer_code</th>\n",
       "      <th>serial</th>\n",
       "      <th>reason</th>\n",
       "      <th>mos</th>\n",
       "      <th>resolved</th>\n",
       "      <th>no_of_accounts_with_syf_13_march</th>\n",
       "      <th>account_balance_13_march</th>\n",
       "      <th>delinquency_history_13_march</th>\n",
       "      <th>account_open_date_13_march</th>\n",
       "      <th>...</th>\n",
       "      <th>delinquency_history_18_march</th>\n",
       "      <th>account_open_date_18_march</th>\n",
       "      <th>account_status_18_march</th>\n",
       "      <th>card_activation_status_18_march</th>\n",
       "      <th>eservice_ind_18_march</th>\n",
       "      <th>ebill_enrolled_status_18_march</th>\n",
       "      <th>auto_pay_enrolled_status_18_march</th>\n",
       "      <th>date_of_call</th>\n",
       "      <th>time_of_call</th>\n",
       "      <th>weighted_score</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>240315173250 DAL1OA3M</td>\n",
       "      <td>D</td>\n",
       "      <td>10010009499</td>\n",
       "      <td>PP</td>\n",
       "      <td>IA PP TR</td>\n",
       "      <td>resolved</td>\n",
       "      <td>1.0</td>\n",
       "      <td>NaN</td>\n",
       "      <td>[00]</td>\n",
       "      <td>5/19/2013</td>\n",
       "      <td>...</td>\n",
       "      <td>[00]</td>\n",
       "      <td>5/19/2013</td>\n",
       "      <td>N</td>\n",
       "      <td>0</td>\n",
       "      <td>1</td>\n",
       "      <td>E</td>\n",
       "      <td>0</td>\n",
       "      <td>03/15/2024</td>\n",
       "      <td>17:32:50</td>\n",
       "      <td>9.519088</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>240315124742 DAL15XHK</td>\n",
       "      <td>E</td>\n",
       "      <td>10006021998</td>\n",
       "      <td>BA</td>\n",
       "      <td>IA BA TS nl TR</td>\n",
       "      <td>floor</td>\n",
       "      <td>2.0</td>\n",
       "      <td>143.28</td>\n",
       "      <td>[00]</td>\n",
       "      <td>9/22/2003</td>\n",
       "      <td>...</td>\n",
       "      <td>[00]</td>\n",
       "      <td>9/22/2003</td>\n",
       "      <td>N</td>\n",
       "      <td>0</td>\n",
       "      <td>1</td>\n",
       "      <td>E</td>\n",
       "      <td>0</td>\n",
       "      <td>03/15/2024</td>\n",
       "      <td>12:47:42</td>\n",
       "      <td>164.932199</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "<p>2 rows × 27 columns</p>\n",
       "</div>"
      ],
      "text/plain": [
       "      timestamp_call_key retailer_code       serial reason             mos  \\\n",
       "0  240315173250 DAL1OA3M             D  10010009499     PP        IA PP TR   \n",
       "1  240315124742 DAL15XHK             E  10006021998     BA  IA BA TS nl TR   \n",
       "\n",
       "   resolved  no_of_accounts_with_syf_13_march  account_balance_13_march  \\\n",
       "0  resolved                               1.0                       NaN   \n",
       "1     floor                               2.0                    143.28   \n",
       "\n",
       "  delinquency_history_13_march account_open_date_13_march  ...  \\\n",
       "0                         [00]                  5/19/2013  ...   \n",
       "1                         [00]                  9/22/2003  ...   \n",
       "\n",
       "  delinquency_history_18_march  account_open_date_18_march  \\\n",
       "0                         [00]                   5/19/2013   \n",
       "1                         [00]                   9/22/2003   \n",
       "\n",
       "   account_status_18_march card_activation_status_18_march  \\\n",
       "0                        N                               0   \n",
       "1                        N                               0   \n",
       "\n",
       "   eservice_ind_18_march  ebill_enrolled_status_18_march  \\\n",
       "0                      1                               E   \n",
       "1                      1                               E   \n",
       "\n",
       "   auto_pay_enrolled_status_18_march date_of_call time_of_call weighted_score  \n",
       "0                                  0   03/15/2024     17:32:50       9.519088  \n",
       "1                                  0   03/15/2024     12:47:42     164.932199  \n",
       "\n",
       "[2 rows x 27 columns]"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Next, we normalize the weighted scores and split the dataset for our model.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.model_selection import train_test_split\n",
    "from sklearn.preprocessing import MinMaxScaler\n",
    "import numpy as np\n",
    "\n",
    "scaler = MinMaxScaler()\n",
    "weighted_scores_norm = scaler.fit_transform(df_enriched[['weighted_score']].fillna(0))\n",
    "\n",
    "labels_enriched = df_enriched['resolved'].apply(lambda x: 1 if x == 'floor' else 0).values\n",
    "\n",
    "X_train_seqs, X_test_seqs, X_train_scores, X_test_scores, y_train, y_test = train_test_split(seqs_padded, weighted_scores_norm, labels_enriched, test_size=0.2, random_state=42)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Modifying our model to accept an additional input in terms of normalized weighted score.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "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_3\"</span>\n",
       "</pre>\n"
      ],
      "text/plain": [
       "\u001b[1mModel: \"functional_3\"\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",
       "│ seq_input           │ (<span style=\"color: #00d7ff; text-decoration-color: #00d7ff\">None</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">12</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_1         │ (<span style=\"color: #00d7ff; text-decoration-color: #00d7ff\">None</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">12</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">64</span>)    │      <span style=\"color: #00af00; text-decoration-color: #00af00\">4,928</span> │ seq_input[<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\">Embedding</span>)         │                   │            │                   │\n",
       "├─────────────────────┼───────────────────┼────────────┼───────────────────┤\n",
       "│ multi_head_attenti… │ (<span style=\"color: #00d7ff; text-decoration-color: #00d7ff\">None</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">12</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">64</span>)    │     <span style=\"color: #00af00; text-decoration-color: #00af00\">33,216</span> │ embedding_1[<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\">MultiHeadAttentio…</span> │                   │            │ embedding_1[<span style=\"color: #00af00; text-decoration-color: #00af00\">0</span>][<span style=\"color: #00af00; text-decoration-color: #00af00\">0</span>] │\n",
       "├─────────────────────┼───────────────────┼────────────┼───────────────────┤\n",
       "│ dropout_5 (<span style=\"color: #0087ff; text-decoration-color: #0087ff\">Dropout</span>) │ (<span style=\"color: #00d7ff; text-decoration-color: #00d7ff\">None</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">12</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">64</span>)    │          <span style=\"color: #00af00; text-decoration-color: #00af00\">0</span> │ multi_head_atten… │\n",
       "├─────────────────────┼───────────────────┼────────────┼───────────────────┤\n",
       "│ add_2 (<span style=\"color: #0087ff; text-decoration-color: #0087ff\">Add</span>)         │ (<span style=\"color: #00d7ff; text-decoration-color: #00d7ff\">None</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">12</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">64</span>)    │          <span style=\"color: #00af00; text-decoration-color: #00af00\">0</span> │ embedding_1[<span style=\"color: #00af00; text-decoration-color: #00af00\">0</span>][<span style=\"color: #00af00; text-decoration-color: #00af00\">0</span>… │\n",
       "│                     │                   │            │ dropout_5[<span style=\"color: #00af00; text-decoration-color: #00af00\">0</span>][<span style=\"color: #00af00; text-decoration-color: #00af00\">0</span>]   │\n",
       "├─────────────────────┼───────────────────┼────────────┼───────────────────┤\n",
       "│ layer_normalizatio… │ (<span style=\"color: #00d7ff; text-decoration-color: #00d7ff\">None</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">12</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">64</span>)    │        <span style=\"color: #00af00; text-decoration-color: #00af00\">128</span> │ add_2[<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\">LayerNormalizatio…</span> │                   │            │                   │\n",
       "├─────────────────────┼───────────────────┼────────────┼───────────────────┤\n",
       "│ dense_3 (<span style=\"color: #0087ff; text-decoration-color: #0087ff\">Dense</span>)     │ (<span style=\"color: #00d7ff; text-decoration-color: #00d7ff\">None</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">12</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">64</span>)    │      <span style=\"color: #00af00; text-decoration-color: #00af00\">4,160</span> │ layer_normalizat… │\n",
       "├─────────────────────┼───────────────────┼────────────┼───────────────────┤\n",
       "│ dense_4 (<span style=\"color: #0087ff; text-decoration-color: #0087ff\">Dense</span>)     │ (<span style=\"color: #00d7ff; text-decoration-color: #00d7ff\">None</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">12</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">64</span>)    │      <span style=\"color: #00af00; text-decoration-color: #00af00\">4,160</span> │ dense_3[<span style=\"color: #00af00; text-decoration-color: #00af00\">0</span>][<span style=\"color: #00af00; text-decoration-color: #00af00\">0</span>]     │\n",
       "├─────────────────────┼───────────────────┼────────────┼───────────────────┤\n",
       "│ dropout_6 (<span style=\"color: #0087ff; text-decoration-color: #0087ff\">Dropout</span>) │ (<span style=\"color: #00d7ff; text-decoration-color: #00d7ff\">None</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">12</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">64</span>)    │          <span style=\"color: #00af00; text-decoration-color: #00af00\">0</span> │ dense_4[<span style=\"color: #00af00; text-decoration-color: #00af00\">0</span>][<span style=\"color: #00af00; text-decoration-color: #00af00\">0</span>]     │\n",
       "├─────────────────────┼───────────────────┼────────────┼───────────────────┤\n",
       "│ add_3 (<span style=\"color: #0087ff; text-decoration-color: #0087ff\">Add</span>)         │ (<span style=\"color: #00d7ff; text-decoration-color: #00d7ff\">None</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">12</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">64</span>)    │          <span style=\"color: #00af00; text-decoration-color: #00af00\">0</span> │ layer_normalizat… │\n",
       "│                     │                   │            │ dropout_6[<span style=\"color: #00af00; text-decoration-color: #00af00\">0</span>][<span style=\"color: #00af00; text-decoration-color: #00af00\">0</span>]   │\n",
       "├─────────────────────┼───────────────────┼────────────┼───────────────────┤\n",
       "│ layer_normalizatio… │ (<span style=\"color: #00d7ff; text-decoration-color: #00d7ff\">None</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">12</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">64</span>)    │        <span style=\"color: #00af00; text-decoration-color: #00af00\">128</span> │ add_3[<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\">LayerNormalizatio…</span> │                   │            │                   │\n",
       "├─────────────────────┼───────────────────┼────────────┼───────────────────┤\n",
       "│ global_average_poo… │ (<span style=\"color: #00d7ff; text-decoration-color: #00d7ff\">None</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">64</span>)        │          <span style=\"color: #00af00; text-decoration-color: #00af00\">0</span> │ layer_normalizat… │\n",
       "│ (<span style=\"color: #0087ff; text-decoration-color: #0087ff\">GlobalAveragePool…</span> │                   │            │                   │\n",
       "├─────────────────────┼───────────────────┼────────────┼───────────────────┤\n",
       "│ score_input         │ (<span style=\"color: #00d7ff; text-decoration-color: #00d7ff\">None</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">1</span>)         │          <span style=\"color: #00af00; text-decoration-color: #00af00\">0</span> │ -                 │\n",
       "│ (<span style=\"color: #0087ff; text-decoration-color: #0087ff\">InputLayer</span>)        │                   │            │                   │\n",
       "├─────────────────────┼───────────────────┼────────────┼───────────────────┤\n",
       "│ concatenate         │ (<span style=\"color: #00d7ff; text-decoration-color: #00d7ff\">None</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">65</span>)        │          <span style=\"color: #00af00; text-decoration-color: #00af00\">0</span> │ global_average_p… │\n",
       "│ (<span style=\"color: #0087ff; text-decoration-color: #0087ff\">Concatenate</span>)       │                   │            │ score_input[<span style=\"color: #00af00; text-decoration-color: #00af00\">0</span>][<span style=\"color: #00af00; text-decoration-color: #00af00\">0</span>] │\n",
       "├─────────────────────┼───────────────────┼────────────┼───────────────────┤\n",
       "│ dense_5 (<span style=\"color: #0087ff; text-decoration-color: #0087ff\">Dense</span>)     │ (<span style=\"color: #00d7ff; text-decoration-color: #00d7ff\">None</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">64</span>)        │      <span style=\"color: #00af00; text-decoration-color: #00af00\">4,224</span> │ concatenate[<span style=\"color: #00af00; text-decoration-color: #00af00\">0</span>][<span style=\"color: #00af00; text-decoration-color: #00af00\">0</span>] │\n",
       "├─────────────────────┼───────────────────┼────────────┼───────────────────┤\n",
       "│ dropout_7 (<span style=\"color: #0087ff; text-decoration-color: #0087ff\">Dropout</span>) │ (<span style=\"color: #00d7ff; text-decoration-color: #00d7ff\">None</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">64</span>)        │          <span style=\"color: #00af00; text-decoration-color: #00af00\">0</span> │ dense_5[<span style=\"color: #00af00; text-decoration-color: #00af00\">0</span>][<span style=\"color: #00af00; text-decoration-color: #00af00\">0</span>]     │\n",
       "├─────────────────────┼───────────────────┼────────────┼───────────────────┤\n",
       "│ dense_6 (<span style=\"color: #0087ff; text-decoration-color: #0087ff\">Dense</span>)     │ (<span style=\"color: #00d7ff; text-decoration-color: #00d7ff\">None</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">1</span>)         │         <span style=\"color: #00af00; text-decoration-color: #00af00\">65</span> │ dropout_7[<span style=\"color: #00af00; text-decoration-color: #00af00\">0</span>][<span style=\"color: #00af00; text-decoration-color: #00af00\">0</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",
       "│ seq_input           │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m12\u001b[0m)        │          \u001b[38;5;34m0\u001b[0m │ -                 │\n",
       "│ (\u001b[38;5;33mInputLayer\u001b[0m)        │                   │            │                   │\n",
       "├─────────────────────┼───────────────────┼────────────┼───────────────────┤\n",
       "│ embedding_1         │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m12\u001b[0m, \u001b[38;5;34m64\u001b[0m)    │      \u001b[38;5;34m4,928\u001b[0m │ seq_input[\u001b[38;5;34m0\u001b[0m][\u001b[38;5;34m0\u001b[0m]   │\n",
       "│ (\u001b[38;5;33mEmbedding\u001b[0m)         │                   │            │                   │\n",
       "├─────────────────────┼───────────────────┼────────────┼───────────────────┤\n",
       "│ multi_head_attenti… │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m12\u001b[0m, \u001b[38;5;34m64\u001b[0m)    │     \u001b[38;5;34m33,216\u001b[0m │ embedding_1[\u001b[38;5;34m0\u001b[0m][\u001b[38;5;34m0\u001b[0m… │\n",
       "│ (\u001b[38;5;33mMultiHeadAttentio…\u001b[0m │                   │            │ embedding_1[\u001b[38;5;34m0\u001b[0m][\u001b[38;5;34m0\u001b[0m] │\n",
       "├─────────────────────┼───────────────────┼────────────┼───────────────────┤\n",
       "│ dropout_5 (\u001b[38;5;33mDropout\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m12\u001b[0m, \u001b[38;5;34m64\u001b[0m)    │          \u001b[38;5;34m0\u001b[0m │ multi_head_atten… │\n",
       "├─────────────────────┼───────────────────┼────────────┼───────────────────┤\n",
       "│ add_2 (\u001b[38;5;33mAdd\u001b[0m)         │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m12\u001b[0m, \u001b[38;5;34m64\u001b[0m)    │          \u001b[38;5;34m0\u001b[0m │ embedding_1[\u001b[38;5;34m0\u001b[0m][\u001b[38;5;34m0\u001b[0m… │\n",
       "│                     │                   │            │ dropout_5[\u001b[38;5;34m0\u001b[0m][\u001b[38;5;34m0\u001b[0m]   │\n",
       "├─────────────────────┼───────────────────┼────────────┼───────────────────┤\n",
       "│ layer_normalizatio… │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m12\u001b[0m, \u001b[38;5;34m64\u001b[0m)    │        \u001b[38;5;34m128\u001b[0m │ add_2[\u001b[38;5;34m0\u001b[0m][\u001b[38;5;34m0\u001b[0m]       │\n",
       "│ (\u001b[38;5;33mLayerNormalizatio…\u001b[0m │                   │            │                   │\n",
       "├─────────────────────┼───────────────────┼────────────┼───────────────────┤\n",
       "│ dense_3 (\u001b[38;5;33mDense\u001b[0m)     │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m12\u001b[0m, \u001b[38;5;34m64\u001b[0m)    │      \u001b[38;5;34m4,160\u001b[0m │ layer_normalizat… │\n",
       "├─────────────────────┼───────────────────┼────────────┼───────────────────┤\n",
       "│ dense_4 (\u001b[38;5;33mDense\u001b[0m)     │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m12\u001b[0m, \u001b[38;5;34m64\u001b[0m)    │      \u001b[38;5;34m4,160\u001b[0m │ dense_3[\u001b[38;5;34m0\u001b[0m][\u001b[38;5;34m0\u001b[0m]     │\n",
       "├─────────────────────┼───────────────────┼────────────┼───────────────────┤\n",
       "│ dropout_6 (\u001b[38;5;33mDropout\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m12\u001b[0m, \u001b[38;5;34m64\u001b[0m)    │          \u001b[38;5;34m0\u001b[0m │ dense_4[\u001b[38;5;34m0\u001b[0m][\u001b[38;5;34m0\u001b[0m]     │\n",
       "├─────────────────────┼───────────────────┼────────────┼───────────────────┤\n",
       "│ add_3 (\u001b[38;5;33mAdd\u001b[0m)         │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m12\u001b[0m, \u001b[38;5;34m64\u001b[0m)    │          \u001b[38;5;34m0\u001b[0m │ layer_normalizat… │\n",
       "│                     │                   │            │ dropout_6[\u001b[38;5;34m0\u001b[0m][\u001b[38;5;34m0\u001b[0m]   │\n",
       "├─────────────────────┼───────────────────┼────────────┼───────────────────┤\n",
       "│ layer_normalizatio… │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m12\u001b[0m, \u001b[38;5;34m64\u001b[0m)    │        \u001b[38;5;34m128\u001b[0m │ add_3[\u001b[38;5;34m0\u001b[0m][\u001b[38;5;34m0\u001b[0m]       │\n",
       "│ (\u001b[38;5;33mLayerNormalizatio…\u001b[0m │                   │            │                   │\n",
       "├─────────────────────┼───────────────────┼────────────┼───────────────────┤\n",
       "│ global_average_poo… │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m64\u001b[0m)        │          \u001b[38;5;34m0\u001b[0m │ layer_normalizat… │\n",
       "│ (\u001b[38;5;33mGlobalAveragePool…\u001b[0m │                   │            │                   │\n",
       "├─────────────────────┼───────────────────┼────────────┼───────────────────┤\n",
       "│ score_input         │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m1\u001b[0m)         │          \u001b[38;5;34m0\u001b[0m │ -                 │\n",
       "│ (\u001b[38;5;33mInputLayer\u001b[0m)        │                   │            │                   │\n",
       "├─────────────────────┼───────────────────┼────────────┼───────────────────┤\n",
       "│ concatenate         │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m65\u001b[0m)        │          \u001b[38;5;34m0\u001b[0m │ global_average_p… │\n",
       "│ (\u001b[38;5;33mConcatenate\u001b[0m)       │                   │            │ score_input[\u001b[38;5;34m0\u001b[0m][\u001b[38;5;34m0\u001b[0m] │\n",
       "├─────────────────────┼───────────────────┼────────────┼───────────────────┤\n",
       "│ dense_5 (\u001b[38;5;33mDense\u001b[0m)     │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m64\u001b[0m)        │      \u001b[38;5;34m4,224\u001b[0m │ concatenate[\u001b[38;5;34m0\u001b[0m][\u001b[38;5;34m0\u001b[0m] │\n",
       "├─────────────────────┼───────────────────┼────────────┼───────────────────┤\n",
       "│ dropout_7 (\u001b[38;5;33mDropout\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m64\u001b[0m)        │          \u001b[38;5;34m0\u001b[0m │ dense_5[\u001b[38;5;34m0\u001b[0m][\u001b[38;5;34m0\u001b[0m]     │\n",
       "├─────────────────────┼───────────────────┼────────────┼───────────────────┤\n",
       "│ dense_6 (\u001b[38;5;33mDense\u001b[0m)     │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m1\u001b[0m)         │         \u001b[38;5;34m65\u001b[0m │ dropout_7[\u001b[38;5;34m0\u001b[0m][\u001b[38;5;34m0\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\">51,009</span> (199.25 KB)\n",
       "</pre>\n"
      ],
      "text/plain": [
       "\u001b[1m Total params: \u001b[0m\u001b[38;5;34m51,009\u001b[0m (199.25 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\">51,009</span> (199.25 KB)\n",
       "</pre>\n"
      ],
      "text/plain": [
       "\u001b[1m Trainable params: \u001b[0m\u001b[38;5;34m51,009\u001b[0m (199.25 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"
    }
   ],
   "source": [
    "from tensorflow.keras.layers import Input, Embedding, MultiHeadAttention, Dropout, LayerNormalization, Dense, GlobalAveragePooling1D, concatenate\n",
    "from tensorflow.keras.models import Model\n",
    "\n",
    "seq_input = Input(shape=(max_seq_length,), dtype='int32', name='seq_input')\n",
    "score_input = Input(shape=(1,), name='score_input')\n",
    "\n",
    "embedding_layer = Embedding(input_dim=len(tokenizer.word_index)+1, output_dim=64)(seq_input)\n",
    "transformer_block = transformer_encoder(embedding_layer)\n",
    "seq_model_output = GlobalAveragePooling1D()(transformer_block)\n",
    "\n",
    "combined_features = concatenate([seq_model_output, score_input], axis=1)\n",
    "\n",
    "x = Dense(64, activation='relu')(combined_features)\n",
    "x = Dropout(0.1)(x)\n",
    "outputs = Dense(1, activation='sigmoid')(x)\n",
    "\n",
    "model_enriched = Model(inputs=[seq_input, score_input], outputs=outputs)\n",
    "model_enriched.compile(optimizer='adam', loss='binary_crossentropy', metrics=['accuracy'])\n",
    "\n",
    "model_enriched.summary()\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Training our new enriched model\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 1/3\n",
      "\u001b[1m44970/44970\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m377s\u001b[0m 8ms/step - accuracy: 0.9609 - loss: 0.1405 - val_accuracy: 0.9635 - val_loss: 0.1331\n",
      "Epoch 2/3\n",
      "\u001b[1m44970/44970\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m386s\u001b[0m 9ms/step - accuracy: 0.9635 - loss: 0.1328 - val_accuracy: 0.9638 - val_loss: 0.1310\n",
      "Epoch 3/3\n",
      "\u001b[1m44970/44970\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m395s\u001b[0m 9ms/step - accuracy: 0.9638 - loss: 0.1315 - val_accuracy: 0.9636 - val_loss: 0.1306\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<keras.src.callbacks.history.History at 0x1978d9e7da0>"
      ]
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "model_enriched.fit([X_train_seqs, X_train_scores], y_train, batch_size=32, epochs=3, validation_data=([X_test_seqs, X_test_scores], y_test))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Albeit very, very marginal, we observe improvements in the model on addition of the new feature in weighted scores of MOS sequences\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Saving our enriched model\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [],
   "source": [
    "model_enriched.save('enriched_model.keras')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\u001b[1m11243/11243\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m33s\u001b[0m 3ms/step\n",
      "F1 Score: 0.9058804913835266\n",
      "AUC Score: 0.9626290424677868\n",
      "Precision: 0.9577655432534372\n",
      "Recall: 0.859328093444681\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 800x600 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\tansw\\AppData\\Local\\Temp\\ipykernel_14852\\3906178938.py:36: FutureWarning: \n",
      "\n",
      "Passing `palette` without assigning `hue` is deprecated and will be removed in v0.14.0. Assign the `x` variable to `hue` and set `legend=False` for the same effect.\n",
      "\n",
      "  sns.barplot(x=metrics, y=values, palette='muted')\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1000x600 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "predictions_prob = model_enriched.predict([X_test_seqs, X_test_scores])\n",
    "predictions = (predictions_prob > 0.5).astype(\"int32\")\n",
    "\n",
    "f1 = f1_score(y_test, predictions)\n",
    "auc_score = roc_auc_score(y_test, predictions_prob)\n",
    "precision = precision_score(y_test, predictions)\n",
    "recall = recall_score(y_test, predictions)\n",
    "\n",
    "print(f\"F1 Score: {f1}\")\n",
    "print(f\"AUC Score: {auc_score}\")\n",
    "print(f\"Precision: {precision}\")\n",
    "print(f\"Recall: {recall}\")\n",
    "\n",
    "fpr, tpr, thresholds = roc_curve(y_test, predictions_prob)\n",
    "roc_auc = auc(fpr, tpr)\n",
    "\n",
    "plt.figure(figsize=(8, 6))\n",
    "plt.plot(fpr, tpr, color='darkorange', lw=2, label=f'ROC curve (area = {roc_auc:.2f})')\n",
    "plt.plot([0, 1], [0, 1], color='navy', lw=2, linestyle='--')\n",
    "plt.xlim([0.0, 1.0])\n",
    "plt.ylim([0.0, 1.05])\n",
    "plt.xlabel('False Positive Rate')\n",
    "plt.ylabel('True Positive Rate')\n",
    "plt.title('Receiver Operating Characteristic (ROC) Curve')\n",
    "plt.legend(loc=\"lower right\")\n",
    "plt.show()\n",
    "\n",
    "metrics = ['F1 Score', 'AUC Score', 'Precision', 'Recall']\n",
    "values = [f1, auc_score, precision, recall]\n",
    "\n",
    "plt.figure(figsize=(10, 6))\n",
    "sns.barplot(x=metrics, y=values, palette='muted')\n",
    "plt.title('Model Performance Metrics with Enriched Data')\n",
    "plt.ylabel('Score')\n",
    "plt.ylim(0, 1) \n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Again, we observe good performances on all metrics\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### LLM Incorporation\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Having obtained a newly enriched model, one that knows the significance of MOS sequences which lead to calls that go to the floor, we decided to take things up - several - notches.\n",
    "\n",
    "We were provided a dictionary file, consisting of definitions of MOS codes. \n",
    "\n",
    "Examples: AA - Activation, AG - Transferred from agent, AL - Account lookup\n",
    "\n",
    "Thus, we decided to leverage these definitions. Since they don't provide any inherent metrics, we decided to calculate our own - analyzing the \"seriousness\" of each definition.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Reading in the MOS definitions dictinary file."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "  code                  status\n",
      "0   AA              Activation\n",
      "1   AG  Transferred from agent\n",
      "2   AL          Account lookup\n",
      "3   AP    Address phone change\n",
      "4   AR         APR Information\n"
     ]
    }
   ],
   "source": [
    "mos_definitions_df = pd.read_csv('./dictionary_files/mos.csv')\n",
    "\n",
    "print(mos_definitions_df.head())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "First, we decide to use Google's BERT (from Hugging Face Transformers library)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from transformers import BertTokenizer, TFBertModel\n",
    "import tensorflow as tf\n",
    "\n",
    "tokenizer = BertTokenizer.from_pretrained('bert-base-uncased')\n",
    "model_bert = TFBertModel.from_pretrained('bert-base-uncased')\n",
    "\n",
    "def get_code_embedding(text):\n",
    "    inputs = tokenizer(text, return_tensors=\"tf\", padding=True, truncation=True, max_length=512)\n",
    "    outputs = model_bert(inputs)\n",
    "    return outputs.pooler_output"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We obtain \"embeddings\" for the MOS sequence."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "mos_definitions_df['embedding'] = mos_definitions_df['Definition'].apply(get_code_embedding)\n",
    "\n",
    "code_to_embedding = {row['Code']: row['embedding'].numpy()[0] for index, row in mos_definitions_df.iterrows()}\n",
    "\n",
    "def mos_to_avg_embedding(mos, code_to_embedding):\n",
    "    codes = mos.split() \n",
    "    embeddings = [code_to_embedding[code] for code in codes if code in code_to_embedding]\n",
    "    if embeddings:\n",
    "        return np.mean(embeddings, axis=0)\n",
    "    else:\n",
    "        return np.zeros((768,)) \n",
    "\n",
    "df['mos_embedding'] = df['mos'].apply(lambda x: mos_to_avg_embedding(x, code_to_embedding))\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "But we realize, a transformer like BERT can't understand \"seriousness\" - not in the way we want it to.\n",
    "\n",
    "Thus, we decide to use OpenAI's GPT-3.5 Turbo API."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Using OpenAI's GPT-3.5 Turbo API"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We leverage OpenAI's library, using our API keys [redacted], and provide an extensive prompt explaining our intentions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import openai\n",
    "\n",
    "mos_df = pd.read_csv('./dictionary_files/mos.csv') \n",
    "\n",
    "openai.api_key = ''\n",
    "\n",
    "def get_seriousness_score(status):\n",
    "    response = openai.Completion.create(\n",
    "      model=\"text-davinci-003\",\n",
    "      prompt=f\"In the context of an IVR system, rate the seriousness of the following description on a scale of 1 to 10: {status}. We call it serious when the description has keywords which indicate that the call should be relayed to a human, as opposed to being handled by an automated system.\",\n",
    "      temperature=0,\n",
    "      max_tokens=60,\n",
    "      top_p=1.0,\n",
    "      frequency_penalty=0.0,\n",
    "      presence_penalty=0.0,\n",
    "      stop=[\"\\n\"]\n",
    "    )\n",
    "    try:\n",
    "        score = [int(s) for s in response.choices[0].text.split() if s.isdigit()][0]\n",
    "        return score\n",
    "    except IndexError:\n",
    "        return None \n",
    "\n",
    "mos_df['seriousness_score'] = mos_df['status'].apply(get_seriousness_score)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We obtain seriousness scores for all definitions, and subsequently, normalize them"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "mos_with_scores_df = pd.read_csv('./dictionary_files/mos_with_score.csv')\n",
    "mos_with_scores_df['seriousness_score_norm'] = (mos_with_scores_df['seriousness_score'] - 1) / (10 - 1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Having obtained scores for all codes, we look at all the MOS sequences present in our dataset and calculate average seriousness for a given MOS sequence for all rows"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_avg_seriousness_for_mos(mos_sequence, code_to_seriousness):\n",
    "    codes = mos_sequence.split()\n",
    "    seriousness_scores = [code_to_seriousness.get(code, 0) for code in codes]\n",
    "    avg_seriousness = np.mean(seriousness_scores) if seriousness_scores else 0\n",
    "    return avg_seriousness\n",
    "\n",
    "code_to_seriousness = pd.Series(mos_with_scores_df['seriousness_score_norm'].values, index=mos_with_scores_df['code']).to_dict()\n",
    "\n",
    "df_enriched['avg_seriousness'] = df_enriched['mos'].apply(lambda x: get_avg_seriousness_for_mos(x, code_to_seriousness))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>timestamp_call_key</th>\n",
       "      <th>retailer_code</th>\n",
       "      <th>serial</th>\n",
       "      <th>reason</th>\n",
       "      <th>mos</th>\n",
       "      <th>resolved</th>\n",
       "      <th>no_of_accounts_with_syf_13_march</th>\n",
       "      <th>account_balance_13_march</th>\n",
       "      <th>delinquency_history_13_march</th>\n",
       "      <th>account_open_date_13_march</th>\n",
       "      <th>...</th>\n",
       "      <th>account_open_date_18_march</th>\n",
       "      <th>account_status_18_march</th>\n",
       "      <th>card_activation_status_18_march</th>\n",
       "      <th>eservice_ind_18_march</th>\n",
       "      <th>ebill_enrolled_status_18_march</th>\n",
       "      <th>auto_pay_enrolled_status_18_march</th>\n",
       "      <th>date_of_call</th>\n",
       "      <th>time_of_call</th>\n",
       "      <th>weighted_score</th>\n",
       "      <th>avg_seriousness</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>240315173250 DAL1OA3M</td>\n",
       "      <td>D</td>\n",
       "      <td>10010009499</td>\n",
       "      <td>PP</td>\n",
       "      <td>IA PP TR</td>\n",
       "      <td>resolved</td>\n",
       "      <td>1.0</td>\n",
       "      <td>NaN</td>\n",
       "      <td>[00]</td>\n",
       "      <td>5/19/2013</td>\n",
       "      <td>...</td>\n",
       "      <td>5/19/2013</td>\n",
       "      <td>N</td>\n",
       "      <td>0</td>\n",
       "      <td>1</td>\n",
       "      <td>E</td>\n",
       "      <td>0</td>\n",
       "      <td>03/15/2024</td>\n",
       "      <td>17:32:50</td>\n",
       "      <td>9.519088</td>\n",
       "      <td>0.370370</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>240315124742 DAL15XHK</td>\n",
       "      <td>E</td>\n",
       "      <td>10006021998</td>\n",
       "      <td>BA</td>\n",
       "      <td>IA BA TS nl TR</td>\n",
       "      <td>floor</td>\n",
       "      <td>2.0</td>\n",
       "      <td>143.28</td>\n",
       "      <td>[00]</td>\n",
       "      <td>9/22/2003</td>\n",
       "      <td>...</td>\n",
       "      <td>9/22/2003</td>\n",
       "      <td>N</td>\n",
       "      <td>0</td>\n",
       "      <td>1</td>\n",
       "      <td>E</td>\n",
       "      <td>0</td>\n",
       "      <td>03/15/2024</td>\n",
       "      <td>12:47:42</td>\n",
       "      <td>164.932199</td>\n",
       "      <td>0.266667</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "<p>2 rows × 28 columns</p>\n",
       "</div>"
      ],
      "text/plain": [
       "      timestamp_call_key retailer_code       serial reason             mos  \\\n",
       "0  240315173250 DAL1OA3M             D  10010009499     PP        IA PP TR   \n",
       "1  240315124742 DAL15XHK             E  10006021998     BA  IA BA TS nl TR   \n",
       "\n",
       "   resolved  no_of_accounts_with_syf_13_march  account_balance_13_march  \\\n",
       "0  resolved                               1.0                       NaN   \n",
       "1     floor                               2.0                    143.28   \n",
       "\n",
       "  delinquency_history_13_march account_open_date_13_march  ...  \\\n",
       "0                         [00]                  5/19/2013  ...   \n",
       "1                         [00]                  9/22/2003  ...   \n",
       "\n",
       "  account_open_date_18_march  account_status_18_march  \\\n",
       "0                  5/19/2013                        N   \n",
       "1                  9/22/2003                        N   \n",
       "\n",
       "   card_activation_status_18_march eservice_ind_18_march  \\\n",
       "0                                0                     1   \n",
       "1                                0                     1   \n",
       "\n",
       "   ebill_enrolled_status_18_march  auto_pay_enrolled_status_18_march  \\\n",
       "0                               E                                  0   \n",
       "1                               E                                  0   \n",
       "\n",
       "   date_of_call time_of_call weighted_score avg_seriousness  \n",
       "0    03/15/2024     17:32:50       9.519088        0.370370  \n",
       "1    03/15/2024     12:47:42     164.932199        0.266667  \n",
       "\n",
       "[2 rows x 28 columns]"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df_enriched.head(2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We further normalize the average seriousness scores obtained"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "avg_seriousness_norm = scaler.fit_transform(df_enriched[['avg_seriousness']].fillna(0))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We split the dataset for our model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "X_train_seqs, X_test_seqs, X_train_scores, X_test_scores, X_train_seriousness, X_test_seriousness, y_train, y_test = train_test_split(\n",
    "    seqs_padded, weighted_scores_norm, avg_seriousness_norm, labels_enriched, test_size=0.2, random_state=42)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Next, we leverage our previously created Transformer model, enriching it with the new feature of seriousness scores provided by the LLMs."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "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_3\"</span>\n",
       "</pre>\n"
      ],
      "text/plain": [
       "\u001b[1mModel: \"functional_3\"\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",
       "│ seq_input           │ (<span style=\"color: #00d7ff; text-decoration-color: #00d7ff\">None</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">12</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_2         │ (<span style=\"color: #00d7ff; text-decoration-color: #00d7ff\">None</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">12</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">64</span>)    │      <span style=\"color: #00af00; text-decoration-color: #00af00\">4,928</span> │ seq_input[<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\">Embedding</span>)         │                   │            │                   │\n",
       "├─────────────────────┼───────────────────┼────────────┼───────────────────┤\n",
       "│ multi_head_attenti… │ (<span style=\"color: #00d7ff; text-decoration-color: #00d7ff\">None</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">12</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">64</span>)    │     <span style=\"color: #00af00; text-decoration-color: #00af00\">33,216</span> │ embedding_2[<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\">MultiHeadAttentio…</span> │                   │            │ embedding_2[<span style=\"color: #00af00; text-decoration-color: #00af00\">0</span>][<span style=\"color: #00af00; text-decoration-color: #00af00\">0</span>] │\n",
       "├─────────────────────┼───────────────────┼────────────┼───────────────────┤\n",
       "│ dropout_6 (<span style=\"color: #0087ff; text-decoration-color: #0087ff\">Dropout</span>) │ (<span style=\"color: #00d7ff; text-decoration-color: #00d7ff\">None</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">12</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">64</span>)    │          <span style=\"color: #00af00; text-decoration-color: #00af00\">0</span> │ multi_head_atten… │\n",
       "├─────────────────────┼───────────────────┼────────────┼───────────────────┤\n",
       "│ add_2 (<span style=\"color: #0087ff; text-decoration-color: #0087ff\">Add</span>)         │ (<span style=\"color: #00d7ff; text-decoration-color: #00d7ff\">None</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">12</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">64</span>)    │          <span style=\"color: #00af00; text-decoration-color: #00af00\">0</span> │ embedding_2[<span style=\"color: #00af00; text-decoration-color: #00af00\">0</span>][<span style=\"color: #00af00; text-decoration-color: #00af00\">0</span>… │\n",
       "│                     │                   │            │ dropout_6[<span style=\"color: #00af00; text-decoration-color: #00af00\">0</span>][<span style=\"color: #00af00; text-decoration-color: #00af00\">0</span>]   │\n",
       "├─────────────────────┼───────────────────┼────────────┼───────────────────┤\n",
       "│ layer_normalizatio… │ (<span style=\"color: #00d7ff; text-decoration-color: #00d7ff\">None</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">12</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">64</span>)    │        <span style=\"color: #00af00; text-decoration-color: #00af00\">128</span> │ add_2[<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\">LayerNormalizatio…</span> │                   │            │                   │\n",
       "├─────────────────────┼───────────────────┼────────────┼───────────────────┤\n",
       "│ dense_3 (<span style=\"color: #0087ff; text-decoration-color: #0087ff\">Dense</span>)     │ (<span style=\"color: #00d7ff; text-decoration-color: #00d7ff\">None</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">12</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">64</span>)    │      <span style=\"color: #00af00; text-decoration-color: #00af00\">4,160</span> │ layer_normalizat… │\n",
       "├─────────────────────┼───────────────────┼────────────┼───────────────────┤\n",
       "│ dense_4 (<span style=\"color: #0087ff; text-decoration-color: #0087ff\">Dense</span>)     │ (<span style=\"color: #00d7ff; text-decoration-color: #00d7ff\">None</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">12</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">64</span>)    │      <span style=\"color: #00af00; text-decoration-color: #00af00\">4,160</span> │ dense_3[<span style=\"color: #00af00; text-decoration-color: #00af00\">0</span>][<span style=\"color: #00af00; text-decoration-color: #00af00\">0</span>]     │\n",
       "├─────────────────────┼───────────────────┼────────────┼───────────────────┤\n",
       "│ dropout_7 (<span style=\"color: #0087ff; text-decoration-color: #0087ff\">Dropout</span>) │ (<span style=\"color: #00d7ff; text-decoration-color: #00d7ff\">None</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">12</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">64</span>)    │          <span style=\"color: #00af00; text-decoration-color: #00af00\">0</span> │ dense_4[<span style=\"color: #00af00; text-decoration-color: #00af00\">0</span>][<span style=\"color: #00af00; text-decoration-color: #00af00\">0</span>]     │\n",
       "├─────────────────────┼───────────────────┼────────────┼───────────────────┤\n",
       "│ add_3 (<span style=\"color: #0087ff; text-decoration-color: #0087ff\">Add</span>)         │ (<span style=\"color: #00d7ff; text-decoration-color: #00d7ff\">None</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">12</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">64</span>)    │          <span style=\"color: #00af00; text-decoration-color: #00af00\">0</span> │ layer_normalizat… │\n",
       "│                     │                   │            │ dropout_7[<span style=\"color: #00af00; text-decoration-color: #00af00\">0</span>][<span style=\"color: #00af00; text-decoration-color: #00af00\">0</span>]   │\n",
       "├─────────────────────┼───────────────────┼────────────┼───────────────────┤\n",
       "│ layer_normalizatio… │ (<span style=\"color: #00d7ff; text-decoration-color: #00d7ff\">None</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">12</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">64</span>)    │        <span style=\"color: #00af00; text-decoration-color: #00af00\">128</span> │ add_3[<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\">LayerNormalizatio…</span> │                   │            │                   │\n",
       "├─────────────────────┼───────────────────┼────────────┼───────────────────┤\n",
       "│ global_average_poo… │ (<span style=\"color: #00d7ff; text-decoration-color: #00d7ff\">None</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">64</span>)        │          <span style=\"color: #00af00; text-decoration-color: #00af00\">0</span> │ layer_normalizat… │\n",
       "│ (<span style=\"color: #0087ff; text-decoration-color: #0087ff\">GlobalAveragePool…</span> │                   │            │                   │\n",
       "├─────────────────────┼───────────────────┼────────────┼───────────────────┤\n",
       "│ weighted_score_inp… │ (<span style=\"color: #00d7ff; text-decoration-color: #00d7ff\">None</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">1</span>)         │          <span style=\"color: #00af00; text-decoration-color: #00af00\">0</span> │ -                 │\n",
       "│ (<span style=\"color: #0087ff; text-decoration-color: #0087ff\">InputLayer</span>)        │                   │            │                   │\n",
       "├─────────────────────┼───────────────────┼────────────┼───────────────────┤\n",
       "│ avg_seriousness_in… │ (<span style=\"color: #00d7ff; text-decoration-color: #00d7ff\">None</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">1</span>)         │          <span style=\"color: #00af00; text-decoration-color: #00af00\">0</span> │ -                 │\n",
       "│ (<span style=\"color: #0087ff; text-decoration-color: #0087ff\">InputLayer</span>)        │                   │            │                   │\n",
       "├─────────────────────┼───────────────────┼────────────┼───────────────────┤\n",
       "│ concatenate         │ (<span style=\"color: #00d7ff; text-decoration-color: #00d7ff\">None</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">66</span>)        │          <span style=\"color: #00af00; text-decoration-color: #00af00\">0</span> │ global_average_p… │\n",
       "│ (<span style=\"color: #0087ff; text-decoration-color: #0087ff\">Concatenate</span>)       │                   │            │ weighted_score_i… │\n",
       "│                     │                   │            │ avg_seriousness_… │\n",
       "├─────────────────────┼───────────────────┼────────────┼───────────────────┤\n",
       "│ dense_5 (<span style=\"color: #0087ff; text-decoration-color: #0087ff\">Dense</span>)     │ (<span style=\"color: #00d7ff; text-decoration-color: #00d7ff\">None</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">64</span>)        │      <span style=\"color: #00af00; text-decoration-color: #00af00\">4,288</span> │ concatenate[<span style=\"color: #00af00; text-decoration-color: #00af00\">0</span>][<span style=\"color: #00af00; text-decoration-color: #00af00\">0</span>] │\n",
       "├─────────────────────┼───────────────────┼────────────┼───────────────────┤\n",
       "│ dropout_8 (<span style=\"color: #0087ff; text-decoration-color: #0087ff\">Dropout</span>) │ (<span style=\"color: #00d7ff; text-decoration-color: #00d7ff\">None</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">64</span>)        │          <span style=\"color: #00af00; text-decoration-color: #00af00\">0</span> │ dense_5[<span style=\"color: #00af00; text-decoration-color: #00af00\">0</span>][<span style=\"color: #00af00; text-decoration-color: #00af00\">0</span>]     │\n",
       "├─────────────────────┼───────────────────┼────────────┼───────────────────┤\n",
       "│ dense_6 (<span style=\"color: #0087ff; text-decoration-color: #0087ff\">Dense</span>)     │ (<span style=\"color: #00d7ff; text-decoration-color: #00d7ff\">None</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">1</span>)         │         <span style=\"color: #00af00; text-decoration-color: #00af00\">65</span> │ dropout_8[<span style=\"color: #00af00; text-decoration-color: #00af00\">0</span>][<span style=\"color: #00af00; text-decoration-color: #00af00\">0</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",
       "│ seq_input           │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m12\u001b[0m)        │          \u001b[38;5;34m0\u001b[0m │ -                 │\n",
       "│ (\u001b[38;5;33mInputLayer\u001b[0m)        │                   │            │                   │\n",
       "├─────────────────────┼───────────────────┼────────────┼───────────────────┤\n",
       "│ embedding_2         │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m12\u001b[0m, \u001b[38;5;34m64\u001b[0m)    │      \u001b[38;5;34m4,928\u001b[0m │ seq_input[\u001b[38;5;34m0\u001b[0m][\u001b[38;5;34m0\u001b[0m]   │\n",
       "│ (\u001b[38;5;33mEmbedding\u001b[0m)         │                   │            │                   │\n",
       "├─────────────────────┼───────────────────┼────────────┼───────────────────┤\n",
       "│ multi_head_attenti… │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m12\u001b[0m, \u001b[38;5;34m64\u001b[0m)    │     \u001b[38;5;34m33,216\u001b[0m │ embedding_2[\u001b[38;5;34m0\u001b[0m][\u001b[38;5;34m0\u001b[0m… │\n",
       "│ (\u001b[38;5;33mMultiHeadAttentio…\u001b[0m │                   │            │ embedding_2[\u001b[38;5;34m0\u001b[0m][\u001b[38;5;34m0\u001b[0m] │\n",
       "├─────────────────────┼───────────────────┼────────────┼───────────────────┤\n",
       "│ dropout_6 (\u001b[38;5;33mDropout\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m12\u001b[0m, \u001b[38;5;34m64\u001b[0m)    │          \u001b[38;5;34m0\u001b[0m │ multi_head_atten… │\n",
       "├─────────────────────┼───────────────────┼────────────┼───────────────────┤\n",
       "│ add_2 (\u001b[38;5;33mAdd\u001b[0m)         │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m12\u001b[0m, \u001b[38;5;34m64\u001b[0m)    │          \u001b[38;5;34m0\u001b[0m │ embedding_2[\u001b[38;5;34m0\u001b[0m][\u001b[38;5;34m0\u001b[0m… │\n",
       "│                     │                   │            │ dropout_6[\u001b[38;5;34m0\u001b[0m][\u001b[38;5;34m0\u001b[0m]   │\n",
       "├─────────────────────┼───────────────────┼────────────┼───────────────────┤\n",
       "│ layer_normalizatio… │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m12\u001b[0m, \u001b[38;5;34m64\u001b[0m)    │        \u001b[38;5;34m128\u001b[0m │ add_2[\u001b[38;5;34m0\u001b[0m][\u001b[38;5;34m0\u001b[0m]       │\n",
       "│ (\u001b[38;5;33mLayerNormalizatio…\u001b[0m │                   │            │                   │\n",
       "├─────────────────────┼───────────────────┼────────────┼───────────────────┤\n",
       "│ dense_3 (\u001b[38;5;33mDense\u001b[0m)     │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m12\u001b[0m, \u001b[38;5;34m64\u001b[0m)    │      \u001b[38;5;34m4,160\u001b[0m │ layer_normalizat… │\n",
       "├─────────────────────┼───────────────────┼────────────┼───────────────────┤\n",
       "│ dense_4 (\u001b[38;5;33mDense\u001b[0m)     │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m12\u001b[0m, \u001b[38;5;34m64\u001b[0m)    │      \u001b[38;5;34m4,160\u001b[0m │ dense_3[\u001b[38;5;34m0\u001b[0m][\u001b[38;5;34m0\u001b[0m]     │\n",
       "├─────────────────────┼───────────────────┼────────────┼───────────────────┤\n",
       "│ dropout_7 (\u001b[38;5;33mDropout\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m12\u001b[0m, \u001b[38;5;34m64\u001b[0m)    │          \u001b[38;5;34m0\u001b[0m │ dense_4[\u001b[38;5;34m0\u001b[0m][\u001b[38;5;34m0\u001b[0m]     │\n",
       "├─────────────────────┼───────────────────┼────────────┼───────────────────┤\n",
       "│ add_3 (\u001b[38;5;33mAdd\u001b[0m)         │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m12\u001b[0m, \u001b[38;5;34m64\u001b[0m)    │          \u001b[38;5;34m0\u001b[0m │ layer_normalizat… │\n",
       "│                     │                   │            │ dropout_7[\u001b[38;5;34m0\u001b[0m][\u001b[38;5;34m0\u001b[0m]   │\n",
       "├─────────────────────┼───────────────────┼────────────┼───────────────────┤\n",
       "│ layer_normalizatio… │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m12\u001b[0m, \u001b[38;5;34m64\u001b[0m)    │        \u001b[38;5;34m128\u001b[0m │ add_3[\u001b[38;5;34m0\u001b[0m][\u001b[38;5;34m0\u001b[0m]       │\n",
       "│ (\u001b[38;5;33mLayerNormalizatio…\u001b[0m │                   │            │                   │\n",
       "├─────────────────────┼───────────────────┼────────────┼───────────────────┤\n",
       "│ global_average_poo… │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m64\u001b[0m)        │          \u001b[38;5;34m0\u001b[0m │ layer_normalizat… │\n",
       "│ (\u001b[38;5;33mGlobalAveragePool…\u001b[0m │                   │            │                   │\n",
       "├─────────────────────┼───────────────────┼────────────┼───────────────────┤\n",
       "│ weighted_score_inp… │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m1\u001b[0m)         │          \u001b[38;5;34m0\u001b[0m │ -                 │\n",
       "│ (\u001b[38;5;33mInputLayer\u001b[0m)        │                   │            │                   │\n",
       "├─────────────────────┼───────────────────┼────────────┼───────────────────┤\n",
       "│ avg_seriousness_in… │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m1\u001b[0m)         │          \u001b[38;5;34m0\u001b[0m │ -                 │\n",
       "│ (\u001b[38;5;33mInputLayer\u001b[0m)        │                   │            │                   │\n",
       "├─────────────────────┼───────────────────┼────────────┼───────────────────┤\n",
       "│ concatenate         │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m66\u001b[0m)        │          \u001b[38;5;34m0\u001b[0m │ global_average_p… │\n",
       "│ (\u001b[38;5;33mConcatenate\u001b[0m)       │                   │            │ weighted_score_i… │\n",
       "│                     │                   │            │ avg_seriousness_… │\n",
       "├─────────────────────┼───────────────────┼────────────┼───────────────────┤\n",
       "│ dense_5 (\u001b[38;5;33mDense\u001b[0m)     │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m64\u001b[0m)        │      \u001b[38;5;34m4,288\u001b[0m │ concatenate[\u001b[38;5;34m0\u001b[0m][\u001b[38;5;34m0\u001b[0m] │\n",
       "├─────────────────────┼───────────────────┼────────────┼───────────────────┤\n",
       "│ dropout_8 (\u001b[38;5;33mDropout\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m64\u001b[0m)        │          \u001b[38;5;34m0\u001b[0m │ dense_5[\u001b[38;5;34m0\u001b[0m][\u001b[38;5;34m0\u001b[0m]     │\n",
       "├─────────────────────┼───────────────────┼────────────┼───────────────────┤\n",
       "│ dense_6 (\u001b[38;5;33mDense\u001b[0m)     │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m1\u001b[0m)         │         \u001b[38;5;34m65\u001b[0m │ dropout_8[\u001b[38;5;34m0\u001b[0m][\u001b[38;5;34m0\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\">51,073</span> (199.50 KB)\n",
       "</pre>\n"
      ],
      "text/plain": [
       "\u001b[1m Total params: \u001b[0m\u001b[38;5;34m51,073\u001b[0m (199.50 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\">51,073</span> (199.50 KB)\n",
       "</pre>\n"
      ],
      "text/plain": [
       "\u001b[1m Trainable params: \u001b[0m\u001b[38;5;34m51,073\u001b[0m (199.50 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"
    }
   ],
   "source": [
    "from tensorflow.keras.layers import Input, Embedding, MultiHeadAttention, Dropout, LayerNormalization, Dense, GlobalAveragePooling1D, Concatenate\n",
    "from tensorflow.keras.models import Model\n",
    "\n",
    "seq_input = Input(shape=(max_seq_length,), dtype='int32', name='seq_input')\n",
    "weighted_score_input = Input(shape=(1,), name='weighted_score_input')\n",
    "avg_seriousness_input = Input(shape=(1,), name='avg_seriousness_input')\n",
    "\n",
    "embedding_layer = Embedding(input_dim=len(tokenizer.word_index) + 1, output_dim=64)(seq_input)\n",
    "transformer_block = transformer_encoder(embedding_layer)\n",
    "seq_model_output = GlobalAveragePooling1D()(transformer_block)\n",
    "\n",
    "combined_features = Concatenate()([seq_model_output, weighted_score_input, avg_seriousness_input])\n",
    "\n",
    "x = Dense(64, activation='relu')(combined_features)\n",
    "x = Dropout(0.1)(x)\n",
    "outputs = Dense(1, activation='sigmoid')(x)\n",
    "\n",
    "model_enriched_with_avg_seriousness = Model(inputs=[seq_input, weighted_score_input, avg_seriousness_input], outputs=outputs)\n",
    "model_enriched_with_avg_seriousness.compile(optimizer='adam', loss='binary_crossentropy', metrics=['accuracy'])\n",
    "\n",
    "model_enriched_with_avg_seriousness.summary()\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Finally, we train our model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 1/3\n",
      "\u001b[1m44970/44970\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m350s\u001b[0m 8ms/step - accuracy: 0.9611 - loss: 0.1400 - val_accuracy: 0.9635 - val_loss: 0.1321\n",
      "Epoch 2/3\n",
      "\u001b[1m44970/44970\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m380s\u001b[0m 8ms/step - accuracy: 0.9636 - loss: 0.1324 - val_accuracy: 0.9636 - val_loss: 0.1311\n",
      "Epoch 3/3\n",
      "\u001b[1m44970/44970\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m386s\u001b[0m 9ms/step - accuracy: 0.9635 - loss: 0.1324 - val_accuracy: 0.9638 - val_loss: 0.1311\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<keras.src.callbacks.history.History at 0x1b813f8ce90>"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "model_enriched_with_avg_seriousness.fit(\n",
    "    [X_train_seqs, X_train_scores, X_train_seriousness], y_train,\n",
    "    batch_size=32, epochs=3,\n",
    "    validation_data=([X_test_seqs, X_test_scores, X_test_seriousness], y_test))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We observe, again, albeit marginal, improvements all around!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Subsequently, we calculate the same metrics as before, to observe how well the new model performs"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\u001b[1m11243/11243\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m35s\u001b[0m 3ms/step\n",
      "F1 Score: 0.9062839622573611\n",
      "AUC Score: 0.9627326265107251\n",
      "Precision: 0.958922887125516\n",
      "Recall: 0.8591234102941979\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 800x600 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\tansw\\AppData\\Local\\Temp\\ipykernel_10172\\832386307.py:40: FutureWarning: \n",
      "\n",
      "Passing `palette` without assigning `hue` is deprecated and will be removed in v0.14.0. Assign the `x` variable to `hue` and set `legend=False` for the same effect.\n",
      "\n",
      "  sns.barplot(x=metrics, y=values, palette='muted')\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1000x600 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "import seaborn as sns\n",
    "from sklearn.metrics import f1_score, roc_auc_score, precision_score, recall_score, roc_curve, auc\n",
    "\n",
    "predictions_prob = model_enriched_with_avg_seriousness.predict([X_test_seqs, X_test_scores, X_test_seriousness])\n",
    "predictions = (predictions_prob > 0.5).astype(\"int32\")\n",
    "\n",
    "f1 = f1_score(y_test, predictions)\n",
    "auc_score = roc_auc_score(y_test, predictions_prob)\n",
    "precision = precision_score(y_test, predictions)\n",
    "recall = recall_score(y_test, predictions)\n",
    "\n",
    "print(f\"F1 Score: {f1}\")\n",
    "print(f\"AUC Score: {auc_score}\")\n",
    "print(f\"Precision: {precision}\")\n",
    "print(f\"Recall: {recall}\")\n",
    "\n",
    "fpr, tpr, thresholds = roc_curve(y_test, predictions_prob)\n",
    "roc_auc = auc(fpr, tpr)\n",
    "\n",
    "plt.figure(figsize=(8, 6))\n",
    "plt.plot(fpr, tpr, color='darkorange', lw=2, label=f'ROC curve (area = {roc_auc:.2f})')\n",
    "plt.plot([0, 1], [0, 1], color='navy', lw=2, linestyle='--')\n",
    "plt.xlim([0.0, 1.0])\n",
    "plt.ylim([0.0, 1.05])\n",
    "plt.xlabel('False Positive Rate')\n",
    "plt.ylabel('True Positive Rate')\n",
    "plt.title('Receiver Operating Characteristic (ROC) Curve')\n",
    "plt.legend(loc=\"lower right\")\n",
    "plt.show()\n",
    "\n",
    "metrics = ['F1 Score', 'AUC Score', 'Precision', 'Recall']\n",
    "values = [f1, auc_score, precision, recall]\n",
    "\n",
    "plt.figure(figsize=(10, 6))\n",
    "sns.barplot(x=metrics, y=values, palette='muted')\n",
    "plt.title('Model Performance Metrics with Avg. Seriousness')\n",
    "plt.ylabel('Score')\n",
    "plt.ylim(0, 1) \n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Despite several constraints pertaining to the dataset and the descriptions' comprehensiveness (or lack thereof), we notice improvements on all scores!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We save our model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [],
   "source": [
    "model_enriched_with_avg_seriousness.save('model_enriched_with_avg_seriousness.keras') "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Widget to prediction resolution status\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "62cf10de06d840cc98e761005ac7b8b9",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Text(value='', description='MOS String:', placeholder='Type something')"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\u001b[1m1/1\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 159ms/step\n",
      "Resolved\n",
      "\u001b[1m1/1\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 16ms/step\n",
      "Resolved\n",
      "\u001b[1m1/1\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 20ms/step\n",
      "Floor\n",
      "\u001b[1m1/1\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 14ms/step\n",
      "Resolved\n",
      "\u001b[1m1/1\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 31ms/step\n",
      "Resolved\n",
      "\u001b[1m1/1\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 16ms/step\n",
      "Resolved\n",
      "\u001b[1m1/1\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 16ms/step\n",
      "Resolved\n",
      "\u001b[1m1/1\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 31ms/step\n",
      "Resolved\n",
      "\u001b[1m1/1\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 31ms/step\n",
      "Resolved\n",
      "\u001b[1m1/1\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 31ms/step\n",
      "Resolved\n",
      "\u001b[1m1/1\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 16ms/step\n",
      "Resolved\n",
      "\u001b[1m1/1\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 11ms/step\n",
      "Resolved\n",
      "\u001b[1m1/1\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 16ms/step\n",
      "Resolved\n",
      "\u001b[1m1/1\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 32ms/step\n",
      "Floor\n",
      "\u001b[1m1/1\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 31ms/step\n",
      "Resolved\n",
      "\u001b[1m1/1\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 7ms/step\n",
      "Resolved\n",
      "\u001b[1m1/1\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 282ms/step\n",
      "Resolved\n",
      "\u001b[1m1/1\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 43ms/step\n",
      "Resolved\n",
      "\u001b[1m1/1\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 47ms/step\n",
      "Resolved\n",
      "\u001b[1m1/1\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 31ms/step\n",
      "Resolved\n",
      "\u001b[1m1/1\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 32ms/step\n",
      "Resolved\n",
      "\u001b[1m1/1\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 33ms/step\n",
      "Resolved\n"
     ]
    }
   ],
   "source": [
    "import ipywidgets as widgets\n",
    "from tensorflow.keras.models import load_model\n",
    "from tensorflow.keras.preprocessing.sequence import pad_sequences\n",
    "from tensorflow.keras.preprocessing.text import Tokenizer\n",
    "import numpy as np\n",
    "\n",
    "tokenizer = Tokenizer()\n",
    "tokenizer.fit_on_texts(df_enriched['mos']) \n",
    "\n",
    "max_seq_length = max([len(seq) for seq in tokenizer.texts_to_sequences(df_enriched['mos'])])\n",
    "\n",
    "model = load_model('my_transformer_model.keras')\n",
    "\n",
    "def predict_mos(mos_string):\n",
    "    seq = tokenizer.texts_to_sequences([mos_string])\n",
    "    padded_seq = pad_sequences(seq, maxlen=max_seq_length, padding='post')\n",
    "    \n",
    "    prediction = model.predict(padded_seq)\n",
    "    \n",
    "    confidence = prediction[0][0]\n",
    "    result = \"Floor\" if confidence >= 0.5 else \"Resolved\"\n",
    "    print(f\"{result}\")\n",
    "\n",
    "text = widgets.Text(\n",
    "    value='',\n",
    "    placeholder='Type something',\n",
    "    description='MOS String:',\n",
    "    disabled=False\n",
    ")\n",
    "\n",
    "display(text)\n",
    "\n",
    "def on_type(change):\n",
    "    new_text = change['new']\n",
    "    text_without_spaces = new_text.replace(\" \", \"\")\n",
    "    \n",
    "    if len(text_without_spaces) % 2 == 0 and not new_text.endswith(\" \"):\n",
    "        predict_mos(new_text)\n",
    "\n",
    "text.observe(on_type, names='value')\n",
    "\n"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "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.12.2"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}