{ "cells": [ { "cell_type": "markdown", "metadata": {}, "source": [ "# Diving into DALI: Exploring NVIDIA's Image Augmentation Library\n", "\n", "\"The" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "*Salvador Dalí. The Persistence of Memory. 1931. Image credit: [The Museum of Modern Art](https://www.moma.org/collection/works/79018)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Deep learning image augmentation pipelines typically offer either speed or flexibility, but never both at the same time. Computationally efficient, production-ready computer vision pipelines tend to be written in C++ and require developers to manually specify all nuts and bolts of image transform algorithms to such an extent that these pipelines aren't terribly amenable to further on-the-fly tweaking. On the other end of the spectrum, popular Python libraries like [Pillow](https://pillow.readthedocs.io/en/stable/) offer high-level APIs that let practitioners choose from near unlimited combinations of tweaks that can be applied to a vast repository of image transform algorithms. Unfortunately, this freedom carries with it the cost of a steep slowdown in processing time.\n", "\n", "The [DALI Library](https://docs.nvidia.com/deeplearning/sdk/dali-developer-guide/docs/examples/getting%20started.html) attempts to give practitioners the best of both worlds. Its image transform algorithms are themselves written in C++ code that squeezes every last drop of performance out of NVIDIA GPU chips, such that image transforms can be performed in parallel on a per-batch basis, across however many GPUs a user has access to. The C++ source code is designed to be called from inside a user-friendly and supposedly flexible Python API, which users can use to create image transform pipelines that play nice with both the PyTorch and TensorFlow frameworks.\n", "\n", "In an attempt to ascertain whether DALI indeed delivers both the speed and flexibility it advertises, I spent the better part of one week running a series of my own experiments with the library. Spoiler alert: while DALI absolutely brings the speed, flexibility is still somewhat lacking.\n", "\n", "### DALI's Promise\n", "Nonetheless, I believe that taking the time to get acquainted with DALI is absolutely worthwhile. The benefits of doing image augmentation on the GPU are self-evident, and my DALI image pipeline ran several times faster than any other comparable image pipeline I've ever written.\n", "\n", "Moreover, given that I just completed part II of the fast.ai deep learning [course](https://course.fast.ai/) earlier this spring, I wanted to see if I could build a DALI pipeline that seamlessly meshed with the reworked, [new and improved version](https://github.com/jamesdellinger/fastai_deep_learning_course_part2_v3) of the fastai library that we built together from scratch as part of our coursework. According to core fastai developer [Sylvain Gugger](https://www.fast.ai/about/#sylvain), the upcoming official version 2 of the fastai library [will contain several of the paradigms](https://forums.fast.ai/t/fastai-v2-roadmap/46661) that we built during our class, such as training loops with a far more flexible callback integration.\n", "\n", "Over the next few paragraphs I'll walk through the ABCs of building DALI pipelines and connecting them to fastai's new style of training loop. As we journey, you'll also see just how fast DALI runs (it's really impressive), as well as one *really weird* workaround I came up with in an attempt to get around one striking shortcoming of the DALI libary." ] }, { "cell_type": "code", "execution_count": 1, "metadata": {}, "outputs": [], "source": [ "%load_ext autoreload\n", "%autoreload 2\n", "%matplotlib inline\n", "%config InlineBackend.figure_format = 'retina'" ] }, { "cell_type": "code", "execution_count": 2, "metadata": {}, "outputs": [], "source": [ "from exports.nb_10 import *" ] }, { "cell_type": "code", "execution_count": 3, "metadata": {}, "outputs": [], "source": [ "from nvidia.dali.pipeline import Pipeline\n", "import nvidia.dali.ops as ops\n", "import nvidia.dali.types as types\n", "from nvidia.dali.plugin.pytorch import DALIClassificationIterator, feed_ndarray" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Setting the Stage\n", "My DALI augmentation pipeline includes the random crop & resize, flip, perspective warp, and rotation transforms that I learned to [implement from scratch](http://nbviewer.jupyter.org/github/jamesdellinger/fastai_deep_learning_course_part2_v3/blob/master/10_augmentation_my_reimplementation.ipynb?flush_cache=true) in this year's fast.ai part II. To set a baseline and gauge whether each DALI transform helps improve results, I created a simple, four layer CNN model whose task was to perform image classification using the [Imagenette dataset](https://github.com/fastai/imagenette). Imagenette was created by [Jeremy Howard](https://www.fast.ai/about/#jeremy) to be a much slimmed-down version of ImageNet that allows practitioners to get a rough feel for how their model would perform if trained on ImageNet, without actually having to train ImageNet from scratch. I like to use Imagenette to perform quick sanity checks during early iterations on prototypes, and it's become an indispensable part of my experiments." ] }, { "cell_type": "code", "execution_count": 4, "metadata": {}, "outputs": [], "source": [ "# Path to the Imagenette dataset\n", "path = datasets.untar_data(imagenette_url)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Image inputs are normalized using the Imagenette means and standard deviations that I calculated back in [Notebook 08](http://nbviewer.jupyter.org/github/jamesdellinger/fastai_deep_learning_course_part2_v3/blob/master/08_data_block_my_reimplementation.ipynb?flush_cache=true)." ] }, { "cell_type": "code", "execution_count": 5, "metadata": {}, "outputs": [], "source": [ "from torch import Tensor\n", "\n", "bs=64 # batch size\n", "imagenette_means = Tensor([0.4879, 0.4740, 0.4307])\n", "imagenette_std_devs = Tensor([0.2814, 0.2831, 0.3079])" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### How to Build a DALI Pipeline\n", "\n", "The backbone of all DALI pipelines is a Python [class called `Pipeline`](https://docs.nvidia.com/deeplearning/sdk/dali-developer-guide/docs/examples/getting%20started.html#Pipeline). I found that it was straightforward to create specialized pipelines for my training and validation data that both inherit from DALI's pipeline class.\n", "\n", "Two methods must be defined when writing your own pipeline class: `__init__()` and `define_graph()`. The init method is the place to specify the hyperparameters of each and every transform operation you wish to call. In addition to augmentations like image rotations and flips, these operations will also include initial image loading, as well as any image resizing and normalizing, tensor reshaping, and data type casting.\n", "\n", "`define_graph()` is the place where you specify *the order* in which you want your pipeline's image transforms to be executed. This method is also where you will want to call a DALI random number generator so that you can pass it to any image transform operation that supports randomly generated augmentations. `define_graph()` ultimately returns a tuple containing your augmented images and their labels. To illustrate how all these pieces come together, here's how I used DALI's `ops.Rotate` function to add randomly generated image rotations to my training pipeline:\n", "\n", "1. In the pipeline's `__init__()` method I created variables for the rotation operation, `ops.Rotate`, as well as for two random number generators. The first random number generator, `ops.Uniform`, will produce a list as long as my batch size. This list will contain floats randomly chosen from a uniform distribution that spans a particular range, and these floats represent angles (in degrees), by which `ops.Rotate` will rotate the batch's images. The second random number generator, `ops.CoinFlip` creates a list containing ones and zeros that is also as long as the batch size. The ones appear with a frequency of 7.5%, and passing this list to the rotation transform will ensure that any image in a batch will have a 7.5% chance of getting rotated:\n", "```python\n", "self.rotate = ops.Rotate(device='gpu', interp_type=types.INTERP_NN)\n", "self.rotate_range = ops.Uniform(range = (-7, 7))\n", "self.rotate_coin = ops.CoinFlip(probability=0.075)\n", "```\n", "\n", "2. The `define_graph()` method is where I call the `ops.Uniform` and `ops.CoinFlip` random number generators to create fresh sets of random numbers for each batch. I then call `ops.Rotate` and pass the two lists of random numbers to its `angle` and `mask` attributes, respectively:\n", "```python\n", "prob_rotate = self.rotate_coin()\n", "angle_range = self.rotate_range()\n", "...\n", "images = self.rotate(images, angle=angle_range, mask=prob_rotate)\n", "```\n", "\n", "DALI will now rotate about 7.5% of the images in each training batch by an angle between -7 and 7 degrees. All image rotations will happen at the same time.\n", "\n", "[`ops.Rotate`](https://docs.nvidia.com/deeplearning/sdk/dali-developer-guide/docs/supported_ops.html#rotate) is, to my mind, the ideal DALI transform operation in that it supports rotating each image by a *randomly chosen* angle. Supporting random parameters should be table stakes for any image augmentation operation. Unfortunately, as I'll detail soon enough, this *isn't true* for DALI's [`ops.WarpAffine`](https://docs.nvidia.com/deeplearning/sdk/dali-developer-guide/docs/supported_ops.html#nvidia.dali.ops.WarpAffine) perspective warp transform operation.\n", "\n", "Once train and validation pipeline classes are completely defined, all that's left to do is build the pipelines and create the train and validation data loaders. I demonstrate this just below, but before that, just below is the complete code for my training and validation set pipeline classes." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Generating random affine transforms for image perspective warps\n", "\n", "Dali's [`ops.WarpAffine`](https://docs.nvidia.com/deeplearning/sdk/dali-developer-guide/docs/supported_ops.html#warpaffine) method has a `matrix` argument that accepts a list of six float values that specify an affine transform matrix.\n", "\n", "Here's a quick refresher on affine transforms:\n", "\n", "A 2-dimensional affine transformation has the very recognizable form $$y = Ax + b$$ where:\n", "* A is a 2x2 matrix\n", "* b is a vector with 2 coordinates\n", "\n", "This kind of affine transform is often represented as the following 3x3 matrix:\n", "\n", "$$\n", "\\begin{bmatrix} \n", "A[0,0] & A[0,1] & b[0] \\\\\n", "A[1,0] & A[1,1] & b[1] \\\\\n", " 0 & 0 & 1\n", "\\end{bmatrix}\n", "$$\n", "\n", "Now in order to properly pass an affine transform matrix to `ops.WarpAffine`, we place the $A$ and $b$ values into a list in the following order:\n", "```\n", "[A[0,0], A[0,1], b[0], A[1,0], A[1,1], b[1]]\n", "```\n", "\n", "In the cell below I've written a helper function to generate an affine transform that can be used to apply a perspective warp to an image. But do I want to apply just any kind of warp? Not really. I want be sure that however I warp the image, the contents of the image don't appear squished or stretched -- it should just look like the image is tilting toward or away from me. I can do this using logic somewhat similar to what was implemented in the [image augmentation notebook](http://nbviewer.jupyter.org/github/jamesdellinger/fastai_deep_learning_course_part2_v3/blob/master/10_augmentation_my_reimplementation.ipynb?flush_cache=true#Perspective-Warping) from part II of the 2019 fast.ai deep learning course: \n", "> If the upper-left corner x and y coordinates are shifted by certain magnitudes, the lower-left and upper-right x,y coordinates should be shifted by the same magnitudes, but in the other direction.\n", "\n", "My algorithm below follows these steps:\n", "1. Take a triangle represented by three sets of coordinates from the original image -- I'll use the orignal image's upper-left, lower-left, and upper-right corners.\n", "2. Specify where I want the coordinates of that triangle to be shifted in the warped image. \n", "3. Compute the affine transform that would relocate the coordinates specified in step 1. to the new locations specified in step 2." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "#### `get_affine_tfm()`" ] }, { "cell_type": "code", "execution_count": 6, "metadata": {}, "outputs": [], "source": [ "import cv2\n", "import numpy as np\n", "\n", "def get_affine_tfm(im_size, mag):\n", " \n", " x_mag = uniform(-mag, mag)\n", " y_mag = uniform(-mag, mag)\n", " \n", " src_pts = (np.array([[0,0], [0,1], [1,0]])*im_size).astype(np.float32)\n", " dest_pts = (np.array([[-x_mag, -y_mag], [x_mag, 1+y_mag], [1+x_mag, y_mag]])*im_size).astype(np.float32)\n", " affine_tfm = cv2.getAffineTransform(src_pts, dest_pts)\n", " return FloatTensor(affine_tfm).view(6).tolist() " ] }, { "cell_type": "code", "execution_count": 7, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "[0.9795135259628296,\n", " -0.02048650197684765,\n", " 1.3111361265182495,\n", " -0.05597070977091789,\n", " 0.9440293312072754,\n", " 3.582125425338745]" ] }, "execution_count": 7, "metadata": {}, "output_type": "execute_result" } ], "source": [ "get_affine_tfm(128, 0.1)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Train and Val Pipelines" ] }, { "cell_type": "code", "execution_count": 8, "metadata": {}, "outputs": [], "source": [ "im_size = 128\n", "\n", "class ImagenetteTrainPipeline(Pipeline):\n", " def __init__(self, batch_size=bs, num_threads=8, device_id=0):\n", " super(ImagenetteTrainPipeline, self).__init__(batch_size, num_threads, device_id, seed=42)\n", " self.input = ops.FileReader(file_root = path/'train', random_shuffle=True)\n", " \n", " # Randomly crop and resize\n", " self.decode = ops.nvJPEGDecoderRandomCrop(device='mixed', output_type=types.RGB,\n", " random_area=[0.08,1.0], \n", " random_aspect_ratio=[0.75,1.333333], \n", " num_attempts=100)\n", " self.resize = ops.Resize(device='gpu', resize_x=im_size, resize_y=im_size,\n", " interp_type=types.INTERP_NN)\n", " \n", " # Will flip vertically with prob of 0.1\n", " self.vert_flip = ops.Flip(device='gpu', horizontal=0, interp_type=types.INTERP_NN)\n", " self.vert_coin = ops.CoinFlip(probability=0.1)\n", " \n", " # My workaround for Dali not supporting random affine transforms: \n", " # a \"synthetic random\" warp affine transform.\n", " self.num_warp_tfms = 7\n", " self.affine_tfms = [get_affine_tfm(im_size, 0.1) for i in range(self.num_warp_tfms)]\n", " self.warp_tfms = [ops.WarpAffine(device='gpu', matrix=i, interp_type=types.INTERP_NN) for i in self.affine_tfms]\n", " self.warp_prob = ops.CoinFlip(probability=0.025)\n", " # TODO: self.warp_prob() should actually be called below in define_graph(). \n", " # Calling it up here in the __init__ method means that the same warp affines \n", " # will be applied to images at the *same* indices in every mini-batch.\n", " self.warp_probs = [self.warp_prob() for i in range(self.num_warp_tfms)]\n", " \n", " # Rotate within a narrow range with probability of 0.075\n", " self.rotate = ops.Rotate(device='gpu', interp_type=types.INTERP_NN)\n", " self.rotate_range = ops.Uniform(range = (-7, 7))\n", " self.rotate_coin = ops.CoinFlip(probability=0.075)\n", " \n", " # Flip horizontally with prob of 0.5, then convert tensor format from \n", " # NHWC to NCHW and normalize.\n", " self.cmnp = ops.CropMirrorNormalize(device='gpu',\n", " output_dtype=types.FLOAT,\n", " output_layout=types.NCHW,\n", " crop=(im_size, im_size),\n", " image_type=types.RGB,\n", " mean=listify(imagenette_means*255),\n", " std=listify(imagenette_std_devs*255))\n", " self.mirror_coin = ops.CoinFlip(probability=0.5)\n", " \n", " def define_graph(self):\n", " # Generate new random numbers for each mini-batch\n", " prob_vert_flip = self.vert_coin()\n", " prob_rotate = self.rotate_coin()\n", " prob_mirror = self.mirror_coin()\n", " angle_range = self.rotate_range()\n", "\n", " # Perform pipeline operations in the order they appear below:\n", " self.jpegs, self.labels = self.input(name='r')\n", " images = self.decode(self.jpegs)\n", " images = self.resize(images)\n", " images = self.vert_flip(images, vertical=prob_vert_flip) # Specify prob_vert_flip here \n", " \n", " for i, tfm in enumerate(self.warp_tfms):\n", " images = tfm(images, mask=self.warp_probs[i])\n", " images = self.rotate(images, angle=angle_range, mask=prob_rotate)\n", "\n", " images = self.cmnp(images, mirror=prob_mirror) \n", " return (images, self.labels)\n", " \n", "class ImagenetteValPipeline(Pipeline):\n", " def __init__(self, batch_size=bs, num_threads=8, device_id=0):\n", " super(ImagenetteValPipeline, self).__init__(batch_size, num_threads, device_id, seed=42)\n", " self.input = ops.FileReader(file_root = path/'val')\n", " self.decode = ops.nvJPEGDecoder(device='mixed', output_type=types.RGB)\n", " # Not possible to center crop with DALI, so I use the entire image.\n", " self.resize = ops.Resize(device = 'gpu', resize_x=im_size, resize_y=im_size, \n", " interp_type=types.INTERP_NN)\n", " \n", " # Convert tensor format from NHWC to NCHW and normalize\n", " self.normperm = ops.NormalizePermute(device=\"gpu\",\n", " height=im_size,\n", " width=im_size,\n", " output_dtype=types.FLOAT,\n", " image_type=types.RGB,\n", " mean=listify(imagenette_means*255),\n", " std=listify(imagenette_std_devs*255))\n", " \n", " def define_graph(self):\n", " self.jpegs, self.labels = self.input(name='r')\n", " images = self.decode(self.jpegs)\n", " images = self.resize(images)\n", " images = self.normperm(images)\n", " return (images, self.labels)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Building DALI Data loaders\n", "\n", "It takes me just three lines of code to build a data loader that works with PyTorch. \n", "\n", "```python\n", "pipe = ImagenetteTrainPipeline()\n", "pipe.build()\n", "train_dl = DALIClassificationIterator(pipe, pipe.epoch_size('r'), stop_at_epoch=True)\n", "```" ] }, { "cell_type": "code", "execution_count": 9, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "([64, 3, 128, 128], [64, 1])" ] }, "execution_count": 9, "metadata": {}, "output_type": "execute_result" } ], "source": [ "pipe = ImagenetteTrainPipeline()\n", "pipe.build()\n", "images, labels = pipe.run()\n", "images.as_tensor().shape(), labels.as_tensor().shape()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Dali Pipeline Speed Test\n", "\n", "Every DALI pipeline object has a `run()` function that will grab a batch of images, send it through the pipeline, and return the transformed images and their labels. Timing this function enabled me to measure just how fast DALI could fly. \n", "\n", "Note that I ran my speed test using an AWS [p2.xlarge](https://aws.amazon.com/ec2/instance-types/p2/) compute instance that has a single GPU, and mini-batches containing 64 images. I found that the final version of my Imagenette training pipeline, which contains twelve operations, runs in just over 40 ms. Moreover, this 40 ms includes the time it takes to load the initial batch's images. Subsequent batches should run faster because DALI is able to load each subsequent batch ahead of time. \n", "\n", "As I added in more transforms, even upwards of twenty consecutive warp affine transforms at one point, the duration never exceeded much higher than 50 ms. (Why did I feel the need to have so many warp affine operations? I'll get to that shortly.)\n", "\n", "At any rate, a duration of 40 ms per mini-batch works out to around 625 µs per image for *all* twelve operations that are in the pipeline. As a basis for comparison, in our fast.ai image augmentation [lesson notebook](https://nbviewer.jupyter.org/github/jamesdellinger/fastai_deep_learning_course_part2_v3/blob/master/10_augmentation_my_reimplementation.ipynb?flush_cache=true#Time-Budget), we saw that the main choke point of using Pillow for image transforms was the 5 ms it took for Pillow to load a single image.\n", "\n", "In the very same notebook we also used PyTorch JIT [to implement](https://nbviewer.jupyter.org/github/jamesdellinger/fastai_deep_learning_course_part2_v3/blob/master/10_augmentation_my_reimplementation.ipynb?flush_cache=true#JIT-version-of-rotate_batch()) an image rotation algorithm that, similar to DALI, transforms batches on the GPU. It ran around 4.3 ms per batch. Assuming that a JIT implementation of any transform would take the same duration (possibly a stretch), a quick back-of-the-envelope calculation would seem to indicate that JIT performance is not much worse than DALI (4.3 x 12 = 51.6 ms). However, the beauty of DALI is that while it took *twelve lines of code* to define the script that carries out our JIT rotation transform, DALI lets us get all the same functionality and speed with just a single function call!" ] }, { "cell_type": "code", "execution_count": 10, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "41.7 ms ± 305 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)\n" ] } ], "source": [ "%timeit -n 100 t_ims, t_lbls = pipe.run()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Display a training mini-batch" ] }, { "cell_type": "code", "execution_count": 11, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "torch.Size([64, 3, 128, 128])" ] }, "execution_count": 11, "metadata": {}, "output_type": "execute_result" } ], "source": [ "t_dali_dl = DALIClassificationIterator(pipe, pipe.epoch_size('r'), stop_at_epoch=True)\n", "next_batch = next(t_dali_dl)[0]['data']\n", "next_batch.size()" ] }, { "cell_type": "code", "execution_count": 12, "metadata": {}, "outputs": [ { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "image/png": { "height": 357, "width": 710 }, "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "# Format the batch so we can display using matplotlib.\n", "def denorm_batch(normed_batch):\n", " means = imagenette_means.view(1,3,1,1).cuda()\n", " std_devs = imagenette_std_devs.view(1,3,1,1).cuda()\n", " return torch.clamp((normed_batch * std_devs + means).permute(0,2,3,1), min=0)\n", "\n", "show_batch(denorm_batch(next_batch), rows=2)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Initialize training and validation DALI iterators (data loaders)" ] }, { "cell_type": "code", "execution_count": 13, "metadata": {}, "outputs": [], "source": [ "train_dl = DALIClassificationIterator(pipe, pipe.epoch_size('r'), stop_at_epoch=True)" ] }, { "cell_type": "code", "execution_count": 14, "metadata": {}, "outputs": [], "source": [ "pipe = ImagenetteValPipeline()\n", "pipe.build()\n", "valid_dl = DALIClassificationIterator(pipe, pipe.epoch_size('r'), stop_at_epoch=True)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Three tricks to get the new fastai to work with DALI data loaders\n", "\n", "I'd like to take a brief detour to share with folks going through the 2019 fast.ai deep learning part II [course](https://course.fast.ai/index.html), three tweaks I added to the codebase so that I could get DALI's data loaders to work seamlessly with the new-and-improved fastai [training loop](http://nbviewer.jupyter.org/github/jamesdellinger/fastai_deep_learning_course_part2_v3/blob/master/09_optimizers_my_reimplementation.ipynb?flush_cache=true#Getting-rid-of-the-Runner-class) that is implemented as part of this course. [This notebook](http://nbviewer.jupyter.org/github/jamesdellinger/fastai_deep_learning_course_part2_v3/blob/master/Diving_into_DALI.ipynb?flush_cache=true#Make-the-Learner-class-compatible-with-Dali-dataloaders) has a working version of a training loop that includes all the following modifications:\n", "\n", "1. Modify the `Learner` class so that it properly indexes into the tensors returned by DALI data loaders to grab the images and labels for each batch. Images and labels are contained under `'data'` and `'labels'` keys, respectively:\n", "```python\n", "xb = to_float_tensor(batch[0]['data'])\n", "yb = batch[0]['label'].squeeze().cuda().long()\n", "```\n", " Also reset DALI train and val data loaders after each epoch:\n", "```python\n", "self.data.train_dl.reset()\n", "self.data.valid_dl.reset()\n", "```\n", "\n", "2. Change the `AvgStats` callback so that it returns `self.tot_loss` (and not `self.tot_loss.item()`):\n", "```python\n", "def all_stats(self): return [self.tot_loss] + self.tot_mets\n", "```\n", "\n", "3. Finally, cap the maximum value that the hyperparameter schedule builder, `combine_scheds()`, uses to track the current iteration's position relative to the training cycle's length. While this value should always be below 1.0, when using DALI there were times when its value at *the beginning* of the final iteration would be 1.0 or just greater (e.g. 1.0000000000000022). This results in an IndexError, as the scheduler is forced to index into a schedule phase that actually doesn't exist!\n", "\n", "Note that I highly recommend the [latest](https://course.fast.ai/index.html) fast.ai part II to anyone who is on their journey toward becoming a deep learning practitioner and researcher: it's no exaggeration to say that when you finish going through the course notebooks, you will have ability and confidence that you can implement *anything* from scratch all on your own!" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "#### 1. Make the `Learner` class compatible with Dali data loaders\n", "NVIDIA's DALI team wrote their own training loop that uses Dali data loaders and then trains a ResNet50 model on ImageNet. That [example](https://github.com/NVIDIA/DALI/blob/666ce55ec27783f36f2b7a39076793d955d4ad0f/docs/examples/pytorch/resnet50/main.py) was invaluable in helping me to identify how to modify the `Learner` class in order to make it compatible with Dali." ] }, { "cell_type": "code", "execution_count": 15, "metadata": {}, "outputs": [], "source": [ "class DaliLearner(Learner):\n", " def __init__(self, model, data, loss_func, opt_func=sgd_opt, lr=3e-4, \n", " splitter=param_getter, callback_funcs=None):\n", " super(DaliLearner, self).__init__(model, data, loss_func, opt_func=sgd_opt, lr=3e-4, \n", " splitter=param_getter, callback_funcs=callback_funcs)\n", " \n", " def all_batches(self):\n", " self.iters = int(self.dl._size/bs)\n", " try:\n", " for i, batch in enumerate(self.dl): \n", " # Modification #1: Extract image and label tensors from \n", " # Dali iterators (data loaders)\n", " xb = to_float_tensor(batch[0]['data'])\n", " yb = batch[0]['label'].squeeze().cuda().long()\n", " self.one_batch(i, xb, yb)\n", " except CancelEpochException: self('after_cancel_epoch')\n", " \n", " def fit(self, epochs, callback_funcs=None, reset_opt=False):\n", " self.add_callbacks(callback_funcs)\n", " if reset_opt or not self.opt: \n", " self.opt = self.opt_func(self.splitter(self.model), lr=self.lr)\n", " \n", " try:\n", " self.do_begin_fit(epochs)\n", " for epoch in range(epochs):\n", " self.do_begin_epoch(epoch)\n", " if not self('begin_epoch'): self.all_batches()\n", " \n", " with torch.no_grad():\n", " self.dl = self.data.valid_dl\n", " if not self('begin_validate'): self.all_batches()\n", " self('after_epoch')\n", " # Modification #2: Reset Dali train and val iterators \n", " # (data loaders) at epoch's end.\n", " self.data.train_dl.reset()\n", " self.data.valid_dl.reset()\n", " \n", " except CancelTrainException: self('after_cancel_train')\n", " finally: \n", " self('after_fit')\n", " self.remove_callbacks(callback_funcs)\n", " \n", "def get_dali_learner(n_outs, data, lr=3e-4, layer=conv_layer, loss_func=F.cross_entropy,\n", " callback_funcs=None, opt_func=sgd_opt, **kwargs):\n", " model = get_cnn_model(data, n_outs, layer, **kwargs)\n", " init_cnn(model)\n", " return DaliLearner(model, data, loss_func, lr, layer, opt_func,\n", " callback_funcs=callback_funcs)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "#### 2. Make the `AvgStats` class compatible with Dali data loaders" ] }, { "cell_type": "code", "execution_count": 16, "metadata": {}, "outputs": [], "source": [ "class DaliAvgStats(AvgStats):\n", " def __init__(self, metrics, in_train):\n", " super(DaliAvgStats, self).__init__(metrics, in_train)\n", " \n", " # Modification: Leave self.tot_loss as a Cuda Tensor, since \n", " # we're doing everything on the GPU. \n", " # Note that orignal implementation of AvgStats used: self.tot_loss.item()\n", " @property\n", " def all_stats(self): return [self.tot_loss] + self.tot_mets\n", " \n", "class DaliAvgStatsCallback(AvgStatsCallback):\n", " def __init__(self, metrics):\n", " self.train_stats, self.valid_stats = DaliAvgStats(metrics,in_train=True), DaliAvgStats(metrics,in_train=False)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "#### 3. Finally, fix the hyperparam scheduler\n", "\n", "I found that my training loop would occasionally break at the final iteration of the final epoch. The error message I saw was:\n", "\n", "```python\n", "~/fastai_docs/dev_course/dl2/exports/nb_05.py in _inner(pos)\n", " 37 def _inner(pos):\n", " 38 idx = (pos >= pcts).nonzero().max()\n", "---> 39 actual_pos = (pos-pcts[idx]) / (pcts[idx+1] - pcts[idx])\n", " 40 return scheds[idx](actual_pos)\n", " 41 return _inner\n", "\n", "IndexError: index 3 is out of bounds for dimension 0 with size 3\n", "```\n", "\n", "This lead me to examine the `combine_scheds()` method that was created back in [Notebook 05](http://nbviewer.jupyter.org/github/jamesdellinger/fastai_deep_learning_course_part2_v3/blob/master/05_anneal_my_reimplementation.ipynb?flush_cache=true#combine_scheds()). We use `combine_scheds()` to define hyper parameter schedules, such as one-cycle cosine learning rate warmup and annealing. It turned out that the value for the `pos` variable at the beginning of the final iteration of the final epoch is sometimes 1.0 or greater (sometimes it's less). When it's 1.0 or higher, this breaks the logic later on down in `combine_scheds()`, as it gets forced to index one position further in the `pcts` list than we'd anticipated. To prevent this, I capped the maximum value of `pos` and `0.9999999`." ] }, { "cell_type": "code", "execution_count": 17, "metadata": {}, "outputs": [], "source": [ "def combine_scheds(pcts, scheds):\n", " assert sum(pcts) == 1.\n", " pcts = tensor([0] + listify(pcts))\n", " assert torch.all(pcts >= 0)\n", " pcts = torch.cumsum(pcts, 0)\n", " def _inner(pos):\n", " # Using Dali data loaders, pos at beginning of final iteration of \n", " # final epoch is sometimes slightly above 1.0 (e.g. 1.0000000000000022).\n", " # Unfortunately the logic below only works if pos is always less than 1.0\n", " # at beginning of final iteration.\n", " #\n", " # Modification: cap maximum pos value at 0.9999999 to prevent this \n", " # unexpected numerical instability.\n", " pos = min(1-1e-7, pos)\n", " idx = (pos >= pcts).nonzero().max() # Get index of most-recently completed phase.\n", " actual_pos = (pos-pcts[idx]) / (pcts[idx+1] - pcts[idx])\n", " return scheds[idx](actual_pos)\n", " return _inner" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Train a simple CNN" ] }, { "cell_type": "code", "execution_count": 20, "metadata": {}, "outputs": [], "source": [ "min_lr=3e-1\n", "n_outs = [64, 64, 128, 256] \n", "phases = combine_scheds([0.3, 0.7], cos_1cycle_anneal(min_lr, 3*min_lr, min_lr))\n", "scheduler = ParamScheduler('lr', phases)\n", "callback_funcs = [partial(DaliAvgStatsCallback, accuracy),\n", " CudaCallback,\n", " Recorder]\n", "data = DataBunch(train_dl, valid_dl, 3, 10)\n", "learn = get_dali_learner(n_outs, data, layer=conv_layer, callback_funcs=callback_funcs)" ] }, { "cell_type": "code", "execution_count": 21, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "['epoch', 'train_loss', 'train_accuracy', 'valid_loss', 'valid_accuracy', 'time']\n", "['0', '1.895819', '0.337211', '2.429746', '0.330000', '00:15']\n", "['1', '1.636598', '0.447417', '2.799575', '0.234000', '00:16']\n", "['2', '1.474476', '0.507290', '1.589068', '0.496000', '00:16']\n", "['3', '1.333716', '0.564216', '1.419040', '0.550000', '00:16']\n", "['4', '1.228488', '0.597255', '1.017867', '0.674000', '00:15']\n", "['5', '1.168154', '0.619901', '1.559534', '0.512000', '00:15']\n", "['6', '1.084979', '0.645106', '0.884512', '0.718000', '00:15']\n", "['7', '1.034656', '0.663254', '0.908206', '0.720000', '00:15']\n" ] } ], "source": [ "learn.fit(8, scheduler)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Run 10 independent training runs" ] }, { "cell_type": "code", "execution_count": 22, "metadata": { "scrolled": false }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "['epoch', 'train_loss', 'train_accuracy', 'valid_loss', 'valid_accuracy', 'time']\n", "['0', '1.903252', '0.327672', '1.881599', '0.356000', '00:15']\n", "['1', '1.641446', '0.441368', '2.001688', '0.392000', '00:15']\n", "['2', '1.460489', '0.515356', '1.404899', '0.562000', '00:15']\n", "['3', '1.337661', '0.557003', '1.531008', '0.512000', '00:16']\n", "['4', '1.222545', '0.595393', '1.292349', '0.568000', '00:15']\n", "['5', '1.164153', '0.619358', '1.158262', '0.606000', '00:15']\n", "['6', '1.090362', '0.641616', '1.012236', '0.674000', '00:15']\n", "['7', '1.037324', '0.655576', '0.893488', '0.734000', '00:15']\n", "['epoch', 'train_loss', 'train_accuracy', 'valid_loss', 'valid_accuracy', 'time']\n", "['0', '1.919156', '0.322786', '1.869435', '0.380000', '00:15']\n", "['1', '1.656038', '0.438964', '2.416688', '0.346000', '00:15']\n", "['2', '1.461003', '0.511633', '1.326631', '0.566000', '00:15']\n", "['3', '1.335952', '0.555607', '1.178318', '0.608000', '00:15']\n", "['4', '1.218848', '0.602606', '1.268802', '0.566000', '00:15']\n", "['5', '1.160984', '0.618892', '1.083393', '0.628000', '00:15']\n", "['6', '1.081529', '0.650458', '0.888637', '0.714000', '00:16']\n", "['7', '1.027310', '0.665503', '0.825380', '0.736000', '00:15']\n", "['epoch', 'train_loss', 'train_accuracy', 'valid_loss', 'valid_accuracy', 'time']\n", "['0', '1.909453', '0.331007', '1.921076', '0.378000', '00:15']\n", "['1', '1.671697', '0.434776', '1.794133', '0.442000', '00:15']\n", "['2', '1.486537', '0.499535', '1.223321', '0.614000', '00:15']\n", "['3', '1.323926', '0.560648', '1.393399', '0.542000', '00:15']\n", "['4', '1.225778', '0.589499', '1.170338', '0.592000', '00:15']\n", "['5', '1.136109', '0.628044', '0.949763', '0.692000', '00:15']\n", "['6', '1.063799', '0.646735', '1.246674', '0.616000', '00:15']\n", "['7', '1.014408', '0.665271', '0.888749', '0.726000', '00:15']\n", "['epoch', 'train_loss', 'train_accuracy', 'valid_loss', 'valid_accuracy', 'time']\n", "['0', '1.900528', '0.332558', '2.099444', '0.310000', '00:16']\n", "['1', '1.654989', '0.432992', '1.866361', '0.386000', '00:15']\n", "['2', '1.483353', '0.505196', '1.464445', '0.528000', '00:15']\n", "['3', '1.340796', '0.553358', '1.446849', '0.536000', '00:15']\n", "['4', '1.236407', '0.588568', '0.999579', '0.678000', '00:15']\n", "['5', '1.157342', '0.618970', '0.997610', '0.666000', '00:15']\n", "['6', '1.088274', '0.642547', '0.915451', '0.700000', '00:15']\n", "['7', '1.031296', '0.662866', '0.964251', '0.692000', '00:15']\n", "['epoch', 'train_loss', 'train_accuracy', 'valid_loss', 'valid_accuracy', 'time']\n", "['0', '1.901068', '0.328990', '2.255987', '0.310000', '00:15']\n", "['1', '1.649639', '0.440670', '1.803807', '0.436000', '00:15']\n", "['2', '1.462271', '0.508221', '1.563730', '0.496000', '00:16']\n", "['3', '1.334529', '0.553436', '1.500115', '0.504000', '00:15']\n", "['4', '1.230358', '0.592601', '1.233233', '0.582000', '00:16']\n", "['5', '1.159015', '0.617341', '1.315156', '0.576000', '00:16']\n", "['6', '1.101140', '0.635722', '1.008087', '0.692000', '00:15']\n", "['7', '1.039505', '0.658911', '1.033928', '0.668000', '00:15']\n", "['epoch', 'train_loss', 'train_accuracy', 'valid_loss', 'valid_accuracy', 'time']\n", "['0', '1.914491', '0.333799', '1.700076', '0.442000', '00:15']\n", "['1', '1.706260', '0.418412', '1.761811', '0.450000', '00:15']\n", "['2', '1.500307', '0.502792', '1.498659', '0.488000', '00:15']\n", "['3', '1.341278', '0.554444', '1.401185', '0.524000', '00:15']\n", "['4', '1.241168', '0.584458', '1.287167', '0.582000', '00:15']\n", "['5', '1.141852', '0.622925', '1.078555', '0.666000', '00:15']\n", "['6', '1.074908', '0.647123', '1.001426', '0.666000', '00:16']\n", "['7', '1.025111', '0.663409', '0.933019', '0.682000', '00:16']\n", "['epoch', 'train_loss', 'train_accuracy', 'valid_loss', 'valid_accuracy', 'time']\n", "['0', '1.871013', '0.339538', '2.708993', '0.272000', '00:15']\n", "['1', '1.623147', '0.450985', '1.787621', '0.412000', '00:15']\n", "['2', '1.440421', '0.519777', '1.394086', '0.512000', '00:16']\n", "['3', '1.334892', '0.560261', '1.627740', '0.472000', '00:16']\n", "['4', '1.234205', '0.596712', '1.228550', '0.592000', '00:16']\n", "['5', '1.149206', '0.621142', '0.970867', '0.686000', '00:15']\n", "['6', '1.088710', '0.640608', '0.995219', '0.688000', '00:15']\n", "['7', '1.039516', '0.657748', '0.964270', '0.702000', '00:15']\n", "['epoch', 'train_loss', 'train_accuracy', 'valid_loss', 'valid_accuracy', 'time']\n", "['0', '1.909240', '0.329766', '1.758170', '0.418000', '00:15']\n", "['1', '1.653682', '0.437956', '1.808382', '0.392000', '00:15']\n", "['2', '1.463706', '0.510005', '1.555678', '0.508000', '00:15']\n", "['3', '1.339135', '0.560261', '1.267131', '0.590000', '00:15']\n", "['4', '1.235054', '0.593687', '1.122498', '0.634000', '00:15']\n", "['5', '1.149252', '0.622693', '0.992919', '0.682000', '00:15']\n", "['6', '1.069907', '0.648053', '0.936361', '0.688000', '00:15']\n", "['7', '1.019157', '0.662634', '0.902274', '0.714000', '00:15']\n", "['epoch', 'train_loss', 'train_accuracy', 'valid_loss', 'valid_accuracy', 'time']\n", "['0', '1.896049', '0.333644', '2.022292', '0.340000', '00:15']\n", "['1', '1.630343', '0.447262', '2.532714', '0.280000', '00:15']\n", "['2', '1.469654', '0.509539', '1.543758', '0.454000', '00:15']\n", "['3', '1.339624', '0.554522', '1.272554', '0.588000', '00:15']\n", "['4', '1.222784', '0.595936', '1.545778', '0.552000', '00:15']\n", "['5', '1.142478', '0.618427', '1.143153', '0.616000', '00:16']\n", "['6', '1.057361', '0.653870', '0.852417', '0.730000', '00:16']\n", "['7', '1.003855', '0.674732', '0.903616', '0.720000', '00:16']\n", "['epoch', 'train_loss', 'train_accuracy', 'valid_loss', 'valid_accuracy', 'time']\n", "['0', '1.862009', '0.346983', '1.660837', '0.448000', '00:15']\n", "['1', '1.634747', '0.446719', '1.812488', '0.400000', '00:15']\n", "['2', '1.466605', '0.512409', '1.517050', '0.522000', '00:15']\n", "['3', '1.327312', '0.554599', '1.251383', '0.564000', '00:16']\n", "['4', '1.246225', '0.584923', '1.105974', '0.620000', '00:15']\n", "['5', '1.152176', '0.613851', '1.083607', '0.636000', '00:15']\n", "['6', '1.077574', '0.649760', '0.915648', '0.694000', '00:15']\n", "['7', '1.038386', '0.662944', '0.954241', '0.696000', '00:15']\n" ] } ], "source": [ "for i in range(10):\n", " min_lr=3e-1\n", " n_outs = [64, 64, 128, 256] \n", " phases = combine_scheds([0.3, 0.7], cos_1cycle_anneal(min_lr, 3*min_lr, min_lr))\n", " scheduler = ParamScheduler('lr', phases)\n", " callback_funcs = [partial(DaliAvgStatsCallback, accuracy),\n", " CudaCallback,\n", " Recorder]\n", " data = DataBunch(train_dl, valid_dl, 3, 10)\n", " learn = get_dali_learner(n_outs, data, layer=conv_layer, callback_funcs=callback_funcs)\n", " \n", " learn.fit(8, scheduler)" ] }, { "cell_type": "code", "execution_count": 94, "metadata": {}, "outputs": [ { "data": { "image/png": "iVBORw0KGgoAAAANSUhEUgAAAwYAAAIqCAYAAACe310tAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAAWJQAAFiUBSVIk8AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDMuMC4yLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvOIA7rQAAIABJREFUeJzs3Xd8lfX5//HXlUUIECBAQPYeygZxoCKgOOoeuLdtHXW3trb1q3ZpbV34s62LWrXuXSeKIAoCyhKQPWRDWEnIHp/fH/edk0PMIjnhzknez8fjPO7zued1yAm5r/uzzDmHiIiIiIg0bjFBByAiIiIiIsFTYiAiIiIiIkoMREREREREiYGIiIiIiKDEQEREREREUGIgIiIiIiIoMRAREREREZQYiIiIiIgISgxERERERAQlBiIiIiIighIDERERERFBiYGIiIiIiKDEQEREREREUGIgIiJ1xMzWm5kzs+ODjkVERKqmxEBEJELM7Dn/Rnh60LHIgTOz7v7Pr+wr38y2m9mnZnatmcXV0fVvNbN7zax7XZxfRKQqdfKfm4iICLAGyAWygw6kBvYA+f77JCAVOMF/XWFmJznnIv25bgW6AdOB9RE+t4hIlVRjICIidcI5N9451985NzfoWGrgHOdcB/+VDHQEnvC3HQPcG1hkIiJ1RImBiIhIFZxzW51zvwCm+KsuCzIeEZG6oMRARKQeMLPmZvZbM/vGzNLNLNfMVpnZJDPrUskx55vZf81siZntNbMcM1ttZk+ZWZ9KrlfSfr67mQ0ws/+Y2UYzKzCzd/x9Qm3u/fJAM3vFzLb58S03s7vNLKGCa5Tb+djMrgzvi2Fmp5vZND/+fWY228wuquLfq7OZPWtmm/1Y1prZI2bWuuz5I+xTf9nBzFLKieuAfyZ+vwKH14wIYFqZPg4/+hw1+b6IiFRFfQxERAJmZgOAjyi9MSwE8oDewE3ApWZ2unNuZplDrwQeDytn4j3w6eW/Ljazs5xzn1Vy+WOBf+G1o8/0r11ejBOAd4CmQDoQD/QD/gCMAM6qzmct57x3++co9q/fDDgCeMnM2jvnHi3nmMHANKDkxnwf0AGvjf7pwD9qEkt1Qw57H1vO9is58J/JPmA70M7fN7x/A8Du/QKo+fdFRKRSqjEQEQmQmbUEPsS7yXsHGA40dc41B3oALwCtgTfNrFWZw3fh3YQeDbTy28InAgOA/+LdZL9kZs0qCeEfwDfAIP/4JOCOcvZ7Ffgf0MM51wpIBu4CHHCmmZ16oJ8dGALcA9wNtPHP2wF4w99+f9mn8mbWBHgdLylYBRzjnGsBNAdOxfvMd9cgluo60V/uc86llbP9gH8mzrm/O+c6ABv9VeH9Gzo4584p2beW3xcRkUopMRARCdavgO7Au3g3hAucc4UAzrn1zrnL8W4E2wPXhh/onHvZOXezc+5r51y6v84555bjtYH/DO8p9HmVXH8HcIpzbknY8WvK2e8b4ELn3Hp/vyzn3APAB/72yq5RkVbAPc65Pznn9vrn3e7HnoZ3Q31amWMuBvrijXZ0cslTcedcsXPuI7yai5Y1iKVSZtbBzB6nNDF4sbz9IvQzqUyNvy8iIlVRYiAiEqwr/OUjzjlXwT4v+8sTK9j+I/65Sm7aR1ey6/9zzuVU45QPVBDfO/5yYHVjC5ML/KipkHMuF/ikgvOWPD1/wzm3tpxj5+AN91lbb/l9KbaZWQawFfiFv20B8LsDPeEB/EwqUyffFxERUB8DEZHA+J1EO/vF182suIJdSzr3/qhTqZl1xmtXfgJeG/YW/PihT8dKwvi6muF+U8H6zf6ydTXPE+5751zWAZ53mL/8qpLzfgmMrUE84Sr6PM8CNzjn8ivYHomfSUXnrfX3RUSkMkoMRESCc0jY+3bV2D8pvGBmY4D38drXl0jHexIPXkfhZLx27RUpr538jzjnMivYVHKt+Oqcp4yKzlnZedv6y62VHLulBrGUNdY5Nx3AzNoDJwMPAVcDc4CnyzsoQj+TitTq+yIiUhU1JRIRCU74/8EtnXNWxat7yc5mFo/Xzr05Xrv14/A6obYq6bQK3F6yeyUxFEX2IzU8zrntzrn/UDry0v8zs6Fl94vgz6QiNf6+iIhUhxIDEZHgbA97f+gBHnsUXrOS3cCZzrkv/bb54drXJrh6aqe/PKSSfSrbVmPOua/wbvwTgEfK2aWufya1+b6IiFRJiYGISECcc+sovdk7p7J9y1HS1nylcy67gn1OqFFg9dsCf3lMJfscW4fX/zPeEK3Hm1nZf9/a/kxK+gyUW5tQy++LiEiVlBiIiATrOX95gz9xVbnMEz4MZ7q/7GNmieXsP4Had8Ctj972l+eaWfeyG83scOrwczvnVgDv+cXfl9lc259Jhr+sbP6B5/zlgX5fRESqpMRARCTy4s2sbRWvkk61DwBr8TqjfmFmV5hZqOOqmXUxs58C84Czw64xE8gG2gDPm9kh/v5Nzexq4E28ybYampeA1XideD82s6MgdCN8Et7wqemVHB8JD/rLMWYWXnNR25/JUn95UXmJha+m3xcRkSopMRARibyj8Ub7qew1GsCf2OskYBneSDPPAelmtsvMsoENwFN4w3SGxq33j7vLL54PbDGzvXhPnZ/Fu3m+ry4/ZBD8NvvnA3uBfsAsM8sEsoCPgX3AH/3d8+oohlnALL94d9j62v5Mng07Nt3MNprZejN7pcw1Dvj7IiJSHUoMREQC5pxbjXcjdwMwDa/zajJQCHwHPA6MAV4oc9wkvLbmJU+q44DlwD14yUllw4FGLefcQmAI8G9gG96QptuAh4FRlLbV31uHYZTUGkzwmy+VxFbjn4lz7nO8p/xfADlAJ6Ab0KHMfjX6voiIVMUqnjhRREQk+pjZC8ClwH3OuXsDDkdEJGqoxkBERBoMM+sJnOsXPw0yFhGRaKPEQEREooqZnWlmfzGzw0o6cZtZEzM7E/gcr2PybOfczEADFRGJMmpKJCIiUcXMrgWe9ovFeH0JkvHa8wP8AIx3zq0JIDwRkailxEBERKKKP3/BtcA4vM65bYFcvFF/3gMe80fvERGRA6DEQERERERE1MdARERERESUGIiIiIiICEoMREREREQEJQYiIiIiIoISAxERERERoXTMZ4kwM1uHN672+oBDEREREZGGrTuQ4ZzrUZuTKDGoO8lNmzZNGTBgQErQgYiIiIhIw7Vs2TJycnJqfR4lBnVn/YABA1LmzZsXdBwiIiIi0oCNGDGC+fPnr6/tedTHQERERERElBiIiIiIiIgSAxERERERQYmBiIiIiIigxEBERERERFBiICIiIiIiKDEQERERERGUGIiIiIiICEoMREREREQEJQYiIiIiIoISAxERERERQYmBiIiIiIgQpYmBmXU2s8lmtsXM8sxsvZk9amatD/A8Z5vZ52a218xyzWyZmf2fmSXWVewiIiIiIvVR1CUGZtYLmAdcBcwFHgHWArcAX5tZm2qe54/AW8DhwDvAE0AGcB/wmZk1jXz0IiIiIiL1U1zQAdTAP4BU4Gbn3OMlK83sYeA24M/AdZWdwMyGAb8D9gIjnHNr/fUGTAJ+AfwauLcO4hcRERERqXeiqsbAzHoCE4D1eE/4w90DZAGXmVmzKk51NmDAMyVJAYBzzgG/BRxwvZnFRih0Eakl5xzer6iIiIjUhWirMRjnL6c454rDNzjnMs1sJl7icCQwtZLzdPCXa8tu8M+zE69WYhCwsLKAzGxeBZv6V3aciFQsLTOPact3sGDjHpZuyWBrei67s/IpKnbEGMSYkRAXQ/MmcTRPjKOFv2zbvAkdkhNJTU6kQ3Iih7RKpFfb5rRMig/6I4mIiNR70ZYY9POXKyvYvgovMehL5YnBTn/Zo+wGM2sBtPWL/akiMRCRyMgvLObjpdv47+wfmLt+NxVVDhQ7KHaOwvwisvOL2JGZV+W52zRLoFe75vRs14z+HVowqHNLDj2kJU0TVCkoIiJSItoSg5b+Mr2C7SXrW1VxnveBu4Brzewfzrn1Ydv+hNfMCKDKUY6ccyPKW+/XJAyv6niRxq6o2PHW/E088ulKtqTn1sk1dmXlsytrN3PX7w6tizHo274Fgzu3ZFSPNhzZM4XOrZPq5PoiIiLRINoSg6qU3NBX2hDZOTfLzJ4Efg58Z2ZvAruB0XijFC0FDgOK6jBWkUZvwYY93PXWYpZvy9xvfYzByO4pHN+vHUM6t6Jnu2akNEsgITaGYuclE3mFRWTlFbEvr4CM3EIycgpIy8xje0Yu2zPy2JaRy8bd2azbmUVeYfGPrl3sYPm2TJZvy+S1bzcB0Ll1U47s2YZjerdlTN92tG6WcFD+HUREROqDaEsMSmoEWlawPbnMfhVyzl1nZnOBnwET/dXzgJOAa/ASgx01D1VEKpJbUMSjn63iqRlrKA5L49s0S+Dyo7pz0agupCaXP51IrEFsjNfHoEViPFD5tCPFxY7Ne3NYuzOL1Tv2sXRzOt9tTmdN2r4fNVfatCeHN+Zt4o15m7zkpFsK4wakcsKAVHqntqjlpxYREanfoi0xWOEv+1awvY+/rKgPwn6cc5OByWXXm9kz/ttvDig6EanS1vQcrnthHos2lebvSQmx/PTYnvz0uJ40bxLZ/5ZiYowuKUl0SUliTN92ofX78gpZujmdeRv2MHvtbr5dv5vs/NJKwmIHc9d7zY8e+Gg5fds358yhnTh9cEe6tlGTIxERaXgsmob/8yc3W403XGmv8JGJ/E7DW/GGYG3nnMuq4TUmAJ8AXzjnjq9FrPOGDx8+fN68igYtEml8vl2/m+tenMfOffmhdUf3asNfzx1Ml5Rgb7YLiopZvDmdWat3MnX5DhZu3FthB+ihXVpx5tCOnDW0k5obiYhI4EaMGMH8+fPnV9T3tbqiqsbAObfGzKbgjTx0I/B42Ob7gGbAk+FJgZn1949dHn4uM0t2zmWUWdcLeAqvb8Fv6uRDiDRSn36/nRtfmk++394/Nsb47akDuOro7sTEWBVH17342BiGd23N8K6t+cW4Puzc5w2ZOnXZDqav3EFuQWk/hYUb97Jw417u/2g5pw7swEWjujKqRwreHIkiIiLRKapqDCB08z4Lb56Bd4FlwBHAWLwmREc753aF7e8AnHNW5jyvA93w+hXsAXoDpwPxwLXOuedqGadqDER8b83fxK/e+I4iv0NBm2YJPHHJcI7s2SbgyKonK6+QT7/fznuLtjBjZRqFxT/+f7Nnu2ZcPKorEw/vQnKi5k0QEZGDJ1I1BlGXGACYWRfgD8DJQBu8JkTvAPc553aX2beixOAKvI7H/YEWeB2NpwMPOue+i0CMSgxE8JKC219bFCp3a5PEi9ccEXjToZrak5XPh0u28to3G/frJ1GieZM4Ljy8C1cd04NOrZoGEKGIiDQ2jToxiAZKDETg4yXbuPGl+aGagv4dWvD81aMqHHEo2izZnM7Lczfw7sIt7Msr3G9bbIxx6qBD+NmxPRnUuaKB1ERERGpPiUE9p8RAGrtZa3Zy5eRvyC/y2ub379CCV352JK2SGl5n3ay8Qt5btIVnv1rH6h37frS9Z9tmXH1MDyaO7EJCXEwAEYqISEMWqcRAf6FEJOLWpu3j+hfnh5KCHm2b8fw1oxpkUgDQrEkcF43qypRbj+PfVx7O0b327zuxdmcWv39nCWP/Pp1X5m6goOjHE66JiIgETYmBiERUenYB1/7nW9JzCgBIbdGEF689gtQWDaP5UGViYoyx/VN56adH8v5Nx3DGkI6ED1S0eW8Ov3lrMeMf+oI35m0KNbESERGpD5QYiEjEFBYVc8NL81i70xsxuElcDM9cMbJRdsId2Kklky4axoK7T+SuU/qTEjbfwYbd2fzy9UX8ZNKXfLkqLcAoRURESikxEJGIefSzVcxcHRotmIcmDmFw51YBRhS8VkkJ/HxML768cyx3ntyPVkmlQ5ku35bJZc/O5cp/z2Xl9swAoxQREVFiICIR8uWqNJ6YvjpUvnl8H04b3DHAiOqXZk3iuOH43nx551huGd+HpvGxoW3TV6Rx8qMz+O3bi9mTlV/JWUREROqOEgMRqbUdGbnc+spCSgY5G927DbeM7xNsUPVUi8R4bjuxL9N/dTwTR3YO9UEodvDSnA2Me2g6r36zgWL1PxARkYNMiYGI1IpzjttfW8Qu/0l32+ZNePSCYcTGWBVHNm7tkxN58LwhfHDTsRzTu21o/Z7sAn795mLO+9csvt+SEWCEIiLS2CgxEJFaeXHOBr5avRMAM5h04VDatWgScFTR49COybxwzSievnz/TtrzN+zltMe/5L7/Lf3R5GkiIiJ1QYmBiNTYhl3Z3P/hslD5Z8f25Oiwp99SPWbGiYe257Pbx3Dj2F7Ex3q1LcUO/j1zPSc9MoMZKzV6kYiI1C0lBiJSI8XFjl++sYjs/CIA+qQ257YT+wYcVXRrmhDLr07qz0e3HMfo3qWTpG3em8Plk+fy6ze+IyO3IMAIRUSkIVNiICI18uKcH5i7bjcAsTHGQxOHkBg20o7UXO/U5rx4zRE8esFQWocNb/rqtxuZ8PAMpi3fEWB0IiLSUCkxEJEDtiMjl799vCJUvn5Mr0Y/X0GkmRlnDevElNvGcMrADqH12zJyueq5b/jl64vU90BERCJKiYGIHLA/fbCMTP+mtGfbZtw0vnfAETVc7Vo04Z+XjuAflwynTdjsyW/M28Spj33J/A17AoxOREQaEiUGInJAvlq1k/cWbQmV/3jWQJrEqQlRXTt10CF8evsYTh9SOmncht3ZnP+vr5k0dRWFRcUBRiciIg2BEgMRqbYNu7K59Nk5ofIZQzoyWqMQHTQpzRJ4/KJhPHrBUFo0iQOgqNjx8KcrufCp2WzcnR1whCIiEs2UGIhItRQUFXPlv+eGyi2axPH70wYEGFHjddawTnx4y7GM7NY6tO7bH/Zw6qQv+XjJtgAjExGRaKbEQESq5cXZP7B2Z1aofOcp/UltkRhgRI1bl5QkXvnZkdxxYt/QLNOZuYVc9+I8/vT+9xSoaZGIiBwgJQYiUqX0nAImTV0VKo/p245Lj+gaYEQCEBcbw03j+/DGdUftN2vyM1+t44Inv2bL3pwAoxMRkWijxEBEqvTP6WvYk+1NrNUlpSlPXT4CMws4KikxrGtrPrj5GMb3Tw2tm79hLz+Z9CXTV2jOAxERqR4lBiJSqc17c5g8c12o/KuT+msUonqoVVICT18+krtO6R9qWrQnu4Ar//0Nk6auorjYBRyhiIjUd0oMRKRSD01ZQX6h1159SOeWnDbokIAjkorExBg/H9OLl396JO2Tm4TWP/zpSm58aT5ZmhBNREQqocRARCq0dEs6by/YHCrfdeoAYmLUhKi+G9UjhQ9uPpajerYJrftoyTbO/ecsNuzSkKYiIlI+JQYiUqG/f7IC57dAOWFAKkeG3WhK/da2eROev2YUVx7dPbRu+bZMznjiK2au3hlcYCIiUm8pMRCRci3YsIdpK9IAMIM7T+4fcERyoOJjY7j3jMN48LzBJMR6/93vzS7g8slzmfzVOpxTvwMRESmlxEBEyvXIZ6XDk54xpCN927cIMBqpjYkju/DKz48ktYXX76Co2PGH97/n7neXUKj5DkRExKfEQER+ZN4Pu5mx0qstiDG4eXyfgCOS2hretTX/u+kYhnVtFVr34uwNXPv8t+xTp2QREUGJgYiU45FPS2sLzhraiV7tmgcYjURK++REXv7pkZw+pGNo3fQVaZz3z1lsTddkaCIijZ0SAxHZzzfrd/OV3zk1Nsa4SbUFDUpifCyPXTCUX4ztHVq3fFsmZz0xkyWb0wOMTEREgqbEQET288inK0Pvzx7WiR5tmwUYjdSFmBjjlyf148HzBhPnDz+7PSOPiU9+zbTlmilZRKSxUmIgIiHzftjDrDW7AL+2YFzvKo6QaDZxZBeev3oULRLjAMjOL+La57/lzXmbAo5MRESCoMRAREL+9cWa0Pszh3akWxvVFjR0R/duy1vXH03n1k0Bb8SiO15fxFMz1lRxpIiINDRKDEQEgFXbM/n0++2h8vVjegUYjRxMfdq34K3rj6Z/h9Ihaf/y4XLu/3CZ5joQEWlElBiICAD/+mJt6P0JA9rTR/MWNCqpyYm8+vOjGNUjJbTuyRlr+eXr31GguQ5ERBoFJQYiwpa9Oby7cHOofP3xqi1ojFo2jef5q0cx4dD2oXVvzt/Ez1+YR05+UYCRiYjIwaDEQER45st1FBZ7TUZG9UhhRLfWAUckQUmMj+UflwznwsO7hNZ9vnwHl0+eQ2ZuQYCRiYhIXVNiINLI7cnK5+W5G0Jl9S2QuNgY7j9n0H5zHXyzfg+XPjOHvdn5AUYmIiJ1SYmBSCP34uwfyCnwmon079CC4/u1CzgiqQ/MvLkO7j7t0NC6RZvSuejpOezclxdgZCIiUleUGIg0YvmFxbww+4dQ+WfH9cTMAoxI6ptrjunBX84eRMnXYtnWDC58ajbbM3KDDUxERCJOiYFII/bRkq3syPSe/rZr0YTTBncMOCKpjy4+oit/P28I/iTJrN6xj4lPfs2mPdnBBiYiIhGlxECkkXLOMfmrdaHyZUd2IyFO/yVI+c4d0ZnHLxpOnJ8d/LArm4n/+pr1O7MCjkxERCJFdwEijdT8DXtZtCkdgITYGC4+omvAEUl995PBh/CvS0eQEOv96diSnsuFT81WciAi0kAoMRBppP49s7S24MyhHWnbvEmA0Ui0OOHQ9jx75UgS470/H9sycrno6dn8sEvJgYhItFNiINIIbdmbw0dLtoXKV43uEWA0Em2O7dOOyVceHkoOtqbnctFTs9m4W30ORESimRIDkUbohdk/UORPaHZEjxQO7ZgccEQSbY7u1ZZnrzicJnH7NytSciAiEr2UGIg0MrkFRftNaHb1MaotkJoZ3bstz1wxMtRpffPeHC56erZGKxIRiVJKDEQamf8t2sLe7AIAOrduygkD2gcckUSzY/u04+nLS5ODTXu85GDL3pyAIxMRkQOlxECkkfnvnNLagsuO7EZsjCY0k9oZ07cdT15WOlrRxt05mgRNRCQKKTEQaUSWbE5n4ca9gDdE6XkjOgcckTQUY/ul8q/LhhMf6yWaG3Znc+kzc9idlR9wZCIiUl1KDEQakfDaglMGdaCNhiiVCBrXvz3/vGREaBK0VTv2ccXkuWTkFgQcmYiIVIcSA5FGIjO3gHcXbg6VLzmiW4DRSEN1wqHtefiCoZjfQm3x5nSufe5bcvKLgg1MRESqFJWJgZl1NrPJZrbFzPLMbL2ZPWpmrQ/wPMeY2bv+8blmtsHMPjSzk+sqdpGgvLNwC9n+zVnf9s05vPsB/bqIVNsZQzryl7MHhcpz1+/m5y/OI69QyYGISH0WdYmBmfUC5gFXAXOBR4C1wC3A12bWpprnuR74EhjvLx8BvgDGAB+Z2e8iH71IMJxz/Hf2D6HyJUd0w0ydjqXuXDSqK7//yYBQecbKNG59ZSGFRcUBRiUiIpWJusQA+AeQCtzsnDvLOfcb59w4vBv7fsCfqzqBmcUD9wO5wAjn3GXOubucc5cBI4E84HdmpgbY0iDM37CH5dsyAWgaH8vZwzsFHJE0Btce25Obx/cJlT9aso3fvLWYYn9yPRERqV+iKjEws57ABGA98ESZzfcAWcBlZtasilOlAC2Blc65FeEbnHPLgJVAU6B5BMIWCdx/Z5d2Oj5jSEeSE+MDjEYak9tO6MPVo0sn0Xtj3ib+9MEynFNyICJS38QFHcABGucvpzjn9quPds5lmtlMvMThSGBqJefZAaQBfc2sj3NuVckGM+sL9AEWOud2VRWQmc2rYFP/qo4VORjSswt4f/HWUPmSI7sGGI00NmbG3acNYF9eAa99uwmAyTPXkZrchOvG9Ao4OhERCRdVNQZ4TYXAe6JfnpIb/L6VncR5j6puxPv888zsP2Z2v5k9j9d/YSlwfgTiFQnce4s2k1/o5dGHdUxmcOdWAUckjY2Zcf85gzllYIfQugc+Ws6b8zYFGJWIiJQVbTUGLf1legXbS9ZXeefjnHvdzLYALwOXh23aDvwbr0NzlZxzI8pb79ckDK/OOUTqUslTWoALDu8SYCTSmMXGGI9cMJTdWXOZs243AHe++R0pzRIY2z814OhERASir8agKiXDrFTZeNXMLgU+wxuRaACQ5C+nAv8PeKWOYhQ5aJZtzWDxZi9fToiL4YwhHQOOSBqzxPhYnr5iJP07tACgqNhxw3/ns2DDnoAjExERiL7EoKRGoGUF25PL7Fcuvx/BZLwmQ5c555Y753Kcc8uBy/CaE51vZsfXPmSR4LweVltw0mEdaJWUEGA0IpCcGM9/rh5Fp1ZNAcgpKOLq575hTdq+gCMTEZFoSwxKRhCqqA9Bybh4FfVBKDEBiAe+KKcTczEwwy+W20xIJBrkFxbz9oLSxGDiyM4BRiNSqn1yIs9fM4rWSd7oWHuyC7j82blsz8gNODIRkcYt2hKDaf5ygpntF7uZtQBGAznA7CrOUzI/QbsKtpesz69JkCL1wdRl29mTXQBAx5aJHN2rbcARiZTq1a45k688nKbxsQBs3pvDFZPnkp5TEHBkIiKNV1QlBs65NcAUoDveqELh7gOaAc8757JKVppZfzMrO3Tol/7yPDMbHL7BzIYC5+H1U/g8ctGLHFyvfbsx9P68EZ2JjdFMx1K/DOvamn9cOpw4/7u5fFsm170wLzSKloiIHFxRlRj4bsCbh2CSmb3jDzP6OXAbXhOi35XZf5n/CnHOzcUbeagp8I2ZvWJmfzWzV4E5QCLwmHNuaR1/FpE6sS09ly9WpoXK543QaERSP43tl8pfzy19PvP12l2c9OgM0jLzAoxKRKRxirrEwK81GAk8BxwB3AH0AiYBR1VnUjLfNcBVwNfASf55TgS+Ai5yzt0W2chFDp4352+i2B+b66iebejaJinYgEQqce6IzvzqpH6h8rqdWVzyzGwyctWsSETkYIq2eQwAcM5txLupr86+5baf8Cc5e85/iTQYzjleD2tGNPFwdTqW+u+G43uxeW8OL83ZAMDK7fu48b/zmXzl4cTHRt0zLBGRqKT/bUUamPl8Eq4eAAAgAElEQVQb9rB+VzYALZrEcfJhhwQckUjVzIw/nTmQK47qFlr35aqd/N+7S/Ge44iISF1TYiDSwLy9YHPo/U8GH0LThNgAoxGpvpgY474zB3LrCX1C616eu4Gnv6zWRPQiIlJLSgxEGpD8wmLe/25rqHz2sE4BRiNSM7eM77Pfd/f+j5bz8ZJtAUYkItI4KDEQaUCmr9jBXn/ugk6tmnJ495SAIxI5cGbGA+cOYpT//XUObn11AYs27g04MhGRhk2JgUgD8s7C0mZEZw7tSIzmLpAo1SQulicvG0F3f0St3IJirvnPt2zakx1wZCIiDZcSA5EGIj2ngM+W7QiV1YxIol3rZglMvvJwWiXFA7BzXx7XPPethjEVEakjSgxEGoiPFm8NzRg7sFMyfdq3CDgikdrr2a45T146gvhYr/ZrxfZMbnppAUXFGqlIRCTSlBiINBDhoxGdNVS1BdJwHNGzDQ+cUzo78hcr07j/w2WVHCEiIjWhxECkAdi0J5s563YDEGNwxtCOAUckElnnjujML8b2DpWf+WrdfhP5iYhI7SkxEGkA3l24JfT+mD7tSG2RGGA0InXj9hP7MuHQ9qHy795ewrwfdgcYkYhIw6LEQCTKOef2a0Z09jDVFkjDFBNjPHLBUPp38PrP5BcV8/MX5rF5b07AkYmINAxKDESi3NItGazesQ+ApIRYTjqsQ8ARidSdZk3iePrykaQ0SwBg5758fvb8t2TnFwYcmYhI9FNiIBLlwmsLTjqsA0kJcQFGI1L3uqQk8c9LhhPnz9OxdEsGv3r9O5zTSEUiIrWhxEAkihUXOz74bmuofKY6HUsjcUTPNvzhzIGh8geLtzJp6uoAIxIRiX5KDESi2Lc/7GFbRi4AKc0SOKZ324AjEjl4Lj6iK1cc1S1UfuSzlXy0eGslR4iISGWUGIhEsf8tKh2N6JSBHYiL1a+0NC53n3Yoo3u3CZVvf20R32/JCDAiEZHopbsIkShVWFTMR0tKn46eNljNiKTxiYuN4YmLh9OtTRIAOQVF/PzFb9mbnR9wZCIi0UeJgUiUmr12Nzv3eTc/qS2aMKpHSsARiQSjVVICz1w+kmYJsQBs3J3Dza8spKhYnZFFRA6EEgORKBXejOjUQYcQ64/QItIY9WnfgocmDg2VZ6xM4+FPVwQYkYhI9FFiIBKF8guL+XjptlD59CFqRiRy8sAO3Di2V6j8xLQ1fLxEnZFFRKpLiYFIFPpqdRrpOQUAdGrVlOFdWwUckUj9cPuJ/RjTt12ofMdri1i1PTPAiEREoocSA5Eo9P6i8E7Hh2CmZkQiALExxqQLh9E1xeuMnJVfxM9emEdGbkHAkYmI1H9KDESiTG5BEVO+3x4qqxmRyP5aJsXz5GUjaBrvdUZetzOL219dSLE6I4uIVEqJgUiUmb4ijX15hQB0b5PEYR2TA45IpP4ZcEgyfz1vcKj82bIdTPp8VYARiYjUf0oMRKLM/74rHY3o9CEd1YxIpAJnDOnIT4/tESo/+tkqpi7bXskRIiKNmxIDkSiSnV/I58t2hMqa1Eykcr8+uT9H9yqdGfnWVxaybmdWgBGJiNRfSgxEoshny3aQU1AEQN/2zenXoUXAEYnUb3GxMTx+0TA6tWoKQGZeIde/OI+c/KKAIxMRqX+UGIhEkQ+/Cx+NSLUFItXRpnkT/nnpcBJivT95y7dl8n/vLgk4KhGR+keJgUiUyM4vZPrK0mZEpw46JMBoRKLL4M6tuOeMQ0Pl1+dt4tVvNgQYkYhI/aPEQCRKTF+RRm5BMeA1I+qd2jzgiESiy8WjunLOsE6h8t3vLmXplvQAIxIRqV+UGIhEiY+WbAu9P3mgagtEDpSZ8aezB9K3vZdU5xcWc/2L80OziIuINHZKDESiQG5BEZ+HDbN46qAOAUYjEr2SEuL456UjaJbgTX62YXc2v3x9Ec5p8jMRESUGIlHgy1U7yfJHUenRthn92ms0IpGa6tWuOQ+eNyRU/vT77Tw1Y22AEYmI1A9KDESiwEeLS0cjOnlgB01qJlJLPxl8CFeN7h4qP/jJCuas3RVcQCIi9YASA5F6Lr+wmE/DmxGpf4FIRNx1ygCGd20FQFGx4xcvL2BHZm7AUYmIBEeJgUg9N3PNTjJzCwHo3LopAzslBxyRSMOQEBfDE5cMJ6VZAgBpmXnc9NICCouKA45MRCQYSgxE6rmPF5eORnSKmhGJRNQhLZvy2IVDKfm1mrNuN3+fsjLYoEREAqLEQKQeKywqZsr3GqZUpC4d26cdt47vGyr/64s1TFu+o5IjREQaJiUGIvXYnHW72ZPtjbHeITmRYV1aBRyRSMN007jeHNe3Xah8+2sL2ZqeE2BEIiIHnxIDkXrswzKjEcXEqBmRSF2IiTEemTiE9slNANiTXcAtLy9UfwMRaVSUGIjUU0XFjk+Wlo5GdMpATWomUpfaNG/CYxcOoyT/nrt+N49NXRVsUCIiB5ESA5F66tv1u9m5Lw+Ats0TGNk9JeCIRBq+I3u24dYTSvsb/L9pq/lq1c4AIxIROXiUGIjUUx8tKe10POGwDsSqGZHIQXHj2N6M7t0GAOfg1lc1v4GINA5KDETqIeccnywtTQw0qZnIwRMbYzxywVDaNvf6G+zcl8+tryykqNgFHJmISN1SYiBSDy3ZnMHWdO8JZcum8RzRU82IRA6m1BaJ+81vMGvNLp6YtjrYoERE6pgSA5F6KHzugvH9U4mP1a+qyME2undbbhrbO1R+9LOVzF67K8CIRETqlu42ROqhKWGjEU04rH2AkYg0bjeP78OoHl6NXbGDm19ewC5/UAARkYZGiYFIPbN+ZxYrtmcC0CQuZr9Jl0Tk4IqLjWHShcNIaZYAwI7MPG57bRHF6m8gIg2QEgOReubT70trC47t05akhLgAoxGRDi0TeXjikFB5xso0/jVjTYARiYjUDSUGIvVMeP+CCYdqUjOR+uD4fqlcN6ZXqPzQlJXM37AnwIhERCIvKhMDM+tsZpPNbIuZ5ZnZejN71MxaV/P4483MVePVpa4/i0i4nfvy+PYH72YjxmD8gNSAIxKREndM6MuIbt6fmaJix80vLyAjtyDgqEREIifq2iiYWS9gFpAKvAssB0YBtwAnm9lo51xVw0asB+6rYNsg4BxgqXNuY0SCFqmmqcu24/ymyyO7pdDGH0ddRIIXHxvDYxcO5ZTHviQzt5BNe3L4/dtL/GFNNQGhiES/qEsMgH/gJQU3O+ceL1lpZg8DtwF/Bq6r7ATOufXAveVtM7OX/bdPRSBWkQOi0YhE6rfOrZN44JzB3PjSfADeW7SF4/q247wRnQOOTESk9qKqKZGZ9QQm4D3xf6LM5nuALOAyM2tWw/O3Ac4GcoAXah6pyIHLyivky9U7Q+UTD1ViIFIf/WTwIVwwsrSl6f+9u4S1afsCjEhEJDIimhiY2WAze8DM3jWzz8LWdzezidXtA1CJcf5yinOuOHyDcy4TmAkkAUfW8PxXAk2A151z6lUmB9WMlWnkF3pf6/4dWtCtTY3yWxE5CO4541B6tvN+R7Pzi7jllYWh318RkWgVscTAzP4AzAfuBE4Hxpa5zsvApbW8TD9/ubKC7av8Zd8anv9af/lkdQ8ws3nlvYD+NYxBGqkpYcOUTlBtgUi9lpQQx+MXDSPBn5V88eZ0/j5lRcBRiYjUTkQSAzO7EPg98CkwFLg/fLtzbi3wLXBGLS/V0l+mV7C9ZH2rAz2xmY3Bu5lf6pybVYPYRGqsoKiYqcvC+xdomFKR+u6wji359Smlz4CemrGWL1amBRiRiEjtRKrG4GZgNXCmc+47IL+cfZYBfSJ0vYqUDAtRkykpf+Yvq11bAOCcG1HeC2+0JJFqmbtuNxm5hQB0bJnIYR2TA45IRKrj6tHdGduvdHbyO15bxM59eQFGJCJSc5FKDAYBnzjnyksISmwBats+oqRGoGUF25PL7FctZpYCnIs6HUtApiwNm9TssA4a+lAkSpgZfzt/CG39oYV37svjjtcWUVxck+dTIiLBilRiYEBVva7aA7m1vE5JA86K+hCU1EhU1AehIlfgdTp+zTm3tyaBidSUc079C0SiWNvmTXh44pBQ+YuVaUyeuS7AiEREaiZSicEq4OiKNppZLHAMsLSW15nmLyeY2X6xm1kLYDTeU//ZB3jen/pLzV0gB92SzRlsTfdy5pZN4zm8R0rAEYnIgTqubzt+flzPUPmvHy9nyeYDqrwWEQlcpBKD14DhZnZHBdvvAnoDL9XmIs65NcAUoDtwY5nN9wHNgOedc1klK82sv5lVOEKQmR0LDACWqNOxBGHK96XNiMb3TyU+NqqmFxER3x0T+jG4s9fStaDIcfPLC8jKKww4KhGR6ovUHcijwCLgQTObA5wCYGZ/98v34T3Fj8QT+RuAHcAkM3vHzO43s8/xZj1eCfyuzP7L/FdFSjodq7ZAAqHZjkUahoS4GB67cBhJCbEArN2ZxX3/q21FuYjIwRORxMA5l4M3b8ELwHBgFF6/g9uBEcCLwMnOuVo/OvFrDUYCzwFHAHcAvYBJwFHOuV3VPZc/4dp5qNOxBGTTnmxWbM8EvJuKY/u0q+IIEanPerRtxh/PHBgqv/btJj74bmuAEYmIVF9cpE7knEsHrjSz24HDgTZ4owPNdc5FdGBn59xG4Kpq7lvh8C7+7MZNIxWXyIGatnxH6P1RPdvQrEnEfiVFJCDnDO/EjFVpvLtwCwC/fXsxw7u14pCW+nMjIvVbxBszO+d2O+c+cc695Jz7INJJgUhDMjUsMRg/IDXASEQkUsyMP541kE6tvEQgPaeAX76uIUxFpP6L1MzHRWZ2dxX7/M7M1AtLxJedX8isNaUt38b2U2Ig0lAkJ8bzyAVDKZmSZObqXTz7lYYwFZH6LZLzGFRnRibN2iTim7l6F/mF3vQf/dq3oEtKUsARiUgkjeqRwvVjeoXKf/tkBd9vyQgwIhGRyh3McRFbU/sJzkQajM+Xl45GNE7NiEQapFtP6MugTt4QpvlFxdz66gJyC4oCjkpEpHw17uloZseVWdW9nHUAsUBX4BJKZy4WadScc3we1r9gXH8lBiINUUJcDI9eOJTTJn1FTkERK7fv44GPlnPvGYcFHZqIyI/UZgiU6UBJTyoHXOG/ymNAMd7QoiKN3tItGWzPyAOgVVI8w7q0CjgiEakrvdo15/enDeB3by8B4LlZ6xnbP5UxfTU8sYjUL7VJDP6AlxAY8H94icIX5exXBOwCpjnnltfieiINRnhtwfF92xGn2Y5FGrSLR3Vl2vI0PlvmNSH85euL+PiWY2nTvEnAkYmIlKpxYuCcu7fkvZldAbzjnJsUiaBEGrrwYUrHDdBsxyINnZnx13MHcdKje9m5L4+0zDx+89ZinrpsBGYal0NE6odIzXzcQ0mBSPWkZeaxaONeAGJjjDGa7VikUWjTvAl/O29wqPzp99t59ZuNAUYkIrI/tV8QOcimrSitLRjZrTUtk+IDjEZEDqax/VO5/KhuofJ9//uedTuzAoxIRKRUbfoY7Me8utDzgJOATkB5DSedc258pK4pEo0+X6bRiEQas9+eOoBZa3axesc+cgqKuPWVBbxx/dHEq6+RiAQsIomBmTUBPgSOx+uMXNIpuYQLWy/SaOUXFvPlqrRQebzmLxBpdBLjY3nswqGc9cRMCoocizalM2nqKu6Y0C/o0ESkkYvU44lfA2OBPwHt8JKAe4GOwMXARuAVICFC1xOJSnPX7SYr35vcqGtKEr3aNQ84IhEJwmEdW/LLsETgiWmr+Wb97gAjEhGJXGJwPjDfOXePc25XyUrn3Dbn3CvAOOA04NYIXU8kKk0Nn+24f6pGIxFpxK49tidH9kwBoNjBba8uJCO3IOCoRKQxi1Ri0AuYGVZ2QKhHpXNuLfABcGWEricSdZxzTA3rX6BmRCKNW2yM8fDEoSQneq16N+3J4d53lwYclYg0ZpFKDAqA3LByJl6TonA/AD0jdD2RqLMmLYsNu7MBaJYQy6geKQFHJCJB69iqKX8+e1Co/NaCzXy0eGuAEYlIYxapxGAT3khEJVYCR5XZZxigBpTSaH0e1ozo2D7taBIXG2A0IlJfnD6kI2cPK/0T+tu3F7MjI7eSI0RE6kakEoOZwNFh5XeAQWb2rJn9xMz+BpwATI/Q9USizlQNUyoiFbj3jMPo2DIRgD3ZBdz55nc4p4H8ROTgilRi8BKwwsy6++VHgW+Aq4D3gDuANcBvInQ9kaiSnlPAtz/sCZWP76/ZjkWkVMum8fz9/CGh8vQVabw0d0OAEYlIYxSRxMA5N905d4pzbr1fzgZG441W9FvgImCoc25zJK4nEm1mrEyjqNh7+jekc0tSWyQGHJGI1DdH927L1aN7hMp/en8Z6zUrsogcRHU2zaJzrtA596Zz7q/OuVf9ZEGkUfp8eXgzovYBRiIi9dmdJ/ejd6o3v0lOQRG3vbaQwqLigKMSkcbioM2/bmZxZnbjwbqeSH1RVOyYtkLDlIpI1RLjY3n0gqHExXhznCzYsJd/fbEm4KhEpLGo88TAPFfgjVQ0qa6vJ1LfLNiwh73Z3qRF7ZObcFjH5IAjEpH6bGCnltx6Qp9Q+dHPVrFkc3qAEYlIY1GrxMDMWpvZ3Wb2npm9aWa3mlli2PbTgKXAZKAb8HbtwhWJPlPDmhGN7afZjkWkateN6cWwrq0AKCx23PrqQnILigKOSkQauhonBmbWFpgH3AucBpwNPAR8aGaxZvY08C7QH2/W4xHOufNqHbFIlJm2XMOUisiBiYuN4ZGJQ2ka7813snrHPh78eEXAUYlIQ1ebGoPfAN2B74A7gV/j1Q6MwUsErgHmAkc6585wzi2sXagi0WfTnmyWb8sEICEuhtG92wYckYhEi+5tm/H70waEypNnrmPW6p0BRiQiDV1tEoNTgB+AI5xzf3fO/Q04Am8W5BOBV4CjnXNzax+mSHQKry04qmcbmjWJCzAaEYk2F4/qyth+pfOe/PL1RaTnFAQYkYg0ZLVJDLoDHzrn8ktWOOdygPf94t1O0zZKIxfev0CjEYnIgTIz/nruYFonxQOwJT2Xe99bGnBUItJQ1SYxaApsL2d9yZ3Q2lqcWyTqZecXMmvNrlB5bD8lBiJy4FKTE/nL2YNC5bcXbObDxVsDjEhEGqq6nOBMtQXSqM1cvYv8Qm9ior7tm9MlJSngiEQkWp0y6BDOGdYpVP7t24vZkZEbYEQi0hDVtsHzUDO7vOw6ADO7DPjRuIzOuedreU2RqKDZjkUkku498zDmrNvN5r057M0u4M43v+PfVx6uIZBFJGJqmxic6b/KMuC5Co5RYiANnnOOz5eXtrRT/wIRqa3kxHj+dv5gLn56DgDTV6Tx3zkbuPTIbgFHJiINRW0Sg/9ELAqRBmbplgy2Z+QB0CopnmFdWgUckYg0BEf3ass1x/Tg2a/WAfDnD5YxundberRtFnBkItIQ1DgxcM5dFclARBqS8GZEx/dtR1xsnXXnEZFG5lcn9WPGyjRW7dhHTkERJzz8BV//ZhypyYlBhyYiUU53KyJ1IHyY0nED1L9ARCInMT6WRy4YSnys17egqNhx0dOzyS0oCjgyEYl2SgxEIiwtM49FG/cCEBtjjOnTroojREQOzMBOLbn1hL6h8pq0LB6asiLAiESkIVBiIBJh01aU1haM6Naalv7ERCIikXTD8b04+bAOofIzX61j9tpdlRwhIlI5JQYiETYtfLbj/hqNSETqhpnxz0uHM6avVyvpHNzx2iIycwsCjkxEopUSA5EIyi8sZsbKtFBZw5SKSF0yMx48bzAtm3o1k5v35vCH/30fcFQiEq2UGIhE0Nx1u8nK9zoAdk1Jole75gFHJCINXfvkRP501sBQ+fV5m5iydFuAEYlItFJiIBJBU8MmNRvXP1UzkorIQXH6kI6cPqRjqHzXW4vZuS8vwIhEJBopMRCJEOccU5eF9S9QMyIROYj+eOZhtE9uAsCurHx++9ZinHMBRyUi0SQiiYGZda3Gq7OZJUfieiL10Zq0LDbszgYgKSGWUT1SAo5IRBqTVkkJPHjekFB5yvfbeXP+5gAjEpFoE6kag/XAuipePwB7zGyLmT1uZm0jdG2ReiF8NKJj+7SlSVxsgNGISGM0pm87LjuyW6h873tL2bQnO8CIRCSaRCoxeB6YARiQDnwBvOYv0/31XwAfAvnAjcA3ZqaZn6TBCO9fML6/ZjsWkWDcdWp/urdJAmBfXiG/fH0RxcVqUiQiVYtUYnA/MAR4AOjinBvnnLvIOTcO6AI86G+/A+gJ3Ad0A+6K0PVFApWeU8A36/eEysf3V84rIsFISojj4QuGEuOPfTB77W7+PWt9oDGJSHSIVGLwALDIOfdb51xW+AbnXJZz7jfAd8ADzrli59x9wELg9AhdXyRQM1amUeQ/kRvSuSWpLRIDjkhEGrPhXVtzw/G9Q+W/frycVdszA4xIRKJBpBKD44BZVewzCxgTVp4NdI7Q9UUC9XlY/4JxakYkIvXAzeP7cFhHb8yP/MJibnttIQVFxQFHJSL1WaQSgyZAhyr2OcTfr8Q+oDBC1xcJTFGxY9oKDVMqIvVLQlwMj1wwlIQ470/9ks0ZPD51VcBRiUh9FqnEYBFwgZkNLG+jmQ0GJuI1HyrRHUiL0PVFArNgwx72ZhcAkNqiSegJnYhI0Pq2b8GvJvQLlZ+YvoYFG/ZUcoSINGaRSgz+ACTijTT0tJldaWan+MtngDn+9j8CmFlTYAIwM0LXFwnM/s2INNuxiNQvVx/TIzSvSlGx447XFpGTXxRwVCJSH0UkMXDOfQJcAuQC1wDPAu/7y6v99Zf5+wEkABcAd9fkev5kaZP9ORHyzGy9mT1qZq1rcK5BZva8mW30z7XDzL4ws8trEps0PmUTAxGR+iQ2xnjo/CE0S/DmVlm7M4sHPloWcFQiUh9FqsYA59yreEOTXgY8AkwGHgUuB7o6514O2zfdOfeJc279gV7HzHoB84CrgLn+tdYCtwBfm1mbAzjXlcAC4CzgS+Ah4A28eRdOPdDYpPHZtCeb5du8kT4S4mIY3Vvz9olI/dMlJYl7Tj8sVP7P1z/w5Sq15hWR/cVF8mTOuX3Af/1XXfkHkArc7Jx7vGSlmT0M3Ab8GbiuqpOY2ZHAM8AS4GTn3LYy2+MjGbQ0TOGzHR/Vsw3NmkT0V0pEJGLOH9mZKd9v57Nl3mSMv3r9Oz659ThaJunPnYh4IlZjcDCYWU+8vgnrgSfKbL4HyAIuM7Nm1Tjdg0AscGnZpADAOVdQu2ilMZi6XKMRiUh0MDPuP2cQKc0SANiWkcs97y0JOCoRqU8i+njTzEYCo4DWeDfdZTnn3B9rcYlx/nKKc26/wZidc5lmNhMvcTgSmFpJnJ2BY4FvgaVmNhYYATi8kZOmlT2/SFnZ+YXMWrMrVB7bT4mBiNRv7Vo04S9nD+K6F+cB8M7CLZx4aAd+MviQgCMTkfogIomBmSUDbwFj8drnV8Thj0xUQyVjrq2sYPsqvMSgL5UkBsDhYft/DhxfZvtiMzvHObe6qoDMbF4Fm/pXdaxEt1mrd5Ff6OWPfds3p0tKUsARiYhU7eSBHTh3eGfenL8JgN+9s5jDu7cmNVkztos0dpFqSvQ3vKf5X+GNQnQiXpJQ9jWuohNUU0t/mV7B9pL1rao4T8mj3YnAAOAc/9y9gReAQcAHZpZQ81CloZuq2Y5FJErdc8ahdGrVFIC92QX8+s3vcM4FHJWIBC1STYnOBOYDYwNuglNSW1HV/26xYctrnXPv++UMM7sCL1kYCZwLvFzO8SHOuRHlBuLVJAyvTtASfZxzfL58e6is/gUiEk2SE+P52/mDufjpOQBMW5HGy3M3cvERXQOOTESCFKkag5YcnHb5JTUCLSvYnlxmv4qUTPuYB3wYvsF5j0ze9YujDjRAaRyWbslge0YeAK2S4hnWpapKKhGR+uXoXm25enSPUPlPH3zPD7uyAoxIRIIWqcRgFXAw2lKs8Jd9K9jex19W1Aeh7HkyK0hmShKHpgcQmzQi4ZOaHd+3HXGxUTXAl4gIAHee3I/eqc0ByM4v4o7XFlFUrCZFIo1VpO5mngBON7NOETpfRab5ywlmtl/sZtYCGA3kALOrOM93wE6grZmVl9AM9Jfrax6qNGT79S8YoP4FIhKdEuNjeWTiUOJivJa43/6wh6dmrA04KhEJSqQSg4+AKcBMM7vKzAabWdfyXrW5iHNujX+d7sCNZTbfBzQDnnfOhepCzay/me03QpBzrhB40i8+GJ5kmNkg4EqgEG8WZJH9pGXm8d2mvQDExhhj+rQLOCIRkZob1LklN43rEyo//OkKlm3NCDAiEQlKpDofr8fr8Gt4swlXxEXgmjcAs4BJZjYeWAYcgTfq0Urgd2X2X+Yvyw6j+hdgPHA5MMjMpgPt8DocJwJ3VGe4Uml8pq/YQcngHSO6tdasoSIS9W4c24vPV+xg0ca9FBQ5bnt1Ie/+YjRN4sqbkkhEGqpIJQbPU/VIQBHhnFvjT6T2B+Bk4FRgKzAJuM85t7ua58n2E4s7gQvxaiBy8ZKOh5xzH9VF/BL9wvsXjO+v0YhEJPrFxcbw8MQhnPrYl+QVFrN8WyaPfLqK35yiKXlEGpOIJAbOuSsjcZ4DuN5G4Kpq7lvhhGvOuWzgXv8lUqX8wmJmrEwLlTVMqYg0FL3aNeeuU/pz7/++B+DJGWsYPyCVw7unBByZiBwsGkpF5ADMXbebrPwiALqmJNGrXfOAIxIRiZzLj+rOMb3bAuAc3P7aQvblFQYclYgcLEoMRA7A1LBJzcb1T8WswgopEZGoExNjPHje4P/f3n2Hx1FdfRz/HlVb7r3j3m1woxkwxgbTWzAQCDVAAiRAgBSSEFoCJARCSYAXktB7rw7VmGIDNu699ybLRZZkSVa57x8zWvtaZy4AACAASURBVK1lyWorze7q93mefcbTz1zPrvbs3EKzRl6FgvU7crn7w8WV7CUi8aJGVYnM7Cm8NgV/cM5t9eerwjnnrqjJOUWC5o12HNZNqdoXiEgc6tyyMX8+cwi/enUOAC9PX8cJg9ozboC6ZhaJdzVtY3AZXmLwN2CrP18VDlBiIDFpVUYOa7fvASAtJZHDe6nerYjEpzOHdeaTRVuYNH8LAL99Yz6f3NiK1k1SAo5MROpSTRODkjHUN5aZF4lbkxeXPi04pm9bdeMnInHLzPjLWUOZvnonGdn5ZGTnc+s783n0whGqQikSx2rUxsA5t9Z/FZaZr/QV2fBF6k94+4LxeqQuInGudZMU7ps4NDQ/af4W3p2zKcCIRKSuqfGxSBVk5hYwY83O0PzYARrtWETi37gBHbjgsG6h+T+9u4DNmbkBRiQidSlSA5wBYGaJQH+gFVBuPQvn3FeRPKdIffhq2TaKir0x/A7p2oL2zRoFHJGISP249dRBTF2xnXU79pCVV8hvXp/Hcz89jIQEVSkSiTcRe2JgZn8CtgHzga+ALyp4icScfXsjUjUiEWk4mqQm8cB5h1DStOCbFRk8/51qBovEo4g8MTCz3wJ3ApnA88B6QCOiSFwoKnZMWapuSkWk4Tq0R2t+NqYXT3y5CoB7/7eYo/u21SCPInEmUlWJrsLroWiEc25bhI4pEhXmrN/Jzj0FALRvlsrgzs0DjkhEpP7ddEI/vly6jSVbssgrKOamV+fw5jWjSUpUc0WReBGpd3M34B0lBRKPPl+879MC1asVkYYoNSmRf5w3jORE7zNw7oZMHpuyMuCoRCSSIpUYbCXCDZlFooVGOxYR8Qzq3JybTugfmn/k8+XM35AZYEQiEkmRSgxeA04ws9QIHU8kKmzYuYclW7IASElK4Kg+bQOOSEQkWD8b04uR3VsBUFjsuPG1OeQVFAUclYhEQqQSg9uAzcAbZqZRkCVufBH2tODIXm1okqoHYyLSsCUmGP847xDSUrxeyVekZ3PfR0sDjkpEIiFSicFCoAdwCrDCzHaY2apyXqqMKDHlc1UjEhHZT/c2Tbj11EGh+aemrmbayowAIxKRSIhUYpCA1z3pOv+VCVg5L3VdIDFjz95Cpq3cHppXYiAiUuqCw7pxXP/SUeB/8/o8ducVBBiRiNRWRL6oO+d6OOd6VuUVifOJ1Idvlmewt7AYgP4dmtGtdVrAEYmIRA8z42/nHEzLtGQANu7K5c73FgUclYjURkQSAzM7yMw6RuJYItFin96IBuppgYhIWe2bN+Lus4aG5t+ctYGPFmwJMCIRqY1IVe1ZDdwToWOJBK642O3TvuB4JQYiIuU69eBOnDmsc2j+D2/PZ1tWfoARiUhNRSox2AWo1ZHEjQWbMkN/2Fo3SWFYt1YBRyQiEr3uOmMIHZs3AmBHzl5+/9Y8nHMBRyUi1RWpxOA7YHiEjiUSuM/CRjse278diRrtWESkQi3Skvn7uQeH5j9bnM7rMzcEGJGI1ESkEoM7gGPM7MoIHU8kUJOXbA39e/yADgFGIiISG47p245Lj+wemr/r/UWs37EnwIhEpLoiNVrTycAU4AkzuwaYDmwByj5HdM65P0fonCJ1YktmHgs27gYgKcE4pp9GOxYRqYpbTh7I18szWJWRQ3Z+ITe/PpdXrjqCBD11FYkJkUoM7gj793AqrlbkACUGEtXCeyM6vFdrmjdKDjAaEZHY0TglkX+cP4xzHp9GUbFj+uod/Peb1Vw1plfQoYlIFUQqMTguQscRCVx4NaJxqkYkIlItw7q15Bdje/PI5BUA/P3jpYzp147+HZsFHJmIVCYiiYFz7stIHEckaHkFRXyzorSDLXVTKiJSfdeN78vkpeks2LibvUXF3PTaHN6+9ihSkiLVtFFE6oLeoSJhpq3MIK/AG+24d7smdG/TJOCIRERiT3JiAg+eNyyUCCzctJtHPl8ecFQiUhklBiJhwrspPX6gqhGJiNRU3w7N+O2J/UPzj01Zwax1OwOMSEQqE7HEwMw6mdmjZrbCzHLNrKicV2GkzicSac45JoclBuMGqBqRiEht/PSonhzRqzUAxQ5uenUOe/bqq4BItIpIYmBmXYAfgJ8DOUAqsA5YDhQBBswFvo7E+UTqwsJNu9myOw+AFo2TGdldox2LiNRGQoJx/7mH0DTVa9K4Zvse7p20JOCoRKQikXpicBvQETjJOXeIv+xp59wAoBfwMdAY+FGEzicSceHdlI7t346kRNW0ExGpra6t0rj99EGh+ee/W8uXy7YFGJGIVCRS33xOBD5yzn1WdoVzbgNwLl5icGeEzicScZ8vDhvtWO0LREQiZuLIrkwYVPq5+ts35rJrz94AIxKR8kQqMegILAybL8JLBABwzmUDnwJnRuh8IhGVnpXH3A2ZACQmGMf2bRdwRCIi8cPMuOdHQ2nbNAWArbvzue3dhZXsJSL1LVKJwW4gJWx+J9ClzDaZgL5tSVT6Iqwa0aE9WtEiTaMdi4hEUtumqdxz9tDQ/HtzN/H+3E0BRiQiZUUqMVgLdAubnwuMM7M0ADNLACYAGyJ0PpGI+jysN6LxGu1YRKROTBjckXNHdg3N3/rOArb6nT6ISPAilRh8DhxnZiU/sz4LdAammdnfganAYODVCJ1PJGLyCor4ennpaMfjNNqxiEidue30QXRp6dU2zswt4DdvzMM5F3BUIgKRSwz+C/wNaAvgnHsBeBgYAtwMHI6XFNwdofOJRMx3q7aTW1AEQM+2TejdrmnAEYmIxK9mjZJ54LxDMPPmv1q2jRe/XxdsUCICRCgxcM4td879zTm3OWzZjUAn4Eigk3PuQuecnhdK1AnvplSDmomI1L0jerXhiqN6hubv/nAxazJyAoxIRCCCIx+Xxzm3zTn3vXNua+Vbi9Q/59y+7QtUjUhEpF78+sT+9G3vPaHNLSjiptfmUFhUHHBUIg1bxBMDMxtgZmeb2cWRPrZIpC3ZksXGXbkANGuUxKE9WgcckYhIw9AoOZEHzx9GUoJXp2jWul088dWqgKMSadgilhiY2TAz+wFvPIM3gGfC1h1rZnvM7PRInU8kEiY+Pi3072P7tSNZox2LiNSbIV1acMP4vqH5hz5bxoKNmQFGJNKwReRbkJn1A6YA/fEaHf+vzCZfATuAiZE4n0gkrNyWTc7eotD8CYPUTamISH27ZmxvhnVrCUBBkeOGV2azZ29hwFGJNEyR+nn0drwBzg5zzt0EzAhf6bx+yL4FDo3Q+URq7dNF+zZ9Oe3gzgFFIiLScCUlJvDg+cNIS0kEYOW2HP78weKAoxJpmCKVGIwH3nLOHeidvA5vbAORqPBZWGJw/7mHkOjXcxURkfrVs20T7jhjcGj+5enr+GjBlgAjEmmYIpUYtKTyUY0T8J4qiARue3Y+M9ftBCDB1E2piEjQzh3ZlVOHdgrN3/LWPLZkqpdzkfoUqcQgHehTyTaDgfUROp9IrXy+JJ2SgTZHdW9N6ybKWUVEgmRm3HP2UDq3aATArj0F3PTaHIqLNSqySH2JVGIwGTjdzPqXt9LMDsWrbvRxhM4nUivh1YiOH6SnBSIi0aBFWjIPnj8sNCrytJXbefJrdWEqUl8ilRjcCxQCX5nZNfhtCcxssD//PpAF3B+h84nUWF5BEV8vzwjNHz9QvRGJiESLw3u14RdjSysh3P/xUuZt2BVgRCINR0QSA+fcUuAcvDYE/wKuBAyYBzzqL/+Rc25dJM4nUhtTV2SQW+B1U9q7XRN6tWsacEQiIhLuhuP7hrowLSx23PDKHHLy1YWpSF2L2GhOzrmPgJ7ATcBrwGfAW8BvgD7OucmROpdIbXy6TzUiPS0QEYk2yYkJPPzjYTTxuzBdnZHDXe8vCjgqkfgX0WFenXO7nHMPO+cucM5NcM6d65x7wDm3w8wamVnzSJzHzLqa2VNmtsnM8s1sjZk9ZGatqnGMKWbmDvBqFIlYJboUFzs+W5wemp+gxEBEJCp1b9OEu84cEpp/9Yf1TJq/OcCIROJfUj2e63Hg4tqe08x6A9OA9sC7wBLgMOAG4CQzO8o5t70ah7yzguV6ZhmH5m7YRUZ2PgBtmqQwrFuVc0kREalnPxrRhS+XbeO9uZsAuOXNeQzr1pLOLRsHHJlIfKrPxAC8dge19RheUnC9c+6foQOb/QO4EbgbuLqqB3PO3RGBmCRGhFcjGj+wvQY1ExGJYmbGX84ewsy1O9m4K5fdeYXc+OocXrrqCH1+i9SBiFYlqmtm1guYAKzBa9Qc7nYgB7jYzJrUc2gSIz5bHNa+QL0RiYhEveaNknn4x8MoyQO+X72D//tyZbBBicSpmEoMgHH+9BPnXHH4CudcFjAVSAOOqOoBzex8M7vFzG4ys5PNLDVy4Uo0Wbs9h2VbswFITUrg6L5tA45IRESqYlSP1lw3rm9o/sFPlzFnvbowFYm0WEsMSgZQW1bB+uX+tF81jvkK3jgMDwCTgHVmNrGqO5vZzPJewIBqxCD14OOFW0L/PqZvW9JS6rsmnYiI1NR14/owsrvXLszrwnQ22erCVCSiYi0xaOFPMytYX7K8ZRWO9S5wOtAVaIz3Rf5ef99XzezkWsQpUejjhaXViCYM7hhgJCIiUl1JiQk8dP4wmqV6P+qs3b6H295dEHBUIvEl1hKDypS0RHKVbeice9A594FzbqNzLs85t9Q59wfgZrxyuacqJ3TOjSzvhddbkkSJ9Kw8Zq3bCUCCqX2BiEgs6tY6jb+cXdqF6VuzNvLmzA0BRiQSX2qcGJhZUXVewCURiLfkiUCLCtY3L7NdTfwHr6vSYWbWrBbHkSjy2aJ0nJ8uHtazNa2bpAQbkIiI1MiZw7pwzoiuofk/vbuAlduyA4xIJH7U5omB1eBVW0v9aUVtCEpaJlXUBqFSzrk8IMufVe9GcSK8fcGEQapGJCISy+46czC92nl/ovfsLeK6l2aTV1AUcFQisa/GiYFzLqEGr8RaxvuFP51gZvvE7v+6fxSQC3xX0xOYWX+gFV5ykFHT40j02J1XwLSVpf+VEwarGpGISCxrkprEPy8YTkqS91Vg0ebd3DtpccBRicS+mGpj4JxbCXwC9AB+UWb1nXi/8D/nnMspWWhmA8xsnx6CzKyXmXUpe3wzaws87c++4pxTdwdx4Isl6RQUefWIhnRpTtdWaQFHJCIitTW4cwtuPXVgaP7Zb9fu83RYRKovFvtrvBaYBjxiZuOBxcDhwHF4VYj+WGb7kp8QwqsyjQH+Y2ZfAiuBHcBBwCl47Rd+AH5bVxcg9euTsN6ITlQ1IhGRuHHxEd2ZuiIj1Ovcb9+Yx5AuLejSsnHAkYnEpph6YgChpwajgGfwEoKbgd7AI8CRzrntVTjMTOAFoD1wjn+Mk4D5wPXAUc45jZwSB/IKipiyND00r25KRUTih5lx3zmHhBKBzNwCrn95NoVFxZXsKSLlicUnBjjn1gOXV3Hb/Ro9O+fmA5dFOCyJQtNWZpCz12uQ1qNNGv06NA04IhERiaQWack8csEwznviO4qKHTPX7uTBz5bxmxM1zqhIdcXcEwOR6vh4QVg1osEdMYtE51giIhJNRnZvzU0nlHZY+NiUlXyzXP2HiFSXEgOJW0XFjs8Wa7RjEZGG4Jpje3N0n7YAOAe/enUO27LyA45KJLYoMZC49cOaHWzP2QtAu2apDO/WMuCIRESkriQkGP84/xDaNvUGsMzIzuem1+ZQXOwCjkwkdigxkLj1yaLSpwUnDOpAQoKqEYmIxLP2zRrx4PnDQvNfL8/gia9WBRiRSGxRYiBxyTm3T3/WJ6oakYhIg3BM33ZcM7Z3aP7+T5Yyc+3OACMSiR1KDCQuLdq8mw07cwFo1iiJI3u1CTgiERGpLzed0I8RB3nVR4uKHde9NIudftVSEamYEgOJSx+HDWo2bkB7UpJ0q4uINBTJiQk8csFwmjfyemXflJnHza/PVXsDkUro25LEpU/CqhFN0GjHIiINTtdWaTxwXml7g8lL0nnya7U3EDkQJQYSd1Zuy2bJliwAUpMSGNu/XcARiYhIEE4Y1IGrjukZmv/7x0v5Yc2OACMSiW5KDCTu/G/+5tC/x/ZvR5PUmBzgW0REIuC3Jw3Yp73BxP/7lm9Xbg84KpHopMRA4s6k+aXViE4Z2inASEREJGjJiQn868IRtExLDi278tkZrEjPDjAqkeikxEDiypqMHBZt3g1ASmIC4wa0DzgiEREJWueWjXkwrL1Bzt4irnlhJjn5hQFGJRJ9lBhIXPnfgtKnBWP6taVZo+QDbC0iIg3FcQPa88C5h4Tml6dn84e35+OceioSKaHEQOLKpLD2BapGJCIi4c4Z2ZW/Tzw4NP/unE288N3aACMSiS5KDCRurN+xh/kbMwFITjTGD+wQcEQiIhJtzh3VjR8f2i00f9cHi5i9TiMji4ASA4kj/1tQ+rTg6D5tadFY1YhERGR/d5wxmMGdmwNQUOT4xYuz2KGRkUWUGEj8CO+N6GRVIxIRkQo0Sk7k8Z+M3Gdk5BtemU2RRkaWBk6JgcSFjbtymbN+FwBJCcaEQapGJCIiFTuoTRoPnl/aU9HXyzN45PPlAUYkEjwlBhIXwgc1G92nLS3TUgKMRkREYsH4gR24dmzv0Pwjk5czZWl6gBGJBEuJgcSF8G5KTxnSMcBIREQkltx0Qj9G924DgHPwq1fnsGHnnoCjEgmGEgOJeVsy85i51utRIjHBmDBYiYGIiFRNUmICj1wwnA7NUwHYtaeAX7w4i/zCooAjE6l/Sgwk5oX3RnRkrza0bqJqRCIiUnVtm6by6IUjSEowAOZuyOTO9xcFHJVI/VNiIDEvfFCzk4fqaYGIiFTfqB6tueXkAaH5l75fxyvT1wUYkUj9U2IgMW3TrlxmrCmtRnSiqhGJiEgNXXF0T047uLS769veXajBz6RBUWIgMe2DeZtC/x7duw1tm6YGGI2IiMQyM+O+iQczoGMzAPYWFXPNC7NIz8oLODKR+qHEQGLa+3NLqxGdfkjnACMREZF4kJaSxJMXj6JF42QAtuzO4xcvzmJvYXHAkYnUPSUGErNWZ+Qwf2MmACmJCapGJCIiEXFQmzT+ecFw/LbIzFizk798qMbIEv+UGEjM+mBuaTWiY/u3C/26IyIiUltj+rXjNyeWNkZ+7tu1vPbD+gAjEql7SgwkZr0f1r5A1YhERCTSrj62F6cOLW2MfOs7C5i7fleAEYnULSUGEpOWbNnNsq3ZADROTuT4ge0DjkhEROJNSWPk/h38xsiFxVz9wkwysvMDjkykbigxkJj0flg1ovED25OWkhRgNCIiEq+apCbxxMUjad7I+zuzOdNrjFxQpMbIEn+UGEjMcc7t0xvRGapGJCIidahH2yY8fMFwzG+M/P3qHfz5AzVGlvijxEBizrwNmazbsQeAZo2SOLZ/u4AjEhGReHdc//b8ekL/0Pxz367lhe/WBhiRSOQpMZCYE16N6MTBHUlNSgwwGhERaSiuHdubU8NGRr7jvYVMW5kRYEQikaXEQGJKcbHjg3ka1ExEROqfmXH/xEMY0qU5AIXFjmtfnMXa7TkBRyYSGUoMJKZMX7ODLbu9oelbN0lhdO82AUckIiINSeOURP59ySjaNUsFYNeeAq549gey8goCjkyk9pQYSEx5e9bG0L9PGdqR5ETdwiIiUr86tWjMkxePJCXJ+xu0Ij2b61+eTVGxCzgykdrRtyqJGXkFRUyaX1qN6OzhXQOMRkREGrLhB7XivnMODs1/sXQb9320JMCIRGpPiYHEjM8Xp5OVXwhAjzZpjDioZcARiYhIQ3bW8C5cO7Z3aP6Jr1bxxswNAUYkUjtKDCRmvD279MP2rOFdsJIOpUVERALy6wn9OX5gh9D8H96az8y1OwKMSKTmlBhITNienc+UpdtC82cP7xJgNCIiIp6EBOOhHw+jf4dmAOwtKubnz89kvT/ejkgsUWIgMeGDeZsp9Bt1jTioJd3bNAk4IhEREU/T1CT+c+koWjdJASAjey+XPzODzFz1VCSxRYmBxIS3Z5f2RnT2CDU6FhGR6NKtdRpPXDySlMTSnoqueWEmewuLA45MpOqUGEjUW7UtmznrdwGQnGicNrRTJXuIiIjUv0N7tObv55b2VDRt5XZufWc+zqkbU4kNSgwk6r0T9rTguP7taeU/qhUREYk2Zw7rws0n9AvNv/bDBh6bsjLAiESqTomBRDXnHG/PCatGpEbHIiIS5X45rg8TR5ZWe/37x0t5b+6mACMSqRolBhLVfli7k/U7cgFo3iiJcQPbBxyRiIjIgZkZ95w9lNG924SW/fr1ufywRt2YSnRTYiBR7Y0fSscuOPXgzqQmJQYYjYiISNWkJCXw+EUj6dO+KQB7C4u56rkfWJORE3BkIhVTYiBRKye/kA/mlT56PXeUeiMSEZHY0aJxMk9fdiht/LZxO/cUcPkzM9iRszfgyETKp8RAotak+ZvJ2VsEQJ/2TRnerWXAEYmIiFRPt9Zp/OfSUaQmeV+5VmfkcMWzM8j1/76JRBMlBhK1Xvthfejf543qipkFGI2IiEjNDD+oFQ+dP4ySP2Oz1+3ily/NorBIYxxIdInJxMDMuprZU2a2yczyzWyNmT1kZq1qccwxZlZkZs7M/hLJeKX6Vm3LZsaanQAkJRhnD1c1IhERiV0nD+3EHacPDs1/viSdP769QGMcSFSJucTAzHoDM4HLgenAg8Aq4AbgWzNrc4DdKzpmM+BZYE8EQ5VaeH1maaPjcQPa065ZaoDRiIiI1N6lo3tw7djeoflXf1jPg58uCzAikX3FXGIAPAa0B653zp3lnLvFOTcOL0HoD9xdg2M+DLQA7o1cmFJThUXFvBmWGJw3qluA0YiIiETOb07szzkjSp+CPzJ5Bc9/tzbAiERKxVRiYGa9gAnAGuDRMqtvB3KAi82sSTWOeSbe04frAY0+EgW+Wr6N9Kx8ANo1S2Vs/3YBRyQiIhIZZsZfzxm6z9+2295dwEcLtgQYlYgnphIDYJw//cQ5t0+LHedcFjAVSAOOqMrBzKw98G/gHefcC5EMVGrutRmlTwt+NKILSYmxdpuKiIhULDkxgcd+MoJDurYAwDm4/pXZzNAAaBKwWPvG1d+fVlQhb7k/7VfF4z2JVwZX1zQgM5tZ3gsYUNNjNmQZ2fl8tnhraP7ckapGJCIi8SctJYmnLjuUnm29Sg57C4v56TMzWLgpM+DIpCGLtcSghT+t6F1TsrzSDu/N7KfAmcC1zrmtlW0v9ePtWRspLPZ6aBjZvVVoxEgREZF406ZpKs9efhhtm3odbGTlFXLpU9NZtS074MikoYq1xKAyJR3dH7DvLzPrATwEvO6ce602J3TOjSzvBSypzXEbIuccL01fF5o/X42ORUQkzh3UJo1nf3oozRolAZCRvZeL/vM9G3flBhyZNESxlhiUPBFoUcH65mW2q8hTQC5wbSSCksiYtnI7qzNyAGjWKInTDukUcEQiIiJ1b3DnFjxz+aE0Tk4EYFNmHhf/53u2+R1xiNSXWEsMlvrTitoQ9PWnlXUKPAKvy9Nt/oBmzswc8LS//o/+sndqF65Ux4vfl3bXds6IrqSlJAUYjYiISP0Z2b01T14ykhS/w41VGTlc8tR0MnMLAo5MGpJY++b1hT+dYGYJ4T0T+YOUHYX3JOC7So7zHF7vRWX1BcYAc/AGUZtd64ilStJ35/HJwtKmHhceflCA0YiIiNS/Y/q245ELhnHti7ModrB4825++swMnr/iMP1YJvUipp4YOOdWAp8APYBflFl9J9AEeM45l1Oy0MwGmNk+PQQ55653zl1Z9kXpE4MP/WVlx0qQOvLqjPWhRseH9WhNvw7NAo5IRESk/p00pBN/O+fg0PzMtTv5+fMzyS8sCjAqaShiKjHwXQukA4+Y2Ttmdq+ZTQZuxKtC9Mcy2y/2XxKlioodL4c1Ov7JEXpaICIiDde5o7px++mDQvNfL8/gupdmU1BUfIC9RGov5hID/6nBKOAZ4HDgZqA38AhwpHNue3DRSU18sSSdTZl5ALRpksJJQzoGHJGIiEiwLj+qJzedUNqk8pNFW7n+ZSUHUrdiLjEAcM6td85d7pzr5JxLcc51d87d4Jzbb8hA55w556y845Sz7TP+9rdGPmqpSHij43NHdSM1KTHAaERERKLDdeP68PMxvULz/1uwhRtfnUOhkgOpIzGZGEj8WL9jD1OWbQvNX3iYqhGJiIgAmBm3nDyAnx7VM7Tsg3mbufn1uRQVH3DIJpEaUWIggXru2zU4/7NtTL92HNSmvM6iREREGiYz40+nDeSy0T1Cy96ds4nfKDmQOqDEQAKTk1/IKzPWh+YvG909wGhERESik5lx++mDuCisc463Zm/kd2/Oo1jJgUSQEgMJzJuzNpCVVwhAz7ZNGNuvfcARiYiIRCcz464zhnBBWJXbN2Zu4PdvzVdyIBGjxEACUVzseGbqmtD8pUd2JyGhSm3ERUREGqSEBOPus4Zw/qhuoWWv/rCeX78xVw2SJSKUGEggvly+jVUZ3jh0zVKTmBj2ISciIiLlS0gw7v3RUCaO7Bpa9tasjdzw6hx1ZSq1psRAAvHUN6tD/z7v0G40TdVQ7yIiIlWRkGDcd87B/PjQ0h/VPpy3mWtfnKURkqVWlBhIvVuRnsXXyzMAMINLj+wRbEAiIiIxJiHBuOfsofv0VvTpoq387LmZ5BUoOZCaUWIg9e6psLYFxw/soC5KRUREaiAhweut6OfHlg6C9uWybVz+9Axy8gsDjExilRIDqVfpWXm8MXNDaP7yo3oEF4yIiEiMMzNuOWkAvzq+b2jZt6u2c8lT09mdVxBgZBKLlBhIvXpm6hr2FnqNow7u2oIje7UJOCIREZHYZmb86vh+/O6kAaFlM9fu5MdPfEd6Vl6AkUmsUWIg9SYrr4Dnv1sbklAN9gAAIABJREFUmr/62N6YqYtSERGRSLhmbG/uOH1QaH7R5t1MfPxb1m7PCTAqiSVKDKTevDx93T4Dmp04uGPAEYmIiMSXy47qyX0TDybRHxto3Y49nPP4tyzYmBlwZBILlBhIvcgvLOK/YV2U/mxMr9CHloiIiETOeaO68cRFI0lN8r7mZWTn8+Mnv+PbldsDjkyinRIDqRfvzt7E1t35ALRrlsrZw7sEHJGIiEj8On5QB1648nCaNfLGCcrOL+TSp6bz0YLNAUcm0UyJgdS5omLHE1+tDM3/9KieNEpODDAiERGR+Hdoj9a8fvWRtG+WCsDeomKufXHWPu39RMIpMZA6N2n+ZlZu8xo+NUtN4idHHBRwRCIiIg3DgI7NefOa0fRs2wSAYgd/emcBd3+4iOJiF3B0Em2UGEidKip2PPL58tD8JaO707xRcoARiYiINCzdWqfx+tVHcnDXFqFl//56Nde8OJPcvRolWUopMZA6NWn+ZpanZwPQNDWJK4/uVckeIiIiEmltm6byys+O4IRBHULLPl64lR//+zu2ZeUHGJlEEyUGUmfKPi24bHQPWjVJCTAiERGRhistJYn/u2gkVxzdM7Rs7vpdnPXoVJZvzQowMokWSgykzpR9WhD+QSQiIiL1LzHB+NNpg7jrzMGU9Bq+cVcuP3p8GlOWpgcbnAROiYHUCT0tEBERiV6XHNmD/1w6irQUr5fArLxCLn9mBv/35UqcU6PkhkqJgdSJt2dv1NMCERGRKDZuQAdev/pIOrVoBIBz8Nf/LeGGV+aoUXIDpcRAIi6voIh/fLI0NH/F0T31tEBERCQKDe7cgvd+eTSH9mgVWvbe3E1M/L9pbNyVG2BkEgQlBhJxz3+7lk2ZeQC0bZrCVWPUE5GIiEi0atcslRevPIILDy8dZ2jhpt2c8c9v+H7V9gAjk/qmxEAiKnNPAf/6YkVo/vrxfWmamhRgRCIiIlKZlKQE7jl7KH85awhJfqvk7Tl7Of/J77j2xZlsz1aXpg2BEgOJqMe/XElmbgEA3duk8eNDNcqxiIhIrLjoiO68dNURtAmrAjxp/hZOeeRrpq/eEWBkUh+UGEjErN+xh6enrg7N/3pCf1KSdIuJiIjEksN6tub9645mdO82oWVbd+dzwb+/47EpKyguVq9F8Urf2iRi7pm0mPzCYgAO7tqCU4d2CjgiERERqYnOLRvz0lVH8J9LRtEqLRnwuiK/76Ol/PTZGezI2RtwhFIXlBhIRExdkcH/FmwJzd9++iASSkZOERERkZh0/KAOfHj9MYzsXtpr0ZSl2zjlYVUtikdKDKTWCoqKuf29haH5Hw3vwsjurQOMSERERCKlc8vGvPKzI/h5WC+DW3bncf6T3/K3j5aw168tILFPiYHU2rPT1rDCH8ysSUoit5w8IOCIREREJJKSExP4/SkD+e+lo2jR2Kta5Bw8PmUlZz82lRXpWQFHKJGgxEBqZevuPB7+bHlo/vrxfWnfvFGAEYmIiEhdGT+wAx/96ph9GiYv3LSbUx/5hmenrcE5NUyOZUoMpFZue3cBWfmFAPRq24TLj+oZcEQiIiJSlzq1aMwLVxzOracOJCXR+yqZX+hVK77kqels2Lkn4AilppQYSI39b/5mPl64NTT/l7OHqHtSERGRBiAhwbjymF68d91RDOjYLLT86+UZTHjwK56dtkbdmsYgfYuTGsncU8BtYQ2OLzisG6N7tw0wIhEREalvAzo2551fHMVVx/TE/M4I9+wt4vb3FnLeE9+yclt2sAFKtSgxkBr584eL2JblDY/evlkqt5w8MOCIREREJAiNkhP546mDeOPq0fRp3zS0/Ie1Ozn54a959IsV6rkoRigxkGqbNH8zb8zcEJr/81lDQj0UiIiISMM0snsrPrz+aK4b14ckfyyjvYXF/P3jpZz88Fd8szwj4AilMkoMpFo2Z+by+7fmh+bPGtaZEwd3DDAiERERiRapSYncPKE/7/3yaIZ2aRFavnJbDhf993t+8eIsNmfmBhihHIgSA6my4mLHr1+fS2ZuAQBdWjbmrrOGBByViIiIRJtBnZvz9rWjufXUgTRNTQot/3D+ZsY/8CWPT1lJfmFRgBFKeZQYSJX964sVTF2xHYAEgwfPH0bzRqpCJCIiIvtLSkzgymN6MfnmYzl7eJfQ8j17i/jbR0sY/8CXvDtno3oviiJKDKRKvliazoOfLQvNXzO2N4f1bB1gRCIiIhIL2jdvxIPnD+O1nx+5T9emG3bmcsMrczjz0alMW6n2B9FAiYFUat32Pdzw8mxKBjM8slcbbjy+X7BBiYiISEw5rGdrPrjuaO44fRCt0kprHMzfmMmF//6ey5+ezvwNmQFGKEoM5ICy8gr42fM/sDvPG924U4tG/PPC4SQl6tYRERGR6klKTOCyo3ry5W+P49qxvUkNGxj1i6XbOP1f33DFMzOYt2FXgFE2XPp2JxXaW1jMNS/MYsmWLABSEhN4/KKRtG2aGnBkIiIiEsuaN0rmtycN4Itfj2XiyK6hwdEAPl+Szhn/mspPn5nB3PVKEOqTEgMpl3OO3781n29WlNb5u/vsIQzr1jLAqERERCSedG7ZmPvPPYSPbhjDqQd32idBmLwknTMfncr5T3zLZ4u2qpFyPUiqfBNpaJxz3PbuQt6cVTqI2Y3H9+PcUd0CjEpERETiVf+OzXj0whEs3ZLFI5OXM2n+5lDbxu9X7+D71Tvo1a4JVxzdk3NGdKVRcmKwAccpPTGQfTjnuP29hTz/3drQsvNHdeP68X0CjEpEREQagpIE4eNfjeHMYZ1JTCh9hLBqWw5/fHsBR9z7OXe9v4jlW7MCjDQ+mXN6LFMXzGzmiBEjRsycOTPoUKqsoKiYP7w1n9dnlj4pOOOQzvzjvEPU2FhERETq3aZduTwzbQ0vf7+OrPzC/daP6t6KCw47iFOGdqJxSsN9ijBy5EhmzZo1yzk3sjbHUWJQR2ItMcjKK+DaF2fx9fLSNgWnHdyJh84fpqRAREREApWdX8irM9bzzLTVrN+Ru9/6JimJTBjckTMO6czRfduS3MC+u0QqMVAbA2HJlt1c++IsVm3LCS2bOLIrf/3RUCUFIiIiErimqUlccXRPLh/dg6krM3h5+jo+WbiVQr9Bcs7eIt6evZG3Z2+kZVoyJw/pyMlDOnF4r9akJjXcJwnVFZOJgZl1Be4CTgLaAJuBd4A7nXM7q3iM3wDHAYOAtkAxsBb4FPiHc27DAXaPC8XFjpemr+PPHywiv7A4tPxXx/flhvF9sfCuAUREREQClpBgHNO3Hcf0bce2rHzenLWB12asZ1VG6Y+bu/YU8PL09bw8fT1pKYkc07ct4wd0YOyAdrRv1ijA6KNfzFUlMrPewDSgPfAusAQ4DO9L/lLgKOfc9iocZwWQDcwFtgLJwHDgWGA3MNY5N7sWcUZ1VaLFm3dz6zsLmLm2NI9qnJzIPT8awtnDuwYYmYiIiEjVOedYuGk378/dxPtzN7EpM6/Cbfu0b8rhPVtzRK82HN6rddwkCg25KtFjeEnB9c65f5YsNLN/ADcCdwNXV+E4Q5xz+905ZnYV8KR/nFMiEnEUWboli8emrOC9uZsIzwn7dWjKYz8ZQZ/2zYILTkRERKSazIwhXVowpEsLfnfSAGau28mH8zYzeUk663bs2WfbFenZrEjP5sXv1wHQrXVjhvr7HtylJYM7N6dVk5QgLiMqxNQTAzPrBawE1gC9nXPFYeua4VUpMqC9cy6n3INUfo4WwC5ghXOuby1ijYonBs45VmXk8NWybbw/dxOz1u07gmByovHzMb355bg+6hNYRERE4oZzjpXbcpi8ZCufL05n1rqdFBRV/r23dZMUerVtQq92TejZtildWzWmQ/NGdGieSofmjaLy+1JDfWIwzp9+Ep4UADjnssxsKjABOAL4vIbnON2fzqvh/oG676MlrN2xh+y8Qnbt2cvKbTlkl9O9F8Cx/drxp9MG6imBiIiIxB0zo0/7pvRp35SfjelN7t4iZq/byXertvPd6h3MWbeLvUXF++23I2cvO3L28sPa8putNktNommjJJqGTVOTEkgwIynRaJycxAPnHVLXl1cnYi0x6O9Pl1WwfjleYtCPKiYGZnYl0BVoCgwFjsdrhHxLFfev6JHAgKrsH2lfLN3G4s27K1yfnGicMKgDPxvTm2HdWtZjZCIiIiLBaZySyOg+bRndpy0AewuLWbY1i/kbM5m3IZMFGzNZtjVrnw5ZypOVX1jumAolmqUmAUoM6kMLf5pZwfqS5dX5xnslcHjY/AzgQufcimrGFhW8m3FfLRonc1jP1ozp145ThnSkTdPUACITERERiR4pSQmhtgkXHOYtKy52bMrMZXVGDqu25bA6I4ctmXlszcojfXc+W3fnhbpIrUhCQuz26hhriUFlSv4nqtxwwjl3BICZtQFG4DU6nmlm5zvnPqrC/uXW5fKfJIyoahyRcs1xvflJ7kE0b5RM00ZJdG+dRrtmqep6VERERKQSCQlG11ZpdG2VxjF92+23vrjYsTuvgOz8QnLyi8jOLyA7v4iCwmIKix1FxY5YHgIq1hKDkicCLSpY37zMdlXmd3H6qZnNwOsC9Tkz6+6c2394vSh2XP/2QYcgIiIiEpcSEoyWaSm0TIvPnotiLadZ6k/7VbC+pBehitogVMo5twv4FmgHDK7pcUREREREYkmsJQZf+NMJZrZP7H53pUcBucB3tTxPF39accsSEREREZE4ElOJgXNuJfAJ0AP4RZnVdwJNgOfCxzAwswFmtk8PQWbW3R8TYT9m9nPgUGA9MD9y0YuIiIiIRK9Ya2MAcC0wDXjEzMYDi/F6FToOrwrRH8tsv9ifhre+HQ68ZWbT/H22Am3wxj8YCmQDFzvniurqIkREREREoklMPTGA0FODUcAzeAnBzUBv4BHgSL8RcWVmAQ8CKcCpwK+BC/B6M3oAGOSc+zLiwYuIiIiIRKlYfGKAc249cHkVt92vn07n3Dq8hEJERERERIjBJwYiIiIiIhJ5SgxERERERESJgYiIiIiIKDEQERERERGUGIiIiIiICEoMREREREQEJQYiIiIiIoISAxERERERQYmBiIiIiIigxEBERERERABzzgUdQ1wys+2NGzduPXDgwKBDEREREZE4tnjxYnJzc3c459rU5jhKDOqIma0GmgNrAjj9AH+6JIBzxxqVVdWprKpH5VV1KqvqUXlVncqq6lRW1RNt5dUD2O2c61mbgygxiENmNhPAOTcy6Fiincqq6lRW1aPyqjqVVfWovKpOZVV1KqvqidfyUhsDERERERFRYiAiIiIiIkoMREREREQEJQYiIiIiIoISAxERERERQb0SiYiIiIgIemIgIiIiIiIoMRAREREREZQYiIiIiIgISgxERERERAQlBiIiIiIighIDERERERFBiYGIiIiIiKDEIK6YWVcze8rMNplZvpmtMbOHzKxV0LHVBTNrY2ZXmtnbZrbCzHLNLNPMvjGzK8ys3PvbzEab2SQz22Fme8xsnpn9yswSD3Cu08xsin/8bDP73swurburqx9mdrGZOf91ZQXbVPvazexSM5vub5/p739a3VxF3TKzY8zsTTPb7L+vNpvZJ2Z2SjnbNth7y8xO9ctlg/9eXGVmr5vZkRVsH9dlZWYTzeyfZva1me3232MvVLJPvZRJNL4/q1NeZtbXzH5nZpPNbL2Z7TWzrWb2rpkdV8l5qnXtZpbo/x/M8+/rHf7/0ejaXnNN1eTeKrP/f8M+9/tUsE21r9vMGpvZnWa21MzyzCzdzF4zs4E1uc5IqOH70Pz7ZIp/3blmttq/ln4V7BPz91WIc06vOHgBvYGtgAPeAf4KTPbnlwBtgo6xDq75av/6NgEvAvcCTwG7/OVv4A/iF7bPmUAhkA38F/i7Xz4OeL2C8/zSX58BPAo8CKz3l90fdDnUovy6+WWV5V/LlZG4duB+f/16f/tHge3+sl8Gfd3VLKNb/bi3AU8D9wBPAjOA+3Rvha7jb2HX8R//8+cNYC9QDFzU0MoKmOPHlgUs9v/9wgG2r5cyidb3Z3XKC3jFX78QeALvs/8tv/wccH0krh0w4HVK/47+3f+/yfbPdWa0l1U5+54etq8D+kTiuoFU4Bt/nxn+Z8JLQAGQAxweC2UFNALeD7v2f/n317PAKuC0eL2vQvEFeXK9IvgfCR/7N9l1ZZb/w1/+f0HHWAfXPM7/kEsos7wjsM6/7nPCljcH0oF8YFTY8kbANH/7H5c5Vg8gz3+T9whb3gpY4e9zZNBlUYOyM+AzYKX/obRfYlCTawdG+8tXAK3KHGu7f7wedXVdES6jc/1r+RRoVs76ZN1bofdbEbAFaF9m3XH+daxqaGXlX3tf/702lgN/0a2XMonm92c1y+syYHg5y4/FS0bzgU61vXbgAn+fqUCjsOWH+udIp5zPhmgqqzL7tfPfp68AU6g4Maj2dQO/9/d5nbC/yXgJb0kSl1CT663PssL7Uu/wfgTaL17CPvfj7b4KxRHUifWK4H8i9PJvstVlb2SgGV4WmgM0CTrWeiyTP/hl8s+wZT/1lz1bzvbj/HVflll+l7/8znL2qfB40f4CbsD7JXcMcAflJwbVvnbgOX/55eXsU+Hxou2FV81ylf++aVeF7RvsvQUc7sf6bgXrdwNZDbmsqPyLbr2USay8Pysrr0r2/YQyPwrV9NqBr/zlx5WzT4XHi9ayAt7GSwzacODEoFrXjfele62/vGd1jhdNZYVX86IImE6Z2gYHOGbc3VdqYxAfxvnTT5xzxeErnHNZeFlpGnBEfQcWoAJ/Whi2rKScPipn+6+APcBoM0ut4j7/K7NNTPDre/4VeNg599UBNq3JtcdLeY0GegKTgJ3m1Z//nZndUEGd+YZ8by3H+5X2MDNrG77CzMbg/TjxWdjihlxWFamvMon3coTyP/uhmtful/VovLL/uir7RDMzuww4C7jaObf9ANvV5Lp7AwcBy5xzq6u4TzS6AO9HoWeB5mZ2kZn93sx+VlFbDOLwvlJiEB/6+9NlFaxf7k/LbTQTb8wsCbjEnw1/s1ZYTs65QrwnLkl4T2Cqss9mvF+Uu5pZWi3Drhd+2TyPV9XqD5VsXq1rN7MmQBcg219fVizdh4f6063ALOADvGTqIWCamX1pZu3Ctm+w95ZzbgfwO6ADsMjMnjSze83sNbxfbz8Ffh62S4MtqwOo8zKJs/dnucysOzAe70vXV2HLa3LtfYBEvGpwZZOMivaJSn65PIz3S/k7lWxek+uOl+8gJZ/7LfCq2T6PV6XoCWCZmT1qYR0BxOt9pcQgPrTwp5kVrC9Z3rIeYokGfwWGAJOccx+HLa9JOVV1nxYVrI82twHDgcucc7mVbFvda4+n+7C9P70aaAwcj/fL9xC89jxj8OrSlmjQ95Zz7iHgR3hfXq8CbsFro7EeeMY5lx62eYMuqwrUR5nE0/tzP/4vsS/iNYK9wzm3M2x1XZZvVJeXeb3zPYtXpfj6KuzSYMuK0s/9u4AfgKF4n/vj8RKFa4E/hW0fl2WlxKBhMH/qAo2iHpjZ9cDNeC39L67u7v60OuUUM2VrZofhPSV4wDn3bSQO6U+re+1RX1Z4v+iAd40TnXOfO+eynXMLgbOBDcCxFVQrKk+831u/xeuF6Bm8agVNgJF47TReNLP7qnM4fxqXZVVD9VkmMVeG/q+4zwNHAa/i9RJTE/F4z92I1yj7qjLJUk3F8/uz5HN/M3C2c26B/7k/GZiI1y7vJjNLqeZxY6qslBjEh8p+LWteZru4ZGa/wHtcugivUc+OMpvUpJyqus/uaoRa78KqEC1j3188DqS6117Z9pX9UhJNSv6ArnLOzQ1f4T9pKXkSdZg/bcj31li8rgnfc87d5Jxb5Zzb45ybhZdEbQRuNrOSajANtqwOoD7KJJ7enyF+UvAC3hOq1/C6xi37paom1x7zf1fNrC9wN/C0c25SFXery3sxasvKV/K5/1HZJ+r+34HVeE8QSsZliMv7SolBfFjqTyuqk9bXn1ZU/y/mmdmv8PobXoCXFGwpZ7MKy8n/4twTr8Haqiru0wnvl9ENzrk9NY++XjTFu4aBQF7Y4DYOuN3f5t/+sof8+Wpdu3MuB+9LYFN/fVmxdB+WXPuuCtaX/AFpXGb7hnhvlQzi80XZFX7s0/H+1gz3FzfksqpInZdJnL0/gVDZvAz8GK/P/AvLq7ddw2tfgddDTS//PFXZJ9oMxqtadXn4Z77/uX+sv81yf9lZ/nxNrjtevoNU63M/Xu8rJQbxoeQP8gQrM9qvmTXDe7yaC3xX34HVBzP7Hd6gInPwkoL0Cjad7E9PKmfdGLyem6Y55/KruM/JZbaJZvl4A6iU95rtb/ONP19Szagm1x4v5fUV3hexvhU8Nh7iT9f404Z8b5X0lNOugvUly/f604ZcVhWprzKJm3L035dv4D0peA642DlXdIBdqnXtfllPwyv7Y6qyTxRaQ8Wf+yU/nr3uz6+BGl/3SrwOLfqZWc8q7hONPvenQ8qu8NuwlHxpXxO2Kv7uq6D6SdUrsi8a4ABn/vX9yb++H4DWlWzbHG8E2+oMItSTGBtYqQZleAflj2NQ7WsnigdQqkG5vOBfy1/KLD8Br67pLqBlQ7+3gPP8WLcAXcqsO9kvq1z80dcbYllRtQHO6rxMYuX9WYXySgU+9Lf5D1UYOKsm107VBqJqHs1ldYD9plC7Ac6al9knKgc4q+Z9lYKX5BQDJ5RZ9xd/3ynxfl8F9h+kV4T/I70Gf1v9m+0dvCG8J/vzS/H/KMfTC7jUv75CvCcGd5TzuqzMPmf522f7f1Duw2uoXPKBtt+gJsB1/voMvFERH8TrbcUB9wddDhEoxzsoJzGo6bUDD/jrw4eHz/CX7Tc8fLS+8HqoWO7H/RVeg8bX/funADhX95YD78nzp37Mu/F6QPkb8B7eH1gH3NDQysq/xmf810d+nCvDlt1fzvZ1XibR+v6sTnkBT/vrtwF3Uv5n/9jaXjteQ9DX/fWL/f+T//r/R4XAmdFeVgc4xhQqTgyqfd14ydpUf58ZeL0DvoT3WZkDHB4LZQUcjdfdbaFfBvcDX/r7pQP94vW+CsUX5Mn1ivB/JnTzPzA34z22X4vXGPeAv6TH6ovSL7QHek0pZ7+j8Aeuwvslcz5ezw2JBzjX6f6HQ5b/ITcDuDToMohwOe6XGNT02vGSthn+9ln+/qcFfa01KJvWeE/dVvvvqe3Au8ARFWzfIO8tIBn4FV51xd3+H7d0vPEfJjTEsqrC59OaoMokGt+f1SkvSr/UHuh1RySuHa8L3hv9/4tc//9mEjA6FsrqAMcoKcP9EoOaXjde3fs78X5QycdL3F4HBsVSWQGD8Hq3Ssf73F+PN5ZB1wOcJ+bvq5KX+QGKiIiIiEgDpsbHIiIiIiKixEBERERERJQYiIiIiIgISgxERERERAQlBiIiIiIighIDERERERFBiYGIiIiIiKDEQEREREREUGIgIiIiIiIoMRAREREREZQYiIiIiIgISgxERCQOmNlYM3NmdkfQsYiIxColBiIiDYj/5dmVWdbDX/5MQGFVKhZiFBGJdUlBByAiIhIB04GBQEbQgYiIxColBiIiEvOcc3uAJUHHISISy1SVSESkAfPr5K/2Zy8tqWrkvy4rs+2JZjbJzDLMLN/MVprZ382sZTnHXeO/mpvZP/x/F5S0ATCzzmZ2m5lNNbMtZrbXzDaZ2UtmNrC6MR6ojYGZ9TWz58xsY9h5njOzvuWVh3+csWY20cymm9keM9thZq+YWZfqlbCISOzQEwMRkYZtCtASuAGYC7wTtm5OyT/M7DbgTmAH8AGQDhwM/Bo4xcyOdM7tLnPsFGAy0Br4BNhN6Rf8McAtwBfAm0A20BeYCJxhZkc55+ZWJ8bymNmhwGdAM+A9YBEwAPgJcKaZjXfO/VDOrtcCZ/j7fAkcDpwPHGJmw5xz+Qc6r4hILFJiICLSgDnnppjZGrwv3XOcc3eU3cbMjsNLCr4FTnHO7QpbdxnwtL/+xjK7dsL7In6scy6nzLrJQAfnXFaZcx0CTAX+Cpxc1RjLY2YGPAc0By5yzr0Ytu584BXgBTMb5JwrLrP7ScChzrn5Yfu8BFwAnAm8VpUYRERiiaoSiYhIZa73p1eFJwUAzrln8H61/0kF+95cTlKAcy69bFLgL5+LlzQcZ2bJtYoaRuM9Hfg2PCnwz/Mq8A3QHzi6nH0fCU8KfP/2p4fVMi4RkaikJwYiIlKZI4EC4FwzO7ec9SlAOzNr45zbHrY8D5hX0UHN7FTgamAU0Jb9/ya1BTbXIu4R/nRyBesn4yUFw4Gvyqwrr3rRen/aqhYxiYhELSUGIiJSmTZ4fy9ur2S7pkB4YpDunHPlbWhm1wMPAzuBT4F1wB7AAWcBhwCptQubFv60ouSiZPl+jaeBXeUsK/SnibUJSkQkWikxEBGRymQCCc651tXcr6KkIAmvTcIWYIRzbnOZ9UfWKMr9ZfrTjhWs71RmOxGRBk1tDEREpMifVvRL+HdAKzMbHKHztcX7lX5aOUlBU0qrAFUnxvLM9qdjK1hfsnxWNY4pIhK3lBiIiMhOvF/3D6pg/YP+9N9m1rnsSjNrYmZHVON86XjVhkb6iUDJcZLxqhe1rUGM5ZkKLAWONrOJZWKeiNdl6jK8RsgiIg2eqhKJiDRwzrlsM/seOMbMXsT7slwEvOecm+ec+9zMbgHuBZab2SS88QiaAt2BY/G+XJ9UxfMVm9kjeOMYzDezd/EaMB+HN+bBF/6/qxxjBedxZnYpXhuGV/3zLMHriegsIAu4pJyuSkVEGiQlBiIiAnAx3pOBk/D66jdgA36vQs65v5nZVLyuS4/G68s/E9gIPAm8VM3z/QnYBlwJ/Nw/1qfArXjtD6odY3mcc9/7g5zdChwPnA6MV8F6AAAApklEQVRkAC8Df3bOLa1m3CIiccsq6DBCREREREQaELUxEBERERERJQYiIiIiIqLEQEREREREUGIgIiIiIiIoMRAREREREZQYiIiIiIgISgxERERERAQlBiIiIiIighIDERERERFBiYGIiIiIiKDEQEREREREUGIgIiIiIiIoMRAREREREZQYiIiIiIgISgxERERERAQlBiIiIiIighIDEREREREB/h+46xsEOAp8AwAAAABJRU5ErkJggg==\n", "text/plain": [ "
" ] }, "metadata": { "image/png": { "height": 277, "width": 387 }, "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "learn.recorder.plot_lr()" ] }, { "cell_type": "code", "execution_count": 95, "metadata": {}, "outputs": [ { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "image/png": { "height": 277, "width": 393 }, "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "learn.recorder.plot_loss()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## \"Lab Notebook\" for my DALI Transform Explorations:\n", "Once my DALI data loader and new fastai training loop were working in perfect harmony, I set for myself the goal of choosing parameters for each of the DALI image transforms that I planned to include (perspective warp, flips, and rotation). I wanted each transform to actually improve my model's performance over the following baseline:\n", "\n", "**My Global Baseline** Random crop resize + 50% chance of horizontal mirror, 8 epochs, one-cycle cosine warmup/annealing, min lr=3e-1, max_lr=9e-1, image size 128px: Valid Accuracy: `72.4%`\n", "\n", "### \"Synthetic Random\" Warp Affine Transform experiments:\n", "As a workaround to DALI's [lack of support](https://github.com/NVIDIA/DALI/issues/552) for randomized perspective warp transforms, I wondered if nonetheless it might be possible to implement DALI's non-randomized perspective warp transform in such a way that it would *seem* to behave as if it truly were random. In order to be deemed successful, this strategy would of course need to bring with it the kind of improvement in model performance that one would expect a truly random perspective warp augmentation to offer. My strategy was as follows:\n", "\n", "**\"Synthetic random\" warp transform**:\n", "1. Write [a function](http://nbviewer.jupyter.org/github/jamesdellinger/fastai_deep_learning_course_part2_v3/blob/master/Diving_into_DALI.ipynb?flush_cache=true#Generating-random-affine-transforms-for-image-perspective-warps) that generates random affine transformations, formatted so that the transform can be passed to DALI's `ops.WarpAffine` [operation](https://docs.nvidia.com/deeplearning/sdk/dali-developer-guide/docs/supported_ops.html#nvidia.dali.ops.WarpAffine). My algorithm ensures that a randomly generated affine transform will tilt an image's perspective, but won't unnaturally squish or stretch the contents of the image.\n", "2. Add somewhere between two and twenty DALI `ops.WarpAffine` operations to my pipeline. (I performed experiments to determine the right amount and found that seven worked best.)\n", "3. Generate a unique affine transformation for each DALI `ops.WarpAffine` operation that I include in my pipeline.\n", "4. Apply each of the pipeline's warp affine transforms to a particular image with a probability somewhere between 0.3 and 0.025. (I performed experiments to determine the best probability and found that 0.025 worked best.)\n", "\n", "My intuition was that with an adequately chosen number of warp affine operations, balanced with a suitable probability that each operation would be applied, I could:\n", "1. Maximize the *variety* of perspective warp transforms applied to a mini-batch's images.\n", "2. Adequately minimize the chance that a single image would have two or more warp transforms applied to it during each mini-batch.\n", "\n", "#### DALI warp affine experiment 1: choosing *where* in the pipeline to place my \"synthetic random\" warp affine transform, and at *what resolution*\n", "I realized that there were also two other things I could adjust:\n", "1. Whether I apply warp affines *before* or *after* I randomly crop and resize training inputs.\n", "2. Whether or not I want the outputs of the warp affine transforms to have black corners: If I kept images at 128px before and after applying warp transforms, outputs would have black corners. However, if I randomly crop and resize images to 156px, I could then generate an affine transform that will both tilt and crop the image down to 128px. If I do this, output images would have no black corners.\n", "\n", "I decided that the following three approaches best encapsulated the possible options. I didn't want to spend too much time on these experiments, so I performed a single training run using each of these three approaches and chose the approach that scored highest.\n", "\n", "Approach #1:\n", "* Use my 4-step synthetic randomized warp affine work-around. Placing 5 warp affines in the pipeline, each with 0.1 prob of being executed. I apply these warp affines *after* crop and resize. Image resolution is 128px: \n", "\n", " Valid Accuracy: `69.0%`\n", "---\n", "\n", "Approach #2:\n", "* Same as approach #1, but apply warp affine operations *before* crop and resize: \n", "\n", " Valid Accuracy: `66.6%` (also ends up adding up to 22sec of train time per epoch)\n", "---\n", "\n", "Approach #3:\n", "* Same as approach #1, but generate affine transforms that prevent any black triangles in corners after warp applied by first resizing image inputs to 156px, then generate an affine transform that will tilt and crop the input image to 128px: \n", "\n", " Valid Accuracy: `67.2%`\n", "\n", "**Conclusion:** Based on a comparison of the above three approaches, I decided that I should settle on approach #1. \n", "\n", "#### DALI warp affine experiment 2: find some promising combinations of number of warp affines & probability of application\n", "Now that I knew how and where in my pipeline I'd place my \"synthetic random\" warp affine, I still had to determine the right balance between variety (the number of warp affine operations I'd actually include) and probability (the chance that any individual warp affine operation would be applied to a given image). \n", "\n", "I decided to make this a two-part grid-search competition. For the first part, which I undertake here in this experiment, I perform several single runs across a wide variety of number warp affines/probability combinations. The top four performing combinations will move onto the final round, which will take place in experiment 3 below.\n", "\n", "* 1 warp affine, 0.1 prob of application: Valid Accuracy: `71.6%`\n", "* 2 warp affines, 0.1 prob of application: Valid Accuracy: `71.4%`\n", "* 3 warp affines, 0.1 prob of application: Valid Accuracy: `73.8%` **Improvement over Baseline!**\n", "* 4 warp affines, 0.1 prob of application: Valid Accuracy: `71.4%`\n", "* 5 warp affines, 0.1 prob of application: Valid Accuracy: `69.0%`\n", "* 6 warp affines, 0.1 prob of application: Valid Accuracy: `72.2%`\n", "* 7 warp affines, 0.1 prob of application: Valid Accuracy: `70.6%`\n", "* 8 warp affines, 0.1 prob of application: Valid Accuracy: `67.6%`\n", "* 9 warp affines, 0.1 prob of application: Valid Accuracy: `69.4%`\n", "* 10 warp affines, 0.1 prob of application: Valid Accuracy: `70.2%`\n", "* 20 warp affines, 0.1 prob of application: Valid Accuracy: `69.4%`\n", "---\n", "* 1 warp affine, 0.2 prob of application: Valid Accuracy: `73.8%` **Improvement over Baseline!**\n", "* 2 warp affines, 0.2 prob of application: Valid Accuracy: `73.8%` **Improvement over Baseline!**\n", "* 3 warp affines, 0.2 prob of application: Valid Accuracy: `72.4%`\n", "* 4 warp affines, 0.2 prob of application: Valid Accuracy: `69.2%`\n", "* 5 warp affines, 0.2 prob of application: Valid Accuracy: `71.8%`\n", "* 6 warp affines, 0.2 prob of application: Valid Accuracy: `67.6%`\n", "* 7 warp affines, 0.2 prob of application: Valid Accuracy: `69.6%`\n", "* 8 warp affines, 0.2 prob of application: Valid Accuracy: `71.0%`\n", "* 9 warp affines, 0.2 prob of application: Valid Accuracy: `71.0%`\n", "* 10 warp affines, 0.2 prob of application: Valid Accuracy: `66.8%`\n", "---\n", "* 1 warp affine, 0.05 prob of application: Valid Accuracy: `74.4%` **Improvement over Baseline!**\n", "* 2 warp affines, 0.05 prob of application: Valid Accuracy: `72.6`\n", "* 3 warp affines, 0.05 prob of application: Valid Accuracy: `71.6%`\n", "* 4 warp affines, 0.05 prob of application: Valid Accuracy: `72.6%`\n", "* 5 warp affines, 0.05 prob of application: Valid Accuracy: `73.6%` **Improvement over Baseline!**\n", "* 6 warp affines, 0.05 prob of application: Valid Accuracy: `72.2%`\n", "* 7 warp affines, 0.05 prob of application: Valid Accuracy: `72.6%`\n", "* 8 warp affines, 0.05 prob of application: Valid Accuracy: `70.8%`\n", "* 9 warp affines, 0.05 prob of application: Valid Accuracy: `71.8`\n", "* 10 warp affines, 0.05 prob of application: Valid Accuracy: `72.8%`\n", "* 11 warp affines, 0.05 prob of application: Valid Accuracy: `74.6%` **Improvement over Baseline!**\n", "* 12 warp affines, 0.05 prob of application: Valid Accuracy: `70.8%`\n", "* 13 warp affines, 0.05 prob of application: Valid Accuracy: `68.0%`\n", "* 14 warp affines, 0.05 prob of application: Valid Accuracy: `71.2%`\n", "* 15 warp affines, 0.05 prob of application: Valid Accuracy: `70.8%`\n", "* 16 warp affines, 0.05 prob of application: Valid Accuracy: `71.2%`\n", "* 17 warp affines, 0.05 prob of application: Valid Accuracy: `67.2%`\n", "* 18 warp affines, 0.05 prob of application: Valid Accuracy: `70.6%`\n", "* 19 warp affines, 0.05 prob of application: Valid Accuracy: `73.8%` **Improvement over Baseline!**\n", "* 20 warp affines, 0.05 prob of application: Valid Accuracy: `69.6%`\n", "---\n", "* 1 warp affine, 0.025 prob of application: Valid Accuracy: `74.2%` **Improvement over Baseline!**\n", "* 2 warp affines, 0.025 prob of application: Valid Accuracy: `75.2%` **Improvement over Baseline!**\n", "* 3 warp affines, 0.025 prob of application: Valid Accuracy: `67.8%`\n", "* 4 warp affines, 0.025 prob of application: Valid Accuracy: `73.8%` **Improvement over Baseline!**\n", "* 5 warp affines, 0.025 prob of application: Valid Accuracy: `76.6%` **Improvement over Baseline!**\n", "* 6 warp affines, 0.025 prob of application: Valid Accuracy: `71.0%`\n", "* 7 warp affines, 0.025 prob of application: Valid Accuracy: `74.6%` **Improvement over Baseline!**\n", "* 8 warp affines, 0.025 prob of application: Valid Accuracy: `71.4%`\n", "* 9 warp affines, 0.025 prob of application: Valid Accuracy: `72.0%`\n", "* 10 warp affines, 0.025 prob of application: Valid Accuracy: `73.8%` **Improvement over Baseline!**\n", "* 11 warp affines, 0.025 prob of application: Valid Accuracy: `74.8%` **Improvement over Baseline!**\n", "* 12 warp affines, 0.025 prob of application: Valid Accuracy: `73.6%` **Improvement over Baseline!**\n", "* 13 warp affines, 0.025 prob of application: Valid Accuracy: `71.8%` **Improvement over Baseline!**\n", "* 14 warp affines, 0.025 prob of application: Valid Accuracy: `74.2%` **Improvement over Baseline!**\n", "* 15 warp affines, 0.025 prob of application: Valid Accuracy: `73.8%` **Improvement over Baseline!**\n", "* 16 warp affines, 0.025 prob of application: Valid Accuracy: `74.4%` **Improvement over Baseline!**\n", "* 17 warp affines, 0.025 prob of application: Valid Accuracy: `73.8%` **Improvement over Baseline!**\n", "* 18 warp affines, 0.025 prob of application: Valid Accuracy: `70.2%`\n", "* 19 warp affines, 0.025 prob of application: Valid Accuracy: `72.6%`\n", "* 20 warp affines, 0.025 prob of application: Valid Accuracy: `72.0%`\n", "---\n", "* 1 warp affine, 0.3 prob of application: Valid Accuracy: `67.4%`\n", "* 2 warp affines, 0.3 prob of application: Valid Accuracy: `71.6%`\n", "* 3 warp affines, 0.3 prob of application: Valid Accuracy: `72.6%`\n", "* 4 warp affines, 0.3 prob of application: Valid Accuracy: `64.0%`\n", "* 5 warp affines, 0.3 prob of application: Valid Accuracy: `67.0%`\n", "---\n", "\n", "**Conclusion:** The above results confirm my intuition that applying a diversity of warp affines to various images is good. But applying multiple warp affines to the same image is bad.\n", "\n", "The unmistakable trend is that as I lower the probability that an individual affine transform gets called on an image, the validation accuracy tends to improve. Only 1-2 of my experiments at the 0.1 and 0.2 probability levels had a validation accuracy that exceeded that of the baseline. However, as I lowered the probability, first to 0.05, and then to 0.025, I saw an increasing portion of experiments reach a validation accuracy that bested the baseline. At the 0.025 probability level, 65% (13 out of 20) of experiments beat the baseline. The question remains, how many affine transforms should I include in the augmentation pipeline? Although the best performance (76.6% validation accuracy) was reached when 5 warp transforms were used, this wasn't terribly different from higher amounts of, say, 11 warp transforms (74.8% validation accuracy), and of even only 1 warp transform (74.2% validation accuracy). \n", "\n", "Additionally, I noticed that adding several (around 20) warp affine operations to the pipeline seems to make images really jittery -- I hypothesize that this is because these particular images got warp-affined over and over. For example, some of the images below (upper right-hand and upper left-hand images, for e.g.) appear to have had multiple warp affine transforms applied to them. These images came from a batch used under approach #1 with 20 warp affine transforms in the pipeline, each with a 0.1 probability of being applied to an image:\n", "Several successive warp transforms\n", "\n", "#### DALI warp affine experiment 3: Choosing the best \"synthetic random\" warp affine:\n", "This is the final half of my grid search competition. I take the top-four performers from the experiment above, which all had a probability of 0.025, and pit them against my baseline (where no warp affines are applied), as well as against a pipeline where I only use a single DALI warp affine that applies *the same* warp affine transform to each image at a probability of 0.025. I do this because I want to rule out the possibility that the default DALI warp affine (where only one affine transform is used throughout the entire training cycle) actually does work better than my \"synthetic random\" workaround.\n", "\n", "This time, I perform ten runs for each option and pick the winner based on the average validation accuracy across all ten runs.\n", "\n", "|Run|Baseline (no warp affines)|1 warp affine, 0.025 prob|2 warp affines, 0.025 prob|5 warp affines, 0.025 prob|**7 warp affines, 0.025 prob**|11 warp affines, 0.025 prob|\n", "---|---|---|---|---|---|---|\n", "1|72.0%|74.0%|71.6%|74.2%|**69.8%**|71.8%\n", "2|72.6%|73.4%|71.8%|70.2%|**71.6%**|71.8%\n", "3|73.4%|67.8%|72.8%|71.8%|**71.8%**|69.8%\n", "4|70.6%|70.2%|69.4%|65.4%|**70.4%**|67.6%\n", "5|72.0%|76.6%|71.4%|72.2%|**74.4%**|71.2%\n", "6|73.2%|71.2%|74.2%|72.0%|**72.2%**|70.8%\n", "7|70.6%|74.4%|72.2%|71.8%|**72.8%**|73.0%\n", "8|74.0%|71.2%|72.8%|72.8%|**73.8%**|74.0%\n", "9|70.8%|69.2%|73.2%|75.6%|**76.0%**|73.6%\n", "10|67.8%|71.8%|70.4%|72.2%|**72.2%**|71.2%\n", "Avg|71.7%|71.98%|71.98%|71.82%|**72.5%**|71.48%\n", "\n", "**Conclusion:** 7 consecutive warp affine transforms, each with a 0.025 probability of being applied to any image input is the winner, clocking in with an average 10-training-run validation accuracy score of `72.5%`. This will serve as my new baseline, which I will attempt to boost even higher by first adding in a rotation transform, and then finally, a vertical flip.\n", "\n", "### Rotation transform experiments: finding a good rotation transform\n", "Unlike warp affine transforms, [rotation transforms](https://docs.nvidia.com/deeplearning/sdk/dali-developer-guide/docs/supported_ops.html#nvidia.dali.ops.Rotate) in DALI do allow a randomly chosen angle of rotation to be applied on a per-image basis. All I have to do is choose the angular range, as well as the probability that the rotation transform will be applied an input image. Ordinarily I'd choose a angle range of [-30, 30] degrees, applied with 0.5 probability. However, since DALI doesn't support reflection padding, I'm concerned about rotating images to excessively large angles, as this would cause output images to have large black triangles in their four corners. To compensate, I began by trying out a smaller range of [-10, 10] degrees with a lower probability, 0.3, that the rotation transform would be applied.\n", "\n", "Ufortunately, this didn't result in an improvement over an updated baseline that now includes my \"synthetic random\" warp affine transform. Nonetheless, after some extensive poking and prodding, I was finally able to locate an angular range and probability that gave a slight boost to my baseline score.\n", "\n", "The columns in the chart below appear in an order, left-to-right, that matches the order in which I undertook each experiment:\n", "\n", "|Run|Baseline (no rotation)|Angle range: [-10,10], 0.3 prob|Angle range: [-15,15], 0.3 prob|Angle range: [-15,15], 0.2 prob|Angle range: [-20,20], 0.1 prob|Angle range: [-30,30], 0.5 prob|Angle range: [-7,7], 0.1 prob|Angle range: [-7,7], 0.2 prob|**Angle range: [-7,7], 0.075 prob**|\n", "---|---|---|---|---|---|---|---|---|---|\n", "1|69.8%|69.6%|73.6%|71.6%|69.8%|68.4%|70.0%|72.0%|**72.0%**|\n", "2|71.6%|71.0%|72.4%|74.0%|74.6%|74.6%|73.0%|73.4%|**74.0%**|\n", "3|71.8%|71.8%|70.6%|72.4%|70.0%|70.0%|72.8%|73.6%|**72.6%**|\n", "4|70.4%|69.6%|70.4%|70.2%|68.8%|66.6%|69.4%|69.6%|**71.8%**|\n", "5|74.4%|71.8%|70.2%|71.0%|67.2%|71.6%|71.2%|72.0%|**72.0%**|\n", "6|72.2%|71.6%|71.2%|68.6%|70.6%|71.4%|71.8%|71.2%|**76.2**|\n", "7|72.8%|75.8%|75.0%|73.4%|72.8%|72.4%|75.4%|72.4%|**72.6%**|\n", "8|73.8%|72.2%|71.8%|74.0%|73.0%|66.0%|74.4%|72.2%|**72.0%**|\n", "9|76.0%|72.6%|74.2%|75.0%|74.8%|71.8%|76.2%|71.0%|**71.2%**|\n", "10|72.2%|72.0%|69.2%|66.2%|69.8%|71.2%|70.4%|74.8%|**72.0%**|\n", "Avg|72.5%|71.80%|71.86%|71.64%|71.14%|70.40%|72.46%|72.22%|**72.64%**|\n", "\n", "**Conclusion:** Mercifully, the pair of an angular range of [-7,7] and 0.075 probability that I finally happened upon in my eighth experiment bumped my 10-run average validation accuracy score ever so slightly. The 0.14 percentage point increase is slight enough to make me suspicious that the increase may well be due to randomness, as opposed to any benefit provided by these sparingly applied, minimal rotation augmentations.\n", "\n", "Nonetheless, the goal of my journey through DALI is simply to illustrate *how* to implement its various image transforms. As long as adding rotation doesn't meaningfully decrease my model's performance, I'm satisfied. I do, however, hypothesize that a possible reason that larger and more frequent rotations result in subpar performance is because [DALI's rotation transform](https://docs.nvidia.com/deeplearning/sdk/dali-developer-guide/docs/supported_ops.html#rotate) doesn't support any form of reflection padding. At best, you can specify a single color value, the `fill_value`, that will be used to the pad empty pixels found in image corners after a rotation. It's great that I'm not forced to use black padding, but I'm skeptical that using, say, all green or all white padding would result in any meaningful bump to the resulting model performance.\n", "\n", "### Vertical flip transform experiments\n", "My final task was to demonstrate how to add a vertical flip augmentation. I had initially intended that vertical flips would be the second-to-last operation in my pipeline, immediately preceding the horizontal flips that are applied inside the `ops.CropMirrorNormalize` [operation](https://docs.nvidia.com/deeplearning/sdk/dali-developer-guide/docs/supported_ops.html#cropmirrornormalize). The only parameter to choose here is the probability that a flip will be applied. I began with 50%, which is same probability with which my model applies a horizonal mirror transform.\n", "\n", "Below are the experiments I ran. As with the rotation experiments above, the left-to-right column order mirrors the order in which I ran the experiments:\n", "\n", "|Run|Baseline (no vertical flip)|0.5 prob; apply *after* warp affine tfms|0.2 prob; apply *after* warp affine tfms|0.1 prob; apply *after* warp affine tfms|0.05 prob; apply *after* warp affine tfms|0.025 prob; apply *after* warp affine tfms|0.0125 prob; apply *after* warp affine tfms|**0.1 prob; apply *before* warp affine tfms**|\n", "---|---|---|---|---|---|---|---|---|\n", "1|72.0%|66.6%|69.6%|73.2%|69.8%|68.0%|73.8%|**70.4%**|\n", "2|74.0%|68.2%|71.0%|72.8%|70.8%|72.0%|73.6%|**75.0%**|\n", "3|72.6%|69.2%|71.6%|69.6%|73.8%|73.4%|73.2%|**75.6%**|\n", "4|71.8%|67.0%|68.2%|67.2%|69.4%|70.4%|70.8%|**69.4%**|\n", "5|72.0%|64.4%|72.8%|70.6%|72.2%|70.0%|70.6%|**73.4%**|\n", "6|76.2%|68.0%|69.6%|69.4%|71.8%|75.0%|73.4%|**73.4%**|\n", "7|72.6%|68.2%|73.4%|74.2%|75.4%|73.6%|72.2%|**73.4%**|\n", "8|72.0%|70.4%|70.8%|72.6%|69.6%|73.8%|72.0%|**69.6%**|\n", "9|71.2%|70.0%|71.0%|71.8%|73.6%|74.6%|74.0%|**74.8%**|\n", "10|72.0%|68.6%|66.8%|72.4%|72.2%|72.6%|71.6%|**72.2%**|\n", "Avg|72.64%|68.06%|70.48%|71.38%|71.86%|72.34%|72.52%|**72.72%**|\n", "\n", "The trend up until just before my final experiment was unmistakable: the less vertical flips, the better the model's performance. I was about to call it a day and give up on vertical flips when I began to wonder if perhaps placing the vertical flip transform earlier in the pipeline would improve things. Although I couldn't work out a reason for myself why the order in which transforms are applied to input images *should* matter, I decided to run just one more experiment, with vertical transforms being applied *before* the warp and rotation transforms, and at a much higher probability (0.1) than I'd been using in my most recent few vertical flip experiments. \n", "\n", "**Conclusion:** Lo and behold, doing this led to a 0.1 percentage point improvement over my baseline. More significantly, however, it was a 1.34 percentage point improvement (or 1.9% increase) over the average validation accuracy I saw when including vertical flips with 0.1 probability *after* the warp affine and rotation transforms.\n", "\n", "### Bonus: horizontal flip transform experiment\n", "The jump in performance that I saw after relocating vertical transforms to a position much earlier in my pipeline was enough to make me wonder if maybe the order in which augmentations are applied somehow *does* matter, at least for the Imagenette dataset. Just for grins, I decided to run one final experiment, this time, also relocating my horizontal flip operation to a position much earlier in the pipeline so that it would precede the warp affine and rotation transforms. (Recall that I had been applying horizontal flips at the end of the augmentation pipeline, inside the `ops.CropMirrorNormalize` operation.):\n", "\n", "|Run|**Baseline (horizontal flip *after* warp affine and rotation tfms)**|Horizontal flip *before* warp affine and rotation tfms|\n", "---|---|---|\n", "1|**70.4%**|71.4%|\n", "2|**75.0%**|68.2%|\n", "3|**75.6%**|70.8%|\n", "4|**69.4%**|61.2%|\n", "5|**73.4%**|70.6%|\n", "6|**73.4%**|73.6%|\n", "7|**73.4%**|74.6%|\n", "8|**69.6%**|70.6%|\n", "9|**74.8%**|71.6%|\n", "10|**72.2%**|71.6%|\n", "Avg|**72.72%**|70.42%|\n", "\n", "**Conclusion:** Interestingly, when relocating horizontal flips so that they, too, precede the warp affine and rotation transforms, I see a 2.3 percentage point drop-off in average validation accuracy. This would seem to indicate the opposite of what the results of my vertical transform relocation experiment indicated.\n", "\n", "All in all, these results may well indicate nothing more than pure random variation. My own reasoning, after all, still tells me that order ought not to matter. I suppose that to better understand whether it is more advantageous to have flips at the beginning of the augmentation pipeline or toward its end, I would need to run experiments with durations longer than ten independent training cycles. I'll save such an exploration for a later day.\n", "\n", "The [cell](http://nbviewer.jupyter.org/github/jamesdellinger/fastai_deep_learning_course_part2_v3/blob/master/Diving_into_DALI.ipynb?flush_cache=true#Train-and-Val-Pipelines) in this notebook that holds my training pipeline contains the operations and paramters that produced my highest average 10-run validation accuracy score of `72.72%`." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### DALI's Most Glaring Deficiency\n", "I'd like to wrap up this dive through the DALI library by spending some time on what I believe is the library's most notable shortcoming: *not all* of its image transform operations are capable of generating randomized outputs. I found this to be particularly ironic in light of the fact that the DALI website [devotes an entire section](https://docs.nvidia.com/deeplearning/sdk/dali-master-branch-user-guide/docs/examples/getting%20started.html#Tensors-as-arguments-and-Random-Number-Generation) to preaching the benefits of image augmentations that *are* able to randomly perturb input images. Said section touts the ability of DALI's image rotation transform to rotate each image by an angle randomly chosen from a specified range, stating:\n", "\n", ">\"Rotating every image by 10 degrees is not that interesting. To make a meaningful augmentation, we would like an operator that rotates our images by a random angle in a given range.\"\n", "\n", "I suppose that DALI's [warp affine image transform](https://docs.nvidia.com/deeplearning/sdk/dali-developer-guide/docs/supported_ops.html#nvidia.dali.ops.WarpAffine) should thus be deemed \"not that interesting\" by virtue of the fact that it does not allow for the random generation (within specified constraints) of image perspective warps. But what's even more frustrating is that, though I [wrote my own logic](http://nbviewer.jupyter.org/github/jamesdellinger/fastai_deep_learning_course_part2_v3/blob/master/Diving_into_DALI.ipynb?flush_cache=true#Generating-random-affine-transforms-for-image-perspective-warps) to randomly generate affine transforms and then format them according to the convention expected by the `matrix` parameter of DALI's warp affine operation, there was absolutely *no way* that I could coax my DALI pipeline to execute this logic for a mini-batch's images at runtime.\n", "\n", "Unsurprisingly, someone [requested support](https://github.com/NVIDIA/DALI/issues/552) for randomized warp affines but a DALI team member [explained](https://github.com/NVIDIA/DALI/issues/552#issuecomment-465568041) that warp affine isn't currently a priority, as the team is focused *\"on providing operators that are used in the most common networks.\"* Now, as someone who was a software product manager in another life, I'm certainly sympathetic to the idea of prioritizing features. However, seeing as how the DALI team wasn't too hesitant to be [loud and proud](https://docs.nvidia.com/deeplearning/sdk/dali-master-branch-user-guide/docs/examples/getting%20started.html#Tensors-as-arguments-and-Random-Number-Generation) about the benefits of randomized image rotations, it's hard for me to see how randomized warp affines *couldn't* be a priority.\n", "\n", "Now that said, one saving grace was that the DALI team member [did encourage](https://github.com/NVIDIA/DALI/issues/552#issuecomment-465568041) open source contributions to make up this feature deficit. This is a good thing, and if I knew more C++ I could see myself porting my [random affine transform logic](http://nbviewer.jupyter.org/github/jamesdellinger/fastai_deep_learning_course_part2_v3/blob/master/Diving_into_DALI.ipynb?flush_cache=true#Generating-random-affine-transforms-for-image-perspective-warps) and submitting a pull request. But I doubt I'll be trying to improve my C++ anytime soon. It's now 2019 and I'm skeptical that C++ will be relevant for deep learning in five years' time. It may well be a better investment to spend time [focusing on Swift](https://www.tensorflow.org/swift), but that's a discussion for another post.\n", "\n", "### \"Synthetic Random\" Warp Affine Transforms\n", "Nonetheless, as I mentioned earlier I wasn't content to omit perspective warps from my augmentation pipeline, nor was I content to limit myself to applying the same single, solitary warp affine transform to any image in any batch. After trying and failing to include logic in my training pipeline that would randomize the affine transform used by DALI's warp operation from one image to the next, I decided to try out an admittedly unconventional workaround that popped into my brain, which I've taken to calling a \"synthetic random\" warp affine transform. Here's how it works:\n", "\n", "1. Write [a function](http://nbviewer.jupyter.org/github/jamesdellinger/fastai_deep_learning_course_part2_v3/blob/master/Diving_into_DALI.ipynb?flush_cache=true#Generating-random-affine-transforms-for-image-perspective-warps) that generates random affine transformations, formatted so that the transform can be passed to DALI's `ops.WarpAffine` [operation](https://docs.nvidia.com/deeplearning/sdk/dali-developer-guide/docs/supported_ops.html#nvidia.dali.ops.WarpAffine). My algorithm ensures that a randomly generated affine transform will tilt an image's perspective, but won't unnaturally squish or stretch the contents of the image.\n", "2. Add somewhere between two and twenty DALI `ops.WarpAffine` operations to my pipeline. (I performed experiments to determine the right amount and found that seven worked best.)\n", "3. Generate a unique affine transformation for each DALI `ops.WarpAffine` operation that I include in my pipeline.\n", "4. Apply each of the pipeline's warp affine transforms to a particular image with a probability somewhere between 0.3 and 0.025. (I performed experiments to determine the best probability and found that 0.025 worked best.)\n", "\n", "My intuition was that with an adequately chosen number of warp affine operations, balanced with a suitable probability that each operation would be applied, I could:\n", "1. Maximize the *variety* of perspective warp transforms applied to a mini-batch's images.\n", "2. Adequately minimize the chance that a single image would have two or more warp transforms applied to it during each mini-batch.\n", "\n", "By way of a sequence of experiments that are [chronicled in my notebook](http://nbviewer.jupyter.org/github/jamesdellinger/fastai_deep_learning_course_part2_v3/blob/master/Diving_into_DALI.ipynb?flush_cache=true#%22Lab-Notebook%22-for-my-DALI-Transform-Explorations:), I found that including seven consecutive warp affine transforms, each with a 0.025 probability of being applied to any image in a batch, brought about the largest increase in average validation accuracy over ten runs. This regime's performance exceeded that of a baseline that didn't contain any warp affine transforms. My \"synthetic random\" warp affines also bested a pipeline that contained just one warp transform that tilted any image in all batches exactly the same way, which would seem to be how DALI currently expects practitioners to use this operation. \n", "\n", "Notably, one plus throughout all of this was, again, DALI's speed: adding an extra two, or twenty, warp affine operations to my pipeline didn't appreciably lengthen the time it took to run each mini-batch through the pipeline.\n", "\n", "Please also know that I don't write about my \"synthetic random\" warp transform with any intent that other practitioners would try a similar approach. Rather, I hope to express that to whatever extent my workaround may indeed seem unconventional, the fact that DALI's warp transfrom doesn't support random parameters is *similarly* unconventional.\n", "\n", "### Three Smaller Quibbles\n", "1. Prospective DALI users, especially folks who've gotten used to the dynamic nature of PyTorch, should expect a decidedly *static* TensorFlow v1.0-like experience. The DALI team definitely wasn't kidding around when they named the Pipeline class' core method *define_graph*, so don't expect to be able to define and run any custom modifications to DALI's operations inside `define_graph()`, which is what I first attempted when trying to add randomness to DALI's warp affine transform. Instead, the current [recommended approach](https://docs.nvidia.com/deeplearning/sdk/dali-developer-guide/docs/examples/extend/create_a_custom_operator.html) is to create your own custom C++ operator and load it at runtime. This certainly doesn't strike me as \"flexible,\" and hopefully DALI will expand its breadth of augmentation options, which should obviate the need for practitioners to create custom ops.\n", "\n", "2. Speaking of which, DALI lacks support for reflection padding. My hypothesis is that this is a big reason that adding rotation transforms to my pipeline didn't improve model performance until I curtailed the range of my rotation angle from [-30,30] degrees to within [-7,7] degrees. In lieu of reflection padding DALI does allow practitioners to specify a single color value that will be used to the pad empty pixels found in image corners after a rotation. However, while It's great that I'm not forced to use black padding, I'm skeptical that using, say, all green or all white padding would result in any meaningful bump in my model's performance.\n", "\n", "3. I had intended to center crop and then resize validation set images. While DALI's `ops.Crop` [operation](https://docs.nvidia.com/deeplearning/sdk/dali-developer-guide/docs/supported_ops.html#nvidia.dali.ops.Crop) allows us to set the coordinates of the crop-window's upper left-hand corner relative to any input image's width and height, there doesn't appear to be any way to make the width and height of the cropping window also scale relative to each input image's width and height. \n", " \n", "### In Conclusion\n", "DALI offers a concise Python API that plays nice with PyTorch, TensorFlow, and with just three tweaks, also works swimmingly with what's shaping up to be the training loop that'll in the upcoming version 2 of the fastai library. By running image augmentations in parallel using GPU-optimized code, DALI more than delivers on its promise of speed, and obviates the need for several-line [JIT scripts](https://nbviewer.jupyter.org/github/jamesdellinger/fastai_deep_learning_course_part2_v3/blob/master/10_augmentation_my_reimplementation.ipynb?flush_cache=true#Time-Budget), which was the only other way I personally knew how to get image augmentations running in batches on the GPU. Unfortunately, not all DALI image transforms support randomization, which is a feature that ironically even the DALI team [acknowledges](https://docs.nvidia.com/deeplearning/sdk/dali-master-branch-user-guide/docs/examples/getting%20started.html#Tensors-as-arguments-and-Random-Number-Generation) is a must-have. While DALI [claims](https://docs.nvidia.com/deeplearning/sdk/dali-developer-guide/docs/examples/getting%20started.html) to be flexible, my attempt to build randomness into DALI's warp affine operation revealed that this supposed flexibility is really only available to folks willing and able to go in and subclass C++ classes. In 2019 I'm not sure that having to go dink and dunk with C++ can still be termed \"flexible.\"\n", "\n", "Even so, though DALI's lack of certain features may make it harder for final versions of my models to reach SOTA or climb a Kaggle leaderboard, I still plan to make the DALI library a daily part of my model prototyping workflow. DALI is easy to use and runs fast. After all, augmenting images in batches on the GPU just saves so much time! I'm hopeful that the library will continue to fill in its gaps and improve. \n", "\n", "### References\n", "1. Feel free to view [the notebook](http://nbviewer.jupyter.org/github/jamesdellinger/fastai_deep_learning_course_part2_v3/blob/master/Diving_into_DALI.ipynb?flush_cache=true) where I experimented with the pipeline discussed in this article.\n", "2. The PyTorch ImageNet training [example](https://github.com/NVIDIA/DALI/blob/666ce55ec27783f36f2b7a39076793d955d4ad0f/docs/examples/pytorch/resnet50/main.py) on DALI's GitHub page, created by [Janusz Lisiecki](https://github.com/JanuszL), [Joaquin Anton](https://github.com/jantonguirao), and [Cliff Woolley](https://github.com/cliffwoolley), was indispensable as a template for helping me figure out how to write my own training & validation pipeline classes from scratch." ] } ], "metadata": { "kernelspec": { "display_name": "Python 3", "language": "python", "name": "python3" }, "language_info": { "codemirror_mode": { "name": "ipython", "version": 3 }, "file_extension": ".py", "mimetype": "text/x-python", "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", "version": "3.7.1" } }, "nbformat": 4, "nbformat_minor": 2 }