01_02_exercises.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "JnGHatCI51JP"
   },
   "source": [
    "# micrograd exercises\n",
    "\n",
    "1. watch the [micrograd video](https://www.youtube.com/watch?v=VMj-3S1tku0) on YouTube\n",
    "2. come back and complete these exercises to level up :)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "OFt6NKOz6iBZ"
   },
   "source": [
    "## section 1: derivatives"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "id": "3Jx9fCXl5xHd"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "6.336362190988558\n"
     ]
    }
   ],
   "source": [
    "# here is a mathematical expression that takes 3 inputs and produces one output\n",
    "from math import sin, cos\n",
    "\n",
    "def f(a, b, c):\n",
    "    return -a**3 + sin(3*b) - 1.0/c + b**2.5 - a**0.5\n",
    "\n",
    "print(f(2, 3, 4))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Question 1:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "# # write the function df that returns the analytical gradient of f\n",
    "# # i.e. use your skills from calculus to take the derivative, then implement the formula\n",
    "# # if you do not calculus then feel free to ask wolframalpha, e.g.:\n",
    "# # https://www.wolframalpha.com/input?i=d%2Fda%28sin%283*a%29%29%29\n",
    "\n",
    "# def gradf(a, b, c):\n",
    "#     return [0, 0, 0] # todo, return [df/da, df/db, df/dc]\n",
    "\n",
    "# # expected answer is the list of \n",
    "# ans = [-12.353553390593273, 10.25699027111255, 0.0625]\n",
    "# yours = gradf(2, 3, 4)\n",
    "# for dim in range(3):\n",
    "#     ok = 'OK' if abs(yours[dim] - ans[dim]) < 1e-5 else 'WRONG!'\n",
    "#     print(f\"{ok} for dim {dim}: expected {ans[dim]}, yours returns {yours[dim]}\")\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Answer 1:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "id": "qXaH59eL9zxf"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "OK for dim 0: expected -12.353553390593273, yours returns -12.353553390593273\n",
      "OK for dim 1: expected 10.25699027111255, yours returns 10.25699027111255\n",
      "OK for dim 2: expected 0.0625, yours returns 0.0625\n"
     ]
    }
   ],
   "source": [
    "def gradf(a, b, c):\n",
    "    dfda = -3.0*a**2 - 1 / (2*a**0.5)\n",
    "    dfdb = 2.5*b**1.5 + 3*cos(3*b)\n",
    "    dfdc = c**-2\n",
    "\n",
    "    return [dfda, dfdb, dfdc]\n",
    "\n",
    "# expected answer is the list of \n",
    "ans = [-12.353553390593273, 10.25699027111255, 0.0625]\n",
    "yours = gradf(2, 3, 4)\n",
    "for dim in range(3):\n",
    "    ok = 'OK' if abs(yours[dim] - ans[dim]) < 1e-5 else 'WRONG!'\n",
    "    print(f\"{ok} for dim {dim}: expected {ans[dim]}, yours returns {yours[dim]}\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Question2:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "# # now estimate the gradient numerically without any calculus, using\n",
    "# # the approximation we used in the video.\n",
    "# # you should not call the function df from the last cell\n",
    "\n",
    "# # -----------\n",
    "# numerical_grad = [0, 0, 0] # TODO\n",
    "# # -----------\n",
    "\n",
    "# for dim in range(3):\n",
    "#     ok = 'OK' if abs(numerical_grad[dim] - ans[dim]) < 1e-5 else 'WRONG!'\n",
    "#     print(f\"{ok} for dim {dim}: expected {ans[dim]}, yours returns {numerical_grad[dim]}\")\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Answer 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "OK for dim 0: expected -12.353553390593273, yours returns -12.353553966448771\n",
      "OK for dim 1: expected 10.25699027111255, yours returns 10.256990385926201\n",
      "OK for dim 2: expected 0.0625, yours returns 0.06249999628948899\n"
     ]
    }
   ],
   "source": [
    "numerical_grad = [0.0, 0.0, 0.0]\n",
    "\n",
    "\n",
    "h = 0.0000001\n",
    "numerical_grad[0] = (f(2+h, 3, 4) - f(2,3,4)) / h\n",
    "numerical_grad[1] = (f(2, 3+h, 4) - f(2,3,4)) / h\n",
    "numerical_grad[2] = (f(2, 3, 4+h) - f(2,3,4)) / h\n",
    "\n",
    "for dim in range(3):\n",
    "    ok = 'OK' if abs(numerical_grad[dim] - ans[dim]) < 1e-5 else 'WRONG!'\n",
    "    print(f\"{ok} for dim {dim}: expected {ans[dim]}, yours returns {numerical_grad[dim]}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Answer 2 (alternative 1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "OK for dim 0: expected -12.353553390593273, yours returns -12.353553966448771\n",
      "OK for dim 1: expected 10.25699027111255, yours returns 10.256990385926201\n",
      "OK for dim 2: expected 0.0625, yours returns 0.06249999628948899\n"
     ]
    }
   ],
   "source": [
    "numerical_grad = [0.0, 0.0, 0.0]\n",
    "\n",
    "h = 0.0000001\n",
    "def num_grad_f(x, h, pos):\n",
    "    ori = f(*x)\n",
    "    x[pos] += h\n",
    "    bump = f(*x)\n",
    "    return (bump-ori) / h\n",
    "\n",
    "numerical_grad[0] = num_grad_f([2,3,4], h, 0)\n",
    "numerical_grad[1] = num_grad_f([2,3,4], h, 1)\n",
    "numerical_grad[2] = num_grad_f([2,3,4], h, 2)\n",
    "\n",
    "\n",
    "for dim in range(3):\n",
    "    ok = 'OK' if abs(numerical_grad[dim] - ans[dim]) < 1e-5 else 'WRONG!'\n",
    "    print(f\"{ok} for dim {dim}: expected {ans[dim]}, yours returns {numerical_grad[dim]}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Answer 2 (alternative 2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "OK for dim 0: expected -12.353553390593273, yours returns -12.353553966448771\n",
      "OK for dim 1: expected 10.25699027111255, yours returns 10.256990412571554\n",
      "OK for dim 2: expected 0.0625, yours returns 0.06250002293484158\n"
     ]
    }
   ],
   "source": [
    "numerical_grad = [0.0, 0.0, 0.0]\n",
    "\n",
    "def num_grad(f, x, h):\n",
    "    out = []\n",
    "    ori = f(*x)\n",
    "    for i, v in enumerate(x):\n",
    "        x[i] += h\n",
    "        bump = f(*x)\n",
    "        d = (bump - ori) / h\n",
    "        out.append(d)\n",
    "        x[i] -= h\n",
    "    return out\n",
    "\n",
    "h = 0.0000001\n",
    "numerical_grad = num_grad(f, [2,3,4], h)\n",
    "\n",
    "for dim in range(3):\n",
    "    ok = 'OK' if abs(numerical_grad[dim] - ans[dim]) < 1e-5 else 'WRONG!'\n",
    "    print(f\"{ok} for dim {dim}: expected {ans[dim]}, yours returns {numerical_grad[dim]}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Question 3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "# # there is an alternative formula that provides a much better numerical \n",
    "# # approximation to the derivative of a function.\n",
    "# # learn about it here: https://en.wikipedia.org/wiki/Symmetric_derivative\n",
    "# # implement it. confirm that for the same step size h this version gives a\n",
    "# # better approximation.\n",
    "\n",
    "# # -----------\n",
    "# numerical_grad = [0, 0, 0] # TODO\n",
    "# # -----------\n",
    "\n",
    "# for dim in range(3):\n",
    "#     ok = 'OK' if abs(numerical_grad[dim] - ans[dim]) < 1e-5 else 'WRONG!'\n",
    "#     print(f\"{ok} for dim {dim}: expected {ans[dim]}, yours returns {numerical_grad[dim]}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Answer 3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "OK for dim 0: expected -12.353553390593273, yours returns -12.353553735522382\n",
      "OK for dim 1: expected 10.25699027111255, yours returns 10.256986371359744\n",
      "OK for dim 2: expected 0.0625, yours returns 0.06250111539429781\n"
     ]
    }
   ],
   "source": [
    "def num_grad2(f, x, h):\n",
    "    out = []\n",
    "    for i, v in enumerate(x):\n",
    "        x[i] += h\n",
    "        bump_up = f(*x)\n",
    "        x[i] -= 2*h\n",
    "        bump_down = f(*x)\n",
    "        d = (bump_up - bump_down) / (2*h)\n",
    "        out.append(d)\n",
    "        \n",
    "    return out\n",
    "\n",
    "h = 0.0000000001\n",
    "numerical_grad = num_grad2(f, [2,3,4], h)\n",
    "\n",
    "\n",
    "for dim in range(3):\n",
    "    ok = 'OK' if abs(numerical_grad[dim] - ans[dim]) < 1e-5 else 'WRONG!'\n",
    "    print(f\"{ok} for dim {dim}: expected {ans[dim]}, yours returns {numerical_grad[dim]}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "tklF9s_4AtlI"
   },
   "source": [
    "## section 2: support for softmax"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Question 4"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "# # Value class starter code, with many functions taken out\n",
    "# from math import exp, log\n",
    "\n",
    "# class Value:\n",
    "#     def __init__(self, data, _children=(), _op='', label=''):\n",
    "#         self.data = data\n",
    "#         self.grad = 0.0\n",
    "#         self._backward = lambda: None\n",
    "#         self._prev = set(_children)\n",
    "#         self._op = _op\n",
    "#         self.label = label\n",
    "    \n",
    "#     def __repr__(self):\n",
    "#         return f\"Value(data={self.data})\"\n",
    "  \n",
    "#     def __add__(self, other): # exactly as in the video\n",
    "#         other = other if isinstance(other, Value) else Value(other)\n",
    "#         out = Value(self.data + other.data, (self, other), '+')\n",
    "\n",
    "#         def _backward():\n",
    "#             self.grad += 1.0 * out.grad\n",
    "#             other.grad += 1.0 * out.grad\n",
    "#         out._backward = _backward\n",
    "#         return out\n",
    "  \n",
    "#   # ------\n",
    "#   # re-implement all the other functions needed for the exercises below\n",
    "#   # your code here\n",
    "#   # TODO\n",
    "#   # ------\n",
    "\n",
    "#     def backward(self): # exactly as in video  \n",
    "#         topo = []\n",
    "#         visited = set()\n",
    "#         def build_topo(v):\n",
    "#             if v not in visited:\n",
    "#                 visited.add(v)\n",
    "#                 for child in v._prev:\n",
    "#                     build_topo(child)\n",
    "#                     topo.append(v)\n",
    "#         build_topo(self)\n",
    "    \n",
    "#         self.grad = 1.0\n",
    "#         for node in reversed(topo):\n",
    "#             node._backward()\n",
    "            \n",
    "            \n",
    "# # without referencing our code/video __too__ much, make this cell work\n",
    "# # you'll have to implement (in some cases re-implemented) a number of functions\n",
    "# # of the Value object, similar to what we've seen in the video.\n",
    "# # instead of the squared error loss this implements the negative log likelihood\n",
    "# # loss, which is very often used in classification.\n",
    "\n",
    "# # this is the softmax function\n",
    "# # https://en.wikipedia.org/wiki/Softmax_function\n",
    "# def softmax(logits):\n",
    "#     counts = [logit.exp() for logit in logits]\n",
    "#     denominator = sum(counts)\n",
    "#     out = [c / denominator for c in counts]\n",
    "#     return out\n",
    "\n",
    "# # this is the negative log likelihood loss function, pervasive in classification\n",
    "# logits = [Value(0.0), Value(3.0), Value(-2.0), Value(1.0)]\n",
    "# probs = softmax(logits)\n",
    "# loss = -probs[3].log() # dim 3 acts as the label for this input example\n",
    "# loss.backward()\n",
    "# print(loss.data)\n",
    "\n",
    "# ans = [0.041772570515350445, 0.8390245074625319, 0.005653302662216329, -0.8864503806400986]\n",
    "# for dim in range(4):\n",
    "#     ok = 'OK' if abs(logits[dim].grad - ans[dim]) < 1e-5 else 'WRONG!'\n",
    "#     print(f\"{ok} for dim {dim}: expected {ans[dim]}, yours returns {logits[dim].grad}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "id": "nAPe_RVrCTeO"
   },
   "outputs": [],
   "source": [
    "from math import exp, log\n",
    "\n",
    "class Value:\n",
    "    \n",
    "    def __init__(self, data, _children=(), _op='', label=''):\n",
    "        self.data = data\n",
    "        self.grad = 0.0\n",
    "        self._backward = lambda: None\n",
    "        self._prev = set(_children)\n",
    "        self._op = _op\n",
    "        self.label = label\n",
    "\n",
    "\n",
    "    def __repr__(self):\n",
    "        return f\"Value(data={self.data})\"\n",
    "\n",
    "\n",
    "    def __add__(self, other): # exactly as in the video\n",
    "        other = other if isinstance(other, Value) else Value(other)\n",
    "        out = Value(self.data + other.data, (self, other), '+')\n",
    "        \n",
    "        def _backward():\n",
    "            self.grad += 1.0 * out.grad\n",
    "            other.grad += 1.0 * out.grad\n",
    "        out._backward = _backward\n",
    "        \n",
    "        return out\n",
    "\n",
    "\n",
    "    def __radd__(self, other):\n",
    "        return self + other    \n",
    "\n",
    "    \n",
    "    def __mul__(self, other):\n",
    "        other = other if isinstance(other, Value) else Value(other)\n",
    "        out = Value(self.data * other.data, _children=(self, other), _op='*')\n",
    "\n",
    "        def _backward():\n",
    "            self.grad = other.data * out.grad\n",
    "            other.grad = self.data * out.grad\n",
    "        out._backward = _backward\n",
    "\n",
    "        return out\n",
    "\n",
    "    def __rmul__(self, other):\n",
    "        return self*other\n",
    "    \n",
    "\n",
    "    def exp(self):\n",
    "        out = Value(exp(self.data), _children=(self,), _op='exp')\n",
    "\n",
    "        def _backward():\n",
    "            self.grad = out.data * out.grad\n",
    "        out._backward = _backward\n",
    "\n",
    "        return out\n",
    "\n",
    "    \n",
    "    def __pow__(self, power):\n",
    "        out = Value(self.data**power, _children=(self,), _op=f'power({power})')\n",
    "\n",
    "        def _backward():\n",
    "            self.grad = power*self.data**(power-1) * out.grad\n",
    "        out._backward = _backward\n",
    "        \n",
    "        return out\n",
    "\n",
    "    \n",
    "    def __truediv__(self, other):\n",
    "        return self * other**(-1)\n",
    "\n",
    "    \n",
    "    def log(self):\n",
    "        out = Value(log(self.data), _children=(self,), _op='log')\n",
    "\n",
    "        def _backward():\n",
    "            self.grad = (1 / self.data) * out.grad\n",
    "        out._backward = _backward\n",
    "        \n",
    "        return out\n",
    "        \n",
    "\n",
    "    def backward(self): # exactly as in video    \n",
    "        topo = []\n",
    "        visited = set()\n",
    "        def build_topo(v):\n",
    "            if v not in visited:\n",
    "                visited.add(v)\n",
    "                for child in v._prev:\n",
    "                    build_topo(child)\n",
    "                topo.append(v)\n",
    "        build_topo(self)\n",
    "        \n",
    "        self.grad = 1.0\n",
    "        for node in reversed(topo):\n",
    "            node._backward()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "id": "VgWvwVQNAvnI"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2.1755153626167147\n",
      "OK for dim 0: expected 0.041772570515350445, yours returns 0.041772570515350445\n",
      "OK for dim 1: expected 0.8390245074625319, yours returns 0.8390245074625319\n",
      "OK for dim 2: expected 0.005653302662216329, yours returns 0.005653302662216329\n",
      "OK for dim 3: expected -0.8864503806400986, yours returns -0.8864503806400986\n"
     ]
    }
   ],
   "source": [
    "def softmax(logits):\n",
    "    counts = [logit.exp() for logit in logits]\n",
    "    denominator = sum(counts)\n",
    "    out = [c / denominator for c in counts]\n",
    "    return out\n",
    "\n",
    "logits = [Value(0.0), Value(3.0), Value(-2.0), Value(1.0)]\n",
    "probs = softmax(logits)\n",
    "loss = -1*probs[3].log() # dim 3 acts as the label for this input example\n",
    "loss.backward()\n",
    "print(loss.data)\n",
    "\n",
    "ans = [0.041772570515350445, 0.8390245074625319, 0.005653302662216329, -0.8864503806400986]\n",
    "for dim in range(4):\n",
    "    ok = 'OK' if abs(logits[dim].grad - ans[dim]) < 1e-5 else 'WRONG!'\n",
    "    print(f\"{ok} for dim {dim}: expected {ans[dim]}, yours returns {logits[dim].grad}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Question 5"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "id": "q7ca1SVAGG1S"
   },
   "outputs": [],
   "source": [
    "# verify the gradient using the torch library\n",
    "# torch should give you the exact same gradient"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/Users/lucasvanwalstijn/miniconda3/envs/fastai/lib/python3.8/site-packages/tqdm/auto.py:22: TqdmWarning: IProgress not found. Please update jupyter and ipywidgets. See https://ipywidgets.readthedocs.io/en/stable/user_install.html\n",
      "  from .autonotebook import tqdm as notebook_tqdm\n"
     ]
    }
   ],
   "source": [
    "import torch"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Answer 5"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[0.041772566735744476,\n",
       " 0.8390244245529175,\n",
       " 0.005653302185237408,\n",
       " -0.8864503502845764]"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# All manual\n",
    "\n",
    "logits = torch.tensor([0.0, 3.0, -2.0, 1.0], requires_grad=True)\n",
    "\n",
    "counts = torch.exp(logits)\n",
    "\n",
    "denominator = torch.sum(counts)\n",
    "\n",
    "loss = -1 * torch.log((counts / denominator))\n",
    "\n",
    "loss[3].backward()\n",
    "\n",
    "[g.item() for g in logits.grad]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Answer 5 (alternative 1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[0.041772566735744476,\n",
       " 0.8390244841575623,\n",
       " 0.005653302650898695,\n",
       " -0.8864504098892212]"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Using softmax and manual nll loss\n",
    "\n",
    "logits = torch.tensor([0.0, 3.0, -2.0, 1.0], requires_grad=True)\n",
    "\n",
    "softmax = torch.nn.functional.softmax(logits, dim=0)\n",
    "\n",
    "loss = -1 * torch.log(softmax)\n",
    "\n",
    "loss[3].backward()\n",
    "\n",
    "[g.item() for g in logits.grad]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Answer 5 (alternative 2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[0.041772566735744476,\n",
       " 0.8390244841575623,\n",
       " 0.005653304047882557,\n",
       " -0.8864504098892212]"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Using log_softmax and nll_loss combined\n",
    "\n",
    "logits = torch.tensor([[0.0, 3.0, -2.0, 1.0]], requires_grad=True)\n",
    "\n",
    "softmax = torch.nn.functional.log_softmax(logits, dim=1)\n",
    "\n",
    "loss = torch.nn.functional.nll_loss(softmax, target=torch.tensor([3], dtype=torch.int64))\n",
    "\n",
    "loss.backward()\n",
    "\n",
    "[g.item() for logit in logits.grad for g in logit]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Answer 5 (alternativ 3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[0.041772566735744476,\n",
       " 0.8390244841575623,\n",
       " 0.005653304047882557,\n",
       " -0.8864504098892212]"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Using log_softmax and manual nll loss combined, observe that we don't take the log anymore during definition of loss\n",
    "\n",
    "logits = torch.tensor([[0.0, 3.0, -2.0, 1.0]], requires_grad=True)\n",
    "\n",
    "softmax = torch.nn.functional.log_softmax(logits, dim=1)\n",
    "\n",
    "loss = -1 * softmax\n",
    "\n",
    "loss[0,3].backward()\n",
    "\n",
    "[g.item() for logit in logits.grad for g in logit]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Answer 5 (alternative 4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[0.041772566735744476,\n",
       " 0.8390244841575623,\n",
       " 0.005653304047882557,\n",
       " -0.8864504098892212]"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Using cross_entropy\n",
    "\n",
    "logits = torch.tensor([[0.0, 3.0, -2.0, 1.0]], requires_grad=True)\n",
    "\n",
    "loss = torch.nn.functional.cross_entropy(logits, target=torch.tensor([3], dtype=torch.int64))\n",
    "\n",
    "loss.backward()\n",
    "\n",
    "[g.item() for logit in logits.grad for g in logit]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "colab": {
   "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.8.8"
  },
  "vscode": {
   "interpreter": {
    "hash": "7c13b8769d29b9cf5cf47e8da9da13ab52310a6e33afb9474b0da20ac390dd33"
   }
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}