{ "cells": [ { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "%matplotlib inline\n", "%reload_ext autoreload\n", "%autoreload 2" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "from fastai.conv_learner import *\n", "from fastai.dataset import *\n", "from fastai.models.resnet import vgg_resnet50\n", "\n", "import json" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "torch.cuda.set_device(2)" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "torch.backends.cudnn.benchmark=True" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Data" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "PATH = Path('data/carvana')\n", "MASKS_FN = 'train_masks.csv'\n", "META_FN = 'metadata.csv'\n", "masks_csv = pd.read_csv(PATH/MASKS_FN)\n", "meta_csv = pd.read_csv(PATH/META_FN)" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "def show_img(im, figsize=None, ax=None, alpha=None):\n", " if not ax: fig,ax = plt.subplots(figsize=figsize)\n", " ax.imshow(im, alpha=alpha)\n", " ax.set_axis_off()\n", " return ax" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "TRAIN_DN = 'train-128'\n", "MASKS_DN = 'train_masks-128'\n", "sz = 128\n", "bs = 64\n", "nw = 16" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "TRAIN_DN = 'train'\n", "MASKS_DN = 'train_masks_png'\n", "sz = 128\n", "bs = 64\n", "nw = 16" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "class MatchedFilesDataset(FilesDataset):\n", " def __init__(self, fnames, y, transform, path):\n", " self.y=y\n", " assert(len(fnames)==len(y))\n", " super().__init__(fnames, transform, path)\n", " def get_y(self, i): return open_image(os.path.join(self.path, self.y[i]))\n", " def get_c(self): return 0" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "x_names = np.array([Path(TRAIN_DN)/o for o in masks_csv['img']])\n", "y_names = np.array([Path(MASKS_DN)/f'{o[:-4]}_mask.png' for o in masks_csv['img']])" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "val_idxs = list(range(1008))\n", "((val_x,trn_x),(val_y,trn_y)) = split_by_idx(val_idxs, x_names, y_names)" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "aug_tfms = [RandomRotate(4, tfm_y=TfmType.CLASS),\n", " RandomFlip(tfm_y=TfmType.CLASS),\n", " RandomLighting(0.05, 0.05, tfm_y=TfmType.CLASS)]" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "tfms = tfms_from_model(resnet34, sz, crop_type=CropType.NO, tfm_y=TfmType.CLASS, aug_tfms=aug_tfms)\n", "datasets = ImageData.get_ds(MatchedFilesDataset, (trn_x,trn_y), (val_x,val_y), tfms, path=PATH)\n", "md = ImageData(PATH, datasets, bs, num_workers=16, classes=None)\n", "denorm = md.trn_ds.denorm" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "x,y = next(iter(md.trn_dl))" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "(torch.Size([64, 3, 128, 128]), torch.Size([64, 128, 128]))" ] }, "execution_count": null, "metadata": {}, "output_type": "execute_result" } ], "source": [ "x.shape,y.shape" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Simple upsample" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "f = resnet34\n", "cut,lr_cut = model_meta[f]" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "def get_base():\n", " layers = cut_model(f(True), cut)\n", " return nn.Sequential(*layers)" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "def dice(pred, targs):\n", " pred = (pred>0).float()\n", " return 2. * (pred*targs).sum() / (pred+targs).sum()" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "class StdUpsample(nn.Module):\n", " def __init__(self, nin, nout):\n", " super().__init__()\n", " self.conv = nn.ConvTranspose2d(nin, nout, 2, stride=2)\n", " self.bn = nn.BatchNorm2d(nout)\n", " \n", " def forward(self, x): return self.bn(F.relu(self.conv(x)))" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "class Upsample34(nn.Module):\n", " def __init__(self, rn):\n", " super().__init__()\n", " self.rn = rn\n", " self.features = nn.Sequential(\n", " rn, nn.ReLU(),\n", " StdUpsample(512,256),\n", " StdUpsample(256,256),\n", " StdUpsample(256,256),\n", " StdUpsample(256,256),\n", " nn.ConvTranspose2d(256, 1, 2, stride=2))\n", " \n", " def forward(self,x): return self.features(x)[:,0]" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "class UpsampleModel():\n", " def __init__(self,model,name='upsample'):\n", " self.model,self.name = model,name\n", "\n", " def get_layer_groups(self, precompute):\n", " lgs = list(split_by_idxs(children(self.model.rn), [lr_cut]))\n", " return lgs + [children(self.model.features)[1:]]" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "m_base = get_base()" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "m = to_gpu(Upsample34(m_base))\n", "models = UpsampleModel(m)" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "learn = ConvLearner(md, models)\n", "learn.opt_fn=optim.Adam\n", "learn.crit=nn.BCEWithLogitsLoss()\n", "learn.metrics=[accuracy_thresh(0.5),dice]" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "learn.freeze_to(1)" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [ { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "e4667e9fa899453da7cbf0a0524fb426", "version_major": 2, "version_minor": 0 }, "text/html": [ "
Failed to display Jupyter Widget of type HBox
.
\n", " If you're reading this message in the Jupyter Notebook or JupyterLab Notebook, it may mean\n", " that the widgets JavaScript is still loading. If this message persists, it\n", " likely means that the widgets JavaScript library is either not installed or\n", " not enabled. See the Jupyter\n", " Widgets Documentation for setup instructions.\n", "
\n", "\n", " If you're reading this message in another frontend (for example, a static\n", " rendering on GitHub or NBViewer),\n", " it may mean that your frontend doesn't currently support widgets.\n", "
\n" ], "text/plain": [ "HBox(children=(IntProgress(value=0, description='Epoch', max=1), HTML(value='')))" ] }, "metadata": {}, "output_type": "display_data" }, { "name": "stdout", "output_type": "stream", "text": [ " 86%|█████████████████████████████████████████████████████████████ | 55/64 [00:22<00:03, 2.46it/s, loss=3.21]" ] }, { "data": { "image/png": "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\n", "text/plain": [ "Failed to display Jupyter Widget of type HBox
.
\n", " If you're reading this message in the Jupyter Notebook or JupyterLab Notebook, it may mean\n", " that the widgets JavaScript is still loading. If this message persists, it\n", " likely means that the widgets JavaScript library is either not installed or\n", " not enabled. See the Jupyter\n", " Widgets Documentation for setup instructions.\n", "
\n", "\n", " If you're reading this message in another frontend (for example, a static\n", " rendering on GitHub or NBViewer),\n", " it may mean that your frontend doesn't currently support widgets.\n", "
\n" ], "text/plain": [ "HBox(children=(IntProgress(value=0, description='Epoch', max=1), HTML(value='')))" ] }, "metadata": {}, "output_type": "display_data" }, { "name": "stdout", "output_type": "stream", "text": [ " 0%| | 0/64 [00:00, ?it/s]\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ "Exception in thread Thread-14:\n", "Traceback (most recent call last):\n", " File \"C:\\Users\\j\\Anaconda3\\envs\\fastai\\lib\\threading.py\", line 916, in _bootstrap_inner\n", " self.run()\n", " File \"C:\\Users\\j\\Anaconda3\\envs\\fastai\\lib\\site-packages\\tqdm\\_tqdm.py\", line 144, in run\n", " for instance in self.tqdm_cls._instances:\n", " File \"C:\\Users\\j\\Anaconda3\\envs\\fastai\\lib\\_weakrefset.py\", line 60, in __iter__\n", " for itemref in self.data:\n", "RuntimeError: Set changed size during iteration\n", "\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ " 92%|█████████████████████████████████████████████████████████████████▍ | 59/64 [00:22<00:01, 2.68it/s, loss=2.45]\n" ] }, { "data": { "image/png": "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\n", "text/plain": [ "