{ "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/paperspace/data/cifar10', \n", " '--save-dir', '/home/paperspace/data/cifar_training/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": "fed69453bc924a72afcb9dc3484a9693", "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": [ " 83%|████████▎ | 81/98 [00:09<00:01, 8.91it/s, loss=14.3]\n", " \r" ] } ], "source": [ "learner.lr_find()" ] }, { "cell_type": "code", "execution_count": 15, "metadata": {}, "outputs": [ { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "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": "9fa15d9436fd443dac4bd8449b3e5bb2", "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/paperspace/imagenet-fast/cifar10/fastai/core.py:30: 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.661849 1.469639 0.4651 \n", " 1 1.34131 1.210569 0.5532 \n", " 2 1.041136 1.016662 0.6513 \n", " 3 0.846846 0.787478 0.7239 \n", " 4 0.700724 0.964983 0.6916 \n", " 5 0.612886 0.63153 0.7725 \n", " 6 0.578661 0.71027 0.7559 \n", " 7 0.550861 0.656968 0.7773 \n", " 8 0.505063 0.594844 0.7973 \n", " 9 0.490741 0.613804 0.793 \n", " 10 0.488837 1.197419 0.6402 \n", " 11 0.471137 0.611046 0.7974 \n", " 12 0.454262 0.658435 0.7856 \n", " 13 0.443972 1.153738 0.6889 \n", " 14 0.44017 0.641931 0.7936 \n", " 15 0.457579 0.844746 0.7143 \n", " 16 0.440278 0.664006 0.7853 \n", " 17 0.446422 0.963016 0.7048 \n", " 18 0.44191 0.699741 0.7564 \n", " 19 0.417722 0.601077 0.8129 \n", " 20 0.427053 0.716967 0.7698 \n", " 21 0.425452 0.64302 0.7892 \n", " 22 0.416377 0.648804 0.7901 \n", " 23 0.416044 0.579311 0.8139 \n", " 24 0.437921 0.787166 0.7687 \n", " 25 0.429666 0.904709 0.7246 \n", " 26 0.420549 0.529497 0.8317 \n", " 27 0.41769 0.601814 0.8111 \n", " 28 0.408542 1.103057 0.6798 \n", " 29 0.409291 0.856053 0.7504 \n", " 30 0.3872 0.600037 0.8025 \n", " 31 0.370547 0.717882 0.7698 \n", " 32 0.363282 0.846418 0.7516 \n", " 33 0.36301 0.602078 0.8207 \n", " 34 0.355719 0.655262 0.8023 \n", " 35 0.350565 0.579733 0.8201 \n", " 36 0.33239 0.539564 0.8233 \n", " 37 0.337597 0.554243 0.8301 \n", " 38 0.321028 0.530299 0.8364 \n", " 39 0.303657 0.45167 0.8537 \n", " 40 0.291951 0.434836 0.858 \n", " 41 0.279641 0.479449 0.8465 \n", " 42 0.269081 0.42819 0.8614 \n", " 43 0.252817 0.41228 0.868 \n", " 44 0.243981 0.418044 0.8631 \n", " 45 0.228508 0.43718 0.8616 \n", " 46 0.204227 0.376154 0.8773 \n", " 47 0.192266 0.366968 0.8845 \n", " 48 0.170918 0.36947 0.8873 \n", " 49 0.138047 0.282216 0.9124 \n", " 50 0.104735 0.255416 0.9231 \n", " 51 0.073477 0.231352 0.9331 \n", " 52 0.05243 0.218864 0.938 \n", " 53 0.044043 0.214278 0.9395 \n", " 54 0.035945 0.219941 0.9381 \n", " 55 0.030622 0.221848 0.9394 \n", " 56 0.027717 0.221275 0.9402 \n", " 57 0.023291 0.221015 0.9419 \n", " 58 0.021033 0.229324 0.9388 \n", " 59 0.018059 0.229549 0.9404 \n", " 60 0.015811 0.233008 0.9409 \n", " 61 0.014571 0.228178 0.9429 \n", " 62 0.013953 0.227541 0.9431 \n", " 63 0.012732 0.229159 0.9428 \n", " 64 0.011158 0.228971 0.9431 \n", "\n", "Finished!\n" ] }, { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "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\u001b[0m in \u001b[0;36m\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 }