Datasets
Models
Downloads: 1
Switch to side-by-side view
--- a +++ b/Code/All Qiskit, PennyLane QML Nov 23/19a3 CPU Default.qubit 197.77s kkawchak.ipynb @@ -0,0 +1,1009 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 19, + "metadata": { + "id": "saZVT5NBpGsV", + "colab": { + "base_uri": "https://localhost:8080/", + "height": 0 + }, + "outputId": "728be7b0-5800-4b95-83f4-22ffd988d324" + }, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Time in seconds since beginning of run: 1700503860.1867297\n", + "Mon Nov 20 18:11:00 2023\n" + ] + } + ], + "source": [ + "# This cell is added by sphinx-gallery\n", + "# It can be customized to whatever you like\n", + "%matplotlib inline\n", + "# !pip install pennylane\n", + "import time\n", + "seconds = time.time()\n", + "print(\"Time in seconds since beginning of run:\", seconds)\n", + "local_time = time.ctime(seconds)\n", + "print(local_time)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "IrRdSTiapGsX" + }, + "source": [ + "Quantum advantage in learning from experiments\n", + "==============================================\n", + "\n", + "::: {.meta}\n", + ":property=\\\"og:description\\\": Learn how quantum memory can boost quantum\n", + "machine learning algorithms :property=\\\"og:image\\\":\n", + "<https://pennylane.ai/qml/_images/learning_from_exp_thumbnail.png>\n", + ":::\n", + "\n", + "*Author: Joseph Bowles --- Posted: 18 April 2022. Last updated: 30 June\n", + "2022.*\n", + "\n", + "This demo is based on the article [Quantum advantage in learning from\n", + "experiments](https://arxiv.org/abs/2112.00778) [\\[1\\]](#ref1) by\n", + "Hsin-Yuan Huang and co-authors. The article investigates the following\n", + "question:\n", + "\n", + "*How useful is access to quantum memory for quantum machine learning?*\n", + "\n", + "They show that access to quantum memory can make a big difference, and\n", + "prove that there exist learning problems for which algorithms with\n", + "quantum memory require *exponentially less resources* than those\n", + "without. We look at one learning task studied in [\\[1\\]](#ref1) for\n", + "which this is the case.\n", + "\n", + "The learning task\n", + "-----------------\n", + "\n", + "The learning task we focus on involves deciding if a unitary is\n", + "time-reversal symmetric (we'll call them T-symmetric) or not.\n", + "Mathematically, time-reversal symmetry in quantum mechanics involves\n", + "reversing the sense of $i$ so that $i \\rightarrow -i$. Hence, a unitary\n", + "$U$ is T-symmetric if\n", + "\n", + "$$U^*=U.$$\n", + "\n", + "Now for the learning task. Let's say we have a bunch of quantum circuits\n", + "$U_1, \\cdots, U_n$, some of which are T-symmetric and some not, but we\n", + "are not told which ones are which.\n" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "LkLkc0PApGsY" + }, + "source": [ + "{.align-center\n", + "width=\"50.0%\"}\n" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "5ExBGwcOpGsY" + }, + "source": [ + "The task is to design an algorithm to determine which of the $U$'s are\n", + "T-symmetric and which are not, given query access to the unitaries. Note\n", + "that we do not have any labels here, so this is an unsupervised learning\n", + "task. To make things concrete, let's consider unitaries acting on 8\n", + "qubits. We will also limit the number of times we can use each unitary:\n" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": { + "id": "lLqfHqpCpGsY" + }, + "outputs": [], + "source": [ + "qubits = 8 # the number of qubits on which the unitaries act\n", + "n_shots = 100 # the number of times we can use each unitary" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "QqtOm_d4pGsY" + }, + "source": [ + "Experiments with and without a quantum memory\n", + "=============================================\n" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "4lhh8844pGsZ" + }, + "source": [ + "To tackle this task we consider experiments with and without quantum\n", + "memory. We also assume that we have access to a single physical\n", + "realization of each unitary; in other words, we do not have multiple\n", + "copies of the devices that implement $U_i$.\n", + "\n", + "An experiment without quantum memory can therefore only make use of a\n", + "single query to $U_i$ in each circuit, since querying $U_i$ again would\n", + "require storing the state of the first query in memory and re-using the\n", + "unitary. In the paper these experiments are called **conventional\n", + "experiments**.\n", + "\n", + "Experiments with quantum memory do not have the limitations of\n", + "conventional experiments. This means that multiple queries can be made\n", + "to $U_i$ in a single circuit, which can be realized in practice by using\n", + "a quantum memory. These experiments are called **quantum-enhanced\n", + "experiments**.\n", + "\n", + "Note that we are not comparing classical and quantum algorithms here,\n", + "but rather two classes of quantum algorithms.\n" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "NQUrpuZmpGsZ" + }, + "source": [ + "{.align-center\n", + "width=\"60.0%\"}\n" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "gVDTZPuLpGsZ" + }, + "source": [ + "The conventional way\n", + "====================\n" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "H4NZdjTMpGsZ" + }, + "source": [ + "First, we will try to solve the task with a conventional experiment. Our\n", + "strategy will be as follows:\n", + "\n", + "- For each $U_i$, we prepare `n_shots` copies of the state\n", + " $U_i\\vert0\\rangle$ and measure each state to generate classical\n", + " measurement data.\n", + "- Use an unsupervised classical machine learning algorithm (kernel\n", + " PCA), to try and separate the data into two clusters corresponding\n", + " to T-symmetric unitaries vs. the rest.\n", + "\n", + "If we succeed in clustering the data then we have successfully managed\n", + "to discriminate the two classes!\n" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "3cBEdL1QpGsa" + }, + "source": [ + "{.align-center\n", + "width=\"70.0%\"}\n" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "VEg1RDR4pGsa" + }, + "source": [ + "To generate the measurement data, we will measure the states\n", + "$U_i\\vert0\\rangle$ in the $y$ basis. The local expectation values take\n", + "the form\n", + "\n", + "$$E_i = \\langle 0\\vert U^{\\dagger}\\sigma_y^{(i)} U \\vert 0 \\rangle.$$\n", + "\n", + "where $\\sigma_y^{(i)}$ acts on the $i^{\\text{th}}$ qubit.\n", + "\n", + "Using the fact that $\\sigma_y^*=-\\sigma_y$ and the property $U^*=U$ for\n", + "T-symmetric unitaries, one finds\n", + "\n", + "$$E_i^*=\\langle 0\\vert (U^{\\dagger})^*(\\sigma_y^{(i)})^* (U)^* \\vert 0 \\rangle = - \\langle 0\\vert U^{\\dagger}\\sigma_y^{(i)} U \\vert 0 \\rangle = - E_i.$$\n", + "\n", + "Since $E_i$ is a real number, the only solution to this is $E_i=0$,\n", + "which implies that all local expectations values are 0 for this class.\n", + "\n", + "For general unitaries it is not the case that $E_i=0$, and so it seems\n", + "as though this will allow us to discriminate the two classes of circuits\n", + "easily. However, for general random unitaries the local expectation\n", + "values approach zero exponentially with the number of qubits: from\n", + "finite measurement data it can still be very hard to see any difference!\n", + "In fact, in the article [exponential separations between learning with\n", + "and without quantum memory](https://arxiv.org/abs/2111.05881)\n", + "[\\[2\\]](#ref2) it is proven that using conventional experiments, any\n", + "successful algorithm *must* use the unitaries an exponential number of\n", + "times.\n" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "VeMMzIc7pGsa" + }, + "source": [ + "Let's see how this looks in practice. First we define a function to\n", + "generate random unitaries, making use of Pennylane's\n", + "[RandomLayers](https://pennylane.readthedocs.io/en/stable/code/api/pennylane.RandomLayers.html)\n", + "template. For the time-symmetric case we will only allow for Y\n", + "rotations, since these unitaries contain only real numbers, and\n", + "therefore result in T-symmetric unitaries. For the other unitaries, we\n", + "will allow rotations about X,Y, and Z.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "metadata": { + "id": "IIqOveLhpGsa" + }, + "outputs": [], + "source": [ + "import pennylane as qml\n", + "from pennylane.templates.layers import RandomLayers\n", + "from pennylane import numpy as np\n", + "\n", + "np.random.seed(234087)\n", + "\n", + "layers, gates = 10, 10 # the number of layers and gates used in RandomLayers\n", + "\n", + "\n", + "def generate_circuit(shots):\n", + " \"\"\"\n", + " generate a random circuit that returns a number of measuement samples\n", + " given by shots\n", + " \"\"\"\n", + " dev = qml.device(\"default.qubit\", wires=qubits, shots=shots)\n", + "\n", + " @qml.qnode(dev)\n", + " def circuit(ts=False):\n", + "\n", + " if ts == True:\n", + " ops = [qml.RY] # time-symmetric unitaries\n", + " else:\n", + " ops = [qml.RX, qml.RY, qml.RZ] # general unitaries\n", + "\n", + " weights = np.random.rand(layers, gates) * np.pi\n", + " RandomLayers(weights, wires=range(qubits), ratio_imprim=0.0001, rotations=ops, seed=np.random.randint(0, 10000))\n", + "\n", + " return [qml.sample(op=qml.PauliY(q)) for q in range(qubits)]\n", + "\n", + " return circuit" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "hjafWs6opGsa" + }, + "source": [ + "let's check if that worked:\n" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 0 + }, + "id": "PDxmRpoDpGsa", + "outputId": "fd74c926-6b83-4828-d5cf-f32271245500" + }, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "[[-1 1 -1]\n", + " [-1 -1 -1]\n", + " [ 1 -1 -1]\n", + " [-1 -1 1]\n", + " [ 1 1 1]\n", + " [-1 -1 1]\n", + " [ 1 -1 1]\n", + " [ 1 -1 -1]]\n", + "\n", + "\n", + "[[-1 -1 -1]\n", + " [-1 1 1]\n", + " [ 1 -1 1]\n", + " [ 1 1 1]\n", + " [-1 -1 -1]\n", + " [ 1 -1 1]\n", + " [ 1 1 -1]\n", + " [ 1 1 -1]]\n" + ] + } + ], + "source": [ + "# the measurement outcomes for the first 3 shots\n", + "circuit = generate_circuit(n_shots)\n", + "print(np.array(circuit(ts=True))[:, 0:3])\n", + "print(\"\\n\")\n", + "print(np.array(circuit(ts=False))[:, 0:3])" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "fqoyiIk3pGsb" + }, + "source": [ + "Now we can generate some data. The first 30 circuits in the data set are\n", + "T-symmetric and the second 30 circuits are not. Since we are in an\n", + "unsupervised setting, the algorithm will not know this information.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "metadata": { + "id": "m8naW3HRpGsb" + }, + "outputs": [], + "source": [ + "circuits = 30 # the number of circuits in each data set\n", + "\n", + "raw_data = []\n", + "\n", + "for ts in [True, False]:\n", + " for __ in range(circuits):\n", + " circuit = generate_circuit(n_shots)\n", + " raw_data.append(circuit(ts=ts))" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "XJIyrRYMpGsb" + }, + "source": [ + "Before feeding the data to a clustering algorithm, we will process it a\n", + "little. For each circuit, we calculate the mean and the variance of each\n", + "output bit and store this in a vector of size `2*qubits`. These vectors\n", + "make up our classical data set.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "metadata": { + "id": "_tpgsRE_pGsb" + }, + "outputs": [], + "source": [ + "def process_data(raw_data):\n", + " \"convert raw data to vectors of means and variances of each qubit\"\n", + "\n", + " raw_data = np.array(raw_data)\n", + " nc = len(raw_data) # the number of circuits used to generate the data\n", + " nq = len(raw_data[0]) # the number of qubits in each circuit\n", + " new_data = np.zeros([nc, 2 * nq])\n", + "\n", + " for k, outcomes in enumerate(raw_data):\n", + " means = [np.mean(outcomes[q, :]) for q in range(nq)]\n", + " variances = [np.var(outcomes[q, :]) for q in range(nq)]\n", + " new_data[k] = np.array(means + variances)\n", + "\n", + " return new_data\n", + "\n", + "\n", + "data = process_data(raw_data)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "GWRIxXZcpGsb" + }, + "source": [ + "Now we use scikit-learn's [kernel\n", + "PCA](https://en.wikipedia.org/wiki/Kernel_principal_component_analysis)\n", + "package to try and cluster the data. This performs principal component\n", + "analysis in a high dimensional feature space defined by a kernel (below\n", + "we use the radial basis function kernel).\n" + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "metadata": { + "id": "3r7XYPtspGsb" + }, + "outputs": [], + "source": [ + "from sklearn.decomposition import KernelPCA\n", + "from sklearn import preprocessing\n", + "\n", + "kernel_pca = KernelPCA(\n", + " n_components=None, kernel=\"rbf\", gamma=None, fit_inverse_transform=True, alpha=0.1\n", + ")\n", + "\n", + "# rescale the data so it has unit standard deviation and zero mean.\n", + "scaler = preprocessing.StandardScaler().fit(data)\n", + "data = scaler.transform(data)\n", + "# try to cluster the data\n", + "fit = kernel_pca.fit(data).transform(data)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "Ebvo16Y5pGsb" + }, + "source": [ + "Let's plot the result. Here we look at the first two principal\n", + "components.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 26, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 430 + }, + "id": "MVbFwU-LpGsc", + "outputId": "2b2fa148-87c7-4afb-b249-47f8c86f36a4" + }, + "outputs": [ + { + "output_type": "display_data", + "data": { + "text/plain": [ + "<Figure size 640x480 with 1 Axes>" + ], + "image/png": "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\n" + }, + "metadata": {} + } + ], + "source": [ + "import matplotlib.pyplot as plt\n", + "\n", + "# make a colour map for the points\n", + "c = np.array([0 for __ in range(circuits)] + [1 for __ in range(circuits)])\n", + "\n", + "plt.scatter(fit[:, 0], fit[:, 1], c=c)\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "SlrsWm7ZpGsc" + }, + "source": [ + "Looks like the algorithm failed to cluster the data. We can try to get a\n", + "separation by increasing the number of shots. Let's increase the number\n", + "of shots by 100 and see what happens.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 27, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 430 + }, + "id": "tfVK7J8OpGsc", + "outputId": "18b25c0b-a858-4371-f67f-b513e924fd96" + }, + "outputs": [ + { + "output_type": "display_data", + "data": { + "text/plain": [ + "<Figure size 640x480 with 1 Axes>" + ], + "image/png": "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\n" + }, + "metadata": {} + } + ], + "source": [ + "n_shots = 10000 # 100 x more shots\n", + "\n", + "raw_data = []\n", + "\n", + "for ts in [True, False]:\n", + " for __ in range(circuits):\n", + " circuit = generate_circuit(n_shots)\n", + " raw_data.append(circuit(ts=ts))\n", + "\n", + "data = process_data(raw_data)\n", + "scaler = preprocessing.StandardScaler().fit(data)\n", + "data = scaler.transform(data)\n", + "\n", + "fit = kernel_pca.fit(data).transform(data)\n", + "\n", + "plt.scatter(fit[:, 0], fit[:, 1], c=c)\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "n2F2k_CRpGsc" + }, + "source": [ + "Now we have a separation, however we required a lot of shots from the\n", + "quantum circuit. As we increase the number of qubits, the number of\n", + "shots we need will scale exponentially (as shown in [\\[2\\]](#ref2)), and\n", + "so conventional strategies cannot learn to separate the data\n", + "efficiently.\n" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "aLJp5ud_pGsc" + }, + "source": [ + "The quantum-enhanced way\n", + "========================\n", + "\n", + "Now let's see what difference having a quantum memory can make. Instead\n", + "of using a single unitary to generate measurement data, we will make use\n", + "of twice the number of qubits, and apply the unitary twice:\n" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "jSO6utq0pGsc" + }, + "source": [ + "{.align-center\n", + "width=\"70.0%\"}\n" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "UNE5n_sGpGsc" + }, + "source": [ + "In practice, this could be done by storing the output state from the\n", + "first unitary in quantum memory and preparing the same state by using\n", + "the unitary again. Let's define a function `enhanced_circuit()` to\n", + "implement that. Note that since we now have twice as many qubits, we use\n", + "half the number of shots as before so that the total number of uses of\n", + "the unitary is unchanged.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 28, + "metadata": { + "id": "jpZYLZkzpGsc" + }, + "outputs": [], + "source": [ + "n_shots = 50\n", + "qubits = 8\n", + "\n", + "dev = qml.device(\"default.qubit\", wires=qubits * 2, shots=n_shots)\n", + "\n", + "\n", + "@qml.qnode(dev)\n", + "def enhanced_circuit(ts=False):\n", + " \"implement the enhanced circuit, using a random unitary\"\n", + "\n", + " if ts == True:\n", + " ops = [qml.RY]\n", + " else:\n", + " ops = [qml.RX, qml.RY, qml.RZ]\n", + "\n", + " weights = np.random.rand(layers, n_shots) * np.pi\n", + " seed = np.random.randint(0, 10000)\n", + "\n", + " for q in range(qubits):\n", + " qml.Hadamard(wires=q)\n", + "\n", + " qml.broadcast(\n", + " qml.CNOT, pattern=[[q, qubits + q] for q in range(qubits)], wires=range(qubits * 2)\n", + " )\n", + " RandomLayers(weights, wires=range(0, qubits), ratio_imprim=0.0001, rotations=ops, seed=seed)\n", + " RandomLayers(weights, wires=range(qubits, 2 * qubits), ratio_imprim=0.0001, rotations=ops, seed=seed)\n", + " qml.broadcast(\n", + " qml.CNOT, pattern=[[q, qubits + q] for q in range(qubits)], wires=range(qubits * 2)\n", + " )\n", + "\n", + " for q in range(qubits):\n", + " qml.Hadamard(wires=q)\n", + "\n", + " return [qml.sample(op=qml.PauliZ(q)) for q in range(2 * qubits)]" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "EgGQFWO6pGsc" + }, + "source": [ + "Now we generate some raw measurement data, and calculate the mean and\n", + "variance of each qubit as before. Our data vectors are now twice as long\n", + "since we have twice the number of qubits.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 29, + "metadata": { + "id": "PeJwszSvpGsd" + }, + "outputs": [], + "source": [ + "raw_data = []\n", + "\n", + "for ts in [True, False]:\n", + " for __ in range(circuits):\n", + " raw_data.append(enhanced_circuit(ts))\n", + "\n", + "data = process_data(raw_data)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "6BhOJM0XpGsd" + }, + "source": [ + "Let's throw that into Kernel PCA again and plot the result.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 30, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 430 + }, + "id": "PoL0WA_ypGsd", + "outputId": "5048148c-8678-41b7-ef34-9ab5616a45b5" + }, + "outputs": [ + { + "output_type": "display_data", + "data": { + "text/plain": [ + "<Figure size 640x480 with 1 Axes>" + ], + "image/png": "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\n" + }, + "metadata": {} + } + ], + "source": [ + "kernel_pca = KernelPCA(\n", + " n_components=None, kernel=\"rbf\", gamma=None, fit_inverse_transform=True, alpha=0.1\n", + ")\n", + "\n", + "scaler = preprocessing.StandardScaler().fit(data)\n", + "data = scaler.transform(data)\n", + "\n", + "fit = kernel_pca.fit(data).transform(data)\n", + "\n", + "c = np.array([0 for __ in range(circuits)] + [1 for __ in range(circuits)])\n", + "plt.scatter(fit[:, 0], fit[:, 1], c=c)\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "Ylz4xQPupGsd" + }, + "source": [ + "Kernel PCA has perfectly separated the two classes! In fact, all the\n", + "T-symmetric unitaries have been mapped to the same point. This is\n", + "because the circuit is actually equivalent to performing\n", + "$U^TU\\otimes \\mathbb{I}\\vert 0 \\rangle$, which for T-symmetric unitaries\n", + "is just the identity operation.\n", + "\n", + "To see this, note that the Hadamard and CNOT gates before\n", + "$U_i\\otimes U_i$ map the $\\vert0\\rangle$ state to the maximally entanged\n", + "state\n", + "$\\vert \\Phi^+\\rangle = \\frac{1}{\\sqrt{2}}(\\vert 00...0\\rangle+ \\vert11...1\\rangle$,\n", + "and the gates after $U_i\\otimes U_i$ are just the inverse\n", + "transformation. The probability that all measurement outcomes give the\n", + "result $+1$ is therefore.\n", + "\n", + "$$p(11\\cdots 1) = \\langle \\Phi^+ \\vert U_i \\otimes U_i \\vert\\Phi^+ \\rangle.$$\n", + "\n", + "A well known fact about the maximally entanged state is that\n", + "$U\\otimes \\mathbb{I}\\vert\\Phi^+\\rangle= \\mathbb{I}\\otimes U^T\\vert\\Phi^+\\rangle$.\n", + "The probabilty is therefore\n", + "\n", + "$$p(11\\cdots 1) = \\langle \\Phi^+ \\vert U_i^T U_i \\otimes \\mathbb{I} \\vert\\Phi^+ \\rangle.$$\n", + "\n", + "For T-symmetric unitaries $U_i^T=U_i^\\dagger$, so this probability is\n", + "equal to one: the $11\\cdots 1$ outcome is always obtained.\n", + "\n", + "If we look at the raw measurement data for the T-symmetric unitaries:\n" + ] + }, + { + "cell_type": "code", + "execution_count": 31, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 0 + }, + "id": "tJPkMr8XpGsd", + "outputId": "f52c0e40-1448-407f-d385-d00f8cdb5ea3" + }, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "tensor([[1, 1, 1, 1, 1],\n", + " [1, 1, 1, 1, 1],\n", + " [1, 1, 1, 1, 1],\n", + " [1, 1, 1, 1, 1],\n", + " [1, 1, 1, 1, 1],\n", + " [1, 1, 1, 1, 1],\n", + " [1, 1, 1, 1, 1],\n", + " [1, 1, 1, 1, 1],\n", + " [1, 1, 1, 1, 1],\n", + " [1, 1, 1, 1, 1],\n", + " [1, 1, 1, 1, 1],\n", + " [1, 1, 1, 1, 1],\n", + " [1, 1, 1, 1, 1],\n", + " [1, 1, 1, 1, 1],\n", + " [1, 1, 1, 1, 1],\n", + " [1, 1, 1, 1, 1]], requires_grad=True)" + ] + }, + "metadata": {}, + "execution_count": 31 + } + ], + "source": [ + "np.array(raw_data[0])[:, 0:5] # outcomes of first 5 shots of the first T-symmetric circuit" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "RCbeEgB9pGsd" + }, + "source": [ + "We see that indeed this is the only measurement outcome.\n", + "\n", + "To make things a bit more interesting, let's add some noise to the\n", + "circuit. We will define a function `noise_layer(epsilon)` that adds some\n", + "random single qubit rotations, where the maximum rotation angle is\n", + "`epsilon`.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 32, + "metadata": { + "id": "oj_9u5_ipGsd" + }, + "outputs": [], + "source": [ + "def noise_layer(epsilon):\n", + " \"apply a random rotation to each qubit\"\n", + " for q in range(2 * qubits):\n", + " angles = (2 * np.random.rand(3) - 1) * epsilon\n", + " qml.Rot(angles[0], angles[1], angles[2], wires=q)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "R1FYa3ltpGse" + }, + "source": [ + "We redefine our `enhanced_circuit()` function with a noise layer applied\n", + "after the unitaries\n" + ] + }, + { + "cell_type": "code", + "execution_count": 33, + "metadata": { + "id": "dFNylIKDpGse" + }, + "outputs": [], + "source": [ + "@qml.qnode(dev)\n", + "def enhanced_circuit(ts=False):\n", + " \"implement the enhanced circuit, using a random unitary with a noise layer\"\n", + "\n", + " if ts == True:\n", + " ops = [qml.RY]\n", + " else:\n", + " ops = [qml.RX, qml.RY, qml.RZ]\n", + "\n", + " weights = np.random.rand(layers, n_shots) * np.pi\n", + " seed = np.random.randint(0, 10000)\n", + "\n", + " for q in range(qubits):\n", + " qml.Hadamard(wires=q)\n", + "\n", + " qml.broadcast(\n", + " qml.CNOT, pattern=[[q, qubits + q] for q in range(qubits)], wires=range(qubits * 2)\n", + " )\n", + " RandomLayers(weights, wires=range(0, qubits), ratio_imprim=0.0001, rotations=ops, seed=seed)\n", + " RandomLayers(weights, wires=range(qubits, 2 * qubits), ratio_imprim=0.0001, rotations=ops, seed=seed)\n", + " noise_layer(np.pi / 4) # added noise layer\n", + " qml.broadcast(\n", + " qml.CNOT, pattern=[[qubits + q, q] for q in range(qubits)], wires=range(qubits * 2)\n", + " )\n", + "\n", + " for q in range(qubits):\n", + " qml.Hadamard(wires=qubits + q)\n", + "\n", + " return [qml.sample(op=qml.PauliZ(q)) for q in range(2 * qubits)]" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "oke1LvWDpGse" + }, + "source": [ + "Now we generate the data and feed it to kernel PCA again.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 34, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 430 + }, + "id": "NnBgZF7TpGse", + "outputId": "050f324d-6efe-4642-be23-c0e78cc053eb" + }, + "outputs": [ + { + "output_type": "display_data", + "data": { + "text/plain": [ + "<Figure size 640x480 with 1 Axes>" + ], + "image/png": "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\n" + }, + "metadata": {} + } + ], + "source": [ + "raw_data = []\n", + "\n", + "for ts in [True, False]:\n", + " for __ in range(circuits):\n", + " raw_data.append(enhanced_circuit(ts))\n", + "\n", + "data = process_data(raw_data)\n", + "\n", + "kernel_pca = KernelPCA(\n", + " n_components=None, kernel=\"rbf\", gamma=None, fit_inverse_transform=True, alpha=0.1\n", + ")\n", + "scaler = preprocessing.StandardScaler().fit(data)\n", + "data = scaler.transform(data)\n", + "fit = kernel_pca.fit(data).transform(data)\n", + "\n", + "c = np.array([0 for __ in range(circuits)] + [1 for __ in range(circuits)])\n", + "plt.scatter(fit[:, 0], fit[:, 1], c=c)\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "dQHy4Y0ZpGse" + }, + "source": [ + "Nice! Even in the presence of noise we still have a clean separation of\n", + "the two classes. This shows that using entanglement can make a big\n", + "difference to learning.\n" + ] + }, + { + "cell_type": "code", + "source": [ + "seconds = time.time()\n", + "print(\"Time in seconds since end of run:\", seconds)\n", + "local_time = time.ctime(seconds)\n", + "print(local_time)" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 0 + }, + "id": "znxK-ted5Yae", + "outputId": "07d25e49-f380-45a1-c8c6-a679f9041e4f" + }, + "execution_count": 35, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Time in seconds since end of run: 1700504057.9524357\n", + "Mon Nov 20 18:14:17 2023\n" + ] + } + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "QNYu0GLrpGse" + }, + "source": [ + "References\n", + "==========\n", + "\n", + "\\[1\\] *Quantum advantage in learning from experiments*, Hsin-Yuan Huang\n", + "et. al., [arxiv:2112.00778](https://arxiv.org/pdf/2112.00778.pdf) (2021)\n", + "\n", + "\\[2\\] *Exponential separations between learning with and without quantum\n", + "memory*, Sitan Chen, Jordan Cotler, Hsin-Yuan Huang, Jerry Li,\n", + "[arxiv:2111.05881](https://arxiv.org/abs/2111.05881) (2021)\n", + "\n", + "About the author\n", + "================\n" + ] + } + ], + "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.9.17" + }, + "colab": { + "provenance": [] + } + }, + "nbformat": 4, + "nbformat_minor": 0 +}