VQA_Transformers.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "OOSjmpMw5gxy"
   },
   "source": [
    "## 0. Download dataset\n",
    "**Note:** If you can't download using gdown due to limited number of downloads, please download it manually and upload it to your drive, then copy it from the drive to colab.\n",
    "```python\n",
    "from google.colab import drive\n",
    "\n",
    "drive.mount('/content/drive')\n",
    "!cp /path/to/dataset/on/your/drive .\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "94MQBB3h9WT_",
    "outputId": "a034a682-f3fb-4523-a34f-fd99e944c750"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "/usr/local/lib/python3.10/dist-packages/gdown/cli.py:121: FutureWarning: Option `--id` was deprecated in version 4.3.1 and will be removed in 5.0. You don't need to pass it anymore to use a file ID.\n",
      "  warnings.warn(\n",
      "Downloading...\n",
      "From: https://drive.google.com/uc?id=1kc6XNqHZJg27KeBuoAoYj70_1rT92191\n",
      "To: /content/vqa_coco_dataset.zip\n",
      "100% 196M/196M [00:03<00:00, 62.6MB/s]\n"
     ]
    }
   ],
   "source": [
    "# https://drive.google.com/file/d/1kc6XNqHZJg27KeBuoAoYj70_1rT92191/view?usp=sharing\n",
    "!gdown --id 1kc6XNqHZJg27KeBuoAoYj70_1rT92191"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "rb5Rh0fGAStN"
   },
   "outputs": [],
   "source": [
    "!unzip -q vqa_coco_dataset.zip"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "VljPGwOLCGoj"
   },
   "source": [
    "## 1. Import libraries"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "KDAACoro5r38",
    "outputId": "88c3480a-b8c8-4683-f689-c1f8dfb39821",
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\u001b[2K     \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m2.2/2.2 MB\u001b[0m \u001b[31m10.9 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
      "\u001b[?25h"
     ]
    }
   ],
   "source": [
    "!pip install timm -q"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "id": "zwmJUbxKCPjS",
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "import torch\n",
    "import torch.nn as nn\n",
    "import torchtext\n",
    "import os\n",
    "import numpy as np\n",
    "import pandas as pd\n",
    "import spacy\n",
    "import timm\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "from PIL import Image\n",
    "from torch.utils.data import Dataset, DataLoader\n",
    "from sklearn.model_selection import train_test_split\n",
    "from torchtext.data.utils import get_tokenizer\n",
    "from torchtext.vocab import build_vocab_from_iterator\n",
    "from torchvision import transforms\n",
    "from transformers import ViTModel, ViTImageProcessor\n",
    "from transformers import AutoTokenizer, RobertaModel"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "Iu20gzLxCu2y"
   },
   "source": [
    "## 2. Read dataset"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "id": "ZOxeYUBvCSki"
   },
   "outputs": [],
   "source": [
    "train_data = []\n",
    "train_set_path = 'datasets/vaq2.0.TrainImages.txt'\n",
    "\n",
    "with open(train_set_path, \"r\") as f:\n",
    "    lines = f.readlines()\n",
    "    for line in lines:\n",
    "        temp = line.split('\\t')\n",
    "        qa = temp[1].split('?')\n",
    "\n",
    "        if len(qa) == 3:\n",
    "            answer = qa[2].strip()\n",
    "        else:\n",
    "            answer = qa[1].strip()\n",
    "\n",
    "        data_sample = {\n",
    "            'image_path': temp[0][:-2],\n",
    "            'question': qa[0] + '?',\n",
    "            'answer': answer\n",
    "        }\n",
    "        train_data.append(data_sample)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "id": "EiZ7OwSfCrKa"
   },
   "outputs": [],
   "source": [
    "val_data = []\n",
    "val_set_path = 'datasets/vaq2.0.DevImages.txt'\n",
    "\n",
    "with open(val_set_path, \"r\") as f:\n",
    "    lines = f.readlines()\n",
    "    for line in lines:\n",
    "        temp = line.split('\\t')\n",
    "        qa = temp[1].split('?')\n",
    "\n",
    "        if len(qa) == 3:\n",
    "            answer = qa[2].strip()\n",
    "        else:\n",
    "            answer = qa[1].strip()\n",
    "\n",
    "        data_sample = {\n",
    "            'image_path': temp[0][:-2],\n",
    "            'question': qa[0] + '?',\n",
    "            'answer': answer\n",
    "        }\n",
    "        val_data.append(data_sample)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "id": "ZoX0dQbjEx53"
   },
   "outputs": [],
   "source": [
    "test_data = []\n",
    "test_set_path = 'datasets/vaq2.0.TestImages.txt'\n",
    "\n",
    "with open(test_set_path, \"r\") as f:\n",
    "    lines = f.readlines()\n",
    "    for line in lines:\n",
    "        temp = line.split('\\t')\n",
    "        qa = temp[1].split('?')\n",
    "\n",
    "        if len(qa) == 3:\n",
    "            answer = qa[2].strip()\n",
    "        else:\n",
    "            answer = qa[1].strip()\n",
    "\n",
    "        data_sample = {\n",
    "            'image_path': temp[0][:-2],\n",
    "            'question': qa[0] + '?',\n",
    "            'answer': answer\n",
    "        }\n",
    "        test_data.append(data_sample)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "d6Qf8EMA-gjK",
    "outputId": "ac738584-2709-46ba-bfe7-b541ac2a9555"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{0: 'no', 1: 'yes'}\n"
     ]
    }
   ],
   "source": [
    "classes = set([sample['answer'] for sample in train_data])\n",
    "classes_to_idx = {\n",
    "    cls_name: idx for idx, cls_name in enumerate(classes)\n",
    "}\n",
    "idx_to_classes = {\n",
    "    idx: cls_name for idx, cls_name in enumerate(classes)\n",
    "}\n",
    "print(idx_to_classes)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "9UznC-J7FVTf"
   },
   "source": [
    "## 3. Create Pytorch dataset"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 100,
   "metadata": {
    "id": "fXAFcSjnGlZF"
   },
   "outputs": [],
   "source": [
    "class VQADataset(Dataset):\n",
    "    def __init__(\n",
    "        self,\n",
    "        data,\n",
    "        classes_to_idx,\n",
    "        img_feature_extractor,\n",
    "        text_tokenizer,\n",
    "        device,\n",
    "        root_dir='/content/val2014-resised/'\n",
    "    ):\n",
    "        self.data = data\n",
    "        self.root_dir = root_dir\n",
    "        self.classes_to_idx = classes_to_idx\n",
    "        self.img_feature_extractor = img_feature_extractor\n",
    "        self.text_tokenizer = text_tokenizer\n",
    "        self.device = device\n",
    "\n",
    "    def __len__(self):\n",
    "        return len(self.data)\n",
    "\n",
    "    def __getitem__(self, index):\n",
    "        img_path = os.path.join(self.root_dir, self.data[index]['image_path'])\n",
    "        img = Image.open(img_path).convert('RGB')\n",
    "        \n",
    "        if self.img_feature_extractor:\n",
    "            img = self.img_feature_extractor(images=img, return_tensors=\"pt\")\n",
    "            img = {k: v.to(self.device).squeeze(0) for k, v in img.items()}\n",
    "            \n",
    "        question = self.data[index]['question']\n",
    "        if self.text_tokenizer:\n",
    "            question = self.text_tokenizer(\n",
    "                question, \n",
    "                padding=\"max_length\", \n",
    "                max_length=20, \n",
    "                truncation=True,\n",
    "                return_tensors=\"pt\"\n",
    "            )\n",
    "            question = {k: v.to(self.device).squeeze(0) for k, v in question.items()}\n",
    "\n",
    "\n",
    "        label = self.data[index]['answer']\n",
    "        label = torch.tensor(\n",
    "            classes_to_idx[label],\n",
    "            dtype=torch.long\n",
    "        ).to(device)\n",
    "            \n",
    "        sample = {\n",
    "            'image': img,\n",
    "            'question': question,\n",
    "            'label': label\n",
    "        }\n",
    "            \n",
    "        return sample"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 101,
   "metadata": {
    "id": "NmyFmD_GL-BQ"
   },
   "outputs": [],
   "source": [
    "img_feature_extractor = ViTImageProcessor.from_pretrained(\"google/vit-base-patch16-224\")\n",
    "text_tokenizer = AutoTokenizer.from_pretrained(\"roberta-base\")\n",
    "device = 'cuda' if torch.cuda.is_available() else 'cpu'\n",
    "\n",
    "train_dataset = VQADataset(\n",
    "    train_data,\n",
    "    classes_to_idx=classes_to_idx,\n",
    "    img_feature_extractor=img_feature_extractor,\n",
    "    text_tokenizer=text_tokenizer,\n",
    "    label_encoder=label_encoder,\n",
    "    device=device\n",
    ")\n",
    "val_dataset = VQADataset(\n",
    "    val_data,\n",
    "    classes_to_idx=classes_to_idx,\n",
    "    img_feature_extractor=img_feature_extractor,\n",
    "    text_tokenizer=text_tokenizer,\n",
    "    label_encoder=label_encoder,\n",
    "    device=device\n",
    ")\n",
    "test_dataset = VQADataset(\n",
    "    test_data,\n",
    "    classes_to_idx=classes_to_idx,\n",
    "    img_feature_extractor=img_feature_extractor,\n",
    "    text_tokenizer=text_tokenizer,\n",
    "    label_encoder=label_encoder,\n",
    "    device=device\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 142,
   "metadata": {
    "id": "AToEIVctirQK",
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "train_batch_size = 256\n",
    "test_batch_size = 32\n",
    "\n",
    "train_loader = DataLoader(\n",
    "    train_dataset,\n",
    "    batch_size=train_batch_size,\n",
    "    shuffle=True\n",
    ")\n",
    "val_loader = DataLoader(\n",
    "    val_dataset,\n",
    "    batch_size=test_batch_size,\n",
    "    shuffle=False\n",
    ")\n",
    "test_loader = DataLoader(\n",
    "    test_dataset,\n",
    "    batch_size=test_batch_size,\n",
    "    shuffle=False\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "fOcnB225J90K"
   },
   "source": [
    "# 5. Create Model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 143,
   "metadata": {
    "id": "PTI-Byg3syEu"
   },
   "outputs": [],
   "source": [
    "class VisualEncoder(nn.Module):\n",
    "    def __init__(self):\n",
    "        super(VisualEncoder, self).__init__()\n",
    "        self.model = ViTModel.from_pretrained(\"google/vit-base-patch16-224\")\n",
    "        \n",
    "    def forward(self, inputs):\n",
    "        outputs = self.model(**inputs)\n",
    "\n",
    "        return outputs.pooler_output"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 144,
   "metadata": {
    "id": "QZ42bHClszGG"
   },
   "outputs": [],
   "source": [
    "class TextEncoder(nn.Module):\n",
    "    def __init__(self):\n",
    "        super(TextEncoder, self).__init__()\n",
    "        self.model = RobertaModel.from_pretrained(\"roberta-base\")\n",
    "\n",
    "    def forward(self, inputs):\n",
    "        outputs = self.model(**inputs)\n",
    "\n",
    "        return outputs.pooler_output"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 153,
   "metadata": {
    "id": "FggG1E0ftSUX"
   },
   "outputs": [],
   "source": [
    "class Classifier(nn.Module):\n",
    "    def __init__(\n",
    "        self, \n",
    "        input_size=768*2, \n",
    "        hidden_size=512,\n",
    "        n_layers=1,\n",
    "        dropout_prob=0.2,\n",
    "        n_classes=2\n",
    "    ):\n",
    "        super(Classifier,self).__init__()\n",
    "        self.lstm = nn.LSTM(\n",
    "            input_size, \n",
    "            hidden_size, \n",
    "            num_layers=n_layers,\n",
    "            batch_first=True,\n",
    "            bidirectional=True\n",
    "        )\n",
    "        self.dropout = nn.Dropout(dropout_prob)\n",
    "        self.fc1 = nn.Linear(hidden_size*2, n_classes)\n",
    "        \n",
    "    def forward(self,x):\n",
    "        x, _ = self.lstm(x)\n",
    "        x = self.dropout(x)\n",
    "        x = self.fc1(x)\n",
    "\n",
    "        return x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 154,
   "metadata": {
    "id": "IjrAeibMtg5H"
   },
   "outputs": [],
   "source": [
    "class VQAModel(nn.Module):\n",
    "    def __init__(\n",
    "        self,\n",
    "        visual_encoder,\n",
    "        text_encoder,\n",
    "        classifier\n",
    "    ):\n",
    "        super(VQAModel, self).__init__()\n",
    "        self.visual_encoder = visual_encoder\n",
    "        self.text_encoder = text_encoder\n",
    "        self.classifier = classifier\n",
    "        \n",
    "\n",
    "    def forward(self, image, answer):\n",
    "        text_out = self.text_encoder(answer)\n",
    "        image_out = self.visual_encoder(image)\n",
    "        x = torch.cat((text_out, image_out), dim=1)\n",
    "        x = self.classifier(x)\n",
    "\n",
    "        return x\n",
    "\n",
    "    def freeze(self, visual=True, textual=True, clas=False):\n",
    "        if visual:\n",
    "            for n,p in self.visual_encoder.named_parameters():\n",
    "                p.requires_grad = False\n",
    "        if textual:\n",
    "            for n,p in self.text_encoder.named_parameters():\n",
    "                p.requires_grad = False\n",
    "        if clas:\n",
    "            for n,p in self.classifier.named_parameters():\n",
    "                p.requires_grad = False"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 158,
   "metadata": {
    "id": "obxbBWAbkg2A"
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Some weights of RobertaModel were not initialized from the model checkpoint at roberta-base and are newly initialized: ['roberta.pooler.dense.weight', 'roberta.pooler.dense.bias']\n",
      "You should probably TRAIN this model on a down-stream task to be able to use it for predictions and inference.\n",
      "Some weights of ViTModel were not initialized from the model checkpoint at google/vit-base-patch16-224 and are newly initialized: ['vit.pooler.dense.bias', 'vit.pooler.dense.weight']\n",
      "You should probably TRAIN this model on a down-stream task to be able to use it for predictions and inference.\n"
     ]
    }
   ],
   "source": [
    "n_classes = len(classes)\n",
    "hidden_size = 1024\n",
    "n_layers = 1\n",
    "dropout_prob = 0.2\n",
    "\n",
    "text_encoder = TextEncoder().to(device)\n",
    "visual_encoder = VisualEncoder().to(device)\n",
    "classifier = Classifier(\n",
    "    hidden_size=hidden_size,\n",
    "    n_layers=n_layers,\n",
    "    dropout_prob=dropout_prob,\n",
    "    n_classes=n_classes\n",
    ").to(device)\n",
    "\n",
    "model = VQAModel(\n",
    "    visual_encoder=visual_encoder,\n",
    "    text_encoder=text_encoder,\n",
    "    classifier=classifier\n",
    ").to(device)\n",
    "model.freeze()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 159,
   "metadata": {
    "id": "ZzhJzxrGmWSO",
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "torch.Size([256, 2])\n"
     ]
    }
   ],
   "source": [
    "inputs = next(iter(train_loader))\n",
    "\n",
    "model.eval()\n",
    "with torch.no_grad():\n",
    "    image = inputs['image']\n",
    "    question = inputs['question']\n",
    "    output = model(image, question)\n",
    "    print(output.shape)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "OmPEn5s-mjJe"
   },
   "source": [
    "## 6. Training"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 160,
   "metadata": {
    "id": "pBIA8pH0rEHF"
   },
   "outputs": [],
   "source": [
    "def evaluate(model, dataloader, criterion):\n",
    "    model.eval()\n",
    "    correct = 0\n",
    "    total = 0\n",
    "    losses = []\n",
    "    with torch.no_grad():\n",
    "        for idx, inputs in enumerate(dataloader):\n",
    "            images = inputs['image']\n",
    "            questions = inputs['question']\n",
    "            labels = inputs['label']\n",
    "            outputs = model(images, questions)\n",
    "            loss = criterion(outputs, labels)\n",
    "            losses.append(loss.item())\n",
    "            _, predicted = torch.max(outputs.data, 1)\n",
    "            total += labels.size(0)\n",
    "            correct += (predicted == labels).sum().item()\n",
    "\n",
    "    loss = sum(losses) / len(losses)\n",
    "    acc = correct / total\n",
    "\n",
    "    return loss, acc"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 161,
   "metadata": {
    "id": "MxNXk8_xrkon"
   },
   "outputs": [],
   "source": [
    "def fit(\n",
    "    model,\n",
    "    train_loader,\n",
    "    val_loader,\n",
    "    criterion,\n",
    "    optimizer,\n",
    "    scheduler,\n",
    "    epochs\n",
    "):\n",
    "    train_losses = []\n",
    "    val_losses = []\n",
    "\n",
    "    for epoch in range(epochs):\n",
    "        batch_train_losses = []\n",
    "\n",
    "        model.train()\n",
    "        for idx, inputs in enumerate(train_loader):\n",
    "            images = inputs['image']\n",
    "            questions = inputs['question']\n",
    "            labels = inputs['label']\n",
    "\n",
    "            optimizer.zero_grad()\n",
    "            outputs = model(images, questions)\n",
    "            loss = criterion(outputs, labels)\n",
    "            loss.backward()\n",
    "            optimizer.step()\n",
    "\n",
    "            batch_train_losses.append(loss.item())\n",
    "\n",
    "        train_loss = sum(batch_train_losses) / len(batch_train_losses)\n",
    "        train_losses.append(train_loss)\n",
    "\n",
    "        val_loss, val_acc = evaluate(\n",
    "            model, val_loader,\n",
    "            criterion\n",
    "        )\n",
    "        val_losses.append(val_loss)\n",
    "\n",
    "        print(f'EPOCH {epoch + 1}:\\tTrain loss: {train_loss:.4f}\\tVal loss: {val_loss:.4f}\\tVal Acc: {val_acc}')\n",
    "\n",
    "        scheduler.step()\n",
    "\n",
    "    return train_losses, val_losses"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 162,
   "metadata": {
    "id": "6hj65HGor2pv"
   },
   "outputs": [],
   "source": [
    "lr = 1e-2\n",
    "epochs = 50\n",
    "scheduler_step_size = epochs * 0.6\n",
    "criterion = nn.CrossEntropyLoss()\n",
    "\n",
    "optimizer = torch.optim.Adam(\n",
    "    model.parameters(),\n",
    "    lr=lr\n",
    ")\n",
    "scheduler = torch.optim.lr_scheduler.StepLR(\n",
    "    optimizer,\n",
    "    step_size=scheduler_step_size,\n",
    "    gamma=0.1\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 163,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "z5Qmw6efr5HG",
    "outputId": "3aefadc9-2755-4afe-f66f-b0d3f693422e",
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "EPOCH 1:\tTrain loss: 1.7915\tVal loss: 0.6914\tVal Acc: 0.5332991803278688\n",
      "EPOCH 2:\tTrain loss: 0.7350\tVal loss: 0.6907\tVal Acc: 0.5322745901639344\n",
      "EPOCH 3:\tTrain loss: 0.7119\tVal loss: 0.7013\tVal Acc: 0.5358606557377049\n",
      "EPOCH 4:\tTrain loss: 0.7047\tVal loss: 0.6995\tVal Acc: 0.48206967213114754\n",
      "EPOCH 5:\tTrain loss: 0.6959\tVal loss: 0.7380\tVal Acc: 0.5358606557377049\n",
      "EPOCH 6:\tTrain loss: 0.7403\tVal loss: 0.6921\tVal Acc: 0.5363729508196722\n",
      "EPOCH 7:\tTrain loss: 0.6921\tVal loss: 0.7845\tVal Acc: 0.4641393442622951\n",
      "EPOCH 8:\tTrain loss: 0.7046\tVal loss: 0.7447\tVal Acc: 0.4713114754098361\n",
      "EPOCH 9:\tTrain loss: 0.6904\tVal loss: 0.7015\tVal Acc: 0.5158811475409836\n",
      "EPOCH 10:\tTrain loss: 0.7283\tVal loss: 0.6828\tVal Acc: 0.5635245901639344\n",
      "EPOCH 11:\tTrain loss: 0.6811\tVal loss: 0.7248\tVal Acc: 0.5445696721311475\n",
      "EPOCH 12:\tTrain loss: 0.6774\tVal loss: 0.7093\tVal Acc: 0.5532786885245902\n",
      "EPOCH 13:\tTrain loss: 0.6708\tVal loss: 0.6681\tVal Acc: 0.5978483606557377\n",
      "EPOCH 14:\tTrain loss: 0.6523\tVal loss: 0.6924\tVal Acc: 0.5650614754098361\n",
      "EPOCH 15:\tTrain loss: 0.6599\tVal loss: 0.6695\tVal Acc: 0.5988729508196722\n",
      "EPOCH 16:\tTrain loss: 0.6530\tVal loss: 0.6777\tVal Acc: 0.5829918032786885\n",
      "EPOCH 17:\tTrain loss: 0.6622\tVal loss: 0.7201\tVal Acc: 0.5619877049180327\n",
      "EPOCH 18:\tTrain loss: 0.6743\tVal loss: 0.6687\tVal Acc: 0.6029713114754098\n",
      "EPOCH 19:\tTrain loss: 0.6470\tVal loss: 0.6664\tVal Acc: 0.5988729508196722\n",
      "EPOCH 20:\tTrain loss: 0.6325\tVal loss: 0.7124\tVal Acc: 0.5809426229508197\n",
      "EPOCH 21:\tTrain loss: 0.6619\tVal loss: 0.6640\tVal Acc: 0.6014344262295082\n",
      "EPOCH 22:\tTrain loss: 0.6154\tVal loss: 0.6582\tVal Acc: 0.6121926229508197\n",
      "EPOCH 23:\tTrain loss: 0.6307\tVal loss: 0.8527\tVal Acc: 0.49436475409836067\n",
      "EPOCH 24:\tTrain loss: 0.6815\tVal loss: 0.7524\tVal Acc: 0.5332991803278688\n",
      "EPOCH 25:\tTrain loss: 0.6348\tVal loss: 0.6792\tVal Acc: 0.5917008196721312\n",
      "EPOCH 26:\tTrain loss: 0.5867\tVal loss: 0.6546\tVal Acc: 0.6260245901639344\n",
      "EPOCH 27:\tTrain loss: 0.5932\tVal loss: 0.6628\tVal Acc: 0.6137295081967213\n",
      "EPOCH 28:\tTrain loss: 0.5958\tVal loss: 0.7143\tVal Acc: 0.600922131147541\n",
      "EPOCH 29:\tTrain loss: 0.6033\tVal loss: 0.6656\tVal Acc: 0.610655737704918\n",
      "EPOCH 30:\tTrain loss: 0.6074\tVal loss: 0.6616\tVal Acc: 0.6290983606557377\n",
      "EPOCH 31:\tTrain loss: 0.5619\tVal loss: 0.6559\tVal Acc: 0.6326844262295082\n",
      "EPOCH 32:\tTrain loss: 0.5556\tVal loss: 0.6545\tVal Acc: 0.6270491803278688\n",
      "EPOCH 33:\tTrain loss: 0.5550\tVal loss: 0.6553\tVal Acc: 0.6275614754098361\n",
      "EPOCH 34:\tTrain loss: 0.5546\tVal loss: 0.6500\tVal Acc: 0.6347336065573771\n",
      "EPOCH 35:\tTrain loss: 0.5489\tVal loss: 0.6593\tVal Acc: 0.6203893442622951\n",
      "EPOCH 36:\tTrain loss: 0.5452\tVal loss: 0.6527\tVal Acc: 0.6352459016393442\n",
      "EPOCH 37:\tTrain loss: 0.5388\tVal loss: 0.6544\tVal Acc: 0.6255122950819673\n",
      "EPOCH 38:\tTrain loss: 0.5402\tVal loss: 0.6528\tVal Acc: 0.6311475409836066\n",
      "EPOCH 39:\tTrain loss: 0.5399\tVal loss: 0.6489\tVal Acc: 0.6429303278688525\n",
      "EPOCH 40:\tTrain loss: 0.5371\tVal loss: 0.6632\tVal Acc: 0.6193647540983607\n",
      "EPOCH 41:\tTrain loss: 0.5334\tVal loss: 0.6552\tVal Acc: 0.6290983606557377\n",
      "EPOCH 42:\tTrain loss: 0.5308\tVal loss: 0.6560\tVal Acc: 0.632172131147541\n",
      "EPOCH 43:\tTrain loss: 0.5253\tVal loss: 0.6503\tVal Acc: 0.6444672131147541\n",
      "EPOCH 44:\tTrain loss: 0.5273\tVal loss: 0.6584\tVal Acc: 0.639344262295082\n",
      "EPOCH 45:\tTrain loss: 0.5294\tVal loss: 0.6500\tVal Acc: 0.6449795081967213\n",
      "EPOCH 46:\tTrain loss: 0.5164\tVal loss: 0.6518\tVal Acc: 0.6362704918032787\n",
      "EPOCH 47:\tTrain loss: 0.5226\tVal loss: 0.6469\tVal Acc: 0.6526639344262295\n",
      "EPOCH 48:\tTrain loss: 0.5186\tVal loss: 0.6516\tVal Acc: 0.6347336065573771\n",
      "EPOCH 49:\tTrain loss: 0.5192\tVal loss: 0.6475\tVal Acc: 0.6536885245901639\n",
      "EPOCH 50:\tTrain loss: 0.5121\tVal loss: 0.6461\tVal Acc: 0.6547131147540983\n"
     ]
    }
   ],
   "source": [
    "train_losses, val_losses = fit(\n",
    "    model,\n",
    "    train_loader,\n",
    "    val_loader,\n",
    "    criterion,\n",
    "    optimizer,\n",
    "    scheduler,\n",
    "    epochs\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 164,
   "metadata": {
    "id": "xIobHWIptBQm"
   },
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1200x500 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "fig, ax = plt.subplots(1, 2, figsize=(12, 5))\n",
    "ax[0].plot(train_losses)\n",
    "ax[0].set_title('Training Loss')\n",
    "ax[0].set_xlabel('Epoch')\n",
    "ax[0].set_ylabel('Loss')\n",
    "ax[1].plot(val_losses, color='orange')\n",
    "ax[1].set_title('Val Loss')\n",
    "ax[1].set_xlabel('Epoch')\n",
    "ax[1].set_ylabel('Loss')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "JPFgeiArr6zp"
   },
   "source": [
    "## 7. Evaluation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 166,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "psvbHQpis5bm",
    "outputId": "2c745e13-4187-4718-f0b5-5c0042ef9311"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Evaluation on val/test dataset\n",
      "Val accuracy:  0.6547131147540983\n",
      "Test accuracy:  0.6364985163204748\n"
     ]
    }
   ],
   "source": [
    "val_loss, val_acc = evaluate(\n",
    "    model,\n",
    "    val_loader,\n",
    "    criterion\n",
    ")\n",
    "test_loss, test_acc = evaluate(\n",
    "    model,\n",
    "    test_loader,\n",
    "    criterion\n",
    ")\n",
    "\n",
    "print('Evaluation on val/test dataset')\n",
    "print('Val accuracy: ', val_acc)\n",
    "print('Test accuracy: ', test_acc)"
   ]
  }
 ],
 "metadata": {
  "accelerator": "GPU",
  "colab": {
   "provenance": []
  },
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.11.5"
  },
  "varInspector": {
   "cols": {
    "lenName": 16,
    "lenType": 16,
    "lenVar": 40
   },
   "kernels_config": {
    "python": {
     "delete_cmd_postfix": "",
     "delete_cmd_prefix": "del ",
     "library": "var_list.py",
     "varRefreshCmd": "print(var_dic_list())"
    },
    "r": {
     "delete_cmd_postfix": ") ",
     "delete_cmd_prefix": "rm(",
     "library": "var_list.r",
     "varRefreshCmd": "cat(var_dic_list()) "
    }
   },
   "types_to_exclude": [
    "module",
    "function",
    "builtin_function_or_method",
    "instance",
    "_Feature"
   ],
   "window_display": false
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}