{ "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": 1, "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": 2, "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": 3, "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(\n", " X_train_np[train_class0, 0],\n", " X_train_np[train_class0, 1],\n", " marker=\"o\",\n", " label=\"Train - Class 0\",\n", " c=\"blue\",\n", ")\n", "plt.scatter(\n", " X_test_np[test_class0, 0],\n", " X_test_np[test_class0, 1],\n", " marker=\"x\",\n", " label=\"Test - Class 0\",\n", " c=\"blue\",\n", ")\n", "plt.scatter(\n", " X_train_np[train_class1, 0],\n", " X_train_np[train_class1, 1],\n", " marker=\"o\",\n", " label=\"Train - Class 1\",\n", " c=\"red\",\n", ")\n", "plt.scatter(\n", " X_test_np[test_class1, 0],\n", " X_test_np[test_class1, 1],\n", " marker=\"x\",\n", " label=\"Test - Class 1\",\n", " c=\"red\",\n", ")\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": 4, "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": 4, "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": 5, "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": 5, "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": 6, "id": "b6fd20c3", "metadata": {}, "outputs": [], "source": [ "q_layer = merlin.QuantumLayer(\n", " builder=builder,\n", " n_photons=2,\n", " measurement_strategy=merlin.MeasurementStrategy.probs(\n", " computation_space=merlin.ComputationSpace.FOCK\n", " ),\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 `FeatureMap.simple` and `FidelityKernel` from MerLin to define the quantum fidelity kernel. `FeatureMap.simple` builds the photonic circuit and `FidelityKernel` wraps it to compute Gram matrices." ] }, { "cell_type": "code", "execution_count": 7, "id": "b50430ab", "metadata": {}, "outputs": [], "source": [ "feature_map = merlin.FeatureMap.simple(input_size=4) # n_modes = input_size + 1 = 5\n", "fidelity_kernel = merlin.FidelityKernel(\n", " feature_map=feature_map,\n", " input_state=[1, 0, 1, 0, 1], # alternating photons for 5 modes\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": 8, "id": "df656e84", "metadata": {}, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ "100%|██████████| 250/250 [00:01<00:00, 151.32it/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": 9, "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}\")" ] }, { "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-0.4", "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.12.7" } }, "nbformat": 4, "nbformat_minor": 5 }