├── workspace ├── models │ ├── __init__.py │ ├── .gitignore │ ├── layers.py │ └── wideresnet.py ├── cifar10_fastai_adamw.ipynb └── cifar10_fastai_dawnbench.ipynb ├── run_container.sh ├── data.py ├── README.md └── Dockerfile /workspace/models/__init__.py: -------------------------------------------------------------------------------- 1 | -------------------------------------------------------------------------------- /workspace/models/.gitignore: -------------------------------------------------------------------------------- 1 | *.png 2 | *.tar 3 | checkpoint* 4 | log* 5 | wgts/ 6 | -------------------------------------------------------------------------------- /run_container.sh: -------------------------------------------------------------------------------- 1 | #! /bin/bash 2 | IMAGE_NAME=$1 3 | 4 | if [[ $# -eq 0 ]] ; then 5 | echo 'ERROR: No argument passed for image name.' 6 | exit 0 7 | fi 8 | 9 | CONTAINER="docker run -id --runtime=nvidia -e NVIDIA_DRIVER_CAPABILITIES=compute,utility -e NVIDIA_VISIBLE_DEVICES=all \ 10 | --ipc=host --net=host -v $PWD/workspace/:/root/workspace $IMAGE_NAME" 11 | echo 'Starting container with commmand: '$CONTAINER 12 | eval $CONTAINER 13 | -------------------------------------------------------------------------------- /data.py: -------------------------------------------------------------------------------- 1 | import os, shutil, re 2 | from glob import glob 3 | from subprocess import run 4 | 5 | path = 'data/' 6 | for ds in ['train', 'test']: 7 | paths = glob(f'{path}cifar/{ds}/*') 8 | for cls in ('airplane', 'automobile', 'bird', 'cat', 'deer', 'dog', 'frog', 'horse', 'ship', 'truck'): 9 | run(f'mkdir -p {path}cifar10/{ds}/{cls}'.split()) 10 | for fpath in paths: 11 | cls = re.search('_(.*)\.png$', fpath).group(1) 12 | fname = re.search('\w*.png$', fpath).group(0) 13 | shutil.copy(fpath, f'{path}cifar10/{ds}/{cls}/{fname}') 14 | -------------------------------------------------------------------------------- /workspace/models/layers.py: -------------------------------------------------------------------------------- 1 | import torch 2 | from torch import nn 3 | 4 | class AdaptiveConcatPool2d(nn.Module): 5 | def __init__(self, sz=None): 6 | super().__init__() 7 | sz = sz or (1,1) 8 | self.ap = nn.AdaptiveAvgPool2d(sz) 9 | self.mp = nn.AdaptiveMaxPool2d(sz) 10 | def forward(self, x): return torch.cat([self.mp(x), self.ap(x)], 1) 11 | 12 | class Lambda(nn.Module): 13 | def __init__(self, f): super().__init__(); self.f=f 14 | def forward(self, x): return self.f(x) 15 | 16 | class Flatten(nn.Module): 17 | def __init__(self): super().__init__() 18 | def forward(self, x): return x.view(x.size(0), -1) 19 | 20 | -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- 1 | ## About 2 | 3 | This repository contains the [fastai](http://www.fast.ai) [DAWNbench](https://dawn.cs.stanford.edu/benchmark/#cifar10-train-time) result adapted to training on 1080ti. It is missing many of the optimizations that allowed the fastai team to achieve 94% accuracy in 2m 54s (no fp16, no data prefetching, etc) on an AWS p3.16xlarge instance with 8 V100 GPUs. On my box with a single 1080ti I am able to train to 94% accuracy (with TTA) in 13 minutes 30 seconds. 4 | 5 | The second notebook adapts recent work by fastai and trains with AdamW and the 1 cycle policy cutting down the number of required epochs to 18. You can read more about this approach on the [fastai blog](http://www.fast.ai/2018/07/02/adam-weight-decay/) or in the [official repositiory](https://github.com/sgugger/Adam-experiments). 6 | 7 | You will need to have [docker](https://docs.docker.com/install/linux/docker-ce/ubuntu/) and [nvidia-docker](https://github.com/NVIDIA/nvidia-docker) installed in order to run this. 8 | 9 | Once you start the docker container, all you have to do is access https://localhost:8888 and enter `jupyter` as password. Open the notebook and hit run all. 10 | 11 | For Tensorflow code please checkout the [tensorflow branch](https://github.com/radekosmulski/cifar10_docker/tree/tensorflow). The implementation there is very minimal but still might be useful as a starting point for experimenting. 12 | 13 | ## Instructions for building and running the container 14 | 1. cd into cloned repo 15 | 2. `docker build -t cifar .` 16 | 3. `./run_container.sh cifar` 17 | 18 | 19 | *SIDENOTE*: You might need to run the commands with sudo. I prefer to do the following: 20 | ``` 21 | sudo groupadd docker 22 | sudo usermod -aG docker $USER 23 | ``` 24 | (this effectively grants docker sudo powers so is not more secure than running docker with sudo) 25 | -------------------------------------------------------------------------------- /Dockerfile: -------------------------------------------------------------------------------- 1 | FROM nvidia/cuda:9.0-base 2 | LABEL maintainer="Radek Osmulski " 3 | 4 | ENV LANG=C.UTF-8 LC_ALL=C.UTF-8 5 | ENV PATH /opt/conda/bin:$PATH 6 | 7 | RUN apt-get update --fix-missing && apt-get install -y wget bzip2 ca-certificates \ 8 | libglib2.0-0 libxext6 libsm6 libxrender1 git 9 | 10 | RUN wget --quiet https://repo.continuum.io/archive/Anaconda3-5.2.0-Linux-x86_64.sh -O ~/anaconda.sh && \ 11 | /bin/bash ~/anaconda.sh -b -p /opt/conda && \ 12 | rm ~/anaconda.sh && \ 13 | ln -s /opt/conda/etc/profile.d/conda.sh /etc/profile.d/conda.sh && \ 14 | echo ". /opt/conda/etc/profile.d/conda.sh" >> ~/.bashrc && \ 15 | echo "conda activate fastai" >> ~/.bashrc 16 | 17 | WORKDIR /root 18 | 19 | RUN git clone https://github.com/fastai/fastai.git && cd fastai && conda env create 20 | 21 | # configure jupyter 22 | RUN jupyter notebook --generate-config 23 | 24 | # This will set the password on the notebook to 'jupyter'. To generate a hash corresponding to a password 25 | # of your choice, run the code below inside a Python interpreter 26 | # from notebook.auth import passwd; print(passwd()) 27 | ARG jupass=sha1:85ff16c0f1a9:c296112bf7b82121f5ec73ef4c1b9305b9e538af 28 | 29 | RUN echo "c.NotebookApp.password = u'"$jupass"'" >> $HOME/.jupyter/jupyter_notebook_config.py 30 | RUN echo "c.NotebookApp.ip = '*'\nc.NotebookApp.open_browser = False" >> $HOME/.jupyter/jupyter_notebook_config.py 31 | 32 | # create ssl cert for jupyter notebook 33 | RUN openssl req -x509 -nodes -days 365 -newkey rsa:1024 -keyout $HOME/mykey.key -out $HOME/mycert.pem -subj "/C=IE" 34 | 35 | RUN apt-get install -y curl grep sed dpkg && \ 36 | TINI_VERSION=`curl https://github.com/krallin/tini/releases/latest | grep -o "/v.*\"" | sed 's:^..\(.*\).$:\1:'` && \ 37 | curl -L "https://github.com/krallin/tini/releases/download/v${TINI_VERSION}/tini_${TINI_VERSION}.deb" > tini.deb && \ 38 | dpkg -i tini.deb && \ 39 | rm tini.deb && \ 40 | apt-get clean 41 | 42 | COPY data.py . 43 | RUN mkdir data 44 | RUN wget http://pjreddie.com/media/files/cifar.tgz -P data/ 45 | RUN tar -xf data/cifar.tgz -C data/ 46 | RUN python data.py 47 | RUN rm -rf data/cifar.tgz data/cifar 48 | 49 | VOLUME workspace /root/workspace 50 | 51 | EXPOSE 8888 52 | 53 | RUN cd fastai && /bin/bash -c "source activate fastai && python setup.py install" 54 | 55 | ENTRYPOINT [ "/usr/bin/tini", "--" ] 56 | SHELL [ "/bin/bash", "-c" ] 57 | CMD source activate fastai && jupyter notebook --certfile=mycert.pem --keyfile mykey.key --allow-root --notebook-dir='workspace' 58 | -------------------------------------------------------------------------------- /workspace/models/wideresnet.py: -------------------------------------------------------------------------------- 1 | # https://github.com/uoguelph-mlrg/Cutout 2 | 3 | import math 4 | import torch 5 | import torch.nn as nn 6 | import torch.nn.functional as F 7 | from .layers import * 8 | 9 | def conv_2d(ni, nf, ks, stride): return nn.Conv2d(ni, nf, kernel_size=ks, stride=stride, padding=ks//2, bias=False) 10 | 11 | def bn(ni, init_zero=False): 12 | m = nn.BatchNorm2d(ni) 13 | m.weight.data.fill_(0 if init_zero else 1) 14 | m.bias.data.zero_() 15 | return m 16 | 17 | def bn_relu_conv(ni, nf, ks, stride, init_zero=False): 18 | bn_initzero = bn(ni, init_zero=init_zero) 19 | return nn.Sequential(bn_initzero, nn.ReLU(inplace=True), conv_2d(ni, nf, ks, stride)) 20 | 21 | def noop(x): return x 22 | 23 | class BasicBlock(nn.Module): 24 | def __init__(self, ni, nf, stride, drop_p=0.0): 25 | super().__init__() 26 | self.bn = nn.BatchNorm2d(ni) 27 | self.conv1 = conv_2d(ni, nf, 3, stride) 28 | self.conv2 = bn_relu_conv(nf, nf, 3, 1) 29 | self.drop = nn.Dropout(drop_p, inplace=True) if drop_p else None 30 | self.shortcut = conv_2d(ni, nf, 1, stride) if ni != nf else noop 31 | 32 | def forward(self, x): 33 | x2 = F.relu(self.bn(x), inplace=True) 34 | r = self.shortcut(x2) 35 | x = self.conv1(x2) 36 | if self.drop: x = self.drop(x) 37 | x = self.conv2(x) ## * 0.2 38 | return x.add_(r) 39 | 40 | 41 | def _make_group(N, ni, nf, block, stride, drop_p): 42 | return [block(ni if i == 0 else nf, nf, stride if i == 0 else 1, drop_p) for i in range(N)] 43 | 44 | class WideResNet(nn.Module): 45 | def __init__(self, num_groups, N, num_classes, k=1, drop_p=0.0, start_nf=16): 46 | super().__init__() 47 | n_channels = [start_nf] 48 | for i in range(num_groups): n_channels.append(start_nf*(2**i)*k) 49 | 50 | layers = [conv_2d(3, n_channels[0], 3, 1)] # conv1 51 | for i in range(num_groups): 52 | layers += _make_group(N, n_channels[i], n_channels[i+1], BasicBlock, (1 if i==0 else 2), drop_p) 53 | 54 | layers += [nn.AdaptiveAvgPool2d(1), bn_relu_conv(n_channels[-1], num_classes, 1, 1), Flatten()] 55 | self.features = nn.Sequential(*layers) 56 | 57 | def forward(self, x): return self.features(x) 58 | 59 | 60 | def wrn_22(): return WideResNet(num_groups=3, N=3, num_classes=10, k=6, drop_p=0.) 61 | def wrn_22_k8(): return WideResNet(num_groups=3, N=3, num_classes=10, k=8, drop_p=0.) 62 | def wrn_22_k10(): return WideResNet(num_groups=3, N=3, num_classes=10, k=10, drop_p=0.) 63 | def wrn_22_k8_p2(): return WideResNet(num_groups=3, N=3, num_classes=10, k=8, drop_p=0.) 64 | def wrn_28(): return WideResNet(num_groups=3, N=4, num_classes=10, k=6, drop_p=0.) 65 | def wrn_28_k8(): return WideResNet(num_groups=3, N=4, num_classes=10, k=8, drop_p=0.) 66 | def wrn_28_k8_p2(): return WideResNet(num_groups=3, N=4, num_classes=10, k=8, drop_p=0.2) 67 | def wrn_28_p2(): return WideResNet(num_groups=3, N=4, num_classes=10, k=6, drop_p=0.2) 68 | 69 | -------------------------------------------------------------------------------- /workspace/cifar10_fastai_adamw.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "metadata": {}, 6 | "source": [ 7 | "https://github.com/sgugger/Adam-experiments" 8 | ] 9 | }, 10 | { 11 | "cell_type": "code", 12 | "execution_count": 1, 13 | "metadata": {}, 14 | "outputs": [], 15 | "source": [ 16 | "from fastai.conv_learner import *\n", 17 | "from fastai.models.cifar10.wideresnet import wrn_22\n", 18 | "from torchvision import transforms, datasets\n", 19 | "\n", 20 | "torch.backends.cudnn.benchmark = True\n", 21 | "PATH = Path(\"../data/cifar10\")" 22 | ] 23 | }, 24 | { 25 | "cell_type": "code", 26 | "execution_count": 2, 27 | "metadata": {}, 28 | "outputs": [], 29 | "source": [ 30 | "classes = ('plane', 'car', 'bird', 'cat', 'deer', 'dog', 'frog', 'horse', 'ship', 'truck')\n", 31 | "stats = (np.array([ 0.4914 , 0.48216, 0.44653]), np.array([ 0.24703, 0.24349, 0.26159]))" 32 | ] 33 | }, 34 | { 35 | "cell_type": "code", 36 | "execution_count": 3, 37 | "metadata": {}, 38 | "outputs": [ 39 | { 40 | "data": { 41 | "text/plain": [ 42 | "[8.325000000000001, 8.325000000000001, 1.3499999999999999]" 43 | ] 44 | }, 45 | "execution_count": 3, 46 | "metadata": {}, 47 | "output_type": "execute_result" 48 | } 49 | ], 50 | "source": [ 51 | "sz = 32\n", 52 | "bs = 128\n", 53 | "\n", 54 | "m = wrn_22()\n", 55 | "base_lr = 3e-3\n", 56 | "lr_div = 10\n", 57 | "wd = 0.1\n", 58 | "cyc_len = 18 # lenght of the cycle expressed in epochs\n", 59 | "ann_len = 0.075 # length of the annealing phase expressed as a fraction of cycle_len\n", 60 | "\n", 61 | "moms = (0.95,0.85)\n", 62 | "beta2=0.99\n", 63 | "\n", 64 | "phase_lengths = [cyc_len * (1-ann_len) / 2, cyc_len * (1-ann_len) / 2, cyc_len * ann_len]; phase_lengths" 65 | ] 66 | }, 67 | { 68 | "cell_type": "code", 69 | "execution_count": 4, 70 | "metadata": {}, 71 | "outputs": [], 72 | "source": [ 73 | "tfms = tfms_from_stats(stats, sz, aug_tfms=[RandomCrop(sz), RandomFlip()], pad=sz//8)\n", 74 | "data = ImageClassifierData.from_paths(PATH, val_name='test', tfms=tfms, bs=bs)" 75 | ] 76 | }, 77 | { 78 | "cell_type": "code", 79 | "execution_count": 5, 80 | "metadata": {}, 81 | "outputs": [], 82 | "source": [ 83 | "learn = ConvLearner.from_model_data(m, data)\n", 84 | "learn.crit = nn.CrossEntropyLoss()\n", 85 | "learn.metrics = [accuracy]" 86 | ] 87 | }, 88 | { 89 | "cell_type": "code", 90 | "execution_count": 6, 91 | "metadata": {}, 92 | "outputs": [], 93 | "source": [ 94 | "def adam(params): return optim.Adam(params, betas=(moms[0], beta2))\n", 95 | "learn.opt_fn = adam" 96 | ] 97 | }, 98 | { 99 | "cell_type": "code", 100 | "execution_count": 7, 101 | "metadata": {}, 102 | "outputs": [], 103 | "source": [ 104 | "training_phases = [\n", 105 | " TrainingPhase(phase_lengths[0], adam, lr=(base_lr/lr_div, base_lr), lr_decay=DecayType.LINEAR,\n", 106 | " momentum=moms, momentum_decay=DecayType.LINEAR, wds=wd, wd_loss=False),\n", 107 | " TrainingPhase(phase_lengths[1], adam, lr=(base_lr, base_lr/lr_div), lr_decay=DecayType.LINEAR,\n", 108 | " momentum=(moms[1], moms[0]), momentum_decay=DecayType.LINEAR, wds=wd, wd_loss=False),\n", 109 | " TrainingPhase(phase_lengths[2], adam, lr=(base_lr/lr_div, base_lr/(lr_div*100)), lr_decay=DecayType.LINEAR,\n", 110 | " momentum=moms[0], wds=wd, wd_loss=False)\n", 111 | "]" 112 | ] 113 | }, 114 | { 115 | "cell_type": "code", 116 | "execution_count": 8, 117 | "metadata": {}, 118 | "outputs": [ 119 | { 120 | "data": { 121 | "application/vnd.jupyter.widget-view+json": { 122 | "model_id": "c7799a4443764a56933f1a03d49b963e", 123 | "version_major": 2, 124 | "version_minor": 0 125 | }, 126 | "text/plain": [ 127 | "HBox(children=(IntProgress(value=0, description='Epoch', max=19), HTML(value='')))" 128 | ] 129 | }, 130 | "metadata": {}, 131 | "output_type": "display_data" 132 | }, 133 | { 134 | "name": "stdout", 135 | "output_type": "stream", 136 | "text": [ 137 | "epoch trn_loss val_loss accuracy \n", 138 | " 0 1.075619 1.015231 0.6435 \n", 139 | " 1 0.82483 1.034227 0.6552 \n", 140 | " 2 0.712239 0.651429 0.7754 \n", 141 | " 3 0.631517 0.575336 0.8018 \n", 142 | " 4 0.576791 0.651911 0.7742 \n", 143 | " 5 0.504203 0.59719 0.8013 \n", 144 | " 6 0.480576 0.686073 0.783 \n", 145 | " 7 0.443939 0.546567 0.8209 \n", 146 | " 8 0.414961 0.459819 0.8399 \n", 147 | " 9 0.348353 0.403022 0.8628 \n", 148 | " 10 0.31422 0.407295 0.8618 \n", 149 | " 11 0.257251 0.336791 0.8856 \n", 150 | " 12 0.237165 0.294243 0.9005 \n", 151 | " 13 0.183506 0.286957 0.9054 \n", 152 | " 14 0.14385 0.243615 0.9206 \n", 153 | " 15 0.108258 0.231928 0.9284 \n", 154 | " 16 0.074345 0.217072 0.9322 \n", 155 | " 17 0.050736 0.212466 0.936 \n", 156 | "CPU times: user 14min 39s, sys: 7min 35s, total: 22min 15s\n", 157 | "Wall time: 15min 59s\n" 158 | ] 159 | }, 160 | { 161 | "data": { 162 | "text/plain": [ 163 | "[array([0.21247]), 0.936]" 164 | ] 165 | }, 166 | "execution_count": 8, 167 | "metadata": {}, 168 | "output_type": "execute_result" 169 | } 170 | ], 171 | "source": [ 172 | "%time learn.fit_opt_sched(training_phases)" 173 | ] 174 | }, 175 | { 176 | "cell_type": "code", 177 | "execution_count": 9, 178 | "metadata": {}, 179 | "outputs": [ 180 | { 181 | "name": "stdout", 182 | "output_type": "stream", 183 | "text": [ 184 | " \r" 185 | ] 186 | }, 187 | { 188 | "data": { 189 | "text/plain": [ 190 | "'Final loss: 0.17752112448215485, Final accuracy: 0.9394999742507935'" 191 | ] 192 | }, 193 | "execution_count": 9, 194 | "metadata": {}, 195 | "output_type": "execute_result" 196 | } 197 | ], 198 | "source": [ 199 | "preds, targs = learn.TTA()\n", 200 | "probs = np.exp(preds)/np.exp(preds).sum(2)[:,:,None]\n", 201 | "probs = np.mean(probs,0)\n", 202 | "acc = learn.metrics[0](V(probs), V(targs)).data[0]\n", 203 | "loss = learn.crit(V(np.log(probs)), V(targs)).data[0]\n", 204 | "f'Final loss: {loss}, Final accuracy: {acc}'" 205 | ] 206 | }, 207 | { 208 | "cell_type": "code", 209 | "execution_count": 10, 210 | "metadata": {}, 211 | "outputs": [ 212 | { 213 | "data": { 214 | "image/png": "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\n", 215 | "text/plain": [ 216 | "
" 217 | ] 218 | }, 219 | "metadata": {}, 220 | "output_type": "display_data" 221 | } 222 | ], 223 | "source": [ 224 | "learn.sched.plot_loss()" 225 | ] 226 | }, 227 | { 228 | "cell_type": "code", 229 | "execution_count": 11, 230 | "metadata": {}, 231 | "outputs": [ 232 | { 233 | "data": { 234 | "image/png": "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\n", 235 | "text/plain": [ 236 | "
" 237 | ] 238 | }, 239 | "metadata": {}, 240 | "output_type": "display_data" 241 | } 242 | ], 243 | "source": [ 244 | "learn.sched.plot_lr()" 245 | ] 246 | } 247 | ], 248 | "metadata": { 249 | "kernelspec": { 250 | "display_name": "Python 3", 251 | "language": "python", 252 | "name": "python3" 253 | }, 254 | "language_info": { 255 | "codemirror_mode": { 256 | "name": "ipython", 257 | "version": 3 258 | }, 259 | "file_extension": ".py", 260 | "mimetype": "text/x-python", 261 | "name": "python", 262 | "nbconvert_exporter": "python", 263 | "pygments_lexer": "ipython3", 264 | "version": "3.6.5" 265 | } 266 | }, 267 | "nbformat": 4, 268 | "nbformat_minor": 2 269 | } 270 | -------------------------------------------------------------------------------- /workspace/cifar10_fastai_dawnbench.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "metadata": {}, 6 | "source": [ 7 | "https://github.com/fastai/imagenet-fast/tree/master/cifar10/dawn_submission" 8 | ] 9 | }, 10 | { 11 | "cell_type": "code", 12 | "execution_count": 1, 13 | "metadata": {}, 14 | "outputs": [], 15 | "source": [ 16 | "from fastai.conv_learner import *\n", 17 | "from models.wideresnet import wrn_22 # this is the models directory from the fastai/imagenet-fast repo\n", 18 | "from torchvision import transforms, datasets\n", 19 | "\n", 20 | "torch.backends.cudnn.benchmark = True\n", 21 | "PATH = Path(\"../data/cifar10\")" 22 | ] 23 | }, 24 | { 25 | "cell_type": "code", 26 | "execution_count": 2, 27 | "metadata": {}, 28 | "outputs": [], 29 | "source": [ 30 | "classes = ('plane', 'car', 'bird', 'cat', 'deer', 'dog', 'frog', 'horse', 'ship', 'truck')\n", 31 | "stats = (np.array([ 0.4914 , 0.48216, 0.44653]), np.array([ 0.24703, 0.24349, 0.26159]))" 32 | ] 33 | }, 34 | { 35 | "cell_type": "markdown", 36 | "metadata": {}, 37 | "source": [ 38 | "We construct the data object manually from low level components in a way that can be used with the fastai library." 39 | ] 40 | }, 41 | { 42 | "cell_type": "code", 43 | "execution_count": 3, 44 | "metadata": {}, 45 | "outputs": [], 46 | "source": [ 47 | "def get_loaders(bs, num_workers):\n", 48 | " traindir = str(PATH/'train')\n", 49 | " valdir = str(PATH/'test')\n", 50 | " tfms = [transforms.ToTensor(),\n", 51 | " transforms.Normalize((0.4914, 0.4822, 0.4465), (0.2023, 0.1994, 0.2010))]\n", 52 | "\n", 53 | " aug_tfms =transforms.Compose([\n", 54 | " transforms.RandomCrop(32, padding=4),\n", 55 | " transforms.RandomHorizontalFlip(),\n", 56 | " ] + tfms)\n", 57 | " \n", 58 | " train_dataset = datasets.ImageFolder(\n", 59 | " traindir,\n", 60 | " aug_tfms)\n", 61 | "\n", 62 | " train_loader = torch.utils.data.DataLoader(\n", 63 | " train_dataset, batch_size=bs, shuffle=True, num_workers=num_workers, pin_memory=True)\n", 64 | "\n", 65 | " val_dataset = datasets.ImageFolder(valdir, transforms.Compose(tfms))\n", 66 | "\n", 67 | " val_loader = torch.utils.data.DataLoader(\n", 68 | " val_dataset, batch_size=bs, shuffle=False, num_workers=num_workers, pin_memory=True)\n", 69 | " \n", 70 | " aug_dataset = datasets.ImageFolder(valdir, aug_tfms)\n", 71 | "\n", 72 | " aug_loader = torch.utils.data.DataLoader(\n", 73 | " aug_dataset, batch_size=bs, shuffle=False, num_workers=num_workers, pin_memory=True)\n", 74 | " \n", 75 | " return train_loader, val_loader, aug_loader" 76 | ] 77 | }, 78 | { 79 | "cell_type": "code", 80 | "execution_count": 4, 81 | "metadata": {}, 82 | "outputs": [], 83 | "source": [ 84 | "def get_data(bs, num_workers):\n", 85 | " trn_dl, val_dl, aug_dl = get_loaders(bs, num_workers)\n", 86 | " data = ModelData(PATH, trn_dl, val_dl)\n", 87 | " data.aug_dl = aug_dl\n", 88 | " data.sz=32\n", 89 | " return data" 90 | ] 91 | }, 92 | { 93 | "cell_type": "code", 94 | "execution_count": 5, 95 | "metadata": {}, 96 | "outputs": [], 97 | "source": [ 98 | "def get_learner(arch, bs):\n", 99 | " learn = ConvLearner.from_model_data(arch.cuda(), get_data(bs, num_cpus()))\n", 100 | " learn.crit = nn.CrossEntropyLoss()\n", 101 | " learn.metrics = [accuracy]\n", 102 | " return learn" 103 | ] 104 | }, 105 | { 106 | "cell_type": "code", 107 | "execution_count": 6, 108 | "metadata": {}, 109 | "outputs": [], 110 | "source": [ 111 | "def get_TTA_accuracy(learn):\n", 112 | " preds, targs = learn.TTA()\n", 113 | " # combining the predictions across augmented and non augmented inputs\n", 114 | " preds = 0.6 * preds[0] + 0.4 * preds[1:].sum(0)\n", 115 | " return accuracy_np(preds, targs)" 116 | ] 117 | }, 118 | { 119 | "cell_type": "markdown", 120 | "metadata": {}, 121 | "source": [ 122 | "## fastai DAWN bench submission " 123 | ] 124 | }, 125 | { 126 | "cell_type": "markdown", 127 | "metadata": {}, 128 | "source": [ 129 | "This I believe is the original FastAI DAWN bench submission in terms of the architecture and the training parameters." 130 | ] 131 | }, 132 | { 133 | "cell_type": "code", 134 | "execution_count": 7, 135 | "metadata": {}, 136 | "outputs": [ 137 | { 138 | "data": { 139 | "application/vnd.jupyter.widget-view+json": { 140 | "model_id": "f309ae504202482296bac8751d999e9b", 141 | "version_major": 2, 142 | "version_minor": 0 143 | }, 144 | "text/plain": [ 145 | "HBox(children=(IntProgress(value=0, description='Epoch', max=1), HTML(value='')))" 146 | ] 147 | }, 148 | "metadata": {}, 149 | "output_type": "display_data" 150 | }, 151 | { 152 | "name": "stdout", 153 | "output_type": "stream", 154 | "text": [ 155 | "epoch trn_loss val_loss accuracy \n", 156 | " 0 2.406675 6239621.644 0.1 \n", 157 | "\n" 158 | ] 159 | }, 160 | { 161 | "data": { 162 | "image/png": "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\n", 163 | "text/plain": [ 164 | "
" 165 | ] 166 | }, 167 | "metadata": {}, 168 | "output_type": "display_data" 169 | } 170 | ], 171 | "source": [ 172 | "learn = get_learner(wrn_22(), 512)\n", 173 | "learn.lr_find(wds=1e-4)\n", 174 | "learn.clip = 1e-1\n", 175 | "learn.sched.plot(n_skip_end=1)" 176 | ] 177 | }, 178 | { 179 | "cell_type": "code", 180 | "execution_count": 8, 181 | "metadata": {}, 182 | "outputs": [ 183 | { 184 | "data": { 185 | "application/vnd.jupyter.widget-view+json": { 186 | "model_id": "5e57e2ab22e747ff85df0ac78e090a0b", 187 | "version_major": 2, 188 | "version_minor": 0 189 | }, 190 | "text/plain": [ 191 | "HBox(children=(IntProgress(value=0, description='Epoch', max=30), HTML(value='')))" 192 | ] 193 | }, 194 | "metadata": {}, 195 | "output_type": "display_data" 196 | }, 197 | { 198 | "name": "stdout", 199 | "output_type": "stream", 200 | "text": [ 201 | "epoch trn_loss val_loss accuracy \n", 202 | " 0 1.600993 1.441529 0.4754 \n", 203 | " 1 1.188086 1.41085 0.5334 \n", 204 | " 2 0.910884 1.36183 0.5558 \n", 205 | " 4 0.611622 0.841227 0.7221 \n", 206 | " 5 0.552191 0.764714 0.7504 \n", 207 | " 6 0.503751 0.737051 0.7511 \n", 208 | " 7 0.460971 0.653494 0.7825 \n", 209 | " 8 0.429952 1.264751 0.6541 \n", 210 | " 9 0.397564 0.723189 0.7511 \n", 211 | " 10 0.37606 0.683567 0.7782 \n", 212 | " 11 0.360873 0.577565 0.7981 \n", 213 | " 12 0.341871 0.695879 0.7759 \n", 214 | " 13 0.323827 0.59713 0.798 \n", 215 | " 14 0.304483 0.473728 0.8451 \n", 216 | " 15 0.28388 0.555944 0.816 \n", 217 | " 16 0.257587 0.87107 0.7456 \n", 218 | " 17 0.242033 0.422021 0.8581 \n", 219 | " 18 0.228757 0.405375 0.8638 \n", 220 | " 19 0.21638 0.411791 0.8625 \n", 221 | " 20 0.197131 0.412363 0.8628 \n", 222 | " 21 0.179344 0.389317 0.8746 \n", 223 | " 22 0.165843 0.392866 0.8762 \n", 224 | " 23 0.144036 0.327264 0.8986 \n", 225 | " 24 0.120298 0.339279 0.8942 \n", 226 | " 25 0.096919 0.281939 0.9124 \n", 227 | " 26 0.069822 0.235627 0.9279 \n", 228 | " 27 0.046569 0.21313 0.9368 \n", 229 | " 28 0.029652 0.209425 0.939 \n", 230 | " 29 0.019703 0.201688 0.9419 \n", 231 | "\n", 232 | "CPU times: user 10min 14s, sys: 8min 33s, total: 18min 47s\n", 233 | "Wall time: 18min 54s\n" 234 | ] 235 | }, 236 | { 237 | "data": { 238 | "text/plain": [ 239 | "[array([0.20169]), 0.9419000004768372]" 240 | ] 241 | }, 242 | "execution_count": 8, 243 | "metadata": {}, 244 | "output_type": "execute_result" 245 | } 246 | ], 247 | "source": [ 248 | "%time learn.fit(1.5, 1, wds=1e-4, cycle_len=30, use_clr_beta=(15, 10, 0.95, 0.85))" 249 | ] 250 | }, 251 | { 252 | "cell_type": "code", 253 | "execution_count": 9, 254 | "metadata": {}, 255 | "outputs": [ 256 | { 257 | "name": "stdout", 258 | "output_type": "stream", 259 | "text": [ 260 | " \r" 261 | ] 262 | }, 263 | { 264 | "data": { 265 | "text/plain": [ 266 | "0.948" 267 | ] 268 | }, 269 | "execution_count": 9, 270 | "metadata": {}, 271 | "output_type": "execute_result" 272 | } 273 | ], 274 | "source": [ 275 | "get_TTA_accuracy(learn)" 276 | ] 277 | }, 278 | { 279 | "cell_type": "markdown", 280 | "metadata": {}, 281 | "source": [ 282 | "## With tweaks for training locally on a 1080ti " 283 | ] 284 | }, 285 | { 286 | "cell_type": "markdown", 287 | "metadata": {}, 288 | "source": [ 289 | "I run the training 3 times just to make sure we hit 94% accuracy with some degree of reliability." 290 | ] 291 | }, 292 | { 293 | "cell_type": "code", 294 | "execution_count": 10, 295 | "metadata": {}, 296 | "outputs": [ 297 | { 298 | "data": { 299 | "application/vnd.jupyter.widget-view+json": { 300 | "model_id": "55a183b9bbe341709b7e12f31492b923", 301 | "version_major": 2, 302 | "version_minor": 0 303 | }, 304 | "text/plain": [ 305 | "HBox(children=(IntProgress(value=0, description='Epoch', max=20), HTML(value='')))" 306 | ] 307 | }, 308 | "metadata": {}, 309 | "output_type": "display_data" 310 | }, 311 | { 312 | "name": "stdout", 313 | "output_type": "stream", 314 | "text": [ 315 | "epoch trn_loss val_loss accuracy \n", 316 | " 0 1.169543 1.263701 0.5503 \n", 317 | " 1 0.908752 1.154146 0.6011 \n", 318 | " 2 0.771108 0.912175 0.6869 \n", 319 | " 3 0.676908 0.793713 0.7236 \n", 320 | " 4 0.628075 0.736298 0.7481 \n", 321 | " 5 0.585728 0.812324 0.7084 \n", 322 | " 6 0.556467 0.958268 0.682 \n", 323 | " 7 0.553127 0.802786 0.7342 \n", 324 | " 8 0.537662 0.661663 0.7748 \n", 325 | " 9 0.503087 0.917536 0.7149 \n", 326 | " 10 0.482562 0.680255 0.7792 \n", 327 | " 11 0.448644 0.824123 0.7396 \n", 328 | " 12 0.420774 0.750203 0.7668 \n", 329 | " 13 0.393915 0.505999 0.8259 \n", 330 | " 14 0.365846 0.544087 0.8179 \n", 331 | " 15 0.328399 0.416165 0.8565 \n", 332 | " 16 0.238594 0.296919 0.8999 \n", 333 | " 17 0.1871 0.245863 0.9157 \n", 334 | " 18 0.134778 0.218889 0.9252 \n", 335 | " 19 0.104386 0.188387 0.9381 \n", 336 | "\n", 337 | "CPU times: user 8min 2s, sys: 5min 24s, total: 13min 27s\n", 338 | "Wall time: 13min 16s\n" 339 | ] 340 | } 341 | ], 342 | "source": [ 343 | "%%time\n", 344 | "learn = get_learner(wrn_22(), 128)\n", 345 | "learn.clip = 1e-1\n", 346 | "learn.fit(1.5, 1, wds=1e-4, cycle_len=20, use_clr_beta=(12, 15, 0.95, 0.85))" 347 | ] 348 | }, 349 | { 350 | "cell_type": "code", 351 | "execution_count": 11, 352 | "metadata": {}, 353 | "outputs": [ 354 | { 355 | "name": "stdout", 356 | "output_type": "stream", 357 | "text": [ 358 | " \r" 359 | ] 360 | }, 361 | { 362 | "data": { 363 | "text/plain": [ 364 | "0.9431" 365 | ] 366 | }, 367 | "execution_count": 11, 368 | "metadata": {}, 369 | "output_type": "execute_result" 370 | } 371 | ], 372 | "source": [ 373 | "get_TTA_accuracy(learn)" 374 | ] 375 | }, 376 | { 377 | "cell_type": "code", 378 | "execution_count": 12, 379 | "metadata": {}, 380 | "outputs": [ 381 | { 382 | "data": { 383 | "application/vnd.jupyter.widget-view+json": { 384 | "model_id": "84d7e3ce03484d649dbf13a7503fc79b", 385 | "version_major": 2, 386 | "version_minor": 0 387 | }, 388 | "text/plain": [ 389 | "HBox(children=(IntProgress(value=0, description='Epoch', max=20), HTML(value='')))" 390 | ] 391 | }, 392 | "metadata": {}, 393 | "output_type": "display_data" 394 | }, 395 | { 396 | "name": "stdout", 397 | "output_type": "stream", 398 | "text": [ 399 | "epoch trn_loss val_loss accuracy \n", 400 | " 0 1.208857 1.557635 0.5105 \n", 401 | " 1 0.928309 1.364705 0.5856 \n", 402 | " 2 0.7586 0.78556 0.7276 \n", 403 | " 3 0.671309 0.965542 0.6779 \n", 404 | " 4 0.629488 0.748223 0.7472 \n", 405 | " 5 0.567147 0.801228 0.7312 \n", 406 | " 6 0.555923 1.104574 0.651 \n", 407 | " 7 0.55037 0.768465 0.7412 \n", 408 | " 8 0.52509 1.087103 0.668 \n", 409 | " 9 0.510132 0.814182 0.7428 \n", 410 | " 10 0.474 1.115937 0.6912 \n", 411 | " 11 0.464195 0.84923 0.7256 \n", 412 | " 12 0.439663 0.473122 0.8399 \n", 413 | " 13 0.405162 0.6486 0.7843 \n", 414 | " 14 0.365501 0.469936 0.841 \n", 415 | " 15 0.322079 0.389312 0.8637 \n", 416 | " 16 0.250046 0.293756 0.8955 \n", 417 | " 17 0.189786 0.25931 0.9132 \n", 418 | " 18 0.139936 0.211995 0.9271 \n", 419 | " 19 0.094604 0.196974 0.9338 \n", 420 | "\n", 421 | "CPU times: user 8min 1s, sys: 5min 25s, total: 13min 27s\n", 422 | "Wall time: 13min 15s\n" 423 | ] 424 | } 425 | ], 426 | "source": [ 427 | "%%time\n", 428 | "learn = get_learner(wrn_22(), 128)\n", 429 | "learn.clip = 1e-1\n", 430 | "learn.fit(1.5, 1, wds=1e-4, cycle_len=20, use_clr_beta=(12, 15, 0.95, 0.85))" 431 | ] 432 | }, 433 | { 434 | "cell_type": "code", 435 | "execution_count": 13, 436 | "metadata": {}, 437 | "outputs": [ 438 | { 439 | "name": "stdout", 440 | "output_type": "stream", 441 | "text": [ 442 | " \r" 443 | ] 444 | }, 445 | { 446 | "data": { 447 | "text/plain": [ 448 | "0.9402" 449 | ] 450 | }, 451 | "execution_count": 13, 452 | "metadata": {}, 453 | "output_type": "execute_result" 454 | } 455 | ], 456 | "source": [ 457 | "get_TTA_accuracy(learn)" 458 | ] 459 | }, 460 | { 461 | "cell_type": "code", 462 | "execution_count": 14, 463 | "metadata": {}, 464 | "outputs": [ 465 | { 466 | "data": { 467 | "application/vnd.jupyter.widget-view+json": { 468 | "model_id": "c89dc22f1fc74dbd956cadd18f13d82e", 469 | "version_major": 2, 470 | "version_minor": 0 471 | }, 472 | "text/plain": [ 473 | "HBox(children=(IntProgress(value=0, description='Epoch', max=20), HTML(value='')))" 474 | ] 475 | }, 476 | "metadata": {}, 477 | "output_type": "display_data" 478 | }, 479 | { 480 | "name": "stdout", 481 | "output_type": "stream", 482 | "text": [ 483 | "epoch trn_loss val_loss accuracy \n", 484 | " 0 1.215059 1.240503 0.5669 \n", 485 | " 1 0.899173 1.022645 0.6619 \n", 486 | " 2 0.75076 0.80045 0.7308 \n", 487 | " 3 0.676683 0.960973 0.6804 \n", 488 | " 4 0.604371 0.844541 0.7308 \n", 489 | " 5 0.579993 0.923703 0.6962 \n", 490 | " 6 0.549273 0.74115 0.7459 \n", 491 | " 7 0.538123 0.842362 0.718 \n", 492 | " 8 0.52504 1.040526 0.6702 \n", 493 | " 9 0.500089 0.84092 0.731 \n", 494 | " 10 0.464431 0.546925 0.819 \n", 495 | " 11 0.444645 0.758121 0.7587 \n", 496 | " 12 0.422681 0.573507 0.8074 \n", 497 | " 13 0.396939 0.584204 0.8102 \n", 498 | " 14 0.377264 0.599833 0.8012 \n", 499 | " 15 0.312021 0.511016 0.8347 \n", 500 | " 16 0.231998 0.320775 0.8931 \n", 501 | " 17 0.184563 0.250778 0.9159 \n", 502 | " 18 0.13895 0.214737 0.9272 \n", 503 | " 19 0.100409 0.196783 0.9358 \n", 504 | "\n", 505 | "CPU times: user 8min 1s, sys: 5min 26s, total: 13min 27s\n", 506 | "Wall time: 13min 15s\n" 507 | ] 508 | } 509 | ], 510 | "source": [ 511 | "%%time\n", 512 | "learn = get_learner(wrn_22(), 128)\n", 513 | "learn.clip = 1e-1\n", 514 | "learn.fit(1.5, 1, wds=1e-4, cycle_len=20, use_clr_beta=(12, 15, 0.95, 0.85))" 515 | ] 516 | }, 517 | { 518 | "cell_type": "code", 519 | "execution_count": 15, 520 | "metadata": {}, 521 | "outputs": [ 522 | { 523 | "name": "stdout", 524 | "output_type": "stream", 525 | "text": [ 526 | " \r" 527 | ] 528 | }, 529 | { 530 | "data": { 531 | "text/plain": [ 532 | "0.9416" 533 | ] 534 | }, 535 | "execution_count": 15, 536 | "metadata": {}, 537 | "output_type": "execute_result" 538 | } 539 | ], 540 | "source": [ 541 | "get_TTA_accuracy(learn)" 542 | ] 543 | }, 544 | { 545 | "cell_type": "code", 546 | "execution_count": 16, 547 | "metadata": {}, 548 | "outputs": [ 549 | { 550 | "data": { 551 | "image/png": "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\n", 552 | "text/plain": [ 553 | "
" 554 | ] 555 | }, 556 | "metadata": {}, 557 | "output_type": "display_data" 558 | } 559 | ], 560 | "source": [ 561 | "learn.sched.plot_loss()" 562 | ] 563 | }, 564 | { 565 | "cell_type": "code", 566 | "execution_count": 17, 567 | "metadata": {}, 568 | "outputs": [ 569 | { 570 | "data": { 571 | "image/png": "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\n", 572 | "text/plain": [ 573 | "
" 574 | ] 575 | }, 576 | "metadata": {}, 577 | "output_type": "display_data" 578 | } 579 | ], 580 | "source": [ 581 | "learn.sched.plot_lr()" 582 | ] 583 | } 584 | ], 585 | "metadata": { 586 | "kernelspec": { 587 | "display_name": "Python 3", 588 | "language": "python", 589 | "name": "python3" 590 | }, 591 | "language_info": { 592 | "codemirror_mode": { 593 | "name": "ipython", 594 | "version": 3 595 | }, 596 | "file_extension": ".py", 597 | "mimetype": "text/x-python", 598 | "name": "python", 599 | "nbconvert_exporter": "python", 600 | "pygments_lexer": "ipython3", 601 | "version": "3.6.5" 602 | } 603 | }, 604 | "nbformat": 4, 605 | "nbformat_minor": 2 606 | } 607 | --------------------------------------------------------------------------------