t81_558_class_03_2_keras.ipynb

{
 "cells": [
  {
   "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": [
    "# Part 3.2: Introduction to Tensorflow and Keras\n",
    "\n",
    "![TensorFlow](https://raw.githubusercontent.com/jeffheaton/t81_558_deep_learning/master/images/class_2_tensorflow.png \"TensorFlow\")\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": [
    "### What version of TensorFlow do you have?\n",
    "\n",
    "TensorFlow is very new and changing rapidly.  It is very important that you run the same version of it that I am using.  For this semester we will use a specific version of TensorFlow (mentioned in the last class notes)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![Self Driving Car](http://imgc-cn.artprintimages.com/images/P-473-488-90/94/9475/CFB6500Z/posters/paul-noth-does-your-car-have-any-idea-why-my-car-pulled-it-over-new-yorker-cartoon.jpg)\n",
    "\n",
    "[Wrong version of TensorFlow?](https://twitter.com/reza_zadeh/status/849160032608440320)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Tensor Flow Version: 2.0.0-beta1\n"
     ]
    }
   ],
   "source": [
    "import tensorflow as tf\n",
    "print(\"Tensor Flow Version: {}\".format(tf.__version__))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Installing TensorFlow\n",
    "\n",
    "* [Google CoLab](https://colab.research.google.com/) - All platforms, use your browser (includes a GPU).\n",
    "* Windows - Supported platform.\n",
    "* Mac - Supported platform.\n",
    "* Linux - Supported platform."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Why TensorFlow\n",
    "\n",
    "* Supported by Google\n",
    "* Works well on Linux/Mac\n",
    "* Excellent GPU support\n",
    "* Python is an easy to learn programming language\n",
    "* Python is [extremely popular](http://www.kdnuggets.com/2014/08/four-main-languages-analytics-data-mining-data-science.html) in the data science community\n",
    "\n",
    "### Other Deep Learning Tools\n",
    "TensorFlow is not the only only game in town.  These are some of the best supported alternatives.  Most of these are written in C++. In order of my own preference (ordered in my own estimation of approximate importance):\n",
    "\n",
    "* [TensorFlow](https://www.tensorflow.org/) Google's deep learning API.  The focus of this class, along with Keras.\n",
    "* [MXNet](https://mxnet.incubator.apache.org/) Apache foundation's deep learning API. Can be used through Keras.\n",
    "* [Theano](http://deeplearning.net/software/theano/) - Python, from the academics that created deep learning.\n",
    "* [Keras](https://keras.io/) - Also by Google, higher level framework that allows the use of TensorFlow, MXNet and Theano interchangeably.\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"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Using TensorFlow\n",
    "\n",
    "TensorFlow is a low-level mathematics API, similar to [Numpy](http://www.numpy.org/).  However, unlike Numpy, TensorFlow is built for deep learning.  TensorFlow works by allowing you to define compute graphs with Python.  In this regard, it is similar to [Spark](http://spark.apache.org/).  TensorFlow compiles these compute graphs into highly efficient C++/[CUDA](https://en.wikipedia.org/wiki/CUDA) code.\n",
    "\n",
    "The [TensorBoard](https://www.tensorflow.org/versions/r0.10/how_tos/summaries_and_tensorboard/index.html) command line utility can be used to view these graphs.  The iris neural network's graph used in this class is shown here:\n",
    "\n",
    "![Iris Graph](https://raw.githubusercontent.com/jeffheaton/t81_558_deep_learning/master/images/class_2_graph_tf.png \"Iris Graph\")\n",
    "\n",
    "Expanding the DNN gives:\n",
    "\n",
    "\n",
    "![Iris DNN Graph](https://raw.githubusercontent.com/jeffheaton/t81_558_deep_learning/master/images/class_2_graph_dnn.png \"Iris DNN Graph\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Using TensorFlow Directly\n",
    "\n",
    "Most of the time in the course we will communicate with TensorFlow using Keras, which allows you to specify the number of hidden layers and simply create the neural network.  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/jpeg": "/9j/4AAQSkZJRgABAQAAAQABAAD/2wBDAAgGBgcGBQgHBwcJCQgKDBQNDAsLDBkSEw8UHRofHh0aHBwgJC4nICIsIxwcKDcpLDAxNDQ0Hyc5PTgyPC4zNDL/2wBDAQkJCQwLDBgNDRgyIRwhMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjL/wAARCAIIAlgDASIAAhEBAxEB/8QAHwAAAQUBAQEBAQEAAAAAAAAAAAECAwQFBgcICQoL/8QAtRAAAgEDAwIEAwUFBAQAAAF9AQIDAAQRBRIhMUEGE1FhByJxFDKBkaEII0KxwRVS0fAkM2JyggkKFhcYGRolJicoKSo0NTY3ODk6Q0RFRkdISUpTVFVWV1hZWmNkZWZnaGlqc3R1dnd4eXqDhIWGh4iJipKTlJWWl5iZmqKjpKWmp6ipqrKztLW2t7i5usLDxMXGx8jJytLT1NXW19jZ2uHi4+Tl5ufo6erx8vP09fb3+Pn6/8QAHwEAAwEBAQEBAQEBAQAAAAAAAAECAwQFBgcICQoL/8QAtREAAgECBAQDBAcFBAQAAQJ3AAECAxEEBSExBhJBUQdhcRMiMoEIFEKRobHBCSMzUvAVYnLRChYkNOEl8RcYGRomJygpKjU2Nzg5OkNERUZHSElKU1RVVldYWVpjZGVmZ2hpanN0dXZ3eHl6goOEhYaHiImKkpOUlZaXmJmaoqOkpaanqKmqsrO0tba3uLm6wsPExcbHyMnK0tPU1dbX2Nna4uPk5ebn6Onq8vP09fb3+Pn6/9oADAMBAAIRAxEAPwDyuiiivROUKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiilAJOAKAEoxnpUixf3j+VSABegp2Jc0RrET14p4RV7U6ighybCiiimSFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAIQCMEVG0X938qlopDTaK5BBwRSVYIDdRUTRkcjkUrGikmMooooKCiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACjGelPWMnrwKlVQo4osS5JEaxH+LipAABgClopmbbYUUUUxBRRRQAUUUUAFFFFABRRRQAUUoBJwKeEA6800rickhgBPQU4R+pqSiqUUZubG7Fpdo9BTgpNLsPtVqD7EOfmM2j0FIUWnkEdaSk0NSZGYz25phBHWp6CAetS4lKb6kFFPZO4/KmVDVjRNPYKKKKBhRRRQAUUUUAMaMNyODURBU4NWKQgMMGlYpSsV6KcyFfpTaRqncKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKkWLu35UCbSGKpbpUyoF9zTsY6UU7Gbk2FFFFMkKKKKACiiigAooooAKKKKACiigDJwKACnKmeT0pypjk9afVKPczlPsAAHSiiirMwp6r3NIoyafWkI31IlLoRzS+SudhYdzkYH1qQFWGQRilYBgQRkGsq4jFvMiRsyRyHaQOle/h8LRrU7Ws1+JjFcztfU01Kuu5CGHqKQqD7UseAgA6CnEV5+Kw6hNqOwRmRFSKSpaQqDXA6fY2U+5HTWUN9aeQRSVm10ZafVEJBBwaSpiARg1GylfpWbjY2jK42iiikUFFFFABRRRQAEAjBqF028jpU1FIaditRT3TbyOlMpGydwooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAoooxnpQAU5ULfT1p6x45b8qkp2Ic+wiqF6UtFFMzCiiigAooooAKKKKACiiigAooooAKKKeqZ5NCVxNpDVUsalVQopelFaJWMpSbCiiimSFAGTRT1GOe9VGN2JuwoGBSjrRSiumEbsxkxay9Rj3Oj5fjrjoPc9q1Kq3FtHMdzKCcY5r2sFs1e1+vYinNQmmylY3jea/muyqBwsi7SPqK1gciufmh2XKxoM91QnAzWnb3QeJS3ykjoa66mHdRckneS38/M2r01pOGzL1RySLGVBB+ZtowKpy6kkblCCeM5zgVCss11dqUUIYgThj+HI7VzRwMOZxm/lfUzjSna70RqEVGRj6VIm/wAtfMxvwN23pn2oIyMV4demlJoqEiKgjIwaCMHFFchsRMmOR0ptT1Gydx+VQ49jSM+jGUUUVJoFFFFABRRRQAVC6beR0qaggEYNIaditRTnXafam0jbcKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiipFi7t+VAm0hqoW+lTKoXpS0UzNybCiiimSFFFFABRRRQAUUUUAFFFFABRRRQAUoBPSnKnc/lUgGBgVSiQ522GqgHuadRRV2M27hRRRQIKKAM9KkC4+tVGLYm7CKvc06iitkraIybuAFOoorrpU3sjKUgqNuhpxaq886xjlgK9jC0XfQhJt6FK+jDgnJB5H15qiJN4LOWCk4YL379T+P6VLc3DSKAFPzjK85yM4/pTJkRLdHAwH6JnJVu+fwx2Fb4qtBSgoPXun0vb+ux6tGLjG0iW3tfPbc6qF/ugYrWtreOFQEXGKoWVwpAXOSOuB0rUQ9K0xUfZw5YbHDiJzbs9h9Np1Ia+brx1IgxjDIplS0xhjntXDOPU3i+g2iiisyxrJu571ERg4NT0jKGFS43LjK25DRSlSp5pKg1CiiigAooooARgGGDUBBBwasUyRdwyOopMqLsQ0UUUjUKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigApyoW6dPWnLF3b8qlp2Ic+w1UC9OvrTqKKZmFFFFABRRRQAUUUUAFFFFABRRRQAUU4IT9KeEA+tNRbJckhioT7CpAoXpS0VaVjNybCiiimSFFFKFJppXASnBfWnBQKWtFDuQ5dgAx0ooorRLsQFOFAGKK6KdPUzlICcVVurjyYiwP/ANao9QEzKPLfag+9gc1ktKSxDozliBmRto7f/X7969ulRVOHPZvTp/XQ1o0Oe0mzQjviw2yYDgc81UvJ9zZVuen4f5xTZbeRpEKeWF2hQynIJHXn1ppWG3hDXeVxwVUc5zkZ+o3fgKcsfThRXNG769Leep1wowjLmQkk6WkEU7xgyZzgALnnOf1I4B/SqsGpmWaRJtxSRQirnOPTJP8Ah19KbeX9tcWyQIsiqhJHHfHXGee/0B71WsJIobgSysRtzgBc54P5H096+Uq4xvEQUZrl0v8Arfbodah7rbWpr/LFcqke7KNg5OR79h05rZjlBUc1kCOG7lM6XICOGI45BHbA/OmC6LfIHIB43Hj/AD+dfW4OtRq0HzO1tXf9O/4nFXouo1Y3TcRqyqzcscCpqw4sNe7Zc5HTcAMkHqBjgcf55rbByK5cVSi6anBbnFUp+zaQlHWnEU2vFnGzKTuRkY+lJUvWmFcdK55QtqjVS7jaKKKgoCAetRMu0+1S0UmrlRlYgopzLjkdKbWbVjVO4UUUUDCiiigCGRcHI6GmVYIyMGoCNpIpM1i76CUUUUigooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiipFi7t+VAm0hqoW6dPWpVQL06+tOopmbk2FFFFMkKKKKACiiigAooooAKKKKACinBCfpTwgH1pqLZLkkMCE/SnhAPc06irUUjNybCiiimSFFFFABQBnpShSfpUgGOlXGDZLlYaFx1p1FLitox7GbfcSilxS4rRU31J5kJiloorWMLbEN3CiikJrrpU38yGyN+RWNqG0Y5GeuK2JDgVj+ar3ZSRRIHwFH93J56jrj0r1vaeyoNtXvp/XY6sJF81+xWv8Az5IYp4nWOMkFmGRg9CemcA46Z7deAMm5uZbuQSSnLAYq7qFxGqNbwjYeFkGAQ3f7319u3WsyvhsyqL2rhFvpdX0uuny/O569KOl/uCiiivNNixZ3RtJ/MC5yMH1x/L862LW7h1B9ph8sJ0bOQOn5cKeua5+tzTN0+nsglCsHIJLc7cDP4YHTPY+lenltV+0VOT01e39evyMKySXN1LFtFJPIZCwJPGTzjGOQfWtyJdkYUdAMVk2IaOUoG3KADnHXPpWsp6V9pVhBUUqa0/y02/yPHxUm52Y+kIpaK8WpT6GMWNopSKSuWUWjVO4hUGmFSKkorNwTKUmiKipCoNMKkVk4NGikmJUTLjkdKlo61DVy4uxBRSsu00lZmydwooooAKZIuRn0p9FA07MrUU512tim1JsFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABTlQt06etOWPu35VLTsQ59hqoF6dfWnUUUzMKKKKACiiigAooooAKKKKACinBCfapAoFNRbJc0iMIT7U8IB9adRVpJGbk2FFFFMkKKKKACiilAJoASnhfWlC4pa1jC25m5dgoxRTq6KcOZmcpWDFFZl3eTQTPGxXBGVK8Ef5/wA+lC6hlFUDMpAwp4yT0r1qeDi7rm1Q3RqNKS6mizqgyzAD1JpQQayJbl7rEYVgQRu25OORnBFSafNJsIkYEDgd/wBe9axwsHLkjq7Xv0CVCUYczevY1KTIqPcKa8gUZqo4V3sc9myUtTS1Zn26RkZwvyrwSeBnOMZ/WhL7LFXI3DuMgH8DXRSo03LlT1/yN/q00rsuyNxj86yLzbuDEcZ6VYkuSUyFyuM5B7c9fyP1qhNN5hrtXs3CUeZdVudFCnKLuRaoPOt4ZIgSsa7XIPT0Pr3+lZNbkT+cotpfmj2kKOmCTnnHUZArMvLOS0cblYIxO0sACcYz396/P81oP2rqLXv5dF8n/wAA9Sm+X3WVqKKK8g1CtmwQRWnmECObja7rj5c54HftyR/KqVnp01yUdlZLdicy44GP84q88wZEiVAsacAde3rXt5PheaspTVl/Wv8Al5+RhUfMrR6bmjYZWNQSSBzjPStNWGKwoLkIBnir8VydgcqQh/i7dcc+lfdVoQaUU0r7f8A8mtSk22aIalyDVI3SquefwqvDqGPnfcY2cjd2XivPq4WMfidr6GMaM5JtI1qKjjlWRdwOR/KpK86ph3FkXtowxSYpaKx9g29h8wmBRioLvYYTuAwOearabdtKFhIUbE/P6V0Sy9ez5lvr+BpFScXJdC4y9xTalIqNhg14tSFmaxlcaRkYqEjBxU9Mde4rGSNoO2hHRRRUGoUUUUAMkXK59KhqzUDrtbFJmkH0G0UUUiwooooAKKKKACiiigAooooAKKKekeeT0oBuw1VLHiplQL9fWnAADAop2MnK4UUUUyQooooAKKKKACiiigAopQpPSpAgHuaaTZLkkMCE/SnqoX606irSSM3JsKKKKZIUUUUAFFFFABRQAT0p4UDrVKLYm0hoUn6VIBjpRRWsYpGbdwoopQKtK7sS3YBS0UV20Y66GUmUb941hPmdDxVC3VyUMgUwryjE/dPUDI/D/PFX7uEyZIbjaVx25rFuF2TfOF652gYH0r169OpOj7qVl167f16ndhOVx5b6ly7ibCiBAgTDOfulTz6/09B7VXgacHZGvzDHB46/5/Wm6vLcx7HjdfLxkP8ALlu2c9ScdcVVfV3zPsXO9Qqs3Xjufr/XvXjxzNYSUoOVr2e1/u/4NkdUYOUFpf8ArqbEd8CSPmAJO3PcUy6ufkIBGfT1qrLMlzAs4neV+h3YGPwH4f5xTHCR2vnzM43Z24GcYI7d85r24ZjRdHnlv5drb/dqYrDpNSsWPPjtbAzKZFyTwOC46Dntzjv68VHuW9tmmgEgEZw24/KBjrnA9PwGKrX8ll5KxKzPjLIyjBII43ZHr+n14zY55YlZY3KhiCceoOQfY18rWzOdGr7r038767/h8ux0xp395b+ZrSXIgkiaJvMDhd4yFTJyRkjHHse2emBTJ9QgjRI7di0LcuhHIwfoOT9T/KsiiuL+1Kyvy9bfpf77a3+Rr7FXu/6/4boaR1iTyyscMatnhiAcLjpjH4/XtTJNXupgRL5cgOcBl4HQ9O/TvmqFFcv1uvr72+ny+4fsodhzOrKAI1UjuM8/mackgQf6pCw6M2T+mcfpUdFYqck7/wCX+Rduhbi1K6hi8pHATB+XaO4xn/PpUzaruLf6NF8zZ5HIX0B/rWdRW6xddO/MyeSPY24tQtbrMM2YlyBGxGSPqeOOg5p1vdrdvIAobZHhVbpgc9RyBwPb6dDhU+OWSI5jkZD6qcV1wzaun735f0vnvt2IdGPQ29kuws7iMxuoyWA69859qk85bxjtZvKhUjzNuQxOM/Qc/hx61jS3089uIZZGcBs5J6/X1q3pUcfk3DtKPM2jYnmbecnn8MD/ACa9CWaSxVeOl1b/AD0/4bV9DN0+VXf9bG3p8mxPL3KyrjDKODxWhvrBhMtuPmBDDHyYOef6+3t9M2vtoKjB69hX1cI0q0bxle255tag3O66mgbmIMV8wZHUZ6UomVhlWBHrmsZDvdjNGBCcyEsSCcDtz1xk/TNE8rpM0sAYwuxCtnIY5yT/AJ9K5fa0IVXTnpbrdW7j+qX0TLOoS5XYSQh6kf4VJpZKq4cAMG5A7e3/AOuqEq3PmAFMlfmyBkcdalkBt5h5TuA+Cq9W98k9Dn61c6tGVblg73VtO9/+H62NXS/dchucGmsMrVawhmTfJM+5nx+GKtHrXiY6jGnPlickdHZO5FRQRg0V5R0ELDBxSVJIOM1HWbVmbxd0FFFFIYUyRcjPpT6DyMUhp2ZWopSMEikpGwUUUUAFFFFABRRRQAUUoBY4FTIgUe9AnKwiR45PWn0UVRk3cKKKKBBRRRQAUUUUAFFFKqlqAbsJ1p6x+v5U8KF6UtWo9zJz7B0oooqiAopQpPal2e9NRbFdDaKfsHrRtFVyMXMhlFSbR6UtP2YucjCk04IO9OoqlBITkwoooqyQoopQKpRb2E3YAKWiiuiELaIzbuFITxQTio3kC9TivRw9Bt6EbjZOh+lZTCN7mVZHVOmN/Tr/AJ/Wr7zKR1rJvJFZuvNetLD81Fweh14ZNSKWryTMUBSRLcnKDJ2njsPWsyt+KA6hbtAYxkYPnEZPHQZ7elY9zHBGxEMxfJyBjgL259fw/wAK+BzLDyjUdXpt8/JdvS/metTkl7nUsafepaRSeapkRuAm7oeOf0/lUE95JM8pG1FkOWVRwen+A/yar0VxvFVORU1ol+O/X57bF8kb3CiiiucsKKKKACiiigAooooAKKKKACiiigApVYo6sMZByMjNJRQBet74CSR7lpGLdPLCjnuc9u3Tr3q2imVwbY5XG9SWGQB6+nSsarVldNBJsZyIZPlcHkAeuPUV62BzGpSfs3Kye79XrcylBJXQt3eyyyyJnEZblAQRnGCf/r0ltf3FqzGOQ/MMc81Vorg+s1ebn5ncvkja1jcspZktmeZ1Jb54yArHIB6n8enUfznht7gx5TDc7treuOv1qK2gZrBYc7PLPzBv4m5OeCcDHfvitexQhG5JG4gZxkduxr7PLORUH7S7ku/yf5+X3nnYipyK8S1CpWMbic+9OPWnU09a4sXPmlc8+G9xjjmm09xxTK8yaszpjsIRkYqGp6icYY1nI1g+g2iiioNAooooAilHINR1O4yh9uagqWaxegUUUUFBRRRQAUoBY4FABY4FTqoUYFBMpWBVCjApaKKoyCiiigAooooAKKKKACigAnpUqoF5700rickhqp3P5VJRRVpWMW2woopQM/SqSuIACaeFApabNJ5MRkKlgOTjriuqjQdSXLHcylMdRSqwZQQetLitp4acNGZ86G0UuKMVn7Nj5kJRS4FLij2TDmQ2inUU/ZeYuYTFGKWirUIoXMwooorRRb0RNwpCcClprGuujS1sS2ULnUBFKYwhJAyeO3tVVnkuHy7IqEbSM5Iwc9Mj0H50/UARMj4GF7nt71BLI8VnOYCwkQHIVSAgB6evTOT7CuvFTdKLjsmtNN/Lfy8n2PQowjyqUVqQK0/lk7DtxngY49cenHWkMssVk08aK2xsPlVPB/X+f+FX+1i14JWjHlY27eCQMY6496df3qqXgiiEZ2gHD525wSOnXt1x145rx8RnMa1Fx5vh8tb200/z+7Y7fZtPbcgvLwTKiRqqqEAbA4J4J689c96pUUV8xUqzqu82dMYpKyCiiisxhRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAOjCFwJCQp7jt6Vr/ZbCAb4/MuCSdpY4VTn26n9Kxqu2NysbeW6ocjCu+SF5z0APv2713YKrShNKpG+u/X07fgZzi3qbMCi4dXdVyBj1J+tbEQCgADgViwxXED4bAUZ+btxn8unf1rWt5N8YJBB7g9Qa+9cqM6VqO3X/gnjYpSve+hZpDQDmlrw69N6nPFjSMioqlqNvvGvNqLqdMGJUcg6GpKa/3axexrHciooorM2CiiigAquwwxFWKilHzA+tJlwepHRRRSNAooooAnRdo96dRRVGG4UUUUAFFFFABRRRQAUqqWNKq7j7VKAB0pqNyJSsIqhRS0UVoZBRRRQAoGTUgGBikUYHvS1tCNjOTuKOtJIiuhVgCD1BpRTJpPLiLbS2Ow616WCg3NW3MJ6vQyLjfaz7IpWCsMMCc7Rnr+ta8R+Qc9qw53a5uAfLbaDkrg5I55/wA+tasEqmMYIxivcnD2kZRXRr8jevF8kW9y3RUYf3oEqsSAwOOtedLCPsct2SUE4pu6qt1cGFNwGeQDjrVUsJzMaTk7InjuY5JHRTyhwalrAjbOoMwcHnkqTj8+/wCVbSOCOtaywylDnitDStS9m1ZktFN3UbvauZ4fyMbjqKbu9qCSatUmFxSajY8YpScVTvJmjQbcZyM5OK7KFK2pUIuTsiG8mQAqepHSs63w0xTa53jHyPtI5zU6zx+SzTc5yJDtzgcgYP8AnqOtVDcWv2aXyGmLKck4Xp0HUepA/I9sVzZhmEFD2TjbS+tk7d7eh61GnyJopXtvb20zJFMZcccdjxnP6/561KdJI0rl3OWNNr4WtKEptwVl0/rU7oppahRRRWRQUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAalkBJbySMS7sdoDnGMcnHPPGO3cfjq2d3HHGFLAY9awNOkEd6gIJWTMZwOfm4qydRhiZhbpJjGBITgnpnI6Y6/pX1OV5rToUHGpv3f3+bOStR9o+VnSi6QpkMMetRWt6z3HluDtc/uztxnuay1zdEtDIrRu2WCjPl59R7Zq7aSrHeODCVYsEGFxgY4/QZr23WpV0o07aq79ey/z8jhlh1CL6s1jUb9RUhpj9K+drqzZjTYykb7p+lLRXKbEFFFFZHQFFFFABTJBlPpT6QjIIoGtGV6KKKk2CiiigCzRRRVGAUUUUAFFFFABTlTPJ6Uqp3P5VJVKPczlPogoooqzMKKKKACnKvc0KueTT60hHqyJS6IKKKUCt4x5mZt2FpGGRS0HpXoYfR3RjIyNRtmdwyqCo64OCaqCSSI7Q4UHOCewz36fXpW44zWXeRqUPY4zXvU4OonKMmm15fLc66Fa6UJK6IjdSxxAt3xggHGPXJoguWglJlG3cAaZaTMJz8v7tVJKqTwPbn/635Upnsrtpg8gikV+WbaN3pjPP+cn286WYSpVFGr0uui6d9v+Bc6nTjqraM0Uu1fjoR1yKqXsm9ODgg5B71TkDwPnejBv4k+7nuP8+opDHMyBjjDDIy4yfw/A13RxmH5Fz6NrVfmRHDcsuaJND++aZo4SHA3ZB4B/oO/4VZhuZIwhk6MOo5HUjH6VVeRNPgS48tiz9MnOPYj0OOv19KbaTi8sfKWPfOg/vHPUc49BnA988da8qlmUYVeS+nZ9v62XkzSpTUltoaL33zBE27iCck4HAzUlrdGVTuPIOMjHP5ZrKgEscx3KuzgPuwVIz1+nTmp3/wBFcSRj903Tacgfj3PBr0IYqnVrOH2ej8zGeGio2W5sB/xpS1Zkd78yqwKluRkY49atCbI+9XQqMZax1Rxyoyi9SZmwMmqF467CG/Gpnk9Dk1QllQTHzMEY4JGRnP6961f7mDna9jWhTvIYk7PEY58+RsI3FfujGOP1/wDr1hShFkZUO5Rxn1961725u7dVBaOSFl5HKhvwzk+vHrz04xa/P82rqpU219OnS2uzPXoxsrhRRRXkmwUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFACo7RuroSGU5BHY1YFjcOu+KJ2j3YBIAPqMjPHBH51WrVsTFPaiLzER05OVI4J6579QOcdPxrrwVGNeqqU3ZMzqS5VdFyGERmJbSMYAUuxADMccnnJH6itWztnjbzZWG8jGFAAx26Co7FUEQIAGQDitAdK+1q4eGEhyw3tY8avXcnygaa33acaa33a8Grq2RDoR0UUVym5C33j9aSlbhjSVkzdbBRRRQMKKKKAK7DDEUlPlGH+tMqTZbBRRRQMs0UUVRgFFFOVCfpRa4m7DQCelSqmOT1pQABxS1ajYzlO+wUUUVRAUUAE9KeE9aai2JtIYBnpTwuOtOAxRWsYJbkOVwoopQK1jFyIbsAFLRRXVCk+hk5BSMe1BOKguJTHGWAyRXo4eg20kTq3Yc7AVk3jAttLFRjGew/D8/89XvfjcQRgj3z+oqnNI0gDlSIycbuv+TXqr2dOldysn1X6HbQoyUtUPjJNmyW5USNwVPVsg9/w6f41z5JYknqeTXR2kq2QeSSfMSnDKoJHPGTxxWJezRTTOY4wMtkvk89f/rdeeM96+Iza0knzbdO/n+mu/Q9Kk/eaS/rsaFtfQJZRi5+dsHBB3N1Ixjt1B544PrVSXVbmQLtbYy45XA6Yx/n6elUaK4J4+tKKinayS030t136GipRTuyzPf3NwhSWXcpOcbQBn/P9fWmRXUsCYibyznJZeGPTjPpxUNFc/t6vNz8zv3vqVyRta2heTVJkikTJDOSxZTjJOcn689sdKsWFxbvbG2ncq5ffvI9jxn9fxxWTRW0MZVi43d0tPk3fp+ZLpx6aHTTiG4VntnBkg+VxjB6kc9sdfoP0Z5rwv5coAYDkdcVjWd/NZMTEcA9QO/Bxn16/wD6q0zKt5arct8smNp245xj8+v+R0+oyrN1ZQfq1287v+m2csqDWj2Jnn+XqPoKjt/3s/Rml6oq8ZP17VW3VLFIscMshLIRx5gG7bn24/D3r2sfioewai9/6/roKNPlTKOpz3Ul0UuWyydAOmDyD+tUqdJI0sjSOcsxLE+pNNr82rVHUm5vqdsI8sUgooorMoKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAq/YTiK3nVpxGpKgAk8568AdOOfoOvFUKtWlotyGZ5hEqsASVJ6g+n0/WujCSqRrJ0leXQidram1b3D/ACxw5bcNyFgFyPxrWsJHltEeT73esyGLMawwRyMg48wvyw9DwDj29q17aLyIFj3FiO5r7arVqzo/vlZ2XTr1PHxPJ03JD1pj9KcetNftXhVXuZw6DKKKK5jYif75ptOk+9Taye5vHYKKKKBhRRRQBFKOhqOppfu/jUNSzWOwUUUUFFmlClulOVM8npUnStFE5ZTtsNVAPc06iirsZt3CinBSaUKB71Sg2S5JDQCacFA606itFBIhybCiijFWlfYkKMUuKWtY0+5Dl2DFFFITgV10qV2Ztlae9WCULIMKRw3v6VKkodQwPBGao6lEXUN1VeqjvVeC5MI2O2R1U56ivbhh4OytutP1NlRUqalHc1i3pVeZgVI7YqB7olgqYZm4AzjNVTeB1zXTSoqMrdQhRluQSMY5Nh2lC2TuUHr15xmn3l59ijzDFmKQ4BI+Xp7r7tjn147VGixzOoyxkJHyEYDc9M544qDUr7dbxwJDLEMdHJ6eoPcHkV87nNWEXJx06bddOnn8vzPThG9kynf3Ru7pmGNgOF4xkdP6VVoor5CrUlVm5yer/r8DsjFRVkFFFFZjCiiigAooooAKntrya0LGIgbhg8f16jt+VQUVUJyhLmg7MTSaszdnhZ4Y7pFISQDg9jj+VV7svFpwQyMBI2THg4Ppz07fpUmiXSZNtOWKn7gLHA/DPr6D1o8Q4S4hiX7qpnrx1r2p4mpPDOotrWfk3pb9fmc6l76pNefyRjUUUV4Z0hRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABV+waLyXUyFZC2QoB5wOO/uaoVu6YvlmFVSHzNufMxknJPQjHrg/SvTyilUqYleztda6/IyrS5YXNbTpN4dGwHQ4IBzgfX860Kr2lstuhA6sdx+tWD0r6XG1XJ+89TwpuMptx2G0x+tPpjferxamxrHcbRRRWJoRyfe/CmU+T734Uys3ubx2CiiikMKKKKAGyfcNQVYb7p+lV6TNIbBRRRSLNCinBc08LjoK6owbPOckhgT1p4AHSlxRiuiNF9EZOYlLgDqaWqt7IFt2PUrhgPoc13YbB+0kkyOZt2RawKKghuEkAwwPGetTZFaVMFKDtYlya3FopCwFQpco8jxg/MhwacMHOS0FdvYnopu8e1IX960jhX2FdjicU0tVS8uTDCWQjIIqFb0MmScEdcGvQo4T7y1Sk1zE1w4wc1lxFWeVC21uNn1z1Hv/nBonmaWXajctgDnvT4LfZumnT5IzkPuADc+/b06VOPrQjT9h9q6/q/3/cehRp+zjdjI7UoyyPJ8ik7iuVIx6ZHrTRbwu0gjmBKjhW+Ug8cH+X1rLnvXe4aSFpEBHUsc9c59uf8APWq3mPvL723k5LZ5z6181Wzm07JuVtL3tp5ad9dfQ7I0pPVux0EMEtuJZWUBoxlTjPJ447HrWDcSCa4eQdGOe/8AUn+daEOo79PktnC8RnJc53HtjPQjjv249Dl1wZjXVWMHGV76v8rNd1+uhVNSu3JBRRRXlmwUUUUAFFFFABRRRQAUUUUAOjdo3DKSCPQkfyq3qQfzYndifMjDjPoc4/lVKppgRHASPvR5Bz1+Zh/SumnWkqE6V9HZ/c/+CS17yZDRRRXMUFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUVJFE00gUcDPLdhVRi5NRitQJ7CAyXCuYiyLk5x8uccAk8YzXSaXaiOCNipXAIC5Pr/AJ/IVV0+wXamVIjHIVjnJP8An07CtxBgV9pgsAsFR5qi99/gePjMTze5EdSGlpD1rkryvc44ISo2+8akqM9TXDU2N4biUUUVkaEcn3vwplPk+9+FMrN7m8dgooopDCiiigBG+6fpVerNVqTNIBRRRSLL2+87W9v/AN/z/wDEUnmX2f8Aj3gx/wBdj/8AE1KH9aeDXq0q0Uv6/wAjypRfb+vvK5kvv+feD/v8f/iaYZb/AHgeRDjH/PU//E1czS5rsp4mC/pf5Ge3Rf18yiZL/wD54Q/9/T/8TWTeyXReTzI4w2zgeYfQ+3NdJVO+gV4HIUbjwCfXtXbSnGtF01Jpv0/yX5mlGqoTV4owtOlvS7tsDOSdxc7T/KtQTajzmCLrx+8P+FXILRIiWA+Y9T61Y2irp8tCmqTm5W66f5MdbERnK6ijGE2pFW3QR9T1bH9KrRvcCbdGimU53jeePT+H+proSgNV47NY5pJO7nP0raNWDt77VvTX/wAlCNeKT91GS8+obk3RqDngBzyfypZJ9R8klolHuGPH6VueWPQUhQdxTjVi38b/AA/+RF9Yjp7iObeS6dlEygIcZ+Y9PypsoIn2lI1TJztkJ7nvj+lbN9bF4SEXJyKgWwUR/Moz/KqnhnW2qyWndfdt8zqp4mCje3yM+2G4kssZcfcDSEZP/fPNQ3sl8086+XlAuXAXcq5XJ5I45yfr9KszRCCYEAHaQQD3/wA4qeKVbtXhnEe1jhARluuTyOf5ZryMbg6kW488rX+L5PR6barbudHPf30v68jmqKmuLcwysisJAoyWXt9ahr46pTlSk4TVmjsTTV0FFaFvpzNZvcsoZfLYjGflIz16enr/AIHPq6tCdJRc1bmV16CjNSbt0CiiisSgooooAKKKKACiiigAooooAKM0VLKcxwcKMIenf5m61SV02IioooqRhRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUATQLbtnzpHU84AXjp6/wD1q1rNEG0AAKeRjo3Xn371h1Nb3DQOOTsJBZQeuP68mvWynMKeDrc04Jrv1RlVpucbJnaQ42jFWB0rH0++D7ULh89GXoT/ADrXU5FfX4lxqRVSDumeBVhKErMdTT1p1IeteFV2HESoz1NSVGeprkqbG8BKKKKyLI5PvfhTKfJ978KZWb3N47BRRRSGFFFFABVarNVqTNIBRRRSLNCgHFRq/Y/nUlbJnC1bceH9adUVAJFaqb6kOPYlzQwVxhhkZzzTA/rTgwNb067i7xZm4D6KbRWjrN7kcg6im0uaarCcBaKTNLW8arJcRCAaYV/OpKQjiu2jXZDVijcRgg8VlxIgklkcZKAMo/H/AD/ga0dRl8tQo4LfxdhVOCEzfPyqqfl5/X6/59K9SrF16SpJ76+i8/U78O+WHM9hiXMbuN4KFiSZGPK8k9gD1/maYDaRyyyKpdz825uNze2PxP6Vca08t1eNV3KcgHpmqpsyq4PWud5XGUrKWnfRu+35G8a0HqOSdrqCaExjDAbFUZ5HbHfgVz80flTOmc7TjOR/QkVtxbIZUfe3mgjAIwoOe5z0xVPUrOSNEnaaOXdwWUBeO3ux6+/TNfM5vhJRTS15W/W3V/f6/Lr005RUtNL/AJmbRRRXzp0hRRRQAUUUUAFFFFABRRRQAoG4gDGTxycVavyPMiQIF2RBDgY3YzzVrRLZJZ2lkcAJ2zyfXv8Ah+PtT/EKqLuJ0I2smcD69f8APpXoQpQjg5Sk/ebVvRP/AD/IwdS9VRsY9FFFeebhRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFAF3T5m85YCVKMSQrLnLY49xkgV0unXYliRWdWcjPBHIrja6DTfM2QyIhEe3hQ3A5wep7kV9JkeKnJvDSa5d9b/AIHFjKUZQudHSGoredJ0yhBwcH2NSnpXZiqfK2eRG6dmJUbfeNSVG33q82psbw3EooorE0I5PvfhTKfJ978KZWb3N47BRRRSGFFFFACNwpPtVerDfdP0qvSZpAKKKKRZZpyuV+lNoqjBq5MGDdKWoKer9j+dWpdzNw7ElFAORkUVRmKGIp4YGo6KpTaE4pktFRhiKcGB9q0U0yHFodS5pKK0Ta2IaHUU2lBrop1dSJRKdzZG5lG9sRqOAOpNTRwiNAozwMZqeivUjjG1YlylZR6IiK1XmQBT6VcIqvcRs8TBeprtw1e8rNig9TDkjaWTKIxTPLAcY+tPv7a5mhEVs5MSdRz6DPO3/e7/AIVNJYMWYsepzgdP1qs4liQR7tqZ529T1/xPtWGPwVXFJz022T1S338/I9WnUi7KL2Mm8tWtLh4yG25+UkdR/jVeuhigh1FnidXDsRhsgnA7ZI449P16VjXdt9nkYK6sueBuBI9Pr9enIr4vG4J0m5w+H8n2/wAvI7IVLvlluV6KKK881CiiigAooooAKkiglm3eWhYKMsew+pp0FrLcMFjQknOODzwT/SteKL7DaqrEx3BBbK9cEjHP4f57d+DwM68lzJpem/p/VjOc7aLcdJO0NpFZoQdgG4gY59OOO9VL5zNYpnfuRuem3/PWnEFjkkk+9SoPMs5oWkfYfmKJyTjknnj/APVX0WKyx06N2ulvw/S3n8zJSilp3/4cxKKVlZGKsCrA4IIwQaSvjjpCiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACr+nrGqmfzHWZW2rtIGMj8/WqFXLG6hgV0mWQq7KfkxnADev1FdWClThXjKr8JE78uh02moV8x24LtnaOn+etaNYsNw0cayxTxvAxwpbOfoemOhrWgmWeFZEPBr7HE+yqR5qOy/X7zw60JKXM+o6mP1p5601+1eHUWjHDcZRRRWBqRyfe/CmU6T71NrN7m8dgooopDCiiigBsn3DUFTS/c/GoaTNYbBRRRSKLNFFFUYBRRRQAoJHSpFYN9aiopp2JcUyeimK+eD1p9WncyasFFFFMQoJFPDA1HRVRk0JxTJaKardjTq2TT2M2rCg0tNpw5rohO+jM5IKawp1Ield1CbuZNELpn+lZN4oD5Ynb1wOp/p3/AM99hzWXeMoQ554r3aF5wavY3w7akV42e3smkhLMSc43fKDg9f04+lc8xZnJcksTkk9c1v2iP57oGCqylWYMCOf0P0+tJ/Z1nA0z3JLlnwq4IK/XBHXn6j07fI5lhHWmlB7N97Pz9ejt+B60ZqDd92VLXTY7qySRmEZ5G5eSTnuPoOg9RVOWyuIFUvGwz2we/T+v5GtSdzK4VY2QJxtJyQfT/P8AWlF1KqqNo3KMBsnP8/8AOBWksl9pCLUem662trbbX+rjU5LW/wAjGe3miz5kMiY67lIx/nI/OkEUhjEgUlCduR68f4it64RtQtUhSVS4OSB1Y8449Mnk/wCFR6fC1laG5V4xKwIALc9Rxjp7/Q15ay29Xljfl76J37W/4b8CvatLXcyhYz+U0jLtC5yCDnjOfp071bsLGB7f7VOzeXu2bcd8H8+349qu20k0k5RE4dtzBcjHqc/160+WNZGEMKqEBySvIJ5Oc9e9ejQyde2jBL3lvfVeT+XZ9e5EqrWj/AeUi05JBblt85BIzjGGPGByO4/ycRMj3EpldQGPXb0NTraOzo0jZKjGenHarYhAHINfT4HBww0feWupxTrJbO77ma8GB0xTbY+VOW3BXH3VYfK31/Q1ovEMfL+VUWhzccMVIwVwcEnPb3/wroxqjOhK/QqlU5tGY+oCX7a7TQ+Uzc7cY/H8aq1saj9pujHH5JCgAgyOMjPPXOOR69wfSsevzXG0vZ1Xa9n5deq6Xt3/AAR6NJ3igooorkNAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACrdnBFNDMZFY7SuCrYI68dMc/0+tVK19PAgtPMczEScBAwCkZ5/wDQRnpXbl9FVsRGDV0Z1XaOhbt45FIaLLqE2YcY3DGOcGtfTw4s08zO73qGxC+Uo4JwKvjpX2+LpU6MOSC6WPFr1nJ8rQHrTH6U801vu185V6ih0I6KKK5jYif75ptOf7xptZPc3WwUUUUDCiiigCOXoBUVPl+/+FMqWbR2CiiigZZoooqjAKKKKACiiigAp6v2NMooTsJq5PRUSvjg9KlrRO5i1YKKKKYgp6tng0yinF2YmrktApAcilroT6oya6DqQ8CgUyZXaIhG2sehxnFelhLSmkzGS6Gff3TRMFGAG43HtVBt0pztZlGRwfvc/hjj2/CnTiSO5CysGLHAYgHj6EVqW8CrGMDtXuJX5uZtRWmjt6v/AC+Z280aME0rszAlwYQE3IFGAAR069R3/wA9qbHA91MfMGCAMnue9bvlr6fpSJbpGWKrgtyayi6FNppf8Ht936mf1t2ehRjsQmSRnPsBVe8iEcZOK2dvtVS8t2kQbMBgwOcciuiliU/dj8jOnWbmnJmXAGtnm+eMuF27e+e4/Q9Papo4XnSNGG1VHKgdwTj9DUcaqt8VC7Ru6Fs/l61tJGAK5qUKcUqsr81/TX0OnEVnDbqZr2JU7kUEYIKHgN6frzUtnamNSWXGTwMdB+ZrQ2+1Lt+lN4mKk5LdnI68nHlZGEx0GKCpqTaaTGKhV7vcxuyFlDfWqF5EpUk1qEZ+tUb2JnQbQDk8g+ldlGqrG1GXvIz4/PeF0meQW+wlj/s9c/z+vNYMoQSN5Zyh5Ht7fhXQiEzWxSSSQKAd46hAAenP9fXrVBrC3W2laKZnYnbgxE7R19Pbr6Z+lfH5th3Od4JJat73T7f11/H2KU7Xv+BlUUrKyMVYEEdiKSvnWmnZnUFFFFIAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAACTgDJNW1vniTy40jKBshmjGSMAc+nQdKTT0L30RDFQh3lsdAOf6VK+m/MTDOrp2yPmPrx+f5V2YejXa56O9/63Ik43szWido/La2/eRuAS2D8pI6HHAPPua1LW6MvySIySYztKnp61hwrHZPtjhOVbEjH5icdcccVoWkMhu3PmbSrDICgcY4HHsa+woe2qQUK3a/8Awf6+Xc83EU4OLl+Jqmmt92nGmP0rxq2jZyQ6DKKKK5Dchb7x+tJRRWR0BRRRQAUUUE4BNAEDnLmm0UVJuFFFFAFhWDDNLVdWKnIqcEMMimZSjYWiiimSFFFFABRRRQAU5W2n2ptFANXJgQRkUtQgkdKlVg1WncxlGwtFFFUSKDg1J1qKnK2PpVwlbRkyVyQdaGOF5pKZcRmeFowQN3BJGcCvRwcoqaUnZGElcx7x1nuP3QLqMF8cjH+c/ma2IVHljHTFOSJEUAKOlP6V6dfF07NQ3fX00CpPnSilogoozRmvPdZt7kcoUhGaWinGtJMXKVorNIppJRyX9e1WQMUUVrLEyluN3k7thRRRWXtWKwUUUVcaqe4mhpFMdcipaYwruoVGmIyry3B3HOCetZ8G1ZSWeNUUZO/ODWjfs3mLGBkN1GcE+w96qzKYrSd4ciRhzwMfe4wfTqfwrfH1E6TjGN5eS23t/SPUw7airvcyb97WWdntywHX5uh6cD0x/T86dXhpVx9rEDYx1MgBIxjPHr3+tP1CwaIvMhiKgAsI84B4Bx2xk9OvPpXwdajXm5VZxt3O+M4q0UzOooorjNQooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooq3ZWhuHLYDKvJUOAx+nB9fxq6cHOXKhN2V2WNP2CCXG3zk/vYXAPBA5ye3GP586lnaB13hmG4Y4OKijfz5MG3QKc8BR745/Lp+Va1rF5cQBxnvgYr73LsM8LQcKkd+631/q55mKrWWm5H9iTy9uMj3qOztJFut5yqR8LwBuHTB79u9aQFLRiMWmrNarY4Y1Z2a7iGo36in1Gxyxr56rK5pBCUh+6fpS01/u1zvY2W5FRRRWZuFFFFABTJDhPrT6ilPIFIqKuyOiiikahRRRQAUqsVORSUUAWAQwyKWq6sVORU6sGGRTMpRsLRRRTJCiiigAooooAKOlFFAEivng0+oKcrkdeRVKXczlDsS0UgIIyKWrMxQ2PpTwQelR0VcZtEuKZLRUYY07f7Vp7RMjlY6ik3CjcPWndBZi0UZzRTEFGaKKd2gFzRmkoqlUkieVDqKbSg1pGaZLi0LSEZFLRXTSqcr1IaMy7sZJZvMV+2AD/DVdC9u+xkKgDJZD0BOOBkD0/GtojNQSwJIMMufavT/d1k1LRvrr/VjeniWkoy2MENOQdw+YDbll5A/yfrSGKd7ExwxFnc43bDwvQgH/AD1/LXa2RVwoAHtWXcxiNiQcE8HBratl9OpR5aej/S1vl+XkdlPEc7sZd3YvbbD1UoGOOcdM8jjrkfhVSt+ArBbNPPHHJB02sAxz/Tmse5FtuP2cvwcYI4I9c9fwx/hXw2NwkKLvGXy6/Ly9bHdCbbs/vIKKKK841CiiigAooooAKKKKACiiigAooooAKKKKACiiigAooqe0tzcThcMUHzSFeoXuaunCVSShFXbE2krsijCFx5hIXqcdfpWx/oUihLW4Ubc4SUbc89ie3PANYtAODkda6MLi3h5XST1+f3kyjfW509p+6ZVbGSMjB7f0/GtiPkcVz8MqtaieVRIZOhHG3qNp6ntweta9jJuQgEkA8HGM/TnpX3NLFSxdG9tuvf8Ar17nj4qlb3i7SGlpD1rxsQ2mzmgIeBUVPc8UyuCo9bHTBaBTJD0FPqJzlqxlsaQWo2iiioNgooooAKrscsTUznCmoKTNILqFFFFIsKKKKACiiigApQSDkGkooAnVw31p1VqkSTs3507mco9iWiiimQFFFFABRRRQAUUUUAKCQcinq4PXio6KadhOKZPRUSsV+lSBgatO5k4tC0UUUyQooooAKXJHekooAcHNODA1HRVKbRLiiWiowxFPDA1qppkuLQtFFFUSKDS02lBrWE+jIkuotIRS0V3UZ6mTRBIOD9KymWN7mXzlZ1GMKCe5x/OtC6mEeVwSdpb8BWLcszzFWBU5wc+vT6V7E2vq8lzWf9fodmEg2ypqxlWVY2ZCq8AqOTgDqcc/0rNrc1gzGGOJIWNvgFGwePf6ketUG0yceaU+ZYwGBxgkHp+PP/66+HxuHq1KzcE2rL5abLul5f8AD+pSmuRXEsrL7asiqyoyfNubPT0qGa2mgdkdD8vUjkdu/wCI/Otby47a0EEbSbycsHUqefbPsP0pHEUto0bMUckliFyXyR9M+vNdn9kylQU2rNLddX2+92uL2rvdbf1qYlFat9ZWscSyxyMiHKqWXJfA+g6nj9fWssIzKzBSQvLEDp9a8WtQlSlyyNozUlcSiiisSgooooAKKKKACiiigAooooAKVVZ2CqCWJwAByTTzC6wiVlwhOAT3/wA/1q9pi2rRT+aqecigpvYgHk5/HpXRTw8pTUJaX11JlKyuQW9kZWkWVmhKYJ3Rkjn19KvRuLUGOIB49uDnOH68n061PGXmbeFxJn7wAxnOc/4+vHpzYFntAK5DKcg19fgMjUIt1NH08+39dTkniEnaRz9zbSQzuuzgc/KCQB1qOG3lnLCJC20ZOB0rfVfMLQzlDEcgksBhsfe9zg/16ikl8yGdobZvlQkgr976E9e1eVLI/wB+6cXe3T8d+nTu+5oq+livYrJNZFTAyrH93arEO2OvXrwfb29bdveyqgWNNzY/DgVHJLOJcrGqljwoUHJ9fr6VJKyPIBD8yqQdyjKOSM5OOh/P8K9zCQrYRfV5a3Xrptey+7btv0wmozV2jbifegJ/lilPWqtjdGdWRoyjp1Bq0etcWYQ5KljzVFxk0xjnnFNpSck0lePJ3Z0LRAeBmoOtSSHAx61HWcmbQWlwoooqSwooooAilPQfjUdKxyxNJUmyVkFFFFAwooooAKKKKACiiigAooooAcrlfcelTKwYcVXoBIORRclxuWaKjWQHg8GpKozasFFFFAgooooAKKKKACiiigB4cjrzTwQelQ0dKakS4Jk9FRiT1p4IPQ1aaZk4tC0UUUxBRRRQAUUUUAODetPqKlBIrSM7bkuPYkopAQaWtTMcKKaKdXVRnqjKSKN/EskR3MVx3BxWdbhZCEeKPy+gY4G5uwz/AJ/pVq9hnmlc7WWNRj72d3vgf5/lSLYyeXG+cumCqtwB07fhXtVKXtqfLZade+my/wCDsdlGap01eW/4EV7I0eHAWTf95iR8p5HGOnT1PSq8UtxuaQDeWAB3dCP8/wCTVh4XtcSNtC7txAAIXkdM1JpyMyZMe0dRjpj2qMPhqcZyhVWujT/rqauoo0uaOq2GfZXkbMshfbkLu9M1HdW2EyBz9eK2AmBTZIg6ketejCtCK5I6I41iHzXZiS2kU2nldw3Bjtk2YAxzyfyHXvTY410+2eJWSR3YMRtPA7EHAIP8u3eriW1xCriPjdzkcHOfUc4xSLaMxJk3AZ4Vmzj+n+RXkxypTq3n5631tr+d/uO11463d0Zk1nGZYYoUUMdu5XBGSOMZODnPp79MZpk+mIPL+zuzr/G56DJwOMD+Z/StVoHjQrHhVYFWx/F1x/P/ABqnIjxoU3NsJyVzxms/7AjJS5kvL5W+69tfXuaQr3as/wCv62KLaTdiNnEe/a2MLknpkH6Y/Gozp12CQYHUjPDcE/T1/CtKEMpEkjFY1UldxwGx2GeOv5VR1DUpbs7PMJjXODjbkccEZ6cV85isHQw9+Zvys9381t/wx0KU27KxTaNlUElcH0YH+VOSF5B8gBJ6LuGT9B1NR0V5acb7fj/wDXUmW0uHXcsLlcE5xxwM/wBKsHSbobjtUhW2k54+v06/lUljqr26pbyn/R8ndtX5uff2qeSFlIckMrYIZTkcjIr18HgaGKmowb+emvy6ef6mTnJXvoNh0mOPdLdSExKRtKDh/Uc4PoeO2aksrR7WSVlbJK/LzgdxyT9R09e3QyxwNKo3EkDgc9KupbM6Kj4IUbc4ySM5xnsOK+iWQ06TTjb73pp+Pp/wTkniLXuyhJOZoXW5UururAHOABnPf6U6KBLJ3UE+VIMrgDcpGMgn/OPzrSNoMZHDDkEdRVeOzllxHI7bUY9euMdj6Vricvp+0U6SXb779unl5kQxEGnfRD7CMMpYKVTjaCcnp/jmtDZxjiiCBYYwi9BU2K2qYnlsk9jz6k+eTaKZsYWLEr945Izxmnrbog+Ufj3qzRiso413sJzm92Y1/FtAJyqeoGTmpdMBkEjuBuLc49e/+RVu7RTAwbGMdziqumQSJiVs7XXI+bpXTOpde1v0aOhT5qDXU0QiqSwAyeppGOBTiajY5OK+axFZzd2RTiNoopjtgY9a4m7HQld2GMctmkoorI3WgUUUUAFMkbC49afUDtuakyoq7G0UUUjUKKKKACiiigAooooAKKKKACiiigAooooAKeshXg8imUUA1csBgwyKWq4JByDUqyA8Hg07mbjbYfRRRTICiiigAooooAKKKKACjpRRQA8SetPDA9KhopqTIcEyeiow5HXmnhgelWmmQ4tC0UUUyQooooAAcU8NmmUVUZNCauS0oNRhvWn1tGfVGTj3HdaMD0ptLmuqGIa6mbgNkiSRdrDIyDSqiqMAUuaWuhYqTVrkuL2DA9KTApaKqNcnlGFaaV9KlpCO9dlKu+4tirIgx0+orKvAAQuQMnGa2pBkGsYQGS7OSMR4Zg3IIzz9PpXfPEclByfXT0udmF1d30Kepu1vaRQq2VlXJzk4GQePxGelY9aep27Y89XZ0ODtXlUHTrnjnOOKzK+AzOTliHfayt6d/n9/fU9elblCiiivPNQrbsz51gokzIykBIwNpx0yvr0649c9BWJW1pflQWTTvGGYybd2TnHH+ev8q9HK5zhXvHt/l/SMa3wmhYkOox1rTVRisyxYtIAoYRgAKD29a1lHSvva1ZuCk1Y8XEaTsKFpQoFLRXk1K7WhgkFFBOKbmuGdXuWojqTIpKKy9qy+UHVHGHUMM5wRQMKoVQAAMADtQSB1phYnpSniJcvK2NQFZuwplFFcjdzZKwhOBk1ETk5pXbceOlNrKTubxjYKKKKRQUUUUANdtq+5qCnO25vYU2pZrFWQUUUUFBRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAPWQrweRUoYMMiq9KCQcg0XJcbliimLIDweDT6ozasFFFFAgooooAKKKKACiiigAooooAeHI6808MDUNFNSZLgmT0VGHI6808MD0q00zNxaFooopkhSgkUlFAEgYGlqKnBiOtaxn3Icew+ikBBpa0IFzS02itI1GtyXHsOooorrpT1sZNEb8CsXUFBx1J+taGoTvCoARtp6sO1ZLK8jHc6tgjIf5fT/H1r241I06Lcu3a/odeFpu6mRag32a2SEwZRsCRgefUjOPUcdeh68isiWKSFtsilWxnBroJZzFLHiIbQA64bJ5x3/Dp7UyVIr+MG5by5DzvA64OB9Byc/QGvlsdgZ1kqvNpsu3muu7v5fej0ac3Hdepz9FaF1pqWsSym4yjZ24UZPTpz6n9D1qCygjuZvLdmBIOMD2JJP09O9eI8NUVRU2tXtquuxupprmGW1u91MI0xnqfp9Oprbs7WWzdhcTh0YY2A5JGFGPyPb0HpRElnZSmLy33KrAyDgkn8+MdKZ5LcFizRryAfT8+OnrX0OW5VNx9rHddddfJHPUqc2j0RPZzmIldhwPmOPQ//rrbiYMgYdCMisaIB78tLknrhlIIyeh49+v/ANattQAoA6V7dao3QTm9f+B17s8zFKPMrC0hNKabXiVJ/eZRQUUUwv6VztpbmqVxxIFNLE9KbRWTm2WopBRRRUFBUbvngUO+eBTKiUjSMerCiiipNAooooAKZI21eOpp54Gars25iaTKirsSiiikahRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAU9ZCvB5FMooBq5YDBhkUtVwSDkGpVkB4PBp3M3G2w+iiimQFFFFABRRRQAUUUUAFFFFABRRRQA9Xx15p4IIyKhoBI6VSkQ4J7E9FMV+x/On1SdzNprcKKKKYgp4f1plFNSa2E0mS0VGCRTwQa2jJMhxsLTqbRWsJ8pm1cVlDDBFU7y1EkR2rz7DmrtFerh8VKGlzNNxd0Y8Vi333UBiOg7VVu4BGcKOTzgV0BWqtxbrJzzn1FetRrRlDkil5XN4Yl895GPcWz3VnFDnY2eA3Qc7ecd857HjPpVG0sZBcszPt8obwwzhu/Xr3H/wBatCaB4NrrtDJ0Kjrz1pbiTfAqeZlgBuYNw/PT14xnn3rwMTlajWhOej9fOy+7fT0Z6UKl17uzGsFe6V0bdvOcYPTvzgVsRwrtGRmqNlbDhjn1wa1kFe9Lmw9Pkvc87E1E2kuhAbKJ2RiuNhyMVaopDXjYrEyn8XQwV5biGiimMe1eVKVtWbJX0Bmz9KbRRWDdzVKwUUUhIAyaQC1Ez54HShmLfSm1DkaxjbVhRRRUlhRRRQAUUU122r70AtRkjZ+UfjUdFFSbJWQUUUUDCiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKAHrIV4PIqUEEZFV6UEg5FFyXG5YopiyBuDwafVGbVgooooEFFFFABRRRQAUUUUAFFFFABTlYr9KbRQDVyZWDUtQVIr9jVqXcylDsPoooqiAo6UUUAPVs/WnVFUinI961hK+jM5RtqOBpabSiumnLoZSXUWo26VJUEsqpkEjPXFexhG5NWMra6GffSKoIJ5OeKoBMLskJUZ3BsZA7f5+lT3Ewe6G0huMbW6Hn/ACfwq9BaZi/e/Mx+9716VZOcuVuyj163/wCAehGaowTfUq2tyYm2SjHvnitaGRZFDKwIPcVny6WHclSoXH3cf4U2FZbO6CFQ5cHG3j36dqid6qcZWfn/AMAxqRp1FeD17GvTaELGNS67WIGVznB9KOlfNV371jKCEY4FR0pOTmkrhlK7OiKsFFFMZ8cDrUt2KSuOZgtREknmk60Vm3c1jGwUUUUigooooAKKKKAEJwMmoGbcc0533HjpTKlmsY2CiiigoKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAp6yFeDyKZRQDVywCCMilquCQcg1KsgPB4NO5m42H0UUUyAooooAKKKKACiiigAooooAKKKKAHKxX6VICCMioaUEg5FNSsTKNyaimqwb606tDJqwUoODSUUCJQcigdaYp7U+uiEr6mMlbQdWVqTRh0ViNx7FcnH8/5Vqk4FZN7IklxGAcqh3OR2Fe/gablCS6CofxLkNla+bIyTBmUDIJXYD9AOnb8q2woApsYAUYpxNZYmuqcVShsiak3Vldi1FJCJGjbO0o2en6U/NISBXAsZOGsQUBxNRs2fpSFiaSuCpUcmbRjYKKCcDJqJn3cDpWTdjVRuKz9hTKKKzbuapWCiiigYUUUUAFFFFABUUj54HSh3zwOlR0maRj1YUUUUiwooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKAHK5X3HpUysG6VXoouS4plmioll/vfnUgIIyDTM2mhaKKKYgooooAKKKKACiiigAooooAKer9j+dMooTsJpMnoqEMV6VIHB+taKVzJxaHU9Wz9aZRVxlYhq4s6PKm1XUA9QRyfx7U5IIo02KihfQCkDmjf7V6CzCagoLSxk6b2HIqxoFXOB6mgsBTCxNJXJVryqS5nuUoWHFiabRRWLbe5olYKQsFHNNZ+w/OoycnJqHIuML7isxY0lFFQahRRRQAUUUUAFFFBIAyaAConfPA6Ujvu4HSmUrmkY9WFFFFIsKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKAClBK9DSUUASrKP4uKkqtSqxXoadyHDsWKKjWUHrxUmc9KCGmgooopiCiiigAooooAKKKKACiiigBwcjvThIO/FR0U02iXFMm3Ke9LUFFPmJ9mT9KQso71DRRzD9mSGT0FMLE9aSik22UopBRRRSGFFFFABRRRQAUUZx1qJpey/nSGk2PZwvXr6VEzFj7elNopGiikFFFFBQUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFKCV6GiigCRZf7w/KnghuhoopkSirXFooopmYUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUxpAOnNFFJlxSZEzFjzSUUUjQKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooA//9k=\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": "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": "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": [
    "# Enter an interactive TensorFlow Session.\n",
    "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": "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": "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": [
    "### 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, like you see above, you define 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",
    "Keras is a separate install from TensorFlow.  To install Keras, use **pip install keras** after **pip install tensorflow**."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Simple TensorFlow Regression: MPG\n",
    "\n",
    "This example shows how to encode the MPG dataset for regression.  This is slightly more complex 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": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Train on 398 samples\n",
      "Epoch 1/100\n",
      "398/398 - 0s - loss: 187.3975\n",
      "Epoch 2/100\n",
      "398/398 - 0s - loss: 100.2128\n",
      "Epoch 3/100\n",
      "398/398 - 0s - loss: 84.8563\n",
      "Epoch 4/100\n",
      "398/398 - 0s - loss: 68.7798\n",
      "Epoch 5/100\n",
      "398/398 - 0s - loss: 61.1985\n",
      "Epoch 6/100\n",
      "398/398 - 0s - loss: 61.9002\n",
      "Epoch 7/100\n",
      "398/398 - 0s - loss: 59.3388\n",
      "Epoch 8/100\n",
      "398/398 - 0s - loss: 52.7194\n",
      "Epoch 9/100\n",
      "398/398 - 0s - loss: 47.9479\n",
      "Epoch 10/100\n",
      "398/398 - 0s - loss: 46.4514\n",
      "Epoch 11/100\n",
      "398/398 - 0s - loss: 44.3975\n",
      "Epoch 12/100\n",
      "398/398 - 0s - loss: 43.4934\n",
      "Epoch 13/100\n",
      "398/398 - 0s - loss: 42.1107\n",
      "Epoch 14/100\n",
      "398/398 - 0s - loss: 43.1567\n",
      "Epoch 15/100\n",
      "398/398 - 0s - loss: 44.3381\n",
      "Epoch 16/100\n",
      "398/398 - 0s - loss: 42.3927\n",
      "Epoch 17/100\n",
      "398/398 - 0s - loss: 39.8586\n",
      "Epoch 18/100\n",
      "398/398 - 0s - loss: 36.5758\n",
      "Epoch 19/100\n",
      "398/398 - 0s - loss: 36.5689\n",
      "Epoch 20/100\n",
      "398/398 - 0s - loss: 36.0899\n",
      "Epoch 21/100\n",
      "398/398 - 0s - loss: 33.1650\n",
      "Epoch 22/100\n",
      "398/398 - 0s - loss: 38.4136\n",
      "Epoch 23/100\n",
      "398/398 - 0s - loss: 31.3028\n",
      "Epoch 24/100\n",
      "398/398 - 0s - loss: 30.0904\n",
      "Epoch 25/100\n",
      "398/398 - 0s - loss: 29.8616\n",
      "Epoch 26/100\n",
      "398/398 - 0s - loss: 30.3222\n",
      "Epoch 27/100\n",
      "398/398 - 0s - loss: 28.0176\n",
      "Epoch 28/100\n",
      "398/398 - 0s - loss: 28.3145\n",
      "Epoch 29/100\n",
      "398/398 - 0s - loss: 32.8491\n",
      "Epoch 30/100\n",
      "398/398 - 0s - loss: 34.3431\n",
      "Epoch 31/100\n",
      "398/398 - 0s - loss: 25.1142\n",
      "Epoch 32/100\n",
      "398/398 - 0s - loss: 24.4670\n",
      "Epoch 33/100\n",
      "398/398 - 0s - loss: 27.7017\n",
      "Epoch 34/100\n",
      "398/398 - 0s - loss: 23.4587\n",
      "Epoch 35/100\n",
      "398/398 - 0s - loss: 23.3439\n",
      "Epoch 36/100\n",
      "398/398 - 0s - loss: 22.0954\n",
      "Epoch 37/100\n",
      "398/398 - 0s - loss: 22.1965\n",
      "Epoch 38/100\n",
      "398/398 - 0s - loss: 21.6180\n",
      "Epoch 39/100\n",
      "398/398 - 0s - loss: 30.1313\n",
      "Epoch 40/100\n",
      "398/398 - 0s - loss: 32.5104\n",
      "Epoch 41/100\n",
      "398/398 - 0s - loss: 23.8946\n",
      "Epoch 42/100\n",
      "398/398 - 0s - loss: 20.4276\n",
      "Epoch 43/100\n",
      "398/398 - 0s - loss: 19.3385\n",
      "Epoch 44/100\n",
      "398/398 - 0s - loss: 19.4313\n",
      "Epoch 45/100\n",
      "398/398 - 0s - loss: 19.6475\n",
      "Epoch 46/100\n",
      "398/398 - 0s - loss: 21.2407\n",
      "Epoch 47/100\n",
      "398/398 - 0s - loss: 18.7425\n",
      "Epoch 48/100\n",
      "398/398 - 0s - loss: 19.1721\n",
      "Epoch 49/100\n",
      "398/398 - 0s - loss: 20.9113\n",
      "Epoch 50/100\n",
      "398/398 - 0s - loss: 24.5793\n",
      "Epoch 51/100\n",
      "398/398 - 0s - loss: 20.4643\n",
      "Epoch 52/100\n",
      "398/398 - 0s - loss: 21.0628\n",
      "Epoch 53/100\n",
      "398/398 - 0s - loss: 20.5054\n",
      "Epoch 54/100\n",
      "398/398 - 0s - loss: 18.2215\n",
      "Epoch 55/100\n",
      "398/398 - 0s - loss: 15.8788\n",
      "Epoch 56/100\n",
      "398/398 - 0s - loss: 16.6591\n",
      "Epoch 57/100\n",
      "398/398 - 0s - loss: 16.8573\n",
      "Epoch 58/100\n",
      "398/398 - 0s - loss: 16.6108\n",
      "Epoch 59/100\n",
      "398/398 - 0s - loss: 17.4109\n",
      "Epoch 60/100\n",
      "398/398 - 0s - loss: 15.8748\n",
      "Epoch 61/100\n",
      "398/398 - 0s - loss: 16.2050\n",
      "Epoch 62/100\n",
      "398/398 - 0s - loss: 14.6622\n",
      "Epoch 63/100\n",
      "398/398 - 0s - loss: 18.1572\n",
      "Epoch 64/100\n",
      "398/398 - 0s - loss: 22.2335\n",
      "Epoch 65/100\n",
      "398/398 - 0s - loss: 21.1229\n",
      "Epoch 66/100\n",
      "398/398 - 0s - loss: 23.2801\n",
      "Epoch 67/100\n",
      "398/398 - 0s - loss: 15.2179\n",
      "Epoch 68/100\n",
      "398/398 - 0s - loss: 15.5569\n",
      "Epoch 69/100\n",
      "398/398 - 0s - loss: 15.6470\n",
      "Epoch 70/100\n",
      "398/398 - 0s - loss: 17.4888\n",
      "Epoch 71/100\n",
      "398/398 - 0s - loss: 14.3624\n",
      "Epoch 72/100\n",
      "398/398 - 0s - loss: 15.3422\n",
      "Epoch 73/100\n",
      "398/398 - 0s - loss: 15.2807\n",
      "Epoch 74/100\n",
      "398/398 - 0s - loss: 14.0129\n",
      "Epoch 75/100\n",
      "398/398 - 0s - loss: 17.5749\n",
      "Epoch 76/100\n",
      "398/398 - 0s - loss: 16.8090\n",
      "Epoch 77/100\n",
      "398/398 - 0s - loss: 19.3954\n",
      "Epoch 78/100\n",
      "398/398 - 0s - loss: 26.0994\n",
      "Epoch 79/100\n",
      "398/398 - 0s - loss: 20.3828\n",
      "Epoch 80/100\n",
      "398/398 - 0s - loss: 16.0578\n",
      "Epoch 81/100\n",
      "398/398 - 0s - loss: 15.3317\n",
      "Epoch 82/100\n",
      "398/398 - 0s - loss: 17.3943\n",
      "Epoch 83/100\n",
      "398/398 - 0s - loss: 14.0143\n",
      "Epoch 84/100\n",
      "398/398 - 0s - loss: 14.1247\n",
      "Epoch 85/100\n",
      "398/398 - 0s - loss: 15.6660\n",
      "Epoch 86/100\n",
      "398/398 - 0s - loss: 18.2521\n",
      "Epoch 87/100\n",
      "398/398 - 0s - loss: 15.7919\n",
      "Epoch 88/100\n",
      "398/398 - 0s - loss: 14.7530\n",
      "Epoch 89/100\n",
      "398/398 - 0s - loss: 13.8280\n",
      "Epoch 90/100\n",
      "398/398 - 0s - loss: 14.3151\n",
      "Epoch 91/100\n",
      "398/398 - 0s - loss: 15.1786\n",
      "Epoch 92/100\n",
      "398/398 - 0s - loss: 14.2929\n",
      "Epoch 93/100\n",
      "398/398 - 0s - loss: 13.7623\n",
      "Epoch 94/100\n",
      "398/398 - 0s - loss: 14.0267\n",
      "Epoch 95/100\n",
      "398/398 - 0s - loss: 19.1403\n",
      "Epoch 96/100\n",
      "398/398 - 0s - loss: 25.9738\n",
      "Epoch 97/100\n",
      "398/398 - 0s - loss: 22.5911\n",
      "Epoch 98/100\n",
      "398/398 - 0s - loss: 16.2154\n",
      "Epoch 99/100\n",
      "398/398 - 0s - loss: 20.0866\n",
      "Epoch 100/100\n",
      "398/398 - 0s - loss: 22.6321\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<tensorflow.python.keras.callbacks.History at 0x1a3687e518>"
      ]
     },
     "execution_count": 7,
     "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 is made up of 4 layers.  The first layer is the input layer.  This is specified by **input_dim** and it is set to be the number of inputs that the dataset has.  One input neuron is needed for ever input (including dummy variables).  However, there are also several hidden layers, with 25 and 10 neurons each. You might be wondering how these numbers were chosen?  This is one of the most common questions about neural networks.  Unfortunately, there is not a good answer.  These are hyperparameters.  They are settings that can affect neural network performance, yet there is not a clearly defined means of setting them.\n",
    "\n",
    "In general, more hidden neurons mean more capability to fit to 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 own feature engineering and data preprocessing.  But this also comes at the expense of training times and risk of overfitting.  In general, you will see that neuron counts start out larger near the input layer and tend to shrink towards the output layer in a sort of triangular fashion. \n",
    "\n",
    "There are techniques that 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",
    "One line is produced 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 Juputer 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"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Next, we will perform actual predictions.  These predictions are assigned 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 is returned by printing out **pred.shape**.  Neural networks can return multiple values, so the result is always an array.  Here the neural network only returns 1 value per prediction (there are 398 cars, so 398 predictions).  However, a 2D array is needed because the neural network has the potential of returning more than one value.   "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Shape: (398, 1)\n",
      "[[21.182856]\n",
      " [20.631006]\n",
      " [21.715326]\n",
      " [22.145594]\n",
      " [21.272028]\n",
      " [16.814447]\n",
      " [16.859858]\n",
      " [16.863672]\n",
      " [16.919336]\n",
      " [19.143885]\n",
      " [20.85409 ]\n",
      " [19.817713]\n",
      " [18.906397]\n",
      " [24.790537]\n",
      " [28.4517  ]\n",
      " [25.507044]\n",
      " [25.902338]\n",
      " [26.852411]\n",
      " [29.587198]\n",
      " [32.081635]\n",
      " [27.146341]\n",
      " [27.616709]\n",
      " [29.132303]\n",
      " [28.619165]\n",
      " [26.282785]\n",
      " [17.365961]\n",
      " [18.963282]\n",
      " [18.620722]\n",
      " [17.918085]\n",
      " [30.061884]\n",
      " [29.050287]\n",
      " [29.424372]\n",
      " [31.837183]\n",
      " [26.257288]\n",
      " [22.56161 ]\n",
      " [22.96078 ]\n",
      " [22.800379]\n",
      " [23.28419 ]\n",
      " [18.246668]\n",
      " [16.610224]\n",
      " [18.76922 ]\n",
      " [19.007257]\n",
      " [13.934748]\n",
      " [14.993891]\n",
      " [12.810785]\n",
      " [24.650156]\n",
      " [28.94517 ]\n",
      " [23.062693]\n",
      " [23.410013]\n",
      " [28.762217]\n",
      " [29.680521]\n",
      " [31.523294]\n",
      " [29.951838]\n",
      " [33.23649 ]\n",
      " [33.930237]\n",
      " [32.41159 ]\n",
      " [32.30213 ]\n",
      " [30.127848]\n",
      " [30.787775]\n",
      " [31.826181]\n",
      " [30.072565]\n",
      " [30.0729  ]\n",
      " [18.339289]\n",
      " [17.723566]\n",
      " [19.426935]\n",
      " [19.216394]\n",
      " [21.51571 ]\n",
      " [16.661707]\n",
      " [17.255884]\n",
      " [17.659357]\n",
      " [18.078974]\n",
      " [29.17077 ]\n",
      " [20.571009]\n",
      " [19.337458]\n",
      " [19.171015]\n",
      " [19.942194]\n",
      " [26.129984]\n",
      " [28.873453]\n",
      " [26.942133]\n",
      " [30.694696]\n",
      " [28.90516 ]\n",
      " [30.585505]\n",
      " [28.460245]\n",
      " [29.86503 ]\n",
      " [31.409891]\n",
      " [20.451105]\n",
      " [21.990442]\n",
      " [20.311945]\n",
      " [20.52453 ]\n",
      " [21.657648]\n",
      " [15.169489]\n",
      " [17.06927 ]\n",
      " [18.44842 ]\n",
      " [19.650537]\n",
      " [16.672327]\n",
      " [15.599817]\n",
      " [21.348291]\n",
      " [25.728678]\n",
      " [25.081171]\n",
      " [26.424036]\n",
      " [25.750101]\n",
      " [26.68786 ]\n",
      " [33.003822]\n",
      " [14.633234]\n",
      " [15.097223]\n",
      " [17.015833]\n",
      " [18.064264]\n",
      " [26.992533]\n",
      " [31.703745]\n",
      " [30.109934]\n",
      " [30.353617]\n",
      " [30.670343]\n",
      " [30.724298]\n",
      " [29.04629 ]\n",
      " [30.400415]\n",
      " [19.759363]\n",
      " [19.418116]\n",
      " [33.181534]\n",
      " [30.548151]\n",
      " [27.967508]\n",
      " [27.33526 ]\n",
      " [23.356745]\n",
      " [27.981989]\n",
      " [27.725504]\n",
      " [22.449915]\n",
      " [26.172815]\n",
      " [27.63241 ]\n",
      " [27.157282]\n",
      " [24.866297]\n",
      " [33.63656 ]\n",
      " [29.540125]\n",
      " [34.98722 ]\n",
      " [28.964045]\n",
      " [22.250452]\n",
      " [23.704096]\n",
      " [23.311152]\n",
      " [20.322687]\n",
      " [17.26272 ]\n",
      " [18.483393]\n",
      " [18.098352]\n",
      " [20.420435]\n",
      " [31.307856]\n",
      " [32.125877]\n",
      " [30.006418]\n",
      " [34.149513]\n",
      " [33.14715 ]\n",
      " [30.773096]\n",
      " [31.435846]\n",
      " [29.982737]\n",
      " [29.683695]\n",
      " [30.382639]\n",
      " [32.08265 ]\n",
      " [25.397242]\n",
      " [24.402338]\n",
      " [25.426447]\n",
      " [26.514292]\n",
      " [17.176752]\n",
      " [18.952845]\n",
      " [19.065607]\n",
      " [17.578089]\n",
      " [23.731379]\n",
      " [22.698908]\n",
      " [23.951227]\n",
      " [23.380213]\n",
      " [26.742731]\n",
      " [25.416803]\n",
      " [25.521662]\n",
      " [31.896677]\n",
      " [29.081247]\n",
      " [27.555567]\n",
      " [29.74734 ]\n",
      " [28.292673]\n",
      " [31.476648]\n",
      " [30.530802]\n",
      " [26.820963]\n",
      " [32.25991 ]\n",
      " [25.892298]\n",
      " [28.708673]\n",
      " [27.65072 ]\n",
      " [27.1112  ]\n",
      " [28.825266]\n",
      " [34.072372]\n",
      " [30.507013]\n",
      " [32.25515 ]\n",
      " [29.457148]\n",
      " [32.143166]\n",
      " [31.92518 ]\n",
      " [20.474787]\n",
      " [20.827936]\n",
      " [21.748621]\n",
      " [20.513453]\n",
      " [25.977991]\n",
      " [24.97729 ]\n",
      " [27.653238]\n",
      " [27.316843]\n",
      " [34.346565]\n",
      " [33.70658 ]\n",
      " [32.804344]\n",
      " [34.51216 ]\n",
      " [24.322504]\n",
      " [25.225946]\n",
      " [23.986109]\n",
      " [26.765528]\n",
      " [32.760147]\n",
      " [33.705894]\n",
      " [32.60479 ]\n",
      " [28.513453]\n",
      " [26.864267]\n",
      " [22.367304]\n",
      " [27.993265]\n",
      " [28.751429]\n",
      " [23.987696]\n",
      " [20.048548]\n",
      " [20.993708]\n",
      " [22.947748]\n",
      " [23.733759]\n",
      " [34.26734 ]\n",
      " [32.16201 ]\n",
      " [35.202286]\n",
      " [31.928537]\n",
      " [34.37539 ]\n",
      " [22.877283]\n",
      " [23.360468]\n",
      " [21.707514]\n",
      " [20.889307]\n",
      " [25.265345]\n",
      " [25.952173]\n",
      " [24.920557]\n",
      " [25.823053]\n",
      " [20.886072]\n",
      " [21.277094]\n",
      " [20.917933]\n",
      " [20.795252]\n",
      " [33.546562]\n",
      " [29.170877]\n",
      " [33.060234]\n",
      " [29.089975]\n",
      " [33.147682]\n",
      " [33.15496 ]\n",
      " [33.866158]\n",
      " [31.93757 ]\n",
      " [29.30691 ]\n",
      " [29.815042]\n",
      " [29.55137 ]\n",
      " [35.4309  ]\n",
      " [34.271423]\n",
      " [35.074623]\n",
      " [34.74259 ]\n",
      " [35.269653]\n",
      " [26.700647]\n",
      " [24.255915]\n",
      " [25.13302 ]\n",
      " [26.581873]\n",
      " [28.34344 ]\n",
      " [28.35789 ]\n",
      " [29.604303]\n",
      " [26.3966  ]\n",
      " [27.391947]\n",
      " [26.308008]\n",
      " [28.0543  ]\n",
      " [26.068384]\n",
      " [26.162806]\n",
      " [26.270624]\n",
      " [26.684595]\n",
      " [26.721079]\n",
      " [22.402063]\n",
      " [32.96969 ]\n",
      " [30.768778]\n",
      " [32.59327 ]\n",
      " [31.985758]\n",
      " [31.242487]\n",
      " [30.289103]\n",
      " [29.447412]\n",
      " [32.04577 ]\n",
      " [29.990747]\n",
      " [28.009684]\n",
      " [30.28721 ]\n",
      " [27.401941]\n",
      " [33.717216]\n",
      " [33.55076 ]\n",
      " [27.702631]\n",
      " [29.522043]\n",
      " [29.741846]\n",
      " [27.89184 ]\n",
      " [27.339502]\n",
      " [24.673822]\n",
      " [24.639917]\n",
      " [23.233027]\n",
      " [24.736261]\n",
      " [21.901178]\n",
      " [23.140833]\n",
      " [25.956964]\n",
      " [23.52923 ]\n",
      " [34.26026 ]\n",
      " [34.453148]\n",
      " [34.442215]\n",
      " [30.107782]\n",
      " [26.884974]\n",
      " [24.679193]\n",
      " [30.350138]\n",
      " [28.65545 ]\n",
      " [32.050774]\n",
      " [32.937157]\n",
      " [35.58735 ]\n",
      " [33.236855]\n",
      " [30.584787]\n",
      " [30.360346]\n",
      " [30.300745]\n",
      " [30.279016]\n",
      " [33.783318]\n",
      " [36.077095]\n",
      " [33.829323]\n",
      " [35.08741 ]\n",
      " [31.186731]\n",
      " [30.612986]\n",
      " [30.531076]\n",
      " [27.890863]\n",
      " [33.96572 ]\n",
      " [31.15069 ]\n",
      " [32.5066  ]\n",
      " [32.726646]\n",
      " [33.388237]\n",
      " [35.07534 ]\n",
      " [30.11355 ]\n",
      " [35.53298 ]\n",
      " [35.86207 ]\n",
      " [35.08956 ]\n",
      " [30.71757 ]\n",
      " [29.297312]\n",
      " [35.204956]\n",
      " [37.030655]\n",
      " [34.90719 ]\n",
      " [35.419037]\n",
      " [29.92167 ]\n",
      " [32.17025 ]\n",
      " [32.039055]\n",
      " [29.228922]\n",
      " [33.79339 ]\n",
      " [32.40145 ]\n",
      " [31.719828]\n",
      " [31.300745]\n",
      " [30.865686]\n",
      " [32.042793]\n",
      " [37.134247]\n",
      " [35.953392]\n",
      " [36.870033]\n",
      " [35.782402]\n",
      " [36.87098 ]\n",
      " [35.60009 ]\n",
      " [35.679466]\n",
      " [33.318245]\n",
      " [34.85598 ]\n",
      " [34.455177]\n",
      " [33.72802 ]\n",
      " [34.062798]\n",
      " [33.911964]\n",
      " [33.920937]\n",
      " [32.280266]\n",
      " [32.686806]\n",
      " [29.770105]\n",
      " [30.18696 ]\n",
      " [30.448008]\n",
      " [30.897028]\n",
      " [27.659174]\n",
      " [26.68307 ]\n",
      " [29.756205]\n",
      " [27.006891]\n",
      " [33.77111 ]\n",
      " [33.21682 ]\n",
      " [34.447884]\n",
      " [32.682655]\n",
      " [32.774925]\n",
      " [32.323784]\n",
      " [31.105509]\n",
      " [31.524668]\n",
      " [35.820503]\n",
      " [36.685707]\n",
      " [36.799934]\n",
      " [34.252266]\n",
      " [35.37664 ]\n",
      " [35.001442]\n",
      " [34.450874]\n",
      " [34.914696]\n",
      " [35.896507]\n",
      " [36.140556]\n",
      " [36.138374]\n",
      " [31.334833]\n",
      " [30.096796]\n",
      " [32.015892]\n",
      " [31.208536]\n",
      " [31.926432]\n",
      " [32.640434]\n",
      " [30.815912]\n",
      " [31.108027]\n",
      " [37.631905]\n",
      " [32.593346]\n",
      " [33.02897 ]\n",
      " [32.833794]]\n"
     ]
    }
   ],
   "source": [
    "pred = model.predict(x)\n",
    "print(\"Shape: {}\".format(pred.shape))\n",
    "print(pred)"
   ]
  },
  {
   "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": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Final score (RMSE): 5.750656444269352\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": [
    "This means that, on average the predictions were within +/- 5.89 values of the correct value.  This is not very good, but we will soon see how to improve it.\n",
    "\n",
    "We can also print out the first 10 cars, with predictions and actual MPG."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1. Car name: chevrolet chevelle malibu, MPG: 18.0, predicted MPG: [21.182856]\n",
      "2. Car name: buick skylark 320, MPG: 15.0, predicted MPG: [20.631006]\n",
      "3. Car name: plymouth satellite, MPG: 18.0, predicted MPG: [21.715326]\n",
      "4. Car name: amc rebel sst, MPG: 16.0, predicted MPG: [22.145594]\n",
      "5. Car name: ford torino, MPG: 17.0, predicted MPG: [21.272028]\n",
      "6. Car name: ford galaxie 500, MPG: 15.0, predicted MPG: [16.814447]\n",
      "7. Car name: chevrolet impala, MPG: 14.0, predicted MPG: [16.859858]\n",
      "8. Car name: plymouth fury iii, MPG: 14.0, predicted MPG: [16.863672]\n",
      "9. Car name: pontiac catalina, MPG: 14.0, predicted MPG: [16.919336]\n",
      "10. Car name: amc ambassador dpl, MPG: 15.0, predicted MPG: [19.143885]\n"
     ]
    }
   ],
   "source": [
    "# Sample predictions\n",
    "for i in range(10):\n",
    "    print(f\"{i+1}. Car name: {cars[i]}, MPG: {y[i]}, predicted MPG: {pred[i]}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Simple TensorFlow Classification: Iris\n",
    "\n",
    "This is a very simple example of how to perform the Iris classification using TensorFlow.  The iris.csv file is used, rather than using the built-in files 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 codeblock above, you will get errors**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "WARNING: Logging before flag parsing goes to stderr.\n",
      "W0819 12:46:16.063336 140736216040320 deprecation.py:323] From /Users/jheaton/miniconda3/envs/tensorflow/lib/python3.6/site-packages/tensorflow/python/ops/math_grad.py:1250: add_dispatch_support.<locals>.wrapper (from tensorflow.python.ops.array_ops) is deprecated and will be removed in a future version.\n",
      "Instructions for updating:\n",
      "Use tf.where in 2.0, which has the same broadcast rule as np.where\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Train on 150 samples\n",
      "Epoch 1/100\n",
      "150/150 - 0s - loss: 1.0951\n",
      "Epoch 2/100\n",
      "150/150 - 0s - loss: 1.0235\n",
      "Epoch 3/100\n",
      "150/150 - 0s - loss: 0.9700\n",
      "Epoch 4/100\n",
      "150/150 - 0s - loss: 0.9167\n",
      "Epoch 5/100\n",
      "150/150 - 0s - loss: 0.8709\n",
      "Epoch 6/100\n",
      "150/150 - 0s - loss: 0.8286\n",
      "Epoch 7/100\n",
      "150/150 - 0s - loss: 0.7916\n",
      "Epoch 8/100\n",
      "150/150 - 0s - loss: 0.7540\n",
      "Epoch 9/100\n",
      "150/150 - 0s - loss: 0.7191\n",
      "Epoch 10/100\n",
      "150/150 - 0s - loss: 0.6858\n",
      "Epoch 11/100\n",
      "150/150 - 0s - loss: 0.6532\n",
      "Epoch 12/100\n",
      "150/150 - 0s - loss: 0.6238\n",
      "Epoch 13/100\n",
      "150/150 - 0s - loss: 0.5905\n",
      "Epoch 14/100\n",
      "150/150 - 0s - loss: 0.5542\n",
      "Epoch 15/100\n",
      "150/150 - 0s - loss: 0.5309\n",
      "Epoch 16/100\n",
      "150/150 - 0s - loss: 0.5089\n",
      "Epoch 17/100\n",
      "150/150 - 0s - loss: 0.4883\n",
      "Epoch 18/100\n",
      "150/150 - 0s - loss: 0.4707\n",
      "Epoch 19/100\n",
      "150/150 - 0s - loss: 0.4568\n",
      "Epoch 20/100\n",
      "150/150 - 0s - loss: 0.4404\n",
      "Epoch 21/100\n",
      "150/150 - 0s - loss: 0.4256\n",
      "Epoch 22/100\n",
      "150/150 - 0s - loss: 0.4125\n",
      "Epoch 23/100\n",
      "150/150 - 0s - loss: 0.4011\n",
      "Epoch 24/100\n",
      "150/150 - 0s - loss: 0.3887\n",
      "Epoch 25/100\n",
      "150/150 - 0s - loss: 0.3779\n",
      "Epoch 26/100\n",
      "150/150 - 0s - loss: 0.3689\n",
      "Epoch 27/100\n",
      "150/150 - 0s - loss: 0.3591\n",
      "Epoch 28/100\n",
      "150/150 - 0s - loss: 0.3479\n",
      "Epoch 29/100\n",
      "150/150 - 0s - loss: 0.3395\n",
      "Epoch 30/100\n",
      "150/150 - 0s - loss: 0.3298\n",
      "Epoch 31/100\n",
      "150/150 - 0s - loss: 0.3211\n",
      "Epoch 32/100\n",
      "150/150 - 0s - loss: 0.3121\n",
      "Epoch 33/100\n",
      "150/150 - 0s - loss: 0.3048\n",
      "Epoch 34/100\n",
      "150/150 - 0s - loss: 0.2978\n",
      "Epoch 35/100\n",
      "150/150 - 0s - loss: 0.2944\n",
      "Epoch 36/100\n",
      "150/150 - 0s - loss: 0.2808\n",
      "Epoch 37/100\n",
      "150/150 - 0s - loss: 0.2749\n",
      "Epoch 38/100\n",
      "150/150 - 0s - loss: 0.2672\n",
      "Epoch 39/100\n",
      "150/150 - 0s - loss: 0.2586\n",
      "Epoch 40/100\n",
      "150/150 - 0s - loss: 0.2546\n",
      "Epoch 41/100\n",
      "150/150 - 0s - loss: 0.2544\n",
      "Epoch 42/100\n",
      "150/150 - 0s - loss: 0.2417\n",
      "Epoch 43/100\n",
      "150/150 - 0s - loss: 0.2354\n",
      "Epoch 44/100\n",
      "150/150 - 0s - loss: 0.2277\n",
      "Epoch 45/100\n",
      "150/150 - 0s - loss: 0.2212\n",
      "Epoch 46/100\n",
      "150/150 - 0s - loss: 0.2180\n",
      "Epoch 47/100\n",
      "150/150 - 0s - loss: 0.2104\n",
      "Epoch 48/100\n",
      "150/150 - 0s - loss: 0.2064\n",
      "Epoch 49/100\n",
      "150/150 - 0s - loss: 0.2008\n",
      "Epoch 50/100\n",
      "150/150 - 0s - loss: 0.1962\n",
      "Epoch 51/100\n",
      "150/150 - 0s - loss: 0.1920\n",
      "Epoch 52/100\n",
      "150/150 - 0s - loss: 0.1871\n",
      "Epoch 53/100\n",
      "150/150 - 0s - loss: 0.1839\n",
      "Epoch 54/100\n",
      "150/150 - 0s - loss: 0.1790\n",
      "Epoch 55/100\n",
      "150/150 - 0s - loss: 0.1753\n",
      "Epoch 56/100\n",
      "150/150 - 0s - loss: 0.1708\n",
      "Epoch 57/100\n",
      "150/150 - 0s - loss: 0.1681\n",
      "Epoch 58/100\n",
      "150/150 - 0s - loss: 0.1674\n",
      "Epoch 59/100\n",
      "150/150 - 0s - loss: 0.1620\n",
      "Epoch 60/100\n",
      "150/150 - 0s - loss: 0.1585\n",
      "Epoch 61/100\n",
      "150/150 - 0s - loss: 0.1543\n",
      "Epoch 62/100\n",
      "150/150 - 0s - loss: 0.1548\n",
      "Epoch 63/100\n",
      "150/150 - 0s - loss: 0.1481\n",
      "Epoch 64/100\n",
      "150/150 - 0s - loss: 0.1474\n",
      "Epoch 65/100\n",
      "150/150 - 0s - loss: 0.1443\n",
      "Epoch 66/100\n",
      "150/150 - 0s - loss: 0.1419\n",
      "Epoch 67/100\n",
      "150/150 - 0s - loss: 0.1376\n",
      "Epoch 68/100\n",
      "150/150 - 0s - loss: 0.1402\n",
      "Epoch 69/100\n",
      "150/150 - 0s - loss: 0.1335\n",
      "Epoch 70/100\n",
      "150/150 - 0s - loss: 0.1316\n",
      "Epoch 71/100\n",
      "150/150 - 0s - loss: 0.1295\n",
      "Epoch 72/100\n",
      "150/150 - 0s - loss: 0.1268\n",
      "Epoch 73/100\n",
      "150/150 - 0s - loss: 0.1276\n",
      "Epoch 74/100\n",
      "150/150 - 0s - loss: 0.1229\n",
      "Epoch 75/100\n",
      "150/150 - 0s - loss: 0.1217\n",
      "Epoch 76/100\n",
      "150/150 - 0s - loss: 0.1223\n",
      "Epoch 77/100\n",
      "150/150 - 0s - loss: 0.1220\n",
      "Epoch 78/100\n",
      "150/150 - 0s - loss: 0.1196\n",
      "Epoch 79/100\n",
      "150/150 - 0s - loss: 0.1164\n",
      "Epoch 80/100\n",
      "150/150 - 0s - loss: 0.1133\n",
      "Epoch 81/100\n",
      "150/150 - 0s - loss: 0.1120\n",
      "Epoch 82/100\n",
      "150/150 - 0s - loss: 0.1115\n",
      "Epoch 83/100\n",
      "150/150 - 0s - loss: 0.1097\n",
      "Epoch 84/100\n",
      "150/150 - 0s - loss: 0.1076\n",
      "Epoch 85/100\n",
      "150/150 - 0s - loss: 0.1079\n",
      "Epoch 86/100\n",
      "150/150 - 0s - loss: 0.1052\n",
      "Epoch 87/100\n",
      "150/150 - 0s - loss: 0.1053\n",
      "Epoch 88/100\n",
      "150/150 - 0s - loss: 0.1034\n",
      "Epoch 89/100\n",
      "150/150 - 0s - loss: 0.1032\n",
      "Epoch 90/100\n",
      "150/150 - 0s - loss: 0.1033\n",
      "Epoch 91/100\n",
      "150/150 - 0s - loss: 0.1022\n",
      "Epoch 92/100\n",
      "150/150 - 0s - loss: 0.1027\n",
      "Epoch 93/100\n",
      "150/150 - 0s - loss: 0.0997\n",
      "Epoch 94/100\n",
      "150/150 - 0s - loss: 0.0992\n",
      "Epoch 95/100\n",
      "150/150 - 0s - loss: 0.0960\n",
      "Epoch 96/100\n",
      "150/150 - 0s - loss: 0.0965\n",
      "Epoch 97/100\n",
      "150/150 - 0s - loss: 0.0948\n",
      "Epoch 98/100\n",
      "150/150 - 0s - loss: 0.0929\n",
      "Epoch 99/100\n",
      "150/150 - 0s - loss: 0.0943\n",
      "Epoch 100/100\n",
      "150/150 - 0s - loss: 0.0938\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<tensorflow.python.keras.callbacks.History at 0x1a37202978>"
      ]
     },
     "execution_count": 11,
     "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": 12,
   "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 trained, 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 3 values come back for each of the 150 iris flowers.  There were 3 types of iris (Iris-setosa, Iris-versicolor, and Iris-virginica).  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Shape: {pred.shape}\n",
      "[[9.95905280e-01 4.09468124e-03 5.72462702e-11]\n",
      " [9.92221296e-01 7.77869625e-03 4.81216067e-10]\n",
      " [9.93821621e-01 6.17839210e-03 3.10125675e-10]\n",
      " [9.90131974e-01 9.86796804e-03 1.15435284e-09]\n",
      " [9.96012688e-01 3.98729835e-03 5.82915244e-11]\n",
      " [9.95936513e-01 4.06342419e-03 3.18236236e-11]\n",
      " [9.93257761e-01 6.74220407e-03 3.92334359e-10]\n",
      " [9.94374633e-01 5.62532060e-03 1.48308213e-10]\n",
      " [9.88211095e-01 1.17889037e-02 2.59820987e-09]\n",
      " [9.92404759e-01 7.59520521e-03 4.07007650e-10]\n",
      " [9.96799111e-01 3.20086861e-03 1.90191769e-11]\n",
      " [9.92514789e-01 7.48518109e-03 3.80376425e-10]\n",
      " [9.92302418e-01 7.69758504e-03 5.09308595e-10]\n",
      " [9.93078649e-01 6.92135701e-03 7.83899390e-10]\n",
      " [9.98802423e-01 1.19753508e-03 8.78470636e-13]\n",
      " [9.98418808e-01 1.58124871e-03 1.49748627e-12]\n",
      " [9.97728407e-01 2.27163034e-03 7.42364416e-12]\n",
      " [9.95641708e-01 4.35829163e-03 6.82981241e-11]\n",
      " [9.96527493e-01 3.47250025e-03 1.53685138e-11]\n",
      " [9.96178985e-01 3.82099347e-03 4.06397069e-11]\n",
      " [9.93515491e-01 6.48450246e-03 1.20557592e-10]\n",
      " [9.95557129e-01 4.44285478e-03 6.52480708e-11]\n",
      " [9.96838927e-01 3.16103175e-03 5.23905710e-11]\n",
      " [9.84825552e-01 1.51744476e-02 1.47307155e-09]\n",
      " [9.84325171e-01 1.56748574e-02 2.11231477e-09]\n",
      " [9.87989068e-01 1.20109031e-02 1.11349163e-09]\n",
      " [9.91569698e-01 8.43037106e-03 3.98622385e-10]\n",
      " [9.95541632e-01 4.45838785e-03 6.16814239e-11]\n",
      " [9.95773375e-01 4.22656676e-03 5.77953241e-11]\n",
      " [9.90031838e-01 9.96820908e-03 9.60224678e-10]\n",
      " [9.89009798e-01 1.09902443e-02 1.10740306e-09]\n",
      " [9.94485915e-01 5.51404105e-03 8.97777339e-11]\n",
      " [9.97512341e-01 2.48768320e-03 1.03998060e-11]\n",
      " [9.98314381e-01 1.68567186e-03 2.57495457e-12]\n",
      " [9.91686404e-01 8.31359252e-03 5.18320054e-10]\n",
      " [9.95646775e-01 4.35321266e-03 9.04540262e-11]\n",
      " [9.97301698e-01 2.69824895e-03 1.24911331e-11]\n",
      " [9.95927632e-01 4.07239981e-03 6.97178218e-11]\n",
      " [9.90811110e-01 9.18894447e-03 1.34120315e-09]\n",
      " [9.94739115e-01 5.26086194e-03 1.11060383e-10]\n",
      " [9.95992005e-01 4.00806544e-03 6.33087818e-11]\n",
      " [9.71936166e-01 2.80637965e-02 2.60075250e-08]\n",
      " [9.92412031e-01 7.58796651e-03 7.58696606e-10]\n",
      " [9.89308059e-01 1.06919315e-02 7.04659275e-10]\n",
      " [9.89756882e-01 1.02431821e-02 4.45895154e-10]\n",
      " [9.90563393e-01 9.43663344e-03 8.78068729e-10]\n",
      " [9.95856225e-01 4.14373586e-03 4.96200789e-11]\n",
      " [9.92311656e-01 7.68836075e-03 5.95625882e-10]\n",
      " [9.96575892e-01 3.42403445e-03 2.54572474e-11]\n",
      " [9.94668126e-01 5.33194980e-03 1.38979953e-10]\n",
      " [2.94724456e-03 9.91568744e-01 5.48394024e-03]\n",
      " [3.33215506e-03 9.79655623e-01 1.70122087e-02]\n",
      " [1.38710113e-03 9.63712692e-01 3.49002481e-02]\n",
      " [3.47693893e-03 8.93831551e-01 1.02691546e-01]\n",
      " [1.65425101e-03 9.40015793e-01 5.83299845e-02]\n",
      " [2.18526274e-03 8.47535074e-01 1.50279701e-01]\n",
      " [2.00093980e-03 9.35999393e-01 6.19997047e-02]\n",
      " [3.12163271e-02 9.63056266e-01 5.72734745e-03]\n",
      " [2.68085208e-03 9.81008768e-01 1.63103621e-02]\n",
      " [5.73053956e-03 9.17905688e-01 7.63637498e-02]\n",
      " [1.07204868e-02 9.58097160e-01 3.11823506e-02]\n",
      " [4.44600033e-03 9.66400683e-01 2.91533489e-02]\n",
      " [5.88344084e-03 9.81077254e-01 1.30393226e-02]\n",
      " [1.51038158e-03 8.58983696e-01 1.39505953e-01]\n",
      " [2.44644489e-02 9.72891033e-01 2.64455914e-03]\n",
      " [5.09165414e-03 9.90731895e-01 4.17656219e-03]\n",
      " [1.82243704e-03 7.71983147e-01 2.26194412e-01]\n",
      " [8.46911967e-03 9.83209729e-01 8.32116790e-03]\n",
      " [6.95101102e-04 6.82365656e-01 3.16939265e-01]\n",
      " [8.15930963e-03 9.77541804e-01 1.42988889e-02]\n",
      " [5.51464618e-04 5.16966581e-01 4.82482016e-01]\n",
      " [8.65310524e-03 9.85957801e-01 5.38911810e-03]\n",
      " [3.18968203e-04 4.94073600e-01 5.05607426e-01]\n",
      " [1.92826777e-03 9.07633066e-01 9.04386416e-02]\n",
      " [5.01001533e-03 9.87907588e-01 7.08242971e-03]\n",
      " [4.04334161e-03 9.88796353e-01 7.16030691e-03]\n",
      " [1.36145821e-03 9.54370797e-01 4.42677774e-02]\n",
      " [5.75631799e-04 7.75723159e-01 2.23701239e-01]\n",
      " [1.99202495e-03 8.88862610e-01 1.09145299e-01]\n",
      " [4.04859148e-02 9.58374262e-01 1.13979192e-03]\n",
      " [8.75601638e-03 9.75714982e-01 1.55290114e-02]\n",
      " [1.40196141e-02 9.78756309e-01 7.22408807e-03]\n",
      " [1.00405561e-02 9.82938230e-01 7.02126604e-03]\n",
      " [7.04912236e-05 1.59627587e-01 8.40301931e-01]\n",
      " [1.50249992e-03 6.57581568e-01 3.40915978e-01]\n",
      " [3.29298875e-03 9.52706218e-01 4.40007374e-02]\n",
      " [2.04835460e-03 9.73700821e-01 2.42508426e-02]\n",
      " [1.80064491e-03 9.26328003e-01 7.18713328e-02]\n",
      " [7.11446907e-03 9.72750366e-01 2.01352704e-02]\n",
      " [4.58958000e-03 9.33132648e-01 6.22777715e-02]\n",
      " [2.29264586e-03 8.10979307e-01 1.86727956e-01]\n",
      " [2.25051423e-03 9.26267445e-01 7.14820847e-02]\n",
      " [6.62725605e-03 9.78905261e-01 1.44675644e-02]\n",
      " [2.84424014e-02 9.65631604e-01 5.92599157e-03]\n",
      " [3.87898530e-03 9.26634490e-01 6.94864914e-02]\n",
      " [6.88543450e-03 9.76448238e-01 1.66663826e-02]\n",
      " [5.18247345e-03 9.63271916e-01 3.15456577e-02]\n",
      " [4.66940738e-03 9.82932448e-01 1.23981629e-02]\n",
      " [8.17393437e-02 9.17208552e-01 1.05202547e-03]\n",
      " [5.69353951e-03 9.68366206e-01 2.59402040e-02]\n",
      " [5.32879540e-07 8.23210925e-03 9.91767347e-01]\n",
      " [8.95817811e-06 3.31911184e-02 9.66799974e-01]\n",
      " [2.19445110e-06 3.26753780e-02 9.67322350e-01]\n",
      " [5.04996160e-06 3.27867605e-02 9.67208147e-01]\n",
      " [9.33723925e-07 1.17232297e-02 9.88275826e-01]\n",
      " [1.71431438e-07 7.75158126e-03 9.92248297e-01]\n",
      " [4.54926558e-05 5.27650118e-02 9.47189569e-01]\n",
      " [1.00141199e-06 2.21799891e-02 9.77819085e-01]\n",
      " [1.36604024e-06 1.71166752e-02 9.82882023e-01]\n",
      " [9.45999432e-07 1.91085879e-02 9.80890512e-01]\n",
      " [1.87616068e-04 4.02042985e-01 5.97769380e-01]\n",
      " [1.35679720e-05 6.88297376e-02 9.31156695e-01]\n",
      " [1.26513087e-05 8.67567360e-02 9.13230658e-01]\n",
      " [5.21668426e-06 2.07028035e-02 9.79291975e-01]\n",
      " [2.72515035e-06 1.51540907e-02 9.84843254e-01]\n",
      " [1.13512579e-05 5.91268390e-02 9.40861762e-01]\n",
      " [2.46448308e-05 1.12076148e-01 8.87899220e-01]\n",
      " [7.81021811e-07 2.50039529e-02 9.74995315e-01]\n",
      " [3.93565536e-08 3.54269170e-03 9.96457279e-01]\n",
      " [3.61763050e-05 1.02817975e-01 8.97145867e-01]\n",
      " [3.47442028e-06 3.80337760e-02 9.61962819e-01]\n",
      " [1.63128952e-05 4.28667627e-02 9.57116902e-01]\n",
      " [1.27698570e-07 6.77923020e-03 9.93220568e-01]\n",
      " [1.80257033e-04 3.49701285e-01 6.50118411e-01]\n",
      " [7.96898621e-06 5.89966066e-02 9.40995395e-01]\n",
      " [1.45760023e-05 1.31040186e-01 8.68945241e-01]\n",
      " [3.22059757e-04 4.59608406e-01 5.40069520e-01]\n",
      " [2.88681971e-04 4.06978995e-01 5.92732310e-01]\n",
      " [1.42547754e-06 1.39963524e-02 9.86002207e-01]\n",
      " [5.86960232e-05 3.25211108e-01 6.74730182e-01]\n",
      " [1.85536430e-06 3.69693041e-02 9.63028848e-01]\n",
      " [2.32648963e-05 2.85936475e-01 7.14040279e-01]\n",
      " [1.16394119e-06 1.24468198e-02 9.87552047e-01]\n",
      " [2.80587177e-04 4.61612344e-01 5.38107157e-01]\n",
      " [7.89159094e-06 3.89935933e-02 9.60998535e-01]\n",
      " [1.18748903e-06 3.28914486e-02 9.67107356e-01]\n",
      " [1.61210687e-06 1.45125967e-02 9.85485792e-01]\n",
      " [2.69324773e-05 1.10715784e-01 8.89257312e-01]\n",
      " [3.88264540e-04 4.52763200e-01 5.46848595e-01]\n",
      " [4.30244436e-05 2.10063189e-01 7.89893806e-01]\n",
      " [1.52015411e-06 1.83379333e-02 9.81660485e-01]\n",
      " [9.48653833e-05 3.39112937e-01 6.60792172e-01]\n",
      " [8.95817811e-06 3.31911184e-02 9.66799974e-01]\n",
      " [7.53827521e-07 1.20648481e-02 9.87934351e-01]\n",
      " [9.89658702e-07 1.35240927e-02 9.86474931e-01]\n",
      " [2.37336790e-05 1.21122427e-01 8.78853858e-01]\n",
      " [3.34572214e-05 1.17552422e-01 8.82414103e-01]\n",
      " [5.88243238e-05 1.95860460e-01 8.04080784e-01]\n",
      " [7.02005536e-06 3.67173627e-02 9.63275671e-01]\n",
      " [5.95824895e-05 1.31053552e-01 8.68886828e-01]]\n"
     ]
    }
   ],
   "source": [
    "pred = model.predict(x)\n",
    "print(\"Shape: {pred.shape}\")\n",
    "print(pred)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "# If you would like to turn of scientific notation, the following line can be used:\n",
    "np.set_printoptions(suppress=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "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": [
    "# The to_xy function represented the input in the same way.  Each row has only 1.0 value because each row is only one type\n",
    "# of iris.  This is the training data, we KNOW what type of iris it is.  This is called one-hot encoding.  Only one value\n",
    "# is 1.0 (hot)\n",
    "print(y[0:10])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "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 1 1 2 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 2 2 2 2 2 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": [
    "# Usually the column (pred) with the highest prediction is considered to be the prediction of the neural network.  It is easy\n",
    "# to convert the predictions to the expected iris species.  The argmax function finds the index of the maximum prediction\n",
    "# for each row.\n",
    "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": "code",
   "execution_count": 17,
   "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": [
    "# Of course it is very easy to turn these indexes back into iris species.  We just use the species list that we created earlier.\n",
    "print(species[predict_classes[1:10]])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Accuracy: 0.9866666666666667\n"
     ]
    }
   ],
   "source": [
    "from sklearn.metrics import accuracy_score\n",
    "# Accuracy might be a more easily understood error metric.  It is essentially a test score.  For all of the iris predictions,\n",
    "# what percent were correct?  The downside is it does not consider how confident the neural network was in each prediction.\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.  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": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[0.00137655 0.49378854 0.5048349 ]]\n",
      "Predict that [[5. 3. 4. 2.]] is: Iris-virginica\n"
     ]
    }
   ],
   "source": [
    "# ad hoc prediction\n",
    "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]}\")\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[0.00137655 0.49378866 0.5048348 ]\n",
      " [0.98949325 0.01050675 0.        ]]\n",
      "Predict that these two flowers [[5.  3.  4.  2. ]\n",
      " [5.2 3.5 1.5 0.8]] are: Index(['Iris-virginica', 'Iris-setosa'], dtype='object')\n"
     ]
    }
   ],
   "source": [
    "# predict two sample flowers\n",
    "sample_flower = np.array( [[5.0,3.0,4.0,2.0],[5.2,3.5,1.5,0.8]], 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} 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": "rga"
  },
  "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.6.9"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}