14-train_SIMPLE_CNN_RNN_sailence_only_fasttext_fr.ipynb

{
 "cells": [
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "606fa719",
   "metadata": {},
   "source": [
    "# Train 14-train_SIMPLE_CNN_RNN_sailence_only"
   ]
  },
  {
   "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 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=4)\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: 4\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 = \"14-train_SIMPLE_CNN_RNN_sailence_only_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=4)"
      ]
     },
     "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": 12,
   "id": "9683721f",
   "metadata": {},
   "outputs": [],
   "source": [
    "from models.BasicModel import BasicModel\n",
    "import torch\n",
    "import torch.nn as nn\n",
    "import torch.nn.functional as F\n",
    "from torch.autograd import Variable\n",
    "\n",
    "class SIMPLE_CNN_RNN(BasicModel):\n",
    "    def __init__(self, device, vocab_size, word_embed = None, dim_word_embed = 100):\n",
    "        super(SIMPLE_CNN_RNN, self).__init__(device)\n",
    "\n",
    "        self.device = device\n",
    "\n",
    "        self.word_embedding = nn.Embedding(vocab_size+2, dim_word_embed, padding_idx=0)\n",
    "        # Load word embedding if specified\n",
    "        if word_embed is not None:\n",
    "            self.word_embedding = torch.nn.Embedding.from_pretrained(torch.from_numpy(word_embed).float())\n",
    "\n",
    "        # 100 : word2vec embedding size\n",
    "        self.word_convs = nn.Sequential(\n",
    "                            nn.Conv1d(in_channels=dim_word_embed,out_channels=100,kernel_size=4,padding='same'),\n",
    "                            nn.BatchNorm1d(num_features=100),\n",
    "                            nn.ReLU(inplace=True))\n",
    "        self.sent_GRU = nn.GRU(input_size = 100, hidden_size=200, batch_first = True, bidirectional = True)\n",
    "\n",
    "        self.Wdoc = nn.Linear(2*200,2*200,bias=True)\n",
    "\n",
    "        self.Wsalience = nn.Bilinear(2*200,2*200,1,bias=False)\n",
    "        self.bias = nn.Parameter(torch.empty(1).uniform_(-0.1, 0.1))\n",
    "\n",
    "    def avg_pool1d(self,x,seq_lens):\n",
    "        out = []\n",
    "        for index,t in enumerate(x):\n",
    "            if seq_lens[index] == 0:\n",
    "                t = t[:1]\n",
    "            else:\n",
    "                t = t[:seq_lens[index],:]\n",
    "            t = torch.t(t).unsqueeze(0)\n",
    "            out.append(torch.avg_pool1d(t,t.size(2)))\n",
    "        \n",
    "        out = torch.cat(out).squeeze(2)\n",
    "        return out\n",
    "\n",
    "    def forward(self, arr_x, doc_lens):\n",
    "        probs = []\n",
    "\n",
    "        max_doc_lens = max(doc_lens)\n",
    "        #sent_lens = torch.sum(torch.sign(arr_x),dim=1).data\n",
    "\n",
    "        arr_x = self.word_embedding(arr_x)\n",
    "        arr_x = self.word_convs(arr_x.permute(0,2,1))\n",
    "        arr_x = torch.avg_pool1d(arr_x, arr_x.size(2)).squeeze(2)\n",
    "\n",
    "        arr_x = self.pad_doc(arr_x, doc_lens)\n",
    "\n",
    "        arr_x = self.sent_GRU(arr_x)[0]\n",
    "        sents_all_docs = arr_x.reshape(len(doc_lens) * max_doc_lens, 2*200) # flat docs\n",
    "        \n",
    "        docs = self.avg_pool1d(arr_x, doc_lens)\n",
    "        docs = torch.tanh(self.Wdoc(docs))\n",
    "        docs_for_each_sent = docs.repeat_interleave(max_doc_lens, dim=0) # repeat doc n times\n",
    "\n",
    "        saliences = self.Wsalience(sents_all_docs, docs_for_each_sent)\n",
    "\n",
    "        # doc_len (number) s\n",
    "        ses = torch.zeros(len(doc_lens), 2*200)\n",
    "        ses = ses.to(self.device)\n",
    "\n",
    "        # for each document, compute probabilities\n",
    "        for position in range(max_doc_lens):\n",
    "            saliences_for_position = saliences[position::max_doc_lens]\n",
    "            prob = saliences_for_position + self.bias\n",
    "            prob = torch.sigmoid(prob)\n",
    "            probs.append(prob)\n",
    "\n",
    "            ses = ses + torch.mul(sents_all_docs[position::max_doc_lens], prob)\n",
    "        probs = torch.cat(probs).squeeze()\n",
    "        if len(probs.shape) == 0:\n",
    "            probs = probs.unsqueeze(0)\n",
    "        probs_filtered = []\n",
    "        for idx, doc_len in enumerate(doc_lens):\n",
    "            prob = probs[idx::len(doc_lens)]\n",
    "            prob = prob[:doc_len]\n",
    "            probs_filtered.append(prob)\n",
    "        probs_filtered = torch.cat(probs_filtered).squeeze()\n",
    "        if len(probs_filtered.shape) == 0:\n",
    "            probs_filtered = probs_filtered.unsqueeze(0)\n",
    "        #probs = probs.to(self.device)\n",
    "        return probs_filtered"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "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": 14,
   "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",
       "  (Wdoc): Linear(in_features=400, out_features=400, bias=True)\n",
       "  (Wsalience): Bilinear(in1_features=400, in2_features=400, out_features=1, bias=False)\n",
       ")"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "model.to(device)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "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": 16,
   "id": "5c803c4f",
   "metadata": {},
   "outputs": [],
   "source": [
    "if not os.path.exists(checkpoints_folder):\n",
    "    os.makedirs(checkpoints_folder)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "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": 18,
   "id": "0991d3c5",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 1:   0%|          | 0/25 [00:00<?, ?batch/s]"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/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:01<00:00, 14.10batch/s, accuracy=0.704, loss=0.543, mae=0.336]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 1 : val loss = 0.664, val mae = 0.484, val accuracy = 0.768, r1 = 0.318, r2 = 0.105, rL = 0.210\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 2: 100%|██████████| 25/25 [00:01<00:00, 19.76batch/s, accuracy=0.742, loss=0.49, mae=0.309] \n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 2 : val loss = 0.619, val mae = 0.456, val accuracy = 0.776, r1 = 0.323, r2 = 0.107, rL = 0.213\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 3: 100%|██████████| 25/25 [00:01<00:00, 19.06batch/s, accuracy=0.769, loss=0.453, mae=0.284]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 3 : val loss = 0.523, val mae = 0.349, val accuracy = 0.776, r1 = 0.324, r2 = 0.108, rL = 0.214\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 4: 100%|██████████| 25/25 [00:01<00:00, 19.45batch/s, accuracy=0.777, loss=0.425, mae=0.282]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 4 : val loss = 0.504, val mae = 0.317, val accuracy = 0.776, r1 = 0.324, r2 = 0.108, rL = 0.214\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 5: 100%|██████████| 25/25 [00:01<00:00, 21.47batch/s, accuracy=0.769, loss=0.416, mae=0.256]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 5 : val loss = 0.487, val mae = 0.324, val accuracy = 0.776, r1 = 0.324, r2 = 0.108, rL = 0.214\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 6: 100%|██████████| 25/25 [00:01<00:00, 19.66batch/s, accuracy=0.77, loss=0.427, mae=0.272] \n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 6 : val loss = 0.485, val mae = 0.317, val accuracy = 0.776, r1 = 0.324, r2 = 0.108, rL = 0.214\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 7: 100%|██████████| 25/25 [00:01<00:00, 19.20batch/s, accuracy=0.759, loss=0.428, mae=0.271]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 7 : val loss = 0.482, val mae = 0.321, val accuracy = 0.776, r1 = 0.324, r2 = 0.108, rL = 0.214\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 8: 100%|██████████| 25/25 [00:01<00:00, 20.61batch/s, accuracy=0.77, loss=0.414, mae=0.269] \n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 8 : val loss = 0.481, val mae = 0.317, val accuracy = 0.776, r1 = 0.324, r2 = 0.108, rL = 0.214\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 9: 100%|██████████| 25/25 [00:01<00:00, 20.68batch/s, accuracy=0.767, loss=0.435, mae=0.271]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 9 : val loss = 0.481, val mae = 0.317, val accuracy = 0.776, r1 = 0.325, r2 = 0.109, rL = 0.214\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 10: 100%|██████████| 25/25 [00:01<00:00, 19.73batch/s, accuracy=0.772, loss=0.407, mae=0.26] \n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 10 : val loss = 0.480, val mae = 0.318, val accuracy = 0.776, r1 = 0.324, r2 = 0.108, rL = 0.214\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 11: 100%|██████████| 25/25 [00:01<00:00, 20.11batch/s, accuracy=0.759, loss=0.433, mae=0.275]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 11 : val loss = 0.480, val mae = 0.317, val accuracy = 0.776, r1 = 0.324, r2 = 0.108, rL = 0.214\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 12: 100%|██████████| 25/25 [00:01<00:00, 21.10batch/s, accuracy=0.773, loss=0.422, mae=0.27] \n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 12 : val loss = 0.480, val mae = 0.317, val accuracy = 0.776, r1 = 0.324, r2 = 0.108, rL = 0.214\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 13: 100%|██████████| 25/25 [00:01<00:00, 20.96batch/s, accuracy=0.765, loss=0.43, mae=0.273] \n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 13 : val loss = 0.480, val mae = 0.314, val accuracy = 0.776, r1 = 0.324, r2 = 0.108, rL = 0.214\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 14: 100%|██████████| 25/25 [00:01<00:00, 24.37batch/s, accuracy=0.772, loss=0.413, mae=0.267]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 14 : val loss = 0.480, val mae = 0.317, val accuracy = 0.776, r1 = 0.324, r2 = 0.108, rL = 0.214\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 15: 100%|██████████| 25/25 [00:00<00:00, 35.32batch/s, accuracy=0.764, loss=0.416, mae=0.265]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 15 : val loss = 0.481, val mae = 0.320, val accuracy = 0.776, r1 = 0.324, r2 = 0.108, rL = 0.214\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 16: 100%|██████████| 25/25 [00:00<00:00, 35.45batch/s, accuracy=0.779, loss=0.402, mae=0.259]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 16 : val loss = 0.480, val mae = 0.321, val accuracy = 0.776, r1 = 0.324, r2 = 0.108, rL = 0.214\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 17: 100%|██████████| 25/25 [00:00<00:00, 35.55batch/s, accuracy=0.786, loss=0.41, mae=0.261] \n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 17 : val loss = 0.480, val mae = 0.316, val accuracy = 0.776, r1 = 0.324, r2 = 0.108, rL = 0.214\n",
      "Training duration = 44.19307065010071\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": 19,
   "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": 20,
   "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": 21,
   "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": 22,
   "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": 23,
   "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": 24,
   "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": 25,
   "id": "4fc41994",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "14"
      ]
     },
     "execution_count": 25,
     "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": 26,
   "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": 27,
   "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": 28,
   "id": "67659b8a",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Eval model:   0%|          | 0/100 [00:00<?, ?batch/s, accuracy=0.62, mae=0.423, rouge1=0.405, rouge2=0.0798, rougeL=0.17]"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Eval model: 100%|██████████| 100/100 [00:00<00:00, 107.51batch/s, accuracy=0.748, mae=0.365, rouge1=0.346, rouge2=0.105, rougeL=0.206]\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": 29,
   "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": 30,
   "id": "4c96cdd0",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "First-n-char': 100%|██████████| 100/100 [00:00<00:00, 134.22batch/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": "markdown",
   "id": "78a3c5d9",
   "metadata": {},
   "source": [
    "### First n char"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "id": "a4c96c70",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "First-n-char': 100%|██████████| 100/100 [00:00<00:00, 136.50batch/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": 32,
   "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
}