{ "cells": [ { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "#hide\n", "from utils import *\n", "from IPython.display import display,HTML" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "# Data munging with fastai" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "In the previous chapter, we showed on examples of texts what `Tokenizer` or a `Numericalize` do to a collection of texts, to explain the usual preprocessing in NLP. We then switched to the data block API, that 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?\n", "\n", "In this chapter, we will saw how to use what we call the 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! After looking at all the pieces that compose it on our example to preprocess text (like in the last chapter), we will show you an example of preparing data for a Siamese Network, which is a model that takes two images as inputs, and has to predict if those images are of the same class or not." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## The mid-level API for data collection" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "The fastai library is built on a layered API. At the very top, you have functions that allow you to train a model in five lines of codes, as we saw in <>. In the case of collecting data for a text classifier for instance, we used the line:" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "from fastai2.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 high-level API for data collection is the data block API and offers more flexibility. As we saw in the last chapter, we can ge the same result with:" ] }, { "cell_type": "code", "execution_count": null, "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. So let's dig into the pieces that we used to write this data block API." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "> note: The mid-level API in general does not only contain functionality for data collection. It also has the callback system that we will study in <>, which allows us to customize the training loop any way we like, and the general optimizer that we will cover in <>." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Transforms and Pipelines" ] }, { "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": null, "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": null, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "(#374) ['xxbos','xxmaj','well',',','\"','cube','\"','(','1997',')'...]" ] }, "execution_count": null, "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 an automatically create the vocab for our corpus:" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "tensor([ 2, 8, 76, 10, 23, 3112, 23, 34, 3113, 33])" ] }, "execution_count": null, "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": [ "For each of those steps, we created an object (`tok` or `num`) called the setup method (which trains the tokenizer if needed for `tok` and creates the vocab for `nums`) then applied it on our raw texts. \n", "\n", "There is a general behavior here that is used in all data preprocessing, that we captured in a class called `Transform`. Both `tok` and `num` are `Transform`s, and in general, a transform is a function that will be applied to your data *lazily* (that means when you ask for it and not all at once, because we don't want to load all images in memory at once, for instance, in computer vision) with an optional *setup* that will initialize some inner state (like the vocab inside `num` for instance).\n", "\n", "fastai's `Transform`s have two more functionality. The first one is that they can optionally reverse their transformation with a *decode* method. This is what is used inside fastai for all the show methods we have seen. For instance, `num` has a decode method that will give us back the tokenized text: " ] }, { "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": [ "num.decode(nums[0])[:100]" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "On the other end, when looking at our data, we would like to see the result of the tokenization, to make sure none of the rules damaged the texts, so `tok` does not have a decode method (in practice, it has one that does nothing). It's the same for data augmentation transforms: since we want to show the effects on images, to make sure we didn't do too much data augmentation (or not enough) we don't decode those transforms. However, we need to undo the effects of the `Normalize` transform we saw in <> to be able to plt the images, so this one has a decode method." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "The second 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, but resize the input (if applicable) and the target (if applicable). It's the same for the 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": null, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "((#374) ['xxbos','xxmaj','well',',','\"','cube','\"','(','1997',')'...],\n", " (#207) ['xxbos','xxmaj','conrad','xxmaj','hall','went','out','with','a','bang'...])" ] }, "execution_count": null, "metadata": {}, "output_type": "execute_result" } ], "source": [ "tok((txts[0], txts[1]))" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Sidebar: 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:" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "def f(x): return x+1\n", "tfm = Transform(f)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "`tfm` will automatically convert `f` to a `Transform` with no setup and no decode method. If you need either of those, you will need to subclass `Transform`. When writing this subclass, you need to implement the actual function in `encodes`, then (optionally), the setup behavior in `setups` and the decoding behavior in `decodes`:" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "class MyTfm(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 `MyTfm` will initialize some states during the setup (the mean of all elements passed), then the transformation is to add that mean. For decoding purposes, we implement the reverse of that transformation by subtracting the mean. Here is an example of `myTfm` in action:" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "(3.0, 5.0, 2.0)" ] }, "execution_count": null, "metadata": {}, "output_type": "execute_result" } ], "source": [ "tfm = MyTfm()\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": [ "To learn more about `Transform`s and how you can use them to have different behavior depending on the type of the input, be sure to check our tutorial in the docs online." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### End sidebar" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "To compose several transforms together, fastai uses `Pipeline`. You can define a `Pipeline` by passing it a list of `Transform`s and it will then compose the transforms incide it: when you call it on an object, it will automatically call the transforms inside in order:" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "tensor([ 2, 8, 76, 10, 23, 3112, 23, 34, 3113, 33, 10, 8, 4477, 22, 88, 32, 10, 27, 42, 14])" ] }, "execution_count": null, "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": 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": [ "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 setup a `Pipeline` of `Transform`s on some data, you need to use a `TfmdLists`." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### TfmdLists and Datasets" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "You 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 the succession of transformations was represented by a `Pipeline` in fastai. The class that groups together this pipeline with your raw items is called `TfmdLists`. Here is the short way of doing the transformation we saw in the previous section:" ] }, { "cell_type": "code", "execution_count": null, "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": null, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "tensor([ 2, 8, 91, 11, 22, 5793, 22, 37, 4910, 34, 11, 8, 13042, 23, 107, 30, 11, 25, 44, 14])" ] }, "execution_count": null, "metadata": {}, "output_type": "execute_result" } ], "source": [ "t = tls[0]; t[:20]" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "And the `TfmdLists` knows how to decode for showing purposing:" ] }, { "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": [ "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 validation set with a splits argument. You just need to pass the indices of which elemets are in the training set, and which are in the validation set:" ] }, { "cell_type": "code", "execution_count": null, "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], splits=splits)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "You can then access them through the `train` and `valid` attribute:" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "tensor([ 2, 8, 20, 30, 87, 510, 1570, 12, 408, 379, 4196, 10, 8, 20, 30, 16, 13, 12216, 202, 509])" ] }, "execution_count": null, "metadata": {}, "output_type": "execute_result" } ], "source": [ "tls.valid[0][:20]" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "If you have manually written a `Transform` that returns your whole data (input and target) from the raw items you had, 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 further in this chapter.\n", "\n", "In general though, you 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 input. If we want to do text classification, we have to process the labels as well. \n", "\n", "Here we need to do two things: first take the label name from the parent folder. There is a function `parent_label` for this:" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "(#50000) ['pos','pos','pos','pos','pos','pos','pos','pos','pos','pos'...]" ] }, "execution_count": null, "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 it during setup, then will transform the string labels into integers when called. fastai provides this transform, it's called `Categorize`:" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "((#2) ['neg','pos'], TensorCategory(1))" ] }, "execution_count": null, "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": null, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "TensorCategory(1)" ] }, "execution_count": null, "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. `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": null, "metadata": {}, "outputs": [], "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:" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "(tensor([ 2, 8, 20, 30, 87, 510, 1570, 12, 408, 379, 4196, 10, 8, 20, 30, 16, 13, 12216, 202, 509]),\n", " TensorCategory(0))" ] }, "execution_count": null, "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": null, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "('xxbos xxmaj this movie had horrible lighting and terrible camera movements . xxmaj this movie is a jumpy horror flick with no meaning at all . xxmaj the slashes are totally fake looking . xxmaj it looks like some 17 year - old idiot wrote this movie and a 10 year old kid shot it . xxmaj with the worst acting you can ever find . xxmaj people are tired of knives . xxmaj at least move on to guns or fire . xxmaj it has almost exact lines from \" when a xxmaj stranger xxmaj calls \" . xxmaj with gruesome killings , only crazy people would enjoy this movie . xxmaj it is obvious the writer does n\\'t have kids or even care for them . i mean at show some mercy . xxmaj just to sum it up , this movie is a \" b \" movie and it sucked . xxmaj just for your own sake , do n\\'t even think about wasting your time watching this crappy movie .',\n", " 'neg')" ] }, "execution_count": null, "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 your `Datasets` object to a `DataLoaders`, which can be done with the `dataloaders` method. Here we need to pass along special arguments 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": null, "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 you should know are:\n", "\n", "- `after_item`: applied on each item after grabbing it inside the dataset. This is the equivalent of the `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 the `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": null, "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 with what we had above is 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. This is the class that will handle the construction of batches by putting samples of roughly the same lengths into batches.\n", "\n", "This does the exact same thing as our `DataBlock` from above:" ] }, { "cell_type": "code", "execution_count": null, "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": [ "...except that now, yuo know how to customize every single piece of it!" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Let's practice what we just learned on this mid-level API for data preprocessing on a computer vision example now, with a Siamese Model input pipeline." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Siamese model" ] }, { "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 pets 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. TK see if we train that model later in the book. " ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "from fastai2.vision.all import *\n", "path = untar_data(URLs.PETS)\n", "files = get_image_files(path/\"images\")" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "class SiameseImage(Tuple):\n", " def show(self, ctx=None, **kwargs): \n", " img1,img2,same_breed = self\n", " dim = 2 if isinstance(img1, Tensor) else 1\n", " return show_image(torch.cat([tensor(img1),tensor(img2)], dim=dim), \n", " title=same_breed, ctx=ctx)" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "" ] }, "execution_count": null, "metadata": {}, "output_type": "execute_result" }, { "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": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "tst = ToTensor()(s)" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "" ] }, "execution_count": null, "metadata": {}, "output_type": "execute_result" }, { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "tst.show()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "All in one transform" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "class SiamesePair(Transform):\n", " def __init__(self,items,labels):\n", " self.items,self.labels,self.assoc = items,labels,self\n", " sortlbl = sorted(enumerate(labels), key=itemgetter(1))\n", " # dict of (each unique label) -- (list of indices with that label)\n", " self.clsmap = {k:L(v).itemgot(0) for k,v in itertools.groupby(sortlbl, key=itemgetter(1))}\n", " self.idxs = range_of(self.items)\n", " \n", " def encodes(self,i):\n", " \"x: tuple of `i`th image and a random image from same or different class; y: True if same class\"\n", " othercls = self.clsmap[self.labels[i]] if random.random()>0.5 else self.idxs\n", " otherit = random.choice(othercls)\n", " return SiameseImage(self.items[i], self.items[otherit], self.labels[otherit]==self.labels[i])" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [] } ], "metadata": { "jupytext": { "split_at_heading": true }, "kernelspec": { "display_name": "Python 3", "language": "python", "name": "python3" } }, "nbformat": 4, "nbformat_minor": 2 }