CrossPriv_Remote_Execution.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "CrossPriv_Remote_Execution.ipynb",
      "provenance": [],
      "collapsed_sections": [],
      "include_colab_link": true
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "accelerator": "GPU"
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/harshitadd/CrossPriv/blob/master/CrossPriv_Remote_Execution.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Aoq3s2Yzd15t",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "!pip install syft==0.2.6 --quiet \n",
        "!pip install pydicom --quiet"
      ],
      "execution_count": 1,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "A6bD7JbBq0D6",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 92
        },
        "outputId": "098eda02-e7eb-4751-a9f5-41300757a351"
      },
      "source": [
        "##Importing Mini Batch Data \n",
        "import os \n",
        "import pydicom \n",
        "import cv2\n",
        "import matplotlib.pyplot as plt\n",
        "import csv  \n",
        "import pandas as pd\n",
        "import torch\n",
        "import torch.nn as nn\n",
        "import torch.nn.functional as F\n",
        "import torch.optim as optim\n",
        "import syft as sy\n",
        "import time\n",
        "import copy\n",
        "import numpy as np\n",
        "import pickle\n",
        "import seaborn as sns\n",
        "from sklearn.preprocessing import MinMaxScaler \n",
        "from google.colab import drive\n",
        "from torch.utils.data import TensorDataset, DataLoader\n",
        "from torch.utils.data import Dataset\n",
        "from sklearn.model_selection import train_test_split\n",
        "from syft.frameworks.torch.fl import utils\n",
        "from syft.workers.websocket_client import WebsocketClientWorker\n",
        "\n",
        "drive.mount('/content/drive')\n",
        "sns.set(style=\"darkgrid\")"
      ],
      "execution_count": 2,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Drive already mounted at /content/drive; to attempt to forcibly remount, call drive.mount(\"/content/drive\", force_remount=True).\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "/usr/local/lib/python3.6/dist-packages/statsmodels/tools/_testing.py:19: FutureWarning: pandas.util.testing is deprecated. Use the functions in the public API at pandas.testing instead.\n",
            "  import pandas.util.testing as tm\n"
          ],
          "name": "stderr"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Nwuyc_DerKUv",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        " def makeData(): \n",
        "  dcm_path=os.listdir('/content/drive/My Drive/Fed_Covid/minibatch/')\n",
        "  dcm_data={}\n",
        "\n",
        "  alpha = 1.5 # Contrast control (1.0-3.0)\n",
        "  beta = 0 # Brightness control (0-100)\n",
        "\n",
        "  ctr=0\n",
        "  for file in dcm_path:\n",
        "    name = '/content/drive/My Drive/Fed_Covid/minibatch/' + file\n",
        "    temp = pydicom.dcmread(name)\n",
        "    image = temp.pixel_array\n",
        "    image = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)\n",
        "    adjusted = cv2.resize(image,(64,64))\n",
        "    dcm_data[file]=adjusted\n",
        "    ctr+=1\n",
        "\n",
        "  labels=[]\n",
        "  with open('/content/drive/My Drive/Fed_Covid/stage_2_train_labels.csv','r') as file:\n",
        "    reader = csv.reader(file)\n",
        "    for row in reader:\n",
        "      labels.append(row)\n",
        "  scaler = MinMaxScaler()\n",
        "  pid=[]\n",
        "  dicom=[]\n",
        "  label=[]\n",
        "  cid = 0\n",
        "  for PID in labels:\n",
        "    for key in dcm_data:\n",
        "      if(key[:-4]==PID[0]):\n",
        "        l=[]\n",
        "        for val in dcm_data[key]:\n",
        "          l.append(scaler.fit_transform(val))\n",
        "        l = np.reshape(l,(3,64,64))\n",
        "        dicom.append(l)\n",
        "        label.append(int(PID[5]))\n",
        "  return dicom, label  \n",
        "\n",
        "      "
      ],
      "execution_count": 3,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Ryg9PjOymSkj",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "dicom, label = makeData()"
      ],
      "execution_count": 4,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "yOeS4TuIgogO",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "class Arguments():\n",
        "    def __init__(self):\n",
        "        self.batch_size = 4\n",
        "        self.test_batch_size = 4\n",
        "        self.epochs = 5\n",
        "        self.lr = 0.01\n",
        "        self.momentum = 0.5\n",
        "        self.log_interval = 10\n",
        "\n",
        "args = Arguments()"
      ],
      "execution_count": 5,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "td7w-9SHFgaK",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "x_train, x_test, y_train, y_test = train_test_split(dicom,label,test_size=0.3)"
      ],
      "execution_count": 6,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "jNDNknm_9hW1",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "test_df = pd.DataFrame()\n",
        "test_df['features']=x_test\n",
        "test_df['labels']=y_test"
      ],
      "execution_count": 7,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "r5E6HzYS5ycR",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "x_train= np.array(x_train)\n",
        "y_train= np.array(y_train)\n",
        "x_test= np.array(x_test)\n",
        "y_test= np.array(y_test)"
      ],
      "execution_count": 8,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "x8KCNM1rpsJb",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "class data_maker(Dataset):\n",
        "  def __init__(self, images, labels):\n",
        "        self.data = images \n",
        "        self.targets = labels \n",
        "\n",
        "        self.to_torchtensor()\n",
        "        \n",
        "  def __len__(self):\n",
        "      return len(self.data)\n",
        "\n",
        "  def to_torchtensor(self):      \n",
        "      self.data=torch.from_numpy(self.data)\n",
        "      self.labels=torch.from_numpy(self.targets)\n",
        "  \n",
        "  def __getitem__(self, idx):\n",
        "      sample=self.data[idx]\n",
        "      target=self.targets[idx]\n",
        "      return sample,target"
      ],
      "execution_count": 78,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "_HjuI6IJnOo_",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        },
        "outputId": "be9572e5-9de3-4fee-812c-e0976cb871d6"
      },
      "source": [
        "hook = sy.TorchHook(torch)\n",
        "hospital = sy.VirtualWorker(hook, id=\"hospital\")  \n",
        "clinic = sy.VirtualWorker(hook, id=\"clinic\")  "
      ],
      "execution_count": 79,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "WARNING:root:Torch was already hooked... skipping hooking process\n"
          ],
          "name": "stderr"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "TGOtNPrLcCXO",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "federated_train_data = data_maker(x_train,y_train).federate((hospital,clinic))"
      ],
      "execution_count": 80,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "iVmlJAfUcCUX",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "federated_train_loader = sy.FederatedDataLoader(federated_train_data,batch_size=args.batch_size)\n",
        "test_data = data_maker(x_test,y_test)\n",
        "test_loader = torch.utils.data.DataLoader(test_data, batch_size=args.test_batch_size)"
      ],
      "execution_count": 81,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "KpiILdmui8ar",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "class Net(nn.Module):\n",
        "    def __init__(self):\n",
        "        super().__init__()\n",
        "        self.conv1 = nn.Conv2d(3,32, kernel_size=8, stride = 2)  \n",
        "        self.pool1 = nn.MaxPool2d(kernel_size=4,stride=2,padding=0)  \n",
        "        self.conv2 = nn.Conv2d(32, 64, 8)\n",
        "        self.pool2 = nn.MaxPool2d(4,2,padding=0)\n",
        "        self.fc1 = nn.Linear(256, 64*64)\n",
        "        self.fc2 = nn.Linear(64*64, 64)\n",
        "        self.fc3 = nn.Linear(64, 2)\n",
        "\n",
        "    def forward(self, x):\n",
        "        \n",
        "        x = F.relu(self.conv1(x))\n",
        "        x = self.pool1(x)\n",
        "        x = F.relu(self.conv2(x))\n",
        "        x = self.pool2(x)\n",
        "        x = x.view(-1,256)\n",
        "        x = F.relu(self.fc1(x))\n",
        "        x = F.relu(self.fc2(x))\n",
        "        x = self.fc3(x)\n",
        "\n",
        "        return F.log_softmax(x,dim=1)"
      ],
      "execution_count": 82,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Re4prk9MpiCz",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "local_losses=[]"
      ],
      "execution_count": 83,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "UtGcY3T-nl0q",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "def train(args, model,train_loader, optimizer, epoch):\n",
        "    model.train()\n",
        "    loss = nn.CrossEntropyLoss()\n",
        "    for batch_idx, (data, target) in enumerate(federated_train_loader):\n",
        "        model.send(data.location) \n",
        "        optimizer.zero_grad()\n",
        "        output = model(data)\n",
        "        out = loss(output, target)\n",
        "        out.backward()\n",
        "        optimizer.step()\n",
        "        model.get() \n",
        "        if batch_idx % args.log_interval == 0:\n",
        "            final_loss = out.get() \n",
        "            print('For Training Epoch: ' + str(epoch) + ' Loss is :' + str(final_loss) + 'at ' + str(data.location))\n",
        "            local_losses.append(final_loss)\n",
        "            "
      ],
      "execution_count": 86,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "K8c137J-cCLk",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "model = Net().double()\n",
        "optimizer = optim.SGD(model.parameters(), lr=args.lr) \n",
        "for epoch in range(1, 50):\n",
        "  train(args, model, federated_train_loader, optimizer, epoch)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "H7h3-XKjfKWl",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "local_loss_hospital=[]\n",
        "local_loss_clinic=[]"
      ],
      "execution_count": 114,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "x9kPDniWrX5n",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "for i in range(0,len(local_losses)-8,8):\n",
        "      local_loss_hospital.append(local_losses[i+3].detach().numpy()) #optimal loss of each local epoch iteration\n",
        "for i in range(4,len(local_losses)-8,8):\n",
        "  local_loss_clinic.append(local_losses[i+3].detach().numpy()) ##optimal loss of each local epoch iteration\n",
        "\n"
      ],
      "execution_count": 115,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "zWjcbsSRdt9O",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 285
        },
        "outputId": "5c09e59c-ad25-4645-f534-ddb420af23bf"
      },
      "source": [
        "plt.xlabel('Number of Federated Iterations')\n",
        "plt.ylabel('Loss on Client Models')\n",
        "plt.plot(local_loss_hospital, label = 'Hospital', linestyle = 'dashed')\n",
        "plt.plot(local_loss_clinic, label = 'Clinic', linestyle = 'dashed')\n",
        "plt.legend()\n",
        "plt.savefig('CrossPriv_Remote_Exec.pdf')\n",
        "\n",
        "plt.show()\n"
      ],
      "execution_count": 120,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ]
          },
          "metadata": {
            "tags": []
          }
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "wYrBbko9pDc7",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        ""
      ],
      "execution_count": null,
      "outputs": []
    }
  ]
}