05_pet_breeds.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#hide\n",
    "! [ -e /content ] && pip install -Uqq fastbook\n",
    "import fastbook\n",
    "fastbook.setup_book()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#hide\n",
    "from fastbook import *"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "[[chapter_pet_breeds]]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Image Classification"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now that you understand what deep learning is, what it's for, and how to create and deploy a model, it's time for us to go deeper! In an ideal world deep learning practitioners wouldn't have to know every detail of how things work under the hood… But as yet, we don't live in an ideal world. The truth is, to make your model really work, and work reliably, there are a lot of details you have to get right, and a lot of details that you have to check. This process requires being able to look inside your neural network as it trains, and as it makes predictions, find possible problems, and know how to fix them.\n",
    "\n",
    "So, from here on in the book we are going to do a deep dive into the mechanics of deep learning. What is the architecture of a computer vision model, an NLP model, a tabular model, and so on? How do you create an architecture that matches the needs of your particular domain? How do you get the best possible results from the training process? How do you make things faster? What do you have to change as your datasets change?\n",
    "\n",
    "We will start by repeating the same basic applications that we looked at in the first chapter, but we are going to do two things:\n",
    "\n",
    "- Make them better.\n",
    "- Apply them to a wider variety of types of data.\n",
    "\n",
    "In order to do these two things, we will have to learn all of the pieces of the deep learning puzzle. This includes different types of layers, regularization methods, optimizers, how to put layers together into architectures, labeling techniques, and much more. We are not just going to dump all of these things on you, though; we will introduce them progressively as needed, to solve actual problems related to the projects we are working on."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## From Dogs and Cats to Pet Breeds"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In our very first model we learned how to classify dogs versus cats. Just a few years ago this was considered a very challenging task—but today, it's far too easy! We will not be able to show you the nuances of training models with this problem, because we get a nearly perfect result without worrying about any of the details. But it turns out that the same dataset also allows us to work on a much more challenging problem: figuring out what breed of pet is shown in each image.\n",
    "\n",
    "In <<chapter_intro>> we presented the applications as already-solved problems. But this is not how things work in real life. We start with some dataset that we know nothing about. We then have to figure out how it is put together, how to extract the data we need from it, and what that data looks like. For the rest of this book we will be showing you how to solve these problems in practice, including all of the intermediate steps necessary to understand the data that you are working with and test your modeling as you go.\n",
    "\n",
    "We already downloaded the Pet dataset, and we can get a path to this dataset using the same code as in <<chapter_intro>>:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from fastai.vision.all import *\n",
    "path = untar_data(URLs.PETS)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now if we are going to understand how to extract the breed of each pet from each image we're going to need to understand how this data is laid out. Such details of data layout are a vital piece of the deep learning puzzle. Data is usually provided in one of these two ways:\n",
    "\n",
    "- Individual files representing items of data, such as text documents or images, possibly organized into folders or with filenames representing information about those items\n",
    "- A table of data, such as in CSV format, where each row is an item which may include filenames providing a connection between the data in the table and data in other formats, such as text documents and images\n",
    "\n",
    "There are exceptions to these rules—particularly in domains such as genomics, where there can be binary database formats or even network streams—but overall the vast majority of the datasets you'll work with will use some combination of these two formats.\n",
    "\n",
    "To see what is in our dataset we can use the `ls` method:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#hide\n",
    "Path.BASE_PATH = path"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(#3) [Path('annotations'),Path('images'),Path('models')]"
      ]
     },
     "execution_count": null,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "path.ls()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can see that this dataset provides us with *images* and *annotations* directories. The [website](https://www.robots.ox.ac.uk/~vgg/data/pets/) for the dataset tells us that the *annotations* directory contains information about where the pets are rather than what they are. In this chapter, we will be doing classification, not localization, which is to say that we care about what the pets are, not where they are. Therefore, we will ignore the *annotations* directory for now. So, let's have a look inside the *images* directory:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(#7394) [Path('images/great_pyrenees_173.jpg'),Path('images/wheaten_terrier_46.jpg'),Path('images/Ragdoll_262.jpg'),Path('images/german_shorthaired_3.jpg'),Path('images/american_bulldog_196.jpg'),Path('images/boxer_188.jpg'),Path('images/staffordshire_bull_terrier_173.jpg'),Path('images/basset_hound_71.jpg'),Path('images/staffordshire_bull_terrier_37.jpg'),Path('images/yorkshire_terrier_18.jpg')...]"
      ]
     },
     "execution_count": null,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(path/\"images\").ls()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Most functions and methods in fastai that return a collection use a class called `L`. `L` can be thought of as an enhanced version of the ordinary Python `list` type, with added conveniences for common operations. For instance, when we display an object of this class in a notebook it appears in the format shown there. The first thing that is shown is the number of items in the collection, prefixed with a `#`. You'll also see in the preceding output that the list is suffixed with an ellipsis. This means that only the first few items are displayed—which is a good thing, because we would not want more than 7,000 filenames on our screen!\n",
    "\n",
    "By examining these filenames, we can see how they appear to be structured. Each filename contains the pet breed, and then an underscore (`_`), a number, and finally the file extension. We need to create a piece of code that extracts the breed from a single `Path`. Jupyter notebooks make this easy, because we can gradually build up something that works, and then use it for the entire dataset. We do have to be careful to not make too many assumptions at this point. For instance, if you look carefully you may notice that some of the pet breeds contain multiple words, so we cannot simply break at the first `_` character that we find. To allow us to test our code, let's pick out one of these filenames:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "fname = (path/\"images\").ls()[0]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The most powerful and flexible way to extract information from strings like this is to use a *regular expression*, also known as a *regex*. A regular expression is a special string, written in the regular expression language, which specifies a general rule for deciding if another string passes a test (i.e., \"matches\" the regular expression), and also possibly for plucking a particular part or parts out of that other string. \n",
    "\n",
    "In this case, we need a regular expression that extracts the pet breed from the filename.\n",
    "\n",
    "We do not have the space to give you a complete regular expression tutorial here, but there are many excellent ones online and we know that many of you will already be familiar with this wonderful tool. If you're not, that is totally fine—this is a great opportunity for you to rectify that! We find that regular expressions are one of the most useful tools in our programming toolkit, and many of our students tell us that this is one of the things they are most excited to learn about. So head over to Google and search for \"regular expressions tutorial\" now, and then come back here after you've had a good look around. The [book's website](https://book.fast.ai/) also provides a list of our favorites.\n",
    "\n",
    "> a: Not only are regular expressions dead handy, but they also have interesting roots. They are \"regular\" because they were originally examples of a \"regular\" language, the lowest rung within the Chomsky hierarchy, a grammar classification developed by linguist Noam Chomsky, who also wrote _Syntactic Structures_, the pioneering work searching for the formal grammar underlying human language. This is one of the charms of computing: it may be that the hammer you reach for every day in fact came from a spaceship.\n",
    "\n",
    "When you are writing a regular expression, the best way to start is just to try it against one example at first. Let's use the `findall` method to try a regular expression against the filename of the `fname` object:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['great_pyrenees']"
      ]
     },
     "execution_count": null,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "re.findall(r'(.+)_\\d+.jpg$', fname.name)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This regular expression plucks out all the characters leading up to the last underscore character, as long as the subsequence characters are numerical digits and then the JPEG file extension.\n",
    "\n",
    "Now that we confirmed the regular expression works for the example, let's use it to label the whole dataset. fastai comes with many classes to help with labeling. For labeling with regular expressions, we can use the `RegexLabeller` class. In this example we use the data block API we saw in <<chapter_production>> (in fact, we nearly always use the data block API—it's so much more flexible than the simple factory methods we saw in <<chapter_intro>>):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "pets = DataBlock(blocks = (ImageBlock, CategoryBlock),\n",
    "                 get_items=get_image_files, \n",
    "                 splitter=RandomSplitter(seed=42),\n",
    "                 get_y=using_attr(RegexLabeller(r'(.+)_\\d+.jpg$'), 'name'),\n",
    "                 item_tfms=Resize(460),\n",
    "                 batch_tfms=aug_transforms(size=224, min_scale=0.75))\n",
    "dls = pets.dataloaders(path/\"images\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "One important piece of this `DataBlock` call that we haven't seen before is in these two lines:\n",
    "\n",
    "```python\n",
    "item_tfms=Resize(460),\n",
    "batch_tfms=aug_transforms(size=224, min_scale=0.75)\n",
    "```\n",
    "\n",
    "These lines implement a fastai data augmentation strategy which we call *presizing*. Presizing is a particular way to do image augmentation that is designed to minimize data destruction while maintaining good performance."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Presizing"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We need our images to have the same dimensions, so that they can collate into tensors to be passed to the GPU. We also want to minimize the number of distinct augmentation computations we perform. The performance requirement suggests that we should, where possible, compose our augmentation transforms into fewer transforms (to reduce the number of computations and the number of lossy operations) and transform the images into uniform sizes (for more efficient processing on the GPU).\n",
    "\n",
    "The challenge is that, if performed after resizing down to the augmented size, various common data augmentation transforms might introduce spurious empty zones, degrade data, or both. For instance, rotating an image by 45 degrees fills corner regions of the new bounds with emptiness, which will not teach the model anything. Many rotation and zooming operations will require interpolating to create pixels. These interpolated pixels are derived from the original image data but are still of lower quality.\n",
    "\n",
    "To work around these challenges, presizing adopts two strategies that are shown in <<presizing>>:\n",
    "\n",
    "1. Resize images to relatively \"large\" dimensions—that is, dimensions significantly larger than the target training dimensions. \n",
    "1. Compose all of the common augmentation operations (including a resize to the final target size) into one, and perform the combined operation on the GPU only once at the end of processing, rather than performing the operations individually and interpolating multiple times.\n",
    "\n",
    "The first step, the resize, creates images large enough that they have spare margin to allow further augmentation transforms on their inner regions without creating empty zones. This transformation works by resizing to a square, using a large crop size. On the training set, the crop area is chosen randomly, and the size of the crop is selected to cover the entire width or height of the image, whichever is smaller.\n",
    "\n",
    "In the second step, the GPU is used for all data augmentation, and all of the potentially destructive operations are done together, with a single interpolation at the end."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<img alt=\"Presizing on the training set\" width=\"600\" caption=\"Presizing on the training set\" id=\"presizing\" src=\"images/att_00060.png\">"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This picture shows the two steps:\n",
    "\n",
    "1. *Crop full width or height*: This is in `item_tfms`, so it's applied to each individual image before it is copied to the GPU. It's used to ensure all images are the same size. On the training set, the crop area is chosen randomly. On the validation set, the center square of the image is always chosen.\n",
    "2. *Random crop and augment*: This is in `batch_tfms`, so it's applied to a batch all at once on the GPU, which means it's fast. On the validation set, only the resize to the final size needed for the model is done here. On the training set, the random crop and any other augmentations are done first.\n",
    "\n",
    "To implement this process in fastai you use `Resize` as an item transform with a large size, and `RandomResizedCrop` as a batch transform with a smaller size. `RandomResizedCrop` will be added for you if you include the `min_scale` parameter in your `aug_transforms` function, as was done in the `DataBlock` call in the previous section. Alternatively, you can use `pad` or `squish` instead of `crop` (the default) for the initial `Resize`.\n",
    "\n",
    "<<interpolations>> shows the difference between an image that has been zoomed, interpolated, rotated, and then interpolated again (which is the approach used by all other deep learning libraries), shown here on the right, and an image that has been zoomed and rotated as one operation and then interpolated just once on the left (the fastai approach), shown here on the left."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hide_input": false
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x216 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "#hide_input\n",
    "#id interpolations\n",
    "#caption A comparison of fastai's data augmentation strategy (left) and the traditional approach (right).\n",
    "dblock1 = DataBlock(blocks=(ImageBlock(), CategoryBlock()),\n",
    "                   get_y=parent_label,\n",
    "                   item_tfms=Resize(460))\n",
    "# Place an image in the 'images/grizzly.jpg' subfolder where this notebook is located before running this\n",
    "dls1 = dblock1.dataloaders([(Path.cwd()/'images'/'grizzly.jpg')]*100, bs=8)\n",
    "dls1.train.get_idxs = lambda: Inf.ones\n",
    "x,y = dls1.valid.one_batch()\n",
    "_,axs = subplots(1, 2)\n",
    "\n",
    "x1 = TensorImage(x.clone())\n",
    "x1 = x1.affine_coord(sz=224)\n",
    "x1 = x1.rotate(draw=30, p=1.)\n",
    "x1 = x1.zoom(draw=1.2, p=1.)\n",
    "x1 = x1.warp(draw_x=-0.2, draw_y=0.2, p=1.)\n",
    "\n",
    "tfms = setup_aug_tfms([Rotate(draw=30, p=1, size=224), Zoom(draw=1.2, p=1., size=224),\n",
    "                       Warp(draw_x=-0.2, draw_y=0.2, p=1., size=224)])\n",
    "x = Pipeline(tfms)(x)\n",
    "#x.affine_coord(coord_tfm=coord_tfm, sz=size, mode=mode, pad_mode=pad_mode)\n",
    "TensorImage(x[0]).show(ctx=axs[0])\n",
    "TensorImage(x1[0]).show(ctx=axs[1]);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can see that the image on the right is less well defined and has reflection padding artifacts in the bottom-left corner; also, the grass at the top left has disappeared entirely. We find that in practice using presizing significantly improves the accuracy of models, and often results in speedups too.\n",
    "\n",
    "The fastai library also provides simple ways to check your data looks right before training a model, which is an extremely important step. We'll look at those next."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Checking and Debugging a DataBlock"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can never just assume that our code is working perfectly. Writing a `DataBlock` is just like writing a blueprint. You will get an error message if you have a syntax error somewhere in your code, but you have no guarantee that your template is going to work on your data source as you intend. So, before training a model you should always check your data. You can do this using the `show_batch` method:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 648x216 with 3 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "dls.show_batch(nrows=1, ncols=3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Take a look at each image, and check that each one seems to have the correct label for that breed of pet. Often, data scientists work with data with which they are not as familiar as domain experts may be: for instance, I actually don't know what a lot of these pet breeds are. Since I am not an expert on pet breeds, I would use Google images at this point to search for a few of these breeds, and make sure the images look similar to what I see in this output.\n",
    "\n",
    "If you made a mistake while building your `DataBlock`, it is very likely you won't see it before this step. To debug this, we encourage you to use the `summary` method. It will attempt to create a batch from the source you give it, with a lot of details. Also, if it fails, you will see exactly at which point the error happens, and the library will try to give you some help. For instance, one common mistake is to forget to use a `Resize` transform, so you end up with pictures of different sizes and are not able to batch them. Here is what the summary would look like in that case (note that the exact text may have changed since the time of writing, but it will give you an idea):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Setting-up type transforms pipelines\n",
      "Collecting items from /home/jhoward/.fastai/data/oxford-iiit-pet/images\n",
      "Found 7390 items\n",
      "2 datasets of sizes 5912,1478\n",
      "Setting up Pipeline: PILBase.create\n",
      "Setting up Pipeline: partial -> Categorize\n",
      "\n",
      "Building one sample\n",
      "  Pipeline: PILBase.create\n",
      "    starting from\n",
      "      /home/jhoward/.fastai/data/oxford-iiit-pet/images/american_pit_bull_terrier_31.jpg\n",
      "    applying PILBase.create gives\n",
      "      PILImage mode=RGB size=500x414\n",
      "  Pipeline: partial -> Categorize\n",
      "    starting from\n",
      "      /home/jhoward/.fastai/data/oxford-iiit-pet/images/american_pit_bull_terrier_31.jpg\n",
      "    applying partial gives\n",
      "      american_pit_bull_terrier\n",
      "    applying Categorize gives\n",
      "      TensorCategory(13)\n",
      "\n",
      "Final sample: (PILImage mode=RGB size=500x414, TensorCategory(13))\n",
      "\n",
      "\n",
      "Setting up after_item: Pipeline: ToTensor\n",
      "Setting up before_batch: Pipeline: \n",
      "Setting up after_batch: Pipeline: IntToFloatTensor\n",
      "\n",
      "Building one batch\n",
      "Applying item_tfms to the first sample:\n",
      "  Pipeline: ToTensor\n",
      "    starting from\n",
      "      (PILImage mode=RGB size=500x414, TensorCategory(13))\n",
      "    applying ToTensor gives\n",
      "      (TensorImage of size 3x414x500, TensorCategory(13))\n",
      "\n",
      "Adding the next 3 samples\n",
      "\n",
      "No before_batch transform to apply\n",
      "\n",
      "Collating items in a batch\n",
      "Error! It's not possible to collate your items in a batch\n",
      "Could not collate the 0-th members of your tuples because got the following shapes\n",
      "torch.Size([3, 414, 500]),torch.Size([3, 375, 500]),torch.Size([3, 500, 281]),torch.Size([3, 203, 300])\n"
     ]
    },
    {
     "ename": "RuntimeError",
     "evalue": "invalid argument 0: Sizes of tensors must match except in dimension 0. Got 414 and 375 in dimension 2 at /opt/conda/conda-bld/pytorch_1579022060824/work/aten/src/TH/generic/THTensor.cpp:612",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mRuntimeError\u001b[0m                              Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-11-8c0a3d421ca2>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[1;32m      4\u001b[0m                  \u001b[0msplitter\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mRandomSplitter\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mseed\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;36m42\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[1;32m      5\u001b[0m                  get_y=using_attr(RegexLabeller(r'(.+)_\\d+.jpg$'), 'name'))\n\u001b[0;32m----> 6\u001b[0;31m \u001b[0mpets1\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0msummary\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mpath\u001b[0m\u001b[0;34m/\u001b[0m\u001b[0;34m\"images\"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;32m~/git/fastai/fastai/data/block.py\u001b[0m in \u001b[0;36msummary\u001b[0;34m(self, source, bs, show_batch, **kwargs)\u001b[0m\n\u001b[1;32m    182\u001b[0m         \u001b[0mwhy\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0m_find_fail_collate\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0ms\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    183\u001b[0m         \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m\"Make sure all parts of your samples are tensors of the same size\"\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0mwhy\u001b[0m \u001b[0;32mis\u001b[0m \u001b[0;32mNone\u001b[0m \u001b[0;32melse\u001b[0m \u001b[0mwhy\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 184\u001b[0;31m         \u001b[0;32mraise\u001b[0m \u001b[0me\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    185\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    186\u001b[0m     \u001b[0;32mif\u001b[0m \u001b[0mlen\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mf\u001b[0m \u001b[0;32mfor\u001b[0m \u001b[0mf\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mdls\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mtrain\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mafter_batch\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mfs\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0mf\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mname\u001b[0m \u001b[0;34m!=\u001b[0m \u001b[0;34m'noop'\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m!=\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m~/git/fastai/fastai/data/block.py\u001b[0m in \u001b[0;36msummary\u001b[0;34m(self, source, bs, show_batch, **kwargs)\u001b[0m\n\u001b[1;32m    176\u001b[0m     \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m\"\\nCollating items in a batch\"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    177\u001b[0m     \u001b[0;32mtry\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 178\u001b[0;31m         \u001b[0mb\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mdls\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mtrain\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcreate_batch\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0ms\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    179\u001b[0m         \u001b[0mb\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mretain_types\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mb\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0ms\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0mis_listy\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0ms\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;32melse\u001b[0m \u001b[0ms\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    180\u001b[0m     \u001b[0;32mexcept\u001b[0m \u001b[0mException\u001b[0m \u001b[0;32mas\u001b[0m \u001b[0me\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m~/git/fastai/fastai/data/load.py\u001b[0m in \u001b[0;36mcreate_batch\u001b[0;34m(self, b)\u001b[0m\n\u001b[1;32m    125\u001b[0m     \u001b[0;32mdef\u001b[0m \u001b[0mretain\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mres\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mb\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m  \u001b[0;32mreturn\u001b[0m \u001b[0mretain_types\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mres\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mb\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0mis_listy\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mb\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;32melse\u001b[0m \u001b[0mb\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    126\u001b[0m     \u001b[0;32mdef\u001b[0m \u001b[0mcreate_item\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0ms\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m  \u001b[0;32mreturn\u001b[0m \u001b[0mnext\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mit\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0ms\u001b[0m \u001b[0;32mis\u001b[0m \u001b[0;32mNone\u001b[0m \u001b[0;32melse\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mdataset\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0ms\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 127\u001b[0;31m     \u001b[0;32mdef\u001b[0m \u001b[0mcreate_batch\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mb\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0;32mreturn\u001b[0m \u001b[0;34m(\u001b[0m\u001b[0mfa_collate\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mfa_convert\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mprebatched\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mb\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    128\u001b[0m     \u001b[0;32mdef\u001b[0m \u001b[0mdo_batch\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mb\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0;32mreturn\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mretain\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcreate_batch\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mbefore_batch\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mb\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mb\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    129\u001b[0m     \u001b[0;32mdef\u001b[0m \u001b[0mto\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mdevice\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mdevice\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mdevice\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m~/git/fastai/fastai/data/load.py\u001b[0m in \u001b[0;36mfa_collate\u001b[0;34m(t)\u001b[0m\n\u001b[1;32m     44\u001b[0m     \u001b[0mb\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mt\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     45\u001b[0m     return (default_collate(t) if isinstance(b, _collate_types)\n\u001b[0;32m---> 46\u001b[0;31m             \u001b[0;32melse\u001b[0m \u001b[0mtype\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mt\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mfa_collate\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0ms\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;32mfor\u001b[0m \u001b[0ms\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mzip\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0mt\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0misinstance\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mb\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mSequence\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     47\u001b[0m             else default_collate(t))\n\u001b[1;32m     48\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m~/git/fastai/fastai/data/load.py\u001b[0m in \u001b[0;36m<listcomp>\u001b[0;34m(.0)\u001b[0m\n\u001b[1;32m     44\u001b[0m     \u001b[0mb\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mt\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     45\u001b[0m     return (default_collate(t) if isinstance(b, _collate_types)\n\u001b[0;32m---> 46\u001b[0;31m             \u001b[0;32melse\u001b[0m \u001b[0mtype\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mt\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mfa_collate\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0ms\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;32mfor\u001b[0m \u001b[0ms\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mzip\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0mt\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0misinstance\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mb\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mSequence\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     47\u001b[0m             else default_collate(t))\n\u001b[1;32m     48\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m~/git/fastai/fastai/data/load.py\u001b[0m in \u001b[0;36mfa_collate\u001b[0;34m(t)\u001b[0m\n\u001b[1;32m     43\u001b[0m \u001b[0;32mdef\u001b[0m \u001b[0mfa_collate\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mt\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[1;32m     44\u001b[0m     \u001b[0mb\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mt\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 45\u001b[0;31m     return (default_collate(t) if isinstance(b, _collate_types)\n\u001b[0m\u001b[1;32m     46\u001b[0m             \u001b[0;32melse\u001b[0m \u001b[0mtype\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mt\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mfa_collate\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0ms\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;32mfor\u001b[0m \u001b[0ms\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mzip\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0mt\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0misinstance\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mb\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mSequence\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     47\u001b[0m             else default_collate(t))\n",
      "\u001b[0;32m~/anaconda3/lib/python3.7/site-packages/torch/utils/data/_utils/collate.py\u001b[0m in \u001b[0;36mdefault_collate\u001b[0;34m(batch)\u001b[0m\n\u001b[1;32m     53\u001b[0m             \u001b[0mstorage\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0melem\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mstorage\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_new_shared\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mnumel\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     54\u001b[0m             \u001b[0mout\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0melem\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mnew\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mstorage\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 55\u001b[0;31m         \u001b[0;32mreturn\u001b[0m \u001b[0mtorch\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mstack\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mbatch\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m0\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mout\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mout\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     56\u001b[0m     \u001b[0;32melif\u001b[0m \u001b[0melem_type\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m__module__\u001b[0m \u001b[0;34m==\u001b[0m \u001b[0;34m'numpy'\u001b[0m \u001b[0;32mand\u001b[0m \u001b[0melem_type\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m__name__\u001b[0m \u001b[0;34m!=\u001b[0m \u001b[0;34m'str_'\u001b[0m\u001b[0;31m \u001b[0m\u001b[0;31m\\\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     57\u001b[0m             \u001b[0;32mand\u001b[0m \u001b[0melem_type\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m__name__\u001b[0m \u001b[0;34m!=\u001b[0m \u001b[0;34m'string_'\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;31mRuntimeError\u001b[0m: invalid argument 0: Sizes of tensors must match except in dimension 0. Got 414 and 375 in dimension 2 at /opt/conda/conda-bld/pytorch_1579022060824/work/aten/src/TH/generic/THTensor.cpp:612"
     ]
    }
   ],
   "source": [
    "#hide_output\n",
    "pets1 = DataBlock(blocks = (ImageBlock, CategoryBlock),\n",
    "                 get_items=get_image_files, \n",
    "                 splitter=RandomSplitter(seed=42),\n",
    "                 get_y=using_attr(RegexLabeller(r'(.+)_\\d+.jpg$'), 'name'))\n",
    "pets1.summary(path/\"images\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "```\n",
    "Setting-up type transforms pipelines\n",
    "Collecting items from /home/sgugger/.fastai/data/oxford-iiit-pet/images\n",
    "Found 7390 items\n",
    "2 datasets of sizes 5912,1478\n",
    "Setting up Pipeline: PILBase.create\n",
    "Setting up Pipeline: partial -> Categorize\n",
    "\n",
    "Building one sample\n",
    "  Pipeline: PILBase.create\n",
    "    starting from\n",
    "      /home/sgugger/.fastai/data/oxford-iiit-pet/images/american_bulldog_83.jpg\n",
    "    applying PILBase.create gives\n",
    "      PILImage mode=RGB size=375x500\n",
    "  Pipeline: partial -> Categorize\n",
    "    starting from\n",
    "      /home/sgugger/.fastai/data/oxford-iiit-pet/images/american_bulldog_83.jpg\n",
    "    applying partial gives\n",
    "      american_bulldog\n",
    "    applying Categorize gives\n",
    "      TensorCategory(12)\n",
    "\n",
    "Final sample: (PILImage mode=RGB size=375x500, TensorCategory(12))\n",
    "\n",
    "Setting up after_item: Pipeline: ToTensor\n",
    "Setting up before_batch: Pipeline: \n",
    "Setting up after_batch: Pipeline: IntToFloatTensor\n",
    "\n",
    "Building one batch\n",
    "Applying item_tfms to the first sample:\n",
    "  Pipeline: ToTensor\n",
    "    starting from\n",
    "      (PILImage mode=RGB size=375x500, TensorCategory(12))\n",
    "    applying ToTensor gives\n",
    "      (TensorImage of size 3x500x375, TensorCategory(12))\n",
    "\n",
    "Adding the next 3 samples\n",
    "\n",
    "No before_batch transform to apply\n",
    "\n",
    "Collating items in a batch\n",
    "Error! It's not possible to collate your items in a batch\n",
    "Could not collate the 0-th members of your tuples because got the following \n",
    "shapes:\n",
    "torch.Size([3, 500, 375]),torch.Size([3, 375, 500]),torch.Size([3, 333, 500]),\n",
    "torch.Size([3, 375, 500])\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can see exactly how we gathered the data and split it, how we went from a filename to a *sample* (the tuple (image, category)), then what item transforms were applied and how it failed to collate those samples in a batch (because of the different shapes). \n",
    "\n",
    "Once you think your data looks right, we generally recommend the next step should be using it to train a simple model. We often see people put off the training of an actual model for far too long. As a result, they don't actually find out what their baseline results look like. Perhaps your problem doesn't need lots of fancy domain-specific engineering. Or perhaps the data doesn't seem to train the model at all. These are things that you want to know as soon as possible. For this initial test, we'll use the same simple model that we used in <<chapter_intro>>:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: left;\">\n",
       "      <th>epoch</th>\n",
       "      <th>train_loss</th>\n",
       "      <th>valid_loss</th>\n",
       "      <th>error_rate</th>\n",
       "      <th>time</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <td>0</td>\n",
       "      <td>1.551305</td>\n",
       "      <td>0.322132</td>\n",
       "      <td>0.106225</td>\n",
       "      <td>00:19</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/html": [
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: left;\">\n",
       "      <th>epoch</th>\n",
       "      <th>train_loss</th>\n",
       "      <th>valid_loss</th>\n",
       "      <th>error_rate</th>\n",
       "      <th>time</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <td>0</td>\n",
       "      <td>0.529473</td>\n",
       "      <td>0.312148</td>\n",
       "      <td>0.095399</td>\n",
       "      <td>00:23</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>1</td>\n",
       "      <td>0.330207</td>\n",
       "      <td>0.245883</td>\n",
       "      <td>0.080514</td>\n",
       "      <td>00:24</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "learn = vision_learner(dls, resnet34, metrics=error_rate)\n",
    "learn.fine_tune(2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As we've briefly discussed before, the table shown when we fit a model shows us the results after each epoch of training. Remember, an epoch is one complete pass through all of the images in the data. The columns shown are the average loss over the items of the training set, the loss on the validation set, and any metrics that we requested—in this case, the error rate.\n",
    "\n",
    "Remember that *loss* is whatever function we've decided to use to optimize the parameters of our model. But we haven't actually told fastai what loss function we want to use. So what is it doing? fastai will generally try to select an appropriate loss function based on what kind of data and model you are using. In this case we have image data and a categorical outcome, so fastai will default to using *cross-entropy loss*."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Cross-Entropy Loss"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "*Cross-entropy loss* is a loss function that is similar to the one we used in the previous chapter, but (as we'll see) has two benefits:\n",
    "\n",
    "- It works even when our dependent variable has more than two categories.\n",
    "- It results in faster and more reliable training.\n",
    "\n",
    "In order to understand how cross-entropy loss works for dependent variables with more than two categories, we first have to understand what the actual data and activations that are seen by the loss function look like."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Viewing Activations and Labels"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's take a look at the activations of our model. To actually get a batch of real data from our `DataLoaders`, we can use the `one_batch` method:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x,y = dls.one_batch()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As you see, this returns the dependent and independent variables, as a mini-batch. Let's see what is actually contained in our dependent variable:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "TensorCategory([ 0,  5, 23, 36,  5, 20, 29, 34, 33, 32, 31, 24, 12, 36,  8, 26, 30,  2, 12, 17,  7, 23, 12, 29, 21,  4, 35, 33,  0, 20, 26, 30,  3,  6, 36,  2, 17, 32, 11,  6,  3, 30,  5, 26, 26, 29,  7, 36,\n",
       "        31, 26, 26,  8, 13, 30, 11, 12, 36, 31, 34, 20, 15,  8,  8, 23], device='cuda:5')"
      ]
     },
     "execution_count": null,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "y"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Our batch size is 64, so we have 64 rows in this tensor. Each row is a single integer between 0 and 36, representing our 37 possible pet breeds. We can view the predictions (that is, the activations of the final layer of our neural network) using `Learner.get_preds`. This function either takes a dataset index (0 for train and 1 for valid) or an iterator of batches. Thus, we can pass it a simple list with our batch to get our predictions. It returns predictions and targets by default, but since we already have the targets, we can effectively ignore them by assigning to the special variable `_`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "tensor([9.9911e-01, 5.0433e-05, 3.7515e-07, 8.8590e-07, 8.1794e-05, 1.8991e-05, 9.9280e-06, 5.4656e-07, 6.7920e-06, 2.3486e-04, 3.7872e-04, 2.0796e-05, 4.0443e-07, 1.6933e-07, 2.0502e-07, 3.1354e-08,\n",
       "        9.4115e-08, 2.9782e-06, 2.0243e-07, 8.5262e-08, 1.0900e-07, 1.0175e-07, 4.4780e-09, 1.4285e-07, 1.0718e-07, 8.1411e-07, 3.6618e-07, 4.0950e-07, 3.8525e-08, 2.3660e-07, 5.3747e-08, 2.5448e-07,\n",
       "        6.5860e-08, 8.0937e-05, 2.7464e-07, 5.6760e-07, 1.5462e-08])"
      ]
     },
     "execution_count": null,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "preds,_ = learn.get_preds(dl=[(x,y)])\n",
    "preds[0]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The actual predictions are 37 probabilities between 0 and 1, which add up to 1 in total:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(37, tensor(1.0000))"
      ]
     },
     "execution_count": null,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len(preds[0]),preds[0].sum()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To transform the activations of our model into predictions like this, we used something called the *softmax* activation function."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Softmax"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In our classification model, we use the softmax activation function in the final layer to ensure that the activations are all between 0 and 1, and that they sum to 1.\n",
    "\n",
    "Softmax is similar to the sigmoid function, which we saw earlier. As a reminder sigmoid looks like this:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "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": [
    "plot_function(torch.sigmoid, min=-4,max=4)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can apply this function to a single column of activations from a neural network, and get back a column of numbers between 0 and 1, so it's a very useful activation function for our final layer.\n",
    "\n",
    "Now think about what happens if we want to have more categories in our target (such as our 37 pet breeds). That means we'll need more activations than just a single column: we need an activation *per category*. We can create, for instance, a neural net that predicts 3s and 7s that returns two activations, one for each class—this will be a good first step toward creating the more general approach. Let's just use some random numbers with a standard deviation of 2 (so we multiply `randn` by 2) for this example, assuming we have 6 images and 2 possible categories (where the first column represents 3s and the second is 7s):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#hide\n",
    "torch.random.manual_seed(42);"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tensor([[ 0.6734,  0.2576],\n",
       "        [ 0.4689,  0.4607],\n",
       "        [-2.2457, -0.3727],\n",
       "        [ 4.4164, -1.2760],\n",
       "        [ 0.9233,  0.5347],\n",
       "        [ 1.0698,  1.6187]])"
      ]
     },
     "execution_count": null,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "acts = torch.randn((6,2))*2\n",
    "acts"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can't just take the sigmoid of this directly, since we don't get rows that add to 1 (i.e., we want the probability of being a 3 plus the probability of being a 7 to add up to 1):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tensor([[0.6623, 0.5641],\n",
       "        [0.6151, 0.6132],\n",
       "        [0.0957, 0.4079],\n",
       "        [0.9881, 0.2182],\n",
       "        [0.7157, 0.6306],\n",
       "        [0.7446, 0.8346]])"
      ]
     },
     "execution_count": null,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "acts.sigmoid()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In <<chapter_mnist_basics>>, our neural net created a single activation per image, which we passed through the `sigmoid` function. That single activation represented the model's confidence that the input was a 3. Binary problems are a special case of classification problems, because the target can be treated as a single boolean value, as we did in `mnist_loss`. But binary problems can also be thought of in the context of the more general group of classifiers with any number of categories: in this case, we happen to have two categories. As we saw in the bear classifier, our neural net will return one activation per category.\n",
    "\n",
    "So in the binary case, what do those activations really indicate? A single pair of activations simply indicates the *relative* confidence of the input being a 3 versus being a 7. The overall values, whether they are both high, or both low, don't matter—all that matters is which is higher, and by how much.\n",
    "\n",
    "We would expect that since this is just another way of representing the same problem, that we would be able to use `sigmoid` directly on the two-activation version of our neural net. And indeed we can! We can just take the *difference* between the neural net activations, because that reflects how much more sure we are of the input being a 3 than a 7, and then take the sigmoid of that:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tensor([0.6025, 0.5021, 0.1332, 0.9966, 0.5959, 0.3661])"
      ]
     },
     "execution_count": null,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(acts[:,0]-acts[:,1]).sigmoid()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The second column (the probability of it being a 7) will then just be that value subtracted from 1. Now, we need a way to do all this that also works for more than two columns. It turns out that this function, called `softmax`, is exactly that:\n",
    "\n",
    "``` python\n",
    "def softmax(x): return exp(x) / exp(x).sum(dim=1, keepdim=True)\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> jargon: Exponential function (exp): Literally defined as `e**x`, where `e` is a special number approximately equal to 2.718. It is the inverse of the natural logarithm function. Note that `exp` is always positive, and it increases _very_ rapidly!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's check that `softmax` returns the same values as `sigmoid` for the first column, and those values subtracted from 1 for the second column:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tensor([[0.6025, 0.3975],\n",
       "        [0.5021, 0.4979],\n",
       "        [0.1332, 0.8668],\n",
       "        [0.9966, 0.0034],\n",
       "        [0.5959, 0.4041],\n",
       "        [0.3661, 0.6339]])"
      ]
     },
     "execution_count": null,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sm_acts = torch.softmax(acts, dim=1)\n",
    "sm_acts"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`softmax` is the multi-category equivalent of `sigmoid`—we have to use it any time we have more than two categories and the probabilities of the categories must add to 1, and we often use it even when there are just two categories, just to make things a bit more consistent. We could create other functions that have the properties that all activations are between 0 and 1, and sum to 1; however, no other function has the same relationship to the sigmoid function, which we've seen is smooth and symmetric. Also, we'll see shortly that the softmax function works well hand-in-hand with the loss function we will look at in the next section.\n",
    "\n",
    "If we have three output activations, such as in our bear classifier, calculating softmax for a single bear image would then look like something like <<bear_softmax>>."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<img alt=\"Bear softmax example\" width=\"280\" id=\"bear_softmax\" caption=\"Example of softmax on the bear classifier\" src=\"images/att_00062.png\">"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "What does this function do in practice? Taking the exponential ensures all our numbers are positive, and then dividing by the sum ensures we are going to have a bunch of numbers that add up to 1. The exponential also has a nice property: if one of the numbers in our activations `x` is slightly bigger than the others, the exponential will amplify this (since it grows, well... exponentially), which means that in the softmax, that number will be closer to 1. \n",
    "\n",
    "Intuitively, the softmax function *really* wants to pick one class among the others, so it's ideal for training a classifier when we know each picture has a definite label. (Note that it may be less ideal during inference, as you might want your model to sometimes tell you it doesn't recognize any of the classes that it has seen during training, and not pick a class because it has a slightly bigger activation score. In this case, it might be better to train a model using multiple binary output columns, each using a sigmoid activation.)\n",
    "\n",
    "Softmax is the first part of the cross-entropy loss—the second part is log likelihood. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Log Likelihood"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "When we calculated the loss for our MNIST example in the last chapter we used:\n",
    "\n",
    "```python\n",
    "def mnist_loss(inputs, targets):\n",
    "    inputs = inputs.sigmoid()\n",
    "    return torch.where(targets==1, 1-inputs, inputs).mean()\n",
    "```\n",
    "\n",
    "Just as we moved from sigmoid to softmax, we need to extend the loss function to work with more than just binary classification—it needs to be able to classify any number of categories (in this case, we have 37 categories). Our activations, after softmax, are between 0 and 1, and sum to 1 for each row in the batch of predictions. Our targets are integers between 0 and 36.  Furthermore, cross-entropy loss generalizes our binary classification loss and allows for more than one correct label per example (which is called multi-label classificaiton, which we will discuss in Chapter 6).\n",
    "\n",
    "In the binary case, we used `torch.where` to select between `inputs` and `1-inputs`. When we treat a binary classification as a general classification problem with two categories, it actually becomes even easier, because (as we saw in the previous section) we now have two columns, containing the equivalent of `inputs` and `1-inputs`. Since there is only one correct label per example, all we need to do is select the appropriate column (as opposed to multiplying multiple probabilities). Let's try to implement this in PyTorch. For our synthetic 3s and 7s example, let's say these are our labels:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "targ = tensor([0,1,0,1,1,0])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "and these are the softmax activations:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tensor([[0.6025, 0.3975],\n",
       "        [0.5021, 0.4979],\n",
       "        [0.1332, 0.8668],\n",
       "        [0.9966, 0.0034],\n",
       "        [0.5959, 0.4041],\n",
       "        [0.3661, 0.6339]])"
      ]
     },
     "execution_count": null,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sm_acts"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Then for each item of `targ` we can use that to select the appropriate column of `sm_acts` using tensor indexing, like so:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tensor([0.6025, 0.4979, 0.1332, 0.0034, 0.4041, 0.3661])"
      ]
     },
     "execution_count": null,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "idx = range(6)\n",
    "sm_acts[idx, targ]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To see exactly what's happening here, let's put all the columns together in a table. Here, the first two columns are our activations, then we have the targets and the row index.  We explain the last column, `result` below:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "\n",
       "<table >\n",
       "  <thead>\n",
       "    <tr>\n",
       "      <th id=\"T_30280_level0_col0\" class=\"col_heading level0 col0\" >3</th>\n",
       "      <th id=\"T_30280_level0_col1\" class=\"col_heading level0 col1\" >7</th>\n",
       "      <th id=\"T_30280_level0_col2\" class=\"col_heading level0 col2\" >targ</th>\n",
       "      <th id=\"T_30280_level0_col3\" class=\"col_heading level0 col3\" >idx</th>\n",
       "      <th id=\"T_30280_level0_col4\" class=\"col_heading level0 col4\" >result</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <td id=\"T_30280_row0_col0\" class=\"data row0 col0\" >0.602469</td>\n",
       "      <td id=\"T_30280_row0_col1\" class=\"data row0 col1\" >0.397531</td>\n",
       "      <td id=\"T_30280_row0_col2\" class=\"data row0 col2\" >0</td>\n",
       "      <td id=\"T_30280_row0_col3\" class=\"data row0 col3\" >0</td>\n",
       "      <td id=\"T_30280_row0_col4\" class=\"data row0 col4\" >0.602469</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td id=\"T_30280_row1_col0\" class=\"data row1 col0\" >0.502065</td>\n",
       "      <td id=\"T_30280_row1_col1\" class=\"data row1 col1\" >0.497935</td>\n",
       "      <td id=\"T_30280_row1_col2\" class=\"data row1 col2\" >1</td>\n",
       "      <td id=\"T_30280_row1_col3\" class=\"data row1 col3\" >1</td>\n",
       "      <td id=\"T_30280_row1_col4\" class=\"data row1 col4\" >0.497935</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td id=\"T_30280_row2_col0\" class=\"data row2 col0\" >0.133188</td>\n",
       "      <td id=\"T_30280_row2_col1\" class=\"data row2 col1\" >0.866811</td>\n",
       "      <td id=\"T_30280_row2_col2\" class=\"data row2 col2\" >0</td>\n",
       "      <td id=\"T_30280_row2_col3\" class=\"data row2 col3\" >2</td>\n",
       "      <td id=\"T_30280_row2_col4\" class=\"data row2 col4\" >0.133188</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td id=\"T_30280_row3_col0\" class=\"data row3 col0\" >0.996640</td>\n",
       "      <td id=\"T_30280_row3_col1\" class=\"data row3 col1\" >0.003360</td>\n",
       "      <td id=\"T_30280_row3_col2\" class=\"data row3 col2\" >1</td>\n",
       "      <td id=\"T_30280_row3_col3\" class=\"data row3 col3\" >3</td>\n",
       "      <td id=\"T_30280_row3_col4\" class=\"data row3 col4\" >0.003360</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td id=\"T_30280_row4_col0\" class=\"data row4 col0\" >0.595949</td>\n",
       "      <td id=\"T_30280_row4_col1\" class=\"data row4 col1\" >0.404051</td>\n",
       "      <td id=\"T_30280_row4_col2\" class=\"data row4 col2\" >1</td>\n",
       "      <td id=\"T_30280_row4_col3\" class=\"data row4 col3\" >4</td>\n",
       "      <td id=\"T_30280_row4_col4\" class=\"data row4 col4\" >0.404051</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td id=\"T_30280_row5_col0\" class=\"data row5 col0\" >0.366118</td>\n",
       "      <td id=\"T_30280_row5_col1\" class=\"data row5 col1\" >0.633882</td>\n",
       "      <td id=\"T_30280_row5_col2\" class=\"data row5 col2\" >0</td>\n",
       "      <td id=\"T_30280_row5_col3\" class=\"data row5 col3\" >5</td>\n",
       "      <td id=\"T_30280_row5_col4\" class=\"data row5 col4\" >0.366118</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "#hide_input\n",
    "from IPython.display import HTML\n",
    "df = pd.DataFrame(sm_acts, columns=[\"3\",\"7\"])\n",
    "df['targ'] = targ\n",
    "df['idx'] = idx\n",
    "df['result'] = sm_acts[range(6), targ]\n",
    "t = df.style.hide_index()\n",
    "#To have html code compatible with our script\n",
    "html = t._repr_html_().split('</style>')[1]\n",
    "html = re.sub(r'<table id=\"([^\"]+)\"\\s*>', r'<table >', html)\n",
    "display(HTML(html))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Looking at this table, you can see that the `result` column can be calculated by taking the `targ` and `idx` columns as indices into the two-column matrix containing the `3` and `7` columns. That's what `sm_acts[idx, targ]` is actually doing.  The really interesting thing here is that this actually works just as well with more than two columns. To see this, consider what would happen if we added an activation column for every digit (0 through 9), and then `targ` contained a number from 0 to 9."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "PyTorch provides a function that does exactly the same thing as `sm_acts[range(n), targ]` (except it takes the negative, because when applying the log afterward, we will have negative numbers), called `nll_loss` (*NLL* stands for *negative log likelihood*):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tensor([-0.6025, -0.4979, -0.1332, -0.0034, -0.4041, -0.3661])"
      ]
     },
     "execution_count": null,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "-sm_acts[idx, targ]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tensor([-0.6025, -0.4979, -0.1332, -0.0034, -0.4041, -0.3661])"
      ]
     },
     "execution_count": null,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "F.nll_loss(sm_acts, targ, reduction='none')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Despite its name, this PyTorch function does not take the log. We'll see why in the next section, but first, let's see why taking the logarithm can be useful."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> warning: Confusing Name, Beware: The nll in `nll_loss` stands for \"negative log likelihood,\" but it doesn't actually take the log at all! It assumes you have _already_ taken the log. PyTorch has a function called `log_softmax` that combines `log` and `softmax` in a fast and accurate way. `nll_loss` is designed to be used after `log_softmax`."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Taking the Log\n",
    "\n",
    "Recall that cross entropy loss may involve the multiplication of many numbers.  Multiplying lots of negative numbers together can cause problems like [numerical underflow](https://en.wikipedia.org/wiki/Arithmetic_underflow) in computers.  Therefore, we want to transform these probabilities to larger values so we can perform mathematical operations on them.  There is a mathematical function that does exactly this: the *logarithm* (available as `torch.log`). It is not defined for numbers less than 0, and looks like this between 0 and 1:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "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": [
    "plot_function(torch.log, min=0,max=1, ty='log(x)', tx='x')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Additionally, we want to ensure our model is able to detect differences between small numbers.  For example, consider the probabilities of .01 and .001.  Indeed, those numbers are very close together—but in another sense, 0.01 is 10 times more confident than 0.001.  By taking the log of our probabilities, we prevent these important differences from being ignored."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Does \"logarithm\" ring a bell? The logarithm function has this identity:\n",
    "\n",
    "```\n",
    "y = b**a\n",
    "a = log(y,b)\n",
    "```\n",
    "\n",
    "In this case, we're assuming that `log(y,b)` returns *log y base b*. However, PyTorch actually doesn't define `log` this way: `log` in Python uses the special number `e` (2.718...) as the base.\n",
    "\n",
    "Perhaps a logarithm is something that you have not thought about for the last 20 years or so. But it's a mathematical idea that is going to be really critical for many things in deep learning, so now would be a great time to refresh your memory. The key thing to know about logarithms is this relationship:\n",
    "\n",
    "    log(a*b) = log(a)+log(b)\n",
    "\n",
    "When we see it in that format, it looks a bit boring; but think about what this really means. It means that logarithms increase linearly when the underlying signal increases exponentially or multiplicatively. This is used, for instance, in the Richter scale of earthquake severity, and the dB scale of noise levels. It's also often used on financial charts, where we want to show compound growth rates more clearly. Computer scientists love using logarithms, because it means that multiplication, which can create really really large and really really small numbers, can be replaced by addition, which is much less likely to result in scales that are difficult for our computers to handle.\n",
    "\n",
    "Observe that the log of a number approaches negative infinity as the number approaches zero.  In our case, since the result relfects the predicted probability of the correct label, we want our loss function to return a small value when the prediction is \"good\" (closer to 1) and a large value when the prediction is \"bad\" (closer to 0).  We can achieve this by taking the negative of the log:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "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": [
    "plot_function(lambda x: -1*torch.log(x), min=0,max=1, tx='x', ty='- log(x)', title = 'Log Loss when true label = 1')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> s: It's not just computer scientists that love logs! Until computers came along, engineers and scientists used a special ruler called a \"slide rule\" that did multiplication by adding logarithms. Logarithms are widely used in physics, for multiplying very big or very small numbers, and many other fields."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's go ahead and update our previous table with an additional column, `loss` to reflect this loss function:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "\n",
       "<table >\n",
       "  <thead>\n",
       "    <tr>\n",
       "      <th id=\"T_090ff_level0_col0\" class=\"col_heading level0 col0\" >3</th>\n",
       "      <th id=\"T_090ff_level0_col1\" class=\"col_heading level0 col1\" >7</th>\n",
       "      <th id=\"T_090ff_level0_col2\" class=\"col_heading level0 col2\" >targ</th>\n",
       "      <th id=\"T_090ff_level0_col3\" class=\"col_heading level0 col3\" >idx</th>\n",
       "      <th id=\"T_090ff_level0_col4\" class=\"col_heading level0 col4\" >result</th>\n",
       "      <th id=\"T_090ff_level0_col5\" class=\"col_heading level0 col5\" >loss</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <td id=\"T_090ff_row0_col0\" class=\"data row0 col0\" >0.602469</td>\n",
       "      <td id=\"T_090ff_row0_col1\" class=\"data row0 col1\" >0.397531</td>\n",
       "      <td id=\"T_090ff_row0_col2\" class=\"data row0 col2\" >0</td>\n",
       "      <td id=\"T_090ff_row0_col3\" class=\"data row0 col3\" >0</td>\n",
       "      <td id=\"T_090ff_row0_col4\" class=\"data row0 col4\" >0.602469</td>\n",
       "      <td id=\"T_090ff_row0_col5\" class=\"data row0 col5\" >0.506720</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td id=\"T_090ff_row1_col0\" class=\"data row1 col0\" >0.502065</td>\n",
       "      <td id=\"T_090ff_row1_col1\" class=\"data row1 col1\" >0.497935</td>\n",
       "      <td id=\"T_090ff_row1_col2\" class=\"data row1 col2\" >1</td>\n",
       "      <td id=\"T_090ff_row1_col3\" class=\"data row1 col3\" >1</td>\n",
       "      <td id=\"T_090ff_row1_col4\" class=\"data row1 col4\" >0.497935</td>\n",
       "      <td id=\"T_090ff_row1_col5\" class=\"data row1 col5\" >0.697285</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td id=\"T_090ff_row2_col0\" class=\"data row2 col0\" >0.133188</td>\n",
       "      <td id=\"T_090ff_row2_col1\" class=\"data row2 col1\" >0.866811</td>\n",
       "      <td id=\"T_090ff_row2_col2\" class=\"data row2 col2\" >0</td>\n",
       "      <td id=\"T_090ff_row2_col3\" class=\"data row2 col3\" >2</td>\n",
       "      <td id=\"T_090ff_row2_col4\" class=\"data row2 col4\" >0.133188</td>\n",
       "      <td id=\"T_090ff_row2_col5\" class=\"data row2 col5\" >2.015990</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td id=\"T_090ff_row3_col0\" class=\"data row3 col0\" >0.996640</td>\n",
       "      <td id=\"T_090ff_row3_col1\" class=\"data row3 col1\" >0.003360</td>\n",
       "      <td id=\"T_090ff_row3_col2\" class=\"data row3 col2\" >1</td>\n",
       "      <td id=\"T_090ff_row3_col3\" class=\"data row3 col3\" >3</td>\n",
       "      <td id=\"T_090ff_row3_col4\" class=\"data row3 col4\" >0.003360</td>\n",
       "      <td id=\"T_090ff_row3_col5\" class=\"data row3 col5\" >5.695763</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td id=\"T_090ff_row4_col0\" class=\"data row4 col0\" >0.595949</td>\n",
       "      <td id=\"T_090ff_row4_col1\" class=\"data row4 col1\" >0.404051</td>\n",
       "      <td id=\"T_090ff_row4_col2\" class=\"data row4 col2\" >1</td>\n",
       "      <td id=\"T_090ff_row4_col3\" class=\"data row4 col3\" >4</td>\n",
       "      <td id=\"T_090ff_row4_col4\" class=\"data row4 col4\" >0.404051</td>\n",
       "      <td id=\"T_090ff_row4_col5\" class=\"data row4 col5\" >0.906213</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td id=\"T_090ff_row5_col0\" class=\"data row5 col0\" >0.366118</td>\n",
       "      <td id=\"T_090ff_row5_col1\" class=\"data row5 col1\" >0.633882</td>\n",
       "      <td id=\"T_090ff_row5_col2\" class=\"data row5 col2\" >0</td>\n",
       "      <td id=\"T_090ff_row5_col3\" class=\"data row5 col3\" >5</td>\n",
       "      <td id=\"T_090ff_row5_col4\" class=\"data row5 col4\" >0.366118</td>\n",
       "      <td id=\"T_090ff_row5_col5\" class=\"data row5 col5\" >1.004798</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "#hide_input\n",
    "from IPython.display import HTML\n",
    "df['loss'] = -torch.log(tensor(df['result']))\n",
    "t = df.style.hide_index()\n",
    "#To have html code compatible with our script\n",
    "html = t._repr_html_().split('</style>')[1]\n",
    "html = re.sub(r'<table id=\"([^\"]+)\"\\s*>', r'<table >', html)\n",
    "display(HTML(html))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Notice how the loss is very large in the third and fourth rows where the predictions are confident and wrong, or in other words have high probabilities on the wrong class.  One benefit of using the log to calculate the loss is that our loss function penalizes predictions that are both confident and wrong.  This kind of penalty works well in practice to aid in more effective model training.  \n",
    "\n",
    "> s: There are other loss functions such as [focal loss](https://arxiv.org/pdf/1708.02002.pdf) that allow you control this penalty with a parameter.  We do not discuss that loss function in this book."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We're calculating the loss from the column containing the correct label. Because there is only one \"right\" answer per example, we don't need to consider the other columns, because by the definition of softmax, they add up to 1 minus the activation corresponding to the correct label. As long as the activation columns sum to 1 (as they will, if we use softmax), then we'll have a loss function that shows how well we're predicting each digit.  Therefore, making the activation for the correct label as high as possible must mean we're also decreasing the activations of the remaining columns.  "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Negative Log Likelihood"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Taking the mean of the negative log of our probabilities (taking the mean of the `loss` column of our table) gives us the *negative log likelihood* loss, which is another name for cross-entropy loss. Recall that PyTorch's `nll_loss` assumes that you already took the log of the softmax, so it doesn't actually do the logarithm for you."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "When we first take the softmax, and then the log likelihood of that, that combination is called *cross-entropy loss*. In PyTorch, this is available as `nn.CrossEntropyLoss` (which, in practice, actually does `log_softmax` and then `nll_loss`):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "loss_func = nn.CrossEntropyLoss()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As you see, this is a class. Instantiating it gives you an object which behaves like a function:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tensor(1.8045)"
      ]
     },
     "execution_count": null,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "loss_func(acts, targ)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "All PyTorch loss functions are provided in two forms, the class just shown above, and also a plain functional form, available in the `F` namespace:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tensor(1.8045)"
      ]
     },
     "execution_count": null,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "F.cross_entropy(acts, targ)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Either one works fine and can be used in any situation. We've noticed that most people tend to use the class version, and that's more often used in PyTorch's official docs and examples, so we'll tend to use that too.\n",
    "\n",
    "By default PyTorch loss functions take the mean of the loss of all items. You can use `reduction='none'` to disable that:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tensor([0.5067, 0.6973, 2.0160, 5.6958, 0.9062, 1.0048])"
      ]
     },
     "execution_count": null,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "nn.CrossEntropyLoss(reduction='none')(acts, targ)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You will notice these values match the `loss` column in our table exactly."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> s: An interesting feature about cross-entropy loss appears when we consider its gradient. The gradient of `cross_entropy(a,b)` is just `softmax(a)-b`. Since `softmax(a)` is just the final activation of the model, that means that the gradient is proportional to the difference between the prediction and the target. This is the same as mean squared error in regression (assuming there's no final activation function such as that added by `y_range`), since the gradient of `(a-b)**2` is `2*(a-b)`. Because the gradient is linear, that means we won't see sudden jumps or exponential increases in gradients, which should lead to smoother training of models."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We have now seen all the pieces hidden behind our loss function. But while this puts a number on how well (or badly) our model is doing, it does nothing to help us know if it's actually any good. Let's now see some ways to interpret our model's predictions."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Model Interpretation"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "It's very hard to interpret loss functions directly, because they are designed to be things computers can differentiate and optimize, not things that people can understand. That's why we have metrics. These are not used in the optimization process, but just to help us poor humans understand what's going on. In this case, our accuracy is looking pretty good already! So where are we making mistakes?\n",
    "\n",
    "We saw in <<chapter_intro>> that we can use a confusion matrix to see where our model is doing well, and where it's doing badly:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 720x720 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "#width 600\n",
    "interp = ClassificationInterpretation.from_learner(learn)\n",
    "interp.plot_confusion_matrix(figsize=(12,12), dpi=60)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Oh dear—in this case, a confusion matrix is very hard to read. We have 37 different breeds of pet, which means we have 37×37 entries in this giant matrix! Instead, we can use the `most_confused` method, which just shows us the cells of the confusion matrix with the most incorrect predictions (here, with at least 5 or more):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[('american_pit_bull_terrier', 'staffordshire_bull_terrier', 10),\n",
       " ('Ragdoll', 'Birman', 8),\n",
       " ('Siamese', 'Birman', 6),\n",
       " ('Bengal', 'Egyptian_Mau', 5),\n",
       " ('american_pit_bull_terrier', 'american_bulldog', 5)]"
      ]
     },
     "execution_count": null,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "interp.most_confused(min_val=5)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Since we are not pet breed experts, it is hard for us to know whether these category errors reflect actual difficulties in recognizing breeds. So again, we turn to Google. A little bit of Googling tells us that the most common category errors shown here are actually breed differences that even expert breeders sometimes disagree about. So this gives us some comfort that we are on the right track.\n",
    "\n",
    "We seem to have a good baseline. What can we do now to make it even better?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Improving Our Model"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We will now look at a range of techniques to improve the training of our model and make it better. While doing so, we will explain a little bit more about transfer learning and how to fine-tune our pretrained model as best as possible, without breaking the pretrained weights.\n",
    "\n",
    "The first thing we need to set when training a model is the learning rate. We saw in the previous chapter that it needs to be just right to train as efficiently as possible, so how do we pick a good one? fastai provides a tool for this."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### The Learning Rate Finder"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "One of the most important things we can do when training a model is to make sure that we have the right learning rate. If our learning rate is too low, it can take many, many epochs to train our model. Not only does this waste time, but it also means that we may have problems with overfitting, because every time we do a complete pass through the data, we give our model a chance to memorize it.\n",
    "\n",
    "So let's just make our learning rate really high, right? Sure, let's try that and see what happens:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: left;\">\n",
       "      <th>epoch</th>\n",
       "      <th>train_loss</th>\n",
       "      <th>valid_loss</th>\n",
       "      <th>error_rate</th>\n",
       "      <th>time</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <td>0</td>\n",
       "      <td>2.778816</td>\n",
       "      <td>5.150732</td>\n",
       "      <td>0.504060</td>\n",
       "      <td>00:20</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/html": [
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: left;\">\n",
       "      <th>epoch</th>\n",
       "      <th>train_loss</th>\n",
       "      <th>valid_loss</th>\n",
       "      <th>error_rate</th>\n",
       "      <th>time</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <td>0</td>\n",
       "      <td>4.354680</td>\n",
       "      <td>3.003533</td>\n",
       "      <td>0.834235</td>\n",
       "      <td>00:24</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "learn = vision_learner(dls, resnet34, metrics=error_rate)\n",
    "learn.fine_tune(1, base_lr=0.1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "That doesn't look good. Here's what happened. The optimizer stepped in the correct direction, but it stepped so far that it totally overshot the minimum loss. Repeating that multiple times makes it get further and further away, not closer and closer!\n",
    "\n",
    "What do we do to find the perfect learning rate—not too high, and not too low? In 2015 the researcher Leslie Smith came up with a brilliant idea, called the *learning rate finder*. His idea was to start with a very, very small learning rate, something so small that we would never expect it to be too big to handle. We use that for one mini-batch, find what the losses are afterwards, and then increase the learning rate by some percentage (e.g., doubling it each time). Then we do another mini-batch, track the loss, and double the learning rate again. We keep doing this until the loss gets worse, instead of better. This is the point where we know we have gone too far. We then select a learning rate a bit lower than this point. Our advice is to pick either:\n",
    "\n",
    "- One order of magnitude less than where the minimum loss was achieved (i.e., the minimum divided by 10)\n",
    "- The last point where the loss was clearly decreasing \n",
    "\n",
    "The learning rate finder computes those points on the curve to help you. Both these rules usually give around the same value. In the first chapter, we didn't specify a learning rate, using the default value from the fastai library (which is 1e-3):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAZAAAAEQCAYAAACeDyIUAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjEsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy8QZhcZAAAgAElEQVR4nO3dd3gc1dn+8e+jblnNsuWu4t4LxhVscOg1wAuhtwRCCL83pNBSCSQkhBAgIS9JICF0EmoooTcbAwYsA8a4d9lyUy9W3z2/P3YFwshWsbSzu7o/17WXd2dnZu8Vyz575sw5Y845REREOirG6wAiIhKZVEBERKRTVEBERKRTVEBERKRTVEBERKRTVEBERKRT4rwO0FX69evn8vLyvI4hIhJRli5dWuycy+rMtlFTQPLy8sjPz/c6hohIRDGzLZ3dVoewRESkU1RARESkU1RARESkU1RARESkU1RARESkU0JWQMxsgZnVmVl18LZmH+vdYGaNLdarNrPhocopIiLtE+oWyP8651KCtzH7We+xFuulOOc2hiqgz+/w+TXFvYhIW3QIK8jvdzyev5UZv3mdnz+z3Os4IiJhL9QF5GYzKzazd81s/n7WO9nMSs1shZl9d18rmdllZpZvZvlFRUWdDrVyeyXfuHsx1z75KXWNPv67bAcNTf5O7086psnnp6qukaKqeraW1rB+dxWfFVZQUl3vdTQR2Y9QjkS/DlgJNABnA8+b2VTn3Ia91nscuAfYBcwCnjKzcufcv/beoXPunuC6TJ8+vVPHnR54bzM3Pr+CjOQEbj1jMn2SE7j0wXze31jCYaM7Nbpf9sHvd6zaWcl760t4d0Mxn2wtp7quiab9HDLsn5rIuEFpTBmazlkzcxiS0SuEiUVkf0JWQJxzH7R4+ICZnQOcAPx5r/VWtnj4npn9CTgD+EoB6QrTcvpwzswcrjl2DBnJCdQ1+ugVH8urK3f22AJSUl3PxuI95GQm0z81ETPr8D6Kquq5+aVVvLR8Z6BfyX25b2l4Vm+OnziQPskJ9IqPJSk+lqT4GBKD9xNija2ltazaWcmqHVXctWADf1mwga9PGcx3Dh/BmIGpXfmWRaQTvJwLywHt+WZq73qdMmloOpOGTvr8cVJ8LIeN7sfrK3fz61Ncp748I1Wjz88D723mj6+vo7q+CYBe8bHk9k1m9IBUxg9OY8LgNHIyk9lZUcfWslq2ltaQGB/DQdl9mJKdTmJcLI98sIVbX1lDXaOP06cNpU/vBGIMYszI7dubQ0f2ZVB6x1oSheW1/GPRRv794Vae/riQw0dncc7MHI4c15/4WHXliXghJAXEzDIIHI5aCDQBZwGHAT9oZd1TgLeBcmAGcCXw01DkbHb0+IG8smIXywsrmDw0I5Qv7ZlF64q44bkVbCjaw/wxWZw3K5edFbVsLqlhU/Eelm4p47ll27+ynRm4YMMiNsbI7J1AUVU9c0f248ZTJjAiK6VL8g3J6MUvT57AlUeM4qH3t/DoBwVc/vBSslITOePgoQzr15vkhFiSE2KJjYmhtqGJPfU+ahqaSIyPpX9qIlmpifRPTaJfSkKP+mEg0l1C1QKJB24CxgI+YDVwqnNujZnNA15yzjV/05wN/BNIBLYBtzjnHghRTgCOGNufGIPXVu6K+gKyrayGm/67ipdX7CS3bzL3XjSdI8cNaHXd8poGVm6vZFtZLQPTk8jOTGZwRhI19T4+2VrOxwVlrN1VzYmTB3HS5EHd8iXdp3cCVx45iivmj2Dh2iL+9WEBdy/cQEfOvO4VH0tOZjI5fZPpl5JIbEygdWRAZV0TJXsaKN1TT1VdE7FmxMfGEB9njBmQxoVzcpmSHd2fCZH2MueiY8zD9OnTXVdO537W3YupqG3k5R8c1mX7DCd1jT7+/vZG7lqwHoDvHTGKS+YOIyk+1uNkHVdV10h5TSO1jT5qGnw0+fwkJ8SRkhhHr4RY6hp97K6qo6iqnl2V9RSU1rClpIaC0j2U7mnAOfA7h99BSmIc/VISyOydQFqveHx+R5PPUd/kY8nmMqrrm5iancHFh+TxtTH9SU+O9/rtixwQM1vqnJvemW2j5nogXe3o8QO46YVVFJTUkNM32es4Xcbvdzy3bDu3vbaGraW1nDBpID87cXxEn92UmhRPatL+v8izMw/8v2FVXSNPLd3Gg4u38IPHPgFgRFZvpuX0YUZeJoePyWJAWtIBv45IpFALZB8KSmo47Na3+PmJ47h0XuTPpOKcY+HaIm55eQ2rdlQyflAaPz1hHHNH9fM6WsTx+x1LNpeSv6WMj7aU8VFBGWU1jQBMGJzG18b056wZ2V1StES624G0QFRA9uPYO94mIzmex74zp0v3210qahvx+R2ZvRM+X9ZcOP7vzfXkbykjO7MXVx8zhpMnDyYmRh3JXcE5x5pdVby1uoi3Vu9maUEZSXEx3HjKRE6fNkQd9hLWdAirmxw9fgB/WbCe0j0NX/pSbs3uyjre3VDM16cMIbYbv5hXbK+goqYxeNgmjgafn4Vrinh91S7yt5Th8ztG9k9hRl4mYwak8NRHhSwvrGBwehK/OmUCZ8/IISFOp712JTNj7MA0xg5M47vzR1BYXsuPHvuEq59YxsK1Rdx06kTSe6mvRKKPWiD7sWpHJSfcuYhxA9P46/nTyO3b+yvr+P2Ofy/Zys0vraKqrolbTp/EWTNyOvw6KYlx+z3ksb28lt+8sIoXlu9o9fmxA1M5atwAkhNjWbKplPzNZVTVN5HbN5kr5o/gtIOGqnCEkM/v+NvCDdz+2loGpiXx8xPHcdzEgWqNSNjRISy6p4AAvLl6Fz98bBl+57j9zKkcPT5wiqvf71i9s4obnl/Bh5tKmT08kz31PnZV1rHgmvkkJ7SvcbejopYjb1tIbIxxzwXTmTOi75eer2/y8Y9Fm/i/N9fjd44r5o9k5rBMquoaqa5vwud3zBnRl6F9vlx8fH5HQWkN2X16EaeBdp75uKCMa5/8lHW7q5mWk8HPThzHwbmZXscS+ZwKCN1XQAC2ltbw3UeW8llhJYePzqKoqp6NxdXUNfpJS4rjZyeO48zp2XxUUMbpf13Mj44ezZVHjmrXvq94ZClvrNrN0D692Fpay63fmMwpU4fg9zueXVbIH15ZS2F5LcdNGMjPThynjtkI1OTz8+TSbdz+2lp2V9Vz4qRB3HjKBPqlJHodTUQFBLq3gEBg3MRvX1zF22uLyOvXm5FZKYzon8JR4waQlfrFF8HlDy1l0boiFlzztS8tX7WjkuFZvUmM+2KcxYI1u7n4viVcc+wYzp+Vy2UP5fPBplK+degwFm8sYdWOSiYMTuMnx+tsqWhQ09DE39/exF1vrSclKY7fnjaR4yYO8jqW9HAqIHR/AWmvjUXVHHPH25w9M5ubTp1EcXU9v3x2BS8s38GUoen85fyDGZLRi7pGH8fc8TZxscZL359HYlws9U0+rnp8Gf/9dAdD+/TimmN1tlQ0WruriqseX8bywgpOmTqYa48bG9HjcCSyqYAQPgUE4PpnP+ORDwr48XFj+evCDVTXNXHWjGye+biQuFjjz+dMY8nmUv70xjoeuXQWh478onXh9zvyt5R9PjGhRKdGn5+/vLWBP7+5jia/4+DcPpw8eRAnTB5E/1QNRpTQUQEhvApIcXU9829dQHV9E1OyM7j1jMmMHpDKxqJqLn94Ket2VxMXYxw/cRB3nnOQ13HFQ1tLa3hu2XaeX7ad1TurSIiL4ebTJnH6wUO9jiY9hAoI4VVAAF5fuYsdFbWcMzPnS2dB1TQ08dOnl/PehhL++7259NfUFxK0blcVv3xuBe9tKOGSucP4yfFjdQaddDsVEMKvgLTF73fq25CvaPL5+c2Lq7jv3c3MHdmP/zv3IDKS9z+IVeRAHEgB0c8bj6h4SGviYmP45ckT+P0Zk/lwUyln3/M+VXWNXscSaZUKiEgYOnN6Nv+4aDrrd1dzxSMf0ejzex1J5CtUQETC1GGjs/jt/0xi0bpifvr0cqLlcLNED02mKBLGzpyezbbSGu58cz3ZmcntnuFAJBRUQETC3A+PHs22slpuf20t/VMTOXtmxybrFOkuKiAiYc7M+N3pkymtaeAn/1lOfGyMxolIWFAfiEgESIiL4W/nH8yhI/pxzZPLeG7Zdq8jiaiAiESKpPhY/n7hdGbkZfLDxz7hpX1cG0YkVFRARCJIr4RY/nnxDA7KzuDKf3/MwrVFXkeSHkwFRCTC9E6M45/fnMGo/qlc/tBSlm4p9TqS9FAqICIRKC0pngcvmcnA9CS+ed8SVu2o9DqS9EAqICIRql9KIg9dMpPkhDgu/OeHbCnZ43Uk6WFUQEQi2NA+yTx0yUwafX4uf/gj6hp9XkeSHkQFRCTCjRqQyu1nTmHVjkpueXm113GkB1EBEYkCR4wdwMWH5HHfu5t5a/Vur+NID6ECIhIlfnz8WMYOTOXqJ5axu7LO6zjSA6iAiESJpPhY/nzOQexpaOKqJ5bh92v2XuleKiAiUWTUgFR+cdJ4Fq0r5vH8rV7HkSinAiISZc6dmcPMvExueXk1ZXsavI4jUUwFRCTKmBk3njKByrombn11jddxJIqpgIhEoXGD0rhoTh7/+rCAZVvLvY4jUSpkBcTMFphZnZlVB2+t/jSygFvMrCR4+72ZWahyikSLHxw9in4pifzi2c/wqUNdukGoWyD/65xLCd7G7GOdy4BTgSnAZOAk4DuhCigSLdKS4vnZCeP4dFsFjy1Rh7p0vXA8hHURcJtzbptzrhC4DbjY20gikemUqYOZNSyT3720ip0VGhsiXSvUBeRmMys2s3fNbP4+1pkALGvxeFlw2VeY2WVmlm9m+UVFui6CyN6aL4fb4PPz46c/xTkdypKuE8oCch0wHBgC3AM8b2YjWlkvBaho8bgCSGmtH8Q5d49zbrpzbnpWVlZ3ZBaJeMP69ea648ayYE2RxoZIlwpZAXHOfeCcq3LO1TvnHgDeBU5oZdVqIK3F4zSg2umnk0inXTQnj9nDM/n1f1dRWF7rdRyJEl72gTigtbOrVhDoQG82JbhMRDopJsa49Ywp+J3juid1KEu6RkgKiJllmNmxZpZkZnFmdh5wGPBKK6s/CPzIzIaY2WDgKuD+UOQUiWbZmcn89IRxvLO+mCfyt3kdR6JAqFog8cBNQBFQDHwPONU5t8bM5plZdYt17waeB5YDnwEvBJeJyAE6b1YO03IyuP21tbr4lBywkBQQ51yRc26Gcy7VOZfhnJvtnHst+Nwi51xKi3Wdc+5a51xm8Hat+j9EuoaZcc2xY9lZWceDizd7HUciXDiOAxGRbjRnRF8OG53FXxZsoLKu0es4EsFUQER6oGuPHUN5TSP/eHuj11EkgqmAiPRAE4ekc+KkQfzjnU0UV9d7HUcilAqISA/1o2NGU9/k56631nsdRSKUCohIDzUiK4Uzpg3lkfcL2Fpa43UciUAqICI92A+OHkVMDNymC09JJ6iAiPRgg9J7ccncYTzzyXaWb6toewORFlRARHq47xw+gszeCfz2xVWa4kQ6RAVEpIdLS4rnyiNGsnhjCQvW6rII0n4qICLCubNyyeubzO9eXK3L30q7qYCICAlxMVx73FjW7KriyaW6Zoi0jwqIiABw/MSBTMnO4K8LNuBXK0TaQQVERIDARIuXzh3G5pIaFqovRNpBBUREPnfcxIEMSEvkvvc2ex1FIoAKiIh8Lj42hvNm5fL22iI2FFW3vYH0aCogIvIl58zMISE2hocWb/E6ioQ5FRAR+ZKs1EROnDyIJ5duo0rXC5H9UAERka+46JA8quubeGqprp0u+6YCIiJfMTU7gynZGTy4eItO6ZV9UgERkVZdfEguG4v3sGDtbq+jSJhSARGRVp04aTBD+/TijtfWaZJFaZUKiIi0KiEuhu8fOYrlhRW8smKX13EkDKmAiMg+nXbQEIZn9eb219ZokkX5ChUQEdmnuNgYfnjUaNbuqua/n273Oo6EGRUQEdmvEycNYuzAVO54bS2NPr/XcSSMqICIyH7FxBhXHTOGzSU1PP2RxoXIF1RARKRNR43rz5TsDO58Y71aIfI5FRARaZOZceURIyksr+XF5Tu8jiNBjT4/d76xjhXbKzx5fRUQEWmXr43pz/B+vbn3nU0aFxImdlbUcftra/msUAVERMJYTIzxrbnD+HRbBflbyryOI8C2sloAhmQke/L6KiAi0m6nTxtKRnI8/1i00esoAhSWBwtIn16evL4KiIi0W6+EWM6flcurK3expWSP13F6vMJgC2RQepInr68CIiIdcuGcXOJijPve3ex1lB6vsLyG/qmJJMXHevL6KiAi0iH905I4ecpgHs/fSkWNLjjlpcLyWs8OX4EHBcTMRplZnZk9vI/nbzCzRjOrbnEbHuqcIrJvl8wdRk2Dj38tKfA6So9WWFbLkIweVECAu4AlbazzmHMupcVNPXYiYWTC4HRmDcvkocVbNMmiR/x+x/byup7TAjGzs4Fy4I1Qvq6IdL0L5+RRWF7LW6t1wSkvFFXX0+DzM7QntEDMLA34FXBVO1Y/2cxKzWyFmX13P/u8zMzyzSy/qKioy7KKSNuOmTCAAWmJPPj+Fq+j9EifjwGJhBaImf3IzKYG7882swIz22hmc9q5i18D9zrntrax3uPAOCAL+DZwvZmd09qKzrl7nHPTnXPTs7Ky2hlDRLpCfGwM58zM4e21RWwu1im9ofb5GBCPBhFCx1ogPwQ2Be/fDNwO/Ab4Y1sbBgvPUcAdba3rnFvpnNvunPM5594D/gSc0YGcIhIi587MIS7GeFitkJArjKQWCJDunKsws1RgCvBn59y9wJh2bDsfyAMKzGwncDVwupl91I5tHWAdyCkiIdI/LYljJw7k8fyt1Db4vI7ToxSW15CRHE9KYpxnGTpSQLaa2SHA2cDbzjlfsF+jPZ+ae4ARwNTg7W/AC8Cxe69oZqeYWR8LmAlcCTzbgZwiEkIXzs6lsq6J55YVeh2lR/H6FF7oWAG5BngS+BmB/gyAk4AP29rQOVfjnNvZfAOqgTrnXJGZzTOz6harnw2sB6qAB4FbnHMPdCCniITQzGGZjBmQyoOLt2iW3hAqLPe+gLS77eOcexEYvNfiJ4K3DnHO3dDi/iIgpcXjVjvMRSQ8mRkXzMnl5898xkcF5Ryc28frSFHPOUdhWS2HjuznaY6OnIU13swGBO+nmNmNwE+A+O4KJyKR4bSDhpCaGMdDizd7HaVHKK9pZE+Dz/MWSEcOYT0KZATv/wE4DJgD3N3VoUQksvROjOP0g4fy4vKdFFfXex0n6jWfwjvUwzOwoGMFJM85t8bMDDgN+AaB02u/0hEuIj3P+bNzafD5eWxJW0O95EB5fSGpZh0pIPXBU3hnAludc8VAPeDNRPQiElZG9k/h0JF9eeT9LTT5/F7HiWqR2AJ5FHgTeAC4P7hsGl8MLhSRHu6C2Xlsr6jjDc2P1a0Ky2pJToglI9nbLuiOnIX1QzM7Bmh0zr0VXOwnMEJdRISjxvVncHoSDy3ewrETBnodJ2oVltcwJKMXgR4F73RoMkXn3KvABjObY2Y5zrl859yb3ZRNRCJMXGwM587K4Z31xWwoqm57A+kUry8k1awjp/EOMrOFwDrgaWC9mS00s73HhohID3bWjBziY42HFmt+rO4SDqPQoWMtkL8Cy4BM59wgoA/wCYFpSUREAMhKTeSESYN46qNt1DQ0eR0n6uypb6KspjGyWiDAXOAq59wegOC/1wKHdEcwEYlc583KpaquieeXbfc6StT5Yhr3yCogZcD4vZaNIXCFQRGRz83I68PoASk88oGumd7VmqdxH9rH2zEg0LEC8nvgdTP7nZl918x+B7wWXC4i8jkz47xZuXy6rYJPt+k3ZlfaFiZjQKADBcQ593fgLKAfcHLw3wuAod0TTUQi2WnThtArPpZH3lcrpCsVltWSEBtDVkqi11E6fBrvm865S51zJzjnLgUWEpjeXUTkS9KS4jll6mCeW7aditpGr+NEjcLyWgZlJBET4/119jpUQPbB+3chImHpvFm51Db6eOZjXWyqq3y6rZxR/VPaXjEEuqKA6AoyItKqSUPTmTI0nYff18WmukJBSQ1bSmqY6/F1QJq1OZWJmR2xn6cTujCLiESh82blcu1Tn/LhplJmDe/rdZyItmh9EQDzRmd5nCSgPXNh3dvG8+ohE5F9OnnKYG5+aRV/W7hBBeQAvbOumMHpSQzv19vrKEA7CohzblgogohIdOqVEMul84Zz6ytr+GRrOVOzM9reSL7C53e8u76Y4ycO8nwSxWZd0QciIrJfFx2SR0ZyPHe+sc7rKBHr023lVNY1MXdUePR/gAqIiIRASmIc3543nDdX72bZVg0s7IxF64oxg0PDpAMdVEBEJESaWyF/UiukU95ZV8zEwelk9g6fc5dUQEQkJNQK6bzq+iY+KihjXhgdvgIVEBEJoQvn5KovpBPe31BCk98xb1R4nL7bTAVEREImNSmeS+cO443Vu1m1o9LrOBFj0boiesXHMi03vM5gUwERkZA6f3YuSfEx3P/uZq+jRIxF64uZPTyTxLhYr6N8iQqIiIRURnICpx00lGc+KaR0T4PXccLetrIaNhbtYW6YHb4CFRAR8cC3Ds2jvsnPvz7URBZt+WBjKQCHjgy/UfwqICIScqMGpDJvVD8eWryFRp/f6zhhbcX2SnrFxzKqf6rXUb5CBUREPPHNQ/PYWVnHS5/t9DpKWFu5o4Kxg1KJDYPrf+xNBUREPDF/dH+G9evNfe9u8jpK2HLOsXJ7JeMHpXkdpVUqICLiiZgY46I5uXxcUM7HBWVexwlL28pqqaxrYvxgFRARkS85Y3o2qYlx3KdTelu1YntgrMyEwekeJ2ldyAuImY0yszoze3gfz5uZ3WJmJcHb7y1c5i4WkS6VkhjHmTOyeXH5DnZW1HkdJ+ys3FFJjMGYAeHXgQ7etEDuApbs5/nLgFOBKcBk4CTgOyHIJSIeuPiQPPzO8eDizV5HCTsrt1cyIiuFXgnhNYCwWUgLiJmdDZQDb+xntYuA25xz25xzhcBtwMUhiCciHsjOTOaY8QN59MMCaht8XscJKyu3V4Rt/weEsICYWRrwK+CqNladACxr8XhZcJmIRKlvzR1GeU0j//m40OsoYaNsTwPbK+qYoAICwK+Be51zW9tYLwWoaPG4AkhprR/EzC4zs3wzyy8qKurCqCISSjPy+jBxSBr/fHcTzjmv44SFlcHJJscPCs8OdAhRATGzqcBRwB3tWL0aaFly04Bq18qnyjl3j3NuunNuelZW+M0TIyLtY2Z869BhrN9dzdvrir2OExZWBs/A0iEsmA/kAQVmthO4GjjdzD5qZd0VBDrQm00JLhORKHbS5MFkpSbyz3c0sBACLZBB6UlhdQXCvYWqgNwDjACmBm9/A14Ajm1l3QeBH5nZEDMbTKDP5P4Q5RQRjyTExXDh7FwWri1i/e4qr+N4bsX2irAdgd4sJAXEOVfjnNvZfCNwmKrOOVdkZvPMrLrF6ncDzwPLgc8IFJq7Q5FTRLx17qwcEuJiuP+9zV5H8VRdo48NRXvCugMdPBqJ7py7wTl3fvD+IudcSovnnHPuWudcZvB2bWv9HyISffqmJHLKlME8tbSQitpGr+N4Zs3OKnx+F9b9H6CpTEQkzFx0SB61jT6eyG/rhM3oFQlnYIEKiIiEmYlD0pmZl8kDizfj8/fMgw8rt1eSmhhHdmYvr6PslwqIiISdiw/NY2tpLW+s2uV1FE+s2F7BuMFphPs0gCogIhJ2jhk/gMHpST2yM73J52fVjqqw70AHFRARCUNxsTFcMCeP9zaUsGZnzzqld+WOSmobfUzL6eN1lDapgIhIWDp7RjaJPfCU3g83lQIwc1imx0napgIiImGpT+8E/mfaEJ7+aBu7KnvOtUKWbC4lJzOZAWlJXkdpkwqIiIStK+aPxO8cf35znddRQsI5R/7mMmbkhX/rA1RARCSMZWcmc9aMbP794VYKSmq8jtPtNhTtoWRPAzOHhX//B6iAiEiY+94Ro4iNMf74xlqvo3S7JZsD/R/T1QIRETlwA9KSuPiQPP7zcSFrd0X3GVlLNpfSLyWB4f16ex2lXVRARCTsXX74CHonxHH7q9HdClmyuZTpuZlhP4CwmQqIiIS9Pr0TuHTeMF5esZNPt5V7Hadb7KyoY2tpLTMi4PTdZiogIhIRLpk7jD7J8dz6yhqvo3SLD4P9HzMjpP8DVEBEJEKkJsVzxfyRLFpXzOINJV7H6XJLNpXSOyGWcYNSvY7SbiogIhIxLpiTy8C0JH7/ymqi7TJBSzaXMi23D3GxkfO1HDlJRaTHS4qP5ftHjeLjgnLeWLXb6zhdpqKmkTW7qiJmAGEzFRARiShnHDyUYf1684dX1+CPkuuFLC0oxTlUQEREulN8bAw/PHo0q3dW8dyy7V7H6RIfbiojPtY4KCfD6ygdogIiIhHnpEmDGD8ojdtfW0tDk9/rOAfs/Y0lTB6aQVJ8rNdROkQFREQiTkyMce1xYygoreGut9Z7HeeAVNc3sbywgjnD+3odpcNUQEQkIs0f059Tpw7mrrfW81lhhddxOm3JplJ8fsecESogIiIhc8PXJ5DZO4Grn1hGfZPP6zid8v7GEuJjLSKuQLg3FRARiVgZyQnc/D+TWL2zij+/EZmHshZvLOGg7D70Sois/g9QARGRCHfkuAGccfBQ/rpwA8u2RtY8WZV1jXxWWMHsCDx8BSogIhIFfnHSePqnJnLdU5/ii6CxIUs2leJ3MHt4ZI3/aKYCIiIRL71XPD89YVxwbEih13HabfGGEhLiYiKy/wNUQEQkSpwYgWNDFm8sYVpO5I3/aKYCIiJRoXlsyNbSWv69pMDrOG2qqGlk5Y5KZkfg+I9mKiAiEjUOH53FzGGZ3PnGemoamryOs18fbCrBOSJyAGEzFRARiRpmxnXHjaG4up773t3sdZz9WryxhMS4GKZG2PxXLamAiEhUOTg3k6PG9edvCzdQXtPgdZx9WryhhINz+5AYF5n9H6ACIiJR6Opjx1Bd38Tvw/Tyt2V7Gli9syqiD1+BCnOqTBsAAA75SURBVIiIRKGxA9P49rzhPPpBAW+tCb8LT72zvhiAQ0aqgLSLmT1sZjvMrNLM1prZpftY72Iz85lZdYvb/FDlFJHo8KOjRzN6QArXPflp2B3Kemv1bvokxzM1OzLHfzQLZQvkZiDPOZcGfB24ycwO3se6i51zKS1uC0KWUkSiQlJ8LLefOZXSPQ1c/+wKr+N8zud3LFhbxOGjs4iNMa/jHJCQFRDn3ArnXH3zw+BtRKheX0R6nolD0rnyyFE8t2w7L3y6w+s4ACzbVk7pnga+Nra/11EOWEj7QMzsL2ZWA6wGdgAv7mPVg8ysOHio6xdmFhe6lCISTa6YP4Ip2Rn87JnlFFXVt71BN1uwejcxFhizEulCWkCcc1cAqcA84Gmgtf+abwMTgf7A6cA5wDWt7c/MLjOzfDPLLyoq6p7QIhLR4mJjuO0bU6hp8PHL5z7zOg5vrtnNtJw+ZCQneB3lgIX8LCznnM859w4wFPhuK89vdM5tcs75nXPLgV8BZ+xjX/c456Y756ZnZUV+NReR7jGyfwrfP3IULy7fycufeXcoa3dlHZ8VVkbF4Svw9jTeONrXB+KAyO5pEhHPXXbYcCYMTuPnz6zw7Kys5lOKj1ABaT8z629mZ5tZipnFmtmxBA5NvdnKuseb2YDg/bHAL4BnQ5FTRKJXfGwMvz9jMuU1Dfz6v6s8yfDW6iIGpScxdmCqJ6/f1ULVAnEEDldtA8qAPwA/cM49a2Y5wbEeOcF1jwQ+NbM9BDrZnwZ+G6KcIhLFJgxO5/LDR/DUR9tCPsCwocnPO+uLmT+mP2bRcVAlJGc3OeeKgMP38VwBkNLi8dXA1aHIJSI9z/eOHMkrK3Zy1ePLePb/HUp2ZnJIXnfJ5lKq65ui5vAVaCoTEelhEuNiufuCg2ny+fn2g/lU14dm2vc3V+8mIS6GQyN8+pKWVEBEpMcZnpXCXedNY93uan7w70/wd/N11H1+x6srdzJ7eF+SE6JnWJsKiIj0SPNGZfGLE8fx+qpd/OHV7p21963Vu9laWstZ07O79XVCLXpKoYhIB110SB5rdlXzlwUbyMlM5uyZOW1v1An3v7eZQelJHDNhQLfs3ytqgYhIj2Vm3Pj1CRw2Oouf/mc5Ly7v+kGG63ZV8c76Ys6fnUt8bHR95UbXuxER6aCEuBj+dv40puX04fv//piFa7t2WqT73ttMYlwM53RT68ZLKiAi0uMlJ8Rx78UzGNk/lcsfWsrSLaVdst+Kmkae/mgbp04dQmbvyJ/7am8qICIiQHqveB781kwGpifxzfuWsKl4zwHv87H8Auoa/Vx0SN6BBwxDKiAiIkFZqYk88M2ZxMYYlz6whMq6xk7vy+d3PPDeFmYNy2T84LQuTBk+VEBERFrI6ZvMX88/mC0lNXzv0Y/xdXKMyOP5Wyksr+Wbhw7r4oThQwVERGQvs4f35cZTJrBwbRG3vLy6Q9s657h74QZ+8vRyZuT14ahx0TN1yd40DkREpBXnzcplzc4q7nl7I6mJcVw+f0Sbp+E2+fxc/9wKHv2ggBMnD+K2b0whLspO3W1JBUREZB9+cdJ4Svc0cNtra3lh+Q5+d/pkpmZntLruzoo6rnlyGYvWFfPd+SO45pgxxMREx6y7+2LOde8cMKEyffp0l5+f73UMEYlCr6zYyS+fXcGuqjrOm5XDNw7OZtKQdGJijEafn/vf3cwfX19Lk99x49cndNuI9u5gZkudc9M7s61aICIibTh2wkAOGdGX215dy4OLN/Pw+wX0S0ngsNFZrCisZM2uKo4Y258bTp5ATt/QTA8fDtQCERHpgNI9Dby9tog3V+9m4doiUpPiuP6k8Rw9fkBEXihKLRARkRDJ7J3AqQcN4dSDhuD3O8yIyMLRFVRAREQ6Kdo7ydsSveeXiYhIt1IBERGRTlEBERGRTlEBERGRTlEBERGRTlEBERGRTlEBERGRTomakehmVgRsAdKBiuDitu43/9sPKO7Ey7bcZ0ee33v5/h7vnbXlss7kjsTM+8vVkcz7yrmv+158PiIxc2vLo/Uz3fJ+tHw+cp1zWR0NDwTmro+mG3BPe++3+Df/QF+rI8/vvXx/j/fOeqC5IzFzW7nbmzkSPh+RmNnrz0coM3v9t/b687H3LRoPYT3fgfstlx3oa3Xk+b2X7+9xa1kPJHckZm5r+/Zm3ntZOH4+IjFza8uj9TPd8n5P/Hx8SdQcwjoQZpbvOjmZmJciMbcyh0YkZobIzN2TM0djC6Qz7vE6QCdFYm5lDo1IzAyRmbvHZlYLREREOkUtEBER6RQVEBER6RQVkHYys7lmtiB4W2tmd3idqT3MbL6ZvWFmb5nZaV7naYuZ5ZlZUYu/defOT/eImZ0THJMU9sxsgJm9Z2YLzexNMxvkdaa2mNkcM1sczPwvM4v3OlN7mFm6mX1oZtVmNtHrPPtiZr8xs0Vm9qSZtXltXhWQdnLOveOcm++cmw+8BzzjcaQ2mVkScBVwvHPua865/3idqZ0WNv+tnXMR8WUMYGYxwBnAVq+ztFMxMNc5dzjwIHCJx3naYwtwRDDzRuAUj/O0Vw1wIvCk10H2JVjYRjjn5gGvA99qaxsVkA4K/uKZCSzyOks7HALUAs+b2X/MbKDXgdrp0OCvoN9aZF0r9FwCXxB+r4O0h3PO55xrzpoKrPAyT3s457Y752qDD5uInL91YwT8GJoHvBS8/xIwt60NorKAmNn/mlm+mdWb2f17PZcZ/DLdY2ZbzOzcDu7+aOCNFv/jdYluyjwAGAmcDPwduCECMu8IZj4M6A/8T1dmDmbr8txmFgucCTzW1XmD+++Wz7SZTTWzD4D/BT6KhMzB7YcBxwP/7cLIzfvuzu+PbncA+fvwxdQnFUBmW68VrddE3w7cBBwL9NrrubuABgJfrlOBF8xsmXNuRfAXemtNzDOcczuD978B3BcJmYFy4F3nXIOZvQH8ONwzB//O9QBm9jQwG3gq3HMH9/W4c87fTY2mbvlbO+c+AWaZ2ZnAT4DLwz2zmaUBDwAXOOcaujBvt+buhpz70qn8QBmBubII/lva5it1xXwo4XoL/hHvb/G4d/CPN7rFsoeA37Vzf/HAZ0BMJGQG+hI4lmnALOC+CMic1uL+zcCFEfK3vgV4FXiZwK+3OyMgc2KL+8cCt0dA5jjgBQL9IN3yueiO3C3Wvx+Y2N3ZO5MfmAQ8Grx/GfC9tl4jWlsg+zIa8Dnn1rZYtgw4vJ3bHwW86br48FUbOp3ZOVdiZv8BFhI4Vtxmp1gXOZC/8+FmdgOBTsdNwC+6Pt4+Hcjf+rrm+xaYJuLKbsjXmgP5W08zs1sAH1BHZHw+ziHwY+h6M7se+KtzrlsOG7bigL4/zOxFAr/6x5jZ3c65+7s+4n7tN79zbnnwsNYiYDdwYVs77GkFJIWvToVcQaADsU3OuZf4opMpVA40810Emq2h1OnMzrnn6eIJ3zrggP7WzVxo50U6kL/1YgJ9TaF2IJkfIvCr2QsH+v/iCV2eqGPazO+c+0lHdhiVnej7UQ2k7bUsDajyIEt7KXPoRGJuZQ6dSM3drMvz97QCshaIM7NRLZZNIbxPX1Tm0InE3MocOpGau1mX54/KAmJmcRYYRBcLxJpZkpnFOef2AE8DvzKz3mZ2KIGBSF41iT+nzKETibmVOXQiNXezkOYPxdkAob4RGO/g9rrdEHwuk8Ao8j1AAXCu13mVWbmVOTwyR3JuL/JrOncREemUqDyEJSIi3U8FREREOkUFREREOkUFREREOkUFREREOkUFREREOkUFREREOkUFRKQLmNlLZnaR1zlEQkkFRCKamW02s6O8zuGcO94590BX79fM5puZ38yqzazKzNaY2Tc7sP0NZvZwV+cSARUQkTaZmdeXPdjunEshMHPqD4G/m9kYjzOJqIBI9DKzk8zsEzMrN7P3zGxyi+d+bGYbgr/qV5rZaS2eu9jM3jWzO8ysFLghuOwdM/uDmZWZ2SYzO77FNgvM7NIW2+9v3WFm9nbwtV83s7va00pwAS8SuNRoy/fyJzPbamaVZrbUzOYFlx8H/BQ4K9iCWRZcnm5m95rZDjMrNLObLHBNd5EOUQGRqGRm04B/At8hcGnfu4HnzCwxuMoGYB6Baz/fCDxsZoNa7GIWsBHoD/ymxbI1QD/g98C9Zvu8APr+1n0U+DCY6wbggna+pxgz+3pwn+tbPLWEwJXuMoP7fsLMkpxzLwO/BR5zzqU456YE138AaAJGAgcBxwCXtieDSEsqIBKtvg3c7Zz7wDnnC/ZP1AOzAZxzTzjntjvn/C5wSdR1wMwW2293zv3ZOdfknKsNLtvinPu7c85H4Et4EDBgH6/f6rpmlgPMAK53zjU4594BnmvjvQw2s3KgFvgP8CPn3MfNTzrnHnbOlQSz3gYkAq0e4jKzAcDxwA+cc3ucc7uBO4Cz28gg8hUqIBKtcoGrgoevyoNfwNnAYAAzu7DF4a1yYCKBX/bNtrayz53Nd5xzNcG7Kft4/X2tOxgobbFsX6/V0nbnXAaBPpA7gSNaPmlmV5nZKjOrCL6X9L3eS0u5QDywo8V7v5tAS0ukQ7zuHBTpLluB3zjnfrP3E2aWC/wdOBJY7JzzmdknQMvDUd11nYMdQKaZJbcoItnt2dA5V29m1wFrzOxU59wzwf6O6wi8lxXOOb+ZlfHFe9n7fWwl0BLr55xrOuB3Iz2aWiASDeKDV11rvsURKBCXm9ksC+htZieaWSrQm8AXaxFA8LTYiaEI6pzbAuQT6JhPMLM5wMkd2L4BuA24PrgolUB/RhGBy5Vez5eve70LyDOzmOD2O4BXgdvMLC3YrzLCzA4/0PcmPY8KiESDFwn0DzTfbnDO5RPoB/k/oIxAp/PFAM65lQS+hBcT+IKdBLwbwrznAXOAEuAm4DECrYL2+ieQY2YnA68ALxG43vUWoI4vHxJ7IvhviZl9FLx/IZAArCTwt3mSQB+NSIfoioQiHjOzx4DVzrlfep1FpCPUAhEJMTObETxsFBMcq3EKgetUi0QUdaKLhN5A4GkC40C2Ad9teVquSKTQISwREekUHcISEZFOUQEREZFOUQEREZFOUQEREZFOUQEREZFOUQEREZFO+f/qAtDe5s8ZYQAAAABJRU5ErkJggg==\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "learn = vision_learner(dls, resnet34, metrics=error_rate)\n",
    "lr_min,lr_steep = learn.lr_find(suggest_funcs=(minimum, steep))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Minimum/10: 1.00e-02, steepest point: 5.25e-03\n"
     ]
    }
   ],
   "source": [
    "print(f\"Minimum/10: {lr_min:.2e}, steepest point: {lr_steep:.2e}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can see on this plot that in the range 1e-6 to 1e-3, nothing really happens and the model doesn't train. Then the loss starts to decrease until it reaches a minimum, and then increases again. We don't want a learning rate greater than 1e-1 as it will give a training that diverges like the one before (you can try for yourself), but 1e-1 is already too high: at this stage we've left the period where the loss was decreasing steadily.\n",
    "\n",
    "In this learning rate plot it appears that a learning rate around 3e-3 would be appropriate, so let's choose that:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: left;\">\n",
       "      <th>epoch</th>\n",
       "      <th>train_loss</th>\n",
       "      <th>valid_loss</th>\n",
       "      <th>error_rate</th>\n",
       "      <th>time</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <td>0</td>\n",
       "      <td>1.328591</td>\n",
       "      <td>0.344678</td>\n",
       "      <td>0.114344</td>\n",
       "      <td>00:20</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/html": [
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: left;\">\n",
       "      <th>epoch</th>\n",
       "      <th>train_loss</th>\n",
       "      <th>valid_loss</th>\n",
       "      <th>error_rate</th>\n",
       "      <th>time</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <td>0</td>\n",
       "      <td>0.540180</td>\n",
       "      <td>0.420945</td>\n",
       "      <td>0.127876</td>\n",
       "      <td>00:24</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>1</td>\n",
       "      <td>0.329827</td>\n",
       "      <td>0.248813</td>\n",
       "      <td>0.083221</td>\n",
       "      <td>00:24</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "learn = vision_learner(dls, resnet34, metrics=error_rate)\n",
    "learn.fine_tune(2, base_lr=3e-3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> Note: Logarithmic Scale: The learning rate finder plot has a logarithmic scale, which is why the middle point between 1e-3 and 1e-2 is between 3e-3 and 4e-3. This is because we care mostly about the order of magnitude of the learning rate."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "It's interesting that the learning rate finder was only discovered in 2015, while neural networks have been under development since the 1950s. Throughout that time finding a good learning rate has been, perhaps, the most important and challenging issue for practitioners. The solution does not require any advanced maths, giant computing resources, huge datasets, or anything else that would make it inaccessible to any curious researcher. Furthermore, Leslie Smith, was not part of some exclusive Silicon Valley lab, but was working as a naval researcher. All of this is to say: breakthrough work in deep learning absolutely does not require access to vast resources, elite teams, or advanced mathematical ideas. There is lots of work still to be done that requires just a bit of common sense, creativity, and tenacity."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now that we have a good learning rate to train our model, let's look at how we can fine-tune the weights of a pretrained model."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Unfreezing and Transfer Learning"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We discussed briefly in <<chapter_intro>> how transfer learning works. We saw that the basic idea is that a pretrained model, trained potentially on millions of data points (such as ImageNet), is fine-tuned for some other task. But what does this really mean?\n",
    "\n",
    "We now know that a convolutional neural network consists of many linear layers with a nonlinear activation function between each pair, followed by one or more final linear layers with an activation function such as softmax at the very end. The final linear layer uses a matrix with enough columns such that the output size is the same as the number of classes in our model (assuming that we are doing classification).\n",
    "\n",
    "This final linear layer is unlikely to be of any use for us when we are fine-tuning in a transfer learning setting, because it is specifically designed to classify the categories in the original pretraining dataset. So when we do transfer learning we remove it, throw it away, and replace it with a new linear layer with the correct number of outputs for our desired task (in this case, there would be 37 activations).\n",
    "\n",
    "This newly added linear layer will have entirely random weights. Therefore, our model prior to fine-tuning has entirely random outputs. But that does not mean that it is an entirely random model! All of the layers prior to the last one have been carefully trained to be good at image classification tasks in general. As we saw in the images from the [Zeiler and Fergus paper](https://arxiv.org/pdf/1311.2901.pdf) in <<chapter_intro>> (see <<img_layer1>> through <<img_layer4>>), the first few layers encode very general concepts, such as finding gradients and edges, and later layers encode concepts that are still very useful for us, such as finding eyeballs and fur.\n",
    "\n",
    "We want to train a model in such a way that we allow it to remember all of these generally useful ideas from the pretrained model, use them to solve our particular task (classify pet breeds), and only adjust them as required for the specifics of our particular task.\n",
    "\n",
    "Our challenge when fine-tuning is to replace the random weights in our added linear layers with weights that correctly achieve our desired task (classifying pet breeds) without breaking the carefully pretrained weights and the other layers. There is actually a very simple trick to allow this to happen: tell the optimizer to only update the weights in those randomly added final layers. Don't change the weights in the rest of the neural network at all. This is called *freezing* those pretrained layers."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "When we create a model from a pretrained network fastai automatically freezes all of the pretrained layers for us. When we call the `fine_tune` method fastai does two things:\n",
    "\n",
    "- Trains the randomly added layers for one epoch, with all other layers frozen\n",
    "- Unfreezes all of the layers, and trains them all for the number of epochs requested\n",
    "\n",
    "Although this is a reasonable default approach, it is likely that for your particular dataset you may get better results by doing things slightly differently. The `fine_tune` method has a number of parameters you can use to change its behavior, but it might be easiest for you to just call the underlying methods directly if you want to get some custom behavior. Remember that you can see the source code for the method by using the following syntax:\n",
    "\n",
    "    learn.fine_tune??\n",
    "\n",
    "So let's try doing this manually ourselves. First of all we will train the randomly added layers for three epochs, using `fit_one_cycle`. As mentioned in <<chapter_intro>>, `fit_one_cycle` is the suggested way to train models without using `fine_tune`. We'll see why later in the book; in short, what `fit_one_cycle` does is to start training at a low learning rate, gradually increase it for the first section of training, and then gradually decrease it again for the last section of training."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "learn.fine_tune??"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: left;\">\n",
       "      <th>epoch</th>\n",
       "      <th>train_loss</th>\n",
       "      <th>valid_loss</th>\n",
       "      <th>error_rate</th>\n",
       "      <th>time</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <td>0</td>\n",
       "      <td>1.188042</td>\n",
       "      <td>0.355024</td>\n",
       "      <td>0.102842</td>\n",
       "      <td>00:20</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>1</td>\n",
       "      <td>0.534234</td>\n",
       "      <td>0.302453</td>\n",
       "      <td>0.094723</td>\n",
       "      <td>00:20</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>2</td>\n",
       "      <td>0.325031</td>\n",
       "      <td>0.222268</td>\n",
       "      <td>0.074425</td>\n",
       "      <td>00:20</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "learn = vision_learner(dls, resnet34, metrics=error_rate)\n",
    "learn.fit_one_cycle(3, 3e-3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Then we'll unfreeze the model:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "learn.unfreeze()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "and run `lr_find` again, because having more layers to train, and weights that have already been trained for three epochs, means our previously found learning rate isn't appropriate any more:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "(1.0964782268274575e-05, 1.5848931980144698e-06)"
      ]
     },
     "execution_count": null,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "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.lr_find()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Note that the graph is a little different from when we had random weights: we don't have that sharp descent that indicates the model is training. That's because our model has been trained already. Here we have a somewhat flat area before a sharp increase, and we should take a point well before that sharp increase—for instance, 1e-5. The point with the maximum gradient isn't what we look for here and should be ignored.\n",
    "\n",
    "Let's train at a suitable learning rate:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: left;\">\n",
       "      <th>epoch</th>\n",
       "      <th>train_loss</th>\n",
       "      <th>valid_loss</th>\n",
       "      <th>error_rate</th>\n",
       "      <th>time</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <td>0</td>\n",
       "      <td>0.263579</td>\n",
       "      <td>0.217419</td>\n",
       "      <td>0.069012</td>\n",
       "      <td>00:24</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>1</td>\n",
       "      <td>0.253060</td>\n",
       "      <td>0.210346</td>\n",
       "      <td>0.062923</td>\n",
       "      <td>00:24</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>2</td>\n",
       "      <td>0.224340</td>\n",
       "      <td>0.207357</td>\n",
       "      <td>0.060217</td>\n",
       "      <td>00:24</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>3</td>\n",
       "      <td>0.200195</td>\n",
       "      <td>0.207244</td>\n",
       "      <td>0.061570</td>\n",
       "      <td>00:24</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>4</td>\n",
       "      <td>0.194269</td>\n",
       "      <td>0.200149</td>\n",
       "      <td>0.059540</td>\n",
       "      <td>00:25</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>5</td>\n",
       "      <td>0.173164</td>\n",
       "      <td>0.202301</td>\n",
       "      <td>0.059540</td>\n",
       "      <td>00:25</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "learn.fit_one_cycle(6, lr_max=1e-5)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This has improved our model a bit, but there's more we can do. The deepest layers of our pretrained model might not need as high a learning rate as the last ones, so we should probably use different learning rates for those—this is known as using *discriminative learning rates*."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Discriminative Learning Rates"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Even after we unfreeze, we still care a lot about the quality of those pretrained weights. We would not expect that the best learning rate for those pretrained parameters would be as high as for the randomly added parameters, even after we have tuned those randomly added parameters for a few epochs. Remember, the pretrained weights have been trained for hundreds of epochs, on millions of images.\n",
    "\n",
    "In addition, do you remember the images we saw in <<chapter_intro>>, showing what each layer learns? The first layer learns very simple foundations, like edge and gradient detectors; these are likely to be just as useful for nearly any task. The later layers learn much more complex concepts, like \"eye\" and \"sunset,\" which might not be useful in your task at all (maybe you're classifying car models, for instance). So it makes sense to let the later layers fine-tune more quickly than earlier layers.\n",
    "\n",
    "Therefore, fastai's default approach is to use discriminative learning rates. This was originally developed in the ULMFiT approach to NLP transfer learning that we will introduce in <<chapter_nlp>>. Like many good ideas in deep learning, it is extremely simple: use a lower learning rate for the early layers of the neural network, and a higher learning rate for the later layers (and especially the randomly added layers). The idea is based on insights developed by [Jason Yosinski](https://arxiv.org/abs/1411.1792), who showed in 2014 that with transfer learning different layers of a neural network should train at different speeds, as seen in <<yosinski>>."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<img alt=\"Impact of different layers and training methods on transfer learning (Yosinski)\" width=\"680\" caption=\"Impact of different layers and training methods on transfer learning (courtesy of Jason Yosinski et al.)\" id=\"yosinski\" src=\"images/att_00039.png\">"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "fastai lets you pass a Python `slice` object anywhere that a learning rate is expected. The first value passed will be the learning rate in the earliest layer of the neural network, and the second value will be the learning rate in the final layer. The layers in between will have learning rates that are multiplicatively equidistant throughout that range. Let's use this approach to replicate the previous training, but this time we'll only set the *lowest* layer of our net to a learning rate of 1e-6; the other layers will scale up to 1e-4. Let's train for a while and see what happens:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: left;\">\n",
       "      <th>epoch</th>\n",
       "      <th>train_loss</th>\n",
       "      <th>valid_loss</th>\n",
       "      <th>error_rate</th>\n",
       "      <th>time</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <td>0</td>\n",
       "      <td>1.145300</td>\n",
       "      <td>0.345568</td>\n",
       "      <td>0.119756</td>\n",
       "      <td>00:20</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>1</td>\n",
       "      <td>0.533986</td>\n",
       "      <td>0.251944</td>\n",
       "      <td>0.077131</td>\n",
       "      <td>00:20</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>2</td>\n",
       "      <td>0.317696</td>\n",
       "      <td>0.208371</td>\n",
       "      <td>0.069012</td>\n",
       "      <td>00:20</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/html": [
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: left;\">\n",
       "      <th>epoch</th>\n",
       "      <th>train_loss</th>\n",
       "      <th>valid_loss</th>\n",
       "      <th>error_rate</th>\n",
       "      <th>time</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <td>0</td>\n",
       "      <td>0.257977</td>\n",
       "      <td>0.205400</td>\n",
       "      <td>0.067659</td>\n",
       "      <td>00:25</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>1</td>\n",
       "      <td>0.246763</td>\n",
       "      <td>0.205107</td>\n",
       "      <td>0.066306</td>\n",
       "      <td>00:25</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>2</td>\n",
       "      <td>0.240595</td>\n",
       "      <td>0.193848</td>\n",
       "      <td>0.062246</td>\n",
       "      <td>00:25</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>3</td>\n",
       "      <td>0.209988</td>\n",
       "      <td>0.198061</td>\n",
       "      <td>0.062923</td>\n",
       "      <td>00:25</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>4</td>\n",
       "      <td>0.194756</td>\n",
       "      <td>0.193130</td>\n",
       "      <td>0.064276</td>\n",
       "      <td>00:25</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>5</td>\n",
       "      <td>0.169985</td>\n",
       "      <td>0.187885</td>\n",
       "      <td>0.056157</td>\n",
       "      <td>00:25</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>6</td>\n",
       "      <td>0.153205</td>\n",
       "      <td>0.186145</td>\n",
       "      <td>0.058863</td>\n",
       "      <td>00:25</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>7</td>\n",
       "      <td>0.141480</td>\n",
       "      <td>0.185316</td>\n",
       "      <td>0.053451</td>\n",
       "      <td>00:25</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>8</td>\n",
       "      <td>0.128564</td>\n",
       "      <td>0.180999</td>\n",
       "      <td>0.051421</td>\n",
       "      <td>00:25</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>9</td>\n",
       "      <td>0.126941</td>\n",
       "      <td>0.186288</td>\n",
       "      <td>0.054127</td>\n",
       "      <td>00:25</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>10</td>\n",
       "      <td>0.130064</td>\n",
       "      <td>0.181764</td>\n",
       "      <td>0.054127</td>\n",
       "      <td>00:25</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>11</td>\n",
       "      <td>0.124281</td>\n",
       "      <td>0.181855</td>\n",
       "      <td>0.054127</td>\n",
       "      <td>00:25</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "learn = vision_learner(dls, resnet34, metrics=error_rate)\n",
    "learn.fit_one_cycle(3, 3e-3)\n",
    "learn.unfreeze()\n",
    "learn.fit_one_cycle(12, lr_max=slice(1e-6,1e-4))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now the fine-tuning is working great!\n",
    "\n",
    "fastai can show us a graph of the training and validation loss:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "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_loss()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As you can see, the training loss keeps getting better and better. But notice that eventually the validation loss improvement slows, and sometimes even gets worse! This is the point at which the model is starting to over fit. In particular, the model is becoming overconfident of its predictions. But this does *not* mean that it is getting less accurate, necessarily. Take a look at the table of training results per epoch, and you will often see that the accuracy continues improving, even as the validation loss gets worse. In the end what matters is your accuracy, or more generally your chosen metrics, not the loss. The loss is just the function we've given the computer to help us to optimize."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Another decision you have to make when training the model is for how long to train for. We'll consider that next."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Selecting the Number of Epochs"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Often you will find that you are limited by time, rather than generalization and accuracy, when choosing how many epochs to train for. So your first approach to training should be to simply pick a number of epochs that will train in the amount of time that you are happy to wait for. Then look at the training and validation loss plots, as shown above, and in particular your metrics, and if you see that they are still getting better even in your final epochs, then you know that you have not trained for too long.\n",
    "\n",
    "On the other hand, you may well see that the metrics you have chosen are really getting worse at the end of training. Remember, it's not just that we're looking for the validation loss to get worse, but the actual metrics. Your validation loss will first get worse during training because the model gets overconfident, and only later will get worse because it is incorrectly memorizing the data. We only care in practice about the latter issue. Remember, our loss function is just something that we use to allow our optimizer to have something it can differentiate and optimize; it's not actually the thing we care about in practice.\n",
    "\n",
    "Before the days of 1cycle training it was very common to save the model at the end of each epoch, and then select whichever model had the best accuracy out of all of the models saved in each epoch. This is known as *early stopping*. However, this is very unlikely to give you the best answer, because those epochs in the middle occur before the learning rate has had a chance to reach the small values, where it can really find the best result. Therefore, if you find that you have overfit, what you should actually do is retrain your model from scratch, and this time select a total number of epochs based on where your previous best results were found.\n",
    "\n",
    "If you have the time to train for more epochs, you may want to instead use that time to train more parameters—that is, use a deeper architecture."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Deeper Architectures"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In general, a model with more parameters can model your data more accurately. (There are lots and lots of caveats to this generalization, and it depends on the specifics of the architectures you are using, but it is a reasonable rule of thumb for now.) For most of the architectures that we will be seeing in this book, you can create larger versions of them by simply adding more layers. However, since we want to use pretrained models, we need to make sure that we choose a number of layers that have already been pretrained for us.\n",
    "\n",
    "This is why, in practice, architectures tend to come in a small number of variants. For instance, the ResNet architecture that we are using in this chapter comes in variants with 18, 34, 50, 101, and 152 layer, pretrained on ImageNet. A larger (more layers and parameters; sometimes described as the \"capacity\" of a model) version of a ResNet will always be able to give us a better training loss, but it can suffer more from overfitting, because it has more parameters to overfit with.\n",
    "\n",
    "In general, a bigger model has the ability to better capture the real underlying relationships in your data, and also to capture and memorize the specific details of your individual images.\n",
    "\n",
    "However, using a deeper model is going to require more GPU RAM, so you may need to lower the size of your batches to avoid an *out-of-memory error*. This happens when you try to fit too much inside your GPU and looks like:\n",
    "\n",
    "```\n",
    "Cuda runtime error: out of memory\n",
    "```\n",
    "\n",
    "You may have to restart your notebook when this happens. The way to solve it is to use a smaller batch size, which means passing smaller groups of images at any given time through your model. You can pass the batch size you want to the call creating your `DataLoaders` with `bs=`.\n",
    "\n",
    "The other downside of deeper architectures is that they take quite a bit longer to train. One technique that can speed things up a lot is *mixed-precision training*. This refers to using less-precise numbers (*half-precision floating point*, also called *fp16*) where possible during training. As we are writing these words in early 2020, nearly all current NVIDIA GPUs support a special feature called *tensor cores* that can dramatically speed up neural network training, by 2-3x. They also require a lot less GPU memory. To enable this feature in fastai, just add `to_fp16()` after your `Learner` creation (you also need to import the module).\n",
    "\n",
    "You can't really know ahead of time what the best architecture for your particular problem is—you need to try training some. So let's try a ResNet-50 now with mixed precision:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: left;\">\n",
       "      <th>epoch</th>\n",
       "      <th>train_loss</th>\n",
       "      <th>valid_loss</th>\n",
       "      <th>error_rate</th>\n",
       "      <th>time</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <td>0</td>\n",
       "      <td>1.427505</td>\n",
       "      <td>0.310554</td>\n",
       "      <td>0.098782</td>\n",
       "      <td>00:21</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>1</td>\n",
       "      <td>0.606785</td>\n",
       "      <td>0.302325</td>\n",
       "      <td>0.094723</td>\n",
       "      <td>00:22</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>2</td>\n",
       "      <td>0.409267</td>\n",
       "      <td>0.294803</td>\n",
       "      <td>0.091340</td>\n",
       "      <td>00:21</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/html": [
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: left;\">\n",
       "      <th>epoch</th>\n",
       "      <th>train_loss</th>\n",
       "      <th>valid_loss</th>\n",
       "      <th>error_rate</th>\n",
       "      <th>time</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <td>0</td>\n",
       "      <td>0.261121</td>\n",
       "      <td>0.274507</td>\n",
       "      <td>0.083897</td>\n",
       "      <td>00:26</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>1</td>\n",
       "      <td>0.296653</td>\n",
       "      <td>0.318649</td>\n",
       "      <td>0.084574</td>\n",
       "      <td>00:26</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>2</td>\n",
       "      <td>0.242356</td>\n",
       "      <td>0.253677</td>\n",
       "      <td>0.069012</td>\n",
       "      <td>00:26</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>3</td>\n",
       "      <td>0.150684</td>\n",
       "      <td>0.251438</td>\n",
       "      <td>0.065629</td>\n",
       "      <td>00:26</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>4</td>\n",
       "      <td>0.094997</td>\n",
       "      <td>0.239772</td>\n",
       "      <td>0.064276</td>\n",
       "      <td>00:26</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>5</td>\n",
       "      <td>0.061144</td>\n",
       "      <td>0.228082</td>\n",
       "      <td>0.054804</td>\n",
       "      <td>00:26</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "from fastai.callback.fp16 import *\n",
    "learn = vision_learner(dls, resnet50, metrics=error_rate).to_fp16()\n",
    "learn.fine_tune(6, freeze_epochs=3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You'll see here we've gone back to using `fine_tune`, since it's so handy! We can pass `freeze_epochs` to tell fastai how many epochs to train for while frozen. It will automatically change learning rates appropriately for most datasets.\n",
    "\n",
    "In this case, we're not seeing a clear win from the deeper model. This is useful to remember—bigger models aren't necessarily better models for your particular case! Make sure you try small models before you start scaling up."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Conclusion"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In this chapter you learned some important practical tips, both for getting your image data ready for modeling (presizing, data block summary) and for fitting the model (learning rate finder, unfreezing, discriminative learning rates, setting the number of epochs, and using deeper architectures). Using these tools will help you to build more accurate image models, more quickly.\n",
    "\n",
    "We also discussed cross-entropy loss. This part of the book is worth spending plenty of time on. You aren't likely to need to actually implement cross-entropy loss from scratch yourself in practice, but it's really important you understand the inputs to and output from that function, because it (or a variant of it, as we'll see in the next chapter) is used in nearly every classification model. So when you want to debug a model, or put a model in production, or improve the accuracy of a model, you're going to need to be able to look at its activations and loss, and understand what's going on, and why. You can't do that properly if you don't understand your loss function.\n",
    "\n",
    "If cross-entropy loss hasn't \"clicked\" for you just yet, don't worry—you'll get there! First, go back to the last chapter and make sure you really understand `mnist_loss`. Then work gradually through the cells of the notebook for this chapter, where we step through each piece of cross-entropy loss. Make sure you understand what each calculation is doing, and why. Try creating some small tensors yourself and pass them into the functions, to see what they return.\n",
    "\n",
    "Remember: the choices made in the implementation of cross-entropy loss are not the only possible choices that could have been made. Just like when we looked at regression we could choose between mean squared error and mean absolute difference (L1). If you have other ideas for possible functions that you think might work, feel free to give them a try in this chapter's notebook! (Fair warning though: you'll probably find that the model will be slower to train, and less accurate. That's because the gradient of cross-entropy loss is proportional to the difference between the activation and the target, so SGD always gets a nicely scaled step for the weights.)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Questionnaire"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "1. Why do we first resize to a large size on the CPU, and then to a smaller size on the GPU?\n",
    "1. If you are not familiar with regular expressions, find a regular expression tutorial, and some problem sets, and complete them. Have a look on the book's website for suggestions.\n",
    "1. What are the two ways in which data is most commonly provided, for most deep learning datasets?\n",
    "1. Look up the documentation for `L` and try using a few of the new methods that it adds.\n",
    "1. Look up the documentation for the Python `pathlib` module and try using a few methods of the `Path` class.\n",
    "1. Give two examples of ways that image transformations can degrade the quality of the data.\n",
    "1. What method does fastai provide to view the data in a `DataLoaders`?\n",
    "1. What method does fastai provide to help you debug a `DataBlock`?\n",
    "1. Should you hold off on training a model until you have thoroughly cleaned your data?\n",
    "1. What are the two pieces that are combined into cross-entropy loss in PyTorch?\n",
    "1. What are the two properties of activations that softmax ensures? Why is this important?\n",
    "1. When might you want your activations to not have these two properties?\n",
    "1. Calculate the `exp` and `softmax` columns of <<bear_softmax>> yourself (i.e., in a spreadsheet, with a calculator, or in a notebook).\n",
    "1. Why can't we use `torch.where` to create a loss function for datasets where our label can have more than two categories?\n",
    "1. What is the value of log(-2)? Why?\n",
    "1. What are two good rules of thumb for picking a learning rate from the learning rate finder?\n",
    "1. What two steps does the `fine_tune` method do?\n",
    "1. In Jupyter Notebook, how do you get the source code for a method or function?\n",
    "1. What are discriminative learning rates?\n",
    "1. How is a Python `slice` object interpreted when passed as a learning rate to fastai?\n",
    "1. Why is early stopping a poor choice when using 1cycle training?\n",
    "1. What is the difference between `resnet50` and `resnet101`?\n",
    "1. What does `to_fp16` do?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Further Research"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "1. Find the paper by Leslie Smith that introduced the learning rate finder, and read it.\n",
    "1. See if you can improve the accuracy of the classifier in this chapter. What's the best accuracy you can achieve? Look on the forums and the book's website to see what other students have achieved with this dataset, and how they did it."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "jupytext": {
   "split_at_heading": true
  },
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}