{ "cells": [ { "cell_type": "markdown", "id": "3a34a533", "metadata": {}, "source": [ "# Bringing the Data Scientist Up to Speed With MerLin\n", "\n", "This notebook is tailored for new users with a data science or machine learning background, who want to upgrade their MerLin experience. If you have just started exploring MerLin with the ``QuantumLayer.simple()`` method and want a little more expressivity and control on your ``QuantumLayer``, this notebook is made for you ! We will guide you step by step so you can leverage the most ouf of MerLin and unlock both your creativity, and the expressivity of your quantum machine learning models !\n", "\n", "\n", "MerLins's QuantumLayer offers much more flexibility that what the ``simple()`` method's is offering. Indeed,\n", "it is possible to adapt the interferometer of the layer to our desires easily with the CircuitBuilder." ] }, { "cell_type": "markdown", "id": "831bf50a", "metadata": {}, "source": [ "Run the following imports." ] }, { "cell_type": "code", "execution_count": 3, "id": "7559ad47", "metadata": {}, "outputs": [], "source": [ "from copy import deepcopy\n", "\n", "import matplotlib.pyplot as plt\n", "import numpy as np\n", "import perceval as pcvl\n", "import torch\n", "import torch.nn as nn\n", "import torch.nn.functional as F\n", "from sklearn.datasets import load_digits, load_iris, make_moons\n", "from sklearn.model_selection import train_test_split\n", "\n", "import merlin as ML\n", "\n", "torch.manual_seed(0)\n", "np.random.seed(0)" ] }, { "cell_type": "markdown", "id": "67b60f7e", "metadata": {}, "source": [ "## ``simple()`` recap: classifying iris\n", "\n", "The ``simple()`` method can be usefull for small classification tasks. Here, we can use it to classify the famous Iris dataset which has 4 features and three flower types.\n", "\n", "Let's first load the data." ] }, { "cell_type": "code", "execution_count": 4, "id": "55fd6601", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Train size: 112 samples\n", "Test size: 38 samples\n" ] } ], "source": [ "iris = load_iris()\n", "X = iris.data.astype(\"float32\")\n", "y = iris.target.astype(\"int64\")\n", "\n", "X_train, X_test, y_train, y_test = train_test_split(\n", " X,\n", " y,\n", " test_size=0.25,\n", " stratify=y,\n", " random_state=42,\n", ")\n", "\n", "X_train = torch.tensor(X_train, dtype=torch.float32)\n", "X_test = torch.tensor(X_test, dtype=torch.float32)\n", "y_train = torch.tensor(y_train, dtype=torch.long)\n", "y_test = torch.tensor(y_test, dtype=torch.long)\n", "\n", "mean = X_train.mean(dim=0, keepdim=True)\n", "std = X_train.std(dim=0, keepdim=True).clamp_min(1e-6)\n", "X_train = (X_train - mean) / std\n", "X_test = (X_test - mean) / std\n", "\n", "print(f\"Train size: {X_train.shape[0]} samples\")\n", "print(f\"Test size: {X_test.shape[0]} samples\")" ] }, { "cell_type": "markdown", "id": "9ce253d3", "metadata": {}, "source": [ "We can then easily create a quantum layer with the ``simple()``method." ] }, { "cell_type": "code", "execution_count": 5, "id": "48e62957", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "SimpleSequential(\n", " (quantum_layer): QuantumLayer(\n", " (_photon_loss_transform): PhotonLossTransform()\n", " (_detector_transform): DetectorTransform()\n", " (measurement_mapping): Probabilities()\n", " )\n", " (post_processing): ModGrouping()\n", ")" ] }, "execution_count": 5, "metadata": {}, "output_type": "execute_result" } ], "source": [ "quantum_classifier = ML.QuantumLayer.simple(input_size=4, output_size=3)\n", "\n", "quantum_classifier" ] }, { "cell_type": "markdown", "id": "5edaba35", "metadata": {}, "source": [ "We can use this layer as ``torch.Module`` to classify the dataset." ] }, { "cell_type": "code", "execution_count": 6, "id": "11893077", "metadata": {}, "outputs": [ { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "# Simple model training and evaluation process.\n", "def run_experiment(layer: torch.nn.Module, epochs: int = 60, lr: float = 0.05):\n", " optimizer = torch.optim.Adam(layer.parameters(), lr=lr)\n", " losses = []\n", " for _ in range(epochs):\n", " layer.train()\n", " optimizer.zero_grad()\n", " logits = layer(X_train)\n", " loss = F.cross_entropy(logits, y_train)\n", " loss.backward()\n", " optimizer.step()\n", " losses.append(loss.item())\n", "\n", " layer.eval()\n", " with torch.no_grad():\n", " train_preds = layer(X_train).argmax(dim=1)\n", " test_preds = layer(X_test).argmax(dim=1)\n", " train_acc = (train_preds == y_train).float().mean().item()\n", " test_acc = (test_preds == y_test).float().mean().item()\n", " return losses, train_acc, test_acc\n", "\n", "\n", "# Running the experiment\n", "test_accs, train_accs = [], []\n", "epochs = [10 * i for i in range(1, 26)]\n", "for epoch in epochs:\n", " simple_layer = deepcopy(quantum_classifier)\n", " losses, train_acc, test_acc = run_experiment(simple_layer, epochs=epoch, lr=0.01)\n", " test_accs.append(test_acc)\n", " train_accs.append(train_acc)\n", "\n", "# Plotting function\n", "plt.plot(epochs, train_accs, label=\"train\")\n", "plt.plot(epochs, test_accs, label=\"test\")\n", "ticks = epochs\n", "indexes_to_pop = []\n", "index = 0\n", "for i in range(len(epochs)):\n", " if i % 3 > 0:\n", " ticks.pop(index)\n", " else:\n", " index += 1\n", "\n", "plt.xticks(ticks=ticks, labels=[str(p) for p in ticks])\n", "plt.xlabel(\"Epochs\")\n", "plt.ylabel(\"Accuracy\")\n", "plt.legend()\n", "plt.show()" ] }, { "cell_type": "markdown", "id": "668b0bb2", "metadata": {}, "source": [ "## What is ``simple()`` doing?\n", "\n", "The simple method creates an interferometer from the same template every time. Indeed, the circuit that is created has the same number of modes as the number of features+1 and puts a photon every two modes. There is exactly one feature encoded per mode. Here is an example of the circuit for an input size (number of features) of 10." ] }, { "cell_type": "code", "execution_count": 21, "id": "729ae20c", "metadata": {}, "outputs": [ { "data": { "image/svg+xml": [ "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "CPLX\n", "\n", "\n", "Φ=input1\n", "\n", "\n", "Φ=input2\n", "\n", "\n", "Φ=input3\n", "\n", "\n", "Φ=input4\n", "\n", "\n", "Φ=input5\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "CPLX\n", "\n", "\n", "\n", "\n", "\n", "\n", "0\n", "1\n", "2\n", "3\n", "4\n", "5\n", "0\n", "1\n", "2\n", "3\n", "4\n", "5\n", "" ], "text/plain": [ "" ] }, "execution_count": 21, "metadata": {}, "output_type": "execute_result" } ], "source": [ "qlayer = ML.QuantumLayer.simple(input_size=5, output_size=4)\n", "\n", "pcvl.pdisplay(qlayer.circuit)" ] }, { "cell_type": "markdown", "id": "e1edb35f", "metadata": {}, "source": [ "We are limited quickly by computation capabilities as well as photon-number control." ] }, { "cell_type": "markdown", "id": "4710c1f4", "metadata": {}, "source": [ "## When does ``simple()`` becomes not appropriate?\n", "\n", "The use of the ``simple()`` method is perfect for beginners in photonic QML who just want to explore the quantum capabilities on easy and small datasets. However, we will need to use the full power of the QuamtumLayer to classify more complex and usefull datasets. Indeed, the method only works for datasets that have 19 or less features due to simulation speed reasons. Also, as stated in the [Fock State-enhanced Expressivity of Quantum Machine Learning Models](https://arxiv.org/abs/2107.05224) paper by Gan *et al*, the expressivity of a photonic quantum layer is directly related to the number of photons. The ``simple()`` method does not allow the user to change in input state of the interferometer.\n", "\n", "We will present another easy to use tool to add a QuantumLayer to your torch modules that lets you control the input photons without any feature restrictions." ] }, { "cell_type": "markdown", "id": "35bfb900", "metadata": {}, "source": [ "## Transition to ``merlin.CircuitBuilder``\n", "\n", "Lets introduce MerLin's powerful ``CircuitBuilder``. This object can be directly passed to a quantum layer. For a specified number of modes, we can create many interferometer patterns. Lets go deeper to the available patterns." ] }, { "cell_type": "markdown", "id": "85f3ebef", "metadata": {}, "source": [ "First, lets create an instance of this object." ] }, { "cell_type": "code", "execution_count": 8, "id": "d372f416", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "" ] }, "execution_count": 8, "metadata": {}, "output_type": "execute_result" } ], "source": [ "circuit_builder = ML.CircuitBuilder(n_modes=2)\n", "\n", "circuit_builder" ] }, { "cell_type": "markdown", "id": "8694199b", "metadata": {}, "source": [ "### A) ``add_rotations()``\n", "\n", "If we want to add simple rotations on given modes, we can use the ``add_rotations()`` method. We can make the parameters trainable and define the starting angle if necessary. " ] }, { "cell_type": "code", "execution_count": 9, "id": "5cc49aac", "metadata": {}, "outputs": [ { "data": { "image/svg+xml": [ "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "Φ=theta_0_0\n", "\n", "\n", "Φ=theta_1_1\n", "\n", "\n", "0\n", "1\n", "0\n", "1\n", "" ], "text/plain": [ "" ] }, "execution_count": 9, "metadata": {}, "output_type": "execute_result" } ], "source": [ "circuit_builder.add_rotations(modes=[0, 1], trainable=True, angle=0.36)\n", "\n", "pcvl.pdisplay(circuit_builder.to_pcvl_circuit())" ] }, { "cell_type": "markdown", "id": "a47b804c", "metadata": {}, "source": [ "### B) ``add_superposition()``\n", "\n", "If we want to add a simple interaction on given modes, we can use the ``add_superposition()`` method. We can make the parameters trainable, define the starting angles if necessary. " ] }, { "cell_type": "code", "execution_count": 10, "id": "a97a0929", "metadata": {}, "outputs": [ { "data": { "image/svg+xml": [ "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "Φ=theta_0_0\n", "\n", "\n", "Φ=theta_1_1\n", "\n", "\n", "\n", "\n", "\n", "Φ_tr=eb0_Φ_0\n", "Θ=eb0_theta_0\n", "\n", "\n", "Rx\n", "\n", "\n", "0\n", "1\n", "0\n", "1\n", "" ], "text/plain": [ "" ] }, "execution_count": 10, "metadata": {}, "output_type": "execute_result" } ], "source": [ "circuit_builder.add_superpositions(modes=[0, 1], theta=0.1, phi=0.15, trainable=True)\n", "\n", "pcvl.pdisplay(circuit_builder.to_pcvl_circuit())" ] }, { "cell_type": "markdown", "id": "cae859ff", "metadata": {}, "source": [ "### C) ``add_entangling_layer()``\n", "\n", "If we want a more complex interactions between the modes, we can add an entangling layer. This layer can represent every single interactions between the modes. The parameters can also be trainable. There are two patterns being \"mzi\" and \"bell\". Here we will use the default one being \"mzi\"." ] }, { "cell_type": "code", "execution_count": 11, "id": "1136819d", "metadata": {}, "outputs": [ { "data": { "image/svg+xml": [ "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "Φ=theta_0_0\n", "\n", "\n", "Φ=theta_1_1\n", "\n", "\n", "\n", "\n", "\n", "Φ_tr=eb0_Φ_0\n", "Θ=eb0_theta_0\n", "\n", "\n", "Rx\n", "\n", "\n", "\n", "CPLX\n", "\n", "\n", "0\n", "1\n", "0\n", "1\n", "" ], "text/plain": [ "" ] }, "execution_count": 11, "metadata": {}, "output_type": "execute_result" } ], "source": [ "circuit_builder.add_entangling_layer(modes=[0, 1], trainable=True, model=\"mzi\")\n", "\n", "pcvl.pdisplay(circuit_builder.to_pcvl_circuit())" ] }, { "cell_type": "markdown", "id": "56667d7b", "metadata": {}, "source": [ "### Encoding\n", "\n", "Just as simple does, we can add angle encoding to the interferometer. It is how and where the features will be assigned in the boson sampler on a forward pass. It is easy to add with a simple call of the ``add_angle_encoding()`` method." ] }, { "cell_type": "code", "execution_count": 12, "id": "57f23c17", "metadata": {}, "outputs": [ { "data": { "image/svg+xml": [ "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "Φ=theta_0_0\n", "\n", "\n", "Φ=theta_1_1\n", "\n", "\n", "\n", "\n", "\n", "Φ_tr=eb0_Φ_0\n", "Θ=eb0_theta_0\n", "\n", "\n", "Rx\n", "\n", "\n", "\n", "CPLX\n", "\n", "\n", "Φ=px1\n", "\n", "\n", "Φ=px2\n", "\n", "\n", "0\n", "1\n", "0\n", "1\n", "" ], "text/plain": [ "" ] }, "execution_count": 12, "metadata": {}, "output_type": "execute_result" } ], "source": [ "circuit_builder.add_angle_encoding(modes=[0, 1])\n", "\n", "pcvl.pdisplay(circuit_builder.to_pcvl_circuit())" ] }, { "cell_type": "markdown", "id": "513e66b1", "metadata": {}, "source": [ "## Create a ``QuantumLayer`` from the ``CircuitBuilder``" ] }, { "cell_type": "markdown", "id": "916449bd", "metadata": {}, "source": [ "### Changing the number of photons\n", "With circuit builder we can now specify the number of photons or the input state of the circuit. Here we will explore the relation between expressivity and the number of photons by classifying the ``make_moons`` dataset. It is a dataset with 2 features and 2 classes.\n", "\n", "Lets's first load the dataset" ] }, { "cell_type": "code", "execution_count": 13, "id": "372437f7", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Train size: 187 samples\n", "Test size: 63 samples\n" ] }, { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "digits = make_moons(n_samples=250)\n", "X = digits[0]\n", "y = digits[1]\n", "\n", "X_train, X_test, y_train, y_test = train_test_split(\n", " X,\n", " y,\n", " test_size=0.25,\n", " stratify=y,\n", " random_state=42,\n", ")\n", "\n", "X_train = torch.tensor(X_train, dtype=torch.float32)\n", "X_test = torch.tensor(X_test, dtype=torch.float32)\n", "y_train = torch.tensor(y_train, dtype=torch.long)\n", "y_test = torch.tensor(y_test, dtype=torch.long)\n", "\n", "mean = X_train.mean(dim=0, keepdim=True)\n", "std = X_train.std(dim=0, keepdim=True).clamp_min(1e-6)\n", "X_train = (X_train - mean) / std\n", "X_test = (X_test - mean) / std\n", "\n", "print(f\"Train size: {X_train.shape[0]} samples\")\n", "print(f\"Test size: {X_test.shape[0]} samples\")\n", "\n", "# Plotting the dataset\n", "class_1 = []\n", "class_2 = []\n", "\n", "for features, label in zip(X, y, strict=True):\n", " if label == 0:\n", " class_1.append(features)\n", " else:\n", " class_2.append(features)\n", "\n", "class_1 = np.array(class_1)\n", "class_2 = np.array(class_2)\n", "\n", "plt.scatter(class_1[:, 0], class_1[:, 1], s=10, color=\"tab:blue\", alpha=0.7)\n", "plt.scatter(class_2[:, 0], class_2[:, 1], s=10, color=\"tab:red\", alpha=0.7)\n", "plt.xlabel(\"x1\")\n", "plt.ylabel(\"x2\")\n", "plt.show()" ] }, { "cell_type": "markdown", "id": "780abd15", "metadata": {}, "source": [ "Lets create a 5 mode interferometer with the circuit builder." ] }, { "cell_type": "code", "execution_count": 14, "id": "c8c1d115", "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", "Φ=px1\n", "\n", "\n", "Φ=px2\n", "\n", "\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": 14, "metadata": {}, "output_type": "execute_result" } ], "source": [ "moon_circuit = ML.CircuitBuilder(n_modes=5)\n", "\n", "moon_circuit.add_entangling_layer()\n", "moon_circuit.add_angle_encoding(modes=[1, 4])\n", "moon_circuit.add_entangling_layer()\n", "\n", "pcvl.pdisplay(moon_circuit.to_pcvl_circuit())" ] }, { "cell_type": "markdown", "id": "c976be94", "metadata": {}, "source": [ "Lets run the classification experiment." ] }, { "cell_type": "code", "execution_count": 15, "id": "6e4b9619", "metadata": {}, "outputs": [], "source": [ "# A simple training experiment\n", "def run_experiment(layer: torch.nn.Module, epochs: int = 60, lr: float = 0.05):\n", " optimizer = torch.optim.Adam(layer.parameters(), lr=lr)\n", " losses = []\n", " for _ in range(epochs):\n", " layer.train()\n", " optimizer.zero_grad()\n", " logits = layer(X_train)\n", " loss = F.cross_entropy(logits, y_train)\n", " loss.backward()\n", " optimizer.step()\n", " losses.append(loss.item())\n", "\n", " layer.eval()\n", " with torch.no_grad():\n", " train_preds = layer(X_train).argmax(dim=1)\n", " test_preds = layer(X_test).argmax(dim=1)\n", " train_acc = (train_preds == y_train).float().mean().item()\n", " test_acc = (test_preds == y_test).float().mean().item()\n", " return losses, train_acc, test_acc" ] }, { "cell_type": "code", "execution_count": 16, "id": "86638fe8", "metadata": {}, "outputs": [ { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "test_accs = [[], [], [], [], []]\n", "epochs = [5 * i for i in range(1, 40)]\n", "for i, num_photons in enumerate([1, 2, 3]):\n", " for epoch in epochs:\n", " qcirc = ML.QuantumLayer(builder=deepcopy(moon_circuit), n_photons=num_photons)\n", " quantum_classifier = nn.Sequential(qcirc, ML.ModGrouping(qcirc.output_size, 2))\n", "\n", " losses, train_acc, test_acc = run_experiment(\n", " quantum_classifier, epochs=epoch, lr=0.01\n", " )\n", " test_accs[i].append(test_acc)\n", "\n", "\n", "# Plotting function\n", "for i, num_photons in enumerate([1, 2, 3]):\n", " plt.plot(epochs, test_accs[i], label=f\"test (photons={num_photons})\")\n", "\n", "ticks = epochs.copy()\n", "index = 0\n", "for i in range(len(epochs)):\n", " if i % 3 > 0:\n", " ticks.pop(index)\n", " else:\n", " index += 1\n", "\n", "plt.xticks(ticks=ticks, labels=[str(p) for p in ticks])\n", "plt.xlabel(\"Epochs\")\n", "plt.ylabel(\"Accuracy\")\n", "plt.legend()\n", "plt.show()" ] }, { "cell_type": "markdown", "id": "d17bc8b6", "metadata": {}, "source": [ "We see that the more the photons, we get better results as the number of epochs increases showing the better expressivity of the model." ] }, { "cell_type": "markdown", "id": "91c4025a", "metadata": {}, "source": [ "\n", "### How to encode more features than modes.\n", "\n", "To test the new way of using a QuantumLayer, we will try to classify ``scikit.learn``'s ``load_digits`` dataset. It is composed of 8x8 images of hand-written numbers 0 through 9. So, it has 64 features per image, much more than ``simple()`` can handle. It is still an easy dataset to classify in theory.\n", "\n", "Let's load the dataset" ] }, { "cell_type": "code", "execution_count": 17, "id": "e3e0d72e", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Train size: 1347 samples\n", "Test size: 450 samples\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" }, { "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" }, { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "digits = load_digits()\n", "X = digits.data.astype(\"float32\")\n", "y = digits.target.astype(\"int64\")\n", "\n", "X_train, X_test, y_train, y_test = train_test_split(\n", " X,\n", " y,\n", " test_size=0.25,\n", " stratify=y,\n", " random_state=42,\n", ")\n", "\n", "X_train = torch.tensor(X_train, dtype=torch.float32)\n", "X_test = torch.tensor(X_test, dtype=torch.float32)\n", "y_train = torch.tensor(y_train, dtype=torch.long)\n", "y_test = torch.tensor(y_test, dtype=torch.long)\n", "\n", "mean = X_train.mean(dim=0, keepdim=True)\n", "std = X_train.std(dim=0, keepdim=True).clamp_min(1e-6)\n", "X_train = (X_train - mean) / std\n", "X_test = (X_test - mean) / std\n", "\n", "print(f\"Train size: {X_train.shape[0]} samples\")\n", "print(f\"Test size: {X_test.shape[0]} samples\")\n", "\n", "# Plot the first 5 digits\n", "for i in range(5):\n", " plt.imshow(digits.images[i], cmap=\"gray\")\n", " plt.axis(\"off\")\n", " plt.show()" ] }, { "cell_type": "markdown", "id": "7ecfc494", "metadata": {}, "source": [ "Let's create a circuit with 8 modes and 8 angle encoding layers." ] }, { "cell_type": "code", "execution_count": 18, "id": "1efb754c", "metadata": {}, "outputs": [ { "data": { "image/svg+xml": [ "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "CPLX\n", "\n", "\n", "Φ=px1\n", "\n", "\n", "Φ=px2\n", "\n", "\n", "Φ=px3\n", "\n", "\n", "Φ=px4\n", "\n", "\n", "Φ=px5\n", "\n", "\n", "Φ=px6\n", "\n", "\n", "Φ=px7\n", "\n", "\n", "Φ=px8\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "CPLX\n", "\n", "\n", "Φ=px9\n", "\n", "\n", "Φ=px10\n", "\n", "\n", "Φ=px11\n", "\n", "\n", "Φ=px12\n", "\n", "\n", "Φ=px13\n", "\n", "\n", "Φ=px14\n", "\n", "\n", "Φ=px15\n", "\n", "\n", "Φ=px16\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "CPLX\n", "\n", "\n", "Φ=px17\n", "\n", "\n", "Φ=px18\n", "\n", "\n", "Φ=px19\n", "\n", "\n", "Φ=px20\n", "\n", "\n", "Φ=px21\n", "\n", "\n", "Φ=px22\n", "\n", "\n", "Φ=px23\n", "\n", "\n", "Φ=px24\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "CPLX\n", "\n", "\n", "Φ=px25\n", "\n", "\n", "Φ=px26\n", "\n", "\n", "Φ=px27\n", "\n", "\n", "Φ=px28\n", "\n", "\n", "Φ=px29\n", "\n", "\n", "Φ=px30\n", "\n", "\n", "Φ=px31\n", "\n", "\n", "Φ=px32\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "CPLX\n", "\n", "\n", "Φ=px33\n", "\n", "\n", "Φ=px34\n", "\n", "\n", "Φ=px35\n", "\n", "\n", "Φ=px36\n", "\n", "\n", "Φ=px37\n", "\n", "\n", "Φ=px38\n", "\n", "\n", "Φ=px39\n", "\n", "\n", "Φ=px40\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "CPLX\n", "\n", "\n", "Φ=px41\n", "\n", "\n", "Φ=px42\n", "\n", "\n", "Φ=px43\n", "\n", "\n", "Φ=px44\n", "\n", "\n", "Φ=px45\n", "\n", "\n", "Φ=px46\n", "\n", "\n", "Φ=px47\n", "\n", "\n", "Φ=px48\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "CPLX\n", "\n", "\n", "Φ=px49\n", "\n", "\n", "Φ=px50\n", "\n", "\n", "Φ=px51\n", "\n", "\n", "Φ=px52\n", "\n", "\n", "Φ=px53\n", "\n", "\n", "Φ=px54\n", "\n", "\n", "Φ=px55\n", "\n", "\n", "Φ=px56\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "CPLX\n", "\n", "\n", "Φ=px57\n", "\n", "\n", "Φ=px58\n", "\n", "\n", "Φ=px59\n", "\n", "\n", "Φ=px60\n", "\n", "\n", "Φ=px61\n", "\n", "\n", "Φ=px62\n", "\n", "\n", "Φ=px63\n", "\n", "\n", "Φ=px64\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "CPLX\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "0\n", "1\n", "2\n", "3\n", "4\n", "5\n", "6\n", "7\n", "0\n", "1\n", "2\n", "3\n", "4\n", "5\n", "6\n", "7\n", "" ], "text/plain": [ "" ] }, "execution_count": 18, "metadata": {}, "output_type": "execute_result" } ], "source": [ "circuit = ML.CircuitBuilder(n_modes=8)\n", "\n", "circuit.add_entangling_layer()\n", "for _ in range(8):\n", " circuit.add_angle_encoding()\n", " circuit.add_entangling_layer()\n", "\n", "pcvl.pdisplay(circuit.to_pcvl_circuit())" ] }, { "cell_type": "markdown", "id": "fdab16b6", "metadata": {}, "source": [ "Lets run the classification experiment" ] }, { "cell_type": "code", "execution_count": 19, "id": "c0f9bdfd", "metadata": {}, "outputs": [], "source": [ "# A simple training experiment\n", "def run_experiment(layer: torch.nn.Module, epochs: int = 60, lr: float = 0.05):\n", " optimizer = torch.optim.Adam(layer.parameters(), lr=lr)\n", " losses = []\n", " test_accuracies = []\n", " train_accuracies = []\n", " for i in range(epochs):\n", " layer.train()\n", " optimizer.zero_grad()\n", " logits = layer(X_train)\n", " loss = F.cross_entropy(logits, y_train)\n", " loss.backward()\n", " optimizer.step()\n", " losses.append(loss.item())\n", "\n", " layer.eval()\n", " with torch.no_grad():\n", " train_preds = layer(X_train).argmax(dim=1)\n", " test_preds = layer(X_test).argmax(dim=1)\n", " train_acc = (train_preds == y_train).float().mean().item()\n", " test_acc = (test_preds == y_test).float().mean().item()\n", " test_accuracies.append(test_acc)\n", " train_accuracies.append(train_acc)\n", " layer.train()\n", " if (i+1)%25==0:\n", " print(\n", " f\"Epoch {i + 1} had a loss of {losses[-1]}, a training accuracy of {train_acc} and a testing accuracy of {test_acc}\"\n", " )\n", "\n", " layer.eval()\n", " return losses, train_accuracies, test_accuracies" ] }, { "cell_type": "markdown", "id": "57264c71", "metadata": {}, "source": [ "To give the right output size, we will use a ``ML.ModGrouping``strategy to make sure was have an output dimension of 10. It combines the outputs of the quantum circuit in a dimension 10 vector (one dimension per class)." ] }, { "cell_type": "code", "execution_count": 20, "id": "7e8010db", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Epoch 25 had a loss of 2.174989938735962, a training accuracy of 0.41128432750701904 and a testing accuracy of 0.3733333349227905\n", "Epoch 50 had a loss of 2.1213064193725586, a training accuracy of 0.5040831565856934 and a testing accuracy of 0.48444443941116333\n", "Epoch 75 had a loss of 2.065514326095581, a training accuracy of 0.5946547985076904 and a testing accuracy of 0.5933333039283752\n", "Epoch 100 had a loss of 2.0221264362335205, a training accuracy of 0.6481069326400757 and a testing accuracy of 0.653333306312561\n", "Epoch 125 had a loss of 1.9971283674240112, a training accuracy of 0.6748329401016235 and a testing accuracy of 0.6733333468437195\n", "Epoch 150 had a loss of 1.980004906654358, a training accuracy of 0.6889383792877197 and a testing accuracy of 0.6822222471237183\n", "Epoch 175 had a loss of 1.9685148000717163, a training accuracy of 0.6948775053024292 and a testing accuracy of 0.6800000071525574\n", "Epoch 200 had a loss of 1.9598309993743896, a training accuracy of 0.7030438184738159 and a testing accuracy of 0.6933333277702332\n", "Epoch 225 had a loss of 1.9529314041137695, a training accuracy of 0.7045285701751709 and a testing accuracy of 0.695555567741394\n", "Epoch 250 had a loss of 1.9475393295288086, a training accuracy of 0.7060133814811707 and a testing accuracy of 0.695555567741394\n", "Epoch 275 had a loss of 1.9434336423873901, a training accuracy of 0.7067557573318481 and a testing accuracy of 0.699999988079071\n", "Epoch 300 had a loss of 1.9402966499328613, a training accuracy of 0.7067557573318481 and a testing accuracy of 0.6933333277702332\n", "Epoch 325 had a loss of 1.9376776218414307, a training accuracy of 0.7074981331825256 and a testing accuracy of 0.6822222471237183\n", "Epoch 350 had a loss of 1.9351595640182495, a training accuracy of 0.7067557573318481 and a testing accuracy of 0.6800000071525574\n", "Epoch 375 had a loss of 1.9324162006378174, a training accuracy of 0.7067557573318481 and a testing accuracy of 0.6755555272102356\n", "Epoch 400 had a loss of 1.9293900728225708, a training accuracy of 0.7089829444885254 and a testing accuracy of 0.6733333468437195\n", "Epoch 425 had a loss of 1.926409125328064, a training accuracy of 0.7082405090332031 and a testing accuracy of 0.6822222471237183\n", "Epoch 450 had a loss of 1.9238649606704712, a training accuracy of 0.7134372591972351 and a testing accuracy of 0.6911110877990723\n", "Epoch 475 had a loss of 1.9218140840530396, a training accuracy of 0.7112100720405579 and a testing accuracy of 0.6911110877990723\n", "Epoch 500 had a loss of 1.9201419353485107, a training accuracy of 0.7097253203392029 and a testing accuracy of 0.6933333277702332\n" ] }, { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "# Running the experiment\n", "epochs = 500\n", "\n", "qcirc = ML.QuantumLayer(builder=deepcopy(circuit), n_photons=1)\n", "quantum_classifier = nn.Sequential(qcirc, ML.ModGrouping(qcirc.output_size, 10))\n", "\n", "losses, train_acc, test_acc = run_experiment(quantum_classifier, epochs=epochs, lr=0.01)\n", "\n", "# Plotting function\n", "plt.plot(list(range(1, epochs + 1)), train_acc, label=\"train\")\n", "plt.plot(list(range(1, epochs + 1)), test_acc, label=\"test\")\n", "ticks = list(range(1, epochs + 1))\n", "indexes_to_pop = []\n", "index = 0\n", "for i in range(1, epochs + 1):\n", " if i % 100 > 0:\n", " ticks.pop(index)\n", " else:\n", " index += 1\n", "\n", "plt.xticks(ticks=ticks, labels=[str(p) for p in ticks])\n", "plt.xlabel(\"Epochs\")\n", "plt.ylabel(\"Accuracy\")\n", "plt.legend()\n", "plt.show()" ] }, { "cell_type": "markdown", "id": "7f314dd6", "metadata": {}, "source": [ "We observe that with 8 times less modes that ``simple()`` would need, we are still able to classify the dataset." ] }, { "cell_type": "markdown", "id": "33c11ef5", "metadata": {}, "source": [ "Here you go! You are now ready to take advantage of the full power of MerLin's ``QuantumLayer``! The next step in your journey would be to investigate the different data encoding in the quantum circuits which can be found on the [angle amplitude encoding page](../user_guide/angle_amplitude_encoding.rst)." ] } ], "metadata": { "kernelspec": { "display_name": "Python 3", "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.12" } }, "nbformat": 4, "nbformat_minor": 5 }