membership_inference/Lab - Membership Inference.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "fd318108",
   "metadata": {},
   "source": [
    "# Lab - Membership Inference"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3cebdbb7",
   "metadata": {},
   "source": [
    "## Install dependencies"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "640a06ab",
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "%pip install torch torchvision tqdm scikit-learn matplotlib"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "960b3574",
   "metadata": {},
   "source": [
    "## Prepare the dataset\n",
    "\n",
    "This sets up three slices of CIFAR-10:\n",
    "\n",
    "- Train: the secret dataset that's used to train the target model (not available to the attacker)\n",
    "- Hold-out: a dataset that's available to the attacker\n",
    "- Test: a dataset used for evaluation of the membership inference attack (not available to the attacker)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "b0ed9986",
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import torch\n",
    "import torch.nn as nn\n",
    "from torch.utils.data import random_split, ConcatDataset\n",
    "from torchvision.transforms import ToTensor\n",
    "from torchvision.datasets import CIFAR10\n",
    "from tqdm.auto import tqdm\n",
    "import matplotlib.pyplot as plt"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "2a08c8f2",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Files already downloaded and verified\n",
      "Files already downloaded and verified\n"
     ]
    }
   ],
   "source": [
    "cifar10_train = CIFAR10(root='./cifar10', train=True, download=True, transform=ToTensor())\n",
    "cifar10_test = CIFAR10(root='./cifar10', train=False, download=True, transform=ToTensor())\n",
    "cifar10_all = ConcatDataset([cifar10_train, cifar10_test])\n",
    "\n",
    "train_ds, test_ds, holdout_ds = \\\n",
    "    random_split(cifar10_all, [.25, .25, .5], generator=torch.Generator().manual_seed(1337))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "9d8ed30c",
   "metadata": {},
   "outputs": [],
   "source": [
    "from torch.utils.data.dataset import Dataset\n",
    "\n",
    "class AppendDataset(Dataset):\n",
    "    '''\n",
    "    Appends a constant label to all points in a dataset.\n",
    "    '''\n",
    "    def __init__(self, ds, y):\n",
    "        self._ds = ds\n",
    "        self._y = y\n",
    "    \n",
    "    def __getitem__(self, idx):\n",
    "        x = self._ds[idx]\n",
    "        return x, self._y\n",
    "    \n",
    "    def __len__(self):\n",
    "        return len(self._ds)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "d0828741",
   "metadata": {},
   "outputs": [],
   "source": [
    "mi_test_ds = ConcatDataset([AppendDataset(train_ds, True), AppendDataset(test_ds, False)])\n",
    "mi_test_ds_labels = np.array([i[1] for i in mi_test_ds])"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "18999cda",
   "metadata": {},
   "source": [
    "## Load target model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "8772fa21",
   "metadata": {},
   "outputs": [],
   "source": [
    "from target_model import get_model\n",
    "# note: the target_model.py file\n",
    "# is part of the lab infrastructure; the attacker does not get to see\n",
    "# the code inside target_model, only make black-box inferences\n",
    "# using the target model\n",
    "\n",
    "target_model = get_model()\n",
    "target_model.load_state_dict(torch.load('target_model.pt'))\n",
    "target_model.eval()\n",
    "\n",
    "if torch.cuda.is_available():\n",
    "    target_model = target_model.cuda()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f8c9feb7",
   "metadata": {},
   "source": [
    "## Tools to evaluate your attack"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "d9f13b92",
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn import metrics\n",
    "from matplotlib import pyplot as plt\n",
    "\n",
    "def run_attack(attack, batch_size=50):\n",
    "    loader = torch.utils.data.DataLoader(mi_test_ds, batch_size=batch_size, shuffle=False, pin_memory=True)\n",
    "    all_preds = []\n",
    "    for (images, classes), labels in loader:\n",
    "        with torch.no_grad():\n",
    "            model_input = images\n",
    "            if torch.cuda.is_available():\n",
    "                model_input = images.cuda()\n",
    "            target_model_outputs = nn.functional.softmax(target_model(model_input))\n",
    "        preds = attack(images, classes, target_model_outputs)\n",
    "        if hasattr(preds, 'cpu'):\n",
    "            preds = preds.cpu().detach().numpy()\n",
    "        labels = labels.cpu().detach().numpy()\n",
    "        all_preds.append(preds)\n",
    "    all_preds = np.concatenate(all_preds)\n",
    "    \n",
    "    return all_preds\n",
    "\n",
    "def plot_roc(*scores_and_names):\n",
    "    '''\n",
    "    Plots an ROC curve and computes AUC, given a list of scores and method names.\n",
    "    \n",
    "    Call this function like plot_roc(scores1, 'name of attack 1', scores2, 'name of attack 2', ...)\n",
    "    to compare different attacks.\n",
    "    '''\n",
    "    fpr = []\n",
    "    tpr = []\n",
    "    for score, name in zip(scores_and_names[::2], scores_and_names[1::2]):\n",
    "        fpr, tpr, thresholds = metrics.roc_curve(mi_test_ds_labels, score)\n",
    "        auc = metrics.roc_auc_score(mi_test_ds_labels, score)\n",
    "        plt.plot(fpr, tpr, label=f'{name} (AUC = {auc:.2f})')\n",
    "    plt.legend(loc=0)\n",
    "    plt.plot([0, 1], [0, 1], 'k--')\n",
    "    plt.xlim([0.0, 1.0])\n",
    "    plt.ylim([0.0, 1.05])\n",
    "    plt.xlabel('False Positive Rate')\n",
    "    plt.ylabel('True Positive Rate')\n",
    "\n",
    "def compute_stats(*preds_and_names):\n",
    "    fpr = []\n",
    "    tpr = []\n",
    "    for pred, name in zip(preds_and_names[::2], preds_and_names[1::2]):\n",
    "        precision = metrics.precision_score(mi_test_ds_labels, pred)\n",
    "        recall = metrics.recall_score(mi_test_ds_labels, pred)\n",
    "        f1 = metrics.f1_score(mi_test_ds_labels, pred)\n",
    "        print(name)\n",
    "        print(f'  Precision: {precision:.4f}')\n",
    "        print(f'     Recall: {recall:.4f}')\n",
    "        print(f'   F1 Score: {f1:.4f}')\n",
    "        print()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "afb13735",
   "metadata": {},
   "source": [
    "## Membership inference attacks\n",
    "\n",
    "A membership inference attack is implemented as a function that takes in a tensor of data points (floats, `[N, C, H, W]`), class labels (integer-encoded, `[N]`), and model outputs from the black-box target model (floats, `[N, 10]`), and predicts whether or not they were used in the training set of the target model. The attack can either return an array of booleans or an array of scores. If it returns scores, the lab infrastructure can compute ROC and AUC for you.\n",
    "\n",
    "A higher score means that the data point is more likely to belong to the training set.\n",
    "\n",
    "Here, we implement a couple silly attacks, just to show you how the pieces of the lab infrastructure fit together."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "e5cccb9e",
   "metadata": {},
   "outputs": [],
   "source": [
    "def membership_inference_attack_random_bool(x, y, probs):\n",
    "    '''\n",
    "    A silly \"attack\" that returns random results.\n",
    "    '''\n",
    "    return np.random.uniform(size=len(x)) > 0.5\n",
    "\n",
    "def membership_inference_attack_random_score(x, y, probs):\n",
    "    '''\n",
    "    A silly \"attack\" that returns random scores.\n",
    "    '''\n",
    "    return np.random.uniform(size=len(x))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "23723840",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Random Prediction\n",
      "  Precision: 0.4986\n",
      "     Recall: 0.5059\n",
      "   F1 Score: 0.5022\n",
      "\n"
     ]
    }
   ],
   "source": [
    "preds = run_attack(membership_inference_attack_random_bool)\n",
    "compute_stats(preds, 'Random Prediction')\n",
    "# note: it doesn't make sense to compute an ROC curve with predictions (only scores)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "41261718",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Random Score, Threshold = 0.55\n",
      "  Precision: 0.4960\n",
      "     Recall: 0.4465\n",
      "   F1 Score: 0.4700\n",
      "\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "scores = run_attack(membership_inference_attack_random_score)\n",
    "plot_roc(scores, 'Random Score')\n",
    "compute_stats(scores > 0.55, 'Random Score, Threshold = 0.55')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "85745c6f",
   "metadata": {},
   "source": [
    "# Exercise: implement membership inference attacks\n",
    "\n",
    "Implement one (or multiple) of the membership inference attack algorithms described in lecture. We suggest that you start with some of the simpler ones (metric-based attacks), and then try a fancier attack (like the one using shadow models). If you use shadow models, you'll need to design your own neural network architectures (you don't know what the target model is using). You could try using pre-defined NN models, like `resnet18` from `torchvision.models`, or come up with your own.\n",
    "\n",
    "To design/train your membership attack, you may use the labeled `holdout_ds` however you like. That dataset is fully available to the attacker. You should not use the ground-truth `mi_test_ds` that is used for evaluating your solution.\n",
    "\n",
    "For methods that give scores, you can plot an ROC curve and look at the AUC. You can also think about how you'd choose a threshold (you don't have the ROC curve available to help you choose the threshold: the ROC curve is produced using ground truth data, which the attacker doesn't have access to)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "a5817e90",
   "metadata": {},
   "outputs": [],
   "source": [
    "# YOUR CODE HERE"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "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.8.10"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}