Classifier.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Lesson 1 - What's your pet"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Welcome to lesson 1! For those of you who are using a Jupyter Notebook for the first time, you can learn about this useful tool in a tutorial we prepared specially for you; click `File`->`Open` now and click `00_notebook_tutorial.ipynb`. \n",
    "\n",
    "In this lesson we will build our first image classifier from scratch, and see if we can achieve world-class results. Let's dive in!\n",
    "\n",
    "Every notebook starts with the following three lines; they ensure that any edits to libraries you make are reloaded here automatically, and also that any charts or images displayed are shown in this notebook."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "%reload_ext autoreload\n",
    "%autoreload 2\n",
    "%matplotlib inline"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "from PIL.Image import open"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We import all the necessary packages. We are going to work with the [fastai V1 library](http://www.fast.ai/2018/10/02/fastai-ai/) which sits on top of [Pytorch 1.0](https://hackernoon.com/pytorch-1-0-468332ba5163). The fastai library provides many useful functions that enable us to quickly and easily build neural networks and train our models."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "from fastai.vision import *\n",
    "from fastai.metrics import error_rate\n",
    "from fastai.vision.transform import *\n",
    "import posixpath"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If you're using a computer with an unusually small GPU, you may get an out of memory error when running this notebook. If this happens, click Kernel->Restart, uncomment the 2nd line below to use a smaller *batch size* (you'll learn all about what this means during the course), and try again."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "bs = 2056\n",
    "# bs = 16   # uncomment this line if you run out of memory even after clicking Kernel->Restart"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Looking at the data"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We are going to use the [Oxford-IIIT Pet Dataset](http://www.robots.ox.ac.uk/~vgg/data/pets/) by [O. M. Parkhi et al., 2012](http://www.robots.ox.ac.uk/~vgg/publications/2012/parkhi12a/parkhi12a.pdf) which features 12 cat breeds and 25 dogs breeds. Our model will need to learn to differentiate between these 37 distinct categories. According to their paper, the best accuracy they could get in 2012 was 59.21%, using a complex model that was specific to pet detection, with separate \"Image\", \"Head\", and \"Body\" models for the pet photos. Let's see how accurate we can be using deep learning!\n",
    "\n",
    "We are going to use the `untar_data` function to which we must pass a URL as an argument and which will download and extract the data."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Help on function untar_data in module fastai.datasets:\n",
      "\n",
      "untar_data(url:str, fname:Union[pathlib.Path, str]=None, dest:Union[pathlib.Path, str]=None, data=True, force_download=False) -> pathlib.Path\n",
      "    Download `url` to `fname` if it doesn't exist, and un-tgz to folder `dest`.\n",
      "\n"
     ]
    }
   ],
   "source": [
    "help(untar_data)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "PosixPath('/home/ubuntu/.fastai/data/oxford-iiit-pet')"
      ]
     },
     "execution_count": null,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[PosixPath('/home/ubuntu/.fastai/data/oxford-iiit-pet/images'),\n",
       " PosixPath('/home/ubuntu/.fastai/data/oxford-iiit-pet/annotations')]"
      ]
     },
     "execution_count": null,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The first thing we do when we approach a problem is to take a look at the data. We _always_ need to understand very well what the problem is and what the data looks like before we can figure out how to solve it. Taking a look at the data means understanding how the data directories are structured, what the labels are and what some sample images look like.\n",
    "\n",
    "The main difference between the handling of image classification datasets is the way labels are stored. In this particular dataset, labels are stored in the filenames themselves. We will need to extract them to be able to classify the images into the correct categories. Fortunately, the fastai library has a handy function made exactly for this, `ImageDataBunch.from_name_re` gets the labels from the filenames using a [regular expression](https://docs.python.org/3.6/library/re.html)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[PosixPath('/home/ubuntu/.fastai/data/oxford-iiit-pet/images/saint_bernard_188.jpg'),\n",
       " PosixPath('/home/ubuntu/.fastai/data/oxford-iiit-pet/images/staffordshire_bull_terrier_114.jpg'),\n",
       " PosixPath('/home/ubuntu/.fastai/data/oxford-iiit-pet/images/Persian_144.jpg'),\n",
       " PosixPath('/home/ubuntu/.fastai/data/oxford-iiit-pet/images/Maine_Coon_268.jpg'),\n",
       " PosixPath('/home/ubuntu/.fastai/data/oxford-iiit-pet/images/newfoundland_95.jpg')]"
      ]
     },
     "execution_count": null,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "data = ImageDataBunch.from_folder(\"./Pictures/\", size=7, bs=bs).normalize(imagenet_stats)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 504x432 with 9 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "data.show_batch(rows=3, figsize=(7,6))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['0', '1']\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "(2, 2)"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "data."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Training: resnet34"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now we will start training our model. We will use a [convolutional neural network](http://cs231n.github.io/convolutional-networks/) backbone and a fully connected head with a single hidden layer as a classifier. Don't know what these things mean? Not to worry, we will dive deeper in the coming lessons. For the moment you need to know that we are building a model which will take images as input and will output the predicted probability for each of the categories (in this case, it will have 37 outputs).\n",
    "\n",
    "We will train for 4 epochs (4 cycles through all our data)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "learn = create_cnn(data, models.resnet34, metrics=error_rate)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Sequential(\n",
       "  (0): Sequential(\n",
       "    (0): Conv2d(3, 64, kernel_size=(7, 7), stride=(2, 2), padding=(3, 3), bias=False)\n",
       "    (1): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "    (2): ReLU(inplace)\n",
       "    (3): MaxPool2d(kernel_size=3, stride=2, padding=1, dilation=1, ceil_mode=False)\n",
       "    (4): Sequential(\n",
       "      (0): BasicBlock(\n",
       "        (conv1): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
       "        (bn1): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "        (relu): ReLU(inplace)\n",
       "        (conv2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
       "        (bn2): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "      )\n",
       "      (1): BasicBlock(\n",
       "        (conv1): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
       "        (bn1): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "        (relu): ReLU(inplace)\n",
       "        (conv2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
       "        (bn2): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "      )\n",
       "      (2): BasicBlock(\n",
       "        (conv1): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
       "        (bn1): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "        (relu): ReLU(inplace)\n",
       "        (conv2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
       "        (bn2): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "      )\n",
       "    )\n",
       "    (5): Sequential(\n",
       "      (0): BasicBlock(\n",
       "        (conv1): Conv2d(64, 128, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1), bias=False)\n",
       "        (bn1): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "        (relu): ReLU(inplace)\n",
       "        (conv2): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
       "        (bn2): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "        (downsample): Sequential(\n",
       "          (0): Conv2d(64, 128, kernel_size=(1, 1), stride=(2, 2), bias=False)\n",
       "          (1): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "        )\n",
       "      )\n",
       "      (1): BasicBlock(\n",
       "        (conv1): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
       "        (bn1): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "        (relu): ReLU(inplace)\n",
       "        (conv2): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
       "        (bn2): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "      )\n",
       "      (2): BasicBlock(\n",
       "        (conv1): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
       "        (bn1): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "        (relu): ReLU(inplace)\n",
       "        (conv2): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
       "        (bn2): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "      )\n",
       "      (3): BasicBlock(\n",
       "        (conv1): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
       "        (bn1): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "        (relu): ReLU(inplace)\n",
       "        (conv2): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
       "        (bn2): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "      )\n",
       "    )\n",
       "    (6): Sequential(\n",
       "      (0): BasicBlock(\n",
       "        (conv1): Conv2d(128, 256, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1), bias=False)\n",
       "        (bn1): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "        (relu): ReLU(inplace)\n",
       "        (conv2): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
       "        (bn2): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "        (downsample): Sequential(\n",
       "          (0): Conv2d(128, 256, kernel_size=(1, 1), stride=(2, 2), bias=False)\n",
       "          (1): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "        )\n",
       "      )\n",
       "      (1): BasicBlock(\n",
       "        (conv1): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
       "        (bn1): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "        (relu): ReLU(inplace)\n",
       "        (conv2): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
       "        (bn2): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "      )\n",
       "      (2): BasicBlock(\n",
       "        (conv1): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
       "        (bn1): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "        (relu): ReLU(inplace)\n",
       "        (conv2): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
       "        (bn2): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "      )\n",
       "      (3): BasicBlock(\n",
       "        (conv1): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
       "        (bn1): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "        (relu): ReLU(inplace)\n",
       "        (conv2): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
       "        (bn2): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "      )\n",
       "      (4): BasicBlock(\n",
       "        (conv1): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
       "        (bn1): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "        (relu): ReLU(inplace)\n",
       "        (conv2): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
       "        (bn2): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "      )\n",
       "      (5): BasicBlock(\n",
       "        (conv1): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
       "        (bn1): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "        (relu): ReLU(inplace)\n",
       "        (conv2): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
       "        (bn2): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "      )\n",
       "    )\n",
       "    (7): Sequential(\n",
       "      (0): BasicBlock(\n",
       "        (conv1): Conv2d(256, 512, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1), bias=False)\n",
       "        (bn1): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "        (relu): ReLU(inplace)\n",
       "        (conv2): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
       "        (bn2): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "        (downsample): Sequential(\n",
       "          (0): Conv2d(256, 512, kernel_size=(1, 1), stride=(2, 2), bias=False)\n",
       "          (1): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "        )\n",
       "      )\n",
       "      (1): BasicBlock(\n",
       "        (conv1): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
       "        (bn1): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "        (relu): ReLU(inplace)\n",
       "        (conv2): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
       "        (bn2): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "      )\n",
       "      (2): BasicBlock(\n",
       "        (conv1): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
       "        (bn1): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "        (relu): ReLU(inplace)\n",
       "        (conv2): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
       "        (bn2): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "      )\n",
       "    )\n",
       "  )\n",
       "  (1): Sequential(\n",
       "    (0): AdaptiveConcatPool2d(\n",
       "      (ap): AdaptiveAvgPool2d(output_size=1)\n",
       "      (mp): AdaptiveMaxPool2d(output_size=1)\n",
       "    )\n",
       "    (1): Flatten()\n",
       "    (2): BatchNorm1d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "    (3): Dropout(p=0.25)\n",
       "    (4): Linear(in_features=1024, out_features=512, bias=True)\n",
       "    (5): ReLU(inplace)\n",
       "    (6): BatchNorm1d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "    (7): Dropout(p=0.5)\n",
       "    (8): Linear(in_features=512, out_features=2, bias=True)\n",
       "  )\n",
       ")"
      ]
     },
     "execution_count": 41,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "learn.model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "learn.lr_find()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "learn.recorder.plot()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "Total time: 05:24 <p><table style='width:300px; margin-bottom:10px'>\n",
       "  <tr>\n",
       "    <th>epoch</th>\n",
       "    <th>train_loss</th>\n",
       "    <th>valid_loss</th>\n",
       "    <th>error_rate</th>\n",
       "  </tr>\n",
       "  <tr>\n",
       "    <th>1</th>\n",
       "    <th>0.355793</th>\n",
       "    <th>0.200532</th>\n",
       "    <th>0.077414</th>\n",
       "  </tr>\n",
       "  <tr>\n",
       "    <th>2</th>\n",
       "    <th>0.265655</th>\n",
       "    <th>0.187706</th>\n",
       "    <th>0.073600</th>\n",
       "  </tr>\n",
       "  <tr>\n",
       "    <th>3</th>\n",
       "    <th>0.239036</th>\n",
       "    <th>0.184935</th>\n",
       "    <th>0.069495</th>\n",
       "  </tr>\n",
       "  <tr>\n",
       "    <th>4</th>\n",
       "    <th>0.228236</th>\n",
       "    <th>0.183978</th>\n",
       "    <th>0.069329</th>\n",
       "  </tr>\n",
       "</table>\n"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "learn.fit_one_cycle(4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [],
   "source": [
    "learn.save('stage-1')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Results"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's see what results we have got. \n",
    "\n",
    "We will first see which were the categories that the model most confused with one another. We will try to see if what the model predicted was reasonable or not. In this case the mistakes look reasonable (none of the mistakes seems obviously naive). This is an indicator that our classifier is working correctly. \n",
    "\n",
    "Furthermore, when we plot the confusion matrix, we can see that the distribution is heavily skewed: the model makes the same mistakes over and over again but it rarely confuses other categories. This suggests that it just finds it difficult to distinguish some specific categories between each other; this is normal behaviour."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "interp = ClassificationInterpretation.from_learner(learn)\n",
    "\n",
    "losses,idxs = interp.top_losses()\n",
    "\n",
    "len(data.valid_ds)==len(losses)==len(idxs)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 157,
   "metadata": {},
   "outputs": [],
   "source": [
    "img = learn.data.train_ds[0][0]\n",
    "predictions = [learn.predict(img)[2][1].numpy().item() for img in learn.data.train_ds.x[:30000]]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 160,
   "metadata": {},
   "outputs": [],
   "source": [
    "paths = [int(posixpath.basename(posixpath.splitext(item)[0])) for item in data.train_ds.items]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 161,
   "metadata": {},
   "outputs": [],
   "source": [
    "dfPredict = pd.DataFrame({\"real\":data.train_ds.y.items[:30000],\"nnLabel\":predictions[:30000],\"path\":paths[:30000]})"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 162,
   "metadata": {},
   "outputs": [],
   "source": [
    "dfPredict.set_index(\"path\",inplace=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 163,
   "metadata": {},
   "outputs": [],
   "source": [
    "def bandSwitch(window):\n",
    "    if window[-1]>0.95:\n",
    "        return 1\n",
    "    elif window[-1]<0.05:\n",
    "        return 0\n",
    "    else: \n",
    "        return float('NaN')\n",
    "        "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 164,
   "metadata": {},
   "outputs": [],
   "source": [
    "dfPredict.sort_index(inplace=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 153,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Rolling [window=2,center=False,axis=0]"
      ]
     },
     "execution_count": 153,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dfPredict['nnLabel'].rolling(2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 165,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/opt/conda/envs/fastai/lib/python3.6/site-packages/ipykernel_launcher.py:1: FutureWarning: Currently, 'apply' passes the values as ndarrays to the applied function. In the future, this will change to passing it as Series objects. You need to specify 'raw=True' to keep the current behaviour, and you can pass 'raw=False' to silence this warning\n",
      "  \"\"\"Entry point for launching an IPython kernel.\n"
     ]
    }
   ],
   "source": [
    "dfPredict['Filtered'] = dfPredict['nnLabel'].rolling(2).mean().rolling(2).apply(bandSwitch)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 166,
   "metadata": {},
   "outputs": [],
   "source": [
    "dfPredict= dfPredict.fillna(method='ffill').fillna(method='bfill')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 167,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/javascript": [
       "/* Put everything inside the global mpl namespace */\n",
       "window.mpl = {};\n",
       "\n",
       "\n",
       "mpl.get_websocket_type = function() {\n",
       "    if (typeof(WebSocket) !== 'undefined') {\n",
       "        return WebSocket;\n",
       "    } else if (typeof(MozWebSocket) !== 'undefined') {\n",
       "        return MozWebSocket;\n",
       "    } else {\n",
       "        alert('Your browser does not have WebSocket support.' +\n",
       "              'Please try Chrome, Safari or Firefox ≥ 6. ' +\n",
       "              'Firefox 4 and 5 are also supported but you ' +\n",
       "              'have to enable WebSockets in about:config.');\n",
       "    };\n",
       "}\n",
       "\n",
       "mpl.figure = function(figure_id, websocket, ondownload, parent_element) {\n",
       "    this.id = figure_id;\n",
       "\n",
       "    this.ws = websocket;\n",
       "\n",
       "    this.supports_binary = (this.ws.binaryType != undefined);\n",
       "\n",
       "    if (!this.supports_binary) {\n",
       "        var warnings = document.getElementById(\"mpl-warnings\");\n",
       "        if (warnings) {\n",
       "            warnings.style.display = 'block';\n",
       "            warnings.textContent = (\n",
       "                \"This browser does not support binary websocket messages. \" +\n",
       "                    \"Performance may be slow.\");\n",
       "        }\n",
       "    }\n",
       "\n",
       "    this.imageObj = new Image();\n",
       "\n",
       "    this.context = undefined;\n",
       "    this.message = undefined;\n",
       "    this.canvas = undefined;\n",
       "    this.rubberband_canvas = undefined;\n",
       "    this.rubberband_context = undefined;\n",
       "    this.format_dropdown = undefined;\n",
       "\n",
       "    this.image_mode = 'full';\n",
       "\n",
       "    this.root = $('<div/>');\n",
       "    this._root_extra_style(this.root)\n",
       "    this.root.attr('style', 'display: inline-block');\n",
       "\n",
       "    $(parent_element).append(this.root);\n",
       "\n",
       "    this._init_header(this);\n",
       "    this._init_canvas(this);\n",
       "    this._init_toolbar(this);\n",
       "\n",
       "    var fig = this;\n",
       "\n",
       "    this.waiting = false;\n",
       "\n",
       "    this.ws.onopen =  function () {\n",
       "            fig.send_message(\"supports_binary\", {value: fig.supports_binary});\n",
       "            fig.send_message(\"send_image_mode\", {});\n",
       "            if (mpl.ratio != 1) {\n",
       "                fig.send_message(\"set_dpi_ratio\", {'dpi_ratio': mpl.ratio});\n",
       "            }\n",
       "            fig.send_message(\"refresh\", {});\n",
       "        }\n",
       "\n",
       "    this.imageObj.onload = function() {\n",
       "            if (fig.image_mode == 'full') {\n",
       "                // Full images could contain transparency (where diff images\n",
       "                // almost always do), so we need to clear the canvas so that\n",
       "                // there is no ghosting.\n",
       "                fig.context.clearRect(0, 0, fig.canvas.width, fig.canvas.height);\n",
       "            }\n",
       "            fig.context.drawImage(fig.imageObj, 0, 0);\n",
       "        };\n",
       "\n",
       "    this.imageObj.onunload = function() {\n",
       "        fig.ws.close();\n",
       "    }\n",
       "\n",
       "    this.ws.onmessage = this._make_on_message_function(this);\n",
       "\n",
       "    this.ondownload = ondownload;\n",
       "}\n",
       "\n",
       "mpl.figure.prototype._init_header = function() {\n",
       "    var titlebar = $(\n",
       "        '<div class=\"ui-dialog-titlebar ui-widget-header ui-corner-all ' +\n",
       "        'ui-helper-clearfix\"/>');\n",
       "    var titletext = $(\n",
       "        '<div class=\"ui-dialog-title\" style=\"width: 100%; ' +\n",
       "        'text-align: center; padding: 3px;\"/>');\n",
       "    titlebar.append(titletext)\n",
       "    this.root.append(titlebar);\n",
       "    this.header = titletext[0];\n",
       "}\n",
       "\n",
       "\n",
       "\n",
       "mpl.figure.prototype._canvas_extra_style = function(canvas_div) {\n",
       "\n",
       "}\n",
       "\n",
       "\n",
       "mpl.figure.prototype._root_extra_style = function(canvas_div) {\n",
       "\n",
       "}\n",
       "\n",
       "mpl.figure.prototype._init_canvas = function() {\n",
       "    var fig = this;\n",
       "\n",
       "    var canvas_div = $('<div/>');\n",
       "\n",
       "    canvas_div.attr('style', 'position: relative; clear: both; outline: 0');\n",
       "\n",
       "    function canvas_keyboard_event(event) {\n",
       "        return fig.key_event(event, event['data']);\n",
       "    }\n",
       "\n",
       "    canvas_div.keydown('key_press', canvas_keyboard_event);\n",
       "    canvas_div.keyup('key_release', canvas_keyboard_event);\n",
       "    this.canvas_div = canvas_div\n",
       "    this._canvas_extra_style(canvas_div)\n",
       "    this.root.append(canvas_div);\n",
       "\n",
       "    var canvas = $('<canvas/>');\n",
       "    canvas.addClass('mpl-canvas');\n",
       "    canvas.attr('style', \"left: 0; top: 0; z-index: 0; outline: 0\")\n",
       "\n",
       "    this.canvas = canvas[0];\n",
       "    this.context = canvas[0].getContext(\"2d\");\n",
       "\n",
       "    var backingStore = this.context.backingStorePixelRatio ||\n",
       "\tthis.context.webkitBackingStorePixelRatio ||\n",
       "\tthis.context.mozBackingStorePixelRatio ||\n",
       "\tthis.context.msBackingStorePixelRatio ||\n",
       "\tthis.context.oBackingStorePixelRatio ||\n",
       "\tthis.context.backingStorePixelRatio || 1;\n",
       "\n",
       "    mpl.ratio = (window.devicePixelRatio || 1) / backingStore;\n",
       "\n",
       "    var rubberband = $('<canvas/>');\n",
       "    rubberband.attr('style', \"position: absolute; left: 0; top: 0; z-index: 1;\")\n",
       "\n",
       "    var pass_mouse_events = true;\n",
       "\n",
       "    canvas_div.resizable({\n",
       "        start: function(event, ui) {\n",
       "            pass_mouse_events = false;\n",
       "        },\n",
       "        resize: function(event, ui) {\n",
       "            fig.request_resize(ui.size.width, ui.size.height);\n",
       "        },\n",
       "        stop: function(event, ui) {\n",
       "            pass_mouse_events = true;\n",
       "            fig.request_resize(ui.size.width, ui.size.height);\n",
       "        },\n",
       "    });\n",
       "\n",
       "    function mouse_event_fn(event) {\n",
       "        if (pass_mouse_events)\n",
       "            return fig.mouse_event(event, event['data']);\n",
       "    }\n",
       "\n",
       "    rubberband.mousedown('button_press', mouse_event_fn);\n",
       "    rubberband.mouseup('button_release', mouse_event_fn);\n",
       "    // Throttle sequential mouse events to 1 every 20ms.\n",
       "    rubberband.mousemove('motion_notify', mouse_event_fn);\n",
       "\n",
       "    rubberband.mouseenter('figure_enter', mouse_event_fn);\n",
       "    rubberband.mouseleave('figure_leave', mouse_event_fn);\n",
       "\n",
       "    canvas_div.on(\"wheel\", function (event) {\n",
       "        event = event.originalEvent;\n",
       "        event['data'] = 'scroll'\n",
       "        if (event.deltaY < 0) {\n",
       "            event.step = 1;\n",
       "        } else {\n",
       "            event.step = -1;\n",
       "        }\n",
       "        mouse_event_fn(event);\n",
       "    });\n",
       "\n",
       "    canvas_div.append(canvas);\n",
       "    canvas_div.append(rubberband);\n",
       "\n",
       "    this.rubberband = rubberband;\n",
       "    this.rubberband_canvas = rubberband[0];\n",
       "    this.rubberband_context = rubberband[0].getContext(\"2d\");\n",
       "    this.rubberband_context.strokeStyle = \"#000000\";\n",
       "\n",
       "    this._resize_canvas = function(width, height) {\n",
       "        // Keep the size of the canvas, canvas container, and rubber band\n",
       "        // canvas in synch.\n",
       "        canvas_div.css('width', width)\n",
       "        canvas_div.css('height', height)\n",
       "\n",
       "        canvas.attr('width', width * mpl.ratio);\n",
       "        canvas.attr('height', height * mpl.ratio);\n",
       "        canvas.attr('style', 'width: ' + width + 'px; height: ' + height + 'px;');\n",
       "\n",
       "        rubberband.attr('width', width);\n",
       "        rubberband.attr('height', height);\n",
       "    }\n",
       "\n",
       "    // Set the figure to an initial 600x600px, this will subsequently be updated\n",
       "    // upon first draw.\n",
       "    this._resize_canvas(600, 600);\n",
       "\n",
       "    // Disable right mouse context menu.\n",
       "    $(this.rubberband_canvas).bind(\"contextmenu\",function(e){\n",
       "        return false;\n",
       "    });\n",
       "\n",
       "    function set_focus () {\n",
       "        canvas.focus();\n",
       "        canvas_div.focus();\n",
       "    }\n",
       "\n",
       "    window.setTimeout(set_focus, 100);\n",
       "}\n",
       "\n",
       "mpl.figure.prototype._init_toolbar = function() {\n",
       "    var fig = this;\n",
       "\n",
       "    var nav_element = $('<div/>')\n",
       "    nav_element.attr('style', 'width: 100%');\n",
       "    this.root.append(nav_element);\n",
       "\n",
       "    // Define a callback function for later on.\n",
       "    function toolbar_event(event) {\n",
       "        return fig.toolbar_button_onclick(event['data']);\n",
       "    }\n",
       "    function toolbar_mouse_event(event) {\n",
       "        return fig.toolbar_button_onmouseover(event['data']);\n",
       "    }\n",
       "\n",
       "    for(var toolbar_ind in mpl.toolbar_items) {\n",
       "        var name = mpl.toolbar_items[toolbar_ind][0];\n",
       "        var tooltip = mpl.toolbar_items[toolbar_ind][1];\n",
       "        var image = mpl.toolbar_items[toolbar_ind][2];\n",
       "        var method_name = mpl.toolbar_items[toolbar_ind][3];\n",
       "\n",
       "        if (!name) {\n",
       "            // put a spacer in here.\n",
       "            continue;\n",
       "        }\n",
       "        var button = $('<button/>');\n",
       "        button.addClass('ui-button ui-widget ui-state-default ui-corner-all ' +\n",
       "                        'ui-button-icon-only');\n",
       "        button.attr('role', 'button');\n",
       "        button.attr('aria-disabled', 'false');\n",
       "        button.click(method_name, toolbar_event);\n",
       "        button.mouseover(tooltip, toolbar_mouse_event);\n",
       "\n",
       "        var icon_img = $('<span/>');\n",
       "        icon_img.addClass('ui-button-icon-primary ui-icon');\n",
       "        icon_img.addClass(image);\n",
       "        icon_img.addClass('ui-corner-all');\n",
       "\n",
       "        var tooltip_span = $('<span/>');\n",
       "        tooltip_span.addClass('ui-button-text');\n",
       "        tooltip_span.html(tooltip);\n",
       "\n",
       "        button.append(icon_img);\n",
       "        button.append(tooltip_span);\n",
       "\n",
       "        nav_element.append(button);\n",
       "    }\n",
       "\n",
       "    var fmt_picker_span = $('<span/>');\n",
       "\n",
       "    var fmt_picker = $('<select/>');\n",
       "    fmt_picker.addClass('mpl-toolbar-option ui-widget ui-widget-content');\n",
       "    fmt_picker_span.append(fmt_picker);\n",
       "    nav_element.append(fmt_picker_span);\n",
       "    this.format_dropdown = fmt_picker[0];\n",
       "\n",
       "    for (var ind in mpl.extensions) {\n",
       "        var fmt = mpl.extensions[ind];\n",
       "        var option = $(\n",
       "            '<option/>', {selected: fmt === mpl.default_extension}).html(fmt);\n",
       "        fmt_picker.append(option)\n",
       "    }\n",
       "\n",
       "    // Add hover states to the ui-buttons\n",
       "    $( \".ui-button\" ).hover(\n",
       "        function() { $(this).addClass(\"ui-state-hover\");},\n",
       "        function() { $(this).removeClass(\"ui-state-hover\");}\n",
       "    );\n",
       "\n",
       "    var status_bar = $('<span class=\"mpl-message\"/>');\n",
       "    nav_element.append(status_bar);\n",
       "    this.message = status_bar[0];\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.request_resize = function(x_pixels, y_pixels) {\n",
       "    // Request matplotlib to resize the figure. Matplotlib will then trigger a resize in the client,\n",
       "    // which will in turn request a refresh of the image.\n",
       "    this.send_message('resize', {'width': x_pixels, 'height': y_pixels});\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.send_message = function(type, properties) {\n",
       "    properties['type'] = type;\n",
       "    properties['figure_id'] = this.id;\n",
       "    this.ws.send(JSON.stringify(properties));\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.send_draw_message = function() {\n",
       "    if (!this.waiting) {\n",
       "        this.waiting = true;\n",
       "        this.ws.send(JSON.stringify({type: \"draw\", figure_id: this.id}));\n",
       "    }\n",
       "}\n",
       "\n",
       "\n",
       "mpl.figure.prototype.handle_save = function(fig, msg) {\n",
       "    var format_dropdown = fig.format_dropdown;\n",
       "    var format = format_dropdown.options[format_dropdown.selectedIndex].value;\n",
       "    fig.ondownload(fig, format);\n",
       "}\n",
       "\n",
       "\n",
       "mpl.figure.prototype.handle_resize = function(fig, msg) {\n",
       "    var size = msg['size'];\n",
       "    if (size[0] != fig.canvas.width || size[1] != fig.canvas.height) {\n",
       "        fig._resize_canvas(size[0], size[1]);\n",
       "        fig.send_message(\"refresh\", {});\n",
       "    };\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.handle_rubberband = function(fig, msg) {\n",
       "    var x0 = msg['x0'] / mpl.ratio;\n",
       "    var y0 = (fig.canvas.height - msg['y0']) / mpl.ratio;\n",
       "    var x1 = msg['x1'] / mpl.ratio;\n",
       "    var y1 = (fig.canvas.height - msg['y1']) / mpl.ratio;\n",
       "    x0 = Math.floor(x0) + 0.5;\n",
       "    y0 = Math.floor(y0) + 0.5;\n",
       "    x1 = Math.floor(x1) + 0.5;\n",
       "    y1 = Math.floor(y1) + 0.5;\n",
       "    var min_x = Math.min(x0, x1);\n",
       "    var min_y = Math.min(y0, y1);\n",
       "    var width = Math.abs(x1 - x0);\n",
       "    var height = Math.abs(y1 - y0);\n",
       "\n",
       "    fig.rubberband_context.clearRect(\n",
       "        0, 0, fig.canvas.width, fig.canvas.height);\n",
       "\n",
       "    fig.rubberband_context.strokeRect(min_x, min_y, width, height);\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.handle_figure_label = function(fig, msg) {\n",
       "    // Updates the figure title.\n",
       "    fig.header.textContent = msg['label'];\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.handle_cursor = function(fig, msg) {\n",
       "    var cursor = msg['cursor'];\n",
       "    switch(cursor)\n",
       "    {\n",
       "    case 0:\n",
       "        cursor = 'pointer';\n",
       "        break;\n",
       "    case 1:\n",
       "        cursor = 'default';\n",
       "        break;\n",
       "    case 2:\n",
       "        cursor = 'crosshair';\n",
       "        break;\n",
       "    case 3:\n",
       "        cursor = 'move';\n",
       "        break;\n",
       "    }\n",
       "    fig.rubberband_canvas.style.cursor = cursor;\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.handle_message = function(fig, msg) {\n",
       "    fig.message.textContent = msg['message'];\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.handle_draw = function(fig, msg) {\n",
       "    // Request the server to send over a new figure.\n",
       "    fig.send_draw_message();\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.handle_image_mode = function(fig, msg) {\n",
       "    fig.image_mode = msg['mode'];\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.updated_canvas_event = function() {\n",
       "    // Called whenever the canvas gets updated.\n",
       "    this.send_message(\"ack\", {});\n",
       "}\n",
       "\n",
       "// A function to construct a web socket function for onmessage handling.\n",
       "// Called in the figure constructor.\n",
       "mpl.figure.prototype._make_on_message_function = function(fig) {\n",
       "    return function socket_on_message(evt) {\n",
       "        if (evt.data instanceof Blob) {\n",
       "            /* FIXME: We get \"Resource interpreted as Image but\n",
       "             * transferred with MIME type text/plain:\" errors on\n",
       "             * Chrome.  But how to set the MIME type?  It doesn't seem\n",
       "             * to be part of the websocket stream */\n",
       "            evt.data.type = \"image/png\";\n",
       "\n",
       "            /* Free the memory for the previous frames */\n",
       "            if (fig.imageObj.src) {\n",
       "                (window.URL || window.webkitURL).revokeObjectURL(\n",
       "                    fig.imageObj.src);\n",
       "            }\n",
       "\n",
       "            fig.imageObj.src = (window.URL || window.webkitURL).createObjectURL(\n",
       "                evt.data);\n",
       "            fig.updated_canvas_event();\n",
       "            fig.waiting = false;\n",
       "            return;\n",
       "        }\n",
       "        else if (typeof evt.data === 'string' && evt.data.slice(0, 21) == \"data:image/png;base64\") {\n",
       "            fig.imageObj.src = evt.data;\n",
       "            fig.updated_canvas_event();\n",
       "            fig.waiting = false;\n",
       "            return;\n",
       "        }\n",
       "\n",
       "        var msg = JSON.parse(evt.data);\n",
       "        var msg_type = msg['type'];\n",
       "\n",
       "        // Call the  \"handle_{type}\" callback, which takes\n",
       "        // the figure and JSON message as its only arguments.\n",
       "        try {\n",
       "            var callback = fig[\"handle_\" + msg_type];\n",
       "        } catch (e) {\n",
       "            console.log(\"No handler for the '\" + msg_type + \"' message type: \", msg);\n",
       "            return;\n",
       "        }\n",
       "\n",
       "        if (callback) {\n",
       "            try {\n",
       "                // console.log(\"Handling '\" + msg_type + \"' message: \", msg);\n",
       "                callback(fig, msg);\n",
       "            } catch (e) {\n",
       "                console.log(\"Exception inside the 'handler_\" + msg_type + \"' callback:\", e, e.stack, msg);\n",
       "            }\n",
       "        }\n",
       "    };\n",
       "}\n",
       "\n",
       "// from http://stackoverflow.com/questions/1114465/getting-mouse-location-in-canvas\n",
       "mpl.findpos = function(e) {\n",
       "    //this section is from http://www.quirksmode.org/js/events_properties.html\n",
       "    var targ;\n",
       "    if (!e)\n",
       "        e = window.event;\n",
       "    if (e.target)\n",
       "        targ = e.target;\n",
       "    else if (e.srcElement)\n",
       "        targ = e.srcElement;\n",
       "    if (targ.nodeType == 3) // defeat Safari bug\n",
       "        targ = targ.parentNode;\n",
       "\n",
       "    // jQuery normalizes the pageX and pageY\n",
       "    // pageX,Y are the mouse positions relative to the document\n",
       "    // offset() returns the position of the element relative to the document\n",
       "    var x = e.pageX - $(targ).offset().left;\n",
       "    var y = e.pageY - $(targ).offset().top;\n",
       "\n",
       "    return {\"x\": x, \"y\": y};\n",
       "};\n",
       "\n",
       "/*\n",
       " * return a copy of an object with only non-object keys\n",
       " * we need this to avoid circular references\n",
       " * http://stackoverflow.com/a/24161582/3208463\n",
       " */\n",
       "function simpleKeys (original) {\n",
       "  return Object.keys(original).reduce(function (obj, key) {\n",
       "    if (typeof original[key] !== 'object')\n",
       "        obj[key] = original[key]\n",
       "    return obj;\n",
       "  }, {});\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.mouse_event = function(event, name) {\n",
       "    var canvas_pos = mpl.findpos(event)\n",
       "\n",
       "    if (name === 'button_press')\n",
       "    {\n",
       "        this.canvas.focus();\n",
       "        this.canvas_div.focus();\n",
       "    }\n",
       "\n",
       "    var x = canvas_pos.x * mpl.ratio;\n",
       "    var y = canvas_pos.y * mpl.ratio;\n",
       "\n",
       "    this.send_message(name, {x: x, y: y, button: event.button,\n",
       "                             step: event.step,\n",
       "                             guiEvent: simpleKeys(event)});\n",
       "\n",
       "    /* This prevents the web browser from automatically changing to\n",
       "     * the text insertion cursor when the button is pressed.  We want\n",
       "     * to control all of the cursor setting manually through the\n",
       "     * 'cursor' event from matplotlib */\n",
       "    event.preventDefault();\n",
       "    return false;\n",
       "}\n",
       "\n",
       "mpl.figure.prototype._key_event_extra = function(event, name) {\n",
       "    // Handle any extra behaviour associated with a key event\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.key_event = function(event, name) {\n",
       "\n",
       "    // Prevent repeat events\n",
       "    if (name == 'key_press')\n",
       "    {\n",
       "        if (event.which === this._key)\n",
       "            return;\n",
       "        else\n",
       "            this._key = event.which;\n",
       "    }\n",
       "    if (name == 'key_release')\n",
       "        this._key = null;\n",
       "\n",
       "    var value = '';\n",
       "    if (event.ctrlKey && event.which != 17)\n",
       "        value += \"ctrl+\";\n",
       "    if (event.altKey && event.which != 18)\n",
       "        value += \"alt+\";\n",
       "    if (event.shiftKey && event.which != 16)\n",
       "        value += \"shift+\";\n",
       "\n",
       "    value += 'k';\n",
       "    value += event.which.toString();\n",
       "\n",
       "    this._key_event_extra(event, name);\n",
       "\n",
       "    this.send_message(name, {key: value,\n",
       "                             guiEvent: simpleKeys(event)});\n",
       "    return false;\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.toolbar_button_onclick = function(name) {\n",
       "    if (name == 'download') {\n",
       "        this.handle_save(this, null);\n",
       "    } else {\n",
       "        this.send_message(\"toolbar_button\", {name: name});\n",
       "    }\n",
       "};\n",
       "\n",
       "mpl.figure.prototype.toolbar_button_onmouseover = function(tooltip) {\n",
       "    this.message.textContent = tooltip;\n",
       "};\n",
       "mpl.toolbar_items = [[\"Home\", \"Reset original view\", \"fa fa-home icon-home\", \"home\"], [\"Back\", \"Back to previous view\", \"fa fa-arrow-left icon-arrow-left\", \"back\"], [\"Forward\", \"Forward to next view\", \"fa fa-arrow-right icon-arrow-right\", \"forward\"], [\"\", \"\", \"\", \"\"], [\"Pan\", \"Pan axes with left mouse, zoom with right\", \"fa fa-arrows icon-move\", \"pan\"], [\"Zoom\", \"Zoom to rectangle\", \"fa fa-square-o icon-check-empty\", \"zoom\"], [\"\", \"\", \"\", \"\"], [\"Download\", \"Download plot\", \"fa fa-floppy-o icon-save\", \"download\"]];\n",
       "\n",
       "mpl.extensions = [\"eps\", \"jpeg\", \"pdf\", \"png\", \"ps\", \"raw\", \"svg\", \"tif\"];\n",
       "\n",
       "mpl.default_extension = \"png\";var comm_websocket_adapter = function(comm) {\n",
       "    // Create a \"websocket\"-like object which calls the given IPython comm\n",
       "    // object with the appropriate methods. Currently this is a non binary\n",
       "    // socket, so there is still some room for performance tuning.\n",
       "    var ws = {};\n",
       "\n",
       "    ws.close = function() {\n",
       "        comm.close()\n",
       "    };\n",
       "    ws.send = function(m) {\n",
       "        //console.log('sending', m);\n",
       "        comm.send(m);\n",
       "    };\n",
       "    // Register the callback with on_msg.\n",
       "    comm.on_msg(function(msg) {\n",
       "        //console.log('receiving', msg['content']['data'], msg);\n",
       "        // Pass the mpl event to the overridden (by mpl) onmessage function.\n",
       "        ws.onmessage(msg['content']['data'])\n",
       "    });\n",
       "    return ws;\n",
       "}\n",
       "\n",
       "mpl.mpl_figure_comm = function(comm, msg) {\n",
       "    // This is the function which gets called when the mpl process\n",
       "    // starts-up an IPython Comm through the \"matplotlib\" channel.\n",
       "\n",
       "    var id = msg.content.data.id;\n",
       "    // Get hold of the div created by the display call when the Comm\n",
       "    // socket was opened in Python.\n",
       "    var element = $(\"#\" + id);\n",
       "    var ws_proxy = comm_websocket_adapter(comm)\n",
       "\n",
       "    function ondownload(figure, format) {\n",
       "        window.open(figure.imageObj.src);\n",
       "    }\n",
       "\n",
       "    var fig = new mpl.figure(id, ws_proxy,\n",
       "                           ondownload,\n",
       "                           element.get(0));\n",
       "\n",
       "    // Call onopen now - mpl needs it, as it is assuming we've passed it a real\n",
       "    // web socket which is closed, not our websocket->open comm proxy.\n",
       "    ws_proxy.onopen();\n",
       "\n",
       "    fig.parent_element = element.get(0);\n",
       "    fig.cell_info = mpl.find_output_cell(\"<div id='\" + id + \"'></div>\");\n",
       "    if (!fig.cell_info) {\n",
       "        console.error(\"Failed to find cell for figure\", id, fig);\n",
       "        return;\n",
       "    }\n",
       "\n",
       "    var output_index = fig.cell_info[2]\n",
       "    var cell = fig.cell_info[0];\n",
       "\n",
       "};\n",
       "\n",
       "mpl.figure.prototype.handle_close = function(fig, msg) {\n",
       "    var width = fig.canvas.width/mpl.ratio\n",
       "    fig.root.unbind('remove')\n",
       "\n",
       "    // Update the output cell to use the data from the current canvas.\n",
       "    fig.push_to_output();\n",
       "    var dataURL = fig.canvas.toDataURL();\n",
       "    // Re-enable the keyboard manager in IPython - without this line, in FF,\n",
       "    // the notebook keyboard shortcuts fail.\n",
       "    IPython.keyboard_manager.enable()\n",
       "    $(fig.parent_element).html('<img src=\"' + dataURL + '\" width=\"' + width + '\">');\n",
       "    fig.close_ws(fig, msg);\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.close_ws = function(fig, msg){\n",
       "    fig.send_message('closing', msg);\n",
       "    // fig.ws.close()\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.push_to_output = function(remove_interactive) {\n",
       "    // Turn the data on the canvas into data in the output cell.\n",
       "    var width = this.canvas.width/mpl.ratio\n",
       "    var dataURL = this.canvas.toDataURL();\n",
       "    this.cell_info[1]['text/html'] = '<img src=\"' + dataURL + '\" width=\"' + width + '\">';\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.updated_canvas_event = function() {\n",
       "    // Tell IPython that the notebook contents must change.\n",
       "    IPython.notebook.set_dirty(true);\n",
       "    this.send_message(\"ack\", {});\n",
       "    var fig = this;\n",
       "    // Wait a second, then push the new image to the DOM so\n",
       "    // that it is saved nicely (might be nice to debounce this).\n",
       "    setTimeout(function () { fig.push_to_output() }, 1000);\n",
       "}\n",
       "\n",
       "mpl.figure.prototype._init_toolbar = function() {\n",
       "    var fig = this;\n",
       "\n",
       "    var nav_element = $('<div/>')\n",
       "    nav_element.attr('style', 'width: 100%');\n",
       "    this.root.append(nav_element);\n",
       "\n",
       "    // Define a callback function for later on.\n",
       "    function toolbar_event(event) {\n",
       "        return fig.toolbar_button_onclick(event['data']);\n",
       "    }\n",
       "    function toolbar_mouse_event(event) {\n",
       "        return fig.toolbar_button_onmouseover(event['data']);\n",
       "    }\n",
       "\n",
       "    for(var toolbar_ind in mpl.toolbar_items){\n",
       "        var name = mpl.toolbar_items[toolbar_ind][0];\n",
       "        var tooltip = mpl.toolbar_items[toolbar_ind][1];\n",
       "        var image = mpl.toolbar_items[toolbar_ind][2];\n",
       "        var method_name = mpl.toolbar_items[toolbar_ind][3];\n",
       "\n",
       "        if (!name) { continue; };\n",
       "\n",
       "        var button = $('<button class=\"btn btn-default\" href=\"#\" title=\"' + name + '\"><i class=\"fa ' + image + ' fa-lg\"></i></button>');\n",
       "        button.click(method_name, toolbar_event);\n",
       "        button.mouseover(tooltip, toolbar_mouse_event);\n",
       "        nav_element.append(button);\n",
       "    }\n",
       "\n",
       "    // Add the status bar.\n",
       "    var status_bar = $('<span class=\"mpl-message\" style=\"text-align:right; float: right;\"/>');\n",
       "    nav_element.append(status_bar);\n",
       "    this.message = status_bar[0];\n",
       "\n",
       "    // Add the close button to the window.\n",
       "    var buttongrp = $('<div class=\"btn-group inline pull-right\"></div>');\n",
       "    var button = $('<button class=\"btn btn-mini btn-primary\" href=\"#\" title=\"Stop Interaction\"><i class=\"fa fa-power-off icon-remove icon-large\"></i></button>');\n",
       "    button.click(function (evt) { fig.handle_close(fig, {}); } );\n",
       "    button.mouseover('Stop Interaction', toolbar_mouse_event);\n",
       "    buttongrp.append(button);\n",
       "    var titlebar = this.root.find($('.ui-dialog-titlebar'));\n",
       "    titlebar.prepend(buttongrp);\n",
       "}\n",
       "\n",
       "mpl.figure.prototype._root_extra_style = function(el){\n",
       "    var fig = this\n",
       "    el.on(\"remove\", function(){\n",
       "\tfig.close_ws(fig, {});\n",
       "    });\n",
       "}\n",
       "\n",
       "mpl.figure.prototype._canvas_extra_style = function(el){\n",
       "    // this is important to make the div 'focusable\n",
       "    el.attr('tabindex', 0)\n",
       "    // reach out to IPython and tell the keyboard manager to turn it's self\n",
       "    // off when our div gets focus\n",
       "\n",
       "    // location in version 3\n",
       "    if (IPython.notebook.keyboard_manager) {\n",
       "        IPython.notebook.keyboard_manager.register_events(el);\n",
       "    }\n",
       "    else {\n",
       "        // location in version 2\n",
       "        IPython.keyboard_manager.register_events(el);\n",
       "    }\n",
       "\n",
       "}\n",
       "\n",
       "mpl.figure.prototype._key_event_extra = function(event, name) {\n",
       "    var manager = IPython.notebook.keyboard_manager;\n",
       "    if (!manager)\n",
       "        manager = IPython.keyboard_manager;\n",
       "\n",
       "    // Check for shift+enter\n",
       "    if (event.shiftKey && event.which == 13) {\n",
       "        this.canvas_div.blur();\n",
       "        event.shiftKey = false;\n",
       "        // Send a \"J\" for go to next cell\n",
       "        event.which = 74;\n",
       "        event.keyCode = 74;\n",
       "        manager.command_mode();\n",
       "        manager.handle_keydown(event);\n",
       "    }\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.handle_save = function(fig, msg) {\n",
       "    fig.ondownload(fig, null);\n",
       "}\n",
       "\n",
       "\n",
       "mpl.find_output_cell = function(html_output) {\n",
       "    // Return the cell and output element which can be found *uniquely* in the notebook.\n",
       "    // Note - this is a bit hacky, but it is done because the \"notebook_saving.Notebook\"\n",
       "    // IPython event is triggered only after the cells have been serialised, which for\n",
       "    // our purposes (turning an active figure into a static one), is too late.\n",
       "    var cells = IPython.notebook.get_cells();\n",
       "    var ncells = cells.length;\n",
       "    for (var i=0; i<ncells; i++) {\n",
       "        var cell = cells[i];\n",
       "        if (cell.cell_type === 'code'){\n",
       "            for (var j=0; j<cell.output_area.outputs.length; j++) {\n",
       "                var data = cell.output_area.outputs[j];\n",
       "                if (data.data) {\n",
       "                    // IPython >= 3 moved mimebundle to data attribute of output\n",
       "                    data = data.data;\n",
       "                }\n",
       "                if (data['text/html'] == html_output) {\n",
       "                    return [cell, data, j];\n",
       "                }\n",
       "            }\n",
       "        }\n",
       "    }\n",
       "}\n",
       "\n",
       "// Register the function which deals with the matplotlib target/channel.\n",
       "// The kernel may be null if the page has been refreshed.\n",
       "if (IPython.notebook.kernel != null) {\n",
       "    IPython.notebook.kernel.comm_manager.register_target('matplotlib', mpl.mpl_figure_comm);\n",
       "}\n"
      ],
      "text/plain": [
       "<IPython.core.display.Javascript object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/html": [
       "<img src=\"data:image/png;base64,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\" width=\"432\">"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "[<matplotlib.lines.Line2D at 0x7f00d4b66eb8>]"
      ]
     },
     "execution_count": 167,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "%matplotlib notebook\n",
    "plt.plot(dfPredict[\"real\"].values,lw=10)\n",
    "plt.plot(dfPredict[\"nnLabel\"].values,color = 'r')\n",
    "plt.plot(dfPredict[\"Filtered\"].values,color = 'k')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1080x792 with 9 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "interp.plot_top_losses(9, figsize=(15,11))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "doc(interp.plot_top_losses)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAdwAAAHmCAYAAADZQj8+AAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAAJOgAACToB8GSSSgAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDMuMC4yLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvOIA7rQAAGPZJREFUeJzt3XmcXXV9//H3J4RIkCUsyhYUCoqgKIugiEhEcQMUENJWaws/FrE/BRUQ5fGoUlorCiJYaVVQEcWFhK2CW11YFVkEBHErWn8CZZMtCCFk8v39MTdpxCwQJ99Jhufzn7n3nHPP/dyQ4ZVz7j0z1VoLALB0jRvtAQDgyUBwAaADwQWADgQXADoQXADoQHBhCVXVulX1laq6uapuqqqvV9Wzl3BfO1XVT6vquqqa+AQfe0hV/e2SPO9IqqopVfWSRax/fVW9t+dMsCwplwXBE1dVleQHST7fWvvkYNlWSVZtrV26BPv7ZJIftdY+N7KT9lNVxyR5sLV2wgLWjW+tze4/FSw7HOHCknl5kkfnxjZJWmvXtdYurWHHV9WNVXVDVf1lMu8I8KKqml5VP6+qMwfbHphkapL3D5ZNqaoL5u63qj5RVfsNbh83OJr+SVWdMFh2TFUdMbi9VVVdMVh/blWtMVh+UVV9uKqurKpfVtVOj31Bg+e9uKrOGmxzXFW9efCYG6pqk8F2e1TVj6rq2qr6TlWtU1UbJTkkybsGR+k7VdXpVXViVX0/yYerar+q+sRgH+fPPSqvqrdW1Zkj/N8HljnjR3sAWE49L8k1C1m3d5KtkrwgydpJrqqqSwbrtk7y3CS3Jbk8yY6ttdOq6qVJLmitTa+qKQvaaVWtmWSvJM9prbWqmrSAzc5I8o7W2sVVdWySDyR552Dd+Nba9lX1usHyVy7g8S9IsnmSe5L8Oslpg8ccluQdg31dluTFgxkOTPKe1trhg6P0eUe4VXVAkmcneWVrbWjuPxoGDk5yeVX9JsnhSV68kD9LGDMc4cLIe2mSL7fWhlprdyS5OMl2g3VXttZuaa3NSXJdko2ewH4fSDIzyWlVtXeSh+ZfWVWrJ5nUWrt4sOjzSV423ybnDL5es4jnvaq19j+ttUeS3Jzk24PlN8z3mMlJvlVVNyQ5MsP/gFiYaa21occuHPy5vD/J95Mc3lq7ZxH7gDFBcGHJ/DTJtgtZV4t43CPz3R7Kgs8yzc4ff2+ulCSD90C3T3J2kj2TfPPxDvuY517Y8z52vjnz3Z8z32P+NcknWmtbJnnr3PkW4g+LWLdlkt8nWX8R28CYIbiwZL6X5ClVddDcBVW1XVXtnOSSJH9ZVStU1dMyfJR55RPY92+TbFFVTxkctb5isP9VkqzeWvt6hk/tbjX/g1pr9ye5d773Z9+S4aPrkbZ6klsHt/9uvuUzkqz6eHZQVdsneW2GT7EfUVUbj+iEsAzyHi4sgcH7l3slOWlwqcvMJP+d4RBekmSHJNcnaRl+j/P2qnrO49z376rqrCQ/SfKrJNcOVq2a5PyqWinDR9HvWsDD/y7JJ6tq5Qy/B7v/Er7ERTkmybSqujXJFUnmxvJrSaZX1Rsy/H7vAlXVU5KcmmT/1tptVXV4ks9W1S7NZROMYS4LAoAOnFIGgA4EFwA6EFwA6EBwAaCDUfmU8sabb9nWmbzRaDw1PKlsMOkJ/R4EYAmdM33aj1trC7s2P8koBXedyRvlsA//+2g8NTyp7PX8yaM9AjwpTJxeNy9uG6eUAaADwQWADgQXADoQXADoQHABoAPBBYAOBBcAOhBcAOhAcAGgA8EFgA4EFwA6EFwA6EBwAaADwQWADgQXADoQXADoQHABoAPBBYAOBBcAOhBcAOhAcAGgA8EFgA4EFwA6EFwA6EBwAaADwQWADgQXADoQXADoQHABoAPBBYAOBBcAOhBcAOhAcAGgA8EFgA4EFwA6EFwA6EBwAaADwQWADgQXADoQXADoQHABoAPBBYAOBBcAOhBcAOhAcAGgA8EFgA4EFwA6EFwA6EBwAaADwQWADgQXADoQXADoQHABoAPBBYAOBBcAOhBcAOhAcAGgA8EFgA4EFwA6EFwA6EBwAaADwQWADgQXADoQXADoQHABoAPBBYAOBBcAOhBcAOhAcAGgA8EFgA4EFwA6EFwA6EBwAaADwQWADgQXADoQXADoQHABoAPBBYAOBBcAOhBcAOhAcAGgA8EFgA4EFwA6EFwA6EBwAaADwQWADgQXADoQXADoQHABoAPBBYAOBBcAOhBcAOhAcAGgA8EFgA4EFwA6EFwA6EBwAaADwQWADgQXADoQXADoYPxoD8Cy4aarf5hzTzs5Q0Oz87o3H5Rf33R9Ljr/q9nxNXvmze/6hyTJeZ/5eK697HuZMzSUXff927xsj30za+bDOfmot+Xhhx7M+BUn5NAPnZJVVl9jlF8NLB8uufiifOiD/5TZs2fn0He+O9dcfVU+f/pn85d/9aYc95ETkiT/fOwxOe+cs7PmWmtl6222zYeP/+goT82SElwy65GZufCLn85R/3pGxq84IUmy6fO2znO3e2muu+y787bb4dVvyJ4HHJrZj87K0W9+bXbafZ9c94OLMnmTzfLXh74v3zvnS7n0wnPy2jcdMEqvBJYfM2fOzMkf+2jOv+AbmTBh+Ptuu+1flJfv8op84+sX/tG2x37wQ3ndbruPxpiMIKeUya+uvyYTnrJSjn/n/jnx8ANz3913ZtLaT09V/dF260x+ZpJkhfErZoUVhv+ttu6GG2XWzIeTJH948IGstsaafYeH5dQVP/xBVpo4MW/cc49M3Wev3H777Vl33XX/5PsuSf7pmPdn1112zkXf/94oTMpIEVxy/z135a7b/l+OPOlz2WXvN+fsT39skdt/88ufzYt23T1VlXUmb5Tf3fyLvGfqK3LZBdPzwimv6TQ1LN/uuOOO/PdvfpOzz/taDjjw4Hzw2GMWuN3fv/3Q/PCqH+eLXz4rR777nZk1a1bfQRkxIx7cqjqhqi6tqjOrasJI75+Rt/Kqq2ezrbbL+BUn5LnbvSS3/vqXC932hisuyc9/fEVev9//TZJccsG0bLHtDvnIWd/NGw85POecelKvsWG5NmnSpLxkx5dmwoQJmfLyXfKzn920wO3WXHP4rNE666yTzTbfPLfeckvPMRlBIxrcqto6ybqttZ2S3JRkn5HcP0vHJs/dKrf8+ldJkv/+xU/z9A2escDtbrn5Fzn3tJPztmNPyrhx//tX56mrTxr+uspqeejBB5b+wDAGvHC77fPzQWSvu/babLzxXyxwuwceGP6eeuihh/LLn/886663XrcZGVkj/aGpHZJ8e3D7m0n2T/KlEX4ORtiqk9bItjvvmmMPfGNq3Lgc/P4T8o0vfSaXXnh2Hrzvntxz1+15x7+cki+ceGxm3H9fjn/nfkmSwz/6mez42r3yiaPfniu/e2GGZg/lrR84YXRfDCwn1lprrey2++vzype/LOPGjcunTv1sPvHxk/OlL56Ru39/d2677dac8cUv5+ijjsyNN96QoaGhHHHU+zJx4sTRHp0lVK21kdtZ1dFJbmqtnVdVmyY5trX2psG6fZPsmySbbrnNvseefv6IPS+wYHs9f/JojwBPChNXrGmttamL2mak38O9N8lqg9uTktwzd0VrbVprbWprbepa66w/wk8LAMu2kQ7uFUleNbj96iSXj/D+AWC5NKLBba1dm+T2qro0yRZJzh7J/QPA8mrEf9JUa+2Ikd4nACzv/OALAOhAcAGgA8EFgA4EFwA6EFwA6EBwAaADwQWADgQXADoQXADoQHABoAPBBYAOBBcAOhBcAOhAcAGgA8EFgA4EFwA6EFwA6EBwAaADwQWADgQXADoQXADoQHABoAPBBYAOBBcAOhBcAOhAcAGgA8EFgA4EFwA6EFwA6EBwAaADwQWADgQXADoQXADoQHABoAPBBYAOBBcAOhBcAOhAcAGgA8EFgA4EFwA6EFwA6EBwAaADwQWADgQXADoQXADoQHABoAPBBYAOBBcAOhBcAOhAcAGgA8EFgA4EFwA6EFwA6EBwAaADwQWADgQXADoQXADoQHABoAPBBYAOBBcAOhBcAOhAcAGgA8EFgA4EFwA6EFwA6EBwAaADwQWADgQXADoQXADoQHABoAPBBYAOBBcAOhBcAOhAcAGgA8EFgA4EFwA6EFwA6EBwAaADwQWADgQXADoQXADoQHABoAPBBYAOBBcAOhBcAOhAcAGgA8EFgA4EFwA6EFwA6EBwAaADwQWADgQXADoQXADoQHABoIPxC1pYVdOStMcuTtJaa1OX+lQAMMYsMLhJjug6BQCMcQsMbmvtt0lSVZVklyTrZ/gIN0nO6DMaAIwdCzvCneurSX6XZLckFyZZN4ILAE/Y4j409fTW2uFJbh98XbnDTAAw5iwuuLOralySe6vqkCSbdJgJAMacxQX3TYNtDsnw0e1blvpEADAGLe493OfMd/vqJKsvxVkAYMxaXHBfO/haSbZJMivJJUt1IgAYgxYZ3Nba++a/X1XnLd1xAGBsWmRwq2qL+e5umGSjpToNAIxRizulfOTga0tyT0boQ1PrrbZSdtti/ZHYFbAIa2z39tEeARhYXHC/0Vo7a+6dqtotyQ1LdyQAGHsWd1nQIY+5f9DSGgQAxrKF/bagg5IcnGSzqroyw59SnpPkon6jAcDYsbBfXnBqklOras/Wmk8mA8CfaXGnlPeee6OGfW4pzwMAY9Ligrvh3ButtZZk46U7DgCMTYsL7oyqekNVrVlVr08yo8dQADDWLO6yoP+T5OgMf4Dq4SRXLPWJAGAMWtwR7mpJ7szwLy24L8nNS30iABiDFnZZ0HuTvCLDgf1KkimttQN7DgYAY8nCjnD3SHJXkvOTXJbha3ABgCW0wOC21nZM8p4kmyU5N8lzBx+emtRzOAAYKxb6Hm5r7ZbW2kmttT2SvCTDvyno/F6DAcBYsrgPTSVJWmu3ttZObq3tvLQHAoCx6HEFFwD48wguAHQguADQgeACQAeCCwAdCC4AdCC4ANCB4AJAB4ILAB0ILgB0ILgA0IHgAkAHggsAHQguAHQguADQgeACQAeCCwAdCC4AdCC4ANCB4AJAB4ILAB0ILgB0ILgA0IHgAkAHggsAHQguAHQguADQgeACQAeCCwAdCC4AdCC4ANCB4AJAB4ILAB0ILgB0ILgA0IHgAkAHggsAHQguAHQguADQgeACQAeCCwAdCC4AdCC4ANCB4AJAB4ILAB0ILgB0ILgA0IHgAkAHggsAHQguAHQguADQgeACQAeCCwAdCC4AdCC4ANCB4AJAB4ILAB0ILgB0ILgA0IHgAkAHggsAHQguAHQguADQgeACQAeCCwAdCC4AdCC4ANCB4AJAB4ILAB0ILgB0ILgA0IHgAkAHggsAHQguAHQguADQgeACQAeCCwAdCC4AdCC4ANCB4AJAB4ILAB0ILgB0ILgA0IHgAkAHggsAHQguAHQguADQgeCSGTNmZJeddsj6a6+Wm356Y5Lk7GlfzSt33jG7v+aVueV3v5u37Zw5c7L91s/Lp//9lCTJ5z7z6ez2ql2y26t2yabPXC8Xfu38UXkNsCxbZeWn5JIzjshdl380W2yyXpJkg6dPyrST3ppvnXpYjj74tUmSI/bfNd8+7bBc9sUj8/Y3TUmSbDx57fzwy0fl3is+lqdOnJAk2XDdNfKtUw/Lt049LD/66nvz1Y8eNCqviydm/GgPwOibOHFizjrnP/IPR78nSfLoo4/mlI+flG9+9+L8+Oqr8pHj/jkfP+VTSZLpX/1yJm+44bzH7n/Awdn/gIOTJDtuv3Ve/opd+78AWMY9/Mij2fuwT+Zf3rnnvGX/8q49c9gHv5Lb7rp/3rKTvvDdnPC5/8y4cZWrzjo6//aVi3P73ffn1QednGkfe+u87X53+7159UEnJ0mOOvDVueWO+/q9GJaYI1wyfvz4rP20p827f/N//Sqbb7FFJkyYkBe/ZMfcdOPwUe/Q0FDOO2d69nrjvn+yj+uvuzabPuvZWXnllbvNDcuLoaE5ufveB+fdHz9+XJ65/lo57vC9841PvSMvfsHGSZLZs+ckSVaasGJ+c8vdmTOn5eGZj+aBB2cudN97THl+Lvj+T5buC2BECC5/4v777suqq6427/7Q0FCS5KyvnJk9994n48b96V+b886Znj333qfbjLA8W3vSKnnes9bP+048N/sdfXqOP+KN89Yd9+69cuN/fCBX//S3i93Pps94eu68Z0buf/DhpTkuI2REg1tVq1bVj6rqwap63kjum34mrbFGZsx4YN79FVZYIUNDQzln+ll549S/WuBj/vNb38irXvO6XiPCcu2+GQ/nV7+9M7feeV/u+P2MzB6akxVWGP7f8XtPPDeb7/6B7D7l+Vnvaasvcj9777p1zvnPa3uMzAgY6fdwH06ye5LjR3i/dPQXm2yan//sZ5k1a1Z+fPVVee6WW+aO22/PnXfemX332j3/c9ttGRoaynYvenG23mbb/OT66/IXm2yapz71qaM9OiwXZj7yaO6f8XBWW2WlzJ49JyuuOD5DQ3MyYcXxmfXo7Dwya3YenjkrD8+ctcj97DFly+zx96d0mpo/14gGt7U2O8ldVTWSu6WDffbcLTdcf31+9ctfZv8DD8rb3n5oXrfry7PSSivlk6ednvU32CAXX35lkuTML5yePzz4h2y9zbZJnE6Gx+Pcf31bXrDZ5Dx7o3Vy2vTLcswpX8s5Jx+SFcevkGP/7YIkyYcP3ztbbLJeVhw/LmdecGXum/FwJq06MWcef0C2fPYGOfvkQ3Li57+Tb19+UzZ5xtNy931/yH0znE5eXlRrbeR3WnV6khNaazfOt2zfJPsmyXbbv3jf71x8+Yg/L/DH1tnh0NEeAZ4UZl53yrTW2tRFbdPtQ1OttWmttamttakbTJ7c62kBYJngU8oA0MGIB7eqvp7kVUlOrar9Rnr/ALA8GvGfNNVac20IADyGU8oA0IHgAkAHggsAHQguAHQguADQgeACQAeCCwAdCC4AdCC4ANCB4AJAB4ILAB0ILgB0ILgA0IHgAkAHggsAHQguAHQguADQgeACQAeCCwAdCC4AdCC4ANCB4AJAB4ILAB0ILgB0ILgA0IHgAkAHggsAHQguAHQguADQgeACQAeCCwAdCC4AdCC4ANCB4AJAB4ILAB0ILgB0ILgA0IHgAkAHggsAHQguAHQguADQgeACQAeCCwAdCC4AdCC4ANCB4AJAB4ILAB0ILgB0ILgA0IHgAkAHggsAHQguAHQguADQgeACQAeCCwAdCC4AdCC4ANCB4AJAB4ILAB0ILgB0ILgA0IHgAkAHggsAHQguAHQguADQgeACQAeCCwAdCC4AdCC4ANCB4AJAB4ILAB0ILgB0ILgA0IHgAkAHggsAHQguAHQguADQgeACQAeCCwAdCC4AdCC4ANCB4AJAB4ILAB0ILgB0ILgA0IHgAkAHggsAHQguAHQguADQgeACQAeCCwAdCC4AdCC4ANCB4AJAB4ILAB0ILgB0ILgA0IHgAkAHggsAHQguAHQguADQgeACQAeCCwAdCC4AdCC4ANBBtdb6P2nVNUlu7v7E/LkmJ7lltIeAJwHfa8ufTVpr2y5qg1EJLsunqjqrtTZ1tOeAsc732tjklDIAdCC4PBHTRnsAeJLwvTYGOaUMAB04wgWADgQXADoYP9oDsGyqqvFJ9knykiRrJrknyeVJzm6tzR7N2eDJoKr+trV2xmjPwcjxHi4LVFVfSPKzJN9Mcn+SSUlenWTz1tpbRnM2GEuqaosFLU7y6dbajr3nYelxhMvCPHMBYb2mqi4ZlWlg7LoiyfQMR3Z+zxyFWViKBJeF+VFVnZHk20keSLJaklcl+dGoTgVjz01Jjmyt/X7+hVV14SjNw1LilDILVVVbJdkhw6eT701yRWvtutGdCsaWqlolyUOttTmjPQtLl+ACQAcuCwKADgQXljFVtVFV3VVVF1XV5VW16RN8/CFVtV9VrVtV/7iQbSZV1eP+4fhVdVxVTXkicwB/THBh2XRxa21KkhOTHDV3YVU97u/Z1trtrbUPLGT1pCR+Gw10JLiwbLsxyd9U1QVV9R9J3lJVL6yq71fVpVV1RJJU1TOq6rKq+nqSlw2WbVRV0we3tx9sf3FVHZ7kbUl2HhxFb1ZVrxms/0FV/fXgMVtV1VVV9bUkm4/Gi4exxGVBsGzbKckvMnxZ1s6ttVZV302yd2vt3qo6d/BDSt6T5NjW2rer6swF7OdjSaa21m4dHCU/I8O/MHufwf3PJZmSZHaS71fVWUn+OcnfJPllEtdfw59JcGHZtHNVXZThH6n5oSQvav97ScGWSc6tqiRZI8mGSTZNcs1g/ZUL2N+E1tqtSdJamzN47FxrJ3lWhq+5nnv/aUnWaa39Ikmq6uqReVnw5OWUMiybLm6tTWmt7Z3kjiTzX6N5fZI3DN7j3SbDof2vJFsP1r9wAft7pKrWS+a9D/xokhUG6+7O8I/x3HWwz61aa7cnuaOqnlXDdd5mJF8cPBk5woXlz3uTnDMI56wkeyb5SJIvDd7TvW8Bj3l3kulVNSvJ15KclGTi4D3e9yT5YJLvVNWcJHdl+ANV/5DkS0nuXMg+gSfAD74AgA6cUgaADgQXADoQXADoQHABoAPBBYAOBBcAOhBcAOjg/wO2uBw2haBhHgAAAABJRU5ErkJggg==\n",
      "text/plain": [
       "<Figure size 480x480 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "interp.plot_confusion_matrix(figsize=(8,8), dpi=60)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[('1', '0', 1057), ('0', '1', 615)]"
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "interp.most_confused(min_val=2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Unfreezing, fine-tuning, and learning rates"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Since our model is working as we expect it to, we will *unfreeze* our model and train some more."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "learn.unfreeze()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "LR Finder is complete, type {learner_name}.recorder.plot() to see the graph.\n"
     ]
    }
   ],
   "source": [
    "learn.lr_find()"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Min numerical gradient: 9.12E-07\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "learn.recorder.plot()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "Total time: 05:05 <p><table style='width:300px; margin-bottom:10px'>\n",
       "  <tr>\n",
       "    <th>epoch</th>\n",
       "    <th>train_loss</th>\n",
       "    <th>valid_loss</th>\n",
       "    <th>error_rate</th>\n",
       "  </tr>\n",
       "  <tr>\n",
       "    <th>1</th>\n",
       "    <th>0.210339</th>\n",
       "    <th>0.185146</th>\n",
       "    <th>0.068126</th>\n",
       "  </tr>\n",
       "  <tr>\n",
       "    <th>2</th>\n",
       "    <th>0.199556</th>\n",
       "    <th>0.186155</th>\n",
       "    <th>0.068790</th>\n",
       "  </tr>\n",
       "  <tr>\n",
       "    <th>3</th>\n",
       "    <th>0.183420</th>\n",
       "    <th>0.188252</th>\n",
       "    <th>0.068416</th>\n",
       "  </tr>\n",
       "</table>\n"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "learn.fit_one_cycle(3,max_lr=slice(1e-6,1e-4))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "learn.load('stage-1');"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "LR Finder is complete, type {learner_name}.recorder.plot() to see the graph.\n"
     ]
    }
   ],
   "source": [
    "learn.lr_find()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Min numerical gradient: 2.29E-06\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "learn.recorder.plot()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "Total time: 00:53 <p><table style='width:300px; margin-bottom:10px'>\n",
       "  <tr>\n",
       "    <th>epoch</th>\n",
       "    <th>train_loss</th>\n",
       "    <th>valid_loss</th>\n",
       "    <th>error_rate</th>\n",
       "  </tr>\n",
       "  <tr>\n",
       "    <th>1</th>\n",
       "    <th>0.242544</th>\n",
       "    <th>0.208489</th>\n",
       "    <th>0.067659</th>\n",
       "  </tr>\n",
       "  <tr>\n",
       "    <th>2</th>\n",
       "    <th>0.206940</th>\n",
       "    <th>0.204482</th>\n",
       "    <th>0.062246</th>\n",
       "  </tr>\n",
       "</table>\n"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "learn.unfreeze()\n",
    "learn.fit_one_cycle(2, max_lr=slice(1e-6,1e-4))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "That's a pretty accurate model!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Training: resnet50"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now we will train in the same way as before but with one caveat: instead of using resnet34 as our backbone we will use resnet50 (resnet34 is a 34 layer residual network while resnet50 has 50 layers. It will be explained later in the course and you can learn the details in the [resnet paper](https://arxiv.org/pdf/1512.03385.pdf)).\n",
    "\n",
    "Basically, resnet50 usually performs better because it is a deeper network with more parameters. Let's see if we can achieve a higher performance here. To help it along, let's us use larger images too, since that way the network can see more detail. We reduce the batch size a bit since otherwise this larger network will require more GPU memory."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "ename": "NameError",
     "evalue": "name 'path_img' is not defined",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mNameError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-7-1b2cbe11e6a6>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m data = ImageDataBunch.from_name_re(path_img, fnames, pat, ds_tfms=get_transforms(),\n\u001b[0m\u001b[1;32m      2\u001b[0m                                    size=299, bs=bs//2).normalize(imagenet_stats)\n",
      "\u001b[0;31mNameError\u001b[0m: name 'path_img' is not defined"
     ]
    }
   ],
   "source": [
    "data = ImageDataBunch.from_name_re(path_img, fnames, pat, ds_tfms=get_transforms(),\n",
    "                                   size=299, bs=bs//2).normalize(imagenet_stats)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "ename": "NameError",
     "evalue": "name 'data' is not defined",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mNameError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-6-c4b481dd1224>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mlearn\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mcreate_cnn\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mdata\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mmodels\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mresnet50\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mmetrics\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0merror_rate\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mNameError\u001b[0m: name 'data' is not defined"
     ]
    }
   ],
   "source": [
    "learn = create_cnn(data, models.resnet50, metrics=error_rate)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "LR Finder is complete, type {learner_name}.recorder.plot() to see the graph.\n"
     ]
    },
    {
     "data": {
      "application/javascript": [
       "/* Put everything inside the global mpl namespace */\n",
       "window.mpl = {};\n",
       "\n",
       "\n",
       "mpl.get_websocket_type = function() {\n",
       "    if (typeof(WebSocket) !== 'undefined') {\n",
       "        return WebSocket;\n",
       "    } else if (typeof(MozWebSocket) !== 'undefined') {\n",
       "        return MozWebSocket;\n",
       "    } else {\n",
       "        alert('Your browser does not have WebSocket support.' +\n",
       "              'Please try Chrome, Safari or Firefox ≥ 6. ' +\n",
       "              'Firefox 4 and 5 are also supported but you ' +\n",
       "              'have to enable WebSockets in about:config.');\n",
       "    };\n",
       "}\n",
       "\n",
       "mpl.figure = function(figure_id, websocket, ondownload, parent_element) {\n",
       "    this.id = figure_id;\n",
       "\n",
       "    this.ws = websocket;\n",
       "\n",
       "    this.supports_binary = (this.ws.binaryType != undefined);\n",
       "\n",
       "    if (!this.supports_binary) {\n",
       "        var warnings = document.getElementById(\"mpl-warnings\");\n",
       "        if (warnings) {\n",
       "            warnings.style.display = 'block';\n",
       "            warnings.textContent = (\n",
       "                \"This browser does not support binary websocket messages. \" +\n",
       "                    \"Performance may be slow.\");\n",
       "        }\n",
       "    }\n",
       "\n",
       "    this.imageObj = new Image();\n",
       "\n",
       "    this.context = undefined;\n",
       "    this.message = undefined;\n",
       "    this.canvas = undefined;\n",
       "    this.rubberband_canvas = undefined;\n",
       "    this.rubberband_context = undefined;\n",
       "    this.format_dropdown = undefined;\n",
       "\n",
       "    this.image_mode = 'full';\n",
       "\n",
       "    this.root = $('<div/>');\n",
       "    this._root_extra_style(this.root)\n",
       "    this.root.attr('style', 'display: inline-block');\n",
       "\n",
       "    $(parent_element).append(this.root);\n",
       "\n",
       "    this._init_header(this);\n",
       "    this._init_canvas(this);\n",
       "    this._init_toolbar(this);\n",
       "\n",
       "    var fig = this;\n",
       "\n",
       "    this.waiting = false;\n",
       "\n",
       "    this.ws.onopen =  function () {\n",
       "            fig.send_message(\"supports_binary\", {value: fig.supports_binary});\n",
       "            fig.send_message(\"send_image_mode\", {});\n",
       "            if (mpl.ratio != 1) {\n",
       "                fig.send_message(\"set_dpi_ratio\", {'dpi_ratio': mpl.ratio});\n",
       "            }\n",
       "            fig.send_message(\"refresh\", {});\n",
       "        }\n",
       "\n",
       "    this.imageObj.onload = function() {\n",
       "            if (fig.image_mode == 'full') {\n",
       "                // Full images could contain transparency (where diff images\n",
       "                // almost always do), so we need to clear the canvas so that\n",
       "                // there is no ghosting.\n",
       "                fig.context.clearRect(0, 0, fig.canvas.width, fig.canvas.height);\n",
       "            }\n",
       "            fig.context.drawImage(fig.imageObj, 0, 0);\n",
       "        };\n",
       "\n",
       "    this.imageObj.onunload = function() {\n",
       "        fig.ws.close();\n",
       "    }\n",
       "\n",
       "    this.ws.onmessage = this._make_on_message_function(this);\n",
       "\n",
       "    this.ondownload = ondownload;\n",
       "}\n",
       "\n",
       "mpl.figure.prototype._init_header = function() {\n",
       "    var titlebar = $(\n",
       "        '<div class=\"ui-dialog-titlebar ui-widget-header ui-corner-all ' +\n",
       "        'ui-helper-clearfix\"/>');\n",
       "    var titletext = $(\n",
       "        '<div class=\"ui-dialog-title\" style=\"width: 100%; ' +\n",
       "        'text-align: center; padding: 3px;\"/>');\n",
       "    titlebar.append(titletext)\n",
       "    this.root.append(titlebar);\n",
       "    this.header = titletext[0];\n",
       "}\n",
       "\n",
       "\n",
       "\n",
       "mpl.figure.prototype._canvas_extra_style = function(canvas_div) {\n",
       "\n",
       "}\n",
       "\n",
       "\n",
       "mpl.figure.prototype._root_extra_style = function(canvas_div) {\n",
       "\n",
       "}\n",
       "\n",
       "mpl.figure.prototype._init_canvas = function() {\n",
       "    var fig = this;\n",
       "\n",
       "    var canvas_div = $('<div/>');\n",
       "\n",
       "    canvas_div.attr('style', 'position: relative; clear: both; outline: 0');\n",
       "\n",
       "    function canvas_keyboard_event(event) {\n",
       "        return fig.key_event(event, event['data']);\n",
       "    }\n",
       "\n",
       "    canvas_div.keydown('key_press', canvas_keyboard_event);\n",
       "    canvas_div.keyup('key_release', canvas_keyboard_event);\n",
       "    this.canvas_div = canvas_div\n",
       "    this._canvas_extra_style(canvas_div)\n",
       "    this.root.append(canvas_div);\n",
       "\n",
       "    var canvas = $('<canvas/>');\n",
       "    canvas.addClass('mpl-canvas');\n",
       "    canvas.attr('style', \"left: 0; top: 0; z-index: 0; outline: 0\")\n",
       "\n",
       "    this.canvas = canvas[0];\n",
       "    this.context = canvas[0].getContext(\"2d\");\n",
       "\n",
       "    var backingStore = this.context.backingStorePixelRatio ||\n",
       "\tthis.context.webkitBackingStorePixelRatio ||\n",
       "\tthis.context.mozBackingStorePixelRatio ||\n",
       "\tthis.context.msBackingStorePixelRatio ||\n",
       "\tthis.context.oBackingStorePixelRatio ||\n",
       "\tthis.context.backingStorePixelRatio || 1;\n",
       "\n",
       "    mpl.ratio = (window.devicePixelRatio || 1) / backingStore;\n",
       "\n",
       "    var rubberband = $('<canvas/>');\n",
       "    rubberband.attr('style', \"position: absolute; left: 0; top: 0; z-index: 1;\")\n",
       "\n",
       "    var pass_mouse_events = true;\n",
       "\n",
       "    canvas_div.resizable({\n",
       "        start: function(event, ui) {\n",
       "            pass_mouse_events = false;\n",
       "        },\n",
       "        resize: function(event, ui) {\n",
       "            fig.request_resize(ui.size.width, ui.size.height);\n",
       "        },\n",
       "        stop: function(event, ui) {\n",
       "            pass_mouse_events = true;\n",
       "            fig.request_resize(ui.size.width, ui.size.height);\n",
       "        },\n",
       "    });\n",
       "\n",
       "    function mouse_event_fn(event) {\n",
       "        if (pass_mouse_events)\n",
       "            return fig.mouse_event(event, event['data']);\n",
       "    }\n",
       "\n",
       "    rubberband.mousedown('button_press', mouse_event_fn);\n",
       "    rubberband.mouseup('button_release', mouse_event_fn);\n",
       "    // Throttle sequential mouse events to 1 every 20ms.\n",
       "    rubberband.mousemove('motion_notify', mouse_event_fn);\n",
       "\n",
       "    rubberband.mouseenter('figure_enter', mouse_event_fn);\n",
       "    rubberband.mouseleave('figure_leave', mouse_event_fn);\n",
       "\n",
       "    canvas_div.on(\"wheel\", function (event) {\n",
       "        event = event.originalEvent;\n",
       "        event['data'] = 'scroll'\n",
       "        if (event.deltaY < 0) {\n",
       "            event.step = 1;\n",
       "        } else {\n",
       "            event.step = -1;\n",
       "        }\n",
       "        mouse_event_fn(event);\n",
       "    });\n",
       "\n",
       "    canvas_div.append(canvas);\n",
       "    canvas_div.append(rubberband);\n",
       "\n",
       "    this.rubberband = rubberband;\n",
       "    this.rubberband_canvas = rubberband[0];\n",
       "    this.rubberband_context = rubberband[0].getContext(\"2d\");\n",
       "    this.rubberband_context.strokeStyle = \"#000000\";\n",
       "\n",
       "    this._resize_canvas = function(width, height) {\n",
       "        // Keep the size of the canvas, canvas container, and rubber band\n",
       "        // canvas in synch.\n",
       "        canvas_div.css('width', width)\n",
       "        canvas_div.css('height', height)\n",
       "\n",
       "        canvas.attr('width', width * mpl.ratio);\n",
       "        canvas.attr('height', height * mpl.ratio);\n",
       "        canvas.attr('style', 'width: ' + width + 'px; height: ' + height + 'px;');\n",
       "\n",
       "        rubberband.attr('width', width);\n",
       "        rubberband.attr('height', height);\n",
       "    }\n",
       "\n",
       "    // Set the figure to an initial 600x600px, this will subsequently be updated\n",
       "    // upon first draw.\n",
       "    this._resize_canvas(600, 600);\n",
       "\n",
       "    // Disable right mouse context menu.\n",
       "    $(this.rubberband_canvas).bind(\"contextmenu\",function(e){\n",
       "        return false;\n",
       "    });\n",
       "\n",
       "    function set_focus () {\n",
       "        canvas.focus();\n",
       "        canvas_div.focus();\n",
       "    }\n",
       "\n",
       "    window.setTimeout(set_focus, 100);\n",
       "}\n",
       "\n",
       "mpl.figure.prototype._init_toolbar = function() {\n",
       "    var fig = this;\n",
       "\n",
       "    var nav_element = $('<div/>')\n",
       "    nav_element.attr('style', 'width: 100%');\n",
       "    this.root.append(nav_element);\n",
       "\n",
       "    // Define a callback function for later on.\n",
       "    function toolbar_event(event) {\n",
       "        return fig.toolbar_button_onclick(event['data']);\n",
       "    }\n",
       "    function toolbar_mouse_event(event) {\n",
       "        return fig.toolbar_button_onmouseover(event['data']);\n",
       "    }\n",
       "\n",
       "    for(var toolbar_ind in mpl.toolbar_items) {\n",
       "        var name = mpl.toolbar_items[toolbar_ind][0];\n",
       "        var tooltip = mpl.toolbar_items[toolbar_ind][1];\n",
       "        var image = mpl.toolbar_items[toolbar_ind][2];\n",
       "        var method_name = mpl.toolbar_items[toolbar_ind][3];\n",
       "\n",
       "        if (!name) {\n",
       "            // put a spacer in here.\n",
       "            continue;\n",
       "        }\n",
       "        var button = $('<button/>');\n",
       "        button.addClass('ui-button ui-widget ui-state-default ui-corner-all ' +\n",
       "                        'ui-button-icon-only');\n",
       "        button.attr('role', 'button');\n",
       "        button.attr('aria-disabled', 'false');\n",
       "        button.click(method_name, toolbar_event);\n",
       "        button.mouseover(tooltip, toolbar_mouse_event);\n",
       "\n",
       "        var icon_img = $('<span/>');\n",
       "        icon_img.addClass('ui-button-icon-primary ui-icon');\n",
       "        icon_img.addClass(image);\n",
       "        icon_img.addClass('ui-corner-all');\n",
       "\n",
       "        var tooltip_span = $('<span/>');\n",
       "        tooltip_span.addClass('ui-button-text');\n",
       "        tooltip_span.html(tooltip);\n",
       "\n",
       "        button.append(icon_img);\n",
       "        button.append(tooltip_span);\n",
       "\n",
       "        nav_element.append(button);\n",
       "    }\n",
       "\n",
       "    var fmt_picker_span = $('<span/>');\n",
       "\n",
       "    var fmt_picker = $('<select/>');\n",
       "    fmt_picker.addClass('mpl-toolbar-option ui-widget ui-widget-content');\n",
       "    fmt_picker_span.append(fmt_picker);\n",
       "    nav_element.append(fmt_picker_span);\n",
       "    this.format_dropdown = fmt_picker[0];\n",
       "\n",
       "    for (var ind in mpl.extensions) {\n",
       "        var fmt = mpl.extensions[ind];\n",
       "        var option = $(\n",
       "            '<option/>', {selected: fmt === mpl.default_extension}).html(fmt);\n",
       "        fmt_picker.append(option)\n",
       "    }\n",
       "\n",
       "    // Add hover states to the ui-buttons\n",
       "    $( \".ui-button\" ).hover(\n",
       "        function() { $(this).addClass(\"ui-state-hover\");},\n",
       "        function() { $(this).removeClass(\"ui-state-hover\");}\n",
       "    );\n",
       "\n",
       "    var status_bar = $('<span class=\"mpl-message\"/>');\n",
       "    nav_element.append(status_bar);\n",
       "    this.message = status_bar[0];\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.request_resize = function(x_pixels, y_pixels) {\n",
       "    // Request matplotlib to resize the figure. Matplotlib will then trigger a resize in the client,\n",
       "    // which will in turn request a refresh of the image.\n",
       "    this.send_message('resize', {'width': x_pixels, 'height': y_pixels});\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.send_message = function(type, properties) {\n",
       "    properties['type'] = type;\n",
       "    properties['figure_id'] = this.id;\n",
       "    this.ws.send(JSON.stringify(properties));\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.send_draw_message = function() {\n",
       "    if (!this.waiting) {\n",
       "        this.waiting = true;\n",
       "        this.ws.send(JSON.stringify({type: \"draw\", figure_id: this.id}));\n",
       "    }\n",
       "}\n",
       "\n",
       "\n",
       "mpl.figure.prototype.handle_save = function(fig, msg) {\n",
       "    var format_dropdown = fig.format_dropdown;\n",
       "    var format = format_dropdown.options[format_dropdown.selectedIndex].value;\n",
       "    fig.ondownload(fig, format);\n",
       "}\n",
       "\n",
       "\n",
       "mpl.figure.prototype.handle_resize = function(fig, msg) {\n",
       "    var size = msg['size'];\n",
       "    if (size[0] != fig.canvas.width || size[1] != fig.canvas.height) {\n",
       "        fig._resize_canvas(size[0], size[1]);\n",
       "        fig.send_message(\"refresh\", {});\n",
       "    };\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.handle_rubberband = function(fig, msg) {\n",
       "    var x0 = msg['x0'] / mpl.ratio;\n",
       "    var y0 = (fig.canvas.height - msg['y0']) / mpl.ratio;\n",
       "    var x1 = msg['x1'] / mpl.ratio;\n",
       "    var y1 = (fig.canvas.height - msg['y1']) / mpl.ratio;\n",
       "    x0 = Math.floor(x0) + 0.5;\n",
       "    y0 = Math.floor(y0) + 0.5;\n",
       "    x1 = Math.floor(x1) + 0.5;\n",
       "    y1 = Math.floor(y1) + 0.5;\n",
       "    var min_x = Math.min(x0, x1);\n",
       "    var min_y = Math.min(y0, y1);\n",
       "    var width = Math.abs(x1 - x0);\n",
       "    var height = Math.abs(y1 - y0);\n",
       "\n",
       "    fig.rubberband_context.clearRect(\n",
       "        0, 0, fig.canvas.width, fig.canvas.height);\n",
       "\n",
       "    fig.rubberband_context.strokeRect(min_x, min_y, width, height);\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.handle_figure_label = function(fig, msg) {\n",
       "    // Updates the figure title.\n",
       "    fig.header.textContent = msg['label'];\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.handle_cursor = function(fig, msg) {\n",
       "    var cursor = msg['cursor'];\n",
       "    switch(cursor)\n",
       "    {\n",
       "    case 0:\n",
       "        cursor = 'pointer';\n",
       "        break;\n",
       "    case 1:\n",
       "        cursor = 'default';\n",
       "        break;\n",
       "    case 2:\n",
       "        cursor = 'crosshair';\n",
       "        break;\n",
       "    case 3:\n",
       "        cursor = 'move';\n",
       "        break;\n",
       "    }\n",
       "    fig.rubberband_canvas.style.cursor = cursor;\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.handle_message = function(fig, msg) {\n",
       "    fig.message.textContent = msg['message'];\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.handle_draw = function(fig, msg) {\n",
       "    // Request the server to send over a new figure.\n",
       "    fig.send_draw_message();\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.handle_image_mode = function(fig, msg) {\n",
       "    fig.image_mode = msg['mode'];\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.updated_canvas_event = function() {\n",
       "    // Called whenever the canvas gets updated.\n",
       "    this.send_message(\"ack\", {});\n",
       "}\n",
       "\n",
       "// A function to construct a web socket function for onmessage handling.\n",
       "// Called in the figure constructor.\n",
       "mpl.figure.prototype._make_on_message_function = function(fig) {\n",
       "    return function socket_on_message(evt) {\n",
       "        if (evt.data instanceof Blob) {\n",
       "            /* FIXME: We get \"Resource interpreted as Image but\n",
       "             * transferred with MIME type text/plain:\" errors on\n",
       "             * Chrome.  But how to set the MIME type?  It doesn't seem\n",
       "             * to be part of the websocket stream */\n",
       "            evt.data.type = \"image/png\";\n",
       "\n",
       "            /* Free the memory for the previous frames */\n",
       "            if (fig.imageObj.src) {\n",
       "                (window.URL || window.webkitURL).revokeObjectURL(\n",
       "                    fig.imageObj.src);\n",
       "            }\n",
       "\n",
       "            fig.imageObj.src = (window.URL || window.webkitURL).createObjectURL(\n",
       "                evt.data);\n",
       "            fig.updated_canvas_event();\n",
       "            fig.waiting = false;\n",
       "            return;\n",
       "        }\n",
       "        else if (typeof evt.data === 'string' && evt.data.slice(0, 21) == \"data:image/png;base64\") {\n",
       "            fig.imageObj.src = evt.data;\n",
       "            fig.updated_canvas_event();\n",
       "            fig.waiting = false;\n",
       "            return;\n",
       "        }\n",
       "\n",
       "        var msg = JSON.parse(evt.data);\n",
       "        var msg_type = msg['type'];\n",
       "\n",
       "        // Call the  \"handle_{type}\" callback, which takes\n",
       "        // the figure and JSON message as its only arguments.\n",
       "        try {\n",
       "            var callback = fig[\"handle_\" + msg_type];\n",
       "        } catch (e) {\n",
       "            console.log(\"No handler for the '\" + msg_type + \"' message type: \", msg);\n",
       "            return;\n",
       "        }\n",
       "\n",
       "        if (callback) {\n",
       "            try {\n",
       "                // console.log(\"Handling '\" + msg_type + \"' message: \", msg);\n",
       "                callback(fig, msg);\n",
       "            } catch (e) {\n",
       "                console.log(\"Exception inside the 'handler_\" + msg_type + \"' callback:\", e, e.stack, msg);\n",
       "            }\n",
       "        }\n",
       "    };\n",
       "}\n",
       "\n",
       "// from http://stackoverflow.com/questions/1114465/getting-mouse-location-in-canvas\n",
       "mpl.findpos = function(e) {\n",
       "    //this section is from http://www.quirksmode.org/js/events_properties.html\n",
       "    var targ;\n",
       "    if (!e)\n",
       "        e = window.event;\n",
       "    if (e.target)\n",
       "        targ = e.target;\n",
       "    else if (e.srcElement)\n",
       "        targ = e.srcElement;\n",
       "    if (targ.nodeType == 3) // defeat Safari bug\n",
       "        targ = targ.parentNode;\n",
       "\n",
       "    // jQuery normalizes the pageX and pageY\n",
       "    // pageX,Y are the mouse positions relative to the document\n",
       "    // offset() returns the position of the element relative to the document\n",
       "    var x = e.pageX - $(targ).offset().left;\n",
       "    var y = e.pageY - $(targ).offset().top;\n",
       "\n",
       "    return {\"x\": x, \"y\": y};\n",
       "};\n",
       "\n",
       "/*\n",
       " * return a copy of an object with only non-object keys\n",
       " * we need this to avoid circular references\n",
       " * http://stackoverflow.com/a/24161582/3208463\n",
       " */\n",
       "function simpleKeys (original) {\n",
       "  return Object.keys(original).reduce(function (obj, key) {\n",
       "    if (typeof original[key] !== 'object')\n",
       "        obj[key] = original[key]\n",
       "    return obj;\n",
       "  }, {});\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.mouse_event = function(event, name) {\n",
       "    var canvas_pos = mpl.findpos(event)\n",
       "\n",
       "    if (name === 'button_press')\n",
       "    {\n",
       "        this.canvas.focus();\n",
       "        this.canvas_div.focus();\n",
       "    }\n",
       "\n",
       "    var x = canvas_pos.x * mpl.ratio;\n",
       "    var y = canvas_pos.y * mpl.ratio;\n",
       "\n",
       "    this.send_message(name, {x: x, y: y, button: event.button,\n",
       "                             step: event.step,\n",
       "                             guiEvent: simpleKeys(event)});\n",
       "\n",
       "    /* This prevents the web browser from automatically changing to\n",
       "     * the text insertion cursor when the button is pressed.  We want\n",
       "     * to control all of the cursor setting manually through the\n",
       "     * 'cursor' event from matplotlib */\n",
       "    event.preventDefault();\n",
       "    return false;\n",
       "}\n",
       "\n",
       "mpl.figure.prototype._key_event_extra = function(event, name) {\n",
       "    // Handle any extra behaviour associated with a key event\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.key_event = function(event, name) {\n",
       "\n",
       "    // Prevent repeat events\n",
       "    if (name == 'key_press')\n",
       "    {\n",
       "        if (event.which === this._key)\n",
       "            return;\n",
       "        else\n",
       "            this._key = event.which;\n",
       "    }\n",
       "    if (name == 'key_release')\n",
       "        this._key = null;\n",
       "\n",
       "    var value = '';\n",
       "    if (event.ctrlKey && event.which != 17)\n",
       "        value += \"ctrl+\";\n",
       "    if (event.altKey && event.which != 18)\n",
       "        value += \"alt+\";\n",
       "    if (event.shiftKey && event.which != 16)\n",
       "        value += \"shift+\";\n",
       "\n",
       "    value += 'k';\n",
       "    value += event.which.toString();\n",
       "\n",
       "    this._key_event_extra(event, name);\n",
       "\n",
       "    this.send_message(name, {key: value,\n",
       "                             guiEvent: simpleKeys(event)});\n",
       "    return false;\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.toolbar_button_onclick = function(name) {\n",
       "    if (name == 'download') {\n",
       "        this.handle_save(this, null);\n",
       "    } else {\n",
       "        this.send_message(\"toolbar_button\", {name: name});\n",
       "    }\n",
       "};\n",
       "\n",
       "mpl.figure.prototype.toolbar_button_onmouseover = function(tooltip) {\n",
       "    this.message.textContent = tooltip;\n",
       "};\n",
       "mpl.toolbar_items = [[\"Home\", \"Reset original view\", \"fa fa-home icon-home\", \"home\"], [\"Back\", \"Back to previous view\", \"fa fa-arrow-left icon-arrow-left\", \"back\"], [\"Forward\", \"Forward to next view\", \"fa fa-arrow-right icon-arrow-right\", \"forward\"], [\"\", \"\", \"\", \"\"], [\"Pan\", \"Pan axes with left mouse, zoom with right\", \"fa fa-arrows icon-move\", \"pan\"], [\"Zoom\", \"Zoom to rectangle\", \"fa fa-square-o icon-check-empty\", \"zoom\"], [\"\", \"\", \"\", \"\"], [\"Download\", \"Download plot\", \"fa fa-floppy-o icon-save\", \"download\"]];\n",
       "\n",
       "mpl.extensions = [\"eps\", \"jpeg\", \"pdf\", \"png\", \"ps\", \"raw\", \"svg\", \"tif\"];\n",
       "\n",
       "mpl.default_extension = \"png\";var comm_websocket_adapter = function(comm) {\n",
       "    // Create a \"websocket\"-like object which calls the given IPython comm\n",
       "    // object with the appropriate methods. Currently this is a non binary\n",
       "    // socket, so there is still some room for performance tuning.\n",
       "    var ws = {};\n",
       "\n",
       "    ws.close = function() {\n",
       "        comm.close()\n",
       "    };\n",
       "    ws.send = function(m) {\n",
       "        //console.log('sending', m);\n",
       "        comm.send(m);\n",
       "    };\n",
       "    // Register the callback with on_msg.\n",
       "    comm.on_msg(function(msg) {\n",
       "        //console.log('receiving', msg['content']['data'], msg);\n",
       "        // Pass the mpl event to the overridden (by mpl) onmessage function.\n",
       "        ws.onmessage(msg['content']['data'])\n",
       "    });\n",
       "    return ws;\n",
       "}\n",
       "\n",
       "mpl.mpl_figure_comm = function(comm, msg) {\n",
       "    // This is the function which gets called when the mpl process\n",
       "    // starts-up an IPython Comm through the \"matplotlib\" channel.\n",
       "\n",
       "    var id = msg.content.data.id;\n",
       "    // Get hold of the div created by the display call when the Comm\n",
       "    // socket was opened in Python.\n",
       "    var element = $(\"#\" + id);\n",
       "    var ws_proxy = comm_websocket_adapter(comm)\n",
       "\n",
       "    function ondownload(figure, format) {\n",
       "        window.open(figure.imageObj.src);\n",
       "    }\n",
       "\n",
       "    var fig = new mpl.figure(id, ws_proxy,\n",
       "                           ondownload,\n",
       "                           element.get(0));\n",
       "\n",
       "    // Call onopen now - mpl needs it, as it is assuming we've passed it a real\n",
       "    // web socket which is closed, not our websocket->open comm proxy.\n",
       "    ws_proxy.onopen();\n",
       "\n",
       "    fig.parent_element = element.get(0);\n",
       "    fig.cell_info = mpl.find_output_cell(\"<div id='\" + id + \"'></div>\");\n",
       "    if (!fig.cell_info) {\n",
       "        console.error(\"Failed to find cell for figure\", id, fig);\n",
       "        return;\n",
       "    }\n",
       "\n",
       "    var output_index = fig.cell_info[2]\n",
       "    var cell = fig.cell_info[0];\n",
       "\n",
       "};\n",
       "\n",
       "mpl.figure.prototype.handle_close = function(fig, msg) {\n",
       "    var width = fig.canvas.width/mpl.ratio\n",
       "    fig.root.unbind('remove')\n",
       "\n",
       "    // Update the output cell to use the data from the current canvas.\n",
       "    fig.push_to_output();\n",
       "    var dataURL = fig.canvas.toDataURL();\n",
       "    // Re-enable the keyboard manager in IPython - without this line, in FF,\n",
       "    // the notebook keyboard shortcuts fail.\n",
       "    IPython.keyboard_manager.enable()\n",
       "    $(fig.parent_element).html('<img src=\"' + dataURL + '\" width=\"' + width + '\">');\n",
       "    fig.close_ws(fig, msg);\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.close_ws = function(fig, msg){\n",
       "    fig.send_message('closing', msg);\n",
       "    // fig.ws.close()\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.push_to_output = function(remove_interactive) {\n",
       "    // Turn the data on the canvas into data in the output cell.\n",
       "    var width = this.canvas.width/mpl.ratio\n",
       "    var dataURL = this.canvas.toDataURL();\n",
       "    this.cell_info[1]['text/html'] = '<img src=\"' + dataURL + '\" width=\"' + width + '\">';\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.updated_canvas_event = function() {\n",
       "    // Tell IPython that the notebook contents must change.\n",
       "    IPython.notebook.set_dirty(true);\n",
       "    this.send_message(\"ack\", {});\n",
       "    var fig = this;\n",
       "    // Wait a second, then push the new image to the DOM so\n",
       "    // that it is saved nicely (might be nice to debounce this).\n",
       "    setTimeout(function () { fig.push_to_output() }, 1000);\n",
       "}\n",
       "\n",
       "mpl.figure.prototype._init_toolbar = function() {\n",
       "    var fig = this;\n",
       "\n",
       "    var nav_element = $('<div/>')\n",
       "    nav_element.attr('style', 'width: 100%');\n",
       "    this.root.append(nav_element);\n",
       "\n",
       "    // Define a callback function for later on.\n",
       "    function toolbar_event(event) {\n",
       "        return fig.toolbar_button_onclick(event['data']);\n",
       "    }\n",
       "    function toolbar_mouse_event(event) {\n",
       "        return fig.toolbar_button_onmouseover(event['data']);\n",
       "    }\n",
       "\n",
       "    for(var toolbar_ind in mpl.toolbar_items){\n",
       "        var name = mpl.toolbar_items[toolbar_ind][0];\n",
       "        var tooltip = mpl.toolbar_items[toolbar_ind][1];\n",
       "        var image = mpl.toolbar_items[toolbar_ind][2];\n",
       "        var method_name = mpl.toolbar_items[toolbar_ind][3];\n",
       "\n",
       "        if (!name) { continue; };\n",
       "\n",
       "        var button = $('<button class=\"btn btn-default\" href=\"#\" title=\"' + name + '\"><i class=\"fa ' + image + ' fa-lg\"></i></button>');\n",
       "        button.click(method_name, toolbar_event);\n",
       "        button.mouseover(tooltip, toolbar_mouse_event);\n",
       "        nav_element.append(button);\n",
       "    }\n",
       "\n",
       "    // Add the status bar.\n",
       "    var status_bar = $('<span class=\"mpl-message\" style=\"text-align:right; float: right;\"/>');\n",
       "    nav_element.append(status_bar);\n",
       "    this.message = status_bar[0];\n",
       "\n",
       "    // Add the close button to the window.\n",
       "    var buttongrp = $('<div class=\"btn-group inline pull-right\"></div>');\n",
       "    var button = $('<button class=\"btn btn-mini btn-primary\" href=\"#\" title=\"Stop Interaction\"><i class=\"fa fa-power-off icon-remove icon-large\"></i></button>');\n",
       "    button.click(function (evt) { fig.handle_close(fig, {}); } );\n",
       "    button.mouseover('Stop Interaction', toolbar_mouse_event);\n",
       "    buttongrp.append(button);\n",
       "    var titlebar = this.root.find($('.ui-dialog-titlebar'));\n",
       "    titlebar.prepend(buttongrp);\n",
       "}\n",
       "\n",
       "mpl.figure.prototype._root_extra_style = function(el){\n",
       "    var fig = this\n",
       "    el.on(\"remove\", function(){\n",
       "\tfig.close_ws(fig, {});\n",
       "    });\n",
       "}\n",
       "\n",
       "mpl.figure.prototype._canvas_extra_style = function(el){\n",
       "    // this is important to make the div 'focusable\n",
       "    el.attr('tabindex', 0)\n",
       "    // reach out to IPython and tell the keyboard manager to turn it's self\n",
       "    // off when our div gets focus\n",
       "\n",
       "    // location in version 3\n",
       "    if (IPython.notebook.keyboard_manager) {\n",
       "        IPython.notebook.keyboard_manager.register_events(el);\n",
       "    }\n",
       "    else {\n",
       "        // location in version 2\n",
       "        IPython.keyboard_manager.register_events(el);\n",
       "    }\n",
       "\n",
       "}\n",
       "\n",
       "mpl.figure.prototype._key_event_extra = function(event, name) {\n",
       "    var manager = IPython.notebook.keyboard_manager;\n",
       "    if (!manager)\n",
       "        manager = IPython.keyboard_manager;\n",
       "\n",
       "    // Check for shift+enter\n",
       "    if (event.shiftKey && event.which == 13) {\n",
       "        this.canvas_div.blur();\n",
       "        event.shiftKey = false;\n",
       "        // Send a \"J\" for go to next cell\n",
       "        event.which = 74;\n",
       "        event.keyCode = 74;\n",
       "        manager.command_mode();\n",
       "        manager.handle_keydown(event);\n",
       "    }\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.handle_save = function(fig, msg) {\n",
       "    fig.ondownload(fig, null);\n",
       "}\n",
       "\n",
       "\n",
       "mpl.find_output_cell = function(html_output) {\n",
       "    // Return the cell and output element which can be found *uniquely* in the notebook.\n",
       "    // Note - this is a bit hacky, but it is done because the \"notebook_saving.Notebook\"\n",
       "    // IPython event is triggered only after the cells have been serialised, which for\n",
       "    // our purposes (turning an active figure into a static one), is too late.\n",
       "    var cells = IPython.notebook.get_cells();\n",
       "    var ncells = cells.length;\n",
       "    for (var i=0; i<ncells; i++) {\n",
       "        var cell = cells[i];\n",
       "        if (cell.cell_type === 'code'){\n",
       "            for (var j=0; j<cell.output_area.outputs.length; j++) {\n",
       "                var data = cell.output_area.outputs[j];\n",
       "                if (data.data) {\n",
       "                    // IPython >= 3 moved mimebundle to data attribute of output\n",
       "                    data = data.data;\n",
       "                }\n",
       "                if (data['text/html'] == html_output) {\n",
       "                    return [cell, data, j];\n",
       "                }\n",
       "            }\n",
       "        }\n",
       "    }\n",
       "}\n",
       "\n",
       "// Register the function which deals with the matplotlib target/channel.\n",
       "// The kernel may be null if the page has been refreshed.\n",
       "if (IPython.notebook.kernel != null) {\n",
       "    IPython.notebook.kernel.comm_manager.register_target('matplotlib', mpl.mpl_figure_comm);\n",
       "}\n"
      ],
      "text/plain": [
       "<IPython.core.display.Javascript object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/html": [
       "<img src=\"data:image/png;base64,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\" width=\"432\">"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Min numerical gradient: 7.59E-07\n"
     ]
    }
   ],
   "source": [
    "learn.lr_find()\n",
    "learn.recorder.plot()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "Total time: 08:41 <p><table style='width:300px; margin-bottom:10px'>\n",
       "  <tr>\n",
       "    <th>epoch</th>\n",
       "    <th>train_loss</th>\n",
       "    <th>valid_loss</th>\n",
       "    <th>error_rate</th>\n",
       "  </tr>\n",
       "  <tr>\n",
       "    <th>1</th>\n",
       "    <th>0.460696</th>\n",
       "    <th>0.321146</th>\n",
       "    <th>0.135396</th>\n",
       "  </tr>\n",
       "  <tr>\n",
       "    <th>2</th>\n",
       "    <th>0.342945</th>\n",
       "    <th>0.241173</th>\n",
       "    <th>0.087278</th>\n",
       "  </tr>\n",
       "  <tr>\n",
       "    <th>3</th>\n",
       "    <th>0.288708</th>\n",
       "    <th>0.220447</th>\n",
       "    <th>0.088688</th>\n",
       "  </tr>\n",
       "  <tr>\n",
       "    <th>4</th>\n",
       "    <th>0.260829</th>\n",
       "    <th>0.199142</th>\n",
       "    <th>0.078483</th>\n",
       "  </tr>\n",
       "  <tr>\n",
       "    <th>5</th>\n",
       "    <th>0.243270</th>\n",
       "    <th>0.199171</th>\n",
       "    <th>0.078566</th>\n",
       "  </tr>\n",
       "  <tr>\n",
       "    <th>6</th>\n",
       "    <th>0.231282</th>\n",
       "    <th>0.196666</th>\n",
       "    <th>0.076534</th>\n",
       "  </tr>\n",
       "  <tr>\n",
       "    <th>7</th>\n",
       "    <th>0.219505</th>\n",
       "    <th>0.199362</th>\n",
       "    <th>0.076285</th>\n",
       "  </tr>\n",
       "  <tr>\n",
       "    <th>8</th>\n",
       "    <th>0.208752</th>\n",
       "    <th>0.200745</th>\n",
       "    <th>0.076824</th>\n",
       "  </tr>\n",
       "</table>\n"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "learn.fit_one_cycle(3,max_lr=5.25e-3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [],
   "source": [
    "learn.save('stage-1-50')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "It's astonishing that it's possible to recognize pet breeds so accurately! Let's see if full fine-tuning helps:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "Total time: 03:30 <p><table style='width:300px; margin-bottom:10px'>\n",
       "  <tr>\n",
       "    <th>epoch</th>\n",
       "    <th>train_loss</th>\n",
       "    <th>valid_loss</th>\n",
       "    <th>error_rate</th>\n",
       "  </tr>\n",
       "  <tr>\n",
       "    <th>1</th>\n",
       "    <th>0.199697</th>\n",
       "    <th>0.200821</th>\n",
       "    <th>0.076741</th>\n",
       "  </tr>\n",
       "  <tr>\n",
       "    <th>2</th>\n",
       "    <th>0.199232</th>\n",
       "    <th>0.200608</th>\n",
       "    <th>0.076368</th>\n",
       "  </tr>\n",
       "  <tr>\n",
       "    <th>3</th>\n",
       "    <th>0.199673</th>\n",
       "    <th>0.200743</th>\n",
       "    <th>0.077239</th>\n",
       "  </tr>\n",
       "</table>\n"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "learn.unfreeze()\n",
    "learn.fit_one_cycle(3, max_lr=slice(1e-8,1e-6))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If it doesn't, you can always go back to your previous model."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "ename": "NameError",
     "evalue": "name 'learn' is not defined",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mNameError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-1-119754ed3d78>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mlearn\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mload\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m'stage-1-50'\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m;\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mNameError\u001b[0m: name 'learn' is not defined"
     ]
    }
   ],
   "source": [
    "learn.load('stage-1-50');"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "interp = ClassificationInterpretation.from_learner(learn)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[('american_pit_bull_terrier', 'staffordshire_bull_terrier', 6),\n",
       " ('Bengal', 'Egyptian_Mau', 5),\n",
       " ('Bengal', 'Abyssinian', 4),\n",
       " ('boxer', 'american_bulldog', 4),\n",
       " ('Ragdoll', 'Birman', 4),\n",
       " ('Egyptian_Mau', 'Bengal', 3)]"
      ]
     },
     "execution_count": null,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "interp.most_confused(min_val=2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Other data formats"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "PosixPath('/home/ubuntu/course-v3/nbs/dl1/data/mnist_sample')"
      ]
     },
     "execution_count": null,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "path = untar_data(URLs.MNIST_SAMPLE); path"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "tfms = get_transforms(do_flip=False)\n",
    "data = ImageDataBunch.from_folder(path, ds_tfms=tfms, size=26)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 360x360 with 9 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "data.show_batch(rows=3, figsize=(5,5))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Total time: 00:23\n",
      "epoch  train_loss  valid_loss  accuracy\n",
      "1      0.116117    0.029745    0.991168  (00:12)\n",
      "2      0.056860    0.015974    0.994603  (00:10)\n",
      "\n"
     ]
    }
   ],
   "source": [
    "learn = create_cnn(data, models.resnet18, metrics=accuracy)\n",
    "learn.fit(2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>name</th>\n",
       "      <th>label</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>train/3/7463.png</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>train/3/21102.png</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>train/3/31559.png</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>train/3/46882.png</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>train/3/26209.png</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "                name  label\n",
       "0   train/3/7463.png      0\n",
       "1  train/3/21102.png      0\n",
       "2  train/3/31559.png      0\n",
       "3  train/3/46882.png      0\n",
       "4  train/3/26209.png      0"
      ]
     },
     "execution_count": null,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df = pd.read_csv(path/'labels.csv')\n",
    "df.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "data = ImageDataBunch.from_csv(path, ds_tfms=tfms, size=28)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[0, 1]"
      ]
     },
     "execution_count": null,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 360x360 with 9 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "data.show_batch(rows=3, figsize=(5,5))\n",
    "data.classes"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[0, 1]"
      ]
     },
     "execution_count": null,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "data = ImageDataBunch.from_df(path, df, ds_tfms=tfms, size=24)\n",
    "data.classes"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[PosixPath('/home/ubuntu/course-v3/nbs/dl1/data/mnist_sample/train/3/7463.png'),\n",
       " PosixPath('/home/ubuntu/course-v3/nbs/dl1/data/mnist_sample/train/3/21102.png')]"
      ]
     },
     "execution_count": null,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "fn_paths = [path/name for name in df['name']]; fn_paths[:2]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['3', '7']"
      ]
     },
     "execution_count": null,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "pat = r\"/(\\d)/\\d+\\.png$\"\n",
    "data = ImageDataBunch.from_name_re(path, fn_paths, pat=pat, ds_tfms=tfms, size=24)\n",
    "data.classes"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['3', '7']"
      ]
     },
     "execution_count": null,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "data = ImageDataBunch.from_name_func(path, fn_paths, ds_tfms=tfms, size=24,\n",
    "        label_func = lambda x: '3' if '/3/' in str(x) else '7')\n",
    "data.classes"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['3', '3', '3', '3', '3']"
      ]
     },
     "execution_count": null,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "labels = [('3' if '/3/' in str(x) else '7') for x in fn_paths]\n",
    "labels[:5]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['3', '7']"
      ]
     },
     "execution_count": null,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "data = ImageDataBunch.from_lists(path, fn_paths, labels=labels, ds_tfms=tfms, size=24)\n",
    "data.classes"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "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.6.8"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}