double_digits_with_MNIST.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "double_digits with MNIST.ipynb",
      "provenance": [],
      "collapsed_sections": []
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    }
  },
  "cells": [
    {
      "cell_type": "code",
      "metadata": {
        "id": "wDlWLbfkJtvu",
        "cellView": "form"
      },
      "source": [
        "#@title Everything not mine is copyright 2020 Google LLC and others.  Dbl-click for more information.\n",
        "# Licensed under the Apache License, Version 2.0 (the \"License\");\n",
        "# you may not use this file except in compliance with the License.\n",
        "# You may obtain a copy of the License at\n",
        "#\n",
        "# https://www.apache.org/licenses/LICENSE-2.0\n",
        "#\n",
        "# Unless required by applicable law or agreed to in writing, software\n",
        "# distributed under the License is distributed on an \"AS IS\" BASIS,\n",
        "# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n",
        "# See the License for the specific language governing permissions and\n",
        "# limitations under the License.\n",
        "\n",
        "# Yann LeCun and Corinna Cortes hold the copyright of MNIST dataset,\n",
        "# which is a derivative work from original NIST datasets. \n",
        "# MNIST dataset is made available under the terms of the \n",
        "# Creative Commons Attribution-Share Alike 3.0 license."
      ],
      "execution_count": 10,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "9SBux8qWSzPz"
      },
      "source": [
        "**This Notebook is heavily modified from the MLCC programming project with single-digit images here:**\n",
        "\n",
        "https://colab.research.google.com/github/google/eng-edu/blob/master/ml/cc/exercises/multi-class_classification_with_MNIST.ipynb"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "cxj8yVh4mFl5"
      },
      "source": [
        "**[Taken from the original MLCC \"project\" with single digit images. I will start with these images and then merge them together, pixel-array by pixel-array, to create a new train/test set of 100 double-digit images.]**"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "9n9_cTveKmse",
        "cellView": "both",
        "outputId": "e676dd71-cf06-4991-b261-47caca69ba6e",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        }
      },
      "source": [
        "# load some standard utilities.\n",
        "\n",
        "import time\n",
        "import random as rd\n",
        "import numpy as np\n",
        "import pandas as pd\n",
        "import tensorflow as tf\n",
        "from tensorflow.keras import layers\n",
        "from matplotlib import pyplot as plt\n",
        "from IPython import display\n",
        "from IPython.display import clear_output\n",
        "# The following lines adjust the granularity of reporting. \n",
        "pd.options.display.max_rows = 10\n",
        "pd.options.display.float_format = \"{:.3f}\".format\n",
        "\n",
        "# The following line improves formatting when ouputting NumPy arrays.\n",
        "np.set_printoptions(linewidth = 200)\n",
        "\n",
        "print(\"Loaded modules.\")"
      ],
      "execution_count": 11,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Loaded modules.\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "vtiZY8eEQR4T"
      },
      "source": [
        "## Variables\n",
        "\n",
        "N = 40000\n",
        "image_size = (imheight, imwidth) = (28,56)"
      ],
      "execution_count": 16,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "JZlvdpyYKx7V",
        "cellView": "both"
      },
      "source": [
        "# load the dataset.\n",
        "(x_train, y_train),(x_test, y_test) = tf.keras.datasets.mnist.load_data()\n",
        "print(\"Loaded the train and test sets.\")"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "4JhBGDPnUtI6",
        "outputId": "2e37ef5d-4b8c-4393-fa58-52717ea66265",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 282
        }
      },
      "source": [
        "#images = x_train.copy()\n",
        "im = np.zeros((28,28))\n",
        "tens = rd.choice(range(images.shape[0])) \n",
        "dubs = images[tens].T\n",
        "for i in range(28):\n",
        "        im[:,i] = dubs[i]\n",
        "plt.imshow(im)"
      ],
      "execution_count": 43,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<matplotlib.image.AxesImage at 0x7f60c7a7a208>"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 43
        },
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ]
          },
          "metadata": {
            "tags": [],
            "needs_background": "light"
          }
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "6X6jzIZm1vDZ",
        "cellView": "both",
        "outputId": "6a41cf2e-9439-4255-f588-22d0281b90b3",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 318
        }
      },
      "source": [
        "# THIS FUNCTION MERGES TWO RANDOMLY CHOSEN SINGLE-DIGIT IMAGES\n",
        "# INTO ONE DOUBLE-DIGIT IMAGE REPRESENTING NUMBERS 0 TO 99.\n",
        "# THE \"CORRECT ANSWER\" FOR THE DOUBLE-DIGIT IMAGE IS CALCULATED\n",
        "# FROM THE ANSWERS GIVEN FOR THE SINGLE-DIGIT IMAGES (IN Y_TRAIN\n",
        "# AND Y_TEST).\n",
        "\n",
        "def doubleDigits(images=x_train,answers=y_train):\n",
        "    im = np.zeros(image_size)\n",
        "    tens = rd.choice(range(images.shape[0]))         # HERE IS WHERE THE \n",
        "    ones = rd.choice(range(images.shape[0]))          # RANDOM NUMS COME FROM\n",
        "    dubs = images[tens].T                    # IMAGE ON THE LEFT\n",
        "    digs = images[ones].T                      # IMAGE ON THE RIGHT\n",
        "    for i in range(28):\n",
        "        im[:,i] = dubs[i]\n",
        "        im[:,i+28] = digs[i]\n",
        "    answer = answers[tens]*10 + answers[ones] #CALCULATE THE RIGHT\n",
        "    return im, answer                         #ANSWER NUMERICALLY                \n",
        "    #returns image array, list of answers\n",
        "print(\"Loaded function doubleDigits.\")\n",
        "\n",
        "# THIS FUNCTION WILL BE CALLED TO GENERATE A NEW \n",
        "# TRAINING SET OF RANDOM DOUBLE-DIGIT IMAGES TO WORK WITH\n",
        "\n",
        "def getDoubleDigits(x_df=x_train,y_df=y_train,how_many=1):\n",
        "    '''\n",
        "        Get a trainable set of how_many double-digit images. \n",
        "        Returns two objects:\n",
        "            - xdf, an array with how_many 28x56 images (ie. of shape(how_many,28,56)),\n",
        "            - ydf, a 1D array with the corresponding labels (shape(how_many,1))\n",
        "    '''\n",
        "    yy = []\n",
        "    xx = []\n",
        "    for i in range(how_many):\n",
        "        dd, ans = doubleDigits(x_df,y_df)\n",
        "        yy += [ans]\n",
        "        xx.append(dd)\n",
        "    return xx, yy\n",
        "\n",
        "print(\"Loaded function getDoubleDigits.\")\n",
        "\n",
        "def plot_curve(epochs, hist, metric):\n",
        "  plt.figure()\n",
        "  plt.xlabel(\"Epoch\")\n",
        "  plt.ylabel(\"Value\")\n",
        "\n",
        "  x = hist[metric]\n",
        "  plt.plot(epochs[1:], x[1:], label=metric)\n",
        "\n",
        "  plt.legend()\n",
        "\n",
        "print(\"Loaded the plot_curve function to be called after training.\")\n",
        "\n",
        "# AND FINALLY CALL FUNCTION gDD TO SHOW AN EXAMPLE OF A \n",
        "# CONSTRUCTED IMAGE AND ANSWER TO MAKE SURE IT LOOKS OK\n",
        "xdf, ydf = getDoubleDigits(x_test,y_test,3)\n",
        "print('Random example:')\n",
        "print('Answer:',ydf[2])\n",
        "plt.imshow(xdf[2])\n"
      ],
      "execution_count": 44,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Loaded function doubleDigits.\n",
            "Loaded function getDoubleDigits.\n",
            "Loaded the plot_curve function to be called after training.\n",
            "Random example:\n",
            "Answer: 70\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<matplotlib.image.AxesImage at 0x7f60c7a5ba20>"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 44
        },
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ]
          },
          "metadata": {
            "tags": [],
            "needs_background": "light"
          }
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "TTEooB0awn_C",
        "cellView": "both",
        "outputId": "4b57f202-7417-4a82-cbfa-4849d4f76404",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 145
        }
      },
      "source": [
        "nrows = 1\n",
        "ncols = 4\n",
        "\n",
        "fig = plt.gcf()\n",
        "fig.set_size_inches(ncols * 4, nrows * 4) \n",
        "x_df, y_df = getDoubleDigits(x_train,y_train,4) # CALL THE gDD FUNCTION TO CONSTRUCT A NEW\n",
        "print(\"Answers:\",y_df)                          # RANDOM SAMPLE OF 4 DOUBLE-DIGIT IMAGES\n",
        "\n",
        "for i, img in enumerate(x_df):\n",
        "    splot = plt.subplot(nrows, ncols, i + 1)\n",
        "    splot.axis('Off')\n",
        "    plt.imshow(img)\n",
        "plt.show()\n"
      ],
      "execution_count": 45,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Answers: [12, 15, 21, 15]\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 1152x288 with 4 Axes>"
            ]
          },
          "metadata": {
            "tags": [],
            "needs_background": "light"
          }
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "4YQljE-wizDw",
        "outputId": "df241db3-fd70-4b01-a22c-3138d3b3ac6a",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 85
        }
      },
      "source": [
        "# HERE IS WHERE WE CONSTRUCT N DOUBLE-DIGIT IMAGES TO TRAIN ON\n",
        "# PLUS ANOTHER N//10 IMAGES TO TEST ON AFTER TRAINING.\n",
        "start = time.time()\n",
        "N = 40000\n",
        "xts, yts = getDoubleDigits(x_test,y_test,N//10)\n",
        "x_test_normalized = np.array(xts) / 255.\n",
        "y_test_norm = np.array(yts)\n",
        "print(\"Made\",N//10,\"new double-digit images to test on.\")\n",
        "print(\"Time taken: {:.3f} seconds\".format(time.time()-start))\n",
        "start = time.time()\n",
        "xtn, ytn = getDoubleDigits(x_train,y_train,N)\n",
        "x_train_normalized = np.array(xtn) / 255.\n",
        "y_train_norm = np.array(ytn)\n",
        "print(\"Made\",N,\"new double-digit images to train on.\")\n",
        "print(\"Time taken: {:.3f} seconds\".format(time.time()-start))"
      ],
      "execution_count": 53,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Made 4000 new double-digit images to test on.\n",
            "Time taken: 0.279 seconds\n",
            "Made 40000 new double-digit images to train on.\n",
            "Time taken: 2.905 seconds\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "krymMuUyB1e-"
      },
      "source": [
        "start = time.time()\n",
        "train_40000 = np.array(xtn).reshape(len(ytn),28*56)\n",
        "print(\"Time taken to reshape train: {:.3f} seconds\".format(time.time()-start))\n",
        "start = time.time()\n",
        "valid_4000 = np.array(xts).reshape(len(yts),28*56)\n",
        "print(\"Time taken to reshape test: {:.3f} seconds\".format(time.time()-start))\n",
        "start = time.time()\n",
        "train_40000 = pd.DataFrame(train_40000)\n",
        "valid_4000 = pd.DataFrame(valid_4000)\n",
        "train_40000[\"target\"] = ytn\n",
        "valid_4000[\"target\"] = yts\n",
        "train_40000.to_csv(\"doubledigits_train_40000\")\n",
        "valid_4000.to_csv(\"doubledigits_valid_4000\")\n",
        "print(\"Time taken to save to files: {:.3f} seconds\".format(time.time()-start))"
      ],
      "execution_count": 55,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "CtoZ3LzuuTLd"
      },
      "source": [
        "## Make double digits\n",
        "* make double digit images with labels 0 - 99"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "cwQbU7vbcH-B"
      },
      "source": [
        "mnist_dataframe = pd.read_csv(\n",
        "  \"https://download.mlcc.google.com/mledu-datasets/mnist_train_small.csv\",\n",
        "  sep=\",\",\n",
        "  header=None)"
      ],
      "execution_count": 68,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "JfFWWvMWDFrR",
        "colab": {}
      },
      "source": [
        "def parse_labels_and_features(dataset):\n",
        "  \"\"\"Extracts labels and features.\n",
        "  \n",
        "  This is a good place to scale or transform the features if needed.\n",
        "  \n",
        "  Args:\n",
        "    dataset: A Pandas `Dataframe`, containing the label on the first column and\n",
        "      monochrome pixel values on the remaining columns, in row major order.\n",
        "  Returns:\n",
        "    A `tuple` `(labels, features)`:\n",
        "      labels: A Pandas `Series`.\n",
        "      features: A Pandas `DataFrame`.\n",
        "  \"\"\"\n",
        "  labels = dataset[0]\n",
        "\n",
        "  # DataFrame.loc index ranges are inclusive at both ends.\n",
        "  features = dataset.loc[:,1:784]\n",
        "  # Scale the data to [0, 1] by dividing out the max value, 255.\n",
        "  features = features / 255\n",
        "\n",
        "  return labels, features"
      ],
      "execution_count": 69,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "LY2KPmO4u2f5"
      },
      "source": [
        "dd_targets, dd_examples = parse_labels_and_features(mnist_dataframe)"
      ],
      "execution_count": 70,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "cP3ne01odiKI"
      },
      "source": [
        "def getDDs(n):\n",
        "    ## slow?\n",
        "    new_examples = pd.DataFrame(columns=[r for r in range(1568)])\n",
        "    new_targets = []\n",
        "    for i in range(n):\n",
        "        left = rd.choice(dd_examples.index.values)   \n",
        "        right = rd.choice(dd_examples.index.values)\n",
        "\n",
        "        answer = dd_targets[left]*10 + dd_targets[right]\n",
        "        new_targets += [answer]\n",
        "\n",
        "        bkgrnd = np.zeros((28,56))   \n",
        "        bkgrnd[:,0:28] += dd_examples.loc[left].values.reshape((28,28))\n",
        "        bkgrnd[:,28:56] += dd_examples.loc[right].values.reshape((28,28))\n",
        "        if i%200 == 0:\n",
        "            print (\"Image\",i,\"of\",n,\"\\tLabel =\",answer)\n",
        "            display.clear_output(wait=True)\n",
        "        bkgrnd = pd.Series(bkgrnd.reshape(1568))\n",
        "        new_examples = new_examples.append(bkgrnd, ignore_index=True)\n",
        "    return pd.Series(new_targets), new_examples"
      ],
      "execution_count": 71,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "mFY_-7vZu8UU",
        "outputId": "21fee910-ec2d-4c3e-b28d-c2b37c68139b",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 51
        }
      },
      "source": [
        "N = 10000\n",
        "start = time.time()\n",
        "validation_targets, validation_examples = getDDs(N//10)\n",
        "print(\"Made\",N//10,\"new double-digit images to validate on.\")\n",
        "print(\"Time taken: {:.3f} seconds\".format(time.time()-start))"
      ],
      "execution_count": 73,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Made 1000 new double-digit images to validate on.\n",
            "Time taken: 3.808 seconds\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "TeUF-6FlekIA",
        "outputId": "8a2afb57-c879-4f4e-fc1e-942837901ede",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 51
        }
      },
      "source": [
        "start = time.time()\n",
        "training_targets, training_examples = getDDs(N)\n",
        "print(\"Made\",N,\"new double-digit images to train on.\")\n",
        "print(\"Time taken: {:.3f} seconds\".format(time.time()-start))"
      ],
      "execution_count": 74,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Made 10000 new double-digit images to train on.\n",
            "Time taken: 179.499 seconds\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "pt99UsgP96CN",
        "outputId": "1fa4b3b2-c415-4382-dd25-e2e6ba9215d6",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        }
      },
      "source": [
        "start = time.time()\n",
        "train_10000, valid_1000 = training_examples, validation_examples\n",
        "train_10000[\"target\"] = training_targets\n",
        "valid_1000[\"target\"] = validation_targets\n",
        "train_10000.to_csv(\"doubledigits_train_10000\")\n",
        "valid_1000.to_csv(\"doubledigits_valid_1000\")\n",
        "print(\"Time taken to save to files: {:.3f} seconds\".format(time.time()-start))"
      ],
      "execution_count": 75,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Time taken to save to files: 21.393 seconds\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "wrnAI1v6u8Uh"
      },
      "source": [
        "Show a random example and its corresponding label."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "s-euVJVtu8Ui"
      },
      "source": [
        "rand_example = np.random.choice(training_examples.index)\n",
        "_, ax = plt.subplots()\n",
        "ax.matshow(training_examples.loc[rand_example].values.reshape(28, 56),cmap=\"binary_r\")\n",
        "ax.set_title(\"Label: %i\" % training_targets.loc[rand_example])\n",
        "ax.grid(False)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "jKaiLbKaAwxy"
      },
      "source": [
        "N,len(set(training_targets)),len(set(validation_targets))"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "3014ezH3C7jT"
      },
      "source": [
        "## Create a deep neural net model\n",
        "\n",
        "[Text from the original project for single digits.]\n",
        "\n",
        "The `create_model` function defines the topography of the deep neural net, specifying the following:\n",
        "\n",
        "* The number of [layers](https://developers.google.com/machine-learning/glossary/#layer) in the deep neural net.\n",
        "* The number of [nodes](https://developers.google.com/machine-learning/glossary/#node) in each layer.\n",
        "* Any [regularization](https://developers.google.com/machine-learning/glossary/#regularization) layers.\n",
        "\n",
        "The `create_model` function also defines the [activation function](https://developers.google.com/machine-learning/glossary/#activation_function) of each layer.  The activation function of the output layer is [softmax](https://developers.google.com/machine-learning/glossary/#softmax), which will yield (100) different outputs for each example. Each of the (100) outputs provides the probability that the input example is a certain digit."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "M5AI0Drej0KS"
      },
      "source": [
        "\n",
        "def create_model(learning_rate):\n",
        "    \"\"\"Create and compile a deep neural net.\"\"\"  \n",
        "    # Define the kind of model to use.\n",
        "    model = tf.keras.models.Sequential()\n",
        "\n",
        "    # The double digit images are stored in two-dimensional arrays of 28x56 pixels \n",
        "    # each. The input layer flattens those two-dimensional arrays into \n",
        "    # one-dimensional 1568-element arrays.\n",
        "    model.add(tf.keras.layers.Flatten(input_shape=(28, 56)))\n",
        "\n",
        "    # The first interconnected layer will have 200 \"neurons\" (each of which \n",
        "    # is connected to each element in the input array). \n",
        "    # A \"weight\" will be randomly assigned to each node-to-node connection;\n",
        "    # all those weights will get adjusted on each pass during training.\n",
        "    # That's how the \"learning\" happens!\n",
        "    model.add(tf.keras.layers.Dense(units=256, activation='relu'))\n",
        "    # This line will help keep the model from \"overlearning\" the training set,\n",
        "    # which can happen, not good. \n",
        "    model.add(tf.keras.layers.Dropout(rate=0.3))\n",
        "\n",
        "    # Define the second interconnected layer, this one with 100 \"neurons\".   \n",
        "    model.add(tf.keras.layers.Dense(units=128, activation='relu'))\n",
        "    model.add(tf.keras.layers.Dropout(rate=0.2))\n",
        "\n",
        "    # Define the output layer. This layer must have exactly 100 \"neurons\", \n",
        "    # one for each possible output value (representing the numbers 0 to 99).\n",
        "    # With Softmax activation, the model will assign each output node the\n",
        "    # probability that the model thinks it's the corresponding double-digit number.\n",
        "    # The one with the highest probability will then be chosen as the model's\n",
        "    # \"best guess\" for each example given.\n",
        "    model.add(tf.keras.layers.Dense(units=100, activation='softmax'))     \n",
        "                            \n",
        "    # Build the model with built-in metrics to measure the progress it's making\n",
        "    # with the training set.  \n",
        "    model.compile(optimizer=tf.keras.optimizers.Adam(lr=learning_rate),\n",
        "                    loss=\"sparse_categorical_crossentropy\",\n",
        "                    metrics=['accuracy']) \n",
        "    return model \n",
        "\n",
        "# THIS FUNCTION WILL TRAIN THE MODEL ON THE TRAINING SET #\n",
        "def train_model(model, train_features, train_label, epochs,\n",
        "                batch_size=None, validation_split=0.1):\n",
        "\n",
        "    history = model.fit(x=train_features, y=train_label, batch_size=batch_size,\n",
        "                      epochs=epochs, shuffle=True, \n",
        "                      validation_split=validation_split)\n",
        " \n",
        "    # Get a snapshot of the model's metrics after each round of training\n",
        "    # to measure its progress.\n",
        "    epochs = history.epoch\n",
        "    hist = pd.DataFrame(history.history)\n",
        "    return epochs, hist    "
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "D-IXYVfvM4gD"
      },
      "source": [
        "## Invoke the previous functions to train on the train set and evaluate on the test set.\n",
        "\n",
        "Run the following code cell to invoke the preceding functions and actually train the model on the training set. "
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "nj3v5EKQFY8s",
        "cellView": "both"
      },
      "source": [
        "# These variables are the adjustable \"hyperparameters\" of the model.\n",
        "learning_rate = 0.001\n",
        "epochs = 20\n",
        "batch_size = 500\n",
        "validation_split = 0.1\n",
        "# \"epochs\" is the number of times the model makes adjustments to all\n",
        "# the weights for all the inter-neuron connections... which is a lot! \n",
        "# This should just take a couple of minutes; you can monitor its progress\n",
        "# in the output window below.\n",
        "\n",
        "# CREATE A NEW NEURAL NETWORK ACCORDING TO SPECIFICATIONS.\n",
        "my_model = create_model(learning_rate)\n",
        "\n",
        "# TRAIN IT ON THE \"NORMALIZED\" TRAINING SET:\n",
        "epochs, hist = train_model(my_model, x_train_normalized, y_train_norm, \n",
        "                           epochs, batch_size, validation_split)\n",
        "\n",
        "# EVALUATE AGAINST THE TEST SET:\n",
        "print(\"\\n Evaluate the new model against the test set:\")\n",
        "my_model.evaluate(x=x_test_normalized, y=y_test_norm, batch_size=batch_size)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "gOwFlKU0yjfh"
      },
      "source": [
        "x_train_normalized.shape"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "N6QCoQqRvRfb"
      },
      "source": [
        "# Plot a graph of the 'accuracy' metric vs. epochs:\n",
        "plot_curve(epochs, hist, 'accuracy')"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "CKFOumI6vg4T"
      },
      "source": [
        "# THIS FUNCTION TRANSLATES THE OUTPUT FROM THE NEURAL NETWORK\n",
        "# INTO A \"BEST GUESS\" FOR EACH EXAMPLE BASED ON THE RELATIVE\n",
        "# PROBABILITY IT ESTIMATES FOR EACH NUMBER 0 TO 99.\n",
        "\n",
        "def getAnswers(how_many=10):  \n",
        "    answers = pd.DataFrame(columns=['Answer','Guess','P(A)','P(G)'])  \n",
        "    answers['Answer'] = y_test_norm[:how_many]\n",
        "    predicts = my_model.predict(x_test_normalized).round(5)\n",
        "    for j in range(0,how_many): # how_many is the number of examples to guess\n",
        "        probs = predicts[j] # one row of 100 probabilities \n",
        "        maxr = max(probs)   # top probability\n",
        "        for i in range(0,100):\n",
        "            if probs[i] == maxr:\n",
        "                answers.at[j,'Guess'] = i\n",
        "                answers.at[j,'P(G)'] = maxr*100\n",
        "            if i == answers['Answer'][j]:\n",
        "                answers.at[j,'P(A)'] = probs[i]*100\n",
        "    return answers\n",
        "print(\"Loaded function getAnswers.\")\n",
        "print(\"Getting answers...\" )\n",
        "\n",
        "# LOAD UP ALL THE GUESSES (W/ PROBABILITES) FOR \n",
        "# EACH EXAMPLE IMAGE IN THE NORMALIZED TEST SET\n",
        "answers = getAnswers(len(x_test_normalized))\n",
        "answers"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "mkl_yxX8GlEt"
      },
      "source": [
        "# FIND THE *WRONG* GUESSES!\n",
        "wrongs = pd.DataFrame(index=answers.index,columns=['Mask'])\n",
        "for row in answers.index:\n",
        "    if answers['Answer'][row] == answers['Guess'][row]:\n",
        "        wrongs['Mask'][row] = False\n",
        "    else:\n",
        "        wrongs['Mask'][row] = True\n",
        "\n",
        "# LOCATE AND PRINT OUT THE LIST OF WRONGS       \n",
        "a = answers.loc[wrongs['Mask']]\n",
        "w = len(a) \n",
        "t = len(x_test_normalized)\n",
        "print(w,\"wrong out of\",t,\"guesses.\")\n",
        "a"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "BZ4riZ5VmQbV"
      },
      "source": [
        "# FIND OUT WHICH NUMBERS IT HAD THE MOST TROUBLE WITH\n",
        "ww = []\n",
        "for i in range(0,100):\n",
        "    w = len((answers.loc[lambda a: a['Answer'] == i]).loc[wrongs['Mask']])\n",
        "    ww += [w]\n",
        "attempts = pd.DataFrame(ww)\n",
        "attempts.sort_values(0).tail(5)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "bffPxjYDlEYJ"
      },
      "source": [
        "# LAST BUT NOT LEAST...\n",
        "# THIS CELL SHOWS WHAT SOME OF THE *WRONG* GUESSES WERE.\n",
        "#\n",
        "# IT SHOWS THE IMAGE THE ALGORITHM HAD TO WORK WITH\n",
        "# ALONG WITH ITS \"BEST GUESS\" AND THE LABELED ANSWER\n",
        "\n",
        "# RUN THE CELL A FEW TIMES TO SEE A FEW EXAMPLES OF WHERE IT FAILED!\n",
        "\n",
        "g = answers['Guess'].loc[wrongs['Mask']]\n",
        "a = answers['Answer'].loc[wrongs['Mask']]\n",
        "x = rd.choice(g.index)  #RANDOMLY SELECT ONE OF THE WRONG GUESSES\n",
        "pa = round(answers['P(A)'][x],2)\n",
        "pg = round(answers['P(G)'][x],2)\n",
        "print(\"Answer[\",x,\"] is\",a[x],\"with estimated probability\",pa,\"\\n\")\n",
        "print(\"Guess[\",x,\"] was\",g[x],\"with estimated probability\",pg,\"\\n\")\n",
        "plt.imshow(x_test_normalized[x])"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "9xo6ne4dOPIl"
      },
      "source": [
        "And that's that, for now!\n",
        "\n",
        "Next step: teach an algorithm to add and subtract just by giving it handwritten digits and handwritten \"+\",\"-\",\"=\" signs!!"
      ]
    }
  ]
}