LAB1.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "markdown",
     "checksum": "c9f943bc6d17f5c41bf78d0fbd8204ab",
     "grade": false,
     "grade_id": "cell-8653d83277fb8418",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "source": [
    "# Lab 1\n",
    "\n",
    "This very first lab will introduce to some PyTorch basics including Tensors, Loss, and Autograd. Hopefully, we will start to get familar with PyTorch. In the end, we will implement a linear regression model from sratch with some synthetic data.\n",
    "\n",
    "Table of Contents:\n",
    "- Tensors\n",
    "- Loss\n",
    "- Autograd\n",
    "- Assignment\n",
    "\n",
    "Some contents of this lab are adapted from [Dive into Deep Learning](https://d2l.ai) and [Official PyTorch Tutorials](https://pytorch.org/tutorials/)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-11-09T19:59:52.845064Z",
     "start_time": "2021-11-09T19:59:52.299637Z"
    },
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "d3642e7fe74ecb8701a63240216578ce",
     "grade": false,
     "grade_id": "cell-7523865a465c9b1e",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "outputs": [],
   "source": [
    "import os\n",
    "import torch\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "import random"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-11-09T19:59:52.851501Z",
     "start_time": "2021-11-09T19:59:52.847236Z"
    },
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "aa13dd5c807dbeb0e92cebc3125b9092",
     "grade": false,
     "grade_id": "cell-825b96ce06875360",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "outputs": [],
   "source": [
    "# set seed\n",
    "seed = 42\n",
    "random.seed(seed)\n",
    "np.random.seed(seed)\n",
    "torch.manual_seed(seed)\n",
    "os.environ[\"PYTHONHASHSEED\"] = str(seed)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "markdown",
     "checksum": "e37e8000c736b9a9406f0d119ff7f3a7",
     "grade": false,
     "grade_id": "cell-7b7bbb08dff3040d",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "source": [
    "## 1. Tensors\n",
    "\n",
    "Tensors are a specialized data structure that are very similar to arrays and matrices. In PyTorch, we use tensors to encode the inputs and outputs of a model, as well as the model’s parameters.\n",
    "\n",
    "Tensors are similar to NumPy’s ndarrays, except that tensors can run on GPUs or other hardware accelerators. Tensors are also optimized for automatic differentiation (we’ll see more about that later in the Autograd section). "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "markdown",
     "checksum": "8a4a90005ecf60dd50e62ea7de665f9a",
     "grade": false,
     "grade_id": "cell-b03b01d3bd61bc0f",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "source": [
    "### 1.1 Initializing a Tensor\n",
    "\n",
    "Tensors can be initialized in various ways. Take a look at the following examples:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "markdown",
     "checksum": "77458c2ce63f29f0d1ad965bd8886bdb",
     "grade": false,
     "grade_id": "cell-2583c6a26873f427",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "source": [
    "**Directly from data**\n",
    "\n",
    "Tensors can be created directly from data. The data type is automatically inferred."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-11-09T19:59:52.858154Z",
     "start_time": "2021-11-09T19:59:52.853403Z"
    },
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "75ee8eefcb5a96b60d90d2b42b6dbef9",
     "grade": false,
     "grade_id": "cell-741b5efbb2c5f945",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tensor([[1, 2],\n",
       "        [3, 4]])"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "data = [[1, 2],[3, 4]]\n",
    "x_data = torch.tensor(data)\n",
    "x_data"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "markdown",
     "checksum": "654228ea3cb6365f53bbead1dd9872b9",
     "grade": false,
     "grade_id": "cell-a51593eb71551154",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "source": [
    "**From a NumPy array**\n",
    "\n",
    "Tensors can be created from NumPy arrays (and vice versa)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-11-09T19:59:52.863349Z",
     "start_time": "2021-11-09T19:59:52.859841Z"
    },
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "74779b8dd201e86c3c29040d89e07ad3",
     "grade": false,
     "grade_id": "cell-b2b7443d0480311c",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tensor([[1, 2],\n",
       "        [3, 4]])"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np_array = np.array(data)\n",
    "x_np = torch.from_numpy(np_array)\n",
    "x_np"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "markdown",
     "checksum": "7efc6ab13e7bb7ebef435ad392769a0d",
     "grade": false,
     "grade_id": "cell-8ee52e294863edd9",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "source": [
    "**From another tensor:**\n",
    "\n",
    "The new tensor retains the properties (shape, datatype) of the argument tensor, unless explicitly overridden."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-11-09T19:59:52.869010Z",
     "start_time": "2021-11-09T19:59:52.864867Z"
    },
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "ee6b4d83b94c4d3969cb7d973229b505",
     "grade": false,
     "grade_id": "cell-ceed6cc164f03815",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Ones Tensor: \n",
      " tensor([[1, 1],\n",
      "        [1, 1]]) \n",
      "\n",
      "Random Tensor: \n",
      " tensor([[0.8823, 0.9150],\n",
      "        [0.3829, 0.9593]]) \n",
      "\n"
     ]
    }
   ],
   "source": [
    "x_ones = torch.ones_like(x_data) # retains the properties of x_data\n",
    "print(f\"Ones Tensor: \\n {x_ones} \\n\")\n",
    "\n",
    "x_rand = torch.rand_like(x_data, dtype=torch.float) # overrides the datatype of x_data\n",
    "print(f\"Random Tensor: \\n {x_rand} \\n\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "markdown",
     "checksum": "43bb0a3f9c2770d1984d84f42a75f907",
     "grade": false,
     "grade_id": "cell-4671fa03f3944139",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "source": [
    "**With random or constant values:**\n",
    "\n",
    "``shape`` is a tuple of tensor dimensions. In the functions below, it determines the dimensionality of the output tensor."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-11-09T19:59:52.876523Z",
     "start_time": "2021-11-09T19:59:52.871788Z"
    },
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "27f971907aa50b901fa91edd9c576761",
     "grade": false,
     "grade_id": "cell-d85438a27666f252",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Random Tensor: \n",
      " tensor([[0.3904, 0.6009, 0.2566],\n",
      "        [0.7936, 0.9408, 0.1332]]) \n",
      "\n",
      "Ones Tensor: \n",
      " tensor([[1., 1., 1.],\n",
      "        [1., 1., 1.]]) \n",
      "\n",
      "Zeros Tensor: \n",
      " tensor([[0., 0., 0.],\n",
      "        [0., 0., 0.]])\n"
     ]
    }
   ],
   "source": [
    "shape = (2,3,)\n",
    "rand_tensor = torch.rand(shape)\n",
    "ones_tensor = torch.ones(shape)\n",
    "zeros_tensor = torch.zeros(shape)\n",
    "\n",
    "print(f\"Random Tensor: \\n {rand_tensor} \\n\")\n",
    "print(f\"Ones Tensor: \\n {ones_tensor} \\n\")\n",
    "print(f\"Zeros Tensor: \\n {zeros_tensor}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "markdown",
     "checksum": "b5d46abd7766af09043a3bc674fd153b",
     "grade": false,
     "grade_id": "cell-c8f38367d33a874e",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "source": [
    "### 1.2 Attributes of a Tensor\n",
    "\n",
    "Tensor attributes describe their shape, datatype, and the device on which they are stored."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-11-09T19:59:52.881522Z",
     "start_time": "2021-11-09T19:59:52.878755Z"
    },
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "a1de096b26be8502d768cf0112e683a0",
     "grade": false,
     "grade_id": "cell-0f572ccb4f2eed6d",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Shape of tensor: torch.Size([3, 4])\n",
      "Datatype of tensor: torch.float32\n",
      "Device tensor is stored on: cpu\n"
     ]
    }
   ],
   "source": [
    "tensor = torch.rand(3,4)\n",
    "\n",
    "print(f\"Shape of tensor: {tensor.shape}\")\n",
    "print(f\"Datatype of tensor: {tensor.dtype}\")\n",
    "print(f\"Device tensor is stored on: {tensor.device}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "markdown",
     "checksum": "abe60a975331fdb7d519d53ef968c668",
     "grade": false,
     "grade_id": "cell-5bc51b213e3495d9",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "source": [
    "### 1.3 Operations on Tensors\n",
    "\n",
    "Over 100 tensor operations, including arithmetic, linear algebra, matrix manipulation (transposing, \n",
    "indexing, slicing), sampling and more are\n",
    "comprehensively described [here](https://pytorch.org/docs/stable/torch.html)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "markdown",
     "checksum": "0115fa9eefb5d1d11440455f5460babe",
     "grade": false,
     "grade_id": "cell-e96ca63d0ccacaf4",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "source": [
    "Let us try out some of the operations from the list. They are pretty similar to the NumPy API."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "markdown",
     "checksum": "4dc3b4f6bb8c31e810c70a2ee180c89b",
     "grade": false,
     "grade_id": "cell-79f659ce1e13fda7",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "source": [
    "**Standard numpy-like indexing and slicing:**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-11-09T19:59:52.889292Z",
     "start_time": "2021-11-09T19:59:52.883071Z"
    },
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "27670eb419578cd89154f9d8d942fd13",
     "grade": false,
     "grade_id": "cell-68254433d58dfef9",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "tensor([[ 0.,  1.,  2.,  3.],\n",
      "        [ 4.,  5.,  6.,  7.],\n",
      "        [ 8.,  9., 10., 11.]])\n",
      "First row:  tensor([0., 1., 2., 3.])\n",
      "First column:  tensor([0., 4., 8.])\n",
      "Last column: tensor([ 3.,  7., 11.])\n"
     ]
    }
   ],
   "source": [
    "tensor = torch.arange(12).reshape(3, 4).float()\n",
    "print(tensor)\n",
    "print('First row: ',tensor[0])\n",
    "print('First column: ', tensor[:, 0])\n",
    "print('Last column:', tensor[:, -1])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "markdown",
     "checksum": "9bf20b4a386a1ede2ba268a8c61ab940",
     "grade": false,
     "grade_id": "cell-07fe46d6a751454b",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "source": [
    "**Joining tensors** \n",
    "\n",
    "You can use ``torch.cat`` to concatenate a sequence of tensors along a given dimension.\n",
    "See also [`torch.stack`](https://pytorch.org/docs/stable/generated/torch.stack.html),\n",
    "another tensor joining op that is subtly different from ``torch.cat``.\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-11-09T19:59:52.894432Z",
     "start_time": "2021-11-09T19:59:52.890861Z"
    },
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "804fe5871c972fef2865361d99b3217c",
     "grade": false,
     "grade_id": "cell-8436764a1dd93dc7",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "tensor([[ 0.,  1.,  2.,  3.,  0.,  1.,  2.,  3.,  0.,  1.,  2.,  3.],\n",
      "        [ 4.,  5.,  6.,  7.,  4.,  5.,  6.,  7.,  4.,  5.,  6.,  7.],\n",
      "        [ 8.,  9., 10., 11.,  8.,  9., 10., 11.,  8.,  9., 10., 11.]])\n"
     ]
    }
   ],
   "source": [
    "t1 = torch.cat([tensor, tensor, tensor], dim=1)\n",
    "print(t1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "markdown",
     "checksum": "b12186a7d48bc1a79d835fb1c1e5f97e",
     "grade": false,
     "grade_id": "cell-70ab95dd8071897a",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "source": [
    "**Arithmetic operations**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-11-09T19:59:52.902039Z",
     "start_time": "2021-11-09T19:59:52.896106Z"
    },
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "c63e7fa1111d6e43fe822182db67f8ec",
     "grade": false,
     "grade_id": "cell-17ade2df712e21e6",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "tensor([[ 14.,  38.,  62.],\n",
      "        [ 38., 126., 214.],\n",
      "        [ 62., 214., 366.]])\n",
      "tensor([[ 14.,  38.,  62.],\n",
      "        [ 38., 126., 214.],\n",
      "        [ 62., 214., 366.]])\n",
      "tensor([[ 14.,  38.,  62.],\n",
      "        [ 38., 126., 214.],\n",
      "        [ 62., 214., 366.]])\n"
     ]
    }
   ],
   "source": [
    "# This computes the matrix multiplication between two tensors. y1, y2, y3 will have the same value\n",
    "y1 = tensor @ tensor.T\n",
    "print(y1)\n",
    "y2 = tensor.matmul(tensor.T)\n",
    "print(y2)\n",
    "y3 = torch.rand_like(tensor)\n",
    "torch.matmul(tensor, tensor.T, out=y3)\n",
    "print(y3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-11-09T19:59:52.908790Z",
     "start_time": "2021-11-09T19:59:52.903624Z"
    },
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "6974f540d18fb1e42492acd33b3a9b5c",
     "grade": false,
     "grade_id": "cell-a119420de324266c",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "tensor([[  0.,   1.,   4.,   9.],\n",
      "        [ 16.,  25.,  36.,  49.],\n",
      "        [ 64.,  81., 100., 121.]])\n",
      "tensor([[  0.,   1.,   4.,   9.],\n",
      "        [ 16.,  25.,  36.,  49.],\n",
      "        [ 64.,  81., 100., 121.]])\n",
      "tensor([[  0.,   1.,   4.,   9.],\n",
      "        [ 16.,  25.,  36.,  49.],\n",
      "        [ 64.,  81., 100., 121.]])\n"
     ]
    }
   ],
   "source": [
    "# This computes the element-wise product. z1, z2, z3 will have the same value\n",
    "z1 = tensor * tensor\n",
    "print(z1)\n",
    "z2 = tensor.mul(tensor)\n",
    "print(z2)\n",
    "z3 = torch.rand_like(tensor)\n",
    "torch.mul(tensor, tensor, out=z3)\n",
    "print(z3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-06-04T10:52:36.043345Z",
     "start_time": "2021-06-04T10:52:36.039305Z"
    },
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "markdown",
     "checksum": "82040cf6f62c339db1c08cdb9fb7d97c",
     "grade": false,
     "grade_id": "cell-ee43563ec55838ed",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "source": [
    "**Single-element tensors** \n",
    "\n",
    "If you have a one-element tensor, for example by aggregating all\n",
    "values of a tensor into one value, you can convert it to a Python\n",
    "numerical value using ``item()``:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-11-09T19:59:52.912965Z",
     "start_time": "2021-11-09T19:59:52.910269Z"
    },
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "e95651812e9d9df69e9b56d0d366efa8",
     "grade": false,
     "grade_id": "cell-d398db15eb46f650",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "66.0 <class 'float'>\n"
     ]
    }
   ],
   "source": [
    "agg = tensor.sum()\n",
    "agg_item = agg.item()  \n",
    "print(agg_item, type(agg_item))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "markdown",
     "checksum": "b648e27cde024b597ebb95528fd89e47",
     "grade": false,
     "grade_id": "cell-ad4c08ac5cb16f59",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "source": [
    "### 1.4 GPU Acceleration\n",
    "\n",
    "If we have NVIDIA GPU(s), we can accelerate computation once we move Tensors onto GPU.\n",
    "Let's compare how much GPU can accelerate especially matrix operations.\n",
    "We will do a matrix-matrix multiplication between two 5k-by-5k matrices on both CPU and GPU.\n",
    "\n",
    "Unfortunately, Coursera does not have a GPU environment. But feel free to try the following snippets on a GPU machine. Ideally, with GPU acceleration, matrix multiplication will be much faster."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-11-09T19:59:53.064705Z",
     "start_time": "2021-11-09T19:59:52.914547Z"
    },
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "9e62482cd8575e2e93b0582038b96841",
     "grade": false,
     "grade_id": "cell-4a444edeeb9268a9",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tensor([[0.7886, 0.5895, 0.7539,  ..., 0.9313, 0.6453, 0.9844],\n",
       "        [0.8312, 0.8682, 0.9359,  ..., 0.4046, 0.9987, 0.8608],\n",
       "        [0.1268, 0.2253, 0.1223,  ..., 0.3939, 0.4493, 0.5327],\n",
       "        ...,\n",
       "        [0.5851, 0.5824, 0.8857,  ..., 0.3165, 0.4845, 0.3896],\n",
       "        [0.3348, 0.1535, 0.5840,  ..., 0.0285, 0.7444, 0.5193],\n",
       "        [0.4027, 0.7190, 0.3847,  ..., 0.9606, 0.6629, 0.0359]])"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mat = torch.rand(5000, 5000)\n",
    "mat"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-11-09T19:59:53.619739Z",
     "start_time": "2021-11-09T19:59:53.066447Z"
    },
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "4b3a80ee483007acd54cd3b012c53f5f",
     "grade": false,
     "grade_id": "cell-3fd0c22a92e541e3",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "CPU times: user 1.79 s, sys: 75.6 ms, total: 1.86 s\n",
      "Wall time: 935 ms\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "tensor([[1697.6149, 1260.7888, 1260.5797,  ..., 1276.7963, 1265.4302,\n",
       "         1273.4852],\n",
       "        [1260.7888, 1655.7581, 1247.6843,  ..., 1256.2366, 1263.6820,\n",
       "         1263.9420],\n",
       "        [1260.5797, 1247.6843, 1658.2701,  ..., 1258.1453, 1267.2046,\n",
       "         1274.8799],\n",
       "        ...,\n",
       "        [1276.7963, 1256.2366, 1258.1453,  ..., 1704.4203, 1270.7225,\n",
       "         1275.9521],\n",
       "        [1265.4302, 1263.6820, 1267.2046,  ..., 1270.7225, 1686.0028,\n",
       "         1272.0708],\n",
       "        [1273.4852, 1263.9420, 1274.8799,  ..., 1275.9521, 1272.0708,\n",
       "         1699.9993]])"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "%%time\n",
    "torch.mm(mat.t(), mat)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-11-09T19:59:53.624524Z",
     "start_time": "2021-11-09T19:59:53.621511Z"
    },
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "b4763761e1069ee61e30ea187629ff02",
     "grade": false,
     "grade_id": "cell-cba286fd4075d893",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "GPU is not available!\n",
      "CPU times: user 331 µs, sys: 0 ns, total: 331 µs\n",
      "Wall time: 247 µs\n"
     ]
    }
   ],
   "source": [
    "%%time\n",
    "if torch.cuda.is_available():\n",
    "    mat = mat.cuda()\n",
    "    torch.mm(mat.t(), mat)\n",
    "else:\n",
    "    print('GPU is not available!')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "markdown",
     "checksum": "dc18412bf74237429ce30f815793755b",
     "grade": false,
     "grade_id": "cell-76b1139eccd0ed58",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "source": [
    "### Exercise 1 [10 points]\n",
    "\n",
    "Implement the Sigmoid function on your own.\n",
    "\n",
    "$$\\sigma(x) = \\frac{1}{1 + \\exp(-x)}$$\n",
    "\n",
    "Note that you should not use existing PyTorch implementation.\n",
    "\n",
    "Hint: try `torch.exp()`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-11-09T19:59:53.628821Z",
     "start_time": "2021-11-09T19:59:53.626556Z"
    },
    "deletable": false
   },
   "outputs": [],
   "source": [
    "def sigmoid(x):\n",
    "    # your code here\n",
    "    return 1/(1+torch.exp(-x));"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-11-09T19:59:53.635026Z",
     "start_time": "2021-11-09T19:59:53.631133Z"
    },
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "73c93decc465fa69d9fc774e746b0261",
     "grade": true,
     "grade_id": "cell-61532367e8d33755",
     "locked": true,
     "points": 10,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "outputs": [],
   "source": [
    "'''\n",
    "AUTOGRADER CELL. DO NOT MODIFY THIS.\n",
    "'''\n",
    "\n",
    "assert torch.allclose(sigmoid(torch.tensor([1.2])), torch.tensor([0.7685]), rtol=1e-2)\n",
    "assert torch.allclose(sigmoid(torch.tensor([0, 1.5])), torch.tensor([0.5000, 0.8176]), rtol=1e-2)\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-06-06T04:38:56.061939Z",
     "start_time": "2021-06-06T04:38:56.056875Z"
    }
   },
   "source": [
    "### Exercise 2 [10 points]\n",
    "\n",
    "Implement a Softmax function on your own.\n",
    "\n",
    "$$\\mathrm{softmax}(\\mathbf{X})_{ij} = \\frac{\\exp(\\mathbf{X}_{ij})}{\\sum_k \\exp(\\mathbf{X}_{ik})}$$\n",
    "\n",
    "Note that you should not use existing PyTorch implementation.\n",
    "\n",
    "Hint: try `torch.exp()` and `torch.sum()`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-11-09T19:59:53.643476Z",
     "start_time": "2021-11-09T19:59:53.640913Z"
    },
    "deletable": false
   },
   "outputs": [],
   "source": [
    "def softmax(X):\n",
    "    # your code here\n",
    "    return torch.exp(X)/torch.sum(torch.exp(X), dim = 1, keepdim=True);"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-11-09T19:59:53.650574Z",
     "start_time": "2021-11-09T19:59:53.647263Z"
    },
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "a12bf676b0a1039fff4e8e1dc4b02e01",
     "grade": true,
     "grade_id": "cell-1180d5dc773f6ff4",
     "locked": true,
     "points": 10,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "outputs": [],
   "source": [
    "'''\n",
    "AUTOGRADER CELL. DO NOT MODIFY THIS.\n",
    "'''\n",
    "\n",
    "X = torch.tensor([[0.2288, 0.4111, 0.0385], [0.6233, 0.0364, 0.1999]])\n",
    "assert torch.allclose(softmax(X), torch.tensor([[0.3304, 0.3965, 0.2731], [0.4523, 0.2515, 0.2962]]), rtol=1e-2)\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exercise 3 [10 points]\n",
    "\n",
    "Implement a linear layer.\n",
    "\n",
    "$$\\mathbf{O} = \\mathbf{X}\\mathbf{W} + \\mathbf{b},$$\n",
    "\n",
    "where $\\mathbf{X}$ is the input feature, $\\mathbf{O}$ is the output feature, $\\mathbf{W}$ and $\\mathbf{b}$ are the weight parameters.\n",
    "\n",
    "Hint: try `torch.matmul()`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-11-09T19:59:53.654881Z",
     "start_time": "2021-11-09T19:59:53.652412Z"
    },
    "deletable": false
   },
   "outputs": [],
   "source": [
    "def linear(X, W, b):\n",
    "    return X@W + b;"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-11-09T19:59:53.661152Z",
     "start_time": "2021-11-09T19:59:53.657104Z"
    },
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "9b4d48b4c1d9f69fc5a3d4146cd9afb8",
     "grade": true,
     "grade_id": "cell-dd9b62c1e826a245",
     "locked": true,
     "points": 10,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "outputs": [],
   "source": [
    "'''\n",
    "AUTOGRADER CELL. DO NOT MODIFY THIS.\n",
    "'''\n",
    "\n",
    "X = torch.Tensor([[0.1, 0.2, 0.3]])\n",
    "W = torch.Tensor([[0.1, 0.2, 0.3]]).T\n",
    "b = torch.Tensor([-0.5])\n",
    "assert torch.allclose(linear(X, W, b), torch.Tensor([[-0.3600]]), rtol=1e-2)\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "markdown",
     "checksum": "c10ec179a54a63dd1e620a09940dff8e",
     "grade": false,
     "grade_id": "cell-c4a2c15a6a98abf0",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "source": [
    "## 2. Loss\n",
    "\n",
    "When presented with some training data, our untrained network is likely not to give the correct answer. Loss function measures the degree of dissimilarity of obtained result to the target value, and it is the loss function that we want to minimize during training. To calculate the loss we make a prediction using the inputs of our given data sample and compare it against the true data label value."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "markdown",
     "checksum": "ccc9aecfe0e75fcaa0601e05038cf1c7",
     "grade": false,
     "grade_id": "cell-3c98f0acdf811685",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "source": [
    "Common loss functions include `nn.MSELoss` (Mean Square Error) for regression tasks, and `nn.NLLLoss` (Negative Log Likelihood) for classification. `nn.CrossEntropyLoss` combines `nn.LogSoftmax` and `nn.NLLLoss`. `nn.BCELoss` is specially designed for binary classification."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "markdown",
     "checksum": "bcedcd02ba0d289891ba2accd04ca62e",
     "grade": false,
     "grade_id": "cell-3634cc3d539441c2",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "source": [
    "**Mean Square Error**\n",
    "\n",
    "The most popular loss function in regression problems is the squared error. When our prediction for an example $i$ is $\\hat{y}^{(i)}$ and the corresponding true label is ${y}^{(i)}$, the squared error is given by:\n",
    "\n",
    "$$l^{(i)} = \\frac{1}{2} \\left(\\hat{y}^{(i)} - y^{(i)}\\right)^2.$$\n",
    "\n",
    "To measure the quality of a model on the entire dataset of $n$ examples, we simply average (or equivalently, sum) the losses on the training set.\n",
    "\n",
    "$$L =\\frac{1}{n}\\sum_{i=1}^n l^{(i)}.$$\n",
    "\n",
    "Let us see how to implement this."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-11-09T19:59:53.665878Z",
     "start_time": "2021-11-09T19:59:53.663104Z"
    },
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "1d263f5353eca3791687c4edfbb38554",
     "grade": false,
     "grade_id": "cell-1df21ca45d9d5c67",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "outputs": [],
   "source": [
    "def squared_loss(y_hat, y):\n",
    "    return ((y_hat - y.reshape(y_hat.shape)) ** 2 / 2).mean()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-11-09T19:59:53.672639Z",
     "start_time": "2021-11-09T19:59:53.667991Z"
    },
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "9431b23a3b8b17ca865a0a3002d1f80c",
     "grade": false,
     "grade_id": "cell-7c1fcabfc2ba5a9c",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tensor(0.0550)"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "y_hat = torch.tensor([0.5, 0.8, 0.2])\n",
    "y = torch.tensor([1.0, 1.0, 0.0])\n",
    "squared_loss(y_hat, y)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "markdown",
     "checksum": "06ebc855353f3068ef9fb75a914d4980",
     "grade": false,
     "grade_id": "cell-1cabefeec5e1cf70",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "source": [
    "### Exercise 4 [10 points]\n",
    "\n",
    "Implement the cross-entropy loss function on your own.\n",
    "\n",
    "$$l^{(i)} = - \\sum_{j=1}^q y_j^{(i)} \\log \\hat{y}_j^{(i)},$$\n",
    "\n",
    "$$L =\\frac{1}{n}\\sum_{i=1}^n l^{(i)}.$$\n",
    "\n",
    "where $\\mathbf{y}^{(i)}$ is a one-hot vector of length $q$, the sum over all its coordinates $j$ vanishes for all but one term.\n",
    "\n",
    "Note that you should not use existing PyTorch implementation.\n",
    "\n",
    "Hint: try `torch.log()`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-11-09T19:59:53.676849Z",
     "start_time": "2021-11-09T19:59:53.674726Z"
    },
    "deletable": false
   },
   "outputs": [],
   "source": [
    "def cross_entropy(y_hat, y):\n",
    "    return (-torch.sum((y * torch.log(y_hat)), dim=1, keepdim=True)).mean()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-11-09T19:59:53.682470Z",
     "start_time": "2021-11-09T19:59:53.678810Z"
    },
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "12f4d9e1cad788bb8e3be9ba16e85017",
     "grade": true,
     "grade_id": "cell-c6fed73a25633029",
     "locked": true,
     "points": 10,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "outputs": [],
   "source": [
    "'''\n",
    "AUTOGRADER CELL. DO NOT MODIFY THIS.\n",
    "'''\n",
    "\n",
    "y = torch.tensor([[1, 0, 0], [0, 0, 1]])\n",
    "y_hat = torch.tensor([[0.1, 0.3, 0.6], [0.3, 0.2, 0.5]])\n",
    "assert torch.allclose(cross_entropy(y_hat, y), torch.tensor([1.4979]), rtol=1e-2)\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "markdown",
     "checksum": "bfb88b78b06ad42c14a5d0f820f88120",
     "grade": false,
     "grade_id": "cell-d2696116d62fd7ca",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "source": [
    "## 3. Autograd\n",
    "\n",
    "When training the model, we want to find parameters (denoted as $\\Theta$) that minimize the total loss across all training examples:\n",
    "\n",
    "$$\\Theta = \\operatorname*{argmin}_{\\Theta}\\  L(\\Theta).$$\n",
    "\n",
    "To do this, we will iteratively reduce the error by updating the parameters in the direction that incrementally lowers the loss function. This algorithm is called gradient descent. The most naive application of gradient descent consists of taking the derivative of the loss function. Let us see how to do this."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "markdown",
     "checksum": "683eed99a46e6950597f646f7d7f0542",
     "grade": false,
     "grade_id": "cell-205d28575317a39c",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "source": [
    "As a toy example, say that we are interested in differentiating the function $y = 2 \\mathbf{x}^\\top \\mathbf{x}$ with respect to the column vector $\\mathbf{x}$. To start, let us create the variable x and assign it an initial value."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-11-09T19:59:53.688440Z",
     "start_time": "2021-11-09T19:59:53.684498Z"
    },
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "831b87d6ad6c21d671885c9b59d4052f",
     "grade": false,
     "grade_id": "cell-a94c031cf67afb4f",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tensor([0., 1., 2., 3.])"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x = torch.arange(4.0)\n",
    "x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-11-09T19:59:53.692926Z",
     "start_time": "2021-11-09T19:59:53.690413Z"
    },
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "9ba41fc51c935748a491e81afe5a9cb5",
     "grade": false,
     "grade_id": "cell-9343288efcab2ee8",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "outputs": [],
   "source": [
    "x.requires_grad_(True)  # Same as `x = torch.arange(4.0, requires_grad=True)`\n",
    "x.grad  # The default value is None"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "markdown",
     "checksum": "38a03324937b683b75c932eda2830925",
     "grade": false,
     "grade_id": "cell-8f9fe71daeddcdaa",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "source": [
    "Now let us calculate $y$."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-11-09T19:59:53.699730Z",
     "start_time": "2021-11-09T19:59:53.695285Z"
    },
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "190120bc8195216af556bea10a61d2ba",
     "grade": false,
     "grade_id": "cell-962c853218ef8a99",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tensor(28., grad_fn=<MulBackward0>)"
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "y = 2 * torch.dot(x, x)\n",
    "y"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "markdown",
     "checksum": "894f7a758ee313a5b86f56c1d69069f2",
     "grade": false,
     "grade_id": "cell-5dd01161ebcf0e5d",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "source": [
    "Since $\\mathbf{x}$ is a vector of length 4, an inner product of $\\mathbf{x}$ and $\\mathbf{x}$ is performed, yielding the scalar output that we assign to $y$. Next, we can automatically calculate the gradient of $y$ with respect to each component of $\\mathbf{x}$ by calling the function for backpropagation and printing the gradient."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-11-09T19:59:53.706397Z",
     "start_time": "2021-11-09T19:59:53.701945Z"
    },
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "590e79a7c90c813eecfa9514a7b7b916",
     "grade": false,
     "grade_id": "cell-d69f7e1a6b657229",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tensor([ 0.,  4.,  8., 12.])"
      ]
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "y.backward()\n",
    "x.grad"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "markdown",
     "checksum": "b98732384eb41e2190df66b086679f0c",
     "grade": false,
     "grade_id": "cell-c9f74064d0da6335",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "source": [
    "The gradient of the function $y = 2\\mathbf{x}^{\\top}\\mathbf{x}$ with respect to $\\mathbf{x}$ should be $4\\mathbf{x}$. Let us quickly verify that our desired gradient was calculated correctly."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-11-09T19:59:53.712706Z",
     "start_time": "2021-11-09T19:59:53.708310Z"
    },
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "98eeddff71971aa7e9d3139bbbf610c1",
     "grade": false,
     "grade_id": "cell-9ecb119a6399614b",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tensor([True, True, True, True])"
      ]
     },
     "execution_count": 32,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x.grad == 4 * x"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "markdown",
     "checksum": "666297b89310b1dd925c3dff70abd221",
     "grade": false,
     "grade_id": "cell-0a368433383bc78c",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "source": [
    "### Exercise 5 [10 points]\n",
    "\n",
    "Let  $f(x) = \\sin(x)$. Plot $f(x)$ and and $\\frac{df(x)}{dx}$, where the latter is computed without exploiting that $f'(x) = \\cos(x)$."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-11-09T19:59:53.904887Z",
     "start_time": "2021-11-09T19:59:53.714715Z"
    },
    "deletable": false
   },
   "outputs": [],
   "source": [
    "x = np.linspace(-np.pi, np.pi, 100)\n",
    "x = torch.tensor(x, requires_grad=True)\n",
    "y = torch.sin(x)\n",
    "\n",
    "y.sum().backward()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-11-09T19:59:53.910186Z",
     "start_time": "2021-11-09T19:59:53.907139Z"
    },
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "1f269cdf3eec73dc8cc5677f149ae164",
     "grade": true,
     "grade_id": "cell-cd0a5df68eb0bdde",
     "locked": true,
     "points": 10,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "outputs": [],
   "source": [
    "'''\n",
    "AUTOGRADER CELL. DO NOT MODIFY THIS.\n",
    "'''\n",
    "\n",
    "assert torch.allclose(x.grad[10].float(), torch.Tensor([-0.8053]), rtol=1e-2)\n",
    "assert torch.allclose(x.grad[50].float(), torch.Tensor([0.9995]), rtol=1e-2)\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "markdown",
     "checksum": "b11b0661947ed8e109c225e96ceeea99",
     "grade": false,
     "grade_id": "cell-85c2cf25d4fba682",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "source": [
    "## Assignment [50 points]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "markdown",
     "checksum": "1b35a9f46a60db8bd30c264b5d9db957",
     "grade": false,
     "grade_id": "cell-b4a75a8b976d4aaf",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "source": [
    "Now, you understand the basics of PyTorch. Let us implement an entire method from scratch, including the data pipeline, the linear model, the loss function, and the gradient descent optimizer. While modern deep learning frameworks can automate nearly all of this work, implementing things from scratch is the only way to make sure that you really know what you are doing. Moreover, when it comes time to customize models, defining our own layers or loss functions, understanding how things work under the hood will prove handy. In this section, we will rely only on tensors and auto differentiation. Afterwards, we will introduce a more concise implementation, taking advantage of bells and whistles of deep learning frameworks."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "markdown",
     "checksum": "b9a10ff3eed9d4d86486552f7eb8d521",
     "grade": false,
     "grade_id": "cell-23a60381928f9e78",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "source": [
    "To keep things simple, we will construct an artificial dataset according to a linear model with additive noise. Our task will be to recover this model’s parameters using the finite set of examples contained in our dataset. We will keep the data low-dimensional so we can visualize it easily. In the following code snippet, we generate a dataset containing 1000 examples, each consisting of 2 features sampled from a standard normal distribution. Thus our synthetic dataset will be a matrix  $\\mathbf{X} \\in \\mathbb{R}^{1000 \\times 2}$.\n",
    "\n",
    "The true parameters generating our dataset will be $\\mathbf{w} = [2, -3.4]^\\top$ and  $b = 4.2$, and our synthetic labels will be assigned according to the following linear model with the noise term $\\epsilon$:\n",
    "$$\\mathbf{y}= \\mathbf{X} \\mathbf{w} + b + \\mathbf\\epsilon.$$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-11-09T19:59:53.915810Z",
     "start_time": "2021-11-09T19:59:53.911988Z"
    },
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "eafb54534edc50b5f60ad281bd7905cc",
     "grade": false,
     "grade_id": "cell-ba81e3393eb6f13c",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "outputs": [],
   "source": [
    "def synthetic_data(w, b, num_examples):\n",
    "    \"\"\"Generate y = Xw + b + noise.\"\"\"\n",
    "    X = torch.normal(0, 1, (num_examples, len(w)))\n",
    "    y = torch.matmul(X, w) + b\n",
    "    y += torch.normal(0, 0.01, y.shape)\n",
    "    return X, y.reshape((-1, 1))\n",
    "\n",
    "true_w = torch.tensor([2, -3.4])\n",
    "true_b = 4.2\n",
    "features, labels = synthetic_data(true_w, true_b, 1000)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-11-09T19:59:53.921422Z",
     "start_time": "2021-11-09T19:59:53.917405Z"
    },
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "eaaa5b43b7df88198948cc2af18b2a55",
     "grade": false,
     "grade_id": "cell-f30d23919c1bc1f4",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "features: tensor([-2.0928, -0.6196]) \n",
      "label: tensor([2.1172])\n"
     ]
    }
   ],
   "source": [
    "print('features:', features[0], '\\nlabel:', labels[0])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "markdown",
     "checksum": "b64abf8de56dce8792e40c54623f330c",
     "grade": false,
     "grade_id": "cell-ff3a9ba26f232db9",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "source": [
    "### Reading the Dataset\n",
    "\n",
    "Recall that training models consists of making multiple passes over the dataset, grabbing one minibatch of examples at a time, and using them to update our model. Since this process is so fundamental to training machine learning algorithms, it is worth defining a utility function to shuffle the dataset and access it in minibatches.\n",
    "\n",
    "In the following code, we define the `data_iter` function to demonstrate one possible implementation of this functionality. The function takes a batch size, a matrix of features, and a vector of labels, yielding minibatches of the size batch_size. Each minibatch consists of a tuple of features and labels."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-11-09T19:59:53.926672Z",
     "start_time": "2021-11-09T19:59:53.923342Z"
    },
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "7174ddcb46bd3dde2a46f2e6a4c805b0",
     "grade": false,
     "grade_id": "cell-62ff69e249c9f591",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "outputs": [],
   "source": [
    "def data_iter(batch_size, features, labels):\n",
    "    num_examples = len(features)\n",
    "    indices = list(range(num_examples))\n",
    "    # The examples are read at random, in no particular order\n",
    "    random.shuffle(indices)\n",
    "    for i in range(0, num_examples, batch_size):\n",
    "        batch_indices = torch.tensor(indices[i:min(i + batch_size, num_examples)])\n",
    "        yield features[batch_indices], labels[batch_indices]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "markdown",
     "checksum": "723d6edc8c2290eab86d5db0bae4b4cc",
     "grade": false,
     "grade_id": "cell-e9a6a7834942b2ad",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "source": [
    "In general, note that we want to use reasonably sized minibatches to take advantage of the GPU hardware, which excels at parallelizing operations. Because each example can be fed through our models in parallel and the gradient of the loss function for each example can also be taken in parallel, GPUs allow us to process hundreds of examples in scarcely more time than it might take to process just a single example.\n",
    "\n",
    "To build some intuition, let us read and print the first small batch of data examples. The shape of the features in each minibatch tells us both the minibatch size and the number of input features. Likewise, our minibatch of labels will have a shape given by batch_size."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-11-09T19:59:53.932958Z",
     "start_time": "2021-11-09T19:59:53.928327Z"
    },
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "5db45991e3570242e92bc0985ace3250",
     "grade": false,
     "grade_id": "cell-07e5479f42cdbff4",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "tensor([[ 0.3328, -0.7500],\n",
      "        [-0.6873, -2.1948],\n",
      "        [ 1.1267,  0.1299],\n",
      "        [-0.8927,  0.8648],\n",
      "        [ 1.7361, -0.1677],\n",
      "        [-0.9680,  1.9231],\n",
      "        [ 1.0110,  0.3615],\n",
      "        [-0.2814,  0.4892],\n",
      "        [ 0.6248, -0.9218],\n",
      "        [ 0.2559, -0.4386]]) \n",
      " tensor([[ 7.4254],\n",
      "        [10.2802],\n",
      "        [ 6.0074],\n",
      "        [-0.5244],\n",
      "        [ 8.2466],\n",
      "        [-4.2738],\n",
      "        [ 4.9697],\n",
      "        [ 1.9719],\n",
      "        [ 8.5883],\n",
      "        [ 6.2239]])\n"
     ]
    }
   ],
   "source": [
    "batch_size = 10\n",
    "\n",
    "for X, y in data_iter(batch_size, features, labels):\n",
    "    print(X, '\\n', y)\n",
    "    break"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "markdown",
     "checksum": "61ba9fba2d0b02868875ce1b7ab0f8a2",
     "grade": false,
     "grade_id": "cell-e1249e2768b4a70b",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "source": [
    "As we run the iteration, we obtain distinct minibatches successively until the entire dataset has been exhausted (try this). While the iteration implemented above is good for didactic purposes, it is inefficient in ways that might get us in trouble on real problems. For example, it requires that we load all the data in memory and that we perform lots of random memory access. The built-in iterators implemented in a deep learning framework are considerably more efficient and they can deal with both data stored in files and data fed via data streams."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "markdown",
     "checksum": "04f16441b25d0c7c21425a3c3c10ed43",
     "grade": false,
     "grade_id": "cell-8a4bb6bb84c24d82",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "source": [
    "### Initializing Model Parameters [10 points]\n",
    "\n",
    "Before we can begin optimizing our model’s parameters by minibatch stochastic gradient descent, we need to have some parameters in the first place. In the following code, we initialize weights by sampling random numbers from a normal distribution with mean 0 and a standard deviation of 0.01, and setting the bias to 0."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-11-09T19:59:53.936969Z",
     "start_time": "2021-11-09T19:59:53.934449Z"
    },
    "deletable": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tensor(4.2000, requires_grad=True)"
      ]
     },
     "execution_count": 66,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "w = None\n",
    "b = None\n",
    "\n",
    "w = torch.tensor([2,-3.4])\n",
    "b = torch.tensor(4.2)\n",
    "\n",
    "w.requires_grad_(True)\n",
    "b.requires_grad_(True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-11-09T19:59:53.942141Z",
     "start_time": "2021-11-09T19:59:53.939098Z"
    },
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "f478d9b29249623cfa6a66c6720fcff9",
     "grade": true,
     "grade_id": "cell-ce0ca0f090c01ba9",
     "locked": true,
     "points": 10,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "outputs": [],
   "source": [
    "'''\n",
    "AUTOGRADER CELL. DO NOT MODIFY THIS.\n",
    "'''\n",
    "\n",
    "assert type(w) is torch.Tensor\n",
    "assert type(b) is torch.Tensor\n",
    "assert w.requires_grad\n",
    "assert b.requires_grad\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-06-06T07:51:46.589522Z",
     "start_time": "2021-06-06T07:51:46.586432Z"
    },
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "markdown",
     "checksum": "fcaab39d8614129a614e410c39aa75cf",
     "grade": false,
     "grade_id": "cell-615d1fb813fa002a",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "source": [
    "### Defining the Model [10 points]\n",
    "\n",
    "Next, we must define our model, relating its inputs and parameters to its outputs. Recall that to calculate the output of the linear model, we simply take the matrix-vector dot product of the input features $\\mathbf{x}$ and the model weights $\\mathbf{w}$ , and add the offset $b$ to each example.\n",
    "\n",
    "This is exactly the same as what we implemented in Exercise 3."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-11-09T19:59:53.946691Z",
     "start_time": "2021-11-09T19:59:53.944101Z"
    },
    "deletable": false
   },
   "outputs": [],
   "source": [
    "def linear(X, W, b):\n",
    "    return X@W+b"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 76,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-11-09T19:59:53.952489Z",
     "start_time": "2021-11-09T19:59:53.948582Z"
    },
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "30c488519d52ee094de4ce5f15452ec3",
     "grade": true,
     "grade_id": "cell-64c3079cc937f819",
     "locked": true,
     "points": 10,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "outputs": [],
   "source": [
    "'''\n",
    "AUTOGRADER CELL. DO NOT MODIFY THIS.\n",
    "'''\n",
    "\n",
    "X_ = torch.Tensor([[0.1, 0.2, 0.3]])\n",
    "W_ = torch.Tensor([[0.1, 0.2, 0.3]]).T\n",
    "b_ = torch.Tensor([-0.5])\n",
    "assert torch.allclose(linear(X_, W_, b_), torch.Tensor([[-0.3600]]), rtol=1e-2)\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "markdown",
     "checksum": "596694b9faa75514f1c038f7ff8bfa38",
     "grade": false,
     "grade_id": "cell-9a215192ecde9028",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "source": [
    "### Defining the Loss Function [10 points]\n",
    "\n",
    "Since updating our model requires taking the gradient of our loss function, we ought to define the loss function first. Here we will use the squared loss function."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 77,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-11-09T19:59:53.957811Z",
     "start_time": "2021-11-09T19:59:53.954638Z"
    },
    "deletable": false
   },
   "outputs": [],
   "source": [
    "def squared_loss(y_hat, y):\n",
    "    return ((y_hat - y.reshape(y_hat.shape)) ** 2 / 2).mean()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 78,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-11-09T19:59:53.963766Z",
     "start_time": "2021-11-09T19:59:53.959848Z"
    },
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "5ea08d374ccf94632a06bf43e9ca6198",
     "grade": true,
     "grade_id": "cell-c736aba0ee97c23a",
     "locked": true,
     "points": 10,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "outputs": [],
   "source": [
    "'''\n",
    "AUTOGRADER CELL. DO NOT MODIFY THIS.\n",
    "'''\n",
    "\n",
    "y = torch.tensor([2, 0.4, 1.1, 2.1])\n",
    "y_hat = torch.tensor([[2.1, 0.3, 1.2, 2.5]])\n",
    "assert torch.allclose(squared_loss(y_hat, y), torch.tensor([0.0238]), rtol=1e-2)\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "markdown",
     "checksum": "6206504a7d0da08b5515310a3b285534",
     "grade": false,
     "grade_id": "cell-6cfd21d340b940b9",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "source": [
    "### Defining the Optimization Algorithm [10 points]\n",
    "\n",
    "Though linear regression has a closed-form solution, we will take this opportunity to introduce your first working example of minibatch stochastic gradient descent.\n",
    "\n",
    "At each step, using one minibatch randomly drawn from our dataset, we will estimate the gradient of the loss with respect to our parameters. Next, we will update our parameters in the direction that may reduce the loss. The following code applies the minibatch stochastic gradient descent update, given a set of parameters, a learning rate, and a batch size. The size of the update step is determined by the learning rate lr. Because our loss is calculated as a sum over the minibatch of examples, we normalize our step size by the batch size (batch_size), so that the magnitude of a typical step size does not depend heavily on our choice of the batch size."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 109,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-11-09T19:59:53.968307Z",
     "start_time": "2021-11-09T19:59:53.965629Z"
    },
    "deletable": false
   },
   "outputs": [],
   "source": [
    "def sgd(params, lr, batch_size):\n",
    "    \"\"\"  Minibatch stochastic gradient descent \"\"\"\n",
    "    lr = lr / batch_size\n",
    "    with torch.no_grad():\n",
    "        for param in params:\n",
    "            \"\"\"\n",
    "            TODO: perform a step gradient descent \n",
    "                  param = param - lr * grad\n",
    "            \"\"\"\n",
    "            param.sub_(lr * param.grad)\n",
    "            param.grad.zero_()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 110,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-11-09T19:59:53.974039Z",
     "start_time": "2021-11-09T19:59:53.970317Z"
    },
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "3194a739ec2f40960d06c5b3826719ed",
     "grade": true,
     "grade_id": "cell-fc34af6a3ad58767",
     "locked": true,
     "points": 10,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "outputs": [],
   "source": [
    "'''\n",
    "AUTOGRADER CELL. DO NOT MODIFY THIS.\n",
    "'''\n",
    "\n",
    "m = torch.ones(1, requires_grad=True)\n",
    "n = 2 * m\n",
    "n.backward()\n",
    "sgd([m], lr=0.1, batch_size=1)\n",
    "assert torch.allclose(m, torch.tensor([0.8000]), rtol=1e-2)\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "markdown",
     "checksum": "17670b2bf4bdadb6fba07d4d0a2ab68e",
     "grade": false,
     "grade_id": "cell-b1f4936a88b7fc46",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "source": [
    "### Training [10 points]\n",
    "\n",
    "Now that we have all of the parts in place, we are ready to implement the main training loop. It is crucial that you understand this code because you will see nearly identical training loops over and over again throughout your career in deep learning.\n",
    "\n",
    "In each iteration, we will grab a minibatch of training examples, and pass them through our model to obtain a set of predictions. After calculating the loss, we initiate the backwards pass through the network, storing the gradients with respect to each parameter. Finally, we will call the optimization algorithm sgd to update the model parameters.\n",
    "\n",
    "In summary, we will execute the following loop:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 111,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-11-09T19:59:54.493522Z",
     "start_time": "2021-11-09T19:59:53.975739Z"
    },
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "5fea51198b0914c1df9789dd019d22d2",
     "grade": false,
     "grade_id": "cell-f5bcc835498528f7",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epoch 1, loss 0.000049\n",
      "epoch 2, loss 0.000049\n",
      "epoch 3, loss 0.000049\n",
      "epoch 4, loss 0.000049\n",
      "epoch 5, loss 0.000049\n",
      "epoch 6, loss 0.000049\n",
      "epoch 7, loss 0.000049\n",
      "epoch 8, loss 0.000049\n",
      "epoch 9, loss 0.000049\n",
      "epoch 10, loss 0.000049\n",
      "epoch 11, loss 0.000049\n",
      "epoch 12, loss 0.000049\n",
      "epoch 13, loss 0.000049\n",
      "epoch 14, loss 0.000049\n",
      "epoch 15, loss 0.000049\n",
      "epoch 16, loss 0.000049\n",
      "epoch 17, loss 0.000049\n",
      "epoch 18, loss 0.000049\n",
      "epoch 19, loss 0.000049\n",
      "epoch 20, loss 0.000049\n"
     ]
    }
   ],
   "source": [
    "lr = 0.03\n",
    "num_epochs = 20\n",
    "net = linear\n",
    "loss = squared_loss\n",
    "\n",
    "for epoch in range(num_epochs):\n",
    "    for X, y in data_iter(batch_size, features, labels):\n",
    "        l = loss(net(X, w, b), y)  # Minibatch loss in `X` and `y`\n",
    "        # Compute gradient on `l` with respect to [`w`, `b`]\n",
    "        l.backward()\n",
    "        sgd([w, b], lr, batch_size)  # Update parameters using their gradient\n",
    "    with torch.no_grad():\n",
    "        train_l = loss(net(features, w, b), labels)\n",
    "        print(f'epoch {epoch + 1}, loss {float(train_l.mean()):f}')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 112,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-11-09T19:59:54.499122Z",
     "start_time": "2021-11-09T19:59:54.495321Z"
    },
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "6715b05b7464b62f52535dc419cb710d",
     "grade": false,
     "grade_id": "cell-82cd66ab962439d4",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "error in estimating w: tensor([-0.0002,  0.0007], grad_fn=<SubBackward0>)\n",
      "error in estimating b: -5.817413330078125e-05\n"
     ]
    }
   ],
   "source": [
    "print(f'error in estimating w: {true_w - w.reshape(true_w.shape)}')\n",
    "print(f'error in estimating b: {true_b - b}')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 113,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-11-09T19:59:54.503602Z",
     "start_time": "2021-11-09T19:59:54.500685Z"
    },
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "f5b9cfab2d884e13c242cfd9a06fc3fa",
     "grade": true,
     "grade_id": "cell-71658d76dbe33cf9",
     "locked": true,
     "points": 10,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "outputs": [],
   "source": [
    "'''\n",
    "AUTOGRADER CELL. DO NOT MODIFY THIS.\n",
    "'''\n",
    "\n",
    "assert (true_w - w.reshape(true_w.shape)).abs().mean() < 0.05\n",
    "assert (true_b - b).abs() < 0.05\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "illinois_payload": {
   "b64z": "",
   "nb_path": "release/LAB1/LAB1.ipynb"
  },
  "kernelspec": {
   "display_name": "Python 3 (Threads: 2)",
   "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.8.12"
  },
  "toc": {
   "base_numbering": 1,
   "nav_menu": {},
   "number_sections": false,
   "sideBar": true,
   "skip_h1_title": true,
   "title_cell": "Table of Contents",
   "title_sidebar": "Contents",
   "toc_cell": false,
   "toc_position": {
    "height": "calc(100% - 180px)",
    "left": "10px",
    "top": "150px",
    "width": "300.390625px"
   },
   "toc_section_display": true,
   "toc_window_display": true
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}