CanaryGradientInteractive_POC.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Example canary-gradient-based MIA"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import os\n",
    "os.environ['CUDA_VISIBLE_DEVICES'] = '0'\n",
    "\n",
    "import tensorflow as tf\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "import math\n",
    "from functools import partial\n",
    "\n",
    "import models\n",
    "from utility import lr_schlr\n",
    "from canary_attack import load_dataset, setup_model, evaluate_canary_attack, inject_canary\n",
    "from canary_utility import local_training"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Setup"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "cifar10_cifar100_256_0.001_resnet20_last_layer_0.001_0.001\n"
     ]
    }
   ],
   "source": [
    "rng_seed = 1\n",
    "dataset_key = \"cifar10\"\n",
    "dataset_key_shadow = \"cifar100\"\n",
    "batch_size_train = 256\n",
    "batch_size_test = 64\n",
    "\n",
    "# attack\n",
    "max_number_of_iters = 10000\n",
    "opt = tf.keras.optimizers.Adam()\n",
    "\n",
    "model_id = 'resnet20'\n",
    "canary_id = 'last_layer'\n",
    "loss_function = models.sparse_classification_loss\n",
    "max_number_of_iters = 3000\n",
    "loss_threshold = 0.001\n",
    "\n",
    "max_num_batches_eval = 100\n",
    "\n",
    "# FedAVG\n",
    "num_iter_fedAVG = 15\n",
    "learning_rate_fedAVG = 0.001\n",
    "\n",
    "name = '_'.join(map(str,[dataset_key, dataset_key_shadow, batch_size_train, loss_threshold, model_id, canary_id, loss_threshold, learning_rate_fedAVG]))\n",
    "print(name)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Load datasets"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "tf.random.set_seed(rng_seed)\n",
    "np.random.seed(rng_seed)  \n",
    "\n",
    "validation, shadow, x_shape, class_num, (x_target, y_target) = load_dataset(\n",
    "    dataset_key,\n",
    "    dataset_key_shadow,\n",
    "    batch_size_test,\n",
    "    batch_size_train,\n",
    "    data_aug_shadow=False\n",
    ")\n",
    "    \n",
    "plt.imshow((x_target[0]+1)/2);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Chosing canary location (i.e., $\\xi$)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "----> layer_normalization_20 (None, 8, 8, 64)\n",
      "--------> (None, 8, 8)\n",
      "input_1\n",
      "\n",
      "conv2d\n",
      "\t conv2d/kernel:0\n",
      "\n",
      "layer_normalization\n",
      "\t layer_normalization/gamma:0\n",
      "\t layer_normalization/beta:0\n",
      "\n",
      "activation\n",
      "\n",
      "conv2d_1\n",
      "\t conv2d_1/kernel:0\n",
      "\n",
      "layer_normalization_1\n",
      "\t layer_normalization_1/gamma:0\n",
      "\t layer_normalization_1/beta:0\n",
      "\n",
      "activation_1\n",
      "\n",
      "conv2d_2\n",
      "\t conv2d_2/kernel:0\n",
      "\n",
      "layer_normalization_2\n",
      "\t layer_normalization_2/gamma:0\n",
      "\t layer_normalization_2/beta:0\n",
      "\n",
      "activation_2\n",
      "\n",
      "tf.__operators__.add\n",
      "\n",
      "conv2d_3\n",
      "\t conv2d_3/kernel:0\n",
      "\n",
      "layer_normalization_3\n",
      "\t layer_normalization_3/gamma:0\n",
      "\t layer_normalization_3/beta:0\n",
      "\n",
      "activation_3\n",
      "\n",
      "conv2d_4\n",
      "\t conv2d_4/kernel:0\n",
      "\n",
      "layer_normalization_4\n",
      "\t layer_normalization_4/gamma:0\n",
      "\t layer_normalization_4/beta:0\n",
      "\n",
      "activation_4\n",
      "\n",
      "tf.__operators__.add_1\n",
      "\n",
      "conv2d_5\n",
      "\t conv2d_5/kernel:0\n",
      "\n",
      "layer_normalization_5\n",
      "\t layer_normalization_5/gamma:0\n",
      "\t layer_normalization_5/beta:0\n",
      "\n",
      "activation_5\n",
      "\n",
      "conv2d_6\n",
      "\t conv2d_6/kernel:0\n",
      "\n",
      "layer_normalization_6\n",
      "\t layer_normalization_6/gamma:0\n",
      "\t layer_normalization_6/beta:0\n",
      "\n",
      "activation_6\n",
      "\n",
      "tf.__operators__.add_2\n",
      "\n",
      "conv2d_7\n",
      "\t conv2d_7/kernel:0\n",
      "\n",
      "layer_normalization_7\n",
      "\t layer_normalization_7/gamma:0\n",
      "\t layer_normalization_7/beta:0\n",
      "\n",
      "activation_7\n",
      "\n",
      "conv2d_8\n",
      "\t conv2d_8/kernel:0\n",
      "\n",
      "layer_normalization_8\n",
      "\t layer_normalization_8/gamma:0\n",
      "\t layer_normalization_8/beta:0\n",
      "\n",
      "conv2d_9\n",
      "\t conv2d_9/kernel:0\n",
      "\n",
      "activation_8\n",
      "\n",
      "layer_normalization_9\n",
      "\t layer_normalization_9/gamma:0\n",
      "\t layer_normalization_9/beta:0\n",
      "\n",
      "tf.__operators__.add_3\n",
      "\n",
      "conv2d_10\n",
      "\t conv2d_10/kernel:0\n",
      "\n",
      "layer_normalization_10\n",
      "\t layer_normalization_10/gamma:0\n",
      "\t layer_normalization_10/beta:0\n",
      "\n",
      "activation_9\n",
      "\n",
      "conv2d_11\n",
      "\t conv2d_11/kernel:0\n",
      "\n",
      "layer_normalization_11\n",
      "\t layer_normalization_11/gamma:0\n",
      "\t layer_normalization_11/beta:0\n",
      "\n",
      "activation_10\n",
      "\n",
      "tf.__operators__.add_4\n",
      "\n",
      "conv2d_12\n",
      "\t conv2d_12/kernel:0\n",
      "\n",
      "layer_normalization_12\n",
      "\t layer_normalization_12/gamma:0\n",
      "\t layer_normalization_12/beta:0\n",
      "\n",
      "activation_11\n",
      "\n",
      "conv2d_13\n",
      "\t conv2d_13/kernel:0\n",
      "\n",
      "layer_normalization_13\n",
      "\t layer_normalization_13/gamma:0\n",
      "\t layer_normalization_13/beta:0\n",
      "\n",
      "activation_12\n",
      "\n",
      "tf.__operators__.add_5\n",
      "\n",
      "conv2d_14\n",
      "\t conv2d_14/kernel:0\n",
      "\n",
      "layer_normalization_14\n",
      "\t layer_normalization_14/gamma:0\n",
      "\t layer_normalization_14/beta:0\n",
      "\n",
      "activation_13\n",
      "\n",
      "conv2d_15\n",
      "\t conv2d_15/kernel:0\n",
      "\n",
      "layer_normalization_15\n",
      "\t layer_normalization_15/gamma:0\n",
      "\t layer_normalization_15/beta:0\n",
      "\n",
      "conv2d_16\n",
      "\t conv2d_16/kernel:0\n",
      "\n",
      "activation_14\n",
      "\n",
      "layer_normalization_16\n",
      "\t layer_normalization_16/gamma:0\n",
      "\t layer_normalization_16/beta:0\n",
      "\n",
      "tf.__operators__.add_6\n",
      "\n",
      "conv2d_17\n",
      "\t conv2d_17/kernel:0\n",
      "\n",
      "layer_normalization_17\n",
      "\t layer_normalization_17/gamma:0\n",
      "\t layer_normalization_17/beta:0\n",
      "\n",
      "activation_15\n",
      "\n",
      "conv2d_18\n",
      "\t conv2d_18/kernel:0\n",
      "\n",
      "layer_normalization_18\n",
      "\t layer_normalization_18/gamma:0\n",
      "\t layer_normalization_18/beta:0\n",
      "\n",
      "activation_16\n",
      "\n",
      "tf.__operators__.add_7\n",
      "\n",
      "conv2d_19\n",
      "\t conv2d_19/kernel:0\n",
      "\n",
      "layer_normalization_19\n",
      "\t layer_normalization_19/gamma:0\n",
      "\t layer_normalization_19/beta:0\n",
      "\n",
      "activation_17\n",
      "\n",
      "conv2d_20\n",
      "\t conv2d_20/kernel:0\n",
      "\n",
      "layer_normalization_20\n",
      "\t layer_normalization_20/gamma:0\n",
      "\t layer_normalization_20/beta:0\n",
      "\n"
     ]
    }
   ],
   "source": [
    "model, layer_idx, g_canary_shift, kernel_idx, pre_canary_layer_trainable_variables = setup_model(model_id, canary_id, x_shape, class_num)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Injecting Canary"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "709it [00:50, 15.56it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Loss Threshold reached!\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "logs = inject_canary(\n",
    "    max_number_of_iters,\n",
    "    batch_size_train,\n",
    "    model,\n",
    "    x_target,\n",
    "    shadow,\n",
    "    pre_canary_layer_trainable_variables,\n",
    "    opt,\n",
    "    loss_threshold=loss_threshold\n",
    ")\n",
    "\n",
    "plt.plot(logs[0]);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Evaluate FedSGD"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Max number of iterations evaluation reached!\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "{'accuracy': 1.0, 'recall': 1.0, 'precision': 1.0}"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "test_canary_fn = partial(\n",
    "    evaluate_canary_attack,\n",
    "    target=x_target,\n",
    "    variables=pre_canary_layer_trainable_variables,\n",
    "    loss_function=loss_function,\n",
    "    g_canary_shift=g_canary_shift,\n",
    "    kernel_idx=kernel_idx,\n",
    "    max_num_batches_eval=max_num_batches_eval\n",
    ")\n",
    "    \n",
    "\n",
    "out, failed = test_canary_fn(model, validation)\n",
    "out"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Evaluate FedAVG (run local SGD step and test canary again)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "709it [01:10, 15.56it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Max number of iterations evaluation reached!\n",
      " FedAVG round: 1\n",
      "\t{'accuracy': 1.0, 'recall': 1.0, 'precision': 1.0}\n",
      "Max number of iterations evaluation reached!\n",
      " FedAVG round: 2\n",
      "\t{'accuracy': 1.0, 'recall': 1.0, 'precision': 1.0}\n",
      "Max number of iterations evaluation reached!\n",
      " FedAVG round: 3\n",
      "\t{'accuracy': 1.0, 'recall': 1.0, 'precision': 1.0}\n",
      "Max number of iterations evaluation reached!\n",
      " FedAVG round: 4\n",
      "\t{'accuracy': 1.0, 'recall': 1.0, 'precision': 1.0}\n",
      "Max number of iterations evaluation reached!\n",
      " FedAVG round: 5\n",
      "\t{'accuracy': 1.0, 'recall': 1.0, 'precision': 1.0}\n",
      "Max number of iterations evaluation reached!\n",
      " FedAVG round: 6\n",
      "\t{'accuracy': 1.0, 'recall': 1.0, 'precision': 1.0}\n",
      "Max number of iterations evaluation reached!\n",
      " FedAVG round: 7\n",
      "\t{'accuracy': 1.0, 'recall': 1.0, 'precision': 1.0}\n",
      "Max number of iterations evaluation reached!\n",
      " FedAVG round: 8\n",
      "\t{'accuracy': 1.0, 'recall': 1.0, 'precision': 1.0}\n",
      "Max number of iterations evaluation reached!\n",
      " FedAVG round: 9\n",
      "\t{'accuracy': 1.0, 'recall': 1.0, 'precision': 1.0}\n",
      "Max number of iterations evaluation reached!\n",
      " FedAVG round: 10\n",
      "\t{'accuracy': 1.0, 'recall': 1.0, 'precision': 1.0}\n",
      "Max number of iterations evaluation reached!\n",
      " FedAVG round: 11\n",
      "\t{'accuracy': 1.0, 'recall': 1.0, 'precision': 1.0}\n",
      "Max number of iterations evaluation reached!\n",
      " FedAVG round: 12\n",
      "\t{'accuracy': 1.0, 'recall': 1.0, 'precision': 1.0}\n",
      "Max number of iterations evaluation reached!\n",
      " FedAVG round: 13\n",
      "\t{'accuracy': 1.0, 'recall': 1.0, 'precision': 1.0}\n",
      "Max number of iterations evaluation reached!\n",
      " FedAVG round: 14\n",
      "\t{'accuracy': 1.0, 'recall': 1.0, 'precision': 1.0}\n",
      "Max number of iterations evaluation reached!\n",
      " FedAVG round: 15\n",
      "\t{'accuracy': 1.0, 'recall': 1.0, 'precision': 1.0}\n"
     ]
    }
   ],
   "source": [
    "canary_scores_FedAVG = local_training(\n",
    "    model,\n",
    "    validation,\n",
    "    num_iter_fedAVG,\n",
    "    learning_rate_fedAVG,\n",
    "    loss_function,\n",
    "    test_canary_fn\n",
    ")"
   ]
  }
 ],
 "metadata": {
  "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": 4
}