examples/IntermidiateLevelAttack.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "honest-paper",
   "metadata": {},
   "outputs": [],
   "source": [
    "from __future__ import print_function\n",
    "import torch\n",
    "import torch.nn as nn\n",
    "import torch.nn.functional as F\n",
    "import torch.optim as optim\n",
    "from torchvision import datasets, transforms\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "# NOTE: This is a hack to get around \"User-agent\" limitations when downloading MNIST datasets\n",
    "#       see, https://github.com/pytorch/vision/issues/3497 for more information\n",
    "from six.moves import urllib\n",
    "opener = urllib.request.build_opener()\n",
    "opener.addheaders = [('User-agent', 'Mozilla/5.0')]\n",
    "urllib.request.install_opener(opener)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "genuine-wealth",
   "metadata": {},
   "outputs": [],
   "source": [
    "from attacksplitnn.splitnn import Client, Server, SplitNN\n",
    "from attacksplitnn.attack import IntermidiateLevelAttack"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "scientific-water",
   "metadata": {},
   "outputs": [],
   "source": [
    "epsilons = [.15]\n",
    "pretrained_model = \"data/lenet_mnist_model.pth\"\n",
    "use_cuda=True"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "irish-pharmacology",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "CUDA Available:  False\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "Net(\n",
       "  (conv1): Conv2d(1, 10, kernel_size=(5, 5), stride=(1, 1))\n",
       "  (conv2): Conv2d(10, 20, kernel_size=(5, 5), stride=(1, 1))\n",
       "  (conv2_drop): Dropout2d(p=0.5, inplace=False)\n",
       "  (fc1): Linear(in_features=320, out_features=50, bias=True)\n",
       "  (fc2): Linear(in_features=50, out_features=10, bias=True)\n",
       ")"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# LeNet Model definition\n",
    "class Net(nn.Module):\n",
    "    def __init__(self):\n",
    "        super(Net, self).__init__()\n",
    "        self.conv1 = nn.Conv2d(1, 10, kernel_size=5)\n",
    "        self.conv2 = nn.Conv2d(10, 20, kernel_size=5)\n",
    "        self.conv2_drop = nn.Dropout2d()\n",
    "        self.fc1 = nn.Linear(320, 50)\n",
    "        self.fc2 = nn.Linear(50, 10)\n",
    "\n",
    "    def forward(self, x):\n",
    "        x = F.relu(F.max_pool2d(self.conv1(x), 2))\n",
    "        x = F.relu(F.max_pool2d(self.conv2_drop(self.conv2(x)), 2))\n",
    "        x = x.view(-1, 320)\n",
    "        x = F.relu(self.fc1(x))\n",
    "        x = F.dropout(x, training=self.training)\n",
    "        x = self.fc2(x)\n",
    "        return F.log_softmax(x, dim=1)\n",
    "# MNIST Test dataset and dataloader declaration\n",
    "test_loader = torch.utils.data.DataLoader(\n",
    "    datasets.MNIST(root='./data', train=False, download=False, transform=transforms.Compose([\n",
    "            transforms.ToTensor(),\n",
    "            ])),\n",
    "        batch_size=1, shuffle=True)\n",
    "# Define what device we are using\n",
    "print(\"CUDA Available: \",torch.cuda.is_available())\n",
    "device = torch.device(\"cuda\" if (use_cuda and torch.cuda.is_available()) else \"cpu\")\n",
    "# Initialize the network\n",
    "model = Net().to(device)\n",
    "# Load the pretrained model\n",
    "model.load_state_dict(torch.load(pretrained_model, map_location='cpu'))\n",
    "# Set the model in evaluation mode. In this case this is for the Dropout layers\n",
    "model.eval()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "signed-bracket",
   "metadata": {},
   "outputs": [],
   "source": [
    "# FGSM attack code\n",
    "def fgsm_attack(image, epsilon, data_grad):\n",
    "    # Collect the element-wise sign of the data gradient\n",
    "    sign_data_grad = data_grad.sign()\n",
    "    # Create the perturbed image by adjusting each pixel of the input image\n",
    "    perturbed_image = image + epsilon*sign_data_grad\n",
    "    # Adding clipping to maintain [0,1] range\n",
    "    perturbed_image = torch.clamp(perturbed_image, 0, 1)\n",
    "    # Return the perturbed image\n",
    "    return perturbed_image"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "electoral-nicaragua",
   "metadata": {},
   "outputs": [],
   "source": [
    "def test( model, device, test_loader, epsilon ):\n",
    "    # Accuracy counter\n",
    "    correct = 0\n",
    "    adv_examples = []\n",
    "    # Loop over all examples in test set\n",
    "    for data, target in test_loader:\n",
    "        # Send the data and label to the device\n",
    "        data, target = data.to(device), target.to(device)\n",
    "        # Set requires_grad attribute of tensor. Important for Attack\n",
    "        data.requires_grad = True\n",
    "        # Forward pass the data through the model\n",
    "        output = model(data)\n",
    "        init_pred = output.max(1, keepdim=True)[1] # get the index of the max log-probability\n",
    "        # If the initial prediction is wrong, dont bother attacking, just move on\n",
    "        if init_pred.item() != target.item():\n",
    "            continue\n",
    "        # Calculate the loss\n",
    "        loss = F.nll_loss(output, target)\n",
    "        # Zero all existing gradients\n",
    "        model.zero_grad()\n",
    "        # Calculate gradients of model in backward pass\n",
    "        loss.backward()\n",
    "        # Collect datagrad\n",
    "        data_grad = data.grad.data\n",
    "        # Call FGSM Attack\n",
    "        perturbed_data = fgsm_attack(data, epsilon, data_grad)\n",
    "        # Re-classify the perturbed image\n",
    "        output = model(perturbed_data)\n",
    "        # Check for success\n",
    "        final_pred = output.max(1, keepdim=True)[1] # get the index of the max log-probability\n",
    "        if final_pred.item() == target.item():\n",
    "            correct += 1\n",
    "            # Special case for saving 0 epsilon examples\n",
    "            if (epsilon == 0) and (len(adv_examples) < 5):\n",
    "                adv_ex = perturbed_data.squeeze().detach().cpu().numpy()\n",
    "                adv_examples.append( (init_pred.item(), final_pred.item(), adv_ex) )\n",
    "        else:\n",
    "            # Save some adv examples for visualization later\n",
    "            if len(adv_examples) < 5:\n",
    "                adv_ex = perturbed_data.squeeze().detach().cpu().numpy()\n",
    "                adv_examples.append( (init_pred.item(), final_pred.item(), adv_ex) )\n",
    "    # Calculate final accuracy for this epsilon\n",
    "    final_acc = correct/float(len(test_loader))\n",
    "    print(\"Epsilon: {}\\tTest Accuracy = {} / {} = {}\".format(epsilon, correct, len(test_loader), final_acc))\n",
    "    # Return the accuracy and an adversarial example\n",
    "    return final_acc, adv_examples"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "stock-vegetable",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epsilon: 0.15\tTest Accuracy = 6826 / 10000 = 0.6826\n"
     ]
    }
   ],
   "source": [
    "accuracies = []\n",
    "examples = []\n",
    "\n",
    "# Run test for each epsilon\n",
    "for eps in epsilons:\n",
    "    acc, ex = test(model, device, test_loader, eps)\n",
    "    accuracies.append(acc)\n",
    "    examples.append(ex)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "id": "subtle-version",
   "metadata": {},
   "outputs": [],
   "source": [
    "# LeNet Model definition\n",
    "class FirstNet(nn.Module):\n",
    "    def __init__(self):\n",
    "        super(FirstNet, self).__init__()\n",
    "        self.conv1 = model.conv1\n",
    "        self.conv2 = model.conv2\n",
    "        self.conv2_drop = model.conv2_drop\n",
    "\n",
    "    def forward(self, x):\n",
    "        x = F.relu(F.max_pool2d(self.conv1(x), 2))\n",
    "        x = F.relu(F.max_pool2d(self.conv2_drop(self.conv2(x)), 2))\n",
    "        x = x.view(-1, 320)\n",
    "        return x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "id": "native-recorder",
   "metadata": {},
   "outputs": [],
   "source": [
    "# LeNet Model definition\n",
    "class SecondNet(nn.Module):\n",
    "    def __init__(self):\n",
    "        super(SecondNet, self).__init__()\n",
    "        self.fc1 = model.fc1\n",
    "        self.fc2 = model.fc2\n",
    "\n",
    "    def forward(self, x):\n",
    "        x = F.relu(self.fc1(x))\n",
    "        x = F.dropout(x, training=self.training)\n",
    "        x = self.fc2(x)\n",
    "        return F.log_softmax(x, dim=1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "id": "polyphonic-version",
   "metadata": {},
   "outputs": [],
   "source": [
    "model_1 = FirstNet()\n",
    "model_1 = model_1.to(device)\n",
    "\n",
    "model_2 = SecondNet()\n",
    "model_2 = model_2.to(device)\n",
    "\n",
    "opt_1 = optim.Adam(model_1.parameters(), lr=1e-3)\n",
    "opt_2 = optim.Adam(model_2.parameters(), lr=1e-3)\n",
    "\n",
    "criterion = F.nll_loss\n",
    "\n",
    "client = Client(model_1)\n",
    "server = Server(model_2)\n",
    "\n",
    "splitnn = SplitNN(client, server, opt_1, opt_2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 191,
   "id": "unavailable-taxation",
   "metadata": {},
   "outputs": [],
   "source": [
    "ila = IntermidiateLevelAttack(splitnn, 300, 5e2, 1, 0.3, with_projection=False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 192,
   "id": "interstate-handling",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 192,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len(examples)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 193,
   "id": "computational-uncertainty",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3 2\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<matplotlib.image.AxesImage at 0x1f384d9bac0>"
      ]
     },
     "execution_count": 193,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "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": [
    "print(examples[0][2][0], examples[0][2][1])\n",
    "adversarial_example = examples[0][2][2]\n",
    "plt.imshow(adversarial_example, cmap=\"gray\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 194,
   "id": "under-rhythm",
   "metadata": {},
   "outputs": [],
   "source": [
    "for data in test_loader:\n",
    "    x, y = data[0], data[1]\n",
    "    if y == 3:\n",
    "        break"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 195,
   "id": "enhanced-longer",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.image.AxesImage at 0x1f384ded940>"
      ]
     },
     "execution_count": 195,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "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": [
    "plt.imshow(x.reshape(28, 28), cmap=\"gray\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 196,
   "id": "wanted-investigator",
   "metadata": {},
   "outputs": [],
   "source": [
    "improved_adversarial_example =\\\n",
    "    ila.attack(x, torch.tensor(adversarial_example).reshape(1, 1, 28, 28))\n",
    "\n",
    "#improved_adversarial_example =\\\n",
    "#    ila.attack(torch.tensor(adversarial_example).reshape(1, 1, 28, 28), x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 197,
   "id": "encouraging-litigation",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.image.AxesImage at 0x1f384e44ee0>"
      ]
     },
     "execution_count": 197,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "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": [
    "plt.imshow(improved_adversarial_example.detach().numpy().reshape(28, 28), cmap=\"gray\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 198,
   "id": "conventional-bailey",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tensor([[-5.0773, -4.6560, -4.9995, -0.1307, -6.6759, -2.5901, -6.5208, -4.6597,\n",
       "         -5.5873, -4.7008]], grad_fn=<LogSoftmaxBackward>)"
      ]
     },
     "execution_count": 198,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "model(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 199,
   "id": "compatible-direction",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tensor([[-4.1109, -2.5250, -0.7170, -1.6996, -4.5845, -3.6864, -5.1711, -1.8943,\n",
       "         -3.5195, -4.4554]], grad_fn=<LogSoftmaxBackward>)"
      ]
     },
     "execution_count": 199,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "model(improved_adversarial_example)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 200,
   "id": "sound-athletics",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tensor([[-4.4411, -2.4131, -1.2055, -1.3830, -4.5097, -4.1008, -5.4751, -1.7146,\n",
       "         -2.2638, -3.4242]], grad_fn=<LogSoftmaxBackward>)"
      ]
     },
     "execution_count": 200,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "model(torch.Tensor(adversarial_example).reshape(1, 1, 28, 28))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "looking-console",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "domestic-finder",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "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.9.1"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}