{ "cells": [ { "cell_type": "markdown", "metadata": {}, "source": [ "# Generating Images to Fool an MNIST Classifier\n", "\n", "_This tutorial is part of the series of pyribs tutorials! See [here](https://docs.pyribs.org/en/stable/tutorials.html) for the list of all tutorials and the order in which they should be read._\n", "\n", "Despite their high performance on classification tasks such as MNIST, neural networks like the [LeNet-5](https://en.wikipedia.org/wiki/LeNet) have a weakness: they are easy to fool. Namely, given images like the ones below, a classifier may confidently believe that it is seeing certain digits, even though the images look like random noise to humans. Naturally, this phenomenon raises some concerns, especially when the network in question is used in a safety-critical system like a self-driving car. Given such unrecognizable input, one would hope that the network at least has low confidence in its prediction.\n", "\n", "![fooling images example](_static/fooling_mnist_example.png)\n", "\n", "To make matters worse for neural networks, generating such images is incredibly easy with QD algorithms. As shown in [Nguyen 2015](http://anhnguyen.me/project/fooling/), one can use simple MAP-Elites to generate these images. In this tutorial, we will use the pyribs version of MAP-Elites to do just that." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Setup\n", "\n", "First, we install pyribs and PyTorch." ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "%pip install ribs torch tqdm matplotlib" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Here, we import PyTorch and some utilities." ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "import time\n", "import sys\n", "\n", "import matplotlib.pyplot as plt\n", "import numpy as np\n", "import torch\n", "import torch.nn as nn\n", "from tqdm import tqdm, trange" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Below, we check what device is available for PyTorch. On Colab, activate the GPU by clicking \"Runtime\" in the toolbar at the top. Then, click \"Change Runtime Type\", and select \"GPU\"." ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "device = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")\n", "print(device)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Preliminary: MNIST Network\n", "\n", "We have pretrained a high-performing [LeNet-5](https://en.wikipedia.org/wiki/LeNet) classifier (98.4% training set accuracy, 98.5% test set accuracy) for the MNIST dataset using the code [here](https://github.com/icaros-usc/pyribs/tree/master/tutorials/mnist/train_mnist_classifier.py). This is the same network that we use in the [LSI MNIST](https://docs.pyribs.org/en/stable/tutorials/lsi_mnist.html) tutorial. Below, we define the network." ] }, { "cell_type": "code", "execution_count": 3, "metadata": {}, "outputs": [], "source": [ "LENET5 = nn.Sequential(\n", " nn.Conv2d(1, 6, (5, 5), stride=1, padding=0), # (1,28,28) -> (6,24,24)\n", " nn.MaxPool2d(2), # (6,24,24) -> (6,12,12)\n", " nn.ReLU(),\n", " nn.Conv2d(6, 16, (5, 5), stride=1, padding=0), # (6,12,12) -> (16,8,8)\n", " nn.MaxPool2d(2), # (16,8,8) -> (16,4,4)\n", " nn.ReLU(),\n", " nn.Flatten(), # (16,4,4) -> (256,)\n", " nn.Linear(256, 120), # (256,) -> (120,)\n", " nn.ReLU(),\n", " nn.Linear(120, 84), # (120,) -> (84,)\n", " nn.ReLU(),\n", " nn.Linear(84, 10), # (84,) -> (10,)\n", " nn.LogSoftmax(dim=1), # (10,) log probabilities\n", ").to(device)\n", "LENET5_MEAN_TRANSFORM = 0.1307\n", "LENET5_STD_DEV_TRANSFORM = 0.3081" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Now, we download the weights and load them into the network." ] }, { "cell_type": "code", "execution_count": 4, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "" ] }, "execution_count": 4, "metadata": {}, "output_type": "execute_result" } ], "source": [ "import os\n", "from urllib.request import urlretrieve\n", "from pathlib import Path\n", "\n", "LOCAL_DIR = Path(\"fooling_mnist_weights\")\n", "LOCAL_DIR.mkdir(exist_ok=True)\n", "WEB_DIR = \"https://raw.githubusercontent.com/icaros-usc/pyribs/master/tutorials/mnist/\"\n", "\n", "# Download the model file to LOCAL_DIR.\n", "filename = \"mnist_classifier.pth\"\n", "model_path = LOCAL_DIR / filename\n", "if not model_path.is_file():\n", " urlretrieve(WEB_DIR + filename, str(model_path))\n", "\n", "# Load the weights of the network.\n", "state_dict = torch.load(\n", " str(LOCAL_DIR / \"mnist_classifier.pth\"),\n", " map_location=device,\n", ")\n", "\n", "# Insert the weights into the network.\n", "LENET5.load_state_dict(state_dict)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Fooling the Classifier with MAP-Elites\n", "\n", "In order to fool the classifier into seeing various digits, we use MAP-Elites. As we have 10 distinct digits (0-9), we have a discrete measure space with 10 values. Note that while pyribs is designed for continuous search spaces, the measure space can be either continuous or discrete.\n", "\n", "Our classifier outputs a log probability vector with its belief that it is seeing each digit. Thus, our objective for each digit is to maximize the probability that the classifier assigns to the image associated with it. For instance, for digit 5, we want to generate an image that makes the classifier believe with high probability that it is seeing a 5.\n", "\n", "In pyribs, we implement MAP-Elites with a [`GridArchive`](https://docs.pyribs.org/en/stable/api/ribs.archives.GridArchive.html) and a [`GaussianEmitter`](https://docs.pyribs.org/en/stable/api/ribs.emitters.GaussianEmitter.html). Below, we start by constructing the `GridArchive`. The archive has 10 cells and a range of (0,10). Since `GridArchive` was originally designed for continuous spaces, it does not directly support discrete spaces, but by using these settings, we have a cell for each digit from 0 to 9." ] }, { "cell_type": "code", "execution_count": 5, "metadata": {}, "outputs": [], "source": [ "from ribs.archives import GridArchive\n", "img_size = (28, 28)\n", "flat_img_size = 784 # 28 * 28\n", "\n", "archive = GridArchive(solution_dim=flat_img_size, dims=[10], ranges=[(0, 10)])" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Next, we use a single `GaussianEmitter` with batch size of 30. The emitter begins with an image filled with 0.5 (i.e. grey, since pixels are in the range $[0,1]$) and has $\\sigma = 0.5$." ] }, { "cell_type": "code", "execution_count": 6, "metadata": {}, "outputs": [], "source": [ "from ribs.emitters import GaussianEmitter\n", "\n", "emitters = [\n", " GaussianEmitter(\n", " archive,\n", " sigma=0.5,\n", " # Start with a grey image.\n", " x0=np.full(flat_img_size, 0.5),\n", " # Bound the generated images to the pixel range.\n", " bounds=[(0, 1)] * flat_img_size,\n", " batch_size=30,\n", " )\n", "]" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Finally, we construct the scheduler to connect the archive and emitter together." ] }, { "cell_type": "code", "execution_count": 7, "metadata": {}, "outputs": [], "source": [ "from ribs.schedulers import Scheduler\n", "\n", "scheduler = Scheduler(archive, emitters)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "With the components created, we now generate the images. As we use 1 emitter with batch size of 30 and run 30,000 iterations, we evaluate 900,000 images in total." ] }, { "cell_type": "code", "execution_count": 8, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Iterations: 100%|████████████████████████████████████████████████████████████████████████████████████████████████████| 30000/30000 [00:55<00:00, 539.24it/s]\n" ] } ], "source": [ "total_itrs = 30_000\n", "start_time = time.time()\n", "\n", "for itr in trange(1, total_itrs + 1, file=sys.stdout, desc='Iterations'):\n", " sols = scheduler.ask()\n", "\n", " with torch.no_grad():\n", " # Reshape and normalize the image and pass it through the network.\n", " imgs = sols.reshape((-1, 1, *img_size))\n", " imgs = (imgs - LENET5_MEAN_TRANSFORM) / LENET5_STD_DEV_TRANSFORM\n", " imgs = torch.tensor(imgs, dtype=torch.float32, device=device)\n", " output = LENET5(imgs)\n", "\n", " # The measures is the digit that the network believes it is seeing,\n", " # i.e. the digit with the maximum probability. The objective is the\n", " # probability associated with that digit.\n", " scores, predicted = torch.max(output.to(\"cpu\"), 1)\n", " scores = torch.exp(scores)\n", " objs = scores.numpy()\n", " meas = predicted.numpy()[:,None]\n", "\n", " scheduler.tell(objs, meas)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Below, we display the images found. Interestingly, though the images look mostly like noise, we can occasionally make out traces of the original digit. Note that MAP-Elites may not find images for all the digits, and this is mostly due to the small behavior space. Usually, QD algorithms run with fairly large behavior spaces. This is something to keep in mind when tuning QD algorithms." ] }, { "cell_type": "code", "execution_count": 9, "metadata": {}, "outputs": [ { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "fig, ax = plt.subplots(2, 5, figsize=(10, 4))\n", "fig.tight_layout()\n", "ax = ax.flatten()\n", "found = set()\n", "\n", "# Display images.\n", "for elite in archive:\n", " digit = elite[\"index\"]\n", " found.add(digit)\n", "\n", " # No need to normalize image because we want to see the original.\n", " ax[digit].imshow(elite[\"solution\"].reshape(28, 28), cmap=\"Greys\")\n", " ax[digit].set_axis_off()\n", " ax[digit].set_title(f\"{digit} | Score: {elite['objective']:.3f}\", pad=8)\n", "\n", "# Mark digits that we did not generate images for.\n", "for digit in range(10):\n", " if digit not in found:\n", " ax[digit].set_title(f\"{digit} | (no solution)\", pad=8)\n", " ax[digit].set_axis_off()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Conclusion\n", "\n", "In this tutorial, we used MAP-Elites to generate images that fool a LeNet-5 MNIST classifier. For further exploration, we recommend referring to [Nguyen 2015](http://anhnguyen.me/project/fooling/) and replicating or extending the other experiments described in the paper." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Citation\n", "\n", "If you find this tutorial useful, please cite it as:\n", "\n", "```text\n", "@article{pyribs_fooling_mnist,\n", " title = {Generating Images to Fool an MNIST Classifier},\n", " author = {Bryon Tjanaka and Matthew C. Fontaine and Stefanos Nikolaidis},\n", " journal = {pyribs.org},\n", " year = {2021},\n", " url = {https://docs.pyribs.org/en/stable/tutorials/fooling_mnist.html}\n", "}\n", "```" ] } ], "metadata": { "kernelspec": { "display_name": "Python 3 (ipykernel)", "language": "python", "name": "python3" }, "language_info": { "codemirror_mode": { "name": "ipython", "version": 3 }, "file_extension": ".py", "mimetype": "text/x-python", "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", "version": "3.8.17" } }, "nbformat": 4, "nbformat_minor": 4 }