W_A.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "accelerator": "GPU",
    "colab": {
      "name": "W-A.ipynb",
      "provenance": [],
      "machine_shape": "hm",
      "mount_file_id": "13gcUvNE5Uv8qTXkeacHj2veVP2tsJ8LG",
      "authorship_tag": "ABX9TyP/pdzHhAsrhCC8vAP4NnC3",
      "include_colab_link": true
    },
    "kernelspec": {
      "display_name": "Python 3",
      "name": "python3"
    },
    "language_info": {
      "name": "python"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/pragyasrivastava0805/congenial-journey/blob/main/W_A.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "iMweKYfY-OJG"
      },
      "source": [
        "import torch\n",
        "from torch.utils.data import Dataset, DataLoader\n",
        "from torchvision import transforms, datasets\n",
        "import numpy as np\n",
        "import os\n",
        "from torch.utils.data.sampler import SubsetRandomSampler\n",
        "from PIL import Image\n",
        "\n",
        "\n",
        "\n",
        "class OfficeAmazonDataset(Dataset):\n",
        "\n",
        "\n",
        "    def __init__(self, image_folder_dataset, transform=None):\n",
        "        super(OfficeAmazonDataset, self).__init__()\n",
        "        self.image_folder_dataset = image_folder_dataset\n",
        "        self.transform = transform\n",
        "\n",
        "    def __len__(self):\n",
        "        return len(self.image_folder_dataset.imgs)\n",
        "\n",
        "    def __getitem__(self, idx):\n",
        "        # read image, class from folder_dataset given index\n",
        "        img, img_label = image_folder_dataset[idx][0], image_folder_dataset[idx][1]\n",
        "\n",
        "        # apply transformations (it already returns them as torch tensors)\n",
        "        if self.transform is not None:\n",
        "            self.transform(img)\n",
        "\n",
        "        img_label_pair = {\"image\": img,\n",
        "                         \"class\": img_label}\n",
        "\n",
        "        return img_label_pair\n",
        "\n",
        "\n",
        "def get_dataloader(dataset, batch_size, train_ratio=0.7):\n",
        "\n",
        "\n",
        "    def get_subset(indices, start, end):\n",
        "        return indices[start:start+end]\n",
        "\n",
        "    # Split train/val data ratios\n",
        "    TRAIN_RATIO, VALIDATION_RATIO = train_ratio, 1-train_ratio\n",
        "    train_set_size = int(len(dataset) * TRAIN_RATIO)\n",
        "    validation_set_size = int(len(dataset) * VALIDATION_RATIO)\n",
        "\n",
        "    # Generate random indices for train and val sets\n",
        "    indices = torch.randperm(len(dataset))\n",
        "    train_indices = get_subset(indices, 0, train_set_size)\n",
        "    validation_indices = get_subset(indices,train_set_size,validation_set_size)\n",
        "    # test_indices = get_subset(indices,train_count+validation_count,len(dataset))\n",
        "\n",
        "    # Create sampler objects\n",
        "    train_sampler = SubsetRandomSampler(train_indices)\n",
        "    val_sampler = SubsetRandomSampler(validation_indices)\n",
        "\n",
        "    # Create data loaders\n",
        "    train_loader = DataLoader(dataset, batch_size=batch_size,\n",
        "                              sampler=train_sampler, num_workers=0)\n",
        "\n",
        "    val_loader = DataLoader(dataset, batch_size=batch_size,\n",
        "                            sampler=val_sampler, num_workers=0)\n",
        "\n",
        "    return train_loader, val_loader\n",
        "\n",
        "\n",
        "def get_office_data(name_dataset):\n",
        "\n",
        "\n",
        "    \n",
        "    root_dir = \"/content/drive/My Drive/Original_images/Original_images\" .format(name_dataset)\n",
        "\n",
        "    __datasets__ = [\"amazon\", \"dslr\", \"webcam\"]\n",
        "\n",
        "    if name_dataset not in __datasets__:\n",
        "        raise ValueError(\"must introduce one of the three datasets in office\")\n",
        "\n",
        "    mean_std = {\n",
        "        \"amazon\":{\n",
        "            \"mean\":[0.7923, 0.7862, 0.7841],\n",
        "            \"std\":[0.3149, 0.3174, 0.3193]\n",
        "        },\n",
        "        \"dslr\":{\n",
        "            \"mean\":[0.4708, 0.4486, 0.4063],\n",
        "            \"std\":[0.2039, 0.1920, 0.1996]\n",
        "        },\n",
        "        \"webcam\":{\n",
        "            \"mean\":[0.6119, 0.6187, 0.6173],\n",
        "            \"std\":[0.2506, 0.2555, 0.2577]\n",
        "        }\n",
        "    }\n",
        "\n",
        "    # compose image transformations\n",
        "    data_transforms = transforms.Compose([\n",
        "            transforms.Resize((227, 227)),\n",
        "            transforms.CenterCrop(227),\n",
        "            # transforms.RandomSizedCrop(224),\n",
        "            # transforms.RandomHorizontalFlip(),\n",
        "            transforms.ToTensor(),\n",
        "            transforms.Normalize(mean=mean_std[name_dataset][\"mean\"],\n",
        "                                 std=mean_std[name_dataset][\"std\"])\n",
        "        ])\n",
        "\n",
        "    # retrieve dataset using ImageFolder\n",
        "    # datasets.ImageFolder() command expects our data to be organized\n",
        "    # in the following way: root/label/picture.png\n",
        "    dataset = datasets.ImageFolder(root=root_dir,\n",
        "                                   transform=data_transforms)\n",
        "    # Dataloader is able to spit out random samples of our data,\n",
        "    # so our model won’t have to deal with the entire dataset every time.\n",
        "    # shuffle data when training\n",
        "  \n",
        "    return dataset"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "YW08SihA-pJu"
      },
      "source": [
        "source_train_loader,source_val_loader=get_dataloader(get_office_data(\"webcam\"),batch_size=64,train_ratio=0.70)\n",
        "target_train_loader,target_val_loader=get_dataloader(get_office_data(\"amazon\"),batch_size=64,train_ratio=0.70)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "iWrfOy0X-0GK"
      },
      "source": [
        "from torch.autograd import Function\n",
        "import torch.nn as nn\n",
        "import torchvision.models as models\n",
        "class ReverseLayerF(Function):\n",
        "\n",
        "    @staticmethod\n",
        "    def forward(ctx, x, alpha):\n",
        "        ctx.alpha = alpha\n",
        "\n",
        "        return x.view_as(x)\n",
        "\n",
        "    @staticmethod\n",
        "    def backward(ctx, grad_output):\n",
        "        output = grad_output.neg() * ctx.alpha\n",
        "\n",
        "        return output, None\n",
        "\n",
        "class ResNet50(nn.Module):\n",
        "    def __init__(self):\n",
        "        super(ResNet50, self).__init__()\n",
        "        \n",
        "        resnetModel = models.resnet50(pretrained=True)\n",
        "        feature_map = list(resnetModel.children())\n",
        "        feature_map.pop()\n",
        "        for layers in feature_map:\n",
        "          layers.trainable=False\n",
        "        self.feature_extractor = nn.Sequential(*feature_map)\n",
        "\n",
        "        self.classifier = nn.Sequential(\n",
        "            nn.Linear(2048, 31),\n",
        "        )\n",
        "\n",
        "        self.discriminator = nn.Sequential(\n",
        "            nn.Linear(2048, 1024),\n",
        "            nn.ReLU(inplace=True),\n",
        "            nn.Dropout(),\n",
        "            nn.Linear(1024, 1024),\n",
        "            nn.ReLU(inplace=True),\n",
        "            nn.Dropout(),\n",
        "            nn.Linear(1024, 32),\n",
        "        )\n",
        "\n",
        "    def forward(self, input_data, alpha):\n",
        "        input_data = input_data.expand(input_data.data.shape[0], 3, 227, 227)\n",
        "        feature = self.feature_extractor(input_data)\n",
        "        feature = feature.view(-1, 2048)\n",
        "\n",
        "        reverse_bottleneck = ReverseLayerF.apply(feature, alpha)\n",
        "\n",
        "        class_output = self.classifier(feature)\n",
        "        domain_output = self.discriminator(reverse_bottleneck)\n",
        "\n",
        "        return class_output, domain_output"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "BwClaI7e-4gP"
      },
      "source": [
        "def test(dataloader):\n",
        "    len_dataloader = len(dataloader)\n",
        "    data_target_iter = iter(dataloader)\n",
        "\n",
        "    i = 0\n",
        "    n_total = 0\n",
        "    n_correct = 0\n",
        "    while i < len_dataloader:\n",
        "\n",
        "        # test model using target data\n",
        "        data_target = data_target_iter.next()\n",
        "        t_img, t_label = data_target\n",
        "\n",
        "        batch_size = len(t_label)\n",
        "\n",
        "        input_img = torch.FloatTensor(batch_size, 3, image_size, image_size)\n",
        "        class_label = torch.LongTensor(batch_size)\n",
        "\n",
        "\n",
        "        input_img.resize_as_(t_img).copy_(t_img)\n",
        "        class_label.resize_as_(t_label).copy_(t_label)\n",
        "\n",
        "        class_output, _ = my_net(input_data=input_img, alpha=alpha)\n",
        "        pred = class_output.data.max(1, keepdim=True)[1]\n",
        "        n_correct += pred.eq(class_label.data.view_as(pred)).cpu().sum()\n",
        "        n_total += batch_size\n",
        "\n",
        "        i += 1\n",
        "    accu = n_correct.data.numpy() * 1.0 / n_total\n",
        "    return accu"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "zgkSFEyF-8Fe",
        "outputId": "2136c730-2fd0-4bdc-e394-6cab24cee988"
      },
      "source": [
        "lr = 1e-3\n",
        "n_epoch=10\n",
        "my_net = ResNet50()\n",
        "import torch.optim as optim\n",
        "optimizer = optim.Adam(my_net.parameters(), lr=lr)\n",
        "image_size=227\n",
        "acc1=[]\n",
        "acc2=[]\n",
        "\n",
        "loss_class = torch.nn.CrossEntropyLoss()\n",
        "loss_domain = torch.nn.CrossEntropyLoss()\n",
        "\n",
        "for p in my_net.parameters():\n",
        "    p.requires_grad = True\n",
        "for epoch in range(n_epoch):\n",
        "\n",
        "    len_dataloader = min(len(source_train_loader), len(target_train_loader))\n",
        "    data_source_iter = iter(source_train_loader)\n",
        "    data_target_iter = iter(target_train_loader)\n",
        "\n",
        "    i = 0\n",
        "    while i < len_dataloader:\n",
        "\n",
        "        \n",
        "        alpha = 1\n",
        "\n",
        "        # training model using source data\n",
        "        data_source = data_source_iter.next()\n",
        "        s_img, s_label = data_source\n",
        "      \n",
        "        my_net.zero_grad()\n",
        "        batch_size = len(s_label)\n",
        "\n",
        "        input_img = torch.FloatTensor(batch_size, 3, image_size, image_size)\n",
        "        class_label = torch.LongTensor(batch_size)\n",
        "    \n",
        "\n",
        "     \n",
        "\n",
        "        input_img.resize_as_(s_img).copy_(s_img)\n",
        "        class_label.resize_as_(s_label).copy_(s_label)\n",
        "\n",
        "        class_output, domain_output = my_net(input_data=input_img, alpha=alpha)\n",
        "        err_s_label = loss_class(class_output, class_label)\n",
        "        err_s_domain = loss_domain(domain_output, class_label)\n",
        "\n",
        "        # training model using target data\n",
        "        data_target = data_target_iter.next()\n",
        "        t_img, _ = data_target\n",
        "\n",
        "        batch_size = len(t_img)\n",
        "\n",
        "        input_img = torch.FloatTensor(batch_size, 3, image_size, image_size)\n",
        "        domain_label = torch.full((batch_size,1),31)\n",
        "        domain_label.squeeze_()\n",
        "\n",
        "      \n",
        "\n",
        "        input_img.resize_as_(t_img).copy_(t_img)\n",
        "\n",
        "        _, domain_output = my_net(input_data=input_img, alpha=alpha)\n",
        "        err_t_domain = loss_domain(domain_output, domain_label)\n",
        "        err = (err_t_domain + err_s_domain)/(len(source_train_loader)+len(target_train_loader)) + err_s_label/(len(source_train_loader))\n",
        "        err.backward()\n",
        "        optimizer.step()\n",
        "\n",
        "        i += 1\n",
        "    print(epoch,n_epoch, err_s_label.cpu().data.numpy(),err_s_domain.cpu().data.numpy(), err_t_domain.cpu().data.numpy())\n",
        "    acc1.append(test(source_val_loader))\n",
        "    acc2.append(test(target_val_loader))"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "/usr/local/lib/python3.7/dist-packages/torch/nn/functional.py:718: UserWarning: Named tensors and all their associated APIs are an experimental feature and subject to change. Please do not use them for anything important until they are released as stable. (Triggered internally at  /pytorch/c10/core/TensorImpl.h:1156.)\n",
            "  return torch.max_pool2d(input, kernel_size, stride, padding, dilation, ceil_mode)\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "0 10 0.15329866 1.4608933 0.69790304\n",
            "1 10 0.031186383 0.8274506 0.8033124\n",
            "2 10 0.21283704 0.84395826 0.83940935\n",
            "3 10 0.20063646 1.0757071 0.8427781\n",
            "4 10 0.21756591 0.9514509 0.72533923\n",
            "5 10 0.16628912 0.75885653 0.908274\n",
            "6 10 0.028771916 0.84763587 0.7694199\n",
            "7 10 0.08634741 1.04891 0.6137556\n",
            "8 10 0.10797983 0.8762209 0.7055952\n",
            "9 10 0.071604505 0.80561876 0.6997424\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "LZ2PPp5d_BL9",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 312
        },
        "outputId": "e96a5455-cfbc-4b40-dd90-b51915a2d24d"
      },
      "source": [
        "\n",
        "\n",
        "\n",
        "import matplotlib.pyplot as plt\n",
        "epsilon=np.arange(0,10,1)\n",
        "plt.plot(epsilon,acc1,color='r',label='Source Test Accuracy')\n",
        "plt.plot(epsilon,acc2,color='g',label='Target Test Accuracy')\n",
        "\n",
        "plt.xlabel(\"Epsilon\")\n",
        "\n",
        "\n",
        "\n",
        "plt.ylabel(\"Accuracies\")\n",
        "plt.title(\"Test Accuracies\")\n",
        "plt.legend()\n",
        "  \n",
        "\n",
        "plt.show()\n",
        "print(acc1[len(acc1)-1],acc2[len(acc2)-1])     "
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ]
          },
          "metadata": {
            "needs_background": "light"
          }
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "0.9724249797242498 0.9708029197080292\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "k38GQVtGxCfe"
      },
      "source": [
        ""
      ],
      "execution_count": null,
      "outputs": []
    }
  ]
}