pytorch/Working with gradients using the Autograd library.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Introduction"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import torch"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tensor([[1., 2., 3.],\n",
       "        [4., 5., 6.]], requires_grad=True)"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "tensor1 = torch.Tensor([[1, 2, 3], \n",
    "                       [4, 5, 6]])\n",
    "tensor2 = torch.Tensor([[7, 8, 9], \n",
    "                        [10, 11, 12]])\n",
    "\n",
    "tensor1.requires_grad_()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "output_tensor = tensor1 * tensor2\n",
    "output_tensor.requires_grad"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "There are still no gradients, but there is a gradient function"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(None, <MulBackward0 at 0x1e61c345438>)"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "output_tensor.grad, output_tensor.grad_fn"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(None, None)"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "tensor1.grad_fn, tensor2.grad_fn"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The gradient function only contains the last operation. Here, even though there is a multiplication as well as a mean, only the mean calculation is recorded as the gradient function"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<MeanBackward0 object at 0x000001E61C345CF8>\n"
     ]
    }
   ],
   "source": [
    "output_tensor = (tensor1 * tensor2).mean()\n",
    "print(output_tensor.grad_fn)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To calculate the gradients, we need to explicitly perform a backward propagation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "output_tensor.backward()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Future calls to backward will accumulate gradients into this vector"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "tensor([[1.1667, 1.3333, 1.5000],\n",
      "        [1.6667, 1.8333, 2.0000]])\n"
     ]
    }
   ],
   "source": [
    "print(tensor1.grad)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "def calculate(t):\n",
    "    return t * 2\n",
    "\n",
    "@torch.no_grad()\n",
    "def calculate_with_no_grad(t):\n",
    "    return t * 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tensor([[ 2.,  4.,  6.],\n",
       "        [ 8., 10., 12.]], grad_fn=<MulBackward0>)"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "result_tensor = calculate(tensor1)\n",
    "result_tensor"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tensor([[ 2.,  4.,  6.],\n",
       "        [ 8., 10., 12.]])"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "result_tensor_no_grad = calculate_with_no_grad(tensor1)\n",
    "result_tensor_no_grad"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Autograd with variables"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tensor([9.])"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import torch \n",
    "from torch.autograd import Variable\n",
    "\n",
    "var = Variable(torch.FloatTensor([9]))\n",
    "var"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tensor([27.], grad_fn=<MulBackward0>)"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "w1 = Variable(torch.FloatTensor([3]), requires_grad = True)\n",
    "w2 = Variable(torch.FloatTensor([7]), requires_grad = True)\n",
    "result_var = var * w1\n",
    "result_var "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Training a linear model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 864x576 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "import numpy as np \n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "x_train = np.array ([[4.7], [2.4], [7.5], [7.1], [4.3], [7.816], \n",
    "                     [8.9], [5.2], [8.59], [2.1], [8] , \n",
    "                     [10], [4.5], [6], [4]],\n",
    "                    dtype = np.float32)\n",
    "\n",
    "y_train = np.array ([[2.6], [1.6], [3.09], [2.4], [2.4], [3.357], \n",
    "                     [2.6], [1.96], [3.53], [1.76], [3.2] , \n",
    "                     [3.5], [1.6], [2.5], [2.2]], \n",
    "                    dtype = np.float32)\n",
    "\n",
    "plt.figure(figsize=(12, 8))\n",
    "plt.scatter(x_train, y_train, label='Original data', s=250, c='g')\n",
    "plt.legend()\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "import torch \n",
    "\n",
    "X_train = torch.from_numpy(x_train) \n",
    "Y_train = torch.from_numpy(y_train)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Input, output and hidden layer sizes plus the learning rate"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "torch.Size([1, 1])"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "input_size = 1 \n",
    "hidden_size = 1\n",
    "output_size = 1\n",
    "\n",
    "w1 = torch.rand(input_size, \n",
    "                hidden_size,         \n",
    "                requires_grad=True)\n",
    "w1.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "torch.Size([1, 1])"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "w2 = torch.rand(hidden_size, \n",
    "                output_size,    \n",
    "                requires_grad=True)\n",
    "w2.shape"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Training\n",
    "\n",
    "#### Foward Pass:\n",
    "* Predicting Y with input data X\n",
    "* finding (matrix X matrix) using .mm function, finding product of X_train and w1 and activation function is identity function\n",
    "* again doing mat product data with second weight w2\n",
    "\n",
    "#### Finding Loss:\n",
    "* Finding difference between Y_train and Y_pred by squaring the difference and then summing out, similar to nn.MSELoss \n",
    "\n",
    "\n",
    "#### For the loss_backward() function call:\n",
    "* backward pass will compute the gradient of loss with respect to all Tensors with requires_grad=True. \n",
    "* After this call w1.grad and w2.grad will be Tensors holding the gradient of the loss with respect to w1 and w2 respectively.\n",
    "\n",
    "#### Manually updating the weights\n",
    "* weights have requires_grad=True, but we don't need to track this in autograd. So will wrap it in torch.no_grad\n",
    "* reducing weight with multiple of learning rate and gradient\n",
    "* manually zero the weight gradients after updating weights"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "w1:  tensor([[0.4990]], requires_grad=True)\n",
      "w2:  tensor([[0.6679]], requires_grad=True)\n"
     ]
    }
   ],
   "source": [
    "learning_rate = 1e-6\n",
    "\n",
    "# Start at 10. Change this to 100, 1000 and 3000 and run the code all the way to the plot at the bottom\n",
    "for iter in range(1, 10):\n",
    "    \n",
    "    y_pred = X_train.mm(w1).mm(w2)\n",
    "    loss = (y_pred - Y_train).pow(2).sum()\n",
    "    \n",
    "    if iter % 50 ==0:\n",
    "        print(iter, loss.item())\n",
    "        \n",
    "    loss.backward()\n",
    "    \n",
    "    with torch.no_grad():\n",
    "        w1 -= learning_rate * w1.grad\n",
    "        w2 -= learning_rate * w2.grad\n",
    "        w1.grad.zero_()\n",
    "        w2.grad.zero_()\n",
    "        \n",
    "print ('w1: ', w1)\n",
    "print ('w2: ', w2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tensor([[ 4.7000],\n",
       "        [ 2.4000],\n",
       "        [ 7.5000],\n",
       "        [ 7.1000],\n",
       "        [ 4.3000],\n",
       "        [ 7.8160],\n",
       "        [ 8.9000],\n",
       "        [ 5.2000],\n",
       "        [ 8.5900],\n",
       "        [ 2.1000],\n",
       "        [ 8.0000],\n",
       "        [10.0000],\n",
       "        [ 4.5000],\n",
       "        [ 6.0000],\n",
       "        [ 4.0000]])"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x_train_tensor = torch.from_numpy(x_train)\n",
    "x_train_tensor"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tensor([[1.5665],\n",
       "        [0.7999],\n",
       "        [2.4997],\n",
       "        [2.3663],\n",
       "        [1.4331],\n",
       "        [2.6050],\n",
       "        [2.9663],\n",
       "        [1.7331],\n",
       "        [2.8629],\n",
       "        [0.6999],\n",
       "        [2.6663],\n",
       "        [3.3329],\n",
       "        [1.4998],\n",
       "        [1.9997],\n",
       "        [1.3332]], grad_fn=<MmBackward>)"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "predicted_in_tensor = x_train_tensor.mm(w1).mm(w2)\n",
    "predicted_in_tensor"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1.5664531 ],\n",
       "       [0.799891  ],\n",
       "       [2.4996593 ],\n",
       "       [2.3663442 ],\n",
       "       [1.433138  ],\n",
       "       [2.6049783 ],\n",
       "       [2.966262  ],\n",
       "       [1.733097  ],\n",
       "       [2.862943  ],\n",
       "       [0.69990456],\n",
       "       [2.6663032 ],\n",
       "       [3.3328788 ],\n",
       "       [1.4997956 ],\n",
       "       [1.9997275 ],\n",
       "       [1.3331516 ]], dtype=float32)"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "predicted = predicted_in_tensor.detach().numpy()\n",
    "predicted"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 864x576 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.figure(figsize=(12, 8))\n",
    "plt.scatter(x_train, y_train, label = 'Original data', s=250, c='g') \n",
    "plt.plot(x_train, predicted, label = 'Fitted line ')\n",
    "plt.legend() \n",
    "plt.show()"
   ]
  },
  {
   "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.7.2"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}