mlp_training.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "2fbbb1fa-9413-42ca-9f4d-be00d266e9c5",
   "metadata": {},
   "outputs": [],
   "source": [
    "import torch\n",
    "import torch.nn as nn\n",
    "import torch.optim as optim\n",
    "from random import randint\n",
    "import time\n",
    "import utils\n",
    "import numpy as np\n",
    "from torch.utils.data import Dataset, TensorDataset, DataLoader\n",
    "from torchvision import datasets, transforms\n",
    "from torchvision.transforms import ToTensor\n",
    "import matplotlib.pyplot as plt\n",
    "import cv2\n",
    "import random"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "cd781f64-7e78-4186-8ddb-2507bc991e3b",
   "metadata": {},
   "outputs": [],
   "source": [
    "def process_dataset(dataset):\n",
    "    X = []\n",
    "    y = []\n",
    "    for i, (k, v) in enumerate(dataset.items()):\n",
    "        X.append(v)\n",
    "        y.append([i] * v.shape[0])\n",
    "    X = np.concatenate(X)\n",
    "    y = np.concatenate(y)\n",
    "    X = torch.from_numpy(X).type(torch.float32)\n",
    "    y = torch.from_numpy(y).type(torch.int64)\n",
    "    dataset = TensorDataset(X, y)\n",
    "    dataloader = DataLoader(dataset, batch_size=32, shuffle=True)\n",
    "    return dataset, dataloader"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 201,
   "id": "067b539d-3ee8-4810-af41-4a5d152f8882",
   "metadata": {},
   "outputs": [],
   "source": [
    "dataset_train = np.load('dataset/dataset_train.npy', allow_pickle=True)[()]\n",
    "dataset_test = np.load('dataset/dataset_test.npy', allow_pickle=True)[()]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 202,
   "id": "7735d889-0b80-4052-b608-a08edc7a7b8e",
   "metadata": {},
   "outputs": [],
   "source": [
    "train_dataset, train_dataloader = process_dataset(dataset_train['cifar'])\n",
    "test_dataset, test_dataloader = process_dataset(dataset_test['cifar'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 363,
   "id": "ebe9d5ba-6d3a-42f4-b9ad-b080f2904140",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Using cpu device.\n",
      "MLP(\n",
      "  (flatten): Flatten(start_dim=1, end_dim=-1)\n",
      "  (fc1): Linear(in_features=3072, out_features=1024, bias=False)\n",
      "  (bn1): BatchNorm1d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "  (fc2): Linear(in_features=1024, out_features=512, bias=False)\n",
      "  (bn2): BatchNorm1d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "  (fc3): Linear(in_features=512, out_features=256, bias=False)\n",
      "  (bn3): BatchNorm1d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "  (fc4): Linear(in_features=256, out_features=128, bias=False)\n",
      "  (bn4): BatchNorm1d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "  (fc5): Linear(in_features=128, out_features=64, bias=False)\n",
      "  (bn5): BatchNorm1d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "  (fc6): Linear(in_features=64, out_features=32, bias=False)\n",
      "  (bn6): BatchNorm1d(32, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "  (fc7): Linear(in_features=32, out_features=10, bias=False)\n",
      "  (relu): ReLU()\n",
      ")\n",
      "There are 3848448 (3.85 million) parameters in this neural network\n"
     ]
    }
   ],
   "source": [
    "device = \"cpu\" # \"cuda\" if torch.cuda.is_available() else \"cpu\"\n",
    "print(f\"Using {device} device.\")\n",
    "\n",
    "class MLP(nn.Module):\n",
    "    def __init__(self, x_dim, h_dim, y_dim):\n",
    "        super(MLP, self).__init__()\n",
    "        self.flatten = nn.Flatten()\n",
    "        self.fc1 = nn.Linear(x_dim, 1024, bias=False)\n",
    "        self.bn1 = nn.BatchNorm1d(1024)\n",
    "        self.fc2 = nn.Linear(1024, 512, bias=False)\n",
    "        self.bn2 = nn.BatchNorm1d(512)\n",
    "        self.fc3 = nn.Linear(512, 256, bias=False)\n",
    "        self.bn3 = nn.BatchNorm1d(256)\n",
    "        self.fc4 = nn.Linear(256, 128, bias=False)\n",
    "        self.bn4 = nn.BatchNorm1d(128)\n",
    "        self.fc5 = nn.Linear(128, 64, bias=False)\n",
    "        self.bn5 = nn.BatchNorm1d(64)\n",
    "        self.fc6 = nn.Linear(64, 32, bias=False)\n",
    "        self.bn6 = nn.BatchNorm1d(32)\n",
    "        self.fc7 = nn.Linear(32, y_dim, bias=False)\n",
    "        # self.relu = nn.LeakyReLU(negative_slope=0.2)\n",
    "        self.relu = nn.ReLU()\n",
    "        \n",
    "    def forward(self, x):\n",
    "        x = self.flatten(x)\n",
    "        # x = self.bn1(self.relu(self.fc1(x)))\n",
    "        # x = self.bn2(self.relu(self.fc2(x)))\n",
    "        # x = self.bn3(self.relu(self.fc3(x)))\n",
    "        # x = self.bn4(self.relu(self.fc4(x)))\n",
    "        # x = self.bn5(self.relu(self.fc5(x)))\n",
    "        # x = self.bn6(self.relu(self.fc6(x)))\n",
    "        x = self.relu(self.fc1(x))\n",
    "        x = self.relu(self.fc2(x))\n",
    "        x = self.relu(self.fc3(x))\n",
    "        x = self.relu(self.fc4(x))\n",
    "        x = self.relu(self.fc5(x))\n",
    "        x = self.relu(self.fc6(x))\n",
    "        x = self.fc7(x)\n",
    "        return x\n",
    "\n",
    "model = MLP(3072, 128, 10).to(device)\n",
    "print(model)\n",
    "utils.display_num_param(model)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "a16c4067-79ee-4b84-8d73-572251ac6595",
   "metadata": {},
   "outputs": [],
   "source": [
    "loss_fn = nn.CrossEntropyLoss()\n",
    "optimizer = torch.optim.Adam(model.parameters(), lr=1e-3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "23d9f3e5-715b-4e2c-98d3-9967b7142294",
   "metadata": {},
   "outputs": [],
   "source": [
    "def train(dataloader, model, loss_fn, optimizer):\n",
    "    size = len(dataloader.dataset)\n",
    "    model.train()\n",
    "    losses = []\n",
    "    for batch, (X, y) in enumerate(dataloader):\n",
    "        X, y = X.to(device), y.to(device)\n",
    "\n",
    "        pred = model(X)\n",
    "        loss = loss_fn(pred, y)\n",
    "\n",
    "        optimizer.zero_grad()\n",
    "        loss.backward()\n",
    "        optimizer.step()\n",
    "\n",
    "        if batch % 100 == 0:\n",
    "            loss, current = loss.item(), batch * len(X)\n",
    "            # print(f\"Loss: {loss:>7f}  [{current:>5d}/{size:>5d}]\")\n",
    "            losses.append(loss)\n",
    "    return losses"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "bf936fea-3d34-4ced-a484-84cabce852c5",
   "metadata": {},
   "outputs": [],
   "source": [
    "def test(dataloader, model, loss_fn):\n",
    "    size = len(dataloader.dataset)\n",
    "    num_batches = len(dataloader)\n",
    "    model.eval()\n",
    "    test_loss, correct = 0, 0\n",
    "    with torch.no_grad():\n",
    "        for X, y in dataloader:\n",
    "            X, y = X.to(device), y.to(device)\n",
    "            pred = model(X)\n",
    "            test_loss += loss_fn(pred, y).item()\n",
    "            correct += (pred.argmax(1) == y).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 * 100"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "46071239-c6b8-4fc3-9f04-cc70419a8ce3",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 1\n",
      "-------------------------------\n",
      "Test Error: \n",
      " Accuracy: 30.9%, Avg loss: 1.989964 \n",
      "\n",
      "Epoch 2\n",
      "-------------------------------\n",
      "Test Error: \n",
      " Accuracy: 35.0%, Avg loss: 1.861700 \n",
      "\n",
      "Epoch 3\n",
      "-------------------------------\n",
      "Test Error: \n",
      " Accuracy: 36.6%, Avg loss: 1.781065 \n",
      "\n",
      "Epoch 4\n",
      "-------------------------------\n",
      "Test Error: \n",
      " Accuracy: 37.0%, Avg loss: 1.789023 \n",
      "\n",
      "Epoch 5\n",
      "-------------------------------\n",
      "Test Error: \n",
      " Accuracy: 38.6%, Avg loss: 1.801456 \n",
      "\n",
      "Epoch 6\n",
      "-------------------------------\n",
      "Test Error: \n",
      " Accuracy: 36.8%, Avg loss: 1.824191 \n",
      "\n",
      "Epoch 7\n",
      "-------------------------------\n",
      "Test Error: \n",
      " Accuracy: 39.9%, Avg loss: 1.734600 \n",
      "\n",
      "Epoch 8\n",
      "-------------------------------\n",
      "Test Error: \n",
      " Accuracy: 38.9%, Avg loss: 1.839155 \n",
      "\n",
      "Epoch 9\n",
      "-------------------------------\n",
      "Test Error: \n",
      " Accuracy: 41.1%, Avg loss: 1.744527 \n",
      "\n",
      "Epoch 10\n",
      "-------------------------------\n",
      "Test Error: \n",
      " Accuracy: 41.3%, Avg loss: 1.770988 \n",
      "\n",
      "Epoch 11\n",
      "-------------------------------\n",
      "Test Error: \n",
      " Accuracy: 40.2%, Avg loss: 1.777155 \n",
      "\n",
      "Epoch 12\n",
      "-------------------------------\n",
      "Test Error: \n",
      " Accuracy: 42.2%, Avg loss: 1.774423 \n",
      "\n",
      "Epoch 13\n",
      "-------------------------------\n",
      "Test Error: \n",
      " Accuracy: 41.8%, Avg loss: 1.719532 \n",
      "\n",
      "Epoch 14\n",
      "-------------------------------\n",
      "Test Error: \n",
      " Accuracy: 41.3%, Avg loss: 1.794394 \n",
      "\n",
      "Epoch 15\n",
      "-------------------------------\n",
      "Test Error: \n",
      " Accuracy: 42.0%, Avg loss: 1.738691 \n",
      "\n",
      "Epoch 16\n",
      "-------------------------------\n",
      "Test Error: \n",
      " Accuracy: 42.7%, Avg loss: 1.755125 \n",
      "\n",
      "Epoch 17\n",
      "-------------------------------\n",
      "Test Error: \n",
      " Accuracy: 41.4%, Avg loss: 1.783282 \n",
      "\n",
      "Epoch 18\n",
      "-------------------------------\n",
      "Test Error: \n",
      " Accuracy: 43.3%, Avg loss: 1.791528 \n",
      "\n",
      "Epoch 19\n",
      "-------------------------------\n",
      "Test Error: \n",
      " Accuracy: 42.9%, Avg loss: 1.757987 \n",
      "\n",
      "Epoch 20\n",
      "-------------------------------\n",
      "Test Error: \n",
      " Accuracy: 42.7%, Avg loss: 1.776884 \n",
      "\n"
     ]
    }
   ],
   "source": [
    "epochs = 20\n",
    "training_losses = []\n",
    "test_accuracy = []\n",
    "for t in range(epochs):\n",
    "    print(f\"Epoch {t+1} - \", end=\"\")\n",
    "    train_losses = train(train_dataloader, model, loss_fn, optimizer)\n",
    "    test_acc = test(test_dataloader, model, loss_fn)\n",
    "    training_losses += train_losses\n",
    "    test_accuracy.append(test_acc)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "dc379b9b-03de-47f9-8062-428fa47aea03",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.title(\"Training losses over 20 epochs\")\n",
    "plt.xlabel(\"Batches\")\n",
    "plt.ylabel(\"Cross Entropy Loss\")\n",
    "plt.plot(training_losses)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "bd060df4-1a90-46a1-80f7-d5d875f70305",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.title(\"Test accuracy over 20 epochs\")\n",
    "plt.xlabel(\"Epochs\")\n",
    "plt.ylabel(\"Accuracy\")\n",
    "plt.plot(test_accuracy)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 344,
   "id": "c3bc9fd4-fe13-4e33-90fe-bf0119289319",
   "metadata": {},
   "outputs": [],
   "source": [
    "def combined_dataset(dataset, size):\n",
    "    combined = {}\n",
    "    for name, data in dataset.items():\n",
    "        if name in dataset:\n",
    "            for clas, d in data.items():\n",
    "                resized = []\n",
    "                for img in d:\n",
    "                    resized.append(cv2.resize(img, (size,size), interpolation=cv2.INTER_AREA))\n",
    "                if clas not in combined:\n",
    "                    combined[clas] = [resized]\n",
    "                else:\n",
    "                    combined[clas].append(resized)\n",
    "    for clas, data in combined.items():\n",
    "        combined[clas] = np.concatenate(data, axis=0)\n",
    "    return combined"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 352,
   "id": "a8eaccdb-ada6-4575-a67d-ad29133354a8",
   "metadata": {},
   "outputs": [],
   "source": [
    "class ImageDataset(Dataset):\n",
    "    def __init__(self, data_dir, size, DOODLES, REAL):\n",
    "        super(ImageDataset, self).__init__()\n",
    "        CLASSES = [\"airplane\", \"car\", \"bird\", \"cat\", \"dog\", \"frog\", \"horse\", \"ship\", \"truck\"]\n",
    "        dataset = np.load(data_dir, allow_pickle=True)[()]\n",
    "        \n",
    "        doodle_dataset = {name: data for name, data in dataset.items() if name in DOODLES}\n",
    "        real_dataset = {name: data for name, data in dataset.items() if name in REAL}\n",
    "        doodles = combined_dataset(doodle_dataset, size)\n",
    "        real = combined_dataset(real_dataset, size)\n",
    "        \n",
    "        class_to_idx = {k: i for i, k in enumerate(CLASSES)}\n",
    "            \n",
    "        self.doodle_data, self.doodle_label = self._return_x_y_pairs(doodles, class_to_idx)\n",
    "        self.real_data, self.real_label = self._return_x_y_pairs(real, class_to_idx)\n",
    "\n",
    "        # data preprocessing\n",
    "        self.doodle_preprocess = transforms.Compose([\n",
    "            transforms.ToPILImage(),\n",
    "            transforms.Resize(size),\n",
    "            transforms.ToTensor(),\n",
    "            transforms.Normalize((self.doodle_data/255).mean(), (self.doodle_data/255).std())\n",
    "        ])\n",
    "        self.real_preprocess = transforms.Compose([\n",
    "            transforms.ToPILImage(),\n",
    "            transforms.Resize(size),\n",
    "            transforms.ToTensor(),\n",
    "            transforms.Normalize((self.real_data/255).mean(axis=(0,1,2,3)), (self.real_data/255).std(axis=(0,1,2,3))),\n",
    "            # transforms.Normalize(self.real_data.mean(), self.real_data.std()),\n",
    "        ])\n",
    "\n",
    "        print(f'Dataset. Doodle data size {len(self.doodle_data)}, real data size {len(self.real_data)}, '\n",
    "              f'ratio {len(self.doodle_data)/len(self.real_data):.3f}, {self.real_data.mean(), self.real_data.std()}')\n",
    "\n",
    "    def _return_x_y_pairs(self, dataset, class_to_idx):\n",
    "        xs, ys = [], []\n",
    "        for clas, data in dataset.items():\n",
    "            labels = [class_to_idx[clas]] * len(data)\n",
    "            xs.append(data)\n",
    "            ys.extend(labels)\n",
    "        return np.concatenate(xs, axis=0), np.array(ys)\n",
    "\n",
    "    def __getitem__(self, idx):\n",
    "        # naive sampling scheme - sample with replacement\n",
    "        doodle_idx, real_idx = random.randint(0, len(self.doodle_data) - 1), random.randint(0, len(self.real_data) - 1)\n",
    "        doodle_data = self.doodle_preprocess(self.doodle_data[doodle_idx])\n",
    "        real_data = self.real_preprocess(self.real_data[real_idx])\n",
    "        return doodle_data, self.doodle_label[doodle_idx], real_data, self.real_label[real_idx]\n",
    "\n",
    "    def __len__(self):\n",
    "        return max(len(self.doodle_data), len(self.real_data))     # could be arbitrary number"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 368,
   "id": "3dbb1b3e-3d2f-4acb-88ff-fd15a88fef24",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Dataset. Doodle data size 7022, real data size 46364, ratio 0.151, (121.70084711243278, 65.10291249861656)\n",
      "Dataset. Doodle data size 1764, real data size 9341, ratio 0.189, (123.28941366940772, 64.57142732393959)\n"
     ]
    }
   ],
   "source": [
    "DOODLES = ['sketchy_doodle', 'tuberlin', 'google_doodles']\n",
    "REAL = ['sketchy_real', 'google_real', 'cifar']\n",
    "train_dataset = ImageDataset(\"dataset/dataset_train.npy\", 32, DOODLES, REAL)\n",
    "test_dataset = ImageDataset(\"dataset/dataset_test.npy\", 32, DOODLES, REAL)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 369,
   "id": "e7f31c2e-9cce-4854-abf4-9bf52fdf23fb",
   "metadata": {},
   "outputs": [],
   "source": [
    "train_dataloader = DataLoader(train_dataset, batch_size=32, shuffle=True)\n",
    "test_dataloader = DataLoader(test_dataset, batch_size=32, shuffle=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 374,
   "id": "d41868e8-1407-4216-a9ab-73d719683cca",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "MLP(\n",
      "  (flatten): Flatten(start_dim=1, end_dim=-1)\n",
      "  (fc1): Linear(in_features=1024, out_features=1024, bias=False)\n",
      "  (bn1): BatchNorm1d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "  (fc2): Linear(in_features=1024, out_features=512, bias=False)\n",
      "  (bn2): BatchNorm1d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "  (fc3): Linear(in_features=512, out_features=256, bias=False)\n",
      "  (bn3): BatchNorm1d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "  (fc4): Linear(in_features=256, out_features=128, bias=False)\n",
      "  (bn4): BatchNorm1d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "  (fc5): Linear(in_features=128, out_features=64, bias=False)\n",
      "  (bn5): BatchNorm1d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "  (fc6): Linear(in_features=64, out_features=32, bias=False)\n",
      "  (bn6): BatchNorm1d(32, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "  (fc7): Linear(in_features=32, out_features=10, bias=False)\n",
      "  (relu): ReLU()\n",
      ")\n",
      "There are 1751296 (1.75 million) parameters in this neural network\n"
     ]
    }
   ],
   "source": [
    "model = MLP(1024, 128, 10).to(device)\n",
    "# model = MLP(3072, 128, 10).to(device)\n",
    "print(model)\n",
    "utils.display_num_param(model)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 375,
   "id": "40fd8b02-41b4-46b7-9446-834bee87766b",
   "metadata": {},
   "outputs": [],
   "source": [
    "loss_fn = nn.CrossEntropyLoss()\n",
    "optimizer = torch.optim.Adam(model.parameters(), lr=1e-3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 376,
   "id": "2c990e5f-8dc1-4db3-9766-28bd1bf5b852",
   "metadata": {},
   "outputs": [],
   "source": [
    "def train(dataloader, model, loss_fn, optimizer):\n",
    "    size = len(dataloader.dataset)\n",
    "    model.train()\n",
    "    losses = []\n",
    "    for batch, (X, y, _, _) in enumerate(dataloader):\n",
    "        X, y = X.to(device), y.to(device).type(torch.LongTensor)\n",
    "\n",
    "        pred = model(X)\n",
    "        loss = loss_fn(pred, y)\n",
    "\n",
    "        optimizer.zero_grad()\n",
    "        loss.backward()\n",
    "        optimizer.step()\n",
    "\n",
    "        if batch % 100 == 0:\n",
    "            loss, current = loss.item(), batch * len(X)\n",
    "            correct = (pred.argmax(1) == y).type(torch.float).sum().item()\n",
    "            print(f\"Loss: {loss:>7f}  [{current:>5d}/{size:>5d}], Acc: {(100*correct/len(X)):>0.1f}%\")\n",
    "            losses.append(loss)\n",
    "    return losses\n",
    "\n",
    "def test(dataloader, model, loss_fn):\n",
    "    size = len(dataloader.dataset)\n",
    "    num_batches = len(dataloader)\n",
    "    # model.eval()\n",
    "    test_loss, correct = 0, 0\n",
    "    with torch.no_grad():\n",
    "        for X, y, _, _ in dataloader:\n",
    "            X, y = X.to(device), y.to(device).type(torch.LongTensor)\n",
    "            pred = model(X)\n",
    "            test_loss += loss_fn(pred, y).item()\n",
    "            correct += (pred.argmax(1) == y).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 * 100"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 377,
   "id": "1fc1eebe-f83d-40a8-9cb0-49aa62664ce1",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 1 - Loss: 2.302975  [    0/46364], Acc: 9.4%\n",
      "Loss: 2.073838  [ 3200/46364], Acc: 28.1%\n",
      "Loss: 1.884107  [ 6400/46364], Acc: 28.1%\n",
      "Loss: 2.012756  [ 9600/46364], Acc: 15.6%\n",
      "Loss: 1.795143  [12800/46364], Acc: 15.6%\n",
      "Loss: 1.671877  [16000/46364], Acc: 43.8%\n",
      "Loss: 1.920967  [19200/46364], Acc: 25.0%\n",
      "Loss: 1.634478  [22400/46364], Acc: 31.2%\n",
      "Loss: 1.579832  [25600/46364], Acc: 37.5%\n",
      "Loss: 1.860176  [28800/46364], Acc: 28.1%\n",
      "Loss: 1.348436  [32000/46364], Acc: 40.6%\n",
      "Loss: 1.363034  [35200/46364], Acc: 43.8%\n",
      "Loss: 1.179522  [38400/46364], Acc: 46.9%\n",
      "Loss: 1.415623  [41600/46364], Acc: 40.6%\n",
      "Loss: 1.252884  [44800/46364], Acc: 59.4%\n",
      "Test Error: \n",
      " Accuracy: 33.6%, Avg loss: 1.979432 \n",
      "\n",
      "Epoch 2 - Loss: 1.186353  [    0/46364], Acc: 59.4%\n",
      "Loss: 1.301276  [ 3200/46364], Acc: 59.4%\n",
      "Loss: 1.161498  [ 6400/46364], Acc: 62.5%\n",
      "Loss: 1.242755  [ 9600/46364], Acc: 43.8%\n",
      "Loss: 1.174426  [12800/46364], Acc: 59.4%\n",
      "Loss: 1.273609  [16000/46364], Acc: 40.6%\n",
      "Loss: 1.028116  [19200/46364], Acc: 59.4%\n",
      "Loss: 1.026072  [22400/46364], Acc: 62.5%\n",
      "Loss: 0.696393  [25600/46364], Acc: 78.1%\n",
      "Loss: 0.914882  [28800/46364], Acc: 65.6%\n",
      "Loss: 0.901957  [32000/46364], Acc: 59.4%\n",
      "Loss: 0.797977  [35200/46364], Acc: 68.8%\n",
      "Loss: 0.953715  [38400/46364], Acc: 65.6%\n",
      "Loss: 0.769274  [41600/46364], Acc: 75.0%\n",
      "Loss: 0.604509  [44800/46364], Acc: 81.2%\n",
      "Test Error: \n",
      " Accuracy: 35.9%, Avg loss: 2.634560 \n",
      "\n",
      "Epoch 3 - Loss: 0.790541  [    0/46364], Acc: 71.9%\n",
      "Loss: 0.592960  [ 3200/46364], Acc: 78.1%\n",
      "Loss: 0.708034  [ 6400/46364], Acc: 75.0%\n"
     ]
    },
    {
     "ename": "KeyboardInterrupt",
     "evalue": "",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mKeyboardInterrupt\u001b[0m                         Traceback (most recent call last)",
      "\u001b[1;32m~\\AppData\\Local\\Temp\\ipykernel_9276\\3545123021.py\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[0;32m      4\u001b[0m \u001b[1;32mfor\u001b[0m \u001b[0mt\u001b[0m \u001b[1;32min\u001b[0m \u001b[0mrange\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mepochs\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m      5\u001b[0m     \u001b[0mprint\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;34mf\"Epoch {t+1} - \"\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mend\u001b[0m\u001b[1;33m=\u001b[0m\u001b[1;34m\"\"\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m----> 6\u001b[1;33m     \u001b[0mtrain_losses\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mtrain\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mtrain_dataloader\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mmodel\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mloss_fn\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0moptimizer\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m      7\u001b[0m     \u001b[0mtest_acc\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mtest\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mtest_dataloader\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mmodel\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mloss_fn\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m      8\u001b[0m     \u001b[0mtraining_losses\u001b[0m \u001b[1;33m+=\u001b[0m \u001b[0mtrain_losses\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;32m~\\AppData\\Local\\Temp\\ipykernel_9276\\1369473269.py\u001b[0m in \u001b[0;36mtrain\u001b[1;34m(dataloader, model, loss_fn, optimizer)\u001b[0m\n\u001b[0;32m      6\u001b[0m         \u001b[0mX\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0my\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mX\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mto\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mdevice\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0my\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mto\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mdevice\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mtype\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mtorch\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mLongTensor\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m      7\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m----> 8\u001b[1;33m         \u001b[0mpred\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mmodel\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mX\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m      9\u001b[0m         \u001b[0mloss\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mloss_fn\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mpred\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0my\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m     10\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;32m~\\anaconda3\\envs\\cs4243\\lib\\site-packages\\torch\\nn\\modules\\module.py\u001b[0m in \u001b[0;36m_call_impl\u001b[1;34m(self, *input, **kwargs)\u001b[0m\n\u001b[0;32m   1049\u001b[0m         if not (self._backward_hooks or self._forward_hooks or self._forward_pre_hooks or _global_backward_hooks\n\u001b[0;32m   1050\u001b[0m                 or _global_forward_hooks or _global_forward_pre_hooks):\n\u001b[1;32m-> 1051\u001b[1;33m             \u001b[1;32mreturn\u001b[0m \u001b[0mforward_call\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m*\u001b[0m\u001b[0minput\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;33m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m   1052\u001b[0m         \u001b[1;31m# Do not call functions when jit is used\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m   1053\u001b[0m         \u001b[0mfull_backward_hooks\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mnon_full_backward_hooks\u001b[0m \u001b[1;33m=\u001b[0m \u001b[1;33m[\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;33m[\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;32m~\\AppData\\Local\\Temp\\ipykernel_9276\\2206837060.py\u001b[0m in \u001b[0;36mforward\u001b[1;34m(self, x)\u001b[0m\n\u001b[0;32m     30\u001b[0m         \u001b[1;31m# x = self.bn5(self.relu(self.fc5(x)))\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m     31\u001b[0m         \u001b[1;31m# x = self.bn6(self.relu(self.fc6(x)))\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m---> 32\u001b[1;33m         \u001b[0mx\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mrelu\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mfc1\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mx\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m     33\u001b[0m         \u001b[0mx\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mrelu\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mfc2\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mx\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m     34\u001b[0m         \u001b[0mx\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mrelu\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mfc3\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mx\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;32m~\\anaconda3\\envs\\cs4243\\lib\\site-packages\\torch\\nn\\modules\\module.py\u001b[0m in \u001b[0;36m_call_impl\u001b[1;34m(self, *input, **kwargs)\u001b[0m\n\u001b[0;32m   1049\u001b[0m         if not (self._backward_hooks or self._forward_hooks or self._forward_pre_hooks or _global_backward_hooks\n\u001b[0;32m   1050\u001b[0m                 or _global_forward_hooks or _global_forward_pre_hooks):\n\u001b[1;32m-> 1051\u001b[1;33m             \u001b[1;32mreturn\u001b[0m \u001b[0mforward_call\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m*\u001b[0m\u001b[0minput\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;33m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m   1052\u001b[0m         \u001b[1;31m# Do not call functions when jit is used\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m   1053\u001b[0m         \u001b[0mfull_backward_hooks\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mnon_full_backward_hooks\u001b[0m \u001b[1;33m=\u001b[0m \u001b[1;33m[\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;33m[\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;32m~\\anaconda3\\envs\\cs4243\\lib\\site-packages\\torch\\nn\\modules\\linear.py\u001b[0m in \u001b[0;36mforward\u001b[1;34m(self, input)\u001b[0m\n\u001b[0;32m     94\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m     95\u001b[0m     \u001b[1;32mdef\u001b[0m \u001b[0mforward\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mself\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0minput\u001b[0m\u001b[1;33m:\u001b[0m \u001b[0mTensor\u001b[0m\u001b[1;33m)\u001b[0m \u001b[1;33m->\u001b[0m \u001b[0mTensor\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m---> 96\u001b[1;33m         \u001b[1;32mreturn\u001b[0m \u001b[0mF\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mlinear\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0minput\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mweight\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mbias\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m     97\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m     98\u001b[0m     \u001b[1;32mdef\u001b[0m \u001b[0mextra_repr\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mself\u001b[0m\u001b[1;33m)\u001b[0m \u001b[1;33m->\u001b[0m \u001b[0mstr\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;32m~\\anaconda3\\envs\\cs4243\\lib\\site-packages\\torch\\nn\\functional.py\u001b[0m in \u001b[0;36mlinear\u001b[1;34m(input, weight, bias)\u001b[0m\n\u001b[0;32m   1845\u001b[0m     \u001b[1;32mif\u001b[0m \u001b[0mhas_torch_function_variadic\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0minput\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mweight\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m   1846\u001b[0m         \u001b[1;32mreturn\u001b[0m \u001b[0mhandle_torch_function\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mlinear\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;33m(\u001b[0m\u001b[0minput\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mweight\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0minput\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mweight\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mbias\u001b[0m\u001b[1;33m=\u001b[0m\u001b[0mbias\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m-> 1847\u001b[1;33m     \u001b[1;32mreturn\u001b[0m \u001b[0mtorch\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0m_C\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0m_nn\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mlinear\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0minput\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mweight\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mbias\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m   1848\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m   1849\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;31mKeyboardInterrupt\u001b[0m: "
     ]
    }
   ],
   "source": [
    "epochs = 20\n",
    "training_losses = []\n",
    "test_accuracy = []\n",
    "for t in range(epochs):\n",
    "    print(f\"Epoch {t+1} - \", end=\"\")\n",
    "    train_losses = train(train_dataloader, model, loss_fn, optimizer)\n",
    "    test_acc = test(test_dataloader, model, loss_fn)\n",
    "    training_losses += train_losses\n",
    "    test_accuracy.append(test_acc)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "e34b5ba8-3fa0-4b14-b650-aaafc7b67979",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "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.7.10"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}