{
 "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": [],
   "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",
    "    train_tfms = transforms.Compose([\n",
    "    #   transforms.RandomResizedCrop(size),\n",
    "        transforms.ColorJitter(.4,.4,.4,.4,)\n",
    "        torchvision.transforms.RandomRotation(3)\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",
    "# 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": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "args_input = [\n",
    "    '/home/paperspace/imagenet-fast/fp16/data/cifar10', \n",
    "    '--save-dir', '/home/paperspace/data/cifar_training/test1', \n",
    "#     '-a', 'resnet56', \n",
    "#     '-j', '6', \n",
    "#     '--prof', \n",
    "#     '-b', '512', \n",
    "#     '--sz', '32',\n",
    "#     '--loss-scale', '128',\n",
    "    '--fp16',\n",
    "#     '--cycle-len', '95',\n",
    "#     '--epochs', '1',\n",
    "#     '--use-clr', '10,13.68,0.95,0.85',\n",
    "    '--wd', '4e-4',\n",
    "    '--lr', '1',\n",
    "#     '--train-half' # With fp16, iterations are so fast this doesn't matter\n",
    "]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "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": 10,
   "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": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "=> creating model 'resnet56'\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": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "model = model.cuda()\n",
    "if args.distributed:\n",
    "    model = DDP(model)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "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": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "# %pdb off"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "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",
    "    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": 16,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "8ef69f477beb4d3e8bfed01af143ff51",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "HBox(children=(IntProgress(value=0, description='Epoch', max=95), HTML(value='')))"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epoch      trn_loss   val_loss   accuracy                 \n",
      "    0      1.712447   1.833531   0.3625    \n",
      "    1      1.433379   1.415709   0.4789                   \n",
      "    2      1.201704   1.424798   0.4972                   \n",
      "    3      0.972714   1.293508   0.5532                    \n",
      "    4      0.829375   1.1275     0.6211                    \n",
      "    5      0.737818   0.941539   0.6633                    \n",
      "    6      0.680515   1.368331   0.5989                    \n",
      "    7      0.625079   1.000476   0.6855                    \n",
      "    8      0.595764   0.662818   0.7773                    \n",
      "    9      0.567586   0.796712   0.7294                    \n",
      "    10     0.548227   1.356656   0.5939                    \n",
      "    11     0.521767   1.060895   0.6728                    \n",
      "    12     0.51377    1.026334   0.6631                    \n",
      "    13     0.50963    0.821884   0.7251                    \n",
      "    14     0.492874   0.922375   0.7075                    \n",
      "    15     0.4939     0.816088   0.7313                    \n",
      "    16     0.483837   0.951244   0.6954                    \n",
      "    17     0.481126   0.951192   0.7234                    \n",
      "    18     0.471243   1.044895   0.6829                    \n",
      "    19     0.479861   0.786801   0.7329                    \n",
      "    20     0.473196   1.176684   0.6714                    \n",
      "    21     0.469695   0.833843   0.7295                    \n",
      "    22     0.456229   0.822647   0.7361                    \n",
      "    23     0.445199   0.778761   0.7461                    \n",
      "    24     0.461717   1.086191   0.6666                    \n",
      "    25     0.460023   1.559681   0.5468                    \n",
      "    26     0.452103   1.696995   0.5655                    \n",
      "    27     0.452314   0.845307   0.7279                    \n",
      "    28     0.447684   1.102241   0.6773                    \n",
      "    29     0.453268   1.073324   0.6709                    \n",
      "    30     0.459597   0.686496   0.7768                    \n",
      "    31     0.44934    0.817006   0.7315                    \n",
      "    32     0.445908   1.00723    0.6774                    \n",
      "    33     0.438506   0.855872   0.7369                    \n",
      "    34     0.44574    0.926519   0.6928                    \n",
      "    35     0.453186   1.191345   0.6352                    \n",
      "    36     0.450718   0.971031   0.6936                    \n",
      "    37     0.440717   0.86745    0.7275                    \n",
      "    38     0.45205    0.811038   0.7356                    \n",
      "    39     0.44678    1.821345   0.5422                    \n",
      "    40     0.4475     0.886747   0.7068                    \n",
      "    41     0.441949   1.120203   0.6602                    \n",
      "    42     0.434638   0.744405   0.7521                    \n",
      "    43     0.445848   0.70227    0.7637                    \n",
      "    44     0.434038   1.674703   0.5329                    \n",
      "    45     0.431747   0.862392   0.7256                    \n",
      "    46     0.430517   0.989298   0.7056                    \n",
      "    47     0.428608   0.900466   0.7161                    \n",
      "    48     0.421462   1.153138   0.675                     \n",
      "    49     0.421739   0.778923   0.7423                    \n",
      "    50     0.417046   0.898347   0.7181                    \n",
      "    51     0.408514   0.636402   0.7825                    \n",
      "    52     0.403153   0.786759   0.746                     \n",
      "    53     0.409866   2.007584   0.5319                    \n",
      "    54     0.405054   0.939345   0.6946                    \n",
      "    55     0.412321   0.786656   0.7369                    \n",
      "    56     0.401213   0.872347   0.7239                    \n",
      "    57     0.390832   0.591661   0.7981                    \n",
      "    58     0.404693   0.977544   0.7297                    \n",
      "    59     0.393188   0.682182   0.7757                    \n",
      "    60     0.381091   1.107444   0.6659                    \n",
      "    61     0.378546   0.983134   0.7174                    \n",
      "    62     0.382777   0.864027   0.7124                    \n",
      "    63     0.374313   0.978872   0.7109                    \n",
      "    64     0.380844   0.792173   0.7549                    \n",
      "    65     0.3688     0.84907    0.7273                    \n",
      "    66     0.360642   0.682964   0.7741                    \n",
      "    67     0.364991   0.787294   0.7497                    \n",
      "    68     0.353996   0.789096   0.7522                    \n",
      "    69     0.338802   1.180366   0.6832                    \n",
      "    70     0.346031   0.680226   0.7786                    \n",
      "    71     0.339485   0.812302   0.7579                    \n",
      "    72     0.325312   0.68303    0.7799                    \n",
      "    73     0.324419   0.771803   0.7639                    \n",
      "    74     0.305435   0.677301   0.7826                    \n",
      "    75     0.294144   0.758308   0.7671                    \n",
      "    76     0.29213    0.595579   0.8089                    \n",
      "    77     0.280119   0.617866   0.8016                    \n",
      "    78     0.259278   0.440051   0.8561                    \n",
      "    79     0.253017   0.549194   0.8267                    \n",
      "    80     0.229714   0.560578   0.8329                    \n",
      "    81     0.200325   0.455327   0.852                     \n",
      "    82     0.176231   0.422332   0.8663                    \n",
      "    83     0.171673   0.435318   0.8599                    \n",
      "    84     0.153526   0.48062    0.8537                    \n",
      "    85     0.139808   0.448213   0.8674                    \n",
      "    86     0.127828   0.402531   0.8764                    \n",
      "    87     0.115272   0.424508   0.8755                    \n",
      "    88     0.096057   0.374069   0.8896                     \n",
      "    89     0.074787   0.400309   0.8857                     \n",
      "    90     0.053752   0.343946   0.9019                     \n",
      "    91     0.033928   0.340189   0.9061                     \n",
      "    92     0.021171   0.338068   0.9086                     \n",
      "    93     0.01291    0.323061   0.9113                     \n",
      "    94     0.008438   0.322918   0.912                       \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": "iVBORw0KGgoAAAANSUhEUgAAAtQAAAEKCAYAAAAy8cIyAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDIuMi4yLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvhp/UCwAAIABJREFUeJzs3Xlc1XXa//HXBQgIIogiKqi4gAiIZo7tY2W55IKZNtNd90xNU3e/pmZJK1vcW0ztbpaauadm2ma6p0krcU3NzBZbNAsERURcwBVEQVH26/cHxxluckHl8D0Hrufj8X1wzvd8D+d9FDjX+Z7r8/mIqmKMMcYYY4y5MD5OBzDGGGOMMcabWUFtjDHGGGPMRbCC2hhjjDHGmItgBbUxxhhjjDEXwQpqY4wxxhhjLoIV1MYYY4wxxlwEK6iNMcYYY4y5CFZQG2OMMcYYcxGsoDbGGGOMMeYi+Dkd4Hx16NBBY2JinI5hjDHn7ZtvvilU1QinczQl+5ttjPFmDf277XUFdUxMDBs3bnQ6hjHGnDcR2e10hqZmf7ONMd6soX+3reXDGGOMMcaYi2AFtTHGGGOMMRfBCmpjjDHGGGMughXUxhhjjDHGXAQrqI0xxhhjjLkIbiuoReRVETkkIhlnuF1E5PcikiMi6SIy0F1ZjDHGGGOMcRd3nqF+HRhxlttHArGu7V7gT27MYowxxhhjjFu4bR5qVf1ERGLOckgK8KaqKvCliISJSGdV3e+uTKb5KTxezifZBYwbEIWPjzgdxxjTCNLyjpKef5T/vCLG6SjGmPOQdaCE5emeWcYlR4dxQ0Kk276/kwu7RAF5da7nu/Z9739CRO6l9iw23bp1a5JwxvPV1Ch3vbaBzXuLKa2o5j8v7+50JGNMI/jH13tY+E0+l/VsT1xkiNNxjDENcLy8ip+++jUHS8oRDzy/dftl3ZptQX26f2493YGq+jLwMsCgQYNOe4xped76eg+b9xYD8OzyrQyJjaBb+yCHUxljLtYjI+L5IPMAUxdl8Pa9lyOe+OpsjPk/frs6m0PHynn//iu5pFs7p+M0OSdn+cgHuta5Hg3scyiL8TJ7Dp/g2eVbuSa2A59PuR5fER5emEZNjb3fMsbbhQf788jweL7aWUTqd/ayYIyn23bgGK+t38WPf9C1RRbT4GxBvRj4iWu2j8uBYuufNg1RU6M8vDANXxGeuyWZqLDWTB2dwFc7i3jzi11OxzPGNIIf/aAr/aNDeXr5VkrKKp2OY4w5A1VlamoGIYF+PDw83uk4jnHntHn/AL4A+ohIvojcLSL3ich9rkOWA7lADvAKcL+7spjm5W9f7uarnUVMHZ1Al7DWAEwcFM21fSKY80EWuwpLHU5ojLlYvj7C7HFJFB4v54XV2U7HMcacwfvf7uXrnUU8OiKe8GB/p+M4xm0FtarepqqdVbWVqkar6l9V9X9U9X9ct6uq/kJVe6lqP1Xd6K4spvnYVVjKnBVZXNsngomDov+1X0SYMz6ZVr4+1vphTDORHB3G7Zd14431u9iyr8TpOMaYeopPVvLM8q0M6BrGjwZ1PfcdmjFbKdF4jZoa5ZGF6fj5Cs+O7/e9gUqdQgOZPiaRDbuO8Nr6Xc6ENMY0qsnD+hAW5M+01Ax7o2yMh/nvVdsoKq3gqXFJLX7qWiuojdd4ff0uvt5VxPQxiXQObX3aY24ZGMXQ+I7M/SCL3ILjTZzQGNPYwoL8mTIyno27j/Dupnyn4xhjXDL2FvO3L3dzx+XdSYoKdTqO46ygNl4ht+A4c1dmcX18R24ZGHXG40SEZ8b3I7CVL5MXpFFtZ7SM8XoTBkZzafd2zFmRRfEJG6BojNNqamoHIrYL8mfSjX2cjuMRrKA2Hq+6Rnl4YTr+vj6nbfWoL7JtIDPHJrJpz1H++lluE6U0xriLj48wKyWRIycqmL9qm9NxjGnxFnyTx7d7jvLYTX0JDWrldByPYAW18Xivfb6Tb3YfYWZKIpFtAxt0n5QBXRiWEMn8VdnkHDrm5oTGGHdL7BLKT66I4e9f7WZzfrHTcYxpsY6UVjBnRRY/iGl31k+MWxorqI1Hyzl0nHkrt3FD30jGDWj4L66I8PTN/Qj292XSgnSqqmvcmNIY0xQeGhZH++AAnrQBisY4Zu7KbZSUVTF7XJKtYlqHFdTGY1W7FnBp7e/LM+PP/xc3IiSAmSlJpOUd5ZVPd7oppTGmqbQNbMUTo+JJyzvKPzfmOR3HmBbnu7yjvL1hD3deGUN8p7ZOx/EoVlAbj/WXT3P5ds9RZo5NpGNIw1o96huT3JmRSZ14YXU22Qet9cMYbzduQBSX9QjnuQ+yKCqtcDqOMS1GdY0ydVEGEW0C+PUNsU7H8ThWUBuPtP3gMZ5fnc3wxEjG9u9ywd9HpHa1tTaBfkx6J41Ka/0wxqud+p0+VlbF3A+ynI5jTIvxv1/vYfPeYp4Y1ZeQQBuIWJ8V1MbjVFXXMHlBGsH+vjw17tyzepxLhzYBzE5JYvPeYv68bkcjpTTGOCUuMoSfXRXD2xvy2LTniNNxjGn2Co+XM++DLK7o2f6iTnI1Z1ZQG4/z8qe5pOUXM3tcEhEhAY3yPUcld2Z0cmd+t2Y7W/fbEsamZRORESKyTURyRGTKaW7vLiJrRCRdRD4Wkeh6t7cVkb0i8mLTpf6/fnVDHJFtA5iWmmHzzRvjZnNWZHGysprZ4xJtIOIZWEFtPMq2A8f47ert3NSvE6OTG/dd8KyUJEJbt2LyAmv9MC2XiPgCLwEjgQTgNhFJqHfYfOBNVU0GZgHP1rt9NrDO3VnPpk2AH1NHJ5Cxt4S3vtrtZBRjmrWNu4pY+E0+d1/dk94dQ5yO47GsoDYeo9LV6hES6MfslKRG//7hwf48Na4fmftK+ONaa/0wLdZgIEdVc1W1AngbSKl3TAKwxnV5bd3bReRSIBJY1QRZz2pUv85c3bsD81Zuo/B4udNxjGl2qqpreHJRBl1CA/nl0N5Ox/FoVlAbj/HndTvYvLeYp8Yl0b5N47R61DciqRMpA7rwh4+2k7nPFocwLVIUUHfOuXzXvrrSgFtcl28GQkSkvYj4AM8DD7s9ZQOICDNTEimrrObZ5TZA0ZjG9uYXu8k6cIypoxMI8vdzOo5Hs4LaeISt+0v43ZrtjE7uzMh+nd36WDPGJNIu2J9J76RRUWWtH6bFOV0DZP0m5MnAEBH5FhgC7AWqgPuB5ap61kmgReReEdkoIhsLCgoaI/MZ9Ypowz3X9OTdTfls2FXk1scypiU5VFLGf6/O5odxEYxI6uR0HI9nBbVx3KlWj9DWrZjlhlaP+toF+/PMzf3IOnCMFz/a7vbHM8bD5ANd61yPBvbVPUBV96nqeFW9BHjCta8YuAJ4QER2Udtn/RMRmVP/AVT1ZVUdpKqDIiIi3PQ0/u2B63sTFdaaqYsybFVUYxrJ08u3UlFVw8yxNhCxIaygNo7749odZO4r4alx/QgP9m+Sx7wxIZLxA6N46eMdbM631g/TomwAYkWkh4j4Az8GFtc9QEQ6uNo7AB4DXgVQ1dtVtZuqxlB7FvtNVf3eLCFNLci/doBi1oFjvPGFDVA05mKt31FI6nf7uG9IT3p0CHY6jlewgto4KnNfMX/4aDspA7o0+UdK00cn0qGNP5MWfEd5VXWTPrYxTlHVKuABYCWwFXhHVTNFZJaIjHUddi2wTUSyqR2A+LQjYc/D8MRIru0TwQurszlYUuZ0HGO8VkVVDdNSM+ka3pr7r7OBiA1lBbVxTEVVDZPeSaNdsD8zxiQ2+eOHBrVizvhksg8e5/drrPXDtByqulxV41S1l6o+7do3TVUXuy4vVNVY1zE/V9XvTaGhqq+r6gNNnf1MRIQZYxKpqK7hmeVbnY5jjNd67fOd5Bw6zowxiQS28nU6jtewgto45sW1OWQdOMYzN/ejXRO1etR3XXxHJl4azZ8+3kFa3lFHMhhjGkdMh2DuG9KL1O/2sX5HodNxjPE6+4tP8rs127mhb0eG9o10Oo5XsYLaOCJjbzEvrc1h/CVR3Jjg7C/tk6MTiGwbyKQFaZRVWuuHMd7s/mt70TW8NdNSM20WH2PO0+ylW6iuUaY78Kmxt7OC2jS58qpqJr2TRvtgf4/4pQ1t3Yo5tySTc+g4L3yY7XQcY8xFCGzly4wxieQcOs5rn+90Oo4xXuOT7AKWbz7AA9f1pmt4kNNxvI4V1KbJ/WFNDtsOHmPOLf0IDWrldBwAhsRFcNvgrrzySS7f7D7idBxjzEUY2jeSG/pG8rs129lffNLpOMZ4vPKqaqYvzqRHh2DuHdLT6TheyQpq06TS8o7yp3U7mHBpNNfHe1Z/1uM39aVzaGsettYPY7ze9DEJVNcos5ducTqKMR7v5XW57CwsZebYRAL8bCDihbCC2jSZsspqJi9II6JNAFNHJzgd53tCAlvx3C3J5BaW8vyqbU7HMcZchK7hQTxwXW+Wbz7AJ9nuXa3RGG+WV3SCF9fmcFO/Tvwwzv0LMTVXVlCbJvO7NdvZfuh4batHa89o9ajv6tgO3H5ZN/7y2U422jLGxni1e12LUkxfnGlzzRtzBjOXbMHXR3hylOed6PImVlCbJvHtniP8ed0OfjSoK9f26eh0nLN67Ka+RIW1ZvKCNE5W2IuwMd4qwM+XGWMT2VlYyiuf5DodxxiPs2brQT7cepBfDo2lS1hrp+N4NSuojdudavXo1DaQJ0b3dTrOObUJ8GPuhGR2HT7B3JVZTscxxlyEIXERjEzqxItrc8grOuF0HGM8RlllNTOWZNK7Yxt+dlUPp+N4PSuojdu9sDqbHQWlPDchmbaBntnqUd+VvTrw0yu689rnu/gy97DTcYwxF2Hq6AR8RJhlAxSN+Zc/rs0hr+gks1OS8PezcvBi2b+gcatvdhfx8qe53Da4G9fEetdgh0dHxtMtPIhHFqZzoqLK6TjGmAvUJaw1vxway+otB/ko66DTcYxx3K7CUv5nXS4pA7pwRa/2TsdpFtxaUIvICBHZJiI5IjLlNLd3E5G1IvKtiKSLyE3uzGOaVlllNQ8vSKdLaGueGOX5rR71Bfn7MX9if/KOnOC5Fdb6YYw3+9lVPejdsQ3TF2fatJimRVNVpi/OxN/Phydu8r7XZk/ltoJaRHyBl4CRQAJwm4jUH0L6JPCOql4C/Bj4o7vymKY3f+U2cgtLmTshmTYBfk7HuSCDe4Rz55UxvPHFbtbvKHQ6jjHmAvn7+TArJZG8opP86eMdTscxxjErMw+wLruA39wYR8e2gU7HaTbceYZ6MJCjqrmqWgG8DaTUO0aBtq7LocA+N+YxTWjDriL++vlO7ri8G1f17uB0nIvyyPB4YtrXtn4cL7fWD2O81ZW9OjC2fxf+tG4Huw+XOh3HmCZ3oqKKWUu2EN8phJ9e0d3pOM2KOwvqKCCvzvV81766ZgB3iEg+sBx40I15TBM5WVHNwwvSiAprzWMjvf/jpNb+vsyf2J+9R0/y7PKtTscxxlyEJ0b1xd/Xh+mLM1FVp+MY06R+vyaHfcVlPDUuCT9fG0bXmNz5rymn2Vf/r9dtwOuqGg3cBPxNRL6XSUTuFZGNIrKxoMBWvPJ0c1dmsevwCeZN6E+wl7Z61DcoJpyfX92Dt77aw6fb7WfQGG8V2TaQX98Qy8fbCli1xQYompYj59Ax/vJpLhMujWZQTLjTcZoddxbU+UDXOtej+X5Lx93AOwCq+gUQCHyvP0BVX1bVQao6KCLCu2aKaGm+zD3Ma5/v4qdXdG92I4cnDetDz4hgHl2YzrGySqfjGGMu0J1XxhDfKYRZS7bYDD6mRVBVpqVmEuTvy5SR8U7HaZbcWVBvAGJFpIeI+FM76HBxvWP2AEMBRKQvtQW1nf7zUicqqnhkYTrdwoN4tBn+wga2qm39OFBSxjPW+mGM1/Lz9WFWShJ7j57kxY9ynI5jjNstSd/P+h2HeXh4Hzq0CXA6TrPktoJaVauAB4CVwFZqZ/PIFJFZIjLWddgk4B4RSQP+Adyp1tTmtZ5bkUXekRPMn9ifIP/m0epR38Bu7bjnhz35x9d5rMu2937GeKvBPcIZPzCKVz7NZUfBcafjGOM2x8oqeWrpFvpFhfIfl9lARHdxa0e6qi5X1ThV7aWqT7v2TVPVxa7LW1T1KlXtr6oDVHWVO/MY91m/o5A3vtjNnVfGMLhH8+7N+s0NcfTu2IZHF6ZTfNJaP4zxVo+N7EtgK1+mp9oARdN8/fbD7RQcL2f2uCR8fU43vM00BhviaS5aaXltq0dM+yAeGd78Wj3qC2zly/MT+1NwvJynbCljY7xWREgAk4f14bOcQpZt3u90HGMaXdaBEl5fv4sf/6AbA7qGOR2nWbOC2ly0Z1dsZe/Rk8yf2J/W/r5Ox2kS/buGcd+Qniz4Jt+WMjbGi91xeXcSu7Rl9tItNs+8aVZUlamLMmgb6Mcjw/s4HafZs4LaXJTPthfy9y/3cPdVPVrcNDy/HBpLn8gQpry7meIT1vphjDfy9RFmj0viYEk5v1+z3ek4xjSa9zbtZcOuIzw6Ip52wf5Ox2n2rKA2F+xYWSWPvptOzw7BTG6B734D/Hx5/tb+HC6tYObSTKfjGGMu0MBu7fjRoK68+tlOsg8eczqOMRet+GQlz67YyiXdwrh1UNdz38FcNCuozQV7ZnkW+4tPMv/W/gS2ahmtHvUlRYXyi2t78d6mvay2RSKM8VqPjoynTaAfUxdl2ABF4/WeX7WNotIKZqck4WMDEZuEFdTmgnySXcA/vt7DPdf0ZGC3dk7HcdQD18cS3ymEx9/fzJHSCqfjGGMuQHiwP48Mj+ernUWkfld/DTJjvEfG3mL+/uVu/vPy7iRFhTodp8WwgtqctxJXq0eviGB+c2Oc03Ec5+/nw/O39udIaQUzlljrhzHe6kc/6Er/6FCeWraVElsN1XihmhrlyUUZhAcH8NCwlteK6SQrqM15e3rpVg6WlPH8rQNabKtHfYldQnnw+lhSv9vHBxk2/ZYx3ujUAMXDpeW8sDrb6TjGnLd3NubxXd5RHr8pntDWrZyO06JYQW3Oy9pth/jnxjz+a0gvm9Oynvuv60Vil7Y8uSiDImv9MMYrJUeHcftl3Xhj/S627CtxOo4xDXaktILnPshicEw4N18S5XScFscKatNgxScrmfJuOnGRbfj1DbFOx/E4rXxrWz+KT1YyLTXD6TjGmAs0eVgfwoL8mZqaQU2NDVA03mHuyixKyqqYNS4RERuI2NSsoDYNNnvpFgqPVzB/Yn8C/KzV43TiO7XlV0NjWZq+n2Xp1vphjDcKC/Jnysh4vtl9hHc35Tsdx5hz+nbPEd7ekMddV8YQ36mt03FaJCuoTYOs2XqQhd/k8/+G9CI52lo9zua+Ib3oFxXK1NQMCo+XOx3HmO8RkREisk1EckRkymlu7y4ia0QkXUQ+FpFo1/4BIvKFiGS6bvtR06dvGhMGRnNp93bMWZFlCzcZj1Zdo0xNzaBjSAC/tokCHGMFtTmn4hOVPPbeZuI7hfDg0N5Ox/F4fq7Wj+NlVTanrfE4IuILvASMBBKA20Qkod5h84E3VTUZmAU869p/AviJqiYCI4DfikizfIft4yPMSknkyIkK5q3KcjqOMWf01le7ydhbwpOjEmgT4Od0nBbLCmpzTjOXZFJUaq0e5yMuMoTf3BjHiowDLLHWD+NZBgM5qpqrqhXA20BKvWMSgDWuy2tP3a6q2aq63XV5H3AIiGiS1A5I7BLKT66I4a2v9rA5v9jpOMZ8T+Hxcuat3MZVvdszOrmz03FaNCuozVmtyjzAe9/u5f7retsE8efpnmt6MKBrGNNSMzh0rMzpOMacEgXk1bme79pXVxpwi+vyzUCIiLSve4CIDAb8gR1uyukRHhoWR/vgAJ60AYrGAz27PIuyympmjk2ygYgOs4LanNGR0goefz+Dvp3b8sB11upxvvx8fZg/sT8nKqp54n1r/TAe43SvuvV/OCcDQ0TkW2AIsBeo+tc3EOkM/A24S1VrvvcAIveKyEYR2VhQUNB4yR3QNrAVT4yKJy3vKG9vyDv3HYxpIht2FfHupnx+fk1Pends43ScFs8KanNGM5ZkcvREBc9P7I+/n/2oXIjeHdsweVgcq7cctOWMjafIB7rWuR4N/J8fTlXdp6rjVfUS4AnXvmIAEWkLLAOeVNUvT/cAqvqyqg5S1UEREd7fETJuQBSX9Qhn7sosm2PeeISq6hqmLsogKqw1D15vJ7w8gVVJ5rQ+yNhP6nf7ePD6WBK62BQ8F+Puq3sysFsY0xdncrDEWj+M4zYAsSLSQ0T8gR8Di+seICIdROTU68NjwKuu/f7A+9QOWFzQhJkdJVK7guKxsirmfmADFI3zXl+/i6wDx5g6OoEgfxuI6AmsoDbfU1RawZOLMkjs0pb7r+vldByv5+sjzJ/Yn7LKah5/b7O1fhhHqWoV8ACwEtgKvKOqmSIyS0TGug67FtgmItlAJPC0a/+twA+BO0XkO9c2oGmfgTPiIkP42VUxvL0hj017jjgdx7RgB0vK+O2H27m2TwTDEyOdjmNcrKA23zMtNYPik5U8f2t/Wvnaj0hj6BnRhkdGxLMm6xDvbtrrdBzTwqnqclWNU9Veqvq0a980VV3surxQVWNdx/xcVctd+/+uqq1UdUCd7Tsnn0tT+tUNcUS2DWDqogyqbYCiccjTy7ZSUV3DjDG2IqInsWrJ/B/L0vezNH0/vxoaa6stNbK7roxhcEw4M5dksr/4pNNxjDHnqU2AH1NHJ5C5r4S3vtrtdBzTAq3PKWRx2j7uG9KLmA7BTscxdVhBbf6l8Hg5U1Mz6BcVyn1DrNWjsfn4CHMnJFNVrUx511o/jPFGo/p15ureHZi3chsFx2wlVNN0KqpqmJqaQdfw1tx/rb1GexorqA0AqsrURRkcL6vi+Vv742etHm4R0yGYR0f0YV12AQs25jsdxxhznkSEmSmJlFVWM2eFDVA0Teevn+1kR0EpM8cmEtjKFlnzNA2umkTEPltoxpam72dFxgF+fWMscZEhTsdp1n5yRQyX9Qhn9tIt7D1qrR/GeJteEW2455qevLspnw27ipyOY1qAvUdP8vs127kxIZLr420goic6Z0EtIleKyBZqR4MjIv1F5I9uT2aaTMGxcqalZtC/axj3XtPT6TjNno+PMG9Cf6pVmfJuurV+GOOFHri+N1FhrZm6KIOq6u+tbWNMo3pq6RYUZdroBKejmDNoyBnqF4DhwGEAVU2jdtok0wyoKk8u2kxpRTXPT0y2Vo8m0q19EI/d1JdPtxfyj69t9TVjvE2Qf+0AxawDx3jjCxugaNxnXXYBKzIO8MB1vekaHuR0HHMGDaqeVLX+K361G7IYByxO28fKzINMujGO3h2t1aMp3T64G1f1bs/Ty7aQV3TC6TjGmPM0PDGSa/tE8MLqbFu0ybhFWWU101Mz6NkhmHt+aJ8ge7KGFNR5InIloCLiLyKTcbV/GO92qKSMaamZXNItjJ9bq0eT8/ERnrslGYBH302nxua1NcariAgzxiRSUV3D08vsZdE0vpc/yWXX4RPMTEkkwM8GInqyhhTU9wG/AKKAfGAAcL87Qxn3U1Uef38zZZXVzJ/YH18fmxzeCdHtgnhiVALrdxzmra/3OB3HeBkRGSQi74vIJhFJF5HNIpLudK6WJKZDMPcN6cXitH2s31HodBzTjOQVneCltTmM6teZa2IjnI5jzqEhBXUfVb1dVSNVtaOq3gH0dXcw417vf7uXD7ce4uHhfegV0cbpOC3abYO7ck1sB55dvpU9h631w5yXt4DXgFuAMcBo11fThO6/thddw1szLTWTiioboGgax4zFmfj6CE+OtpLLGzSkoP5DA/cZL3GwpIwZizMZ1L0dd13Vw+k4LZ5IbeuHrwgPL0yz1g9zPgpUdbGq7lTV3ac2p0O1NIGtfJkxJpGcQ8d59fOdTscxzcCHWw6yJusQvxoaS+fQ1k7HMQ1wxoJaRK4QkUlAhIg8VGebATSokUdERojINhHJEZEpZzjmVhHZIiKZIvK/F/QsTIOpKo+9t5mK6hrmWauHx+gS1pqpoxP4amcRb36xy+k4xntMF5G/iMhtIjL+1OZ0qJZoaN9Ibugbye/XbGefzS9vLsLJimpmLMkktmMbfna1nfTyFmc7Q+0PtAH8gJA6Wwkw4VzfWER8gZeAkUACcJuIJNQ7JhZ4DLhKVROBX1/AczDnYeE3+XyUdYhHhsfTo4Ot1eNJJg6K5to+Ecz5IItdhaVOxzHe4S5qx7WMoLbV41Tbh3HA9DEJVNcoTy3b4nQU48X++HEO+UdOMisliVY2la3X8DvTDaq6DlgnIq9f4EeIg4EcVc0FEJG3gRSg7l+ae4CXVPWI6zEPXcDjmAbaX3ySWUu2MDgmnDuvjHE6jqlHRJgzPpkbX1jHwwvT+Oe9V+BjnyCYs+uvqv2cDmFqdQ0P4oHrevP86mw+yS7gh3E2kMycn52Fpfx5XS7jBnThil7tnY5jzkND3vqcEJF5IrJcRD46tTXgflFA3fmr81376ooD4kTkcxH5UkRGnO4bici9IrJRRDYWFBQ04KFNfarKlHc3U1WjzJuYbIWah+oUGsj0MYls2HWE19bvcjqO8Xxf1v/kzzjr3iE96dEhmOmLMymvsiUbTMOpKtNSMwjw8+HxUTYQ0ds0pKB+C8gCegAzgV3Ahgbc73QVW/3RVn5ALHAtcBvwFxEJ+96dVF9W1UGqOigiwt7xX4h3NuaxLruAKSPj6d7eWj082S0Doxga35G5H2SRW3Dc6TjGs10NfOcaq2LT5nmAAD9fZoxNZGdhKa98kut0HONFVmQc4NPthTw0LI6OIYFOxzHnqSEFdXtV/StQqarrVPVnwOUNuF8+0LXO9Whg32mOSVXVSlXdCWyjtsA2jWjv0ZPMXrqVy3uG85+Xd3c6jjkHEeGZ8f0IbOXL5AVpVNusH+bMRlD7N3MYNm2exxgSF8HIpE68uDbHVkE1DVJaXsXspVvo27mtvU57qYYU1JWur/tFZJSIXEJtcXwuG4BYEekhIv7Aj4HF9Y5ZBFwHICIdqG0Bsbf0jai21SOdGlXmTehvrR5eIrLGaTonAAAgAElEQVRtIDPHJrJpz1H++pn9Spgz0jNsxmFTRyfgI8KspTZA0Zzb7z/azv7iMp4al4ifDUT0Sg35X3tKREKBScBk4C/Ab851J1WtAh4AVlK7VPk7qpopIrNEZKzrsJXAYRHZAqwFHlbVwxfwPMwZ/OPrPD7dXshjN/Wla3iQ03HMeUgZ0IVhCZHMX5VNzqFjTscxnmkZsNT1dQ21JyRWOJrIALVTYf5yaCyrtxzko6yDTscxHmz7wWP89dOdTLw0mku7hzsdx1ygsxbUrqnvYlW1WFUzVPU6Vb1UVeufaT4tVV2uqnGq2ktVn3btm3bq/lrrIVVNUNV+qvr2RT8j8y95RSd4etkWrurdntsHd3M6jjlPIsLTN/cj2N+XSQvSqaq2FdjM/+X6u5ns+hpL7exKnzmdy9T62VU96N2xDdMXZ1JWaQMUzfepKlNTMwgO8GPKyHin45iLcNaCWlWrgbFnO8Z4ppoa5dF3a8cmPXeLzerhrSJCApiZkkRa3lFe+dRWYDNnp6qbgB84ncPU8vfzYVZKInlFJ/nTxzucjmM80OK0fXyZW8TDw/vQvk2A03HMRTjjPNR1rBeRF4F/Av9abcL1h9t4qLe+3sP6HYd55uZ+RLezVg9vNia5Mys27+eF1dkM7duRuMgQpyMZDyEiD9W56gMMBGxuUQ9yZa8OjO3fhT+t28H4gVE2y5L5l2NllTy1bCvJ0aHcZp8ie72G9FBfCSQCs4DnXdt8d4YyFyev6ATPLt/KNbEduG1w13PfwXg0EWH2uCTaBPox6Z00Kq31w/xb3VVsA6jtpU5xNJH5nidG9cXf14fpizNRtTGjptYLq7dTeLyc2SlJ+NqnyF7vnGeoVfW6pghiGkdNjfLwwjR8RXjulmRE7Je0OejQJoDZKUn84n838ed1O3jgeptd0gCwRVUX1N0hIhOBBWc43jggsm0gv74hlqeWbWXVloMMT+zkdCTjsK37S3jji13cNrgb/bt+b/kN44VsbpZm5m9f7ubL3CKeHN2XLmGtnY5jGtGo5M6MTu7M79ZsZ+v+EqfjGM/wWAP3GYfdeWUM8Z1CmLVkCycqqpyOYxxUU6NMXZRBaOtWPDK8j9NxTCOxgroZ2X24lDkrshgSF8Gtg6zVozmalZJEaOtWTF5grR8tmYiMFJE/AFEi8vs62+uAVWseyM/Xh1kpSew9epIXP8pxOo5x0Lub8tm4+whTRsQTFuTvdBzTSKygbiZqapSHF6Tj5yvMuaWftXo0U+HB/jw1rh+Z+0r441qbNaAF2wdsBMqAb+psi4HhDuYyZzG4RzjjB0bxyqe57Cg47nQc44DiE5XMWZHFwG5hTLi0IWvkGW9xzh5qERl/mt3FwGZVPdT4kcyFeH39Lr7eVcS8Ccl0DrVWj+ZsRFInUgZ04Q8fbeeGhI4kdgl1OpJpYqqaBqSJyP+qauU572A8xmMj+7J6y0Gmp2byt7sH28mPFmb+qm0cOVHBm3cPtulsm5mGnKG+m9rVEW93ba8ADwGfi8h/ujGbaaCdhaXMXZnF9fEd7R1vCzFjTCLtgv2Z9E4aFVXW+tGCDRaR1SKSLSK5IrJTRGyteg8WERLA5GF9+CynkGWb9zsdxzShzfnF/P2r3fzkihg7EdIMNaSgrgH6quotqnoLkACUA5cBj7oznDm36hrl4QVp+Pv68Ox4a/VoKdoF+/PMzf3IOnCMFz/a7nQc45y/Av8NXE3tgi6DsIVdPN4dl3cnsUtbZi/dwvFya3lvCWpqlCdTM2gfHMBDw+KcjmPcoCEFdYyqHqxz/RAQp6pFgH3U6LDXPt/Jxt1HmDE2kci2gU7HMU3oxoRIxg+M4qWPd7A5v9jpOMYZxaq6QlUPqerhU9u57iQiI0Rkm4jkiMiU09zeXUTWiEi6iHwsItF1bvupiGx3bT9t7CfUEvj61M4tf7CknN+vsTfELcHbG/JIyzvKE6PiaRvYyuk4xg0aUlB/KiJLXX9EfwqkAp+ISDBw1L3xzNnsKDjOvJXbuKFvJDdfEuV0HOOA6aMT6dDGn0kLvqO8qtrpOKbprRWReSJyhYgMPLWd7Q4i4gu8BIyk9hPH20Qkod5h84E3VTWZ2kW9nnXdNxyYTu0nlIOB6SLSrnGfUsswsFs7fjSoK69+tpPsg8ecjmPcqKi0grkrs7isRzjjBthrdXPVkIL6F8DrwADgEuBN4BeqWmqLvjinukaZvCCN1v6+PDM+yVo9WqjQoFbMGZ9M9sHj/O5DO9PVAl1GbZvHMzR8JdvBQI6q5qpqBfA2319dMQFY47q8ts7tw4HVqlqkqkeA1cCIi34WLdSjI+NpE+jH1EUZtoJiM/bciiyOlVUxe5y9VjdnDVkpUYGFrs14iL98msu3e47yux8PoGOItXq0ZNfFd2TipdH8z7odDE/sZKtutSAXeFIjCsircz2f2sK8rjTgFuB3wM1AiIi0P8N97ZTbBQoP9ueR4fE8/v5mUr/bxzj7pLHZ2bTnCP/cmMc91/QgLjLE6TjGjc55hlpExrt65YpFpEREjomILdPmoJxDx3h+dTbDEyMZ27+L03GMB3hydAKRbQOZtCCNskpr/WgpRCRSRP4qIitc1xNE5O5z3e00++qfHp0MDBGRb4EhwF5qF4xpyH0RkXtFZKOIbCwoKDjn82jJfvSDrvSPDuWpZVspKbNhSc1JtWtFxMi2AfzqBhuI2Nw1pOVjLjBWVUNVta2qhqhqW3cHM6dXVV3DpAXpBPv78tQ4m9XD1Apt3Yo5tySTc+g4L3yY7XQc03ReB1YCp95ZZwO/Psd98oG6S6lGU7tQzL+o6j5VHa+qlwBPuPYVN+S+rmNfVtVBqjooIiKi4c+mBTo1QPFwaTkvrLbf3ebk71/uJnNfCVNHJ9Am4JwNAcbLNaSgPqiqW92exDTIy5/mkpZ3lFkpSUSEBDgdx3iQIXER3Da4K698kss3u484Hcc0jQ6q+g6105uiqlXAuT6i2ADEikgPEfEHfkztCov/IiIdROTU68NjwKuuyyuBYSLSzjUYcZhrn7kIydFh3H5ZN95Yv4st++wD4Oag4Fg581dt4+reHRjVr7PTcUwTaEhBvVFE/ikit7naP8afYfVE42bbDhzjt6u3c1O/ToxOtl9Q832P39SXzqGtedhaP1qKUldvswKIyOXUrmR7Rq6i+wFqC+GtwDuqmikis0RkrOuwa4FtIpINRAJPu+5bBMymtijfAMxy7TMXafKwPoQF+TM1NYOaGhug6O2eXb6VsspqZqYk2ifJLURDCuq2wAlqz0SMcW2j3RnKfF9ldQ2TF6QREujH7BQbKWxOLySwFc/dkkxuYSnzV25zOo5xv4eoPbvcS0Q+p3YWpgfPdSdVXa6qcaraS1VPFcvTVHWx6/JCVY11HfNzVS2vc99XVbW3a3vNPU+r5QkL8mfKyHi+2X2EhZvynY5jLsJXuYd579u93HNNT3pFtHE6jmkiDZnl466mCGLO7s/rdrB5bzF/vH0g7dtYq4c5s6tjO3D7Zd346+c7GZHUiUEx4U5HMm6iqptEZAjQh9oBg9tU1Ua2eakJA6P554Y85qzIYnhCJ0KDbAEQb1NZXcO01EyiwlrzwPW9nY5jmtAZz1CLyCOur38Qkd/X35ouotm6v4TfrdnO6OTO3GS9WKYBHrupL1FhrZm8II2TFdb60Vy5Fmm5CRhK7aeID4rIQ86mMhfKx0eYlZLI0RMVzFuV5XQccwHeWL+LbQePMW1MAkH+NhCxJTlby8epgYgbgW9Os5kmcKrVI7R1K2alJDkdx3iJNgF+zJ2QzK7DJ5i70l6Ym7ElwJ1AeyCkzma8VGKXUH5yRQxvfbWH9HxbjNibHCgu44XV2VzXJ4JhCZFOxzFN7Ixvn1R1ievrG00Xx9T3x7U7yNxXwv/ccSnhwf5OxzFe5MpeHfjpFd157fNdDE/sxOU92zsdyTS+aNfy4KYZeWhYHEvT9zN1UQbv338VPj42ZsYbPLVsC5U1yoyxNhCxJWrIwi5xIvKyiKwSkY9ObU0RrqXL3FfMHz7aTsqALoxI6uR0HOOFHh0ZT7fwIB5ZmE5peZXTcUzjWyEiw5wOYRpX28BWPDEqnrT8Yt7ekHfuOxjHfZ5TyNL0/dx/bS+6tw92Oo5xQENm+VgAfAs8CTxcZzNuVFFVw6R30mgX7M+MMYlOxzFeKsjfj3kTktlTdILnPrDWj2boS+B9ETlpK9k2L+MGRHFZj3DmrsyiqLTC6TjmLCqqapiamkG38CDuG9LL6TjGIQ0pqKtU9U+q+rWqfnNqc3uyFu7FtTlkHTjGMzf3o521epiLcFnP9tx1VQxvfrGb9TsKnY5jGtfzwBVAkK1k27yI1K6geKysirn2Ztij/eWzXHILSpk5NpHAVr5OxzEOaUhBvURE7heRziISfmpze7IWLGNvMS+tzWH8JVHcaAMbTCN4ZHg8Me1rWz+OW+tHc7IdyFBVWwmkGYqLDOFnV8Xw9oY8Nu2x1U890d6jJ/nDmhyGJURyXXxHp+MYBzWkoP4ptS0e6/n3DB8b3RmqJSuvqmbSO2m0D/ZnurV6mEbS2t+X+RP7s/foSZ5dvvXcdzDeYj/wsYg8JiIPndqcDmUaz69uiCOybQBTF2VQbSsoepxZSzJRlGljEpyOYhx21oJaRHyAO1S1R72tZxPla3H+sCaHbQePMeeWfjapv2lUg2LC+fnVPXjrqz18ur3A6TimcewE1gD+2LR5zVKbAD+mjk4gc18Jb3212+k4po612w6xMvMgD14fS3S7IKfjGIedddZxVa0RkfnU9ugZN0vLO8qf1u1gwqXRXB9vrR6m8U0a1oc1WYd4dGE6K3/zQ0IC7U2bN1PVmQAiElJ7VY87HMm4wah+nXm7dx7zVm5jZFJnIkJstVynlVVWM2NxJj07BPPza3o4Hcd4gIa0fKwSkVvkAiZVFJERIrJNRHJEZMpZjpsgIioig873MZqLsspqJi9II6JNAFNH20dHxj0CW9W2fhwoKePpZdb64e1EJElEvgUygEwR+UZErFesmRERZqYkUlZZzbMr7PfWE/x5XS67D59gVkoSAX42ENE0rKB+iNqp88rPZ1om15K4LwEjgQTgNhH5XqXoOrPyS+Cr80rezPxuzXa2HzrOs7f0I7S1nTU07jOwWzvu+WFP3t6Qx7psa/3wci8DD6lqd1XtDkwCXnE4k3GDXhFtuOeanry3aS9f7yxyOk6LtufwCf74cQ6jkjtzdWwHp+MYD3HOgto1DZOPqvqf57RMg4EcVc1V1QrgbSDlNMfNBuYCZeeVvBn5ds8R/rxuBz8a1JXr+tgoYeN+v7khjt4d2/DownSKT1Y6HcdcuGBVXXvqiqp+DNiqEs3UA9f3JiqsNdNSM6iqrnE6ToukqsxYkomfjzB1lH2abP6tIWeoEZF2IjJYRH54amvA3aKAuks85bv21f2+lwBdVXVpgxM3M6daPTq1DeSJ0X2djmNaiMBWvjw/sT8Fx8t5aukWp+OYC5crIlNFJMa1PUntQEXTDAX51w5QzDpwjNfX73I6Tou0estBPso6xK9viKNTaKDTcYwHacjS4z8HPgFWAjNdX2c04Hufruf6X3P+uGYQeYHajyjPleFeEdkoIhsLCprXR9QvrM5mR0Epc25Jpq0NEDNNqH/XMO4b0pMF3+TzUdZBp+OYC/MzIAJ4F3gP6ADc6WQg417DEyO5tk8Ev/1wOwdLWuwHu444WVHNzCVbiItsw51XxTgdx3iYhpyh/hXwA2C3ql4HXAI0pKrNB7rWuR4N7KtzPQRIonYO1V3A5cDi0w1MVNWXVXWQqg6KiIhowEN7h292F/Hyp7ncNrgbP4xrPs/LeI9fDo2lT2QIU97dTPEJa/3wQr2o/TvrA7QChlJ7AsQ0UyLCjDGJVFTX2MDiJvbS2hz2Hj3JrJQkWvk26AN+04I05CeiTFXLAEQkQFWzgD4NuN8GIFZEeoiIP/BjYPGpG1W1WFU7qGqMqsYAXwJjVbVFLBpTVlnNwwvS6RLamidGWauHcUaAX+2sH4dLK5i5JNPpOOb8vQW8CowHRru2MY4mMm4X0yGY+4b0YnHaPtbnFDodp0XILTjOy5/kcvMlUVzes73TcYwHakhBnS8iYcAiYLWIpPJ/zzSflqpWAQ9Q2yKyFXhHVTNFZJaIjL2Y0M3B/JXbyC0sZe6EZNoEnHU6cGPcql90KL+4thfvfbuX1Vus9cPLFKjqElXdqaq7T21OhzLud/+1vega3pppizOpqLIBiu6kqkxfnEmAnw+P3RTvdBzjoc5Zyanqza6LM0RkLRAKfNCQb66qy4Hl9fZNO8Ox1zbkezYHG3YV8dfPd3LH5d24qrdNuWOc98D1sazacpDH39/MoO7taBfs73Qk0zDTReQv1K6WWH5qp6q+51wk0xQCW/kyY0wid7+xkVc/38l9Q3o5HanZWr75AJ9uL2TGmAQ6hthARHN6DZ3l42oRuUtV1wFfUG+2DtNwJyuqeXhBGlFhrXlspLV6GM/g7+fD87f250hpBTOs9cOb3AUMAEZQ2+oxhtq2D9MCDO0byQ19I/ndh9vZd/Sk03GapePlVcxeuoWEzm254/LuTscxHqwhs3xMBx4FHnPtagX83Z2hmrO5K7PYdfgE8yb0J9haPYwHSewSyoPXx5L63T4+yNjvdBzTMP1dA7Z/qqp3ubafOR3KNJ3pYxKoUeWpZTb9pTv8fs12DpSUMXtcEn42ENGcRUN+Om4GxgKlAKq6j9oZOsx5+jL3MK99voufXtGdK3rZoAbjee6/rheJXdryxPsZHD5efu47GKd9eboVaE3L0TU8iAeu683yzQf4xFY+bVTZB4/x6mc7uXVQNJd2b+d0HOPhGlJQV6iq4ppDWkRsFa4LcKKiikcWptMtPIhHR9qgBuOZWvnWtn6UlFUybbG1fniBq4HvRGSbiKSLyGYRSXc6lGla9w7pSY8OwUxfnEl5VbXTcZoFVWXqogyCA/x4dIS9Zptza0hB/Y6I/BkIE5F7gA+BV9wbq/l5bkUWe4pOMG9CMkH+1uphPFd8p7b8amgsy9L3syzdWj883AggFhjGv/unbdq8FibAz5cZYxPZWVjKK5/kOh2nWUj9bh9f7SzikRF9aN8mwOk4xgucs6BW1fnAQmpX4uoDTFPVP7g7WHOyfkchb3yxm7uuiuEym7/SeIH7hvSiX1QoU1MzKLTWD49Vd6o8mzavZRsSF8HIpE68uDaHvKITTsfxaiVllTy1bCv9o0P58Q+6OR3HeIkGddir6mpVfVhVJ6vqaneHak5Ky2tbPWLaB/HIcPvYyHgHP1frx/GyKqYuyqC268sY48mmjk7AR4SZS2yA4sX471XZHC4tZ/a4JHx9xOk4xkucsaAWkWMiUnKa7ZiIlDRlSG/27Iqt7D16kvkT+9Pa39fpOMY0WFxkCL+5MY4VGQdYYq0fxni8LmGt+eXQWD7cepA1W22RpguxZV8Jb36xi/8Y3I3k6DCn4xgvcsaCWlVDVLXtabYQVW3blCG91WfbC/n7l3u4+6oeDIoJdzqOMeftnmt6MKBrGNNSMzh0rMzpOMaYc/jZVT3o3bENM5ZkUlZpAxTPR02NMjU1g7Agfx4e3sfpOMbL2KSKbnKsrJJH302nZ4dgJtsvpvFSfr4+zJ/YnxMV1TzxvrV+GOPp/P18mJWSSF7RSf748Q6n43iVhZvy+Wb3EaaMjCcsyFaLNefHCmo3eWZ5FvuLTzJvYn8CW1mrh/FevTu2YfKwOFZvOUjqd/ucjmOMOYcre3VgbP8u/M+6HewqLHU6jlc4eqKCOSuyuLR7OyYMjHY6jvFCVlC7wSfZBfzj6z3cc01PmwzeNAt3X92Tgd3CmL44k4Ml1vrh7URkhGvu6hwRmXKa27uJyFoR+dY1v/VNrv2tROQN13zXW0Xkse9/d+MJnhjVF39fH2YsybRPlhpg3sptHD1RweyUJHxsIKK5AFZQN7ISV6tHr4hgfnNjnNNxjGkUvj7C/In9Kaus5vH3NtsLtBcTEV/gJWAkkADcdprVFp8E3lHVS4AfA3907Z8IBKhqP+BS4L9EJKYpcpvzE9k2kF/fEMvH2wpYmWkDFM8mLe8o//v1Hn56ZQwJXWyImLkwVlA3sqeXbuVgSRnP3zrAWj1Ms9Izog2PjIhnTdYh3t201+k45sINBnJUNVdVK4C3gZR6xyhwqrIIBfbV2R8sIn5Aa6ACsFmfPNSdV8YQ3ymE2Uu3cKKiyuk4HqnaNRCxQ5sAOwlmLooV1I1o7bZD/HNjHv81pBcDutp0O6b5uevKGAbHhDNzSSb7i086HcdcmCggr871fNe+umYAd4hIPrAceNC1fyFQCuwH9gDzVbXIrWnNBfPz9WFWShJ7j57kxY9ynI7jkd7esIf0/GKeuKkvbQNbOR3HeDErqBtJ8clKprybTlxkG359Q6zTcYxxCx8fYe6EZCqra5jyrrV+eKnTNYjW/4+8DXhdVaOBm4C/iYgPtWe3q4EuQA9gkoj0/N4DiNwrIhtFZGNBQUHjpjfnZXCPcMYPjOKVT3PJOXTc6Tge5fDxcuZ+sI3Le4aTMqCL03GMl7OCupHMXrqFwuMVzJ/YnwA/a/UwzVdMh2CmjIhnXXYB72zMO/cdjKfJB7rWuR7Nv1s6TrkbeAdAVb8AAoEOwH8AH6hqpaoeAj4HBtV/AFV9WVUHqeqgiIgINzwFcz4eG9mXwFa+zFhsAxTreu6DLErLq5idkoSIDUQ0F8cK6kawZutBFn6Tz/8b0stWVjItwk+uiOGyHuE8tbR2JVDjVTYAsSLSQ0T8qR10uLjeMXuAoQAi0pfagrrAtf96qRUMXA5kNVlyc0EiQgKYPKwPn+UUsmyzrXoK8M3uIt7ZmM/dV/cgNjLE6TimGbCC+iIVn6jksfc2E98phAeH9nY6jjFNwsdHmDehP9WqTHk33c56eRFVrQIeAFYCW6mdzSNTRGaJyFjXYZOAe0QkDfgHcKfW/ie/BLQBMqgtzF9T1fQmfxLmvN1xeXcSu7Rl9tItHC9v2QMUq6preHJRJp3aBvLLodaiaRqHFdQXaeaSTA6XWquHaXm6tQ/isZv68un2Qv7xtbV+eBNVXa6qcaraS1Wfdu2bpqqLXZe3qOpVqtpfVQeo6irX/uOqOlFVE1U1QVXnOfk8TMP5+gizxyVxsKSc36/Z7nQcR/39y91s3V/C1NEJBAf4OR3HNBNWUF+EVZkHeO/bvfziut4kRYU6HceYJnf74G5c1bs9Ty/bQl7RCafjGGPOYmC3dvxoUFde/Wwn2QePOR3HEYeOlfH8qmyuie3ATf06OR3HNCNWUF+gI6UVPP5+Bn07t+WB66zVw7RMPj7Cc7ckA/Dou+nU1FjrhzGe7NGR8bQJ9OPJRRktslXr2eVZlFfVMHNsog1ENI3KCuoLNGNJJkdPVDB/YjL+fvbPaFqu6HZBPDEqgfU7DvPWV7udjmOMOYvwYH8eGR7P1zuLSP2u/uQuzduXuYd5/9u93PvDnvSMaON0HNPMWCV4AT7I2E/qd/t48PpYErtYq4cxtw3uyjWxHXh2RRZ7DlvrhzGe7Ec/6Er/6FCeWraVkrJKp+M0icrqGqalZhAV1ppf2KfKxg2soD5PRaUVPLkog8Qubbn/ul5OxzHGI4jUtn74ivDwwjRr/TDGg50aoHi4tJz/XpXtdJwm8frnu8g+eJzpYxJo7W8TCJjGZwX1eZqWmkHxyUqev7U/rXztn8+YU7qEtWbq6AS+2lnEm1/scjqOMeYskqPDuP2ybrz5xS627CtxOo5bHSgu47cfZnN9fEduTIh0Oo5ppqwiPA/L0vezNH0/vxoaS3yntk7HMcbjTBwUzbV9IpjzQRa7CkudjmOMOYvJw/oQFuTP1NSMZv2p0uxlW6iqUWaMsYGIxn2soG6gwuPlTE3NoF9UKPcNsVYPY05HRJgzPplWvj5MXpBGdTN+kTbG24UF+TNlZDzf7D7Cwk35Tsdxi8+2F7IsfT/3X9ubbu2DnI5jmjErqBtAVZm6KIPjZVU8f2t//KzVw5gz6hQayPQxiWzcfYTXPt/pdBxjzFlMGBjNpd3bMWdFFsUnmtcAxfKqaqalZtC9fRD/NaSn03FMM2eVYQMsTd/PiowD/PrGWOIiQ5yOY4zHu2VgFEPjOzJv5TZyC447HccYcwY+PsKslESOnqhg3qosp+M0qr98upPcwlJmjk0ksJUNRDTuZQX1ORQcK2daagb9u4Zx7zX2DteYhhARnhnfj8BWvtb6YYyHS+wSyk+uiOGtr/aQnn/U6TiNIv/ICf7w0XaGJ0ZybZ+OTscxLYBbC2oRGSEi20QkR0SmnOb2h0Rki4iki8gaEenuzjznS1V5ctFmSiuqeX5isrV6GHMeItsGMnNsIpv2HOWvn+U6HccYcxYPDYujfXAAUxc1jwGKs5ZsQRCmjUl0OoppIdxWIYqIL/ASMBJIAG4TkYR6h30LDFLVZGAhMNddeS7E4rR9rMw8yKQb4+jd0Vo9jDlfKQO6MCwhkvmrssk5dMzpOMaYM2gb2IonRsWTll/M2xvynI5zUdZmHWLVloM8OLQ3UWGtnY5jWgh3nnIdDOSoaq6qVgBvAyl1D1DVtap6alm1L4FoN+Y5L4dKypiWmskl3cL4ubV6GHNBRISnbk4iyN+XSQvSqaqucTqSMeYMxg2I4rIe4cxdmUVRaYXTcS5IWWU10xdn0isimJ9fba/dpum4s6COAuq+zc137TuTu4EVbszTYKrK4+9vpqyymvkT++PrY/NWGnOhOoYEMislibS8o7z8qbV+GOOpRGpXUDxWVsXcD7xzgOKfPt7BnqITzEpJwt/P2jRN03HnT9vpqtDTNmaJyB3AIGDeGW6/V0Q2isjGgoKCRox4eu9/u5cPtx7i4eF96BXRxu2PZ0xzNya5MyOTOohIjv4AABbfSURBVPHb1dvJPmitH8Z4qrjIEH52VQxvb8hj054jTsc5L7sPl/KndTsYndyZq3p3cDqOaWHcWVDnA13rXI8G9tU/SERuAJ4Axqpq+em+kaq+rKqDVHVQRESEW8KecrCkjBmLMxn0/9u78/iqynvf458fGQhjAIPIPCgYCKAiUJwYhKooGgv2ihdPpe2ptT22B6tSPA5QqEeUXqn3aO2ham29DlWwGgGloAyOIChTGCODzKPMMuZ3/9iLGnOChiQ7a2ft7/v12q+s4dlr/Z6svZ/8stbzrNWyPj+8pHVc9yWSLE6e+aqdkcqdLy/imLp+iCSsf+/XjkZ1YwMUq8odetydkXn5pFUz7rum+HAtkfiLZ0L9MdDWzFqbWTowGMgrWsDMLgD+m1gyvT2OsZSKu3PPq0s4eqKQcerqIVKhsmpXZ0xuR5Zs2st/z/4s7HBE5BRqV0/l/gEdyN+8j+fnrg87nFL5x7JtzFq5gzu+246zMjPCDkeSUNwSanc/DtwOTAOWAy+7e76ZjTaz64Ji44DawCtmttDM8k6xuUoxccFG3lmxneFXZtM6q1aYoYhE0jWdGzOgc2Mee3s1y7fsCzscETmFazo15tJzshg3bSU79pd48ThhHDp6nNFvLOPcRnW45eJWYYcjSSquPfbdfaq7t3P3s939wWDZA+6eF0z3c/dG7n5+8Lrum7cYP1v2fsnoN5bRvVUDhuoLKRI3o3M7klkjTV0/RBKYmfGb3BwOHzvBQ28uDzucb/T4OwVs2vMlY67vSJqeFyEh0SePWFePEZOWcLzQGff9zlRTVw+RuGlQK53fXt+JZVv28cTMgrDDEZFTOLthbX5yWRte/WQT89buDjucEhVsP8Cf3l3DwC5N6d66QdjhSBJTQg28PH8Ds1ftYET/bFqeoa4eIvF2VcezyD2/CY+/U0D+5r1hhyMip3D75bGHozzw+tKEu4+8uzMqL5+MtBTu6d8+7HAkySV9Qr1pz5eMmbycHm0a8C89EurJ5yKRNuraHOrXSufOlxdx9Hhi/aEWkZia6bEBiiu27ufZD9aFHc7XTFmyhfcKdnLXFefSsE71sMORJJfUCXWsq8diCt0Zd8N56uohUonq10rnP7/XiRVb9/P4O6vDDkdETuHKnEb0Prchv5+xmm37DocdDgAHjhxnzORl5DSpy806GSYJIKkT6hfnbeDd1Tu55+r2NG9QM+xwRJLOdzs0YmCXpjwx6zOWbFTXD5FEZGaMujaHoycKeXBKYgxQfGzGKrbtO8KY6zvqFreSEJI2od6w+xAPTlnGJeecwZDuLcIORyRpjRyQQ1btdO58ZSFHjp8IOxwRKUGrrFrc1uts8hZt5oOCnaHGsnLrfp55fx2DuzWnS4v6ocYiclJSJtSFhc6vJy0G4OFBuquHSJgya6bx0MBOrNp2gMdmqOuHSKL6ee+zad6gBg/k5Yc27sHduf/1pdTJSGX4VdmhxCBSkqRMqJ+f9zkffLaLe6/pQLP66uohErbLsxvx/Qub8cfZn7Fow56wwxGREmSkpTDq2hwKth/gmffXhhLDawtjt/AbfmU2DWqlhxKDSEmSLqHesPsQD01dzmVts7ipe/OwwxGRwH0DOtCobgZ3vrKIw8fU9UMkEfVt34h+7Rvx2IzVbN7zZaXue++Xx3hwygrOa16Pwd3091sSS1Il1IWFzt0TF1HNjLGDOmOmrh4iiSKzRhpjB3WmYPsBxs9YFXY4InIKI6/tQKE7v52yrFL3O376KnYdPMJvczuqq6YknKRKqJ/7aD0frdnN/QPa07RejbDDEZFierVryE3dm/OnOWtYsP6LsMOJLDO7ysxWmlmBmY0oYX0LM5tpZp+a2WIzu7rIus5m9qGZ5ZvZEjPLqNzoJWzNG9Tk9j7nMHXJVuas2lEp+1y6aS9//XAdN3+nJZ2aZVbKPkVOR9Ik1Ot3HWTsmyvo1a4h/6urLhWJJKr/uLo9jTNrcLe6fsSFmaUATwD9gQ7ATWbWoVix+4CX3f0CYDDwh+C9qcD/A25z9xygN3CskkKXBHJrrza0zqrFyLz8uN+dp7AwNhCxfs107rri3LjuS6SskiKhLix07n5lMakpxthBndTVQySB1clI4+FBnVmz8yC/m7Yy7HCiqDtQ4O5r3P0o8BKQW6yMA3WD6UxgczB9BbDY3RcBuPsud9d/PUmoemoKo67LYe3Og0yYvSau+3plwQY+/XwPI/pnk1kzLa77EimrpEion/1gHfPW7eaBAR1onKmuHiKJ7tK2WQz5Tguefn8tH63ZFXY4UdMU2FBkfmOwrKhRwM1mthGYCvwiWN4OcDObZmafmNnweAcriatXu4b073gWj88sYMPuQ3HZx55DRxn75gq6tqzPoC7N4rIPkYoQ+YT62IlCnv1gHZdnn8kNF+rLKFJV3HN1e5rVr8GQp+by64mL2VTJdxSIsJIu0Xmx+ZuAZ929GXA18JyZVQNSgUuBIcHP75lZ3/+xA7NbzWy+mc3fsaNy+thKOO4f0IGUasZv3ojPAMVHpq1k3+HjjLleAxElsUU+oU5LqUbe7ZfwsO7qIVKl1K6eyt9/fgk/uKglf/90E33GzWLk60vZvu9w2KFVdRuBogNJmvFVl46Tfgy8DODuHwIZQFbw3tnuvtPdDxE7e92l+A7cfYK7d3X3rg0bNoxDFSRRNKlXg1/2bcuM5dt4e/m2Ct32og17eHHe59xyUSvaN6777W8QCVHkE2qAejXTaVinethhiMhpyqpdnZHX5jDr7t4MurAZz8/9nJ7jZvLQ1OV8cfBo2OFVVR8Dbc2stZmlExt0mFeszOdAXwAza08sod4BTAM6m1nNYIBiL6By750mCedHl7TmnDNrM+qN/AobSHyi0LnvtaVk1a7OHd9tWyHbFImnpEioRaRqa1KvBg8N7MTbd/bi6o6NmfDuGi57ZCaPTl/FvsO6ycTpcPfjwO3EkuPlxO7mkW9mo83suqDYncBPzGwR8CIw1GO+AB4llpQvBD5x9ymVXwtJJOmp1Ridm8OG3V/yh1mfVcg2X5j3OUs27eW+a9pTJ0MDESXxmXvxrnOJrWvXrj5//vywwxCREK3etp/xM1YxdclWMmuk8dNebRh6cStqpqeGHdo3MrMF7t417Dgqk9rs5PHLFz/lrfyt/GNYT1pl1SrzdnYdOEKf380ip0kmL/zkO+quKaEqbbutM9QiUuW0bVSHPwy5kMm/uJQLW9bnkbdW0vORmTzz3lrdu1okJPde0570lGqMeiOf8pysG/vmCg4dPcHo3Bwl01JlKKEWkSqrY9NMnhnajUk/u5hzz6rD6MnL6D1uFs/PXc+xE4VhhyeSVBrVzWBYv7bMWrmDafllG6A4f91uXlmwkR9f1pq2jepUcIQi8aOEWkSqvAtb1uf5f+3BCz/5Dk3qZXDv35fS9//MZtKCjZworFrd2kSqsqEXtyL7rDqMfiOfQ0ePn9Z7j58o5L7XltI4M4NfXq6BiFK1KKEWkci4+OwsJv3sYv48tBt1MlK585VFXDF+NlMWb6FQibVI3KWmVGN0bkc27z3M4+8UnNZ7//rhelZs3c8DAzpQq3pij4cQKU4JtYhEipnRJ/tMJv/iUp4c0oVqZvzbC58w4L/e4+3l28rVt1NEvl331g0Y2KUpf3p3DQXbD5TqPdv3HebR6au4rG0WV3U8K84RilQ8JdQiEklmRv9OjXlrWE/G33geB48e58d/mc/AJz/g/YKdYYcnEmn39G9PRloKI/OWluqf2P+cupyjxwsZndtRAxGlSlJCLSKRllLN+N4FzZjxq148NLATW/ceZshTc7lpwkcsWL877PBEIqlhnercdcW5vF+wiylLtnxj2Q8/28VrCzfz015taF2O2+2JhEkJtYgkhbSUatzUvQUz7+rNqGs7sHr7AQY9+SFD/zyPpZv2hh2eSOTc3KMlOU3qMmbyMg4cKXmA4rEThTzw+lKa1a/Bz3ufU8kRilQcJdQiklQy0lIYeklr5gzvzYj+2SzcsIcB//Uetz23gFXb9ocdnkhkpFQzxlzfkW37jvDYjFUllnnmvbWs3n6AUdfmUCM9pZIjFKk4SqhFJCnVTE/ltl5nM2d4H4b1a8t7BTu58vdzGPbSp6zbeTDs8EQioUuL+tzYtTnPvL+OlVu//g/rlr1f8tjbq+nX/kz6dWgUUoQiFUMJtYgktboZaQzr1453h/fhpz3P5q38rfR9dDYjJi1m054vww5PpMr7df9s6mSkcv/rXx+gOGbyMk4UOiOvzQkxOpGKEdeE2syuMrOVZlZgZiNKWF/dzP4WrJ9rZq3iGY+IyKnUr5XOiP7ZzBneh3/p0ZJXP9lEn3GzGJWXz/b9h8MOT6TKalArneFXZjNv7W5eW7gJgDmrdjB1yVb+rc85NG9QM+QIRcovbgm1maUATwD9gQ7ATWbWoVixHwNfuPs5wHjg4XjFIyJSGmfWyWDUdTnMurs3gy5synMfrafnIzN56M3lfHHwaNjhiVRJN3ZrznnNMnlwygp2HjjCyLx8Wp1Rk1t7tgk7NJEKEc8z1N2BAndf4+5HgZeA3GJlcoG/BNMTgb6mG1CKSAJoUq8GDw3szNu/6kX/jo2ZMGcNlz0yk/HTV7Hv8LGwwxOpUk4OUNx18AhdfzuDtTsP8pvcjmSkaSCiREM8E+qmwIYi8xuDZSWWcffjwF7gjDjGJCJyWlpl1WL8jefzj2E9uaxtFo+9vZrLHp7J9GXbwg5NpErp3Kweg7u1AODy7DPp1a5hyBGJVJzUOG67pDPNxR+XVJoymNmtwK0ALVq0KH9kIiKnqW2jOjx584Us3bSX8dNX0TpL/T5FTteI/tnUq5nGDy9uFXYoIhUqngn1RqB5kflmwOZTlNloZqlAJvA/Hl3m7hOACQBdu3b99meYiojEScemmTw9tFvYYYhUSZk10vj1VdlhhyFS4eLZ5eNjoK2ZtTazdGAwkFesTB5wSzB9A/COF72njoiIiIhIgovbGWp3P25mtwPTgBTgGXfPN7PRwHx3zwOeBp4zswJiZ6YHxyseEREREZF4iGeXD9x9KjC12LIHikwfBr4fzxhEREREROJJT0oUERERESkHJdQiIiIiIuWghFpEREREpByUUIuIiIiIlIMSahERERGRcrCqdttnM9sBrC/DW7OAnRUcTqJKprpCctU3meoK0atvS3dPquctq80utWSqr+oaXVGsb6na7SqXUJeVmc13965hx1EZkqmukFz1Taa6QvLVV76SbMc+meqrukZXstW3KHX5EBEREREpByXUIiIiIiLlkEwJ9YSwA6hEyVRXSK76JlNdIfnqK19JtmOfTPVVXaMr2er7T0nTh1pEREREJB6S6Qy1iIiIiEiFi3xCbWZXmdlKMyswsxFhx1NWZtbczGaa2XIzyzezfw+WNzCz6Wa2OvhZP1huZvZ/g3ovNrMuRbZ1S1B+tZndEladvo2ZpZjZp2Y2OZhvbWZzg7j/ZmbpwfLqwXxBsL5VkW3cEyxfaWZXhlOTb2Zm9cxsopmtCI7vRRE/rncEn+GlZvaimWVE9dhK2USh3VabHd02G5Kr3VabXUruHtkXkAJ8BrQB0oFFQIew4ypjXRoDXYLpOsAqoAPwCDAiWD4CeDiYvhp4EzCgBzA3WN4AWBP8rB9M1w+7fqeo86+AF4DJwfzLwOBg+o/Az4LpnwN/DKYHA38LpjsEx7w60Dr4LKSEXa8S6vkX4F+D6XSgXlSPK9AUWAvUKHJMh0b12OpVps9IJNpttdnRbbODWJOi3VabXfpX1M9QdwcK3H2Nux8FXgJyQ46pTNx9i7t/EkzvB5YT+6DnEvtiE/y8PpjOBf7qMR8B9cysMXAlMN3dd7v7F8B04KpKrEqpmFkz4BrgqWDegMuBiUGR4nU9+TuYCPQNyucCL7n7EXdfCxQQ+0wkDDOrC/QEngZw96PuvoeIHtdAKlDDzFKBmsAWInhspcwi0W6rzY5mmw1J2W6rzS6FqCfUTYENReY3BsuqtOASygXAXKCRu2+BWAMOnBkUO1Xdq8rv5PfAcKAwmD8D2OPux4P5onH/s07B+r1B+apQ1zbADuDPwaXSp8ysFhE9ru6+Cfgd8DmxRnkvsIBoHlspm8gdW7XZQLS+10nTbqvNLr2oJ9RWwrIqfVsTM6sNTAKGufu+bypawjL/huUJw8wGANvdfUHRxSUU9W9Zl/B1JfaffxfgSXe/ADhI7FLhqVTluhL0KcwldsmvCVAL6F9C0SgcWymbSB1btdlfE5XvddK022qzSy/qCfVGoHmR+WbA5pBiKTczSyPWMD/v7q8Gi7cFl44Ifm4Plp+q7lXhd3IJcJ2ZrSN2ufdyYmc/6gWXnODrcf+zTsH6TGA3VaOuG4GN7j43mJ9IrKGO4nEF6Aesdfcd7n4MeBW4mGgeWymbyBxbtdmR/V4nU7utNruUop5Qfwy0DUajphPrIJ8XckxlEvRBehpY7u6PFlmVB5wcGXwL8HqR5T8IRhf3APYGl6CmAVeYWf3gP88rgmUJw93vcfdm7t6K2DF7x92HADOBG4Jixet68ndwQ1Deg+WDg1HHrYG2wLxKqkapuPtWYIOZnRss6gssI4LHNfA50MPMagaf6ZP1jdyxlTKLRLutNjuabTYkXbutNru0KnqUY6K9iI2uXUVsROm9YcdTjnpcSuzyyGJgYfC6mljfpLeB1cHPBkF5A54I6r0E6FpkWz8iNiCgAPhh2HX7lnr35qsR422IfQELgFeA6sHyjGC+IFjfpsj77w1+ByuB/mHX5xR1PB+YHxzb14iN9o7scQV+A6wAlgLPERv1Hcljq1eZPyNVvt1Wmx3dNjuIM2nabbXZpXvpSYkiIiIiIuUQ9S4fIiIiIiJxpYRaRERERKQclFCLiIiIiJSDEmoRERERkXJQQi0iIiIiUg5KqKVKMrMPgp+tzOx/V/C2/6OkfYmISNmozZao023zpEozs97AXe4+4DTek+LuJ75h/QF3r10R8YmIyFfUZktU6Qy1VElmdiCYHAtcZmYLzewOM0sxs3Fm9rGZLTaznwble5vZTDN7gdiN9TGz18xsgZnlm9mtwbKxQI1ge88X3VfwlKtxZrbUzJaY2Y1Ftj3LzCaa2Qozez54ohRmNtbMlgWx/K4yf0ciIolCbbZEXeq3FxFJaCMocrYjaGT3uns3M6sOvG9m/wjKdgc6uvvaYP5H7r7bzGoAH5vZJHcfYWa3u/v5JexrILGnY50HZAXvmROsuwDIATYD7wOXmNky4HtAtru7mdWr8NqLiFQtarMlknSGWqLmCuAHZrYQmEvsUbBtg3XzijTMAL80s0XAR0DzIuVO5VLgRXc/4e7bgNlAtyLb3ujuhcQeMdwK2AccBp4ys4HAoXLXTkQkWtRmSyQooZaoMeAX7n5+8Grt7ifPdhz8Z6FYP75+wEXufh7wKZBRim2fypEi0yeAVHc/TuwMyyTgeuCt06qJiEj0qc2WSFBCLVXdfqBOkflpwM/MLA3AzNqZWa0S3pcJfOHuh8wsG+hRZN2xk+8vZg5wY9DnryHQE5h3qsDMrDaQ6e5TgWHELj2KiCQztdkSSepDLVXdYuB4cBnwWeAxYpfuPgkGmewgdqahuLeA28xsMbCS2CXEkyYAi83sE3cfUmT534GLgEWAA8PdfWvQuJekDvC6mWUQO1NyR9mqKCISGWqzJZJ02zwRERERkXJQlw8RERERkXJQQi0iIiIiUg5KqEVEREREykEJtYiIiIhIOSihFhEREREpByXUIiIiIiLloIRaRERERKQclFCLiIiIiJTD/wfEHXI59qDrEwAAAABJRU5ErkJggg==\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": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "learner.save('cifar10-wd4e4-lr1')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "cfcb452e653f4e7489e2939c6a4a0e6f",
       "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": [
      " 81%|████████  | 79/98 [00:06<00:01, 12.36it/s, loss=0.0398] \n",
      "                                                            \r"
     ]
    }
   ],
   "source": [
    "learner.lr_find()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "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": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "dbed3f506e8245bda149bd62be36ed77",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "HBox(children=(IntProgress(value=0, description='Epoch', max=15), HTML(value='')))"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epoch      trn_loss   val_loss   accuracy                    \n",
      "    0      0.006505   0.322454   0.911     \n",
      "    1      0.006266   0.323212   0.9128                      \n",
      "    2      0.007029   0.323482   0.9125                      \n",
      "    3      0.006095   0.321533   0.9118                      \n",
      "    4      0.005952   0.323129   0.9117                      \n",
      "    5      0.005498   0.322257   0.9112                      \n",
      "    6      0.005841   0.323728   0.9117                      \n",
      "    7      0.005956   0.322007   0.9119                      \n",
      "    8      0.006588   0.321131   0.9119                      \n",
      " 64%|██████▍   | 63/98 [00:05<00:02, 12.17it/s, loss=0.00652]"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Process Process-1468:\n",
      "Process Process-1465:\n",
      "Process Process-1467:\n",
      "Process Process-1470:\n",
      "Process Process-1469:\n",
      "Process Process-1464:\n",
      "Process Process-1466:\n",
      "Traceback (most recent call last):\n",
      "Traceback (most recent call last):\n",
      "Traceback (most recent call last):\n",
      "Traceback (most recent call last):\n",
      "  File \"/home/paperspace/anaconda3/envs/fastai/lib/python3.6/multiprocessing/process.py\", line 258, in _bootstrap\n",
      "    self.run()\n",
      "Traceback (most recent call last):\n",
      "  File \"/home/paperspace/anaconda3/envs/fastai/lib/python3.6/multiprocessing/process.py\", line 258, in _bootstrap\n",
      "    self.run()\n",
      "  File \"/home/paperspace/anaconda3/envs/fastai/lib/python3.6/multiprocessing/process.py\", line 258, in _bootstrap\n",
      "    self.run()\n",
      "Traceback (most recent call last):\n",
      "  File \"/home/paperspace/anaconda3/envs/fastai/lib/python3.6/multiprocessing/process.py\", line 93, in run\n",
      "    self._target(*self._args, **self._kwargs)\n",
      "  File \"/home/paperspace/anaconda3/envs/fastai/lib/python3.6/multiprocessing/process.py\", line 258, in _bootstrap\n",
      "    self.run()\n",
      "  File \"/home/paperspace/anaconda3/envs/fastai/lib/python3.6/multiprocessing/process.py\", line 258, in _bootstrap\n",
      "    self.run()\n",
      "  File \"/home/paperspace/anaconda3/envs/fastai/lib/python3.6/multiprocessing/process.py\", line 258, in _bootstrap\n",
      "    self.run()\n",
      "  File \"/home/paperspace/anaconda3/envs/fastai/lib/python3.6/site-packages/torch/utils/data/dataloader.py\", line 50, in _worker_loop\n",
      "    r = index_queue.get()\n",
      "  File \"/home/paperspace/anaconda3/envs/fastai/lib/python3.6/multiprocessing/process.py\", line 93, in run\n",
      "    self._target(*self._args, **self._kwargs)\n",
      "  File \"/home/paperspace/anaconda3/envs/fastai/lib/python3.6/multiprocessing/process.py\", line 93, in run\n",
      "    self._target(*self._args, **self._kwargs)\n",
      "  File \"/home/paperspace/anaconda3/envs/fastai/lib/python3.6/multiprocessing/process.py\", line 93, in run\n",
      "    self._target(*self._args, **self._kwargs)\n",
      "  File \"/home/paperspace/anaconda3/envs/fastai/lib/python3.6/multiprocessing/queues.py\", line 334, in get\n",
      "    with self._rlock:\n",
      "  File \"/home/paperspace/anaconda3/envs/fastai/lib/python3.6/multiprocessing/process.py\", line 93, in run\n",
      "    self._target(*self._args, **self._kwargs)\n",
      "Traceback (most recent call last):\n",
      "  File \"/home/paperspace/anaconda3/envs/fastai/lib/python3.6/site-packages/torch/utils/data/dataloader.py\", line 50, in _worker_loop\n",
      "    r = index_queue.get()\n",
      "  File \"/home/paperspace/anaconda3/envs/fastai/lib/python3.6/multiprocessing/process.py\", line 93, in run\n",
      "    self._target(*self._args, **self._kwargs)\n",
      "  File \"/home/paperspace/anaconda3/envs/fastai/lib/python3.6/multiprocessing/synchronize.py\", line 96, in __enter__\n",
      "    return self._semlock.__enter__()\n",
      "  File \"/home/paperspace/anaconda3/envs/fastai/lib/python3.6/site-packages/torch/utils/data/dataloader.py\", line 55, in _worker_loop\n",
      "    samples = collate_fn([dataset[i] for i in batch_indices])\n",
      "  File \"/home/paperspace/anaconda3/envs/fastai/lib/python3.6/site-packages/torch/utils/data/dataloader.py\", line 55, in _worker_loop\n",
      "    samples = collate_fn([dataset[i] for i in batch_indices])\n",
      "  File \"/home/paperspace/anaconda3/envs/fastai/lib/python3.6/site-packages/torch/utils/data/dataloader.py\", line 50, in _worker_loop\n",
      "    r = index_queue.get()\n",
      "  File \"/home/paperspace/anaconda3/envs/fastai/lib/python3.6/multiprocessing/process.py\", line 258, in _bootstrap\n",
      "    self.run()\n",
      "  File \"/home/paperspace/anaconda3/envs/fastai/lib/python3.6/multiprocessing/queues.py\", line 334, in get\n",
      "    with self._rlock:\n",
      "  File \"/home/paperspace/anaconda3/envs/fastai/lib/python3.6/site-packages/torch/utils/data/dataloader.py\", line 50, in _worker_loop\n",
      "    r = index_queue.get()\n",
      "KeyboardInterrupt\n",
      "  File \"/home/paperspace/anaconda3/envs/fastai/lib/python3.6/site-packages/torch/utils/data/dataloader.py\", line 55, in <listcomp>\n",
      "    samples = collate_fn([dataset[i] for i in batch_indices])\n",
      "  File \"/home/paperspace/anaconda3/envs/fastai/lib/python3.6/site-packages/torch/utils/data/dataloader.py\", line 55, in <listcomp>\n",
      "    samples = collate_fn([dataset[i] for i in batch_indices])\n",
      "  File \"/home/paperspace/anaconda3/envs/fastai/lib/python3.6/multiprocessing/process.py\", line 93, in run\n",
      "    self._target(*self._args, **self._kwargs)\n",
      "  File \"/home/paperspace/anaconda3/envs/fastai/lib/python3.6/multiprocessing/queues.py\", line 334, in get\n",
      "    with self._rlock:\n",
      "  File \"/home/paperspace/anaconda3/envs/fastai/lib/python3.6/multiprocessing/synchronize.py\", line 96, in __enter__\n",
      "    return self._semlock.__enter__()\n",
      "  File \"/home/paperspace/anaconda3/envs/fastai/lib/python3.6/multiprocessing/queues.py\", line 335, in get\n",
      "    res = self._reader.recv_bytes()\n",
      "  File \"/home/paperspace/anaconda3/envs/fastai/lib/python3.6/site-packages/torchvision/datasets/folder.py\", line 124, in __getitem__\n",
      "    img = self.transform(img)\n",
      "  File \"/home/paperspace/anaconda3/envs/fastai/lib/python3.6/site-packages/torchvision/datasets/folder.py\", line 124, in __getitem__\n",
      "    img = self.transform(img)\n",
      "  File \"/home/paperspace/anaconda3/envs/fastai/lib/python3.6/multiprocessing/synchronize.py\", line 96, in __enter__\n",
      "    return self._semlock.__enter__()\n",
      "KeyboardInterrupt\n",
      "  File \"/home/paperspace/anaconda3/envs/fastai/lib/python3.6/site-packages/torch/utils/data/dataloader.py\", line 50, in _worker_loop\n",
      "    r = index_queue.get()\n",
      "KeyboardInterrupt\n",
      "  File \"/home/paperspace/anaconda3/envs/fastai/lib/python3.6/site-packages/torchvision/transforms/transforms.py\", line 42, in __call__\n",
      "    img = t(img)\n",
      "  File \"/home/paperspace/anaconda3/envs/fastai/lib/python3.6/site-packages/torchvision/transforms/transforms.py\", line 42, in __call__\n",
      "    img = t(img)\n",
      "KeyboardInterrupt\n",
      "  File \"/home/paperspace/anaconda3/envs/fastai/lib/python3.6/site-packages/torchvision/transforms/transforms.py\", line 61, in __call__\n",
      "    return F.to_tensor(pic)\n",
      "  File \"/home/paperspace/anaconda3/envs/fastai/lib/python3.6/multiprocessing/queues.py\", line 334, in get\n",
      "    with self._rlock:\n",
      "  File \"/home/paperspace/anaconda3/envs/fastai/lib/python3.6/site-packages/torchvision/transforms/transforms.py\", line 61, in __call__\n",
      "    return F.to_tensor(pic)\n",
      "  File \"/home/paperspace/anaconda3/envs/fastai/lib/python3.6/site-packages/torchvision/transforms/functional.py\", line 71, in to_tensor\n",
      "    img = img.view(pic.size[1], pic.size[0], nchannel)\n",
      "  File \"/home/paperspace/anaconda3/envs/fastai/lib/python3.6/site-packages/torchvision/transforms/functional.py\", line 63, in to_tensor\n",
      "    img = torch.ByteTensor(torch.ByteStorage.from_buffer(pic.tobytes()))\n",
      "  File \"/home/paperspace/anaconda3/envs/fastai/lib/python3.6/multiprocessing/synchronize.py\", line 96, in __enter__\n",
      "    return self._semlock.__enter__()\n",
      "  File \"/home/paperspace/anaconda3/envs/fastai/lib/python3.6/site-packages/PIL/Image.py\", line 721, in tobytes\n",
      "    e = _getencoder(self.mode, encoder_name, args)\n",
      "ERROR:root:Internal Python error in the inspect module.\n",
      "Below is the traceback from this internal error.\n",
      "\n",
      "KeyboardInterrupt\n",
      "  File \"/home/paperspace/anaconda3/envs/fastai/lib/python3.6/site-packages/PIL/Image.py\", line 453, in _getencoder\n",
      "    encoder = getattr(core, encoder_name + \"_encoder\")\n",
      "KeyboardInterrupt\n",
      "  File \"/home/paperspace/anaconda3/envs/fastai/lib/python3.6/multiprocessing/connection.py\", line 216, in recv_bytes\n",
      "    buf = self._recv_bytes(maxlength)\n",
      "  File \"/home/paperspace/anaconda3/envs/fastai/lib/python3.6/multiprocessing/connection.py\", line 407, in _recv_bytes\n",
      "    buf = self._recv(4)\n",
      "  File \"/home/paperspace/anaconda3/envs/fastai/lib/python3.6/multiprocessing/connection.py\", line 379, in _recv\n",
      "    chunk = read(handle, remaining)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Traceback (most recent call last):\n",
      "  File \"/home/paperspace/anaconda3/envs/fastai/lib/python3.6/site-packages/IPython/core/interactiveshell.py\", line 2963, in run_code\n",
      "    exec(code_obj, self.user_global_ns, self.user_ns)\n",
      "  File \"<ipython-input-20-c99c0c2bcae9>\", line 5, in <module>\n",
      "    **sargs\n",
      "  File \"/home/paperspace/anaconda3/envs/fastai/lib/python3.6/site-packages/fastai/learner.py\", line 251, in fit\n",
      "    return self.fit_gen(self.model, self.data, layer_opt, n_cycle, **kwargs)\n",
      "  File \"/home/paperspace/anaconda3/envs/fastai/lib/python3.6/site-packages/fastai/learner.py\", line 198, in fit_gen\n",
      "    metrics=metrics, callbacks=callbacks, reg_fn=self.reg_fn, clip=self.clip, fp16=self.fp16, **kwargs)\n",
      "  File \"/home/paperspace/anaconda3/envs/fastai/lib/python3.6/site-packages/fastai/model.py\", line 115, in fit\n",
      "    loss = stepper.step(V(x),V(y), epoch)\n",
      "  File \"/home/paperspace/anaconda3/envs/fastai/lib/python3.6/site-packages/fastai/model.py\", line 47, in step\n",
      "    output = self.m(*xs)\n",
      "  File \"/home/paperspace/anaconda3/envs/fastai/lib/python3.6/site-packages/torch/nn/modules/module.py\", line 357, in __call__\n",
      "    result = self.forward(*input, **kwargs)\n",
      "  File \"/home/paperspace/anaconda3/envs/fastai/lib/python3.6/site-packages/fastai/fp16.py\", line 11, in forward\n",
      "    return self.module(input.half())\n",
      "  File \"/home/paperspace/anaconda3/envs/fastai/lib/python3.6/site-packages/torch/nn/modules/module.py\", line 357, in __call__\n",
      "    result = self.forward(*input, **kwargs)\n",
      "  File \"/home/paperspace/imagenet-fast/cifar10/models/cifar10/clr_resnet.py\", line 48, in forward\n",
      "    out = self.layer2(out)\n",
      "  File \"/home/paperspace/anaconda3/envs/fastai/lib/python3.6/site-packages/torch/nn/modules/module.py\", line 357, in __call__\n",
      "    result = self.forward(*input, **kwargs)\n",
      "  File \"/home/paperspace/anaconda3/envs/fastai/lib/python3.6/site-packages/torch/nn/modules/container.py\", line 67, in forward\n",
      "    input = module(input)\n",
      "  File \"/home/paperspace/anaconda3/envs/fastai/lib/python3.6/site-packages/torch/nn/modules/module.py\", line 357, in __call__\n",
      "    result = self.forward(*input, **kwargs)\n",
      "  File \"/home/paperspace/imagenet-fast/cifar10/models/cifar10/clr_resnet.py\", line 24, in forward\n",
      "    out = self.bn2(self.conv2(F.relu(self.bn1(out))))\n",
      "  File \"/home/paperspace/anaconda3/envs/fastai/lib/python3.6/site-packages/torch/nn/functional.py\", line 583, in relu\n",
      "    return threshold(input, 0, 0, inplace)\n",
      "KeyboardInterrupt\n",
      "\n",
      "During handling of the above exception, another exception occurred:\n",
      "\n",
      "Traceback (most recent call last):\n",
      "  File \"/home/paperspace/anaconda3/envs/fastai/lib/python3.6/site-packages/IPython/core/interactiveshell.py\", line 1863, in showtraceback\n",
      "    stb = value._render_traceback_()\n",
      "AttributeError: 'KeyboardInterrupt' object has no attribute '_render_traceback_'\n",
      "\n",
      "During handling of the above exception, another exception occurred:\n",
      "\n",
      "Traceback (most recent call last):\n",
      "  File \"/home/paperspace/anaconda3/envs/fastai/lib/python3.6/site-packages/IPython/core/ultratb.py\", line 1095, in get_records\n",
      "    return _fixed_getinnerframes(etb, number_of_lines_of_context, tb_offset)\n",
      "  File \"/home/paperspace/anaconda3/envs/fastai/lib/python3.6/site-packages/IPython/core/ultratb.py\", line 311, in wrapped\n",
      "    return f(*args, **kwargs)\n",
      "  File \"/home/paperspace/anaconda3/envs/fastai/lib/python3.6/site-packages/IPython/core/ultratb.py\", line 345, in _fixed_getinnerframes\n",
      "    records = fix_frame_records_filenames(inspect.getinnerframes(etb, context))\n",
      "  File \"/home/paperspace/anaconda3/envs/fastai/lib/python3.6/inspect.py\", line 1483, in getinnerframes\n",
      "    frameinfo = (tb.tb_frame,) + getframeinfo(tb, context)\n",
      "  File \"/home/paperspace/anaconda3/envs/fastai/lib/python3.6/inspect.py\", line 1441, in getframeinfo\n",
      "    filename = getsourcefile(frame) or getfile(frame)\n",
      "  File \"/home/paperspace/anaconda3/envs/fastai/lib/python3.6/inspect.py\", line 696, in getsourcefile\n",
      "    if getattr(getmodule(object, filename), '__loader__', None) is not None:\n",
      "  File \"/home/paperspace/anaconda3/envs/fastai/lib/python3.6/inspect.py\", line 742, in getmodule\n",
      "    os.path.realpath(f)] = module.__name__\n",
      "  File \"/home/paperspace/anaconda3/envs/fastai/lib/python3.6/posixpath.py\", line 388, in realpath\n",
      "    path, ok = _joinrealpath(filename[:0], filename, {})\n",
      "  File \"/home/paperspace/anaconda3/envs/fastai/lib/python3.6/posixpath.py\", line 422, in _joinrealpath\n",
      "    if not islink(newpath):\n",
      "  File \"/home/paperspace/anaconda3/envs/fastai/lib/python3.6/posixpath.py\", line 171, in islink\n",
      "    st = os.lstat(path)\n",
      "  File \"/home/paperspace/anaconda3/envs/fastai/lib/python3.6/site-packages/torch/utils/data/dataloader.py\", line 175, in handler\n",
      "    _error_if_any_worker_fails()\n",
      "RuntimeError: DataLoader worker (pid 17315) exited unexpectedly with exit code 1.\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "KeyboardInterrupt\n"
     ]
    },
    {
     "ename": "KeyboardInterrupt",
     "evalue": "",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\r",
      " 64%|██████▍   | 63/98 [00:19<00:11,  3.15it/s, loss=0.00652]"
     ]
    }
   ],
   "source": [
    "learner.fit(1e-5,1, cycle_len=15,\n",
    "            sampler=train_sampler,\n",
    "            wds=args.weight_decay,\n",
    "            loss_scale=args.loss_scale,\n",
    "            **sargs\n",
    "           )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "TTA acc: 0.9226                              \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
}