{ "cells": [ { "cell_type": "markdown", "id": "f766403d", "metadata": {}, "source": [ "# Binary Classification Example with MerLin\n", "\n", "The goal of this notebook is to serve as an example on how to use MerLin for a simple binary classification task. To do so, we will compare using a Variational Quantum Circuit (VQC) with using a quantum kernel approach for classification on Iris (2 classes only)." ] }, { "cell_type": "markdown", "id": "6f392cc3", "metadata": {}, "source": [ "## 1. Import libraries" ] }, { "cell_type": "code", "execution_count": 20, "id": "29f7b980", "metadata": {}, "outputs": [], "source": [ "import matplotlib.pyplot as plt\n", "import numpy as np\n", "import perceval as pcvl\n", "import sklearn.svm\n", "import torch\n", "from tqdm import tqdm\n", "\n", "import merlin\n", "from merlin.datasets import iris" ] }, { "cell_type": "markdown", "id": "10417091", "metadata": {}, "source": [ "## Prepare dataset\n", "\n", "For dataset, we will use 2-class Iris since it is a simple dataset with 4 features without being trivial. We specify 2-class here since the original Iris dataset has 3 classes, but we will only consider the first two." ] }, { "cell_type": "code", "execution_count": 21, "id": "678cad22", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Training samples: 81\n", "Test samples: 19\n", "Features: 4\n", "Classes: 2\n", "All test labels: tensor([1, 1, 0, 1, 0, 0, 1, 0, 1, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0])\n", "All test labels (one hot): \n", "tensor([[0, 1],\n", " [0, 1],\n", " [1, 0],\n", " [0, 1],\n", " [1, 0],\n", " [1, 0],\n", " [0, 1],\n", " [1, 0],\n", " [0, 1],\n", " [1, 0],\n", " [1, 0],\n", " [0, 1],\n", " [1, 0],\n", " [1, 0],\n", " [1, 0],\n", " [1, 0],\n", " [1, 0],\n", " [1, 0],\n", " [1, 0]])\n" ] } ], "source": [ "train_features, train_labels, train_metadata = iris.get_data_train()\n", "test_features, test_labels, test_metadata = iris.get_data_test()\n", "\n", "assert len(train_features) == len(train_labels)\n", "assert len(test_features) == len(test_labels)\n", "\n", "# Filter training set to only keep first two labels\n", "binary_train_features = []\n", "binary_train_labels = []\n", "for i in range(len(train_features)):\n", " if train_labels[i] > 1:\n", " continue\n", " else:\n", " binary_train_features.append(train_features[i])\n", " binary_train_labels.append(train_labels[i])\n", "\n", "# Filter test set to only keep first two labels\n", "binary_test_features = []\n", "binary_test_labels = []\n", "for i in range(len(test_features)):\n", " if test_labels[i] > 1:\n", " continue\n", " else:\n", " binary_test_features.append(test_features[i])\n", " binary_test_labels.append(test_labels[i])\n", "\n", "# Convert data to PyTorch tensors\n", "# 1-D labels for the fidelity kernel method\n", "X_train = torch.FloatTensor(np.array(binary_train_features))\n", "y_train_1D = torch.LongTensor(np.array(binary_train_labels))\n", "X_test = torch.FloatTensor(np.array(binary_test_features))\n", "y_test_1D = torch.LongTensor(np.array(binary_test_labels))\n", "\n", "# Convert 1-dimensional labels to 2 dimensional one hot vectors\n", "# For the VQC that uses Binary Cross Entropy Loss (BCELoss)\n", "y_train_one_hot = torch.nn.functional.one_hot(y_train_1D, num_classes=2)\n", "y_test_one_hot = torch.nn.functional.one_hot(y_test_1D, num_classes=2)\n", "\n", "print(f\"Training samples: {X_train.shape[0]}\")\n", "print(f\"Test samples: {X_test.shape[0]}\")\n", "print(f\"Features: {X_train.shape[1]}\")\n", "print(f\"Classes: {len(torch.unique(y_train_1D))}\")\n", "print(f\"All test labels: {y_test_1D}\")\n", "print(f\"All test labels (one hot): \\n{y_test_one_hot}\")\n", "\n", "# Convert one hot vectors from long to float\n", "y_train = y_train_one_hot.float()\n", "y_test = y_test_one_hot.float()" ] }, { "cell_type": "markdown", "id": "1fe8ddcb", "metadata": {}, "source": [ "### Visualization\n", "\n", "Let's visualize the the first two features of our dataset." ] }, { "cell_type": "code", "execution_count": 22, "id": "834f4a41", "metadata": {}, "outputs": [ { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "# Convert tensors to numpy\n", "X_train_np = X_train.numpy()\n", "y_train_np = y_train_1D.numpy()\n", "\n", "X_test_np = X_test.numpy()\n", "y_test_np = y_test_1D.numpy()\n", "\n", "# Create masks for the two classes\n", "train_class0 = y_train_np == 0\n", "train_class1 = y_train_np == 1\n", "\n", "test_class0 = y_test_np == 0\n", "test_class1 = y_test_np == 1\n", "\n", "# Plot\n", "plt.figure(figsize=(8, 6))\n", "\n", "plt.scatter(X_train_np[train_class0, 0], X_train_np[train_class0, 1],\n", " marker='o', label='Train - Class 0', c=\"blue\")\n", "plt.scatter(X_test_np[test_class0, 0], X_test_np[test_class0, 1],\n", " marker='x', label='Test - Class 0', c=\"blue\")\n", "plt.scatter(X_train_np[train_class1, 0], X_train_np[train_class1, 1],\n", " marker='o', label='Train - Class 1', c=\"red\")\n", "plt.scatter(X_test_np[test_class1, 0], X_test_np[test_class1, 1],\n", " marker='x', label='Test - Class 1', c=\"red\")\n", "\n", "# Labels and legend\n", "plt.xlabel(\"Feature 1\")\n", "plt.ylabel(\"Feature 2\")\n", "plt.title(\"Iris data visualization (first 2 features)\")\n", "plt.legend()\n", "plt.grid(True)\n", "\n", "plt.show()" ] }, { "cell_type": "markdown", "id": "53eb25d6", "metadata": {}, "source": [ "## Define models\n", "\n", "### VQC\n", "\n", "To define the VQC, we must first define the photonic circuit we will use. One can use the `QuantumLayer.simple()` method for the highest-level entry point. For this tutorial however, we will use the `CircuitBuilder` which requires a bit more effort but offers more flexibility to the user.\n", "\n", "### CircuitBuilder\n", "We will use angle encoding so we need at least 4 modes to encode the 4 features on different modes. It is common practice to have d + 1 modes, where d is the number of features.\n", "\n", "For the structure of our circuit, we will use the one proposed by [Gan et al.](https://arxiv.org/abs/2107.05224):\n", "\n", "1. A trainable circuit block\n", "2. A data encoding block (angle encoding) with one phase shifter encoder per mode\n", "3. Another trainable circuit block\n", "\n", "For the trainable circuit blocks, we will model the structure on the [Mach-Zehnder Interferometer](https://en.wikipedia.org/wiki/Mach%E2%80%93Zehnder_interferometer) (MZI) circuit structure." ] }, { "cell_type": "code", "execution_count": 23, "id": "a1ed76e6", "metadata": {}, "outputs": [ { "data": { "image/svg+xml": [ "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "CPLX\n", "\n", "\n", "Φ=phi1\n", "\n", "\n", "Φ=phi2\n", "\n", "\n", "Φ=phi3\n", "\n", "\n", "Φ=phi4\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "CPLX\n", "\n", "\n", "\n", "\n", "\n", "0\n", "1\n", "2\n", "3\n", "4\n", "0\n", "1\n", "2\n", "3\n", "4\n", "" ], "text/plain": [ "" ] }, "execution_count": 23, "metadata": {}, "output_type": "execute_result" } ], "source": [ "builder = merlin.CircuitBuilder(n_modes=5)\n", "builder.add_entangling_layer(trainable=True, model=\"mzi\", name=\"left\")\n", "builder.add_angle_encoding(modes=[0, 1, 2, 3], name=\"phi\")\n", "builder.add_entangling_layer(trainable=True, model=\"mzi\", name=\"right\")\n", "\n", "# Visualize global circuit\n", "pcvl.pdisplay(builder.to_pcvl_circuit())" ] }, { "cell_type": "code", "execution_count": 24, "id": "370e7b4e", "metadata": {}, "outputs": [ { "data": { "image/svg+xml": [ "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "CPLX\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "Rx\n", "\n", "\n", "Φ=left_li0\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "Rx\n", "\n", "\n", "Φ=left_lo0\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "Rx\n", "\n", "\n", "Φ=left_li1\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "Rx\n", "\n", "\n", "Φ=left_lo1\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "Rx\n", "\n", "\n", "Φ=left_li2\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "Rx\n", "\n", "\n", "Φ=left_lo2\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "Rx\n", "\n", "\n", "Φ=left_li3\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "Rx\n", "\n", "\n", "Φ=left_lo3\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "Rx\n", "\n", "\n", "Φ=left_li4\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "Rx\n", "\n", "\n", "Φ=left_lo4\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "Rx\n", "\n", "\n", "Φ=left_li5\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "Rx\n", "\n", "\n", "Φ=left_lo5\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "Rx\n", "\n", "\n", "Φ=left_li6\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "Rx\n", "\n", "\n", "Φ=left_lo6\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "Rx\n", "\n", "\n", "Φ=left_li7\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "Rx\n", "\n", "\n", "Φ=left_lo7\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "Rx\n", "\n", "\n", "Φ=left_li8\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "Rx\n", "\n", "\n", "Φ=left_lo8\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "Rx\n", "\n", "\n", "Φ=left_li9\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "Rx\n", "\n", "\n", "Φ=left_lo9\n", "\n", "\n", "\n", "\n", "\n", "Φ=phi1\n", "\n", "\n", "Φ=phi2\n", "\n", "\n", "Φ=phi3\n", "\n", "\n", "Φ=phi4\n", "\n", "CPLX\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "Rx\n", "\n", "\n", "Φ=right_li0\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "Rx\n", "\n", "\n", "Φ=right_lo0\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "Rx\n", "\n", "\n", "Φ=right_li1\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "Rx\n", "\n", "\n", "Φ=right_lo1\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "Rx\n", "\n", "\n", "Φ=right_li2\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "Rx\n", "\n", "\n", "Φ=right_lo2\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "Rx\n", "\n", "\n", "Φ=right_li3\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "Rx\n", "\n", "\n", "Φ=right_lo3\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "Rx\n", "\n", "\n", "Φ=right_li4\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "Rx\n", "\n", "\n", "Φ=right_lo4\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "Rx\n", "\n", "\n", "Φ=right_li5\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "Rx\n", "\n", "\n", "Φ=right_lo5\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "Rx\n", "\n", "\n", "Φ=right_li6\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "Rx\n", "\n", "\n", "Φ=right_lo6\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "Rx\n", "\n", "\n", "Φ=right_li7\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "Rx\n", "\n", "\n", "Φ=right_lo7\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "Rx\n", "\n", "\n", "Φ=right_li8\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "Rx\n", "\n", "\n", "Φ=right_lo8\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "Rx\n", "\n", "\n", "Φ=right_li9\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "Rx\n", "\n", "\n", "Φ=right_lo9\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "0\n", "1\n", "2\n", "3\n", "4\n", "0\n", "1\n", "2\n", "3\n", "4\n", "" ], "text/plain": [ "" ] }, "execution_count": 24, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# For a detailed visualization of the entangling blocks\n", "pcvl.pdisplay(builder.to_pcvl_circuit(), recursive=True)" ] }, { "cell_type": "markdown", "id": "5f021877", "metadata": {}, "source": [ "### QuantumLayer\n", "\n", "We must now define the quantum layer that will be our complete VQC. The number of photons controls the expressivity of the photonic circuit output. Note that it is good practice to have a number of photons inferior to the number of modes divided by two." ] }, { "cell_type": "code", "execution_count": 25, "id": "b6fd20c3", "metadata": {}, "outputs": [], "source": [ "q_layer = merlin.QuantumLayer(\n", " builder=builder,\n", " n_photons=2,\n", " measurement_strategy=merlin.MeasurementStrategy.probs(computation_space=merlin.ComputationSpace.FOCK)\n", ")\n", "# We have to map the number of outputs from the quantum layer to the number of classes (2)\n", "# We use a grouping strategy from MerLin to do it\n", "vqc = torch.nn.Sequential(q_layer, merlin.LexGrouping(q_layer.output_size, 2))" ] }, { "cell_type": "markdown", "id": "b699c512", "metadata": {}, "source": [ "### Quantum Kernel Method (Fidelity Kernel)\n", "\n", "The fidelity kernel encodes real inputs into a multi-Fock space, evaluates their overlaps and returns a similarity matrix.\n", "\n", "We will use the `FidelityKernel.simple()` method from MerLin to define the quantum fidelity kernel with the highest-level of abstraction. A user with more experience could use the `FeatureMap` along with the `FidelityKernel` classes for more control." ] }, { "cell_type": "code", "execution_count": 26, "id": "b50430ab", "metadata": {}, "outputs": [], "source": [ "fidelity_kernel = merlin.FidelityKernel.simple(\n", " input_size=4,\n", " n_modes=5,\n", " computation_space=merlin.ComputationSpace.FOCK,\n", ")" ] }, { "cell_type": "markdown", "id": "12739eff", "metadata": {}, "source": [ "## Training the models\n", "\n", "The training for the two models considered is different so let's consider them separately once more.\n", "\n", "### Training for the VQC\n", "\n", "The training for this model is identical to how any other torch neural network model would be trained." ] }, { "cell_type": "code", "execution_count": 27, "id": "df656e84", "metadata": {}, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ "100%|██████████| 250/250 [00:01<00:00, 191.45it/s]\n" ] }, { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" }, { "name": "stdout", "output_type": "stream", "text": [ "Final VQC test accuracy: 1.0\n" ] } ], "source": [ "# Define most important hyperparameters\n", "epochs=250\n", "lr=0.02\n", "optimizer = torch.optim.Adam(vqc.parameters(), lr=lr)\n", "loss_fn = torch.nn.BCELoss()\n", "\n", "# To store training metrics\n", "train_accuracies = []\n", "train_losses = []\n", "test_accuracies = []\n", "test_losses = []\n", "\n", "for _ in tqdm(range(epochs)):\n", " vqc.train()\n", " optimizer.zero_grad()\n", " predictions = vqc(X_train)\n", " loss = loss_fn(predictions, y_train)\n", " loss.backward()\n", " optimizer.step()\n", "\n", " #Evaluate the model on the train set\n", " train_preds = predictions.argmax(dim=1)\n", " train_acc = (train_preds == y_train.argmax(dim=1)).float().mean().item()\n", " train_accuracies.append(train_acc)\n", " train_losses.append(loss.item())\n", "\n", " # Evaluate the model on the test set\n", " vqc.eval()\n", " predictions = vqc(X_test)\n", " test_preds = predictions.argmax(dim=1)\n", " test_acc = (test_preds == y_test.argmax(dim=1)).float().mean().item()\n", " test_accuracies.append(test_acc)\n", " with torch.no_grad():\n", " loss = loss_fn(predictions, y_test)\n", " test_losses.append(loss.item())\n", "\n", "\n", "epoch_range = range(1, epochs + 1)\n", "\n", "# Accuracy plot\n", "plt.figure(figsize=(8, 5))\n", "plt.plot(epoch_range, train_accuracies, label=\"Train accuracy\")\n", "plt.plot(epoch_range, test_accuracies, label=\"Test accuracy\")\n", "plt.xlabel(\"Epochs\")\n", "plt.ylabel(\"Accuracy\")\n", "plt.legend()\n", "plt.show()\n", "\n", "# Loss plot\n", "plt.figure(figsize=(8, 5))\n", "plt.plot(epoch_range, train_losses, label=\"Train loss\")\n", "plt.plot(epoch_range, test_losses, label=\"Test loss\")\n", "plt.xlabel(\"Epochs\")\n", "plt.ylabel(\"Loss\")\n", "plt.legend()\n", "plt.show()\n", "\n", "print(f\"Final VQC test accuracy: {test_accuracies[-1]}\")" ] }, { "cell_type": "markdown", "id": "43b88607", "metadata": {}, "source": [ "### Training for the quantum kernel method\n", "\n", "The training for this model is similar to the training of other kernel methods. We will use the SVC class from scikit-learn because it accepts pre-computed kernels." ] }, { "cell_type": "code", "execution_count": 28, "id": "99e5926d", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Train kernel matrix shape: torch.Size([81, 81])\n", "Test kernel matrix shape: torch.Size([19, 81])\n", "SVC training started\n", "SVC training ended\n", "Final quantum fidelity kernel test accuracy: 1.0\n" ] } ], "source": [ "svc = sklearn.svm.SVC(kernel=\"precomputed\")\n", "\n", "K_train = fidelity_kernel(X_train)\n", "K_test = fidelity_kernel(X_test, X_train)\n", "print(\"Train kernel matrix shape:\", K_train.shape)\n", "print(\"Test kernel matrix shape:\", K_test.shape)\n", "\n", "print(\"SVC training started\")\n", "svc.fit(K_train.detach().numpy(), y_train_1D.detach().numpy())\n", "print(\"SVC training ended\")\n", "test_accuracy = svc.score(K_test.detach().numpy(), y_test_1D.detach().numpy())\n", "print(f\"Final quantum fidelity kernel test accuracy: {test_accuracy}\")\n" ] }, { "cell_type": "markdown", "id": "5753552c", "metadata": {}, "source": [ "## Conclusion\n", "\n", "In the end, we see that both approaches manage to perfectly classify this dataset. You can choose to use which methodology you prefer but it usually is good practice to consider both of these large families of models. \n", "\n", "For more information on how to use the ideal VQC, look at the [QuantumLayer Essentials page](https://merlinquantum.ai/user_guide/layer.html).\n", "\n", "For more information on how to use the ideal quantum fidelity kernel, look at the [Photonic Kernel Methods page](https://merlinquantum.ai/user_guide/kernels.html)." ] } ], "metadata": { "kernelspec": { "display_name": ".venv", "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.13.5" } }, "nbformat": 4, "nbformat_minor": 5 }