diff --git a/binder-index.md b/binder-index.md index 06b87df6042c..73bd5fd54953 100644 --- a/binder-index.md +++ b/binder-index.md @@ -251,6 +251,14 @@ These are noted in the README.md files for each sample, along with complete inst Q# standalone + + + Numerical Integration with QAE + + + Q# + python + + Characterization: Bayesian Phase Estimation diff --git a/samples/azure-quantum/qae-numerical-integration/QuantumAmplitudeEstimation.ipynb b/samples/azure-quantum/qae-numerical-integration/QuantumAmplitudeEstimation.ipynb new file mode 100644 index 000000000000..086fd304d393 --- /dev/null +++ b/samples/azure-quantum/qae-numerical-integration/QuantumAmplitudeEstimation.ipynb @@ -0,0 +1,1207 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Numerical Integration with Quantum Amplitude Estimation\n", + "\n", + "In this sample we will be integrating functions numerically using Quantum Amplitude Estimation (QAE).\n", + "Warning: This sample is intended for users with an advanced level of knowledge of mathematics.\n", + "\n", + "This sample is based on the work [arXiv:2005.07711](https://arxiv.org/abs/2005.07711) by Vazquez and Woerner.\n", + "\n", + "In this sample we cover techniques of visualizing results and seeing noise on hardware in action.\n", + "\n", + "The basics of QAE are that we are given an operation implementation a unitary $A$ with the following properties\n", + "\n", + "$$A\\ket{0}_{n+1} = \\sqrt{1-a}\\ket{\\psi_0}_n\\ket{0} + \\sqrt{a}\\ket{\\psi_1}_n\\ket{1}$$\n", + "\n", + "with $\\psi_0$ and $\\psi_1$ being arbitrary states.\n", + "\n", + "From this we construct the operations implementing the following operators:\n", + "\n", + "- $S_{\\psi_0}, S_{\\psi_1}$, which are reflections across $\\psi_0$ and $\\psi_1$ respectively\n", + "- $Q=A S_{\\psi_0} A^\\dagger S_{\\psi_1}$ as the full operator\n", + "\n", + "Amplitude estimation will then try to estimate $a$ given the operators $A$ and $Q$.\n", + "For this we construct a circuit where we apply $A$ followed by $k$ applications of $Q$ and in the end measure the last qubit:\n", + "$$Q^kA\\ket{0}_n, k \\geq 0, n \\geq 2$$ \n", + "\n", + "After running the circuit multiple times we estimate $a$ to be the probability of getting result $1$.\n", + "\n", + "Our results improve if we build an $A$ that has the same $a$ acts on a greater number of qubits $n$ or by increasing the number of iterations $k$.\n", + "Increasing $n$ comes at the cost of needing more qubits, whereas $k$ comes at the cost of higher circuit depth.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Preparing Q# environment...\n", + "." + ] + } + ], + "source": [ + "import qsharp" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "import math\n", + "import random\n", + "from scipy import optimize\n", + "import pandas as pd\n", + "\n", + "import qsharp.azure\n", + "import datetime\n", + "from qsharp.azure import AzureJob" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Below we are implementing a circuit for the numerical integral\n", + "\n", + "$$\\int_{x=0}^y{\\sin^2(\\pi x)dx} = \\frac{2\\pi y - \\sin(2 \\pi y)}{4\\pi}$$\n", + "\n", + "Details on this circuit can be found in the paper [arXiv:2005.07711](https://arxiv.org/abs/2005.07711).\n", + "\n", + "The fundamental idea is that we \n", + "* Discretize the interval $[0,2\\pi{}]$ into points $[x_0, \\ldots, x_{2^n}]$ that are spaced uniformly, where $n+1$ is the number of qubits for the circuit\n", + "* Put the quantum program in the state of the function at the discrete points\n", + "* Estimate the amplitudes at those given points\n", + "* Calculate the Riemann integral using these values\n", + "\n", + "The reason amplitude estimation is effective on quantum computers is that the quantum version has quadratic speedup over its classical counterpart. \n", + "This stems from the fact that the QAE algorithm fundamentally builds on Grover's search.\n", + "\n", + "For a circuit with $n+1$ qubits, we have one target qubit and $n$ control qubits.\n", + "\n", + "Our algorithm has two main components:\n", + "\n", + "- State preparation $A$\n", + "- Iteration operator $Q$\n" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "%%qsharp\n", + "\n", + "open Microsoft.Quantum.Math;\n", + "open Microsoft.Quantum.Arithmetic;\n", + "open Microsoft.Quantum.Convert;\n", + "open Microsoft.Quantum.Arrays;\n", + "open Microsoft.Quantum.Diagnostics;\n", + "open Microsoft.Quantum.Measurement;" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Let's build our state preparation $A$:\n", + "\n", + "We prepare state using controlled $Y$-axis rotations on a target qubit. For $i \\in [1,2^n]$, we control $Y$-axis rotation with angles $\\theta_i = 2\\pi(x_i - x_0)$ on the control qubits being in state $\\ket{i}_n$. \n", + "Additionally, we control the rotation $2\\pi x_0$ on the control qubits being $\\ket{0}_n$. \n", + "The paper optimizes this to only have $n+1$ thetas, where $R_Y(\\theta_0)$ is uncontrolled and $R_Y(\\theta_i), i > 0$ is controlled on the $(n - i)^\\text{th}$ control wire.\n", + "Due to the uniform spacing, we see $$\\exists \\Delta, x_i = x_0 + i * \\Delta$$\n", + "Therefore it follows that the optimized version is equivalent to the version that is controlled on $\\ket{i}_n, i \\in [0, 2^n]$." + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [], + "source": [ + "%%qsharp\n", + "operation PrepareState(theta : Double[], ctls : Qubit[], target : Qubit) : Unit is Adj + Ctl { // Corresponds to operator A\n", + " EqualityFactI(Length(theta), Length(ctls) + 1, \"Thetas and controls must have same length\");\n", + " ApplyToEachCA(H, ctls);\n", + " Ry(theta[0], target);\n", + " for i in IndexRange(ctls) {\n", + " Controlled Ry([ctls[Length(ctls) - 1 - i]], (theta[i + 1], target));\n", + " }\n", + "}" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "... and our Iteration operator $Q$: The iteration operator $Q$ is given as follows $$Q=A S_0 A^\\dagger S_1$$ where \n", + "$$S_0 = I_{n + 1} - 2 \\ket{0}\\bra{0}_{n+1}, S_1 = I_n \\otimes Z$$" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [], + "source": [ + "%%qsharp\n", + "operation Rotate(theta : Double[], ctls : Qubit[], target : Qubit) : Unit is Adj + Ctl { // Corresponds to operator Q\n", + " Z(target);\n", + " within {\n", + " Adjoint PrepareState(theta, ctls, target);\n", + " ApplyToEachCA(X, ctls + [target]); // Turns |0...0> into |1...1> (i.e., enabling the controlled Z to reflect)\n", + " } apply {\n", + " Controlled Z (ctls, target);\n", + " }\n", + "}" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The final algorithm will then be built to correspond to the matrix operation:\n", + "$$Q^kA\\ket{0}_n, k \\geq 0, n \\geq 2$$ " + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# Not required, but can be helpful to provide type information to some IDEs.\n", + "EstimateAmplitude: qsharp.QSharpCallable = None\n", + "EstimateAmplitudeNShots: qsharp.QSharpCallable = None" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [], + "source": [ + "%%qsharp\n", + "operation EstimateAmplitude(theta : Double[], k : Int) : Result {\n", + " use ctls = Qubit[Length(theta) - 1];\n", + " use target = Qubit();\n", + " PrepareState(theta, ctls, target);\n", + " RepeatCA(Rotate, k, (theta, ctls, target));\n", + " let res = MResetZ(target);\n", + " ResetAll(ctls);\n", + " return res;\n", + "}\n", + "\n", + "operation CountOneResults<'TInput> (op : ('TInput => Result), n : Int , input : 'TInput) : Int {\n", + " return Count(res -> res == One, DrawMany(op, n, input));\n", + "}\n", + "\n", + "operation EstimateAmplitudeNShots(n : Int, theta : Double[], k : Int) : Int {\n", + " return CountOneResults(EstimateAmplitude, n, (theta, k));\n", + "}\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Spin Echo Optimization\n", + "\n", + "After building our $A$ and $Q$, we can use properties of quantum circuits to reduce the number of rotations by merging them.\n", + "Essentially, we can compute the inverse of our rotations through the `Z` gates, allowing us to merge the operators $A^\\dagger S_1 A$.\n", + "This optimization is called Spin Echo optimization. \n", + "Please refer to [arXiv:2005.07711](https://arxiv.org/abs/2005.07711) for more details on why it works. \n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# Not required, but can be helpful to provide type information to some IDEs.\n", + "EstimateAmplitudeSpinEcho: qsharp.QSharpCallable = None\n", + "EstimateAmplitudeNShotsSpinEcho: qsharp.QSharpCallable = None" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [], + "source": [ + "%%qsharp\n", + "operation RotateSpinEcho(theta : Double[], ctls : Qubit[], target : Qubit) : Unit is Adj + Ctl {\n", + " PrepareState(Mapped(x -> 2.0 * x, theta), ctls, target);\n", + " ApplyToEachCA(H, ctls);\n", + " Z(target);\n", + " within {\n", + " ApplyToEachCA(X, ctls + [target]); // Turns |0...0> into |1...1> (i.e., enabling the controlled Z to reflect)\n", + " } apply {\n", + " Controlled Z (ctls, target);\n", + " }\n", + " \n", + "}\n", + "\n", + "operation EstimateAmplitudeSpinEcho(theta : Double[], k : Int) : Result {\n", + " use ctls = Qubit[Length(theta) - 1];\n", + " use target = Qubit();\n", + " RepeatCA(RotateSpinEcho, k, (theta, ctls, target));\n", + " PrepareState(theta, ctls, target);\n", + " ApplyToEachCA(H, ctls);\n", + " let res = MResetZ(target);\n", + " ResetAll(ctls);\n", + " return res;\n", + "}\n", + "\n", + "operation EstimateAmplitudeNShotsSpinEcho(n : Int, theta : Double[], k : Int) : Int {\n", + " return CountOneResults(EstimateAmplitudeSpinEcho, n, (theta, k));\n", + "}" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Resource Estimation of Spin Echo Optimization\n", + "\n", + "To see the effectiveness of the Spin Echo optimization, we will use the resource estimator to see the difference in gate count. \n", + "For this we will use the resource estimator and for bit length 2 and 3 we will see the how many fewer gates the optimized circuit needs for given $k$." + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [], + "source": [ + "from IPython.core.display import HTML" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
Differences with Spin Echo optimization at bit length 2
k1Q gate reduction2Q gate reduction
116.0%28.57%
220.45%33.33%
423.17%36.36%
824.68%38.1%
1625.48%39.02%
3225.9%39.51%
6426.1%39.75%
12826.21%39.88%
\n", + "
\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
Differences with Spin Echo optimization at bit length 3
k1Q gate reduction2Q gate reduction
114.89%18.18%
219.28%20.0%
421.94%21.05%
823.41%21.62%
1624.19%21.92%
3224.59%22.07%
6424.79%22.15%
12824.9%22.18%
\n" + ], + "text/plain": [ + "" + ] + }, + "execution_count": 9, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "dfs = []\n", + "for bitlen in (2, 3):\n", + " deltas = []\n", + " theta = list(map(lambda _ : random.uniform(0, 3.14), range(bitlen))) # Random thetas\n", + " for k in map(lambda x : 2 ** x, range(8)):\n", + " spin_echo_res = EstimateAmplitudeSpinEcho.estimate_resources(theta=theta, k=k)\n", + " res = EstimateAmplitude.estimate_resources(theta=theta, k=k)\n", + "\n", + " def delta(key : str) -> int:\n", + " return (res[key] - spin_echo_res[key])\n", + "\n", + " delta_2q = str(np.round(delta('CNOT') / res['CNOT'] * 100, 2)) + '%'\n", + " delta_1q = str(np.round((delta('QubitClifford') + delta('R') + delta('T')) / (res['QubitClifford'] + res['R'] + res['T']) * 100, 2)) + '%'\n", + " deltas.append([k, delta_1q, delta_2q])\n", + " df = pd.DataFrame(deltas, columns=[\"k\", \"1Q gate reduction\", \"2Q gate reduction\"])\n", + " df = df.style.set_caption(f\"Differences with Spin Echo optimization at bit length {bitlen}\").hide_index()\n", + " dfs.append(df)\n", + "\n", + "html_dfs = list(map(lambda df : df.to_html(), dfs))\n", + "HTML(\"
\".join(html_dfs))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We see that the Spin Echo circuit requires fewer gates across the board and for higher $k$ we get bigger benefits.\n", + "\n", + "## Maximum Likelihood Estimator (MLE)\n", + "\n", + "We will be using the MLE to get our optimal theta results with a modified optimization function that you can see in the code below as `loglikelihood`.\n", + "\n", + "To learn more about why and how this estimator works with QAE please see [arXiv:1904.10246](https://arxiv.org/pdf/1904.10246.pdf).\n", + "\n", + "We use (and adapt) the MLE calculation methods from the work resulting from [arXiv:1904.10246](https://arxiv.org/pdf/1904.10246.pdf) that can be found in the [Qiskit community tutorials on GitHub](https://github.com/qiskit-community/qiskit-community-tutorials/blob/master/algorithms/SimpleIntegral_AEwoPE.ipynb)." + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [], + "source": [ + "from typing import List, Tuple\n", + "\n", + "def calculate_theta(hit_list: List[int], number: List[int], shots: List[int]) -> List[float]:\n", + " \"\"\"\n", + " calculate optimal theta values\n", + " hit_list: list of count of obserbving \"1\"\n", + " number: list of number of Grover operators \n", + " shots_list: list of number of shots\n", + "\n", + " Return:\n", + " theta_candidates: list of optimal theta\n", + " \"\"\"\n", + "\n", + " small = 1.e-15 # small valued parameter to avoid zero division\n", + " confidence_level = 5 # confidence level to determine the search range\n", + "\n", + " theta_candidates = []\n", + " range_min = 0.0 + small\n", + " range_max = 1.0 - small\n", + " for idx_grover_operator in range(len(number)):\n", + "\n", + " def loglikelihood(p):\n", + " ret = np.zeros_like(p)\n", + " theta = np.arcsin(np.sqrt(p))\n", + " for n in range(idx_grover_operator + 1):\n", + " ihit = hit_list[n]\n", + " arg = (2 * number[n] + 1) * theta\n", + " ret = ret + 2 * ihit * np.log(np.abs(np.sin(arg))) + 2 * (\n", + " shots - ihit) * np.log(np.abs(np.cos(arg)))\n", + " return -ret\n", + "\n", + " search_range = (range_min, range_max)\n", + " prob_candidate = optimize.brute(loglikelihood, [search_range])[0]\n", + " theta_candidates.append(np.arcsin(np.sqrt(prob_candidate)))\n", + " pbound = cramer_rao_bound(idx_grover_operator, shots, prob_candidate, number)\n", + " range_max = min(prob_candidate+confidence_level * pbound, 1.0 - small)\n", + " range_min = max(prob_candidate-confidence_level * pbound, 0.0 + small)\n", + " return theta_candidates\n", + "\n", + "\n", + "def cramer_rao_bound(M: int, shots: List[int], p0: float, number: List[int]) -> float:\n", + " \"\"\"\n", + " calculate Cramér-Rao lower bound\n", + " M: upper limit of the sum in Fisher information \n", + " shots_list: list of number of shots\n", + " p0: the true parameter value to be estimated\n", + " number: list of number of Grover operators \n", + "\n", + " Return:\n", + " square root of Cramér-Rao lower bound: lower bound on the standard deviation of unbiased estimators\n", + " \"\"\"\n", + " fisher_info = sum(map(lambda mk : shots / (p0 * (1 - p0)) * (2 * mk + 1)**2, number[:M+1]))\n", + " return np.sqrt(1 / fisher_info)\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "With the statistical preliminaries out of the way, let's build a function that assembles our $\\theta_i, i \\in [0, n]$, runs our circuit and calculates the most likely values." + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": { + "scrolled": true + }, + "outputs": [], + "source": [ + "def compute_theta(bit_length: int, y_int: Tuple[float, float]) -> List[float]:\n", + " (y0, y) = y_int\n", + " y_scs = [i * (y - y0) / bit_length for i in range(bit_length)]\n", + " thetas = [2 * math.pi * (y_sc - y0) for y_sc in y_scs]\n", + " return thetas\n", + "\n", + "\n", + "def integrate(run_fn, bit_length: int, y_int: Tuple[float, float], ks: List[int], shots=250) -> List[float]:\n", + " prev = 0\n", + " (_, y) = y_int\n", + " print(f\"integration for y in {y_int}\")\n", + " # Precompute thetas\n", + " theta = compute_theta(bit_length=bit_length, y_int=y_int)\n", + " # Run Amplitude estimation\n", + " good_states = []\n", + " for k in ks:\n", + " good_states.append(run_fn(n=shots, theta=theta, k=k, y_int=y_int))\n", + " result_thetas = calculate_theta(good_states, ks, shots)\n", + " return list(map(lambda x: x * y, result_thetas))\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We then proceed to actually integrate our work and collect data." + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [], + "source": [ + "from IPython.display import clear_output\n", + "n = 15\n", + "ys = list(map(lambda x : 0.5 * x / n, list(range(n + 1))))\n", + "ks = [0, 1, 2, 4, 8, 16]\n", + "\n", + "def get_results(run_fn, bit_length=2, ys=ys, ks=ks, shots=200):\n", + " k_vals = dict()\n", + " for k in ks:\n", + " k_vals[k] = []\n", + " prev = ys[0]\n", + " for y in ys: \n", + " res = list(integrate(run_fn, bit_length=2, y_int=(0, y), shots=200, ks=ks))\n", + " assert len(ks) == len(res)\n", + " for i in range(len(ks)):\n", + " k_vals[ks[i]] += [res[i]]\n", + " prev = y\n", + " return k_vals" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "integration for y in (0, 0.0)\n", + "integration for y in (0, 0.03333333333333333)\n", + "integration for y in (0, 0.06666666666666667)\n", + "integration for y in (0, 0.1)\n", + "integration for y in (0, 0.13333333333333333)\n", + "integration for y in (0, 0.16666666666666666)\n", + "integration for y in (0, 0.2)\n", + "integration for y in (0, 0.23333333333333334)\n", + "integration for y in (0, 0.26666666666666666)\n", + "integration for y in (0, 0.3)\n", + "integration for y in (0, 0.3333333333333333)\n", + "integration for y in (0, 0.36666666666666664)\n", + "integration for y in (0, 0.4)\n", + "integration for y in (0, 0.43333333333333335)\n", + "integration for y in (0, 0.4666666666666667)\n", + "integration for y in (0, 0.5)\n" + ] + } + ], + "source": [ + "k_vals = get_results(EstimateAmplitudeNShotsSpinEcho.simulate)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Now we'll plot our approximations for different values of $k$ against the exact integral" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [], + "source": [ + "def f(x : float) -> float:\n", + " return (math.sin(math.pi * x)) ** 2\n", + "\n", + "def int_f(x : float) -> float:\n", + " return x / 2 - math.sin(2 * math.pi *x) / (4 * math.pi)" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [], + "source": [ + "colors = dict()\n", + "colors[0] = 'b'\n", + "colors[1] = 'r'\n", + "colors[2] = 'c'\n", + "colors[4] = 'm'\n", + "colors[8] = 'y'\n", + "colors[16] = 'pink'\n", + "colors[32] = 'grey'" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": {}, + "outputs": [], + "source": [ + "def plot(ys : list, k_vals : dict) -> None:\n", + " int_f_y = list(map(int_f, ys))\n", + " f_y = list(map(f, ys))\n", + " fig, ax = plt.subplots()\n", + " ax.set_xlabel('y')\n", + " int_fx_plot, = plt.plot(ys, int_f_y, color='g', label='$g(y) = \\int_{x=0}^y \\sin^2(\\pi x) dx$')\n", + " apprx_plots = []\n", + " for k, vals in k_vals.items(): \n", + " f_vals = list(map(lambda x : x / 1, vals))\n", + " apprx_plot, = plt.plot(ys, f_vals, colors[k], label='$\\widehat{g(y)}, ' + f'k={k}$')\n", + " apprx_plots.append(apprx_plot)\n", + " ax.legend(handles=[int_fx_plot] + apprx_plots)" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "plot(ys, k_vals)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "In this plot we see that all of our results look fairly close to the expected value graphed in green.\n", + "\n", + "Therefore, we'll graph the errors to get see which $k$ performs best." + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": {}, + "outputs": [], + "source": [ + "def loss(x : float, expected : float) -> float: \n", + " return (x - expected) ** 2\n", + "\n", + "def compute_err(ys : list, vals : list) -> list:\n", + " assert len(ys) == len(vals)\n", + " err = []\n", + " f_y = list(map(f, ys))\n", + " int_f_y = list(map(int_f, ys))\n", + " err = [loss(g_hat_y, g_y) for g_hat_y, g_y in zip(vals, int_f_y)]\n", + " return err\n", + "\n", + "def plot_err(ys, k_err : dict) -> None:\n", + " fig, ax = plt.subplots()\n", + " ax.set_xlabel('y')\n", + " ax.set_ylabel('error')\n", + " err_plots = []\n", + " for k, err in k_err.items(): \n", + " err_plot, = plt.plot(ys, err, colors[k], label='$L(\\hat{y}, y)$, ' + f'k={k}')\n", + " err_plots.append(err_plot)\n", + " ax.legend(handles=err_plots)\n", + "\n", + "def plot_average_err(k_err_avg : dict) -> None:\n", + " fig, ax = plt.subplots()\n", + " ax.set_xlabel('$k$')\n", + " ax.set_ylabel('Frequentis risk (average error)')\n", + " plt.bar(list(map(lambda x : str(x), k_err_avg.keys())), k_err_avg.values())\n", + "\n", + "def build_err(ys : list, k_vals : dict) -> tuple:\n", + " k_err = dict()\n", + " k_err_avg = dict()\n", + " for k, vals in k_vals.items():\n", + " f_vals = list(map(lambda x : f(x) / 2, vals))\n", + " k_err[k] = compute_err(ys, f_vals)\n", + " k_err_avg[k] = np.average(k_err[k])\n", + " return (k_err, k_err_avg)" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "metadata": {}, + "outputs": [], + "source": [ + "k_err, k_err_avg = build_err(ys, k_vals)" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "plot_err(ys, k_err)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Here we clearly see that $k=0$ performs worse than the other values. Let's look at the average error to get a better picture." + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "plot_average_err(k_err_avg)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "As we'd expect, the error is trending downward with increasing $k$.\n", + "\n", + "Let us now repeat the same on IonQ Harmony to see if the results are the same.\n", + "\n", + "First, we will connect to the Azure Quantum service and select the IonQ harmony target." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "targets = qsharp.azure.connect(\n", + " resourceId=\"\",\n", + " location=\"\"\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "This workspace has 10 targets:\n", + "- ionq.qpu (average queue time 0:01:13)\n", + "- ionq.qpu.aria-1 (average queue time 3:40:44)\n", + "- ionq.simulator (average queue time 0:00:02)\n", + "- quantinuum.hqs-lt-s1 (average queue time 0:00:00)\n", + "- quantinuum.hqs-lt-s1-apival (average queue time 0:00:01)\n", + "- quantinuum.hqs-lt-s2 (average queue time 0:00:00)\n", + "- quantinuum.hqs-lt-s2-apival (average queue time 0:00:01)\n", + "- quantinuum.hqs-lt-s1-sim (average queue time 3:47:43)\n", + "- quantinuum.hqs-lt-s2-sim (average queue time 0:02:33)\n", + "- quantinuum.hqs-lt (average queue time 0:00:00)\n" + ] + } + ], + "source": [ + "print(f\"This workspace has {len(targets)} targets:\")\n", + "for target in targets:\n", + " print(f\"- {target.id} (average queue time {datetime.timedelta(seconds=target.average_queue_time)})\")" + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Loading package Microsoft.Quantum.Providers.IonQ and dependencies...\n", + "Active target is now ionq.qpu\n" + ] + }, + { + "data": { + "text/plain": [ + "{'id': 'ionq.qpu', 'current_availability': {}, 'average_queue_time': 73}" + ] + }, + "execution_count": 25, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "qsharp.azure.target(\"ionq.qpu\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Now we write some logic to handle our jobs. Since jobs submitted to real hardware might take a bit to complete, we want to have infrastructure to submit jobs, check their status and fetch their results." + ] + }, + { + "cell_type": "code", + "execution_count": 26, + "metadata": {}, + "outputs": [], + "source": [ + "def submit_integration_jobs_yint(bit_length: int, y_int: tuple, ks, shots=250):\n", + " theta = compute_theta(bit_length=bit_length, y_int=y_int)\n", + " # Run Amplitude estimation\n", + " k_jobs = dict()\n", + " for k in ks:\n", + " k_jobs[k] = qsharp.azure.submit(EstimateAmplitudeSpinEcho, jobName = f\"QAE for bit length {bit_length}, k={k}, y_int={y_int}\", shots=shots, theta=theta, k=k)\n", + " return k_jobs\n", + "\n", + "def submit_integration_jobs(bit_length: int, ys : list, ks, shots=250):\n", + " y_k_jobs = dict()\n", + " for y in ys:\n", + " y_int = (0, y)\n", + " y_k_jobs[y_int] = submit_integration_jobs_yint(bit_length, y_int, ks, shots)\n", + " return y_k_jobs\n", + "\n", + "def get_job(job_id : str) -> tuple:\n", + " current_job = qsharp.azure.status(jobId=job_id)\n", + " succeeded = current_job.status == 'Succeeded'\n", + " if succeeded:\n", + " print(f'Job completed')\n", + " elif current_job.status == 'Failed':\n", + " print(f'Job \\\"{current_job.name}\\\" failed. Please review reason at {current_job.uri}')\n", + " else:\n", + " print(f'Job \\\"{current_job.name}\\\" is still running. Please check back later!')\n", + " return (succeeded, current_job)\n", + "\n", + "\n", + "def get_job_result(job_id : str, shots : int) -> int:\n", + " (success, _) = get_job(job_id=job_id)\n", + " if not success:\n", + " raise Exception(\"Job not completed\")\n", + " output = qsharp.azure.output(jobId=job_id)\n", + " if '1' not in output: # All 0 return\n", + " return 0\n", + " return np.round(output['1'] * shots)\n", + "\n", + "\n", + "def get_all_job_results(y_k_jobs : dict, shots=250) -> dict:\n", + " y_k_job_result = dict()\n", + " for (y, k_jobs) in y_k_jobs.items():\n", + " y_k_job_result[y] = dict()\n", + " for (k, job) in k_jobs.items():\n", + " y_k_job_result[y][k] = get_job_result(job_id=job.id, shots=shots)\n", + " return y_k_job_result\n", + "\n", + "def build_use_job_output(y_k_job_result : dict):\n", + " def use_job_output(n : int, theta : list, k : int, y_int : tuple) -> int:\n", + " return y_k_job_result[y_int][k]\n", + " return use_job_output\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Let's go ahead and run them!\n", + "\n", + "\n", + "**Please note that this sample makes use of paid services on Azure Quantum. \n", + "The cost of running this sample with the provided parameters on IonQ is approximately \\$147. \n", + "This quantity is only an approximate estimate and should not be used as a binding reference. \n", + "The cost of the service might vary depending on your region, demand and other factors.**\n", + "\n", + "Please note this might take a while. Please keep the tab with the sample open until completion." + ] + }, + { + "cell_type": "code", + "execution_count": 27, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Submitted all jobs successfully!\n" + ] + } + ], + "source": [ + "#y_k_jobs = submit_integration_jobs(bit_length=2,ys=ys,ks=ks)\n", + "\n", + "clear_output(wait=True)\n", + "print(\"Submitted all jobs successfully!\")" + ] + }, + { + "cell_type": "code", + "execution_count": 28, + "metadata": {}, + "outputs": [], + "source": [ + "import pickle\n" + ] + }, + { + "cell_type": "code", + "execution_count": 29, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n" + ] + } + ], + "source": [ + "with open('jobs-qpu.pkl', 'wb') as pkl_file:\n", + " pickle.dump(y_k_jobs, pkl_file)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 33, + "metadata": {}, + "outputs": [], + "source": [ + "with open('jobs-qpu.pkl', 'rb') as pkl_file:\n", + " y_k_jobs = pickle.load(pkl_file)" + ] + }, + { + "cell_type": "code", + "execution_count": 37, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Processed all results successfully!\n" + ] + } + ], + "source": [ + "y_k_job_results = get_all_job_results(y_k_jobs,)\n", + "clear_output(wait=True)\n", + "print(\"Processed all results successfully!\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Once we're done, we will get our results.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 38, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "integration for y in (0, 0.0)\n", + "integration for y in (0, 0.03333333333333333)\n", + "integration for y in (0, 0.06666666666666667)\n", + "integration for y in (0, 0.1)\n", + "integration for y in (0, 0.13333333333333333)\n", + "integration for y in (0, 0.16666666666666666)\n", + "integration for y in (0, 0.2)\n", + "integration for y in (0, 0.23333333333333334)\n", + "integration for y in (0, 0.26666666666666666)\n", + "integration for y in (0, 0.3)\n", + "integration for y in (0, 0.3333333333333333)\n", + "integration for y in (0, 0.36666666666666664)\n", + "integration for y in (0, 0.4)\n", + "integration for y in (0, 0.43333333333333335)\n", + "integration for y in (0, 0.4666666666666667)\n", + "integration for y in (0, 0.5)\n" + ] + } + ], + "source": [ + "k_vals_aq = get_results(build_use_job_output(y_k_job_results))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Let's now graph our results/errors and see if they differ from our findings on the simulator!" + ] + }, + { + "cell_type": "code", + "execution_count": 39, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "plot(ys, k_vals_aq)" + ] + }, + { + "cell_type": "code", + "execution_count": 40, + "metadata": {}, + "outputs": [], + "source": [ + "k_err, k_err_avg = build_err(ys, k_vals_aq)" + ] + }, + { + "cell_type": "code", + "execution_count": 41, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "plot_err(ys, k_err)" + ] + }, + { + "cell_type": "code", + "execution_count": 42, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "plot_average_err(k_err_avg)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "In our graph we see our results are not as on the simulator. \n", + "In fact, in our testing $k=0$ performed better than any other $k$.\n", + "This comes down to the noise incurred by the additional gates that we need to apply for the larger values of $k$.\n", + "This is an interesting result because it shows considerations for current quantum computers that a perfect simulator does not depict: Every gate introduces noise.\n", + "As a result, one of our goals must be to reduce circuit depth. \n", + "Despite having the reduced depth already using the spin echo optimization, we still have noise effects. \n", + "Without this optimization's circuit depth reduction we'd expect noise to be even higher.\n", + "But we can see that even with very few qubits and high noise we were able to approximate our integral quite closely.\n", + "That means that there is a lot more to explore with what we can do on current hardware.\n" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3.7.13 ('qsharp-env-37')", + "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.7.13" + }, + "vscode": { + "interpreter": { + "hash": "2ae822f0f83fed12107faf85edb2b742fdce767c971cd51f224ccfc7e38aba9d" + } + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/samples/azure-quantum/qae-numerical-integration/README.md b/samples/azure-quantum/qae-numerical-integration/README.md new file mode 100644 index 000000000000..0a874a4c3f7d --- /dev/null +++ b/samples/azure-quantum/qae-numerical-integration/README.md @@ -0,0 +1,40 @@ +--- +page_type: sample +author: adrianleh +description: Numerical Integration with Quantum Amplitude Estimation, using the Azure Quantum service +ms.author: t-alehmann@microsoft.com +ms.date: 09/06/2021 +languages: +- qsharp +- python +products: +- qdk +- azure-quantum +--- + +# Numerical Integration with Quantum Amplitude Estimation (QAE) + +In this sample we will be using Quantum Amplitude Estimation to perform numerical integration on the function $f(x) = \sin^2(\pi x)$. + +This sample is based on the work [arXiv:2005.07711](https:arxiv.org/abs/2005.07711) by Vazquez and Woerner. +We build QAE, optimize it, see the effects of the optimization and run on both the simulator and hardware. +This will allow us to the real-world effects of noise in NISQ machines. + +In this sample we cover techniques of visualizing results and seeing noise on hardware in action. + +This sample is a Q# jupyter notebook targeted at IonQ machines. + +## Q# with Jupyter Notebook + +Make sure that you have followed the [Q# + Jupyter Notebook quickstart](https://docs.microsoft.com/azure/quantum/install-jupyter-qdk) for the Quantum Development Kit, and then start a new Jupyter Notebook session from the folder containing this sample: + +```shell +cd qae-num-int +jupyter notebook +``` + +Once Jupyter starts, open the `QuantumAmplitudeEstimation.ipynb` notebook and follow the instructions there. + +## Manifest + +- [QuantumAmplitudeEstimation.ipynb](https://github.com/microsoft/quantum/blob/main/samples/azure-quantum/qae-num-int/QuantumAmplitudeEstimation.ipynb): IQ# notebook for this sample targetting IonQ. \ No newline at end of file