Pytorch.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Pytorch"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## basic"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Tensors"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "from __future__ import print_function\n",
    "import torch"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "tensor([[-1.8882e-29,  3.0801e-41,  5.0447e-44],\n",
      "        [ 0.0000e+00,         nan,  0.0000e+00],\n",
      "        [ 1.3788e-14,  3.6423e-06,  2.0699e-19],\n",
      "        [ 3.3738e-12,  7.4086e+28,  6.9397e+22],\n",
      "        [ 1.7260e+25,  2.2856e+20,  5.0948e-14]])\n"
     ]
    }
   ],
   "source": [
    "x = torch.empty(5, 3)\n",
    "print(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "tensor([[0.3809, 0.9270, 0.9140],\n",
      "        [0.9029, 0.3442, 0.0564],\n",
      "        [0.6236, 0.8208, 0.2178],\n",
      "        [0.1682, 0.2741, 0.4104],\n",
      "        [0.6452, 0.3909, 0.5285]])\n"
     ]
    }
   ],
   "source": [
    "x =torch.rand(5, 3)\n",
    "print(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "tensor([[0, 0, 0],\n",
      "        [0, 0, 0],\n",
      "        [0, 0, 0],\n",
      "        [0, 0, 0],\n",
      "        [0, 0, 0]])\n"
     ]
    }
   ],
   "source": [
    "x = torch.zeros(5, 3, dtype=torch.long)\n",
    "print(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "tensor([5.5000, 3.0000])\n"
     ]
    }
   ],
   "source": [
    "x = torch.tensor([5.5, 3])\n",
    "print(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "tensor([[1., 1., 1.],\n",
      "        [1., 1., 1.],\n",
      "        [1., 1., 1.],\n",
      "        [1., 1., 1.],\n",
      "        [1., 1., 1.]], dtype=torch.float64)\n",
      "-------------------------\n",
      "tensor([[-0.5059, -0.9057,  1.1698],\n",
      "        [ 1.4891,  0.9715,  0.1597],\n",
      "        [ 0.7834,  0.7476, -0.0135],\n",
      "        [-1.3493,  0.8096, -0.0139],\n",
      "        [ 0.1034, -0.3083, -0.5273]])\n",
      "torch.Size([5, 3])\n"
     ]
    }
   ],
   "source": [
    "x = x.new_ones(5, 3, dtype=torch.double)   # new_* methods take in sizes\n",
    "print(x)\n",
    "print('-------------------------------------------------')\n",
    "\n",
    "x = torch.randn_like(x, dtype=torch.float)  # override dtype!\n",
    "print(x)\n",
    "\n",
    "print(x.size()) # getsize"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Operations"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Any operation that mutates a tensor in-place is post-fixed with an _. For example: `x.copy_(y), x.t_()`, will change x."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {
    "collapsed": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "tensor([[ 0.3859, -0.6464,  1.7737],\n",
      "        [ 2.1816,  1.3875,  0.4016],\n",
      "        [ 0.8185,  0.9907,  0.8553],\n",
      "        [-0.8256,  0.9758,  0.9095],\n",
      "        [ 1.0654,  0.6660, -0.4235]])\n",
      "-------------------------------------------------\n",
      "tensor([[ 0.3859, -0.6464,  1.7737],\n",
      "        [ 2.1816,  1.3875,  0.4016],\n",
      "        [ 0.8185,  0.9907,  0.8553],\n",
      "        [-0.8256,  0.9758,  0.9095],\n",
      "        [ 1.0654,  0.6660, -0.4235]])\n",
      "-------------------------------------------------\n",
      "tensor([[ 0.3859, -0.6464,  1.7737],\n",
      "        [ 2.1816,  1.3875,  0.4016],\n",
      "        [ 0.8185,  0.9907,  0.8553],\n",
      "        [-0.8256,  0.9758,  0.9095],\n",
      "        [ 1.0654,  0.6660, -0.4235]])\n",
      "-------------------------------------------------\n",
      "tensor([[ 0.3859, -0.6464,  1.7737],\n",
      "        [ 2.1816,  1.3875,  0.4016],\n",
      "        [ 0.8185,  0.9907,  0.8553],\n",
      "        [-0.8256,  0.9758,  0.9095],\n",
      "        [ 1.0654,  0.6660, -0.4235]])\n"
     ]
    }
   ],
   "source": [
    "y = torch.rand(5, 3)\n",
    "print(x + y)\n",
    "print('-------------------------------------------------')\n",
    "\n",
    "print(torch.add(x, y))\n",
    "print('-------------------------------------------------')\n",
    "\n",
    "result = torch.empty_like(x)\n",
    "torch.add(x, y, out=result)\n",
    "print(result)\n",
    "\n",
    "print('-------------------------------------------------')\n",
    "y.add_(x)\n",
    "print(y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {
    "collapsed": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "torch.Size([4, 4]) torch.Size([16]) torch.Size([2, 8])\n"
     ]
    }
   ],
   "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",
    "print(x.size(), y.size(), z.size())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If you have a one element tensor, use `.item()` to get the value as a Python number"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "tensor([0.3159])\n",
      "0.31590744853019714\n"
     ]
    }
   ],
   "source": [
    "x = torch.randn(1)\n",
    "print(x)\n",
    "print(x.item())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### NumPy Bridge \n",
    "The Torch Tensor and NumPy array will share their underlying memory locations (if the Torch Tensor is on CPU), and changing one will change the other."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "tensor([1., 1., 1., 1., 1.])\n"
     ]
    }
   ],
   "source": [
    "a = torch.ones(5)\n",
    "print(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1. 1. 1. 1. 1.]\n"
     ]
    }
   ],
   "source": [
    "b = a.numpy()\n",
    "print(b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "tensor([2., 2., 2., 2., 2.])\n",
      "[2. 2. 2. 2. 2.]\n"
     ]
    }
   ],
   "source": [
    "a.add_(1)\n",
    "print(a)\n",
    "print(b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[2. 2. 2. 2. 2.]\n",
      "tensor([2., 2., 2., 2., 2.], dtype=torch.float64)\n"
     ]
    }
   ],
   "source": [
    "import numpy as np\n",
    "\n",
    "a = np.ones(5)\n",
    "b = torch.from_numpy(a)\n",
    "np.add(a,1, out=a)\n",
    "print(a)\n",
    "print(b)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### CUDA Tensors"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [],
   "source": [
    "if torch.cuda.is_available():\n",
    "    device = torch.device(\"cuda\")\n",
    "    y = torch.ones_like(x, device=device)\n",
    "    x = x.to(device)\n",
    "    z = x + Y\n",
    "    print(z)\n",
    "    print(z.to(\"cpu\", torch.double))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Autograd"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Tensor\n",
    "torch.Tensor is the central class of the package. If you set its attribute `.requires_grad` as `True`, it starts to track all operations on it. When you finish your computation you can call `.backward()` and have all the gradients computed automatically. The gradient for this tensor will be accumulated into .grad attribute.\n",
    "\n",
    "To stop a tensor from tracking history, you can call `.detach()` to detach it from the computation history, and to prevent future computation from being tracked."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "tensor([[1., 1.],\n",
      "        [1., 1.]], requires_grad=True)\n"
     ]
    }
   ],
   "source": [
    "import torch\n",
    "\n",
    "x = torch.ones(2, 2, requires_grad=True)\n",
    "print(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "tensor([[3., 3.],\n",
      "        [3., 3.]], grad_fn=<AddBackward>)\n",
      "-------------------------------------------------\n",
      "<AddBackward object at 0x7f04b2ebb208>\n"
     ]
    }
   ],
   "source": [
    "y = x + 2\n",
    "print(y)\n",
    "print('-------------------------------------------------')\n",
    "\n",
    "print(y.grad_fn)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "tensor([[27., 27.],\n",
      "        [27., 27.]], grad_fn=<MulBackward>) tensor(27., grad_fn=<MeanBackward1>)\n"
     ]
    }
   ],
   "source": [
    "z = y * y * 3\n",
    "out = z.mean()\n",
    "\n",
    "print(z, out)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`.requires_grad_( ... )` changes an existing Tensor’s `requires_grad` flag in-place. The input flag defaults to `False` if not given."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "False\n",
      "True\n",
      "<SumBackward0 object at 0x7f04b2ebba58>\n"
     ]
    }
   ],
   "source": [
    "a =torch.randn(2, 2)\n",
    "a = ((a* 3) / (a - 1))\n",
    "print(a.requires_grad)\n",
    "a.requires_grad_(True)\n",
    "print(a.requires_grad)\n",
    "b = (a * a).sum()\n",
    "print(b.grad_fn)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Gradients "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "tensor([[4.5000, 4.5000],\n",
      "        [4.5000, 4.5000]])\n"
     ]
    }
   ],
   "source": [
    "out.backward()\n",
    "print(x.grad)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "tensor([ 788.7339, -607.5063, -494.8064], grad_fn=<MulBackward>)\n"
     ]
    }
   ],
   "source": [
    "x = torch.randn(3, requires_grad=True)\n",
    "y = x * 2\n",
    "while y.data.norm() < 1000:\n",
    "    y =  y *2\n",
    "    \n",
    "print(y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "tensor([ 102.4000, 1024.0000,    0.1024])\n"
     ]
    }
   ],
   "source": [
    "v = torch.tensor([0.1, 1.0, 0.0001], dtype=torch.float)\n",
    "y.backward(v) # vector-Jacobian product\n",
    "\n",
    "print(x.grad)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n",
      "True\n",
      "False\n"
     ]
    }
   ],
   "source": [
    "print(x.requires_grad)\n",
    "print((x ** 2).requires_grad)\n",
    "\n",
    "with torch.no_grad():\n",
    "    print((x ** 2).requires_grad)\n",
    "    \n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Neural Network "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Define the network"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![mnist network](https://pytorch.org/tutorials/_images/mnist.png)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Net(\n",
      "  (conv1): Conv2d(1, 6, kernel_size=(5, 5), stride=(1, 1))\n",
      "  (conv2): Conv2d(6, 16, kernel_size=(5, 5), stride=(1, 1))\n",
      "  (fc1): Linear(in_features=400, out_features=120, bias=True)\n",
      "  (fc2): Linear(in_features=120, out_features=84, bias=True)\n",
      "  (fc3): Linear(in_features=84, out_features=10, bias=True)\n",
      ")\n"
     ]
    }
   ],
   "source": [
    "import torch\n",
    "import torch.nn as nn\n",
    "import torch.nn.functional as F\n",
    "\n",
    "\n",
    "class Net(nn.Module):\n",
    "    \n",
    "    def __init__(self):\n",
    "        super(Net, self).__init__()\n",
    "        # 1 input image channel, 6 output channels, 5x5 square convolution kernel\n",
    "        self.conv1 = nn.Conv2d(1, 6, 5)\n",
    "        self.conv2 = nn.Conv2d(6, 16, 5)\n",
    "        # an affine operation: y = Wx + b\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",
    "        # Max pooling over a (2, 2) window\n",
    "        x = F.max_pool2d(F.relu(self.conv1(x)), (2, 2))\n",
    "        # If the size is a square you can only specify a single number\n",
    "        x = F.max_pool2d(F.relu(self.conv2(x)), 2)\n",
    "        x = x.view(-1, self.num_flat_features(x))\n",
    "        x = F.relu(self.fc1(x))\n",
    "        x = F.relu(self.fc2(x))\n",
    "        x = self.fc3(x)\n",
    "        return x\n",
    "    \n",
    "    def num_flat_features(slef, x):\n",
    "        size = x.size()[1:]\n",
    "        num_features = 1\n",
    "        for s in size:\n",
    "            num_features *= s\n",
    "        return num_features\n",
    "    \n",
    "net = Net()\n",
    "print(net)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "10\n",
      "torch.Size([6, 1, 5, 5])\n",
      "torch.Size([6])\n",
      "torch.Size([16, 6, 5, 5])\n",
      "torch.Size([16])\n",
      "torch.Size([120, 400])\n",
      "torch.Size([120])\n",
      "torch.Size([84, 120])\n",
      "torch.Size([84])\n",
      "torch.Size([10, 84])\n",
      "torch.Size([10])\n"
     ]
    }
   ],
   "source": [
    "params = list(net.parameters())\n",
    "print(len(params))\n",
    "\n",
    "for i in range(len(params)):\n",
    "    print(params[i].size())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "tensor([[-0.0912,  0.0611, -0.0037, -0.0468, -0.0163, -0.0095,  0.0097, -0.0717,\n",
      "          0.1212, -0.0903]], grad_fn=<ThAddmmBackward>)\n"
     ]
    }
   ],
   "source": [
    "input = torch.randn(1, 1, 32, 32) # nSamples x nChannels x Height x Width\n",
    "out = net(input)\n",
    "print(out)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "metadata": {},
   "outputs": [],
   "source": [
    "net.zero_grad()\n",
    "out.backward(torch.randn(1, 10))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### loss"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "tensor(1.3818, grad_fn=<MseLossBackward>)\n"
     ]
    }
   ],
   "source": [
    "output = net(input)\n",
    "target = torch.randn(10)\n",
    "target = target.view(1, -1)\n",
    "criterion = nn.MSELoss()\n",
    "\n",
    "loss = criterion(output, target)\n",
    "print(loss)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 74,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<MseLossBackward object at 0x7f04b1e865c0>\n",
      "<ThAddmmBackward object at 0x7f04b1e86a90>\n",
      "<ExpandBackward object at 0x7f04b1e865c0>\n"
     ]
    }
   ],
   "source": [
    "print(loss.grad_fn)\n",
    "print(loss.grad_fn.next_functions[0][0])\n",
    "print(loss.grad_fn.next_functions[0][0].next_functions[0][0])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### backprop"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 75,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "conv1.bias.grad before backward\n",
      "tensor([0., 0., 0., 0., 0., 0.])\n",
      "conv1.bias.grad after backward\n",
      "tensor([-0.0001, -0.0132, -0.0090,  0.0103, -0.0137, -0.0082])\n"
     ]
    }
   ],
   "source": [
    "net.zero_grad()\n",
    "\n",
    "print('conv1.bias.grad before backward')\n",
    "print(net.conv1.bias.grad)\n",
    "\n",
    "loss.backward()\n",
    "\n",
    "print('conv1.bias.grad after backward')\n",
    "print(net.conv1.bias.grad)\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Update the weights"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 76,
   "metadata": {},
   "outputs": [],
   "source": [
    "learning_rate = 0.01\n",
    "for f in net.parameters():\n",
    "    f.data.sub_(f.grad.data * learning_rate)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 78,
   "metadata": {},
   "outputs": [],
   "source": [
    "import torch.optim as optim\n",
    "\n",
    "optimizer = optim.SGD(net.parameters(), lr=0.01)\n",
    "\n",
    "# in your training loop:\n",
    "optimizer.zero_grad()   # zero the gradient buffers\n",
    "output = net(input)\n",
    "loss = criterion(output, target)\n",
    "loss.backward()\n",
    "optimizer.step()  # Does the update"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##  Training a classifier"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### loading and normalizing data "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 93,
   "metadata": {},
   "outputs": [],
   "source": [
    "import torch\n",
    "import torchvision\n",
    "import torchvision.transforms as transforms"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 108,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Files already downloaded and verified\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",
    "traninset = torchvision.datasets.CIFAR10(root='./data', train=True,\n",
    "                                        download=True, transform=transform)\n",
    "trainloader = torch.utils.data.DataLoader(traninset, 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=True, num_workers=2)\n",
    "\n",
    "classes = ('plane', 'car', 'bird', 'cat',\n",
    "           'deer', 'dog', 'frog', 'horse', 'ship', 'truck')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 109,
   "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"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " deer  deer plane  frog\n"
     ]
    }
   ],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "import numpy as np\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",
    "    plt.show()\n",
    "    \n",
    "dataiter = iter(trainloader)\n",
    "images, labels = dataiter.next()\n",
    "\n",
    "imshow(torchvision.utils.make_grid(images))\n",
    "\n",
    "print(' '.join('%5s' % classes[labels[j]] for j in range(4)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### define network, loss and optimizer "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 113,
   "metadata": {},
   "outputs": [],
   "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\n",
    "\n",
    "net = Net()\n",
    "\n",
    "criterion = nn.CrossEntropyLoss()\n",
    "optimizer = optim.SGD(net.parameters(), lr=0.001, momentum=0.9)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Training"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 115,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1,  2000] loss: 2.201\n",
      "[1,  4000] loss: 1.866\n",
      "[1,  6000] loss: 1.685\n",
      "[1,  8000] loss: 1.585\n",
      "[1, 10000] loss: 1.510\n",
      "[1, 12000] loss: 1.457\n",
      "[2,  2000] loss: 1.388\n",
      "[2,  4000] loss: 1.363\n",
      "[2,  6000] loss: 1.336\n",
      "[2,  8000] loss: 1.311\n",
      "[2, 10000] loss: 1.283\n",
      "[2, 12000] loss: 1.245\n",
      "Finished Training\n"
     ]
    }
   ],
   "source": [
    "for epoch in range(2):\n",
    "    \n",
    "    running_loss = 0.0\n",
    "    for i, data in enumerate(trainloader, 0):\n",
    "        inputs, labels = data\n",
    "        \n",
    "        optimizer.zero_grad()\n",
    "        \n",
    "        outputs = net(inputs)\n",
    "        loss = criterion(outputs, labels)\n",
    "        loss.backward()\n",
    "        optimizer.step()\n",
    "        \n",
    "        running_loss += loss.item()\n",
    "        if i % 2000 == 1999:\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": [
    "### Test the network on the test data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 119,
   "metadata": {
    "collapsed": true
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Exception ignored in: <bound method _DataLoaderIter.__del__ of <torch.utils.data.dataloader._DataLoaderIter object at 0x7f04a83bbb38>>\n",
      "Traceback (most recent call last):\n",
      "  File \"/home/dd/.pyenv/versions/3.6.6/lib/python3.6/site-packages/torch/utils/data/dataloader.py\", line 399, in __del__\n",
      "    #\n",
      "  File \"/home/dd/.pyenv/versions/3.6.6/lib/python3.6/site-packages/torch/utils/data/dataloader.py\", line 378, in _shutdown_workers\n",
      "    #          must continue to next iteration .\n",
      "  File \"/home/dd/.pyenv/versions/3.6.6/lib/python3.6/multiprocessing/queues.py\", line 337, in get\n",
      "    return _ForkingPickler.loads(res)\n",
      "  File \"/home/dd/.pyenv/versions/3.6.6/lib/python3.6/site-packages/torch/multiprocessing/reductions.py\", line 151, in rebuild_storage_fd\n",
      "    # storages of mixed types: float, bytes, double... If you make the entire\n",
      "  File \"/home/dd/.pyenv/versions/3.6.6/lib/python3.6/multiprocessing/resource_sharer.py\", line 57, in detach\n",
      "    with _resource_sharer.get_connection(self._id) as conn:\n",
      "  File \"/home/dd/.pyenv/versions/3.6.6/lib/python3.6/multiprocessing/resource_sharer.py\", line 87, in get_connection\n",
      "    c = Client(address, authkey=process.current_process().authkey)\n",
      "  File \"/home/dd/.pyenv/versions/3.6.6/lib/python3.6/multiprocessing/connection.py\", line 493, in Client\n",
      "    answer_challenge(c, authkey)\n",
      "  File \"/home/dd/.pyenv/versions/3.6.6/lib/python3.6/multiprocessing/connection.py\", line 737, in answer_challenge\n",
      "    response = connection.recv_bytes(256)        # reject large message\n",
      "  File \"/home/dd/.pyenv/versions/3.6.6/lib/python3.6/multiprocessing/connection.py\", line 216, in recv_bytes\n",
      "    buf = self._recv_bytes(maxlength)\n",
      "  File \"/home/dd/.pyenv/versions/3.6.6/lib/python3.6/multiprocessing/connection.py\", line 407, in _recv_bytes\n",
      "    buf = self._recv(4)\n",
      "  File \"/home/dd/.pyenv/versions/3.6.6/lib/python3.6/multiprocessing/connection.py\", line 379, in _recv\n",
      "    chunk = read(handle, remaining)\n",
      "ConnectionResetError: [Errno 104] Connection reset by peer\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "GroundTruth:    car horse  deer plane\n"
     ]
    }
   ],
   "source": [
    "dataiter = iter(testloader)\n",
    "images, labels = dataiter.next()\n",
    "\n",
    "imshow(torchvision.utils.make_grid(images))\n",
    "\n",
    "print('GroundTruth: ', ' '.join('%5s' % classes[labels[j]] for j in range(4)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### analysis"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 122,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Predicted:  horse   cat  bird horse\n"
     ]
    }
   ],
   "source": [
    "output = net(images)\n",
    "\n",
    "_, predicted = torch.max(outputs, 1)\n",
    "\n",
    "print('Predicted: ', ' '.join('%5s' % classes[predicted[j]] for j in range(4)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 123,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Accuracy of the network on 10000 teat images: 54 %\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 10000 teat images: %d %%' %(100 * correct / total))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 124,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Accuracy of plane : 53 %\n",
      "Accuracy of   car : 58 %\n",
      "Accuracy of  bird : 50 %\n",
      "Accuracy of   cat : 44 %\n",
      "Accuracy of  deer : 39 %\n",
      "Accuracy of   dog : 61 %\n",
      "Accuracy of  frog : 46 %\n",
      "Accuracy of horse : 55 %\n",
      "Accuracy of  ship : 71 %\n",
      "Accuracy of truck : 69 %\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": [
    "### train on GPU"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 125,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "cpu\n"
     ]
    }
   ],
   "source": [
    "device =  torch.device(\"cuda:0\" if torch.cuda.is_available() else \"cpu\")\n",
    "print(device)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 126,
   "metadata": {},
   "outputs": [],
   "source": [
    "net.to(device)\n",
    "\n",
    "inputs, lablels = inputs.to(device), labels.to(device)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Data parallelism \n",
    "\n",
    "Ref. [this](https://pytorch.org/tutorials/beginner/blitz/data_parallel_tutorial.html#sphx-glr-beginner-blitz-data-parallel-tutorial-py)"
   ]
  },
  {
   "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": 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": 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": 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": []
  }
 ],
 "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.6"
  },
  "toc": {
   "base_numbering": 1,
   "nav_menu": {},
   "number_sections": true,
   "sideBar": true,
   "skip_h1_title": true,
   "title_cell": "Table of Contents",
   "title_sidebar": "Contents",
   "toc_cell": false,
   "toc_position": {},
   "toc_section_display": true,
   "toc_window_display": true
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}