t81_558_class_03_2_keras.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a href=\"https://colab.research.google.com/github/jeffheaton/t81_558_deep_learning/blob/master/t81_558_class_03_2_keras.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# T81-558: Applications of Deep Neural Networks\n",
    "**Module 3: Introduction to TensorFlow**\n",
    "* Instructor: [Jeff Heaton](https://sites.wustl.edu/jeffheaton/), McKelvey School of Engineering, [Washington University in St. Louis](https://engineering.wustl.edu/Programs/Pages/default.aspx)\n",
    "* For more information visit the [class website](https://sites.wustl.edu/jeffheaton/t81-558/)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Module 3 Material\n",
    "\n",
    "* Part 3.1: Deep Learning and Neural Network Introduction [[Video]](https://www.youtube.com/watch?v=zYnI4iWRmpc&list=PLjy4p-07OYzulelvJ5KVaT2pDlxivl_BN) [[Notebook]](t81_558_class_03_1_neural_net.ipynb)\n",
    "* **Part 3.2: Introduction to Tensorflow and Keras** [[Video]](https://www.youtube.com/watch?v=PsE73jk55cE&list=PLjy4p-07OYzulelvJ5KVaT2pDlxivl_BN) [[Notebook]](t81_558_class_03_2_keras.ipynb)\n",
    "* Part 3.3: Saving and Loading a Keras Neural Network [[Video]](https://www.youtube.com/watch?v=-9QfbGM1qGw&list=PLjy4p-07OYzulelvJ5KVaT2pDlxivl_BN) [[Notebook]](t81_558_class_03_3_save_load.ipynb)\n",
    "* Part 3.4: Early Stopping in Keras to Prevent Overfitting [[Video]](https://www.youtube.com/watch?v=m1LNunuI2fk&list=PLjy4p-07OYzulelvJ5KVaT2pDlxivl_BN) [[Notebook]](t81_558_class_03_4_early_stop.ipynb)\n",
    "* Part 3.5: Extracting Weights and Manual Calculation [[Video]](https://www.youtube.com/watch?v=7PWgx16kH8s&list=PLjy4p-07OYzulelvJ5KVaT2pDlxivl_BN) [[Notebook]](t81_558_class_03_5_weights.ipynb)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Google CoLab Instructions\n",
    "\n",
    "The following code ensures that Google CoLab is running the correct version of TensorFlow."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "try:\n",
    "    %tensorflow_version 2.x\n",
    "    COLAB = True\n",
    "    print(\"Note: using Google CoLab\")\n",
    "except:\n",
    "    print(\"Note: not using Google CoLab\")\n",
    "    COLAB = False"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Part 3.2: Introduction to Tensorflow and Keras\n",
    "\n",
    "TensorFlow is an open-source software library for machine learning in various kinds of perceptual and language understanding tasks. It is currently used for both research and production by different teams in many commercial Google products, such as speech recognition, Gmail, Google Photos, and search, many of which had previously used its predecessor DistBelief. TensorFlow was originally developed by the Google Brain team for Google's research and production purposes and later released under the Apache 2.0 open source license on November 9, 2015.\n",
    "\n",
    "* [TensorFlow Homepage](https://www.tensorflow.org/)\n",
    "* [TensorFlow GitHib](https://github.com/tensorflow/tensorflow)\n",
    "* [TensorFlow Google Groups Support](https://groups.google.com/forum/#!forum/tensorflow)\n",
    "* [TensorFlow Google Groups Developer Discussion](https://groups.google.com/a/tensorflow.org/forum/#!forum/discuss)\n",
    "* [TensorFlow FAQ](https://www.tensorflow.org/resources/faq)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Why TensorFlow\n",
    "\n",
    "* Supported by Google\n",
    "* Works well on Windows, Linux, and Mac\n",
    "* Excellent GPU support\n",
    "* Python is an easy to learn programming language\n",
    "* Python is extremely popular in the data science community\n",
    "\n",
    "## Deep Learning Tools\n",
    "TensorFlow is not the only game in town. The biggest competitor to TensorFlow/Keras is PyTorch. Listed below are some of the deep learning toolkits actively being supported:\n",
    "\n",
    "* **[TensorFlow](https://www.tensorflow.org/)** - Google's deep learning API.  The focus of this class, along with Keras.\n",
    "* **[Keras](https://keras.io/)** - Also by Google, higher level framework that allows the use of TensorFlow, MXNet and Theano interchangeably.\n",
    "* **[PyTorch](https://pytorch.org/)** - PyTorch is an open source machine learning library based on the Torch library, used for applications such as computer vision and natural language processing. It is primarily developed by Facebook's AI Research lab. \n",
    "\n",
    "Other deep learning tools:\n",
    "\n",
    "* **[MXNet](https://mxnet.incubator.apache.org/)** Apache foundation's deep learning API. Can be used through Keras.\n",
    "* **[Torch](http://torch.ch/)** is used by Google DeepMind, the Facebook AI Research Group, IBM, Yandex and the Idiap Research Institute.  It has been used for some of the most advanced deep learning projects in the world.  However, it requires the [LUA](https://en.wikipedia.org/wiki/Lua_(programming_language))** programming language.  It is very advanced, but it is not mainstream.  I have not worked with Torch (yet!).\n",
    "* **[PaddlePaddle](https://github.com/baidu/Paddle)** - [Baidu](http://www.baidu.com/)'s deep learning API.\n",
    "* **[Deeplearning4J](http://deeplearning4j.org/)** - Java based. Supports all major platforms. GPU support in Java!\n",
    "* **[Computational Network Toolkit (CNTK)](https://github.com/Microsoft/CNTK)** - Microsoft.  Support for Windows/Linux, command line only.  Bindings for predictions for C#/Python. GPU support.\n",
    "* **[H2O](http://www.h2o.ai/)** - Java based.  Supports all major platforms.  Limited support for computer vision. No GPU support.\n",
    "\n",
    "In my opinion, the two primary Python libraries for deep learning are PyTorch and Keras. Generally, PyTorch requires more lines of code to perform the deep learning applications presented in this course.  This trait of PyTorch gives Keras an easier learning curve than PyTorch.  However, if you are creating entirely new neural network structures, in a research setting, PyTorch can make for easier access to some of the low-level internals of deep learning.\n",
    "\n",
    "## Using TensorFlow Directly\n",
    "\n",
    "Most of the time in the course, we will communicate with TensorFlow using Keras [[Cite:franccois2017deep]](https://www.manning.com/books/deep-learning-with-python), which allows you to specify the number of hidden layers and create the neural network.  TensorFlow is a low-level mathematics API, similar to [Numpy](http://www.numpy.org/).  However, unlike Numpy, TensorFlow is built for deep learning. TensorFlow compiles these compute graphs into highly efficient C++/[CUDA](https://en.wikipedia.org/wiki/CUDA) code.\n",
    "\n",
    "### TensorFlow Linear Algebra Examples\n",
    "\n",
    "TensorFlow is a library for linear algebra.  Keras is a higher-level abstraction for neural networks that you build upon TensorFlow.  In this section, I will demonstrate some basic linear algebra that employs TensorFlow directly and does not make use of Keras.  First, we will see how to multiply a row and column matrix."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "tf.Tensor([[12.]], shape=(1, 1), dtype=float32)\n",
      "12.0\n"
     ]
    }
   ],
   "source": [
    "import tensorflow as tf\n",
    "\n",
    "# Create a Constant op that produces a 1x2 matrix.  The op is\n",
    "# added as a node to the default graph.\n",
    "#\n",
    "# The value returned by the constructor represents the output\n",
    "# of the Constant op.\n",
    "matrix1 = tf.constant([[3., 3.]])\n",
    "\n",
    "# Create another Constant that produces a 2x1 matrix.\n",
    "matrix2 = tf.constant([[2.],[2.]])\n",
    "\n",
    "# Create a Matmul op that takes 'matrix1' and 'matrix2' as inputs.\n",
    "# The returned value, 'product', represents the result of the matrix\n",
    "# multiplication.\n",
    "product = tf.matmul(matrix1, matrix2)\n",
    "\n",
    "print(product)\n",
    "print(float(product))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This example multiplied two TensorFlow constant tensors.  Next, we will see how to subtract a constant from a variable."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "tf.Tensor([-2. -1.], shape=(2,), dtype=float32)\n",
      "[-2. -1.]\n"
     ]
    }
   ],
   "source": [
    "import tensorflow as tf\n",
    "\n",
    "x = tf.Variable([1.0, 2.0])\n",
    "a = tf.constant([3.0, 3.0])\n",
    "\n",
    "# Add an op to subtract 'a' from 'x'.  Run it and print the result\n",
    "sub = tf.subtract(x, a)\n",
    "print(sub)\n",
    "print(sub.numpy())\n",
    "# ==> [-2. -1.]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Of course, variables are only useful if their values can be changed.  The program can accomplish this change in value by calling the assign function."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<tf.Variable 'UnreadVariable' shape=(2,) dtype=float32, numpy=array([4., 6.], dtype=float32)>"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x.assign([4.0, 6.0])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The program can now perform the subtraction with this new value."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "tf.Tensor([1. 3.], shape=(2,), dtype=float32)\n",
      "[1. 3.]\n"
     ]
    }
   ],
   "source": [
    "sub = tf.subtract(x, a)\n",
    "print(sub)\n",
    "print(sub.numpy())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In the next section, we will see a TensorFlow example that has nothing to do with neural networks."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### TensorFlow Mandelbrot Set Example\n",
    "\n",
    "Next, we examine another example where we use TensorFlow directly.  To demonstrate that TensorFlow is mathematical and does not only provide neural networks, we will also first use it for a non-machine learning rendering task. The code presented here is capable of rendering a [Mandelbrot set](https://en.wikipedia.org/wiki/Mandelbrot_set). Note, I based this example on a Mandelbrot example that I found [here]( https://chromium.googlesource.com/external/github.com/tensorflow/tensorflow/+/r0.10/tensorflow/g3doc/tutorials/mandelbrot/index.md). I've updated the code slightly to comply with current versions of TensorFlow."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/jpeg": "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\n",
      "text/plain": [
       "<IPython.core.display.Image object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Import libraries for simulation\n",
    "import tensorflow as tf\n",
    "import numpy as np\n",
    "\n",
    "# Imports for visualization\n",
    "import PIL.Image\n",
    "from io import BytesIO\n",
    "from IPython.display import Image, display\n",
    "\n",
    "def DisplayFractal(a, fmt='jpeg'):\n",
    "  \"\"\"Display an array of iteration counts as a\n",
    "     colorful picture of a fractal.\"\"\"\n",
    "  a_cyclic = (6.28*a/20.0).reshape(list(a.shape)+[1])\n",
    "  img = np.concatenate([10+20*np.cos(a_cyclic),\n",
    "                        30+50*np.sin(a_cyclic),\n",
    "                        155-80*np.cos(a_cyclic)], 2)\n",
    "  img[a==a.max()] = 0\n",
    "  a = img\n",
    "  a = np.uint8(np.clip(a, 0, 255))\n",
    "  f = BytesIO()\n",
    "  PIL.Image.fromarray(a).save(f, fmt)\n",
    "  display(Image(data=f.getvalue()))\n",
    "\n",
    "# Use NumPy to create a 2D array of complex numbers\n",
    "\n",
    "Y, X = np.mgrid[-1.3:1.3:0.005, -2:1:0.005]\n",
    "Z = X+1j*Y\n",
    "\n",
    "xs = tf.constant(Z.astype(np.complex64))\n",
    "zs = tf.Variable(xs)\n",
    "ns = tf.Variable(tf.zeros_like(xs, tf.float32))\n",
    "\n",
    "\n",
    "\n",
    "# Operation to update the zs and the iteration count.\n",
    "#\n",
    "# Note: We keep computing zs after they diverge! This\n",
    "#       is very wasteful! There are better, if a little\n",
    "#       less simple, ways to do this.\n",
    "#\n",
    "for i in range(200):\n",
    "    # Compute the new values of z: z^2 + x\n",
    "    zs_ = zs*zs + xs\n",
    "\n",
    "    # Have we diverged with this new value?\n",
    "    not_diverged = tf.abs(zs_) < 4\n",
    "\n",
    "    zs.assign(zs_),\n",
    "    ns.assign_add(tf.cast(not_diverged, tf.float32))\n",
    "    \n",
    "DisplayFractal(ns.numpy())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Mandlebrot render is both simple and infinitely complex at the same time. This view shows the entire Mandlebrot universe at the same time, as it is completely zoomed out. However, if you zoom in on any non-black portion of the plot, you will find infinite hidden complexity. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Introduction to Keras\n",
    "\n",
    "[Keras](https://keras.io/) is a layer on top of Tensorflow that makes it much easier to create neural networks.  Rather than define the graphs, as you see above, you set the individual layers of the network with a much more high-level API.  Unless you are performing research into entirely new structures of deep neural networks, it is unlikely that you need to program TensorFlow directly.  \n",
    "\n",
    "**For this class, we will use usually use TensorFlow through Keras, rather than direct TensorFlow**\n",
    "\n",
    "### Simple TensorFlow Regression: MPG\n",
    "\n",
    "This example shows how to encode the MPG dataset for regression.  This dataset is slightly more complicated than Iris, because:\n",
    "\n",
    "* Input has both numeric and categorical\n",
    "* Input has missing values\n",
    "\n",
    "This example uses functions defined above in this notepad, the \"helpful functions\". These functions allow you to build the feature vector for a neural network. Consider the following:\n",
    "\n",
    "* Predictors/Inputs \n",
    "    * Fill any missing inputs with the median for that column.  Use **missing_median**.\n",
    "    * Encode textual/categorical values with **encode_text_dummy**.\n",
    "    * Encode numeric values with **encode_numeric_zscore**.\n",
    "* Output\n",
    "    * Discard rows with missing outputs.\n",
    "    * Encode textual/categorical values with **encode_text_index**.\n",
    "    * Do not encode output numeric values.\n",
    "* Produce final feature vectors (x) and expected output (y) with **to_xy**.\n",
    "\n",
    "To encode categorical values that are part of the feature vector, use the functions from above if the categorical value is the target (as was the case with Iris, use the same technique as Iris). The iris technique allows you to decode back to Iris text strings from the predictions."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Train on 398 samples\n",
      "Epoch 1/100\n",
      "398/398 - 0s - loss: 532928.3769\n",
      "Epoch 2/100\n",
      "398/398 - 0s - loss: 253903.1740\n",
      "Epoch 3/100\n",
      "398/398 - 0s - loss: 100463.9936\n",
      "Epoch 4/100\n",
      "398/398 - 0s - loss: 39376.4139\n",
      "Epoch 5/100\n",
      "398/398 - 0s - loss: 14699.5505\n",
      "Epoch 6/100\n",
      "398/398 - 0s - loss: 10070.2764\n",
      "Epoch 7/100\n",
      "398/398 - 0s - loss: 8767.4534\n",
      "Epoch 8/100\n",
      "398/398 - 0s - loss: 7568.0651\n",
      "Epoch 9/100\n",
      "398/398 - 0s - loss: 6519.3935\n",
      "Epoch 10/100\n",
      "398/398 - 0s - loss: 5638.3222\n",
      "Epoch 11/100\n",
      "398/398 - 0s - loss: 4900.6222\n",
      "Epoch 12/100\n",
      "398/398 - 0s - loss: 4256.2369\n",
      "Epoch 13/100\n",
      "398/398 - 0s - loss: 3715.3158\n",
      "Epoch 14/100\n",
      "398/398 - 0s - loss: 3243.3127\n",
      "Epoch 15/100\n",
      "398/398 - 0s - loss: 2837.4957\n",
      "Epoch 16/100\n",
      "398/398 - 0s - loss: 2493.2320\n",
      "Epoch 17/100\n",
      "398/398 - 0s - loss: 2191.6368\n",
      "Epoch 18/100\n",
      "398/398 - 0s - loss: 1935.9826\n",
      "Epoch 19/100\n",
      "398/398 - 0s - loss: 1709.9219\n",
      "Epoch 20/100\n",
      "398/398 - 0s - loss: 1517.5594\n",
      "Epoch 21/100\n",
      "398/398 - 0s - loss: 1347.0029\n",
      "Epoch 22/100\n",
      "398/398 - 0s - loss: 1202.3976\n",
      "Epoch 23/100\n",
      "398/398 - 0s - loss: 1074.8017\n",
      "Epoch 24/100\n",
      "398/398 - 0s - loss: 965.3571\n",
      "Epoch 25/100\n",
      "398/398 - 0s - loss: 869.1089\n",
      "Epoch 26/100\n",
      "398/398 - 0s - loss: 786.9213\n",
      "Epoch 27/100\n",
      "398/398 - 0s - loss: 712.5439\n",
      "Epoch 28/100\n",
      "398/398 - 0s - loss: 648.9730\n",
      "Epoch 29/100\n",
      "398/398 - 0s - loss: 592.6204\n",
      "Epoch 30/100\n",
      "398/398 - 0s - loss: 542.2534\n",
      "Epoch 31/100\n",
      "398/398 - 0s - loss: 499.5945\n",
      "Epoch 32/100\n",
      "398/398 - 0s - loss: 460.6432\n",
      "Epoch 33/100\n",
      "398/398 - 0s - loss: 426.6404\n",
      "Epoch 34/100\n",
      "398/398 - 0s - loss: 397.0015\n",
      "Epoch 35/100\n",
      "398/398 - 0s - loss: 371.2881\n",
      "Epoch 36/100\n",
      "398/398 - 0s - loss: 347.1069\n",
      "Epoch 37/100\n",
      "398/398 - 0s - loss: 327.0558\n",
      "Epoch 38/100\n",
      "398/398 - 0s - loss: 308.9706\n",
      "Epoch 39/100\n",
      "398/398 - 0s - loss: 293.4671\n",
      "Epoch 40/100\n",
      "398/398 - 0s - loss: 279.4684\n",
      "Epoch 41/100\n",
      "398/398 - 0s - loss: 266.5202\n",
      "Epoch 42/100\n",
      "398/398 - 0s - loss: 255.4313\n",
      "Epoch 43/100\n",
      "398/398 - 0s - loss: 245.8519\n",
      "Epoch 44/100\n",
      "398/398 - 0s - loss: 237.3705\n",
      "Epoch 45/100\n",
      "398/398 - 0s - loss: 229.9772\n",
      "Epoch 46/100\n",
      "398/398 - 0s - loss: 223.4570\n",
      "Epoch 47/100\n",
      "398/398 - 0s - loss: 217.3037\n",
      "Epoch 48/100\n",
      "398/398 - 0s - loss: 212.0329\n",
      "Epoch 49/100\n",
      "398/398 - 0s - loss: 207.3768\n",
      "Epoch 50/100\n",
      "398/398 - 0s - loss: 203.4740\n",
      "Epoch 51/100\n",
      "398/398 - 0s - loss: 199.8031\n",
      "Epoch 52/100\n",
      "398/398 - 0s - loss: 196.9008\n",
      "Epoch 53/100\n",
      "398/398 - 0s - loss: 194.1096\n",
      "Epoch 54/100\n",
      "398/398 - 0s - loss: 191.8634\n",
      "Epoch 55/100\n",
      "398/398 - 0s - loss: 189.6037\n",
      "Epoch 56/100\n",
      "398/398 - 0s - loss: 187.9038\n",
      "Epoch 57/100\n",
      "398/398 - 0s - loss: 186.4501\n",
      "Epoch 58/100\n",
      "398/398 - 0s - loss: 184.9448\n",
      "Epoch 59/100\n",
      "398/398 - 0s - loss: 183.7436\n",
      "Epoch 60/100\n",
      "398/398 - 0s - loss: 182.6323\n",
      "Epoch 61/100\n",
      "398/398 - 0s - loss: 181.8248\n",
      "Epoch 62/100\n",
      "398/398 - 0s - loss: 180.8635\n",
      "Epoch 63/100\n",
      "398/398 - 0s - loss: 180.1527\n",
      "Epoch 64/100\n",
      "398/398 - 0s - loss: 179.4130\n",
      "Epoch 65/100\n",
      "398/398 - 0s - loss: 178.8714\n",
      "Epoch 66/100\n",
      "398/398 - 0s - loss: 178.4050\n",
      "Epoch 67/100\n",
      "398/398 - 0s - loss: 177.8955\n",
      "Epoch 68/100\n",
      "398/398 - 0s - loss: 177.4985\n",
      "Epoch 69/100\n",
      "398/398 - 0s - loss: 177.1324\n",
      "Epoch 70/100\n",
      "398/398 - 0s - loss: 176.8686\n",
      "Epoch 71/100\n",
      "398/398 - 0s - loss: 176.5298\n",
      "Epoch 72/100\n",
      "398/398 - 0s - loss: 176.3295\n",
      "Epoch 73/100\n",
      "398/398 - 0s - loss: 176.0535\n",
      "Epoch 74/100\n",
      "398/398 - 0s - loss: 175.8712\n",
      "Epoch 75/100\n",
      "398/398 - 0s - loss: 175.6723\n",
      "Epoch 76/100\n",
      "398/398 - 0s - loss: 175.5422\n",
      "Epoch 77/100\n",
      "398/398 - 0s - loss: 175.3606\n",
      "Epoch 78/100\n",
      "398/398 - 0s - loss: 175.2149\n",
      "Epoch 79/100\n",
      "398/398 - 0s - loss: 175.1186\n",
      "Epoch 80/100\n",
      "398/398 - 0s - loss: 174.9576\n",
      "Epoch 81/100\n",
      "398/398 - 0s - loss: 174.8516\n",
      "Epoch 82/100\n",
      "398/398 - 0s - loss: 174.7489\n",
      "Epoch 83/100\n",
      "398/398 - 0s - loss: 174.6472\n",
      "Epoch 84/100\n",
      "398/398 - 0s - loss: 174.5678\n",
      "Epoch 85/100\n",
      "398/398 - 0s - loss: 174.4445\n",
      "Epoch 86/100\n",
      "398/398 - 0s - loss: 174.3567\n",
      "Epoch 87/100\n",
      "398/398 - 0s - loss: 174.2643\n",
      "Epoch 88/100\n",
      "398/398 - 0s - loss: 174.1730\n",
      "Epoch 89/100\n",
      "398/398 - 0s - loss: 174.1209\n",
      "Epoch 90/100\n",
      "398/398 - 0s - loss: 174.0430\n",
      "Epoch 91/100\n",
      "398/398 - 0s - loss: 173.9585\n",
      "Epoch 92/100\n",
      "398/398 - 0s - loss: 173.8340\n",
      "Epoch 93/100\n",
      "398/398 - 0s - loss: 173.7509\n",
      "Epoch 94/100\n",
      "398/398 - 0s - loss: 173.6775\n",
      "Epoch 95/100\n",
      "398/398 - 0s - loss: 173.5709\n",
      "Epoch 96/100\n",
      "398/398 - 0s - loss: 173.5111\n",
      "Epoch 97/100\n",
      "398/398 - 0s - loss: 173.4251\n",
      "Epoch 98/100\n",
      "398/398 - 0s - loss: 173.3334\n",
      "Epoch 99/100\n",
      "398/398 - 0s - loss: 173.2709\n",
      "Epoch 100/100\n",
      "398/398 - 0s - loss: 173.1735\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<tensorflow.python.keras.callbacks.History at 0x275f09bc408>"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from tensorflow.keras.models import Sequential\n",
    "from tensorflow.keras.layers import Dense, Activation\n",
    "import pandas as pd\n",
    "import io\n",
    "import os\n",
    "import requests\n",
    "import numpy as np\n",
    "from sklearn import metrics\n",
    "\n",
    "df = pd.read_csv(\n",
    "    \"https://data.heatonresearch.com/data/t81-558/auto-mpg.csv\", \n",
    "    na_values=['NA', '?'])\n",
    "\n",
    "cars = df['name']\n",
    "\n",
    "# Handle missing value\n",
    "df['horsepower'] = df['horsepower'].fillna(df['horsepower'].median())\n",
    "\n",
    "# Pandas to Numpy\n",
    "x = df[['cylinders', 'displacement', 'horsepower', 'weight',\n",
    "       'acceleration', 'year', 'origin']].values\n",
    "y = df['mpg'].values # regression\n",
    "\n",
    "# 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')\n",
    "model.fit(x,y,verbose=2,epochs=100)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Introduction to Neural Network Hyperparameters\n",
    "\n",
    "If you look at the above code, you will see that the neural network contains four layers.  The first layer is the input layer because it contains the **input_dim** parameter that the programmer sets to be the number of inputs that the dataset has.  The network needs one input neuron for every column in the data set (including dummy variables).  \n",
    "\n",
    "There are also several hidden layers, with 25 and 10 neurons each. You might be wondering how the programmer chose these numbers. Selecting a hidden neuron structure is one of the most common questions about neural networks.  Unfortunately, there is not a right answer.  These are hyperparameters.  They are settings that can affect neural network performance, yet there are not a clearly defined means of setting them.\n",
    "\n",
    "In general, more hidden neurons mean more capability to fit complex problems.  However, too many neurons can lead to overfitting and lengthy training times.  Too few can lead to underfitting the problem and will sacrifice accuracy.  Also, how many layers you have is another hyperparameter.  In general, more layers allow the neural network to be able to perform more of its feature engineering and data preprocessing.  But this also comes at the expense of training times and the risk of overfitting.  In general, you will see that neuron counts start larger near the input layer and tend to shrink towards the output layer in a sort of triangular fashion. \n",
    "\n",
    "Some techniques use machine learning to optimize these values.  These will be discussed in [Module 8.3](t81_558_class_08_3_keras_hyperparameters.ipynb).\n",
    "\n",
    "### Controlling the Amount of Output\n",
    "\n",
    "The program produces one line of output for each training epoch.  You can eliminate this output by setting the verbose setting of the fit command:\n",
    "\n",
    "* **verbose=0** - No progress output (use with Jupyter if you do not want output)\n",
    "* **verbose=1** - Display progress bar, does not work well with Jupyter\n",
    "* **verbose=2** - Summary progress output (use with Jupyter if you want to know the loss at each epoch)\n",
    "\n",
    "### Regression Prediction\n",
    "\n",
    "Next, we will perform actual predictions.  The program assigns these predictions to the **pred** variable. These are all MPG predictions from the neural network.  Notice that this is a 2D array?  You can always see the dimensions of what Keras returns by printing out **pred.shape**.  Neural networks can return multiple values, so the result is always an array.  Here the neural network only returns one value per prediction (there are 398 cars, so 398 predictions).  However, a 2D range is needed because the neural network has the potential of returning more than one value.   "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Shape: (398, 1)\n",
      "[[23.08987 ]\n",
      " [23.776747]\n",
      " [22.190557]\n",
      " [22.24273 ]\n",
      " [22.536469]\n",
      " [27.865118]\n",
      " [27.486967]\n",
      " [27.316473]\n",
      " [27.953611]\n",
      " [24.391483]]\n"
     ]
    }
   ],
   "source": [
    "pred = model.predict(x)\n",
    "print(f\"Shape: {pred.shape}\")\n",
    "print(pred[0:10])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We would like to see how good these predictions are.  We know what the correct MPG is for each car, so we can measure how close the neural network was."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Final score (RMSE): 13.157274080377979\n"
     ]
    }
   ],
   "source": [
    "# Measure RMSE error.  RMSE is common for regression.\n",
    "score = np.sqrt(metrics.mean_squared_error(pred,y))\n",
    "print(f\"Final score (RMSE): {score}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The number printed above is the average amount that the predictions were above or below the expected output. We can also print out the first ten cars, with predictions and actual MPG."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1. Car name: chevrolet chevelle malibu, MPG: 18.0, predicted MPG: {pred[i]}\n",
      "2. Car name: buick skylark 320, MPG: 15.0, predicted MPG: {pred[i]}\n",
      "3. Car name: plymouth satellite, MPG: 18.0, predicted MPG: {pred[i]}\n",
      "4. Car name: amc rebel sst, MPG: 16.0, predicted MPG: {pred[i]}\n",
      "5. Car name: ford torino, MPG: 17.0, predicted MPG: {pred[i]}\n",
      "6. Car name: ford galaxie 500, MPG: 15.0, predicted MPG: {pred[i]}\n",
      "7. Car name: chevrolet impala, MPG: 14.0, predicted MPG: {pred[i]}\n",
      "8. Car name: plymouth fury iii, MPG: 14.0, predicted MPG: {pred[i]}\n",
      "9. Car name: pontiac catalina, MPG: 14.0, predicted MPG: {pred[i]}\n",
      "10. Car name: amc ambassador dpl, MPG: 15.0, predicted MPG: {pred[i]}\n"
     ]
    }
   ],
   "source": [
    "# Sample predictions\n",
    "for i in range(10):\n",
    "    print(f\"{i+1}. Car name: {cars[i]}, MPG: {y[i]}, \" \n",
    "          + \"predicted MPG: {pred[i]}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Simple TensorFlow Classification: Iris\n",
    "\n",
    "Classification is the process by which a neural network attempts to classify the input into one or more classes.  The simplest way of evaluating a classification network is to track the percentage of training set items that were classified incorrectly.  We typically score human results in this manner. For example, you might have taken multiple-choice exams in school in which you had to shade in a bubble for choices A, B, C, or D.  If you chose the wrong letter on a 10-question exam, you would earn a 90%.  In the same way, we can grade computers; however, most classification algorithms do not merely choose A, B, C, or D.  Computers typically report a classification as their percent confidence in each class.  Figure 3.EXAM shows how a computer and a human might both respond to question number 1 on an exam.\n",
    "\n",
    "**Figure 3.EXAM: Classification Neural Network Output**\n",
    "![Classification Neural Network Output](images/class-multi-choice.png \"Classification Neural Network Output\")\n",
    "\n",
    "As you can see, the human test taker marked the first question as \"B.\" However, the computer test taker had an 80% (0.8) confidence in \"B\" and was also somewhat sure with 10% (0.1) on \"A.\" The computer then distributed the remaining points on the other two.  In the simplest sense, the machine would get 80% of the score for this question if the correct answer were \"B.\" The computer would get only 5% (0.05) of the points if the correct answer were \"D.\" \n",
    "\n",
    "What we just saw is a straightforward example of how to perform the Iris classification using TensorFlow.  The iris.csv file is used, rather than using the built-in data that many of the Google examples require.  \n",
    "\n",
    "**Make sure that you always run previous code blocks.  If you run the code block below, without the code block above, you will get errors**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Train on 150 samples\n",
      "Epoch 1/100\n",
      "150/150 - 0s - loss: 1.1343\n",
      "Epoch 2/100\n",
      "150/150 - 0s - loss: 1.0067\n",
      "Epoch 3/100\n",
      "150/150 - 0s - loss: 0.9150\n",
      "Epoch 4/100\n",
      "150/150 - 0s - loss: 0.8430\n",
      "Epoch 5/100\n",
      "150/150 - 0s - loss: 0.7892\n",
      "Epoch 6/100\n",
      "150/150 - 0s - loss: 0.7348\n",
      "Epoch 7/100\n",
      "150/150 - 0s - loss: 0.6847\n",
      "Epoch 8/100\n",
      "150/150 - 0s - loss: 0.6382\n",
      "Epoch 9/100\n",
      "150/150 - 0s - loss: 0.6041\n",
      "Epoch 10/100\n",
      "150/150 - 0s - loss: 0.5686\n",
      "Epoch 11/100\n",
      "150/150 - 0s - loss: 0.5374\n",
      "Epoch 12/100\n",
      "150/150 - 0s - loss: 0.5166\n",
      "Epoch 13/100\n",
      "150/150 - 0s - loss: 0.4913\n",
      "Epoch 14/100\n",
      "150/150 - 0s - loss: 0.4706\n",
      "Epoch 15/100\n",
      "150/150 - 0s - loss: 0.4519\n",
      "Epoch 16/100\n",
      "150/150 - 0s - loss: 0.4337\n",
      "Epoch 17/100\n",
      "150/150 - 0s - loss: 0.4207\n",
      "Epoch 18/100\n",
      "150/150 - 0s - loss: 0.4026\n",
      "Epoch 19/100\n",
      "150/150 - 0s - loss: 0.3894\n",
      "Epoch 20/100\n",
      "150/150 - 0s - loss: 0.3764\n",
      "Epoch 21/100\n",
      "150/150 - 0s - loss: 0.3630\n",
      "Epoch 22/100\n",
      "150/150 - 0s - loss: 0.3527\n",
      "Epoch 23/100\n",
      "150/150 - 0s - loss: 0.3409\n",
      "Epoch 24/100\n",
      "150/150 - 0s - loss: 0.3296\n",
      "Epoch 25/100\n",
      "150/150 - 0s - loss: 0.3179\n",
      "Epoch 26/100\n",
      "150/150 - 0s - loss: 0.3091\n",
      "Epoch 27/100\n",
      "150/150 - 0s - loss: 0.2985\n",
      "Epoch 28/100\n",
      "150/150 - 0s - loss: 0.2884\n",
      "Epoch 29/100\n",
      "150/150 - 0s - loss: 0.2825\n",
      "Epoch 30/100\n",
      "150/150 - 0s - loss: 0.2703\n",
      "Epoch 31/100\n",
      "150/150 - 0s - loss: 0.2643\n",
      "Epoch 32/100\n",
      "150/150 - 0s - loss: 0.2554\n",
      "Epoch 33/100\n",
      "150/150 - 0s - loss: 0.2482\n",
      "Epoch 34/100\n",
      "150/150 - 0s - loss: 0.2395\n",
      "Epoch 35/100\n",
      "150/150 - 0s - loss: 0.2341\n",
      "Epoch 36/100\n",
      "150/150 - 0s - loss: 0.2358\n",
      "Epoch 37/100\n",
      "150/150 - 0s - loss: 0.2174\n",
      "Epoch 38/100\n",
      "150/150 - 0s - loss: 0.2181\n",
      "Epoch 39/100\n",
      "150/150 - 0s - loss: 0.2091\n",
      "Epoch 40/100\n",
      "150/150 - 0s - loss: 0.2036\n",
      "Epoch 41/100\n",
      "150/150 - 0s - loss: 0.1967\n",
      "Epoch 42/100\n",
      "150/150 - 0s - loss: 0.1946\n",
      "Epoch 43/100\n",
      "150/150 - 0s - loss: 0.1917\n",
      "Epoch 44/100\n",
      "150/150 - 0s - loss: 0.1816\n",
      "Epoch 45/100\n",
      "150/150 - 0s - loss: 0.1884\n",
      "Epoch 46/100\n",
      "150/150 - 0s - loss: 0.1736\n",
      "Epoch 47/100\n",
      "150/150 - 0s - loss: 0.1745\n",
      "Epoch 48/100\n",
      "150/150 - 0s - loss: 0.1655\n",
      "Epoch 49/100\n",
      "150/150 - 0s - loss: 0.1620\n",
      "Epoch 50/100\n",
      "150/150 - 0s - loss: 0.1579\n",
      "Epoch 51/100\n",
      "150/150 - 0s - loss: 0.1552\n",
      "Epoch 52/100\n",
      "150/150 - 0s - loss: 0.1511\n",
      "Epoch 53/100\n",
      "150/150 - 0s - loss: 0.1493\n",
      "Epoch 54/100\n",
      "150/150 - 0s - loss: 0.1457\n",
      "Epoch 55/100\n",
      "150/150 - 0s - loss: 0.1434\n",
      "Epoch 56/100\n",
      "150/150 - 0s - loss: 0.1426\n",
      "Epoch 57/100\n",
      "150/150 - 0s - loss: 0.1396\n",
      "Epoch 58/100\n",
      "150/150 - 0s - loss: 0.1402\n",
      "Epoch 59/100\n",
      "150/150 - 0s - loss: 0.1320\n",
      "Epoch 60/100\n",
      "150/150 - 0s - loss: 0.1310\n",
      "Epoch 61/100\n",
      "150/150 - 0s - loss: 0.1279\n",
      "Epoch 62/100\n",
      "150/150 - 0s - loss: 0.1290\n",
      "Epoch 63/100\n",
      "150/150 - 0s - loss: 0.1237\n",
      "Epoch 64/100\n",
      "150/150 - 0s - loss: 0.1224\n",
      "Epoch 65/100\n",
      "150/150 - 0s - loss: 0.1197\n",
      "Epoch 66/100\n",
      "150/150 - 0s - loss: 0.1192\n",
      "Epoch 67/100\n",
      "150/150 - 0s - loss: 0.1155\n",
      "Epoch 68/100\n",
      "150/150 - 0s - loss: 0.1175\n",
      "Epoch 69/100\n",
      "150/150 - 0s - loss: 0.1135\n",
      "Epoch 70/100\n",
      "150/150 - 0s - loss: 0.1146\n",
      "Epoch 71/100\n",
      "150/150 - 0s - loss: 0.1092\n",
      "Epoch 72/100\n",
      "150/150 - 0s - loss: 0.1090\n",
      "Epoch 73/100\n",
      "150/150 - 0s - loss: 0.1076\n",
      "Epoch 74/100\n",
      "150/150 - 0s - loss: 0.1044\n",
      "Epoch 75/100\n",
      "150/150 - 0s - loss: 0.1061\n",
      "Epoch 76/100\n",
      "150/150 - 0s - loss: 0.1021\n",
      "Epoch 77/100\n",
      "150/150 - 0s - loss: 0.1029\n",
      "Epoch 78/100\n",
      "150/150 - 0s - loss: 0.1022\n",
      "Epoch 79/100\n",
      "150/150 - 0s - loss: 0.0997\n",
      "Epoch 80/100\n",
      "150/150 - 0s - loss: 0.0989\n",
      "Epoch 81/100\n",
      "150/150 - 0s - loss: 0.0977\n",
      "Epoch 82/100\n",
      "150/150 - 0s - loss: 0.1010\n",
      "Epoch 83/100\n",
      "150/150 - 0s - loss: 0.0966\n",
      "Epoch 84/100\n",
      "150/150 - 0s - loss: 0.0953\n",
      "Epoch 85/100\n",
      "150/150 - 0s - loss: 0.0937\n",
      "Epoch 86/100\n",
      "150/150 - 0s - loss: 0.0965\n",
      "Epoch 87/100\n",
      "150/150 - 0s - loss: 0.0918\n",
      "Epoch 88/100\n",
      "150/150 - 0s - loss: 0.0923\n",
      "Epoch 89/100\n",
      "150/150 - 0s - loss: 0.0900\n",
      "Epoch 90/100\n",
      "150/150 - 0s - loss: 0.0897\n",
      "Epoch 91/100\n",
      "150/150 - 0s - loss: 0.0913\n",
      "Epoch 92/100\n",
      "150/150 - 0s - loss: 0.0871\n",
      "Epoch 93/100\n",
      "150/150 - 0s - loss: 0.0900\n",
      "Epoch 94/100\n",
      "150/150 - 0s - loss: 0.0882\n",
      "Epoch 95/100\n",
      "150/150 - 0s - loss: 0.0867\n",
      "Epoch 96/100\n",
      "150/150 - 0s - loss: 0.0854\n",
      "Epoch 97/100\n",
      "150/150 - 0s - loss: 0.0847\n",
      "Epoch 98/100\n",
      "150/150 - 0s - loss: 0.0840\n",
      "Epoch 99/100\n",
      "150/150 - 0s - loss: 0.0852\n",
      "Epoch 100/100\n",
      "150/150 - 0s - loss: 0.0871\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<tensorflow.python.keras.callbacks.History at 0x275f1d9bdc8>"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import pandas as pd\n",
    "import io\n",
    "import requests\n",
    "import numpy as np\n",
    "from sklearn import metrics\n",
    "from tensorflow.keras.models import Sequential\n",
    "from tensorflow.keras.layers import Dense, Activation\n",
    "from tensorflow.keras.callbacks import EarlyStopping\n",
    "\n",
    "df = pd.read_csv(\n",
    "    \"https://data.heatonresearch.com/data/t81-558/iris.csv\", \n",
    "    na_values=['NA', '?'])\n",
    "\n",
    "# Convert to numpy - Classification\n",
    "x = df[['sepal_l', 'sepal_w', 'petal_l', 'petal_w']].values\n",
    "dummies = pd.get_dummies(df['species']) # Classification\n",
    "species = dummies.columns\n",
    "y = dummies.values\n",
    "\n",
    "\n",
    "# Build neural network\n",
    "model = Sequential()\n",
    "model.add(Dense(50, input_dim=x.shape[1], activation='relu')) # Hidden 1\n",
    "model.add(Dense(25, activation='relu')) # Hidden 2\n",
    "model.add(Dense(y.shape[1],activation='softmax')) # Output\n",
    "\n",
    "model.compile(loss='categorical_crossentropy', optimizer='adam')\n",
    "model.fit(x,y,verbose=2,epochs=100)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Index(['Iris-setosa', 'Iris-versicolor', 'Iris-virginica'], dtype='object')\n"
     ]
    }
   ],
   "source": [
    "# Print out number of species found:\n",
    "\n",
    "print(species)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now that you have a neural network training, we would like to be able to use it. The following code makes use of our neural network. Exactly like before, we will generate predictions.  Notice that three values come back for each of the 150 iris flowers.  There were three types of iris (Iris-setosa, Iris-versicolor, and Iris-virginica).  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Shape: (150, 3)\n",
      "[[9.98257935e-01 1.74211117e-03 1.47250105e-08]\n",
      " [9.94762123e-01 5.23775769e-03 9.35751956e-08]\n",
      " [9.97034669e-01 2.96533993e-03 5.68744980e-08]\n",
      " [9.94459629e-01 5.54029271e-03 1.55113412e-07]\n",
      " [9.98531222e-01 1.46873493e-03 1.33291875e-08]\n",
      " [9.98098075e-01 1.90198515e-03 1.37531018e-08]\n",
      " [9.96991158e-01 3.00874189e-03 7.64488419e-08]\n",
      " [9.97346044e-01 2.65395525e-03 3.05425694e-08]\n",
      " [9.92665589e-01 7.33401440e-03 3.12981911e-07]\n",
      " [9.95905280e-01 4.09475202e-03 5.66798697e-08]]\n"
     ]
    }
   ],
   "source": [
    "pred = model.predict(x)\n",
    "print(f\"Shape: {pred.shape}\")\n",
    "print(pred[0:10])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If you would like to turn of scientific notation, the following line can be used:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "np.set_printoptions(suppress=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now we see these values rounded up."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1 0 0]\n",
      " [1 0 0]\n",
      " [1 0 0]\n",
      " [1 0 0]\n",
      " [1 0 0]\n",
      " [1 0 0]\n",
      " [1 0 0]\n",
      " [1 0 0]\n",
      " [1 0 0]\n",
      " [1 0 0]]\n"
     ]
    }
   ],
   "source": [
    "print(y[0:10])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Usually, the program considers the column with the highest prediction to be the prediction of the neural network.  It is easy to convert the predictions to the expected iris species.  The argmax function finds the index of the maximum prediction for each row."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Predictions: [0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0\n",
      " 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 2 1 1 1\n",
      " 1 1 1 1 1 1 1 1 1 2 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 2 2 2 2 2 2 2 2 2 2 2\n",
      " 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 1 2 2 2 1 2 2 2 2 2 2 2 2 2 2 2 2 2 2\n",
      " 2 2]\n",
      "Expected: [0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0\n",
      " 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1\n",
      " 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 2 2 2 2 2 2 2 2 2 2 2\n",
      " 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2\n",
      " 2 2]\n"
     ]
    }
   ],
   "source": [
    "predict_classes = np.argmax(pred,axis=1)\n",
    "expected_classes = np.argmax(y,axis=1)\n",
    "print(f\"Predictions: {predict_classes}\")\n",
    "print(f\"Expected: {expected_classes}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Of course, it is straightforward to turn these indexes back into iris species. We use the species list that we created earlier."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Index(['Iris-setosa', 'Iris-setosa', 'Iris-setosa', 'Iris-setosa',\n",
      "       'Iris-setosa', 'Iris-setosa', 'Iris-setosa', 'Iris-setosa',\n",
      "       'Iris-setosa'],\n",
      "      dtype='object')\n"
     ]
    }
   ],
   "source": [
    "print(species[predict_classes[1:10]])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Accuracy might be a more easily understood error metric.  It is essentially a test score.  For all of the iris predictions, what percent were correct?  The downside is it does not consider how confident the neural network was in each prediction."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Accuracy: 0.9733333333333334\n"
     ]
    }
   ],
   "source": [
    "from sklearn.metrics import accuracy_score\n",
    "\n",
    "correct = accuracy_score(expected_classes,predict_classes)\n",
    "print(f\"Accuracy: {correct}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The code below performs two ad hoc predictions.  The first prediction is simply a single iris flower, and the second predicts two iris flowers.  Notice that the argmax in the second prediction requires **axis=1**?  Since we have a 2D array now, we must specify which axis to take the argmax over.  The value **axis=1** specifies we want the max column index for each row."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[0.00208851 0.19842853 0.799483  ]]\n",
      "Predict that [[5. 3. 4. 2.]] is: Iris-virginica\n"
     ]
    }
   ],
   "source": [
    "sample_flower = np.array( [[5.0,3.0,4.0,2.0]], dtype=float)\n",
    "pred = model.predict(sample_flower)\n",
    "print(pred)\n",
    "pred = np.argmax(pred)\n",
    "print(f\"Predict that {sample_flower} is: {species[pred]}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can also predict two sample flowers."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[0.00208851 0.19842838 0.79948306]\n",
      " [0.9900221  0.00997756 0.00000035]]\n",
      "Predict that these two flowers [[5.  3.  4.  2. ]\n",
      " [5.2 3.5 1.5 0.8]] \n",
      "are: Index(['Iris-virginica', 'Iris-setosa'], dtype='object')\n"
     ]
    }
   ],
   "source": [
    "sample_flower = np.array( [[5.0,3.0,4.0,2.0],[5.2,3.5,1.5,0.8]],\\\n",
    "        dtype=float)\n",
    "pred = model.predict(sample_flower)\n",
    "print(pred)\n",
    "pred = np.argmax(pred,axis=1)\n",
    "print(f\"Predict that these two flowers {sample_flower} \")\n",
    "print(f\"are: {species[pred]}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "anaconda-cloud": {},
  "kernelspec": {
   "display_name": "Python 3.6 (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.7.7"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}