{ "cells": [ { "cell_type": "markdown", "metadata": {}, "source": [ "# Chapter 11 - Data Munging with FastAi Mid-layer API \n", "> This chapter is not directly ML but mostly FastAi API costomizations. Looks great. At this point I think I need to use FastAI in at least a toy project. These files must be developed overtime. It a source for me.\n", "- toc: true \n", "- badges: true\n", "- comments: true\n", "- categories: [fastbook]\n", "- image: images/fastbook_images/chapter-11/dataM.png" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "![](images/chapter-11/dataM.png)" ] }, { "cell_type": "code", "execution_count": 1, "metadata": {}, "outputs": [], "source": [ "#hide\n", "#!pip install -Uqq fastbook\n", "import fastbook\n", "fastbook.setup_book()" ] }, { "cell_type": "code", "execution_count": 2, "metadata": {}, "outputs": [], "source": [ "#hide\n", "from fastbook import *\n", "from IPython.display import display,HTML" ] }, { "cell_type": "raw", "metadata": {}, "source": [ "[[chapter_midlevel_data]]" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "# Data Munging with fastai's Mid-Level API" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "We have seen what `Tokenizer` and `Numericalize` do to a collection of texts, and how they're used inside the data block API, which handles those transforms for us directly using the `TextBlock`. But what if we want to only apply one of those transforms, either to see intermediate results or because we have already tokenized texts? More generally, what can we do when the data block API is not flexible enough to accommodate our particular use case? For this, we need to use fastai's *mid-level API* for processing data. The data block API is built on top of that layer, so it will allow you to do everything the data block API does, and much much more." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Going Deeper into fastai's Layered API" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "The fastai library is built on a *layered API*. In the very top layer there are *applications* that allow us to train a model in five lines of codes, as we saw in <>. In the case of creating `DataLoaders` for a text classifier, for instance, we used the line:" ] }, { "cell_type": "code", "execution_count": 3, "metadata": {}, "outputs": [], "source": [ "from fastai.text.all import *\n", "\n", "dls = TextDataLoaders.from_folder(untar_data(URLs.IMDB), valid='test')" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "The factory method `TextDataLoaders.from_folder` is very convenient when your data is arranged the exact same way as the IMDb dataset, but in practice, that often won't be the case. The data block API offers more flexibility. As we saw in the last chapter, we can get the same result with:" ] }, { "cell_type": "code", "execution_count": 4, "metadata": {}, "outputs": [], "source": [ "path = untar_data(URLs.IMDB)\n", "dls = DataBlock(\n", " blocks=(TextBlock.from_folder(path),CategoryBlock),\n", " get_y = parent_label,\n", " get_items=partial(get_text_files, folders=['train', 'test']),\n", " splitter=GrandparentSplitter(valid_name='test')\n", ").dataloaders(path)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "But it's sometimes not flexible enough. For debugging purposes, for instance, we might need to apply just parts of the transforms that come with this data block. Or we might want to create a `DataLoaders` for some application that isn't directly supported by fastai. In this section, we'll dig into the pieces that are used inside fastai to implement the data block API. Understanding these will enable you to leverage the power and flexibility of this mid-tier API." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "> note: Mid-Level API: The mid-level API does not only contain functionality for creating `DataLoaders`. It also has the _callback_ system, which allows us to customize the training loop any way we like, and the _general optimizer_. Both will be covered in <>." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Transforms" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "When we studied tokenization and numericalization in the last chapter, we started by grabbing a bunch of texts:" ] }, { "cell_type": "code", "execution_count": 5, "metadata": {}, "outputs": [], "source": [ "files = get_text_files(path, folders = ['train', 'test'])\n", "txts = L(o.open().read() for o in files[:2000])" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "We then showed how to tokenize them with a `Tokenizer`:" ] }, { "cell_type": "code", "execution_count": 6, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "(#206) ['xxbos','i','had','never','heard','of','this','film','until','i'...]" ] }, "execution_count": 6, "metadata": {}, "output_type": "execute_result" } ], "source": [ "tok = Tokenizer.from_folder(path)\n", "tok.setup(txts)\n", "toks = txts.map(tok)\n", "toks[0]" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "and how to numericalize, including automatically creating the vocab for our corpus:" ] }, { "cell_type": "code", "execution_count": 7, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "TensorText([ 2, 19, 87, 137, 617, 14, 21, 30, 355, 19])" ] }, "execution_count": 7, "metadata": {}, "output_type": "execute_result" } ], "source": [ "num = Numericalize()\n", "num.setup(toks)\n", "nums = toks.map(num)\n", "nums[0][:10]" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "The classes also have a `decode` method. For instance, `Numericalize.decode` gives us back the string tokens:" ] }, { "cell_type": "code", "execution_count": 9, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "(#10) ['xxbos','i','had','never','heard','of','this','film','until','i']" ] }, "execution_count": 9, "metadata": {}, "output_type": "execute_result" } ], "source": [ "nums_dec = num.decode(nums[0][:10]); nums_dec" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "and `Tokenizer.decode` turns this back into a single string (it may not, however, be exactly the same as the original string; this depends on whether the tokenizer is *reversible*, which the default word tokenizer is not at the time we're writing this book):" ] }, { "cell_type": "code", "execution_count": 10, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "'xxbos i had never heard of this film until i'" ] }, "execution_count": 10, "metadata": {}, "output_type": "execute_result" } ], "source": [ "tok.decode(nums_dec)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "`decode` is used by fastai's `show_batch` and `show_results`, as well as some other inference methods, to convert predictions and mini-batches into a human-understandable representation.\n", "\n", "For each of `tok` or `num` in the preceding example, we created an object, called the `setup` method (which trains the tokenizer if needed for `tok` and creates the vocab for `num`), applied it to our raw texts (by calling the object as a function), and then finally decoded the result back to an understandable representation. These steps are needed for most data preprocessing tasks, so fastai provides a class that encapsulates them. This is the `Transform` class. Both `Tokenize` and `Numericalize` are `Transform`s.\n", "\n", "In general, a `Transform` is an object that behaves like a function and has an optional `setup` method that will initialize some inner state (like the vocab inside `num`) and an optional `decode` that will reverse the function (this reversal may not be perfect, as we saw with `tok`).\n", "\n", "A good example of `decode` is found in the `Normalize` transform that we saw in <>: to be able to plot the images its `decode` method undoes the normalization (i.e., it multiplies by the standard deviation and adds back the mean). On the other hand, data augmentation transforms do not have a `decode` method, since we want to show the effects on images to make sure the data augmentation is working as we want.\n", "\n", "A special behavior of `Transform`s is that they always get applied over tuples. In general, our data is always a tuple `(input,target)` (sometimes with more than one input or more than one target). When applying a transform on an item like this, such as `Resize`, we don't want to resize the tuple as a whole; instead, we want to resize the input (if applicable) and the target (if applicable) separately. It's the same for batch transforms that do data augmentation: when the input is an image and the target is a segmentation mask, the transform needs to be applied (the same way) to the input and the target.\n", "\n", "We can see this behavior if we pass a tuple of texts to `tok`:" ] }, { "cell_type": "code", "execution_count": 11, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "((#206) ['xxbos','i','had','never','heard','of','this','film','until','i'...],\n", " (#498) ['xxbos','\"','ardh','xxmaj','satya','\"','is','one','of','the'...])" ] }, "execution_count": 11, "metadata": {}, "output_type": "execute_result" } ], "source": [ "tok((txts[0], txts[1]))" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Writing Your Own Transform" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "If you want to write a custom transform to apply to your data, the easiest way is to write a function. As you can see in this example, a `Transform` will only be applied to a matching type, if a type is provided (otherwise it will always be applied). In the following code, the `:int` in the function signature means that `f` only gets applied to `int`s. That's why `tfm(2.0)` returns `2.0`, but `tfm(2)` returns `3` here:" ] }, { "cell_type": "code", "execution_count": 12, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "(3, 2.0)" ] }, "execution_count": 12, "metadata": {}, "output_type": "execute_result" } ], "source": [ "def f(x:int): return x+1\n", "tfm = Transform(f)\n", "tfm(2),tfm(2.0)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "> Note: I didn't know that is possible. `x:int` usage is very surprising. Is it python or FastAI?" ] }, { "cell_type": "code", "execution_count": 15, "metadata": { "scrolled": true }, "outputs": [ { "data": { "text/plain": [ "(3, 3.0)" ] }, "execution_count": 15, "metadata": {}, "output_type": "execute_result" } ], "source": [ "def f(x:int): return x+1\n", "\n", "f(2),f(2.0)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "> Note: Oh it is FastAI." ] }, { "cell_type": "code", "execution_count": 13, "metadata": {}, "outputs": [], "source": [ "doc(Transform)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Here, `f` is converted to a `Transform` with no `setup` and no `decode` method.\n", "\n", "Python has a special syntax for passing a function (like `f`) to another function (or something that behaves like a function, known as a *callable* in Python), called a *decorator*. A decorator is used by prepending a callable with `@` and placing it before a function definition (there are lots of good online tutorials about Python decorators, so take a look at one if this is a new concept for you). The following is identical to the previous code:" ] }, { "cell_type": "code", "execution_count": 16, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "(3, 2.0)" ] }, "execution_count": 16, "metadata": {}, "output_type": "execute_result" } ], "source": [ "@Transform\n", "def f(x:int): return x+1\n", "f(2),f(2.0)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "If you need either `setup` or `decode`, you will need to subclass `Transform` to implement the actual encoding behavior in `encodes`, then (optionally), the setup behavior in `setups` and the decoding behavior in `decodes`:" ] }, { "cell_type": "code", "execution_count": 17, "metadata": {}, "outputs": [], "source": [ "class NormalizeMean(Transform):\n", " def setups(self, items): self.mean = sum(items)/len(items)\n", " def encodes(self, x): return x-self.mean\n", " def decodes(self, x): return x+self.mean" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Here, `NormalizeMean` will initialize some state during the setup (the mean of all elements passed), then the transformation is to subtract that mean. For decoding purposes, we implement the reverse of that transformation by adding the mean. Here is an example of `NormalizeMean` in action:" ] }, { "cell_type": "code", "execution_count": 18, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "(3.0, -1.0, 2.0)" ] }, "execution_count": 18, "metadata": {}, "output_type": "execute_result" } ], "source": [ "tfm = NormalizeMean()\n", "tfm.setup([1,2,3,4,5])\n", "start = 2\n", "y = tfm(start)\n", "z = tfm.decode(y)\n", "tfm.mean,y,z" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Note that the method called and the method implemented are different, for each of these methods:\n", "\n", "```asciidoc\n", "[options=\"header\"]\n", "|======\n", "| Class | To call | To implement\n", "| `nn.Module` (PyTorch) | `()` (i.e., call as function) | `forward`\n", "| `Transform` | `()` | `encodes`\n", "| `Transform` | `decode()` | `decodes`\n", "| `Transform` | `setup()` | `setups`\n", "|======\n", "```\n", "\n", "So, for instance, you would never call `setups` directly, but instead would call `setup`. The reason for this is that `setup` does some work before and after calling `setups` for you. To learn more about `Transform`s and how you can use them to implement different behavior depending on the type of the input, be sure to check the tutorials in the fastai docs." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Pipeline" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "To compose several transforms together, fastai provides the `Pipeline` class. We define a `Pipeline` by passing it a list of `Transform`s; it will then compose the transforms inside it. When you call `Pipeline` on an object, it will automatically call the transforms inside, in order:" ] }, { "cell_type": "code", "execution_count": 19, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "TensorText([ 2, 19, 87, 137, 617, 14, 21, 30, 355, 19, 356, 678, 18, 44, 1736, 68, 0, 7, 1292, 11])" ] }, "execution_count": 19, "metadata": {}, "output_type": "execute_result" } ], "source": [ "tfms = Pipeline([tok, num])\n", "t = tfms(txts[0]); t[:20]" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "And you can call `decode` on the result of your encoding, to get back something you can display and analyze:" ] }, { "cell_type": "code", "execution_count": 20, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "'xxbos i had never heard of this film until i came across it by accident when xxunk xxup imdb . i saw'" ] }, "execution_count": 20, "metadata": {}, "output_type": "execute_result" } ], "source": [ "tfms.decode(t)[:100]" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "The only part that doesn't work the same way as in `Transform` is the setup. To properly set up a `Pipeline` of `Transform`s on some data, you need to use a `TfmdLists`." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## TfmdLists and Datasets: Transformed Collections" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Your data is usually a set of raw items (like filenames, or rows in a DataFrame) to which you want to apply a succession of transformations. We just saw that a succession of transformations is represented by a `Pipeline` in fastai. The class that groups together this `Pipeline` with your raw items is called `TfmdLists`." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### TfmdLists" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Here is the short way of doing the transformation we saw in the previous section:" ] }, { "cell_type": "code", "execution_count": 21, "metadata": {}, "outputs": [], "source": [ "tls = TfmdLists(files, [Tokenizer.from_folder(path), Numericalize])" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "At initialization, the `TfmdLists` will automatically call the `setup` method of each `Transform` in order, providing them not with the raw items but the items transformed by all the previous `Transform`s in order. We can get the result of our `Pipeline` on any raw element just by indexing into the `TfmdLists`:" ] }, { "cell_type": "code", "execution_count": 22, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "TensorText([ 2, 19, 87, 133, 572, 14, 20, 32, 384, 19, 410, 619, 17, 48, 1639, 69, 13842, 7, 942, 10])" ] }, "execution_count": 22, "metadata": {}, "output_type": "execute_result" } ], "source": [ "t = tls[0]; t[:20]" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "'xxbos xxmaj well , \" cube \" ( 1997 ) , xxmaj vincenzo \\'s first movie , was one of the most interesti'" ] }, "execution_count": null, "metadata": {}, "output_type": "execute_result" } ], "source": [ "tls.decode(t)[:100]" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "And the `TfmdLists` knows how to decode for show purposes:" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "In fact, it even has a `show` method:" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "xxbos xxmaj well , \" cube \" ( 1997 ) , xxmaj vincenzo 's first movie , was one of the most interesting and tricky ideas that xxmaj i 've ever seen when talking about movies . xxmaj they had just one scenery , a bunch of actors and a plot . xxmaj so , what made it so special were all the effective direction , great dialogs and a bizarre condition that characters had to deal like rats in a labyrinth . xxmaj his second movie , \" cypher \" ( 2002 ) , was all about its story , but it was n't so good as \" cube \" but here are the characters being tested like rats again . \n", "\n", " \" nothing \" is something very interesting and gets xxmaj vincenzo coming back to his ' cube days ' , locking the characters once again in a very different space with no time once more playing with the characters like playing with rats in an experience room . xxmaj but instead of a thriller sci - fi ( even some of the promotional teasers and trailers erroneous seemed like that ) , \" nothing \" is a loose and light comedy that for sure can be called a modern satire about our society and also about the intolerant world we 're living . xxmaj once again xxmaj xxunk amaze us with a great idea into a so small kind of thing . 2 actors and a blinding white scenario , that 's all you got most part of time and you do n't need more than that . xxmaj while \" cube \" is a claustrophobic experience and \" cypher \" confusing , \" nothing \" is completely the opposite but at the same time also desperate . \n", "\n", " xxmaj this movie proves once again that a smart idea means much more than just a millionaire budget . xxmaj of course that the movie fails sometimes , but its prime idea means a lot and offsets any flaws . xxmaj there 's nothing more to be said about this movie because everything is a brilliant surprise and a totally different experience that i had in movies since \" cube \" .\n" ] } ], "source": [ "tls.show(t)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "The `TfmdLists` is named with an \"s\" because it can handle a training and a validation set with a `splits` argument. You just need to pass the indices of which elements are in the training set, and which are in the validation set:" ] }, { "cell_type": "code", "execution_count": 29, "metadata": {}, "outputs": [], "source": [ "cut = int(len(files)*0.8)\n", "splits = [list(range(cut)), list(range(cut,len(files)))]\n", "tls = TfmdLists(files, [Tokenizer.from_folder(path), Numericalize], \n", " splits=splits)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "You can then access them through the `train` and `valid` attributes:" ] }, { "cell_type": "code", "execution_count": 31, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "TensorText([ 2, 8, 20, 30, 62, 208, 15, 43, 9, 463, 30, 19, 42, 145, 132, 10, 19, 83, 324, 60])" ] }, "execution_count": 31, "metadata": {}, "output_type": "execute_result" } ], "source": [ "tls.valid[0][:20]" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "If you have manually written a `Transform` that performs all of your preprocessing at once, turning raw items into a tuple with inputs and targets, then `TfmdLists` is the class you need. You can directly convert it to a `DataLoaders` object with the `dataloaders` method. This is what we will do in our Siamese example later in this chapter.\n", "\n", "In general, though, you will have two (or more) parallel pipelines of transforms: one for processing your raw items into inputs and one to process your raw items into targets. For instance, here, the pipeline we defined only processes the raw text into inputs. If we want to do text classification, we also have to process the labels into targets. \n", "\n", "For this we need to do two things. First we take the label name from the parent folder. There is a function, `parent_label`, for this:" ] }, { "cell_type": "code", "execution_count": 33, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "(#50000) ['pos','pos','pos','pos','pos','pos','pos','pos','pos','pos'...]" ] }, "execution_count": 33, "metadata": {}, "output_type": "execute_result" } ], "source": [ "lbls = files.map(parent_label)\n", "lbls" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Then we need a `Transform` that will grab the unique items and build a vocab with them during setup, then transform the string labels into integers when called. fastai provides this for us; it's called `Categorize`:" ] }, { "cell_type": "code", "execution_count": 34, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "(['neg', 'pos'], TensorCategory(1))" ] }, "execution_count": 34, "metadata": {}, "output_type": "execute_result" } ], "source": [ "cat = Categorize()\n", "cat.setup(lbls)\n", "cat.vocab, cat(lbls[0])" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "To do the whole setup automatically on our list of files, we can create a `TfmdLists` as before:" ] }, { "cell_type": "code", "execution_count": 35, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "TensorCategory(1)" ] }, "execution_count": 35, "metadata": {}, "output_type": "execute_result" } ], "source": [ "tls_y = TfmdLists(files, [parent_label, Categorize()])\n", "tls_y[0]" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "But then we end up with two separate objects for our inputs and targets, which is not what we want. This is where `Datasets` comes to the rescue." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Datasets" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "`Datasets` will apply two (or more) pipelines in parallel to the same raw object and build a tuple with the result. Like `TfmdLists`, it will automatically do the setup for us, and when we index into a `Datasets`, it will return us a tuple with the results of each pipeline:" ] }, { "cell_type": "code", "execution_count": 36, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "(TensorText([ 2, 19, 87, 133, 572, 14, 20, 32, 384, 19, 410, 619, 17, 48, 1639, 69, 13842, 7, 942, 10]),\n", " TensorCategory(1))" ] }, "execution_count": 36, "metadata": {}, "output_type": "execute_result" } ], "source": [ "x_tfms = [Tokenizer.from_folder(path), Numericalize]\n", "y_tfms = [parent_label, Categorize()]\n", "dsets = Datasets(files, [x_tfms, y_tfms])\n", "x,y = dsets[0]\n", "x[:20],y" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Like a `TfmdLists`, we can pass along `splits` to a `Datasets` to split our data between training and validation sets:" ] }, { "cell_type": "code", "execution_count": 37, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "(TensorText([ 2, 8, 20, 30, 62, 208, 15, 43, 9, 463, 30, 19, 42, 145, 132, 10, 19, 83, 324, 60]),\n", " TensorCategory(0))" ] }, "execution_count": 37, "metadata": {}, "output_type": "execute_result" } ], "source": [ "x_tfms = [Tokenizer.from_folder(path), Numericalize]\n", "y_tfms = [parent_label, Categorize()]\n", "dsets = Datasets(files, [x_tfms, y_tfms], splits=splits)\n", "x,y = dsets.valid[0]\n", "x[:20],y" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "It can also decode any processed tuple or show it directly:" ] }, { "cell_type": "code", "execution_count": 38, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "('xxbos xxmaj this movie has got to be the worse movie i have ever seen . i only watched about a half an hour and i just shut it off . xxmaj the cars in this movie look like two geo metro \\'s front ends smashed together . xxmaj this movie is n\\'t even good for laughs . xxmaj the only time i laughed was when xxmaj dante kept saying in funny voice , \" nobody can beat xxmaj dante , xxmaj xxunk xxunk . \" i said holy god and shut it off . xxmaj bad , xxmaj bad movie . 2 / 10',\n", " 'neg')" ] }, "execution_count": 38, "metadata": {}, "output_type": "execute_result" } ], "source": [ "t = dsets.valid[0]\n", "dsets.decode(t)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "The last step is to convert our `Datasets` object to a `DataLoaders`, which can be done with the `dataloaders` method. Here we need to pass along a special argument to take care of the padding problem (as we saw in the last chapter). This needs to happen just before we batch the elements, so we pass it to `before_batch`: " ] }, { "cell_type": "code", "execution_count": 39, "metadata": {}, "outputs": [], "source": [ "dls = dsets.dataloaders(bs=64, before_batch=pad_input)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "`dataloaders` directly calls `DataLoader` on each subset of our `Datasets`. fastai's `DataLoader` expands the PyTorch class of the same name and is responsible for collating the items from our datasets into batches. It has a lot of points of customization, but the most important ones that you should know are:\n", "\n", "- `after_item`:: Applied on each item after grabbing it inside the dataset. This is the equivalent of `item_tfms` in `DataBlock`.\n", "- `before_batch`:: Applied on the list of items before they are collated. This is the ideal place to pad items to the same size.\n", "- `after_batch`:: Applied on the batch as a whole after its construction. This is the equivalent of `batch_tfms` in `DataBlock`." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "As a conclusion, here is the full code necessary to prepare the data for text classification:" ] }, { "cell_type": "code", "execution_count": 40, "metadata": {}, "outputs": [], "source": [ "tfms = [[Tokenizer.from_folder(path), Numericalize], [parent_label, Categorize]]\n", "files = get_text_files(path, folders = ['train', 'test'])\n", "splits = GrandparentSplitter(valid_name='test')(files)\n", "dsets = Datasets(files, tfms, splits=splits)\n", "dls = dsets.dataloaders(dl_type=SortedDL, before_batch=pad_input)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "The two differences from the previous code are the use of `GrandparentSplitter` to split our training and validation data, and the `dl_type` argument. This is to tell `dataloaders` to use the `SortedDL` class of `DataLoader`, and not the usual one. `SortedDL` constructs batches by putting samples of roughly the same lengths into batches.\n", "\n", "This does the exact same thing as our previous `DataBlock`:" ] }, { "cell_type": "code", "execution_count": 41, "metadata": {}, "outputs": [], "source": [ "path = untar_data(URLs.IMDB)\n", "dls = DataBlock(\n", " blocks=(TextBlock.from_folder(path),CategoryBlock),\n", " get_y = parent_label,\n", " get_items=partial(get_text_files, folders=['train', 'test']),\n", " splitter=GrandparentSplitter(valid_name='test')\n", ").dataloaders(path)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "But now, you know how to customize every single piece of it!\n", "\n", "Let's practice what we just learned about this mid-level API for data preprocessing, using a computer vision example now." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Applying the Mid-Level Data API: SiamesePair" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "A *Siamese model* takes two images and has to determine if they are of the same class or not. For this example, we will use the Pet dataset again and prepare the data for a model that will have to predict if two images of pets are of the same breed or not. We will explain here how to prepare the data for such a model, then we will train that model in <>.\n", "\n", "First things first, let's get the images in our dataset:" ] }, { "cell_type": "code", "execution_count": 42, "metadata": {}, "outputs": [], "source": [ "from fastai.vision.all import *\n", "path = untar_data(URLs.PETS)\n", "files = get_image_files(path/\"images\")" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "If we didn't care about showing our objects at all, we could directly create one transform to completely preprocess that list of files. We will want to look at those images though, so we need to create a custom type. When you call the `show` method on a `TfmdLists` or a `Datasets` object, it will decode items until it reaches a type that contains a `show` method and use it to show the object. That `show` method gets passed a `ctx`, which could be a `matplotlib` axis for images, or a row of a DataFrame for texts.\n", "\n", "Here we create a `SiameseImage` object that subclasses `fastuple` and is intended to contain three things: two images, and a Boolean that's `True` if the images are of the same breed. We also implement the special `show` method, such that it concatenates the two images with a black line in the middle. Don't worry too much about the part that is in the `if` test (which is to show the `SiameseImage` when the images are Python images, not tensors); the important part is in the last three lines:" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "> Note: need the check what is `fastuple` ?" ] }, { "cell_type": "code", "execution_count": 44, "metadata": {}, "outputs": [], "source": [ "doc(fastuple)" ] }, { "cell_type": "code", "execution_count": 43, "metadata": {}, "outputs": [], "source": [ "class SiameseImage(fastuple):\n", " def show(self, ctx=None, **kwargs): \n", " img1,img2,same_breed = self\n", " if not isinstance(img1, Tensor):\n", " if img2.size != img1.size: img2 = img2.resize(img1.size)\n", " t1,t2 = tensor(img1),tensor(img2)\n", " t1,t2 = t1.permute(2,0,1),t2.permute(2,0,1)\n", " else: t1,t2 = img1,img2\n", " line = t1.new_zeros(t1.shape[0], t1.shape[1], 10)\n", " return show_image(torch.cat([t1,line,t2], dim=2), \n", " title=same_breed, ctx=ctx)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Let's create a first `SiameseImage` and check our `show` method works:" ] }, { "cell_type": "code", "execution_count": 45, "metadata": {}, "outputs": [ { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "img = PILImage.create(files[0])\n", "s = SiameseImage(img, img, True)\n", "s.show();" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "We can also try with a second image that's not from the same class:" ] }, { "cell_type": "code", "execution_count": 46, "metadata": {}, "outputs": [ { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "img1 = PILImage.create(files[1])\n", "s1 = SiameseImage(img, img1, False)\n", "s1.show();" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "The important thing with transforms that we saw before is that they dispatch over tuples or their subclasses. That's precisely why we chose to subclass `fastuple` in this instance—this way we can apply any transform that works on images to our `SiameseImage` and it will be applied on each image in the tuple:" ] }, { "cell_type": "code", "execution_count": 47, "metadata": {}, "outputs": [ { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "s2 = Resize(224)(s1)\n", "s2.show();" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Here the `Resize` transform is applied to each of the two images, but not the Boolean flag. Even if we have a custom type, we can thus benefit from all the data augmentation transforms inside the library.\n", "\n", "We are now ready to build the `Transform` that we will use to get our data ready for a Siamese model. First, we will need a function to determine the classes of all our images:" ] }, { "cell_type": "code", "execution_count": 48, "metadata": {}, "outputs": [], "source": [ "def label_func(fname):\n", " return re.match(r'^(.*)_\\d+.jpg$', fname.name).groups()[0]" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "For each image our tranform will, with a probability of 0.5, draw an image from the same class and return a `SiameseImage` with a true label, or draw an image from another class and return a `SiameseImage` with a false label. This is all done in the private `_draw` function. There is one difference between the training and validation sets, which is why the transform needs to be initialized with the splits: on the training set we will make that random pick each time we read an image, whereas on the validation set we make this random pick once and for all at initialization. This way, we get more varied samples during training, but always the same validation set:" ] }, { "cell_type": "code", "execution_count": 49, "metadata": {}, "outputs": [], "source": [ "class SiameseTransform(Transform):\n", " def __init__(self, files, label_func, splits):\n", " self.labels = files.map(label_func).unique()\n", " self.lbl2files = {l: L(f for f in files if label_func(f) == l) \n", " for l in self.labels}\n", " self.label_func = label_func\n", " self.valid = {f: self._draw(f) for f in files[splits[1]]}\n", " \n", " def encodes(self, f):\n", " f2,t = self.valid.get(f, self._draw(f))\n", " img1,img2 = PILImage.create(f),PILImage.create(f2)\n", " return SiameseImage(img1, img2, t)\n", " \n", " def _draw(self, f):\n", " same = random.random() < 0.5\n", " cls = self.label_func(f)\n", " if not same: \n", " cls = random.choice(L(l for l in self.labels if l != cls)) \n", " return random.choice(self.lbl2files[cls]),same" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "We can then create our main transform:" ] }, { "cell_type": "code", "execution_count": 50, "metadata": {}, "outputs": [ { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "splits = RandomSplitter()(files)\n", "tfm = SiameseTransform(files, label_func, splits)\n", "tfm(files[0]).show();" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "In the mid-level API for data collection we have two objects that can help us apply transforms on a set of items, `TfmdLists` and `Datasets`. If you remember what we have just seen, one applies a `Pipeline` of transforms and the other applies several `Pipeline`s of transforms in parallel, to build tuples. Here, our main transform already builds the tuples, so we use `TfmdLists`:" ] }, { "cell_type": "code", "execution_count": 51, "metadata": {}, "outputs": [ { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "tls = TfmdLists(files, tfm, splits=splits)\n", "show_at(tls.valid, 0);" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "And we can finally get our data in `DataLoaders` by calling the `dataloaders` method. One thing to be careful of here is that this method does not take `item_tfms` and `batch_tfms` like a `DataBlock`. The fastai `DataLoader` has several hooks that are named after events; here what we apply on the items after they are grabbed is called `after_item`, and what we apply on the batch once it's built is called `after_batch`:" ] }, { "cell_type": "code", "execution_count": 52, "metadata": {}, "outputs": [], "source": [ "dls = tls.dataloaders(after_item=[Resize(224), ToTensor], \n", " after_batch=[IntToFloatTensor, Normalize.from_stats(*imagenet_stats)])" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Note that we need to pass more transforms than usual—that's because the data block API usually adds them automatically:\n", "\n", "- `ToTensor` is the one that converts images to tensors (again, it's applied on every part of the tuple).\n", "- `IntToFloatTensor` converts the tensor of images containing integers from 0 to 255 to a tensor of floats, and divides by 255 to make the values between 0 and 1." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "We can now train a model using this `DataLoaders`. It will need a bit more customization than the usual model provided by `cnn_learner` since it has to take two images instead of one, but we will see how to create such a model and train it in <>." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Conclusion" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "fastai provides a layered API. It takes one line of code to grab the data when it's in one of the usual settings, making it easy for beginners to focus on training a model without spending too much time assembling the data. Then, the high-level data block API gives you more flexibility by allowing you to mix and match some building blocks. Underneath it, the mid-level API gives you greater flexibility to apply any transformations on your items. In your real-world problems, this is probably what you will need to use, and we hope it makes the step of data-munging as easy as possible." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Questionnaire" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "1. Why do we say that fastai has a \"layered\" API? What does it mean?\n", "1. Why does a `Transform` have a `decode` method? What does it do?\n", "1. Why does a `Transform` have a `setup` method? What does it do?\n", "1. How does a `Transform` work when called on a tuple?\n", "1. Which methods do you need to implement when writing your own `Transform`?\n", "1. Write a `Normalize` transform that fully normalizes items (subtract the mean and divide by the standard deviation of the dataset), and that can decode that behavior. Try not to peek!\n", "1. Write a `Transform` that does the numericalization of tokenized texts (it should set its vocab automatically from the dataset seen and have a `decode` method). Look at the source code of fastai if you need help.\n", "1. What is a `Pipeline`?\n", "1. What is a `TfmdLists`? \n", "1. What is a `Datasets`? How is it different from a `TfmdLists`?\n", "1. Why are `TfmdLists` and `Datasets` named with an \"s\"?\n", "1. How can you build a `DataLoaders` from a `TfmdLists` or a `Datasets`?\n", "1. How do you pass `item_tfms` and `batch_tfms` when building a `DataLoaders` from a `TfmdLists` or a `Datasets`?\n", "1. What do you need to do when you want to have your custom items work with methods like `show_batch` or `show_results`?\n", "1. Why can we easily apply fastai data augmentation transforms to the `SiamesePair` we built?" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Further Research" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "1. Use the mid-level API to prepare the data in `DataLoaders` on your own datasets. Try this with the Pet dataset and the Adult dataset from Chapter 1.\n", "1. Look at the Siamese tutorial in the fastai documentation to learn how to customize the behavior of `show_batch` and `show_results` for new type of items. Implement it in your own project." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Understanding fastai's Applications: Wrap Up" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Congratulations—you've completed all of the chapters in this book that cover the key practical parts of training models and using deep learning! You know how to use all of fastai's built-in applications, and how to customize them using the data block API and loss functions. You even know how to create a neural network from scratch, and train it! (And hopefully you now know some of the questions to ask to make sure your creations help improve society too.)\n", "\n", "The knowledge you already have is enough to create full working prototypes of many types of neural network applications. More importantly, it will help you understand the capabilities and limitations of deep learning models, and how to design a system that's well adapted to them.\n", "\n", "In the rest of this book we will be pulling apart those applications, piece by piece, to understand the foundations they are built on. This is important knowledge for a deep learning practitioner, because it is what allows you to inspect and debug models that you build and create new applications that are customized for your particular projects." ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [] } ], "metadata": { "jupytext": { "split_at_heading": true }, "kernelspec": { "display_name": "Python 3", "language": "python", "name": "python3" }, "language_info": { "codemirror_mode": { "name": "ipython", "version": 3 }, "file_extension": ".py", "mimetype": "text/x-python", "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", "version": "3.8.10" } }, "nbformat": 4, "nbformat_minor": 2 }