VQA_CNN+LSTM.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": 1,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "94MQBB3h9WT_",
        "outputId": "6cab9878-75b2-46dd-9ba4-60cf4c9864ca"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "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:02<00:00, 90.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": 2,
      "metadata": {
        "id": "rb5Rh0fGAStN"
      },
      "outputs": [],
      "source": [
        "!unzip -q vqa_coco_dataset.zip"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "VljPGwOLCGoj"
      },
      "source": [
        "## 1. Import libraries"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "!pip install timm -q"
      ],
      "metadata": {
        "id": "KDAACoro5r38"
      },
      "execution_count": 1,
      "outputs": []
    },
    {
      "cell_type": "code",
      "execution_count": 2,
      "metadata": {
        "id": "zwmJUbxKCPjS"
      },
      "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"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Iu20gzLxCu2y"
      },
      "source": [
        "## 2. Read dataset"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 3,
      "metadata": {
        "id": "ZOxeYUBvCSki"
      },
      "outputs": [],
      "source": [
        "train_data = []\n",
        "train_set_path = './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": 4,
      "metadata": {
        "id": "EiZ7OwSfCrKa"
      },
      "outputs": [],
      "source": [
        "val_data = []\n",
        "val_set_path = './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": 5,
      "metadata": {
        "id": "ZoX0dQbjEx53"
      },
      "outputs": [],
      "source": [
        "test_data = []\n",
        "test_set_path = './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": "markdown",
      "metadata": {
        "id": "A_n5-R4NMqBx"
      },
      "source": [
        "## 3. Data Preprocessing"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 6,
      "metadata": {
        "id": "_RqGo2gUNwLW"
      },
      "outputs": [],
      "source": [
        "eng = spacy.load(\"en_core_web_sm\") # Load the English model to tokenize English text\n",
        "\n",
        "def get_tokens(data_iter):\n",
        "    for sample in data_iter:\n",
        "        question = sample['question']\n",
        "\n",
        "        yield [token.text for token in eng.tokenizer(question)]\n",
        "\n",
        "\n",
        "vocab = build_vocab_from_iterator(\n",
        "    get_tokens(train_data),\n",
        "    min_freq=2,\n",
        "    specials= ['<pad>', '<sos>', '<eos>', '<unk>'],\n",
        "    special_first=True\n",
        ")\n",
        "vocab.set_default_index(vocab['<unk>'])"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 7,
      "metadata": {
        "id": "NDRHRaKyRiq6",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "d16b124c-2f1a-4f00-8ef4-0d5e0be84d88"
      },
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "1678"
            ]
          },
          "metadata": {},
          "execution_count": 7
        }
      ],
      "source": [
        "len(vocab)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 8,
      "metadata": {
        "id": "G8cMLRR5Nyrm"
      },
      "outputs": [],
      "source": [
        "def tokenize(question, max_seq_len):\n",
        "    tokens = [token.text for token in eng.tokenizer(question)]\n",
        "    sequence = [vocab[token] for token in tokens]\n",
        "    if len(sequence) < max_seq_len:\n",
        "        sequence += [vocab['<pad>']] * (max_seq_len - len(sequence))\n",
        "    else:\n",
        "        sequence = sequence[:max_seq_len]\n",
        "\n",
        "    return sequence"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 9,
      "metadata": {
        "id": "GNfi1xqHTDgA",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "d79f65f7-7aea-443d-8f2c-2d3aea6be516"
      },
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "[6, 5, 7, 16, 21, 75, 3, 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]"
            ]
          },
          "metadata": {},
          "execution_count": 9
        }
      ],
      "source": [
        "example_question = \"Is this a picture of an apple?\"\n",
        "max_seq_len = 20\n",
        "\n",
        "tokenize(example_question, max_seq_len)"
      ]
    },
    {
      "cell_type": "code",
      "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)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "d6Qf8EMA-gjK",
        "outputId": "e378185b-ecc9-471d-f386-2bf3079c448e"
      },
      "execution_count": 10,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "{0: 'yes', 1: 'no'}\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "9UznC-J7FVTf"
      },
      "source": [
        "## 4. Create Pytorch dataset"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 11,
      "metadata": {
        "id": "fXAFcSjnGlZF"
      },
      "outputs": [],
      "source": [
        "class VQADataset(Dataset):\n",
        "    def __init__(\n",
        "        self,\n",
        "        data,\n",
        "        classes_to_idx,\n",
        "        max_seq_len=20,\n",
        "        transform=None,\n",
        "        root_dir='/content/val2014-resised/'\n",
        "    ):\n",
        "        self.transform = transform\n",
        "        self.data = data\n",
        "        self.max_seq_len = max_seq_len\n",
        "        self.root_dir = root_dir\n",
        "        self.classes_to_idx = classes_to_idx\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",
        "        if self.transform:\n",
        "            img = self.transform(img)\n",
        "\n",
        "        question = self.data[index]['question']\n",
        "        question = tokenize(question, self.max_seq_len)\n",
        "        question = torch.tensor(question, dtype=torch.long)\n",
        "\n",
        "        label = self.data[index]['answer']\n",
        "        label = classes_to_idx[label]\n",
        "        label = torch.tensor(label, dtype=torch.long)\n",
        "\n",
        "        return img, question, label"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "transform = transforms.Compose([\n",
        "    transforms.Resize((224, 224)),\n",
        "    transforms.ToTensor(),\n",
        "    transforms.Normalize((0.485, 0.456, 0.406), (0.229, 0.224, 0.225)),\n",
        "])"
      ],
      "metadata": {
        "id": "AtRtdtYzrgeB"
      },
      "execution_count": 12,
      "outputs": []
    },
    {
      "cell_type": "code",
      "execution_count": 13,
      "metadata": {
        "id": "NmyFmD_GL-BQ"
      },
      "outputs": [],
      "source": [
        "train_dataset = VQADataset(\n",
        "    train_data,\n",
        "    classes_to_idx=classes_to_idx,\n",
        "    transform=transform\n",
        ")\n",
        "val_dataset = VQADataset(\n",
        "    val_data,\n",
        "    classes_to_idx=classes_to_idx,\n",
        "    transform=transform\n",
        ")\n",
        "test_dataset = VQADataset(\n",
        "    test_data,\n",
        "    classes_to_idx=classes_to_idx,\n",
        "    transform=transform\n",
        ")"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 14,
      "metadata": {
        "id": "AToEIVctirQK"
      },
      "outputs": [],
      "source": [
        "train_batch_size = 128\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": 15,
      "metadata": {
        "id": "UwZNqfIvLmup"
      },
      "outputs": [],
      "source": [
        "class VQAModel(nn.Module):\n",
        "    def __init__(\n",
        "        self,\n",
        "        n_classes,\n",
        "        img_model_name='resnet50',\n",
        "        embeddding_dim=300,\n",
        "        n_layers=1,\n",
        "        hidden_size=128,\n",
        "        dropout_prob=0.2\n",
        "    ):\n",
        "        super(VQAModel, self).__init__()\n",
        "        self.image_encoder = timm.create_model(\n",
        "            img_model_name,\n",
        "            pretrained=True,\n",
        "            num_classes=hidden_size\n",
        "        )\n",
        "\n",
        "        self.embedding = nn.Embedding(len(vocab), embeddding_dim)\n",
        "        self.lstm1 = nn.LSTM(\n",
        "            input_size=embeddding_dim,\n",
        "            hidden_size=hidden_size,\n",
        "            num_layers=n_layers,\n",
        "            batch_first=True,\n",
        "            bidirectional=True\n",
        "        )\n",
        "        self.lstm2 = nn.LSTM(\n",
        "            input_size=hidden_size*3,\n",
        "            hidden_size=hidden_size,\n",
        "            num_layers=n_layers,\n",
        "            batch_first=True,\n",
        "            bidirectional=True\n",
        "        )\n",
        "        self.dropout = nn.Dropout(dropout_prob)\n",
        "        self.fc = nn.Linear(hidden_size * 2, n_classes)\n",
        "\n",
        "    def forward(self, img, text):\n",
        "        img_features = self.image_encoder(img)\n",
        "\n",
        "        text_emb = self.embedding(text)\n",
        "        lstm_out, _ = self.lstm1(text_emb)\n",
        "\n",
        "        lstm_out = lstm_out[:, -1, :]\n",
        "\n",
        "        combined = torch.cat((img_features, lstm_out), dim=1)\n",
        "        x, _ = self.lstm2(combined)\n",
        "        x = self.dropout(x)\n",
        "        x = self.fc(x)\n",
        "\n",
        "        return x"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 16,
      "metadata": {
        "id": "obxbBWAbkg2A"
      },
      "outputs": [],
      "source": [
        "n_classes = len(classes)\n",
        "img_model_name = 'resnet50'\n",
        "hidden_size = 128\n",
        "n_layers = 1\n",
        "embeddding_dim = 64\n",
        "dropout_prob = 0.2\n",
        "device = 'cuda' if torch.cuda.is_available() else 'cpu'\n",
        "\n",
        "model = VQAModel(\n",
        "    n_classes=n_classes,\n",
        "    img_model_name=img_model_name,\n",
        "    embeddding_dim=embeddding_dim,\n",
        "    n_layers=n_layers,\n",
        "    hidden_size=hidden_size,\n",
        "    dropout_prob=dropout_prob\n",
        ").to(device)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 17,
      "metadata": {
        "id": "ZzhJzxrGmWSO",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "13e3c3d3-f524-4335-82e5-5d37b33c66fe"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "torch.Size([128, 2])\n"
          ]
        }
      ],
      "source": [
        "images, questions, labels = next(iter(train_loader))\n",
        "\n",
        "model.eval()\n",
        "with torch.no_grad():\n",
        "    images = images.to(device)\n",
        "    questions = questions.to(device)\n",
        "    output = model(images, questions)\n",
        "    print(output.shape)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "OmPEn5s-mjJe"
      },
      "source": [
        "## 6. Training"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 18,
      "metadata": {
        "id": "pBIA8pH0rEHF"
      },
      "outputs": [],
      "source": [
        "def evaluate(model, dataloader, criterion, device):\n",
        "    model.eval()\n",
        "    correct = 0\n",
        "    total = 0\n",
        "    losses = []\n",
        "    with torch.no_grad():\n",
        "        for image, question, labels in dataloader:\n",
        "            image, question, labels = image.to(device), question.to(device), labels.to(device)\n",
        "            outputs = model(image, question)\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": 19,
      "metadata": {
        "id": "MxNXk8_xrkon"
      },
      "outputs": [],
      "source": [
        "def fit(\n",
        "    model,\n",
        "    train_loader,\n",
        "    val_loader,\n",
        "    criterion,\n",
        "    optimizer,\n",
        "    scheduler,\n",
        "    device,\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, (images, questions, labels) in enumerate(train_loader):\n",
        "            images = images.to(device)\n",
        "            questions = questions.to(device)\n",
        "            labels = labels.to(device)\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, device\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": 20,
      "metadata": {
        "id": "6hj65HGor2pv"
      },
      "outputs": [],
      "source": [
        "lr = 1e-2\n",
        "epochs = 50\n",
        "\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": 21,
      "metadata": {
        "id": "z5Qmw6efr5HG",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "e75bdfa0-e348-4a79-99c8-4318dd76e5ff"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "EPOCH 1:\tTrain loss: 0.7225\tVal loss: 0.6914\tVal Acc: 0.5358606557377049\n",
            "EPOCH 2:\tTrain loss: 0.6940\tVal loss: 0.6956\tVal Acc: 0.4682377049180328\n",
            "EPOCH 3:\tTrain loss: 0.6944\tVal loss: 0.6901\tVal Acc: 0.5358606557377049\n",
            "EPOCH 4:\tTrain loss: 0.6944\tVal loss: 0.6924\tVal Acc: 0.5358606557377049\n",
            "EPOCH 5:\tTrain loss: 0.6935\tVal loss: 0.6910\tVal Acc: 0.5358606557377049\n",
            "EPOCH 6:\tTrain loss: 0.6936\tVal loss: 0.6962\tVal Acc: 0.48206967213114754\n",
            "EPOCH 7:\tTrain loss: 0.6950\tVal loss: 0.6919\tVal Acc: 0.5358606557377049\n",
            "EPOCH 8:\tTrain loss: 0.6933\tVal loss: 0.6921\tVal Acc: 0.5358606557377049\n",
            "EPOCH 9:\tTrain loss: 0.6935\tVal loss: 0.6920\tVal Acc: 0.5358606557377049\n",
            "EPOCH 10:\tTrain loss: 0.6944\tVal loss: 0.6919\tVal Acc: 0.5358606557377049\n",
            "EPOCH 11:\tTrain loss: 0.6935\tVal loss: 0.6918\tVal Acc: 0.5358606557377049\n",
            "EPOCH 12:\tTrain loss: 0.6937\tVal loss: 0.6916\tVal Acc: 0.5348360655737705\n",
            "EPOCH 13:\tTrain loss: 0.6931\tVal loss: 0.6909\tVal Acc: 0.5358606557377049\n",
            "EPOCH 14:\tTrain loss: 0.6927\tVal loss: 0.6946\tVal Acc: 0.4641393442622951\n",
            "EPOCH 15:\tTrain loss: 0.6931\tVal loss: 0.6914\tVal Acc: 0.5368852459016393\n",
            "EPOCH 16:\tTrain loss: 0.6926\tVal loss: 0.6914\tVal Acc: 0.5389344262295082\n",
            "EPOCH 17:\tTrain loss: 0.6935\tVal loss: 0.6909\tVal Acc: 0.5358606557377049\n",
            "EPOCH 18:\tTrain loss: 0.6932\tVal loss: 0.6931\tVal Acc: 0.5261270491803278\n",
            "EPOCH 19:\tTrain loss: 0.6922\tVal loss: 0.6920\tVal Acc: 0.5358606557377049\n",
            "EPOCH 20:\tTrain loss: 0.6928\tVal loss: 0.6928\tVal Acc: 0.5332991803278688\n",
            "EPOCH 21:\tTrain loss: 0.6926\tVal loss: 0.6926\tVal Acc: 0.5332991803278688\n",
            "EPOCH 22:\tTrain loss: 0.6936\tVal loss: 0.6911\tVal Acc: 0.5343237704918032\n",
            "EPOCH 23:\tTrain loss: 0.6963\tVal loss: 0.6931\tVal Acc: 0.5358606557377049\n",
            "EPOCH 24:\tTrain loss: 0.6953\tVal loss: 0.6937\tVal Acc: 0.47540983606557374\n",
            "EPOCH 25:\tTrain loss: 0.6948\tVal loss: 0.6926\tVal Acc: 0.5302254098360656\n",
            "EPOCH 26:\tTrain loss: 0.6943\tVal loss: 0.6950\tVal Acc: 0.4918032786885246\n",
            "EPOCH 27:\tTrain loss: 0.6944\tVal loss: 0.6911\tVal Acc: 0.5358606557377049\n",
            "EPOCH 28:\tTrain loss: 0.6936\tVal loss: 0.6930\tVal Acc: 0.5348360655737705\n",
            "EPOCH 29:\tTrain loss: 0.6963\tVal loss: 0.6948\tVal Acc: 0.4707991803278688\n",
            "EPOCH 30:\tTrain loss: 0.6967\tVal loss: 0.6973\tVal Acc: 0.4764344262295082\n",
            "EPOCH 31:\tTrain loss: 0.6935\tVal loss: 0.6909\tVal Acc: 0.5358606557377049\n",
            "EPOCH 32:\tTrain loss: 0.6929\tVal loss: 0.6905\tVal Acc: 0.5358606557377049\n",
            "EPOCH 33:\tTrain loss: 0.6930\tVal loss: 0.6917\tVal Acc: 0.5358606557377049\n",
            "EPOCH 34:\tTrain loss: 0.6925\tVal loss: 0.6909\tVal Acc: 0.5358606557377049\n",
            "EPOCH 35:\tTrain loss: 0.6924\tVal loss: 0.6912\tVal Acc: 0.5358606557377049\n",
            "EPOCH 36:\tTrain loss: 0.6925\tVal loss: 0.6917\tVal Acc: 0.5358606557377049\n",
            "EPOCH 37:\tTrain loss: 0.6925\tVal loss: 0.6911\tVal Acc: 0.5358606557377049\n",
            "EPOCH 38:\tTrain loss: 0.6926\tVal loss: 0.6915\tVal Acc: 0.5358606557377049\n",
            "EPOCH 39:\tTrain loss: 0.6928\tVal loss: 0.6907\tVal Acc: 0.5358606557377049\n",
            "EPOCH 40:\tTrain loss: 0.6921\tVal loss: 0.6909\tVal Acc: 0.5358606557377049\n",
            "EPOCH 41:\tTrain loss: 0.6927\tVal loss: 0.6906\tVal Acc: 0.5358606557377049\n",
            "EPOCH 42:\tTrain loss: 0.6923\tVal loss: 0.6911\tVal Acc: 0.5358606557377049\n",
            "EPOCH 43:\tTrain loss: 0.6925\tVal loss: 0.6918\tVal Acc: 0.5358606557377049\n",
            "EPOCH 44:\tTrain loss: 0.6921\tVal loss: 0.6907\tVal Acc: 0.5358606557377049\n",
            "EPOCH 45:\tTrain loss: 0.6925\tVal loss: 0.6908\tVal Acc: 0.5358606557377049\n",
            "EPOCH 46:\tTrain loss: 0.6923\tVal loss: 0.6913\tVal Acc: 0.5358606557377049\n",
            "EPOCH 47:\tTrain loss: 0.6923\tVal loss: 0.6910\tVal Acc: 0.5358606557377049\n",
            "EPOCH 48:\tTrain loss: 0.6922\tVal loss: 0.6912\tVal Acc: 0.5358606557377049\n",
            "EPOCH 49:\tTrain loss: 0.6927\tVal loss: 0.6909\tVal Acc: 0.5358606557377049\n",
            "EPOCH 50:\tTrain loss: 0.6923\tVal loss: 0.6912\tVal Acc: 0.5358606557377049\n"
          ]
        }
      ],
      "source": [
        "train_losses, val_losses = fit(\n",
        "    model,\n",
        "    train_loader,\n",
        "    val_loader,\n",
        "    criterion,\n",
        "    optimizer,\n",
        "    scheduler,\n",
        "    device,\n",
        "    epochs\n",
        ")"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 22,
      "metadata": {
        "id": "xIobHWIptBQm",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 487
        },
        "outputId": "5784c533-8181-4028-e5af-61e6bfe51cd8"
      },
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 1200x500 with 2 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        }
      ],
      "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": 24,
      "metadata": {
        "id": "psvbHQpis5bm",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "b5b9ef47-2cdd-4332-f126-33ed4963ac10"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Evaluation on val/test dataset\n",
            "Val accuracy:  0.5358606557377049\n",
            "Test accuracy:  0.5489614243323442\n"
          ]
        }
      ],
      "source": [
        "val_loss, val_acc = evaluate(\n",
        "    model,\n",
        "    val_loader,\n",
        "    criterion,\n",
        "    device\n",
        ")\n",
        "test_loss, test_acc = evaluate(\n",
        "    model,\n",
        "    test_loader,\n",
        "    criterion,\n",
        "    device\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",
      "name": "python3"
    },
    "language_info": {
      "name": "python"
    }
  },
  "nbformat": 4,
  "nbformat_minor": 0
}