4-Attention-NER-CONLL.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "61u1pfXh2MyN"
   },
   "source": [
    "# LSTM et Attention\n",
    "\n",
    "\n",
    "Dans ce notebook, le but sera de faire de la reconnaissance d'entités nommées en utilisant le modèle d'attention associé au LSTM.\n",
    "\n",
    "L'attention est décrit dans l'article de [Vaswani et al., 2017](https://papers.nips.cc/paper/7181-attention-is-all-you-need.pdf). \n",
    "\n",
    "Nous allons utiliser plusieurs couches d'attention à l'aide de la méthode de PyTorch `MultiheadAttention`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 256
    },
    "colab_type": "code",
    "id": "ucl3Yfvyckdc",
    "outputId": "4cf6a69d-28e5-445c-ebbe-d0d40cb3f20a"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Requirement already satisfied: torchtext==0.6.0 in /opt/conda/lib/python3.7/site-packages (0.6.0)\n",
      "Requirement already satisfied: tqdm in /opt/conda/lib/python3.7/site-packages (from torchtext==0.6.0) (4.46.0)\n",
      "Requirement already satisfied: requests in /opt/conda/lib/python3.7/site-packages (from torchtext==0.6.0) (2.23.0)\n",
      "Requirement already satisfied: torch in /opt/conda/lib/python3.7/site-packages (from torchtext==0.6.0) (1.4.0)\n",
      "Requirement already satisfied: numpy in /opt/conda/lib/python3.7/site-packages (from torchtext==0.6.0) (1.18.5)\n",
      "Requirement already satisfied: six in /opt/conda/lib/python3.7/site-packages (from torchtext==0.6.0) (1.14.0)\n",
      "Requirement already satisfied: sentencepiece in /opt/conda/lib/python3.7/site-packages (from torchtext==0.6.0) (0.1.91)\n",
      "Requirement already satisfied: chardet<4,>=3.0.2 in /opt/conda/lib/python3.7/site-packages (from requests->torchtext==0.6.0) (3.0.4)\n",
      "Requirement already satisfied: idna<3,>=2.5 in /opt/conda/lib/python3.7/site-packages (from requests->torchtext==0.6.0) (2.9)\n",
      "Requirement already satisfied: certifi>=2017.4.17 in /opt/conda/lib/python3.7/site-packages (from requests->torchtext==0.6.0) (2020.6.20)\n",
      "Requirement already satisfied: urllib3!=1.25.0,!=1.25.1,<1.26,>=1.21.1 in /opt/conda/lib/python3.7/site-packages (from requests->torchtext==0.6.0) (1.25.9)\n",
      "Requirement already satisfied: pytorch-crf in /opt/conda/lib/python3.7/site-packages (0.7.2)\n"
     ]
    }
   ],
   "source": [
    "!pip install torchtext==0.6.0\n",
    "!pip install pytorch-crf\n",
    "\n",
    "import time\n",
    "import torch\n",
    "import matplotlib.pyplot as plt\n",
    "from torch import nn\n",
    "from torch.optim import Adam\n",
    "from torchtext.data import Field, NestedField, BucketIterator\n",
    "from torchtext.datasets import SequenceTaggingDataset\n",
    "from torchtext.vocab import Vocab\n",
    "from torchcrf import CRF\n",
    "from collections import Counter\n",
    "import torch.optim as optim\n",
    "\n",
    "from torchtext import data\n",
    "from torchtext import datasets\n",
    "\n",
    "import spacy\n",
    "from torchcrf import CRF\n",
    "import numpy as np\n",
    "import pandas as pd\n",
    "\n",
    "import time\n",
    "import random\n",
    "import string\n",
    "from itertools import chain"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "-yePexcpdBni"
   },
   "source": [
    "# Préparer les données\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "mH1o5Giyc-Cl"
   },
   "outputs": [],
   "source": [
    "SEED = 1234\n",
    "\n",
    "random.seed(SEED)\n",
    "np.random.seed(SEED)\n",
    "torch.manual_seed(SEED)\n",
    "torch.backends.cudnn.deterministic = True\n",
    "\n",
    "TEXT = data.Field(lower = False) \n",
    "TAG = data.Field(unk_token = None) \n",
    "\n",
    "my_path = \"data_ner/\"\n",
    "train_data, valid_data, test_data = data.TabularDataset.splits(\n",
    "        path= my_path ,\n",
    "        train=\"train.csv\",\n",
    "        validation=\"valid.csv\",\n",
    "        test=\"test.csv\", format='csv', skip_header=True,\n",
    "        fields=((\"text\", TEXT), (\"tag\", TAG))\n",
    "    )\n",
    "\n",
    "MIN_FREQ = 1\n",
    "\n",
    "TEXT.build_vocab(train_data, \n",
    "                 min_freq = MIN_FREQ, # les mots qui apparaissent moins que MIN_FREQ fois seront ignorés du vocabulaire\n",
    "                 vectors = \"glove.6B.300d\",\n",
    "                 unk_init = torch.Tensor.normal_)\n",
    "\n",
    "TAG.build_vocab(train_data)\n",
    "BATCH_SIZE = 64\n",
    "\n",
    "device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')\n",
    "#device = 'cpu'\n",
    "train_iterator, valid_iterator, test_iterator = data.BucketIterator.splits(\n",
    "    (train_data, valid_data, test_data), \n",
    "    batch_size = BATCH_SIZE,\n",
    "    device = device, sort=False)\n",
    "\n",
    "# padding index\n",
    "TEXT_PAD_IDX = TEXT.vocab.stoi[TEXT.pad_token]\n",
    "TAG_PAD_IDX = TAG.vocab.stoi[TAG.pad_token]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "jH-cyyDAde-8"
   },
   "source": [
    "# Construire le modèle\n",
    "\n",
    "On ajoute une nouvelle couche à notre modèle. On utilise le module de PyTorch `MultiheadAttention`, qui est une implémentation du mécanisme d'attention décrit dans [cet article](https://papers.nips.cc/paper/7181-attention-is-all-you-need.pdf). \n",
    "\n",
    "Les inputs (*query*, *key*, et *value*) pour la couche d'attention sont les mêmes : la sortie du LSTM."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "tla69_ChdVwQ"
   },
   "outputs": [],
   "source": [
    "class BiLSTM(nn.Module):\n",
    "\n",
    "    def __init__(self,\n",
    "                 input_dim,\n",
    "                 embedding_dim,\n",
    "                 hidden_dim,\n",
    "                 output_dim,\n",
    "                 lstm_layers,\n",
    "                 attn_heads,\n",
    "                 emb_dropout,\n",
    "                 lstm_dropout,\n",
    "                 attn_dropout,\n",
    "                 fc_dropout,\n",
    "                 word_pad_idx,  \n",
    "                 tag_pad_idx):\n",
    "        super().__init__()\n",
    "        self.word_pad_idx = word_pad_idx  \n",
    "        self.tag_pad_idx = tag_pad_idx  \n",
    "        \n",
    "        # LAYER 1A: Word Embedding\n",
    "        self.embedding_dim = embedding_dim\n",
    "        self.embedding = nn.Embedding(\n",
    "            num_embeddings=input_dim,\n",
    "            embedding_dim=embedding_dim,\n",
    "            padding_idx=word_pad_idx\n",
    "        )\n",
    "        self.emb_dropout = nn.Dropout(emb_dropout)\n",
    "        \n",
    "        \n",
    "        # LAYER 2: BiLSTM\n",
    "        self.lstm = nn.LSTM(\n",
    "            input_size=embedding_dim,\n",
    "            hidden_size=hidden_dim,\n",
    "            num_layers=lstm_layers,\n",
    "            bidirectional=True,\n",
    "            dropout=lstm_dropout if lstm_layers > 1 else 0\n",
    "        )\n",
    "        \n",
    "        # LAYER 3: Self-attention\n",
    "        self.attn = nn.MultiheadAttention(\n",
    "            embed_dim=hidden_dim * 2,\n",
    "            num_heads=attn_heads,\n",
    "            dropout=attn_dropout\n",
    "        )\n",
    "        # LAYER 4: Fully-connected\n",
    "        self.fc_dropout = nn.Dropout(fc_dropout)\n",
    "        self.fc = nn.Linear(hidden_dim * 2, output_dim) \n",
    "        # LAYER 5: CRF\n",
    "        self.tag_pad_idx = tag_pad_idx\n",
    "        self.crf = CRF(num_tags=output_dim)\n",
    "        \n",
    "        for name, param in self.named_parameters():\n",
    "            nn.init.normal_(param.data, mean=0, std=0.1)\n",
    "\n",
    "    def forward(self, words, tags=None):\n",
    "        # words = [sentence length, batch size]\n",
    "        # tags = [sentence length, batch size]\n",
    "        \n",
    "        # embedding_out = [sentence length, batch size, embedding dim]\n",
    "        embedding_out = self.emb_dropout(self.embedding(words))\n",
    "  \n",
    "        # lstm_out = [sentence length, batch size, hidden dim * 2]\n",
    "        lstm_out, _ = self.lstm(embedding_out)\n",
    "        \n",
    "        # crée mask pour padding\n",
    "        # key_padding_mask = [batch size, sentence length]\n",
    "        key_padding_mask = torch.as_tensor(words == self.word_pad_idx).permute(1, 0)\n",
    "        # attn_out = [sentence length, batch size, hidden dim * 2]\n",
    "        # attn_weight = [batch size, sentence length, sentence length]\n",
    "        attn_out, attn_weight = self.attn(lstm_out, lstm_out, lstm_out, key_padding_mask=key_padding_mask)\n",
    "        # fc_out = [sentence length, batch size, output dim]\n",
    "        fc_out = self.fc(self.fc_dropout(attn_out))\n",
    "        crf_mask = words != self.word_pad_idx\n",
    "        crf_out = self.crf.decode(fc_out, mask=crf_mask)\n",
    "        crf_loss = -self.crf(fc_out, tags=tags, mask=crf_mask) if tags is not None else None\n",
    "        return crf_out, crf_loss, attn_weight\n",
    "\n",
    "    def init_crf_transitions(self, tag_names, imp_value=-100):\n",
    "        num_tags = len(tag_names)\n",
    "        for i in range(num_tags):\n",
    "            tag_name = tag_names[i]\n",
    "            # I and <pad> impossible au début\n",
    "            if tag_name[0] == \"I\" or tag_name == \"<pad>\":\n",
    "                torch.nn.init.constant_(self.crf.start_transitions[i], imp_value)\n",
    "        # transition impossible O - I\n",
    "        tag_is = {}\n",
    "        for tag_position in (\"B\", \"I\", \"O\"):\n",
    "            tag_is[tag_position] = [i for i, tag in enumerate(tag_names) if tag[0] == tag_position]\n",
    "        impossible_transitions_position = {\n",
    "            \"O\": \"I\"\n",
    "\n",
    "        }\n",
    "        for from_tag, to_tag_list in impossible_transitions_position.items():\n",
    "            to_tags = list(to_tag_list)\n",
    "            \n",
    "            for from_tag_i in tag_is[from_tag]:\n",
    "                for to_tag in to_tags:\n",
    "                    for to_tag_i in tag_is[to_tag]:\n",
    "                    \n",
    "                        torch.nn.init.constant_(\n",
    "                            self.crf.transitions[from_tag_i, to_tag_i], imp_value\n",
    "                        )\n",
    "        # transitions impossibles entre différents types\n",
    "        impossible_transitions_tags = {\n",
    "            \"B\": \"I\",\n",
    "            \"I\": \"I\"\n",
    "        }\n",
    "        for from_tag, to_tag_list in impossible_transitions_tags.items():\n",
    "            to_tags = list(to_tag_list)\n",
    "            for from_tag_i in tag_is[from_tag]:\n",
    "                for to_tag in to_tags:\n",
    "                    for to_tag_i in tag_is[to_tag]:\n",
    "                        if tag_names[from_tag_i].split(\"-\")[1] != tag_names[to_tag_i].split(\"-\")[1]:\n",
    "                            torch.nn.init.constant_(\n",
    "                                self.crf.transitions[from_tag_i, to_tag_i], imp_value\n",
    "                            )\n",
    "    \n",
    "    def count_parameters(self):\n",
    "        return sum(p.numel() for p in self.parameters() if p.requires_grad)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 293
    },
    "colab_type": "code",
    "id": "cKUIfovfdj5c",
    "outputId": "25991bda-d650-48df-e4ca-b4080583e480"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Le modèle a 7,441,978 paramètres à entraîner.\n"
     ]
    }
   ],
   "source": [
    "model = BiLSTM(\n",
    "    input_dim=len(TEXT.vocab),\n",
    "    embedding_dim=300,\n",
    "    hidden_dim=64,\n",
    "    output_dim=len(TAG.vocab),\n",
    "    lstm_layers=2,\n",
    "    attn_heads=16,\n",
    "    emb_dropout=0.5,\n",
    "    lstm_dropout=0.2,\n",
    "    attn_dropout=0.2,\n",
    "    fc_dropout=0.2,\n",
    "    word_pad_idx=TEXT_PAD_IDX,\n",
    "    tag_pad_idx=TAG_PAD_IDX\n",
    ")\n",
    "\n",
    "def init_weights(m):\n",
    "    for name, param in m.named_parameters():\n",
    "        nn.init.normal_(param.data, mean = 0, std = 0.1)\n",
    "        \n",
    "model.apply(init_weights)\n",
    "\n",
    "pretrained_embeddings = TEXT.vocab.vectors\n",
    "model.embedding.weight.data.copy_(pretrained_embeddings)\n",
    "model.embedding.weight.data[TAG_PAD_IDX] = torch.zeros(300)\n",
    "\n",
    "# CRF transitions initialisation\n",
    "model.init_crf_transitions(\n",
    "    tag_names=TAG.vocab.itos\n",
    ")\n",
    "print(f\"Le modèle a {model.count_parameters():,} paramètres à entraîner.\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "8okYjPr3drvI"
   },
   "source": [
    "# Entraînement\n",
    "\n",
    " - Optimiseur et fonction loss"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "def optimiseur(model, lr=1e-5, eps=1e-6, weight_decay_rate=0.001, second_weight_decay_rate=0.0):\n",
    "    param_optimizer = list(model.named_parameters())\n",
    "    no_decay = ['bias', 'gamma', 'beta']\n",
    "    optimizer_grouped_parameters = [\n",
    "        {'params': [p for n, p in param_optimizer if not any(nd in n for nd in no_decay)],\n",
    "            'weight_decay_rate': weight_decay_rate},\n",
    "        {'params': [p for n, p in param_optimizer if any(nd in n for nd in no_decay)],\n",
    "            'weight_decay_rate': second_weight_decay_rate}]\n",
    "    return optim.Adam(\n",
    "        optimizer_grouped_parameters,\n",
    "        lr=lr,\n",
    "        eps=eps\n",
    "    )\n",
    "\n",
    "optimizer = optimiseur(model, lr=1e-4, eps=1e-6, weight_decay_rate=0.01, second_weight_decay_rate=0.0)\n",
    "#scheduler = optim.lr_scheduler.StepLR(optimizer, step_size=10, gamma=0.5)\n",
    "\n",
    "criterion = nn.CrossEntropyLoss(ignore_index = TAG_PAD_IDX)\n",
    "\n",
    "model = model.to(device)\n",
    "criterion = criterion.to(device)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "optimizer = optim.Adam(model.parameters(),  lr=1e-4)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    " - Métriques"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.metrics import f1_score, classification_report\n",
    "\n",
    "def f1_loss( preds, y, tag_pad_idx, full_report=False):\n",
    "    index_o = TAG.vocab.stoi[\"O\"]\n",
    "    positive_labels = [i for i in range(len(TAG.vocab.itos))\n",
    "                       if i not in (tag_pad_idx, index_o)]\n",
    "\n",
    "    flatten_preds = [pred for sent_pred in preds for pred in sent_pred]\n",
    "\n",
    "    positive_preds = [pred for pred in flatten_preds\n",
    "                      if pred not in (tag_pad_idx, index_o)]\n",
    "\n",
    "    flatten_y = [tag for sent_tag in y for tag in sent_tag]\n",
    "    if full_report:\n",
    "      \n",
    "        positive_names = [TAG.vocab.itos[i]\n",
    "                              for i in range(len(TAG.vocab.itos))\n",
    "                              if i not in (tag_pad_idx, index_o)]\n",
    "        print(classification_report(\n",
    "                y_true=flatten_y,\n",
    "                y_pred=flatten_preds,\n",
    "                labels=positive_labels,\n",
    "                target_names=positive_names\n",
    "            ))\n",
    "\n",
    "    return f1_score(\n",
    "            y_true=flatten_y,\n",
    "            y_pred=flatten_preds,\n",
    "            labels=positive_labels,\n",
    "            average=\"micro\"\n",
    "        ), flatten_preds, flatten_y"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "def train(model, iterator, optimizer, tag_pad_idx):\n",
    "    \n",
    "    epoch_loss = 0\n",
    "    epoch_f1 = 0    \n",
    "    model.train()\n",
    "    \n",
    "    for batch in iterator:\n",
    "        \n",
    "        text = batch.text\n",
    "        tags = batch.tag\n",
    "      \n",
    "        optimizer.zero_grad()\n",
    "\n",
    "        pred_tags_list, batch_loss, _ = model(text, tags)\n",
    "        \n",
    "        # pour calculer la loss et le score f1, on flatten true tags\n",
    "        true_tags_list = [\n",
    "                [tag for tag in sent_tag if tag != TAG_PAD_IDX]\n",
    "                for sent_tag in tags.permute(1, 0).tolist()\n",
    "            ]\n",
    "        f1,_,_ = f1_loss(pred_tags_list, true_tags_list, tag_pad_idx)\n",
    "\n",
    "        batch_loss.backward()\n",
    "        \n",
    "        optimizer.step()\n",
    "        epoch_loss += batch_loss.item()\n",
    "        epoch_f1 += f1\n",
    "        \n",
    "    return epoch_loss / len(iterator), epoch_f1 / len(iterator)\n",
    "\n",
    "def evaluate(model, iterator, tag_pad_idx,full_report):\n",
    "    \n",
    "    epoch_loss = 0\n",
    "    epoch_f1 = 0\n",
    "    \n",
    "    model.eval()\n",
    "    preds = []\n",
    "    labels = []\n",
    "    with torch.no_grad():\n",
    "    \n",
    "        for batch in iterator:\n",
    "\n",
    "            text = batch.text\n",
    "            tags = batch.tag\n",
    "        \n",
    "            pred_tags_list, batch_loss,_ = model(text, tags)\n",
    "            true_tags_list = [\n",
    "                [tag for tag in sent_tag if tag != TAG_PAD_IDX]\n",
    "                for sent_tag in tags.permute(1, 0).tolist()\n",
    "                ]\n",
    "            \n",
    "            f1, pred, lab = f1_loss(pred_tags_list, true_tags_list, tag_pad_idx, full_report)\n",
    "            preds.append(pred)\n",
    "            labels.append(lab)\n",
    "            epoch_loss += batch_loss.item()\n",
    "            epoch_f1 += f1\n",
    "        \n",
    "    return epoch_loss / len(iterator), epoch_f1 / len(iterator),preds, labels"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch: 01 | Epoch Time: 1m 5s\n",
      "\tTrain Loss: 661.254 | Train F1 score: 0.24%\n",
      "\t Val. Loss: 560.469 |  Val. F1 score: 0.00%\n",
      "Epoch: 11 | Epoch Time: 1m 5s\n",
      "\tTrain Loss: 188.922 | Train F1 score: 52.35%\n",
      "\t Val. Loss: 490.283 |  Val. F1 score: 43.81%\n",
      "Epoch: 21 | Epoch Time: 0m 43s\n",
      "\tTrain Loss: 143.336 | Train F1 score: 64.42%\n",
      "\t Val. Loss: 513.242 |  Val. F1 score: 52.50%\n",
      "Epoch: 31 | Epoch Time: 0m 38s\n",
      "\tTrain Loss: 117.209 | Train F1 score: 71.57%\n",
      "\t Val. Loss: 446.614 |  Val. F1 score: 61.12%\n",
      "Epoch: 41 | Epoch Time: 0m 41s\n",
      "\tTrain Loss: 98.804 | Train F1 score: 75.86%\n",
      "\t Val. Loss: 458.566 |  Val. F1 score: 64.68%\n"
     ]
    }
   ],
   "source": [
    "def epoch_time(start_time, end_time):\n",
    "    elapsed_time = end_time - start_time\n",
    "    elapsed_mins = int(elapsed_time / 60)\n",
    "    elapsed_secs = int(elapsed_time - (elapsed_mins * 60))\n",
    "    return elapsed_mins, elapsed_secs\n",
    "\n",
    "N_EPOCHS = 50\n",
    "\n",
    "t_loss = []\n",
    "t_f1 = []\n",
    "v_loss = []\n",
    "v_f1 = []\n",
    "\n",
    "best_valid_loss = float('inf')\n",
    "\n",
    "for epoch in range(N_EPOCHS):\n",
    "\n",
    "    start_time = time.time()\n",
    "   \n",
    "    \n",
    "    train_loss, train_f1 = train(model, train_iterator, optimizer, TAG_PAD_IDX)\n",
    "    t_loss.append(train_loss)\n",
    "    t_f1.append(train_f1) \n",
    "    \n",
    "    valid_loss, valid_f1,_,_ = evaluate(model, valid_iterator, TAG_PAD_IDX, full_report= False)\n",
    "    v_loss.append(valid_loss)\n",
    "    v_f1.append(valid_f1)\n",
    "    \n",
    "    #scheduler.step()\n",
    "    end_time = time.time()\n",
    "\n",
    "    epoch_mins, epoch_secs = epoch_time(start_time, end_time)\n",
    "    \n",
    "    if valid_loss < best_valid_loss:\n",
    "        best_valid_loss = valid_loss\n",
    "        torch.save(model.state_dict(), 'tut4-model_conll.pt')\n",
    "    \n",
    "\n",
    "    if epoch%10 == 0: \n",
    "        print(f'Epoch: {epoch+1:02} | Epoch Time: {epoch_mins}m {epoch_secs}s')\n",
    "        print(f'\\tTrain Loss: {train_loss:.3f} | Train F1 score: {train_f1*100:.2f}%')\n",
    "        print(f'\\t Val. Loss: {valid_loss:.3f} |  Val. F1 score: {valid_f1*100:.2f}%')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.legend.Legend at 0x7fb7f4126150>"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import seaborn as sns\n",
    "import matplotlib.pyplot as plt \n",
    "import numpy as np \n",
    "sns.set()\n",
    "\n",
    "x = np.linspace(0, N_EPOCHS,N_EPOCHS)\n",
    "\n",
    "plt.plot(x,t_loss)\n",
    "plt.plot(x,v_loss)\n",
    "plt.title(\"Loss\")\n",
    "plt.legend([\"Train loss\", \"Valid loss\"])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.legend.Legend at 0x7fb7f405f290>"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "x = np.linspace(0, N_EPOCHS,N_EPOCHS)\n",
    "\n",
    "plt.plot(x,t_f1)\n",
    "plt.plot(x,v_f1)\n",
    "plt.title(\"F1 score\")\n",
    "plt.legend([\"Train F1\", \"Valid F1\"])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Test Loss: 568.749 |  Test F1 score: 54.10%\n"
     ]
    }
   ],
   "source": [
    "from sklearn.metrics import confusion_matrix, precision_recall_fscore_support\n",
    "model.load_state_dict(torch.load('tut4-model_conll.pt'))\n",
    "\n",
    "test_loss, test_f1, preds, labels = evaluate(model, test_iterator, TAG_PAD_IDX, full_report=False)\n",
    "print(f'Test Loss: {test_loss:.3f} |  Test F1 score: {test_f1*100:.2f}%')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "predict =  [item for sublist in preds for item in sublist]\n",
    "true =  [item for sublist in labels for item in sublist]\n",
    "confusion = confusion_matrix(true, predict)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Matrice de confusion"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>O</th>\n",
       "      <th>LOC</th>\n",
       "      <th>PER</th>\n",
       "      <th>ORG</th>\n",
       "      <th>MISC</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>O</th>\n",
       "      <td>38403</td>\n",
       "      <td>17</td>\n",
       "      <td>33</td>\n",
       "      <td>20</td>\n",
       "      <td>47</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>LOC</th>\n",
       "      <td>491</td>\n",
       "      <td>1256</td>\n",
       "      <td>98</td>\n",
       "      <td>52</td>\n",
       "      <td>27</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>PER</th>\n",
       "      <td>1886</td>\n",
       "      <td>12</td>\n",
       "      <td>851</td>\n",
       "      <td>17</td>\n",
       "      <td>6</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>ORG</th>\n",
       "      <td>1047</td>\n",
       "      <td>137</td>\n",
       "      <td>239</td>\n",
       "      <td>947</td>\n",
       "      <td>124</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>MISC</th>\n",
       "      <td>399</td>\n",
       "      <td>7</td>\n",
       "      <td>34</td>\n",
       "      <td>15</td>\n",
       "      <td>460</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "          O   LOC  PER  ORG  MISC\n",
       "O     38403    17   33   20    47\n",
       "LOC     491  1256   98   52    27\n",
       "PER    1886    12  851   17     6\n",
       "ORG    1047   137  239  947   124\n",
       "MISC    399     7   34   15   460"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "confusion_df =pd.DataFrame(confusion)\n",
    "\n",
    "confusion_df.columns=[i for i in TAG.vocab.itos][1:]\n",
    "s = pd.Series([i for i in TAG.vocab.itos][1:])\n",
    "confusion_df = confusion_df.set_index([s])\n",
    "\n",
    "confusion_df['LOC'] = confusion_df['B-LOC'] + confusion_df['I-LOC']\n",
    "confusion_df['PER'] = confusion_df['B-PER'] + confusion_df['I-PER']\n",
    "confusion_df['ORG'] = confusion_df['B-ORG'] + confusion_df['I-ORG']\n",
    "confusion_df['MISC'] = confusion_df['B-MISC'] + confusion_df['I-MISC']\n",
    "\n",
    "\n",
    "confusion_df = confusion_df.drop(columns=[ i for i in TAG.vocab.itos if i != 'O' and i != '<pad>' ])\n",
    "\n",
    "confusion_df.loc['LOC'] = confusion_df.loc['B-LOC'] + confusion_df.loc['I-LOC']\n",
    "confusion_df.loc['PER'] = confusion_df.loc['B-PER'] + confusion_df.loc['I-PER']\n",
    "confusion_df.loc['ORG'] = confusion_df.loc['B-ORG'] + confusion_df.loc['I-ORG']\n",
    "confusion_df.loc['MISC'] = confusion_df.loc['B-MISC'] + confusion_df.loc['I-MISC']\n",
    "\n",
    "confusion_df = confusion_df.drop([i for i in TAG.vocab.itos if i != 'O' and i != '<pad>' ])\n",
    "\n",
    "confusion_df"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Precision-Recall-F1Score"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "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>Precision</th>\n",
       "      <th>Recall</th>\n",
       "      <th>F1-score</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>O</th>\n",
       "      <td>0.909463</td>\n",
       "      <td>0.996963</td>\n",
       "      <td>0.951205</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>LOC</th>\n",
       "      <td>0.878936</td>\n",
       "      <td>0.652807</td>\n",
       "      <td>0.749180</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>PER</th>\n",
       "      <td>0.678088</td>\n",
       "      <td>0.306999</td>\n",
       "      <td>0.422647</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>ORG</th>\n",
       "      <td>0.901047</td>\n",
       "      <td>0.379711</td>\n",
       "      <td>0.534274</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>MISC</th>\n",
       "      <td>0.692771</td>\n",
       "      <td>0.502732</td>\n",
       "      <td>0.582647</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "      Precision    Recall  F1-score\n",
       "O      0.909463  0.996963  0.951205\n",
       "LOC    0.878936  0.652807  0.749180\n",
       "PER    0.678088  0.306999  0.422647\n",
       "ORG    0.901047  0.379711  0.534274\n",
       "MISC   0.692771  0.502732  0.582647"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "cm = confusion_df.to_numpy()\n",
    "\n",
    "TP = np.diag(cm)\n",
    "FP = np.sum(cm, axis=0) - TP\n",
    "FN = np.sum(cm, axis=1) - TP\n",
    "\n",
    "num_classes = 4\n",
    "TN = []\n",
    "for i in range(num_classes):\n",
    "    temp = np.delete(cm, i, 0)    \n",
    "    temp = np.delete(temp, i, 1) \n",
    "    TN.append(sum(sum(temp)))\n",
    "    \n",
    "precision = TP/(TP+FP)\n",
    "recall = TP/(TP+FN)\n",
    "f1 = (2*precision*recall)/(precision+recall)\n",
    "\n",
    "prf_df =pd.DataFrame()\n",
    "prf_df['Precision'] = precision\n",
    "prf_df['Recall'] = recall\n",
    "prf_df['F1-score'] = f1\n",
    "\n",
    "s = pd.Series([i for i in confusion_df.index])\n",
    "prf_df = prf_df.set_index([s])\n",
    "\n",
    "prf_df"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "On peut visualiser les poids d'attention."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "def visualize_attn(tokens, weights):\n",
    "    fig, ax = plt.subplots(figsize=(8, 8))\n",
    "    im = ax.imshow(weights, cmap=plt.get_cmap(\"gray\"))\n",
    "    ax.set_xticks(list(range(len(tokens))))\n",
    "    ax.set_yticks(list(range(len(tokens))))\n",
    "    ax.set_xticklabels(tokens)\n",
    "    ax.set_yticklabels(tokens)\n",
    "    # Create colorbar\n",
    "    _ = ax.figure.colorbar(im, ax=ax)\n",
    "    # Rotate the tick labels and set their alignment.\n",
    "    plt.setp(ax.get_xticklabels(), rotation=60, ha=\"right\",\n",
    "                 rotation_mode=\"anchor\")\n",
    "    plt.tight_layout()\n",
    "    plt.show()\n",
    "\n",
    "def tag_sentence(model, device, sentence, text_field, tag_field):\n",
    " \n",
    "    model.eval()\n",
    "    \n",
    "    if isinstance(sentence, str):\n",
    "        nlp = spacy.load('en')\n",
    "        tokens = [token.text for token in nlp(sentence)]\n",
    "    else:\n",
    "        tokens = [token for token in sentence]\n",
    "\n",
    "    if text_field.lower:\n",
    "        tokens = [t.lower() for t in tokens]\n",
    "        \n",
    "    max_word_len = max([len(token) for token in tokens])\n",
    "    \n",
    "    numericalized_tokens = [text_field.vocab.stoi[t] for t in tokens]\n",
    "    unk_idx = text_field.vocab.stoi[text_field.unk_token]  \n",
    "    unks = [t for t, n in zip(tokens, numericalized_tokens) if n == unk_idx]\n",
    "    \n",
    "    token_tensor = torch.LongTensor(numericalized_tokens)    \n",
    "    token_tensor = token_tensor.unsqueeze(-1).to(device)\n",
    "    \n",
    "    predictions,_, attn_weight = model(token_tensor)\n",
    "    visualize_attn(tokens, attn_weight.detach().cpu().numpy()[0])\n",
    "    \n",
    "    predicted_tags = [tag_field.vocab.itos[t] for t in predictions[0]]\n",
    "    \n",
    "    return tokens, predicted_tags, unks"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "sentence :  ['West', 'Indian', 'all-rounder', 'Phil', 'Simmons', 'took', 'four', 'for', '38', 'on', 'Friday', 'as', 'Leicestershire', 'beat', 'Somerset', 'by', 'an', 'innings', 'and', '39', 'runs', 'in', 'two', 'days', 'to', 'take', 'over', 'at', 'the', 'head', 'of', 'the', 'county', 'championship', '.']\n",
      "actual tags :  ['B-MISC', 'I-MISC', 'O', 'B-PER', 'I-PER', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'B-ORG', 'O', 'B-ORG', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O', 'O']\n"
     ]
    }
   ],
   "source": [
    "example_index = 3\n",
    "\n",
    "sentence = vars(valid_data.examples[example_index])['text']\n",
    "actual_tags = vars(valid_data.examples[example_index])['tag']\n",
    "\n",
    "print(\"sentence : \", sentence)\n",
    "print(\"actual tags : \", actual_tags)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 576x576 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Pred. Tag\t\t\t\tActual Tag\t\t\t\tCorrect?\t\t\t\tToken\n",
      "\n",
      "B-MISC \t\t\t\t B-MISC \t\t\t\t ✔ \t\t\t\t\t West\n",
      "I-MISC \t\t\t\t I-MISC \t\t\t\t ✔ \t\t\t\t\t Indian\n",
      "O \t\t\t\t\t O \t\t\t\t\t ✔ \t\t\t\t\t all-rounder\n",
      "B-PER \t\t\t\t B-PER \t\t\t\t ✔ \t\t\t\t\t Phil\n",
      "I-PER \t\t\t\t I-PER \t\t\t\t ✔ \t\t\t\t\t Simmons\n",
      "O \t\t\t\t\t O \t\t\t\t\t ✔ \t\t\t\t\t took\n",
      "O \t\t\t\t\t O \t\t\t\t\t ✔ \t\t\t\t\t four\n",
      "O \t\t\t\t\t O \t\t\t\t\t ✔ \t\t\t\t\t for\n",
      "O \t\t\t\t\t O \t\t\t\t\t ✔ \t\t\t\t\t 38\n",
      "O \t\t\t\t\t O \t\t\t\t\t ✔ \t\t\t\t\t on\n",
      "O \t\t\t\t\t O \t\t\t\t\t ✔ \t\t\t\t\t Friday\n",
      "O \t\t\t\t\t O \t\t\t\t\t ✔ \t\t\t\t\t as\n",
      "O \t\t\t\t\t B-ORG \t\t\t\t ✘ \t\t\t\t\t Leicestershire\n",
      "O \t\t\t\t\t O \t\t\t\t\t ✔ \t\t\t\t\t beat\n",
      "B-PER \t\t\t\t B-ORG \t\t\t\t ✘ \t\t\t\t\t Somerset\n",
      "O \t\t\t\t\t O \t\t\t\t\t ✔ \t\t\t\t\t by\n",
      "O \t\t\t\t\t O \t\t\t\t\t ✔ \t\t\t\t\t an\n",
      "O \t\t\t\t\t O \t\t\t\t\t ✔ \t\t\t\t\t innings\n",
      "O \t\t\t\t\t O \t\t\t\t\t ✔ \t\t\t\t\t and\n",
      "O \t\t\t\t\t O \t\t\t\t\t ✔ \t\t\t\t\t 39\n",
      "O \t\t\t\t\t O \t\t\t\t\t ✔ \t\t\t\t\t runs\n",
      "O \t\t\t\t\t O \t\t\t\t\t ✔ \t\t\t\t\t in\n",
      "O \t\t\t\t\t O \t\t\t\t\t ✔ \t\t\t\t\t two\n",
      "O \t\t\t\t\t O \t\t\t\t\t ✔ \t\t\t\t\t days\n",
      "O \t\t\t\t\t O \t\t\t\t\t ✔ \t\t\t\t\t to\n",
      "O \t\t\t\t\t O \t\t\t\t\t ✔ \t\t\t\t\t take\n",
      "O \t\t\t\t\t O \t\t\t\t\t ✔ \t\t\t\t\t over\n",
      "O \t\t\t\t\t O \t\t\t\t\t ✔ \t\t\t\t\t at\n",
      "O \t\t\t\t\t O \t\t\t\t\t ✔ \t\t\t\t\t the\n",
      "O \t\t\t\t\t O \t\t\t\t\t ✔ \t\t\t\t\t head\n",
      "O \t\t\t\t\t O \t\t\t\t\t ✔ \t\t\t\t\t of\n",
      "O \t\t\t\t\t O \t\t\t\t\t ✔ \t\t\t\t\t the\n",
      "O \t\t\t\t\t O \t\t\t\t\t ✔ \t\t\t\t\t county\n",
      "O \t\t\t\t\t O \t\t\t\t\t ✔ \t\t\t\t\t championship\n",
      "O \t\t\t\t\t O \t\t\t\t\t ✔ \t\t\t\t\t .\n"
     ]
    }
   ],
   "source": [
    "tokens, pred_tags, unks = tag_sentence(model, \n",
    "                                       device, \n",
    "                                       sentence, \n",
    "                                       TEXT, \n",
    "                                       TAG)\n",
    "\n",
    "\n",
    "print(\"Pred. Tag\\t\\t\\t\\tActual Tag\\t\\t\\t\\tCorrect?\\t\\t\\t\\tToken\\n\")\n",
    "for token, pred_tag, actual_tag in zip(tokens, pred_tags, actual_tags):\n",
    "    correct = '✔' if pred_tag == actual_tag else '✘'\n",
    "    space = 5 if pred_tag == 'O'else 4\n",
    "    space1 = 5 if actual_tag == 'O'else 4    \n",
    "    print(pred_tag,\"\\t\"*space, actual_tag, \"\\t\"*space1, correct,\"\\t\"*5, token)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 576x576 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[]\n",
      "Pred. Tag\tToken\n",
      "\n",
      "O\t\tThe\n",
      "O\t\twill\n",
      "O\t\tdeliver\n",
      "O\t\ta\n",
      "O\t\tspeech\n",
      "O\t\tabout\n",
      "O\t\tthe\n",
      "O\t\tconflict\n",
      "O\t\tin\n",
      "B-LOC\t\tNorth\n",
      "I-LOC\t\tKorea\n",
      "O\t\ttomorrow\n",
      "O\t\tin\n",
      "B-LOC\t\tNew\n",
      "I-LOC\t\tYork\n",
      "O\t\twith\n",
      "O\t\tmy\n",
      "O\t\tfriend\n",
      "O\t\tMary\n",
      "O\t\tKate\n",
      "O\t\t.\n"
     ]
    }
   ],
   "source": [
    "sentence = 'The will deliver a speech about the conflict in North Korea tomorrow in New York with my friend Mary Kate.'\n",
    "\n",
    "tokens, tags, unks = tag_sentence(model, \n",
    "                                  device, \n",
    "                                  sentence, \n",
    "                                  TEXT, \n",
    "                                  TAG)\n",
    "\n",
    "print(unks)\n",
    "print(\"Pred. Tag\\tToken\\n\")\n",
    "\n",
    "\n",
    "for token, tag in zip(tokens, tags):\n",
    "    print(f\"{tag}\\t\\t{token}\")"
   ]
  }
 ],
 "metadata": {
  "colab": {
   "collapsed_sections": [],
   "name": "5 - BiLSTM with Multi-head Dot-Product Self-Attention for Indonesian NER",
   "provenance": []
  },
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}