cifar10/cifar10-super-convergence-tuned.ipynb

{
 "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",
    "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": [
    "#print(models.cifar10.__dict__)\n",
    "#print(model_names)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Example usage: python run_fastai.py /home/paperspace/ILSVRC/Data/CLS-LOC/ -a resnext_50_32x4d --epochs 1 -j 4 -b 64 --fp16\n",
    "\n",
    "parser = argparse.ArgumentParser(description='PyTorch Cifar10 Training')\n",
    "parser.add_argument('data', metavar='DIR',\n",
    "                    help='path to dataset')\n",
    "parser.add_argument('--save-dir', type=str, default=Path.home()/'imagenet_training',\n",
    "                    help='Directory to save logs and models.')\n",
    "parser.add_argument('--arch', '-a', metavar='ARCH', default='resnet56',\n",
    "                    choices=model_names,\n",
    "                    help='model architecture: ' +\n",
    "                    ' | '.join(model_names) +\n",
    "                    ' (default: resnet56)')\n",
    "parser.add_argument('-j', '--workers', default=7, type=int, metavar='N',\n",
    "                    help='number of data loading workers (default: 4)')\n",
    "parser.add_argument('--epochs', default=1, type=int, metavar='N',\n",
    "                    help='number of total epochs to run')\n",
    "parser.add_argument('--cycle-len', default=95, type=float, metavar='N',\n",
    "                    help='Length of cycle to run')\n",
    "# parser.add_argument('--start-epoch', default=0, type=int, metavar='N',\n",
    "#                     help='manual epoch number (useful on restarts)')\n",
    "parser.add_argument('-b', '--batch-size', default=512, type=int,\n",
    "                    metavar='N', help='mini-batch size (default: 256)')\n",
    "parser.add_argument('--lr', '--learning-rate', default=0.8, type=float,\n",
    "                    metavar='LR', help='initial learning rate')\n",
    "parser.add_argument('--momentum', default=0.9, type=float, metavar='M', help='momentum')\n",
    "parser.add_argument('--weight-decay', '--wd', default=1e-4, type=float,\n",
    "                    metavar='W', help='weight decay (default: 1e-4)')\n",
    "# parser.add_argument('--print-freq', '-p', default=10, type=int,\n",
    "#                     metavar='N', help='print frequency (default: 10)')\n",
    "# parser.add_argument('--resume', default='', type=str, metavar='PATH',\n",
    "#                     help='path to latest checkpoint (default: none)')\n",
    "# parser.add_argument('-e', '--evaluate', dest='evaluate', action='store_true',\n",
    "#                     help='evaluate model on validation set')\n",
    "parser.add_argument('--pretrained', dest='pretrained', action='store_true', help='use pre-trained model')\n",
    "parser.add_argument('--fp16', action='store_true', help='Run model fp16 mode.')\n",
    "parser.add_argument('--use-tta', default=True, type=bool, help='Validate model with TTA at the end of traiing.')\n",
    "parser.add_argument('--train-half', action='store_true', help='Train model on half images. TODO: allow custom epochs and LR')\n",
    "parser.add_argument('--sz',       default=32, type=int, help='Size of transformed image.')\n",
    "# parser.add_argument('--decay-int', default=30, type=int, help='Decay LR by 10 every decay-int epochs')\n",
    "parser.add_argument('--use-clr', default='10,13.68,0.95,0.85', type=str, \n",
    "                    help='div,pct,max_mom,min_mom. Pass in a string delimited by commas. Ex: \"20,2,0.95,0.85\"')\n",
    "parser.add_argument('--loss-scale', type=float, default=128,\n",
    "                    help='Loss scaling, positive power of 2 values can improve fp16 convergence.')\n",
    "parser.add_argument('--prof', dest='prof', action='store_true', help='Only run a few iters for profiling.')\n",
    "\n",
    "parser.add_argument('--dist-url', default='file://sync.file', type=str,\n",
    "                    help='url used to set up distributed training')\n",
    "parser.add_argument('--dist-backend', default='nccl', type=str, help='distributed backend')\n",
    "\n",
    "parser.add_argument('--world-size', default=1, type=int,\n",
    "                    help='Number of GPUs to use. Can either be manually set ' +\n",
    "                    'or automatically set by using \\'python -m multiproc\\'.')\n",
    "parser.add_argument('--rank', default=0, type=int,\n",
    "                    help='Used for multi-process training. Can either be manually set ' +\n",
    "                    'or automatically set by using \\'python -m multiproc\\'.')\n",
    "\n",
    "class TorchModelData(ModelData):\n",
    "    def __init__(self, path, trn_dl, val_dl, aug_dl=None):\n",
    "        super().__init__(path, trn_dl, val_dl)\n",
    "        self.aug_dl = aug_dl\n",
    "\n",
    "def torch_loader(data_path, size):\n",
    "    # Data loading code\n",
    "    traindir = os.path.join(data_path, 'train')\n",
    "    valdir = os.path.join(data_path, 'test')\n",
    "    normalize = transforms.Normalize(mean=[0.4914 , 0.48216, 0.44653], std=[0.24703, 0.24349, 0.26159])\n",
    "    \n",
    "    scale_size = 40\n",
    "    padding = int((scale_size - size) / 2)\n",
    "    train_tfms = transforms.Compose([\n",
    "        transforms.RandomCrop(size, padding=padding),\n",
    "        transforms.ColorJitter(.25,.25,.25),\n",
    "        transforms.RandomRotation(2),\n",
    "        transforms.RandomHorizontalFlip(),\n",
    "        transforms.ToTensor(),\n",
    "        normalize,\n",
    "    ])\n",
    "    train_dataset = datasets.ImageFolder(traindir, train_tfms)\n",
    "    train_sampler = (torch.utils.data.distributed.DistributedSampler(train_dataset)\n",
    "                     if args.distributed else None)\n",
    "    train_loader = torch.utils.data.DataLoader(\n",
    "        train_dataset, batch_size=args.batch_size, shuffle=(train_sampler is None),\n",
    "        num_workers=args.workers, pin_memory=True, sampler=train_sampler)\n",
    "\n",
    "    val_tfms = transforms.Compose([\n",
    "    #   transforms.Resize(int(size*1.14)),\n",
    "    #   transforms.CenterCrop(size),\n",
    "        transforms.ToTensor(),\n",
    "        normalize,\n",
    "    ])\n",
    "    val_loader = torch.utils.data.DataLoader(\n",
    "        datasets.ImageFolder(valdir, val_tfms),\n",
    "        batch_size=args.batch_size, shuffle=False,\n",
    "        num_workers=args.workers, pin_memory=True)\n",
    "\n",
    "\n",
    "    aug_loader = torch.utils.data.DataLoader(\n",
    "        datasets.ImageFolder(valdir, train_tfms),\n",
    "        batch_size=args.batch_size, shuffle=False,\n",
    "        num_workers=args.workers, pin_memory=True)\n",
    "\n",
    "    train_loader = DataPrefetcher(train_loader)\n",
    "    val_loader = DataPrefetcher(val_loader)\n",
    "    aug_loader = DataPrefetcher(aug_loader)\n",
    "    if args.prof:\n",
    "        train_loader.stop_after = 200\n",
    "        val_loader.stop_after = 0\n",
    "\n",
    "    data = TorchModelData(data_path, train_loader, val_loader, aug_loader)\n",
    "    return data, train_sampler\n",
    "\n",
    "\n",
    "# Seems to speed up training by ~2%\n",
    "class DataPrefetcher():\n",
    "    def __init__(self, loader, stop_after=None):\n",
    "        self.loader = loader\n",
    "        self.dataset = loader.dataset\n",
    "        self.stream = torch.cuda.Stream()\n",
    "        self.stop_after = stop_after\n",
    "        self.next_input = None\n",
    "        self.next_target = None\n",
    "\n",
    "    def __len__(self):\n",
    "        return len(self.loader)\n",
    "    \n",
    "    def preload(self):\n",
    "        try:\n",
    "            self.next_input, self.next_target = next(self.loaditer)\n",
    "        except StopIteration:\n",
    "            self.next_input = None\n",
    "            self.next_target = None\n",
    "            return\n",
    "        with torch.cuda.stream(self.stream):\n",
    "            self.next_input = self.next_input.cuda(async=True)\n",
    "            self.next_target = self.next_target.cuda(async=True)\n",
    "\n",
    "    def __iter__(self):\n",
    "        count = 0\n",
    "        self.loaditer = iter(self.loader)\n",
    "        self.preload()\n",
    "        while self.next_input is not None:\n",
    "            torch.cuda.current_stream().wait_stream(self.stream)\n",
    "            input = self.next_input\n",
    "            target = self.next_target\n",
    "            self.preload()\n",
    "            count += 1\n",
    "            yield input, target\n",
    "            if type(self.stop_after) is int and (count > self.stop_after):\n",
    "                break\n",
    "                \n",
    "def top5(output, target):\n",
    "    \"\"\"Computes the precision@k for the specified values of k\"\"\"\n",
    "    top5 = 5\n",
    "    batch_size = target.size(0)\n",
    "    _, pred = output.topk(top5, 1, True, True)\n",
    "    pred = pred.t()\n",
    "    correct = pred.eq(target.view(1, -1).expand_as(pred))\n",
    "    correct_k = correct[:top5].view(-1).float().sum(0, keepdim=True)\n",
    "    return correct_k.mul_(1.0 / batch_size)\n",
    "\n",
    "\n",
    "class ImagenetLoggingCallback(Callback):\n",
    "    def __init__(self, save_path, print_every=50):\n",
    "        super().__init__()\n",
    "        self.save_path=save_path\n",
    "        self.print_every=print_every\n",
    "    def on_train_begin(self):\n",
    "        self.batch = 0\n",
    "        self.epoch = 0\n",
    "        self.f = open(self.save_path, \"a\", 1)\n",
    "        self.log(\"\\ton_train_begin\")\n",
    "    def on_epoch_end(self, metrics):\n",
    "        log_str = f'\\tEpoch:{self.epoch}\\ttrn_loss:{self.last_loss}'\n",
    "        for (k,v) in zip(['val_loss', 'acc', 'top5', ''], metrics): log_str += f'\\t{k}:{v}'\n",
    "        self.log(log_str)\n",
    "        self.epoch += 1\n",
    "    def on_batch_end(self, metrics):\n",
    "        self.last_loss = metrics\n",
    "        self.batch += 1\n",
    "        if self.batch % self.print_every == 0:\n",
    "            self.log(f'Epoch: {self.epoch} Batch: {self.batch} Metrics: {metrics}')\n",
    "    def on_train_end(self):\n",
    "        self.log(\"\\ton_train_end\")\n",
    "        self.f.close()\n",
    "    def log(self, string):\n",
    "        self.f.write(time.strftime(\"%Y-%m-%dT%H:%M:%S\")+\"\\t\"+string+\"\\n\")\n",
    "        \n",
    "        \n",
    "class DisbleTransformCallback(Callback):\n",
    "    def __init__(self, dataset, disable_at=120):\n",
    "        super().__init__()\n",
    "        self.dataset = dataset\n",
    "        self.disable_at = disable_at\n",
    "    def on_epoch_end(self, metrics):\n",
    "        log_str = f'\\tEpoch:{self.epoch}\\ttrn_loss:{self.last_loss}'\n",
    "        for (k,v) in zip(['val_loss', 'acc', 'top5', ''], metrics): log_str += f'\\t{k}:{v}'\n",
    "        self.log(log_str)\n",
    "        self.epoch += 1\n",
    "        print('Disabling dataset transforms')\n",
    "        if self.epoch > disable_at:\n",
    "            dataset.transform = None\n",
    "\n",
    "# Logging + saving models\n",
    "def save_args(name, save_dir):\n",
    "    if (args.rank != 0) or not args.save_dir: return {}\n",
    "\n",
    "    log_dir = f'{save_dir}/training_logs'\n",
    "    os.makedirs(log_dir, exist_ok=True)\n",
    "    return {\n",
    "        'best_save_name': f'{name}_best_model',\n",
    "        'cycle_save_name': f'{name}',\n",
    "        'callbacks': [\n",
    "            ImagenetLoggingCallback(f'{log_dir}/{name}_log.txt')\n",
    "        ]\n",
    "    }\n",
    "\n",
    "def save_sched(sched, save_dir):\n",
    "    if (args.rank != 0) or not args.save_dir: return {}\n",
    "    log_dir = f'{save_dir}/training_logs'\n",
    "    sched.save_path = log_dir\n",
    "    sched.plot_loss()\n",
    "    sched.plot_lr()\n",
    "\n",
    "def update_model_dir(learner, base_dir):\n",
    "    learner.tmp_path = f'{base_dir}/tmp'\n",
    "    os.makedirs(learner.tmp_path, exist_ok=True)\n",
    "    learner.models_path = f'{base_dir}/models'\n",
    "    os.makedirs(learner.models_path, exist_ok=True)\n",
    "    "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Configuration"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "args_input = [\n",
    "    '/home/ubuntu/data/cifar10', \n",
    "    '--save-dir', '/home/ubuntu/data/cf_train_save/65e_pre18_clr30_rollout20_lr12_wd_2e4_ls256',\n",
    "    '-a', 'preact_resnet18',\n",
    "#     '-j', '6', \n",
    "#     '--prof', \n",
    "    '-b', '512', \n",
    "#     '--sz', '32',\n",
    "    '--loss-scale', '256',\n",
    "    '--fp16',\n",
    "    '--cycle-len', '65',\n",
    "#     '--epochs', '1',\n",
    "    '--use-clr', '30, 20, 0.95, 0.85',\n",
    "    '--wd', '2e-4',\n",
    "    '--lr', '1.2',\n",
    "#     '--train-half' # With fp16, iterations are so fast this doesn't matter\n",
    "]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 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": 7,
   "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": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "=> creating model 'preact_resnet18'\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": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "model = model.cuda()\n",
    "if args.distributed:\n",
    "    model = DDP(model)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "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": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "# x,y = next(iter(data.trn_dl))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "# plt.imshow(np.transpose(x[50], (1, 2, 0)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "# %pdb off"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "d7d0d4f2a55e4120a6cfebd186d78863",
       "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:08<00:02,  9.44it/s, loss=12.8]\n",
      "                                                          \r"
     ]
    }
   ],
   "source": [
    "learner.lr_find()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "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(n_skip=0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 128x128\n",
    "if args.train_half: \n",
    "    save_dir = args.save_dir+'/128'\n",
    "    update_model_dir(learner, save_dir)\n",
    "    sargs = save_args('first_run_128', save_dir)\n",
    "    sargs['callbacks'] += [DisableTransformCallback(data.train_ds, 5)]\n",
    "    learner.fit(args.lr,args.epochs, cycle_len=45,\n",
    "                train_sampler=train_sampler,\n",
    "                wds=args.weight_decay,\n",
    "                use_clr_beta=args.use_clr,\n",
    "                loss_scale=args.loss_scale,\n",
    "                **sargs\n",
    "            )\n",
    "    save_sched(learner.sched, save_dir)\n",
    "    data, train_sampler = torch(args.data, args.sz)\n",
    "    learner.set_data(data)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "75b2bf71ab954d69ad96b2a8fc62b51f",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "HBox(children=(IntProgress(value=0, description='Epoch', max=65), HTML(value='')))"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "                                                          \r"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/ubuntu/git/imagenet-fast/cifar10/fastai/core.py:31: UserWarning: volatile was removed and now has no effect. Use `with torch.no_grad():` instead.\n",
      "  x = Variable(T(x), volatile=volatile, requires_grad=requires_grad)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epoch      trn_loss   val_loss   accuracy   \n",
      "    0      1.597727   1.542461   0.4633    \n",
      "    1      1.258801   1.103473   0.6208                   \n",
      "    2      0.972911   0.935949   0.6776                    \n",
      "    3      0.792725   0.751558   0.7408                    \n",
      "    4      0.682035   0.813925   0.7252                    \n",
      "    5      0.601548   0.701359   0.759                     \n",
      "    6      0.549059   0.65844    0.7854                    \n",
      "    7      0.519294   0.619365   0.7902                    \n",
      "    8      0.496927   0.621373   0.7929                    \n",
      "    9      0.480748   0.589091   0.801                     \n",
      "    10     0.474157   0.525024   0.8264                    \n",
      "    11     0.466476   0.742185   0.7579                    \n",
      "    12     0.460254   0.696792   0.7754                    \n",
      "    13     0.449546   1.378255   0.6583                    \n",
      "    14     0.447112   0.599804   0.8026                    \n",
      "    15     0.435825   0.904703   0.7283                    \n",
      "    16     0.436086   0.604347   0.7967                    \n",
      "    17     0.438422   0.789051   0.7612                    \n",
      "    18     0.422497   0.502078   0.8328                    \n",
      "    19     0.419885   0.685179   0.7851                    \n",
      "    20     0.44072    0.521533   0.8191                    \n",
      "    21     0.419834   0.604293   0.8046                    \n",
      "    22     0.416162   0.557601   0.8197                    \n",
      "    23     0.427043   0.571396   0.8209                    \n",
      "    24     0.428038   0.621226   0.8058                    \n",
      "    25     0.407386   0.566577   0.8201                    \n",
      "    26     0.444162   0.67172    0.7917                    \n",
      "    27     0.40936    0.660644   0.8053                    \n",
      "    28     0.414098   0.492572   0.8376                    \n",
      "    29     0.40194    0.693754   0.7975                    \n",
      "    30     0.39849    0.901087   0.7494                    \n",
      "    31     0.371218   0.663193   0.8005                    \n",
      "    32     0.383486   0.608334   0.8029                    \n",
      "    33     0.348831   0.881796   0.7536                    \n",
      "    34     0.334356   0.555002   0.8299                    \n",
      "    35     0.34575    0.880541   0.7458                    \n",
      "    36     0.33493    0.560533   0.8208                    \n",
      "    37     0.322747   0.74743    0.7853                    \n",
      "    38     0.315978   0.555727   0.8309                    \n",
      "    39     0.312028   0.56871    0.8131                    \n",
      "    40     0.297595   0.433099   0.8556                    \n",
      "    41     0.286247   0.429109   0.864                     \n",
      "    42     0.262504   0.474889   0.8534                    \n",
      "    43     0.255202   0.378953   0.8759                    \n",
      "    44     0.238911   0.38378    0.8698                    \n",
      "    45     0.22766    0.354805   0.8869                    \n",
      "    46     0.211996   0.370351   0.8824                    \n",
      "    47     0.190193   0.330143   0.8917                    \n",
      "    48     0.16702    0.343959   0.8917                    \n",
      "    49     0.141143   0.321683   0.9015                    \n",
      "    50     0.106302   0.252937   0.9213                    \n",
      "    51     0.072987   0.228383   0.9333                     \n",
      "    52     0.054684   0.221551   0.9334                     \n",
      "    53     0.044502   0.22194    0.9377                     \n",
      "    54     0.035976   0.229909   0.9376                     \n",
      "    55     0.032249   0.224786   0.9371                     \n",
      "    56     0.028004   0.228738   0.9378                     \n",
      "    57     0.024184   0.225704   0.938                      \n",
      "    58     0.021198   0.232919   0.9411                     \n",
      "    59     0.017807   0.234266   0.938                      \n",
      "    60     0.016931   0.233138   0.9413                     \n",
      "    61     0.015856   0.23176    0.9401                     \n",
      "    62     0.013712   0.231135   0.9407                     \n",
      "    63     0.012768   0.230449   0.9414                     \n",
      "    64     0.011091   0.231521   0.9417                     \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": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "learner.save('cifar10-resnext-aug-preact')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "ename": "AttributeError",
     "evalue": "'CircularLR_beta' object has no attribute 'plot'",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mAttributeError\u001b[0m                            Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-19-d5621b0b5f81>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mlearner\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0msched\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mplot\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mAttributeError\u001b[0m: 'CircularLR_beta' object has no attribute 'plot'"
     ]
    }
   ],
   "source": [
    "learner.sched.plot()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "learner.lr_find()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "learner.sched.plot()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "leaner.fig"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "learner.fit(1e-5,1, cycle_len=15,\n",
    "            wds=args.weight_decay,\n",
    "            loss_scale=args.loss_scale,\n",
    "            **sargs\n",
    "           )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "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": [
    "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\")"
   ]
  }
 ],
 "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
}