Logistic_Regression_Torch_Attack.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "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.8.5"
    },
    "colab": {
      "name": "Logistic Regression Torch Attack v2.ipynb",
      "provenance": [],
      "toc_visible": true
    },
    "accelerator": "GPU"
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "houzvCG5ey9a"
      },
      "source": [
        "# References\n",
        "\n",
        "[Logistic Regression on MNIST](https://towardsdatascience.com/logistic-regression-on-mnist-with-pytorch-b048327f8d19)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "1g9rCTz_fvX_"
      },
      "source": [
        "# (1) Load the required packages\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "PqGbPjVie3XP",
        "outputId": "b5e3f3f5-cc4c-4dc6-854f-fe977cc316ff"
      },
      "source": [
        "!pip install foolbox"
      ],
      "execution_count": 14,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Requirement already satisfied: foolbox in /usr/local/lib/python3.7/dist-packages (3.3.1)\n",
            "Requirement already satisfied: numpy in /usr/local/lib/python3.7/dist-packages (from foolbox) (1.19.5)\n",
            "Requirement already satisfied: typing-extensions>=3.7.4.1 in /usr/local/lib/python3.7/dist-packages (from foolbox) (3.7.4.3)\n",
            "Requirement already satisfied: eagerpy==0.29.0 in /usr/local/lib/python3.7/dist-packages (from foolbox) (0.29.0)\n",
            "Requirement already satisfied: setuptools in /usr/local/lib/python3.7/dist-packages (from foolbox) (54.2.0)\n",
            "Requirement already satisfied: scipy in /usr/local/lib/python3.7/dist-packages (from foolbox) (1.4.1)\n",
            "Requirement already satisfied: GitPython>=3.0.7 in /usr/local/lib/python3.7/dist-packages (from foolbox) (3.1.14)\n",
            "Requirement already satisfied: requests>=2.24.0 in /usr/local/lib/python3.7/dist-packages (from foolbox) (2.25.1)\n",
            "Requirement already satisfied: gitdb<5,>=4.0.1 in /usr/local/lib/python3.7/dist-packages (from GitPython>=3.0.7->foolbox) (4.0.7)\n",
            "Requirement already satisfied: chardet<5,>=3.0.2 in /usr/local/lib/python3.7/dist-packages (from requests>=2.24.0->foolbox) (3.0.4)\n",
            "Requirement already satisfied: certifi>=2017.4.17 in /usr/local/lib/python3.7/dist-packages (from requests>=2.24.0->foolbox) (2020.12.5)\n",
            "Requirement already satisfied: idna<3,>=2.5 in /usr/local/lib/python3.7/dist-packages (from requests>=2.24.0->foolbox) (2.10)\n",
            "Requirement already satisfied: urllib3<1.27,>=1.21.1 in /usr/local/lib/python3.7/dist-packages (from requests>=2.24.0->foolbox) (1.24.3)\n",
            "Requirement already satisfied: smmap<5,>=3.0.1 in /usr/local/lib/python3.7/dist-packages (from gitdb<5,>=4.0.1->GitPython>=3.0.7->foolbox) (4.0.0)\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "uNNxA_M02f3d"
      },
      "source": [
        "import torch\n",
        "from torch.utils.data import DataLoader\n",
        "from torchvision.datasets import MNIST\n",
        "import torchvision.transforms as transforms\n",
        "\n",
        "import time\n",
        "import torch.nn as nn\n",
        "import numpy as np\n",
        "from foolbox import PyTorchModel, accuracy, samples, plot, criteria, distances\n",
        "import foolbox.attacks as fa\n",
        "import torchvision.models as models\n",
        "import eagerpy as ep\n",
        "import matplotlib.pyplot as plt\n",
        "import foolbox as fb"
      ],
      "execution_count": 15,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ieLY4ozT2es_"
      },
      "source": [
        "device = 'cuda' if torch.cuda.is_available() else 'cpu'"
      ],
      "execution_count": 16,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "TWz965j3e_JV"
      },
      "source": [
        "# (2) Setup the Logistic Regression model"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "TmxyTFQzfE0n"
      },
      "source": [
        "class LogisticRegression(torch.nn.Module):\n",
        "    def __init__(self, input_size, num_classes):\n",
        "        super(LogisticRegression, self).__init__()\n",
        "        self.linear = torch.nn.Linear(input_size, num_classes)\n",
        "        \n",
        "    def forward(self, x):\n",
        "        x = x.reshape(x.shape[0], -1)\n",
        "        out = self.linear(x)\n",
        "        return out"
      ],
      "execution_count": 17,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "At8AHOppfHSl"
      },
      "source": [
        "# (3) Train the model"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "s1pre_PffPMs"
      },
      "source": [
        "## (3a) Prepare the MNIST dataset"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "KZP-NrMk2etA"
      },
      "source": [
        "batch_size = 100\n",
        "\n",
        "train_dataset = MNIST(root='.',\n",
        "                               train=True,\n",
        "                               transform=transforms.ToTensor(),\n",
        "                               download=True,\n",
        "                              )\n",
        "test_dataset = MNIST(root='.',\n",
        "                              train=False,\n",
        "                              transform=transforms.ToTensor(),\n",
        "                              download=True,\n",
        "                              )\n",
        "\n",
        "train_loader = DataLoader(dataset=train_dataset,\n",
        "                          batch_size=batch_size,\n",
        "                          shuffle=True,\n",
        "                         )\n",
        "test_loader = DataLoader(dataset=test_dataset,\n",
        "                         batch_size=batch_size,\n",
        "                         shuffle=False,\n",
        "                        )\n"
      ],
      "execution_count": 18,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Dn_XjxsZfN6n"
      },
      "source": [
        "## (3b) Train the model"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "8-59AK3J2etA"
      },
      "source": [
        "input_size = 784\n",
        "num_classes = 10\n",
        "num_epochs = 25\n",
        "lr = 0.001"
      ],
      "execution_count": 19,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "JNlLhrui2etB"
      },
      "source": [
        "logReg_model = LogisticRegression(input_size, num_classes).to(device)\n",
        "\n",
        "criterion = torch.nn.CrossEntropyLoss()\n",
        "\n",
        "optimizer = torch.optim.SGD(logReg_model.parameters(), lr=lr)"
      ],
      "execution_count": 20,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "oe56KBpy2etB",
        "outputId": "630d92e9-117a-4569-df7e-37f3c9ec6b09"
      },
      "source": [
        "itr = 0\n",
        "report_req = 100\n",
        "for epoch in range(num_epochs):\n",
        "    for (images, labels) in train_loader:\n",
        "        images = images.reshape(-1, input_size).to(device)\n",
        "        labels = labels.to(device)\n",
        "        \n",
        "        optimizer.zero_grad()\n",
        "        outputs = logReg_model(images)\n",
        "        loss = criterion(outputs, labels)\n",
        "        loss.backward()\n",
        "        optimizer.step()\n",
        "        \n",
        "        if itr % report_req == 0:\n",
        "            print(f'Epoch: {epoch+1}; Step: {itr+1}; Loss: {loss:.5f}')\n",
        "            \n",
        "        itr += 1"
      ],
      "execution_count": 21,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Epoch: 1; Step: 1; Loss: 2.27732\n",
            "Epoch: 1; Step: 101; Loss: 2.20088\n",
            "Epoch: 1; Step: 201; Loss: 2.06650\n",
            "Epoch: 1; Step: 301; Loss: 2.00924\n",
            "Epoch: 1; Step: 401; Loss: 1.89472\n",
            "Epoch: 1; Step: 501; Loss: 1.88048\n",
            "Epoch: 2; Step: 601; Loss: 1.78726\n",
            "Epoch: 2; Step: 701; Loss: 1.71464\n",
            "Epoch: 2; Step: 801; Loss: 1.63312\n",
            "Epoch: 2; Step: 901; Loss: 1.58551\n",
            "Epoch: 2; Step: 1001; Loss: 1.61335\n",
            "Epoch: 2; Step: 1101; Loss: 1.43171\n",
            "Epoch: 3; Step: 1201; Loss: 1.37884\n",
            "Epoch: 3; Step: 1301; Loss: 1.40031\n",
            "Epoch: 3; Step: 1401; Loss: 1.39878\n",
            "Epoch: 3; Step: 1501; Loss: 1.24374\n",
            "Epoch: 3; Step: 1601; Loss: 1.39727\n",
            "Epoch: 3; Step: 1701; Loss: 1.22967\n",
            "Epoch: 4; Step: 1801; Loss: 1.26823\n",
            "Epoch: 4; Step: 1901; Loss: 1.25857\n",
            "Epoch: 4; Step: 2001; Loss: 1.16621\n",
            "Epoch: 4; Step: 2101; Loss: 1.17693\n",
            "Epoch: 4; Step: 2201; Loss: 1.15802\n",
            "Epoch: 4; Step: 2301; Loss: 1.13293\n",
            "Epoch: 5; Step: 2401; Loss: 1.12106\n",
            "Epoch: 5; Step: 2501; Loss: 1.04897\n",
            "Epoch: 5; Step: 2601; Loss: 1.04692\n",
            "Epoch: 5; Step: 2701; Loss: 1.09648\n",
            "Epoch: 5; Step: 2801; Loss: 1.02216\n",
            "Epoch: 5; Step: 2901; Loss: 0.94176\n",
            "Epoch: 6; Step: 3001; Loss: 0.96042\n",
            "Epoch: 6; Step: 3101; Loss: 0.96698\n",
            "Epoch: 6; Step: 3201; Loss: 1.00655\n",
            "Epoch: 6; Step: 3301; Loss: 0.94535\n",
            "Epoch: 6; Step: 3401; Loss: 0.95700\n",
            "Epoch: 6; Step: 3501; Loss: 0.93945\n",
            "Epoch: 7; Step: 3601; Loss: 0.87359\n",
            "Epoch: 7; Step: 3701; Loss: 0.78733\n",
            "Epoch: 7; Step: 3801; Loss: 0.85465\n",
            "Epoch: 7; Step: 3901; Loss: 0.95002\n",
            "Epoch: 7; Step: 4001; Loss: 0.95697\n",
            "Epoch: 7; Step: 4101; Loss: 0.78578\n",
            "Epoch: 8; Step: 4201; Loss: 0.79457\n",
            "Epoch: 8; Step: 4301; Loss: 0.89323\n",
            "Epoch: 8; Step: 4401; Loss: 0.80052\n",
            "Epoch: 8; Step: 4501; Loss: 0.89737\n",
            "Epoch: 8; Step: 4601; Loss: 0.85653\n",
            "Epoch: 8; Step: 4701; Loss: 0.77377\n",
            "Epoch: 9; Step: 4801; Loss: 0.86323\n",
            "Epoch: 9; Step: 4901; Loss: 0.81546\n",
            "Epoch: 9; Step: 5001; Loss: 0.76492\n",
            "Epoch: 9; Step: 5101; Loss: 0.80786\n",
            "Epoch: 9; Step: 5201; Loss: 0.82125\n",
            "Epoch: 9; Step: 5301; Loss: 0.68800\n",
            "Epoch: 10; Step: 5401; Loss: 0.83161\n",
            "Epoch: 10; Step: 5501; Loss: 0.74616\n",
            "Epoch: 10; Step: 5601; Loss: 0.78479\n",
            "Epoch: 10; Step: 5701; Loss: 0.66580\n",
            "Epoch: 10; Step: 5801; Loss: 0.82571\n",
            "Epoch: 10; Step: 5901; Loss: 0.70808\n",
            "Epoch: 11; Step: 6001; Loss: 0.84824\n",
            "Epoch: 11; Step: 6101; Loss: 0.87856\n",
            "Epoch: 11; Step: 6201; Loss: 0.70099\n",
            "Epoch: 11; Step: 6301; Loss: 0.71182\n",
            "Epoch: 11; Step: 6401; Loss: 0.60170\n",
            "Epoch: 11; Step: 6501; Loss: 0.76676\n",
            "Epoch: 12; Step: 6601; Loss: 0.77089\n",
            "Epoch: 12; Step: 6701; Loss: 0.72905\n",
            "Epoch: 12; Step: 6801; Loss: 0.73230\n",
            "Epoch: 12; Step: 6901; Loss: 0.86111\n",
            "Epoch: 12; Step: 7001; Loss: 0.68326\n",
            "Epoch: 12; Step: 7101; Loss: 0.71247\n",
            "Epoch: 13; Step: 7201; Loss: 0.63402\n",
            "Epoch: 13; Step: 7301; Loss: 0.72312\n",
            "Epoch: 13; Step: 7401; Loss: 0.71274\n",
            "Epoch: 13; Step: 7501; Loss: 0.64311\n",
            "Epoch: 13; Step: 7601; Loss: 0.66282\n",
            "Epoch: 13; Step: 7701; Loss: 0.54832\n",
            "Epoch: 14; Step: 7801; Loss: 0.52175\n",
            "Epoch: 14; Step: 7901; Loss: 0.61382\n",
            "Epoch: 14; Step: 8001; Loss: 0.63922\n",
            "Epoch: 14; Step: 8101; Loss: 0.64420\n",
            "Epoch: 14; Step: 8201; Loss: 0.66844\n",
            "Epoch: 14; Step: 8301; Loss: 0.60991\n",
            "Epoch: 15; Step: 8401; Loss: 0.67025\n",
            "Epoch: 15; Step: 8501; Loss: 0.59706\n",
            "Epoch: 15; Step: 8601; Loss: 0.66663\n",
            "Epoch: 15; Step: 8701; Loss: 0.76750\n",
            "Epoch: 15; Step: 8801; Loss: 0.77985\n",
            "Epoch: 15; Step: 8901; Loss: 0.60321\n",
            "Epoch: 16; Step: 9001; Loss: 0.50736\n",
            "Epoch: 16; Step: 9101; Loss: 0.59850\n",
            "Epoch: 16; Step: 9201; Loss: 0.61641\n",
            "Epoch: 16; Step: 9301; Loss: 0.73581\n",
            "Epoch: 16; Step: 9401; Loss: 0.63195\n",
            "Epoch: 16; Step: 9501; Loss: 0.75127\n",
            "Epoch: 17; Step: 9601; Loss: 0.67253\n",
            "Epoch: 17; Step: 9701; Loss: 0.67094\n",
            "Epoch: 17; Step: 9801; Loss: 0.53364\n",
            "Epoch: 17; Step: 9901; Loss: 0.56863\n",
            "Epoch: 17; Step: 10001; Loss: 0.55383\n",
            "Epoch: 17; Step: 10101; Loss: 0.51109\n",
            "Epoch: 18; Step: 10201; Loss: 0.64710\n",
            "Epoch: 18; Step: 10301; Loss: 0.52765\n",
            "Epoch: 18; Step: 10401; Loss: 0.61291\n",
            "Epoch: 18; Step: 10501; Loss: 0.63318\n",
            "Epoch: 18; Step: 10601; Loss: 0.45364\n",
            "Epoch: 18; Step: 10701; Loss: 0.68038\n",
            "Epoch: 19; Step: 10801; Loss: 0.51940\n",
            "Epoch: 19; Step: 10901; Loss: 0.69627\n",
            "Epoch: 19; Step: 11001; Loss: 0.51414\n",
            "Epoch: 19; Step: 11101; Loss: 0.65156\n",
            "Epoch: 19; Step: 11201; Loss: 0.63497\n",
            "Epoch: 19; Step: 11301; Loss: 0.51275\n",
            "Epoch: 20; Step: 11401; Loss: 0.53092\n",
            "Epoch: 20; Step: 11501; Loss: 0.52178\n",
            "Epoch: 20; Step: 11601; Loss: 0.54157\n",
            "Epoch: 20; Step: 11701; Loss: 0.42654\n",
            "Epoch: 20; Step: 11801; Loss: 0.53141\n",
            "Epoch: 20; Step: 11901; Loss: 0.66919\n",
            "Epoch: 21; Step: 12001; Loss: 0.62865\n",
            "Epoch: 21; Step: 12101; Loss: 0.54091\n",
            "Epoch: 21; Step: 12201; Loss: 0.58677\n",
            "Epoch: 21; Step: 12301; Loss: 0.57848\n",
            "Epoch: 21; Step: 12401; Loss: 0.52788\n",
            "Epoch: 21; Step: 12501; Loss: 0.52211\n",
            "Epoch: 22; Step: 12601; Loss: 0.55733\n",
            "Epoch: 22; Step: 12701; Loss: 0.58777\n",
            "Epoch: 22; Step: 12801; Loss: 0.54285\n",
            "Epoch: 22; Step: 12901; Loss: 0.53378\n",
            "Epoch: 22; Step: 13001; Loss: 0.51834\n",
            "Epoch: 22; Step: 13101; Loss: 0.58991\n",
            "Epoch: 23; Step: 13201; Loss: 0.33951\n",
            "Epoch: 23; Step: 13301; Loss: 0.51098\n",
            "Epoch: 23; Step: 13401; Loss: 0.67966\n",
            "Epoch: 23; Step: 13501; Loss: 0.53140\n",
            "Epoch: 23; Step: 13601; Loss: 0.54676\n",
            "Epoch: 23; Step: 13701; Loss: 0.64956\n",
            "Epoch: 24; Step: 13801; Loss: 0.50076\n",
            "Epoch: 24; Step: 13901; Loss: 0.63271\n",
            "Epoch: 24; Step: 14001; Loss: 0.46311\n",
            "Epoch: 24; Step: 14101; Loss: 0.42797\n",
            "Epoch: 24; Step: 14201; Loss: 0.56550\n",
            "Epoch: 24; Step: 14301; Loss: 0.58999\n",
            "Epoch: 25; Step: 14401; Loss: 0.52839\n",
            "Epoch: 25; Step: 14501; Loss: 0.48323\n",
            "Epoch: 25; Step: 14601; Loss: 0.52774\n",
            "Epoch: 25; Step: 14701; Loss: 0.45640\n",
            "Epoch: 25; Step: 14801; Loss: 0.45640\n",
            "Epoch: 25; Step: 14901; Loss: 0.45557\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "U8CgPetyfeXI"
      },
      "source": [
        "## (3c) Test the model"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "zC8bgvm12etC",
        "outputId": "823664d9-b42c-4c30-adc0-f499c3190b46"
      },
      "source": [
        "correct = 0\n",
        "total = 0\n",
        "for (images, labels) in test_loader:\n",
        "    images = images.reshape(-1, input_size).to(device)\n",
        "    labels = labels.to(device)\n",
        "\n",
        "    outputs = logReg_model(images)\n",
        "\n",
        "    predicted = torch.argmax(outputs, 1)\n",
        "    \n",
        "    correct += torch.sum(predicted==labels)\n",
        "    total += labels.shape[0]\n",
        "\n",
        "acc = correct / total * 100\n",
        "print(f'Final accuracy is: {acc:.2f}%')"
      ],
      "execution_count": 22,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Final accuracy is: 87.99%\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ReXZ6QEPfkZu"
      },
      "source": [
        "# (4) Perform the attack"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ZDJp_cG6gAgU"
      },
      "source": [
        "## (4a) Helper functions"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "_ROhYoTI2etC"
      },
      "source": [
        "def plot_images(images):\n",
        "    fig, axs = plt.subplots(1, len(images), figsize=(24, 24))\n",
        "\n",
        "    for i, ax in enumerate(axs.flat):\n",
        "        image = images[i]\n",
        "        image = np.squeeze(image, axis=0)\n",
        "        ax.matshow(image)\n",
        "        ax.axis('off')\n",
        "        ax.set_title(f'Image {i}')\n",
        "\n",
        "    fig.show()"
      ],
      "execution_count": 23,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "QIM8SRdbgFg8"
      },
      "source": [
        "## (4b) Setup the PyTorchModel and do a simple test"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 176
        },
        "id": "wRNzwVtS2etC",
        "outputId": "355b8fa3-227d-421c-bdb8-18cdedec9e16"
      },
      "source": [
        "model = logReg_model.eval()\n",
        "fmodel = PyTorchModel(model, bounds=(0, 1))\n",
        "batch_size = 20\n",
        "images, labels = samples(fmodel, dataset=\"mnist\", batchsize=20)\n",
        "\n",
        "clean_acc = accuracy(fmodel, images, labels)\n",
        "predictions = fmodel(images).argmax(-1)\n",
        "plot_images(images.cpu().numpy())\n",
        "print(\"labels     : \", [l for l in labels.cpu().numpy()])\n",
        "print(\"predictions: \", [l for l in predictions.cpu().numpy()])\n",
        "\n",
        "print(f\"clean accuracy:  {clean_acc * 100:.1f} %\")\n",
        "print(\"\")"
      ],
      "execution_count": 24,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "labels     :  [7, 2, 1, 0, 4, 1, 4, 9, 5, 9, 0, 6, 9, 0, 1, 5, 9, 7, 3, 4]\n",
            "predictions:  [7, 2, 1, 0, 4, 1, 4, 9, 6, 9, 0, 6, 9, 0, 1, 5, 9, 7, 3, 4]\n",
            "clean accuracy:  95.0 %\n",
            "\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 1728x1728 with 20 Axes>"
            ]
          },
          "metadata": {
            "tags": [],
            "needs_background": "light"
          }
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ncjGTUmzgQzl"
      },
      "source": [
        "## (4c) Start the actual attack"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "KJ8GSd0i2etD",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 1000
        },
        "outputId": "79cedf13-aea0-4e57-f14e-fa2947206618"
      },
      "source": [
        "test_size = 1000  # assuming we are running 1000 tests for each attack\n",
        "batch_size = 200   # adjust your batch size according to memory limitation, as long as it's a divisor of 1000\n",
        "# test_size = 1000  # assuming we are running 1000 tests for each attack\n",
        "# batch_size = 50   # adjust your batch size according to memory limitation, as long as it's a divisor of 1000\n",
        "num_batch = int(test_size / batch_size)\n",
        "\n",
        "test_dataset = MNIST(root='./data', download=True, train=False, transform=transforms.ToTensor())\n",
        "test_dataloader = DataLoader(test_dataset, batch_size=batch_size, shuffle=False)\n",
        "\n",
        "Linf_epsilons = [\n",
        "    0.1,\n",
        "    0.2,\n",
        "    0.3,\n",
        "    0.4,\n",
        "    0.5\n",
        "]\n",
        "CW_epsilons = [\n",
        "    0.1,\n",
        "    1,\n",
        "    10,\n",
        "    100,\n",
        "    1000\n",
        "]\n",
        "L2_epsilons = [\n",
        "    1,\n",
        "    2,\n",
        "    3,\n",
        "    4,\n",
        "    5\n",
        "]\n",
        "attacks = [\n",
        "    # gradient-based attacks\n",
        "    {\"name\": \"Fast Gradient Method\", \"model\": fa.L2FastGradientAttack(), \"epsilons\": L2_epsilons},\n",
        "    {\"name\": \"Fast Gradient Sign Method\", \"model\": fa.LinfFastGradientAttack(), \"epsilons\": Linf_epsilons},\n",
        "    {\"name\": \"L2 Projected Gradient Descent\", \"model\": fa.L2ProjectedGradientDescentAttack(), \"epsilons\": L2_epsilons},\n",
        "    {\"name\": \"Linf Projected Gradient Descent\", \"model\": fa.LinfProjectedGradientDescentAttack(), \"epsilons\": Linf_epsilons},\n",
        "    {\"name\": \"Carlini & Wagner L2 Attack\", \"model\": fa.L2CarliniWagnerAttack(), \"epsilons\": CW_epsilons},\n",
        "    # # decision-based attacks\n",
        "    # {\"name\": \"Boundary Attack\", \"model\": fa.BoundaryAttack(), \"epsilons\": L2_epsilons}, \n",
        "    {\"name\": \"Additive Uniform Noise Attack\", \"model\": fa.LinfAdditiveUniformNoiseAttack(), \"epsilons\": Linf_epsilons},\n",
        "    {\"name\": \"Additive Gaussian Noise Attack\", \"model\": fa.L2AdditiveGaussianNoiseAttack(), \"epsilons\": L2_epsilons},\n",
        "    {\"name\": \"Linear Search Contrast Reduction Attack\", \"model\": fa.LinearSearchContrastReductionAttack(distance=distances.linf), \"epsilons\": Linf_epsilons}, \n",
        "    {\"name\": \"Binary Search Contrast Reduction Attack\", \"model\": fa.BinarySearchContrastReductionAttack(distance=distances.linf), \"epsilons\": Linf_epsilons}, \n",
        "    {\"name\": \"Gaussian Blur Attack\", \"model\": fa.GaussianBlurAttack(distance=distances.linf), \"epsilons\": Linf_epsilons}\n",
        "]\n",
        "\n",
        "fig, axs = plt.subplots(len(attacks))\n",
        "fig.tight_layout()\n",
        "\n",
        "attack_results = {}\n",
        "for attack in attacks:\n",
        "    attack_results[attack['name']] = None\n",
        "\n",
        "for i, attack in enumerate(attacks):\n",
        "    clean_accuracy = torch.zeros(num_batch)\n",
        "    robust_accuracy_batch = torch.zeros([num_batch, len(L2_epsilons)])\n",
        "    count = 0\n",
        "    t1 = time.time()\n",
        "    for images, labels in test_dataloader:\n",
        "        images = images.to(device)\n",
        "        labels = labels.to(device)\n",
        "        if count == num_batch:\n",
        "            break\n",
        "        images = ep.astensor(images)\n",
        "        labels = ep.astensor(labels)\n",
        "        clean_accuracy[count] = fb.utils.accuracy(fmodel, images, labels)\n",
        "\n",
        "        # The raw adversarial examples. This depends on the attack and we cannot make an guarantees about this output.\n",
        "        # The clipped adversarial examples. These are guaranteed to not be perturbed more than epsilon and thus are the actual adversarial examples you want to visualize. Note that some of them might not actually switch the class. To know which samples are actually adversarial, you should look at the third tensor.\n",
        "        # The third tensor contains a boolean for each sample, indicating which samples are true adversarials that are both misclassified and within the epsilon balls around the clean samples.\n",
        "        raw_adv, clipped_adv, is_adv = attack[\"model\"](fmodel, images, labels, epsilons=attack[\"epsilons\"])\n",
        "\n",
        "        success_ = is_adv.numpy()\n",
        "        robust_accuracy_batch[count] = torch.from_numpy(1.0 - success_.mean(axis=-1))\n",
        "\n",
        "        count += 1\n",
        "\n",
        "    t2 = time.time()\n",
        "    print(attack)\n",
        "    print(\"Clean accuracy: {:.5f}\".format(torch.mean(clean_accuracy)))\n",
        "    print(\"Average time taken for each test: {} seconds\".format((t2 - t1) / test_size))\n",
        "    robust_accuracy = torch.mean(robust_accuracy_batch, dim=0)\n",
        "    print(\"Accuracy with {} attack: {}\".format(attack[\"name\"], robust_accuracy))\n",
        "\n",
        "    attack_results[attack['name']] = robust_accuracy\n",
        "\n",
        "    # plot the robust accuracy against epsilons for the particular attack\n",
        "    axs[i].set_ylim([0, 1])\n",
        "    axs[i].plot(attack[\"epsilons\"], robust_accuracy.numpy())\n",
        "    axs[i].set_title(attack[\"name\"])"
      ],
      "execution_count": 27,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "/usr/local/lib/python3.7/dist-packages/ipykernel_launcher.py:48: UserWarning: Tight layout not applied. tight_layout cannot make axes height small enough to accommodate all axes decorations\n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "{'name': 'Fast Gradient Method', 'model': L2FastGradientAttack(rel_stepsize=1.0, abs_stepsize=None, steps=1, random_start=False), 'epsilons': [1, 2, 3, 4, 5]}\n",
            "Clean accuracy: 0.86000\n",
            "Average time taken for each test: 0.00018316411972045898 seconds\n",
            "Accuracy with Fast Gradient Method attack: tensor([0.6560, 0.3400, 0.0580, 0.0070, 0.0010])\n",
            "{'name': 'Fast Gradient Sign Method', 'model': LinfFastGradientAttack(rel_stepsize=1.0, abs_stepsize=None, steps=1, random_start=False), 'epsilons': [0.1, 0.2, 0.3, 0.4, 0.5]}\n",
            "Clean accuracy: 0.86000\n",
            "Average time taken for each test: 0.0001858975887298584 seconds\n",
            "Accuracy with Fast Gradient Sign Method attack: tensor([0.4230, 0.0220, 0.0000, 0.0000, 0.0000])\n",
            "{'name': 'L2 Projected Gradient Descent', 'model': L2ProjectedGradientDescentAttack(rel_stepsize=0.025, abs_stepsize=None, steps=50, random_start=True), 'epsilons': [1, 2, 3, 4, 5]}\n",
            "Clean accuracy: 0.86000\n",
            "Average time taken for each test: 0.0021656210422515867 seconds\n",
            "Accuracy with L2 Projected Gradient Descent attack: tensor([0.6350, 0.3290, 0.0520, 0.0040, 0.0000])\n",
            "{'name': 'Linf Projected Gradient Descent', 'model': LinfProjectedGradientDescentAttack(rel_stepsize=0.03333333333333333, abs_stepsize=None, steps=40, random_start=True), 'epsilons': [0.1, 0.2, 0.3, 0.4, 0.5]}\n",
            "Clean accuracy: 0.86000\n",
            "Average time taken for each test: 0.0011750199794769286 seconds\n",
            "Accuracy with Linf Projected Gradient Descent attack: tensor([0.4280, 0.0240, 0.0000, 0.0000, 0.0000])\n",
            "{'name': 'Carlini & Wagner L2 Attack', 'model': L2CarliniWagnerAttack(binary_search_steps=9, steps=10000, stepsize=0.01, confidence=0, initial_const=0.001, abort_early=True), 'epsilons': [0.1, 1, 10, 100, 1000]}\n",
            "Clean accuracy: 0.86000\n",
            "Average time taken for each test: 0.4303672475814819 seconds\n",
            "Accuracy with Carlini & Wagner L2 Attack attack: tensor([0.8390, 0.5750, 0.0000, 0.0000, 0.0000])\n",
            "{'name': 'Additive Uniform Noise Attack', 'model': LinfAdditiveUniformNoiseAttack(), 'epsilons': [0.1, 0.2, 0.3, 0.4, 0.5]}\n",
            "Clean accuracy: 0.86000\n",
            "Average time taken for each test: 0.00014947772026062013 seconds\n",
            "Accuracy with Additive Uniform Noise Attack attack: tensor([0.8650, 0.8560, 0.8610, 0.8530, 0.8250])\n",
            "{'name': 'Additive Gaussian Noise Attack', 'model': L2AdditiveGaussianNoiseAttack(), 'epsilons': [1, 2, 3, 4, 5]}\n",
            "Clean accuracy: 0.86000\n",
            "Average time taken for each test: 0.00016417026519775392 seconds\n",
            "Accuracy with Additive Gaussian Noise Attack attack: tensor([0.8570, 0.8560, 0.8600, 0.8600, 0.8610])\n",
            "{'name': 'Linear Search Contrast Reduction Attack', 'model': LinearSearchContrastReductionAttack(distance=Linf distance, steps=1000, target=0.5), 'epsilons': [0.1, 0.2, 0.3, 0.4, 0.5]}\n",
            "Clean accuracy: 0.86000\n",
            "Average time taken for each test: 0.002705106973648071 seconds\n",
            "Accuracy with Linear Search Contrast Reduction Attack attack: tensor([0.8380, 0.7810, 0.5200, 0.2240, 0.0950])\n",
            "{'name': 'Binary Search Contrast Reduction Attack', 'model': BinarySearchContrastReductionAttack(distance=Linf distance, binary_search_steps=15, target=0.5), 'epsilons': [0.1, 0.2, 0.3, 0.4, 0.5]}\n",
            "Clean accuracy: 0.86000\n",
            "Average time taken for each test: 0.00016992068290710448 seconds\n",
            "Accuracy with Binary Search Contrast Reduction Attack attack: tensor([0.8380, 0.7810, 0.5220, 0.2240, 0.0950])\n",
            "{'name': 'Gaussian Blur Attack', 'model': GaussianBlurAttack(distance=Linf distance, steps=1000, channel_axis=None, max_sigma=None), 'epsilons': [0.1, 0.2, 0.3, 0.4, 0.5]}\n",
            "Clean accuracy: 0.86000\n",
            "Average time taken for each test: 0.11511821365356445 seconds\n",
            "Accuracy with Gaussian Blur Attack attack: tensor([0.8470, 0.8420, 0.8350, 0.8210, 0.8000])\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 432x288 with 10 Axes>"
            ]
          },
          "metadata": {
            "tags": [],
            "needs_background": "light"
          }
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "9mF2aCkO2etE",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "cb53d8f7-76f9-4c86-ffee-be36c4449acd"
      },
      "source": [
        "attack_results"
      ],
      "execution_count": 28,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "{'Additive Gaussian Noise Attack': tensor([0.8570, 0.8560, 0.8600, 0.8600, 0.8610]),\n",
              " 'Additive Uniform Noise Attack': tensor([0.8650, 0.8560, 0.8610, 0.8530, 0.8250]),\n",
              " 'Binary Search Contrast Reduction Attack': tensor([0.8380, 0.7810, 0.5220, 0.2240, 0.0950]),\n",
              " 'Carlini & Wagner L2 Attack': tensor([0.8390, 0.5750, 0.0000, 0.0000, 0.0000]),\n",
              " 'Fast Gradient Method': tensor([0.6560, 0.3400, 0.0580, 0.0070, 0.0010]),\n",
              " 'Fast Gradient Sign Method': tensor([0.4230, 0.0220, 0.0000, 0.0000, 0.0000]),\n",
              " 'Gaussian Blur Attack': tensor([0.8470, 0.8420, 0.8350, 0.8210, 0.8000]),\n",
              " 'L2 Projected Gradient Descent': tensor([0.6350, 0.3290, 0.0520, 0.0040, 0.0000]),\n",
              " 'Linear Search Contrast Reduction Attack': tensor([0.8380, 0.7810, 0.5200, 0.2240, 0.0950]),\n",
              " 'Linf Projected Gradient Descent': tensor([0.4280, 0.0240, 0.0000, 0.0000, 0.0000])}"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 28
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "PKol_IUY2etE"
      },
      "source": [
        ""
      ],
      "execution_count": 25,
      "outputs": []
    }
  ]
}