notebooks/[demo] pytorch softmax regression & MLP.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "59e21222",
   "metadata": {},
   "outputs": [],
   "source": [
    "import torch\n",
    "import matplotlib.pyplot as plt\n",
    "plt.rc('font', size=16)\n",
    "\n",
    "%matplotlib inline\n",
    "%config InlineBackend.figure_format = 'retina'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "a4a4059a",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "device(type='cpu')"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "device = torch.device(\"cuda:0\" if torch.cuda.is_available() else \"cpu\")\n",
    "device"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "75872441",
   "metadata": {},
   "source": [
    "# 1. Data\n",
    "\n",
    "more on Pytorch **DATASETS** & **DATALOADERS** : https://pytorch.org/tutorials/beginner/basics/data_tutorial.html"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "da276e58",
   "metadata": {},
   "source": [
    "## 1.1 load dataset\n",
    "\n",
    "### - build-in datasets in pytorch : [torchvision.datasets](https://pytorch.org/vision/stable/datasets.html)\n",
    "\n",
    "### - dataset transforms : [torchvision.transforms](https://pytorch.org/vision/stable/transforms.html)\n",
    "\n",
    "`ToTensor` converts the image data from PIL type to 32-bit floating point tensors. It divides all numbers by 255 so that all pixel values are between 0 and 1."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "5deb7126",
   "metadata": {},
   "outputs": [],
   "source": [
    "import torch.nn as nn\n",
    "from torchvision import datasets, transforms"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "3ffd47c0",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Downloading http://fashion-mnist.s3-website.eu-central-1.amazonaws.com/train-images-idx3-ubyte.gz to ../../data/FashionMNIST/raw/train-images-idx3-ubyte.gz\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "47ae819db559450f807d79aebd26f02b",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "0it [00:00, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Extracting ../../data/FashionMNIST/raw/train-images-idx3-ubyte.gz to ../../data/FashionMNIST/raw\n",
      "Downloading http://fashion-mnist.s3-website.eu-central-1.amazonaws.com/train-labels-idx1-ubyte.gz to ../../data/FashionMNIST/raw/train-labels-idx1-ubyte.gz\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "1630338105d54af2a52503c51e3b2d0a",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "0it [00:00, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Extracting ../../data/FashionMNIST/raw/train-labels-idx1-ubyte.gz to ../../data/FashionMNIST/raw\n",
      "Downloading http://fashion-mnist.s3-website.eu-central-1.amazonaws.com/t10k-images-idx3-ubyte.gz to ../../data/FashionMNIST/raw/t10k-images-idx3-ubyte.gz\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "78a187ade57a47bdb18cdbd634120f7a",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "0it [00:00, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Extracting ../../data/FashionMNIST/raw/t10k-images-idx3-ubyte.gz to ../../data/FashionMNIST/raw\n",
      "Downloading http://fashion-mnist.s3-website.eu-central-1.amazonaws.com/t10k-labels-idx1-ubyte.gz to ../../data/FashionMNIST/raw/t10k-labels-idx1-ubyte.gz\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "86070eb8155f46ceb86b59705660a5c6",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "0it [00:00, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Extracting ../../data/FashionMNIST/raw/t10k-labels-idx1-ubyte.gz to ../../data/FashionMNIST/raw\n",
      "Processing...\n",
      "Done!\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/Users/hhg/opt/anaconda3/lib/python3.7/site-packages/torchvision/datasets/mnist.py:480: UserWarning: The given NumPy array is not writeable, and PyTorch does not support non-writeable tensors. This means you can write to the underlying (supposedly non-writeable) NumPy array using the tensor. You may want to copy the array to protect its data or make it writeable before converting it to a tensor. This type of warning will be suppressed for the rest of this program. (Triggered internally at  /Users/distiller/project/conda/conda-bld/pytorch_1603729051302/work/torch/csrc/utils/tensor_numpy.cpp:141.)\n",
      "  return torch.from_numpy(parsed.astype(m[2], copy=False)).view(*s)\n"
     ]
    }
   ],
   "source": [
    "fmnist_train = datasets.FashionMNIST(\n",
    "    root=\"../../data\", train=True, transform=transforms.ToTensor(), download=True)\n",
    "fmnist_test = datasets.FashionMNIST(\n",
    "    root=\"../../data\", train=False, transform=transforms.ToTensor(), download=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "7e5c3732",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Dataset FashionMNIST\n",
       "    Number of datapoints: 60000\n",
       "    Root location: ../../data\n",
       "    Split: Train\n",
       "    StandardTransform\n",
       "Transform: ToTensor()"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "fmnist_train"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "a11a1bac",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Dataset FashionMNIST\n",
       "    Number of datapoints: 10000\n",
       "    Root location: ../../data\n",
       "    Split: Test\n",
       "    StandardTransform\n",
       "Transform: ToTensor()"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "fmnist_test"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "95d3b40c",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 936x288 with 5 Axes>"
      ]
     },
     "metadata": {
      "image/png": {
       "height": 174,
       "width": 739
      },
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "labels_map = {\n",
    "    0: \"T-Shirt\",\n",
    "    1: \"Trouser\",\n",
    "    2: \"Pullover\",\n",
    "    3: \"Dress\",\n",
    "    4: \"Coat\",\n",
    "    5: \"Sandal\",\n",
    "    6: \"Shirt\",\n",
    "    7: \"Sneaker\",\n",
    "    8: \"Bag\",\n",
    "    9: \"Ankle Boot\",\n",
    "}\n",
    "\n",
    "fig, axes = plt.subplots(1, 5, figsize=(13, 4))\n",
    "plt.subplots_adjust(hspace=0.001, wspace=0.001)\n",
    "\n",
    "for i in range(5):\n",
    "    image, label = fmnist_train.__getitem__(i)\n",
    "    axes[i].imshow(image.squeeze().numpy())\n",
    "    axes[i].set_title(f'{label} : {labels_map[label]}')\n",
    "    axes[i].axis('off')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "a11be2c2",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "torch.Size([1, 28, 28])"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ID = 10\n",
    "image, label = fmnist_train.__getitem__(ID)\n",
    "image.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "d5541669",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "torch.Size([28, 28])"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "image.squeeze().shape # squeeze : removes all dimensions of size 1 (a,1,b,1) -> (a,b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "64aae77e",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "numpy.ndarray"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(image.squeeze().numpy())"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c4a69e2c",
   "metadata": {},
   "source": [
    "## 1.2 DataLoader"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "cca97a70",
   "metadata": {},
   "outputs": [],
   "source": [
    "from torch.utils.data import DataLoader"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "12b1b9e0",
   "metadata": {},
   "outputs": [],
   "source": [
    "batch_size = 100\n",
    "\n",
    "train_loader = DataLoader(fmnist_train, batch_size=batch_size, shuffle=True)\n",
    "test_loader = DataLoader(fmnist_test, batch_size=batch_size, shuffle=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "33d85d75",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Feature batch shape: torch.Size([100, 1, 28, 28])\n",
      "Labels batch shape: torch.Size([100])\n"
     ]
    }
   ],
   "source": [
    "# Iterate through DataLoader\n",
    "train_images, train_labels = next(iter(train_loader))\n",
    "print(f\"Feature batch shape: {train_images.shape}\")\n",
    "print(f\"Labels batch shape: {train_labels.shape}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "e5f3d5cc",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Number of iterations per epoch 600\n"
     ]
    }
   ],
   "source": [
    "print('Number of iterations per epoch', len(train_loader)) # 60000 // batch_size + 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "4845969a",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 144x144 with 1 Axes>"
      ]
     },
     "metadata": {
      "image/png": {
       "height": 138,
       "width": 123
      },
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "img = train_images[0].squeeze().numpy() # train_images[0].shape = (1, 28, 28)\n",
    "                                        # train_images[0].squeeze().shape = (28,28)\n",
    "                                        # tensor.numpy() -> transform pytorch tensor to numpy array\n",
    "label = int(train_labels[0].numpy())\n",
    "\n",
    "# plot\n",
    "plt.figure(figsize=(2, 2))\n",
    "plt.imshow(img)\n",
    "plt.title(f'{label} : {labels_map[label]}')\n",
    "plt.axis('off')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "913730ed",
   "metadata": {},
   "source": [
    "# 2. Model\n",
    "\n",
    "### [torch.nn](https://pytorch.org/tutorials/beginner/nn_tutorial.html) modules -- a base class used to develop all neural network models"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "fa35ce3a",
   "metadata": {},
   "outputs": [],
   "source": [
    "import torch.nn as nn"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "8866de90",
   "metadata": {},
   "outputs": [],
   "source": [
    "input_size = 28*28\n",
    "output_size = 10\n",
    "hidden_size = 256\n",
    "\n",
    "## --- Model 1 (d2l §3.5 ~ §3.7) -------------------------\n",
    "## ------ Softmax Regression (single layer network) ------\n",
    "## -------------------------------------------------------\n",
    "\n",
    "class SoftmaxRegressionNet(nn.Module):\n",
    "    def __init__(self, input_size, output_size):\n",
    "        super().__init__()\n",
    "        self.input_size = input_size\n",
    "        self.linear = nn.Linear(input_size, output_size)\n",
    "    \n",
    "    def forward(self, x):\n",
    "        o = self.linear(x)              # o : output logits (Note! softmax activation not applied yet.)\n",
    "        return o\n",
    "\n",
    "## --- Model 2 (d2l §4.2 ~ §4.3) -------------------------\n",
    "## ------ MLP with 1 hidden layer (2 layer network) ------ \n",
    "## -------------------------------------------------------\n",
    "\n",
    "class MLP(nn.Module):\n",
    "    def __init__(self, input_size, hidden_size, output_size):\n",
    "        super().__init__()\n",
    "        self.input_size = input_size\n",
    "        \n",
    "        self.linear1 = nn.Linear(input_size, hidden_size)\n",
    "        self.relu = nn.ReLU()\n",
    "        self.linear2 = nn.Linear(hidden_size, output_size)\n",
    "    \n",
    "    def forward(self, x):            \n",
    "        o = self.linear1(x)\n",
    "        o = self.relu(o)\n",
    "        o = self.linear2(o)\n",
    "        return o"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "e810e8e2",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "MLP(\n",
       "  (linear1): Linear(in_features=784, out_features=256, bias=True)\n",
       "  (relu): ReLU()\n",
       "  (linear2): Linear(in_features=256, out_features=10, bias=True)\n",
       ")"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#model = SoftmaxRegressionNet(input_size, output_size)\n",
    "model = MLP(input_size, hidden_size, output_size)\n",
    "model.to(device)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "b7b69587",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "TOTAL  : 203530\n"
     ]
    }
   ],
   "source": [
    "# count model parameters\n",
    "print('TOTAL  :', sum(param.numel() for param in model.parameters() if param.requires_grad))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7240cba7",
   "metadata": {},
   "source": [
    "# 3. Loss"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "id": "0cb09664",
   "metadata": {},
   "outputs": [],
   "source": [
    "criterion = nn.CrossEntropyLoss()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "920b4066",
   "metadata": {},
   "source": [
    "Usage : `loss = criterion(Y_pred, Y)`\n",
    "\n",
    "**Careful!** <br>\n",
    "`nn.CrossEntropyLoss` applies: ``nn.LogSoftmax`` and ``nn.NLLLoss`` (negative log likelihood loss). <br>\n",
    "So don't apply softmax in the forward loop. <br>\n",
    "``Y`` is class (digit) labels, not one-hot!   <br>\n",
    "``Y_pred`` has raw scores (logits), no Softmax!"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "40dfe373",
   "metadata": {},
   "source": [
    "# 4. Optimization"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "id": "1510d273",
   "metadata": {},
   "outputs": [],
   "source": [
    "import torch.optim as optim"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "id": "68b71808",
   "metadata": {},
   "outputs": [],
   "source": [
    "learning_rate = 0.1\n",
    "optimizer = torch.optim.SGD(model.parameters(), lr=learning_rate)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "796d136a",
   "metadata": {},
   "source": [
    "# 5. Training Loop\n",
    "\n",
    "### loss.backward() : calculate dloss/dw_i \n",
    "\n",
    "### optimizer.step()  : update network parameters (w_i)\n",
    "\n",
    "### optimizer.zero_grad() \n",
    "Whenever `loss.backward()` is called, it'll write the gradients and accumulate them in the w_i.grad attribute. <br>\n",
    "e.g. try to print out `model.linear1.weight.grad` <br>\n",
    "So we need to call `optimizer.zero_grad()` to zero gradient again and again for every iteration."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "id": "45435ad9",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epoch 1/10, step 200/600, loss=0.6474\n",
      "epoch 1/10, step 400/600, loss=0.4925\n",
      "epoch 1/10, step 600/600, loss=0.5004\n",
      "--- End epoch 1 training, accuracy = 76.63%, avgLoss = 0.6824\n",
      "epoch 2/10, step 200/600, loss=0.6122\n",
      "epoch 2/10, step 400/600, loss=0.3900\n",
      "epoch 2/10, step 600/600, loss=0.4404\n",
      "--- End epoch 2 training, accuracy = 83.29%, avgLoss = 0.4716\n",
      "epoch 3/10, step 200/600, loss=0.5268\n",
      "epoch 3/10, step 400/600, loss=0.5635\n",
      "epoch 3/10, step 600/600, loss=0.4728\n",
      "--- End epoch 3 training, accuracy = 85.29%, avgLoss = 0.4174\n",
      "epoch 4/10, step 200/600, loss=0.3626\n",
      "epoch 4/10, step 400/600, loss=0.4187\n",
      "epoch 4/10, step 600/600, loss=0.3936\n",
      "--- End epoch 4 training, accuracy = 86.15%, avgLoss = 0.3900\n",
      "epoch 5/10, step 200/600, loss=0.3520\n",
      "epoch 5/10, step 400/600, loss=0.4255\n",
      "epoch 5/10, step 600/600, loss=0.5084\n",
      "--- End epoch 5 training, accuracy = 86.76%, avgLoss = 0.3699\n",
      "epoch 6/10, step 200/600, loss=0.4321\n",
      "epoch 6/10, step 400/600, loss=0.3819\n",
      "epoch 6/10, step 600/600, loss=0.4184\n",
      "--- End epoch 6 training, accuracy = 87.33%, avgLoss = 0.3535\n",
      "epoch 7/10, step 200/600, loss=0.2836\n",
      "epoch 7/10, step 400/600, loss=0.4043\n",
      "epoch 7/10, step 600/600, loss=0.2023\n",
      "--- End epoch 7 training, accuracy = 87.72%, avgLoss = 0.3384\n",
      "epoch 8/10, step 200/600, loss=0.3593\n",
      "epoch 8/10, step 400/600, loss=0.3362\n",
      "epoch 8/10, step 600/600, loss=0.2186\n",
      "--- End epoch 8 training, accuracy = 88.14%, avgLoss = 0.3280\n",
      "epoch 9/10, step 200/600, loss=0.5180\n",
      "epoch 9/10, step 400/600, loss=0.4941\n",
      "epoch 9/10, step 600/600, loss=0.3080\n",
      "--- End epoch 9 training, accuracy = 88.53%, avgLoss = 0.3193\n",
      "epoch 10/10, step 200/600, loss=0.2565\n",
      "epoch 10/10, step 400/600, loss=0.3456\n",
      "epoch 10/10, step 600/600, loss=0.4731\n",
      "--- End epoch 10 training, accuracy = 88.84%, avgLoss = 0.3091\n"
     ]
    }
   ],
   "source": [
    "num_epochs = 10\n",
    "\n",
    "# training loop\n",
    "n_total_steps = len(train_loader)\n",
    "\n",
    "train_loss = []\n",
    "train_acc  = []\n",
    "for epoch in range(num_epochs):\n",
    "    running_loss = 0.\n",
    "    running_corrects = 0\n",
    "    for i, (images, labels) in enumerate(train_loader):\n",
    "        # reshape images with torch.view (size -1 is inferred from other dimensions) and push it to the device\n",
    "        # 100, 1, 28, 28\n",
    "        # 100, 784 (784-> input_size)\n",
    "        images = images.reshape(-1, 28*28).to(device) \n",
    "        labels = labels.to(device)\n",
    "        \n",
    "        # forward\n",
    "        outputs = model(images)\n",
    "        \n",
    "        # loss\n",
    "        loss = criterion(outputs, labels) # predicted outputs v.s. actual labels\n",
    "        \n",
    "        # backwards\n",
    "        optimizer.zero_grad()  # zero gradient\n",
    "        loss.backward()        # loss.backward would calculate dloss/dw_i  \n",
    "        optimizer.step()       # update network parameters (w_i)\n",
    "        \n",
    "        # compute statistics (avg. loss, accuracy)\n",
    "        running_loss += loss.item() * labels.size(0)\n",
    "        _, predictions = torch.max(outputs, 1)\n",
    "        running_corrects += torch.sum(predictions == labels.data)\n",
    "        \n",
    "        if (i+1)%200 == 0: # every 200 steps, print something\n",
    "            print(f'epoch {epoch+1}/{num_epochs}, step {i+1}/{n_total_steps}, loss={loss.item():.4f}')\n",
    "    \n",
    "    epoch_loss = running_loss / len(fmnist_train)            ; train_loss.append(epoch_loss)\n",
    "    epoch_acc  = running_corrects / len(fmnist_train) * 100. ; train_acc.append(epoch_acc)\n",
    "    print(f'--- End epoch {epoch+1} training, accuracy = {epoch_acc:.2f}%, avgLoss = {epoch_loss:.4f}')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "id": "9df26d96",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "accuracy = 87.0%\n"
     ]
    }
   ],
   "source": [
    "# test and evaluation\n",
    "with torch.no_grad():\n",
    "    \n",
    "    n_correct = 0\n",
    "    n_samples = 0\n",
    "    \n",
    "    for images, labels in test_loader:\n",
    "        images = images.reshape(-1, 28*28).to(device)\n",
    "        labels = labels.to(device)\n",
    "        outputs = model(images)\n",
    "        \n",
    "        # compute statistics (avg. loss, accuracy)\n",
    "        _, predictions = torch.max(outputs, 1)\n",
    "        n_correct += torch.sum(predictions == labels.data) # n_correct += (predictions == labels).sum().item()\n",
    "\n",
    "    test_acc = 100.*n_correct/len(test_loader.dataset)\n",
    "    print(f'accuracy = {test_acc}%')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "id": "74b0e419",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1080x360 with 2 Axes>"
      ]
     },
     "metadata": {
      "image/png": {
       "height": 337,
       "width": 887
      },
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "fig, ax = plt.subplots(1, 2, figsize=(15, 5))\n",
    "plt.rc('font', size=16)\n",
    "\n",
    "ax[0].plot(range(1,11), train_loss, 'o--', label='training set', color='b')\n",
    "ax[1].plot(range(1,11), train_acc, 'o--', label='training set', color='b')\n",
    "\n",
    "\n",
    "ax[1].axhline(test_acc , color='darkred', label='test set')\n",
    "\n",
    "ax[1].set_title(f'test accuracy: {test_acc:.3}%')\n",
    "\n",
    "ax[0].set_ylabel('loss')\n",
    "ax[1].set_ylabel('accuracy')\n",
    "\n",
    "for i in range(2):\n",
    "    ax[i].set_xlabel('epoch')\n",
    "    ax[i].legend(loc='best')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "073ed5f6",
   "metadata": {},
   "source": [
    "# ------------ End ------------"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "328fd057",
   "metadata": {},
   "source": [
    "## Nice tutorials for learning pytorch\n",
    "\n",
    "- Introduction to PyTorch youtube series https://pytorch.org/tutorials/beginner/introyt.html\n",
    "- https://www.youtube.com/watch?v=EMXfZB8FVUA&list=PLqnslRFeH2UrcDBWF5mfPGpqQDSta6VK4"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "a858c480",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "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.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}