02-train_SIMPLE_CNN_RNN_fasttext_fr.ipynb

{
 "cells": [
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "606fa719",
   "metadata": {},
   "source": [
    "# Train SIMPLE_CNN_RNN"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "a8a5bd39",
   "metadata": {},
   "outputs": [],
   "source": [
    "import os\n",
    "\n",
    "import numpy as np\n",
    "import pandas as pd\n",
    "\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "import torch\n",
    "import torch.nn as nn\n",
    "from torch.nn.utils import clip_grad_norm_\n",
    "\n",
    "from tqdm import tqdm\n",
    "\n",
    "from rouge_score import rouge_scorer\n",
    "\n",
    "from utils_french.EmbMgr import EmbMgr\n",
    "from utils_french.Dataset import Dataset\n",
    "from utils_french.DataLoader import DataLoader\n",
    "from utils_french.preprocess_df import preprocess_df\n",
    "from utils_french.accuracy_nb_sent_per_doc import accuracy_nb_sent_per_doc_fn\n",
    "from utils_french.accuracy_prop_sent_per_doc import accuracy_prop_sent_per_doc_fn\n",
    "from utils_french.split_all_docs import split_all_docs\n",
    "\n",
    "from models.SIMPLE_CNN_RNN import SIMPLE_CNN_RNN\n",
    "\n",
    "from time import time\n",
    "\n",
    "import json\n",
    "import argparse"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "818410ea",
   "metadata": {},
   "outputs": [],
   "source": [
    "def is_notebook() -> bool:\n",
    "    try:\n",
    "        shell = get_ipython().__class__.__name__\n",
    "        if shell == 'ZMQInteractiveShell':\n",
    "            return True   # Jupyter notebook or qtconsole\n",
    "        elif shell == 'TerminalInteractiveShell':\n",
    "            return False  # Terminal running IPython\n",
    "        else:\n",
    "            return False  # Other type (?)\n",
    "    except NameError:\n",
    "        return False      # Probably standard Python interpreter"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "690fa032",
   "metadata": {},
   "outputs": [],
   "source": [
    "pd.set_option('display.max_columns', None)\n",
    "pd.set_option('display.max_rows', None)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "b2636e0b",
   "metadata": {},
   "source": [
    "## (Hyper-)parameters"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "6e7aad39",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Parse args if script mode\n",
    "parser = argparse.ArgumentParser(description='extractive summary')\n",
    "\n",
    "parser.add_argument('-is_graphic',type=int,default=1,choices=[0,1])\n",
    "parser.add_argument('-gpu_num',type=int,default=1)\n",
    "parser.add_argument('-batch_size',type=int,default=4)\n",
    "parser.add_argument('-epochs',type=int,default=100)\n",
    "parser.add_argument('-dataset',type=str,default=\"./data/wiki_geo_ratio_sc_0.5/\")\n",
    "parser.add_argument('-doc_col_name',type=str,default=\"flat_contents\")\n",
    "parser.add_argument('-label_col_name',type=str,default=\"labels_sentences\")\n",
    "parser.add_argument('-sum_col_name',type=str,default=\"summaries\")\n",
    "parser.add_argument('-max_doc_len',type=int,default=100)\n",
    "\n",
    "args = None\n",
    "\n",
    "if is_notebook():\n",
    "    args = parser.parse_args(\"\")\n",
    "else:\n",
    "    args = parser.parse_args()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "824eacf5",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "parse:\n",
      "is_graphic: True\n",
      "cuda_num: 1\n",
      "epochs 100\n",
      "batch_size 4\n"
     ]
    }
   ],
   "source": [
    "# parameters\n",
    "is_graphic = args.is_graphic != 0\n",
    "cuda_num = args.gpu_num\n",
    "embed_name = \"cc.fr.300.vec\"\n",
    "\n",
    "# hyper-parameters\n",
    "vocab_size = 150000\n",
    "batch_size = args.batch_size\n",
    "epochs = args.epochs\n",
    "learning_rate = 1e-3\n",
    "early_stopping = 3\n",
    "model_name = \"02-train_SIMPLE_CNN_RNN_FastTextfr\"\n",
    "sub_folder_name = \"model_name__{}__time__{}__embed_name__{}__lr__{}__batch_size__{}__vocab_size__{}__cuda_num__{}\".format(model_name, time(), embed_name, learning_rate, batch_size, vocab_size, cuda_num)\n",
    "checkpoints_folder = \"./checkpoints/\" + sub_folder_name\n",
    "average_number_of_sentences_per_document = 3\n",
    "\n",
    "# print\n",
    "print(\"parse:\")\n",
    "print(\"is_graphic:\", is_graphic)\n",
    "print(\"cuda_num:\", cuda_num)\n",
    "print(\"epochs\", epochs)\n",
    "print(\"batch_size\", batch_size)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "c8ddd4d5",
   "metadata": {},
   "source": [
    "## PyTorch initialisation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "d09bc3ed",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Number of available GPUs: 6\n",
      "GPU 0: NVIDIA GeForce GTX 1080 Ti\n",
      "GPU 1: NVIDIA GeForce GTX 1080 Ti\n",
      "GPU 2: NVIDIA GeForce GTX 1080 Ti\n",
      "GPU 3: NVIDIA GeForce GTX 1080\n",
      "GPU 4: NVIDIA GeForce GTX 1080\n",
      "GPU 5: NVIDIA GeForce GTX 1080\n"
     ]
    }
   ],
   "source": [
    "# Check if a GPU is available\n",
    "if torch.cuda.is_available():\n",
    "    # Display the number of available GPUs\n",
    "    print(f\"Number of available GPUs: {torch.cuda.device_count()}\")\n",
    "    # Display the name of each GPU\n",
    "    for i in range(torch.cuda.device_count()):\n",
    "        print(f\"GPU {i}: {torch.cuda.get_device_name(i)}\")\n",
    "else:\n",
    "    print(\"No GPU available.\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "b0c5786e",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "device(type='cuda', index=1)"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "if torch.cuda.is_available():  \n",
    "  dev = \"cuda:\" + str(cuda_num) \n",
    "else:  \n",
    "  dev = \"cpu\" \n",
    "\n",
    "device = torch.device(dev)\n",
    "device"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "3393fe4e",
   "metadata": {},
   "source": [
    "## Chargement des données"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "97644745",
   "metadata": {},
   "outputs": [],
   "source": [
    "glovemgr = EmbMgr(\"./data/cc.fr.300.vec\", vocab_size=vocab_size, header=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "fe745c8d",
   "metadata": {},
   "outputs": [],
   "source": [
    "df_train = pd.read_json(args.dataset + \"/train.json\")\n",
    "train_dataset = Dataset(preprocess_df(df_train, glovemgr=glovemgr, is_sep_n=False, remove_stop_word=True, stemming=False, trunc_sent=50, padding_sent=50, trunc_doc=args.max_doc_len, doc_column_name=args.doc_col_name, labels_column_name=args.label_col_name))\n",
    "train_iter = DataLoader(dataset=train_dataset, batch_size=batch_size, shuffle=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "f8b39f3e",
   "metadata": {},
   "outputs": [],
   "source": [
    "df_val = pd.read_json(args.dataset + \"/val.json\")\n",
    "val_dataset = Dataset(preprocess_df(df_val, glovemgr=glovemgr, is_sep_n=False, remove_stop_word=True, stemming=False, trunc_sent=50, padding_sent=50, trunc_doc=args.max_doc_len, doc_column_name=args.doc_col_name, labels_column_name=args.label_col_name))\n",
    "val_iter = DataLoader(dataset=val_dataset, batch_size=1, shuffle=False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "0f086978",
   "metadata": {},
   "outputs": [],
   "source": [
    "df_test = pd.read_json(args.dataset + \"/test.json\")\n",
    "test_dataset = Dataset(preprocess_df(df_test, glovemgr=glovemgr, is_sep_n=False, remove_stop_word=True, stemming=False, trunc_sent=50, padding_sent=50, trunc_doc=args.max_doc_len, doc_column_name=args.doc_col_name, labels_column_name=args.label_col_name))\n",
    "test_iter = DataLoader(dataset=test_dataset, batch_size=1, shuffle=False)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "fc41eb07",
   "metadata": {},
   "source": [
    "## Model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "9683721f",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "380f8ba1",
   "metadata": {},
   "outputs": [],
   "source": [
    "model = SIMPLE_CNN_RNN(device=device, vocab_size=vocab_size, word_embed=glovemgr.getEmbeddings(), dim_word_embed=300)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "2ae1a236",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "SIMPLE_CNN_RNN(\n",
       "  (word_embedding): Embedding(150001, 300)\n",
       "  (word_convs): Sequential(\n",
       "    (0): Conv1d(300, 100, kernel_size=(4,), stride=(1,), padding=same)\n",
       "    (1): BatchNorm1d(100, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "    (2): ReLU(inplace=True)\n",
       "  )\n",
       "  (sent_GRU): GRU(100, 200, batch_first=True, bidirectional=True)\n",
       "  (rel_pos_emb): Embedding(11, 100)\n",
       "  (abs_pos_emb): Embedding(100, 100)\n",
       "  (Wdoc): Linear(in_features=400, out_features=400, bias=True)\n",
       "  (Wcontent): Linear(in_features=400, out_features=1, bias=False)\n",
       "  (Wsalience): Bilinear(in1_features=400, in2_features=400, out_features=1, bias=False)\n",
       "  (Wnovelty): Bilinear(in1_features=400, in2_features=400, out_features=1, bias=False)\n",
       "  (Wabs_pos): Linear(in_features=100, out_features=1, bias=False)\n",
       "  (Wrel_pos): Linear(in_features=100, out_features=1, bias=False)\n",
       ")"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "model.to(device)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "4bc411ce",
   "metadata": {},
   "outputs": [],
   "source": [
    "loss_fn = nn.BCELoss()\n",
    "optimizer = torch.optim.Adamax(model.parameters(),lr=learning_rate)\n",
    "scheduler = torch.optim.lr_scheduler.StepLR(optimizer, step_size=1, gamma=0.5)\n",
    "mae_fn = nn.L1Loss()"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "1852182a",
   "metadata": {},
   "source": [
    "## Train"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "5c803c4f",
   "metadata": {},
   "outputs": [],
   "source": [
    "if not os.path.exists(checkpoints_folder):\n",
    "    os.makedirs(checkpoints_folder)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "c6618af5",
   "metadata": {},
   "outputs": [],
   "source": [
    "df_val[\"doc_splitted\"] = split_all_docs(df_val[args.doc_col_name], is_sep_n = False)\n",
    "val_set = df_val\n",
    "scorer = rouge_scorer.RougeScorer(['rouge1', 'rouge2', 'rougeL'], use_stemmer=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "0991d3c5",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 1:   0%|          | 0/25 [00:00<?, ?batch/s]/home/raoufdine/.local/lib/python3.9/site-packages/torch/nn/modules/conv.py:309: UserWarning: Using padding='same' with even kernel lengths and odd dilation may require a zero-padded copy of the input be created (Triggered internally at ../aten/src/ATen/native/Convolution.cpp:895.)\n",
      "  return F.conv1d(input, weight, bias, self.stride,\n",
      "Epoch 1: 100%|██████████| 25/25 [00:03<00:00,  6.95batch/s, accuracy=0.726, loss=3.22, mae=0.313]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 1 : val loss = 0.597, val mae = 0.420, val accuracy = 0.773, r1 = 0.292, r2 = 0.083, rL = 0.185\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 2: 100%|██████████| 25/25 [00:02<00:00,  8.49batch/s, accuracy=0.766, loss=0.448, mae=0.266]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 2 : val loss = 0.503, val mae = 0.347, val accuracy = 0.776, r1 = 0.305, r2 = 0.095, rL = 0.195\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 3: 100%|██████████| 25/25 [00:03<00:00,  8.14batch/s, accuracy=0.76, loss=0.432, mae=0.254] \n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 3 : val loss = 0.469, val mae = 0.315, val accuracy = 0.775, r1 = 0.319, r2 = 0.110, rL = 0.211\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 4: 100%|██████████| 25/25 [00:02<00:00,  9.15batch/s, accuracy=0.783, loss=0.414, mae=0.254]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 4 : val loss = 0.457, val mae = 0.302, val accuracy = 0.774, r1 = 0.323, r2 = 0.111, rL = 0.214\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 5: 100%|██████████| 25/25 [00:02<00:00,  8.78batch/s, accuracy=0.794, loss=0.393, mae=0.252]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 5 : val loss = 0.452, val mae = 0.294, val accuracy = 0.774, r1 = 0.324, r2 = 0.110, rL = 0.215\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 6: 100%|██████████| 25/25 [00:02<00:00,  8.74batch/s, accuracy=0.786, loss=0.395, mae=0.239]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 6 : val loss = 0.451, val mae = 0.294, val accuracy = 0.774, r1 = 0.324, r2 = 0.110, rL = 0.215\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 7: 100%|██████████| 25/25 [00:02<00:00,  8.80batch/s, accuracy=0.779, loss=0.401, mae=0.247]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 7 : val loss = 0.450, val mae = 0.295, val accuracy = 0.774, r1 = 0.324, r2 = 0.110, rL = 0.215\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 8: 100%|██████████| 25/25 [00:03<00:00,  7.96batch/s, accuracy=0.774, loss=0.4, mae=0.242]  \n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 8 : val loss = 0.450, val mae = 0.296, val accuracy = 0.774, r1 = 0.324, r2 = 0.110, rL = 0.215\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 9: 100%|██████████| 25/25 [00:02<00:00,  8.43batch/s, accuracy=0.791, loss=0.385, mae=0.239]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 9 : val loss = 0.450, val mae = 0.297, val accuracy = 0.775, r1 = 0.324, r2 = 0.111, rL = 0.215\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 10: 100%|██████████| 25/25 [00:03<00:00,  8.22batch/s, accuracy=0.8, loss=0.378, mae=0.234]  \n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 10 : val loss = 0.451, val mae = 0.298, val accuracy = 0.774, r1 = 0.324, r2 = 0.111, rL = 0.215\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 11: 100%|██████████| 25/25 [00:02<00:00,  8.60batch/s, accuracy=0.787, loss=0.387, mae=0.243]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 11 : val loss = 0.451, val mae = 0.297, val accuracy = 0.774, r1 = 0.324, r2 = 0.111, rL = 0.215\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 12: 100%|██████████| 25/25 [00:02<00:00,  9.13batch/s, accuracy=0.789, loss=0.386, mae=0.245]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 12 : val loss = 0.448, val mae = 0.294, val accuracy = 0.775, r1 = 0.324, r2 = 0.110, rL = 0.215\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 13: 100%|██████████| 25/25 [00:02<00:00,  9.04batch/s, accuracy=0.794, loss=0.38, mae=0.238] \n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 13 : val loss = 0.450, val mae = 0.296, val accuracy = 0.774, r1 = 0.324, r2 = 0.110, rL = 0.214\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 14: 100%|██████████| 25/25 [00:02<00:00,  9.08batch/s, accuracy=0.783, loss=0.397, mae=0.249]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 14 : val loss = 0.449, val mae = 0.295, val accuracy = 0.775, r1 = 0.324, r2 = 0.110, rL = 0.215\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 15: 100%|██████████| 25/25 [00:02<00:00,  8.64batch/s, accuracy=0.781, loss=0.399, mae=0.249]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 15 : val loss = 0.449, val mae = 0.295, val accuracy = 0.775, r1 = 0.324, r2 = 0.110, rL = 0.215\n",
      "Training duration = 82.30386710166931\n"
     ]
    }
   ],
   "source": [
    "arr_train_loss = []\n",
    "arr_train_mae = []\n",
    "arr_train_acc = []\n",
    "arr_val_loss = []\n",
    "arr_val_mae = []\n",
    "arr_val_acc = []\n",
    "\n",
    "t1 = time()\n",
    "for epoch in range(1, epochs+1):\n",
    "    # train 1 epoch\n",
    "    model.train()\n",
    "    nb_batch_train = 0\n",
    "    total_train_loss = 0\n",
    "    total_train_mae = 0\n",
    "    total_train_acc = 0\n",
    "    with tqdm(train_iter, unit=\"batch\", total=len(train_iter)) as tepoch:\n",
    "        for batch in tepoch:\n",
    "            tepoch.set_description(f\"Epoch {epoch}\")\n",
    "            features = []\n",
    "            doc_lens = []\n",
    "\n",
    "            for j in range(batch_size):\n",
    "                doc_lens.append(len(batch[j][\"docs\"]))\n",
    "                features = features + batch[j][\"docs\"]\n",
    "            \n",
    "            features = torch.tensor(features, dtype=torch.long).to(device)\n",
    "\n",
    "            targets = [torch.tensor(batch[j][\"labels\"], dtype=torch.float) for j in range(batch_size)]\n",
    "            targets = torch.cat(targets)\n",
    "            targets = targets.to(device)\n",
    "            \n",
    "            probs = model(features, doc_lens)\n",
    "            \n",
    "            loss = loss_fn(probs, targets)\n",
    "            optimizer.zero_grad()\n",
    "            loss.backward()\n",
    "            clip_grad_norm_(model.parameters(), 1.0)\n",
    "            optimizer.step()\n",
    "            nb_batch_train += 1\n",
    "            total_train_loss += loss.item()\n",
    "            total_train_mae += mae_fn(probs, targets).item()\n",
    "            total_train_acc += accuracy_prop_sent_per_doc_fn(probs=probs.cpu().detach().numpy(), targets=targets.cpu().detach().numpy(), doc_lens=doc_lens)\n",
    "            tepoch.set_postfix(loss=total_train_loss/nb_batch_train, mae=total_train_mae/nb_batch_train, accuracy=total_train_acc/nb_batch_train)\n",
    "\n",
    "    # Save model\n",
    "    model.save(checkpoints_folder + \"/\" + model_name + \"-\" + str(epoch) + \".pt\")\n",
    "\n",
    "    # Show train and val score\n",
    "    model.eval()\n",
    "    nb_batch_val = 0\n",
    "    total_val_loss = 0\n",
    "    total_val_mae = 0\n",
    "    total_val_acc = 0\n",
    "\n",
    "    total_r1 = 0\n",
    "    total_r2 = 0\n",
    "    total_rl = 0\n",
    "\n",
    "    for i, batch in enumerate(val_iter):\n",
    "        features = []\n",
    "        doc_lens = []\n",
    "\n",
    "        for j in range(1):\n",
    "            doc_lens.append(len(batch[j][\"docs\"]))\n",
    "            features = features + batch[j][\"docs\"]\n",
    "            \n",
    "        features = torch.tensor(features, dtype=torch.long).to(device)\n",
    "\n",
    "        targets = [torch.tensor(batch[j][\"labels\"], dtype=torch.float) for j in range(1)]\n",
    "        targets = torch.cat(targets)\n",
    "        targets = targets.to(device)\n",
    "        \n",
    "        y_pred = model(features, doc_lens)\n",
    "\n",
    "        loss = loss_fn(y_pred, targets)\n",
    "\n",
    "        nb_batch_val += 1\n",
    "        total_val_loss += loss.item()\n",
    "\n",
    "        doc = val_set[\"doc_splitted\"].iloc[i]\n",
    "        summaries = val_set[args.sum_col_name].iloc[i]\n",
    "\n",
    "        indices = torch.argsort(y_pred, descending=True)\n",
    "\n",
    "        if indices.shape[0] > len(doc):\n",
    "            continue\n",
    "\n",
    "        y_pred_thresh = []\n",
    "\n",
    "        txt = \"\"\n",
    "\n",
    "        for j in range(min(len(doc), y_pred.shape[0])):\n",
    "            txt = txt + \". \" + doc[indices[j]]\n",
    "            y_pred_thresh.append(indices[j])\n",
    "            if len(txt) >= len(summaries):\n",
    "                break\n",
    "\n",
    "        y_pred_thresh.sort()\n",
    "\n",
    "        txt = \"\"\n",
    "\n",
    "        for j in y_pred_thresh:\n",
    "            txt = txt + \". \" + doc[j]\n",
    "\n",
    "        n = min(len(txt), len(summaries))\n",
    "\n",
    "        while n < len(txt) and txt[n].isalnum():\n",
    "            n += 1\n",
    "\n",
    "        txt = txt[:n]\n",
    "\n",
    "        #assert len(txt) - len(summaries) <= 20\n",
    "\n",
    "        scores = scorer.score(summaries, txt)\n",
    "        total_r1 += scores[\"rouge1\"].fmeasure\n",
    "        total_r2 += scores[\"rouge2\"].fmeasure\n",
    "        total_rl += scores[\"rougeL\"].fmeasure\n",
    "\n",
    "        probs = y_pred.tolist() # compute_probs(y_pred)\n",
    "        probs_tensor = y_pred #torch.tensor(probs, dtype=torch.float).to(device)\n",
    "\n",
    "        total_val_mae += mae_fn(probs_tensor, targets).item()\n",
    "        total_val_acc += accuracy_nb_sent_per_doc_fn(probs=probs, targets=targets.cpu().detach().numpy(), doc_lens=doc_lens, average_number_of_sentences_per_document=average_number_of_sentences_per_document)\n",
    "\n",
    "    arr_train_loss.append(total_train_loss / nb_batch_train)\n",
    "    arr_train_mae.append(total_train_mae / nb_batch_train)\n",
    "    arr_train_acc.append(total_train_acc / nb_batch_train)\n",
    "\n",
    "    arr_val_loss.append(total_val_loss / nb_batch_val)\n",
    "    arr_val_mae.append(total_val_mae / nb_batch_val)\n",
    "    arr_val_acc.append(total_val_acc / nb_batch_val)\n",
    "    \n",
    "    print(\"Epoch {} : val loss = {:.3f}, val mae = {:.3f}, val accuracy = {:.3f}, r1 = {:.3f}, r2 = {:.3f}, rL = {:.3f}\".format(epoch, total_val_loss / nb_batch_val, total_val_mae / nb_batch_val, total_val_acc / nb_batch_val, total_r1 / nb_batch_val, total_r2 / nb_batch_val, total_rl / nb_batch_val))\n",
    "\n",
    "    if len(arr_val_loss) >= early_stopping+1:\n",
    "        if min(arr_val_loss[-early_stopping:]) >= arr_val_loss[-(early_stopping+1)]:\n",
    "            break\n",
    "\n",
    "    # update lr\n",
    "    scheduler.step()\n",
    "\n",
    "t2 = time()\n",
    "print(\"Training duration =\", t2-t1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "2f39ceed",
   "metadata": {},
   "outputs": [],
   "source": [
    "training_metrics = {}\n",
    "training_metrics[\"duration\"]   = t2 - t1\n",
    "training_metrics[\"train_loss\"] = arr_train_loss\n",
    "training_metrics[\"train_mae\"]  = arr_train_mae\n",
    "training_metrics[\"train_acc\"]  = arr_train_acc\n",
    "training_metrics[\"val_loss\"]   = arr_val_loss\n",
    "training_metrics[\"val_mae\"]    = arr_val_mae\n",
    "training_metrics[\"val_acc\"]    = arr_val_acc\n",
    "\n",
    "# Save to file in JSON format\n",
    "\n",
    "with open(checkpoints_folder + \"/training_metrics.json\", 'w') as fp:\n",
    "    json.dump(training_metrics, fp)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "8cd8fbee",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# draw Losses\n",
    "if is_graphic:\n",
    "    plt.plot(list(range(1, len(arr_train_loss) + 1)), arr_train_loss, label=\"train\")\n",
    "    plt.plot(list(range(1, len(arr_val_loss) + 1)), arr_val_loss, label=\"val\")\n",
    "\n",
    "    plt.title(\"Loss\")\n",
    "    plt.xlabel(\"epoch\")\n",
    "    plt.ylabel(\"loss\")\n",
    "    plt.legend(loc=\"upper left\")\n",
    "\n",
    "    plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "id": "8bda887e",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# draw mae\n",
    "if is_graphic:\n",
    "    plt.plot(list(range(1, len(arr_train_mae) + 1)), arr_train_mae, label=\"train\")\n",
    "    plt.plot(list(range(1, len(arr_val_mae) + 1)), arr_val_mae, label=\"val\")\n",
    "\n",
    "    plt.title(\"MAE\")\n",
    "    plt.xlabel(\"epoch\")\n",
    "    plt.ylabel(\"mae\")\n",
    "    plt.legend(loc=\"upper right\")\n",
    "\n",
    "    plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "id": "1cc21154",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# draw Accuracies\n",
    "if is_graphic:\n",
    "    plt.plot(list(range(1, len(arr_train_acc) + 1)), arr_train_acc, label=\"train\")\n",
    "    plt.plot(list(range(1, len(arr_val_acc) + 1)), arr_val_acc, label=\"val\")\n",
    "\n",
    "    plt.title(\"Accuracy\")\n",
    "    plt.xlabel(\"epoch\")\n",
    "    plt.ylabel(\"accuracy\")\n",
    "    plt.legend(loc=\"upper left\")\n",
    "\n",
    "    plt.show()"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "0133ff45",
   "metadata": {},
   "source": [
    "# Eval model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "id": "e095b271",
   "metadata": {},
   "outputs": [],
   "source": [
    "from utils.split_all_docs import split_all_docs\n",
    "from rouge_score import rouge_scorer\n",
    "from utils.threshold_probs import threshold_probs_by_prop"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "id": "273c6eb2",
   "metadata": {},
   "outputs": [],
   "source": [
    "model = SIMPLE_CNN_RNN(device=device, vocab_size=vocab_size, word_embed=glovemgr.getEmbeddings(), dim_word_embed=300)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "id": "4fc41994",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "12"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "best_epoch = np.argmin(np.array(arr_val_loss)) + 1\n",
    "model.load(checkpoints_folder + \"/\" + model_name + \"-\" + str(best_epoch) + \".pt\")\n",
    "model.to(device)\n",
    "model.eval()\n",
    "best_epoch"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "id": "3edbae7a",
   "metadata": {},
   "outputs": [],
   "source": [
    "test_set = df_test\n",
    "test_set[\"doc_splited\"] = split_all_docs(test_set[args.doc_col_name], False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "id": "bb8ab07a",
   "metadata": {},
   "outputs": [],
   "source": [
    "scorer = rouge_scorer.RougeScorer(['rouge1', 'rouge2', 'rougeL'], use_stemmer=True)\n",
    "criterion = nn.BCELoss()\n",
    "mae_fn = nn.L1Loss()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "id": "67659b8a",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Eval model:   0%|          | 0/100 [00:00<?, ?batch/s]"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Eval model: 100%|██████████| 100/100 [00:02<00:00, 44.03batch/s, accuracy=0.787, mae=0.315, rouge1=0.319, rouge2=0.0898, rougeL=0.193]\n"
     ]
    }
   ],
   "source": [
    "arr_rouge1 = []\n",
    "arr_rouge2 = []\n",
    "arr_rougeL = []\n",
    "arr_loss = []\n",
    "mae = []\n",
    "accuracy = []\n",
    "\n",
    "idx = 0\n",
    "with tqdm(test_iter, unit=\"batch\", total=len(test_iter)) as tepoch:\n",
    "    for batch in tepoch:\n",
    "        tepoch.set_description(\"Eval model\")\n",
    "        features = []\n",
    "        doc_lens = []\n",
    "\n",
    "        for j in range(1):\n",
    "            doc_lens.append(len(batch[j][\"docs\"]))\n",
    "            features = features + batch[j][\"docs\"]\n",
    "                \n",
    "        features = torch.tensor(features, dtype=torch.long).to(device)\n",
    "\n",
    "        targets = [torch.tensor(batch[j][\"labels\"], dtype=torch.float) for j in range(1)]\n",
    "        targets = torch.cat(targets)\n",
    "        targets = targets.to(device)\n",
    "\n",
    "        y_pred = model(features, doc_lens)\n",
    "    \n",
    "        loss = criterion(y_pred, targets)\n",
    "\n",
    "        arr_loss.append(loss.item())\n",
    "\n",
    "        doc = test_set[\"doc_splited\"].iloc[idx]\n",
    "        summaries = test_set[args.sum_col_name].iloc[idx]\n",
    "\n",
    "        probs = np.array(y_pred.tolist()) # compute_probs(y_pred)\n",
    "        probs_tensor = y_pred #torch.tensor(probs, dtype=torch.float).to(device)\n",
    "\n",
    "        #probs = threshold_probs_by_nb(probs=probs, doc_lens=[probs.shape[0]], average_number_of_sentences_per_document=average_number_of_sentences_per_document)\n",
    "        #probs = threshold_probs_by_prop(probs=probs, doc_lens=[probs.shape[0]], average_proportion_of_sentences_per_document=average_proportion_of_sentences_per_document)\n",
    "        indices = torch.argsort(y_pred, descending=True)\n",
    "\n",
    "        if indices.shape[0] > len(doc):\n",
    "            continue\n",
    "\n",
    "        y_pred_thresh = []\n",
    "\n",
    "        txt = \"\"\n",
    "\n",
    "        for i in range(min(len(doc), y_pred.shape[0])):\n",
    "            txt = txt + \". \" + doc[indices[i]]\n",
    "            y_pred_thresh.append(indices[i])\n",
    "            if len(txt) >= len(summaries):\n",
    "                break\n",
    "\n",
    "        y_pred_thresh.sort()\n",
    "\n",
    "        txt = \"\"\n",
    "\n",
    "        for i in y_pred_thresh:#range(min(len(doc), y_pred.shape[0])):\n",
    "            txt = txt + \". \" + doc[i]\n",
    "\n",
    "        n = min(len(txt), len(summaries))\n",
    "\n",
    "        while n < len(txt) and txt[n].isalnum():\n",
    "            n += 1\n",
    "\n",
    "        txt = txt[:n]\n",
    "\n",
    "        #assert len(txt) - len(summaries) <= 20\n",
    "\n",
    "        scores = scorer.score(summaries, txt)\n",
    "        arr_rouge1.append(scores[\"rouge1\"].fmeasure)\n",
    "        arr_rouge2.append(scores[\"rouge2\"].fmeasure)\n",
    "        arr_rougeL.append(scores[\"rougeL\"].fmeasure)\n",
    "\n",
    "        mae.append(mae_fn(probs_tensor, targets).item())\n",
    "\n",
    "        accuracy.append(accuracy_nb_sent_per_doc_fn(probs=probs, targets=targets.cpu().detach().numpy(), doc_lens=[len(probs)], average_number_of_sentences_per_document=average_number_of_sentences_per_document))\n",
    "        #accuracy.append(accuracy_prop_sent_per_doc_fn(probs=probs, targets=targets.cpu().detach().numpy(), doc_lens=[len(probs)], average_proportion_of_sentences_per_document=average_proportion_of_sentences_per_document))\n",
    "\n",
    "        tepoch.set_postfix(accuracy = np.mean(accuracy), mae = np.mean(mae), rouge1 = np.mean(arr_rouge1), rouge2 = np.mean(arr_rouge2), rougeL = np.mean(arr_rougeL))\n",
    "        idx += 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "id": "5c1fd15f",
   "metadata": {},
   "outputs": [],
   "source": [
    "test_metrics = {}\n",
    "test_metrics[\"accuracy\"] = np.mean(accuracy)\n",
    "test_metrics[\"mae\"]      = np.mean(mae)\n",
    "test_metrics[\"rouge1\"]   = np.mean(arr_rouge1)\n",
    "test_metrics[\"rouge2\"]   = np.mean(arr_rouge2)\n",
    "test_metrics[\"rougeL\"]   = np.mean(arr_rougeL)\n",
    "\n",
    "# Save to file in JSON format\n",
    "\n",
    "with open(checkpoints_folder + \"/test_metrics.json\", 'w') as fp:\n",
    "    json.dump(test_metrics, fp)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "496646f2",
   "metadata": {},
   "source": [
    "### Lead-3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "id": "4c96cdd0",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Lead-3: 100%|██████████| 100/100 [00:00<00:00, 193.43batch/s, rouge1=0.309, rouge2=0.0904, rougeL=0.195]\n"
     ]
    }
   ],
   "source": [
    "arr_rouge1 = []\n",
    "arr_rouge2 = []\n",
    "arr_rougeL = []\n",
    "mae = []\n",
    "accuracy = []\n",
    "\n",
    "idx = 0\n",
    "with tqdm(test_iter, unit=\"batch\", total=len(test_iter)) as tepoch:\n",
    "    for batch in tepoch:\n",
    "        tepoch.set_description(\"Lead-3\")\n",
    "        doc = test_set[\"doc_splited\"].iloc[idx]\n",
    "\n",
    "        txt = \"\"\n",
    "\n",
    "        for i in range(min(len(doc), 3)):\n",
    "            txt = txt + doc[i]\n",
    "\n",
    "        summaries = test_set[args.sum_col_name].iloc[idx]\n",
    "\n",
    "        n = min(len(txt), len(summaries))\n",
    "\n",
    "        while n < len(txt) and txt[n].isalnum():\n",
    "            n += 1\n",
    "\n",
    "        txt = txt[:n]\n",
    "\n",
    "        scores = scorer.score(summaries, txt)\n",
    "        arr_rouge1.append(scores[\"rouge1\"].fmeasure)\n",
    "        arr_rouge2.append(scores[\"rouge2\"].fmeasure)\n",
    "        arr_rougeL.append(scores[\"rougeL\"].fmeasure)\n",
    "\n",
    "        idx += 1\n",
    "\n",
    "        tepoch.set_postfix(rouge1 = np.mean(arr_rouge1), rouge2 = np.mean(arr_rouge2), rougeL = np.mean(arr_rougeL))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "78a3c5d9",
   "metadata": {},
   "source": [
    "### First n char"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "id": "a4c96c70",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "First-n-char': 100%|██████████| 100/100 [00:00<00:00, 145.78batch/s, rouge1=0.325, rouge2=0.0923, rougeL=0.199]\n"
     ]
    }
   ],
   "source": [
    "arr_rouge1 = []\n",
    "arr_rouge2 = []\n",
    "arr_rougeL = []\n",
    "mae = []\n",
    "accuracy = []\n",
    "\n",
    "idx = 0\n",
    "with tqdm(test_iter, unit=\"batch\", total=len(test_iter)) as tepoch:\n",
    "    for batch in tepoch:\n",
    "        tepoch.set_description(\"First-n-char'\")\n",
    "        doc = test_set[\"doc_splited\"].iloc[idx]\n",
    "\n",
    "        txt = \"\"\n",
    "\n",
    "        for i in range(len(doc)):\n",
    "            txt = txt + doc[i]\n",
    "\n",
    "        summaries = test_set[args.sum_col_name].iloc[idx]\n",
    "\n",
    "        n = min(len(txt), len(summaries))\n",
    "\n",
    "        while n < len(txt) and txt[n].isalnum():\n",
    "            n += 1\n",
    "\n",
    "        txt = txt[:n]\n",
    "\n",
    "        scores = scorer.score(summaries, txt)\n",
    "        arr_rouge1.append(scores[\"rouge1\"].fmeasure)\n",
    "        arr_rouge2.append(scores[\"rouge2\"].fmeasure)\n",
    "        arr_rougeL.append(scores[\"rougeL\"].fmeasure)\n",
    "\n",
    "        idx += 1\n",
    "\n",
    "        tepoch.set_postfix(rouge1 = np.mean(arr_rouge1), rouge2 = np.mean(arr_rouge2), rougeL = np.mean(arr_rougeL))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "id": "e4f4796c",
   "metadata": {},
   "outputs": [
    {
     "ename": "SystemExit",
     "evalue": "",
     "output_type": "error",
     "traceback": [
      "An exception has occurred, use %tb to see the full traceback.\n",
      "\u001b[0;31mSystemExit\u001b[0m\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/raoufdine/anaconda3/lib/python3.9/site-packages/IPython/core/interactiveshell.py:3465: UserWarning: To exit: use 'exit', 'quit', or Ctrl-D.\n",
      "  warn(\"To exit: use 'exit', 'quit', or Ctrl-D.\", stacklevel=1)\n"
     ]
    }
   ],
   "source": [
    "# Does not excute this cell if you want to execute the following cells.\n",
    "import sys\n",
    "sys.exit()"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "base",
   "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.9.13"
  },
  "vscode": {
   "interpreter": {
    "hash": "4f810f0bde7d7b5dc90f9e6832822547e13e234c53731a97fc91254323942f40"
   }
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}