based on cifar10_tutorial.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "%matplotlib inline"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "import torch\n",
    "import torchvision\n",
    "import torchvision.transforms as transforms\n",
    "import pandas as pd\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "cuda:0\n"
     ]
    }
   ],
   "source": [
    "device = torch.device(\"cuda:0\" if torch.cuda.is_available() else \"cpu\")\n",
    "\n",
    "# Assume that we are on a CUDA machine, then this should print a CUDA device:\n",
    "\n",
    "print(device)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "test = pd.read_csv('./data/test.csv')\n",
    "train = pd.read_csv('./data/train.csv')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "train_label = train['label'].copy()\n",
    "train.drop(columns='label', inplace= True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(42000, 784)\n",
      "(28000, 784)\n"
     ]
    }
   ],
   "source": [
    "print(train.shape)\n",
    "print(test.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "train = train.values.reshape((42000,28,28))\n",
    "test = test.values.reshape((28000,28,28))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "train = (train/255)*2 - 1\n",
    "test = (test/255)*2 -1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "9\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x7fec82fc28d0>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "img_num=100\n",
    "plt.imshow(train[img_num], cmap='gray')\n",
    "print(train_label[img_num])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x7fec82b78dd8>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.hist(train_label,bins=10)\n",
    "plt.grid()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Downloading https://www.cs.toronto.edu/~kriz/cifar-10-python.tar.gz to ./data/cifar-10-python.tar.gz\n",
      "Files already downloaded and verified\n"
     ]
    }
   ],
   "source": [
    "transform = transforms.Compose(\n",
    "    [transforms.ToTensor(),\n",
    "     transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))])\n",
    "\n",
    "trainset = torchvision.datasets.CIFAR10(root='./data', train=True,\n",
    "                                        download=True, transform=transform)\n",
    "trainloader = torch.utils.data.DataLoader(trainset, batch_size=4,\n",
    "                                          shuffle=True, num_workers=2)\n",
    "\n",
    "testset = torchvision.datasets.CIFAR10(root='./data', train=False,\n",
    "                                       download=True, transform=transform)\n",
    "testloader = torch.utils.data.DataLoader(testset, batch_size=4,\n",
    "                                         shuffle=False, num_workers=2)\n",
    "\n",
    "classes = ('plane', 'car', 'bird', 'cat',\n",
    "           'deer', 'dog', 'frog', 'horse', 'ship', 'truck')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "truck plane   cat truck\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x7f1261d18da0>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "import numpy as np\n",
    "\n",
    "# functions to show an image\n",
    "\n",
    "\n",
    "def imshow(img):\n",
    "    img = img / 2 + 0.5     # unnormalize\n",
    "    npimg = img.numpy()\n",
    "    plt.imshow(np.transpose(npimg, (1, 2, 0)))\n",
    "\n",
    "\n",
    "# get some random training images\n",
    "dataiter = iter(trainloader)\n",
    "images, labels = dataiter.next()\n",
    "\n",
    "# show images\n",
    "imshow(torchvision.utils.make_grid(images))\n",
    "# print labels\n",
    "print(' '.join('%5s' % classes[labels[j]] for j in range(4)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "2. Define a Convolution Neural Network\n",
    "^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n",
    "Copy the neural network from the Neural Networks section before and modify it to\n",
    "take 3-channel images (instead of 1-channel images as it was defined).\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "import torch.nn as nn\n",
    "import torch.nn.functional as F\n",
    "\n",
    "\n",
    "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\n",
    "\n",
    "\n",
    "net = Net()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "3. Define a Loss function and optimizer\n",
    "^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n",
    "Let's use a Classification Cross-Entropy loss and SGD with momentum.\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "import torch.optim as optim\n",
    "\n",
    "criterion = nn.CrossEntropyLoss()\n",
    "optimizer = optim.SGD(net.parameters(), lr=0.001, momentum=0.9)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "4. Train the network\n",
    "^^^^^^^^^^^^^^^^^^^^\n",
    "\n",
    "This is when things start to get interesting.\n",
    "We simply have to loop over our data iterator, and feed the inputs to the\n",
    "network and optimize.\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1,  2000] loss: 1.210\n",
      "[1,  4000] loss: 1.222\n",
      "[1,  6000] loss: 1.239\n",
      "[1,  8000] loss: 1.224\n",
      "[1, 10000] loss: 1.203\n",
      "[1, 12000] loss: 1.188\n",
      "[2,  2000] loss: 1.118\n",
      "[2,  4000] loss: 1.125\n",
      "[2,  6000] loss: 1.138\n",
      "[2,  8000] loss: 1.115\n",
      "[2, 10000] loss: 1.125\n",
      "[2, 12000] loss: 1.148\n",
      "Finished Training\n"
     ]
    }
   ],
   "source": [
    "for epoch in range(2):  # loop over the dataset multiple times\n",
    "\n",
    "    running_loss = 0.0\n",
    "    for i, data in enumerate(trainloader, 0):\n",
    "        # get the inputs\n",
    "        inputs, labels = data\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('[%d, %5d] loss: %.3f' %\n",
    "                  (epoch + 1, i + 1, running_loss / 2000))\n",
    "            running_loss = 0.0\n",
    "\n",
    "print('Finished Training')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "5. Test the network on the test data\n",
    "^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n",
    "\n",
    "We have trained the network for 2 passes over the training dataset.\n",
    "But we need to check if the network has learnt anything at all.\n",
    "\n",
    "We will check this by predicting the class label that the neural network\n",
    "outputs, and checking it against the ground-truth. If the prediction is\n",
    "correct, we add the sample to the list of correct predictions.\n",
    "\n",
    "Okay, first step. Let us display an image from the test set to get familiar.\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "GroundTruth:    cat  ship  ship plane\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x7f1254cd3a20>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "dataiter = iter(testloader)\n",
    "images, labels = dataiter.next()\n",
    "\n",
    "# print images\n",
    "imshow(torchvision.utils.make_grid(images))\n",
    "print('GroundTruth: ', ' '.join('%5s' % classes[labels[j]] for j in range(4)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Okay, now let us see what the neural network thinks these examples above are:\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "outputs = net(images)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "('plane',\n",
       " 'car',\n",
       " 'bird',\n",
       " 'cat',\n",
       " 'deer',\n",
       " 'dog',\n",
       " 'frog',\n",
       " 'horse',\n",
       " 'ship',\n",
       " 'truck')"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "classes"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tensor([[-1.0768, -1.7356,  0.0956,  3.1794,  0.1648,  1.8878, -0.1639,\n",
       "         -1.3305,  1.3446, -1.4992],\n",
       "        [ 2.7825,  5.6037, -2.7953, -3.7077, -3.0060, -4.9877, -3.4721,\n",
       "         -3.9127,  5.0826,  4.4617],\n",
       "        [ 1.3664,  3.7786, -1.9103, -1.6330, -2.3153, -2.7557, -1.6349,\n",
       "         -2.8045,  1.8889,  2.9659],\n",
       "        [ 2.9547,  0.5159,  0.3308, -1.3198,  1.2028, -3.6262, -1.8722,\n",
       "         -2.3336,  3.9037, -0.4199]])"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "outputs"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The outputs are energies for the 10 classes.\n",
    "Higher the energy for a class, the more the network\n",
    "thinks that the image is of the particular class.\n",
    "So, let's get the index of the highest energy:\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Predicted:    cat   car   car  ship\n"
     ]
    }
   ],
   "source": [
    "_, predicted = torch.max(outputs, 1)\n",
    "\n",
    "print('Predicted: ', ' '.join('%5s' % classes[predicted[j]]\n",
    "                              for j in range(4)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The results seem pretty good.\n",
    "\n",
    "Let us look at how the network performs on the whole dataset.\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Accuracy of the network on the 10000 test images: 59 %\n"
     ]
    }
   ],
   "source": [
    "correct = 0\n",
    "total = 0\n",
    "with torch.no_grad():\n",
    "    for data in testloader:\n",
    "        images, labels = data\n",
    "        outputs = net(images)\n",
    "        _, predicted = torch.max(outputs.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))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "That looks waaay better than chance, which is 10% accuracy (randomly picking\n",
    "a class out of 10 classes).\n",
    "Seems like the network learnt something.\n",
    "\n",
    "Hmmm, what are the classes that performed well, and the classes that did\n",
    "not perform well:\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Accuracy of plane : 71 %\n",
      "Accuracy of   car : 65 %\n",
      "Accuracy of  bird : 37 %\n",
      "Accuracy of   cat : 40 %\n",
      "Accuracy of  deer : 56 %\n",
      "Accuracy of   dog : 52 %\n",
      "Accuracy of  frog : 69 %\n",
      "Accuracy of horse : 62 %\n",
      "Accuracy of  ship : 71 %\n",
      "Accuracy of truck : 71 %\n"
     ]
    }
   ],
   "source": [
    "class_correct = list(0. for i in range(10))\n",
    "class_total = list(0. for i in range(10))\n",
    "with torch.no_grad():\n",
    "    for data in testloader:\n",
    "        images, labels = data\n",
    "        outputs = net(images)\n",
    "        _, predicted = torch.max(outputs, 1)\n",
    "        c = (predicted == labels).squeeze()\n",
    "        for i in range(4):\n",
    "            label = labels[i]\n",
    "            class_correct[label] += c[i].item()\n",
    "            class_total[label] += 1\n",
    "\n",
    "\n",
    "for i in range(10):\n",
    "    print('Accuracy of %5s : %2d %%' % (\n",
    "        classes[i], 100 * class_correct[i] / class_total[i]))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Okay, so what next?\n",
    "\n",
    "How do we run these neural networks on the GPU?\n",
    "\n",
    "Training on GPU\n",
    "----------------\n",
    "Just like how you transfer a Tensor on to the GPU, you transfer the neural\n",
    "net onto the GPU.\n",
    "\n",
    "Let's first define our device as the first visible cuda device if we have\n",
    "CUDA available:\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "cuda:0\n"
     ]
    }
   ],
   "source": [
    "device = torch.device(\"cuda:0\" if torch.cuda.is_available() else \"cpu\")\n",
    "\n",
    "# Assume that we are on a CUDA machine, then this should print a CUDA device:\n",
    "\n",
    "print(device)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The rest of this section assumes that `device` is a CUDA device.\n",
    "\n",
    "Then these methods will recursively go over all modules and convert their\n",
    "parameters and buffers to CUDA tensors:\n",
    "\n",
    ".. code:: python\n",
    "\n",
    "    net.to(device)\n",
    "\n",
    "\n",
    "Remember that you will have to send the inputs and targets at every step\n",
    "to the GPU too:\n",
    "\n",
    ".. code:: python\n",
    "\n",
    "        inputs, labels = inputs.to(device), labels.to(device)\n",
    "\n",
    "Why dont I notice MASSIVE speedup compared to CPU? Because your network\n",
    "is realllly small.\n",
    "\n",
    "**Exercise:** Try increasing the width of your network (argument 2 of\n",
    "the first ``nn.Conv2d``, and argument 1 of the second ``nn.Conv2d`` –\n",
    "they need to be the same number), see what kind of speedup you get.\n",
    "\n",
    "**Goals achieved**:\n",
    "\n",
    "- Understanding PyTorch's Tensor library and neural networks at a high level.\n",
    "- Train a small neural network to classify images\n",
    "\n",
    "Training on multiple GPUs\n",
    "-------------------------\n",
    "If you want to see even more MASSIVE speedup using all of your GPUs,\n",
    "please check out :doc:`data_parallel_tutorial`.\n",
    "\n",
    "Where do I go next?\n",
    "-------------------\n",
    "\n",
    "-  :doc:`Train neural nets to play video games </intermediate/reinforcement_q_learning>`\n",
    "-  `Train a state-of-the-art ResNet network on imagenet`_\n",
    "-  `Train a face generator using Generative Adversarial Networks`_\n",
    "-  `Train a word-level language model using Recurrent LSTM networks`_\n",
    "-  `More examples`_\n",
    "-  `More tutorials`_\n",
    "-  `Discuss PyTorch on the Forums`_\n",
    "-  `Chat with other users on Slack`_\n",
    "\n",
    "\n"
   ]
  }
 ],
 "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.6.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}