{ "nbformat": 4, "nbformat_minor": 0, "metadata": { "colab": { "name": "Opt Attack for MNIST", "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": "17fce51d-09d2-4885-ed53-ad6c3599e173" }, "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 | 29.25 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": { "id": "E0pIjQB-pEeA" }, "source": [ "def load_model(model, filename):\n", " \"\"\" Load the training model \"\"\"\n", " model.load_state_dict(torch.load(filename))\n", "\n", "\n", "def load_mnist_data(batch_size=1):\n", " \"\"\" Load MNIST data from torchvision.datasets \n", " input: None\n", " output: minibatches of train and test sets \n", " \"\"\"\n", " # MNIST Dataset\n", " train_dataset = torchvision.datasets.MNIST(root='./data/mnist', train=True, transform=torchvision.transforms.ToTensor(), download=True)\n", " test_dataset = torchvision.datasets.MNIST(root='./data/mnist', 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=False)\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_mnist_data(test_batch_size)" ], "execution_count": null, "outputs": [] }, { "cell_type": "markdown", "metadata": { "id": "qIuRnHrPpO7c" }, "source": [ "#### Load Pre-trained Classification Model" ] }, { "cell_type": "code", "metadata": { "colab": { "base_uri": "https://localhost:8080/" }, "id": "DAVI9BjCpJ7t", "outputId": "07135fe8-494a-43f7-e2dc-dc9d804a466a" }, "source": [ "class BasicCNN(nn.Module):\n", " def __init__(self):\n", " super(BasicCNN, self).__init__() \n", " self.main = nn.Sequential(\n", " nn.Conv2d(1, 20, kernel_size=5),\n", " nn.ReLU(),\n", " nn.MaxPool2d(2, stride=2),\n", " nn.Conv2d(20, 50, kernel_size=5),\n", " nn.ReLU(),\n", " nn.MaxPool2d(2, stride=2))\n", " self.fc = nn.Sequential(\n", " nn.Linear(4*4*50, 500), \n", " nn.ReLU(), \n", " nn.Linear(500, 10))\n", " def forward(self, x):\n", " x = self.main(x)\n", " x = x.view(-1, 4*4*50)\n", " x = self.fc(x)\n", " return x\n", "\n", "\n", "model_dir = 'attackbox/model/m_cnn'\n", "net = BasicCNN()\n", "load_model(net, model_dir)\n", "net = torch.nn.DataParallel(net, device_ids=[0])\n", "net.cuda()\n", "net.eval()" ], "execution_count": null, "outputs": [ { "output_type": "execute_result", "data": { "text/plain": [ "DataParallel(\n", " (module): BasicCNN(\n", " (main): Sequential(\n", " (0): Conv2d(1, 20, kernel_size=(5, 5), stride=(1, 1))\n", " (1): ReLU()\n", " (2): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)\n", " (3): Conv2d(20, 50, kernel_size=(5, 5), stride=(1, 1))\n", " (4): ReLU()\n", " (5): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)\n", " )\n", " (fc): Sequential(\n", " (0): Linear(in_features=800, out_features=500, bias=True)\n", " (1): ReLU()\n", " (2): Linear(in_features=500, out_features=10, bias=True)\n", " )\n", " )\n", ")" ] }, "metadata": { "tags": [] }, "execution_count": 41 } ] }, { "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=80000):\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) % 100 == 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, cmap='gray') # for grayscale\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 = 10 # 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": "e2735636-b8b0-4728-d22b-f616eb302aa9" }, "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, cmap='gray') # for grayscale\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 21.6926\n", "--------> Found distortion 15.7801\n", "--------> Found distortion 12.9252\n", "==========> Found best distortion 12.9252 in 0.1781 seconds using 255 queries\n", "Iteration 10 distortion 6.5614 num_queries 2357\n", "Iteration 20 distortion 4.5230 num_queries 4498\n", "Iteration 30 distortion 3.7154 num_queries 6640\n", "Iteration 40 distortion 3.1540 num_queries 8734\n", "Iteration 50 distortion 2.8883 num_queries 10664\n", "Iteration 60 distortion 2.7302 num_queries 12589\n", "Iteration 70 distortion 2.6171 num_queries 14545\n", "Iteration 80 distortion 2.4914 num_queries 16400\n", "Iteration 90 distortion 2.4219 num_queries 18286\n", "Iteration 100 distortion 2.3339 num_queries 20214\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 2.2563 num_queries 22087\n", "Iteration 120 distortion 2.1904 num_queries 23963\n", "Iteration 130 distortion 2.1423 num_queries 25861\n", "Iteration 140 distortion 2.0967 num_queries 27719\n", "Iteration 150 distortion 2.0606 num_queries 29650\n", "Iteration 160 distortion 2.0340 num_queries 31528\n", "Iteration 170 distortion 2.0167 num_queries 33413\n", "Iteration 180 distortion 2.0002 num_queries 35330\n", "Iteration 190 distortion 1.9770 num_queries 37205\n", "Iteration 200 distortion 1.9600 num_queries 39090\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 210 distortion 1.9393 num_queries 41015\n", "Iteration 220 distortion 1.9253 num_queries 42854\n", "Iteration 230 distortion 1.9104 num_queries 44696\n", "Iteration 240 distortion 1.9008 num_queries 46547\n", "Iteration 250 distortion 1.8883 num_queries 48458\n", "Iteration 260 distortion 1.8804 num_queries 50323\n", "Iteration 270 distortion 1.8702 num_queries 52213\n", "Iteration 280 distortion 1.8611 num_queries 54061\n", "Iteration 290 distortion 1.8529 num_queries 55941\n", "Iteration 300 distortion 1.8444 num_queries 57861\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 310 distortion 1.8392 num_queries 59721\n", "Iteration 320 distortion 1.8353 num_queries 61581\n", "Iteration 330 distortion 1.8307 num_queries 63491\n", "Iteration 340 distortion 1.8243 num_queries 65443\n", "Iteration 350 distortion 1.8187 num_queries 67318\n", "Iteration 360 distortion 1.8142 num_queries 69266\n", "Iteration 370 distortion 1.8098 num_queries 71261\n", "Iteration 380 distortion 1.8056 num_queries 73196\n", "Warning: not moving, g2 1.804643 gtheta 1.804643\n", "Warning: not moving, g2 1.804593 gtheta 1.804593\n", "Warning: not moving, g2 1.804585 gtheta 1.804585\n", "Iteration 390 distortion 1.8044 num_queries 76577\n", "Warning: not moving, g2 1.804448 gtheta 1.804448\n", "Warning: not moving, g2 1.804429 gtheta 1.804429\n", "Warning: not moving, g2 1.804429 gtheta 1.804429\n", "\n", "Adversarial Example Found Successfully: distortion 1.8044 target 3 queries 80172 \n", "Time: 55.8117 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 20.2277\n", "--------> Found distortion 19.2837\n", "--------> Found distortion 18.1427\n", "--------> Found distortion 15.4665\n", "--------> Found distortion 14.8374\n", "--------> Found distortion 14.3282\n", "==========> Found best distortion 14.3282 in 0.2209 seconds using 301 queries\n", "Iteration 10 distortion 8.0117 num_queries 2257\n", "Iteration 20 distortion 6.3727 num_queries 4465\n", "Iteration 30 distortion 5.4464 num_queries 6627\n", "Iteration 40 distortion 5.0552 num_queries 8629\n", "Iteration 50 distortion 4.6529 num_queries 10668\n", "Iteration 60 distortion 4.3012 num_queries 12690\n", "Iteration 70 distortion 4.0992 num_queries 14683\n", "Iteration 80 distortion 3.9484 num_queries 16714\n", "Iteration 90 distortion 3.8415 num_queries 18801\n", "Iteration 100 distortion 3.7545 num_queries 20765\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 3.5999 num_queries 22772\n", "Iteration 120 distortion 3.5066 num_queries 24775\n", "Iteration 130 distortion 3.4393 num_queries 26755\n", "Iteration 140 distortion 3.3914 num_queries 28778\n", "Iteration 150 distortion 3.3420 num_queries 30724\n", "Iteration 160 distortion 3.2745 num_queries 32702\n", "Iteration 170 distortion 3.2387 num_queries 34605\n", "Iteration 180 distortion 3.1933 num_queries 36491\n", "Iteration 190 distortion 3.1603 num_queries 38313\n", "Iteration 200 distortion 3.1253 num_queries 40206\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 210 distortion 3.0983 num_queries 42077\n", "Iteration 220 distortion 3.0676 num_queries 43922\n", "Iteration 230 distortion 3.0381 num_queries 45820\n", "Iteration 240 distortion 3.0092 num_queries 47697\n", "Warning: not moving, g2 2.994199 gtheta 2.994199\n", "Warning: not moving, g2 2.992342 gtheta 2.992342\n", "Warning: not moving, g2 2.992333 gtheta 2.992333\n", "Warning: not moving, g2 2.992326 gtheta 2.992326\n", "Warning: not moving, g2 2.991897 gtheta 2.991897\n", "Iteration 250 distortion 2.9919 num_queries 52735\n", "Warning: not moving, g2 2.991888 gtheta 2.991888\n", "\n", "Adversarial Example Found Successfully: distortion 2.9919 target 8 queries 54557 \n", "Time: 37.9156 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 11.0326\n", "--------> Found distortion 9.4533\n", "--------> Found distortion 8.1595\n", "--------> Found distortion 7.3981\n", "--------> Found distortion 7.1213\n", "==========> Found best distortion 7.1213 in 0.2130 seconds using 298 queries\n", "Iteration 10 distortion 4.1717 num_queries 2167\n", "Iteration 20 distortion 3.1347 num_queries 4198\n", "Iteration 30 distortion 2.7153 num_queries 6204\n", "Iteration 40 distortion 2.4456 num_queries 8186\n", "Iteration 50 distortion 2.2099 num_queries 10172\n", "Iteration 60 distortion 2.0605 num_queries 12074\n", "Iteration 70 distortion 1.9230 num_queries 13995\n", "Iteration 80 distortion 1.8426 num_queries 15867\n", "Iteration 90 distortion 1.7795 num_queries 17754\n", "Iteration 100 distortion 1.7043 num_queries 19687\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 1.6644 num_queries 21535\n", "Iteration 120 distortion 1.6168 num_queries 23436\n", "Iteration 130 distortion 1.5839 num_queries 25205\n", "Iteration 140 distortion 1.5513 num_queries 26962\n", "Iteration 150 distortion 1.5200 num_queries 28755\n", "Iteration 160 distortion 1.5009 num_queries 30504\n", "Iteration 170 distortion 1.4834 num_queries 32238\n", "Iteration 180 distortion 1.4665 num_queries 33986\n", "Iteration 190 distortion 1.4580 num_queries 35718\n", "Iteration 200 distortion 1.4455 num_queries 37460\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 210 distortion 1.4318 num_queries 39218\n", "Iteration 220 distortion 1.4222 num_queries 40949\n", "Iteration 230 distortion 1.4134 num_queries 42699\n", "Iteration 240 distortion 1.4044 num_queries 44414\n", "Iteration 250 distortion 1.3971 num_queries 46143\n", "Iteration 260 distortion 1.3917 num_queries 47853\n", "Iteration 270 distortion 1.3824 num_queries 49563\n", "Iteration 280 distortion 1.3754 num_queries 51306\n", "Iteration 290 distortion 1.3696 num_queries 53046\n", "Iteration 300 distortion 1.3603 num_queries 54758\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 310 distortion 1.3547 num_queries 56482\n", "Iteration 320 distortion 1.3494 num_queries 58236\n", "Iteration 330 distortion 1.3455 num_queries 59972\n", "Iteration 340 distortion 1.3416 num_queries 61712\n", "Iteration 350 distortion 1.3376 num_queries 63408\n", "Warning: not moving, g2 1.335398 gtheta 1.335398\n", "Warning: not moving, g2 1.335396 gtheta 1.335396\n", "Warning: not moving, g2 1.335396 gtheta 1.335396\n", "Warning: not moving, g2 1.335396 gtheta 1.335396\n", "Iteration 360 distortion 1.3354 num_queries 66819\n", "Warning: not moving, g2 1.335396 gtheta 1.335396\n", "Warning: not moving, g2 1.335394 gtheta 1.335394\n", "\n", "Adversarial Example Found Successfully: distortion 1.3354 target 8 queries 69675 \n", "Time: 49.8736 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", "Searching for the initial direction on 100 random directions: \n", "--------> Found distortion 23.6498\n", "--------> Found distortion 20.7610\n", "--------> Found distortion 20.7439\n", "--------> Found distortion 17.3456\n", "==========> Found best distortion 17.3456 in 0.1623 seconds using 221 queries\n", "Iteration 10 distortion 9.3120 num_queries 2355\n", "Iteration 20 distortion 7.1715 num_queries 4629\n", "Iteration 30 distortion 5.4653 num_queries 6854\n", "Iteration 40 distortion 4.8085 num_queries 8988\n", "Iteration 50 distortion 4.4135 num_queries 11101\n", "Iteration 60 distortion 4.0934 num_queries 13186\n", "Iteration 70 distortion 3.8067 num_queries 15194\n", "Iteration 80 distortion 3.6572 num_queries 17180\n", "Iteration 90 distortion 3.4646 num_queries 19261\n", "Iteration 100 distortion 3.3341 num_queries 21284\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 3.2430 num_queries 23226\n", "Iteration 120 distortion 3.1915 num_queries 25115\n", "Iteration 130 distortion 3.1226 num_queries 26988\n", "Iteration 140 distortion 3.0539 num_queries 28884\n", "Iteration 150 distortion 2.9924 num_queries 30774\n", "Iteration 160 distortion 2.9570 num_queries 32651\n", "Iteration 170 distortion 2.9154 num_queries 34555\n", "Iteration 180 distortion 2.8836 num_queries 36393\n", "Iteration 190 distortion 2.8453 num_queries 38233\n", "Iteration 200 distortion 2.8207 num_queries 40091\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 210 distortion 2.8043 num_queries 41940\n", "Iteration 220 distortion 2.7745 num_queries 43776\n", "Iteration 230 distortion 2.7517 num_queries 45628\n", "Iteration 240 distortion 2.7358 num_queries 47492\n", "Iteration 250 distortion 2.7215 num_queries 49326\n", "Iteration 260 distortion 2.7041 num_queries 51195\n", "Iteration 270 distortion 2.6871 num_queries 53015\n", "Iteration 280 distortion 2.6741 num_queries 54883\n", "Iteration 290 distortion 2.6593 num_queries 56748\n", "Iteration 300 distortion 2.6501 num_queries 58683\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 310 distortion 2.6432 num_queries 60545\n", "Iteration 320 distortion 2.6333 num_queries 62454\n", "Iteration 330 distortion 2.6236 num_queries 64393\n", "Iteration 340 distortion 2.6142 num_queries 66255\n", "Warning: not moving, g2 2.607182 gtheta 2.607182\n", "Iteration 350 distortion 2.6072 num_queries 68370\n", "Warning: not moving, g2 2.606903 gtheta 2.606903\n", "Warning: not moving, g2 2.606076 gtheta 2.606076\n", "Warning: not moving, g2 2.606057 gtheta 2.606057\n", "Warning: not moving, g2 2.606057 gtheta 2.606057\n", "Warning: not moving, g2 2.606056 gtheta 2.606056\n", "\n", "Adversarial Example Found Successfully: distortion 2.6061 target 4 queries 74435 \n", "Time: 51.8625 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: 4\n", "Searching for the initial direction on 100 random directions: \n", "--------> Found distortion 22.1668\n", "--------> Found distortion 18.3034\n", "--------> Found distortion 16.1457\n", "--------> Found distortion 15.0462\n", "--------> Found distortion 14.0748\n", "==========> Found best distortion 14.0748 in 0.1763 seconds using 256 queries\n", "Iteration 10 distortion 5.4833 num_queries 2467\n", "Iteration 20 distortion 3.7117 num_queries 4704\n", "Iteration 30 distortion 3.0331 num_queries 6807\n", "Iteration 40 distortion 2.6412 num_queries 8845\n", "Iteration 50 distortion 2.3391 num_queries 10805\n", "Iteration 60 distortion 2.1541 num_queries 12761\n", "Iteration 70 distortion 2.0816 num_queries 14674\n", "Iteration 80 distortion 1.9935 num_queries 16610\n", "Iteration 90 distortion 1.9405 num_queries 18597\n", "Iteration 100 distortion 1.8726 num_queries 20500\n" ], "name": "stdout" }, { "output_type": "display_data", "data": { "image/png": "iVBORw0KGgoAAAANSUhEUgAAAPsAAAD4CAYAAAAq5pAIAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjIsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+WH4yJAAATy0lEQVR4nO3dW2xd5ZUH8P+yc3Oce5yEkELTCQRx06SDCSACAiqqNEJK8kDUPKBw0ThIjdRIfRjEPBQRIRBM2+nDUMmZRE1HHUpFExEkNDQTVWL6UiWgALkwwKAktZXYiU1ujnOz1zx4BxnwXsvZ3zlnn3T9f1Jk+6yzz/68z1nZx2ft9X2iqiCiv30NZQ+AiGqDyU4UBJOdKAgmO1EQTHaiIMbUcmciYn70LyLm9tWsHDQ02P/vDQ4O5sa8cafGBwYGzHg1pRyXartaXy8A0NjYmBtLfb5VdcQDk5TsIrIUwC8BNAL4d1V9KeXxJkyYYMYvXryYG7t06VLKrjFp0iQzfurUqdzY+PHjzW29F8a4cePM+IkTJ8x4NaUcFwAYMyb/JZb6nFmPDdivl1RNTU1mvK+vz4xPmzYtN9bT01NoTJ7Cb+NFpBHAvwH4AYBbAKwWkVsqNTAiqqyUv9kXA/hMVT9X1QsAfgdgeWWGRUSVlpLs8wD8ddjPHdltXyEibSKyW0R2J+yLiBJV/QM6VW0H0A74H9ARUfWknNk7AVw37OdvZbcRUR1KSfZdAG4Uke+IyDgAPwSwvTLDIqJKk5RapIgsA/CvGCq9bVbVF6z7NzQ06NixY3Pj3lhSSinz58834wcPHiz82J5q14MnTpxYKAYAvb29Zjy1jm6V7s6cOWNu65W3+vv7C40JqP5z4pUsvd89RVXq7Kr6NoC3Ux6DiGqDl8sSBcFkJwqCyU4UBJOdKAgmO1EQTHaiIJLq7Fe8s8TLZa1W0AsXLqQ8dKmam5vN+NmzZ814ynPo7dtr1SyTV4c/f/58bsxrK/Z6yq3rRQD/ObPq/N7zaT1n/f39GBgYGPHBeWYnCoLJThQEk50oCCY7URBMdqIgmOxEQdS89JYyha7Vrun9Hl6pxJsl1WL9ToDfTpk6yypdOe85K3P67tT227wWV57ZiYJgshMFwWQnCoLJThQEk50oCCY7URBMdqIg6qrF1Wu3PHfuXG7Mq6Nb26by9u2t8po6rbC1Sqw3FXSZyx5XW0obqbdCrLfisNfiWs2lrllnJwqOyU4UBJOdKAgmO1EQTHaiIJjsREEw2YmCqGmdvbGxUa2edG8J3pQe4zKX0E11ww03mPE33ngjN7Zo0SJzW6+e7NXhZ8yYYcat11d3d7e5rWfVqlVm/K233sqNea+1ave7t7S05Ma816J3zUhVlmwWkYMATgMYAHBJVVtTHo+Iqicp2TMPqurxCjwOEVUR/2YnCiI12RXAH0XkPRFpG+kOItImIrtFZPfVfJ010dUu9W38ElXtFJHZAHaIyMeq+u7wO6hqO4B2YOgDusT9EVFBSWd2Ve3MvnYD2AZgcSUGRUSVVzjZRaRZRCZf/h7A9wHsrdTAiKiyUt7GzwGwLavDjgHwn6r6X9YGqmrOkW7VHgGgq6srN+b1lF+8eNGMW/V/wO5P9pb/9R77xIkTZvyRRx4x4wsXLsyNeTV6r87uxWfNmmXGrefU6/Pv6Ogw4+vWrTPj69evz40tXbrU3NarZafW2Y8fr30Bq3Cyq+rnAP6+gmMhoipi6Y0oCCY7URBMdqIgmOxEQTDZiYKoRCPMqKmqWdLwyh1WqebChQuFtwXs6ZgBu9XT27c3bbBX3lq7dq0Zt0p/t99+u7mtV/bbt2+fGb/33nvNuFWiSjnmALB//34zfv/99+fGvFKst+8yFc0DntmJgmCyEwXBZCcKgslOFASTnSgIJjtREEx2oiBqWmf3VHO6Z6+G77WpWlNqefXiqVOnmvE777zTjN90001m/IUXXsiNbdu2LemxvdbhnTt3mnHruFrtzgBw+PBhM37HHXeY8ccffzw3djVPkWZdI2C+TqsxGCKqP0x2oiCY7ERBMNmJgmCyEwXBZCcKgslOFETNl2xuamrKjff19RV+7NQavTUuAGhubs6NedMCt7bai9t6tfCenh4z7i3LXE3eks29vb25MW9ZZK+nfNOmTWb8oYceyo0tWbLE3PbQoUNmvJpSp0XPW7KZZ3aiIJjsREEw2YmCYLITBcFkJwqCyU4UBJOdKIia9rMPDg4m1dKtWrhXR/dqtv39/Wbcmo973rx55rZPPPGEGfeWJr7nnnvMeJmsOrrHW/bYe85uvfVWM27NiW8twT0aM2fONOPe2K1a+alTp8xtrTkCrMd1z+wisllEukVk77DbZojIDhH5NPs63XscIirXaN7G/xrA11eufwbATlW9EcDO7GciqmNusqvquwC+/l5tOYAt2fdbAKyo8LiIqMKK/s0+R1WPZN8fBTAn744i0gagreB+iKhCkj+gU1UVkdxuGlVtB9AOANb9iKi6ipbeukRkLgBkX7srNyQiqoaiyb4dwJrs+zUA3qzMcIioWty38SLyGoAHALSISAeAnwJ4CcDvReQpAIcArKrEYFJ60qdMmWJu6/UAe3V2q7Z58803m9s++uijZnzv3r1mPIU3p703X763fWq92vL000+bca8f/vTp07kx67oJwD8u3joEg4ODZtx7vVms602saxfcZFfV1Tmh77mjIqK6wctliYJgshMFwWQnCoLJThQEk50oiLpastkrj1m8EpFX6pg2bZoZt9ol16xZkxsDgFmzZpnxF1980Yyn8EpAXgnJK4emmDx5shl//vnnzXhLS4sZf/jhh3Nj3nLRXlnPa9WePXu2GZ84cWJuzMsDq9xpPd88sxMFwWQnCoLJThQEk50oCCY7URBMdqIgmOxEQdRVnf38+fNm3Go79Oqm1XT33XebcW+q6B07dlRyOF9h1XMBv0V1/PjxZtxb6tq6vuGVV14xt/Xq6F5rsHXcU68/8KaS9l7LVoutt++iy6zzzE4UBJOdKAgmO1EQTHaiIJjsREEw2YmCYLITBVHzOru1lK1XP7Rqk2PHji08JsDuVweA5ubm3JjX+/z6668XGlMleHX0+fPnm3Hr9wb8erJVj16wYIG5rVcL956zo0eP5sZSpnIGgC+++MKMe/MAWPv3Xk9Tp07NjZ08eTI3xjM7URBMdqIgmOxEQTDZiYJgshMFwWQnCoLJThREzevsVi3d61+2apNejX7MGPtX9frhrXnCOzs7zW3vuusuM+71nHs1Yavu6tWivfn2Dx06ZMa9Orw1B/p9991nbuuNbevWrWbc+t2t6z0A//XkXQNgLS8O2HMzeI/d29trxvO4Z3YR2Swi3SKyd9htz4lIp4jsyf4tK7R3IqqZ0byN/zWApSPc/gtVXZT9e7uywyKiSnOTXVXfBVDsfQMR1Y2UD+jWiciH2dv86Xl3EpE2EdktIrsT9kVEiYom+68ALACwCMARAD/Lu6Oqtqtqq6q2FtwXEVVAoWRX1S5VHVDVQQAbASyu7LCIqNIKJbuIzB3240oA9py+RFQ6t84uIq8BeABAi4h0APgpgAdEZBEABXAQwNrR7KyxsdFcB/348ePm9lY92uvb9nj1YqvOfuDAAXPblStXmvF33nnHjL/88stmfN68ebmxnp4ec1uvln3bbbeZcateDNjrlHtjGxgYMOOnTp0y41ZPuVcH9+bL9/r4vVr5jBkzcmNWHz5gH3PrugY32VV19Qg3b/K2I6L6wstliYJgshMFwWQnCoLJThQEk50oCCm6/GuhnYmo1WrqTQedOv2vxdu3VdLwynYbN2404ytWrDDjXnnLas+1xg34rb9ei6v3+rFKXN6+r732WjPe2mpflGlN9+yV3lJZbceAPV100RbWy1R1xP5dntmJgmCyEwXBZCcKgslOFASTnSgIJjtREEx2oiBqXme36oveUrXWks2pLYnV5E0VvXDhQjP+4IMPmvHTp0/nxmbNmmVu+/HHH5vxbdu2mfEJEyaY8Q0bNuTGnnzySXPbKVOmmHGvDm+9nrzXg9XSDNivxbKxzk4UHJOdKAgmO1EQTHaiIJjsREEw2YmCYLITBVHzJZst3tTBFq9u6tWDz507V3jfHm9sXq17z549Ztyaltjq6QaAyZMnm/GmpiYz7s0xYNW6rXEDfi/+9Om5q44BAE6ePJkb86Ye9+ro3nUd3jUCx44dK/zY1rUx1jHjmZ0oCCY7URBMdqIgmOxEQTDZiYJgshMFwWQnCuJvps7uqWYd3Zv/3JrXHUj/vVPmGffmy/eWRfZYvfYeb36DTz75pPBje8+Zx7tuw6qjA/ZxFxmxHf1L1joC1mvNPbOLyHUi8icR2S8i+0Tkx9ntM0Rkh4h8mn21r3AgolKN5m38JQA/UdVbANwN4EcicguAZwDsVNUbAezMfiaiOuUmu6oeUdX3s+9PAzgAYB6A5QC2ZHfbAsBew4iISnVFf7iIyHwA3wXwFwBzVPVIFjoKYE7ONm0A2ooPkYgqYdSfxovIJAB/ALBeVb/yqY0OXZk/4tX5qtquqq2qaq/CR0RVNapkF5GxGEr036rq1uzmLhGZm8XnAuiuzhCJqBLct/EyVAfYBOCAqv58WGg7gDUAXsq+vuk9VkNDg7m8sVfO6O6uz/9PvNJaKq9MNGfOiH9BAQA6OzvNbb0W2JkzZyZtPzg4mBvzlk2u5vTf3nPmHfPU0p1VbvVKb0XLmaMZ8b0AHgPwkYhcbqx+FkNJ/nsReQrAIQCrCo2AiGrCTXZV/TOAvP9qvlfZ4RBRtfByWaIgmOxEQTDZiYJgshMFwWQnCqKmLa6Dg4Nmy6RXX0xx/fXXm/HDhw9Xbd+pvJqwVa/22kS99tqenh4z7j1nLS0thfed2vprtZF6S5Vb1wcA/nHxpui2auXeNNbWtQ8nTpzIjfHMThQEk50oCCY7URBMdqIgmOxEQTDZiYJgshMFUVdTSU+dOtWMW3VXrzfaWr4X8OvF1jK63jTV1V4u2vvdUqSO/bHHHsuNeX3Zr776qhn3WM+ptxx0Ku93s+Z18Pr4rce2rg/gmZ0oCCY7URBMdqIgmOxEQTDZiYJgshMFwWQnCqLmdXar9un1lFvbTpkyxdw2tRZt1ZOtmikA9PX1Je170qRJZty7xsDizX9+zTXXmPGOjg4zvmvXrtzYhg0bzG0/+OADM+6x5gGw5toHgK6uLjPuPecTJ04049bYvPkLvF78PDyzEwXBZCcKgslOFASTnSgIJjtREEx2oiCY7ERBiFezE5HrAPwGwBwACqBdVX8pIs8B+EcAx7K7Pquqb1uP1djYqFZ/9NmzZ0c/8ivk1ZO9Or01Nm+eb28O8qampqS4xevb9vquvePi1fit392b097jzSs/ffr03Jg3r/vRo0fNuFdn9/LKmt/dY11voqpQ1RHvMJqLai4B+Imqvi8ikwG8JyI7stgvVPVfrni0RFRzo1mf/QiAI9n3p0XkAIB51R4YEVXWFf3NLiLzAXwXwF+ym9aJyIcisllERnzPJCJtIrJbRHYXvcyPiNKNOtlFZBKAPwBYr6qnAPwKwAIAizB05v/ZSNuparuqtqpqazXXciMi26iSXUTGYijRf6uqWwFAVbtUdUBVBwFsBLC4esMkolRussvQ6XgTgAOq+vNht88ddreVAPZWfnhEVCmjKb0tAfA/AD4CcLmO8iyA1Rh6C68ADgJYm32Yl6uhoUGtZXSt6ZoBv0yUYvbs2WbcalP1ylteae5qZi0fDNhLG3t/1nmvzWq3Flus1zHgvybGjRuXG/Namq2y3eDgYPHSm6r+GcBIG5s1dSKqL7yCjigIJjtREEx2oiCY7ERBMNmJgmCyEwXh1tkrujMRc2dW7RFIq1d7dVGvXbKhofj/i97UwF6rp9fimnJcvG1TnxOrZtzf3194W8BfLtpqr/Xq4N7z7bUte6xrSrwlm6323L6+PgwMDIxYZ+eZnSgIJjtREEx2oiCY7ERBMNmJgmCyEwXBZCcKotZ19mMADg27qQXA8ZoN4MrU69jqdVwAx1ZUJcf2bVWdNVKgpsn+jZ0PTULZWtoADPU6tnodF8CxFVWrsfFtPFEQTHaiIMpO9vaS92+p17HV67gAjq2omoyt1L/Ziah2yj6zE1GNMNmJgigl2UVkqYj8r4h8JiLPlDGGPCJyUEQ+EpE9IrK75LFsFpFuEdk77LYZIrJDRD7NvuavS1z7sT0nIp3ZsdsjIstKGtt1IvInEdkvIvtE5MfZ7aUeO2NcNTluNf+bXUQaAXwC4GEAHQB2AVitqvtrOpAcInIQQKuqln4BhojcD+AMgN+o6m3ZbS8D6FXVl7L/KKer6j/VydieA3Cm7GW8s9WK5g5fZhzACgCPo8RjZ4xrFWpw3Mo4sy8G8Jmqfq6qFwD8DsDyEsZR91T1XQC9X7t5OYAt2fdbMPRiqbmcsdUFVT2iqu9n358GcHmZ8VKPnTGumigj2ecB+OuwnztQX+u9K4A/ish7ItJW9mBGMGfYMltHAcwpczAjcJfxrqWvLTNeN8euyPLnqfgB3TctUdV/APADAD/K3q7WJR36G6yeaqejWsa7VkZYZvxLZR67osufpyoj2TsBXDfs529lt9UFVe3MvnYD2Ib6W4q66/IKutnX7pLH86V6WsZ7pGXGUQfHrszlz8tI9l0AbhSR74jIOAA/BLC9hHF8g4g0Zx+cQESaAXwf9bcU9XYAa7Lv1wB4s8SxfEW9LOOdt8w4Sj52pS9/rqo1/wdgGYY+kf8/AP9cxhhyxvV3AD7I/u0re2wAXsPQ27qLGPps4ykAMwHsBPApgP8GMKOOxvYfGFra+0MMJdbcksa2BENv0T8EsCf7t6zsY2eMqybHjZfLEgXBD+iIgmCyEwXBZCcKgslOFASTnSgIJjtREEx2oiD+H8N6YkGdHbndAAAAAElFTkSuQmCC\n", "text/plain": [ "
" ] }, "metadata": { "tags": [], "needs_background": "light" } }, { "output_type": "stream", "text": [ "Iteration 110 distortion 1.8309 num_queries 22403\n", "Iteration 120 distortion 1.7800 num_queries 24330\n", "Iteration 130 distortion 1.7447 num_queries 26409\n", "Iteration 140 distortion 1.7050 num_queries 28347\n", "Iteration 150 distortion 1.6700 num_queries 30230\n", "Iteration 160 distortion 1.6502 num_queries 32079\n", "Iteration 170 distortion 1.6253 num_queries 33957\n", "Iteration 180 distortion 1.6016 num_queries 35751\n", "Iteration 190 distortion 1.5790 num_queries 37495\n", "Iteration 200 distortion 1.5661 num_queries 39240\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 210 distortion 1.5491 num_queries 41130\n", "Iteration 220 distortion 1.5367 num_queries 42884\n", "Iteration 230 distortion 1.5283 num_queries 44610\n", "Warning: not moving, g2 1.523693 gtheta 1.523693\n", "Iteration 240 distortion 1.5237 num_queries 46616\n", "Warning: not moving, g2 1.522981 gtheta 1.522981\n", "Warning: not moving, g2 1.522977 gtheta 1.522977\n", "Warning: not moving, g2 1.522962 gtheta 1.522962\n", "Warning: not moving, g2 1.522901 gtheta 1.522901\n", "Warning: not moving, g2 1.522869 gtheta 1.522869\n", "\n", "Adversarial Example Found Successfully: distortion 1.5229 target 9 queries 53594 \n", "Time: 37.3649 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: 5\n", "Searching for the initial direction on 100 random directions: \n", "--------> Found distortion 14.2197\n", "--------> Found distortion 12.1809\n", "--------> Found distortion 11.1767\n", "--------> Found distortion 10.2726\n", "--------> Found distortion 10.2309\n", "--------> Found distortion 9.9485\n", "--------> Found distortion 9.5018\n", "--------> Found distortion 9.0070\n", "==========> Found best distortion 9.0070 in 0.2479 seconds using 357 queries\n", "Iteration 10 distortion 5.4451 num_queries 2262\n", "Iteration 20 distortion 3.9805 num_queries 4530\n", "Iteration 30 distortion 3.3886 num_queries 6698\n", "Iteration 40 distortion 3.0639 num_queries 8676\n", "Iteration 50 distortion 2.8318 num_queries 10637\n", "Iteration 60 distortion 2.6765 num_queries 12581\n", "Iteration 70 distortion 2.5445 num_queries 14472\n", "Iteration 80 distortion 2.4477 num_queries 16354\n", "Iteration 90 distortion 2.3535 num_queries 18256\n", "Iteration 100 distortion 2.2842 num_queries 20100\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 2.2260 num_queries 22021\n", "Iteration 120 distortion 2.1609 num_queries 23957\n", "Iteration 130 distortion 2.1178 num_queries 25830\n", "Iteration 140 distortion 2.0742 num_queries 27730\n", "Iteration 150 distortion 2.0322 num_queries 29610\n", "Iteration 160 distortion 1.9967 num_queries 31511\n", "Iteration 170 distortion 1.9696 num_queries 33333\n", "Iteration 180 distortion 1.9523 num_queries 35237\n", "Iteration 190 distortion 1.9275 num_queries 37094\n", "Iteration 200 distortion 1.9076 num_queries 38955\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 210 distortion 1.8905 num_queries 40845\n", "Warning: not moving, g2 1.890442 gtheta 1.890442\n", "Warning: not moving, g2 1.890426 gtheta 1.890426\n", "Warning: not moving, g2 1.890421 gtheta 1.890421\n", "Warning: not moving, g2 1.889648 gtheta 1.889648\n", "Iteration 220 distortion 1.8896 num_queries 44476\n", "Warning: not moving, g2 1.889098 gtheta 1.889098\n", "Warning: not moving, g2 1.888660 gtheta 1.888660\n", "\n", "Adversarial Example Found Successfully: distortion 1.8887 target 8 queries 47789 \n", "Time: 32.7883 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: 6\n", "Searching for the initial direction on 100 random directions: \n", "--------> Found distortion 10.9227\n", "--------> Found distortion 10.0284\n", "--------> Found distortion 9.1624\n", "--------> Found distortion 8.3492\n", "--------> Found distortion 8.3489\n", "--------> Found distortion 7.9666\n", "==========> Found best distortion 7.9666 in 0.2366 seconds using 314 queries\n", "Iteration 10 distortion 3.1855 num_queries 2240\n", "Iteration 20 distortion 2.5788 num_queries 4191\n", "Iteration 30 distortion 2.1809 num_queries 6231\n", "Iteration 40 distortion 1.9028 num_queries 8144\n", "Iteration 50 distortion 1.6895 num_queries 10126\n", "Iteration 60 distortion 1.5970 num_queries 11921\n", "Iteration 70 distortion 1.5173 num_queries 13719\n", "Iteration 80 distortion 1.4408 num_queries 15474\n", "Iteration 90 distortion 1.3985 num_queries 17200\n", "Iteration 100 distortion 1.3525 num_queries 19000\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 1.3118 num_queries 20752\n", "Iteration 120 distortion 1.2730 num_queries 22568\n", "Iteration 130 distortion 1.2480 num_queries 24328\n", "Iteration 140 distortion 1.2282 num_queries 26079\n", "Iteration 150 distortion 1.2108 num_queries 27799\n", "Iteration 160 distortion 1.1943 num_queries 29548\n", "Iteration 170 distortion 1.1722 num_queries 31323\n", "Iteration 180 distortion 1.1558 num_queries 33153\n", "Iteration 190 distortion 1.1458 num_queries 34919\n", "Iteration 200 distortion 1.1339 num_queries 36679\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 210 distortion 1.1283 num_queries 38431\n", "Iteration 220 distortion 1.1198 num_queries 40159\n", "Iteration 230 distortion 1.1100 num_queries 41875\n", "Iteration 240 distortion 1.1017 num_queries 43615\n", "Iteration 250 distortion 1.0953 num_queries 45400\n", "Iteration 260 distortion 1.0885 num_queries 47170\n", "Iteration 270 distortion 1.0850 num_queries 48936\n", "Iteration 280 distortion 1.0800 num_queries 50702\n", "Iteration 290 distortion 1.0740 num_queries 52474\n", "Warning: not moving, g2 1.074027 gtheta 1.074027\n", "Warning: not moving, g2 1.073428 gtheta 1.073428\n", "Iteration 300 distortion 1.0734 num_queries 54965\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": [ "Warning: not moving, g2 1.073398 gtheta 1.073398\n", "Warning: not moving, g2 1.073356 gtheta 1.073356\n", "Warning: not moving, g2 1.073356 gtheta 1.073356\n", "Warning: not moving, g2 1.073356 gtheta 1.073356\n", "\n", "Adversarial Example Found Successfully: distortion 1.0734 target 8 queries 60454 \n", "Time: 42.0288 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: 7\n", "Searching for the initial direction on 100 random directions: \n", "--------> Found distortion 11.0201\n", "--------> Found distortion 9.6334\n", "--------> Found distortion 9.3704\n", "--------> Found distortion 8.1277\n", "--------> Found distortion 8.0221\n", "==========> Found best distortion 8.0221 in 0.2280 seconds using 298 queries\n", "Iteration 10 distortion 3.8324 num_queries 2332\n", "Iteration 20 distortion 2.7913 num_queries 4506\n", "Iteration 30 distortion 2.5182 num_queries 6416\n", "Iteration 40 distortion 2.1687 num_queries 8427\n", "Iteration 50 distortion 1.9964 num_queries 10417\n", "Iteration 60 distortion 1.9104 num_queries 12345\n", "Iteration 70 distortion 1.7952 num_queries 14233\n", "Iteration 80 distortion 1.7457 num_queries 16167\n", "Iteration 90 distortion 1.6874 num_queries 18094\n", "Iteration 100 distortion 1.6291 num_queries 19981\n" ], "name": "stdout" }, { "output_type": "display_data", "data": { "image/png": "iVBORw0KGgoAAAANSUhEUgAAAPsAAAD4CAYAAAAq5pAIAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjIsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+WH4yJAAAT8UlEQVR4nO3dbWyVZZoH8P/VUt5KeWlxsTiwMGgwzfrCBskSq47RnQhfcBKV4cNGk9FiMmPGOLoa9sOgyRhddcf5sJnY2SHDbBgJcWYcE0mEJSTd8cNENKgouiAUBugLUqAtBWpPr/1wHiYV+1zX4dznnOfA/f8lTdtz9Xmeu0/P1fNyPdd9i6qCiK58NVkPgIgqg8lOFAkmO1EkmOxEkWCyE0ViQiUPJiLmW/81NcX/7xkdHS16WwCYMME+FSMjI6kxETG3Da14eOfF+t0nTpxobjs8PGzGy/m71dbWmvFcLlf0vrMWct5Cz7mqjruDoGQXkXsA/AJALYD/UtUXQvY3depUM27dqYeGhkIOjdmzZ5vx7u7u1FhdXZ25rZdQXjJPmzbNjPf396fGmpubzW0PHTpkxidPnmzGz549a8YtM2bMMON9fX1F7xuwk8b7R2P9cy+E9+Dx1VdfpcbKdc6LfigVkVoA/wlgBYAWAGtEpKXY/RFReYW8Zl8GYL+qHlDVYQCbAawqzbCIqNRCkv0aAH8d8/2R5LavEZE2EdklIrsCjkVEgcr+Bp2qtgNoB/w36IiofEIe2Y8CmDfm+28ltxFRFQpJ9vcAXCciC0VkIoDvA3irNMMiolKTkDqpiKwE8CrypbcNqvoz6+dramrUKit45ZDBwcHU2JQpU8xtvZqtV4+2jl3NQmr0haivrzfj1v3r/PnzRW8LhI190qRJZtwbW5asHDp//jxGR0dLX2dX1a0Atobsg4gqg5fLEkWCyU4UCSY7USSY7ESRYLITRYLJThSJoDr7JR9MRK1aejnrqqGuuuqq1Njx48fLeuxy1oRD+909VqtnaBtpCO/39oSeF8vMmTPN+KlTp8x4Wj87H9mJIsFkJ4oEk50oEkx2okgw2YkiwWQnikTFS2/l2ndoK2fItMbz5s1LjXnbAsCxY8fMuDfbqNVm6m3rzeDqzZI6MDBgxsvJG1tTU1NqrKenx9zWa5n2pnv2Zju2xu7NsmzNLjsyMpLa4spHdqJIMNmJIsFkJ4oEk50oEkx2okgw2YkiwWQnisQVU2f3eHVTbyVWa5VXr8XV27dXkz137pwZnz59emosdLpmr5XTa7+19h/aJuod26ple7+3tcpqIfFyslpgBwYGMDIywjo7UcyY7ESRYLITRYLJThQJJjtRJJjsRJFgshNFImgV16IOaNQ+vZ7zkKmkvb5uq0cYAA4cOJAaa2hoMLc9c+aMGff64b0plzs7O1Nj3pLK06ZNM+Mhff6AfQ2BV2dvbGw04x6rln7y5Elz2+bmZjPuXRtx+vRpMx7Cuj9Yv3NQsotIJ4ABADkAI6q6NGR/RFQ+pXhkv1NVvyzBfoiojPianSgSocmuALaJyPsi0jbeD4hIm4jsEpFdgcciogChT+NbVfWoiPwdgO0i8pmqdoz9AVVtB9AOZNsIQxS7oEd2VT2afO4F8EcAy0oxKCIqvaKTXUTqRaThwtcAvgtgT6kGRkSlVXQ/u4h8G/lHcyD/cuB3qvozZ5uqfRo/a9YsM27VhL1adH9/vxn35j/3lvC1eu3Xr19vbrtw4UIz3traasa9sXvXL1jmz59vxgcHB824tZbAl1/aBSRrjgDA/5t6S0Jb582r4XvSlmwu+jW7qh4AcFPRIyKiimLpjSgSTHaiSDDZiSLBZCeKBJOdKBIVb3G1hCyTG1qu8FoerRbZ0GN7LaxLliwx488++2xqbPny5ea2hw8fNuPWsscA0N3dbcYt3tLE3tgWLFhgxk+cOJEa8+5rXuuux2vftaai9srA3n01DR/ZiSLBZCeKBJOdKBJMdqJIMNmJIsFkJ4oEk50oElfMks3essjeNNReXdVqWfTaGb1WTM8777xjxq2xe1NFey2qb7/9thl/8cUXzbh1DYG35LI3DXbIefeubfCWyfbOm7d/65oRLyetlupcLpfa4spHdqJIMNmJIsFkJ4oEk50oEkx2okgw2YkiwWQnisRlVWe3apOeSv6el+q+++4z44899pgZt/qfveWiT506Zcbnzp1rxr39v/rqq6mxLVu2mNteyaxprmfMmGFu6/Wzs85OFDkmO1EkmOxEkWCyE0WCyU4UCSY7USSY7ESRuKzq7BZrXnfA70+26p6A3w9v8eZHf/fdd824t3zw/v37U2Pe0sS33XabGe/t7TXjDQ0NZtw6/urVq81te3p6zLg19zpg9/J71wd4eeHNExCyf6/P35q/YGRkpPg6u4hsEJFeEdkz5rZGEdkuIvuSz/as9kSUuUKexv8GwD0X3fYMgB2qeh2AHcn3RFTF3GRX1Q4AfRfdvArAxuTrjQDuLfG4iKjEil3rbY6qdiVfdwOYk/aDItIGoK3I4xBRiQQv7Kiqar3xpqrtANqB8r5BR0S2YktvPSLSDADJZ/stWyLKXLHJ/haAB5OvHwTwp9IMh4jKxa2zi8jrAL4DYDaAHgA/BfAmgC0A5gM4BOABVb34Tbzx9mUezJoPG7Br3eW+XsCao9xbi7ulpcWMd3R0mPGDBw+a8VtuuSU1tnjxYnPbO+64w4w/9dRTZtxbS9yqR3tz0t9///1mPOTah9DrKrz7auj67pZFixalxo4cOYJz586NW2d3X7Or6pqU0F2FDY2IqgEvlyWKBJOdKBJMdqJIMNmJIsFkJ4pE8BV0pTRlyhQzHrr0scWbptorr1luuOEGM97Y2GjGvfJXU1NTasxrE21vbzfjK1asMOPLly8341Ybqtd2HFJaK7dylta8du0vvviiqP3ykZ0oEkx2okgw2YkiwWQnigSTnSgSTHaiSDDZiSJR0Tq7iJjT5Hp1dKsWbrWgAsD58+fNeEiLrDdV9Nq1a824V+Nfsyat8TBv+/btqbHQVs67777bjHsGBgZSYzt37gzad4hqruF71x9Y9zdrWz6yE0WCyU4UCSY7USSY7ESRYLITRYLJThQJJjtRJCpeZ7fqviE1Ya+O7i2x69XK+/v7U2NeP/q2bdvM+J133mnGb7rpJjNu9ct7U0nfdZc9SbB33rzrE6z4Sy+9ZG67adMmM3727FkzfqUaGhoqajs+shNFgslOFAkmO1EkmOxEkWCyE0WCyU4UCSY7USTcJZtLejBnyeaGhgZze6s32ptr26vhX3311Wa8q6srNWb16APA/PnzzfiHH35oxgtYVtuMh/jss8/M+COPPGLGt27dmhrz/t4bNmww448++qgZt+asD+UtVe1d92HVyr2/p3VfP3fuHEZHR8fdgfvILiIbRKRXRPaMuW29iBwVkd3Jx0pvP0SUrUKexv8GwD3j3P5zVb05+Uj/901EVcFNdlXtANBXgbEQURmFvEH3IxH5KHman/oCRkTaRGSXiOwKOBYRBSo22X8JYBGAmwF0AXgl7QdVtV1Vl6rq0iKPRUQlUFSyq2qPquZUdRTArwAsK+2wiKjUikp2EWke8+33AOxJ+1kiqg5unV1EXgfwHQCzAfQA+Gny/c0AFEAngLWqml6ITtTW1qrVH+3VJi3etl5d9OTJk0Ufe+7cuWbc6oUH/J7yN99885LHdIHX871x40Yz/uSTT5rx6dOnm/FXXkl9hefOh+/x5rS31jH35o0/c+aMGfeu2/Bq5db+vW299RVUddwduJNXqOp4f5Ffe9sRUXXh5bJEkWCyE0WCyU4UCSY7USSY7ESRqKoWV29KZms5Wm+Z2/r6ejPuLfl84sSJ1Jg3DbU3Nu/Y119/vRl/4oknUmNHjhwxt33uuefMuDc2r6zY0tKSGtu8ebO5rTVFNgDs27fPjK9YsSI11tdnt3t40zWHLvlstd+GLrOdVnrjIztRJJjsRJFgshNFgslOFAkmO1EkmOxEkWCyE0WionX2mpoaraurS40PDw+b21vtlN62XtxbmthqFa2trTW39ers1jkByjslcihvCm+r/ddrUX3ttdfM+OHDh834rbfemho7fvy4ue3IyIgZ9+RyuaDtQ7DOThQ5JjtRJJjsRJFgshNFgslOFAkmO1EkmOxEkaiqfnaP1efr9fh6SzKfPn3ajFt1dq/W7NXZQ3lL+Fq86wu8KbrLeQ2A1+++evVqM75u3brU2Msvv2xuO2GCPfGyV0f37o8hdXzrbzY0NIRcLsc6O1HMmOxEkWCyE0WCyU4UCSY7USSY7ESRYLITReKyqrOX05QpU8y4VWe/9tprzW27u7vNuNcP710DYJk0aZIZD1kmG/Dr0SH15BtvvNGM79y504xb6xAsWLDA3Nbrd/fyxlsq29LU1GTGrTUMgIB+dhGZJyI7ReRTEflERH6c3N4oIttFZF/y2V4AnYgyVcjT+BEAP1HVFgD/BOCHItIC4BkAO1T1OgA7ku+JqEq5ya6qXar6QfL1AIC9AK4BsArAxuTHNgK4t1yDJKJw9guui4jIAgBLAPwFwBxV7UpC3QDmpGzTBqCt+CESUSkU/G68iEwD8HsAj6vq11bz0/y7FeO+Y6Gq7aq6VFWXBo2UiIIUlOwiUod8om9S1T8kN/eISHMSbwbQW54hElEpuKU3ERHkX5P3qerjY25/CcAJVX1BRJ4B0Kiq/2rtq6amRq1SjdcuaW3rlXhmzpxpxr2WRKuEderUKXPb0DZQbwnfWbPSCyFemcYr+3mlO29JZ6tsGFr2ffrpp834888/nxp74403zG0feughM+6N3Wstts6rVw7Np2T6uNJKb4W8Zr8VwL8A+FhEdie3rQPwAoAtIvIDAIcAPFDAvogoI26yq+qfAaT9K7mrtMMhonLh5bJEkWCyE0WCyU4UCSY7USSY7ESRuKxaXEPq7N6UyYODg2bcWi66v78/NeZtC/i1bm9J597e7K5n8q5f8K5BKKfPP/88NWZdmwAAy5YtM+OdnZ3FDKkgoW3DXLKZKHJMdqJIMNmJIsFkJ4oEk50oEkx2okgw2YkiUdE6e2g/e4jQ2mVzc3NqrKurKzVWCK9nfMaMGWa8nHX2+vp6Mx4yZbLHm2PAY/Xae3+zrVu3mvGHH37YjHtLOlv3t9BrF1hnJ4ock50oEkx2okgw2YkiwWQnigSTnSgSTHaiSFxW/eyTJ09OjXnzdJeTNY834C8H7dWTvd/Nm0e8Wnk1fO/ah5Dlpjs6Osy4twx3a2urGfeWfLauKfH+3tb8CIODg8jlcqyzE8WMyU4UCSY7USSY7ESRYLITRYLJThQJJjtRJNxVXEVkHoDfApgDQAG0q+ovRGQ9gEcAXCgorlNVswlYRMzeba/n3Jvb3eLNE37y5Mmi9z116lQzfubMGTPu/d5eP7u1Bro3J73Xd+1paGgw4wMDA6kx77xY11WEuv3228343r17zfjixYvN+MGDB82493cph0LWZx8B8BNV/UBEGgC8LyLbk9jPVfXl8g2PiEqlkPXZuwB0JV8PiMheANeUe2BEVFqX9JpdRBYAWALgL8lNPxKRj0Rkg4iM+zxZRNpEZJeI7KrmSzeJrnQFJ7uITAPwewCPq2o/gF8CWATgZuQf+V8ZbztVbVfVpaq61LuGnIjKp6BkF5E65BN9k6r+AQBUtUdVc6o6CuBXAOyV8IgoU26yS/7h+NcA9qrqf4y5fex0q98DsKf0wyOiUnFbXEWkFcD/AvgYwIVezHUA1iD/FF4BdAJYm7yZZ+3LPJhXwhoaGkqN1dTY/7dCpyW2zJ0714wfO3bMjJezPOa9dAqNe+c9ZHpw79heObWvr6/oY3u89lyvrGjxWqKtFlhVTZ1KupB34/8MYLyN7Ym1iaiq8Ao6okgw2YkiwWQnigSTnSgSTHaiSDDZiSJxWU0lHXhsM15XV2fGrVq3Vwf36qbessdeHd5qG7auTSiFkOsbrCWVAWB4eNiMh/zNvGN71wd4f/NyXjth7TuXy3HJZqLYMdmJIsFkJ4oEk50oEkx2okgw2YkiwWQnikSl6+zHARwac9NsAF9WbACXplrHVq3jAji2YpVybH+vqleNF6hosn/j4PlJKJdmNgBDtY6tWscFcGzFqtTY+DSeKBJMdqJIZJ3s7Rkf31KtY6vWcQEcW7EqMrZMX7MTUeVk/chORBXCZCeKRCbJLiL3iMjnIrJfRJ7JYgxpRKRTRD4Wkd0isivjsWwQkV4R2TPmtkYR2S4i+5LP9uTplR3behE5mpy73SKyMqOxzRORnSLyqYh8IiI/Tm7P9NwZ46rIeav4a3YRqQXwfwD+GcARAO8BWKOqn1Z0IClEpBPAUlXN/AIMEbkdwCCA36rqPyS3/TuAPlV9IflHOUtVn66Ssa0HMJj1Mt7JakXNY5cZB3AvgIeQ4bkzxvUAKnDesnhkXwZgv6oeUNVhAJsBrMpgHFVPVTsAXLysySoAG5OvNyJ/Z6m4lLFVBVXtUtUPkq8HAFxYZjzTc2eMqyKySPZrAPx1zPdHUF3rvSuAbSLyvoi0ZT2YccwZs8xWN4A5WQ5mHO4y3pV00TLjVXPuiln+PBTfoPumVlX9RwArAPwwebpalTT/GqyaaqcFLeNdKeMsM/43WZ67Ypc/D5VFsh8FMG/M999KbqsKqno0+dwL4I+ovqWoey6soJt87s14PH9TTct4j7fMOKrg3GW5/HkWyf4egOtEZKGITATwfQBvZTCObxCR+uSNE4hIPYDvovqWon4LwIPJ1w8C+FOGY/maalnGO22ZcWR87jJf/jxZ4rWiHwBWIv+O/BcA/i2LMaSM69sAPkw+Psl6bABeR/5p3VfIv7fxAwBNAHYA2AfgfwA0VtHY/hv5pb0/Qj6xmjMaWyvyT9E/ArA7+ViZ9bkzxlWR88bLZYkiwTfoiCLBZCeKBJOdKBJMdqJIMNmJIsFkJ4oEk50oEv8PNaCHlwVaRkMAAAAASUVORK5CYII=\n", "text/plain": [ "
" ] }, "metadata": { "tags": [], "needs_background": "light" } }, { "output_type": "stream", "text": [ "Iteration 110 distortion 1.5754 num_queries 21751\n", "Iteration 120 distortion 1.5431 num_queries 23541\n", "Iteration 130 distortion 1.5121 num_queries 25276\n", "Iteration 140 distortion 1.4905 num_queries 27130\n", "Iteration 150 distortion 1.4658 num_queries 29028\n", "Iteration 160 distortion 1.4406 num_queries 30794\n", "Iteration 170 distortion 1.4260 num_queries 32516\n", "Iteration 180 distortion 1.4133 num_queries 34302\n", "Iteration 190 distortion 1.4006 num_queries 36073\n", "Warning: not moving, g2 1.387048 gtheta 1.387048\n", "Iteration 200 distortion 1.3870 num_queries 37933\n" ], "name": "stdout" }, { "output_type": "display_data", "data": { "image/png": "iVBORw0KGgoAAAANSUhEUgAAAPsAAAD4CAYAAAAq5pAIAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjIsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+WH4yJAAATLUlEQVR4nO3df2yVZZYH8O8pFrDlV1m0IQIrTPjDOskyimSjqLMZd2SIpqCJgT82asbtmMwYTCbZVTdx9A+N7q7LYtxMLDsKY0YJZnDhD7MZtsHoxGQQCQMIugKBAOHn8qsttIX27B99NRX7nlPuc+99r5zvJ2na3tPnfZ8+957e23ve53lEVUFEV7+6ojtARNXBZCcKgslOFASTnSgIJjtRENdU82QiYr71LyJme6tyUFdn/90aGBgw40We25Ny/JTfqxztU1S67ynHTmXdp965RxAf9hdPSnYRWQBgBYBRAP5TVV9KOV59fb0Z7+vry41de+21Ztvu7m4zPnbsWDN+4cKFip3b09DQYMa7urpyY2PGjDHb9vT0mPHU9hbvj9g119gPT+vxANiPJ+8PQW9vrxlPZd2n/f39ZlvrsWgp+WW8iIwC8B8AfgKgBcBSEWkp9XhEVFkp/7PPA7BHVfepah+ANQBay9MtIiq3lGS/AcDBId8fym77BhFpE5EtIrIl4VxElKjib9CpajuAdsB/g46IKiflmf0wgOlDvp+W3UZENSgl2T8BMFtEZorIaABLAGwoT7eIqNwkpZ4oIgsB/DsGS29vqOoLzs+bJ/PKPJcuXcqNeeUK79iVLrUUxSspWmM6krhXwrLGPaVsl8or63mPp9Q6vHX+lDFX1crU2VX1fQDvpxyDiKqDl8sSBcFkJwqCyU4UBJOdKAgmO1EQTHaiIKo6n72urg7jxo3LjXv1xZRauHdsjzUl8fz580nHTjV69OjcmDeNNHVcvHqzNc3UO7fXd8/Fixcrdm5rzAH/sWqtQeBNaS718cZndqIgmOxEQTDZiYJgshMFwWQnCoLJThRE0hTXKz6ZiFoljZQll72Vaa0yzEhYUxK91WW9VVC9+8Brb01j9co43ph7Uz29EpPXd0tjY6MZ91ZZnTRpUm7s1KlTZltv3LxxSbnPJ06caLa1xry3txcDAwPDTnHlMztREEx2oiCY7ERBMNmJgmCyEwXBZCcKgslOFETV6+wp7UeNGlVyW68u6k1ZtGq+qctYe0sqd3Z2mvEJEybkxrw6uneNwIkTJ8y4d32Ddf7U+yRlF1drzAC/b2fOnDHjlWTdZz09PayzE0XHZCcKgslOFASTnSgIJjtREEx2oiCY7ERBXDXz2T1ezTZli15vW2Tv+oCmpiYz7s3Ft/rm1aK9Mfe2ZPbmlFvjfu7cObOtdw2Ad/1Cd3d3bsxbKto7tjduXV1dZjwlD7ztniuyZbOI7AfQCaAfwCVVnZtyPCKqnHJsEvE3qnqyDMchogri/+xEQaQmuwL4g4h8KiJtw/2AiLSJyBYR2ZJ4LiJKkPoyfr6qHhaR6wFsFJHPVfXDoT+gqu0A2oH0iTBEVLqkZ3ZVPZx9Pg7gPQDzytEpIiq/kpNdRBpFZPxXXwP4MYCd5eoYEZVXysv4ZgDvZXXYawC8rar/7TWyaohW/RBI217Yq6t69WSrXuy19eqmJ0/axQxrm2vAnpv98ssvm21nzZplxu+66y4z7q2vbtXhvfvEuwbEa9/c3JwbO3TokNnWq7N7dfRK7mNQ6rUxJSe7qu4D8Feltiei6mLpjSgIJjtREEx2oiCY7ERBMNmJgijHRJgRExGzJJGyva/HW67ZY5U7vCms3rm9Usqdd95pxl988cXc2C233GK23bdvnxn3SkTWNFLALjumTjv2WOPuTUtOKfMCaaW1SpWg+cxOFASTnSgIJjtREEx2oiCY7ERBMNmJgmCyEwXxndqyOUVq7dKaxuoteXz+/PmSjw0AGzZsMOPeFFiLNy6bNm0y488++2zJ5/bq7N64eNNQres2ent7zbapeeH1PeX41u/d19fHLZuJomOyEwXBZCcKgslOFASTnSgIJjtREEx2oiC+U3V2a964t3SvN6e8knVRT2trqxn3atnWvG+vxu/NR7/++uvNuDeur7/+em7s3XffNdt6tXBvHQFrXIq8vz3edRvWGgGssxMRk50oCiY7URBMdqIgmOxEQTDZiYJgshMFUVN19pS6qaeSx/Y0Njaa8Y8++siMe3XXXbt25ca8tfhvuukmM+6Nm/e7dXZ25sYeeOABs+3evXvNuMeaL++Ni7cdtLcNtzfX3lpX3rsGwNLf3w9VLa3OLiJviMhxEdk55LbJIrJRRL7MPjeV3DsiqoqRvIxfBWDBZbc9BaBDVWcD6Mi+J6Ia5ia7qn4I4NRlN7cCWJ19vRrAojL3i4jKrNS93ppV9Uj29VEAzXk/KCJtANpKPA8RlUnyxo6qqtYbb6raDqAdKHbBSaLoSi29HRORqQCQfT5evi4RUSWUmuwbADycff0wgPXl6Q4RVYpbZxeRdwD8EMAUAMcA/ArAfwFYC2AGgAMAHlLVy9/EG+5Y5sm8NcwtqftpV9Ktt95qxj/44AMz/sUXX5jx2267LTc2bdo0s+19991nxtva7LdbZs2aZcat++Xjjz82295///1m/LvMqsN7j2Xr2oauri709/cPW2d3s0tVl+aEfuS1JaLawctliYJgshMFwWQnCoLJThQEk50oiOQr6K6UNX0vZdvkWjZjxgwz7m25vHz5cjM+ceLE3NipU3ZFdNWqVWb87rvvNuNz5swx40ePHs2NdXV1mW2vZt4y2ZZz586V1I7P7ERBMNmJgmCyEwXBZCcKgslOFASTnSgIJjtREFWts9fV1aGhoSE37tVdU5a99qbPpkyR9ZZ6XrZsWcnHBoDHH3/cjHd0dOTGrBo8AJw8edKM33vvvWbcq/la47p582azbS0rcmly63oTK0f4zE4UBJOdKAgmO1EQTHaiIJjsREEw2YmCYLITBVHVLZvr6urUWkK3p6enYuf25oynbNE7YcIEs+3ixYvN+GuvvWbGL1y4UPLxp0+fbrZ98MEHzfiCBZfv6flN3uPHip8+fdpse+ONN5rxSs6Hr3Qd3Tq+d25vu+mSt2wmoqsDk50oCCY7URBMdqIgmOxEQTDZiYJgshMFUdU6u7dlc+KxzXh9fb0Zt+r/gF1n92r4U6ZMMeM7duww40Wul797924z7m3pvH79+txYU1OT2fatt94y44899pgZT7k2wrsGwFsfwcsr67oOb20F69yXLl3CwMBAaXV2EXlDRI6LyM4htz0nIodFZFv2sdA7DhEVayQv41cBGO4yquWqOif7eL+83SKicnOTXVU/BGDvIURENS/lDbpfiMj27GV+7j9fItImIltEZEvCuYgoUanJ/msA3wMwB8ARAK/k/aCqtqvqXFWdW+K5iKgMSkp2VT2mqv2qOgBgJYB55e0WEZVbSckuIlOHfLsYwM68nyWi2uDW2UXkHQA/BDAFwDEAv8q+nwNAAewH8DNVPeKezKmze+uvW3OIvTm+Xp394sWLZtzi1dm9uc/enPE1a9aY8dGjR+fGrFozALz55ptm/Omnnzbj3n22YsWK3NiiRYvMtl7fvXGzrl/wHg9HjtgP5+uuu86Mnzlzxoyn1Nmtx7qq5s5ndzeJUNWlw9z8G68dEdUWXi5LFASTnSgIJjtREEx2oiCY7ERB1NQUV2+a6dixY3Nj3tbB3lLR1rEBeznn8ePHm23Pnj1rxr0y0O23327GH3300dzYwYMHzbavvJJ78SMAv6TpTfWcOXNmbuztt98227a0tJjxrVu3mvHW1tbcmLdsubd8d3d3txkvEpeSJgqOyU4UBJOdKAgmO1EQTHaiIJjsREEw2YmCqHqd3dqO1psKak2n9KYFelNYvTq7VZdNnT7rLWvs1XxTpud6y1SnPj6sqaBWHRwAVq5cacaPHj1qxufPn58b27t3r9k2ZQvvorHOThQck50oCCY7URBMdqIgmOxEQTDZiYJgshMFUVPz2VN4c+FTttAF7Dq7t5R0V1eXGffmhFtLRXu8+ejetQ2eSj5+1q5da8a9pahfeOGF3Njzzz9fUp++C1hnJwqOyU4UBJOdKAgmO1EQTHaiIJjsREEw2YmCuGrq7Km8Or1l0qRJZtwbY2uOP+CviW9dA+DV6L258p5Kzvu++eabzfjmzZvNeENDQ25s9uzZZtsDBw6Yce/6hJTf23s8eOcuuc4uItNFZJOI7BKRz0RkWXb7ZBHZKCJfZp+bvGMRUXFG8jL+EoBfqmoLgL8G8HMRaQHwFIAOVZ0NoCP7nohqlJvsqnpEVbdmX3cC2A3gBgCtAFZnP7YagH3tIhEVyr4o+zIiciOAHwD4E4BmVT2ShY4CaM5p0wagrfQuElE5jPjdeBEZB+D3AJ5U1W+8Y6SD70AN+y6Uqrar6lxVnZvUUyJKMqJkF5F6DCb671R1XXbzMRGZmsWnAjhemS4SUTm4pTcZXGt4NYBTqvrkkNv/BcD/qepLIvIUgMmq+g/OsdQq1VRyed7UJZOtbZm9KaqnT5824x5rCW0A6O3tzY15pTFvCW6P17fU0p7liSeeMOOvvvpqbmzdunW5MQB45JFHzHhnZ6cZT3m8eW2t+7S/vz+39DaS/9nvAPB3AHaIyLbstmcAvARgrYj8FMABAA+N4FhEVBA32VX1jwDy/tT8qLzdIaJK4eWyREEw2YmCYLITBcFkJwqCyU4UBKe4ZiZOnGjGz549mxvzpiQ2NjaacatODvjTVK370FvGOnWKqldnt+r4KVtNA/71DZ9//nlurLl52Ku7v3bHHXeY8e3bt5vxInEpaaLgmOxEQTDZiYJgshMFwWQnCoLJThQEk50oiDB1dq8W7s0htuJevdg7t1cv9ur01nx579zefHZvXFKPX0nWEt979uwx23Z0dJjxJUuWmPGUvKqvrzfj3uONdXai4JjsREEw2YmCYLITBcFkJwqCyU4UBJOdKIgr2v6paFbN16tretvcVlLqtskp8937+vrMtp7U7YO9Or3Fu0+9ufhnzpzJjXnbPd9zzz1mfMaMGWb80KFDZtwat5RrH6wx4zM7URBMdqIgmOxEQTDZiYJgshMFwWQnCoLJThSEW2cXkekAfgugGYACaFfVFSLyHIC/B3Ai+9FnVPV973hW3darq6bs3+7VZD3WuVPr6J6GhgYzfv78+ZKP7dXBU+ejW3OzU9eNT3k8LFq0yIxv27bNjLe0tJjxY8eOmXGrzu7lgfV4s8Z0JBfVXALwS1XdKiLjAXwqIhuz2HJV/dcRHIOICjaS/dmPADiSfd0pIrsB3FDpjhFReV3Ra1sRuRHADwD8KbvpFyKyXUTeEJGmnDZtIrJFRLYk9ZSIkow42UVkHIDfA3hSVc8B+DWA7wGYg8Fn/leGa6eq7ao6V1XnlqG/RFSiESW7iNRjMNF/p6rrAEBVj6lqv6oOAFgJYF7luklEqdxkl8G3a38DYLeq/tuQ26cO+bHFAHaWv3tEVC7uUtIiMh/ARwB2APiq1vEMgKUYfAmvAPYD+Fn2Zp51LPNkKdMpveWYvRLSmDFjzLg1zTRlu+eR8Mpj1n2YOi5F8u4Tb8nl7u7u3Fg1l1CvtrylpEfybvwfAQzX2K2pE1Ht4BV0REEw2YmCYLITBcFkJwqCyU4UBJOdKIirZsvmsWPHmvGenh4zbm3vC9jLEntStz32lmu2pu8WuYQ2YP9ule5byvTalOsuRsIal5Qtvnt6etDf388tm4kiY7ITBcFkJwqCyU4UBJOdKAgmO1EQTHaiIKpdZz8B4MCQm6YAOFm1DlyZWu1brfYLYN9KVc6+/aWqXjdcoKrJ/q2Ti2yp1bXparVvtdovgH0rVbX6xpfxREEw2YmCKDrZ2ws+v6VW+1ar/QLYt1JVpW+F/s9ORNVT9DM7EVUJk50oiEKSXUQWiMgXIrJHRJ4qog95RGS/iOwQkW1F70+X7aF3XER2DrltsohsFJEvs8/D7rFXUN+eE5HD2dhtE5GFBfVtuohsEpFdIvKZiCzLbi907Ix+VWXcqv4/u4iMAvC/AP4WwCEAnwBYqqq7qtqRHCKyH8BcVS38AgwRuQtAF4Dfqur3s9v+GcApVX0p+0PZpKr/WCN9ew5AV9HbeGe7FU0dus04gEUAHkGBY2f06yFUYdyKeGafB2CPqu5T1T4AawC0FtCPmqeqHwI4ddnNrQBWZ1+vxuCDpepy+lYTVPWIqm7Nvu4E8NU244WOndGvqigi2W8AcHDI94dQW/u9K4A/iMinItJWdGeG0Txkm62jAJqL7Mww3G28q+mybcZrZuxK2f48Fd+g+7b5qnoLgJ8A+Hn2crUm6eD/YLVUOx3RNt7VMsw2418rcuxK3f48VRHJfhjA9CHfT8tuqwmqejj7fBzAe6i9raiPfbWDbvb5eMH9+VotbeM93DbjqIGxK3L78yKS/RMAs0VkpoiMBrAEwIYC+vEtItKYvXECEWkE8GPU3lbUGwA8nH39MID1BfblG2plG++8bcZR8NgVvv25qlb9A8BCDL4jvxfAPxXRh5x+zQLw5+zjs6L7BuAdDL6su4jB9zZ+CuAvAHQA+BLA/wCYXEN9ewuDW3tvx2BiTS2ob/Mx+BJ9O4Bt2cfCosfO6FdVxo2XyxIFwTfoiIJgshMFwWQnCoLJThQEk50oCCY7URBMdqIg/h/2N35VIT1SegAAAABJRU5ErkJggg==\n", "text/plain": [ "
" ] }, "metadata": { "tags": [], "needs_background": "light" } }, { "output_type": "stream", "text": [ "Warning: not moving, g2 1.387041 gtheta 1.387041\n", "Warning: not moving, g2 1.387041 gtheta 1.387041\n", "Warning: not moving, g2 1.387040 gtheta 1.387040\n", "Warning: not moving, g2 1.387040 gtheta 1.387040\n", "Warning: not moving, g2 1.387035 gtheta 1.387035\n", "\n", "Adversarial Example Found Successfully: distortion 1.3870 target 4 queries 43843 \n", "Time: 30.4667 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: 8\n", "Searching for the initial direction on 100 random directions: \n", "--------> Found distortion 21.9925\n", "--------> Found distortion 13.8548\n", "--------> Found distortion 13.7946\n", "--------> Found distortion 11.9700\n", "--------> Found distortion 11.9390\n", "--------> Found distortion 10.5300\n", "==========> Found best distortion 10.5300 in 0.2325 seconds using 319 queries\n", "Iteration 10 distortion 4.6115 num_queries 2340\n", "Iteration 20 distortion 3.2478 num_queries 4430\n", "Iteration 30 distortion 2.7375 num_queries 6482\n", "Iteration 40 distortion 2.3396 num_queries 8483\n", "Iteration 50 distortion 2.1509 num_queries 10426\n", "Iteration 60 distortion 1.9716 num_queries 12329\n", "Iteration 70 distortion 1.8488 num_queries 14231\n", "Iteration 80 distortion 1.7941 num_queries 16103\n", "Iteration 90 distortion 1.7303 num_queries 17999\n", "Iteration 100 distortion 1.6731 num_queries 19905\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 1.6218 num_queries 21733\n", "Iteration 120 distortion 1.5799 num_queries 23499\n", "Iteration 130 distortion 1.5496 num_queries 25223\n", "Iteration 140 distortion 1.5228 num_queries 26948\n", "Iteration 150 distortion 1.4983 num_queries 28708\n", "Iteration 160 distortion 1.4700 num_queries 30440\n", "Iteration 170 distortion 1.4415 num_queries 32197\n", "Iteration 180 distortion 1.4197 num_queries 33931\n", "Iteration 190 distortion 1.4040 num_queries 35694\n", "Iteration 200 distortion 1.3874 num_queries 37441\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 210 distortion 1.3708 num_queries 39158\n", "Iteration 220 distortion 1.3630 num_queries 40910\n", "Iteration 230 distortion 1.3517 num_queries 42674\n", "Iteration 240 distortion 1.3468 num_queries 44398\n", "Iteration 250 distortion 1.3396 num_queries 46194\n", "Iteration 260 distortion 1.3343 num_queries 47944\n", "Iteration 270 distortion 1.3268 num_queries 49679\n", "Warning: not moving, g2 1.320521 gtheta 1.320521\n", "Iteration 280 distortion 1.3205 num_queries 51669\n", "Warning: not moving, g2 1.320497 gtheta 1.320497\n", "Warning: not moving, g2 1.320496 gtheta 1.320496\n", "Warning: not moving, g2 1.320404 gtheta 1.320404\n", "Iteration 290 distortion 1.3197 num_queries 56580\n", "Warning: not moving, g2 1.319671 gtheta 1.319671\n", "Warning: not moving, g2 1.319668 gtheta 1.319668\n", "\n", "Adversarial Example Found Successfully: distortion 1.3197 target 6 queries 58765 \n", "Time: 40.9462 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: 9\n", "Searching for the initial direction on 100 random directions: \n", "--------> Found distortion 10.2435\n", "--------> Found distortion 9.5930\n", "--------> Found distortion 8.3625\n", "==========> Found best distortion 8.3625 in 0.1863 seconds using 259 queries\n", "Iteration 10 distortion 4.7027 num_queries 2164\n", "Iteration 20 distortion 3.4224 num_queries 4372\n", "Iteration 30 distortion 2.9647 num_queries 6455\n", "Iteration 40 distortion 2.6800 num_queries 8407\n", "Iteration 50 distortion 2.4188 num_queries 10390\n", "Iteration 60 distortion 2.3124 num_queries 12311\n", "Iteration 70 distortion 2.2107 num_queries 14257\n", "Iteration 80 distortion 2.1266 num_queries 16299\n", "Iteration 90 distortion 2.0559 num_queries 18246\n", "Iteration 100 distortion 1.9940 num_queries 20143\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 1.8980 num_queries 22058\n", "Iteration 120 distortion 1.8586 num_queries 23978\n", "Iteration 130 distortion 1.8062 num_queries 25881\n", "Warning: not moving, g2 1.792409 gtheta 1.792409\n", "Warning: not moving, g2 1.792409 gtheta 1.792409\n", "Warning: not moving, g2 1.792408 gtheta 1.792408\n", "Iteration 140 distortion 1.7891 num_queries 29757\n", "Warning: not moving, g2 1.789025 gtheta 1.789025\n", "Warning: not moving, g2 1.788392 gtheta 1.788392\n", "Warning: not moving, g2 1.788388 gtheta 1.788388\n", "\n", "Adversarial Example Found Successfully: distortion 1.7884 target 8 queries 33800 \n", "Time: 22.9623 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: 10\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" } } ] } ] }