Part_3_constructing_functions.ipynb

{
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/jermwatt/computational_maths/blob/collab/Part_3_constructing_functions.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ic6B1wYLaXCu"
      },
      "source": [
        "## Computational Mathematics "
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "PF16w08faXCx"
      },
      "source": [
        "# Part 3: Computation graphs and the construction of endlessly complex functions"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "HnNODG2eaXCy"
      },
      "source": [
        "In the previous post we learned about elementary functions like polynomials, reciprocal functions, trigonometric functions, and more, shown in Table 1 below for easy reference."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "H2QNfaiOaXCy"
      },
      "source": [
        " <center>\n",
        "     <caption>Table 1: Elementary functions</caption>\n",
        " </center>\n",
        "  \n",
        "<table>\n",
        "  <col width=\"180\">\n",
        "  <col width=\"100\">\n",
        "<thead>\n",
        "<tr>\n",
        "    <th>elementary function</th>\n",
        "    <th>equation</th> \n",
        "  </tr>\n",
        "  </thead>\n",
        "  <tbody>\n",
        "    <tr>\n",
        "    <td>constant</td>\n",
        "    <td>$c$</td>\n",
        "  </tr>\n",
        "  <tr>\n",
        "    <td>monomial (degree $p\\neq 0$)</td>\n",
        "    <td>$x^p$</td>\n",
        "  </tr>\n",
        "    <tr>\n",
        "    <td>sine</td>\n",
        "    <td>$\\text{sin}(x)$</td>\n",
        "  </tr>\n",
        "  <tr>\n",
        "    <td>cosine</td>\n",
        "    <td>$\\text{cos}(x)$</td>\n",
        "  </tr>\n",
        "  <tr>\n",
        "    <td>exponential</td>\n",
        "    <td>$e^x$</td>\n",
        "  </tr>\n",
        "  <tr>\n",
        "    <td>logarithm</td>\n",
        "    <td>$\\text{log}(x)$</td>\n",
        "  </tr>\n",
        "    <tr>\n",
        "    <td>hyperbloic tangent</td>\n",
        "    <td>$\\text{tanh}(x)$</td>\n",
        "  </tr>\n",
        "      <tr>\n",
        "    <td>rectified linear unit (ReLU) </td>\n",
        "    <td>$\\text{max}\\left(0,x\\right)$</td>\n",
        "  </tr>\n",
        "  </tbody>\n",
        "</table>"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "QayouOxsaXCz"
      },
      "source": [
        "We also learned about basic operations such as addition, multiplcation, max/min, composition, etc., which we summarize here in Table 2."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "rjBb808IaXC0"
      },
      "source": [
        " <center>\n",
        "     <caption>Table 2: Elementary operations</caption>\n",
        " </center>\n",
        " \n",
        "<table>\n",
        "  <col width=\"350\">\n",
        "  <col width=\"120\">\n",
        "<thead>\n",
        "<tr>\n",
        "    <th>operation</th> \n",
        "    <th>equation</th>\n",
        "  </tr>\n",
        "  </thead>\n",
        "  <tbody>\n",
        "  <tr>\n",
        "    <td> addition of a constant $c$ to the function $f(x)$ </td>\n",
        "    <td> $c + f(x)$</td>\n",
        "  </tr> \n",
        "    <tr>\n",
        "    <td> multiplication of the function $f(x)$ by a constant $c$ </td>\n",
        "    <td> $c\\,f(x)$</td>\n",
        "  </tr> \n",
        "  <tr>\n",
        "  <td>addition of the functions $f(x)$ and $g(x)$</td>\n",
        "    <td> $f(x) + g(x)$ </td>\n",
        "  </tr> \n",
        "  <tr>\n",
        "  <td> multiplication of the functions $f(x)$ and $g(x)$ </td>\n",
        "    <td> $f(x)\\, g(x)$ </td>\n",
        "  </tr>  \n",
        "   <tr>\n",
        "  <td> maximum of the functions $f(x)$ and $g(x)$</td>\n",
        "    <td> $\\text{max}\\left(f(x),g(x)\\right)$ </td>\n",
        "  </tr>\n",
        "  <tr>\n",
        "  <td> composition of the function $f(x)$ with the function $g(x)$</td>\n",
        "    <td> $f(g(x))$ </td>\n",
        "  </tr>\n",
        "  </tbody>\n",
        "</table>"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "nXZCtAS-aXC0"
      },
      "source": [
        "Introducing the idea of a computation graph, in this post we combine functions and operations listed in these two Tables in order to construct new functions of arbitrary complexity. The same thinking also allows us to deconstruct generic functions into their elementary functions and operations in a consistent manner.  This basic idea arises throughout machine learning: from the design Automatic Differentiation algorithms to the design of novel neural network architectures."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "collapsed": true,
        "id": "AgPgv95qaXC1"
      },
      "outputs": [],
      "source": [
        "# import standard libs\n",
        "import os\n",
        "from pathlib import Path \n",
        "import pandas as pd\n",
        "import numpy as np\n",
        "from IPython.display import Image\n",
        "import matplotlib.pyplot as plt\n",
        "from mpl_toolkits.mplot3d import Axes3D\n",
        "\n",
        "# setup steps if running on local machine / container\n",
        "if not os.getenv(\"COLAB_RELEASE_TAG\"):\n",
        "    # make sure autograd is installed on machine / container\n",
        "    !pip3 install autograd\n",
        "    \n",
        "    # append path to data / custom library\n",
        "    import sys\n",
        "    sys.path.append('../')\n",
        "    \n",
        "    # import custom library\n",
        "    from compmaths_libraries import basics_library as baslib\n",
        "else: # # setup steps if running on collab\n",
        "    # install github clone - allows for easy cloning of subdirectories\n",
        "    !pip install github-clone\n",
        "\n",
        "    # clone library subdirectory\n",
        "    if not Path('compmaths_libraries').is_dir():\n",
        "      !ghclone https://github.com/jermwatt/computational_maths/tree/collab/compmaths_libraries \n",
        "    else:\n",
        "      print('compmaths_libraries already cloned!')\n",
        "\n",
        "    from compmaths_libraries import basics_library as baslib\n",
        "\n",
        "    # clone datasets\n",
        "    if not Path('compmaths_data').is_dir():\n",
        "      !ghclone https://github.com/jermwatt/computational_maths/tree/collab/compmaths_data\n",
        "    else:\n",
        "      print('compmaths_data already cloned!')\n",
        "\n",
        "    # clone work images\n",
        "    if not Path('compmaths_images').is_dir():\n",
        "      !ghclone https://github.com/jermwatt/computational_maths/tree/collab/compmaths_images\n",
        "    else:\n",
        "      print('compmaths_images already cloned!')\n",
        "\n",
        "    # clone demo output images\n",
        "    if not Path('demo_images').is_dir():\n",
        "      !ghclone https://github.com/jermwatt/computational_maths/tree/collab/demo_images\n",
        "    else:\n",
        "      print('demo_images already cloned!')"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "q5akWJYMaXC2"
      },
      "source": [
        "# 1.   Computational graphs for arithmetic "
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "XBlloU_vaXC3"
      },
      "source": [
        "How do you compute the numerical value of\n",
        "\n",
        "$$ 5*2^3 + 1 $$\n",
        "\n",
        "There is a lot going on here, with three mathematical operations for numbers present - multiplication, exponentiation, and addition - how do we know which to perform first, second, and third?  If we perform the multoplication first, then exponentiation, and then addition we get\n",
        "\n",
        "$$ 5*2^3 + 1 = \\left(\\left(5*2\\right)^3\\right)+1 = \\left(10^3\\right)+1 = 1000 + 1 = 1001$$\n",
        "\n",
        "\n",
        "But if we exponentiate first, then multiply, then add we get \n",
        "\n",
        "$$ 5*2^3 + 1 = \\left(5*\\left(2^3\\right)\\right)+1 = \\left(5*8\\right)+1 = 40 + 1 = 41$$\n",
        "\n",
        "Performing Exponentiation first, followed by addition and then multplication gives yet another result\n",
        "\n",
        "$$ 5*2^3 + 1 = 5*\\left(\\left(2^3\\right)+1\\right) = 5*\\left(8+1\\right) = 5 * 9 = 45$$\n",
        "\n",
        "\n",
        "\n",
        "In other words, depending on the order in which we employ operations we can end up with different results.  In secondary school you learn the conventional order for evaluating arithmetic expressions: parenthesis first, then exponentiation, then multiplication/division, and finally addition/subtraction. With this conventional order of operations our second result above is correct.  \n",
        "\n",
        "The way these operations are performed computationally - i.e., either when we perform the calculation by hand or when we let a computer handle it - can be expressed visually using a *computational graph*.  This is an often employed tool that visualizes all sorts of computational algorithms - in particular basic arithmetic - and is used throughout machine learning to help visualize computation."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "XaQGhRZdaXC3"
      },
      "source": [
        "## 1.1  Example computations"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "KKX-3h8xaXC4"
      },
      "source": [
        "In this short subsection we look at a few examples with arithmetic to get a basic intuition as to how they work in tandem with computation graphs.  Along the way we will learn important concepts and language to describe computation graphs as well."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "mu99OaV0aXC4"
      },
      "source": [
        "#### <span style=\"color:#a50e3e;\">Example. </span>  Building a computation graph for $2\\times3 + 5$ "
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "qJlAR6CeaXC4"
      },
      "source": [
        "Following the order of operations we can break apart the expression $2\\times3 + 5$ operation-by-operation. Because multiplication takes precedence to addition we first perform multiplication to get \n",
        "\n",
        "\n",
        "\\begin{array}\n",
        "\\\n",
        "a = 2\\times 3 \\\\\n",
        "\\end{array} \n",
        "\n",
        "Then we add 5 to this product (stored in the variable $a$)\n",
        "\n",
        "\\begin{array}\n",
        "\\\n",
        "b = a + 5  \\\\\n",
        "\\end{array} \n",
        "\n",
        "All together we have \n",
        "\n",
        "\\begin{array}\n",
        "\\\n",
        "a = 2\\times 3 \\\\\n",
        "b = a + 5  \\\\\n",
        "\\end{array} \n",
        "\n",
        "where $b$ represents the desired arithmetic $2\\times3 + 5$ completely.\n",
        "\n",
        "We can plot this set of equations as the graph shown below which gives us a visual perspective on the computation.\n",
        "\n",
        "<p><img src=\"https://github.com/jermwatt/computational_maths/blob/collab/compmaths_images/numbers_graph_1.png?raw=1\" width=\"25%\" height=\"auto\"></p>"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "qma-ZoIDaXC5"
      },
      "source": [
        "A bit of nomenclature regarding the visual computation graph: the circles containing input values and operations are referred to as *nodes*, with the directed arrows called *edges*.  \n",
        "\n",
        "> When visualizing the computation graphs circles containing inputs, operations, or functions are referred as *nodes* with directed arrows called *edges*. \n",
        "\n",
        "Those nodes containing operations correspond one-to-one with the equation view of the graph shown above, with the letter denoting each equation shown above its corresponding node on the graph.\n",
        "\n",
        "To further describe the local topology of a computation graphs in words the terms *parent* and *child* node are used to describe adjacent hierarchical relationships, or in other words two nodes connected in a graph by a single edge.  The parent node is the one taking in the other node as input, or where the arrow points to.  The child node is the input of the parent, or where the arrow originates.  Because these terms / relationships are defined locally a particular node can be both a parent and a child with respect to other nodes in the graph. \n",
        "\n",
        "> To further describe the local topology of a computation graphs in words the terms *parent* and *child* node are used to describe adjacent hierarchical relationships, or in other words two nodes connected in a graph by a single edge.  The parent node is the one taking in the other node as input, or where the arrow points to.  The child node is the input of the parent, or where the arrow originates.  Because these terms / relationships are defined locally a particular node can be both a parent and a child with respect to other nodes in the graph. "
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "XfsQGyaVaXC5"
      },
      "source": [
        "Lets use this computation graph vocabulary to describe what is going on in the computation graph shown above for $2\\times3 + 5$. Examining the graph we can see how $a$ takes in both $2$ and $3$, and so $a$ is the parent node to the children $2$ and $3$. Examining how $a$ and $b$ are related we can see that $a$ is a child node here, with $b$ being its parent as well as the parent of $5$."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "kIxAA4DUaXC5"
      },
      "source": [
        "----"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "q5onNK1paXC6"
      },
      "source": [
        "#### <span style=\"color:#a50e3e;\">Example. </span>  A computation graph for $\\text{tanh}(1.5)\\text{cos}(1.5) + \\text{log}(1.5)$"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "xxcXgKrHaXC6"
      },
      "source": [
        "In this example we have an arithmetic expression that contains function evaluations as well. We treat arithmetic expressions containing function evaluation(s) with the same order of operations - treating each function evaluation as a parenthesis applying the same operation rules inside them before simplifying the rest of the arithmetic.\n",
        "\n",
        "Following the order of operations we can break apart the expression $\\text{tanh}(1.5)\\text{cos}(1.5) + \\text{log}(1.5)$ operation-by-operation into the list of equations capturing the parent/child relations as\n",
        "\n",
        "\\begin{array}\n",
        "\\\n",
        "a = \\text{tanh}(1.5) \\\\\n",
        "b = \\text{cos}(1.5) \\\\\n",
        "c = \\text{log}(1.5) \\\\\n",
        "d = a\\times b \\\\\n",
        "e = d + c \\\\\n",
        "\\end{array} \n",
        "\n",
        "which corresponds to the following computation graph."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "m34fJcFBaXC6"
      },
      "source": [
        "<p><img src=\"https://github.com/jermwatt/computational_maths/blob/collab/compmaths_images/graph_eval.png?raw=1\" width=\"80%\" height=\"auto\"></p>"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "VrGt7eO1aXC6"
      },
      "source": [
        "Take a moment to verify that the computation graph above indeed represents the expression $\\text{tanh}(1.5)\\text{cos}(1.5) + \\text{log}(1.5)$. Again every node (except the input node in gray) contains an operation: the nodes $d$ and $e$ contain the operations multiplication and addition, while the nodes $a$, $b$, and $c$ contain composition with $\\text{tanh}$, $\\text{cos}$, and $\\text{log}$, repectively. In general, when any of the elementary functions appear in a node, that node represents the composition of that elementary function with its input.   \n",
        "\n",
        "We can now use the computation graph to evaluate the expression $\\text{tanh}(1.5)\\text{cos}(1.5) + \\text{log}(1.5)$. To do so, we start from the input node (shown in gray) on the left and wiggle our way to the rightmost node $e$.\n",
        "\n",
        "With the first parent-child equation we have $a = \\text{tanh}(1.5) = 0.905$, which can be shown on the computation graph as follows \n",
        "\n",
        "<p><img src=\"https://github.com/jermwatt/computational_maths/blob/collab/compmaths_images/graph_a.png?raw=1\" width=\"80%\" height=\"auto\"></p>\n",
        "\n",
        "where the parent and child nodes are highlighted in red and blue, respectively.\n",
        "\n",
        "Moving on to the second equation we have $b = \\text{cos}(1.5) = 0.701$\n",
        "\n",
        "<p><img src=\"https://github.com/jermwatt/computational_maths/blob/collab/compmaths_images/graph_b.png?raw=1\" width=\"80%\" height=\"auto\"></p>\n",
        "\n",
        "The third and last parent of the input node is the node $c$ whose value is found as $c = \\text{log}(1.5)\\approx 0.176$ \n",
        "\n",
        "<p><img src=\"https://github.com/jermwatt/computational_maths/blob/collab/compmaths_images/graph_c.png?raw=1\" width=\"80%\" height=\"auto\"></p>\n",
        "\n",
        "Continuning our evaluation, next we get to the node $d$ that has two children: nodes $a$ and $b$, whose values are already found. Therefore we have $d = a \\times b \\ = 0.905 \\times 0.701 = 0.634$  \n",
        "\n",
        "<p><img src=\"https://github.com/jermwatt/computational_maths/blob/collab/compmaths_images/graph_d.png?raw=1\" width=\"80%\" height=\"auto\"></p>\n",
        "\n",
        "Finally, the node $e$ can be evaluated using the values of its children, nodes $c$ and $d$, as $e=d+c= 0.634+0.176=0.810$.\n",
        "\n",
        "<p><img src=\"https://github.com/jermwatt/computational_maths/blob/collab/compmaths_images/graph_e.png?raw=1\" width=\"80%\" height=\"auto\"></p>\n",
        "\n",
        "\n",
        "As you see here in this example, the final value of a mathematical expression is found by moving forward (from left to right) through the computation graph. "
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "DIgA7akLaXC7"
      },
      "source": [
        "#### <span style=\"color:#a50e3e;\">Example. </span>  Deriving a mathematical expression from its computation graph "
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "pvRs4V52aXC7"
      },
      "source": [
        "So far in our examples we always started with a mathematical expression and built its computation graph. We can also do the reverse, that is, start with a computational graph and form the mathematical expression it represents. Take the computation graph below for example. \n",
        "\n",
        "<p><img src=\"https://github.com/jermwatt/computational_maths/blob/collab/compmaths_images/reverse_0.png?raw=1\" width=\"70%\" height=\"auto\"></p>\n",
        "\n",
        "Once again starting at the first input node (containing the number $1.5$) and moving forward through the graph we can build up the mathematical expression step by step. This progression is visually depicted in the series of figures below. \n",
        "\n",
        "<p><img src=\"https://github.com/jermwatt/computational_maths/blob/collab/compmaths_images/reverse_1.png?raw=1\" width=\"70%\" height=\"auto\"></p>\n",
        "\n",
        "---\n",
        "\n",
        "<p><img src=\"https://github.com/jermwatt/computational_maths/blob/collab/compmaths_images/reverse_2.png?raw=1\" width=\"70%\" height=\"auto\"></p>\n",
        "\n",
        "---\n",
        "\n",
        "<p><img src=\"https://github.com/jermwatt/computational_maths/blob/collab/compmaths_images/reverse_3.png?raw=1\" width=\"70%\" height=\"auto\"></p>\n",
        "\n",
        "---\n",
        "\n",
        "<p><img src=\"https://github.com/jermwatt/computational_maths/blob/collab/compmaths_images/reverse_4.png?raw=1\" width=\"70%\" height=\"auto\"></p>\n",
        "\n",
        "---\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "AVZ9BbK7aXC7"
      },
      "source": [
        "Hence our computation graph represents the expression \n",
        "$$\n",
        "\\text{cos}\\left(\\left(1.5\\right)^2 + \\left(-1\\right)^2\\right) \n",
        "$$"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "HviWQLpmaXC7"
      },
      "source": [
        "Every mathematical expression has a corresponding computation graph and vice versa."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "2xc4foDkaXC7"
      },
      "source": [
        "## 1.2  Summary"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "2Ww_2NgUaXC8"
      },
      "source": [
        "We have just seen how a computation graph gives us a second more visual way of understanding the computation involved in arithmetic expressions, including those containing function evaluations.  Moreover they allow us to break down or build arbitrarily complex expressions - involving many different values, operations, and functions - using a sequence of simple steps of a computation graph.  These simple steps are each an equation  - as illustrated in the examples here - and each *always* consists of one or two numerical values and an operation (e.g., addition, multiplication, etc.,) or function evaluation.  Furthermore, visualizing the computation graph becomes the best way organize even moderately complex parent-child relations as opposed to listing the relationships as a vertical column of equations.\n",
        "\n",
        "> The computation graph allows us to construct or deconstruct complex arithmetic expressions using a sequences of simple parent-child equations consisting of one or two numerical values and an operation (e.g., addition, multiplication, etc.,) or function evaluation.  Visualizing the computation graph is the best way to organize even moderately complex parent-child relations."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "SlbfZR9OaXC8"
      },
      "source": [
        "We have also learned vocabulary terms *parent* and *child* node to describe the local hierarchical structure of a computation graph."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "_tL2n7-naXC8"
      },
      "source": [
        "As mentioned, we will see computation graphs offer an equally helpful view of many other important algorithmic ideas and yields similar benefit, like the construction of arbitrarily complex functions discussed in the next Section."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "oxkTgJ-5aXC8"
      },
      "source": [
        "# 2. Constructing endlessly complex functions out of elementary parts"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "sSc3XJNiaXC8"
      },
      "source": [
        "In this Section we discuss how one can take various elementary functions and operations and combine them to create infinitely complex functions.  The framework for doing this mirrors the previous Section's examples of evaluating arithmetic expressions almost completely - including the use of computation graphs / deconstructed lists of equations to illustrate each operation / elementary function used.  The main difference here is that our input is now a variable or set of variables.\n",
        "\n",
        "But overall we will see here that the computation graph allows us to construct / deconstruct complex functions using a nested composition of simple parent-child equations that are composed together, each consisting of one or two inputs and an operation (e.g., addition, multiplication, etc.,) or elementary function transformation. \n",
        "\n",
        "> The computation graph allows us to construct or deconstruct complex functions using a *nested composition of parent-child equations* consisting of one or two inputs and an operation (e.g., addition, multiplication, etc.,) or elementary function transformation. "
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "eKnw1QPdaXC8"
      },
      "source": [
        "## 2.1  Example functions"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "HOv-cnA_aXC8"
      },
      "source": [
        "In this short subsection we look at a few examples of how one can use a computation graph mindset to both deconstruct and construct generic functions from elementary parts.  We do this by example to gain the basic intuition as to how this is done."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "2igx28d4aXC9"
      },
      "source": [
        "#### <span style=\"color:#a50e3e;\">Example. </span> Building a computation graph for   $f(x) = \\text{tanh}(x)\\text{cos}(x) + \\text{log}(x)$"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "lQ6aAJsDaXC9"
      },
      "source": [
        "In the previous Section we saw a numerical example mirroring this one. Therefore the computation graph takes the following simliar form \n",
        "\n",
        "<p><img src=\"https://github.com/jermwatt/computational_maths/blob/collab/compmaths_images/equation_graph_2.png?raw=1\" width=\"40%\" height=\"auto\"></p>\n",
        "\n",
        "with the only difference being that now our input node contains the variable $x$ instead of a particular numerical value. The parent-child equations can be written similarly as \n",
        "\n",
        "\n",
        "\\begin{array}\n",
        "\\\n",
        "a = \\text{tanh}(x) \\\\\n",
        "b = \\text{cos}(x) \\\\\n",
        "c = \\text{log}(x) \\\\\n",
        "d = a\\times b \\\\\n",
        "e = d + c \\\\\n",
        "\\end{array} \n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "b3FwtFOsaXC9"
      },
      "source": [
        "Computationally speaking in order to plot this function note we can either use the full form of the equation or the list of parent-child equations. We plot both versions side by side in the Python cell below."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 2,
      "metadata": {
        "id": "yiIAH7yFaXC9",
        "outputId": "cde56aac-33a6-4bf6-f00e-1edb621376b6",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 377
        }
      },
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 1080x360 with 2 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {
            "needs_background": "light"
          }
        }
      ],
      "source": [
        "# specify range of input for our functions\n",
        "x = np.linspace(0.1,5,200)\n",
        "x.shape = (len(x),1)\n",
        "\n",
        "# create function using full equation\n",
        "f1 = np.tanh(x)*np.cos(x) + np.log(x)\n",
        "\n",
        "# generate plot using parent-child equations\n",
        "a = np.tanh(x)\n",
        "b = np.cos(x)\n",
        "c = np.log(x)\n",
        "d = a*b\n",
        "e = d + c\n",
        "\n",
        "# reshape each form and stack into table\n",
        "f1.shape = (len(f1),1)\n",
        "table1 = np.stack((x,f1), axis=1) \n",
        "e.shape = (len(e),1)\n",
        "table2 = np.stack((x,e),axis=1)\n",
        "\n",
        "# use custom plotter to show both functions\n",
        "baslib.basics_plotter.double_plot(table1 = table1, table2 = table2,plot_type = 'continuous',xlabel = '$x$',ylabel_1 = '$f_1$',ylabel_2 = '$e$',fontsize = 18)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "collapsed": true,
        "id": "m2Oku7G9aXC-"
      },
      "source": [
        "#### <span style=\"color:#a50e3e;\">Example. </span> Deriving a function's equation from its computation graph "
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "uZcwaCWlaXC-"
      },
      "source": [
        "Given the following computation graph "
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "sSRGlGdmaXC-"
      },
      "source": [
        "<p><img src=\"https://github.com/jermwatt/computational_maths/blob/collab/compmaths_images/reverse_func_0.png?raw=1\" width=\"80%\" height=\"auto\"></p>"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "fUN2KNwKaXC-"
      },
      "source": [
        "we can easily complete the equation it represents by navigating the graph forward, starting from the input node $x_1$.  \n",
        "\n",
        "<p><img src=\"https://github.com/jermwatt/computational_maths/blob/collab/compmaths_images/reverse_func_1.png?raw=1\" width=\"80%\" height=\"auto\"></p>\n",
        "\n",
        "---\n",
        "\n",
        "<p><img src=\"https://github.com/jermwatt/computational_maths/blob/collab/compmaths_images/reverse_func_2.png?raw=1\" width=\"80%\" height=\"auto\"></p>\n",
        "\n",
        "---\n",
        "\n",
        "<p><img src=\"https://github.com/jermwatt/computational_maths/blob/collab/compmaths_images/reverse_func_3.png?raw=1\" width=\"80%\" height=\"auto\"></p>\n",
        "\n",
        "---\n",
        "\n",
        "<p><img src=\"https://github.com/jermwatt/computational_maths/blob/collab/compmaths_images/reverse_func_4.png?raw=1\" width=\"80%\" height=\"auto\"></p>"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "cxRhscdDaXC_"
      },
      "source": [
        "In other words, our equation is\n",
        "\n",
        "$$\n",
        "f(x) = \\text{cos}(x_1^2 + x_2^2)\n",
        "$$\n",
        "\n",
        "which we plot in the next Python cell.  Note that the default viewing angle here has been set to a bird's eye view - looking down on the function directly from above."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 3,
      "metadata": {
        "id": "XeCcto_laXC_",
        "outputId": "afc2b979-3ffa-4af3-d3ce-09fc06288bc7",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 303
        }
      },
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 360x360 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {
            "needs_background": "light"
          }
        }
      ],
      "source": [
        "# what function should we play with?  Defined in the next line.\n",
        "f = lambda x: np.cos( x[0]**2 + x[1]**2)\n",
        "\n",
        "# create an instance of the visualizer with this function\n",
        "opt_test = baslib.math_function_plotting_3d.visualizer()\n",
        "\n",
        "# run\n",
        "view = [-90,45]\n",
        "input_range = np.linspace(-5,5,1000) \n",
        "opt_test.draw_it(g = f,set_figsize = 5,set_axis = 'off',view = view,input_range=input_range)  # other options: horiz_1_label = 'horizontal_1',horiz_2_label = 'horizontal_2',vert_label = 'vertical',set_title = 'my title')"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "K2CsA0AyaXC_"
      },
      "source": [
        "#### <span style=\"color:#a50e3e;\">Example. </span>  Constructing a new function out of elementary parts "
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "RtuPaoifaXC_"
      },
      "source": [
        "What can we build using a short list of elementary parts - including addition / subtraction / multiplication / division, and a few elementary functions?  We have a great number of choices with how to start, but lets begin by defining two child nodes and go from there.\n",
        "\n",
        "We start with multiplication by a constant \n",
        "\n",
        "$$\n",
        "a(x) = 20\\times x\n",
        "$$\n",
        "\n",
        "<p><img src=\"https://github.com/jermwatt/computational_maths/blob/collab/compmaths_images/construct_a.png?raw=1\" width=\"80%\" height=\"auto\"></p>\n",
        "\n",
        "and another child node that creating that squares the input as\n",
        "\n",
        "$$\n",
        "b(x) = x^2\n",
        "$$\n",
        "\n",
        "<p><img src=\"https://github.com/jermwatt/computational_maths/blob/collab/compmaths_images/construct_b.png?raw=1\" width=\"80%\" height=\"auto\"></p>\n",
        "\n",
        "Now we have two child nodes, both transformations of the input $x$.  Next, lets shove $a$ through a cosine function, and add 1 to $b$ giving two parent nodes\n",
        "\n",
        "$$\n",
        "c(a) = \\text{cos}(a)\\\\\n",
        "d(b) = b + 1 \\\\\n",
        "$$\n",
        "\n",
        "<p><img src=\"https://github.com/jermwatt/computational_maths/blob/collab/compmaths_images/construct_c_d.png?raw=1\" width=\"80%\" height=\"auto\"></p>\n",
        "\n",
        "Finally lets make a division parent for $d$, and multiply the result by $c$ as \n",
        "\n",
        "$$\n",
        "e(d) = \\frac{1}{d} \\\\\n",
        "f(c,e) = c\\times e \\\\\n",
        "$$\n",
        "\n",
        "<p><img src=\"https://github.com/jermwatt/computational_maths/blob/collab/compmaths_images/construct_e_f.png?raw=1\" width=\"80%\" height=\"auto\"></p>\n",
        "\n",
        "giving the final parent node $f$.  All together then, we have made a set of parent-child equations (note here we will leave off the parentheses on the left side denoting input for readability purposes since the associated input of each equation is clear from the right hand side of each equation)\n",
        "\n",
        "\\begin{array}\n",
        "\\\n",
        "a = 20 \\times x \\\\\n",
        "b = x^2 \\\\\n",
        "c = \\text{cos}(a)\\\\\n",
        "d = b + 1 \\\\\n",
        "e = \\frac{1}{d} \\\\\n",
        "f = c\\times e \\\\\n",
        "\\end{array}\n",
        "\n",
        "Of course this is an inferior way of detailing these parent-child relationships, which are better expressed by visualizing the graph as shown above."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ojHfUZvDaXDA"
      },
      "source": [
        "We plot the full function\n",
        "\n",
        "$$\n",
        "g(x) = \\frac{\\text{cos}(20x)}{x^2 + 1}\n",
        "$$\n",
        "\n",
        "in the next Python cell."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 4,
      "metadata": {
        "id": "myuqyMlIaXDA",
        "outputId": "13f50bea-1566-4aa8-e2f1-3c36df7cc6ad",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 294
        }
      },
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 936x360 with 3 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {
            "needs_background": "light"
          }
        }
      ],
      "source": [
        "# specify range of input for our function\n",
        "x = np.linspace(-3,3,500)\n",
        "\n",
        "# form the equation\n",
        "g = np.cos(20*x)/(x**2 + 1)\n",
        "\n",
        "# make a table of values for our function\n",
        "table1 = np.stack((x,g), axis=1)  \n",
        "\n",
        "# use custom plotter to display function\n",
        "baslib.basics_plotter.single_plot(table = table1,xlabel = '$x$',ylabel = 'g',rotate_ylabel = 0)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "4iqniYPXaXDA"
      },
      "source": [
        "## 2.2 Section summary"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "zEhP60_ZaXDA"
      },
      "source": [
        "As with arithmetic expressions, we have now seen how to construct / deconstruct complex equations into their elementary parts using the computation graph.  This shows how complex equations can be constructed from sequentially composed parent-child equations, where each equation consists of either one or two inputs and an operation of function transformation.  Moreover we saw how in particular how any function can be represented as a nested composition of the parent-child equations defined by its computation graph."
      ]
    }
  ],
  "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.2"
    },
    "toc": {
      "colors": {
        "hover_highlight": "#DAA520",
        "navigate_num": "#000000",
        "navigate_text": "#333333",
        "running_highlight": "#FF0000",
        "selected_highlight": "#FFD700",
        "sidebar_border": "#EEEEEE",
        "wrapper_background": "#FFFFFF"
      },
      "moveMenuLeft": true,
      "nav_menu": {
        "height": "318px",
        "width": "252px"
      },
      "navigate_menu": true,
      "number_sections": false,
      "sideBar": true,
      "threshold": 4,
      "toc_cell": false,
      "toc_section_display": "block",
      "toc_window_display": false,
      "widenNotebook": false
    },
    "colab": {
      "provenance": [],
      "include_colab_link": true
    }
  },
  "nbformat": 4,
  "nbformat_minor": 0
}