hw1.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "bXoQir0P3P_L"
   },
   "source": [
    "# 10-714: Homework 1\n",
    "\n",
    "This homework will get you started with your implementation of the **needle** (**ne**cessary **e**lements of **d**eep **le**arning) library that you will develop throughout this course.  In particular, the goal of this assignment is to build a basic **automatic differentiation** framework, then use this to re-implement the simple two-layer neural network you used for the MNIST digit classification problem in HW0.\n",
    "\n",
    "First, as you did for HW0, make a copy of this notebook file by selecting \"Save a copy in Drive\" from the \"File\" menu, and then run the code block below.  Then run the code below to set up and install the necessary packages."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Code to set up the assignment\n",
    "from google.colab import drive\n",
    "drive.mount('/content/drive')\n",
    "%cd /content/drive/MyDrive/\n",
    "!mkdir -p 10714\n",
    "%cd /content/drive/MyDrive/10714\n",
    "!git clone https://github.com/dlsys10714/hw1.git\n",
    "%cd /content/drive/MyDrive/10714/hw1\n",
    "\n",
    "!pip3 install --upgrade --no-deps git+https://github.com/dlsys10714/mugrade.git\n",
    "!pip3 install numdifftools"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "Q9vtSr-B3RMx",
    "outputId": "10894b4a-cced-49c4-917b-73cc51a07d30"
   },
   "outputs": [],
   "source": [
    "import sys\n",
    "sys.path.append('./python')\n",
    "sys.path.append('./apps')\n",
    "from simple_ml import *"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Introduction to `needle`\n",
    "\n",
    "For an introduction to the `needle` framework, refer to Lecture 5 in class and [this Jupyter notebook](https://github.com/dlsys10714/notebooks/blob/main/5_automatic_differentiation_implementation.ipynb) from the lecture. For this homework, you will be implementing the basics of automatic differentiation using a `numpy` CPU backend (in later assignments, you will move to your own linear algebra library including GPU code). All code for this assignment will be written in Python.\n",
    "\n",
    "For the purposes of this assignment, there are two important files in the `needle` library, the `python/needle/autograd.py` file (which defines the basics of the computational graph framework, and also will form the basis of the automatic differentiation framework), and the `python/needle/ops.py`.file (which contains implementations of various operators that you will use implement throughout the assignment and the course).\n",
    "\n",
    "Although the basic framework for automatic differentiation is already set up in the `autograd.py` file, you should familiarize yourself with the basic concepts of the library as it relates to a few different defined classes.  Note that we would **not** recommend attempting to read through the entire code base before starting your implementations (some of the functionality will likely make more sense after you have implemented something), but you should have a basic understanding of the basic structure and organization of the classes that needle defines. Specifically, you should get familiar with the basic concepts behind the following classes:\n",
    "- `Value`: A value computed in a compute graph, i.e., either the output of some operations applied to other `Value` objects, or a constant (leaf) `Value` objects  We use a generic class here (which we then specialize to e.g. Tensors), in order to allow for other data structures in later version of needle, but for now you will interact with this class mostly through its subclass `Tensor` (see below).\n",
    "- `Op`: An operator in a compute graph.  Operators need to define their \"forward\" pass in the `compute()` method (i.e., how to compute the operator on the underlying data of the `Value` objects), as well as their \"backward\" pass via the `gradient()` method, which defines how to multiply by incoming output gradients.  The details of writing such operators will be given below.\n",
    "- `Tensor`: This is a subclass of `Value` that corresponds to an actual tensor output, i.e., a multi-dimensional array within a computation graph.  All of your code for this assignment (and most of the following) will use this subclass of `Value` rather than the generic class above.  We have provided several convenience functions (e.g., operator overloading) that let you operate on tensor using normal Python conventions, but these will not work properly until you implement the corresponding operations.\n",
    "- `TensorOp`: This is a subclass for `Op` for operators that return Tensors.  All the operations you implement for this assignment will be of this type.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "18KCMTWT3zVY"
   },
   "source": [
    "## Question 1: Implementing forward computation [10 pts]\n",
    "\n",
    "\n",
    "First, you will implement the forward computation for new operators.  To see how this works, consider the `EWiseAdd` operator in the `ops.py` file:\n",
    "\n",
    "```python\n",
    "class EWiseAdd(TensorOp):\n",
    "    def compute(self, a: NDArray, b: NDArray):\n",
    "        return a + b\n",
    "\n",
    "    def gradient(self, out_grad: Tensor, node: Tensor):\n",
    "        return out_grad, out_grad\n",
    "\n",
    "def add(a, b):\n",
    "    return EWiseAdd()(a, b)\n",
    "```\n",
    "\n",
    "The conventions for implementations of this class are the following.  The `compute()` function computes the \"forward\" pass, i.e., just computes the operation itself.  However, it is important to emphasize the inputs to compute are both `NDArray` objects (i.e., in this initial implementation, they are just `numpy.ndarray` objects, though in a later assignment you will implement your own NDArray).  That is, `compute()` computes the forward pass on the _raw data objects_ themselves, not on Tensor objects within the automatic differentiation.\n",
    "\n",
    "We will discuss the `gradient()` call in the next section, but it is important to emphasize here that this call is different from forward in that it takes `Tensor` arguments.  This means that any call you make within this function _should_ be done via `TensorOp` operations themselves (so that you can take gradients of gradients).\n",
    "\n",
    "Finally, note that we also define a helper `add()` function, to avoid the need to call `EWiseAdd()(a,b)` (which is a bit cumbersome) to add two `Tensor` objects.  These functions are all written for you, and should be self-explanatory.\n",
    "\n",
    "\n",
    "For this question, you will need to implement the `compute` call for each of the following classes.  These calls are very straightforward, and should be essentially one line that calls to the relevant numpy function.  Note that because in later homeworks you will use a backend other than numpy, we have imported numpy as `import numpy as array_api`, so that you'll need to call `array_api.add()` etc, if you want to use the typical `np.X()` calls.\n",
    "\n",
    "- `PowerScalar`: raise input to an integer (scalar) power\n",
    "- `EWiseDiv`: true division of the inputs, element-wise (2 inputs)\n",
    "- `DivScalar`: true division of the input by a scalar, element-wise (1 input, `scalar` - number)\n",
    "- `MatMul`: matrix multiplication of the inputs (2 inputs)\n",
    "- `Summation`: sum of array elements over given axes (1 input, `axes` - tuple)\n",
    "- `BroadcastTo`: broadcast an array to a new shape (1 input, `shape` - tuple)\n",
    "- `Reshape`: gives a new shape to an array without changing its data (1 input, `shape` - tuple)\n",
    "- `Negate`: numerical negative, element-wise (1 input)\n",
    "- `Transpose`: reverses the order of two axes (axis1, axis2), defaults to the last two axes (1 input, `axes` - tuple)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\u001b[1m============================= test session starts ==============================\u001b[0m\n",
      "platform darwin -- Python 3.9.7, pytest-6.2.4, py-1.10.0, pluggy-0.13.1 -- /Users/zkolter/opt/anaconda3/bin/python3\n",
      "cachedir: .pytest_cache\n",
      "rootdir: /Users/zkolter/Dropbox/class/10-714/homework/hw1\n",
      "plugins: pytest_check-1.0.4, anyio-2.2.0\n",
      "collected 21 items / 13 deselected / 8 selected                                \u001b[0m\n",
      "\n",
      "tests/test_autograd_hw.py::test_divide_forward \u001b[32mPASSED\u001b[0m\u001b[32m                    [ 12%]\u001b[0m\n",
      "tests/test_autograd_hw.py::test_divide_scalar_forward \u001b[32mPASSED\u001b[0m\u001b[32m             [ 25%]\u001b[0m\n",
      "tests/test_autograd_hw.py::test_matmul_forward \u001b[32mPASSED\u001b[0m\u001b[32m                    [ 37%]\u001b[0m\n",
      "tests/test_autograd_hw.py::test_summation_forward \u001b[32mPASSED\u001b[0m\u001b[32m                 [ 50%]\u001b[0m\n",
      "tests/test_autograd_hw.py::test_broadcast_to_forward \u001b[32mPASSED\u001b[0m\u001b[32m              [ 62%]\u001b[0m\n",
      "tests/test_autograd_hw.py::test_reshape_forward \u001b[32mPASSED\u001b[0m\u001b[32m                   [ 75%]\u001b[0m\n",
      "tests/test_autograd_hw.py::test_negate_forward \u001b[32mPASSED\u001b[0m\u001b[32m                    [ 87%]\u001b[0m\n",
      "tests/test_autograd_hw.py::test_transpose_forward \u001b[32mPASSED\u001b[0m\u001b[32m                 [100%]\u001b[0m\n",
      "\n",
      "\u001b[32m======================= \u001b[32m\u001b[1m8 passed\u001b[0m, \u001b[33m13 deselected\u001b[0m\u001b[32m in 0.48s\u001b[0m\u001b[32m =======================\u001b[0m\n"
     ]
    }
   ],
   "source": [
    "!python3 -m pytest -v -k \"forward\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "!python3 -m mugrade submit 'YOUR_GRADER_KEY_HERE' -k \"forward\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Question 2: Implementing backward computation [25 pts]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now that you have implemented the functions within our computation graph, in order to implement automatic differentiation using our computational graph, we need to be able to compute the backward pass, i.e., multiply the relevant derivatives of the function with the incoming backward gradients.\n",
    "\n",
    "The easiest way to perform these computations is, again, via taking \"fake\" partial derivatives (assuming everything is a scalar), and then matching sizes: here the tests we provide will automatically check against numerical derivatives to ensure that your solution is correct.\n",
    "\n",
    "The general goal of reverse mode auto-differentiation is to compute the gradient of some downstream function $\\ell$ of $f(x,y)$ with respect to $x$ (or $y$).  Written formally, we could write this as trying to compute\n",
    "\\begin{equation}\n",
    "\\frac{\\partial \\ell}{\\partial x} = \\frac{\\partial \\ell}{\\partial f(x,y)} \\frac{\\partial f(x,y)}{\\partial x}.\n",
    "\\end{equation}\n",
    "The \"incoming backward gradient\" is precisely the term $\\frac{\\partial \\ell}{\\partial f(x,y)}$, so we want our `gradient()` function to ultimately compute the _product_ between this backward gradient the function's own derivative $\\frac{\\partial f(x,y)}{\\partial x}$."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To see how this works a bit more concretely, consider the element-wise addition function we presented above\n",
    "\\begin{equation}\n",
    "f(x,y) = x + y.\n",
    "\\end{equation}\n",
    "Let's suppose that in this setting $x,y\\in \\mathbb{R}^n$, so that $f(x,y) \\in \\mathbb{R}^n$ as well.  Then via simple differentiation\n",
    "\\begin{equation}\n",
    "\\frac{\\partial f(x,y)}{\\partial x} = 1\n",
    "\\end{equation}\n",
    "so that \n",
    "\\begin{equation}\n",
    "\\frac{\\partial \\ell}{\\partial x} = \\frac{\\partial \\ell}{\\partial f(x,y)} \\frac{\\partial f(x,y)}{\\partial x} = \\frac{\\partial \\ell}{\\partial f(x,y)}\n",
    "\\end{equation}\n",
    "i.e., the product of the function's derivative with respect to its first argument $x$ is just exactly the same as the backward incoming gradient.  The same is true of the gradient with respect to the second argument $y$.  This is precisely what is captured by the following method of the `EWiseAdd` operator.\n",
    "```python\n",
    "    def gradient(self, out_grad: Tensor, node: Tensor):\n",
    "        return out_grad, out_grad\n",
    "```\n",
    "i.e., the function just results the incoming backward gradient (which actually _is_ here the product between the backward incoming gradient and the derivative with respect to each argument of the function).  And because the size of $f(x,y)$ is the same as the size of both $x$ and $y$, we don't even need to worry about dimensions here."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now consider another example, the (element-wise) multiplication function\n",
    "\\begin{equation}\n",
    "f(x,y) = x \\circ y\n",
    "\\end{equation}\n",
    "where $\\circ$ denotes element-wise multiplication between $x$ and $y$.  The partial derivative of this function is given by\n",
    "\\begin{equation}\n",
    "\\frac{\\partial f(x,y)}{\\partial x} = y\n",
    "\\end{equation}\n",
    "and similarly \n",
    "\\begin{equation}\n",
    "\\frac{\\partial f(x,y)}{\\partial y} = x\n",
    "\\end{equation}\n",
    "\n",
    "Thus to compute the product of the incoming gradient\n",
    "\\begin{equation}\n",
    "\\frac{\\partial \\ell}{\\partial x} = \\frac{\\partial \\ell}{\\partial f(x,y)} \\frac{\\partial f(x,y)}{\\partial x} = \\frac{\\partial \\ell}{\\partial f(x,y)} \\cdot y\n",
    "\\end{equation}\n",
    "If $x,y \\in \\mathbb{R}^n$ like in the previous example, then $f(x,y) \\in \\mathbb{R}^n$ as well so the first element returned back the gradient function would just be the element-wise multiplication\n",
    "\\begin{equation}\n",
    "\\frac{\\partial \\ell}{\\partial f(x,y)} \\circ y\n",
    "\\end{equation}\n",
    "\n",
    "This is captures in the `gradient()` call of the `EWiseMul` class.\n",
    "```python\n",
    "class EWiseMul(TensorOp):\n",
    "    def compute(self, a: NDArray, b: NDArray):\n",
    "        return a * b\n",
    "\n",
    "    def gradient(self, out_grad: Tensor, node: Tensor):\n",
    "        lhs, rhs = node.inputs\n",
    "        return out_grad * rhs, out_grad * lhs\n",
    "```\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Implementing backward passes\n",
    "\n",
    "Note that, unlike the forward pass functions, the arguments to the `gradient` function are `needle` objects. It is important to implement the backward passes using only `needle` operations (i.e. those defined in `python/needle/ops.py`), rather than using `numpy` operations on the underlying `numpy` data, so that we can construct the gradients themselves via a computation graph (one exception is for the `ReLU` operation defined below, where you could directly access data within the Tensor without risk because the gradient itself is non-differentiable, but this is a special case).\n",
    "\n",
    "\n",
    "To complete this question, fill in the `gradient` function of the following classes:\n",
    "\n",
    "- `EWiseDiv`\n",
    "- `DivScalar`\n",
    "- `MatMul`\n",
    "- `Summation`\n",
    "- `BroadcastTo`\n",
    "- `Reshape`\n",
    "- `Negate`\n",
    "- `Transpose`\n",
    "\n",
    "All of the `gradient` functions can be computed using just the operations defined in `python/needle/ops.py`, so there is no need to define any additional forward functions.\n",
    "\n",
    "**Hint:** while gradients of multiplication, division, etc, may be relatively intuitive to compute it can seem a bit less intuitive to compute backward passes of items like `Broadcast` or `Summation`.  To get a handle on these, you can check gradients numerically and print out their actual values, if you don't know where to start (see the `tests/test_autograd_hw.py`, specifically the `check_gradients()` function within that file to get a sense about how to do this).  And remember that the size of `out_grad` will always be the size of the _output_ of the operation, whereas the sizes of the `Tensor` objects _returned_ by `gradient()` have to always be the same as the original _inputs_ to the operator.\n",
    "\n",
    "\n",
    "### Checking backward passes\n",
    "To reiterate the above, remember that we can check that these backward passes are correct by doing numerical gradient checking as covered in lecture:\n",
    "\\begin{equation}\n",
    "\\delta^T \\nabla_\\theta f(\\theta) = \\frac{f(\\theta + \\epsilon \\delta) - f(\\theta - \\epsilon \\delta)}{2 \\epsilon} + o(\\epsilon^2)\n",
    "\\end{equation}\n",
    "We provide the function `gradient_check` for doing this numerical checking in `tests/test_autograd.py`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "etSSMzD0fee0",
    "outputId": "2e8d28f1-9dee-4ad0-d9c3-9d9bdb1c30ea",
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\u001b[1m============================= test session starts ==============================\u001b[0m\n",
      "platform darwin -- Python 3.9.7, pytest-6.2.4, py-1.10.0, pluggy-0.13.1 -- /Users/zkolter/opt/anaconda3/bin/python3\n",
      "cachedir: .pytest_cache\n",
      "rootdir: /Users/zkolter/Dropbox/class/10-714/homework/hw1\n",
      "plugins: pytest_check-1.0.4, anyio-2.2.0\n",
      "collected 21 items / 12 deselected / 9 selected                                \u001b[0m\n",
      "\n",
      "tests/test_autograd_hw.py::test_divide_backward \u001b[32mPASSED\u001b[0m\u001b[32m                   [ 11%]\u001b[0m\n",
      "tests/test_autograd_hw.py::test_divide_scalar_backward \u001b[32mPASSED\u001b[0m\u001b[32m            [ 22%]\u001b[0m\n",
      "tests/test_autograd_hw.py::test_matmul_simple_backward \u001b[32mPASSED\u001b[0m\u001b[32m            [ 33%]\u001b[0m\n",
      "tests/test_autograd_hw.py::test_matmul_batched_backward \u001b[32mPASSED\u001b[0m\u001b[32m           [ 44%]\u001b[0m\n",
      "tests/test_autograd_hw.py::test_reshape_backward \u001b[32mPASSED\u001b[0m\u001b[32m                  [ 55%]\u001b[0m\n",
      "tests/test_autograd_hw.py::test_negate_backward \u001b[32mPASSED\u001b[0m\u001b[32m                   [ 66%]\u001b[0m\n",
      "tests/test_autograd_hw.py::test_transpose_backward \u001b[32mPASSED\u001b[0m\u001b[32m                [ 77%]\u001b[0m\n",
      "tests/test_autograd_hw.py::test_broadcast_to_backward \u001b[32mPASSED\u001b[0m\u001b[32m             [ 88%]\u001b[0m\n",
      "tests/test_autograd_hw.py::test_summation_backward \u001b[32mPASSED\u001b[0m\u001b[32m                [100%]\u001b[0m\n",
      "\n",
      "\u001b[32m======================= \u001b[32m\u001b[1m9 passed\u001b[0m, \u001b[33m12 deselected\u001b[0m\u001b[32m in 0.53s\u001b[0m\u001b[32m =======================\u001b[0m\n"
     ]
    }
   ],
   "source": [
    "!python3 -m pytest -l -v -k \"backward\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "!python3 -m mugrade submit 'YOUR_GRADER_KEY_HERE' -k \"backward\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "SQMdWR1x7Euc"
   },
   "source": [
    "## Question 3: Topological sort [20 pts]\n",
    "\n",
    "Now your system is capable of performing operations on tensors which builds up a computation graph. Next you will write one of the main utilities needed for automatic differentiation - the [topological sort](https://en.wikipedia.org/wiki/Topological_sorting). This will allow us to traverse through (forward or backward) the computation graph, computing gradients along the way. Furthermore, the previously built components will allow for the operations we perform during this reverse topological traversal to further add to our computation graph (as discussed in lecture), and will therefore give us higher-order differentiation \"for free.\" \n",
    "\n",
    "Fill out the `find_topo_sort` method and the `topo_sort_dfs` helper method (in `python/needle/autograd.py`) to perform this topological sorting. \n",
    "\n",
    "#### Hints: \n",
    "- Ensure that you do a post-order depth-first search, otherwise the test cases will fail. \n",
    "- The `topo_sort_dfs` method is not required, but we find it useful to use this as a recursive helper function. \n",
    "- The \"Reverse mode AD by extending computational graph\" section of the Lecture 4 slides walks through an example of the proper node ordering. \n",
    "- We will be traversing this sorting backwards in later parts of this homework, but the `find_topo_sort` should return the node ordering in the forward direction. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "pQqntvth8GVa",
    "outputId": "c8bcdac7-c8e3-47ca-f450-fac21d29bfab"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\u001b[1m============================= test session starts ==============================\u001b[0m\n",
      "platform darwin -- Python 3.9.7, pytest-6.2.4, py-1.10.0, pluggy-0.13.1\n",
      "rootdir: /Users/zkolter/Dropbox/class/10-714/homework/hw1\n",
      "plugins: pytest_check-1.0.4, anyio-2.2.0\n",
      "collected 21 items / 20 deselected / 1 selected                                \u001b[0m\n",
      "\n",
      "tests/test_autograd_hw.py \u001b[32m.\u001b[0m\u001b[32m                                              [100%]\u001b[0m\n",
      "\n",
      "\u001b[32m======================= \u001b[32m\u001b[1m1 passed\u001b[0m, \u001b[33m20 deselected\u001b[0m\u001b[32m in 0.43s\u001b[0m\u001b[32m =======================\u001b[0m\n"
     ]
    }
   ],
   "source": [
    "!python3 -m pytest -k \"topo_sort\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "rPouXyxCfee1",
    "outputId": "803faa1b-a480-4501-8149-b32ff4d1b90b"
   },
   "outputs": [],
   "source": [
    "!python3 -m mugrade submit 'YOUR_GRADER_KEY_HERE' -k \"topo_sort\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "OTDpkG098JiR"
   },
   "source": [
    "## Question 4: Implementing reverse mode differentiation [25 pts]\n",
    "\n",
    "Once you have correctly implemented the topological sort, you will next leverage it to implement reverse mode automatic differentiation. As a recap from last lecture, we will need to traverse the computational graph in reverse topological order, and construct the new adjoint nodes. For this question, implement the Reverse AD algorithm in the `compute_gradient_of_variables` function in `python/needle/autograd.py`. This will enable use of the `backward` function that computes the gradient and stores the gradient in the `grad` field of each input `Tensor`. With this completed, our reverse mode auto-differentiation engine is functional. We can check the correctness of our implementation in much the same way that we numerically checked the individual backward gradients, by comparing the numerical gradient to the computed one, using the function `gradient_check` in `tests/test_autograd.py`."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![image2.png](data:image/png;base64,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)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As discussed in lecture the result of reverse mode AD is still a computational graph. We can extend that graph further by composing more operations and run reverse mode AD again on the gradient (the last two tests of this problem). "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "4L37C7ez8fkM",
    "outputId": "f2846195-0754-465c-97d7-c36a7ade8cea"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\u001b[1m============================= test session starts ==============================\u001b[0m\n",
      "platform darwin -- Python 3.9.7, pytest-6.2.4, py-1.10.0, pluggy-0.13.1\n",
      "rootdir: /Users/zkolter/Dropbox/class/10-714/homework/hw1\n",
      "plugins: pytest_check-1.0.4, anyio-2.2.0\n",
      "collected 21 items / 20 deselected / 1 selected                                \u001b[0m\n",
      "\n",
      "tests/test_autograd_hw.py \u001b[32m.\u001b[0m\u001b[32m                                              [100%]\u001b[0m\n",
      "\n",
      "\u001b[32m======================= \u001b[32m\u001b[1m1 passed\u001b[0m, \u001b[33m20 deselected\u001b[0m\u001b[32m in 0.47s\u001b[0m\u001b[32m =======================\u001b[0m\n"
     ]
    }
   ],
   "source": [
    "!python3 -m pytest -k \"compute_gradient\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "nwjSL3n6fee2",
    "outputId": "8ff6a756-ac4d-4255-bef0-181c7ebbb594"
   },
   "outputs": [],
   "source": [
    "!python3 -m mugrade submit 'YOUR_GRADER_KEY_HERE' -k \"compute_gradient\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "qgMkRkJE8i9D"
   },
   "source": [
    "## Question 5: Softmax loss [10 pts]\n",
    "\n",
    "The following questions will be tested using the MNIST dataset, so we will use the `parse_mnist` function we wrote in the Homework 0. \n",
    "\n",
    "1. First, copy and paste your solution to Question 2 of Homework 0 to the `parse_mnist` function in the `apps/simple_ml.py` file.  \n",
    "\n",
    "In this question, you will implement the softmax loss as defined in the `softmax_loss()` function in `apps/simple_ml.py`, which we defined in Question 3 of Homework 0, except this time, the softmax loss takes as input a `Tensor` of logits and a `Tensor` of one hot encodings of the true labels. As a reminder, for a multi-class output that can take on values $y \\in \\{1,\\ldots,k\\}$, the softmax loss takes as input a vector of logits $z \\in \\mathbb{R}^k$, the true class $y \\in \\{1,\\ldots,k\\}$ (which is encoded for this function as a one-hot-vector), and returns a loss defined by\n",
    "\\begin{equation}\n",
    "\\ell_{\\mathrm{softmax}}(z, y) = \\log\\sum_{i=1}^k \\exp z_i - z_y.\n",
    "\\end{equation}\n",
    "\n",
    "You will first need to implement the forward and backward passes of one additional operator: ``log``. \n",
    "\n",
    "2. Fill out the `compute()` function in the `Log` operator in `python/needle/ops.py`.\n",
    "3. Fill out the `gradient()` function in the `Log` operator in `python/needle/ops.py`. \n",
    " \n",
    "Once those operators have been implemented, \n",
    "\n",
    "4. Implement the function `softmax_loss` in `apps/simple_ml.py`. \n",
    "\n",
    "You can start with your solution from Homework 0, and then modify it to be compatible with `needle` objects and operations. As with the previous homework, the function you implement should compute the _average_ softmax loss over a batch of size $m$, i.e. logits `Z` will be an $m \\times k$ `Tensor` where each row represents one example, and `y_one_hot` will be an $m \\times k$ `Tensor` that contains all zeros except for a 1 in the element corresponding to the true label for each row. Finally, note that the average softmax loss returned should also be a `Tensor`. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "CpwK-c989OkI",
    "outputId": "0f145d00-6dce-46c9-d5f4-5d72e6d65419"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\u001b[1m============================= test session starts ==============================\u001b[0m\n",
      "platform darwin -- Python 3.9.7, pytest-6.2.4, py-1.10.0, pluggy-0.13.1\n",
      "rootdir: /Users/zkolter/Dropbox/class/10-714/homework/hw1\n",
      "plugins: pytest_check-1.0.4, anyio-2.2.0\n",
      "collected 21 items / 20 deselected / 1 selected                                \u001b[0m\n",
      "\n",
      "tests/test_autograd_hw.py \u001b[32m.\u001b[0m\u001b[32m                                              [100%]\u001b[0m\n",
      "\n",
      "\u001b[32m======================= \u001b[32m\u001b[1m1 passed\u001b[0m, \u001b[33m20 deselected\u001b[0m\u001b[32m in 0.69s\u001b[0m\u001b[32m =======================\u001b[0m\n"
     ]
    }
   ],
   "source": [
    "!python3 -m pytest -k \"softmax_loss_ndl\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "DTwK4X6bfee2",
    "outputId": "6e666bd5-7f75-461b-b42a-673512ba953d"
   },
   "outputs": [],
   "source": [
    "!python3 -m mugrade submit 'YOUR_GRADER_KEY_HERE' -k \"softmax_loss_ndl\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "oWGd-mr-9luT"
   },
   "source": [
    "## Question 6: SGD for a two-layer neural network [10 pts]\n",
    "\n",
    "As you did in Homework 0, you will now implement stochastic gradient descent (SGD) for a simple two-layer neural network as defined in Question 5 of Homework 0. \n",
    "\n",
    "Specifically, for input $x \\in \\mathbb{R}^n$, we'll consider a two-layer neural network (without bias terms) of the form\n",
    "\\begin{equation}\n",
    "z = W_2^T \\mathrm{ReLU}(W_1^T x)\n",
    "\\end{equation}\n",
    "where $W_1 \\in \\mathbb{R}^{n \\times d}$ and $W_2 \\in \\mathbb{R}^{d \\times k}$ represent the weights of the network (which has a $d$-dimensional hidden unit), and where $z \\in \\mathbb{R}^k$ represents the logits output by the network.  We again use the softmax / cross-entropy loss, meaning that we want to solve the optimization problem, overloading the notation to describe the batch form with matrix $X \\in \\mathbb{R}^{m \\times n}$: \n",
    "\\begin{equation}\n",
    "\\min_{W_1, W_2} \\;\\; \\ell_{\\mathrm{softmax}}(\\mathrm{ReLU}(X W_1) W_2, y).\n",
    "\\end{equation}\n",
    "\n",
    "\n",
    "First, you will need to implement the forward and backward passes of the `relu` operator. \n",
    "1. Begin by filling out the function `ReLU` operator in `python/needle/ops.py`.\n",
    "2. Then fill out the `gradient` function of the class `ReLU` in `python/needle/ops.py`.  **Note that in this one case it's acceptable to access the `.realize_cached_data()` call on the output tensor, since the ReLU function is not twice differentiable anyway**.\n",
    "\n",
    "Then, \n",
    "\n",
    "3. Fill out the `nn_epoch` method in the `apps/simple_ml.py` file. \n",
    "\n",
    "Again, you can use your solution in Homework 0 for the `nn_epoch` function as a starting point. Note that unlike in Homework 0, the inputs `W1` and `W2` are `Tensors`. Inputs `X` and `y` however are still numpy arrays - you should iterate over mini-batches of the numpy arrays `X` and `y` as you did in Homework 0, and then cast each `X_batch` as a `Tensor`, and one hot encode `y_batch` and cast as a `Tensor`. While last time we derived the backpropagation equations for this two-layer ReLU network directly, this time we will be using our auto-differentiation engine to compute the gradients generically by calling the `.backward()` method of the `Tensor` class. For each mini-batch, after calling `.backward()`, you should compute the updated values for `W1` and `W2` in `numpy`, and then create new `Tensors` for `W1` and `W2` with these `numpy` values. Your solution should return the final `W1` and `W2` `Tensors`. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "LHKC82ex9wFg",
    "outputId": "5a319557-624e-45be-e839-3e1d30efb6f5"
   },
   "outputs": [],
   "source": [
    "!python3 -m pytest -l -k \"nn_epoch_ndl\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "lVt8QXrcfee3",
    "outputId": "fad588b5-4f02-4219-84c1-6c9e30be1650"
   },
   "outputs": [],
   "source": [
    "!python3 -m mugrade submit 'YOUR_GRADER_KEY_HERE' -k \"nn_epoch_ndl\""
   ]
  }
 ],
 "metadata": {
  "colab": {
   "collapsed_sections": [],
   "name": "hw1_combined.ipynb",
   "provenance": []
  },
  "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.4"
  },
  "vscode": {
   "interpreter": {
    "hash": "916dbcbb3f70747c44a77c7bcd40155683ae19c65e1c03b4aa3499c5328201f1"
   }
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}