{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## CIFAR 10"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "%matplotlib inline\n",
    "%reload_ext autoreload\n",
    "%autoreload 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "import argparse\n",
    "import os\n",
    "import shutil\n",
    "import time\n",
    "\n",
    "from fastai.transforms import *\n",
    "from fastai.dataset import *\n",
    "from fastai.fp16 import *\n",
    "from fastai.conv_learner import *\n",
    "from pathlib import *\n",
    "\n",
    "import torch\n",
    "from torch.autograd import Variable\n",
    "import torch.nn as nn\n",
    "import torch.nn.parallel\n",
    "import torch.backends.cudnn as cudnn\n",
    "import torch.distributed as dist\n",
    "import torch.optim\n",
    "import torch.utils.data\n",
    "import torch.utils.data.distributed\n",
    "import torchvision.transforms as transforms\n",
    "import torchvision.datasets as datasets\n",
    "import models\n",
    "import models.cifar10 as cifar10models\n",
    "from distributed import DistributedDataParallel as DDP\n",
    "\n",
    "# print(models.cifar10.__dict__)\n",
    "model_names = sorted(name for name in models.__dict__\n",
    "                     if name.islower() and not name.startswith(\"__\")\n",
    "                     and callable(models.__dict__[name]))\n",
    "\n",
    "cifar10_names = sorted(name for name in cifar10models.__dict__\n",
    "                     if name.islower() and not name.startswith(\"__\")\n",
    "                     and callable(cifar10models.__dict__[name]))\n",
    "\n",
    "model_names = cifar10_names + model_names"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['preact_resnet18', 'preact_resnet34', 'preact_resnet50', 'resnet56', 'resnext29_16_64', 'resnext29_8_64', 'dpn107', 'dpn131', 'dpn68', 'dpn92', 'dpn98', 'inceptionresnetv2', 'inceptionresnetv2_conc', 'inceptionv4', 'load', 'load_block17', 'load_block35', 'load_block8', 'load_conv2d', 'load_conv2d_nobn', 'load_linear', 'load_mixed_4a_7a', 'load_mixed_5', 'load_mixed_5b', 'load_mixed_6', 'load_mixed_6a', 'load_mixed_7', 'load_mixed_7a', 'nasnetalarge', 'pre_resnet101', 'pre_resnet152', 'pre_resnet18', 'pre_resnet34', 'pre_resnet50', 'reduce', 'resnet101', 'resnet152', 'resnet18', 'resnet34', 'resnet50', 'resnext101', 'resnext152', 'resnext18', 'resnext34', 'resnext50', 'resnext_101_32x4d', 'resnext_101_64x4d', 'resnext_50_32x4d', 'se_resnet_101', 'se_resnet_152', 'se_resnet_18', 'se_resnet_34', 'se_resnet_50', 'se_resnet_50_conc', 'se_resnext_101', 'se_resnext_152', 'se_resnext_50', 'test', 'test_block17', 'test_block35', 'test_block8', 'test_conv2d', 'test_conv2d_nobn', 'test_mixed_4a_7a', 'test_mixed_5b', 'test_mixed_6a', 'test_mixed_7a', 'wrn_50_2f']\n"
     ]
    }
   ],
   "source": [
    "\n",
    "print(model_names)\n",
    "\n",
    "# Example usage: python run_fastai.py /home/paperspace/ILSVRC/Data/CLS-LOC/ -a resnext_50_32x4d --epochs 1 -j 4 -b 64 --fp16\n",
    "\n",
    "parser = argparse.ArgumentParser(description='PyTorch Cifar10 Training')\n",
    "parser.add_argument('data', metavar='DIR',\n",
    "                    help='path to dataset')\n",
    "parser.add_argument('--save-dir', type=str, default=Path.home()/'imagenet_training',\n",
    "                    help='Directory to save logs and models.')\n",
    "parser.add_argument('--arch', '-a', metavar='ARCH', default='resnet56',\n",
    "                    choices=model_names,\n",
    "                    help='model architecture: ' +\n",
    "                    ' | '.join(model_names) +\n",
    "                    ' (default: resnet56)')\n",
    "parser.add_argument('-j', '--workers', default=7, type=int, metavar='N',\n",
    "                    help='number of data loading workers (default: 4)')\n",
    "parser.add_argument('--epochs', default=1, type=int, metavar='N',\n",
    "                    help='number of total epochs to run')\n",
    "parser.add_argument('--cycle-len', default=95, type=float, metavar='N',\n",
    "                    help='Length of cycle to run')\n",
    "# parser.add_argument('--start-epoch', default=0, type=int, metavar='N',\n",
    "#                     help='manual epoch number (useful on restarts)')\n",
    "parser.add_argument('-b', '--batch-size', default=512, type=int,\n",
    "                    metavar='N', help='mini-batch size (default: 256)')\n",
    "parser.add_argument('--lr', '--learning-rate', default=0.8, type=float,\n",
    "                    metavar='LR', help='initial learning rate')\n",
    "parser.add_argument('--momentum', default=0.9, type=float, metavar='M', help='momentum')\n",
    "parser.add_argument('--weight-decay', '--wd', default=1e-4, type=float,\n",
    "                    metavar='W', help='weight decay (default: 1e-4)')\n",
    "# parser.add_argument('--print-freq', '-p', default=10, type=int,\n",
    "#                     metavar='N', help='print frequency (default: 10)')\n",
    "# parser.add_argument('--resume', default='', type=str, metavar='PATH',\n",
    "#                     help='path to latest checkpoint (default: none)')\n",
    "# parser.add_argument('-e', '--evaluate', dest='evaluate', action='store_true',\n",
    "#                     help='evaluate model on validation set')\n",
    "parser.add_argument('--pretrained', dest='pretrained', action='store_true', help='use pre-trained model')\n",
    "parser.add_argument('--fp16', action='store_true', help='Run model fp16 mode.')\n",
    "parser.add_argument('--use-tta', default=True, type=bool, help='Validate model with TTA at the end of traiing.')\n",
    "parser.add_argument('--train-half', action='store_true', help='Train model on half images. TODO: allow custom epochs and LR')\n",
    "parser.add_argument('--sz',       default=32, type=int, help='Size of transformed image.')\n",
    "# parser.add_argument('--decay-int', default=30, type=int, help='Decay LR by 10 every decay-int epochs')\n",
    "parser.add_argument('--use-clr', default='10,13.68,0.95,0.85', type=str, \n",
    "                    help='div,pct,max_mom,min_mom. Pass in a string delimited by commas. Ex: \"20,2,0.95,0.85\"')\n",
    "parser.add_argument('--loss-scale', type=float, default=128,\n",
    "                    help='Loss scaling, positive power of 2 values can improve fp16 convergence.')\n",
    "parser.add_argument('--prof', dest='prof', action='store_true', help='Only run a few iters for profiling.')\n",
    "\n",
    "parser.add_argument('--dist-url', default='file://sync.file', type=str,\n",
    "                    help='url used to set up distributed training')\n",
    "parser.add_argument('--dist-backend', default='nccl', type=str, help='distributed backend')\n",
    "\n",
    "parser.add_argument('--world-size', default=1, type=int,\n",
    "                    help='Number of GPUs to use. Can either be manually set ' +\n",
    "                    'or automatically set by using \\'python -m multiproc\\'.')\n",
    "parser.add_argument('--rank', default=0, type=int,\n",
    "                    help='Used for multi-process training. Can either be manually set ' +\n",
    "                    'or automatically set by using \\'python -m multiproc\\'.')\n",
    "\n",
    "class TorchModelData(ModelData):\n",
    "    def __init__(self, path, trn_dl, val_dl, aug_dl=None):\n",
    "        super().__init__(path, trn_dl, val_dl)\n",
    "        self.aug_dl = aug_dl\n",
    "\n",
    "def torch_loader(data_path, size):\n",
    "    # Data loading code\n",
    "    traindir = os.path.join(data_path, 'train')\n",
    "    valdir = os.path.join(data_path, 'test')\n",
    "    normalize = transforms.Normalize(mean=[0.4914 , 0.48216, 0.44653], std=[0.24703, 0.24349, 0.26159])\n",
    "    \n",
    "    scale_size = 40\n",
    "    padding = int((scale_size - size) / 2)\n",
    "    train_tfms = transforms.Compose([\n",
    "        transforms.RandomCrop(size, padding=padding),\n",
    "        transforms.ColorJitter(.25,.25,.25),\n",
    "        transforms.RandomRotation(2),\n",
    "        transforms.RandomHorizontalFlip(),\n",
    "        transforms.ToTensor(),\n",
    "        normalize,\n",
    "    ])\n",
    "    train_dataset = datasets.ImageFolder(traindir, train_tfms)\n",
    "    train_sampler = (torch.utils.data.distributed.DistributedSampler(train_dataset)\n",
    "                     if args.distributed else None)\n",
    "    train_loader = torch.utils.data.DataLoader(\n",
    "        train_dataset, batch_size=args.batch_size, shuffle=(train_sampler is None),\n",
    "        num_workers=args.workers, pin_memory=True, sampler=train_sampler)\n",
    "\n",
    "    val_tfms = transforms.Compose([\n",
    "    #   transforms.Resize(int(size*1.14)),\n",
    "    #   transforms.CenterCrop(size),\n",
    "        transforms.ToTensor(),\n",
    "        normalize,\n",
    "    ])\n",
    "    val_loader = torch.utils.data.DataLoader(\n",
    "        datasets.ImageFolder(valdir, val_tfms),\n",
    "        batch_size=args.batch_size, shuffle=False,\n",
    "        num_workers=args.workers, pin_memory=True)\n",
    "\n",
    "\n",
    "    aug_loader = torch.utils.data.DataLoader(\n",
    "        datasets.ImageFolder(valdir, train_tfms),\n",
    "        batch_size=args.batch_size, shuffle=False,\n",
    "        num_workers=args.workers, pin_memory=True)\n",
    "\n",
    "    train_loader = DataPrefetcher(train_loader)\n",
    "    val_loader = DataPrefetcher(val_loader)\n",
    "    aug_loader = DataPrefetcher(aug_loader)\n",
    "    if args.prof:\n",
    "        train_loader.stop_after = 200\n",
    "        val_loader.stop_after = 0\n",
    "\n",
    "    data = TorchModelData(data_path, train_loader, val_loader, aug_loader)\n",
    "    return data, train_sampler\n",
    "\n",
    "\n",
    "# Seems to speed up training by ~2%\n",
    "class DataPrefetcher():\n",
    "    def __init__(self, loader, stop_after=None):\n",
    "        self.loader = loader\n",
    "        self.dataset = loader.dataset\n",
    "        self.stream = torch.cuda.Stream()\n",
    "        self.stop_after = stop_after\n",
    "        self.next_input = None\n",
    "        self.next_target = None\n",
    "\n",
    "    def __len__(self):\n",
    "        return len(self.loader)\n",
    "    \n",
    "    def preload(self):\n",
    "        try:\n",
    "            self.next_input, self.next_target = next(self.loaditer)\n",
    "        except StopIteration:\n",
    "            self.next_input = None\n",
    "            self.next_target = None\n",
    "            return\n",
    "        with torch.cuda.stream(self.stream):\n",
    "            self.next_input = self.next_input.cuda(async=True)\n",
    "            self.next_target = self.next_target.cuda(async=True)\n",
    "\n",
    "    def __iter__(self):\n",
    "        count = 0\n",
    "        self.loaditer = iter(self.loader)\n",
    "        self.preload()\n",
    "        while self.next_input is not None:\n",
    "            torch.cuda.current_stream().wait_stream(self.stream)\n",
    "            input = self.next_input\n",
    "            target = self.next_target\n",
    "            self.preload()\n",
    "            count += 1\n",
    "            yield input, target\n",
    "            if type(self.stop_after) is int and (count > self.stop_after):\n",
    "                break\n",
    "                \n",
    "def top5(output, target):\n",
    "    \"\"\"Computes the precision@k for the specified values of k\"\"\"\n",
    "    top5 = 5\n",
    "    batch_size = target.size(0)\n",
    "    _, pred = output.topk(top5, 1, True, True)\n",
    "    pred = pred.t()\n",
    "    correct = pred.eq(target.view(1, -1).expand_as(pred))\n",
    "    correct_k = correct[:top5].view(-1).float().sum(0, keepdim=True)\n",
    "    return correct_k.mul_(1.0 / batch_size)\n",
    "\n",
    "\n",
    "class ImagenetLoggingCallback(Callback):\n",
    "    def __init__(self, save_path, print_every=50):\n",
    "        super().__init__()\n",
    "        self.save_path=save_path\n",
    "        self.print_every=print_every\n",
    "    def on_train_begin(self):\n",
    "        self.batch = 0\n",
    "        self.epoch = 0\n",
    "        self.f = open(self.save_path, \"a\", 1)\n",
    "        self.log(\"\\ton_train_begin\")\n",
    "    def on_epoch_end(self, metrics):\n",
    "        log_str = f'\\tEpoch:{self.epoch}\\ttrn_loss:{self.last_loss}'\n",
    "        for (k,v) in zip(['val_loss', 'acc', 'top5', ''], metrics): log_str += f'\\t{k}:{v}'\n",
    "        self.log(log_str)\n",
    "        self.epoch += 1\n",
    "    def on_batch_end(self, metrics):\n",
    "        self.last_loss = metrics\n",
    "        self.batch += 1\n",
    "        if self.batch % self.print_every == 0:\n",
    "            self.log(f'Epoch: {self.epoch} Batch: {self.batch} Metrics: {metrics}')\n",
    "    def on_train_end(self):\n",
    "        self.log(\"\\ton_train_end\")\n",
    "        self.f.close()\n",
    "    def log(self, string):\n",
    "        self.f.write(time.strftime(\"%Y-%m-%dT%H:%M:%S\")+\"\\t\"+string+\"\\n\")\n",
    "        \n",
    "        \n",
    "class DisbleTransformCallback(Callback):\n",
    "    def __init__(self, dataset, disable_at=120):\n",
    "        super().__init__()\n",
    "        self.dataset = dataset\n",
    "        self.disable_at = disable_at\n",
    "    def on_epoch_end(self, metrics):\n",
    "        log_str = f'\\tEpoch:{self.epoch}\\ttrn_loss:{self.last_loss}'\n",
    "        for (k,v) in zip(['val_loss', 'acc', 'top5', ''], metrics): log_str += f'\\t{k}:{v}'\n",
    "        self.log(log_str)\n",
    "        self.epoch += 1\n",
    "        print('Disabling dataset transforms')\n",
    "        if self.epoch > disable_at:\n",
    "            dataset.transform = None\n",
    "\n",
    "# Logging + saving models\n",
    "def save_args(name, save_dir):\n",
    "    if (args.rank != 0) or not args.save_dir: return {}\n",
    "\n",
    "    log_dir = f'{save_dir}/training_logs'\n",
    "    os.makedirs(log_dir, exist_ok=True)\n",
    "    return {\n",
    "        'best_save_name': f'{name}_best_model',\n",
    "        'cycle_save_name': f'{name}',\n",
    "        'callbacks': [\n",
    "            ImagenetLoggingCallback(f'{log_dir}/{name}_log.txt')\n",
    "        ]\n",
    "    }\n",
    "\n",
    "def save_sched(sched, save_dir):\n",
    "    if (args.rank != 0) or not args.save_dir: return {}\n",
    "    log_dir = f'{save_dir}/training_logs'\n",
    "    sched.save_path = log_dir\n",
    "    sched.plot_loss()\n",
    "    sched.plot_lr()\n",
    "\n",
    "def update_model_dir(learner, base_dir):\n",
    "    learner.tmp_path = f'{base_dir}/tmp'\n",
    "    os.makedirs(learner.tmp_path, exist_ok=True)\n",
    "    learner.models_path = f'{base_dir}/models'\n",
    "    os.makedirs(learner.models_path, exist_ok=True)\n",
    "    "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Resnet block"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "args_input = [\n",
    "    '/home/paperspace/imagenet-fast/fp16/data/cifar10', \n",
    "    '--save-dir', '/home/paperspace/data/cifar_training/test1', \n",
    "    '-a', 'preact_resnet50', \n",
    "#     '-j', '6', \n",
    "#     '--prof', \n",
    "    '-b', '512', \n",
    "#     '--sz', '32',\n",
    "#     '--loss-scale', '128',\n",
    "    '--fp16',\n",
    "    '--cycle-len', '60',\n",
    "#     '--epochs', '1',\n",
    "    '--use-clr', '20,18,0.95,0.85',\n",
    "    '--wd', '2e-4',\n",
    "    '--lr', '1',\n",
    "#     '--train-half' # With fp16, iterations are so fast this doesn't matter\n",
    "]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "# This is important for speed\n",
    "cudnn.benchmark = True\n",
    "global arg\n",
    "args = parser.parse_args(args_input); args\n",
    "if args.cycle_len > 1: args.cycle_len = int(args.cycle_len)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "args.distributed = args.world_size > 1\n",
    "args.gpu = 0\n",
    "if args.distributed:\n",
    "    args.gpu = args.rank % torch.cuda.device_count()\n",
    "\n",
    "if args.distributed:\n",
    "    torch.cuda.set_device(args.gpu)\n",
    "    dist.init_process_group(backend=args.dist_backend, init_method=args.dist_url,\n",
    "                            world_size=args.world_size)\n",
    "\n",
    "if args.fp16:\n",
    "    assert torch.backends.cudnn.enabled, \"fp16 mode requires cudnn backend to be enabled.\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "=> creating model 'preact_resnet50'\n"
     ]
    }
   ],
   "source": [
    "# create model\n",
    "model = cifar10models.__dict__[args.arch] if args.arch in cifar10_names else models.__dict__[args.arch] \n",
    "if args.pretrained:\n",
    "    print(\"=> using pre-trained model '{}'\".format(args.arch))\n",
    "    model = model(pretrained=True)\n",
    "else:\n",
    "    print(\"=> creating model '{}'\".format(args.arch))\n",
    "    model = model()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "model = model.cuda()\n",
    "if args.distributed:\n",
    "    model = DDP(model)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "if args.train_half:\n",
    "    data, train_sampler = torch_loader(args.data, 16)\n",
    "else:\n",
    "    data, train_sampler = torch_loader(args.data, args.sz)\n",
    "\n",
    "learner = Learner.from_model_data(model, data)\n",
    "# learner.crit = F.nll_loss\n",
    "learner.crit = F.cross_entropy\n",
    "learner.metrics = [accuracy]\n",
    "if args.fp16: learner.half()\n",
    "\n",
    "if args.prof:\n",
    "    args.epochs = 1\n",
    "    args.cycle_len=.01\n",
    "if args.use_clr:\n",
    "    args.use_clr = tuple(map(float, args.use_clr.split(',')))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "# x,y = next(iter(data.trn_dl))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "# plt.imshow(np.transpose(x[50], (1, 2, 0)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [],
   "source": [
    "# %pdb off"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "2145418e14e845f497b55ffd8398d238",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "HBox(children=(IntProgress(value=0, description='Epoch', max=1), HTML(value='')))"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " 15%|█▌        | 15/98 [00:04<00:22,  3.64it/s, loss=2.39]\n",
      " 16%|█▋        | 16/98 [00:04<00:22,  3.68it/s, loss=2.39]"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Exception in thread Thread-4:\n",
      "Traceback (most recent call last):\n",
      "  File \"/home/paperspace/anaconda3/envs/fastai/lib/python3.6/threading.py\", line 916, in _bootstrap_inner\n",
      "    self.run()\n",
      "  File \"/home/paperspace/anaconda3/envs/fastai/lib/python3.6/site-packages/tqdm/_monitor.py\", line 62, in run\n",
      "    for instance in self.tqdm_cls._instances:\n",
      "  File \"/home/paperspace/anaconda3/envs/fastai/lib/python3.6/_weakrefset.py\", line 60, in __iter__\n",
      "    for itemref in self.data:\n",
      "RuntimeError: Set changed size during iteration\n",
      "\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " 88%|████████▊ | 86/98 [00:20<00:02,  4.29it/s, loss=134] \n"
     ]
    }
   ],
   "source": [
    "learner.lr_find()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "learner.sched.plot()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 128x128\n",
    "if args.train_half: \n",
    "    save_dir = args.save_dir+'/128'\n",
    "    update_model_dir(learner, save_dir)\n",
    "    sargs = save_args('first_run_128', save_dir)\n",
    "    sargs['callbacks'] += [DisableTransformCallback(data.train_ds, 5)]\n",
    "    learner.fit(args.lr,args.epochs, cycle_len=45,\n",
    "                train_sampler=train_sampler,\n",
    "                wds=args.weight_decay,\n",
    "                use_clr_beta=args.use_clr,\n",
    "                loss_scale=args.loss_scale,\n",
    "                **sargs\n",
    "            )\n",
    "    save_sched(learner.sched, save_dir)\n",
    "    data, train_sampler = torch(args.data, args.sz)\n",
    "    learner.set_data(data)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "ad3fda4a5e0d429abc0a7c4805109818",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "HBox(children=(IntProgress(value=0, description='Epoch', max=60), HTML(value='')))"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epoch      trn_loss   val_loss   accuracy                 \n",
      "    0      2.245936   2.228234   0.23      \n",
      "    1      1.891597   1.706828   0.3638                   \n",
      "    2      1.662194   1.476923   0.4567                   \n",
      "    3      1.500541   1.338445   0.5125                   \n",
      "    4      1.360604   1.233304   0.5539                   \n",
      "    5      1.208304   1.131711   0.5935                   \n",
      "    6      1.082064   1.069637   0.6337                   \n",
      "    7      0.98461    0.94652    0.6699                    \n",
      "    8      0.900918   0.832646   0.7004                    \n",
      "    9      0.819869   1.045434   0.6457                    \n",
      "    10     0.746519   0.916172   0.6738                    \n",
      "    11     0.718537   0.801661   0.7106                    \n",
      "    12     0.669545   0.627794   0.7818                    \n",
      "    13     0.618797   0.65864    0.7723                    \n",
      "    14     0.588434   0.787638   0.7475                    \n",
      "    15     0.573386   0.609908   0.7905                    \n",
      "    16     0.561982   0.763521   0.7464                    \n",
      "    17     0.54299    0.78705    0.7349                    \n",
      "    18     0.532402   0.743404   0.7559                    \n",
      "    19     0.523774   0.90625    0.7077                    \n",
      "    20     0.508664   0.79797    0.7334                    \n",
      "    21     0.506003   0.618367   0.7907                    \n",
      "    22     0.494013   0.745909   0.7576                    \n",
      "    23     0.487272   0.847763   0.7234                    \n",
      "    24     0.491039   0.593619   0.8019                    \n",
      "    25     0.507369   0.544064   0.8138                    \n",
      "    26     0.47543    0.647273   0.7837                    \n",
      "    27     0.456015   0.698345   0.7719                    \n",
      "    28     0.440883   0.551565   0.819                     \n",
      "    29     0.431023   0.577162   0.8039                    \n",
      "    30     0.426791   0.565634   0.8108                    \n",
      "    31     0.407529   0.719702   0.7728                    \n",
      "    32     0.400397   0.710503   0.7707                    \n",
      "    33     0.382763   0.581605   0.8079                    \n",
      "    34     0.378888   0.50685    0.8294                    \n",
      "    35     0.374004   0.694361   0.7902                    \n",
      "    36     0.364203   0.547592   0.823                     \n",
      "    37     0.348122   0.455088   0.8509                    \n",
      "    38     0.333729   0.442609   0.8461                    \n",
      "    39     0.3234     0.490248   0.8326                    \n",
      "    40     0.29991    0.426351   0.8576                    \n",
      "    41     0.289124   0.386449   0.8707                    \n",
      "    42     0.276744   0.440993   0.8525                    \n",
      "    43     0.265305   0.365772   0.8756                    \n",
      "    44     0.237126   0.331618   0.8928                    \n",
      "    45     0.214655   0.319781   0.8932                    \n",
      "    46     0.194987   0.300269   0.8999                    \n",
      "    47     0.154052   0.27897    0.909                     \n",
      "    48     0.126818   0.2409     0.9236                    \n",
      "    49     0.094009   0.233152   0.9247                     \n",
      "    50     0.080817   0.225963   0.9304                     \n",
      "    51     0.069746   0.240966   0.9255                     \n",
      "    52     0.06146    0.215223   0.9333                     \n",
      "    53     0.055725   0.214275   0.9355                     \n",
      "    54     0.049614   0.217713   0.9331                     \n",
      "    55     0.041751   0.214561   0.9371                     \n",
      "    56     0.036472   0.214109   0.9367                     \n",
      "    57     0.032184   0.211613   0.9391                     \n",
      "    58     0.028103   0.206728   0.9411                     \n",
      "    59     0.024435   0.208003   0.9406                     \n",
      "\n",
      "Finished!\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAtUAAAEKCAYAAADdM6kMAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDIuMi4yLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvhp/UCwAAIABJREFUeJzs3Xl8VPX1//HXyb4QEkIStgQCZA9VUURBFNl3sGp/1S4utbWt1VZxwyoBgrRu1VqrbW211trWWtvKLpuIiqKACmYnBELCGrYEErKf3x8Z/KbIMkAmN5mc5+NxH2bu3Mm8IyQ53HvP+YiqYowxxhhjjDl3Pk4HMMYYY4wxpr2zotoYY4wxxpjzZEW1McYYY4wx58mKamOMMcYYY86TFdXGGGOMMcacJyuqjTHGGGOMOU9WVBtjjDHGGHOerKg2xhhjjDHmPFlRbYwxxhhjzHnyczrA2YqKitL4+HinYxhjzFnbuHHjflWNdjpHa7Kf2caY9uxsfm63u6I6Pj6eDRs2OB3DGGPOmogUO52htdnPbGNMe3Y2P7ft9g9jjDHGGGPOkxXVxhhjjDHGnCcrqo0xxhhjjDlPVlQbY4wxxhhznqyoNsYYY4wx5jx5rKgWkZdFZJ+IZJ3ieRGR34hIoYhsFpGLPZXFGGOMMcYYT/LkmepXgPGneX4CkOjabgd+58EsxhhjjDHGeIzH5lSr6nsiEn+aQ6YBr6qqAutEJEJEeqjqbk9lMu3Xwcpa3t9SxtQLeyIiTscxxnhQ9q5ysnaW881LezsdxZgOLWtnOcuz9zgdo0VcEBvB6LRuHn0PJxd/6QWUNHtc6tr3laJaRG6n6Ww2vXvbD9mO6AevbmBj8SEaGpVrL451Oo4xxoNeWbud+Z/v4vJ+XenTNdTpOMZ0SBXVddz88iccqKzFG85lffuy3l5dVJ/sj0hPdqCqvgi8CDBo0KCTHmO818qcvWwsPgTAL5bkMiq1G+HB/g6nMsZ4yv3jkln8xW7mLc7lxZsGOR3HmA7pt+8UcrCqlkV3DWNAr3Cn47QLTk7/KAXimj2OBXY5lMW0UdV1DcxemE1iTCfe+skVHKys5enl+U7HMsZ4UEznIH4yIoHlOXv5sHC/03GM6XC27a/kz2u38Y1LYq2gPgtOFtULgJtcU0AuB8rtfmpzohdWF1J66BiZ0wZwUVwE3728D39dV0zWznKnoxljPOi2YX2J7RJM5qIc6hsanY5jTIcyb3EOgX6+3Dcu2eko7YonR+r9A/gISBaRUhG5TUR+JCI/ch2yBCgCCoE/And4Kotpn7btr+T3a4q45qKeDOnfFYDpY5OJDA1g5vwsGhvtTiBjvFWQvy8/n5hK3p4jvL6+5MwvMMa0iPe3lLEydx8/GZFATFiQ03HaFU9O/7jxDM8r8BNPvb9p31SVWQuyCfTz4ecTU7/cHx7sz0MTUrn3X5v418YSmw5gjBebMKA7g/tG8vSKAqZc2NN6KYzxsPqGRuYuyqF3ZAjfGxbvdJx2x1ZUNG3Ssuw9vFdQxj1jkojp/L//Ur724l5cGt+Fx5bmcaiy1qGExhhPExEyJqdxqKqW51ZtcTqOMV7v75/soGDvUX4+MZVAP1+n47Q7VlSbNqeqtp7MhTmkdA/jpiF9vvK8iDD3mgFUVNfzpDUtGuPVBvQK55uD4njlw+0UlR11Oo4xXutwVS1PryhgSL+ujEv37Og5b2VFtWlznnunkF3l1Tx6zQD8fE/+VzSle2duGRrPPz7ZwaaSw62c0BjTmu4dm0yQvy/zFuc6HcUYr/XrlVuoOFZHxpQ0W2TtHFlRbdqUwn1H+dP7RVx/SSyD4iNPe+zdoxOJ7hTII29l0WBNi8Z4reiwQO4amcCqvH28V1DmdBxjvE7hviP8dV0xNwzuTWqPzk7HabesqDZtRlNzYhbB/r7MmJByxuPDgvx5ZHIaX+ws5++f7GiFhMYYp9xyRTx9uoYw10bsGdPi5i7KJSTAl3vHJDkdpV2zotq0GYu/2M3awgPcPy6ZqE6Bbr1mygU9GNKvK0++nceBozUeTmiMcUqgX9OIvS37jvK3j+0f0ca0lNV5+1hTUMbPRiXS1c3fvebkrKg2bcLRmnrmLsphQK/OfOuyrzYnnkpT02I6x+oaeGxpngcTGmOcNjatG0P7d+WZlQUcrrLJP8acr7qGRuYuzqFfVCg3DYl3Ok67Z0W1aRN+s2oLeytqmDttAL4+Z9cgkRATxm3D+vGvjaVs2H7QQwmNMU4TETKmpFFxrI5fr7QRe8acr1c/KqaorJKHJ6US4Gcl4fmy/4PGcQV7j/DyB9u44dI4Bvbuck6f466RCfQID2Lm/Gy739IYL5bSvTM3Du7NX9cVs2XvEafjGNNuHays5dmVBVyZGMXIlBin43gFK6qNo1SVR97KolOQHw+MP3Nz4qmEBvqRMTmN3N0V/HVdcQsmNMa0NdPHJBES4Mvcxbk0Lc5rjDlbT6/Ip7K2gYzJNkKvpVhRbRw1//NdfLLtIA+MSyEyNOC8Ptf4Ad25Kimap5cXsK+iuoUSGuN9RGS8iOSLSKGIzDjJ831EZJWIbBaRd0Uk9oTnO4vIThH5beul/j9dOwXys1GJvFdQxrv5NmLPmLOVt6eCv3+8g+9c1pvEbmFOx/EaVlQbx1RU1/Ho4lwujIvghkvjzvvziQhzpqZTU9/IL5bYIhHGnIyI+ALPAxOANOBGEUk74bCngFdV9QIgE/jlCc/PBdZ4Ouvp3DQknn5RocxdnEOd3fJljNtUlbmLcggL8ufu0TZCryVZUW0c88yKAg5U1jB3Wjo+Z9mceCp9o0L54fB+vPX5LtYVHWiRz2mMlxkMFKpqkarWAq8D0044Jg1Y5fp4dfPnReQSoBuwvBWynlKAnw+PTE6lqKySVz+yW76McdeKnL2sLTzAPaMT6XKeV4jN/7Ki2jgiZ1cFf/lwO9++rDcXxEa06Oe+4+oEYrsEkzE/y85gGfNVvYCSZo9LXfua2wRc5/r460CYiHQVER/gV8D9Hk/phhHJMVyVFM2zKws4WGkj9ow5k5r6BuYtySUhphPfvtz98bXGPVZUm1bX2KhkzM8iIiSA+8eee3PiqQQH+DJ7SjoFe4/y57XbWvzzG9POneyy0IndfvcBw0XkM2A4sBOoB+4AlqhqCachIreLyAYR2VBW5rl7nkWEmZNSqaxt4OkV+R57H2O8xStrt1N8oIqZk9Pw97USsKXZ/1HT6v79aSkbig8xY0IK4SH+HnmP0WndGJUSw69XbmF3+TGPvIcx7VQp0LyJIRbY1fwAVd2lqteq6kDgYde+cmAIcKeIbKfpvuubROSxE99AVV9U1UGqOig6OtpDX0aTxG5hfOey3vz94x3k7anw6HsZ056VHanhuXcKGZkSw/Akz35fdlRWVJtWVV5Vx2NL87ikTxeuvzj2zC84D7OnptPQqDy62JoWjWlmPZAoIn1FJAC4AVjQ/AARiXLd6gHwEPAygKp+W1V7q2o8TWezX1XVr0wPaW13j04iLMifuYtybMSeMafwq+X5VNc18PCkVKejeC0rqk2remp5PoeqaslswebEU4mLDOEnIxJYvHk3H2zZ79H3Mqa9UNV64E5gGZALvKGq2SKSKSJTXYddDeSLSAFNTYnzHAnrpi6hAdwzOpG1hQdYkbPX6TjGtDlZO8v554YSbh4aT//oTk7H8VpWVJtW80VpOa99XMxNQ+JJ7xneKu95+1X9iO8aQsb8LGrqG1rlPY1p61R1iaomqWp/VZ3n2pehqgtcH7+pqomuY76vqjUn+RyvqOqdrZ39VL59eR8SYjoxb0mufa8b04yqkrkohy4hAfx0VKLTcbyaFdWmVTQ2KjPnZ9E1NJDpY1tvLmaQvy+zp6ZTtL+SP71vTYvGeCt/Xx9mTk6j+EAVr6zd7nQcY9qMpVl7+GTbQaaPSSI82DN9TKaJFdWmVfxzQwmflxzm4UkpdA5q3W/qq5NjGJ/enefe2ULpoapWfW9jTOsZnhTNyJQYnnunkLIjXzm5bkyHU13XwC+W5JLSPaxFFlkzp2dFtfG4Q5W1PP52HoP7RnLNRSeOw20dM6ekIQiZC3MceX9jTOt4eFIq1XU2Ys8YgJc+2EbpoWNkTE7Dz0boeZz9HzYe98SyPI5U1zN32gBEPNuceCq9IoK5a1QCy3P2sjpvnyMZjDGe1z+6EzcPjef19SVk7yp3Oo4xjtlbUc3zqwsZm9aNoQlRTsfpEKyoNh712Y5DvL6+hFuHxpPcPczRLN8f1o/+0aHMXphNdZ01MhnjrX46KpGIYH8yF9qIPdNxPfF2PvUNaiP0WpEV1cZjGlzNiTFhgdw9pvWaE08lwM+HudMGUHygit+v2ep0HGOMh4QH+zN9bDIfbzvI21l7nI5jTKvbVHKYf39ayq3D4unTNdTpOB2GFdXGY/7+yQ6ydlbwyKQ0OgX6OR0HgKEJUUy5sCcvvLuV4gOVTscxxnjIjZfGkdwtjHlLcu3KlOlQjo/Qi+oUyJ0jEpyO06FYUW08Yv/RGp58O4+h/bsy+YIeTsf5Hw9PTMXfR5i9INsuDRvjpfx8fciYkkbpoWO89IGN0zQdx4JNu9hYfIj7xzWtNGpajxXVxiMeX5rHsboGMh1sTjyV7uFB3DMmidX5Zbb6mjFe7IqEKMakdeP51YXsq6h2Oo4xHnestoHHluaR3rMz119iI/RamxXVpsVt2H6Qf20s5bZh/UiIaZvLod48NJ7kbmHMWZjDsVq7NGyMt3p4Yip1DY08scxG7Bnv94f3trK7vJpZU9Lx9WlbJ7Q6AiuqTYuqb2hk5vxseoYH8dNRbfdeLn9fHzKnpbPz8DGeX13odBxjjIfER4XyvSv68ubGUr4otRF7xnvtOnyM36/ZyqSv9WBw30in43RIHi2qRWS8iOSLSKGIzDjJ871FZLWIfCYim0VkoifzGM/767picndXMHNyGiEBbaM58VQu69eVawf24sX3iigqO+p0HGOMh9w5MoGoTgHMWWh9FMZ7Pf52Ho0KMyakOB2lw/JYUS0ivsDzwAQgDbhRRNJOOOwR4A1VHQjcALzgqTzG8/ZVVPP08gKuSopm/IDuTsdxy0MTUwn092GWNS0a47XCgvy5b2wyG4oPsWjzbqfjGNPiNhYfYv7nu7j9yn7ERYY4HafD8uSZ6sFAoaoWqWot8Dow7YRjFOjs+jgc2OXBPMbDfrk0j5r6RuZMTW9zzYmnEh0WyH1jk3l/y36WfGHzbI3xVt8YFEdaj848tjTPRuwZr9LYqGQuzCYmLJAfX93f6TgdmieL6l5ASbPHpa59zc0GviMipcAS4C4P5jEetK7oAP/9bCc/HN6PvlHta9D8ty/rTVqPzsxdlENlTb3TcYwxHuDrI2RMSWPn4WO8+F6R03GMaTH//Wwnm0rLeXB8CqFtZE2IjsqTRfXJTlWeeH39RuAVVY0FJgJ/FZGvZBKR20Vkg4hsKCsr80BUcz7qGhrJmJ9Fr4hg7ri67TYnnoqfrw9zrxnAnopqfrNqi9NxjDEecnm/rkwY0J3fvbuVPeU2Ys+0f5U19Tz+dh4XxkXw9YEnnrc0rc2TRXUp0HxIYixfvb3jNuANAFX9CAgCok78RKr6oqoOUtVB0dHRHoprztUra7dTsPcos6emExzg63Scc3JJny58c1AcL32wjYK9R5yOY4zxkJ9PTKVBlcffznM6ijHn7XfvbmXfkRoyJqfhYyP0HOfJono9kCgifUUkgKZGxAUnHLMDGAUgIqk0FdV2Krod2VNeza9XFjAyJYbRqTFOxzkvD4xPJjTQj4z5Wda0aIyXiosM4fvD+vLfz3by6Y5DTscx5pyVHKzixfeLmHZRTy7p08XpOAYPFtWqWg/cCSwDcmma8pEtIpkiMtV12L3AD0RkE/AP4Ba1aqZdeXRxDvWNyuwp7ac58VS6dgrkgfHJrCs6yIJN1jNrjLe6Y0QC0WGBZC7MobHRfuWY9umxpXn4CDw43kbotRUenVOtqktUNUlV+6vqPNe+DFVd4Po4R1WvUNULVfUiVV3uyTymZa0t3M+izbu54+oEenf1jhE+N1zamwtjw3l0cS4V1XVOxzHGeECnQD8eGJfM5yWHmb9pp9NxjDlrHxcdYPEXu/nR8P70jAh2Oo5xsRUVzTmprW9qTuzTNYQfDu/ndJwW4+sjzL1mAPuP1vDMigKn4xhjPOS6i2O5IDacx5fmU1VrU39M+9HQqGQuyqFneBA/vMpG6LUlVlSbc/LSB9vYWlbJ7KnpBPm3z+bEU7kgNoJvDe7NXz7cTs6uCqfjGGM8wMdHyJicxp6Kan6/xkbsmfbjzY0lZO+q4MEJKe12OIC3sqLanLWdh4/xm1VbGJvWjRHJ7bs58VTuH5dMREgAGfOz7J5LY7zUoPhIplzYkz+s2crOw8ecjmPMGR2pruPJZflc0qcLUy/s6XQccwIrqs1Ze3RRDoqSMeXEVee9R0RIADMmpLCh+BD//rTU6TjGGA+ZMSEFkaamL2Paut+uLmT/0VoyJqe1++EA3siKanNW1hSUsTRrD3eNTCS2i3c0J57K9RfHcnHvCB5bmkd5lTUtGuONekUEc/tV/Vm4aRcbth90Oo4xp1R8oJI/f7Cd6y6O5cK4CKfjmJOwotq4rbqugVnzs+gXFcr3r+zrdByP83E1LR6qquWp5flOxzHGeMiPhveje+cg5tiIPdOGzVuci7+v8OD4ZKejmFOwotq47Y/vFbH9QBVzpqUT6NcxmiPSe4Zz05B4Xvu4mC9Ky52OY4zxgJAAPx6ckMwXO8vtdi/TJn1YuJ/lOXu5Y0QCMZ2DnI5jTsGKauOWkoNV/HZ1IZO+1oMrEzvWUvHTxybRNTSQR6xp0RivNe3CXlwUF8ETy/I5WmMj9kzbUd/QSOaiHOIig7ltmPdfJW7PrKg2bpmzMAdfH+GRyalOR2l1nYP8eXhSCptKDvPPDSVOxzHGeICPjzBrShplR2p4YXWh03GM+dLr60vI23OEn09I9boRtt7GimpzRqty97Iydy8/G5VIj/COuXLTNRf14rK+kTz+dh4HK2udjmOM8YCBvbvw9YG9+NMH2yg5WOV0HGMoP1bH0ysKuKxvJOMHdHc6jjkDK6rNaVXXNTB7YTaJMZ34Xge+7CTS1LR4pLqeJ9620VvGeKsHx6fgK8Ivl+Y6HcUYfrNqC4eqasmYYiP02gMrqs1pvfDuVkoOHiNz2gD8fTv2X5ekbmF874p4Xl9fwqc7Djkdx5hzJiLjRSRfRApFZMZJnu8jIqtEZLOIvCsisa79F4nIRyKS7Xrum62f3rO6hwfx46v7s+SLPawrOuB0HNOBbS07yl8+3M4Nl8aR3jPc6TjGDR27SjKntX1/Jb9fs5VpF/VkSP+uTsdpE342OolunQPJmJ9FgzUtmnZIRHyB54EJQBpwo4icuJLTU8CrqnoBkAn80rW/CrhJVdOB8cCvRcTrBubeflU/ekUEk7kwx77PjWPmLc4l2N+Xe8faCL32wopqc1KqyuyF2QT4+vDwxI7XnHgqnQL9mDk5jaydFfzt42Kn4xhzLgYDhapapKq1wOvAtBOOSQNWuT5effx5VS1Q1S2uj3cB+wCvGwcU5O/LjAkp5Oyu4F/WnGwcsKagjHfy9nHXqASiOgU6Hce4yYpqc1LLc/bybn4Z94xJspmYJ5j0tR4MS4jiyWX5lB2pcTqOMWerF9C8Uix17WtuE3Cd6+OvA2Ei8j+Xq0RkMBAAbPVQTkdNvqAHg/p04anl+RypthVVTeupa2hk7qIc4ruGcMvQjtvL1B5ZUW2+oqq2nsyFOaR0D+PmIX2cjtPmiAhzpqVTXdfAY0utadG0OyfrdjrxHof7gOEi8hkwHNgJfDm8WUR6AH8FblXVxq+8gcjtIrJBRDaUlZW1XPJWJCJkTElj/9FafvuOjdgzredv64op3HeUhyelEeBnZVp7Yn9a5it++04hOw83NSf6dfDmxFPpH92JH1zZj39/Wsr67QedjmPM2SgF4po9jgV2NT9AVXep6rWqOhB42LWvHEBEOgOLgUdUdd3J3kBVX1TVQao6KDq6/d4dckFsBNdfEsvLa7exfX+l03FMB3CospZnVm5hWEIUo1NjnI5jzpJVTOZ/bC07yh/fL+Lai3sxuG+k03HatDtHJtArIpiZb2VR3/CVk3XGtFXrgUQR6SsiAcANwILmB4hIlIgc//3wEPCya38A8F+amhj/1YqZHfPAuGQCfH2Yt8RG7BnP+/XKAo5U1zFzso3Qa4+sqDZfUlVmzc8myN+XhyZYc+KZhAQ0NS3m7TnCXz6ypkXTPqhqPXAnsAzIBd5Q1WwRyRSRqa7DrgbyRaQA6AbMc+3/f8BVwC0i8rlru6h1v4LWFdM5iDtGJLAiZy9rC/c7Hcd4sYK9R3jt4x18+7I+JHcPczqOOQdWVJsvLfliDx8U7ue+sclEh1m3sTvGpXfj6uRonllRwN6KaqfjGOMWVV2iqkmq2l9V57n2ZajqAtfHb6pqouuY76tqjWv/a6rqr6oXNds+d/JraQ23DetLXGTTiD27KmU8QVWZuyiH0ABf7hmT5HQcc46sqDYAHK2pZ+6iHNJ7duY7l1tzortEhDlT06ltaGTeYrs8bIw3CvL35ecTUsnfe4TX19uIPdPyVuXu4/0t+7l7dBKRoQFOxzHnyIpqA8Bzq7awp6KazGkD8PWx+7jORp+uofxoeH8WbNrFh3Z52BivNH5Ady7rG8nTKwooP2Yj9kzLqa1vZN6SXPpHh/Jdm7jVrllRbSjYe4SXPtjGNwfFcUmfLk7HaZfuuLo/cZHBZCzIprbeLg8b422Oj9g7VFXLb1ZtcTqO8SJ/+XA72/ZX8sjkNPxt4la75vafnoiEejKIcYaqkjE/i9BAPx6ckOJ0nHYryN+XOVPTKdx3lJfXbnM6jjHGA9J7hnPDpXH85cPtbC076nQc4wX2H63hN6u2cHVyNCOSbYRee3fGolpEhopIDk1d4ojIhSLygseTmVaxYNMu1hUd5IHxyXYf13kamdKNMWndeHblFnYdPuZ0HGOMB0wfk0yQv6/1UJgW8avlBRyra+CRSWlORzEtwJ0z1c8A44ADAKq6iaaRSqadO1Jdx6OLc7kwNpwbLu3tdByvkDE5DUV5dHGO01GMMR4QHRbIXSMTeCdvH2sK2udqkaZtyNlVwT/X7+C7Q/qQENPJ6TimBbh1+4eqntju3OCBLKaVPbNiC/uP1jD3GmtObClxkSHcOSKBJV/s4T37hWuMV7rlinj6dA1h7qIc6mzEnjkHqkrmomzCg/25e5SN0PMW7hTVJSIyFFARCRCR+3DdCmLar9zdFfzlo+18a3BvLoiNcDqOV/nBVf3oGxXKrAXZ1NTbvz+N8TaBfr48PDGVwn1H+ds6W/jJnL1l2XtYV3SQ6WOSCA/xdzqOaSHuFNU/An4C9AJKgYuAOzwZyniWqjLzrSzCg/25f1yy03G8TqBfU9Pitv2VvLimyOk4xouJyCAR+a+IfCoim0XkCxHZ7HSujmBMWjeuSOjKMyu3cKiy1uk4ph2prmtg3pJckruFceNgu/XSm7hTVCer6rdVtZuqxqjqdwBbw7od+/enO9lQfIgZ41OICLHmRE+4KimaiV/rzm9XF1JysMrpOMZ7/Q34M3AdMAWY7Pqv8TARYebkNI5U1/GsjdgzZ+HltdsoOXiMmZPT8LMRel7FnT/N59zcZ9qB8mN1/HJJLhf3juD6S2KdjuPVZk5Ow9dHmLPQmhaNx5Sp6gJV3aaqxcc3p0N1FCndO/Oty3rz13XFbNl7xOk4ph3YV1HN8+8UMjq1G8MSo5yOY1rYKYtqERkiIvcC0SIyvdk2G/B155OLyHgRyReRQhGZcYpj/p+I5IhItoj8/Zy+CuO2Xy3P51BVLZnTBuBjzYke1SM8mJ+NSmRl7l5W5e51Oo7xTrNE5E8icqOIXHt8czpURzJ9TDKhAb7MXZyLqjodx7RxTy7Lp7ahkYcn2QV/b3S6M9UBQCfADwhrtlUA15/pE4uIL/A8MAFIA24UkbQTjkkEHgKuUNV04O5z+BqMm7J2lvPaumK+e3kfBvQKdzpOh3DrFX1JiOnE7IXZVNdZ06JpcbfS1OcynqbbPo7fAmJaSWRoAD8bncR7BWWszt/ndBzThn1RWs6bn5Zy6xV96Rtl6+l5I79TPaGqa4A1IvLKOV5OHAwUqmoRgIi8DkwDml8L/wHwvKoecr2n/UTykMZG5ZG3sogMDWT6WGtObC0Bfj7MnTaAG/+4jhfe3cr0MTY6ybSoC1X1a06H6OhuGtKHv31czKOLchmWEE2An90na/6XqjJnYTaRIQHcOTLB6TjGQ9z5zq8SkSdFZImIvHN8c+N1vYDm861LXfuaSwKSRGStiKwTkfEn+0QicruIbBCRDWVlNvv3XPxrYwmflxzm5xNTCA+28T2taUj/rky7qCe/X7OV7fsrnY5jvMu6E68Amtbn7+vDI5NSKdpfyasfbXc6jmmDFm3ezYbiQ9w3LpnOQfY72Fu5U1T/DcgD+gJzgO3Aejded7Ibdk+84cwPSASuBm4E/iQiXxmarKovquogVR0UHR3txlub5g5V1vLY0jwGx0fy9YEn/rvGtIaHJ6YS4OvDrAXZdt+laUnDgM9dvSs2Us9BI5JjuCopmmdXbeHA0Rqn45g2pLqugceW5pHaozP/b1Cc03GMB7lTVHdV1ZeAOlVdo6rfAy5343WlQPO/PbHArpMcM19V61R1G5BPU5FtWtCTy/OpqK4n85p0RKw50QkxnYO4Z0wSawrKWJZtTYumxYyn6WfmWGyknqNEhJmTUqmqbeDpFQVOxzFtyIvvFbHz8DFmTUmz1Yu9nDtFdZ3rv7tFZJKIDKSpQD6T9UCiiPQVkQDgBmDBCce8BYwAEJEomm4HsdUyWtCmksP845Md3DI0npTunZ2O06HdPKQPKd3DyFyYTVVtvdNxjHfQU2zGAYndwvju5X34xyc7yN1d4XQc0wbsKa/md+9uZcKA7lzer6vTcYyHuVNUPyoi4cC9wH3An4B7zvQiVa0H7gSW0bSs+Ruqmi0imSIy1XXYMuCAiOQAq4H7VfV4LOUeAAAgAElEQVTAOXwd5iQaXM2J0Z0CuXu0XQBwmp+vD3OvGcCu8mqee6fQ6TjGOywGFrn+u4qmkxJLHU3Uwd09OpHOwf48ujjHbvUyPP52Hg2q/HyijdDrCE45/QO+HIuXqKqLgHJcZ5XdpapLgCUn7Mto9rEC012baWH/+GQHX+ws59kbLiLMGiPahEvjI7nu4lj+9H4R110cS0JMJ6cjmXbsxMkfInIx8EOH4hggIiSAe0YnMWtBNity9jI2vbvTkYxDPt1xiP9+tpM7ru5PXGSI03FMKzjtmWpVbQCmnu4Y0zYdOFrDk8vyGdKvK1Mv7Ol0HNPMQxNTCPb3ZdaCLDuTZVqUqn4KXOp0jo7u25f1JjGmE/OW5FJTb/PpO6LGRiVzYQ7RYYHcMcJG6HUU7tz+8aGI/FZErhSRi49vHk9mzsvjb+dRWVNP5jRrTmxrojoFcv+4ZNYWHmDR5t1OxzHt2Amr3d7nWpXW5o46zM/Xh5mT0yg+UMUra7c7Hcc4YP6mnXxecpgHxiXTKfC0NwUYL+JOUT0USAcygV+5tqc8Gcqcn43FB3ljQym3XdmXxG5hTscxJ/Gty/owoFdnHl2cw9Eaa1o056z5areBNN1bPc3RRAaAq5KiGZUSw3PvFFJ2xEbsdSRVtfU8vjSfC2LDue5id+Y6GG9xxqJaVUecZBvZGuHM2atvaGTmW9n0CA/ipyOtObGt8vUR5k4bwL4jNTy70sZvmXOWo6pzXNs8Vf0bNlKvzfj5pFSq6xr41fJ8p6OYVvT7d7eyp6KajMlp+NgIvQ7F1lL1Mq+tKyZndwUzJ6cRapec2rSBvbtww6VxvLx2O/l7jjgdx7RPD7m5zzigf3Qnbh4azz83lJC1s9zpOKYVlB6q4g/vFTHlwp4Mio90Oo5pZVZUe5GyIzX8ankBVyZGMWGAdZy3Bw+MSyEsyI+Z861p0bhPRCaIyHNALxH5TbPtFcDuJ2pDfjoqkS4hAWQushF7HcFjS/MQgRkTUpyOYhxgRbUX+eWSXGrqG5kz1ZoT24suoQE8OD6FT7Yd5K3Pdzodx7Qfu4ANQDWwsdm2ABjnYC5zgvBgf6aPSeKTbQdZmrXH6TjGg9ZvP8iizbu5/ar+9IoIdjqOccAZ7w8QkWtPsrsc+EJV97V8JHMuPi46wH8+28mdIxLoF22zj9uTbw6K45/rS5i3OI+RKd0ID7aZ4ub0VHUTsElE/q6qdWd8gXHUDZfG8dq6Yn6xJJeRKTEE+fs6Hcm0sOMj9Lp3DuJHw/s5Hcc4xJ0z1bfRtIrit13bH2larGWtiHzXg9mMm+oaGsmYn02viGB+YvMw2x0fH+HRawZwoLKGZ1ZY06I5K4NFZIWIFIhIkYhsE5Eip0OZ/+Xn60PG5DRKDx3jpQ+2OR3HeMCbn5byxc5yZkxIISTA+pk6KneK6kYgVVWvU9XrgDSgBrgMeNCT4Yx7/vLhdvL3HmHWlDSCA+wMSHs0oFc437msD69+tN0amszZeAl4GhhG06Ivg7DFX9qkoQlRjE3rxvOrC9lXUe10HNOCjtbU8+SyfAb2jmDaRbbYWkfmTlEdr6p7mz3eBySp6kHALjs6bG9FNc+sKGBEcjRj0ro5Hcech/vGJtMlJICM+Vk0NlpDk3FLuaouVdV9qnrg+HamF4nIeBHJF5FCEZlxkuf7iMgqEdksIu+KSGyz524WkS2u7eaW/oK82cOTUqlvUJ5YZiP2vMnzq5tmkc+aYv1MHZ07RfX7IrLI9YP0ZmA+8J6IhAKHPRvPnMmji3Opa1RmW3Niuxce4s9DE1P5dMdh3txY6nQc0z6sFpEnRWSIuyveiogv8DwwgaYrjzeKSNoJhz0FvKqqF9C08NcvXa+NBGbRdKVyMDBLRLq07Jfkvfp0DeXWYfG8ubGUzaX269Mb7DhQxUvvb+Pagb24KC7C6TjGYe4U1T8BXgEuAgYCrwI/UdVKVR3hwWzmDD4s3M/CTbv48fD+9Oka6nQc0wKuu7gXl8Z34bG38zhcVet0HNP2XUbTLR+/wP0VbwcDhapapKq1wOt8dRXGNGCV6+PVzZ4fB6xQ1YOqeghYAYw/76+iA7lzRAJRnQLIXGgj9rzBL5bk4usjPDDeRugZ91ZUVFV9U1XvUdW7XR/bTwKH1dY3MnN+Fr0jQ/jx1f2djmNaiIiQOW0A5cfqeNIuEZszOMcVb3sBJc0el7r2NbcJuM718deBMBHp6uZrzWmEBflz39hkNhQfYuHm3U7HMefho60HeDt7D3dc3Z/u4UFOxzFtwBmLahG51nXvXLmIVIjIERGpaI1w5tReXruNrWWVzJ6aZuOZvExqj87cPCSev3+yg00ldonYnJqIdBORl0RkqetxmojcdqaXnWTfiSdK7gOGi8hnwHBgJ02LyrjzWkTkdhHZICIbysrKzvh1dDTfGBRHWo/OPLYkl2O1DU7HMeegoVHJXJRDr4hgfnCVjdAzTdy5/eMJYKqqhqtqZ1UNU9XOng5mTm3X4WM8u3ILY9K6MTLFmhO90T1jEonqFMjM+Vk0WNOiObVXgGXA8ZEDBcDdZ3hNKRDX7HEsTYvJfElVd6nqtao6EHjYta/cnde6jn1RVQep6qDo6Gj3v5oOwtdHmDUljV3l1bz4nk1AbI/+ub6E3N0VPDQxxU5smS+5U1TvVdVcjycxbnt0cQ6KkjH5xN4i4y3Cgvx5ZFIqm0vL+ccnO5yOY9quKFV9g6bRp6hqPXCmU5/rgUQR6SsiAcANNK3E+CURiRKR478fHgJedn28DBgrIl1cDYpjXfvMWbqsX1cmfq07v1+zld3lx5yOY85CRXUdv1qez+D4SCZ9rYfTcUwb4k5RvUFE/ikiN7puBbn2FKssmlbwXkEZS77Yw50jEoiLDHE6jvGgqRf2ZEi/rjy5LJ8DR2ucjmPapkrXvc4KICKX07Ti7Sm5Cu87aSqGc4E3VDVbRDJFZKrrsKuBfBEpALoB81yvPQjMpakwXw9kuvaZc/DQhFQaVHl8aZ7TUcxZeG7VFg5W1ZIxJc2mbpn/4U5R3RmooumMxBTXNtmToczJ1dQ3MGtBNn2jQu0erg6gqWkxncqaeh5/237pmpOaTtNZ5v4ispam6Ux3nelFqrpEVZNUtb+qHi+YM1R1gevjN1U10XXM91W1ptlrX1bVBNf2Z898WR1DXGQIP7iyL299votPdxxyOo5xw7b9lbzy4Xa+cUksA3qFOx3HtDFnXEtTVW9tjSDmzP74XhHb9lfy6vcGE+hn93B1BIndwrjtyr78YU0R37w0jkv6RDodybQhqvqpiAwHkmlqIsxXVVuUqx254+oE/rWhlMyFOfznx0Px8bEzn23ZvMU5BPr5ct+4ZKejmDbolGeqReQB13+fE5HfnLi1XkQDUHKwit+uLmTi17pzVZI1/nQkPx2ZSI/wIGa+lU19Q6PTcUwb4lrIZSIwiqariXeJyHRnU5mzERroxwPjU/i85DDzN+10Oo45jfe3lLEydx8/GZFATJiN0DNfdbrbP443J24ANp5kM60oc1EOPiI8MsmaEzua0EA/Zk5OI2d3Ba+tK3Y6jmlbFgK3AF2BsGabaUeuHdiLC2LDeXxpPlW19U7HMSdR39DI3EU59I4M4XvD4p2OY9qoU97+oaoLXf/9S+vFMSfzTt5eVuTsZcaEFHpGBDsdxzhgwoDuXJkYxa+WFzDxgh52lsQcF+taSty0Yz4+QsbkNK7//Uf8/t2tTB9rtxa0NX//ZAcFe4/yh+9eYrdfmlNyZ/GXJBF5UUSWi8g7x7fWCGeguq6pOTEhphPfu6Kv03GMQ0SEOVPTqalv5JdLrGnRfGmpiIx1OoQ5f4PiI5lyYU/+8F4RpYeqnI5jmjlcVcvTKwoY2r8rY9NsbQhzau5M//gX8BnwCHB/s820gt+9u5WSg8fInJpOgJ87f1zGW/WL7sTtV/Xjv5/t5OOiA07HMW3DOuC/InLMVrxt/2ZMSEEEHrMRe23Kr1duoeJYnY3QM2fkTpVWr6q/U9VPVHXj8c3jyQzFByr53ZqtTLmwJ0MTopyOY9qAn4xIoFdEMDPnZ1FnTYsGfgUMAUJsxdv2r1dEMLdf1Z9Fm3ezfruN/24LCvcd4a/rirlxcG9Sutu3ljk9d4rqhSJyh4j0EJHI45vHk3VwqsrsBdn4+wiPTEp1Oo5pI4IDfJk1JY2CvUd5Ze12p+MY520BslTV1rL3Ej8a3o/unYPIXJhDY6P9sTpt7qJcQgJ8mT4myekoph1wp6i+mabbPT7k/yZ/bPBkKAMrcvayOr+Me8Yk0a2zNaWZ/zMmrRsjU2L49coC9pRXOx3HOGs38K6IPCQi049vTocy5y4kwI8ZE1L4Ymc5//601Ok4HdrqvH2sKSjjZ6MS6dop0Ok4ph04bVEtIj7Ad1S17wmbLefnQcdqG5izMIfkbmHcPDTe6TimjRERZk9Jp75ReXRxjtNxjLO2AauAAGyknteYdlFPBvaO4Ill+RytsRF7TqhraGTu4hz6RYVy05B4p+OYduK0RbWqNgJPtVIW4/L86kJ2Hj5G5rR0/H2tOdF8Ve+uIdxxdQKLNu9mbeF+p+MYh6jqHFWdAzwN/KrZY9OOiQizpqRTdqSGF1YXOh2nQ3r1o2KKyip5ZHKqDQkwbnPnb8pyEblOzqHlVUTGi0i+iBSKyIzTHHe9iKiIDDrb9/A2RWVHefG9Iq4d2IvL+nV1Oo5pw344vB99uoYwc34WNfUNTscxDhCRASLyGZAFZIvIRhFJdzqXOX8XxUVw7cBe/OmDbZQctBF7relgZS3PrizgqqRoRiTHOB3HtCPuFNXTaRqrV3M2I5tcy+c+D0wA0oAbReQrywGKSBjwU+Djs0ruhVSVWQuyCfTz4aGJ1pxoTi/I35fZU9MpKqvkpQ+2OR3HOONFYLqq9lHVPsC9wB8dzmRayAPjU/AV4RdLcs98sGkxT6/Ip7K2gZmTUm2EnjkrZyyqXSOafFQ14CxHNg0GClW1SFVrgdeBaSc5bi7wBNDhO66WZu3h/S37uXdsEtFh1hRhzmxEcgzj0rvx3KqmW4ZMhxOqqquPP1DVd4FQ5+KYltQ9PIgfX92fpVl7WGez6VtF3p4K/v7xDr57eR8Su1l7gjk7bt0oJCJdRGSwiFx1fHPjZb2AkmaPS137mn/egUCcqi5yO7GXqqypJ3NhDmk9OvOdy/s4Hce0IzMnp6EomQuznY5iWl+RiMwUkXjX9ghNzYvGS9x+VT96RQQzZ2EODTZiz6NUlbmLcugc7M/doxOdjmPaIXeWKf8+8B6wDJjj+u9sNz73ya6ZfPkTwTVZ5BmaLleeKcPtIrJBRDaUlZW58dbtz2/e2cKeimrmXjMAP2tONGchtksId41MZFn2Xlbn73M6jmld3wOigX8D/wGigFucDGRaVpC/LzMmpJC7u4I3NpSc+QXmnK3I2cvawgPcMzqJiJAAp+OYdsid6u1nwKVAsaqOAAYC7lS2pUBcs8exwK5mj8OAATTNWN0OXA4sOFmzoqq+qKqDVHVQdHS0G2/dvmzZe4SX3t/G/xsUyyV9ujgdx7RDP7iyH/2iQ5m9IJvqOmta7ED60/Rz1gfwB0bRdBLEeJHJF/Tg0vguPLUsn4rqOqfjeKWa+gbmLcklMaYT376st9NxTDvlTlFdrarVACISqKp5QLIbr1sPJIpIXxEJAG4AFhx/UlXLVTVKVeNVNR5YB0xV1Q61sIyqkjE/m9BAPx4cn+J0HNNOBfj5kDl1AMUHqvjDmiKn45jW8zfgZeBaYLJrm+JoItPiRISMyekcrKrlt+/YiD1PeGXtdooPVDFzcppdLTbnzJ2/OaUiEgG8BawQkfn87xnnk1LVeuBOmm4XyQXeUNVsEckUkannE9qbLNi0i4+KDnD/uGRbscmcl2GJUUy6oAcvvFvIjgM2gquDKFPVhaq6TVWLj29OhzIt72ux4Vx/cSx/XruN7fsrnY7jVcqO1PDcO4WMSonhqiTvuxpuWo870z++rqqHVXU2MBN4CbjGnU+uqktUNUlV+6vqPNe+DFVdcJJjr+5oZ6mPVNcxb3EuF8SGc+Ngu9xkzt/MSWn4+QhzrGmxo5glIn8SkRtF5Nrjm9OhjGfcPz6ZAF8f5tmIvRb11LJ8auobeHiSjbI158fd6R/DRORWVV0DfMQJUzzMufn1yi2UHa1h7rQB+PrYLExz/rqHB3H36CRW5e1jRc5ep+MYz7sVuAgYT9NtH1NougXEeKGYsCB+MjLB1VBnK6m2hKyd5byxsYSbh8TTL7qT03FMO+fO9I9ZwIPAQ65d/sBrngzVEeTtqeCVD7dzw6W9uTAuwuk4xovcckU8Sd06MXtBNsdqrWnRy13oauK+WVVvdW3fczqU8ZzvXdGXuMhgMhfmUN/Q6HScdk1VyVyYQ5eQAO4aZSP0zPlz50z114GpQCWAqu6iaXKHOUeqSsZb2XQO8uOBce70fBrjPn9fHzKnDWDn4WO88K41NXm5dSdbqdZ4ryB/Xx6emEr+3iP8Y72N2DsfS77YwyfbD3Lv2CTCg/2djmO8gDtFda2qKq4Z0yJiq3Wdp/9+tpNPth9kxoQUuoTaLEzT8i7v15WvD+zFH9YUsc2amrzZMOBzEckXkc0i8oWIbHY6lPGscenduaxvJE8vz6e8ykbsnYvqugZ+sSSXlO5h3HCp9TSZluFOUf2GiPwBiBCRHwArgT96Npb3Kj9Wxy+W5DKwdwTfuCTuzC8w5hw9NDGFQD8fMuZn0fTvYuOFxgOJwFj+735qG6nn5USEjClpHD5Wx7Ortjgdp1360/tF7Dx8jIwpadbTZFqMO9M/ngLepGnFrmQgQ1Wf83Qwb/X08nwOVtYyd9oAfOwb2XhQTFgQ08cm8f6W/SzN2uN0HOMBzcfo2Ui9jiW9Zzg3XBrHqx9tp3DfUafjtCt7K6p54d2tjEvvxtD+UU7HMV7ErekfqrpCVe9X1ftUdYWnQ3mrrJ3l/HVdMd+5vA8DeoU7Hcd0AN+9vA9pPTozd1EOlTX1TscxxrSge8cmE+zvy7zFOU5HaVcefzuP+gbl4YnWjmBa1imLahE5IiIVJ9mOiEhFa4b0Bo2Nysz5WXQJCeDesdacaFqHn68Pc69JZ3d5Nb95xy4TG+NNojoFcteoBFbnl/Fu/j6n47QLn5cc5j+f7uR7w/rSu2uI03GMlzllUa2qYara+SRbmKp2bs2Q3uDNjaV8tuMwD01MtS5j06ou6RPJNy6J5aX3t7Fl7xGn4xhjWtAtQ/sS3zWERxfnUmcj9k6raYReNlGdArlzZILTcYwXsgXuW8HhqloeezuPS+O7cN3Ftm6OaX0zJqQQGuhHxvxsa1o0xosE+Pnw8KQ0Cvcd5W/r7Hb601mwaRef7jjMA+OS6RTo53Qc44WsqG4FTy7Lp/xYHZnTBiBizYmm9XXtFMj945L5qOgACzbtcjqOMaYFjU6NYVhCFM+s3MKhylqn47RJVbX1PLY0jwG9OnP9JbFOxzFeyopqD9tUcpi/f7KDm4fEk9rD7poxzrlxcG8uiA1n3uJcjlTbbNuOTETGu2ZbF4rIjJM831tEVovIZ6751xNd+/1F5C+uedi5IvLQVz+7aW0iwszJaRypruPXKwucjtMm/WFNEbvLq8mYnG6Tt4zHWFHtQQ2u5sSoToHcPcaWQDXO8vUR5k4bQNnRGp5ZYU2LHZWI+ALPAxOANODGk6zK+AjwhqoOBG4AXnDt/wYQqKpfAy4Bfigi8a2R25xecvcwvnVZb177eAcF1jvxP3YdPsYf3tvKpAt6MLhvpNNxjBezotqDXl+/g82l5TwyKZXOQdacaJx3YVwENw7uzV8+2k7ubhvi00ENBgpVtUhVa4HXgWknHKPA8Utr4cCuZvtDRcQPCAZqAfuL1EZMH5NMaIAvcxflWO9EM48tzUMVHpqQ4nQU4+WsqPaQg5W1PPF2Ppf3i2TqhT2djmPMlx4Yl0znID9babHj6gWUNHtc6trX3GzgOyJSCiwB7nLtfxOoBHYDO4CnVPWgR9Mat0WGBvCz0U0LPr2TZyP2ADYWH2TBpl3cflU/YrvYCD3jWVZUe8jjS/OorKlnrjUnmjYmIiSAGRNSWL/9EP/+dKfTcUzrO9kPpBP/dXUj8IqqxgITgb+KiA9NZ7kbgJ5AX+BeEen3lTcQuV1ENojIhrKyspZNb07rpiF96BcdyqOLc6mt79gj9hoblTkLc+jWOZAfDe/vdBzTAVhR7QEbiw/xzw0l3DasL4ndwpyOY8xXfOOSOC7uHcEvl+RSfsyaFjuYUiCu2eNY/u/2juNuA94AUNWPgCAgCvgW8Laq1qnqPmAtMOjEN1DVF1V1kKoOio6O9sCXYE7F39eHmZPS2La/klc/2u50HEf957OdbC4t58HxTSNFjfE0K6pbWEOjMvOtLLp3DuKno6w50bRNPj7C3GsGcKiqll8tz3c6jmld64FEEekrIgE0NSIuOOGYHcAoABFJpamoLnPtHylNQoHLgbxWS27cMiIlhuFJ0Ty7agsHjtY4HccRlTX1PPF2HhfGRXDNRbY+hGkdVlS3sNfWFZOzu4KZk9PsX8amTUvvGc5NQ+J5bV0xWTvLnY5jWomq1gN3AsuAXJqmfGSLSKaITHUddi/wAxHZBPwDuEWbbsB/HugEZNFUnP9ZVTe3+hdhzmjm5FSqaht4ekXHHLH3wruF7DtSw6wpaTZCz7Qaq/paUNmRGp5ans+whCgmfq2703GMOaN7xiSxaPNuHnkri//8eKj98ukgVHUJTQ2IzfdlNPs4B7jiJK87StNYPdPGJcSE8d3L+/DqR9v5zuV9OtQ6CSUHq/jj+9u45qKeXNy7i9NxTAdiZ6pb0C+X5lJd18CcaenWnGjahfBgf34+MYXPSw7zxoaSM7/AGNNu3D06kc7B/h1uxN4vl+biK8KDNkLPtDIrqlvIJ9sO8p9Pd/KDK/vRP7qT03GMcdvXB/ZicHwkj7+dZ0scG+NFIkICmD4miQ+3HmB5zl6n47SKdUUHWPLFHn40vD89woOdjmM6GCuqW0B9QyMZ87PoFRHMnSMTnI5jzFkRETKvSaeiup4nllnPmTHe5FuDe5MY04lfLMmlpr7B6Tge1dCoZC7MoWd4ELdf9ZVJj8Z4nBXVLeAvHxWTt+cIMyenERJgt6mb9iele2duHRrP6+tL+GzHIafjGGNaiJ+vDzMnp1F8oIo/r93udByP+teGEnJ2VzBjYirBAb5OxzEdkBXV52lvRTXPrCjg6uRoxqV3czqOMefs7jFJxIQFMnN+Fg2NHef+S2O83VVJ0YxKieG37xRSdsQ7R+wdqa7jqeX5DOrThSkX9HA6jumgrKg+T79YkkttQyOzp1hzomnfOgX68cikNLJ2VvD3j4udjmOMaUEPT0qlpr6Bp5Z551z6375TyP6jtWRMSbPfxcYxVlSfhw+37mf+57v40fD+xEeFOh3HmPM2+YIeDO3flSeX5bO/gy4aYYw36hfdiZuHxPPGxhKvm0u/fX8lL6/dxvWXxHJBbITTcUwHZkX1OaqtbyRjfjZxkcHccXV/p+MY0yJEhMxpAzhW18BjS61p0RhvcteoRLqEBJDpZSP25i3JJcDXhwfGJTsdxXRwVlSfoz+v3UbhvqPMnpJOkL81RBjvkRDTie9f2Y83N5ayYftBp+MYY1pIeLA/945N4pNtB1matcfpOC1ibeF+VuTs5Y4RCcR0DnI6jungrKg+B7vLj/Hsqi2MTu3GqFRrTjTe566RCfQMD+KRt7Kob2h0Oo4xpoXccGlvUrqH8YslTYuVtWf1DY1kLswhLjKY24b1dTqOMVZUn4tHF+XS0KjMmpLmdBRjPCIkwI+MKWnk7TnCqx9Z06Ix3sLXR8iYkkbpoWO89ME2p+Ocl3+sLyF/7xF+PiHVrhibNsGjRbWIjBeRfBEpFJEZJ3l+uojkiMhmEVklIn08maclvFdQxuIvdnPniATiIkOcjmOMx4xL787wpGieXlHAvopqp+MYY1rI0P5RjEvvxvOrC9nbTr+3y6vqeHp5Ppf1jWT8gO5OxzEG8GBRLSK+wPPABCANuFFETjy1+xkwSFUvAN4EnvBUnpZQU9/A7AXZxHcN4Qe2WpPxciLCnKnp1NY3Mm9JrtNxjDEt6OcTU6lvUJ54u32O2Ht21RYOH6uzEXqmTfHkmerBQKGqFqlqLfA6MK35Aaq6WlWrXA/XAbEezHPe/vT+Nor2VzJ7qjUnmo4hPiqUHw3vx/zPd/Hh1v1OxzHGtJA+XUO5dVg8//60lE0lh52Oc1YK9x3l1Y+2c8OlcaT3DHc6jjFf8mRR3Qsoafa41LXvVG4Dlp7sCRG5XUQ2iMiGsrKyFozovtJDVTz3zhbGp3fn6uQYRzIY44Q7RiQQFxlMxvxs6qxp0RivceeIBKI6Bba7EXvzFucQ7O/LvWNthJ5pWzxZVJ/sesxJv2tF5DvAIODJkz2vqi+q6iBVHRQdHd2CEd2XuTAHQZhpzYmmgwny92X2lHQK9x3l5Xbe2GSM+T9hQf7cPy6JjcWHWLBpl9Nx3PJu/j5W55dx16imfxAY05Z4sqguBeKaPY4FvvJdKyKjgYeBqaraJpdwW523j+U5e7lrVAK9IoKdjmNMqxuV2o3RqTE8u2oLu8uPOR3HGNNCrr8kjvSenXl8aR7Hatv2iL26hkbmLsohvmsItwy1EXqm7fFkUb0eSBSRviISANwALGh+gIgMBP5AU0G9z4NZzll1XQOzF2bTPzqU7w+z5kTTcc2akk5Do/LoImtaNMZb+PoIs6aks6u8mhffK3I6zmm9tq6YrWWVPDwpjQA/mwhs2h6P/a1U1XrgTmAZkAu8oarZIpIpIlNdhz0JdAL+JSKfi8iCU3w6x/x+zVaKD1SROW2AfRObDi0uMoQ7RySw+IvdvFfgTG+DMablDe4byaSv9SbezO0AABbqSURBVOD3a7a22StRhypr+fXKLQxLiGJ0qvU1mbbJo1Wiqi5R1SRV7a+q81z7Mv5/e3ceX1V953/89clOQhYgLCEJEmQJAWQRUYu1TFUERGid9iFWf7W1P52202mdjsPgaLFi/Y22nU7tr9aWaWunrWPbsb8qIopWcGldEJEtYd8T9i3saz6/P+4BrxEQSG7OPTfv5+NxH/fc7z3L+4bDN5+cc77nuvu0YPpqd+/s7oOCx7gzr7Flrd9xgJ+8soqxF5UwvGdx2HFEQnf7lT3o3iGX+6ZVc/hYcp8qFpGzN2l0Jcfdefj5pWFHOaX/+PNy9h46yrfG6hZ6krx06PU03J1vP1tNZppx73UanCgCsUGL94/vz5rt+/nPJD9VLCJnr7x9Lnd8vAdPz9/IvPW7wo7zAcu37OWJt9dz86UX0KdLfthxRE5LRfVp/HnJVmYt3cqdV/emS2FO2HFEksYnendkdP8u/Hj2SjbsPPDRC4hIJHxlxIV0ys/m/mdraGhIjlvsuTsPTK+hbXYG37ymd9hxRM5IRfUpHDwS++bE3p3b8oXh3cOOI5J0vjW2CsOYMr0m7Cgi0kzysjOYOKqSBRt28/T8urDjAPDykq28vmI7d17di3Z5WWHHETkjFdWn8JNXVlK3+yBTxvcnM10/IpHGuha14etX9eKlmi3MWrol7Dgi0kxuGFzKwLJCHn5hKfsPHws1y5FjDTw4Ywk9O7XllssuCDWLyNlQxdjImu37+dmrq/n04FIu69Eh7DgiSetLV1TQs1Nb7ptWzaGjGrQokgrS0ozJ11exZc9hfvrqqlCz/Ncba1mzfT/3XtdXB7gkErSXxnF3Jj+zmOyMNO4eUxl2HJGklpWRxpRx/diw8yCPvRLuL18RaT4XX9CecQO7MvW11dTuCmfcxPZ9h/nRyyv4mz4dGdFHt9CTaFBRHeeFxZt5fcV2vjmyN53yNThR5KN8rGcx1w/symOvrmLdjv1hxxGRZjJpdCVm8FBIt9j79xeXc/Doce4dq7tvSXSoqA4cOHKMKdNr6FtSwP/StVsiZ+3e6/qSlZ7GfdOqcU+OOwaISNN0LWrD3115IdMXbuKdtTtbdNs1G/fw+3fW8/nLu3Nhx7Ytum2RplBRHfjRyyvZVH+IB8b3I0PXbomctc4FOdx5dS9eWbaNF2s0aFEkVXz5ExdSUpjDlBa8xZ67M2V6NYVtMvnGVb1aZJsizUXVI7By615+/vpqPnNxGUO7tw87jkjkfOFj3ansks+UZ2s4cCTcOwaISPNok5XOpNGVLKqr56l5tS2yzZnVm3lr9U6+ObIPhbmZLbJNkebS6ovq2ODEanKDzkNEzl1GehpTxvenbvdBfjxrZdhx5COY2SgzW2ZmK81s0ine72Zms83sPTNbaGZj4t67yMzeNLNqM1tkZhqAksLGDezK4G5FfG/mMvYl+BZ7h44e58EZS+jTOZ+bLilP6LZEEqHVF9XPLtzEG6t28M+jKilumx12HJHIGlbRnhuGlPKfr69m1bZ9YceR0zCzdOBRYDRQBdxkZo1Hg90L/MHdBwMTgJ8Ey2YAvwW+7O79gBHA0RaKLiEwM+67vh/b9h7m0dmJ/YP5l39dw4adB5l8fZUuw5RIatV77b7Dx/jO9BoGlBbyuWHdwo4jEnl3j+5LTmY69z2jQYtJbBiw0t1Xu/sR4HfA+EbzOFAQTBcCG4PpkcBCd18A4O473F03KU9xg8qLuGFwKb94fQ3rdyTmFntb9xzi0VkruaaqM8N7FidkGyKJ1qqL6h++tJxt+w7zwKf6k55mYccRibyO+dncNbIPf1m5necWbQo7jpxaKbAh7nVt0Bbv28AtZlYLzAD+IWjvDbiZzTSzeWY2MdFhJTlMHFVJeprxf2YsScj6vzdzGUeON3DPmL4JWb9IS2i1RfWyzXt5/I21TLiknEHlRWHHEUkZt1x2Af26FvDA9JqEX4Mp5+VURxAan1a4CfiVu5cBY4DfmFkakAFcAdwcPH/azK760AbM7jCzuWY2d9u2bc2bXkLRpTCHr464kBeqN/Pmqh3Nuu5FtbGBkLcNr6B7cV6zrlukJbXKotrd+dYzi8nPyWDitRqcKNKc0tOMBz7Vny17Yt+IJkmnFogfBVbG+5d3nPAl4A8A7v4mkAMUB8u+6u7b3f0AsaPYQxpvwN2nuvtQdx/asWPHBHwECcPtV/agtKgNU6bXcLyZbrHn7tz/bDUd8rL42id7Nss6RcLSKovqp+fXMWfNTv5lVCXt8rLCjiOScoZ0a8eES8r55V/WsHzL3rDjyAe9A/QyswozyyI2EHFao3nWA1cBmFlfYkX1NmAmcJGZ5QaDFj8B1LRYcglVTmY6d4+pZMmmPfxh7oaPXuAsTF+4ibnrdnHXyD7k5+gWehJtra6orj94lAefW8rA8iJuHKpb9ogkysRRlbTNyeDepxdr0GIScfdjwNeIFchLiN3lo9rMppjZuGC2fwJuN7MFwJPAFzxmF/ADYoX5fGCeuz/X8p9CwnLdgBKGdW/P92cuY8+hpt345dDR4zz0/FKqSgr4rH4fSwpodUX1f7y0nB37D/Od8f1J0+BEkYRpn5fFxGsrmbNmJ8/Mb3x1gYTJ3We4e293v9DdHwzaJrv7tGC6xt2Hu/tAdx/k7i/GLftbd+/n7v3dXQMVWxkzY/L1Vew8cKTJ96Sf+tpq6nYf5L7rq3SzAEkJraqort5Yz6/fXMstl17AgLLCsOOIpLwJl5QzsLyI7zy3pMlHtUQkOfQvLeSzF5fx+F/XsGb7/vNax6b6gzz2yirGDOjCpT06NHNCkXC0mqK6oSH2zYntcrO4a2SfsOOItAppacYD4/uxY/9hfvDi8rDjiEgzuevaPmSlp/Hgc+d3i72Hn1/KcXfuHq1b6EnqaDVF9VPzanl33S4mja6kMFeDIURaykVlRdx8aTd+/eZaqjfWhx1HRJpBp/wc/v6TPfnzki38ZcX2c1p23vpdPD1/I7d/vILy9rkJSijS8lpFUb37wBEeen4pQy9ox98OKQs7jkir888jK2mXm8XkZ6ppaKZbcYlIuG4bXkF5+zZMmV7NseMNZ7VMQ4Nz/7M1dMrP5qsjdAs9SS2toqj+/ovL2H3gCFM0OFEkFIW5mUwaXcm763Zx37RqZi/dyta9h8KOJSJNkJOZzj1j+rJ8yz6enLP+rJZ5en4dCzbsZuKoSvKyMxKcUKRlpfweffR4Ayu27OPWj3WnqmtB2HFEWq2/HVLGrKVb+c1b6/jNW+sA6JSfzYDSQvqVFtK/awH9SwspKczBTH/8ikTBtf26cFmP9vzgpeWMG1h6xssr9x8+xsMvLGVgWSE3DC5twZQiLSPli+rM9DR+d8dlHDnLU1MikhhpacZjt1zM3kNHWbJpL4vq6qmuq2fxxnpmL9vKiatCOuRlfaDIHlBaSFm7Niq0RZKQmTF5bD/G/t/XeeTlFUy+vuq08/701VVs2XOYn9w8RGeNJSWlfFENsf/02RnpYccQESA/J5NhFe0ZVtH+ZNvBI8dZsnkPi+vqg8cepr62mmNBpV2Qk0H/0sL3H10L6N4hT7+YRZJAVdcCbrwkNhj5c5d2o2enth+ap3bXAaa+tppxA7ty8QXtP7wSkRTQKopqEUlubbLSGdKtHUO6tTvZdvjYcZZt3sviuj0s3hg7qv2rN9Zy5FjsrFNeVjr9uhbSr7SAAUGx3aM4j4z0VjFURCSp/NPI3kxfsJEHn6vh8S8O+9D7//b8Usxg0ujKENKJtAwV1SKSlLIz0rmorIiLyopOtp0YI3GiyF5UV8+Tc9bz+NFYoZ2TmUbfkgL6dy0MrtUuoFenfLIyVGiLJFJx22y+flUvHpyxhFeWbWVEn04n35uzZifPLdzEN67qRdeiNiGmFEksFdUiEhmZ6WlUdS2IDToeWg7A8QZn9bZYob2oNnZU+0/v1Z0cDJmVnkafLvnBpSOxgrtPl3xyMnVJmEhzuvVj3Xni7XU8ML2G4T2LyUxPo6HBmTK9mpLCHL78iQvDjiiSUAktqs1sFPAIkA783N0favR+NvBr4GJgB3Cju69NZCYRSS3paUavzvn06pzPpwfH2hoanHU7D7x/jfbGemYs2nTytl8ZwTInBkP2Ly2gb0kBuVk6ziByvrIy0rjnuipu//VcfvvWOr44vIKn3q1lcd0eHpkwiDZZ+kNWUlvCfoOYWTrwKHANUAu8Y2bT3L0mbrYvAbvcvaeZTQAeBm5MVCYRaR3S0oyK4jwqivO4fmBXANyd2l0HTxbZi+v2MGvpVv7n3drYMgYXdmxL/9JC+gXFdr+uBeTn6BtYRc7W1X07cUXPYn745xVc3bcz3525jCHdihgX/D8USWWJPCwzDFjp7qsBzOx3wHggvqgeD3w7mH4K+LGZmbvrK9dEpFmZGeXtcylvn8voASVArNDevOdQbDBkXT3VG+t5Y9V2/vRe3cnlKorzThbZA4JCuyg3K6yPIZLUzIxvja1i9COv8fHvzgbgF7cO1S0xpVVIZFFdCmyIe10LXHq6edz9mJnVAx2A7QnMJSICxAqAksI2lBS24Zqqzifbt+49RPXGPScHQ763fjfTF246+X5ZuzZMHlvFyH5dwogtktT6dMnnxku68eSc9Yy9qISB5UUfvZBICkhkUX2qP0sbH4E+m3kwszuAOwC6devW9GQiImfQKT+HTn1y+Ju4Oxjs2n+E6o2xgZCL6urpmJ8dYkKR5DZpVCXtcjO57YqKsKOItJhEFtW1QHnc6zJg42nmqTWzDKAQ2Nl4Re4+FZgKMHToUF0aIiItrl1eFlf0KuaKXsVhRxFJeoW5mUwcpXtSS+uSyJu3vgP0MrMKM8sCJgDTGs0zDbg1mP4MMEvXU4uIiIhI1CTsSHVwjfTXgJnEbqn3S3evNrMpwFx3nwb8AviNma0kdoR6QqLyiIiIiIgkSkJvyuruM4AZjdomx00fAj6byAwiIiIiIomm7+4VEREREWkiFdUiIiIiIk2kolpEREREpIlUVIuIiIiINJGKahERERGRJrKo3RbazLYB685j0WKi+/Xnyh4OZQ9HKme/wN07tlSYZKA+O3KUPRzKHo6zyX7W/XbkiurzZWZz3X1o2DnOh7KHQ9nDoewC0f5ZKns4lD0cyv4+Xf4hIiIiItJEKqpFRERERJqoNRXVU8MO0ATKHg5lD4eyC0T7Z6ns4VD2cCh7oNVcUy0iIiIikiit6Ui1iIiIiEhCpHxRbWajzGyZma00s0lh5wEws1+a2VYzWxzX1t7MXjKzFcFzu6DdzOxHQf6FZjYkbplbg/lXmNmtLZS93Mxmm9kSM6s2s29EJb+Z5ZjZHDNbEGS/P2ivMLO3gxy/N7OsoD07eL0yeL973LruDtqXmdm1ic4et910M3vPzKZHKbuZrTWzRWY238zmBm1Jv88E2ywys6fMbGmw318elexRpX67WXNHts8OthnpfjuqfXawXfXb55rd3VP2AaQDq4AeQBawAKhKglxXAkOAxXFt3wUmBdOTgIeD6THA84ABlwFvB+3tgdXBc7tgul0LZC8BhgTT+cByoCoK+YMMbYPpTODtINMfgAlB+0+BrwTTXwV+GkxPAH4fTFcF+1I2UBHsY+kttO98E/hvYHrwOhLZgbVAcaO2pN9ngu3+F/C/g+ksoCgq2aP4QP12c+eObJ8dbDfS/TYR7bODba9F/fY5ZU/4P0qYD+ByYGbc67uBu8POFWTpzgc752VASTBdAiwLpn8G3NR4PuAm4Gdx7R+YrwU/xzPANVHLD+QC84BLid34PaPxPgPMBC4PpjOC+azxfhQ/X4IzlwEvA58EpgdZopJ9LR/unJN+nwEKgDUE40+ilD2qD9RvJ/ozRLLPDrYZqX6bCPfZwbbWon77nLKn+uUfpcCGuNe1QVsy6uzumwCC505B++k+Q+ifLTg9NZjYkYNI5A9Oxc0HtgIvEfurf7e7HztFjpMZg/frgQ5hZQd+CEwEGoLXHYhOdgdeNLN3zeyOoC0K+0wPYBvweHAK9+dmlheR7FEVpZ9VpPaDKPbZEOl+O8p9NqjfPufsqV5U2ynavMVTNM3pPkOon83M2gJ/BO509z1nmvUUbaHld/fj7j6I2BGEYUDfM+RImuxmNhbY6u7vxjefIUfSZA8Md/chwGjg783syjPMm0zZM4id8n/M3QcD+4mdNjydZMoeVanws0q6/SCqfTZEs99OgT4b1G+fc/ZUL6prgfK412XAxpCyfJQtZlYCEDxvDdpP9xlC+2xmlkmsc37C3f9f0ByZ/ADuvht4hdj1U0VmlnGKHCczBu8XAjsJJ/twYJyZrQV+R+x04g8jkh133xg8bwX+ROwXYxT2mVqg1t3fDl4/RayzjkL2qIrSzyoS+0Eq9NkQuX470n02qN8+Q/tppXpR/Q7QKxhtm0Xs4v9pIWc6nWnArcH0rcSuezvR/vlgdOplQH1w2mImMNLM2gUjWEcGbQllZgb8Alji7j+IUn4z62hmRcF0G+BqYAkwG/jMabKf+EyfAWZ57MKqacCEYLR2BdALmJPI7O5+t7uXuXt3YvvxLHe/OQrZzSzPzPJPTBP7t15MBPYZd98MbDCzPkHTVUBNFLJHmPrtZhTlPjvIH8l+O8p9NqjfPu/sibxYPBkexEZ1Lid2DdY9YecJMj0JbAKOEvtL6EvErp16GVgRPLcP5jXg0SD/ImBo3HpuA1YGjy+2UPYriJ3+WAjMDx5jopAfuAh4L8i+GJgctPcg1kmtBP4HyA7ac4LXK4P3e8St657gMy0DRrfw/jOC90eSJ332IOOC4FF94v9hFPaZYJuDgLnBfvM0sVHgkcge1Qfqt5szd2T77GCbke+3iVifHZdT/fY5Ztc3KoqIiIiINFGqX/4hIiIiIpJwKqpFRERERJpIRbWIiIiISBOpqBYRERERaSIV1SIiIiIiTaSiWiLJzN4Inrub2eeaed3/eqptiYjI+VGfLa2BbqknkWZmI4C73H3sOSyT7u7Hz/D+Pndv2xz5RETkfeqzJZXpSLVEkpntCyYfAj5uZvPN7B/NLN3Mvmdm75jZQjP7u2D+EWY228z+m9jN3TGzp83sXTOrNrM7graHgDbB+p6I31bwbUvfM7PFZrbIzG6MW/crZvaUmS01syeCbzHDzB4ys5ogy/db8mckIpIs1GdLa5Dx0bOIJLVJxB31CDraene/xMyygb+a2YvBvMOA/u6+Jnh9m7vvDL769h0z+6O7TzKzr7n7oFNs6wZi39I0ECgOlnkteG8w0A/YCPwVGG5mNcCngUp39xNftSsi0oqpz5aUpSPVkmpGAp83s/nA28S+lrRX8N6cuM4Z4OtmtgB4CyiPm+90rgCedPfj7r4FeBW4JG7dte7eQOxrgLsDe4BDwM/N7AbgQJM/nYhIalGfLSlDRbWkGgP+wd0HBY8Kdz9x1GP/yZli1/VdDVzu7gOB94Ccs1j36RyOmz4OZLj7MWJHWv4IfAp44Zw+iYhI6lOfLSlDRbVE3V4gP+71TOArZpYJYGa9zSzvFMsVArvc/YCZVQKXxb139MTyjbwG3BhcA9gRuBKYc7pgZtYWKHT3GcCdxE5Dioi0ZuqzJWXpmmqJuoXAseCU4K+AR4idxpsXDDzZRuyIQ2MvAF82s4XAMmKnE0+YCiw0s3nufnNc+5+Ay4EFgAMT3X1z0MGfSj7wjJnlEDti8o/n9xFFRFKG+mxJWbqlnoiIiIhIE+nyDxERERGRJlJRLSIiIiLSRCqqRURERESaSEW1iIiIiEgTqagWEREREWkiFdUiIiIiIk2kolpEREREpIlUVIuIiIiINNH/B7HRds5TIXutAAAAAElFTkSuQmCC\n",
      "text/plain": [
       "<Figure size 864x288 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Full size\n",
    "update_model_dir(learner, args.save_dir)\n",
    "sargs = save_args('first_run', args.save_dir)\n",
    "learner.fit(args.lr,args.epochs, cycle_len=args.cycle_len,\n",
    "            sampler=train_sampler,\n",
    "            wds=args.weight_decay,\n",
    "            use_clr_beta=args.use_clr,\n",
    "            loss_scale=args.loss_scale,\n",
    "            **sargs\n",
    "           )\n",
    "save_sched(learner.sched, args.save_dir)\n",
    "\n",
    "print('Finished!')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [],
   "source": [
    "learner.save('cifar10-resnext-aug-preact')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "learner.sched.plot()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "learner.lr_find()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "learner.sched.plot()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "leaner.fig"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "learner.fit(1e-5,1, cycle_len=15,\n",
    "            wds=args.weight_decay,\n",
    "            loss_scale=args.loss_scale,\n",
    "            **sargs\n",
    "           )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "TTA acc: 0.2077                              \n"
     ]
    }
   ],
   "source": [
    "\n",
    "if args.use_tta:\n",
    "    log_preds,y = learner.TTA()\n",
    "    preds = np.mean(np.exp(log_preds),0)\n",
    "    acc = accuracy(torch.FloatTensor(preds),torch.LongTensor(y))\n",
    "    print('TTA acc:', acc)\n",
    "    \n",
    "    with open(args.save_dir+'/tta_accuracy.txt', \"a\", 1) as f:\n",
    "        f.write(time.strftime(\"%Y-%m-%dT%H:%M:%S\")+f\"\\tTTA accuracty: {acc}\\n\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "TTA acc: 0.2029                              \n"
     ]
    }
   ],
   "source": [
    "\n",
    "if args.use_tta:\n",
    "    log_preds,y = learner.TTA()\n",
    "    preds = np.mean(np.exp(log_preds),0)\n",
    "    acc = accuracy(torch.FloatTensor(preds),torch.LongTensor(y))\n",
    "    print('TTA acc:', acc)\n",
    "    \n",
    "    with open(args.save_dir+'/tta_accuracy.txt', \"a\", 1) as f:\n",
    "        f.write(time.strftime(\"%Y-%m-%dT%H:%M:%S\")+f\"\\tTTA accuracty: {acc}\\n\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.6.5"
  },
  "toc": {
   "nav_menu": {
    "height": "266px",
    "width": "252px"
   },
   "number_sections": true,
   "sideBar": true,
   "skip_h1_title": false,
   "toc_cell": false,
   "toc_position": {},
   "toc_section_display": "block",
   "toc_window_display": false
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}