BasicsPytorch.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "BasicsPytorch.ipynb",
      "provenance": [],
      "collapsed_sections": [
        "8YRhSo0Ib2ez"
      ]
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "accelerator": "GPU"
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "RBgX0O-62juD",
        "colab_type": "text"
      },
      "source": [
        "#Import\n",
        "\n",
        "Libraries are usually imported in the beginning."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "PjLUKYHvQHse",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "import numpy as np\n",
        "import torch\n",
        "import torch.nn as nn\n",
        "import torch.nn.functional as F\n",
        "import torch.optim as optim\n",
        "\n",
        "import torchvision\n",
        "import torchvision.transforms as transforms\n",
        "import torchvision.transforms.functional as FT\n",
        "\n",
        "import matplotlib.pyplot as plt "
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "pjQIlWcb24aa",
        "colab_type": "text"
      },
      "source": [
        "# GPU Check\n",
        "\n",
        "You can usually check the version of most libraries by calling the `__version__` attribute.\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "uhfSo3uOUh-y",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "torch.__version__"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "qeItoIO53MkU",
        "colab_type": "text"
      },
      "source": [
        "You can check if the GPU is being used by running the following command."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "U1ZjftJVblQ7",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "torch.cuda.is_available()"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "SwvaSrFP3pPA",
        "colab_type": "text"
      },
      "source": [
        "Use the following line of code whenever writing deep learning code, since it gives flexibility to the user."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "6tfTEGJTXQY-",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "device = 'cuda' if torch.cuda.is_available() else 'cpu'"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "L2LxWxnUXG_N",
        "colab_type": "text"
      },
      "source": [
        "# Tensor Basics"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "bcb-MEBNbvPg",
        "colab_type": "text"
      },
      "source": [
        "## Defining Tensors\n",
        "\n",
        "You can initialize tensors in many ways. The most common ones are `.tensor()`, `.rand()` and `.zeros()`."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "oKx3DxlSXI6p",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "x = torch.empty(5, 3)\n",
        "print(x)\n",
        "print(x.size())"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "NecMOHxj4iq_",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "y = torch.rand(5, 3)\n",
        "print(y)\n",
        "print(y.shape)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "OrRGZ2zYbo31",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "x = torch.tensor([1, 2, 3])\n",
        "print(x)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Ecv7crZLbqPb",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "y = torch.rand_like(x, dtype=torch.float32)\n",
        "print(y)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Gqd45P6Sbq_U",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "y.shape"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "SNaOqVYMboKp",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "z = torch.zeros((5, 3), dtype=torch.float32, device=device)\n",
        "print(z)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "colab_type": "text",
        "id": "8YRhSo0Ib2ez"
      },
      "source": [
        "## Tensor Operations\n",
        "\n",
        "You can usually perform operations on torch tensors in more ways than 1."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "w93fFgbK6cxD",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "print(x)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "g-QWyIYW6etr",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "print(y)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Lu732dTYbrzr",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "z1 = x + y\n",
        "print(z1)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "yYvNdeRTb6Iy",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "z2 = torch.add(x, y)\n",
        "print(z2)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "3vX9ClvH7P-z",
        "colab_type": "text"
      },
      "source": [
        "You can either perform `out-place` operations:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "PNAASSm_7sKo",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "r1 = torch.Tensor(2,3)\n",
        "torch.add(x, y, out=r1)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "e_mTx4du626T",
        "colab_type": "text"
      },
      "source": [
        "Or can perform `in-place` operations:\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "05c86dGhb6zi",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "y.add_(x)\n",
        "print(y)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "FExLGL7qAd-X",
        "colab_type": "text"
      },
      "source": [
        "There is a difference between `x + y` and `x+=y`."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "RJQSrfWFb8OP",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "print(id(x))\n",
        "\n",
        "x = x + y\n",
        "print(id(x))\n",
        "\n",
        "x += y\n",
        "print(id(x))"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "colab_type": "text",
        "id": "FPFxFhdXcC2i"
      },
      "source": [
        "## Reshaping Tensors"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "er5wnkq_b9l7",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "x = torch.randn(4, 4)\n",
        "y = x.view(16)\n",
        "z = x.view(-1, 8)  # the size -1 is inferred from other dimensions\n",
        "\n",
        "print(x.size(), y.size(), z.size())"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "1_BSCuF_cJxt",
        "colab_type": "text"
      },
      "source": [
        "## Torch tensors to NumPy arrays and back"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "fiBi6oancGcm",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "x = torch.rand((3, 3))\n",
        "print(x)\n",
        "print(type(x))"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "jjhRtRH6cKgg",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "y = x.numpy()\n",
        "print(y)\n",
        "print(type(y))"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "F8xojZPjcNlE",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "z = torch.from_numpy(y)\n",
        "print(z)\n",
        "print(type(z))"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "UPpxBV9sAzTq",
        "colab_type": "text"
      },
      "source": [
        "## Indexing"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "3mJaUPKWcOEc",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "z[0, :] = 0\n",
        "z[:, 2] = 1\n",
        "print(z)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "C2b59XAiA3RB",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "z[:,:] = 0.5\n",
        "print(z)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "oxA66TzjkdWL",
        "colab_type": "text"
      },
      "source": [
        "# Simple Neural Network on CIFAR-10"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "colab_type": "text",
        "id": "u1tsU2Uq9aRO"
      },
      "source": [
        "## Dataloader Definition"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "wzdRWHY7l7A_",
        "colab_type": "text"
      },
      "source": [
        "Define variables that will be needed for loading data."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "t8hgCzN39fPN",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "batch_size = 4\n",
        "num_workers = 2\n",
        "root_dir = './data'\n",
        "classes = ('plane', 'car', 'bird', 'cat', 'deer', 'dog', 'frog', 'horse', 'ship', 'truck')"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "mbZvryHnDmn8",
        "colab_type": "text"
      },
      "source": [
        "Define the preprocessing that will be done with each image before loading."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "v4Hm07ZKkiTK",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "transform = transforms.Compose(\n",
        "    [transforms.ToTensor(),\n",
        "     transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))])"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "hg5rv8wzBPgO",
        "colab_type": "text"
      },
      "source": [
        "Define the train and test dataset."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "5w4GHAy7BNXQ",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "trainset = torchvision.datasets.CIFAR10(root=root_dir, train=True,\n",
        "                                        download=True, transform=transform)\n",
        "\n",
        "testset = torchvision.datasets.CIFAR10(root=root_dir, train=False,\n",
        "                                       download=True, transform=transform)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Y9xKnxtRBbiS",
        "colab_type": "text"
      },
      "source": [
        "Define the dataloaders for both the train dataset and test dataset."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "LKc9HbFZBUoh",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "trainloader = torch.utils.data.DataLoader(trainset, batch_size=batch_size,\n",
        "                                          shuffle=True, num_workers=num_workers)\n",
        "\n",
        "testloader = torch.utils.data.DataLoader(testset, batch_size=batch_size,\n",
        "                                         shuffle=False, num_workers=num_workers)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "s3n0lK9qBokN",
        "colab_type": "text"
      },
      "source": [
        "### Visualizing a single batch from the dataloader"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "zZOmfePgkzwn",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "def imshow(img):\n",
        "  img = img / 2 + 0.5\n",
        "  npimg = img.numpy()\n",
        "  plt.imshow(np.transpose(npimg, (1, 2, 0)))\n",
        "  plt.show()"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "h69QTj4HlIla",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "dataiter = iter(trainloader)\n",
        "images, labels = dataiter.next()\n",
        "\n",
        "imshow(torchvision.utils.make_grid(images))"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "kB7xAH03lZ06",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "torchvision.utils.make_grid(images).size()"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "fgXZxEhtBspP",
        "colab_type": "text"
      },
      "source": [
        "### Making custom transforms, datasets and dataloaders\n",
        "\n",
        "You can make custom:\n",
        "\n",
        "* transforms (preprocessing)\n",
        "* datasets (loading datasets from various places and in various forms)\n",
        "* dataloaders (accumulating loaded data in a particular way)\n",
        "\n",
        "Have a look at the following tutorial by Pytorch for more details:\n",
        "[Tutorial](https://pytorch.org/tutorials/beginner/data_loading_tutorial.html)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "qtG9qGBfmCT0",
        "colab_type": "text"
      },
      "source": [
        "## Model Definition"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "vLIQBDzRB8EL",
        "colab_type": "text"
      },
      "source": [
        "While defining the model, make sure the model class extends `nn.Module`.\n",
        "\n",
        "When `nn.Module` is extended, it requires two functions to be defined:\n",
        "* `__init__()`\n",
        "* `forward()`"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Pivno4GKmD0B",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "class Net(nn.Module):\n",
        "    def __init__(self):\n",
        "        super(Net, self).__init__()\n",
        "        self.conv1 = nn.Conv2d(3, 6, 5)\n",
        "        self.pool = nn.MaxPool2d(2, 2)\n",
        "        self.conv2 = nn.Conv2d(6, 16, 5)\n",
        "        self.fc1 = nn.Linear(16 * 5 * 5, 120)\n",
        "        self.fc2 = nn.Linear(120, 84)\n",
        "        self.fc3 = nn.Linear(84, 10)\n",
        "\n",
        "    def forward(self, x):\n",
        "        x = self.pool(F.relu(self.conv1(x)))\n",
        "        x = self.pool(F.relu(self.conv2(x)))\n",
        "        x = x.view(-1, 16 * 5 * 5)\n",
        "        x = F.relu(self.fc1(x))\n",
        "        x = F.relu(self.fc2(x))\n",
        "        x = self.fc3(x)\n",
        "        return x"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "VzijLMv5CZoT",
        "colab_type": "text"
      },
      "source": [
        "Initialize the model and transfer it to the device you will be using."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "1MuaHkb2mJx4",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "net = Net().to(device)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "FdfwgrSuCfNd",
        "colab_type": "text"
      },
      "source": [
        "The `DataParallel()` function is used to parallelize the training process across multiple GPUs."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "2kxmthzlmLFP",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "net = nn.DataParallel(net)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "kYmXSMuuC3uQ",
        "colab_type": "text"
      },
      "source": [
        "## Training Definition"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "FweA3WKTDCLL",
        "colab_type": "text"
      },
      "source": [
        "Define the relevant variables for training the model."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "uwKkA8OOC6db",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "n_epochs = 2\n",
        "model_ckpt = './cifar_net.pth'\n",
        "learning_rate = 0.001\n",
        "momentum = 0.9"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "2mF0i_lxDToD",
        "colab_type": "text"
      },
      "source": [
        "Define the optimizer for training the model."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "YKkCaKr6mZ1B",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "optimizer = optim.SGD(net.parameters(), lr = learning_rate, momentum = momentum)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "wlf8u4RDD4GZ",
        "colab_type": "text"
      },
      "source": [
        "Define the loss function to be used."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "FBr5R81nEDNF",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "criterion = nn.CrossEntropyLoss()"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "xFOT0f0REK7E",
        "colab_type": "text"
      },
      "source": [
        "Define the training procedure!"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "CsoIHgRKnNlg",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "for epoch in range(n_epochs):  # loop over the dataset multiple times\n",
        "\n",
        "    running_loss = 0.0\n",
        "    for i, data in enumerate(trainloader, 0):\n",
        "        # get the inputs; data is a list of [inputs, labels]\n",
        "        inputs, labels = data\n",
        "        inputs = inputs.to(device)\n",
        "        labels = labels.to(device)\n",
        "\n",
        "        # zero the parameter gradients\n",
        "        optimizer.zero_grad()\n",
        "\n",
        "        # forward + backward + optimize\n",
        "        outputs = net(inputs)\n",
        "        loss = criterion(outputs, labels)\n",
        "        loss.backward()\n",
        "        optimizer.step()\n",
        "\n",
        "        # print statistics\n",
        "        running_loss += loss.item()\n",
        "        if i % 2000 == 1999:    # print every 2000 mini-batches\n",
        "            print(f'[{epoch + 1}, {i + 1}] Loss: {running_loss / 2000:.3f}')\n",
        "            running_loss = 0.0"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "-BRQMr4bEPE8",
        "colab_type": "text"
      },
      "source": [
        "Save the model weights."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "-wJKuJiP9xa6",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "torch.save(net.state_dict(), model_ckpt)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "lBZAf8KhEYS4",
        "colab_type": "text"
      },
      "source": [
        "## Test the Model\n",
        " "
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "7ORC3g9AEgn6",
        "colab_type": "text"
      },
      "source": [
        "Show test images and corresponding ground truth."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "BwRLaI_U960z",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "dataiter = iter(testloader)\n",
        "images, labels = dataiter.next()\n",
        "\n",
        "imshow(torchvision.utils.make_grid(images))\n",
        "print('GroundTruth: ', ' '.join('%5s' % classes[labels[j]] for j in range(4)))"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Ak6OR6yUErRj",
        "colab_type": "text"
      },
      "source": [
        "Show predicted classes by the model."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "uPwTTuMC-Mms",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "outputs = net(images)\n",
        "\n",
        "_, predicted = torch.max(outputs, 1)\n",
        "\n",
        "print('Predicted: ', ' '.join('%5s' % classes[predicted[j]]\n",
        "                              for j in range(4)))"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "cSTZ6W0SEvPY",
        "colab_type": "text"
      },
      "source": [
        "Calculate accuracy of the model."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "eKy-_c3Y-V6I",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "correct = 0\n",
        "total = 0\n",
        "with torch.no_grad():\n",
        "    for data in testloader:\n",
        "        images, labels = data\n",
        "        outputs = net(images.to(device))\n",
        "        _, predicted = torch.max(outputs.cpu().data, 1)\n",
        "        total += labels.size(0)\n",
        "        correct += (predicted == labels).sum().item()\n",
        "\n",
        "print('Accuracy of the network on the 10000 test images: %d %%' % (\n",
        "    100 * correct / total))"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "VmKuBHqDE4ok",
        "colab_type": "text"
      },
      "source": [
        "# Tensorboard"
      ]
    }
  ]
}