notebook_key-point_matching.ipynb

{
  "cells": [
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "oXyt3vkIw7K2",
        "outputId": "4aa6d7a0-bd87-4d7d-efa5-d40c6e961cef"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Mounted at /content/drive\n"
          ]
        }
      ],
      "source": [
        "'''\n",
        "Marco Costante, Alex Costanzino, Alessandra Stramiglio, Xiaowei Wen\n",
        "MSc students in Artificial Intelligence\n",
        "@ Alma Mater Studiorum, University of Bologna\n",
        "January, 2022\n",
        "'''\n",
        "\n",
        "from google.colab import drive\n",
        "drive.mount('/content/drive')"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "4847FosCyyhj"
      },
      "source": [
        "# Project work: **Key-Points Matching**\n",
        "Key Point Analysis (KPA) is a new NLP task, with strong relations to computational argumentation, opinion analysis, and summarization.\n",
        "\n",
        "Given an input corpus, consisting of a collection of relatively short, opinionated texts focused on a topic of interest, the goal of KPA is to produce a succinct list of the most prominent key-points in the input corpus, along with their relative prevalence. Thus, the output of KPA is a bullet-like summary, with an important quantitative angle and an associated well-defined evaluation framework. \n",
        "\n",
        "Successful solutions to KPA can be used to gain better insights from public opinions as expressed in social media, surveys, and so forth, giving rise to a new form of a communication channel between decision makers and people that might be impacted by the decision."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "OxAEuybR3KvW"
      },
      "outputs": [],
      "source": [
        "import numpy as np\n",
        "import pandas as pd\n",
        "import tensorflow as tf\n",
        "\n",
        "!pip install tensorflow-text --quiet\n",
        "import tensorflow_text as text\n",
        "\n",
        "!pip install --upgrade tensorflow_hub --quiet\n",
        "import tensorflow_hub as hub\n",
        "\n",
        "import matplotlib.pyplot as plt\n",
        "from tqdm import tqdm\n",
        "\n",
        "!pip install contractions --quiet\n",
        "import contractions\n",
        "\n",
        "!pip install focal-loss --quiet\n",
        "import focal_loss\n",
        "\n",
        "!pip install -U sentence-transformers --quiet\n",
        "import sentence_transformers"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "k2TCu5NMy3oG"
      },
      "source": [
        "## 1.0 **Data loading**\n",
        "The dataset is divided in:\n",
        "* Arguments (`arg_id`, `argument`, `topic`, `stance`);\n",
        "* Keypoint (`key_point_id`, `keypoint`, `topic`, `stance`);\n",
        "* Labels (`arg_id`, `key_point_id`, label).\n",
        "\n",
        "Each dataset has its own split (train, dev and test).\n",
        "The dataset is directly loaded via url from the GitHub repository."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Iu4p-8vF3y-Y",
        "outputId": "a3ecad7f-1b60-4f47-b2b1-cbfb02d59ea1"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "There are 5583 arguments in the train set, 932 arguments in the dev set and 723 arguments in the test set.\n"
          ]
        }
      ],
      "source": [
        "# Arguments dataset loading.\n",
        "arguments_train = pd.read_csv(filepath_or_buffer = 'https://raw.githubusercontent.com/IBM/KPA_2021_shared_task/main/kpm_data/arguments_train.csv')\n",
        "arguments_dev = pd.read_csv(filepath_or_buffer = 'https://raw.githubusercontent.com/IBM/KPA_2021_shared_task/main/kpm_data/arguments_dev.csv')\n",
        "arguments_test = pd.read_csv(filepath_or_buffer = 'https://raw.githubusercontent.com/IBM/KPA_2021_shared_task/main/test_data/arguments_test.csv')\n",
        "\n",
        "print(f'There are {len(arguments_train)} arguments in the train set, {len(arguments_dev)} arguments in the dev set and {len(arguments_test)} arguments in the test set.')\n",
        "\n",
        "# Check.\n",
        "# arguments_train.head()\n",
        "# arguments_dev.head()\n",
        "# arguments_test.head()"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "N8T0uT3Z36q7",
        "outputId": "41319c3c-028c-46f6-fcde-5f0b9c7726c9"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "There are 207 keypoints in the train set, 36 keypoints in the dev set and 33 keypoints in the test set.\n"
          ]
        }
      ],
      "source": [
        "# Key-points dataest loading.\n",
        "key_points_train = pd.read_csv(filepath_or_buffer = 'https://raw.githubusercontent.com/IBM/KPA_2021_shared_task/main/kpm_data/key_points_train.csv')\n",
        "key_points_dev = pd.read_csv(filepath_or_buffer = 'https://raw.githubusercontent.com/IBM/KPA_2021_shared_task/main/kpm_data/key_points_dev.csv')\n",
        "key_points_test = pd.read_csv(filepath_or_buffer = 'https://raw.githubusercontent.com/IBM/KPA_2021_shared_task/main/test_data/key_points_test.csv')\n",
        "\n",
        "print(f'There are {len(key_points_train)} keypoints in the train set, {len(key_points_dev)} keypoints in the dev set and {len(key_points_test)} keypoints in the test set.')\n",
        "\n",
        "# Check.\n",
        "# key_points_train.head()\n",
        "# key_points_dev.head()\n",
        "# key_points_test.head()"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "xtqWZbTe36xS",
        "outputId": "eedad6ce-7b4f-4474-fe41-6c7036088752"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "There are 20635 labels in the train set, 3458 labels in the dev set and 3426 labels in the test set.\n"
          ]
        }
      ],
      "source": [
        "# Labels dataset loading.\n",
        "labels_train = pd.read_csv(filepath_or_buffer = 'https://raw.githubusercontent.com/IBM/KPA_2021_shared_task/main/kpm_data/labels_train.csv')\n",
        "labels_dev = pd.read_csv(filepath_or_buffer = 'https://raw.githubusercontent.com/IBM/KPA_2021_shared_task/main/kpm_data/labels_dev.csv')\n",
        "labels_test = pd.read_csv(filepath_or_buffer = 'https://raw.githubusercontent.com/IBM/KPA_2021_shared_task/main/test_data/labels_test.csv')\n",
        "\n",
        "print(f'There are {len(labels_train)} labels in the train set, {len(labels_dev)} labels in the dev set and {len(labels_test)} labels in the test set.')\n",
        "\n",
        "# Check.\n",
        "# labels_train.head()\n",
        "# labels_dev.head()\n",
        "# labels_test.head()"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "_Sdi7-a6Ypch"
      },
      "source": [
        "The dataset is unbalanced."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "eZeDsyHXWrzn",
        "outputId": "ac0d7a67-1fd6-4220-e92b-b18ca4782060"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "There are 4260 positive samples and 16375 negative samples over 20635 samples of the training set.\n",
            "There are 738 positive samples and 2720 negative samples over 3458 samples of the development set.\n",
            "There are 552 positive samples and 2874 negative samples over 3426 samples of the test set.\n"
          ]
        }
      ],
      "source": [
        "# Balance of the train dataset.\n",
        "print(f\"There are {np.sum(labels_train['label'].tolist())} positive samples and {len(labels_train['label']) - np.sum(labels_train['label'].tolist())} negative samples over {len(labels_train['label'])} samples of the training set.\")\n",
        "# Balance of the dev dataset.\n",
        "print(f\"There are {np.sum(labels_dev['label'].tolist())} positive samples and {len(labels_dev['label']) - np.sum(labels_dev['label'].tolist())} negative samples over {len(labels_dev['label'])} samples of the development set.\")\n",
        "# Balance of the test dataset.\n",
        "print(f\"There are {np.sum(labels_test['label'].tolist())} positive samples and {len(labels_test['label']) - np.sum(labels_test['label'].tolist())} negative samples over {len(labels_test['label'])} samples of the test set.\")"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "UaFHaKW9A_jt"
      },
      "source": [
        "## 2.0 **Data processing**"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "2UGqYY2dBb5m"
      },
      "source": [
        "### 2.1 **Text cleaning**\n",
        "The text cleaning consists in lowercase every letter, expand abbreviations and verbal contractions, remove possible special characters and uncommon symbols.\n",
        "\n",
        "Notice that the new dataframes override the previous ones."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "a6YvcijoBe7J",
        "outputId": "ea0cf208-7a3a-4e32-aabd-b62d2324f64c"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Before: \n",
            "\n",
            "                                            argument                                          topic\n",
            "0  `people reach their limit when it comes to the...  Assisted suicide should be a criminal offence\n",
            "1  A patient should be able to decide when they h...  Assisted suicide should be a criminal offence\n",
            "2  a person has the right to end their suffering ...  Assisted suicide should be a criminal offence\n",
            "3  a person should have the dignity to choose how...  Assisted suicide should be a criminal offence\n",
            "4  a person should have the right to be able to c...  Assisted suicide should be a criminal offence\n",
            "After: \n",
            "\n",
            "                                            argument                                          topic\n",
            "0  people reach their limit when it comes to thei...  assisted suicide should be a criminal offence\n",
            "1  a patient should be able to decide when they h...  assisted suicide should be a criminal offence\n",
            "2  a person has the right to end their suffering ...  assisted suicide should be a criminal offence\n",
            "3  a person should have the dignity to choose how...  assisted suicide should be a criminal offence\n",
            "4  a person should have the right to be able to c...  assisted suicide should be a criminal offence\n",
            "Before: \n",
            "\n",
            "                                            argument                                        topic\n",
            "0  having a school uniform can reduce bullying as...  We should abandon the use of school uniform\n",
            "1             it is a good way to instill discipline  We should abandon the use of school uniform\n",
            "2  it is cheaper for parents to buy school unifor...  We should abandon the use of school uniform\n",
            "3  one of the benefits of school uniforms is that...  We should abandon the use of school uniform\n",
            "4  researchers found that in schools across the w...  We should abandon the use of school uniform\n",
            "After: \n",
            "\n",
            "                                            argument                                        topic\n",
            "0  having a school uniform can reduce bullying as...  we should abandon the use of school uniform\n",
            "1             it is a good way to instill discipline  we should abandon the use of school uniform\n",
            "2  it is cheaper for parents to buy school unifor...  we should abandon the use of school uniform\n",
            "3  one of the benefits of school uniforms is that...  we should abandon the use of school uniform\n",
            "4  researchers found that in schools across the w...  we should abandon the use of school uniform\n",
            "Before: \n",
            "\n",
            "                                            argument                                           topic\n",
            "0  Routine child vaccinations isn't mandatory sin...  Routine child vaccinations should be mandatory\n",
            "1  Routine child vaccinations should not be manda...  Routine child vaccinations should be mandatory\n",
            "2  Routine child vaccinations should not be neces...  Routine child vaccinations should be mandatory\n",
            "3  A vaccine that has not been sufficiently teste...  Routine child vaccinations should be mandatory\n",
            "4  As long as vaccines are not free of side effec...  Routine child vaccinations should be mandatory\n",
            "After: \n",
            "\n",
            "                                            argument                                           topic\n",
            "0  routine child vaccinations is not mandatory si...  routine child vaccinations should be mandatory\n",
            "1  routine child vaccinations should not be manda...  routine child vaccinations should be mandatory\n",
            "2  routine child vaccinations should not be neces...  routine child vaccinations should be mandatory\n",
            "3  a vaccine that has not been sufficiently teste...  routine child vaccinations should be mandatory\n",
            "4  as long as vaccines are not free of side effec...  routine child vaccinations should be mandatory\n",
            "Before: \n",
            "\n",
            "                                           key_point                                          topic\n",
            "0  Assisted suicide gives dignity to the person t...  Assisted suicide should be a criminal offence\n",
            "1                 Assisted suicide reduces suffering  Assisted suicide should be a criminal offence\n",
            "2  People should have the freedom to choose to en...  Assisted suicide should be a criminal offence\n",
            "3  The terminally ill would benefit from assisted...  Assisted suicide should be a criminal offence\n",
            "4  Assisted suicide allows people to solicit some...  Assisted suicide should be a criminal offence\n",
            "After: \n",
            "\n",
            "                                           key_point                                          topic\n",
            "0  assisted suicide gives dignity to the person t...  assisted suicide should be a criminal offence\n",
            "1                 assisted suicide reduces suffering  assisted suicide should be a criminal offence\n",
            "2  people should have the freedom to choose to en...  assisted suicide should be a criminal offence\n",
            "3  the terminally ill would benefit from assisted...  assisted suicide should be a criminal offence\n",
            "4  assisted suicide allows people to solicit some...  assisted suicide should be a criminal offence\n",
            "Before: \n",
            "\n",
            "                                           key_point                                        topic\n",
            "0  Children can still express themselves using ot...  We should abandon the use of school uniform\n",
            "1                    School uniform reduces bullying  We should abandon the use of school uniform\n",
            "2  School uniforms encourage discipline or focus ...  We should abandon the use of school uniform\n",
            "3                        School uniforms saves costs  We should abandon the use of school uniform\n",
            "4   School uniforms create a sense of equality/unity  We should abandon the use of school uniform\n",
            "After: \n",
            "\n",
            "                                           key_point                                        topic\n",
            "0  children can still express themselves using ot...  we should abandon the use of school uniform\n",
            "1                    school uniform reduces bullying  we should abandon the use of school uniform\n",
            "2  school uniforms encourage discipline or focus ...  we should abandon the use of school uniform\n",
            "3                        school uniforms saves costs  we should abandon the use of school uniform\n",
            "4   school uniforms create a sense of equality unity  we should abandon the use of school uniform\n",
            "Before: \n",
            "\n",
            "                                           key_point                                           topic\n",
            "0  Routine child vaccinations, or their side effe...  Routine child vaccinations should be mandatory\n",
            "1     Mandatory vaccination contradicts basic rights  Routine child vaccinations should be mandatory\n",
            "2        The parents and not the state should decide  Routine child vaccinations should be mandatory\n",
            "3  Routine child vaccinations are not necessary t...  Routine child vaccinations should be mandatory\n",
            "4           Routine child vaccinations are effective  Routine child vaccinations should be mandatory\n",
            "After: \n",
            "\n",
            "                                           key_point                                           topic\n",
            "0  routine child vaccinations  or their side effe...  routine child vaccinations should be mandatory\n",
            "1     mandatory vaccination contradicts basic rights  routine child vaccinations should be mandatory\n",
            "2        the parents and not the state should decide  routine child vaccinations should be mandatory\n",
            "3  routine child vaccinations are not necessary t...  routine child vaccinations should be mandatory\n",
            "4           routine child vaccinations are effective  routine child vaccinations should be mandatory\n"
          ]
        }
      ],
      "source": [
        "import re\n",
        "import nltk\n",
        "\n",
        "from typing import List, Callable\n",
        "from functools import reduce\n",
        "\n",
        "# Lowercase everything.\n",
        "def lower(text: str) -> str:\n",
        "    return text.lower()\n",
        "\n",
        "# Expand abbreviations and verbal contractions.\n",
        "def expand(text: str) -> str:\n",
        "    return contractions.fix(text)\n",
        "\n",
        "# Remove special characters.\n",
        "def replace_special_characters(text: str) -> str:\n",
        "    replace_symbols = re.compile('[/(){}\\[\\]\\|@,;]')\n",
        "    return replace_symbols.sub(' ', text)\n",
        "\n",
        "def filter_out_uncommon_symbols(text: str) -> str:\n",
        "    good_symbols = re.compile('[^0-9a-z #+_]')\n",
        "    return re.sub(good_symbols, '', text)\n",
        "\n",
        "pipeline = [lower, expand, replace_special_characters, filter_out_uncommon_symbols]\n",
        "\n",
        "def text_prepare(text: str,\n",
        "                 filter_methods: List[Callable[[str], str]] = None) -> str:\n",
        "    '''\n",
        "    Applies a list of pre-processing functions in sequence (reduce).\n",
        "    Note that the order is important here!\n",
        "    '''\n",
        "\n",
        "    filter_methods = filter_methods if filter_methods is not None else pipeline\n",
        "\n",
        "    return reduce(lambda txt, f: f(txt), filter_methods, text)\n",
        "\n",
        "def cleaning(dataframes: list, labels: list):\n",
        "  for dataframe in dataframes:\n",
        "    print('Before: \\n')\n",
        "    print(dataframe[labels].head(5))\n",
        "    \n",
        "    for label in labels:\n",
        "      dataframe[label] = dataframe[label].apply(lambda txt: text_prepare(txt))\n",
        "    \n",
        "    print('After: \\n')\n",
        "    print(dataframe[labels].head(5))\n",
        "\n",
        "arguments_dataset_list = [arguments_train, arguments_dev, arguments_test]\n",
        "arguments_labels_list = ['argument', 'topic']\n",
        "\n",
        "cleaning(arguments_dataset_list, arguments_labels_list)\n",
        "\n",
        "key_points_datasets_list = [key_points_train, key_points_dev, key_points_test]\n",
        "key_points_labels_list = ['key_point', 'topic']\n",
        "\n",
        "cleaning(key_points_datasets_list, key_points_labels_list)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 206
        },
        "id": "gKwkADByDWSc",
        "outputId": "eff75eea-b857-43ec-f219-a9d80d77d063"
      },
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/html": [
              "\n",
              "  <div id=\"df-3dc2fd35-730d-49e6-9012-482eee8e0705\">\n",
              "    <div class=\"colab-df-container\">\n",
              "      <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>key_point_id</th>\n",
              "      <th>key_point</th>\n",
              "      <th>topic</th>\n",
              "      <th>stance</th>\n",
              "    </tr>\n",
              "  </thead>\n",
              "  <tbody>\n",
              "    <tr>\n",
              "      <th>0</th>\n",
              "      <td>kp_4_0</td>\n",
              "      <td>children can still express themselves using ot...</td>\n",
              "      <td>we should abandon the use of school uniform</td>\n",
              "      <td>-1</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>1</th>\n",
              "      <td>kp_4_1</td>\n",
              "      <td>school uniform reduces bullying</td>\n",
              "      <td>we should abandon the use of school uniform</td>\n",
              "      <td>-1</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>2</th>\n",
              "      <td>kp_4_2</td>\n",
              "      <td>school uniforms encourage discipline or focus ...</td>\n",
              "      <td>we should abandon the use of school uniform</td>\n",
              "      <td>-1</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>3</th>\n",
              "      <td>kp_4_3</td>\n",
              "      <td>school uniforms saves costs</td>\n",
              "      <td>we should abandon the use of school uniform</td>\n",
              "      <td>-1</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>4</th>\n",
              "      <td>kp_4_4</td>\n",
              "      <td>school uniforms create a sense of equality unity</td>\n",
              "      <td>we should abandon the use of school uniform</td>\n",
              "      <td>-1</td>\n",
              "    </tr>\n",
              "  </tbody>\n",
              "</table>\n",
              "</div>\n",
              "      <button class=\"colab-df-convert\" onclick=\"convertToInteractive('df-3dc2fd35-730d-49e6-9012-482eee8e0705')\"\n",
              "              title=\"Convert this dataframe to an interactive table.\"\n",
              "              style=\"display:none;\">\n",
              "        \n",
              "  <svg xmlns=\"http://www.w3.org/2000/svg\" height=\"24px\"viewBox=\"0 0 24 24\"\n",
              "       width=\"24px\">\n",
              "    <path d=\"M0 0h24v24H0V0z\" fill=\"none\"/>\n",
              "    <path d=\"M18.56 5.44l.94 2.06.94-2.06 2.06-.94-2.06-.94-.94-2.06-.94 2.06-2.06.94zm-11 1L8.5 8.5l.94-2.06 2.06-.94-2.06-.94L8.5 2.5l-.94 2.06-2.06.94zm10 10l.94 2.06.94-2.06 2.06-.94-2.06-.94-.94-2.06-.94 2.06-2.06.94z\"/><path d=\"M17.41 7.96l-1.37-1.37c-.4-.4-.92-.59-1.43-.59-.52 0-1.04.2-1.43.59L10.3 9.45l-7.72 7.72c-.78.78-.78 2.05 0 2.83L4 21.41c.39.39.9.59 1.41.59.51 0 1.02-.2 1.41-.59l7.78-7.78 2.81-2.81c.8-.78.8-2.07 0-2.86zM5.41 20L4 18.59l7.72-7.72 1.47 1.35L5.41 20z\"/>\n",
              "  </svg>\n",
              "      </button>\n",
              "      \n",
              "  <style>\n",
              "    .colab-df-container {\n",
              "      display:flex;\n",
              "      flex-wrap:wrap;\n",
              "      gap: 12px;\n",
              "    }\n",
              "\n",
              "    .colab-df-convert {\n",
              "      background-color: #E8F0FE;\n",
              "      border: none;\n",
              "      border-radius: 50%;\n",
              "      cursor: pointer;\n",
              "      display: none;\n",
              "      fill: #1967D2;\n",
              "      height: 32px;\n",
              "      padding: 0 0 0 0;\n",
              "      width: 32px;\n",
              "    }\n",
              "\n",
              "    .colab-df-convert:hover {\n",
              "      background-color: #E2EBFA;\n",
              "      box-shadow: 0px 1px 2px rgba(60, 64, 67, 0.3), 0px 1px 3px 1px rgba(60, 64, 67, 0.15);\n",
              "      fill: #174EA6;\n",
              "    }\n",
              "\n",
              "    [theme=dark] .colab-df-convert {\n",
              "      background-color: #3B4455;\n",
              "      fill: #D2E3FC;\n",
              "    }\n",
              "\n",
              "    [theme=dark] .colab-df-convert:hover {\n",
              "      background-color: #434B5C;\n",
              "      box-shadow: 0px 1px 3px 1px rgba(0, 0, 0, 0.15);\n",
              "      filter: drop-shadow(0px 1px 2px rgba(0, 0, 0, 0.3));\n",
              "      fill: #FFFFFF;\n",
              "    }\n",
              "  </style>\n",
              "\n",
              "      <script>\n",
              "        const buttonEl =\n",
              "          document.querySelector('#df-3dc2fd35-730d-49e6-9012-482eee8e0705 button.colab-df-convert');\n",
              "        buttonEl.style.display =\n",
              "          google.colab.kernel.accessAllowed ? 'block' : 'none';\n",
              "\n",
              "        async function convertToInteractive(key) {\n",
              "          const element = document.querySelector('#df-3dc2fd35-730d-49e6-9012-482eee8e0705');\n",
              "          const dataTable =\n",
              "            await google.colab.kernel.invokeFunction('convertToInteractive',\n",
              "                                                     [key], {});\n",
              "          if (!dataTable) return;\n",
              "\n",
              "          const docLinkHtml = 'Like what you see? Visit the ' +\n",
              "            '<a target=\"_blank\" href=https://colab.research.google.com/notebooks/data_table.ipynb>data table notebook</a>'\n",
              "            + ' to learn more about interactive tables.';\n",
              "          element.innerHTML = '';\n",
              "          dataTable['output_type'] = 'display_data';\n",
              "          await google.colab.output.renderOutput(dataTable, element);\n",
              "          const docLink = document.createElement('div');\n",
              "          docLink.innerHTML = docLinkHtml;\n",
              "          element.appendChild(docLink);\n",
              "        }\n",
              "      </script>\n",
              "    </div>\n",
              "  </div>\n",
              "  "
            ],
            "text/plain": [
              "  key_point_id  ... stance\n",
              "0       kp_4_0  ...     -1\n",
              "1       kp_4_1  ...     -1\n",
              "2       kp_4_2  ...     -1\n",
              "3       kp_4_3  ...     -1\n",
              "4       kp_4_4  ...     -1\n",
              "\n",
              "[5 rows x 4 columns]"
            ]
          },
          "metadata": {},
          "execution_count": 8
        }
      ],
      "source": [
        "# Check.\n",
        "# arguments_train.head()\n",
        "# arguments_dev.head()\n",
        "# arguments_test.head()\n",
        "\n",
        "# key_points_train.head()\n",
        "key_points_dev.head()\n",
        "# key_points_test.head()"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "### 2.2 **Text tokenization**\n",
        "Text tokenization consists into split a whole sentencences into meaningful pieces of it. It is achieved with the punkt tokenizer by NLTK."
      ],
      "metadata": {
        "id": "wF_FoUnEbfHK"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Create copies of the processed dataframes.\n",
        "arguments_train_tok = arguments_train.copy()\n",
        "arguments_dev_tok = arguments_dev.copy()\n",
        "arguments_test_tok = arguments_test.copy()\n",
        "\n",
        "key_points_train_tok = key_points_train.copy()\n",
        "key_points_dev_tok = key_points_dev.copy()\n",
        "key_points_test_tok = key_points_test.copy()\n",
        "\n",
        "# Note: it takes a while.\n",
        "from nltk.tokenize import wordpunct_tokenize\n",
        "\n",
        "def tokenize_dataset(dataframes: list, labels: list):\n",
        "  for df in dataframes:\n",
        "    for lab in labels:\n",
        "      df[lab] = df[lab].apply(wordpunct_tokenize)\n",
        "\n",
        "tokenize_dataset([arguments_train_tok, arguments_dev_tok, arguments_test_tok], labels = arguments_labels_list)\n",
        "tokenize_dataset([key_points_train_tok, key_points_dev_tok, key_points_test_tok], labels = key_points_labels_list)"
      ],
      "metadata": {
        "id": "tfkyF1albkaX"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "### 2.3 **Lenghts analysis**\n",
        "Padding is not needed for processor and the pre-trained models since they automatically takes into account different lengths, but is needed for the GloVe embeddings.\n",
        "\n",
        "In any case, length distribution studies are useful to decide if it makes sense to employ attention mechanisms.\n",
        "\n",
        "Key-points lengths are not considered since their maximum length is fixed."
      ],
      "metadata": {
        "id": "7szBYrm3SAn_"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "def extract_info(dataframe: pd.DataFrame) -> int:\n",
        "  plt.figure()\n",
        "  plt.title('Argument length distribution vs. Topic length distribution ')\n",
        "  \n",
        "  no_token_argument = [len(sentence) for sentence in dataframe['argument']]\n",
        "  n_c, _, _ = plt.hist(no_token_argument, bins = [i for i in range(1, 50)], cumulative = False)\n",
        "\n",
        "  no_token_topic = [len(sentence) for sentence in dataframe['topic']]\n",
        "  n_e, _, _ = plt.hist(no_token_topic, bins = [i for i in range(1, 50)], cumulative = False)\n",
        "\n",
        "  return max(max(no_token_argument), max(no_token_topic))\n",
        "\n",
        "max_tokens = max(extract_info(arguments_train_tok), extract_info(arguments_dev_tok))\n",
        "\n",
        "print(f'The maximum found length is {max_tokens}.')"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 563
        },
        "id": "5a-pU6gLSNP3",
        "outputId": "9e1ac1f0-4fae-40ae-86b7-6df885f82c81"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "The maximum found length is 44.\n"
          ]
        },
        {
          "output_type": "display_data",
          "data": {
            "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYQAAAEICAYAAABfz4NwAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjIsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+WH4yJAAAZ9ElEQVR4nO3de7QlZXnn8e8vjagREZSWAA02amtEl7bSIo6XoEQERFBXBkEjeImtKzjqqOMgcS0YDTNqFA2j4mqVABlBUURQMdIa4y2CNopcFGODELpt6FYEwQsKPPNHvUeL5pw+l73Prc/3s9Zep+qtqreet06d/dT7Vu19UlVIkvQnsx2AJGluMCFIkgATgiSpMSFIkgATgiSpMSFIkgATwpyQZL8k62Zp3yck+X8DbP9vSf6mTb84yYVDjO3KJPu16YHiHKXu45J8ZFj1zTdJbkvy0Elu43k6et1bzXk65xJC+8X9Ism9ZzuWYUlybZK/nANxTOsfdFV9rKoOmEAcpyX5+wnU9+iq+rdB4xqt3VX1v6vqbwate7q1N6/b2us3Se7qzd821XqraruqumaYsQ6L5+nd6p7R83ROJYQkS4GnAQUcOs66i2YgJM2CJNvMdgxzRXvz2q6qtgMOAn46Mt/KNEu2xvN0TiUE4CjgIuA04Oj+gpatT0lyQZJfAc9I8oQk30tya5JPJvnESEZP8tIk39isjkry8F59H0zyhXa19c0kf5bkfa2HclWSx/e23TXJOUk2JflJktf2lp2Q5OwkZ7RYrkyyoi37Z2AP4LNtP28e7yBMdV9t+ajHJMn9gC8Au/auMHdtm207Vn2jxPasdmxuSfJ+IL1lfzjm6bw3ycYkv0xyeZLHJFkJvBh4c4vhs239a5P8zySXAb9Kss0oPav7tPbcmuS7SR432u+29/sds93ZrGuf5NDW9pvT9VIf1Vt2bZI3JbmstfsTSe4zyrG5d9v+Mb2yxemu7B+cZKckn2vr3JTk60mm/DeY5FEt1ptb7If2lp2W5ENJVrfj9dUkDxnteCW5b5L3JLmute8bSe47gf17ns7D83RL5mJC+Fh7PTvJzpstfxFwInB/4NvAuXTJ44HAWcDzJ7m/w4G3AjsBtwPfAr7b5j8FnATQ/mg/C3wf2A3YH3h9kmf36joU+DiwA3A+8H6AqnoJ8J/Ac9tV3bu2FNAg+0qyLWMck6r6Ffe8wvzpluobJbadgE/3jtnVwFPGaMoBwNOBRwAPoDvWP6+qVXS/33e1GJ7b2+ZI4DnADlV1xyh1HgZ8srXtTOAzSe41xv6ZQLtH2vUIumP1emAxcAFdAt+2t9rhwIHAnsBjgZeOsq/b6Y7PkZtt99Wq2gi8EVjX9rEzcBxdb3jSWrs/C1wIPBj4b8DHkjyyt9qLgbfT/a4upTvuo3k3sDfwX+iO7ZuBu8bZv+fpPD1Pt2TOJIQkTwUeApxdVZfQ/RJftNlq51XVN6vqLmA5sA1wclX9vqo+TZckJuPcqrqkqn5Ld4L+tqrOqKo7gU8AIz2EJwKLq+ptVfW7Nvb6YeCIXl3fqKoL2rb/DDyOqRlkX/sytWMy0dgPBq6sqk9V1e+B9wE3jLHu7+kS958DqaofVtWGceI4uaqur6rfjLH8kt6+TwLuQ9fmQb0Q+HxVrW51vxu4L90bZD+2n1bVTXRvhMvHqOtM7v67elErg+6Y7AI8pP1+vl5T/zKxfYHtgHe08+Rfgc9x92T0+ar6WktUfwc8Ocnu/UraG/vLgddV1fqqurOq/r1tsyWep/P7PB3VnEkIdENEF1bVz9r8mWw2bARc35veFVi/2R/U9UzOjb3p34wyPzJG+xC6rtzNIy+6q7t+D6Z/wv2arts4lTHGQfY11WMy0dh37dfX9jNq/e0N6v3AB4CNSVYl2X6cOMaLtb/vu+iutncde/UJ2xW4brO6r6e78h2x+TEaa/z+K8CfJnlSuntiy+kuNgD+AVgLXJjkmiTHDhjz9S3WEddtFnP/eN0G3MQ9j9dOdG9YV09y/56nE1g+h8/TUc2JhNDGKw8H/iLJDUluAP478Lj++Bt3715vAHZLkl5Z/+rnV8Cf9vbxZwOEeD3wk6raofe6f1UdPMHtJ3MVOMi+xjsmg3617YZ+fW0/u4+1clWdXFV7A3vRdcn/xzhxjBdff99/AiwBRrrVv6b3+wb6v+/x6v0p3RvcSN0j7Vo/znb30K5ez6a7Uj8S+FxV3dqW3VpVb6yqh9INf7whyf6T3Ucv5t1z93sQe2wWc/94bUc3hHG3YQjgZ8BvgYdNcv+ep2Ob8+fpWOZEQgCeB9xJ9wtZ3l6PAr5Od19hNN9q27ym3dg5DNint/z7wKOTLG83Vk4YIL5vA7e2m0n3TbKo3Xh64gS3vxGY6DPfg+xrvGNyI/CgJA+YYCyb+zzdMX1BuzJ7LXc/of8gyRPbVfK96JLzb/njuPRkjkff3r19v57uvs9FbdmlwIva8ToQ+IveduO1+2zgOUn2b/G+sdX971OIEbre7QvpxvBHhotIckiSh7c/5FvofldbHKvfgovp3lzenORe6Z6Dfy7dGPuIg5M8tY0xvx24qKrudnXbrjJPBU5qNzEXJXlyxn/s2/N0bPPlPL2HuZIQjgb+qar+s6puGHnRdeVePFq3sKp+B7wAeAVwM/DXdGOot7fl/wG8DfgS8GPgG5vXMVHtqu8QukT1E7qrqo/Q3YSaiP8DvLV1rd80XfuawDG5iu6m1DUtlkl1Y9tw3n8F3gH8HFgGfHOM1benG1P+BV039+d0QyYAHwX2ajF8ZhIhnEf3RvsL4CXAC9pYKsDr6N4Qb6Z7I/5DveO1u6p+RHes/i/d8X4u3UMAv5tEbP36LqZ7c9mV7smREcvozsfb6N4UP1hVXwFI97TbcZPYx+9anAe1mD8IHNXaOuJM4Hi6oaK9WxtH8ybgcuA7bd13Ms57g+fpFs2L83Q0mfo9rbknycXAh6rqn2Y7lrnCY7IwJTkNWFdVb53tWCbC83RumCs9hClJ8hfpPjuwTZKj6R6z+pfZjms2eUw0H3iezk3z/ZN2j6QbV7sfcA3wVxN4ZGxr5zHRfOB5OgdtVUNGkqSpm9dDRpKk4ZnzQ0Y77bRTLV26dLbDkKR545JLLvlZVS2e7HZzPiEsXbqUNWvWzHYYkjRvJLlu/LXuySEjSRJgQpAkNSYESRJgQpAkNSYESRJgQpAkNSYESRJgQpAkNSYESRIwDz6pPGecMMb//TjhlpmNQ5KmiT0ESRJgQpAkNQ4ZDcqhJElbCXsIkiTAhCBJakwIkiTAhCBJakwIkiTAhCBJakwIkiRgAgkhyalJNia5olf2iSSXtte1SS5t5UuT/Ka37EO9bfZOcnmStUlOTpLpaZIkaSom8sG004D3A2eMFFTVC0emk7wH6H8K6+qqWj5KPacArwQuBi4ADgS+MPmQJUnTYdweQlV9DbhptGXtKv9w4Kwt1ZFkF2D7qrqoqoouuTxv8uFKkqbLoPcQngbcWFU/7pXtmeR7Sb6a5GmtbDdgXW+dda1sVElWJlmTZM2mTZsGDFGSNBGDJoQjuXvvYAOwR1U9HngDcGaS7SdbaVWtqqoVVbVi8eLFA4YoSZqIKX+5XZJtgBcAe4+UVdXtwO1t+pIkVwOPANYDS3qbL2llkqQ5YpAewl8CV1XVH4aCkixOsqhNPxRYBlxTVRuAXybZt913OAo4b4B9S5KGbCKPnZ4FfAt4ZJJ1SV7RFh3BPW8mPx24rD2G+ing1VU1ckP6b4GPAGuBq/EJI0maU8YdMqqqI8cof+koZecA54yx/hrgMZOMT5I0Q/yksiQJMCFIkhoTgiQJMCFIkhoTgiQJMCFIkhoTgiQJMCFIkhoTgiQJMCFIkhoTgiQJMCFIkhoTgiQJMCFIkhoTgiQJMCFIkhoTgiQJMCFIkhoTgiQJmEBCSHJqko1JruiVnZBkfZJL2+vg3rK3JFmb5EdJnt0rP7CVrU1y7PCbIkkaxER6CKcBB45S/t6qWt5eFwAk2Qs4Anh02+aDSRYlWQR8ADgI2As4sq0rSZojthlvhar6WpKlE6zvMODjVXU78JMka4F92rK1VXUNQJKPt3V/MOmIJUnTYpB7CK9JclkbUtqxle0GXN9bZ10rG6t8VElWJlmTZM2mTZsGCFGSNFFTTQinAA8DlgMbgPcMLSKgqlZV1YqqWrF48eJhVi1JGsO4Q0ajqaobR6aTfBj4XJtdD+zeW3VJK2ML5ZKkOWBKPYQku/Rmnw+MPIF0PnBEknsn2RNYBnwb+A6wLMmeSbalu/F8/tTDliQN27g9hCRnAfsBOyVZBxwP7JdkOVDAtcCrAKrqyiRn090svgM4pqrubPW8BvgisAg4taquHHprJElTNpGnjI4cpfijW1j/RODEUcovAC6YVHSSpBnjJ5UlSYAJQZLUmBAkSYAJQZLUmBAkSYAJQZLUmBAkSYAJQZLUmBAkSYAJQZLUmBAkSYAJQZLUmBAkSYAJQZLUmBAkSYAJQZLUmBAkSYAJQZLUjJsQkpyaZGOSK3pl/5DkqiSXJTk3yQ6tfGmS3yS5tL0+1Ntm7ySXJ1mb5OQkmZ4mSZKmYiI9hNOAAzcrWw08pqoeC/wH8Jbesquranl7vbpXfgrwSmBZe21epyRpFo2bEKrqa8BNm5VdWFV3tNmLgCVbqiPJLsD2VXVRVRVwBvC8qYUsSZoOw7iH8HLgC735PZN8L8lXkzytle0GrOuts66VjSrJyiRrkqzZtGnTEEKUJI1noISQ5O+AO4CPtaINwB5V9XjgDcCZSbafbL1VtaqqVlTVisWLFw8SoiRpgraZ6oZJXgocAuzfhoGoqtuB29v0JUmuBh4BrOfuw0pLWpkkaY6YUg8hyYHAm4FDq+rXvfLFSRa16YfS3Ty+pqo2AL9Msm97uugo4LyBo5ckDc24PYQkZwH7ATslWQccT/dU0b2B1e3p0YvaE0VPB96W5PfAXcCrq2rkhvTf0j2xdF+6ew79+w6SpFk2bkKoqiNHKf7oGOueA5wzxrI1wGMmFZ0kacb4SWVJEmBCkCQ1JgRJEmBCkCQ1JgRJEmBCkCQ1JgRJEmBCkCQ1JgRJEmBCkCQ1JgRJEmBCkCQ1JgRJEmBCkCQ1JgRJEmBCkCQ1JgRJEmBCkCQ1JgRJEjDBhJDk1CQbk1zRK3tgktVJftx+7tjKk+TkJGuTXJbkCb1tjm7r/zjJ0cNvjiRpqibaQzgNOHCzsmOBL1fVMuDLbR7gIGBZe60EToEugQDHA08C9gGOH0kikqTZN6GEUFVfA27arPgw4PQ2fTrwvF75GdW5CNghyS7As4HVVXVTVf0CWM09k4wkaZYMcg9h56ra0KZvAHZu07sB1/fWW9fKxiq/hyQrk6xJsmbTpk0DhChJmqih3FSuqgJqGHW1+lZV1YqqWrF48eJhVStJ2oJBEsKNbSiI9nNjK18P7N5bb0krG6tckjQHDJIQzgdGnhQ6GjivV35Ue9poX+CWNrT0ReCAJDu2m8kHtDJJ0hywzURWSnIWsB+wU5J1dE8LvQM4O8krgOuAw9vqFwAHA2uBXwMvA6iqm5K8HfhOW+9tVbX5jWpJ0iyZUEKoqiPHWLT/KOsWcMwY9ZwKnDrh6CRJM8ZPKkuSABOCJKkxIUiSABOCJKkxIUiSABOCJKkxIUiSABOCJKkxIUiSABOCJKkxIUiSABOCJKkxIUiSABOCJKkxIUiSABOCJKkxIUiSABOCJKmZckJI8sgkl/Zev0zy+iQnJFnfKz+4t81bkqxN8qMkzx5OEyRJwzCh/6k8mqr6EbAcIMkiYD1wLvAy4L1V9e7++kn2Ao4AHg3sCnwpySOq6s6pxiBJGp5hDRntD1xdVddtYZ3DgI9X1e1V9RNgLbDPkPYvSRrQsBLCEcBZvfnXJLksyalJdmxluwHX99ZZ18ruIcnKJGuSrNm0adOQQpQkbcnACSHJtsChwCdb0SnAw+iGkzYA75lsnVW1qqpWVNWKxYsXDxqiJGkChtFDOAj4blXdCFBVN1bVnVV1F/Bh/jgstB7YvbfdklYmSZoDhpEQjqQ3XJRkl96y5wNXtOnzgSOS3DvJnsAy4NtD2L8kaQim/JQRQJL7Ac8CXtUrfleS5UAB144sq6ork5wN/AC4AzhmwT5hdMIDxii/ZWbjkKSegRJCVf0KeNBmZS/ZwvonAicOsk9J0vTwk8qSJMCEIElqBhoy0haMdZ9AkuYoewiSJMCEIElqTAiSJMCEIElqTAiSJMCEIElqTAiSJMCEIElqTAiSJMCEIElqTAiSJMCEIElqTAiSJMCEIElqTAiSJMCEIElqBk4ISa5NcnmSS5OsaWUPTLI6yY/bzx1beZKcnGRtksuSPGHQ/UuShmNYPYRnVNXyqlrR5o8FvlxVy4Avt3mAg4Bl7bUSOGVI+5ckDWi6howOA05v06cDz+uVn1Gdi4AdkuwyTTFIkiZhGAmhgAuTXJJkZSvbuao2tOkbgJ3b9G7A9b1t17Wyu0myMsmaJGs2bdo0hBAlSePZZgh1PLWq1id5MLA6yVX9hVVVSWoyFVbVKmAVwIoVKya1rSRpagbuIVTV+vZzI3AusA9w48hQUPu5sa2+Hti9t/mSViZJmmUDJYQk90ty/5Fp4ADgCuB84Oi22tHAeW36fOCo9rTRvsAtvaElSdIsGnTIaGfg3CQjdZ1ZVf+S5DvA2UleAVwHHN7WvwA4GFgL/Bp42YD7lyQNyUAJoaquAR43SvnPgf1HKS/gmEH2KUmaHn5SWZIEmBAkSY0JQZIEmBAkSY0JQZIEmBAkSY0JQZIEmBAkSY0JQZIEmBAkSY0JQZIEmBAkSc0w/kGOtnJLj/38mMuufcdzZjASSdPJHoIkCTAhSJIaE4IkCfAegqbJWPcdvOcgzV0mhAVomG/WW7rhLGl+mXJCSLI7cAbd/1UuYFVV/WOSE4BXApvaqsdV1QVtm7cArwDuBF5bVV8cIHYtEPY2pJkxSA/hDuCNVfXdJPcHLkmyui17b1W9u79ykr2AI4BHA7sCX0ryiKq6c4AYNEQzcbXvI6zS3DXlm8pVtaGqvtumbwV+COy2hU0OAz5eVbdX1U+AtcA+U92/JGm4hnIPIclS4PHAxcBTgNckOQpYQ9eL+AVdsriot9k6xkggSVYCKwH22GOPYYSoeWCyPRR7G9JwDZwQkmwHnAO8vqp+meQU4O109xXeDrwHePlk6qyqVcAqgBUrVtSgMc4bJzxgC8tumbk4JC1IAyWEJPeiSwYfq6pPA1TVjb3lHwY+12bXA7v3Nl/SyjQAn/KRNCyDPGUU4KPAD6vqpF75LlW1oc0+H7iiTZ8PnJnkJLqbysuAb091/9JU+MSSNLZBeghPAV4CXJ7k0lZ2HHBkkuV0Q0bXAq8CqKork5wN/IDuCaVjfMJI08WekzR5U04IVfUNIKMsumAL25wInDjVfUqSpo+fVJ4vxrzhfOaMhiFp6+WX20mSAHsI0ri8Ea2FwoQg4U1oCRwykiQ19hCkKXIoSVsbewiSJMCEIElqHDKShmwqN6gdZtJcYEKQ5oBhPuVkctFUOWQkSQLsIUhbHZ9+0lSZEKQFwv8wp/E4ZCRJAuwhSGLyN7XtUWyd7CFIkgB7CJKmwM9abJ3sIUiSABOCJKmZ8SGjJAcC/wgsAj5SVe+Y6RgkzTyHmea+Ge0hJFkEfAA4CNgLODLJXjMZgyRpdDPdQ9gHWFtV1wAk+ThwGPCDGY5D0jwwE//Jzl7IH810QtgNuL43vw540uYrJVkJrGyztyX50Rbq3An42dAinHcOWcjtX8hth4Xd/qG1Pe8cRi0zaiJtf8hUKp6Tj51W1Spg1UTWTbKmqlZMc0hz1kJu/0JuOyzs9tv26Wn7TD9ltB7YvTe/pJVJkmbZTCeE7wDLkuyZZFvgCOD8GY5BkjSKGR0yqqo7krwG+CLdY6enVtWVA1Y7oaGlrdhCbv9Cbjss7Pbb9mmQqpquuiVJ84ifVJYkASYESVIzrxNCkgOT/CjJ2iTHznY80y3JqUk2JrmiV/bAJKuT/Lj93HE2Y5wuSXZP8pUkP0hyZZLXtfKtvv1J7pPk20m+39r+v1r5nkkubuf/J9qDGlulJIuSfC/J59r8Qmr7tUkuT3JpkjWtbFrO+3mbEBbo12CcBhy4WdmxwJerahnw5Ta/NboDeGNV7QXsCxzTft8Lof23A8+sqscBy4EDk+wLvBN4b1U9HPgF8IpZjHG6vQ74YW9+IbUd4BlVtbz3+YNpOe/nbUKg9zUYVfU7YORrMLZaVfU14KbNig8DTm/TpwPPm9GgZkhVbaiq77bpW+neHHZjAbS/Ore12Xu1VwHPBD7VyrfKtgMkWQI8B/hImw8LpO1bMC3n/XxOCKN9DcZusxTLbNq5qja06RuAnWczmJmQZCnweOBiFkj725DJpcBGYDVwNXBzVd3RVtmaz//3AW8G7mrzD2LhtB265H9hkkva1/rANJ33c/KrKzQ1VVVJturniJNsB5wDvL6qftldLHa25vZX1Z3A8iQ7AOcCfz7LIc2IJIcAG6vqkiT7zXY8s+SpVbU+yYOB1Umu6i8c5nk/n3sIfg1G58YkuwC0nxtnOZ5pk+RedMngY1X16Va8YNoPUFU3A18BngzskGTkom5rPf+fAhya5Fq6YeFn0v0/lYXQdgCqan37uZHuYmAfpum8n88Jwa/B6JwPHN2mjwbOm8VYpk0bN/4o8MOqOqm3aKtvf5LFrWdAkvsCz6K7h/IV4K/aaltl26vqLVW1pKqW0v2N/2tVvZgF0HaAJPdLcv+RaeAA4Aqm6byf159UTnIw3fjiyNdgnDjLIU2rJGcB+9F9/e2NwPHAZ4CzgT2A64DDq2rzG8/zXpKnAl8HLuePY8nH0d1H2Krbn+SxdDcOF9FdxJ1dVW9L8lC6q+YHAt8D/rqqbp+9SKdXGzJ6U1UdslDa3tp5bpvdBjizqk5M8iCm4byf1wlBkjQ883nISJI0RCYESRJgQpAkNSYESRJgQpAkNSYESRJgQpAkNf8fM35DAithrYQAAAAASUVORK5CYII=\n",
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ]
          },
          "metadata": {
            "needs_background": "light"
          }
        },
        {
          "output_type": "display_data",
          "data": {
            "image/png": "iVBORw0KGgoAAAANSUhEUgAAAX4AAAEICAYAAABYoZ8gAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjIsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+WH4yJAAAVY0lEQVR4nO3da7SkVX3n8e9PQDFigkjb4SatkRgxK7TaGhydEWWigArG5RDRaCeji3mhE5jRMcRxLRkzzpBMgg4xmkWUgAkoREVQSQaGYLwkoI3iBdEREQIt0K2IghcQ+M+LZx8tmnP6XOrUue3vZ61ap+q5/vdTT/9q136qqlNVSJL68aDlLkCStLQMfknqjMEvSZ0x+CWpMwa/JHXG4Jekzhj8SyTJYUluWqZ9n5zkb8ZY/+NJXt3uvzzJxYtY29VJDmv3x6pzmm2/Mcm7F2t7q02SO5M8dp7reJ5Ov+01dZ4uS/C3J+i7SR6yHPufhCTXJ/m3K6COif7Draqzq+q5c6jjzCT/fQ7be2JVfXzcuqZrd1X9j6p69bjbnrQWUne224+S3Dfy+M6Fbreq9qiq6xaz1sXieXq/bS/5ebrkwZ9kA/CvgQKOnmXZXZagJC2DJLsudw0rRQupPapqD+BI4FtTj9s0LZO1ep4uR4//lcDlwJnA5tEZ7dX3XUkuSvID4NlJnpzk80nuSPK3Sc6deoVO8jtJPrXDNirJ40a2984kf9d6T59O8otJ3t7ecXw1yZNG1t03yQeTbE/yzSS/NzLv5CTnJXlvq+XqJJvavL8GHg18pO3nDbMdhIXuq82f9pgkeRjwd8C+Iz3GfdtqD55pe9PU9hvt2HwvyTuAjMz76THP4G1JtiX5fpIvJfnVJMcDLwfe0Gr4SFv++iS/n+SLwA+S7DrNO6XdW3vuSPK5JIdM99yOPL8ztjs7vCVPcnRr++0Z3nU+YWTe9Ulen+SLrd3nJtl9mmPzkLb+r45MW5ehp/6oJHsn+Whb5rYkn0yy4H9nSZ7Qar291X70yLwzk/xFkkva8frHJAdOd7ySPDTJnya5obXvU0keOof9e56uwvN0NssV/Ge32/OSrN9h/suAtwIPBz4DnM/wIrEX8D7gN+e5v2OBNwF7A3cB/wx8rj3+AHAqQPvH+RHgC8B+wOHAiUmeN7Kto4H3A3sCFwLvAKiqVwD/Aryw9dL+eGcFjbOvJA9mhmNSVT/ggT3Gb+1se9PUtjfwoZFj9g3gGTM05bnAvwF+GfgFhmP9nao6neH5/eNWwwtH1jkOeD6wZ1XdM802jwH+trXtHODDSXabYf/Mod1T7fplhmN1IrAOuIjhhfrBI4sdCxwBPAb4NeB3ptnXXQzH57gd1vvHqtoGvA64qe1jPfBGhne389ba/RHgYuBRwH8Ezk7y+JHFXg78IcNzdRXDcZ/OnwBPAf4Vw7F9A3DfLPv3PF2l5+lsljT4kzwTOBA4r6quZHiyXrbDYhdU1aer6j5gI7ArcFpV/aSqPsTwYjAf51fVlVX1Y4YT8cdV9d6quhc4F5jq8T8VWFdVb6mqu9vY6F8CLx3Z1qeq6qK27l8Dh7Aw4+zrUBZ2TOZa+1HA1VX1gar6CfB24JYZlv0Jwwv0rwCpqmuq6uZZ6jitqm6sqh/NMP/KkX2fCuzO0OZx/Rbwsaq6pG37T4CHMgThaG3fqqrbGAJv4wzbOof7P1cva9NgOCb7AAe25+eTtfAfxDoU2AM4pZ0n/wB8lPu/6Hysqj7RXpD+K/D0JAeMbqQF+L8HTqiqrVV1b1X9U1tnZzxPV/d5OqOl7vFvBi6uqm+3x+eww3APcOPI/X2BrTv8w7mR+bl15P6Ppnk8NYZ6IMNbsNunbgy9tdF3JKMn1g8Z3u4tZAxwnH0t9JjMtfZ9R7fX9jPt9lsQvQP4c2BbktOT/PwsdcxW6+i+72PoPe878+Jzti9www7bvpGhJztlx2M00/j6ZcDPJfn1DNesNjJ0KgD+F3AtcHGS65KcNGbNN7Zap9ywQ82jx+tO4DYeeLz2Zgimb8xz/56nc5i/gs/TGS1Z8LfxxGOBZyW5JcktwH8CDhkdH+P+b4tvBvZLkpFpo72ZHwA/N7KPXxyjxBuBb1bVniO3h1fVUXNcfz69unH2NdsxGffnVm8e3V7bzwEzLVxVp1XVU4CDGd5K/5dZ6pitvtF9PwjYH5h6O/xDRp5vYPT5nm2732IIsqltT7Vr6yzrPUDrjZ7H0PM+DvhoVd3R5t1RVa+rqscyDFv85ySHz3cfIzUfkPtfI3j0DjWPHq89GIYe7jd8AHwb+DHwS/Pcv+fpzFb8ebozS9njfxFwL8OB39huTwA+yTDuP51/buu8tl1gOQZ42sj8LwBPTLKxXeA4eYz6PgPc0S7qPDTJLu0C0FPnuP6twFw/Mz3OvmY7JrcCj0zyC3OsZUcfYzimL249rd/j/ifuTyV5auv17sbwIvxjfjZuPJ/jMeopI/s+keG6zOVt3lXAy9rxOgJ41sh6s7X7POD5SQ5v9b6ubfufFlAjDO9Wf4thjH1qmIckL0jyuPYP9nsMz9VOx9J34gqGEHlDkt0yfI78hQxj4FOOSvLMNgb8h8DlVXW/3mrrNZ4BnNouJu6S5OmZ/ePUnqczWy3n6bSWMvg3A39VVf9SVbdM3Rjegr18urdzVXU38GLgVcDtwG8zjHHe1eb/P+AtwP8Fvg58asdtzFXrxb2A4QXpmwy9pHczXAyai/8JvKm9JX79pPY1h2PyVYaLQ9e1Wub19rMNw/074BTgO8BBwKdnWPznGcZ8v8vw9vQ7DEMdAO8BDm41fHgeJVzAEKjfBV4BvLiNdQKcwBB8tzME7k+3O1u7q+prDMfqzxiO9wsZLsbfPY/aRrd3BUOI7MvwSY0pBzGcj3cyhN87q+oygAyfLnvjPPZxd6vzyFbzO4FXtrZOOQd4M8MQz1NaG6fzeuBLwGfbsn/ELP/+PU93alWcpzPJwq87LY8kVwB/UVV/tdy1rBQekz4lORO4qaretNy1zIXn6cqx4n+yIcmzMnz2ftckmxk+vvT3y13XcvKYaDXwPF25VsO30h7PMO71MOA64CVz+CjWWucx0WrgebpCrbqhHknSeFb8UI8kaXGtiKGevffeuzZs2LDcZUjSqnLllVd+u6rWzXe9FRH8GzZsYMuWLctdhiStKklumH2pB3KoR5I6Y/BLUmcMfknqjMEvSZ0x+CWpMwa/JHXG4Jekzhj8ktQZg1+SOrMivrnbnZNn+H8sTv7e0tYhqUv2+CWpMwa/JHXGoZ5xOWwjaZUx+FeDmV5cwBcYSfPmUI8kdcbgl6TOGPyS1BmDX5I648XdudrZBVZJWkXs8UtSZwx+SeqMwS9JnTH4JakzBr8kdcbgl6TOGPyS1BmDX5I6Y/BLUmcMfknqjMEvSZ0x+CWpMwa/JHXG4Jekzhj8ktQZg1+SOmPwS1JnDH5J6ozBL0mdMfglqTOzBn+SA5JcluQrSa5OckKbvleSS5J8vf19RJueJKcluTbJF5M8edKNkCTN3Vx6/PcAr6uqg4FDgdckORg4Cbi0qg4CLm2PAY4EDmq344F3LXrVkqQFmzX4q+rmqvpcu38HcA2wH3AMcFZb7CzgRe3+McB7a3A5sGeSfRa9cknSgsxrjD/JBuBJwBXA+qq6uc26BVjf7u8H3Diy2k1t2o7bOj7JliRbtm/fPs+yJUkLNefgT7IH8EHgxKr6/ui8qiqg5rPjqjq9qjZV1aZ169bNZ1VJ0hjmFPxJdmMI/bOr6kNt8q1TQzjt77Y2fStwwMjq+7dpkqQVYC6f6gnwHuCaqjp1ZNaFwOZ2fzNwwcj0V7ZP9xwKfG9kSEiStMx2ncMyzwBeAXwpyVVt2huBU4DzkrwKuAE4ts27CDgKuBb4IfC7i1qxJGksswZ/VX0KyAyzD59m+QJeM2ZdkqQJ8Zu7ktQZg1+SOmPwS1JnDH5J6ozBL0mdMfglqTMGvyR1xuCXpM4Y/JLUGYNfkjpj8EtSZwx+SeqMwS9JnTH4JakzBr8kdcbgl6TOGPyS1BmDX5I6Y/BLUmcMfknqjMEvSZ0x+CWpMwa/JHXG4Jekzhj8ktQZg1+SOmPwS1JnDH5J6ozBL0mdMfglqTMGvyR1xuCXpM4Y/JLUGYNfkjoza/AnOSPJtiRfHpl2cpKtSa5qt6NG5v1BkmuTfC3J8yZVuCRpYebS4z8TOGKa6W+rqo3tdhFAkoOBlwJPbOu8M8kui1WsJGl8swZ/VX0CuG2O2zsGeH9V3VVV3wSuBZ42Rn2SpEU2zhj/a5N8sQ0FPaJN2w+4cWSZm9q0B0hyfJItSbZs3759jDIkSfOx0OB/F/BLwEbgZuBP57uBqjq9qjZV1aZ169YtsAxJ0nwtKPir6taqureq7gP+kp8N52wFDhhZdP82TZK0Qiwo+JPsM/LwN4GpT/xcCLw0yUOSPAY4CPjMeCVKkhbTrrMtkOR9wGHA3kluAt4MHJZkI1DA9cB/AKiqq5OcB3wFuAd4TVXdO5nSJUkLMWvwV9Vx00x+z06Wfyvw1nGKkiRNjt/claTOGPyS1BmDX5I6Y/BLUmcMfknqjMEvSZ0x+CWpMwa/JHXG4Jekzhj8ktQZg1+SOmPwS1JnDH5J6ozBL0mdMfglqTMGvyR1xuCXpM4Y/JLUGYNfkjpj8EtSZwx+SeqMwS9JnTH4JakzBr8kdcbgl6TOGPyS1BmDX5I6Y/BLUmcMfknqjMEvSZ0x+CWpMwa/JHXG4Jekzhj8ktQZg1+SOjNr8Cc5I8m2JF8embZXkkuSfL39fUSbniSnJbk2yReTPHmSxUuS5m8uPf4zgSN2mHYScGlVHQRc2h4DHAkc1G7HA+9anDIlSYtl1uCvqk8At+0w+RjgrHb/LOBFI9PfW4PLgT2T7LNYxUqSxrfQMf71VXVzu38LsL7d3w+4cWS5m9q0B0hyfJItSbZs3759gWVIkuZr7Iu7VVVALWC906tqU1VtWrdu3bhlSJLmaKHBf+vUEE77u61N3wocMLLc/m2aJGmFWGjwXwhsbvc3AxeMTH9l+3TPocD3RoaEJEkrwK6zLZDkfcBhwN5JbgLeDJwCnJfkVcANwLFt8YuAo4BrgR8CvzuBmiVJY5g1+KvquBlmHT7NsgW8ZtyiJEmT4zd3JakzBr8kdcbgl6TOGPyS1BmDX5I6Y/BLUmcMfknqjMEvSZ0x+CWpMwa/JHXG4Jekzhj8ktQZg1+SOmPwS1JnDH5J6ozBL0mdMfglqTMGvyR1xuCXpM4Y/JLUGYNfkjpj8EtSZwx+SeqMwS9JnTH4JakzBr8kdcbgl6TOGPyS1BmDX5I6Y/BLUmcMfknqzK7LXYBWjg0nfWza6def8vwlrkTSJNnjl6TOGPyS1JmxhnqSXA/cAdwL3FNVm5LsBZwLbACuB46tqu+OV6ZWG4eNpJVrMcb4n11V3x55fBJwaVWdkuSk9vj3F2E/moeZghcMX6l3k7i4ewxwWLt/FvBxDP5VzRcRaW0Zd4y/gIuTXJnk+DZtfVXd3O7fAqyfbsUkxyfZkmTL9u3bxyxDkjRX4/b4n1lVW5M8CrgkyVdHZ1ZVJanpVqyq04HTATZt2jTtMpKkxTdWj7+qtra/24DzgacBtybZB6D93TZukZKkxbPgHn+ShwEPqqo72v3nAm8BLgQ2A6e0vxcsRqFaPDsbs1/ObUlaGuMM9awHzk8ytZ1zqurvk3wWOC/Jq4AbgGPHL1OStFgWHPxVdR1wyDTTvwMcPk5RkqTJ8Zu7ktQZg1+SOuOvc2pJ+WUwafkZ/KvcWvpUjb/vIy0Ng38FmTH4dl/iQiStaQa/Vi2HjaSF8eKuJHXG4JekzjjUoxVvKX5iwqEh9cQevyR1xh6/1qT5vktYyIVi3z1otbLHL0mdMfglqTMGvyR1xuCXpM4Y/JLUGT/VIy0yf0pCK509fknqjD1+aRZr6aevJbDHL0ndsccvrQB+C1hLyR6/JHXG4Jekzhj8ktQZx/gnZKef5fb/0NUq4bWHtcngl1Ywfy5ak2DwS53wG8WaYvBLq9RS/JeUWpsMfmkJGbBaCfxUjyR1xuCXpM4Y/JLUGYNfkjrjxV1J87aQi9R+ZHTlMPglLQm/WLZyTGyoJ8kRSb6W5NokJ01qP5Kk+ZlI8CfZBfhz4EjgYOC4JAdPYl+SpPmZ1FDP04Brq+o6gCTvB44BvjKh/Ulag+Z7LcFho7lJVS3+RpOXAEdU1avb41cAv15Vrx1Z5njg+Pbw8cDXZtns3sC3F73Y1aHntkPf7e+57dB3++fS9gOrat18N7xsF3er6nTg9Lkun2RLVW2aYEkrVs9th77b33Pboe/2T7Ltk7q4uxU4YOTx/m2aJGmZTSr4PwsclOQxSR4MvBS4cEL7kiTNw0SGeqrqniSvBf4PsAtwRlVdPeZm5zwstAb13Hbou/09tx36bv/E2j6Ri7uSpJXL3+qRpM4Y/JLUmVUR/D39/EOSM5JsS/LlkWl7Jbkkydfb30csZ42TkuSAJJcl+UqSq5Oc0Kb30v7dk3wmyRda+/9bm/6YJFe08//c9oGJNSnJLkk+n+Sj7XFPbb8+yZeSXJVkS5s2kXN/xQd/hz//cCZwxA7TTgIuraqDgEvb47XoHuB1VXUwcCjwmvZc99L+u4DnVNUhwEbgiCSHAn8EvK2qHgd8F3jVMtY4aScA14w87qntAM+uqo0jn9+fyLm/4oOfkZ9/qKq7gamff1iTquoTwG07TD4GOKvdPwt40ZIWtUSq6uaq+ly7fwdDAOxHP+2vqrqzPdyt3Qp4DvCBNn3Ntj/J/sDzgXe3x6GTtu/ERM791RD8+wE3jjy+qU3ryfqqurndvwVYv5zFLIUkG4AnAVfQUfvbUMdVwDbgEuAbwO1VdU9bZC2f/28H3gDc1x4/kn7aDsOL/MVJrmw/aQMTOvf9Pf5VpqoqyZr+DG6SPYAPAidW1feHjt9grbe/qu4FNibZEzgf+JVlLmlJJHkBsK2qrkxy2HLXs0yeWVVbkzwKuCTJV0dnLua5vxp6/P78A9yaZB+A9nfbMtczMUl2Ywj9s6vqQ21yN+2fUlW3A5cBTwf2TDLVSVur5/8zgKOTXM8wnPsc4H/TR9sBqKqt7e82hhf9pzGhc381BL8//zC0d3O7vxm4YBlrmZg2pvse4JqqOnVkVi/tX9d6+iR5KPAbDNc5LgNe0hZbk+2vqj+oqv2ragPDv/F/qKqX00HbAZI8LMnDp+4DzwW+zITO/VXxzd0kRzGM/039/MNbl7mkiUnyPuAwhp9kvRV4M/Bh4Dzg0cANwLFVteMF4FUvyTOBTwJf4mfjvG9kGOfvof2/xnABbxeGTtl5VfWWJI9l6AXvBXwe+O2qumv5Kp2sNtTz+qp6QS9tb+08vz3cFTinqt6a5JFM4NxfFcEvSVo8q2GoR5K0iAx+SeqMwS9JnTH4JakzBr8kdcbgl6TOGPyS1Jn/D3g9h8BL7KCrAAAAAElFTkSuQmCC\n",
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ]
          },
          "metadata": {
            "needs_background": "light"
          }
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "vVmQwxuSiXiP"
      },
      "source": [
        "## 3.0 **The Key-Points Matching problem**\n",
        "Given a controversial topic $T$ with a list of $m$ arguments and $n$ key\n",
        "points:\n",
        "* $A_1, A_2, \\dots, A_m$; \n",
        "* $K_1, K_2, \\dots, K_n$,\n",
        "\n",
        "along with their corresponding $m+n$ stances:\n",
        "* $S_1, S_2, \\dots, S_{m+n}$;\n",
        "\n",
        "with $S_i \\in \\{−1, 1\\}$, which\n",
        "imply the attack or support relationships against the topic, the task is to rank key points that have the same stance with an input argument by the matching score.\n",
        "\n",
        "This priority is dependent on both the topic and the semantic of statements."
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## 4.0 **Unsupervised approaches**"
      ],
      "metadata": {
        "id": "AmyX8LL-U0Em"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "### 4.1 **Pre-trained embeddings**\n",
        "It is possible to use pre-trained embeddings to measure the \"distance\" of each pair of keyword and argument.\n",
        "\n",
        "GloVe is a context independent model that computes a single embedding for each word, while BERT is a contextualized embedding model that takes the entire sentence into account.\n",
        "\n",
        "Again, we use cosine similarity to compute the match score.\n",
        "\n",
        "For each method it is possible to decide wether to consider also topic and stance."
      ],
      "metadata": {
        "id": "tDr2J9xaVUcm"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "#### 4.1.1 **GloVe embeddings**\n",
        "GloVe is an unsupervised learning algorithm for obtaining vector representations for words. Training is performed on aggregated global word-word co-occurrence statistics from a corpus, and the resulting representations showcase interesting linear substructures of the word vector space.\n",
        "\n",
        "\n",
        "The training objective of GloVe is to learn word vectors such that their dot product equals the logarithm of the words' probability of co-occurrence. Owing to the fact that the logarithm of a ratio equals the difference of logarithms, this objective associates (the logarithm of) ratios of co-occurrence probabilities with vector differences in the word vector space. Because these ratios can encode some form of meaning, this information gets encoded as vector differences as well. \n"
      ],
      "metadata": {
        "id": "Rajy4_AbXPVa"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "##### 4.1.1.1 **Out-of-vocaboulary terms & embedding**\n",
        "At first some functions to handle OOVs terms and token embeddings are define. In particular:\n",
        "* `build_vocaboulary`: create a double vocaboulary from a dataframe to mantain encode and decode tokens;\n",
        "* `load_glove_embedding`: given a chosen embedding dimension, it downloads the corresponding pre-trained corpus;\n",
        "* `get_OOV_terms`: given a vocaboulary and a word listings returns the set of OOV terms;\n",
        "* `build_embedding_matrix`: returns the matrix to pass to the embedding layer as kernel initializer."
      ],
      "metadata": {
        "id": "bKK1gosDXKiw"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import gensim\n",
        "import gensim.downloader as gloader\n",
        "\n",
        "from collections import OrderedDict\n",
        "from typing import OrderedDict\n",
        "\n",
        "def build_vocabulary(dataset: pd.DataFrame, labels: list) -> (OrderedDict[int, str], OrderedDict[str, int], list):\n",
        "    idx2word = OrderedDict()\n",
        "    word2idx = OrderedDict()\n",
        "    \n",
        "    curr_idx = 1 # Start at 1 since 0 is reserved for padding.\n",
        "\n",
        "    for label in labels:\n",
        "      for row in tqdm(dataset[label].values):\n",
        "        for token in row:\n",
        "            if token not in word2idx:\n",
        "                word2idx[token] = curr_idx\n",
        "                idx2word[curr_idx] = token\n",
        "                curr_idx += 1\n",
        "\n",
        "    word_listing = list(idx2word.values())\n",
        "\n",
        "    return idx2word, word2idx, word_listing\n",
        "\n",
        "def load_glove_embedding(embedding_dimension: int) -> gensim.models.keyedvectors.KeyedVectors:\n",
        "    download_path = \"glove-wiki-gigaword-{}\".format(embedding_dimension)\n",
        "\n",
        "    # Sanity check.\n",
        "    try:\n",
        "        embedded_model = gloader.load(download_path)\n",
        "    except ValueError as e:\n",
        "        print(\"Invalid embedding dimension.\")\n",
        "        raise e\n",
        "\n",
        "    return embedded_model\n",
        "\n",
        "def get_OOV_terms(embedding_model: gensim.models.keyedvectors.KeyedVectors, word_listing: List[str]) -> list:\n",
        "    embedding_vocabulary = set(embedding_model.vocab.keys())\n",
        "    oov = set(word_listing).difference(embedding_vocabulary)\n",
        "    return list(oov)\n",
        "\n",
        "def build_embedding_matrix(embedding_model: gensim.models.keyedvectors.KeyedVectors,\n",
        "                           embedding_dimension: int,\n",
        "                           word2idx: OrderedDict[str, int],\n",
        "                           vocab_size: int) -> np.ndarray:\n",
        "\n",
        "    # Note: we take (vocab_size) + 1 since we start counting by 1, having reserved 0 for the padding.\n",
        "    embedding_matrix = np.zeros((vocab_size + 1, embedding_dimension), dtype = np.float32) \n",
        "\n",
        "    for word, idx in tqdm(word2idx.items()):\n",
        "        try:\n",
        "            embedding_vector = embedding_model[word]\n",
        "        except (KeyError, TypeError):\n",
        "            embedding_vector = np.random.uniform(low = -0.05, high = 0.05, size = embedding_dimension)\n",
        "\n",
        "        embedding_matrix[idx] = embedding_vector\n",
        "\n",
        "    return embedding_matrix\n",
        "\n",
        "emb_dim = 300\n",
        "embedded_model = load_glove_embedding(embedding_dimension = emb_dim)"
      ],
      "metadata": {
        "id": "dwoPB90ZXkLc",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "d3f3d5e2-45c0-46cf-b78e-aa33165c2ddc"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[==================================================] 100.0% 376.1/376.1MB downloaded\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "At first the vocabularies of words and tags for the training set is created, the out-of-vocabularies (OOV) words extracted, assigning random vectors for the OOV words. The same process is repeated for the validation set, taking into account the fact that the OOV words already considered for the training set, are not OOV words for the validation set. The same was done for the test set.\n",
        "\n",
        "Note: the process must take into account arguments and key-points (two distinct dataframes).\n"
      ],
      "metadata": {
        "id": "GQprH0lHYrib"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Step 0: load GloVe vocaboulary.\n",
        "vocaboulary = list(embedded_model.vocab.keys()) \n",
        "\n",
        "# Step 1: creation of vocaboulary for the training set and extraction of his OOVs.\n",
        "_, _, word_listing_train_arg = build_vocabulary(arguments_train_tok, ['argument'])\n",
        "_, _, word_listing_train_kp = build_vocabulary(key_points_train_tok, ['key_point'])\n",
        "\n",
        "word_listing_train = word_listing_train_arg + word_listing_train_kp\n",
        "\n",
        "oov_terms_train = get_OOV_terms(embedded_model, word_listing_train)\n",
        "print(f'There are {len(oov_terms_train)} OOVs in the training set.')\n",
        "\n",
        "print('\\n')\n",
        "\n",
        "# Step 2: creation of vocabulary for the validation set and extraction of his OOVs, taking into account the ones already from training set.\n",
        "_, _, word_listing_val_arg = build_vocabulary(arguments_dev_tok, ['argument'])\n",
        "_, _, word_listing_val_kp = build_vocabulary(key_points_dev_tok, ['key_point'])\n",
        "\n",
        "word_listing_val = word_listing_val_arg + word_listing_val_kp\n",
        "\n",
        "oov_terms_val = get_OOV_terms(embedded_model, word_listing_val)\n",
        "oov_terms_val = list(set(oov_terms_val).difference(set(oov_terms_train)))\n",
        "print(f'There are {len(oov_terms_val)} new OOVs in the validation set.')\n",
        "\n",
        "print('\\n')\n",
        "\n",
        "# Step 3: creation of vocabulary for the test set and extraction of his OOVs.\n",
        "_, _, word_listing_test_arg = build_vocabulary(arguments_test_tok, ['argument'])\n",
        "_, _, word_listing_test_kp = build_vocabulary(key_points_test_tok, ['key_point'])\n",
        "\n",
        "word_listing_test = word_listing_test_arg + word_listing_test_kp\n",
        "\n",
        "oov_terms_test = get_OOV_terms(embedded_model, word_listing_test)\n",
        "oov_terms_test = list(set(oov_terms_test).difference((set(oov_terms_train).union(set(oov_terms_val)))))\n",
        "print(f'There are {len(oov_terms_test)} new OOVs in the test set.')\n",
        "\n",
        "print('\\n')\n",
        "\n",
        "# Step 4: merge vocabulary and OOVs.\n",
        "vocaboulary = np.concatenate((vocaboulary, oov_terms_train, oov_terms_val, oov_terms_test))\n",
        "\n",
        "# Step 5: creation of a comprehensive dictionary.\n",
        "word2idx = dict(zip(vocaboulary, range(1, len(vocaboulary) + 1))) # Start from 1 since we reserve 0 for padding.\n",
        "\n",
        "# Step 6: creation of the whole embedding matrix.\n",
        "embedding_matrix = build_embedding_matrix(embedded_model, emb_dim, word2idx, len(word2idx))\n",
        "\n",
        "print('\\n')\n",
        "print(\"Embedding matrix shape: {}.\".format(embedding_matrix.shape))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "x2I-TwCsZQ5E",
        "outputId": "964c23b8-5994-490a-971c-f58e00cb054f"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "100%|██████████| 5583/5583 [00:00<00:00, 372475.65it/s]\n",
            "100%|██████████| 207/207 [00:00<00:00, 401211.15it/s]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "There are 235 OOVs in the training set.\n",
            "\n",
            "\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "100%|██████████| 932/932 [00:00<00:00, 286485.26it/s]\n",
            "100%|██████████| 36/36 [00:00<00:00, 247939.15it/s]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "There are 43 new OOVs in the validation set.\n",
            "\n",
            "\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "100%|██████████| 723/723 [00:00<00:00, 252896.49it/s]\n",
            "100%|██████████| 33/33 [00:00<00:00, 191972.31it/s]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "There are 23 new OOVs in the test set.\n",
            "\n",
            "\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "100%|██████████| 400301/400301 [00:01<00:00, 387886.66it/s]"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "\n",
            "\n",
            "Embedding matrix shape: (400302, 300).\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "##### 4.1.1.2 **Dataset encoding**\n",
        "The datasets are encoded and aligned with the respective identifiers."
      ],
      "metadata": {
        "id": "WnLsRwA1dawp"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "def encode_sentence(sentence, word2idx):\n",
        "  return [word2idx[words] for words in sentence]\n",
        "\n",
        "def encode_dataframe(dataframe, word2idx, columns):\n",
        "  encoded_dataframe = pd.DataFrame(columns = columns)\n",
        "\n",
        "  for column in columns:\n",
        "    encoded_dataframe[column] = dataframe[column].apply(lambda sentence: encode_sentence(sentence, word2idx))\n",
        "\n",
        "  return encoded_dataframe\n",
        "\n",
        "# The dataset is encoded and then the id columns restored.\n",
        "arguments_train_enc = encode_dataframe(arguments_train_tok, word2idx, arguments_labels_list)\n",
        "arguments_train_enc['arg_id'] = arguments_train['arg_id']\n",
        "\n",
        "arguments_dev_enc = encode_dataframe(arguments_dev_tok, word2idx, arguments_labels_list)\n",
        "arguments_dev_enc['arg_id'] = arguments_dev['arg_id']\n",
        "\n",
        "arguments_test_enc = encode_dataframe(arguments_test_tok, word2idx, arguments_labels_list)\n",
        "arguments_test_enc['arg_id'] = arguments_test['arg_id']\n",
        "\n",
        "key_points_train_enc = encode_dataframe(key_points_train_tok, word2idx, key_points_labels_list)\n",
        "key_points_train_enc['key_point_id'] = key_points_train['key_point_id']\n",
        "\n",
        "key_points_dev_enc = encode_dataframe(key_points_dev_tok, word2idx, key_points_labels_list)\n",
        "key_points_dev_enc['key_point_id'] = key_points_dev['key_point_id']\n",
        "\n",
        "key_points_test_enc = encode_dataframe(key_points_test_tok, word2idx, key_points_labels_list)\n",
        "key_points_test_enc['key_point_id'] = key_points_test['key_point_id']"
      ],
      "metadata": {
        "id": "8pxuQpUteQxK"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "##### 4.1.1.3 **Labels alignment**\n",
        "The pairs of argument and key-point pairs identifier are extracted. With these pairs the encoded arguments and key-points are extracted.\n",
        "\n",
        "Topic and stance gives the “main context”. The argument and the key-point can also be integrated with this main context and then matched."
      ],
      "metadata": {
        "id": "sRs3KYRFX9GU"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "from keras.preprocessing.sequence import pad_sequences\n",
        "\n",
        "def flatten(t: list) -> list:\n",
        "  # Flatten a nested list.\n",
        "  return [item for sublist in t for item in sublist]\n",
        "\n",
        "indexes = [i for i in range(len(labels_test))]\n",
        "\n",
        "# Generations of pairs arg-kp of the test set.\n",
        "arg_id = [labels_test['arg_id'][k] for k in indexes]\n",
        "kp_id = [labels_test['key_point_id'][k] for k in indexes]\n",
        "\n",
        "# Arguments extraction.\n",
        "arguments = flatten([arguments_test_enc.loc[arguments_test_enc['arg_id'] == arg]['argument'].tolist() for arg in arg_id])\n",
        "arguments = pad_sequences(arguments, maxlen = max_tokens, padding = 'post')\n",
        "\n",
        "# Key-points extraction.\n",
        "keypoints = flatten([key_points_test_enc.loc[key_points_test_enc['key_point_id'] == kp]['key_point'].tolist() for kp in kp_id])\n",
        "keypoints = pad_sequences(keypoints, maxlen = max_tokens, padding = 'post')\n",
        "\n",
        "# Topics extraction.\n",
        "topics = flatten([arguments_test_enc.loc[arguments_test_enc['arg_id'] == arg]['topic'].tolist() for arg in arg_id])\n",
        "topics = pad_sequences(keypoints, maxlen = max_tokens, padding = 'post')"
      ],
      "metadata": {
        "id": "ROmFLDWeYN5J"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "##### 4.1.1.4 **GloVe application**\n",
        "GloVe embedding matrix is applied, unrolling the vectors in order to apply the cosine similarity.\n"
      ],
      "metadata": {
        "id": "Qk9m4lFnbyE1"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Application of the embedding matrix.\n",
        "arguments_emb = embedding_matrix[arguments].reshape((len(labels_test), -1))\n",
        "keypoints_emb = embedding_matrix[keypoints].reshape((len(labels_test), -1))\n",
        "\n",
        "# Concatenation of the topic and application of the embedding matrix.\n",
        "arguments_topic = np.concatenate((arguments, topics), axis = -1)\n",
        "keypoints_topic = np.concatenate((keypoints, topics), axis = -1)\n",
        "\n",
        "arguments_topic_emb = embedding_matrix[arguments_topic].reshape((len(labels_test), -1))\n",
        "keypoints_topic_emb = embedding_matrix[keypoints_topic].reshape((len(labels_test), -1))"
      ],
      "metadata": {
        "id": "XAHdckHoZhnP"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "##### 4.1.1.5 **Cosine similarity calculation and evaluation**\n",
        "Cosine similarity is evaluated wether if the topic is considered or not. The general performances are worsened if the topic is taken into account, but the average precision score is higher in the latter case. \n",
        "\n",
        "The cause can be the redundacy in of the such feature.\n"
      ],
      "metadata": {
        "id": "duCMkydXatVA"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "def cos_sim(vec1: np.ndarray, vec2: np.ndarray) -> np.ndarray:\n",
        "  return np.dot(vec1, vec2)/(np.linalg.norm(vec1) * np.linalg.norm(vec2))\n",
        "\n",
        "# Cosine similarity is calculated and then rounded. \n",
        "predictions_glove_no_topic = np.rint([cos_sim(arguments_emb[i], keypoints_emb[i]) for i in range(len(indexes))])\n",
        "predictions_glove_with_topic = np.rint([cos_sim(arguments_topic_emb[i], keypoints_topic_emb[i]) for i in range(len(indexes))])\n",
        "\n",
        "true_values = labels_test['label'].to_numpy()"
      ],
      "metadata": {
        "id": "r-UkjJQQeeaI"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "from sklearn.metrics import classification_report, average_precision_score, PrecisionRecallDisplay, balanced_accuracy_score, ConfusionMatrixDisplay\n",
        "\n",
        "print('Metrics when topic is not considered:')\n",
        "print(classification_report(true_values, predictions_glove_no_topic))\n",
        "print(f'The average precision score is: {average_precision_score(true_values, predictions_glove_no_topic)}.')\n",
        "print(f'The balanced accuracy precision score is: {balanced_accuracy_score(true_values, predictions_glove_no_topic)}.')\n",
        "\n",
        "print(f'The confusion matrix is: ')\n",
        "ConfusionMatrixDisplay.from_predictions(y_true = true_values, y_pred = predictions_glove_no_topic);\n",
        "\n",
        "print('\\n')\n",
        "\n",
        "print('Metrics when topic is considered:')\n",
        "print(classification_report(true_values, predictions_glove_with_topic))\n",
        "print(f'The average precision score is: {average_precision_score(true_values, predictions_glove_with_topic)}.')\n",
        "print(f'The balanced accuracy score is: {balanced_accuracy_score(true_values, predictions_glove_with_topic)}.')\n",
        "\n",
        "print(f'The confusion matrix is: ')\n",
        "ConfusionMatrixDisplay.from_predictions(true_values, predictions_glove_with_topic);"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 1000
        },
        "id": "nJH6U2CYgqrR",
        "outputId": "83fd7526-2e7b-4ea2-e133-6bf9db7387dc"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Metrics when topic is not considered:\n",
            "              precision    recall  f1-score   support\n",
            "\n",
            "           0       0.84      0.99      0.91      2874\n",
            "           1       0.18      0.01      0.02       552\n",
            "\n",
            "    accuracy                           0.83      3426\n",
            "   macro avg       0.51      0.50      0.47      3426\n",
            "weighted avg       0.73      0.83      0.77      3426\n",
            "\n",
            "The average precision score is: 0.16141364461561275.\n",
            "The balanced accuracy precision score is: 0.5009473994735409.\n",
            "The confusion matrix is: \n",
            "\n",
            "\n",
            "Metrics when topic is considered:\n",
            "              precision    recall  f1-score   support\n",
            "\n",
            "           0       0.85      0.28      0.42      2874\n",
            "           1       0.17      0.74      0.27       552\n",
            "\n",
            "    accuracy                           0.36      3426\n",
            "   macro avg       0.51      0.51      0.35      3426\n",
            "weighted avg       0.74      0.36      0.40      3426\n",
            "\n",
            "The average precision score is: 0.164798818151822.\n",
            "The balanced accuracy score is: 0.5132011890714351.\n",
            "The confusion matrix is: \n"
          ]
        },
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 432x288 with 2 Axes>"
            ]
          },
          "metadata": {
            "needs_background": "light"
          }
        },
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 432x288 with 2 Axes>"
            ]
          },
          "metadata": {
            "needs_background": "light"
          }
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "print('Metrics when topic is not considered:')\n",
        "PrecisionRecallDisplay.from_predictions(true_values, [cos_sim(arguments_emb[i], keypoints_emb[i]) for i in range(len(indexes))]);\n",
        "\n",
        "print('Metrics when topic is considered:')\n",
        "PrecisionRecallDisplay.from_predictions(true_values, [cos_sim(arguments_topic_emb[i], keypoints_topic_emb[i]) for i in range(len(indexes))]);"
      ],
      "metadata": {
        "id": "bT_zTa69n05W",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 578
        },
        "outputId": "a3643ee1-688a-4c51-e918-d2f7a20b1340"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Metrics when topic is not considered:\n",
            "Metrics when topic is considered:\n"
          ]
        },
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ]
          },
          "metadata": {
            "needs_background": "light"
          }
        },
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ]
          },
          "metadata": {
            "needs_background": "light"
          }
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "#### 4.1.2 **BERT embeddings**\n",
        "BERT (Bidirectional Encoder Representations from Transformers) provides dense vector representations for natural language by using a deep, pre-trained neural network with the Transformer architecture.\n",
        "\n",
        "BERT is a contextualized embedding model that takes the entire sentence into account. The following implementation takes automatically into account padding and encoding.\n",
        "\n",
        "BERT provides three different kinds of output:\n",
        "* `pooled_output`: pooled output of the entire sequence with shape `[batch_size, hidden_size]`. Can be used as sentence representation;\n",
        "* `sequence_output`: representations of every token in the input sequence with shape `[batch_size, max_sequence_length, hidden_size]`;\n",
        "* `encoder_outputs`: a list of 12 tensors of shapes `[batch_size, sequence_length, hidden_size]` with the outputs of the $i$-th Transformer block.\n",
        "\n",
        "For sake of simplicity (and RAM occupancy) the pooled output is computed with a lighter implementation.\n"
      ],
      "metadata": {
        "id": "_iJy7Ws8pYMw"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Faster implementation to work with pooled outputs.\n",
        "pretrained_bert_model = sentence_transformers.SentenceTransformer('all-mpnet-base-v2');"
      ],
      "metadata": {
        "id": "8wbJPINZrO6z"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "indexes = [i for i in range(len(labels_test))]\n",
        "\n",
        "# Generations of pairs arg-kp of the test set.\n",
        "arg_id = [labels_test['arg_id'][k] for k in indexes]\n",
        "kp_id = [labels_test['key_point_id'][k] for k in indexes]\n",
        "\n",
        "# Arguments extraction.\n",
        "arguments = flatten([arguments_test.loc[arguments_test['arg_id'] == arg]['argument'].tolist() for arg in arg_id])\n",
        "encoded_arguments = pretrained_bert_model.encode(arguments)\n",
        "\n",
        "# Key-points extraction.\n",
        "keypoints = flatten([key_points_test.loc[key_points_test['key_point_id'] == kp]['key_point'].tolist() for kp in kp_id])\n",
        "encoded_keypoints = pretrained_bert_model.encode(keypoints)\n",
        "\n",
        "# Topics extraction.\n",
        "topics = flatten([arguments_test.loc[arguments_test['arg_id'] == arg]['topic'].tolist() for arg in arg_id])\n",
        "encoded_topics = pretrained_bert_model.encode(topics)"
      ],
      "metadata": {
        "id": "JrimRJtOqQxz"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "arguments_topic = np.concatenate((encoded_arguments, encoded_topics), axis = -1)\n",
        "keypoints_topic = np.concatenate((encoded_keypoints, encoded_topics), axis = -1)"
      ],
      "metadata": {
        "id": "Dkx8q8i905N9"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "##### 4.1.2.1 **Cosine similarity calculation and evaluation**\n",
        "Cosine similarity is evaluated wether if the topic is considered or not. The general performances are worsened if the topic is taken into account. The cause can be due to the redundacy of the such feature.\n"
      ],
      "metadata": {
        "id": "zaU2Yk3t3LJF"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "def cos_sim(vec1: np.ndarray, vec2: np.ndarray) -> np.ndarray:\n",
        "  return np.dot(vec1, vec2)/(np.linalg.norm(vec1) * np.linalg.norm(vec2))\n",
        "\n",
        "# Cosine similarity is calculated and then rounded. \n",
        "predictions_bert_no_topic = np.rint([cos_sim(encoded_arguments[i], encoded_keypoints[i]) for i in range(len(indexes))])\n",
        "predictions_bert_with_topic = np.rint([cos_sim(arguments_topic[i], keypoints_topic[i]) for i in range(len(indexes))])\n",
        "\n",
        "true_values = labels_test['label'].to_numpy()"
      ],
      "metadata": {
        "id": "cSQBuZEk3UJ7"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "from sklearn.metrics import classification_report, average_precision_score, PrecisionRecallDisplay, ConfusionMatrixDisplay\n",
        "\n",
        "print('Metrics when topic is not considered:')\n",
        "print(classification_report(true_values, predictions_bert_no_topic))\n",
        "print(f'The average precision score is: {average_precision_score(true_values, predictions_bert_no_topic)}.')\n",
        "print(f'The balanced accuracy precision score is: {balanced_accuracy_score(true_values, predictions_bert_no_topic)}.')\n",
        "\n",
        "print(f'The confusion matrix is: ')\n",
        "ConfusionMatrixDisplay.from_predictions(true_values, predictions_bert_no_topic);\n",
        "\n",
        "print('\\n')\n",
        "\n",
        "print('Metrics when topic is considered:')\n",
        "print(classification_report(true_values, predictions_bert_with_topic))\n",
        "print(f'The average precision score is: {average_precision_score(true_values, predictions_bert_with_topic)}.')\n",
        "print(f'The balanced accuracy score is: {balanced_accuracy_score(true_values, predictions_bert_with_topic)}.')\n",
        "\n",
        "print(f'The confusion matrix is: ')\n",
        "ConfusionMatrixDisplay.from_predictions(true_values, predictions_bert_with_topic);"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 1000
        },
        "outputId": "faa354f4-bb6a-46e3-8ca5-bd923c3b5f8a",
        "id": "U_xlJIbu3UJ9"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Metrics when topic is not considered:\n",
            "              precision    recall  f1-score   support\n",
            "\n",
            "           0       0.92      0.51      0.65      2874\n",
            "           1       0.23      0.76      0.35       552\n",
            "\n",
            "    accuracy                           0.55      3426\n",
            "   macro avg       0.57      0.63      0.50      3426\n",
            "weighted avg       0.81      0.55      0.60      3426\n",
            "\n",
            "The average precision score is: 0.2125523032284284.\n",
            "The balanced accuracy precision score is: 0.6341241566064566.\n",
            "The confusion matrix is: \n",
            "\n",
            "\n",
            "Metrics when topic is considered:\n",
            "              precision    recall  f1-score   support\n",
            "\n",
            "           0       1.00      0.00      0.00      2874\n",
            "           1       0.16      1.00      0.28       552\n",
            "\n",
            "    accuracy                           0.16      3426\n",
            "   macro avg       0.58      0.50      0.14      3426\n",
            "weighted avg       0.86      0.16      0.05      3426\n",
            "\n",
            "The average precision score is: 0.16130917592051433.\n",
            "The balanced accuracy score is: 0.5006958942240779.\n",
            "The confusion matrix is: \n"
          ]
        },
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 432x288 with 2 Axes>"
            ]
          },
          "metadata": {
            "needs_background": "light"
          }
        },
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 432x288 with 2 Axes>"
            ]
          },
          "metadata": {
            "needs_background": "light"
          }
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "print('Metrics when topic is not considered:')\n",
        "PrecisionRecallDisplay.from_predictions(true_values, [cos_sim(encoded_arguments[i], encoded_keypoints[i]) for i in range(len(indexes))]);\n",
        "\n",
        "print('Metrics when topic is considered:')\n",
        "PrecisionRecallDisplay.from_predictions(true_values, [cos_sim(arguments_topic[i], keypoints_topic[i]) for i in range(len(indexes))]);"
      ],
      "metadata": {
        "id": "-sRsu3EOoCws",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 578
        },
        "outputId": "abb0fed8-953e-4ed7-ae19-8ca893b08d80"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Metrics when topic is not considered:\n",
            "Metrics when topic is considered:\n"
          ]
        },
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ]
          },
          "metadata": {
            "needs_background": "light"
          }
        },
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ]
          },
          "metadata": {
            "needs_background": "light"
          }
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "### 4.2 **Tf-idf**\n",
        "In order to assess the role of lexical overlap in the matching task, we represent each argument and key point as tf-idf weighted word vectors and use their cosine similarity as the match score."
      ],
      "metadata": {
        "id": "3LwdSHQdVDwm"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "from sklearn.feature_extraction.text import TfidfVectorizer\n",
        "vectorizer = TfidfVectorizer()\n",
        "\n",
        "indexes = [i for i in range(len(labels_test))]\n",
        "\n",
        "# Generations of pairs arg-kp of the test set.\n",
        "arg_id = [labels_test['arg_id'][k] for k in indexes]\n",
        "kp_id = [labels_test['key_point_id'][k] for k in indexes]\n",
        "\n",
        "# Arguments extraction.\n",
        "arguments = flatten([arguments_test.loc[arguments_test['arg_id'] == arg]['argument'].tolist() for arg in arg_id])\n",
        "\n",
        "# Key-points extraction.\n",
        "keypoints = flatten([key_points_test.loc[key_points_test['key_point_id'] == kp]['key_point'].tolist() for kp in kp_id])\n",
        "\n",
        "# Topics extraction.\n",
        "topics = flatten([arguments_test.loc[arguments_test['arg_id'] == arg]['topic'].tolist() for arg in arg_id])\n",
        "\n",
        "# Pairs of arguments and key-points extraction\n",
        "args_kps = [vectorizer.fit_transform([arguments[i], keypoints[i]]).toarray() for i in indexes]\n",
        "args_kps_topic = [vectorizer.fit_transform([arguments[i] + topics[i], keypoints[i] + topics[i]]).toarray() for i in indexes]"
      ],
      "metadata": {
        "id": "gbRR0_EIUOSX"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "##### 4.2.2 **Cosine similarity calculation and evaluation**\n",
        "Cosine similarity is evaluated wether if the topic is considered or not. The general performances are worsened if the topic is taken into account. The cause can be due to the redundacy of the such feature.\n"
      ],
      "metadata": {
        "id": "yhK8ojqjWoS3"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "predictions_tfidf = np.rint([cos_sim(args_kps[i][0], args_kps[i][1]) for i in indexes])\n",
        "predictions_tfidf_topic = np.rint([cos_sim(args_kps_topic[i][0], args_kps_topic[i][1]) for i in indexes])\n",
        "\n",
        "true_values = labels_test['label'].to_numpy()"
      ],
      "metadata": {
        "id": "dL4BMIbQUg-x"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "PrecisionRecallDisplay.from_predictions(true_values, [cos_sim(args_kps[i][0], args_kps[i][1]) for i in indexes])\n",
        "PrecisionRecallDisplay.from_predictions(true_values, [cos_sim(args_kps_topic[i][0], args_kps_topic[i][1]) for i in indexes])"
      ],
      "metadata": {
        "id": "Zd_ni3nlvHFX",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 297
        },
        "outputId": "9fc4e782-4347-4ad8-f3c4-0188cec2d6d8"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<sklearn.metrics._plot.precision_recall_curve.PrecisionRecallDisplay at 0x7f1b97445590>"
            ]
          },
          "metadata": {},
          "execution_count": 27
        },
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ]
          },
          "metadata": {
            "needs_background": "light"
          }
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "from sklearn.metrics import classification_report, average_precision_score, PrecisionRecallDisplay, ConfusionMatrixDisplay\n",
        "\n",
        "print('Metrics when topic is not considered:')\n",
        "print(classification_report(true_values, predictions_tfidf))\n",
        "print(f'The average precision score is: {average_precision_score(true_values, predictions_tfidf)}.')\n",
        "print(f'The accuracy precision score is: {balanced_accuracy_score(true_values, predictions_tfidf)}.')\n",
        "\n",
        "print(f'The confusion matrix is: ')\n",
        "ConfusionMatrixDisplay.from_predictions(true_values, predictions_tfidf);\n",
        "\n",
        "print('\\n')\n",
        "\n",
        "print('Metrics when topic is considered:')\n",
        "print(classification_report(true_values, predictions_tfidf_topic))\n",
        "print(f'The average precision score is: {average_precision_score(true_values, predictions_tfidf_topic)}.')\n",
        "print(f'The accuracy score is: {balanced_accuracy_score(true_values, predictions_tfidf_topic)}.')\n",
        "\n",
        "print(f'The confusion matrix is: ')\n",
        "ConfusionMatrixDisplay.from_predictions(true_values, predictions_tfidf_topic);"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 1000
        },
        "id": "3iya3dF4WzXJ",
        "outputId": "20438bca-3f6a-4f8d-9fb1-63fb65d6c56c"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Metrics when topic is not considered:\n",
            "              precision    recall  f1-score   support\n",
            "\n",
            "           0       0.84      1.00      0.91      2874\n",
            "           1       1.00      0.00      0.01       552\n",
            "\n",
            "    accuracy                           0.84      3426\n",
            "   macro avg       0.92      0.50      0.46      3426\n",
            "weighted avg       0.87      0.84      0.77      3426\n",
            "\n",
            "The average precision score is: 0.16416025787456534.\n",
            "The accuracy precision score is: 0.5018115942028986.\n",
            "The confusion matrix is: \n",
            "\n",
            "\n",
            "Metrics when topic is considered:\n",
            "              precision    recall  f1-score   support\n",
            "\n",
            "           0       0.84      0.76      0.80      2874\n",
            "           1       0.17      0.26      0.20       552\n",
            "\n",
            "    accuracy                           0.68      3426\n",
            "   macro avg       0.51      0.51      0.50      3426\n",
            "weighted avg       0.73      0.68      0.70      3426\n",
            "\n",
            "The average precision score is: 0.163263762979095.\n",
            "The accuracy score is: 0.5075375934162355.\n",
            "The confusion matrix is: \n"
          ]
        },
        {
          "output_type": "display_data",
          "data": {
            "image/png": "iVBORw0KGgoAAAANSUhEUgAAAT8AAAEGCAYAAAAT05LOAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjIsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+WH4yJAAAa7UlEQVR4nO3de7xXdZ3v8debLYIgyDXiZpChDnXyEnnt+CArRefMA53JRpvK4+RBS7o3Z9TOpKNZzsPSxrwUKqNOXtLRlIoEwhqzR8TFCAVSdt64KVcFARX2/pw/1tr4A9m/vRbs3/5d1vv5eKwHv/X9rcv3B/nu+13f9V1LEYGZWdF0q3YFzMyqweFnZoXk8DOzQnL4mVkhOfzMrJD2q3YFSg0a0BSjRnavdjUsh2cW9ap2FSyH19nCm/GG9uUYp364d6zf0JJp2wWL3pgRERP25XyVUlPhN2pkd+bOGFntalgOpw47stpVsBz+ELP3+RjrN7Qwd8bBmbZtGrps0D6fsEJqKvzMrPYF0Eprtauxzxx+ZpZLEGyPbN3eWubwM7Pc3PIzs8IJgpYGmBbr8DOz3Fpx+JlZwQTQ4vAzsyJyy8/MCieA7b7mZ2ZFE4S7vWZWQAEt9Z99Dj8zyyeZ4VH/HH5mlpNoYZ+ejVATHH5mlksy4OHwM7OCSe7zc/iZWQG1uuVnZkXjlp+ZFVIgWhrgDRgOPzPLzd1eMyucQLwZTdWuxj5z+JlZLslNzu72mlkBecDDzAonQrSEW35mVkCtDdDyq//4NrMulQx47JdpKUfSSEm/lrRE0mJJX0rLL5e0UtLCdDm9ZJ9LJDVLelrSqSXlE9KyZkkXZ/kdbvmZWS6dOOCxA/haRDwhqQ+wQNKs9LvrIuK7pRtLGgucDbwXGAb8StKh6dc3Ah8DVgDzJE2LiCXlTu7wM7PcWjrhPr+IWA2sTj9vlrQUGF5ml4nAvRHxBvCcpGbgmPS75oh4FkDSvem2ZcPP3V4zy6VthkeWJStJo4CjgD+kRZMlLZI0VVL/tGw4sLxktxVpWXvlZTn8zCy31uiWaQEGSZpfskza/ViSDgQeAL4cEZuAm4FDgCNJWobfq8RvcLfXzHJJHmyQud20LiLGtfelpO4kwXdXRDwIEBEvl3x/C/DzdHUlMLJk9xFpGWXK2+WWn5nlEojt0ZRpKUeSgNuApRFxbUn50JLNzgSeSj9PA86W1EPSaGAMMBeYB4yRNFrS/iSDItM6+h1u+ZlZLhF01k3OJwKfBp6UtDAtuxQ4R9KRJI3M54ELkvPGYkn3kQxk7AAuiogWAEmTgRlAEzA1IhZ3dHKHn5nlpE65yTkiHoc9Hmh6mX2uAq7aQ/n0cvvticPPzHIJOq3lV1UOPzPLzQ8zNbPCCeSHmZpZ8SSvrqz/6Kj/X2BmXcwvLTezAgpom71R1xx+ZpabW35mVjgRcsvPzIonGfDw29vMrHD8Dg8zK6BkwMPX/MysgDzDw8wKxzM8zKywOukFRlXl8DOzXCJge6vDz8wKJun2OvzMrIA8w6Og1qzszjVfOphX1nYHBad/aj1nnr+Ovzx1ANdfPII3X+9G037B5O+s4PCjtnL/TYN59MEBALS0wPJlPfnJk0/Rt3/LzrIvTDiUgUO3c+Wdz1XzpxXeuPGbuPDKVTR1C355zwDuu2FItatUc3yrSwaSJgD/TvJc/Vsj4upKnq+rNO0XTPrmKsa8fxtbX+vG5AmHcvRJm7n1W0P51Fdf4oMnb2bu7D7c9q1hXPNAM2d9fi1nfX4tAHNm9uXBWwbvDD6Ah24dzMgxb7D1tfrvStSzbt2Ci769kkvOfjfrVnfnB9OXMWfGQby4rGe1q1ZjGqPbW7FfIKkJuBE4DRhL8lKSsZU6X1caOGQHY96/DYBeB7Yy8j1vsG51dyTYsjmZ9rNlUxMDhmx/276/fqg/48/YuHN97aruzJ3dl9M+ub5rKm/tOuyorax6fn9eerEHO7Z34zcP9+P4U1+tdrVqUmv6Ho+OllpWyZbfMUBzRDwLIOleYCLJm5caxkvL9+cvTx3A4Udv5cIrVnLpOYdwyxXDiIDrpi3bZdvXt4r5v+nDRVet2Fn2w8uGc/7/W8XW1+p/rmS9G/jO7axdtf/O9XWru3P40VurWKPalIz21v//XivZdh0OLC9ZX5GW7ULSpLa3ua9d37L71zVt25ZuXHn+KC68YiW9+7Ty8zsGccG/ruSuBUu44PJVXPvVg3fZfs6sg3jvuC07u7xzZvWl36C3WpFm9aDtJucsSy2resc9IqZExLiIGDd4YP38v8mO7XDl+aM4+W838qHTk67RrPsH7Px80t+8wjMLe+2yz38/3G+XLu+Seb2ZM7MvnzlmLN/53Lv40+N9+LfJuwamdZ31L3Vn8LA3d64PGrqddau7V7FGtasRur2VDL+VwMiS9RFpWd2LgGu/djAjx7zB312wdmf5wCHbWfT7AwFY+PiBDBv9xs7vtmzqxqI5B3LChE07y/7x0tXctWAJd85dwiU3v8ARH9rMP9/wYtf9ENvF0wt7MXz0mwwZ+Qb7dW9l/MRXmDPzoGpXq+a0jfbWe8uvktf85gFjJI0mCb2zgU9W8HxdZvHc3sz+rwGM/qttfO6jhwFw3iWr+PI1y7n5m8NpaRH792jly9e81ev/3S/78YGTNtOzV2u1qm0daG0RN35jON+++1m6NcHMewfwwjMe6d2TRhjtVURU7uDS6cD3SW51mZq+bb1d447oGXNnjCy3idWYU4cdWe0qWA5/iNlsig371CTrf/g74uSpH8+07YMn3rwgIsbty/kqpaL3+UXEdGB6Jc9hZl2v1ru0WXiGh5nl4hkeZlZYjRB+9X/V0sy6VGfd5ydppKRfS1oiabGkL6XlAyTNkrQs/bN/Wi5J10tqlrRI0tElxzo33X6ZpHOz/A6Hn5nl1kn3+e0AvhYRY4HjgIvSKbAXA7MjYgwwO12HZKrsmHSZBNwMSVgClwHHkswsu6wtMMtx+JlZLhGwo7VbpqX8cWJ1RDyRft4MLCWZBTYRuCPd7A7gjPTzRODOSMwB+kkaCpwKzIqIDRGxEZgFTOjod/ian5nlluOa3yBJ80vWp0TElN03kjQKOAr4AzAkIlanX70EtD1XrL0ps5mm0u7O4WdmueR8gdG6ju7zk3Qg8ADw5YjYJL117IgISRW5GdndXjPLLUKZlo5I6k4SfHdFxINp8ctpd5b0zzVpeXtTZvdqKq3Dz8xy64wBDyVNvNuApRFxbclX04C2EdtzgYdLyj+TjvoeB7yado9nAKdI6p8OdJySlpXlbq+Z5RLRaff5nQh8GnhS0sK07FLgauA+SZ8FXgA+kX43HTgdaAa2Aucl9YkNkq4keZ4AwBURsaGjkzv8zCwn0dIJr66MiMeh3ebhR/awfQAXtXOsqcDUPOd3+JlZblmu59U6h5+Z5eK5vWZWTJFc96t3Dj8zy63WH1GfhcPPzHKJThrwqDaHn5nl5m6vmRWSR3vNrHAiHH5mVlC+1cXMCsnX/MyscALR6tFeMyuiBmj4OfzMLCcPeJhZYTVA08/hZ2a5NXTLT9IPKJPvEfHFitTIzGpaAK2tDRx+wPwy35lZUQXQyC2/iLijdF1Sr4jYWvkqmVmta4T7/Dq8WUfS8ZKWAH9O14+QdFPFa2ZmtSsyLjUsy52K3yd5I/p6gIj4E3BSJStlZrUs22sra31QJNNob0QsL32RMNBSmeqYWV2o8VZdFlnCb7mkE4BIXzD8JWBpZatlZjUrIBpgtDdLt/dCktfFDQdWAUfSzuvjzKwolHGpXR22/CJiHfAPXVAXM6sXDdDtzTLa+25JP5O0VtIaSQ9LendXVM7MalRBRnvvBu4DhgLDgPuBeypZKTOrYW03OWdZaliW8OsVEf8ZETvS5cdAz0pXzMxqV0S2pZaVm9s7IP34S0kXA/eSZP7fA9O7oG5mVqsaYLS33IDHApKwa/uVF5R8F8AllaqUmdU21XirLot2u70RMToi3p3+ufviAQ+zoso62JEhICVNTQdSnyopu1zSSkkL0+X0ku8ukdQs6WlJp5aUT0jLmtOeaocyzfCQ9D5gLCXX+iLiziz7mlmj6dTBjNuBG4Dd8+S6iPjuLmeVxgJnA+8lGXz9laRD069vBD4GrADmSZoWEUvKnbjD8JN0GTCeJPymA6cBj++hsmZWFJ3U7Y2IxySNyrj5RODeiHgDeE5SM3BM+l1zRDwLIOnedNuy4ZdltPfjwEeAlyLiPOAI4KCMlTWzRtSacYFBkuaXLJMynmGypEVpt7h/WjYcWF6yzYq0rL3ysrKE37aIaAV2SOoLrAFGZqm9mTWgfPf5rYuIcSXLlAxnuBk4hGQq7Wrge5X4GVmu+c2X1A+4hWQE+DXg95WojJnVh0qO9kbEyzvPI90C/DxdXcmuDa8RaRllytuVZW7v59OPP5T0CNA3IhZ1tJ+ZNbAKhp+koRGxOl09E2gbCZ4G3C3pWpIBjzHAXJLb8cZIGk0SemcDn+zoPOVucj663HcR8USWH2Jm1h5J95AMqA6StAK4DBgv6UiSiH2e9B7jiFgs6T6SgYwdwEUR0ZIeZzIwA2gCpkbE4o7OXa7lV66fHcDJHR08r2eeHcjHzjmvsw9rFdSNP1a7ClYFndXtjYhz9lB8W5ntrwKu2kP5dHLOPCv3AqMP5zmQmRVE0PDT28zM9qwBprc5/Mwst0aY2+vwM7P8GiD8sjzJWZI+Jemb6frBko7paD8za2AFeZLzTcDxQNuozGaSScRmVkCK7Esty9LtPTYijpb0R4CI2Chp/wrXy8xqWUFGe7dLaiJtxEoaTNuUZTMrpFpv1WWRpdt7PfBT4B2SriJ5nNW3K1orM6ttDXDNL8vc3rskLSB5rJWAMyJiacVrZma1qQ6u52WR5WGmBwNbgZ+VlkXEi5WsmJnVsCKEH/AL3nqRUU9gNPA0yaOkzayA1ABX/bN0e/9H6Xr6tJfPt7O5mVldyD3DIyKekHRsJSpjZnWiCN1eSV8tWe0GHA2sqliNzKy2FWXAA+hT8nkHyTXABypTHTOrC40efunNzX0i4utdVB8zqweNHH6S9ouIHZJO7MoKmVltE40/2juX5PreQknTgPuBLW1fRsSDFa6bmdWiAl3z6wmsJ3lnR9v9fgE4/MyKqsHD7x3pSO9TvBV6bRrgp5vZXmuABCgXfk3Agewaem0a4Keb2d5q9G7v6oi4ostqYmb1o8HDr/6fVmhmnS8af7T3I11WCzOrL43c8ouIDV1ZETOrH41+zc/MbM8cfmZWOHXwiPosHH5mlotojG5vlhcYmZntorPe2ytpqqQ1kp4qKRsgaZakZemf/dNySbpeUrOkRemDldv2OTfdfpmkc7P8BoefmeXXeW9vux2YsFvZxcDsiBgDzE7XAU4DxqTLJOBmSMISuAw4FjgGuKwtMMtx+JlZfp0UfhHxGLD7nSUTgTvSz3cAZ5SU3xmJOUA/SUOBU4FZEbEhIjYCs3h7oL6Nr/mZWT75nuoySNL8kvUpETGlg32GRMTq9PNLwJD083Bgecl2K9Ky9srLcviZWX7Zw29dRIzb69NEhFSZ4RV3e80sN7VmW/bSy2l3lvTPNWn5SmBkyXYj0rL2ysty+JlZbp012tuOaUDbiO25wMMl5Z9JR32PA15Nu8czgFMk9U8HOk5Jy8pyt9fM8unEm5wl3QOMJ7k2uIJk1PZq4D5JnwVeAD6Rbj4dOB1oBrYC50EyFVfSlcC8dLsrskzPdfiZWX6dFH4RcU47X73twSoREcBF7RxnKjA1z7kdfmaWS6PM8HD4mVluaq3/9HP4mVk+frCBmRWVu71mVkwOPzMrIrf8zKyYHH5mVjgFeHubmdnb+D4/MyuuqP/0c/iZWW5u+RkA/3n9/Wzb1p3WVtHS2o2LvvE3fPrv/sjpJy/j1U09AJj6kw8wd+EIAM6euIgJ45fR2ipuuuNY5i/q8LmL1gUGD3uTf/r3F+k3eAcETP/xQB66bXC1q1V7fJNzeZKmAv8LWBMR76vUeWrF1781gU2be+5S9sD0sfzXL3b96QcPf4Xxxz/H//mnMxjYfyv/9o2ZnPeVM2kNP12s2lp2iClXDKP5yV4c0LuFGx55hice68OLy3p2vHPBNMKARyX/i7udDM/RL5oTxr3Ib34/mu07mnhpbR9WvdSHw96zrtrVMmDDmu40P9kLgG1bmlje3JNBQ7dXuVa1qcIPM+0SFWv5RcRjkkZV6vi1JEJcfclMIsQvZh/K9EcPA2DiqUv52El/4ZlnB/KjH3+Q17b0YFD/rSxtfqsrtXZDbwb131qtqls7hox4k0Pet40/P9Gr2lWpPYEHPDqDpEkkr6GjR4+DqlybvfOVy09j/cbe9Ou7jasvncnyVQfxs18dzl0PHkEg/vdZf+SCT83jez/6ULWrahn07NXCv9z6PD/85jC2vtZU7erUpEYY8Kj6haaImBIR4yJi3P7de1e7Ontl/cak3q9sOoDfzTuYww5ZxyuvHkBrdCNCTH90DIcdknRt123sxeCBW3buO3jAFtZtdOuiVjTtF/zLrc/z6IP9+d0v+1W7OrWr897bWzVVD79617PHdg7ouX3n5w+8fxXPr+jHgH5vdWVP/OCLPL88+Q/p9wtGMv745+i+XwvvHLyZ4e/cxNPNg6pSd9td8NXvLWf5sp48OMWjvO1pu8m5gu/w6BJV7/bWu34Hvc7lX30UgKam4Ne/G838P43gnz//GIe8awOBeHntgXz/1uMBeGFFfx6bM4pbv/sQLS3iB/9xnEd6a8R7j9nCR8/ayLNLenLTrKcB+I/vDGXeo32rXLMaE9EQDzNVVOjCZemLSYCXgcsi4rZy+/TtMzw+OG6Pj+i3GtXtv/9Y7SpYDn+I2WyKDdqXY/TpNyKOOulLmbb97c/+74J9eW9vJVVytLe9F5OYWZ2r9S5tFu72mlk+ATRAt9fhZ2b51X/2OfzMLD93e82skBphtNfhZ2b51MENzFk4/Mwsl+Qm5/pPP4efmeVX409sycLhZ2a5NULLz/OqzCyfrA81yJCPkp6X9KSkhZLmp2UDJM2StCz9s39aLknXS2qWtEjS0fvyMxx+ZpZTMrc3y5LRhyPiyJJpcBcDsyNiDDA7XQc4DRiTLpOAm/flVzj8zCy/iGzL3pkI3JF+vgM4o6T8zkjMAfpJGrq3J3H4mVk+kesx9oMkzS9ZJr39aMyUtKDkuyERsTr9/BIwJP08HFhesu+KtGyveMDDzPLL3qpb18FTXT4UESslvQOYJenPu54mQqrMfBK3/Mwsv04a8IiIlemfa4CfAscAL7d1Z9M/16SbrwRGluw+Ii3bKw4/M8tNra2ZlrLHkHpL6tP2GTgFeAqYBpybbnYu8HD6eRrwmXTU9zjg1ZLucW7u9ppZPkFn3eQ8BPipJEiy6O6IeETSPOA+SZ8FXgA+kW4/HTgdaAa2Aufty8kdfmaWi4hOuck5Ip4FjthD+XrgI3soD6DTHvXu8DOz/BpghofDz8zyc/iZWeF03jW/qnL4mVluHY3k1gOHn5nltE9T12qGw8/M8gkcfmZWUPXf63X4mVl+jfAwU4efmeXn8DOzwomAlvrv9zr8zCw/t/zMrJAcfmZWOAFkfz9HzXL4mVlOAeFrfmZWNIEHPMysoHzNz8wKyeFnZsXjBxuYWREF4EdamVkhueVnZsXj6W1mVkQB4fv8zKyQPMPDzArJ1/zMrHAiPNprZgXllp+ZFU8QLS3VrsQ+c/iZWT5+pJWZFVYD3OrSrdoVMLP6EkC0RqalI5ImSHpaUrOkiytf+7c4/Mwsn0gfZpplKUNSE3AjcBowFjhH0tgu+AWAu71mthc6acDjGKA5Ip4FkHQvMBFY0hkH74iihoasJa0FXqh2PSpgELCu2pWwXBr13+xdETF4Xw4g6RGSv58segKvl6xPiYgp6XE+DkyIiPPT9U8Dx0bE5H2pX1Y11fLb13+UWiVpfkSMq3Y9LDv/m7UvIiZUuw6dwdf8zKxaVgIjS9ZHpGVdwuFnZtUyDxgjabSk/YGzgWlddfKa6vY2sCnVroDl5n+zCouIHZImAzOAJmBqRCzuqvPX1ICHmVlXcbfXzArJ4WdmheTwq6BqTt2xvSNpqqQ1kp6qdl2sshx+FVLtqTu2124HGuI+NivP4Vc5O6fuRMSbQNvUHathEfEYsKHa9bDKc/hVznBgecn6irTMzGqAw8/MCsnhVzlVnbpjZuU5/CqnqlN3zKw8h1+FRMQOoG3qzlLgvq6cumN7R9I9wO+BwyStkPTZatfJKsPT28yskNzyM7NCcviZWSE5/MyskBx+ZlZIDj8zKySHXx2R1CJpoaSnJN0vqdc+HOv29O1ZSLq13EMXJI2XdMJenON5SW97y1d75btt81rOc10u6et562jF5fCrL9si4siIeB/wJnBh6ZeS9uq1BBFxfkSUe1fqeCB3+JnVModf/fot8J60VfZbSdOAJZKaJF0jaZ6kRZIuAFDihvT5gr8C3tF2IEm/kTQu/TxB0hOS/iRptqRRJCH7lbTV+T8lDZb0QHqOeZJOTPcdKGmmpMWSbgXU0Y+Q9JCkBek+k3b77rq0fLakwWnZIZIeSff5raTDO+Mv04rHLzCqQ2kL7zTgkbToaOB9EfFcGiCvRsQHJfUAfidpJnAUcBjJswWHAEuAqbsddzBwC3BSeqwBEbFB0g+B1yLiu+l2dwPXRcTjkg4mmcXyV8BlwOMRcYWkvwayzI74x/QcBwDzJD0QEeuB3sD8iPiKpG+mx55M8mKhCyNimaRjgZuAk/fir9EKzuFXXw6QtDD9/FvgNpLu6NyIeC4tPwV4f9v1POAgYAxwEnBPRLQAqyQ9uofjHwc81nasiGjvuXYfBcZKOxt2fSUdmJ7jb9N9fyFpY4bf9EVJZ6afR6Z1XQ+0Aj9Jy38MPJie4wTg/pJz98hwDrO3cfjVl20RcWRpQRoCW0qLgC9ExIzdtju9E+vRDTguIl7fQ10ykzSeJEiPj4itkn4D9Gxn80jP+8rufwdme8PX/BrPDOBzkroDSDpUUm/gMeDv02uCQ4EP72HfOcBJkkan+w5IyzcDfUq2mwl8oW1FUlsYPQZ8Mi07DejfQV0PAjamwXc4ScuzTTegrfX6SZLu9CbgOUlnpeeQpCM6OIfZHjn8Gs+tJNfznkhfwvMjkhb+T4Fl6Xd3kjy5ZBcRsRaYRNLF/BNvdTt/BpzZNuABfBEYlw6oLOGtUed/JQnPxSTd3xc7qOsjwH6SlgJXk4Rvmy3AMelvOBm4Ii3/B+Czaf0W41cD2F7yU13MrJDc8jOzQnL4mVkhOfzMrJAcfmZWSA4/Myskh5+ZFZLDz8wK6f8DVVSj8l8XylAAAAAASUVORK5CYII=\n",
            "text/plain": [
              "<Figure size 432x288 with 2 Axes>"
            ]
          },
          "metadata": {
            "needs_background": "light"
          }
        },
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 432x288 with 2 Axes>"
            ]
          },
          "metadata": {
            "needs_background": "light"
          }
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## 5.0 **Supervised approaches**"
      ],
      "metadata": {
        "id": "SieCEoPSUd8J"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "### 5.1 **Metrics**"
      ],
      "metadata": {
        "id": "c_HJIvZO9986"
      }
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "r2m21Av_4Bjs"
      },
      "outputs": [],
      "source": [
        "from keras import backend as K\n",
        "\n",
        "def recall_m(y_true, y_pred):\n",
        "    true_positives = K.sum(K.round(K.clip(y_true * y_pred, 0, 1)))\n",
        "    possible_positives = K.sum(K.round(K.clip(y_true, 0, 1)))\n",
        "    recall = true_positives / (possible_positives + K.epsilon())\n",
        "    return recall\n",
        "\n",
        "def precision_m(y_true, y_pred):\n",
        "    true_positives = K.sum(K.round(K.clip(y_true * y_pred, 0, 1)))\n",
        "    predicted_positives = K.sum(K.round(K.clip(y_pred, 0, 1)))\n",
        "    precision = true_positives / (predicted_positives + K.epsilon())\n",
        "    return precision\n",
        "\n",
        "def f1_m(y_true, y_pred):\n",
        "    precision = precision_m(y_true, y_pred)\n",
        "    recall = recall_m(y_true, y_pred)\n",
        "    return 2 * ((precision * recall) / (precision + recall + K.epsilon()))"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "3W41M7vbfG2c"
      },
      "source": [
        "### 5.2 **Neural architecture #1**\n",
        "The experimented neural architecture is composed by:\n",
        "* *Stance encoder*: encode the stance value (1 or -1) employing a fully-connected network with no activation function to map the scalar input to a $N$-dimensional vector space;\n",
        "* *BERT*: extract the contextualized representation for textual inputs;\n",
        "* A context integration layer is done by stacking stance encoding, topic encoding and statements encoding;\n",
        "* *Statement encoder*: another fully-connected network on top of the context integration layer to get the final $D$-dimensional embeddings for key points or arguments.\n",
        "\n",
        "<div>\n",
        "<center>\n",
        "<img src = \"https://i.ibb.co/BPGXRyJ/architecture.jpg\" width = \"800\"/>\n",
        "<center>\n",
        "</div>\n",
        "\n",
        "The extraction of contextualized vector representation is already embedded in the generator."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "UYQRPK4M-GT2"
      },
      "outputs": [],
      "source": [
        "# Load the pre-trained BERT model.\n",
        "bert_preprocess_model = hub.KerasLayer(\"https://tfhub.dev/tensorflow/bert_en_uncased_preprocess/3\")\n",
        "bert_model = hub.KerasLayer(\"https://tfhub.dev/tensorflow/bert_en_uncased_L-24_H-1024_A-16/4\", trainable = False)\n",
        "\n",
        "# Hidden states of BERT.\n",
        "layers = 1024"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "TIvTHWF4Y4E8"
      },
      "outputs": [],
      "source": [
        "from tensorflow.keras.layers import Dense, TimeDistributed, Input, concatenate, add, average, Dropout, dot, Lambda, LSTM, Bidirectional\n",
        "from tensorflow.keras.models import Model\n",
        "from tensorflow.keras.callbacks import EarlyStopping, ModelCheckpoint\n",
        "from tensorflow.keras.initializers import Constant, glorot_normal\n",
        "from tensorflow.keras.optimizers import RMSprop, Adamax, SGD, Adam\n",
        "from tensorflow.keras.optimizers.schedules import ExponentialDecay, CosineDecayRestarts\n",
        "from tensorflow.keras import regularizers\n",
        "from tensorflow.keras.metrics import Precision, Recall\n",
        "from tensorflow.keras.losses import BinaryCrossentropy, CosineSimilarity\n",
        "\n",
        "\n",
        "# Note: the learning rate is not parametrized since we use a scheduler.\n",
        "def classifier(no_last_state: int, \n",
        "               dropout: float = 0.5, recurrent_dropout: float = 0.25, \n",
        "               initial_learning_rate: float = 0.0001, N_stance: int = 16) -> Model:\n",
        "\n",
        "  hidden_states = 32\n",
        "\n",
        "  ''' Network structure '''\n",
        "  # Inputs.\n",
        "  topic_input = Input(shape = (no_last_state * layers), \n",
        "                      #batch_size = batch_size, \n",
        "                      name = 'topic_input')\n",
        "  \n",
        "  argument_input = Input(shape = (no_last_state * layers), \n",
        "                         #batch_size = batch_size, \n",
        "                         name = 'argument_input')\n",
        "  \n",
        "  keypoint_input = Input(shape = (no_last_state * layers), \n",
        "                         #batch_size = batch_size, \n",
        "                         name = 'keypoint_input')\n",
        "\n",
        "  stance_input = Input(shape = (1, ), \n",
        "                       #batch_size = batch_size, \n",
        "                       name = 'stance_input')\n",
        "\n",
        "  # Stance encoder.\n",
        "  encoded_stance = Dense(units = N_stance, activation = None, name = 'fcn')(stance_input)\n",
        "  \n",
        "  # Context integration layer.\n",
        "  argument_integration = concatenate([encoded_stance, topic_input, argument_input])\n",
        "  keypoint_integration = concatenate([encoded_stance, topic_input, keypoint_input])\n",
        "\n",
        "  # Statement encoder.\n",
        "  mlp0 = Dense(units = (hidden_states / 2), activation = 'selu', \n",
        "              kernel_regularizer = regularizers.l1_l2(l1 = 1e-5, l2 = 1e-4),\n",
        "              bias_regularizer = regularizers.l2(1e-4),\n",
        "              activity_regularizer = regularizers.l2(1e-5),\n",
        "              name = 'st_enc_0')\n",
        "  \n",
        "  mlp1 = Dropout(rate = dropout, name = 'st_enc_drp')\n",
        "\n",
        "  mlp2 = Dense(units = hidden_states, activation = 'selu', \n",
        "              kernel_regularizer = regularizers.l1_l2(l1 = 1e-5, l2 = 1e-4),\n",
        "              bias_regularizer = regularizers.l2(1e-4),\n",
        "              activity_regularizer = regularizers.l2(1e-5),               \n",
        "              name = 'st_enc_2')\n",
        "\n",
        "  mlp0_argument = mlp0(argument_integration)\n",
        "  mlp1_argument = mlp1(mlp0_argument)\n",
        "  argument_output = mlp2(mlp1_argument)\n",
        "\n",
        "  mlp0_keypoint = mlp0(keypoint_integration)\n",
        "  mlp1_keypoint = mlp1(mlp0_keypoint)\n",
        "  keypoint_output = mlp2(mlp1_keypoint)\n",
        "\n",
        "  # Cosine similarity.\n",
        "  cos_sim = dot(inputs = [argument_output, keypoint_output], axes = -1, normalize = True)\n",
        "  # Rescale in range [0,1].\n",
        "  output = Lambda(lambda x: (x + 1) / 2)(cos_sim)\n",
        "\n",
        "  end_to_end = Model(inputs = (topic_input, argument_input, keypoint_input, stance_input), outputs = output)\n",
        "\n",
        "  # Compile the model.\n",
        "  scheduler_exp = ExponentialDecay(initial_learning_rate,\n",
        "                                   decay_steps = 100000,\n",
        "                                   decay_rate = 0.96,\n",
        "                                   staircase = True)\n",
        "  \n",
        "  scheduler_cos = CosineDecayRestarts(initial_learning_rate,\n",
        "                                      first_decay_steps = 1000)\n",
        "\n",
        "  end_to_end.compile(loss = focal_loss.BinaryFocalLoss(gamma = 2),\n",
        "                     optimizer = Adamax(learning_rate = scheduler_cos),\n",
        "                     metrics = ['binary_accuracy', precision_m, recall_m, f1_m]) \n",
        "  \n",
        "  # Check if the structure is correct.\n",
        "  end_to_end.summary()\n",
        "\n",
        "  return end_to_end"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "0PI8tc-49BEF",
        "outputId": "3dd34a4a-b389-4070-ab5f-86d1de30c15e"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Model: \"model\"\n",
            "__________________________________________________________________________________________________\n",
            " Layer (type)                   Output Shape         Param #     Connected to                     \n",
            "==================================================================================================\n",
            " stance_input (InputLayer)      [(None, 1)]          0           []                               \n",
            "                                                                                                  \n",
            " fcn (Dense)                    (None, 16)           32          ['stance_input[0][0]']           \n",
            "                                                                                                  \n",
            " topic_input (InputLayer)       [(None, 4096)]       0           []                               \n",
            "                                                                                                  \n",
            " argument_input (InputLayer)    [(None, 4096)]       0           []                               \n",
            "                                                                                                  \n",
            " keypoint_input (InputLayer)    [(None, 4096)]       0           []                               \n",
            "                                                                                                  \n",
            " concatenate (Concatenate)      (None, 8208)         0           ['fcn[0][0]',                    \n",
            "                                                                  'topic_input[0][0]',            \n",
            "                                                                  'argument_input[0][0]']         \n",
            "                                                                                                  \n",
            " concatenate_1 (Concatenate)    (None, 8208)         0           ['fcn[0][0]',                    \n",
            "                                                                  'topic_input[0][0]',            \n",
            "                                                                  'keypoint_input[0][0]']         \n",
            "                                                                                                  \n",
            " st_enc_0 (Dense)               (None, 16)           131344      ['concatenate[0][0]',            \n",
            "                                                                  'concatenate_1[0][0]']          \n",
            "                                                                                                  \n",
            " st_enc_drp (Dropout)           (None, 16)           0           ['st_enc_0[0][0]',               \n",
            "                                                                  'st_enc_0[1][0]']               \n",
            "                                                                                                  \n",
            " st_enc_2 (Dense)               (None, 32)           544         ['st_enc_drp[0][0]',             \n",
            "                                                                  'st_enc_drp[1][0]']             \n",
            "                                                                                                  \n",
            " dot (Dot)                      (None, 1)            0           ['st_enc_2[0][0]',               \n",
            "                                                                  'st_enc_2[1][0]']               \n",
            "                                                                                                  \n",
            " lambda (Lambda)                (None, 1)            0           ['dot[0][0]']                    \n",
            "                                                                                                  \n",
            "==================================================================================================\n",
            "Total params: 131,920\n",
            "Trainable params: 131,920\n",
            "Non-trainable params: 0\n",
            "__________________________________________________________________________________________________\n"
          ]
        }
      ],
      "source": [
        "# Number of last states to concatenate out.\n",
        "l = 4\n",
        "\n",
        "matcher = classifier(no_last_state = l, initial_learning_rate = 0.00005)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 340
        },
        "id": "nTBKAxYD9F80",
        "outputId": "e3a01696-7c36-4189-861e-e7e4b427e126"
      },
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<IPython.core.display.Image object>"
            ]
          },
          "metadata": {},
          "execution_count": 15
        }
      ],
      "source": [
        "from tensorflow.keras.utils import plot_model\n",
        "plot_model(matcher, show_shapes = True)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "fXgUI_zQH8Dg"
      },
      "source": [
        "#### 5.2.1 **Data generator with vector representation**\n",
        "To avoid high memory usage a data generator is implemented.\n",
        "\n",
        "The generator is initialized with:\n",
        "* A *shuffle* parameter to add more robustness to the batches of data;\n",
        "* A *batch_size* parameter to decide the size of the aforementioned batches;\n",
        "* The dataset parameters;\n",
        "* The *embedder* parameter to pass the chosen transformer;\n",
        "* A *no_last_state* parameter to decide how many states of the transformer's output concatenate to obtain the representation.\n",
        "\n",
        "The data is handled in order to parse and align the pairs in the labels dataframes. Then, topics, arguments and keypoints are encoded through BERT, and averaged over the last $l$ states.\n",
        "\n",
        "Zero-Shot learning is a type of machine learning technique, where the model is used without fine-tuning on a particular task.\n",
        "\n",
        "A single datapoint is output in the form of: `([topic, argument, keypoint, stance], label)`."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "4cPWSRvShDuG"
      },
      "outputs": [],
      "source": [
        "from tensorflow.keras.utils import Sequence\n",
        "\n",
        "def flatten(t: list) -> list:\n",
        "  # Flatten a nested list.\n",
        "  return [item for sublist in t for item in sublist]\n",
        "\n",
        "class DataGenerator(Sequence):\n",
        "  def __init__(self, shuffle: bool, batch_size: int, \n",
        "               arguments_df: pd.DataFrame, key_points_df: pd.DataFrame, labels_df: pd.DataFrame, \n",
        "               preprocessor, pretrained_model, no_last_state: int):\n",
        "    \n",
        "    self.shuffle = shuffle\n",
        "    self.batch_size = batch_size\n",
        "    self.no_last_state = no_last_state\n",
        "    self.preprocessor = preprocessor\n",
        "    self.pretrained_model = pretrained_model\n",
        "\n",
        "    self.arguments_df = arguments_df.copy()\n",
        "    self.key_points_df = key_points_df.copy()\n",
        "    self.labels_df = labels_df.copy()      \n",
        "    \n",
        "    # Labels.\n",
        "    self.labels = labels_df['label'].values\n",
        "\n",
        "    # Stance.\n",
        "    self.stance = arguments_df['stance'].tolist()\n",
        "\n",
        "    self.length = len(labels_df)\n",
        "    self.indexes = np.arange(self.length)\n",
        "    self.on_epoch_end()\n",
        "\n",
        "    self.n = 0\n",
        "\n",
        "  def on_epoch_end(self):\n",
        "    # Shuffle the indexes to have more robust batches.\n",
        "    if self.shuffle:\n",
        "      np.random.shuffle(self.indexes)\n",
        "\n",
        "  def __len__(self):\n",
        "    # Length of the batch.\n",
        "    return int(np.ceil(self.length / self.batch_size))\n",
        "\n",
        "  def __getitem__(self, idx):\n",
        "    '''Generate one batch of data.'''\n",
        "    # Select the indexes of the batch.\n",
        "    indexes = self.indexes[idx * self.batch_size : (idx + 1) * self.batch_size]\n",
        "\n",
        "    # For each row in the labels dataframe we have the pair argument and keypoint. These two lines retrieve the pairs in the batch\n",
        "    arg_id = [self.labels_df['arg_id'][k] for k in indexes]\n",
        "    kp_id = [self.labels_df['key_point_id'][k] for k in indexes]\n",
        "\n",
        "    ''' Warning: it produces nested list! '''\n",
        "\n",
        "    # Take the topic from the arguments dataframe that match the given argument, already paired before.\n",
        "    topics = flatten([self.arguments_df.loc[self.arguments_df['arg_id'] == arg]['topic'].tolist() for arg in arg_id])\n",
        "    # Preprocces add [CLS] as 0 and [SEP] as 2 and pads with 1s.\n",
        "    preprocessed_topic = self.preprocessor(topics)\n",
        "    # Encode the topics and picks the last four states of the [CLS].\n",
        "    encoded_topic = np.array(self.pretrained_model(preprocessed_topic)['encoder_outputs'][-self.no_last_state:])[:,:,0,:]\n",
        "    # Swap axes to have the batch size at the beginning.\n",
        "    encoded_topic = np.swapaxes(encoded_topic, 0, 1)\n",
        "    encoded_topic = np.reshape(encoded_topic, (-1, self.no_last_state * layers))\n",
        "\n",
        "    # Take the arguments from the arguments dataframe that match the given argument, already paired before.\n",
        "    arguments = flatten([self.arguments_df.loc[self.arguments_df['arg_id'] == arg]['argument'].tolist() for arg in arg_id])\n",
        "    # Preprocces add [CLS] as 0 and [SEP] as 2 and pads with 1s.\n",
        "    preprocessed_argument = self.preprocessor(arguments)\n",
        "    # Encode the arguments and picks the last four states of the [CLS].\n",
        "    encoded_argument = np.array(self.pretrained_model(preprocessed_argument)['encoder_outputs'][-self.no_last_state:])[:,:,0,:]\n",
        "    # Swap axes to have the batch size at the beginning.\n",
        "    encoded_argument = np.swapaxes(encoded_argument, 0, 1)\n",
        "    encoded_argument = np.reshape(encoded_argument, (-1, self.no_last_state * layers))\n",
        "    \n",
        "    # Take the keypoint from the keypoints dataframe that match the given argument, already paired before.\n",
        "    keypoints = flatten([self.key_points_df.loc[self.key_points_df['key_point_id'] == kp]['key_point'].tolist() for kp in kp_id])\n",
        "    # Preprocces add [CLS] as 0 and [SEP] as 2 and pads with 1s.\n",
        "    preprocessed_keypoint = self.preprocessor(keypoints)\n",
        "    # Encode the keypoints and picks the last four states of the [CLS].\n",
        "    encoded_keypoint = np.array(self.pretrained_model(preprocessed_keypoint)['encoder_outputs'][-self.no_last_state:])[:,:,0,:]\n",
        "    # Swap axes to have the batch size at the beginning.\n",
        "    encoded_keypoint = np.swapaxes(encoded_keypoint, 0, 1)\n",
        "    encoded_keypoint = np.reshape(encoded_keypoint, (-1, self.no_last_state * layers))\n",
        "\n",
        "    # Take the stance from the arguments dataframe that match the given argument, already paired before.\n",
        "    stance = np.array([self.arguments_df.loc[self.arguments_df['arg_id'] == arg]['stance'].tolist() for arg in arg_id])\n",
        "\n",
        "    labels = np.array([self.labels[k] for k in indexes])\n",
        "\n",
        "    features = [encoded_topic, \n",
        "                encoded_argument, \n",
        "                encoded_keypoint, \n",
        "                stance]\n",
        "\n",
        "    return features, labels\n",
        "    \n",
        "  def __next__(self):\n",
        "    if self.n >= self.__len__():\n",
        "        self.n = 0\n",
        "    \n",
        "    result = self.__getitem__(self.n)\n",
        "    self.n += 1\n",
        "\n",
        "    return result\n",
        "  "
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "VHgyaB52rQLs"
      },
      "outputs": [],
      "source": [
        "# Batch size.\n",
        "batch_size = 32\n",
        "\n",
        "# Instantiate generators.\n",
        "train_gen = DataGenerator(shuffle = True, batch_size = batch_size,\n",
        "                          arguments_df = arguments_train, key_points_df = key_points_train, labels_df = labels_train, \n",
        "                          preprocessor = bert_preprocess_model, pretrained_model = bert_model, no_last_state = l)\n",
        "\n",
        "dev_gen = DataGenerator(shuffle = True, batch_size = batch_size,\n",
        "                        arguments_df = arguments_dev, key_points_df = key_points_dev, labels_df = labels_dev, \n",
        "                        preprocessor = bert_preprocess_model, pretrained_model = bert_model, no_last_state = l)\n",
        "\n",
        "# No need to shuffle test data.\n",
        "test_gen = DataGenerator(shuffle = False, batch_size = batch_size,\n",
        "                         arguments_df = arguments_test, key_points_df = key_points_test, labels_df = labels_test, \n",
        "                         preprocessor = bert_preprocess_model, pretrained_model = bert_model, no_last_state = l)"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "#### 5.2.2 **Training**"
      ],
      "metadata": {
        "id": "CaTisB1C-IQo"
      }
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "rkEUK8lZ-v82"
      },
      "outputs": [],
      "source": [
        "checkpoint = [EarlyStopping(monitor = 'val_loss', patience = 10, verbose = 1, mode = 'auto'),\n",
        "              ModelCheckpoint(filepath = \"/content/drive/MyDrive/[NLP]/project/models/adamax_cd_hu64_bs128.h5\",\n",
        "                              monitor = 'val_loss', verbose = 1, save_best_only = True)]"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "qIJVDcWRA8pJ"
      },
      "outputs": [],
      "source": [
        "# Train the model.\n",
        "matcher.fit(x = train_gen,\n",
        "            validation_data = dev_gen,\n",
        "            epochs = 100, callbacks = checkpoint)  "
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "f67V2J67Kv8t"
      },
      "outputs": [],
      "source": [
        "# Manual saving in case Colab crashes.\n",
        "\"\"\" \n",
        "from tensorflow.keras.models import save_model\n",
        "save_model(reloaded_model, '/content/drive/MyDrive/[NLP]/project/models/adamax_cd_hu64_bs128.h5')\n",
        "\"\"\""
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "DtgTzVwrSnTk"
      },
      "outputs": [],
      "source": [
        "# Reload the model and restart the training.\n",
        "from tensorflow.keras.models import load_model\n",
        "\n",
        "reloaded_model = load_model(filepath = '/content/drive/MyDrive/[NLP]/project/models/adamax_cd_hu64_bs128.h5',\n",
        "                            custom_objects = {'precision_m': precision_m, 'recall_m': recall_m, 'f1_m': f1_m})\n",
        "\n",
        "# To change optimizers in further training.\n",
        "\"\"\"\n",
        "scheduler_cos = CosineDecayRestarts(initial_learning_rate = 0.000001, first_decay_steps = 1000)\n",
        "  \n",
        "reloaded_model.compile(loss = focal_loss.BinaryFocalLoss(gamma = 2),\n",
        "                       optimizer = Adamax(learning_rate = scheduler_cos),\n",
        "                       metrics = ['binary_accuracy', precision_m, recall_m, f1_m]) \n",
        "\"\"\"\n",
        "\n",
        "reloaded_model.summary()\n",
        "\n",
        "reloaded_model.fit(x = train_gen,\n",
        "                   validation_data = dev_gen,\n",
        "                   epochs = 100, callbacks = checkpoint)"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "#### 5.2.3 **Classifier evaluation**"
      ],
      "metadata": {
        "id": "xOy9zQVuWhFh"
      }
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "64jNFl101W1r",
        "outputId": "d630f5ed-67e3-4900-951b-c0b91f368d6e"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Model: \"model\"\n",
            "__________________________________________________________________________________________________\n",
            " Layer (type)                   Output Shape         Param #     Connected to                     \n",
            "==================================================================================================\n",
            " stance_input (InputLayer)      [(None, 1)]          0           []                               \n",
            "                                                                                                  \n",
            " fcn (Dense)                    (None, 16)           32          ['stance_input[0][0]']           \n",
            "                                                                                                  \n",
            " topic_input (InputLayer)       [(None, 4096)]       0           []                               \n",
            "                                                                                                  \n",
            " argument_input (InputLayer)    [(None, 4096)]       0           []                               \n",
            "                                                                                                  \n",
            " keypoint_input (InputLayer)    [(None, 4096)]       0           []                               \n",
            "                                                                                                  \n",
            " concatenate (Concatenate)      (None, 8208)         0           ['fcn[0][0]',                    \n",
            "                                                                  'topic_input[0][0]',            \n",
            "                                                                  'argument_input[0][0]']         \n",
            "                                                                                                  \n",
            " concatenate_1 (Concatenate)    (None, 8208)         0           ['fcn[0][0]',                    \n",
            "                                                                  'topic_input[0][0]',            \n",
            "                                                                  'keypoint_input[0][0]']         \n",
            "                                                                                                  \n",
            " st_enc_0 (Dense)               (None, 16)           131344      ['concatenate[0][0]',            \n",
            "                                                                  'concatenate_1[0][0]']          \n",
            "                                                                                                  \n",
            " st_enc_drp (Dropout)           (None, 16)           0           ['st_enc_0[0][0]',               \n",
            "                                                                  'st_enc_0[1][0]']               \n",
            "                                                                                                  \n",
            " st_enc_2 (Dense)               (None, 32)           544         ['st_enc_drp[0][0]',             \n",
            "                                                                  'st_enc_drp[1][0]']             \n",
            "                                                                                                  \n",
            " dot (Dot)                      (None, 1)            0           ['st_enc_2[0][0]',               \n",
            "                                                                  'st_enc_2[1][0]']               \n",
            "                                                                                                  \n",
            " lambda (Lambda)                (None, 1)            0           ['dot[0][0]']                    \n",
            "                                                                                                  \n",
            "==================================================================================================\n",
            "Total params: 131,920\n",
            "Trainable params: 131,920\n",
            "Non-trainable params: 0\n",
            "__________________________________________________________________________________________________\n"
          ]
        }
      ],
      "source": [
        "from tensorflow.keras.models import load_model\n",
        "\n",
        "reloaded_model = load_model(filepath = '/content/drive/MyDrive/[NLP]/project/models/adamax_cd_hu64_bs128.h5',\n",
        "                            custom_objects = {'precision_m': precision_m, 'recall_m': recall_m, 'f1_m': f1_m})\n",
        " \n",
        "reloaded_model.summary()"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Sample weighting.\n",
        "total_samples = len(labels_test['label'].to_numpy())\n",
        "\n",
        "pos_samples = sum(labels_test['label'].to_numpy())\n",
        "neg_samples = total_samples - pos_samples\n",
        "\n",
        "pos_percentage = pos_samples/total_samples\n",
        "neg_percentage = neg_samples/total_samples\n",
        "\n",
        "weights = []\n",
        "\n",
        "for p in labels_test['label'].to_numpy():\n",
        "  if p == 1:\n",
        "    weights.append(pos_percentage)\n",
        "  else:\n",
        "    weights.append(neg_percentage)"
      ],
      "metadata": {
        "id": "bUehIDDFr-2Z"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "from sklearn.metrics import accuracy_score, classification_report, f1_score, recall_score, precision_score, PrecisionRecallDisplay, roc_curve, balanced_accuracy_score, ConfusionMatrixDisplay\n",
        "\n",
        "def evaluate_classifier(model: tf.keras.Model, test_set_generator, true_labels):\n",
        "  predictions = model.predict(test_set_generator)\n",
        "\n",
        "  # Threshold tuning.\n",
        "  fpr, tpr, thresholds = roc_curve(true_labels, predictions)\n",
        "  thr = thresholds[np.argmin(np.abs(fpr + tpr - 1))]\n",
        "\n",
        "  predictions_thr = np.zeros(predictions.shape)\n",
        "  predictions_thr[predictions >= thr] = 1\n",
        "\n",
        "  print(classification_report(predictions_thr, \n",
        "                              true_labels, \n",
        "                              #sample_weight = weights\n",
        "                              ))\n",
        "    \n",
        "  print(f'The average precision score is: {average_precision_score(true_labels, predictions_thr)}.')\n",
        "  print(f'The balanced accuracy score is: {balanced_accuracy_score(true_labels, predictions_thr)}.')\n",
        "  print(f'The tuned threshold is: {thr}.')\n",
        "\n",
        "  print(f'The confusion matrix is: ')\n",
        "  ConfusionMatrixDisplay.from_predictions(true_values, predictions_thr)\n",
        "\n",
        "  PrecisionRecallDisplay.from_predictions(true_labels, predictions)\n",
        "  \n",
        "evaluate_classifier(reloaded_model, test_gen, labels_test['label'].to_numpy())"
      ],
      "metadata": {
        "id": "PmyselQdZS5x",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 761
        },
        "outputId": "374f0392-a953-4ca6-9c24-c9cb76b10192"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "              precision    recall  f1-score   support\n",
            "\n",
            "         0.0       0.66      0.91      0.76      2079\n",
            "         1.0       0.66      0.27      0.38      1347\n",
            "\n",
            "    accuracy                           0.66      3426\n",
            "   macro avg       0.66      0.59      0.57      3426\n",
            "weighted avg       0.66      0.66      0.61      3426\n",
            "\n",
            "The balanced accuracy score is: 0.6576143687029137.\n",
            "The tuned threshold is: 0.2977856397628784.\n",
            "The confusion matrix is: \n"
          ]
        },
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 432x288 with 2 Axes>"
            ]
          },
          "metadata": {
            "needs_background": "light"
          }
        },
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ]
          },
          "metadata": {
            "needs_background": "light"
          }
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "nK-dTPyNcarV"
      },
      "source": [
        "### 5.3 **Neural architecture #2**\n",
        "The extraction of contextualized vector representation is already embedded in the generator.\n",
        "Such outputs are reshaped and encoded with a fully connected layer and then the cosine similarity of the encoded vectors is computed.\n",
        "\n",
        "<div>\n",
        "<center>\n",
        "<img src = \"https://i.ibb.co/3hpvmNw/acrch-Tiny.jpg\" width = \"800\"/>\n",
        "<center>\n",
        "</div>\n",
        "\n",
        "The extraction of contextualized vector representation is already embedded in the generator."
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Load the pre-trained BERT model.\n",
        "bert_preprocess_model = hub.KerasLayer(\"https://tfhub.dev/tensorflow/bert_en_uncased_preprocess/3\")\n",
        "bert_model = hub.KerasLayer(\"https://tfhub.dev/tensorflow/bert_en_uncased_L-24_H-1024_A-16/4\", trainable = False)\n",
        "\n",
        "# Hidden states of BERT.\n",
        "layers = 1024"
      ],
      "metadata": {
        "id": "8Dg3F-lbgwBL"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "zBNEuRyfcie9"
      },
      "outputs": [],
      "source": [
        "from tensorflow.keras.layers import Dense, Reshape, Input, concatenate, add, average, Dropout, dot, Lambda, LSTM, Bidirectional, TimeDistributed\n",
        "from tensorflow.keras.models import Model\n",
        "from tensorflow.keras.callbacks import EarlyStopping, ModelCheckpoint\n",
        "from tensorflow.keras.initializers import Constant, glorot_normal\n",
        "from tensorflow.keras.optimizers import RMSprop, Adamax, SGD, Adam\n",
        "from tensorflow.keras.optimizers.schedules import ExponentialDecay, CosineDecayRestarts\n",
        "from tensorflow.keras import regularizers\n",
        "from tensorflow.keras.metrics import Precision, Recall\n",
        "from tensorflow.keras.losses import BinaryCrossentropy, CosineSimilarity\n",
        "\n",
        "# Note: the learning rate is not parametrized since we use a scheduler.\n",
        "def classifier(no_transformers: int,\n",
        "               dropout: float = 0.5, recurrent_dropout: float = 0.25, \n",
        "               initial_learning_rate: float = 0.0001) -> Model:\n",
        "\n",
        "  hidden_states = 32\n",
        "\n",
        "  # Inputs.\n",
        "  argument_input = Input(shape = (no_transformers, layers), \n",
        "                         name = 'argument_input')\n",
        "  \n",
        "  keypoint_input = Input(shape = (no_transformers, layers), \n",
        "                         name = 'keypoint_input')\n",
        "  \n",
        "  reshaper = Reshape((-1, ))\n",
        "\n",
        "  argument = reshaper(argument_input)\n",
        "  keypoint = reshaper(keypoint_input)\n",
        "\n",
        "  encoder = Dense(units = hidden_states, activation = 'gelu',\n",
        "                  kernel_regularizer = regularizers.l1_l2(l1 = 1e-5, l2 = 1e-4),\n",
        "                  bias_regularizer = regularizers.l2(1e-4),\n",
        "                  activity_regularizer = regularizers.l2(1e-5), \n",
        "                  name = 'encoder')\n",
        "  \n",
        "  dropout = Dropout(rate = dropout, name = 'dropout')\n",
        "\n",
        "  argument_enc = encoder(argument)\n",
        "  argument_enc = dropout(argument_enc)\n",
        "\n",
        "  keypoint_enc = encoder(keypoint)\n",
        "  keypoint_enc = dropout(keypoint_enc)\n",
        "\n",
        "  # Cosine similarity.\n",
        "  cos_sim = dot(inputs = [argument_enc, keypoint_enc], axes = -1, normalize = True)\n",
        "  # Rescale in range [0,1].\n",
        "  output = Lambda(lambda x: (x + 1) / 2)(cos_sim)\n",
        "\n",
        "  end_to_end = Model(inputs = (argument_input, keypoint_input), outputs = output)\n",
        "\n",
        "  # Compile the model.\n",
        "  scheduler_exp = ExponentialDecay(initial_learning_rate,\n",
        "                                   decay_steps = 100000,\n",
        "                                   decay_rate = 0.96,\n",
        "                                   staircase = True)\n",
        "  \n",
        "  scheduler_cos = CosineDecayRestarts(initial_learning_rate,\n",
        "                                      first_decay_steps = 1000)\n",
        "\n",
        "  end_to_end.compile(loss = focal_loss.BinaryFocalLoss(gamma = 2),\n",
        "                     optimizer = Adamax(learning_rate = scheduler_cos),\n",
        "                     metrics = ['binary_accuracy', precision_m, recall_m, f1_m]) \n",
        "  \n",
        "  # Check if the structure is correct.\n",
        "  end_to_end.summary()\n",
        "\n",
        "  return end_to_end"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "matcher_two = classifier(no_transformers = 24, initial_learning_rate = 0.00005)\n",
        "\n",
        "from tensorflow.keras.utils import plot_model\n",
        "plot_model(matcher_two, show_shapes = True)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 1000
        },
        "id": "tGYSuf3Jk9qx",
        "outputId": "1e37f659-8e46-43d3-de3c-f5e7481f7896"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Model: \"model_1\"\n",
            "__________________________________________________________________________________________________\n",
            " Layer (type)                   Output Shape         Param #     Connected to                     \n",
            "==================================================================================================\n",
            " argument_input (InputLayer)    [(None, 24, 1024)]   0           []                               \n",
            "                                                                                                  \n",
            " keypoint_input (InputLayer)    [(None, 24, 1024)]   0           []                               \n",
            "                                                                                                  \n",
            " reshape (Reshape)              (None, 24576)        0           ['argument_input[0][0]',         \n",
            "                                                                  'keypoint_input[0][0]']         \n",
            "                                                                                                  \n",
            " encoder (Dense)                (None, 32)           786464      ['reshape[0][0]',                \n",
            "                                                                  'reshape[1][0]']                \n",
            "                                                                                                  \n",
            " dropout (Dropout)              (None, 32)           0           ['encoder[0][0]',                \n",
            "                                                                  'encoder[1][0]']                \n",
            "                                                                                                  \n",
            " dot_1 (Dot)                    (None, 1)            0           ['dropout[0][0]',                \n",
            "                                                                  'dropout[1][0]']                \n",
            "                                                                                                  \n",
            " lambda_1 (Lambda)              (None, 1)            0           ['dot_1[0][0]']                  \n",
            "                                                                                                  \n",
            "==================================================================================================\n",
            "Total params: 786,464\n",
            "Trainable params: 786,464\n",
            "Non-trainable params: 0\n",
            "__________________________________________________________________________________________________\n"
          ]
        },
        {
          "output_type": "execute_result",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<IPython.core.display.Image object>"
            ]
          },
          "metadata": {},
          "execution_count": 25
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "JfWoEPiUly8-"
      },
      "source": [
        "#### 5.3.1 **Data generator with vector representation**\n",
        "To avoid high memory usage a data generator is implemented.\n",
        "\n",
        "The generator is initialized with:\n",
        "* A *shuffle* parameter to add more robustness to the batches of data;\n",
        "* A *batch_size* parameter to decide the size of the aforementioned batches;\n",
        "* The dataset parameters;\n",
        "* The *embedder* parameter to pass the chosen transformer.\n",
        "\n",
        "The data is handled in order to parse and align the pairs in the labels dataframes. Then, topics, arguments and keypoints are encoded through BERT.\n",
        "\n",
        "Zero-Shot learning is a type of machine learning technique, where the model is used without fine-tuning on a particular task.\n",
        "\n",
        "A single datapoint is output in the form of: `([argument, keypoint], label)`."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "uFHNW8t5iuSF"
      },
      "outputs": [],
      "source": [
        "from tensorflow.keras.utils import Sequence\n",
        "\n",
        "def flatten(t: list) -> list:\n",
        "  # Flatten a nested list.\n",
        "  return [item for sublist in t for item in sublist]\n",
        "\n",
        "class DataGeneratorReduced(Sequence):\n",
        "  def __init__(self, shuffle: bool, batch_size: int, \n",
        "               arguments_df: pd.DataFrame, key_points_df: pd.DataFrame, labels_df: pd.DataFrame, \n",
        "               preprocessor, pretrained_model):\n",
        "    \n",
        "    self.shuffle = shuffle\n",
        "    self.batch_size = batch_size\n",
        "    self.preprocessor = preprocessor\n",
        "    self.pretrained_model = pretrained_model\n",
        "\n",
        "    self.arguments_df = arguments_df.copy()\n",
        "    self.key_points_df = key_points_df.copy()\n",
        "    self.labels_df = labels_df.copy()      \n",
        "    \n",
        "    # Labels.\n",
        "    self.labels = labels_df['label'].values\n",
        "\n",
        "    # Stance.\n",
        "    self.stance = arguments_df['stance'].tolist()\n",
        "\n",
        "    self.length = len(labels_df)\n",
        "    self.indexes = np.arange(self.length)\n",
        "    self.on_epoch_end()\n",
        "\n",
        "    self.n = 0\n",
        "\n",
        "  def on_epoch_end(self):\n",
        "    # Shuffle the indexes to have more robust batches.\n",
        "    if self.shuffle:\n",
        "      np.random.shuffle(self.indexes)\n",
        "\n",
        "  def __len__(self):\n",
        "    # Length of the batch.\n",
        "    return int(np.ceil(self.length / self.batch_size))\n",
        "\n",
        "  def __getitem__(self, idx):\n",
        "    '''Generate one batch of data.'''\n",
        "    # Select the indexes of the batch.\n",
        "    indexes = self.indexes[idx * self.batch_size : (idx + 1) * self.batch_size]\n",
        "\n",
        "    # For each row in the labels dataframe we have the pair argument and keypoint. These two lines retrieve the pairs in the batch\n",
        "    arg_id = [self.labels_df['arg_id'][k] for k in indexes]\n",
        "    kp_id = [self.labels_df['key_point_id'][k] for k in indexes]\n",
        "\n",
        "    ''' Warning: it produces nested list! '''\n",
        "\n",
        "    # Take the arguments from the arguments dataframe that match the given argument, already paired before.\n",
        "    arguments = flatten([self.arguments_df.loc[self.arguments_df['arg_id'] == arg]['argument'].tolist() for arg in arg_id])\n",
        "    # Preprocces add [CLS] as 0 and [SEP] as 2 and pads with 1s.\n",
        "    preprocessed_argument = self.preprocessor(arguments)\n",
        "    # Encode the arguments and picks the last four states of the [CLS].\n",
        "    encoded_argument = np.array(self.pretrained_model(preprocessed_argument)['encoder_outputs'])[:,:,0,:]\n",
        "    # Swap axes to have the batch size at the beginning.\n",
        "    encoded_argument = np.swapaxes(encoded_argument, 0, 1)\n",
        "    \n",
        "    # Take the keypoint from the keypoints dataframe that match the given argument, already paired before.\n",
        "    keypoints = flatten([self.key_points_df.loc[self.key_points_df['key_point_id'] == kp]['key_point'].tolist() for kp in kp_id])\n",
        "    # Preprocces add [CLS] as 0 and [SEP] as 2 and pads with 1s.\n",
        "    preprocessed_keypoint = self.preprocessor(keypoints)\n",
        "    # Encode the keypoints and picks the last four states of the [CLS].\n",
        "    encoded_keypoint = np.array(self.pretrained_model(preprocessed_keypoint)['encoder_outputs'])[:,:,0,:]\n",
        "    # Swap axes to have the batch size at the beginning.\n",
        "    encoded_keypoint = np.swapaxes(encoded_keypoint, 0, 1)\n",
        "\n",
        "    labels = np.array([self.labels[k] for k in indexes])\n",
        "\n",
        "    features = [encoded_argument, encoded_keypoint]\n",
        "\n",
        "    return features, labels\n",
        "    \n",
        "  def __next__(self):\n",
        "    if self.n >= self.__len__():\n",
        "        self.n = 0\n",
        "    \n",
        "    result = self.__getitem__(self.n)\n",
        "    self.n += 1\n",
        "\n",
        "    return result\n",
        "  "
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Batch size.\n",
        "batch_size = 64\n",
        "\n",
        "# Instantiate generators.\n",
        "train_gen = DataGeneratorReduced(shuffle = True, batch_size = batch_size,\n",
        "                                 arguments_df = arguments_train, key_points_df = key_points_train, labels_df = labels_train, \n",
        "                                 preprocessor = bert_preprocess_model, pretrained_model = bert_model)\n",
        "\n",
        "dev_gen = DataGeneratorReduced(shuffle = True, batch_size = batch_size,\n",
        "                               arguments_df = arguments_dev, key_points_df = key_points_dev, labels_df = labels_dev, \n",
        "                               preprocessor = bert_preprocess_model, pretrained_model = bert_model)\n",
        "\n",
        "# No need to shuffle test data.\n",
        "test_gen = DataGeneratorReduced(shuffle = False, batch_size = batch_size,\n",
        "                                arguments_df = arguments_test, key_points_df = key_points_test, labels_df = labels_test, \n",
        "                                preprocessor = bert_preprocess_model, pretrained_model = bert_model)"
      ],
      "metadata": {
        "id": "atCE_u6OhU-D"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "#### 5.3.2 **Training**"
      ],
      "metadata": {
        "id": "34bz-GGzmJ19"
      }
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "OGdDQueFmNmv"
      },
      "outputs": [],
      "source": [
        "checkpoint = [EarlyStopping(monitor = 'val_loss', patience = 10, verbose = 1, mode = 'auto'),\n",
        "              ModelCheckpoint(filepath = \"/content/drive/MyDrive/[NLP]/project/models/adamax_cd_hu32_bs64_small.h5\",\n",
        "                              monitor = 'val_loss', verbose = 1, save_best_only = True)]"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "039e1Gq7mS4P"
      },
      "outputs": [],
      "source": [
        "# Train the model.\n",
        "from tensorflow.keras.models import load_model\n",
        "\n",
        "reloaded_model_two = load_model(filepath = '/content/drive/MyDrive/[NLP]/project/models/adamax_cd_hu32_bs64_small.h5',\n",
        "                            custom_objects = {'precision_m': precision_m, 'recall_m': recall_m, 'f1_m': f1_m})\n",
        " \n",
        "reloaded_model_two.summary()\n",
        "\n",
        "reloaded_model_two.fit(x = train_gen,\n",
        "                       validation_data = dev_gen,\n",
        "                       epochs = 100, callbacks = checkpoint)  "
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "#### 5.3.3 **Classifier evaluation**"
      ],
      "metadata": {
        "id": "ldvgf1y0nkkD"
      }
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "84483f13-3ba6-4380-dcb2-68e55b194eda",
        "id": "Gt0WLoYHnpjk"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Model: \"model_1\"\n",
            "__________________________________________________________________________________________________\n",
            " Layer (type)                   Output Shape         Param #     Connected to                     \n",
            "==================================================================================================\n",
            " argument_input (InputLayer)    [(None, 24, 1024)]   0           []                               \n",
            "                                                                                                  \n",
            " keypoint_input (InputLayer)    [(None, 24, 1024)]   0           []                               \n",
            "                                                                                                  \n",
            " reshape (Reshape)              (None, 24576)        0           ['argument_input[0][0]',         \n",
            "                                                                  'keypoint_input[0][0]']         \n",
            "                                                                                                  \n",
            " encoder (Dense)                (None, 32)           786464      ['reshape[0][0]',                \n",
            "                                                                  'reshape[1][0]']                \n",
            "                                                                                                  \n",
            " dropout (Dropout)              (None, 32)           0           ['encoder[0][0]',                \n",
            "                                                                  'encoder[1][0]']                \n",
            "                                                                                                  \n",
            " dot_1 (Dot)                    (None, 1)            0           ['dropout[0][0]',                \n",
            "                                                                  'dropout[1][0]']                \n",
            "                                                                                                  \n",
            " lambda_1 (Lambda)              (None, 1)            0           ['dot_1[0][0]']                  \n",
            "                                                                                                  \n",
            "==================================================================================================\n",
            "Total params: 786,464\n",
            "Trainable params: 786,464\n",
            "Non-trainable params: 0\n",
            "__________________________________________________________________________________________________\n"
          ]
        }
      ],
      "source": [
        "from tensorflow.keras.models import load_model\n",
        "\n",
        "reloaded_model_two = load_model(filepath = '/content/drive/MyDrive/[NLP]/project/models/adamax_cd_hu32_bs64_small.h5',\n",
        "                            custom_objects = {'precision_m': precision_m, 'recall_m': recall_m, 'f1_m': f1_m})\n",
        " \n",
        "reloaded_model_two.summary()"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "from sklearn.metrics import accuracy_score, classification_report, f1_score, recall_score, precision_score, PrecisionRecallDisplay, roc_curve, balanced_accuracy_score, ConfusionMatrixDisplay\n",
        "\n",
        "def evaluate_classifier(model: tf.keras.Model, test_set_generator, true_labels):\n",
        "  predictions = model.predict(test_set_generator)\n",
        "\n",
        "  # Threshold tuning.\n",
        "  fpr, tpr, thresholds = roc_curve(true_labels, predictions)\n",
        "  thr = thresholds[np.argmin(np.abs(fpr + tpr - 1))]\n",
        "\n",
        "  predictions_thr = np.zeros(predictions.shape)\n",
        "  predictions_thr[predictions >= thr] = 1\n",
        "\n",
        "  print(classification_report(predictions_thr, \n",
        "                              true_labels, \n",
        "                              #sample_weight = weights\n",
        "                              ))\n",
        "    \n",
        "  print(f'The average precision score is: {average_precision_score(true_labels, predictions_thr)}.')\n",
        "  print(f'The balanced accuracy score is: {balanced_accuracy_score(true_labels, predictions_thr)}.')\n",
        "  print(f'The tuned threshold is: {thr}.')\n",
        "\n",
        "\n",
        "  print(f'The confusion matrix is: ')\n",
        "  ConfusionMatrixDisplay.from_predictions(true_values, predictions_thr)\n",
        "\n",
        "  PrecisionRecallDisplay.from_predictions(true_labels, predictions)\n",
        "  \n",
        "evaluate_classifier(reloaded_model_two, test_gen, labels_test['label'].to_numpy())"
      ],
      "metadata": {
        "id": "JioDZrYD0oel",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 761
        },
        "outputId": "03c2d233-c370-4bc8-9036-97387844ea57"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "              precision    recall  f1-score   support\n",
            "\n",
            "         0.0       0.66      0.91      0.77      2093\n",
            "         1.0       0.66      0.27      0.39      1333\n",
            "\n",
            "    accuracy                           0.66      3426\n",
            "   macro avg       0.66      0.59      0.58      3426\n",
            "weighted avg       0.66      0.66      0.62      3426\n",
            "\n",
            "The balanced accuracy score is: 0.6632893104595927.\n",
            "The tuned threshold is: 0.3550012707710266.\n",
            "The confusion matrix is: \n"
          ]
        },
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 432x288 with 2 Axes>"
            ]
          },
          "metadata": {
            "needs_background": "light"
          }
        },
        {
          "output_type": "display_data",
          "data": {
            "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYIAAAEGCAYAAABo25JHAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjIsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+WH4yJAAAgAElEQVR4nO3dd3gVVfrA8e+bSgep0kNHQAwQEFAUsICAWBewoFhAXLvbdF2xrWtBd1ddfyK6rGVdFNEFRARZpKmgBAwdKSF0lRpCSX9/f8wkhLQ7Ibn3Jrnv53ny5M6cc2feCSHvnXPOnCOqijHGmNAVFuwAjDHGBJclAmOMCXGWCIwxJsRZIjDGmBBnicAYY0JcRLADKKn69etrTExMsMMwxpgKZeXKlQdUtUFhZRUuEcTExBAfHx/sMIwxpkIRkR1FlVnTkDHGhDhLBMYYE+IsERhjTIizRGCMMSHOEoExxoQ4vyUCEZkiIr+IyLoiykVEXhWRrSKyRkS6+ysWY4wxRfPnHcE7wOBiyq8A2rlf44A3/BiLMcaYIvjtOQJVXSIiMcVUuQp4T515sJeLSB0Raayq+/wRz4qkQyzdvB+A6tERjLkghuiIcH+cyhhjKpRgPlDWFNiVZ3u3u69AIhCRcTh3DbRo0eKMTrZqx2FeW7iVnOUXurU4i16t6p7RsYwxpjKpEJ3FqjpZVeNUNa5Bg0KfkPbprovbsP25oUwd2xuArGxbkMcYYyC4iWAP0DzPdjN3nzHGmAAKZiKYBdzijh7qDST7q3/AGGNM0fzWRyAiU4H+QH0R2Q08AUQCqOokYA4wBNgKnABu81csxhhjiubPUUM3+ChX4B5/nd8YY4w3FaKz2BhjjP9YIjDGmBBnicAYY0KcJQJjjAlxlgiMMSbEWSIwxpgQZ4nAGGNCnCUCY4wJcZYIjDEmxFkiMMaYEGeJwBhjQpwlAmOMCXGWCIwxJsRZIjDGmBBnicAYY0KcJQJjjAlxlgiMMSbEWSIwxpgQZ4nAGGNCnCUCY4wJcZYIjDEmxFkiMMaYEGeJwBhjQpwlAmOMCXGWCIwxJsRZIjDGmBBnicAYY0JcyCaCG95azpafU4IdhjHGBF2El0oi0hC4AGgCnATWAfGqmu3H2Pxuw76jtGtUM9hhGGNMUBWbCERkAPAIUBf4AfgFqAJcDbQRkenAy6p61N+BGmOM8Q9fdwRDgLGqujN/gYhEAMOAy4BP/BCbMcaYACg2Eajq74opywRmlHlExhhjAuqMO4tF5LayDCRQFA12CMYYU66UZtTQU2UWRQBt2GvdGcYYk5evzuI1RRUBjco+HP9LSc0MdgjGGFOu+OosbgQMAg7n2y/At36JyBhjTED5SgSzgRqqmpC/QEQW+SUiY4wxAeVr1NAdxZTdWPbhGGOMCTS/TjEhIoNF5EcR2SoijxRS3kJEForIDyKyRkSG+DMeY4wxBfktEYhIOPA6cAXQCbhBRDrlq/YnYJqqdgNGAf/nr3iMMcYUzp93BL2AraqaqKrpwIfAVfnqKFDLfV0b2OvHeAqY8cMeUlIzAnlKY4wpd/yZCJoCu/Js73b35fUkcLOI7AbmAPcVdiARGSci8SISv3///lIF1bVZ7dzXC3/czycrd5fqeMYYU9F5TgQiMrm47TN0A/COqjbDmdfofREpEJOqTlbVOFWNa9CgQalOeMk5jZh934W52+lZFXoCVWOMKbWS3BG86WM7vz1A8zzbzdx9ed0BTANQ1WU4M5vWL0FMZ6RaVLi/T2GMMRWG50SgqiuL2y7ECqCdiLQSkSiczuBZ+ersBC4BEJFzcBJB6dp+jDHGlIivKSY+g6JnaVPV4cWUZYrIvcA8IByYoqrrReRpnEVtZgG/Ad4SkYfc84xRVZsVzhhjAsjXk8UvlebgqjoHpxM4774JeV5vwFn5LKAOHk8P9CmNMabc8vVk8eKc1yJSFWihqj/6PSo/O3rShowaY0wOT30EInIlkADMdbdjRSR/e78xxpgKyGtn8ZM4D4gdAXAnoWvlp5iMMcYEkNdEkKGqyfn2WaeuMcZUAr46i3OsF5EbgXARaQfcj61HYIwxlYLXO4L7gM5AGjAVOAo86K+gAun5Lzbx1GfrWZF0KNihGGNMUHi6I1DVE8BjIvKCs6kp/g3Lv85rXif3dbbCv75JYtO+FKaO6x3EqIwxJji8jhrqKSJrgTXAWhFZLSI9/Bua/9SvEc33j11y2j6bc8gYE6q89hH8E/i1qi4FEJELgX8BXf0VmDHGmMDw2keQlZMEAFT1ayDTPyEZY4wJJF9zDXV3Xy4WkTdxOooVGAks8m9ogVW3elSwQzDGmKDw1TT0cr7tJ/K8rtDPEVSNPH0qaglSHMYYE2y+5hoaEKhAAq1mlUguaFuPb7YeBODLDT+z58hJmtapGuTIjDEmsLx2FiMiQ3GeJaiSs09Vn/ZHUIHSo2Xd3EQAsD8lzRKBMSbkeB0+OgmnX+A+nFaUXwEt/RhXQLy/LCnYIRhjTNB5HTXUV1VvAQ6r6lNAH6C9/8IKjCM2HbUxxnhOBCfd7ydEpAmQATT2T0jGGGMCyWsimC0idYCJwCogCWcoaaVwbfemALy1JDHIkRhjTOB5nWvoGfflJyIyG6hSyLTUFVa1KGco6edr9/F6kGMxxphA8/VA2bXFlKGqn5Z9SIETHRFGaobNMWSMCW2+7giuLKZMgQqdCKaP78u/l+8gTOxxMmNM6PL1QNltgQokGLo0rc3z13XlpXk/BjsUY4wJGq+dxZXaA5e2AyCu5VlBjsQYYwLPEgEQGR5G3zb1sBYiY0woskRgjDEhztPwURGpBvwGaKGqY90F7Duo6my/Rhdg6ZnZXPTiQnYeOgFAnWqRLPxNf86yKaqNMZWY1zuCf+EsXN/H3d4D/NkvEQVRSlpmbhIAOHIig19S0oIYkTHG+J/XRNBGVV/EmVoiZzF7a1E3xphKwGsiSBeRqriL0YhIG5w7hEolcf/xYIdgjDEB53U9gieBuUBzEfkAuAAY46eYjDHGBJDXuYa+FJGVQG+cJqEHVPWAXyMzxhgTEF4XpvkMuBxYpKqzK2MSSMssfM6hbfuPBTgSY4wJLK99BC8B/YANIjJdRK4XkSq+3lSR5PzB73h2TX54/DKu7eZMTf3ghwnBDMsYY/zOa9PQYmCxiIQDA4GxwBSglh9jC4qHLmvPWdWjSM9y7hByvhtjTGVVksXrq+LMRjoS6A6866+ggiEjX9NQVIQ9dG2MCQ1e+wimARtx7gb+gfNcwX3+DCzQjqdnAacSwIRhnQC4sG39oMVkjDGB4PWO4J/ADaqa5c9gyoML2jh/+OtUi6J7izq5E9FtP3AcVaV1gxpBjM4YY8qerxXKBqrqV0B14CrJNz1nRV+hrDCFNQllZSsDXloEwJZnryAy3JqNjDGVh687gouBryh8pTKfK5SJyGDgFSAceFtVny+kzgicB9YUWK2qN/oOOzAyspSlWw4wM2FP7r6sbCUyPIhBGWNMGfO1QtkT7sunVXV73jIRaVXce90RRq8DlwG7gRUiMktVN+Sp0w54FLhAVQ+LSMMzuAa/Wb83GYCHp60OciTGGOM/XvsIPsEZKZTXdKBHMe/pBWxV1UQAEfkQuArYkKfOWOB1VT0MoKq/eIynzK147FLUmUopV7YWUdkYYyoRX30EHYHOQG0RuTZPUS3A1wNlTYFdebZ3A+fnq9PePc83OM1HT6rqXA9xl7kGNaODcVpjjAk6X3cEHYBhQB1O7ydIwfk0Xxbnbwf0B5oBS0TkXFU9kreSiIwDxgG0aNGiDE5bclHhYfZwmTGmUvLVRzATmCkifVR1WQmPvQdonme7mbsvr93Ad6qaAWwXkc04iWFFvjgmA5MB4uLigtJgU6tqJAeOpbHz0AnaN6oZjBCMMcYvih0HKSK/d1/eKCKv5v/ycewVQDsRaSUiUcAoYFa+OjNw7gYQkfo4TUWJJb0If7nyvCa5r4+nZQIwafG2YIVjjDF+4atpaKP7Pb6kB1bVTBG5F5iH0/4/RVXXi8jTQLyqznLLLheRDUAW8DtVPVjSc/nLazd047PVewHn+YKTGVmkFzFLqTHGVFS+moY+c7/nziskImFADVU96uvgqjoHmJNv34Q8rxV42P0qlx68tB1bfj5Gg5rRvPNtEhnWT2CMqWQ8DR8Vkf8A43E+ta8AaonIK6o60Z/BlQcPXto+9/U73yYxb/3PHDqeTt3qUUGMyhhjyo7XuRI6uXcAVwNfAK2A0X6Lqpyb+v1OfvwpJdhhGGNMmfCaCCJFJBInEcxyR/mE7ONWE+f9yJh/fV+i96RlZvFd4kFOpGf6KSpjjDkzXhPBm0ASzuRzS0SkJeCzj6CyuePCU7Nq7EtOLdF7n/5sAyMnL+eV/20p67CMMaZUvK5Q9iqQd7joDhEZ4J+Qyq/OTU4tyNaktveVOo+mZvDBdzsBOJZmdwTGmPLF68I0tUXkryIS7369jHN3EFI27jt1E1SSKSke/ujUpHURYVJMTWOMCTyvTUNTcKaVGOF+HQX+5a+gyqtNeTqIV+9OZs+Rkz7fsy/5JP/b+DMA1aPC2fzzMVIzKv36PsaYCsRrImijqk+oaqL79RTQ2p+BlUfREacvRLBqx+Fi6+9LPskFz38FwO8Hd+B4ehbLEg/y8LQE3vlmOws3/cLWX1K4450VzN/wM8/N2Uj3Z+YTn3TIb9dgjDH5eZ2G+qSIXKiqXwOIyAWA74/DlcyL13flj5+uZe76n07b/9cvf+TVr7byzm096d/BWVJBVenz3Fe5de68sDUvzv0RgDlrf2LO2tOPsWDTqRm4N/98jLiYuv66DGOMOY3XO4LxwOsikiQiSTgL2N/lt6jKqbrVo5g0ugcPuQ+Z3Tf1By6euJBXv9oKwJh/OXPlZWcrby89tY7PoM6NCl0CsyhpmdZ0ZIwJHJ9/nUQkFmdG0FFAV6CrqnZT1TX+Dq68GtSlUe7rHQdPFCifvmo3z85xpmkKDxNevaEbAJ/ff6Gn4z/12Qb+8dUWfvvx6ty5jU6kZ5KSmpFb5+GPEuj+zHyWJ5abqZmMMRWUr4VpJgA3AyuBF4HnVPWtQARWniUdKPjHP0dKaga/n34qR2599gpEnJFCnZvUZtFv+9P/pUXMfbAfg/++lLrVo2jToDp9WtfjhvNb5DYnvfTlZgCmr9zNw5e156/zne2be7egRnQkn/7gzOi9ad9Rereu55frNMaEBl99BCOBWFU9ISL1gLlAyCeC/ENAI8KETHddy3Of/DJ3/zNXd8lNAjli6lcn6fmhAMy5vx9tG9bw2WyUkwQA/r18Z6liN8aY/Hw1DaWp6gkAd3po7w3dldgl5zQ8bfv3gzsUqDPzngsY3btlscfp1KRWgSSw9dkr+Ghcb/428rxi3zv+4jYeozXGmOL5uiNoLSI5i8kI0CbPNqo63G+RlWMiQtLzQ4l55HMAxvZrTUpqJq+5ncbhYcJ5zeuc0bEjwsM4323q6dCoFgm7jvCXORv55g8D2fJLCtdPWsamZwZzMj3LFskxxpQJX4ngqnzbL/krkIpo8ugevDB3EyLCby7vkJsI/jqi+E/zXnVqUotOTWpx4/nOOs1xMXVzm5VOptvIImNM2fC1MM3iQAVSEV3e+Wwu73x2gf1Xdm1SSG1jjCmffI0a+gxn0fi57tTTectaA2OAJFWd4rcIK5A3R/dgy88phAVpPqHkExlUjQov0TMLxhjjq2loLM4ykn8XkUPAfqAKEANsA/6hqjP9GmEFMqjz2Qwq5A4hED5asZM/fLIWgN8N6sA9A9oGJQ5jTMUjzrLBHiqKxACNcaaW2JwzmijQ4uLiND4+PhinLlcOH0+n2zPziyz/+8hYru7WNIARGWPKMxFZqapxhZV5bkNQ1SRVXaaqCcFKAuaU44WsdBabZ6TSzkP2T2SM8cbrpHOmnMlZD6FaVDgn0rNY+adLqVcjmqxspc0f5/D20kSuim1Cy3oht2yEMaaELBFUUNER4blDSfPKaeo7mprJxRMXsXrC5dSuFhno8IwxFYgNL6lk8k9pMfZ9608xxhTP61KVF4jIfBHZLCKJIrJdRBL9HZwpufAwYcPTg3jhunMB+H77IY6mZvh4lzEmlHm9I/gn8FfgQqAnEOd+N+VQtagIRvZskbu9Ye/RYmobY0Kd10SQrKpfqOovqnow58uvkZlSu/+SdsEOwRhTAXhNBAtFZKKI9BGR7jlffo3MlFrv1rbcpTHGN6+jhs53v+d9GEGBgWUbjgkEVWXW6r20qFuNbi3OCnY4xpgg85QIVHWAvwMx/nPkRHru6zW7jzD8H98AIAILHr6YVxdsIS6mLv07NOCx/67jxvNbBG2qDGNM4HlKBCJSG3gCuMjdtRh4WlWT/RWYKb2c9ZTH/3tVoeWqMPBlZ4LZGQl7c/cv3ryfj8b1zl0XwRhTuXntI5gCpAAj3K+jwL/8FZQpGzGleKp45OTlZGRlA5C4/xifrNzNt9sOlFVoxphyxNOkcyKSoKqxvvYFgk06V3LfbD3ATW9/B8D6pwZRPToCVaXVo3OYdHMPBnVuxCsLttDx7Jo0rVONK//xdZHHenN0D2s2MqYCKm7SOa+dxSdF5EJV/do94AU4s5CaCuCCtvX58qGLaFmvGtER4cCp5TZzPHhp+9zXd13UmjeXFP68YHzSIUsExlQyXhPB3cC7bl+BAIdwFqUxFUT7RjU91310yDm5iWDKmDgGdmwEQMwjn7P552N+ic8YEzxeRw0lAOeJSC132x5VreQKm9AOnI7k5JMZVI0M5+Uvf6Rdo5pc36NZgKMzxpQlX0tV3qyq/xaRh/PtB0BV/+rH2Ew5dd5TX562bYnAmIrN16ihnGEnNYv4MiGksCeVg7Q8szGmDHleqvKMDi4yGHgFCAfeVtXni6h3HTAd6KmqxQ4JslFDwbPr0An6vbiQj8f3oWdMXc576kuSTzozm9apFsmqP11GmGUGY8qlUi9VKSIvikgtEYkUkQUisl9EbvbxnnDgdeAKoBNwg4h0KqReTeAB4DsvsZjgaV63GknPD6VnjHNnMOTcU6OHjpzI4NZ/fc+0Fbs4fDy9qEMYY8ohrw+UXe52EA8DkoC2wO98vKcXsFVVE1U1HfgQuKqQes8ALwCpHmMx5cRz13Yl6fmhtG7gtCAu3XKA33+yhm7PzCc+6VCQozPGeOU1EeR0Kg8FPvY4tURTYFee7d3uvlzuDKbNVfVzj3GYcuitWwrebV4/aRmPfrqW9XuTOXgsjb1HTuLPZkhjzJnz+hzBbBHZhPMQ2d0i0oBSfoIXkTCcxW7GeKg7DhgH0KJFCx+1TaC1aVAjd7hpdrbS+o9zAJj6/U6mfr/ztLpDzj2b/7upR8BjNMYUzdMdgao+AvQF4lQ1AzhO4c08ee0BmufZbubuy1ET6AIsEpEkoDcwS0QKfLxU1cmqGqeqcQ0aNPASsgmSsDAp8hkEgDlrf+KWKd/z7bYDHDyWFsDIjDFFKXbUkIgMVNWvROTawspV9dNi3hsBbAYuwUkAK4AbVXV9EfUXAb+1UUOVS3pmNoqy69AJxr2/ksT9x08rf/LKToy5oFWQojMmdJRm1NDF7vcrC/kaVtwbVTUTuBeYB2wEpqnqehF5WkSGlyB+U4FFRYQRHRFO24Y1+eo3/QuUP/nZBmat3kt6ZjbxSYdOWzvBGBMYfn2OwB/sjqDyiHmk4BiBiDBh61+GBCEaYyq3sniO4C8iUifP9lki8ueyCtCEpu3PFfyDn5mtHDiWRmZWNssTD5J8IiMIkRkTWryuR/CDqnbLt2+VqgZ8AXu7I6h8srMVEWj16JwCZUO7Nub1GwP+a2ZMpVPqOwIgXESi8xywKhBdTH1jPAsLE0SEbx8ZWKCsojVdGlMReX2O4ANggYjkLE95G/Cuf0IyoapJnaqnDT2NeeRz5qz9ieWJB+nduh5pmVlEhYflzn5rjCkbXtcjeEFEVgOXurueUdV5/gvLmFNGTV5+2nZkuPDDhMupEe31c4wxpjhem4bAGQI6V1V/Cyx1J4szxm+2PHtFofszspQuT8wjO9uajYwpC54+UonIWJwpHuoCbXDmDJqE87CYMX4RGR5G/J8u5afkVCLChY5n1+L9ZUk8PtN5JrHjhLls/nPhycIY453Xe+t7cGYT/Q5AVbeISEO/RWWMq36NaOrXODUuYXSfGHYfPsmbSxKJtLUPjCkTXpuG0typpIHc6SPsvtwExaNDzgHgeHoWMY98TswjnzPklaWcSM88rd6h4+l8sXYfR1PtWQRjiuP1jmCxiPwRqCoilwG/Bj7zX1jGlMyGfUfpNKHo8Qt/GNyRpAPH+Sh+V4GyqpHh3DOgDXf2a02VyHB/hmlMueT1gTIB7gQuBwRn/qC3NQiDvO2BMpOXqvLqgq387X+bS32sdg1rcGvfGL7a9AsNakRzR79WtG9kYyJM5VDcA2U+E4G75OR6Ve3oj+BKyhKBKczyxINs2HuU2y88fSbTk+lZnDNhbu72h+N607t1PQBW7jhM/RpRDHllKcfTswo97pQxcTSsWYWGtaJpWLOK/y7AGD8rVSJwDzATuE9Vd/qs7GeWCIw/DHhpEdsPOFNkR0WEkZ6ZXWz90b1b8uiQjlSLsmcZTMVQFolgCdAN+B5nURoAVDXg00lbIjCBkLj/GANfXlyi92x4etBpiSFh1xGmfL2dWav3cmHb+jx37bk0r1utrEM1xpOySAQXF7ZfVUv2P6UMWCIwwfb+8h08PmNdqY4RJrD+qcFUjbLOaRMYZ5wIRKQKMB5oC6wF/ukuOBM0lghMebFq52F2HDxO79b16PPcV4XWuX9gW2pVjeTPn28stPz6Hs0Y2rUx/ds3KDCH0q5DJwgLE5rUrpJblpmVzY5DJ2hSuyrZqmw/cJyfklPp1boutapElu0FmkqlNIngIyADWApcAexQ1Qf8EqVHlghMefXL0VRW7jjMoM5nE1bMw27fbj3AjW9/V+bnn3XvBXRtVsd3RROSSpMI1qrque7rCOD7YKxBkJclAlMZHD6ezvDXv2bXoZNlfuznrz2XUb1alPlxTcVWmkRw2uIzwVqMJi9LBKayUVWyFcLPcMqMtMwsOvxpbqFlgzo34vUbuxMRXpL5JU1lVJpEkMWpUUICVAVOuK9VVWuVcaw+WSIwpnA/Jafy+sKtvL98R6HlAzo04M3RcURFWFIIRaUeNVSeWCIwxrf9KWkkHTzOryYtK1BWPSqcLk1r8/iwTnRpWjsI0ZlgsERgTIibtXov90/9ocD+Pw09hzF9Y6zpKARYIjDGAPDagi3E7zjM4s37C5QN7dqYV0d1O+O+ClO+WSIwxhTwxqJtvDB3U5HlN/RqzhNXdrYZWSsJSwTGmGIl7DrC1a9/U2T5s9d04dpuzexJ6ArMEoExxrOsbCU+6RAjJy8vtPyWPi15anjnAk9Cm/LNEoEx5ow9PC2BT1ftKbK8WlQ4J9xpvCcM68SYvjHFPlltgsMSgTGm1DKzslm8eT93vFv8/79JN3dncJfGAYrKeGWJwBjjF5MWb6NRrWjOb1WPJ2et58sNP59W/p87z6dv2/pBis7kZYnAGON3qkqrR+cU2P+7QR0YEdecBjWjgxCVyWGJwBgTcJMWb+P5L04fnnpVbBMevLQ9repXD1JUoau4RGDr7Blj/GL8xW1oWDOaifN+ZF9yKgAzE/YyM2Evsc3rcHf/Npxzdi1EnInzGtSsQu2qtqZCMNgdgTEmIHYePMHV//cNh46nF1lHBFTh6tgmNKlTlSMnM6geFc6ADg1p26gGDWtWCWDElYs1DRljyo3sbGXCrHV8HL+btg1rsPPgCVLSMjmrWiRnVY8icf/xYt9ft3oUh46n071FHY6mZjKuX2uanlWVGtERtKxXjRrRETZ3UiEsERhjKhRVZX9KGkdTM5kWv4v3liWRmpFdomO0rFeNtIxsLu/ciHYNa3BDrxZkKyE7DbclAmNMpaOqTPkmiV9SUknYeYTdh0+y54iz4tvQro35fM2+Qt8XJrDgN/1DrsPaEoExJuSkZ2aTeOAYWdnK+H+vZH9KWpF3FfVrRNGnTX1eGRlbaZ+KtkRgjDE4T0fPXrOPBz9KoHOTWqzfe7RAnT6t6/Hna7rQpkGNIEToP5U+EWRkZLB7925SU1ODFJWpiKpUqUKzZs2IjLQhi6EuJTWDX3+wiu8SD5Ge5dw1NKwZzX2XtKN1/eo0qBlNq/rViazAndBBSwQiMhh4BQgH3lbV5/OVPwzcCWQC+4HbVbXwBVddhSWC7du3U7NmTerVq2czIhpPVJWDBw+SkpJCq1atgh2OKUde+d8W3v46kZTUzAJl3VvUYdXOIwCc27Q2F7WvT1R4OCN6NqNx7aqBDrVEgpIIRCQc2AxcBuwGVgA3qOqGPHUGAN+p6gkRuRvor6ojiztuYYlg48aNdOzY0ZKAKRFVZdOmTZxzzjnBDsWUQx9+v5MvN/zM2bWrkHTgOGv3JCPA0TwJIkwgO8+f0F6t6vLs1V1o16hm4AP2IVhPFvcCtqpqohvEh8BVQG4iUNWFeeovB24+05NZEjAlZb8zpjijerVgVK8WPutNW7GLhT/+whfrfuL77Ye47G9LuKFXC565qnOFeZ7Bn1E2BXbl2d7t7ivKHcAXhRWIyDgRiReR+P37C661aowxwTKiZ3PeuLkHSc8P5c4LnWbGqd/vpO1jX7A88WCQo/OmXKQrEbkZiAMmFlauqpNVNU5V4xo0aBDY4Dz66aefGDVqFG3atKFHjx4MGTKEzZs3k5SURJcuXcrsPBMmTOB///sfAEuXLqVz587ExsayZ88err/++lIdW1UZOHAgR4+eGkkxY8YMRIRNm05NHpaUlETVqlWJjY2lU6dOjB8/nuzskj3sk19aWhojR46kbdu2nH/++SQlJRWok5qaSq9evTjvvPPo3LkzTzzxRG7ZmDFjaNWqFbGxscTGxpKQkADA7NmzmTBhQqliM8arPw3rxNonL8/dHjV5ORNmrqPcD8pRVb98AX2AeXm2HwUeLaTepcBGoKGX4/bo0UPz27BhQ4F9gZSdna29e/fWN954I3dfQkKCLlmyRLdv366dO3f2y3nvuksMp3kAABCXSURBVOsuff/998/ovRkZGQX2zZ49Wx988MHT9o0YMUIvvPBCnTBhQu6+vNeUkZGh/fr1008++eSM4sjx+uuv61133aWqqlOnTtURI0YUqJOdna0pKSmqqpqenq69evXSZcuWqarqrbfeqh9//HGh74mNjdXjx48Xet5g/+6Yyik7O1vnrNmrLf8wW1v+YbYOf22pfpd4MKgxAfFaxN9Vf/YRrADaiUgrYA8wCrgxbwUR6Qa8CQxW1V/K4qRPfbaeDYWMDS6NTk1q8cSVnYssX7hwIZGRkYwfPz5333nnnQdw2ifbpKQkRo8ezfHjzlwq//jHP+jbty/79u1j5MiRHD16lMzMTN544w369u3LHXfcQXx8PCLC7bffzkMPPcSYMWMYNmwYR44cYdq0acybN48vvviCZ599lmHDhrFu3TqysrJ45JFHWLRoEWlpadxzzz3cddddLFq0iMcff5yzzjqLTZs2sXnz5tOu44MPPmDcuHG528eOHePrr79m4cKFXHnllTz11FMFrj0iIoK+ffuydevWM/rZ5pg5cyZPPvkkANdffz333nsvqnpaO76IUKOGM7Y7IyODjIwMn+38IkL//v2ZPXs2I0aMKFWMxnglIlxxbmOmj+/D9ZOWsXp3MiPeXMYnd/ehR8u6wQ6vAL81DalqJnAvMA/nE/80VV0vIk+LyHC32kSgBvCxiCSIyCx/xeNP69ato0ePHj7rNWzYkPnz57Nq1So++ugj7r//fgD+85//MGjQIBISEli9enVu08aePXtYt24da9eu5bbbbjvtWHfeeSfDhw9n4sSJfPDBB6eV/fOf/6R27dqsWLGCFStW8NZbb7F9+3YAVq1axSuvvFIgCQB88803p13HzJkzGTx4MO3bt6devXqsXLmywHtOnDjBggULOPfccwuU9evXL7epJu9XTtNWXnv27KF58+aAk1xq167NwYMF21ezsrKIjY2lYcOGXHbZZZx//vm5ZY899hhdu3bloYceIi0tLXd/XFwcS5cuLXAsY/wtLqYuSc8P5S/XOP8/rntjGTGPfM4lLy9i7rqfyM4uH01Gfl2PQFXnAHPy7ZuQ5/WlZX3O4j65B1tGRgb33nsvCQkJhIeH5/4x7tmzJ7fffjsZGRlcffXVxMbG0rp1axITE7nvvvsYOnQol19+uY+jn/Lll1+yZs0apk+fDkBycjJbtmwhKiqKXr16FTlu/tChQ9SseWrY29SpU3nggQcAGDVqFFOnTs1NFNu2bSM2NhYR4aqrruKKK64ocDx//PENDw8nISGBI0eOcM0117Bu3Tq6dOnCc889x9lnn016ejrjxo3jhRdeyO0baNiwIXv37i3zWIzx6oZezTmampG7UM+2/ccZ/2/ng9VZ1SK5s19r7rqoddBGGdnCNGWgc+fOuX90i/O3v/2NRo0asXr1arKzs6lSxZlb/aKLLmLJkiV8/vnnjBkzhocffphbbrmF1atXM2/ePCZNmsS0adOYMmWKp3hUlddee41Bgwadtn/RokVUr170RFsRERFkZ2cTFhbGoUOH+Oqrr1i7di0iQlZWFiLCxIlOf36bNm1yO2SL0q9fP1JSUgrsf+mll7j00tM/AzRt2pRdu3bRrFkzMjMzSU5Opl69ekUeu06dOgwYMIC5c+fSpUsXGjd2FkuPjo7mtttu46WXXsqtm5qaStWq5fthH1O5iQjjL27D+IvbALBuTzKvLNhCvepRfLhiFxPn/cjEeT9ydWwTshQeG3IOZ9cO3NoLlgjKwMCBA/njH//I5MmTc9vY16xZQ3Jycm5zBzifzJs1a0ZYWBjvvvsuWVlZAOzYsYNmzZoxduxY0tLSWLVqFUOGDCEqKorrrruODh06cPPN3h+xGDRoEG+88QYDBw4kMjKSzZs307RpcSN3HR06dCAxMZG2bdsyffp0Ro8ezZtvvplbfvHFF7N06VJatPA9thpKdkcwfPhw3n33Xfr06cP06dMZOHBggfb//fv3ExkZSZ06dTh58iTz58/nD3/4AwD79u2jcePGqCozZsw4baTW5s2by3TkljGl1aVpbd66xXm2a9xFrRn48mIAZiQ4d66frXa+3zOgDY1rV6Vbizq0rFedGtH++ZNtiaAMiAj//e9/efDBB3nhhReoUqUKMTEx/P3vfz+t3q9//Wuuu+463nvvPQYPHpz76XzRokVMnDiRyMhIatSowXvvvceePXu47bbbcodlPvfcc57jufPOO0lKSqJ79+6oKg0aNGDGjBk+3zd06FAWLVpE27ZtmTp1au4f2RzXXXddofvLwh133MHo0aNp27YtdevW5cMPPwRg79693HnnncyZM4d9+/Zx6623kpWVRXZ2NiNGjGDYsGEA3HTTTezfvx9VJTY2lkmTJuUee+HChSX6+RkTSK0b1CDp+aG527dM+Z4lm53npV5fuO20un8dcR7Xdm9W5jFUiknnNm7caNMElIF9+/Zxyy23MH/+/GCHUmZ+/vlnbrzxRhYsWFBouf3umPIqMyubIyczWLP7CCuSDnPwWBrXdGtGnzZFN5kWxxavN540btyYsWPHcvToUWrVqhXscMrEzp07efnll4MdhjElFhEeRv0a0Qzs2IiBHRv591x+PbqpcCrbWPuePXsGOwRjyr1yMcVEWahoTVwm+Ox3xhhHpUgEVapU4eDBg/Yf23im7noEOUN4jQlllaJpqFmzZuzevRubmdSURM4KZcaEukqRCCIjI22VKWOMOUOVomnIGGPMmbNEYIwxIc4SgTHGhLgK92SxiOwHdpzh2+sDB8ownIrArjk02DWHhtJcc0tVLXSJxwqXCEpDROKLesS6srJrDg12zaHBX9dsTUPGGBPiLBEYY0yIC7VEMDnYAQSBXXNosGsODX655pDqIzDGGFNQqN0RGGOMyccSgTHGhLhKmQhEZLCI/CgiW0XkkULKo0XkI7f8OxGJCXyUZcvDNT8sIhtEZI2ILBCRlsGIsyz5uuY89a4TERWRCj/U0Ms1i8gI9996vYj8J9AxljUPv9stRGShiPzg/n4PCUacZUVEpojILyKyrohyEZFX3Z/HGhHpXuqTqmql+gLCgW1AayAKWA10ylfn18Ak9/Uo4KNgxx2Aax4AVHNf3x0K1+zWqwksAZYDccGOOwD/zu2AH4Cz3O2GwY47ANc8Gbjbfd0JSAp23KW85ouA7sC6IsqHAF8AAvQGvivtOSvjHUEvYKuqJqpqOvAhcFW+OlcB77qvpwOXiIgEMMay5vOaVXWhqp5wN5cDFX3+ZS//zgDPAC8AqYEMzk+8XPNY4HVVPQygqr8EOMay5uWaFchZW7U2sDeA8ZU5VV0CHCqmylXAe+pYDtQRkcalOWdlTARNgV15tne7+wqto6qZQDJwZitClw9erjmvO3A+UVRkPq/ZvWVurqqfBzIwP/Ly79weaC8i34jIchEZHLDo/MPLNT8J3Cwiu4E5wH2BCS1oSvr/3adKsR6B8U5EbgbigIuDHYs/iUgY8FdgTJBDCbQInOah/jh3fUtE5FxVPRLUqPzrBuAdVX1ZRPoA74tIF1XNDnZgFUVlvCPYAzTPs93M3VdoHRGJwLmdPBiQ6PzDyzUjIpcCjwHDVTUtQLH5i69rrgl0ARaJSBJOW+qsCt5h7OXfeTcwS1UzVHU7sBknMVRUXq75DmAagKouA6rgTM5WWXn6/14SlTERrADaiUgrEYnC6Qyela/OLOBW9/X1wFfq9sJUUD6vWUS6AW/iJIGK3m4MPq5ZVZNVtb6qxqhqDE6/yHBVjQ9OuGXCy+/2DJy7AUSkPk5TUWIggyxjXq55J3AJgIicg5MIKvO6tbOAW9zRQ72BZFXdV5oDVrqmIVXNFJF7gXk4Iw6mqOp6EXkaiFfVWcA/cW4ft+J0yowKXsSl5/GaJwI1gI/dfvGdqjo8aEGXksdrrlQ8XvM84HIR2QBkAb9T1Qp7t+vxmn8DvCUiD+F0HI+pyB/sRGQqTjKv7/Z7PAFEAqjqJJx+kCHAVuAEcFupz1mBf17GGGPKQGVsGjLGGFMClgiMMSbEWSIwxpgQZ4nAGGNCnCUCY4wJcZYIjN+JSJaIJIjIOhH5TETqlPHxk9wx84jIsSLqVBWRxSISLiIxInLSjWmDiExyn0QuyTnjRORV93V/Eembp2y8iNxSmmtyj/OkiPzWR513ROT6EhwzpqhZLfPVe1ZEduX/eYrIvSJyu9fzmYrBEoEJhJOqGquqXXCe27gnCDHcDnyqqlnu9jZVjQW64sxYeXVJDqaq8ap6v7vZH+ibp2ySqr5X+pCD6jOcCd/ym0Lln8sn5FgiMIG2DHeCLBFpIyJzRWSliCwVkY7u/kYi8l8RWe1+9XX3z3DrrheRcSU8703AzPw73UkHvwXaup+Wv5JTaza0cM/7K/duZrWILHH39ReR2eKsZTEeeMi9w+iX80leRDqKyPc553KPv9Z93cO9Q1kpIvN8zR4pImNFZIUbwyciUi1P8aUiEi8im0VkmFs/XEQmuu9ZIyJ3leSHparLC3ta1Z3BNklECksSpoKyRGACRkTCcaYCyHnqdzJwn6r2AH4L/J+7/1VgsaqehzMv+3p3/+1u3TjgfhHxNGOsOzVBa1VNKqSsmhvTWuA14F1V7Qp84MYBMAEY5MZz2tPY7jEnAX9z73qW5inbBESJSCt310jgIxGJdM91vXs9U4BnfVzGp6ra041hI878OjlicD69DwUmiUgVtzxZVXsCPYGxeeLIufYmIjLHx3kLEw/0O4P3mXKq0k0xYcqlqiKSgHMnsBGYLyI1cJpTcqa8AIh2vw8EbgFwm3KS3f33i8g17uvmOJOpeZk+oT6Qf/bNNm5MCsxU1S9E5H3gWrf8feBF9/U3wDsiMg341MP58pqGkwCed7+PBDrgTIg33732cMDXXDFdROTPQB2cqULm5T2HO9PmFhFJBDoClwNd8/Qf1Mb5eW3OeZOq7sWZqqCkfnHPYSoJSwQmEE6qaqz76XseTh/BO8ARt53eJxHpD1wK9FHVEyKyCGdyMU/nL6TuNq/nVtXxInI+zifulSLSw+N5AT7CSXafOofSLSJyLrBeVfuU4DjvAFer6moRGYM7sVxOiPlDxlm96j5VzZswkLJZlrUKzs/UVBLWNGQCxm1fvh9nkrATwHYR+RXkrsN6nlt1Ac5ymjlt3bVxPtEedpNAR5xppb2e9zAQ7jaZFOdbTk1AeBOw1I2hjap+p6oTcGa1bJ7vfSk4014Xdu5tOJO/PY6TFAB+BBqIM3c+IhIpIp19xFYT2Oc2K92Ur+xXIhImIm1wlnT8ESfh3u3WR0Tai0h1H+fwqj3gc+SRqTgsEZiAUtUfgDU4i4ncBNwhIqtx+gFyliB8ABjgdqyuxBnVMxeIEJGNOM0sy0t46i+BC33UuQ+4TUTWAKPdOAAmishad9jltzjr5ub1GXBNTmdxIcf9CLiZU3Pmp+NMf/6Ce+0J5Bl1VITHge9wmqk25SvbCXyPs+rceFVNBd4GNgCr3LjfJF8LQHF9BCLyojgzX1YTkd0i8mSe4guA+T7iNRWIzT5qQoI4y1Y+pKqjgx1LRSbOuhYP28+xcrE7AhMSVHUVsNAduWTOXH2cuxNTidgdgTHGhDi7IzDGmBBnicAYY0KcJQJjjAlxlgiMMSbEWSIwxpgQ9/8r3FVUOAboOwAAAABJRU5ErkJggg==\n",
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ]
          },
          "metadata": {
            "needs_background": "light"
          }
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        ""
      ],
      "metadata": {
        "id": "A8107Ph65V0U"
      },
      "execution_count": null,
      "outputs": []
    }
  ],
  "metadata": {
    "accelerator": "GPU",
    "colab": {
      "collapsed_sections": [],
      "machine_shape": "hm",
      "name": "key-point_matching_costante-costanzino-stramiglio-wen.ipynb",
      "provenance": []
    },
    "kernelspec": {
      "display_name": "Python 3",
      "name": "python3"
    },
    "language_info": {
      "name": "python"
    }
  },
  "nbformat": 4,
  "nbformat_minor": 0
}