{ "nbformat": 4, "nbformat_minor": 0, "metadata": { "colab": { "name": "Opt Attack for CIFAR-10", "provenance": [], "collapsed_sections": [], "include_colab_link": true }, "kernelspec": { "name": "python3", "display_name": "Python 3" }, "language_info": { "name": "python" }, "accelerator": "GPU" }, "cells": [ { "cell_type": "markdown", "metadata": { "id": "view-in-github", "colab_type": "text" }, "source": [ "\"Open" ] }, { "cell_type": "markdown", "metadata": { "id": "OrPgZRyVo_dJ" }, "source": [ "#### Load Required Libraries" ] }, { "cell_type": "code", "metadata": { "colab": { "base_uri": "https://localhost:8080/" }, "id": "3NN3tJgCjttX", "outputId": "56a50523-2e21-4e3c-8c66-4f5277acd84e" }, "source": [ "!git clone https://github.com/ndb796/attackbox" ], "execution_count": null, "outputs": [ { "output_type": "stream", "text": [ "Cloning into 'attackbox'...\n", "remote: Enumerating objects: 594, done.\u001b[K\n", "remote: Counting objects: 100% (19/19), done.\u001b[K\n", "remote: Compressing objects: 100% (13/13), done.\u001b[K\n", "remote: Total 594 (delta 7), reused 14 (delta 6), pack-reused 575\u001b[K\n", "Receiving objects: 100% (594/594), 74.55 MiB | 23.69 MiB/s, done.\n", "Resolving deltas: 100% (298/298), done.\n", "Checking out files: 100% (191/191), done.\n" ], "name": "stdout" } ] }, { "cell_type": "code", "metadata": { "id": "orvMQ3aUpNQl" }, "source": [ "import torch\n", "import torch.nn as nn\n", "from torch.autograd import Variable\n", "import torchvision\n", "\n", "import numpy as np\n", "from numpy import linalg as LA\n", "import matplotlib.pyplot as plt\n", "\n", "import os\n", "import time\n", "import shutil" ], "execution_count": null, "outputs": [] }, { "cell_type": "markdown", "metadata": { "id": "8_8c9VyHpYxN" }, "source": [ "#### Load Dataset" ] }, { "cell_type": "code", "metadata": { "colab": { "base_uri": "https://localhost:8080/" }, "id": "E0pIjQB-pEeA", "outputId": "2f13cf11-61e6-4329-a671-b1c7df83511f" }, "source": [ "def load_model(model, filename):\n", " \"\"\" Load the training model \"\"\"\n", " model.load_state_dict(torch.load(filename))\n", "\n", "\n", "def load_cifar10_data(batch_size=1):\n", " \"\"\" Load MNIST data from torchvision.datasets \n", " input: None\n", " output: minibatches of train and test sets \n", " \"\"\"\n", " # CIFAR10 Dataset\n", " train_dataset = torchvision.datasets.CIFAR10('./data/cifar10-py', download=True, train=True, transform=torchvision.transforms.ToTensor())\n", " test_dataset = torchvision.datasets.CIFAR10('./data/cifar10-py', download=True, train=False, transform=torchvision.transforms.ToTensor())\n", "\n", " # Data Loader (Input Pipeline)\n", " train_loader = torch.utils.data.DataLoader(dataset=train_dataset, batch_size=batch_size, shuffle=True)\n", " test_loader = torch.utils.data.DataLoader(dataset=test_dataset, batch_size=batch_size, shuffle=False)\n", "\n", " return train_loader, test_loader, train_dataset, test_dataset\n", "\n", "\n", "test_batch_size = 1\n", "train_loader, test_loader, train_dataset, test_dataset = load_cifar10_data(test_batch_size)" ], "execution_count": null, "outputs": [ { "output_type": "stream", "text": [ "Files already downloaded and verified\n", "Files already downloaded and verified\n" ], "name": "stdout" } ] }, { "cell_type": "markdown", "metadata": { "id": "qIuRnHrPpO7c" }, "source": [ "#### Load Pre-trained Classification Model" ] }, { "cell_type": "code", "metadata": { "colab": { "base_uri": "https://localhost:8080/" }, "id": "YKwl6DoNAm94", "outputId": "c7c9a601-0000-4bc4-814d-13068beaf704" }, "source": [ "cfg = {\n", " 'VGG11': [64, 'M', 128, 'M', 256, 256, 'M', 512, 512, 'M', 512, 512, 'M'],\n", " 'VGG13': [64, 64, 'M', 128, 128, 'M', 256, 256, 'M', 512, 512, 'M', 512, 512, 'M'],\n", " 'VGG16': [64, 64, 'M', 128, 128, 'M', 256, 256, 256, 'M', 512, 512, 512, 'M', 512, 512, 512, 'M'],\n", " 'VGG19': [64, 64, 'M', 128, 128, 'M', 256, 256, 256, 256, 'M', 512, 512, 512, 512, 'M', 512, 512, 512, 512, 'M'],\n", "}\n", "\n", "\n", "class VGG_plain(nn.Module):\n", " def __init__(self, vgg_name, nclass, img_width=32):\n", " super(VGG_plain, self).__init__()\n", " self.img_width = img_width\n", " self.features = self._make_layers(cfg[vgg_name])\n", " self.classifier = nn.Linear(512, nclass)\n", "\n", " def forward(self, x):\n", " out = self.features(x)\n", " out = out.view(out.size(0), -1)\n", " out = self.classifier(out)\n", " return out\n", "\n", " def _make_layers(self, cfg):\n", " layers = []\n", " in_channels = 3\n", " width = self.img_width\n", " for x in cfg:\n", " if x == 'M':\n", " layers += [nn.MaxPool2d(kernel_size=2, stride=2)]\n", " width = width // 2\n", " else:\n", " layers += [nn.Conv2d(in_channels, x, kernel_size=3, padding=1),\n", " nn.BatchNorm2d(x),\n", " nn.ReLU(inplace=True)]\n", " in_channels = x\n", " layers += [nn.AvgPool2d(kernel_size=width, stride=1)]\n", " return nn.Sequential(*layers)\n", "\n", " def predict(self, image):\n", " self.eval()\n", " image = torch.clamp(image,0,1)\n", " image = Variable(image, volatile=True).view(1,3, 32,32)\n", " if torch.cuda.is_available():\n", " image = image.cuda()\n", " output = self(image)[0]\n", " print(output)\n", " _, predict = torch.max(output.data, 1)\n", " return predict[0]\n", " \n", " def predict_batch(self, image):\n", " self.eval()\n", " image = torch.clamp(image,0,1)\n", " image = Variable(image, volatile=True)\n", " if torch.cuda.is_available():\n", " image = image.cuda()\n", " output = self(image)[0]\n", " _, predict = torch.max(output.data, 1)\n", " return predict\n", "\n", "\n", "def vgg16():\n", " return VGG_plain('VGG16', nclass=10)\n", "\n", "\n", "model_dir = 'attackbox/model/cifar10_vgg_plain.pth'\n", "net = vgg16()\n", "net = torch.nn.DataParallel(net, device_ids=[0])\n", "load_model(net, model_dir)\n", "net.cuda()\n", "net.eval()" ], "execution_count": null, "outputs": [ { "output_type": "execute_result", "data": { "text/plain": [ "DataParallel(\n", " (module): VGG_plain(\n", " (features): Sequential(\n", " (0): Conv2d(3, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n", " (1): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", " (2): ReLU(inplace=True)\n", " (3): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n", " (4): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", " (5): ReLU(inplace=True)\n", " (6): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)\n", " (7): Conv2d(64, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n", " (8): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", " (9): ReLU(inplace=True)\n", " (10): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n", " (11): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", " (12): ReLU(inplace=True)\n", " (13): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)\n", " (14): Conv2d(128, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n", " (15): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", " (16): ReLU(inplace=True)\n", " (17): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n", " (18): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", " (19): ReLU(inplace=True)\n", " (20): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n", " (21): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", " (22): ReLU(inplace=True)\n", " (23): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)\n", " (24): Conv2d(256, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n", " (25): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", " (26): ReLU(inplace=True)\n", " (27): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n", " (28): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", " (29): ReLU(inplace=True)\n", " (30): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n", " (31): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", " (32): ReLU(inplace=True)\n", " (33): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)\n", " (34): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n", " (35): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", " (36): ReLU(inplace=True)\n", " (37): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n", " (38): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", " (39): ReLU(inplace=True)\n", " (40): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n", " (41): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", " (42): ReLU(inplace=True)\n", " (43): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)\n", " (44): AvgPool2d(kernel_size=1, stride=1, padding=0)\n", " )\n", " (classifier): Linear(in_features=512, out_features=10, bias=True)\n", " )\n", ")" ] }, "metadata": { "tags": [] }, "execution_count": 40 } ] }, { "cell_type": "code", "metadata": { "id": "kLnrkPAbp2Ec" }, "source": [ "class PytorchModel(object):\n", " def __init__(self,model, bounds, num_classes):\n", " self.model = model\n", " self.model.eval()\n", " self.bounds = bounds\n", " self.num_classes = num_classes\n", " self.num_queries = 0\n", "\n", " def predict(self,image):\n", " image = torch.clamp(image,self.bounds[0],self.bounds[1]).cuda()\n", " if len(image.size())!=4:\n", " image = image.unsqueeze(0)\n", " output = self.model(image)\n", " self.num_queries += 1\n", " return output\n", " \n", " def predict_prob(self,image):\n", " with torch.no_grad():\n", " image = torch.clamp(image,self.bounds[0],self.bounds[1]).cuda()\n", " if len(image.size())!=4:\n", " image = image.unsqueeze(0)\n", " output = self.model(image)\n", " self.num_queries += image.size(0)\n", " return output\n", "\n", " def predict_label(self, image, batch=False):\n", " if isinstance(image, np.ndarray):\n", " image = torch.from_numpy(image).type(torch.FloatTensor)\n", " image = torch.clamp(image,self.bounds[0],self.bounds[1]).cuda()\n", " if len(image.size())!=4:\n", " image = image.unsqueeze(0)\n", " with torch.no_grad():\n", " output = self.model(image)\n", " self.num_queries += image.size(0)\n", " _, predict = torch.max(output.data, 1)\n", " if batch:\n", " return predict\n", " else:\n", " return predict[0]\n", "\n", " def predict_ensemble(self, image):\n", " if isinstance(image, np.ndarray):\n", " image = torch.from_numpy(image).type(torch.FloatTensor)\n", " image = torch.clamp(image,self.bounds[0],self.bounds[1]).cuda()\n", " if len(image.size())!=4:\n", " image = image.unsqueeze(0)\n", " with torch.no_grad():\n", " output = self.model(image)\n", " output.zero_()\n", " for i in range(10):\n", " output += self.model(image)\n", " self.num_queries += image.size(0)\n", "\n", " _, predict = torch.max(output.data, 1)\n", "\n", " return predict[0]\n", "\n", " def get_num_queries(self):\n", " return self.num_queries\n", "\n", " def get_gradient(self,loss):\n", " loss.backward()" ], "execution_count": null, "outputs": [] }, { "cell_type": "markdown", "metadata": { "id": "D8gtuAehpsSu" }, "source": [ "#### Adversarial Attack" ] }, { "cell_type": "code", "metadata": { "id": "5-rNUNmBl2mI" }, "source": [ "MAX_ITER = 1000\n", "\n", "\n", "class OPT_attack(object):\n", " def __init__(self, model):\n", " self.model = model\n", " self.log = torch.ones(MAX_ITER, 2)\n", "\n", " def get_log(self):\n", " return self.log\n", "\n", " def attack_untargeted(self, x0, y0, alpha=0.2, beta=0.001, iterations=1500, query_limit=20000):\n", " \"\"\" Attack the original image and return adversarial example\n", " model: (pytorch model)\n", " train_dataset: set of training data\n", " (x0, y0): original image\n", " \"\"\"\n", " model = self.model\n", " if type(x0) is torch.Tensor:\n", " x0 = x0.cpu().numpy()\n", " if type(y0) is torch.Tensor:\n", " y0 = y0.item()\n", " if (model.predict_label(x0) != y0):\n", " print(\"Fail to classify the image. No need to attack.\")\n", " return torch.tensor(x0).cuda()\n", "\n", " # 공격을 위한 초기 방향(initial direction) theta 찾기 / g_theta: 거리(짧을수록 좋음)\n", " num_directions = 100\n", " best_theta, g_theta = None, float('inf')\n", " query_count = 0\n", " print(\"Searching for the initial direction on %d random directions: \" % (num_directions))\n", " np.random.seed(args.seed)\n", " timestart = time.time()\n", " for i in range(num_directions):\n", " query_count += 1\n", " theta = np.random.randn(*x0.shape) # 랜덤 theta 샘플링\n", " if model.predict_label(x0 + theta) != y0:\n", " initial_lbd = LA.norm(theta)\n", " theta /= initial_lbd # 단위 방향 벡터\n", " lbd, count = self.fine_grained_binary_search(model, x0, y0, theta, initial_lbd, g_theta)\n", " query_count += count\n", " if lbd < g_theta: # 더 짧은 거리(g_theta)를 찾았다면\n", " best_theta, g_theta = theta, lbd\n", " print(\"--------> Found distortion %.4f\" % g_theta)\n", " if g_theta == float('inf'): # 만약 적절한 theta를 찾지 못했다면 500회 더 반복\n", " num_directions = 500\n", " best_theta, g_theta = None, float('inf')\n", " print(\"Searching for the initial direction on %d random directions: \" % (num_directions))\n", " timestart = time.time()\n", " for i in range(num_directions):\n", " query_count += 1\n", " theta = np.random.randn(*x0.shape) # 랜덤 theta 샘플링\n", " if model.predict_label(x0 + theta) != y0:\n", " initial_lbd = LA.norm(theta)\n", " theta /= initial_lbd # 단위 방향 벡터\n", " lbd, count = self.fine_grained_binary_search(model, x0, y0, theta, initial_lbd, g_theta)\n", " query_count += count\n", " if lbd < g_theta: # 더 짧은 거리(g_theta)를 찾았다면\n", " best_theta, g_theta = theta, lbd\n", " print(\"--------> Found distortion %.4f\" % g_theta)\n", "\n", " if g_theta == float('inf'): \n", " print(\"Couldn't find valid initial, failed\")\n", " return torch.tensor(x0).cuda()\n", " timeend = time.time()\n", " print(\"==========> Found best distortion %.4f in %.4f seconds using %d queries\" % (g_theta, timeend - timestart, query_count)) \n", " self.log[0][0], self.log[0][1] = g_theta, query_count\n", "\n", " # 반복적으로 theta를 업데이트하며 공격 수행\n", " timestart = time.time()\n", " g1 = 1.0\n", " theta, g2 = best_theta, g_theta\n", " opt_count = 0\n", " stopping = 0.01\n", " prev_obj = 100000\n", " for i in range(iterations):\n", " # theta의 기울기(gradient) 예측\n", " gradient = np.zeros(theta.shape)\n", " q = 10\n", " min_g1 = float('inf')\n", " for _ in range(q):\n", " u = np.random.randn(*theta.shape)\n", " u /= LA.norm(u)\n", " ttt = theta+beta * u\n", " ttt /= LA.norm(ttt)\n", " g1, count = self.fine_grained_binary_search_local(model, x0, y0, ttt, initial_lbd = g2, tol=beta/500)\n", " opt_count += count\n", " gradient += (g1 - g2) / beta * u # 기울기 구하기\n", " if g1 < min_g1:\n", " min_g1 = g1\n", " min_ttt = ttt\n", " gradient = 1.0 / q * gradient\n", "\n", " # 쿼리 한도(query limit)를 초과했다면 종료\n", " if opt_count > query_limit:\n", " break\n", "\n", " # 공격이 진행되는 상황에서 로깅(logging)\n", " if (i + 1) % 10 == 0:\n", " print(\"Iteration %3d distortion %.4f num_queries %d\" % (i + 1, LA.norm(g2 * theta), opt_count))\n", " prev_obj = g2\n", " self.log[i+1][0], self.log[i+1][1] = g2, opt_count + query_count\n", "\n", " if (i + 1) % 50 == 0:\n", " # 화면에 이미지 출력하기\n", " img = torch.tensor(x0 + g2 * theta, dtype=torch.float) # [batch_size, 1, H, W]\n", " img = torch.clamp(img, min=0, max=1).squeeze(0) # [1, H, W]\n", " img = torchvision.transforms.ToPILImage()(img)\n", " plt.imshow(img)\n", " plt.show()\n", "\n", " # 예측된 기울기를 이용하여 theta를 업데이트할 것임\n", " min_theta = theta\n", " min_g2 = g2\n", "\n", " for _ in range(15): # 예측된 기울기를 이용해 alpha만큼 업데이트했을 때 거리(g_2)가 줄어드는지 확인하여 기록\n", " new_theta = theta - alpha * gradient\n", " new_theta /= LA.norm(new_theta)\n", " new_g2, count = self.fine_grained_binary_search_local(model, x0, y0, new_theta, initial_lbd = min_g2, tol=beta/500)\n", " opt_count += count\n", " alpha = alpha * 2\n", " if new_g2 < min_g2:\n", " min_theta = new_theta \n", " min_g2 = new_g2\n", " else:\n", " break\n", "\n", " if min_g2 >= g2: # 필요하다면 alpha를 조금 더 줄여서 거리(g_2)가 줄어드는지 다시 확인하여 기록\n", " for _ in range(15):\n", " alpha = alpha * 0.25\n", " new_theta = theta - alpha * gradient\n", " new_theta /= LA.norm(new_theta)\n", " new_g2, count = self.fine_grained_binary_search_local(model, x0, y0, new_theta, initial_lbd = min_g2, tol=beta/500)\n", " opt_count += count\n", " if new_g2 < g2:\n", " min_theta = new_theta \n", " min_g2 = new_g2\n", " break\n", "\n", " # 결과적으로 theta(방향)와 g_theta(거리) 정보를 업데이트\n", " if min_g2 <= min_g1:\n", " theta, g2 = min_theta, min_g2\n", " else:\n", " theta, g2 = min_ttt, min_g1\n", "\n", " if g2 < g_theta:\n", " best_theta, g_theta = theta, g2\n", "\n", " if alpha < 1e-4:\n", " alpha = 1.0\n", " print(\"Warning: not moving, g2 %lf gtheta %lf\" % (g2, g_theta))\n", " beta = beta * 0.1\n", " if (beta < 1e-8):\n", " break\n", "\n", " target = model.predict_label(x0 + g_theta * best_theta)\n", " timeend = time.time()\n", " print(\"\\nAdversarial Example Found Successfully: distortion %.4f target %d queries %d \\nTime: %.4f seconds\" % (g_theta, target, query_count + opt_count, timeend-timestart))\n", "\n", " self.log[i+1:,0] = g_theta\n", " self.log[i+1:,1] = opt_count + query_count\n", " return torch.tensor(x0 + g_theta * best_theta, dtype=torch.float).cuda()\n", "\n", " # theta를 업데이트할 때 사용\n", " def fine_grained_binary_search_local(self, model, x0, y0, theta, initial_lbd=1.0, tol=1e-5):\n", " nquery = 0\n", " lbd = initial_lbd\n", "\n", " if model.predict_label(x0 + lbd * theta) == y0:\n", " lbd_lo = lbd\n", " lbd_hi = lbd * 1.01\n", " nquery += 1\n", " while model.predict_label(x0 + lbd_hi * theta) == y0:\n", " lbd_hi = lbd_hi * 1.01\n", " nquery += 1\n", " if lbd_hi > 20:\n", " return float('inf'), nquery\n", " else:\n", " lbd_hi = lbd\n", " lbd_lo = lbd * 0.99\n", " nquery += 1\n", " while model.predict_label(x0 + lbd_lo * theta) != y0 :\n", " lbd_lo = lbd_lo * 0.99\n", " nquery += 1\n", "\n", " while (lbd_hi - lbd_lo) > tol:\n", " lbd_mid = (lbd_lo + lbd_hi) / 2.0\n", " nquery += 1\n", " if model.predict_label(x0 + lbd_mid * theta) != y0:\n", " lbd_hi = lbd_mid\n", " else:\n", " lbd_lo = lbd_mid\n", " return lbd_hi, nquery\n", "\n", " # 처음에 initial theta를 찾을 때 사용\n", " def fine_grained_binary_search(self, model, x0, y0, theta, initial_lbd, current_best):\n", " nquery = 0\n", " if initial_lbd > current_best: \n", " if model.predict_label(x0 + current_best * theta) == y0:\n", " nquery += 1\n", " return float('inf'), nquery\n", " lbd = current_best\n", " else:\n", " lbd = initial_lbd\n", "\n", " lbd_hi = lbd\n", " lbd_lo = 0.0\n", "\n", " while (lbd_hi - lbd_lo) > 1e-5:\n", " lbd_mid = (lbd_lo + lbd_hi) / 2.0\n", " nquery += 1\n", " if model.predict_label(x0 + lbd_mid * theta) != y0:\n", " lbd_hi = lbd_mid\n", " else:\n", " lbd_lo = lbd_mid\n", " return lbd_hi, nquery\n", "\n", " def __call__(self, input_xi, label_or_target, TARGETED=False, epsilon=None):\n", " if TARGETED:\n", " print(\"Not Implemented.\")\n", " else:\n", " adv = self.attack_untargeted(input_xi, label_or_target)\n", " return adv" ], "execution_count": null, "outputs": [] }, { "cell_type": "code", "metadata": { "id": "ytpMQL5stsQD" }, "source": [ "# 단순히 p-norm 거리(distance) 계산\n", "def distance(x_adv, x, norm='l2'):\n", " diff = (x_adv - x).view(x.size(0), -1)\n", " if norm == 'l2':\n", " out = torch.sqrt(torch.sum(diff * diff)).item()\n", " return out\n", " elif norm == 'linf':\n", " out = torch.sum(torch.max(torch.abs(diff), 1)[0]).item()\n", " return out" ], "execution_count": null, "outputs": [] }, { "cell_type": "code", "metadata": { "id": "ksIwqNi9hrEs" }, "source": [ "from types import SimpleNamespace\n", "\n", "args = SimpleNamespace()\n", "\n", "args.attack = 'OPT_attack' # Attack to be used.\n", "args.targeted = False # Targeted attack.\n", "args.random_start = False # PGD attack with random start.\n", "args.epsilon = 1.0\n", "args.seed = 123\n", "args.norm = 'l2'\n", "args.test_batch = 3 # The number of test batch." ], "execution_count": null, "outputs": [] }, { "cell_type": "code", "metadata": { "colab": { "base_uri": "https://localhost:8080/", "height": 1000 }, "id": "Ftqcu-xFmF-i", "outputId": "68eb3a69-3337-4a6f-f043-fb6a94596718" }, "source": [ "amodel = PytorchModel(net, bounds=[0, 1], num_classes=10)\n", "attack = OPT_attack(amodel)\n", "\n", "total_r_count = 0\n", "total_clean_count = 0\n", "total_distance = 0\n", "\n", "for i, (xi, yi) in enumerate(test_loader):\n", " print(f\"image batch: {i}\")\n", " if i == args.test_batch:\n", " break\n", "\n", " xi, yi = xi.cuda(), yi.cuda()\n", " adv = attack(xi, yi, epsilon=args.epsilon, TARGETED=args.targeted)\n", "\n", " # 결과 출력(l_2 distortion이 충분히 감소했을 때 성공)\n", " img = torchvision.transforms.ToPILImage()(torch.clamp(adv, min=0, max=1).squeeze(0))\n", " plt.imshow(img)\n", " plt.show()\n", "\n", " if args.targeted == False:\n", " r_count = (torch.max(amodel.predict(adv), 1)[1] == yi).nonzero().shape[0]\n", " clean_count = (torch.max(amodel.predict(xi), 1)[1] == yi).nonzero().shape[0]\n", " total_r_count += r_count\n", " total_clean_count += clean_count\n", " total_distance += distance(adv, xi, norm=args.norm)\n", "\n", " if i == 0:\n", " logs = torch.zeros(attack.get_log().size())\n", " logs += attack.get_log()\n", "\n", "logs /= args.test_batch\n", "print(\"saving logs to numpy array\")\n", "npy_file = \"log.npy\"\n", "np.save(npy_file,logs.numpy())\n", "\n", "plot_log = np.load(npy_file)\n", "plt.plot(plot_log[:,1], plot_log[:,0])\n", "plt.ylabel('Distortion')\n", "plt.xlabel('Num of queries')\n", "plt.show()" ], "execution_count": null, "outputs": [ { "output_type": "stream", "text": [ "image batch: 0\n", "Searching for the initial direction on 100 random directions: \n", "--------> Found distortion 3.7202\n", "--------> Found distortion 3.7017\n", "--------> Found distortion 3.5716\n", "--------> Found distortion 2.9893\n", "--------> Found distortion 2.8506\n", "--------> Found distortion 2.7356\n", "==========> Found best distortion 2.7356 in 3.2823 seconds using 312 queries\n", "Iteration 10 distortion 1.8053 num_queries 2103\n", "Iteration 20 distortion 1.0979 num_queries 4027\n", "Iteration 30 distortion 0.8589 num_queries 5969\n", "Iteration 40 distortion 0.7311 num_queries 7772\n", "Iteration 50 distortion 0.6423 num_queries 9536\n" ], "name": "stdout" }, { "output_type": "display_data", "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "tags": [], "needs_background": "light" } }, { "output_type": "stream", "text": [ "Iteration 60 distortion 0.5951 num_queries 11179\n", "Iteration 70 distortion 0.5617 num_queries 12839\n", "Iteration 80 distortion 0.5255 num_queries 14509\n", "Iteration 90 distortion 0.4884 num_queries 16200\n", "Iteration 100 distortion 0.4657 num_queries 17840\n" ], "name": "stdout" }, { "output_type": "display_data", "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "tags": [], "needs_background": "light" } }, { "output_type": "stream", "text": [ "Iteration 110 distortion 0.4451 num_queries 19486\n", "\n", "Adversarial Example Found Successfully: distortion 0.4412 target 6 queries 20440 \n", "Time: 212.0795 seconds\n" ], "name": "stdout" }, { "output_type": "display_data", "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "tags": [], "needs_background": "light" } }, { "output_type": "stream", "text": [ "image batch: 1\n", "Searching for the initial direction on 100 random directions: \n", "--------> Found distortion 4.5299\n", "--------> Found distortion 4.0619\n", "--------> Found distortion 3.9259\n", "--------> Found distortion 3.8379\n", "--------> Found distortion 3.4344\n", "--------> Found distortion 3.3284\n", "==========> Found best distortion 3.3284 in 3.1464 seconds using 312 queries\n", "Iteration 10 distortion 2.0991 num_queries 2245\n", "Iteration 20 distortion 1.7654 num_queries 4296\n", "Iteration 30 distortion 1.4610 num_queries 6263\n", "Iteration 40 distortion 1.0342 num_queries 8254\n", "Iteration 50 distortion 0.7985 num_queries 10143\n" ], "name": "stdout" }, { "output_type": "display_data", "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "tags": [], "needs_background": "light" } }, { "output_type": "stream", "text": [ "Iteration 60 distortion 0.6608 num_queries 11884\n", "Iteration 70 distortion 0.5963 num_queries 13592\n", "Iteration 80 distortion 0.5478 num_queries 15331\n", "Iteration 90 distortion 0.5143 num_queries 17071\n", "Iteration 100 distortion 0.4827 num_queries 18770\n" ], "name": "stdout" }, { "output_type": "display_data", "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "tags": [], "needs_background": "light" } }, { "output_type": "stream", "text": [ "\n", "Adversarial Example Found Successfully: distortion 0.4606 target 1 queries 20410 \n", "Time: 212.6560 seconds\n" ], "name": "stdout" }, { "output_type": "display_data", "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "tags": [], "needs_background": "light" } }, { "output_type": "stream", "text": [ "image batch: 2\n", "Searching for the initial direction on 100 random directions: \n", "--------> Found distortion 2.2699\n", "--------> Found distortion 1.8510\n", "--------> Found distortion 1.6913\n", "--------> Found distortion 1.5024\n", "==========> Found best distortion 1.5024 in 2.7768 seconds using 273 queries\n", "Iteration 10 distortion 0.8068 num_queries 1969\n", "Iteration 20 distortion 0.6085 num_queries 3722\n", "Iteration 30 distortion 0.5042 num_queries 5532\n", "Iteration 40 distortion 0.4492 num_queries 7233\n", "Iteration 50 distortion 0.4066 num_queries 8893\n" ], "name": "stdout" }, { "output_type": "display_data", "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "tags": [], "needs_background": "light" } }, { "output_type": "stream", "text": [ "Iteration 60 distortion 0.3604 num_queries 10573\n", "Iteration 70 distortion 0.3374 num_queries 12166\n", "Iteration 80 distortion 0.3159 num_queries 13751\n", "Iteration 90 distortion 0.2970 num_queries 15362\n", "Iteration 100 distortion 0.2859 num_queries 16886\n" ], "name": "stdout" }, { "output_type": "display_data", "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "tags": [], "needs_background": "light" } }, { "output_type": "stream", "text": [ "Iteration 110 distortion 0.2694 num_queries 18447\n", "Iteration 120 distortion 0.2587 num_queries 19946\n", "\n", "Adversarial Example Found Successfully: distortion 0.2581 target 9 queries 20365 \n", "Time: 214.3301 seconds\n" ], "name": "stdout" }, { "output_type": "display_data", "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "tags": [], "needs_background": "light" } }, { "output_type": "stream", "text": [ "image batch: 3\n", "saving logs to numpy array\n" ], "name": "stdout" }, { "output_type": "display_data", "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "tags": [], "needs_background": "light" } } ] } ] }