model_comparison.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "driving-factor",
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas as pd \n",
    "import numpy as np\n",
    "from typing import List, Optional\n",
    "import matplotlib.pyplot as plt\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "lyric-cincinnati",
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "from sklearn.metrics import roc_curve, auc\n",
    "\n",
    "def plot_roc_curve(models_data):\n",
    "    \"\"\"\n",
    "    Plots ROC curves for multiple models.\n",
    "\n",
    "    Parameters:\n",
    "    - models_data: Dictionary where keys are model names and values are a tuple containing true labels and predicted probabilities.\n",
    "    \"\"\"\n",
    "    \n",
    "    plt.figure(figsize=(10, 8))\n",
    "\n",
    "    # Plot the \"No Skill\" line\n",
    "    plt.plot([0, 1], [0, 1], linestyle='--', lw=2, color='r', alpha=0.8, label='Random Guess')\n",
    "\n",
    "    # Plot ROC curves for each model\n",
    "    for model_name, data in models_data.items():\n",
    "        y_true, predicted_probabilities = data\n",
    "        fpr, tpr, _ = roc_curve(y_true, predicted_probabilities)\n",
    "        roc_auc = auc(fpr, tpr)\n",
    "        plt.plot(fpr, tpr, lw=2, alpha=0.8, label=f'{model_name} (AUC = {roc_auc:.2f})')\n",
    "        \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.tight_layout()\n",
    "    plt.show()\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "virgin-mexican",
   "metadata": {},
   "source": [
    "### read our model results"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "balanced-programming",
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.metrics import roc_curve, auc\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "import numpy as np\n",
    "import torch\n",
    "from torch import nn\n",
    "import torch.nn.functional as F\n",
    "import pandas as pd\n",
    "from tqdm import tqdm\n",
    "from torch.utils.data import DataLoader, TensorDataset\n",
    "tqdm.pandas()\n",
    "import torch\n",
    "from torch import nn\n",
    "from torch.nn import Transformer\n",
    "from torch.utils.data import Dataset, DataLoader\n",
    "from torch.nn.utils.rnn import pad_sequence\n",
    "from sklearn.metrics import accuracy_score, f1_score, roc_auc_score\n",
    "from sklearn.model_selection import train_test_split\n",
    "import numpy as np\n",
    "\n",
    "from sklearn.metrics import average_precision_score\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "confused-trailer",
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "# Custom Dataset\n",
    "class MyDataset(Dataset):\n",
    "    def __init__(self, src_data, tgt_data):\n",
    "        self.src_data = [torch.tensor(seq, dtype=torch.float32) for seq in src_data]\n",
    "        self.tgt_data = [torch.tensor(tgt, dtype=torch.float32) for tgt in tgt_data]\n",
    "\n",
    "    def __len__(self):\n",
    "        return len(self.src_data)\n",
    "\n",
    "    def __getitem__(self, idx):\n",
    "        return self.src_data[idx], self.tgt_data[idx]\n",
    "\n",
    "# Custom Collate function to handle variable sequence length\n",
    "def collate_fn(batch):\n",
    "    src, tgt = zip(*batch)\n",
    "    src = pad_sequence(src, batch_first=True, padding_value=0)\n",
    "    tgt = pad_sequence(tgt, batch_first=True, padding_value=-1)  # Special padding value for target data\n",
    "    return src, tgt\n",
    "\n",
    "\n",
    "def create_masks(src):\n",
    "    src_key_padding_mask = (src == 0).all(axis=-1)\n",
    "    \n",
    "    # future_mask shape should be (seq_len, seq_len)\n",
    "    future_mask = torch.triu(torch.ones((src.shape[1], src.shape[1])), diagonal=1).bool()\n",
    "\n",
    "    return src_key_padding_mask, future_mask\n",
    "\n",
    "\n",
    "# Transformer Model\n",
    "class TransformerModel(nn.Module):\n",
    "    def __init__(self, input_dim, embedding_size, num_heads, num_layers, dropout):\n",
    "        super(TransformerModel, self).__init__()\n",
    "        self.embedding = nn.Linear(input_dim, embedding_size)\n",
    "        self.transformer = Transformer(\n",
    "            d_model=embedding_size,\n",
    "            nhead=num_heads,\n",
    "            num_encoder_layers=num_layers,\n",
    "            num_decoder_layers=num_layers,\n",
    "            dropout=dropout,\n",
    "        )\n",
    "        self.fc = nn.Linear(embedding_size, 1)\n",
    "\n",
    "    def forward(self, src, src_key_padding_mask=None, future_mask=None):\n",
    "        #print(np.shape(src))\n",
    "        src = self.embedding(src)\n",
    "        #print(np.shape(src))\n",
    "        src = src.transpose(0, 1) \n",
    "        #print(np.shape(src))\n",
    "        output = self.transformer.encoder(src, src_key_padding_mask=src_key_padding_mask, mask = future_mask)\n",
    "        #print(np.shape(output))\n",
    "        output = self.fc(output)\n",
    "        #print(np.shape(output))\n",
    "        output = torch.sigmoid(output)\n",
    "        #print(np.shape(output))\n",
    "        return output.transpose(0, 1).squeeze(-1)\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "eleven-finland",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Transformer KG Model\n",
    "# first KG_dims are word embedding vectors, will be put into a linear layer first to reduce the dim to KG_compress_dims\n",
    "# the compressed word embedding will be concated with the other features , and go through transformers \n",
    "class TransformerKGModel(nn.Module):\n",
    "    def __init__(self, KG_dims, KG_compress_dims, input_dim, embedding_size, num_heads, num_layers, dropout):\n",
    "        super(TransformerKGModel, self).__init__()\n",
    "        self.compress  = nn.Linear(KG_dims, KG_compress_dims)\n",
    "        #self.concat_dims = KG_compress_dims\n",
    "        self.embedding = nn.Linear(input_dim, embedding_size)\n",
    "        self.transformer = Transformer(\n",
    "            d_model=embedding_size,\n",
    "            nhead=num_heads,\n",
    "            num_encoder_layers=num_layers,\n",
    "            num_decoder_layers=num_layers,\n",
    "            dropout=dropout,\n",
    "        )\n",
    "        self.fc = nn.Linear(embedding_size, 1)\n",
    "\n",
    "    def forward(self, src, src_key_padding_mask=None, future_mask=None):\n",
    "        \n",
    "        KG_part = src[:,:,:self.compress.in_features] # first KG_dims features are word embeddings\n",
    "        \n",
    "        \n",
    "        other_parts = src[:,:, self.compress.in_features:] # [seq_len, batch_size, feature_size]\n",
    "        # Compress KG_part  to KG_compress_dims\n",
    "        compressed = self.compress(KG_part)  \n",
    "        # Concatenate with second part\n",
    "        src = torch.cat((compressed, other_parts), dim=-1)  \n",
    "        # Reshape for transformer\n",
    "   \n",
    "        #src = src.unsqueeze(1)\n",
    "        \n",
    "\n",
    "        src = self.embedding(src)\n",
    "\n",
    "        src = src.transpose(0, 1) \n",
    "\n",
    "        output = self.transformer.encoder(src, src_key_padding_mask=src_key_padding_mask, mask = future_mask)\n",
    "\n",
    "        output = self.fc(output)\n",
    "\n",
    "        output = torch.sigmoid(output)\n",
    "\n",
    "        return output.transpose(0, 1).squeeze(-1)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "rubber-simpson",
   "metadata": {},
   "outputs": [],
   "source": [
    "import pickle\n",
    "with open('./data/src_data_KG_0905.pkl', 'rb') as file1:\n",
    "    src_data = pickle.load(file1)\n",
    "    \n",
    "    \n",
    "with open('./data/tgt_data_KG_0905.pkl', 'rb') as file2:\n",
    "    tgt_data = pickle.load(file2)\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "identical-drive",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "33528 33528\n"
     ]
    }
   ],
   "source": [
    "print(len(src_data), len(tgt_data))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "fewer-westminster",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Split data into training and testing sets\n",
    "src_train, src_test, tgt_train, tgt_test = train_test_split(src_data, tgt_data, test_size=0.2, random_state=0)\n",
    "\n",
    "# Create datasets\n",
    "train_dataset = MyDataset(src_train, tgt_train)\n",
    "test_dataset = MyDataset(src_test, tgt_test)\n",
    "\n",
    "# Create data loaders\n",
    "train_dataloader = DataLoader(train_dataset, batch_size=8, shuffle=True, collate_fn=collate_fn)\n",
    "test_dataloader = DataLoader(test_dataset, batch_size=8, shuffle=False, collate_fn=collate_fn)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "stable-fortune",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2.0.1\n",
      "11.7\n",
      "Using CPU\n"
     ]
    }
   ],
   "source": [
    "import torch\n",
    "print(torch.__version__)\n",
    "print(torch.version.cuda)\n",
    "\n",
    "# Check if CUDA (GPU support) is available\n",
    "if torch.cuda.is_available():\n",
    "    device = torch.device(\"cuda\")\n",
    "    print(\"Using GPU:\", torch.cuda.get_device_name(0))\n",
    "else:\n",
    "    device = torch.device(\"cpu\")\n",
    "    print(\"Using CPU\")\n",
    "\n",
    "# Now, you can use `device` to send your tensors to the GPU or CPU.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "neither-winning",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "TransformerKGModel(\n",
       "  (compress): Linear(in_features=64, out_features=16, bias=True)\n",
       "  (embedding): Linear(in_features=32, out_features=32, bias=True)\n",
       "  (transformer): Transformer(\n",
       "    (encoder): TransformerEncoder(\n",
       "      (layers): ModuleList(\n",
       "        (0-1): 2 x TransformerEncoderLayer(\n",
       "          (self_attn): MultiheadAttention(\n",
       "            (out_proj): NonDynamicallyQuantizableLinear(in_features=32, out_features=32, bias=True)\n",
       "          )\n",
       "          (linear1): Linear(in_features=32, out_features=2048, bias=True)\n",
       "          (dropout): Dropout(p=0.2, inplace=False)\n",
       "          (linear2): Linear(in_features=2048, out_features=32, bias=True)\n",
       "          (norm1): LayerNorm((32,), eps=1e-05, elementwise_affine=True)\n",
       "          (norm2): LayerNorm((32,), eps=1e-05, elementwise_affine=True)\n",
       "          (dropout1): Dropout(p=0.2, inplace=False)\n",
       "          (dropout2): Dropout(p=0.2, inplace=False)\n",
       "        )\n",
       "      )\n",
       "      (norm): LayerNorm((32,), eps=1e-05, elementwise_affine=True)\n",
       "    )\n",
       "    (decoder): TransformerDecoder(\n",
       "      (layers): ModuleList(\n",
       "        (0-1): 2 x TransformerDecoderLayer(\n",
       "          (self_attn): MultiheadAttention(\n",
       "            (out_proj): NonDynamicallyQuantizableLinear(in_features=32, out_features=32, bias=True)\n",
       "          )\n",
       "          (multihead_attn): MultiheadAttention(\n",
       "            (out_proj): NonDynamicallyQuantizableLinear(in_features=32, out_features=32, bias=True)\n",
       "          )\n",
       "          (linear1): Linear(in_features=32, out_features=2048, bias=True)\n",
       "          (dropout): Dropout(p=0.2, inplace=False)\n",
       "          (linear2): Linear(in_features=2048, out_features=32, bias=True)\n",
       "          (norm1): LayerNorm((32,), eps=1e-05, elementwise_affine=True)\n",
       "          (norm2): LayerNorm((32,), eps=1e-05, elementwise_affine=True)\n",
       "          (norm3): LayerNorm((32,), eps=1e-05, elementwise_affine=True)\n",
       "          (dropout1): Dropout(p=0.2, inplace=False)\n",
       "          (dropout2): Dropout(p=0.2, inplace=False)\n",
       "          (dropout3): Dropout(p=0.2, inplace=False)\n",
       "        )\n",
       "      )\n",
       "      (norm): LayerNorm((32,), eps=1e-05, elementwise_affine=True)\n",
       "    )\n",
       "  )\n",
       "  (fc): Linear(in_features=32, out_features=1, bias=True)\n",
       ")"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# KG Transformer model\n",
    "KG_dims =64\n",
    "KG_compress_dims = 16\n",
    "input_dim = len(src_train[0][0]) -KG_dims + KG_compress_dims\n",
    "embedding_size = 16*2\n",
    "num_heads = 4\n",
    "num_layers = 2\n",
    "dropout = 0.2\n",
    "\n",
    "model= TransformerKGModel(KG_dims, KG_compress_dims, input_dim, embedding_size, num_heads, num_layers, dropout)\n",
    "\n",
    "# Step 2: Load the weights\n",
    "model_path = \"./data/memory_transformer_KG_v1_0905.pth\"\n",
    "model.load_state_dict(torch.load(model_path, map_location=device))\n",
    "model.to(device)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "municipal-advocacy",
   "metadata": {},
   "outputs": [],
   "source": [
    "model.eval()\n",
    "with torch.no_grad():\n",
    "    all_probs, all_preds, all_targets = [], [],[]\n",
    "    for src, tgt in test_dataloader:\n",
    "        src = src.to(device)\n",
    "\n",
    "        tgt = tgt.to(device)\n",
    "        # Create masks\n",
    "        src_key_padding_mask = (src == 0).all(axis=-1).to(device)\n",
    "\n",
    "        # Pass your sequences and mask through the model\n",
    "        output = model(src, src_key_padding_mask)\n",
    "\n",
    "        # Save predictions and targets\n",
    "        tgt_mask = (tgt != -1).to(device)\n",
    "        probs = output[tgt_mask].cpu().numpy()\n",
    "        preds = (output > 0.5).float()\n",
    "        all_probs.extend(probs)\n",
    "        all_preds.extend(preds[tgt_mask].cpu().numpy())\n",
    "        all_targets.extend(tgt[tgt_mask].cpu().numpy())\n",
    "\n",
    "    # Compute metrics\n",
    "    accuracy = accuracy_score(all_targets, all_preds)\n",
    "    f1 = f1_score(all_targets, all_preds)\n",
    "    roc_auc = roc_auc_score(all_targets, all_probs) if len(np.unique(all_targets)) > 1 else np.nan\n",
    "    avg_precision = average_precision_score(all_targets, all_probs)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "ecological-bundle",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4725894"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len(all_targets)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "structured-denver",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Accuracy: 0.792072568703403, F1 Score: 0.8583064395073848, ROC AUC: 0.838790699801552, Average Precision Score: 0.9220629361855226\n"
     ]
    }
   ],
   "source": [
    "print(f\"Accuracy: {accuracy}, F1 Score: {f1}, ROC AUC: {roc_auc}, Average Precision Score: {avg_precision}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "grateful-canal",
   "metadata": {},
   "source": [
    "### pick up the records where the word shows up at the first of a given day for each user , so that we can compare with benchmarks fairly"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "korean-usage",
   "metadata": {},
   "outputs": [],
   "source": [
    "# #'Y','spelling','review_time','uid', 'user_tenure','rsp1_rate',\n",
    "#        'rsp2_rate', 'rsp3_rate', 'rsp4_rate', 'acknowledge_rate', 'difficulty',  'study_method', 'repeat_time_inday',\n",
    "#        'real_delta_interval_within_inday', 'review_day_th',\n",
    "#        'delta_t_between_inday', 'delta_t_within_inday', 'repeat_time_history',\n",
    "#        'delta_interval_within_inday','last_real_interval_byday'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "smaller-tobacco",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "id": "documented-homeless",
   "metadata": {},
   "outputs": [],
   "source": [
    "model.eval()\n",
    "with torch.no_grad():\n",
    "    sub_all_probs, sub_all_preds, sub_all_targets = [], [],[]\n",
    "    for src, tgt in test_dataloader:\n",
    "        src = src.to(device)\n",
    "\n",
    "        tgt = tgt.to(device)\n",
    "        # Create masks\n",
    "        src_key_padding_mask = (src == 0).all(axis=-1).to(device)\n",
    "\n",
    "        # Pass your sequences and mask through the model\n",
    "        output = model(src, src_key_padding_mask)\n",
    "\n",
    "        # Save predictions and targets\n",
    "        tgt_mask = (tgt != -1).to(device)\n",
    "        \n",
    "        # condition 1:  the -8th feature is repeat_time_inday. ==1 meaning this word shows up first time in the specific day for the user.\n",
    "         # condition 2 : we exclude the word shown to customers first time in history \n",
    "        condition1 = src[...,-8]==1\n",
    "        condition2 = src[...,-1]!=0\n",
    "        combined_condition = condition1 & condition2\n",
    "        \n",
    "        indices = torch.nonzero(combined_condition)\n",
    "        output =output[indices[:, 0], indices[:, 1]]\n",
    "   \n",
    "        probs =output.cpu().numpy()\n",
    "        \n",
    "        \n",
    "        preds = (output > 0.5).float()\n",
    "        \n",
    "        sub_all_probs.extend(probs)\n",
    "        sub_all_preds.extend(preds.cpu().numpy())\n",
    "        sub_all_targets.extend(tgt[indices[:, 0], indices[:, 1]].cpu().numpy())\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "id": "unavailable-short",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "957191"
      ]
     },
     "execution_count": 40,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len(sub_all_targets)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "id": "complicated-gardening",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Compute metrics\n",
    "sub_accuracy = accuracy_score(sub_all_targets, sub_all_preds)\n",
    "sub_f1 = f1_score(sub_all_targets, sub_all_preds)\n",
    "sub_roc_auc = roc_auc_score(sub_all_targets, sub_all_probs) if len(np.unique(sub_all_targets)) > 1 else np.nan\n",
    "sub_avg_precision = average_precision_score(sub_all_targets, sub_all_probs)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "id": "twenty-relationship",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Accuracy: 0.7443582315337274, F1 Score: 0.8243230242819585, ROC AUC: 0.7669904946808391, Average Precision Score: 0.8778724440382282\n"
     ]
    }
   ],
   "source": [
    "print(f\"Accuracy: {sub_accuracy}, F1 Score: {sub_f1}, ROC AUC: {sub_roc_auc}, Average Precision Score: {sub_avg_precision}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "extended-blank",
   "metadata": {},
   "source": [
    "### read benchmark models results"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "id": "floating-conversation",
   "metadata": {},
   "outputs": [],
   "source": [
    "GRU_HLR_results = pd.read_csv('./data/GRU_HLR_results.csv')\n",
    "HLR_results = pd.read_csv('./data/HLR_results.csv')\n",
    "DHP_HLR_results = pd.read_csv('./data/DHP_HLR_results.csv')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "id": "severe-somalia",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "925165"
      ]
     },
     "execution_count": 44,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len(GRU_HLR_results.y_test)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "urban-british",
   "metadata": {},
   "source": [
    "## Model ROC Curves"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "id": "statewide-bouquet",
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "from sklearn.metrics import roc_curve, auc\n",
    "import seaborn as sns\n",
    "\n",
    "def plot_roc_curve2(models_data):\n",
    "    \"\"\"\n",
    "    Plots fancy ROC curves for multiple models.\n",
    "\n",
    "    Parameters:\n",
    "    - models_data: Dictionary where keys are model names and values are a tuple containing true labels and predicted probabilities.\n",
    "    \"\"\"\n",
    "    \n",
    "    plt.figure(figsize=(12, 10))\n",
    "    sns.set_style(\"whitegrid\")\n",
    "    \n",
    "    # Plot the \"No Skill\" line\n",
    "    plt.plot([0, 1], [0, 1], linestyle='--', lw=3, color='grey', alpha=0.7, label='Random Guess')\n",
    "\n",
    "    # Use a colormap to get color for the plots\n",
    "    colormap = plt.get_cmap('tab10')\n",
    "    \n",
    "    # Plot ROC curves for each model\n",
    "    for idx, (model_name, data) in enumerate(models_data.items()):\n",
    "        y_true, predicted_probabilities = data\n",
    "        fpr, tpr, _ = roc_curve(y_true, predicted_probabilities)\n",
    "        roc_auc = auc(fpr, tpr)\n",
    "        color = colormap(idx)\n",
    "        plt.plot(fpr, tpr, color=color, lw=2, alpha=0.8, label=model_name)\n",
    "        # Annotate the AUC on the plot\n",
    "        auc_x = fpr[np.argmin(np.abs(tpr - 0.5))]\n",
    "        auc_y = tpr[np.argmin(np.abs(tpr - 0.5))]\n",
    "        plt.annotate(f\"AUC: {roc_auc:.2f}\", (auc_x, auc_y), color=color, xytext=(-10,-10), textcoords='offset points')\n",
    "\n",
    "    plt.xlabel('False Positive Rate', fontsize=14)\n",
    "    plt.ylabel('True Positive Rate', fontsize=14)\n",
    "    plt.title('Receiver Operating Characteristic (ROC) Curve', fontsize=16)\n",
    "    plt.legend(loc='lower right', title='Models')\n",
    "    plt.tight_layout()\n",
    "    plt.show()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "id": "meaning-kansas",
   "metadata": {},
   "outputs": [],
   "source": [
    "models_data = {\n",
    "    'GRU_HLR': (GRU_HLR_results.y_test, GRU_HLR_results.y_prob.values),\n",
    "        'Duolingo_HLR': (HLR_results.y_test, HLR_results.y_prob.values),\n",
    "        'DHP_HLR': (DHP_HLR_results.y_test, DHP_HLR_results.y_prob.values),\n",
    "    \"KG_Transformer\": (all_targets,all_probs),\n",
    "    \"KG_Transformer_first\":(sub_all_targets, sub_all_probs)\n",
    "}\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "id": "historical-bloom",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1000x800 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plot_roc_curve(models_data)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "suited-conspiracy",
   "metadata": {},
   "source": [
    "## build performance table "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "id": "corrected-majority",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "GRU_HLR\n",
      "Duolingo_HLR\n",
      "DHP_HLR\n",
      "KG_Transformer\n",
      "KG_Transformer_first\n"
     ]
    }
   ],
   "source": [
    "from sklearn.metrics import log_loss, accuracy_score, f1_score, roc_auc_score, average_precision_score,hamming_loss,cohen_kappa_score,balanced_accuracy_score\n",
    "l =[]\n",
    "for model_name, data in models_data.items():\n",
    "    print(model_name)\n",
    "    y_true, predicted_probabilities = data\n",
    "    predicted_probabilities = np.array(predicted_probabilities)\n",
    "    y_pred_label = np.where(predicted_probabilities > 0.5, 1, 0)\n",
    "    accuracy = accuracy_score(y_true, y_pred_label)\n",
    "    f1 = f1_score(y_true, y_pred_label)\n",
    "    roc_auc = roc_auc_score(y_true, predicted_probabilities) if len(np.unique(y_true)) > 1 else np.nan\n",
    "    avg_precision = average_precision_score(y_true, predicted_probabilities)\n",
    "    Log_loss = log_loss(y_true,predicted_probabilities)\n",
    "    Hamming_loss = hamming_loss(y_true, y_pred_label)\n",
    "    cohen_kappa = cohen_kappa_score(y_true, y_pred_label)\n",
    "    balanced_accuracy = balanced_accuracy_score(y_true, y_pred_label)\n",
    "    l.append([model_name,accuracy,f1,roc_auc, avg_precision,Log_loss,Hamming_loss,cohen_kappa,balanced_accuracy])\n",
    "    \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "id": "iraqi-organization",
   "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>model_name</th>\n",
       "      <th>accuracy</th>\n",
       "      <th>f1</th>\n",
       "      <th>roc_auc</th>\n",
       "      <th>avg_precision</th>\n",
       "      <th>Log_loss</th>\n",
       "      <th>Hamming_loss</th>\n",
       "      <th>cohen_kappa</th>\n",
       "      <th>balanced_accuracy</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>GRU_HLR</td>\n",
       "      <td>0.700596</td>\n",
       "      <td>0.816889</td>\n",
       "      <td>0.628669</td>\n",
       "      <td>0.793185</td>\n",
       "      <td>0.608101</td>\n",
       "      <td>0.299404</td>\n",
       "      <td>0.071481</td>\n",
       "      <td>0.527857</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>Duolingo_HLR</td>\n",
       "      <td>0.704943</td>\n",
       "      <td>0.821376</td>\n",
       "      <td>0.621781</td>\n",
       "      <td>0.784095</td>\n",
       "      <td>0.622004</td>\n",
       "      <td>0.295057</td>\n",
       "      <td>0.064805</td>\n",
       "      <td>0.524711</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>DHP_HLR</td>\n",
       "      <td>0.704554</td>\n",
       "      <td>0.821662</td>\n",
       "      <td>0.604061</td>\n",
       "      <td>0.772706</td>\n",
       "      <td>0.599084</td>\n",
       "      <td>0.295446</td>\n",
       "      <td>0.057577</td>\n",
       "      <td>0.521815</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>KG_Transformer</td>\n",
       "      <td>0.792073</td>\n",
       "      <td>0.858306</td>\n",
       "      <td>0.838791</td>\n",
       "      <td>0.922063</td>\n",
       "      <td>0.437670</td>\n",
       "      <td>0.207927</td>\n",
       "      <td>0.469802</td>\n",
       "      <td>0.722380</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>KG_Transformer_first</td>\n",
       "      <td>0.744358</td>\n",
       "      <td>0.824323</td>\n",
       "      <td>0.766990</td>\n",
       "      <td>0.877872</td>\n",
       "      <td>0.517027</td>\n",
       "      <td>0.255642</td>\n",
       "      <td>0.356574</td>\n",
       "      <td>0.670732</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "             model_name  accuracy        f1   roc_auc  avg_precision  \\\n",
       "0               GRU_HLR  0.700596  0.816889  0.628669       0.793185   \n",
       "1          Duolingo_HLR  0.704943  0.821376  0.621781       0.784095   \n",
       "2               DHP_HLR  0.704554  0.821662  0.604061       0.772706   \n",
       "3        KG_Transformer  0.792073  0.858306  0.838791       0.922063   \n",
       "4  KG_Transformer_first  0.744358  0.824323  0.766990       0.877872   \n",
       "\n",
       "   Log_loss  Hamming_loss  cohen_kappa  balanced_accuracy  \n",
       "0  0.608101      0.299404     0.071481           0.527857  \n",
       "1  0.622004      0.295057     0.064805           0.524711  \n",
       "2  0.599084      0.295446     0.057577           0.521815  \n",
       "3  0.437670      0.207927     0.469802           0.722380  \n",
       "4  0.517027      0.255642     0.356574           0.670732  "
      ]
     },
     "execution_count": 49,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "performance_report= pd.DataFrame(l,columns = [\"model_name\",\"accuracy\",\"f1\",\"roc_auc\", \"avg_precision\",\"Log_loss\",\"Hamming_loss\",\"cohen_kappa\",\"balanced_accuracy\"])\n",
    "performance_report"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "id": "concerned-pricing",
   "metadata": {},
   "outputs": [],
   "source": [
    "performance_report.to_csv('./data/performance_comparison_report.csv',index=None)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "labeled-elements",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "cz",
   "language": "python",
   "name": "cz"
  },
  "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.11.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}