--- a
+++ b/BERT_and_DistilBERT_models.ipynb
@@ -0,0 +1,3753 @@
+{
+  "cells": [
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "vRgACNW3tqNj"
+      },
+      "source": [
+        "# Loading the Data and required libraries"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 3,
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "aNk1wBiStAUh",
+        "outputId": "2f5e4ee3-310b-4262-c57e-c090afc7c025"
+      },
+      "outputs": [
+        {
+          "name": "stdout",
+          "output_type": "stream",
+          "text": [
+            "Collecting transformers\n",
+            "  Downloading transformers-4.32.0-py3-none-any.whl (7.5 MB)\n",
+            "\u001b[2K     \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m7.5/7.5 MB\u001b[0m \u001b[31m51.8 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
+            "\u001b[?25hRequirement already satisfied: filelock in /usr/local/lib/python3.10/dist-packages (from transformers) (3.12.2)\n",
+            "Collecting huggingface-hub<1.0,>=0.15.1 (from transformers)\n",
+            "  Downloading huggingface_hub-0.16.4-py3-none-any.whl (268 kB)\n",
+            "\u001b[2K     \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m268.8/268.8 kB\u001b[0m \u001b[31m32.6 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
+            "\u001b[?25hRequirement already satisfied: numpy>=1.17 in /usr/local/lib/python3.10/dist-packages (from transformers) (1.23.5)\n",
+            "Requirement already satisfied: packaging>=20.0 in /usr/local/lib/python3.10/dist-packages (from transformers) (23.1)\n",
+            "Requirement already satisfied: pyyaml>=5.1 in /usr/local/lib/python3.10/dist-packages (from transformers) (6.0.1)\n",
+            "Requirement already satisfied: regex!=2019.12.17 in /usr/local/lib/python3.10/dist-packages (from transformers) (2023.6.3)\n",
+            "Requirement already satisfied: requests in /usr/local/lib/python3.10/dist-packages (from transformers) (2.31.0)\n",
+            "Collecting tokenizers!=0.11.3,<0.14,>=0.11.1 (from transformers)\n",
+            "  Downloading tokenizers-0.13.3-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl (7.8 MB)\n",
+            "\u001b[2K     \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m7.8/7.8 MB\u001b[0m \u001b[31m82.0 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
+            "\u001b[?25hCollecting safetensors>=0.3.1 (from transformers)\n",
+            "  Downloading safetensors-0.3.3-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl (1.3 MB)\n",
+            "\u001b[2K     \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m1.3/1.3 MB\u001b[0m \u001b[31m62.8 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
+            "\u001b[?25hRequirement already satisfied: tqdm>=4.27 in /usr/local/lib/python3.10/dist-packages (from transformers) (4.66.1)\n",
+            "Requirement already satisfied: fsspec in /usr/local/lib/python3.10/dist-packages (from huggingface-hub<1.0,>=0.15.1->transformers) (2023.6.0)\n",
+            "Requirement already satisfied: typing-extensions>=3.7.4.3 in /usr/local/lib/python3.10/dist-packages (from huggingface-hub<1.0,>=0.15.1->transformers) (4.7.1)\n",
+            "Requirement already satisfied: charset-normalizer<4,>=2 in /usr/local/lib/python3.10/dist-packages (from requests->transformers) (3.2.0)\n",
+            "Requirement already satisfied: idna<4,>=2.5 in /usr/local/lib/python3.10/dist-packages (from requests->transformers) (3.4)\n",
+            "Requirement already satisfied: urllib3<3,>=1.21.1 in /usr/local/lib/python3.10/dist-packages (from requests->transformers) (2.0.4)\n",
+            "Requirement already satisfied: certifi>=2017.4.17 in /usr/local/lib/python3.10/dist-packages (from requests->transformers) (2023.7.22)\n",
+            "Installing collected packages: tokenizers, safetensors, huggingface-hub, transformers\n",
+            "Successfully installed huggingface-hub-0.16.4 safetensors-0.3.3 tokenizers-0.13.3 transformers-4.32.0\n"
+          ]
+        }
+      ],
+      "source": [
+        "!pip install transformers"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 4,
+      "metadata": {
+        "id": "prj9lpais5N4"
+      },
+      "outputs": [],
+      "source": [
+        "import pandas as pd\n",
+        "import numpy as np\n",
+        "import re\n",
+        "import datetime\n",
+        "import seaborn as sns\n",
+        "import matplotlib.pyplot as plt\n",
+        "from google.colab import drive\n",
+        "\n",
+        "from sklearn.model_selection import train_test_split\n",
+        "\n",
+        "import string\n",
+        "import nltk\n",
+        "from tqdm import tqdm\n",
+        "from nltk import word_tokenize\n",
+        "from nltk.stem.porter import PorterStemmer\n",
+        "from nltk.corpus import stopwords\n",
+        "\n",
+        "from keras.models import Sequential\n",
+        "from keras.layers import LSTM, Dense, Dropout, Embedding\n",
+        "from keras.optimizers import RMSprop\n",
+        "from keras.utils import to_categorical\n",
+        "from keras.callbacks import ModelCheckpoint\n",
+        "from keras.preprocessing.text import Tokenizer\n",
+        "from keras.utils import pad_sequences\n",
+        "\n",
+        "import tensorflow as tf\n",
+        "import tensorflow_hub as hub\n",
+        "from keras.models import Model\n",
+        "from transformers import AutoTokenizer, AutoModel, AutoModelForSequenceClassification, glue_convert_examples_to_features\n",
+        "from transformers import TFBertForSequenceClassification, BertTokenizer\n",
+        "from transformers import TFDistilBertForSequenceClassification, DistilBertTokenizer"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 5,
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "a53Y-zB0t-s4",
+        "outputId": "5ea45f77-fdb1-4c3f-9a8a-deed4657d65d"
+      },
+      "outputs": [
+        {
+          "name": "stdout",
+          "output_type": "stream",
+          "text": [
+            "Mounted at /content/drive\n"
+          ]
+        }
+      ],
+      "source": [
+        "drive.mount('/content/drive')\n",
+        "DIR = \"drive/My Drive/mimic3 data/\""
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 6,
+      "metadata": {
+        "id": "HdwF0kFHuH4y"
+      },
+      "outputs": [],
+      "source": [
+        "adm_notes = pd.read_csv(DIR + \"readmission.csv\", low_memory=False)"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "# Natural Language"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 8,
+      "metadata": {
+        "id": "3I8Wd3mXufr0"
+      },
+      "outputs": [],
+      "source": [
+        "def clean_text(texts):\n",
+        "    texts = texts.str.replace('\\n',' ')\n",
+        "    texts = texts.str.replace('\\r',' ')\n",
+        "\n",
+        "    table = str.maketrans('', '', string.punctuation + '0123456789')\n",
+        "    texts = [text.lower().translate(table) for text in texts]\n",
+        "\n",
+        "    return texts"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 9,
+      "metadata": {
+        "id": "fl8eOt6fuh8a"
+      },
+      "outputs": [],
+      "source": [
+        "adm_notes = adm_notes.dropna(subset=['TEXT'])\n",
+        "\n",
+        "adm_notes['TEXT'] = clean_text(adm_notes['TEXT'])"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "# Model\n",
+        "## Words, Train and Test"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "Repartition data"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 11,
+      "metadata": {
+        "id": "LKzK3GxJumVx"
+      },
+      "outputs": [],
+      "source": [
+        "df_train, df_test = train_test_split(adm_notes, test_size=0.3)"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "Subsample non-readmitted patients to match size of readmitted ones"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 12,
+      "metadata": {
+        "id": "UAJWbduRuoq2"
+      },
+      "outputs": [],
+      "source": [
+        "rows_pos = df_train['READM_WITHIN_30'] == 1\n",
+        "df_train_pos = df_train.loc[rows_pos]\n",
+        "df_train_neg = df_train.loc[~rows_pos]\n",
+        "\n",
+        "df_train = pd.concat([df_train_pos, df_train_neg.sample(n = len(df_train_pos))], axis = 0)\n",
+        "df_train = df_train.sample(n = len(df_train)).reset_index(drop = True)"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 13,
+      "metadata": {
+        "id": "SlIebKFsusjM"
+      },
+      "outputs": [],
+      "source": [
+        "df_test, df_val = train_test_split(df_test, test_size=0.5)\n",
+        "\n",
+        "df_test = df_test.sample(n = len(df_test)).reset_index(drop = True)\n",
+        "df_val = df_val.sample(n = len(df_val)).reset_index(drop = True)"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "# Recurrent Neural Network\n",
+        "## BERT"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 15,
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/",
+          "height": 234,
+          "referenced_widgets": [
+            "178d630eadaa4dd9b74dbcefd224d3b4",
+            "a140a2bca40541fda4002767cf417f96",
+            "4ccffeed03d14112961d4cebf2f2fb72",
+            "492f20122ea447c58fbefd31e96a14a5",
+            "e423f72267404deea786df62c644fc4c",
+            "99df75cdc78540ab8baed488a4abe8a3",
+            "1e511ecd44a5435aa5abd7c51116d528",
+            "565bdc888b8a42409755ac6b8108c34a",
+            "873cb5c833d440efb858c1c3479d17da",
+            "f47a00ac8acc4b389f496b99092c19b1",
+            "3e34788d30ba4e5392c5a85fbf58a67e",
+            "3754f80f086f4708875f0b1163b25808",
+            "95341e5af7004275956e9940746432d5",
+            "6ee730438ba946baa28d1f64ef2a78eb",
+            "bc140a927bf44f0fb434a766c5d2ab90",
+            "6fde21134e1b4e3aaa417948a030e552",
+            "cabcd31714754e16b694a6406c1d03e3",
+            "1612224012c64b5583852e66ca628ee0",
+            "4964e4353c794b0aa93dd1e0e1da5105",
+            "eed9f5d7668a45d18cf796d2166653fb",
+            "baeee7ca6ab149af96d69cecff72f01b",
+            "2693830bbe424cd6b818570f604ab23e",
+            "e0011432a92743eea923f745f2336957",
+            "053b48adee434f5e8886ea321c7cd4d8",
+            "dfb12e3b904c4fcf97c5f5e27c5233d7",
+            "4a57d71ae43444e2b9085d2b8fba55dc",
+            "5f9a0b7dce1f42bba47ae40caf4bfc67",
+            "e128fd325857405eb3c9ec496b6a8250",
+            "345da4d0f7ce422d92b8c2f4a252e6b4",
+            "c66c5c6f43934f8ca9e6f0abf44d6684",
+            "259138c7918e495ca7d19f72d7d19946",
+            "634a08a9500b491e9125bd4624f815fb",
+            "06dc764f212e431db2f4071a595cf86f",
+            "e63c1acab3004ffca2b8ddaa5910e9ad",
+            "6bb8b04fb92c4a4a912aafdb98dbe33f",
+            "adf0996e064746f7a0d0ca3a8d9479cf",
+            "e3e9707eb7254739b3cbef0d57b29755",
+            "d5ff4f4192874c7b973b4b80c5de7508",
+            "3acfe3a035f34483bd8671b8e1e5dbcd",
+            "4df665f906e04efbbe8eec6fb4a31cf8",
+            "86cd199b5b7343b1af73f551a974fb3b",
+            "cad5edc94bf144d88ccd1f3a00b7aa3a",
+            "c98096746def4baf92adc948a764a5bf",
+            "60b6208f7dea431e9967b38f62ce9495"
+          ]
+        },
+        "id": "zq80VpF6uxNq",
+        "outputId": "ac991d9f-4c29-444d-cfd8-e8c3148e3774"
+      },
+      "outputs": [
+        {
+          "data": {
+            "application/vnd.jupyter.widget-view+json": {
+              "model_id": "178d630eadaa4dd9b74dbcefd224d3b4",
+              "version_major": 2,
+              "version_minor": 0
+            },
+            "text/plain": [
+              "Downloading (…)solve/main/vocab.txt:   0%|          | 0.00/232k [00:00<?, ?B/s]"
+            ]
+          },
+          "metadata": {},
+          "output_type": "display_data"
+        },
+        {
+          "data": {
+            "application/vnd.jupyter.widget-view+json": {
+              "model_id": "3754f80f086f4708875f0b1163b25808",
+              "version_major": 2,
+              "version_minor": 0
+            },
+            "text/plain": [
+              "Downloading (…)okenizer_config.json:   0%|          | 0.00/28.0 [00:00<?, ?B/s]"
+            ]
+          },
+          "metadata": {},
+          "output_type": "display_data"
+        },
+        {
+          "data": {
+            "application/vnd.jupyter.widget-view+json": {
+              "model_id": "e0011432a92743eea923f745f2336957",
+              "version_major": 2,
+              "version_minor": 0
+            },
+            "text/plain": [
+              "Downloading (…)lve/main/config.json:   0%|          | 0.00/570 [00:00<?, ?B/s]"
+            ]
+          },
+          "metadata": {},
+          "output_type": "display_data"
+        },
+        {
+          "data": {
+            "application/vnd.jupyter.widget-view+json": {
+              "model_id": "e63c1acab3004ffca2b8ddaa5910e9ad",
+              "version_major": 2,
+              "version_minor": 0
+            },
+            "text/plain": [
+              "Downloading model.safetensors:   0%|          | 0.00/440M [00:00<?, ?B/s]"
+            ]
+          },
+          "metadata": {},
+          "output_type": "display_data"
+        },
+        {
+          "name": "stderr",
+          "output_type": "stream",
+          "text": [
+            "All PyTorch model weights were used when initializing TFBertForSequenceClassification.\n",
+            "\n",
+            "Some weights or buffers of the TF 2.0 model TFBertForSequenceClassification were not initialized from the PyTorch model and are newly initialized: ['classifier.weight', 'classifier.bias']\n",
+            "You should probably TRAIN this model on a down-stream task to be able to use it for predictions and inference.\n"
+          ]
+        }
+      ],
+      "source": [
+        "tokenizer = BertTokenizer.from_pretrained(\"bert-base-uncased\")\n",
+        "model = TFBertForSequenceClassification.from_pretrained(\"bert-base-uncased\")"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 15,
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "nlzLJDCHvPDT",
+        "outputId": "768deef3-2ba9-43b4-f9bb-4f9242be7506"
+      },
+      "outputs": [
+        {
+          "name": "stderr",
+          "output_type": "stream",
+          "text": [
+            "100%|██████████| 4142/4142 [03:03<00:00, 22.60it/s]\n",
+            "100%|██████████| 6582/6582 [03:59<00:00, 27.49it/s]\n",
+            "100%|██████████| 6582/6582 [04:00<00:00, 27.33it/s]\n"
+          ]
+        }
+      ],
+      "source": [
+        "pad_token=0\n",
+        "pad_token_segment_id=0\n",
+        "max_length=512\n",
+        "\n",
+        "def convert_to_input(texts):\n",
+        "  input_ids, attention_masks, token_type_ids = [], [], []\n",
+        "\n",
+        "  for text in tqdm(texts, position=0, leave=True):\n",
+        "    inputs = tokenizer.encode_plus(text, add_special_tokens=True, max_length=max_length, truncation=True, return_token_type_ids=True)\n",
+        "\n",
+        "    i, t = inputs[\"input_ids\"], inputs[\"token_type_ids\"]\n",
+        "    m = [1] * len(i)\n",
+        "\n",
+        "    padding_length = max_length - len(i)\n",
+        "\n",
+        "    i = i + ([pad_token] * padding_length)\n",
+        "    m = m + ([0] * padding_length)\n",
+        "    t = t + ([pad_token_segment_id] * padding_length)\n",
+        "\n",
+        "    input_ids.append(i)\n",
+        "    attention_masks.append(m)\n",
+        "    token_type_ids.append(t)\n",
+        "\n",
+        "  return [np.asarray(input_ids),\n",
+        "            np.asarray(attention_masks),\n",
+        "            np.asarray(token_type_ids)]\n",
+        "\n",
+        "X_train_input = convert_to_input(df_train['TEXT'])\n",
+        "X_test_input = convert_to_input(df_test['TEXT'])\n",
+        "X_val_input = convert_to_input(df_val['TEXT'])"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 16,
+      "metadata": {
+        "id": "8wR8s6xMvV8k"
+      },
+      "outputs": [],
+      "source": [
+        "def to_features(input_ids,attention_masks,token_type_ids,y):\n",
+        "  return {\"input_ids\": input_ids,\n",
+        "          \"attention_mask\": attention_masks,\n",
+        "          \"token_type_ids\": token_type_ids},y\n",
+        "\n",
+        "train_data = (X_train_input[0], X_train_input[1], X_train_input[2], df_train['READM_WITHIN_30'])\n",
+        "test_data = (X_test_input[0], X_test_input[1], X_test_input[2], df_test['READM_WITHIN_30'])\n",
+        "val_data = (X_val_input[0], X_val_input[1], X_val_input[2], df_val['READM_WITHIN_30'])\n",
+        "\n",
+        "train_ds = tf.data.Dataset.from_tensor_slices(train_data).map(to_features).shuffle(len(df_train['READM_WITHIN_30'])).batch(10)\n",
+        "test_ds = tf.data.Dataset.from_tensor_slices(test_data).map(to_features).batch(10)\n",
+        "val_ds = tf.data.Dataset.from_tensor_slices(val_data).map(to_features).batch(10)"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 17,
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "4NOJzpDYvrZa",
+        "outputId": "d2d224ce-a113-44b2-ac57-463effd8c8e4"
+      },
+      "outputs": [
+        {
+          "name": "stdout",
+          "output_type": "stream",
+          "text": [
+            "Epoch 1/3\n",
+            "415/415 [==============================] - 862s 2s/step - loss: 0.6968 - accuracy: 0.5048 - val_loss: 0.6672 - val_accuracy: 0.8943\n",
+            "Epoch 2/3\n",
+            "415/415 [==============================] - 750s 2s/step - loss: 0.6814 - accuracy: 0.5649 - val_loss: 0.7449 - val_accuracy: 0.4926\n",
+            "Epoch 3/3\n",
+            "415/415 [==============================] - 750s 2s/step - loss: 0.6675 - accuracy: 0.6132 - val_loss: 0.6305 - val_accuracy: 0.6392\n"
+          ]
+        }
+      ],
+      "source": [
+        "optimizer = tf.keras.optimizers.Adam(learning_rate=3e-5)\n",
+        "loss = tf.keras.losses.SparseCategoricalCrossentropy(from_logits=True)\n",
+        "metric = tf.keras.metrics.SparseCategoricalAccuracy('accuracy')\n",
+        "\n",
+        "model.compile(optimizer=optimizer, loss=loss, metrics=[metric])\n",
+        "\n",
+        "history = model.fit(train_ds, epochs=3, validation_data=val_ds)"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 20,
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "mmmkop05CuP4",
+        "outputId": "88a5a481-aef3-4a54-ebbb-183826670653"
+      },
+      "outputs": [
+        {
+          "name": "stdout",
+          "output_type": "stream",
+          "text": [
+            "659/659 [==============================] - 268s 406ms/step\n",
+            "              precision    recall  f1-score   support\n",
+            "\n",
+            "           0      0.958     0.648     0.773      6160\n",
+            "           1      0.102     0.585     0.174       422\n",
+            "\n",
+            "    accuracy                          0.644      6582\n",
+            "   macro avg      0.530     0.617     0.473      6582\n",
+            "weighted avg      0.903     0.644     0.734      6582\n",
+            "\n",
+            "0.6165176647996553\n"
+          ]
+        }
+      ],
+      "source": [
+        "from sklearn.metrics import classification_report, roc_auc_score\n",
+        "\n",
+        "y_pred = model.predict(test_ds, verbose=1)\n",
+        "y_pred_class = np.argmax(y_pred[0], axis=1)\n",
+        "\n",
+        "print(classification_report(df_test['READM_WITHIN_30'], y_pred_class, digits=3))\n",
+        "print(roc_auc_score(df_test['READM_WITHIN_30'], y_pred_class))"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 21,
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/",
+          "height": 399
+        },
+        "id": "uNLlIBmKCwcn",
+        "outputId": "3887419e-5c8c-44ae-c711-0517080ef98e"
+      },
+      "outputs": [
+        {
+          "data": {
+            "image/png": "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",
+            "text/plain": [
+              "<Figure size 900x400 with 2 Axes>"
+            ]
+          },
+          "metadata": {},
+          "output_type": "display_data"
+        }
+      ],
+      "source": [
+        "sns.set('talk', 'whitegrid', 'dark', font_scale=0.7,\n",
+        "        rc={\"lines.linewidth\": 1, 'grid.linestyle': '--'})\n",
+        "\n",
+        "fig, ax = plt.subplots(nrows=1, ncols=2, figsize=(9, 4))\n",
+        "\n",
+        "ax[0].plot(history.history['accuracy'])\n",
+        "ax[0].plot(history.history['val_accuracy'])\n",
+        "ax[0].set_title('Model accuracy')\n",
+        "ax[0].set_ylabel('Accuracy')\n",
+        "ax[0].set_xlabel('Epoch')\n",
+        "ax[0].legend(['Train', 'Test'], loc='upper left')\n",
+        "\n",
+        "ax[1].plot(history.history['loss'])\n",
+        "ax[1].plot(history.history['val_loss'])\n",
+        "ax[1].set_title('Model loss')\n",
+        "ax[1].set_ylabel('Loss')\n",
+        "ax[1].set_xlabel('Epoch')\n",
+        "ax[1].legend(['Train', 'Test'], loc='upper left')\n",
+        "\n",
+        "fig.tight_layout()\n",
+        "plt.show()"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 22,
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "T_9pzxMjxZIa",
+        "outputId": "f04d0a24-9273-4431-9eb4-82d4d13253d4"
+      },
+      "outputs": [
+        {
+          "name": "stdout",
+          "output_type": "stream",
+          "text": [
+            "Model: \"tf_bert_for_sequence_classification\"\n",
+            "_________________________________________________________________\n",
+            " Layer (type)                Output Shape              Param #   \n",
+            "=================================================================\n",
+            " bert (TFBertMainLayer)      multiple                  109482240 \n",
+            "                                                                 \n",
+            " dropout_37 (Dropout)        multiple                  0         \n",
+            "                                                                 \n",
+            " classifier (Dense)          multiple                  1538      \n",
+            "                                                                 \n",
+            "=================================================================\n",
+            "Total params: 109,483,778\n",
+            "Trainable params: 109,483,778\n",
+            "Non-trainable params: 0\n",
+            "_________________________________________________________________\n"
+          ]
+        }
+      ],
+      "source": [
+        "model.summary()"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "# Recurrent Neural Network\n",
+        "## DistilBERT"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 17,
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/",
+          "height": 252,
+          "referenced_widgets": [
+            "79d57f935064437480a5fbda2484296a",
+            "13977ea565854a70b3c6e5326353d073",
+            "37a9e25f56b34c2b883c24625ff5b2b3",
+            "0546ef8deffa45f094f7d6c3c592bfd5",
+            "c788f6072cd14fd78cdf717101a08f78",
+            "2abcd910a6004c16b9ea6065069aa6a0",
+            "a10f69294a894811b60fa718a6093b45",
+            "46a5aa46b4464ca689c1ac5fb03cc45c",
+            "3c5f50e2fdb94c2e9e19e2f7584d0e05",
+            "f1f92a7ea6df4e1384eb17c5110071f0",
+            "3fd1c28ad8084c2dab865acb0fe42258",
+            "783bc9c99fc74fafbf42149d7f13bc1e",
+            "a196cfb3144e4a7e8274e7cab4a89d9d",
+            "d77e71b0a9944634857c776bf1cfde53",
+            "adf28c1e165c41c99fd392b5089dd304",
+            "b894c5adb54047ad8c352f34b23686fc",
+            "2a2b781ccce043599a06d89c5cbe5a15",
+            "aae4a428305d45c889b9b8e12b8cc90e",
+            "b9dafb0d592e4f5d8d6861ec804a2a68",
+            "d8c19b401dfd4a1ba7b157a9dde8ee0e",
+            "1fdd7a784c0548da9c819fcc7ab77ec7",
+            "e7c6da20ae904c97853d9a79ea8309b3",
+            "3e0a008a1b1f4ffe9cf10c5d19517ec4",
+            "8386ab8b2ac8471ab80d2abef9d46df3",
+            "b18cc5b7d66c4a75a4610ebb0496a796",
+            "9c15290253a842379e3d32277b04171a",
+            "52adc82f81f44d39beaa2e160cd65f84",
+            "10f7160b224d4b99bcee1d7861c48fed",
+            "e7b9e76d51b647a2a23123c10f0a05f2",
+            "512a794302e84fe5913e9c73575823eb",
+            "7c1dc0f2c9ca40d79b2fd279164b6108",
+            "68c1ee9f9e3842b0bad42068ead18bd9",
+            "f817891cfe4f48b4bd0b4b66e5d8287c",
+            "37e2b828a59b4a76856112d220094106",
+            "53c2049832884610832f6c4a4fb101e5",
+            "d36cf93f48f645b1aee13ef823fc0d7e",
+            "ff69874079c141d192118af82f29e897",
+            "41e9d07259344489bce31d3dbbcee038",
+            "a0a3b1a15b494dcbb95895031fc8badd",
+            "cea662b72d9c4bcf9b36cf983df2d769",
+            "b8cd74e6833a4ddb95b3d812ccb52dfc",
+            "050e1436ee394ceebdb81719c12745b6",
+            "089ae2bdb98f4c2885404989e12a84ff",
+            "c5c6fa9c480548389f658f4482971f2d"
+          ]
+        },
+        "id": "3xjWEBVQE41U",
+        "outputId": "b4b53868-a6d7-4c20-d88e-5c80b3b04efc"
+      },
+      "outputs": [
+        {
+          "data": {
+            "application/vnd.jupyter.widget-view+json": {
+              "model_id": "79d57f935064437480a5fbda2484296a",
+              "version_major": 2,
+              "version_minor": 0
+            },
+            "text/plain": [
+              "Downloading (…)solve/main/vocab.txt:   0%|          | 0.00/232k [00:00<?, ?B/s]"
+            ]
+          },
+          "metadata": {},
+          "output_type": "display_data"
+        },
+        {
+          "data": {
+            "application/vnd.jupyter.widget-view+json": {
+              "model_id": "783bc9c99fc74fafbf42149d7f13bc1e",
+              "version_major": 2,
+              "version_minor": 0
+            },
+            "text/plain": [
+              "Downloading (…)okenizer_config.json:   0%|          | 0.00/28.0 [00:00<?, ?B/s]"
+            ]
+          },
+          "metadata": {},
+          "output_type": "display_data"
+        },
+        {
+          "data": {
+            "application/vnd.jupyter.widget-view+json": {
+              "model_id": "3e0a008a1b1f4ffe9cf10c5d19517ec4",
+              "version_major": 2,
+              "version_minor": 0
+            },
+            "text/plain": [
+              "Downloading (…)lve/main/config.json:   0%|          | 0.00/483 [00:00<?, ?B/s]"
+            ]
+          },
+          "metadata": {},
+          "output_type": "display_data"
+        },
+        {
+          "data": {
+            "application/vnd.jupyter.widget-view+json": {
+              "model_id": "37e2b828a59b4a76856112d220094106",
+              "version_major": 2,
+              "version_minor": 0
+            },
+            "text/plain": [
+              "Downloading model.safetensors:   0%|          | 0.00/268M [00:00<?, ?B/s]"
+            ]
+          },
+          "metadata": {},
+          "output_type": "display_data"
+        },
+        {
+          "name": "stderr",
+          "output_type": "stream",
+          "text": [
+            "Some weights of the PyTorch model were not used when initializing the TF 2.0 model TFDistilBertForSequenceClassification: ['vocab_layer_norm.bias', 'vocab_transform.weight', 'vocab_transform.bias', 'vocab_layer_norm.weight', 'vocab_projector.bias']\n",
+            "- This IS expected if you are initializing TFDistilBertForSequenceClassification from a PyTorch model trained on another task or with another architecture (e.g. initializing a TFBertForSequenceClassification model from a BertForPreTraining model).\n",
+            "- This IS NOT expected if you are initializing TFDistilBertForSequenceClassification from a PyTorch model that you expect to be exactly identical (e.g. initializing a TFBertForSequenceClassification model from a BertForSequenceClassification model).\n",
+            "Some weights or buffers of the TF 2.0 model TFDistilBertForSequenceClassification were not initialized from the PyTorch model and are newly initialized: ['pre_classifier.weight', 'pre_classifier.bias', 'classifier.weight', 'classifier.bias']\n",
+            "You should probably TRAIN this model on a down-stream task to be able to use it for predictions and inference.\n"
+          ]
+        }
+      ],
+      "source": [
+        "tokenizer = DistilBertTokenizer.from_pretrained(\"distilbert-base-uncased\")\n",
+        "model = TFDistilBertForSequenceClassification.from_pretrained(\n",
+        "    \"distilbert-base-uncased\",\n",
+        "    num_labels = 2,\n",
+        ")"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 18,
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "0EQa9M8AIN2t",
+        "outputId": "046c9d7b-acf8-423d-9386-2a36909c9143"
+      },
+      "outputs": [
+        {
+          "name": "stderr",
+          "output_type": "stream",
+          "text": [
+            "100%|██████████| 4056/4056 [03:28<00:00, 19.42it/s]\n",
+            "100%|██████████| 6582/6582 [04:15<00:00, 25.71it/s]\n",
+            "100%|██████████| 6582/6582 [04:09<00:00, 26.37it/s]\n"
+          ]
+        }
+      ],
+      "source": [
+        "pad_token=0\n",
+        "pad_token_segment_id=0\n",
+        "max_length=512\n",
+        "\n",
+        "def convert_to_input(texts):\n",
+        "  input_ids, attention_masks, token_type_ids = [], [], []\n",
+        "\n",
+        "  for text in tqdm(texts, position=0, leave=True):\n",
+        "    inputs = tokenizer.encode_plus(text, add_special_tokens=True, max_length=max_length, truncation=True, return_token_type_ids=True)\n",
+        "\n",
+        "    i, t = inputs[\"input_ids\"], inputs[\"token_type_ids\"]\n",
+        "    m = [1] * len(i)\n",
+        "\n",
+        "    padding_length = max_length - len(i)\n",
+        "\n",
+        "    i = i + ([pad_token] * padding_length)\n",
+        "    m = m + ([0] * padding_length)\n",
+        "    t = t + ([pad_token_segment_id] * padding_length)\n",
+        "\n",
+        "    input_ids.append(i)\n",
+        "    attention_masks.append(m)\n",
+        "    token_type_ids.append(t)\n",
+        "\n",
+        "  return [np.asarray(input_ids),\n",
+        "            np.asarray(attention_masks),\n",
+        "            np.asarray(token_type_ids)]\n",
+        "\n",
+        "X_train_input = convert_to_input(df_train['TEXT'])\n",
+        "X_test_input = convert_to_input(df_test['TEXT'])\n",
+        "X_val_input = convert_to_input(df_val['TEXT'])"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 22,
+      "metadata": {
+        "id": "nTlVbphJtj7v"
+      },
+      "outputs": [],
+      "source": [
+        "def to_features(input_ids,attention_masks,token_type_ids,y):\n",
+        "  return {\"input_ids\": input_ids,\n",
+        "          \"attention_mask\": attention_masks},y\n",
+        "\n",
+        "train_data = (X_train_input[0], X_train_input[1], X_train_input[2], df_train['READM_WITHIN_30'])\n",
+        "test_data = (X_test_input[0], X_test_input[1], X_test_input[2], df_test['READM_WITHIN_30'])\n",
+        "val_data = (X_val_input[0], X_val_input[1], X_val_input[2], df_val['READM_WITHIN_30'])\n",
+        "\n",
+        "train_ds = tf.data.Dataset.from_tensor_slices(train_data).map(to_features).shuffle(len(df_train['READM_WITHIN_30'])).batch(16)\n",
+        "test_ds = tf.data.Dataset.from_tensor_slices(test_data).map(to_features).batch(16)\n",
+        "val_ds = tf.data.Dataset.from_tensor_slices(val_data).map(to_features).batch(16)"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 23,
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "KOIyOSzitmxb",
+        "outputId": "90c00e3c-cc56-40b9-a8a8-9156b728b94c"
+      },
+      "outputs": [
+        {
+          "name": "stdout",
+          "output_type": "stream",
+          "text": [
+            "Epoch 1/3\n",
+            "254/254 [==============================] - 413s 1s/step - loss: 0.6967 - accuracy: 0.5035 - val_loss: 0.7198 - val_accuracy: 0.0779\n",
+            "Epoch 2/3\n",
+            "254/254 [==============================] - 387s 2s/step - loss: 0.6751 - accuracy: 0.5799 - val_loss: 0.6040 - val_accuracy: 0.7458\n",
+            "Epoch 3/3\n",
+            "254/254 [==============================] - 387s 2s/step - loss: 0.6234 - accuracy: 0.6647 - val_loss: 0.5900 - val_accuracy: 0.6603\n"
+          ]
+        }
+      ],
+      "source": [
+        "optimizer = tf.keras.optimizers.Adam(learning_rate=3e-5)\n",
+        "loss = tf.keras.losses.SparseCategoricalCrossentropy(from_logits=True)\n",
+        "metric = tf.keras.metrics.SparseCategoricalAccuracy('accuracy')\n",
+        "\n",
+        "model.compile(optimizer=optimizer, loss=loss, metrics=[metric])\n",
+        "\n",
+        "history = model.fit(train_ds, epochs=3, validation_data=val_ds)"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 24,
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "ufnlJX6VtpOh",
+        "outputId": "b398b4f0-e59b-4a37-878b-716df5a7543f"
+      },
+      "outputs": [
+        {
+          "name": "stdout",
+          "output_type": "stream",
+          "text": [
+            "412/412 [==============================] - 134s 322ms/step\n",
+            "              precision    recall  f1-score   support\n",
+            "\n",
+            "           0      0.956     0.665     0.784      6124\n",
+            "           1      0.116     0.590     0.194       458\n",
+            "\n",
+            "    accuracy                          0.660      6582\n",
+            "   macro avg      0.536     0.627     0.489      6582\n",
+            "weighted avg      0.897     0.660     0.743      6582\n",
+            "\n",
+            "0.6271406221923053\n"
+          ]
+        }
+      ],
+      "source": [
+        "from sklearn.metrics import classification_report, roc_auc_score\n",
+        "\n",
+        "y_pred = model.predict(test_ds, verbose=1)\n",
+        "y_pred_class = np.argmax(y_pred[0], axis=1)\n",
+        "\n",
+        "print(classification_report(df_test['READM_WITHIN_30'], y_pred_class, digits=3))\n",
+        "print(roc_auc_score(df_test['READM_WITHIN_30'], y_pred_class))"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 25,
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/",
+          "height": 399
+        },
+        "id": "4vnCDWdVtrPy",
+        "outputId": "0138712b-681a-41d7-c16f-a3330d24a800"
+      },
+      "outputs": [
+        {
+          "data": {
+            "image/png": "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",
+            "text/plain": [
+              "<Figure size 900x400 with 2 Axes>"
+            ]
+          },
+          "metadata": {},
+          "output_type": "display_data"
+        }
+      ],
+      "source": [
+        "sns.set('talk', 'whitegrid', 'dark', font_scale=0.7,\n",
+        "        rc={\"lines.linewidth\": 1, 'grid.linestyle': '--'})\n",
+        "\n",
+        "fig, ax = plt.subplots(nrows=1, ncols=2, figsize=(9, 4))\n",
+        "\n",
+        "ax[0].plot(history.history['accuracy'])\n",
+        "ax[0].plot(history.history['val_accuracy'])\n",
+        "ax[0].set_title('Model accuracy')\n",
+        "ax[0].set_ylabel('Accuracy')\n",
+        "ax[0].set_xlabel('Epoch')\n",
+        "ax[0].legend(['Train', 'Test'], loc='upper left')\n",
+        "\n",
+        "ax[1].plot(history.history['loss'])\n",
+        "ax[1].plot(history.history['val_loss'])\n",
+        "ax[1].set_title('Model loss')\n",
+        "ax[1].set_ylabel('Loss')\n",
+        "ax[1].set_xlabel('Epoch')\n",
+        "ax[1].legend(['Train', 'Test'], loc='upper left')\n",
+        "\n",
+        "fig.tight_layout()\n",
+        "plt.show()"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 26,
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "gBgcr-tTtto7",
+        "outputId": "75663c76-ca38-4aab-bbff-4e44eafbae50"
+      },
+      "outputs": [
+        {
+          "name": "stdout",
+          "output_type": "stream",
+          "text": [
+            "Model: \"tf_distil_bert_for_sequence_classification\"\n",
+            "_________________________________________________________________\n",
+            " Layer (type)                Output Shape              Param #   \n",
+            "=================================================================\n",
+            " distilbert (TFDistilBertMai  multiple                 66362880  \n",
+            " nLayer)                                                         \n",
+            "                                                                 \n",
+            " pre_classifier (Dense)      multiple                  590592    \n",
+            "                                                                 \n",
+            " classifier (Dense)          multiple                  1538      \n",
+            "                                                                 \n",
+            " dropout_57 (Dropout)        multiple                  0         \n",
+            "                                                                 \n",
+            "=================================================================\n",
+            "Total params: 66,955,010\n",
+            "Trainable params: 66,955,010\n",
+            "Non-trainable params: 0\n",
+            "_________________________________________________________________\n"
+          ]
+        }
+      ],
+      "source": [
+        "model.summary()"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "id": "s8xqYj6gtv2d"
+      },
+      "outputs": [],
+      "source": []
+    }
+  ],
+  "metadata": {
+    "accelerator": "GPU",
+    "colab": {
+      "gpuType": "T4",
+      "provenance": [],
+      "toc_visible": true
+    },
+    "kernelspec": {
+      "display_name": "Python 3",
+      "name": "python3"
+    },
+    "language_info": {
+      "name": "python"
+    },
+    "widgets": {
+      "application/vnd.jupyter.widget-state+json": {
+        "050e1436ee394ceebdb81719c12745b6": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_module_version": "1.5.0",
+          "model_name": "ProgressStyleModel",
+          "state": {
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "ProgressStyleModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "StyleView",
+            "bar_color": null,
+            "description_width": ""
+          }
+        },
+        "053b48adee434f5e8886ea321c7cd4d8": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_module_version": "1.5.0",
+          "model_name": "HTMLModel",
+          "state": {
+            "_dom_classes": [],
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "HTMLModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/controls",
+            "_view_module_version": "1.5.0",
+            "_view_name": "HTMLView",
+            "description": "",
+            "description_tooltip": null,
+            "layout": "IPY_MODEL_e128fd325857405eb3c9ec496b6a8250",
+            "placeholder": "​",
+            "style": "IPY_MODEL_345da4d0f7ce422d92b8c2f4a252e6b4",
+            "value": "Downloading (…)lve/main/config.json: 100%"
+          }
+        },
+        "0546ef8deffa45f094f7d6c3c592bfd5": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_module_version": "1.5.0",
+          "model_name": "HTMLModel",
+          "state": {
+            "_dom_classes": [],
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "HTMLModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/controls",
+            "_view_module_version": "1.5.0",
+            "_view_name": "HTMLView",
+            "description": "",
+            "description_tooltip": null,
+            "layout": "IPY_MODEL_f1f92a7ea6df4e1384eb17c5110071f0",
+            "placeholder": "​",
+            "style": "IPY_MODEL_3fd1c28ad8084c2dab865acb0fe42258",
+            "value": " 232k/232k [00:00&lt;00:00, 14.6MB/s]"
+          }
+        },
+        "06dc764f212e431db2f4071a595cf86f": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_module_version": "1.5.0",
+          "model_name": "DescriptionStyleModel",
+          "state": {
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "DescriptionStyleModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "StyleView",
+            "description_width": ""
+          }
+        },
+        "089ae2bdb98f4c2885404989e12a84ff": {
+          "model_module": "@jupyter-widgets/base",
+          "model_module_version": "1.2.0",
+          "model_name": "LayoutModel",
+          "state": {
+            "_model_module": "@jupyter-widgets/base",
+            "_model_module_version": "1.2.0",
+            "_model_name": "LayoutModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "LayoutView",
+            "align_content": null,
+            "align_items": null,
+            "align_self": null,
+            "border": null,
+            "bottom": null,
+            "display": null,
+            "flex": null,
+            "flex_flow": null,
+            "grid_area": null,
+            "grid_auto_columns": null,
+            "grid_auto_flow": null,
+            "grid_auto_rows": null,
+            "grid_column": null,
+            "grid_gap": null,
+            "grid_row": null,
+            "grid_template_areas": null,
+            "grid_template_columns": null,
+            "grid_template_rows": null,
+            "height": null,
+            "justify_content": null,
+            "justify_items": null,
+            "left": null,
+            "margin": null,
+            "max_height": null,
+            "max_width": null,
+            "min_height": null,
+            "min_width": null,
+            "object_fit": null,
+            "object_position": null,
+            "order": null,
+            "overflow": null,
+            "overflow_x": null,
+            "overflow_y": null,
+            "padding": null,
+            "right": null,
+            "top": null,
+            "visibility": null,
+            "width": null
+          }
+        },
+        "10f7160b224d4b99bcee1d7861c48fed": {
+          "model_module": "@jupyter-widgets/base",
+          "model_module_version": "1.2.0",
+          "model_name": "LayoutModel",
+          "state": {
+            "_model_module": "@jupyter-widgets/base",
+            "_model_module_version": "1.2.0",
+            "_model_name": "LayoutModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "LayoutView",
+            "align_content": null,
+            "align_items": null,
+            "align_self": null,
+            "border": null,
+            "bottom": null,
+            "display": null,
+            "flex": null,
+            "flex_flow": null,
+            "grid_area": null,
+            "grid_auto_columns": null,
+            "grid_auto_flow": null,
+            "grid_auto_rows": null,
+            "grid_column": null,
+            "grid_gap": null,
+            "grid_row": null,
+            "grid_template_areas": null,
+            "grid_template_columns": null,
+            "grid_template_rows": null,
+            "height": null,
+            "justify_content": null,
+            "justify_items": null,
+            "left": null,
+            "margin": null,
+            "max_height": null,
+            "max_width": null,
+            "min_height": null,
+            "min_width": null,
+            "object_fit": null,
+            "object_position": null,
+            "order": null,
+            "overflow": null,
+            "overflow_x": null,
+            "overflow_y": null,
+            "padding": null,
+            "right": null,
+            "top": null,
+            "visibility": null,
+            "width": null
+          }
+        },
+        "13977ea565854a70b3c6e5326353d073": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_module_version": "1.5.0",
+          "model_name": "HTMLModel",
+          "state": {
+            "_dom_classes": [],
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "HTMLModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/controls",
+            "_view_module_version": "1.5.0",
+            "_view_name": "HTMLView",
+            "description": "",
+            "description_tooltip": null,
+            "layout": "IPY_MODEL_2abcd910a6004c16b9ea6065069aa6a0",
+            "placeholder": "​",
+            "style": "IPY_MODEL_a10f69294a894811b60fa718a6093b45",
+            "value": "Downloading (…)solve/main/vocab.txt: 100%"
+          }
+        },
+        "1612224012c64b5583852e66ca628ee0": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_module_version": "1.5.0",
+          "model_name": "DescriptionStyleModel",
+          "state": {
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "DescriptionStyleModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "StyleView",
+            "description_width": ""
+          }
+        },
+        "178d630eadaa4dd9b74dbcefd224d3b4": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_module_version": "1.5.0",
+          "model_name": "HBoxModel",
+          "state": {
+            "_dom_classes": [],
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "HBoxModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/controls",
+            "_view_module_version": "1.5.0",
+            "_view_name": "HBoxView",
+            "box_style": "",
+            "children": [
+              "IPY_MODEL_a140a2bca40541fda4002767cf417f96",
+              "IPY_MODEL_4ccffeed03d14112961d4cebf2f2fb72",
+              "IPY_MODEL_492f20122ea447c58fbefd31e96a14a5"
+            ],
+            "layout": "IPY_MODEL_e423f72267404deea786df62c644fc4c"
+          }
+        },
+        "1e511ecd44a5435aa5abd7c51116d528": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_module_version": "1.5.0",
+          "model_name": "DescriptionStyleModel",
+          "state": {
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "DescriptionStyleModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "StyleView",
+            "description_width": ""
+          }
+        },
+        "1fdd7a784c0548da9c819fcc7ab77ec7": {
+          "model_module": "@jupyter-widgets/base",
+          "model_module_version": "1.2.0",
+          "model_name": "LayoutModel",
+          "state": {
+            "_model_module": "@jupyter-widgets/base",
+            "_model_module_version": "1.2.0",
+            "_model_name": "LayoutModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "LayoutView",
+            "align_content": null,
+            "align_items": null,
+            "align_self": null,
+            "border": null,
+            "bottom": null,
+            "display": null,
+            "flex": null,
+            "flex_flow": null,
+            "grid_area": null,
+            "grid_auto_columns": null,
+            "grid_auto_flow": null,
+            "grid_auto_rows": null,
+            "grid_column": null,
+            "grid_gap": null,
+            "grid_row": null,
+            "grid_template_areas": null,
+            "grid_template_columns": null,
+            "grid_template_rows": null,
+            "height": null,
+            "justify_content": null,
+            "justify_items": null,
+            "left": null,
+            "margin": null,
+            "max_height": null,
+            "max_width": null,
+            "min_height": null,
+            "min_width": null,
+            "object_fit": null,
+            "object_position": null,
+            "order": null,
+            "overflow": null,
+            "overflow_x": null,
+            "overflow_y": null,
+            "padding": null,
+            "right": null,
+            "top": null,
+            "visibility": null,
+            "width": null
+          }
+        },
+        "259138c7918e495ca7d19f72d7d19946": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_module_version": "1.5.0",
+          "model_name": "ProgressStyleModel",
+          "state": {
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "ProgressStyleModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "StyleView",
+            "bar_color": null,
+            "description_width": ""
+          }
+        },
+        "2693830bbe424cd6b818570f604ab23e": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_module_version": "1.5.0",
+          "model_name": "DescriptionStyleModel",
+          "state": {
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "DescriptionStyleModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "StyleView",
+            "description_width": ""
+          }
+        },
+        "2a2b781ccce043599a06d89c5cbe5a15": {
+          "model_module": "@jupyter-widgets/base",
+          "model_module_version": "1.2.0",
+          "model_name": "LayoutModel",
+          "state": {
+            "_model_module": "@jupyter-widgets/base",
+            "_model_module_version": "1.2.0",
+            "_model_name": "LayoutModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "LayoutView",
+            "align_content": null,
+            "align_items": null,
+            "align_self": null,
+            "border": null,
+            "bottom": null,
+            "display": null,
+            "flex": null,
+            "flex_flow": null,
+            "grid_area": null,
+            "grid_auto_columns": null,
+            "grid_auto_flow": null,
+            "grid_auto_rows": null,
+            "grid_column": null,
+            "grid_gap": null,
+            "grid_row": null,
+            "grid_template_areas": null,
+            "grid_template_columns": null,
+            "grid_template_rows": null,
+            "height": null,
+            "justify_content": null,
+            "justify_items": null,
+            "left": null,
+            "margin": null,
+            "max_height": null,
+            "max_width": null,
+            "min_height": null,
+            "min_width": null,
+            "object_fit": null,
+            "object_position": null,
+            "order": null,
+            "overflow": null,
+            "overflow_x": null,
+            "overflow_y": null,
+            "padding": null,
+            "right": null,
+            "top": null,
+            "visibility": null,
+            "width": null
+          }
+        },
+        "2abcd910a6004c16b9ea6065069aa6a0": {
+          "model_module": "@jupyter-widgets/base",
+          "model_module_version": "1.2.0",
+          "model_name": "LayoutModel",
+          "state": {
+            "_model_module": "@jupyter-widgets/base",
+            "_model_module_version": "1.2.0",
+            "_model_name": "LayoutModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "LayoutView",
+            "align_content": null,
+            "align_items": null,
+            "align_self": null,
+            "border": null,
+            "bottom": null,
+            "display": null,
+            "flex": null,
+            "flex_flow": null,
+            "grid_area": null,
+            "grid_auto_columns": null,
+            "grid_auto_flow": null,
+            "grid_auto_rows": null,
+            "grid_column": null,
+            "grid_gap": null,
+            "grid_row": null,
+            "grid_template_areas": null,
+            "grid_template_columns": null,
+            "grid_template_rows": null,
+            "height": null,
+            "justify_content": null,
+            "justify_items": null,
+            "left": null,
+            "margin": null,
+            "max_height": null,
+            "max_width": null,
+            "min_height": null,
+            "min_width": null,
+            "object_fit": null,
+            "object_position": null,
+            "order": null,
+            "overflow": null,
+            "overflow_x": null,
+            "overflow_y": null,
+            "padding": null,
+            "right": null,
+            "top": null,
+            "visibility": null,
+            "width": null
+          }
+        },
+        "345da4d0f7ce422d92b8c2f4a252e6b4": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_module_version": "1.5.0",
+          "model_name": "DescriptionStyleModel",
+          "state": {
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "DescriptionStyleModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "StyleView",
+            "description_width": ""
+          }
+        },
+        "3754f80f086f4708875f0b1163b25808": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_module_version": "1.5.0",
+          "model_name": "HBoxModel",
+          "state": {
+            "_dom_classes": [],
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "HBoxModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/controls",
+            "_view_module_version": "1.5.0",
+            "_view_name": "HBoxView",
+            "box_style": "",
+            "children": [
+              "IPY_MODEL_95341e5af7004275956e9940746432d5",
+              "IPY_MODEL_6ee730438ba946baa28d1f64ef2a78eb",
+              "IPY_MODEL_bc140a927bf44f0fb434a766c5d2ab90"
+            ],
+            "layout": "IPY_MODEL_6fde21134e1b4e3aaa417948a030e552"
+          }
+        },
+        "37a9e25f56b34c2b883c24625ff5b2b3": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_module_version": "1.5.0",
+          "model_name": "FloatProgressModel",
+          "state": {
+            "_dom_classes": [],
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "FloatProgressModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/controls",
+            "_view_module_version": "1.5.0",
+            "_view_name": "ProgressView",
+            "bar_style": "success",
+            "description": "",
+            "description_tooltip": null,
+            "layout": "IPY_MODEL_46a5aa46b4464ca689c1ac5fb03cc45c",
+            "max": 231508,
+            "min": 0,
+            "orientation": "horizontal",
+            "style": "IPY_MODEL_3c5f50e2fdb94c2e9e19e2f7584d0e05",
+            "value": 231508
+          }
+        },
+        "37e2b828a59b4a76856112d220094106": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_module_version": "1.5.0",
+          "model_name": "HBoxModel",
+          "state": {
+            "_dom_classes": [],
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "HBoxModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/controls",
+            "_view_module_version": "1.5.0",
+            "_view_name": "HBoxView",
+            "box_style": "",
+            "children": [
+              "IPY_MODEL_53c2049832884610832f6c4a4fb101e5",
+              "IPY_MODEL_d36cf93f48f645b1aee13ef823fc0d7e",
+              "IPY_MODEL_ff69874079c141d192118af82f29e897"
+            ],
+            "layout": "IPY_MODEL_41e9d07259344489bce31d3dbbcee038"
+          }
+        },
+        "3acfe3a035f34483bd8671b8e1e5dbcd": {
+          "model_module": "@jupyter-widgets/base",
+          "model_module_version": "1.2.0",
+          "model_name": "LayoutModel",
+          "state": {
+            "_model_module": "@jupyter-widgets/base",
+            "_model_module_version": "1.2.0",
+            "_model_name": "LayoutModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "LayoutView",
+            "align_content": null,
+            "align_items": null,
+            "align_self": null,
+            "border": null,
+            "bottom": null,
+            "display": null,
+            "flex": null,
+            "flex_flow": null,
+            "grid_area": null,
+            "grid_auto_columns": null,
+            "grid_auto_flow": null,
+            "grid_auto_rows": null,
+            "grid_column": null,
+            "grid_gap": null,
+            "grid_row": null,
+            "grid_template_areas": null,
+            "grid_template_columns": null,
+            "grid_template_rows": null,
+            "height": null,
+            "justify_content": null,
+            "justify_items": null,
+            "left": null,
+            "margin": null,
+            "max_height": null,
+            "max_width": null,
+            "min_height": null,
+            "min_width": null,
+            "object_fit": null,
+            "object_position": null,
+            "order": null,
+            "overflow": null,
+            "overflow_x": null,
+            "overflow_y": null,
+            "padding": null,
+            "right": null,
+            "top": null,
+            "visibility": null,
+            "width": null
+          }
+        },
+        "3c5f50e2fdb94c2e9e19e2f7584d0e05": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_module_version": "1.5.0",
+          "model_name": "ProgressStyleModel",
+          "state": {
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "ProgressStyleModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "StyleView",
+            "bar_color": null,
+            "description_width": ""
+          }
+        },
+        "3e0a008a1b1f4ffe9cf10c5d19517ec4": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_module_version": "1.5.0",
+          "model_name": "HBoxModel",
+          "state": {
+            "_dom_classes": [],
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "HBoxModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/controls",
+            "_view_module_version": "1.5.0",
+            "_view_name": "HBoxView",
+            "box_style": "",
+            "children": [
+              "IPY_MODEL_8386ab8b2ac8471ab80d2abef9d46df3",
+              "IPY_MODEL_b18cc5b7d66c4a75a4610ebb0496a796",
+              "IPY_MODEL_9c15290253a842379e3d32277b04171a"
+            ],
+            "layout": "IPY_MODEL_52adc82f81f44d39beaa2e160cd65f84"
+          }
+        },
+        "3e34788d30ba4e5392c5a85fbf58a67e": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_module_version": "1.5.0",
+          "model_name": "DescriptionStyleModel",
+          "state": {
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "DescriptionStyleModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "StyleView",
+            "description_width": ""
+          }
+        },
+        "3fd1c28ad8084c2dab865acb0fe42258": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_module_version": "1.5.0",
+          "model_name": "DescriptionStyleModel",
+          "state": {
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "DescriptionStyleModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "StyleView",
+            "description_width": ""
+          }
+        },
+        "41e9d07259344489bce31d3dbbcee038": {
+          "model_module": "@jupyter-widgets/base",
+          "model_module_version": "1.2.0",
+          "model_name": "LayoutModel",
+          "state": {
+            "_model_module": "@jupyter-widgets/base",
+            "_model_module_version": "1.2.0",
+            "_model_name": "LayoutModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "LayoutView",
+            "align_content": null,
+            "align_items": null,
+            "align_self": null,
+            "border": null,
+            "bottom": null,
+            "display": null,
+            "flex": null,
+            "flex_flow": null,
+            "grid_area": null,
+            "grid_auto_columns": null,
+            "grid_auto_flow": null,
+            "grid_auto_rows": null,
+            "grid_column": null,
+            "grid_gap": null,
+            "grid_row": null,
+            "grid_template_areas": null,
+            "grid_template_columns": null,
+            "grid_template_rows": null,
+            "height": null,
+            "justify_content": null,
+            "justify_items": null,
+            "left": null,
+            "margin": null,
+            "max_height": null,
+            "max_width": null,
+            "min_height": null,
+            "min_width": null,
+            "object_fit": null,
+            "object_position": null,
+            "order": null,
+            "overflow": null,
+            "overflow_x": null,
+            "overflow_y": null,
+            "padding": null,
+            "right": null,
+            "top": null,
+            "visibility": null,
+            "width": null
+          }
+        },
+        "46a5aa46b4464ca689c1ac5fb03cc45c": {
+          "model_module": "@jupyter-widgets/base",
+          "model_module_version": "1.2.0",
+          "model_name": "LayoutModel",
+          "state": {
+            "_model_module": "@jupyter-widgets/base",
+            "_model_module_version": "1.2.0",
+            "_model_name": "LayoutModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "LayoutView",
+            "align_content": null,
+            "align_items": null,
+            "align_self": null,
+            "border": null,
+            "bottom": null,
+            "display": null,
+            "flex": null,
+            "flex_flow": null,
+            "grid_area": null,
+            "grid_auto_columns": null,
+            "grid_auto_flow": null,
+            "grid_auto_rows": null,
+            "grid_column": null,
+            "grid_gap": null,
+            "grid_row": null,
+            "grid_template_areas": null,
+            "grid_template_columns": null,
+            "grid_template_rows": null,
+            "height": null,
+            "justify_content": null,
+            "justify_items": null,
+            "left": null,
+            "margin": null,
+            "max_height": null,
+            "max_width": null,
+            "min_height": null,
+            "min_width": null,
+            "object_fit": null,
+            "object_position": null,
+            "order": null,
+            "overflow": null,
+            "overflow_x": null,
+            "overflow_y": null,
+            "padding": null,
+            "right": null,
+            "top": null,
+            "visibility": null,
+            "width": null
+          }
+        },
+        "492f20122ea447c58fbefd31e96a14a5": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_module_version": "1.5.0",
+          "model_name": "HTMLModel",
+          "state": {
+            "_dom_classes": [],
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "HTMLModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/controls",
+            "_view_module_version": "1.5.0",
+            "_view_name": "HTMLView",
+            "description": "",
+            "description_tooltip": null,
+            "layout": "IPY_MODEL_f47a00ac8acc4b389f496b99092c19b1",
+            "placeholder": "​",
+            "style": "IPY_MODEL_3e34788d30ba4e5392c5a85fbf58a67e",
+            "value": " 232k/232k [00:00&lt;00:00, 10.3MB/s]"
+          }
+        },
+        "4964e4353c794b0aa93dd1e0e1da5105": {
+          "model_module": "@jupyter-widgets/base",
+          "model_module_version": "1.2.0",
+          "model_name": "LayoutModel",
+          "state": {
+            "_model_module": "@jupyter-widgets/base",
+            "_model_module_version": "1.2.0",
+            "_model_name": "LayoutModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "LayoutView",
+            "align_content": null,
+            "align_items": null,
+            "align_self": null,
+            "border": null,
+            "bottom": null,
+            "display": null,
+            "flex": null,
+            "flex_flow": null,
+            "grid_area": null,
+            "grid_auto_columns": null,
+            "grid_auto_flow": null,
+            "grid_auto_rows": null,
+            "grid_column": null,
+            "grid_gap": null,
+            "grid_row": null,
+            "grid_template_areas": null,
+            "grid_template_columns": null,
+            "grid_template_rows": null,
+            "height": null,
+            "justify_content": null,
+            "justify_items": null,
+            "left": null,
+            "margin": null,
+            "max_height": null,
+            "max_width": null,
+            "min_height": null,
+            "min_width": null,
+            "object_fit": null,
+            "object_position": null,
+            "order": null,
+            "overflow": null,
+            "overflow_x": null,
+            "overflow_y": null,
+            "padding": null,
+            "right": null,
+            "top": null,
+            "visibility": null,
+            "width": null
+          }
+        },
+        "4a57d71ae43444e2b9085d2b8fba55dc": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_module_version": "1.5.0",
+          "model_name": "HTMLModel",
+          "state": {
+            "_dom_classes": [],
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "HTMLModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/controls",
+            "_view_module_version": "1.5.0",
+            "_view_name": "HTMLView",
+            "description": "",
+            "description_tooltip": null,
+            "layout": "IPY_MODEL_634a08a9500b491e9125bd4624f815fb",
+            "placeholder": "​",
+            "style": "IPY_MODEL_06dc764f212e431db2f4071a595cf86f",
+            "value": " 570/570 [00:00&lt;00:00, 19.0kB/s]"
+          }
+        },
+        "4ccffeed03d14112961d4cebf2f2fb72": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_module_version": "1.5.0",
+          "model_name": "FloatProgressModel",
+          "state": {
+            "_dom_classes": [],
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "FloatProgressModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/controls",
+            "_view_module_version": "1.5.0",
+            "_view_name": "ProgressView",
+            "bar_style": "success",
+            "description": "",
+            "description_tooltip": null,
+            "layout": "IPY_MODEL_565bdc888b8a42409755ac6b8108c34a",
+            "max": 231508,
+            "min": 0,
+            "orientation": "horizontal",
+            "style": "IPY_MODEL_873cb5c833d440efb858c1c3479d17da",
+            "value": 231508
+          }
+        },
+        "4df665f906e04efbbe8eec6fb4a31cf8": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_module_version": "1.5.0",
+          "model_name": "DescriptionStyleModel",
+          "state": {
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "DescriptionStyleModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "StyleView",
+            "description_width": ""
+          }
+        },
+        "512a794302e84fe5913e9c73575823eb": {
+          "model_module": "@jupyter-widgets/base",
+          "model_module_version": "1.2.0",
+          "model_name": "LayoutModel",
+          "state": {
+            "_model_module": "@jupyter-widgets/base",
+            "_model_module_version": "1.2.0",
+            "_model_name": "LayoutModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "LayoutView",
+            "align_content": null,
+            "align_items": null,
+            "align_self": null,
+            "border": null,
+            "bottom": null,
+            "display": null,
+            "flex": null,
+            "flex_flow": null,
+            "grid_area": null,
+            "grid_auto_columns": null,
+            "grid_auto_flow": null,
+            "grid_auto_rows": null,
+            "grid_column": null,
+            "grid_gap": null,
+            "grid_row": null,
+            "grid_template_areas": null,
+            "grid_template_columns": null,
+            "grid_template_rows": null,
+            "height": null,
+            "justify_content": null,
+            "justify_items": null,
+            "left": null,
+            "margin": null,
+            "max_height": null,
+            "max_width": null,
+            "min_height": null,
+            "min_width": null,
+            "object_fit": null,
+            "object_position": null,
+            "order": null,
+            "overflow": null,
+            "overflow_x": null,
+            "overflow_y": null,
+            "padding": null,
+            "right": null,
+            "top": null,
+            "visibility": null,
+            "width": null
+          }
+        },
+        "52adc82f81f44d39beaa2e160cd65f84": {
+          "model_module": "@jupyter-widgets/base",
+          "model_module_version": "1.2.0",
+          "model_name": "LayoutModel",
+          "state": {
+            "_model_module": "@jupyter-widgets/base",
+            "_model_module_version": "1.2.0",
+            "_model_name": "LayoutModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "LayoutView",
+            "align_content": null,
+            "align_items": null,
+            "align_self": null,
+            "border": null,
+            "bottom": null,
+            "display": null,
+            "flex": null,
+            "flex_flow": null,
+            "grid_area": null,
+            "grid_auto_columns": null,
+            "grid_auto_flow": null,
+            "grid_auto_rows": null,
+            "grid_column": null,
+            "grid_gap": null,
+            "grid_row": null,
+            "grid_template_areas": null,
+            "grid_template_columns": null,
+            "grid_template_rows": null,
+            "height": null,
+            "justify_content": null,
+            "justify_items": null,
+            "left": null,
+            "margin": null,
+            "max_height": null,
+            "max_width": null,
+            "min_height": null,
+            "min_width": null,
+            "object_fit": null,
+            "object_position": null,
+            "order": null,
+            "overflow": null,
+            "overflow_x": null,
+            "overflow_y": null,
+            "padding": null,
+            "right": null,
+            "top": null,
+            "visibility": null,
+            "width": null
+          }
+        },
+        "53c2049832884610832f6c4a4fb101e5": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_module_version": "1.5.0",
+          "model_name": "HTMLModel",
+          "state": {
+            "_dom_classes": [],
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "HTMLModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/controls",
+            "_view_module_version": "1.5.0",
+            "_view_name": "HTMLView",
+            "description": "",
+            "description_tooltip": null,
+            "layout": "IPY_MODEL_a0a3b1a15b494dcbb95895031fc8badd",
+            "placeholder": "​",
+            "style": "IPY_MODEL_cea662b72d9c4bcf9b36cf983df2d769",
+            "value": "Downloading model.safetensors: 100%"
+          }
+        },
+        "565bdc888b8a42409755ac6b8108c34a": {
+          "model_module": "@jupyter-widgets/base",
+          "model_module_version": "1.2.0",
+          "model_name": "LayoutModel",
+          "state": {
+            "_model_module": "@jupyter-widgets/base",
+            "_model_module_version": "1.2.0",
+            "_model_name": "LayoutModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "LayoutView",
+            "align_content": null,
+            "align_items": null,
+            "align_self": null,
+            "border": null,
+            "bottom": null,
+            "display": null,
+            "flex": null,
+            "flex_flow": null,
+            "grid_area": null,
+            "grid_auto_columns": null,
+            "grid_auto_flow": null,
+            "grid_auto_rows": null,
+            "grid_column": null,
+            "grid_gap": null,
+            "grid_row": null,
+            "grid_template_areas": null,
+            "grid_template_columns": null,
+            "grid_template_rows": null,
+            "height": null,
+            "justify_content": null,
+            "justify_items": null,
+            "left": null,
+            "margin": null,
+            "max_height": null,
+            "max_width": null,
+            "min_height": null,
+            "min_width": null,
+            "object_fit": null,
+            "object_position": null,
+            "order": null,
+            "overflow": null,
+            "overflow_x": null,
+            "overflow_y": null,
+            "padding": null,
+            "right": null,
+            "top": null,
+            "visibility": null,
+            "width": null
+          }
+        },
+        "5f9a0b7dce1f42bba47ae40caf4bfc67": {
+          "model_module": "@jupyter-widgets/base",
+          "model_module_version": "1.2.0",
+          "model_name": "LayoutModel",
+          "state": {
+            "_model_module": "@jupyter-widgets/base",
+            "_model_module_version": "1.2.0",
+            "_model_name": "LayoutModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "LayoutView",
+            "align_content": null,
+            "align_items": null,
+            "align_self": null,
+            "border": null,
+            "bottom": null,
+            "display": null,
+            "flex": null,
+            "flex_flow": null,
+            "grid_area": null,
+            "grid_auto_columns": null,
+            "grid_auto_flow": null,
+            "grid_auto_rows": null,
+            "grid_column": null,
+            "grid_gap": null,
+            "grid_row": null,
+            "grid_template_areas": null,
+            "grid_template_columns": null,
+            "grid_template_rows": null,
+            "height": null,
+            "justify_content": null,
+            "justify_items": null,
+            "left": null,
+            "margin": null,
+            "max_height": null,
+            "max_width": null,
+            "min_height": null,
+            "min_width": null,
+            "object_fit": null,
+            "object_position": null,
+            "order": null,
+            "overflow": null,
+            "overflow_x": null,
+            "overflow_y": null,
+            "padding": null,
+            "right": null,
+            "top": null,
+            "visibility": null,
+            "width": null
+          }
+        },
+        "60b6208f7dea431e9967b38f62ce9495": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_module_version": "1.5.0",
+          "model_name": "DescriptionStyleModel",
+          "state": {
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "DescriptionStyleModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "StyleView",
+            "description_width": ""
+          }
+        },
+        "634a08a9500b491e9125bd4624f815fb": {
+          "model_module": "@jupyter-widgets/base",
+          "model_module_version": "1.2.0",
+          "model_name": "LayoutModel",
+          "state": {
+            "_model_module": "@jupyter-widgets/base",
+            "_model_module_version": "1.2.0",
+            "_model_name": "LayoutModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "LayoutView",
+            "align_content": null,
+            "align_items": null,
+            "align_self": null,
+            "border": null,
+            "bottom": null,
+            "display": null,
+            "flex": null,
+            "flex_flow": null,
+            "grid_area": null,
+            "grid_auto_columns": null,
+            "grid_auto_flow": null,
+            "grid_auto_rows": null,
+            "grid_column": null,
+            "grid_gap": null,
+            "grid_row": null,
+            "grid_template_areas": null,
+            "grid_template_columns": null,
+            "grid_template_rows": null,
+            "height": null,
+            "justify_content": null,
+            "justify_items": null,
+            "left": null,
+            "margin": null,
+            "max_height": null,
+            "max_width": null,
+            "min_height": null,
+            "min_width": null,
+            "object_fit": null,
+            "object_position": null,
+            "order": null,
+            "overflow": null,
+            "overflow_x": null,
+            "overflow_y": null,
+            "padding": null,
+            "right": null,
+            "top": null,
+            "visibility": null,
+            "width": null
+          }
+        },
+        "68c1ee9f9e3842b0bad42068ead18bd9": {
+          "model_module": "@jupyter-widgets/base",
+          "model_module_version": "1.2.0",
+          "model_name": "LayoutModel",
+          "state": {
+            "_model_module": "@jupyter-widgets/base",
+            "_model_module_version": "1.2.0",
+            "_model_name": "LayoutModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "LayoutView",
+            "align_content": null,
+            "align_items": null,
+            "align_self": null,
+            "border": null,
+            "bottom": null,
+            "display": null,
+            "flex": null,
+            "flex_flow": null,
+            "grid_area": null,
+            "grid_auto_columns": null,
+            "grid_auto_flow": null,
+            "grid_auto_rows": null,
+            "grid_column": null,
+            "grid_gap": null,
+            "grid_row": null,
+            "grid_template_areas": null,
+            "grid_template_columns": null,
+            "grid_template_rows": null,
+            "height": null,
+            "justify_content": null,
+            "justify_items": null,
+            "left": null,
+            "margin": null,
+            "max_height": null,
+            "max_width": null,
+            "min_height": null,
+            "min_width": null,
+            "object_fit": null,
+            "object_position": null,
+            "order": null,
+            "overflow": null,
+            "overflow_x": null,
+            "overflow_y": null,
+            "padding": null,
+            "right": null,
+            "top": null,
+            "visibility": null,
+            "width": null
+          }
+        },
+        "6bb8b04fb92c4a4a912aafdb98dbe33f": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_module_version": "1.5.0",
+          "model_name": "HTMLModel",
+          "state": {
+            "_dom_classes": [],
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "HTMLModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/controls",
+            "_view_module_version": "1.5.0",
+            "_view_name": "HTMLView",
+            "description": "",
+            "description_tooltip": null,
+            "layout": "IPY_MODEL_3acfe3a035f34483bd8671b8e1e5dbcd",
+            "placeholder": "​",
+            "style": "IPY_MODEL_4df665f906e04efbbe8eec6fb4a31cf8",
+            "value": "Downloading model.safetensors: 100%"
+          }
+        },
+        "6ee730438ba946baa28d1f64ef2a78eb": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_module_version": "1.5.0",
+          "model_name": "FloatProgressModel",
+          "state": {
+            "_dom_classes": [],
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "FloatProgressModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/controls",
+            "_view_module_version": "1.5.0",
+            "_view_name": "ProgressView",
+            "bar_style": "success",
+            "description": "",
+            "description_tooltip": null,
+            "layout": "IPY_MODEL_4964e4353c794b0aa93dd1e0e1da5105",
+            "max": 28,
+            "min": 0,
+            "orientation": "horizontal",
+            "style": "IPY_MODEL_eed9f5d7668a45d18cf796d2166653fb",
+            "value": 28
+          }
+        },
+        "6fde21134e1b4e3aaa417948a030e552": {
+          "model_module": "@jupyter-widgets/base",
+          "model_module_version": "1.2.0",
+          "model_name": "LayoutModel",
+          "state": {
+            "_model_module": "@jupyter-widgets/base",
+            "_model_module_version": "1.2.0",
+            "_model_name": "LayoutModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "LayoutView",
+            "align_content": null,
+            "align_items": null,
+            "align_self": null,
+            "border": null,
+            "bottom": null,
+            "display": null,
+            "flex": null,
+            "flex_flow": null,
+            "grid_area": null,
+            "grid_auto_columns": null,
+            "grid_auto_flow": null,
+            "grid_auto_rows": null,
+            "grid_column": null,
+            "grid_gap": null,
+            "grid_row": null,
+            "grid_template_areas": null,
+            "grid_template_columns": null,
+            "grid_template_rows": null,
+            "height": null,
+            "justify_content": null,
+            "justify_items": null,
+            "left": null,
+            "margin": null,
+            "max_height": null,
+            "max_width": null,
+            "min_height": null,
+            "min_width": null,
+            "object_fit": null,
+            "object_position": null,
+            "order": null,
+            "overflow": null,
+            "overflow_x": null,
+            "overflow_y": null,
+            "padding": null,
+            "right": null,
+            "top": null,
+            "visibility": null,
+            "width": null
+          }
+        },
+        "783bc9c99fc74fafbf42149d7f13bc1e": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_module_version": "1.5.0",
+          "model_name": "HBoxModel",
+          "state": {
+            "_dom_classes": [],
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "HBoxModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/controls",
+            "_view_module_version": "1.5.0",
+            "_view_name": "HBoxView",
+            "box_style": "",
+            "children": [
+              "IPY_MODEL_a196cfb3144e4a7e8274e7cab4a89d9d",
+              "IPY_MODEL_d77e71b0a9944634857c776bf1cfde53",
+              "IPY_MODEL_adf28c1e165c41c99fd392b5089dd304"
+            ],
+            "layout": "IPY_MODEL_b894c5adb54047ad8c352f34b23686fc"
+          }
+        },
+        "79d57f935064437480a5fbda2484296a": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_module_version": "1.5.0",
+          "model_name": "HBoxModel",
+          "state": {
+            "_dom_classes": [],
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "HBoxModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/controls",
+            "_view_module_version": "1.5.0",
+            "_view_name": "HBoxView",
+            "box_style": "",
+            "children": [
+              "IPY_MODEL_13977ea565854a70b3c6e5326353d073",
+              "IPY_MODEL_37a9e25f56b34c2b883c24625ff5b2b3",
+              "IPY_MODEL_0546ef8deffa45f094f7d6c3c592bfd5"
+            ],
+            "layout": "IPY_MODEL_c788f6072cd14fd78cdf717101a08f78"
+          }
+        },
+        "7c1dc0f2c9ca40d79b2fd279164b6108": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_module_version": "1.5.0",
+          "model_name": "ProgressStyleModel",
+          "state": {
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "ProgressStyleModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "StyleView",
+            "bar_color": null,
+            "description_width": ""
+          }
+        },
+        "8386ab8b2ac8471ab80d2abef9d46df3": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_module_version": "1.5.0",
+          "model_name": "HTMLModel",
+          "state": {
+            "_dom_classes": [],
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "HTMLModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/controls",
+            "_view_module_version": "1.5.0",
+            "_view_name": "HTMLView",
+            "description": "",
+            "description_tooltip": null,
+            "layout": "IPY_MODEL_10f7160b224d4b99bcee1d7861c48fed",
+            "placeholder": "​",
+            "style": "IPY_MODEL_e7b9e76d51b647a2a23123c10f0a05f2",
+            "value": "Downloading (…)lve/main/config.json: 100%"
+          }
+        },
+        "86cd199b5b7343b1af73f551a974fb3b": {
+          "model_module": "@jupyter-widgets/base",
+          "model_module_version": "1.2.0",
+          "model_name": "LayoutModel",
+          "state": {
+            "_model_module": "@jupyter-widgets/base",
+            "_model_module_version": "1.2.0",
+            "_model_name": "LayoutModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "LayoutView",
+            "align_content": null,
+            "align_items": null,
+            "align_self": null,
+            "border": null,
+            "bottom": null,
+            "display": null,
+            "flex": null,
+            "flex_flow": null,
+            "grid_area": null,
+            "grid_auto_columns": null,
+            "grid_auto_flow": null,
+            "grid_auto_rows": null,
+            "grid_column": null,
+            "grid_gap": null,
+            "grid_row": null,
+            "grid_template_areas": null,
+            "grid_template_columns": null,
+            "grid_template_rows": null,
+            "height": null,
+            "justify_content": null,
+            "justify_items": null,
+            "left": null,
+            "margin": null,
+            "max_height": null,
+            "max_width": null,
+            "min_height": null,
+            "min_width": null,
+            "object_fit": null,
+            "object_position": null,
+            "order": null,
+            "overflow": null,
+            "overflow_x": null,
+            "overflow_y": null,
+            "padding": null,
+            "right": null,
+            "top": null,
+            "visibility": null,
+            "width": null
+          }
+        },
+        "873cb5c833d440efb858c1c3479d17da": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_module_version": "1.5.0",
+          "model_name": "ProgressStyleModel",
+          "state": {
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "ProgressStyleModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "StyleView",
+            "bar_color": null,
+            "description_width": ""
+          }
+        },
+        "95341e5af7004275956e9940746432d5": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_module_version": "1.5.0",
+          "model_name": "HTMLModel",
+          "state": {
+            "_dom_classes": [],
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "HTMLModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/controls",
+            "_view_module_version": "1.5.0",
+            "_view_name": "HTMLView",
+            "description": "",
+            "description_tooltip": null,
+            "layout": "IPY_MODEL_cabcd31714754e16b694a6406c1d03e3",
+            "placeholder": "​",
+            "style": "IPY_MODEL_1612224012c64b5583852e66ca628ee0",
+            "value": "Downloading (…)okenizer_config.json: 100%"
+          }
+        },
+        "99df75cdc78540ab8baed488a4abe8a3": {
+          "model_module": "@jupyter-widgets/base",
+          "model_module_version": "1.2.0",
+          "model_name": "LayoutModel",
+          "state": {
+            "_model_module": "@jupyter-widgets/base",
+            "_model_module_version": "1.2.0",
+            "_model_name": "LayoutModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "LayoutView",
+            "align_content": null,
+            "align_items": null,
+            "align_self": null,
+            "border": null,
+            "bottom": null,
+            "display": null,
+            "flex": null,
+            "flex_flow": null,
+            "grid_area": null,
+            "grid_auto_columns": null,
+            "grid_auto_flow": null,
+            "grid_auto_rows": null,
+            "grid_column": null,
+            "grid_gap": null,
+            "grid_row": null,
+            "grid_template_areas": null,
+            "grid_template_columns": null,
+            "grid_template_rows": null,
+            "height": null,
+            "justify_content": null,
+            "justify_items": null,
+            "left": null,
+            "margin": null,
+            "max_height": null,
+            "max_width": null,
+            "min_height": null,
+            "min_width": null,
+            "object_fit": null,
+            "object_position": null,
+            "order": null,
+            "overflow": null,
+            "overflow_x": null,
+            "overflow_y": null,
+            "padding": null,
+            "right": null,
+            "top": null,
+            "visibility": null,
+            "width": null
+          }
+        },
+        "9c15290253a842379e3d32277b04171a": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_module_version": "1.5.0",
+          "model_name": "HTMLModel",
+          "state": {
+            "_dom_classes": [],
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "HTMLModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/controls",
+            "_view_module_version": "1.5.0",
+            "_view_name": "HTMLView",
+            "description": "",
+            "description_tooltip": null,
+            "layout": "IPY_MODEL_68c1ee9f9e3842b0bad42068ead18bd9",
+            "placeholder": "​",
+            "style": "IPY_MODEL_f817891cfe4f48b4bd0b4b66e5d8287c",
+            "value": " 483/483 [00:00&lt;00:00, 18.2kB/s]"
+          }
+        },
+        "a0a3b1a15b494dcbb95895031fc8badd": {
+          "model_module": "@jupyter-widgets/base",
+          "model_module_version": "1.2.0",
+          "model_name": "LayoutModel",
+          "state": {
+            "_model_module": "@jupyter-widgets/base",
+            "_model_module_version": "1.2.0",
+            "_model_name": "LayoutModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "LayoutView",
+            "align_content": null,
+            "align_items": null,
+            "align_self": null,
+            "border": null,
+            "bottom": null,
+            "display": null,
+            "flex": null,
+            "flex_flow": null,
+            "grid_area": null,
+            "grid_auto_columns": null,
+            "grid_auto_flow": null,
+            "grid_auto_rows": null,
+            "grid_column": null,
+            "grid_gap": null,
+            "grid_row": null,
+            "grid_template_areas": null,
+            "grid_template_columns": null,
+            "grid_template_rows": null,
+            "height": null,
+            "justify_content": null,
+            "justify_items": null,
+            "left": null,
+            "margin": null,
+            "max_height": null,
+            "max_width": null,
+            "min_height": null,
+            "min_width": null,
+            "object_fit": null,
+            "object_position": null,
+            "order": null,
+            "overflow": null,
+            "overflow_x": null,
+            "overflow_y": null,
+            "padding": null,
+            "right": null,
+            "top": null,
+            "visibility": null,
+            "width": null
+          }
+        },
+        "a10f69294a894811b60fa718a6093b45": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_module_version": "1.5.0",
+          "model_name": "DescriptionStyleModel",
+          "state": {
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "DescriptionStyleModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "StyleView",
+            "description_width": ""
+          }
+        },
+        "a140a2bca40541fda4002767cf417f96": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_module_version": "1.5.0",
+          "model_name": "HTMLModel",
+          "state": {
+            "_dom_classes": [],
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "HTMLModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/controls",
+            "_view_module_version": "1.5.0",
+            "_view_name": "HTMLView",
+            "description": "",
+            "description_tooltip": null,
+            "layout": "IPY_MODEL_99df75cdc78540ab8baed488a4abe8a3",
+            "placeholder": "​",
+            "style": "IPY_MODEL_1e511ecd44a5435aa5abd7c51116d528",
+            "value": "Downloading (…)solve/main/vocab.txt: 100%"
+          }
+        },
+        "a196cfb3144e4a7e8274e7cab4a89d9d": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_module_version": "1.5.0",
+          "model_name": "HTMLModel",
+          "state": {
+            "_dom_classes": [],
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "HTMLModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/controls",
+            "_view_module_version": "1.5.0",
+            "_view_name": "HTMLView",
+            "description": "",
+            "description_tooltip": null,
+            "layout": "IPY_MODEL_2a2b781ccce043599a06d89c5cbe5a15",
+            "placeholder": "​",
+            "style": "IPY_MODEL_aae4a428305d45c889b9b8e12b8cc90e",
+            "value": "Downloading (…)okenizer_config.json: 100%"
+          }
+        },
+        "aae4a428305d45c889b9b8e12b8cc90e": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_module_version": "1.5.0",
+          "model_name": "DescriptionStyleModel",
+          "state": {
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "DescriptionStyleModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "StyleView",
+            "description_width": ""
+          }
+        },
+        "adf0996e064746f7a0d0ca3a8d9479cf": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_module_version": "1.5.0",
+          "model_name": "FloatProgressModel",
+          "state": {
+            "_dom_classes": [],
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "FloatProgressModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/controls",
+            "_view_module_version": "1.5.0",
+            "_view_name": "ProgressView",
+            "bar_style": "success",
+            "description": "",
+            "description_tooltip": null,
+            "layout": "IPY_MODEL_86cd199b5b7343b1af73f551a974fb3b",
+            "max": 440449768,
+            "min": 0,
+            "orientation": "horizontal",
+            "style": "IPY_MODEL_cad5edc94bf144d88ccd1f3a00b7aa3a",
+            "value": 440449768
+          }
+        },
+        "adf28c1e165c41c99fd392b5089dd304": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_module_version": "1.5.0",
+          "model_name": "HTMLModel",
+          "state": {
+            "_dom_classes": [],
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "HTMLModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/controls",
+            "_view_module_version": "1.5.0",
+            "_view_name": "HTMLView",
+            "description": "",
+            "description_tooltip": null,
+            "layout": "IPY_MODEL_1fdd7a784c0548da9c819fcc7ab77ec7",
+            "placeholder": "​",
+            "style": "IPY_MODEL_e7c6da20ae904c97853d9a79ea8309b3",
+            "value": " 28.0/28.0 [00:00&lt;00:00, 1.12kB/s]"
+          }
+        },
+        "b18cc5b7d66c4a75a4610ebb0496a796": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_module_version": "1.5.0",
+          "model_name": "FloatProgressModel",
+          "state": {
+            "_dom_classes": [],
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "FloatProgressModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/controls",
+            "_view_module_version": "1.5.0",
+            "_view_name": "ProgressView",
+            "bar_style": "success",
+            "description": "",
+            "description_tooltip": null,
+            "layout": "IPY_MODEL_512a794302e84fe5913e9c73575823eb",
+            "max": 483,
+            "min": 0,
+            "orientation": "horizontal",
+            "style": "IPY_MODEL_7c1dc0f2c9ca40d79b2fd279164b6108",
+            "value": 483
+          }
+        },
+        "b894c5adb54047ad8c352f34b23686fc": {
+          "model_module": "@jupyter-widgets/base",
+          "model_module_version": "1.2.0",
+          "model_name": "LayoutModel",
+          "state": {
+            "_model_module": "@jupyter-widgets/base",
+            "_model_module_version": "1.2.0",
+            "_model_name": "LayoutModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "LayoutView",
+            "align_content": null,
+            "align_items": null,
+            "align_self": null,
+            "border": null,
+            "bottom": null,
+            "display": null,
+            "flex": null,
+            "flex_flow": null,
+            "grid_area": null,
+            "grid_auto_columns": null,
+            "grid_auto_flow": null,
+            "grid_auto_rows": null,
+            "grid_column": null,
+            "grid_gap": null,
+            "grid_row": null,
+            "grid_template_areas": null,
+            "grid_template_columns": null,
+            "grid_template_rows": null,
+            "height": null,
+            "justify_content": null,
+            "justify_items": null,
+            "left": null,
+            "margin": null,
+            "max_height": null,
+            "max_width": null,
+            "min_height": null,
+            "min_width": null,
+            "object_fit": null,
+            "object_position": null,
+            "order": null,
+            "overflow": null,
+            "overflow_x": null,
+            "overflow_y": null,
+            "padding": null,
+            "right": null,
+            "top": null,
+            "visibility": null,
+            "width": null
+          }
+        },
+        "b8cd74e6833a4ddb95b3d812ccb52dfc": {
+          "model_module": "@jupyter-widgets/base",
+          "model_module_version": "1.2.0",
+          "model_name": "LayoutModel",
+          "state": {
+            "_model_module": "@jupyter-widgets/base",
+            "_model_module_version": "1.2.0",
+            "_model_name": "LayoutModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "LayoutView",
+            "align_content": null,
+            "align_items": null,
+            "align_self": null,
+            "border": null,
+            "bottom": null,
+            "display": null,
+            "flex": null,
+            "flex_flow": null,
+            "grid_area": null,
+            "grid_auto_columns": null,
+            "grid_auto_flow": null,
+            "grid_auto_rows": null,
+            "grid_column": null,
+            "grid_gap": null,
+            "grid_row": null,
+            "grid_template_areas": null,
+            "grid_template_columns": null,
+            "grid_template_rows": null,
+            "height": null,
+            "justify_content": null,
+            "justify_items": null,
+            "left": null,
+            "margin": null,
+            "max_height": null,
+            "max_width": null,
+            "min_height": null,
+            "min_width": null,
+            "object_fit": null,
+            "object_position": null,
+            "order": null,
+            "overflow": null,
+            "overflow_x": null,
+            "overflow_y": null,
+            "padding": null,
+            "right": null,
+            "top": null,
+            "visibility": null,
+            "width": null
+          }
+        },
+        "b9dafb0d592e4f5d8d6861ec804a2a68": {
+          "model_module": "@jupyter-widgets/base",
+          "model_module_version": "1.2.0",
+          "model_name": "LayoutModel",
+          "state": {
+            "_model_module": "@jupyter-widgets/base",
+            "_model_module_version": "1.2.0",
+            "_model_name": "LayoutModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "LayoutView",
+            "align_content": null,
+            "align_items": null,
+            "align_self": null,
+            "border": null,
+            "bottom": null,
+            "display": null,
+            "flex": null,
+            "flex_flow": null,
+            "grid_area": null,
+            "grid_auto_columns": null,
+            "grid_auto_flow": null,
+            "grid_auto_rows": null,
+            "grid_column": null,
+            "grid_gap": null,
+            "grid_row": null,
+            "grid_template_areas": null,
+            "grid_template_columns": null,
+            "grid_template_rows": null,
+            "height": null,
+            "justify_content": null,
+            "justify_items": null,
+            "left": null,
+            "margin": null,
+            "max_height": null,
+            "max_width": null,
+            "min_height": null,
+            "min_width": null,
+            "object_fit": null,
+            "object_position": null,
+            "order": null,
+            "overflow": null,
+            "overflow_x": null,
+            "overflow_y": null,
+            "padding": null,
+            "right": null,
+            "top": null,
+            "visibility": null,
+            "width": null
+          }
+        },
+        "baeee7ca6ab149af96d69cecff72f01b": {
+          "model_module": "@jupyter-widgets/base",
+          "model_module_version": "1.2.0",
+          "model_name": "LayoutModel",
+          "state": {
+            "_model_module": "@jupyter-widgets/base",
+            "_model_module_version": "1.2.0",
+            "_model_name": "LayoutModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "LayoutView",
+            "align_content": null,
+            "align_items": null,
+            "align_self": null,
+            "border": null,
+            "bottom": null,
+            "display": null,
+            "flex": null,
+            "flex_flow": null,
+            "grid_area": null,
+            "grid_auto_columns": null,
+            "grid_auto_flow": null,
+            "grid_auto_rows": null,
+            "grid_column": null,
+            "grid_gap": null,
+            "grid_row": null,
+            "grid_template_areas": null,
+            "grid_template_columns": null,
+            "grid_template_rows": null,
+            "height": null,
+            "justify_content": null,
+            "justify_items": null,
+            "left": null,
+            "margin": null,
+            "max_height": null,
+            "max_width": null,
+            "min_height": null,
+            "min_width": null,
+            "object_fit": null,
+            "object_position": null,
+            "order": null,
+            "overflow": null,
+            "overflow_x": null,
+            "overflow_y": null,
+            "padding": null,
+            "right": null,
+            "top": null,
+            "visibility": null,
+            "width": null
+          }
+        },
+        "bc140a927bf44f0fb434a766c5d2ab90": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_module_version": "1.5.0",
+          "model_name": "HTMLModel",
+          "state": {
+            "_dom_classes": [],
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "HTMLModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/controls",
+            "_view_module_version": "1.5.0",
+            "_view_name": "HTMLView",
+            "description": "",
+            "description_tooltip": null,
+            "layout": "IPY_MODEL_baeee7ca6ab149af96d69cecff72f01b",
+            "placeholder": "​",
+            "style": "IPY_MODEL_2693830bbe424cd6b818570f604ab23e",
+            "value": " 28.0/28.0 [00:00&lt;00:00, 1.64kB/s]"
+          }
+        },
+        "c5c6fa9c480548389f658f4482971f2d": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_module_version": "1.5.0",
+          "model_name": "DescriptionStyleModel",
+          "state": {
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "DescriptionStyleModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "StyleView",
+            "description_width": ""
+          }
+        },
+        "c66c5c6f43934f8ca9e6f0abf44d6684": {
+          "model_module": "@jupyter-widgets/base",
+          "model_module_version": "1.2.0",
+          "model_name": "LayoutModel",
+          "state": {
+            "_model_module": "@jupyter-widgets/base",
+            "_model_module_version": "1.2.0",
+            "_model_name": "LayoutModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "LayoutView",
+            "align_content": null,
+            "align_items": null,
+            "align_self": null,
+            "border": null,
+            "bottom": null,
+            "display": null,
+            "flex": null,
+            "flex_flow": null,
+            "grid_area": null,
+            "grid_auto_columns": null,
+            "grid_auto_flow": null,
+            "grid_auto_rows": null,
+            "grid_column": null,
+            "grid_gap": null,
+            "grid_row": null,
+            "grid_template_areas": null,
+            "grid_template_columns": null,
+            "grid_template_rows": null,
+            "height": null,
+            "justify_content": null,
+            "justify_items": null,
+            "left": null,
+            "margin": null,
+            "max_height": null,
+            "max_width": null,
+            "min_height": null,
+            "min_width": null,
+            "object_fit": null,
+            "object_position": null,
+            "order": null,
+            "overflow": null,
+            "overflow_x": null,
+            "overflow_y": null,
+            "padding": null,
+            "right": null,
+            "top": null,
+            "visibility": null,
+            "width": null
+          }
+        },
+        "c788f6072cd14fd78cdf717101a08f78": {
+          "model_module": "@jupyter-widgets/base",
+          "model_module_version": "1.2.0",
+          "model_name": "LayoutModel",
+          "state": {
+            "_model_module": "@jupyter-widgets/base",
+            "_model_module_version": "1.2.0",
+            "_model_name": "LayoutModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "LayoutView",
+            "align_content": null,
+            "align_items": null,
+            "align_self": null,
+            "border": null,
+            "bottom": null,
+            "display": null,
+            "flex": null,
+            "flex_flow": null,
+            "grid_area": null,
+            "grid_auto_columns": null,
+            "grid_auto_flow": null,
+            "grid_auto_rows": null,
+            "grid_column": null,
+            "grid_gap": null,
+            "grid_row": null,
+            "grid_template_areas": null,
+            "grid_template_columns": null,
+            "grid_template_rows": null,
+            "height": null,
+            "justify_content": null,
+            "justify_items": null,
+            "left": null,
+            "margin": null,
+            "max_height": null,
+            "max_width": null,
+            "min_height": null,
+            "min_width": null,
+            "object_fit": null,
+            "object_position": null,
+            "order": null,
+            "overflow": null,
+            "overflow_x": null,
+            "overflow_y": null,
+            "padding": null,
+            "right": null,
+            "top": null,
+            "visibility": null,
+            "width": null
+          }
+        },
+        "c98096746def4baf92adc948a764a5bf": {
+          "model_module": "@jupyter-widgets/base",
+          "model_module_version": "1.2.0",
+          "model_name": "LayoutModel",
+          "state": {
+            "_model_module": "@jupyter-widgets/base",
+            "_model_module_version": "1.2.0",
+            "_model_name": "LayoutModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "LayoutView",
+            "align_content": null,
+            "align_items": null,
+            "align_self": null,
+            "border": null,
+            "bottom": null,
+            "display": null,
+            "flex": null,
+            "flex_flow": null,
+            "grid_area": null,
+            "grid_auto_columns": null,
+            "grid_auto_flow": null,
+            "grid_auto_rows": null,
+            "grid_column": null,
+            "grid_gap": null,
+            "grid_row": null,
+            "grid_template_areas": null,
+            "grid_template_columns": null,
+            "grid_template_rows": null,
+            "height": null,
+            "justify_content": null,
+            "justify_items": null,
+            "left": null,
+            "margin": null,
+            "max_height": null,
+            "max_width": null,
+            "min_height": null,
+            "min_width": null,
+            "object_fit": null,
+            "object_position": null,
+            "order": null,
+            "overflow": null,
+            "overflow_x": null,
+            "overflow_y": null,
+            "padding": null,
+            "right": null,
+            "top": null,
+            "visibility": null,
+            "width": null
+          }
+        },
+        "cabcd31714754e16b694a6406c1d03e3": {
+          "model_module": "@jupyter-widgets/base",
+          "model_module_version": "1.2.0",
+          "model_name": "LayoutModel",
+          "state": {
+            "_model_module": "@jupyter-widgets/base",
+            "_model_module_version": "1.2.0",
+            "_model_name": "LayoutModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "LayoutView",
+            "align_content": null,
+            "align_items": null,
+            "align_self": null,
+            "border": null,
+            "bottom": null,
+            "display": null,
+            "flex": null,
+            "flex_flow": null,
+            "grid_area": null,
+            "grid_auto_columns": null,
+            "grid_auto_flow": null,
+            "grid_auto_rows": null,
+            "grid_column": null,
+            "grid_gap": null,
+            "grid_row": null,
+            "grid_template_areas": null,
+            "grid_template_columns": null,
+            "grid_template_rows": null,
+            "height": null,
+            "justify_content": null,
+            "justify_items": null,
+            "left": null,
+            "margin": null,
+            "max_height": null,
+            "max_width": null,
+            "min_height": null,
+            "min_width": null,
+            "object_fit": null,
+            "object_position": null,
+            "order": null,
+            "overflow": null,
+            "overflow_x": null,
+            "overflow_y": null,
+            "padding": null,
+            "right": null,
+            "top": null,
+            "visibility": null,
+            "width": null
+          }
+        },
+        "cad5edc94bf144d88ccd1f3a00b7aa3a": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_module_version": "1.5.0",
+          "model_name": "ProgressStyleModel",
+          "state": {
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "ProgressStyleModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "StyleView",
+            "bar_color": null,
+            "description_width": ""
+          }
+        },
+        "cea662b72d9c4bcf9b36cf983df2d769": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_module_version": "1.5.0",
+          "model_name": "DescriptionStyleModel",
+          "state": {
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "DescriptionStyleModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "StyleView",
+            "description_width": ""
+          }
+        },
+        "d36cf93f48f645b1aee13ef823fc0d7e": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_module_version": "1.5.0",
+          "model_name": "FloatProgressModel",
+          "state": {
+            "_dom_classes": [],
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "FloatProgressModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/controls",
+            "_view_module_version": "1.5.0",
+            "_view_name": "ProgressView",
+            "bar_style": "success",
+            "description": "",
+            "description_tooltip": null,
+            "layout": "IPY_MODEL_b8cd74e6833a4ddb95b3d812ccb52dfc",
+            "max": 267954768,
+            "min": 0,
+            "orientation": "horizontal",
+            "style": "IPY_MODEL_050e1436ee394ceebdb81719c12745b6",
+            "value": 267954768
+          }
+        },
+        "d5ff4f4192874c7b973b4b80c5de7508": {
+          "model_module": "@jupyter-widgets/base",
+          "model_module_version": "1.2.0",
+          "model_name": "LayoutModel",
+          "state": {
+            "_model_module": "@jupyter-widgets/base",
+            "_model_module_version": "1.2.0",
+            "_model_name": "LayoutModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "LayoutView",
+            "align_content": null,
+            "align_items": null,
+            "align_self": null,
+            "border": null,
+            "bottom": null,
+            "display": null,
+            "flex": null,
+            "flex_flow": null,
+            "grid_area": null,
+            "grid_auto_columns": null,
+            "grid_auto_flow": null,
+            "grid_auto_rows": null,
+            "grid_column": null,
+            "grid_gap": null,
+            "grid_row": null,
+            "grid_template_areas": null,
+            "grid_template_columns": null,
+            "grid_template_rows": null,
+            "height": null,
+            "justify_content": null,
+            "justify_items": null,
+            "left": null,
+            "margin": null,
+            "max_height": null,
+            "max_width": null,
+            "min_height": null,
+            "min_width": null,
+            "object_fit": null,
+            "object_position": null,
+            "order": null,
+            "overflow": null,
+            "overflow_x": null,
+            "overflow_y": null,
+            "padding": null,
+            "right": null,
+            "top": null,
+            "visibility": null,
+            "width": null
+          }
+        },
+        "d77e71b0a9944634857c776bf1cfde53": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_module_version": "1.5.0",
+          "model_name": "FloatProgressModel",
+          "state": {
+            "_dom_classes": [],
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "FloatProgressModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/controls",
+            "_view_module_version": "1.5.0",
+            "_view_name": "ProgressView",
+            "bar_style": "success",
+            "description": "",
+            "description_tooltip": null,
+            "layout": "IPY_MODEL_b9dafb0d592e4f5d8d6861ec804a2a68",
+            "max": 28,
+            "min": 0,
+            "orientation": "horizontal",
+            "style": "IPY_MODEL_d8c19b401dfd4a1ba7b157a9dde8ee0e",
+            "value": 28
+          }
+        },
+        "d8c19b401dfd4a1ba7b157a9dde8ee0e": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_module_version": "1.5.0",
+          "model_name": "ProgressStyleModel",
+          "state": {
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "ProgressStyleModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "StyleView",
+            "bar_color": null,
+            "description_width": ""
+          }
+        },
+        "dfb12e3b904c4fcf97c5f5e27c5233d7": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_module_version": "1.5.0",
+          "model_name": "FloatProgressModel",
+          "state": {
+            "_dom_classes": [],
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "FloatProgressModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/controls",
+            "_view_module_version": "1.5.0",
+            "_view_name": "ProgressView",
+            "bar_style": "success",
+            "description": "",
+            "description_tooltip": null,
+            "layout": "IPY_MODEL_c66c5c6f43934f8ca9e6f0abf44d6684",
+            "max": 570,
+            "min": 0,
+            "orientation": "horizontal",
+            "style": "IPY_MODEL_259138c7918e495ca7d19f72d7d19946",
+            "value": 570
+          }
+        },
+        "e0011432a92743eea923f745f2336957": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_module_version": "1.5.0",
+          "model_name": "HBoxModel",
+          "state": {
+            "_dom_classes": [],
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "HBoxModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/controls",
+            "_view_module_version": "1.5.0",
+            "_view_name": "HBoxView",
+            "box_style": "",
+            "children": [
+              "IPY_MODEL_053b48adee434f5e8886ea321c7cd4d8",
+              "IPY_MODEL_dfb12e3b904c4fcf97c5f5e27c5233d7",
+              "IPY_MODEL_4a57d71ae43444e2b9085d2b8fba55dc"
+            ],
+            "layout": "IPY_MODEL_5f9a0b7dce1f42bba47ae40caf4bfc67"
+          }
+        },
+        "e128fd325857405eb3c9ec496b6a8250": {
+          "model_module": "@jupyter-widgets/base",
+          "model_module_version": "1.2.0",
+          "model_name": "LayoutModel",
+          "state": {
+            "_model_module": "@jupyter-widgets/base",
+            "_model_module_version": "1.2.0",
+            "_model_name": "LayoutModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "LayoutView",
+            "align_content": null,
+            "align_items": null,
+            "align_self": null,
+            "border": null,
+            "bottom": null,
+            "display": null,
+            "flex": null,
+            "flex_flow": null,
+            "grid_area": null,
+            "grid_auto_columns": null,
+            "grid_auto_flow": null,
+            "grid_auto_rows": null,
+            "grid_column": null,
+            "grid_gap": null,
+            "grid_row": null,
+            "grid_template_areas": null,
+            "grid_template_columns": null,
+            "grid_template_rows": null,
+            "height": null,
+            "justify_content": null,
+            "justify_items": null,
+            "left": null,
+            "margin": null,
+            "max_height": null,
+            "max_width": null,
+            "min_height": null,
+            "min_width": null,
+            "object_fit": null,
+            "object_position": null,
+            "order": null,
+            "overflow": null,
+            "overflow_x": null,
+            "overflow_y": null,
+            "padding": null,
+            "right": null,
+            "top": null,
+            "visibility": null,
+            "width": null
+          }
+        },
+        "e3e9707eb7254739b3cbef0d57b29755": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_module_version": "1.5.0",
+          "model_name": "HTMLModel",
+          "state": {
+            "_dom_classes": [],
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "HTMLModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/controls",
+            "_view_module_version": "1.5.0",
+            "_view_name": "HTMLView",
+            "description": "",
+            "description_tooltip": null,
+            "layout": "IPY_MODEL_c98096746def4baf92adc948a764a5bf",
+            "placeholder": "​",
+            "style": "IPY_MODEL_60b6208f7dea431e9967b38f62ce9495",
+            "value": " 440M/440M [00:01&lt;00:00, 310MB/s]"
+          }
+        },
+        "e423f72267404deea786df62c644fc4c": {
+          "model_module": "@jupyter-widgets/base",
+          "model_module_version": "1.2.0",
+          "model_name": "LayoutModel",
+          "state": {
+            "_model_module": "@jupyter-widgets/base",
+            "_model_module_version": "1.2.0",
+            "_model_name": "LayoutModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "LayoutView",
+            "align_content": null,
+            "align_items": null,
+            "align_self": null,
+            "border": null,
+            "bottom": null,
+            "display": null,
+            "flex": null,
+            "flex_flow": null,
+            "grid_area": null,
+            "grid_auto_columns": null,
+            "grid_auto_flow": null,
+            "grid_auto_rows": null,
+            "grid_column": null,
+            "grid_gap": null,
+            "grid_row": null,
+            "grid_template_areas": null,
+            "grid_template_columns": null,
+            "grid_template_rows": null,
+            "height": null,
+            "justify_content": null,
+            "justify_items": null,
+            "left": null,
+            "margin": null,
+            "max_height": null,
+            "max_width": null,
+            "min_height": null,
+            "min_width": null,
+            "object_fit": null,
+            "object_position": null,
+            "order": null,
+            "overflow": null,
+            "overflow_x": null,
+            "overflow_y": null,
+            "padding": null,
+            "right": null,
+            "top": null,
+            "visibility": null,
+            "width": null
+          }
+        },
+        "e63c1acab3004ffca2b8ddaa5910e9ad": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_module_version": "1.5.0",
+          "model_name": "HBoxModel",
+          "state": {
+            "_dom_classes": [],
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "HBoxModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/controls",
+            "_view_module_version": "1.5.0",
+            "_view_name": "HBoxView",
+            "box_style": "",
+            "children": [
+              "IPY_MODEL_6bb8b04fb92c4a4a912aafdb98dbe33f",
+              "IPY_MODEL_adf0996e064746f7a0d0ca3a8d9479cf",
+              "IPY_MODEL_e3e9707eb7254739b3cbef0d57b29755"
+            ],
+            "layout": "IPY_MODEL_d5ff4f4192874c7b973b4b80c5de7508"
+          }
+        },
+        "e7b9e76d51b647a2a23123c10f0a05f2": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_module_version": "1.5.0",
+          "model_name": "DescriptionStyleModel",
+          "state": {
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "DescriptionStyleModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "StyleView",
+            "description_width": ""
+          }
+        },
+        "e7c6da20ae904c97853d9a79ea8309b3": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_module_version": "1.5.0",
+          "model_name": "DescriptionStyleModel",
+          "state": {
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "DescriptionStyleModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "StyleView",
+            "description_width": ""
+          }
+        },
+        "eed9f5d7668a45d18cf796d2166653fb": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_module_version": "1.5.0",
+          "model_name": "ProgressStyleModel",
+          "state": {
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "ProgressStyleModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "StyleView",
+            "bar_color": null,
+            "description_width": ""
+          }
+        },
+        "f1f92a7ea6df4e1384eb17c5110071f0": {
+          "model_module": "@jupyter-widgets/base",
+          "model_module_version": "1.2.0",
+          "model_name": "LayoutModel",
+          "state": {
+            "_model_module": "@jupyter-widgets/base",
+            "_model_module_version": "1.2.0",
+            "_model_name": "LayoutModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "LayoutView",
+            "align_content": null,
+            "align_items": null,
+            "align_self": null,
+            "border": null,
+            "bottom": null,
+            "display": null,
+            "flex": null,
+            "flex_flow": null,
+            "grid_area": null,
+            "grid_auto_columns": null,
+            "grid_auto_flow": null,
+            "grid_auto_rows": null,
+            "grid_column": null,
+            "grid_gap": null,
+            "grid_row": null,
+            "grid_template_areas": null,
+            "grid_template_columns": null,
+            "grid_template_rows": null,
+            "height": null,
+            "justify_content": null,
+            "justify_items": null,
+            "left": null,
+            "margin": null,
+            "max_height": null,
+            "max_width": null,
+            "min_height": null,
+            "min_width": null,
+            "object_fit": null,
+            "object_position": null,
+            "order": null,
+            "overflow": null,
+            "overflow_x": null,
+            "overflow_y": null,
+            "padding": null,
+            "right": null,
+            "top": null,
+            "visibility": null,
+            "width": null
+          }
+        },
+        "f47a00ac8acc4b389f496b99092c19b1": {
+          "model_module": "@jupyter-widgets/base",
+          "model_module_version": "1.2.0",
+          "model_name": "LayoutModel",
+          "state": {
+            "_model_module": "@jupyter-widgets/base",
+            "_model_module_version": "1.2.0",
+            "_model_name": "LayoutModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "LayoutView",
+            "align_content": null,
+            "align_items": null,
+            "align_self": null,
+            "border": null,
+            "bottom": null,
+            "display": null,
+            "flex": null,
+            "flex_flow": null,
+            "grid_area": null,
+            "grid_auto_columns": null,
+            "grid_auto_flow": null,
+            "grid_auto_rows": null,
+            "grid_column": null,
+            "grid_gap": null,
+            "grid_row": null,
+            "grid_template_areas": null,
+            "grid_template_columns": null,
+            "grid_template_rows": null,
+            "height": null,
+            "justify_content": null,
+            "justify_items": null,
+            "left": null,
+            "margin": null,
+            "max_height": null,
+            "max_width": null,
+            "min_height": null,
+            "min_width": null,
+            "object_fit": null,
+            "object_position": null,
+            "order": null,
+            "overflow": null,
+            "overflow_x": null,
+            "overflow_y": null,
+            "padding": null,
+            "right": null,
+            "top": null,
+            "visibility": null,
+            "width": null
+          }
+        },
+        "f817891cfe4f48b4bd0b4b66e5d8287c": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_module_version": "1.5.0",
+          "model_name": "DescriptionStyleModel",
+          "state": {
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "DescriptionStyleModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "StyleView",
+            "description_width": ""
+          }
+        },
+        "ff69874079c141d192118af82f29e897": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_module_version": "1.5.0",
+          "model_name": "HTMLModel",
+          "state": {
+            "_dom_classes": [],
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "HTMLModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/controls",
+            "_view_module_version": "1.5.0",
+            "_view_name": "HTMLView",
+            "description": "",
+            "description_tooltip": null,
+            "layout": "IPY_MODEL_089ae2bdb98f4c2885404989e12a84ff",
+            "placeholder": "​",
+            "style": "IPY_MODEL_c5c6fa9c480548389f658f4482971f2d",
+            "value": " 268M/268M [00:01&lt;00:00, 258MB/s]"
+          }
+        }
+      }
+    }
+  },
+  "nbformat": 4,
+  "nbformat_minor": 0
+}