{"cells":[{"metadata":{},"cell_type":"markdown","source":"## Loading Libraries"},{"metadata":{"_cell_guid":"b1076dfc-b9ad-4769-8c92-a6c4dae69d19","_uuid":"8f2839f25d086af736a60e9eeb907d3b93b6e0e5","trusted":true},"cell_type":"code","source":"import os\n\nimport numpy as np\nfrom numpy.random import choice\nimport pandas as pd\nimport matplotlib.pyplot as plt\n%matplotlib inline\n\nimport time\n\nimport PIL\n\nimport torch\nfrom torch import nn, Tensor\nfrom torch.utils.data import Dataset, DataLoader\nfrom torchvision import transforms, models\nimport torchvision\n\n\n# For AUC:\nfrom sklearn.metrics import roc_auc_score\n\n\nnp.random.seed(42)","execution_count":null,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"## Helper functions\n### Timing"},{"metadata":{"trusted":true},"cell_type":"code","source":"def function_timer(function):\n    \n    def wrapper(*args, **kwargs):\n        start    = time.time()\n        result   = function(*args, **kwargs)\n        duration = time.time() - start\n        \n        hours    = int(duration // 60**2)\n        minutes  = int((duration % 60**2) // 60)  \n        seconds  = int(duration % 60)\n        print(f'execution-time of function \"{function.__name__}\": {hours}h {minutes}m {seconds}s')\n        \n        return result\n        \n    return wrapper\n","execution_count":null,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"### Plot learning curves"},{"metadata":{"trusted":true},"cell_type":"code","source":"def plot_error_curves(errors_over_time: list, error_name='error'):\n    \"\"\"\n    @ errors_over_time: list of tuples: (training-error, validation-error)\n    \"\"\"\n\n    if len(errors_over_time) <= 1:\n        print(f'Require at least two data-poits for plotting. Got {len(errors_over_time)}.')\n        return 0\n    \n    error_train, error_validation = zip(*errors_over_time)\n\n    plt.plot(range(len(error_train)), error_train)\n    plt.plot(range(len(error_validation)), error_validation)\n    plt.xticks(range(0, len(error_train) + 1, len(error_train) // 2))\n    plt.xlabel('epoch')\n    plt.ylabel(f'{error_name}')\n    plt.legend(('training', 'validation'))\n    plt.title(f'{error_name} over time')\n    plt.show();","execution_count":null,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"# Data preparation\n## Set directories and train/validaton split"},{"metadata":{"_cell_guid":"79c7e3d0-c299-4dcb-8224-4455121ee9b0","_uuid":"d629ff2d2480ee46fbb7e2d37f6b5fab8052498a","trusted":true},"cell_type":"code","source":"DATA_DIR = '../input'\n\ntrain_dir = os.path.join(DATA_DIR, 'train')\ntest_dir  = os.path.join(DATA_DIR, 'test')\n\n\ndef train_validation_split(df, val_fraction=0.1):\n    val_ids  = np.random.choice(df.id, size=int(len(df) * val_fraction))\n    val_df   = df.query('id     in @val_ids')\n    train_df = df.query('id not in @val_ids')\n    return train_df, val_df\n\n\ntrain_label_df, val_label_df = train_validation_split(pd.read_csv(os.path.join(DATA_DIR, 'train_labels.csv')),\n                                                      val_fraction=0.1)","execution_count":null,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"## Dataset Class"},{"metadata":{"trusted":true},"cell_type":"code","source":"class HistoPatches(Dataset):\n    \n    def __init__(self,\n                 image_dir: str,\n                 label_df=None,\n                 transform=transforms.ToTensor(),\n                 sample_n=None,\n                 in_memory=False):\n        \"\"\"\n        @ image_dir:   path to directory with images\n        @ label_df:    df with image id (str) and label (0/1) - only for labeled test-set\n        @ transforms:  image transformation; by default no transformation\n        @ sample_n:    if not None, only use that many observations\n        \"\"\"\n        self.image_dir = image_dir\n        self.img_files = os.listdir(image_dir)\n        self.label_df  = label_df\n        self.transform = transform\n        self.in_memory = in_memory\n        \n        if sample_n and label_df is None:\n            print('subsampling is currently only implemented when a label-dataframe is provided.')\n            print('(because training- and validation-set share the same image directory')\n            print('and the test-set does not need to be subsampled)')\n        elif sample_n:\n            self.label_df  = self.label_df.sample(n=sample_n)\n            ids            = set(self.label_df.id)\n            self.img_files = [f for f in self.img_files if f.split('.')[0] in ids]\n            \n        #self.label_df = self.label_df.reset_index(drop=True)\n            \n        if in_memory:\n            self.id2image = self._load_images()\n\n        print(f'Initialized datatset with {len(self.img_files)} images.\\n')\n        \n    @function_timer\n    def _load_images(self):\n        print('loading images in memory...')\n        id2image = {}\n        \n        for file_name in self.img_files:\n            img = PIL.Image.open(os.path.join(self.image_dir, file_name))\n            X   = self.transform(img)\n            id_ = file_name.split('.')[0]\n            id2image[id_] = X\n            \n        return id2image\n    \n    def __getitem__(self, idx):\n        file_name = self.img_files[idx]\n        id_ = file_name.split('.')[0]\n        \n        #row = self.label_df.iloc[idx]\n        #assert row.label == self.label_df.loc[idx].label\n        #y   = float(row.label)\n        \n        if self.in_memory:\n            X = self.id2image[id_]\n        else:\n            img = PIL.Image.open(os.path.join(self.image_dir, file_name))\n            X   = self.transform(img)\n            \n        if self.label_df is not None:\n            y = float(self.label_df.query('id == @id_').label)\n            return X, y\n        else:\n            return X, id_\n    \n    def __len__(self):\n        return len(self.img_files)\n    \n","execution_count":null,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"## Load Data into RAM"},{"metadata":{"trusted":true},"cell_type":"code","source":"image_trans = transforms.Compose([#transforms.CenterCrop(30),\n                                  transforms.ToTensor(),\n                                  transforms.Normalize(mean=[0.70017236, 0.5436771, 0.6961061], \n                                                       std=[0.22246036, 0.26757348, 0.19798167])\n                                 ])\nmemory      = True\nbatchsize   = 64\n\ntrain = HistoPatches(train_dir,\n                     train_label_df,\n                     transform=image_trans,\n                     sample_n=70000, #70k was best\n                     in_memory=memory)\n\nval   = HistoPatches(train_dir,\n                     val_label_df,\n                     transform=image_trans,\n                     sample_n=4000,\n                     in_memory=memory)\n\ntrain_loader = DataLoader(train, batch_size=batchsize, shuffle=True)\nval_loader   = DataLoader(val,   batch_size=batchsize, shuffle=False)\n\nprint('test and show batch-dimension:')\nfor i, (X, y) in enumerate(train_loader):\n    if i == 10:\n        print(X.shape, y.shape)\n        break","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"markdown","source":"# Cyclic Learning Rate Class"},{"metadata":{"trusted":true},"cell_type":"code","source":"class CyclicLR(object):\n    def __init__(self, optimizer, base_lr=1e-3, max_lr=6e-3,\n                 step_size=2000, mode='triangular', gamma=1.,\n                 scale_fn=None, scale_mode='cycle', last_batch_iteration=-1):\n\n        \n        self.optimizer = optimizer\n\n        if isinstance(base_lr, list) or isinstance(base_lr, tuple):\n            if len(base_lr) != len(optimizer.param_groups):\n                raise ValueError(\"expected {} base_lr, got {}\".format(\n                    len(optimizer.param_groups), len(base_lr)))\n            self.base_lrs = list(base_lr)\n        else:\n            self.base_lrs = [base_lr] * len(optimizer.param_groups)\n\n        if isinstance(max_lr, list) or isinstance(max_lr, tuple):\n            if len(max_lr) != len(optimizer.param_groups):\n                raise ValueError(\"expected {} max_lr, got {}\".format(\n                    len(optimizer.param_groups), len(max_lr)))\n            self.max_lrs = list(max_lr)\n        else:\n            self.max_lrs = [max_lr] * len(optimizer.param_groups)\n\n        self.step_size = step_size\n\n        if mode not in ['triangular', 'triangular2', 'exp_range'] \\\n                and scale_fn is None:\n            raise ValueError('mode is invalid and scale_fn is None')\n\n        self.mode = mode\n        self.gamma = gamma\n\n        if scale_fn is None:\n            if self.mode == 'triangular':\n                self.scale_fn = self._triangular_scale_fn\n                self.scale_mode = 'cycle'\n            elif self.mode == 'triangular2':\n                self.scale_fn = self._triangular2_scale_fn\n                self.scale_mode = 'cycle'\n            elif self.mode == 'exp_range':\n                self.scale_fn = self._exp_range_scale_fn\n                self.scale_mode = 'iterations'\n        else:\n            self.scale_fn = scale_fn\n            self.scale_mode = scale_mode\n\n        self.step(batch_iteration = last_batch_iteration + 1)\n        self.last_batch_iteration = last_batch_iteration\n\n    def step(self, batch_iteration = None, ):\n        if batch_iteration is None:\n            batch_iteration = self.last_batch_iteration + 1\n        self.last_batch_iteration = batch_iteration\n        for param_group, lr in zip(self.optimizer.param_groups, self.get_lr()):\n            param_group['lr'] = lr\n\n    def _triangular_scale_fn(self, x):\n        return 1.\n\n    def _triangular2_scale_fn(self, x):\n        return 1 / (2. ** (x - 1))\n\n    def _exp_range_scale_fn(self, x):\n        return self.gamma**(x)\n\n    def get_lr(self):\n        step_size = float(self.step_size)\n        cycle = np.floor(1 + self.last_batch_iteration / (2 * step_size))\n        x = np.abs(self.last_batch_iteration / step_size - 2 * cycle + 1)\n\n        lrs = []\n        param_lrs = zip(self.optimizer.param_groups, self.base_lrs, self.max_lrs)\n        for param_group, base_lr, max_lr in param_lrs:\n            base_height = (max_lr - base_lr) * np.maximum(0, (1 - x))\n            if self.scale_mode == 'cycle':\n                lr = base_lr + base_height * self.scale_fn(cycle)\n            else:\n                lr = base_lr + base_height * self.scale_fn(self.last_batch_iteration)\n            lrs.append(lr)\n        return lrs","execution_count":null,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"## Why Use AUC instead of Accuracy?"},{"metadata":{"trusted":true},"cell_type":"code","source":"# Pie chart, where the slices will be ordered and plotted counter-clockwise:\nlabels = '1', '0'\nsizes = [np.mean(val_label_df.label), 1-np.mean(val_label_df.label)]\n#explode = (0, 0.1, 0, 0)  # only \"explode\" the 2nd slice (i.e. 'Hogs')\n\nfig1, ax1 = plt.subplots()\nax1.pie(sizes, labels=labels, autopct='%1.1f%%',\n        shadow=True, startangle=90)\nax1.axis('equal')  # Equal aspect ratio ensures that pie is drawn as a circle.\nax1.set(title = \"Test Set Label Distribution\")\nplt.show()","execution_count":null,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"We see, the label distribution in our validation set is skewed towards label 0"},{"metadata":{},"cell_type":"markdown","source":"# Training Routine"},{"metadata":{"trusted":true},"cell_type":"code","source":"@function_timer\ndef train_model(net, train, validation, optimizer, device, scheduler = None, max_epoch=100, verbose=False):\n    \"\"\"\n    This function returns nothing. The parametes of @net are updated in-place\n    and the error statistics are written to a global variable. This allows to\n    stop the training at any point and still have the results.\n  \n    @ net: a defined model - can also be pretrained\n    @ train, test: DataLoaders of training- and test-set\n    @ max_epoch: stop training after this number of epochs\n    \"\"\"\n    global error_stats  # to track error log even when training aborted\n    error_stats = []\n  \n    criterion = nn.BCEWithLogitsLoss()\n    #scheduler = torch.optim.lr_scheduler.MultiStepLR(\n    #    optimizer,\n    #    milestones=[x for x in range(1, max_epoch) if x % 20 == 0],\n    #    gamma=0.5  # decrease learning rate by half each step\n    #)\n    net.to(device)\n    \n    print('epoch\\ttraining-CE\\ttraining-acc\\ttraining_auc\\tvalidation-CE\\tvalidation-acc\\tvalidation_auc')\n    for epoch in range(max_epoch):\n        net.train()\n        training_loss = 0\n        training_acc = 0\n        validation_loss = 0\n        validation_acc = 0\n        training_auc = 0\n        validation_auc = 0\n    \n        for batch_i, (X, y) in enumerate(train):\n            \n            if verbose and batch_i % (batchsize/4) == 0:\n                print(f'\\t...batch {batch_i} / {len(train)}')\n            \n            X , y = X.to(device), y.to(device)\n            optimizer.zero_grad()\n            if scheduler is not None:\n                scheduler.step()\n            # prediction and error:\n            out  = net(X).squeeze()\n            loss = criterion(out.type(torch.DoubleTensor).cuda(), y)  # loss of current batch\n            training_loss += loss.item()\n            predictions = torch.sigmoid(out).round().detach().cpu().numpy()\n            training_acc += np.mean(y.detach().cpu().numpy() == predictions) * 100\n            training_auc += get_roc_score(out ,y)\n\n            # update parameters:\n            loss.backward()\n            optimizer.step()\n\n        with torch.no_grad():  # no backpropagation necessary\n            net.eval()\n\n            for X, y in validation:\n                X , y = X.to(device), y.to(device)\n\n                # prediction and error:\n                out  = net(X).squeeze()\n                loss = criterion(out.type(torch.DoubleTensor).cuda(), y)  # loss of current batch\n                validation_loss += loss.item()\n                predictions = torch.sigmoid(out).round().detach().cpu().numpy()\n                validation_acc += np.mean(y.detach().cpu().numpy() == predictions) * 100\n                validation_auc += get_roc_score(out ,y)\n    \n        # convert to batch loss:\n        training_acc    = training_acc    / len(train)\n        training_loss   = training_loss   / len(train)\n        training_auc    = training_auc    / len(train)\n        validation_acc  = validation_acc  / len(validation)\n        validation_loss = validation_loss / len(validation)\n        validation_auc  = validation_auc  / len(validation)\n        #scheduler.step()\n       \n        #torch.save(net.state_dict(), f'epoch{epoch}.pt')\n        error_stats.append( (training_loss, validation_loss, training_acc, validation_acc, training_auc, validation_auc) )\n\n        print('{}\\t{:.4f}\\t\\t{:.2f}\\t\\t{:.4f}\\t\\t{:.4f}\\t\\t{:.2f}\\t\\t{:.4f}'.format(\n            epoch, training_loss, training_acc, training_auc, validation_loss, validation_acc, validation_auc)\n             )\n        \n","execution_count":null,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"# Model\n## DenseNet121 Architecture\n\n![image.png](attachment:image.png)","attachments":{"image.png":{"image/png":"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"}}},{"metadata":{},"cell_type":"markdown","source":"## Helper function to determine input shapes at the start of the network\nWe want to fit 96x96 images into a DenseNet, which expects a 224x224 image. Therefore we replace the first few layers of the DenseNet with a convolutional block that transforms the image accordingly."},{"metadata":{"trusted":true},"cell_type":"code","source":"def conv_dim(in_dim, k=3, s=1, p=0, p_left=None, p_right=None):\n    \n    if p is not None:\n        p_left = p_right = p\n    assert p_left is not None and p_right is not None\n        \n    tmp = (in_dim - k + p_left + p_right) / s\n    out_dim = int(np.floor(tmp) + 1)\n    \n    if tmp % 1 != 0:\n        print('no exact output-dim; using Gauss-brackets.')\n    print(f'out-dim: {out_dim}')\n\n\n# conv_dim(30, k=3, s=1, p=0)","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"#orig_net = models.densenet121()\n#print(orig_net.features[:4])\n\n#x = X.cpu()\n#h1 = orig_net.features[:4](x)\n#print(h1.shape)","execution_count":null,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"## Alteration of the DenseNet121"},{"metadata":{"trusted":true},"cell_type":"code","source":"from collections import OrderedDict\n\nnet_fullimage = models.densenet121(pretrained=False)\nnet_fullimage.features = nn.Sequential(\n    nn.Sequential(OrderedDict([\n            ('conv0', nn.Conv2d(3, 64, kernel_size=3, stride=2, padding=1, bias=False)),\n            ('norm0', nn.BatchNorm2d(64)),\n            ('relu0', nn.ReLU(inplace=True))\n        ])),  # 96**2 -> 48**2\n    net_fullimage.features[4:])\n\nnet_fullimage.classifier = nn.Sequential(\n    nn.Linear(1024, 512),\n    nn.Linear(512, 1)\n)\n# net_fullimage","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"net = net_fullimage  # choose net to train here\n\n# # just for testing\n# myloss = nn.BCEWithLogitsLoss()\n# net.cuda()\n# for i, (X, y) in enumerate(train_loader):\n#     if i == 10:\n#         X , y = X.cuda(), y.cuda()\n#         print(X.shape, y.shape)\n#         out = net(X).squeeze()\n#         print(f'loss: {myloss(y, out.type(torch.DoubleTensor).cuda()).item()}')\n#         break","execution_count":null,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"# Prepare for Training\n## AUC score calculation"},{"metadata":{"trusted":true},"cell_type":"code","source":"def get_roc_score(net_output, y):\n    \"\"\"\n    @ net_output: output from neural network (cuda)tensor, with NO sigmoid applied yet!\n    @ y: label (cuda)tensor [0s, 1s]\n    \"\"\"\n    \n    # Apply sigmoid\n    net_out = nn.Sigmoid()(net_output)\n    # reshape from (batch_size, 1) to (batch_size, ) and convert to numpy\n    net_out_np = net_out.reshape(-1).detach().cpu().numpy()\n    # convert to numpy\n    y_np = y.detach().cpu().numpy()\n    return roc_auc_score(y_np,net_out_np)","execution_count":null,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"## Hyperparameter settings"},{"metadata":{"trusted":true},"cell_type":"code","source":"nr_cycles = 10\nepochs = 20\ntotal_number_batches = epochs * len(train_loader)\nstepsize = int(.5*total_number_batches/nr_cycles)\noptimizer = torch.optim.Adam(net.parameters(), lr=0.01, weight_decay=0)\nscheduler = CyclicLR(optimizer, base_lr=0.0001, max_lr=0.01,\n                 step_size=stepsize, mode='triangular2')\nprint(f'Stepsize: {stepsize}')","execution_count":null,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"# Training the model"},{"metadata":{"trusted":true},"cell_type":"code","source":"train_model(net,\n            train_loader,\n            val_loader,\n            optimizer,\n            scheduler = scheduler,\n            device=torch.device('cuda:0' if torch.cuda.is_available() else 'cpu'),\n            max_epoch=epochs,\n            verbose=False)","execution_count":null,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"Training- and validation error are always pretty close => regularization probably not necessary"},{"metadata":{},"cell_type":"markdown","source":"# Display Learning Curves of Training"},{"metadata":{"trusted":true},"cell_type":"code","source":"accuracy = [(x[2], x[3]) for x in error_stats]\nplot_error_curves(accuracy, error_name='accuracy')","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"bce = [(x[0], x[1]) for x in error_stats]\nplot_error_curves(bce, error_name='binary cross-entropy')","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"auc_ = [(x[4], x[5]) for x in error_stats]\nplot_error_curves(auc_, error_name = \"Area Under the Curve (AUC))\")","execution_count":null,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"## Save network parameters"},{"metadata":{"_kg_hide-input":false,"trusted":true},"cell_type":"code","source":"torch.save(net.state_dict(), 'swag_net2.pt')","execution_count":null,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"# Display ROC Curve on Validation Data Set:"},{"metadata":{"trusted":true},"cell_type":"code","source":"from sklearn.metrics import roc_curve\n\n# Predict all values\ny_pred = []\ny_true = []\nnet.eval()\nfor idx, (X, y) in enumerate(val_loader):\n    X, y = X.cuda(), y.cuda()\n    # save into y_pred and y_true (true)\n    y_pred.extend(list(net(X).reshape(-1).detach().cpu().numpy()))\n    y_true.extend(list(y.detach().cpu().numpy()))\n  \n\nfpr, tpr, _ = roc_curve(y_true, y_pred)\nauc_score = roc_auc_score(y_true, y_pred)\nplt.figure(1)\nplt.plot([0, 1], [0, 1], 'k--')\nplt.plot(fpr, tpr, label='AUC: {0:.4f}'.format(auc_score))\nplt.xlabel('False positive rate')\nplt.ylabel('True positive rate')\nplt.title('ROC curve')\nplt.legend(loc='lower right')\nplt.show()\n","execution_count":null,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"# Predict for submission file"},{"metadata":{"trusted":true},"cell_type":"code","source":"# free up some RAM:\ntry:\n   del val, val_loader, train, train_loader\nexcept:\n   pass","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"test = HistoPatches(image_dir=os.path.join(DATA_DIR, 'test'), transform = image_trans)\ntest_loader = DataLoader(test, batch_size=batchsize, shuffle = False)\nprediction_df = pd.DataFrame(columns=['id', 'label'])","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"net.eval()\nfor X, ids in test_loader:\n    out = net(X.cuda()).squeeze()\n    predictions = torch.sigmoid(out).detach().cpu().numpy()\n    df = pd.DataFrame({'id': ids, 'label': predictions.astype(float)})\n    prediction_df = prediction_df.append(df)","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"display(prediction_df.head())\nprediction_df.to_csv('submission.csv', index=False)\nos.listdir('.')","execution_count":null,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"<a href=\"submission.csv\"> Download submission-file </a>\n \n<a href=\"swag_net2.pt\"> Download net parameters</a>"}],"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.8"}},"nbformat":4,"nbformat_minor":1}