{"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":"# Learning to Combine: Knowledge Aggregation for Multi-Source Domain Adaptation\n","metadata":{}},{"cell_type":"markdown","source":"### **Introduction:**\nThe paper \"Learning to Combine: Knowledge Aggregation for Multi-Source Domain Adaptation\" addresses the challenge of multi-source domain adaptation (MSDA) by proposing a Learning to Combine for MSDA (LtC-MSDA) framework. MSDA involves transferring knowledge learned from multiple source domains to a target domain, which is more practical and challenging than conventional single-source domain adaptation. The proposed framework aims to mitigate the problems arising due to the increase of modalities and aligning feature distributions among multiple domains.\n\n### **Research Question:**\nThe research question addressed in this paper is how to achieve more precise predictions for target samples in MSDA through the utilization of knowledge among different domains, thereby mitigating the error of single-source prediction.\n\n### **Contribution:**\nThe paper proposes a Learning to Combine for MSDA (LtC-MSDA) framework that uses a knowledge graph to explore interactions among domains, facilitating the combination of different domains' knowledge via information propagation. The proposed framework learns a graph model that predicts query samples under the guidance of correlated prototypes. Additionally, the paper introduces a Relation Alignment Loss (RAL) to boost the features' intra-class invariance and inter-class separability, ensuring the consistency of categories' relational interdependency on all domains.\n\nThe proposed framework outperforms existing methods with a remarkable margin, as shown by the comprehensive results on public benchmark datasets. The paper's contribution lies in providing an end-to-end learnable solution for MSDA that exploits interactions among domains through a knowledge graph and the use of a GCN model for information propagation. The proposed RAL enhances the model's performance by boosting the features' intra-class invariance and inter-class separability.\n\n### **Conclusion:**\nIn conclusion, the paper proposes a Learning to Combine for MSDA (LtC-MSDA) framework that addresses the challenge of multi-source domain adaptation by exploiting interactions among domains through a knowledge graph and a GCN model for information propagation. The proposed RAL enhances the model's performance by boosting the features' intra-class invariance and inter-class separability, ensuring the consistency of categories' relational interdependency on all domains. The proposed framework outperforms existing methods with a remarkable margin, as shown by the comprehensive results on public benchmark datasets.","metadata":{}},{"cell_type":"markdown","source":"# CIFAR10 + ResNet18","metadata":{}},{"cell_type":"code","source":"!pip install timm","metadata":{"scrolled":true,"execution":{"iopub.status.busy":"2023-04-28T02:57:42.777889Z","iopub.execute_input":"2023-04-28T02:57:42.778290Z","iopub.status.idle":"2023-04-28T02:57:54.090497Z","shell.execute_reply.started":"2023-04-28T02:57:42.778210Z","shell.execute_reply":"2023-04-28T02:57:54.089301Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"# Introduction:\n\nThe CIFAR-10 dataset contains 60,000 color images of 32 x 32 pixels in 3 channels divided into 10 classes. Each class contains 6,000 images. The training set contains 50,000 images, while the test sets provides 10,000 images. This image taken from the CIFAR repository ( https://www.cs.toronto.edu/~kriz/cifar.html ). This is a classification problem with 10 classes(muti-label classification). We can take a view on this image for more comprehension of the dataset.","metadata":{}},{"cell_type":"markdown","source":"**Label Encoding is as follows:**\n\n| **Label** | **Type** |\n| -: | :-: |\n| 0 | airplane |\n| 1 | automobile |\n| 2 | bird |\n| 3 | cat |\n| 4 | deer |\n| 5 | dog |\n| 6 | frog |\n| 7 | horse |\n| 8 | ship |\n| 9 | truck |","metadata":{}},{"cell_type":"code","source":"import numpy as np\nimport pandas as pd\nimport matplotlib.pyplot as plt\nimport pickle\nfrom PIL import Image\nimport torchvision.datasets as dsets\nimport torchvision.transforms as transforms\nimport torch\nimport torch.nn as nn\nimport pickle\nimport os\nimport torch.nn.functional as F\nimport requests\nfrom sklearn.metrics import confusion_matrix, classification_report\nimport seaborn as sn\nimport pandas as pd\nimport timm\n\n\ntorch.manual_seed(1)  # Set manual seed\nfrom sklearn import preprocessing\nfrom torch.utils.data import DataLoader, Dataset, Subset\n\n# Define GPU device - We will run our model on GPU\nmps_device = torch.device(\"cuda\")\n","metadata":{"ExecuteTime":{"end_time":"2023-01-12T03:35:34.14164Z","start_time":"2023-01-12T03:35:31.219551Z"},"execution":{"iopub.status.busy":"2023-04-28T02:57:54.094836Z","iopub.execute_input":"2023-04-28T02:57:54.095140Z","iopub.status.idle":"2023-04-28T02:57:57.203117Z","shell.execute_reply.started":"2023-04-28T02:57:54.095108Z","shell.execute_reply":"2023-04-28T02:57:57.202007Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"# 1. Data Preparation\n\n\nThe idea here is to pass as much as different transformed images to our model so that our model learns complex patterns and restricts itself to overfit.\n\nThe following steps have been implemented for the same\n\n- *Image resizing* : As the image size from source is 32X32 we apply resize function just to make sure every images passed to our process is similar in terms of size\n\n\n- *Image transformation*: We apply different transformation to the image. Details mentioned below. Here one point to note is that we can randomly apply every type of transformation as this might lead to underfitting. The reason behind this is that the resolution of the images is already very low and applying some critical transfortions like centercrop, vertical flip and other might decay model performance\n\n\n- *Apply normalization to image*: The mean and standard deviation is taken from different studies researchers have implemented and have them to converge faster. You can experiment with different image size and standard deviations as well\n\n\n- *Apply Random Erasing*: It helps in randomly adding some noise to the image, so that the model can learn to generalize better.","metadata":{}},{"cell_type":"markdown","source":"**Define the image size and transformation pipeline for training and validation**","metadata":{}},{"cell_type":"code","source":"IMAGE_SIZE = 224\n\nmean, std = [0.4914, 0.4822, 0.4465], [0.247, 0.243, 0.261]\n# These values are mostly used by researchers as found to very useful in fast convergence\n\n\n# https://pytorch.org/vision/stable/transforms.html\n# We can try various transformation for good generalization of model\ncomposed_train = transforms.Compose(\n    [\n        transforms.Resize(\n            (IMAGE_SIZE, IMAGE_SIZE)\n        ),  # Resize the image in a 32X32 shape\n        transforms.RandomRotation(20),  # Randomly rotate some images by 20 degrees\n        transforms.RandomHorizontalFlip(0.5),  # Randomly horizontal flip the images\n        transforms.ColorJitter(\n            brightness=0.1,  # Randomly adjust color jitter of the images\n            contrast=0.1,\n            saturation=0.1,\n        ),\n        transforms.RandomAdjustSharpness(\n            sharpness_factor=2, p=0.1\n        ),  # Randomly adjust sharpness\n        transforms.ToTensor(),  # Converting image to tensor\n        transforms.Normalize(\n            mean, std\n        ),  # Normalizing with standard mean and standard deviation\n        transforms.RandomErasing(p=0.5, scale=(0.02, 0.1), value=1.0, inplace=False),\n    ]\n)\n\n\ncomposed_test = transforms.Compose(\n    [\n        transforms.Resize((IMAGE_SIZE, IMAGE_SIZE)),\n        transforms.ToTensor(),\n        transforms.Normalize(mean, std),\n    ]\n)\n","metadata":{"ExecuteTime":{"end_time":"2023-01-12T03:35:34.154114Z","start_time":"2023-01-12T03:35:34.149023Z"},"execution":{"iopub.status.busy":"2023-04-28T02:57:57.204685Z","iopub.execute_input":"2023-04-28T02:57:57.205252Z","iopub.status.idle":"2023-04-28T02:57:57.215111Z","shell.execute_reply.started":"2023-04-28T02:57:57.205211Z","shell.execute_reply":"2023-04-28T02:57:57.213424Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"**Load train and validation dataset**","metadata":{}},{"cell_type":"code","source":"# Load the data and transform the dataset\ntrain_dataset = dsets.CIFAR10(\n    root=\"./data\", train=True, download=True, transform=composed_train\n)\nvalidation_dataset = dsets.CIFAR10(\n    root=\"./data\", train=False, download=True, transform=composed_test\n)\n\n# Create train and validation batch for training\ntrain_loader = torch.utils.data.DataLoader(dataset=train_dataset, batch_size=256, shuffle=True)\nvalidation_loader = torch.utils.data.DataLoader(\n    dataset=validation_dataset, batch_size=256\n)\n","metadata":{"ExecuteTime":{"end_time":"2023-01-12T03:35:35.774839Z","start_time":"2023-01-12T03:35:34.161393Z"},"execution":{"iopub.status.busy":"2023-04-28T02:57:57.216569Z","iopub.execute_input":"2023-04-28T02:57:57.217248Z","iopub.status.idle":"2023-04-28T02:58:13.893200Z","shell.execute_reply.started":"2023-04-28T02:57:57.217210Z","shell.execute_reply":"2023-04-28T02:58:13.892217Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"**Some important functions to print the images and image convertor from tensor to numpy**","metadata":{}},{"cell_type":"code","source":"def show_data(img):\n    try:\n        plt.imshow(img[0])\n    except Exception as e:\n        print(e)\n    print(img[0].shape, img[0].permute(1, 2, 0).shape)\n    plt.imshow(img[0].permute(1, 2, 0))\n    plt.title(\"y = \" + str(img[1]))\n    plt.show()\n\n\n# We need to convert the images to numpy arrays as tensors are not compatible with matplotlib.\ndef im_convert(tensor):\n    # Lets\n    img = tensor.cpu().clone().detach().numpy()  #\n    img = img.transpose(1, 2, 0)\n    img = img * np.array(tuple(mean)) + np.array(tuple(std))\n    img = img.clip(0, 1)  # Clipping the size to print the images later\n    return img\n","metadata":{"ExecuteTime":{"end_time":"2023-01-12T03:35:35.789356Z","start_time":"2023-01-12T03:35:35.78525Z"},"execution":{"iopub.status.busy":"2023-04-28T02:58:13.896676Z","iopub.execute_input":"2023-04-28T02:58:13.897088Z","iopub.status.idle":"2023-04-28T02:58:13.904557Z","shell.execute_reply.started":"2023-04-28T02:58:13.897048Z","shell.execute_reply":"2023-04-28T02:58:13.903540Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"**Lets print some random datasets**","metadata":{}},{"cell_type":"code","source":"show_data(train_dataset[8])\n","metadata":{"ExecuteTime":{"end_time":"2023-01-12T03:35:35.92177Z","start_time":"2023-01-12T03:35:35.797086Z"},"execution":{"iopub.status.busy":"2023-04-28T02:58:13.906534Z","iopub.execute_input":"2023-04-28T02:58:13.907188Z","iopub.status.idle":"2023-04-28T02:58:14.190290Z","shell.execute_reply.started":"2023-04-28T02:58:13.907126Z","shell.execute_reply":"2023-04-28T02:58:14.188745Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"# Different classes in CIPHAR 10 dataset.\nclasses = (\n    \"airplane\",\n    \"automobile\",\n    \"bird\",\n    \"cat\",\n    \"deer\",\n    \"dog\",\n    \"frog\",\n    \"horse\",\n    \"ship\",\n    \"truck\",\n)\n\n# Define an iterable on the data\ndata_iterable = iter(\n    train_loader\n)  # converting our train_dataloader to iterable so that we can iter through it.\nimages, labels = next(\n    data_iterable\n)  # going from 1st batch of 100 images to the next batch\nfig = plt.figure(figsize=(20, 10))\n\n# Lets plot 50 images from our train_dataset\nfor idx in np.arange(10):\n    ax = fig.add_subplot(2, 5, idx + 1, xticks=[], yticks=[])\n\n    # Note: imshow cant print tensor !\n    # Lets convert tensor image to numpy using im_convert function for imshow to print the image\n    plt.imshow(im_convert(images[idx]))\n    ax.set_title(classes[labels[idx].item()])\n","metadata":{"ExecuteTime":{"end_time":"2023-01-12T06:46:12.464082Z","start_time":"2023-01-12T06:46:12.211329Z"},"execution":{"iopub.status.busy":"2023-04-28T02:58:14.192989Z","iopub.execute_input":"2023-04-28T02:58:14.193770Z","iopub.status.idle":"2023-04-28T02:58:16.369861Z","shell.execute_reply.started":"2023-04-28T02:58:14.193708Z","shell.execute_reply":"2023-04-28T02:58:16.368782Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"## 2. Convolution Neural Network Implementation","metadata":{}},{"cell_type":"markdown","source":"**i) Define common model training module**","metadata":{}},{"cell_type":"code","source":"def train_model(model, train_loader, validation_loader, optimizer, n_epochs=20):\n    # Global variable\n    N_test = len(validation_dataset)\n    accuracy_list = []\n    train_loss_list = []\n    model = model.to(mps_device)\n    train_cost_list = []\n    val_cost_list = []\n\n    for epoch in range(n_epochs):\n        train_COST = 0\n        for x, y in train_loader:\n            x = x.to(mps_device)\n            y = y.to(mps_device)\n            model.train()\n            optimizer.zero_grad()\n            z = model(x)\n            loss = criterion(z, y)\n            loss.backward()\n            optimizer.step()\n            train_COST += loss.item()\n\n        train_COST = train_COST / len(train_loader)\n        train_cost_list.append(train_COST)\n        correct = 0\n\n        # Perform the prediction on the validation data\n        val_COST = 0\n        for x_test, y_test in validation_loader:\n            model.eval()\n            x_test = x_test.to(mps_device)\n            y_test = y_test.to(mps_device)\n            z = model(x_test)\n            val_loss = criterion(z, y_test)\n            _, yhat = torch.max(z.data, 1)\n            correct += (yhat == y_test).sum().item()\n            val_COST += val_loss.item()\n\n        val_COST = val_COST / len(validation_loader)\n        val_cost_list.append(val_COST)\n\n        accuracy = correct / N_test\n        accuracy_list.append(accuracy)\n\n        print(\n            \"--> Epoch Number : {}\".format(epoch + 1),\n            \" | Training Loss : {}\".format(round(train_COST, 4)),\n            \" | Validation Loss : {}\".format(round(val_COST, 4)),\n            \" | Validation Accuracy : {}%\".format(round(accuracy * 100, 2)),\n        )\n\n    return accuracy_list, train_cost_list, val_cost_list\n","metadata":{"ExecuteTime":{"end_time":"2023-01-12T03:35:38.3747Z","start_time":"2023-01-12T03:35:38.355133Z"},"execution":{"iopub.status.busy":"2023-04-28T02:58:16.371566Z","iopub.execute_input":"2023-04-28T02:58:16.372417Z","iopub.status.idle":"2023-04-28T02:58:16.400062Z","shell.execute_reply.started":"2023-04-28T02:58:16.372375Z","shell.execute_reply":"2023-04-28T02:58:16.398939Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"class ResNet(nn.Module):\n    def __init__(self, model_name=\"resnet18d\"):\n        super().__init__()\n        self.model = timm.create_model(model_name, pretrained=True)\n        n_features = self.model.fc.in_features\n        #         self.model.global_pool = nn.Identity()\n        #         self.model.fc = nn.Identity()\n        #         self.pooling = nn.AdaptiveAvgPool2d(1)\n        #         self.fc = nn.Linear(n_features, 10)\n\n        self.model.fc = nn.Linear(n_features, 10)\n\n    def forward(self, x):\n#         bs = x.size(0)\n#         features = self.model(x)\n        #         pooled_features = self.pooling(features).view(bs, -1)\n        #         output = self.fc(pooled_features)\n#         return output\n        return self.model(x)\n","metadata":{"execution":{"iopub.status.busy":"2023-04-28T02:58:16.401825Z","iopub.execute_input":"2023-04-28T02:58:16.402619Z","iopub.status.idle":"2023-04-28T02:58:16.435950Z","shell.execute_reply.started":"2023-04-28T02:58:16.402578Z","shell.execute_reply":"2023-04-28T02:58:16.434905Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"![image.png](attachment:8d6eabff-54c4-4ff0-a137-869cff10ed4a.png)","metadata":{},"attachments":{"8d6eabff-54c4-4ff0-a137-869cff10ed4a.png":{"image/png":"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"}}},{"cell_type":"code","source":"# Define the model\nmodel_mmtv5 = ResNet()\n\n# Define the model learning hyperparameters\ncriterion = nn.CrossEntropyLoss()\noptimizer = torch.optim.Adam(model_mmtv5.parameters())\n\n# Train the model\naccuracy_list_normal, train_cost_list, val_cost_list = train_model(\n    model=model_mmtv5,\n    n_epochs=20,\n    train_loader=train_loader,\n    validation_loader=validation_loader,\n    optimizer=optimizer,\n)\n","metadata":{"ExecuteTime":{"end_time":"2023-01-03T16:57:27.523485Z","start_time":"2023-01-03T16:48:57.592468Z"},"_kg_hide-output":true,"execution":{"iopub.status.busy":"2023-04-28T03:12:51.178790Z","iopub.execute_input":"2023-04-28T03:12:51.179488Z","iopub.status.idle":"2023-04-28T03:18:18.368591Z","shell.execute_reply.started":"2023-04-28T03:12:51.179451Z","shell.execute_reply":"2023-04-28T03:18:18.367525Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"# Save model:\npickle.dump(model_mmtv5, open(\"./model_mmtv5.pkl\", \"wb\"))","metadata":{"ExecuteTime":{"end_time":"2023-01-03T17:02:35.023674Z","start_time":"2023-01-03T17:02:35.014772Z"},"execution":{"iopub.status.busy":"2023-04-28T03:18:18.370774Z","iopub.execute_input":"2023-04-28T03:18:18.371161Z","iopub.status.idle":"2023-04-28T03:18:18.481747Z","shell.execute_reply.started":"2023-04-28T03:18:18.371122Z","shell.execute_reply":"2023-04-28T03:18:18.480307Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"# 3. Model Performance Report & Error Analysis","metadata":{}},{"cell_type":"markdown","source":"**i) Printing model training loss vs accuracy:**","metadata":{}},{"cell_type":"code","source":"fig, ax1 = plt.subplots()\ncolor = \"tab:red\"\nax1.plot(train_cost_list, color=color)\nax1.set_xlabel(\"epoch\", color=color)\nax1.set_ylabel(\"total loss\", color=color)\nax1.tick_params(axis=\"y\", color=color)\n\nax2 = ax1.twinx()\ncolor = \"tab:blue\"\nax2.set_ylabel(\"accuracy\", color=color)\nax2.plot(accuracy_list_normal, color=color)\nax2.tick_params(axis=\"y\", labelcolor=color)\nfig.tight_layout()\n","metadata":{"ExecuteTime":{"end_time":"2023-01-12T06:01:27.104742Z","start_time":"2023-01-12T06:01:26.903829Z"},"execution":{"iopub.status.busy":"2023-04-28T03:18:18.483870Z","iopub.execute_input":"2023-04-28T03:18:18.484948Z","iopub.status.idle":"2023-04-28T03:18:18.785625Z","shell.execute_reply.started":"2023-04-28T03:18:18.484907Z","shell.execute_reply":"2023-04-28T03:18:18.784630Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"**Takeaway**\n\nAs we can see that there is no sort of anomolous behavior in model traning and model converges to minima smoothly","metadata":{}},{"cell_type":"markdown","source":"**ii) Printing training and validation loss:**","metadata":{}},{"cell_type":"code","source":"plt.plot(train_cost_list, \"r\", label=\"Training Loss\")\nplt.plot(val_cost_list, \"g\", label=\"Validation Loss\")\nplt.xlabel(\"Iteration\")\nplt.title(\"Loss\")\nplt.legend()\n","metadata":{"ExecuteTime":{"end_time":"2023-01-12T06:01:30.115149Z","start_time":"2023-01-12T06:01:30.001415Z"},"execution":{"iopub.status.busy":"2023-04-28T03:18:18.788398Z","iopub.execute_input":"2023-04-28T03:18:18.788787Z","iopub.status.idle":"2023-04-28T03:18:19.002673Z","shell.execute_reply.started":"2023-04-28T03:18:18.788744Z","shell.execute_reply":"2023-04-28T03:18:19.001647Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"**Takeaways :** \n\nWe can see that the training loss and validation loss are close to each other. This gives a sense that we did a decent job in **avoiding our model to overfit.**","metadata":{}},{"cell_type":"markdown","source":"**iii) Error Analysis: Printing Confusion Matrix & Classification Report :**","metadata":{}},{"cell_type":"code","source":"y_pred = []\ny_true = []\n\n# iterate over test data\nfor x, y in torch.utils.data.DataLoader(dataset=validation_dataset, batch_size=1):\n    # print('iter val', i)\n    x = x.to(mps_device)\n    y = y.to(mps_device)\n    z = model_mmtv5(x)\n    _, yhat = torch.max(z, 1)\n    pred = yhat.data.cpu().numpy()\n    y_pred.extend(pred)  # Save Prediction\n\n    labels = y.data.cpu().numpy()\n    y_true.extend(labels)  # Save Truth\n\n# Build confusion matrix\ncf_matrix = confusion_matrix(y_true, y_pred)\ndf_cm = pd.DataFrame(\n    cf_matrix / np.sum(cf_matrix) * 10,\n    index=[i for i in classes],\n    columns=[i for i in classes],\n)\nplt.figure(figsize=(12, 7))\nsn.heatmap(df_cm, annot=True)\nplt.savefig(\"output.png\")\n","metadata":{"ExecuteTime":{"end_time":"2023-01-12T06:02:30.943667Z","start_time":"2023-01-12T06:01:33.045037Z"},"execution":{"iopub.status.busy":"2023-04-28T03:18:19.004584Z","iopub.execute_input":"2023-04-28T03:18:19.005543Z","iopub.status.idle":"2023-04-28T03:19:13.780328Z","shell.execute_reply.started":"2023-04-28T03:18:19.005502Z","shell.execute_reply":"2023-04-28T03:19:13.779249Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"print(classification_report(y_true, y_pred))\n","metadata":{"ExecuteTime":{"end_time":"2023-01-12T06:04:05.364903Z","start_time":"2023-01-12T06:04:05.331539Z"},"_kg_hide-input":true,"execution":{"iopub.status.busy":"2023-04-28T03:19:13.781995Z","iopub.execute_input":"2023-04-28T03:19:13.782434Z","iopub.status.idle":"2023-04-28T03:19:13.814211Z","shell.execute_reply.started":"2023-04-28T03:19:13.782397Z","shell.execute_reply":"2023-04-28T03:19:13.813198Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"# Plot the mis-classified samples\ncount = 0\ni = 0\nfor x, y in torch.utils.data.DataLoader(dataset=validation_dataset, batch_size=1):\n    # print('iter val', i)\n    x = x.to(mps_device)\n    y = y.to(mps_device)\n    z = model_mmtv5(x)\n    _, yhat = torch.max(z, 1)\n    if yhat != y:\n        show_data(validation_dataset[i])\n        plt.show()\n        print(\"yhat: \", yhat)\n        count += 1\n    if count >= 3:\n        break\n    i += 1\n","metadata":{"ExecuteTime":{"end_time":"2023-01-12T06:04:49.989669Z","start_time":"2023-01-12T06:04:49.526144Z"},"execution":{"iopub.status.busy":"2023-04-28T03:19:13.815675Z","iopub.execute_input":"2023-04-28T03:19:13.816043Z","iopub.status.idle":"2023-04-28T03:19:14.687266Z","shell.execute_reply.started":"2023-04-28T03:19:13.816008Z","shell.execute_reply":"2023-04-28T03:19:14.686270Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"**iv) Printing how out model performs on the first 20 images:**","metadata":{}},{"cell_type":"code","source":"data_iterable = iter(validation_loader)\nimages, labels = next(data_iterable)\nimages = images.to(mps_device)\nlabels = labels.to(mps_device)\noutput = model_mmtv5(images)\n_, preds = torch.max(output, 1)\n\nfig = plt.figure(figsize=(25, 5))\n\nfor idx in np.arange(20):\n    ax = fig.add_subplot(2, 10, idx + 1, xticks=[], yticks=[])\n    plt.imshow(im_convert(images[idx]))\n    ax.set_title(\n        \"{} ({})\".format(\n            str(classes[preds[idx].item()]), str(classes[labels[idx].item()])\n        ),\n        color=(\"green\" if preds[idx] == labels[idx] else \"red\"),\n    )\n","metadata":{"ExecuteTime":{"end_time":"2023-01-12T06:04:55.151415Z","start_time":"2023-01-12T06:04:54.49281Z"},"_kg_hide-input":true,"execution":{"iopub.status.busy":"2023-04-28T03:19:14.688801Z","iopub.execute_input":"2023-04-28T03:19:14.689415Z","iopub.status.idle":"2023-04-28T03:19:16.371546Z","shell.execute_reply.started":"2023-04-28T03:19:14.689376Z","shell.execute_reply":"2023-04-28T03:19:16.370631Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"# 4. Performance on Hold-Out Set","metadata":{}},{"cell_type":"markdown","source":"**Randomly test our model performance on random image taken from internet and see how our model performs on totally unseen data**","metadata":{}},{"cell_type":"code","source":"url = \"https://encrypted-tbn0.gstatic.com/images?q=tbn:ANd9GcRsa3ISspmdRq4nDC9M6pfoNh1TvukFHBzGuA&usqp=CAU\"\nresponse = requests.get(url, stream=True)\nimg = Image.open(response.raw)\nplt.imshow(img)\n\n# Image cleared to reduce size of ipynb file\n","metadata":{"ExecuteTime":{"end_time":"2023-01-12T06:05:00.130844Z","start_time":"2023-01-12T06:04:59.783618Z"},"execution":{"iopub.status.busy":"2023-04-28T03:19:16.373160Z","iopub.execute_input":"2023-04-28T03:19:16.373952Z","iopub.status.idle":"2023-04-28T03:19:16.622525Z","shell.execute_reply.started":"2023-04-28T03:19:16.373898Z","shell.execute_reply":"2023-04-28T03:19:16.621648Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"# Convert holdout image to testing format\nimg = composed_test(img)\nplt.imshow(im_convert(img))\n\nimage = img.to(mps_device).unsqueeze(0)\noutput = model_mmtv5(image)\n_, pred = torch.max(output, 1)\nprint(\"Prediction by Model:\", (classes[pred.item()]))\n","metadata":{"ExecuteTime":{"end_time":"2023-01-12T06:05:02.51582Z","start_time":"2023-01-12T06:05:02.423782Z"},"execution":{"iopub.status.busy":"2023-04-28T03:19:16.626245Z","iopub.execute_input":"2023-04-28T03:19:16.626597Z","iopub.status.idle":"2023-04-28T03:19:16.854768Z","shell.execute_reply.started":"2023-04-28T03:19:16.626561Z","shell.execute_reply":"2023-04-28T03:19:16.853678Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"url = (\n    \"https://cdn.pixabay.com/photo/2016/02/19/15/46/labrador-retriever-1210559__480.jpg\"\n)\nresponse = requests.get(url, stream=True)\nimg = Image.open(response.raw)\nplt.imshow(img)\n","metadata":{"ExecuteTime":{"end_time":"2023-01-12T06:05:04.362706Z","start_time":"2023-01-12T06:05:04.096454Z"},"execution":{"iopub.status.busy":"2023-04-28T03:19:16.856067Z","iopub.execute_input":"2023-04-28T03:19:16.856443Z","iopub.status.idle":"2023-04-28T03:19:17.186549Z","shell.execute_reply.started":"2023-04-28T03:19:16.856406Z","shell.execute_reply":"2023-04-28T03:19:17.185651Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"# Convert holdout image to testing format\nimg = composed_test(img)\nplt.imshow(im_convert(img))\nimage = img.to(mps_device).unsqueeze(0)\noutput = model_mmtv5(image)\n_, pred = torch.max(output, 1)\nprint(\"Prediction by Model:\", (classes[pred.item()]))\n","metadata":{"ExecuteTime":{"end_time":"2023-01-12T06:05:05.999176Z","start_time":"2023-01-12T06:05:05.93402Z"},"execution":{"iopub.status.busy":"2023-04-28T03:19:17.187975Z","iopub.execute_input":"2023-04-28T03:19:17.189064Z","iopub.status.idle":"2023-04-28T03:19:17.429413Z","shell.execute_reply.started":"2023-04-28T03:19:17.189018Z","shell.execute_reply":"2023-04-28T03:19:17.428762Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"# 5. Prediction on Test","metadata":{}},{"cell_type":"code","source":"class TestImageDataset(Dataset):\n    def __init__(\n        self, annotations_file, img_dir, transform=None, target_transform=None\n    ):\n        self.img_labels = pd.read_csv(annotations_file)\n        self.img_dir = img_dir\n        self.transform = transform\n        self.target_transform = target_transform\n\n    def __len__(self):\n        return len(self.img_labels)\n\n    def __getitem__(self, idx):\n        # Define the path where images are stored by yourself.\n        # Remember, the first image is ./train/1.png\n        img_path = self.img_dir + \"/\" + str(self.img_labels.iloc[idx, 0]) + \".png\"\n\n        # Read image. Recall how you converted an image to numpy array in the previous step.\n        image = np.asarray(Image.open(img_path).convert(\"RGB\"))\n\n        label = self.img_labels.iloc[idx, 1]\n        if self.transform:\n            image = self.transform(image)\n        if self.target_transform:\n            label = self.target_transform(label)\n        return image, label\n","metadata":{"ExecuteTime":{"end_time":"2023-01-12T06:05:08.731504Z","start_time":"2023-01-12T06:05:08.716616Z"},"execution":{"iopub.status.busy":"2023-04-28T03:19:17.430614Z","iopub.execute_input":"2023-04-28T03:19:17.431586Z","iopub.status.idle":"2023-04-28T03:19:17.440441Z","shell.execute_reply.started":"2023-04-28T03:19:17.431545Z","shell.execute_reply":"2023-04-28T03:19:17.439460Z"},"trusted":true},"execution_count":null,"outputs":[]}]}