{ "cells": [ { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "#hide\n", "#skip\n", "! [ -e /content ] && pip install -Uqq fastai # upgrade fastai on colab" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "#default_exp vision.core\n", "#default_cls_lvl 3" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "#export\n", "from fastai.torch_basics import *\n", "from fastai.data.all import *\n", "\n", "from PIL import Image" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "from fastai.data.external import *" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "#hide\n", "from nbdev.showdoc import *" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "#export\n", "_all_ = ['Image','ToTensor']" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "#It didn't use to be necessary to add ToTensor in all but we don't have the encodes methods defined here otherwise.\n", "#TODO: investigate" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "# Core vision\n", "> Basic image opening/processing functionality" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Helpers" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "#export\n", "imagenet_stats = ([0.485, 0.456, 0.406], [0.229, 0.224, 0.225])\n", "cifar_stats = ([0.491, 0.482, 0.447], [0.247, 0.243, 0.261])\n", "mnist_stats = ([0.131], [0.308])" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "im = Image.open(TEST_IMAGE).resize((30,20))" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "#export\n", "if not hasattr(Image,'_patched'):\n", " _old_sz = Image.Image.size.fget\n", " @patch(as_prop=True)\n", " def size(x:Image.Image): return fastuple(_old_sz(x))\n", " Image._patched = True" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "#export\n", "@patch(as_prop=True)\n", "def n_px(x: Image.Image): return x.size[0] * x.size[1]" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "#### `Image.n_px`" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "> `Image.n_px` (property)\n", "\n", "Number of pixels in image" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "test_eq(im.n_px, 30*20)" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "#export\n", "@patch(as_prop=True)\n", "def shape(x: Image.Image): return x.size[1],x.size[0]" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "#### `Image.shape`\n", "\n", "> `Image.shape` (property)\n", "\n", "Image (height,width) tuple (NB: opposite order of `Image.size()`, same order as numpy array and pytorch tensor)" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "test_eq(im.shape, (20,30))" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "#export\n", "@patch(as_prop=True)\n", "def aspect(x: Image.Image): return x.size[0]/x.size[1]" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "#### `Image.aspect`\n", "\n", "> `Image.aspect` (property)\n", "\n", "Aspect ratio of the image, i.e. `width/height`" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "test_eq(im.aspect, 30/20)" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "#export\n", "@patch\n", "def reshape(x: Image.Image, h, w, resample=0):\n", " \"`resize` `x` to `(w,h)`\"\n", " return x.resize((w,h), resample=resample)" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [ { "data": { "text/markdown": [ "

Image.reshape[source]

\n", "\n", "> Image.reshape(**`x`**:`Image`, **`h`**, **`w`**, **`resample`**=*`0`*)\n", "\n", "`resize` `x` to `(w,h)`" ], "text/plain": [ "" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "show_doc(Image.Image.reshape)" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "test_eq(im.reshape(12,10).shape, (12,10))" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "#export\n", "@patch\n", "def to_bytes_format(im:Image.Image, format='png'):\n", " \"Convert to bytes, default to PNG format\"\n", " arr = io.BytesIO()\n", " im.save(arr, format=format)\n", " return arr.getvalue()" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [ { "data": { "text/markdown": [ "

Image.to_bytes_format[source]

\n", "\n", "> Image.to_bytes_format(**`im`**:`Image`, **`format`**=*`'png'`*)\n", "\n", "Convert to bytes, default to PNG format" ], "text/plain": [ "" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "show_doc(Image.Image.to_bytes_format)" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "#export\n", "@patch\n", "def to_thumb(self:Image.Image, h, w=None):\n", " \"Same as `thumbnail`, but uses a copy\"\n", " if w is None: w=h\n", " im = self.copy()\n", " im.thumbnail((w,h))\n", " return im" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [ { "data": { "text/markdown": [ "

Image.to_thumb[source]

\n", "\n", "> Image.to_thumb(**`h`**, **`w`**=*`None`*)\n", "\n", "Same as `thumbnail`, but uses a copy" ], "text/plain": [ "" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "show_doc(Image.Image.to_thumb)" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "#export\n", "@patch\n", "def resize_max(x: Image.Image, resample=0, max_px=None, max_h=None, max_w=None):\n", " \"`resize` `x` to `max_px`, or `max_h`, or `max_w`\"\n", " h,w = x.shape\n", " if max_px and x.n_px>max_px: h,w = fastuple(h,w).mul(math.sqrt(max_px/x.n_px))\n", " if max_h and h>max_h: h,w = (max_h ,max_h*w/h)\n", " if max_w and w>max_w: h,w = (max_w*h/w,max_w )\n", " return x.reshape(round(h), round(w), resample=resample)" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "test_eq(im.resize_max(max_px=20*30).shape, (20,30))\n", "test_eq(im.resize_max(max_px=300).n_px, 294)\n", "test_eq(im.resize_max(max_px=500, max_h=10, max_w=20).shape, (10,15))\n", "test_eq(im.resize_max(max_h=14, max_w=15).shape, (10,15))\n", "test_eq(im.resize_max(max_px=300, max_h=10, max_w=25).shape, (10,15))" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [ { "data": { "text/markdown": [ "

Image.resize_max[source]

\n", "\n", "> Image.resize_max(**`x`**:`Image`, **`resample`**=*`0`*, **`max_px`**=*`None`*, **`max_h`**=*`None`*, **`max_w`**=*`None`*)\n", "\n", "`resize` `x` to `max_px`, or `max_h`, or `max_w`" ], "text/plain": [ "" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "show_doc(Image.Image.resize_max)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Basic types" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "This section regroups the basic types used in vision with the transform that create objects of those types." ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "#export\n", "def to_image(x):\n", " \"Convert a tensor or array to a PIL int8 Image\"\n", " if isinstance(x,Image.Image): return x\n", " if isinstance(x,Tensor): x = to_np(x.permute((1,2,0)))\n", " if x.dtype==np.float32: x = (x*255).astype(np.uint8)\n", " return Image.fromarray(x, mode=['RGB','CMYK'][x.shape[0]==4])" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "#export\n", "def load_image(fn, mode=None):\n", " \"Open and load a `PIL.Image` and convert to `mode`\"\n", " im = Image.open(fn)\n", " im.load()\n", " im = im._new(im.im)\n", " return im.convert(mode) if mode else im" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "# export\n", "def image2tensor(img):\n", " \"Transform image to byte tensor in `c*h*w` dim order.\"\n", " res = tensor(img)\n", " if res.dim()==2: res = res.unsqueeze(-1)\n", " return res.permute(2,0,1)" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "#export\n", "class PILBase(Image.Image, metaclass=BypassNewMeta):\n", " _bypass_type=Image.Image\n", " _show_args = {'cmap':'viridis'}\n", " _open_args = {'mode': 'RGB'}\n", " @classmethod\n", " def create(cls, fn:(Path,str,Tensor,ndarray,bytes), **kwargs)->None:\n", " \"Open an `Image` from path `fn`\"\n", " if isinstance(fn,TensorImage): fn = fn.permute(1,2,0).type(torch.uint8)\n", " if isinstance(fn, TensorMask): fn = fn.type(torch.uint8)\n", " if isinstance(fn,Tensor): fn = fn.numpy()\n", " if isinstance(fn,ndarray): return cls(Image.fromarray(fn))\n", " if isinstance(fn,bytes): fn = io.BytesIO(fn)\n", " return cls(load_image(fn, **merge(cls._open_args, kwargs)))\n", "\n", " def show(self, ctx=None, **kwargs):\n", " \"Show image using `merge(self._show_args, kwargs)`\"\n", " return show_image(self, ctx=ctx, **merge(self._show_args, kwargs))\n", "\n", " def __repr__(self): return f'{self.__class__.__name__} mode={self.mode} size={\"x\".join([str(d) for d in self.size])}'" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "#export\n", "class PILImage(PILBase): pass" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "#export\n", "class PILImageBW(PILImage): _show_args,_open_args = {'cmap':'Greys'},{'mode': 'L'}" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "im = PILImage.create(TEST_IMAGE)\n", "test_eq(type(im), PILImage)\n", "test_eq(im.mode, 'RGB')\n", "test_eq(str(im), 'PILImage mode=RGB size=1200x803')" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [ { "data": { "image/png": "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\n", "text/plain": [ "" ] }, "execution_count": null, "metadata": {}, "output_type": "execute_result" } ], "source": [ "im.resize((64,64))" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [ { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "ax = im.show(figsize=(1,1))" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "test_fig_exists(ax)" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "timg = TensorImage(image2tensor(im))\n", "tpil = PILImage.create(timg)" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [ { "data": { "image/png": "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\n", "text/plain": [ "" ] }, "execution_count": null, "metadata": {}, "output_type": "execute_result" } ], "source": [ "tpil.resize((64,64))" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "#hide\n", "test_eq(np.array(im), np.array(tpil))" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "#export\n", "class PILMask(PILBase): _open_args,_show_args = {'mode':'L'},{'alpha':0.5, 'cmap':'tab20'}" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "im = PILMask.create(TEST_IMAGE)\n", "test_eq(type(im), PILMask)\n", "test_eq(im.mode, 'L')\n", "test_eq(str(im), 'PILMask mode=L size=1200x803')" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "#export\n", "OpenMask = Transform(PILMask.create)\n", "OpenMask.loss_func = CrossEntropyLossFlat(axis=1)\n", "PILMask.create = OpenMask" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Images" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "mnist = untar_data(URLs.MNIST_TINY)\n", "fns = get_image_files(mnist)\n", "mnist_fn = TEST_IMAGE_BW" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [ { "data": { "image/png": "iVBORw0KGgoAAAANSUhEUgAAABwAAAAcCAAAAABXZoBIAAAA4klEQVR4nGNgGEjgu/Xf//gIrFLMiZ/+/v3793cpPxZJkWN/IeC9NUKQCUq/Wfab4fv9VwwMfP7YDM5r3MAQ/Pfv30MSWO2VYgj++/fvXwMMYxkYGBieMTAwMDAceIZVEgLOvsIhmYLVOgYGBgYGx29///5dz4Jdcs3fv3//uuHQ6fT379+/78ywSwo6vvj79+9UVhx6dXv//v1bjUVC8+zZs4pMDX//fk2GCSHcxmnAwLBlnQEDw6cbmDqNoNHy9wpcCBEIj/fhcAjEXKvNv//+/XtbB4d899+/TYb4DKA9AABLQV4KAJgjfgAAAABJRU5ErkJggg==\n", "text/plain": [ "PILImageBW mode=L size=28x28" ] }, "execution_count": null, "metadata": {}, "output_type": "execute_result" } ], "source": [ "timg = Transform(PILImageBW.create)\n", "mnist_img = timg(mnist_fn)\n", "test_eq(mnist_img.size, (28,28))\n", "assert isinstance(mnist_img, PILImageBW)\n", "mnist_img" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Segmentation masks" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "#export\n", "class AddMaskCodes(Transform):\n", " \"Add the code metadata to a `TensorMask`\"\n", " def __init__(self, codes=None):\n", " self.codes = codes\n", " if codes is not None: self.vocab,self.c = codes,len(codes)\n", "\n", " def decodes(self, o:TensorMask):\n", " if self.codes is not None: o.codes=self.codes\n", " return o" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "camvid = untar_data(URLs.CAMVID_TINY)\n", "fns = get_image_files(camvid/'images')\n", "cam_fn = fns[0]\n", "mask_fn = camvid/'labels'/f'{cam_fn.stem}_P{cam_fn.suffix}'" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "cam_img = PILImage.create(cam_fn)\n", "test_eq(cam_img.size, (128,96))\n", "tmask = Transform(PILMask.create)\n", "mask = tmask(mask_fn)\n", "test_eq(type(mask), PILMask)\n", "test_eq(mask.size, (128,96))" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [ { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "_,axs = plt.subplots(1,3, figsize=(12,3))\n", "cam_img.show(ctx=axs[0], title='image')\n", "mask.show(alpha=1, ctx=axs[1], vmin=1, vmax=30, title='mask')\n", "cam_img.show(ctx=axs[2], title='superimposed')\n", "mask.show(ctx=axs[2], vmin=1, vmax=30);" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Points" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "# export\n", "class TensorPoint(TensorBase):\n", " \"Basic type for points in an image\"\n", " _show_args = dict(s=10, marker='.', c='r')\n", "\n", " @classmethod\n", " def create(cls, t, img_size=None)->None:\n", " \"Convert an array or a list of points `t` to a `Tensor`\"\n", " return cls(tensor(t).view(-1, 2).float(), img_size=img_size)\n", "\n", " def show(self, ctx=None, **kwargs):\n", " if 'figsize' in kwargs: del kwargs['figsize']\n", " x = self.view(-1,2)\n", " ctx.scatter(x[:, 0], x[:, 1], **{**self._show_args, **kwargs})\n", " return ctx" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "#export\n", "TensorPointCreate = Transform(TensorPoint.create)\n", "TensorPointCreate.loss_func = MSELossFlat()\n", "TensorPoint.create = TensorPointCreate" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Points are expected to come as an array/tensor of shape `(n,2)` or as a list of lists with two elements. Unless you change the defaults in `PointScaler` (see later on), coordinates should go from 0 to width/height, with the first one being the column index (so from 0 to width) and the second one being the row index (so from 0 to height).\n", "\n", "> Note: This is different from the usual indexing convention for arrays in numpy or in PyTorch, but it's the way points are expected by matplotlib or the internal functions in PyTorch like `F.grid_sample`." ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "pnt_img = TensorImage(mnist_img.resize((28,35)))\n", "pnts = np.array([[0,0], [0,35], [28,0], [28,35], [9, 17]])\n", "tfm = Transform(TensorPoint.create)\n", "tpnts = tfm(pnts)\n", "test_eq(tpnts.shape, [5,2])\n", "test_eq(tpnts.dtype, torch.float32)" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [ { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "ctx = pnt_img.show(figsize=(1,1), cmap='Greys')\n", "tpnts.show(ctx=ctx);" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Bounding boxes" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "# export\n", "def get_annotations(fname, prefix=None):\n", " \"Open a COCO style json in `fname` and returns the lists of filenames (with maybe `prefix`) and labelled bboxes.\"\n", " annot_dict = json.load(open(fname))\n", " id2images, id2bboxes, id2cats = {}, collections.defaultdict(list), collections.defaultdict(list)\n", " classes = {o['id']:o['name'] for o in annot_dict['categories']}\n", " for o in annot_dict['annotations']:\n", " bb = o['bbox']\n", " id2bboxes[o['image_id']].append([bb[0],bb[1], bb[0]+bb[2], bb[1]+bb[3]])\n", " id2cats[o['image_id']].append(classes[o['category_id']])\n", " id2images = {o['id']:ifnone(prefix, '') + o['file_name'] for o in annot_dict['images'] if o['id'] in id2bboxes}\n", " ids = list(id2images.keys())\n", " return [id2images[k] for k in ids], [(id2bboxes[k], id2cats[k]) for k in ids]" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Test ```get_annotations``` on the coco_tiny dataset against both image filenames and bounding box labels. " ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "coco = untar_data(URLs.COCO_TINY)\n", "test_images, test_lbl_bbox = get_annotations(coco/'train.json')\n", "annotations = json.load(open(coco/'train.json'))\n", "categories, images, annots = map(lambda x:L(x),annotations.values())\n", "\n", "test_eq(test_images, images.attrgot('file_name'))\n", "\n", "def bbox_lbls(file_name):\n", " img = images.filter(lambda img:img['file_name']==file_name)[0]\n", " bbs = annots.filter(lambda a:a['image_id'] == img['id'])\n", " i2o = {k['id']:k['name'] for k in categories}\n", " lbls = [i2o[cat] for cat in bbs.attrgot('category_id')]\n", " bboxes = [[bb[0],bb[1], bb[0]+bb[2], bb[1]+bb[3]] for bb in bbs.attrgot('bbox')]\n", " return [bboxes, lbls]\n", "\n", "for idx in random.sample(range(len(images)),5): \n", " test_eq(test_lbl_bbox[idx], bbox_lbls(test_images[idx]))" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "# export\n", "from matplotlib import patches, patheffects" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "# export\n", "def _draw_outline(o, lw):\n", " o.set_path_effects([patheffects.Stroke(linewidth=lw, foreground='black'), patheffects.Normal()])\n", "\n", "def _draw_rect(ax, b, color='white', text=None, text_size=14, hw=True, rev=False):\n", " lx,ly,w,h = b\n", " if rev: lx,ly,w,h = ly,lx,h,w\n", " if not hw: w,h = w-lx,h-ly\n", " patch = ax.add_patch(patches.Rectangle((lx,ly), w, h, fill=False, edgecolor=color, lw=2))\n", " _draw_outline(patch, 4)\n", " if text is not None:\n", " patch = ax.text(lx,ly, text, verticalalignment='top', color=color, fontsize=text_size, weight='bold')\n", " _draw_outline(patch,1)" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "# export\n", "class TensorBBox(TensorPoint):\n", " \"Basic type for a tensor of bounding boxes in an image\"\n", " @classmethod\n", " def create(cls, x, img_size=None)->None: return cls(tensor(x).view(-1, 4).float(), img_size=img_size)\n", "\n", " def show(self, ctx=None, **kwargs):\n", " x = self.view(-1,4)\n", " for b in x: _draw_rect(ctx, b, hw=False, **kwargs)\n", " return ctx" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Bounding boxes are expected to come as tuple with an array/tensor of shape `(n,4)` or as a list of lists with four elements and a list of corresponding labels. Unless you change the defaults in `PointScaler` (see later on), coordinates for each bounding box should go from 0 to width/height, with the following convention: x1, y1, x2, y2 where (x1,y1) is your top-left corner and (x2,y2) is your bottom-right corner.\n", "\n", "> Note: We use the same convention as for points with x going from 0 to width and y going from 0 to height." ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "# export\n", "class LabeledBBox(L):\n", " \"Basic type for a list of bounding boxes in an image\"\n", " def show(self, ctx=None, **kwargs):\n", " for b,l in zip(self.bbox, self.lbl):\n", " if l != '#na#': ctx = retain_type(b, self.bbox).show(ctx=ctx, text=l)\n", " return ctx\n", "\n", " bbox,lbl = add_props(lambda i,self: self[i])" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "coco = untar_data(URLs.COCO_TINY)\n", "images, lbl_bbox = get_annotations(coco/'train.json')\n", "idx=2\n", "coco_fn,bbox = coco/'train'/images[idx],lbl_bbox[idx]\n", "coco_img = timg(coco_fn)" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [ { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "tbbox = LabeledBBox(TensorBBox(bbox[0]), bbox[1])\n", "ctx = coco_img.show(figsize=(3,3), cmap='Greys')\n", "tbbox.show(ctx=ctx);" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Basic Transforms" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Unless specifically mentioned, all the following transforms can be used as single-item transforms (in one of the list in the `tfms` you pass to a `TfmdDS` or a `Datasource`) or tuple transforms (in the `tuple_tfms` you pass to a `TfmdDS` or a `Datasource`). The safest way that will work across applications is to always use them as `tuple_tfms`. For instance, if you have points or bounding boxes as targets and use `Resize` as a single-item transform, when you get to `PointScaler` (which is a tuple transform) you won't have the correct size of the image to properly scale your points." ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "# export\n", "PILImage ._tensor_cls = TensorImage\n", "PILImageBW._tensor_cls = TensorImageBW\n", "PILMask ._tensor_cls = TensorMask" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "#export\n", "@ToTensor\n", "def encodes(self, o:PILBase): return o._tensor_cls(image2tensor(o))\n", "@ToTensor\n", "def encodes(self, o:PILMask): return o._tensor_cls(image2tensor(o)[0])" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Any data augmentation transform that runs on PIL Images must be run before this transform." ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "ToTensor:\n", "encodes: (PILMask,object) -> encodes\n", "(PILBase,object) -> encodes\n", "decodes: \n", "\n", "\n" ] } ], "source": [ "tfm = ToTensor()\n", "print(tfm)\n", "print(type(mnist_img))\n", "print(type(tfm(mnist_img)))" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "tfm = ToTensor()\n", "test_eq(tfm(mnist_img).shape, (1,28,28))\n", "test_eq(type(tfm(mnist_img)), TensorImageBW)\n", "test_eq(tfm(mask).shape, (96,128))\n", "test_eq(type(tfm(mask)), TensorMask)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Let's confirm we can pipeline this with `PILImage.create`." ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [ { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "pipe_img = Pipeline([PILImageBW.create, ToTensor()])\n", "img = pipe_img(mnist_fn)\n", "test_eq(type(img), TensorImageBW)\n", "pipe_img.show(img, figsize=(1,1));" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [ { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "def _cam_lbl(x): return mask_fn\n", "cam_tds = Datasets([cam_fn], [[PILImage.create, ToTensor()], [_cam_lbl, PILMask.create, ToTensor()]])\n", "show_at(cam_tds, 0);" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "To work with data augmentation, and in particular the `grid_sample` method, points need to be represented with coordinates going from -1 to 1 (-1 being top or left, 1 bottom or right), which will be done unless you pass `do_scale=False`. We also need to make sure they are following our convention of points being x,y coordinates, so pass along `y_first=True` if you have your data in an y,x format to add a flip.\n", "\n", "> Warning: This transform needs to run on the tuple level, before any transform that changes the image size." ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "#export\n", "def _scale_pnts(y, sz, do_scale=True, y_first=False):\n", " if y_first: y = y.flip(1)\n", " res = y * 2/tensor(sz).float() - 1 if do_scale else y\n", " return TensorPoint(res, img_size=sz)\n", "\n", "def _unscale_pnts(y, sz): return TensorPoint((y+1) * tensor(sz).float()/2, img_size=sz)" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "#export\n", "class PointScaler(Transform):\n", " \"Scale a tensor representing points\"\n", " order = 1\n", " def __init__(self, do_scale=True, y_first=False): self.do_scale,self.y_first = do_scale,y_first\n", " def _grab_sz(self, x):\n", " self.sz = [x.shape[-1], x.shape[-2]] if isinstance(x, Tensor) else x.size\n", " return x\n", "\n", " def _get_sz(self, x): return getattr(x, 'img_size') if self.sz is None else self.sz\n", "\n", " def setups(self, dl):\n", " res = first(dl.do_item(None), risinstance(TensorPoint))\n", " if res is not None: self.c = res.numel()\n", "\n", " def encodes(self, x:(PILBase,TensorImageBase)): return self._grab_sz(x)\n", " def decodes(self, x:(PILBase,TensorImageBase)): return self._grab_sz(x)\n", "\n", " def encodes(self, x:TensorPoint): return _scale_pnts(x, self._get_sz(x), self.do_scale, self.y_first)\n", " def decodes(self, x:TensorPoint): return _unscale_pnts(x.view(-1, 2), self._get_sz(x))" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "To work with data augmentation, and in particular the `grid_sample` method, points need to be represented with coordinates going from -1 to 1 (-1 being top or left, 1 bottom or right), which will be done unless you pass `do_scale=False`. We also need to make sure they are following our convention of points being x,y coordinates, so pass along `y_first=True` if you have your data in an y,x format to add a flip.\n", "\n", "> Note: This transform automatically grabs the sizes of the images it sees before a TensorPoint object and embeds it in them. For this to work, those images need to be before any points in the order of your final tuple. If you don't have such images, you need to embed the size of the corresponding image when creating a TensorPoint by passing it with `sz=...`." ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "def _pnt_lbl(x): return TensorPoint.create(pnts)\n", "def _pnt_open(fn): return PILImage(PILImage.create(fn).resize((28,35)))\n", "pnt_tds = Datasets([mnist_fn], [_pnt_open, [_pnt_lbl]])\n", "pnt_tdl = TfmdDL(pnt_tds, bs=1, after_item=[PointScaler(), ToTensor()])" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "test_eq(pnt_tdl.after_item.c, 10)" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "#hide\n", "#Check the size was grabbed by PointScaler and added to y\n", "tfm = PointScaler()\n", "tfm.as_item=False\n", "x,y = tfm(pnt_tds[0])\n", "test_eq(tfm.sz, x.size)\n", "test_eq(y.img_size, x.size)" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "x,y = pnt_tdl.one_batch()\n", "#Scaling and flipping properly done\n", "#NB: we added a point earlier at (9,17); formula below scales to (-1,1) coords\n", "test_close(y[0], tensor([[-1., -1.], [-1., 1.], [1., -1.], [1., 1.], [9/14-1, 17/17.5-1]]))\n", "a,b = pnt_tdl.decode_batch((x,y))[0]\n", "test_eq(b, tensor(pnts).float())\n", "#Check types\n", "test_eq(type(x), TensorImage)\n", "test_eq(type(y), TensorPoint)\n", "test_eq(type(a), TensorImage)\n", "test_eq(type(b), TensorPoint)\n", "test_eq(b.img_size, (28,35)) #Automatically picked the size of the input" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [ { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "pnt_tdl.show_batch(figsize=(2,2), cmap='Greys');" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "#export\n", "class BBoxLabeler(Transform):\n", " def setups(self, dl): self.vocab = dl.vocab\n", "\n", " def decode (self, x, **kwargs):\n", " self.bbox,self.lbls = None,None\n", " return self._call('decodes', x, **kwargs)\n", "\n", " def decodes(self, x:TensorMultiCategory):\n", " self.lbls = [self.vocab[a] for a in x]\n", " return x if self.bbox is None else LabeledBBox(self.bbox, self.lbls)\n", "\n", " def decodes(self, x:TensorBBox):\n", " self.bbox = x\n", " return self.bbox if self.lbls is None else LabeledBBox(self.bbox, self.lbls)" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "#export\n", "#LabeledBBox can be sent in a tl with MultiCategorize (depending on the order of the tls) but it is already decoded.\n", "@MultiCategorize\n", "def decodes(self, x:LabeledBBox): return x" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "#export\n", "@PointScaler\n", "def encodes(self, x:TensorBBox):\n", " pnts = self.encodes(cast(x.view(-1,2), TensorPoint))\n", " return cast(pnts.view(-1, 4), TensorBBox)\n", "\n", "@PointScaler\n", "def decodes(self, x:TensorBBox):\n", " pnts = self.decodes(cast(x.view(-1,2), TensorPoint))\n", " return cast(pnts.view(-1, 4), TensorBBox)" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "def _coco_bb(x): return TensorBBox.create(bbox[0])\n", "def _coco_lbl(x): return bbox[1]\n", "\n", "coco_tds = Datasets([coco_fn], [PILImage.create, [_coco_bb], [_coco_lbl, MultiCategorize(add_na=True)]], n_inp=1)\n", "coco_tdl = TfmdDL(coco_tds, bs=1, after_item=[BBoxLabeler(), PointScaler(), ToTensor()])" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "#hide\n", "#Check the size was grabbed by PointScaler and added to y\n", "tfm = PointScaler()\n", "tfm.as_item=False\n", "x,y,z = tfm(coco_tds[0])\n", "test_eq(tfm.sz, x.size)\n", "test_eq(y.img_size, x.size)" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "Categorize -- {'vocab': None, 'sort': True, 'add_na': True}:\n", "encodes: (object,object) -> encodes\n", "decodes: (object,object) -> decodes" ] }, "execution_count": null, "metadata": {}, "output_type": "execute_result" } ], "source": [ "Categorize(add_na=True)" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "(#3) [Pipeline: PILBase.create,Pipeline: _coco_bb,Pipeline: _coco_lbl -> MultiCategorize -- {'vocab': None, 'sort': True, 'add_na': True}]" ] }, "execution_count": null, "metadata": {}, "output_type": "execute_result" } ], "source": [ "coco_tds.tfms" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "(PILImage mode=RGB size=128x128,\n", " TensorBBox([[-0.9011, -0.4606, 0.1416, 0.6764],\n", " [ 0.2000, -0.2405, 1.0000, 0.9102],\n", " [ 0.4909, -0.9325, 0.9284, -0.5011]]),\n", " TensorMultiCategory([1, 1, 1]))" ] }, "execution_count": null, "metadata": {}, "output_type": "execute_result" } ], "source": [ "x,y,z" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "x,y,z = coco_tdl.one_batch()\n", "test_close(y[0], -1+tensor(bbox[0])/64)\n", "test_eq(z[0], tensor([1,1,1]))\n", "a,b,c = coco_tdl.decode_batch((x,y,z))[0]\n", "test_close(b, tensor(bbox[0]).float())\n", "test_eq(c.bbox, b)\n", "test_eq(c.lbl, bbox[1])\n", "\n", "#Check types\n", "test_eq(type(x), TensorImage)\n", "test_eq(type(y), TensorBBox)\n", "test_eq(type(z), TensorMultiCategory)\n", "test_eq(type(a), TensorImage)\n", "test_eq(type(b), TensorBBox)\n", "test_eq(type(c), LabeledBBox)\n", "test_eq(y.img_size, (128,128))" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [ { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "coco_tdl.show_batch();" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "#hide\n", "#test other direction works too\n", "coco_tds = Datasets([coco_fn], [PILImage.create, [_coco_lbl, MultiCategorize(add_na=True)], [_coco_bb]])\n", "coco_tdl = TfmdDL(coco_tds, bs=1, after_item=[BBoxLabeler(), PointScaler(), ToTensor()])\n", "\n", "x,y,z = coco_tdl.one_batch()\n", "test_close(z[0], -1+tensor(bbox[0])/64)\n", "test_eq(y[0], tensor([1,1,1]))\n", "a,b,c = coco_tdl.decode_batch((x,y,z))[0]\n", "test_eq(b, bbox[1])\n", "test_close(c.bbox, tensor(bbox[0]).float())\n", "test_eq(c.lbl, b)\n", "\n", "#Check types\n", "test_eq(type(x), TensorImage)\n", "test_eq(type(y), TensorMultiCategory)\n", "test_eq(type(z), TensorBBox)\n", "test_eq(type(a), TensorImage)\n", "test_eq(type(b), MultiCategory)\n", "test_eq(type(c), LabeledBBox)\n", "test_eq(z.img_size, (128,128))" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "# Export -" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "#hide\n", "from nbdev.export import notebook2script\n", "notebook2script()" ] }, { "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 }