bim-attack-on-mnist-dataset.ipynb

{"metadata":{"kernelspec":{"language":"python","display_name":"Python 3","name":"python3"},"language_info":{"name":"python","version":"3.10.13","mimetype":"text/x-python","codemirror_mode":{"name":"ipython","version":3},"pygments_lexer":"ipython3","nbconvert_exporter":"python","file_extension":".py"},"kaggle":{"accelerator":"nvidiaTeslaT4","dataSources":[{"sourceId":3004,"databundleVersionId":861823,"sourceType":"competition"},{"sourceId":242592,"sourceType":"datasetVersion","datasetId":102285}],"dockerImageVersionId":30698,"isInternetEnabled":true,"language":"python","sourceType":"notebook","isGpuEnabled":true}},"nbformat_minor":4,"nbformat":4,"cells":[{"cell_type":"code","source":"import torch\nimport torchvision\nimport torchvision.transforms as transforms\n\n# Define transformations for the training and testing data\ntransform = transforms.Compose([transforms.ToTensor()])\n\n# Load the training and test datasets\ntrain_dataset = torchvision.datasets.MNIST(root='./data', train=True, download=True, transform=transform)\ntest_dataset = torchvision.datasets.MNIST(root='./data', train=False, download=True, transform=transform)\n\ntrain_loader = torch.utils.data.DataLoader(dataset=train_dataset, batch_size=64, shuffle=True)\ntest_loader = torch.utils.data.DataLoader(dataset=test_dataset, batch_size=64, shuffle=False)\n","metadata":{"execution":{"iopub.status.busy":"2024-05-25T06:43:51.897843Z","iopub.execute_input":"2024-05-25T06:43:51.898087Z","iopub.status.idle":"2024-05-25T06:44:00.687149Z","shell.execute_reply.started":"2024-05-25T06:43:51.898064Z","shell.execute_reply":"2024-05-25T06:44:00.686053Z"},"trusted":true},"execution_count":1,"outputs":[{"name":"stdout","text":"Downloading http://yann.lecun.com/exdb/mnist/train-images-idx3-ubyte.gz\nFailed to download (trying next):\nHTTP Error 403: Forbidden\n\nDownloading https://ossci-datasets.s3.amazonaws.com/mnist/train-images-idx3-ubyte.gz\nDownloading https://ossci-datasets.s3.amazonaws.com/mnist/train-images-idx3-ubyte.gz to ./data/MNIST/raw/train-images-idx3-ubyte.gz\n","output_type":"stream"},{"name":"stderr","text":"100%|██████████| 9912422/9912422 [00:00<00:00, 14478057.54it/s]\n","output_type":"stream"},{"name":"stdout","text":"Extracting ./data/MNIST/raw/train-images-idx3-ubyte.gz to ./data/MNIST/raw\n\nDownloading http://yann.lecun.com/exdb/mnist/train-labels-idx1-ubyte.gz\nFailed to download (trying next):\nHTTP Error 403: Forbidden\n\nDownloading https://ossci-datasets.s3.amazonaws.com/mnist/train-labels-idx1-ubyte.gz\nDownloading https://ossci-datasets.s3.amazonaws.com/mnist/train-labels-idx1-ubyte.gz to ./data/MNIST/raw/train-labels-idx1-ubyte.gz\n","output_type":"stream"},{"name":"stderr","text":"100%|██████████| 28881/28881 [00:00<00:00, 1020528.34it/s]","output_type":"stream"},{"name":"stdout","text":"Extracting ./data/MNIST/raw/train-labels-idx1-ubyte.gz to ./data/MNIST/raw\n\nDownloading http://yann.lecun.com/exdb/mnist/t10k-images-idx3-ubyte.gz\n","output_type":"stream"},{"name":"stderr","text":"\n","output_type":"stream"},{"name":"stdout","text":"Failed to download (trying next):\nHTTP Error 403: Forbidden\n\nDownloading https://ossci-datasets.s3.amazonaws.com/mnist/t10k-images-idx3-ubyte.gz\nDownloading https://ossci-datasets.s3.amazonaws.com/mnist/t10k-images-idx3-ubyte.gz to ./data/MNIST/raw/t10k-images-idx3-ubyte.gz\n","output_type":"stream"},{"name":"stderr","text":"100%|██████████| 1648877/1648877 [00:00<00:00, 9424378.12it/s]\n","output_type":"stream"},{"name":"stdout","text":"Extracting ./data/MNIST/raw/t10k-images-idx3-ubyte.gz to ./data/MNIST/raw\n\nDownloading http://yann.lecun.com/exdb/mnist/t10k-labels-idx1-ubyte.gz\nFailed to download (trying next):\nHTTP Error 403: Forbidden\n\nDownloading https://ossci-datasets.s3.amazonaws.com/mnist/t10k-labels-idx1-ubyte.gz\nDownloading https://ossci-datasets.s3.amazonaws.com/mnist/t10k-labels-idx1-ubyte.gz to ./data/MNIST/raw/t10k-labels-idx1-ubyte.gz\n","output_type":"stream"},{"name":"stderr","text":"100%|██████████| 4542/4542 [00:00<00:00, 3589022.00it/s]","output_type":"stream"},{"name":"stdout","text":"Extracting ./data/MNIST/raw/t10k-labels-idx1-ubyte.gz to ./data/MNIST/raw\n\n","output_type":"stream"},{"name":"stderr","text":"\n","output_type":"stream"}]},{"cell_type":"code","source":"import torch.nn as nn\nimport torch.nn.functional as F\n\nclass SimpleCNN(nn.Module):\n    def __init__(self):\n        super(SimpleCNN, self).__init__()\n        self.conv1 = nn.Conv2d(1, 32, kernel_size=3)\n        self.conv2 = nn.Conv2d(32, 64, kernel_size=3)\n        self.fc1 = nn.Linear(64 * 12 * 12, 128)\n        self.fc2 = nn.Linear(128, 10)\n    \n    def forward(self, x):\n        x = F.relu(self.conv1(x))\n        x = F.max_pool2d(self.conv2(x), 2)\n        x = x.view(-1, 64 * 12 * 12)\n        x = F.relu(self.fc1(x))\n        x = self.fc2(x)\n        return x\n\n# Instantiate the model, define the loss function and the optimizer\nmodel = SimpleCNN()\ncriterion = nn.CrossEntropyLoss()\noptimizer = torch.optim.Adam(model.parameters(), lr=0.001)\n\n# Training the model\nnum_epochs = 5\nfor epoch in range(num_epochs):\n    for images, labels in train_loader:\n        outputs = model(images)\n        loss = criterion(outputs, labels)\n        \n        optimizer.zero_grad()\n        loss.backward()\n        optimizer.step()\n    \n    print(f'Epoch [{epoch+1}/{num_epochs}], Loss: {loss.item():.4f}')","metadata":{"execution":{"iopub.status.busy":"2024-05-25T06:44:00.688974Z","iopub.execute_input":"2024-05-25T06:44:00.689391Z","iopub.status.idle":"2024-05-25T06:48:31.831385Z","shell.execute_reply.started":"2024-05-25T06:44:00.689363Z","shell.execute_reply":"2024-05-25T06:48:31.830391Z"},"trusted":true},"execution_count":2,"outputs":[{"name":"stdout","text":"Epoch [1/5], Loss: 0.0372\nEpoch [2/5], Loss: 0.0135\nEpoch [3/5], Loss: 0.0023\nEpoch [4/5], Loss: 0.0017\nEpoch [5/5], Loss: 0.0008\n","output_type":"stream"}]},{"cell_type":"code","source":"import numpy as np\n\ndef bim_attack(model, images, labels, epsilon=0.1, alpha=0.01, num_iter=10):\n    model.eval()\n    perturbed_images = images.clone().detach().requires_grad_(True)\n    \n    for _ in range(num_iter):\n        perturbed_images.grad = None\n        outputs = model(perturbed_images)\n        loss = criterion(outputs, labels)\n        loss.backward()\n        \n        with torch.no_grad():\n            perturbed_images += alpha * perturbed_images.grad.sign()\n            perturbed_images = torch.clamp(perturbed_images, images - epsilon, images + epsilon)\n            perturbed_images = torch.clamp(perturbed_images, 0, 1)\n        \n        perturbed_images.requires_grad_(True)\n    \n    return perturbed_images\n\n# Evaluate the model on adversarial examples\ndef evaluate(model, data_loader):\n    model.eval()\n    correct = 0\n    total = 0\n    for images, labels in data_loader:\n        images, labels = images.to('cpu'), labels.to('cpu')\n        perturbed_images = bim_attack(model, images, labels)\n        outputs = model(perturbed_images)\n        _, predicted = torch.max(outputs.data, 1)\n        total += labels.size(0)\n        correct += (predicted == labels).sum().item()\n    \n    print(f'Accuracy of the model on the adversarial examples: {100 * correct / total}%')\n# Function to evaluate the model on normal test data\ndef evaluate_normal(model, data_loader):\n    model.eval()  # Set the model to evaluation mode\n    correct = 0\n    total = 0\n    \n    with torch.no_grad():  # No need to compute gradients for evaluation\n        for images, labels in data_loader:\n            images, labels = images.to('cpu'), labels.to('cpu')  # Move data to the same device as the model\n            outputs = model(images)\n            _, predicted = torch.max(outputs.data, 1)\n            total += labels.size(0)\n            correct += (predicted == labels).sum().item()\n    \n    accuracy = 100 * correct / total\n    print(f'Accuracy of the model on the normal test data: {accuracy:.2f}%')\n    return accuracy\n\n# Evaluate the model on the normal test dataset\nevaluate_normal(model, test_loader)\n\n# Evaluate the model on the test dataset with adversarial examples\nevaluate(model, test_loader)","metadata":{"execution":{"iopub.status.busy":"2024-05-25T06:48:31.833364Z","iopub.execute_input":"2024-05-25T06:48:31.833648Z","iopub.status.idle":"2024-05-25T06:50:00.238835Z","shell.execute_reply.started":"2024-05-25T06:48:31.833622Z","shell.execute_reply":"2024-05-25T06:50:00.238008Z"},"trusted":true},"execution_count":3,"outputs":[{"name":"stdout","text":"Accuracy of the model on the normal test data: 98.85%\nAccuracy of the model on the adversarial examples: 49.1%\n","output_type":"stream"}]},{"cell_type":"code","source":"import torch\nimport torchvision\nimport matplotlib.pyplot as plt\n\n# Function to visualize the original and adversarial images\ndef visualize_adversarial_examples(model, data_loader, epsilon=0.1, alpha=0.01, num_iter=10):\n    model.eval()\n    \n    # Get a batch of test images\n    images, labels = next(iter(data_loader))\n    \n    # Generate adversarial examples\n    perturbed_images = bim_attack(model, images, labels, epsilon, alpha, num_iter)\n    \n    # Plot the original and adversarial images\n    num_images = min(5, len(images))  # Number of images to display\n    fig, axes = plt.subplots(2, num_images, figsize=(10, 5))\n    \n    for i in range(num_images):\n        # Original image\n        axes[0, i].imshow(images[i].squeeze().numpy(), cmap='gray')\n        axes[0, i].set_title(f\"Original {labels[i].item()}\")\n        axes[0, i].axis('off')\n        \n        # Adversarial image\n        axes[1, i].imshow(perturbed_images[i].squeeze().detach().numpy(), cmap='gray')\n        axes[1, i].set_title(f\"Adversarial\")\n        axes[1, i].axis('off')\n    \n    plt.tight_layout()\n    plt.show()\n\n# Visualize the original and adversarial images\nvisualize_adversarial_examples(model, test_loader)","metadata":{"execution":{"iopub.status.busy":"2024-05-25T06:50:00.241057Z","iopub.execute_input":"2024-05-25T06:50:00.241521Z","iopub.status.idle":"2024-05-25T06:50:01.497647Z","shell.execute_reply.started":"2024-05-25T06:50:00.241486Z","shell.execute_reply":"2024-05-25T06:50:01.496714Z"},"trusted":true},"execution_count":4,"outputs":[{"output_type":"display_data","data":{"text/plain":"<Figure size 1000x500 with 10 Axes>","image/png":"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"},"metadata":{}}]}]}