{ "cells": [ { "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ "# Error mitigation on Amazon Braket \n", "\n", "In this example notebook, you will learn how to get started with using IonQ's Aria QPU on Amazon Braket. You’ll learn how Aria's two built-in error mitigation techniques work, how to switch between them, and the performance difference you can expect to see with and without these techniques for toy problems. " ] }, { "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ "## Quantum phase estimation \n", "\n", "Quantum phase estimation (QPE) is a fundamental algorithm in quantum computing that plays a crucial role in many applications. The QPE algorithm is designed to estimate the eigenvalues of a unitary operator. Below, we provide an example implementation in the Braket SDK. " ] }, { "cell_type": "code", "execution_count": 7, "metadata": {}, "outputs": [], "source": [ "import matplotlib.pyplot as plt\n", "import numpy as np\n", "import pandas as pd\n", "from braket.aws import AwsDevice\n", "from braket.circuits import Circuit\n", "from braket.devices import LocalSimulator\n", "from braket.tracking import Tracker\n", "from phase_estimation import phase_estimation_circuit\n", "\n", "%matplotlib inline" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "cost_tracker = Tracker().start()" ] }, { "cell_type": "code", "execution_count": 5, "metadata": {}, "outputs": [], "source": [ "# device = LocalSimulator()\n", "device = AwsDevice(\"arn:aws:braket:us-east-1::device/qpu/ionq/Aria-1\")" ] }, { "cell_type": "code", "execution_count": 6, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "T : |0| 1 |2| 3 |4| 5 |6| 7 |8| 9 |10| 11 |12| 13 |14| 15 |16| 17 |18| 19 |20| 21 |22| 23 |24 | 25 |26| 27 |28 | 29 |30 | 31 |32 | 33 |34| 35 |36| 37 |38| 39 |40|\n", " \n", "q0 : -H-Rz(6.28)------------------------------------------------------------------------C------------C--SWAP------------------------------------------------------------------------X-Rz(0.20)---X-Rz(-0.20)---X-Rz(0.39)--X--Rz(-0.39)-X--Rz(0.79)-X--Rz(-0.79)-H--\n", " | | | | | | | | | \n", "q1 : -H-Rz(3.14)-----------------------------------------------C------------C--SWAP-----|------------|--|------------------------------------------------X-Rz(0.39)--X--Rz(-0.39)-X-|-Rz(0.79)-X-|-Rz(-0.79)-H-|-Rz(-0.79)-|------------C-----------C---------------\n", " | | | | | | | | | | | | | | \n", "q2 : -H-Rz(1.57)------------------------C-----------C----------|------------|--SWAP-----|------------|--|---------------------X--Rz(0.79)-X--Rz(-0.79)-H-|-Rz(-0.79)-|------------C-|----------C-|-Rz(-0.39)---C-----------C----------------------------------------\n", " | | | | | | | | | | | | | \n", "q3 : -H-Rz(0.79)-C-----------C----------|-----------|----------|------------|-----------|------------|--SWAP-----H--Rz(-0.79)-C-----------C--Rz(-0.39)---C-----------C--Rz(-0.20)---C------------C------------------------------------------------------------------\n", " | | | | | | | | \n", "q4 : -X----------X-Rz(-0.79)-X-Rz(0.79)-X-Rz(-1.57)-X-Rz(1.57)-X--Rz(-3.14)-X--Rz(3.14)-X--Rz(-6.28)-X--Rz(6.28)----------------------------------------------------------------------------------------------------------------------------------------------------\n", "\n", "T : |0| 1 |2| 3 |4| 5 |6| 7 |8| 9 |10| 11 |12| 13 |14| 15 |16| 17 |18| 19 |20| 21 |22| 23 |24 | 25 |26| 27 |28 | 29 |30 | 31 |32 | 33 |34| 35 |36| 37 |38| 39 |40|\n" ] } ], "source": [ "circ = phase_estimation_circuit(n_qubits=4, phase=np.pi / 4)\n", "print(circ)" ] }, { "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ "## Aria \n", "\n", "First, we run the QPE circuit on the Aria device with the maximum number of shots per task (2,500). " ] }, { "cell_type": "code", "execution_count": 5, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "AwsQuantumTask('id/taskArn':'arn:aws:braket:us-east-1::quantum-task/6bd86be9-2811-49b2-a62e-86cd328d444f')\n" ] } ], "source": [ "task = device.run(circ, shots=2500)\n", "print(task)" ] }, { "cell_type": "code", "execution_count": 13, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "{'00000': 0.0028,\n", " '10000': 0.0038,\n", " '01000': 0.0102,\n", " '11000': 0.0002,\n", " '00100': 0.0002,\n", " '01100': 0.0002,\n", " '10010': 0.0002,\n", " '01010': 0.0002,\n", " '11010': 0.0004,\n", " '00110': 0.0002,\n", " '00001': 0.015,\n", " '10001': 0.0084,\n", " '01001': 0.8792,\n", " '11001': 0.03,\n", " '00101': 0.0046,\n", " '10101': 0.0006,\n", " '01101': 0.0128,\n", " '11101': 0.0026,\n", " '00011': 0.0004,\n", " '10011': 0.002,\n", " '01011': 0.0074,\n", " '11011': 0.011,\n", " '00111': 0.0018,\n", " '10111': 0.004,\n", " '01111': 0.001,\n", " '11111': 0.0008}" ] }, "execution_count": 13, "metadata": {}, "output_type": "execute_result" } ], "source": [ "probs = task.result().measurement_probabilities" ] }, { "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ "## Error Mitigation with debiasing\n", "\n", "Debiasing aims to reduce the accumulation of coherent errors by using different physical implementations of the same circuit and using classical compute to combine the results and extract the clearest possible signal from a noisy source [1]. \n", "\n", "IonQ's debiasing method uses different implementations of a circuit through various qubit permutations and/or gate decompositions. The implementations can be chosen to reduce the effects of certain types of noise. Aggregating the results from all implementations reduces the effect of systematic errors and can improve the accuracy of your results. \n", "\n", "To use debiasing, a minimum of 2500 shots is required. In the Braket SDK, you can enable debiasing with a single line of code." ] }, { "cell_type": "code", "execution_count": 7, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "AwsQuantumTask('id/taskArn':'arn:aws:braket:us-east-1::quantum-task/522e8472-78ff-4997-850e-5d9d9a8f5474')\n" ] } ], "source": [ "from braket.error_mitigation import Debias\n", "\n", "task_em = device.run(circ, shots=2500, device_parameters={\"errorMitigation\": Debias()})\n", "print(task_em)" ] }, { "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ "The results from debiasing are returned like normal measurement probabilities. Any expecation value or result type will be computed from these probabilities. " ] }, { "cell_type": "code", "execution_count": 14, "metadata": {}, "outputs": [], "source": [ "result = task_em.result()\n", "debias_probs = result.measurement_probabilities" ] }, { "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ "### Sharpening\n", "\n", "For quantum algorithms where the expected output distribution consists of few high-probability bitstrings, we can use IonQ’s sharpening strategy to post-process the results of a debiased run. Sharpening is a non-linear aggregation strategy that compares the results of each variant and discards inconsistent shots, favoring the most likely measurement outcome across variants. \n", "This is in contrast the the default aggregation for debiasing, which averages all the measurements together. Since sharpening is a post-processing technique, it can be applied at no additional cost to a debiased run. It’s important to keep in mind that because there is a minimum probability threshold for a shot to be considered consistent, sharpening can distort the correct probability distribution if applied to a non-sparse output distribution.\n", "\n", "The sharpened probabilities are available in the task result via a single line of code:" ] }, { "cell_type": "code", "execution_count": 15, "metadata": {}, "outputs": [], "source": [ "sharp_probs = result.additional_metadata.ionqMetadata.sharpenedProbabilities" ] }, { "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ "Sharpening your results will return a renormalized probability distribution rather than the full distribution of measurements counts, and is available at no additional cost when you run with the Debias() strategy. Note that expectation values will be computed using the debiased probabilities, **not** the sharpened probabilities. " ] }, { "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ "## Compare results from error mitigation" ] }, { "cell_type": "code", "execution_count": 16, "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", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", "
debias offdebias ondebias on, sharpened
101110.00400.0028NaN
001010.00460.0076NaN
010110.00740.0112NaN
100010.00840.0068NaN
010000.01020.0088NaN
110110.01100.0120NaN
011010.01280.0108NaN
000010.01500.0088NaN
110010.03000.0316NaN
010010.87920.88521.0
\n", "
" ], "text/plain": [ " debias off debias on debias on, sharpened\n", "10111 0.0040 0.0028 NaN\n", "00101 0.0046 0.0076 NaN\n", "01011 0.0074 0.0112 NaN\n", "10001 0.0084 0.0068 NaN\n", "01000 0.0102 0.0088 NaN\n", "11011 0.0110 0.0120 NaN\n", "01101 0.0128 0.0108 NaN\n", "00001 0.0150 0.0088 NaN\n", "11001 0.0300 0.0316 NaN\n", "01001 0.8792 0.8852 1.0" ] }, "execution_count": 16, "metadata": {}, "output_type": "execute_result" } ], "source": [ "debias_off = pd.DataFrame.from_dict(probs, orient=\"index\").rename(columns={0: \"debias off\"})\n", "debias_on = pd.DataFrame.from_dict(debias_probs, orient=\"index\").rename(columns={0: \"debias on\"})\n", "sharpen_on = pd.DataFrame.from_dict(sharp_probs, orient=\"index\").rename(\n", " columns={0: \"debias on, sharpened\"}\n", ")\n", "df = debias_off.join(debias_on).join(sharpen_on)\n", "df2 = df.sort_values(by=\"debias off\").tail(10)\n", "df2" ] }, { "cell_type": "code", "execution_count": 18, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "" ] }, "execution_count": 18, "metadata": {}, "output_type": "execute_result" }, { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "df2.plot.bar(logy=False, ylabel=\"Probability\", xlabel=\"Bitstring\")" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Task Summary\n", "Note: Charges shown are estimates based on your Amazon Braket simulator and quantum processing unit (QPU) task usage. Estimated charges shown may differ from your actual charges. Estimated charges do not factor in any discounts or credits, and you may experience additional charges based on your use of other services such as Amazon Elastic Compute Cloud (Amazon EC2).\n", "Estimated cost to run this example: 150.6 USD\n" ] } ], "source": [ "print(\"Task Summary\")\n", "print(\n", " \"Note: Charges shown are estimates based on your Amazon Braket simulator and quantum processing unit (QPU) task usage. Estimated charges shown may differ from your actual charges. Estimated charges do not factor in any discounts or credits, and you may experience additional charges based on your use of other services such as Amazon Elastic Compute Cloud (Amazon EC2).\"\n", ")\n", "print(\n", " f\"Estimated cost to run this example: {cost_tracker.qpu_tasks_cost() + cost_tracker.simulator_tasks_cost():.3f} USD\"\n", ")" ] }, { "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ "## References \n", "\n", "[1] “Enhancing quantum computer performance via symmetrization”, https://arxiv.org/abs/2301.07233" ] } ], "metadata": { "kernelspec": { "display_name": "tket", "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.5" }, "orig_nbformat": 4 }, "nbformat": 4, "nbformat_minor": 2 }