Coding_test_IISc.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "Coding_test_IISc.ipynb",
      "provenance": [],
      "collapsed_sections": []
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    }
  },
  "cells": [
    {
      "cell_type": "code",
      "metadata": {
        "id": "E0b_7LuHHdC1"
      },
      "source": [
        "# importing the required libraries\n",
        "from __future__ import print_function\n",
        "from __future__ import division\n",
        "import torch\n",
        "import torch.nn as nn\n",
        "import torch.optim as optim\n",
        "import numpy as np\n",
        "import torchvision\n",
        "from torch.utils.data import Subset, DataLoader\n",
        "from torchvision import datasets, models, transforms\n",
        "import torch.nn.functional as F\n",
        "import matplotlib.pyplot as plt\n",
        "import time\n",
        "import os\n",
        "import copy\n",
        "import sys\n",
        "import os\n",
        "import logging\n",
        "from PIL import Image\n",
        "from tqdm import tqdm"
      ],
      "execution_count": 53,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "hlqwIVCpGAvg"
      },
      "source": [
        "# !unzip drive/MyDrive/PACS.zip &> /dev/null\n",
        "# from PIL import Image\n",
        "\n",
        "# Image.open('/content/kfold/cartoon/dog/pic_016.jpg').size"
      ],
      "execution_count": 54,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "O5DGRLXNFufM"
      },
      "source": [
        "def set_parameter_requires_grad(model, feature_extracting):\n",
        "    if feature_extracting:\n",
        "        for param in model.parameters():\n",
        "            param.requires_grad = False"
      ],
      "execution_count": 55,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "1zRyEiz8du4j",
        "outputId": "ba130724-fb58-4b51-e5d8-583f6696dd01"
      },
      "source": [
        "def initialize_model(num_classes, feature_extract = True, use_pretrained=True):\n",
        "    model_ft = None\n",
        "    input_size = 0\n",
        "\n",
        "    model_ft = models.resnet18(pretrained=use_pretrained) #Using pretrained feature extractor \n",
        "    set_parameter_requires_grad(model_ft, feature_extract) #Setting .reuires_grad to False so that params remains fixed for feature extractor\n",
        "    num_ftrs = model_ft.fc.in_features\n",
        "    model_ft.fc = nn.Linear(num_ftrs, num_classes) #Classifier\n",
        "\n",
        "    return model_ft\n",
        "\n",
        "feature_extract = True\n",
        "\n",
        "model_ft = initialize_model( 7, feature_extract = True, use_pretrained=True) #for determining object class\n",
        "\n",
        "lamda_param = torch.Tensor([0.43,0.23, 0.33]) # randomly initialized\n",
        "\n",
        "# taking only those parameters that are to be optimized\n",
        "if feature_extract:\n",
        "    params_to_update = []\n",
        "    for name,param in model_ft.named_parameters():\n",
        "        if param.requires_grad == True:\n",
        "            params_to_update.append(param)\n",
        "            print(\"\\t\",name)\n",
        "    params_to_update.append(lamda_param)\n",
        "optimizer_ft = optim.SGD(params_to_update, lr=0.001, momentum=0.9)"
      ],
      "execution_count": 56,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "\t fc.weight\n",
            "\t fc.bias\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "lfT2GPxCU4mc",
        "outputId": "bcb9ab57-2230-4edb-9f07-f5db9be84400"
      },
      "source": [
        "print(model_ft)"
      ],
      "execution_count": 57,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "ResNet(\n",
            "  (conv1): Conv2d(3, 64, kernel_size=(7, 7), stride=(2, 2), padding=(3, 3), bias=False)\n",
            "  (bn1): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
            "  (relu): ReLU(inplace=True)\n",
            "  (maxpool): MaxPool2d(kernel_size=3, stride=2, padding=1, dilation=1, ceil_mode=False)\n",
            "  (layer1): Sequential(\n",
            "    (0): BasicBlock(\n",
            "      (conv1): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
            "      (bn1): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
            "      (relu): ReLU(inplace=True)\n",
            "      (conv2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
            "      (bn2): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
            "    )\n",
            "    (1): BasicBlock(\n",
            "      (conv1): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
            "      (bn1): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
            "      (relu): ReLU(inplace=True)\n",
            "      (conv2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
            "      (bn2): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
            "    )\n",
            "  )\n",
            "  (layer2): Sequential(\n",
            "    (0): BasicBlock(\n",
            "      (conv1): Conv2d(64, 128, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1), bias=False)\n",
            "      (bn1): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
            "      (relu): ReLU(inplace=True)\n",
            "      (conv2): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
            "      (bn2): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
            "      (downsample): Sequential(\n",
            "        (0): Conv2d(64, 128, kernel_size=(1, 1), stride=(2, 2), bias=False)\n",
            "        (1): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
            "      )\n",
            "    )\n",
            "    (1): BasicBlock(\n",
            "      (conv1): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
            "      (bn1): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
            "      (relu): ReLU(inplace=True)\n",
            "      (conv2): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
            "      (bn2): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
            "    )\n",
            "  )\n",
            "  (layer3): Sequential(\n",
            "    (0): BasicBlock(\n",
            "      (conv1): Conv2d(128, 256, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1), bias=False)\n",
            "      (bn1): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
            "      (relu): ReLU(inplace=True)\n",
            "      (conv2): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
            "      (bn2): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
            "      (downsample): Sequential(\n",
            "        (0): Conv2d(128, 256, kernel_size=(1, 1), stride=(2, 2), bias=False)\n",
            "        (1): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
            "      )\n",
            "    )\n",
            "    (1): BasicBlock(\n",
            "      (conv1): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
            "      (bn1): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
            "      (relu): ReLU(inplace=True)\n",
            "      (conv2): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
            "      (bn2): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
            "    )\n",
            "  )\n",
            "  (layer4): Sequential(\n",
            "    (0): BasicBlock(\n",
            "      (conv1): Conv2d(256, 512, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1), bias=False)\n",
            "      (bn1): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
            "      (relu): ReLU(inplace=True)\n",
            "      (conv2): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
            "      (bn2): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
            "      (downsample): Sequential(\n",
            "        (0): Conv2d(256, 512, kernel_size=(1, 1), stride=(2, 2), bias=False)\n",
            "        (1): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
            "      )\n",
            "    )\n",
            "    (1): BasicBlock(\n",
            "      (conv1): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
            "      (bn1): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
            "      (relu): ReLU(inplace=True)\n",
            "      (conv2): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
            "      (bn2): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
            "    )\n",
            "  )\n",
            "  (avgpool): AdaptiveAvgPool2d(output_size=(1, 1))\n",
            "  (fc): Linear(in_features=512, out_features=7, bias=True)\n",
            ")\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "9TqW2C4Po40Z",
        "outputId": "a9223d37-78ba-46e7-e26d-4be8e4c0947a"
      },
      "source": [
        "if not os.path.isdir('./Homework3-PACS'):\n",
        "  !git clone https://github.com/MachineLearning2020/Homework3-PACS\n",
        "\n",
        "# Define datasets root\n",
        "DIR_PHOTO = 'Homework3-PACS/PACS/photo'\n",
        "DIR_ART = 'Homework3-PACS/PACS/art_painting'\n",
        "DIR_CARTOON = 'Homework3-PACS/PACS/cartoon'\n",
        "DIR_SKETCH = 'Homework3-PACS/PACS/sketch'\n",
        "\n",
        "# means and standard deviations ImageNet because the network is pretrained\n",
        "means, stds = (0.485, 0.456, 0.406), (0.229, 0.224, 0.225)\n",
        "\n",
        "transf = transforms.Compose([transforms.CenterCrop(224),  # Crops a central square patch of the image 224 because torchvision's AlexNet needs a 224x224 input!\n",
        "                              transforms.ToTensor(), # Turn PIL Image to torch.Tensor\n",
        "                              transforms.Normalize(means,stds) # Normalizes tensor with mean and standard deviation\n",
        "])\n",
        "\n",
        "# Prepare Pytorch train/test Datasets\n",
        "photo_dataset = torchvision.datasets.ImageFolder(DIR_PHOTO, transform=transf)\n",
        "art_dataset = torchvision.datasets.ImageFolder(DIR_ART, transform=transf)\n",
        "cartoon_dataset = torchvision.datasets.ImageFolder(DIR_CARTOON, transform=transf)\n",
        "sketch_dataset = torchvision.datasets.ImageFolder(DIR_SKETCH, transform=transf)\n",
        "\n",
        "# Check dataset sizes\n",
        "print(f\"Photo Dataset: {len(photo_dataset)}\")\n",
        "print(f\"Art Dataset: {len(art_dataset)}\")\n",
        "print(f\"Cartoon Dataset: {len(cartoon_dataset)}\")\n",
        "print(f\"Sketch Dataset: {len(sketch_dataset)}\")"
      ],
      "execution_count": 58,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Photo Dataset: 1670\n",
            "Art Dataset: 2048\n",
            "Cartoon Dataset: 2344\n",
            "Sketch Dataset: 3929\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "qI8IqG8Jj1_7"
      },
      "source": [
        "BATCH_SIZE = 128 \n",
        "\n",
        "# Dataloaders iterate over pytorch datasets \n",
        "photo_dataloader = DataLoader(photo_dataset, batch_size=BATCH_SIZE, shuffle=True, num_workers=2)\n",
        "art_dataloader = DataLoader(art_dataset, batch_size=BATCH_SIZE, shuffle=True, num_workers=2, drop_last=False)\n",
        "cartoon_dataloader = DataLoader(cartoon_dataset, batch_size=BATCH_SIZE, shuffle=True, num_workers=2, drop_last=False)\n",
        "sketch_dataloader = DataLoader(sketch_dataset, batch_size=BATCH_SIZE, shuffle=True, num_workers=2, drop_last=False)"
      ],
      "execution_count": 59,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "UMnOtenhhmP1"
      },
      "source": [
        "from sklearn.model_selection import train_test_split\n",
        "\n",
        "def train_val_dataset(dataset, val_split=0.1):\n",
        "    train_idx, val_idx = train_test_split(list(range(len(dataset))), test_size=val_split)\n",
        "    datasets = {}\n",
        "    train_source_data = Subset(dataset, train_idx)\n",
        "    val_source_data = Subset(dataset, val_idx)\n",
        "    return train_source_data, val_source_data\n",
        "\n",
        "l = []\n",
        "l.append(photo_dataset)\n",
        "l.append(art_dataset)\n",
        "l.append(cartoon_dataset)\n",
        "image_datasets = torch.utils.data.ConcatDataset(l)\n",
        "\n",
        "train_source_data, val_source_data = train_val_dataset(image_datasets, val_split = 0.1)\n",
        "\n",
        "#prepare train and val dataloader\n",
        "train_dataloader = DataLoader(train_source_data, batch_size=BATCH_SIZE, shuffle=True, num_workers=2)\n",
        "val_dataloader = DataLoader(val_source_data, batch_size=BATCH_SIZE, shuffle=True, num_workers=2)\n",
        "test_loader = sketch_dataloader"
      ],
      "execution_count": 60,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "iLBX-gVSsp2N"
      },
      "source": [
        "def LossCE():\n",
        "  return nn.CrossEntropyLoss()\n",
        "def LossWeighted(lossce, sigma):\n",
        "  sig_max = np.max(sigma)\n",
        "  if sig_max>= 0.95:\n",
        "    return sig_max * lossce\n",
        "  else:\n",
        "    return 0\n",
        "def Hloss():\n",
        "  return nn.CrossEntropyLoss()\n",
        "\n",
        "dataloaders = {'train': train_dataloader, 'val': val_dataloader}"
      ],
      "execution_count": 61,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "djW9v4bUMXSl"
      },
      "source": [
        "device = torch.device(\"cuda:0\" if torch.cuda.is_available() else \"cpu\")\n",
        "\n",
        "loss1_list = []\n",
        "loss2_list = []\n",
        "loss3_list = []\n",
        "\n",
        "def train_model(model, dataloaders, criterion, optimizer, num_epochs=25, is_inception=False):\n",
        "    since = time.time()\n",
        "\n",
        "    val_acc_history = []\n",
        "\n",
        "    best_model_wts = copy.deepcopy(model.state_dict())\n",
        "    best_acc = 0.0\n",
        "\n",
        "    for epoch in range(num_epochs):\n",
        "        print('Epoch {}/{}'.format(epoch, num_epochs - 1))\n",
        "        print('-' * 10)\n",
        "\n",
        "        # Each epoch has a training and validation phase\n",
        "        for phase in ['train', 'val']:\n",
        "            if phase == 'train':\n",
        "                model.train()  # Set model to training mode\n",
        "            else:\n",
        "                model.eval()   # Set model to evaluate mode\n",
        "\n",
        "            running_loss = 0.0\n",
        "            running_corrects = 0\n",
        "\n",
        "            # Iterate over data.\n",
        "            for inputs, labels in dataloaders[phase]:\n",
        "                inputs = inputs.to(device)\n",
        "                labels = labels.to(device)\n",
        "\n",
        "                # zero the parameter gradients\n",
        "                optimizer.zero_grad()\n",
        "\n",
        "                # forward\n",
        "                # track history if only in train\n",
        "                with torch.set_grad_enabled(phase == 'train'):\n",
        "                    \n",
        "                    if is_inception and phase == 'train':\n",
        "                        \n",
        "                        outputs = model(inputs)\n",
        "                        sigma = F.softmax(outputs, dim=1)\n",
        "                        sig_max = torch.max(sigma)\n",
        "                        if sig_max >= 0.95:\n",
        "                          loss2 = sig_max*criterion(outputs, labels)\n",
        "                        else:\n",
        "                          loss2 = 0\n",
        "                        loss2_list.append(loss2)\n",
        "                        loss1 = criterion(outputs, labels)\n",
        "                        loss1_list.append(loss1)\n",
        "                        loss3 = criterion(outputs, labels)\n",
        "                        loss3_list.append(loss3)\n",
        "                        loss = lamda_param[0]*loss1+lamda_param[1]*loss2+lamda_param[2]*loss3\n",
        "                    else:\n",
        "                        outputs = model(inputs)\n",
        "                        loss = criterion(outputs, labels)\n",
        "\n",
        "                    _, preds = torch.max(outputs, 1)\n",
        "\n",
        "                    # backward + optimize only if in training phase\n",
        "                    if phase == 'train':\n",
        "                        loss.backward()\n",
        "                        optimizer.step()\n",
        "\n",
        "                # statistics\n",
        "                running_loss += loss.item() * inputs.size(0)\n",
        "                running_corrects += torch.sum(preds == labels.data)\n",
        "\n",
        "            epoch_loss = running_loss / len(dataloaders[phase].dataset)\n",
        "            epoch_acc = running_corrects.double() / len(dataloaders[phase].dataset)\n",
        "\n",
        "            print('{} Loss: {:.4f} Acc: {:.4f}'.format(phase, epoch_loss, epoch_acc))\n",
        "\n",
        "            # deep copy the model\n",
        "            if phase == 'val' and epoch_acc > best_acc:\n",
        "                best_acc = epoch_acc\n",
        "                best_model_wts = copy.deepcopy(model.state_dict())\n",
        "            if phase == 'val':\n",
        "                val_acc_history.append(epoch_acc)\n",
        "\n",
        "        print()\n",
        "\n",
        "    time_elapsed = time.time() - since\n",
        "    print('Training complete in {:.0f}m {:.0f}s'.format(time_elapsed // 60, time_elapsed % 60))\n",
        "    print('Best val Acc: {:4f}'.format(best_acc))\n",
        "\n",
        "    # load best model weights\n",
        "    model.load_state_dict(best_model_wts)\n",
        "    return model, val_acc_history"
      ],
      "execution_count": 64,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "OH1jgs3Hor8t",
        "outputId": "166ff904-efca-486d-dbd6-ba17cb8b3abd"
      },
      "source": [
        "model_ft, hist = train_model(model_ft, dataloaders, criterion = nn.CrossEntropyLoss(), optimizer = optimizer_ft, num_epochs=2, is_inception=True)"
      ],
      "execution_count": 65,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Epoch 0/1\n",
            "----------\n",
            "train Loss: 1.2502 Acc: 0.4077\n",
            "val Loss: 1.1883 Acc: 0.6590\n",
            "\n",
            "Epoch 1/1\n",
            "----------\n",
            "train Loss: 0.8098 Acc: 0.7503\n",
            "val Loss: 0.8356 Acc: 0.8056\n",
            "\n",
            "Training complete in 17m 25s\n",
            "Best val Acc: 0.805601\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 296
        },
        "id": "Fxkm159tpzE7",
        "outputId": "1a49cc88-a8a0-4cb7-c975-f82d16667fb9"
      },
      "source": [
        "# to make a graph tracking the status of individual loss components as the training progresses\n",
        "def plotLosses( loss_2, loss_3, n_epochs=10, save_pic=True) : \n",
        "     epochs = range(n_epochs)\n",
        "     plt.figure()\n",
        "     plt.xlabel('Iterations')\n",
        "     plt.ylabel('Loss')\n",
        "     plt.plot(epochs, loss_2, 'g--', label=\"LossWeighted\")\n",
        "     plt.plot(epochs, loss_3, 'r--', label=\"HLoss\")\n",
        "     plt.legend()\n",
        "     plt.show()\n",
        "     if save_pic: \n",
        "          plt.savefig('losses.png')\n",
        "     return\n",
        "\n",
        "plotLosses( loss2_list, loss3_list, n_epochs=len(loss1_list), save_pic = True) "
      ],
      "execution_count": 70,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ]
          },
          "metadata": {
            "tags": [],
            "needs_background": "light"
          }
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 432x288 with 0 Axes>"
            ]
          },
          "metadata": {
            "tags": []
          }
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "JeYVDJEisEe8",
        "outputId": "bd42a272-91fb-4f80-b583-1edd5cc9ca83"
      },
      "source": [
        "# finding the test accuracy\n",
        "running_corrects = 0\n",
        "model_ft.eval()\n",
        "acc_pro = []\n",
        "for inputs, labels in test_loader:\n",
        "  inputs = inputs.to(device)\n",
        "  labels = labels.to(device)\n",
        "\n",
        "  outputs = model_ft(inputs)\n",
        "  _, preds = torch.max(outputs, 1)\n",
        "  running_corrects += torch.sum(preds == labels.data)\n",
        "  epoch_acc = running_corrects.double() / len(test_loader.dataset)\n",
        "\n",
        "  acc_pro.append(epoch_acc)\n",
        "\n",
        "print('Test Accuracy: {:.4f}'.format(acc_pro[-1]))"
      ],
      "execution_count": 78,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Test Accuracy: 0.2879\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "zYnOD9XIytoK"
      },
      "source": [
        ""
      ],
      "execution_count": null,
      "outputs": []
    }
  ]
}