{"metadata":{"kernelspec":{"language":"python","display_name":"Python 3","name":"python3"},"language_info":{"pygments_lexer":"ipython3","nbconvert_exporter":"python","version":"3.6.4","file_extension":".py","codemirror_mode":{"name":"ipython","version":3},"name":"python","mimetype":"text/x-python"}},"nbformat_minor":4,"nbformat":4,"cells":[{"cell_type":"markdown","source":"![1_uR7-mfI6AE6cqGqG0rDE8w.png](attachment:4596314f-fe69-4967-83ad-83da11c6d918.png)","metadata":{},"attachments":{"4596314f-fe69-4967-83ad-83da11c6d918.png":{"image/png":"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"}}},{"cell_type":"markdown","source":"**PyTorch/XLA**\n\nThe PyTorch-TPU project was born out of a collaborative effort between the Facebook PyTorch and Google TPU teams and was officially launched at the 2019 PyTorch Developer Conference. This new integration enables PyTorch users to run and scale up their models on Cloud TPUs. PyTorch / XLA package lets PyTorch connect to Cloud TPUs and use TPU cores as devices","metadata":{}},{"cell_type":"code","source":"!curl https://raw.githubusercontent.com/pytorch/xla/master/contrib/scripts/env-setup.py -o pytorch-xla-env-setup.py\n!python pytorch-xla-env-setup.py --apt-packages libomp5 libopenblas-dev\n!pip install timm","metadata":{"_uuid":"8f2839f25d086af736a60e9eeb907d3b93b6e0e5","_cell_guid":"b1076dfc-b9ad-4769-8c92-a6c4dae69d19","_kg_hide-output":true,"_kg_hide-input":true,"execution":{"iopub.status.busy":"2021-06-11T07:01:12.212608Z","iopub.execute_input":"2021-06-11T07:01:12.213265Z","iopub.status.idle":"2021-06-11T07:02:23.299152Z","shell.execute_reply.started":"2021-06-11T07:01:12.213154Z","shell.execute_reply":"2021-06-11T07:02:23.298053Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"# **0. Importing Libraries**\n","metadata":{}},{"cell_type":"markdown","source":"PyTorch / XLA adds a new xla device type to PyTorch. This device type works just like other PyTorch device types.","metadata":{}},{"cell_type":"code","source":"import os\nimport pandas as pd\nfrom scipy import stats\nimport numpy as np\nimport glob\nimport tensorflow as tf\nimport timm\nimport random\nimport time\nimport copy\nfrom operator import itemgetter\n\nfrom collections import OrderedDict, namedtuple\nimport joblib\n\nimport logging\nimport sys\n\nfrom PIL import Image\nimport cv2\nimport albumentations\nimport io\nimport IPython.display as display\n\nimport torch\nimport torch.nn as nn\nimport torch.nn.functional as F\nfrom torch.optim import lr_scheduler\nimport torch.optim as optim\nimport torch_xla\nimport torch_xla.core.xla_model as xm\nimport torch_xla.debug.metrics as met\nimport torch_xla.distributed.parallel_loader as pl\nimport torch_xla.distributed.xla_multiprocessing as xmp\nimport torch_xla.utils.utils as xu\nimport torchvision\nfrom torchvision import datasets, transforms\nfrom torch.utils.data import Dataset, DataLoader, ConcatDataset\nimport torchvision.transforms as transforms\nfrom torchvision.utils import make_grid\n\nimport matplotlib.pyplot as plt\nimport seaborn as sns\nfrom sklearn.model_selection import train_test_split\nfrom sklearn import metrics, model_selection\n\nimport warnings\nwarnings.filterwarnings(\"ignore\");","metadata":{"execution":{"iopub.status.busy":"2021-06-11T07:02:23.301285Z","iopub.execute_input":"2021-06-11T07:02:23.301729Z","iopub.status.idle":"2021-06-11T07:02:31.334959Z","shell.execute_reply.started":"2021-06-11T07:02:23.301678Z","shell.execute_reply":"2021-06-11T07:02:31.334040Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"# **1. Data Loading**","metadata":{}},{"cell_type":"markdown","source":"**Paths**","metadata":{}},{"cell_type":"code","source":"train_files = glob.glob('../input/tpu-getting-started/*/train/*.tfrec')\nval_files = glob.glob('../input/tpu-getting-started/*/val/*.tfrec')\ntest_files = glob.glob('../input/tpu-getting-started/*/test/*.tfrec')","metadata":{"execution":{"iopub.status.busy":"2021-06-11T07:02:31.336776Z","iopub.execute_input":"2021-06-11T07:02:31.337121Z","iopub.status.idle":"2021-06-11T07:02:31.430186Z","shell.execute_reply.started":"2021-06-11T07:02:31.337087Z","shell.execute_reply":"2021-06-11T07:02:31.428999Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"**Here we read tfrecords files in PyTorch. I recommend** https://medium.com/analytics-vidhya/how-to-read-tfrecords-files-in-pytorch-72763786743f","metadata":{}},{"cell_type":"code","source":"train_feature_description = {\n    'class': tf.io.FixedLenFeature([], tf.int64),\n    'id': tf.io.FixedLenFeature([], tf.string),\n    'image': tf.io.FixedLenFeature([], tf.string),\n}\n\ndef _parse_image_function(example_proto):\n  # Parse the input tf.Example proto using the dictionary above.\n  return tf.io.parse_single_example(example_proto, train_feature_description)\n\ntrain_ids = []\ntrain_class = []\ntrain_images = []\n\nfor i in train_files:\n  train_image_dataset = tf.data.TFRecordDataset(i)\n\n  train_image_dataset = train_image_dataset.map(_parse_image_function)\n\n  ids = [str(id_features['id'].numpy())[2:-1] for id_features in train_image_dataset] # [2:-1] is done to remove b' from 1st and 'from last in train id names\n  train_ids = train_ids + ids\n\n  classes = [int(class_features['class'].numpy()) for class_features in train_image_dataset]\n  train_class = train_class + classes\n\n  images = [image_features['image'].numpy() for image_features in train_image_dataset]\n  train_images = train_images + images","metadata":{"execution":{"iopub.status.busy":"2021-06-11T07:02:31.431522Z","iopub.execute_input":"2021-06-11T07:02:31.431817Z","iopub.status.idle":"2021-06-11T07:03:55.430981Z","shell.execute_reply.started":"2021-06-11T07:02:31.431788Z","shell.execute_reply":"2021-06-11T07:03:55.429204Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"val_feature_description = {\n    'class': tf.io.FixedLenFeature([], tf.int64),\n    'id': tf.io.FixedLenFeature([], tf.string),\n    'image': tf.io.FixedLenFeature([], tf.string),\n}\n\ndef _parse_image_function(example_proto):\n  # Parse the input tf.Example proto using the dictionary above.\n  return tf.io.parse_single_example(example_proto, val_feature_description)\n\nval_ids = []\nval_class = []\nval_images = []\n\nfor i in val_files:\n    val_image_dataset = tf.data.TFRecordDataset(i)\n\n    val_image_dataset = val_image_dataset.map(_parse_image_function)\n\n    ids = [str(image_features['id'].numpy())[2:-1] for image_features in val_image_dataset]\n    val_ids += ids\n\n    classes = [int(image_features['class'].numpy()) for image_features in val_image_dataset]\n    val_class += classes \n\n    images = [image_features['image'].numpy() for image_features in val_image_dataset]\n    val_images += images","metadata":{"execution":{"iopub.status.busy":"2021-06-11T07:03:55.433621Z","iopub.execute_input":"2021-06-11T07:03:55.434045Z","iopub.status.idle":"2021-06-11T07:04:22.116160Z","shell.execute_reply.started":"2021-06-11T07:03:55.433995Z","shell.execute_reply":"2021-06-11T07:04:22.115166Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"test_feature_description = {\n    'id': tf.io.FixedLenFeature([], tf.string),\n    'image': tf.io.FixedLenFeature([], tf.string),\n}\n\ndef _parse_image_function_test(example_proto):\n    return tf.io.parse_single_example(example_proto, test_feature_description)\n\ntest_ids = []\ntest_images = []\nfor i in test_files:\n    test_image_dataset = tf.data.TFRecordDataset(i)\n    \n    test_image_dataset = test_image_dataset.map(_parse_image_function_test)\n\n    ids = [str(id_features['id'].numpy())[2:-1] for id_features in test_image_dataset]\n    test_ids = test_ids + ids\n\n    images = [image_features['image'].numpy() for image_features in test_image_dataset]\n    test_images = test_images + images","metadata":{"execution":{"iopub.status.busy":"2021-06-11T07:04:22.117499Z","iopub.execute_input":"2021-06-11T07:04:22.117793Z","iopub.status.idle":"2021-06-11T07:04:58.308046Z","shell.execute_reply.started":"2021-06-11T07:04:22.117755Z","shell.execute_reply":"2021-06-11T07:04:58.306967Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"**Let's take a quick look at the data. I don't know about you, but the first thing I always want to do is look at what our data looks like :)**","metadata":{}},{"cell_type":"code","source":"import IPython.display as display\n\ndisplay.display(display.Image(data=val_images[1]))","metadata":{"execution":{"iopub.status.busy":"2021-06-11T07:04:58.309840Z","iopub.execute_input":"2021-06-11T07:04:58.310301Z","iopub.status.idle":"2021-06-11T07:04:58.321532Z","shell.execute_reply.started":"2021-06-11T07:04:58.310247Z","shell.execute_reply":"2021-06-11T07:04:58.320474Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"# **2. Data preparation**","metadata":{}},{"cell_type":"markdown","source":"**Let's write our dataset**","metadata":{}},{"cell_type":"code","source":"class MyDataset():\n    def __init__(self, ids, cls, imgs, transforms, is_test=False):\n        self.ids = ids\n        if not is_test:\n            self.cls = cls\n        self.imgs = imgs\n        self.transforms = transforms\n        self.is_test = is_test\n    \n    def __len__(self):\n        return len(self.ids)\n\n    def __getitem__(self, idx):\n        img = self.imgs[idx]\n        img = Image.open(io.BytesIO(img))\n        img = self.transforms(img)\n        if self.is_test:\n            return img, -1, self.ids[idx]\n        return img, int(self.cls[idx]), self.ids[idx]","metadata":{"execution":{"iopub.status.busy":"2021-06-11T07:04:58.325171Z","iopub.execute_input":"2021-06-11T07:04:58.325842Z","iopub.status.idle":"2021-06-11T07:04:58.334275Z","shell.execute_reply.started":"2021-06-11T07:04:58.325788Z","shell.execute_reply":"2021-06-11T07:04:58.333302Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"**Let's write augmentation and normalization right away**","metadata":{}},{"cell_type":"code","source":"train_transforms = transforms.Compose([\n                        transforms.RandomResizedCrop(224),\n                        transforms.RandomHorizontalFlip(),\n                        transforms.RandomVerticalFlip(),\n                        transforms.ToTensor(),\n                        transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]),\n                        transforms.RandomErasing()\n                    ])\n\ntest_transforms = transforms.Compose([\n                        transforms.CenterCrop(224),\n                        transforms.Resize(224),\n                        transforms.ToTensor(),\n                        transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225])\n                    ])","metadata":{"execution":{"iopub.status.busy":"2021-06-11T07:04:58.336606Z","iopub.execute_input":"2021-06-11T07:04:58.337129Z","iopub.status.idle":"2021-06-11T07:04:58.346613Z","shell.execute_reply.started":"2021-06-11T07:04:58.337076Z","shell.execute_reply":"2021-06-11T07:04:58.345534Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"train_ds = MyDataset(train_ids, train_class, train_images, train_transforms)\nvalid_ds = MyDataset(val_ids, val_class, val_images, test_transforms)","metadata":{"execution":{"iopub.status.busy":"2021-06-11T07:04:58.348182Z","iopub.execute_input":"2021-06-11T07:04:58.348634Z","iopub.status.idle":"2021-06-11T07:04:58.362759Z","shell.execute_reply.started":"2021-06-11T07:04:58.348592Z","shell.execute_reply":"2021-06-11T07:04:58.361741Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"device = xm.xla_device()","metadata":{"execution":{"iopub.status.busy":"2021-06-11T07:04:58.364023Z","iopub.execute_input":"2021-06-11T07:04:58.364340Z","iopub.status.idle":"2021-06-11T07:05:04.252611Z","shell.execute_reply.started":"2021-06-11T07:04:58.364311Z","shell.execute_reply":"2021-06-11T07:05:04.251190Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"from torch.utils.data import Dataset, DataLoader, ConcatDataset\n\ntrain_sampler = torch.utils.data.distributed.DistributedSampler(\n        train_ds,\n        num_replicas=xm.xrt_world_size(),\n        rank=xm.get_ordinal(),\n        shuffle=True\n    )\n\nvalid_sampler = torch.utils.data.distributed.DistributedSampler(\n        valid_ds,\n        num_replicas=xm.xrt_world_size(),\n        rank=xm.get_ordinal(),\n        shuffle=True\n    )\n    \ntrain_loader = DataLoader(train_ds, 128, sampler=train_sampler, num_workers=4, pin_memory=True)\nval_loader = DataLoader(valid_ds, 128, sampler=valid_sampler, num_workers=4, pin_memory=True)\n\ndataset_sizes = {\n    'train': len(train_ds),\n    'val': len(valid_ds),\n}","metadata":{"execution":{"iopub.status.busy":"2021-06-11T07:05:04.253996Z","iopub.execute_input":"2021-06-11T07:05:04.254496Z","iopub.status.idle":"2021-06-11T07:05:04.271434Z","shell.execute_reply.started":"2021-06-11T07:05:04.254447Z","shell.execute_reply":"2021-06-11T07:05:04.270609Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"dataset_sizes","metadata":{"execution":{"iopub.status.busy":"2021-06-11T07:05:04.272501Z","iopub.execute_input":"2021-06-11T07:05:04.272921Z","iopub.status.idle":"2021-06-11T07:05:04.287087Z","shell.execute_reply.started":"2021-06-11T07:05:04.272889Z","shell.execute_reply":"2021-06-11T07:05:04.285812Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"**We have already normalized the data, but at this stage I would like to dwell in more detail, because this is very important.**\n\nIn datasets, we have three-channel images, that is, we need to normalize for each channel separately (!!!). Because of the unnormalized data, problems may appear, for example, regularization during training can work to the detriment, but we do not want this at all. The task of normalization is to make the mean as close to zero as possible, and the standard deviation around 1.\n\nHow each channel looks separately can be seen below:","metadata":{}},{"cell_type":"code","source":"transforms_example = transforms.Compose([\n                        transforms.CenterCrop(224),\n                        transforms.ToTensor(),])\n\nexampleset = MyDataset(train_ids, train_class, train_images, transforms_example)\n\nx, y, _ = next(iter(DataLoader(exampleset)))\n\nchannels = ['Red', 'Green', 'Blue']\ncmaps = [plt.cm.Reds_r, plt.cm.Greens_r, plt.cm.Blues_r]\n\nfig, ax = plt.subplots(1, 4, figsize=(15, 10))\n\nfor i, axs in enumerate(fig.axes[:3]):\n    axs.imshow(x[0][i,:,:], cmap=cmaps[i])\n    axs.set_title(f'{channels[i]} Channel')\n    axs.set_xticks([])\n    axs.set_yticks([])\n    \nax[3].imshow(x[0].permute(1,2,0))\nax[3].set_title('Three Channels')\nax[3].set_xticks([])\nax[3].set_yticks([]);","metadata":{"execution":{"iopub.status.busy":"2021-06-11T07:05:04.288559Z","iopub.execute_input":"2021-06-11T07:05:04.290426Z","iopub.status.idle":"2021-06-11T07:05:04.699907Z","shell.execute_reply.started":"2021-06-11T07:05:04.290381Z","shell.execute_reply":"2021-06-11T07:05:04.698853Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"**Now let's check how well we managed to normalize the data for each channel for the test, training and validation datasets:**","metadata":{}},{"cell_type":"code","source":"channels = 3\n\nloaders = {\n    'train':train_loader,\n    'val':val_loader,\n}\n\nfor channel in range(channels):\n    for x in ['train', 'val']:\n        #number of pixels in the dataset = number of all pixels in one object * number of all objects in the dataset\n        num_pxl = dataset_sizes[x]*224*224\n    \n        #we go through the butches and sum up the pixels of the objects, \n        #which then divide the sum by the number of all pixels to calculate the average\n        total_sum = 0\n        for batch in loaders[x]:\n            layer = list(map(itemgetter(channel), batch[0]))\n            layer = torch.stack(layer, dim=0)\n            total_sum += layer.sum()\n        mean = total_sum / num_pxl\n\n        #we calculate the standard deviation using the formula that I indicated above\n        sum_sqrt = 0\n        for batch in loaders[x]: \n            layer = list(map(itemgetter(channel), batch[0]))\n            sum_sqrt += ((torch.stack(layer, dim=0) - mean).pow(2)).sum()\n        std = torch.sqrt(sum_sqrt / num_pxl)\n        \n        print(f'|channel:{channel+1}| {x} - mean: {mean}, std: {std}')","metadata":{"execution":{"iopub.status.busy":"2021-06-11T07:05:04.701228Z","iopub.execute_input":"2021-06-11T07:05:04.701517Z","iopub.status.idle":"2021-06-11T07:18:21.196536Z","shell.execute_reply.started":"2021-06-11T07:05:04.701489Z","shell.execute_reply":"2021-06-11T07:18:21.194739Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"**Let's take a look at the pixel distribution after normalization**","metadata":{}},{"cell_type":"code","source":"x, y, _ = next(iter(exampleset))\n\ndef plotHist(img):\n  plt.figure(figsize=(10,5))\n  plt.subplot(1,2,1)\n  plt.imshow(x.permute(1,2,0))\n  plt.axis('off')\n  histo = plt.subplot(1,2,2)\n  histo.set_ylabel('Count')\n  histo.set_xlabel('Pixel Intensity')\n  plt.hist(img.numpy().flatten(), bins=10, lw=0, alpha=0.5, color='r')\n\nplotHist(x)","metadata":{"execution":{"iopub.status.busy":"2021-06-11T07:18:21.198967Z","iopub.execute_input":"2021-06-11T07:18:21.199320Z","iopub.status.idle":"2021-06-11T07:18:21.519448Z","shell.execute_reply.started":"2021-06-11T07:18:21.199267Z","shell.execute_reply":"2021-06-11T07:18:21.518393Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"**Let's take a batch from the training dataset and see its mean and standard deviation:**","metadata":{}},{"cell_type":"code","source":"x.mean(), x.std()","metadata":{"execution":{"iopub.status.busy":"2021-06-11T07:18:21.521207Z","iopub.execute_input":"2021-06-11T07:18:21.521645Z","iopub.status.idle":"2021-06-11T07:18:21.625511Z","shell.execute_reply.started":"2021-06-11T07:18:21.521603Z","shell.execute_reply":"2021-06-11T07:18:21.624360Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"def norm_out(img):\n    \n    img = img.permute(1,2,0)\n    mean = torch.FloatTensor([0.485, 0.456, 0.406])\n    std = torch.FloatTensor([0.229, 0.224, 0.225])\n    \n    img = img*std + mean\n        \n    return np.clip(img,0,1)","metadata":{"execution":{"iopub.status.busy":"2021-06-11T07:18:21.627341Z","iopub.execute_input":"2021-06-11T07:18:21.627711Z","iopub.status.idle":"2021-06-11T07:18:21.633800Z","shell.execute_reply.started":"2021-06-11T07:18:21.627674Z","shell.execute_reply":"2021-06-11T07:18:21.632851Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"def show_batch(dl):\n    \n    for images, labels, _ in dl:\n        fig, ax = plt.subplots(figsize=(25, 25))\n        ax.set_xticks([]); ax.set_yticks([])\n        #images = norm_out(images[:60])\n        ax.imshow(norm_out(make_grid(images[:60], nrow=10)))#.permute(1, 2, 0))\n        ax.set_title('Images without augmentation', fontsize=40)\n        break\n        \nshow_batch(loaders['val'])","metadata":{"execution":{"iopub.status.busy":"2021-06-11T07:18:21.635307Z","iopub.execute_input":"2021-06-11T07:18:21.635618Z","iopub.status.idle":"2021-06-11T07:18:25.827390Z","shell.execute_reply.started":"2021-06-11T07:18:21.635585Z","shell.execute_reply":"2021-06-11T07:18:25.826076Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"def show_batch(dl):\n    for images, labels, _ in dl:\n        fig, ax = plt.subplots(figsize=(25, 25))\n        ax.set_xticks([]); ax.set_yticks([])\n        ax.imshow(make_grid(images[:60], nrow=10).permute(1, 2, 0))\n        ax.set_title('Images with augmentation', fontsize=40)\n        break\n        \nshow_batch(loaders['train'])","metadata":{"execution":{"iopub.status.busy":"2021-06-11T07:18:25.828832Z","iopub.execute_input":"2021-06-11T07:18:25.829192Z","iopub.status.idle":"2021-06-11T07:18:29.726465Z","shell.execute_reply.started":"2021-06-11T07:18:25.829156Z","shell.execute_reply":"2021-06-11T07:18:29.725084Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"# **3. Training and Test**\n**Idea:** I will use an ensemble of pre-trained models, the idea is this: I first train only the classifier on 10 epochs, then unfreeze the network and train all together for another 10 epochs. After that, the model makes predictions on the test data","metadata":{}},{"cell_type":"markdown","source":"**Training for one epoch**","metadata":{}},{"cell_type":"code","source":"def train(loader, epoch, model, optimizer, criterion):\n   #tracker = xm.RateTracker()\n   model.train()\n   running_loss = 0.\n   running_corrects = 0.\n   tot = 0\n   for i, (ip, tgt, _) in enumerate(loader):\n      ip, tgt = ip.to(device), tgt.to(device)                            \n      output = model(ip)\n      loss = criterion(output, tgt)\n      tot += ip.shape[0]\n\n      # Append outputs\n      _, pred = output.max(dim=1)\n      running_corrects += torch.sum(pred == tgt.data)\n\n      # compute gradient and do SGD step\n      optimizer.zero_grad()\n      loss.backward()\n      #torch.nn.utils.clip_grad_norm_(model.parameters(), 1.0)\n      #optimizer.step()\n      xm.optimizer_step(optimizer)\n\n      running_loss += loss.item()*ip.size(0)\n\n   return running_corrects, running_loss","metadata":{"execution":{"iopub.status.busy":"2021-06-11T07:18:29.728040Z","iopub.execute_input":"2021-06-11T07:18:29.728358Z","iopub.status.idle":"2021-06-11T07:18:29.736461Z","shell.execute_reply.started":"2021-06-11T07:18:29.728325Z","shell.execute_reply":"2021-06-11T07:18:29.735412Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"**Val for one epoch**","metadata":{}},{"cell_type":"code","source":"def test(loader, model, criterion):\n        with torch.no_grad():\n            model.eval()\n            running_loss = 0.\n            running_corrects = 0.\n            tot = 0\n            for i, (ip, tgt, _) in enumerate(loader):\n                ip, tgt = ip.to(device), tgt.to(device)\n                output = model(ip)\n                loss = criterion(output, tgt)\n                tot += ip.shape[0]\n                _, pred = output.max(dim=1)\n                running_corrects += torch.sum(pred == tgt.data)\n                running_loss += loss.item()*ip.size(0)\n\n            return running_corrects, running_loss","metadata":{"execution":{"iopub.status.busy":"2021-06-11T07:18:29.737819Z","iopub.execute_input":"2021-06-11T07:18:29.738280Z","iopub.status.idle":"2021-06-11T07:18:29.755001Z","shell.execute_reply.started":"2021-06-11T07:18:29.738233Z","shell.execute_reply":"2021-06-11T07:18:29.753767Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"**Function for predictions on a test set**","metadata":{}},{"cell_type":"code","source":"def predict(model, loader, device):\n    with torch.no_grad():\n        torch.cuda.empty_cache()\n        model.eval()\n        preds = dict()\n        for i, (ip, _, ids) in enumerate(loader):\n            ip = ip.to(device)\n            output = model(ip)\n            _, pred = output.max(dim=1)\n            for i, j in zip(ids, pred.cpu().detach()):\n                preds[i] = j\n            \n        return preds","metadata":{"execution":{"iopub.status.busy":"2021-06-11T07:18:29.760272Z","iopub.execute_input":"2021-06-11T07:18:29.760677Z","iopub.status.idle":"2021-06-11T07:18:29.769291Z","shell.execute_reply.started":"2021-06-11T07:18:29.760639Z","shell.execute_reply":"2021-06-11T07:18:29.768024Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"**This is where we will record the history of learning, so that we can make visualization later. We need visualization to evaluate learning, for example, overfitting or underfitting. Of course, we can analyze with numbers, but it is much easier to perceive information visually**","metadata":{}},{"cell_type":"code","source":"losses = {'train':[], 'val':[]}\naccuracies = {'train':[], 'val':[]}","metadata":{"execution":{"iopub.status.busy":"2021-06-11T07:18:29.771020Z","iopub.execute_input":"2021-06-11T07:18:29.771359Z","iopub.status.idle":"2021-06-11T07:18:29.780007Z","shell.execute_reply.started":"2021-06-11T07:18:29.771326Z","shell.execute_reply":"2021-06-11T07:18:29.778955Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"Fit function structure:\n\n1. **Classifier Training**\n2. **Network-wide Training**\n3. **Predictions**","metadata":{}},{"cell_type":"markdown","source":"**In a typical XLA:TPU training scenario we’re training on multiple TPU cores in parallel (a single Cloud TPU device includes 8 TPU cores). So we need to ensure that all the gradients are exchanged between the data parallel replicas by consolidating the gradients and taking an optimizer step. For this we provide the xm.optimizer_step(optimizer) which does the gradient consolidation and step-taking**","metadata":{}},{"cell_type":"code","source":"def fit(seed, epochs, model):\n\n  # Train and valid dataloaders\n  xm.master_print('Creating a model {}...'.format(seed))\n  device = xm.xla_device()\n  WRAPPED_MODEL = xmp.MpModelWrapper(model)\n  model = WRAPPED_MODEL.to(device)\n  model.to(device)  \n  criterion = nn.CrossEntropyLoss()\n\n  if seed==1:\n        optimizer = torch.optim.Adam(model.head.parameters(), lr=0.001* xm.xrt_world_size(), betas=(0.9, 0.999), eps=1e-08, weight_decay=0)\n  if seed==2 or seed==3:\n    optimizer = torch.optim.Adam(model.fc.parameters(), lr=0.001* xm.xrt_world_size(), betas=(0.9, 0.999), eps=1e-08, weight_decay=0)\n  if seed==4 or seed==0:\n    optimizer = torch.optim.Adam(model.classifier.parameters(), lr=0.001* xm.xrt_world_size(), betas=(0.9, 0.999), eps=1e-08, weight_decay=0)\n#   scheduler = torch.optim.lr_scheduler.ReduceLROnPlateau(optimizer, mode='max', factor=0.7, patience=3, verbose=True)\n\n  scheduler = torch.optim.lr_scheduler.StepLR(optimizer, 4, gamma=0.1)\n  since = time.time()\n  best_model = copy.deepcopy(model.state_dict())\n  best_acc = 0.0\n  for epoch in range(epochs):\n    \n    #train\n    xm.master_print('Epoch: {}/{}'.format(epoch+1, epochs))\n    para_loader = pl.ParallelLoader(train_loader, [device])\n    running_corrects, running_loss = train(para_loader.per_device_loader(device), epoch, model, optimizer, criterion)\n    epoch_loss = running_loss / dataset_sizes['train']\n    epoch_acc = running_corrects/dataset_sizes['train']\n    losses['train'].append(epoch_loss)\n    accuracies['train'].append(epoch_acc)\n    xm.master_print('{} - loss:{}, accuracy{}'.format('train', epoch_loss, epoch_acc))\n\n    #val\n    para_loader = pl.ParallelLoader(val_loader, [device])\n    running_corrects, running_loss = test(para_loader.per_device_loader(device), model, criterion)\n    epoch_loss = running_loss / dataset_sizes['val']\n    epoch_acc = running_corrects/dataset_sizes['val']\n    losses['val'].append(epoch_loss)\n    accuracies['val'].append(epoch_acc)\n    xm.master_print('{} - loss:{}, accuracy{}'.format('val', epoch_loss, epoch_acc))\n    \n    #epoch end\n    xm.master_print('Time: {}m {}s'.format((time.time()- since)//60, (time.time()- since)%60))\n    xm.master_print('=='*31)\n    if epoch_acc > best_acc:\n      best_acc = epoch_acc\n      best_model = copy.deepcopy(model.state_dict())\n    scheduler.step()\n      \n  time_elapsed = time.time() - since\n  xm.master_print('CLASSIFIER TRAINING TIME {}m {}s'.format(time_elapsed//60, time_elapsed%60))\n  xm.master_print('=='*31)\n\n\n  model.load_state_dict(best_model)\n\n  for param in model.parameters():\n        param.requires_grad=True\n\n  optimizer = torch.optim.Adam(model.parameters(), lr=0.0001* xm.xrt_world_size(), betas=(0.9, 0.999), eps=1e-08, weight_decay=0)  \n#   scheduler = torch.optim.lr_scheduler.ReduceLROnPlateau(optimizer, mode='max', factor=0.7, patience=3, verbose=True)\n  scheduler = torch.optim.lr_scheduler.StepLR(optimizer, 4, gamma=0.1)\n  for epoch in range(epochs):\n\n    #train\n    xm.master_print('Epoch: {}/{}'.format(epoch+1, epochs))\n    para_loader = pl.ParallelLoader(train_loader, [device])\n    running_corrects, running_loss = train(para_loader.per_device_loader(device), epoch, model, optimizer, criterion)\n    epoch_loss = running_loss / dataset_sizes['train']\n    epoch_acc = running_corrects/dataset_sizes['train']\n    losses['train'].append(epoch_loss)\n    accuracies['train'].append(epoch_acc)\n    xm.master_print('{} - loss:{}, accuracy{}'.format('train', epoch_loss, epoch_acc))\n\n    #val\n    para_loader = pl.ParallelLoader(val_loader, [device])\n    running_corrects, running_loss = test(para_loader.per_device_loader(device), model, criterion)\n    epoch_loss = running_loss / dataset_sizes['val']\n    epoch_acc = running_corrects/dataset_sizes['val']\n    losses['val'].append(epoch_loss)\n    accuracies['val'].append(epoch_acc)\n    xm.master_print('{} - loss:{}, accuracy{}'.format('val', epoch_loss, epoch_acc))\n    \n    #epoch end\n    xm.master_print('Time: {}m {}s'.format((time.time()- since)//60, (time.time()- since)%60))\n    xm.master_print('=='*31)\n    if epoch_acc > best_acc:\n      best_acc = epoch_acc\n      best_model = copy.deepcopy(model.state_dict())\n    scheduler.step()\n\n  time_elapsed = time.time() - since\n  xm.master_print('ALL NET TRAINING TIME {}m {}s'.format(time_elapsed//60, time_elapsed%60))\n  xm.master_print('=='*31)\n\n  model.load_state_dict(best_model)\n    \n  predictions = predict(model, testloader, device)\n  for key in predictions.keys():\n    ensemble_df.loc[ensemble_df['id'] == key, 'model_' + str(seed + 1)] = int((predictions[key]).item())\n  \n  xm.master_print('Prediction Saved! \\n')","metadata":{"execution":{"iopub.status.busy":"2021-06-11T07:18:29.781434Z","iopub.execute_input":"2021-06-11T07:18:29.781748Z","iopub.status.idle":"2021-06-11T07:18:29.810970Z","shell.execute_reply.started":"2021-06-11T07:18:29.781718Z","shell.execute_reply":"2021-06-11T07:18:29.809807Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"# **MODELS**","metadata":{}},{"cell_type":"markdown","source":"**1. DenseNet**","metadata":{}},{"cell_type":"code","source":"densenet121 = torchvision.models.densenet121(pretrained=True)\nfor param in densenet121.parameters():\n  param.requires_grad=False\n\ndensenet121.classifier = nn.Linear(in_features=densenet121.classifier.in_features, out_features=104, bias=True)","metadata":{"execution":{"iopub.status.busy":"2021-06-11T07:18:29.812369Z","iopub.execute_input":"2021-06-11T07:18:29.812797Z","iopub.status.idle":"2021-06-11T07:18:32.151527Z","shell.execute_reply.started":"2021-06-11T07:18:29.812752Z","shell.execute_reply":"2021-06-11T07:18:32.150566Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"**2. ViT**","metadata":{}},{"cell_type":"code","source":"ViT  = timm.create_model(\"vit_base_patch16_224\", pretrained=True)\nfor param in ViT.parameters():\n  param.requires_grad=False\n\nViT.head = nn.Linear(ViT.head.in_features, 104)","metadata":{"execution":{"iopub.status.busy":"2021-06-11T07:18:32.152825Z","iopub.execute_input":"2021-06-11T07:18:32.153124Z","iopub.status.idle":"2021-06-11T07:18:38.370819Z","shell.execute_reply.started":"2021-06-11T07:18:32.153096Z","shell.execute_reply":"2021-06-11T07:18:38.369759Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"**3. GoogLeNet**","metadata":{}},{"cell_type":"code","source":"googlenet = torchvision.models.googlenet(pretrained=True)\nfor param in googlenet.parameters():\n  param.grad_requires = False\n\ngooglenet.fc = nn.Linear(in_features=googlenet.fc.in_features, out_features=104, bias=True)","metadata":{"execution":{"iopub.status.busy":"2021-06-11T07:18:38.372360Z","iopub.execute_input":"2021-06-11T07:18:38.372769Z","iopub.status.idle":"2021-06-11T07:18:41.215229Z","shell.execute_reply.started":"2021-06-11T07:18:38.372724Z","shell.execute_reply":"2021-06-11T07:18:41.214236Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"**4. ResNet**","metadata":{}},{"cell_type":"code","source":"resnet101 = torchvision.models.resnet101(pretrained=True)\nfor param in resnet101.parameters():\n  param.grad_requires = False\n\nresnet101.fc = nn.Linear(in_features=resnet101.fc.in_features, out_features=104, bias=True)","metadata":{"execution":{"iopub.status.busy":"2021-06-11T07:18:41.216406Z","iopub.execute_input":"2021-06-11T07:18:41.216898Z","iopub.status.idle":"2021-06-11T07:18:49.286580Z","shell.execute_reply.started":"2021-06-11T07:18:41.216817Z","shell.execute_reply":"2021-06-11T07:18:49.285769Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"**5. VGG19**","metadata":{}},{"cell_type":"code","source":"vgg19_bn = torchvision.models.vgg19_bn(pretrained=True)\nfor param in vgg19_bn.parameters():\n  param.grad_requires = False\n\nvgg19_bn.classifier[6] = nn.Linear(4096, 104, bias=True)","metadata":{"execution":{"iopub.status.busy":"2021-06-11T07:18:49.288100Z","iopub.execute_input":"2021-06-11T07:18:49.288760Z","iopub.status.idle":"2021-06-11T07:19:10.897900Z","shell.execute_reply.started":"2021-06-11T07:18:49.288712Z","shell.execute_reply":"2021-06-11T07:19:10.896790Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"**Launching training**","metadata":{}},{"cell_type":"code","source":"test_transforms = transforms.Compose([\n                        transforms.CenterCrop(224),\n                        transforms.Resize(224),\n                        transforms.ToTensor(),\n                        transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]),\n                    ])\n\ntest_ds = MyDataset(test_ids, [], test_images, test_transforms, True)\ntestloader = DataLoader(test_ds, 128, num_workers=4, pin_memory=True, shuffle=False)\n\nsubmit_df = pd.read_csv('../input/tpu-getting-started/sample_submission.csv')\nensemble_df = submit_df.copy()\n\nnum_models = 5\nnum_epochs = 10\n\nmodels = [densenet121, ViT, googlenet, resnet101, vgg19_bn]\n\nfor seed in range(num_models):\n   preds = fit(seed=seed, epochs=num_epochs, model=models[seed])","metadata":{"execution":{"iopub.status.busy":"2021-06-11T07:19:10.899294Z","iopub.execute_input":"2021-06-11T07:19:10.899605Z","iopub.status.idle":"2021-06-11T15:18:30.519686Z","shell.execute_reply.started":"2021-06-11T07:19:10.899574Z","shell.execute_reply":"2021-06-11T15:18:30.517638Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"# **4. Submit Preparing**","metadata":{}},{"cell_type":"code","source":"ensemble_df.head(10)","metadata":{"execution":{"iopub.status.busy":"2021-06-11T15:18:30.525908Z","iopub.execute_input":"2021-06-11T15:18:30.526307Z","iopub.status.idle":"2021-06-11T15:18:30.597966Z","shell.execute_reply.started":"2021-06-11T15:18:30.526264Z","shell.execute_reply":"2021-06-11T15:18:30.596810Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"# Final prediction\nfinal_pred = ensemble_df.iloc[:,2:].mode(axis=1).iloc[:,0]\nsubmit_df.label = final_pred.astype(int)\nsubmit_df.head(10)","metadata":{"execution":{"iopub.status.busy":"2021-06-11T15:18:30.599296Z","iopub.execute_input":"2021-06-11T15:18:30.599687Z","iopub.status.idle":"2021-06-11T15:18:34.857091Z","shell.execute_reply.started":"2021-06-11T15:18:30.599655Z","shell.execute_reply":"2021-06-11T15:18:34.855957Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"# Create a submission file\nsubmit_df.to_csv('submission11062021.csv', index=False)","metadata":{"execution":{"iopub.status.busy":"2021-06-11T15:18:34.858456Z","iopub.execute_input":"2021-06-11T15:18:34.858747Z","iopub.status.idle":"2021-06-11T15:18:34.887182Z","shell.execute_reply.started":"2021-06-11T15:18:34.858719Z","shell.execute_reply":"2021-06-11T15:18:34.886384Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"# **5. Learning Visualization**","metadata":{}},{"cell_type":"markdown","source":"**As you can see, the idea of defrosting feature extractor worked and we see a sharp increase in accuracy**","metadata":{}},{"cell_type":"code","source":"fig, ax = plt.subplots(5, 2, figsize=(15, 15))\nmodelname = ['DenseNet', 'ViT', 'GoogLeNet', 'ResNet101', 'VGG16 with BN']\n\nepochs=10\n\ni=0\n\nfor row in range(5):\n\n  epoch_list = list(range(1,epochs*2+1))\n\n  ax[row][0].plot(epoch_list, accuracies['train'][i:20+i], '-o', label='Train Accuracy')\n  ax[row][0].plot(epoch_list, accuracies['val'][i:20+i], '-o', label='Validation Accuracy')\n  ax[row][0].plot([epochs for x in range(20)],  np.linspace(min(accuracies['train'][i:20+i]).cpu(), max(accuracies['train'][i:20+i]).cpu(), 20), color='r', label='Unfreeze net')\n  ax[row][0].set_xticks(np.arange(0, epochs*2+1, 5))\n  ax[row][0].set_ylabel('Accuracy Value')\n  ax[row][0].set_xlabel('Epoch')\n  ax[row][0].set_title('Accuracy {}'.format(modelname[row]))\n  ax[row][0].legend(loc=\"best\")\n\n  ax[row][1].plot(epoch_list, losses['train'][i:20+i], '-o', label='Train Loss')\n  ax[row][1].plot(epoch_list, losses['val'][i:20+i], '-o',label='Validation Loss')\n  ax[row][1].plot([epochs for x in range(20)], np.linspace(min(losses['train'][i:20+i]), max(losses['train'][i:20+i]), 20), color='r', label='Unfreeze net')\n  ax[row][1].set_xticks(np.arange(0, epochs*2+1, 5))\n  ax[row][1].set_ylabel('Loss Value')\n  ax[row][1].set_xlabel('Epoch')\n  ax[row][1].set_title('Loss {}'.format(modelname[row]))\n  ax[row][1].legend(loc=\"best\")\n  fig.tight_layout()\n  fig.subplots_adjust(top=1.5, wspace=0.3)\n\n  i+=20","metadata":{"execution":{"iopub.status.busy":"2021-06-11T15:22:38.181790Z","iopub.execute_input":"2021-06-11T15:22:38.182623Z","iopub.status.idle":"2021-06-11T15:22:41.530379Z","shell.execute_reply.started":"2021-06-11T15:22:38.182564Z","shell.execute_reply":"2021-06-11T15:22:41.529079Z"},"trusted":true},"execution_count":null,"outputs":[]}]}