C2_W2_Backprop.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Optional Lab: Back propagation using a computation graph\n",
    "Working through this lab will give you insight into a key algorithm used by most machine learning frameworks. Gradient descent requires the derivative of the cost with respect to each parameter in the network.  Neural networks can have millions or even billions of parameters. The *back propagation* algorithm is used to compute those derivatives. *Computation graphs* are used to simplify the operation. Let's dig into this below."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sympy import *\n",
    "import numpy as np\n",
    "import re\n",
    "%matplotlib widget\n",
    "import matplotlib.pyplot as plt\n",
    "from matplotlib.widgets import TextBox\n",
    "from matplotlib.widgets import Button\n",
    "import ipywidgets as widgets\n",
    "from lab_utils_backprop import *"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Computation Graph\n",
    "A computation graph simplifies the computation of complex derivatives by breaking them into smaller steps. Let's see how this works.\n",
    "\n",
    "Let's calculate the derivative of this slightly complex expression, $J = (2+3w)^2$. We would like to find the derivative of $J$ with respect to $w$ or $\\frac{\\partial J}{\\partial w}$."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "plt.close(\"all\")\n",
    "plt_network(config_nw0, \"./images/C2_W2_BP_network0.PNG\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Above, you can see we broke the expression into two nodes which we can work on independently. If you already have a good understanding of the process from the lecture, you can go ahead and fill in the boxes in the diagram above. You will want to first fill in the blue boxes going left to right and then fill in the green boxes starting on the right and moving to the left.\n",
    "If you have the correct values, the values will show as green or blue. If the value is incorrect, it will be red. Note, the interactive graphic is not particularly robust. If you run into trouble with the interface, run the cell above again to restart.\n",
    "\n",
    "If you are unsure of the process, we will work this example step by step below.\n",
    "\n",
    "### Forward Propagation   \n",
    "Let's calculate the values in the forward direction.\n",
    "\n",
    ">Just a note about this section. It uses global variables and reuses them as the calculation progresses. If you run cells out of order, you may get funny results. If you do, go back to this point and run them in order."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "w = 3\n",
    "a = 2+3*w\n",
    "J = a**2\n",
    "print(f\"a = {a}, J = {J}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can fill these values in the blue boxes above."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "tags": []
   },
   "source": [
    "### Backprop\n",
    "<img align=\"left\" src=\"./images/C2_W2_BP_network0_j.PNG\"     style=\" width:100px; padding: 10px 20px; \" > Backprop is the algorithm we use to calculate derivatives. As described in the lectures, backprop starts at the right and moves to the left. The first node to consider is $J = a^2 $ and the first step is to find $\\frac{\\partial J}{\\partial a}$ \n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### $\\frac{\\partial J}{\\partial a}$ \n",
    "#### Arithmetically\n",
    "Find $\\frac{\\partial J}{\\partial a}$ by finding how $J$ changes as a result of a little change in $a$. This is described in detail in the derivatives optional lab."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a_epsilon = a + 0.001       # a epsilon\n",
    "J_epsilon = a_epsilon**2    # J_epsilon\n",
    "k = (J_epsilon - J)/0.001   # difference divided by epsilon\n",
    "print(f\"J = {J}, J_epsilon = {J_epsilon}, dJ_da ~= k = {k} \")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "$\\frac{\\partial J}{\\partial a}$ is 22 which is $2\\times a$. Our result is not exactly $2 \\times a$ because our epsilon value is not infinitesimally small. \n",
    "#### Symbolically\n",
    "Now, let's use SymPy to calculate derivatives symbolically as we did in the derivatives optional lab. We will prefix the name of the variable with an 's' to indicate this is a *symbolic* variable."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "sw,sJ,sa = symbols('w,J,a')\n",
    "sJ = sa**2\n",
    "sJ"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "sJ.subs([(sa,a)])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "dJ_da = diff(sJ, sa)\n",
    "dJ_da"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "So, $\\frac{\\partial J}{\\partial a} = 2a$. When $a=11$, $\\frac{\\partial J}{\\partial a} = 22$. This matches our arithmetic calculation above.\n",
    "If you have not already done so, you can go back to the diagram above and fill in the value for $\\frac{\\partial J}{\\partial a}$."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "tags": []
   },
   "source": [
    "### $\\frac{\\partial J}{\\partial w}$ \n",
    "<img align=\"left\" src=\"./images/C2_W2_BP_network0_a.PNG\"     style=\" width:100px; padding: 10px 20px; \" >  Moving from right to left, the next value we would like to compute is $\\frac{\\partial J}{\\partial w}$. To do this, we first need to calculate $\\frac{\\partial a}{\\partial w}$ which describes how the output of this node, $a$, changes when the input $w$ changes a little bit."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Arithmetically\n",
    "Find $\\frac{\\partial a}{\\partial w}$ by finding how $a$ changes as a result of a little change in $w$."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "w_epsilon = w + 0.001       # a  plus a small value, epsilon\n",
    "a_epsilon = 2 + 3*w_epsilon\n",
    "k = (a_epsilon - a)/0.001   # difference divided by epsilon\n",
    "print(f\"a = {a}, a_epsilon = {a_epsilon}, da_dw ~= k = {k} \")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Calculated arithmetically,  $\\frac{\\partial a}{\\partial w} \\approx 3$. Let's try it with SymPy."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "sa = 2 + 3*sw\n",
    "sa"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "da_dw = diff(sa,sw)\n",
    "da_dw"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    ">The next step is the interesting part:\n",
    "> - We know that a small change in $w$ will cause $a$ to change by 3 times that amount.\n",
    "> - We know that a small change in $a$ will cause $J$ to change by $2\\times a$ times that amount. (a=11 in this example)    \n",
    " so, putting these together, \n",
    "> - We  know that a small change in $w$ will cause $J$ to change by $3 \\times 2\\times a$ times that amount.\n",
    "> \n",
    "> These cascading changes go by the name of *the chain rule*.  It can be written like this: \n",
    " $$\\frac{\\partial J}{\\partial w} = \\frac{\\partial a}{\\partial w} \\frac{\\partial J}{\\partial a} $$\n",
    " \n",
    "It's worth spending some time thinking this through if it is not clear. This is a key take-away.\n",
    " \n",
    " Let's try calculating it:\n",
    " "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "dJ_dw = da_dw * dJ_da\n",
    "dJ_dw"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "And $a$ is 11 in this example so $\\frac{\\partial J}{\\partial w} = 66$. We can check this arithmetically:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "w_epsilon = w + 0.001\n",
    "a_epsilon = 2 + 3*w_epsilon\n",
    "J_epsilon = a_epsilon**2\n",
    "k = (J_epsilon - J)/0.001   # difference divided by epsilon\n",
    "print(f\"J = {J}, J_epsilon = {J_epsilon}, dJ_dw ~= k = {k} \")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "OK! You can now fill the values for  $\\frac{\\partial a}{\\partial w}$ and $\\frac{\\partial J}{\\partial w}$ in  the diagram if you have not already done so. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Another view**  \n",
    "One could visualize these cascading changes this way:  \n",
    "<img align=\"center\" src=\"./images/C2_W2_BP_network0_diff.PNG\"  style=\" width:500px; padding: 10px 20px; \" >  \n",
    "A small change in $w$ is multiplied by $\\frac{\\partial a}{\\partial w}$ resulting in a change that is 3 times as large. This larger change is then multiplied by $\\frac{\\partial J}{\\partial a}$ resulting in a change that is now $3 \\times 22 = 66$ times larger."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Computation Graph of a Simple Neural Network\n",
    "Below is a graph of the neural network used in the lecture with different values. Try and fill in the values in the boxes. Note, the interactive graphic is not particularly robust. If you run into trouble with the interface, run the cell below again to restart."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "plt.close(\"all\")\n",
    "plt_network(config_nw1, \"./images/C2_W2_BP_network1.PNG\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Below, we will go through the computations required to fill in the above computation graph in detail. We start with the forward path."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Forward propagation\n",
    "The calculations in the forward path are the ones you have recently learned for neural networks. You can compare the values below to those you calculated for the diagram above."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Inputs and parameters\n",
    "x = 2\n",
    "w = -2\n",
    "b = 8\n",
    "y = 1\n",
    "# calculate per step values   \n",
    "c = w * x\n",
    "a = c + b\n",
    "d = a - y\n",
    "J = d**2/2\n",
    "print(f\"J={J}, d={d}, a={a}, c={c}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Backward propagation (Backprop)\n",
    "<img align=\"left\" src=\"./images/C2_W2_BP_network1_jdsq.PNG\"     style=\" width:100px; padding: 10px 20px; \" > As described in the lectures, backprop starts at the right and moves to the left. The first node to consider is $J = \\frac{1}{2}d^2 $ and the first step is to find $\\frac{\\partial J}{\\partial d}$ \n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "tags": []
   },
   "source": [
    "### $\\frac{\\partial J}{\\partial d}$ "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Arithmetically\n",
    "Find $\\frac{\\partial J}{\\partial d}$ by finding how $J$ changes as a result of a little change in $d$."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "d_epsilon = d + 0.001\n",
    "J_epsilon = d_epsilon**2/2\n",
    "k = (J_epsilon - J)/0.001   # difference divided by epsilon\n",
    "print(f\"J = {J}, J_epsilon = {J_epsilon}, dJ_dd ~= k = {k} \")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "$\\frac{\\partial J}{\\partial d}$ is 3, which is the value of $d$. Our result is not exactly $d$ because our epsilon value is not infinitesimally small. \n",
    "#### Symbolically\n",
    "Now, let's use SymPy to calculate derivatives symbolically, as we did in the derivatives optional lab. We will prefix the name of the variable with an 's' to indicate this is a *symbolic* variable."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "sx,sw,sb,sy,sJ = symbols('x,w,b,y,J')\n",
    "sa, sc, sd = symbols('a,c,d')\n",
    "sJ = sd**2/2\n",
    "sJ"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "sJ.subs([(sd,d)])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "dJ_dd = diff(sJ, sd)\n",
    "dJ_dd"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "So, $\\frac{\\partial J}{\\partial d}$ = d. When $d=3$, $\\frac{\\partial J}{\\partial d}$ = 3. This matches our arithmetic calculation above.\n",
    "If you have not already done so, you can go back to the diagram above and fill in the value for $\\frac{\\partial J}{\\partial d}$."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### $\\frac{\\partial J}{\\partial a}$ \n",
    "<img align=\"left\" src=\"./images/C2_W2_BP_network1_d.PNG\"     style=\" width:100px; padding: 10px 20px; \" >  Moving from right to left, the next value we would like to compute is $\\frac{\\partial J}{\\partial a}$. To do this, we first need to calculate $\\frac{\\partial d}{\\partial a}$ which describes how the output of this node changes when the input $a$ changes a little bit. (Note, we are not interested in how the output changes when $y$ changes since $y$ is not a parameter.)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Arithmetically\n",
    "Find $\\frac{\\partial d}{\\partial a}$ by finding how $d$ changes as a result of a little change in $a$."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a_epsilon = a + 0.001         # a  plus a small value\n",
    "d_epsilon = a_epsilon - y\n",
    "k = (d_epsilon - d)/0.001   # difference divided by epsilon\n",
    "print(f\"d = {d}, d_epsilon = {d_epsilon}, dd_da ~= k = {k} \")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Calculated arithmetically,  $\\frac{\\partial d}{\\partial a} \\approx 1$. Let's try it with SymPy.\n",
    "#### Symbolically"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "sd = sa - sy\n",
    "sd"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "dd_da = diff(sd,sa)\n",
    "dd_da"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Calculated arithmetically,  $\\frac{\\partial d}{\\partial a}$ also equals 1.  \n",
    ">The next step is the interesting part, repeated again in this example:\n",
    "> - We know that a small change in $a$ will cause $d$ to change by 1 times that amount.\n",
    "> - We know that a small change in $d$ will cause $J$ to change by $d$ times that amount. (d=3 in this example)    \n",
    " so, putting these together, \n",
    "> - We  know that a small change in $a$ will cause $J$ to change by $1\\times d$ times that amount.\n",
    "> \n",
    ">This is again *the chain rule*.  It can be written like this: \n",
    " $$\\frac{\\partial J}{\\partial a} = \\frac{\\partial d}{\\partial a} \\frac{\\partial J}{\\partial d} $$\n",
    " \n",
    " Let's try calculating it:\n",
    " "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "dJ_da = dd_da * dJ_dd\n",
    "dJ_da"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "And $d$ is 3 in this example so $\\frac{\\partial J}{\\partial a} = 3$. We can check this arithmetically:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a_epsilon = a + 0.001\n",
    "d_epsilon = a_epsilon - y\n",
    "J_epsilon = d_epsilon**2/2\n",
    "k = (J_epsilon - J)/0.001   \n",
    "print(f\"J = {J}, J_epsilon = {J_epsilon}, dJ_da ~= k = {k} \")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "OK, they match! You can now fill the values for  $\\frac{\\partial d}{\\partial a}$ and $\\frac{\\partial J}{\\partial a}$ in the diagram if you have not already done so. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "tags": []
   },
   "source": [
    "> **The steps in backprop**   \n",
    ">Now that you have worked through several nodes, we can write down the basic method:\\\n",
    "> working right to left, for each node:\n",
    ">- calculate the local derivative(s) of the node\n",
    ">- using the chain rule, combine with the derivative of the cost with respect to the node to the right.   \n",
    "\n",
    "The 'local derivative(s)' are the derivative(s) of the output of the current node with respect to all inputs or parameters.\n",
    "\n",
    "Let's continue the job. We'll be a bit less verbose now that you are familiar with the method."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "tags": []
   },
   "source": [
    "### $\\frac{\\partial J}{\\partial c}$,  $\\frac{\\partial J}{\\partial b}$\n",
    "<img align=\"left\" src=\"./images/C2_W2_BP_network1_a.PNG\"     style=\" width:100px; padding: 10px 20px; \" >The next node has two derivatives of interest. We need to calculate  $\\frac{\\partial J}{\\partial c}$ so we can propagate to the left. We also want to calculate   $\\frac{\\partial J}{\\partial b}$. Finding the derivative of the cost with respect to the parameters $w$ and $b$ is the object of backprop. We will find the local derivatives,  $\\frac{\\partial a}{\\partial c}$ and  $\\frac{\\partial a}{\\partial b}$ first and then combine those with the derivative coming from the right, $\\frac{\\partial J}{\\partial a}$."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# calculate the local derivatives da_dc, da_db\n",
    "sa = sc + sb\n",
    "sa"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "da_dc = diff(sa,sc)\n",
    "da_db = diff(sa,sb)\n",
    "print(da_dc, da_db)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "dJ_dc = da_dc * dJ_da\n",
    "dJ_db = da_db * dJ_da\n",
    "print(f\"dJ_dc = {dJ_dc},  dJ_db = {dJ_db}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "And in our example, d = 3"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "tags": []
   },
   "source": [
    "###  $\\frac{\\partial J}{\\partial w}$\n",
    "<img align=\"left\" src=\"./images/C2_W2_BP_network1_c.PNG\"     style=\" width:100px; padding: 10px 20px; \" > The last node in this example calculates `c`. Here, we are interested in how J changes with respect to the parameter w. We will not back propagate to the input $x$, so we are not interested in $\\frac{\\partial J}{\\partial x}$. Let's start by calculating $\\frac{\\partial c}{\\partial w}$."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# calculate the local derivative\n",
    "sc = sw * sx\n",
    "sc"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "dc_dw = diff(sc,sw)\n",
    "dc_dw"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This derivative is a bit more exciting than the last one. This will vary depending on the value of $x$. This is 2 in our example.\n",
    "\n",
    "Combine this with $\\frac{\\partial J}{\\partial c}$ to find $\\frac{\\partial J}{\\partial w}$."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "dJ_dw = dc_dw * dJ_dc\n",
    "dJ_dw"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(f\"dJ_dw = {dJ_dw.subs([(sd,d),(sx,x)])}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "$d=3$,  so $\\frac{\\partial J}{\\partial w} = 6$ for our example.   \n",
    "Let's test this arithmetically:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "J_epsilon = ((w+0.001)*x+b - y)**2/2\n",
    "k = (J_epsilon - J)/0.001  \n",
    "print(f\"J = {J}, J_epsilon = {J_epsilon}, dJ_dw ~= k = {k} \")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "They match! Great. You can add $\\frac{\\partial J}{\\partial w}$ to the diagram above and our analysis is complete."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Congratulations!\n",
    "You've worked through an example of back propagation using a computation graph. You can apply this to larger examples by following the same node by node approach. "
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}