Phase 3.ipynb

{
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/saeedzou/Deep-Learning-Project/blob/main/Phase%203.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Student Names :\n",
        "# Saeedreza Zouahkiani, Masoud Rahimi, Ehsanollah Shourezari"
      ],
      "metadata": {
        "id": "IAwnUsVXqecC"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Loading necessary data and modules\n",
        "We follow these steps:\n",
        "- Download the MSCTD dataset\n",
        "- Import necessary packages\n",
        "- Define our Dataset class from previous phases\n",
        "- Load the dataset (Imagenet parameters for image transform)\n",
        "- Preprocessed the text (lower casing, lemmatizing)"
      ],
      "metadata": {
        "id": "m7g-yIFLqnH5"
      }
    },
    {
      "cell_type": "code",
      "execution_count": 1,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "efwLVBYQo76z",
        "outputId": "9b59f44f-5319-4967-eb13-f26301b45971"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Cloning into 'MSCTD'...\n",
            "remote: Enumerating objects: 1217, done.\u001b[K\n",
            "remote: Counting objects: 100% (27/27), done.\u001b[K\n",
            "remote: Compressing objects: 100% (23/23), done.\u001b[K\n",
            "remote: Total 1217 (delta 13), reused 7 (delta 3), pack-reused 1190\u001b[K\n",
            "Receiving objects: 100% (1217/1217), 102.24 MiB | 16.25 MiB/s, done.\n",
            "Resolving deltas: 100% (616/616), done.\n",
            "Updating files: 100% (934/934), done.\n",
            "Downloading...\n",
            "From: https://drive.google.com/uc?id=1-1NCqtM8rb8qpjSTE250j6b7ELPeUWSP\n",
            "To: /content/train_ende.zip\n",
            "100% 2.90G/2.90G [00:40<00:00, 72.0MB/s]\n",
            "Downloading...\n",
            "From: https://drive.google.com/uc?id=1MQVgE3zOqaia3XAUuxlqsOs8QHGJoQGL\n",
            "To: /content/dev.zip\n",
            "100% 638M/638M [00:10<00:00, 61.6MB/s]\n",
            "Downloading...\n",
            "From: https://drive.google.com/uc?id=1--rcb6puOiImZ0rbKoP8jtOvkqx0CdgF\n",
            "To: /content/test.zip\n",
            "100% 641M/641M [00:05<00:00, 109MB/s]\n"
          ]
        }
      ],
      "source": [
        "# This block downloads and preprocesses the needed data for the project\n",
        "!git clone https://github.com/XL2248/MSCTD\n",
        "!cp MSCTD/MSCTD_data/ende/eng* .\n",
        "!cp MSCTD/MSCTD_data/ende/ima* .\n",
        "!cp MSCTD/MSCTD_data/ende/sent* .\n",
        "!rm -rf MSCTD\n",
        "!pip -q install --upgrade --no-cache-dir gdown\n",
        "!gdown 1-1NCqtM8rb8qpjSTE250j6b7ELPeUWSP\n",
        "!gdown 1MQVgE3zOqaia3XAUuxlqsOs8QHGJoQGL\n",
        "!gdown 1--rcb6puOiImZ0rbKoP8jtOvkqx0CdgF\n",
        "!unzip -q train_ende.zip\n",
        "!unzip -q dev.zip\n",
        "!unzip -q test.zip\n",
        "!mv train_ende train\n",
        "!mkdir train/image\n",
        "!mkdir dev/image\n",
        "!mkdir test/image\n",
        "!mv train/*.jpg train/image\n",
        "!mv dev/*.jpg dev/image\n",
        "!mv test/*.jpg test/image\n",
        "!mv *train.txt train\n",
        "!mv *dev.txt dev\n",
        "!mv *test.txt test"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 2,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "oM987Bi4o2q2",
        "outputId": "11fcdaa6-7dde-4873-9174-5192d57cc0a4"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "[nltk_data] Downloading package stopwords to /root/nltk_data...\n",
            "[nltk_data]   Unzipping corpora/stopwords.zip.\n",
            "[nltk_data] Downloading package omw-1.4 to /root/nltk_data...\n",
            "[nltk_data] Downloading package punkt to /root/nltk_data...\n",
            "[nltk_data]   Unzipping tokenizers/punkt.zip.\n",
            "[nltk_data] Downloading package averaged_perceptron_tagger to\n",
            "[nltk_data]     /root/nltk_data...\n",
            "[nltk_data]   Unzipping taggers/averaged_perceptron_tagger.zip.\n",
            "[nltk_data] Downloading package wordnet to /root/nltk_data...\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "\u001b[2K     \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m6.3/6.3 MB\u001b[0m \u001b[31m85.2 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
            "\u001b[2K     \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m7.6/7.6 MB\u001b[0m \u001b[31m97.9 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
            "\u001b[2K     \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m190.3/190.3 KB\u001b[0m \u001b[31m22.0 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
            "\u001b[2K     \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m549.1/549.1 KB\u001b[0m \u001b[31m29.3 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
            "\u001b[2K     \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m1.9/1.9 MB\u001b[0m \u001b[31m22.5 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
            "\u001b[?25h"
          ]
        }
      ],
      "source": [
        "import numpy as np\n",
        "import pandas as pd\n",
        "import nltk\n",
        "import nltk.tokenize as tokenize\n",
        "from nltk.corpus import stopwords\n",
        "from nltk.stem import WordNetLemmatizer\n",
        "from nltk.tokenize import word_tokenize\n",
        "from nltk.corpus import wordnet\n",
        "nltk.download('stopwords')\n",
        "nltk.download('omw-1.4')\n",
        "nltk.download('punkt')\n",
        "nltk.download('averaged_perceptron_tagger')\n",
        "nltk.download('wordnet')\n",
        "stop_words = set(stopwords.words(\"english\"))\n",
        "lemmatizer = WordNetLemmatizer()\n",
        "from sklearn.metrics import classification_report, confusion_matrix\n",
        "import torch\n",
        "import torch.nn as nn\n",
        "import torch.nn.functional as F\n",
        "import torch.optim as optim\n",
        "from torch.utils.data import Dataset, DataLoader\n",
        "import torchvision\n",
        "from torchvision.io import read_image\n",
        "from torchvision import transforms\n",
        "import json\n",
        "import cv2\n",
        "from pycocotools.coco import COCO\n",
        "import os\n",
        "import string\n",
        "import re\n",
        "import gc\n",
        "import random\n",
        "import matplotlib.pyplot as plt\n",
        "!pip install -q transformers\n",
        "import seaborn as sns\n",
        "from transformers import BertTokenizer\n",
        "from transformers import BertModel\n",
        "from PIL import Image\n",
        "!pip install -q timm\n",
        "import timm\n",
        "from tqdm import tqdm\n",
        "!pip install -q facenet_pytorch\n",
        "from facenet_pytorch import MTCNN, InceptionResnetV1"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 3,
      "metadata": {
        "id": "1HI_093VpCl1"
      },
      "outputs": [],
      "source": [
        "class MSCTD(Dataset):\n",
        "    \"\"\"\n",
        "    :param root: root path of the dataset\n",
        "    :param split: train, dev, test\n",
        "    :param image_transform: transform for image\n",
        "    :param text_transform: transform for text\n",
        "    :param sentiment_transform: transform for sentiment\n",
        "    :param has_data: dict, whether the dataset has image, text\n",
        "    :param text_path: path of the text file\n",
        "    :param image_path: path of the image folder\n",
        "    :param sentiment_path: path of the sentiment file\n",
        "    :param image_index_path: path of the image index file\n",
        "\n",
        "    :return: combination of image, sentiment, text, image_index\n",
        "\n",
        "    Example:\n",
        "    >>> from torchvision import transforms\n",
        "    >>> image_transform = transforms.Compose([\n",
        "    >>>     transforms.Resize((640, 1280)),\n",
        "    >>>     transforms.Lambda(lambda x: x.permute(1, 2, 0))\n",
        "    >>> ])\n",
        "    >>> text_transform = None\n",
        "    >>> sentiment_transform = None\n",
        "    >>> dataset = MSCTD(root='data', split='train', image_transform=image_transform,\n",
        "    >>>                 text_transform=text_transform, sentiment_transform=sentiment_transform)\n",
        "    >>> image, text, sentiment = dataset[0]\n",
        "\n",
        "    \"\"\"\n",
        "    def __init__(self, root, split, image_transform=None, text_transform=None, sentiment_transform=None,\n",
        "                 has_data={'image': True, 'text': True}, text_path=None, image_path=None, sentiment_path=None,\n",
        "                 image_index_path=None):\n",
        "        data_path = os.path.join(root, split)\n",
        "        default_path = {\n",
        "            'text': os.path.join(data_path, 'english_' + split + '.txt'),\n",
        "            'image': os.path.join(data_path, 'image'),\n",
        "            'sentiment': os.path.join(data_path, 'sentiment_' + split + '.txt'),\n",
        "            'image_index': os.path.join(data_path, 'image_index_' + split + '.txt'),\n",
        "        }\n",
        "        self.image = [] if has_data['image'] else None\n",
        "        self.image_transform = image_transform\n",
        "        self.image_path = image_path if image_path else default_path['image']\n",
        "        self.text = [] if has_data['text'] else None\n",
        "        self.text_transform = text_transform\n",
        "        self.text_path = text_path if text_path else default_path['text']\n",
        "        self.sentiment_path = sentiment_path if sentiment_path else default_path['sentiment']\n",
        "        self.image_index_path = image_index_path if image_index_path else default_path['image_index']\n",
        "        self.sentiment = []\n",
        "        self.image_index = []\n",
        "        self.sentiment_transform = sentiment_transform\n",
        "        self.load_data()\n",
        "        \n",
        "    def load_data(self):\n",
        "        self.sentiment = np.loadtxt(self.sentiment_path, dtype=int)\n",
        "        if self.text is not None:\n",
        "            with open(self.text_path, 'r') as f:\n",
        "                self.text = f.readlines()\n",
        "            self.text = [x.strip() for x in self.text]\n",
        "        with open(self.image_index_path, 'r') as f:\n",
        "            data = f.readlines()\n",
        "        self.image_index = [list(map(int, x[1:-2].split(','))) for x in data]\n",
        "\n",
        "    def __getitem__(self, index):\n",
        "        image = None\n",
        "        text = None\n",
        "        sentiment = self.sentiment[index]\n",
        "        if self.image is not None:\n",
        "            imag_path = os.path.join(self.image_path, str(index)+'.jpg')\n",
        "            image = read_image(imag_path)\n",
        "            if self.image_transform:\n",
        "                image = self.image_transform(image)\n",
        "        if self.text is not None:\n",
        "            text = self.text[index]\n",
        "            if self.text_transform:\n",
        "                text = self.text_transform(text)\n",
        "        if self.sentiment_transform:\n",
        "            sentiment = self.sentiment_transform(sentiment)\n",
        "        if text is not None and image is not None:\n",
        "            return image, text, sentiment\n",
        "        elif text is not None:\n",
        "            return text, sentiment\n",
        "        elif image is not None:\n",
        "            return image, sentiment\n",
        "        else:\n",
        "            raise Exception('Either image or text should be not None')\n",
        "\n",
        "    def __len__(self):\n",
        "        return len(self.sentiment)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 4,
      "metadata": {
        "id": "OQr-lM0Epwx7"
      },
      "outputs": [],
      "source": [
        "image_transform = torchvision.transforms.Compose([\n",
        "    torchvision.transforms.ToPILImage(),\n",
        "    torchvision.transforms.Resize((224, 224)),\n",
        "    torchvision.transforms.ToTensor(),\n",
        "    torchvision.transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225])\n",
        "    ])\n",
        "MSCTD_train = MSCTD(root='.', split='train', image_transform=image_transform, has_data={'image': True, 'text': True})\n",
        "MSCTD_dev = MSCTD(root='.', split='dev', image_transform=image_transform, has_data={'image': True, 'text': True})\n",
        "MSCTD_test = MSCTD(root='.', split='test', image_transform=image_transform, has_data={'image': True, 'text': True})"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 5,
      "metadata": {
        "id": "SklafdvXpxGn"
      },
      "outputs": [],
      "source": [
        "def get_wordnet_pos(word):\n",
        "    \"\"\"Map POS tag to first character used by WordNetLemmatizer\"\"\"\n",
        "    tag = nltk.pos_tag([word])[0][1][0].upper()\n",
        "    tag_dict = {\"J\": wordnet.ADJ,\n",
        "                \"N\": wordnet.NOUN,\n",
        "                \"V\": wordnet.VERB,\n",
        "                \"R\": wordnet.ADV}\n",
        "\n",
        "    return tag_dict.get(tag, wordnet.NOUN)\n",
        "\n",
        "def text_preprocessor(dataset):\n",
        "      # preprocess text\n",
        "      dataset.text = [preprocess_text(text) for text in dataset.text]\n",
        "\n",
        "def preprocess_text(text):\n",
        "      # Replace contractions with original text\n",
        "  text = re.sub(r'(\\b[Aa]in\\'t\\b)', \"am not\", text)\n",
        "  text = re.sub(r'(\\b[Hh]a\\'t\\b)', \"has\", text)\n",
        "  text = re.sub(r'(\\b[Ii]\\'m\\b)', \"i am\", text)\n",
        "  text = re.sub(r'(\\b\\'s\\b)', \" is\", text)\n",
        "  text = re.sub(r'(\\b\\'re\\b)', \" are\", text)\n",
        "  text = re.sub(r'(\\b\\'ve\\b)', \" have\", text)\n",
        "  text = re.sub(r'(\\b\\'d\\b)', \" would\", text)\n",
        "  text = re.sub(r'(\\b\\'ll\\b)', \" will\", text)\n",
        "  text = re.sub(r'(\\b[Ss]han\\'t\\b)', \"shall not\", text)\n",
        "  text = re.sub(r'(\\b[Ww]on\\'t\\b)', \"will not\", text)\n",
        "  text = re.sub(r'(\\b[Ww]ouldn\\'t\\b)', \"would not\", text)\n",
        "  text = re.sub(r'(\\b[Dd]on\\'t\\b)', \"do not\", text)\n",
        "  text = re.sub(r'(\\b[Cc]an\\'t\\b)', \"can not\", text)\n",
        "  text = re.sub(r'(\\b[Ii]s\\'nt\\b)', \"is not\", text)\n",
        "  text = re.sub(r'(\\b[Ww]eren\\'t\\b)', \"were not\", text)\n",
        "  text = re.sub(r'(\\b[Hh]aven\\'t\\b)', \"have not\", text)\n",
        "  text = re.sub(r'(\\b[Hh]adn\\'t\\b)', \"had not\", text)\n",
        "  text = re.sub(r'(\\b[Hh]asn\\'t\\b)', \"has not\", text)\n",
        "  text = re.sub(r'(\\b[Hh]adn\\'t\\b)', \"had not\", text)\n",
        "  text = re.sub(r'(\\b[Dd]idn\\'t\\b)', \"did not\", text)\n",
        "\n",
        "  # Remove punctuation\n",
        "  text = text.translate(str.maketrans(\"\", \"\", string.punctuation))\n",
        "\n",
        "  # Convert to lowercase\n",
        "  text = text.lower()\n",
        "\n",
        "  # Tokenize text\n",
        "  tokens = word_tokenize(text)\n",
        "\n",
        "  # Remove stop words\n",
        "  # tokens = [token for token in tokens if token not in stop_words]\n",
        "  # Remove numbers\n",
        "  tokens = [token for token in tokens if token.isalpha()]\n",
        "\n",
        "  # Lemmatize tokens\n",
        "  tokens = [lemmatizer.lemmatize(token, get_wordnet_pos(token)) for token in tokens]\n",
        "\n",
        "  return ' '.join(tokens)\n",
        "\n",
        "# Test the TextPreprocessor\n",
        "text_preprocessor(MSCTD_train)\n",
        "text_preprocessor(MSCTD_dev)\n",
        "text_preprocessor(MSCTD_test)"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Part 1\n",
        "The steps that we followed are mentioned at the beginning of each subpart\n"
      ],
      "metadata": {
        "id": "AqJewCmNrlKo"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Part 1 Subpart 1\n",
        "We followed these steps:\n",
        "\n",
        "Using ResNet50 as image encoder (entire image) and BERT as text encoder:\n",
        "- Defined dataset for tokenizing, model class for image encoder, model class for text encoder, and model class for MLP classifier\n",
        "- Load the dataset and dataloaders, instantiated encoders and classifier, and defined optimizer that optimizes over encoders and classifier\n",
        "- Train for 3 epochs\n",
        "- Plot accuracy and loss curves\n",
        "- Reported confusion matrix and classification report\n",
        "\n",
        "Using Face Features:\n",
        "- Change image transform for the MTCNN\n",
        "- instantiated MTCNN, VGGFace2, TextEncoder, MLP classifier, and defined an optimizer that optimizes TextEncoder and MLP parameters\n",
        "- Train for 2 epochs\n",
        "- Reported confusion matrix and classification report\n",
        "\n",
        "\n"
      ],
      "metadata": {
        "id": "pzqrpT_a8yJj"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Using ResNet50 as image encoder (entire image) and BERT as text encoder. \n",
        "We passed the images to a ResNet50 and removed the fc head. This outputs a 2048-d vector for each image. We then concatenated the encoded image with encoded text (size 768) and pass the result to a Multi-layer Perceptron to predict the sentiment.\n"
      ],
      "metadata": {
        "id": "rWFLAj-iALxs"
      }
    },
    {
      "cell_type": "code",
      "execution_count": 6,
      "metadata": {
        "id": "7jgwu_OxCor0"
      },
      "outputs": [],
      "source": [
        "# define a class that get a dataset and return tokenized dataset\n",
        "class TokenizedDataset(Dataset):\n",
        "    def __init__(self, dataset, tokenizer, max_length=80):\n",
        "        self.dataset = dataset\n",
        "        self.tokenizer = tokenizer\n",
        "        self.max_length = max_length\n",
        "    def __getitem__(self, index):\n",
        "        image, text, sentiment = self.dataset[index]\n",
        "        text = self.tokenizer.encode_plus(text, add_special_tokens=True, max_length=self.max_length, \n",
        "                                          padding='max_length', truncation=True, return_tensors='pt')\n",
        "        return image, text, sentiment\n",
        "    def __len__(self):\n",
        "        return len(self.dataset)\n",
        "\n",
        "# define a image_encoder model using resnet50 on timm\n",
        "class ImageEncoder(nn.Module):\n",
        "    def __init__(self, is_trainable=True):\n",
        "        super(ImageEncoder, self).__init__()\n",
        "        self.resnet = timm.create_model('resnet50', pretrained=True)\n",
        "        self.resnet.fc = nn.Identity()\n",
        "        if not is_trainable:\n",
        "            for param in self.resnet.parameters():\n",
        "                param.requires_grad = False\n",
        "\n",
        "    def forward(self, x):\n",
        "        return self.resnet(x)\n",
        "\n",
        "# define a text_encoder model using bert-base-uncased on huggingface\n",
        "class TextEncoder(nn.Module):\n",
        "    def __init__(self, is_trainable=True):\n",
        "        super(TextEncoder, self).__init__()\n",
        "        self.bert = BertModel.from_pretrained('bert-base-uncased')\n",
        "        if not is_trainable:\n",
        "            for param in self.bert.parameters():\n",
        "                param.requires_grad = False\n",
        "\n",
        "    def forward(self, x):\n",
        "        x = {k: v.squeeze(1) for k, v in x.items()}\n",
        "        return self.bert(**x).last_hidden_state[:, 0, :]\n",
        "\n",
        "# define an MLP classifier\n",
        "class MLPClassifier(nn.Module):\n",
        "    def __init__(self, input_dim, hidden_dim, output_dim):\n",
        "        super(MLPClassifier, self).__init__()\n",
        "        self.fc1 = nn.Linear(input_dim, hidden_dim)\n",
        "        self.fc2 = nn.Linear(hidden_dim, output_dim)\n",
        "        self.relu = nn.ReLU()\n",
        "        self.dropout = nn.Dropout(0.2)\n",
        "        self.softmax = nn.Softmax(dim=1)\n",
        "\n",
        "    def forward(self, x):\n",
        "        x = self.fc1(x)\n",
        "        x = self.relu(x)\n",
        "        x = self.dropout(x)\n",
        "        x = self.fc2(x)\n",
        "        x = self.softmax(x)\n",
        "        return x\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "2vgsrDe1eqaw",
        "outputId": "86a1644e-5004-4836-a81c-f78c9d370cce"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "Some weights of the model checkpoint at bert-base-uncased were not used when initializing BertModel: ['cls.seq_relationship.weight', 'cls.predictions.transform.dense.weight', 'cls.predictions.transform.LayerNorm.weight', 'cls.predictions.transform.LayerNorm.bias', 'cls.predictions.bias', 'cls.seq_relationship.bias', 'cls.predictions.decoder.weight', 'cls.predictions.transform.dense.bias']\n",
            "- This IS expected if you are initializing BertModel from the checkpoint of a model trained on another task or with another architecture (e.g. initializing a BertForSequenceClassification model from a BertForPreTraining model).\n",
            "- This IS NOT expected if you are initializing BertModel from the checkpoint of a model that you expect to be exactly identical (initializing a BertForSequenceClassification model from a BertForSequenceClassification model).\n"
          ]
        }
      ],
      "source": [
        "tokenizer = BertTokenizer.from_pretrained('bert-base-uncased')\n",
        "\n",
        "# tokenize datasets\n",
        "max_length = 25\n",
        "tokenized_train = TokenizedDataset(MSCTD_train, tokenizer, max_length)\n",
        "tokenized_dev = TokenizedDataset(MSCTD_dev, tokenizer, max_length)\n",
        "tokenized_test = TokenizedDataset(MSCTD_test, tokenizer, max_length)\n",
        "\n",
        "# dataloader\n",
        "train_dataloader_tokenized = DataLoader(tokenized_train, batch_size=32, shuffle=True)\n",
        "dev_dataloader_tokenized = DataLoader(tokenized_dev, batch_size=32, shuffle=True)\n",
        "test_dataloader_tokenized = DataLoader(tokenized_test, batch_size=32, shuffle=True)\n",
        "\n",
        "# define device\n",
        "device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')\n",
        "\n",
        "# define image_encoder and text_encoder\n",
        "image_encoder = ImageEncoder(is_trainable=True).to(device)\n",
        "text_encoder = TextEncoder(is_trainable=True).to(device)\n",
        "\n",
        "# define the classifier\n",
        "classifier = MLPClassifier(2048 + 768, 512, 3).to(device)\n",
        "\n",
        "# define the optimizer\n",
        "optimizer = optim.Adam(list(text_encoder.parameters()) + list(classifier.parameters()) + list(image_encoder.parameters()), lr=1e-5)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "DQybwz-iVy5v",
        "outputId": "9a489ccd-808b-405a-ee34-b49e38da7854"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "100%|██████████| 633/633 [09:49<00:00,  1.07it/s]\n",
            "100%|██████████| 159/159 [01:20<00:00,  1.98it/s]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Epoch 1/3, Train Loss: 0.9549, Train Acc: 0.5847, Dev Loss: 0.9391, Dev Acc: 0.6000\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "100%|██████████| 633/633 [09:15<00:00,  1.14it/s]\n",
            "100%|██████████| 159/159 [01:46<00:00,  1.49it/s]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Epoch 2/3, Train Loss: 0.8628, Train Acc: 0.6818, Dev Loss: 0.9342, Dev Acc: 0.6008\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "100%|██████████| 633/633 [09:37<00:00,  1.10it/s]\n",
            "100%|██████████| 159/159 [01:20<00:00,  1.99it/s]"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Epoch 3/3, Train Loss: 0.8073, Train Acc: 0.7419, Dev Loss: 0.9481, Dev Acc: 0.5927\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "\n"
          ]
        }
      ],
      "source": [
        "train_losses = []\n",
        "dev_losses = []\n",
        "train_accs = []\n",
        "dev_accs = []\n",
        "num_epochs = 3\n",
        "for epoch in range(num_epochs):\n",
        "    # train\n",
        "    train_loss = 0\n",
        "    train_acc = 0\n",
        "    total_samples = 0\n",
        "    for images, texts, labels in tqdm(train_dataloader_tokenized):\n",
        "        images = images.to(device)\n",
        "        labels = labels.to(device)\n",
        "        texts = texts.to(device)\n",
        "        # get the image and text embeddings\n",
        "        image_embeddings = image_encoder(images)\n",
        "        text_embeddings = text_encoder(texts)\n",
        "        # concatenate the image and text embeddings\n",
        "        embeddings = torch.cat((image_embeddings, text_embeddings), dim=1)\n",
        "        # get the predictions\n",
        "        predictions = classifier(embeddings)\n",
        "        # calculate the loss\n",
        "        loss = F.cross_entropy(predictions, labels)\n",
        "        # calculate the accuracy\n",
        "        acc = (predictions.argmax(dim=1) == labels).float().sum()\n",
        "        # backpropagation\n",
        "        optimizer.zero_grad()\n",
        "        loss.backward()\n",
        "        optimizer.step()\n",
        "        # update the loss and accuracy\n",
        "        train_loss += loss.item()\n",
        "        train_acc += acc.item()\n",
        "        total_samples += labels.size(0)\n",
        "    # calculate the average loss and accuracy\n",
        "    train_loss /= len(train_dataloader_tokenized)\n",
        "    train_acc /= total_samples\n",
        "    # save the loss and accuracy\n",
        "    train_losses.append(train_loss)\n",
        "    train_accs.append(train_acc)\n",
        "\n",
        "    # evaluate\n",
        "    dev_loss = 0\n",
        "    dev_acc = 0\n",
        "    total_samples = 0\n",
        "    with torch.no_grad():\n",
        "        for images, texts, labels in tqdm(dev_dataloader_tokenized):\n",
        "            images = images.to(device)\n",
        "            labels = labels.to(device)\n",
        "            texts = texts.to(device)\n",
        "            # get the image and text embeddings\n",
        "            image_embeddings = image_encoder(images)\n",
        "            text_embeddings = text_encoder(texts)\n",
        "            # concatenate the image and text embeddings\n",
        "            embeddings = torch.cat((image_embeddings, text_embeddings), dim=1)\n",
        "            # get the predictions\n",
        "            predictions = classifier(embeddings)\n",
        "            # calculate the loss\n",
        "            loss = F.cross_entropy(predictions, labels)\n",
        "            # calculate the accuracy\n",
        "            acc = (predictions.argmax(dim=1) == labels).float().sum()\n",
        "            # update the loss and accuracy\n",
        "            dev_loss += loss.item()\n",
        "            dev_acc += acc.item()\n",
        "            total_samples += labels.size(0)\n",
        "    # calculate the average loss and accuracy\n",
        "    dev_loss /= len(dev_dataloader_tokenized)\n",
        "    dev_acc /= total_samples\n",
        "    # save the loss and accuracy\n",
        "    dev_losses.append(dev_loss)\n",
        "    dev_accs.append(dev_acc)\n",
        "\n",
        "    # print the loss and accuracy\n",
        "    print(f'Epoch {epoch+1}/{num_epochs}, Train Loss: {train_loss:.4f}, Train Acc: {train_acc:.4f}, Dev Loss: {dev_loss:.4f}, Dev Acc: {dev_acc:.4f}')"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "gCM5X2-_nxMT",
        "outputId": "7d164499-fad5-46e2-9691-2f213118002c",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 350
        }
      },
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 1080x360 with 2 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {
            "needs_background": "light"
          }
        }
      ],
      "source": [
        "# plot the loss and accuracy\n",
        "fig, ax = plt.subplots(1, 2, figsize=(15, 5))\n",
        "ax[0].plot(train_losses, label='train')\n",
        "ax[0].plot(dev_losses, label='dev')\n",
        "ax[0].set_xlabel('Epoch')\n",
        "ax[0].set_ylabel('Loss')\n",
        "ax[0].title.set_text('Loss')\n",
        "ax[0].legend()\n",
        "ax[1].plot(train_accs, label='train')\n",
        "ax[1].plot(dev_accs, label='dev')\n",
        "ax[1].set_xlabel('Epoch')\n",
        "ax[1].set_ylabel('Accuracy')\n",
        "ax[1].title.set_text('Accuracy')\n",
        "ax[1].legend()\n",
        "plt.show()\n"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# confusion matrix and classification report\n",
        "y_true = []\n",
        "y_pred = []\n",
        "with torch.no_grad():\n",
        "    for images, texts, labels in tqdm(test_dataloader_tokenized):\n",
        "        images = images.to(device)\n",
        "        labels = labels.to(device)\n",
        "        texts = texts.to(device)\n",
        "        # get the image and text embeddings\n",
        "        image_embeddings = image_encoder(images)\n",
        "        text_embeddings = text_encoder(texts)\n",
        "        # concatenate the image and text embeddings\n",
        "        embeddings = torch.cat((image_embeddings, text_embeddings), dim=1)\n",
        "        # get the predictions\n",
        "        predictions = classifier(embeddings)\n",
        "        # get the labels\n",
        "        y_true.extend(labels.tolist())\n",
        "        y_pred.extend(predictions.argmax(dim=1).tolist())"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "QryvA-kbD5g8",
        "outputId": "6f954cf3-b220-4d08-91e4-60029f07ffae"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "100%|██████████| 159/159 [01:31<00:00,  1.75it/s]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# confusion matrix\n",
        "cm = sns.heatmap(confusion_matrix(y_true, y_pred), annot=True, fmt='d', cmap='Blues', xticklabels=['neutral', 'negative', 'positive'], yticklabels=['neutral', 'negative', 'positive'])\n",
        "cm.set_xlabel('Predicted')\n",
        "cm.set_ylabel('True')\n",
        "plt.show()\n",
        "# classification report\n",
        "print('\\n\\n')\n",
        "print(classification_report(y_true, y_pred, target_names=['neutral', 'negative', 'positive']))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 519
        },
        "id": "jtSgFVDoEPJO",
        "outputId": "c4641487-b26e-406b-e4f7-f6fa6872fa2c"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 432x288 with 2 Axes>"
            ],
            "image/png": "iVBORw0KGgoAAAANSUhEUgAAAXUAAAEGCAYAAACaSwWnAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjIsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+WH4yJAAAgAElEQVR4nO3dd5wV1fnH8c93F1B6R1F6EaLGAiioxKgkRo0KGkNQUaxoROwVUezlFyt2VBQTlGZD7GDBBlJEBERFASkC0pvC7vL8/phZvLTde3d39t4dnnde89qZc2fmnDvBZ88+c+aMzAznnHPxkJXuBjjnnCs5HtSdcy5GPKg751yMeFB3zrkY8aDunHMxUi7dDdiRxz6b48NyInZEk7rpbkLsNatXOd1N2CnsWg4V9xwVD7w46Zjz65ePFLu+qHhP3TnnYiRje+rOOVeqFI8+rgd155wDyMpOdwtKhAd155wDUMamyVPiQd0558DTL845FyveU3fOuRjxnrpzzsWI99Sdcy5GfPSLc87FiKdfnHMuRjz94pxzMeI9deecixEP6s45FyPZfqPUOefiw3PqzjkXI55+cc65GPGeunPOxUhMeurx+BbOOVdcUvJLoafSQElLJE3bzmdXSjJJdcJtSeovaZakqZLaJOzbQ9L34dIjma/hQd055yCYJiDZpXDPAcdsXSipIXA08FNC8bFAy3DpCTwe7lsL6Ae0Bw4G+kmqWejXSKZ1zjkXe8pKfimEmY0Flm/noweAa4DEl1x3Bp63wDighqT6wN+A98xsuZmtAN5jO78othZJTl3Smq0avfkjwMysWhT1OudckaVwo1RST4Jedb4BZjagkGM6AwvM7CttWdeewLyE7flh2Y7KCxRJUDezqlGc1znnIpPCjdIwgBcYxLc4tVQJ6EOQeolUqYx+kVQP2DV/28x+KmB355wrfdGOfmkONAXye+kNgMmSDgYWAA0T9m0Qli0Ajtiq/MPCKor0W0g6UdL3wGzgI2AO8FaUdTrnXJGU7I3SLZjZ12ZWz8yamFkTglRKGzNbBIwEzgxHwXQAVpnZz8A7wNGSaoY3SI8Oywr+Gim3LjW3AR2A78ysKdAJGBdxnc45l7qSHdL4IvA50ErSfEnnFrD7m8CPwCzgKeAiADNbThBDJ4TLrWFZgaJOv+SY2TJJWZKyzOwDSQ9GXKdzzqWuBNMvZnZqIZ83SVg3oNcO9hsIDEyl7qiD+kpJVYCxwGBJS4B1EdfpnHOpi8k0AVGnXzoD64HLgbeBH4ATIq7TOedSJinpJZNF1lOXlA2MMrMjgU3AoKjqcs654sr0YJ2syIK6meVJ2iSpupmtiqoe55wrCcryoJ6MtcDXkt4jIZduZpdEXG+JW/HzPN58/M7N26t/WUSHk86gSs06jHv1vyz/eR7dbuzPbk33AmDu9El8Nnwgebm5ZJcrR8eu59Nw7wPS1fwyJS8vj6sv7E6tOnXpe1d/3nxlCK+PeIFFC+cz6NUxVKseTH8x/6fZPHzPzfz4/UxOP7cXXf51ZppbXjbc1Pd6xn70IbVq1ebl10YBcPWVlzF39mwA1qxZQ9WqVRn28mssWDCfk044jiZNmgLwx/3358Z+t6at7VHynnpyXg6XRNubPiDj1azfkNNvfRyATZvyeOby02ne5jByN27g+ItvYsyg/lvsX7FKdU649Faq1KzN0vlzePW+Ppz3wAvpaHqZM+qlF2nQqCnr168FoPW+B9DukMPpe9n5W+xXpWp1zut9DeM/+SAdzSyzOnc5mVNP684N11+7uew/9/0+KO3e/7ubKlWqbN5u0LARw15+rVTbmA5xCepR3yitYWaDEheg0FnGMt28GVOoXq8+1ersRq09GlGzfsNt9qnXuAVVatYGoPaejcnN2UBuzsbSbmqZs/SXxUwa9zF/+XuXzWXNWram3u57bLNvjZq1aNl6H8qV89cCpKJtu4OoVr36dj8zM9595y2O/fvxpdyq9IvLjdKog/r25v89K+I6I/fd+A9p1f6IpPefNfET6jVuQbnyFaJrVEwMfOReelxwKVlZPoFoOkyeNJHatWvTuHGTzWULFsyn6z+6cE6P7kyeNDF9jYuaUlgyWFSzNJ4KnAY0lTQy4aOqbH86yjIjLzeHH6eM49BTzklq/2UL5vDp8GfoctWdhe+8k5vw+Viq16hF81Z7M21KjINHBnvrzVEcc9zvvfS6devxzugPqFGjJjOmT+OyS3rx8mtvbJGeiYtM74EnK6q/Wz8DfgbqAPcllK8Bpu7ooMTpLE+95g46dj4touYV3ZypE6jXuAWVqxeeRVqz/BdGPXwrR59/NTXqbZs+cFuaOe0rJnz2EZPGf0LOxo2sX7+OB+64gctvuCPdTdsp5ObmMmb0ewwZ9vttsAoVKlChQvAX5t777EvDho2YO2c2++z7x3Q1MzJx+eswqql35wJzgUNSPG7zdJaPfTYnI2+ofjf+Q/ZKIvWyYf1aRj54I4edcg57tNwn+obFwBnn9+aM83sDMG3KRF4d+rwH9FI0/vPPaNq0GbvtvvvmsuXLl1O9enWys7OZP28ec+fOoUGDbe8hxYH31JOw1csyKgDlgXVl9SUZORt+46fpkzmqx6Wby2ZN+pSPBj/Gr2tW8dqDN1K3YXNOuupOvho9kpWLFzJ+5GDGjxwMwElX3UWlajXS1fwya9RLL/LqkEGsWL6My879F23bd6TX1TexYvlSrr6gO+vXr0MSo0a8QP/nRlCpcvxSAyXp2quuYOKEL1i5cgV/Pepw/t2rNyf/45+8/dabHHPc37fYd/LECTz6SH/KlyuHsrLoe9MtVK8R03/D8YjpKJhLphQqCn4NdgY6mNl1he2fqT31ODmiSd10NyH2mtWrnO4m7BR2LVf8kFznrCFJx5ylz3XL2F8BpZZECt+/9yrBe/eccy6jxGVIY9Tpl5MTNrOAdsBvUdbpnHNF4dMEJCdxRsZcgjcfdY64TuecS1mm98CTFWlQN7Ozozy/c86VlLgE9ajfUbqXpDGSpoXb+0nqG2WdzjlXFHHJqUd9o/Qp4HogB8DMpgLdIq7TOedSFpegHnVOvZKZfbHVRciNuE7nnEtdZsfqpEUd1JdKak74AJKkUwimD3DOuYzi0wQkpxfBY/+tJS0AZgOnR1ync86lLNPTKsmKOqgvAJ4FPgBqAasJpuON56tTnHNlVzxieuQ3Sl8jGKueAywkeL3dugKPcM65NCjJG6WSBkpakj/yLyz7j6SZkqZKekVSjYTPrpc0S9K3kv6WUH5MWDZLUqHTq0D0PfUGZnZMxHU451yxlXD65TngEeD5hLL3gOvNLFfSPQQjA6+VtDfBqMB9gD2A0ZL2Co95FPgrMB+YIGmkmc0oqOKoe+qfSYrfxMvOudgpyZ66mY1lqxcCmdm7ZpY/+m8c0CBc7wwMMbMNZjYbmAUcHC6zzOxHM9sIDCGJJ/Kj7ql3BM6SNBvYQJC1MjPbL+J6nXMuJanM/ZL4Qp/QgPB9EMk6Bxgaru9JEOTzzQ/LAOZtVd6+sBNHHdSPjfj8zjlXIlJJvyS+0KcI9dxA8LzO4KIcX5io536ZG+X5nXOupJTGkEZJZwHHA53s95dZLAASXyfVICyjgPIdisdoe+ecKyYp+aVo59cxwDXAiWa2PuGjkUA3SbtIagq0BL4AJgAtJTWVVIHgZurIwuqJOv3inHNlQkn21CW9CBwB1JE0H+hHMNplF+C9sK5xZnahmU2XNAyYQZCW6WVmeeF5LgbeAbKBgWY2vbC6Pag75xyQVYIvyTCzU7dT/EwB+98BbPOWdTN7E3gzlbo9qDvnHEVPq2QaD+rOOUfJ9tTTyYO6c87hPXXnnIsVn6XROediJCYx3YO6c86BvyTDOedixXvqzjkXI55Td865GIlJTPeg7pxz4D1155yLlZjEdA/qzjkH/kRp5A5vVCfdTYi9tn+/Nt1NiL2l4x9OdxN2EsUPyJ5+cc65GIlJTPeg7pxz4D1155yLlZjEdA/qzjkHfqPUOedixdMvzjkXIx7UnXMuRmIS0z2oO+cceE/dOediJSYx3YO6c85BfEa/xONVH845V0xZUtJLYSQNlLRE0rSEslqS3pP0ffizZlguSf0lzZI0VVKbhGN6hPt/L6lHUt+jCN/dOediR0p+ScJzwDFblV0HjDGzlsCYcBvgWKBluPQEHg/ao1pAP6A9cDDQL/8XQUE8qDvnHMGN0mSXwpjZWGD5VsWdgUHh+iCgS0L58xYYB9SQVB/4G/CemS03sxXAe2z7i2IbHtSdcw7IUvKLpJ6SJiYsPZOoYjcz+zlcXwTsFq7vCcxL2G9+WLaj8gL5jVLnnCO1G6VmNgAYUNS6zMwkWVGPL4j31J1zDlAK/yuixWFahfDnkrB8AdAwYb8GYdmOygvkQd0550gt/VJEI4H8ESw9gNcSys8MR8F0AFaFaZp3gKMl1QxvkB4dlhUo8vSLpIpAIzP7Nuq6nHOuqEryiVJJLwJHAHUkzScYxXI3MEzSucBcoGu4+5vAccAsYD1wNoCZLZd0GzAh3O9WM9v65us2Ig3qkk4A7gUqAE0lHRA27MQo63XOuVSV5BOlZnbqDj7qtJ19Dei1g/MMBAamUnfU6ZebCcZXrgQwsylA04jrdM65lJXkw0fpFHX6JcfMVm31Z00kd3ydc6444jJNQNRBfbqk04BsSS2BS4DPIq7TOedSluEd8KRFnX7pDewDbABeAFYBl0Vcp3POpczTL8lpbWY3ADdEXI9zzhVLZofq5EUd1O+TtDswAhhqZtMKO8A559IhLi/JiDT9YmZHAkcCvwBPSvpaUt8o63TOuaIohYePSkXkT5Sa2SIz6w9cCEwBboq6TuecS1VWlpJeMlmhQT18dLW7pJvC7UaSDk7m5JL+IOlmSV8DDxOMfGlQrBY751wESnLq3XRKJqf+GLAJOAq4FVgDvAQclMSxA4GhwN/MbGFRG+mcc1HL8A540pIJ6u3NrI2kLwHMbIWkCsmc3MwOKVbrnHOulGR6DzxZyQT1HEnZhE+CSqpL0HPfIUnDzKxrmHZJfIJUBFMd7FfUBjvnXBTiEdKTC+r9gVeAepLuAE4BChvBcmn48/hitM0550pNdkzyL4UGdTMbLGkSwexiArqY2TeFHJP/yqaLzOzaxM8k3QNcu+1RZUNeXh7XXnQGtWrXpc+dD/HgnTfww7ffkF2uHC1b78MFl/ehXLnyrF2zmkf/cwuLFs6nQoVd6HX1TTRq2iLdzc9IT/Q7nWMP35dflq+h3T/vBOCGC47jnJMP5ZcVawHo98hI3vlkBu32acwjNwYT4ElwxxNvMvKDqQBUr1KRx/udxt7N62MGF94ymPFTZ6fnS2Wwm2/sw8djP6RWrdoMf+V1AL77diZ33NqPX9evp/6ee3LH3fdSpUoVcnJyuO3mvsycMYPcvDyOP7Ez55x3QZq/QTTikn5JZvRLI4I5fl8nmMx9XViWjL9up+zY5JuXed54+UX2bNRk8/afOh1L/+de4oGnh7JhwwZGv/kqAC+9MJCmLVrxwNND6X3dLQx89N40tTjz/ff1cXTu9eg25Q//7wM6dLubDt3u5p1PZgAw/YeFHHb6/9Gh29107vUYD/c9lezs4J/xvdecwrufzeCAk2/n4H/dxcwfF5Xq9ygrTuh8Eo88/tQWZbf268sll13JsFde58hOf+X5Z58BYPS7b7NxYw7DXnmdwUNf4qXhQ1m4YH46mh05KfklkyUzTv0NYFT4cwzwI/BWQQdI+neYT28laWrCMhuYWtxGp8uyXxYzefwn/OW4LpvL2rbvuHmYU8vW+7Dsl+ANVfPn/si+BwQDhBo0asqSRQtZuXxZWtqd6T6d/APLV61Pat9ff8shLy+4pbNLhfIEU1FDtSq70rFNc5575XMAcnLzWLX212gaXMa1bXcQ1atX36Lsp7lzaNMu+Pfa4ZBDGTP6XSDovf7663pyc3PZsOE3ypcvT+UqVUq9zaUhLnO/FBrUzeyPZrZf+LMlwfzonxdy2AvACQQ9+xMSlrZm1r2YbU6bgY/exxk9L0Xa9rLl5ubw0XtvcOBBhwLQpNlejP/kfQC+nzmNXxYvYtnSJdsc53bswm6H88XQ63mi3+nUqFpxc/lB+zZm0ogbmDi8D5fcMYS8vE002aM2S1esZcAt3fn8xWt57KbTqLRrUoO0HNCseQs+fH8MAKPfeZvFi4IMaqe//o2KFStx9FF/4rijj+KMHudQvXqNdDY1MjtTT30LZjYZaF/IPqvMbI6ZnWpmc4FfCUbBVCkodSOpp6SJkiYOH5zSyz4iN/HzsVSvWZPme/1hu58/9dDd7L1fG/be70AATjr1LNatXcOVPU/lzVeG0rRlK7Ky/JWwyXpq+MfsfcLNtO92N4uWrubuK07e/NmEaXNpe8oddOz+f1x9ztHsUqEc5cplc0Drhjw1/GMOOfUe1v+6gavO2V72z21Pv1vvZPjQFzit68msW7+O8uXLAzB92tdkZ2XxzpixjHprNP97/lnmz5uX5tZGY6d5+EjSFQmbWUAbIKkHicLX2d0P7EHw5uzGwDcE0/Fuw8wGAAMAps1fm1Ev05g5/SsmfDaWyeM/JWfjRtavX8tDd/bl0j63M+z5AaxauYJrbvl9MspKlatw8TU3A2Bm/Pv0E9it/p5pan3Zs2T5ms3rA1/+lJf7X7jNPt/OXsza9RvYp8UeLFi8ggVLVjJh2lwAXhk9hSvP9qCerKbNmvHYgKAjNXfObD4Z+xEAb70xikM6/ony5ctTq3Zt9j+gDTOmT6NBw4YFna5Mys7wYJ2sZLqOVROWXQhy652TPP/tQAfgOzNrSjCCZlwR2pl23c/rzVND3+KJF0Zxed87+eMBB3Fpn9sZ/cYrTJnwOZf3vXOLnvi6tWvIyckBYPSbr7D3fm2oVDmeucgo7F6n2ub1zkftz4wfgnRA4z1qb74x2qh+TVo13Z25C5exeNka5i9aQcvG9QA44uBWfqM0BcuXBfd7Nm3axNMDnuAfXbsBUL9+fSaMD/6T/XX9er6e+hVNmjZLWzujFJcJvQrsqYcPHVU1s6uKeP4cM1smKUtSlpl9IOnBIp4rIz354F3U3W13+vQ+G4D2HY+k65k9mT93Ng/f0w9JNGzSjIuu8nnMdmTQXWfxp7YtqVOjCrPevo3bnniTw9u2ZL9WDTAz5v68nN63vwjAoQc246qzjyYnN49Nm4xL7xzKspXrALjinuE8e+dZVCiXzZwFS+nZ73/p/FoZ6/prrmDShAmsXLmCYzr9mQt79Wb9+vUMGzIYgKM6HU3nLkG6q+upp3Fz3z6c0uV4zIwTu5zMXq1apbP5kcn0YJ0s5Y8e2OYDqZyZ5Ur6vKiP+0saDXQB7gLqEKRgDjKzQws7NtPSL3F00AnXpbsJsbd0/MPpbsJOoXKF4udOrnz926Rjzn0ntMrYXwEF9dS/IMifT5E0EhgOrMv/0MxeTuL8nYHfgMuB04HqBJOCOedcRolLTz2ZaQJ2BZYRzNJohPO3AIUGdTNbl7A5qCgNdM650lCS90klXQ6cRxArvwbOBuoDQ4DawCTgDDPbKGkX4HmgLUGs/ZeZzSlq3QXdKK0XjnyZFjZqGjA9/JnUa+kkrZG0eqtlnqRXJMXzbotzrkwqJyW9FETSnsAlQDsz2xfIBroB9wAPmFkLYAVwbnjIucCKsPyBcL8iKyioZwNVwqVqwnr+kowHgauBPQlejnEVwYNJQwjmWnfOuYxQwg8flQMqSioHVAJ+Jsh2jAg/H0RwvxGCNHV+JmME0EnFGAxfUPrlZzMrbv77RDPbP2F7gKQpZnatpD7FPLdzzpWYVB7/l9QT6JlQNCB8zgYzWyDpXuAnggcv3yVIt6w0s9xw//kEnV3Cn/PCY3MlrSJI0SwtyvcoKKiXRIZpvaSu/P7b6RSCG6ew5TzrzjmXVqn0jRMflNz2PKpJ0PtuCqwkGGRyTPFbmJyC0i+dSuD8pwNnEAxlXByud5dUEbi4BM7vnHMlogQfPvoLMNvMfjGzHIJBJYcBNcJ0DATp6AXh+gKgIQRDyQlGCRZ59r8d9tTNbHlRT5pwjh8JJvLank+Ke37nnCspJfiSjJ+ADpIqEaRfOgETgQ8IshVDgB7Aa+H+I8Ptz8PP37cdPUCUhEhnmJK0l6QxkqaF2/tJKuytSc45V+pKqqduZuMJUs6TCUYOZhGkaq4FrpA0iyBn/kx4yDNA7bD8CqBYTwUmM069OJ4iGP3yJICZTZX0AsGcMM45lzFUgm8pNbN+QL+tin8kmLp8631/A/5ZUnVHHdQrmdkXW43Oyd3Rzs45ly470xOlxbFUUnPCkS6STiEYr+mccxnFg3pyehHkklpLWgDMJhgR45xzGSXTX36RrKiD+gLgWYK7vrWA1QR3eX1SL+dcRsmOyYvJog7qrxEMvp9Mkm9Lcs65dMj0F0onK+qg3sDMSu1JKuecK6q45NSj/oPjM0l/jLgO55wrthKe0Cttou6pdwTOkjQb2EA4F7uZ7Rdxvc45l5KsEhynnk5RB/VjIz6/c86ViEzvgScr0qBuZnOjPL9zzpWUcjFJqkfdU3fOuTLBe+rOORcjPqTROediJCYx3YO6c85B9OO7S4sHdeecw9MvzjkXKx7UnXMuRuIR0j2oO+cc4DdKnXMuVnw+deecixEf/eKcczHiN0ojtiF3U7qbEHvT3v1PupsQew9+/EO6m7BTuKFTi2Kfw9MvzjkXI3FJv8TlezjnXLFISnpJ4lw1JI2QNFPSN5IOkVRL0nuSvg9/1gz3laT+kmZJmiqpTXG+hwd155wjGKee7JKEh4C3zaw1sD/wDXAdMMbMWgJjwm0I3jvRMlx6Ao8X53t4UHfOOSBbSnopiKTqwOHAMwBmttHMVgKdgUHhboOALuF6Z+B5C4wDakiqX9Tv4UHdOedI7R2lknpKmpiw9Ew4VVPgF+BZSV9KelpSZWA3M/s53GcRsFu4vicwL+H4+WFZkfiNUuecA5TCRAFmNgAYsIOPywFtgN5mNl7SQ/yeask/3iRZUdtaEO+pO+ccqfXUCzEfmG9m48PtEQRBfnF+WiX8uST8fAHQMOH4BmFZkXhQd845IAslvRTEzBYB8yS1Cos6ATOAkUCPsKwH8Fq4PhI4MxwF0wFYlZCmSZmnX5xzjhKf0Ks3MFhSBeBH4GyCTvQwSecCc4Gu4b5vAscBs4D14b5F5kHdOeco2WkCzGwK0G47H3Xazr4G9Cqpuj2oO+cckBWPWQI8qDvnHKQ2+iWTeVB3zjn8JRnOORcr3lN3zrkY8Zy6c87FiL8kwznnYiQeId2DunPOAd5Td865WIlHSI947pdwLoPukm4KtxtJOjjKOp1zrkhK+C0Z6RL1hF6PAYcAp4bba4BHI67TOedSliUlvWSyqNMv7c2sjaQvAcxsRTjBjXPOZZTMDtXJizqo50jKBgxAUl1gU8R1Oudc6mIS1aNOv/QHXgHqSboD+AS4M+I6nXMuZUrhf5ks0p66mQ2WNIlgukkBXczsmyjrdM65osjwVHnSIg3qkvoDQ8zMb4465zJaTGJ65OmXSUBfST9IulfS9iaNd865tJOU9JLJIg3qZjbIzI4DDgK+Be6R9H2UdTrnXFGU4Iun06q0nihtAbQGGgOeU3fOZZwMj9VJizqn/n/AScAPwFDgNjNbGWWdzjlXJDGJ6lH31H8ADjGzpRHX45xzxZLpQxWTFUlQl9TazGYCE4BGkholfm5mk6OotzRsysvjht5nUqt2Pa6+7QFuueJ8fvt1HQCrVq6geat9uPLme5nx1STuu/lK6u2+BwAHHXYkJ3c/P51Nz3gbN2zgmovPIWdjDnl5uXQ88i90P/ci7r/jRr6eMonKlasAcPkNt9K8ZWvWrF7Ng3f14+eF86lQoQKXXX8LTZq1SPO3yHyrFs9n7DN3b95eu3QR+x/fnV9+nMnqJfMB2Lh+HRUqVeaEPo+w8Jsvmfzqs2zKyyUruxxtTz6X+q32T1fzI5PpufJkRdVTvwLoCdy3nc8MOCqieiP31qtD2LNhU35dHwTyfvc/tfmzB269hraH/Hnzdut9D+Tq2x4o9TaWVeUrVOCuh56iYqVK5ObmcNW/z6Zd+44AnHvR5XQ88q9b7D/sv0/TrGUrbrzrAebNnc1j99/FXQ8NSEfTy5TquzXghD6PALBpUx4j+pxJo/0PZe+jumzeZ+JLT1O+YiUAdqlSjaP+3Y9KNWqzYuEcRj98E/+86/m0tD1KcQnqkYx+MbOe4eqxZnZk4gIcF0WdpWHZL4uZ8sUnHHls520+W79uLdO/mki7Q/+8nSNdMiRRsVIQSHJzc8nLyy3wv7Sf5vzI/m2DST8bNm7K4p8XsmL5slJpa1wsmvkVVevUp0rtepvLzIw5kz6mabvg33Lths2pVKM2ADXqNyYvZwN5OTlpaW+USvqJUknZkr6UNCrcbippvKRZkobmz4MlaZdwe1b4eZPifI+ox6l/lmRZmfDfJ+7n1PMuQdr2sk387CP2PeAgKoUpAoDvv/ma6y48jXtuuIT5c34ozaaWWXl5eVx8VldOO+EoDmzXgdb7/BGAQQMe4aIe/2RA//+Qs3EjAE1b7MVnH40B4NsZX7Nk8c8sXbI4bW0vi2ZPGrs5eOdbMms6FavVoFq9PbfZ/6cvP6VWw+Zkly9fWk0sNREMabyULUf73QM8YGYtgBXAuWH5ucCKsPyBcL8iiySoS9pdUlugoqQDJbUJlyOASlHUGbXJ4z6mWo2aNGv5h+1+/vmH73DoEX/bvN2kRSv6/3ckdz/xAkd3/hf33XJ1aTW1TMvOzuaR54bx/Mvv8N0305jz4yzOuuASBrzwKg89NZg1q1cxfPCzAHTtfg5r167h4rO6MvKlITRv2Yqs7Kj7KfGRl5vD/Knjadym4xblsyd+RJN22/7FuXLhXCa9+iyHnNa7tJpYqkpyOnVJDYC/A0+H2yJIO48IdxkE5Oe7OofbhJ93UjGecIrqv4C/AfcCDYD7CXLr9xHk2vvs6CBJPSVNlDTx5ReejahpRfPdjK+YPO5jLjnzRB6+qw/Tv5rAo/fcCMDqVSv54dsZHND+sM37V6pchfE+bEIAAAzXSURBVF3DnOSBBx9GXl4uq1f5aM5kValajf3aHMSkcZ9Sq05dJFG+QgX+elxnvv1mGhBc4yv63Mojzw3jqr63s2rlCurv0SDNLS87FkyfSK2GzalYrebmsk15efw05TOatD18i33XrVjKBwNup2OPK6lat35pN7V0pBDVE2NVuPTc6mwPAtfw+6y0tYGVZpYbbs8H8v8U2hOYBxB+vircv0giuVFqZoOAQZL+YWYvpXDcAGAAwKQ5qy2KthVVt3Mupts5FwMw46tJvDHif/S69jYAvvh4DAe270iFCrts3n/l8qVUr1kbScyaOR3btImq1aqnpe1lxaoVy8kuV44qVauxYcNvfDlhHKecfjbLl/5CrTp1MTM+//gDmjQNRrisXbOaXXatSPny5Xnn9ZfZd/+2W6S/XMHmTBxL04O27JH/PPNLqu/WgMo162wu27h+Le8/djNtOp9FveZ7l3YzS00qL79IjFVbk3Q8sMTMJoXZiVIV1ZDG7mb2P6CJpCu2/tzM7o+i3nT5/KN3ObFrjy3Kxn/8PqNHjSA7uxwVdtmF3tffkfFzRqTb8mVLue+OG9m0aRO2aRN/Oupo2h92ONddcj6rVq4AM5q1bMXFV/UFYN7c2dx3+41IonHT5lx63c3p/QJlSM6G31g480s6nHbxFuVzJo3dJvUy86NRrPllIVPfepGpb70IwF96307FqjVKrb2loQT/6zwMOFHSccCuQDXgIaCGpHJhb7wBsCDcfwHQEJgvqRxQHSjyHX+ZlXyHWNIFZvakpH7b+9zMbinsHJnWU4+jGpXjd7Mr0wyZuqDwnVyx3dCpRbFj8neL1ycdc/barVJS9YU99avM7HhJw4GXzGyIpCeAqWb2mKRewB/N7EJJ3YCTzaxrUb4DRJd+eTL8WWjwds65TFAKT5ReCwyRdDvwJfBMWP4M8F9Js4DlQLfiVFIac7/cDvwKvA3sB1wepmaccy5jRJEdNbMPgQ/D9R+Bg7ezz2/AP0uqzqjHfx1tZquB44E5BLM1+tg+51zGKckhjekU9YRe+ef/OzDczFb5zULnXCaKS2yKOqiPkjSTIP3yb0l1gd8irtM551IWk5ge+ZuPrgMOBdqZWQ6wjuDpKeecyyiefkmCpPJAd+Dw8E+bj4AnoqzTOeeKJNOjdZKiTr88DpQHHgu3zwjLzou4XuecS4m/JCM5B5lZ4mz670v6KuI6nXMuZZ5TT06epOb5G5KaAXkR1+mccynLUvJLJou6p3418IGkH8PtJsDZEdfpnHNFkOHROklR99Q/BZ4kmH5yebj+ecR1OudcyiJ4SUZaRB3UnweaArcBDwPNgP9GXKdzzqXMhzQmZ18zS5yA+QNJMyKu0znnUpbpPfBkRd1TnyypQ/6GpPbAxIjrdM65lElKeslkUffU2wKfSfop3G4EfCvpa8DMbL+I63fOuaRkdqhOXtRB/ZiIz++ccyUiwzvgSYs0qJvZ3CjP75xzJcWfKHXOuTiJR0z3oO6ccxCbmO5B3TnnALJiklT3oO6cc8TnRmnU49Sdc86VIu+pO+cc8empe1B3zjniM6TR0y/OOUfJzdIoqaGkDyTNkDRd0qVheS1J70n6PvxZMyyXpP6SZkmaKqlNcb6HB3XnnKNEp97NBa4MJzPsAPSStDdwHTDGzFoCY8JtgGOBluHSk+CVn0XmQd055wjSL8n+ryBm9rOZTQ7X1wDfAHsCnYFB4W6DgC7hemfgeQuMA2pIql/U7+FB3TnnSK2nLqmnpIkJS8/tn1NNgAOB8cBuZvZz+NEiYLdwfU9gXsJh88OyIvEbpc45R2pPlJrZAGBAgeeTqgAvAZeZ2erEKXvNzCRZkRpaCO+pO+cclOirjySVJwjog83s5bB4cX5aJfy5JCxfADRMOLxBWFYkHtSdc45gmoBkl4Io6JI/A3xjZvcnfDQS6BGu9wBeSyg/MxwF0wFYlZCmSZnMIvkLYKckqWf4Z5mLiF/j6Pk1Lh5JHYGPga+BTWFxH4K8+jCClwXNBbqa2fLwl8AjBO+fWA+cbWZFfkOcB/USJGmimbVLdzvizK9x9Pwal22efnHOuRjxoO6cczHiQb1keR4yen6No+fXuAzznLpzzsWI99Sdcy5GPKg751yMeFAvYZKaSDqtiMeuLen2xJmkGpIuStjeQ9KIdLaprJN0oaQzw/WzJO2R8NnT4WyDLoN5Tr2ESToCuMrMjt/OZ+XMLLeAY9eaWZUo2xcn4WRJo8xs3zQ3JZYkfUjwb7nID8K40uc99VDYw/5G0lPhxPbvSqooqbmktyVNkvSxpNbh/s9JOiXh+Pxe9t3AnyRNkXR52NsZKel9YIykKpLGSJos6WtJndPwdUtFEa5pc0njwutye/41LeCa3Q00D6/1f8L6poXHjJO0T0JbPpTUTlJlSQMlfSHpyzhd//D7z5Q0OLzuIyRVktQp/K5fh999l3D/uxW8yGGqpHvDspslXRX+224HDA6vb8WEa3ihpP8k1HuWpEfC9e7htZ0i6UlJ2em4Fjs1M/Ml+GulCcHk9geE28OA7gST2bcMy9oD74frzwGnJBy/Nvx5BEHvMb/8LIKpNGuF2+WAauF6HWAWv//FtDbd1yHN13QUcGq4fmHCNd3uNQvPP22r+qaF65cDt4Tr9YFvw/U7ge7heg3gO6Byuq9VCV5vAw4LtwcCfQmmdd0rLHseuAyoDXyb8G+vRvjzZoLeOcCHQLuE839IEOjrArMSyt8COgJ/AF4HyofljwFnpvu67GyL99S3NNvMpoTrkwj+IzkUGC5pCvAkQYBI1XtmtjxcF3CnpKnAaIJ5k3fb4ZFlXyrX9BBgeLj+QsI5inLNhgH5f0l1BfJz7UcD14V1fwjsSjAXR1zMM7NPw/X/AZ0I/j/4LiwbBBwOrAJ+A56RdDLBnCNJMbNfgB8ldZBUG2gNfBrW1RaYEF7fTkCzEvhOLgU+n/qWNiSs5xEEjpVmdsB29s0lTF9JygIqFHDedQnrpxP0dNqaWY6kOQSBJa5SuaY7kvI1M7MFkpZJ2g/4F0HPH4JfEP8ws29TqL8s2fom2UqCXvmWO5nlSjqYIPCeAlwMHJVCPUMIflnOBF4xMwsnphpkZtcXqeWuRHhPvWCrgdmS/gmbXxC7f/jZHIJeCcCJQPlwfQ1QtYBzVgeWhMHpSKBxibc6sxV0TccB/wjXuyUcs6NrVti1HgpcA1Q3s6lh2TtA7zAAIenA4n6hDNNI0iHh+mnARKCJpBZh2RnARwpe4FDdzN4kSFXtv+2pCry+rxC8hu1UggAPQVrtFEn1YPOLlne2f99p50G9cKcD50r6CphO8A8Z4Cngz2H5IfzeG58K5En6StLl2znfYKCdpK+BMwl6OjubHV3Ty4ArwjRLC4IUAezgmpnZMuBTSdMSb9wlGEHwy2FYQtltBL+Ap0qaHm7HybcELzr+BqgJPACcTZDuyp8K9gmCYD0qvNafAFds51zPAU/k3yhN/MDMVhC8e7OxmX0Rls0gyOG/G573PYqWrnTF4EMaXcaQVAn4NfxTvhvBTdPYjE6JmnyIp8Nz6i6ztAUeCVMjK4Fz0twe58oc76k751yMeE7dOedixIO6c87FiAd155yLEQ/qLhKS8sKhcNMkDQ9HthT1XJvn2VEhMwVKOkLSoUWoY46kOkVto3OZwoO6i8qvZnZAOLxuI78/0QkEM1YW5aRmdl44HnpHjiCYhsC5nZIHdVcaPgZahL3ojyWNBGZIyg5nV5wQzhR4AWx+yvQRSd9KGg3Uyz9R/kyB4foxCmZu/ErBLI5NCH55XB7+lfAnSXUlvRTWMUHSYeGxtRXMGjld0tME0wc4V+b5OHUXqbBHfizwdljUBtjXzGZL6gmsMrODFEwH+6mkd4EDgVbA3gRzxcwgmHEw8bx1CZ7qPTw8Vy0zWy7pCYLZHfOnkn0BeMDMPpHUiGCagD8A/YBPzOxWSX8Hzo30QjhXSjyou6hUDGfqg6Cn/gxBWuQLM5sdlh8N7Kff56WvDrQkmEXwRTPLAxYqmIt+ax2AsfnnSpgFc2t/AfYOp3oBqBbOe3I4cHJ47BuSVhTxezqXUTyou6j8uvVMjGFgTZyxUkBvM3tnq/2OK8F2ZAEdzOy37bTFudjxnLpLp3eAf0sqDyBpL0mVgbHAv8Kce33gyO0cOw44XFLT8NhaYfnWMwu+C/TO35CU/4tmLMEshkg6lmDyK+fKPA/qLp2eJsiXT1bwGronCf56fAX4PvzseeDzrQ8MX9TQE3g5nO1xaPjR68BJ+TdKgUsIZnicKmkGv4/CuYXgl8J0gjTMTxF9R+dKlc/94pxzMeI9deecixEP6s45FyMe1J1zLkY8qDvnXIx4UHfOuRjxoO6cczHiQd0552Lk/wG2637riv1YeAAAAABJRU5ErkJggg==\n"
          },
          "metadata": {
            "needs_background": "light"
          }
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "\n",
            "\n",
            "\n",
            "              precision    recall  f1-score   support\n",
            "\n",
            "     neutral       0.44      0.55      0.49      1298\n",
            "    negative       0.67      0.71      0.69      2163\n",
            "    positive       0.67      0.48      0.56      1606\n",
            "\n",
            "    accuracy                           0.60      5067\n",
            "   macro avg       0.59      0.58      0.58      5067\n",
            "weighted avg       0.61      0.60      0.60      5067\n",
            "\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Using Face Features\n",
        "We used MTCNN to extract faces from the images, then pass the cropped images to InceptionResnetV1 with pretrained 'vggface2' weights which embeds each face to a 512 dimensional vector. We then average these embeddings for images with multiple faces and use an all zeros 512 dimensional vector for images with no detected faces. We then concatenate these image embeddings with BERT output and pass it to a Multi-Layer Perceptron."
      ],
      "metadata": {
        "id": "J8ADYFDeByde"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# define an image transform that resizes the input to 640x1280 and reshape to (H, W, C)\n",
        "image_transform = transforms.Compose([\n",
        "    transforms.Resize((640, 1280)),\n",
        "    torchvision.transforms.Lambda(lambda x: x.permute(1, 2, 0))\n",
        "])\n",
        "# change the image transform of the dataset\n",
        "MSCTD_train.image_transform = image_transform\n",
        "MSCTD_dev.image_transform = image_transform\n",
        "MSCTD_test.image_transform = image_transform"
      ],
      "metadata": {
        "id": "vwQteDt1E5Jq"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')\n",
        "mtcnn = MTCNN(image_size=160, margin=0, min_face_size=20, thresholds=[0.8, 0.9, 0.9], keep_all=True, device=device)\n",
        "resnet = InceptionResnetV1(pretrained='vggface2').eval().to(device)\n",
        "np.warnings.filterwarnings('ignore', category=np.VisibleDeprecationWarning)\n",
        "\n",
        "# define text encoder\n",
        "text_encoder = TextEncoder(is_trainable=True).to(device)\n",
        "\n",
        "# define the classifier\n",
        "classifier = MLPClassifier(512+768, 512, 3).to(device)\n",
        "\n",
        "# define the optimizer\n",
        "optimizer = optim.Adam(list(classifier.parameters()) + list(text_encoder.parameters()), lr=1e-5)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 124,
          "referenced_widgets": [
            "8741d5cc28ef4fb3b4968aa05d9c1b65",
            "b6321a1e370a49e0bfd863e28559b737",
            "452c1d02549046ff94945f0f3d74d64f",
            "15b0fb9a413a4abc838c0eb99ef5e2d0",
            "f80d2533f04a4ecc83921b0d6f1d5f37",
            "a70f1e3bc12642cd93c28da7e5fbb9d5",
            "e89599ab79d84e8c9204fccde2f2b123",
            "38a1ece6af714171830173ad962f5eeb",
            "9c37d1e9c8b5491bb55cc61a98b00edd",
            "f9b305eece3c479c8da0cc57a849aec2",
            "954b9f39f7eb4f75b825a2e0210156bb"
          ]
        },
        "id": "L2lc5PItE9SS",
        "outputId": "a41cc8fe-13d8-4932-9179-2dea1f2416a2"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "  0%|          | 0.00/107M [00:00<?, ?B/s]"
            ],
            "application/vnd.jupyter.widget-view+json": {
              "version_major": 2,
              "version_minor": 0,
              "model_id": "8741d5cc28ef4fb3b4968aa05d9c1b65"
            }
          },
          "metadata": {}
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "Some weights of the model checkpoint at bert-base-uncased were not used when initializing BertModel: ['cls.seq_relationship.weight', 'cls.predictions.transform.dense.weight', 'cls.predictions.transform.LayerNorm.weight', 'cls.predictions.transform.LayerNorm.bias', 'cls.predictions.bias', 'cls.seq_relationship.bias', 'cls.predictions.decoder.weight', 'cls.predictions.transform.dense.bias']\n",
            "- This IS expected if you are initializing BertModel from the checkpoint of a model trained on another task or with another architecture (e.g. initializing a BertForSequenceClassification model from a BertForPreTraining model).\n",
            "- This IS NOT expected if you are initializing BertModel from the checkpoint of a model that you expect to be exactly identical (initializing a BertForSequenceClassification model from a BertForSequenceClassification model).\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "train_losses = []\n",
        "dev_losses = []\n",
        "train_accs = []\n",
        "dev_accs = []\n",
        "num_epochs = 2\n",
        "for epoch in range(num_epochs):\n",
        "    # train\n",
        "    train_loss = 0\n",
        "    train_acc = 0\n",
        "    total_samples = 0\n",
        "    for images, texts, labels in tqdm(train_dataloader_tokenized):\n",
        "        # crop face images\n",
        "        image_cropped = mtcnn(images)\n",
        "        # average embeddings over images with multiple faces and zero for images with no face\n",
        "        image_embeddings = torch.stack([torch.mean(resnet(image.to(device)), dim=0) if image is not None else torch.zeros(512).to(device) for image in image_cropped])\n",
        "        labels = labels.to(device)\n",
        "        texts = texts.to(device)\n",
        "        # get the text embeddings\n",
        "        text_embeddings = text_encoder(texts)\n",
        "        # concatenate the image and text embeddings\n",
        "        embeddings = torch.cat((image_embeddings, text_embeddings), dim=1)\n",
        "        # get the predictions\n",
        "        predictions = classifier(embeddings)\n",
        "        # calculate the loss\n",
        "        loss = F.cross_entropy(predictions, labels)\n",
        "        # calculate the accuracy\n",
        "        acc = (predictions.argmax(dim=1) == labels).float().sum()\n",
        "        # backpropagation\n",
        "        optimizer.zero_grad()\n",
        "        loss.backward()\n",
        "        optimizer.step()\n",
        "        # update the loss and accuracy\n",
        "        train_loss += loss.item()\n",
        "        train_acc += acc.item()\n",
        "        total_samples += labels.size(0)\n",
        "    # calculate the average loss and accuracy\n",
        "    train_loss /= len(train_dataloader_tokenized)\n",
        "    train_acc /= total_samples\n",
        "    # save the loss and accuracy\n",
        "    train_losses.append(train_loss)\n",
        "    train_accs.append(train_acc)\n",
        "\n",
        "    # evaluate\n",
        "    dev_loss = 0\n",
        "    dev_acc = 0\n",
        "    total_samples = 0\n",
        "    with torch.no_grad():\n",
        "        for images, texts, labels in tqdm(dev_dataloader_tokenized):\n",
        "            # crop face images\n",
        "            image_cropped = mtcnn(images)\n",
        "            # average embeddings over images with multiple faces and zero for images with no face\n",
        "            image_embeddings = torch.stack([torch.mean(resnet(image.to(device)), dim=0) if image is not None else torch.zeros(512).to(device) for image in image_cropped])\n",
        "            labels = labels.to(device)\n",
        "            texts = texts.to(device)\n",
        "            # get the text embeddings\n",
        "            text_embeddings = text_encoder(texts)\n",
        "            # concatenate the image and text embeddings\n",
        "            embeddings = torch.cat((image_embeddings, text_embeddings), dim=1)\n",
        "            # get the predictions\n",
        "            predictions = classifier(embeddings)\n",
        "            # calculate the loss\n",
        "            loss = F.cross_entropy(predictions, labels)\n",
        "            # calculate the accuracy\n",
        "            acc = (predictions.argmax(dim=1) == labels).float().sum()\n",
        "            # update the loss and accuracy\n",
        "            dev_loss += loss.item()\n",
        "            dev_acc += acc.item()\n",
        "            total_samples += labels.size(0)\n",
        "    # calculate the average loss and accuracy\n",
        "    dev_loss /= len(dev_dataloader_tokenized)\n",
        "    dev_acc /= total_samples\n",
        "    # save the loss and accuracy\n",
        "    dev_losses.append(dev_loss)\n",
        "    dev_accs.append(dev_acc)\n",
        "\n",
        "    # print the loss and accuracy\n",
        "    print(f'Epoch {epoch+1}/{num_epochs}, Train Loss: {train_loss:.4f}, Train Acc: {train_acc:.4f}, Dev Loss: {dev_loss:.4f}, Dev Acc: {dev_acc:.4f}')"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "0AkgF-0KFRS8",
        "outputId": "634e2005-956a-4fa9-c274-23dce0bc921a"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "100%|██████████| 633/633 [38:27<00:00,  3.65s/it]\n",
            "100%|██████████| 159/159 [07:09<00:00,  2.70s/it]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Epoch 1/2, Train Loss: 0.9497, Train Acc: 0.5907, Dev Loss: 0.9362, Dev Acc: 0.6018\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "100%|██████████| 633/633 [38:46<00:00,  3.67s/it]\n",
            "100%|██████████| 159/159 [07:15<00:00,  2.74s/it]"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Epoch 2/2, Train Loss: 0.8623, Train Acc: 0.6831, Dev Loss: 0.9359, Dev Acc: 0.6044\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# confusion matrix and classification report\n",
        "y_true = []\n",
        "y_pred = []\n",
        "with torch.no_grad():\n",
        "    for images, texts, labels in tqdm(test_dataloader_tokenized):\n",
        "        labels = labels.to(device)\n",
        "        texts = texts.to(device)\n",
        "        # crop face images\n",
        "        image_cropped = mtcnn(images)\n",
        "        # average embeddings over images with multiple faces and zero for images with no face\n",
        "        image_embeddings = torch.stack([torch.mean(resnet(image.to(device)), dim=0) if image is not None else torch.zeros(512).to(device) for image in image_cropped])\n",
        "        # get the text embeddings\n",
        "        text_embeddings = text_encoder(texts)\n",
        "        # concatenate the image and text embeddings\n",
        "        embeddings = torch.cat((image_embeddings, text_embeddings), dim=1)\n",
        "        # get the predictions\n",
        "        predictions = classifier(embeddings)\n",
        "        # get the labels\n",
        "        y_true.extend(labels.tolist())\n",
        "        y_pred.extend(predictions.argmax(dim=1).tolist())"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "qh7CE-w4FLIv",
        "outputId": "d9a94914-34ca-4516-d07e-c3afbf5fc10d"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "100%|██████████| 159/159 [07:25<00:00,  2.80s/it]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# confusion matrix\n",
        "cm = sns.heatmap(confusion_matrix(y_true, y_pred), annot=True, fmt='d', cmap='Blues', xticklabels=['neutral', 'negative', 'positive'], yticklabels=['neutral', 'negative', 'positive'])\n",
        "cm.set_xlabel('Predicted')\n",
        "cm.set_ylabel('True')\n",
        "plt.show()\n",
        "# classification report\n",
        "print('\\n\\n')\n",
        "print(classification_report(y_true, y_pred, target_names=['neutral', 'negative', 'positive']))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 519
        },
        "id": "X5OmJ1DYGzmm",
        "outputId": "09e4a5fa-e6ab-4475-ad7b-7245a8f24e45"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 432x288 with 2 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {
            "needs_background": "light"
          }
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "\n",
            "\n",
            "\n",
            "              precision    recall  f1-score   support\n",
            "\n",
            "     neutral       0.46      0.56      0.50      1298\n",
            "    negative       0.68      0.72      0.70      2163\n",
            "    positive       0.66      0.49      0.56      1606\n",
            "\n",
            "    accuracy                           0.60      5067\n",
            "   macro avg       0.60      0.59      0.59      5067\n",
            "weighted avg       0.62      0.60      0.60      5067\n",
            "\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Part 1 Subpart 2\n",
        "\n",
        "We followed these steps:\n",
        "\n",
        "Using CLIP:\n",
        "- Load pretrained CLIP model and AutoProcessor, then changing image transform of dataset to PILImage\n",
        "- Defined a TextImageDataset for CLIP\n",
        "- Created dataset and dataloaders. Instantiated MLP classifier\n",
        "- Defined train and evaluation functions\n",
        "- Defined two optimizers, one for CLIP and one for MLP classifier, and train for 2 epochs\n",
        "- Reported classification report and confusion matrix\n",
        "\n",
        "Using ViT + BERT:\n",
        "- Define Vision Transformer class\n",
        "- Instantiated Encoders and classifier\n",
        "- train for 3 epochs\n",
        "- Reported confusion matrix and classification report\n",
        "\n"
      ],
      "metadata": {
        "id": "CcahCTSx5_xW"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Using CLIP"
      ],
      "metadata": {
        "id": "NU6lC40kk85k"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "from transformers import AutoProcessor, CLIPModel\n",
        "\n",
        "# load pretrained processor and model for CLIP\n",
        "processor = AutoProcessor.from_pretrained(\"openai/clip-vit-base-patch32\")\n",
        "clip_model = CLIPModel.from_pretrained(\"openai/clip-vit-base-patch32\")\n",
        "# define device\n",
        "device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')\n",
        "# move the model to device\n",
        "clip_model = clip_model.to(device)\n",
        "\n",
        "# change image transforms on the dataset to PIL image to be ready for AutoProcessor\n",
        "image_transform = transforms.ToPILImage()\n",
        "MSCTD_train.image_transform = image_transform\n",
        "MSCTD_dev.image_transform = image_transform\n",
        "MSCTD_test.image_transform = image_transform"
      ],
      "metadata": {
        "id": "5ks-NPRpbDzz",
        "outputId": "01318f8f-4e76-4d1f-a756-bce0e425e411",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 273,
          "referenced_widgets": [
            "ab4de94edd374902ba19e095a1574c09",
            "4eb2115aec5f40548e08d8acf967d3ce",
            "d4ce1ab67f1b46f4828779109f2cdd6d",
            "67dbcd182fe847038e197442bc946cb9",
            "099f1a06be2f4bc589a23387de0b5958",
            "d2c106bc01dc40fca64ef45abfcd62b3",
            "bda078bac6534dc5bcf7a0fa4216d13f",
            "f9a2f37629c8434e88301f0ff22f11eb",
            "4202e739ce6342f3ab6d3b3b7b3ec4c6",
            "eb352e019cd94a4b9502b8170ea3e77b",
            "2dd120a4fcfc4e6e81433405faf4fabc",
            "be356a263f1f48c1acf65d4d93aca285",
            "2ec92719fec543b8a1c8ffbd3ebb0e04",
            "7ced846360fe4ac9832fc06273f3123a",
            "1f0e9dbb0c0a468b90e09ef3dd2b7d68",
            "c489f7182f204ae0a57b3464eea4494e",
            "d215211010f24231b00c97a09ef427af",
            "487a646ca805438a9ef2d1ee1d98a65b",
            "3c4e2c6b4c904995af7527e6af1f2064",
            "e5c7d1a34a5842af9d9e28ce57cfdc98",
            "7e51a113772e4ceb8d072900577a02b4",
            "37146d56aff1481dae8a80297cdd42c4",
            "910440a5aa11480aa9cf48984128a67e",
            "aa4614982ce644f289beda9b49eadcbd",
            "abc087188c984174a1473232df4f3b99",
            "f36cb501cb7a4f818d646b8864bc790c",
            "8d6bd867219e4f83bde84a25dc3f7e9a",
            "e3f6a9ff8a074261b188f081522b55c7",
            "372c0aa4b1644c7e88cb388123b02555",
            "d273a30bc0a5497aa78cead30ac7e8ff",
            "26257c1e8f514d3888cc71b7c5a3938d",
            "c4dfb3053f77475baa2fd42dd946c8ba",
            "f167ae4608834c1f804d7244953b0648",
            "39c2798c8b464251bdd014c304644a17",
            "bcb37951a38b4ae3ac90306c0c62f6cf",
            "6866489565e448f6a3dc4dd23cf0604b",
            "513bae98944f410aaba77547fa73ea00",
            "babfb4a9833e4e35989fab3fda5b3998",
            "b0c7eb90e8474103897c527d4328d3d1",
            "341f9c9f35b34382b10a9c6f93abc6fe",
            "b7926d74af0140eaa0fdc598afa677a0",
            "e5b60e8da3764866980e2bf7d372d089",
            "0deb6178218c47a99ffd375e4e2b60a5",
            "7efa97f13d2e4fa68d5deef2ee9552d0",
            "bbfc94a3aaf44e158eaf632ab09b46ba",
            "fc62ceecc4434e63992991a521c045f3",
            "de846be5457d4d2f80e82fd545ee503a",
            "077882c4cb444ef2a64595cbc0864d32",
            "e88f5086b08245fb8632c566c1f081e7",
            "65750e3c06f04c8398d60f1eac22bad0",
            "21ccad27efe2438ba6a42d16302f607f",
            "96e6231c5d6a4b5a8d1773ce8bc4b18d",
            "7ec0cd078d4941658ff25d51ffdbd71b",
            "7365a635162f44a19e6ff136dbadbcb1",
            "53da52afee264514bd4ee5fd0830d0b2",
            "5faa15162b6c4c39ae121ecd891816f6",
            "7c210be738214309b000dc62cd0c6a02",
            "e2d5426f9d9f4e90822ea13ffb9db839",
            "4efd197140874b739d9b3e4b94b74abb",
            "1a415954ed0d43e294e68b44680965d8",
            "3ce7ec3c098f4497a705bd4718bed68b",
            "3a127010c12042b0b60e42a637f7bbef",
            "96dd8dbf37b44570980f754e6fefbed1",
            "a2a34b9053694ed580b100a51590f462",
            "00674bc8606340b481ef53319b179472",
            "487b74da65574775a48922af522f2b0c",
            "5a9243a85b484d3b8e7197c4d77e0f3a",
            "e0d2608de2ed433f8d33f79c457761f2",
            "fab0b7e87b7f46ef9e6a61abcaeb0e1c",
            "6935884281e0441e8ba020af6e1654a7",
            "fc85369e35e14c9090f00d6013e95a34",
            "963543d2015a4e6e87e03facc1b08e10",
            "becb77eee8e847fb9901173d65201acb",
            "2d420782335448a58a9c2fb157088181",
            "cb86fd939c2643c9823210738e53536c",
            "7ac372a7a43c4d73ae4a3f6124510a9f",
            "886619927d5e476b8e72a264f44b71fe",
            "69599ecc5ba845418b9d297963ea73f6",
            "01131cf984f34bf19ec61b444249084e",
            "6f44a9a165364667b9e2f86fd585a794",
            "6e3b0a70a0724ccfa9cfb917b238c405",
            "f48d63a5d0bc467faee427f147567b66",
            "a578b9741c8d45da822a7222b6da4d21",
            "b46e7205d2d14945b8cefbf66e522559",
            "2376e85f817b40feb5715fdedd126406",
            "c688c66d7b604e73b8785a1f952b9a4a",
            "96f023f840f24e6db5a3439e1bee8308",
            "5e4c76bc097f48dcb2a112313fb14507"
          ]
        }
      },
      "execution_count": 7,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "Downloading (…)rocessor_config.json:   0%|          | 0.00/316 [00:00<?, ?B/s]"
            ],
            "application/vnd.jupyter.widget-view+json": {
              "version_major": 2,
              "version_minor": 0,
              "model_id": "ab4de94edd374902ba19e095a1574c09"
            }
          },
          "metadata": {}
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "Downloading (…)okenizer_config.json:   0%|          | 0.00/568 [00:00<?, ?B/s]"
            ],
            "application/vnd.jupyter.widget-view+json": {
              "version_major": 2,
              "version_minor": 0,
              "model_id": "be356a263f1f48c1acf65d4d93aca285"
            }
          },
          "metadata": {}
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "Downloading (…)lve/main/config.json:   0%|          | 0.00/4.19k [00:00<?, ?B/s]"
            ],
            "application/vnd.jupyter.widget-view+json": {
              "version_major": 2,
              "version_minor": 0,
              "model_id": "910440a5aa11480aa9cf48984128a67e"
            }
          },
          "metadata": {}
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "Downloading (…)olve/main/vocab.json:   0%|          | 0.00/862k [00:00<?, ?B/s]"
            ],
            "application/vnd.jupyter.widget-view+json": {
              "version_major": 2,
              "version_minor": 0,
              "model_id": "39c2798c8b464251bdd014c304644a17"
            }
          },
          "metadata": {}
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "Downloading (…)olve/main/merges.txt:   0%|          | 0.00/525k [00:00<?, ?B/s]"
            ],
            "application/vnd.jupyter.widget-view+json": {
              "version_major": 2,
              "version_minor": 0,
              "model_id": "bbfc94a3aaf44e158eaf632ab09b46ba"
            }
          },
          "metadata": {}
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "Downloading (…)/main/tokenizer.json:   0%|          | 0.00/2.22M [00:00<?, ?B/s]"
            ],
            "application/vnd.jupyter.widget-view+json": {
              "version_major": 2,
              "version_minor": 0,
              "model_id": "5faa15162b6c4c39ae121ecd891816f6"
            }
          },
          "metadata": {}
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "Downloading (…)cial_tokens_map.json:   0%|          | 0.00/389 [00:00<?, ?B/s]"
            ],
            "application/vnd.jupyter.widget-view+json": {
              "version_major": 2,
              "version_minor": 0,
              "model_id": "5a9243a85b484d3b8e7197c4d77e0f3a"
            }
          },
          "metadata": {}
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "Downloading (…)\"pytorch_model.bin\";:   0%|          | 0.00/605M [00:00<?, ?B/s]"
            ],
            "application/vnd.jupyter.widget-view+json": {
              "version_major": 2,
              "version_minor": 0,
              "model_id": "69599ecc5ba845418b9d297963ea73f6"
            }
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# define dataset\n",
        "class TextImageCLIPDataset(Dataset):\n",
        "    def __init__(self, data):\n",
        "        self.data = data\n",
        "    def __len__(self):\n",
        "        return len(self.data)\n",
        "    def __getitem__(self, idx):  \n",
        "        image, text, sentiment = self.data[idx]\n",
        "        inputs_dict = processor(text=text, images=image, return_tensors=\"pt\", add_special_tokens = True, padding='max_length', truncation=True, max_length = 30 )\n",
        "        return(inputs_dict['input_ids'].squeeze(0), inputs_dict['attention_mask'].squeeze(0), inputs_dict['pixel_values'].squeeze(0), sentiment)"
      ],
      "metadata": {
        "id": "rsM8p2lRbfEQ"
      },
      "execution_count": 8,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Create Datasets\n",
        "clip_trainset = TextImageCLIPDataset(MSCTD_train)\n",
        "clip_devset = TextImageCLIPDataset(MSCTD_dev)\n",
        "clip_testset = TextImageCLIPDataset(MSCTD_test)\n",
        "# create DataLoaders\n",
        "clip_trainloader = DataLoader(clip_trainset, batch_size=64, shuffle=True) \n",
        "clip_devloader = DataLoader(clip_devset, batch_size=64, shuffle=False)\n",
        "clip_testloader = DataLoader(clip_testset, batch_size=64, shuffle=False)\n",
        "\n",
        "# define classifier\n",
        "cat_classifier = MLPClassifier(2*clip_model.projection_dim, 512, 3).to(device)"
      ],
      "metadata": {
        "id": "bF71HtzMdKS_"
      },
      "execution_count": 9,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "def clip_model_train_loop(dataloader, clip_model, clip_mlp, loss_fn, optimizer_clip, optimizer_mlp):\n",
        "    train_losses = []\n",
        "    dev_losses = []\n",
        "    train_accs = []\n",
        "    dev_accs = []\n",
        "    size = len(dataloader.dataset)\n",
        "    num_batches = len(dataloader)\n",
        "    clip_model.train() \n",
        "    clip_mlp.train()\n",
        "    train_loss = 0\n",
        "    train_acc = 0\n",
        "    total_samples = 0\n",
        "    for data in tqdm(dataloader):\n",
        "        labels = data[3].to(device)\n",
        "        # get text image embeddings\n",
        "        text_image_embed = clip_model(data[0].to(device), \n",
        "                      attention_mask =data[1].to(device),\n",
        "                      pixel_values = data[2].to(device))\n",
        "        # get text features\n",
        "        text_feature = text_image_embed.text_embeds\n",
        "        # get image features\n",
        "        image_feature = text_image_embed.image_embeds\n",
        "        # concat the text and image features\n",
        "        text_image_feature = torch.cat((text_feature,image_feature),1)\n",
        "        # pass the concatenated features to classifier\n",
        "        pred = clip_mlp(text_image_feature)\n",
        "        # calculate loss\n",
        "        loss = loss_fn(pred, labels)\n",
        "        # Backpropagation\n",
        "        optimizer_mlp.zero_grad()\n",
        "        optimizer_clip.zero_grad()\n",
        "        loss.backward()\n",
        "        optimizer_clip.step()\n",
        "        optimizer_mlp.step()\n",
        "        acc = (pred.argmax(dim=1) == labels).float().sum()\n",
        "        train_loss += loss.item()\n",
        "        train_acc += acc.item()\n",
        "        total_samples += labels.size(0)\n",
        "    # calculate the average loss and accuracy\n",
        "    train_loss /= len(dataloader)\n",
        "    train_acc /= total_samples\n",
        "    # save the loss and accuracy\n",
        "    train_losses.append(train_loss)\n",
        "    train_accs.append(train_acc)\n",
        "    print(f'Train Loss: {train_loss:.4f}, Train Acc: {train_acc:.4f}')\n",
        "\n",
        "def clip_model_test_loop(dataloader,clip_model, clip_mlp, loss_fn):\n",
        "    size = len(dataloader.dataset)\n",
        "    num_batches = len(dataloader)\n",
        "    test_loss, correct = 0, 0\n",
        "    clip_model.eval()\n",
        "    clip_mlp.eval()\n",
        "    with torch.no_grad():\n",
        "        for data in tqdm(dataloader): \n",
        "            text_image_embed = clip_model(data[0].to(device), \n",
        "                          attention_mask=data[1].to(device),\n",
        "                          pixel_values = data[2].to(device))\n",
        "            text_feature = text_image_embed.text_embeds\n",
        "            image_feature = text_image_embed.image_embeds\n",
        "            text_image_feature = torch.cat((text_feature,image_feature),1)\n",
        "            pred = clip_mlp(text_image_feature)\n",
        "            labels = data[3].to(device)\n",
        "            loss = loss_fn(pred, labels)\n",
        "            test_loss += loss_fn(pred, labels).item()\n",
        "            correct += (pred.argmax(1) == labels).type(torch.float).sum().item()\n",
        "    test_loss /= num_batches\n",
        "    correct /= size\n",
        "    print(f\"Test Error: \\n Accuracy: {(100*correct):>0.1f}%, Avg loss: {test_loss:>8f} \\n\")\n",
        "    return correct\n"
      ],
      "metadata": {
        "id": "LlKPxPTZearz"
      },
      "execution_count": 10,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "loss_fn = nn.CrossEntropyLoss()\n",
        "epochs = 2\n",
        "optimizer_clip = torch.optim.Adam(clip_model.parameters(), lr = 5e-6)\n",
        "optimizer_mlp = torch.optim.Adam(cat_classifier.parameters(), lr = 1e-3)\n",
        "val_accuracy = []\n",
        "for t in range(epochs):\n",
        "    print(f\"Epoch {t+1}\\n-------------------------------\")\n",
        "    clip_model_train_loop(clip_trainloader, clip_model, cat_classifier, loss_fn, optimizer_clip, optimizer_mlp)\n",
        "    val_accuracy.append(clip_model_test_loop(clip_devloader,clip_model, cat_classifier, loss_fn))"
      ],
      "metadata": {
        "id": "BLfmMUhTenA4",
        "outputId": "52a05566-62b9-49f8-9854-b0b1fb0ef579",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "execution_count": 11,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Epoch 1\n",
            "-------------------------------\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "100%|██████████| 317/317 [11:49<00:00,  2.24s/it]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Train Loss: 0.9620, Train Acc: 0.5693\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "100%|██████████| 80/80 [02:00<00:00,  1.51s/it]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Test Error: \n",
            " Accuracy: 59.0%, Avg loss: 0.946273 \n",
            "\n",
            "Epoch 2\n",
            "-------------------------------\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "100%|██████████| 317/317 [11:16<00:00,  2.13s/it]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Train Loss: 0.8751, Train Acc: 0.6673\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "100%|██████████| 80/80 [01:57<00:00,  1.46s/it]"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Test Error: \n",
            " Accuracy: 59.1%, Avg loss: 0.944894 \n",
            "\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "size = len(clip_testloader.dataset)\n",
        "num_batches = len(clip_testloader)\n",
        "clip_model.eval()\n",
        "cat_classifier.eval()\n",
        "y_true, y_pred = [], []\n",
        "with torch.no_grad():\n",
        "    for data in tqdm(clip_testloader): \n",
        "        text_image_embed = clip_model(data[0].to(device), \n",
        "                      attention_mask=data[1].to(device),\n",
        "                      pixel_values = data[2].to(device))\n",
        "        text_feature = text_image_embed.text_embeds\n",
        "        image_feature = text_image_embed.image_embeds\n",
        "        text_image_feature = torch.cat((text_feature,image_feature),1)\n",
        "        pred = cat_classifier(text_image_feature)\n",
        "        labels = data[3].to(device)\n",
        "        y_true.extend(labels.tolist())\n",
        "        y_pred.extend(pred.argmax(1).tolist())"
      ],
      "metadata": {
        "id": "NPexfmpQuwuQ",
        "outputId": "ca4a107b-bfe8-41b9-acd2-f9ea1ca3dd3a",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "execution_count": 14,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "100%|██████████| 80/80 [02:18<00:00,  1.73s/it]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# confusion matrix\n",
        "cm = sns.heatmap(confusion_matrix(y_true, y_pred), annot=True, fmt='d', cmap='Blues', xticklabels=['neutral', 'negative', 'positive'], yticklabels=['neutral', 'negative', 'positive'])\n",
        "cm.set_xlabel('Predicted')\n",
        "cm.set_ylabel('True')\n",
        "plt.show()\n",
        "# classification report\n",
        "print('\\n\\n')\n",
        "print(classification_report(y_true, y_pred, target_names=['neutral', 'negative', 'positive']))"
      ],
      "metadata": {
        "id": "CasU5B6NvdTg",
        "outputId": "6d0ff505-faf5-49e0-d4ec-6853b81a24c5",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 505
        }
      },
      "execution_count": 15,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 432x288 with 2 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {
            "needs_background": "light"
          }
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "\n",
            "\n",
            "\n",
            "              precision    recall  f1-score   support\n",
            "\n",
            "     neutral       0.46      0.50      0.48      1298\n",
            "    negative       0.67      0.68      0.68      2163\n",
            "    positive       0.61      0.56      0.58      1606\n",
            "\n",
            "    accuracy                           0.60      5067\n",
            "   macro avg       0.58      0.58      0.58      5067\n",
            "weighted avg       0.60      0.60      0.60      5067\n",
            "\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Using ViT as backbone for images and BERT as backbone for text\n",
        "We concatenated the head of each backbone and used max pooling on the features obtained from each backbone and trained an MLP on top of it\n"
      ],
      "metadata": {
        "id": "o3DBoayLHKmR"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# define a image_encoder model using resnet50 on timm\n",
        "class ViTEncoder(nn.Module):\n",
        "    def __init__(self, is_trainable=True):\n",
        "        super(ViTEncoder, self).__init__()\n",
        "        self.vit = timm.create_model('vit_base_patch16_224', pretrained=True)\n",
        "        self.vit.head = nn.Identity()\n",
        "        if not is_trainable:\n",
        "            for param in self.vit.parameters():\n",
        "                param.requires_grad = False\n",
        "\n",
        "    def forward(self, x):\n",
        "        return self.vit(x)"
      ],
      "metadata": {
        "id": "Bp4L2IQxHb5F"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "image_transform = torchvision.transforms.Compose([\n",
        "    torchvision.transforms.ToPILImage(),\n",
        "    torchvision.transforms.Resize((224, 224)),\n",
        "    torchvision.transforms.ToTensor(),\n",
        "    torchvision.transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225])\n",
        "    ])\n",
        "\n",
        "# change the image transform of the dataset\n",
        "MSCTD_train.image_transform = image_transform\n",
        "MSCTD_dev.image_transform = image_transform\n",
        "MSCTD_test.image_transform = image_transform\n",
        "\n",
        "# define image_encoder and text_encoder\n",
        "image_encoder = ViTEncoder(is_trainable=True).to(device)\n",
        "text_encoder = TextEncoder(is_trainable=True).to(device)\n",
        "\n",
        "# define the classifier\n",
        "classifier = MLPClassifier(768, 512, 3).to(device)\n",
        "\n",
        "# define the optimizer\n",
        "optimizer = optim.Adam(list(text_encoder.parameters()) + list(classifier.parameters()) + list(image_encoder.parameters()), lr=1e-5)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "LPv1TJfyHjFm",
        "outputId": "7ab0b805-75df-4c8f-c659-6c72f628ee5b"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "Some weights of the model checkpoint at bert-base-uncased were not used when initializing BertModel: ['cls.seq_relationship.weight', 'cls.predictions.transform.dense.weight', 'cls.predictions.transform.LayerNorm.weight', 'cls.predictions.transform.LayerNorm.bias', 'cls.predictions.bias', 'cls.seq_relationship.bias', 'cls.predictions.decoder.weight', 'cls.predictions.transform.dense.bias']\n",
            "- This IS expected if you are initializing BertModel from the checkpoint of a model trained on another task or with another architecture (e.g. initializing a BertForSequenceClassification model from a BertForPreTraining model).\n",
            "- This IS NOT expected if you are initializing BertModel from the checkpoint of a model that you expect to be exactly identical (initializing a BertForSequenceClassification model from a BertForSequenceClassification model).\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "train_losses = []\n",
        "dev_losses = []\n",
        "train_accs = []\n",
        "dev_accs = []\n",
        "num_epochs = 3\n",
        "for epoch in range(num_epochs):\n",
        "    # train\n",
        "    train_loss = 0\n",
        "    train_acc = 0\n",
        "    total_samples = 0\n",
        "    for images, texts, labels in tqdm(train_dataloader_tokenized):\n",
        "        images = images.to(device)\n",
        "        labels = labels.to(device)\n",
        "        texts = texts.to(device)\n",
        "        # get the image and text embeddings\n",
        "        image_embeddings = image_encoder(images)\n",
        "        text_embeddings = text_encoder(texts)\n",
        "        # concatenate the image and text embeddings\n",
        "        embeddings = torch.cat((image_embeddings.unsqueeze(1), text_embeddings.unsqueeze(1)), dim=1)\n",
        "        embeddings = torch.max(embeddings, dim=1)[0]\n",
        "        # get the predictions\n",
        "        predictions = classifier(embeddings)\n",
        "        # calculate the loss\n",
        "        loss = F.cross_entropy(predictions, labels)\n",
        "        # calculate the accuracy\n",
        "        acc = (predictions.argmax(dim=1) == labels).float().sum()\n",
        "        # backpropagation\n",
        "        optimizer.zero_grad()\n",
        "        loss.backward()\n",
        "        optimizer.step()\n",
        "        # update the loss and accuracy\n",
        "        train_loss += loss.item()\n",
        "        train_acc += acc.item()\n",
        "        total_samples += labels.size(0)\n",
        "    # calculate the average loss and accuracy\n",
        "    train_loss /= len(train_dataloader_tokenized)\n",
        "    train_acc /= total_samples\n",
        "    # save the loss and accuracy\n",
        "    train_losses.append(train_loss)\n",
        "    train_accs.append(train_acc)\n",
        "    # evaluate\n",
        "    dev_loss = 0\n",
        "    dev_acc = 0\n",
        "    total_samples = 0\n",
        "    with torch.no_grad():\n",
        "        for images, texts, labels in tqdm(dev_dataloader_tokenized):\n",
        "            images = images.to(device)\n",
        "            labels = labels.to(device)\n",
        "            texts = texts.to(device)\n",
        "            # get the image and text embeddings\n",
        "            image_embeddings = image_encoder(images)\n",
        "            text_embeddings = text_encoder(texts)\n",
        "            # concatenate the image and text embeddings\n",
        "            embeddings = torch.cat((image_embeddings.unsqueeze(1), text_embeddings.unsqueeze(1)), dim=1)\n",
        "            embeddings = torch.max(embeddings, dim=1)[0]\n",
        "            # get the predictions\n",
        "            predictions = classifier(embeddings)\n",
        "            # calculate the loss\n",
        "            loss = F.cross_entropy(predictions, labels)\n",
        "            # calculate the accuracy\n",
        "            acc = (predictions.argmax(dim=1) == labels).float().sum()\n",
        "            # update the loss and accuracy\n",
        "            dev_loss += loss.item()\n",
        "            dev_acc += acc.item()\n",
        "            total_samples += labels.size(0)\n",
        "    # calculate the average loss and accuracy\n",
        "    dev_loss /= len(dev_dataloader_tokenized)\n",
        "    dev_acc /= total_samples\n",
        "    # save the loss and accuracy\n",
        "    dev_losses.append(dev_loss)\n",
        "    dev_accs.append(dev_acc)\n",
        "    # print the loss and accuracy\n",
        "    print(f'Epoch {epoch+1}/{num_epochs}, Train Loss: {train_loss:.4f}, Train Acc: {train_acc:.4f}, Dev Loss: {dev_loss:.4f}, Dev Acc: {dev_acc:.4f}')"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "IHe5QQk7HoS1",
        "outputId": "90fd829b-8fb5-4cf0-c379-1845bf1b0bde"
      },
      "execution_count": null,
      "outputs": [
        {
          "metadata": {
            "tags": null
          },
          "name": "stderr",
          "output_type": "stream",
          "text": [
            "100%|██████████| 633/633 [17:14<00:00,  1.63s/it]\n",
            "100%|██████████| 159/159 [01:57<00:00,  1.36it/s]\n"
          ]
        },
        {
          "metadata": {
            "tags": null
          },
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Epoch 1/3, Train Loss: 0.9568, Train Acc: 0.5781, Dev Loss: 0.9323, Dev Acc: 0.6022\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "100%|██████████| 633/633 [16:53<00:00,  1.60s/it]\n",
            "100%|██████████| 159/159 [01:56<00:00,  1.37it/s]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Epoch 2/3, Train Loss: 0.8608, Train Acc: 0.6844, Dev Loss: 0.9360, Dev Acc: 0.6030\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "100%|██████████| 633/633 [16:35<00:00,  1.57s/it]\n",
            "100%|██████████| 159/159 [01:55<00:00,  1.38it/s]"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Epoch 3/3, Train Loss: 0.8082, Train Acc: 0.7390, Dev Loss: 0.9398, Dev Acc: 0.6010\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# confusion matrix and classification report\n",
        "y_true = []\n",
        "y_pred = []\n",
        "with torch.no_grad():\n",
        "    for images, texts, labels in tqdm(test_dataloader_tokenized):\n",
        "        images = images.to(device)\n",
        "        labels = labels.to(device)\n",
        "        texts = texts.to(device)\n",
        "        # get the image and text embeddings\n",
        "        image_embeddings = image_encoder(images)\n",
        "        text_embeddings = text_encoder(texts)\n",
        "        # concatenate the image and text embeddings\n",
        "        embeddings = torch.cat((image_embeddings.unsqueeze(1), text_embeddings.unsqueeze(1)), dim=1)\n",
        "        embeddings = torch.max(embeddings, dim=1)[0]\n",
        "        # get the predictions\n",
        "        predictions = classifier(embeddings)\n",
        "        # get the labels\n",
        "        y_true.extend(labels.tolist())\n",
        "        y_pred.extend(predictions.argmax(dim=1).tolist())"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Eo3RL2pAH6tU",
        "outputId": "d2d458f6-9014-4bff-988c-f9352c91a2d9"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "100%|██████████| 159/159 [02:04<00:00,  1.28it/s]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# confusion matrix\n",
        "cm = sns.heatmap(confusion_matrix(y_true, y_pred), annot=True, fmt='d', cmap='Blues', xticklabels=['neutral', 'negative', 'positive'], yticklabels=['neutral', 'negative', 'positive'])\n",
        "cm.set_xlabel('Predicted')\n",
        "cm.set_ylabel('True')\n",
        "plt.show()\n",
        "# classification report\n",
        "print('\\n\\n')\n",
        "print(classification_report(y_true, y_pred, target_names=['neutral', 'negative', 'positive']))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 519
        },
        "id": "xy_OuYWOH-0N",
        "outputId": "08239c54-dd12-4966-bac1-14dc9c46eb69"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 432x288 with 2 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {
            "needs_background": "light"
          }
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "\n",
            "\n",
            "\n",
            "              precision    recall  f1-score   support\n",
            "\n",
            "     neutral       0.46      0.54      0.50      1298\n",
            "    negative       0.72      0.66      0.69      2163\n",
            "    positive       0.61      0.60      0.60      1606\n",
            "\n",
            "    accuracy                           0.61      5067\n",
            "   macro avg       0.60      0.60      0.60      5067\n",
            "weighted avg       0.62      0.61      0.61      5067\n",
            "\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Part 2\n",
        "We followed these steps:\n",
        "- Train Image and Text backbones on original dataset\n",
        "- Downloaded and preprocessed COCO dataset for extracting peoples categories\n",
        "- Train the Image FC layer on pseudo labels generated from Text backbone on COCO\n",
        "- Reported classification report and confusion matrix"
      ],
      "metadata": {
        "id": "Hs5Sw_zR82_D"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Image and Text Backbones from Phase 1 and 2\n",
        "We chose Resnet50 for image backbone and BERT for text backbone"
      ],
      "metadata": {
        "id": "F6x0jVoAozyM"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "tokenizer = BertTokenizer.from_pretrained('bert-base-uncased')\n",
        "\n",
        "# tokenize datasets\n",
        "max_length = 25\n",
        "tokenized_train = TokenizedDataset(MSCTD_train, tokenizer, max_length)\n",
        "tokenized_dev = TokenizedDataset(MSCTD_dev, tokenizer, max_length)\n",
        "tokenized_test = TokenizedDataset(MSCTD_test, tokenizer, max_length)\n",
        "\n",
        "# dataloader\n",
        "train_dataloader_tokenized = DataLoader(tokenized_train, batch_size=32, shuffle=True)\n",
        "dev_dataloader_tokenized = DataLoader(tokenized_dev, batch_size=32, shuffle=True)\n",
        "test_dataloader_tokenized = DataLoader(tokenized_test, batch_size=32, shuffle=True)\n",
        "\n",
        "# define device\n",
        "device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')"
      ],
      "metadata": {
        "id": "bsIEyDGEaaiZ"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# define a new class for image encoder that gets image encoder as input and adds a linear layer on top of it\n",
        "class ImageEncoderWithLinearLayer(nn.Module):\n",
        "    def __init__(self, is_trainable=True):\n",
        "        super(ImageEncoderWithLinearLayer, self).__init__()\n",
        "        self.image_encoder = ImageEncoder(is_trainable=True)\n",
        "        self.relu = nn.ReLU()\n",
        "        self.linear_layer = nn.Linear(2048, 3)\n",
        "\n",
        "    def forward(self, x):\n",
        "        x = self.image_encoder(x)\n",
        "        x = self.relu(x)\n",
        "        x = self.linear_layer(x)\n",
        "        return x\n",
        "\n",
        "# define a new class for text encoder that gets text encoder as input and adds a linear layer on top of it\n",
        "class TextEncoderWithLinearLayer(nn.Module):\n",
        "    def __init__(self, is_trainable=True):\n",
        "        super(TextEncoderWithLinearLayer, self).__init__()\n",
        "        self.text_encoder = TextEncoder(is_trainable=True)\n",
        "        self.linear_layer = nn.Linear(768, 3)\n",
        "\n",
        "    def forward(self, x):\n",
        "        x = self.text_encoder(x)\n",
        "        x = self.linear_layer(x)\n",
        "        return x\n",
        "\n",
        "image_encoder = ImageEncoderWithLinearLayer().to(device)\n",
        "image_optimizer = optim.Adam(image_encoder.parameters(), lr=1e-5)\n",
        "text_encoder = TextEncoderWithLinearLayer().to(device)\n",
        "text_optimizer = optim.Adam(text_encoder.parameters(), lr=1e-5)"
      ],
      "metadata": {
        "id": "2CqPukX_afdG",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 143,
          "referenced_widgets": [
            "37208c6aada94765bd76443b137f2427",
            "2b0b6dae110b48c4820fb23e085b7596",
            "10fd80efdfb04010ae7aa33471c9c263",
            "64262e050f9c49bcbe9422fcb211345b",
            "47807478c4f94784ab13232feaa93d91",
            "795068a3f1b545eba12cefdcace57049",
            "21230213567b4d9187383f824294767a",
            "682e45aa70f74e9f832b872b8cd485ef",
            "dda11bff89bf44faa42584f756fcc8d0",
            "8573e0fc886f46339db904fedc9992b9",
            "2cfeb66a45484db6949d8be7792080d2"
          ]
        },
        "outputId": "5a0851dd-d868-4a46-e27a-6c90c24ff893"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "Downloading: \"https://github.com/rwightman/pytorch-image-models/releases/download/v0.1-rsb-weights/resnet50_a1_0-14fe96d1.pth\" to /root/.cache/torch/hub/checkpoints/resnet50_a1_0-14fe96d1.pth\n"
          ]
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "Downloading (…)\"pytorch_model.bin\";:   0%|          | 0.00/440M [00:00<?, ?B/s]"
            ],
            "application/vnd.jupyter.widget-view+json": {
              "version_major": 2,
              "version_minor": 0,
              "model_id": "37208c6aada94765bd76443b137f2427"
            }
          },
          "metadata": {}
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "Some weights of the model checkpoint at bert-base-uncased were not used when initializing BertModel: ['cls.predictions.transform.dense.bias', 'cls.predictions.transform.dense.weight', 'cls.seq_relationship.bias', 'cls.seq_relationship.weight', 'cls.predictions.bias', 'cls.predictions.decoder.weight', 'cls.predictions.transform.LayerNorm.weight', 'cls.predictions.transform.LayerNorm.bias']\n",
            "- This IS expected if you are initializing BertModel from the checkpoint of a model trained on another task or with another architecture (e.g. initializing a BertForSequenceClassification model from a BertForPreTraining model).\n",
            "- This IS NOT expected if you are initializing BertModel from the checkpoint of a model that you expect to be exactly identical (initializing a BertForSequenceClassification model from a BertForSequenceClassification model).\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Training image backbone on MSCTD dataset\n"
      ],
      "metadata": {
        "id": "mNFWjtigSwTE"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "train_losses = []\n",
        "dev_losses = []\n",
        "train_accs = []\n",
        "dev_accs = []\n",
        "num_epochs = 3\n",
        "for epoch in range(num_epochs):\n",
        "    # train\n",
        "    train_loss = 0\n",
        "    train_acc = 0\n",
        "    total_samples = 0\n",
        "    for images, _, labels in tqdm(train_dataloader_tokenized):\n",
        "        images = images.to(device)\n",
        "        labels = labels.to(device)\n",
        "        # get the predictions\n",
        "        predictions = image_encoder(images)\n",
        "        # calculate the loss\n",
        "        loss = F.cross_entropy(predictions, labels)\n",
        "        # calculate the accuracy\n",
        "        acc = (predictions.argmax(dim=1) == labels).float().sum()\n",
        "        # backpropagation\n",
        "        image_optimizer.zero_grad()\n",
        "        loss.backward()\n",
        "        image_optimizer.step()\n",
        "        # update the loss and accuracy\n",
        "        train_loss += loss.item()\n",
        "        train_acc += acc.item()\n",
        "        total_samples += labels.size(0)\n",
        "    # calculate the average loss and accuracy\n",
        "    train_loss /= len(train_dataloader_tokenized)\n",
        "    train_acc /= total_samples\n",
        "    # save the loss and accuracy\n",
        "    train_losses.append(train_loss)\n",
        "    train_accs.append(train_acc)\n",
        "    # evaluate\n",
        "    dev_loss = 0\n",
        "    dev_acc = 0\n",
        "    total_samples = 0\n",
        "    with torch.no_grad():\n",
        "        for images, _, labels in tqdm(dev_dataloader_tokenized):\n",
        "            images = images.to(device)\n",
        "            labels = labels.to(device)\n",
        "            # get the predictions\n",
        "            predictions = image_encoder(images)\n",
        "            # calculate the loss\n",
        "            loss = F.cross_entropy(predictions, labels)\n",
        "            # calculate the accuracy\n",
        "            acc = (predictions.argmax(dim=1) == labels).float().sum()\n",
        "            # update the loss and accuracy\n",
        "            dev_loss += loss.item()\n",
        "            dev_acc += acc.item()\n",
        "            total_samples += labels.size(0)\n",
        "    # calculate the average loss and accuracy\n",
        "    dev_loss /= len(dev_dataloader_tokenized)\n",
        "    dev_acc /= total_samples\n",
        "    # save the loss and accuracy\n",
        "    dev_losses.append(dev_loss)\n",
        "    dev_accs.append(dev_acc)\n",
        "    # print the loss and accuracy\n",
        "    print(f'Epoch {epoch+1}/{num_epochs}, Train Loss: {train_loss:.4f}, Train Acc: {train_acc:.4f}, Dev Loss: {dev_loss:.4f}, Dev Acc: {dev_acc:.4f}')"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "zSs1X5SGQx-c",
        "outputId": "9f3d20ab-b212-4167-ed4a-d2d7d69f6441"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "100%|██████████| 633/633 [08:27<00:00,  1.25it/s]\n",
            "100%|██████████| 159/159 [01:19<00:00,  2.00it/s]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Epoch 1/3, Train Loss: 1.0910, Train Acc: 0.3743, Dev Loss: 1.0939, Dev Acc: 0.3731\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "100%|██████████| 633/633 [07:50<00:00,  1.34it/s]\n",
            "100%|██████████| 159/159 [01:14<00:00,  2.12it/s]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Epoch 2/3, Train Loss: 1.0850, Train Acc: 0.3924, Dev Loss: 1.0943, Dev Acc: 0.3658\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "100%|██████████| 633/633 [07:32<00:00,  1.40it/s]\n",
            "100%|██████████| 159/159 [01:12<00:00,  2.21it/s]"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Epoch 3/3, Train Loss: 1.0816, Train Acc: 0.4008, Dev Loss: 1.0940, Dev Acc: 0.3743\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "torch.save(image_encoder, 'image_backbone.pth')"
      ],
      "metadata": {
        "id": "3J20teELYL4R"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Training text backbone on MSCTD dataset"
      ],
      "metadata": {
        "id": "Y53xHFmaTN0r"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "train_losses = []\n",
        "dev_losses = []\n",
        "train_accs = []\n",
        "dev_accs = []\n",
        "num_epochs = 2\n",
        "for epoch in range(num_epochs):\n",
        "    # train\n",
        "    train_loss = 0\n",
        "    train_acc = 0\n",
        "    total_samples = 0\n",
        "    for ـ, texts, labels in tqdm(train_dataloader_tokenized):\n",
        "        texts = texts.to(device)\n",
        "        labels = labels.to(device)\n",
        "        # get the predictions\n",
        "        predictions = text_encoder(texts)\n",
        "        # calculate the loss\n",
        "        loss = F.cross_entropy(predictions, labels)\n",
        "        # calculate the accuracy\n",
        "        acc = (predictions.argmax(dim=1) == labels).float().sum()\n",
        "        # backpropagation\n",
        "        text_optimizer.zero_grad()\n",
        "        loss.backward()\n",
        "        text_optimizer.step()\n",
        "        # update the loss and accuracy\n",
        "        train_loss += loss.item()\n",
        "        train_acc += acc.item()\n",
        "        total_samples += labels.size(0)\n",
        "    # calculate the average loss and accuracy\n",
        "    train_loss /= len(train_dataloader_tokenized)\n",
        "    train_acc /= total_samples\n",
        "    # save the loss and accuracy\n",
        "    train_losses.append(train_loss)\n",
        "    train_accs.append(train_acc)\n",
        "    # evaluate\n",
        "    dev_loss = 0\n",
        "    dev_acc = 0\n",
        "    total_samples = 0\n",
        "    with torch.no_grad():\n",
        "        for _, texts, labels in tqdm(dev_dataloader_tokenized):\n",
        "            texts = texts.to(device)\n",
        "            labels = labels.to(device)\n",
        "            # get the predictions\n",
        "            predictions = text_encoder(texts)\n",
        "            # calculate the loss\n",
        "            loss = F.cross_entropy(predictions, labels)\n",
        "            # calculate the accuracy\n",
        "            acc = (predictions.argmax(dim=1) == labels).float().sum()\n",
        "            # update the loss and accuracy\n",
        "            dev_loss += loss.item()\n",
        "            dev_acc += acc.item()\n",
        "            total_samples += labels.size(0)\n",
        "    # calculate the average loss and accuracy\n",
        "    dev_loss /= len(dev_dataloader_tokenized)\n",
        "    dev_acc /= total_samples\n",
        "    # save the loss and accuracy\n",
        "    dev_losses.append(dev_loss)\n",
        "    dev_accs.append(dev_acc)\n",
        "    # print the loss and accuracy\n",
        "    print(f'Epoch {epoch+1}/{num_epochs}, Train Loss: {train_loss:.4f}, Train Acc: {train_acc:.4f}, Dev Loss: {dev_loss:.4f}, Dev Acc: {dev_acc:.4f}')"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "1227-d69RxSf",
        "outputId": "a5433a2c-72cd-4100-880c-b3fc37f15335"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "100%|██████████| 633/633 [05:46<00:00,  1.82it/s]\n",
            "100%|██████████| 159/159 [01:06<00:00,  2.40it/s]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Epoch 1/2, Train Loss: 0.8711, Train Acc: 0.5996, Dev Loss: 0.8630, Dev Acc: 0.6087\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "100%|██████████| 633/633 [05:48<00:00,  1.81it/s]\n",
            "100%|██████████| 159/159 [01:06<00:00,  2.40it/s]"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Epoch 2/2, Train Loss: 0.6810, Train Acc: 0.7133, Dev Loss: 0.9410, Dev Acc: 0.5951\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "torch.save(text_encoder, 'text_backbone.pth')"
      ],
      "metadata": {
        "id": "mwXLtcDtYlfa"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Weakly Supervised Learning on COCO\n",
        "We chose COCO dataset for this part and selected the samples that are under peoples category and chose only the first caption and then selected a fraction of this dataset. We then followed the same preprocessing steps on image and caption as we did for the MSCTD dataset"
      ],
      "metadata": {
        "id": "7eCyonr1foXO"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Downloading and preprocessing COCO\n"
      ],
      "metadata": {
        "id": "NZJJiyVFpd5V"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "!wget http://images.cocodataset.org/annotations/annotations_trainval2014.zip\n",
        "!unzip -q annotations_trainval2014.zip\n",
        "!wget http://images.cocodataset.org/zips/train2014.zip\n",
        "!unzip -q train2014.zip\n",
        "!rm -f train2014.zip\n",
        "!rm -f annotations_trainval2014.zip"
      ],
      "metadata": {
        "id": "inECcG-KFkMz",
        "outputId": "f276651c-560c-4b8e-95cd-17302baf90a8",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "--2023-02-11 16:54:44--  http://images.cocodataset.org/annotations/annotations_trainval2014.zip\n",
            "Resolving images.cocodataset.org (images.cocodataset.org)... 52.216.32.33, 3.5.17.132, 54.231.233.9, ...\n",
            "Connecting to images.cocodataset.org (images.cocodataset.org)|52.216.32.33|:80... connected.\n",
            "HTTP request sent, awaiting response... 200 OK\n",
            "Length: 252872794 (241M) [application/zip]\n",
            "Saving to: ‘annotations_trainval2014.zip’\n",
            "\n",
            "annotations_trainva 100%[===================>] 241.16M  44.7MB/s    in 5.8s    \n",
            "\n",
            "2023-02-11 16:54:50 (41.6 MB/s) - ‘annotations_trainval2014.zip’ saved [252872794/252872794]\n",
            "\n",
            "--2023-02-11 16:54:59--  http://images.cocodataset.org/zips/train2014.zip\n",
            "Resolving images.cocodataset.org (images.cocodataset.org)... 54.231.233.9, 3.5.6.125, 54.231.129.105, ...\n",
            "Connecting to images.cocodataset.org (images.cocodataset.org)|54.231.233.9|:80... connected.\n",
            "HTTP request sent, awaiting response... 200 OK\n",
            "Length: 13510573713 (13G) [application/zip]\n",
            "Saving to: ‘train2014.zip’\n",
            "\n",
            "train2014.zip       100%[===================>]  12.58G  45.6MB/s    in 4m 48s  \n",
            "\n",
            "2023-02-11 16:59:47 (44.7 MB/s) - ‘train2014.zip’ saved [13510573713/13510573713]\n",
            "\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "class COCOPeopleDataset(Dataset):\n",
        "    def __init__(self, annFile, captions_path, transforms=None):\n",
        "        self.coco = COCO(annFile)\n",
        "        self.coco_caps = COCO(captions_path)\n",
        "        self.imgIds = self.coco.getImgIds(catIds=self.coco.getCatIds(catNms=['person']))\n",
        "        self.transforms = transforms\n",
        "\n",
        "        self.text = []\n",
        "        for idx in range(len(self.imgIds)):\n",
        "            img = self.coco.loadImgs(self.imgIds[idx])[0]\n",
        "            annIds = self.coco_caps.getAnnIds(imgIds=img['id'])\n",
        "            anns = self.coco_caps.loadAnns(annIds)\n",
        "            self.text.append(anns[0]['caption'])\n",
        "\n",
        "    def __len__(self):\n",
        "        return len(self.imgIds)\n",
        "\n",
        "    def __getitem__(self, idx):\n",
        "        img = self.coco.loadImgs(self.imgIds[idx])[0]\n",
        "        path = os.path.join('train2014/', img['file_name'])\n",
        "        image = cv2.imread(path)\n",
        "        image = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)\n",
        "        image = image.astype(np.float32) / 255.0\n",
        "        caption = self.text[idx]\n",
        "\n",
        "        if self.transforms is not None:\n",
        "            image = self.transforms(image)\n",
        "\n",
        "        return image, caption\n",
        "\n",
        "\n",
        "# Apply desired transformations\n",
        "image_transform = transforms.Compose([transforms.ToTensor(), \n",
        "                                      transforms.Resize((224, 224)), \n",
        "                                      transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225])])\n",
        "\n",
        "# Create the dataset\n",
        "coco_dataset = COCOPeopleDataset(annFile='/content/annotations/instances_train2014.json',captions_path='/content/annotations/captions_train2014.json', transforms=image_transform)\n",
        "     "
      ],
      "metadata": {
        "id": "eOAtSCN2M5vK",
        "outputId": "d1691285-91d3-4d9b-881c-10f8f2893551",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "loading annotations into memory...\n",
            "Done (t=14.33s)\n",
            "creating index...\n",
            "index created!\n",
            "loading annotations into memory...\n",
            "Done (t=0.96s)\n",
            "creating index...\n",
            "index created!\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "def get_wordnet_pos(word):\n",
        "    \"\"\"Map POS tag to first character used by WordNetLemmatizer\"\"\"\n",
        "    tag = nltk.pos_tag([word])[0][1][0].upper()\n",
        "    tag_dict = {\"J\": wordnet.ADJ,\n",
        "                \"N\": wordnet.NOUN,\n",
        "                \"V\": wordnet.VERB,\n",
        "                \"R\": wordnet.ADV}\n",
        "\n",
        "    return tag_dict.get(tag, wordnet.NOUN)\n",
        "\n",
        "def text_preprocessor(dataset):\n",
        "      # preprocess text\n",
        "      dataset.text = [preprocess_text(text) for text in dataset.text]\n",
        "\n",
        "def preprocess_text(text):\n",
        "      # Replace contractions with original text\n",
        "  text = re.sub(r'(\\b[Aa]in\\'t\\b)', \"am not\", text)\n",
        "  text = re.sub(r'(\\b[Hh]a\\'t\\b)', \"has\", text)\n",
        "  text = re.sub(r'(\\b[Ii]\\'m\\b)', \"i am\", text)\n",
        "  text = re.sub(r'(\\b\\'s\\b)', \" is\", text)\n",
        "  text = re.sub(r'(\\b\\'re\\b)', \" are\", text)\n",
        "  text = re.sub(r'(\\b\\'ve\\b)', \" have\", text)\n",
        "  text = re.sub(r'(\\b\\'d\\b)', \" would\", text)\n",
        "  text = re.sub(r'(\\b\\'ll\\b)', \" will\", text)\n",
        "  text = re.sub(r'(\\b[Ss]han\\'t\\b)', \"shall not\", text)\n",
        "  text = re.sub(r'(\\b[Ww]on\\'t\\b)', \"will not\", text)\n",
        "  text = re.sub(r'(\\b[Ww]ouldn\\'t\\b)', \"would not\", text)\n",
        "  text = re.sub(r'(\\b[Dd]on\\'t\\b)', \"do not\", text)\n",
        "  text = re.sub(r'(\\b[Cc]an\\'t\\b)', \"can not\", text)\n",
        "  text = re.sub(r'(\\b[Ii]s\\'nt\\b)', \"is not\", text)\n",
        "  text = re.sub(r'(\\b[Ww]eren\\'t\\b)', \"were not\", text)\n",
        "  text = re.sub(r'(\\b[Hh]aven\\'t\\b)', \"have not\", text)\n",
        "  text = re.sub(r'(\\b[Hh]adn\\'t\\b)', \"had not\", text)\n",
        "  text = re.sub(r'(\\b[Hh]asn\\'t\\b)', \"has not\", text)\n",
        "  text = re.sub(r'(\\b[Hh]adn\\'t\\b)', \"had not\", text)\n",
        "  text = re.sub(r'(\\b[Dd]idn\\'t\\b)', \"did not\", text)\n",
        "\n",
        "  # Remove punctuation\n",
        "  text = text.translate(str.maketrans(\"\", \"\", string.punctuation))\n",
        "\n",
        "  # Convert to lowercase\n",
        "  text = text.lower()\n",
        "\n",
        "  # Tokenize text\n",
        "  tokens = word_tokenize(text)\n",
        "\n",
        "  # Remove stop words\n",
        "  # tokens = [token for token in tokens if token not in stop_words]\n",
        "  # Remove numbers\n",
        "  tokens = [token for token in tokens if token.isalpha()]\n",
        "\n",
        "  # Lemmatize tokens\n",
        "  tokens = [lemmatizer.lemmatize(token, get_wordnet_pos(token)) for token in tokens]\n",
        "\n",
        "  return ' '.join(tokens)\n",
        "\n",
        "# Test the TextPreprocessor\n",
        "text_preprocessor(coco_dataset)"
      ],
      "metadata": {
        "id": "QcgNXxIERhHa"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# define a class that get a dataset and return tokenized dataset\n",
        "class TokenizedCoco(Dataset):\n",
        "    def __init__(self, dataset, tokenizer, max_length=80):\n",
        "        self.dataset = dataset\n",
        "        self.tokenizer = tokenizer\n",
        "        self.max_length = max_length\n",
        "    def __getitem__(self, index):\n",
        "        image, text = self.dataset[index]\n",
        "        text = self.tokenizer.encode_plus(text, add_special_tokens=True, max_length=self.max_length, \n",
        "                                          padding='max_length', truncation=True, return_tensors='pt')\n",
        "        return image, text\n",
        "    def __len__(self):\n",
        "        return len(self.dataset)"
      ],
      "metadata": {
        "id": "81RtEIQSeZ60"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Weakly supervised learning "
      ],
      "metadata": {
        "id": "G487DKPUqO8W"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "image_encoder = torch.load('image_backbone.pth')\n",
        "for param in image_encoder.parameters():\n",
        "    param.requires_grad = False\n",
        "for param in image_encoder.linear_layer.parameters():\n",
        "    param.requires_grad = True"
      ],
      "metadata": {
        "id": "wvWc3xZSwun9"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# evaluate on original Dataset\n",
        "test_loss = 0\n",
        "test_acc = 0\n",
        "total_samples = 0\n",
        "y_true = []\n",
        "y_pred = []\n",
        "with torch.no_grad():\n",
        "    for images, _, labels in tqdm(test_dataloader_tokenized):\n",
        "        images = images.to(device)\n",
        "        labels = labels.to(device)\n",
        "        # get the image embeddings\n",
        "        predictions = image_encoder(images)\n",
        "        # calculate the loss\n",
        "        loss = F.cross_entropy(predictions, labels)\n",
        "        # calculate the accuracy\n",
        "        acc = (predictions.argmax(dim=1) == labels).float().sum()\n",
        "        # update the loss and accuracy\n",
        "        test_loss += loss.item()\n",
        "        test_acc += acc.item()\n",
        "        total_samples += labels.size(0)\n",
        "        y_true.extend(labels.tolist())\n",
        "        y_pred.extend(predictions.argmax(dim=1).tolist())\n",
        "# calculate the average loss and accuracy\n",
        "test_loss /= len(test_dataloader_tokenized)\n",
        "test_acc /= total_samples\n",
        "print(f\"Test Accuracy before domain adaptation: {test_acc}\")"
      ],
      "metadata": {
        "id": "DFppfawkxylg",
        "outputId": "c8dbe35a-b64d-4dfc-8a72-88e95e8b03ce",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "100%|██████████| 159/159 [01:26<00:00,  1.83it/s]"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Test Accuracy before domain adaptation: 0.40911782119597395\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "coco_dataset_tokenized = TokenizedCoco(coco_dataset, tokenizer, max_length=25)\n",
        "coco_dataset_tokenized, _ = torch.utils.data.random_split(coco_dataset_tokenized, [0.2, 0.8])\n",
        "coco_dataloader_tokenized = DataLoader(coco_dataset_tokenized, batch_size=32, shuffle=True)\n",
        "image_optimizer = optim.Adam(image_encoder.parameters(), lr=1e-5)"
      ],
      "metadata": {
        "id": "qeiNMRnSU1sj"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "train_losses = []\n",
        "dev_losses = []\n",
        "train_accs = []\n",
        "dev_accs = []\n",
        "num_epochs = 2\n",
        "for epoch in range(num_epochs):\n",
        "    # train\n",
        "    train_loss = 0\n",
        "    train_acc = 0\n",
        "    total_samples = 0\n",
        "    for images, texts in tqdm(coco_dataloader_tokenized):\n",
        "        images = images.to(device)\n",
        "        texts = texts.to(device)\n",
        "        labels = labels.to(device)\n",
        "        # get the pseudo labels from text encoder\n",
        "        labels = text_encoder(texts)\n",
        "        # get predictions from image encoder\n",
        "        predictions = image_encoder(images)\n",
        "        # calculate the loss\n",
        "        loss = F.cross_entropy(predictions, labels)\n",
        "        # calculate the accuracy\n",
        "        acc = (predictions.argmax(dim=1) == labels.argmax(dim=1)).float().sum()\n",
        "        # backpropagation\n",
        "        image_optimizer.zero_grad()\n",
        "        loss.backward()\n",
        "        image_optimizer.step()\n",
        "        # update the loss and accuracy\n",
        "        train_loss += loss.item()\n",
        "        train_acc += acc.item()\n",
        "        total_samples += labels.size(0)\n",
        "    # calculate the average loss and accuracy\n",
        "    train_loss /= len(train_dataloader_tokenized)\n",
        "    train_acc /= total_samples\n",
        "    # save the loss and accuracy\n",
        "    train_losses.append(train_loss)\n",
        "    train_accs.append(train_acc)\n",
        "    # print the loss and accuracy\n",
        "    print(f'Epoch {epoch+1}/{num_epochs}, Train Loss: {train_loss:.4f}, Train Acc: {train_acc:.4f}')"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "WQ7hS5CqWgYr",
        "outputId": "b9835941-efcf-4ae1-e932-c82fc814762c"
      },
      "execution_count": null,
      "outputs": [
        {
          "metadata": {
            "tags": null
          },
          "name": "stderr",
          "output_type": "stream",
          "text": [
            "100%|██████████| 283/283 [03:10<00:00,  1.49it/s]\n"
          ]
        },
        {
          "metadata": {
            "tags": null
          },
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Epoch 1/2, Train Loss: -0.5445, Train Acc: 0.7294\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "100%|██████████| 283/283 [02:33<00:00,  1.84it/s]"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Epoch 2/2, Train Loss: -0.9749, Train Acc: 0.8542\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# evaluate on original Dataset\n",
        "test_loss = 0\n",
        "test_acc = 0\n",
        "total_samples = 0\n",
        "y_true = []\n",
        "y_pred = []\n",
        "with torch.no_grad():\n",
        "    for images, _, labels in tqdm(test_dataloader_tokenized):\n",
        "        images = images.to(device)\n",
        "        labels = labels.to(device)\n",
        "        # get the image embeddings\n",
        "        predictions = image_encoder(images)\n",
        "        # calculate the loss\n",
        "        loss = F.cross_entropy(predictions, labels)\n",
        "        # calculate the accuracy\n",
        "        acc = (predictions.argmax(dim=1) == labels).float().sum()\n",
        "        # update the loss and accuracy\n",
        "        test_loss += loss.item()\n",
        "        test_acc += acc.item()\n",
        "        total_samples += labels.size(0)\n",
        "        y_true.extend(labels.tolist())\n",
        "        y_pred.extend(predictions.argmax(dim=1).tolist())\n",
        "# calculate the average loss and accuracy\n",
        "test_loss /= len(test_dataloader_tokenized)\n",
        "test_acc /= total_samples\n",
        "print(f\"Test Accuracy after domain adaptation: {test_acc}\")"
      ],
      "metadata": {
        "id": "t8a2OZQaoMkj",
        "outputId": "0d47896f-0964-4f45-a74a-b1b02164deb9",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "100%|██████████| 159/159 [01:37<00:00,  1.64it/s]"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Test Accuracy after domain adaptation: 0.2561673574106967\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# confusion matrix\n",
        "cm = sns.heatmap(confusion_matrix(y_true, y_pred), annot=True, fmt='d', cmap='Blues', xticklabels=['neutral', 'negative', 'positive'], yticklabels=['neutral', 'negative', 'positive'])\n",
        "cm.set_xlabel('Predicted')\n",
        "cm.set_ylabel('True')\n",
        "plt.show()\n",
        "# classification report\n",
        "print('\\n\\n')\n",
        "print(classification_report(y_true, y_pred, target_names=['neutral', 'negative', 'positive']))"
      ],
      "metadata": {
        "id": "8tK1TKU3u4nX",
        "outputId": "cbf6d574-7d49-4b97-bce1-744b60a7e823",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 650
        }
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 432x288 with 2 Axes>"
            ],
            "image/png": "iVBORw0KGgoAAAANSUhEUgAAAXUAAAEGCAYAAACaSwWnAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjIsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+WH4yJAAAgAElEQVR4nO3debwWdd3/8df7nAOCuAAiRxRwAzdcwAW11NxyzyWX3LUssrD9rjS9szTLutW6/WkqFql37luSmRtqbpmiEouCoqBCcEgUcGM75/P7Y+bgJZ3lus655pyLOe+nj3mcme81M9+ZiT7X9/rMd76jiMDMzPKhqrMPwMzMysdB3cwsRxzUzcxyxEHdzCxHHNTNzHKkprMPoDmHXvOsu+Vk7M4zRnb2IZiVRY8a1N599BxxVtEx56MXr2h3fVlxS93MLEcqtqVuZtahlI82roO6mRlAVXVnH0FZOKibmQGoYtPkJXFQNzMDp1/MzHLFLXUzsxxxS93MLEfcUjczyxH3fjEzyxGnX8zMcsTpFzOzHHFL3cwsR3IS1PNxFmZm7VVdXfzUAkmDJD0q6SVJUyV9Ky3vK+khSa+mf/uk5ZJ0uaQZkiZJ2rFgX6el678q6bRiTsNB3cwMkpx6sVPLVgDfi4htgN2A0ZK2Ac4GxkfEUGB8ugxwMDA0nUYBVyWHo77A+cCuwEjg/MYvgpY4qJuZQZJ+KXZqQUTMjYgX0vn3gJeBjYAjgOvT1a4HjkznjwBuiMQzQG9JA4ADgYci4p2IeBd4CDiotdNwUDczg5Ja6pJGSZpQMI1qepfaBBgB/AOojYi56UfzgNp0fiPgrYLNZqdlzZW3yDdKzcygpBulETEGGNPi7qS1gDuBb0fEYhWkbSIiJGXydje31M3MoJw5dSR1IwnoN0bEXWlxXZpWIf07Py2fAwwq2HxgWtZceYsc1M3MIBkmoNipBUqa5L8HXo6Iywo+Ggc09mA5DbinoPzUtBfMbsCiNE3zAHCApD7pDdID0rIWOf1iZgbl7Kf+aeAUYLKkiWnZj4CLgdsknQG8ARyXfnYfcAgwA/gQ+CJARLwj6ULguXS9CyLindYqzySoS3oPaCpfJJJ00jpZ1Gtm1mZlGiYgIp4kiXVN2a+J9QMY3cy+xgJjS6k/k6AeEWtnsV8zs8zk5InSDkm/SOoP9Ghcjog3O6JeM7OiOai3TtLhwKXAhiR3ejcm6Yg/LMt6zcxKlpPx1LP+arqQ5DHZVyJiU5J80jMZ12lmVroydmnsTFkH9eURsQCoklQVEY8CO2dcp5lZ6co0TEBnyzqnvjB9qupx4EZJ84EPMq7TzKx0Fd4CL1bWXzlHkPS7/A5wP/Aa8LmM6zQzK5mSMV2KmipZZi11SdXAvRGxD9DAx6OTmZlVnEoP1sXKLKhHRL2kBknrRsSirOoxMysHVTmoF+N9kkdlH6Iglx4R38y43rL41mc2ZeTGvVn40XJG3z4FgC/tNoiRg3uzoiGYu3gJv3lsJh8sq6emSpy11yYM7deLBmDMU28wee57AHxm874cN2JDAnjnw2Vc8sjrLF6yovNObDX11BOP88uLL6KhvoGjjj6WM77S5Gin1g5d+RrnpaWedU79LuC/SW6UPp9OEzKus2wefuVtfnzf9E+UvTh7EV+/fTJn3TGFfy1awnEjBgBw4NbrAzD6jimcd+80vrz7YARUCUZ9emPOuXcaZ90xhZkLPuKwYbWrVmWtqK+v5+cXXcBvr/4dd4/7C/ffdy+vzZjR2YeVK139Guclp551UO8dEdcXTkCrr2OqFFPnvsd7q7SoX5y9mIZ0VJtpdR+wXq/uAAzu05N/zlkMwKIlK3h/2QqGrt8r+UcArFGTXOo1u1fzzofLOuwc8mLK5EkMGrQxAwcNolv37hx0yKE89uj4zj6sXOnq19hBvThNvSj19Izr7DCf3aofz7+V3C6YueBDdtu4D1WC2rW7M6RfL/qt1Z36huDKJ2bx22O34/9OHs7gPj14cNq/O/nIVz/z6+rYYMAGK5f719ZSV1fXiUeUP13+GquEqYJlNUrjCcCJwKaSxhV8tDbQ6tCRq4MvjBhAfUPw6KsLAHhw2r8Z1Lsn//v5Ycx/fxkv171PQwTVVeKQYf35xp1TmLd4KWd+emOOHb4ht774r04+AzMrVOkt8GJldaP0aWAu0I9k7JdG7wGTmtsofc/fKIBtTzqbwXseldHhtc/+W/Rjl437cO6901aWNQRc+/ePxym75IitmbNwCZuttyYA8xYvBeCJ19/h2OEDOvaAc6B/bS3z5s5buTy/ro7aWt+bKKeufo2rqir7SdFiZXIWEfFGRDwWEbtHxN8KphciotluHxExJiJ2joidKzWg7zRoXY4ePoAL7n+FpSsaVpavUVO1Mm8+fKN1qI/grYVLWPDBMgb37sk6PZLvzxEbrcNb737UKce+Ohu27Xa8+eYsZs9+i+XLlnH/fX/hM/vs29mHlStd/RrnJaee9SiNhS/L6A50Az5YXV6S8YP9Nme7AWuzTo8arj9pODdOmM2xIzakW7W46NAtAZg2/wOufGIW6/ao4cJDtyQCFnyQdFsEeOfD5dz0/Bx+dfjWrGgI5r+/lF8/OrMzT2u1VFNTwznn/pivjfoyDQ31HHnU0QwZMrSzDytXuvw1LmOsljQWOAyYHxHbpmW3Alumq/QGFkbEcEmbkIxe29jV7pmIODPdZifgOqAnyRuSvpW+VKP5ulv5vGzS9/YdAewWEWe3tv6h1zzbMQfWhd15xsjOPgSzsuhR0/6Q3O/0W4qOOW9fd3yL9Unai+Q5nRsag/oqn19K8i7SC9Kgfm8z6z0LfBP4B0lQvzwi/tpS3R2WRIrEn4ADO6pOM7NilTP9EhGP00ynkLSBexxwcyvHMwBYJyKeSVvnNwBHtlZ31umXzxcsVpEMu7skyzrNzNqilGECCjt1pMZExJgiN98TqIuIVwvKNpX0IrAYOC8ingA2AmYXrDM7LWtR1sMEFI7IuAKYRZKCMTOrKKXcAE0DeLFBfFUn8MlW+lxgcEQsSHPof5LU5rfDZRrUI+KLWe7fzKxcOqJXi6Qa4PPATo1lEbEUWJrOPy/pNWALYA4wsGDzgWlZizLNqUvaQtJ4SVPS5e0lnZdlnWZmbdFBXRr3B6ZFxMq0iqT106HKkbQZMBR4PSLmAosl7Zbm4U8F7mmtgqxvlF4LnAMsB4iIScDxGddpZlaycgZ1STcDfwe2lDRb0hnpR8fznzdI9wImSZoI3AGcGRGNN1m/DvwOmEHykqEWe75A9jn1NSPi2VUugsecNbPKU8bsS0Sc0Ez56U2U3Qnc2cz6E4D/6OrYkqyD+tuSNid9AEnSMSQ3BczMKkpehgnIOqiPJrlDvJWkOcBM4KSM6zQzK1mlP/5frKyD+hzgD8CjQF+SPpinARdkXK+ZWWnyEdMzD+r3AAuBFwCPNWtmFcst9eIMjIiDMq7DzKzd8hLUs74z8LSk7TKuw8ys3Tz0bnH2AE6XNJPkiSmRjO21fcb1mpmVpJSxXypZ1kH94Iz3b2ZWFpXeAi9W1mO/vJHl/s3MysVB3cwsR3IS0x3UzczALXUzs1yp8o1SM7P8yElD3UHdzAzcUjczyxW31M3MciQvN0rzMYCwmVk7ScVPre9LYyXNb3yVZ1r2E0lzJE1Mp0MKPjtH0gxJ0yUdWFB+UFo2Q9LZxZyHW+pmZpT9JRnXAVcAN6xS/uuIuKSwQNI2JK+5GwZsCDwsaYv04yuBzwKzgeckjYuIl1qq2EHdzIzy5tQj4nFJmxS5+hHALRGxFJgpaQYwMv1sRkS8nhyfbknXbTGoO/1iZkZpozRKGiVpQsE0qshqzpI0KU3P9EnLNgLeKlhndlrWXHmLHNTNzCgtpx4RYyJi54JpTBFVXAVsDgwneVfzpVmch9MvZmZk3/slIuoK6roWuDddnAMMKlh1YFpGC+XNckvdzIzy9n5pev8aULB4FNDYM2YccLykNSRtCgwFngWeA4ZK2lRSd5KbqeNaq8ctdTMzyvtEqaSbgb2BfpJmA+cDe0saDgQwC/gqQERMlXQbyQ3QFcDoiKhP93MW8ABQDYyNiKmt1h0RZTuRcuo54qzKPLAcefe5Kzr7EMzKokcN7Y7Iu/7ib0XHnH+c85mKfVLJLXUzMzxMgJlZruRlmAAHdTMz3FI3M8sVD71rZpYjTr+YmeWIg7qZWY7kJKY7qJuZgVvqZma5kpOY7qBuZgbu/WJmlitVOWmqO6ibmeH0i5lZrvhGqZlZjuQkpe6gbmYGvlFqZpYrav+Q7BXBr7MzMyNJvxQ7tUbSWEnzJU0pKPsfSdMkTZJ0t6Teafkmkj6SNDGdri7YZidJkyXNkHS5ikj8Zx7UJfWUtGXW9ZiZtYekoqciXAcctErZQ8C2EbE98ApwTsFnr0XE8HQ6s6D8KuArJO8tHdrEPv9DpkFd0ueAicD96fJwSa2+ONXMrKOV88XTEfE48M4qZQ9GxIp08RlgYMvHowHAOhHxTCTvHb0BOLK1urNuqf8EGAksBIiIicCmGddpZlayKqnoSdIoSRMKplElVvcl4K8Fy5tKelHS3yTtmZZtBMwuWGd2WtairG+ULo+IRav8XPELpc2s4pTS+yUixgBj2lKPpHOBFcCNadFcYHBELJC0E/AnScPasm/IPqhPlXQiUC1pKPBN4OmM6zQzK1lHPHsk6XTgMGC/NKVCRCwFlqbzz0t6DdgCmMMnUzQD07IWZZ1++QYwjOSAbwIWAd/OuE4zs5KVkn5pC0kHAT8ADo+IDwvK15dUnc5vRnJD9PWImAsslrRb2uvlVOCe1urJuqW+VUScC5ybcT1mZu1Szoa6pJuBvYF+kmYD55P0dlkDeChNST+T9nTZC7hA0nKgATgzIhpvsn6dpCdNT5IcfGEevklZB/VLJW0A3AHcGhFTWtvAzKwzlHPsl4g4oYni3zez7p3Anc18NgHYtpS6M02/RMQ+wD7Av4Fr0k7052VZp5lZW5Tz4aPOlPnDRxExLyIuB84k6bP+46zrNDMrVVWVip4qWatBXYmTJf04XR4saWQxO5e0taSfSJoM/D+Sni8tdrg3M+sMZX6itNMUk1P/LUnyfl/gAuA9kvzPLkVsOxa4FTgwIv7V1oM0M8tahTfAi1ZMUN81InaU9CJARLwrqXsxO4+I3dt1dGZmHaTSW+DFKiaoL0/7UAYkfSpJWu7NknRbRByXpl0KnyAVEOmANmZmFSMfIb24oH45cDfQX9JFwDFAaz1YvpX+Pawdx2Zm1mGqc5J/aTWoR8SNkp4H9iP5MjsyIl5uZZu56ezXI+KHhZ9J+iXww//cqvIMrO3N7y48lf7rrU0EjL3zKa68+TE+v/8Izj3zELbatJY9T7mEF156c+U22w7dkCvOO4G1e/WgoSHY4+RfsXTZCu654utssP461FRX89SLr/HtX9xKQ4OHwSnFU088zi8vvoiG+gaOOvpYzvhKqWMoWWu68jXuMukXSYOBD4E/F5ZFxJvNb7XSZ/nPAH5wE2UVaUV9A2dfdhcTp81mrTXX4Ombfsj4f0xj6mv/4vjvXcsV533y+YLq6irG/uw0zvjvG5j8yhz6rtuL5SvqATj5h2N574MlANx8yZc5+rM7cvsDz3f4Oa2u6uvr+flFF3DNtX+gtraWE79wDHvvsy+bDxnS2YeWG139GuckpheVfvkLSV5cQA+SoXOnk4zp0iRJXyN5vHUzSZMKPlobeKrNR9vB5r29mHlvLwbg/Q+XMm3mPDZcvzeP/GNak+vvv/tWTHl1DpNfScbceWfRBys/awzoNTVVdKupJh3Lx4o0ZfIkBg3amIGDBgFw0CGH8tij47tMwOkIXf0at3VMl0pTTPplu8JlSTuSBOyW3EQyRsEvgLMLyt8rGNNgtTJ4QF+GbzmQ56bManadoYP7EwHjrhxNvz5rcccDz3PZ9Q+v/HzclaPZeduNefCpl7jr4Rc74KjzY35dHRsM2GDlcv/aWiZPmtTCFlaqrn6NcxLTS3+iNCJeAHZtZZ1FETErIk6IiDeAj0ha+2ul6ZwmFQ48v+LtqaUeWmZ69ezOzZd8me9fcufKFndTaqqr+dSIzfjiudex35cu4/B9d2DvkVus/Pzw0Vey6Wd/xBrda9h7F7/hz6ySdJmHjyR9t2CxCtgRKOpBovR1dpcBGwLzgY2Bl2kmdVM48HzPEWdVRH6ipqaKmy/5Crf+dQL3PPLPFtedM38hT77wGgsWJmmX+5+cyoitBvHYs6+sXGfpshX8+bFJfG7v7ZpN49h/6l9by7y581Yuz6+ro7a2thOPKH+6+jWurvBgXaxiWuprF0xrkOTYjyhy/z8DdgNeiYhNSXrQPNOG4+w0V59/EtNnzuPyPz7S6roPPf0Sw4ZsSM8e3aiurmLPnYbw8uvz6NWzOxv0WwdIbqYevMcwps+qy/rQc2XYttvx5puzmD37LZYvW8b99/2Fz+yzb2cfVq509WuclwG9Wmyppw8drR0R/9XG/S9PX9FUJakqIh6V9Js27qvDfWr4Zpx02K5MfmUOz9yS3Bo4/4pxrNGthst+eCz9+qzFXZefyaTpczh89JUsfO8jLv/jIzz5xx8QETzw5FTuf3Iq/fuuzR2/+Srdu9VQVSUen/Aq197xZCef3eqlpqaGc879MV8b9WUaGuo58qijGTJkaGcfVq509Wtc6cG6WGquF4akmohYIenvbX3cX9LDJG+//gXQjyQFs0tEfKq1bSsl/ZJn7z53RWcfgllZ9Khp/wOh3/vz9KJjzqWf27JivwJaSr88m/6dKGmcpFMkfb5xKnL/R5DcJP0OcD/wGvC5th+umVk2ypl+kTRW0nxJUwrK+kp6SNKr6d8+abkkXS5phqRJaQ/Dxm1OS9d/VdJpRZ1HEev0ABaQjNJ4GElQLurx/4j4ICLqI2JFRFwfEZdHxIJitjUz60hS8VMRrgMOWqXsbGB8RAwFxvNxd++DSd5LOhQYBVyVHI/6krwGb1dgJHB+4xdBS1rKqfdPe75M4eOHjxoV9TNF0ntNrLsImAB8LyJeL2Y/ZmZZqynv6+wel7TJKsVHkLy3FOB64DGSp+uPAG6IJBf+jKTekgak6z7U+GyPpIdIvihubqnuloJ6NbAWTQ9eVmzu6TfAbJKHkQQcD2wOvEAy1vreRe7HzCxTpcR0SaNIWtWNxqRdsltSWzAu1jygsb/oRsBbBevNTsuaK29RS0F9bkRc0NoOWnF4ROxQsDxG0sSI+KGkH7Vz32ZmZVPKMAGFz9S0RUSEpEw6g7SUUy/Hb5EPJR3X2KVR0nFA4yOZ7t1iZhWjzDn1ptSlaRXSv/PT8jnAoIL1BqZlzZW3qKWgvl8pR9uMk4BTSA6+Lp0/WVJP4Kwy7N/MrCw64OGjcUBjD5bTgHsKyk9Ne8HsBixK0zQPAAdI6pPeID0gLWtRs+mXcgy8ld4Iba4Lo5++MbOKUc6XZEi6meSeYT9Js0l6sVwM3CbpDOAN4Lh09fuAQ4AZJMOcfxGSGCzpQuC5dL0LionLxQy922aStiDpnlMbEdtK2p4kz/6zLOs1MytVOZ8ojYgTmvnoPzIgaa+X0c3sZyxJp5KilTxKY4muBc4BlgNExCSSHjBmZhVFJfxXyTJtqQNrRsSzqwxVuSLjOs3MSpaXsV+yDupvS9qctKeLpGOAuS1vYmbW8RzUizOapC/nVpLmADNJesSYmVWUSn/5RbGyDupzgD8AjwJ9gcUkXXna+1CTmVlZVWd9h7GDZB3U7wEWkgwLUNTbkszMOkOXefF0Ow2MiFVHKjMzqzh5yaln/YPjaUnbZVyHmVm7dcAwAR0i65b6HsDpkmYCS0nGk4mI2D7jes3MSlJV4f3Pi5V1UD844/2bmZVFpbfAi5VpUI+IN7Lcv5lZudTkJKmedUvdzGy14Ja6mVmOuEujmVmO5CSmO6ibmUH2/bs7ioO6mRn5Sb/k5cvJzKxdqqSip5ZI2lLSxIJpsaRvS/qJpDkF5YcUbHOOpBmSpks6sD3n4Za6mRmU7dGjiJgODAeQVE0ysOHdJK+p+3VEXPKJeqVtSF4eNAzYEHhY0hYRUd+W+t1SNzMjs2EC9gNea+WZnSOAWyJiaUTMJHlX6ci2noeDupkZyXjqJUyjJE0omEY1s9vjgZsLls+SNEnSWEl90rKNgLcK1pmdlrWJg7qZGUkwLHaKiDERsXPBNGbV/UnqDhwO3J4WXQVsTpKamQtcmsV5OKduZkYmvV8OBl6IiDqAxr8Akq4F7k0X5wCDCrYbmJa1ScUG9Q33PbSzD8HMupAMXmd3AgWpF0kDIqLxHc1HAVPS+XHATZIuI7lROhR4tq2VVmxQNzPrSOXMRUvqBXwW+GpB8a8kDQcCmNX4WURMlXQb8BKwAhjd1p4v4KBuZgaUt6UeER8A661SdkoL618EXFSOuh3UzcwoXz/1zuagbmYGVOdkmAAHdTMzPEqjmVmuKCcJGAd1MzPcUjczy5Uqt9TNzPLDLXUzsxzJy0syHNTNzICqfMR0B3UzM3DvFzOzXMlJ9sVB3cwM3FI3M8sV59TNzHLEvV/MzHIkHyHdQd3MDMhPS90vnjYzI2mpFzu1ui9plqTJkiZKmpCW9ZX0kKRX07990nJJulzSDEmTJO3YnvPINKinB3uypB+ny4MljcyyTjOzNilnVE/sExHDI2LndPlsYHxEDAXGp8uQvKB6aDqNAq5qz2lk3VL/LbA7yQtYAd4Drsy4TjOzklVJRU9tdARwfTp/PXBkQfkNkXgG6C1pQJvPo60bFmnXiBgNLAGIiHeB7hnXaWZWsjI31AN4UNLzkkalZbURMTednwfUpvMbAW8VbDs7LWuTrG+ULpdUTXKCSFofaMi4TjOz0pXQAE8D9aiCojERMaZgeY+ImCOpP/CQpGmF20dESIr2HG5zsg7qlwN3A/0lXQQcA5yXcZ1mZiUr5YnSNICPaeHzOenf+ZLuBkYCdZIGRMTcNL0yP119DjCoYPOBaVmbZJp+iYgbgR8AvwDmAkdGxO1Z1mlm1hZS8VPL+1EvSWs3zgMHAFOAccBp6WqnAfek8+OAU9OOJbsBiwrSNCXLtKUu6XLglojwzVEzq2hl7KVeC9ytJPrXADdFxP2SngNuk3QG8AZwXLr+fcAhwAzgQ+CL7ak86/TL88B5krYkScPcEhETMq7TzKxkKtPDRxHxOrBDE+ULgP2aKA9gdFkqJ/v0y/URcQiwCzAd+KWkV7Os08ysLcqVfulsHTVMwBBgK2Bj4OUOqtPMrGgVHquLlnVO/VfAUcBrwK3AhRGxMMs6zczaJCdRPeuW+mvA7hHxdsb1mJm1i1+S0QJJW0XENOA5YLCkwYWfR8QLWdRbbhd/YTv23Xp9Fry/jIMveXJl+al7bMzJnx5MfUPw2Mv/5pf3TgfgzH0347hdB1LfEFzwp5d5YnryXbZ2jxp+cdx2bDFgLSLg7Fsn8+Ib/sFSqqeeeJxfXnwRDfUNHHX0sZzxlVGtb2Ql6crXuNJz5cXKqqX+XZKnrS5t4rMA9s2o3rK687nZ/N+Tb3DJCduvLNtt877sP6w/h13yFMvqG1hvrWTUgyG1a3HYiAEc9Ksn6b/uGtzw1ZHsf/HfaAj48ZFb8/j0f3PWDS/SrVr06FbdWae02qqvr+fnF13ANdf+gdraWk78wjHsvc++bD5kSGcfWm509WvsoN6CiGj8ej84IpYUfiapRxZ1ZuG5199loz49P1F24qcGc/Ujr7OsPhntYMH7ywDYf1h/7n1xLsvqG5j9zke8seADdhjcm1fr3meXzfry/VsmA7C8Plhev6JjTyQHpkyexKBBGzNwUPLg3UGHHMpjj47vMgGnI3T1a5yX9EvWA3o9XWTZamPT9Xuxy2Z9uPObu3PT13dlu0HrAlC7bg/mLvz4+2vewiXUrtuDQX178s4Hy/jV8dsx7ruf5ufHbUvP7m6pl2p+XR0bDNhg5XL/2lrq6uo68Yjyp6tf47x0acwkqEvaQNJOQE9JIyTtmE57A2tmUWdHqakSvdfsxtGX/52L/zyN/3fK8FbXH7bROtz49JscftlTfLS0njP33ayDjtbMilX+4dQ7R1Y59QOB00kGprmsoPw94EfNbVQ48lm//b/BOtsfnNHhtd28RUt4YFLSepn01iIaAvr26k7doiUM6P1xZmmD3j2oW7SEuYuWMG/REv755iIA/jppnoN6G/SvrWXe3Hkrl+fX1VFbW9vCFlaqLn+NKz1aFymTlnr6JOk+wOkRsU/BdHhE3NXCdmMiYueI2LkSAzrAg1Pq2G3IegBs0m9NuteIdz5Yxvip8zlsxAC6V1cxsG9PNunXi3++uZC331vG3IVL2HT9XgB8auh6zKh7vzNPYbU0bNvtePPNWcye/RbLly3j/vv+wmf2WS3ut682uvo17oCXZHSIrLo0nhwRfwQ2kfTdVT+PiMua2Kzi/ObkHdh187706dWdJ/97H/73gVe549nZXPyF7fjrf+3BsvoGvn/zJABerXuf+ybO4/4f7El9QwM/uWsqDeloyT+9+yV+fdIOdKsWb73zET+4ZVInntXqqaamhnPO/TFfG/VlGhrqOfKooxkyZGhnH1audPVrXNmhunhKxpIp806lr0bENZLOb+rziPhpa/vY/Ht/zWQAefvY1F9W5q8hs1L1qGl/TH6l7sOiY84WtWtW7HdAVl0ar0n/thq8zcwqgbs0FkHSryStI6mbpPGS/i3p5CzrNDNrC3dpLM4BEbEYOAyYRTJa4/czrtPMrGTu0lja/g8Fbo+IReUaiN7MrJzyEpuybqnfm75FeydgvKT1gSWtbGNm1uHK+I7SQZIelfSSpKmSvpWW/0TSHEkT0+mQgm3OkTRD0nRJB7bnPDJtqUfE2emY6osiol7SB8ARWdZpZtYWZWynrwC+FxEvpC+gfl7SQ+lnv46ISz5Rr7QNcDwwDNgQeFjSFhFR35bKs35JRjfgZGCv9KfN34Crs6zTzKxNyhTVI2IuMDedf0/Sy8BGLWxyBMn7m5cCMyXNAEYCf29L/VmnX64iSb38Np12TMvMzCqKSvlPGiVpQsHU5MDzkjYBRgD/SIvOkjRJ0jM6vAYAAAlkSURBVFhJfdKyjYC3CjabTctfAi3K+kbpLhFR+FbtRyT9M+M6zcxKVsp90ogYA4xpeX9aC7gT+HZELJZ0FXAhyTslLiR538SX2nq8zcm6pV4vafPGBUmbAW3KE5mZZalKxU+tSVPPdwI3No53FRF1EVEfEQ3AtSQpFoA5wKCCzQemZW2SdUv9+8Cjkl5PlzcBvphxnWZmbVCepLqSG4i/B14uHOdK0oA03w5wFDAlnR8H3CTpMpIbpUOBZ9taf9ZB/SngGmA/YCHwAG1M/puZZamM3dQ/DZwCTJY0MS37EXCCpOEk6ZdZwFcBImKqpNuAl0h6zoxua88XyD6o3wAsJskfAZwI/B9wbMb1mpmVpFwxPSKebGZ397WwzUXAReWoP+ugvm1EbFOw/KiklzKu08ysZDl5oDTzG6UvSNqtcUHSrsCEjOs0MyuZpKKnSpZ1S30n4GlJb6bLg4HpkiYDERHbZ1y/mVlRKjtUFy/roH5Qxvs3MyuLCm+AFy3rsV/eyHL/ZmblkpeXZGTdUjczWz3kI6Y7qJuZQW5iuoO6mRlAVU6S6g7qZmbk50Zp1v3UzcysA7mlbmZGflrqDupmZrhLo5lZrrilbmaWIw7qZmY54vSLmVmO5KWl7i6NZmYkT5QWO7W6L+kgSdMlzZB0dkaH3CQHdTMzKFtUl1QNXAkcDGxD8hq7bVreqnycfjEzo6zDBIwEZkTE6wCSbgGOIHkHaeYqNqi/dunBq12GS9KoiBjT2ceRZ77G2euq17hHTfF3SiWNAkYVFI0puGYbAW8VfDYb2LX9R1gcp1/Ka1Trq1g7+Rpnz9e4FRExJiJ2Lpgq5kvQQd3MrLzmAIMKlgemZR3CQd3MrLyeA4ZK2lRSd+B4YFxHVV6xOfXVVMX8BMsxX+Ps+Rq3Q0SskHQW8ABQDYyNiKkdVb8ioqPqMjOzjDn9YmaWIw7qZmY54qBeZpI2kXRiG7d9v9zHk2eSekv6esHyhpLu6MxjWt1JOlPSqen86ZI2LPjsdx35ZKS1jXPqZSZpb+C/IuKwJj6riYgVLWz7fkSsleXx5YmkTYB7I2LbTj6UXJL0GMm/5QmdfSxWPLfUU2kL+2VJ10qaKulBST0lbS7pfknPS3pC0lbp+tdJOqZg+8ZW9sXAnpImSvpO2toZJ+kRYLyktSSNl/SCpMmSjuiE0+0Qbbimm0t6Jr0uP2u8pi1cs4uBzdNr/T9pfVPSbZ6RNKzgWB6TtLOkXpLGSnpW0ot5uv7p+U+TdGN63e+QtKak/dJznZye+xrp+hdLeknSJEmXpGU/kfRf6b/tnYEb0+vbs+AaninpfwrqPV3SFen8yem1nSjpmnQcFOtIEeEp+bWyCbACGJ4u3wacDIwHhqZluwKPpPPXAccUbP9++ndvktZjY/npJI8J902Xa4B10vl+wAw+/sX0fmdfh06+pvcCJ6TzZxZc0yavWbr/KavUNyWd/w7w03R+ADA9nf85cHI63xt4BejV2deqjNc7gE+ny2OB80geWd8iLbsB+DawHjC94N9e7/TvT0ha5wCPATsX7P8xkkC/PsnYJo3lfwX2ALYG/gx0S8t/C5za2delq01uqX/SzIiYmM4/T/J/kk8Bt0uaCFxDEiBK9VBEvJPOC/i5pEnAwyTjRNS266grWynXdHfg9nT+poJ9tOWa3QY0/pI6DmjMtR8AnJ3W/RjQAxhc8llVrrci4ql0/o/AfiT/G7ySll0P7AUsApYAv5f0eeDDYiuIiH8Dr0vaTdJ6wFbAU2ldOwHPpdd3P2CzMpyTlcAPH33S0oL5epLAsTAihjex7grS9JWkKqB7C/v9oGD+JJKWzk4RsVzSLJLAklelXNPmlHzNImKOpAWStge+QNLyh+QL4uiImF5C/auTVW+SLSRplX9ypeQBmZEkgfcY4Cxg3xLquYXky3IacHdEhCQB10fEOW06cisLt9RbthiYKelYACV2SD+bRdIqATgc6JbOvwes3cI+1wXmp8FpH2Djsh91ZWvpmj4DHJ3OH1+wTXPXrLVrfSvwA2DdiJiUlj0AfCMNQEga0d4TqjCDJe2ezp8ITAA2kTQkLTsF+JuktUiuy30kqaod/nNXLV7fu0mGkz2BJMBDklY7RlJ/AEl9JXW1f9+dzkG9dScBZ0j6JzCV5B8ywLXAZ9Ly3fm4NT4JqJf0T0nfaWJ/NwI7S5oMnErS0ulqmrum3wa+m6ZZhpCkCKCZaxYRC4CnJE0pvHFX4A6SL4fbCsouJPkCniRparqcJ9OB0ZJeBvoAvwa+SJLumgw0AFeTBOt702v9JPDdJvZ1HXB1443Swg8i4l3gZWDjiHg2LXuJJIf/YLrfh2hbutLawV0arWJIWhP4KP0pfzzJTdPc9E7JmtzF03BO3SrLTsAVaWpkIfClTj4es9WOW+pmZjninLqZWY44qJuZ5YiDuplZjjioWyYk1add4aZIuj3t2dLWfa0cZ0etjBQoaW9Jn2pDHbMk9WvrMZpVCgd1y8pHETE87V63jI+f6ASSESvbstOI+HLaH7o5e5MMQ2DWJTmoW0d4AhiStqKfkDQOeElSdTq64nPpSIFfhZVPmV4habqkh4H+jTtqHCkwnT9IyciN/1QyiuMmJF8e30l/JewpaX1Jd6Z1PCfp0+m26ykZNXKqpN+RDB9gttpzP3XLVNoiPxi4Py3aEdg2ImZKGgUsiohdlAwH+5SkB4ERwJbANiRjxbxEMuJg4X7XJ3mqd690X30j4h1JV5OM7tg4lOxNwK8j4klJg0mGCdgaOB94MiIukHQocEamF8KsgzioW1Z6piP1QdJS/z1JWuTZiJiZlh8AbK+Px6VfFxhKMorgzRFRD/xLyVj0q9oNeLxxXwWjYK5qf2CbdKgXgHXScU/2Aj6fbvsXSe+28TzNKoqDumXlo1VHYkwDa+GIlQK+EREPrLLeIWU8jipgt4hY0sSxmOWOc+rWmR4AviapG4CkLST1Ah4HvpDm3AcA+zSx7TPAXpI2Tbftm5avOrLgg8A3GhckNX7RPE4yiiGSDiYZ/Mpsteegbp3pdyT58heUvIbuGpJfj3cDr6af3QD8fdUN0xc1jALuSkd7vDX96M/AUY03SoFvkozwOEnSS3zcC+enJF8KU0nSMG9mdI5mHcpjv5iZ5Yhb6mZmOeKgbmaWIw7qZmY54qBuZpYjDupmZjnioG5mliMO6mZmOfL/AcTBSyiXiXgyAAAAAElFTkSuQmCC\n"
          },
          "metadata": {
            "needs_background": "light"
          }
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "\n",
            "\n",
            "\n",
            "              precision    recall  f1-score   support\n",
            "\n",
            "     neutral       0.26      1.00      0.41      1298\n",
            "    negative       0.00      0.00      0.00      2163\n",
            "    positive       0.00      0.00      0.00      1606\n",
            "\n",
            "    accuracy                           0.26      5067\n",
            "   macro avg       0.09      0.33      0.14      5067\n",
            "weighted avg       0.07      0.26      0.10      5067\n",
            "\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "/usr/local/lib/python3.8/dist-packages/sklearn/metrics/_classification.py:1318: UndefinedMetricWarning: Precision and F-score are ill-defined and being set to 0.0 in labels with no predicted samples. Use `zero_division` parameter to control this behavior.\n",
            "  _warn_prf(average, modifier, msg_start, len(result))\n",
            "/usr/local/lib/python3.8/dist-packages/sklearn/metrics/_classification.py:1318: UndefinedMetricWarning: Precision and F-score are ill-defined and being set to 0.0 in labels with no predicted samples. Use `zero_division` parameter to control this behavior.\n",
            "  _warn_prf(average, modifier, msg_start, len(result))\n",
            "/usr/local/lib/python3.8/dist-packages/sklearn/metrics/_classification.py:1318: UndefinedMetricWarning: Precision and F-score are ill-defined and being set to 0.0 in labels with no predicted samples. Use `zero_division` parameter to control this behavior.\n",
            "  _warn_prf(average, modifier, msg_start, len(result))\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "Here we see that because in the coco dataset most captions are considered emotionless, the text model predicts neutral and the image model tries to mimic that behavior as well. This is why after domain adaptation the models prediction tends toward the neutral class, which is well expected as the coco dataset doesn't have emotions in its captions"
      ],
      "metadata": {
        "id": "5V2ILzgqe7fD"
      }
    }
  ],
  "metadata": {
    "accelerator": "GPU",
    "colab": {
      "provenance": [],
      "include_colab_link": true
    },
    "gpuClass": "standard",
    "kernelspec": {
      "display_name": "torch",
      "language": "python",
      "name": "python3"
    },
    "language_info": {
      "codemirror_mode": {
        "name": "ipython",
        "version": 3
      },
      "file_extension": ".py",
      "mimetype": "text/x-python",
      "name": "python",
      "nbconvert_exporter": "python",
      "pygments_lexer": "ipython3",
      "version": "3.8.16"
    },
    "orig_nbformat": 4,
    "vscode": {
      "interpreter": {
        "hash": "e2f775898ea1037b7c9eeca230f0f6a000b04cbdfbf9c82813024cd1951cbec6"
      }
    },
    "widgets": {
      "application/vnd.jupyter.widget-state+json": {
        "8741d5cc28ef4fb3b4968aa05d9c1b65": {
          "model_module": "@jupyter-widgets/controls",
          "model_name": "HBoxModel",
          "model_module_version": "1.5.0",
          "state": {
            "_dom_classes": [],
            "_model_module": "@jupyter-widgets/controls",
            "_model_module_version": "1.5.0",
            "_model_name": "HBoxModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/controls",
            "_view_module_version": "1.5.0",
            "_view_name": "HBoxView",
            "box_style": "",
            "children": [
              "IPY_MODEL_b6321a1e370a49e0bfd863e28559b737",
              "IPY_MODEL_452c1d02549046ff94945f0f3d74d64f",
              "IPY_MODEL_15b0fb9a413a4abc838c0eb99ef5e2d0"
            ],
            "layout": "IPY_MODEL_f80d2533f04a4ecc83921b0d6f1d5f37"
          }
        },
        "b6321a1e370a49e0bfd863e28559b737": {
          "model_module": "@jupyter-widgets/controls",
          "model_name": "HTMLModel",
          "model_module_version": "1.5.0",
          "state": {
            "_dom_classes": [],
            "_model_module": "@jupyter-widgets/controls",
            "_model_module_version": "1.5.0",
            "_model_name": "HTMLModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/controls",
            "_view_module_version": "1.5.0",
            "_view_name": "HTMLView",
            "description": "",
            "description_tooltip": null,
            "layout": "IPY_MODEL_a70f1e3bc12642cd93c28da7e5fbb9d5",
            "placeholder": "​",
            "style": "IPY_MODEL_e89599ab79d84e8c9204fccde2f2b123",
            "value": "100%"
          }
        },
        "452c1d02549046ff94945f0f3d74d64f": {
          "model_module": "@jupyter-widgets/controls",
          "model_name": "FloatProgressModel",
          "model_module_version": "1.5.0",
          "state": {
            "_dom_classes": [],
            "_model_module": "@jupyter-widgets/controls",
            "_model_module_version": "1.5.0",
            "_model_name": "FloatProgressModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/controls",
            "_view_module_version": "1.5.0",
            "_view_name": "ProgressView",
            "bar_style": "success",
            "description": "",
            "description_tooltip": null,
            "layout": "IPY_MODEL_38a1ece6af714171830173ad962f5eeb",
            "max": 111898327,
            "min": 0,
            "orientation": "horizontal",
            "style": "IPY_MODEL_9c37d1e9c8b5491bb55cc61a98b00edd",
            "value": 111898327
          }
        },
        "15b0fb9a413a4abc838c0eb99ef5e2d0": {
          "model_module": "@jupyter-widgets/controls",
          "model_name": "HTMLModel",
          "model_module_version": "1.5.0",
          "state": {
            "_dom_classes": [],
            "_model_module": "@jupyter-widgets/controls",
            "_model_module_version": "1.5.0",
            "_model_name": "HTMLModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/controls",
            "_view_module_version": "1.5.0",
            "_view_name": "HTMLView",
            "description": "",
            "description_tooltip": null,
            "layout": "IPY_MODEL_f9b305eece3c479c8da0cc57a849aec2",
            "placeholder": "​",
            "style": "IPY_MODEL_954b9f39f7eb4f75b825a2e0210156bb",
            "value": " 107M/107M [00:13&lt;00:00, 9.39MB/s]"
          }
        },
        "f80d2533f04a4ecc83921b0d6f1d5f37": {
          "model_module": "@jupyter-widgets/base",
          "model_name": "LayoutModel",
          "model_module_version": "1.2.0",
          "state": {
            "_model_module": "@jupyter-widgets/base",
            "_model_module_version": "1.2.0",
            "_model_name": "LayoutModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/base",
            "_view_module_version": "1.2.0",
            "_view_name": "LayoutView",
            "align_content": null,
            "align_items": null,
            "align_self": null,
            "border": null,
            "bottom": null,
            "display": null,
            "flex": null,
            "flex_flow": null,
            "grid_area": null,
            "grid_auto_columns": null,
            "grid_auto_flow": null,
            "grid_auto_rows": null,
            "grid_column": null,
            "grid_gap": null,
            "grid_row": null,
            "grid_template_areas": null,
            "grid_template_columns": null,
            "grid_template_rows": null,
            "height": null,
            "justify_content": null,
            "justify_items": null,
            "left": null,
            "margin": null,
            "max_height": null,
            "max_width": null,
            "min_height": null,
            "min_width": null,
            "object_fit": null,
            "object_position": null,
            "order": null,
            "overflow": null,
            "overflow_x": null,
            "overflow_y": null,
            "padding": null,
            "right": null,
            "top": null,
            "visibility": null,
            "width": null
          }
        },
        "a70f1e3bc12642cd93c28da7e5fbb9d5": {
          "model_module": "@jupyter-widgets/base",
          "model_name": "LayoutModel",
          "model_module_version": "1.2.0",
          "state": {
            "_model_module": "@jupyter-widgets/base",
            "_model_module_version": "1.2.0",
            "_model_name": "LayoutModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/base",
            "_view_module_version": "1.2.0",
            "_view_name": "LayoutView",
            "align_content": null,
            "align_items": null,
            "align_self": null,
            "border": null,
            "bottom": null,
            "display": null,
            "flex": null,
            "flex_flow": null,
            "grid_area": null,
            "grid_auto_columns": null,
            "grid_auto_flow": null,
            "grid_auto_rows": null,
            "grid_column": null,
            "grid_gap": null,
            "grid_row": null,
            "grid_template_areas": null,
            "grid_template_columns": null,
            "grid_template_rows": null,
            "height": null,
            "justify_content": null,
            "justify_items": null,
            "left": null,
            "margin": null,
            "max_height": null,
            "max_width": null,
            "min_height": null,
            "min_width": null,
            "object_fit": null,
            "object_position": null,
            "order": null,
            "overflow": null,
            "overflow_x": null,
            "overflow_y": null,
            "padding": null,
            "right": null,
            "top": null,
            "visibility": null,
            "width": null
          }
        },
        "e89599ab79d84e8c9204fccde2f2b123": {
          "model_module": "@jupyter-widgets/controls",
          "model_name": "DescriptionStyleModel",
          "model_module_version": "1.5.0",
          "state": {
            "_model_module": "@jupyter-widgets/controls",
            "_model_module_version": "1.5.0",
            "_model_name": "DescriptionStyleModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/base",
            "_view_module_version": "1.2.0",
            "_view_name": "StyleView",
            "description_width": ""
          }
        },
        "38a1ece6af714171830173ad962f5eeb": {
          "model_module": "@jupyter-widgets/base",
          "model_name": "LayoutModel",
          "model_module_version": "1.2.0",
          "state": {
            "_model_module": "@jupyter-widgets/base",
            "_model_module_version": "1.2.0",
            "_model_name": "LayoutModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/base",
            "_view_module_version": "1.2.0",
            "_view_name": "LayoutView",
            "align_content": null,
            "align_items": null,
            "align_self": null,
            "border": null,
            "bottom": null,
            "display": null,
            "flex": null,
            "flex_flow": null,
            "grid_area": null,
            "grid_auto_columns": null,
            "grid_auto_flow": null,
            "grid_auto_rows": null,
            "grid_column": null,
            "grid_gap": null,
            "grid_row": null,
            "grid_template_areas": null,
            "grid_template_columns": null,
            "grid_template_rows": null,
            "height": null,
            "justify_content": null,
            "justify_items": null,
            "left": null,
            "margin": null,
            "max_height": null,
            "max_width": null,
            "min_height": null,
            "min_width": null,
            "object_fit": null,
            "object_position": null,
            "order": null,
            "overflow": null,
            "overflow_x": null,
            "overflow_y": null,
            "padding": null,
            "right": null,
            "top": null,
            "visibility": null,
            "width": null
          }
        },
        "9c37d1e9c8b5491bb55cc61a98b00edd": {
          "model_module": "@jupyter-widgets/controls",
          "model_name": "ProgressStyleModel",
          "model_module_version": "1.5.0",
          "state": {
            "_model_module": "@jupyter-widgets/controls",
            "_model_module_version": "1.5.0",
            "_model_name": "ProgressStyleModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/base",
            "_view_module_version": "1.2.0",
            "_view_name": "StyleView",
            "bar_color": null,
            "description_width": ""
          }
        },
        "f9b305eece3c479c8da0cc57a849aec2": {
          "model_module": "@jupyter-widgets/base",
          "model_name": "LayoutModel",
          "model_module_version": "1.2.0",
          "state": {
            "_model_module": "@jupyter-widgets/base",
            "_model_module_version": "1.2.0",
            "_model_name": "LayoutModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/base",
            "_view_module_version": "1.2.0",
            "_view_name": "LayoutView",
            "align_content": null,
            "align_items": null,
            "align_self": null,
            "border": null,
            "bottom": null,
            "display": null,
            "flex": null,
            "flex_flow": null,
            "grid_area": null,
            "grid_auto_columns": null,
            "grid_auto_flow": null,
            "grid_auto_rows": null,
            "grid_column": null,
            "grid_gap": null,
            "grid_row": null,
            "grid_template_areas": null,
            "grid_template_columns": null,
            "grid_template_rows": null,
            "height": null,
            "justify_content": null,
            "justify_items": null,
            "left": null,
            "margin": null,
            "max_height": null,
            "max_width": null,
            "min_height": null,
            "min_width": null,
            "object_fit": null,
            "object_position": null,
            "order": null,
            "overflow": null,
            "overflow_x": null,
            "overflow_y": null,
            "padding": null,
            "right": null,
            "top": null,
            "visibility": null,
            "width": null
          }
        },
        "954b9f39f7eb4f75b825a2e0210156bb": {
          "model_module": "@jupyter-widgets/controls",
          "model_name": "DescriptionStyleModel",
          "model_module_version": "1.5.0",
          "state": {
            "_model_module": "@jupyter-widgets/controls",
            "_model_module_version": "1.5.0",
            "_model_name": "DescriptionStyleModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/base",
            "_view_module_version": "1.2.0",
            "_view_name": "StyleView",
            "description_width": ""
          }
        },
        "37208c6aada94765bd76443b137f2427": {
          "model_module": "@jupyter-widgets/controls",
          "model_name": "HBoxModel",
          "model_module_version": "1.5.0",
          "state": {
            "_dom_classes": [],
            "_model_module": "@jupyter-widgets/controls",
            "_model_module_version": "1.5.0",
            "_model_name": "HBoxModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/controls",
            "_view_module_version": "1.5.0",
            "_view_name": "HBoxView",
            "box_style": "",
            "children": [
              "IPY_MODEL_2b0b6dae110b48c4820fb23e085b7596",
              "IPY_MODEL_10fd80efdfb04010ae7aa33471c9c263",
              "IPY_MODEL_64262e050f9c49bcbe9422fcb211345b"
            ],
            "layout": "IPY_MODEL_47807478c4f94784ab13232feaa93d91"
          }
        },
        "2b0b6dae110b48c4820fb23e085b7596": {
          "model_module": "@jupyter-widgets/controls",
          "model_name": "HTMLModel",
          "model_module_version": "1.5.0",
          "state": {
            "_dom_classes": [],
            "_model_module": "@jupyter-widgets/controls",
            "_model_module_version": "1.5.0",
            "_model_name": "HTMLModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/controls",
            "_view_module_version": "1.5.0",
            "_view_name": "HTMLView",
            "description": "",
            "description_tooltip": null,
            "layout": "IPY_MODEL_795068a3f1b545eba12cefdcace57049",
            "placeholder": "​",
            "style": "IPY_MODEL_21230213567b4d9187383f824294767a",
            "value": "Downloading (…)&quot;pytorch_model.bin&quot;;: 100%"
          }
        },
        "10fd80efdfb04010ae7aa33471c9c263": {
          "model_module": "@jupyter-widgets/controls",
          "model_name": "FloatProgressModel",
          "model_module_version": "1.5.0",
          "state": {
            "_dom_classes": [],
            "_model_module": "@jupyter-widgets/controls",
            "_model_module_version": "1.5.0",
            "_model_name": "FloatProgressModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/controls",
            "_view_module_version": "1.5.0",
            "_view_name": "ProgressView",
            "bar_style": "success",
            "description": "",
            "description_tooltip": null,
            "layout": "IPY_MODEL_682e45aa70f74e9f832b872b8cd485ef",
            "max": 440473133,
            "min": 0,
            "orientation": "horizontal",
            "style": "IPY_MODEL_dda11bff89bf44faa42584f756fcc8d0",
            "value": 440473133
          }
        },
        "64262e050f9c49bcbe9422fcb211345b": {
          "model_module": "@jupyter-widgets/controls",
          "model_name": "HTMLModel",
          "model_module_version": "1.5.0",
          "state": {
            "_dom_classes": [],
            "_model_module": "@jupyter-widgets/controls",
            "_model_module_version": "1.5.0",
            "_model_name": "HTMLModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/controls",
            "_view_module_version": "1.5.0",
            "_view_name": "HTMLView",
            "description": "",
            "description_tooltip": null,
            "layout": "IPY_MODEL_8573e0fc886f46339db904fedc9992b9",
            "placeholder": "​",
            "style": "IPY_MODEL_2cfeb66a45484db6949d8be7792080d2",
            "value": " 440M/440M [00:03&lt;00:00, 121MB/s]"
          }
        },
        "47807478c4f94784ab13232feaa93d91": {
          "model_module": "@jupyter-widgets/base",
          "model_name": "LayoutModel",
          "model_module_version": "1.2.0",
          "state": {
            "_model_module": "@jupyter-widgets/base",
            "_model_module_version": "1.2.0",
            "_model_name": "LayoutModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/base",
            "_view_module_version": "1.2.0",
            "_view_name": "LayoutView",
            "align_content": null,
            "align_items": null,
            "align_self": null,
            "border": null,
            "bottom": null,
            "display": null,
            "flex": null,
            "flex_flow": null,
            "grid_area": null,
            "grid_auto_columns": null,
            "grid_auto_flow": null,
            "grid_auto_rows": null,
            "grid_column": null,
            "grid_gap": null,
            "grid_row": null,
            "grid_template_areas": null,
            "grid_template_columns": null,
            "grid_template_rows": null,
            "height": null,
            "justify_content": null,
            "justify_items": null,
            "left": null,
            "margin": null,
            "max_height": null,
            "max_width": null,
            "min_height": null,
            "min_width": null,
            "object_fit": null,
            "object_position": null,
            "order": null,
            "overflow": null,
            "overflow_x": null,
            "overflow_y": null,
            "padding": null,
            "right": null,
            "top": null,
            "visibility": null,
            "width": null
          }
        },
        "795068a3f1b545eba12cefdcace57049": {
          "model_module": "@jupyter-widgets/base",
          "model_name": "LayoutModel",
          "model_module_version": "1.2.0",
          "state": {
            "_model_module": "@jupyter-widgets/base",
            "_model_module_version": "1.2.0",
            "_model_name": "LayoutModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/base",
            "_view_module_version": "1.2.0",
            "_view_name": "LayoutView",
            "align_content": null,
            "align_items": null,
            "align_self": null,
            "border": null,
            "bottom": null,
            "display": null,
            "flex": null,
            "flex_flow": null,
            "grid_area": null,
            "grid_auto_columns": null,
            "grid_auto_flow": null,
            "grid_auto_rows": null,
            "grid_column": null,
            "grid_gap": null,
            "grid_row": null,
            "grid_template_areas": null,
            "grid_template_columns": null,
            "grid_template_rows": null,
            "height": null,
            "justify_content": null,
            "justify_items": null,
            "left": null,
            "margin": null,
            "max_height": null,
            "max_width": null,
            "min_height": null,
            "min_width": null,
            "object_fit": null,
            "object_position": null,
            "order": null,
            "overflow": null,
            "overflow_x": null,
            "overflow_y": null,
            "padding": null,
            "right": null,
            "top": null,
            "visibility": null,
            "width": null
          }
        },
        "21230213567b4d9187383f824294767a": {
          "model_module": "@jupyter-widgets/controls",
          "model_name": "DescriptionStyleModel",
          "model_module_version": "1.5.0",
          "state": {
            "_model_module": "@jupyter-widgets/controls",
            "_model_module_version": "1.5.0",
            "_model_name": "DescriptionStyleModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/base",
            "_view_module_version": "1.2.0",
            "_view_name": "StyleView",
            "description_width": ""
          }
        },
        "682e45aa70f74e9f832b872b8cd485ef": {
          "model_module": "@jupyter-widgets/base",
          "model_name": "LayoutModel",
          "model_module_version": "1.2.0",
          "state": {
            "_model_module": "@jupyter-widgets/base",
            "_model_module_version": "1.2.0",
            "_model_name": "LayoutModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/base",
            "_view_module_version": "1.2.0",
            "_view_name": "LayoutView",
            "align_content": null,
            "align_items": null,
            "align_self": null,
            "border": null,
            "bottom": null,
            "display": null,
            "flex": null,
            "flex_flow": null,
            "grid_area": null,
            "grid_auto_columns": null,
            "grid_auto_flow": null,
            "grid_auto_rows": null,
            "grid_column": null,
            "grid_gap": null,
            "grid_row": null,
            "grid_template_areas": null,
            "grid_template_columns": null,
            "grid_template_rows": null,
            "height": null,
            "justify_content": null,
            "justify_items": null,
            "left": null,
            "margin": null,
            "max_height": null,
            "max_width": null,
            "min_height": null,
            "min_width": null,
            "object_fit": null,
            "object_position": null,
            "order": null,
            "overflow": null,
            "overflow_x": null,
            "overflow_y": null,
            "padding": null,
            "right": null,
            "top": null,
            "visibility": null,
            "width": null
          }
        },
        "dda11bff89bf44faa42584f756fcc8d0": {
          "model_module": "@jupyter-widgets/controls",
          "model_name": "ProgressStyleModel",
          "model_module_version": "1.5.0",
          "state": {
            "_model_module": "@jupyter-widgets/controls",
            "_model_module_version": "1.5.0",
            "_model_name": "ProgressStyleModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/base",
            "_view_module_version": "1.2.0",
            "_view_name": "StyleView",
            "bar_color": null,
            "description_width": ""
          }
        },
        "8573e0fc886f46339db904fedc9992b9": {
          "model_module": "@jupyter-widgets/base",
          "model_name": "LayoutModel",
          "model_module_version": "1.2.0",
          "state": {
            "_model_module": "@jupyter-widgets/base",
            "_model_module_version": "1.2.0",
            "_model_name": "LayoutModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/base",
            "_view_module_version": "1.2.0",
            "_view_name": "LayoutView",
            "align_content": null,
            "align_items": null,
            "align_self": null,
            "border": null,
            "bottom": null,
            "display": null,
            "flex": null,
            "flex_flow": null,
            "grid_area": null,
            "grid_auto_columns": null,
            "grid_auto_flow": null,
            "grid_auto_rows": null,
            "grid_column": null,
            "grid_gap": null,
            "grid_row": null,
            "grid_template_areas": null,
            "grid_template_columns": null,
            "grid_template_rows": null,
            "height": null,
            "justify_content": null,
            "justify_items": null,
            "left": null,
            "margin": null,
            "max_height": null,
            "max_width": null,
            "min_height": null,
            "min_width": null,
            "object_fit": null,
            "object_position": null,
            "order": null,
            "overflow": null,
            "overflow_x": null,
            "overflow_y": null,
            "padding": null,
            "right": null,
            "top": null,
            "visibility": null,
            "width": null
          }
        },
        "2cfeb66a45484db6949d8be7792080d2": {
          "model_module": "@jupyter-widgets/controls",
          "model_name": "DescriptionStyleModel",
          "model_module_version": "1.5.0",
          "state": {
            "_model_module": "@jupyter-widgets/controls",
            "_model_module_version": "1.5.0",
            "_model_name": "DescriptionStyleModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/base",
            "_view_module_version": "1.2.0",
            "_view_name": "StyleView",
            "description_width": ""
          }
        },
        "ab4de94edd374902ba19e095a1574c09": {
          "model_module": "@jupyter-widgets/controls",
          "model_name": "HBoxModel",
          "model_module_version": "1.5.0",
          "state": {
            "_dom_classes": [],
            "_model_module": "@jupyter-widgets/controls",
            "_model_module_version": "1.5.0",
            "_model_name": "HBoxModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/controls",
            "_view_module_version": "1.5.0",
            "_view_name": "HBoxView",
            "box_style": "",
            "children": [
              "IPY_MODEL_4eb2115aec5f40548e08d8acf967d3ce",
              "IPY_MODEL_d4ce1ab67f1b46f4828779109f2cdd6d",
              "IPY_MODEL_67dbcd182fe847038e197442bc946cb9"
            ],
            "layout": "IPY_MODEL_099f1a06be2f4bc589a23387de0b5958"
          }
        },
        "4eb2115aec5f40548e08d8acf967d3ce": {
          "model_module": "@jupyter-widgets/controls",
          "model_name": "HTMLModel",
          "model_module_version": "1.5.0",
          "state": {
            "_dom_classes": [],
            "_model_module": "@jupyter-widgets/controls",
            "_model_module_version": "1.5.0",
            "_model_name": "HTMLModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/controls",
            "_view_module_version": "1.5.0",
            "_view_name": "HTMLView",
            "description": "",
            "description_tooltip": null,
            "layout": "IPY_MODEL_d2c106bc01dc40fca64ef45abfcd62b3",
            "placeholder": "​",
            "style": "IPY_MODEL_bda078bac6534dc5bcf7a0fa4216d13f",
            "value": "Downloading (…)rocessor_config.json: 100%"
          }
        },
        "d4ce1ab67f1b46f4828779109f2cdd6d": {
          "model_module": "@jupyter-widgets/controls",
          "model_name": "FloatProgressModel",
          "model_module_version": "1.5.0",
          "state": {
            "_dom_classes": [],
            "_model_module": "@jupyter-widgets/controls",
            "_model_module_version": "1.5.0",
            "_model_name": "FloatProgressModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/controls",
            "_view_module_version": "1.5.0",
            "_view_name": "ProgressView",
            "bar_style": "success",
            "description": "",
            "description_tooltip": null,
            "layout": "IPY_MODEL_f9a2f37629c8434e88301f0ff22f11eb",
            "max": 316,
            "min": 0,
            "orientation": "horizontal",
            "style": "IPY_MODEL_4202e739ce6342f3ab6d3b3b7b3ec4c6",
            "value": 316
          }
        },
        "67dbcd182fe847038e197442bc946cb9": {
          "model_module": "@jupyter-widgets/controls",
          "model_name": "HTMLModel",
          "model_module_version": "1.5.0",
          "state": {
            "_dom_classes": [],
            "_model_module": "@jupyter-widgets/controls",
            "_model_module_version": "1.5.0",
            "_model_name": "HTMLModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/controls",
            "_view_module_version": "1.5.0",
            "_view_name": "HTMLView",
            "description": "",
            "description_tooltip": null,
            "layout": "IPY_MODEL_eb352e019cd94a4b9502b8170ea3e77b",
            "placeholder": "​",
            "style": "IPY_MODEL_2dd120a4fcfc4e6e81433405faf4fabc",
            "value": " 316/316 [00:00&lt;00:00, 7.87kB/s]"
          }
        },
        "099f1a06be2f4bc589a23387de0b5958": {
          "model_module": "@jupyter-widgets/base",
          "model_name": "LayoutModel",
          "model_module_version": "1.2.0",
          "state": {
            "_model_module": "@jupyter-widgets/base",
            "_model_module_version": "1.2.0",
            "_model_name": "LayoutModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/base",
            "_view_module_version": "1.2.0",
            "_view_name": "LayoutView",
            "align_content": null,
            "align_items": null,
            "align_self": null,
            "border": null,
            "bottom": null,
            "display": null,
            "flex": null,
            "flex_flow": null,
            "grid_area": null,
            "grid_auto_columns": null,
            "grid_auto_flow": null,
            "grid_auto_rows": null,
            "grid_column": null,
            "grid_gap": null,
            "grid_row": null,
            "grid_template_areas": null,
            "grid_template_columns": null,
            "grid_template_rows": null,
            "height": null,
            "justify_content": null,
            "justify_items": null,
            "left": null,
            "margin": null,
            "max_height": null,
            "max_width": null,
            "min_height": null,
            "min_width": null,
            "object_fit": null,
            "object_position": null,
            "order": null,
            "overflow": null,
            "overflow_x": null,
            "overflow_y": null,
            "padding": null,
            "right": null,
            "top": null,
            "visibility": null,
            "width": null
          }
        },
        "d2c106bc01dc40fca64ef45abfcd62b3": {
          "model_module": "@jupyter-widgets/base",
          "model_name": "LayoutModel",
          "model_module_version": "1.2.0",
          "state": {
            "_model_module": "@jupyter-widgets/base",
            "_model_module_version": "1.2.0",
            "_model_name": "LayoutModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/base",
            "_view_module_version": "1.2.0",
            "_view_name": "LayoutView",
            "align_content": null,
            "align_items": null,
            "align_self": null,
            "border": null,
            "bottom": null,
            "display": null,
            "flex": null,
            "flex_flow": null,
            "grid_area": null,
            "grid_auto_columns": null,
            "grid_auto_flow": null,
            "grid_auto_rows": null,
            "grid_column": null,
            "grid_gap": null,
            "grid_row": null,
            "grid_template_areas": null,
            "grid_template_columns": null,
            "grid_template_rows": null,
            "height": null,
            "justify_content": null,
            "justify_items": null,
            "left": null,
            "margin": null,
            "max_height": null,
            "max_width": null,
            "min_height": null,
            "min_width": null,
            "object_fit": null,
            "object_position": null,
            "order": null,
            "overflow": null,
            "overflow_x": null,
            "overflow_y": null,
            "padding": null,
            "right": null,
            "top": null,
            "visibility": null,
            "width": null
          }
        },
        "bda078bac6534dc5bcf7a0fa4216d13f": {
          "model_module": "@jupyter-widgets/controls",
          "model_name": "DescriptionStyleModel",
          "model_module_version": "1.5.0",
          "state": {
            "_model_module": "@jupyter-widgets/controls",
            "_model_module_version": "1.5.0",
            "_model_name": "DescriptionStyleModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/base",
            "_view_module_version": "1.2.0",
            "_view_name": "StyleView",
            "description_width": ""
          }
        },
        "f9a2f37629c8434e88301f0ff22f11eb": {
          "model_module": "@jupyter-widgets/base",
          "model_name": "LayoutModel",
          "model_module_version": "1.2.0",
          "state": {
            "_model_module": "@jupyter-widgets/base",
            "_model_module_version": "1.2.0",
            "_model_name": "LayoutModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/base",
            "_view_module_version": "1.2.0",
            "_view_name": "LayoutView",
            "align_content": null,
            "align_items": null,
            "align_self": null,
            "border": null,
            "bottom": null,
            "display": null,
            "flex": null,
            "flex_flow": null,
            "grid_area": null,
            "grid_auto_columns": null,
            "grid_auto_flow": null,
            "grid_auto_rows": null,
            "grid_column": null,
            "grid_gap": null,
            "grid_row": null,
            "grid_template_areas": null,
            "grid_template_columns": null,
            "grid_template_rows": null,
            "height": null,
            "justify_content": null,
            "justify_items": null,
            "left": null,
            "margin": null,
            "max_height": null,
            "max_width": null,
            "min_height": null,
            "min_width": null,
            "object_fit": null,
            "object_position": null,
            "order": null,
            "overflow": null,
            "overflow_x": null,
            "overflow_y": null,
            "padding": null,
            "right": null,
            "top": null,
            "visibility": null,
            "width": null
          }
        },
        "4202e739ce6342f3ab6d3b3b7b3ec4c6": {
          "model_module": "@jupyter-widgets/controls",
          "model_name": "ProgressStyleModel",
          "model_module_version": "1.5.0",
          "state": {
            "_model_module": "@jupyter-widgets/controls",
            "_model_module_version": "1.5.0",
            "_model_name": "ProgressStyleModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/base",
            "_view_module_version": "1.2.0",
            "_view_name": "StyleView",
            "bar_color": null,
            "description_width": ""
          }
        },
        "eb352e019cd94a4b9502b8170ea3e77b": {
          "model_module": "@jupyter-widgets/base",
          "model_name": "LayoutModel",
          "model_module_version": "1.2.0",
          "state": {
            "_model_module": "@jupyter-widgets/base",
            "_model_module_version": "1.2.0",
            "_model_name": "LayoutModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/base",
            "_view_module_version": "1.2.0",
            "_view_name": "LayoutView",
            "align_content": null,
            "align_items": null,
            "align_self": null,
            "border": null,
            "bottom": null,
            "display": null,
            "flex": null,
            "flex_flow": null,
            "grid_area": null,
            "grid_auto_columns": null,
            "grid_auto_flow": null,
            "grid_auto_rows": null,
            "grid_column": null,
            "grid_gap": null,
            "grid_row": null,
            "grid_template_areas": null,
            "grid_template_columns": null,
            "grid_template_rows": null,
            "height": null,
            "justify_content": null,
            "justify_items": null,
            "left": null,
            "margin": null,
            "max_height": null,
            "max_width": null,
            "min_height": null,
            "min_width": null,
            "object_fit": null,
            "object_position": null,
            "order": null,
            "overflow": null,
            "overflow_x": null,
            "overflow_y": null,
            "padding": null,
            "right": null,
            "top": null,
            "visibility": null,
            "width": null
          }
        },
        "2dd120a4fcfc4e6e81433405faf4fabc": {
          "model_module": "@jupyter-widgets/controls",
          "model_name": "DescriptionStyleModel",
          "model_module_version": "1.5.0",
          "state": {
            "_model_module": "@jupyter-widgets/controls",
            "_model_module_version": "1.5.0",
            "_model_name": "DescriptionStyleModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/base",
            "_view_module_version": "1.2.0",
            "_view_name": "StyleView",
            "description_width": ""
          }
        },
        "be356a263f1f48c1acf65d4d93aca285": {
          "model_module": "@jupyter-widgets/controls",
          "model_name": "HBoxModel",
          "model_module_version": "1.5.0",
          "state": {
            "_dom_classes": [],
            "_model_module": "@jupyter-widgets/controls",
            "_model_module_version": "1.5.0",
            "_model_name": "HBoxModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/controls",
            "_view_module_version": "1.5.0",
            "_view_name": "HBoxView",
            "box_style": "",
            "children": [
              "IPY_MODEL_2ec92719fec543b8a1c8ffbd3ebb0e04",
              "IPY_MODEL_7ced846360fe4ac9832fc06273f3123a",
              "IPY_MODEL_1f0e9dbb0c0a468b90e09ef3dd2b7d68"
            ],
            "layout": "IPY_MODEL_c489f7182f204ae0a57b3464eea4494e"
          }
        },
        "2ec92719fec543b8a1c8ffbd3ebb0e04": {
          "model_module": "@jupyter-widgets/controls",
          "model_name": "HTMLModel",
          "model_module_version": "1.5.0",
          "state": {
            "_dom_classes": [],
            "_model_module": "@jupyter-widgets/controls",
            "_model_module_version": "1.5.0",
            "_model_name": "HTMLModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/controls",
            "_view_module_version": "1.5.0",
            "_view_name": "HTMLView",
            "description": "",
            "description_tooltip": null,
            "layout": "IPY_MODEL_d215211010f24231b00c97a09ef427af",
            "placeholder": "​",
            "style": "IPY_MODEL_487a646ca805438a9ef2d1ee1d98a65b",
            "value": "Downloading (…)okenizer_config.json: 100%"
          }
        },
        "7ced846360fe4ac9832fc06273f3123a": {
          "model_module": "@jupyter-widgets/controls",
          "model_name": "FloatProgressModel",
          "model_module_version": "1.5.0",
          "state": {
            "_dom_classes": [],
            "_model_module": "@jupyter-widgets/controls",
            "_model_module_version": "1.5.0",
            "_model_name": "FloatProgressModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/controls",
            "_view_module_version": "1.5.0",
            "_view_name": "ProgressView",
            "bar_style": "success",
            "description": "",
            "description_tooltip": null,
            "layout": "IPY_MODEL_3c4e2c6b4c904995af7527e6af1f2064",
            "max": 568,
            "min": 0,
            "orientation": "horizontal",
            "style": "IPY_MODEL_e5c7d1a34a5842af9d9e28ce57cfdc98",
            "value": 568
          }
        },
        "1f0e9dbb0c0a468b90e09ef3dd2b7d68": {
          "model_module": "@jupyter-widgets/controls",
          "model_name": "HTMLModel",
          "model_module_version": "1.5.0",
          "state": {
            "_dom_classes": [],
            "_model_module": "@jupyter-widgets/controls",
            "_model_module_version": "1.5.0",
            "_model_name": "HTMLModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/controls",
            "_view_module_version": "1.5.0",
            "_view_name": "HTMLView",
            "description": "",
            "description_tooltip": null,
            "layout": "IPY_MODEL_7e51a113772e4ceb8d072900577a02b4",
            "placeholder": "​",
            "style": "IPY_MODEL_37146d56aff1481dae8a80297cdd42c4",
            "value": " 568/568 [00:00&lt;00:00, 22.6kB/s]"
          }
        },
        "c489f7182f204ae0a57b3464eea4494e": {
          "model_module": "@jupyter-widgets/base",
          "model_name": "LayoutModel",
          "model_module_version": "1.2.0",
          "state": {
            "_model_module": "@jupyter-widgets/base",
            "_model_module_version": "1.2.0",
            "_model_name": "LayoutModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/base",
            "_view_module_version": "1.2.0",
            "_view_name": "LayoutView",
            "align_content": null,
            "align_items": null,
            "align_self": null,
            "border": null,
            "bottom": null,
            "display": null,
            "flex": null,
            "flex_flow": null,
            "grid_area": null,
            "grid_auto_columns": null,
            "grid_auto_flow": null,
            "grid_auto_rows": null,
            "grid_column": null,
            "grid_gap": null,
            "grid_row": null,
            "grid_template_areas": null,
            "grid_template_columns": null,
            "grid_template_rows": null,
            "height": null,
            "justify_content": null,
            "justify_items": null,
            "left": null,
            "margin": null,
            "max_height": null,
            "max_width": null,
            "min_height": null,
            "min_width": null,
            "object_fit": null,
            "object_position": null,
            "order": null,
            "overflow": null,
            "overflow_x": null,
            "overflow_y": null,
            "padding": null,
            "right": null,
            "top": null,
            "visibility": null,
            "width": null
          }
        },
        "d215211010f24231b00c97a09ef427af": {
          "model_module": "@jupyter-widgets/base",
          "model_name": "LayoutModel",
          "model_module_version": "1.2.0",
          "state": {
            "_model_module": "@jupyter-widgets/base",
            "_model_module_version": "1.2.0",
            "_model_name": "LayoutModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/base",
            "_view_module_version": "1.2.0",
            "_view_name": "LayoutView",
            "align_content": null,
            "align_items": null,
            "align_self": null,
            "border": null,
            "bottom": null,
            "display": null,
            "flex": null,
            "flex_flow": null,
            "grid_area": null,
            "grid_auto_columns": null,
            "grid_auto_flow": null,
            "grid_auto_rows": null,
            "grid_column": null,
            "grid_gap": null,
            "grid_row": null,
            "grid_template_areas": null,
            "grid_template_columns": null,
            "grid_template_rows": null,
            "height": null,
            "justify_content": null,
            "justify_items": null,
            "left": null,
            "margin": null,
            "max_height": null,
            "max_width": null,
            "min_height": null,
            "min_width": null,
            "object_fit": null,
            "object_position": null,
            "order": null,
            "overflow": null,
            "overflow_x": null,
            "overflow_y": null,
            "padding": null,
            "right": null,
            "top": null,
            "visibility": null,
            "width": null
          }
        },
        "487a646ca805438a9ef2d1ee1d98a65b": {
          "model_module": "@jupyter-widgets/controls",
          "model_name": "DescriptionStyleModel",
          "model_module_version": "1.5.0",
          "state": {
            "_model_module": "@jupyter-widgets/controls",
            "_model_module_version": "1.5.0",
            "_model_name": "DescriptionStyleModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/base",
            "_view_module_version": "1.2.0",
            "_view_name": "StyleView",
            "description_width": ""
          }
        },
        "3c4e2c6b4c904995af7527e6af1f2064": {
          "model_module": "@jupyter-widgets/base",
          "model_name": "LayoutModel",
          "model_module_version": "1.2.0",
          "state": {
            "_model_module": "@jupyter-widgets/base",
            "_model_module_version": "1.2.0",
            "_model_name": "LayoutModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/base",
            "_view_module_version": "1.2.0",
            "_view_name": "LayoutView",
            "align_content": null,
            "align_items": null,
            "align_self": null,
            "border": null,
            "bottom": null,
            "display": null,
            "flex": null,
            "flex_flow": null,
            "grid_area": null,
            "grid_auto_columns": null,
            "grid_auto_flow": null,
            "grid_auto_rows": null,
            "grid_column": null,
            "grid_gap": null,
            "grid_row": null,
            "grid_template_areas": null,
            "grid_template_columns": null,
            "grid_template_rows": null,
            "height": null,
            "justify_content": null,
            "justify_items": null,
            "left": null,
            "margin": null,
            "max_height": null,
            "max_width": null,
            "min_height": null,
            "min_width": null,
            "object_fit": null,
            "object_position": null,
            "order": null,
            "overflow": null,
            "overflow_x": null,
            "overflow_y": null,
            "padding": null,
            "right": null,
            "top": null,
            "visibility": null,
            "width": null
          }
        },
        "e5c7d1a34a5842af9d9e28ce57cfdc98": {
          "model_module": "@jupyter-widgets/controls",
          "model_name": "ProgressStyleModel",
          "model_module_version": "1.5.0",
          "state": {
            "_model_module": "@jupyter-widgets/controls",
            "_model_module_version": "1.5.0",
            "_model_name": "ProgressStyleModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/base",
            "_view_module_version": "1.2.0",
            "_view_name": "StyleView",
            "bar_color": null,
            "description_width": ""
          }
        },
        "7e51a113772e4ceb8d072900577a02b4": {
          "model_module": "@jupyter-widgets/base",
          "model_name": "LayoutModel",
          "model_module_version": "1.2.0",
          "state": {
            "_model_module": "@jupyter-widgets/base",
            "_model_module_version": "1.2.0",
            "_model_name": "LayoutModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/base",
            "_view_module_version": "1.2.0",
            "_view_name": "LayoutView",
            "align_content": null,
            "align_items": null,
            "align_self": null,
            "border": null,
            "bottom": null,
            "display": null,
            "flex": null,
            "flex_flow": null,
            "grid_area": null,
            "grid_auto_columns": null,
            "grid_auto_flow": null,
            "grid_auto_rows": null,
            "grid_column": null,
            "grid_gap": null,
            "grid_row": null,
            "grid_template_areas": null,
            "grid_template_columns": null,
            "grid_template_rows": null,
            "height": null,
            "justify_content": null,
            "justify_items": null,
            "left": null,
            "margin": null,
            "max_height": null,
            "max_width": null,
            "min_height": null,
            "min_width": null,
            "object_fit": null,
            "object_position": null,
            "order": null,
            "overflow": null,
            "overflow_x": null,
            "overflow_y": null,
            "padding": null,
            "right": null,
            "top": null,
            "visibility": null,
            "width": null
          }
        },
        "37146d56aff1481dae8a80297cdd42c4": {
          "model_module": "@jupyter-widgets/controls",
          "model_name": "DescriptionStyleModel",
          "model_module_version": "1.5.0",
          "state": {
            "_model_module": "@jupyter-widgets/controls",
            "_model_module_version": "1.5.0",
            "_model_name": "DescriptionStyleModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/base",
            "_view_module_version": "1.2.0",
            "_view_name": "StyleView",
            "description_width": ""
          }
        },
        "910440a5aa11480aa9cf48984128a67e": {
          "model_module": "@jupyter-widgets/controls",
          "model_name": "HBoxModel",
          "model_module_version": "1.5.0",
          "state": {
            "_dom_classes": [],
            "_model_module": "@jupyter-widgets/controls",
            "_model_module_version": "1.5.0",
            "_model_name": "HBoxModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/controls",
            "_view_module_version": "1.5.0",
            "_view_name": "HBoxView",
            "box_style": "",
            "children": [
              "IPY_MODEL_aa4614982ce644f289beda9b49eadcbd",
              "IPY_MODEL_abc087188c984174a1473232df4f3b99",
              "IPY_MODEL_f36cb501cb7a4f818d646b8864bc790c"
            ],
            "layout": "IPY_MODEL_8d6bd867219e4f83bde84a25dc3f7e9a"
          }
        },
        "aa4614982ce644f289beda9b49eadcbd": {
          "model_module": "@jupyter-widgets/controls",
          "model_name": "HTMLModel",
          "model_module_version": "1.5.0",
          "state": {
            "_dom_classes": [],
            "_model_module": "@jupyter-widgets/controls",
            "_model_module_version": "1.5.0",
            "_model_name": "HTMLModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/controls",
            "_view_module_version": "1.5.0",
            "_view_name": "HTMLView",
            "description": "",
            "description_tooltip": null,
            "layout": "IPY_MODEL_e3f6a9ff8a074261b188f081522b55c7",
            "placeholder": "​",
            "style": "IPY_MODEL_372c0aa4b1644c7e88cb388123b02555",
            "value": "Downloading (…)lve/main/config.json: 100%"
          }
        },
        "abc087188c984174a1473232df4f3b99": {
          "model_module": "@jupyter-widgets/controls",
          "model_name": "FloatProgressModel",
          "model_module_version": "1.5.0",
          "state": {
            "_dom_classes": [],
            "_model_module": "@jupyter-widgets/controls",
            "_model_module_version": "1.5.0",
            "_model_name": "FloatProgressModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/controls",
            "_view_module_version": "1.5.0",
            "_view_name": "ProgressView",
            "bar_style": "success",
            "description": "",
            "description_tooltip": null,
            "layout": "IPY_MODEL_d273a30bc0a5497aa78cead30ac7e8ff",
            "max": 4186,
            "min": 0,
            "orientation": "horizontal",
            "style": "IPY_MODEL_26257c1e8f514d3888cc71b7c5a3938d",
            "value": 4186
          }
        },
        "f36cb501cb7a4f818d646b8864bc790c": {
          "model_module": "@jupyter-widgets/controls",
          "model_name": "HTMLModel",
          "model_module_version": "1.5.0",
          "state": {
            "_dom_classes": [],
            "_model_module": "@jupyter-widgets/controls",
            "_model_module_version": "1.5.0",
            "_model_name": "HTMLModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/controls",
            "_view_module_version": "1.5.0",
            "_view_name": "HTMLView",
            "description": "",
            "description_tooltip": null,
            "layout": "IPY_MODEL_c4dfb3053f77475baa2fd42dd946c8ba",
            "placeholder": "​",
            "style": "IPY_MODEL_f167ae4608834c1f804d7244953b0648",
            "value": " 4.19k/4.19k [00:00&lt;00:00, 150kB/s]"
          }
        },
        "8d6bd867219e4f83bde84a25dc3f7e9a": {
          "model_module": "@jupyter-widgets/base",
          "model_name": "LayoutModel",
          "model_module_version": "1.2.0",
          "state": {
            "_model_module": "@jupyter-widgets/base",
            "_model_module_version": "1.2.0",
            "_model_name": "LayoutModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/base",
            "_view_module_version": "1.2.0",
            "_view_name": "LayoutView",
            "align_content": null,
            "align_items": null,
            "align_self": null,
            "border": null,
            "bottom": null,
            "display": null,
            "flex": null,
            "flex_flow": null,
            "grid_area": null,
            "grid_auto_columns": null,
            "grid_auto_flow": null,
            "grid_auto_rows": null,
            "grid_column": null,
            "grid_gap": null,
            "grid_row": null,
            "grid_template_areas": null,
            "grid_template_columns": null,
            "grid_template_rows": null,
            "height": null,
            "justify_content": null,
            "justify_items": null,
            "left": null,
            "margin": null,
            "max_height": null,
            "max_width": null,
            "min_height": null,
            "min_width": null,
            "object_fit": null,
            "object_position": null,
            "order": null,
            "overflow": null,
            "overflow_x": null,
            "overflow_y": null,
            "padding": null,
            "right": null,
            "top": null,
            "visibility": null,
            "width": null
          }
        },
        "e3f6a9ff8a074261b188f081522b55c7": {
          "model_module": "@jupyter-widgets/base",
          "model_name": "LayoutModel",
          "model_module_version": "1.2.0",
          "state": {
            "_model_module": "@jupyter-widgets/base",
            "_model_module_version": "1.2.0",
            "_model_name": "LayoutModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/base",
            "_view_module_version": "1.2.0",
            "_view_name": "LayoutView",
            "align_content": null,
            "align_items": null,
            "align_self": null,
            "border": null,
            "bottom": null,
            "display": null,
            "flex": null,
            "flex_flow": null,
            "grid_area": null,
            "grid_auto_columns": null,
            "grid_auto_flow": null,
            "grid_auto_rows": null,
            "grid_column": null,
            "grid_gap": null,
            "grid_row": null,
            "grid_template_areas": null,
            "grid_template_columns": null,
            "grid_template_rows": null,
            "height": null,
            "justify_content": null,
            "justify_items": null,
            "left": null,
            "margin": null,
            "max_height": null,
            "max_width": null,
            "min_height": null,
            "min_width": null,
            "object_fit": null,
            "object_position": null,
            "order": null,
            "overflow": null,
            "overflow_x": null,
            "overflow_y": null,
            "padding": null,
            "right": null,
            "top": null,
            "visibility": null,
            "width": null
          }
        },
        "372c0aa4b1644c7e88cb388123b02555": {
          "model_module": "@jupyter-widgets/controls",
          "model_name": "DescriptionStyleModel",
          "model_module_version": "1.5.0",
          "state": {
            "_model_module": "@jupyter-widgets/controls",
            "_model_module_version": "1.5.0",
            "_model_name": "DescriptionStyleModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/base",
            "_view_module_version": "1.2.0",
            "_view_name": "StyleView",
            "description_width": ""
          }
        },
        "d273a30bc0a5497aa78cead30ac7e8ff": {
          "model_module": "@jupyter-widgets/base",
          "model_name": "LayoutModel",
          "model_module_version": "1.2.0",
          "state": {
            "_model_module": "@jupyter-widgets/base",
            "_model_module_version": "1.2.0",
            "_model_name": "LayoutModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/base",
            "_view_module_version": "1.2.0",
            "_view_name": "LayoutView",
            "align_content": null,
            "align_items": null,
            "align_self": null,
            "border": null,
            "bottom": null,
            "display": null,
            "flex": null,
            "flex_flow": null,
            "grid_area": null,
            "grid_auto_columns": null,
            "grid_auto_flow": null,
            "grid_auto_rows": null,
            "grid_column": null,
            "grid_gap": null,
            "grid_row": null,
            "grid_template_areas": null,
            "grid_template_columns": null,
            "grid_template_rows": null,
            "height": null,
            "justify_content": null,
            "justify_items": null,
            "left": null,
            "margin": null,
            "max_height": null,
            "max_width": null,
            "min_height": null,
            "min_width": null,
            "object_fit": null,
            "object_position": null,
            "order": null,
            "overflow": null,
            "overflow_x": null,
            "overflow_y": null,
            "padding": null,
            "right": null,
            "top": null,
            "visibility": null,
            "width": null
          }
        },
        "26257c1e8f514d3888cc71b7c5a3938d": {
          "model_module": "@jupyter-widgets/controls",
          "model_name": "ProgressStyleModel",
          "model_module_version": "1.5.0",
          "state": {
            "_model_module": "@jupyter-widgets/controls",
            "_model_module_version": "1.5.0",
            "_model_name": "ProgressStyleModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/base",
            "_view_module_version": "1.2.0",
            "_view_name": "StyleView",
            "bar_color": null,
            "description_width": ""
          }
        },
        "c4dfb3053f77475baa2fd42dd946c8ba": {
          "model_module": "@jupyter-widgets/base",
          "model_name": "LayoutModel",
          "model_module_version": "1.2.0",
          "state": {
            "_model_module": "@jupyter-widgets/base",
            "_model_module_version": "1.2.0",
            "_model_name": "LayoutModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/base",
            "_view_module_version": "1.2.0",
            "_view_name": "LayoutView",
            "align_content": null,
            "align_items": null,
            "align_self": null,
            "border": null,
            "bottom": null,
            "display": null,
            "flex": null,
            "flex_flow": null,
            "grid_area": null,
            "grid_auto_columns": null,
            "grid_auto_flow": null,
            "grid_auto_rows": null,
            "grid_column": null,
            "grid_gap": null,
            "grid_row": null,
            "grid_template_areas": null,
            "grid_template_columns": null,
            "grid_template_rows": null,
            "height": null,
            "justify_content": null,
            "justify_items": null,
            "left": null,
            "margin": null,
            "max_height": null,
            "max_width": null,
            "min_height": null,
            "min_width": null,
            "object_fit": null,
            "object_position": null,
            "order": null,
            "overflow": null,
            "overflow_x": null,
            "overflow_y": null,
            "padding": null,
            "right": null,
            "top": null,
            "visibility": null,
            "width": null
          }
        },
        "f167ae4608834c1f804d7244953b0648": {
          "model_module": "@jupyter-widgets/controls",
          "model_name": "DescriptionStyleModel",
          "model_module_version": "1.5.0",
          "state": {
            "_model_module": "@jupyter-widgets/controls",
            "_model_module_version": "1.5.0",
            "_model_name": "DescriptionStyleModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/base",
            "_view_module_version": "1.2.0",
            "_view_name": "StyleView",
            "description_width": ""
          }
        },
        "39c2798c8b464251bdd014c304644a17": {
          "model_module": "@jupyter-widgets/controls",
          "model_name": "HBoxModel",
          "model_module_version": "1.5.0",
          "state": {
            "_dom_classes": [],
            "_model_module": "@jupyter-widgets/controls",
            "_model_module_version": "1.5.0",
            "_model_name": "HBoxModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/controls",
            "_view_module_version": "1.5.0",
            "_view_name": "HBoxView",
            "box_style": "",
            "children": [
              "IPY_MODEL_bcb37951a38b4ae3ac90306c0c62f6cf",
              "IPY_MODEL_6866489565e448f6a3dc4dd23cf0604b",
              "IPY_MODEL_513bae98944f410aaba77547fa73ea00"
            ],
            "layout": "IPY_MODEL_babfb4a9833e4e35989fab3fda5b3998"
          }
        },
        "bcb37951a38b4ae3ac90306c0c62f6cf": {
          "model_module": "@jupyter-widgets/controls",
          "model_name": "HTMLModel",
          "model_module_version": "1.5.0",
          "state": {
            "_dom_classes": [],
            "_model_module": "@jupyter-widgets/controls",
            "_model_module_version": "1.5.0",
            "_model_name": "HTMLModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/controls",
            "_view_module_version": "1.5.0",
            "_view_name": "HTMLView",
            "description": "",
            "description_tooltip": null,
            "layout": "IPY_MODEL_b0c7eb90e8474103897c527d4328d3d1",
            "placeholder": "​",
            "style": "IPY_MODEL_341f9c9f35b34382b10a9c6f93abc6fe",
            "value": "Downloading (…)olve/main/vocab.json: 100%"
          }
        },
        "6866489565e448f6a3dc4dd23cf0604b": {
          "model_module": "@jupyter-widgets/controls",
          "model_name": "FloatProgressModel",
          "model_module_version": "1.5.0",
          "state": {
            "_dom_classes": [],
            "_model_module": "@jupyter-widgets/controls",
            "_model_module_version": "1.5.0",
            "_model_name": "FloatProgressModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/controls",
            "_view_module_version": "1.5.0",
            "_view_name": "ProgressView",
            "bar_style": "success",
            "description": "",
            "description_tooltip": null,
            "layout": "IPY_MODEL_b7926d74af0140eaa0fdc598afa677a0",
            "max": 862328,
            "min": 0,
            "orientation": "horizontal",
            "style": "IPY_MODEL_e5b60e8da3764866980e2bf7d372d089",
            "value": 862328
          }
        },
        "513bae98944f410aaba77547fa73ea00": {
          "model_module": "@jupyter-widgets/controls",
          "model_name": "HTMLModel",
          "model_module_version": "1.5.0",
          "state": {
            "_dom_classes": [],
            "_model_module": "@jupyter-widgets/controls",
            "_model_module_version": "1.5.0",
            "_model_name": "HTMLModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/controls",
            "_view_module_version": "1.5.0",
            "_view_name": "HTMLView",
            "description": "",
            "description_tooltip": null,
            "layout": "IPY_MODEL_0deb6178218c47a99ffd375e4e2b60a5",
            "placeholder": "​",
            "style": "IPY_MODEL_7efa97f13d2e4fa68d5deef2ee9552d0",
            "value": " 862k/862k [00:01&lt;00:00, 660kB/s]"
          }
        },
        "babfb4a9833e4e35989fab3fda5b3998": {
          "model_module": "@jupyter-widgets/base",
          "model_name": "LayoutModel",
          "model_module_version": "1.2.0",
          "state": {
            "_model_module": "@jupyter-widgets/base",
            "_model_module_version": "1.2.0",
            "_model_name": "LayoutModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/base",
            "_view_module_version": "1.2.0",
            "_view_name": "LayoutView",
            "align_content": null,
            "align_items": null,
            "align_self": null,
            "border": null,
            "bottom": null,
            "display": null,
            "flex": null,
            "flex_flow": null,
            "grid_area": null,
            "grid_auto_columns": null,
            "grid_auto_flow": null,
            "grid_auto_rows": null,
            "grid_column": null,
            "grid_gap": null,
            "grid_row": null,
            "grid_template_areas": null,
            "grid_template_columns": null,
            "grid_template_rows": null,
            "height": null,
            "justify_content": null,
            "justify_items": null,
            "left": null,
            "margin": null,
            "max_height": null,
            "max_width": null,
            "min_height": null,
            "min_width": null,
            "object_fit": null,
            "object_position": null,
            "order": null,
            "overflow": null,
            "overflow_x": null,
            "overflow_y": null,
            "padding": null,
            "right": null,
            "top": null,
            "visibility": null,
            "width": null
          }
        },
        "b0c7eb90e8474103897c527d4328d3d1": {
          "model_module": "@jupyter-widgets/base",
          "model_name": "LayoutModel",
          "model_module_version": "1.2.0",
          "state": {
            "_model_module": "@jupyter-widgets/base",
            "_model_module_version": "1.2.0",
            "_model_name": "LayoutModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/base",
            "_view_module_version": "1.2.0",
            "_view_name": "LayoutView",
            "align_content": null,
            "align_items": null,
            "align_self": null,
            "border": null,
            "bottom": null,
            "display": null,
            "flex": null,
            "flex_flow": null,
            "grid_area": null,
            "grid_auto_columns": null,
            "grid_auto_flow": null,
            "grid_auto_rows": null,
            "grid_column": null,
            "grid_gap": null,
            "grid_row": null,
            "grid_template_areas": null,
            "grid_template_columns": null,
            "grid_template_rows": null,
            "height": null,
            "justify_content": null,
            "justify_items": null,
            "left": null,
            "margin": null,
            "max_height": null,
            "max_width": null,
            "min_height": null,
            "min_width": null,
            "object_fit": null,
            "object_position": null,
            "order": null,
            "overflow": null,
            "overflow_x": null,
            "overflow_y": null,
            "padding": null,
            "right": null,
            "top": null,
            "visibility": null,
            "width": null
          }
        },
        "341f9c9f35b34382b10a9c6f93abc6fe": {
          "model_module": "@jupyter-widgets/controls",
          "model_name": "DescriptionStyleModel",
          "model_module_version": "1.5.0",
          "state": {
            "_model_module": "@jupyter-widgets/controls",
            "_model_module_version": "1.5.0",
            "_model_name": "DescriptionStyleModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/base",
            "_view_module_version": "1.2.0",
            "_view_name": "StyleView",
            "description_width": ""
          }
        },
        "b7926d74af0140eaa0fdc598afa677a0": {
          "model_module": "@jupyter-widgets/base",
          "model_name": "LayoutModel",
          "model_module_version": "1.2.0",
          "state": {
            "_model_module": "@jupyter-widgets/base",
            "_model_module_version": "1.2.0",
            "_model_name": "LayoutModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/base",
            "_view_module_version": "1.2.0",
            "_view_name": "LayoutView",
            "align_content": null,
            "align_items": null,
            "align_self": null,
            "border": null,
            "bottom": null,
            "display": null,
            "flex": null,
            "flex_flow": null,
            "grid_area": null,
            "grid_auto_columns": null,
            "grid_auto_flow": null,
            "grid_auto_rows": null,
            "grid_column": null,
            "grid_gap": null,
            "grid_row": null,
            "grid_template_areas": null,
            "grid_template_columns": null,
            "grid_template_rows": null,
            "height": null,
            "justify_content": null,
            "justify_items": null,
            "left": null,
            "margin": null,
            "max_height": null,
            "max_width": null,
            "min_height": null,
            "min_width": null,
            "object_fit": null,
            "object_position": null,
            "order": null,
            "overflow": null,
            "overflow_x": null,
            "overflow_y": null,
            "padding": null,
            "right": null,
            "top": null,
            "visibility": null,
            "width": null
          }
        },
        "e5b60e8da3764866980e2bf7d372d089": {
          "model_module": "@jupyter-widgets/controls",
          "model_name": "ProgressStyleModel",
          "model_module_version": "1.5.0",
          "state": {
            "_model_module": "@jupyter-widgets/controls",
            "_model_module_version": "1.5.0",
            "_model_name": "ProgressStyleModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/base",
            "_view_module_version": "1.2.0",
            "_view_name": "StyleView",
            "bar_color": null,
            "description_width": ""
          }
        },
        "0deb6178218c47a99ffd375e4e2b60a5": {
          "model_module": "@jupyter-widgets/base",
          "model_name": "LayoutModel",
          "model_module_version": "1.2.0",
          "state": {
            "_model_module": "@jupyter-widgets/base",
            "_model_module_version": "1.2.0",
            "_model_name": "LayoutModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/base",
            "_view_module_version": "1.2.0",
            "_view_name": "LayoutView",
            "align_content": null,
            "align_items": null,
            "align_self": null,
            "border": null,
            "bottom": null,
            "display": null,
            "flex": null,
            "flex_flow": null,
            "grid_area": null,
            "grid_auto_columns": null,
            "grid_auto_flow": null,
            "grid_auto_rows": null,
            "grid_column": null,
            "grid_gap": null,
            "grid_row": null,
            "grid_template_areas": null,
            "grid_template_columns": null,
            "grid_template_rows": null,
            "height": null,
            "justify_content": null,
            "justify_items": null,
            "left": null,
            "margin": null,
            "max_height": null,
            "max_width": null,
            "min_height": null,
            "min_width": null,
            "object_fit": null,
            "object_position": null,
            "order": null,
            "overflow": null,
            "overflow_x": null,
            "overflow_y": null,
            "padding": null,
            "right": null,
            "top": null,
            "visibility": null,
            "width": null
          }
        },
        "7efa97f13d2e4fa68d5deef2ee9552d0": {
          "model_module": "@jupyter-widgets/controls",
          "model_name": "DescriptionStyleModel",
          "model_module_version": "1.5.0",
          "state": {
            "_model_module": "@jupyter-widgets/controls",
            "_model_module_version": "1.5.0",
            "_model_name": "DescriptionStyleModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/base",
            "_view_module_version": "1.2.0",
            "_view_name": "StyleView",
            "description_width": ""
          }
        },
        "bbfc94a3aaf44e158eaf632ab09b46ba": {
          "model_module": "@jupyter-widgets/controls",
          "model_name": "HBoxModel",
          "model_module_version": "1.5.0",
          "state": {
            "_dom_classes": [],
            "_model_module": "@jupyter-widgets/controls",
            "_model_module_version": "1.5.0",
            "_model_name": "HBoxModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/controls",
            "_view_module_version": "1.5.0",
            "_view_name": "HBoxView",
            "box_style": "",
            "children": [
              "IPY_MODEL_fc62ceecc4434e63992991a521c045f3",
              "IPY_MODEL_de846be5457d4d2f80e82fd545ee503a",
              "IPY_MODEL_077882c4cb444ef2a64595cbc0864d32"
            ],
            "layout": "IPY_MODEL_e88f5086b08245fb8632c566c1f081e7"
          }
        },
        "fc62ceecc4434e63992991a521c045f3": {
          "model_module": "@jupyter-widgets/controls",
          "model_name": "HTMLModel",
          "model_module_version": "1.5.0",
          "state": {
            "_dom_classes": [],
            "_model_module": "@jupyter-widgets/controls",
            "_model_module_version": "1.5.0",
            "_model_name": "HTMLModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/controls",
            "_view_module_version": "1.5.0",
            "_view_name": "HTMLView",
            "description": "",
            "description_tooltip": null,
            "layout": "IPY_MODEL_65750e3c06f04c8398d60f1eac22bad0",
            "placeholder": "​",
            "style": "IPY_MODEL_21ccad27efe2438ba6a42d16302f607f",
            "value": "Downloading (…)olve/main/merges.txt: 100%"
          }
        },
        "de846be5457d4d2f80e82fd545ee503a": {
          "model_module": "@jupyter-widgets/controls",
          "model_name": "FloatProgressModel",
          "model_module_version": "1.5.0",
          "state": {
            "_dom_classes": [],
            "_model_module": "@jupyter-widgets/controls",
            "_model_module_version": "1.5.0",
            "_model_name": "FloatProgressModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/controls",
            "_view_module_version": "1.5.0",
            "_view_name": "ProgressView",
            "bar_style": "success",
            "description": "",
            "description_tooltip": null,
            "layout": "IPY_MODEL_96e6231c5d6a4b5a8d1773ce8bc4b18d",
            "max": 524657,
            "min": 0,
            "orientation": "horizontal",
            "style": "IPY_MODEL_7ec0cd078d4941658ff25d51ffdbd71b",
            "value": 524657
          }
        },
        "077882c4cb444ef2a64595cbc0864d32": {
          "model_module": "@jupyter-widgets/controls",
          "model_name": "HTMLModel",
          "model_module_version": "1.5.0",
          "state": {
            "_dom_classes": [],
            "_model_module": "@jupyter-widgets/controls",
            "_model_module_version": "1.5.0",
            "_model_name": "HTMLModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/controls",
            "_view_module_version": "1.5.0",
            "_view_name": "HTMLView",
            "description": "",
            "description_tooltip": null,
            "layout": "IPY_MODEL_7365a635162f44a19e6ff136dbadbcb1",
            "placeholder": "​",
            "style": "IPY_MODEL_53da52afee264514bd4ee5fd0830d0b2",
            "value": " 525k/525k [00:01&lt;00:00, 484kB/s]"
          }
        },
        "e88f5086b08245fb8632c566c1f081e7": {
          "model_module": "@jupyter-widgets/base",
          "model_name": "LayoutModel",
          "model_module_version": "1.2.0",
          "state": {
            "_model_module": "@jupyter-widgets/base",
            "_model_module_version": "1.2.0",
            "_model_name": "LayoutModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/base",
            "_view_module_version": "1.2.0",
            "_view_name": "LayoutView",
            "align_content": null,
            "align_items": null,
            "align_self": null,
            "border": null,
            "bottom": null,
            "display": null,
            "flex": null,
            "flex_flow": null,
            "grid_area": null,
            "grid_auto_columns": null,
            "grid_auto_flow": null,
            "grid_auto_rows": null,
            "grid_column": null,
            "grid_gap": null,
            "grid_row": null,
            "grid_template_areas": null,
            "grid_template_columns": null,
            "grid_template_rows": null,
            "height": null,
            "justify_content": null,
            "justify_items": null,
            "left": null,
            "margin": null,
            "max_height": null,
            "max_width": null,
            "min_height": null,
            "min_width": null,
            "object_fit": null,
            "object_position": null,
            "order": null,
            "overflow": null,
            "overflow_x": null,
            "overflow_y": null,
            "padding": null,
            "right": null,
            "top": null,
            "visibility": null,
            "width": null
          }
        },
        "65750e3c06f04c8398d60f1eac22bad0": {
          "model_module": "@jupyter-widgets/base",
          "model_name": "LayoutModel",
          "model_module_version": "1.2.0",
          "state": {
            "_model_module": "@jupyter-widgets/base",
            "_model_module_version": "1.2.0",
            "_model_name": "LayoutModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/base",
            "_view_module_version": "1.2.0",
            "_view_name": "LayoutView",
            "align_content": null,
            "align_items": null,
            "align_self": null,
            "border": null,
            "bottom": null,
            "display": null,
            "flex": null,
            "flex_flow": null,
            "grid_area": null,
            "grid_auto_columns": null,
            "grid_auto_flow": null,
            "grid_auto_rows": null,
            "grid_column": null,
            "grid_gap": null,
            "grid_row": null,
            "grid_template_areas": null,
            "grid_template_columns": null,
            "grid_template_rows": null,
            "height": null,
            "justify_content": null,
            "justify_items": null,
            "left": null,
            "margin": null,
            "max_height": null,
            "max_width": null,
            "min_height": null,
            "min_width": null,
            "object_fit": null,
            "object_position": null,
            "order": null,
            "overflow": null,
            "overflow_x": null,
            "overflow_y": null,
            "padding": null,
            "right": null,
            "top": null,
            "visibility": null,
            "width": null
          }
        },
        "21ccad27efe2438ba6a42d16302f607f": {
          "model_module": "@jupyter-widgets/controls",
          "model_name": "DescriptionStyleModel",
          "model_module_version": "1.5.0",
          "state": {
            "_model_module": "@jupyter-widgets/controls",
            "_model_module_version": "1.5.0",
            "_model_name": "DescriptionStyleModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/base",
            "_view_module_version": "1.2.0",
            "_view_name": "StyleView",
            "description_width": ""
          }
        },
        "96e6231c5d6a4b5a8d1773ce8bc4b18d": {
          "model_module": "@jupyter-widgets/base",
          "model_name": "LayoutModel",
          "model_module_version": "1.2.0",
          "state": {
            "_model_module": "@jupyter-widgets/base",
            "_model_module_version": "1.2.0",
            "_model_name": "LayoutModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/base",
            "_view_module_version": "1.2.0",
            "_view_name": "LayoutView",
            "align_content": null,
            "align_items": null,
            "align_self": null,
            "border": null,
            "bottom": null,
            "display": null,
            "flex": null,
            "flex_flow": null,
            "grid_area": null,
            "grid_auto_columns": null,
            "grid_auto_flow": null,
            "grid_auto_rows": null,
            "grid_column": null,
            "grid_gap": null,
            "grid_row": null,
            "grid_template_areas": null,
            "grid_template_columns": null,
            "grid_template_rows": null,
            "height": null,
            "justify_content": null,
            "justify_items": null,
            "left": null,
            "margin": null,
            "max_height": null,
            "max_width": null,
            "min_height": null,
            "min_width": null,
            "object_fit": null,
            "object_position": null,
            "order": null,
            "overflow": null,
            "overflow_x": null,
            "overflow_y": null,
            "padding": null,
            "right": null,
            "top": null,
            "visibility": null,
            "width": null
          }
        },
        "7ec0cd078d4941658ff25d51ffdbd71b": {
          "model_module": "@jupyter-widgets/controls",
          "model_name": "ProgressStyleModel",
          "model_module_version": "1.5.0",
          "state": {
            "_model_module": "@jupyter-widgets/controls",
            "_model_module_version": "1.5.0",
            "_model_name": "ProgressStyleModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/base",
            "_view_module_version": "1.2.0",
            "_view_name": "StyleView",
            "bar_color": null,
            "description_width": ""
          }
        },
        "7365a635162f44a19e6ff136dbadbcb1": {
          "model_module": "@jupyter-widgets/base",
          "model_name": "LayoutModel",
          "model_module_version": "1.2.0",
          "state": {
            "_model_module": "@jupyter-widgets/base",
            "_model_module_version": "1.2.0",
            "_model_name": "LayoutModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/base",
            "_view_module_version": "1.2.0",
            "_view_name": "LayoutView",
            "align_content": null,
            "align_items": null,
            "align_self": null,
            "border": null,
            "bottom": null,
            "display": null,
            "flex": null,
            "flex_flow": null,
            "grid_area": null,
            "grid_auto_columns": null,
            "grid_auto_flow": null,
            "grid_auto_rows": null,
            "grid_column": null,
            "grid_gap": null,
            "grid_row": null,
            "grid_template_areas": null,
            "grid_template_columns": null,
            "grid_template_rows": null,
            "height": null,
            "justify_content": null,
            "justify_items": null,
            "left": null,
            "margin": null,
            "max_height": null,
            "max_width": null,
            "min_height": null,
            "min_width": null,
            "object_fit": null,
            "object_position": null,
            "order": null,
            "overflow": null,
            "overflow_x": null,
            "overflow_y": null,
            "padding": null,
            "right": null,
            "top": null,
            "visibility": null,
            "width": null
          }
        },
        "53da52afee264514bd4ee5fd0830d0b2": {
          "model_module": "@jupyter-widgets/controls",
          "model_name": "DescriptionStyleModel",
          "model_module_version": "1.5.0",
          "state": {
            "_model_module": "@jupyter-widgets/controls",
            "_model_module_version": "1.5.0",
            "_model_name": "DescriptionStyleModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/base",
            "_view_module_version": "1.2.0",
            "_view_name": "StyleView",
            "description_width": ""
          }
        },
        "5faa15162b6c4c39ae121ecd891816f6": {
          "model_module": "@jupyter-widgets/controls",
          "model_name": "HBoxModel",
          "model_module_version": "1.5.0",
          "state": {
            "_dom_classes": [],
            "_model_module": "@jupyter-widgets/controls",
            "_model_module_version": "1.5.0",
            "_model_name": "HBoxModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/controls",
            "_view_module_version": "1.5.0",
            "_view_name": "HBoxView",
            "box_style": "",
            "children": [
              "IPY_MODEL_7c210be738214309b000dc62cd0c6a02",
              "IPY_MODEL_e2d5426f9d9f4e90822ea13ffb9db839",
              "IPY_MODEL_4efd197140874b739d9b3e4b94b74abb"
            ],
            "layout": "IPY_MODEL_1a415954ed0d43e294e68b44680965d8"
          }
        },
        "7c210be738214309b000dc62cd0c6a02": {
          "model_module": "@jupyter-widgets/controls",
          "model_name": "HTMLModel",
          "model_module_version": "1.5.0",
          "state": {
            "_dom_classes": [],
            "_model_module": "@jupyter-widgets/controls",
            "_model_module_version": "1.5.0",
            "_model_name": "HTMLModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/controls",
            "_view_module_version": "1.5.0",
            "_view_name": "HTMLView",
            "description": "",
            "description_tooltip": null,
            "layout": "IPY_MODEL_3ce7ec3c098f4497a705bd4718bed68b",
            "placeholder": "​",
            "style": "IPY_MODEL_3a127010c12042b0b60e42a637f7bbef",
            "value": "Downloading (…)/main/tokenizer.json: 100%"
          }
        },
        "e2d5426f9d9f4e90822ea13ffb9db839": {
          "model_module": "@jupyter-widgets/controls",
          "model_name": "FloatProgressModel",
          "model_module_version": "1.5.0",
          "state": {
            "_dom_classes": [],
            "_model_module": "@jupyter-widgets/controls",
            "_model_module_version": "1.5.0",
            "_model_name": "FloatProgressModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/controls",
            "_view_module_version": "1.5.0",
            "_view_name": "ProgressView",
            "bar_style": "success",
            "description": "",
            "description_tooltip": null,
            "layout": "IPY_MODEL_96dd8dbf37b44570980f754e6fefbed1",
            "max": 2224041,
            "min": 0,
            "orientation": "horizontal",
            "style": "IPY_MODEL_a2a34b9053694ed580b100a51590f462",
            "value": 2224041
          }
        },
        "4efd197140874b739d9b3e4b94b74abb": {
          "model_module": "@jupyter-widgets/controls",
          "model_name": "HTMLModel",
          "model_module_version": "1.5.0",
          "state": {
            "_dom_classes": [],
            "_model_module": "@jupyter-widgets/controls",
            "_model_module_version": "1.5.0",
            "_model_name": "HTMLModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/controls",
            "_view_module_version": "1.5.0",
            "_view_name": "HTMLView",
            "description": "",
            "description_tooltip": null,
            "layout": "IPY_MODEL_00674bc8606340b481ef53319b179472",
            "placeholder": "​",
            "style": "IPY_MODEL_487b74da65574775a48922af522f2b0c",
            "value": " 2.22M/2.22M [00:01&lt;00:00, 1.47MB/s]"
          }
        },
        "1a415954ed0d43e294e68b44680965d8": {
          "model_module": "@jupyter-widgets/base",
          "model_name": "LayoutModel",
          "model_module_version": "1.2.0",
          "state": {
            "_model_module": "@jupyter-widgets/base",
            "_model_module_version": "1.2.0",
            "_model_name": "LayoutModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/base",
            "_view_module_version": "1.2.0",
            "_view_name": "LayoutView",
            "align_content": null,
            "align_items": null,
            "align_self": null,
            "border": null,
            "bottom": null,
            "display": null,
            "flex": null,
            "flex_flow": null,
            "grid_area": null,
            "grid_auto_columns": null,
            "grid_auto_flow": null,
            "grid_auto_rows": null,
            "grid_column": null,
            "grid_gap": null,
            "grid_row": null,
            "grid_template_areas": null,
            "grid_template_columns": null,
            "grid_template_rows": null,
            "height": null,
            "justify_content": null,
            "justify_items": null,
            "left": null,
            "margin": null,
            "max_height": null,
            "max_width": null,
            "min_height": null,
            "min_width": null,
            "object_fit": null,
            "object_position": null,
            "order": null,
            "overflow": null,
            "overflow_x": null,
            "overflow_y": null,
            "padding": null,
            "right": null,
            "top": null,
            "visibility": null,
            "width": null
          }
        },
        "3ce7ec3c098f4497a705bd4718bed68b": {
          "model_module": "@jupyter-widgets/base",
          "model_name": "LayoutModel",
          "model_module_version": "1.2.0",
          "state": {
            "_model_module": "@jupyter-widgets/base",
            "_model_module_version": "1.2.0",
            "_model_name": "LayoutModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/base",
            "_view_module_version": "1.2.0",
            "_view_name": "LayoutView",
            "align_content": null,
            "align_items": null,
            "align_self": null,
            "border": null,
            "bottom": null,
            "display": null,
            "flex": null,
            "flex_flow": null,
            "grid_area": null,
            "grid_auto_columns": null,
            "grid_auto_flow": null,
            "grid_auto_rows": null,
            "grid_column": null,
            "grid_gap": null,
            "grid_row": null,
            "grid_template_areas": null,
            "grid_template_columns": null,
            "grid_template_rows": null,
            "height": null,
            "justify_content": null,
            "justify_items": null,
            "left": null,
            "margin": null,
            "max_height": null,
            "max_width": null,
            "min_height": null,
            "min_width": null,
            "object_fit": null,
            "object_position": null,
            "order": null,
            "overflow": null,
            "overflow_x": null,
            "overflow_y": null,
            "padding": null,
            "right": null,
            "top": null,
            "visibility": null,
            "width": null
          }
        },
        "3a127010c12042b0b60e42a637f7bbef": {
          "model_module": "@jupyter-widgets/controls",
          "model_name": "DescriptionStyleModel",
          "model_module_version": "1.5.0",
          "state": {
            "_model_module": "@jupyter-widgets/controls",
            "_model_module_version": "1.5.0",
            "_model_name": "DescriptionStyleModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/base",
            "_view_module_version": "1.2.0",
            "_view_name": "StyleView",
            "description_width": ""
          }
        },
        "96dd8dbf37b44570980f754e6fefbed1": {
          "model_module": "@jupyter-widgets/base",
          "model_name": "LayoutModel",
          "model_module_version": "1.2.0",
          "state": {
            "_model_module": "@jupyter-widgets/base",
            "_model_module_version": "1.2.0",
            "_model_name": "LayoutModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/base",
            "_view_module_version": "1.2.0",
            "_view_name": "LayoutView",
            "align_content": null,
            "align_items": null,
            "align_self": null,
            "border": null,
            "bottom": null,
            "display": null,
            "flex": null,
            "flex_flow": null,
            "grid_area": null,
            "grid_auto_columns": null,
            "grid_auto_flow": null,
            "grid_auto_rows": null,
            "grid_column": null,
            "grid_gap": null,
            "grid_row": null,
            "grid_template_areas": null,
            "grid_template_columns": null,
            "grid_template_rows": null,
            "height": null,
            "justify_content": null,
            "justify_items": null,
            "left": null,
            "margin": null,
            "max_height": null,
            "max_width": null,
            "min_height": null,
            "min_width": null,
            "object_fit": null,
            "object_position": null,
            "order": null,
            "overflow": null,
            "overflow_x": null,
            "overflow_y": null,
            "padding": null,
            "right": null,
            "top": null,
            "visibility": null,
            "width": null
          }
        },
        "a2a34b9053694ed580b100a51590f462": {
          "model_module": "@jupyter-widgets/controls",
          "model_name": "ProgressStyleModel",
          "model_module_version": "1.5.0",
          "state": {
            "_model_module": "@jupyter-widgets/controls",
            "_model_module_version": "1.5.0",
            "_model_name": "ProgressStyleModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/base",
            "_view_module_version": "1.2.0",
            "_view_name": "StyleView",
            "bar_color": null,
            "description_width": ""
          }
        },
        "00674bc8606340b481ef53319b179472": {
          "model_module": "@jupyter-widgets/base",
          "model_name": "LayoutModel",
          "model_module_version": "1.2.0",
          "state": {
            "_model_module": "@jupyter-widgets/base",
            "_model_module_version": "1.2.0",
            "_model_name": "LayoutModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/base",
            "_view_module_version": "1.2.0",
            "_view_name": "LayoutView",
            "align_content": null,
            "align_items": null,
            "align_self": null,
            "border": null,
            "bottom": null,
            "display": null,
            "flex": null,
            "flex_flow": null,
            "grid_area": null,
            "grid_auto_columns": null,
            "grid_auto_flow": null,
            "grid_auto_rows": null,
            "grid_column": null,
            "grid_gap": null,
            "grid_row": null,
            "grid_template_areas": null,
            "grid_template_columns": null,
            "grid_template_rows": null,
            "height": null,
            "justify_content": null,
            "justify_items": null,
            "left": null,
            "margin": null,
            "max_height": null,
            "max_width": null,
            "min_height": null,
            "min_width": null,
            "object_fit": null,
            "object_position": null,
            "order": null,
            "overflow": null,
            "overflow_x": null,
            "overflow_y": null,
            "padding": null,
            "right": null,
            "top": null,
            "visibility": null,
            "width": null
          }
        },
        "487b74da65574775a48922af522f2b0c": {
          "model_module": "@jupyter-widgets/controls",
          "model_name": "DescriptionStyleModel",
          "model_module_version": "1.5.0",
          "state": {
            "_model_module": "@jupyter-widgets/controls",
            "_model_module_version": "1.5.0",
            "_model_name": "DescriptionStyleModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/base",
            "_view_module_version": "1.2.0",
            "_view_name": "StyleView",
            "description_width": ""
          }
        },
        "5a9243a85b484d3b8e7197c4d77e0f3a": {
          "model_module": "@jupyter-widgets/controls",
          "model_name": "HBoxModel",
          "model_module_version": "1.5.0",
          "state": {
            "_dom_classes": [],
            "_model_module": "@jupyter-widgets/controls",
            "_model_module_version": "1.5.0",
            "_model_name": "HBoxModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/controls",
            "_view_module_version": "1.5.0",
            "_view_name": "HBoxView",
            "box_style": "",
            "children": [
              "IPY_MODEL_e0d2608de2ed433f8d33f79c457761f2",
              "IPY_MODEL_fab0b7e87b7f46ef9e6a61abcaeb0e1c",
              "IPY_MODEL_6935884281e0441e8ba020af6e1654a7"
            ],
            "layout": "IPY_MODEL_fc85369e35e14c9090f00d6013e95a34"
          }
        },
        "e0d2608de2ed433f8d33f79c457761f2": {
          "model_module": "@jupyter-widgets/controls",
          "model_name": "HTMLModel",
          "model_module_version": "1.5.0",
          "state": {
            "_dom_classes": [],
            "_model_module": "@jupyter-widgets/controls",
            "_model_module_version": "1.5.0",
            "_model_name": "HTMLModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/controls",
            "_view_module_version": "1.5.0",
            "_view_name": "HTMLView",
            "description": "",
            "description_tooltip": null,
            "layout": "IPY_MODEL_963543d2015a4e6e87e03facc1b08e10",
            "placeholder": "​",
            "style": "IPY_MODEL_becb77eee8e847fb9901173d65201acb",
            "value": "Downloading (…)cial_tokens_map.json: 100%"
          }
        },
        "fab0b7e87b7f46ef9e6a61abcaeb0e1c": {
          "model_module": "@jupyter-widgets/controls",
          "model_name": "FloatProgressModel",
          "model_module_version": "1.5.0",
          "state": {
            "_dom_classes": [],
            "_model_module": "@jupyter-widgets/controls",
            "_model_module_version": "1.5.0",
            "_model_name": "FloatProgressModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/controls",
            "_view_module_version": "1.5.0",
            "_view_name": "ProgressView",
            "bar_style": "success",
            "description": "",
            "description_tooltip": null,
            "layout": "IPY_MODEL_2d420782335448a58a9c2fb157088181",
            "max": 389,
            "min": 0,
            "orientation": "horizontal",
            "style": "IPY_MODEL_cb86fd939c2643c9823210738e53536c",
            "value": 389
          }
        },
        "6935884281e0441e8ba020af6e1654a7": {
          "model_module": "@jupyter-widgets/controls",
          "model_name": "HTMLModel",
          "model_module_version": "1.5.0",
          "state": {
            "_dom_classes": [],
            "_model_module": "@jupyter-widgets/controls",
            "_model_module_version": "1.5.0",
            "_model_name": "HTMLModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/controls",
            "_view_module_version": "1.5.0",
            "_view_name": "HTMLView",
            "description": "",
            "description_tooltip": null,
            "layout": "IPY_MODEL_7ac372a7a43c4d73ae4a3f6124510a9f",
            "placeholder": "​",
            "style": "IPY_MODEL_886619927d5e476b8e72a264f44b71fe",
            "value": " 389/389 [00:00&lt;00:00, 6.27kB/s]"
          }
        },
        "fc85369e35e14c9090f00d6013e95a34": {
          "model_module": "@jupyter-widgets/base",
          "model_name": "LayoutModel",
          "model_module_version": "1.2.0",
          "state": {
            "_model_module": "@jupyter-widgets/base",
            "_model_module_version": "1.2.0",
            "_model_name": "LayoutModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/base",
            "_view_module_version": "1.2.0",
            "_view_name": "LayoutView",
            "align_content": null,
            "align_items": null,
            "align_self": null,
            "border": null,
            "bottom": null,
            "display": null,
            "flex": null,
            "flex_flow": null,
            "grid_area": null,
            "grid_auto_columns": null,
            "grid_auto_flow": null,
            "grid_auto_rows": null,
            "grid_column": null,
            "grid_gap": null,
            "grid_row": null,
            "grid_template_areas": null,
            "grid_template_columns": null,
            "grid_template_rows": null,
            "height": null,
            "justify_content": null,
            "justify_items": null,
            "left": null,
            "margin": null,
            "max_height": null,
            "max_width": null,
            "min_height": null,
            "min_width": null,
            "object_fit": null,
            "object_position": null,
            "order": null,
            "overflow": null,
            "overflow_x": null,
            "overflow_y": null,
            "padding": null,
            "right": null,
            "top": null,
            "visibility": null,
            "width": null
          }
        },
        "963543d2015a4e6e87e03facc1b08e10": {
          "model_module": "@jupyter-widgets/base",
          "model_name": "LayoutModel",
          "model_module_version": "1.2.0",
          "state": {
            "_model_module": "@jupyter-widgets/base",
            "_model_module_version": "1.2.0",
            "_model_name": "LayoutModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/base",
            "_view_module_version": "1.2.0",
            "_view_name": "LayoutView",
            "align_content": null,
            "align_items": null,
            "align_self": null,
            "border": null,
            "bottom": null,
            "display": null,
            "flex": null,
            "flex_flow": null,
            "grid_area": null,
            "grid_auto_columns": null,
            "grid_auto_flow": null,
            "grid_auto_rows": null,
            "grid_column": null,
            "grid_gap": null,
            "grid_row": null,
            "grid_template_areas": null,
            "grid_template_columns": null,
            "grid_template_rows": null,
            "height": null,
            "justify_content": null,
            "justify_items": null,
            "left": null,
            "margin": null,
            "max_height": null,
            "max_width": null,
            "min_height": null,
            "min_width": null,
            "object_fit": null,
            "object_position": null,
            "order": null,
            "overflow": null,
            "overflow_x": null,
            "overflow_y": null,
            "padding": null,
            "right": null,
            "top": null,
            "visibility": null,
            "width": null
          }
        },
        "becb77eee8e847fb9901173d65201acb": {
          "model_module": "@jupyter-widgets/controls",
          "model_name": "DescriptionStyleModel",
          "model_module_version": "1.5.0",
          "state": {
            "_model_module": "@jupyter-widgets/controls",
            "_model_module_version": "1.5.0",
            "_model_name": "DescriptionStyleModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/base",
            "_view_module_version": "1.2.0",
            "_view_name": "StyleView",
            "description_width": ""
          }
        },
        "2d420782335448a58a9c2fb157088181": {
          "model_module": "@jupyter-widgets/base",
          "model_name": "LayoutModel",
          "model_module_version": "1.2.0",
          "state": {
            "_model_module": "@jupyter-widgets/base",
            "_model_module_version": "1.2.0",
            "_model_name": "LayoutModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/base",
            "_view_module_version": "1.2.0",
            "_view_name": "LayoutView",
            "align_content": null,
            "align_items": null,
            "align_self": null,
            "border": null,
            "bottom": null,
            "display": null,
            "flex": null,
            "flex_flow": null,
            "grid_area": null,
            "grid_auto_columns": null,
            "grid_auto_flow": null,
            "grid_auto_rows": null,
            "grid_column": null,
            "grid_gap": null,
            "grid_row": null,
            "grid_template_areas": null,
            "grid_template_columns": null,
            "grid_template_rows": null,
            "height": null,
            "justify_content": null,
            "justify_items": null,
            "left": null,
            "margin": null,
            "max_height": null,
            "max_width": null,
            "min_height": null,
            "min_width": null,
            "object_fit": null,
            "object_position": null,
            "order": null,
            "overflow": null,
            "overflow_x": null,
            "overflow_y": null,
            "padding": null,
            "right": null,
            "top": null,
            "visibility": null,
            "width": null
          }
        },
        "cb86fd939c2643c9823210738e53536c": {
          "model_module": "@jupyter-widgets/controls",
          "model_name": "ProgressStyleModel",
          "model_module_version": "1.5.0",
          "state": {
            "_model_module": "@jupyter-widgets/controls",
            "_model_module_version": "1.5.0",
            "_model_name": "ProgressStyleModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/base",
            "_view_module_version": "1.2.0",
            "_view_name": "StyleView",
            "bar_color": null,
            "description_width": ""
          }
        },
        "7ac372a7a43c4d73ae4a3f6124510a9f": {
          "model_module": "@jupyter-widgets/base",
          "model_name": "LayoutModel",
          "model_module_version": "1.2.0",
          "state": {
            "_model_module": "@jupyter-widgets/base",
            "_model_module_version": "1.2.0",
            "_model_name": "LayoutModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/base",
            "_view_module_version": "1.2.0",
            "_view_name": "LayoutView",
            "align_content": null,
            "align_items": null,
            "align_self": null,
            "border": null,
            "bottom": null,
            "display": null,
            "flex": null,
            "flex_flow": null,
            "grid_area": null,
            "grid_auto_columns": null,
            "grid_auto_flow": null,
            "grid_auto_rows": null,
            "grid_column": null,
            "grid_gap": null,
            "grid_row": null,
            "grid_template_areas": null,
            "grid_template_columns": null,
            "grid_template_rows": null,
            "height": null,
            "justify_content": null,
            "justify_items": null,
            "left": null,
            "margin": null,
            "max_height": null,
            "max_width": null,
            "min_height": null,
            "min_width": null,
            "object_fit": null,
            "object_position": null,
            "order": null,
            "overflow": null,
            "overflow_x": null,
            "overflow_y": null,
            "padding": null,
            "right": null,
            "top": null,
            "visibility": null,
            "width": null
          }
        },
        "886619927d5e476b8e72a264f44b71fe": {
          "model_module": "@jupyter-widgets/controls",
          "model_name": "DescriptionStyleModel",
          "model_module_version": "1.5.0",
          "state": {
            "_model_module": "@jupyter-widgets/controls",
            "_model_module_version": "1.5.0",
            "_model_name": "DescriptionStyleModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/base",
            "_view_module_version": "1.2.0",
            "_view_name": "StyleView",
            "description_width": ""
          }
        },
        "69599ecc5ba845418b9d297963ea73f6": {
          "model_module": "@jupyter-widgets/controls",
          "model_name": "HBoxModel",
          "model_module_version": "1.5.0",
          "state": {
            "_dom_classes": [],
            "_model_module": "@jupyter-widgets/controls",
            "_model_module_version": "1.5.0",
            "_model_name": "HBoxModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/controls",
            "_view_module_version": "1.5.0",
            "_view_name": "HBoxView",
            "box_style": "",
            "children": [
              "IPY_MODEL_01131cf984f34bf19ec61b444249084e",
              "IPY_MODEL_6f44a9a165364667b9e2f86fd585a794",
              "IPY_MODEL_6e3b0a70a0724ccfa9cfb917b238c405"
            ],
            "layout": "IPY_MODEL_f48d63a5d0bc467faee427f147567b66"
          }
        },
        "01131cf984f34bf19ec61b444249084e": {
          "model_module": "@jupyter-widgets/controls",
          "model_name": "HTMLModel",
          "model_module_version": "1.5.0",
          "state": {
            "_dom_classes": [],
            "_model_module": "@jupyter-widgets/controls",
            "_model_module_version": "1.5.0",
            "_model_name": "HTMLModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/controls",
            "_view_module_version": "1.5.0",
            "_view_name": "HTMLView",
            "description": "",
            "description_tooltip": null,
            "layout": "IPY_MODEL_a578b9741c8d45da822a7222b6da4d21",
            "placeholder": "​",
            "style": "IPY_MODEL_b46e7205d2d14945b8cefbf66e522559",
            "value": "Downloading (…)&quot;pytorch_model.bin&quot;;: 100%"
          }
        },
        "6f44a9a165364667b9e2f86fd585a794": {
          "model_module": "@jupyter-widgets/controls",
          "model_name": "FloatProgressModel",
          "model_module_version": "1.5.0",
          "state": {
            "_dom_classes": [],
            "_model_module": "@jupyter-widgets/controls",
            "_model_module_version": "1.5.0",
            "_model_name": "FloatProgressModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/controls",
            "_view_module_version": "1.5.0",
            "_view_name": "ProgressView",
            "bar_style": "success",
            "description": "",
            "description_tooltip": null,
            "layout": "IPY_MODEL_2376e85f817b40feb5715fdedd126406",
            "max": 605247071,
            "min": 0,
            "orientation": "horizontal",
            "style": "IPY_MODEL_c688c66d7b604e73b8785a1f952b9a4a",
            "value": 605247071
          }
        },
        "6e3b0a70a0724ccfa9cfb917b238c405": {
          "model_module": "@jupyter-widgets/controls",
          "model_name": "HTMLModel",
          "model_module_version": "1.5.0",
          "state": {
            "_dom_classes": [],
            "_model_module": "@jupyter-widgets/controls",
            "_model_module_version": "1.5.0",
            "_model_name": "HTMLModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/controls",
            "_view_module_version": "1.5.0",
            "_view_name": "HTMLView",
            "description": "",
            "description_tooltip": null,
            "layout": "IPY_MODEL_96f023f840f24e6db5a3439e1bee8308",
            "placeholder": "​",
            "style": "IPY_MODEL_5e4c76bc097f48dcb2a112313fb14507",
            "value": " 605M/605M [00:03&lt;00:00, 128MB/s]"
          }
        },
        "f48d63a5d0bc467faee427f147567b66": {
          "model_module": "@jupyter-widgets/base",
          "model_name": "LayoutModel",
          "model_module_version": "1.2.0",
          "state": {
            "_model_module": "@jupyter-widgets/base",
            "_model_module_version": "1.2.0",
            "_model_name": "LayoutModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/base",
            "_view_module_version": "1.2.0",
            "_view_name": "LayoutView",
            "align_content": null,
            "align_items": null,
            "align_self": null,
            "border": null,
            "bottom": null,
            "display": null,
            "flex": null,
            "flex_flow": null,
            "grid_area": null,
            "grid_auto_columns": null,
            "grid_auto_flow": null,
            "grid_auto_rows": null,
            "grid_column": null,
            "grid_gap": null,
            "grid_row": null,
            "grid_template_areas": null,
            "grid_template_columns": null,
            "grid_template_rows": null,
            "height": null,
            "justify_content": null,
            "justify_items": null,
            "left": null,
            "margin": null,
            "max_height": null,
            "max_width": null,
            "min_height": null,
            "min_width": null,
            "object_fit": null,
            "object_position": null,
            "order": null,
            "overflow": null,
            "overflow_x": null,
            "overflow_y": null,
            "padding": null,
            "right": null,
            "top": null,
            "visibility": null,
            "width": null
          }
        },
        "a578b9741c8d45da822a7222b6da4d21": {
          "model_module": "@jupyter-widgets/base",
          "model_name": "LayoutModel",
          "model_module_version": "1.2.0",
          "state": {
            "_model_module": "@jupyter-widgets/base",
            "_model_module_version": "1.2.0",
            "_model_name": "LayoutModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/base",
            "_view_module_version": "1.2.0",
            "_view_name": "LayoutView",
            "align_content": null,
            "align_items": null,
            "align_self": null,
            "border": null,
            "bottom": null,
            "display": null,
            "flex": null,
            "flex_flow": null,
            "grid_area": null,
            "grid_auto_columns": null,
            "grid_auto_flow": null,
            "grid_auto_rows": null,
            "grid_column": null,
            "grid_gap": null,
            "grid_row": null,
            "grid_template_areas": null,
            "grid_template_columns": null,
            "grid_template_rows": null,
            "height": null,
            "justify_content": null,
            "justify_items": null,
            "left": null,
            "margin": null,
            "max_height": null,
            "max_width": null,
            "min_height": null,
            "min_width": null,
            "object_fit": null,
            "object_position": null,
            "order": null,
            "overflow": null,
            "overflow_x": null,
            "overflow_y": null,
            "padding": null,
            "right": null,
            "top": null,
            "visibility": null,
            "width": null
          }
        },
        "b46e7205d2d14945b8cefbf66e522559": {
          "model_module": "@jupyter-widgets/controls",
          "model_name": "DescriptionStyleModel",
          "model_module_version": "1.5.0",
          "state": {
            "_model_module": "@jupyter-widgets/controls",
            "_model_module_version": "1.5.0",
            "_model_name": "DescriptionStyleModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/base",
            "_view_module_version": "1.2.0",
            "_view_name": "StyleView",
            "description_width": ""
          }
        },
        "2376e85f817b40feb5715fdedd126406": {
          "model_module": "@jupyter-widgets/base",
          "model_name": "LayoutModel",
          "model_module_version": "1.2.0",
          "state": {
            "_model_module": "@jupyter-widgets/base",
            "_model_module_version": "1.2.0",
            "_model_name": "LayoutModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/base",
            "_view_module_version": "1.2.0",
            "_view_name": "LayoutView",
            "align_content": null,
            "align_items": null,
            "align_self": null,
            "border": null,
            "bottom": null,
            "display": null,
            "flex": null,
            "flex_flow": null,
            "grid_area": null,
            "grid_auto_columns": null,
            "grid_auto_flow": null,
            "grid_auto_rows": null,
            "grid_column": null,
            "grid_gap": null,
            "grid_row": null,
            "grid_template_areas": null,
            "grid_template_columns": null,
            "grid_template_rows": null,
            "height": null,
            "justify_content": null,
            "justify_items": null,
            "left": null,
            "margin": null,
            "max_height": null,
            "max_width": null,
            "min_height": null,
            "min_width": null,
            "object_fit": null,
            "object_position": null,
            "order": null,
            "overflow": null,
            "overflow_x": null,
            "overflow_y": null,
            "padding": null,
            "right": null,
            "top": null,
            "visibility": null,
            "width": null
          }
        },
        "c688c66d7b604e73b8785a1f952b9a4a": {
          "model_module": "@jupyter-widgets/controls",
          "model_name": "ProgressStyleModel",
          "model_module_version": "1.5.0",
          "state": {
            "_model_module": "@jupyter-widgets/controls",
            "_model_module_version": "1.5.0",
            "_model_name": "ProgressStyleModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/base",
            "_view_module_version": "1.2.0",
            "_view_name": "StyleView",
            "bar_color": null,
            "description_width": ""
          }
        },
        "96f023f840f24e6db5a3439e1bee8308": {
          "model_module": "@jupyter-widgets/base",
          "model_name": "LayoutModel",
          "model_module_version": "1.2.0",
          "state": {
            "_model_module": "@jupyter-widgets/base",
            "_model_module_version": "1.2.0",
            "_model_name": "LayoutModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/base",
            "_view_module_version": "1.2.0",
            "_view_name": "LayoutView",
            "align_content": null,
            "align_items": null,
            "align_self": null,
            "border": null,
            "bottom": null,
            "display": null,
            "flex": null,
            "flex_flow": null,
            "grid_area": null,
            "grid_auto_columns": null,
            "grid_auto_flow": null,
            "grid_auto_rows": null,
            "grid_column": null,
            "grid_gap": null,
            "grid_row": null,
            "grid_template_areas": null,
            "grid_template_columns": null,
            "grid_template_rows": null,
            "height": null,
            "justify_content": null,
            "justify_items": null,
            "left": null,
            "margin": null,
            "max_height": null,
            "max_width": null,
            "min_height": null,
            "min_width": null,
            "object_fit": null,
            "object_position": null,
            "order": null,
            "overflow": null,
            "overflow_x": null,
            "overflow_y": null,
            "padding": null,
            "right": null,
            "top": null,
            "visibility": null,
            "width": null
          }
        },
        "5e4c76bc097f48dcb2a112313fb14507": {
          "model_module": "@jupyter-widgets/controls",
          "model_name": "DescriptionStyleModel",
          "model_module_version": "1.5.0",
          "state": {
            "_model_module": "@jupyter-widgets/controls",
            "_model_module_version": "1.5.0",
            "_model_name": "DescriptionStyleModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/base",
            "_view_module_version": "1.2.0",
            "_view_name": "StyleView",
            "description_width": ""
          }
        }
      }
    }
  },
  "nbformat": 4,
  "nbformat_minor": 0
}