{
 "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": 6,
   "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": 8,
   "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(.3,.3,.3),\n",
    "        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": 10,
   "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', '2e-4',\n",
    "    '--lr', '1',\n",
    "#     '--train-half' # With fp16, iterations are so fast this doesn't matter\n",
    "]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "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": 12,
   "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": 13,
   "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": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "model = model.cuda()\n",
    "if args.distributed:\n",
    "    model = DDP(model)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "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": 24,
   "metadata": {},
   "outputs": [],
   "source": [
    "x,y = next(iter(data.trn_dl))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "torch.Size([512, 3, 32, 32])"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<matplotlib.image.AxesImage at 0x7f549a31f7f0>"
      ]
     },
     "execution_count": 44,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAP8AAAD8CAYAAAC4nHJkAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDIuMi4yLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvhp/UCwAAENxJREFUeJzt3X+QVfV5x/H3Iz+yLUu7IAorYFBCpjJOBboy1hi1WqMxdpBMk2qblk6drGnCtI7aGYqm0mo6JqM4dpIxWSMTjAYwagoTzVRLk8GmrbKC/FCioiEBWVgQtoKWKPD0j3N2ZiH3e+7dc889d+H7ec0we/c895zz7Nn9cH987/kec3dEJD6nNLsBEWkOhV8kUgq/SKQUfpFIKfwikVL4RSKl8ItESuEXiZTCLxKp4fWsbGZXAfcDw4Bvu/vdVe4f/jjhiIwVP8jVnkiU3N1quZ/l/XivmQ0DXgOuAHYAa4Hr3f2VjHXCO5uUsbMduVoUiVKt4a/naf9sYKu7v+nu7wPLgTl1bE9ESlRP+CcC2wd8vyNdJiIngHpe81d6avFrT+vNrBPorGM/ItIA9YR/BzB5wPeTgJ3H38ndu4AuqPKaX0RKVc/T/rXANDM7y8xGAtcBq4ppS0QaLfcjv7sfNrP5wL+RDPUtcfeXc3eid/RFSpV7qC/XzvS0X6ThyhjqE5ETmMIvEimFXyRSCr9IpBR+kUjVdVafDEXXBZa/lrHOukY0IkOcHvlFIqXwi0RK4ReJlMIvEimFXyRSerf/pPPhwPLpGevo3f4Y6ZFfJFIKv0ikFH6RSCn8IpFS+EUipfCLREpDfSeZSyacWXH5lGlTg+ssfa5R3chQpkd+kUgp/CKRUvhFIqXwi0RK4ReJlMIvEqm6hvrMbBtwADgCHHb3jiKakvym3PDfFZd/93sLS+5Ehroixvn/wN33FrAdESmRnvaLRKre8DvwjJm9aGadRTQkIuWo92n/x9x9p5mdDjxrZj9z9zUD75D+p6D/GESGmLoe+d19Z/q1F/gBMLvCfbrcvUNvBooMLbnDb2ajzGx0/23gE8DmohoTkcYyd8+3otnZJI/2kLx8+J67f6XKOvl2JiI1c3er5X65w5+Hwi/SeLWGX0N9IpFS+EUipfCLRErhF4mUwi8SKYVfJFIKv0ikFH6RSCn8IpFS+EUipfCLREqX6yrAJV+8IVjb+6O3g7Vxe04N1lpawvvbNTy8ze1Uru3bpWtyybH0yC8SKYVfJFIKv0ikFH6RSCn8IpFS+EUipaG+ArT1tQVrTz/+7WCtZXt4m6ecE671bgvXxl9Z0wxOInrkF4mVwi8SKYVfJFIKv0ikFH6RSCn8IpGqOtRnZkuAa4Bedz83XTYWWAFMAbYBn3X3/Y1rc2hbeNvNwdpvTs9YcVa49M6acO1vvnBn9aZEqqjlkf87wFXHLVsArHb3acDq9HsROYFUDb+7rwH2Hbd4DrA0vb0UuLbgvkSkwfK+5h/v7j0A6dfTi2tJRMrQ8I/3mlkn0Nno/YjI4OR95N9tZu0A6dfe0B3dvcvdO9y9I+e+RKQB8oZ/FTAvvT0PWFlMOyJSllqG+pYBlwLjzGwHcAdwN/CYmd0A/BL4TCObHOrWr30lWJsx/YxgbeT/hbc55pLzgrWjbMzoJjTz56GMdSRGVcPv7tcHSpcX3IuIlEif8BOJlMIvEimFXyRSCr9IpBR+kUhpAs8CLLt/ebB2ePuRYG3K5DODtXMmfDRYm9R+RbA299PHn4OV+MKXPxdcB3Zn1ORkpUd+kUgp/CKRUvhFIqXwi0RK4ReJlMIvEilz9/J2Zlbezhqi8hlzE/l4cI09vB2svc8bwdrEttnB2sOPfCtYu+xTZwVrIWZD5Pp+raeGawfDx1GO5e41/UL1yC8SKYVfJFIKv0ikFH6RSCn8IpHSiT2D8tsVl77Fs4Xv6dwLwyf25HlHP8vuDeH5/cafF5oTsAH0jn6p9MgvEimFXyRSCr9IpBR+kUgp/CKRUvhFIlX1xB4zWwJcA/S6+7npskXA54E96d0WuvvTVXd2gp/YM2fcworLV+7951zbu/zqW4K1p5+6J1gbmWtv+ax89N+DtWs/F55LUJqnyBN7vgNUmhXyPnefkf6rGnwRGVqqht/d1wD7SuhFREpUz2v++Wa20cyWmNmYwjoSkVLkDf8DwFRgBtAD3Bu6o5l1mlm3mXXn3JeINECu8Lv7bnc/4u5HgQeB4LQz7t7l7h3u3pG3SREpXq7wm1n7gG/nApuLaUdEylLLUN8y4FJgHMl1ne5Iv58BOLANuNHde6ru7AQf6lv0+0srLj935szgOi0XtgVrn/qzyXX31Ex/d3tXsHbPV24ssRMZqNahvqqn9Lr79RUWPzTojkRkSNEn/EQipfCLRErhF4mUwi8SKYVfJFK6XNegVL6clL+6N7xKeB7Ok1rRlwC7/c7Hg7XFq5YHa++tDa93stLlukQkk8IvEimFXyRSCr9IpBR+kUgp/CKR0lBfAW7/YnAuE+78xs0ldjJ0FD3UN37SJ4O1j8wOn1X50yfzTa56ItNQn4hkUvhFIqXwi0RK4ReJlMIvEim921+IUcHKW28cDNbOOC28xY1rdwZrrW2twdqUWb9VcfnhnEd+ZM437Vc+tb7i8uEjwr1fc2WkZ0EVTO/2i0gmhV8kUgq/SKQUfpFIKfwikVL4RSJVy+W6JgMPAxOAo0CXu99vZmOBFcAUkkt2fdbd91fZ1kk61Bf21qsZP/KucOlHK34SXu3Qu8Fay5jKw47nf3xicJ2L50wLN5LT0cBfwt7t4XX+9C/nB2ur13+jzo7iUeRQ32HgFnc/B7gA+JKZTQcWAKvdfRqwOv1eRE4QVcPv7j3uvi69fQDYAkwE5gD9V65cClzbqCZFpHiDes1vZlOAmcDzwPj+K/OmX08vujkRaZyqV+ntZ2atwBPATe7+Tq2TNZhZJ9CZrz0RaZSaHvnNbARJ8B919yfTxbvNrD2ttwO9ldZ19y5373D3jiIaFpFiVA2/JQ/xDwFb3H3xgNIqYF56ex6wsvj2RKRRahnquwh4DthEMtQHsJDkdf9jwJnAL4HPuPu+KtuKbqjvpy/vDtYunB5+m6TjtPCw14t7Bz/s9XtcF6x1+7JBb6+a3rsqL9/2evhsxUPTjgRrl3z5zHpbikatQ31VX/O7+38CoY1dPpimRGTo0Cf8RCKl8ItESuEXiZTCLxIphV8kUprAs4nezTj2owq+3FUWfznj1zI9XNq5Ilz72cOVT9/7nWlnBNe5ecU/BWsrdoVrcixN4CkimRR+kUgp/CKRUvhFIqXwi0RK4ReJVM2TeUjx7nhqSbB2yszZwdrR9S8Mel9fv+1fw8WM4bxR9kfB2nuVp3AAYB5/UnH5X316bnCdFbuWBmtSPD3yi0RK4ReJlMIvEimFXyRSCr9IpPRufxPt3xSe3+9f7g6fyDL/yqsGva/zL5416HUA3uOHudZbSuURic628FyC8Itc+5J89MgvEimFXyRSCr9IpBR+kUgp/CKRUvhFIlXL5bomAw8DE0gu19Xl7veb2SLg88Ce9K4L3f3pKtvSHH4D3NUZPpHltq//RbBmI8ub3694WaPLh0vr4mRW2OW6SH4jt7j7OjMbDbxoZs+mtfvc/Z68TYpI89Ryrb4eoCe9fcDMtgATG92YiDTWoF7zm9kUYCbJFXoB5pvZRjNbYmZjCu5NRBqo5vCbWSvwBHCTu78DPABMBWaQPDO4N7Bep5l1m1l3Af2KSEFqCr+ZjSAJ/qPu/iSAu+929yPufhR4EKg49Yy7d7l7h7t3FNW0iNSvavjNzICHgC3uvnjA8vYBd5sLbC6+PRFplFqG+i4CngM2kQz1ASwErid5yu/ANuDG9M3BrG1pqE+kwWod6tO1+kROMrpWn4hkUvhFIqXwi0RK4ReJlMIvEimFXyRSCr9IpBR+kUgp/CKRUvhFIqXwi0RK4ReJlMIvEimFXyRSCr9IpBR+kUgp/CKRUvhFIqXwi0Sqlst1FWZq60e5d+a3Ao20Btc7zMEc64QdOtgXXm94xiFpqbzVltHhPv7nvzYGa/f03RjeV4Zb2yofQ4BLLzu/4vK+Pb8KrtN38H+DtV09vwjW9u6t/HsB+ObhrwUq4XVubVscrA0PH2IOhzfJwcD+2oa3hbd3OPzX8/O+8PEYzpFgrY/w39wO3gqsE/699ARqR3k9uM7x9MgvEimFXyRSCr9IpBR+kUgp/CKRquVyXS3AGuBDJKMDj7v7HWZ2FrAcGAusA/7c3d/P2lbH9A7vfiRwsd7JGSu2BJZnvAOcqabrmRTk7nDJ/j7cyFiuCNbe3vBMeKO/W0tTJViXY52ZGbUyf2cfZNQO5aztz6iFRisyRjEIXBivY2EH3W90F3bFnl8Bl7n7eSTX5rvKzC4Avgrc5+7TSH60G2rZoYgMDVXD74n+/4NGpP8cuAx4PF2+FLi2IR2KSEPU9JrfzIaZ2UtAL/As8AbQ5+79n4bYAUxsTIsi0gg1hd/dj7j7DGASMBs4p9LdKq1rZp1m1m1m3Xv278nfqYgUalDv9rt7H/AT4AKgzcz6Pws7CdgZWKfL3TvcveO0MafV06uIFKhq+M3sNDNrS2//BvCHwBbgx8Afp3ebB6xsVJMiUrxaTuxpB5aa2TCS/ywec/cfmtkrwHIzuwtYDzxUbUOH3obXHq588sOkCcOC67WMrqHL45yS9ZOFhg4h84ygo4HlBzOGePr2hmuPnL82WGtvPzVYe/8/wtscGdpk1s+cJesMqSyh82ayfi/rc+4rh6MZP1fWj3wwY8hu6897w+v1vRusHeirfNLP8IyDNbq18jj3wX3hE7h+fftVuPtGKozAuvubJK//ReQEpE/4iURK4ReJlMIvEimFXyRSCr9IpKqe1Vfozsz2AP2ToI0DMgbCSqM+jqU+jnWi9fFhd6/p03Slhv+YHZt1u3tHU3auPtSH+tDTfpFYKfwikWpm+LuauO+B1Mex1MexTto+mvaaX0SaS0/7RSLVlPCb2VVm9qqZbTWzBc3oIe1jm5ltMrOXzCwws2hD9rvEzHrNbPOAZWPN7Fkzez39OqZJfSwys7fSY/KSmV1dQh+TzezHZrbFzF42s79Nl5d6TDL6KPWYmFmLmb1gZhvSPv4xXX6WmT2fHo8VZjayrh25e6n/gGEk04CdDYwENgDTy+4j7WUbMK4J+70YmAVsHrDsa8CC9PYC4KtN6mMRcGvJx6MdmJXeHg28Bkwv+5hk9FHqMSGZq7g1vT0CeJ5kAp3HgOvS5d8E/rqe/TTjkX82sNXd3/Rkqu/lwJwm9NE07r4G2Hfc4jkkE6FCSROiBvoonbv3uPu69PYBksliJlLyMcnoo1SeaPikuc0I/0Rg+4Dvmzn5pwPPmNmLZtbZpB76jXf3Hkj+CIHTm9jLfDPbmL4saPjLj4HMbArJ/BHP08RjclwfUPIxKWPS3GaEv9IFBZo15PAxd58FfBL4kpld3KQ+hpIHgKkk12joAe4ta8dm1go8Adzk7u+Utd8a+ij9mHgdk+bWqhnh38Gx1+cJTv7ZaO6+M/3aC/yA5s5MtNvM2gHSr+E5oRrI3Xenf3hHgQcp6ZiY2QiSwD3q7k+mi0s/JpX6aNYxSfc96Elza9WM8K8FpqXvXI4ErgNWld2EmY0ys9H9t4FPAJuz12qoVSQToUITJ0TtD1tqLiUcEzMzkjkgt7j74gGlUo9JqI+yj0lpk+aW9Q7mce9mXk3yTuobwG1N6uFskpGGDcDLZfYBLCN5+vgByTOhG4BTgdXA6+nXsU3q47vAJmAjSfjaS+jjIpKnsBuBl9J/V5d9TDL6KPWYkFxxcX26v83APwz4m30B2Ap8H/hQPfvRJ/xEIqVP+IlESuEXiZTCLxIphV8kUgq/SKQUfpFIKfwikVL4RSL1//OPmSnfPBJTAAAAAElFTkSuQmCC\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.imshow(np.transpose(x[50], (1, 2, 0)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "# %pdb off"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "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": 18,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "07db130cc2ea4fbbacceeeb514fbc6d0",
       "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.964649   2.29585    0.2413    \n",
      "    1      1.629196   1.670711   0.4153                   \n",
      "    2      1.279893   1.212244   0.5794                   \n",
      "    3      1.022324   1.081357   0.621                    \n",
      "    4      0.87207    0.947416   0.6629                    \n",
      "    5      0.7623     1.424813   0.5834                    \n",
      "    6      0.711834   0.880024   0.6867                    \n",
      "    7      0.673645   0.882425   0.7036                    \n",
      "    8      0.624824   0.75577    0.7406                    \n",
      "    9      0.591317   0.977343   0.6912                    \n",
      "    10     0.576992   0.738988   0.7422                    \n",
      "    11     0.54849    0.760248   0.7389                    \n",
      "    12     0.537716   0.806278   0.7491                    \n",
      "    13     0.521323   0.857931   0.7177                    \n",
      "    14     0.520798   0.709312   0.7678                    \n",
      "    15     0.501003   1.247033   0.6533                    \n",
      "    16     0.488959   0.970011   0.7197                    \n",
      "    17     0.474377   0.710652   0.7681                    \n",
      "    18     0.476366   0.686354   0.7693                    \n",
      "    19     0.480246   1.048503   0.6718                    \n",
      "    20     0.460859   0.705917   0.7693                    \n",
      "    21     0.4575     0.928597   0.7142                    \n",
      "    22     0.451474   1.079432   0.6969                    \n",
      "    23     0.457522   0.714242   0.7713                    \n",
      "    24     0.454815   0.958381   0.7166                    \n",
      "    25     0.454017   0.721306   0.7626                    \n",
      "    26     0.440028   0.671276   0.783                     \n",
      "    27     0.432509   0.704762   0.7709                    \n",
      "    28     0.434946   0.848601   0.7411                    \n",
      "    29     0.436465   0.878166   0.7304                    \n",
      "    30     0.427199   0.884603   0.7291                    \n",
      "    31     0.434507   1.089957   0.6863                    \n",
      "    32     0.417676   0.861309   0.7223                    \n",
      "    33     0.421785   0.723549   0.7686                    \n",
      "    34     0.422014   0.76699    0.7494                    \n",
      "    35     0.414088   0.737529   0.7734                    \n",
      "    36     0.42199    0.867438   0.7532                    \n",
      "    37     0.410439   0.731212   0.7665                    \n",
      "    38     0.419615   0.893294   0.722                     \n",
      "    39     0.410767   0.783612   0.7611                    \n",
      "    40     0.417583   0.834628   0.7361                    \n",
      "    41     0.412891   0.63415    0.7936                    \n",
      "    42     0.409541   0.940022   0.7131                    \n",
      "    43     0.406647   0.683275   0.7813                    \n",
      "    44     0.404456   0.787411   0.7438                    \n",
      "    45     0.396082   0.752332   0.7505                    \n",
      "    46     0.393867   0.762795   0.7638                    \n",
      "    47     0.399886   0.699477   0.7797                    \n",
      "    48     0.39515    0.909923   0.71                      \n",
      "    49     0.393156   0.672227   0.7759                    \n",
      "    50     0.378291   0.74518    0.7671                    \n",
      "    51     0.379188   1.026341   0.7154                    \n",
      "    52     0.384426   0.720828   0.7656                    \n",
      "    53     0.376072   0.84426    0.7349                    \n",
      "    54     0.367509   0.724659   0.771                     \n",
      "    55     0.376669   0.787541   0.7382                    \n",
      "    56     0.366169   0.679759   0.7823                    \n",
      "    57     0.366301   0.766295   0.7787                    \n",
      "    58     0.347275   0.569886   0.8152                    \n",
      "    59     0.360935   0.670394   0.7923                    \n",
      "    60     0.347934   0.603666   0.8008                    \n",
      "    61     0.336586   0.581869   0.8179                    \n",
      "    62     0.342905   0.801929   0.7625                    \n",
      "    63     0.343652   0.529446   0.8312                    \n",
      "    64     0.335459   0.678714   0.7988                    \n",
      "    65     0.329838   0.817373   0.7575                    \n",
      "    66     0.322143   0.718153   0.7865                    \n",
      "    67     0.324445   0.632962   0.7979                    \n",
      "    68     0.312053   0.57795    0.8145                    \n",
      "    69     0.301993   0.502879   0.8408                    \n",
      "    70     0.30651    0.496823   0.8404                    \n",
      "    71     0.29968    0.694079   0.7911                    \n",
      "    72     0.289324   0.570044   0.8077                    \n",
      "    73     0.284152   0.791094   0.758                     \n",
      "    74     0.27619    0.637103   0.8159                    \n",
      "    75     0.262262   0.5558     0.823                     \n",
      "    76     0.250873   0.483756   0.8489                    \n",
      "    77     0.231588   0.470876   0.8502                    \n",
      "    78     0.226033   0.506693   0.8422                    \n",
      "    79     0.208242   0.403554   0.8717                    \n",
      "    80     0.177001   0.499644   0.8528                    \n",
      "    81     0.171563   0.455609   0.8591                    \n",
      "    82     0.146025   0.644057   0.8225                    \n",
      "    83     0.13099    0.407798   0.8785                    \n",
      "    84     0.127202   0.411514   0.879                     \n",
      "    85     0.109014   0.399722   0.8855                    \n",
      "    86     0.102309   0.395437   0.8841                    \n",
      "    87     0.082008   0.409852   0.8869                     \n",
      "    88     0.072423   0.396025   0.8919                     \n",
      "    89     0.059635   0.389407   0.8953                     \n",
      "    90     0.044886   0.398666   0.8958                     \n",
      "    91     0.036124   0.377657   0.9034                     \n",
      "    92     0.027008   0.373316   0.9056                     \n",
      "    93     0.02094    0.370854   0.9058                     \n",
      "    94     0.018163   0.369598   0.9068                     \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": "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\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": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "learner.sched.plot()"
   ]
  },
  {
   "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
}