Part_3_Achieving_Privacy_with_Private_Aggregation_of_Teacher_Ensembles.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "2c7f50C2yAjp"
   },
   "source": [
    "# [Part 3] - Achieving Privacy with Private Aggregation of Teacher Ensembles (PATE)\n",
    "\n",
    "# Introduction\n",
    "\n",
    "This notebook belongs to a 4-parts project. This part is dedicated to implement a training strategy that ensures privacy, called PATE, which was introduced by Papernot et al (2017) on their paper [Semi-supervised knowledge transfer for Deep Learning from private training data](https://arxiv.org/abs/1610.05755). "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "PqIqUi-k3PSP"
   },
   "source": [
    "Additionally, we use an utility function from [PySyft](https://github.com/OpenMined/PySyft), a library for encrypted, privacy preserving deep learning, that allow us to analyze our PATE implementation and know how private our learning strategy is. For this reason we start by installing PySyft, which also will be useful for the 4th part of this project."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "JUsY4znI4eiM"
   },
   "outputs": [],
   "source": [
    "%%capture\n",
    "!pip install syft"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 106
    },
    "colab_type": "code",
    "id": "kB-TXvI0pVbN",
    "outputId": "7478ebf1-c376-40a6-d61e-e9dd46e02ad9"
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "WARNING: Logging before flag parsing goes to stderr.\n",
      "W0820 12:51:08.221711 4337219008 secure_random.py:26] Falling back to insecure randomness since the required custom op could not be found for the installed version of TensorFlow. Fix this by compiling custom ops. Missing file was '/anaconda3/envs/pysyft/lib/python3.7/site-packages/tf_encrypted/operations/secure_random/secure_random_module_tf_1.14.0.so'\n",
      "W0820 12:51:08.231410 4337219008 deprecation_wrapper.py:119] From /anaconda3/envs/pysyft/lib/python3.7/site-packages/tf_encrypted/session.py:26: The name tf.Session is deprecated. Please use tf.compat.v1.Session instead.\n",
      "\n"
     ]
    }
   ],
   "source": [
    "# Data Load\n",
    "import os\n",
    "import numpy as np\n",
    "\n",
    "# PyTorch (modeling)\n",
    "import torch\n",
    "from torch import nn\n",
    "import torch.nn.functional as F\n",
    "from torch import optim\n",
    "from torch.utils.data.sampler import SubsetRandomSampler\n",
    "from torchvision import transforms\n",
    "import torchvision.transforms.functional as TF\n",
    "from torch.utils.data import random_split\n",
    "from torch.utils.data import DataLoader\n",
    "\n",
    "# Visualization\n",
    "import matplotlib.pyplot as plt\n",
    "%matplotlib inline\n",
    "\n",
    "# Our helper (takes a while because we load all data there as well)\n",
    "import helper\n",
    "\n",
    "from syft.frameworks.torch.differential_privacy import pate"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "1Cn4P_APEuLe"
   },
   "outputs": [],
   "source": [
    "exp_i_data = helper.load_exp_i(\"dataset/experiment-i\")\n",
    "exp_ii_data_air, exp_ii_data_spo = helper.load_exp_ii(\"dataset/experiment-ii\")\n",
    "\n",
    "datasets = {\n",
    "    \"Base\":exp_i_data,\n",
    "    \"Spo\":exp_ii_data_air,\n",
    "    \"Air\":exp_ii_data_spo\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "X0Drb4AYh9eM"
   },
   "source": [
    "# PATE Overview \n",
    "\n",
    "Privacy methods in deep learning (and machine learning in general) arise as a necessity of ensuring the subjects, whose data is being used for modeling, that the models are not storing any sensitive data and that there is no way of retreiving it by neither using the model nor by examining its parameters.\n",
    "\n",
    "Sensitive data can be thought, for example, in a medical scenario, where models can be created for example to improve the diagnostics capabilities of hospitals, but at thhe same time patients do not want to leak any of their personal (or medical) information by contributing with their data to the creation of a machine learning model.\n",
    "\n",
    "The difficulty arises when the goals is to guarantee to *every person* that their private data is, in fact, private. Most training methods cannot accomplish this, because even though the models look forward to generalize to the test set, they can still overfit on outliers (specific training examples). \n",
    "\n",
    "PATE (stands for Private Aggregation of Teacher Ensembles) is a model-agnostic learning strategy, meaning that it can be implemented no matter what learning algorithm is being used for a specific task. It works by creating a teachers-student scenario, where the teachers represent already available models for a task and the student is the new model to develop for the same task. The student's training phase uses labels that are acquired from the aggregated votes that teachers generate for every data point, and privacy is ensured by adding some noise to the teacher votes.\n",
    "\n",
    "After training, the student model is the one deployed, instead of the teacher ensemble."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "IP4GcB2mD6HZ"
   },
   "source": [
    "# Our proposed scenario\n",
    "\n",
    "We simulate the following scenario with the data we have been working on to develop the idea of PATE: \n",
    "\n",
    "* We work on a hospital where we have three patitents who have used a pressure mattress. We would like to monitor their in-bed lying positions to, among others, prevent any skin lesion if they stay on the same position for a long time period. We have, however, no model to accomplish this but we know that there are ten hospitals who built a model using their own data. We ask them to borrow us their models, which we will use to train ours. Additionally, we want to ensure that the data contained in their models will not be leaked, even though that their models per-se might leak private data or contain sensitive information. Additionally, we want to ensure *our patients* that our model will not overfit and contain any of their private information (i.e., by looking at the model parameters or by using it, nobody would be able to generate an image of their exact pressure recordings).\n",
    "\n",
    "* We regard every subject collection of measurements (from S1 to S10) as data collected from *individual hospitals*, meaning that there are ten hospitals available to help. Their models are the **teacher models**.\n",
    "\n",
    "* We possess data of S11 to S13, and we want to create a model on our data, based on the teacher votes. Our model is the **student model**.\n",
    "\n",
    "* We assume for simplicity that the architecture of all models is the same. We use the proposed architecture in part 2, a convolutional neural network, which can be instanciated via `helper.py` by callling `CNN()`.\n",
    "\n",
    "## STEP 1: Gather the Teachers\n",
    "\n",
    "Let's begin by creating a function to train the teachers. While on a real application we should get already trained models from the hospitals, our simulated scenario require us to train the models. For this, we instantiate a CNN and set the learning strategy on `train_teacher()`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "DUrBVpHn0LY-"
   },
   "outputs": [],
   "source": [
    "def train_teacher(device, trainloader, epochs=15, seed=123):\n",
    "  model = helper.CNN()\n",
    "\n",
    "  criterion = nn.NLLLoss()\n",
    "\n",
    "  optimizer = optim.Adam(model.parameters(), lr = 0.001)\n",
    "\n",
    "  model.to(device)\n",
    "\n",
    "  torch.manual_seed(seed)\n",
    "\n",
    "  for epoch in range(epochs):\n",
    "    for inputs, labels in trainloader:\n",
    "\n",
    "      inputs, labels = inputs.to(device), labels.to(device)\n",
    "\n",
    "      optimizer.zero_grad()\n",
    "\n",
    "      logps = model.forward(inputs)\n",
    "      loss = criterion(logps, labels)\n",
    "      loss.backward()\n",
    "      optimizer.step()\n",
    "\n",
    "  return model"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "Qi8YH2pqCTZf"
   },
   "source": [
    "## STEP 2: Gather the teacher votes\n",
    "\n",
    "The idea of PATE is that every teacher examines the data we want to train our model on (that is, data from S11, S12, and S13)  and generates a prediction for each image. This prediction is the teacher's _vote_ and we gather all of the votes together for every image.\n",
    "\n",
    "We achieve this on this chunk by doing the following:\n",
    "\n",
    "+ We loop for every hospital, getting the data of this hospital (`private_data`) and then training a model on it.\n",
    "  + This trained model (teacher) generates predictions on our data `my_data`.\n",
    "  + We also calculate the accuracy of every single teacher in our data. We do this for the purpose of the PATE analysis, because on a real setting we would not have any labels for our data.\n",
    "+ We gather all teacher votes into a matrix, the dimensions of it should be `(number_of_images x number_of_teachers)`\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 364
    },
    "colab_type": "code",
    "id": "m6SY6Tt9YW1U",
    "outputId": "59065979-1937-4f2b-e251-fdab86850cf8"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Training teacher on S1 data\n",
      "- Accuracy on our data: 0.742\n",
      "Training teacher on S2 data\n",
      "- Accuracy on our data: 0.865\n",
      "Training teacher on S3 data\n",
      "- Accuracy on our data: 0.963\n",
      "Training teacher on S4 data\n",
      "- Accuracy on our data: 0.895\n",
      "Training teacher on S5 data\n",
      "- Accuracy on our data: 0.859\n",
      "Training teacher on S6 data\n",
      "- Accuracy on our data: 0.867\n",
      "Training teacher on S7 data\n",
      "- Accuracy on our data: 0.829\n",
      "Training teacher on S8 data\n",
      "- Accuracy on our data: 0.822\n",
      "Training teacher on S9 data\n",
      "- Accuracy on our data: 0.968\n",
      "Training teacher on S10 data\n",
      "- Accuracy on our data: 0.872\n"
     ]
    }
   ],
   "source": [
    "device = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")\n",
    "\n",
    "hospitals = [\"S1\", \"S2\", \"S3\", \"S4\", \"S5\", \"S6\", \"S7\", \"S8\", \"S9\", \"S10\"]\n",
    "\n",
    "hospitals_preds = {}\n",
    "\n",
    "my_hospital = [\"S11\", \"S12\", \"S13\"]\n",
    "\n",
    "my_data = helper.Mat_Dataset([\"Base\"], my_hospital)\n",
    "my_data_loader = DataLoader(my_data, batch_size=len(my_data), shuffle=False)\n",
    "\n",
    "for hospital in hospitals:\n",
    "  \n",
    "  print(f'Training teacher on {hospital} data')\n",
    "  \n",
    "  private_data = helper.Mat_Dataset([\"Base\"], [hospital])\n",
    "  private_data_loader = DataLoader(private_data, batch_size=64, shuffle=True)\n",
    "  private_model = train_teacher(device, private_data_loader)\n",
    "  \n",
    "  accuracy = 0\n",
    "  private_model.to(device)\n",
    "  private_model.eval()\n",
    "  with torch.no_grad():\n",
    "      \n",
    "    for inputs, labels in my_data_loader:\n",
    "\n",
    "      inputs, labels = inputs.to(device), labels.to(device)\n",
    "      logps = private_model.forward(inputs)\n",
    "      ps = torch.exp(logps)\n",
    "      top_p, top_class = ps.topk(1, dim=1)\n",
    "      equals = top_class == labels.view(*top_class.shape)\n",
    "      accuracy += torch.mean(equals.type(torch.FloatTensor))\n",
    "      print(f\"- Accuracy on our data: {accuracy/len(my_data_loader):.3f}\")\n",
    "      hospitals_preds[hospital] = top_class\n",
    "    \n",
    "  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 34
    },
    "colab_type": "code",
    "id": "JtPuIN2HGlR7",
    "outputId": "906ae815-209b-4785-da69-6e269de71cb9"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(4324, 10)"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "hospital_p = np.hstack([hospitals_preds.get(key).cpu() for key in hospitals_preds.keys()])\n",
    "hospital_p.shape"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "n_tJB6K2jS77"
   },
   "source": [
    "## STEP 3: Add noise\n",
    "\n",
    "To ensure privacy, we apply some noise to the votes before applying plurality (i.e., choosing the label with the largest count). Theoretical justifications can be found [in this paper](https://arxiv.org/pdf/1610.05755.pdf) and giving them here are out of the scope of this project.\n",
    "\n",
    "One of the intuitive reasons of applying noise is to avoid that, in the case of a tie between two votes, only one teacher (or dataset) is responsible for making several decisive votes, leading to overfitting.\n",
    "\n",
    "Of course, there is no free lunch: adding large quantities of noise results on a decrease in the overall accuracy of the model.\n",
    "\n",
    "We apply Laplacian noise on every vote. The following image (taken from [Wikipedia](https://en.wikipedia.org/wiki/Laplace_distribution)) shows the Laplacian distribution, which is defined by a location parameter (μ) and a scale parameter (b).\n",
    "\n",
    "![Laplace Distribution](img/laplace_distribution.png)\n",
    "\n",
    "In this work, we set `b = 1 / epsilon`, where epsilon is a number we define arbitrarily. We will vary epsilon to vary the amount of noise we give to the teacher votes."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "7FpVAOIChuHa"
   },
   "outputs": [],
   "source": [
    "# Number of classes in our setting\n",
    "num_positions = 3\n",
    "\n",
    "def hospitals_vote(hospital_p, epsilon=0.1):\n",
    "  new_labels = list()\n",
    "\n",
    "  for a_measurement in hospital_p:\n",
    "\n",
    "    label_counts = np.bincount(a_measurement, minlength=num_positions)\n",
    "\n",
    "    beta = 1 / epsilon\n",
    "\n",
    "    for i in range(len(label_counts)):\n",
    "      label_counts[i] += np.random.laplace(0, beta, 1)\n",
    "\n",
    "    new_label = np.argmax(label_counts)\n",
    "\n",
    "    new_labels.append(new_label)\n",
    "  \n",
    "  return np.array(new_labels)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "kyNZretKmP3n"
   },
   "source": [
    "## STEP 4: Analyze the results\n",
    "\n",
    "PySyft has a great function to analyze our results after applying PATE: `pate.perform_analysis()`. The output we get is based on the theory behind differential privacy, where we analyze our learning algorithms by calculating their respective (ε,δ) values. Slightly speaking, we can consider this ε as the amount of data leaked by our algorithm. Additionally,  `pate.perform_analysis()` calculates an ε that is independent of our teacher votes and one that depends on it. We are interested in the latter, because if we suppose, for example, that all our teachers agree on the same vote, then we can add with more confidence some noise and be sure that the majority vote will be the same as the one without adding any noise."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 121
    },
    "colab_type": "code",
    "id": "V-DMo2MmnLRL",
    "outputId": "110b5543-630c-49de-a5f6-52d2213ed048"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epsilon = 0.1\n",
      "Data Independent Epsilon: 184.47292546497027\n",
      "Data Dependent Epsilon: 184.4729254649701\n",
      "Epsilon = 0.01\n",
      "Data Independent Epsilon: 7.202231366242557\n",
      "Data Dependent Epsilon: 7.202231366242335\n"
     ]
    }
   ],
   "source": [
    "from syft.frameworks.torch.differential_privacy import pate\n",
    "\n",
    "print(\"Epsilon = 0.1\")\n",
    "indices = hospitals_vote(hospital_p, epsilon=0.1)\n",
    "data_dep_eps, data_ind_eps = pate.perform_analysis(teacher_preds=hospital_p.transpose(), indices=indices, noise_eps=0.1, delta=1e-5)\n",
    "print(\"Data Independent Epsilon:\", data_ind_eps)\n",
    "print(\"Data Dependent Epsilon:\", data_dep_eps)\n",
    "\n",
    "print(\"Epsilon = 0.01\")\n",
    "indices = hospitals_vote(hospital_p, epsilon=0.01)\n",
    "data_dep_eps, data_ind_eps = pate.perform_analysis(teacher_preds=hospital_p.transpose(), indices=indices, noise_eps=0.01, delta=1e-5)\n",
    "print(\"Data Independent Epsilon:\", data_ind_eps)\n",
    "print(\"Data Dependent Epsilon:\", data_dep_eps)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "trHDAJwqy3Y2"
   },
   "source": [
    "As expected, the more noise we give, the less information gets leaked (shown as a low value of `data_ind_eps`). However, what happened to the accuracy of the aggregated votes? Well, since we have labels in our simulated case, we can calculate this:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 121
    },
    "colab_type": "code",
    "id": "VvqowEnElbYy",
    "outputId": "9a746839-016e-4826-9549-9e1e07fa64c3"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epsilon = 1 (Almost no noise at all)\n",
      "Accuracy of the aggregated votes without almost no noise: 0.932\n",
      "Epsilon = 0.1\n",
      "Accuracy of the aggregated votes: 0.551\n",
      "Epsilon = 0.01\n",
      "Accuracy of the aggregated votes: 0.352\n"
     ]
    }
   ],
   "source": [
    "true_labels = my_data[:][1]\n",
    "print(\"Epsilon = 1 (Almost no noise at all)\")\n",
    "indices = hospitals_vote(hospital_p, epsilon=1)\n",
    "votes_acc = sum(np.array(indices) == true_labels)/np.shape(np.array(indices) == true_labels)[0]\n",
    "print(f\"Accuracy of the aggregated votes without almost no noise: {votes_acc:.3f}\")\n",
    "\n",
    "print(\"Epsilon = 0.1\")\n",
    "indices = hospitals_vote(hospital_p, epsilon=0.1)\n",
    "votes_acc = sum(np.array(indices) == true_labels)/np.shape(np.array(indices) == true_labels)[0]\n",
    "print(f\"Accuracy of the aggregated votes: {votes_acc:.3f}\")\n",
    "\n",
    "print(\"Epsilon = 0.01\")\n",
    "indices = hospitals_vote(hospital_p, epsilon=0.01)\n",
    "votes_acc = sum(np.array(indices) == true_labels)/np.shape(np.array(indices) == true_labels)[0]\n",
    "print(f\"Accuracy of the aggregated votes: {votes_acc:.3f}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "lTubL-TA4A73"
   },
   "source": [
    "The accuracy dropped dramatically! We can explain this by examining some noise values that are generated with the Laplace distribution:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 191
    },
    "colab_type": "code",
    "id": "6hHYcRha2WK4",
    "outputId": "e47e04df-48ad-42ae-fc36-a8e5c7ec6411"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[11.37609765]\n",
      "[-22.89845685]\n",
      "[-25.00192447]\n",
      "[-3.01532858]\n",
      "[10.64106731]\n",
      "[4.41105405]\n",
      "[2.83267913]\n",
      "[6.89490391]\n",
      "[-13.68992175]\n",
      "[2.20059478]\n"
     ]
    }
   ],
   "source": [
    "for i in range(10):\n",
    "  print(np.random.laplace(0, 1/0.1, 1))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "gfAGaS19jb9g"
   },
   "source": [
    "As we can see, these numbers are big compared with the number of votes we get in our matrix. Therefore, in order to preserve privacy, we also need to generate a large amount of teachers.\n",
    "\n",
    "> To ensure that the noisy label is likely to be the correct one, the noise scale should be small compared to the gap between the two largest values of the votes (for example, if we have three classes, ten teachers are the votes are [1, 2, 8], then the additive gap is six). Since the gap itself increases with the number of teachers, having more teachers would lower the privacy cost. (Idea taken from [Papernot et. al (2017](https://arxiv.org/abs/1610.05755)). "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "2szgnmw_6c3o"
   },
   "source": [
    "# Improving our PATE results: increase the amount of teachers\n",
    "\n",
    "Now we will extend our setting by creating several teachers for every hospital (i.e., several models for every subject data). We will test by creating 10, 15 and 20 models for every subject and we will plot the accuracy and ε with respect to the amount of noise we add. Additionally, we want to point out that every the subsets of data we use to model the individual teachers are all disjoint between each other.\n",
    "\n",
    "Note that we can confidently increase the number of teachers in our dataset as the complexity of classifying the positions of this dataset is low for the `CNN()` we proposed. An in-depth analysis of how accuracy gets affected by splitting the training set into smaller parts is out of the scope of this project."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 1000
    },
    "colab_type": "code",
    "id": "vaoLtluX8dDH",
    "outputId": "2cbef14f-e5a0-49f3-f575-4c08bcbd5660"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Running PATE using 100 teachers...\n",
      "Warning: May not have used enough values of l. Increase 'moments' variable and run again.\n",
      "Running PATE using 150 teachers...\n",
      "Warning: May not have used enough values of l. Increase 'moments' variable and run again.\n",
      "Warning: May not have used enough values of l. Increase 'moments' variable and run again.\n",
      "Warning: May not have used enough values of l. Increase 'moments' variable and run again.\n",
      "Warning: May not have used enough values of l. Increase 'moments' variable and run again.\n",
      "Warning: May not have used enough values of l. Increase 'moments' variable and run again.\n",
      "Warning: May not have used enough values of l. Increase 'moments' variable and run again.\n",
      "Running PATE using 300 teachers...\n",
      "Warning: May not have used enough values of l. Increase 'moments' variable and run again.\n",
      "Warning: May not have used enough values of l. Increase 'moments' variable and run again.\n",
      "Warning: May not have used enough values of l. Increase 'moments' variable and run again.\n",
      "Warning: May not have used enough values of l. Increase 'moments' variable and run again.\n",
      "Warning: May not have used enough values of l. Increase 'moments' variable and run again.\n",
      "Warning: May not have used enough values of l. Increase 'moments' variable and run again.\n",
      "Warning: May not have used enough values of l. Increase 'moments' variable and run again.\n",
      "Warning: May not have used enough values of l. Increase 'moments' variable and run again.\n",
      "Warning: May not have used enough values of l. Increase 'moments' variable and run again.\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1152x576 with 3 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1152x576 with 3 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1152x576 with 3 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "device = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")\n",
    "\n",
    "hospitals = [\"S1\", \"S2\", \"S3\", \"S4\", \"S5\", \"S6\", \"S7\", \"S8\", \"S9\", \"S10\"]\n",
    "\n",
    "hospitals_preds = {}\n",
    "\n",
    "my_hospital = [\"S11\", \"S12\", \"S13\"]\n",
    "\n",
    "my_data = helper.Mat_Dataset([\"Base\"], my_hospital)\n",
    "my_data_loader = DataLoader(my_data, batch_size=len(my_data), shuffle=False)\n",
    "\n",
    "class Mini_Dataset(torch.utils.data.Dataset):\n",
    "  def __init__(self, samples, labels):\n",
    "    self.samples = samples\n",
    "    self.labels = labels\n",
    "\n",
    "  def __len__(self):\n",
    "    return self.samples.shape[0]\n",
    "\n",
    "  def __getitem__(self, idx):\n",
    "    return self.samples[idx], self.labels[idx]\n",
    "\n",
    "for n_teachers in [10, 15, 30]:\n",
    "  \n",
    "  print(f\"Running PATE using {n_teachers * 10} teachers...\")  \n",
    "  for hospital in hospitals:\n",
    "    private_data = helper.Mat_Dataset([\"Base\"], [hospital])\n",
    "    n_images = len(private_data)\n",
    "    batch_size = int(n_images/n_teachers)\n",
    "    private_data_loader = DataLoader(private_data, batch_size=batch_size, shuffle=True)\n",
    "\n",
    "    i = 0\n",
    "\n",
    "    for samples, labels in iter(private_data_loader):\n",
    "      mini_dataset = Mini_Dataset(samples, labels)\n",
    "      if len(mini_dataset) < batch_size:\n",
    "        continue\n",
    "      mini_data_loader = DataLoader(mini_dataset, batch_size=int(len(mini_dataset)/5), shuffle=True)\n",
    "      private_model = train_teacher(device, mini_data_loader)\n",
    "      accuracy = 0\n",
    "      private_model.to(device)\n",
    "      private_model.eval()\n",
    "      with torch.no_grad():\n",
    "\n",
    "        for inputs, labels in my_data_loader:\n",
    "\n",
    "          inputs, labels = inputs.to(device), labels.to(device)\n",
    "          logps = private_model.forward(inputs)\n",
    "          ps = torch.exp(logps)\n",
    "          top_p, top_class = ps.topk(1, dim=1)\n",
    "          equals = top_class == labels.view(*top_class.shape)\n",
    "          accuracy += torch.mean(equals.type(torch.FloatTensor))\n",
    "          #print(f\"Accuracy {accuracy/len(my_data_loader):.3f}, Hospital: {hospital}, Teacher: {i}\")\n",
    "          hospitals_preds[hospital + \"_\" +  str(i)] = top_class\n",
    "          i += 1\n",
    "\n",
    "  hospital_p = np.hstack([hospitals_preds.get(key).cpu() for key in hospitals_preds.keys()])\n",
    "  num_positions = 3\n",
    "\n",
    "  accuracies = []\n",
    "  data_independent_eps = []\n",
    "  data_dependent_eps = []\n",
    "  noises = np.arange(0.1, 0, -0.01)\n",
    "  for noise_eps in noises:\n",
    "    indices = hospitals_vote(hospital_p, epsilon=noise_eps)\n",
    "    data_dep_eps, data_ind_eps = pate.perform_analysis(teacher_preds=hospital_p.transpose(), indices=indices, noise_eps=noise_eps, delta=1e-5)\n",
    "    #print(\"Data Independent Epsilon:\", data_ind_eps)\n",
    "    #print(\"Data Dependent Epsilon:\", data_dep_eps)\n",
    "\n",
    "    true_labels = my_data[:][1]\n",
    "    accuracies.append(sum(np.array(indices) == true_labels)/np.shape(np.array(indices) == true_labels)[0])\n",
    "    data_dependent_eps.append(data_dep_eps)\n",
    "    data_independent_eps.append(data_ind_eps)\n",
    "\n",
    "  noises = 1/np.arange(0.1, 0, -0.01)\n",
    "\n",
    "  fig = plt.figure(figsize=(16,8))\n",
    "\n",
    "  fig.suptitle(f'Trade-off between accuracy and privacy using {n_teachers*10} teachers')\n",
    "\n",
    "  ax1 = fig.add_subplot(1, 3, 1)\n",
    "  plt.plot(noises, accuracies)\n",
    "  ax1.title.set_text(\"Accuracy\")\n",
    "  ax1.set_xlabel('b (Laplace distribution\\'s scale parameter)')\n",
    "  ax1.set_ylabel('Accuracy [%]')\n",
    "  ax2 = fig.add_subplot(1, 3, 2)\n",
    "  plt.plot(noises, data_independent_eps)\n",
    "  ax2.title.set_text(\"Data Independent Epsilon\")\n",
    "  ax2.set_xlabel('b (Laplace distribution\\'s scale parameter)')\n",
    "  ax2.set_ylabel('Epsilon')\n",
    "  ax3 = fig.add_subplot(1, 3, 3, sharey = ax2)\n",
    "  plt.plot(noises, data_dependent_eps)\n",
    "  ax3.title.set_text(\"Data Dependent Epsilon\")\n",
    "  ax3.set_xlabel('b (Laplace distribution\\'s scale parameter)')\n",
    "  ax3.set_ylabel('Epsilon')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "BsW7dYjIAyh3"
   },
   "source": [
    "## [Part 3] - Conclusions\n",
    "\n",
    "The latter results are really enlightening: \n",
    "\n",
    "First, on all the plots of the left we see, as expected, a decrease of the accuracy the more noise we add. \n",
    "\n",
    "Now, if we take into account the _Data Dependent Epsilon_ plot on the right we see that, in comparison with the _Data Dependent Epsilon_ plots, **for low levels of noise we can ensure privacy** by obtaining a low epsilon, **even when adding small quantities of noise** (which also means that our accuracy will be better). \n",
    "\n",
    "We can explain the _low epsilon obtained_ as follows: since now we have a high amount of teachers individually work well on the data, we expect a high level of agreement between them. The higher the agreement is, the more we can be confident that adding a low amount of noise will not change the plurality vote of the teachers, meaning that there are no teachers that are \"fundamental\" when taking the majority vote, and this in turn means that our epsilon is low.\n",
    "\n",
    "Hence, if we train a student model with, for example, our 100-teacher-generated labels (`indices`), we can create a model that maintains a high level of accuracy while being preserving the privacy of the data used to generate it!"
   ]
  }
 ],
 "metadata": {
  "accelerator": "GPU",
  "colab": {
   "collapsed_sections": [],
   "name": "Part_3_Achieving_Privacy_with_Private_Aggregation_of_Teacher_Ensembles.ipynb",
   "provenance": [],
   "version": "0.3.2"
  },
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}