lec_9_v5.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 146,
   "id": "71f2ac91",
   "metadata": {},
   "outputs": [],
   "source": [
    "import torch\n",
    "import matplotlib.pyplot as plt\n",
    "import torch.nn as nn\n",
    "from torch import tensor\n",
    "import torch.nn.functional as F\n",
    "import torchvision.transforms.functional as TF\n",
    "import matplotlib as mpl\n",
    "from datasets import load_dataset\n",
    "from torch.utils.data import DataLoader, default_collate\n",
    "from operator import itemgetter, attrgetter\n",
    "mpl.rcParams['image.cmap'] = 'gray'\n",
    "torch.set_printoptions(precision=2, linewidth=140, sci_mode=False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "bf840846",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Found cached dataset fashion_mnist (/Users/arun/.cache/huggingface/datasets/fashion_mnist/fashion_mnist/1.0.0/0a671f063342996f19779d38c0ab4abef9c64f757b35af8134b331c294d7ba48)\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "3e85c3161a424d23a00ac11b37522a21",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "  0%|          | 0/2 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "name = 'fashion_mnist'\n",
    "x,y = 'image', 'label'\n",
    "rds = load_dataset(name)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 339,
   "id": "5ecc92e4",
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_dls(train_ds, valid_ds, batch_size, **kwargs):\n",
    "    return (\n",
    "        DataLoader(train_ds, batch_size=batch_size, shuffle=True, **kwargs),\n",
    "        DataLoader(train_ds, batch_size=batch_size*2, shuffle=True, **kwargs)\n",
    "    )\n",
    "\n",
    "def collate_dict(d):\n",
    "    g = itemgetter(*d.features)\n",
    "    def _f(b):\n",
    "        return g(default_collate(b))\n",
    "    return _f\n",
    "\n",
    "class DataLoaders:\n",
    "    def __init__(self, *dls):\n",
    "        self.train_dl,self.val_dl = dls[:2]\n",
    "    \n",
    "    @classmethod\n",
    "    def from_dd(cls, ds, batch_size, **kwargs):\n",
    "        f = collate_dict(ds['train'])\n",
    "        return cls(*get_dls(*ds.values(), batch_size=batch_size, collate_fn=f, **kwargs))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 340,
   "id": "ce421490",
   "metadata": {},
   "outputs": [],
   "source": [
    "def inplace(f):\n",
    "    def _f(b):\n",
    "        f(b)\n",
    "        return b\n",
    "    return _f\n",
    "\n",
    "@inplace\n",
    "def transform_(b):\n",
    "    x,y = 'image', 'label'\n",
    "    b[x] = [torch.flatten(TF.to_tensor(ele)) for ele in b[x]]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 341,
   "id": "87c9aa0f",
   "metadata": {},
   "outputs": [],
   "source": [
    "tds = rds.with_transform(transform_)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 342,
   "id": "4b836730",
   "metadata": {},
   "outputs": [],
   "source": [
    "bs = 1024\n",
    "dls = DataLoaders.from_dd(tds, batch_size=bs)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 343,
   "id": "d3e477bd",
   "metadata": {},
   "outputs": [],
   "source": [
    "class CancelFitException(Exception):\n",
    "    pass\n",
    "class CancelBatchException(Exception):\n",
    "    pass\n",
    "class CancelEpochException(Exception):\n",
    "    pass"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 344,
   "id": "97fbc420",
   "metadata": {},
   "outputs": [],
   "source": [
    "class Callback():\n",
    "    order = 0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 383,
   "id": "11585e7d",
   "metadata": {},
   "outputs": [],
   "source": [
    "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:\n",
    "            method(learn)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 384,
   "id": "649ed60f",
   "metadata": {},
   "outputs": [],
   "source": [
    "n,nh = 28*28,50\n",
    "\n",
    "def get_model():\n",
    "    return nn.Sequential(*[\n",
    "        nn.Linear(n, nh),\n",
    "        nn.ReLU(),\n",
    "        nn.Linear(nh, 10)\n",
    "    ])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 385,
   "id": "b1a9d79f",
   "metadata": {},
   "outputs": [],
   "source": [
    "class Metric:\n",
    "    def __init__(self):\n",
    "        self.reset()\n",
    "    \n",
    "    def reset(self):\n",
    "        self.ns,self.vals = [],[]\n",
    "    \n",
    "    def add(self, inp, targ=None, n=1):\n",
    "        self.last = self.calc(inp, targ)\n",
    "        self.ns.append(n)\n",
    "        self.vals.append(self.last)\n",
    "    \n",
    "    def calc(self, inp, targ):\n",
    "        return inp\n",
    "\n",
    "    @property\n",
    "    def value(self):\n",
    "        ns = tensor(self.ns)\n",
    "        return (tensor(self.vals)*ns).sum()/ns.sum()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 386,
   "id": "4821f671",
   "metadata": {},
   "outputs": [],
   "source": [
    "class Accuracy(Metric):\n",
    "    def calc(self, inp, targ):\n",
    "        return(inp == targ).float().mean()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 387,
   "id": "51721a99",
   "metadata": {},
   "outputs": [],
   "source": [
    "acc = Accuracy()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 388,
   "id": "44d5fd24",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tensor(0.45)"
      ]
     },
     "execution_count": 388,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "acc.add(tensor([0, 1, 2, 0, 1, 2]), tensor([0, 1, 1, 2, 1, 0]))\n",
    "acc.add(tensor([1, 1, 2, 0, 1]), tensor([0, 1, 1, 2, 1]))\n",
    "acc.value"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 389,
   "id": "8e587982",
   "metadata": {},
   "outputs": [],
   "source": [
    "loss = Metric()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 390,
   "id": "a8c5dbeb",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(tensor(0.62), 0.62)"
      ]
     },
     "execution_count": 390,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "loss.add(0.6, n=32)\n",
    "loss.add(0.9, n=2)\n",
    "loss.value, round((0.6*32+0.9*2)/(32+2), 2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 391,
   "id": "994d8b06",
   "metadata": {},
   "outputs": [],
   "source": [
    "from torcheval.metrics import MulticlassAccuracy, Mean"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 392,
   "id": "45d85a6b",
   "metadata": {},
   "outputs": [],
   "source": [
    "metric = MulticlassAccuracy()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 393,
   "id": "fc5f3db8",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<torcheval.metrics.classification.accuracy.MulticlassAccuracy at 0x1813a6010>"
      ]
     },
     "execution_count": 393,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "metric.update(tensor([0, 1, 2, 0, 1, 2]), tensor([0, 1, 1, 2, 1, 0]))\n",
    "metric.update(tensor([1, 1, 2, 0, 1]), tensor([0, 1, 1, 2, 1]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 394,
   "id": "d11cbc43",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tensor(0.45)"
      ]
     },
     "execution_count": 394,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "metric.compute()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 395,
   "id": "6bfde09d",
   "metadata": {},
   "outputs": [],
   "source": [
    "metric = Mean()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 396,
   "id": "45ec8440",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<torcheval.metrics.aggregation.mean.Mean at 0x18166a650>"
      ]
     },
     "execution_count": 396,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "metric.update(torch.tensor(0.6), weight=32)\n",
    "metric.update(torch.tensor(0.9), weight=2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 397,
   "id": "e6e18613",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tensor(0.62, dtype=torch.float64)"
      ]
     },
     "execution_count": 397,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "metric.compute()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 398,
   "id": "ba12cbcb",
   "metadata": {},
   "outputs": [],
   "source": [
    "import copy"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 409,
   "id": "86e81ec8",
   "metadata": {},
   "outputs": [],
   "source": [
    "class MetricsCB(Callback):\n",
    "    def __init__(self, *ms, **metrics):\n",
    "        self.metrics = metrics\n",
    "        for m in ms:\n",
    "            self.metrics[type(m).__name__] = m\n",
    "        self.all_metrics = copy.copy(metrics)\n",
    "        self.all_metrics['loss'] = self.loss = Mean()\n",
    "    \n",
    "    def before_fit(self, learn):\n",
    "        learn.metrics = self\n",
    "    \n",
    "    def before_epoch(self, learn):\n",
    "        [m.reset() for m in self.all_metrics.values()]\n",
    "    \n",
    "    def after_batch(self, learn):\n",
    "        x,y,*_ = learn.batch\n",
    "        for m in self.metrics.values():\n",
    "            m.update(learn.preds, y)\n",
    "        self.loss.update(learn.loss, weight=len(x))\n",
    "    \n",
    "    def _log(self, d):\n",
    "        print(d)\n",
    "    \n",
    "    def after_epoch(self, learn):\n",
    "        log = {k: f'{m.compute():.3f}' for k, m in self.all_metrics.items()}\n",
    "        log['epoch'] = learn.epoch\n",
    "        log['train'] = 'train' if learn.model.training else 'val'\n",
    "        self._log(log)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 410,
   "id": "190a4924",
   "metadata": {},
   "outputs": [],
   "source": [
    "class with_cbs:\n",
    "    def __init__(self, nm):\n",
    "        self.nm = nm\n",
    "    \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']:\n",
    "                pass\n",
    "            finally:\n",
    "                o.callback(f'cleanup_{self.nm}')    \n",
    "        return _f"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 411,
   "id": "879e863c",
   "metadata": {},
   "outputs": [],
   "source": [
    "import torch.optim as optim\n",
    "import fastcore.all as fc\n",
    "from functools import partial\n",
    "import copy"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 412,
   "id": "5a15fd86",
   "metadata": {},
   "outputs": [],
   "source": [
    "class TrainCB(Callback):\n",
    "    def __init__(self, n_inp=1):\n",
    "        self.n_inp = n_inp\n",
    "\n",
    "    def predict(self, learn):\n",
    "        learn.preds = learn.model(*learn.batch[:self.n_inp])\n",
    "    \n",
    "    def get_loss(self, learn):\n",
    "        learn.loss = learn.loss_func(learn.preds, *learn.batch[self.n_inp:])\n",
    "    \n",
    "    def backward(self, learn):\n",
    "        learn.loss.backward()\n",
    "    \n",
    "    def step(self, learn):\n",
    "        learn.opt.step()\n",
    "    \n",
    "    def zero_grad(self, learn):\n",
    "        learn.opt.zero_grad()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 470,
   "id": "df6bbdae",
   "metadata": {},
   "outputs": [],
   "source": [
    "class Learner():\n",
    "    def __init__(self, model, dls=(0,), lr=0.1, loss_func=F.cross_entropy, opt_func=optim.SGD, cbs=None):\n",
    "        cbs = fc.L(cbs)\n",
    "        fc.store_attr()\n",
    "    \n",
    "    def __getattr__(self, name):\n",
    "        if name in ('predict', 'get_loss', 'backward', 'step', 'zero_grad'):\n",
    "            return partial(self.callback, name)\n",
    "        raise AttributeError(name)\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",
    "    @property\n",
    "    def training(self):\n",
    "        return self.model.training\n",
    "        \n",
    "    @with_cbs('epoch')\n",
    "    def _one_epoch(self):\n",
    "        for self.batch in self.dl:\n",
    "            self._one_batch()\n",
    "    \n",
    "    def one_epoch(self, train):\n",
    "        self.dl = self.dls.train_dl if train else self.dls.val_dl\n",
    "        self.model.train(train)\n",
    "        self._one_epoch()\n",
    "    \n",
    "    @with_cbs('fit')\n",
    "    def _fit(self, train, val):\n",
    "        for self.epoch in self.epochs:\n",
    "            if train:\n",
    "                self.one_epoch(True)\n",
    "            if val:\n",
    "                with torch.no_grad():\n",
    "                    self.one_epoch(False)\n",
    "    \n",
    "    def fit(self, n_epochs=1, train=True, val=True, cbs=None, lr=None):\n",
    "        cbs = fc.L(cbs)\n",
    "        for cb in cbs:\n",
    "            self.cbs.add(cb)\n",
    "        try:\n",
    "            self.n_epochs = n_epochs\n",
    "            self.epochs = range(n_epochs)\n",
    "            lr = lr if lr is not None else self.lr\n",
    "            self.opt = self.opt_func(self.model.parameters(), lr=lr)\n",
    "            self._fit(train, val)\n",
    "        finally:\n",
    "            for cb in cbs:\n",
    "                self.cbs.remove(cb)\n",
    "\n",
    "    def callback(self, method_nm):\n",
    "        run_cbs(self.cbs, method_nm, self)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 471,
   "id": "6eb6fe5d",
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'Accuracy': '0.606', 'loss': '1.363', 'epoch': 0, 'train': 'train'}\n",
      "{'Accuracy': '0.675', 'loss': '0.892', 'epoch': 0, 'train': 'val'}\n",
      "{'Accuracy': '0.716', 'loss': '0.787', 'epoch': 1, 'train': 'train'}\n",
      "{'Accuracy': '0.729', 'loss': '0.742', 'epoch': 1, 'train': 'val'}\n",
      "{'Accuracy': '0.753', 'loss': '0.693', 'epoch': 2, 'train': 'train'}\n",
      "{'Accuracy': '0.763', 'loss': '0.660', 'epoch': 2, 'train': 'val'}\n"
     ]
    }
   ],
   "source": [
    "model = get_model()\n",
    "metrics = MetricsCB(Accuracy=MulticlassAccuracy())\n",
    "cbs = [TrainCB(), metrics]\n",
    "learn = Learner(model, dls=dls, cbs=cbs)\n",
    "learn.fit(3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "10ce2ae4",
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "from fastprogress import master_bar, progress_bar"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 443,
   "id": "c8c1085a",
   "metadata": {},
   "outputs": [],
   "source": [
    "class ProgressCB(Callback):\n",
    "    order = MetricsCB.order + 1\n",
    "    \n",
    "    def __init__(self, plot=False):\n",
    "        self.plot = plot\n",
    "\n",
    "    def before_fit(self, learn):\n",
    "        if hasattr(learn, 'metrics'):\n",
    "            learn.metrics._log = self._log\n",
    "        learn.epochs = self.mbar = master_bar(learn.epochs)\n",
    "        self.first = True\n",
    "        self.losses = []\n",
    "        self.val_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):\n",
    "        learn.dl = progress_bar(learn.dl, leave=False, parent=self.mbar)\n",
    "    \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",
    "            if self.val_losses:\n",
    "                self.mbar.update_graph([[fc.L.range(self.losses), self.losses],\\\n",
    "                [[fc.L.range(learn.epoch).map(lambda x: (x+1)*len(learn.dls.train_dl)) ,self.val_losses]]])\n",
    "    \n",
    "    def after_epoch(self, learn):\n",
    "        if not learn.training:\n",
    "            if self.plot and hasattr(learn, 'metrics'):\n",
    "                self.val_losses.append(learn.metrics.all_metrics['loss'].compute())\n",
    "                self.mbar.update_graph([[fc.L.range(self.losses), self.losses],\\\n",
    "                        [fc.L.range(learn.epoch+1).map(lambda x: (x+1)*len(learn.dls.train_dl)), self.val_losses]])\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 445,
   "id": "1fd1dccd",
   "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.589</td>\n",
       "      <td>1.385</td>\n",
       "      <td>0</td>\n",
       "      <td>train</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>0.665</td>\n",
       "      <td>0.909</td>\n",
       "      <td>0</td>\n",
       "      <td>val</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>0.721</td>\n",
       "      <td>0.796</td>\n",
       "      <td>1</td>\n",
       "      <td>train</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>0.739</td>\n",
       "      <td>0.723</td>\n",
       "      <td>1</td>\n",
       "      <td>val</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>0.747</td>\n",
       "      <td>0.704</td>\n",
       "      <td>2</td>\n",
       "      <td>train</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>0.780</td>\n",
       "      <td>0.634</td>\n",
       "      <td>2</td>\n",
       "      <td>val</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAXoAAAD4CAYAAADiry33AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/bCgiHAAAACXBIWXMAAAsTAAALEwEAmpwYAAA3tklEQVR4nO3dd3xV9f3H8dcnN3vvHUgIYRNCCFsRxIF7VsFR26rU1braattfW2tba4e7jmLFiaKCW1RcgLITZISZAAEyyIKEhCRkfX9/3AsEyAJucm9uPs/HI4/ce8733vu5h/C+537P93yPGGNQSinlutwcXYBSSqmupUGvlFIuToNeKaVcnAa9Ukq5OA16pZRyce6OLqA14eHhJjEx0dFlKKVUj5GVlVVmjIlobZ1TBn1iYiKZmZmOLkMppXoMEdnV1jrtulFKKRenQa+UUi5Og14ppVycU/bRK6XUyWhoaCA/P5+6ujpHl9LlvL29iY+Px8PDo9OP0aBXSvV4+fn5BAQEkJiYiIg4upwuY4yhvLyc/Px8kpKSOv047bpRSvV4dXV1hIWFuXTIA4gIYWFhJ/3NRYNeKeUSXD3kDzuV9+kyQV/X0MSLS3awLLfM0aUopZRTcZmgd3cTXvxuBy99v9PRpSilepmKigqee+65k37chRdeSEVFhf0LOo7rBL3FjatHxfPt1hKKKmsdXY5SqhdpK+ibmprafdyCBQsIDg7uoqqOcpmgB7h2dALNBuZl5ju6FKVUL/Lggw+yfft20tLSGD16NFOmTOG6665j+PDhAFx++eWMGjWKoUOHMmvWrCOPS0xMpKysjLy8PAYPHsytt97K0KFDOe+886ittd8Oq0sNr+wb5sfE/mG8nbmHO6f0x82tdxycUUod9eePN7Kp8IBdn3NIbCB/umRom+sfffRRsrOzWbt2LYsWLeKiiy4iOzv7yBDI2bNnExoaSm1tLaNHj+aqq64iLCzsmOfIycnhrbfe4sUXX+Saa65h/vz53HDDDXapv8M9ehFJEJFvRWSziGwUkbtbaXO9iKy3/SwTkREt1uWJyAYRWSsiXT5T2bWj+5C/v5al2/WgrFLKMcaMGXPMOPenn36aESNGMG7cOPbs2UNOTs4Jj0lKSiItLQ2AUaNGkZeXZ7d6OrNH3wjcb4xZIyIBQJaIfGmM2dSizU7gLGPMfhG5AJgFjG2xfooxpluS9/yhUQT7ejB31R7OTGl1xk6llAtrb8+7u/j5+R25vWjRIr766iuWL1+Or68vkydPbnUcvJeX15HbFovFrl03He7RG2OKjDFrbLergM1A3HFtlhlj9tvurgDi7VbhSfJyt3DlyHgWbtpLefUhR5WhlOpFAgICqKqqanVdZWUlISEh+Pr6smXLFlasWNHN1Z3kwVgRSQRGAivbaXYz8FmL+wZYKCJZIjKzneeeKSKZIpJZWlp6MmWdYMaYBBqaDO+tKTit51FKqc4ICwtj4sSJDBs2jF//+tfHrJs2bRqNjY2kpqbyhz/8gXHjxnV7fWKM6VxDEX9gMfA3Y8x7bbSZAjwHnGGMKbctizXGFIpIJPAl8AtjzJL2XisjI8Oc7oVHrnp+GRU19Xx131m95ow5pXqrzZs3M3jwYEeX0W1ae78ikmWMyWitfaf26EXEA5gPzGkn5FOB/wGXHQ55AGNMoe13CfA+MKYzr3m6rh4Vz/bSg2wuav3rlFJK9RadGXUjwEvAZmPM42206QO8B9xojNnWYrmf7QAuIuIHnAdk26Pwjpw3JAo3gc+yi7rj5ZRSyml1Zo9+InAjcLZtiORaEblQRG4Tkdtsbf4IhAHPHTeMMgr4XkTWAauAT40xn9v7TbQmzN+LsUlhfJa9tzteTimlnFaHwyuNMd8D7XZyG2NuAW5pZfkOYMSJj+geFwyP5o8fbiSnuIqUqABHlaGUUg7lUlMgHO/8odGIwHs/6OgbpVTv5dJBHxXozZSBkTy/aDu3vpZJRU29o0tSSqlu59JBD/D8Dek8MG0QX28u5sXvdji6HKWUAsDf3x+AwsJCrr766lbbTJ48mdMdag69IOi93C3cPjmZMUmhfLWpxNHlKKXUMWJjY5k3b16XvobLB/1h5w6JZmtxFbvLaxxdilLKBT3wwAPHzEn/0EMP8ec//5mpU6eSnp7O8OHD+fDDD094XF5eHsOGDQOgtraW6dOnk5qayrXXXmu3+W5capri9pw7OIq/fLKJLzcXc/MZnb96ulKqh/nsQdi7wb7PGT0cLni03SbTp0/nnnvu4Y477gDgnXfe4fPPP+fee+8lMDCQsrIyxo0bx6WXXtrm2frPP/88vr6+rF+/nvXr15Oenm6X8nvNHn2fMF8GRgXw5SYdV6+Usr+RI0dSUlJCYWEh69atIyQkhJiYGH73u9+RmprKOeecQ0FBAcXFxW0+x5IlS47MQZ+amkpqaqpdaus1e/QA5w6J4vnF2ymvPkSYv1fHD1BK9Twd7Hl3pauvvpp58+axd+9epk+fzpw5cygtLSUrKwsPDw8SExNbnaK4pa6Ym6vX7NEDXD4yjmZjmL1ULyCulLK/6dOnM3fuXObNm8fVV19NZWUlkZGReHh48O2337Jr1652Hz9p0iTmzJkDQHZ2NuvXr7dLXb0q6PtH+nPhsBheXbaLypoGR5ejlHIxQ4cOpaqqiri4OGJiYrj++uvJzMwkIyODOXPmMGjQoHYff/vtt1NdXU1qair//Oc/GTPGPnNAdnqa4u5kj2mK27K56AAXPPUd95yTwj3nDOiS11BKdS+dptgO0xS7ksExgUwdFMkbK3bjjB9ySillb70u6AGmDYumrPoQW/bqXPVKKdfXK4P+8EXDv8s5vUsWKqWcR2/5hn4q77NXBn10kDcpkf58l1Pm6FKUUnbg7e1NeXm5y4e9MYby8nK8vb1P6nG9ahx9S2emRDBn5S7qGprw9rA4uhyl1GmIj48nPz+f0lLX/5bu7e1NfHz8ST2mFwd9OLOX7mR13r4jXTlKqZ7Jw8ODpCSd2qQtvbLrBmBsv1A8LKLdN0opl9drg97X052MvqEa9Eopl9drgx7gjJRwNhcdoKSq/bknlFKqJ+vVQT/J1je/NFf36pVSrqvDoBeRBBH5VkQ2i8hGEbm7lTYiIk+LSK6IrBeR9BbrponIVtu6B+39Bk7H0NhAQnw9tPtGKeXSOrNH3wjcb4wZDIwD7hSRIce1uQBIsf3MBJ4HEBEL8Kxt/RBgRiuPdRg3N2Fi/3C+yylz+fG3Sqneq8OgN8YUGWPW2G5XAZuBuOOaXQa8ZqxWAMEiEgOMAXKNMTuMMfXAXFtbpzEpJYLSqkNsLDzg6FKUUqpLnFQfvYgkAiOBlcetigP2tLifb1vW1vLWnnumiGSKSGZ3nvRw9uBIArzd+dNHG2lsau6211VKqe7S6aAXEX9gPnCPMeb43d/WLoli2ll+4kJjZhljMowxGRER3XcCU7i/F3+9fBhZu/bz3KLt3fa6SinVXToV9CLigTXk5xhj3mulST6Q0OJ+PFDYznKncllaHJeOiOXpr3Morz7k6HKUUsquOjPqRoCXgM3GmMfbaPYR8GPb6JtxQKUxpghYDaSISJKIeALTbW2dzh1TkmlsNizYUOToUpRSyq46M9fNROBGYIOIrLUt+x3QB8AY8wKwALgQyAVqgJ/a1jWKyF3AF4AFmG2M2WjPN2Avg6IDGRDlz0frCrlxfKKjy1FKKbvpMOiNMd/Tel97yzYGuLONdQuwfhA4vUtHxPLvhdsoqKglLtjH0eUopZRd9OozY493yYhYAD5Z53SHEZRS6pRp0LfQN8yP1PggFm4qdnQpSillNxr0xxmbFMqG/EoONTY5uhSllLILDfrjpPcJob6pWc+UVUq5DA3646T3DQHgh90Vji1EKaXsRIP+OFGB3sQF+7Bm935Hl6KUUnahQd+KtD7B/LBLg14p5Ro06FuR3ieEwso69lbqlaeUUj2fBn0r0vsEA5Cle/VKKRegQd+KobFBRAZ48djCrVTVNTi6HKWUOi0a9K3wdHfj6Rkj2bWvhgfmr9erTymlejQN+jaM6xfGveeksGDDXh1Tr5Tq0TTo23FRqnXum01FGvRKqZ5Lg74dfUJ98fZwY+veKkeXopRSp0yDvh0WN2FAVIAGvVKqR9Og78DAqAC2aNArpXowDfoODIwOoKz6kF5LVinVY2nQd2BgdACAdt8opXosDfoOHA567b5RSvVUGvQdiPD3ItTPU/folVI9VodBLyKzRaRERLLbWP9rEVlr+8kWkSYRCbWtyxORDbZ1mfYuvjuICAOjAlhfUElTs54hq5TqeTqzR/8KMK2tlcaYfxlj0owxacBvgcXGmH0tmkyxrc84rUod6OxBkWwuOsA1/11OQUWto8tRSqmT0mHQG2OWAPs6amczA3jrtCpyQrecmcST16axpegAjyzY7OhylFLqpNitj15EfLHu+c9vsdgAC0UkS0RmdvD4mSKSKSKZpaWl9irLLkSEy0fGcd7QaFbu2KeTnCmlehR7Hoy9BFh6XLfNRGNMOnABcKeITGrrwcaYWcaYDGNMRkREhB3Lsp/RiaGUVR9iZ9lBR5eilFKdZs+gn85x3TbGmELb7xLgfWCMHV+v241JCgVgdV5ne7KUUsrx7BL0IhIEnAV82GKZn4gEHL4NnAe0OnKnp0iO8CPMz5OVOzXolVI9h3tHDUTkLWAyEC4i+cCfAA8AY8wLtmZXAAuNMS37NKKA90Xk8Ou8aYz53H6ldz8RYXRiqO7RK6V6lA6D3hgzoxNtXsE6DLPlsh3AiFMtzFmNSQrl8417KaqsJSbIx9HlKKVUh/TM2JN0uJ9+5Q7dq1dK9Qwa9CdpcEwgQT4eLNte5uhSlFKqUzToT5LFTRjXL5Rl28sdXYpSSnWKBv0pmNg/nPz9tewur3F0KUop1SEN+lMwITkcgKXafaOU6gE06E9BcoQfUYFeLM3VoFdKOT8N+lMgIkxIDmf59nIampodXY5SSrVLg/4UXTIihvKD9fzhg2yd5Ewp5dQ06E/R2YOiuHNKMnNX72H20jxHl6OUUm3SoD8N9587kDFJoby5cpejS1FKqTZp0J8GNzdhdGIIu8prqG/UvnqllHPSoD9NKZEBNDYbdpXrHPVKKeekQX+a+kf6A5BbUu3gSpRSqnUa9KepX4QfoEGvlHJeGvSnydfTnbhgH3I06JVSTkqD3g5Sovx1j14p5bQ06O2gf4Q/20uraWrWE6eUUs5Hg94O+kf6c6ixmYL9tY4uRSmlTqBBbwdHRt6UVjm4EqWUOpEGvR0cDvp1eyodXIlSSp2ow6AXkdkiUiIi2W2snywilSKy1vbzxxbrponIVhHJFZEH7Vm4Mwn29WTKwAhe+n4nJQfqHF2OUkodozN79K8A0zpo850xJs328zCAiFiAZ4ELgCHADBEZcjrFOrM/XTKU+qZm/vrpZkeXopRSx+gw6I0xS4B9p/DcY4BcY8wOY0w9MBe47BSep0dIDPfj9rOS+WhdIWv3VDi6HKWUOsJeffTjRWSdiHwmIkNty+KAPS3a5NuWtUpEZopIpohklpaW2qms7jVzUj8CvNx5dVmeo0tRSqkj7BH0a4C+xpgRwDPAB7bl0krbNgeaG2NmGWMyjDEZERERdiir+/l5uXPVqHg+XV9EadUhR5ejlFKAHYLeGHPAGFNtu70A8BCRcKx78AktmsYDhaf7es7uxvF9qW9q5u3Vux1dilJKAXYIehGJFhGx3R5je85yYDWQIiJJIuIJTAc+Ot3Xc3bJEf6cmRLOGyt206jXk1VKOYHODK98C1gODBSRfBG5WURuE5HbbE2uBrJFZB3wNDDdWDUCdwFfAJuBd4wxG7vmbTiXm8YnsvdAHV9uKnZ0KUophXtHDYwxMzpY/x/gP22sWwAsOLXSeq4pgyKJD/Hh1eV5XDA8xtHlKKV6OT0ztgtY3IQbxvVlxY59bN2r0yIopRxLg76LXJuRgJe7G68tz3N0KUqpXk6DvouE+Hly6YhY3ltTQGVtg6PLUUr1Yhr0XeimCYnUNjQxPyvf0aUopXoxDfouNCwuiPQ+wby+YhfNelESpZSDaNB3sZsmJLKz7CDf5ZY5uhSlVC+lQd/FLhgWQ7i/F6/p/DdKKQfRoO9inu5uXDcmgW+2lrC7vMbR5SileiEN+m5w3di+uInwxspdji5FKdULadB3g+ggb84fGsXbq/dQ19Dk6HKUUr2MBn03uWFcXyprG/gsu8jRpSilehkN+m4yLimMvmG+vL16T8eNlVLKjjTou4mbm3BNRgIrduwjr+ygo8tRSvUiGvTd6OpR8bgJvJOpe/VKqe6jQd+NogK9OXtQFG+t2k31oUZHl6OU6iU06LvZXWf3Z39NA68s3UlzsyG3pNrRJSmlXFyHFx5R9pWWEMzUQZHMWrKD1Xn7WbytlFd+OprJAyMdXZpSykXpHr0D3HvuAA7UNbJ8Rzm+nhY++KHA0SUppVyY7tE7wLC4IGbdOIqkcD9mL83jo7UF1NY34eNpcXRpSikXpHv0DnLe0GhSogK4JDWGg/VNfLu1xNElKaVcVIdBLyKzRaRERLLbWH+9iKy3/SwTkREt1uWJyAYRWSsimfYs3FWM7RdGuL8XH68rdHQpSikX1Zk9+leAae2s3wmcZYxJBf4CzDpu/RRjTJoxJuPUSnRtFjfh4tQYvt5Swr6D9Y4uRynlgjoMemPMEmBfO+uXGWP22+6uAOLtVFuvMWNMH+obm5m7erejS1FKuSB799HfDHzW4r4BFopIlojMbO+BIjJTRDJFJLO0tNTOZTm3gdEBjO8XxhvLd9HY1ExlTQPG6KUHlVL2YbegF5EpWIP+gRaLJxpj0oELgDtFZFJbjzfGzDLGZBhjMiIiIuxVVo/xk4mJFFbWcd3/VpL2l4U8+VWOo0tSSrkIuwS9iKQC/wMuM8aUH15ujCm0/S4B3gfG2OP1XNE5g6PoE+rLuj0VDIkJ5Jlvclid12aPmVJKddppB72I9AHeA240xmxrsdxPRAIO3wbOA1oduaOsB2Xn3T6epQ+ezdyZ44gP8eXet9dSU69z4iilTk9nhle+BSwHBopIvojcLCK3ichttiZ/BMKA544bRhkFfC8i64BVwKfGmM+74D24jMgAb8L9vQjw9uDRq4aTv7+WD37QYZdKqdMjznjQLyMjw2Rm9u5h98YYLnr6e5qaDZ/fcyYi4uiSlFJOTESy2hrGrmfGOikR4ScTEtlaXMWKHdpXr5Q6dRr0TuzStFhCfD14YfF2mpqd75uXUqpn0KB3Yt4eFu6c0p/F20q5e+4P1Dc2O7okpVQPpLNXOrlbzuxHszE8smALhRW1PDV9JAmhvo4uSynVg+gefQ8wc1Iyz8wYSU5xNRc+9R1r91Q4uiSlVA+iQd9DXDIilgV3n0mQrwe3vZ5FadUhR5eklOohNOh7kIRQX/574ygqauu59bVMtpfq9WaVUh3ToO9hhsYG8fg1aWwrruK8J5bw38XbHV2SUsrJadD3QBcOj2HJb6Zw1oAIHlu4jb2VdY4uSSnlxDToe6hwfy/+fOlQmo3h+UW5ji5HKeXENOh7sIRQX64eFc9bq/dQWFHr6HKUUk5Kg76Hu3NKfwAufuZ73lixSy9YopQ6gQZ9D5cQ6sv7d0xgQJQ///dBNl9vLnF0SUopJ6NB7wKGxgbx+s1jiQ/x4T/f5upevVLqGBr0LsLD4sbtk5NZu6eCpbnlHT9AKdVr6Fw3LuTqUfE8/XUOD8xfz/jkMPbsq2FT4QH+++NRTEgOd3R5SikH0T16F+LlbuGfV48gNtibJdtKqaprxMPdjae/1guNK9Wb6R69izlrQARnDYg4cv/FJTv424LNrNtTwYiEYMcVppRyGN2jd3HTxyQQ4O3O84u206wXL1GqV9Kgd3EB3h78eHxfPt+4l/GPfs2bK3c7uiSlVDfrMOhFZLaIlIhIdhvrRUSeFpFcEVkvIukt1k0Tka22dQ/as3DVefeeM4Anr00jNtiHhz7aSP7+GgCq6hocXJlSqjt0Zo/+FWBaO+svAFJsPzOB5wFExAI8a1s/BJghIkNOp1h1atwtblw+Mo5nr0sHgSe/yuFfX2wh7eEvWblDh2Iq5eo6DHpjzBJgXztNLgNeM1YrgGARiQHGALnGmB3GmHpgrq2tcpDYYB9uHNeXeVn5PPvtdowxPPHVNkeXpZTqYvYYdRMH7GlxP9+2rLXlY+3weuo03DE5mY/XFTJ1cBT9I/35yyebeDdzD19s3Et8iC8PXjAIbw+Lo8tUStmRPYJeWllm2lne+pOIzMTa9UOfPn3sUJZqTZi/F8t/OxWLm1DX0MR/F2/n1/PW4+NhobahhBU7ynn1Z2OICvR2dKlKKTuxx6ibfCChxf14oLCd5a0yxswyxmQYYzIiIiLaaqbswOJm/Qz29rDw8GXDuDI9jq/vP4uXfzKa7aXVPPetzm+vlCuxR9B/BPzYNvpmHFBpjCkCVgMpIpIkIp7AdFtb5USmDYvm8WusI3KmDIrkkhGxvJuVT2WtjshRylV0ZnjlW8ByYKCI5IvIzSJym4jcZmuyANgB5AIvAncAGGMagbuAL4DNwDvGmI1d8B6UHf1sYhI19U28vVrH2yvlKsQZp7TNyMgwmZmZji6j17r2v8vZWlxFv3A/UuOD+b+LBuNu0XPrlHJmIpJljMlobZ3+71UnuO/cAcSH+CAivLIsj9/MX6/TJyjVg+mkZuoEY/uF8ckvzgTgqa9yeOKrbRyobeCRK4cTGaCjcZTqaXSPXrXrl1P784eLh7Akp4zznljC4m2lji5JKXWSNOhVu0SEm89IYsEvzyQ60JufvryKl77f2e7lCr/ZUszu8ppurFIp1R7tulGd0j/Sn/m3T+Cet9fyl0828e2WEs5MCSe78ABnpoRzxcg4PCxuFFXWcsurmYzqG8I7Px+P7F6Oyc8kW1Io9R/MxCEJeLnrmbdKdScddaNOijGGOSt388iCzdTUNxHm50n5wXr6hfvxzm3jeWPFLp78ynpFqzduHsvwbc8QtPpJABqNGznSh6DkscQOPRPiMyB8ALg5b/AXVNTybuYefnF2ypETzZRyRu2NutGgV6eksqaBQ01NRPh7sXBTMb948wfOGRLJD7sr6Bvmy+7yGnw8LZRV1xPSvJ/fjahhYNNWSrcsZ2DTNgKwde14BkBsmjX040ZBXAYExjj0vR1WU9/Ilc8tY8veKj66ayKp8cGOLkmpNrUX9Np1o05JkK8H4AHA+UOj+cXZ/XnsS+tMmH+6ZChl1Yf4vw+yGRQdwH9vvJi+YX4AFO0oJ3XWMh6a4MVNfcqhIBPyM2HZM9DcaH3ywDhb6I+yfgDEpIGXf7e+P2MMv3p3HVv2VgGwq7xGg171WBr0yi5um5zMguy97D9Yz9TBkbiJEO7vxaQB4fh6Hv0zG9cvjItS43hkVTFTJl5Gn7QZ1hUNdbB3vTX0CzKhIAs222bMEDeIGAzxtj3+uFEQObhLu3ye/TaXBRv2cs85KTz5VQ679+nBZdVzadeNspt9B+upqW8kPsS33XZFlbWc9/gShsUFMeeWsbi5CZU1Dby8bCeB3h4MiwtiVN8QFv2wmfkff8jPk/czglxr+NdVWJ/Eww9iR0Jcuq3bJwMCY0FOvx/9683F3PJaJpeNiOWJa9MY/bevmTookn9cnXraz61UV9GuG9UtQv08CfXz7LBdTJAPv7toML99bwPPLcrlrAGR3PfOWnJKqo+0OXyQVySVDUU+LPrVFCwC7NsB+ZmY/NUc2L6SwBXPI822Cdj8o1v09Y+yfgh4BZz0+/jXF1tJifTn0atSERH6hPqwa9/Bk34epZyFBr1yiOmjE1iwoYh/L9zGvxduI8DbnTdvHUtKZACrdu5jQXYRsUHeDI4J5L531rFkWylTBkVCWDKEJfP2ofE8+N0Gzh8YzPNTPXErWnO022fLJ7ZXEYgYZOvysXX7RA4BS9t/9nUNTeSUVHPH5OQjF2DpG+anl1xsoaKmntKqQ6REnfyHqHIMDXrlECLCSzeNJnPXPvL31TImKZTEcOsB24tSY7go1Trypr6xmUcWbOGNFbusQY+1i+jRz7cQEeDFF1sreCo+hXvP/TmM/TkAhYX5vDbvfX4xsBK/0rWwZQH88Ib1hd19rKN8Dh/ojRuFCYwnu7CKYXGBbCuuoqnZMCQm8EitfUJ9+WBtAYcam/QcAOCpr3N4c+VuFv16MjFBPo4uR3WCBr1yGE93NyYkh0Ny+21mjEngP9/mkltSRf/IAP726Waq6xpZcPeZzFqyg6e+zmFYXBDnDokC4JPcQ7xQ2I9hk0dy8fmxYAzs3wn5WdZ+/oJMWPUiLP8PAPXe4ew92BfftEmU+wwmADeGxB4N+r5hvhgDe/bV0j+ye0f/OKO8soMcamzmyS9z9LhFD6FBr5zej8cn8saKXdz/zjquH9eX+WvyuXNKMgOiAvjr5cPYVlzFvW+v5YM7J9I/0p/l263dLLmH+/xFMCFJvL7VjWlnXGKdmK2xHoqzoSCLNUu+oJ9kk7zhCZKBDd5g3hpg7eqJH8VgtxTcaWT3voMa9EBRZR0A72bt4dZJSfSP1C4cZ6dz3SinFxHgxd+uGM66/Ep+M2894/qFcu85AwDr5RBfuGEUXu5u3P/OWhqamlm1cx/AMQd31+dX8scPN3L3W2utUy67e0JcOvuH3sSP9/+MqfWPcYH36zwc/Ffe8v8xEtoPchbCp/cz+ONLyfa6maGf/Qg+/y1smAf786zfFE7B/77bwVO2s4d7ooKKWi4ZEYuPh4VZS3Y4uhzVCbpHr3qEC4fHMGNMAt/nlvHMjPRjLoQSG+zDfecN4PfvZzP7+50crG/C28ON3OKjQX84/JfvKOflZXncfEYSAB+tK6ShyXD92D7MWbmbbW7J3DB2Clw2zBrkFbsx+ZnMnTefsxv3QOZsWPGc9Ul9w4/p6ycuHXxCOnwvry7Po7KmgV+c3R+3HjatwoG6BqrqGhkeF8jBQ42s3VPh6JJUJ2jQqx7jkSuG09RsWr3a1ZUj4/nn51v598KtAFw2Io73fyigsakZd4sbK3eWkxjmS/9If/7x+RYmpYSTHOHPO5l7GBITyG1nJTNn5W7rgdjD/fMiENIXCenL3K8j+C7Yh5duTIPijbaTumwjfXK+OFpIWP+jJ3XFj4Ko4dZvDzbl1YfYs68WsH7jGBjds7o9iiqs3TaxwT4MjQ1k8bZS6hqajoxQUs5Jg171GCKCu6X1PWAfTwvXje3D84u2MyQmkNFJobyduYfd+2pIDPNj1c59XDAshl+dP5Dzn1zCfe+sY2L/cDYWHuDfPxpBQqgv/cL92FF2kCExQSc8f98wX3KKq8HiYR21E5sGo20r6yqh8Afr+P6CTJpyv8Z9/VzrOosnRKceOalr26FEwADC6rx9PS7oCyusH1KxwT5YRGhqNmzdW8WIhGDHFqbapX30ymX8eHxfPCzCmSnhRw6a5pZUs2VvFQfqGhnbL5SIAC8euWI4GwoqeWHxdq7NSOCq9DgApgyKxMvdjZSoEw+4pvcJYUfZQYoqa098Ye8g6DcZJv2KL4Y/Qf99T/Lp1C/hR69Yh3xaPGHNa/DeLYz/9BzWeP2cN7z/RVjm45DzJdTs68Ktcno+WlfIO5l7jtwvsAV9XLAPQ2OtH4gbCw84pLbWHKhr4Kcvr+K7HL1ATku6R69cRkyQD5/+8kxig4+O7c4pqT6yFzomKRSAacOiufmMJPLKDvLw5UMR27QJ9547gGsyElrthpgyKJK/f7aFRVtLmTGmD7X1TRRV1uLr6U500NHLK1qvwCXcv7CcxqvG8F1lPwj4EROGB3FJbCWvz3+PuOqNDCOXmLJXYc4r1geG9jt6Uld8BkQPB3evE+qoqmvgmW9yuSwt9kjQduRUu1aMMfzjsy2UVh9i8oAIIgO9KayoxcMiRPhbawvwcmdTUeVJP3dXMMbwm3fX8+3WUuJCfDgzJcLRJTmNTgW9iEwDngIswP+MMY8et/7XwPUtnnMwEGGM2ScieUAV0AQ0tjUXg1L2MKDF2ZqxQd7kllRTVddIXLDPMXPw/OHiISc81t/Lvc2ulJRIf2KDvFm0tYThcUFMn7WC6kONuLsJL96UwZSB1pO5lm0vJ6NvCLv21XD33LUEeLnjbhHmZeWz8Ywk5u2fyAXDrqIwOoB/f5zF4uuDCK/YYB3fn/c9bHgXAOPmAdHDkZbTN4cl8/4PBcxasoOXvt/JXVP6c++5A9rdHt/llPLTl1fz5q3jjnzQddbufTVH9uD/u2QHf7h4CIUVtUQHeR85iDw4NtBp9uhfXprH5xv34mlxOzq0VgGdCHoRsQDPAucC+cBqEfnIGLPpcBtjzL+Af9naXwLca4xp+X10ijGmzK6VK9WB5Eh/PllvHVXzs4lJp/VcIsLkQZF8+EMBZdX1eHu48fBlI5i9dCe3v5HFnFvGERXoxa7yGm4an8j45DDW7ang4hGx+HpY+L8Ps3np+50ApCUEMywuiIP48ERuNGcPSmXShHvwsLhBZQF7Ny/lw08/YlzxToaVvIFl1SxrEd7BjDDJPByQTHVEGv/7upJLRsS0OY69qq6BB+dvoLHZ8M2WEsYkhZJdUIkInfo28H2u9b9sRt8Q5qzcxe2TkymsqCO2xdmwQ2MDmbtqD03NxqEXZskpruLRz7dwzuBIgn09WbRVu25a6kwf/Rgg1xizwxhTD8wFLmun/QzgLXsUp9TpSEsIptnAr88fyO8vGnzazzdlYCQH65vI2rWf+84dyJXp8bz8kzFEBXpz15tr+HJTMQAT+4czOCaQ6WP64O/ljpub8PsLBxMfYg3IEQnBDIoOICncjzkrd3Pzq5lMfWwxn2cXQVAcr1ak8s+m6/iF119JqZ7Fp2fMg0uepm7AJXjWlnJDwzzuKPwda7xvI+ylMTDvZ7D8Odi9Ehqse+DNzYaHP95EUWUtsUHeLN9RjjGG297IYvqsFZ26pu+y3HJigrz5x9WpHGps5n/f7aSgopa4Fl1jQ2ICqW1oYmeZ4yZ9a2xq5v531+Hv5c6jV6WSEulPWfUhKmsauq2GF5fs4M2Vu49Z9uHaAv75+ZZuq6E9nQn6OGBPi/v5tmUnEBFfYBowv8ViAywUkSwRmdnWi4jITBHJFJHM0lL9NFan784p/Vn+27O5c0p/u+xtTkgOw9PixqDoAK4dnQBYT+Z6/Jo09h6o49HPthDm58mAVg7m+nm585/r0rlubB8GRAXgbnHjm/vP4oc/nMusG0fh62nhjjlryC6o5IMfCpiUEs6X901iyqBo7vyqnjcaJvNB/G+4oP5RtvxkI/xkAfNCZ7Kmvg9m93L44rcw+zz4ezyNz09i8RM30vzDm/xujIWr0mPJLqhk+fZy8vfXUlXXyB1vZlHX0HRMjW+u3M3qPOsX8eZmw7LtZUxItg5DvTg1lteX57H3QN0xx0CGx1u/GTz3be4Jz9dd3snMZ31+JX+9fBjh/l5HD8SXVnVbDS99v5Nnvsnh8LTvdQ1N/OWTTTy3aDsbCx1/DKMzQd/a/5C2Tgm8BFh6XLfNRGNMOnABcKeITGrtgcaYWcaYDGNMRkSEHkRRp8/bw2Kd7sBO/LzceeHGdJ69Pv2YD45RfUO4fmwfDjU2Mz457MjB3eOlJQTzyBXDjzxWRAjx8+S8odG8PXM8wb6e3Pzqaooq67hqVDxe7haevT6dswZE8H8fZPPwJ5voE+rL4L4xkDiRkHN/xc21v2Th+d/CfVvg2jmUDp/JutJmRh/4isc8X+CWdddyd+a5vGL5G7vm/Y7zLVk8c2kc2QUHeGHx9iO1bS46wO/e38BfP90MwKaiA+yvaeCMlDAA7prSn4P1TTQ1m2OCfmBUAHdMTua9Hwr40QvLqa1vP+xLDtTx1082kb/ffhdyWbHD+s3jwuHWifBajrjqDlV1Dew9UEdRZd2R1/xoXSFl1fVY3IQXneDs4c4cjM0HElrcjwcK22g7neO6bYwxhbbfJSLyPtauoCUnX6pSjnf2oKhWl/9m2iC2FFVxZXqrX3Y7FOTrwQPTBvLA/A0EeLtzzmDr63h7WJj9k9G8vHQn//piK1emxx35IDlrQARRgV78+4utjLxlLN9Wp/KHLAuhvufw7I0jGOVXaj3Iu3s1YWu+ZXztu8zwaIaFjzHBP5Kc7yOp3z8Ez+BY1m1tZJqbOyX5weTnhfPVFmu3x4TkcAAGRgcwbWg0n2/cS2zw0Q9PEeE30wYxNDaIO99cw+sr8pg5qfVZ6hZvK+Xet9ey72A9Pp4W7j9v4Cltq+Otz68gNf7oMYf4EF883bvvgOz20qPdVou3ldI/0p/Z3+9kUHQAE/uH88qyPH51/sAOL8jTlToT9KuBFBFJAgqwhvl1xzcSkSDgLOCGFsv8ADdjTJXt9nnAw/YoXClnEujtwbzbJ5zWc/xoVAJfbCxmWFzQMcMhLW7CLWf24/qxffF0P/ol3N3ixhPXpHHLa5lMfXwxVXWNnNE/nKempxHm7wWEQ+Rg3EfewENFy1mfV8RzZ1s42383lu2r8MjZTF3ud7g3lDG9uYHph0/gfeUh7gF+5hdM4JsJEBALAdH8LTSMUVFNjDpkoKgPBMSAbxi4uXFRagxzV4fz/KLtXDe2L/5ex0ZLZW0Dd725hpggb/y93NudOuGNFbt4ZVken9995pGzoDcVHuChjzZy2chYrrZ92wHrRerzymv4UcbRfVGLm5Ac4X9KQd/Q1ExNfRNBPh7ttmtqNny9uZipg6PIKbZ2EQV4ubMkp4w+ob5s2VvFv65OZWL/cF5dlsfLS/NaHenVXToMemNMo4jcBXyBdXjlbGPMRhG5zbb+BVvTK4CFxpiWR2WigPdteyDuwJvGmM/t+QaUchVubsLsn4xuc72P54lj4Sf0D+fNW8dx39tr+cmERO45Z0CrxyPOGhjBhoJK0s84G3w9CZ4Az7+ayZJtpTQ1N9LHu46Pf5LMU+8vobp0D5Hs56ZBXtBUDlVFULiGsIOl3ArwXsuiPSAgGgJieMY9jPfrm1nx2jecmT6cas9IttcFkDZkMK8sL6GqrpG3bk3jrVW7+WhtIc3N5oS5fuoamnjyqxzKqg+RXXiANNsZt099vY3Vu/axKm8f87Lyee/2CYgI6wsqABhx3IXb+0f688Pu/W1uy6q6Bn717jpC/Tz5+5VHp1p+9LMtvLcmn0W/mkKQb9thP39NPr+Zt55nZowkt7QaD4twRXocb6/eQ3ZBJYOiA7g0LRYvdwsXDo/hndV7uO/cAfh5OebUpU69qjFmAbDguGUvHHf/FeCV45btAEacVoVKqXalJQTzza8mt9tm5qR+XD0qnmDfo/Pu/GbaQGrqGxmdGMqV6XH4h/mRMDaUP364kamDIgmdftyHTmM9VBdD1V5r+B/+OWD9HVy1nemeBfgUfAEF4AWEAXwKt+DNNQERxHyZyMyGQBKa3Cj/ehMRsUkc9IrgP5k19EvqR51xp6z6EGDte09LCGZX+UEWbirm9rOSCfLx4O+fbWFdfiVpCcGsz7ce6Bwef+xw0f4R1qG1tfVNJ3xAllTV8eOXVrFlb5VtmOwwPCxuVNU1MHfVbg7WN/G/73e02bXU3GyO9Lsv2VbK/pp6ksL9mDIokteW78Li1sSz16cf+dZx04REPlpXyHtr8rlxfGK7/05dRc+MVaoX8LC4ERV47IHpAVEBvHnruGOWXToilq82l/Draa2EnLsnBCdYf9rg1WxYlbOHVes30cejktCmMpau3UiEKefKJAs0lhF7YD0/tRThtfRjAPyABwC2QLkJ5Ay/cEoIoW51JDSnsn6n4VyL4eb+kXiGxPLElzA/K5+0hGDW7qkgKdzvhK6WgdEBGAPPL8rl3nMHUN/UfCR4H/54EzvLDnLDuD68sWI3m4sOkBofzLysfA7WNzE4JpCXl1pnOG35wfifb3JYtr2cacOiySmpJsTXg+9zy/B0d2NYbBDj+4Uxsk8wt5zRj+SIoyOv0vsEkxofxCvL8rhhXN82D9Z3JTGnOKd2V8rIyDCZmZmOLkMpZQfZBZVsL63msjTrgermZsOIh7/gigE+FBXsxLOmmHvGBlCcv4Pdu3ZwXkIzh/YX4FlTQrhUIscN8mvCQgnBRMUlsrjQHUtQLJNGpVqPGQTGQEAMDb6RPPBxHu+tLaRPqC8FFbWMTQrl9snJ3PjSKn45NYUZYxIY//dv+NMlQ7hpfCJTH19MkI8H/7gqlWlPLeHOyf351fnWDzxjDOP+/jXFB6zfNmKDvLl9cjJ/+HAjAL+cmsJ97ZylPD8rn/vfXcecW8YysX94V2xmRCSrrZkHdI9eKdWlhsUFMSzuaNeKm5uQlhDCa+vLgAhe/dlFpAyIIAWOdLV8uLaAu+euJT3en9Ki3cyd3pc490o4UETBru2s3rCRwfsOEteUT9/qjfD1+8e8pgfwmIcffwoJo6AphPrISFbt9mLRqyHM8Ivg9n7B+DR70jfQwprdFSSGl7Kz7CBPXpvGwOgAzh4YybysfO47dwBubsK24mqKDxzirin92VR0gCtGxtmOH1iDvqMrj12UGsNDH23kvTUFXRb07dGgV0p1u5EJwXyXU8a1GQmcNeDoeTOH+9PH9bOO31+TX83PJ2UQN/zomc1xow037lrE3so60hKCeeyaEcT7maPHDmzHDKRqL0FVhQRV7YUD2xjuUYSlud4669brjwOwGKjYGkDl9nDe8glmzK5hsD+GXwZ58/S2g2zMsjB80GC+22qdz+f6cX2OuSD64amtUzoIem8PCxcMj+bT9UX89fJhrR5Y70oa9EqpbndpWhy799Xw+4tbn5oiKtCbfuF+VB1q5BdTU45ZZ3ETvrhnEm4ixww3JSzZ+tMGizHUV5XjWVt85MNgzcbNbNq6haimCtKCa7DkfgkHSxhhmnnJE/j0MfgUfoobl/qEEvlOX2sXUUAMBETzizDDhxXN9DOJUBtnnbK6jT74y0fG8U5mPl9tLuaSEbGAddrnqACvVi+mY0/aR6+UckrZBZVY3ITBMYFd9hrr9lRw2bNLCfByZ9lvzybA2wOaGuFgCf+et4iCPTt45NwIXvl8GeMjGkgLqrF9cyi0XnDmeB6+tuGmsbbf0RBovd3sH8OP3txJeHQi//3ZRHaWHeS8JxYzdVAUz9+QftoHabWPXinV47Ts1+8qQ2IDCff3ZMaYPtaQB7C4Q2AsI8ZN5T/bgsj63pfd9fG8ev4YaNHNRH0NVO898u3A+rMXDhRafxdkWn83Wi+/6IZtErDd0Pj3YLwJ4X+WAIq3hpD1SgoZwwZDYDwMnGb396lBr5TqtTwsbiz+9RR8Wrkwy1kDIrhubB/2VtaR3ieYcf2Om8/f09d6wZjQfm2/gDFQV3Hkw+Bg2R5e/3IlkY378K8vZWhADSMObSQgbwnsMuAfBQO32fdNokGvlOrl2jpb1dPdjUeuGH56Ty4CPiHWn6gh+PWHERGXcN3/VuDl7sZ3t5+Nh6eF57/LZeaoADwbumbGTQ16pZTqRuOTw3jy2jQsbkJEgPWSjHedM6hLX1ODXimlutnhk8e6S9eO6VFKKeVwGvRKKeXiNOiVUsrFadArpZSL06BXSikXp0GvlFIuToNeKaVcnAa9Ukq5OKecvVJESoFdp/jwcKDMjuV0Ja21a2itXUNr7Rr2qrWvMSaitRVOGfSnQ0Qy25qq09lorV1Da+0aWmvX6I5atetGKaVcnAa9Ukq5OFcM+lmOLuAkaK1dQ2vtGlpr1+jyWl2uj14ppdSxXHGPXimlVAsa9Eop5eJcJuhFZJqIbBWRXBF50NH1tCQiCSLyrYhsFpGNInK3bflDIlIgImttPxc6ulYAEckTkQ22mjJty0JF5EsRybH9DnGCOge22HZrReSAiNzjLNtVRGaLSImIZLdY1uZ2FJHf2v5+t4rI+U5Q679EZIuIrBeR90Uk2LY8UURqW2zfF5yg1jb/zZ1wu77dos48EVlrW95129UY0+N/AAuwHegHeALrgCGOrqtFfTFAuu12ALANGAI8BPzK0fW1Um8eEH7csn8CD9puPwj8w9F1tvI3sBfo6yzbFZgEpAPZHW1H29/DOsALSLL9PVscXOt5gLvt9j9a1JrYsp2TbNdW/82dcbset/4x4I9dvV1dZY9+DJBrjNlhjKkH5gKXObimI4wxRcaYNbbbVcBmoHuvJXb6LgNetd1+FbjccaW0aiqw3RhzqmdU250xZgmw77jFbW3Hy4C5xphDxpidQC7Wv+tu0VqtxpiFxphG290VQHx31dOeNrZrW5xuux4mIgJcA7zV1XW4StDHAXta3M/HSYNURBKBkcBK26K7bF+NZztDd4iNARaKSJaIzLQtizLGFIH1gwuIdFh1rZvOsf9hnHG7Qtvb0dn/hn8GfNbifpKI/CAii0XkTEcVdZzW/s2debueCRQbY3JaLOuS7eoqQS+tLHO6caMi4g/MB+4xxhwAngeSgTSgCOvXOGcw0RiTDlwA3CkikxxdUHtExBO4FHjXtshZt2t7nPZvWER+DzQCc2yLioA+xpiRwH3AmyIS6Kj6bNr6N3fa7QrM4Nidky7brq4S9PlAQov78UChg2pplYh4YA35OcaY9wCMMcXGmCZjTDPwIt34lbI9xphC2+8S4H2sdRWLSAyA7XeJ4yo8wQXAGmNMMTjvdrVpazs65d+wiNwEXAxcb2wdybZukHLb7Sys/d4DHFdlu//mzrpd3YErgbcPL+vK7eoqQb8aSBGRJNve3XTgIwfXdIStL+4lYLMx5vEWy2NaNLsCyD7+sd1NRPxEJODwbawH5LKxbs+bbM1uAj50TIWtOmbPyBm3awttbcePgOki4iUiSUAKsMoB9R0hItOAB4BLjTE1LZZHiIjFdrsf1lp3OKbKIzW19W/udNvV5hxgizEm//CCLt2u3XX0uRuObl+IdTTLduD3jq7nuNrOwPp1cT2w1vZzIfA6sMG2/CMgxglq7Yd1lMI6YOPhbQmEAV8DObbfoY6u1VaXL1AOBLVY5hTbFeuHTxHQgHXP8ub2tiPwe9vf71bgAieoNRdr//bhv9kXbG2vsv1trAPWAJc4Qa1t/ps723a1LX8FuO24tl22XXUKBKWUcnGu0nWjlFKqDRr0Sinl4jTolVLKxWnQK6WUi9OgV0opF6dBr5RSLk6DXimlXNz/A0LvVWsjdFqEAAAAAElFTkSuQmCC",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "model = get_model()\n",
    "metrics = MetricsCB(Accuracy=MulticlassAccuracy())\n",
    "progress = ProgressCB(plot=True)\n",
    "cbs = [TrainCB(), metrics, progress]\n",
    "learn = Learner(model, dls=dls, cbs=cbs)\n",
    "learn.fit(3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 474,
   "id": "2b4f6d9c",
   "metadata": {},
   "outputs": [],
   "source": [
    "class TrainLearner(Learner):\n",
    "    def predict(self):\n",
    "        self.preds = self.model(self.batch[0])\n",
    "    \n",
    "    def get_loss(self):\n",
    "        self.loss = self.loss_func(self.preds, self.batch[1])\n",
    "    \n",
    "    def backward(self):\n",
    "        self.loss.backward()\n",
    "    \n",
    "    def step(self):\n",
    "        self.opt.step()\n",
    "    \n",
    "    def zero_grad(self):\n",
    "        self.opt.zero_grad()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 475,
   "id": "961324f5",
   "metadata": {},
   "outputs": [],
   "source": [
    "class MomentumLearner(TrainLearner):\n",
    "    def __init__(self, model, dls=(0,), lr=None, cbs=None, mom=0.85):\n",
    "        self.mom = mom\n",
    "        super().__init__(model, dls=dls, lr=lr, cbs=cbs)\n",
    "    \n",
    "    def zero_grad(self):\n",
    "        with torch.no_grad():\n",
    "            for p in self.model.parameters():\n",
    "                p.grad *= self.mom"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 476,
   "id": "a96a34a1",
   "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.674</td>\n",
       "      <td>0.938</td>\n",
       "      <td>0</td>\n",
       "      <td>train</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>0.793</td>\n",
       "      <td>0.587</td>\n",
       "      <td>0</td>\n",
       "      <td>val</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>0.819</td>\n",
       "      <td>0.515</td>\n",
       "      <td>1</td>\n",
       "      <td>train</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>0.829</td>\n",
       "      <td>0.485</td>\n",
       "      <td>1</td>\n",
       "      <td>val</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 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "model = get_model()\n",
    "metrics = MetricsCB(Accuracy=MulticlassAccuracy())\n",
    "progress = ProgressCB(plot=True)\n",
    "cbs = [metrics, progress]\n",
    "learn = MomentumLearner(model, dls=dls, cbs=cbs, lr=0.1)\n",
    "learn.fit(2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "6e7a9f78",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "85383072",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "python_main",
   "language": "python",
   "name": "python_main"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.11.0"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}