Skip to content

Instantly share code, notes, and snippets.

@cosenal

cosenal/qw_benchmark.ipynb

Created February 12, 2025 09:34
Show Gist options

  • Select an option

    Learn more about clone URLs
  • Save cosenal/172f1c42194ce50d6e991ab931dd6d45 to your computer and use it in GitHub Desktop.

Select an option

Learn more about clone URLs
Save cosenal/172f1c42194ce50d6e991ab931dd6d45 to your computer and use it in GitHub Desktop.
Download ZIP
qw_benchmark.ipynb
Display the source blob
Display the rendered blob
Raw
qw_benchmark.ipynb
{
"cells": [
{
"cell_type": "markdown",
"metadata": {
"id": "view-in-github",
"colab_type": "text"
},
"source": [
"<a href=\"https://colab.research.google.com/gist/cosenal/172f1c42194ce50d6e991ab931dd6d45/qw_benchmark.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"id": "Yj9nX5QMXzSA"
},
"outputs": [],
"source": [
"import os\n",
"from dotenv import load_dotenv\n",
"from qiskit_ibm_runtime import QiskitRuntimeService\n",
"\n",
"load_dotenv()\n",
"\n",
"service = QiskitRuntimeService(\n",
" channel='ibm_quantum',\n",
" instance='uf-benchmarking/metriq-gym/metriq-gym',\n",
" token=os.getenv('QISKIT_IBM_TOKEN')\n",
")"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "zvpq4NDgXzSB"
},
"source": [
"# Coding intermediate-stage quantum benchmarks\n",
"\n",
"### Alessandro Cosentino, Quantum Wednesday, Jan 22, 2025\n"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "NucUg9VRXzSC"
},
"source": [
"## Introduction\n",
"\n",
"_Quantum benchmarks_: Providing a quantitative metrics for the quality of a quantum computer.\n",
"\n",
"Intermediate-stage: ~10–1000 qubits – understand the noise of a device in a more holistic way, connectivity, error rates, etc.\n",
"\n",
"Regime where error mitigation techniques are necessary (repeating iteration of circuits and averaging results)"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "ryppMa3BXzSC"
},
"source": [
"## Scale, quality, and speed"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "kJWCOJAvXzSC"
},
"source": [
"### Performance metrics\n",
"- Scale: the number of qubits\n",
"- Quality: Quantum volume\n",
"- Speed: CLOPS"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"id": "A7AtkylLXzSC"
},
"outputs": [],
"source": [
"n_qubits = 3"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "L9JF-sqoXzSD"
},
"source": [
"## Quality: Quantum Volume (QV)\n",
"\n",
"📄 [Validating quantum computers using randomized model circuits](https://arxiv.org/pdf/1811.12926) by Andrew W. Cross, Lev S. Bishop, Sarah Sheldon, Paul D. Nation, Jay M. Gambetta\n",
"\n",
"### Generating circuits\n",
"\n",
"- Layers of qubit permutations and random 2-qubit unitaries\n",
"- Mimicking a usual quantum circuit\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"id": "CbcItHgTXzSD",
"outputId": "e3c03b1d-6998-4d26-cb11-7ef0020c182e"
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
" ┌──────────────┐┌──────────┐┌──────────────┐┌──────────┐┌──────────────┐»\n",
"q_0: ┤0 ├┤0 ├┤0 ├┤0 ├┤0 ├»\n",
" │ ││ Unitary ││ ││ Unitary ││ │»\n",
"q_1: ┤1 Permutation ├┤1 ├┤1 Permutation ├┤1 ├┤1 Permutation ├»\n",
" │ │├─────────┬┘│ │├─────────┬┘│ │»\n",
"q_2: ┤2 ├┤ Unitary ├─┤2 ├┤ Unitary ├─┤2 ├»\n",
" └──────────────┘└─────────┘ └──────────────┘└─────────┘ └──────────────┘»\n",
"« ┌──────────┐\n",
"«q_0: ┤0 ├\n",
"« │ Unitary │\n",
"«q_1: ┤1 ├\n",
"« ├─────────┬┘\n",
"«q_2: ┤ Unitary ├─\n",
"« └─────────┘ \n"
]
}
],
"source": [
"import numpy as np\n",
"import scipy\n",
"from qiskit.circuit import QuantumCircuit, CircuitInstruction\n",
"from qiskit.circuit.library.generalized_gates import PermutationGate, UnitaryGate\n",
"\n",
"\n",
"rng = np.random.default_rng()\n",
"\n",
"qv_circuit = QuantumCircuit(n_qubits)\n",
"unitaries = scipy.stats.unitary_group.rvs(4, n_qubits * n_qubits, rng).reshape(\n",
" n_qubits, n_qubits, 4, 4\n",
")\n",
"qubits = tuple(qv_circuit.qubits)\n",
"for row in unitaries:\n",
" perm = rng.permutation(n_qubits)\n",
"\n",
" qv_circuit._append(CircuitInstruction(PermutationGate(perm), qubits))\n",
" for w, unitary in enumerate(row):\n",
" gate = UnitaryGate(unitary, check_input=False, num_qubits=2)\n",
" qubit = 2 * w\n",
" qv_circuit._append(CircuitInstruction(gate, qubits[qubit : qubit + 2]))\n",
"print(qv_circuit)"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"id": "ybvcgo3qXzSE",
"outputId": "e9ea11a1-f1f9-429c-83bc-d3ceb6abd201"
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"4\n"
]
},
{
"data": {
"text/html": [
"<pre style=\"word-wrap: normal;white-space: pre;background: #fff0;line-height: 1.1;font-family: &quot;Courier New&quot;,Courier,monospace\"> ┌──────────┐┌──────────┐┌──────────┐ ░ ┌─┐ \n",
" q_0: ┤1 ├┤1 ├┤1 ├─░─┤M├──────\n",
" │ ││ Unitary ││ │ ░ └╥┘┌─┐ \n",
" q_1: ┤ Unitary ├┤0 ├┤ Unitary ├─░──╫─┤M├───\n",
" │ │└──────────┘│ │ ░ ║ └╥┘┌─┐\n",
" q_2: ┤0 ├────────────┤0 ├─░──╫──╫─┤M├\n",
" └──────────┘ └──────────┘ ░ ║ ║ └╥┘\n",
"meas: 3/════════════════════════════════════════╩══╩══╩═\n",
" 0 1 2 </pre>"
],
"text/plain": [
" ┌──────────┐┌──────────┐┌──────────┐ ░ ┌─┐ \n",
" q_0: ┤1 ├┤1 ├┤1 ├─░─┤M├──────\n",
" │ ││ Unitary ││ │ ░ └╥┘┌─┐ \n",
" q_1: ┤ Unitary ├┤0 ├┤ Unitary ├─░──╫─┤M├───\n",
" │ │└──────────┘│ │ ░ ║ └╥┘┌─┐\n",
" q_2: ┤0 ├────────────┤0 ├─░──╫──╫─┤M├\n",
" └──────────┘ └──────────┘ ░ ║ ║ └╥┘\n",
"meas: 3/════════════════════════════════════════╩══╩══╩═\n",
" 0 1 2 "
]
},
"execution_count": 314,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"from qiskit.circuit.library import QuantumVolume as QuantumVolumeCircuit\n",
"\n",
"n_qubits = 3\n",
"qv_circuit = QuantumVolumeCircuit(n_qubits, depth=n_qubits)\n",
"qv_circuit.measure_all()\n",
"qv_circuit = qv_circuit.decompose()\n",
"print(qv_circuit.depth())\n",
"qv_circuit.draw()"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"id": "wenUNRkZXzSE",
"outputId": "a27d06c3-ec68-40ae-ce13-ca54a4707c08"
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"global phase: 1.4042\n",
" ┌───────────────────────────┐ ┌───┐┌─────────────────────────┐┌───┐»\n",
" q_0: ┤ U(1.0666,-0.29243,1.1851) ├─┤ X ├┤ U(1.5478,-3.0431,0.229) ├┤ X ├»\n",
" └┬──────────────────────────┤ └─┬─┘└─────────────────────────┘└─┬─┘»\n",
" q_1: ─┤ U(2.1872,2.5946,0.54123) ├───┼───────────────────────────────┼──»\n",
" ┌┴──────────────────────────┴┐ │ ┌─────────────────────┐ │ »\n",
" q_2: ┤ U(1.5107,-2.8895,-0.55864) ├──■────┤ U(1.0589,-π/2,-π/2) ├────■──»\n",
" └────────────────────────────┘ └─────────────────────┘ »\n",
"meas: 3/═══════════════════════════════════════════════════════════════════»\n",
" »\n",
"« ┌───────────────────────────┐┌───┐┌───────────────────────────┐»\n",
"« q_0: ┤ U(1.6714,0.01024,-1.4692) ├┤ X ├┤ U(1.1624,0.38401,-1.3391) ├»\n",
"« └───────────────────────────┘└─┬─┘└───────────────────────────┘»\n",
"« q_1: ───────────────────────────────┼───────────────────────────────»\n",
"« ┌───────────────────┐ │ ┌──────────────────────────┐»\n",
"« q_2: ────┤ U(0.33009,0,-π/2) ├──────■───┤ U(1.139,0.035436,2.3121) ├»\n",
"« └───────────────────┘ └──────────────────────────┘»\n",
"«meas: 3/═══════════════════════════════════════════════════════════════»\n",
"« »\n",
"« ┌───────────────────────────┐ ┌───┐┌────────────────────────────┐┌───┐»\n",
"« q_0: ┤ U(2.5856,2.0243,-0.40144) ├─┤ X ├┤ U(1.5659,-3.0406,0.048485) ├┤ X ├»\n",
"« └───────────────────────────┘ └─┬─┘└──┬──────────────────────┬──┘└─┬─┘»\n",
"« q_1: ────────────────────────────────■─────┤ U(0.63743,-π/2,-π/2) ├─────■──»\n",
"« ┌────────────────────────────┐ └──────────────────────┘ »\n",
"« q_2: ┤ U(0.63126,2.708,-0.005662) ├────────────────────────────────────────»\n",
"« └────────────────────────────┘ »\n",
"«meas: 3/══════════════════════════════════════════════════════════════════════»\n",
"« »\n",
"« ┌───────────────────────────┐┌───┐┌────────────────────────────┐»\n",
"« q_0: ┤ U(1.6714,0.01024,-1.4692) ├┤ X ├┤ U(2.8179,-0.34297,-2.2611) ├»\n",
"« └───┬───────────────────┬───┘└─┬─┘└┬──────────────────────────┬┘»\n",
"« q_1: ────┤ U(0.09162,0,-π/2) ├──────■───┤ U(2.2421,2.3578,-2.5793) ├─»\n",
"« └───────────────────┘ └──────────────────────────┘ »\n",
"« q_2: ────────────────────────────────────────────────────────────────»\n",
"« »\n",
"«meas: 3/════════════════════════════════════════════════════════════════»\n",
"« »\n",
"« ┌─────────────────────────────┐┌───┐┌─────────────────────────────┐»\n",
"« q_0: ┤ U(1.1462,-0.20622,-0.78343) ├┤ X ├┤ U(1.5776,-3.0407,-0.067187) ├»\n",
"« └─────────────────────────────┘└─┬─┘└─────────────────────────────┘»\n",
"« q_1: ─────────────────────────────────┼─────────────────────────────────»\n",
"« │ ┌──────────────────────┐ »\n",
"« q_2: ─────────────────────────────────■──────┤ U(0.40318,-π/2,-π/2) ├───»\n",
"« └──────────────────────┘ »\n",
"«meas: 3/═══════════════════════════════════════════════════════════════════»\n",
"« »\n",
"« ┌───┐┌───────────────────────────┐┌───┐┌───────────────────────────┐»\n",
"« q_0: ┤ X ├┤ U(1.6714,0.01024,-1.4692) ├┤ X ├┤ U(2.2095,-0.38991,1.6739) ├»\n",
"« └─┬─┘└───────────────────────────┘└─┬─┘└───────────────────────────┘»\n",
"« q_1: ──┼─────────────────────────────────┼───────────────────────────────»\n",
"« │ ┌───────────────────┐ │ ┌───────────────────────────┐»\n",
"« q_2: ──■──────┤ U(0.30963,-π,π/2) ├──────■──┤ U(1.0476,-1.1709,0.49445) ├»\n",
"« └───────────────────┘ └───────────────────────────┘»\n",
"«meas: 3/════════════════════════════════════════════════════════════════════»\n",
"« »\n",
"« ░ ┌─┐ \n",
"« q_0: ─░─┤M├──────\n",
"« ░ └╥┘┌─┐ \n",
"« q_1: ─░──╫─┤M├───\n",
"« ░ ║ └╥┘┌─┐\n",
"« q_2: ─░──╫──╫─┤M├\n",
"« ░ ║ ║ └╥┘\n",
"«meas: 3/════╩══╩══╩═\n",
"« 0 1 2 \n"
]
}
],
"source": [
"qv_circuit = qv_circuit.decompose(reps=1)\n",
"print(qv_circuit.draw())"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"id": "JcSbM0yRXzSE",
"outputId": "f5745eb5-825c-4073-8419-ecdd445e2418"
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"[0.21218720078468323, 0.19779501855373383, 0.04661557823419571, 0.11564416438341141, 0.004920824896544218, 0.21720710396766663, 0.074178546667099, 0.1314513236284256]\n"
]
}
],
"source": [
"from pyqrack import QrackSimulator\n",
"\n",
"simulator = QrackSimulator(n_qubits)\n",
"simulator.run_qiskit_circuit(qv_circuit, shots=1000)\n",
"probabilities = simulator.out_probs()\n",
"print(probabilities)"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"id": "J4d5HnL1XzSE",
"outputId": "f1089478-5c71-4803-fc4e-a27710c3a3eb"
},
"outputs": [
{
"data": {
"text/plain": [
"<BarContainer object of 8 artists>"
]
},
"execution_count": 317,
"metadata": {},
"output_type": "execute_result"
},
{
"data": {
"image/png": "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",
"text/plain": [
"<Figure size 640x480 with 1 Axes>"
]
},
"metadata": {},
"output_type": "display_data"
}
],
"source": [
"import matplotlib.pyplot as plt\n",
"\n",
"binary_labels = [bin(i)[2:].zfill(n_qubits) for i in range(2**n_qubits)]\n",
"\n",
"plt.bar(binary_labels, probabilities)"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"id": "C-7BXKpAXzSF",
"outputId": "7eb28f61-10e0-4d7f-e540-b5ab0e20e9f3"
},
"outputs": [
{
"data": {
"text/plain": [
"<BarContainer object of 8 artists>"
]
},
"execution_count": 318,
"metadata": {},
"output_type": "execute_result"
},
{
"data": {
"image/png": "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",
"text/plain": [
"<Figure size 640x480 with 1 Axes>"
]
},
"metadata": {},
"output_type": "display_data"
}
],
"source": [
"sorted_data = sorted(zip(probabilities, binary_labels))\n",
"sorted_probabilities, sorted_labels = zip(*sorted_data)\n",
"\n",
"plt.bar(sorted_labels, sorted_probabilities)"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"id": "r4k9wIu7XzSF",
"outputId": "9fd000d9-e69c-426d-8498-22309b84b7de"
},
"outputs": [
{
"data": {
"text/plain": [
"<BarContainer object of 8 artists>"
]
},
"execution_count": 319,
"metadata": {},
"output_type": "execute_result"
},
{
"data": {
"image/png": "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",
"text/plain": [
"<Figure size 640x480 with 1 Axes>"
]
},
"metadata": {},
"output_type": "display_data"
}
],
"source": [
"import numpy as np\n",
"\n",
"median_probability = np.median(probabilities)\n",
"heavy_outputs = [label for label, prob in zip(binary_labels, probabilities) if prob > median_probability]\n",
"colors = ['red' if p > median_probability else 'blue' for p in sorted_probabilities]\n",
"plt.bar(sorted_labels, sorted_probabilities, color=colors)\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"id": "OahzuKWjXzSF",
"outputId": "0c2c0ee3-a24f-471e-f2a7-a6ed4b0025a4"
},
"outputs": [
{
"data": {
"text/plain": [
"{'000': 205,\n",
" '001': 200,\n",
" '110': 72,\n",
" '101': 204,\n",
" '010': 69,\n",
" '111': 110,\n",
" '011': 113,\n",
" '100': 27}"
]
},
"execution_count": 320,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"from qiskit import transpile\n",
"from qiskit_ibm_runtime.fake_provider import FakeManilaV2\n",
"from qiskit_ibm_runtime import SamplerV2\n",
"\n",
"N_SHOTS = 1000\n",
"backend = FakeManilaV2()\n",
"transpiled_qv_circuit = transpile(qv_circuit, backend)\n",
"\n",
"sampler = SamplerV2(backend)\n",
"job = sampler.run([transpiled_qv_circuit], shots=N_SHOTS)\n",
"result = job.result()\n",
"counts = result[0].data.meas.get_counts()\n",
"counts"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"id": "iOSMYmv9XzSF",
"outputId": "33df7457-174f-4a49-efa3-11dc613aa281"
},
"outputs": [
{
"data": {
"text/plain": [
"719"
]
},
"execution_count": 321,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"heavy_counts = 0\n",
"for label, count in counts.items():\n",
" if label in heavy_outputs:\n",
" heavy_counts += count\n",
"heavy_counts\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"id": "T-51PWVsXzSF",
"outputId": "2d762cd7-0054-4374-8027-e2fee646d45d"
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Quantum Volume >= 8\n",
"\n"
]
}
],
"source": [
"if heavy_counts / N_SHOTS > 2/3:\n",
" print(f\"Quantum Volume >= {2**n_qubits}\\n\")"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "wKm_a9iEXzSG"
},
"source": [
"## Putting it all together"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"id": "kcKZhLGNXzSG",
"outputId": "1b5a0566-e51e-4be5-c897-de6bb2885cb2"
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Quantum Volume is 4\n",
"\n"
]
}
],
"source": [
"def create_qv_circuit(n_qubits):\n",
" qv_circuit = QuantumVolumeCircuit(n_qubits, depth=n_qubits)\n",
" qv_circuit.measure_all()\n",
" return qv_circuit\n",
"\n",
"def get_ideal_probabilities(circuit):\n",
" simulator = QrackSimulator(circuit.num_qubits)\n",
" simulator.reset_all()\n",
" simulator.run_qiskit_circuit(circuit.decompose(reps=2), shots=1000)\n",
" return simulator.out_probs()\n",
"\n",
"def get_heavy_outputs(probabilities):\n",
" median_probability = np.median(probabilities)\n",
" return [label for label, prob in zip(binary_labels, probabilities) if prob > median_probability]\n",
"\n",
"def is_qv_heavy_output(label, heavy_outputs):\n",
" return label in heavy_outputs\n",
"\n",
"def run_qv_circuit_on_backend(circuit, backend, n_shots):\n",
" transpiled_qv_circuit = transpile(circuit, backend)\n",
" sampler = SamplerV2(backend)\n",
" job = sampler.run([transpiled_qv_circuit], shots=n_shots)\n",
" result = job.result()\n",
" counts = result[0].data.meas.get_counts()\n",
" return counts\n",
"\n",
"def get_heavy_counts(counts, heavy_outputs):\n",
" heavy_counts = 0\n",
" for label, count in counts.items():\n",
" if is_qv_heavy_output(label, heavy_outputs):\n",
" heavy_counts += count\n",
" return heavy_counts\n",
"\n",
"def multiple_trials(n_qubits, n_trials, backend, n_shots):\n",
" heavy_counts = 0\n",
" for _ in range(n_trials):\n",
" qv_circuit = create_qv_circuit(n_qubits)\n",
" ideal_probabilities = get_ideal_probabilities(qv_circuit)\n",
" heavy_outputs = get_heavy_outputs(ideal_probabilities)\n",
" counts = run_qv_circuit_on_backend(qv_circuit, backend, n_shots)\n",
" heavy_counts += get_heavy_counts(counts, heavy_outputs)\n",
" return heavy_counts\n",
"\n",
"def condition_met(heavy_counts, n_trials, n_shots):\n",
" # return heavy_counts / (n_trials * n_shots) > 2/3\n",
" #\n",
" # Now with confidence interval, i.e., the heavy output probability is greater than 2/3 w.p. > 97%\n",
" #\n",
" return (heavy_counts - 2*np.sqrt(heavy_counts*(n_shots-(heavy_counts/n_trials)))) / (n_trials * n_shots) > 2/3\n",
"\n",
"\n",
"def run_qv_benchmark(backend, n_qubits, n_trials, n_shots):\n",
" heavy_counts = multiple_trials(n_qubits, n_trials, backend, n_shots)\n",
" return condition_met(heavy_counts, n_trials, n_shots)\n",
"\n",
"\n",
"\n",
"backend = FakeManilaV2()\n",
"n_qubits = 3\n",
"\n",
"n_trials = 10\n",
"n_shots = 1000\n",
"\n",
"while run_qv_benchmark(backend, n_qubits, n_trials, n_shots):\n",
" n_qubits += 1\n",
"\n",
"print(f\"Quantum Volume is {2**(n_qubits-1)}\\n\")\n"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "AszxExt2XzSG"
},
"source": [
"### Observations ⚠️\n",
"\n",
"- Choice of parameters is important (n_trials, n_shots)\n",
"- Not scalable to large quantum computers\n",
" - Computational cost of simulating the circuits\n",
" - Computational cost of comparing distributions\n",
"- Driver in this implementation is the client\n",
" - queue times!\n",
"- easy to x-platform-ify: we only need {counts} from the quantum computer"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "qiCgstbbXzSG"
},
"source": [
"### Mirror Quantum Volume"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"id": "EA2Cxd0HXzSG"
},
"outputs": [],
"source": [
"from qiskit import QuantumCircuit\n",
"\n",
"n_qubits = 3\n",
"\n",
"qv_circuit = create_qv_circuit(n_qubits)\n",
"qv_circuit.remove_final_measurements()\n",
"mirror_qv_circuit = QuantumCircuit(n_qubits)\n",
"quantum_ops = qv_circuit.copy()\n",
"\n",
"\n",
"half_depth = len(quantum_ops.data) // 2\n",
"for i in range(half_depth):\n",
" mirror_qv_circuit.append(quantum_ops.data[i][0], quantum_ops.data[i][1])\n",
"\n",
"mirror_qv_circuit.compose(mirror_qv_circuit.inverse(), inplace=True)\n",
"\n",
"mirror_qv_circuit.measure_all()"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"id": "6AwxeIL7XzSG",
"outputId": "ce1e10a5-bf01-4638-f82c-5b652d69244b"
},
"outputs": [
{
"data": {
"text/plain": [
"<BarContainer object of 8 artists>"
]
},
"execution_count": 327,
"metadata": {},
"output_type": "execute_result"
},
{
"data": {
"image/png": "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",
"text/plain": [
"<Figure size 640x480 with 1 Axes>"
]
},
"metadata": {},
"output_type": "display_data"
}
],
"source": [
"simulator = QrackSimulator(n_qubits)\n",
"simulator.run_qiskit_circuit(mirror_qv_circuit.decompose(reps=2), shots=10000)\n",
"probabilities = simulator.out_probs()\n",
"plt.bar(binary_labels, probabilities)"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "lR1wn8-yXzSG"
},
"source": [
"## Speed: Circuit Layer Operations Per Second (CLOPS)\n",
"\n",
"📄 [Quality, Speed, and Scale: three key attributes to measure the performance of near-term quantum computers](https://arxiv.org/abs/2110.14108) by Andrew Wack, Hanhee Paik, Ali Javadi-Abhari, Petar Jurcevic, Ismael Faro, Jay M. Gambetta, Blake R. Johnson\n",
"\n",
"Name inspired by **FLOPS** (Floating Point Operations Per Second)"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "B_G084UgXzSH"
},
"source": [
"- chain of parametrized Quantum Volume circuits where the parameter of circuit i is the output of circuit i-1 (mimicking a variational algorithm)"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"id": "kA-E_8b4XzSH",
"outputId": "784c5764-9a69-4a89-8a80-f6a125bc24ea"
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"CLOPS: 410.25 layers/sec\n"
]
}
],
"source": [
"import time\n",
"from qiskit import transpile\n",
"\n",
"def run_clops_benchmark(backend, qv_circuits, shots=100):\n",
" transpiled_circuits = transpile(qv_circuits, backend)\n",
"\n",
" start_time = time.time()\n",
" job = backend.run(transpiled_circuits, shots=shots)\n",
" result = job.result()\n",
" end_time = time.time()\n",
"\n",
" execution_time = end_time - start_time\n",
" total_layers = len(qv_circuits) * qv_circuits[0].num_qubits\n",
" return total_layers / execution_time\n",
"\n",
"n_qubits = 5\n",
"num_circuits = 10\n",
"\n",
"qv_circuits = [create_qv_circuit(n_qubits) for _ in range(num_circuits)]\n",
"\n",
"backend = FakeManilaV2()\n",
"\n",
"clops = run_clops_benchmark(backend, qv_circuits)\n",
"print(f\"CLOPS: {clops:.2f} layers/sec\")"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "WuRo2nomXzSH"
},
"source": [
"### Observations ⚠️\n",
"\n",
"- notice the parameters: n_qubits, num_circuits, num_shots\n",
"- a batch of circuits, not a parametrized chain\n",
"- Driver is again the client\n",
" - queue times!"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"id": "QTRPX4u4XzSH",
"outputId": "1393ea83-36e9-462f-ac59-e61b9b191d53"
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"ExecutionSpans([SliceSpan(<start='2024-12-10 18:47:30', stop='2024-12-10 18:49:36', size=2048>)])\n"
]
}
],
"source": [
"from qiskit_ibm_runtime.execution_span import ExecutionSpan\n",
"\n",
"job = service.job('cxc7k5mtpsjg008x83xg')\n",
"job_result = job.result()\n",
"spans: list[ExecutionSpan] = job_result.metadata[\"execution\"][\"execution_spans\"].sort()\n",
"print(spans)"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"id": "0j7515neXzSH",
"outputId": "1a8d9405-1b80-4d8a-8e0b-4c51cf33a27b"
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"CLOPS: 1625.00 layers/sec\n"
]
}
],
"source": [
"N_LAYERS = 100\n",
"\n",
"clops = round(\n",
" sum(span.size for span in spans) * N_LAYERS\n",
" / (spans[-1].stop - spans[0].start).total_seconds()\n",
")\n",
"print(f\"CLOPS: {clops:.2f} layers/sec\")"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "hFgR1U1FXzSH"
},
"source": [
"- steady state / no warmup time"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "WPp_rnD8XzSH"
},
"source": [
"# In the next episode\n",
"\n",
"- Scale: largest connected component under a given a violation of an inequality (e.g. Bell's inequality)\n",
"- Speed: CLOPS_h ([IBM blog post](https://www.ibm.com/quantum/blog/quantum-metric-layer-fidelity))\n",
"- Quality: Error per layered gate (EPLG)\n"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "ArihJT_pXzSH"
},
"source": []
}
],
"metadata": {
"kernelspec": {
"display_name": "metriq-gym-ueIgtH0Z-py3.12",
"language": "python",
"name": "python3"
},
"language_info": {
"codemirror_mode": {
"name": "ipython",
"version": 3
},
"file_extension": ".py",
"mimetype": "text/x-python",
"name": "python",
"nbconvert_exporter": "python",
"pygments_lexer": "ipython3",
"version": "3.12.8"
},
"colab": {
"provenance": [],
"include_colab_link": true
}
},
"nbformat": 4,
"nbformat_minor": 0
}
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment