{ "cells": [ { "cell_type": "markdown", "metadata": { "gloss": { "computational-basis-state": { "text": "Also known as Z-basis states, these are the states we measure when we measure in the Z (or 'computational') basis. These are the states with labels like |00〉 and |00110100〉. IBM systems always measure in the Z-basis.", "title": "computational basis state" }, "features": { "text": "A feature is a property of the things we're trying to learn about that we can assign a number to. If we were learning something about cats, the features might be \"height\" or \"age\" or \"propensity to consume treats\".", "title": "features" }, "unitary": { "text": "A unitary operation is a reversible operation that preserves the norm (i.e. makes sure our probabilities always sum to 1). Read more.", "title": "unitary" } }, "id": "UZF_2zRBNKKu" }, "source": "# Data encoding\n\nIn this page, we will introduce the problem of data encoding for quantum machine learning, then describe and implement various data encoding methods." }, { "cell_type": "markdown", "metadata": { "id": "yIP2dJQQNKKz" }, "source": "## Introduction\n\nData representation is crucial for the success of machine learning models. For classical machine learning, the problem is how to represent the data numerically, so that it can be best processed by a classical machine learning algorithm.\n\nFor quantum machine learning, this question is similar, but more fundamental: how to represent and efficiently input the data into a quantum system, so that it can be processed by a quantum machine learning algorithm. This is usually referred to as data *encoding*, but is also called data *embedding* or *loading*.\n\nThis process is a critical part of quantum machine learning algorithms and directly affects their computational power." }, { "cell_type": "markdown", "metadata": { "formulas": { "_ket-dataset": { "meaning": "This is a quantum statevector that represents our dataset, 𝒳.", "say": "Ket script X" }, "_ket-x": { "meaning": "This vertical bar and angled bracket mean we're referring to a ket (column vector) with label 'x'.", "say": "Ket x" }, "_m": { "meaning": "This is the number of entries in our dataset." }, "_sum-m": { "meaning": "This notation means we add together |xm〉 (the mth element of our dataset) for all values of m between 1 and M (i.e., the entire dataset).", "say": "Sum of all computational basis states in our dataset (𝒳)" }, "_x-lil-m": { "meaning": "This is the mth element of the dataset. It is an N-dimensional vector. Here, the 'm' is just used to mean \"any number between 1 and M\"", "say": "X little-M" }, "brace": { "meaning": "These curly brackets (braces) mean everything inside the brackets forms a set.", "say": "Brace (or \"curly bracket\")", "type": "Universal notation" }, "ellipsis": { "meaning": "These dots omit things where the pattern can be implied.", "say": "Ellipsis", "type": "Universal notation" }, "in": { "meaning": "This symbol means the things to the left of the symbol are contained in the set to the right of the symbol.", "say": "In", "type": "Universal notation" }, "script-x": { "meaning": "This is a symbol we’ve chosen to represent our dataset.", "say": "Script X", "type": "Locally defined variable" } }, "id": "SEzY7nEVNKK0" }, "source": "## Methods\n\nLet's consider a classical dataset $\\mathscr{X}$ consisting of $M$ samples, each with $N$ [features](gloss:features):\n\n$$\\class{script-x}{\\mathscr{X}} = \\class{brace}{\\{}x^{(1)},\\class{ellipsis}{\\dots},\\cssId{_x-lil-m}{x^{(m)}},\\dots,x^{(M)}\\class{brace}{\\}}$$\n\nwhere $x^{(m)}$ is an $N$ dimensional vector for $m = 1, ..., M$. To represent this dataset in a qubit system, we can use various embedding techniques, some of which are briefly explained and implemented below, as per References [1](#References) and [2](#References)." }, { "cell_type": "markdown", "metadata": { "id": "RbLJ-XT0NKK0" }, "source": "### Basis encoding\n\nBasis encoding associates a classical $N$-bit string with a [computational basis state](gloss:computational-basis-state) of a $N$-qubit system. For example, if $x = 5$, this can be represented as a $4$-bit string as $0101$, and by a $4$-qubit system as the quantum state $|0101\\rangle$. More generally, for an $N$-bit string: $x = (b_1, b_2, ... , b_N)$, the corresponding $N$-qubit state is $\\cssId{ket-x}{| x \\rangle} = | b_1, b_2, ... , b_N \\rangle$ with $b_n \\class{in}{\\in} \\{0,1\\}$ for $n = 1 , \\dots , N$.\n\nFor the classical dataset $\\mathscr{X}$ described above, to use basis encoding, each data point must be a $N$-bit string: $x^{(m)} = (b_1, b_2, ... , b_N)$, which then can be mapped directly to the quantum state $|x^{m}\\rangle = |b_1, b_2, ... , b_N \\rangle$ with $b_n \\in \\{0, 1 \\} $ for $n = 1, ..., N$ and $m = 1, ..., M$. We can represent the entire dataset as superpositions of computational basis states:\n\n$$\\cssId{_ket-dataset}{| \\mathscr{X} \\rangle} = \\frac{1}{\\sqrt{\\cssId{_m}{M}}}\\cssId{_sum-m}{\\sum_{m=1}^{M}|x^{m} \\rangle} $$\n\n\n\n### Basis encoding\n\n q-statevector-binary-encoding\n p Add/remove bit strings to/from our input dataset on the left to see how basis encoding encodes this in the state vector on the right.\n\n\n\nIn Qiskit, once we calculate what state will encode our dataset, we can use the `initialize` function to prepare it. For example, the dataset $\\mathscr{X} = \\{x^{(1)}=101, x^{(2)}=111\\}$ is encoded as the state $|\\mathscr{X}\\rangle= \\frac{1}{\\sqrt{2}}(|101\\rangle+|111\\rangle)$:" }, { "cell_type": "code", "execution_count": 1, "metadata": { "id": "LBVMr-9vNKK1", "executionInfo": { "status": "error", "timestamp": 1787112536379, "user_tz": -180, "elapsed": 542, "user": { "displayName": "Joseph Volkan ÖZCAN", "userId": "11389530967736397480" } }, "outputId": "1ecc2b95-a511-46f5-f333-6152d7c4ccae", "colab": { "base_uri": "https://localhost:8080/", "height": 378 } }, "outputs": [ { "output_type": "error", "ename": "ModuleNotFoundError", "evalue": "No module named 'qiskit'", "traceback": [ "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", "\u001b[0;31mModuleNotFoundError\u001b[0m Traceback (most recent call last)", "\u001b[0;32m/tmp/ipykernel_1091/2242919659.py\u001b[0m in \u001b[0;36m\u001b[0;34m()\u001b[0m\n\u001b[1;32m 1\u001b[0m \u001b[0;32mimport\u001b[0m \u001b[0mmath\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 2\u001b[0;31m \u001b[0;32mfrom\u001b[0m \u001b[0mqiskit\u001b[0m \u001b[0;32mimport\u001b[0m \u001b[0mQuantumCircuit\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 3\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 4\u001b[0m desired_state = [\n\u001b[1;32m 5\u001b[0m \u001b[0;36m0\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", "\u001b[0;31mModuleNotFoundError\u001b[0m: No module named 'qiskit'", "", "\u001b[0;31m---------------------------------------------------------------------------\u001b[0;32m\nNOTE: If your import is failing due to a missing package, you can\nmanually install dependencies using either !pip or !apt.\n\nTo view examples of installing some common dependencies, click the\n\"Open Examples\" button below.\n\u001b[0;31m---------------------------------------------------------------------------\u001b[0m\n" ], "errorDetails": { "actions": [ { "action": "open_url", "actionText": "Open Examples", "url": "/notebooks/snippets/importing_libraries.ipynb" } ] } } ], "source": "import math\nfrom qiskit import QuantumCircuit\n\ndesired_state = [\n 0,\n 0,\n 0,\n 0,\n 0,\n 1 / math.sqrt(2),\n 0,\n 1 / math.sqrt(2)]\n\nqc = QuantumCircuit(3)\nqc.initialize(desired_state, [0,1,2])\nqc.decompose().decompose().decompose().decompose().decompose().draw()" }, { "cell_type": "markdown", "metadata": { "id": "GOEOsSR_NKK5" }, "source": "This example illustrates a couple of disadvantages of basis encoding. While it is simple to understand, the state vectors can become quite sparse, and schemes to implement it are usually not efficient." }, { "cell_type": "markdown", "metadata": { "formulas": { "_a-norm": { "meaning": "This is a normalization constant. We can calculate it from the inverse of the Euclidean (l2) norm of the datapoint vector.", "say": "A norm" } }, "id": "XDY6evGsNKK6" }, "source": "### Amplitude encoding\n\nAmplitude encoding encodes data into the amplitudes of a quantum state. It represents a normalised classical $N$-dimensional data point, $x$, as the amplitudes of a $n$-qubit quantum state, $|\\psi_x\\rangle$:\n\n$$|\\psi_x\\rangle = \\sum_{i=1}^N x_i |i\\rangle$$\n\nwhere $N = 2^n$, $x_i$ is the $i^{th}$ element of $x$ and $|i\\rangle$ is the $i^{th}$ computational basis state.\n\nTo encode the classical dataset $\\mathscr{X}$ described above, we concatenate all $M$ $N$-dimensional data points into one amplitude vector, of length $N \\times M$:\n\n$$\\alpha=\\cssId{_a-norm}{A_{\\text{norm}}}(x_{1}^{(1)},...,x_{N}^{(1)},...,x_{1}^{(m)},...,x_{N}^{(m)},...,x_{1}^{(M)},...,x_{N}^{(M)})$$\n\nwhere $A_{\\text{norm}}$ is a normalisation constant, such that $|\\alpha|^2 = 1$. The dataset $\\mathscr{X}$ can now be represented in the computational basis as:\n\n$$|\\mathscr{X}\\rangle = \\sum_{i=1}^N \\alpha_i |i\\rangle$$\n\nwhere $\\alpha_i$ are elements of the amplitude vector and $|i\\rangle$ are the computational basis states. The number of amplitudes to be encoded is $N \\times M$. As a system of $n$ qubits provides $2^n$ amplitudes, amplitude embedding requires $n \\ge \\mathrm{log}_2(NM)$ qubits.\n\n\n\n### Amplitude encoding\n\n q-statevector-amplitude-encoding\n p Change the values of the data points on the left, and see how amplitude encoding encodes these as a state vector on the right.\n\n\n\nAs an example, let's encode the dataset $\\mathscr{X}= \\{x^{(1)}=(1.5,0), x^{(2)}=(-2,3)\\}$ using amplitude encoding. Concatenating both data points and normalizing the resulting vector, we get:\n\n$$\\alpha = \\frac{1}{\\sqrt{15.25}}(1.5,0,-2,3)$$\n\nand the resulting 2-qubit quantum state would be:\n\n$$|\\mathscr{X}\\rangle = \\frac{1}{\\sqrt{15.25}}(1.5|00\\rangle-2|10\\rangle+3|11\\rangle)$$\n\nIn the example above, the total number of elements of the amplitude vector, $N \\times M$, is a power of 2. When $N \\times M$ is not a power of 2, we can simply choose a value for $n$ such that $2^n\\geq MN$ and pad the amplitude vector with uninformative constants.\n\nLike in basis encoding, once we calculate what state will encode our dataset, in Qiskit we can use the `initialize` function to prepare it:" }, { "cell_type": "code", "execution_count": null, "metadata": { "id": "W5abUoquNKK6", "outputId": "c02f7550-bcb1-4d9a-958c-6344752f16de" }, "outputs": [ { "data": { "image/svg+xml": [ "" ], "text/plain": [ "
" ] }, "execution_count": 2, "metadata": {}, "output_type": "execute_result" } ], "source": "desired_state = [\n 1 / math.sqrt(15.25) * 1.5,\n 0,\n 1 / math.sqrt(15.25) * -2,\n 1 / math.sqrt(15.25) * 3]\n\nqc = QuantumCircuit(2)\nqc.initialize(desired_state, [0,1])\n\nqc.decompose().decompose().decompose().decompose().decompose().draw()" }, { "cell_type": "markdown", "metadata": { "id": "i9XYzjJaNKK7" }, "source": "The advantage of amplitude encoding is that it only requires $\\mathrm{log}_2(NM)$ qubits to encode. However, subsequent algorithms must operate on the amplitudes of a quantum state, and methods to prepare and measure the quantum states tend not to be efficient." }, { "cell_type": "markdown", "metadata": { "formulas": { "_big-o-times-n": { "meaning": "This represents the tensor product operation over N qubits.", "say": "big o-times" }, "_big-o-times-n2": { "meaning": "This represents the tensor product operation over N/2 qubits.", "say": "big o-times" } }, "id": "vUj3gFvvNKK7" }, "source": "### Angle encoding\n\nAngle encoding encodes $N$ features into the rotation angles of $n$ qubits, where $N \\le n$. For example, the data point $x = (x_1,...,x_N)$ can be encoded as:\n\n$$\\cssId{_}{|x\\rangle} = \\class{_big-o-times-n}{\\bigotimes^N_{i=1}} \\cos(x_i)|0\\rangle + \\sin(x_i)|1\\rangle$$\n\nThis is different from the previous two encoding methods, as it only encodes one data point at a time, rather than a whole dataset. It does, however, only require N qubits or less and a constant depth quantum circuit, making it amenable to current quantum hardware.\n\nWe can specify angle encoding as a [unitary](gloss:unitary):\n\n$$ S_{x_j} = \\class{_big-o-times-n}{\\bigotimes_{i=1}^N} U(x_j^{(i)}) $$\n\nwhere:\n\n$$\nU(x_j^{(i)}) = \\begin{bmatrix} \\cos(x_j^{(i)}) & -\\sin(x_j^{(i)}) \\\\ \\sin(x_j^{(i)}) & \\cos(x_j^{(i)}) \\\\ \\end{bmatrix}\n$$\n\nRemembering that a single-qubit rotation around the $Y$-axis is:\n\n$$RY(\\theta) = \\exp(-i \\frac{\\theta}{2} Y) = \\begin{pmatrix} \\cos{\\frac{\\theta}{2}} & -\\sin{\\frac{\\theta}{2}} \\\\ \\sin{\\frac{\\theta}{2}} & \\cos{\\frac{\\theta}{2}} \\end{pmatrix} $$ \n \nWe note that $U(x_j^{(i)}) = RY(2x_j^{(i)})$, and as an example, encode the data point $x = (0, \\pi/4, \\pi/2)$ using Qiskit:" }, { "cell_type": "code", "execution_count": null, "metadata": { "id": "zZuCZ1zKNKK8", "outputId": "3f8f0a87-adc9-4f0e-a35a-ac9e6c3a7768" }, "outputs": [ { "data": { "image/svg+xml": [ "" ], "text/plain": [ "
" ] }, "execution_count": 3, "metadata": {}, "output_type": "execute_result" } ], "source": "qc = QuantumCircuit(3)\nqc.ry(0, 0)\nqc.ry(2*math.pi/4, 1)\nqc.ry(2*math.pi/2, 2)\nqc.draw()" }, { "cell_type": "markdown", "metadata": { "id": "GEYZjQxwNKK8" }, "source": "Dense angle encoding is a slight generalization of angle encoding, that encodes two features per qubit using the relative phase, where the data point $x = (x_1,...,x_N)$ can be encoded as:\n\n$$|x\\rangle = \\class{_big-o-times-n2}{\\bigotimes_{i=1}^{N/2}} \\cos(x_{2i-1})|0\\rangle + e^{i x_{2i}}\\sin(x_{2i-1})|1\\rangle$$\n\nAlthough the angle and dense angle encoding use sinusoids and exponentials, there is nothing special about these functions. We can easily abstract these to a general class of qubit encodings that use arbitrary functions, or define the encodings as arbitrary unitaries, implemented as parameterized quantum circuits." }, { "cell_type": "markdown", "metadata": { "id": "tO75LuqBNKK9" }, "source": "### Arbitrary encoding\n\nArbitrary encoding encodes $N$ features as rotations on $N$ parameterized gates on $n$ qubits, where $n \\leq N$. Like angle encoding, it only encodes one data point at a time, rather than a whole dataset. It also uses a constant depth quantum circuit and $n \\leq N$ qubits, meaning it can be run on current quantum hardware." }, { "cell_type": "markdown", "metadata": { "id": "iUCD1Pi-NKK9" }, "source": "For example, to use the Qiskit [`EfficientSU2`](https://qiskit.org/documentation/stubs/qiskit.circuit.library.EfficientSU2.html) circuit to encode 12 features, would only use 3 qubits:" }, { "cell_type": "code", "execution_count": null, "metadata": { "id": "ctvCmFOZNKK-", "outputId": "b255f706-b098-40a7-eb67-dea7f2faf5c1" }, "outputs": [ { "data": { "image/svg+xml": [ "" ], "text/plain": [ "
" ] }, "execution_count": 4, "metadata": {}, "output_type": "execute_result" } ], "source": "from qiskit.circuit.library import EfficientSU2\ncircuit = EfficientSU2(num_qubits=3, reps=1, insert_barriers=True)\ncircuit.decompose().draw()" }, { "cell_type": "markdown", "metadata": { "id": "974K5q9rNKK-" }, "source": "Here we encode the data point $x = [0.1,0.2,0.3,0.4,0.5,0.6,0.7,0.8,0.9,1.0,1.1,1.2]$ with 12 features, using each of the parameterized gates to encode a different feature." }, { "cell_type": "code", "execution_count": null, "metadata": { "id": "e_Ilr8RvNKK-", "outputId": "994fce26-dc6d-458f-c399-66bb4ff5c85f" }, "outputs": [ { "data": { "image/svg+xml": [ "" ], "text/plain": [ "
" ] }, "execution_count": 5, "metadata": {}, "output_type": "execute_result" } ], "source": "x = [0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9, 1.0, 1.1, 1.2]\nencode = circuit.bind_parameters(x)\nencode.decompose().draw()" }, { "cell_type": "markdown", "metadata": { "id": "IrwnKkTmNKK_" }, "source": "The Qiskit [`ZZFeatureMap`](https://qiskit.org/documentation/stubs/qiskit.circuit.library.ZZFeatureMap.html) circuit with 3 qubits, only encodes a data point of 3 features, despite having 6 parameterized gates:" }, { "cell_type": "code", "execution_count": null, "metadata": { "id": "WTqLYZ8GNKK_", "outputId": "0f4ec4b9-c61d-4973-ae4f-cb84dd8f1bb7" }, "outputs": [ { "data": { "image/svg+xml": [ "" ], "text/plain": [ "
" ] }, "execution_count": 6, "metadata": {}, "output_type": "execute_result" } ], "source": "from qiskit.circuit.library import ZZFeatureMap\ncircuit = ZZFeatureMap(3, reps=1, insert_barriers=True)\ncircuit.decompose().draw()" }, { "cell_type": "code", "execution_count": null, "metadata": { "id": "1KIj2V-oNKLA", "outputId": "88ffc431-ca7e-40fb-d845-0cb3e7c07e6e" }, "outputs": [ { "data": { "image/svg+xml": [ "" ], "text/plain": [ "
" ] }, "execution_count": 7, "metadata": {}, "output_type": "execute_result" } ], "source": "x = [0.1, 0.2, 0.3]\nencode = circuit.bind_parameters(x)\nencode.decompose().draw()" }, { "cell_type": "markdown", "metadata": { "id": "3rT-6mVFNKLA" }, "source": "\n\n### Quick quiz\n\n\n\n\n\nA parameterized quantum circuit has 16 parameters. What is the largest number of features it can encode?\n\n\n\n\n\n1. 4\n\n\n\n\n\n2. 8\n\n\n\n\n\n3. 16\n\n\n\n\n\n3. 32\n\n\n\n\n\n" }, { "cell_type": "markdown", "metadata": { "formulas": { "big-o-times": { "meaning": "In the same way a big sigma (Σ) represents summation over different values, this big 'otimes' means we take the Kronecker product of the formula to it's right for a set of values.", "say": "big o-times" } }, "id": "eUManKSpNKLB" }, "source": "The performance of different parameterized quantum circuits on different types of data is an active area of investigation.\n\n
\n\n$$\\cssId{big-o-times}{\\bigotimes}$$\n\n
" }, { "cell_type": "markdown", "metadata": { "id": "zrdKZYDBNKLB" }, "source": "## References\n\n1. Maria Schuld and Francesco Petruccione, *Supervised Learning with Quantum Computers*, Springer 2018, [doi:10.1007/978-3-319-96424-9](https://www.springer.com/gp/book/9783319964232).\n2. Ryan LaRose and Brian Coyle, *Robust data encodings for quantum classifiers*, Physical Review A 102, 032420 (2020), [doi:10.1103/PhysRevA.102.032420](https://journals.aps.org/pra/abstract/10.1103/PhysRevA.102.032420), [arXiv:2003.01695](https://arxiv.org/abs/2003.01695)." }, { "cell_type": "code", "execution_count": null, "metadata": { "id": "WGymQOv3NKLB", "outputId": "e8fc3dac-8fbf-47a1-fb54-45dfbc594bcc" }, "outputs": [ { "data": { "text/html": [ "

Version Information

Qiskit SoftwareVersion
qiskit-terra0.21.2
qiskit-aer0.10.4
qiskit-ibmq-provider0.19.2
qiskit0.37.2
qiskit-nature0.4.1
qiskit-finance0.3.2
qiskit-optimization0.4.0
qiskit-machine-learning0.4.0
System information
Python version3.8.13
Python compilerClang 13.1.6 (clang-1316.0.21.2.5)
Python builddefault, Aug 29 2022 05:17:23
OSDarwin
CPUs8
Memory (Gb)32.0
Thu Sep 01 16:39:10 2022 BST
" ], "text/plain": [ "" ] }, "metadata": {}, "output_type": "display_data" } ], "source": "# pylint: disable=unused-import\nimport qiskit.tools.jupyter\n%qiskit_version_table" } ], "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" }, "colab": { "provenance": [] } }, "nbformat": 4, "nbformat_minor": 0 }