PyTorch Lab - 7 - Pytorch CUDA Semantics

demo7-LinearModelUsingAutograd.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np \n",
    "import matplotlib.pyplot as plt"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Creating Dataset\n",
    "A simple dataset using numpy arrays"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [],
   "source": [
    "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)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### View the data\n",
    "There seems to be some relationship which can be plotted between x_train and y_train. A regression line can be drawn to represent the relationship"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAswAAAHVCAYAAADl4K3UAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDMuMC4yLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvOIA7rQAAIABJREFUeJzt3X903Hd95/vXm4yERhM3sYIBOY6lLA5tICS2JAJOsFQIRMa1CXZpCctyiQ+30lLtXbNX4h5KD6WFc3qgWLTsrg0rN1HCvWkwkARiYwTZEksLK0KkcUJ+0USAZLtSiYlkOxqNkRXe9w+NjWzLX41G39HMaJ6Pc3Q8+s7nM3ppMjN65Tuf+X7N3QUAAABgdq/IdQAAAAAgn1GYAQAAgAAUZgAAACAAhRkAAAAIQGEGAAAAAlCYAQAAgAAUZgAAACAAhRkAAAAIQGEGAAAAAkRyHWA2r3rVq7y6ujrXMQAAALCE9ff3/9rdV8w1Li8Lc3V1tfr6+nIdAwAAAEuYmQ2lM44lGQAAAEAACjMAAAAQgMIMAAAABMjLNcwAAACF7PTp0zp69KhOnTqV6yiQVFZWplWrVqmkpCSj+RRmAACAkB09elTLli1TdXW1zOyi49xd3UPdau9tV3w4rompCZVHylWzskZt69tUX1UfOB9zc3e9+OKLOnr0qK6++uqMboPCDAAAELJTp07NWZa7BrrUtK9JY6fGlJhMyOWSpOM6rpHnRnRw8KAqohXq2NyhxjWNixV9yTEzXXHFFTp27FjGt8EaZgAAgCwIKsudhzq1be82HTl5ROOT42fL8hku1/jkuA6fOKyte7eq81BntuMuaQvdS09hBgAAWERdA11qOdCi5FQyrfHJqaRaDrSoa6Ary8lwMRRmAACAReLuatrXlHZZPiM5lVTz/ma5+9yDU44eParbbrtN11xzjV73utdpx44dmpycnHXs8PCw3ve+9815m5s2bdLx48fTzjDTX//1X2vnzp1zjrv00ksDrz9+/Lh2796dUYZMUZgBAAAWSfdQt8ZOjWU0dzQ5qp6hnrTGuru2bdum9773vXr++ef13HPPaXx8XH/5l395wdipqSmtXLlS3/zmN+e83QMHDujyyy+fd/YwUZgBAACWsPbediUmExnNTUwm1N7bntbYH/zgByorK9P27dslSZdccon+/u//XnfddZcmJiZ0991360/+5E+0ZcsW3XrrrRocHNR1110nSZqYmNCf/umf6vrrr9f73/9+veUtb1FfX58kqbq6Wr/+9a81ODioa6+9Vn/2Z3+mN77xjbr11luVTE7vNd+zZ4/e/OY364YbbtAf//Efa2JiIjDrL3/5S61fv15vfvOb9alPfers9vHxcd1yyy2qqanRm970Jn3729+WJH3iE5/Qz3/+c61du1Yf//jHLzouTBRmAACARRIfjl/wAb90uVz9I/1pjX366adVW1t7zrbf+73f0+rVqzUwMCBJ6u3t1T333KMf/OAH54zbvXu3li9frp/+9Kf61Kc+pf7+2X/m888/r5aWFj399NO6/PLLdf/990uStm3bpscee0xPPPGErr32Wt15552BWXfs2KGPfvSjeuyxx/Ta17727PaysjI9+OCDisfjeuSRR9Ta2ip31+c+9zm97nWv0+OPP64vfOELFx0XJgozAADAIpmYCt7bOpfk6fTWPrv7rEeGmLn9Xe96lyoqKi4Y88Mf/lC33367JOm6667T9ddfP+vPuPrqq7V27VpJUm1trQYHByVJTz31lDZs2KA3velNuvfee/X0008HZv3Rj36kD3zgA5KkD33oQ+dk/eQnP6nrr79e73znO/Wv//qv+tWvfjXr75TOuIXgOMwAAKCgFdLJP8oj5TquzD40J0nRkmha4974xjee3eN7xsmTJ3XkyBG97nWvU39/v2Kx2Kxz0907+8pXvvLs5UsuueTskow77rhD3/rWt3TDDTfo7rvv1sGDB+e8rdn++9x77706duyY+vv7VVJSourq6lnPnJjuuIVgDzMAAChYXQNdqvqHKm25b4u+89x3NDw+rOOnjmt4fFjfee472nzfZlV/qVrfG/herqNKkmpW1siUWXk3mWora+ceKOmWW27RxMSEvvrVr0qSXn75ZbW2tuqOO+5QeXl54Ny3ve1t+vrXvy5JeuaZZ/Tkk0/OK+dLL72kyspKnT59Wvfee++c42+++WZ97Wtfk6Rzxp84cUKvfvWrVVJSokceeURDQ0OSpGXLlumll16ac1yYKMwAAKAgFeLJP1rXtypWOvue3bnESmNqXd+a1lgz04MPPqhvfOMbuuaaa/T6179eZWVl+tu//ds55/75n/+5jh07puuvv16f//zndf311+uyyy5LO+dnP/tZveUtb9G73vUu/cEf/MGc47/0pS9p165devOb36wTJ06c3f7BD35QfX19qqur07333nv2tq644grdfPPNuu666/Txj3/8ouPCZGEvig5DXV2dn/k0JgAAwPm6Brq0be+2eR3POBqJ6oH3P6CNazZmMdm0Z599Vtdee+0F291dVf9QpSMnj8z7NldftlqDOwazvrzk5Zdf1unTp1VWVqaf//znuuWWW/Tcc8+ptLQ0qz8322b7b2Jm/e5eN9dc9jADAICCspgn/wibmWnPlj2KRtJbi3xGNBJVx+aORVmLPTExobe97W264YYbtHXrVn35y18u+LK8UHzoDwAAFJQwTv7RUN0Qcqr0Na5p1K5Nu9I+PXY0EtXuTbvVuKZxEdJNrxHmnf5zUZgBAEBBCePkH4tRmC92aDdJ2r5uuyqXVap5f7NGk6NKTCbOWYNtMsVKY6qIVqhjc8eileXF4D69tvzfxv9NE6cn9Fv/rV5hr1B5Sblee+lrdWnppaHvSV/ouwoUZgAAUFAW6+QfC1FWVqYXX3xRV1xxxUXL38Y1GzW4Y1A9Qz3a2btT8ZG4kqeTipZEVVtZq7ab2rRh9Ya8OSReGE6cOqGhE0Oa+u2Ufuu/Pbv9ZX9ZJ35zQi9NvqTIKyKquqxKl5Wl/0HDIO6uF198UWVlZRnfBoUZAAAUlMU6+cdCrFq1SkePHtWxY8fmHPtqvVp/t/bvpLXnXTEh/exnP8tOwBwYnxzXaHI0rb29IzaiimiFLi29NJSfXVZWplWrVmU8n8IMAAAKymKd/GMhSkpKdPXVV2f95xSKroEubXsgf49qMheOkgEAAArKYp38A+Eo5KOanDFnYTazMjP7iZk9YWZPm9nfzDLmDjM7ZmaPp77+zxnXfdjMnk99fTjsXwAAABSXxTr5B8IRxlFNci2dPcy/kfQOd79B06trNprZW2cZt9fd16a+/lGSzKxC0qclvUXSjZI+bWbLQ8oOAACKUENVg5aXZVYnKqIVqq+qDzkRgoRxVJNcm7Mw+7Tx1Lclqa909403SnrY3UfdfUzSw5JyvxAFAAAUrEI4+Qd+pxCOajKXtNYwm9klZva4pBc0XYAfnWXYH5vZT83sm2Z2VWrblZJmnvvxaGrbbD+jycz6zKwvnU+UAgCA4nXm5B/plubFPvkHfqcQjmoyl7QKs7u/7O5rJa2SdKOZXXfekH2Sqt39ekn/U9I9qe2z/S/crP+L4e4d7l7n7nUrVqxILz0AACha29dt1wPvf0CrL1s9fbKL82qHyXRp6aVafdlqPfj+B3XHujtyE7TIlUfKFzR/MY5qMpd5HSXD3Y9LOqjzllW4+4vu/pvUt3sknfn46VFJV80YukrScEZJAQAAznPm5B/7P7Bff/T6P9LKZSu1vGy5Vi5bqc2v36zv/PvvaHDHIHuWc2gpHNVkzuMwm9kKSafd/biZRSW9U9LnzxtT6e4jqW/fI+nZ1OXvSfrbGR/0u1XSX4SSHAAAQNNrmhuqGxbldNeYv9b1rTo4eFDjk+NzDz5PvhzVJJ0Tl1RKusfMLtH0Humvu/t+M/uMpD53f0jSfzaz90iakjQq6Q5JcvdRM/uspMdSt/UZdx8N+5cAAABAfjpzVJNMCnO+HNXE8uFg0Oerq6vzvr6+XMcAAABACL438D1t3bt13mf6e/D9D2Z1OY2Z9bt73VzjONMfAAAAsqrQj2qSzpIMAAAAYEG2r9uuymWVat7frNHkqBKTiXOOz2wyxUpjqohWqGNzR96UZYnCDAAAgEVy5qgmPUM92tm7U/GRuJKnk4qWRFVbWau2m9q0YfWGvDu5DIUZAAAAi6YQj2rCGmYAAAAgAIUZAAAACEBhBgAAAAJQmAEAAIAAFGYAAAAgAIUZAAAACEBhBgAAAAJQmAEAAIAAFGYAAAAgAIUZAAAACEBhBgAAAAJEch0AAACEy93VPdSt9t52xYfjmpiaUHmkXDUra9S2vk31VfUys1zHBAoGhRkAgCWka6BLTfuaNHZqTInJhFwuSTqu4xp5bkQHBw+qIlqhjs0dalzTmOO0QGFgSQYAAEtE56FObdu7TUdOHtH45PjZsnyGyzU+Oa7DJw5r696t6jzUmaOkQGGhMAMAsAR0DXSp5UCLklPJtMYnp5JqOdCiroGuLCcDCh+FGQCAAufuatrXlHZZPiM5lVTz/ma5+9yDgSJGYQYAoMB1D3Vr7NRYRnNHk6PqGeoJORGwtFCYAQAocO297UpMJjKam5hMqL23PeREwNJCYQYAoMDFh+MXfMAvXS5X/0h/yImApYXCDABAgZuYmljQ/OTp+a19BooNhRkAgAJXHilf0PxoSTSkJMDSRGEGAKDA1ayskSmzM/eZTLWVtSEnApYWCjMAAAWudX2rYqWxjObGSmNqXd8aciJgaaEwAwBQ4BqqGrS8bHlGcyuiFaqvqg85EbC0UJgBAChwZqY9W/YoGpnfWuRoJKqOzR0yy2w5B1AsKMwAACwBjWsatWvTrrRLczQS1e5Nu9W4pjHLyYDCF8l1AAAAEI7t67arclmlmvc3azQ5qsRk4pzjM5tMsdKYKqIV6tjcQVkG0kRhBgBgCdm4ZqMGdwyqZ6hHO3t3Kj4SV/J0UtGSqGora9V2U5s2rN7AMgxgHijMAAAsMWamhuoGNVQ35DoKsCSwhhkAAAAIQGEGAAAAAlCYAQAAgAAUZgAAACAAhRkAAAAIQGEGAAAAAlCYAQAAgAAUZgAAACDAnIXZzMrM7Cdm9oSZPW1mfzPLmP/bzJ4xs5+a2T+bWdWM6142s8dTXw+F/QsAAAAA2ZTOmf5+I+kd7j5uZiWSfmhm33X3H88Yc0hSnbtPmNlHJf2dpPenrku6+9pwYwMAAACLY849zD5tPPVtSerLzxvziLtPpL79saRVoaYEAAAAciStNcxmdomZPS7pBUkPu/ujAcM/Ium7M74vM7M+M/uxmb13AVkBAACARZfOkgy5+8uS1prZ5ZIeNLPr3P2p88eZ2X+QVCepYcbm1e4+bGb/TtIPzOxJd//5LHObJDVJ0urVqzP4VQAAAIDwzesoGe5+XNJBSRvPv87M3inpLyW9x91/M2POcOrfX6TmrrvIbXe4e527161YsWI+sQAAAICsSecoGStSe5ZlZlFJ75T0s/PGrJP0PzRdll+YsX25mb0ydflVkm6W9Ex48QEAQFjcXQcHD2rLfVt0ZfuVWv755bqy/UptuW+Luge75e5z3wiwBKWzJKNS0j1mdommC/bX3X2/mX1GUp+7PyTpC5IulfQNM5Okw+7+HknXSvofZvbb1NzPuTuFGQCAPNM10KWmfU0aOzWmxGRCnvp8/3Ed18hzIzo4eFAV0Qp1bO5Q45rGHKcFFpfl4/8t1tXVeV9fX65jAABQFDoPdarlQIuSU8k5x0YjUe3atEvb121fhGRAdplZv7vXzTWOM/0BAFDEuga60i7LkpScSqrlQIu6BrqynAzIHxRmAACKlLuraV9T2mX5jORUUs37m1nTjKJBYQYAoEh1D3Vr7NRYRnNHk6PqGeoJORGQnyjMAAAUqfbediUmExnNTUwm1N7bHnIiID9RmAEAKFLx4fjZo2HMl8vVP9IfciIgP1GYAQAoUhNTEwuanzw9v7XPQKGiMAMAUKTKI+ULmh8tiYaUBMhvFGYAAIpUzcoamSyjuSZTbWVtyImA/ERhBgCgSLWub1WsNJbR3FhpTK3rW0NOBOQnCjMAAEWqoapBy8uWZzS3Ilqh+qr6kBMB+YnCDABAkTIz7dmyR9HI/NYiRyNRdWzukFlmyzmAQkNhBgCgiDWuadSuTbvSLs3RSFS7N+1W45rGLCcD8kck1wEAAEBubV+3XZXLKtW8v1mjyVElJhPnHJ/ZZIqVxlQRrVDH5g7KMooOhRkAAGjjmo0a3DGonqEe7ezdqfhIXMnTSUVLoqqtrFXbTW3asHoDyzBQlCjMAABA0vSa5obqBjVUN+Q6CpBXWMMMAAAABKAwAwAAAAEozAAAAEAACjMAAAAQgA/9AQCwyNxd3UPdau9tV3w4rompCZVHylWzskZt69tUX1XP0SiAPEJhBgBgEXUNdKlpX5PGTo2dc7zj4zqukedGdHDwIMc7BvIMSzIAAFgknYc6tW3vNh05eUTjk+PnnBxEklyu8clxHT5xWFv3blXnoc4cJQUwE4UZAIBF0DXQpZYDLUpOJdMan5xKquVAi7oGurKcDMBcKMwAAGSZu6tpX1PaZfmM5FRSzfub5e5zDwaQNRRmAACyrHuoW2OnxjKaO5ocVc9QT8iJAMwHhRkAgCxr721XYjKR0dzEZELtve0hJwIwHxRmAACyLD4cv+ADfulyufpH+kNOBGA+KMwAAGTZxNTEguYnT89v7TOAcFGYAQDIsvJI+YLmR0uiISUBkAkKMwAAWVazskamzM7cZzLVVtaGnAjAfFCYAQDIstb1rYqVxjKaGyuNqXV9a8iJAMwHhRkAgCxrqGrQ8rLlGc2tiFaovqo+5EQA5oPCDABAlpmZ9mzZo2hkfmuRo5GoOjZ3yCyz5RwAwkFhBgBgETSuadSuTbvSLs3RSFS7N+1W45rGLCcDMJdIrgMAAFAstq/brspllWre36zR5KgSk4lzjs9sMsVKY6qIVqhjcwdlGcgTFGYAABbRxjUbNbhjUD1DPdrZu1PxkbiSp5OKlkRVW1mrtpvatGH1BpZhAHmEwgwAwCIzMzVUN6ihuiHXUQCkgTXMAAAAQAAKMwAAABCAwgwAAAAEoDADAAAAASjMAAAAQIA5C7OZlZnZT8zsCTN72sz+ZpYxrzSzvWY2YGaPmln1jOv+IrX9X8yMA0oCAACgoKSzh/k3kt7h7jdIWitpo5m99bwxH5E05u5rJP29pM9Lkpm9QdLtkt4oaaOk3WZ2SVjhAQAAgGybszD7tPHUtyWpLz9v2G2S7kld/qakW2z6iOu3Sfqau//G3X8paUDSjaEkBwAAABZBWmuYzewSM3tc0guSHnb3R88bcqWkI5Lk7lOSTki6Yub2lKOpbbP9jCYz6zOzvmPHjs3vtwAAAACyJK3C7O4vu/taSask3Whm1503ZLbzd3rA9tl+Roe717l73YoVK9KJBQAAAGTdvI6S4e7HJR3U9HrkmY5KukqSzCwi6TJJozO3p6ySNJxhVgAAAGDRpXOUjBVmdnnqclTSOyX97LxhD0n6cOry+yT9wN09tf321FE0rpZ0jaSfhBUeAAAAyLZIGmMqJd2TOrrFKyR93d33m9lnJPW5+0OS7pT0/5rZgKb3LN8uSe7+tJl9XdIzkqYktbj7y9n4RQAAAIBssOkdwfmlrq7O+/r6ch0DAAAAS5iZ9bt73VzjONMfAAAAEIDCDAAAAASgMAMAAAABKMwAAABAAAozAAAAEIDCDAAAAASgMAMAAAABKMwAAABAAAozAAAAEIDCDAAAAASgMAMAAAABKMwAAABAAAozAAAAEIDCDAAAAASgMAMAAAABKMwAAABAAAozAAAAEIDCDAAAAASgMAMAAAABKMwAAABAAAozAAAAEIDCDAAAAASgMAMAAAABKMwAAABAAAozAAAAEIDCDAAAAASgMAMAAAABKMwAAABAAAozAAAAEIDCDAAAAASgMAMAAAABKMwAAABAAAozAAAAEIDCDAAAAASgMAMAAAABKMwAAABAAAozAAAAEIDCDAAAAASgMAMAAAABKMwAAABAAAozAAAAECAy1wAzu0rSVyW9VtJvJXW4+5fOG/NxSR+ccZvXSlrh7qNmNijpJUkvS5py97rw4gMAAADZNWdhljQlqdXd42a2TFK/mT3s7s+cGeDuX5D0BUkysy2S/ou7j864jbe7+6/DDA4AAAAshjmXZLj7iLvHU5dfkvSspCsDpnxA0n3hxAMAAABya15rmM2sWtI6SY9e5PpySRsl3T9js0v6vpn1m1lTwG03mVmfmfUdO3ZsPrEAAACArEm7MJvZpZouwh9z95MXGbZF0o/OW45xs7vXSHq3pBYzq59tort3uHudu9etWLEi3VgAAABAVqVVmM2sRNNl+V53fyBg6O06bzmGuw+n/n1B0oOSbswsKgAAALD45izMZmaS7pT0rLt/MWDcZZIaJH17xrZY6oOCMrOYpFslPbXQ0AAAAMBiSecoGTdL+pCkJ83s8dS2T0paLUnu/pXUtq2Svu/uiRlzXyPpwenOrYikf3L3rjCCAwAAAIthzsLs7j+UZGmMu1vS3edt+4WkGzLMBgAAAOQcZ/oDAAAAAlCYAQAAgAAUZgAAACAAhRkAAAAIQGEGAAAAAlCYAQAAgAAUZgAAACAAhRkAAAAIQGEGAAAAAlCYAQAAgAAUZgAAACAAhRkAAAAIQGEGAAAAAlCYAQAAgAAUZgAAACAAhRkAAAAIEMl1AAD5y93VPdSt9t52xYfjmpiaUHmkXDUra9S2vk31VfUys1zHBICs4XUQkmTunusMF6irq/O+vr5cxwCKWtdAl5r2NWns1JgSkwm5fvdaYTLFSmOqiFaoY3OHGtc05jApAGQHr4NLn5n1u3vdXONYkgHgAp2HOrVt7zYdOXlE45Pj5/yRkCSXa3xyXIdPHNbWvVvVeagzR0kBIDt4HcRMFGYA5+ga6FLLgRYlp5JpjU9OJdVyoEVdA11ZTgYAi4PXQZyPwgzgLHdX076mtP9InJGcSqp5f7PycYkXAMwHr4OYDYUZwFndQ90aOzWW0dzR5Kh6hnpCTgQAi4vXQcyGwgzgrPbediUmExnNTUwm1N7bHnIiAFhcvA5iNhRmAGfFh+MXfLAlXS5X/0h/yIkAYHHxOojZUJgBnDUxNbGg+cnT81vzBwD5htdBzIbCDOCs8kj5guZHS6IhJQGA3OB1ELOhMAM4q2ZljUyZnbHKZKqtrA05EQAsLl4HMRsKM4CzWte3KlYay2hurDSm1vWtIScCgMXF6yBmQ2EGcFZDVYOWly3PaG5FtEL1VfUhJwKAxcXrIGZDYQZwlplpz5Y9ikbmtwYvGomqY3OHzDJ7GxMA8gWvg5gNhRnAORrXNGrXpl1p/7GIRqLavWm3Gtc0ZjkZACwOXgdxvkiuAwDIP9vXbVflsko172/WaHJUicnEOcclNZlipTFVRCvUsbmDPxIAlhxeBzGT5eM5z+vq6ryvry/XMYCi5+7qGerRzt6dio/ElTydVLQkqtrKWrXd1KYNqzfw9iOAJY3XwaXNzPrdvW7OcRRmAAAAFKN0CzNrmAEAAIAAFGYAAAAgAB/6A4AC4e7qHupWe2+74sNxTUxNqDxSrpqVNWpb36b6qnrWUgJAFlCYAaAAdA10qWlfk8ZOjZ3zaf3jOq6R50Z0cPAgn9YHgCxhSQYA5LnOQ53atnebjpw8ovHJ8XMObSVJLtf45LgOnzisrXu3qvNQZ46SAsDSRGEGgDzWNdCllgMtSk4l0xqfnEqq5UCLuga6spwMAIoHhRkA8pS7q2lfU9pl+YzkVFLN+5uVj4cNBYBCNGdhNrOrzOwRM3vWzJ42sx2zjPlDMzthZo+nvv5qxnUbzexfzGzAzD4R9i8AAEtV91C3xk6NZTR3NDmqnqGekBMBQHFKZw/zlKRWd79W0lsltZjZG2YZ97/cfW3q6zOSZGaXSNol6d2S3iDpAxeZCwA4T3tvuxKTiYzmJiYTau9tDzkRABSnOQuzu4+4ezx1+SVJz0q6Ms3bv1HSgLv/wt0nJX1N0m2ZhgWAYhIfjl/wAb90uVz9I/0hJwKA4jSvNcxmVi1pnaRHZ7l6vZk9YWbfNbM3prZdKenIjDFHdZGybWZNZtZnZn3Hjh2bTywAWJImpiYWND95en5rnwEAs0u7MJvZpZLul/Qxdz953tVxSVXufoOk/ybpW2emzXJTs+4ucfcOd69z97oVK1akGwsAlqzySPmC5kdLoiElAYDillZhNrMSTZfle939gfOvd/eT7j6eunxAUomZvUrTe5SvmjF0laThBacGgCJQs7JGNut+h7mZTLWVtSEnAoDilM5RMkzSnZKedfcvXmTMa1PjZGY3pm73RUmPSbrGzK42s1JJt0t6KKzwALCUta5vVaw0ltHcWGlMretbQ04EAMUpnVNj3yzpQ5KeNLPHU9s+KWm1JLn7VyS9T9JHzWxKUlLS7T59ANApM/tPkr4n6RJJd7n70yH/DgCwJDVUNWh52XKNT47Pe25FtEL1VfVZSAUAxWfOwuzuP9Tsa5Fnjvnvkv77Ra47IOlARukAoIiZmfZs2aOte7fO6+Ql0UhUHZs7lHrjDwCwQJzpDwDyWOOaRu3atEvRSHof4ItGotq9abca1zRmORkAFI90lmQAAHJo+7rtqlxWqeb9zRpNjioxmTjn+MwmU6w0popohTo2d1CWASBkFGYAKAAb12zU4I5B9Qz1aGfvTsVH4kqeTipaElVtZa3abmrThtUbWIYBAFlAYQaAAmFmaqhuUEN1Q66jAEBRYQ0zAAAAEIDCDAAAAASgMAMAAAABWMMM5Dl3V/dQt9p72xUfjmtiakLlkXLVrKxR2/o21VfV80EvIAM8twCky6ZPyJdf6urqvK+vL9cxgJzrGuhS074mjZ0a41BiQIh4bgGQJDPrd/e6ucaxJAPIU52HOrVt7zYdOXlE45Pj5/xBlySXa3xyXIdPHNbWvVvVeagzR0mBwsJzC8B8UZiBPNQ10KWWAy1pnw45OZVUy4EWdQ10ZTkZUNh4bgHIBIUZyDPurqYVb9NsAAAXDElEQVR9TWn/QT8jOZVU8/5m5eMyKyAf8NwCkCkKM5Bnuoe6NXZqLKO5o8lR9Qz1hJwIWBp4bgHIFIUZyDPtve1KTCYympuYTKi9tz3kRMDSwHMLQKYozECeiQ/HL/gQUrpcrv6R/pATAUsDzy0AmaIwA3lmYmpiQfOTp+e3PhMoFjy3AGSKwgzkmfJI+YLmR0uiISUBlhaeWwAyRWEG8kzNyhqZMju7mMlUW1kbciJgaeC5BSBTFGYgz7Sub1WsNJbR3FhpTK3rW0NOBCwNPLcAZIrCDOSZhqoGLS9bntHcimiF6qvqQ04ELA08twBkisIM5Bkz054texSNzG+9ZDQSVcfmDpll9pYzsNTx3AKQKQozkIca1zRq16Zdaf9hj0ai2r1ptxrXNGY5GVDYeG4ByEQk1wEAzG77uu2qXFap5v3NGk2OKjGZOOcYsiZTrDSmimiFOjZ38AcdSBPPLQDzZe6ZHcQ9m+rq6ryvry/XMYC84O7qGerRzt6dio/ElTydVLQkqtrKWrXd1KYNqzfwVjGQAZ5bAMys393r5hxHYQYAAEAxSrcws4YZAAAACEBhBgAAAAJQmAEAAIAAFGYAAAAgAIUZAAAACEBhBgAAAAJQmAEAAIAAFGYAAAAgAIUZAAAACEBhBgAAAAJQmAEAAIAAFGYAAAAgAIUZAAAACEBhBgAAAAJQmAEAAIAAFGYAAAAgwJyF2cyuMrNHzOxZM3vazHbMMuaDZvbT1Nf/NrMbZlw3aGZPmtnjZtYX9i8AAAAAZFMkjTFTklrdPW5myyT1m9nD7v7MjDG/lNTg7mNm9m5JHZLeMuP6t7v7r8OLDQAAACyOOQuzu49IGkldfsnMnpV0paRnZoz53zOm/FjSqpBzAgAAADkxrzXMZlYtaZ2kRwOGfUTSd2d875K+b2b9ZtY034AAAABALqWzJEOSZGaXSrpf0sfc/eRFxrxd04X5bTM23+zuw2b2akkPm9nP3L1nlrlNkpokafXq1fP4FQAAAIDsSWsPs5mVaLos3+vuD1xkzPWS/lHSbe7+4pnt7j6c+vcFSQ9KunG2+e7e4e517l63YsWK+f0WAAAAQJbMuYfZzEzSnZKedfcvXmTMakkPSPqQuz83Y3tM0itSa59jkm6V9JlQkgN5xN3VPdSt9t52xYfjmpiaUHmkXDUra9S2vk31VfWafioBAIBCk86SjJslfUjSk2b2eGrbJyWtliR3/4qkv5J0haTdqVIw5e51kl4j6cHUtoikf3L3rlB/AyDHuga61LSvSWOnxpSYTMjlkqTjOq6R50Z0cPCgKqIV6tjcocY1jTlOCwAA5svcPdcZLlBXV+d9fRyyGfmv81CnWg60KDmVnHNsNBLVrk27tH3d9kVIBgAA5mJm/amdvIE40x+Qoa6BrrTLsiQlp5JqOdCirgHeZAEAoJBQmIEMuLua9jWlXZbPSE4l1by/Wfn4zg4AAJgdhRnIQPdQt8ZOjWU0dzQ5qp6hC46sCAAA8hSFGchAe2+7EpOJjOYmJhNq720POREAAMgWCjOQgfhw/OzRMObL5eof6Q85EQAAyBYKM5CBiamJBc1Pnp7f2mcAAJA7FGYgA+WR8gXNj5ZEQ0oCAACyjcIMZKBmZY1MmZ25z2SqrawNOREAAMgWCjOQgdb1rYqVxjKaGyuNqXV9a8iJAABAtlCYgQw0VDVoednyjOZWRCtUX1UfciIAAJAtFGYgA2amPVv2KBqZ31rkaCSqjs0dMstsOQcAAFh8FGYgQ41rGrVr0660S3M0EtXuTbvVuKYxy8kAAECYIrkOABSy7eu2q3JZpZr3N2s0OarEZOKc4zObTLHSmCqiFerY3EFZBgCgAFGYgQXauGajBncMqmeoRzt7dyo+ElfydFLRkqhqK2vVdlObNqzewDIMAAAKFIUZCIGZqaG6QQ3VDbmOAgAAQsYaZgAAACAAhRkAAAAIQGEGAAAAAlCYAQAAgAAUZgAAACAAhRkAAAAIQGEGAAAAAlCYAQAAgAAUZgAAACAAhRkAAAAIQGEGAAAAAlCYAQAAgAAUZgAAACAAhRkAAAAIQGEGAAAAAlCYAQAAgAAUZgAAACAAhRkAAAAIQGEGAAAAAlCYAQAAgAAUZgAAACAAhRkAAAAIQGEGAAAAAlCYAQAAgAAUZgAAACAAhRkAAAAIQGEGAAAAAsxZmM3sKjN7xMyeNbOnzWzHLGPMzP6rmQ2Y2U/NrGbGdR82s+dTXx8O+xcAAAAAsimSxpgpSa3uHjezZZL6zexhd39mxph3S7om9fUWSV+W9BYzq5D0aUl1kjw19yF3Hwv1twAAAACyZM49zO4+4u7x1OWXJD0r6crzht0m6as+7ceSLjezSkmNkh5299FUSX5Y0sZQfwMAAAAgi9LZw3yWmVVLWifp0fOuulLSkRnfH01tu9j22W67SVKTJK1evXo+sQAUGXdX91C32nvbFR+Oa2JqQuWRctWsrFHb+jbVV9XLzHIdEwCwRKRdmM3sUkn3S/qYu588/+pZpnjA9gs3undI6pCkurq6WccAQNdAl5r2NWns1JgSkwl56iXluI5r5LkRHRw8qIpohTo2d6hxTWOO0wIAloK0jpJhZiWaLsv3uvsDsww5KumqGd+vkjQcsB0A5q3zUKe27d2mIyePaHxy/GxZPsPlGp8c1+ETh7V171Z1HurMUVIAwFKSzlEyTNKdkp519y9eZNhDkv6P1NEy3irphLuPSPqepFvNbLmZLZd0a2obAMxL10CXWg60KDmVTGt8ciqplgMt6hroynIyAMBSl86SjJslfUjSk2b2eGrbJyWtliR3/4qkA5I2SRqQNCFpe+q6UTP7rKTHUvM+4+6j4cUHUAzcXU37mtIuy2ckp5Jq3t+swR2DrGkGAGRszsLs7j/U7GuRZ45xSS0Xue4uSXdllA4AJHUPdWvsVGZHoxxNjqpnqEcN1Q0hpwIAFAvO9Acg77X3tisxmchobmIyofbe9pATAQCKCYUZQN6LD8cv+IBfulyu/pH+kBMBAIoJhRlA3puYmljQ/OTp+a19BgBgJgozgLxXHilf0PxoSTSkJACAYkRhBpD3albWyII/e3xRJlNtZW3IiQAAxYTCDCDvta5vVaw0ltHcWGlMretbQ04EACgmFGYAea+hqkHLy5ZnNLciWqH6qvqQEwEAigmFGUDeMzPt2bJH0cj81iJHI1F1bO7gpCUAgAWhMAMoCI1rGrVr0660S3M0EtXuTbvVuKYxy8kAAEtdOqfGBoC8sH3ddlUuq1Tz/maNJkeVmEycc3xmkylWGlNFtEIdmzsoywCAUFCYARSUjWs2anDHoHqGerSzd6fiI3ElTycVLYmqtrJWbTe1acPqDSzDAACEhsIMoOCYmRqqG9RQ3ZDrKACAIsAaZgAAACAAhRkAAAAIQGEGAAAAAlCYAQAAgAAUZgAAACAAhRkAAAAIQGEGAAAAAlCYAQAAgAAUZgAAACAAhRkAAAAIQGEGAAAAAlCYAQAAgAAUZgAAACAAhRkAAAAIQGEGAAAAAlCYAQAAgAAUZgAAACAAhRkAAAAIQGEGAAAAAlCYAQAAgAAUZgAAACAAhRkAAAAIEMl1gFxzd3UPdau9t13x4bgmpiZUHilXzcoata1vU31Vvcws1zEBAACQI0VdmLsGutS0r0ljp8aUmEzI5ZKk4zqukedGdHDwoCqiFerY3KHGNY05TgsAAIBcKNolGZ2HOrVt7zYdOXlE45PjZ8vyGS7X+OS4Dp84rK17t6rzUGeOkgIAACCXirIwdw10qeVAi5JTybTGJ6eSajnQoq6BriwnAwAAQL4pusLs7mra15R2WT4jOZVU8/5mufvcgwEAALBkFF1h7h7q1tipsYzmjiZH1TPUE3IiAAAA5LOiK8ztve1KTCYympuYTKi9tz3kRAAAAMhncx4lw8zukrRZ0gvuft0s139c0gdn3N61kla4+6iZDUp6SdLLkqbcvS6s4JmKD8cv+IBfulyu/pH+kBMBAAAgn6Wzh/luSRsvdqW7f8Hd17r7Wkl/Ianb3UdnDHl76vqcl2VJmpiaWND85On5rX0GAABAYZuzMLt7j6TRucalfEDSfQtKlGXlkfIFzY+WRENKAgAAgEIQ2hpmMyvX9J7o+2dsdknfN7N+M2uaY36TmfWZWd+xY8fCinWBmpU1MmV25j6TqbayNuREAAAAyGdhfuhvi6Qfnbcc42Z3r5H0bkktZlZ/scnu3uHude5et2LFihBjnat1fatipbGM5sZKY2pd3xpyIgAAAOSzMAvz7TpvOYa7D6f+fUHSg5JuDPHnZaShqkHLy5ZnNLciWqH6qot2fgAAACxBoRRmM7tMUoOkb8/YFjOzZWcuS7pV0lNh/LyFMDPt2bJH0cj81iJHI1F1bO6QWWbLOQAAAFCY5izMZnafpF5Jv29mR83sI2b2H83sP84YtlXS99195gGOXyPph2b2hKSfSPqOu+fFuaUb1zRq16ZdaZfmaCSq3Zt2q3FNY5aTAQAAIN9YPp7qua6uzvv6+rL+c7oGutS8v1mjyVElJhPnHJ/ZZIqVxlQRrVDH5g7KMgAAwBJjZv3pHPp4zhOXLGUb12zU4I5B9Qz1aGfvTsVH4kqeTipaElVtZa3abmrThtUbWIYBAABQxIq6MEvTa5obqhvUUN2Q6ygAAADIQ2EeJQMAAABYcijMAAAAQAAKMwAAABCAwgwAAAAEoDADAAAAASjMAAAAQAAKMwAAABCAwgwAAAAEoDADAAAAASjMAAAAQAAKMwAAABCAwgwAAAAEoDADAAAAASjMAAAAQIBIrgMsZe6u7qFutfe2Kz4c18TUhMoj5apZWaO29W2qr6qXmeU6JpYwHoMAACycuXuuM1ygrq7O+/r6ch1jQboGutS0r0ljp8aUmEzI9bv72WSKlcZUEa1Qx+YONa5pzGFSLFU8BgEACGZm/e5eN9c4lmRkQeehTm3bu01HTh7R+OT4OUVFklyu8clxHT5xWFv3blXnoc4cJcVSxWMQAIDwUJhD1jXQpZYDLUpOJdMan5xKquVAi7oGurKcDMWCxyAAAOGiMIfI3dW0ryntonJGciqp5v3NysflMSgsPAYBAAgfhTlE3UPdGjs1ltHc0eSoeoZ6Qk6EYsNjEACA8FGYQ9Te267EZCKjuYnJhNp720NOhGLDYxAAgPBRmEMUH45f8OGqdLlc/SP9ISdCseExCABA+CjMIZqYmljQ/OTp+a07Bc7HYxAAgPBRmENUHilf0PxoSTSkJChWPAYBAAgfhTlENStrZMrsrGkmU21lbciJUGx4DAIAED4Kc4ha17cqVhrLaG6sNKbW9a0hJ0Kx4TEIAED4KMwhaqhq0PKy5RnNrYhWqL6qPuREKDY8BgEACB+FOURmpj1b9igamd860Ggkqo7NHTLL7K104AwegwAAhI/CHLLGNY3atWlX2oUlGolq96bdalzTmOVkKBY8BgEACFck1wGWou3rtqtyWaWa9zdrNDmqxGTinGPjmkyx0pgqohXq2NxBUUHoeAwCABAec8/sJAfZVFdX5319fbmOsWDurp6hHu3s3an4SFzJ00lFS6KqraxV201t2rB6A2+BI6t4DAIAcHFm1u/udXOOozADAACgGKVbmFnDDAAAAASgMAMAAAABKMwAAABAAAozAAAAEIDCDAAAAASgMAMAAAABKMwAAABAgDkLs5ndZWYvmNlTF7n+D83shJk9nvr6qxnXbTSzfzGzATP7RJjBAQAAgMWQzh7muyVtnGPM/3L3tamvz0iSmV0iaZekd0t6g6QPmNkbFhIWAAAAWGxzFmZ375E0msFt3yhpwN1/4e6Tkr4m6bYMbgcAAADImbDWMK83syfM7Ltm9sbUtislHZkx5mhq26zMrMnM+sys79ixYyHFAgAAABYmjMIcl1Tl7jdI+m+SvpXabrOM9YvdiLt3uHudu9etWLEihFgAAADAwi24MLv7SXcfT10+IKnEzF6l6T3KV80YukrS8EJ/HgAAALCYFlyYzey1ZmapyzembvNFSY9JusbMrjazUkm3S3pooT8PAAAAWEyRuQaY2X2S/lDSq8zsqKRPSyqRJHf/iqT3SfqomU1JSkq63d1d0pSZ/SdJ35N0iaS73P3pdEL19/f/2syGMvh90vEqSb/O0m0vVdxn88d9Nn/cZ/PHfTY/3F/zx302f9xn85fL+6wqnUE23W2Lh5n1uXtdrnMUEu6z+eM+mz/us/njPpsf7q/54z6bP+6z+SuE+4wz/QEAAAABKMwAAABAgGIszB25DlCAuM/mj/ts/rjP5o/7bH64v+aP+2z+uM/mL+/vs6JbwwwAAADMRzHuYQYAAADSRmEGAAAAAhRNYTazq8zsETN71syeNrMduc6U78yszMx+YmZPpO6zv8l1pkJgZpeY2SEz25/rLIXAzAbN7Ekze9zM+nKdpxCY2eVm9k0z+1nqNW19rjPlMzP7/dTj68zXSTP7WK5z5Tsz+y+p1/6nzOw+MyvLdaZ8ZmY7UvfV0zy+Ls7M7jKzF8zsqRnbKszsYTN7PvXv8lxmnE3RFGZJU5Ja3f1aSW+V1GJmb8hxpnz3G0nvcPcbJK2VtNHM3prjTIVgh6Rncx2iwLzd3dfm+3E488iXJHW5+x9IukE83gK5+7+kHl9rJdVKmpD0YI5j5TUzu1LSf5ZU5+7XafoEZLfnNlX+MrPrJP2ZpBs1/ZzcbGbX5DZV3rpb0sbztn1C0j+7+zWS/jn1fV4pmsLs7iPuHk9dfknTf2CuzG2q/ObTxlPflqS++JRoADNbJemPJP1jrrNgaTKz35NUL+lOSXL3SXc/nttUBeUWST9392ydTXYpiUiKmllEUrmk4RznyWfXSvqxu0+4+5Skbklbc5wpL7l7j6TR8zbfJume1OV7JL13UUOloWgK80xmVi1pnaRHc5sk/6WWFzwu6QVJD7s791mwf5D0/0j6ba6DFBCX9H0z6zezplyHKQD/TtIxSZ2ppT//aGaxXIcqILdLui/XIfKdu/+rpJ2SDksakXTC3b+f21R57SlJ9WZ2hZmVS9ok6aocZyokr3H3EWl6B6ekV+c4zwWKrjCb2aWS7pf0MXc/mes8+c7dX069jblK0o2pt50wCzPbLOkFd+/PdZYCc7O710h6t6aXStXnOlCei0iqkfRld18nKaE8fPsyH5lZqaT3SPpGrrPku9Qa0tskXS1ppaSYmf2H3KbKX+7+rKTPS3pYUpekJzS9FBRLRFEVZjMr0XRZvtfdH8h1nkKSesv3oC5cd4TfuVnSe8xsUNLXJL3DzP6/3EbKf+4+nPr3BU2vK70xt4ny3lFJR2e82/NNTRdozO3dkuLu/qtcBykA75T0S3c/5u6nJT0g6aYcZ8pr7n6nu9e4e72mlxw8n+tMBeRXZlYpSal/X8hxngsUTWE2M9P0mr9n3f2Luc5TCMxshZldnroc1fQL6M9ymyp/uftfuPsqd6/W9Nu+P3B39sgEMLOYmS07c1nSrZp+axMX4e7/JumImf1+atMtkp7JYaRC8gGxHCNdhyW91czKU38/bxEfLg1kZq9O/bta0jbxWJuPhyR9OHX5w5K+ncMss4rkOsAiulnShyQ9mVqTK0mfdPcDOcyU7yol3WNml2j6f66+7u4cKg1heo2kB6f/Hisi6Z/cvSu3kQrC/yXp3tQSg19I2p7jPHkvta70XZKac52lELj7o2b2TUlxTS8tOKQCOH1xjt1vZldIOi2pxd3Hch0oH5nZfZL+UNKrzOyopE9L+pykr5vZRzT9P2t/kruEs+PU2AAAAECAolmSAQAAAGSCwgwAAAAEoDADAAAAASjMAAAAQAAKMwAAABCAwgwAAAAEoDADAAAAAf5/LjRotBtcP+8AAAAASUVORK5CYII=\n",
      "text/plain": [
       "<Figure size 864x576 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.figure(figsize=(12, 8))\n",
    "\n",
    "plt.scatter(x_train, y_train, label='Original data', s=250, c='g')\n",
    "\n",
    "plt.legend()\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [],
   "source": [
    "import torch "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Converting data to pytorch tensors\n",
    "By defualt requires_grad = False"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "requires_grad for X_train:  False\n",
      "requires_grad for Y_train:  False\n"
     ]
    }
   ],
   "source": [
    "X_train = torch.from_numpy(x_train) \n",
    "Y_train = torch.from_numpy(y_train)\n",
    "\n",
    "print('requires_grad for X_train: ', X_train.requires_grad)\n",
    "print('requires_grad for Y_train: ', Y_train.requires_grad)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Set the details for our neural network\n",
    "Input, output and hidden layer sizes plus the learning rate"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 74,
   "metadata": {},
   "outputs": [],
   "source": [
    "input_size = 1 \n",
    "hidden_size = 1\n",
    "output_size = 1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Create random Tensors for weights.<br>\n",
    "Setting requires_grad=True indicates that we want to compute gradients with respect to these Tensors during the backward pass"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 75,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "torch.Size([1, 1])"
      ]
     },
     "execution_count": 75,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "w1 = torch.rand(input_size, \n",
    "                hidden_size, \n",
    "                \n",
    "                requires_grad=True)\n",
    "w1.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 76,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "torch.Size([1, 1])"
      ]
     },
     "execution_count": 76,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "w2 = torch.rand(hidden_size, \n",
    "                output_size, \n",
    "                \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": 77,
   "metadata": {},
   "outputs": [],
   "source": [
    "learning_rate = 1e-6"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 78,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 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_()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 79,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "w1:  tensor([[0.3358]], requires_grad=True)\n",
      "w2:  tensor([[0.3698]], requires_grad=True)\n"
     ]
    }
   ],
   "source": [
    "print ('w1: ', w1)\n",
    "print ('w2: ', w2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Checking the output"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Converting data into a tensor"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 80,
   "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": 80,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x_train_tensor = torch.from_numpy(x_train)\n",
    "x_train_tensor"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Get the predicted values using the weights \n",
    "Using final weights calculated from our training in order to get the predicted values"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 81,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tensor([[0.5836],\n",
       "        [0.2980],\n",
       "        [0.9313],\n",
       "        [0.8816],\n",
       "        [0.5339],\n",
       "        [0.9705],\n",
       "        [1.1051],\n",
       "        [0.6457],\n",
       "        [1.0666],\n",
       "        [0.2608],\n",
       "        [0.9934],\n",
       "        [1.2417],\n",
       "        [0.5588],\n",
       "        [0.7450],\n",
       "        [0.4967]], grad_fn=<MmBackward>)"
      ]
     },
     "execution_count": 81,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "predicted_in_tensor = x_train_tensor.mm(w1).mm(w2)\n",
    "predicted_in_tensor"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Convert the prediction to a numpy array\n",
    "This will be used to plot the regression line in a plot"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 82,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0.58360565],\n",
       "       [0.29801142],\n",
       "       [0.9312856 ],\n",
       "       [0.88161707],\n",
       "       [0.5339371 ],\n",
       "       [0.97052383],\n",
       "       [1.1051255 ],\n",
       "       [0.64569134],\n",
       "       [1.0666325 ],\n",
       "       [0.26075998],\n",
       "       [0.99337137],\n",
       "       [1.2417141 ],\n",
       "       [0.5587714 ],\n",
       "       [0.74502856],\n",
       "       [0.49668568]], dtype=float32)"
      ]
     },
     "execution_count": 82,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "predicted = predicted_in_tensor.detach().numpy()\n",
    "predicted"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Plotting\n",
    "Our training has produced a rather accurate regression line"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 83,
   "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",
    "\n",
    "plt.scatter(x_train, y_train, label = 'Original data', s=250, c='g') \n",
    "\n",
    "plt.plot(x_train, predicted, label = 'Fitted line ')\n",
    "\n",
    "plt.legend() \n",
    "\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "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.1"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}