{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Deep Learning 101\n",
    "## SLC Python Meetup: June 2, 2021\n",
    "\n",
    "<img width=800 height=600 src=../images/broken-clock.jpg>\n",
    "\n",
    "<!-- TEASER_END -->"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Feel Free To Follow Along At Home\n",
    "\n",
    "download the notebook and fire up a jupyter server and play around. You can get my posts as .ipynb files just by replacing the .html with .ipynb in the url e.g.\n",
    "\n",
    "```\n",
    "wget http://asymptoticlabs.com/blog/posts/deep-learning-101.ipynb\n",
    "jupyter notebook\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# What Can You Do With Deep Learning ?\n",
    "\n",
    "* Learn simple easy to use representations of data \n",
    "* Predict the folding structure of proteins\n",
    "* Predict the chemical properties of molecules\n",
    "* Play super human Chess/Go/Shogi/... \n",
    "* Turn random noise into novel images\n",
    "* Recommend new content to users\n",
    "* Rank the relevancy of search result candidates\n",
    "* Automatically caption images\n",
    "* Identify the people in a photo\n",
    "* Automatically generate interactive fiction\n",
    "* Predict y given x\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Deep Learning in a Nutshell ?\n",
    "\n",
    "1. Formulate a problem so that you have inputs x and target labels y\n",
    "1. The inputs x are the initial \"activations\" of the network\n",
    "1. For each layer in the network which is connected to the current activations\n",
    "    1. Mix your inputs together into a large number of buckets call them \"channels\". The mixing is done by matrix multiplication.\n",
    "    2. Forget the parts of the mixed up inputs less than some threshold in each channel\n",
    "    3. Pass the results as an input to the next layer\n",
    "2. Turn the last set of outputs into probabilities (Squeeze them so they lie between 0 and 1 and sum to 1). \n",
    "2. Slightly alter particular mix of inputs to improve predictions to match a set of target labels\n",
    "2. Repeat till you get good results or get bored\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Why Does Deep Learning Work?\n",
    "\n",
    "## Simple Pattern Matching + Memorization Works! \n",
    "#### (when you have enough parameters and enough data)\n",
    "\n",
    "https://xkcd.com/1897\n",
    "\n",
    "<img src=https://imgs.xkcd.com/comics/self_driving.png>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Why Does Deep Learning Work?\n",
    "## Most Optima are Global Optima\n",
    "\n",
    "<table>\n",
    "    <tr>\n",
    "        <th><h1> Less Like This</h1></th>\n",
    "        <th><h1> More Like This</h1></th>\n",
    "    <\\tr>\n",
    "    <tr>\n",
    "        <td> <img width=600 src=../images/hubble-ultra-deep-field.jpg> </td>\n",
    "        <td> <img width=600 src=../images/water-light-patterns.jpg> </td>\n",
    "    <\\tr>\n",
    "\n",
    "</table>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# First Some Imports\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "notes"
    }
   },
   "source": [
    "I use TensorFlow + Keras but pytorch has recently become quite mature and you may actually want to start with that, If I was starting over again I think I would prefer pytorch but I just haven't devoted the time needed to learn it."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [],
   "source": [
    "import tensorflow as tf\n",
    "import tensorflow.keras.layers as L #All the types of network modules \n",
    "\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'2.2.0'"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#TensorFlow is still changing quickly \n",
    "tf.__version__"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "outputs": [],
   "source": [
    "plt.rcParams.update(\n",
    "    {\n",
    "        \"figure.figsize\":(12, 6),\n",
    "        \"font.size\":15,\n",
    "    }\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# A (Very) Simple Problem to Solve\n",
    "\n",
    "## With Just a Hint of Real World Complexity\n",
    "\n",
    "* Goal: Learn to map the integers to a class probability with a small amount of label noise\n",
    "* x = 0 -> y=(1, 0, 0, ...)\n",
    "* x = 1 -> y=(0, 1, 0, ...)\n",
    "* ...\n",
    "* In the real world this would be learning a class probability as a function of a single categorical variable\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "def generate_random_digit_xy_pairs(\n",
    "    n_samples, \n",
    "    n_classes=None,\n",
    "    scale=1.0,\n",
    "    corruption_fraction=0,\n",
    "):\n",
    "    x = (scale*np.random.exponential(size=(n_samples, 1))).astype(int)\n",
    "    \n",
    "    if n_classes is None:\n",
    "        n_classes = len(np.unique(x))\n",
    "    \n",
    "    x = np.clip(x, 0, n_classes-1) #clip to a fixed range\n",
    "    x = x.reshape((-1, 1)) #add a channel dimension\n",
    "    \n",
    "    y = x\n",
    "    #add a small amount of label noise\n",
    "    if corruption_fraction > 0:\n",
    "        y = np.where(\n",
    "            np.random.random(y.shape) < corruption_fraction,\n",
    "            np.random.randint(n_classes+1, size=y.shape),\n",
    "            y\n",
    "        )   \n",
    "    \n",
    "    y = tf.keras.utils.to_categorical(x, num_classes=n_classes)\n",
    "    \n",
    "    return x, y"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "np.random.seed(1234)\n",
    "n_classes = 10\n",
    "scale = 1.5\n",
    "x_train, y_train = generate_random_digit_xy_pairs(\n",
    "    n_samples=1000, \n",
    "    n_classes=n_classes,\n",
    "    scale=scale,\n",
    "    corruption_fraction=0.05\n",
    ")\n",
    "x_test, y_test = generate_random_digit_xy_pairs(\n",
    "    n_samples=1000, \n",
    "    n_classes=n_classes,\n",
    "    scale=scale,\n",
    "    corruption_fraction=0.05,\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[(array([0]), array([1., 0., 0., 0., 0., 0., 0., 0., 0., 0.], dtype=float32)),\n",
       " (array([1]), array([0., 1., 0., 0., 0., 0., 0., 0., 0., 0.], dtype=float32)),\n",
       " (array([0]), array([1., 0., 0., 0., 0., 0., 0., 0., 0., 0.], dtype=float32)),\n",
       " (array([2]), array([0., 0., 1., 0., 0., 0., 0., 0., 0., 0.], dtype=float32)),\n",
       " (array([2]), array([0., 0., 1., 0., 0., 0., 0., 0., 0., 0.], dtype=float32))]"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list(zip(x_train[:5], y_train[:5]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Text(0, 0.5, 'Count ')"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 864x432 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.hist(x_train, bins=20)\n",
    "plt.xlabel(\"X value\")\n",
    "plt.ylabel(\"Count \")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# A Somewhat Naive Approach"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "def build_naive_network(n_classes):\n",
    "    input_activations = L.Input(shape=[1]) \n",
    "    \n",
    "    hidden_layer = L.Dense(\n",
    "        units=32, #number of output channels\n",
    "        activation=\"relu\",\n",
    "    )\n",
    "    #calling a layer as a function applies it to the input activations\n",
    "    hidden_activations = hidden_layer(input_activations)\n",
    "    \n",
    "    output_layer = L.Dense(\n",
    "        units=n_classes,\n",
    "        activation=\"softmax\",\n",
    "    )\n",
    "    class_probabilities = output_layer(hidden_activations)\n",
    "    \n",
    "    #make the model\n",
    "    model = tf.keras.models.Model(input_activations, class_probabilities)\n",
    "    \n",
    "    return model"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# ReLU? Softmax? Whatsat?\n",
    "\n",
    "A ReLU activation is in some sense just about the most gentle non-linearity you could imagine. It is linear almost everywhere but has a kink at 0. ReLU activations have come to be the defacto standard.\n",
    "\n",
    "$$\n",
    "ReLU(x) = max(0, x)\n",
    "$$\n",
    "\n",
    "Softmax just turns a vector of numbers both positive and negative into a vector that can be considered probabilities, which is very helpful for classification problems.\n",
    "$$\n",
    "{\\large\n",
    "softmax(x) = \\frac{exp(x_{j})}{\\sum_j^{N_C} exp(x_{j})}\n",
    "}\n",
    "$$\n",
    "\n",
    "Every once in a while you may want to use \"tanh\" or \"sigmoid\" activations but most of the time these suffice."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [],
   "source": [
    "model = build_naive_network(n_classes=n_classes)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Model: \"model\"\n",
      "_________________________________________________________________\n",
      "Layer (type)                 Output Shape              Param #   \n",
      "=================================================================\n",
      "input_1 (InputLayer)         [(None, 1)]               0         \n",
      "_________________________________________________________________\n",
      "dense (Dense)                (None, 32)                64        \n",
      "_________________________________________________________________\n",
      "dense_1 (Dense)              (None, 10)                330       \n",
      "=================================================================\n",
      "Total params: 394\n",
      "Trainable params: 394\n",
      "Non-trainable params: 0\n",
      "_________________________________________________________________\n"
     ]
    }
   ],
   "source": [
    "model.summary()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<IPython.core.display.Image object>"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "tf.keras.utils.plot_model(\n",
    "    model,\n",
    "    show_shapes=True,\n",
    "    show_layer_names=True,\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Picking an Optimizer and a Loss"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "optimizer = tf.keras.optimizers.Adam() # Modern standard optimizer\n",
    "\n",
    "model.compile(\n",
    "    loss=tf.keras.losses.CategoricalCrossentropy(), # typical for classification problems\n",
    "    optimizer=optimizer, \n",
    "    metrics=[\"accuracy\"], #extra numbers to track\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Check That The GPU Has Been Found\n",
    "\n",
    "e.g. if you are running in a docker you need to use either the --runtime nvidia flag or the nvidia-docker command instead of docker otherwise the GPU will not be found. There may also be driver problems etc etc."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[name: \"/device:CPU:0\"\n",
       " device_type: \"CPU\"\n",
       " memory_limit: 268435456\n",
       " locality {\n",
       " }\n",
       " incarnation: 13370115685411096310,\n",
       " name: \"/device:XLA_CPU:0\"\n",
       " device_type: \"XLA_CPU\"\n",
       " memory_limit: 17179869184\n",
       " locality {\n",
       " }\n",
       " incarnation: 10671607922699612273\n",
       " physical_device_desc: \"device: XLA_CPU device\",\n",
       " name: \"/device:GPU:0\"\n",
       " device_type: \"GPU\"\n",
       " memory_limit: 10436244928\n",
       " locality {\n",
       "   bus_id: 1\n",
       "   links {\n",
       "   }\n",
       " }\n",
       " incarnation: 1374095835648744634\n",
       " physical_device_desc: \"device: 0, name: GeForce GTX 1080 Ti, pci bus id: 0000:41:00.0, compute capability: 6.1\",\n",
       " name: \"/device:XLA_GPU:0\"\n",
       " device_type: \"XLA_GPU\"\n",
       " memory_limit: 17179869184\n",
       " locality {\n",
       " }\n",
       " incarnation: 8564099187364803404\n",
       " physical_device_desc: \"device: XLA_GPU device\"]"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from tensorflow.python.client import device_lib\n",
    "\n",
    "device_lib.list_local_devices()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Train The Model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 1/20\n",
      "32/32 [==============================] - 0s 7ms/step - loss: 2.4261 - accuracy: 0.2080 - val_loss: 2.3065 - val_accuracy: 0.0320\n",
      "Epoch 2/20\n",
      "32/32 [==============================] - 0s 4ms/step - loss: 2.2551 - accuracy: 0.0360 - val_loss: 2.1638 - val_accuracy: 0.0320\n",
      "Epoch 3/20\n",
      "32/32 [==============================] - 0s 4ms/step - loss: 2.1295 - accuracy: 0.6300 - val_loss: 2.0576 - val_accuracy: 0.7790\n",
      "Epoch 4/20\n",
      "32/32 [==============================] - 0s 4ms/step - loss: 2.0321 - accuracy: 0.7390 - val_loss: 1.9652 - val_accuracy: 0.7470\n",
      "Epoch 5/20\n",
      "32/32 [==============================] - 0s 4ms/step - loss: 1.9481 - accuracy: 0.7250 - val_loss: 1.8799 - val_accuracy: 0.7470\n",
      "Epoch 6/20\n",
      "32/32 [==============================] - 0s 4ms/step - loss: 1.8656 - accuracy: 0.7250 - val_loss: 1.7943 - val_accuracy: 0.7470\n",
      "Epoch 7/20\n",
      "32/32 [==============================] - 0s 4ms/step - loss: 1.7833 - accuracy: 0.7250 - val_loss: 1.7057 - val_accuracy: 0.7470\n",
      "Epoch 8/20\n",
      "32/32 [==============================] - 0s 4ms/step - loss: 1.6930 - accuracy: 0.7250 - val_loss: 1.6130 - val_accuracy: 0.7470\n",
      "Epoch 9/20\n",
      "32/32 [==============================] - 0s 4ms/step - loss: 1.5996 - accuracy: 0.7250 - val_loss: 1.5148 - val_accuracy: 0.7470\n",
      "Epoch 10/20\n",
      "32/32 [==============================] - 0s 4ms/step - loss: 1.5018 - accuracy: 0.7250 - val_loss: 1.4174 - val_accuracy: 0.7470\n",
      "Epoch 11/20\n",
      "32/32 [==============================] - 0s 4ms/step - loss: 1.4040 - accuracy: 0.7250 - val_loss: 1.3194 - val_accuracy: 0.7470\n",
      "Epoch 12/20\n",
      "32/32 [==============================] - 0s 4ms/step - loss: 1.3093 - accuracy: 0.7250 - val_loss: 1.2265 - val_accuracy: 0.7470\n",
      "Epoch 13/20\n",
      "32/32 [==============================] - 0s 4ms/step - loss: 1.2197 - accuracy: 0.7250 - val_loss: 1.1412 - val_accuracy: 0.7470\n",
      "Epoch 14/20\n",
      "32/32 [==============================] - 0s 4ms/step - loss: 1.1384 - accuracy: 0.7250 - val_loss: 1.0626 - val_accuracy: 0.7470\n",
      "Epoch 15/20\n",
      "32/32 [==============================] - 0s 4ms/step - loss: 1.0646 - accuracy: 0.7250 - val_loss: 0.9935 - val_accuracy: 0.7470\n",
      "Epoch 16/20\n",
      "32/32 [==============================] - 0s 4ms/step - loss: 0.9989 - accuracy: 0.7250 - val_loss: 0.9317 - val_accuracy: 0.7470\n",
      "Epoch 17/20\n",
      "32/32 [==============================] - 0s 4ms/step - loss: 0.9407 - accuracy: 0.7250 - val_loss: 0.8770 - val_accuracy: 0.7470\n",
      "Epoch 18/20\n",
      "32/32 [==============================] - 0s 3ms/step - loss: 0.8891 - accuracy: 0.7250 - val_loss: 0.8289 - val_accuracy: 0.7470\n",
      "Epoch 19/20\n",
      "32/32 [==============================] - 0s 4ms/step - loss: 0.8436 - accuracy: 0.7250 - val_loss: 0.7860 - val_accuracy: 0.7470\n",
      "Epoch 20/20\n",
      "32/32 [==============================] - 0s 4ms/step - loss: 0.8045 - accuracy: 0.7250 - val_loss: 0.7470 - val_accuracy: 0.7470\n"
     ]
    }
   ],
   "source": [
    "fit_history = model.fit(\n",
    "    x_train,\n",
    "    y_train,\n",
    "    validation_data=(\n",
    "        x_test,\n",
    "        y_test,\n",
    "    ),\n",
    "    batch_size=32,\n",
    "    epochs=20,\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Make Sure You Check Your GPU Utilization!\n",
    "\n",
    "\n",
    "```nvidia-smi -l ```\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "notes"
    }
   },
   "source": [
    "The chances are very high that your GPU utilization may be low or even that you aren't using the GPU at all! I have frequently found that somehow tensorflow has quietly fallen back to CPU only and sometimes it can be difficult to tell the difference between a tough to compute model and a model that is being churned through on only the CPU. I usually don't bother with getting my GPU utilization above around 75% and often settle for just 50% or so. Squeezing that last little bit out of the GPU can often be very hard and simple changes to your data pipeline can easily tank all that hard work. \n",
    "\n",
    "This model is incredibly light weight and I can't get much above 10% utilization through batch size alone. Often you may need to optimize your data pipeline in some way for."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# The Importance of Broken Clocks\n",
    "\n",
    "<img width=800 height=600 src=../images/broken-clock.jpg>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "notes"
    }
   },
   "source": [
    "Even a broken clock is right twice a day. And your first baseline for a model should always be A constant model one whose output does not change with respect to the inputs at all. These sorts of baselines are often the most useful possible diagnostics because you can know for certain that something is wrong if your model isn't at least beating this simple baseline. What would a good categorical cross entropy for this problem be? 1.2, 0.5, 0.005? It is very hard to say problem to problem but if you know the \"broken clock\" model would give you the same performance as your model currently does then you know that either something is wrong or you just don't have real predictive power."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0.471, 0.254, 0.118, 0.079, 0.036, 0.017, 0.011, 0.006, 0.003,\n",
       "       0.005], dtype=float32)"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "broken_clock_probs = np.mean(y_train, axis=0)\n",
    "broken_clock_probs"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "slideshow": {
     "slide_type": "notes"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1.422876388056832"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from sklearn import metrics\n",
    "metrics.log_loss(y_test,  np.ones((y_test.shape))*broken_clock_probs)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "Which if the probabilities are well calibrated will be equal to the entropy of the labels!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "def calc_entropy(p):\n",
    "    return -1.0*np.sum(p*np.log(p))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1.4685654640197754"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "calc_entropy(broken_clock_probs)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "notes"
    }
   },
   "source": [
    "So the model beats a broken clock by a factor of 2 should we consider that a win? Do we need more data? Should we try a new model architecture or data augmentation somehow?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Tip: The \"v\" weights of the adam optimizer are an estimate of the running average squared gradient magnitude"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[('Adam/dense/kernel/v:0', TensorShape([1, 32]), 0.0021857),\n",
       " ('Adam/dense/bias/v:0', TensorShape([32]), 0.00251424),\n",
       " ('Adam/dense_1/kernel/v:0', TensorShape([32, 10]), 0.00026588986),\n",
       " ('Adam/dense_1/bias/v:0', TensorShape([10]), 0.0048605013)]"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "[(w.name, w.shape, np.mean(w.numpy())) for w in optimizer.weights if \"/v:\" in w.name]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "notes"
    }
   },
   "source": [
    "Even extremely large values or extremely small values here aren't necessarily a problem but they often can be. For example I recently was training a model where these values were all 1e-10 or smaller in nearly every layer which was related to some problems with the loss function I was using. The deeper the network usually the smaller these values are though things like batch normalization combat that somewhat."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# What did it learn?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [],
   "source": [
    "def make_activation_model(net):\n",
    "    activation_map = {layer.name:layer.output for layer in net.layers}\n",
    "    return tf.keras.Model(net.inputs, activation_map)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [],
   "source": [
    "activation_model = make_activation_model(model)\n",
    "feature_maps = activation_model.predict(np.arange(10)[:, np.newaxis])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 864x432 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "hidden_features = feature_maps[\"dense\"]\n",
    "for channel in range(32):\n",
    "    plt.plot(hidden_features[:, channel], alpha=0.7, lw=3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "notes"
    }
   },
   "source": [
    "Gross! The network has learned features which are all mostly the same (common and not necessarily bad for a neural network, but "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 864x432 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 864x432 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 864x432 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "for name in feature_maps:\n",
    "    plt.title(name)\n",
    "    plt.imshow(feature_maps[name])\n",
    "    plt.ylabel(\"Digit Input\")\n",
    "    plt.xlabel(\"Activation Channel\")\n",
    "    plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# About 20% Cooler"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [],
   "source": [
    "def build_network(\n",
    "    channels, \n",
    "    n_classes,\n",
    "    dropout=-1,\n",
    "    vocabulary_size=None,\n",
    "    embedding_dimension=None,\n",
    "):\n",
    "    #I like to chain activations in blocks together by overwriting \"x\"\n",
    "    x = L.Input(shape=[1])\n",
    "    input_activations = {\n",
    "        \"a_categorical_feature\":x\n",
    "    }\n",
    "    \n",
    "    if not (embedding_dimension is None):\n",
    "        # Important Note!\n",
    "        # input dimension would not normally be equal to n_classes!!!\n",
    "        x = L.Embedding(input_dim=vocabulary_size, output_dim=embedding_dimension)(x)\n",
    "        x = L.Reshape((embedding_dimension,))(x) #get rid of the sequence dimension\n",
    "    \n",
    "    for layer_idx, n_ch in enumerate(channels):\n",
    "        x = L.Dense(n_ch, activation=\"relu\")(x)\n",
    "        if dropout > 0:\n",
    "            x = L.Dropout(dropout)(x)\n",
    "    \n",
    "    class_probabilities = L.Dense(n_classes, activation=\"softmax\")(x)\n",
    "    \n",
    "    #make the model\n",
    "    model = tf.keras.models.Model(input_activations, class_probabilities)\n",
    "    \n",
    "    #compile the model\n",
    "    model.compile(\n",
    "        loss=tf.keras.losses.SparseCategoricalCrossentropy(), #can also pass from_logits\n",
    "        optimizer=\"adam\",\n",
    "        metrics=[\"accuracy\"]\n",
    "    )\n",
    "    \n",
    "    return model"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# We Need to Go Deeper!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [],
   "source": [
    "cooler_model = build_network(\n",
    "    [32, 32, 32],\n",
    "    n_classes=n_classes,\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [],
   "source": [
    "cooler_x_train = {\"a_categorical_feature\":x_train}\n",
    "cooler_y_train = np.argmax(y_train, axis=1)\n",
    "\n",
    "cooler_x_test = {\"a_categorical_feature\":x_test}\n",
    "cooler_y_test = np.argmax(y_test, axis=1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 1/20\n",
      "32/32 [==============================] - 0s 6ms/step - loss: 2.2245 - accuracy: 0.6110 - val_loss: 2.1246 - val_accuracy: 0.7470\n",
      "Epoch 2/20\n",
      "32/32 [==============================] - 0s 4ms/step - loss: 2.0183 - accuracy: 0.7250 - val_loss: 1.8407 - val_accuracy: 0.7470\n",
      "Epoch 3/20\n",
      "32/32 [==============================] - 0s 4ms/step - loss: 1.6516 - accuracy: 0.7320 - val_loss: 1.3438 - val_accuracy: 0.8120\n",
      "Epoch 4/20\n",
      "32/32 [==============================] - 0s 4ms/step - loss: 1.1237 - accuracy: 0.7840 - val_loss: 0.8330 - val_accuracy: 0.7470\n",
      "Epoch 5/20\n",
      "32/32 [==============================] - 0s 4ms/step - loss: 0.7578 - accuracy: 0.7600 - val_loss: 0.5929 - val_accuracy: 0.7470\n",
      "Epoch 6/20\n",
      "32/32 [==============================] - 0s 4ms/step - loss: 0.5988 - accuracy: 0.7890 - val_loss: 0.4770 - val_accuracy: 0.8650\n",
      "Epoch 7/20\n",
      "32/32 [==============================] - 0s 4ms/step - loss: 0.4962 - accuracy: 0.8690 - val_loss: 0.4015 - val_accuracy: 0.9300\n",
      "Epoch 8/20\n",
      "32/32 [==============================] - 0s 4ms/step - loss: 0.4267 - accuracy: 0.9180 - val_loss: 0.3446 - val_accuracy: 0.9300\n",
      "Epoch 9/20\n",
      "32/32 [==============================] - 0s 4ms/step - loss: 0.3690 - accuracy: 0.9220 - val_loss: 0.2989 - val_accuracy: 0.9300\n",
      "Epoch 10/20\n",
      "32/32 [==============================] - 0s 4ms/step - loss: 0.3240 - accuracy: 0.9220 - val_loss: 0.2634 - val_accuracy: 0.9300\n",
      "Epoch 11/20\n",
      "32/32 [==============================] - 0s 4ms/step - loss: 0.2876 - accuracy: 0.9220 - val_loss: 0.2302 - val_accuracy: 0.9300\n",
      "Epoch 12/20\n",
      "32/32 [==============================] - 0s 4ms/step - loss: 0.2556 - accuracy: 0.9220 - val_loss: 0.2049 - val_accuracy: 0.9300\n",
      "Epoch 13/20\n",
      "32/32 [==============================] - 0s 4ms/step - loss: 0.2338 - accuracy: 0.9250 - val_loss: 0.1904 - val_accuracy: 0.9300\n",
      "Epoch 14/20\n",
      "32/32 [==============================] - 0s 4ms/step - loss: 0.2159 - accuracy: 0.9440 - val_loss: 0.1761 - val_accuracy: 0.9300\n",
      "Epoch 15/20\n",
      "32/32 [==============================] - 0s 4ms/step - loss: 0.1940 - accuracy: 0.9300 - val_loss: 0.1598 - val_accuracy: 0.9620\n",
      "Epoch 16/20\n",
      "32/32 [==============================] - 0s 4ms/step - loss: 0.1793 - accuracy: 0.9310 - val_loss: 0.1452 - val_accuracy: 0.9620\n",
      "Epoch 17/20\n",
      "32/32 [==============================] - 0s 4ms/step - loss: 0.1687 - accuracy: 0.9500 - val_loss: 0.1350 - val_accuracy: 0.9620\n",
      "Epoch 18/20\n",
      "32/32 [==============================] - 0s 4ms/step - loss: 0.1563 - accuracy: 0.9490 - val_loss: 0.1271 - val_accuracy: 0.9620\n",
      "Epoch 19/20\n",
      "32/32 [==============================] - 0s 4ms/step - loss: 0.1431 - accuracy: 0.9580 - val_loss: 0.1209 - val_accuracy: 0.9620\n",
      "Epoch 20/20\n",
      "32/32 [==============================] - 0s 4ms/step - loss: 0.1343 - accuracy: 0.9580 - val_loss: 0.1113 - val_accuracy: 0.9620\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<tensorflow.python.keras.callbacks.History at 0x7f85a3cff450>"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "cooler_model.fit(\n",
    "    cooler_x_train,\n",
    "    cooler_y_train,\n",
    "    validation_data=(\n",
    "        cooler_x_test,\n",
    "        cooler_y_test,\n",
    "    ),\n",
    "    batch_size=32,\n",
    "    epochs=20,\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [],
   "source": [
    "cooler_activation_model = make_activation_model(cooler_model)\n",
    "cooler_feature_maps = cooler_activation_model.predict(np.arange(10)[:, np.newaxis])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 864x432 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 864x432 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 864x432 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAs8AAAEcCAYAAAA4MFmrAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjMsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+AADFEAAAgAElEQVR4nO3deZxkZX3v8c+XYZhhGxhWNzY1irhdFRPU654YhXiJxgWMMYZ7g5pw3feYiCZqoteA0QRFE1BzCSpXo6CIgIKiiQouqAgiaxBUwGEdmPV3/zinpWh6Oc2crqrp/rxfr3p11Tmnfs+v+nR1/frp5zxPqgpJkiRJs9ti1AlIkiRJmwuLZ0mSJKkji2dJkiSpI4tnSZIkqSOLZ0mSJKkji2dJkiSpI4tnSRqSJJcnOWvUeUiS7j6LZ0nSvEnyZ0mqve0y6nwkaVNZPEuS5kWSewHvAm4ZdS6S1BeLZ0nSfPlH4FLg30ediCT1xeJZknqWZI8kn0xyY5Kbkpyc5H4zHP/bSb6U5IYktyc5P8lLpzju8iRnJdk3yeeT3Ny2cVKSe0w6dqckRyW5pI15fZLzkrxuirjPT3JOG291km8mec4mfg+eBfwP4CXAhk2JJUnjxOJZknqUZEfgq8CzgY8DbwRWA18Btp3i+MOBLwHbAe8AXg1cAhyT5D1TNHFv4CzgSuB1wAltWx+bdNyngCOAU4H/Dbwd+BbwpEnt/w1wInAz8JcD+X4qyZ/P4aUPxlwBfAD4UFV96+7EkKRxlaoadQ6StGAkeSfwJuCwqjpuYPvRwCuAs6vqSe22ewKXAZ+uqhdMivM+muL3AVV1SbvtcmAv4PlV9cmBY/8R+DPgQVV1YZIdgBuAY6rqz2bI9ZHAecC7qurNk/b9O/AU4N5VdfMcvwfHAL8P7FtVNyY5HvhjYNequm4usSRp3NjzLEn9+n3gF9y1J/jvpjj2OcAy4J+T7DJ4A06m+R391EnPuXqwcG59uf16//brbcAa4LeS7D1Drn8IFPDRKdr/HLA98JgZnn8XSR5LM1Tj1VV141yeK0mbgy1HnYAkLTD3Bb5dVXca51tV1yS5YdKxD2q/njFDvN0nPb50imOub7/u3La1NskrgfcBlyW5gKbA/veqOnNS+wEunEP700qyFfBh4Iyq+reuz5OkzYnFsyT1b7rxcJnm8YuAa6Z5zuRieaaL734dv6o+mOSzwEHAE2l6uY9I8omqOmTg+AKeMUPcH83Q3mR/DuwLvCbJ/Qe2b99+3SfJiqqa6g8ASdosWDxLUr8uBR6QZMlg73M7vnmHScde3H69rqpm6n2+W6rqGuAjwEeSLKG5gPHQJO+tqm+37T8duLKqftxDk3vRDDU5dZr93wJupbk4UpI2S455lqR+fZZmqMOLJm1/wxTHfpJmbPLbkmw9eWeSHZIsm2sCSbZJss3gtraQP799uFP79ePt13e2xfXkOLvNsenjgOdOcTur3X8Y8MI5xpSksWLPsyT1693AC4APJ3kUzbCHJ9FceHenmSaq6qokL6PpHf5xko8DVwC7Ag+lufhwP+DyOebwAODsJJ8Bfgisohnf/DKa2T2+1rb/7SRvBd4GfC/Jp4CrgXsCjwIOBLbq2mhVfR/4/uTtSX6vvXuys21I2txZPEtSj6pqVZLHA39P0/scmp7XJwNnTnH8cUl+AryWZpaKHWmK7Ito5l3++d1I47+Af2nb/H2aGT1+RnMx399V1eqB9t+e5Dzg5cAraeai/iVN0f2Ku9G2JC1ozvMsSZIkdeSYZ0mSJKkjh21IkmaUZCdmH/t8m4uiSFoMHLYhSZpRkrNo5oqeyUer6sXzn40kjZbFsyRpRu2sIStnOezqqrpgGPlI0ihZPEuSJEkdbVZjnrfK8lqebXuNma2W9hoPoNas7T3mYlbbbzP7QXOUm1fPftBc4m15l/UlNlmtn2kVZs1Vrej/52g+5KZ+fzbnzTZ3WdNl062+rf+Y8yGTV1nvIeSyztNpd1a3r+k9Zt/m4/f7FmvX9x7Tz/XxVzv0+7N0++pVrFt765Rv9s2qeF6ebTlg6dN7jbnkPvfqNR7A+ksv7z3mYrbugEf1HnPpGef1Gm/Jyp17jQew4brre485L7bo/w8HNvb/h8Pax+7fe8zMwz/uln7p3P6DzoM85KG9x6xv/6D3mPMhy+a86OOstth7j95jbrjop73H7Nt8/H7f+tL+f3f6uT7+bn/Cb/Ya73tffd+0+5yqTpIkSerI4lmSJEnqyOJZkiRJ6mjoxXOS/ZKcmWR1kquTvD3JPAyalCRJkvo11AsGk6wEzgAuAA4G7ge8l6aIf8swc5EkSZLmatizbbwU2Bp4dlXdBJyeZAVwZJJ3t9skSZKksTTsYRvPAE6bVCSfSFNQz7b0qyRJkjRSwy6e9wUuHNxQVVcCq9t9kiRJ0tga9rCNlcANU2xf1e67iySHA4cDLGfzWCFMkiRJC9Mopqqbak2uTLOdqjq2qvavqv2XZvn8ZiZJkiTNYNjF8ypgxym278DUPdKSJEnS2Bh28Xwhk8Y2J9kD2JZJY6ElSZKkcTPs4vlU4HeTbD+w7fnAbcDZQ85FkiRJmpNhF88fBNYAn07y2+3FgEcCf+8cz5IkSRp3Q51to6pWJXkq8AHgZJpxzkfRFNCSJEnSWBv2VHVU1QXAU4bdriRJkrSpRjFVnSRJkrRZsniWJEmSOhr6sI1NkS22YIttt+415vpLL+81nvq3/Jpbeo+5oed42XYeVr+87vr+Y86DLfe8d+8x119+Ze8xSXoPueUt63qPubnIur7fRdOslDWGluy6S+8x11/0095jbrH99rMfNEcbb+n39/GSdRt7jQewYeW2vcfcbMzD7zlq83hnZkPPec4Qzp5nSZIkqSOLZ0mSJKkji2dJkiSpI4tnSZIkqSOLZ0mSJKkji2dJkiSpI4tnSZIkqSOLZ0mSJKkji2dJkiSpI4tnSZIkqSOLZ0mSJKkji2dJkiSpI4tnSZIkqSOLZ0mSJKkji2dJkiSpI4tnSZIkqSOLZ0mSJKkji2dJkiSpI4tnSZIkqSOLZ0mSJKmjLUedwFzUhg1suOHGUaehGSx58AN7j7nhRxf1HrN3S5b0H3LXXXuPueHaa/uPucuK3mNumb16j7nx1vW9x1z6s1/1HrP/LOfHFtfe0HvMjb1HhCW779Z7zNp6We8x50OWbdV7zC133qPXeHXd6l7jAbB+Q+8h+484P5bsuGPvMTesWtV7zPmw9JZ+f3tmY027z55nSZIkqSOLZ0mSJKkji2dJkiSpI4tnSZIkqSOLZ0mSJKmjoRbPSZ6b5HNJfpbkliTnJTl0mDlIkiRJd9ewp6p7NXAZ8CrgOuBA4IQku1TV+4eciyRJkjQnwy6en1lV1w08/nKSe9EU1RbPkiRJGmtDHbYxqXCe8F2g/1nsJUmSpJ6NwwWDjwUuGHUSkiRJ0mxGujx3kqcCBwOHzXDM4cDhAMvZZkiZSZIkSXc1sp7nJHsDJwCfrarjpzuuqo6tqv2rav+lLBtSdpIkSdJdjaR4TrITcCpwJfDCUeQgSZIkzdXQi+ck2wCnAFsBB1XVrcPOQZIkSbo7hjrmOcmWwKeA3wAeV1W/HGb7kiRJ0qYY9gWD/0SzMMorgJ2SHDCw77tVtWbI+UiSJEmdDbt4flr79X1T7NsHuHx4qUiSJElzM9Tiuar2HmZ7kiRJUp/GYZEUSZIkabNg8SxJkiR1NNIVBrXw3Ljfjr3H3O5HvYfsXS2Zh79Dd13Zf8xrr+095Jqdl/cec4sV/S+ItHTV7b3HXH/5lb3H3Fys/9nVo06hk9p9p/6Dbuw/5HzI0qW9x1x7n36/n0sv7v/naD5e9+YiO2zff9BVq3oPueU+e/Uec+PN/c45kQ017T57niVJkqSOLJ4lSZKkjiyeJUmSpI46Fc9JLk3y8Gn2PSTJpf2mJUmSJI2frj3PewPTXcGzDXCfXrKRJEmSxti0s20kWQEMTp1wjyR7TjpsOXAI8LN5yE2SJEkaKzNNVfcq4K1AtbfPTHNcgNf0nJckSZI0dmYqnk8AzqUpjj8HvBa4aNIxa4GLqmrxTnYqSZKkRWPa4rmqLgYuBkjyZOA7VXXzsBKTJEmSxk3XFQa/DZBkm+kOqKrVvWQkSZIkjamuxfMtNOOeZ7JkE3ORJEmSxlrX4vkw7lo87wQ8DdgP+Os+k5IkSZLGUafiuaqOn2bXUUn+CXhwbxlJkiRJY6qP5bk/DbyohziSJEnSWOujeH40sKaHOJIkSdJY6zRsI8m7p9i8FfAg4KnA0X0mJUmSJI2jrhcMPneKbbcDVwEvB47tLSNJkiRpTHW9YHCf+U5EkiRJGnd9jHmWJEmSFoXOxXOShyY5IclPk9zafj0hycPmM0FJkiRpXHS9YPD3gU8ClwAnAb8EdgMOBs5N8ryq+vd5y1KbjRvv1/9Ck9v1HnEeJL2HXLfztr3HnI9/Na3ZseulE91tWNb/93Pnq27oPeaG3iOqb2t36f99tPSmzWSCqa2W9h5y9T2X9Rpvu3N+2Ws8gCUrVvQec3OxcbttRp1CJ7fvs0vvMZdfdl2/ATdsnHZX10+9vwM+Czyvqn690mCSN9EU0+8GLJ4lSZK0oHXtiNoD+Mhg4QzQPj4WuE/fiUmSJEnjpmvxfC7TL8H9EOA7/aQjSZIkja+uwzZeDZyYZCnN8IyJMc/PAv4XcEiSXw+0qarVfScqSZIkjVrX4vlb7dd3Ae8c2D5xVc83Jx3f6aqxJPcGLgK2Bbavqls65iNJkiQNXdfi+TCgZj1q7t4D3EJTPEuSJEljresKg8f33XCSxwNPp+nJfk/f8SVJkqS+9T9BawdJlgDvB94O9D/5qiRJkjQPOs22kWRpktcm+UaSK5P8cvJtju2+FFgO/OOcM5YkSZJGpGvP81HAS4BTgK8Aa+9ug0l2Bv4aeGFVrcs8rMwmSZIkzYeuxfNzgTdW1Xt7aPMdwDer6gtdDk5yOHA4wHI2j2UnJUmStDB1LZ4DnL+pjSV5MM3MHU9IsmO7eaIi3iHJhqq6bfA5VXUszSqGrMhO8zHjhyRJktRJ1xUGPwwc2kN7vwEsBf4DWNXeJsY9X0VzEaEkSZI0lrr2PP8C+MMkXwFO564zZFRVHdMhzjnAkydtezrwBuBA4NKO+UiSJElD17V4Prr9uifwxCn2FzBr8VxV1wFnDW5Lsnd792uuMChJkqRx1nWRlK7DOyRJkqQFa+RFcVUdX1Wx11mSJEnjbtqe5yT7zSVQVV2w6elIkiRJ42umYRs/pBnLPJu0xy3pJSNJkiRpTM1UPE+eFUOSJEla1KYtnqvq7GEmooXh1j3XjzqF0ZiHZebX7ri095jLe48Ia3aYh9c+DzF3WX177zE1/tbs1HVSqe6WrNnQe8z+f+Khlm3Ve8zbdu73Uqnteo3W2Hjb4n2vb9ih/9/y8/Gzees9+/98W/aj22Y/aC42bpx218gvGJQkSZI2FxbPkiRJUkcWz5IkSVJHFs+SJElSR52K5yR7JplydHeSLZPs2W9akiRJ0vjp2vN8GfCIafY9vN0vSZIkLWhdi+eZZipZDqzpIRdJkiRprM20PPfDgP82sOnAJPtOOmw58DzgJ/OQmyRJkjRWZpo9/lnAW9v7BfzVNMddBrykz6QkSZKkcTTTsI13AtsDK2iGbTylfTx4W1ZV96uqM+Y7UUmSJGnUZlqeex2wrn3olHaSJEla9GYa87wfcElVrWnvz6iqLug1M0mSJGnMzDTm+YfAAcC32vs1zXFp9y3pNzVJkiRpvMxUPD8ZuGDgviRJkrSozTTm+eyp7kuSJEmLlRcCSpIkSR11Kp6TbEyyYZrb+iS/SvKVJM+a74QlSZKkUZlpzPOgV7e3m4CTgWuB3YBn0sz3/M/A44GTkvxxVf3rPOQqSZIkjVTX4vlewNer6tBJ29+Y5ERgZVX9dpKPAa8HLJ4lSZK04HQd8/wnwHHT7DsO+KP2/ieA39jUpCRJkqRx1LXneUtgX+BLU+x7EHcU4WuB23vIS5uplfe5cdQpLBhrVvR/Pe/y3iPC2h3Se8zbd5luWvm7r273V9NidPsO/b+Plv2q/2UNun4Yz0UtX9p7zDUr+3+/963WrR11CiOzbrv+f5K26j0i3L7zPMxXcVvPv+Nr47S7un6XTwTelWRL7hjzvCtwMPB27uiVfiRw4d1OVJIkSRpjXYvnV9D0Kv8N8J6B7WuADwOvax9/Ezizt+wkSZKkMdKpeK6qtcArkrwNeChwD+DnwA+q6lcDx501H0lKkiRJ42BOg2PaQtnVBiVJkrQoTVs8JzkQOKeqbmrvz6iqvtClwXbc9GuB/wnsSTN++lNV9apuKUuSJEmjMVPP8ynAAcC32vsFTHeZbQFdLz8+Dngq8Daaiwv3APbr+FxJkiRpZGYqnvcBrhm4v8mSPB04BHh4VV3QR0xJkiRpWKYtnqvqiqnub6LDgC9bOEuSJGlzNOsFg0kC/A7NEI7d282/AP4DOKOq5rKawW8Bn0vyAeBFbftfBI6oqqvnkrgkSZI0bDMWz0keQbPk9v2ADcB1NOOed26f+5Mkh1TV9zq2dw/gxcD3aYZvbA+8G/hMkgPmWIhLkiRJQzXt+ohJdgdOA24DDgS2q6p7VdU9aYreg2gWTjktyW4d20t7O7iqvlBVnwD+CPhN4CnT5HF4knOTnLuONV1flyRJktS7mRYX/980hfPjq+q0dqEUAKpqTVWdCjyhPeaIju2tollY5fqBbefQFOFTzrhRVcdW1f5Vtf9SlnVsRpIkSerfTMXz04B/qqqbpjugqm4AjgGe3rG9H0+zPcDGjjEkSZKkkZipeL4/8J0OMc5rj+3iFOBhSXYZ2PYEYCnNOGhJkiRpbM1UPO8A3Nghxs3Aio7tHQtcD5yc5JlJXgB8nGbWjnM6xpAkSZJGYqbiOTQrB3Yx3cqDd9IOAXkKzdjnE4F/BM4EntexHUmSJGlkZpvn+bQk6zcxxp1U1U9pZu+QJEmSNiszFb5vG1oWkiRJ0mZgpuW5LZ4lSZKkATONeZYkSZI0YE7jlaXZHHDPK3qPeUnvEefBFp2umZ2Tddv1H3M+rF3R9bri7tbvuq73mLVm7ewHacFZu0P/76MNy/vvd5qPD+NatrT3mGtX9v9+V3/Wbbek95hb9R4R1qzsP+bGNf2uQl0bp/9Zt+dZkiRJ6sjiWZIkSerI4lmSJEnqyOJZkiRJ6sjiWZIkSerI4lmSJEnqyOJZkiRJ6sjiWZIkSerI4lmSJEnqyOJZkiRJ6sjiWZIkSerI4lmSJEnqyOJZkiRJ6sjiWZIkSerI4lmSJEnqyOJZkiRJ6sjiWZIkSerI4lmSJEnqyOJZkiRJ6sjiWZIkSepoy1EnoIXloJXf6z3mP7Bv7zF7l/Qecu32/cecD+u3r95jrtzl5t5j1tq1vcfU+Fu3ov+YG5ZtHv1OG7da0nvM9Tuu7z2m+rNu283jZ3Ptyo29x6w1a3oOOP1n2+bxXZYkSZLGgMWzJEmS1JHFsyRJktSRxbMkSZLU0dCL5ySHJPlOkluS/CzJx5Lca9h5SJIkSXM11OI5yf8A/g34BnAw8AbgCcApSewFlyRJ0lgb9lR1LwC+U1VHTGxIchPwWeCBwI+HnI8kSZLU2bB7e5cCN07adkP7dfOY1FaSJEmL1rCL538BHp/kRUlWJHkA8DfAV6rqgiHnIkmSJM3JUIvnqvo88GLgWJoe6IuAJcCzp3tOksOTnJvk3HX0vHqMJEmSNAfDvmDwycAHgfcBTwYOAXYCPpNkynVEq+rYqtq/qvZfyrLhJStJkiRNMuwLBt8LfK6q3jCxIcn3gAtpZt/49JDzkSRJkjob9pjnfYHvDW6oqouA24D7DTkXSZIkaU6GXTxfATxycEOSBwFbA5cPORdJkiRpToY9bOODwFFJrgZOBXYH/oqmcP7CkHORJEmS5mTYxfM/AGuBlwEvpZnj+RzgTVV165BzkSRJkuZkqMVzVRVwTHuTJEmSNivDHvMsSZIkbbYsniVJkqSOLJ4lSZKkjoZ9waAWuIO2ub33mP/Qe8R5kPQecv12vYecFxtXrO895v13uq73mDeuXdt7TI2/tSs29h5zw1b9v9/nw8at+u8fW76y/9/x6s+6bUedQTe1cvP+fWzPsyRJktSRxbMkSZLUkcWzJEmS1JHFsyRJktSRxbMkSZLUkcWzJEmS1JHFsyRJktSRxbMkSZLUkcWzJEmS1JHFsyRJktSRxbMkSZLUkcWzJEmS1JHFsyRJktSRxbMkSZLUkcWzJEmS1JHFsyRJktSRxbMkSZLUkcWzJEmS1JHFsyRJktSRxbMkSZLUUapq1Dl0luRa4IoOh+4CXDfP6WjTeI7Gn+dovHl+xp/naLx5fsbfKM/RXlW161Q7Nqviuask51bV/qPOQ9PzHI0/z9F48/yMP8/RePP8jL9xPUcO25AkSZI6sniWJEmSOlqoxfOxo05As/IcjT/P0Xjz/Iw/z9F48/yMv7E8RwtyzLMkSZI0HxZqz7MkSZLUuwVVPCfZL8mZSVYnuTrJ25MsGXVegiQvTlJT3F466twWqyT3T/KhJN9PsiHJWVMckyRvTvJfSW5L8tUk/20E6S46Hc/P5VO8p34+gnQXnSTPTfK5JD9LckuS85IcOsVxf5rk4iS3t8c8dRT5LkZdzlGSs6b5bFo+qrwXkyTPSfKNJNe375GLkrwlyVYDx4zd59CWo2y8T0lWAmcAFwAHA/cD3kvzB8JbRpia7uwpwG0Djy8dVSLiwcCBwH8CW01zzBuBvwReB1wIvBo4I8lDqsoibX51OT8AJwDvH3i8dj6T0q+9GrgMeBXNPLQHAick2aWq3g+Q5BDgg8CRwDnAnwCnJHl0Vf1wJFkvLrOeo9ZXgDdPeu6a4aS46O1M8/1/D3AD8Js075d7AEe0x4zd59CCGfOc5E3A62kmtb6p3fZ62pMwsU2jkeTFwHHA9lV1y4jTEZBki6ra2N4/Cdilqp40sH858AvgvVX19nbbtsDlwIeqyj9K59Fs56fdfjlwUlW9dvgZLm5tAXbdpG0nAI+pqn3axxcBX6+qw9rHWwDfB75fVS8cds6LTcdzdBZwXVU9ZwQpagpJ3gH8ObASWMYYfg4tpGEbzwBOm1QknwhsDTxxNClJ42uiMJvBY4EVwCcHnnMrcDLN+03zqMP50QhNLspa3wV2A0hyX+AB3Pn9sxH4FL5/hmK2c6SxdT13/LdtLD+HFlLxvC9Nd/6vVdWVwOp2n8bDJUnWt+OaXjLqZDSjfYENwMWTtv8Y31Pj5LAka5PcmOSkJHuNOqFF7LE0QwfhjvfIhZOO+TGwU5Ipl/3VvBs8RxOe1l4rtTrJaUkeNorEFrMkS5Jsk+S/Ay8HjqlmaMRYfg4tmDHPNN37N0yxfVW7T6N1Dc2YpW8BS4BDgQ8m2aaqjhppZprOSuCWqtowafsqYJskW1WV42tH67M0Y6KvAh4EvBX4WpKHVtWNI81skWkvBDwYOKzdNPG5M/lzadXA/muHkJpaU5wjgLOBjwI/BfYC/oLmPfTwqrp86EkuXrfSDNEA+BjN+GYY08+hhVQ8A0w1gDvTbNcQVdVpwGkDm05Nsgx4S5L3+S/qsTXde2q6fRqiqnrFwMOvJfkG8D2aC9OOHk1Wi0+SvWku3PxsVR0/affk94nvnxGY7hxV1VsHDvtakjNo/lvwyvam4XgssA3NBYN/BXwA+LN239h9Di2k4nkVsOMU23dg6h5pjd5JwPOAvXHWjXG0Ctg+yZJJf/XvCKyuqnUjykvTqKofthepPXLUuSwWSXYCTgWuBAYvApzoYd4RGPwvwMTnlJ9LQzLDObqLqvp5kq/je2ioquo77d1zklwHfDTJexnTz6GFNOb5QiaNf0myB7Atdx1zpvFiD8x4upBmiM39J22/y/UFGju+p4YgyTbAKTQXNx3UXsg0YeI9Mnlc5r7Ar6rKIRtDMMs5monvodGZKKT3YUw/hxZS8Xwq8LtJth/Y9nyaOYXPHk1KmsUf0My9ecWoE9GUvgHcBDx3YkP7QfRMmvebxkyShwAPBM4bdS4LXZItaWbO+A3gGVX1y8H9VXUp8BPu/P7Zon3s+2cIZjtH0zxnd+Bx+B4apce1Xy9jTD+HFtKwjQ/SXKH56SR/B9yXZo7nv3eO59FL8v9oLhY8n+avyOe3t5c73nk02l9AB7YP7w2sSDIx1+kXqmp1kr8F/jLJKu6YnH4L7rwoh+bBbOcHeDLNv6BPAa6m6Yl5C82/po8farKL0z/RnJ9X0MyeccDAvu9W1Rqaz6B/befj/jrwxzSF3AuGm+qiNeM5ovlD8100BfYVwJ7Am4CNeM3AUCT5Is0Cdz+imVXjccBrgE9U1SXtMWP3ObRgFkmBZnlumkHmj6EZT/YR4MgprtLUkCV5J01P8x40A/0vAI6uqo+PNLFFrL2A5rJpdu9TVZcnCc3KWy+jWQnqXJo/eL47lCQXsdnOD83cp0cBD6MZ/3c98EXgzVV19RBSXNTagni6aQH3mZipIcmfAm+g+d33I+B1VXXmMHJc7GY7R8A64MPAI2h+v90MnAX8RVU5NG0Ikvw18Cyaa5/W01z/dBzwwYnxzOP4ObSgimdJkiRpPi2kMc+SJEnSvLJ4liRJkjqyeJYkSZI6sniWJEmSOrJ4liRJkjqyeJYkSZI6sniWtKCkcVmSSjJ5Sdcuz98tyZHtPMuD25/UxnxIX7kOxH59kidNsb2SHNF3e7PksnuSo5NckmRNklVJTk3yuwPHHJ/k3GHm1Zf5PI+SFgeLZ0kLzWNoJtwHOORuPH834K0DMSZ8p419yd1NbAavB540xfbH0Kx+NhRJHkiz8tpBwP8Bnga8CLgc+FyShw8rF0kaVwtpeW5JAjgUuBX4YXv/b/oIWlU3Af/ZR6w5tDnU9oD/C/wKeGz7eiecnOQYmpVbJWlRs+dZ0oKRZAnwXOBzwL8A+yV52BTH7ZXk35Jcl2R1kvOTvKAdqvGD9rCvtP/er/Y5d/p3f5Kzk3xyitj/J8mV7ZKyJPnbJD9IckuSq5L83yT3GDj+cpolZ9860d7EEI6phm0kOSLJxe2QirAMZ6AAAAYBSURBVJ8medWk/Ue2r+sRSf6zfX3fTfL4Wb53TwAeBbxpUuEMQFWdX1VXTnrO77Tfu1uTnJPkwZP2vybJt5PcmOQXSU6ePJQmyVlJTmq//z9NclM7TOQ+A8fs3X4vnpfkQ228q5K8LckWk+I9JMnnk9zc3j41+P2WpE1l8SxpIXkKsDtwInASsI6m9/nXkuwG/AfwaOC1wDOBfwb2AK4B/rA99M9phk08Zpq2TgR+L8m2A7FDU7x/sqqq3bwb8E6aoRCvBO4LfLkt9AGeBdzY5jDR3nemajDJnwLvp/nj4Jk0Qzrem+SNkw7dBvgo8CHgD4A1wGeSbDPNawF4IrABOGOGYwbtCbwHeAfN93g34JMTfzS07gN8ADgY+FNgCfD1JDtMivVbwBHAa4DDgUcCx07R5ruBW4DnAP8K/FV7H4C2MP86sBz4I+DFwINpes4zOZgk3R0O25C0kBxKM7Tgi1W1NsnpwCFJ3jxQzL4K2AF4VFVd0247cyJAkvPbuxfMMmziJJpC9pk0hTTAATRF5cRjquqwgdhLaAr3q4DHAV+tqu8mWQ9cNVN7bQ/rkcDxVfWadvOX2kL0TUmOrqrb2+1bA6+sqi+3z72GZizzE4AvTtPEvYFrq+q2GV7zoJ2Ax1XVxQP5fQZ4IHBh+9p/3SvevvbTgV/SFNMfG4i1Ajioqla1x94DOCrJ1pPy+erAaz89ydOBZwMT/wF4K/Bz4BlVtbaNdX6bz4HA5zu+Nkmalj3PkhaEJMtoenE/M1E4Af9Gc+HfAQOHPoWmuL6GTVBV1wJfBp4/sPn5wCVV9euZKJI8I8k3ktwIrKcpnAEeMMcm7wPci7teQPgJmuLzoQPb1gFnDTy+YCDGTGqW/YMunyicp2sjyQFJTk9yPc1rXw1sx11f+7cnCudJse496bgvTXp8AXd+Tb9NU8BvTLJlki2By2gueNy/06uSpFlYPEtaKJ4B7Ah8IcmOSXakKSDXcOehGzvTDM/ow4nAM5KsaHten0tTzAKQ5NE0QyyuohlG8BjuKOSXz7Gte7ZffzFp+8TjnQa23VRVGyceDPwxMVObPwN2TdI1r8kXD96pjSR70hS7AV5C09P+aJqe58ltzBhrluMGj9kFeAPNHw+Dt/vSDMuRpE3msA1JC8VEgTzV1G7PS/KqqtoAXM8dheim+gxwDM0whCtoeoY/MbD/WcC1wPMnho0k2etutjVR8O82afvu7ddf3c24E84C3g48lX6GNzydZuz1wVV1K0DbE7zTjM/aNL+iOScfmWLfdfPYrqRFxOJZ0mYvyXbA79EM05h8odkjgL8HnkxzMdyZwMuT7F5Vk3txYfpez7uoqlVJvkQzXOMK4MdVdf7AIVsD6wbGW8MdFyRObnO29q4Crqbp3T51YPvzgJu4Y5aQu6WqvpbkPOCdSb5aVTcP7k/yUOCGqvqvjiG3BjbSDNcYzHU+P3fOBB4CnDfpey5JvbF4lrQQHEzTy/m+qvrm4I4kXwf+gqZn+gzgKJqFP76W5B3AfwEPAratqncDVwK3AX/cjlNeNziGeQqfoJkW70aamSUGnQ68MsnRwMnAY4EXThHjQuCgJF+kmU3iosnFa1VtTHIk8KF2DPHpNDNkvAx488DFgpviD4GvAOcmOYpmTPEK4HdpZsv4LZrvVxdfppld47gk/0wz68Vrmd+5oo8EvgV8Psm/0PQ23xv4HZoLLc+ax7YlLRKOeZa0EBwKXDy5cAaoqnU0szE8O8my9kK/x9HMPnE0cArN9GhXtsffTlMoPgo4G/j2LG1/lqZ3dRcGZtloY32BZgzuH9CMfX4iTQ/5ZK+jWdjl8217j5qqoar6MPBymuEgp7Sv+zVV9bez5NhJVV1EM03cF2lWPTwd+DjNBX4vqKrvzyHWD4A/oSm4TwFeQNNrfmMfuU7T5k9oxpSvpvkPxKnA22jGvf90vtqVtLjE/2xJkiRJ3djzLEmSJHVk8SxJkiR1ZPEsSZIkdWTxLEmSJHVk8SxJkiR1ZPEsSZIkdWTxLEmSJHVk8SxJkiR1ZPEsSZIkdfT/ARnozWk//QeRAAAAAElFTkSuQmCC\n",
      "text/plain": [
       "<Figure size 864x432 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 864x432 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "for name in cooler_feature_maps:\n",
    "    plt.title(name)\n",
    "    plt.imshow(cooler_feature_maps[name])\n",
    "    plt.ylabel(\"Digit Input\")\n",
    "    plt.xlabel(\"Activation Channel\")\n",
    "    plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Categoricals --> Embeddings"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "notes"
    }
   },
   "source": [
    "But Really we are making the problem too hard on ourselves, Encoding a categorical variable as a scalar variable just because it happens to be an integer is really bad form. The proper way to deal with that input is to put it through an embedding layer. This is more or less equivalent to onehot encoding it and then putting the one hot encoded vector through one dense layer. But it is much much more efficient."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [],
   "source": [
    "embedding_model = build_network(\n",
    "    [32,],\n",
    "    n_classes=n_classes,\n",
    "    vocabulary_size=n_classes,\n",
    "    embedding_dimension=32,\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 1/20\n",
      "32/32 [==============================] - 0s 6ms/step - loss: 2.1738 - accuracy: 0.4710 - val_loss: 2.0211 - val_accuracy: 0.4720\n",
      "Epoch 2/20\n",
      "32/32 [==============================] - 0s 4ms/step - loss: 1.8077 - accuracy: 0.6280 - val_loss: 1.4943 - val_accuracy: 0.8120\n",
      "Epoch 3/20\n",
      "32/32 [==============================] - 0s 4ms/step - loss: 1.1978 - accuracy: 0.9070 - val_loss: 0.8669 - val_accuracy: 0.9300\n",
      "Epoch 4/20\n",
      "32/32 [==============================] - 0s 4ms/step - loss: 0.6900 - accuracy: 0.9530 - val_loss: 0.4789 - val_accuracy: 0.9860\n",
      "Epoch 5/20\n",
      "32/32 [==============================] - 0s 4ms/step - loss: 0.3819 - accuracy: 0.9750 - val_loss: 0.2572 - val_accuracy: 0.9860\n",
      "Epoch 6/20\n",
      "32/32 [==============================] - 0s 4ms/step - loss: 0.2228 - accuracy: 0.9800 - val_loss: 0.1585 - val_accuracy: 0.9880\n",
      "Epoch 7/20\n",
      "32/32 [==============================] - 0s 4ms/step - loss: 0.1513 - accuracy: 0.9810 - val_loss: 0.1093 - val_accuracy: 0.9880\n",
      "Epoch 8/20\n",
      "32/32 [==============================] - 0s 4ms/step - loss: 0.1105 - accuracy: 0.9810 - val_loss: 0.0768 - val_accuracy: 0.9880\n",
      "Epoch 9/20\n",
      "32/32 [==============================] - 0s 4ms/step - loss: 0.0835 - accuracy: 0.9810 - val_loss: 0.0566 - val_accuracy: 0.9880\n",
      "Epoch 10/20\n",
      "32/32 [==============================] - 0s 5ms/step - loss: 0.0664 - accuracy: 0.9840 - val_loss: 0.0437 - val_accuracy: 0.9950\n",
      "Epoch 11/20\n",
      "32/32 [==============================] - 0s 5ms/step - loss: 0.0546 - accuracy: 0.9920 - val_loss: 0.0353 - val_accuracy: 0.9950\n",
      "Epoch 12/20\n",
      "32/32 [==============================] - 0s 4ms/step - loss: 0.0454 - accuracy: 0.9920 - val_loss: 0.0292 - val_accuracy: 0.9950\n",
      "Epoch 13/20\n",
      "32/32 [==============================] - 0s 4ms/step - loss: 0.0382 - accuracy: 0.9920 - val_loss: 0.0246 - val_accuracy: 0.9950\n",
      "Epoch 14/20\n",
      "32/32 [==============================] - 0s 4ms/step - loss: 0.0320 - accuracy: 0.9940 - val_loss: 0.0205 - val_accuracy: 0.9970\n",
      "Epoch 15/20\n",
      "32/32 [==============================] - 0s 4ms/step - loss: 0.0270 - accuracy: 0.9950 - val_loss: 0.0177 - val_accuracy: 0.9970\n",
      "Epoch 16/20\n",
      "32/32 [==============================] - 0s 4ms/step - loss: 0.0236 - accuracy: 0.9970 - val_loss: 0.0154 - val_accuracy: 1.0000\n",
      "Epoch 17/20\n",
      "32/32 [==============================] - 0s 4ms/step - loss: 0.0208 - accuracy: 1.0000 - val_loss: 0.0137 - val_accuracy: 1.0000\n",
      "Epoch 18/20\n",
      "32/32 [==============================] - 0s 4ms/step - loss: 0.0185 - accuracy: 1.0000 - val_loss: 0.0123 - val_accuracy: 1.0000\n",
      "Epoch 19/20\n",
      "32/32 [==============================] - 0s 4ms/step - loss: 0.0162 - accuracy: 1.0000 - val_loss: 0.0107 - val_accuracy: 1.0000\n",
      "Epoch 20/20\n",
      "32/32 [==============================] - 0s 4ms/step - loss: 0.0143 - accuracy: 1.0000 - val_loss: 0.0094 - val_accuracy: 1.0000\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<tensorflow.python.keras.callbacks.History at 0x7f85a397cf10>"
      ]
     },
     "execution_count": 42,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "embedding_model.fit(\n",
    "    cooler_x_train,\n",
    "    cooler_y_train,\n",
    "    validation_data=(\n",
    "        cooler_x_test,\n",
    "        cooler_y_test,\n",
    "    ),\n",
    "    batch_size=32,\n",
    "    epochs=20,\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [],
   "source": [
    "embedding_activation_model = make_activation_model(embedding_model)\n",
    "embedding_feature_maps = embedding_activation_model.predict(np.arange(10)[:, np.newaxis])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 864x432 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 864x432 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 864x432 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 864x432 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "for name in embedding_feature_maps:\n",
    "    fmap = embedding_feature_maps[name]\n",
    "    if len(fmap.shape) != 2:\n",
    "        continue\n",
    "    plt.title(name)\n",
    "    plt.imshow(fmap)\n",
    "    plt.ylabel(\"Digit Input\")\n",
    "    plt.xlabel(\"Activation Channel\")\n",
    "    plt.show()"
   ]
  }
 ],
 "metadata": {
  "celltoolbar": "Slideshow",
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.6"
  },
  "nikola": {
   "author": "Tim Anderton",
   "category": "",
   "date": "2021-06-02",
   "description": "",
   "link": "",
   "slug": "deep-learning-101",
   "tags": "neural networks, meetup talks",
   "title": "Deep Learning 101",
   "type": "text"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}