9_Backpropagation.ipynb

{
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/glopez21/Deep-Learning-Intro/blob/main/9_Backpropagation.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "P4Iks8wdK-sT"
      },
      "source": [
        "# Training Neural Networks\n",
        "\n",
        "Backpropagation [[Cite:rumelhart1986learning]](https://www.iro.umontreal.ca/~vincentp/ift3395/lectures/backprop_old.pdf) is one of the most common methods for training a neural network. Rumelhart, Hinton, & Williams introduced backpropagation, and it remains popular today. Programmers frequently train deep neural networks with backpropagation because it scales really well when run on graphical processing units (GPUs). To understand this algorithm for neural networks, we must examine how to train it as well as how it processes a pattern.\n",
        "\n",
        "Researchers have extended classic backpropagation and modified to give rise to many different training algorithms. This section will discuss the most commonly used training algorithms for neural networks. We begin with classic backpropagation and end the chapter with stochastic gradient descent (SGD).\n",
        "\n",
        "Backpropagation is the primary means of determining a neural network's weights during training. Backpropagation works by calculating a weight change amount ($v_t$) for every weight($\\theta$, theta) in the neural network. This value is subtracted from every weight by the following equation: \n",
        "\n",
        "$$ \\theta_t = \\theta_{t-1} - v_t $$\n",
        "\n",
        "We repeat this process for every iteration($t$). The training algorithm determines how we calculate the weight change. Classic backpropagation calculates a gradient ($\\nabla$, nabla) for every weight in the neural network for the neural network's error function ($J$). We scale the gradient by a learning rate ($\\eta$, eta).\n",
        "\n",
        "$$ v_t = \\eta \\nabla_{\\theta_{t-1}} J(\\theta_{t-1}) $$\n",
        "\n",
        "The learning rate is an important concept for backpropagation training. Setting the learning rate can be complex:\n",
        "\n",
        "* Too low a learning rate will usually converge to a reasonable solution; however, the process will be prolonged.\n",
        "* Too high of a learning rate will either fail outright or converge to a higher error than a better learning rate.\n",
        "\n",
        "Common values for learning rate are: 0.1, 0.01, 0.001, etc.\n",
        "\n",
        "Backpropagation is a gradient descent type, and many texts will use these two terms interchangeably. Gradient descent refers to calculating a gradient on each weight in the neural network for each training element. Because the neural network will not output the expected value for a training element, the gradient of each weight will indicate how to modify each weight to achieve the expected output. If the neural network did output exactly what was expected, the gradient for each weight would be 0, indicating that no change to the weight is necessary.\n",
        "\n",
        "The gradient is the derivative of the error function at the weight's current value. The error function measures the distance of the neural network's output from the expected output. We can use gradient descent, a process in which each weight's gradient value can reach even lower values of the error function. \n",
        "  \n",
        "The gradient is the partial derivative of each weight in the neural network concerning the error function. Each weight has a gradient that is the slope of the error function. Weight is a connection between two neurons. Calculating the gradient of the error function allows the training method to determine whether it should increase or decrease the weight. In turn, this determination will decrease the error of the neural network. The error is the difference between the expected output and actual output of the neural network. Many different training methods called propagation-training algorithms utilize gradients. In all of them, the sign of the gradient tells the neural network the following information:\n",
        "\n",
        "* Zero gradient - The weight does not contribute to the neural network's error.\n",
        "* Negative gradient - The algorithm should increase the weight to lower error.\n",
        "* Positive gradient - The algorithm should decrease the weight to lower error.\n",
        "\n",
        "\n",
        "Because many algorithms depend on gradient calculation, we will begin with an analysis of this process. First of all, let's examine the gradient. Essentially, training is a search for the set of weights that will cause the neural network to have the lowest error for a training set. If we had infinite computation resources, we would try every possible combination of weights to determine the one that provided the lowest error during the training. \n",
        "\n",
        "Because we do not have unlimited computing resources, we have to use some shortcuts to prevent the need to examine every possible weight combination. These training methods utilize clever techniques to avoid performing a brute-force search of all weight values. This type of exhaustive search would be impossible because even small networks have an infinite number of weight combinations.\n",
        "\n",
        "Consider a chart that shows the error of a neural network for each possible weight. Figure 4.DRV is a graph that demonstrates the error for a single weight:\n",
        "\n",
        "**Figure 4.DRV: Derivative**\n",
        "![Derivative](https://raw.githubusercontent.com/jeffheaton/t81_558_deep_learning/master/images/class_2_deriv.png \"Derivative\")\n",
        "\n",
        "Looking at this chart, you can easily see that the optimal weight is where the line has the lowest y-value. The problem is that we see only the error for the current value of the weight; we do not see the entire graph because that process would require an exhaustive search. However, we can determine the slope of the error curve at a particular weight. In the above chart, we see the slope of the error curve at 1.5. The straight line barely touches the error curve at 1.5 gives the slope. In this case, the slope, or gradient, is -0.5622. The negative slope indicates that an increase in the weight will lower the error.\n",
        "The gradient is the instantaneous slope of the error function at the specified weight. The derivative of the error curve at that point gives the gradient. This line tells us the steepness of the error function at the given weight.  \n",
        "Derivatives are one of the most fundamental concepts in calculus. For this book, you need to understand that a derivative provides the slope of a function at a specific point. A training technique and this slope can give you the information to adjust the weight for a lower error. Using our working definition of the gradient, we will show how to calculate it.\n",
        "\n",
        "## Momentum Backpropagation\n",
        "\n",
        "Momentum adds another term to the calculation of $v_t$:\n",
        "\n",
        "$$ v_t = \\eta \\nabla_{\\theta_{t-1}} J(\\theta_{t-1}) + \\lambda v_{t-1} $$\n",
        "\n",
        "Like the learning rate, momentum adds another training parameter that scales the effect of momentum. Momentum backpropagation has two training parameters: learning rate ($\\eta$, eta) and momentum ($\\lambda$, lambda). Momentum adds the scaled value of the previous weight change amount ($v_{t-1}$) to the current weight change amount($v_t$).\n",
        "\n",
        "This technique has the effect of adding additional force behind the direction a weight is moving. Figure 4.MTM shows how this might allow the weight to escape local minima.\n",
        "\n",
        "**Figure 4.MTM: Momentum**\n",
        "![Momentum](https://raw.githubusercontent.com/jeffheaton/t81_558_deep_learning/master/images/class_5_momentum.png \"Momentum\")\n",
        "\n",
        "A typical value for momentum is 0.9.\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "fGYYeUKrK-sT"
      },
      "source": [
        "## Batch and Online Backpropagation\n",
        "\n",
        "How often should the weights of a neural network be updated?  We can calculate gradients for a training set element.  These gradients can also be summed together into batches, and the weights updated once per batch.\n",
        "\n",
        "* **Online Training** - Update the weights based on gradients calculated from a single training set element.\n",
        "* **Batch Training** - Update the weights based on the sum of the gradients over all training set elements.\n",
        "* **Batch Size** - Update the weights based on the sum of some batch size of training set elements.\n",
        "* **Mini-Batch Training** - The same as batch size, but with minimal batch size.  Mini-batches are very popular, often in the 32-64 element range.\n",
        "\n",
        "Because the batch size is smaller than the full training set size, it may take several batches to make it completely through the training set.  \n",
        "\n",
        "* **Step/Iteration** - The number of processed batches.\n",
        "* **Epoch** - The number of times the algorithm processed the complete training set.\n",
        "\n",
        "## Stochastic Gradient Descent\n",
        "\n",
        "Stochastic gradient descent (SGD) is currently one of the most popular neural network training algorithms.  It works very similarly to Batch/Mini-Batch training, except that the batches are made up of a random set of training elements.\n",
        "\n",
        "This technique leads to a very irregular convergence in error during training, as shown in Figure 4.SGD.\n",
        "\n",
        "**Figure 4.SGD: SGD Error**\n",
        "![SGD Error](https://raw.githubusercontent.com/jeffheaton/t81_558_deep_learning/master/images/class_5_sgd_error.png \"SGD Error\")\n",
        "[Image from Wikipedia](https://en.wikipedia.org/wiki/Stochastic_gradient_descent)\n",
        "\n",
        "Because the neural network is trained on a random sample of the complete training set each time, the error does not make a smooth transition downward.  However, the error usually does go down.\n",
        "\n",
        "Advantages to SGD include:\n",
        "\n",
        "* Computationally efficient.  Each training step can be relatively fast, even with a huge training set.\n",
        "* Decreases overfitting by focusing on only a portion of the training set each step.\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "0DjBXCMFK-sT"
      },
      "source": [
        "## Other Techniques\n",
        "\n",
        "One problem with simple backpropagation training algorithms is that they are susceptible to learning rate and momentum. This technique is difficult because:\n",
        "\n",
        "* Learning rate must be adjusted to a small enough level to train an accurate neural network.\n",
        "* Momentum must be large enough to overcome local minima yet small enough not to destabilize the training.\n",
        "* A single learning rate/momentum is often not good enough for the entire training process. It is often helpful to automatically decrease the learning rate as the training progresses.\n",
        "* All weights share a single learning rate/momentum.\n",
        "\n",
        "Other training techniques:\n",
        "\n",
        "* **Resilient Propagation** - Use only the magnitude of the gradient and allow each neuron to learn at its rate. There is no need for learning rate/momentum; however, it only works in full batch mode.\n",
        "* **Nesterov accelerated gradient** - Helps mitigate the risk of choosing a bad mini-batch.\n",
        "* **Adagrad** - Allows an automatically decaying per-weight learning rate and momentum concept.\n",
        "* **Adadelta** - Extension of Adagrad that seeks to reduce its aggressive, monotonically decreasing learning rate.\n",
        "* **Non-Gradient Methods** - Non-gradient methods can *sometimes* be useful, though rarely outperform gradient-based backpropagation methods.  These include: [simulated annealing](https://en.wikipedia.org/wiki/Simulated_annealing), [genetic algorithms](https://en.wikipedia.org/wiki/Genetic_algorithm), [particle swarm optimization](https://en.wikipedia.org/wiki/Particle_swarm_optimization), [Nelder Mead](https://en.wikipedia.org/wiki/Nelder%E2%80%93Mead_method), and [many more](https://en.wikipedia.org/wiki/Category:Optimization_algorithms_and_methods)."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "FH_YF1HYK-sT"
      },
      "source": [
        "## ADAM Update\n",
        "\n",
        "ADAM is the first training algorithm you should try.  It is very effective.  Kingma and Ba (2014) introduced the Adam update rule that derives its name from the adaptive moment estimates. [[Cite:kingma2014adam]](https://arxiv.org/abs/1412.6980)  Adam estimates the first (mean) and second (variance) moments to determine the weight corrections.  Adam begins with an exponentially decaying average of past gradients (m):\n",
        "\n",
        "$$ m_t = \\beta_1 m_{t-1} + (1-\\beta_1) g_t $$\n",
        "\n",
        "This average accomplishes a similar goal as classic momentum update; however, its value is calculated automatically based on the current gradient ($g_t$).  The update rule then calculates the second moment ($v_t$):\n",
        "\n",
        "$$ v_t = \\beta_2 v_{t-1} + (1-\\beta_2) g_t^2 $$\n",
        "\n",
        "The values $m_t$ and $v_t$ are estimates of the gradients' first moment (the mean) and the second moment (the uncentered variance).  However, they will be strongly biased towards zero in the initial training cycles.  The first moment’s bias is corrected as follows.\n",
        "\n",
        "$$ \\hat{m}_t = \\frac{m_t}{1-\\beta^t_1} $$\n",
        "\n",
        "Similarly, the second moment is also corrected:\n",
        "\n",
        "$$ \\hat{v}_t = \\frac{v_t}{1-\\beta_2^t} $$\n",
        "\n",
        "These bias-corrected first and second moment estimates are applied to the ultimate Adam update rule, as follows:\n",
        "\n",
        "$$ \\theta_t = \\theta_{t-1} - \\frac{\\alpha \\cdot \\hat{m}_t}{\\sqrt{\\hat{v}_t}+\\eta} \\hat{m}_t $$\n",
        "\n",
        "Adam is very tolerant to initial learning rate (\\alpha) and other training parameters. Kingma and Ba (2014)  propose default values of 0.9 for $\\beta_1$, 0.999 for $\\beta_2$, and 10-8 for $\\eta$."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Qwp7eYOnK-sU"
      },
      "source": [
        "## Methods Compared\n",
        "\n",
        "The following image shows how each of these algorithms train. It is animated, so it is not displayed in the printed book, but can be accessed from here: [https://bit.ly/3kykkbn](https://bit.ly/3kykkbn).\n",
        "\n",
        "![Training Techniques](https://raw.githubusercontent.com/jeffheaton/t81_558_deep_learning/master/images/contours_evaluation_optimizers.gif \"Training Techniques\")\n",
        "Image credits: [Alec Radford](https://scholar.google.com/citations?user=dOad5HoAAAAJ&hl=en)\n",
        "\n",
        "## Specifying the Update Rule in Keras\n",
        "\n",
        "TensorFlow allows the update rule to be set to one of:\n",
        "\n",
        "* Adagrad\n",
        "* **Adam**\n",
        "* Ftrl\n",
        "* Momentum\n",
        "* RMSProp\n",
        "* **SGD**"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "import pandas as pd\n",
        "import seaborn as sns\n",
        "import matplotlib.pyplot as plt\n",
        "\n",
        "from tensorflow.keras.models import Sequential\n",
        "from tensorflow.keras.layers import Dense, Activation\n",
        "from tensorflow.keras.callbacks import EarlyStopping\n",
        "from scipy.stats import zscore\n",
        "from sklearn.model_selection import train_test_split\n",
        "\n",
        "sns.set()"
      ],
      "metadata": {
        "id": "R1gRHYhXLHpD"
      },
      "execution_count": 1,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Regression chart.\n",
        "def chart_regression(pred, y, sort=True):\n",
        "    t = pd.DataFrame({'pred': pred, 'y': y.flatten()})\n",
        "    if sort:\n",
        "        t.sort_values(by=['y'], inplace=True)\n",
        "    plt.plot(t['y'].tolist(), label='expected')\n",
        "    plt.plot(t['pred'].tolist(), label='prediction')\n",
        "    plt.ylabel('output')\n",
        "    plt.legend()\n",
        "    plt.show()"
      ],
      "metadata": {
        "id": "L1SwAlkfLHfN"
      },
      "execution_count": 2,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Read the data set\n",
        "df = pd.read_csv('https://raw.githubusercontent.com/glopez21/Deep-Learning-Intro/main/data/job-simple-dataset.csv', na_values=['NA','?'])"
      ],
      "metadata": {
        "id": "RjvtAnyyLHa0"
      },
      "execution_count": 3,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Generate dummies for job\n",
        "df = pd.concat([df,pd.get_dummies(df['job'],prefix=\"job\")],axis=1)\n",
        "df.drop('job', axis=1, inplace=True)"
      ],
      "metadata": {
        "id": "oKjVameqLfci"
      },
      "execution_count": 4,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Generate dummies for area\n",
        "df = pd.concat([df,pd.get_dummies(df['area'],prefix=\"area\")],axis=1)\n",
        "df.drop('area', axis=1, inplace=True)"
      ],
      "metadata": {
        "id": "Q-GlZEV-LfYw"
      },
      "execution_count": 5,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Generate dummies for product\n",
        "df = pd.concat([df,pd.get_dummies(df['product'],prefix=\"product\")],axis=1)\n",
        "df.drop('product', axis=1, inplace=True)"
      ],
      "metadata": {
        "id": "dljGtiCJLfVo"
      },
      "execution_count": 6,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Missing values for income\n",
        "med = df['income'].median()\n",
        "df['income'] = df['income'].fillna(med)"
      ],
      "metadata": {
        "id": "ex8H43BvLlI2"
      },
      "execution_count": 7,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Standardize ranges\n",
        "df['income'] = zscore(df['income'])\n",
        "df['aspect'] = zscore(df['aspect'])\n",
        "df['save_rate'] = zscore(df['save_rate'])\n",
        "df['subscriptions'] = zscore(df['subscriptions'])"
      ],
      "metadata": {
        "id": "A27IYZP5LlFM"
      },
      "execution_count": 8,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Convert to numpy - Classification\n",
        "x_columns = df.columns.drop('age').drop('id')\n",
        "x = df[x_columns].values\n",
        "y = df['age'].values"
      ],
      "metadata": {
        "id": "GLPgkurNLozs"
      },
      "execution_count": 9,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Create train/test\n",
        "x_train, x_test, y_train, y_test = train_test_split(x, y, test_size=0.25, random_state=42)"
      ],
      "metadata": {
        "id": "yfxTUb7vLowc"
      },
      "execution_count": 10,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Build the neural network\n",
        "model = Sequential()\n",
        "model.add(Dense(25, input_dim=x.shape[1], activation='relu')) # Hidden 1\n",
        "model.add(Dense(10, activation='relu')) # Hidden 2\n",
        "model.add(Dense(1)) # Output\n",
        "model.compile(loss='mean_squared_error', optimizer='adam') # Modify here\n",
        "monitor = EarlyStopping(monitor='val_loss', min_delta=1e-3, patience=5, verbose=1, mode='auto', restore_best_weights=True)"
      ],
      "metadata": {
        "id": "kYG3hdERLq15"
      },
      "execution_count": 11,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "model.fit(x_train,y_train,validation_data=(x_test,y_test), callbacks=[monitor], verbose = 0, epochs = 1000)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "bgTq-GM5Lqyq",
        "outputId": "a9fb7c41-e9d6-4c75-dd5e-eafca4acb39b"
      },
      "execution_count": 12,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Restoring model weights from the end of the best epoch: 105.\n",
            "Epoch 110: early stopping\n"
          ]
        },
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<keras.callbacks.History at 0x7f21d4dc0a90>"
            ]
          },
          "metadata": {},
          "execution_count": 12
        }
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 13,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 285
        },
        "id": "6OgRyfTvK-sU",
        "outputId": "ca320e28-03f7-493d-b3b3-c7aa66a4d639"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "16/16 [==============================] - 0s 2ms/step\n"
          ]
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        }
      ],
      "source": [
        "# Plot the chart\n",
        "pred = model.predict(x_test)\n",
        "chart_regression(pred.flatten(),y_test)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "aEm49S9VK-sV"
      },
      "outputs": [],
      "source": []
    }
  ],
  "metadata": {
    "anaconda-cloud": {},
    "kernelspec": {
      "display_name": "Python 3.9 (tensorflow)",
      "language": "python",
      "name": "tensorflow"
    },
    "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.9.7"
    },
    "varInspector": {
      "cols": {
        "lenName": 16,
        "lenType": 16,
        "lenVar": 40
      },
      "kernels_config": {
        "python": {
          "delete_cmd_postfix": "",
          "delete_cmd_prefix": "del ",
          "library": "var_list.py",
          "varRefreshCmd": "print(var_dic_list())"
        },
        "r": {
          "delete_cmd_postfix": ") ",
          "delete_cmd_prefix": "rm(",
          "library": "var_list.r",
          "varRefreshCmd": "cat(var_dic_list()) "
        }
      },
      "types_to_exclude": [
        "module",
        "function",
        "builtin_function_or_method",
        "instance",
        "_Feature"
      ],
      "window_display": false
    },
    "colab": {
      "provenance": [],
      "include_colab_link": true
    }
  },
  "nbformat": 4,
  "nbformat_minor": 0
}