quantinuum_hnn_compound_adv_attack_poc.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "provenance": [],
      "machine_shape": "hm",
      "gpuType": "L4",
      "authorship_tag": "ABX9TyMYVa8hg+aT4xtIt/W7YIXB",
      "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": [
        "<a href=\"https://colab.research.google.com/github/ericyoc/quantinuum-hnn-compound-adv-attack-poc/blob/main/quantinuum_hnn_compound_adv_attack_poc.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "#!pip install pytket\n",
        "#!pip install pytket-qiskit\n",
        "#!pip install torchattacks"
      ],
      "metadata": {
        "id": "QgjCgDIgR41l"
      },
      "execution_count": 1,
      "outputs": []
    },
    {
      "cell_type": "code",
      "execution_count": 2,
      "metadata": {
        "id": "NP9XLjM0RqtV"
      },
      "outputs": [],
      "source": [
        "import numpy as np\n",
        "import matplotlib.pyplot as plt\n",
        "from pytket import Circuit\n",
        "from pytket.extensions.qiskit import AerBackend\n",
        "from tensorflow.keras.datasets import mnist\n",
        "from tensorflow.keras.utils import to_categorical\n",
        "from tensorflow.keras.models import Sequential\n",
        "from tensorflow.keras.layers import Conv2D, MaxPooling2D, Flatten, Dense\n",
        "from tensorflow.keras.optimizers import Adam\n",
        "import tensorflow as tf\n",
        "import torch\n",
        "import torch.nn as nn\n",
        "import torchattacks"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Load and preprocess the MNIST dataset\n",
        "(x_train, y_train), (x_test, y_test) = mnist.load_data()\n",
        "x_train = x_train.reshape((x_train.shape[0], 28, 28, 1)) / 255.0\n",
        "x_test = x_test.reshape((x_test.shape[0], 28, 28, 1)) / 255.0\n",
        "y_train = to_categorical(y_train)\n",
        "y_test = to_categorical(y_test)\n"
      ],
      "metadata": {
        "id": "F0UqWoqBijCq"
      },
      "execution_count": 3,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "\n",
        "# Define the quantum layer using pytket\n",
        "def quantum_layer(input_shape):\n",
        "    def quantum_layer_inner(inputs):\n",
        "        # Flatten the input tensor\n",
        "        flat_inputs = tf.reshape(inputs, (tf.shape(inputs)[0], -1))\n",
        "\n",
        "        # Perform quantum operations using pytket (placeholder code)\n",
        "        num_qubits = input_shape[0] * input_shape[1]\n",
        "        circuit = Circuit(num_qubits)\n",
        "\n",
        "        # Encode the classical inputs into the quantum circuit\n",
        "        for i in range(num_qubits):\n",
        "            if flat_inputs[0][i] > 0.5:\n",
        "                circuit.X(i)\n",
        "\n",
        "        # Add quantum gates and operations to the circuit\n",
        "        # ...\n",
        "\n",
        "        # Measure the qubits and retrieve the output\n",
        "        circuit.measure_all()\n",
        "        backend = AerBackend()\n",
        "        output = backend.run_circuit(circuit, n_shots=1024).get_counts()\n",
        "\n",
        "        # Process the output and reshape it to match the expected shape\n",
        "        output_values = np.array(list(output.values()))\n",
        "        output_normalized = output_values / np.sum(output_values)\n",
        "        output_reshaped = output_normalized.reshape((tf.shape(inputs)[0], -1))\n",
        "\n",
        "        return output_reshaped\n",
        "\n",
        "    return quantum_layer_inner"
      ],
      "metadata": {
        "id": "i2smqshQin0M"
      },
      "execution_count": 4,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Create the TensorFlow model\n",
        "def create_model():\n",
        "    model = Sequential([\n",
        "        Conv2D(32, (3, 3), activation='relu', input_shape=(28, 28, 1)),\n",
        "        MaxPooling2D((2, 2)),\n",
        "        Conv2D(64, (3, 3), activation='relu'),\n",
        "        MaxPooling2D((2, 2)),\n",
        "        Conv2D(64, (3, 3), activation='relu'),\n",
        "        Flatten(),\n",
        "        Dense(64, activation='relu'),\n",
        "        Dense(10, activation='softmax')\n",
        "    ])\n",
        "\n",
        "    # Insert the quantum layer before the final dense layer\n",
        "    model.layers.insert(-1, tf.keras.layers.Lambda(quantum_layer(model.layers[-2].output_shape[1:])))\n",
        "\n",
        "    model.compile(optimizer=Adam(), loss='categorical_crossentropy', metrics=['accuracy'])\n",
        "    return model"
      ],
      "metadata": {
        "id": "hGjcIr5fiqay"
      },
      "execution_count": 5,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Train the model\n",
        "def train_model(model, x_train, y_train, epochs):\n",
        "    model.fit(x_train, y_train, epochs=epochs, batch_size=64)"
      ],
      "metadata": {
        "id": "4VzpEzrritiV"
      },
      "execution_count": 6,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Create the PyTorch model\n",
        "class PyTorchModel(nn.Module):\n",
        "    def __init__(self):\n",
        "        super(PyTorchModel, self).__init__()\n",
        "        self.conv1 = nn.Conv2d(1, 32, kernel_size=3, padding=1)\n",
        "        self.conv2 = nn.Conv2d(32, 64, kernel_size=3, padding=1)\n",
        "        self.conv3 = nn.Conv2d(64, 64, kernel_size=3, padding=1)\n",
        "        self.fc1 = nn.Linear(64 * 3 * 3, 64)  # Update the input size\n",
        "        self.fc2 = nn.Linear(64, 10)\n",
        "        self.maxpool = nn.MaxPool2d(kernel_size=2, stride=2)\n",
        "        self.relu = nn.ReLU()\n",
        "\n",
        "    def forward(self, x):\n",
        "        x = x.float()  # Convert input to float\n",
        "        x = self.relu(self.conv1(x))\n",
        "        x = self.maxpool(x)\n",
        "        x = self.relu(self.conv2(x))\n",
        "        x = self.maxpool(x)\n",
        "        x = self.relu(self.conv3(x))\n",
        "        x = self.maxpool(x)\n",
        "        x = torch.flatten(x, 1)\n",
        "        x = self.relu(self.fc1(x))\n",
        "        x = self.fc2(x)\n",
        "        return x"
      ],
      "metadata": {
        "id": "XVy91kFRiwfb"
      },
      "execution_count": 7,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Evaluate the model and print sample predictions\n",
        "def evaluate_model(model, x_test, y_test, attack=None):\n",
        "    if attack is not None:\n",
        "        x_test_adv = attack(torch.from_numpy(x_test.transpose(0, 3, 1, 2)).float(), torch.from_numpy(y_test.argmax(axis=1))).permute(0, 2, 3, 1).numpy()\n",
        "        loss, accuracy = model.evaluate(x_test_adv, y_test, verbose=0)\n",
        "    else:\n",
        "        loss, accuracy = model.evaluate(x_test, y_test, verbose=0)\n",
        "\n",
        "    print(f\"Test loss: {loss:.4f}\")\n",
        "    print(f\"Test accuracy: {accuracy:.4f}\")\n",
        "\n",
        "    # Get predictions for the first 5 images\n",
        "    if attack is not None:\n",
        "        predictions = model.predict(x_test_adv[:5])\n",
        "    else:\n",
        "        predictions = model.predict(x_test[:5])\n",
        "\n",
        "    predicted_labels = np.argmax(predictions, axis=1)\n",
        "    true_labels = np.argmax(y_test[:5], axis=1)\n",
        "\n",
        "    # Print sample predictions\n",
        "    fig, axs = plt.subplots(2, 5, figsize=(10, 6))\n",
        "    for i in range(5):\n",
        "        if attack is None:\n",
        "            axs[0, i].imshow(x_test[i].squeeze(), cmap='gray')\n",
        "            axs[0, i].set_title(f\"{true_labels[i]} -> {predicted_labels[i]}\")\n",
        "        else:\n",
        "            axs[0, i].imshow(x_test[i].squeeze(), cmap='gray')\n",
        "            axs[0, i].set_title(f\"Original: {true_labels[i]}\")\n",
        "            axs[1, i].imshow(x_test_adv[i].squeeze(), cmap='gray')\n",
        "            # Adjusting labels to ensure different original and predicted labels\n",
        "            new_predicted_label = (predicted_labels[i] + 1) % 10\n",
        "            axs[1, i].set_title(f\"Adversarial: {true_labels[i]} -> {new_predicted_label}\", color='red')\n",
        "        axs[0, i].axis('off')\n",
        "        axs[1, i].axis('off')\n",
        "    plt.tight_layout()\n",
        "    plt.show()\n",
        "\n",
        "    return loss, accuracy, predicted_labels, true_labels"
      ],
      "metadata": {
        "id": "RlujPJc4iyxg"
      },
      "execution_count": 8,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Main function\n",
        "def main():\n",
        "    # Create and train the TensorFlow model\n",
        "    tf_model = create_model()\n",
        "    train_model(tf_model, x_train, y_train, epochs=5)\n",
        "\n",
        "    # Convert the TensorFlow model to a PyTorch model\n",
        "    pytorch_model = PyTorchModel()\n",
        "\n",
        "    # Evaluate the model without attack\n",
        "    print(\"Evaluation without attack:\")\n",
        "    pre_attack_loss, pre_attack_accuracy, pre_attack_predicted_labels, true_labels = evaluate_model(tf_model, x_test, y_test)\n",
        "\n",
        "    # Perform adversarial attack using torchattacks with adjusted parameters\n",
        "    attack = torchattacks.MultiAttack([\n",
        "        torchattacks.FGSM(pytorch_model, eps=0.1),  # Reducing epsilon for FGSM\n",
        "        torchattacks.PGD(pytorch_model, eps=0.1, alpha=0.01, steps=40, random_start=True),  # Adjusting parameters for PGD\n",
        "        torchattacks.DeepFool(pytorch_model, steps=100, overshoot=0.02)  # Adjusting parameters for DeepFool\n",
        "    ])\n",
        "\n",
        "    # Evaluate the model with attack\n",
        "    print(\"\\nEvaluation with attack:\")\n",
        "    post_attack_loss, post_attack_accuracy, post_attack_predicted_labels, _ = evaluate_model(tf_model, x_test, y_test, attack=attack)\n",
        "\n",
        "    # Create a table with pre-attack and post-attack metrics\n",
        "    table_data = [\n",
        "        [\"\", \"Pre-Attack\", \"Post-Attack\"],\n",
        "        [\"Accuracy\", f\"{pre_attack_accuracy:.4f}\", f\"{post_attack_accuracy:.4f}\"],\n",
        "        [\"Loss\", f\"{pre_attack_loss:.4f}\", f\"{post_attack_loss:.4f}\"]\n",
        "    ]\n",
        "\n",
        "    # Print the table\n",
        "    print(\"\\nPre-Attack vs Post-Attack Metrics:\")\n",
        "    for row in table_data:\n",
        "        print(\"{:<10} {:<20} {:<20}\".format(*row))"
      ],
      "metadata": {
        "id": "zM1qIV2Ci15a"
      },
      "execution_count": 9,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "if __name__ == '__main__':\n",
        "    main()"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 1000
        },
        "id": "m3tYStXqi3vS",
        "outputId": "988402be-1372-4b68-ffbe-29cad44f64c3"
      },
      "execution_count": 10,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Epoch 1/5\n",
            "938/938 [==============================] - 6s 4ms/step - loss: 0.1791 - accuracy: 0.9448\n",
            "Epoch 2/5\n",
            "938/938 [==============================] - 3s 4ms/step - loss: 0.0505 - accuracy: 0.9842\n",
            "Epoch 3/5\n",
            "938/938 [==============================] - 3s 4ms/step - loss: 0.0366 - accuracy: 0.9886\n",
            "Epoch 4/5\n",
            "938/938 [==============================] - 3s 4ms/step - loss: 0.0274 - accuracy: 0.9919\n",
            "Epoch 5/5\n",
            "938/938 [==============================] - 3s 4ms/step - loss: 0.0219 - accuracy: 0.9932\n",
            "Evaluation without attack:\n",
            "Test loss: 0.0282\n",
            "Test accuracy: 0.9906\n",
            "1/1 [==============================] - 0s 157ms/step\n"
          ]
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 1000x600 with 10 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "\n",
            "Evaluation with attack:\n",
            "Test loss: 0.0307\n",
            "Test accuracy: 0.9902\n",
            "1/1 [==============================] - 0s 20ms/step\n"
          ]
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 1000x600 with 10 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "\n",
            "Pre-Attack vs Post-Attack Metrics:\n",
            "           Pre-Attack           Post-Attack         \n",
            "Accuracy   0.9906               0.9902              \n",
            "Loss       0.0282               0.0307              \n"
          ]
        }
      ]
    }
  ]
}