notebooks/poisoning_attack_feature_collision-pytorch.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Clean-Label Feature Collision Attacks on a PyTorch Classifier"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In this notebook, we will learn how to use ART to run a clean-label feature collision poisoning attack on a neural network trained with PyTorch. We will be training our data on a subset of the CIFAR-10 dataset. The methods described are derived from [this paper](https://arxiv.org/abs/1804.00792) by Shafahi, Huang, et. al. 2018."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import os, sys\n",
    "from os.path import abspath\n",
    "\n",
    "module_path = os.path.abspath(os.path.join('..'))\n",
    "if module_path not in sys.path:\n",
    "    sys.path.append(module_path)\n",
    "\n",
    "import warnings\n",
    "warnings.filterwarnings('ignore')\n",
    "\n",
    "\n",
    "import torch\n",
    "import torch.nn as nn\n",
    "\n",
    "from art import config\n",
    "from art.utils import load_dataset, get_file\n",
    "from art.estimators.classification import PyTorchClassifier\n",
    "from art.attacks.poisoning import FeatureCollisionAttack\n",
    "\n",
    "import numpy as np\n",
    "\n",
    "%matplotlib inline\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "np.random.seed(301)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(50000, 32, 32, 3)\n",
      "shape of x_train (1000, 3, 32, 32)\n",
      "shape of y_train (1000, 10)\n"
     ]
    }
   ],
   "source": [
    "(x_train, y_train), (x_test, y_test), min_, max_ = load_dataset('cifar10')\n",
    "print(x_train.shape)\n",
    "x_train = np.transpose(x_train, (0, 3, 1, 2)).astype(np.float32)\n",
    "x_test = np.transpose(x_test, (0, 3, 1, 2)).astype(np.float32)\n",
    "num_samples_train = 1000\n",
    "num_samples_test = 1000\n",
    "x_train = x_train[0:num_samples_train]\n",
    "y_train = y_train[0:num_samples_train]\n",
    "x_test = x_test[0:num_samples_test]\n",
    "y_test = y_test[0:num_samples_test]\n",
    "\n",
    "class_descr = ['airplane', 'automobile', 'bird', 'cat', 'deer', 'dog', 'frog', 'horse', 'ship', 'truck']\n",
    "print(\"shape of x_train\",x_train.shape)\n",
    "print(\"shape of y_train\",y_train.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "!wget -c https://www.dropbox.com/s/ljkld6opyruvn5u/resnet18.pt?dl=0"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Load Model to be Attacked\n",
    "\n",
    "In this example, we using a RESNET18 model pretrained on the CIFAR dataset."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Model Definition and pretrained model pulled from: \n",
    "# https://github.com/huyvnphan/PyTorch_CIFAR10\n",
    "import torch\n",
    "import torch.nn as nn\n",
    "import os\n",
    "\n",
    "__all__ = [\n",
    "    \"ResNet\",\n",
    "    \"resnet18\",\n",
    "    \"resnet34\",\n",
    "    \"resnet50\",\n",
    "]\n",
    "\n",
    "\n",
    "def conv3x3(in_planes, out_planes, stride=1, groups=1, dilation=1):\n",
    "    \"\"\"3x3 convolution with padding\"\"\"\n",
    "    return nn.Conv2d(\n",
    "        in_planes,\n",
    "        out_planes,\n",
    "        kernel_size=3,\n",
    "        stride=stride,\n",
    "        padding=dilation,\n",
    "        groups=groups,\n",
    "        bias=False,\n",
    "        dilation=dilation,\n",
    "    )\n",
    "\n",
    "\n",
    "def conv1x1(in_planes, out_planes, stride=1):\n",
    "    \"\"\"1x1 convolution\"\"\"\n",
    "    return nn.Conv2d(in_planes, out_planes, kernel_size=1, stride=stride, bias=False)\n",
    "\n",
    "\n",
    "class BasicBlock(nn.Module):\n",
    "    expansion = 1\n",
    "\n",
    "    def __init__(\n",
    "        self,\n",
    "        inplanes,\n",
    "        planes,\n",
    "        stride=1,\n",
    "        downsample=None,\n",
    "        groups=1,\n",
    "        base_width=64,\n",
    "        dilation=1,\n",
    "        norm_layer=None,\n",
    "    ):\n",
    "        super(BasicBlock, self).__init__()\n",
    "        if norm_layer is None:\n",
    "            norm_layer = nn.BatchNorm2d\n",
    "        if groups != 1 or base_width != 64:\n",
    "            raise ValueError(\"BasicBlock only supports groups=1 and base_width=64\")\n",
    "        if dilation > 1:\n",
    "            raise NotImplementedError(\"Dilation > 1 not supported in BasicBlock\")\n",
    "        # Both self.conv1 and self.downsample layers downsample the input when stride != 1\n",
    "        self.conv1 = conv3x3(inplanes, planes, stride)\n",
    "        self.bn1 = norm_layer(planes)\n",
    "        self.relu = nn.ReLU(inplace=True)\n",
    "        self.conv2 = conv3x3(planes, planes)\n",
    "        self.bn2 = norm_layer(planes)\n",
    "        self.downsample = downsample\n",
    "        self.stride = stride\n",
    "\n",
    "    def forward(self, x):\n",
    "        identity = x\n",
    "\n",
    "        out = self.conv1(x)\n",
    "        out = self.bn1(out)\n",
    "        out = self.relu(out)\n",
    "\n",
    "        out = self.conv2(out)\n",
    "        out = self.bn2(out)\n",
    "\n",
    "        if self.downsample is not None:\n",
    "            identity = self.downsample(x)\n",
    "\n",
    "        out += identity\n",
    "        out = self.relu(out)\n",
    "\n",
    "        return out\n",
    "\n",
    "\n",
    "class Bottleneck(nn.Module):\n",
    "    expansion = 4\n",
    "\n",
    "    def __init__(\n",
    "        self,\n",
    "        inplanes,\n",
    "        planes,\n",
    "        stride=1,\n",
    "        downsample=None,\n",
    "        groups=1,\n",
    "        base_width=64,\n",
    "        dilation=1,\n",
    "        norm_layer=None,\n",
    "    ):\n",
    "        super(Bottleneck, self).__init__()\n",
    "        if norm_layer is None:\n",
    "            norm_layer = nn.BatchNorm2d\n",
    "        width = int(planes * (base_width / 64.0)) * groups\n",
    "        # Both self.conv2 and self.downsample layers downsample the input when stride != 1\n",
    "        self.conv1 = conv1x1(inplanes, width)\n",
    "        self.bn1 = norm_layer(width)\n",
    "        self.conv2 = conv3x3(width, width, stride, groups, dilation)\n",
    "        self.bn2 = norm_layer(width)\n",
    "        self.conv3 = conv1x1(width, planes * self.expansion)\n",
    "        self.bn3 = norm_layer(planes * self.expansion)\n",
    "        self.relu = nn.ReLU(inplace=True)\n",
    "        self.downsample = downsample\n",
    "        self.stride = stride\n",
    "\n",
    "    def forward(self, x):\n",
    "        identity = x\n",
    "\n",
    "        out = self.conv1(x)\n",
    "        out = self.bn1(out)\n",
    "        out = self.relu(out)\n",
    "\n",
    "        out = self.conv2(out)\n",
    "        out = self.bn2(out)\n",
    "        out = self.relu(out)\n",
    "\n",
    "        out = self.conv3(out)\n",
    "        out = self.bn3(out)\n",
    "\n",
    "        if self.downsample is not None:\n",
    "            identity = self.downsample(x)\n",
    "\n",
    "        out += identity\n",
    "        out = self.relu(out)\n",
    "\n",
    "        return out\n",
    "\n",
    "\n",
    "class ResNet(nn.Module):\n",
    "    def __init__(\n",
    "        self,\n",
    "        block,\n",
    "        layers,\n",
    "        num_classes=10,\n",
    "        zero_init_residual=False,\n",
    "        groups=1,\n",
    "        width_per_group=64,\n",
    "        replace_stride_with_dilation=None,\n",
    "        norm_layer=None,\n",
    "    ):\n",
    "        super(ResNet, self).__init__()\n",
    "        if norm_layer is None:\n",
    "            norm_layer = nn.BatchNorm2d\n",
    "        self._norm_layer = norm_layer\n",
    "\n",
    "        self.inplanes = 64\n",
    "        self.dilation = 1\n",
    "        if replace_stride_with_dilation is None:\n",
    "            # each element in the tuple indicates if we should replace\n",
    "            # the 2x2 stride with a dilated convolution instead\n",
    "            replace_stride_with_dilation = [False, False, False]\n",
    "        if len(replace_stride_with_dilation) != 3:\n",
    "            raise ValueError(\n",
    "                \"replace_stride_with_dilation should be None \"\n",
    "                \"or a 3-element tuple, got {}\".format(replace_stride_with_dilation)\n",
    "            )\n",
    "        self.groups = groups\n",
    "        self.base_width = width_per_group\n",
    "\n",
    "        # CIFAR10: kernel_size 7 -> 3, stride 2 -> 1, padding 3->1\n",
    "        self.conv1 = nn.Conv2d(\n",
    "            3, self.inplanes, kernel_size=3, stride=1, padding=1, bias=False\n",
    "        )\n",
    "        # END\n",
    "\n",
    "        self.bn1 = norm_layer(self.inplanes)\n",
    "        self.relu = nn.ReLU(inplace=True)\n",
    "        self.maxpool = nn.MaxPool2d(kernel_size=3, stride=2, padding=1)\n",
    "        self.layer1 = self._make_layer(block, 64, layers[0])\n",
    "        self.layer2 = self._make_layer(\n",
    "            block, 128, layers[1], stride=2, dilate=replace_stride_with_dilation[0]\n",
    "        )\n",
    "        self.layer3 = self._make_layer(\n",
    "            block, 256, layers[2], stride=2, dilate=replace_stride_with_dilation[1]\n",
    "        )\n",
    "        self.layer4 = self._make_layer(\n",
    "            block, 512, layers[3], stride=2, dilate=replace_stride_with_dilation[2]\n",
    "        )\n",
    "        self.avgpool = nn.AdaptiveAvgPool2d((1, 1))\n",
    "        self.fc = nn.Linear(512 * block.expansion, num_classes)\n",
    "\n",
    "        for m in self.modules():\n",
    "            if isinstance(m, nn.Conv2d):\n",
    "                nn.init.kaiming_normal_(m.weight, mode=\"fan_out\", nonlinearity=\"relu\")\n",
    "            elif isinstance(m, (nn.BatchNorm2d, nn.GroupNorm)):\n",
    "                nn.init.constant_(m.weight, 1)\n",
    "                nn.init.constant_(m.bias, 0)\n",
    "\n",
    "        # Zero-initialize the last BN in each residual branch,\n",
    "        # so that the residual branch starts with zeros, and each residual block behaves like an identity.\n",
    "        # This improves the model by 0.2~0.3% according to https://arxiv.org/abs/1706.02677\n",
    "        if zero_init_residual:\n",
    "            for m in self.modules():\n",
    "                if isinstance(m, Bottleneck):\n",
    "                    nn.init.constant_(m.bn3.weight, 0)\n",
    "                elif isinstance(m, BasicBlock):\n",
    "                    nn.init.constant_(m.bn2.weight, 0)\n",
    "\n",
    "    def _make_layer(self, block, planes, blocks, stride=1, dilate=False):\n",
    "        norm_layer = self._norm_layer\n",
    "        downsample = None\n",
    "        previous_dilation = self.dilation\n",
    "        if dilate:\n",
    "            self.dilation *= stride\n",
    "            stride = 1\n",
    "        if stride != 1 or self.inplanes != planes * block.expansion:\n",
    "            downsample = nn.Sequential(\n",
    "                conv1x1(self.inplanes, planes * block.expansion, stride),\n",
    "                norm_layer(planes * block.expansion),\n",
    "            )\n",
    "\n",
    "        layers = []\n",
    "        layers.append(\n",
    "            block(\n",
    "                self.inplanes,\n",
    "                planes,\n",
    "                stride,\n",
    "                downsample,\n",
    "                self.groups,\n",
    "                self.base_width,\n",
    "                previous_dilation,\n",
    "                norm_layer,\n",
    "            )\n",
    "        )\n",
    "        self.inplanes = planes * block.expansion\n",
    "        for _ in range(1, blocks):\n",
    "            layers.append(\n",
    "                block(\n",
    "                    self.inplanes,\n",
    "                    planes,\n",
    "                    groups=self.groups,\n",
    "                    base_width=self.base_width,\n",
    "                    dilation=self.dilation,\n",
    "                    norm_layer=norm_layer,\n",
    "                )\n",
    "            )\n",
    "\n",
    "        return nn.Sequential(*layers)\n",
    "\n",
    "    def forward(self, x):\n",
    "        x = self.conv1(x)\n",
    "        x = self.bn1(x)\n",
    "        x = self.relu(x)\n",
    "        x = self.maxpool(x)\n",
    "\n",
    "        x = self.layer1(x)\n",
    "        x = self.layer2(x)\n",
    "        x = self.layer3(x)\n",
    "        x = self.layer4(x)\n",
    "\n",
    "        x = self.avgpool(x)\n",
    "        x = x.reshape(x.size(0), -1)\n",
    "        x = self.fc(x)\n",
    "\n",
    "        return x\n",
    "\n",
    "\n",
    "def _resnet(arch, block, layers, pretrained, progress, device, **kwargs):\n",
    "    model = ResNet(block, layers, **kwargs)\n",
    "    if pretrained:\n",
    "        # Download the model state_dict from the link: and run your code\n",
    "        state_dict = torch.load(\n",
    "            'resnet18.pt?dl=0', map_location=device\n",
    "        )\n",
    "        model.load_state_dict(state_dict)\n",
    "    return model\n",
    "\n",
    "\n",
    "def resnet18(pretrained=False, progress=True, device=\"cpu\", **kwargs):\n",
    "    \"\"\"Constructs a ResNet-18 model.\n",
    "    Args:\n",
    "        pretrained (bool): If True, returns a model pre-trained on ImageNet\n",
    "        progress (bool): If True, displays a progress bar of the download to stderr\n",
    "    \"\"\"\n",
    "    return _resnet(\n",
    "        \"resnet18\", BasicBlock, [2, 2, 2, 2], pretrained, progress, device, **kwargs\n",
    "    )\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "import torch.optim as optim\n",
    "# Pretrained model\n",
    "classifier_model = resnet18(pretrained=True)\n",
    "classifier_model.eval() # for evaluation\n",
    "criterion =  nn.CrossEntropyLoss()\n",
    "optimizer = optim.Adam(classifier_model.parameters(), lr=0.0001)\n",
    "classifier = PyTorchClassifier(clip_values=(min_, max_), model=classifier_model, \n",
    "                             preprocessing=((0.4914, 0.4822, 0.4465),(0.2471, 0.2435, 0.2616)),nb_classes=10,input_shape=(3,32,32),loss=criterion,\n",
    "                             optimizer=optimizer)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Choose Target Image from Test Set"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "shape of target_instance (1, 3, 32, 32)\n",
      "true_class: bird\n",
      "predicted_class: bird\n",
      "avgpool\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "target_class = \"bird\" # one of ['airplane', 'automobile', 'bird', 'cat', 'deer', 'dog', 'frog', 'horse', 'ship', 'truck']\n",
    "target_label = np.zeros(len(class_descr))\n",
    "target_label[class_descr.index(target_class)] = 1\n",
    "target_instance = np.expand_dims(x_test[np.argmax(y_test, axis=1) == class_descr.index(target_class)][3], axis=0)\n",
    "img_plot = np.transpose(target_instance[0],(1,2,0))\n",
    "fig = plt.imshow(img_plot)\n",
    "print(\"shape of target_instance\",target_instance.shape)\n",
    "print('true_class: ' + target_class)\n",
    "print('predicted_class: ' + class_descr[np.argmax(classifier.predict(target_instance), axis=1)[0]])\n",
    "\n",
    "feature_layer = classifier.layer_names[-2]\n",
    "print(feature_layer)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Poison Training Images to Misclassify Test\n",
    "\n",
    "The attacker wants to make it such that whenever a prediction is made on this particular cat the output will be a horse."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "New test data to be poisoned (10 images):\n",
      "Correctly classified: 9\n",
      "Incorrectly classified: 1\n"
     ]
    }
   ],
   "source": [
    "base_class = \"frog\" # one of ['airplane', 'automobile', 'bird', 'cat', 'deer', 'dog', 'frog', 'horse', 'ship', 'truck']\n",
    "base_idxs = np.argmax(y_test, axis=1) == class_descr.index(base_class)\n",
    "base_instances = np.copy(x_test[base_idxs][:10])\n",
    "base_labels = y_test[base_idxs][:10]\n",
    "x_test_pred = np.argmax(classifier.predict(base_instances), axis=1)\n",
    "nb_correct_pred = np.sum(x_test_pred == np.argmax(base_labels, axis=1))\n",
    "\n",
    "print(\"New test data to be poisoned (10 images):\")\n",
    "print(\"Correctly classified: {}\".format(nb_correct_pred))\n",
    "print(\"Incorrectly classified: {}\".format(10-nb_correct_pred))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 720x720 with 9 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.figure(figsize=(10,10))\n",
    "for i in range(0, 9):\n",
    "    pred_label, true_label = class_descr[x_test_pred[i]], class_descr[np.argmax(base_labels[i])]\n",
    "    plt.subplot(330 + 1 + i)\n",
    "    fig=plt.imshow(np.transpose(base_instances[i],(1,2,0)))\n",
    "    fig.axes.get_xaxis().set_visible(False)\n",
    "    fig.axes.get_yaxis().set_visible(False)\n",
    "    fig.axes.text(0.5, -0.1, pred_label + \" (\" + true_label + \")\", fontsize=12, transform=fig.axes.transAxes, \n",
    "                  horizontalalignment='center')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The captions on the images can be read: `predicted label (true label)`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Creating Poison Frogs"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "4dccde13287d43e080eee5249bc8bba4",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Feature collision:   0%|          | 0/10 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "8b4c7d9f21224c21a06a6e1bda722b30",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Feature collision:   0%|          | 0/10 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "dc9d7bbbdc2242e89d52f0fdc124530c",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Feature collision:   0%|          | 0/10 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "2db0bb76ebd04ed4ba8517d6d4a37ae4",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Feature collision:   0%|          | 0/10 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "0aeea5caf93b401ea2c829c57f27fce7",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Feature collision:   0%|          | 0/10 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "8d37e32993fc49e3aea0b106af8184c7",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Feature collision:   0%|          | 0/10 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "276b96fb1e5c43eb8d9506b342ef78fd",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Feature collision:   0%|          | 0/10 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "3375721a2f9149ba80506b2b09366fd9",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Feature collision:   0%|          | 0/10 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "8dd24ede3fcd4bc49b3798d1e3970eb1",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Feature collision:   0%|          | 0/10 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "a2b042a6b28d4c0fb881854fd080e18f",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Feature collision:   0%|          | 0/10 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "attack = FeatureCollisionAttack(classifier, \n",
    "                                target_instance, \n",
    "                                feature_layer, \n",
    "                                max_iter=10, \n",
    "                                similarity_coeff=256,\n",
    "                                watermark=0.3,\n",
    "                                learning_rate=1)\n",
    "poison, poison_labels = attack.poison(base_instances)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 720x720 with 9 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "poison_pred = np.argmax(classifier.predict(poison), axis=1)\n",
    "plt.figure(figsize=(10,10))\n",
    "for i in range(0, 9):\n",
    "    pred_label, true_label = class_descr[poison_pred[i]], class_descr[np.argmax(poison_labels[i])]\n",
    "    plt.subplot(330 + 1 + i)\n",
    "    fig=plt.imshow(np.transpose(poison[i],(1,2,0)))\n",
    "    fig.axes.get_xaxis().set_visible(False)\n",
    "    fig.axes.get_yaxis().set_visible(False)\n",
    "    fig.axes.text(0.5, -0.1, pred_label + \" (\" + true_label + \")\", fontsize=12, transform=fig.axes.transAxes, \n",
    "                  horizontalalignment='center')\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Notice how the network classifies most of theses poison examples as frogs, and it's not incorrect to do so. The examples look mostly froggy. A slight watermark of the target instance is also added to push the poisons closer to the target class in feature space."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Training with Poison Images"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "import torch.optim as optim\n",
    "adv_train = np.vstack([x_train, poison])\n",
    "adv_labels = np.vstack([y_train, poison_labels])\n",
    "classifier_model.train()\n",
    "classifier.fit(adv_train, adv_labels, nb_epochs=20, batch_size=4)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Fooled Network Misclassifies Bird"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "true_class: bird\n",
      "predicted_class: frog\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "fig = plt.imshow(np.transpose(target_instance[0],(1,2,0)))\n",
    "\n",
    "print('true_class: ' + target_class)\n",
    "print('predicted_class: ' + class_descr[np.argmax(classifier.predict(target_instance), axis=1)[0]])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "These attacks allow adversaries who can poison your dataset the ability to mislabel any particular target instance of their choosing without manipulating labels."
   ]
  }
 ],
 "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.9.9"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}