The_MRC_data_creation.ipynb

{
  "cells": [
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "VvC-bbcRxxcY",
        "outputId": "a1365cd2-27d4-423c-e131-4f65bc69022c"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Drive already mounted at /content/drive; to attempt to forcibly remount, call drive.mount(\"/content/drive\", force_remount=True).\n"
          ]
        }
      ],
      "source": [
        "from google.colab import drive\n",
        "drive.mount('/content/drive')"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "zJxC1_Gh731r",
        "outputId": "e1101fc3-9c8a-42b7-a946-0da2a39432ed"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "/content/drive/MyDrive/Notebooks/LDSI/data\n"
          ]
        }
      ],
      "source": [
        "%cd /content/drive/MyDrive/Notebooks/LDSI/data"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "aW9Ub9B3CQRJ"
      },
      "outputs": [],
      "source": [
        "import json\n",
        "\n",
        "f = open('train.json')\n",
        "f2 = open('dev.json')\n",
        "old_train = json.load(f)\n",
        "old_dev = json.load(f2)\n",
        "#list: old_train. dict:old['document_number'] = {dict_keys(['id', 'annotations', 'data', 'meta'])}\n",
        "#old_train[i_document_number]['annotations'][0].keys()['result'][j_sentence_number].keys() = { 'id', 'value'.keys() = {'end','start','labels',''text'} }"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "FOeNBvhzCcbe"
      },
      "outputs": [],
      "source": [
        "#old_train[0]['annotations'][0]['result'][0]['value']"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "LABELS = [#\"MASK\",\n",
        "          \"PREAMBLE\", \"NONE\", \"FAC\", \"ISSUE\", \"ARG_RESPONDENT\", \"ARG_PETITIONER\", \"ANALYSIS\", \"PRE_RELIED\",\n",
        "              \"PRE_NOT_RELIED\", \"STA\", \"RLC\", \"RPC\", \"RATIO\"]\n",
        "\n",
        "label_definition = [#\"MASK\",\n",
        "                    \"A typical judgement would start with the court name, the details of parties, lawyers and judges names, Headnotes. This section typically would end with a keyword like (JUDGEMENT or ORDER etc.)Some supreme court cases also have HEADNOTES, ACTS section. They are also part of Preamble.\",\n",
        "                    \"If a sentence does not belong to any of the above categories E.g. We have considered the submissions made by learned counsel for the parties and have perused the record.\",\n",
        "                    \"This refers to the chronology of events (but not judgement by lower court) that led to filing the case, and how the case evolved over time in the legal system.\",\n",
        "                    \"Some judgements mention the key points on which the verdict needs to be delivered. Such Legal Questions Framed by the Court are ISSUES.\",\n",
        "                    \"Arguments by respondents lawyers. Precedent cases argued by respondent lawyers fall under this but when court discusses them later then they belong to either the relied / not relied upon category.\",\n",
        "                    \"Arguments by petitioners' lawyers. Precedent cases argued by petitioner lawyers fall under this but when court discusses them later then they belong to either the relied / not relied upon category.\",\n",
        "                    \"Courts discussion on the evidence,facts presented,prior cases and statutes. These are views of the court. Discussions on how the law is applicable or not applicable to current case. Observations(non binding) from court.\",\n",
        "                    \"Sentences in which the court discusses prior case documents, discussions and decisions which were relied upon by the court for final decisions.So Precedent will have both the tags Analysis + Precedent.\",\n",
        "                    \"Sentences in which the court discusses prior case documents, discussions and decisions which were not relied upon by the court for final decisions. It could be due to the fact that the situation in that case is not relevant to the current case.\",\n",
        "                    \"Text in which the court discusses Established laws, which can come from a mixture of sources – Acts , Sections, Articles, Rules, Order, Notices, Notifications, Quotations directly from the bare act, and so on. Statute will have both the tags Analysis + Statute\",\n",
        "                    \"Judgments given by the lower courts (Trial Court, High Court) based on which the present appeal was made (to the Supreme Court or high court). The verdict of the lower Court, Analysis & the ratio behind the judgement by the lower Court is annotated with this label.\",\n",
        "                    \"Final decision + conclusion + order of the Court following from the natural / logical outcome of the rationale.\",\n",
        "                    \"Main Reason given for the application of any legal principle to the legal issue. This is the result of the analysis by the court. This typically appears right before the final decision. This is not the same as “Ratio Decidendi” taught in the Legal Academic curriculum.\"]\n",
        "\n",
        "print(len(LABELS))\n",
        "print(len(label_definition))\n",
        "                    "
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "xjqOqcYxDL0L",
        "outputId": "6f720d66-4740-4e45-d9d5-1a41fc1b0bef"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "13\n",
            "13\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "#print(old_train[0]['annotations'][0]['result'][1]['value']['text'])\n",
        "#print(old_train[0]['annotations'][0]['result'][1]['value']['labels'])\n",
        "print(old_train[0]['id'])\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "fI_9dr4wu87n",
        "outputId": "8ad0058b-59a0-406e-e334-09e5efd5b7ea"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "4203\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [],
      "metadata": {
        "id": "cjCs2Ewru77x"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "#list: old_train. dict:old['document_number'] = {dict_keys(['id', 'annotations', 'data', 'meta'])}\n",
        "#old_train[i_document_number]['annotations'][0]['result'][j_sentence_number].keys() = { 'id', 'value'.keys() = {'end','start','labels',''text'} }\n",
        "\n",
        "def create_new_data_dictionary(data_dict):\n",
        "  new_data = list()\n",
        "  for k in range(len(LABELS)):\n",
        "    label = LABELS[k]\n",
        "    #print(label)\n",
        "    for i in range(len(data_dict)):#document access\n",
        "      x = data_dict[i]['annotations'][0]['result']\n",
        "      id = data_dict[i]['id']\n",
        "      new_id = id*10 + k\n",
        "      doc = {}\n",
        "      #doc['id'] = new_id\n",
        "      sentences = list()\n",
        "      \n",
        "      for j in range(len(x)):#sentece access\n",
        "        sentence_x = {}\n",
        "        #print(x[j].keys())\n",
        "        old_label = x[j]['value']['labels'][0]\n",
        "        new_label = 0\n",
        "        if label == old_label:\n",
        "          new_label = 1\n",
        "        new_text = label+'. '+label_definition[k]+' '+x[j]['value']['text']\n",
        "        sentence_x['old_label'] = old_label\n",
        "        sentence_x['new_label'] = new_label\n",
        "        sentence_x['new_text'] = new_text\n",
        "        sentence_x['old_text'] = x[j]['value']['text']\n",
        "      \n",
        "        sentences.append(sentence_x)\n",
        "      doc['data'] = sentences\n",
        "      doc['id'] = new_id\n",
        "    \n",
        "      new_data.append(doc)\n",
        "  return new_data\n",
        "\n",
        "\n",
        "\n",
        "\n"
      ],
      "metadata": {
        "id": "txQUZVyAFkI9"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "RT8e3i95tl7R"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "new_train = create_new_data_dictionary(old_train)\n",
        "new_dev = create_new_data_dictionary(old_dev)"
      ],
      "metadata": {
        "id": "61JRiTADY412"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "for i in range(14):\n",
        "  print(i*247)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "7xE14sg1aE9X",
        "outputId": "e5da8954-eca2-4107-e2fe-4b3467655730"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "0\n",
            "247\n",
            "494\n",
            "741\n",
            "988\n",
            "1235\n",
            "1482\n",
            "1729\n",
            "1976\n",
            "2223\n",
            "2470\n",
            "2717\n",
            "2964\n",
            "3211\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "print(new_train[1482]['id'])\n",
        "print(new_train[1482]['data'][0])"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "030amIqya17Y",
        "outputId": "b1b17470-cc08-4979-e969-31c0a562918d"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "42036\n",
            "{'old_label': 'ANALYSIS', 'new_label': 1, 'new_text': 'ANALYSIS. Courts discussion on the evidence,facts presented,prior cases and statutes. These are views of the court. Discussions on how the law is applicable or not applicable to current case. Observations(non binding) from court. $~26\\n*       IN THE HIGH COURT OF DELHI AT NEW DELHI', 'old_text': '$~26\\n*       IN THE HIGH COURT OF DELHI AT NEW DELHI'}\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "import pandas as pd\n",
        "\n",
        "import warnings\n",
        "warnings.filterwarnings('ignore')\n",
        "\n",
        "pd.set_option('display.max_columns', None)"
      ],
      "metadata": {
        "id": "t45flFQ2ybZA"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "!pip install transformers\n",
        "!pip install allennlp\n",
        "!pip install --upgrade google-cloud-storage"
      ],
      "metadata": {
        "id": "QhTX30leyQ8S"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "!pip install torchtext"
      ],
      "metadata": {
        "id": "EzB_z9A8yaNe"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "import os\n",
        "import re\n",
        "import torchtext\n",
        "import json\n",
        "from tqdm.notebook import tqdm\n",
        "from torch.utils.data import Dataset, DataLoader\n",
        "from transformers import AutoTokenizer\n",
        "from sklearn.preprocessing import MultiLabelBinarizer, StandardScaler, KBinsDiscretizer\n",
        "import numpy as np"
      ],
      "metadata": {
        "id": "Vc_IlfS0cCEQ"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "class RRDataset(Dataset):\n",
        "  def __init__(self, new_data_dict, tokenizer_path, max_len):\n",
        "    self.encoding = []\n",
        "    self.labels = []\n",
        "    self.tokenizer = AutoTokenizer.from_pretrained(tokenizer_path)\n",
        "    self.sep_token_id = self.tokenizer.sep_token_id\n",
        "    self.pad_token_id = self.tokenizer.pad_token_id\n",
        "    #self.label_to_ind = label_to_ind\n",
        "    self.max_len = max_len\n",
        "\n",
        "    ans = map(self.parse_doc,new_data_dict)\n",
        "    text_labels = list(ans)\n",
        "    self.text = [x[1] for x in text_labels]\n",
        "    self.labels = [x[0] for x in text_labels]\n",
        "    self.id = [x[2] for x in text_labels]\n",
        "    self.text, self.labels, self.id = zip(*list(filter(lambda x: (len(x[0]) > 0 and len(x[1]) > 0), zip(self.text, self.labels,self.id))))\n",
        "\n",
        "    return\n",
        "\n",
        "\n",
        "  def __len__(self):\n",
        "    return len(self.labels)\n",
        "\n",
        "\n",
        "  def __getitem__(self, item):\n",
        "    return (self.text[item], self.labels[item], self.id[item])\n",
        "  \n",
        "  def parse_doc(self,x):\n",
        "    doc_labels, text = [],[]\n",
        "    #print(x)\n",
        "    id = x['id']\n",
        "    #print(x.keys())\n",
        "    sentences = x['data']\n",
        "    for sentence in sentences:\n",
        "        #doc_labels.append(sentence['value']['labels'][0])\n",
        "        doc_labels.append(sentence['new_label'])\n",
        "        #text.append(sentence['value']['text'])\n",
        "        text.append(self.tokenizer.encode(sentence['new_text'])[:self.max_len])\n",
        "    return (doc_labels, text, id)"
      ],
      "metadata": {
        "id": "c58jR48V-QgC"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "bert_model = \"zlucia/custom-legalbert\"\n",
        "\n",
        "train_dataset = RRDataset(new_train,tokenizer_path = bert_model,  max_len = 128)\n",
        "dev_dataset = RRDataset(new_dev,tokenizer_path = bert_model, max_len = 128)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 145,
          "referenced_widgets": [
            "4102092d0efd43cdb1b004c5572da0f9",
            "6a57363331524b13bd6a6da1b44e8084",
            "25360f03287541be88f7e577b3204732",
            "e218f1f6295b49b89f1b89f913489267",
            "8027c36c1d134f048b429f81b5d56610",
            "ef48424a33414e95897194747337ad66",
            "811e7bba7790479e8435699d216931b3",
            "e45f4783d184447b8cc93aeb5a7167ad",
            "5537cb517ed8447c85ac07bc637ce587",
            "821b4c62fb67409baeca4b0435c0d5ba",
            "a5f4831edc1648c993b7b4ec24beb511",
            "5b42fe40c9b34e5f849c7fb869268401",
            "fc93d4df58b84538bf82ef3b7a7498f7",
            "2f291d725a2640bd8c8f7ac5ca1b4ae5",
            "77980e836290411ca35971c5055b69be",
            "df26225cc73948c0bb35cb490b1c7cfa",
            "00c1dd1a42234e8b9f71995b32fba821",
            "160983fa69a040c3b3d148f71ef825dd",
            "e716deabae93414cba71923849752ca0",
            "1faf76ee65044a8391c0c65dc61981bd",
            "582c2227093044b2b45c02a1a3c2fa9f",
            "0cd52f4e15a148b5b13ad86e445fe6db",
            "fb047f147f7e413a8addcc1978e0ea76",
            "908b19ea547b46b297c864b3bc6cce4d",
            "bf6597126c934fdb9d0b7ce943f750ca",
            "1098098593f345c4be0fae9359dca92b",
            "8bafc463461b42cc90b290e065e703e1",
            "39d9922d02c44c2391d960004e5114bb",
            "02f2cd86778049a49a4946ec276a6048",
            "0426dd947ae244dea1d03042d42140c1",
            "bde4e397ea89436490912eef27121164",
            "4e39809631cc4315ab9e25cdffea4ff3",
            "9faf58bc5fe1467cb6958c9b57819bed",
            "e1ef774e1ae54405b28b9ab043d2ab2c",
            "e1b0e25268cb4c7887105cca9ac94f82",
            "cd05ab87b3c3463b93351ab82e1a93b9",
            "f32ea568ef214b4db34d8da601ede4fa",
            "202974d4a5404647b3f3aade5236473c",
            "6c04472103ca403788ad65541990c0cd",
            "2746d87451a24a0c8d5ed933ddef7f9b",
            "a98b5e4d30014596b50b14b76fa6aa29",
            "124672fc6c5b47e5aff604fa8517f5e0",
            "76752a2a4b3b40c1bcb31683891e59ae",
            "9e6899efa51b40d18655da8822de36c7"
          ]
        },
        "id": "wgxdqQyo_hSx",
        "outputId": "b99fc67d-8cb7-4a2f-f8dd-0637073dc39d"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "Downloading:   0%|          | 0.00/307 [00:00<?, ?B/s]"
            ],
            "application/vnd.jupyter.widget-view+json": {
              "version_major": 2,
              "version_minor": 0,
              "model_id": "4102092d0efd43cdb1b004c5572da0f9"
            }
          },
          "metadata": {}
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "Downloading:   0%|          | 0.00/747 [00:00<?, ?B/s]"
            ],
            "application/vnd.jupyter.widget-view+json": {
              "version_major": 2,
              "version_minor": 0,
              "model_id": "5b42fe40c9b34e5f849c7fb869268401"
            }
          },
          "metadata": {}
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "Downloading:   0%|          | 0.00/245k [00:00<?, ?B/s]"
            ],
            "application/vnd.jupyter.widget-view+json": {
              "version_major": 2,
              "version_minor": 0,
              "model_id": "fb047f147f7e413a8addcc1978e0ea76"
            }
          },
          "metadata": {}
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "Downloading:   0%|          | 0.00/112 [00:00<?, ?B/s]"
            ],
            "application/vnd.jupyter.widget-view+json": {
              "version_major": 2,
              "version_minor": 0,
              "model_id": "e1ef774e1ae54405b28b9ab043d2ab2c"
            }
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "#x,y,z = train_dataset.__getitem__(0)"
      ],
      "metadata": {
        "id": "mBfC7ACp_jCb"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "zVok31ztFI2p"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "9-y0cgUfFKTU"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "from allennlp.data.dataset_readers.dataset_utils import enumerate_spans\n",
        "import torch\n",
        "\n",
        "class MyCollate:\n",
        "    def __init__(self, pad_idx, sep_idx, max_width, label_to_ind):\n",
        "        self.pad_token_id = pad_idx\n",
        "        self.sep_token_id = sep_idx\n",
        "        self.max_width = max_width\n",
        "        self.label_to_ind = label_to_ind\n",
        "\n",
        "    def pad_sentence_for_batch(self, tokens_lists, max_len: int):\n",
        "        pad_id = self.pad_token_id\n",
        "        toks_ids = []\n",
        "        att_masks = []\n",
        "        for item_toks in tokens_lists:\n",
        "            padded_item_toks = item_toks + [pad_id] * (max_len - len(item_toks))\n",
        "            toks_ids.append(padded_item_toks)\n",
        "\n",
        "            att_mask = [1] * len(item_toks) + [0] * (max_len - len(item_toks))\n",
        "            att_masks.append(att_mask)\n",
        "            \n",
        "        return toks_ids, att_masks\n",
        "    \n",
        "    def pad_doc_for_batch(self, doc_lengths, labels, segment_ids, max_len):\n",
        "        lab_masks = []\n",
        "        sent_masks = []\n",
        "        seg_masks = []\n",
        "        for i  in range(len(labels)):\n",
        "          lab_item = labels[i] + [self.label_to_ind['MASK']]*(max_len - len(labels[i]))\n",
        "          lab_masks.append(lab_item)\n",
        "\n",
        "          seg_item = segment_ids[i] + [0]*(max_len - len(segment_ids[i]))\n",
        "          seg_masks.append(seg_item)\n",
        "\n",
        "          each_sent_mask = [1] * doc_lengths[i] + [0] * (max_len- doc_lengths[i])\n",
        "          sent_masks.append(each_sent_mask)\n",
        "\n",
        "        return sent_masks, lab_masks, seg_masks\n",
        "\n",
        "    def span_enumeration(self, sent_masks, max_width):\n",
        "        all_span_ids = []\n",
        "        for each in range(len(sent_masks)):\n",
        "            each_span_ids = enumerate_spans(sent_masks[each][(sent_masks[each].nonzero())], offset=0, max_span_width=max_width)\n",
        "            #each_span_ids = enumerate_spans(x[\"sentence_mask\"][each], offset=0, max_span_width=3)\n",
        "            all_span_ids.append(each_span_ids)\n",
        "\n",
        "        max_span_len = max([len(x) for x in all_span_ids])\n",
        "        span_ids = [x+[[0,0]]*(max_span_len-len(x)) for x in all_span_ids]\n",
        "        return span_ids\n",
        "    \n",
        "    \n",
        "    def seg_mask_fix(self,seg_inds):\n",
        "        max_path = self.max_width\n",
        "        counter = np.zeros((len(seg_inds)), dtype=np.int32)\n",
        "        seg_inds_fix = []\n",
        "        for b,  sent_inds in enumerate(seg_inds):\n",
        "            counter = 0\n",
        "            new_inds = []\n",
        "            for i , flag in enumerate(sent_inds):\n",
        "                path_flag = (counter >= max_path-1)\n",
        "                    \n",
        "                mask_step = flag | path_flag\n",
        "                new_inds.append(mask_step)\n",
        "                counter = counter + 1\n",
        "                counter = (1- mask_step)*counter*(counter < max_path)\n",
        "                \n",
        "            seg_inds_fix.append(new_inds)     \n",
        "        return seg_inds_fix\n",
        "\n",
        "    \n",
        "    def convert_labels_to_segments(self,labels):\n",
        "      seg_ids = []\n",
        "      for i  in range(len(labels)):\n",
        "          each_seg_id = []\n",
        "          prev = labels[i][0]\n",
        "          each_seg_id.append(0)\n",
        "          for j in range(1,len(labels[i])):\n",
        "              if(prev != labels[i][j]):\n",
        "                  each_seg_id[len(each_seg_id)-1] = 1\n",
        "                  each_seg_id.append(0)\n",
        "                  prev = labels[i][j]\n",
        "              else:\n",
        "                  each_seg_id.append(0)\n",
        "          each_seg_id[len(each_seg_id)-1] = 1\n",
        "          seg_ids.append(each_seg_id)\n",
        "      segments = self.seg_mask_fix(seg_ids)\n",
        "      return segments\n",
        "\n",
        "    def __call__(self, batch):\n",
        "        batch = filter(lambda x: x is not None, batch)\n",
        "        docs , labels, id = list(zip(*batch))\n",
        "        doc_lengths = [len(x) for x in docs]\n",
        "        sent_lengths = []\n",
        "        for element in docs:\n",
        "          sent_lengths.append([len(i) for i in element])\n",
        "        \n",
        "        batch_sz = len(id)\n",
        "        batch_max_doc_length = max(doc_lengths)\n",
        "        batch_max_sent_length = max([max(sl) for sl in sent_lengths])\n",
        "\n",
        "        docs_tensor = torch.zeros((batch_sz, batch_max_doc_length, batch_max_sent_length), dtype=torch.long)\n",
        "        att_mask = torch.zeros((batch_sz, batch_max_doc_length, batch_max_sent_length), dtype=torch.long)\n",
        "\n",
        "        segments = self.convert_labels_to_segments(labels)\n",
        "        padded_sent_mask, padded_label_id, padded_segments = self.pad_doc_for_batch(doc_lengths, labels, segments, batch_max_doc_length)\n",
        "\n",
        "        label_ids = torch.tensor(padded_label_id , dtype=torch.long)\n",
        "        segment_ids = torch.tensor(padded_segments , dtype=torch.long)\n",
        "        sent_mask = torch.tensor(padded_sent_mask, dtype=torch.long)\n",
        "\n",
        "        spans = torch.tensor(self.span_enumeration(sent_mask, self.max_width), dtype = torch.long)\n",
        "\n",
        "        for doc_idx, doc in enumerate(docs):\n",
        "            padded_token_lists, att_mask_lists = self.pad_sentence_for_batch(doc, batch_max_sent_length)\n",
        "\n",
        "            for sent_idx, (padded_tokens, att_masks) in enumerate(\n",
        "                    zip(padded_token_lists, att_mask_lists)):\n",
        "                docs_tensor[doc_idx, sent_idx, :] = torch.tensor(padded_tokens, dtype=torch.long)\n",
        "                att_mask[doc_idx, sent_idx, :] = torch.tensor(att_masks, dtype=torch.long)\n",
        "        \n",
        "\n",
        "        output = {\n",
        "            \"sentence_mask\": torch.tensor(sent_mask),\n",
        "            \"input_ids\": torch.tensor(docs_tensor),\n",
        "            \"attention_mask\": torch.tensor(att_mask),\n",
        "            \"label_ids\": torch.tensor(label_ids),\n",
        "            \"segment_mask\": torch.tensor(segment_ids),\n",
        "            \"span_indices\": torch.tensor(spans),\n",
        "            \"doc_name\": id\n",
        "        }\n",
        "        return output\n",
        "        "
      ],
      "metadata": {
        "id": "x0VP4vMaFbtY"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "label_to_ind = {}\n",
        "label_to_ind['0'] = 0\n",
        "label_to_ind['1'] = 1\n",
        "label_to_ind['MASK'] = 2\n",
        "label_to_ind['START'] = 3\n",
        "label_to_ind['STOP'] = 4"
      ],
      "metadata": {
        "id": "8BZt9cgWJeiG"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "train_dataloader =  DataLoader(train_dataset, batch_size=1, shuffle=True, collate_fn = MyCollate(pad_idx = train_dataset.pad_token_id, sep_idx = train_dataset.pad_token_id, max_width = 1,label_to_ind=label_to_ind))\n",
        "\n",
        "dev_dataloader =  DataLoader(dev_dataset, batch_size=1, shuffle=True, collate_fn = MyCollate(pad_idx = train_dataset.pad_token_id, sep_idx = train_dataset.pad_token_id, max_width = 1,label_to_ind=label_to_ind))"
      ],
      "metadata": {
        "id": "E_GV-Vh5J9t4"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "for batch_idx, x in tqdm(enumerate(train_dataloader),total=len(train_dataloader), leave=False):\n",
        "      #print(x[\"sentence_mask\"], x[\"input_ids\"],x[\"attention_mask\"], x[\"label_ids\"])\n",
        "      print(x[\"sentence_mask\"].shape, x[\"input_ids\"].shape,x[\"attention_mask\"].shape, x[\"label_ids\"].shape, x[\"doc_name\"],x[\"span_indices\"].shape,x[\"segment_mask\"].shape)\n",
        "      #print(x['span_indices'])\n",
        "      print(x['label_ids'])\n",
        "      print(x[\"segment_mask\"])\n",
        "      break"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 205,
          "referenced_widgets": [
            "2c2be68a7811405cae35755b7c7837be",
            "4e5df798f71e4e22a2e5acc5a88b7096",
            "09ea0a6e4d6e4349b18885f2755a55fa",
            "b649705caf8241e7a51f5fa1d0a07057",
            "bf384cbdb2ce48fabd2d9e5c8f76f0c2",
            "6e7e3e94918c42258c1b5c0880017903",
            "e5a4fdf16dbc49e6a669b40d0af8e3c1",
            "839b67fbea974c089655de010c30e7fd",
            "cc503c5ccfdb43008744ebd0ae341780",
            "41fbf948af614e3dbf9f4ee4e8c7875f",
            "0e1ad1fbe4b746f5874668593997ad85"
          ]
        },
        "id": "lnjSKcQnKWN1",
        "outputId": "4b0eb495-66f1-4c49-a2fa-3c55ee853ab2"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "  0%|          | 0/3185 [00:00<?, ?it/s]"
            ],
            "application/vnd.jupyter.widget-view+json": {
              "version_major": 2,
              "version_minor": 0,
              "model_id": "2c2be68a7811405cae35755b7c7837be"
            }
          },
          "metadata": {}
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "torch.Size([1, 88]) torch.Size([1, 88, 128]) torch.Size([1, 88, 128]) torch.Size([1, 88]) (17475,) torch.Size([1, 88, 2]) torch.Size([1, 88])\n",
            "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, 1, 1, 1, 1, 0,\n",
            "         0, 0, 0, 0, 1, 1, 1, 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, 1, 0, 0, 0, 0]])\n",
            "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, 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, 1, 1, 1, 1,\n",
            "         1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]])\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "import torch \n",
        "import torch.nn as nn\n",
        "import numpy as np\n",
        "from torch.autograd import Variable\n",
        "\n",
        "\n",
        "class SpanCRF(nn.Module):\n",
        "    def __init__(self,  label_to_ind, max_path):\n",
        "        super(SpanCRF, self).__init__()\n",
        "\n",
        "        self.tag_to_ix = label_to_ind\n",
        "        self.tagset_size = len(self.tag_to_ix)\n",
        "        self.max_path = max_path\n",
        "        \n",
        "        self.transitions = nn.Parameter(torch.randn(self.tagset_size, self.tagset_size))\n",
        "\n",
        "\n",
        "        \n",
        "    def _forward_alg(self, logits, len_list, is_volatile=False):\n",
        "        \"\"\"\n",
        "        Computes the (batch_size,) denominator term (FloatTensor list) for the log-likelihood, which is the\n",
        "        sum of the likelihoods across all possible state sequences.\n",
        "        \n",
        "        Arguments:\n",
        "            logits: [batch_size, seq_len, max_path, n_labels] FloatTensor\n",
        "            lens: [batch_size] LongTensor\n",
        "        \"\"\"\n",
        "        batch_size, seq_len, max_path, n_labels = logits.size()\n",
        "        \n",
        "        alpha = logits.data.new(batch_size, seq_len+1, self.tagset_size).fill_(-10000).to(device)\n",
        "        alpha[:, 0, self.tag_to_ix['START']] = 0\n",
        "        alpha = Variable(alpha, volatile=is_volatile)\n",
        "        \n",
        "        # Transpose batch size and time dimensions:\n",
        "        logits_t = logits.permute(1,0,2,3).to(device)\n",
        "        c_lens = len_list.clone()\n",
        "        \n",
        "        alpha_out_sum = Variable(logits.data.new(batch_size,max_path, self.tagset_size).fill_(0)).to(device)\n",
        "        mat = Variable(logits.data.new(batch_size,self.tagset_size,self.tagset_size).fill_(0)).to(device)\n",
        "        \n",
        "        for j, logit in enumerate(logits_t):\n",
        "            for i in range(0,max_path):\n",
        "                if i<=j:\n",
        "                    alpha_exp = alpha[:,j-i, :].clone().unsqueeze(1).expand(batch_size,self.tagset_size, self.tagset_size)\n",
        "                    logit_exp = logit[:, i].unsqueeze(-1).expand(batch_size, self.tagset_size, self.tagset_size).to(device)\n",
        "                    trans_exp = self.transitions.unsqueeze(0).expand_as(alpha_exp)\n",
        "                    mat = alpha_exp + logit_exp + trans_exp\n",
        "                    alpha_out_sum[:,i,:] =  self.log_sum_exp(mat , 2, keepdim=True).squeeze(2)\n",
        "\n",
        "            alpha_nxt = self.log_sum_exp(alpha_out_sum , dim=1, keepdim=True).squeeze(1)\n",
        "            \n",
        "            mask = Variable((c_lens > 0).float().unsqueeze(-1).expand(batch_size,self.tagset_size)).to(device)\n",
        "            alpha_nxt = mask * alpha_nxt + (1 - mask) *alpha[:, j, :].clone() \n",
        "            \n",
        "            c_lens = c_lens - 1      \n",
        "\n",
        "            alpha[:,j+1, :] = alpha_nxt\n",
        "\n",
        "        alpha[:,-1,:] = alpha[:,-1,:] + self.transitions[self.tag_to_ix['STOP']].unsqueeze(0).expand_as(alpha[:,-1,:])\n",
        "        norm = self.log_sum_exp(alpha[:,-1,:], 1).squeeze(-1)\n",
        "\n",
        "        return norm\n",
        "\n",
        "        \n",
        "    def viterbi_decode(self, logits, lens):\n",
        "        \"\"\"\n",
        "        Use viterbi algorithm to compute the most probable path of segments\n",
        "        \n",
        "        Arguments:\n",
        "            logits: [batch_size, seq_len, max_path, n_labels] FloatTensor\n",
        "            lens: [batch_size] LongTensor\n",
        "        \"\"\"\n",
        "        batch_size, seq_len, max_path, n_labels = logits.size()\n",
        "        logits = logits.to(device)\n",
        "        # Transpose to batch size and time dimensions\n",
        "        logits_t = logits.permute(1,0,2,3)\n",
        "        \n",
        "        vit = Variable(logits.data.new(batch_size,seq_len+1, self.tagset_size).fill_(-10000),\n",
        "                                       volatile = not self.training).to(device)\n",
        "        \n",
        "        vit_tag_max = Variable(logits.data.new(batch_size,max_path, self.tagset_size).fill_(-10000),\n",
        "                                   volatile = not self.training).to(device)\n",
        "        \n",
        "        vit_tag_argmax = Variable(logits.data.new(batch_size,max_path, self.tagset_size).fill_(-100),\n",
        "                                   volatile = not self.training).to(device)\n",
        "        vit[:,0, self.tag_to_ix['START']] = 0\n",
        "        c_lens = Variable(lens.clone(), volatile= not self.training).to(device)\n",
        "        \n",
        "        pointers = Variable(logits.data.new(batch_size, seq_len, self.tagset_size, 2 ).fill_(-100))\n",
        "        for j, logit in enumerate(logits_t):\n",
        "            for i in range(0,max_path):\n",
        "                if i<=j:\n",
        "                    vit_exp = vit[:,j-i, :].clone().unsqueeze(1).expand(batch_size,self.tagset_size, self.tagset_size)\n",
        "                    trn_exp = self.transitions.unsqueeze(0).expand_as(vit_exp)\n",
        "                    vit_trn_sum = vit_exp + trn_exp\n",
        "                    vt_max, vt_argmax = vit_trn_sum.max(2)\n",
        "                    vit_nxt = vt_max + logit[:, i]\n",
        "                    vit_tag_max[:,i,:] = vit_nxt\n",
        "                    vit_tag_argmax[:,i,:] = vt_argmax\n",
        "           \n",
        "            seg_vt_max, seg_vt_argmax = vit_tag_max.max(1)\n",
        "            \n",
        "            mask = (c_lens > 0).float().unsqueeze(-1).expand_as(seg_vt_max)\n",
        "            vit[:, j+1, :] = mask*seg_vt_max + (1-mask)*vit[:, j, :].clone()\n",
        "            \n",
        "            mask = (c_lens == 1).float().unsqueeze(-1).expand_as(  vit[:, j+1, :])\n",
        "            vit[:, j+1, :] = vit[:, j+1, :] +  mask * self.transitions[ self.tag_to_ix['STOP'] ].unsqueeze(0).expand_as( vit[:, j+1, :] )\n",
        "            \n",
        "            idx_exp = seg_vt_argmax.unsqueeze(1)\n",
        "            pointers[:,j,:,0] =  torch.gather(vit_tag_argmax, 1,idx_exp ).squeeze(1)\n",
        "            pointers[:,j,:,1] = seg_vt_argmax \n",
        "            \n",
        "            c_lens = c_lens - 1  \n",
        "        \n",
        "        #Get the argmax from the last viterbi scores and follow the reverse pointers for the best path \n",
        "        end_max , end_max_idx = vit[:,-1,:].max(1)\n",
        "        end_max_idx = end_max_idx.data.cpu().numpy()\n",
        "        \n",
        "        pointers = pointers.data.long().cpu().numpy()\n",
        "        pointers_rev = np.flip(pointers,1)\n",
        "        paths = []\n",
        "        segments = []\n",
        "        \n",
        "        for b in range(batch_size):\n",
        "            #Different lengths each sentence, so get the starting index on the reverse list\n",
        "            start_index = seq_len-lens[b] \n",
        "            path = [end_max_idx[b]]\n",
        "            segment = [lens[b]]\n",
        "            \n",
        "            if (start_index >= seq_len -1):\n",
        "                paths.append(path)\n",
        "                continue\n",
        "            \n",
        "            max_tuple = pointers_rev[b,start_index,end_max_idx[b]]\n",
        "            start_index += 1\n",
        "            prev_tag = end_max_idx[b]\n",
        "            next_tag = max_tuple[0]\n",
        "            next_jump = max_tuple[1]\n",
        "            \n",
        "            for j, argmax in enumerate(pointers_rev[b,start_index:,:]):\n",
        "                #Append same tag as many times as indicated by the best segment length we stored\n",
        "                if next_jump > 0:\n",
        "                    next_jump -= 1\n",
        "                    path.insert(0, prev_tag)\n",
        "                    continue\n",
        "                #Switch to next tag when we hit zero\n",
        "                else:\n",
        "                    segment.insert(0, lens[b]- j-1)\n",
        "                    path.insert(0, next_tag)\n",
        "                \n",
        "                #Get the next tag, and the number of times we have to append the previous one\n",
        "                prev_tag = next_tag\n",
        "                max_tuple = argmax[next_tag]\n",
        "                next_tag = max_tuple[0]\n",
        "                next_jump = max_tuple[1]\n",
        "                \n",
        "            segments.append(segment)     \n",
        "            paths.append(path)\n",
        "            \n",
        "        return paths, segments\n",
        "        \n",
        "        \n",
        "    def _bilstm_score(self, logits, labels, seg_inds, lens):\n",
        "        \n",
        "        \"\"\"\n",
        "        Computes the (batch_size,) numerator (FloatTensor list) for the log-likelihood, which is the\n",
        "        \n",
        "        Arguments:\n",
        "            logits: [batch_size, seq_len, max_path, n_labels] FloatTensor\n",
        "            labels: [batch_size, seq_len] LongTensor\n",
        "            seg_inds: [batch_size, seq_len] LongTensor\n",
        "            lens: [batch_size] LongTensor\n",
        "        \"\"\"\n",
        "        lens = Variable( lens, volatile = not self.training)\n",
        "        \n",
        "        batch_size, max_len, _, _ = logits.size()\n",
        "        \n",
        "        # Transpose to batch size and time dimensions\n",
        "        labels = labels.transpose(1,0)\n",
        "        \n",
        "        seg_inds = seg_inds.transpose(1,0).data.cpu().numpy()\n",
        "        labels_exp = labels.unsqueeze(-1)\n",
        "\n",
        "        #Construct the mask the will sellect the corrects segments from all possible segments for each timstep\n",
        "        mask_seg = np.zeros(( batch_size, max_len, self.max_path))\n",
        "        \n",
        "        mask_step =  np.zeros(( batch_size), dtype=np.int32)\n",
        "        counter = np.zeros((batch_size), dtype=np.int32)\n",
        "        \n",
        "        #For each timstep accross all sentences\n",
        "        for i in range(0,max_len):\n",
        "            #0 or 1 depending if we are on the end of a segment\n",
        "            mask_step =  seg_inds[:, i] \n",
        "            mask_seg[np.arange(batch_size), i, counter] = mask_step \n",
        "            counter = counter + 1\n",
        "            counter = (1- mask_step)*counter*(counter < self.max_path)\n",
        "           \n",
        "        mask_seg = torch.from_numpy(mask_seg).float()\n",
        "        if next(self.parameters()).is_cuda == True:\n",
        "            mask_seg = mask_seg.cuda()\n",
        "            \n",
        "        mask_seg = mask_seg.unsqueeze(-1).expand_as(logits)\n",
        "        mask_seg = Variable(mask_seg,  volatile = not self.training).to(device)\n",
        "        \n",
        "        logit_mask = logits*mask_seg\n",
        "        sum_cols = torch.sum(logit_mask, dim=2).squeeze(2)\n",
        "        \n",
        "        all_scores = torch.gather(sum_cols, 2, labels_exp).squeeze(-1)\n",
        "        \n",
        "        mask_time = self.sequence_mask(lens).float()\n",
        "        all_scores = all_scores*mask_time\n",
        "        \n",
        "        sum_seg_scores = torch.sum(all_scores, dim=1).squeeze(-1)\n",
        "\n",
        "        return  sum_seg_scores\n",
        "        \n",
        "    def score(self, logits, y, seg_inds, lens):\n",
        "        logits = logits.to(device)\n",
        "        bilstm_score = self._bilstm_score(logits, y, seg_inds, lens)\n",
        "        transition_score = self.transition_score(y, lens, seg_inds )\n",
        "        \n",
        "        score = transition_score + bilstm_score\n",
        "\n",
        "        return score\n",
        "    \n",
        "    def transition_score(self, labels, lens, mask_seg_idx):\n",
        "        \"\"\"\n",
        "        Computes the (batch_size,) scores (FloatTensor list) that will be added to the emission scores\n",
        "        \n",
        "        Arguments:\n",
        "            logits: [batch_size, seq_len, max_path, n_labels] FloatTensor\n",
        "            labels: [batch_size, seq_len] LongTensor\n",
        "            seg_inds: [batch_size, seq_len] LongTensor\n",
        "            lens: [batch_size] LongTensor\n",
        "        \"\"\"\n",
        "        lens = Variable( lens, volatile = not self.training)\n",
        "        labels = labels.transpose(1,0)\n",
        "        mask_seg_idx = mask_seg_idx.transpose(1,0)\n",
        "        batch_size, seq_len = labels.size()\n",
        "        # pad labels with <start> and <stop> indices\n",
        "        labels_ext = Variable(labels.data.new(batch_size, seq_len + 2))\n",
        "        labels_ext[:, 0] = self.tag_to_ix['START']\n",
        "        labels_ext[:, 1:-1] = labels\n",
        "        mask = self.sequence_mask(lens + 1, max_len=seq_len + 2).long()\n",
        "        pad_stop = Variable(labels.data.new(1).fill_(self.tag_to_ix['STOP']))\n",
        "        \n",
        "        pad_stop = pad_stop.unsqueeze(-1).expand(batch_size, seq_len + 2)\n",
        "        labels_ext = (1 + (-1)*mask) * pad_stop + mask * labels_ext\n",
        "        trn = self.transitions\n",
        "        \n",
        "        trn_exp = trn.unsqueeze(0).expand(batch_size, *trn.size())\n",
        "        lbl_r = labels_ext[:, 1:]\n",
        "        lbl_rexp = lbl_r.unsqueeze(-1).expand(*lbl_r.size(), trn.size(0))\n",
        "        trn_row = torch.gather(trn_exp, 1, lbl_rexp)\n",
        "        \n",
        "        lbl_lexp = labels_ext[:, :-1].unsqueeze(-1)\n",
        "        trn_scr = torch.gather(trn_row, 2, lbl_lexp)\n",
        "        trn_scr = trn_scr.squeeze(-1)\n",
        "        \n",
        "        # Mask sentences in time dim\n",
        "        mask = self.sequence_mask(lens + 1).float()\n",
        "        trn_scr = trn_scr * mask\n",
        "        \n",
        "        trn_scr[:, 1:] = trn_scr[:, 1:].clone()*mask_seg_idx.float() \n",
        "        \n",
        "        score = trn_scr.sum(1).squeeze(-1)\n",
        "        \n",
        "        return score\n",
        "\n",
        "    def loglik(self, logits, y, lens):\n",
        "        norm_score = self._forward_alg(logits, lens)\n",
        "        sequence_score = self.score(logits, y, lens, logits=logits)\n",
        "        loglik = sequence_score - norm_score\n",
        "\n",
        "        return loglik   \n",
        "\n",
        "\n",
        "    def log_sum_exp(self,vec, dim=0, keepdim=True):\n",
        "        max_val, idx = torch.max(vec, dim, keepdim=True)\n",
        "        max_exp = max_val.expand_as(vec)\n",
        "    \n",
        "        return max_val + torch.log(torch.sum(torch.exp(vec - max_exp), dim, keepdim=keepdim))\n",
        "\n",
        "    \n",
        "    def sequence_mask(self,lens, max_len=None):\n",
        "        batch_size = lens.size(0)\n",
        "        if max_len is None:\n",
        "        \n",
        "            max_len = lens.max().data\n",
        "            \n",
        "        ranges = torch.arange(0, max_len).long()\n",
        "        ranges = ranges.unsqueeze(0).expand(batch_size, max_len)\n",
        "        ranges = Variable(ranges)\n",
        "        if lens.data.is_cuda:\n",
        "            ranges = ranges.cuda()\n",
        "\n",
        "        lens_exp = lens.unsqueeze(1).expand_as(ranges)\n",
        "        mask = ranges < lens_exp\n",
        "        return mask"
      ],
      "metadata": {
        "id": "MIkfNit0V6OH"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "from allennlp.common.util import pad_sequence_to_length\n",
        "from allennlp.modules.seq2seq_encoders import PytorchSeq2SeqWrapper\n",
        "from allennlp.nn.util import masked_mean, masked_softmax\n",
        "from allennlp.modules.span_extractors import EndpointSpanExtractor,SelfAttentiveSpanExtractor\n",
        "import copy\n",
        "\n",
        "from transformers import BertModel\n",
        "\n",
        "from allennlp.modules import ConditionalRandomField\n",
        "\n",
        "import torch\n",
        "import torch.nn as nn\n",
        "\n",
        "\n",
        "class CRFOutputLayer(torch.nn.Module):\n",
        "    ''' CRF output layer consisting of a linear layer and a CRF. '''\n",
        "    def __init__(self, in_dim, num_labels):\n",
        "        super(CRFOutputLayer, self).__init__()\n",
        "        self.num_labels = num_labels\n",
        "        self.classifier = torch.nn.Linear(in_dim, self.num_labels)\n",
        "        self.crf = ConditionalRandomField(self.num_labels)\n",
        "\n",
        "    def forward(self, x, mask, labels=None):\n",
        "        ''' x: shape: batch, max_sequence, in_dim\n",
        "            mask: shape: batch, max_sequence\n",
        "            labels: shape: batch, max_sequence\n",
        "        '''\n",
        "\n",
        "        batch_size, max_sequence, in_dim = x.shape\n",
        "\n",
        "        logits = self.classifier(x)\n",
        "        outputs = {}\n",
        "        if labels is not None:\n",
        "            log_likelihood = self.crf(logits, labels, mask)\n",
        "            loss = -log_likelihood\n",
        "            outputs[\"loss\"] = loss\n",
        "        else:\n",
        "            best_paths = self.crf.viterbi_tags(logits, mask)\n",
        "            predicted_label = [x for x, y in best_paths]\n",
        "            predicted_label = [pad_sequence_to_length(x, desired_length=max_sequence) for x in predicted_label]\n",
        "            predicted_label = torch.tensor(predicted_label)\n",
        "            outputs[\"predicted_label\"] = predicted_label\n",
        "\n",
        "            #log_denominator = self.crf._input_likelihood(logits, mask)\n",
        "            #log_numerator = self.crf._joint_likelihood(logits, predicted_label, mask)\n",
        "            #log_likelihood = log_numerator - log_denominator\n",
        "            #outputs[\"log_likelihood\"] = log_likelihood\n",
        "\n",
        "        return outputs\n",
        "        \n",
        "\n",
        "\n",
        "class AttentionPooling(torch.nn.Module):\n",
        "    def __init__(self, in_features, dimension_context_vector_u=200, number_context_vectors=5):\n",
        "        super(AttentionPooling, self).__init__()\n",
        "        self.dimension_context_vector_u = dimension_context_vector_u\n",
        "        self.number_context_vectors = number_context_vectors\n",
        "        self.linear1 = torch.nn.Linear(in_features=in_features, out_features=self.dimension_context_vector_u, bias=True)\n",
        "        self.linear2 = torch.nn.Linear(in_features=self.dimension_context_vector_u,\n",
        "                                       out_features=self.number_context_vectors, bias=False)\n",
        "\n",
        "        self.output_dim = self.number_context_vectors * in_features\n",
        "\n",
        "    def forward(self, tokens, mask):\n",
        "        #shape tokens: (batch_size, tokens, in_features)\n",
        "\n",
        "        # compute the weights\n",
        "        # shape tokens: (batch_size, tokens, dimension_context_vector_u)\n",
        "        a = self.linear1(tokens)\n",
        "        a = torch.tanh(a)\n",
        "        # shape (batch_size, tokens, number_context_vectors)\n",
        "        a = self.linear2(a)\n",
        "        # shape (batch_size, number_context_vectors, tokens)\n",
        "        a = a.transpose(1, 2)\n",
        "        a = masked_softmax(a, mask)\n",
        "\n",
        "        # calculate weighted sum\n",
        "        s = torch.bmm(a, tokens)\n",
        "        s = s.view(tokens.shape[0], -1)\n",
        "        return s\n",
        "\n",
        "\n",
        "\n",
        "class BertTokenEmbedder(torch.nn.Module):\n",
        "    def __init__(self, config):\n",
        "        super(BertTokenEmbedder, self).__init__()\n",
        "        self.bert = BertModel.from_pretrained(config[\"bert_model\"])\n",
        "        self.bert_trainable = config[\"bert_trainable\"]\n",
        "        self.bert_hidden_size = self.bert.config.hidden_size\n",
        "        for param in self.bert.parameters():\n",
        "            param.requires_grad = self.bert_trainable\n",
        "\n",
        "    def forward(self, batch):\n",
        "        if \"bert_embeddings\" in batch:\n",
        "            return batch[\"bert_embeddings\"]\n",
        "\n",
        "        documents, sentences, tokens = batch[\"input_ids\"].shape\n",
        "        attention_mask = batch[\"attention_mask\"].view(-1, tokens)\n",
        "        input_ids = batch[\"input_ids\"].view(-1, tokens)\n",
        "\n",
        "        outputs = self.bert(input_ids=input_ids, attention_mask=attention_mask)\n",
        "        # shape (documents*sentences, tokens, 768)\n",
        "        bert_embeddings = outputs[0]\n",
        "\n",
        "        if not self.bert_trainable:\n",
        "            batch[\"bert_embeddings\"] = bert_embeddings.to(\"cpu\")\n",
        "        return bert_embeddings\n",
        "\n",
        "class BertHSLN(torch.nn.Module):\n",
        "    def __init__(self, config):\n",
        "        super(BertHSLN, self).__init__()\n",
        "\n",
        "        self.bert = BertTokenEmbedder(config)\n",
        "        self.dropout = torch.nn.Dropout(config[\"dropout\"])\n",
        "        self.word_lstm_hidden_size = config[\"word_lstm_hs\"]\n",
        "        self.word_lstm = PytorchSeq2SeqWrapper(torch.nn.GRU(input_size=self.bert.bert_hidden_size,\n",
        "                                  hidden_size=self.word_lstm_hidden_size,\n",
        "                                  num_layers=1, batch_first=True, bidirectional=True))\n",
        "\n",
        "        self.attention_pooling = AttentionPooling(2 * self.word_lstm_hidden_size,\n",
        "                                                  dimension_context_vector_u=config[\"att_pooling_dim_ctx\"],\n",
        "                                                  number_context_vectors=config[\"att_pooling_num_ctx\"])\n",
        "        \n",
        "        input_dim = self.attention_pooling.output_dim\n",
        "        self.sentence_lstm_hidden_size = config[\"sentence_lstm_hs\"]\n",
        "        self.sentence_lstm = PytorchSeq2SeqWrapper(torch.nn.GRU(input_size=input_dim,\n",
        "                                  hidden_size=self.sentence_lstm_hidden_size,\n",
        "                                  num_layers=1, batch_first=True, bidirectional=True))\n",
        "        \n",
        "\n",
        "\n",
        "        self.input_dim = self.sentence_lstm_hidden_size * 2\n",
        "        self.max_path = config[\"max_path\"]\n",
        "        self.num_labels = len(config['label_to_ind'])\n",
        "        \n",
        "        self.span_crf = config[\"span_crf\"]\n",
        "        self.crf = config[\"crf\"]\n",
        "\n",
        "        if self.crf:\n",
        "          self.crf_fc = nn.Linear(self.input_dim, self.num_labels)\n",
        "          self.crf = SpanCRF(config[\"label_to_ind\"],1)\n",
        "          #self.crf = CRFOutputLayer(in_dim=self.input_dim, num_labels=self.num_labels)\n",
        "\n",
        "        if self.span_crf:\n",
        "          #self.endpoint_span_extractor = EndpointSpanExtractor(self.sentence_lstm_hidden_size * 2,\n",
        "          #                                                    combination=\"x,y,x*y,x-y\",\n",
        "          #                                                    num_width_embeddings=config[\"max_path\"],\n",
        "          #                                                    span_width_embedding_dim=config[\"span_width_embedding_dim\"],\n",
        "          #                                                    bucket_widths=True)\n",
        "          self.endpoint_span_extractor = SelfAttentiveSpanExtractor(self.sentence_lstm_hidden_size * 2,\n",
        "                                                              num_width_embeddings=config[\"max_path\"],\n",
        "                                                              span_width_embedding_dim=config[\"span_width_embedding_dim\"],\n",
        "                                                              bucket_widths=True)\n",
        "          #self.span_input_dim = self.sentence_lstm_hidden_size * 2 * 4 + config[\"span_width_embedding_dim\"]\n",
        "          self.span_input_dim = self.sentence_lstm_hidden_size * 2  + config[\"span_width_embedding_dim\"]\n",
        "          \n",
        "          self.crf_spanfc = nn.Linear(self.span_input_dim, self.num_labels)\n",
        "          self.spancrf = SpanCRF(config[\"label_to_ind\"],self.max_path)\n",
        "\n",
        "\n",
        "\n",
        "\n",
        "    def forward(self, batch, labels=None, eval=False):\n",
        "\n",
        "        documents, sentences, tokens = batch[\"input_ids\"].shape\n",
        "  \n",
        "        # shape (documents*sentences, tokens, 768)\n",
        "        bert_embeddings = self.bert(batch)\n",
        "        bert_embeddings = self.dropout(bert_embeddings)\n",
        "\n",
        "        tokens_mask = batch[\"attention_mask\"].view(-1, tokens)\n",
        "\n",
        "        # shape (documents*sentences, tokens, 2*lstm_hidden_size)\n",
        "        bert_embeddings_encoded = self.word_lstm(bert_embeddings, tokens_mask)\n",
        "\n",
        "        #shape (documents*sentences, pooling_out)\n",
        "        sentence_embeddings = self.attention_pooling(bert_embeddings_encoded, tokens_mask)\n",
        "\n",
        "        # shape: (documents, sentences, pooling_out)\n",
        "        sentence_embeddings = sentence_embeddings.view(documents, sentences, -1)\n",
        "        sentence_embeddings = self.dropout(sentence_embeddings)\n",
        "\n",
        "\n",
        "        sentence_mask = batch[\"sentence_mask\"]\n",
        "\n",
        "        # shape: (documents, sentence, 2*lstm_hidden_size)\n",
        "        sentence_embeddings_encoded = self.sentence_lstm(sentence_embeddings, sentence_mask)\n",
        "        sentence_embeddings_encoded = self.dropout(sentence_embeddings_encoded)\n",
        "\n",
        "        sentence_len = torch.sum(sentence_mask,dim=-1)\n",
        "        output = {}\n",
        "\n",
        "        if self.span_crf:\n",
        "            span_embeddings = self.endpoint_span_extractor(sentence_embeddings_encoded,batch[\"span_indices\"], sentence_mask)\n",
        "            segment_rep = self.crf_spanfc(span_embeddings)\n",
        "            _,max_span_len,_ = segment_rep.shape\n",
        "        \n",
        "            segment_span_feat = torch.zeros(documents, sentences, self.max_path, self.num_labels)\n",
        "\n",
        "        \n",
        "            batch_size, max_span_len,_ = batch[\"span_indices\"].shape\n",
        "            _, max_seq_len, max_path_len, _ = segment_span_feat.shape\n",
        "\n",
        "            for i in range(batch_size):\n",
        "              for j in range(max_span_len):\n",
        "                start_idx = batch[\"span_indices\"][i][j][0]\n",
        "                len_idx = batch[\"span_indices\"][i][j][1] - batch[\"span_indices\"][i][j][0]\n",
        "                segment_span_feat[i,start_idx,len_idx,:] = segment_rep[i][j]\n",
        "            \n",
        "            segment_mask = batch[\"segment_mask\"]\n",
        "            \n",
        "            if not eval:\n",
        "                span_forward_var_batch = self.spancrf._forward_alg(segment_span_feat,sentence_len )\n",
        "                span_gold_score_batch = self.spancrf.score(segment_span_feat, labels.transpose(0,1) , segment_mask.transpose(0,1),sentence_len)\n",
        "                loss = (span_forward_var_batch-span_gold_score_batch).mean()\n",
        "                #output['span_crf'] = {\"forward_var_batch\":span_forward_var_batch , \"gold_score_batch\" : span_gold_score_batch}\n",
        "                output['loss2'] = loss\n",
        "\n",
        "        if self.crf:\n",
        "            #output = self.crf(sentence_embeddings_encoded, sentence_mask, labels)\n",
        "            #return output \n",
        "\n",
        "            segment_feat = sentence_embeddings_encoded.unsqueeze(2)\n",
        "            segment_feat = self.crf_fc(segment_feat)\n",
        "            segment_feat = segment_feat.view(documents, sentences, 1, self.num_labels)\n",
        "            \n",
        "            if not eval:\n",
        "                forward_var_batch = self.crf._forward_alg(segment_feat,sentence_len )\n",
        "                gold_score_batch = self.crf.score(segment_feat, labels.transpose(0,1) , sentence_mask.transpose(0,1),sentence_len)\n",
        "                loss = (forward_var_batch-gold_score_batch  ).mean()\n",
        "                output['loss1'] = loss\n",
        "            \n",
        "\n",
        "        if eval:\n",
        "            if self.crf:\n",
        "              crf_tag_seqs, crf_segments = self.crf.viterbi_decode(segment_feat,sentence_len )\n",
        "              #output['crf'] = {\"tag_seqs\":crf_tag_seqs, \"segments\":  crf_segments }\n",
        "              output[\"predicted_label1\"] = crf_tag_seqs\n",
        "            if self.span_crf:\n",
        "              span_crf_tag_seqs, span_crf_segments = self.spancrf.viterbi_decode(segment_span_feat,sentence_len )\n",
        "              #output['span_crf'] = {\"tag_seqs\":span_crf_tag_seqs, \"segments\":  span_crf_segments }\n",
        "              output[\"predicted_label2\"] = span_crf_tag_seqs\n",
        "\n",
        "        return output"
      ],
      "metadata": {
        "id": "eWRpmueoXHMP"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "config = {\n",
        "    \"dropout\":0.5,\n",
        "    \"word_lstm_hs\":512,\n",
        "    \"att_pooling_dim_ctx\":200,\n",
        "    \"att_pooling_num_ctx\": 15,\n",
        "    \"sentence_lstm_hs\":512,\n",
        "    \"bert_model\": bert_model,\n",
        "    \"bert_trainable\": False,\n",
        "    \"label_to_ind\" : label_to_ind,\n",
        "    \"max_path\": 10,\n",
        "    \"span_width_embedding_dim\" :100,\n",
        "    \"lr_epoch_decay\":0.9,\n",
        "    \"crf\": True,\n",
        "    \"span_crf\" : False\n",
        "}"
      ],
      "metadata": {
        "id": "YPyoJ8L4XLfh"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "from sklearn.metrics import precision_recall_fscore_support, classification_report, confusion_matrix, accuracy_score\n",
        "import numpy as np\n",
        "\n",
        "def eval_model(model, eval_batches, device,label_to_ind, id):\n",
        "    model.eval()\n",
        "    true_labels = []\n",
        "    labels_dict={}\n",
        "    predicted_labels = []\n",
        "    docwise_predicted_labels=[]\n",
        "    docwise_true_labels = []\n",
        "    doc_name_list = []\n",
        "    with torch.no_grad():\n",
        "        for batch in eval_batches:\n",
        "            # move tensor to gpu\n",
        "            shift_to_device(batch,device)\n",
        "\n",
        "            output = model(batch=batch, eval=True)\n",
        "            \n",
        "            for each in range(len(batch['doc_name'])):\n",
        "                true_labels_batch, predicted_labels_batch = \\\n",
        "                    clear_and_map_padded_values(batch[\"label_ids\"][each], output[id][each],label_to_ind)\n",
        "                assert len(batch['sentence_mask'][each].nonzero()) == len(predicted_labels_batch)\n",
        "\n",
        "                #print(batch[\"label_ids\"][each].shape, output['predicted_label'][each].shape)\n",
        "                #print(len(true_labels_batch), len(predicted_labels_batch))\n",
        "                #print(batch['doc_name'][each])\n",
        "                docwise_true_labels.append(true_labels_batch)\n",
        "                docwise_predicted_labels.append(predicted_labels_batch)\n",
        "                doc_name_list.append(batch['doc_name'][each])\n",
        "                true_labels.extend(true_labels_batch)\n",
        "                predicted_labels.extend(predicted_labels_batch)\n",
        "            \n",
        "            shift_to_device(batch,torch.device(\"cpu\"))\n",
        "    \n",
        "    labels_dict['y_true']=true_labels\n",
        "    labels_dict['y_predicted'] = predicted_labels\n",
        "    labels_dict['docwise_y_true'] = docwise_true_labels\n",
        "    labels_dict['docwise_y_predicted'] = docwise_predicted_labels\n",
        "    labels_dict['doc_names'] = doc_name_list\n",
        "    metrics, confusion, class_report = \\\n",
        "        calc_classification_metrics(y_true=true_labels, y_predicted=predicted_labels,labels = list(label_to_ind.keys()))\n",
        "    return metrics, confusion,labels_dict, class_report\n",
        "    \n",
        "    \n",
        "def clear_and_map_padded_values(true_labels, predicted_labels,label_to_ind):\n",
        "    cleared_predicted = []\n",
        "    cleared_true = []\n",
        "    ind_to_label = {v: k for k, v in label_to_ind.items()}\n",
        "    for true_label, predicted_label in zip(true_labels, predicted_labels):\n",
        "        if true_label.item() != label_to_ind['MASK']:\n",
        "            cleared_true.append(ind_to_label[true_label.item()])\n",
        "            cleared_predicted.append(ind_to_label[predicted_label.item()])\n",
        "    return cleared_true, cleared_predicted\n",
        "\n",
        "def calc_classification_metrics(y_true, y_predicted, labels):\n",
        "    macro_precision, macro_recall, macro_f1, _ = precision_recall_fscore_support(y_true, y_predicted, average='macro')\n",
        "    micro_precision, micro_recall, micro_f1, _ = precision_recall_fscore_support(y_true, y_predicted, average='micro')\n",
        "    weighted_precision, weighted_recall, weighted_f1, _ = precision_recall_fscore_support(y_true, y_predicted, average='weighted')\n",
        "    per_label_precision, per_label_recall, per_label_f1, _ = precision_recall_fscore_support(y_true, y_predicted, average=None, labels=labels)\n",
        "\n",
        "    acc = accuracy_score(y_true, y_predicted)\n",
        "\n",
        "    class_report = classification_report(y_true, y_predicted, digits=4)\n",
        "    confusion_abs = confusion_matrix(y_true, y_predicted, labels=labels)\n",
        "    # normalize confusion matrix\n",
        "    confusion = np.around(confusion_abs.astype('float') / confusion_abs.sum(axis=1)[:, np.newaxis] * 100, 2)\n",
        "    return {\"acc\": acc,\n",
        "            \"macro-f1\": macro_f1,\n",
        "            \"macro-precision\": macro_precision,\n",
        "            \"macro-recall\": macro_recall,\n",
        "            \"micro-f1\": micro_f1,\n",
        "            \"micro-precision\": micro_precision,\n",
        "            \"micro-recall\": micro_recall,\n",
        "            \"weighted-f1\": weighted_f1,\n",
        "            \"weighted-precision\": weighted_precision,\n",
        "            \"weighted-recall\": weighted_recall,\n",
        "            \"labels\": labels,\n",
        "            \"per-label-f1\": per_label_f1.tolist(),\n",
        "            \"per-label-precision\": per_label_precision.tolist(),\n",
        "            \"per-label-recall\": per_label_recall.tolist(),\n",
        "            \"confusion_abs\": confusion_abs.tolist()\n",
        "            }, \\\n",
        "           confusion.tolist(), \\\n",
        "           class_report"
      ],
      "metadata": {
        "id": "DvCjVEZLXScT"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "def shift_to_device(batch,device):\n",
        "  for key in batch.keys():\n",
        "    if(torch.is_tensor(batch[key])):\n",
        "      batch[key] = batch[key].to(device)\n",
        "    else:\n",
        "      batch[key] = batch[key]"
      ],
      "metadata": {
        "id": "atemjU27XVTG"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "import torch.optim as optim\n",
        "from tqdm import tqdm\n",
        "from sklearn.metrics import accuracy_score,precision_score,recall_score,f1_score\n",
        "import itertools\n",
        "import gc\n",
        "from torch.optim.lr_scheduler import StepLR\n",
        "\n",
        "gc.collect()\n",
        "torch.cuda.empty_cache()\n",
        "\n",
        "num_epochs = 100\n",
        "learning_rate = 3e-4\n",
        "\n",
        "device = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")\n",
        "\n",
        "model = BertHSLN(config).to(device)\n",
        "\n",
        "\n",
        "for name, param in model.named_parameters():\n",
        "  if(\"bert\" in name):\n",
        "    param.requires_grad = False\n",
        "\n",
        "optimizer = optim.Adam(list(filter(lambda p: p.requires_grad, model.parameters())), lr=learning_rate)\n",
        "max_grad_norm = 1.0\n",
        "epoch_scheduler = StepLR(optimizer, step_size=1, gamma=config[\"lr_epoch_decay\"])\n",
        "\n",
        "\n",
        "for epoch in range(num_epochs):\n",
        "    print(f\"[Epoch {epoch} / {num_epochs}]\")\n",
        "    model.train()\n",
        "    for batch_idx, batch in tqdm(enumerate(train_dataloader),total=len(train_dataloader), leave=False):\n",
        "        shift_to_device(batch,device)\n",
        "        output = model(batch, batch[\"label_ids\"])\n",
        "        loss = output[\"loss1\"]\n",
        "        #loss = output[\"loss1\"] + output[\"loss2\"]\n",
        "        loss = loss.sum()\n",
        "        loss.backward()\n",
        "        torch.nn.utils.clip_grad_norm_(model.parameters(), max_grad_norm)\n",
        "        optimizer.step()\n",
        "        optimizer.zero_grad()\n",
        "        shift_to_device(batch,torch.device(\"cpu\"))\n",
        "    print(f\"Loss in epoch {epoch} : {loss.item()}\")\n",
        "    epoch_scheduler.step()\n",
        "\n",
        "    test_metrics, test_confusion,labels_dict,_ = eval_model(model, dev_dataloader , device,label_to_ind,\"predicted_label1\")\n",
        "    print(test_metrics)\n",
        "    #test_metrics, test_confusion,labels_dict,_ = eval_model(model, dev_dataloader , device,label_to_ind,\"predicted_label2\")\n",
        "    #print(test_metrics)"
      ],
      "metadata": {
        "id": "3LlTHdc9XX3_"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "torch.cuda.empty_cache()"
      ],
      "metadata": {
        "id": "mB8OKe6tXbG1"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "NZK7tk__gKzS"
      },
      "execution_count": null,
      "outputs": []
    }
  ],
  "metadata": {
    "colab": {
      "name": "The_MRC_data_creation.ipynb",
      "provenance": [],
      "collapsed_sections": []
    },
    "kernelspec": {
      "display_name": "Python 3",
      "name": "python3"
    },
    "language_info": {
      "name": "python"
    },
    "gpuClass": "standard",
    "accelerator": "GPU",
    "widgets": {
      "application/vnd.jupyter.widget-state+json": {
        "4102092d0efd43cdb1b004c5572da0f9": {
          "model_module": "@jupyter-widgets/controls",
          "model_name": "HBoxModel",
          "model_module_version": "1.5.0",
          "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_6a57363331524b13bd6a6da1b44e8084",
              "IPY_MODEL_25360f03287541be88f7e577b3204732",
              "IPY_MODEL_e218f1f6295b49b89f1b89f913489267"
            ],
            "layout": "IPY_MODEL_8027c36c1d134f048b429f81b5d56610"
          }
        },
        "6a57363331524b13bd6a6da1b44e8084": {
          "model_module": "@jupyter-widgets/controls",
          "model_name": "HTMLModel",
          "model_module_version": "1.5.0",
          "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_ef48424a33414e95897194747337ad66",
            "placeholder": "​",
            "style": "IPY_MODEL_811e7bba7790479e8435699d216931b3",
            "value": "Downloading: 100%"
          }
        },
        "25360f03287541be88f7e577b3204732": {
          "model_module": "@jupyter-widgets/controls",
          "model_name": "FloatProgressModel",
          "model_module_version": "1.5.0",
          "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_e45f4783d184447b8cc93aeb5a7167ad",
            "max": 307,
            "min": 0,
            "orientation": "horizontal",
            "style": "IPY_MODEL_5537cb517ed8447c85ac07bc637ce587",
            "value": 307
          }
        },
        "e218f1f6295b49b89f1b89f913489267": {
          "model_module": "@jupyter-widgets/controls",
          "model_name": "HTMLModel",
          "model_module_version": "1.5.0",
          "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_821b4c62fb67409baeca4b0435c0d5ba",
            "placeholder": "​",
            "style": "IPY_MODEL_a5f4831edc1648c993b7b4ec24beb511",
            "value": " 307/307 [00:00&lt;00:00, 6.25kB/s]"
          }
        },
        "8027c36c1d134f048b429f81b5d56610": {
          "model_module": "@jupyter-widgets/base",
          "model_name": "LayoutModel",
          "model_module_version": "1.2.0",
          "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
          }
        },
        "ef48424a33414e95897194747337ad66": {
          "model_module": "@jupyter-widgets/base",
          "model_name": "LayoutModel",
          "model_module_version": "1.2.0",
          "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
          }
        },
        "811e7bba7790479e8435699d216931b3": {
          "model_module": "@jupyter-widgets/controls",
          "model_name": "DescriptionStyleModel",
          "model_module_version": "1.5.0",
          "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": ""
          }
        },
        "e45f4783d184447b8cc93aeb5a7167ad": {
          "model_module": "@jupyter-widgets/base",
          "model_name": "LayoutModel",
          "model_module_version": "1.2.0",
          "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
          }
        },
        "5537cb517ed8447c85ac07bc637ce587": {
          "model_module": "@jupyter-widgets/controls",
          "model_name": "ProgressStyleModel",
          "model_module_version": "1.5.0",
          "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": ""
          }
        },
        "821b4c62fb67409baeca4b0435c0d5ba": {
          "model_module": "@jupyter-widgets/base",
          "model_name": "LayoutModel",
          "model_module_version": "1.2.0",
          "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
          }
        },
        "a5f4831edc1648c993b7b4ec24beb511": {
          "model_module": "@jupyter-widgets/controls",
          "model_name": "DescriptionStyleModel",
          "model_module_version": "1.5.0",
          "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": ""
          }
        },
        "5b42fe40c9b34e5f849c7fb869268401": {
          "model_module": "@jupyter-widgets/controls",
          "model_name": "HBoxModel",
          "model_module_version": "1.5.0",
          "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_fc93d4df58b84538bf82ef3b7a7498f7",
              "IPY_MODEL_2f291d725a2640bd8c8f7ac5ca1b4ae5",
              "IPY_MODEL_77980e836290411ca35971c5055b69be"
            ],
            "layout": "IPY_MODEL_df26225cc73948c0bb35cb490b1c7cfa"
          }
        },
        "fc93d4df58b84538bf82ef3b7a7498f7": {
          "model_module": "@jupyter-widgets/controls",
          "model_name": "HTMLModel",
          "model_module_version": "1.5.0",
          "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_00c1dd1a42234e8b9f71995b32fba821",
            "placeholder": "​",
            "style": "IPY_MODEL_160983fa69a040c3b3d148f71ef825dd",
            "value": "Downloading: 100%"
          }
        },
        "2f291d725a2640bd8c8f7ac5ca1b4ae5": {
          "model_module": "@jupyter-widgets/controls",
          "model_name": "FloatProgressModel",
          "model_module_version": "1.5.0",
          "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_e716deabae93414cba71923849752ca0",
            "max": 747,
            "min": 0,
            "orientation": "horizontal",
            "style": "IPY_MODEL_1faf76ee65044a8391c0c65dc61981bd",
            "value": 747
          }
        },
        "77980e836290411ca35971c5055b69be": {
          "model_module": "@jupyter-widgets/controls",
          "model_name": "HTMLModel",
          "model_module_version": "1.5.0",
          "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_582c2227093044b2b45c02a1a3c2fa9f",
            "placeholder": "​",
            "style": "IPY_MODEL_0cd52f4e15a148b5b13ad86e445fe6db",
            "value": " 747/747 [00:00&lt;00:00, 22.5kB/s]"
          }
        },
        "df26225cc73948c0bb35cb490b1c7cfa": {
          "model_module": "@jupyter-widgets/base",
          "model_name": "LayoutModel",
          "model_module_version": "1.2.0",
          "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
          }
        },
        "00c1dd1a42234e8b9f71995b32fba821": {
          "model_module": "@jupyter-widgets/base",
          "model_name": "LayoutModel",
          "model_module_version": "1.2.0",
          "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
          }
        },
        "160983fa69a040c3b3d148f71ef825dd": {
          "model_module": "@jupyter-widgets/controls",
          "model_name": "DescriptionStyleModel",
          "model_module_version": "1.5.0",
          "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": ""
          }
        },
        "e716deabae93414cba71923849752ca0": {
          "model_module": "@jupyter-widgets/base",
          "model_name": "LayoutModel",
          "model_module_version": "1.2.0",
          "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
          }
        },
        "1faf76ee65044a8391c0c65dc61981bd": {
          "model_module": "@jupyter-widgets/controls",
          "model_name": "ProgressStyleModel",
          "model_module_version": "1.5.0",
          "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": ""
          }
        },
        "582c2227093044b2b45c02a1a3c2fa9f": {
          "model_module": "@jupyter-widgets/base",
          "model_name": "LayoutModel",
          "model_module_version": "1.2.0",
          "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
          }
        },
        "0cd52f4e15a148b5b13ad86e445fe6db": {
          "model_module": "@jupyter-widgets/controls",
          "model_name": "DescriptionStyleModel",
          "model_module_version": "1.5.0",
          "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": ""
          }
        },
        "fb047f147f7e413a8addcc1978e0ea76": {
          "model_module": "@jupyter-widgets/controls",
          "model_name": "HBoxModel",
          "model_module_version": "1.5.0",
          "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_908b19ea547b46b297c864b3bc6cce4d",
              "IPY_MODEL_bf6597126c934fdb9d0b7ce943f750ca",
              "IPY_MODEL_1098098593f345c4be0fae9359dca92b"
            ],
            "layout": "IPY_MODEL_8bafc463461b42cc90b290e065e703e1"
          }
        },
        "908b19ea547b46b297c864b3bc6cce4d": {
          "model_module": "@jupyter-widgets/controls",
          "model_name": "HTMLModel",
          "model_module_version": "1.5.0",
          "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_39d9922d02c44c2391d960004e5114bb",
            "placeholder": "​",
            "style": "IPY_MODEL_02f2cd86778049a49a4946ec276a6048",
            "value": "Downloading: 100%"
          }
        },
        "bf6597126c934fdb9d0b7ce943f750ca": {
          "model_module": "@jupyter-widgets/controls",
          "model_name": "FloatProgressModel",
          "model_module_version": "1.5.0",
          "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_0426dd947ae244dea1d03042d42140c1",
            "max": 251156,
            "min": 0,
            "orientation": "horizontal",
            "style": "IPY_MODEL_bde4e397ea89436490912eef27121164",
            "value": 251156
          }
        },
        "1098098593f345c4be0fae9359dca92b": {
          "model_module": "@jupyter-widgets/controls",
          "model_name": "HTMLModel",
          "model_module_version": "1.5.0",
          "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_4e39809631cc4315ab9e25cdffea4ff3",
            "placeholder": "​",
            "style": "IPY_MODEL_9faf58bc5fe1467cb6958c9b57819bed",
            "value": " 245k/245k [00:00&lt;00:00, 1.63MB/s]"
          }
        },
        "8bafc463461b42cc90b290e065e703e1": {
          "model_module": "@jupyter-widgets/base",
          "model_name": "LayoutModel",
          "model_module_version": "1.2.0",
          "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
          }
        },
        "39d9922d02c44c2391d960004e5114bb": {
          "model_module": "@jupyter-widgets/base",
          "model_name": "LayoutModel",
          "model_module_version": "1.2.0",
          "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
          }
        },
        "02f2cd86778049a49a4946ec276a6048": {
          "model_module": "@jupyter-widgets/controls",
          "model_name": "DescriptionStyleModel",
          "model_module_version": "1.5.0",
          "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": ""
          }
        },
        "0426dd947ae244dea1d03042d42140c1": {
          "model_module": "@jupyter-widgets/base",
          "model_name": "LayoutModel",
          "model_module_version": "1.2.0",
          "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
          }
        },
        "bde4e397ea89436490912eef27121164": {
          "model_module": "@jupyter-widgets/controls",
          "model_name": "ProgressStyleModel",
          "model_module_version": "1.5.0",
          "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": ""
          }
        },
        "4e39809631cc4315ab9e25cdffea4ff3": {
          "model_module": "@jupyter-widgets/base",
          "model_name": "LayoutModel",
          "model_module_version": "1.2.0",
          "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
          }
        },
        "9faf58bc5fe1467cb6958c9b57819bed": {
          "model_module": "@jupyter-widgets/controls",
          "model_name": "DescriptionStyleModel",
          "model_module_version": "1.5.0",
          "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": ""
          }
        },
        "e1ef774e1ae54405b28b9ab043d2ab2c": {
          "model_module": "@jupyter-widgets/controls",
          "model_name": "HBoxModel",
          "model_module_version": "1.5.0",
          "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_e1b0e25268cb4c7887105cca9ac94f82",
              "IPY_MODEL_cd05ab87b3c3463b93351ab82e1a93b9",
              "IPY_MODEL_f32ea568ef214b4db34d8da601ede4fa"
            ],
            "layout": "IPY_MODEL_202974d4a5404647b3f3aade5236473c"
          }
        },
        "e1b0e25268cb4c7887105cca9ac94f82": {
          "model_module": "@jupyter-widgets/controls",
          "model_name": "HTMLModel",
          "model_module_version": "1.5.0",
          "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_6c04472103ca403788ad65541990c0cd",
            "placeholder": "​",
            "style": "IPY_MODEL_2746d87451a24a0c8d5ed933ddef7f9b",
            "value": "Downloading: 100%"
          }
        },
        "cd05ab87b3c3463b93351ab82e1a93b9": {
          "model_module": "@jupyter-widgets/controls",
          "model_name": "FloatProgressModel",
          "model_module_version": "1.5.0",
          "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_a98b5e4d30014596b50b14b76fa6aa29",
            "max": 112,
            "min": 0,
            "orientation": "horizontal",
            "style": "IPY_MODEL_124672fc6c5b47e5aff604fa8517f5e0",
            "value": 112
          }
        },
        "f32ea568ef214b4db34d8da601ede4fa": {
          "model_module": "@jupyter-widgets/controls",
          "model_name": "HTMLModel",
          "model_module_version": "1.5.0",
          "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_76752a2a4b3b40c1bcb31683891e59ae",
            "placeholder": "​",
            "style": "IPY_MODEL_9e6899efa51b40d18655da8822de36c7",
            "value": " 112/112 [00:00&lt;00:00, 3.09kB/s]"
          }
        },
        "202974d4a5404647b3f3aade5236473c": {
          "model_module": "@jupyter-widgets/base",
          "model_name": "LayoutModel",
          "model_module_version": "1.2.0",
          "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
          }
        },
        "6c04472103ca403788ad65541990c0cd": {
          "model_module": "@jupyter-widgets/base",
          "model_name": "LayoutModel",
          "model_module_version": "1.2.0",
          "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
          }
        },
        "2746d87451a24a0c8d5ed933ddef7f9b": {
          "model_module": "@jupyter-widgets/controls",
          "model_name": "DescriptionStyleModel",
          "model_module_version": "1.5.0",
          "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": ""
          }
        },
        "a98b5e4d30014596b50b14b76fa6aa29": {
          "model_module": "@jupyter-widgets/base",
          "model_name": "LayoutModel",
          "model_module_version": "1.2.0",
          "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
          }
        },
        "124672fc6c5b47e5aff604fa8517f5e0": {
          "model_module": "@jupyter-widgets/controls",
          "model_name": "ProgressStyleModel",
          "model_module_version": "1.5.0",
          "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": ""
          }
        },
        "76752a2a4b3b40c1bcb31683891e59ae": {
          "model_module": "@jupyter-widgets/base",
          "model_name": "LayoutModel",
          "model_module_version": "1.2.0",
          "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
          }
        },
        "9e6899efa51b40d18655da8822de36c7": {
          "model_module": "@jupyter-widgets/controls",
          "model_name": "DescriptionStyleModel",
          "model_module_version": "1.5.0",
          "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": ""
          }
        },
        "2c2be68a7811405cae35755b7c7837be": {
          "model_module": "@jupyter-widgets/controls",
          "model_name": "HBoxModel",
          "model_module_version": "1.5.0",
          "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_4e5df798f71e4e22a2e5acc5a88b7096",
              "IPY_MODEL_09ea0a6e4d6e4349b18885f2755a55fa",
              "IPY_MODEL_b649705caf8241e7a51f5fa1d0a07057"
            ],
            "layout": "IPY_MODEL_bf384cbdb2ce48fabd2d9e5c8f76f0c2"
          }
        },
        "4e5df798f71e4e22a2e5acc5a88b7096": {
          "model_module": "@jupyter-widgets/controls",
          "model_name": "HTMLModel",
          "model_module_version": "1.5.0",
          "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_6e7e3e94918c42258c1b5c0880017903",
            "placeholder": "​",
            "style": "IPY_MODEL_e5a4fdf16dbc49e6a669b40d0af8e3c1",
            "value": "  0%"
          }
        },
        "09ea0a6e4d6e4349b18885f2755a55fa": {
          "model_module": "@jupyter-widgets/controls",
          "model_name": "FloatProgressModel",
          "model_module_version": "1.5.0",
          "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": "danger",
            "description": "",
            "description_tooltip": null,
            "layout": "IPY_MODEL_839b67fbea974c089655de010c30e7fd",
            "max": 3185,
            "min": 0,
            "orientation": "horizontal",
            "style": "IPY_MODEL_cc503c5ccfdb43008744ebd0ae341780",
            "value": 0
          }
        },
        "b649705caf8241e7a51f5fa1d0a07057": {
          "model_module": "@jupyter-widgets/controls",
          "model_name": "HTMLModel",
          "model_module_version": "1.5.0",
          "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_41fbf948af614e3dbf9f4ee4e8c7875f",
            "placeholder": "​",
            "style": "IPY_MODEL_0e1ad1fbe4b746f5874668593997ad85",
            "value": " 0/3185 [00:00&lt;?, ?it/s]"
          }
        },
        "bf384cbdb2ce48fabd2d9e5c8f76f0c2": {
          "model_module": "@jupyter-widgets/base",
          "model_name": "LayoutModel",
          "model_module_version": "1.2.0",
          "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
          }
        },
        "6e7e3e94918c42258c1b5c0880017903": {
          "model_module": "@jupyter-widgets/base",
          "model_name": "LayoutModel",
          "model_module_version": "1.2.0",
          "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
          }
        },
        "e5a4fdf16dbc49e6a669b40d0af8e3c1": {
          "model_module": "@jupyter-widgets/controls",
          "model_name": "DescriptionStyleModel",
          "model_module_version": "1.5.0",
          "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": ""
          }
        },
        "839b67fbea974c089655de010c30e7fd": {
          "model_module": "@jupyter-widgets/base",
          "model_name": "LayoutModel",
          "model_module_version": "1.2.0",
          "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
          }
        },
        "cc503c5ccfdb43008744ebd0ae341780": {
          "model_module": "@jupyter-widgets/controls",
          "model_name": "ProgressStyleModel",
          "model_module_version": "1.5.0",
          "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": ""
          }
        },
        "41fbf948af614e3dbf9f4ee4e8c7875f": {
          "model_module": "@jupyter-widgets/base",
          "model_name": "LayoutModel",
          "model_module_version": "1.2.0",
          "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
          }
        },
        "0e1ad1fbe4b746f5874668593997ad85": {
          "model_module": "@jupyter-widgets/controls",
          "model_name": "DescriptionStyleModel",
          "model_module_version": "1.5.0",
          "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": ""
          }
        }
      }
    }
  },
  "nbformat": 4,
  "nbformat_minor": 0
}