{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "5796054b",
   "metadata": {},
   "source": [
    "\n",
    "<p align=\"center\">\n",
    "    <img src=\"https://github.com/GeostatsGuy/GeostatsPy/blob/master/TCG_color_logo.png?raw=true\" width=\"220\" height=\"240\" />\n",
    "\n",
    "</p>\n",
    "\n",
    "### Interactive Simple Machine Learning Artificial Neural Network (ANN)\n",
    "\n",
    "\n",
    "#### Michael Pyrcz, Professor, The University of Texas at Austin \n",
    "\n",
    "##### [Twitter](https://twitter.com/geostatsguy) | [GitHub](https://github.com/GeostatsGuy) | [Website](http://michaelpyrcz.com) | [GoogleScholar](https://scholar.google.com/citations?user=QVZ20eQAAAAJ&hl=en&oi=ao) | [Book](https://www.amazon.com/Geostatistical-Reservoir-Modeling-Michael-Pyrcz/dp/0199731446) | [YouTube](https://www.youtube.com/channel/UCLqEr-xV-ceHdXXXrTId5ig)  | [LinkedIn](https://www.linkedin.com/in/michael-pyrcz-61a648a1)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e41c1943",
   "metadata": {},
   "source": [
    "#### Neural Networks\n",
    "\n",
    "Machine learning method for supervised learning for classification and regression analysis.  Here are some key aspects of support vector machines.\n",
    "\n",
    "**Basic Design** *\"...a computing system made up of a number of simple, highly interconnected processing elements, which process information by their dynamic state response to external inputs.\"* Caudill (1989). \n",
    "\n",
    "**Nature-inspire Computing** based on the neuronal structure in the brain, including many interconnected simple, processing units, known as nodes that are capable of complicated emergent pattern detection due to a large number of nodes and interconnectivity.\n",
    "\n",
    "**Training and Testing** just like and other predictive model (e.g. linear regression, decision trees and support vector machines) we perform training to fit parameters and testing to tune hyperparameters.  Here we observe the error with training and testing datasets, but do not demonstrate tuning of the hyperparameters.  \n",
    "\n",
    "**Parameters** are the weights applied to each connection and a bias term applied to each node.  For a single node in an artificial neural network, this includes the slope terms, $\\beta_i$, and the bias term, $\\beta_{0}$.\n",
    "\n",
    "\\begin{equation}\n",
    "Y = \\sum_{i=1}^m \\beta_i X + \\beta_0\n",
    "\\end{equation}\n",
    "\n",
    "it can be seen that the number of parameters increases rapidly as we increase the number of nodes and the connectivity between the nodes.\n",
    "\n",
    "**Layers** the typical artificial neural net is structured with an **input layer**, with one node for each $m$ predictor feature, $X_1,\\ldots,X_m$. There is an **ouput layer**, with one node for each $r$ response feature, $Y_1,\\ldots,Y_r$.  There may be one or more layers of nodes between the input and output layers, known as **hidden layer(s)**.  \n",
    "\n",
    "**Connections** are the linkages between the nodes in adjacent layers.  For example, in a fully connected artificial neural network, all the input nodes are connected to all of the nodes in the first layer, then all of the nodes in the first layer are connected to the next layer and so forth. Each connection includes a weight parameter as indicated above.\n",
    "\n",
    "**Nodes** receive the weighted signal from the connected previous layer nodes, sum and then apply this result to the **activation** function in the node. Some example activation functions include:\n",
    "\n",
    "* **Binary** the node fires or not.  This is represented by a Heaviside step function.\n",
    "\n",
    "* **Identify** the input is passed to the output $f(x) = x$\n",
    "\n",
    "* **Linear** the node passes a signal that increases linearly with the weighted input.\n",
    "\n",
    "* **Logistic** also known as sigmoid or soft step $f(x) = \\frac{1}{1+e^{-x}}$\n",
    "\n",
    "the node output is the nonlinear activiation function applied to the linearly weighted inputs. This is fed to all nodes in the next layer.\n",
    "\n",
    "**Training Cycles** - the presentation of a batch of data, forward application of the current prediction model to make estimates, calculation of error and then backpropagation of error to correct the artificial neural network parameters to reduce the error over all of the batches.\n",
    "\n",
    "**Batch** is the set of training data for each training cycle of forward prediction and back propagation of error, drawn to train for each iteration. There is a trade-off, a larger batch results in more computational time per iteration, but a more accurate estimate of the error to adjust the weights.  Smaller batches result in a nosier estimate of the error, but faster epochs, this results in faster learning and even possibly more robust models.\n",
    "\n",
    "**Epochs** - is a set of training cycles, batches covering all available training data.  \n",
    "\n",
    "**Local Minimums** - if one calculated the error hypersurface over the range of model parameters it would be hyparabolic, there is a global minimium error solution.  But this error hyper surface is rough and it is possible to be stuck in a local minimum. **Learning Rate** and **Mommentum** coefficients are introduced to avoid getting stuck in local minimums.\n",
    "\n",
    "* **Mommentum** is a hyperparameter to control the use of information from the weight update over the last epoch for consideration in the current epoch.  This can be accomplished with an update vector, $v_i$, a mommentum parameter, $\\alpha$, to calculate the current weight update, $v_{i+1}$ given the new update $\\theta_{i+1}$.\n",
    "\n",
    "\\begin{equation}\n",
    "v_{i+1} = \\alpha v_i + \\theta_{i+1}\n",
    "\\end{equation}\n",
    "\n",
    "* **Learning Rate** is a hyperparameter that controls the adjustment of the weights in response to the gradient indicated by backpropagation of error \n",
    "\n",
    "##### Applications to subsurface modeling\n",
    "\n",
    "We demonstrate the estimation of normal score transformed porosity from depth.  This would be useful for building a vertical trend model. \n",
    "\n",
    "* modeling the complicated relationship between porosity and depth.\n",
    "\n",
    "#### Limitations of Neural Network Estimation\n",
    "\n",
    "Since we demonstrate the use of an artificial neural network to estimate porosity from sparsely sampled data over depth, we should comment on limitations of our artificial neural networks for this estimation problem:\n",
    "\n",
    "* does not honor the well data\n",
    "\n",
    "* does not honor the histogram of the data\n",
    "\n",
    "* does not honor spatial correlation \n",
    "\n",
    "* does not honor the multivariate relationship\n",
    "\n",
    "* generally low interpretability models\n",
    "\n",
    "* requires a large number of data for effective training\n",
    "\n",
    "* high model complexity with high model variance\n",
    "\n",
    "#### Import Required Packages\n",
    "\n",
    "We will also need some standard packages. These should have been installed with Anaconda 3."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "877ffa62",
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import pandas as pd\n",
    "import matplotlib.pyplot as plt\n",
    "from matplotlib.ticker import (MultipleLocator, AutoMinorLocator, AutoLocator) # control of axes ticks\n",
    "from ipywidgets import interactive                      # widgets and interactivity\n",
    "from ipywidgets import widgets                            \n",
    "from ipywidgets import Layout\n",
    "from ipywidgets import Label\n",
    "from ipywidgets import VBox, HBox\n",
    "import math\n",
    "seed = 13"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a27fea49",
   "metadata": {},
   "source": [
    "If you get a package import error, you may have to first install some of these packages. This can usually be accomplished by opening up a command window on Windows and then typing 'python -m pip install [package-name]'. More assistance is available with the respective package docs.  \n",
    "\n",
    "#### Declare Functions\n",
    "\n",
    "I just added a convenience function for adding major and minor gridlines."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "8abbc843",
   "metadata": {},
   "outputs": [],
   "source": [
    "def add_grid():\n",
    "    plt.gca().grid(True, which='major',linewidth = 1.0); plt.gca().grid(True, which='minor',linewidth = 0.2) # add y grids\n",
    "    plt.gca().tick_params(which='major',length=7); plt.gca().tick_params(which='minor', length=4)\n",
    "    plt.gca().xaxis.set_minor_locator(AutoMinorLocator()); plt.gca().yaxis.set_minor_locator(AutoMinorLocator()) # turn on minor ticks   \n",
    "\n",
    "def calculate_angle_rads(x1, y1, x2, y2):\n",
    "    dx = x2 - x1     # Calculate the differences\n",
    "    dy = y2 - y1\n",
    "    angle_rads = math.atan2(dy, dx)    # Calculate the angle in radians\n",
    "    #angle_degrees = math.degrees(angle_radians)    # Convert the angle to degrees\n",
    "    return angle_rads\n",
    "    \n",
    "def offset(pto, distance, angle_deg): # modified from ChatGPT 4.o generated\n",
    "    angle_rads = math.radians(angle_deg) # Convert angle from degrees to radians\n",
    "    x_new = pto[0] + distance * math.cos(angle_rads) # Calculate the new coordinates\n",
    "    y_new = pto[1] + distance * math.sin(angle_rads)\n",
    "    return np.array((x_new, y_new))\n",
    "\n",
    "def offsetx(xo, distance, angle_deg): # modified from ChatGPT 4.o generated\n",
    "    angle_rads = math.radians(angle_deg) # Convert angle from degrees to radians\n",
    "    x_new = xo + distance * math.cos(angle_rads) # Calculate the new coordinates\n",
    "    return np.array((xo, x_new))\n",
    "\n",
    "def offset_arrx(xo, distance, angle_deg,size): # modified from ChatGPT 4.o generated\n",
    "    angle_rads = math.radians(angle_deg) # Convert angle from degrees to radians\n",
    "    x_new = xo + distance * math.cos(angle_rads) # Calculate the new coordinates\n",
    "    x_arr = x_new + size * math.cos(angle_rads+2.48) # Calculate the new coordinates\n",
    "    return np.array((x_new, x_arr))\n",
    "\n",
    "def offsety(yo, distance, angle_deg): # modified from ChatGPT 4.o generated\n",
    "    angle_rads = math.radians(angle_deg) # Convert angle from degrees to radians\n",
    "    y_new = yo + distance * math.sin(angle_rads) # Calculate the new coordinates\n",
    "    return np.array((yo, y_new))\n",
    "\n",
    "def offset_arry(yo, distance, angle_deg,size): # modified from ChatGPT 4.o generated\n",
    "    angle_rads = math.radians(angle_deg) # Convert angle from degrees to radians\n",
    "    y_new = yo + distance * math.sin(angle_rads) # Calculate the new coordinates\n",
    "    y_arr = y_new + size * math.sin(angle_rads+2.48) # Calculate the new coordinates\n",
    "    return np.array((y_new, y_arr))\n",
    "\n",
    "def lint(x1, y1, x2, y2, t):\n",
    "    # Calculate the interpolated coordinates\n",
    "    x = x1 + t * (x2 - x1)\n",
    "    y = y1 + t * (y2 - y1)\n",
    "    return np.array((x, y))\n",
    "\n",
    "def lintx(x1, y1, x2, y2, t):\n",
    "    # Calculate the interpolated coordinates\n",
    "    x = x1 + t * (x2 - x1)\n",
    "    return x\n",
    "\n",
    "def linty(x1, y1, x2, y2, t):\n",
    "    # Calculate the interpolated coordinates\n",
    "    y = y1 + t * (y2 - y1)\n",
    "    return y\n",
    "\n",
    "def lint_intx(x1, y1, x2, y2, ts, te):\n",
    "    # Calculate the interpolated coordinates\n",
    "    xs = x1 + ts * (x2 - x1)\n",
    "    xe = x1 + te * (x2 - x1)\n",
    "    return np.array((xs,xe))\n",
    "\n",
    "def lint_inty(x1, y1, x2, y2, ts, te):\n",
    "    # Calculate the interpolated coordinates\n",
    "    ys = y1 + ts * (y2 - y1)\n",
    "    ye = y1 + te * (y2 - y1)\n",
    "    return np.array((ys,ye))\n",
    "\n",
    "def lint_int_arrx(x1, y1, x2, y2, ts, te, size):\n",
    "    # Calculate the interpolated coordinates\n",
    "    xe = x1 + te * (x2 - x1)\n",
    "    line_angle_rads = calculate_angle_rads(x1, y1, x2, y2)\n",
    "    x_arr = xe + size * math.cos(line_angle_rads+2.48) # Calculate the new coordinates\n",
    "    return np.array((xe,x_arr))\n",
    "\n",
    "def lint_int_arry(x1, y1, x2, y2, ts, te, size):\n",
    "    # Calculate the interpolated coordinates\n",
    "    ye = y1 + te * (y2 - y1)\n",
    "    line_angle_rads = calculate_angle_rads(x1, y1, x2, y2)\n",
    "    y_arr = ye + size * math.sin(line_angle_rads+2.48) # Calculate the new coordinates\n",
    "    return np.array((ye,y_arr))\n",
    "\n",
    "def as_si(x, ndp): # from xnx on StackOverflow https://stackoverflow.com/questions/31453422/displaying-numbers-with-x-instead-of-e-scientific-notation-in-matplotlib \n",
    "    s = '{x:0.{ndp:d}e}'.format(x=x, ndp=ndp)\n",
    "    m, e = s.split('e')\n",
    "    return r'{m:s}\\times 10^{{{e:d}}}'.format(m=m, e=int(e))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7913b84d",
   "metadata": {},
   "source": [
    "#### The Simple ANN\n",
    "\n",
    "I wrote this code to specify a simple ANN:\n",
    "\n",
    "- three input nodes, 2 hidden nodes and 1 output node\n",
    "\n",
    "and to train the ANN by interatively performing the forward calculation and backpropagation. I calculate:\n",
    "\n",
    "- the error and then propagate it to each node\n",
    "- solve for the partial derivatives of the error with respect to each weight and bias\n",
    "\n",
    "all weights, biases and partial derivatives for all epoch are recorded in vectors for plotting"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "183d883f",
   "metadata": {},
   "outputs": [],
   "source": [
    "x1 = 0.5; x2 = 0.2; x3 = 0.7; y = 0.3 # training data\n",
    "lr = 0.2 # learning rate\n",
    "\n",
    "np.random.seed(seed=seed)\n",
    "\n",
    "nepoch = 1000\n",
    "\n",
    "y4 = np.zeros(nepoch); y5 = np.zeros(nepoch); y6 = np.zeros(nepoch)\n",
    "\n",
    "w14 = np.zeros(nepoch); w24 = np.zeros(nepoch); w34 = np.zeros(nepoch)\n",
    "w15 = np.zeros(nepoch); w25 = np.zeros(nepoch); w35 = np.zeros(nepoch)\n",
    "w46 = np.zeros(nepoch); w56 = np.zeros(nepoch)\n",
    "\n",
    "dw14 = np.zeros(nepoch); dw24 = np.zeros(nepoch); dw34 = np.zeros(nepoch)\n",
    "dw15 = np.zeros(nepoch); dw25 = np.zeros(nepoch); dw35 = np.zeros(nepoch)\n",
    "dw46 = np.zeros(nepoch); dw56 = np.zeros(nepoch)\n",
    "\n",
    "db4 = np.zeros(nepoch); db5 = np.zeros(nepoch); db6 = np.zeros(nepoch)\n",
    "\n",
    "b4 = np.zeros(nepoch); b5 = np.zeros(nepoch); b6 = np.zeros(nepoch)\n",
    "y4 = np.zeros(nepoch); y5 = np.zeros(nepoch); y6 = np.zeros(nepoch)\n",
    "d4 = np.zeros(nepoch); d5 = np.zeros(nepoch); d6 = np.zeros(nepoch)\n",
    "\n",
    "# initialize the weights and biases\n",
    "w14[0] = np.random.random(); w24[0] = np.random.random(); w34[0] = np.random.random()\n",
    "w15[0] = np.random.random(); w25[0] = np.random.random(); w35[0] = np.random.random()\n",
    "w46[0] = np.random.random(); w56[0] = np.random.random()\n",
    "b4[0] = np.random.random(); b5[0] = np.random.random(); b6[0] = np.random.random()\n",
    "\n",
    "for i in range(0,nepoch):\n",
    "\n",
    "# forward pass of model\n",
    "    y4[i] = w14[i]*x1 + w24[i]*x2 + w34[i]*x3 + b4[i]; \n",
    "    y4[i] = 1.0/(1 + math.exp(-1*y4[i]))\n",
    "    \n",
    "    y5[i] = w15[i]*x1 + w25[i]*x2 + w35[i]*x3 + b5[i]\n",
    "    y5[i] = 1.0/(1 + math.exp(-1*y5[i]))\n",
    "    \n",
    "    y6[i] = w46[i]*y4[i] + w56[i]*y5[i] + b6[i]\n",
    "#    y6[i] = 1.0/(1 + math.exp(-1*y6[i])) # sgimoid / logistic activation at o6 \n",
    "\n",
    "# back propagate the error through the nodes\n",
    "#    d6[i] = y6[i]*(1-y6[i])*(y-y6[i]) # sgimoid / logistic activation at o6 \n",
    "    d6[i] = (y-y6[i]) # identity activation o at o6\n",
    "    d5[i] = y5[i]*(1-y5[i])*w56[i]*d6[i]; d4[i] = y4[i]*(1-y4[i])*w46[i]*d6[i]\n",
    "\n",
    "# calculate the change in weights\n",
    "    if i < nepoch - 1:\n",
    "        dw14[i] = lr*d4[i]*x1; dw24[i] = lr*d4[i]*x2; dw34[i] = lr*d4[i]*x3\n",
    "        dw15[i] = lr*d5[i]*x1; dw25[i] = lr*d5[i]*x2; dw35[i] = lr*d5[i]*x3\n",
    "        dw46[i] = lr*d6[i]*y4[i]; dw56[i] = lr*d6[i]*y5[i] \n",
    "        \n",
    "        db4[i] = lr*d4[i]; db5[i] = lr*d5[i]; db6[i] = lr*d6[i];\n",
    "\n",
    "        w14[i+1] = w14[i] + dw14[i]; w24[i+1] = w24[i] + dw24[i]; w34[i+1] = w34[i] + dw34[i] \n",
    "        w15[i+1] = w15[i] + dw15[i]; w25[i+1] = w25[i] + dw25[i]; w35[i+1] = w35[i] + dw35[i] \n",
    "        w46[i+1] = w46[i] + dw46[i]; w56[i+1] = w56[i] + dw56[i]\n",
    "\n",
    "        b4[i+1] = b4[i] + db4[i]; b5[i+1] = b5[i] + db5[i]; b6[i+1] = b6[i] + db6[i] "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "97845fba",
   "metadata": {},
   "source": [
    "#### Check the ANN Convergence\n",
    "\n",
    "Now we plot the weights, biases and prediction over the epochs to check the training convergence."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "a59db6f8",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 3 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.subplot(131)\n",
    "plt.plot(np.arange(1,nepoch+1,1),y6,color='red',label=r'$\\hat{y}$'); plt.xlim([1,nepoch]); plt.ylim([0,1])\n",
    "plt.xlabel('Epochs'); plt.ylabel(r'$\\hat{y}$'); plt.title('Simple Artificial Neural Network Prediction')\n",
    "plt.plot([1,nepoch],[y,y],color='black',ls='--'); plt.vlines(400,-1.5,1.5,color='black')\n",
    "add_grid(); plt.legend(loc='upper right'); plt.xscale('log')\n",
    "\n",
    "plt.subplot(132)\n",
    "plt.plot(np.arange(1,nepoch+1,1),w14,color='lightcoral',label = r'$\\lambda_{1,4}$') \n",
    "plt.plot(np.arange(1,nepoch+1,1),w24,color='red',label = r'$\\lambda_{2,4}$') \n",
    "plt.plot(np.arange(1,nepoch+1,1),w34,color='darkred',label = r'$\\lambda_{3,4}$') \n",
    "plt.plot(np.arange(1,nepoch+1,1),w15,color='dodgerblue',label = r'$\\lambda_{1,5}$') \n",
    "plt.plot(np.arange(1,nepoch+1,1),w25,color='blue',label = r'$\\lambda_{2,5}$') \n",
    "plt.plot(np.arange(1,nepoch+1,1),w35,color='darkblue',label = r'$\\lambda_{3,5}$')\n",
    "plt.plot(np.arange(1,nepoch+1,1),w46,color='orange',label = r'$\\lambda_{4,6}$')\n",
    "plt.plot(np.arange(1,nepoch+1,1),w56,color='darkorange',label = r'$\\lambda_{5,6}$')\n",
    "plt.plot([1,nepoch],[0,0],color='black',ls='--')\n",
    "plt.xlim([1,nepoch]); plt.ylim([-1.5,1.5]); plt.vlines(400,-1.5,1.5,color='black')\n",
    "plt.xlabel('Epochs'); plt.ylabel(r'$\\hat{y}$'); plt.title('Simple Artificial Neural Network Weights')\n",
    "add_grid(); plt.legend(loc='upper right'); plt.xscale('log')\n",
    "\n",
    "plt.subplot(133)\n",
    "plt.plot(np.arange(1,nepoch+1,1),w14,color='lightgreen',label = r'$\\phi_{4}$') \n",
    "plt.plot(np.arange(1,nepoch+1,1),w24,color='green',label = r'$\\phi_{5}$') \n",
    "plt.plot(np.arange(1,nepoch+1,1),w34,color='darkgreen',label = r'$\\phi_{6}$') \n",
    "plt.plot([1,nepoch],[0,0],color='black',ls='--')\n",
    "plt.xlim([1,nepoch]); plt.ylim([-1.5,1.5]); plt.vlines(400,-1.5,1.5,color='black')\n",
    "plt.xlabel('Epochs'); plt.ylabel(r'$\\hat{y}$'); plt.title('Simple Artificial Neural Network Biases')\n",
    "add_grid(); plt.legend(loc='upper right'); plt.xscale('log')\n",
    "\n",
    "plt.subplots_adjust(left=0.0, bottom=0.0, right=3.0, top=1.0, wspace=0.2, hspace=0.2); plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5e25f0c7",
   "metadata": {},
   "source": [
    "#### ANN Visualization Dashboard\n",
    "\n",
    "Here I design the ANN display, it is quite a bit so I designed it first outside the dashboard for efficiency."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "975ec481",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "iepoch = 1\n",
    "\n",
    "dx = -0.19; dy = -0.09; edge = 1.0\n",
    "\n",
    "o6x = 17; o6y =5; h5x = 10; h5y = 3.5; h4x = 10; h4y = 6.5\n",
    "i1x = 3; i1y = 9.0; i2x = 3; i2y = 5; i3x = 3; i3y = 1.0; buffer = 0.5\n",
    "\n",
    "plt.subplot(111)\n",
    "plt.gca().set_axis_off()\n",
    "\n",
    "circle_i1 = plt.Circle((i1x,i1y), 0.25, fill=False, edgecolor = 'black',lw=2,zorder=100); plt.annotate(r' $I_1$',(i1x+dx,i1y+dy),zorder=100); \n",
    "circle_i1b = plt.Circle((i1x,i1y), 0.40, fill=True, facecolor = 'white',edgecolor = None,lw=1,zorder=10);\n",
    "plt.gca().add_patch(circle_i1); plt.gca().add_patch(circle_i1b)\n",
    "\n",
    "circle_i2 = plt.Circle((i2x,i2y), 0.25, fill=False, edgecolor = 'black',lw=2,zorder=100); plt.annotate(r' $I_2$',(i2x+dx,i2y+dy),zorder=100); \n",
    "circle_i2b = plt.Circle((i2x,i2y), 0.40, fill=True, facecolor = 'white',edgecolor = None,lw=1,zorder=10);\n",
    "plt.gca().add_patch(circle_i2); plt.gca().add_patch(circle_i2b)\n",
    "\n",
    "circle_i3 = plt.Circle((i3x,i3y), 0.25, fill=False, edgecolor = 'black',lw=2,zorder=100); plt.annotate(r' $I_3$',(i3x+dx,i3y+dy),zorder=100); \n",
    "circle_i3b = plt.Circle((i3x,i3y), 0.40, fill=True, facecolor = 'white',edgecolor = None,lw=1,zorder=10);\n",
    "plt.gca().add_patch(circle_i3); plt.gca().add_patch(circle_i3b)\n",
    "\n",
    "circle_h4 = plt.Circle((h4x,h4y), 0.25, fill=False, edgecolor = 'black',lw=2,zorder=100); plt.annotate(r'$H_4$',(h4x+dx,h4y+dy),zorder=100); \n",
    "circle_h4b = plt.Circle((h4x,h4y), 0.40, fill=True, facecolor = 'white',edgecolor = None,lw=1,zorder=10);\n",
    "plt.gca().add_patch(circle_h4); plt.gca().add_patch(circle_h4b)\n",
    "\n",
    "circle_h5 = plt.Circle((h5x,h5y), 0.25, fill=False, edgecolor = 'black',lw=2,zorder=100); plt.annotate(r'$H_5$',(h5x+dx,h5y+dy),zorder=100); \n",
    "circle_h5b = plt.Circle((h5x,h5y), 0.40, fill=True, facecolor = 'white',edgecolor = None,lw=1,zorder=10);\n",
    "plt.gca().add_patch(circle_h5); plt.gca().add_patch(circle_h5b)\n",
    "\n",
    "circle_o6 = plt.Circle((o6x,o6y), 0.25, fill=False, edgecolor = 'black',lw=2,zorder=100); plt.annotate(r'$O_6$',(o6x+dx,o6y+dy),zorder=100); \n",
    "circle_o6b = plt.Circle((o6x,o6y), 0.40, fill=True, facecolor = 'white',edgecolor = None,lw=1,zorder=10);\n",
    "plt.gca().add_patch(circle_o6); plt.gca().add_patch(circle_o6b)\n",
    "\n",
    "plt.plot([i1x-edge,i1x],[i1y,i1y],color='grey',lw=1.0,zorder=1)\n",
    "plt.plot([i2x-edge,i2x],[i2y,i2y],color='grey',lw=1.0,zorder=1)\n",
    "plt.plot([i3x-edge,i3x],[i3y,i3y],color='grey',lw=1.0,zorder=1)\n",
    "\n",
    "plt.annotate(r'$x_1$ = ' + str(np.round(x1,2)),(i1x-buffer-1.6,i1y-0.05),size=8,zorder=200,color='grey',\n",
    "             bbox=dict(boxstyle=\"round,pad=0.0\", edgecolor='white', facecolor='white', alpha=1.0),rotation=0) \n",
    "plt.annotate(r'$x_2$ = ' + str(np.round(x2,2)),(i2x-buffer-1.6,i2y-0.05),size=8,zorder=200,color='grey',\n",
    "             bbox=dict(boxstyle=\"round,pad=0.0\", edgecolor='white', facecolor='white', alpha=1.0),rotation=0) \n",
    "plt.annotate(r'$x_3$ = ' + str(np.round(x3,2)),(i3x-buffer-1.6,i3y-0.05),size=8,zorder=200,color='grey',\n",
    "             bbox=dict(boxstyle=\"round,pad=0.0\", edgecolor='white', facecolor='white', alpha=1.0),rotation=0) \n",
    "\n",
    "plt.plot([i1x,h4x],[i1y,h4y],color='lightcoral',lw=1.0,zorder=1)\n",
    "plt.plot([i2x,h4x],[i2y,h4y],color='red',lw=1.0,zorder=1)\n",
    "plt.plot([i3x,h4x],[i3y,h4y],color='darkred',lw=1.0,zorder=1)\n",
    "\n",
    "plt.plot([i1x,h5x],[i1y,h5y],color='dodgerblue',lw=1.0,zorder=1)\n",
    "plt.plot([i2x,h5x],[i2y,h5y],color='blue',lw=1.0,zorder=1)\n",
    "plt.plot([i3x,h5x],[i3y,h5y],color='darkblue',lw=1.0,zorder=1)\n",
    "\n",
    "plt.plot([h4x,o6x],[h4y,o6y],color='orange',lw=1.0,zorder=1)\n",
    "plt.plot([h5x,o6x],[h5y,o6y],color='darkorange',lw=1.0,zorder=1)\n",
    "\n",
    "plt.plot([o6x+edge,o6x],[o6y,o6y],color='grey',lw=1.0,zorder=1)\n",
    "plt.annotate(r'$\\hat{y}$ = ' + str(np.round(y6[iepoch],2)),(o6x+buffer+0.7,o6y-0.05),size=8,zorder=200,color='grey',\n",
    "             bbox=dict(boxstyle=\"round,pad=0.0\", edgecolor='white', facecolor='white', alpha=1.0),rotation=0) \n",
    "\n",
    "plt.plot(offsetx(h4x,2,-12),offsety(h4y,2,-12)+0.1,color='orange',lw=1.0,zorder=1)\n",
    "plt.plot(offset_arrx(h4x,2,-12,0.2),offset_arry(h4y,2,-12,0.2)+0.1,color='orange',lw=1.0,zorder=1)\n",
    "plt.annotate(r'$H_{4}$ = ' + str(np.round(y4[iepoch],2)),(lintx(h4x,h4y,o6x,o6y,0.08),linty(h4x,h4y,o6x,o6y,0.08)-0.0),size=8,zorder=200,color='orange',\n",
    "             bbox=dict(boxstyle=\"round,pad=0.0\", edgecolor='white', facecolor='white', alpha=1.0),rotation=-12)\n",
    "\n",
    "plt.plot(offsetx(h5x,2,12),offsety(h5y,2,12)+0.1,color='darkorange',lw=1.0,zorder=1)\n",
    "plt.plot(offset_arrx(h5x,2,12,0.2),offset_arry(h5y,2,12,0.2)+0.1,color='darkorange',lw=1.0,zorder=1)\n",
    "plt.annotate(r'$H_{5}$ = ' + str(np.round(y5[iepoch],2)),(lintx(h5x,h5y,o6x,o6y,0.07),linty(h5x,h5y,o6x,o6y,0.07)+0.25),size=8,zorder=200,color='darkorange',\n",
    "             bbox=dict(boxstyle=\"round,pad=0.0\", edgecolor='white', facecolor='white', alpha=1.0),rotation=12)\n",
    "\n",
    "plt.annotate(r'$\\frac{\\partial P}{\\partial O_{6_{in}}}$ = ' + str(np.round(d6[iepoch],2)),(o6x-0.5,o6y-0.7),size=10)\n",
    "plt.annotate(r'$\\frac{\\partial P}{\\partial H_{4_{in}}}$ = ' + str(np.round(d4[iepoch],2)),(h4x-0.5,h4y-0.7),size=10)\n",
    "plt.annotate(r'$\\frac{\\partial P}{\\partial H_{5_{in}}}$ = ' + str(np.round(d5[iepoch],2)),(h5x-0.5,h5y-0.7),size=10)\n",
    "\n",
    "plt.annotate(r'$\\frac{\\partial P}{\\partial \\hat{y}}$ = ' + str(np.round(d6[iepoch],2)),(o6x,o6y-1.2),size=10)\n",
    "plt.annotate(r'$\\frac{\\partial P}{\\partial H_{4_{out}}}$ = ' + str(np.round(w46[iepoch]*d6[iepoch],2)),(h4x,h4y-1.2),size=10)\n",
    "plt.annotate(r'$\\frac{\\partial P}{\\partial H_{5_{out}}}$ = ' + str(np.round(w56[iepoch]*d6[iepoch],2)),(h5x,h5y-1.2),size=10)\n",
    "\n",
    "plt.plot(lint_intx(h4x, h4y, o6x, o6y,0.4,0.6),lint_inty(h4x,h4y,o6x,o6y,0.4,0.6)-0.1,color='orange',lw=1.0,zorder=1)\n",
    "plt.plot(lint_int_arrx(o6x,o6y,h4x,h4y,0.4,0.6,0.2),lint_int_arry(o6x,o6y,h4x,h4y,0.4,0.6,0.2)-0.1,color='orange',lw=1.0,zorder=1)\n",
    "plt.annotate(r'$\\frac{\\partial P}{\\partial \\lambda_{4,6}}$ = ' + str(np.round(dw46[iepoch]/lr,4)),(lintx(h4x,h4y,o6x,o6y,0.5)-0.6,linty(h4x,h4y,o6x,o6y,0.5)-0.72),size=10,zorder=200,color='orange',\n",
    "              bbox=dict(boxstyle=\"round,pad=0.0\", edgecolor='white', facecolor='white', alpha=1.0),rotation=-11)\n",
    "\n",
    "plt.plot(lint_intx(h5x, h5y, o6x, o6y,0.4,0.6),lint_inty(h5x,h5y,o6x,o6y,0.4,0.6)-0.1,color='darkorange',lw=1.0,zorder=1)\n",
    "plt.plot(lint_int_arrx(o6x,o6y,h5x,h5y,0.4,0.6,0.2),lint_int_arry(o6x,o6y,h5x,h5y,0.4,0.6,0.2)-0.1,color='darkorange',lw=1.0,zorder=1)\n",
    "plt.annotate(r'$\\frac{\\partial P}{\\partial \\lambda_{5,6}}$ = ' + str(np.round(dw56[iepoch]/lr,4)),(lintx(h5x,h5y,o6x,o6y,0.5)-0.4,linty(h5x,h5y,o6x,o6y,0.5)-0.6),size=10,zorder=200,color='darkorange',\n",
    "              bbox=dict(boxstyle=\"round,pad=0.0\", edgecolor='white', facecolor='white', alpha=1.0),rotation=12)\n",
    "\n",
    "plt.plot(offsetx(i1x,2,-20),offsety(i1y,2,-20)+0.1,color='lightcoral',lw=1.0,zorder=1)\n",
    "plt.plot(offset_arrx(i1x,2,-20,0.2),offset_arry(i1y,2,-20,0.2)+0.1,color='lightcoral',lw=1.0,zorder=1)\n",
    "plt.annotate(r'$I_{1}$ = ' + str(np.round(x1,2)),(lintx(i1x,i1y,h4x,h4y,0.1),linty(i1x,i1y,h4x,h4y,0.1)),size=8,zorder=200,color='lightcoral',\n",
    "             bbox=dict(boxstyle=\"round,pad=0.0\", edgecolor='white', facecolor='white', alpha=1.0),rotation=-20)\n",
    "\n",
    "plt.plot(offsetx(i2x,2,12),offsety(i2y,2,12)+0.1,color='red',lw=1.0,zorder=1)\n",
    "plt.plot(offset_arrx(i2x,2,12,0.2),offset_arry(i2y,2,12,0.2)+0.1,color='red',lw=1.0,zorder=1)\n",
    "plt.annotate(r'$I_{2}$ = ' + str(np.round(x2,2)),(lintx(i2x,i2y,h4x,h4y,0.1),linty(i2x,i2y,h4x,h4y,0.1)+0.22),size=8,zorder=200,color='red',\n",
    "             bbox=dict(boxstyle=\"round,pad=0.0\", edgecolor='white', facecolor='white', alpha=1.0),rotation=12)\n",
    "\n",
    "plt.plot(offsetx(i3x,2,38),offsety(i3y,2,38)+0.1,color='darkred',lw=1.0,zorder=1)\n",
    "plt.plot(offset_arrx(i3x,2,38,0.2),offset_arry(i3y,2,38,0.2)+0.1,color='darkred',lw=1.0,zorder=1)\n",
    "plt.annotate(r'$I_{3}$ = ' + str(np.round(x3,2)),(lintx(i3x,i3y,h4x,h4y,0.08)-0.2,linty(i3x,i3y,h4x,h4y,0.08)+0.2),size=8,zorder=200,color='darkred',\n",
    "             bbox=dict(boxstyle=\"round,pad=0.0\", edgecolor='white', facecolor='white', alpha=1.0),rotation=38)\n",
    "\n",
    "plt.annotate(r'$\\lambda_{1,4}$ = ' + str(np.round(w14[iepoch],2)),((i1x+h4x)*0.45,(i1y+h4y)*0.5-0.05),size=8,zorder=200,color='lightcoral',\n",
    "             bbox=dict(boxstyle=\"round,pad=0.0\", edgecolor='white', facecolor='white', alpha=1.0),rotation=-18) \n",
    "plt.annotate(r'$\\lambda_{2,4}$ = ' + str(np.round(w24[iepoch],2)),((i2x+h4x)*0.45-0.3,(i2y+h4y)*0.5-0.03),size=8,zorder=200,color='red',\n",
    "             bbox=dict(boxstyle=\"round,pad=0.0\", edgecolor='white', facecolor='white', alpha=1.0),rotation=10) \n",
    "plt.annotate(r'$\\lambda_{3,4}$ = ' + str(np.round(w34[iepoch],2)),((i3x+h4x)*0.45-1.2,(i3y+h4y)*0.5-1.1),size=8,zorder=200,color='darkred',\n",
    "             bbox=dict(boxstyle=\"round,pad=0.0\", edgecolor='white', facecolor='white', alpha=1.0),rotation=38) \n",
    "\n",
    "plt.annotate(r'$\\lambda_{1,5}$ = ' + str(np.round(w15[iepoch],2)),((i1x+h5x)*0.55-2.5,(i1y+h5y)*0.5+0.9),size=8,zorder=200,color='dodgerblue',\n",
    "    bbox=dict(boxstyle=\"round,pad=0.0\", edgecolor='white', facecolor='white', alpha=1.0),rotation=-36) \n",
    "plt.annotate(r'$\\lambda_{2,5}$ = ' + str(np.round(w25[iepoch],2)),((i2x+h5x)*0.55-1.5,(i2y+h5y)*0.5+0.05),size=8,zorder=200,color='blue',\n",
    "             bbox=dict(boxstyle=\"round,pad=0.0\", edgecolor='white', facecolor='white', alpha=1.0),rotation=-12) \n",
    "plt.annotate(r'$\\lambda_{3,5}$ = ' + str(np.round(w35[iepoch],2)),((i3x+h5x)*0.55-1.0,(i3y+h5y)*0.5+0.1),size=8,zorder=200,color='darkblue',\n",
    "             bbox=dict(boxstyle=\"round,pad=0.0\", edgecolor='white', facecolor='white', alpha=1.0),rotation=20) \n",
    "\n",
    "plt.annotate(r'$\\lambda_{4,6}$ = ' + str(np.round(w46[iepoch],2)),((h4x+o6x)*0.47,(h4y+o6y)*0.47+0.39),size=8,zorder=200,color='orange',\n",
    "    bbox=dict(boxstyle=\"round,pad=0.0\", edgecolor='white', facecolor='white', alpha=1.0),rotation=-12) \n",
    "plt.annotate(r'$\\lambda_{5,6}$ = ' + str(np.round(w56[iepoch],2)),((h5x+o6x)*0.47,(h5y+o6y)*0.47+0.26),size=8,zorder=200,color='darkorange',\n",
    "    bbox=dict(boxstyle=\"round,pad=0.0\", edgecolor='white', facecolor='white', alpha=1.0),rotation=12) \n",
    "\n",
    "plt.plot(lint_intx(i1x, i1y, h4x, h4y,0.4,0.6),lint_inty(i1x,i1y,h4x,h4y,0.4,0.6)-0.1,color='lightcoral',lw=1.0,zorder=1)\n",
    "plt.plot(lint_int_arrx(h4x,h4y,i1x,i1y,0.4,0.6,0.2),lint_int_arry(h4x,h4y,i1x,i1y,0.4,0.6,0.2)-0.1,color='lightcoral',lw=1.0,zorder=1)\n",
    "plt.annotate(r'$\\frac{\\partial P}{\\partial \\lambda_{1,4}} =$' + r'${0:s}$'.format(as_si(dw14[iepoch]/lr,2)),(lintx(i1x,i1y,h4x,h4y,0.5)-0.6,linty(i1x,i1y,h4x,h4y,0.5)-1.0),size=8,zorder=200,color='lightcoral',\n",
    "              bbox=dict(boxstyle=\"round,pad=0.0\", edgecolor='white', facecolor='white', alpha=1.0),rotation=-20)\n",
    "\n",
    "plt.plot(lint_intx(i2x, i2y, h4x, h4y,0.3,0.5),lint_inty(i2x,i2y,h4x,h4y,0.3,0.5)-0.1,color='red',lw=1.0,zorder=1)\n",
    "plt.plot(lint_int_arrx(h4x,h4y,i2x,i2y,0.5,0.7,0.2),lint_int_arry(h4x,h4y,i2x,i2y,0.5,0.7,0.2)-0.12,color='red',lw=1.0,zorder=1)\n",
    "plt.annotate(r'$\\frac{\\partial P}{\\partial \\lambda_{2,4}} =$' + r'${0:s}$'.format(as_si(dw24[iepoch]/lr,2)),(lintx(i2x,i2y,h4x,h4y,0.5)-1.05,linty(i2x,i2y,h4x,h4y,0.5)-0.7),size=8,zorder=200,color='red',\n",
    "              bbox=dict(boxstyle=\"round,pad=0.0\", edgecolor='white', facecolor='white', alpha=1.0),rotation=12)\n",
    "\n",
    "plt.plot(lint_intx(i3x, i3y, h4x, h4y,0.2,0.4),lint_inty(i3x,i3y,h4x,h4y,0.2,0.4)-0.1,color='darkred',lw=1.0,zorder=1)\n",
    "plt.plot(lint_int_arrx(h4x,h4y,i3x,i3y,0.5,0.8,0.2),lint_int_arry(h4x,h4y,i3x,i3y,0.5,0.8,0.2)-0.12,color='darkred',lw=1.0,zorder=1)\n",
    "plt.annotate(r'$\\frac{\\partial P}{\\partial \\lambda_{3,4}} =$' + r'${0:s}$'.format(as_si(dw34[iepoch]/lr,2)),(lintx(i3x,i3y,h4x,h4y,0.5)-1.7,linty(i3x,i3y,h4x,h4y,0.5)-1.7),size=8,zorder=200,color='darkred',\n",
    "              bbox=dict(boxstyle=\"round,pad=0.0\", edgecolor='white', facecolor='white', alpha=1.0),rotation=38)\n",
    "\n",
    "plt.plot(lint_intx(i3x, i3y, h5x, h5y,0.4,0.6),lint_inty(i3x,i3y,h5x,h5y,0.4,0.6)-0.1,color='darkblue',lw=1.0,zorder=1)\n",
    "plt.plot(lint_int_arrx(h5x,h5y,i3x,i3y,0.4,0.6,0.2),lint_int_arry(h5x,h5y,i3x,i3y,0.4,0.6,0.2)-0.12,color='darkblue',lw=1.0,zorder=1)\n",
    "plt.annotate(r'$\\frac{\\partial P}{\\partial \\lambda_{3,5}} =$' + r'${0:s}$'.format(as_si(dw35[iepoch]/lr,2)),(lintx(i3x,i3y,h5x,h5y,0.5)-0.4,linty(i3x,i3y,h5x,h5y,0.5)-0.6),size=8,zorder=200,color='darkblue',\n",
    "              bbox=dict(boxstyle=\"round,pad=0.0\", edgecolor='white', facecolor='white', alpha=1.0),rotation=20)\n",
    "\n",
    "plt.plot(lint_intx(i2x, i2y, h5x, h5y,0.3,0.5),lint_inty(i2x,i2y,h5x,h5y,0.3,0.5)-0.1,color='blue',lw=1.0,zorder=1)\n",
    "plt.plot(lint_int_arrx(h5x,h5y,i2x,i2y,0.3,0.7,0.2),lint_int_arry(h5x,h5y,i2x,i2y,0.3,0.7,0.2)-0.12,color='blue',lw=1.0,zorder=1)\n",
    "plt.annotate(r'$\\frac{\\partial P}{\\partial \\lambda_{2,5}} =$' + r'${0:s}$'.format(as_si(dw25[iepoch]/lr,2)),(lintx(i2x,i2y,h5x,h5y,0.5)-1.2,linty(i2x,i2y,h5x,h5y,0.5)-0.65),size=8,zorder=200,color='blue',\n",
    "              bbox=dict(boxstyle=\"round,pad=0.0\", edgecolor='white', facecolor='white', alpha=1.0),rotation=-12)\n",
    "\n",
    "plt.plot(lint_intx(i1x, i1y, h5x, h5y,0.2,0.4),lint_inty(i1x,i1y,h5x,h5y,0.2,0.4)-0.1,color='dodgerblue',lw=1.0,zorder=1)\n",
    "plt.plot(lint_int_arrx(h5x,h5y,i1x,i1y,0.2,0.8,0.2),lint_int_arry(h5x,h5y,i1x,i1y,0.2,0.8,0.2)-0.12,color='dodgerblue',lw=1.0,zorder=1)\n",
    "plt.annotate(r'$\\frac{\\partial P}{\\partial \\lambda_{1,5}} =$' + r'${0:s}$'.format(as_si(dw15[iepoch]/lr,2)),(lintx(i1x,i1y,h5x,h5y,0.5)-2.2,linty(i1x,i1y,h4x,h4y,0.5)-1.5),size=8,zorder=200,color='dodgerblue',\n",
    "              bbox=dict(boxstyle=\"round,pad=0.0\", edgecolor='white', facecolor='white', alpha=1.0),rotation=-36,xycoords = 'data')\n",
    "\n",
    "plt.subplots_adjust(left=0.0, bottom=0.0, right=1.5, top=1.0, wspace=0.2, hspace=0.2); plt.show()\n",
    "\n",
    "\n",
    "#plt.annotate(r'$\\frac{\\partial P}{\\partial \\lambda_{1,5}}$ = {0:s}$'.format(as_si(dw15[iepoch]/lr,2))' + str(np.round(dw15[iepoch]/lr,4)),(lintx(i1x,i1y,h5x,h5y,0.5)-2.3,linty(i1x,i1y,h4x,h4y,0.5)-1.6),size=10,zorder=200,color='dodgerblue',\n",
    "\n",
    "# plt.xlim([0,20]); plt.ylim([0,10])\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "cf37b61d",
   "metadata": {},
   "source": [
    "#### Interactive Artificial Neural Network (ANN)\n",
    "\n",
    "The interactive inputs include:\n",
    "\n",
    "* **$n_{epoch}$** - number of cycles through the data, coupled forward prediction and back propagation\n",
    "\n",
    "* **$lr$** - learning rate, applied to the weight and bias derivatives"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "d270c12b",
   "metadata": {},
   "outputs": [],
   "source": [
    "# widgets and dashboard\n",
    "l = widgets.Text(value='                                             Machine Learning Simple Artificial Neural Network, Prof. Michael Pyrcz, The University of Texas at Austin',layout=Layout(width='950px', height='30px'))\n",
    "\n",
    "nepoch = widgets.IntSlider(min=0, max = 100, value=0, step = 1, description = '$n_{epoch}$',orientation='horizontal', style = {'description_width': 'initial'},\n",
    "                           continuous_update=False,layout=Layout(width='400px', height='30px'))\n",
    "\n",
    "lr = widgets.FloatLogSlider(min=-5, max = 0, value=-4, step = 0.1, description = '$lr$',orientation='horizontal', style = {'description_width': 'initial'},\n",
    "                           continuous_update=False,layout=Layout(width='400px', height='30px'))\n",
    "\n",
    "ui1 = widgets.HBox([nepoch,lr],)\n",
    "ui = widgets.VBox([l,ui1],)\n",
    "\n",
    "def run_plot(nepoch,lr):                       # make data, fit models and plot\n",
    "    iepoch = nepoch\n",
    "    np.random.seed(seed=seed)\n",
    "    x1 = 0.5; x2 = 0.2; x3 = 0.7; y = 0.3 # training data\n",
    "    \n",
    "    np.random.seed(seed=seed)\n",
    "    \n",
    "    nepoch = 1000\n",
    "    \n",
    "    y4 = np.zeros(nepoch); y5 = np.zeros(nepoch); y6 = np.zeros(nepoch)\n",
    "    \n",
    "    w14 = np.zeros(nepoch); w24 = np.zeros(nepoch); w34 = np.zeros(nepoch)\n",
    "    w15 = np.zeros(nepoch); w25 = np.zeros(nepoch); w35 = np.zeros(nepoch)\n",
    "    w46 = np.zeros(nepoch); w56 = np.zeros(nepoch)\n",
    "    \n",
    "    dw14 = np.zeros(nepoch); dw24 = np.zeros(nepoch); dw34 = np.zeros(nepoch)\n",
    "    dw15 = np.zeros(nepoch); dw25 = np.zeros(nepoch); dw35 = np.zeros(nepoch)\n",
    "    dw46 = np.zeros(nepoch); dw56 = np.zeros(nepoch)\n",
    "    \n",
    "    db4 = np.zeros(nepoch); db5 = np.zeros(nepoch); db6 = np.zeros(nepoch)\n",
    "    \n",
    "    b4 = np.zeros(nepoch); b5 = np.zeros(nepoch); b6 = np.zeros(nepoch)\n",
    "    y4 = np.zeros(nepoch); y5 = np.zeros(nepoch); y6 = np.zeros(nepoch)\n",
    "    d4 = np.zeros(nepoch); d5 = np.zeros(nepoch); d6 = np.zeros(nepoch)\n",
    "    \n",
    "    # initialize the weights and biases\n",
    "    w14[0] = np.random.random(); w24[0] = np.random.random(); w34[0] = np.random.random()\n",
    "    w15[0] = np.random.random(); w25[0] = np.random.random(); w35[0] = np.random.random()\n",
    "    w46[0] = np.random.random(); w56[0] = np.random.random()\n",
    "    b4[0] = np.random.random(); b5[0] = np.random.random(); b6[0] = np.random.random()\n",
    "    \n",
    "    for i in range(0,nepoch):\n",
    "    \n",
    "    # forward pass of model\n",
    "        y4[i] = w14[i]*x1 + w24[i]*x2 + w34[i]*x3 + b4[i]; \n",
    "        y4[i] = 1.0/(1 + math.exp(-1*y4[i]))\n",
    "        \n",
    "        y5[i] = w15[i]*x1 + w25[i]*x2 + w35[i]*x3 + b5[i]\n",
    "        y5[i] = 1.0/(1 + math.exp(-1*y5[i]))\n",
    "        \n",
    "        y6[i] = w46[i]*y4[i] + w56[i]*y5[i] + b6[i]\n",
    "    #    y6[i] = 1.0/(1 + math.exp(-1*y6[i])) # sgimoid / logistic activation at o6 \n",
    "    \n",
    "    # back propagate the error through the nodes\n",
    "    #    d6[i] = y6[i]*(1-y6[i])*(y-y6[i]) # sgimoid / logistic activation at o6 \n",
    "        d6[i] = (y-y6[i]) # identity activation o at o6\n",
    "        d5[i] = y5[i]*(1-y5[i])*w56[i]*d6[i]; d4[i] = y4[i]*(1-y4[i])*w46[i]*d6[i]\n",
    "    \n",
    "    # calculate the change in weights\n",
    "        if i < nepoch - 1:\n",
    "            dw14[i] = lr*d4[i]*x1; dw24[i] = lr*d4[i]*x2; dw34[i] = lr*d4[i]*x3 \n",
    "            dw15[i] = lr*d5[i]*x1; dw25[i] = lr*d5[i]*x2; dw35[i] = lr*d5[i]*x3\n",
    "            dw46[i] = lr*d6[i]*y4[i]; dw56[i] = lr*d6[i]*y5[i] \n",
    "            \n",
    "            db4[i] = lr*d4[i]; db5[i] = lr*d5[i]; db6[i] = lr*d6[i];\n",
    "    \n",
    "            w14[i+1] = w14[i] + dw14[i]; w24[i+1] = w24[i] + dw24[i]; w34[i+1] = w34[i] + dw34[i] \n",
    "            w15[i+1] = w15[i] + dw15[i]; w25[i+1] = w25[i] + dw25[i]; w35[i+1] = w35[i] + dw35[i] \n",
    "            w46[i+1] = w46[i] + dw46[i]; w56[i+1] = w56[i] + dw56[i]\n",
    "    \n",
    "            b4[i+1] = b4[i] + db4[i]; b5[i+1] = b5[i] + db5[i]; b6[i+1] = b6[i] + db6[i] \n",
    "    \n",
    "    dx = -0.21; dy = -0.09; edge = 1.0\n",
    "    \n",
    "    o6x = 17; o6y =5; h5x = 10; h5y = 3.5; h4x = 10; h4y = 6.5\n",
    "    i1x = 3; i1y = 9.0; i2x = 3; i2y = 5; i3x = 3; i3y = 1.0; buffer = 0.5\n",
    "    \n",
    "    plt.subplot(111)\n",
    "    plt.gca().set_axis_off()\n",
    "    \n",
    "    circle_i1 = plt.Circle((i1x,i1y), 0.25, fill=False, edgecolor = 'black',lw=2,zorder=100); plt.annotate(r' $I_1$',(i1x+dx,i1y+dy),zorder=100); \n",
    "    circle_i1b = plt.Circle((i1x,i1y), 0.40, fill=True, facecolor = 'white',edgecolor = None,lw=1,zorder=10);\n",
    "    plt.gca().add_patch(circle_i1); plt.gca().add_patch(circle_i1b)\n",
    "    \n",
    "    circle_i2 = plt.Circle((i2x,i2y), 0.25, fill=False, edgecolor = 'black',lw=2,zorder=100); plt.annotate(r' $I_2$',(i2x+dx,i2y+dy),zorder=100); \n",
    "    circle_i2b = plt.Circle((i2x,i2y), 0.40, fill=True, facecolor = 'white',edgecolor = None,lw=1,zorder=10);\n",
    "    plt.gca().add_patch(circle_i2); plt.gca().add_patch(circle_i2b)\n",
    "    \n",
    "    circle_i3 = plt.Circle((i3x,i3y), 0.25, fill=False, edgecolor = 'black',lw=2,zorder=100); plt.annotate(r' $I_3$',(i3x+dx,i3y+dy),zorder=100); \n",
    "    circle_i3b = plt.Circle((i3x,i3y), 0.40, fill=True, facecolor = 'white',edgecolor = None,lw=1,zorder=10);\n",
    "    plt.gca().add_patch(circle_i3); plt.gca().add_patch(circle_i3b)\n",
    "    \n",
    "    circle_h4 = plt.Circle((h4x,h4y), 0.25, fill=False, edgecolor = 'black',lw=2,zorder=100); plt.annotate(r'$H_4$',(h4x+dx,h4y+dy),zorder=100); \n",
    "    circle_h4b = plt.Circle((h4x,h4y), 0.40, fill=True, facecolor = 'white',edgecolor = None,lw=1,zorder=10);\n",
    "    plt.gca().add_patch(circle_h4); plt.gca().add_patch(circle_h4b)\n",
    "    \n",
    "    circle_h5 = plt.Circle((h5x,h5y), 0.25, fill=False, edgecolor = 'black',lw=2,zorder=100); plt.annotate(r'$H_5$',(h5x+dx,h5y+dy),zorder=100); \n",
    "    circle_h5b = plt.Circle((h5x,h5y), 0.40, fill=True, facecolor = 'white',edgecolor = None,lw=1,zorder=10);\n",
    "    plt.gca().add_patch(circle_h5); plt.gca().add_patch(circle_h5b)\n",
    "    \n",
    "    circle_o6 = plt.Circle((o6x,o6y), 0.25, fill=False, edgecolor = 'black',lw=2,zorder=100); plt.annotate(r'$O_6$',(o6x+dx,o6y+dy),zorder=100); \n",
    "    circle_o6b = plt.Circle((o6x,o6y), 0.40, fill=True, facecolor = 'white',edgecolor = None,lw=1,zorder=10);\n",
    "    plt.gca().add_patch(circle_o6); plt.gca().add_patch(circle_o6b)\n",
    "    \n",
    "    plt.plot([i1x-edge,i1x],[i1y,i1y],color='grey',lw=1.0,zorder=1)\n",
    "    plt.plot([i2x-edge,i2x],[i2y,i2y],color='grey',lw=1.0,zorder=1)\n",
    "    plt.plot([i3x-edge,i3x],[i3y,i3y],color='grey',lw=1.0,zorder=1)\n",
    "    \n",
    "    plt.annotate(r'$x_1$ = ' + str(np.round(x1,2)),(i1x-buffer-1.6,i1y-0.05),size=8,zorder=200,color='grey',\n",
    "                 bbox=dict(boxstyle=\"round,pad=0.0\", edgecolor='white', facecolor='white', alpha=1.0),rotation=0,ha='left') \n",
    "    plt.annotate(r'$x_2$ = ' + str(np.round(x2,2)),(i2x-buffer-1.6,i2y-0.05),size=8,zorder=200,color='grey',\n",
    "                 bbox=dict(boxstyle=\"round,pad=0.0\", edgecolor='white', facecolor='white', alpha=1.0),rotation=0) \n",
    "    plt.annotate(r'$x_3$ = ' + str(np.round(x3,2)),(i3x-buffer-1.6,i3y-0.05),size=8,zorder=200,color='grey',\n",
    "                 bbox=dict(boxstyle=\"round,pad=0.0\", edgecolor='white', facecolor='white', alpha=1.0),rotation=0) \n",
    "    \n",
    "    plt.plot([i1x,h4x],[i1y,h4y],color='lightcoral',lw=1.0,zorder=1)\n",
    "    plt.plot([i2x,h4x],[i2y,h4y],color='red',lw=1.0,zorder=1)\n",
    "    plt.plot([i3x,h4x],[i3y,h4y],color='darkred',lw=1.0,zorder=1)\n",
    "    \n",
    "    plt.plot([i1x,h5x],[i1y,h5y],color='dodgerblue',lw=1.0,zorder=1)\n",
    "    plt.plot([i2x,h5x],[i2y,h5y],color='blue',lw=1.0,zorder=1)\n",
    "    plt.plot([i3x,h5x],[i3y,h5y],color='darkblue',lw=1.0,zorder=1)\n",
    "    \n",
    "    plt.plot([h4x,o6x],[h4y,o6y],color='orange',lw=1.0,zorder=1)\n",
    "    plt.plot([h5x,o6x],[h5y,o6y],color='darkorange',lw=1.0,zorder=1)\n",
    "    \n",
    "    plt.plot([o6x+edge,o6x],[o6y,o6y],color='grey',lw=1.0,zorder=1)\n",
    "    plt.annotate(r'$\\hat{y}$ = ' + str(np.round(y6[iepoch],2)),(o6x+buffer+0.7,o6y-0.05),size=8,zorder=200,color='grey',\n",
    "                 bbox=dict(boxstyle=\"round,pad=0.0\", edgecolor='white', facecolor='white', alpha=1.0),rotation=0) \n",
    "    \n",
    "    plt.plot(offsetx(h4x,2,-12),offsety(h4y,2,-12)+0.1,color='orange',lw=1.0,zorder=1)\n",
    "    plt.plot(offset_arrx(h4x,2,-12,0.2),offset_arry(h4y,2,-12,0.2)+0.1,color='orange',lw=1.0,zorder=1)\n",
    "    plt.annotate(r'$H_{4}$ = ' + str(np.round(y4[iepoch],2)),(lintx(h4x,h4y,o6x,o6y,0.08),linty(h4x,h4y,o6x,o6y,0.08)-0.0),size=8,zorder=200,color='orange',\n",
    "                 bbox=dict(boxstyle=\"round,pad=0.0\", edgecolor='white', facecolor='white', alpha=1.0),rotation=-12)\n",
    "    \n",
    "    plt.plot(offsetx(h5x,2,12),offsety(h5y,2,12)+0.1,color='darkorange',lw=1.0,zorder=1)\n",
    "    plt.plot(offset_arrx(h5x,2,12,0.2),offset_arry(h5y,2,12,0.2)+0.1,color='darkorange',lw=1.0,zorder=1)\n",
    "    plt.annotate(r'$H_{5}$ = ' + str(np.round(y5[iepoch],2)),(lintx(h5x,h5y,o6x,o6y,0.07),linty(h5x,h5y,o6x,o6y,0.07)+0.25),size=8,zorder=200,color='darkorange',\n",
    "                 bbox=dict(boxstyle=\"round,pad=0.0\", edgecolor='white', facecolor='white', alpha=1.0),rotation=12)\n",
    "    \n",
    "    plt.annotate(r'$\\frac{\\partial P}{\\partial O_{6_{in}}}$ = ' + str(np.round(d6[iepoch],2)),(o6x-0.5,o6y-0.7),size=10)\n",
    "    plt.annotate(r'$\\frac{\\partial P}{\\partial H_{4_{in}}}$ = ' + str(np.round(d4[iepoch],2)),(h4x-0.5,h4y-0.7),size=10)\n",
    "    plt.annotate(r'$\\frac{\\partial P}{\\partial H_{5_{in}}}$ = ' + str(np.round(d5[iepoch],2)),(h5x-0.5,h5y-0.7),size=10)\n",
    "    \n",
    "    plt.annotate(r'$\\frac{\\partial P}{\\partial \\hat{y}}$ = ' + str(np.round(d6[iepoch],2)),(o6x,o6y-1.2),size=10)\n",
    "    plt.annotate(r'$\\frac{\\partial P}{\\partial H_{4_{out}}}$ = ' + str(np.round(w46[iepoch]*d6[iepoch],2)),(h4x,h4y-1.2),size=10)\n",
    "    plt.annotate(r'$\\frac{\\partial P}{\\partial H_{5_{out}}}$ = ' + str(np.round(w56[iepoch]*d6[iepoch],2)),(h5x,h5y-1.2),size=10)\n",
    "    \n",
    "    plt.plot(lint_intx(h4x, h4y, o6x, o6y,0.4,0.6),lint_inty(h4x,h4y,o6x,o6y,0.4,0.6)-0.1,color='orange',lw=1.0,zorder=1)\n",
    "    plt.plot(lint_int_arrx(o6x,o6y,h4x,h4y,0.4,0.6,0.2),lint_int_arry(o6x,o6y,h4x,h4y,0.4,0.6,0.2)-0.1,color='orange',lw=1.0,zorder=1)\n",
    "    plt.annotate(r'$\\frac{\\partial P}{\\partial \\lambda_{4,6}} =$' + r'${0:s}$'.format(as_si(dw46[iepoch]/lr,2)),(lintx(h4x,h4y,o6x,o6y,0.5)-0.6,linty(h4x,h4y,o6x,o6y,0.5)-0.72),size=7,zorder=200,color='orange',\n",
    "                  bbox=dict(boxstyle=\"round,pad=0.0\", edgecolor='white', facecolor='white', alpha=1.0),rotation=-11)\n",
    "    \n",
    "    plt.plot(lint_intx(h5x, h5y, o6x, o6y,0.4,0.6),lint_inty(h5x,h5y,o6x,o6y,0.4,0.6)-0.1,color='darkorange',lw=1.0,zorder=1)\n",
    "    plt.plot(lint_int_arrx(o6x,o6y,h5x,h5y,0.4,0.6,0.2),lint_int_arry(o6x,o6y,h5x,h5y,0.4,0.6,0.2)-0.1,color='darkorange',lw=1.0,zorder=1)\n",
    "    plt.annotate(r'$\\frac{\\partial P}{\\partial \\lambda_{5,6}} =$' + r'${0:s}$'.format(as_si(dw56[iepoch]/lr,2)),(lintx(h5x,h5y,o6x,o6y,0.5)-0.4,linty(h5x,h5y,o6x,o6y,0.5)-0.6),size=7,zorder=200,color='darkorange',\n",
    "                  bbox=dict(boxstyle=\"round,pad=0.0\", edgecolor='white', facecolor='white', alpha=1.0),rotation=12)\n",
    "    \n",
    "    plt.plot(offsetx(i1x,2,-20),offsety(i1y,2,-20)+0.1,color='lightcoral',lw=1.0,zorder=1)\n",
    "    plt.plot(offset_arrx(i1x,2,-20,0.2),offset_arry(i1y,2,-20,0.2)+0.1,color='lightcoral',lw=1.0,zorder=1)\n",
    "    plt.annotate(r'$I_{1}$ = ' + str(np.round(x1,2)),(lintx(i1x,i1y,h4x,h4y,0.1),linty(i1x,i1y,h4x,h4y,0.1)),size=8,zorder=200,color='lightcoral',\n",
    "                 bbox=dict(boxstyle=\"round,pad=0.0\", edgecolor='white', facecolor='white', alpha=1.0),rotation=-20)\n",
    "    \n",
    "    plt.plot(offsetx(i2x,2,12),offsety(i2y,2,12)+0.1,color='red',lw=1.0,zorder=1)\n",
    "    plt.plot(offset_arrx(i2x,2,12,0.2),offset_arry(i2y,2,12,0.2)+0.1,color='red',lw=1.0,zorder=1)\n",
    "    plt.annotate(r'$I_{2}$ = ' + str(np.round(x2,2)),(lintx(i2x,i2y,h4x,h4y,0.1),linty(i2x,i2y,h4x,h4y,0.1)+0.22),size=8,zorder=200,color='red',\n",
    "                 bbox=dict(boxstyle=\"round,pad=0.0\", edgecolor='white', facecolor='white', alpha=1.0),rotation=12)\n",
    "    \n",
    "    plt.plot(offsetx(i3x,2,38),offsety(i3y,2,38)+0.1,color='darkred',lw=1.0,zorder=1)\n",
    "    plt.plot(offset_arrx(i3x,2,38,0.2),offset_arry(i3y,2,38,0.2)+0.1,color='darkred',lw=1.0,zorder=1)\n",
    "    plt.annotate(r'$I_{3}$ = ' + str(np.round(x3,2)),(lintx(i3x,i3y,h4x,h4y,0.08)-0.2,linty(i3x,i3y,h4x,h4y,0.08)+0.2),size=8,zorder=200,color='darkred',\n",
    "                 bbox=dict(boxstyle=\"round,pad=0.0\", edgecolor='white', facecolor='white', alpha=1.0),rotation=38)\n",
    "    \n",
    "    plt.annotate(r'$\\lambda_{1,4}$ = ' + str(np.round(w14[iepoch],2)),((i1x+h4x)*0.45,(i1y+h4y)*0.5-0.05),size=8,zorder=200,color='lightcoral',\n",
    "                 bbox=dict(boxstyle=\"round,pad=0.0\", edgecolor='white', facecolor='white', alpha=1.0),rotation=-18) \n",
    "    plt.annotate(r'$\\lambda_{2,4}$ = ' + str(np.round(w24[iepoch],2)),((i2x+h4x)*0.45-0.3,(i2y+h4y)*0.5-0.03),size=8,zorder=200,color='red',\n",
    "                 bbox=dict(boxstyle=\"round,pad=0.0\", edgecolor='white', facecolor='white', alpha=1.0),rotation=12) \n",
    "    plt.annotate(r'$\\lambda_{3,4}$ = ' + str(np.round(w34[iepoch],2)),((i3x+h4x)*0.45-1.2,(i3y+h4y)*0.5-1.1),size=8,zorder=200,color='darkred',\n",
    "                 bbox=dict(boxstyle=\"round,pad=0.0\", edgecolor='white', facecolor='white', alpha=1.0),rotation=38) \n",
    "    \n",
    "    plt.annotate(r'$\\lambda_{1,5}$ = ' + str(np.round(w15[iepoch],2)),((i1x+h5x)*0.55-2.5,(i1y+h5y)*0.5+0.9),size=8,zorder=200,color='dodgerblue',\n",
    "        bbox=dict(boxstyle=\"round,pad=0.0\", edgecolor='white', facecolor='white', alpha=1.0),rotation=-36) \n",
    "    plt.annotate(r'$\\lambda_{2,5}$ = ' + str(np.round(w25[iepoch],2)),((i2x+h5x)*0.55-1.5,(i2y+h5y)*0.5+0.05),size=8,zorder=200,color='blue',\n",
    "                 bbox=dict(boxstyle=\"round,pad=0.0\", edgecolor='white', facecolor='white', alpha=1.0),rotation=-12) \n",
    "    plt.annotate(r'$\\lambda_{3,5}$ = ' + str(np.round(w35[iepoch],2)),((i3x+h5x)*0.55-1.0,(i3y+h5y)*0.5+0.1),size=8,zorder=200,color='darkblue',\n",
    "                 bbox=dict(boxstyle=\"round,pad=0.0\", edgecolor='white', facecolor='white', alpha=1.0),rotation=18) \n",
    "    \n",
    "    plt.annotate(r'$\\lambda_{4,6}$ = ' + str(np.round(w46[iepoch],2)),((h4x+o6x)*0.47,(h4y+o6y)*0.47+0.39),size=8,zorder=200,color='orange',\n",
    "        bbox=dict(boxstyle=\"round,pad=0.0\", edgecolor='white', facecolor='white', alpha=1.0),rotation=-12) \n",
    "    plt.annotate(r'$\\lambda_{5,6}$ = ' + str(np.round(w56[iepoch],2)),((h5x+o6x)*0.47,(h5y+o6y)*0.47+0.26),size=8,zorder=200,color='darkorange',\n",
    "        bbox=dict(boxstyle=\"round,pad=0.0\", edgecolor='white', facecolor='white', alpha=1.0),rotation=12) \n",
    "    \n",
    "    plt.plot(lint_intx(i1x, i1y, h4x, h4y,0.4,0.6),lint_inty(i1x,i1y,h4x,h4y,0.4,0.6)-0.1,color='lightcoral',lw=1.0,zorder=1)\n",
    "    plt.plot(lint_int_arrx(h4x,h4y,i1x,i1y,0.4,0.6,0.2),lint_int_arry(h4x,h4y,i1x,i1y,0.4,0.6,0.2)-0.1,color='lightcoral',lw=1.0,zorder=1)\n",
    "    plt.annotate(r'$\\frac{\\partial P}{\\partial \\lambda_{1,4}} =$' + r'${0:s}$'.format(as_si(dw14[iepoch]/lr,2)),(lintx(i1x,i1y,h4x,h4y,0.5)-0.6,linty(i1x,i1y,h4x,h4y,0.5)-1.0),size=7,zorder=200,color='lightcoral',\n",
    "                  bbox=dict(boxstyle=\"round,pad=0.0\", edgecolor='white', facecolor='white', alpha=1.0),rotation=-20)\n",
    "    \n",
    "    plt.plot(lint_intx(i2x, i2y, h4x, h4y,0.3,0.5),lint_inty(i2x,i2y,h4x,h4y,0.3,0.5)-0.1,color='red',lw=1.0,zorder=1)\n",
    "    plt.plot(lint_int_arrx(h4x,h4y,i2x,i2y,0.5,0.7,0.2),lint_int_arry(h4x,h4y,i2x,i2y,0.5,0.7,0.2)-0.12,color='red',lw=1.0,zorder=1)\n",
    "    plt.annotate(r'$\\frac{\\partial P}{\\partial \\lambda_{2,4}} =$' + r'${0:s}$'.format(as_si(dw24[iepoch]/lr,2)),(lintx(i2x,i2y,h4x,h4y,0.5)-1.05,linty(i2x,i2y,h4x,h4y,0.5)-0.7),size=7,zorder=200,color='red',\n",
    "                  bbox=dict(boxstyle=\"round,pad=0.0\", edgecolor='white', facecolor='white', alpha=1.0),rotation=12)\n",
    "    \n",
    "    plt.plot(lint_intx(i3x, i3y, h4x, h4y,0.2,0.4),lint_inty(i3x,i3y,h4x,h4y,0.2,0.4)-0.1,color='darkred',lw=1.0,zorder=1)\n",
    "    plt.plot(lint_int_arrx(h4x,h4y,i3x,i3y,0.5,0.8,0.2),lint_int_arry(h4x,h4y,i3x,i3y,0.5,0.8,0.2)-0.12,color='darkred',lw=1.0,zorder=1)\n",
    "    plt.annotate(r'$\\frac{\\partial P}{\\partial \\lambda_{3,4}} =$' + r'${0:s}$'.format(as_si(dw34[iepoch]/lr,2)),(lintx(i3x,i3y,h4x,h4y,0.5)-1.7,linty(i3x,i3y,h4x,h4y,0.5)-1.7),size=7,zorder=200,color='darkred',\n",
    "                  bbox=dict(boxstyle=\"round,pad=0.0\", edgecolor='white', facecolor='white', alpha=1.0),rotation=38)\n",
    "    \n",
    "    plt.plot(lint_intx(i3x, i3y, h5x, h5y,0.4,0.6),lint_inty(i3x,i3y,h5x,h5y,0.4,0.6)-0.1,color='darkblue',lw=1.0,zorder=1)\n",
    "    plt.plot(lint_int_arrx(h5x,h5y,i3x,i3y,0.4,0.6,0.2),lint_int_arry(h5x,h5y,i3x,i3y,0.4,0.6,0.2)-0.12,color='darkblue',lw=1.0,zorder=1)\n",
    "    plt.annotate(r'$\\frac{\\partial P}{\\partial \\lambda_{3,5}} =$' + r'${0:s}$'.format(as_si(dw35[iepoch]/lr,2)),(lintx(i3x,i3y,h5x,h5y,0.5)-0.4,linty(i3x,i3y,h5x,h5y,0.5)-0.6),size=7,zorder=200,color='darkblue',\n",
    "                  bbox=dict(boxstyle=\"round,pad=0.0\", edgecolor='white', facecolor='white', alpha=1.0),rotation=20)\n",
    "    \n",
    "    plt.plot(lint_intx(i2x, i2y, h5x, h5y,0.3,0.5),lint_inty(i2x,i2y,h5x,h5y,0.3,0.5)-0.1,color='blue',lw=1.0,zorder=1)\n",
    "    plt.plot(lint_int_arrx(h5x,h5y,i2x,i2y,0.3,0.7,0.2),lint_int_arry(h5x,h5y,i2x,i2y,0.3,0.7,0.2)-0.12,color='blue',lw=1.0,zorder=1)\n",
    "    plt.annotate(r'$\\frac{\\partial P}{\\partial \\lambda_{2,5}} =$' + r'${0:s}$'.format(as_si(dw25[iepoch]/lr,2)),(lintx(i2x,i2y,h5x,h5y,0.5)-1.2,linty(i2x,i2y,h5x,h5y,0.5)-0.65),size=7,zorder=200,color='blue',\n",
    "                  bbox=dict(boxstyle=\"round,pad=0.0\", edgecolor='white', facecolor='white', alpha=1.0),rotation=-12)\n",
    "    \n",
    "    plt.plot(lint_intx(i1x, i1y, h5x, h5y,0.2,0.4),lint_inty(i1x,i1y,h5x,h5y,0.2,0.4)-0.1,color='dodgerblue',lw=1.0,zorder=1)\n",
    "    plt.plot(lint_int_arrx(h5x,h5y,i1x,i1y,0.2,0.8,0.2),lint_int_arry(h5x,h5y,i1x,i1y,0.2,0.8,0.2)-0.12,color='dodgerblue',lw=1.0,zorder=1)\n",
    "    plt.annotate(r'$\\frac{\\partial P}{\\partial \\lambda_{1,5}} =$' + r'${0:s}$'.format(as_si(dw15[iepoch]/lr,2)),(lintx(i1x,i1y,h5x,h5y,0.5)-2.2,linty(i1x,i1y,h4x,h4y,0.5)-0.2),size=7,zorder=200,color='dodgerblue',\n",
    "                  bbox=dict(boxstyle=\"round,pad=0.0\", edgecolor='white', facecolor='white', alpha=1.0),rotation=-36,xycoords = 'data',va=\"top\",ha=\"left\")\n",
    "    \n",
    "    plt.plot([0.5,20,20,0.5,0.5],[0,0,10,10,0],color='black')\n",
    "    #plt.scatter(0,10,color='yellow')\n",
    "    \n",
    "    plt.subplots_adjust(left=0.0, bottom=0.0, right=1.5, top=1.0, wspace=0.2, hspace=0.2); plt.show()\n",
    "       \n",
    "# connect the function to make the samples and plot to the widgets    \n",
    "interactive_plot = widgets.interactive_output(run_plot, {'nepoch':nepoch,'lr':lr})\n",
    "interactive_plot.clear_output(wait = True)               # reduce flickering by delaying plot updating   "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "873fbf10",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "722d6adfe51c490fbfc1898511b56792",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "VBox(children=(Text(value='                                             Machine Learning Simple Artificial Neu…"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "e9d7acbdc0b347008e5d98f33b222c28",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Output()"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "display(ui, interactive_plot)                           # display the interactive plot"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d1b27996",
   "metadata": {},
   "source": [
    "#### Comments\n",
    "\n",
    "This was an interactive demonstration of a simple artifial neural network. Providing students an opportunity to play with machine learning, deep learning for experiential learning.\n",
    "  \n",
    "#### The Author:\n",
    "\n",
    "### Michael Pyrcz, Professor, The University of Texas at Austin \n",
    "*Novel Data Analytics, Geostatistics and Machine Learning Subsurface Solutions*\n",
    "\n",
    "With over 17 years of experience in subsurface consulting, research and development, Michael has returned to academia driven by his passion for teaching and enthusiasm for enhancing engineers' and geoscientists' impact in subsurface resource development. \n",
    "\n",
    "For more about Michael check out these links:\n",
    "\n",
    "#### [Twitter](https://twitter.com/geostatsguy) | [GitHub](https://github.com/GeostatsGuy) | [Website](http://michaelpyrcz.com) | [GoogleScholar](https://scholar.google.com/citations?user=QVZ20eQAAAAJ&hl=en&oi=ao) | [Book](https://www.amazon.com/Geostatistical-Reservoir-Modeling-Michael-Pyrcz/dp/0199731446) | [YouTube](https://www.youtube.com/channel/UCLqEr-xV-ceHdXXXrTId5ig)  | [LinkedIn](https://www.linkedin.com/in/michael-pyrcz-61a648a1)\n",
    "\n",
    "#### Want to Work Together?\n",
    "\n",
    "I hope this content is helpful to those that want to learn more about subsurface modeling, data analytics and machine learning. Students and working professionals are welcome to participate.\n",
    "\n",
    "* Want to invite me to visit your company for training, mentoring, project review, workflow design and / or consulting? I'd be happy to drop by and work with you! \n",
    "\n",
    "* Interested in partnering, supporting my graduate student research or my Subsurface Data Analytics and Machine Learning consortium (co-PIs including Profs. Foster, Torres-Verdin and van Oort)? My research combines data analytics, stochastic modeling and machine learning theory with practice to develop novel methods and workflows to add value. We are solving challenging subsurface problems!\n",
    "\n",
    "* I can be reached at mpyrcz@austin.utexas.edu.\n",
    "\n",
    "I'm always happy to discuss,\n",
    "\n",
    "*Michael*\n",
    "\n",
    "Michael Pyrcz, Ph.D., P.Eng. Professor, Cockrell School of Engineering and The Jackson School of Geosciences, The University of Texas at Austin\n",
    "\n",
    "#### More Resources Available at: [Twitter](https://twitter.com/geostatsguy) | [GitHub](https://github.com/GeostatsGuy) | [Website](http://michaelpyrcz.com) | [GoogleScholar](https://scholar.google.com/citations?user=QVZ20eQAAAAJ&hl=en&oi=ao) | [Book](https://www.amazon.com/Geostatistical-Reservoir-Modeling-Michael-Pyrcz/dp/0199731446) | [YouTube](https://www.youtube.com/channel/UCLqEr-xV-ceHdXXXrTId5ig)  | [LinkedIn](https://www.linkedin.com/in/michael-pyrcz-61a648a1)  \n",
    "  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "82cd5982",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "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.11.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}