core.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#|default_exp core"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#|export\n",
    "import sys, gc, traceback, math, typing, random, numpy as np\n",
    "from collections.abc import Mapping\n",
    "from copy import copy\n",
    "from itertools import zip_longest\n",
    "from functools import partial, wraps\n",
    "from operator import attrgetter, itemgetter\n",
    "\n",
    "import matplotlib.pyplot as plt\n",
    "import fastcore.all as fc\n",
    "from fastprogress import progress_bar, master_bar\n",
    "\n",
    "import torch, torch.nn.functional as F\n",
    "from torch import nn, optim\n",
    "from torch.utils.data import DataLoader\n",
    "from torch.optim.lr_scheduler import ExponentialLR\n",
    "from torch.utils.data import default_collate\n",
    "\n",
    "from torcheval.metrics import Mean"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#|export\n",
    "try: from accelerate import Accelerator\n",
    "except: Accelerator=None"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from torcheval.metrics import  MulticlassAccuracy"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Introduction"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This is the core functionality of the training framework developed interactively in the most recent FastAI course ('Impractical Deep Learning for Coders'). It is built on top of ideas from the fastai library, but is more flexible, and simpler."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#| export\n",
    "def set_seed(seed, deterministic=False):\n",
    "    torch.use_deterministic_algorithms(deterministic)\n",
    "    torch.manual_seed(seed)\n",
    "    random.seed(seed)\n",
    "    np.random.seed(seed)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# For reproducibility\n",
    "import os\n",
    "\n",
    "os.environ['CUBLAS_WORKSPACE_CONFIG']=':4096:8'\n",
    "set_seed(42, True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Datasets and Dataloaders"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from datasets import load_dataset\n",
    "import torchvision.transforms.v2.functional as TF"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "ds = load_dataset('fashion_mnist')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "trn = ds['train']\n",
    "val = ds['test']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Dataset({\n",
       "    features: ['image', 'label'],\n",
       "    num_rows: 60000\n",
       "})"
      ]
     },
     "execution_count": null,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "trn"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A dataset needs to match the PyTorch dataset interface, which is very simple. It needs to have a `__len__` method, and a `__getitem__` method. The `__getitem__` method typically returns a tuple of (x, y) where x is the input and y is the target."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#|export\n",
    "class Dataset():\n",
    "    \"Simple dataset that combines two collections\"\n",
    "    def __init__(self, x, y): self.x,self.y = x,y\n",
    "    def __len__(self): return len(self.x)\n",
    "    def __getitem__(self, i): return self.x[i],self.y[i]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A dataset can optionally include transformation functions."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#|export\n",
    "class TfmDataset(Dataset):\n",
    "    \"Dataset subclass that transforms items\"\n",
    "    def __init__(self, x, y, tfm_x=None, tfm_y=None):\n",
    "        super().__init__(x,y)\n",
    "        self.tfm_x,self.tfm_y = tfm_x,tfm_y\n",
    "        \n",
    "    def __getitem__(self, i):\n",
    "        x,y = self.x[i],self.y[i]\n",
    "        return self.tfm_x(x) if self.tfm_x else x, self.tfm_y(y) if self.tfm_y else y"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "trn_ds = TfmDataset(trn['image'], trn['label'], tfm_x=TF.to_tensor)\n",
    "val_ds = TfmDataset(val['image'], val['label'], tfm_x=TF.to_tensor)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#|export\n",
    "def get_dls(train_ds, valid_ds, bs, **kwargs):\n",
    "    \"Convert train and validation datasets to data loaders\"\n",
    "    return (DataLoader(train_ds, batch_size=bs, shuffle=True, **kwargs),\n",
    "            DataLoader(valid_ds, batch_size=bs*2, **kwargs))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "bs = 1024\n",
    "trn_dl,val_dl = get_dls(trn_ds, val_ds, bs=bs)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/galopy/miniforge3/lib/python3.10/site-packages/torchvision/transforms/v2/functional/_deprecated.py:12: UserWarning: The function `to_tensor(...)` is deprecated and will be removed in a future release. Instead, please use `to_image(...)` followed by `to_dtype(..., dtype=torch.float32, scale=True)`.\n",
      "  warnings.warn(\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "(torch.Size([1024, 1, 28, 28]), tensor([5, 7, 4, 7, 3, 8, 9, 5, 3, 1]))"
      ]
     },
     "execution_count": null,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "xb,yb = next(iter(trn_dl))\n",
    "xb.shape,yb[:10]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Huggingface datasets typically return dictionaries, so here's a collate function to handle them:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#|export \n",
    "def collate_dict(ds):\n",
    "    get = itemgetter(*ds.features)\n",
    "    def _f(b): return get(default_collate(b))\n",
    "    return _f"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can transform these dict-style datasets using `with_transform`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def transforms(b):\n",
    "    b['image'] = [TF.to_tensor(o)*2-1 for o in b['image']]\n",
    "    return b"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "tds = ds.with_transform(transforms)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#|export\n",
    "class DataLoaders:\n",
    "    \"Convert a `DatasetDict` into a pair of `DataLoader`s\"\n",
    "    def __init__(self, *dls): self.train,self.valid = dls[:2]\n",
    "\n",
    "    @classmethod\n",
    "    def from_dd(cls, dd, batch_size, as_tuple=True, **kwargs):\n",
    "        f = collate_dict(dd['train'])\n",
    "        return cls(*get_dls(*dd.values(), bs=batch_size, collate_fn=f))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can recreate the same `DataLoader`s as before using this:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "dls = DataLoaders.from_dd(tds, batch_size=bs)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(torch.Size([1024, 1, 28, 28]), tensor([1, 8, 6,  ..., 4, 2, 8]))"
      ]
     },
     "execution_count": null,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "xb,yb = next(iter(dls.train))\n",
    "xb.shape,yb"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Utilities for Displaying Images"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We often work with images - this section has some convenient utilities for displaying them. At some point I'll add some examples :)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#| export\n",
    "@fc.delegates(plt.Axes.imshow)\n",
    "def show_image(im, ax=None, figsize=None, title=None, noframe=True, **kwargs):\n",
    "    \"Show a PIL or PyTorch image on `ax`.\"\n",
    "    if fc.hasattrs(im, ('cpu','permute','detach')):\n",
    "        im = im.detach().cpu()\n",
    "        if len(im.shape)==3 and im.shape[0]<5: im=im.permute(1,2,0)\n",
    "    elif not isinstance(im,np.ndarray): im=np.array(im)\n",
    "    if im.shape[-1]==1: im=im[...,0]\n",
    "    if ax is None: _,ax = plt.subplots(figsize=figsize)\n",
    "    ax.imshow(im, **kwargs)\n",
    "    if title is not None: ax.set_title(title)\n",
    "    ax.set_xticks([]) \n",
    "    ax.set_yticks([]) \n",
    "    if noframe: ax.axis('off')\n",
    "    return ax"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#| export\n",
    "@fc.delegates(plt.subplots, keep=True)\n",
    "def subplots(\n",
    "    nrows:int=1, # Number of rows in returned axes grid\n",
    "    ncols:int=1, # Number of columns in returned axes grid\n",
    "    figsize:tuple=None, # Width, height in inches of the returned figure\n",
    "    imsize:int=3, # Size (in inches) of images that will be displayed in the returned figure\n",
    "    suptitle:str=None, # Title to be set to returned figure\n",
    "    **kwargs\n",
    "): # fig and axs\n",
    "    \"A figure and set of subplots to display images of `imsize` inches\"\n",
    "    if figsize is None: figsize=(ncols*imsize, nrows*imsize)\n",
    "    fig,ax = plt.subplots(nrows, ncols, figsize=figsize, **kwargs)\n",
    "    if suptitle is not None: fig.suptitle(suptitle)\n",
    "    if nrows*ncols==1: ax = np.array([ax])\n",
    "    return fig,ax"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#| export\n",
    "@fc.delegates(subplots)\n",
    "def get_grid(\n",
    "    n:int, # Number of axes\n",
    "    nrows:int=None, # Number of rows, defaulting to `int(math.sqrt(n))`\n",
    "    ncols:int=None, # Number of columns, defaulting to `ceil(n/rows)`\n",
    "    title:str=None, # If passed, title set to the figure\n",
    "    weight:str='bold', # Title font weight\n",
    "    size:int=14, # Title font size\n",
    "    **kwargs,\n",
    "): # fig and axs\n",
    "    \"Return a grid of `n` axes, `rows` by `cols`\"\n",
    "    if nrows: ncols = ncols or int(np.floor(n/nrows))\n",
    "    elif ncols: nrows = nrows or int(np.ceil(n/ncols))\n",
    "    else:\n",
    "        nrows = int(math.sqrt(n))\n",
    "        ncols = int(np.floor(n/nrows))\n",
    "    fig,axs = subplots(nrows, ncols, **kwargs)\n",
    "    for i in range(n, nrows*ncols): axs.flat[i].set_axis_off()\n",
    "    if title is not None: fig.suptitle(title, weight=weight, size=size)\n",
    "    return fig,axs"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#| export\n",
    "@fc.delegates(subplots)\n",
    "def show_images(ims:list, # Images to show\n",
    "                nrows:typing.Union[int, None]=None, # Number of rows in grid\n",
    "                ncols:typing.Union[int, None]=None, # Number of columns in grid (auto-calculated if None)\n",
    "                titles:typing.Union[list, None]=None, # Optional list of titles for each image\n",
    "                **kwargs):\n",
    "    \"Show all images `ims` as subplots with `rows` using `titles`\"\n",
    "    axs = get_grid(len(ims), nrows, ncols, **kwargs)[1].flat\n",
    "    for im,t,ax in zip_longest(ims, [] if titles is None else titles, axs): show_image(im, ax=ax, title=t)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "plt.rcParams['image.cmap'] = 'gray_r'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "feat = fc.nested_attr(dls, 'train.dataset.features')\n",
    "names = feat['label'].names\n",
    "titles = [names[i] for i in yb]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 300x400 with 9 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "show_images(xb[:9], titles=titles[:9], figsize=(3,4));"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Device management"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Convenience functions related to device management. Note that if you do `from minai import *`  then def_device will be defined and will be used as the default in functions like to_device() unless you specify otherwise."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#|export\n",
    "def_device = 'mps' if torch.backends.mps.is_available() else 'cuda' if torch.cuda.is_available() else 'cpu'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#|export\n",
    "def to_device(x, device=def_device):\n",
    "    if isinstance(x, torch.Tensor): return x.to(device)\n",
    "    if isinstance(x, Mapping): return {k:v.to(device) for k,v in x.items()}\n",
    "    return type(x)(to_device(o, device) for o in x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#|export\n",
    "def to_cpu(x):\n",
    "    if isinstance(x, Mapping): return {k:to_cpu(v) for k,v in x.items()}\n",
    "    if isinstance(x, list): return [to_cpu(o) for o in x]\n",
    "    if isinstance(x, tuple): return tuple(to_cpu(list(x)))\n",
    "    return x.detach().cpu()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#|export\n",
    "def collate_device(b): return to_device(default_collate(b))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## The Learner "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The core of miniai is the Learner class. It binds together model, dataloaders, loss function and so on. The goal is to handle everything required for training a model while still providing complete control over any of the steps involved. This is done by leaning heavily on callbacks. \n",
    "\n",
    "It may be instructive here to look at how a single batch is processed (code from the Learner definition below):\n",
    "\n",
    "```python\n",
    "@with_cbs('batch')\n",
    "def _one_batch(self):\n",
    "    self.predict()\n",
    "    self.callback('after_predict')\n",
    "    self.get_loss()\n",
    "    self.callback('after_loss')\n",
    "    if self.training:\n",
    "        self.backward()\n",
    "        self.callback('after_backward')\n",
    "        self.step()\n",
    "        self.callback('after_step')\n",
    "        self.zero_grad()\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The `@with_cbs('batch')` decorator means that any of the models callbacks that define a `before_batch` or `after_batch` method will have said method called when appropriate. This allows you to do things like pre-process a batch of data before the model sees it, or log the loss after the batch has been processed. Within the `_one_batch` method, five special functions are called (predict, get_loss, backward, step, zero_grad). These are the five steps that are required for training a model. There are additional points where callbacks can be called, for example after the loss has been calculated but before the model has been updated. \n",
    "\n",
    "The default Learner doesn't even define these methods - instead, it looks to see if they are defined in any of its callbacks. If you're not planning on doing anything fancy, then TrainCB is all you need. It defines all of the methods above. Alternatively, you can use `TrainLearner` which is a subclass of Learner that defines all of the methods above.\n",
    "\n",
    "What's the point? These choices mean that if you're just fitting a basic model then you can use TrainLearner or TrainCB and you don't need to worry about any of the details. BUT if you do want to go in and add something fancy, you now have that option. Need a custom step to modify gradients before they are applied? No problem - re-define the step method. Need to make sure everything is on the right device before calling the model? No problem - check out DeviceCB to see how easy it is to do this! "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Callback Infrastructure"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#|export\n",
    "class CancelFitException(Exception): pass\n",
    "class CancelBatchException(Exception): pass\n",
    "class CancelEpochException(Exception): pass"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#|export\n",
    "class Callback(): order = 0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#|export\n",
    "def run_cbs(cbs, method_nm, learn=None):\n",
    "    for cb in sorted(cbs, key=attrgetter('order')):\n",
    "        method = getattr(cb, method_nm, None)\n",
    "        if method is not None: method(learn)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#|export\n",
    "class with_cbs:\n",
    "    def __init__(self, nm): self.nm = nm\n",
    "    def __call__(self, f):\n",
    "        def _f(o, *args, **kwargs):\n",
    "            try:\n",
    "                o.callback(f'before_{self.nm}')\n",
    "                f(o, *args, **kwargs)\n",
    "                o.callback(f'after_{self.nm}')\n",
    "            except globals()[f'Cancel{self.nm.title()}Exception']: pass\n",
    "            finally: o.callback(f'cleanup_{self.nm}')\n",
    "        return _f"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Learner class and friends"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#|export\n",
    "from itertools import cycle"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#|export\n",
    "class CycleDL():\n",
    "    def __init__(self, items, sz=None):\n",
    "        self.items = items\n",
    "        self.sz = len(items) if sz is None else sz\n",
    "        self.it = None\n",
    "\n",
    "    def __len__(self): return len(self.items) if self.sz is None else self.sz\n",
    "    def __iter__(self):\n",
    "        if self.it is None: self.it = cycle(iter(self.items))\n",
    "        for i in range(self.sz): yield next(self.it)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[[0, 1, 2], [3, 4, 5], [6, 7, 8], [9, 0, 1], [2, 3, 4]]"
      ]
     },
     "execution_count": null,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "d = CycleDL(range(10), 3)\n",
    "[list(d) for _ in range(5)]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#|export\n",
    "class Learner():\n",
    "    def __init__(self, model, dls=(0,), loss_func=F.mse_loss, lr=0.1, cbs=None, opt_func=optim.SGD, epoch_sz=None):\n",
    "        cbs = fc.L(cbs)\n",
    "        fc.store_attr()\n",
    "\n",
    "    @with_cbs('batch')\n",
    "    def _one_batch(self):\n",
    "        self.predict()\n",
    "        self.callback('after_predict')\n",
    "        self.get_loss()\n",
    "        self.callback('after_loss')\n",
    "        if self.training:\n",
    "            self.backward()\n",
    "            self.callback('after_backward')\n",
    "            self.step()\n",
    "            self.callback('after_step')\n",
    "            self.zero_grad()\n",
    "\n",
    "    @with_cbs('epoch')\n",
    "    def _one_epoch(self):\n",
    "        for self.iter,self.batch in enumerate(self.dl): self._one_batch()\n",
    "\n",
    "    def one_epoch(self, training):\n",
    "        self.model.train(training)\n",
    "        self.dl = self.train_dl if training else self.dls.valid\n",
    "        self._one_epoch()\n",
    "\n",
    "    @with_cbs('fit')\n",
    "    def _fit(self, train, valid):\n",
    "        self.train_dl = self.dls.train\n",
    "        if self.epoch_sz is not None: self.train_dl = CycleDL(self.train_dl, self.epoch_sz)\n",
    "        for self.epoch in self.epochs:\n",
    "            if train: self.one_epoch(True)\n",
    "            if valid:\n",
    "                with torch.inference_mode(): self.one_epoch(False)\n",
    "\n",
    "    def fit(self, n_epochs=1, train=True, valid=True, cbs=None, lr=None):\n",
    "        cbs = fc.L(cbs)\n",
    "        self.cbs += cbs\n",
    "        try:\n",
    "            self.n_epochs = n_epochs\n",
    "            self.epochs = range(n_epochs)\n",
    "            if lr is None: lr = self.lr\n",
    "            if self.opt_func: self.opt = self.opt_func(self.model.parameters(), lr)\n",
    "            self._fit(train, valid)\n",
    "        finally:\n",
    "            for cb in cbs: self.cbs.remove(cb)\n",
    "\n",
    "    def __getattr__(self, name):\n",
    "        if name in ('predict','get_loss','backward','step','zero_grad'): return partial(self.callback, name)\n",
    "        raise AttributeError(name)\n",
    "\n",
    "    def callback(self, method_nm): run_cbs(self.cbs, method_nm, self)\n",
    "    \n",
    "    @property\n",
    "    def training(self): return self.model.training"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#|export\n",
    "def _get_inp(b, n_inp, inp_nm):\n",
    "    if inp_nm is not None: return [b[inp_nm]]\n",
    "    return b[:n_inp]\n",
    "\n",
    "def _get_lbl(b, n_inp, lbl_nm):\n",
    "    if lbl_nm is not None: return [b[lbl_nm]]\n",
    "    return b[n_inp:]\n",
    "\n",
    "def _get_preds(b, preds_nm):\n",
    "    return b if preds_nm is None else getattr(b, preds_nm)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#|export\n",
    "class TrainLearner(Learner):\n",
    "    def __init__(self, model, dls, loss_func, lr=None, cbs=None, opt_func=torch.optim.SGD, epoch_sz=None,\n",
    "                 n_inp=1, inp_nm=None, lbl_nm=None, preds_nm=None):\n",
    "        super().__init__(model, dls, loss_func, lr, cbs, opt_func=opt_func, epoch_sz=epoch_sz)\n",
    "        self.n_inp,self.inp_nm,self.lbl_nm,self.preds_nm = n_inp,inp_nm,lbl_nm,preds_nm\n",
    "\n",
    "    def predict(self):\n",
    "        inps = _get_inp(self.batch, self.n_inp, self.inp_nm)\n",
    "        self.preds = self.model(*inps)\n",
    "\n",
    "    def get_loss(self):\n",
    "        lbls = _get_lbl(self.batch, self.n_inp, self.lbl_nm)\n",
    "        preds = _get_preds(self.preds, self.preds_nm)\n",
    "        self.loss = self.loss_func(preds, *lbls)\n",
    "\n",
    "    def backward(self): self.loss.backward()\n",
    "    def step(self): self.opt.step()\n",
    "    def zero_grad(self): self.opt.zero_grad()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#|export\n",
    "class TrainCB(Callback):\n",
    "    def __init__(self, n_inp=1, inp_nm=None, lbl_nm=None, preds_nm=None):\n",
    "        self.n_inp = n_inp\n",
    "        self.n_inp,self.inp_nm,self.lbl_nm,self.preds_nm = n_inp,inp_nm,lbl_nm,preds_nm\n",
    "\n",
    "    def predict(self, learn):\n",
    "        inps = _get_inp(learn.batch, self.n_inp, self.inp_nm)\n",
    "        learn.preds = learn.model(*inps)\n",
    "\n",
    "    def get_loss(self, learn):\n",
    "        lbls = _get_lbl(learn.batch, self.n_inp, self.lbl_nm)\n",
    "        preds = _get_preds(learn.preds, self.preds_nm)\n",
    "        learn.loss = learn.loss_func(preds, *lbls)\n",
    "\n",
    "    def backward(self, learn): learn.loss.backward()\n",
    "    def step(self, learn): learn.opt.step()\n",
    "    def zero_grad(self, learn): learn.opt.zero_grad()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#|export\n",
    "class MomentumLearner(TrainLearner):\n",
    "    def __init__(self, model, dls, loss_func, lr=None, cbs=None, opt_func=torch.optim.SGD, epoch_sz=None,\n",
    "                 n_inp=1, inp_nm=None, lbl_nm=None, preds_nm=None, mom=0.85):\n",
    "        self.mom = mom\n",
    "        super().__init__(model, dls, loss_func, lr, cbs, opt_func=opt_func, epoch_sz=epoch_sz, n_inp=n_inp,\n",
    "                        inp_nm=inp_nm, lbl_nm=lbl_nm, preds_nm=preds_nm)\n",
    "\n",
    "    def zero_grad(self):\n",
    "        with torch.no_grad():\n",
    "            for p in self.model.parameters():\n",
    "                if p.grad is not None:\n",
    "                    p.grad.detach_()\n",
    "                    p.grad *= self.mom"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Some useful callbacks"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "DeviceCB - makes sure everything is on the right device:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#|export\n",
    "class DeviceCB(Callback):\n",
    "    def __init__(self, device=def_device): fc.store_attr()\n",
    "    def before_fit(self, learn):\n",
    "        if hasattr(learn.model, 'to'): learn.model.to(self.device)\n",
    "    def before_batch(self, learn): learn.batch = to_device(learn.batch, device=self.device)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Sometimes you only want to run a single batch, for example when debugging. This callback allows you to do that, making use of the CancelFitException:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#|export\n",
    "class SingleBatchCB(Callback):\n",
    "    order = 1\n",
    "    def after_batch(self, learn): raise CancelFitException()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We rely on torcheval metrics for calculating metrics. By defauly, adding a MetricsCB will track the loss. But you can feed in other metrics as needed:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#|export\n",
    "class MetricsCB(Callback):\n",
    "    def __init__(self, *ms, **metrics):\n",
    "        for o in ms: metrics[type(o).__name__] = o\n",
    "        self.metrics = metrics\n",
    "        self.all_metrics = copy(metrics)\n",
    "        self.all_metrics['loss'] = self.loss = Mean()\n",
    "\n",
    "    def _log(self, d): print(d)\n",
    "    def before_fit(self, learn): learn.metrics = self\n",
    "    def before_epoch(self, learn): [o.reset() for o in self.all_metrics.values()]\n",
    "\n",
    "    def after_epoch(self, learn):\n",
    "        log = {k:f'{v.compute():.3f}' for k,v in self.all_metrics.items()}\n",
    "        log['epoch'] = learn.epoch\n",
    "        log['train'] = 'train' if learn.model.training else 'eval'\n",
    "        self._log(log)\n",
    "\n",
    "    def after_batch(self, learn):\n",
    "        x,y,*_ = to_cpu(learn.batch)\n",
    "        for m in self.metrics.values(): m.update(to_cpu(learn.preds), y)\n",
    "        self.loss.update(to_cpu(learn.loss), weight=len(x))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "ProgressCB is a simple callback that prints out the progress of training. It's not very sophisticated, but it's useful for debugging. Any metrics being tracked via MetricsCB will be printed out as well. And you can set plot=True to get a plot of the loss during training:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#|export\n",
    "class ProgressCB(Callback):\n",
    "    order = MetricsCB.order+1\n",
    "    def __init__(self, plot=False): self.plot = plot\n",
    "    def before_fit(self, learn):\n",
    "        learn.epochs = self.mbar = master_bar(learn.epochs)\n",
    "        self.first = True\n",
    "        if hasattr(learn, 'metrics'): learn.metrics._log = self._log\n",
    "        self.losses = []\n",
    "\n",
    "    def _log(self, d):\n",
    "        if self.first:\n",
    "            self.mbar.write(list(d), table=True)\n",
    "            self.first = False\n",
    "        self.mbar.write(list(d.values()), table=True)\n",
    "\n",
    "    def before_epoch(self, learn): learn.dl = progress_bar(learn.dl, leave=False, parent=self.mbar)\n",
    "    def after_batch(self, learn):\n",
    "        learn.dl.comment = f'{learn.loss:.3f}'\n",
    "        if self.plot and hasattr(learn, 'metrics') and learn.training:\n",
    "            self.losses.append(learn.loss.item())\n",
    "            self.mbar.update_graph([[fc.L.range(self.losses), self.losses]])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "There are callbacks for all sorts of things, here are some common ones."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "cbs = [\n",
    "    TrainCB(), # Handles the core steps in the training loop\n",
    "    DeviceCB(), # Puts data and model on GPU\n",
    "    MetricsCB(accuracy=MulticlassAccuracy())\n",
    "]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We'll try a very basic convnet:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def conv(nin,nout):\n",
    "    return [nn.Conv2d(nin, nout, kernel_size=3, stride=2, padding=1),\n",
    "            nn.ReLU(), nn.BatchNorm2d(nout)]\n",
    "\n",
    "def get_model():\n",
    "    return nn.Sequential(*conv(1, 16), *conv(16,32), *conv(32,32),\n",
    "                         nn.AdaptiveAvgPool2d(1), nn.Flatten(), nn.Linear(32,10))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "opt = partial(torch.optim.AdamW, betas=(0.9,0.95), eps=1e-5)\n",
    "learn = Learner(get_model(), dls, nn.CrossEntropyLoss(), lr=0.05, cbs=cbs, opt_func=opt)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "\n",
       "<style>\n",
       "    /* Turns off some styling */\n",
       "    progress {\n",
       "        /* gets rid of default border in Firefox and Opera. */\n",
       "        border: none;\n",
       "        /* Needs to be in here for Safari polyfill so background images work as expected. */\n",
       "        background-size: auto;\n",
       "    }\n",
       "    progress:not([value]), progress:not([value])::-webkit-progress-bar {\n",
       "        background: repeating-linear-gradient(45deg, #7e7e7e, #7e7e7e 10px, #5c5c5c 10px, #5c5c5c 20px);\n",
       "    }\n",
       "    .progress-bar-interrupted, .progress-bar-interrupted::-webkit-progress-bar {\n",
       "        background: #F44336;\n",
       "    }\n",
       "</style>\n"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/html": [
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: left;\">\n",
       "      <th>accuracy</th>\n",
       "      <th>loss</th>\n",
       "      <th>epoch</th>\n",
       "      <th>train</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <td>0.706</td>\n",
       "      <td>0.801</td>\n",
       "      <td>0</td>\n",
       "      <td>train</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>0.528</td>\n",
       "      <td>1.657</td>\n",
       "      <td>0</td>\n",
       "      <td>eval</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 600x400 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "learn.fit(1, cbs=[ProgressCB(plot=True)])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#| export\n",
    "class CapturePreds(Callback):\n",
    "    def before_fit(self, learn): self.all_inps,self.all_preds,self.all_targs = [],[],[]\n",
    "    def after_batch(self, learn):\n",
    "        self.all_inps. append(to_cpu(learn.batch[0]))\n",
    "        self.all_preds.append(to_cpu(learn.preds))\n",
    "        self.all_targs.append(to_cpu(learn.batch[1]))\n",
    "    def after_fit(self, learn):\n",
    "        self.all_preds,self.all_targs,self.all_inps = map(torch.cat, [self.all_preds,self.all_targs,self.all_inps])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#| export\n",
    "@fc.patch\n",
    "def capture_preds(self: Learner, cbs=None, inps=False):\n",
    "    cp = CapturePreds()\n",
    "    with torch.inference_mode(): self.fit(1, train=False, cbs=[cp]+fc.L(cbs))\n",
    "    res = cp.all_preds,cp.all_targs\n",
    "    if inps: res = res+(cp.all_inps,)\n",
    "    return res"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(torch.Size([10000, 10]), torch.Size([10000]))"
      ]
     },
     "execution_count": null,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "preds,targs = learn.capture_preds()\n",
    "preds.shape,targs.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tensor(0.5278)"
      ]
     },
     "execution_count": null,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(preds.argmax(1)==targs).float().mean()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If you want logging more often than the end of each full pass through the data loader, set `epoch_sz` to be the number of batches you'd like to count as an \"epoch\"."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "\n",
       "<style>\n",
       "    /* Turns off some styling */\n",
       "    progress {\n",
       "        /* gets rid of default border in Firefox and Opera. */\n",
       "        border: none;\n",
       "        /* Needs to be in here for Safari polyfill so background images work as expected. */\n",
       "        background-size: auto;\n",
       "    }\n",
       "    progress:not([value]), progress:not([value])::-webkit-progress-bar {\n",
       "        background: repeating-linear-gradient(45deg, #7e7e7e, #7e7e7e 10px, #5c5c5c 10px, #5c5c5c 20px);\n",
       "    }\n",
       "    .progress-bar-interrupted, .progress-bar-interrupted::-webkit-progress-bar {\n",
       "        background: #F44336;\n",
       "    }\n",
       "</style>\n"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/html": [
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: left;\">\n",
       "      <th>accuracy</th>\n",
       "      <th>loss</th>\n",
       "      <th>epoch</th>\n",
       "      <th>train</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <td>0.404</td>\n",
       "      <td>1.628</td>\n",
       "      <td>0</td>\n",
       "      <td>train</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>0.356</td>\n",
       "      <td>2.397</td>\n",
       "      <td>0</td>\n",
       "      <td>eval</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>0.644</td>\n",
       "      <td>0.961</td>\n",
       "      <td>1</td>\n",
       "      <td>train</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>0.461</td>\n",
       "      <td>1.773</td>\n",
       "      <td>1</td>\n",
       "      <td>eval</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>0.714</td>\n",
       "      <td>0.769</td>\n",
       "      <td>2</td>\n",
       "      <td>train</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>0.521</td>\n",
       "      <td>1.769</td>\n",
       "      <td>2</td>\n",
       "      <td>eval</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "learn = Learner(get_model(), dls, nn.CrossEntropyLoss(), lr=0.05,\n",
    "                cbs=cbs, opt_func=opt, epoch_sz=10)\n",
    "learn.fit(3, cbs=[ProgressCB()])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#| export\n",
    "@fc.patch\n",
    "@fc.delegates(show_images)\n",
    "def show_image_batch(self:Learner, max_n=9, cbs=None, **kwargs):\n",
    "    self.fit(1, cbs=[SingleBatchCB()]+fc.L(cbs))\n",
    "    xb,yb = self.batch\n",
    "    feat = fc.nested_attr(self.dls, 'train.dataset.features')\n",
    "    if feat is None: titles = np.array(yb)\n",
    "    else:\n",
    "        names = feat['label'].names\n",
    "        titles = [names[i] for i in yb]\n",
    "    show_images(xb[:max_n], titles=titles[:max_n], **kwargs)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 300x400 with 9 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "learn.show_image_batch(figsize=(3,4))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Learning Rate Finder"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A useful method from FastAI, the learning rate finder tries batches at ever-increasing LRs and plots the loss. It's a good way to get a sense of what LR to use for training. Note that we also patch in the `lr_find` method to the Learner class, so you can call it directly."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#|export\n",
    "class LRFinderCB(Callback):\n",
    "    def __init__(self, gamma=1.3, max_mult=3): fc.store_attr()\n",
    "    \n",
    "    def before_fit(self, learn):\n",
    "        self.sched = ExponentialLR(learn.opt, self.gamma)\n",
    "        self.lrs,self.losses = [],[]\n",
    "        self.min = math.inf\n",
    "\n",
    "    def after_batch(self, learn):\n",
    "        if not learn.training: raise CancelEpochException()\n",
    "        self.lrs.append(learn.opt.param_groups[0]['lr'])\n",
    "        loss = to_cpu(learn.loss)\n",
    "        self.losses.append(loss)\n",
    "        if loss < self.min: self.min = loss\n",
    "        if loss > self.min*self.max_mult:\n",
    "            raise CancelFitException()\n",
    "        self.sched.step()\n",
    "\n",
    "    def cleanup_fit(self, learn):\n",
    "        plt.plot(self.lrs, self.losses)\n",
    "        plt.xscale('log')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#|export\n",
    "@fc.patch\n",
    "def lr_find(self:Learner, gamma=1.3, max_mult=3, start_lr=1e-5, max_epochs=10):\n",
    "    self.fit(max_epochs, lr=start_lr, cbs=LRFinderCB(gamma=gamma, max_mult=max_mult))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "learn = Learner(get_model(), dls, nn.CrossEntropyLoss(), lr=0.1, cbs=cbs, opt_func=opt)\n",
    "learn.lr_find()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Scheduling callbacks"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#|export\n",
    "class RecorderCB(Callback):\n",
    "    def __init__(self, **d): self.d = d\n",
    "    def before_fit(self, learn):\n",
    "        self.recs = {k:[] for k in self.d}\n",
    "        self.pg = learn.opt.param_groups[0]\n",
    "    \n",
    "    def after_batch(self, learn):\n",
    "        if not learn.training: return\n",
    "        for k,v in self.d.items():\n",
    "            self.recs[k].append(v(self))\n",
    "\n",
    "    def plot(self):\n",
    "        for k,v in self.recs.items():\n",
    "            plt.plot(v, label=k)\n",
    "            plt.legend()\n",
    "            plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#|export\n",
    "class BaseSchedCB(Callback):\n",
    "    def __init__(self, sched): self.sched = sched\n",
    "    def before_fit(self, learn): self.schedo = self.sched(learn.opt)\n",
    "    def _step(self, learn):\n",
    "        if learn.training: self.schedo.step()      "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#|export  \n",
    "class BatchSchedCB(BaseSchedCB):\n",
    "    def after_batch(self, learn): self._step(learn)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#|export\n",
    "class EpochSchedCB(BaseSchedCB):\n",
    "    def after_epoch(self, learn): self._step(learn)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#|export\n",
    "class HasLearnCB(Callback):\n",
    "    def before_fit(self, learn): self.learn = learn \n",
    "    def after_fit(self, learn): self.learn = None"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Accelerated training loops"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#|export \n",
    "class MixedPrecision(TrainCB):\n",
    "    order = DeviceCB.order+10\n",
    "    def __init__(self, n_inp=1, dtype=torch.bfloat16):\n",
    "        super().__init__(n_inp=n_inp)\n",
    "        self.dtype=dtype\n",
    "    \n",
    "    def before_fit(self, learn): self.scaler = torch.cuda.amp.GradScaler()\n",
    "\n",
    "    def before_batch(self, learn):\n",
    "        self.autocast = torch.autocast(\"cuda\", dtype=self.dtype)\n",
    "        self.autocast.__enter__()\n",
    "\n",
    "    def after_loss(self, learn): self.autocast.__exit__(None, None, None)\n",
    "        \n",
    "    def backward(self, learn): self.scaler.scale(learn.loss).backward()\n",
    "\n",
    "    def step(self, learn):\n",
    "        self.scaler.step(learn.opt)\n",
    "        self.scaler.update()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/tmp/ipykernel_6897/3850268229.py:8: FutureWarning: `torch.cuda.amp.GradScaler(args...)` is deprecated. Please use `torch.amp.GradScaler('cuda', args...)` instead.\n",
      "  def before_fit(self, learn): self.scaler = torch.cuda.amp.GradScaler()\n"
     ]
    },
    {
     "data": {
      "text/html": [
       "\n",
       "<style>\n",
       "    /* Turns off some styling */\n",
       "    progress {\n",
       "        /* gets rid of default border in Firefox and Opera. */\n",
       "        border: none;\n",
       "        /* Needs to be in here for Safari polyfill so background images work as expected. */\n",
       "        background-size: auto;\n",
       "    }\n",
       "    progress:not([value]), progress:not([value])::-webkit-progress-bar {\n",
       "        background: repeating-linear-gradient(45deg, #7e7e7e, #7e7e7e 10px, #5c5c5c 10px, #5c5c5c 20px);\n",
       "    }\n",
       "    .progress-bar-interrupted, .progress-bar-interrupted::-webkit-progress-bar {\n",
       "        background: #F44336;\n",
       "    }\n",
       "</style>\n"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/html": [
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: left;\">\n",
       "      <th>accuracy</th>\n",
       "      <th>loss</th>\n",
       "      <th>epoch</th>\n",
       "      <th>train</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <td>0.716</td>\n",
       "      <td>0.788</td>\n",
       "      <td>0</td>\n",
       "      <td>train</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>0.822</td>\n",
       "      <td>0.507</td>\n",
       "      <td>0</td>\n",
       "      <td>eval</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 600x400 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "cbs = [MixedPrecision(), DeviceCB(), MetricsCB(accuracy=MulticlassAccuracy())]\n",
    "learn = Learner(get_model(), dls, nn.CrossEntropyLoss(), lr=0.05, cbs=cbs, opt_func=opt)\n",
    "learn.fit(1, cbs=[ProgressCB(plot=True)])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#|export\n",
    "class AccelerateCB(TrainCB):\n",
    "    order = DeviceCB.order+10\n",
    "    def __init__(self, n_inp=1, mixed_precision=\"fp16\"):\n",
    "        super().__init__(n_inp=n_inp)\n",
    "        self.acc = Accelerator(mixed_precision=mixed_precision)\n",
    "        \n",
    "    def before_fit(self, learn):\n",
    "        learn.model,learn.opt,learn.dls.train,learn.dls.valid = self.acc.prepare(\n",
    "            learn.model, learn.opt, learn.dls.train, learn.dls.valid)\n",
    "    \n",
    "    def after_fit(self, learn): learn.model = self.acc.unwrap_model(learn.model)\n",
    "    def backward(self, learn): self.acc.backward(learn.loss)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Hooks"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#| export\n",
    "def append_stats(hook, mod, inp, outp):\n",
    "    if not hasattr(hook,'stats'): hook.stats = ([],[],[])\n",
    "    acts = to_cpu(outp).float()\n",
    "    hook.stats[0].append(acts.mean())\n",
    "    hook.stats[1].append(acts.std())\n",
    "    hook.stats[2].append(acts.abs().histc(40,0,10))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#| export\n",
    "def get_min(h):\n",
    "    h1 = torch.stack(h.stats[2]).t().float()\n",
    "    return h1[0]/h1.sum(0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#| export\n",
    "class Hook():\n",
    "    def __init__(self, m, f): self.hook = m.register_forward_hook(partial(f, self))\n",
    "    def remove(self): self.hook.remove()\n",
    "    def __del__(self): self.remove()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#| export\n",
    "class Hooks(list):\n",
    "    def __init__(self, ms, f): super().__init__([Hook(m, f) for m in ms])\n",
    "    def __enter__(self, *args): return self\n",
    "    def __exit__ (self, *args): self.remove()\n",
    "    def __del__(self): self.remove()\n",
    "    def __delitem__(self, i):\n",
    "        self[i].remove()\n",
    "        super().__delitem__(i)\n",
    "    def remove(self):\n",
    "        for h in self: h.remove()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#| export\n",
    "class HooksCallback(Callback):\n",
    "    def __init__(self, hookfunc, mod_filter=fc.noop, on_train=True, on_valid=False, mods=None):\n",
    "        fc.store_attr()\n",
    "        super().__init__()\n",
    "    \n",
    "    def before_fit(self, learn):\n",
    "        if self.mods: mods=self.mods\n",
    "        else: mods = fc.filter_ex(learn.model.modules(), self.mod_filter)\n",
    "        self.hooks = Hooks(mods, partial(self._hookfunc, learn))\n",
    "\n",
    "    def _hookfunc(self, learn, *args, **kwargs):\n",
    "        if (self.on_train and learn.training) or (self.on_valid and not learn.training): self.hookfunc(*args, **kwargs)\n",
    "\n",
    "    def after_fit(self, learn): self.hooks.remove()\n",
    "    def __iter__(self): return iter(self.hooks)\n",
    "    def __len__(self): return len(self.hooks)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#| export\n",
    "# Thanks to @ste for initial version of histgram plotting code\n",
    "def get_hist(h): return torch.stack(h.stats[2]).t().float().log1p()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#|export\n",
    "class ActivationStats(HooksCallback):\n",
    "    def __init__(self, mod_filter=fc.noop): super().__init__(append_stats, mod_filter)\n",
    "\n",
    "    def color_dim(self, figsize=(11,5)):\n",
    "        fig,axes = get_grid(len(self), figsize=figsize)\n",
    "        for ax,h in zip(axes.flat, self):\n",
    "            show_image(get_hist(h), ax, origin='lower')\n",
    "\n",
    "    def dead_chart(self, figsize=(11,5)):\n",
    "        fig,axes = get_grid(len(self), figsize=figsize)\n",
    "        for ax,h in zip(axes.flatten(), self):\n",
    "            ax.plot(get_min(h))\n",
    "            ax.set_ylim(0,1)\n",
    "\n",
    "    def plot_stats(self, figsize=(10,4)):\n",
    "        fig,axs = plt.subplots(1,2, figsize=figsize)\n",
    "        for h in self:\n",
    "            for i in 0,1: axs[i].plot(h.stats[i])\n",
    "        axs[0].set_title('Means')\n",
    "        axs[1].set_title('Stdevs')\n",
    "        plt.legend(fc.L.range(self))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "astats = ActivationStats(fc.risinstance(nn.Conv2d))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "learn = Learner(get_model(), dls, nn.CrossEntropyLoss(), lr=0.05, cbs=cbs, opt_func=opt)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/tmp/ipykernel_6897/3850268229.py:8: FutureWarning: `torch.cuda.amp.GradScaler(args...)` is deprecated. Please use `torch.amp.GradScaler('cuda', args...)` instead.\n",
      "  def before_fit(self, learn): self.scaler = torch.cuda.amp.GradScaler()\n"
     ]
    },
    {
     "data": {
      "text/html": [
       "\n",
       "<style>\n",
       "    /* Turns off some styling */\n",
       "    progress {\n",
       "        /* gets rid of default border in Firefox and Opera. */\n",
       "        border: none;\n",
       "        /* Needs to be in here for Safari polyfill so background images work as expected. */\n",
       "        background-size: auto;\n",
       "    }\n",
       "    progress:not([value]), progress:not([value])::-webkit-progress-bar {\n",
       "        background: repeating-linear-gradient(45deg, #7e7e7e, #7e7e7e 10px, #5c5c5c 10px, #5c5c5c 20px);\n",
       "    }\n",
       "    .progress-bar-interrupted, .progress-bar-interrupted::-webkit-progress-bar {\n",
       "        background: #F44336;\n",
       "    }\n",
       "</style>\n"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/html": [
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: left;\">\n",
       "      <th>accuracy</th>\n",
       "      <th>loss</th>\n",
       "      <th>epoch</th>\n",
       "      <th>train</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <td>0.719</td>\n",
       "      <td>0.760</td>\n",
       "      <td>0</td>\n",
       "      <td>train</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>0.755</td>\n",
       "      <td>0.632</td>\n",
       "      <td>0</td>\n",
       "      <td>eval</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "learn.fit(1, cbs=[ProgressCB(), astats])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1100x500 with 3 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.rc('image', cmap='viridis')\n",
    "astats.color_dim()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1000x400 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "astats.plot_stats()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAA40AAAGyCAYAAABA5yFoAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjAsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvlHJYcgAAAAlwSFlzAAAPYQAAD2EBqD+naQAAWAZJREFUeJzt3Xd4lfX9//HXOSdnZCckZJKwEZC9IuKiRrFSWmu11FEtdVTFVuXX1mIVa4f4bau1tlaqVm3rolpHXSiiONlD2RsSAllA9jjJOffvj5ADMbkhJ2Sc8XxcV67KyX3O+dx3OW/O6/4si2EYhgAAAAAAaIO1pxsAAAAAAAhchEYAAAAAgClCIwAAAADAFKERAAAAAGCK0AgAAAAAMEVoBAAAAACYIjQCAAAAAEwRGgEAAAAApgiNAAAAAABThEYAAAAAgCm/Q+PHH3+sGTNmKCMjQxaLRa+99tpJn7N06VKNGzdOTqdTgwYN0jPPPNOBpgKAf6hXAIIJNQtAoPI7NFZXV2v06NF69NFH23X8nj17NH36dE2dOlXr16/X7bffruuvv17vvvuu340FAH9QrwAEE2oWgEBlMQzD6PCTLRa9+uqruuSSS0yPufPOO/XWW29p48aNvse+973vqaysTIsWLeroWwOAX6hXAIIJNQtAIIno6jdYtmyZcnNzWzw2bdo03X777abPqa+vV319ve/PXq9Xhw8fVlJSkiwWS1c1FUAPMgxDlZWVysjIkNXaM9OtO1KvJGoWEI6CtWZRr4DwdKo1q8tDY2FhoVJTU1s8lpqaqoqKCtXW1ioyMrLVc+bPn6/77ruvq5sGIADl5+erT58+PfLeHalXEjULCGfBVrOoV0B462jN6vLQ2BFz587VnDlzfH8uLy9Xdna28vPzFRcX14MtA9BVKioqlJWVpdjY2J5uit+oWUD4CdaaRb0CwtOp1qwuD41paWkqKipq8VhRUZHi4uJM79o7nU45nc5Wj8fFxVHQgBDXk8OjOlKvJGoWEM6CrWZRr4Dw1tGa1eWD8CdPnqwlS5a0eGzx4sWaPHlyV781APiFegUgmFCzAHQXv0NjVVWV1q9fr/Xr10tqWu55/fr1ysvLk9Q07OGaa67xHX/TTTdp9+7d+vnPf66tW7fqb3/7m/7zn//ojjvu6JwzAAAT1CsAwYSaBSBQ+R0aV69erbFjx2rs2LGSpDlz5mjs2LGaN2+eJOngwYO+4iZJ/fv311tvvaXFixdr9OjRevDBB/Xkk09q2rRpnXQKANA26hWAYELNAhCoTmmfxu5SUVGh+Ph4lZeXM94eCFGh9DkPpXMB0LZQ+ZyHynkAOLFT/az3zMZCAAAAAICgQGgEAAAAAJgiNAIAAAAATBEaAQAAAACmCI0AAAAAAFOERgAAAACAKUIjAAAAAMAUoREAAAAAYIrQCAAAAAAwRWgEAAAAAJgiNAIAAAAATBEaAQAAAACmCI0AAAAAAFOERgAAAACAKUIjAAAAAMAUoREAAAAAYIrQCAAAAAAwRWgEAAAAAJgiNAIAAAAATBEaAQAAAACmCI0AAAAAAFOERgAAAACAKUIjAAAAAMAUoREAAAAAYIrQCAAAAAAwRWgEAAAAAJgiNAIAAAAATBEaAQAAAACmCI0AAAAAAFOERgAAAACAKUIjAAAAAMAUoREAAAAAYIrQCAAAAAAwRWgEAAAAAJgiNAIAAAAATBEaAQAAAACmCI0AAAAAAFOERgAAAACAKUIjAAAAAMAUoREAAAAAYIrQCAAAAAAwRWgEAAAAAJgiNAIAAAAATBEaAQAAAACmCI0AAAAAAFOERgAAAACAKUIjAAAAAMAUoREAAAAAYIrQCAAAAAAwRWgEAAAAAJgiNAIAAAAATBEaAQAAAACmCI0AAAAAAFOERgAAAACAKUIjAAAAAMAUoREAAAAAYIrQCAAAAAAwRWgEAAAAAJgiNAIAAAAATBEaAQAAAACmCI0AAAAAAFOERgAAAACAKUIjAAAAAMAUoREAAAAAYIrQCAAAAAAwRWgEAAAAAJjqUGh89NFH1a9fP7lcLuXk5GjlypUnPP7hhx/WaaedpsjISGVlZemOO+5QXV1dhxoMAP6iZgEIJtQsAIHG79C4cOFCzZkzR/fee6/Wrl2r0aNHa9q0aSouLm7z+Oeff16/+MUvdO+992rLli36xz/+oYULF+quu+465cYDwMlQswAEE2oWgEDkd2h86KGHdMMNN2jWrFkaPny4FixYoKioKD311FNtHv/5559rypQpuvLKK9WvXz9deOGFuuKKK0561wwAOgM1C0AwoWYBCER+hUa32601a9YoNzf32AtYrcrNzdWyZcvafM6ZZ56pNWvW+IrX7t279fbbb+viiy82fZ/6+npVVFS0+AEAf1GzAAST7qhZ1CsAHRHhz8GlpaXyeDxKTU1t8Xhqaqq2bt3a5nOuvPJKlZaW6qyzzpJhGGpsbNRNN910wmET8+fP13333edP0wCgFWoWgGDSHTWLegWgI7p89dSlS5fq/vvv19/+9jetXbtWr7zyit566y395je/MX3O3LlzVV5e7vvJz8/v6mYCgCRqFoDg4m/Nol4B6Ai/ehqTk5Nls9lUVFTU4vGioiKlpaW1+Zx77rlH3//+93X99ddLkkaOHKnq6mrdeOON+uUvfymrtXVudTqdcjqd/jQNAFqhZgEIJt1Rs6hXADrCr55Gh8Oh8ePHa8mSJb7HvF6vlixZosmTJ7f5nJqamlYFy2azSZIMw/C3vQDQbtQsAMGEmgUgUPnV0yhJc+bM0bXXXqsJEyZo0qRJevjhh1VdXa1Zs2ZJkq655hplZmZq/vz5kqQZM2booYce0tixY5WTk6OdO3fqnnvu0YwZM3xFDQC6CjULQDChZgEIRH6HxpkzZ6qkpETz5s1TYWGhxowZo0WLFvkmbefl5bW443X33XfLYrHo7rvvVkFBgXr37q0ZM2bod7/7XeedBQCYoGYBCCbULACByGIEwdiFiooKxcfHq7y8XHFxcT3dHABdIJQ+56F0LgDaFiqf81A5DwAndqqf9S5fPRUAAAAAELwIjQAAAAAAU4RGAAAAAIApQiMAAAAAwBShEQAAAABgitAIAAAAADBFaAQAAAAAmCI0AgAAAABMERoBAAAAAKYIjQAAAAAAU4RGAAAAAIApQiMAAAAAwBShEQAAAABgitAIAAAAADBFaAQAAAAAmCI0AgAAAABMERoBAAAAAKYIjQAAAAAAU4RGAAAAAIApQiMAAAAAwBShEQAAAABgitAIAAAAADBFaAQAAAAAmCI0AgAAAABMERoBAAAAAKYIjQAAAAAAU4RGAAAAAIApQiMAAAAAwBShEQAAAABgitAIAAAAADBFaAQAAAAAmCI0AgAAAABMERoBAAAAAKYIjQAAAAAAU4RGAAAAAIApQiMAAAAAwBShEQAAAABgitAIAAAAADBFaAQAAAAAmCI0AgAAAABMERoBAAAAAKYIjQAAAAAAU4RGAAAAAIApQiMAAAAAwBShEQAAAABgitAIAAAAADBFaAQAAAAAmCI0AgAAAABMERoBAAAAAKYIjQAAAAAAU4RGAAAAAIApQiMAAAAAwBShEQAAAABgitAIAAAAADBFaAQAAAAAmCI0AgAAAABMERoBAAAAAKYIjQAAAAAAU4RGAAAAAIApQiMAAAAAwBShEQAAAABgitAIAAAAADBFaAQAAAAAmCI0AgAAAABMERoBAAAAAKYIjQAAAAAAUx0KjY8++qj69esnl8ulnJwcrVy58oTHl5WVafbs2UpPT5fT6dSQIUP09ttvd6jBAOAvahaAYELNAhBoIvx9wsKFCzVnzhwtWLBAOTk5evjhhzVt2jRt27ZNKSkprY53u9264IILlJKSopdfflmZmZnat2+fEhISOqP9AHBC1CwAwYSaBSAQWQzDMPx5Qk5OjiZOnKi//vWvkiSv16usrCz9+Mc/1i9+8YtWxy9YsEB/+MMftHXrVtnt9g41sqKiQvHx8SovL1dcXFyHXgNAYOuqzzk1C0BXCJWaRb0CwsOpftb9Gp7qdru1Zs0a5ebmHnsBq1W5ublatmxZm8/53//+p8mTJ2v27NlKTU3ViBEjdP/998vj8Zi+T319vSoqKlr8AIC/qFkAgkl31CzqFYCO8Cs0lpaWyuPxKDU1tcXjqampKiwsbPM5u3fv1ssvvyyPx6O3335b99xzjx588EH99re/NX2f+fPnKz4+3veTlZXlTzMBQBI1C0Bw6Y6aRb0C0BFdvnqq1+tVSkqKHn/8cY0fP14zZ87UL3/5Sy1YsMD0OXPnzlV5ebnvJz8/v6ubCQCSqFkAgou/NYt6BaAj/FoIJzk5WTabTUVFRS0eLyoqUlpaWpvPSU9Pl91ul81m8z02bNgwFRYWyu12y+FwtHqO0+mU0+n0p2kA0Ao1C0Aw6Y6aRb0C0BF+9TQ6HA6NHz9eS5Ys8T3m9Xq1ZMkSTZ48uc3nTJkyRTt37pTX6/U9tn37dqWnp7f55QsAOgs1C0AwoWYBCFR+D0+dM2eOnnjiCf3zn//Uli1bdPPNN6u6ulqzZs2SJF1zzTWaO3eu7/ibb75Zhw8f1m233abt27frrbfe0v3336/Zs2d33lkAgAlqFoBgQs0CEIj83qdx5syZKikp0bx581RYWKgxY8Zo0aJFvknbeXl5slqPZdGsrCy9++67uuOOOzRq1ChlZmbqtttu05133tl5ZwEAJqhZAIIJNQtAIPJ7n8aewB5CQOgLpc95KJ0LgLaFyuc8VM4DwIl16z6NAAAAAIDwQmgEAAAAAJgiNAIAAAAATBEaAQAAAACmCI0AAAAAAFOERgAAAACAKUIjAAAAAMAUoREAAAAAYIrQCAAAAAAwRWgEAAAAAJgiNAIAAAAATBEaAQAAAACmCI0AAAAAAFOERgAAAACAKUIjAAAAAMAUoREAAAAAYIrQCAAAAAAwRWgEAAAAAJgiNAIAAAAATBEaAQAAAACmCI0AAAAAAFOERgAAAACAKUIjAAAAAMAUoREAAAAAYIrQCAAAAAAwRWgEAAAAAJgiNAIAAAAATBEaAQAAAACmCI0AAAAAAFOERgAAAACAKUIjAAAAAMAUoREAAAAAYIrQCAAAAAAwRWgEAAAAAJgiNAIAAAAATBEaAQAAAACmCI0AAAAAAFOERgAAAACAKUIjAAAAAMAUoREAAAAAYIrQCAAAAAAwRWgEAAAAAJgiNAIAAAAATBEaAQAAAACmCI0AAAAAAFOERgAAAACAKUIjAAAATsrrNVRV36gj1e6ebgqAbkZoBAAAwEltK6rUiHvf1QV/+rinmwKgmxEaAQAAcFIuu02SVNfg6eGWAOhuhEYAAACclMve9LWR0AiEH0IjAAAATsoV0dTT2Og11Ojx9nBrAHQnQiMAAABOKtJh8/13XSOhEQgnhEYAAACclDPi2NdGhqgC4YXQCAAAgJOyWCy+4FjrJjQC4YTQCAAAgHZpXkG1vpHQCIQTQiMAAADa5dgKqsxpBMIJoREAAADtEslejUBYIjQCAACgXVy+0EhPIxBOCI0AAABoF+fR0FhLTyMQVgiNAAAAaBdXRPOcRkIjEE4IjQAAAGgXF3MagbBEaAQAAEC7+BbCaWROIxBOCI0AAABol+YtN+rpaQTCCqERAAAA7dI8PLXWTWgEwgmhEQAAAO3im9PYSGgEwklETzcAAMJVg8erT3eWqr7BqwuHp8pqtfR0kwDghJz25tVTmdMIhJMO9TQ++uij6tevn1wul3JycrRy5cp2Pe/FF1+UxWLRJZdc0pG3BYAOCdSaVd/o1aynV+mmZ9fI7eELGIAmgVqzpOMWwmFOIxBW/A6NCxcu1Jw5c3Tvvfdq7dq1Gj16tKZNm6bi4uITPm/v3r366U9/qrPPPrvDjQUAfwVyzXJGHCvB9dy1B6DArlnS8VtuULOAcOJ3aHzooYd0ww03aNasWRo+fLgWLFigqKgoPfXUU6bP8Xg8uuqqq3TfffdpwIABp9RgAPBHINesCKtFzSNS65kfBECBXbMkyRXRPDyVmgWEE79Co9vt1po1a5Sbm3vsBaxW5ebmatmyZabP+/Wvf62UlBRdd9117Xqf+vp6VVRUtPgBAH8Fes2yWCxyRjTdta9nzzMg7HVHzTrV71guhqcCYcmv0FhaWiqPx6PU1NQWj6empqqwsLDN53z66af6xz/+oSeeeKLd7zN//nzFx8f7frKysvxpJgBICo6a1byoBKERQHfUrFP9jsXqqUB46tItNyorK/X9739fTzzxhJKTk9v9vLlz56q8vNz3k5+f34WtBIAmPVGzmuc1MjwVgL86UrNO9TuWi9VTgbDk15YbycnJstlsKioqavF4UVGR0tLSWh2/a9cu7d27VzNmzPA95vU2FZmIiAht27ZNAwcObPU8p9Mpp9PpT9MAoJVgqFmOCHoaATTpjpp1qt+xGJ4KhCe/ehodDofGjx+vJUuW+B7zer1asmSJJk+e3Or4oUOHasOGDVq/fr3v55vf/KamTp2q9evXM+wUQJcKhprlm9PIXXsg7AVDzSI0AuHJr55GSZozZ46uvfZaTZgwQZMmTdLDDz+s6upqzZo1S5J0zTXXKDMzU/Pnz5fL5dKIESNaPD8hIUGSWj0OAF0h0GsWw1MBHC/QaxZbbgDhye/QOHPmTJWUlGjevHkqLCzUmDFjtGjRIt+k7by8PFmtXTpVEgDaLdBrlpPhqQCOE+g169icRm50AeHEYhiG0dONOJmKigrFx8ervLxccXFxPd0cAF0glD7n/pzLFY8v17Ldh/SXK8ZqxuiMbmohgFMVKjXL3/PYW1qt8/64VNEOmzb9+qJuaCGAznCqNSukugQNw9DVT67QBQ99pJLK+p5uDgCcFFtuAAgmkY7mLTeoWUA4CanQaLFYtLWwQjuKq1RcWdfTzQGAk3LYmNMIIHi4ji7e5fEaavAQHIFwEVKhUZKSY5qWkT5U5e7hlgDAyTntrJ4KIHg0j46QpFrmNQJhI2RDY2kVw1MBBD4WwgEQTJwRVlksTf/NYjhA+AjB0OiQRGgEEBzYcgNAMLFYLMfqFiMkgLARgqGxuaeR4akAAp/z6PwgNz2NAIJEpG+vRm52AeEi9EJj7NHQyOqpAIIAq6cCCDYuX2ikbgHhIvRC49GexhKGpwIIAqyeCiDYNIdGFsIBwkcIhsbmOY0MTwUQ+Hw9jdyxBxAkmuc0MjwVCB8hGBpZPRVA8Gie08jwVADBwsWcRiDshGxoPFztltdr9HBrAODEWD0VQLDxLYTDzS4gbIRcaEw6OjzV4zVUVtvQw60BgBNrDo2sngogWLjsDE8Fwk3IhUa7zaqEKLskhqgCCHxOO8NTAQQXhqcC4SfkQqN03LxGtt0AEOCOrZ5KaAQQHAiNQPgJ0dDYNESVbTcABLpj+zTy5QtAcDg2PJWbXUC4CNHQ2LyCKttuAAhsvoVw+PIFIEg0r/pMTyMQPkI8NHZ/T2NlXYMMg1VbAbQPW24ACDaRjubQSN0CwkVIhsbesT0zp3HRxoMa+av39I9P93Tr+wIIXqyeCiDYuI7e7KqlpxEIGyEZGpvnNHZ3T+OLq/IlSX//eLcaPXwBBHByLuY0AggyvrpFaATCRkiGxqTo7p/TWONu1Oe7DkmSSirr9eG2km57bwDBy2FjeCqA4OJbPZWbXUDYCMnQmHx0eOqhbuxp/HznoRbDyxauyuu29wYQvI6tnkpoBBAcWD0VCD+hGRp9w1Pd3bYozZKtxZKkswYlS5I+2FqswvK6bnlvAMGreU6jx2swrB1AUGCfRiD8hGhobOppdHu8qqhr7PL3MwxDHx4Njded3V+T+vWS15BeXpPf5e8NILg1r54q0dsIIDg0h0YWwgHCR0iGRpfdplhnhKTuWQxn88EKFVbUyWW3avKAJM2cmCVJWrg6X14v228AMOeIOFaGWUEVQDA41tNIzQLCRUiGRunYvMbu2Hbjw+OGprrsNl08Ml2xzgjlH67Vst2Huvz9AQQvm9Uiu80iiZ5GAMHBFcHqqUC4Cd3QeNy8xlPhaUdPYfN8xq8NTZXUtOntt8ZmSDq2DQcAmHHY2HYDQPBgTiMQfkI4NDZvu9GxnkbDMPTv5fs05r73dPdrG0yPO1RVr/X5ZZKkqUN7+x7/3sRsSdK7Gwt1pLr7tv4AEHycdrbdABA8Ih3NW25Qs4BwQWhsQ3FFnWY9s0r3vLZRlfWNeuOLg6arsC7dViLDkIanxyk9PtL3+IjMeI3IjJPb49Wzy/d17CQAhAWnb6gXX8AABD7X0QW8at30NALhImRDY5JveKp/ofHdTYWa9vDHWrqtRI4Iq2xWi8prG1RQVtvm8R8cHZp6/rCUVr+77qz+kqRHPtihzQcq/GoHgPDhC40MTwUQBHz7NDZ6um1rMwA9K2RD47GexvYPDd1WWKmbn12jIzUNGp4epzd/fJaGpMZKkja1EfoaPF59vL1EkjR1aOvQeMmYTOUOS1WDx9DtC9cx9h9Am5q33WD1VADBoHlIvWE0bW8GIPSFQWhsf0/jG18ckNeQzhyYpNdmT9GQ1FgNT4+T1HZoXLX3sCrrG5UU7dDoPgmtfm+xWPTAd0YqOcah7UVV+sO721r8vqq+UTuKKv04KwChyGlv7mnkyxeAwNfc0yix7QYQLkI2NPaO9W94qmEYenvDQUnSzIlZvr3TTs9oCo2bD5S3es5nO0slSecM6S2b1dLm6ybHOPX7y0ZJkv7x6R59trNUheV1mv/OFk2ev0QX/Oljvbpuvx9nBiDUsHoqgGDisFnV/LWHbTeA8BDR0w3oKr6exsr2DU/dXlSl3aXVctis+tpxQ02bQ2ObPY17jkiSzhjQ64Sv/bWhqboyJ1vPr8jTTc+uUa3bo8bjtvL447vbdfHIdN8QNQDhhZ5GAMHEYrHIZbepxu1RLaERCAsh29PYHBprGzyqrm886fHNvYznDElWrMvue3z40dB4sLxOh4/bOqOuwePbamNivxOHRkm6e/ow9U+OVmVdoxq9hib176UFV49TapxTBWW1emFFXrvPDUBoab5hxOqpAILFsb0aqVtAOAjZ0BjtjFDk0YLWniGq72xsCo1fH5He4vFYl119k6IkqcUKqF/uL5fb41VyjFP9k6NP+vpRjgg9/YOJuuW8gXpt9hT950eTddGIdP34a4MlSX/9cJdq3CcPtwBCD6unAgg2rqN1i0X+gPAQsqFRkpLbOa9xZ3GlthdVyW6zKHdYaqvfHxuiemxe48o9hyRJk/onymJpez7jV/VLjtbPLxqqMVkJvse+OyFL2b2iVFpVr2c+39uu1wEQWo6FRu7YAwgOx3oaCY1AOAjt0Hh0iGrJSeY1vrOhUJI0ZVCy4qPsrX5/eka8pJbzGlfubZrPOKkdQ1NPxBFh1R0XNPU2/v2j3SqvbTil1wMQfByERgBBpnnbjTrqFhAWQjo0JkW3b9uNtzc2hcaLvzI0tdnwr/Q0Nnq8WrP3sCRpUv+kU27nN0dnanBKjMprG/TkJ7tP+fW6gtdraNmuQ9xRBLqAb04jX74ABInIowt41br5XgCEg5AOjc3bbhyqMu9p3FNarS0HK2SzWnTB8NZDU6Vjw1N3l1arxt2oLQcrVe32KNYVodPSYk+5nTarRf/vwtMkNW3L4c/ekt3lD+9t0xVPLNddr2zo6aYAIYc5jQCCTfPwVOoWEB5CdssN6bhtN04QwpoXwDlzYJISox1tHpMS61LvWKdKKuu15WCl1uU1DU2d2K+X6f6M/pp2eqpG94nXF/vLNf/trXrwu6M75XU7w8aCcj3+cVMP6KvrC3TTeQM1JPXUw3Kw2FNarcc/3q0ad9PKt40eryLtNs29eJhS41w93TyEAN+WG6xCCCBIMKcRCC8h3dPYrtB4dD7jV1dN/arm3sbNB8q16ujQ1PZstdFeFotFv/rm6bJYpP+u3a/Pd5V22mu3xd3o1TsbDmp3SdUJj2vwePXzl7+Ux2vIbrPIMKQ/Ld7epW0LJIZh6GcvfaEXVubp9fUH9NaXB/XupiK9tv6Afv3m5p5uHkIEw1MBBBuXvXn1VOoWEA7COjR+vL1EGwrKZbVIF57e9tDUZs2hcWNBhVY1L4LTv/NCoySNzU7UVTnZkqS7X93YJUM+3I1ePb8iT1P/uFQ3P7dW0x/5VG99edD0+Cc+2a3NBysUH2nXP2dNksUivbOxsMVKsqFsyZZird53RM4Iq+66eKh+NWO47rp4qCwW6a0vD/p6nYFT0Tw81U1oBBAkXBH0NALhJMRDY/OWG63nNOYdqtGPX1gnSfrepGxfwDTTvILqe5sLdbjaLZfdqpGZ8Z3cYuln04aqd6xTu0urtWDpqS2K4/UaKqms14b95XpvU6H+/tEuTf3jUt316gYVlNXKEWFVbYNHs59fqwff2yav12jx/F0lVXr4/R2SpHnfGK4zByVrxqgMSeHR2+jxGvr9u1slSbOm9NeN5wzUD47+72Xj+kiS7n97iwzDONHLACflYE4jgCDjcjSFxlpCIxAWQntOY+zRnsbKlj2NNe5G3fjv1SqvbdDorATdO2P4SV9reHpTT+ORmqYtMcZmJfq+6HWm+Ei75n1juH78wjo9+uFOzRidrgG9Y/x+nfKaBl31j+XaWFDR6ne9Y526+dyBmjkxSw+/v11PfLJHf/lgp7YcrNRN5w6QoabA+cf3tsnd6NXZg5N16bhMSdJtuYP15pcH9P6WYq3PL2ux52SoeXVdgbYXVSnOFaGbzx3Y4ndzLhyiN748oFV7j2jx5iJdeHpaD7USoYDhqQCCzbGeRuoWEA5CvKexKTRW1jfqpdX5qqpvlGEY+sV/N2hrYaWSYxxacPU43xe2E8nuFaUY57GM3dlDU4/3jVHpOmdIb7k9Xs19ZYN2lVT53Zv1x/e2aWNBhSwWKSXWqdF94nXh8FTdO2O4Pvn5VP3wrP6Kdkbol9OH66HvjpYjwqr3txTpsgXLdPmCZZr5+HKt2ntEUQ6b7v/2SFksTQv+DOwdo0uP9rI9+N62Tj/3QFHX4PH1pt4ydVCr/TvT4yN13Vn9JUkPLNqqBg//aKLjnOzTCCDIHJvTSE8jEA5CuqcxzhWh9HiXDpbX6Wcvf6l5r2/SqD7xWrHnsCKsFj165Tilx0e267WsVouGp8dppW9/xq4LjRaLRb/91ghd8KePtGLPYZ3/4EdKinZofN9ETTs9TZeOy/SFuLZ8ub9Mz67YJ0l67rocnTko+YTvd+m4PhrYO0b3vbFJh6rdslossloku82qm88bqKxeUS2Ov+38wXptXYE+2VGqFbsPKWfAqe9VGWieXb5PBWW1Sotz6Qdn9mvzmJvOHagXV+Zrd0m1XlyVr++f0bd7G4mQcWz1VL58AQgObLkBhJeQDo0Wi0WvzZ6i/6zK1yvrCrSntFor9jSFvrunD/M77AzPaAqNEVaLxmYndEGLj8lOitKCq8frsaW7tH5/mQ5Vu/Xe5iK9t7lItQ0eXW0SUDxeQ/e8tlGGIX1rTMZJA2Oz0VkJeuWWKe06NqtXlL47MUvPr8jTT1/+Qm/cepYSotreriQYVdQ16NEPd0qSbs8d7PuH8atiXXbdljtY817fpD+/v12XjMlQrMve5rHAiTA8FUCwYfVUILyEdGiUpNQ4l358/mDd+rVBWp9fpje+OKjUOKeuNek9OpHm+XujsxIU5ej6Szd1aIqmDk1RfaNHGwsq9Pr6Av1r2T79+s3NGpedqOFHV3Q93our8vTF/nLFOiP0y4uHdVnb7pw2VJ/uKFXe4RrdvnC9nrp2oqydtGdlSWW9Vu45rMRou84c2L7Q25n+9fleHalp0MDe0bpsfJ8THnvFpGw989le7S6t1hMf79acC0/rplYilLB6KoBgE3n0hmqtm55GIByEfGhsZrFYNDY7UWOzEzv8GjNGZ6iksl7nnta7E1t2cs4Im8b3TdS47AQVHKnVkq3FuvWFtXrj1rMUfdw8y0NV9fr9oqZ5hnMuHKKULtx4Pj7KrgVXj9elj32mpdtK9PCSHZpzwRDf7yvrGrT/SK2GpbcOtm3ZVlipZ5fv07Ldh7SzuGnvSKtF+uhnU1sNj+1KXq+hF1bmS5JuOW+QImwnnvZrt1n184tO003PrtUTn+zR1ZP7KiW26647QhOrpwIINs6jobGOugWEhZBeCKez2awW3XDOAA1Jje2R97dYLPrD5aOVFufS7pJq3fP6Rt/vCsvrdPdrG1Ve26Dh6XHdMr9ueEac5l86UpL0yJIdWrKlSJsPVOiuVzco5/4l+vqfP9HCVXknfZ3iyjpdvuBz/Xv5Pl9gdEZY5TWkz3eVduk5fNWnO0tVUFarWFeEpo9Kb9dzpp2eprHZCapt8OjPR7coAfzBQjgAgk3z1A0WwgHCA6ExyPSKduiRK8bKapFeWVugea9v1My/L9PkB5bonY2FkqTfXDLipD1kneXbY/vomslNAfVH/16jix/5RM+vyFPN0eEqD763/aRDV+7732ZV1DVqaFqsFlw9TuvuuUA3nD1AkrRi9+GuPYGvWLiqqZfx22MzTecyfpXFYtEvLhoqSXpxVb52lVR1WfsQmpjTCCDYuCKY0wiEE0JjEJrUv5fuyG0aCvqvZfu0Ys9hGYY0oW+iHrtqnMb37fgQ3I64e/pwjctOUKPXUITVoumj0vXsdTnqkxip4sp6/WvZXtPnLt5cpLc2HJTNatEfLx+ti0akKzHaoZwBTavTNi9c1B0OVdXrvc1Nwft7E7P9em7OgCSdPzRFHq+hP74buluRoGuweiqAYENPIxBewmZOY6i5Zeog5R2u0a6SKl00Ik3TR2UoM6F924d0NkeEVc/8cJI+2FKsMwcm+eZS3p47RD996Qs99tEuXZGTrbivrCxaWdege15rGmJ7/dn9NSIz3ve78X0TFWG1qKCsVvmHa7plXuMrawvU4DE0qk98m4sMnczPLxqqD7cV652NhVqbd0TjTmH+LMILw1MBBJtIByMkgHBCT2OQslmb5je+cssU3XjOwB4LjM3iXHZdMjazxeI73x6bqUEpMSqradCTH+9u9Zw/vLtNhRV1yu4VpdvPH9Lid1GOCI3s0xQiu6O30TAMvXh0/qW/vYzNTkuL1XfGNa22+sDbW2UYRqe1D6GteXiq2+Pl7w2AoOCKYPVUIJwQGtFlbFaLfnphUxh88tM9Kq2q9/1u1d7D+vfyfZKk+7890nfH8ng5/Zv20Vyx+1CXt3X1viPaVVKtSLtNM0a3bwGcttxxwRA5I6xaufewlmwp7sQWIpQ1r55qGFKDh9AIIPD59mlk9VQgLBAa0aWmnZ6mUX3iVeP26JElO/T2hoP6wdMrNfPvy2QY0mXj++iswW3vxdg8r3H5nq4PjS8e3WbjG6PSFfuVYbT+yEiI1A+m9JMk/f7drfJ4CQA4uebhqRLbbgAIDsxpBMILoRFdymKx6GfTmja8/9eyfbrlubVauq1EXkM6e3Cy7p4+zPS5E/omymqR8g/X6kBZbZe1saKuQW9tOCBJ+t6kjg1NPd4t5w5SfKRd24uq9N+1+0/59RD6WoZG5gcBCHzNC3jVNTCsHggHhEZ0ubMGJevso72JqXFOzZ46UB/+9Dz9+7ocJUQ5TJ8X67L7FsdZ0YW9ja+s2a+6Bq8Gp8RoXHbCKb9efJRds6cOlCT9afF27sLipCwWi2+IKqERQDA4flsq6hYQ+lg9FV3OYrFowdXjtaukSqdnxMtmtbT7uTn9e+nL/eVasfuwvj22T6e3rdHj1ZOf7pEkfX9yX1ks7W/biVwzuZ+e+WyvDpTX6Z+f79WPzh3YKa+L0OWMsMrd6JWbL18AgkDkcaGxrsHT7r2NAQQnehrRLaKdERrVJ8GvwChJZww4uhhOF62g+taGg9p/pFZJ0Q5dPj6r017XZbdpzoVNw3If/XCnymrcnfbaCE3NK6gypxFAMLDbrL5/0+sauNkFhDpCIwLahH69ZLFIe0qrVVxR16mvbRiGHlu6S5L0gzP7tbmC66n49thMDU2LVUVdo+99/FVYXqe5r3ypOxau1zsbDqrG3dipbUTg8O3VyJcvAEHCFdE8r5GbXUCoY3gqAlp8pF3D0+O06UCFlu85rG+Ozui01166vURbCysV7bDpmsn9Ou11m9msFt150VDNemaVnv58r4ZnxOmbozPaPQT27Q0HNfeVDSqvbZAkvbquQC67VecNSdEFw1N1zpDe6h3r7PR2o2c4mdMIIMi47DZVuz1suwGEAUIjAl5O/yRtOlChFbsPdWpobO79u2JStuKjOr7Nxomcd1pvnT80RUu2Fuu2F9fr7Q0H9dtLRp4w7FXVN+pX/9ukl9c0rbw6MjNeOf17adGmQu0/UqtFmwq1aFOh73fnndZbWYlRslktirBZ5LBZNb5folJiXZ1+Pmvzjuj9zUU6e3Bv5fTvJaufw41h7thCOHz5AhAcjm27wc0uINQRGhHwcgb00lOf7dGy3Yfk8Rp+z4tsy5p9R7Ryz2HZbRZdd3b/Tmhl2ywWixZ8f7weW7pLjyzZoXc3FWnlnsO69sx+qqhtVEFZjQrKanWkukF1DR7VHv0xDMlikW4+d6Buzx0iR4RVv5w+TJsOVOjdTYX6cFuxNhZUaENBuTYUlLd6X4fNqm+PzdQN5/TXoJTYNtvm9Ro6VO1WdX2j+iZFnbQHtMHj1a3PrdWB8jr9bekupcW59I1R6bpkbKZvlVt0nPPoly+GpwIIFq6j227UurnZBYQ6QiMCXk7/XrJZLdpdUq2L//yJ7po+TOcO6d3u59c1ePTJjlJFWC3qmxSlPolRWvBRUy/jJWMylR4f2VVNl9S0WMBPzh+s84el6KcvfaktByv08Ps7TvicrF6R+uNlo5VzdCEgqSmAjsiM14jMeP2/C09TcWWdPtpWos93HVJ5bYMavYYaPV4drnZra2GlFq7O18LV+Zp6Wm9lJESqqr5R1fWNqqht1MGKWhWV18vtaQoov7x4mG44Z8AJ27RoY6EOlNcpxhkhi0UqrKjTk5/u0ZOf7tGIzDhdldNX3xydoWgnZaUjmoenNv9/AgCBztfTyAgJIOTx7Q4BLyHKoT9cNkr3vbFZ24oqde1TK3XOkN6a941hpr1oUtMiMs+t2KfnV+TpUPWx1UutFsl7tCfvR+eeOCh1ptMz4vX67Cl6+rM92nigQhnxLmUmRiojPlJJMQ5FOSIUabfJ5bAqKdp50h7VlFiXLp+QpcsntF71dfXew3r8491avKVIH24rOWnb/rxkh749LlPJMebDZp/6rGlrkuvP7q+bzxuopdtK9L/1B7R4c5E2FlRo7isb9Lu3tuiqM7L182lDO6VHOJw4GZ4KIMi4fCMkqFtAqOvQ6qmPPvqo+vXrJ5fLpZycHK1cudL02CeeeEJnn322EhMTlZiYqNzc3BMeD7Tl0nF99NHPztN1Z/WX3WbRx9tL9J3Hlqmksr7VsXUNHv30pS901v99oL98sFOHqt1Kj3dpaFqsohw2eY2m46aPTD9h6OwKjgirfnTuQP3lirGae/EwXTO5n3KHp2psdqJOS4tVdlKUUmJdpxy4JvTrpcevmaD355yr23MH67bzB+vu6cP0wKUj9dcrx+qlmybr0zunavtvv65RfeJVVd+oh9/fbvp6a/OOaF1emRw2q67K6StnhE3TTk/To1eN0/K7ztcvLx6m/snRqqpv1N8/2q3nV+w7pfZ3tmCoWayeCqBZMNQs6djwVOY0AqHP79C4cOFCzZkzR/fee6/Wrl2r0aNHa9q0aSouLm7z+KVLl+qKK67Qhx9+qGXLlikrK0sXXnihCgoKTrnxCC8JUQ7d843hen/OuRqaFqvy2gb936KtrY770+LtennNfjV6DU3q30uPXTVOn/x8qhbdfo423TdNK395vt649Sz98fLRPXAW3Wtg7xjdnjtEd1wwRNefPUDfm5Stb4zK0MR+vdQnMUqOCKvuuniYJOmFlfnaWVzZ5us8/dleSdI3x2S0WsSnV7RDN5wzQB/8v3M19+tDJUm/f3dbm4G+JwRLzTq2TyNfvoBwFiw1S5JcEc0L4dDTCIQ6v0PjQw89pBtuuEGzZs3S8OHDtWDBAkVFRempp55q8/jnnntOt9xyi8aMGaOhQ4fqySeflNfr1ZIlS0658QhPfZOiNf/SkZKkl9fs15p9R3y/W5d3RE98sluS9Lerxuk/P5qsr49MV4St6a+6xWJRSqxLI/vE+4bVhLszBiTpguGp8ngNzX+7dQg/WF6rtzcclCTNmtLP9HUsFouuP3uARmbGq7KuUfPf2dJVTfZLsNQshqcCkIKnZkmS6+j+xrWERiDk+RUa3W631qxZo9zc3GMvYLUqNzdXy5Yta9dr1NTUqKGhQb169TI9pr6+XhUVFS1+gOONzU7Udyf0kSTNe32jPF5D9Y0e/fzlL+U1pEvGZOjikek93Mrg8YuvD1WE1aIlW4v1+c7SFr/75+f75PEaOmNAL52eceJVUm1Wi357yQhZLNIrawu0fPehrmz2SQVTzXLaGZ4KhLvuqFmd+R3rWE8jdQsIdX6FxtLSUnk8HqWmprZ4PDU1VYWFhe16jTvvvFMZGRktCuJXzZ8/X/Hx8b6frKzWC30Ad140VHGuCG06UKHnV+bpL0t2akdxlZJjnLp3xuk93bygMrB3jK7KyZYk/e7tLWo8uoJnjbtRL6zMkyRdd1b7Fg0anZWgKyc1vdY9r21UQw+uBhpMNat5eCqrpwLhqztqVmd+xzo2p5GeRiDUdWghnI564IEH9OKLL+rVV1+Vy2W+8fjcuXNVXl7u+8nPz+/GViJYJMU49dNpp0mSfv/OVj12dBuN315yuhKjHT3ZtKD0k/MHK9bZFMJPu2eRpjzwgb796Ocqr21Q36QofW1oSrtf6+fThiop2qEdxVV66tM9XdjqrtWdNevY8FRCI4COaU/N6szvWGy5AYQPv0JjcnKybDabioqKWjxeVFSktLS0Ez73j3/8ox544AG99957GjVq1AmPdTqdiouLa/EDtOXKSdkalh6nyvpGebyGpo9M10UjGJbaEUkxTt01fZgcEVZ5vIYKymq1rahpYZxZZ/bza0XX+Ci75h5dYOfh93foQFltl7T5ZIKpZjl8q6fy5QsIV91RszrzO5aLYfVA2PArNDocDo0fP77F5OrmydaTJ082fd7vf/97/eY3v9GiRYs0YcKEjrcW+IoIm1W/+dbpsliaVvG871sMSz0VV0zK1tZfX6Tlc8/Xf2+erD9/b4z+NHO0vj+5n9+v9Z1xmZrYL1FDUmNU427s/Ma2QzDVLHoaAQRTzZKkyKM9jbVubnYBoS7C3yfMmTNH1157rSZMmKBJkybp4YcfVnV1tWbNmiVJuuaaa5SZman58+dLkv7v//5P8+bN0/PPP69+/fr5xuTHxMQoJiamE08F4WpCv15649azFB9pP+Hm9Ggfq9WitHiX0uJdGt+3469jsVj09+9PUHyk/ZT3nTwVwVKz2HIDgBQ8NUtieCoQTvwOjTNnzlRJSYnmzZunwsJCjRkzRosWLfJN2s7Ly5PVeqwD87HHHpPb7dZll13W4nXuvfde/epXvzq11gNHjcg88aqe6Bm9AmBuabDULN/qqXz5AsJasNQsSXLa2acRCBcWwzCMnm7EyVRUVCg+Pl7l5eXMbwRCVCh9zjtyLgtX5enO/25Q7rAUPXntxC5uIYBTFSo161TO46XV+frZy1/q3CG99c8fTuqiFgLoDKdas7p19VQAQNsYngog2LjoaQTCBqERAALAsdVTCY0AggOhEQgfhEYACADHVk/lyxeA4BDpC43c7AJCHaERAAIAw1MBBJtIR1PdqqrvmW2VAHQfQiMABIBjq6cSGgEEh5TYpm2uSqrqFQTrKgI4BYRGAAgAzcNT3YRGAEGi99HQ6G70qry2oYdbA6ArERoBIAAcG57KnEYAwcFltykhyi5JKqqo7+HWAOhKhEYACACsngogGKXGuiRJRRV1PdwSAF2J0AgAAeDY6qmERgDBIyWuaYgqoREIbYRGAAgAvjmNHq+8XhaUABAcUuOaehqLKxmeCoQyQiMABADn0f3OpKbgCADBIJWeRiAsEBoBIAA09zRKDFEFEDyaexoJjUBoIzQCQACIsFpktTT9NyuoAggWKb6FcBieCoQyQiMABACLxcIKqgCCTvPw1GJ6GoGQRmgEgABxbK9GQiOA4HD8Qjgs4gWELkIjAASIY9tuMDwVQHDoHdvU09joNXS4xt3DrQHQVQiNABAgnHb2agQQXOw2q5JjHJJYDAcIZYRGAAgQzcNT3YRGAEGkeTGcYhbDAUIWoREAAsSx4amERgDBIy2ebTeAUEdoBIAAcWz1VOY0AggezSuosu0GELoIjQAQIOhpBBCMfHs1VtLTCIQqQiMABAi23AAQjHzbbjA8FQhZhEYACBBsuQEgGDE8FQh9hEYACBBOO6unAgg+zT2NLIQDhC5CIwAECOY0AghGKUd7Gkur6tXooX4BoYjQCAAB4tjqqXzpAhA8kqKdslkt8hpSaZW7p5sDoAsQGgEgQDCnEUAwslkt6h3TPK+RIapAKCI0AkCAYPVUAMHq2GI4hEYgFBEaASBA0NMIIFilNC+GU8kKqkAoIjQCQIBw2ptKMqunAgg2zT2N7NUIhCZCIwAECIanAghWqbFsuwGEMkIjAAQIVk8FEKyO7dXI8FQgFBEaASBAMKcRQLBKYSEcIKQRGgEgQBwLjfQ0AgguzT2NxSyEA4QkQiMABAjmNAIIVs2h8XC1m9ESQAgiNAJAgGD1VADBKjHKLrvNIkkqobcRCDmERgAIEMxpBBCsLBaLUmJZDAcIVYRGAAgQzGkEEMzYqxEIXYRGAAgQvjmNbLkBIAgd23aD0AiEGkIjAAQIhqcCCGa+0MicRiDkEBoBIECweiqAYEZPIxC6CI0AECASo+2yWqQat0cFZbU93RwA8EvznMaDZYRGINQQGgEgQMS67BqbnShJ+nBrcQ+3BgD8Myw9TpK0Ys8h7S6p6uHWAOhMhEYACCBfG5oiidAIIPgMS49T7rAUeQ3pT+/v6OnmAOhEhEYACCBTT2sKjZ/tKlVdAwviAAgud1wwRJL0xhcHtOVgRQ+3BkBnITQCQAAZlh6r9HiX6hq8Wrb7UE83BwD8cnpGvKaPSpckPbR4ew+3BkBnITQCQACxWCw672hv41KGqAIIQnfkDpHVIi3eXKT1+WU93RwAnYDQCAABpnle4wfbimUYRg+3BgD8MyglRt8e20eS9OB723q4NQA6A6ERAALMlEFJckRYlX+4VrtYgRBAELo9d7DsNos+2VGq5Qy1B4IeoREAAkyUI0JnDEiSJH3AEFUAQSirV5RmTsySJN36/FqCIxDkCI0AEIC+dlpvSYRGAMHrjtwhGpoWq9Iqt656coWe/GQ3Q+6BIEVoBIAA9LWhqZKk1XuPqKKuoUOvcaTarX8v36dX1u7XF/llquzg68A/h6vdmvX0St392gZ5vHxBRvhKinHq1Vum6JIxGfJ4Df32rS36yYvrVV3f2NNNA+CniJ5uAACgteykKA3sHa1dJdX6ZHupbwn79npnw0Hd8/pGlVa5WzyeEe/SD8/qr1lT+stmtXRmkyGpxt2oWc+s0hdHV4xMinb69q0DwlGkw6Y/zRyjMVkJ+u1bW/TGFwe0Lu+IfvOtEZp6dNEvAIGPnkYACFDNq6i+t7mw3UO6SqvqNfu5tbr5ubUqrXJrQO9o5fTvpd6xTknSgfI6/fatLbr0b5/5Nt42DEMbC8p13xubdNWTy7W1sGs25DYMQ8WVdfp4e4ke/3iXfvrSF/r38n3tfu7ukio1eLxd0rbO0ODx6pbn1uqL/DJFOWySpEc+2KEPTzLEuLq+US+tzteBstruaGbQY3hj8LFYLPrBlP564cYzlJkQqf1HajXrmVWa/dxaFVfU+Y6rb/ScdEREVX2jiivrlHeoRtuLKpV/uKarmw9AksUIgupbUVGh+Ph4lZeXKy4urqebA6ALhNLnvLPOZdmuQ7riieWSpHHZCbr1a4M09bQUWSzHegjrGjzadKBC6/KOaF1emT7dWary2gbZrBbdfO5A/fj8QXJGNAWY8toGvfXlQc1/Z4sq6xoVYbXo0nGZ+iK/XNuKKn2v2TvWqVduPlNZvaI63PbjNXq8enVdgf62dJf2lFa3+v1PvjZId1wwpMV5Hc/jNfTrNzbpn8v2Kad/Lz17fY7stp6957lyz2HlH67RuL6J6pfUdJ1++tKX+u/a/XLZrXr+hjP0ytr9enZ5nuIj7Xrzx2e1up6GYejdTUW6741NOlhep35JUVp0+zly2W09cUonZRiGthVV6tMdpRqaFqezBid36DW2HKzUwJRo39/L9mrweHXfG5v0+roD+uaYDN14zgD1TYr2uw2dJVRqVnefR3V9o/68ZIf+8ekeebyGohw2xTgjVFHXoLqGpptCIzLjdPHIdF08Il19k6K0saBC724q1LubCrWjuPWK0uOyE3T1GX118cj0gP38AD3tVD/rhEYAASGUPueddS6GYeiP723TE5/skbux6cvU8PQ4DUqJUUFZrQqO1Kqosk5freJD02L1h8tGa2Sf+DZft6iiTvNe36h3NxX5HnNEWHXB8FTtLKrStqJK9UuK0ss3n6nkGGe727t0W7HW7DuirMQo9UuOVt+kKH2yo1R/+WCH9h1q6g2wWqR+ydEamharaEeEXlqzX5J083kD9fNpp7UKjnUNHt3+4not2lToe+y6s/rrnm8Mb3e7OtvSbcW67p+rffMVk2Mc6pMYpfX5ZbJZLXrimvH62tBU1Td6NPPvy7U+v0ynZ8TpvzefKZfdJq/XUN7hGv3mzc1a8pVeyFunDtJPp512wvc/XO3W/9YXaOrQlG4JTct2HdL/vjigpduKdbC8qVfIbrNo6c+mKjMh0q/Xuv/tLXr8490a3Sdez91whmKc7ZslU1HXoNnPrdUnO0p9j1kt0vRRGfrROQM0IrPtv+snUtfg0ee7ShXtiNCk/r1Mb1qYtilEalZPncemA+W669WNvqHcZuIj7Sqvbdn7aLFIkXabIu02ldc2qPHoZzEhyq5LxmTqjAG9NK5volJiXR1uX9PIiHpJUlK0QxE9fKOqOzV4vPoiv0zZvaKUEtfxa4jAQmgEEBJC6XPe2edSXFmnf3yyR/9evk81bk+r3ydFOzQ2O1FjsxM0NjtBE/v1aldP3KKNhXp/S5HGZifoGyMzFB9lV1FFnb7z2Ofaf6RWIzPj9cKNLb/YG4bR5pfrpz/bo/ve2Gz6XknRDv3o3AG6Mqdvi9d76tM9+vWbTc+7/qz++uX0Yb7XL6tx64Z/rdaqvUfksFl11RnZevqzvZKkv1wxVjNGZ5z0HDvbloMVunzBMlXVNyq7V5QKy+vkPm7I7O8vG6XvTsjy/flAWa2+8ZdPdbjarYQouxo9hqqOWwTEbrPoxnMGaHBKrG5fuF4RVove+snZOi0tts33r3E36vIFy7TpQIVsVou+My5Tt04drOyktnuF3Y1e3fu/jVq6rURXTMrWtWf2U3ykvV3nWl3fqN++tVkvrMz3PeayWxXjtKu0ql5XTMrS/EtHteu1JOmJj3frd29v8f35rEHJ+scPJpy0x7GgrFY/fHqVthVVKtJu08+mnaaPd5Ro6bYS3zHD0uM0Y3S6ZozKOGEPucdraPnuQ3p9fYHe2Vioyrqm/y/OHpyse2ecrkEpMe0+n1CpWT15Hh6voc0HKmSxNIXDuEi73I1evb+lSG9vOKjPdx2Sx2so0m7Teaf11rTT03Teab0VH2n31Yniyjr9Z1W+XliZr4KvDPHO6hWpoWlxSjj62nEuuzITI5XTv1ervyeVdQ36cn+51ueXaV1emb7YX6aSo6HRYmman5wa59TY7ARddHq6cga0XWfLatzaUFCuL/eXa1thpWrcjapr8KquwSOvYei0tDiNy07QuL6JGpAcrdoGj4or6lVUUacat0cDe8eoT2KkrF+Zc97g8aq2waNYZ4TpDY66Bo8Ky+t0oKxWB8rrlBTj0FmDkts9MqO8pkHPr8zTv5bt1cHyOjlsVs2cmKWbzxuoDD9vEJ2M12u0Okd0LUIjgJAQSp/zrjqXI9VuvbKuQB6vV5kJUcpMjFRGgku9Y5x+95KcyO6SKl22YJkOV7s1uk+8MhIilXe4RvmHaxRhs2r21EG6ZnJf3xeRJz/Zrd++1RQGcoelqL7Rq72HqrX/SK0Soxy68ZwBumZyX0U52u5V+veyvbrn9U2SpAG9oxXlsMlmtaqovE6FFXWKdUXoiWsm6IwBSfq/RVv12NJdinLY9NrsKRqS2na4+qp1eUf07PI8SVKkw6pIu029Y52aOSFb8VHtC1FFFXW65NHPdLC8TmcM6KV//TBH3qPzQdfsO6LsXlH6+sjWCxZ9trNU1z610tcb0mzKoCTd983TNSil6Rxu/Ndqvbe5KcT/96YzW32h8noN3fLcWi3aVChnhFX1R3ufI6wWfWdcH936tUEtvgiX1zbopn+v0bLj9seLdUVo1pn99MOz+ishynHC63XHwvXae7SH+LsT+ujikek6Y0CSNh0o13ceWyab1aIlc85Vv+ST93a+um6/7lj4hSTpqpxsvbquQDVuj6aPStcj3xvb5qJMDR6vFm8u0q/+t0nFlfVKiXXqqR9M9PUqbjpQrgUf7dY7Gw62uLbj+ybqtvMH6+zByS0+Fx9uK9av39jcYoh0apxTR6ob5PZ4FWG16Idn9ddPzh/crh7QUKlZgXweR6rd2l1apdMz4k867NTjNfTh1mJ9sK1Ya/cd0baiylajMI6XmRCpyQOTZLNYtC7/iHYUV7U6vvnvZVurICdE2XX+0FRFOWwqqaxXSVW9CsvrWgXXE3HYrC1uOjWLcth0Wlqs0uJcKqqo04GyOhVX1slrNLUpIdKu+Ci7nBE21bobVeP2qNbtUWUbq9Imxzj0rTGZumx8Hw1Lb/n/b1mNW9uLqrS9qFIb9pfrf18cUG2Dx9eG5puUdptFl0/I0gXDUtU3KUpZvaJMg6jXa+jdTYX6dGepxmUnatqINN/nqdHj1aJNhfrHp3u0Pr9McS67kmMc6h3rVIwzQrUNHt+5eLyGnHarXBE2uew2Jcc4NDwjTsPT4zU8I069os3r1/EaPF5tLCjXzuIq5R2u0d5DNTpQVqt+SdG6YHiKzh7cW9HtHPHQHfYdqlZ1vUfD0mPb9e+612uorLahXdeD0AggJITS5zwUzuXL/WW64vHlqm6jZ1OShqTG6FffPF0bC8p1/9tbJUk//togzTlubmJ9o0d2q7Vdd5NfWJmnu17d0OpLW1qcS//84SRfz1ujx6trnlqpz3cd0oDkaP3lyrHqFe1QnMuuKIetzX9kl+8+pFlPr/J9GTper2iHfnHRUF02vs8J21ld36jv/r2ph29A72i9evOUdodNSco/XKPy2gbFOCMU7YxQrCui1Zfgg+W1uuChj1VV36jffOt0fX9yvxa//+O72/TXD3fKYbPq+RtyZLVa9PD7O/Tx9qYetwirRd+dmKVbpw6SJP3g6ZXaXlSlaIdNt0wdpNfXF2h7UdN8sGiHTVfmZOv6swco9bjhZ7tKqvTiyjw99dleebyG0uNdevDy0TpzUMv5iz94eqWWbivRpWMz9dDMMSc896XbinX9P1er0WvourP66+7pw/TpzlL98JlVavAYuvqMbM37xunyGoYMQyqsqNN/VufrpdX7VVrV1NNzWmqsnpo1sc3hsGU1bi3aWKg3vjygZbsOqfn7/ZkDk3TnRUPVK9qhX7+5WYs3Nw3Hjo+0a/qodH1rdIYm9uulvMM1+vWbm317oqbEOvXijWdoQO8T9zqGwudcCp3z+KqKugatzyvTvsM1qqxrUEVto8prG7StsEJf7i9vdRNHkvokRmp0VoLGZiVoTFaCTs+IlyPCqkPV9SquqNf+I7X6aHux3ttUpEPV7jbetUm/pCiN7JOg4elxSoyyy2W3yWW3qsHTdJNpbd4Rfbm/3HfjJ9JuU1q8S84Iq3aXVvumI3SEy25VRkKk0uNd2lZY2WIF7SiHTc1VzpDaHLkyNC1W1589QDNGp2vtvjL9ecl2Ld99uMUxNqtFfRIjNXlAknKHpWrKoGS57FZ9uK1YD763XZsOHFtMzWW3KndYqoakxmrhqta9wR0V64pQnMuuWFdTPU2OcSozIVJ9EiN9Nzo/21mqlXsOm/47JjUF9zMGJikzIVIOm0V2m1WOCKvsNqvsR//sjLAqLT5SWb0ildUrSnEuu7xeQ1XuRlXUNviuo9XStOiTYRiqcXuO/jTK4226yZAY5VBilF0JUY4WN8oMw9DHO0r1j0/3+Op5ZkKkpp2epq+PTNOYrIQWIb2grFaf7ijRpzsP6fOdpRqUEqOFP5p80mtGaAQQEkLpcx4q57I274gWbSxUWpxL2b2ilJ0UpTX7juj3i7bqSE3LOUY/OX+w7sgdfEo9nnmHapR3uEYNXq88HkOGpEn9e7UaTllaVa8Zf/nUN7+umctu1XcnZOmO3CFKPHrXdcXuQ/rB0cA4ZVCSzhncW7UNHtU2ePTBlmLfohpjshJ0zzeGaURmfIvhkntLq7V4c5FeWVegLQcrlBTt0Ku3TDEdDnqq/rVsr+a9vkkxzgg9e32OBqXEKMYZodfWFej2heslSQ9ePlrfGd/H95w1+w7r4fd3+Ob7OWxWxbgidLjarZRYp56eNVGnZ8T7egAe+WCnb+Vch82qS8dlanhGnF5dV6B1eWW+150xOkO//daINsPxl/vL9M2/fiarRXrvjnN8vaXNjlS79fGOEn24tViLNhWqrsGrb43J0J++O8YXzt/88oB+/MK6E/YGNfUGZ+lH5w5QrOvkIb24ok5//3i3/r1sn68Hp7k3x2a1aNaZ/XRb7uA2X2vJliL9+s3NinZE6I0fn3XSLWlC5XMeKufhj+r6Rq3ed0QrjvbCj8lK0JjshHbPgWz0eLVq7xF9vKNEEVaLesc61TvGqd6xTg1OiW3XDSV3o1cHy2vVK9qhmOOGnDZ6mkZqbDlYqZLKeqXHu5SR0BSEYl0RKq9t0JEat8pqGuRu9CrKYVOkw6YoR4TiI+1KjDo2dLfB49XH20v08pr9WrKluM1ezcyESA1OjdHglBhNPS1FkwcmtarjK3Yf0rMr8rSjqFL7DtW0ugHnjLCqT2KkdpU09eLHOCP0jVHpWrnnsHZ/ZfGzXtEOff+MvvrOuD6qb/SopKpepVVuVdc3Ns1TddiaRptYLKpvbBrWW9fo0YGyOm0+UKFNB8p9IyDaKzHKrtMz4pWdFKW+vaKUFu/Sl/vL9f6WIt98e39E2m2qa/ScsHadiM1qUVqcS5kJkcpMjNSmA+W+G3pWi5p6kL9yjZsfj7BZfMPqmyVE2bXyrlw5Ik48DJnQCCAkhNLnPJTOpS1lNW49tHi7nl2+T15Duj13sG7P7d69CDcWlOuXr27Q/iO1LRbCkJp6kuZcMERDUmN13T9Xqcbt0dmDk/XENRNa9O41eLx65rO9evj97b470RZLU09TZkKkKusaW6zUGGm36bkbcjQuO7HLzsvjNXTZgs9bhLc4V9OwrQaPoZvOHahffH1om89dsfuQHlq8XSv2NPUKDEmN0dOzJrXqnTMMQ0u3l+ixD3dp5d7WPQjnDumtKydlK3d46gnb2jycdvqodD165TgZhqH3txTriY93a9W+wy2+UJ13Wm89/v0Jrb7UPLdin379xmZfj4vU9P/B2YN768pJWTp/WGqHVsrNP1yjPy3erlfXF8gwpMkDknTft04/6XDmugaPSirr27VycKh8zkPlPHBilXUNOlLdoKbbcZJhSMlHh4X6o3mBoC0HK7R0W4kWby7y9R667FZde2Y/3XTOQCVGO2QYhjYUlOu1dQe0q6RKXx+RpkvGZp7yCrdV9Y0qLK9TVX2jKusaVFnXqOKKOu0/Uqv9R2pVUFarpBiHpgxM1pmDkjQsLa7NkSSGYWhXSZU+3VGqirpGNXi8cjd6Vd/oVaPXq4ZGQw1er2rdHh0or9P+wzWtepgdNquinU2jXJpHS0hNozkiHTZFOyNkkVRW26Aj1W5V1LUeQtx8/HcnZmnWmf2VEufUR9tLfOsOfDUkWi3S6KwEnT0oWVMGJWtsduJJA6NEaAQQIkLpcx5K53IiO4srVVxZrzMH+r/1QmcyDEO1DR6t3Vem3761WVsLK1v8vq3AeLyiijr93ztb9c7GwlZ3dyOsFuUM6KULhqXqohHpSovv+pUE95RWa+4rX2rLwcoWq0ZeMDxVf796/EmH+36+q1Tr88t0VU7fky56s3rvYT35yR6VVNXr6yPS9M0xGe3ubdlysEJf//MnkqS7pw/Tf9cW+HowpaZhblOHpmjqaSma0DfRtN11DR7VN3pltUhWi0URNovf23GY2VlcqaKKep3ZRu/JqQqVz3monAd6hmEY2lpYqa2FFZoyKPmUVqwNBtX1jSqprFeU06Y4l93vANzo8aq0yq2CshoVlNWp4EitYpw2fXNMZpv1utHjVVV9o+obmwOtRylxLsW1Y+TFVxEaAYSEUPqch9K5BJtGj1cvrsrXg+9t05GaBk0ZlKQnr5moSMfJ/2E3DEOHq90qKGu6Wy1JUwYm+zV3sbNV1TfqQFmtDlW5NaFfYo/vT/lVtz6/Vm9+edD352iHTdec2U/fP6Nvp6+2GGhC5XMeKucB4MRO9bMeOMsFAQBwiiJsVl19Rl/NGJWh1fsOH12goX13gi0Wi5JinEqKcWpUn4SubWg7xTgjmoZUnnikaI+544IhWrqtRBaL2rUqKwAgOBEaAQAhJz7KrvOHBWjSCiEDe8fok59PlevoAhYAgNBEaAQAAB2W2M790gAAwatDkyMeffRR9evXTy6XSzk5OVq5cuUJj3/ppZc0dOhQuVwujRw5Um+//XaHGgsAHUHNAhBMqFkAAo3foXHhwoWaM2eO7r33Xq1du1ajR4/WtGnTVFxc3Obxn3/+ua644gpdd911WrdunS655BJdcskl2rhx4yk3HgBOhpoFIJhQswAEIr9XT83JydHEiRP117/+VZLk9XqVlZWlH//4x/rFL37R6viZM2equrpab775pu+xM844Q2PGjNGCBQva9Z6s7AWEvq76nFOzAHSFUKlZ1CsgPHTr6qlut1tr1qzR3LlzfY9ZrVbl5uZq2bJlbT5n2bJlmjNnTovHpk2bptdee830ferr61VfX+/7c3l5uaSmkwUQmpo/3525CxA1C0BXCdaaRb0CwtOp1iy/QmNpaak8Ho9SU1uuSJeamqqtW7e2+ZzCwsI2jy8sLDR9n/nz5+u+++5r9XhWVpY/zQUQhCorKxUfH98pr0XNAtDVgq1mUa+A8NbRmhWQq6fOnTu3xV0zr9erw4cPKykpSRaL5YTPraioUFZWlvLz8xlm4SeuXcdw3Tru+GsXGxuryspKZWRk9HSz/EbN6hlcu47hunVcKNSsU6lXEn9/Oorr1nFcu47rzJrlV2hMTk6WzWZTUVFRi8eLioqUlpbW5nPS0tL8Ol6SnE6nnE5ni8cSEhL8aari4uL4i9VBXLuO4bp1XPO166y79c2oWeGBa9cxXLeOC+aa1Rn1SuLvT0dx3TqOa9dxnVGz/Fo91eFwaPz48VqyZInvMa/XqyVLlmjy5MltPmfy5MktjpekxYsXmx4PAJ2FmgUgmFCzAAQqv4enzpkzR9dee60mTJigSZMm6eGHH1Z1dbVmzZolSbrmmmuUmZmp+fPnS5Juu+02nXvuuXrwwQc1ffp0vfjii1q9erUef/zxzj0TAGgDNQtAMKFmAQhEfofGmTNnqqSkRPPmzVNhYaHGjBmjRYsW+SZh5+XlyWo91oF55pln6vnnn9fdd9+tu+66S4MHD9Zrr72mESNGdN5ZHMfpdOree+9tNfQCJ8e16xiuW8d1x7WjZoUurl3HcN06jprF35+O4rp1HNeu4zrz2vm9TyMAAAAAIHz4NacRAAAAABBeCI0AAAAAAFOERgAAAACAKUIjAAAAAMBUyIXGRx99VP369ZPL5VJOTo5WrlzZ000KKPPnz9fEiRMVGxurlJQUXXLJJdq2bVuLY+rq6jR79mwlJSUpJiZG3/nOd1ptHBzuHnjgAVksFt1+++2+x7hu5goKCnT11VcrKSlJkZGRGjlypFavXu37vWEYmjdvntLT0xUZGanc3Fzt2LGjB1vcfahZJ0bN6hzULP9Qs9pGvTo5albnoGb5pztqVkiFxoULF2rOnDm69957tXbtWo0ePVrTpk1TcXFxTzctYHz00UeaPXu2li9frsWLF6uhoUEXXnihqqurfcfccccdeuONN/TSSy/po48+0oEDB3TppZf2YKsDy6pVq/T3v/9do0aNavE4161tR44c0ZQpU2S32/XOO+9o8+bNevDBB5WYmOg75ve//70eeeQRLViwQCtWrFB0dLSmTZumurq6Hmx516NmnRw169RRs/xDzWob9ap9qFmnjprln26rWUYImTRpkjF79mzfnz0ej5GRkWHMnz+/B1sV2IqLiw1JxkcffWQYhmGUlZUZdrvdeOmll3zHbNmyxZBkLFu2rKeaGTAqKyuNwYMHG4sXLzbOPfdc47bbbjMMg+t2Infeeadx1llnmf7e6/UaaWlpxh/+8AffY2VlZYbT6TReeOGF7mhij6Fm+Y+a5R9qlv+oWW2jXnUMNcs/1Cz/dVfNCpmeRrfbrTVr1ig3N9f3mNVqVW5urpYtW9aDLQts5eXlkqRevXpJktasWaOGhoYW13Ho0KHKzs7mOkqaPXu2pk+f3uL6SFy3E/nf//6nCRMm6PLLL1dKSorGjh2rJ554wvf7PXv2qLCwsMW1i4+PV05OTkhfO2pWx1Cz/EPN8h81qzXqVcdRs/xDzfJfd9WskAmNpaWl8ng8Sk1NbfF4amqqCgsLe6hVgc3r9er222/XlClTNGLECElSYWGhHA6HEhISWhzLdZRefPFFrV27VvPnz2/1O66bud27d+uxxx7T4MGD9e677+rmm2/WT37yE/3zn/+UJN/1CbfPLjXLf9Qs/1CzOoaa1Rr1qmOoWf6hZnVMd9WsiM5rMoLN7NmztXHjRn366ac93ZSAl5+fr9tuu02LFy+Wy+Xq6eYEFa/XqwkTJuj++++XJI0dO1YbN27UggULdO211/Zw6xBMqFntR83qOGoWOgs1q/2oWR3XXTUrZHoak5OTZbPZWq2iVFRUpLS0tB5qVeC69dZb9eabb+rDDz9Unz59fI+npaXJ7XarrKysxfHhfh3XrFmj4uJijRs3ThEREYqIiNBHH32kRx55RBEREUpNTeW6mUhPT9fw4cNbPDZs2DDl5eVJku/6hNtnl5rlH2qWf6hZHUfNao165T9qln+oWR3XXTUrZEKjw+HQ+PHjtWTJEt9jXq9XS5Ys0eTJk3uwZYHFMAzdeuutevXVV/XBBx+of//+LX4/fvx42e32Ftdx27ZtysvLC+vreP7552vDhg1av36972fChAm66qqrfP/NdWvblClTWi03vn37dvXt21eS1L9/f6WlpbW4dhUVFVqxYkVIXztqVvtQszqGmtVx1KzWqFftR83qGGpWx3Vbzer4Wj2B58UXXzScTqfxzDPPGJs3bzZuvPFGIyEhwSgsLOzppgWMm2++2YiPjzeWLl1qHDx40PdTU1PjO+amm24ysrOzjQ8++MBYvXq1MXnyZGPy5Mk92OrAdPyqXobBdTOzcuVKIyIiwvjd735n7Nixw3juueeMqKgo49lnn/Ud88ADDxgJCQnG66+/bnz55ZfGt771LaN///5GbW1tD7a861GzTo6a1XmoWe1DzWob9ap9qFmdh5rVPt1Vs0IqNBqGYfzlL38xsrOzDYfDYUyaNMlYvnx5TzcpoEhq8+fpp5/2HVNbW2vccsstRmJiohEVFWV8+9vfNg4ePNhzjQ5QXy1mXDdzb7zxhjFixAjD6XQaQ4cONR5//PEWv/d6vcY999xjpKamGk6n0zj//PONbdu29VBruxc168SoWZ2HmtV+1Ky2Ua9OjprVeahZ7dcdNctiGIbRgZ5QAAAAAEAYCJk5jQAAAACAzkdoBAAAAACYIjQCAAAAAEwRGgEAAAAApgiNAAAAAABThEYAAAAAgClCIwAAAADAFKERAAAAAGCK0AgAAAAAMEVoBAAAAACYIjQCAAAAAEwRGgEAAAAApv4/hgerCjNyYywAAAAASUVORK5CYII=",
      "text/plain": [
       "<Figure size 1100x500 with 3 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "astats.dead_chart()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#|export\n",
    "def _flops(x, h, w):\n",
    "    if x.dim()<3: return x.numel()\n",
    "    if x.dim()==4: return x.numel()*h*w"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#|export\n",
    "@fc.patch\n",
    "def summary(self:Learner):\n",
    "    res = '|Module|Input|Output|Num params|MFLOPS|\\n|--|--|--|--|--|\\n'\n",
    "    totp,totf = 0,0\n",
    "    def _f(hook, mod, inp, outp):\n",
    "        nonlocal res,totp,totf\n",
    "        nparms = sum(o.numel() for o in mod.parameters())\n",
    "        totp += nparms\n",
    "        *_,h,w = outp.shape\n",
    "        flops = sum(_flops(o, h, w) for o in mod.parameters())/1e6\n",
    "        totf += flops\n",
    "        res += f'|{type(mod).__name__}|{tuple(inp[0].shape)}|{tuple(outp.shape)}|{nparms}|{flops:.1f}|\\n'\n",
    "    with Hooks(self.model, _f) as hooks: self.fit(1, lr=1, cbs=SingleBatchCB())\n",
    "    print(f\"Tot params: {totp}; MFLOPS: {totf:.1f}\")\n",
    "    if fc.IN_NOTEBOOK:\n",
    "        from IPython.display import Markdown\n",
    "        return Markdown(res)\n",
    "    else: print(res)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Tot params: 14538; MFLOPS: 0.4\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/tmp/ipykernel_6897/3850268229.py:8: FutureWarning: `torch.cuda.amp.GradScaler(args...)` is deprecated. Please use `torch.amp.GradScaler('cuda', args...)` instead.\n",
      "  def before_fit(self, learn): self.scaler = torch.cuda.amp.GradScaler()\n"
     ]
    },
    {
     "data": {
      "text/markdown": [
       "|Module|Input|Output|Num params|MFLOPS|\n",
       "|--|--|--|--|--|\n",
       "|Conv2d|(1024, 1, 28, 28)|(1024, 16, 14, 14)|160|0.0|\n",
       "|ReLU|(1024, 16, 14, 14)|(1024, 16, 14, 14)|0|0.0|\n",
       "|BatchNorm2d|(1024, 16, 14, 14)|(1024, 16, 14, 14)|32|0.0|\n",
       "|Conv2d|(1024, 16, 14, 14)|(1024, 32, 7, 7)|4640|0.2|\n",
       "|ReLU|(1024, 32, 7, 7)|(1024, 32, 7, 7)|0|0.0|\n",
       "|BatchNorm2d|(1024, 32, 7, 7)|(1024, 32, 7, 7)|64|0.0|\n",
       "|Conv2d|(1024, 32, 7, 7)|(1024, 32, 4, 4)|9248|0.1|\n",
       "|ReLU|(1024, 32, 4, 4)|(1024, 32, 4, 4)|0|0.0|\n",
       "|BatchNorm2d|(1024, 32, 4, 4)|(1024, 32, 4, 4)|64|0.0|\n",
       "|AdaptiveAvgPool2d|(1024, 32, 4, 4)|(1024, 32, 1, 1)|0|0.0|\n",
       "|Flatten|(1024, 32, 1, 1)|(1024, 32)|0|0.0|\n",
       "|Linear|(1024, 32)|(1024, 10)|330|0.0|\n"
      ],
      "text/plain": [
       "<IPython.core.display.Markdown object>"
      ]
     },
     "execution_count": null,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "learn.summary()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#| export\n",
    "class BatchTransformCB(Callback):\n",
    "    def __init__(self, tfm, on_train=True, on_val=True): fc.store_attr()\n",
    "\n",
    "    def before_batch(self, learn):\n",
    "        if (self.on_train and learn.training) or (self.on_val and not learn.training):\n",
    "            learn.batch = self.tfm(learn.batch)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def _norm(b): return (b[0]-xmean)/xstd,b[1]\n",
    "norm = BatchTransformCB(_norm)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#|export\n",
    "class GeneralRelu(nn.Module):\n",
    "    def __init__(self, leak=None, sub=None, maxv=None):\n",
    "        super().__init__()\n",
    "        self.leak,self.sub,self.maxv = leak,sub,maxv\n",
    "\n",
    "    def forward(self, x): \n",
    "        x = F.leaky_relu(x,self.leak) if self.leak is not None else F.relu(x)\n",
    "        if self.sub is not None: x -= self.sub\n",
    "        if self.maxv is not None: x.clamp_max_(self.maxv)\n",
    "        return x"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Data augmentation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import random"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#|export\n",
    "def _rand_erase1(x, pct, xm, xs, mn, mx):\n",
    "    szx = int(pct*x.shape[-2])\n",
    "    szy = int(pct*x.shape[-1])\n",
    "    stx = int(random.random()*(1-pct)*x.shape[-2])\n",
    "    sty = int(random.random()*(1-pct)*x.shape[-1])\n",
    "    nn.init.normal_(x[:,:,stx:stx+szx,sty:sty+szy], mean=xm, std=xs)\n",
    "    x.clamp_(mn, mx)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#|export\n",
    "def rand_erase(x, pct=0.2, min_num=0, max_num = 4):\n",
    "    xm,xs,mn,mx = x.mean(),x.std(),x.min(),x.max()\n",
    "    num = random.randint(min_num, max_num)\n",
    "    for i in range(num): _rand_erase1(x, pct, xm, xs, mn, mx)\n",
    "    return x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 390x390 with 9 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.rcParams['image.cmap'] = 'gray_r'\n",
    "xb,_ = next(iter(dls.train))\n",
    "xbt = xb[:9]\n",
    "rand_erase(xbt, 0.2, 3, 3)\n",
    "show_images(xbt, imsize=1.3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#|export\n",
    "class RandErase(nn.Module):\n",
    "    def __init__(self, pct=0.2, max_num=4):\n",
    "        super().__init__()\n",
    "        self.pct,self.max_num = pct,max_num\n",
    "    def forward(self, x): return rand_erase(x, self.pct, self.max_num)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#|export\n",
    "def _rand_copy1(x, pct):\n",
    "    szx = int(pct*x.shape[-2])\n",
    "    szy = int(pct*x.shape[-1])\n",
    "    stx1 = int(random.random()*(1-pct)*x.shape[-2])\n",
    "    sty1 = int(random.random()*(1-pct)*x.shape[-1])\n",
    "    stx2 = int(random.random()*(1-pct)*x.shape[-2])\n",
    "    sty2 = int(random.random()*(1-pct)*x.shape[-1])\n",
    "    x[:,:,stx1:stx1+szx,sty1:sty1+szy] = x[:,:,stx2:stx2+szx,sty2:sty2+szy]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#|export\n",
    "def rand_copy(x, pct=0.2, min_num=0, max_num=4):\n",
    "    num = random.randint(min_num, max_num)\n",
    "    for i in range(num): _rand_copy1(x, pct)\n",
    "    return x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 390x390 with 9 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "xbt = xb[:9]\n",
    "xb,_ = next(iter(dls.train))\n",
    "rand_copy(xbt, 0.2, 3, 3)\n",
    "show_images(xbt, imsize=1.3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#|export\n",
    "class RandCopy(nn.Module):\n",
    "    def __init__(self, pct=0.2, max_num=4):\n",
    "        super().__init__()\n",
    "        self.pct,self.max_num = pct,max_num\n",
    "    def forward(self, x): return rand_copy(x, self.pct, self.max_num)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Clean memory"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#|export\n",
    "def clean_ipython_hist():\n",
    "    # Code in this function mainly copied from IPython source\n",
    "    if not 'get_ipython' in globals(): return\n",
    "    ip = get_ipython()\n",
    "    user_ns = ip.user_ns\n",
    "    ip.displayhook.flush()\n",
    "    pc = ip.displayhook.prompt_count + 1\n",
    "    for n in range(1, pc): user_ns.pop('_i'+repr(n),None)\n",
    "    user_ns.update(dict(_i='',_ii='',_iii=''))\n",
    "    hm = ip.history_manager\n",
    "    hm.input_hist_parsed[:] = [''] * pc\n",
    "    hm.input_hist_raw[:] = [''] * pc\n",
    "    hm._i = hm._ii = hm._iii = hm._i00 =  ''"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#|export\n",
    "def clean_tb():\n",
    "    # h/t Piotr Czapla\n",
    "    if hasattr(sys, 'last_traceback'):\n",
    "        traceback.clear_frames(sys.last_traceback)\n",
    "        delattr(sys, 'last_traceback')\n",
    "    if hasattr(sys, 'last_type'): delattr(sys, 'last_type')\n",
    "    if hasattr(sys, 'last_value'): delattr(sys, 'last_value')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#|export\n",
    "def clean_mem():\n",
    "    clean_tb()\n",
    "    clean_ipython_hist()\n",
    "    gc.collect()\n",
    "    torch.cuda.empty_cache()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## export -"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from nbdev import nbdev_export; nbdev_export()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "python3",
   "language": "python",
   "name": "python3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}