generate_adversarial_examples.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import foolbox\n",
    "import torch\n",
    "import torchvision\n",
    "import numpy as np\n",
    "from torchvision import datasets, transforms\n",
    "from sklearn.model_selection import train_test_split\n",
    "import torch.nn.functional as F\n",
    "from torch.utils.data.sampler import SubsetRandomSampler\n",
    "from torch.autograd import Variable\n",
    "from torch.utils.data import DataLoader\n",
    "import pickle\n",
    "import sys\n",
    "import os\n",
    "\n",
    "from model import CNN\n",
    "from torchsummary import summary\n",
    "import copy"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Number of classes in the dataset\n",
    "num_classes = 10"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### load data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "transform_test = transforms.Compose([\n",
    "    transforms.ToTensor(),\n",
    "])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "classes = ('plane', 'car', 'bird', 'cat', 'deer', \n",
    "           'dog', 'frog', 'horse', 'ship', 'truck')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "test_dataset = torchvision.datasets.CIFAR10(\n",
    "    root='./data', train=False, download=True, transform=transform_test)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "model_folder = os.path.abspath('./adversarial')\n",
    "if not os.path.exists(model_folder):\n",
    "    os.mkdir(model_folder)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### load classification model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Send the model to GPU\n",
    "model = CNN()\n",
    "\n",
    "model.load_state_dict(torch.load('./checkpoints/cifar10.pth'))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "device = torch.device(\"cuda:0\" if torch.cuda.is_available() else \"cpu\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "model = model.to(device)\n",
    "\n",
    "model.eval()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### load adversarial generation tool - Foolbox"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "fmodel = foolbox.models.PyTorchModel(model, bounds = (0, 1), num_classes = num_classes, device = device)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### FGSM"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "fgsm_adv = []\n",
    "fgsm_index = []\n",
    "fgsm_label = []"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "for idx in range(len(test_dataset)):\n",
    "    img, label = test_dataset.__getitem__(idx)\n",
    "    \n",
    "    image = img.detach().numpy()\n",
    "    \n",
    "    # apply attack on source image\n",
    "    attack = foolbox.attacks.FGSM(fmodel)\n",
    "    adversarial = attack(image, label, max_epsilon = 0.2)\n",
    "    \n",
    "    if adversarial is None:\n",
    "        continue\n",
    "    \n",
    "    #adversarial = normalize(adversarial)\n",
    "    \n",
    "    fgsm_adv.append(torch.from_numpy(adversarial))\n",
    "    fgsm_index.append(idx)\n",
    "    fgsm_label.append(label)\n",
    "    \n",
    "    print('image {} save'.format(idx))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print('length of adversarial images : {}'.format(len(fgsm_adv)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "with open ('./adversarial/FGSM_indexs.pickle', 'wb') as fp:\n",
    "    pickle.dump(fgsm_index, fp)\n",
    "\n",
    "with open ('./adversarial/FGSM_adv_images.pickle', 'wb') as fp:\n",
    "    pickle.dump(fgsm_adv, fp)\n",
    "    \n",
    "with open ('./adversarial/FGSM_adv_label.pickle', 'wb') as fp:\n",
    "    pickle.dump(fgsm_label, fp)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### DeepFool"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "DF_adv = []\n",
    "DF_index = []\n",
    "DF_label = []"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for idx in range(len(test_dataset)):\n",
    "    img, label = test_dataset.__getitem__(idx)\n",
    "    \n",
    "    image = img.detach().numpy()\n",
    "    \n",
    "    # apply attack on source image\n",
    "    attack = foolbox.attacks.DeepFoolLinfinityAttack(fmodel)\n",
    "    adversarial = attack(image, label, steps=50)\n",
    "    \n",
    "    if adversarial is None:\n",
    "        continue\n",
    "    \n",
    "    #adversarial = normalize(adversarial)\n",
    "    \n",
    "    DF_adv.append(torch.from_numpy(adversarial))\n",
    "    DF_index.append(idx)\n",
    "    DF_label.append(label)\n",
    "    \n",
    "    print('image {} save'.format(idx))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print('length of adversarial images : {}'.format(len(DF_adv)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "with open ('./adversarial/DF_indexs.pickle', 'wb') as fp:\n",
    "    pickle.dump(DF_index, fp)\n",
    "\n",
    "with open ('./adversarial/DF_adv_images.pickle', 'wb') as fp:\n",
    "    pickle.dump(DF_adv, fp)\n",
    "    \n",
    "with open ('./adversarial/DF_adv_label.pickle', 'wb') as fp:\n",
    "    pickle.dump(DF_label, fp)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### SaliencyMap"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "SM_adv = []\n",
    "SM_index = []\n",
    "SM_label = []"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for idx in range(len(test_dataset)):\n",
    "    img, label = test_dataset.__getitem__(idx)\n",
    "    \n",
    "    image = img.detach().numpy()\n",
    "\n",
    "    # apply attack on source image\n",
    "    attack = foolbox.attacks.SaliencyMapAttack(fmodel)\n",
    "    adversarial = attack(image, label)\n",
    "    \n",
    "    if adversarial is None:\n",
    "        continue\n",
    "    \n",
    "    #adversarial = normalize(adversarial)\n",
    "    \n",
    "    SM_adv.append(torch.from_numpy(adversarial))\n",
    "    SM_index.append(idx)\n",
    "    SM_label.append(label)\n",
    "    \n",
    "    print('image {} save'.format(idx))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print('length of adversarial images : {}'.format(len(SM_adv)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "with open ('./adversarial/SM_indexs.pickle', 'wb') as fp:\n",
    "    pickle.dump(SM_index, fp)\n",
    "\n",
    "with open ('./adversarial/SM_adv_images.pickle', 'wb') as fp:\n",
    "    pickle.dump(SM_adv, fp)\n",
    "    \n",
    "with open ('./adversarial/SM_adv_label.pickle', 'wb') as fp:\n",
    "    pickle.dump(SM_label, fp)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "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.5.2"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}