fine_tune_mDeBERTaV3.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "Ri5QvriGQvu2"
   },
   "source": [
    "**Fine tuning mdeBERTaV3 for the purpose of GED**\n",
    "\n",
    " "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "#INB: you might have to install some of the following packages to run this notebook:\n",
    "\n",
    "#!sudo pip uninstall transformers -y \n",
    "#!pip install transformers[sentencepiece]\n",
    "# !pip install --upgrade pip\n",
    "# !pip install accelerate\n",
    "# #!pip install sentencepiece\n",
    "# !pip install --no-cache-dir transformers sentencepiece"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "#IMPORT PACKAGES\n",
    "\n",
    "from transformers import AutoModel\n",
    "from transformers import AutoTokenizer\n",
    "from sklearn.model_selection import train_test_split\n",
    "import torch\n",
    "import torch.nn as nn\n",
    "import numpy as np\n",
    "import pandas as pd\n",
    "from tqdm.notebook import tqdm\n",
    "import matplotlib.pyplot as plt\n",
    "import gc\n",
    "import itertools\n",
    "from itertools import groupby\n",
    "from itertools import repeat\n",
    "from itertools import chain\n",
    "from tqdm import tqdm\n",
    "\n",
    "from collections import Counter\n",
    "\n",
    "from accelerate import Accelerator\n",
    "\n",
    "from sklearn.metrics import accuracy_score\n",
    "from sklearn.metrics import precision_score\n",
    "from sklearn.metrics import recall_score\n",
    "from sklearn.metrics import f1_score\n",
    "from sklearn.metrics import confusion_matrix\n",
    "\n",
    "from sklearn.utils import class_weight\n",
    "from sklearn.metrics import fbeta_score\n",
    "\n",
    "# ----------\n",
    "import os\n",
    "os.environ[\"TOKENIZERS_PARALLELISM\"] = \"false\"\n",
    "os.environ[\"PYTORCH_CUDA_ALLOC_CONF\"] = \"0\"\n",
    "os.environ[\"CUDA_LAUNCH_BLOCKING\"] = \"1\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "id": "2Y9NL32WSpOY"
   },
   "outputs": [],
   "source": [
    "#SET UP MODEL CONFIG\n",
    "\n",
    "config = {\n",
    "    'model': 'microsoft/mdeberta-v3-base',  \n",
    "    'dropout': 0.3,\n",
    "    'max_length': 128, #512\n",
    "    'batch_size': 2, #default 8 #4 #2 #1\n",
    "    'epochs': 7, #7 \n",
    "    'lr': 3e-04, #default: 3e-04\n",
    "    'enable_scheduler': True,\n",
    "    'scheduler': 'CosineAnnealingWarmRestarts',\n",
    "    'gradient_accumulation_steps': 2,\n",
    "    'adam_eps': 1e-6, # 1e-8 default, 1e-6 as set in the example\n",
    "    'freeze_encoder': True\n",
    "}\n",
    "#look into hyperparameters sereach"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 244,
     "referenced_widgets": [
      "68462eb13cc74f52a6b6ed5a1b13aa90",
      "2f44991d4e874f579e0f741080b3f6e8",
      "141409525736449291821a2b811f9065",
      "cf00b989763c45d0bd1c928ceeedf0e0",
      "a9404034847842e89ac0d9cd73e4f3e8",
      "3f812f9d29ed4309b62bae67be6f6ce2",
      "23d513e352f5416cb16ce6934df4ff69",
      "7c309ec75faf4cfbb1ef4dd8929693ab",
      "d3e617bfbf7042229b9d31156963cc87",
      "e0843b4cb8b24cd48703671a94930f38",
      "557c87612c124071bc3571c1e3020328",
      "86db8c51dadb4ae7ad398f7217519d69",
      "7c29b4845ec54c8ba06cbbb82dc93321",
      "e119ebbb44f24428bc2f34cc59bce58c",
      "2c2af7b5445f4f61b9a63753b1171801",
      "1a15e83976534eb296eac77cc39bfca8",
      "180c353465004567b28f28cf56852774",
      "08da2f3030e4428eb1b6c215ca76e81d",
      "3262ac452db747339fc44ebe46f0c148",
      "16434e01599742e7923a83c5851130ef",
      "fe8309ff14cd40d5a9e29a4e45aa2ce7",
      "d2a9cc9a859747108a893d0cc09757bd",
      "35ba870dd81a4164afed08d99cda23b9",
      "2e8a78bb018143239736ca2a1e001c27",
      "dd214f9ec2704ecc9cc80add80c85517",
      "9522a212c0984a62a4045df525d03390",
      "57b86ca5a031411da0a7dc72e228560c",
      "0037026abbad48039849058e11bf8157",
      "745e36a65e6d46c28a382ecba5d9fcd4",
      "e793c187ff3045f8907938d235528239",
      "7638dc3abfde421a892f517cdd95a8ad",
      "c278ad7f27a341559548e077307ca561",
      "cf3f9081fbaf4cc7a96015de86f86007",
      "177692768f084d0d8ae442122a374f63",
      "369bc3d9ae034c82bbb39e2f8e082018",
      "9a0ed4ded9f54737ba8e5616295ce55b",
      "36b5381d71a44af7860f07da7a3fac55",
      "f77ca69f93404b1cb5992727d2cb8341",
      "8655a122477d497592f043955f13bfe7",
      "a55e223098a64b298b809a79438155a7",
      "19f9fb0210df42ac8e1d643a05bd99f2",
      "53aec027b46e480cb985c9c2d1683484",
      "23556081a1f4409588624ed4062b7995",
      "c8d9448b21494b1d922f44bf0168560b",
      "4c0f5f926f9c483586e2278cdc680428",
      "5ef4c12ba20f4d55a7b0fd4745d08045",
      "bdba310346de42dd8e8dbf55305f95b1",
      "296838014d2a4f35bb25cc225ffcb457",
      "8ce8b968150f4a0a91c573ad63e6a944",
      "5b641c2abc05496e87f7314503b05ad2",
      "60e95e47af20453ba8a92126b937ed7a",
      "bdf4cf13df9b423e85d447410d27bae4",
      "07c3d1e6dd734ee5828b4625aaeb85b9",
      "56f67d26dde346ff8a9c1456cd88f198",
      "8e4735513b974e09983b5d3f84302917",
      "397a5d82280b48038df0aea203a67c2a",
      "31c47f2a9ca24c70b64e9cf03fc98bf9",
      "2a79739ca06e46448aa0a79ec88f731b",
      "25bfeb9224d3496a9afc42bde116aaf9",
      "aa8684c2ea1e496a82f537fcd56fbad4",
      "a943c01693aa4124a98c2e655719a11c",
      "878992de10d64a0782e358875be7c8fa",
      "0d6a8e8114cf474caad474e4853d5573",
      "0a061bde8b084f22857255000aa8a4c7",
      "30db4c2d40e846b9b74bd20a2be7c109",
      "8e79b9283ad244e4a54fcc335e8e870e"
     ]
    },
    "id": "ogpackv6TEHj",
    "outputId": "44ae0416-b70c-4674-9408-673f3db42ec9"
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Special tokens have been added in the vocabulary, make sure the associated word embeddings are fine-tuned or trained.\n"
     ]
    }
   ],
   "source": [
    "#SET UP TOKENIZER\n",
    "\n",
    "tokenizer = AutoTokenizer.from_pretrained(config['model'],use_fast=False)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "id": "eSkkt8MwTNBw"
   },
   "outputs": [],
   "source": [
    "#READ THE DATA USING CSV\n",
    "\n",
    "def load_data(language):\n",
    "  train_df = pd.read_csv(f'./thesis_data/{language}_train.txt',sep='\\t',header=None,names=[\"token\",\"C/I\"],skip_blank_lines=False)\n",
    "  test_df = pd.read_csv(f'./thesis_data/{language}_test.txt',sep='\\t',header=None,names=[\"token\",\"C/I\"],skip_blank_lines=False)\n",
    "  dev_df = pd.read_csv(f'./thesis_data/{language}_dev.txt',sep='\\t',header=None,names=[\"token\",\"C/I\"],skip_blank_lines=False)\n",
    "  return train_df, test_df, dev_df"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "id": "fROzKV357bOO"
   },
   "outputs": [],
   "source": [
    "#DEFININE OUR TRAIN, TEST AND DEVELOPMENT SET\n",
    "\n",
    "train_df=load_data('sv')[0]\n",
    "test_df=load_data('sv')[1]\n",
    "dev_df=load_data('sv')[2]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "E7cJAywe7QLk",
    "outputId": "f156435c-54e7-44cf-e740-3da8583750d9"
   },
   "outputs": [],
   "source": [
    "#VISUALISING OUR DATA\n",
    "\n",
    "print(train_df.head(10))\n",
    "print(test_df.head(10))\n",
    "print(dev_df.head(10))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "Ot92-SFTZAky",
    "outputId": "cc8d567b-5bad-46a8-a4a4-27eb7a93a514"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['token', 'C/I']\n"
     ]
    }
   ],
   "source": [
    "#VISUALISING OUR COLUMNS\n",
    "\n",
    "print(train_df.columns.to_list())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "id": "yXj8AAgIOOBW"
   },
   "outputs": [],
   "source": [
    "#PROCESS THE DATAFRAME\n",
    "\n",
    "def process_df(df,is_test=False):\n",
    "\n",
    "  '''This function processes the data by adding EOS tokens at the end of each\n",
    "  sentence/sequence of labels, to facilitate the sentence tokenization.\n",
    "\n",
    "  It takes a dataframe as an parameter.\n",
    "  The user can also optionally set is_test to True; if so, only the sentences\n",
    "  will be processed and not the sequence of labels.\n",
    "  \n",
    "  Return: a dataframe'''\n",
    "\n",
    "  df['token'] = df['token'].fillna(value=\"EOS\")\n",
    "  if not is_test:\n",
    "    df['C/I'] =df['C/I'].fillna(value=\"EOS\")\n",
    "    return df\n",
    "  return df"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "id": "ShHwTaWp0tSt"
   },
   "outputs": [],
   "source": [
    "#PROCESS THE DATA\n",
    "\n",
    "train_df=process_df(train_df)\n",
    "dev_df=process_df(dev_df)\n",
    "test_df=process_df(test_df)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#VISUALISE THE DATA\n",
    "\n",
    "print(dev_df.head(10))\n",
    "print(train_df.head(10))\n",
    "print(test_df.head(10))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "id": "W2FF2LUi5vOp"
   },
   "outputs": [],
   "source": [
    "#GETTING THE SENTENCES AND LABELS\n",
    "\n",
    "def get_sents_labels(df, is_test=False):\n",
    "\n",
    "  '''This function groups the sentences and the corresponding labels.\n",
    "  It takes a dataframe as an input.\n",
    "  Optionally, the user can indicate if the df is the test set.\n",
    "  \n",
    "  This function creates a tuple with the input sentences and corresponding \n",
    "  list of labels:\n",
    "  ([\"sentence 1\",\"sentence 2\"],[labels 1, labels 2])\n",
    "  \n",
    "  Or a tuple with just a list of sentences for the test set:\n",
    "  ([\"sentence 1\",\"sentence 2\"])\n",
    "\n",
    "  Return: a tuple\n",
    "  '''\n",
    "\n",
    "  tokens=\" \".join(list(df[\"token\"]))\n",
    "  sents=tokens.split(\"EOS\")[:-1] #getting rid of the last empty string \n",
    "\n",
    "  if is_test:\n",
    "\n",
    "    return tuple([sents])\n",
    "  \n",
    "  else:\n",
    "\n",
    "    all_labels=\" \".join(list(df[\"C/I\"]))\n",
    "    labels=all_labels.split(\"EOS\")[:-1]\n",
    "\n",
    "    return sents, labels"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "id": "DutyH0qPyVou"
   },
   "outputs": [],
   "source": [
    "#PROCESSING THE DATA\n",
    "\n",
    "train_inputs=get_sents_labels(train_df)\n",
    "dev_inputs=get_sents_labels(dev_df)\n",
    "test_inputs=get_sents_labels(test_df, is_test=False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "CbMN7D2LItht",
    "outputId": "8cc27ac6-0279-4b66-dae5-646f69c3ff54"
   },
   "outputs": [],
   "source": [
    "#VISUALISING THE DATA\n",
    "\n",
    "print(train_inputs)\n",
    "print(dev_inputs)\n",
    "print(test_inputs)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "#CHECKING MAX LENGTH OF THE INPUT\n",
    "\n",
    "def max_length(inputs):\n",
    "    inputs=[input.strip().split() for input in inputs[0]]\n",
    "    longest_input=max(inputs, key=len)\n",
    "    #print(longest_input)\n",
    "    return len(longest_input)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The longest sentences of each dataset have a length of 217 (train), 84 (development), 88 (test), 88 (self-test)\n"
     ]
    }
   ],
   "source": [
    "#PRINTING THE MAX LENGTH OF EACH DATASET\n",
    "\n",
    "print(f\"The longest sentences of each dataset have a length of {max_length(train_inputs)} (train), {max_length(dev_inputs)} (development), {max_length(test_inputs)} (test), {max_length(test_inputs)} (self-test)\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "yfMA-d954oAV",
    "outputId": "28c1727d-ed61-4226-85bf-8c699b629dc9"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'c': 1, 'i': 2, 'X': 2, 'SPLITTER': 0, 'EMPTY': 0}\n"
     ]
    }
   ],
   "source": [
    "#LABEL 2 IDX DICTIONARY\n",
    "#Will be used to convert the labels to numerical values for torch.tensor\n",
    "\n",
    "label2idx={\"c\":1, \"i\":2, \"X\":2, \"SPLITTER\":0, \"EMPTY\":0}\n",
    "print(label2idx)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [],
   "source": [
    "#DATA PROCESSING\n",
    "\n",
    "class GetDataset:\n",
    "  \n",
    "    '''This class processes the data that will be fed to the model later on.\n",
    "    First, it encodes each sentence. Then, based on the encodings and subtokens,\n",
    "    it re-matches the labels corresponding to this sentence.\n",
    "    The labels of the subtokens is always \"X\".\n",
    "    It then matches the labels to their corresponding numerical value\n",
    "    in label2idx.\n",
    "\n",
    "    Return: a tuple with dictionaries of tensors ({sentence},{labels})\n",
    "    or just a tensor {sentence} for the test set'''\n",
    "\n",
    "    def __init__(self, inputs, config, tokenizer=None, is_test=False, verify_rematching=False):\n",
    "        self.inputs=inputs\n",
    "        self.classes = ['C/I']\n",
    "        self.max_len = config['max_length']\n",
    "        self.tokenizer = tokenizer\n",
    "        self.is_test = is_test\n",
    "        self.verify_rematching=verify_rematching\n",
    "        \n",
    "    def __getitem__(self,idx): #gets an indiviual element from the sample\n",
    "\n",
    "        #get element at index idx in the 0th element of the tuple\n",
    "        #=the list of tokenized sentences\n",
    "        sample = self.inputs[0][idx].split() \n",
    " \n",
    "        #Then, we can tokenize our sentences\n",
    "        tokenized = tokenizer.encode_plus(self.inputs[0][idx], #the full sentence\n",
    "                                      None, #what does that stand for?\n",
    "                                      add_special_tokens=True, #encode the sequences with the special tokens relative to their model.\n",
    "                                      max_length=self.max_len, #maximum length for truncation?\n",
    "                                      truncation=True, #Activates truncation to a maximum length specified with the argument max_length\n",
    "                                      padding='max_length' #the padding will go up until max_length \n",
    "                                     )\n",
    "  \n",
    "\n",
    "        #Converting our inputs to tensors\n",
    "        inputs = {\n",
    "            \"input_ids\": torch.tensor(tokenized['input_ids'], dtype=torch.long), #replace with encoding\n",
    "            \"token_type_ids\": torch.tensor(tokenized['token_type_ids'], dtype=torch.long), #you should probably stack the token_type-ids too, as well as the attention mask.\n",
    "            \"attention_mask\": torch.tensor(tokenized['attention_mask'], dtype=torch.long)\n",
    "        }\n",
    "        \n",
    "        #if you pass the test set: just encode the sample\n",
    "        if self.is_test:\n",
    "          return inputs\n",
    "        \n",
    "        #otherwise, perform further data transformations on labels, so as to match \n",
    "        #them to the newly tokenized sentence\n",
    "        else: \n",
    "\n",
    "          #get the labels\n",
    "          labels=self.inputs[1][idx].split()\n",
    "          #print(\"Selected sample:\",sample)\n",
    "\n",
    "          #match the sentence with its labels\n",
    "          matched_tokens=list(zip(sample,labels))\n",
    "\n",
    "          new_labels=[]\n",
    "\n",
    "          #for each word/label pair\n",
    "          for token in matched_tokens:\n",
    "            #encode the word\n",
    "            word_encoding=tokenizer.encode_plus(token[0])\n",
    "            #check the length\n",
    "            len_subtokens=len(word_encoding['input_ids'])-2\n",
    "\n",
    "            #if the length >1, there are subtokens\n",
    "            if len_subtokens>1:\n",
    "              #add the corresponding label as many times as there are subtokens/add X as many times as there are subtokens\n",
    "              new_labels.append(token[1])\n",
    "              new_labels.extend([token[1]]*(len_subtokens-1)) #DIFFERENT: rplace X with token[1]\n",
    "            \n",
    "            #otherwise, just add the token\n",
    "            else:\n",
    "              new_labels.append(token[1])\n",
    "\n",
    "          #ADD SPECIAL LABELS\n",
    "          new_labels.append(\"SPLITTER\")\n",
    "          new_labels.insert(0,\"SPLITTER\")\n",
    "          len_padding=len(new_labels)\n",
    "          #print(len_padding, self.max_len)\n",
    "          new_labels.extend([\"EMPTY\" for i in range(self.max_len-len_padding)])\n",
    "          #print(\"New labels:\",new_labels)\n",
    "          #print(len(new_labels))\n",
    "          if len(new_labels)>self.max_len:\n",
    "            del new_labels[self.max_len:]\n",
    "\n",
    "        #Mapping the labels to their numerical values in dict2idx\n",
    "        numerical_labels=[label2idx[k] for k in new_labels]\n",
    "         \n",
    "        targets = {\n",
    "            \"labels\": torch.tensor(numerical_labels, dtype=torch.int8),\n",
    "        }\n",
    "\n",
    "        #Checking that the re-matching was successful\n",
    "        if self.verify_rematching:\n",
    "          if len(tokenizer.encode_plus(self.inputs[0][idx])['input_ids']) != len_padding:\n",
    "            print(f\"Error: the length of the labels does not correspond to the length of the encoding.\\n Length of the encoding: {len(tokenizer.encode_plus(self.inputs[0][idx])['input_ids'])-2}\\n length of the new labels: {len(new_labels)}\")\n",
    "            print(sample, new_labels,tokenizer.encode_plus(self.inputs[0][idx]))\n",
    "\n",
    "\n",
    "        return inputs, targets #inputs and labels\n",
    "    \n",
    "    def __len__(self):\n",
    "        return len(self.inputs[0])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {
    "id": "nzZJcxXLJoXk"
   },
   "outputs": [],
   "source": [
    "#PROCESSING OUR DATA\n",
    "\n",
    "train_ds = GetDataset(train_inputs, config, tokenizer=tokenizer, verify_rematching=True) #bring it back to input when you train the model for real\n",
    "dev_ds = GetDataset(dev_inputs, config, tokenizer=tokenizer, verify_rematching=True)\n",
    "test_ds = GetDataset(test_inputs, config, tokenizer=tokenizer, verify_rematching=True, is_test=False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "bzpmWhHsB8dQ",
    "outputId": "b7f9e0d5-afef-4458-cc78-43c4a3e7625a"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "({'input_ids': tensor([     1,    432,   9211,    260,    267,  27847,   3600,   1565,    260,\n",
       "           28178,    296,    714,    270,    513,    260,  42890,    260,    267,\n",
       "          120581,  99043,   1288,    270,    513,    589,   8711,  61917,  10825,\n",
       "             391, 106498,   1288,   1034,    273,    270,    621,   1967,  37944,\n",
       "             500,    306,    287,  44573,    287,    260,    261,      2,      0,\n",
       "               0,      0,      0,      0,      0,      0,      0,      0,      0,\n",
       "               0,      0,      0,      0,      0,      0,      0,      0,      0,\n",
       "               0,      0,      0,      0,      0,      0,      0,      0,      0,\n",
       "               0,      0,      0,      0,      0,      0,      0,      0,      0,\n",
       "               0,      0,      0,      0,      0,      0,      0,      0,      0,\n",
       "               0,      0,      0,      0,      0,      0,      0,      0,      0,\n",
       "               0,      0,      0,      0,      0,      0,      0,      0,      0,\n",
       "               0,      0,      0,      0,      0,      0,      0,      0,      0,\n",
       "               0,      0,      0,      0,      0,      0,      0,      0,      0,\n",
       "               0,      0]),\n",
       "  'token_type_ids': tensor([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n",
       "          0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n",
       "          0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n",
       "          0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n",
       "          0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n",
       "          0, 0, 0, 0, 0, 0, 0, 0]),\n",
       "  'attention_mask': tensor([1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n",
       "          1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0,\n",
       "          0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n",
       "          0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n",
       "          0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n",
       "          0, 0, 0, 0, 0, 0, 0, 0])},\n",
       " {'labels': tensor([0, 1, 1, 1, 1, 1, 1, 1, 2, 2, 2, 2, 1, 1, 1, 1, 1, 1, 2, 2, 1, 1, 1, 1,\n",
       "          2, 2, 2, 1, 1, 1, 2, 2, 2, 1, 2, 1, 1, 2, 2, 1, 1, 1, 1, 0, 0, 0, 0, 0,\n",
       "          0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n",
       "          0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n",
       "          0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n",
       "          0, 0, 0, 0, 0, 0, 0, 0], dtype=torch.int8)})"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#CHECKING THE PROCESSING\n",
    "\n",
    "test_ds[27]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [],
   "source": [
    "#CHECKING THAT THE PADDING WORKED\n",
    "\n",
    "def check_length_tensors(data):\n",
    "    '''Checking that each tensor has a a maximum length of max_length'''\n",
    "    for i in tqdm(range(len(data))):\n",
    "        if len(data[i][0]['input_ids'])!=config['max_length']:\n",
    "               print(\"error inputs ids\",len(data[i][0]['input_ids']))\n",
    "        if len(data[i][0]['attention_mask'])!=config['max_length']:\n",
    "               print(\"error attention mask\",len(data[i][0]['input_ids']))\n",
    "        if len(data[i][0]['token_type_ids'])!=config['max_length']:\n",
    "               print(\"error token type ids\",len(data[i][0]['input_ids']))\n",
    "        if len(data[i][1]['labels'])!=config['max_length']:\n",
    "               print(\"error labels\",len(data[i][0]['input_ids']),len(data[i][1]['labels']))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "check_length_tensors(self_test_ds)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "LblXak8lJyX9",
    "outputId": "2d7fa237-fd08-45e5-ae47-a0c19188b2d3"
   },
   "outputs": [],
   "source": [
    "#CHECKING THE RE-MATCHING\n",
    "\n",
    "def check_label_rematching(inputs,dataset):\n",
    "    '''For each sentence of the inputs, makes the matching check from GetDataset '''\n",
    "    for i in tqdm(range(len(inputs[0]))):\n",
    "      dataset[i]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|████████████████████████████████████████████████████████████████████████████████| 913/913 [00:01<00:00, 481.70it/s]\n"
     ]
    }
   ],
   "source": [
    "check_label_rematching(train_inputs,train_ds)\n",
    "check_label_rematching(dev_inputs,dev_ds)\n",
    "check_label_rematching(test_inputs,test_ds)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {
    "id": "andWvj8eMM5q"
   },
   "outputs": [],
   "source": [
    "#LOADING THE DATA\n",
    "\n",
    "train_loader = torch.utils.data.DataLoader(train_ds,\n",
    "                                           batch_size=config['batch_size'],\n",
    "                                           shuffle=True, #reshuffle the data at every epoch\n",
    "                                           num_workers=0, #number of subprocesses used for the data loading\n",
    "                                           pin_memory=True #from tensor.utilis.data: If True, the data loader will copy Tensors into device/CUDA pinned memory before returning them.\n",
    "                                          )\n",
    "dev_loader = torch.utils.data.DataLoader(dev_ds,\n",
    "                                         batch_size=config['batch_size'],\n",
    "                                         shuffle=True,\n",
    "                                         num_workers=0,\n",
    "                                         pin_memory=True\n",
    "                                        )\n",
    "test_loader = torch.utils.data.DataLoader(test_ds,\n",
    "                                         batch_size=config['batch_size'],\n",
    "                                         shuffle=False, #True\n",
    "                                         num_workers=0,\n",
    "                                         pin_memory=True\n",
    "                                        )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "loader shapes: 3364 456 457\n"
     ]
    }
   ],
   "source": [
    "\n",
    "#CHECKING THE LOADER SHAPES\n",
    "print('loader shapes:',len(train_loader), len(dev_loader),len(test_loader))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [],
   "source": [
    "#MEAN POOLING\n",
    "\n",
    "class MeanPooling(nn.Module): #calculates the average values for patch of feature maps\n",
    "    def __init__(self):\n",
    "        super(MeanPooling, self).__init__()\n",
    "        \n",
    "    def forward(self, last_hidden_state, attention_mask):\n",
    "        input_mask_expanded = attention_mask.unsqueeze(-1).expand(last_hidden_state.size()).float()\n",
    "        sum_embeddings = torch.sum(last_hidden_state * input_mask_expanded, 1)\n",
    "        sum_mask = input_mask_expanded.sum(1)\n",
    "        sum_mask = torch.clamp(sum_mask, min=1e-9)\n",
    "        mean_embeddings = sum_embeddings / sum_mask\n",
    "        return mean_embeddings"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {
    "id": "A52S6OkqFaxm"
   },
   "outputs": [],
   "source": [
    "#MODEL\n",
    "\n",
    "class mdeBERTaModel(nn.Module):\n",
    "    def __init__(self,config,num_classes=2):\n",
    "        super(mdeBERTaModel,self).__init__()\n",
    "        self.model_name = config['model']\n",
    "        self.freeze = config['freeze_encoder'] #whether or not the weights are frozen from encoder to decoder (here: true)\n",
    "        \n",
    "        self.encoder = AutoModel.from_pretrained(self.model_name) #automatically creates an instance from the model name\n",
    "        if self.freeze:\n",
    "            for param in self.encoder.base_model.parameters():\n",
    "                param.requires_grad = False #gradients dont need to be computed here, since they are the same than in the encoder\n",
    "                \n",
    "        self.pooler = MeanPooling()\n",
    "        self.dropout = nn.Dropout(config['dropout']) #neurons to be ignored to avoid overfitting\n",
    "        self.fc1 = nn.Linear(self.encoder.config.hidden_size,256) #two linear layers, this one reduces the feature space to 64. \n",
    "        #Reduces overfitting, bottleneck, previously of size 64\n",
    "        self.fc2 = nn.Linear(256,config['max_length']) #final layer\n",
    "        \n",
    "        \n",
    "    def forward(self,inputs): #takes inputs as a parameters\n",
    "        \n",
    "        #WITH MEAN POOLING\n",
    "        outputs = self.encoder(**inputs,return_dict=True) #input goes through encoder, put it back to True if you put the MeanPooling back\n",
    "        outputs = self.pooler(outputs['last_hidden_state'], inputs['attention_mask']) #last hidden state and attention masked are passed into the pooling        \n",
    "        outputs = self.fc1(outputs) \n",
    "        outputs = self.fc2(outputs) #passes through the final layers to get probabilities\n",
    "        return outputs #probabilities"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {
    "id": "F8aaJPYWFkyE"
   },
   "outputs": [],
   "source": [
    "#TRAINER\n",
    "\n",
    "class Trainer:\n",
    "    def __init__(self, model, loaders, config, accelerator):\n",
    "        self.model = model\n",
    "        self.train_loader, self.dev_loader = loaders\n",
    "        self.config = config\n",
    "        self.input_keys = ['input_ids','token_type_ids','attention_mask']\n",
    "        self.accelerator = accelerator #accelerators speed up the processing (more efficient with matrix calculations)\n",
    "        \n",
    "        self.optim = self._get_optim()\n",
    "        \n",
    "        self.scheduler = torch.optim.lr_scheduler.CosineAnnealingWarmRestarts(self.optim, T_0=5,eta_min=1e-7)\n",
    "        \n",
    "        self.train_losses = []\n",
    "        self.val_losses = []\n",
    "        \n",
    "    def prepare(self):\n",
    "        self.model, self.optim, self.train_loader, self.dev_loader, self.scheduler = self.accelerator.prepare(\n",
    "            self.model, \n",
    "            self.optim, \n",
    "            self.train_loader, \n",
    "            self.dev_loader, \n",
    "            self.scheduler\n",
    "        )\n",
    "        \n",
    "    def _get_optim(self):\n",
    "        no_decay = ['bias', 'LayerNorm.weight'] #weight decay helps improve accuracy. Here: list of params that should not be decayed\n",
    "        optimizer_grouped_parameters = [\n",
    "            #specifies parameters to be decay\n",
    "            {'params': [p for n, p in self.model.named_parameters() if not any(nd in n for nd in no_decay)], 'weight_decay': 0.0001}, \n",
    "            #specifies parameters to not be decayed\n",
    "            {'params': [p for n, p in self.model.named_parameters() if any(nd in n for nd in no_decay)], 'weight_decay': 0.0}\n",
    "        ]\n",
    "        optimizer = torch.optim.AdamW(optimizer_grouped_parameters, lr=self.config['lr'], eps=self.config['adam_eps']) #optimizer is AdamW\n",
    "        return optimizer\n",
    "\n",
    "        \n",
    "    def loss_fn(self, outputs, targets): \n",
    "\n",
    "      #LOSS FUNCTION: CROSS-ENTROPY LOSS WITH ADDED WEIGHT\n",
    "        colwise_mse = torch.mean(torch.square(targets - outputs), dim=0) \n",
    "        \n",
    "        modified_mse = torch.where((targets == 2) & ((torch.round(outputs) == 0) | (torch.round(outputs) == 1)), colwise_mse * 50, colwise_mse)\n",
    "\n",
    "        loss = torch.mean(torch.sqrt(modified_mse))\n",
    "        return loss\n",
    "    \n",
    "    \n",
    "    def train_one_epoch(self,epoch):\n",
    "        \n",
    "        running_loss = 0.\n",
    "        progress = tqdm(self.train_loader, total=len(self.train_loader))\n",
    "        \n",
    "        for idx,(inputs,targets) in enumerate(progress):\n",
    "            with self.accelerator.accumulate(self.model):\n",
    "            \n",
    "                outputs = self.model(inputs)\n",
    "\n",
    "                loss = self.loss_fn(outputs, targets['labels'])\n",
    "                running_loss += loss.item() #running loss: average of loss across all batches - here, it is update before calculating the average\n",
    "\n",
    "                self.accelerator.backward(loss)\n",
    "                \n",
    "                self.optim.step()\n",
    "                \n",
    "                if self.config['enable_scheduler']:\n",
    "                    self.scheduler.step(epoch - 1 + idx / len(self.train_loader))\n",
    "                    \n",
    "                self.optim.zero_grad() #sets the gradients to 0\n",
    "\n",
    "                del inputs, targets, outputs, loss\n",
    "            \n",
    "            \n",
    "        train_loss = running_loss/len(self.train_loader) #average loss is calculated\n",
    "        self.train_losses.append(train_loss)\n",
    "        \n",
    "    @torch.no_grad() #python decorator: modifies behaviour of a function/class\n",
    "    #used to avoid re-calculating gradients\n",
    "\n",
    "    def valid_one_epoch(self,epoch): #checking how the model behaves with unseen data\n",
    "        \n",
    "        running_loss = 0.\n",
    "        progress = tqdm(self.dev_loader, total=len(self.dev_loader))\n",
    "        \n",
    "        for (inputs, targets) in progress:\n",
    "            \n",
    "            outputs = self.model(inputs)\n",
    "            \n",
    "            loss = self.loss_fn(outputs, targets['labels'])\n",
    "            running_loss += loss.item()\n",
    "            \n",
    "            #no backwardfn used, no gradients = no weights are updated\n",
    "\n",
    "            del inputs, targets, outputs, loss\n",
    "            \n",
    "        \n",
    "        val_loss = running_loss/len(self.dev_loader)\n",
    "        self.val_losses.append(val_loss)\n",
    "        \n",
    "    \n",
    "    def test(self, test_loader):\n",
    "        \n",
    "        preds = []\n",
    "        for (inputs) in test_loader:\n",
    "            \n",
    "            outputs = self.model(inputs)\n",
    "            preds.append(outputs.detach().cpu()) #detached from the computational graph so that it can be manipulated on the cpu\n",
    "            \n",
    "        preds = torch.concat(preds)\n",
    "        return preds\n",
    "    \n",
    "    def fit(self):\n",
    "        \n",
    "        self.prepare() #sets the model and a wide range of params\n",
    "        \n",
    "        fit_progress = tqdm(\n",
    "            range(1, self.config['epochs']+1),\n",
    "            leave = True,\n",
    "            desc=\"Training...\"\n",
    "        )\n",
    "        \n",
    "        for epoch in fit_progress:\n",
    "            \n",
    "            self.model.train() #train function of the model\n",
    "            fit_progress.set_description(f\"EPOCH {epoch} / {self.config['epochs']} | training...\")\n",
    "            self.train_one_epoch(epoch)\n",
    "            self.clear()\n",
    "            \n",
    "            self.model.eval()\n",
    "            fit_progress.set_description(f\"EPOCH {epoch} / {self.config['epochs']} | validating...\")\n",
    "            self.valid_one_epoch(epoch)\n",
    "            self.clear()\n",
    "\n",
    "            print(f\"{'➖️'*10} EPOCH {epoch} / {self.config['epochs']} {'➖️'*10}\")\n",
    "            print(f\"train loss: {self.train_losses[-1]}\")\n",
    "            print(f\"valid loss: {self.val_losses[-1]}\\n\\n\")\n",
    "            \n",
    "    \n",
    "    def clear(self):\n",
    "        gc.collect() #frees up memory space\n",
    "        torch.cuda.empty_cache() #clears up memory cache"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {
    "id": "IGpUagaDFojn"
   },
   "outputs": [],
   "source": [
    "#DEFINE ACCELERATOR\n",
    "\n",
    "accelerator = Accelerator(gradient_accumulation_steps=config['gradient_accumulation_steps'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Some weights of the model checkpoint at microsoft/mdeberta-v3-base were not used when initializing DebertaV2Model: ['lm_predictions.lm_head.LayerNorm.weight', 'mask_predictions.dense.bias', 'mask_predictions.classifier.bias', 'lm_predictions.lm_head.LayerNorm.bias', 'mask_predictions.classifier.weight', 'lm_predictions.lm_head.dense.bias', 'lm_predictions.lm_head.bias', 'mask_predictions.LayerNorm.bias', 'mask_predictions.LayerNorm.weight', 'deberta.embeddings.word_embeddings._weight', 'lm_predictions.lm_head.dense.weight', 'mask_predictions.dense.weight']\n",
      "- This IS expected if you are initializing DebertaV2Model from the checkpoint of a model trained on another task or with another architecture (e.g. initializing a BertForSequenceClassification model from a BertForPreTraining model).\n",
      "- This IS NOT expected if you are initializing DebertaV2Model from the checkpoint of a model that you expect to be exactly identical (initializing a BertForSequenceClassification model from a BertForSequenceClassification model).\n"
     ]
    }
   ],
   "source": [
    "#TRAIN WITH ACCELERATE\n",
    "\n",
    "model = mdeBERTaModel(config).to(device=accelerator.device)\n",
    "trainer = Trainer(model, (train_loader, dev_loader), config, accelerator)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#TRAIN\n",
    "\n",
    "trainer.fit()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "Jo5A4WbaFyJ2"
   },
   "source": [
    "RESULT LOSSES"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {
    "id": "bUJOeYdIFz1Y"
   },
   "outputs": [],
   "source": [
    "#GETTING THE LOSSES\n",
    "\n",
    "losses_df = pd.DataFrame({'epoch':list(range(1,config['epochs'] + 1)),\n",
    "                          'train_loss':trainer.train_losses, \n",
    "                          'val_loss': trainer.val_losses\n",
    "                         })"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {
    "id": "w2W_WZhOF41r"
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>epoch</th>\n",
       "      <th>train_loss</th>\n",
       "      <th>val_loss</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>1</td>\n",
       "      <td>0.338988</td>\n",
       "      <td>0.316281</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>2</td>\n",
       "      <td>0.306961</td>\n",
       "      <td>0.299228</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>3</td>\n",
       "      <td>0.297355</td>\n",
       "      <td>0.307885</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>4</td>\n",
       "      <td>0.291384</td>\n",
       "      <td>0.295687</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>5</td>\n",
       "      <td>0.288630</td>\n",
       "      <td>0.293018</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>5</th>\n",
       "      <td>6</td>\n",
       "      <td>0.299867</td>\n",
       "      <td>0.317428</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>6</th>\n",
       "      <td>7</td>\n",
       "      <td>0.294782</td>\n",
       "      <td>0.292806</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   epoch  train_loss  val_loss\n",
       "0      1    0.338988  0.316281\n",
       "1      2    0.306961  0.299228\n",
       "2      3    0.297355  0.307885\n",
       "3      4    0.291384  0.295687\n",
       "4      5    0.288630  0.293018\n",
       "5      6    0.299867  0.317428\n",
       "6      7    0.294782  0.292806"
      ]
     },
     "execution_count": 38,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#PRINTING THE LOSSES\n",
    "\n",
    "losses_df"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.legend.Legend at 0x7f03c5444a00>"
      ]
     },
     "execution_count": 39,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "#PLOTTING THE LOSSES\n",
    "\n",
    "plt.plot(trainer.train_losses, color='red')\n",
    "plt.plot(trainer.val_losses, color='orange')\n",
    "plt.title('MCRMSE Loss')\n",
    "plt.legend(['Train', 'Validation'], loc='upper right')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "TESTING"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [],
   "source": [
    "#GET PREDICTIONS\n",
    "\n",
    "def predict(data_loader, model):\n",
    "    model.to(device=accelerator.device)\n",
    "    model.eval()\n",
    "    y_pred = []\n",
    "    y_true=[]\n",
    "\n",
    "    for batch in tqdm(data_loader):\n",
    "        labels=batch[1]['labels'].tolist()\n",
    "        y_true.append(labels)\n",
    "    \n",
    "    \n",
    "        with torch.no_grad():\n",
    "            inputs={key:value.to(device=accelerator.device) for key, value in batch[0].items()}\n",
    "            outputs = model(inputs)\n",
    "\n",
    "        rounded_outputs = np.trunc(outputs.detach().cpu().numpy()) #truncate instead of rounding\n",
    "        y_pred.extend(rounded_outputs)\n",
    "    \n",
    "    y_pred = np.vstack(y_pred).tolist()\n",
    "    y_true = [inner_list for sublist in y_true for inner_list in sublist]\n",
    "\n",
    "    return y_true,y_pred"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|█████████████████████████████████████████████████████████████████████████████████| 457/457 [00:22<00:00, 20.63it/s]\n"
     ]
    }
   ],
   "source": [
    "#COLLECTING PREDICTIONS\n",
    "\n",
    "y_true_pred=predict(test_loader, model)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [],
   "source": [
    "#GETTING THE TRUE AND PREDICTED VALUES\n",
    "\n",
    "unprocessed_y_true=y_true_pred[0]\n",
    "unprocessed_y_pred=y_true_pred[1]\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#VISUALISING THE DATA\n",
    "print(unprocessed_y_true[27])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#VISUALISE PREDICTIONS AND TRUE VALUES\n",
    "\n",
    "print(\"Truth\",unprocessed_y_true[0])\n",
    "print(\"Prediction\",unprocessed_y_pred[0])\n",
    "print(\"Truth\",unprocessed_y_true[1])\n",
    "print(\"Prediction\",unprocessed_y_pred[1])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [],
   "source": [
    "#CHECKING THE SIMILARITY BETWEEN THE PREDICTIONS AND THE TRUTH\n",
    "\n",
    "def output_similarity(y_pred):\n",
    "    counter={}\n",
    "    for i in tqdm(range(len(y_pred[0]))):\n",
    "        element_i=[]\n",
    "        for prediction in y_pred:\n",
    "            element_i.append(prediction[i])\n",
    "        counter[i]=dict(Counter(element_i))\n",
    "    return counter"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|███████████████████████████████████████████████████████████████████████████████| 128/128 [00:00<00:00, 4349.18it/s]\n",
      "100%|███████████████████████████████████████████████████████████████████████████████| 128/128 [00:00<00:00, 6326.77it/s]\n"
     ]
    }
   ],
   "source": [
    "prediction_counter=output_similarity(unprocessed_y_pred)\n",
    "truth_counter=output_similarity(unprocessed_y_true)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [],
   "source": [
    "#CREATING A FUNCTION FOR DATA VISUALISATION\n",
    "\n",
    "def plot_counted_values(data):\n",
    "    positions = []\n",
    "    zeros = []\n",
    "    ones = []\n",
    "    twos = []\n",
    "    threes = []\n",
    "    fours = []\n",
    "\n",
    "    for position, values in data.items():\n",
    "        positions.append(position)\n",
    "        zeros.append(values.get(0.0, 0))\n",
    "        ones.append(values.get(1.0, 0))\n",
    "        twos.append(values.get(2.0, 0))\n",
    "        threes.append(values.get(3.0, 0))\n",
    "        fours.append(values.get(4.0, 0))\n",
    "\n",
    "    plt.plot(positions, zeros, label='0')\n",
    "    plt.plot(positions, ones, label='1')\n",
    "    plt.plot(positions, twos, label='2')\n",
    "    plt.plot(positions, threes, label='3')\n",
    "    plt.plot(positions, fours, label='4')\n",
    "\n",
    "    plt.xlabel('Position')\n",
    "    plt.ylabel('Count')\n",
    "    plt.title('Counts of 0s, 1s, 2s, 3s, 4s at Each Position')\n",
    "    plt.legend()\n",
    "    plt.grid(True)\n",
    "    plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Predictions:\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Truth:\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "#PLOTTING THE PREDICTIONS AND TRUE VALUES\n",
    "\n",
    "print(\"Predictions:\")\n",
    "plot_counted_values(prediction_counter)\n",
    "print(\"Truth:\")\n",
    "plot_counted_values(truth_counter)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "EVALUATE THE MODEL WITHOUT FURTHER PROCESSING"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [],
   "source": [
    "#EXACT MATCH ACCURACY PER LABEL\n",
    "\n",
    "def exact_match_accuracy(y_true_preds):\n",
    "    acc = 0\n",
    "    total=0\n",
    "    for x,y in zip(y_true_preds[0], y_true_preds[1]):\n",
    "        for a,b in zip(x,y):\n",
    "            if a == b:\n",
    "                acc += 1\n",
    "            total+=1\n",
    "    return acc/total"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Percentage of correct tokens: \n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "0.9182040662650602"
      ]
     },
     "execution_count": 50,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "print(\"Percentage of correct tokens: \")\n",
    "exact_match_accuracy(y_true_pred)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "PROCESS THE PREDICTIONS\n",
    "\n",
    "STEPS\n",
    "\n",
    "1: remove all the empty labels + testing that they were correctly removed\n",
    "\n",
    "2: check how good the model is at predicting the correct length\n",
    "\n",
    "3: fit the length of the predictions to the length of the gold standards + testing that the lengths fit\n",
    "\n",
    "4: compute exact sentence matching\n",
    "\n",
    "5: flatten all sentences to compute acc/f1/recall/precision"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'c': 1, 'i': 2, 'X': 2, 'SPLITTER': 0, 'EMPTY': 0}\n"
     ]
    }
   ],
   "source": [
    "print(label2idx)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [],
   "source": [
    "#1 REMOVE ALL EMPTY LABELS\n",
    "\n",
    "def filter_data(list_of_labels):\n",
    "    filtered_predictions=[[x for x in sublist if x not in [0]] for sublist in list_of_labels]    \n",
    "    return filtered_predictions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [],
   "source": [
    "filtered_y_true=filter_data(unprocessed_y_true)\n",
    "filtered_y_pred=filter_data(unprocessed_y_pred)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [],
   "source": [
    "#TEST FILTERING\n",
    "\n",
    "def display_filtered_data(unprocessed_data,filtered_data,n):\n",
    "    for pair in list(zip(unprocessed_data,filtered_data))[:n]:\n",
    "        print(\"This should contain empty tokens:\\n\",pair[0],\"\\nThis should not:\\n\",pair[1])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "This should contain empty tokens:\n",
      " [0, 1, 1, 1, 1, 1, 2, 2, 1, 2, 1, 2, 1, 1, 1, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 2, 1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0] \n",
      "This should not:\n",
      " [1, 1, 1, 1, 1, 2, 2, 1, 2, 1, 2, 1, 1, 1, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 2, 1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 1, 1]\n",
      "This should contain empty tokens:\n",
      " [0, 1, 1, 1, 2, 2, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0] \n",
      "This should not:\n",
      " [1, 1, 1, 2, 2, 1, 1, 1, 1, 1, 1]\n"
     ]
    }
   ],
   "source": [
    "display_filtered_data(unprocessed_y_true,filtered_y_true,2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {},
   "outputs": [],
   "source": [
    "#2 CHECKING HOW GOOD THE MODEL IS AT PREDICTING THE CORRECT LENGTH\n",
    "\n",
    "def length_predictions(filtered_y_true,filtered_y_pred):\n",
    "    count=0\n",
    "    count_longer_preds=0\n",
    "    count_shorter_preds=0\n",
    "    for data_point in zip(filtered_y_true,filtered_y_pred):\n",
    "        if len(data_point[0])!=len(data_point[1]):\n",
    "            count+=1\n",
    "            #print(len(data_point[0]),len(data_point[1]))\n",
    "        if len(data_point[0])<len(data_point[1]):\n",
    "            count_longer_preds+=1\n",
    "        if len(data_point[0])>len(data_point[1]):\n",
    "            count_shorter_preds+=1\n",
    "    print(f\"Number of sentences of wrong length: {count} over {len(filtered_y_true)} \\nNumber of predictions that are too long: {count_longer_preds}\\nNumber of predictions that are too short: {count_shorter_preds}\\nHence: {round(count/len(filtered_y_true)*100)}% are of wrong length\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Number of sentences of wrong length: 835 over 913 \n",
      "Number of predictions that are too long: 183\n",
      "Number of predictions that are too short: 652\n",
      "Hence: 91% are of wrong length\n"
     ]
    }
   ],
   "source": [
    "length_predictions(filtered_y_true,filtered_y_pred)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {},
   "outputs": [],
   "source": [
    "#3 FIT THE LENGTHS OF THE PREDICTIONS\n",
    "\n",
    "def fit_predictions(y_pred,y_true):\n",
    "    truncated_predictions=[]\n",
    "    for pred,truth in zip(y_pred,y_true):\n",
    "        if len(pred)>len(truth):\n",
    "            #print(\"Previous prediction: \",pred)\n",
    "            del pred[len(truth):]\n",
    "            #print(\"New truncated prediction: \",pred)\n",
    "            truncated_predictions.append(pred)\n",
    "        elif len(pred)<len(truth):\n",
    "            #print(\"Previous prediction: \",pred)\n",
    "            pred.extend(label2idx[\"SPLITTER\"] for i in range(len(truth)-len(pred)))\n",
    "            #print(\"New extended prediction: \",pred)\n",
    "            truncated_predictions.append(pred)\n",
    "        else:\n",
    "            truncated_predictions.append(pred)\n",
    "    return truncated_predictions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {},
   "outputs": [],
   "source": [
    "fitted_y_pred=fit_predictions(filtered_y_pred,filtered_y_true)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {},
   "outputs": [],
   "source": [
    "#CHECKING THE MATCHING OF THE LENGTHS\n",
    "\n",
    "def check_matching_length(fitted_y_pred,filtered_y_true):\n",
    "    for pred,truth in zip(fitted_y_pred,filtered_y_true):\n",
    "        if len(pred)!=len(truth):\n",
    "                print(f\"Problem: the length do not match.{len(pred)}, {len(truth)}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {},
   "outputs": [],
   "source": [
    "check_matching_length(fitted_y_pred,filtered_y_true)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {},
   "outputs": [],
   "source": [
    "#4 CHECK HOW MANY SENTENCES WERE COMPLETELY CORRECT\n",
    "\n",
    "def exact_sentence_matching(fitted_y_pred,filtered_y_true):\n",
    "    correctly_predicted_sentences=0\n",
    "    total=0\n",
    "    for pair in list(zip(fitted_y_pred,filtered_y_true)):\n",
    "        total+=1\n",
    "        if pair[0]==pair[1]:\n",
    "            correctly_predicted_sentences+=1\n",
    "    return correctly_predicted_sentences/total"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Number of correctly predicted sentences:\n",
      "\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "0.03176341730558598"
      ]
     },
     "execution_count": 63,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "print(\"Number of correctly predicted sentences:\\n\")\n",
    "exact_sentence_matching(fitted_y_pred,filtered_y_true)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "metadata": {},
   "outputs": [],
   "source": [
    "#5 FLATTEN ALL THE LISTS\n",
    "\n",
    "def flatten_list(y):\n",
    "    flat_list = [item for sublist in y for item in sublist]\n",
    "    return flat_list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "metadata": {},
   "outputs": [],
   "source": [
    "y_true=flatten_list(filtered_y_true)\n",
    "y_pred=flatten_list(fitted_y_pred)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Number of 0,1,2 in gold standards:  Counter({1: 18311, 2: 4556})\n",
      "Number of 0,1,2 in predictions:  Counter({1.0: 17733, 0: 4861, 2.0: 273})\n"
     ]
    }
   ],
   "source": [
    "print(\"Number of 0,1,2 in gold standards: \",Counter(y_true))\n",
    "print(\"Number of 0,1,2 in predictions: \",Counter(y_pred))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "EVALUATION METRICS\n",
    "\n",
    "precision, recall, f1, accuracy, for the whole set\n",
    "\n",
    "Then, creating a confusion matrix"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/usr/local/lib64/python3.10/site-packages/sklearn/metrics/_classification.py:1334: UndefinedMetricWarning: Recall is ill-defined and being set to 0.0 in labels with no true samples. Use `zero_division` parameter to control this behavior.\n",
      "  _warn_prf(average, modifier, msg_start, len(result))\n"
     ]
    }
   ],
   "source": [
    "precision=precision_score(y_true, y_pred, average='weighted')\n",
    "recall=recall_score(y_true, y_pred, average='weighted')\n",
    "f1=f1_score(y_true, y_pred, average='weighted')\n",
    "accuracy=accuracy_score(y_true,y_pred)\n",
    "fbeta=fbeta_score(y_true, y_pred, average='weighted', beta=0.5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Weighted metrics\n",
      "\n",
      "Precision: 0.6828402503013651\n",
      "Recall: 0.6095683736388683\n",
      "F1: 0.6223140407412981\n",
      "Accuracy: 0.6095683736388683\n",
      "F0.5: 0.6356185938812726\n"
     ]
    }
   ],
   "source": [
    "print(\"Weighted metrics\\n\")\n",
    "print(\"Precision:\",precision)\n",
    "print(\"Recall:\",recall)\n",
    "print(\"F1:\",f1)\n",
    "print(\"Accuracy:\",accuracy)\n",
    "print(\"F0.5:\",fbeta)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The high precision/recall/F1/accuracy is not due to the fact that the model learns things (or at least, not completely). Rather, they can be explained by the fact that the model outputs gets truncated. So, all the 1s that the model wrongly predicts at the end of each sentence gets truncated. Hence, we are left with mostly 1s (which are almost always correct) and very few 2s. To get a better idea, it is necessary to evaluate the model per category."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/usr/local/lib64/python3.10/site-packages/sklearn/metrics/_classification.py:1334: UndefinedMetricWarning: Recall is ill-defined and being set to 0.0 in labels with no true samples. Use `zero_division` parameter to control this behavior.\n",
      "  _warn_prf(average, modifier, msg_start, len(result))\n"
     ]
    }
   ],
   "source": [
    "macro_precision=precision_score(y_true, y_pred, average='macro')\n",
    "macro_recall=recall_score(y_true, y_pred, average='macro')\n",
    "macro_f1=f1_score(y_true, y_pred, average='macro')\n",
    "macro_fbeta=fbeta_score(y_true, y_pred, average='macro', beta=0.5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Macro metrics\n",
      "\n",
      "Precision: 0.3557881055766354\n",
      "Recall: 0.25803232054398073\n",
      "F1: 0.2671401168281342\n",
      "F0.5: 0.28187950365691017\n"
     ]
    }
   ],
   "source": [
    "print(\"Macro metrics\\n\")\n",
    "print(\"Precision:\",macro_precision)\n",
    "print(\"Recall:\",macro_recall)\n",
    "print(\"F1:\",macro_f1)\n",
    "print(\"F0.5:\",macro_fbeta)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "metadata": {},
   "outputs": [],
   "source": [
    "micro_precision=precision_score(y_true, y_pred, average='micro')\n",
    "micro_recall=recall_score(y_true, y_pred, average='micro')\n",
    "micro_f1=f1_score(y_true, y_pred, average='micro')\n",
    "micro_fbeta=fbeta_score(y_true, y_pred, average='micro', beta=0.5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Micro metrics\n",
      "\n",
      "Precision: 0.6095683736388683\n",
      "Recall: 0.6095683736388683\n",
      "F1: 0.6095683736388683\n",
      "F0.5: 0.6095683736388683\n"
     ]
    }
   ],
   "source": [
    "print(\"Micro metrics\\n\")\n",
    "print(\"Precision:\",micro_precision)\n",
    "print(\"Recall:\",micro_recall)\n",
    "print(\"F1:\",micro_f1)\n",
    "print(\"F0.5:\",micro_fbeta)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "#MAKING A CONFUSION MATRIX\n",
    "#NB: ADAPT THE TICKS TO THE RESULTS OF THE MODEL\n",
    "\n",
    "conf_matrix = confusion_matrix(y_true=y_true, y_pred=y_pred)\n",
    "\n",
    "fig, ax = plt.subplots(figsize=(3, 3))\n",
    "ax.matshow(conf_matrix, cmap=plt.cm.Oranges, alpha=0.3)\n",
    "\n",
    "plt.xticks(np.arange(conf_matrix.shape[1]), [ 0, 1, 2])\n",
    "plt.yticks(np.arange(conf_matrix.shape[0]), [ 0, 1, 2])\n",
    "\n",
    "for i in range(conf_matrix.shape[0]):\n",
    "    for j in range(conf_matrix.shape[1]):\n",
    "        ax.text(x=j, y=i,s=conf_matrix[i, j], va='center', ha='center', size='large')\n",
    " \n",
    "plt.xlabel('Predictions', fontsize=10)\n",
    "plt.ylabel('Actuals', fontsize=10)\n",
    "plt.title('Confusion Matrix', fontsize=10)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "CREATING A FILE FOR EVALUATION"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(label2idx)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#REPLACING THE LABELS BY THEIR ALPHABETICAL VALUE\n",
    "\n",
    "c_i_dicitonary={3:\"c\",1:\"i\",2:\"X\",0:\"X\",-1:\"X\"}\n",
    "list_labels=[[c_i_dicitonary[k] for k in sublist] for sublist in filtered_y_pred]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#CHECKING IF SENTENCES GOT TRUNCATED\n",
    "\n",
    "def match_truncated_sentences(test_inputs):\n",
    "    test_sentences=[input.strip().split() for input in test_inputs[0]]\n",
    "\n",
    "    zipped_labels=zip(test_sentences,list_labels)\n",
    "    zipped_labels=list(zipped_labels)\n",
    "    zipped_labels=enumerate(zipped_labels)\n",
    "\n",
    "    for index,sentence in zipped_labels:\n",
    "        if len(sentence[0])!=len(sentence[1]):\n",
    "            print(\"Error for the sentence:\",index)\n",
    "            sentence[1].extend(['X']*(len(sentence[0])-len(sentence[1])))\n",
    "            print(len(sentence[0]),len(sentence[1]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "match_truncated_sentences(test_inputs)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#ADDING LINE JUMPS AND FLATTENING THE LISTS\n",
    "\n",
    "labels = [''.join(lst) + \" \" for lst in list_labels]\n",
    "labels=[[x for x in string] for string in labels]\n",
    "labels=flatten_list(labels)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#MAKE SURE TO HAVE THE UNLABELLED TEST FILE IN THE CORRECT DIRECTORY\n",
    "#CHANGE DIRECTORY NAME IF NECESSARY\n",
    "\n",
    "def write_predictions(language):\n",
    "    with open(f'./thesis_data/{language}_test_unlabelled.txt') as f:\n",
    "        L = f.readlines()\n",
    "        t = map(lambda s: s.strip(), L)\n",
    "#         lines = (line.rstrip() for line in f) \n",
    "#         lines = (line for line in lines if line)\n",
    "        t=list(t)\n",
    "        token_label=[token+'\\t'+label+\"\\n\" for token,label in zip(t,labels)]\n",
    "    with open(f'./thesis_data/{language}_test_unlabelled.txt','w') as f:\n",
    "        for element in token_label:\n",
    "            f.write(element)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#write_predictions(\"sv\")"
   ]
  }
 ],
 "metadata": {
  "colab": {
   "provenance": []
  },
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.10.8"
  },
  "widgets": {
   "application/vnd.jupyter.widget-state+json": {
    "0037026abbad48039849058e11bf8157": {
     "model_module": "@jupyter-widgets/base",
     "model_module_version": "1.2.0",
     "model_name": "LayoutModel",
     "state": {
      "_model_module": "@jupyter-widgets/base",
      "_model_module_version": "1.2.0",
      "_model_name": "LayoutModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/base",
      "_view_module_version": "1.2.0",
      "_view_name": "LayoutView",
      "align_content": null,
      "align_items": null,
      "align_self": null,
      "border": null,
      "bottom": null,
      "display": null,
      "flex": null,
      "flex_flow": null,
      "grid_area": null,
      "grid_auto_columns": null,
      "grid_auto_flow": null,
      "grid_auto_rows": null,
      "grid_column": null,
      "grid_gap": null,
      "grid_row": null,
      "grid_template_areas": null,
      "grid_template_columns": null,
      "grid_template_rows": null,
      "height": null,
      "justify_content": null,
      "justify_items": null,
      "left": null,
      "margin": null,
      "max_height": null,
      "max_width": null,
      "min_height": null,
      "min_width": null,
      "object_fit": null,
      "object_position": null,
      "order": null,
      "overflow": null,
      "overflow_x": null,
      "overflow_y": null,
      "padding": null,
      "right": null,
      "top": null,
      "visibility": null,
      "width": null
     }
    },
    "07c3d1e6dd734ee5828b4625aaeb85b9": {
     "model_module": "@jupyter-widgets/controls",
     "model_module_version": "1.5.0",
     "model_name": "ProgressStyleModel",
     "state": {
      "_model_module": "@jupyter-widgets/controls",
      "_model_module_version": "1.5.0",
      "_model_name": "ProgressStyleModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/base",
      "_view_module_version": "1.2.0",
      "_view_name": "StyleView",
      "bar_color": null,
      "description_width": ""
     }
    },
    "08da2f3030e4428eb1b6c215ca76e81d": {
     "model_module": "@jupyter-widgets/controls",
     "model_module_version": "1.5.0",
     "model_name": "DescriptionStyleModel",
     "state": {
      "_model_module": "@jupyter-widgets/controls",
      "_model_module_version": "1.5.0",
      "_model_name": "DescriptionStyleModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/base",
      "_view_module_version": "1.2.0",
      "_view_name": "StyleView",
      "description_width": ""
     }
    },
    "0a061bde8b084f22857255000aa8a4c7": {
     "model_module": "@jupyter-widgets/controls",
     "model_module_version": "1.5.0",
     "model_name": "ProgressStyleModel",
     "state": {
      "_model_module": "@jupyter-widgets/controls",
      "_model_module_version": "1.5.0",
      "_model_name": "ProgressStyleModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/base",
      "_view_module_version": "1.2.0",
      "_view_name": "StyleView",
      "bar_color": null,
      "description_width": ""
     }
    },
    "0d6a8e8114cf474caad474e4853d5573": {
     "model_module": "@jupyter-widgets/base",
     "model_module_version": "1.2.0",
     "model_name": "LayoutModel",
     "state": {
      "_model_module": "@jupyter-widgets/base",
      "_model_module_version": "1.2.0",
      "_model_name": "LayoutModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/base",
      "_view_module_version": "1.2.0",
      "_view_name": "LayoutView",
      "align_content": null,
      "align_items": null,
      "align_self": null,
      "border": null,
      "bottom": null,
      "display": null,
      "flex": null,
      "flex_flow": null,
      "grid_area": null,
      "grid_auto_columns": null,
      "grid_auto_flow": null,
      "grid_auto_rows": null,
      "grid_column": null,
      "grid_gap": null,
      "grid_row": null,
      "grid_template_areas": null,
      "grid_template_columns": null,
      "grid_template_rows": null,
      "height": null,
      "justify_content": null,
      "justify_items": null,
      "left": null,
      "margin": null,
      "max_height": null,
      "max_width": null,
      "min_height": null,
      "min_width": null,
      "object_fit": null,
      "object_position": null,
      "order": null,
      "overflow": null,
      "overflow_x": null,
      "overflow_y": null,
      "padding": null,
      "right": null,
      "top": null,
      "visibility": null,
      "width": null
     }
    },
    "141409525736449291821a2b811f9065": {
     "model_module": "@jupyter-widgets/controls",
     "model_module_version": "1.5.0",
     "model_name": "FloatProgressModel",
     "state": {
      "_dom_classes": [],
      "_model_module": "@jupyter-widgets/controls",
      "_model_module_version": "1.5.0",
      "_model_name": "FloatProgressModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/controls",
      "_view_module_version": "1.5.0",
      "_view_name": "ProgressView",
      "bar_style": "success",
      "description": "",
      "description_tooltip": null,
      "layout": "IPY_MODEL_7c309ec75faf4cfbb1ef4dd8929693ab",
      "max": 52,
      "min": 0,
      "orientation": "horizontal",
      "style": "IPY_MODEL_d3e617bfbf7042229b9d31156963cc87",
      "value": 52
     }
    },
    "16434e01599742e7923a83c5851130ef": {
     "model_module": "@jupyter-widgets/controls",
     "model_module_version": "1.5.0",
     "model_name": "ProgressStyleModel",
     "state": {
      "_model_module": "@jupyter-widgets/controls",
      "_model_module_version": "1.5.0",
      "_model_name": "ProgressStyleModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/base",
      "_view_module_version": "1.2.0",
      "_view_name": "StyleView",
      "bar_color": null,
      "description_width": ""
     }
    },
    "177692768f084d0d8ae442122a374f63": {
     "model_module": "@jupyter-widgets/controls",
     "model_module_version": "1.5.0",
     "model_name": "HBoxModel",
     "state": {
      "_dom_classes": [],
      "_model_module": "@jupyter-widgets/controls",
      "_model_module_version": "1.5.0",
      "_model_name": "HBoxModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/controls",
      "_view_module_version": "1.5.0",
      "_view_name": "HBoxView",
      "box_style": "",
      "children": [
       "IPY_MODEL_369bc3d9ae034c82bbb39e2f8e082018",
       "IPY_MODEL_9a0ed4ded9f54737ba8e5616295ce55b",
       "IPY_MODEL_36b5381d71a44af7860f07da7a3fac55"
      ],
      "layout": "IPY_MODEL_f77ca69f93404b1cb5992727d2cb8341"
     }
    },
    "180c353465004567b28f28cf56852774": {
     "model_module": "@jupyter-widgets/base",
     "model_module_version": "1.2.0",
     "model_name": "LayoutModel",
     "state": {
      "_model_module": "@jupyter-widgets/base",
      "_model_module_version": "1.2.0",
      "_model_name": "LayoutModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/base",
      "_view_module_version": "1.2.0",
      "_view_name": "LayoutView",
      "align_content": null,
      "align_items": null,
      "align_self": null,
      "border": null,
      "bottom": null,
      "display": null,
      "flex": null,
      "flex_flow": null,
      "grid_area": null,
      "grid_auto_columns": null,
      "grid_auto_flow": null,
      "grid_auto_rows": null,
      "grid_column": null,
      "grid_gap": null,
      "grid_row": null,
      "grid_template_areas": null,
      "grid_template_columns": null,
      "grid_template_rows": null,
      "height": null,
      "justify_content": null,
      "justify_items": null,
      "left": null,
      "margin": null,
      "max_height": null,
      "max_width": null,
      "min_height": null,
      "min_width": null,
      "object_fit": null,
      "object_position": null,
      "order": null,
      "overflow": null,
      "overflow_x": null,
      "overflow_y": null,
      "padding": null,
      "right": null,
      "top": null,
      "visibility": null,
      "width": null
     }
    },
    "19f9fb0210df42ac8e1d643a05bd99f2": {
     "model_module": "@jupyter-widgets/base",
     "model_module_version": "1.2.0",
     "model_name": "LayoutModel",
     "state": {
      "_model_module": "@jupyter-widgets/base",
      "_model_module_version": "1.2.0",
      "_model_name": "LayoutModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/base",
      "_view_module_version": "1.2.0",
      "_view_name": "LayoutView",
      "align_content": null,
      "align_items": null,
      "align_self": null,
      "border": null,
      "bottom": null,
      "display": null,
      "flex": null,
      "flex_flow": null,
      "grid_area": null,
      "grid_auto_columns": null,
      "grid_auto_flow": null,
      "grid_auto_rows": null,
      "grid_column": null,
      "grid_gap": null,
      "grid_row": null,
      "grid_template_areas": null,
      "grid_template_columns": null,
      "grid_template_rows": null,
      "height": null,
      "justify_content": null,
      "justify_items": null,
      "left": null,
      "margin": null,
      "max_height": null,
      "max_width": null,
      "min_height": null,
      "min_width": null,
      "object_fit": null,
      "object_position": null,
      "order": null,
      "overflow": null,
      "overflow_x": null,
      "overflow_y": null,
      "padding": null,
      "right": null,
      "top": null,
      "visibility": null,
      "width": null
     }
    },
    "1a15e83976534eb296eac77cc39bfca8": {
     "model_module": "@jupyter-widgets/base",
     "model_module_version": "1.2.0",
     "model_name": "LayoutModel",
     "state": {
      "_model_module": "@jupyter-widgets/base",
      "_model_module_version": "1.2.0",
      "_model_name": "LayoutModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/base",
      "_view_module_version": "1.2.0",
      "_view_name": "LayoutView",
      "align_content": null,
      "align_items": null,
      "align_self": null,
      "border": null,
      "bottom": null,
      "display": null,
      "flex": null,
      "flex_flow": null,
      "grid_area": null,
      "grid_auto_columns": null,
      "grid_auto_flow": null,
      "grid_auto_rows": null,
      "grid_column": null,
      "grid_gap": null,
      "grid_row": null,
      "grid_template_areas": null,
      "grid_template_columns": null,
      "grid_template_rows": null,
      "height": null,
      "justify_content": null,
      "justify_items": null,
      "left": null,
      "margin": null,
      "max_height": null,
      "max_width": null,
      "min_height": null,
      "min_width": null,
      "object_fit": null,
      "object_position": null,
      "order": null,
      "overflow": null,
      "overflow_x": null,
      "overflow_y": null,
      "padding": null,
      "right": null,
      "top": null,
      "visibility": null,
      "width": null
     }
    },
    "23556081a1f4409588624ed4062b7995": {
     "model_module": "@jupyter-widgets/base",
     "model_module_version": "1.2.0",
     "model_name": "LayoutModel",
     "state": {
      "_model_module": "@jupyter-widgets/base",
      "_model_module_version": "1.2.0",
      "_model_name": "LayoutModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/base",
      "_view_module_version": "1.2.0",
      "_view_name": "LayoutView",
      "align_content": null,
      "align_items": null,
      "align_self": null,
      "border": null,
      "bottom": null,
      "display": null,
      "flex": null,
      "flex_flow": null,
      "grid_area": null,
      "grid_auto_columns": null,
      "grid_auto_flow": null,
      "grid_auto_rows": null,
      "grid_column": null,
      "grid_gap": null,
      "grid_row": null,
      "grid_template_areas": null,
      "grid_template_columns": null,
      "grid_template_rows": null,
      "height": null,
      "justify_content": null,
      "justify_items": null,
      "left": null,
      "margin": null,
      "max_height": null,
      "max_width": null,
      "min_height": null,
      "min_width": null,
      "object_fit": null,
      "object_position": null,
      "order": null,
      "overflow": null,
      "overflow_x": null,
      "overflow_y": null,
      "padding": null,
      "right": null,
      "top": null,
      "visibility": null,
      "width": null
     }
    },
    "23d513e352f5416cb16ce6934df4ff69": {
     "model_module": "@jupyter-widgets/controls",
     "model_module_version": "1.5.0",
     "model_name": "DescriptionStyleModel",
     "state": {
      "_model_module": "@jupyter-widgets/controls",
      "_model_module_version": "1.5.0",
      "_model_name": "DescriptionStyleModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/base",
      "_view_module_version": "1.2.0",
      "_view_name": "StyleView",
      "description_width": ""
     }
    },
    "25bfeb9224d3496a9afc42bde116aaf9": {
     "model_module": "@jupyter-widgets/controls",
     "model_module_version": "1.5.0",
     "model_name": "HTMLModel",
     "state": {
      "_dom_classes": [],
      "_model_module": "@jupyter-widgets/controls",
      "_model_module_version": "1.5.0",
      "_model_name": "HTMLModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/controls",
      "_view_module_version": "1.5.0",
      "_view_name": "HTMLView",
      "description": "",
      "description_tooltip": null,
      "layout": "IPY_MODEL_30db4c2d40e846b9b74bd20a2be7c109",
      "placeholder": "​",
      "style": "IPY_MODEL_8e79b9283ad244e4a54fcc335e8e870e",
      "value": " 2.46M/2.46M [00:00&lt;00:00, 83.5MB/s]"
     }
    },
    "296838014d2a4f35bb25cc225ffcb457": {
     "model_module": "@jupyter-widgets/controls",
     "model_module_version": "1.5.0",
     "model_name": "HTMLModel",
     "state": {
      "_dom_classes": [],
      "_model_module": "@jupyter-widgets/controls",
      "_model_module_version": "1.5.0",
      "_model_name": "HTMLModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/controls",
      "_view_module_version": "1.5.0",
      "_view_name": "HTMLView",
      "description": "",
      "description_tooltip": null,
      "layout": "IPY_MODEL_56f67d26dde346ff8a9c1456cd88f198",
      "placeholder": "​",
      "style": "IPY_MODEL_8e4735513b974e09983b5d3f84302917",
      "value": " 579/579 [00:00&lt;00:00, 27.8kB/s]"
     }
    },
    "2a79739ca06e46448aa0a79ec88f731b": {
     "model_module": "@jupyter-widgets/controls",
     "model_module_version": "1.5.0",
     "model_name": "FloatProgressModel",
     "state": {
      "_dom_classes": [],
      "_model_module": "@jupyter-widgets/controls",
      "_model_module_version": "1.5.0",
      "_model_name": "FloatProgressModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/controls",
      "_view_module_version": "1.5.0",
      "_view_name": "ProgressView",
      "bar_style": "success",
      "description": "",
      "description_tooltip": null,
      "layout": "IPY_MODEL_0d6a8e8114cf474caad474e4853d5573",
      "max": 2464616,
      "min": 0,
      "orientation": "horizontal",
      "style": "IPY_MODEL_0a061bde8b084f22857255000aa8a4c7",
      "value": 2464616
     }
    },
    "2c2af7b5445f4f61b9a63753b1171801": {
     "model_module": "@jupyter-widgets/controls",
     "model_module_version": "1.5.0",
     "model_name": "HTMLModel",
     "state": {
      "_dom_classes": [],
      "_model_module": "@jupyter-widgets/controls",
      "_model_module_version": "1.5.0",
      "_model_name": "HTMLModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/controls",
      "_view_module_version": "1.5.0",
      "_view_name": "HTMLView",
      "description": "",
      "description_tooltip": null,
      "layout": "IPY_MODEL_fe8309ff14cd40d5a9e29a4e45aa2ce7",
      "placeholder": "​",
      "style": "IPY_MODEL_d2a9cc9a859747108a893d0cc09757bd",
      "value": " 579/579 [00:00&lt;00:00, 15.3kB/s]"
     }
    },
    "2e8a78bb018143239736ca2a1e001c27": {
     "model_module": "@jupyter-widgets/controls",
     "model_module_version": "1.5.0",
     "model_name": "HTMLModel",
     "state": {
      "_dom_classes": [],
      "_model_module": "@jupyter-widgets/controls",
      "_model_module_version": "1.5.0",
      "_model_name": "HTMLModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/controls",
      "_view_module_version": "1.5.0",
      "_view_name": "HTMLView",
      "description": "",
      "description_tooltip": null,
      "layout": "IPY_MODEL_0037026abbad48039849058e11bf8157",
      "placeholder": "​",
      "style": "IPY_MODEL_745e36a65e6d46c28a382ecba5d9fcd4",
      "value": "Downloading spm.model: 100%"
     }
    },
    "2f44991d4e874f579e0f741080b3f6e8": {
     "model_module": "@jupyter-widgets/controls",
     "model_module_version": "1.5.0",
     "model_name": "HTMLModel",
     "state": {
      "_dom_classes": [],
      "_model_module": "@jupyter-widgets/controls",
      "_model_module_version": "1.5.0",
      "_model_name": "HTMLModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/controls",
      "_view_module_version": "1.5.0",
      "_view_name": "HTMLView",
      "description": "",
      "description_tooltip": null,
      "layout": "IPY_MODEL_3f812f9d29ed4309b62bae67be6f6ce2",
      "placeholder": "​",
      "style": "IPY_MODEL_23d513e352f5416cb16ce6934df4ff69",
      "value": "Downloading (…)okenizer_config.json: 100%"
     }
    },
    "30db4c2d40e846b9b74bd20a2be7c109": {
     "model_module": "@jupyter-widgets/base",
     "model_module_version": "1.2.0",
     "model_name": "LayoutModel",
     "state": {
      "_model_module": "@jupyter-widgets/base",
      "_model_module_version": "1.2.0",
      "_model_name": "LayoutModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/base",
      "_view_module_version": "1.2.0",
      "_view_name": "LayoutView",
      "align_content": null,
      "align_items": null,
      "align_self": null,
      "border": null,
      "bottom": null,
      "display": null,
      "flex": null,
      "flex_flow": null,
      "grid_area": null,
      "grid_auto_columns": null,
      "grid_auto_flow": null,
      "grid_auto_rows": null,
      "grid_column": null,
      "grid_gap": null,
      "grid_row": null,
      "grid_template_areas": null,
      "grid_template_columns": null,
      "grid_template_rows": null,
      "height": null,
      "justify_content": null,
      "justify_items": null,
      "left": null,
      "margin": null,
      "max_height": null,
      "max_width": null,
      "min_height": null,
      "min_width": null,
      "object_fit": null,
      "object_position": null,
      "order": null,
      "overflow": null,
      "overflow_x": null,
      "overflow_y": null,
      "padding": null,
      "right": null,
      "top": null,
      "visibility": null,
      "width": null
     }
    },
    "31c47f2a9ca24c70b64e9cf03fc98bf9": {
     "model_module": "@jupyter-widgets/controls",
     "model_module_version": "1.5.0",
     "model_name": "HTMLModel",
     "state": {
      "_dom_classes": [],
      "_model_module": "@jupyter-widgets/controls",
      "_model_module_version": "1.5.0",
      "_model_name": "HTMLModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/controls",
      "_view_module_version": "1.5.0",
      "_view_name": "HTMLView",
      "description": "",
      "description_tooltip": null,
      "layout": "IPY_MODEL_a943c01693aa4124a98c2e655719a11c",
      "placeholder": "​",
      "style": "IPY_MODEL_878992de10d64a0782e358875be7c8fa",
      "value": "Downloading spm.model: 100%"
     }
    },
    "3262ac452db747339fc44ebe46f0c148": {
     "model_module": "@jupyter-widgets/base",
     "model_module_version": "1.2.0",
     "model_name": "LayoutModel",
     "state": {
      "_model_module": "@jupyter-widgets/base",
      "_model_module_version": "1.2.0",
      "_model_name": "LayoutModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/base",
      "_view_module_version": "1.2.0",
      "_view_name": "LayoutView",
      "align_content": null,
      "align_items": null,
      "align_self": null,
      "border": null,
      "bottom": null,
      "display": null,
      "flex": null,
      "flex_flow": null,
      "grid_area": null,
      "grid_auto_columns": null,
      "grid_auto_flow": null,
      "grid_auto_rows": null,
      "grid_column": null,
      "grid_gap": null,
      "grid_row": null,
      "grid_template_areas": null,
      "grid_template_columns": null,
      "grid_template_rows": null,
      "height": null,
      "justify_content": null,
      "justify_items": null,
      "left": null,
      "margin": null,
      "max_height": null,
      "max_width": null,
      "min_height": null,
      "min_width": null,
      "object_fit": null,
      "object_position": null,
      "order": null,
      "overflow": null,
      "overflow_x": null,
      "overflow_y": null,
      "padding": null,
      "right": null,
      "top": null,
      "visibility": null,
      "width": null
     }
    },
    "35ba870dd81a4164afed08d99cda23b9": {
     "model_module": "@jupyter-widgets/controls",
     "model_module_version": "1.5.0",
     "model_name": "HBoxModel",
     "state": {
      "_dom_classes": [],
      "_model_module": "@jupyter-widgets/controls",
      "_model_module_version": "1.5.0",
      "_model_name": "HBoxModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/controls",
      "_view_module_version": "1.5.0",
      "_view_name": "HBoxView",
      "box_style": "",
      "children": [
       "IPY_MODEL_2e8a78bb018143239736ca2a1e001c27",
       "IPY_MODEL_dd214f9ec2704ecc9cc80add80c85517",
       "IPY_MODEL_9522a212c0984a62a4045df525d03390"
      ],
      "layout": "IPY_MODEL_57b86ca5a031411da0a7dc72e228560c"
     }
    },
    "369bc3d9ae034c82bbb39e2f8e082018": {
     "model_module": "@jupyter-widgets/controls",
     "model_module_version": "1.5.0",
     "model_name": "HTMLModel",
     "state": {
      "_dom_classes": [],
      "_model_module": "@jupyter-widgets/controls",
      "_model_module_version": "1.5.0",
      "_model_name": "HTMLModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/controls",
      "_view_module_version": "1.5.0",
      "_view_name": "HTMLView",
      "description": "",
      "description_tooltip": null,
      "layout": "IPY_MODEL_8655a122477d497592f043955f13bfe7",
      "placeholder": "​",
      "style": "IPY_MODEL_a55e223098a64b298b809a79438155a7",
      "value": "Downloading (…)okenizer_config.json: 100%"
     }
    },
    "36b5381d71a44af7860f07da7a3fac55": {
     "model_module": "@jupyter-widgets/controls",
     "model_module_version": "1.5.0",
     "model_name": "HTMLModel",
     "state": {
      "_dom_classes": [],
      "_model_module": "@jupyter-widgets/controls",
      "_model_module_version": "1.5.0",
      "_model_name": "HTMLModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/controls",
      "_view_module_version": "1.5.0",
      "_view_name": "HTMLView",
      "description": "",
      "description_tooltip": null,
      "layout": "IPY_MODEL_23556081a1f4409588624ed4062b7995",
      "placeholder": "​",
      "style": "IPY_MODEL_c8d9448b21494b1d922f44bf0168560b",
      "value": " 52.0/52.0 [00:00&lt;00:00, 1.70kB/s]"
     }
    },
    "397a5d82280b48038df0aea203a67c2a": {
     "model_module": "@jupyter-widgets/controls",
     "model_module_version": "1.5.0",
     "model_name": "HBoxModel",
     "state": {
      "_dom_classes": [],
      "_model_module": "@jupyter-widgets/controls",
      "_model_module_version": "1.5.0",
      "_model_name": "HBoxModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/controls",
      "_view_module_version": "1.5.0",
      "_view_name": "HBoxView",
      "box_style": "",
      "children": [
       "IPY_MODEL_31c47f2a9ca24c70b64e9cf03fc98bf9",
       "IPY_MODEL_2a79739ca06e46448aa0a79ec88f731b",
       "IPY_MODEL_25bfeb9224d3496a9afc42bde116aaf9"
      ],
      "layout": "IPY_MODEL_aa8684c2ea1e496a82f537fcd56fbad4"
     }
    },
    "3f812f9d29ed4309b62bae67be6f6ce2": {
     "model_module": "@jupyter-widgets/base",
     "model_module_version": "1.2.0",
     "model_name": "LayoutModel",
     "state": {
      "_model_module": "@jupyter-widgets/base",
      "_model_module_version": "1.2.0",
      "_model_name": "LayoutModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/base",
      "_view_module_version": "1.2.0",
      "_view_name": "LayoutView",
      "align_content": null,
      "align_items": null,
      "align_self": null,
      "border": null,
      "bottom": null,
      "display": null,
      "flex": null,
      "flex_flow": null,
      "grid_area": null,
      "grid_auto_columns": null,
      "grid_auto_flow": null,
      "grid_auto_rows": null,
      "grid_column": null,
      "grid_gap": null,
      "grid_row": null,
      "grid_template_areas": null,
      "grid_template_columns": null,
      "grid_template_rows": null,
      "height": null,
      "justify_content": null,
      "justify_items": null,
      "left": null,
      "margin": null,
      "max_height": null,
      "max_width": null,
      "min_height": null,
      "min_width": null,
      "object_fit": null,
      "object_position": null,
      "order": null,
      "overflow": null,
      "overflow_x": null,
      "overflow_y": null,
      "padding": null,
      "right": null,
      "top": null,
      "visibility": null,
      "width": null
     }
    },
    "4c0f5f926f9c483586e2278cdc680428": {
     "model_module": "@jupyter-widgets/controls",
     "model_module_version": "1.5.0",
     "model_name": "HBoxModel",
     "state": {
      "_dom_classes": [],
      "_model_module": "@jupyter-widgets/controls",
      "_model_module_version": "1.5.0",
      "_model_name": "HBoxModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/controls",
      "_view_module_version": "1.5.0",
      "_view_name": "HBoxView",
      "box_style": "",
      "children": [
       "IPY_MODEL_5ef4c12ba20f4d55a7b0fd4745d08045",
       "IPY_MODEL_bdba310346de42dd8e8dbf55305f95b1",
       "IPY_MODEL_296838014d2a4f35bb25cc225ffcb457"
      ],
      "layout": "IPY_MODEL_8ce8b968150f4a0a91c573ad63e6a944"
     }
    },
    "53aec027b46e480cb985c9c2d1683484": {
     "model_module": "@jupyter-widgets/controls",
     "model_module_version": "1.5.0",
     "model_name": "ProgressStyleModel",
     "state": {
      "_model_module": "@jupyter-widgets/controls",
      "_model_module_version": "1.5.0",
      "_model_name": "ProgressStyleModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/base",
      "_view_module_version": "1.2.0",
      "_view_name": "StyleView",
      "bar_color": null,
      "description_width": ""
     }
    },
    "557c87612c124071bc3571c1e3020328": {
     "model_module": "@jupyter-widgets/controls",
     "model_module_version": "1.5.0",
     "model_name": "DescriptionStyleModel",
     "state": {
      "_model_module": "@jupyter-widgets/controls",
      "_model_module_version": "1.5.0",
      "_model_name": "DescriptionStyleModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/base",
      "_view_module_version": "1.2.0",
      "_view_name": "StyleView",
      "description_width": ""
     }
    },
    "56f67d26dde346ff8a9c1456cd88f198": {
     "model_module": "@jupyter-widgets/base",
     "model_module_version": "1.2.0",
     "model_name": "LayoutModel",
     "state": {
      "_model_module": "@jupyter-widgets/base",
      "_model_module_version": "1.2.0",
      "_model_name": "LayoutModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/base",
      "_view_module_version": "1.2.0",
      "_view_name": "LayoutView",
      "align_content": null,
      "align_items": null,
      "align_self": null,
      "border": null,
      "bottom": null,
      "display": null,
      "flex": null,
      "flex_flow": null,
      "grid_area": null,
      "grid_auto_columns": null,
      "grid_auto_flow": null,
      "grid_auto_rows": null,
      "grid_column": null,
      "grid_gap": null,
      "grid_row": null,
      "grid_template_areas": null,
      "grid_template_columns": null,
      "grid_template_rows": null,
      "height": null,
      "justify_content": null,
      "justify_items": null,
      "left": null,
      "margin": null,
      "max_height": null,
      "max_width": null,
      "min_height": null,
      "min_width": null,
      "object_fit": null,
      "object_position": null,
      "order": null,
      "overflow": null,
      "overflow_x": null,
      "overflow_y": null,
      "padding": null,
      "right": null,
      "top": null,
      "visibility": null,
      "width": null
     }
    },
    "57b86ca5a031411da0a7dc72e228560c": {
     "model_module": "@jupyter-widgets/base",
     "model_module_version": "1.2.0",
     "model_name": "LayoutModel",
     "state": {
      "_model_module": "@jupyter-widgets/base",
      "_model_module_version": "1.2.0",
      "_model_name": "LayoutModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/base",
      "_view_module_version": "1.2.0",
      "_view_name": "LayoutView",
      "align_content": null,
      "align_items": null,
      "align_self": null,
      "border": null,
      "bottom": null,
      "display": null,
      "flex": null,
      "flex_flow": null,
      "grid_area": null,
      "grid_auto_columns": null,
      "grid_auto_flow": null,
      "grid_auto_rows": null,
      "grid_column": null,
      "grid_gap": null,
      "grid_row": null,
      "grid_template_areas": null,
      "grid_template_columns": null,
      "grid_template_rows": null,
      "height": null,
      "justify_content": null,
      "justify_items": null,
      "left": null,
      "margin": null,
      "max_height": null,
      "max_width": null,
      "min_height": null,
      "min_width": null,
      "object_fit": null,
      "object_position": null,
      "order": null,
      "overflow": null,
      "overflow_x": null,
      "overflow_y": null,
      "padding": null,
      "right": null,
      "top": null,
      "visibility": null,
      "width": null
     }
    },
    "5b641c2abc05496e87f7314503b05ad2": {
     "model_module": "@jupyter-widgets/base",
     "model_module_version": "1.2.0",
     "model_name": "LayoutModel",
     "state": {
      "_model_module": "@jupyter-widgets/base",
      "_model_module_version": "1.2.0",
      "_model_name": "LayoutModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/base",
      "_view_module_version": "1.2.0",
      "_view_name": "LayoutView",
      "align_content": null,
      "align_items": null,
      "align_self": null,
      "border": null,
      "bottom": null,
      "display": null,
      "flex": null,
      "flex_flow": null,
      "grid_area": null,
      "grid_auto_columns": null,
      "grid_auto_flow": null,
      "grid_auto_rows": null,
      "grid_column": null,
      "grid_gap": null,
      "grid_row": null,
      "grid_template_areas": null,
      "grid_template_columns": null,
      "grid_template_rows": null,
      "height": null,
      "justify_content": null,
      "justify_items": null,
      "left": null,
      "margin": null,
      "max_height": null,
      "max_width": null,
      "min_height": null,
      "min_width": null,
      "object_fit": null,
      "object_position": null,
      "order": null,
      "overflow": null,
      "overflow_x": null,
      "overflow_y": null,
      "padding": null,
      "right": null,
      "top": null,
      "visibility": null,
      "width": null
     }
    },
    "5ef4c12ba20f4d55a7b0fd4745d08045": {
     "model_module": "@jupyter-widgets/controls",
     "model_module_version": "1.5.0",
     "model_name": "HTMLModel",
     "state": {
      "_dom_classes": [],
      "_model_module": "@jupyter-widgets/controls",
      "_model_module_version": "1.5.0",
      "_model_name": "HTMLModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/controls",
      "_view_module_version": "1.5.0",
      "_view_name": "HTMLView",
      "description": "",
      "description_tooltip": null,
      "layout": "IPY_MODEL_5b641c2abc05496e87f7314503b05ad2",
      "placeholder": "​",
      "style": "IPY_MODEL_60e95e47af20453ba8a92126b937ed7a",
      "value": "Downloading (…)lve/main/config.json: 100%"
     }
    },
    "60e95e47af20453ba8a92126b937ed7a": {
     "model_module": "@jupyter-widgets/controls",
     "model_module_version": "1.5.0",
     "model_name": "DescriptionStyleModel",
     "state": {
      "_model_module": "@jupyter-widgets/controls",
      "_model_module_version": "1.5.0",
      "_model_name": "DescriptionStyleModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/base",
      "_view_module_version": "1.2.0",
      "_view_name": "StyleView",
      "description_width": ""
     }
    },
    "68462eb13cc74f52a6b6ed5a1b13aa90": {
     "model_module": "@jupyter-widgets/controls",
     "model_module_version": "1.5.0",
     "model_name": "HBoxModel",
     "state": {
      "_dom_classes": [],
      "_model_module": "@jupyter-widgets/controls",
      "_model_module_version": "1.5.0",
      "_model_name": "HBoxModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/controls",
      "_view_module_version": "1.5.0",
      "_view_name": "HBoxView",
      "box_style": "",
      "children": [
       "IPY_MODEL_2f44991d4e874f579e0f741080b3f6e8",
       "IPY_MODEL_141409525736449291821a2b811f9065",
       "IPY_MODEL_cf00b989763c45d0bd1c928ceeedf0e0"
      ],
      "layout": "IPY_MODEL_a9404034847842e89ac0d9cd73e4f3e8"
     }
    },
    "745e36a65e6d46c28a382ecba5d9fcd4": {
     "model_module": "@jupyter-widgets/controls",
     "model_module_version": "1.5.0",
     "model_name": "DescriptionStyleModel",
     "state": {
      "_model_module": "@jupyter-widgets/controls",
      "_model_module_version": "1.5.0",
      "_model_name": "DescriptionStyleModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/base",
      "_view_module_version": "1.2.0",
      "_view_name": "StyleView",
      "description_width": ""
     }
    },
    "7638dc3abfde421a892f517cdd95a8ad": {
     "model_module": "@jupyter-widgets/controls",
     "model_module_version": "1.5.0",
     "model_name": "ProgressStyleModel",
     "state": {
      "_model_module": "@jupyter-widgets/controls",
      "_model_module_version": "1.5.0",
      "_model_name": "ProgressStyleModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/base",
      "_view_module_version": "1.2.0",
      "_view_name": "StyleView",
      "bar_color": null,
      "description_width": ""
     }
    },
    "7c29b4845ec54c8ba06cbbb82dc93321": {
     "model_module": "@jupyter-widgets/controls",
     "model_module_version": "1.5.0",
     "model_name": "HTMLModel",
     "state": {
      "_dom_classes": [],
      "_model_module": "@jupyter-widgets/controls",
      "_model_module_version": "1.5.0",
      "_model_name": "HTMLModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/controls",
      "_view_module_version": "1.5.0",
      "_view_name": "HTMLView",
      "description": "",
      "description_tooltip": null,
      "layout": "IPY_MODEL_180c353465004567b28f28cf56852774",
      "placeholder": "​",
      "style": "IPY_MODEL_08da2f3030e4428eb1b6c215ca76e81d",
      "value": "Downloading (…)lve/main/config.json: 100%"
     }
    },
    "7c309ec75faf4cfbb1ef4dd8929693ab": {
     "model_module": "@jupyter-widgets/base",
     "model_module_version": "1.2.0",
     "model_name": "LayoutModel",
     "state": {
      "_model_module": "@jupyter-widgets/base",
      "_model_module_version": "1.2.0",
      "_model_name": "LayoutModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/base",
      "_view_module_version": "1.2.0",
      "_view_name": "LayoutView",
      "align_content": null,
      "align_items": null,
      "align_self": null,
      "border": null,
      "bottom": null,
      "display": null,
      "flex": null,
      "flex_flow": null,
      "grid_area": null,
      "grid_auto_columns": null,
      "grid_auto_flow": null,
      "grid_auto_rows": null,
      "grid_column": null,
      "grid_gap": null,
      "grid_row": null,
      "grid_template_areas": null,
      "grid_template_columns": null,
      "grid_template_rows": null,
      "height": null,
      "justify_content": null,
      "justify_items": null,
      "left": null,
      "margin": null,
      "max_height": null,
      "max_width": null,
      "min_height": null,
      "min_width": null,
      "object_fit": null,
      "object_position": null,
      "order": null,
      "overflow": null,
      "overflow_x": null,
      "overflow_y": null,
      "padding": null,
      "right": null,
      "top": null,
      "visibility": null,
      "width": null
     }
    },
    "8655a122477d497592f043955f13bfe7": {
     "model_module": "@jupyter-widgets/base",
     "model_module_version": "1.2.0",
     "model_name": "LayoutModel",
     "state": {
      "_model_module": "@jupyter-widgets/base",
      "_model_module_version": "1.2.0",
      "_model_name": "LayoutModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/base",
      "_view_module_version": "1.2.0",
      "_view_name": "LayoutView",
      "align_content": null,
      "align_items": null,
      "align_self": null,
      "border": null,
      "bottom": null,
      "display": null,
      "flex": null,
      "flex_flow": null,
      "grid_area": null,
      "grid_auto_columns": null,
      "grid_auto_flow": null,
      "grid_auto_rows": null,
      "grid_column": null,
      "grid_gap": null,
      "grid_row": null,
      "grid_template_areas": null,
      "grid_template_columns": null,
      "grid_template_rows": null,
      "height": null,
      "justify_content": null,
      "justify_items": null,
      "left": null,
      "margin": null,
      "max_height": null,
      "max_width": null,
      "min_height": null,
      "min_width": null,
      "object_fit": null,
      "object_position": null,
      "order": null,
      "overflow": null,
      "overflow_x": null,
      "overflow_y": null,
      "padding": null,
      "right": null,
      "top": null,
      "visibility": null,
      "width": null
     }
    },
    "86db8c51dadb4ae7ad398f7217519d69": {
     "model_module": "@jupyter-widgets/controls",
     "model_module_version": "1.5.0",
     "model_name": "HBoxModel",
     "state": {
      "_dom_classes": [],
      "_model_module": "@jupyter-widgets/controls",
      "_model_module_version": "1.5.0",
      "_model_name": "HBoxModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/controls",
      "_view_module_version": "1.5.0",
      "_view_name": "HBoxView",
      "box_style": "",
      "children": [
       "IPY_MODEL_7c29b4845ec54c8ba06cbbb82dc93321",
       "IPY_MODEL_e119ebbb44f24428bc2f34cc59bce58c",
       "IPY_MODEL_2c2af7b5445f4f61b9a63753b1171801"
      ],
      "layout": "IPY_MODEL_1a15e83976534eb296eac77cc39bfca8"
     }
    },
    "878992de10d64a0782e358875be7c8fa": {
     "model_module": "@jupyter-widgets/controls",
     "model_module_version": "1.5.0",
     "model_name": "DescriptionStyleModel",
     "state": {
      "_model_module": "@jupyter-widgets/controls",
      "_model_module_version": "1.5.0",
      "_model_name": "DescriptionStyleModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/base",
      "_view_module_version": "1.2.0",
      "_view_name": "StyleView",
      "description_width": ""
     }
    },
    "8ce8b968150f4a0a91c573ad63e6a944": {
     "model_module": "@jupyter-widgets/base",
     "model_module_version": "1.2.0",
     "model_name": "LayoutModel",
     "state": {
      "_model_module": "@jupyter-widgets/base",
      "_model_module_version": "1.2.0",
      "_model_name": "LayoutModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/base",
      "_view_module_version": "1.2.0",
      "_view_name": "LayoutView",
      "align_content": null,
      "align_items": null,
      "align_self": null,
      "border": null,
      "bottom": null,
      "display": null,
      "flex": null,
      "flex_flow": null,
      "grid_area": null,
      "grid_auto_columns": null,
      "grid_auto_flow": null,
      "grid_auto_rows": null,
      "grid_column": null,
      "grid_gap": null,
      "grid_row": null,
      "grid_template_areas": null,
      "grid_template_columns": null,
      "grid_template_rows": null,
      "height": null,
      "justify_content": null,
      "justify_items": null,
      "left": null,
      "margin": null,
      "max_height": null,
      "max_width": null,
      "min_height": null,
      "min_width": null,
      "object_fit": null,
      "object_position": null,
      "order": null,
      "overflow": null,
      "overflow_x": null,
      "overflow_y": null,
      "padding": null,
      "right": null,
      "top": null,
      "visibility": null,
      "width": null
     }
    },
    "8e4735513b974e09983b5d3f84302917": {
     "model_module": "@jupyter-widgets/controls",
     "model_module_version": "1.5.0",
     "model_name": "DescriptionStyleModel",
     "state": {
      "_model_module": "@jupyter-widgets/controls",
      "_model_module_version": "1.5.0",
      "_model_name": "DescriptionStyleModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/base",
      "_view_module_version": "1.2.0",
      "_view_name": "StyleView",
      "description_width": ""
     }
    },
    "8e79b9283ad244e4a54fcc335e8e870e": {
     "model_module": "@jupyter-widgets/controls",
     "model_module_version": "1.5.0",
     "model_name": "DescriptionStyleModel",
     "state": {
      "_model_module": "@jupyter-widgets/controls",
      "_model_module_version": "1.5.0",
      "_model_name": "DescriptionStyleModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/base",
      "_view_module_version": "1.2.0",
      "_view_name": "StyleView",
      "description_width": ""
     }
    },
    "9522a212c0984a62a4045df525d03390": {
     "model_module": "@jupyter-widgets/controls",
     "model_module_version": "1.5.0",
     "model_name": "HTMLModel",
     "state": {
      "_dom_classes": [],
      "_model_module": "@jupyter-widgets/controls",
      "_model_module_version": "1.5.0",
      "_model_name": "HTMLModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/controls",
      "_view_module_version": "1.5.0",
      "_view_name": "HTMLView",
      "description": "",
      "description_tooltip": null,
      "layout": "IPY_MODEL_c278ad7f27a341559548e077307ca561",
      "placeholder": "​",
      "style": "IPY_MODEL_cf3f9081fbaf4cc7a96015de86f86007",
      "value": " 4.31M/4.31M [00:00&lt;00:00, 37.8MB/s]"
     }
    },
    "9a0ed4ded9f54737ba8e5616295ce55b": {
     "model_module": "@jupyter-widgets/controls",
     "model_module_version": "1.5.0",
     "model_name": "FloatProgressModel",
     "state": {
      "_dom_classes": [],
      "_model_module": "@jupyter-widgets/controls",
      "_model_module_version": "1.5.0",
      "_model_name": "FloatProgressModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/controls",
      "_view_module_version": "1.5.0",
      "_view_name": "ProgressView",
      "bar_style": "success",
      "description": "",
      "description_tooltip": null,
      "layout": "IPY_MODEL_19f9fb0210df42ac8e1d643a05bd99f2",
      "max": 52,
      "min": 0,
      "orientation": "horizontal",
      "style": "IPY_MODEL_53aec027b46e480cb985c9c2d1683484",
      "value": 52
     }
    },
    "a55e223098a64b298b809a79438155a7": {
     "model_module": "@jupyter-widgets/controls",
     "model_module_version": "1.5.0",
     "model_name": "DescriptionStyleModel",
     "state": {
      "_model_module": "@jupyter-widgets/controls",
      "_model_module_version": "1.5.0",
      "_model_name": "DescriptionStyleModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/base",
      "_view_module_version": "1.2.0",
      "_view_name": "StyleView",
      "description_width": ""
     }
    },
    "a9404034847842e89ac0d9cd73e4f3e8": {
     "model_module": "@jupyter-widgets/base",
     "model_module_version": "1.2.0",
     "model_name": "LayoutModel",
     "state": {
      "_model_module": "@jupyter-widgets/base",
      "_model_module_version": "1.2.0",
      "_model_name": "LayoutModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/base",
      "_view_module_version": "1.2.0",
      "_view_name": "LayoutView",
      "align_content": null,
      "align_items": null,
      "align_self": null,
      "border": null,
      "bottom": null,
      "display": null,
      "flex": null,
      "flex_flow": null,
      "grid_area": null,
      "grid_auto_columns": null,
      "grid_auto_flow": null,
      "grid_auto_rows": null,
      "grid_column": null,
      "grid_gap": null,
      "grid_row": null,
      "grid_template_areas": null,
      "grid_template_columns": null,
      "grid_template_rows": null,
      "height": null,
      "justify_content": null,
      "justify_items": null,
      "left": null,
      "margin": null,
      "max_height": null,
      "max_width": null,
      "min_height": null,
      "min_width": null,
      "object_fit": null,
      "object_position": null,
      "order": null,
      "overflow": null,
      "overflow_x": null,
      "overflow_y": null,
      "padding": null,
      "right": null,
      "top": null,
      "visibility": null,
      "width": null
     }
    },
    "a943c01693aa4124a98c2e655719a11c": {
     "model_module": "@jupyter-widgets/base",
     "model_module_version": "1.2.0",
     "model_name": "LayoutModel",
     "state": {
      "_model_module": "@jupyter-widgets/base",
      "_model_module_version": "1.2.0",
      "_model_name": "LayoutModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/base",
      "_view_module_version": "1.2.0",
      "_view_name": "LayoutView",
      "align_content": null,
      "align_items": null,
      "align_self": null,
      "border": null,
      "bottom": null,
      "display": null,
      "flex": null,
      "flex_flow": null,
      "grid_area": null,
      "grid_auto_columns": null,
      "grid_auto_flow": null,
      "grid_auto_rows": null,
      "grid_column": null,
      "grid_gap": null,
      "grid_row": null,
      "grid_template_areas": null,
      "grid_template_columns": null,
      "grid_template_rows": null,
      "height": null,
      "justify_content": null,
      "justify_items": null,
      "left": null,
      "margin": null,
      "max_height": null,
      "max_width": null,
      "min_height": null,
      "min_width": null,
      "object_fit": null,
      "object_position": null,
      "order": null,
      "overflow": null,
      "overflow_x": null,
      "overflow_y": null,
      "padding": null,
      "right": null,
      "top": null,
      "visibility": null,
      "width": null
     }
    },
    "aa8684c2ea1e496a82f537fcd56fbad4": {
     "model_module": "@jupyter-widgets/base",
     "model_module_version": "1.2.0",
     "model_name": "LayoutModel",
     "state": {
      "_model_module": "@jupyter-widgets/base",
      "_model_module_version": "1.2.0",
      "_model_name": "LayoutModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/base",
      "_view_module_version": "1.2.0",
      "_view_name": "LayoutView",
      "align_content": null,
      "align_items": null,
      "align_self": null,
      "border": null,
      "bottom": null,
      "display": null,
      "flex": null,
      "flex_flow": null,
      "grid_area": null,
      "grid_auto_columns": null,
      "grid_auto_flow": null,
      "grid_auto_rows": null,
      "grid_column": null,
      "grid_gap": null,
      "grid_row": null,
      "grid_template_areas": null,
      "grid_template_columns": null,
      "grid_template_rows": null,
      "height": null,
      "justify_content": null,
      "justify_items": null,
      "left": null,
      "margin": null,
      "max_height": null,
      "max_width": null,
      "min_height": null,
      "min_width": null,
      "object_fit": null,
      "object_position": null,
      "order": null,
      "overflow": null,
      "overflow_x": null,
      "overflow_y": null,
      "padding": null,
      "right": null,
      "top": null,
      "visibility": null,
      "width": null
     }
    },
    "bdba310346de42dd8e8dbf55305f95b1": {
     "model_module": "@jupyter-widgets/controls",
     "model_module_version": "1.5.0",
     "model_name": "FloatProgressModel",
     "state": {
      "_dom_classes": [],
      "_model_module": "@jupyter-widgets/controls",
      "_model_module_version": "1.5.0",
      "_model_name": "FloatProgressModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/controls",
      "_view_module_version": "1.5.0",
      "_view_name": "ProgressView",
      "bar_style": "success",
      "description": "",
      "description_tooltip": null,
      "layout": "IPY_MODEL_bdf4cf13df9b423e85d447410d27bae4",
      "max": 579,
      "min": 0,
      "orientation": "horizontal",
      "style": "IPY_MODEL_07c3d1e6dd734ee5828b4625aaeb85b9",
      "value": 579
     }
    },
    "bdf4cf13df9b423e85d447410d27bae4": {
     "model_module": "@jupyter-widgets/base",
     "model_module_version": "1.2.0",
     "model_name": "LayoutModel",
     "state": {
      "_model_module": "@jupyter-widgets/base",
      "_model_module_version": "1.2.0",
      "_model_name": "LayoutModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/base",
      "_view_module_version": "1.2.0",
      "_view_name": "LayoutView",
      "align_content": null,
      "align_items": null,
      "align_self": null,
      "border": null,
      "bottom": null,
      "display": null,
      "flex": null,
      "flex_flow": null,
      "grid_area": null,
      "grid_auto_columns": null,
      "grid_auto_flow": null,
      "grid_auto_rows": null,
      "grid_column": null,
      "grid_gap": null,
      "grid_row": null,
      "grid_template_areas": null,
      "grid_template_columns": null,
      "grid_template_rows": null,
      "height": null,
      "justify_content": null,
      "justify_items": null,
      "left": null,
      "margin": null,
      "max_height": null,
      "max_width": null,
      "min_height": null,
      "min_width": null,
      "object_fit": null,
      "object_position": null,
      "order": null,
      "overflow": null,
      "overflow_x": null,
      "overflow_y": null,
      "padding": null,
      "right": null,
      "top": null,
      "visibility": null,
      "width": null
     }
    },
    "c278ad7f27a341559548e077307ca561": {
     "model_module": "@jupyter-widgets/base",
     "model_module_version": "1.2.0",
     "model_name": "LayoutModel",
     "state": {
      "_model_module": "@jupyter-widgets/base",
      "_model_module_version": "1.2.0",
      "_model_name": "LayoutModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/base",
      "_view_module_version": "1.2.0",
      "_view_name": "LayoutView",
      "align_content": null,
      "align_items": null,
      "align_self": null,
      "border": null,
      "bottom": null,
      "display": null,
      "flex": null,
      "flex_flow": null,
      "grid_area": null,
      "grid_auto_columns": null,
      "grid_auto_flow": null,
      "grid_auto_rows": null,
      "grid_column": null,
      "grid_gap": null,
      "grid_row": null,
      "grid_template_areas": null,
      "grid_template_columns": null,
      "grid_template_rows": null,
      "height": null,
      "justify_content": null,
      "justify_items": null,
      "left": null,
      "margin": null,
      "max_height": null,
      "max_width": null,
      "min_height": null,
      "min_width": null,
      "object_fit": null,
      "object_position": null,
      "order": null,
      "overflow": null,
      "overflow_x": null,
      "overflow_y": null,
      "padding": null,
      "right": null,
      "top": null,
      "visibility": null,
      "width": null
     }
    },
    "c8d9448b21494b1d922f44bf0168560b": {
     "model_module": "@jupyter-widgets/controls",
     "model_module_version": "1.5.0",
     "model_name": "DescriptionStyleModel",
     "state": {
      "_model_module": "@jupyter-widgets/controls",
      "_model_module_version": "1.5.0",
      "_model_name": "DescriptionStyleModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/base",
      "_view_module_version": "1.2.0",
      "_view_name": "StyleView",
      "description_width": ""
     }
    },
    "cf00b989763c45d0bd1c928ceeedf0e0": {
     "model_module": "@jupyter-widgets/controls",
     "model_module_version": "1.5.0",
     "model_name": "HTMLModel",
     "state": {
      "_dom_classes": [],
      "_model_module": "@jupyter-widgets/controls",
      "_model_module_version": "1.5.0",
      "_model_name": "HTMLModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/controls",
      "_view_module_version": "1.5.0",
      "_view_name": "HTMLView",
      "description": "",
      "description_tooltip": null,
      "layout": "IPY_MODEL_e0843b4cb8b24cd48703671a94930f38",
      "placeholder": "​",
      "style": "IPY_MODEL_557c87612c124071bc3571c1e3020328",
      "value": " 52.0/52.0 [00:00&lt;00:00, 610B/s]"
     }
    },
    "cf3f9081fbaf4cc7a96015de86f86007": {
     "model_module": "@jupyter-widgets/controls",
     "model_module_version": "1.5.0",
     "model_name": "DescriptionStyleModel",
     "state": {
      "_model_module": "@jupyter-widgets/controls",
      "_model_module_version": "1.5.0",
      "_model_name": "DescriptionStyleModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/base",
      "_view_module_version": "1.2.0",
      "_view_name": "StyleView",
      "description_width": ""
     }
    },
    "d2a9cc9a859747108a893d0cc09757bd": {
     "model_module": "@jupyter-widgets/controls",
     "model_module_version": "1.5.0",
     "model_name": "DescriptionStyleModel",
     "state": {
      "_model_module": "@jupyter-widgets/controls",
      "_model_module_version": "1.5.0",
      "_model_name": "DescriptionStyleModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/base",
      "_view_module_version": "1.2.0",
      "_view_name": "StyleView",
      "description_width": ""
     }
    },
    "d3e617bfbf7042229b9d31156963cc87": {
     "model_module": "@jupyter-widgets/controls",
     "model_module_version": "1.5.0",
     "model_name": "ProgressStyleModel",
     "state": {
      "_model_module": "@jupyter-widgets/controls",
      "_model_module_version": "1.5.0",
      "_model_name": "ProgressStyleModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/base",
      "_view_module_version": "1.2.0",
      "_view_name": "StyleView",
      "bar_color": null,
      "description_width": ""
     }
    },
    "dd214f9ec2704ecc9cc80add80c85517": {
     "model_module": "@jupyter-widgets/controls",
     "model_module_version": "1.5.0",
     "model_name": "FloatProgressModel",
     "state": {
      "_dom_classes": [],
      "_model_module": "@jupyter-widgets/controls",
      "_model_module_version": "1.5.0",
      "_model_name": "FloatProgressModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/controls",
      "_view_module_version": "1.5.0",
      "_view_name": "ProgressView",
      "bar_style": "success",
      "description": "",
      "description_tooltip": null,
      "layout": "IPY_MODEL_e793c187ff3045f8907938d235528239",
      "max": 4305025,
      "min": 0,
      "orientation": "horizontal",
      "style": "IPY_MODEL_7638dc3abfde421a892f517cdd95a8ad",
      "value": 4305025
     }
    },
    "e0843b4cb8b24cd48703671a94930f38": {
     "model_module": "@jupyter-widgets/base",
     "model_module_version": "1.2.0",
     "model_name": "LayoutModel",
     "state": {
      "_model_module": "@jupyter-widgets/base",
      "_model_module_version": "1.2.0",
      "_model_name": "LayoutModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/base",
      "_view_module_version": "1.2.0",
      "_view_name": "LayoutView",
      "align_content": null,
      "align_items": null,
      "align_self": null,
      "border": null,
      "bottom": null,
      "display": null,
      "flex": null,
      "flex_flow": null,
      "grid_area": null,
      "grid_auto_columns": null,
      "grid_auto_flow": null,
      "grid_auto_rows": null,
      "grid_column": null,
      "grid_gap": null,
      "grid_row": null,
      "grid_template_areas": null,
      "grid_template_columns": null,
      "grid_template_rows": null,
      "height": null,
      "justify_content": null,
      "justify_items": null,
      "left": null,
      "margin": null,
      "max_height": null,
      "max_width": null,
      "min_height": null,
      "min_width": null,
      "object_fit": null,
      "object_position": null,
      "order": null,
      "overflow": null,
      "overflow_x": null,
      "overflow_y": null,
      "padding": null,
      "right": null,
      "top": null,
      "visibility": null,
      "width": null
     }
    },
    "e119ebbb44f24428bc2f34cc59bce58c": {
     "model_module": "@jupyter-widgets/controls",
     "model_module_version": "1.5.0",
     "model_name": "FloatProgressModel",
     "state": {
      "_dom_classes": [],
      "_model_module": "@jupyter-widgets/controls",
      "_model_module_version": "1.5.0",
      "_model_name": "FloatProgressModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/controls",
      "_view_module_version": "1.5.0",
      "_view_name": "ProgressView",
      "bar_style": "success",
      "description": "",
      "description_tooltip": null,
      "layout": "IPY_MODEL_3262ac452db747339fc44ebe46f0c148",
      "max": 579,
      "min": 0,
      "orientation": "horizontal",
      "style": "IPY_MODEL_16434e01599742e7923a83c5851130ef",
      "value": 579
     }
    },
    "e793c187ff3045f8907938d235528239": {
     "model_module": "@jupyter-widgets/base",
     "model_module_version": "1.2.0",
     "model_name": "LayoutModel",
     "state": {
      "_model_module": "@jupyter-widgets/base",
      "_model_module_version": "1.2.0",
      "_model_name": "LayoutModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/base",
      "_view_module_version": "1.2.0",
      "_view_name": "LayoutView",
      "align_content": null,
      "align_items": null,
      "align_self": null,
      "border": null,
      "bottom": null,
      "display": null,
      "flex": null,
      "flex_flow": null,
      "grid_area": null,
      "grid_auto_columns": null,
      "grid_auto_flow": null,
      "grid_auto_rows": null,
      "grid_column": null,
      "grid_gap": null,
      "grid_row": null,
      "grid_template_areas": null,
      "grid_template_columns": null,
      "grid_template_rows": null,
      "height": null,
      "justify_content": null,
      "justify_items": null,
      "left": null,
      "margin": null,
      "max_height": null,
      "max_width": null,
      "min_height": null,
      "min_width": null,
      "object_fit": null,
      "object_position": null,
      "order": null,
      "overflow": null,
      "overflow_x": null,
      "overflow_y": null,
      "padding": null,
      "right": null,
      "top": null,
      "visibility": null,
      "width": null
     }
    },
    "f77ca69f93404b1cb5992727d2cb8341": {
     "model_module": "@jupyter-widgets/base",
     "model_module_version": "1.2.0",
     "model_name": "LayoutModel",
     "state": {
      "_model_module": "@jupyter-widgets/base",
      "_model_module_version": "1.2.0",
      "_model_name": "LayoutModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/base",
      "_view_module_version": "1.2.0",
      "_view_name": "LayoutView",
      "align_content": null,
      "align_items": null,
      "align_self": null,
      "border": null,
      "bottom": null,
      "display": null,
      "flex": null,
      "flex_flow": null,
      "grid_area": null,
      "grid_auto_columns": null,
      "grid_auto_flow": null,
      "grid_auto_rows": null,
      "grid_column": null,
      "grid_gap": null,
      "grid_row": null,
      "grid_template_areas": null,
      "grid_template_columns": null,
      "grid_template_rows": null,
      "height": null,
      "justify_content": null,
      "justify_items": null,
      "left": null,
      "margin": null,
      "max_height": null,
      "max_width": null,
      "min_height": null,
      "min_width": null,
      "object_fit": null,
      "object_position": null,
      "order": null,
      "overflow": null,
      "overflow_x": null,
      "overflow_y": null,
      "padding": null,
      "right": null,
      "top": null,
      "visibility": null,
      "width": null
     }
    },
    "fe8309ff14cd40d5a9e29a4e45aa2ce7": {
     "model_module": "@jupyter-widgets/base",
     "model_module_version": "1.2.0",
     "model_name": "LayoutModel",
     "state": {
      "_model_module": "@jupyter-widgets/base",
      "_model_module_version": "1.2.0",
      "_model_name": "LayoutModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/base",
      "_view_module_version": "1.2.0",
      "_view_name": "LayoutView",
      "align_content": null,
      "align_items": null,
      "align_self": null,
      "border": null,
      "bottom": null,
      "display": null,
      "flex": null,
      "flex_flow": null,
      "grid_area": null,
      "grid_auto_columns": null,
      "grid_auto_flow": null,
      "grid_auto_rows": null,
      "grid_column": null,
      "grid_gap": null,
      "grid_row": null,
      "grid_template_areas": null,
      "grid_template_columns": null,
      "grid_template_rows": null,
      "height": null,
      "justify_content": null,
      "justify_items": null,
      "left": null,
      "margin": null,
      "max_height": null,
      "max_width": null,
      "min_height": null,
      "min_width": null,
      "object_fit": null,
      "object_position": null,
      "order": null,
      "overflow": null,
      "overflow_x": null,
      "overflow_y": null,
      "padding": null,
      "right": null,
      "top": null,
      "visibility": null,
      "width": null
     }
    }
   }
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}