iqm-benchmarks 2.13__tar.gz → 2.14__tar.gz

{iqm_benchmarks-2.13 → iqm_benchmarks-2.14}/CHANGELOG.rst

@@ -2,6 +2,10 @@
 Changelog
 =========
 
+Version 2.14
+============
+* Added devices folder in docs with notebook to benchmark IQM Spark.
+
 Version 2.13
 ============
 * Move all example notebooks to docs. `#30 <https://github.com/iqm-finland/iqm-benchmarks/pull/30>`_

{iqm_benchmarks-2.13/src/iqm_benchmarks.egg-info → iqm_benchmarks-2.14}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: iqm-benchmarks
-Version: 2.13
+Version: 2.14
 Summary: A package for implementation of Quantum Characterization, Verification and Validation (QCVV) techniques on IQM's hardware at gate level abstraction
 Author-email: IQM Finland Oy <developers@meetiqm.com>, Aniket Rath <aniket.rath@meetiqm.com>, Jami Rönkkö <jami@meetiqm.com>, Pedro Figueroa Romero <pedro.romero@meetiqm.com>, Vicente Pina Canelles <vicente.pina@meetiqm.com>, Raphael Brieger <raphael.brieger@meetiqm.com>, Stefan Seegerer <stefan.seegerer@meetiqm.com>, Miikka Koistinen <miikka@meetiqm.com>, Adrian Auer <adrian.auer@meetiqm.com>
 Project-URL: Homepage, https://github.com/iqm-finland/iqm-benchmarks

{iqm_benchmarks-2.13 → iqm_benchmarks-2.14}/docs/conf.py

@@ -164,6 +164,7 @@ extlinks = {
 
 # -- Options for MyST-NB ---------------------------------------------------------
 nb_execution_mode = 'off'
+myst_enable_extensions = ["dollarmath"]
 
 
 # -- Options for sphinxcontrib.bibtex -------------------------------------------------

iqm_benchmarks-2.14/docs/devices/devices.rst

@@ -0,0 +1,8 @@
+Devices
+#######
+This section provides examples and guidance on how to benchmark specific IQM devices.
+
+.. toctree::
+   :maxdepth: 1
+
+   spark

iqm_benchmarks-2.14/docs/devices/spark.ipynb

@@ -0,0 +1,792 @@
+{
+    "cells": [
+        {
+            "cell_type": "markdown",
+            "id": "8665b62277d47a17",
+            "metadata": {},
+            "source": [
+                "# Benchmarking IQM Spark"
+            ]
+        },
+        {
+            "cell_type": "markdown",
+            "id": "afde8699",
+            "metadata": {},
+            "source": [
+                "This notebook allows you to run some useful benchmarks for the Spark system. Before starting, make sure you have installed all the necessary packages:"
+            ]
+        },
+        {
+            "cell_type": "code",
+            "execution_count": null,
+            "id": "17792e11",
+            "metadata": {},
+            "outputs": [],
+            "source": [
+                "!pip install iqm-benchmarks\n",
+                "!pip install ipykernel"
+            ]
+        },
+        {
+            "cell_type": "markdown",
+            "id": "66ed5587739635b5",
+            "metadata": {},
+            "source": [
+                "## Connect to the backend"
+            ]
+        },
+        {
+            "cell_type": "code",
+            "execution_count": null,
+            "id": "691a27964b11b9ed",
+            "metadata": {
+                "ExecuteTime": {
+                    "end_time": "2024-11-26T11:04:54.444032Z",
+                    "start_time": "2024-11-26T11:04:52.642210Z"
+                }
+            },
+            "outputs": [],
+            "source": [
+                "import os\n",
+                "from iqm.qiskit_iqm import IQMProvider\n",
+                "\n",
+                "os.environ[\"IQM_TOKENS_FILE\"]=\"YOUR TOKEN HERE\"\n",
+                "iqm_url =  'YOUR URL HERE'\n",
+                "provider = IQMProvider(iqm_url)\n",
+                "backend = provider.get_backend()"
+            ]
+        },
+        {
+            "cell_type": "markdown",
+            "id": "06f43ca2",
+            "metadata": {},
+            "source": [
+                "We can access the Spark backend and plot its connectivity graph to check that everything is working properly."
+            ]
+        },
+        {
+            "cell_type": "code",
+            "execution_count": null,
+            "id": "e183e7c5",
+            "metadata": {},
+            "outputs": [],
+            "source": [
+                "from rustworkx.visualization import mpl_draw\n",
+                "from rustworkx import spring_layout\n",
+                "\n",
+                "mpl_draw(backend.coupling_map.graph.to_undirected(multigraph=False), arrows=True, with_labels=True, node_color='#32a8a4', pos=spring_layout(backend.coupling_map.graph, num_iter=200))"
+            ]
+        },
+        {
+            "cell_type": "markdown",
+            "id": "34c084c2",
+            "metadata": {},
+            "source": [
+                "We run the cell below to ignore those warnings that are not critical for the correct run of the benchmarks."
+            ]
+        },
+        {
+            "cell_type": "code",
+            "execution_count": 4,
+            "id": "28154b11",
+            "metadata": {},
+            "outputs": [],
+            "source": [
+                "import warnings\n",
+                "warnings.filterwarnings(action=\"ignore\")  "
+            ]
+        },
+        {
+            "cell_type": "markdown",
+            "id": "3a5460c0",
+            "metadata": {},
+            "source": [
+                "## GHZ state fidelity"
+            ]
+        },
+        {
+            "cell_type": "markdown",
+            "id": "42d71982",
+            "metadata": {},
+            "source": [
+                "The GHZ (Greenberger-Horne-Zeilinger) state is a maximally entangled quantum state that involves three or more qubits, $n$. It is an equal superposition of all qubits being in state 0 and all qubits being in state 1, i.e., $| GHZ \\rangle = \\frac{1}{\\sqrt{2}}(|0\\rangle^{\\otimes n}+|1\\rangle^{\\otimes n})$.\n",
+                "\n",
+                "The GHZ state fidelity acts as a **witness** for genuine multi-qubit entanglement if found to be above $0.5$. This means that the measurement results cannot be explained without entanglement involving **all** qubits, so it is a great way to evaluate the \"quantumness\" of the computer. \n",
+                "\n",
+                "The state $\\rho_{\\text{ideal}}= |GHZ\\rangle\\langle GHZ|$ is a pure state, so in this case the fidelity can be computed as:\n",
+                "\n",
+                "$$\n",
+                "F(\\text{ideal}, \\text{measured})= \\langle GHZ | \\rho_{\\text{measured}} | GHZ \\rangle,$$\n",
+                "\n",
+                "where $\\rho_{\\text{measured}}$ is the density matrix given by the actual results of the quantum computer. The ideal GHZ state density matrix entries can be written as $\\rho_{i,j}=\\langle i| \\rho_{\\text{ideal}} | j \\rangle$ where $i,j$ are the $n$ basis states $\\{|00..0\\rangle, ..., |11..1\\rangle\\}$; only the corner entries $\\rho_{0,0},\\rho_{0,n},\\rho_{n,0}$ and $\\rho_{n,n} $ are non-zero. This simplifies the process since we only need to measure these four components. In the fidelity formula, all other entries are effectively nullified by the zero entries in the ideal state matrix. To measure the coherences (off-diagonal entries) we use the method of multiple quantum coherences [Mooney, 2021](https://iopscience.iop.org/article/10.1088/2399-6528/ac1df7/meta). "
+            ]
+        },
+        {
+            "cell_type": "code",
+            "execution_count": 5,
+            "id": "55bf7633",
+            "metadata": {},
+            "outputs": [],
+            "source": [
+                "from iqm.benchmarks.entanglement.ghz import GHZConfiguration, GHZBenchmark"
+            ]
+        },
+        {
+            "cell_type": "code",
+            "execution_count": 6,
+            "id": "29c9dda9",
+            "metadata": {},
+            "outputs": [],
+            "source": [
+                "GHZ = GHZConfiguration(\n",
+                "    state_generation_routine=\"tree\",\n",
+                "    custom_qubits_array=[[0,1,2,3,4]],\n",
+                "    shots=1000,\n",
+                "    qiskit_optim_level=3,\n",
+                "    optimize_sqg=True,\n",
+                "    fidelity_routine=\"coherences\", \n",
+                "    rem=True,\n",
+                "    mit_shots=1000,\n",
+                ")"
+            ]
+        },
+        {
+            "cell_type": "markdown",
+            "id": "afd7e8b8",
+            "metadata": {},
+            "source": [
+                "> If you want to modify the settings above, please refer to the documentation [here](https://iqm-finland.github.io/iqm-benchmarks/api/iqm.benchmarks.entanglement.ghz.GHZConfiguration.html#iqm.benchmarks.entanglement.ghz.GHZConfiguration)."
+            ]
+        },
+        {
+            "cell_type": "markdown",
+            "id": "cd0bd717",
+            "metadata": {},
+            "source": [
+                "Before running the benchmark analysis, we can visualize the histogram of counts obtained from measuring a GHZ state on 5 qubits:"
+            ]
+        },
+        {
+            "cell_type": "code",
+            "execution_count": null,
+            "id": "5c2f2077",
+            "metadata": {},
+            "outputs": [],
+            "source": [
+                "from iqm.benchmarks.entanglement.ghz import generate_ghz_spanning_tree, get_edges\n",
+                "from qiskit import transpile\n",
+                "from qiskit.visualization import plot_histogram\n",
+                "\n",
+                "qubit_layout = [0,1,2,3,4]\n",
+                "graph = get_edges(coupling_map=backend.coupling_map, qubit_layout=qubit_layout)\n",
+                "ghz_circuit = generate_ghz_spanning_tree(graph, qubit_layout, n_state=5)[0]\n",
+                "qc_transp = transpile(ghz_circuit, backend=backend, optimization_level=3)\n",
+                "res = backend.run(qc_transp, shots=10000).result() \n",
+                "counts=res.get_counts()\n",
+                "\n",
+                "plot_histogram(counts)"
+            ]
+        },
+        {
+            "cell_type": "code",
+            "execution_count": null,
+            "id": "f2d380a8",
+            "metadata": {},
+            "outputs": [],
+            "source": [
+                "benchmark_ghz = GHZBenchmark(backend, GHZ)\n",
+                "run_ghz = benchmark_ghz.run()"
+            ]
+        },
+        {
+            "cell_type": "code",
+            "execution_count": null,
+            "id": "7ee53190",
+            "metadata": {},
+            "outputs": [],
+            "source": [
+                "result_ghz = benchmark_ghz.analyze()\n",
+                "for observation in result_ghz.observations:\n",
+                "    if observation.identifier.string_identifier == str(qubit_layout):\n",
+                "        print(f\"{observation.name}: {observation.value}\") "
+            ]
+        },
+        {
+            "cell_type": "markdown",
+            "id": "beb8d573",
+            "metadata": {},
+            "source": [
+                "## Quantum Volume"
+            ]
+        },
+        {
+            "cell_type": "markdown",
+            "id": "a8451afb",
+            "metadata": {},
+            "source": [
+                "Quantum volume is a single-number metric that was introduced in [Cross, 2019](https://journals.aps.org/pra/abstract/10.1103/PhysRevA.100.032328). It evaluates the quality of a quantum processor via the largest random *square* circuit, i.e., with the same number of layers of parallel random 2-qubit unitaries as number of qubits, that it can run successfully.\n",
+                "\n",
+                "The success of a run is based on the heavy output probability, which corresponds to the probability of observing *heavy outputs*, i.e. the measurement outputs that occcur with a probability greater than the median of the distribution. The heavy output generation problem asks if the generated distribution of the random circuit we run contains heavy outputs at least 2/3 of the time (on average) with a high confidence level, typically higher than 97.5%. It can be shown that the heavy output probability for an ideal device is at around 0.85 asymptotically. \n",
+                "The quantum volume is then defined as\n",
+                "\n",
+                "$$\\log_2 V_q = \\underset{n}{\\text{argmax}} \\min (n, d(n))$$\n",
+                "\n",
+                "where $n \\leq N$ is a number of qubits and $d(n)$ is the *achievable depth*, i.e. the largest depth such that we are confident the probability of observing a heavy output is greater than 2/3.\n"
+            ]
+        },
+        {
+            "cell_type": "code",
+            "execution_count": 10,
+            "id": "2953c181",
+            "metadata": {},
+            "outputs": [],
+            "source": [
+                "from iqm.benchmarks.quantum_volume.quantum_volume import QuantumVolumeConfiguration, QuantumVolumeBenchmark"
+            ]
+        },
+        {
+            "cell_type": "markdown",
+            "id": "aa510035",
+            "metadata": {},
+            "source": [
+                "We define a combination of qubits to test quantum volume on. Due to the star topology, the combinations must contain at least qubit #2 (see topmost graph)."
+            ]
+        },
+        {
+            "cell_type": "code",
+            "execution_count": 11,
+            "id": "0a828dca",
+            "metadata": {},
+            "outputs": [],
+            "source": [
+                "QV = QuantumVolumeConfiguration(\n",
+                "    num_circuits=500, \n",
+                "    shots=2**8,\n",
+                "    calset_id=None,\n",
+                "    num_sigmas=2,\n",
+                "    choose_qubits_routine=\"custom\",\n",
+                "    custom_qubits_array=[[0,1,2], [0,2,3], [0,2,4], [1,2,3], [1,2,4]], \n",
+                "    qiskit_optim_level=3,\n",
+                "    optimize_sqg=True,\n",
+                "    max_gates_per_batch=60_000,\n",
+                "    rem=True,\n",
+                "    mit_shots=1_000,\n",
+                ")"
+            ]
+        },
+        {
+            "cell_type": "markdown",
+            "id": "f4961b2b",
+            "metadata": {},
+            "source": [
+                "> If you want to modify the settings above, please refer to the documentation [here](https://iqm-finland.github.io/iqm-benchmarks/api/iqm.benchmarks.quantum_volume.quantum_volume.QuantumVolumeConfiguration.html#iqm.benchmarks.quantum_volume.quantum_volume.QuantumVolumeConfiguration)."
+            ]
+        },
+        {
+            "cell_type": "markdown",
+            "id": "121ddd03",
+            "metadata": {},
+            "source": [
+                "Warning: The following code cell may take few minutes to run since it will compute the benchmark on all the qubit layouts specified above."
+            ]
+        },
+        {
+            "cell_type": "code",
+            "execution_count": null,
+            "id": "4a5abb3d",
+            "metadata": {},
+            "outputs": [],
+            "source": [
+                "benchmark_qv = QuantumVolumeBenchmark(backend, QV)\n",
+                "run_qv = benchmark_qv.run()"
+            ]
+        },
+        {
+            "cell_type": "code",
+            "execution_count": null,
+            "id": "7d649b35",
+            "metadata": {},
+            "outputs": [],
+            "source": [
+                "result_qv = benchmark_qv.analyze()\n",
+                "for v in result_qv.plots.values():\n",
+                "    display(v)"
+            ]
+        },
+        {
+            "cell_type": "markdown",
+            "id": "bbd2d8a9",
+            "metadata": {},
+            "source": [
+                "## Circuit Layer Operations Per Second (CLOPS)"
+            ]
+        },
+        {
+            "cell_type": "markdown",
+            "id": "4e659f10",
+            "metadata": {},
+            "source": [
+                "CLOPS is a metric that estimates the speed at which a quantum computer can execute Quantum Volume (QV) layers of a quantum circuit. That is, the circuits to calculate this benchmark have the same structure as the ones used for QV. Here we follow the definition introduced in ([Wack, 2021](https://arxiv.org/abs/2110.14108)), but other versions of this benchmark exist. \n",
+                "\n",
+                "CLOPS is measured by means of a quantum variational-like protocol, where templates of parametrized QV circuits are assigned random parameters, executed, and outcomes are used as a seed to assign new parameters and repeat the process. The ratio of number of templates ($M$), parameter updates ($K$), measurement shots ($S$) and QV layers ($\\log_2\\mathrm{QV}$) with the time taken to run all, constitutes the CLOPS value: \n",
+                "\n",
+                "$$\n",
+                "\\mathrm{CLOPS}=M\\times{K}\\times{S}\\times\\log_2\\mathrm{QV}/\\mathrm{total\\_time}.\n",
+                "$$\n",
+                "\n",
+                "Notice that the total CLOPS time includes that of assignment of parameters, submission of circuits and retrieval of results."
+            ]
+        },
+        {
+            "cell_type": "code",
+            "execution_count": 14,
+            "id": "1e1687c8",
+            "metadata": {},
+            "outputs": [],
+            "source": [
+                "from iqm.benchmarks.quantum_volume.clops import CLOPSConfiguration, CLOPSBenchmark, plot_times"
+            ]
+        },
+        {
+            "cell_type": "code",
+            "execution_count": 15,
+            "id": "e2c3a156",
+            "metadata": {},
+            "outputs": [],
+            "source": [
+                "CLOPS = CLOPSConfiguration(\n",
+                "    qubits=[0,1,2],\n",
+                "    num_circuits=100,\n",
+                "    num_updates=10, \n",
+                "    num_shots=100, \n",
+                "    calset_id=None,\n",
+                "    qiskit_optim_level=3,\n",
+                "    optimize_sqg=True,\n",
+                "    routing_method=\"sabre\",\n",
+                "    physical_layout=\"fixed\",\n",
+                ")"
+            ]
+        },
+        {
+            "cell_type": "markdown",
+            "id": "e9f0a8d4",
+            "metadata": {},
+            "source": [
+                "> If you want to modify the settings above, please refer to the documentation [here](https://iqm-finland.github.io/iqm-benchmarks/api/iqm.benchmarks.quantum_volume.clops.CLOPSConfiguration.html#iqm.benchmarks.quantum_volume.clops.CLOPSConfiguration)."
+            ]
+        },
+        {
+            "cell_type": "code",
+            "execution_count": null,
+            "id": "dcd33d91",
+            "metadata": {},
+            "outputs": [],
+            "source": [
+                "benchmark_clops = CLOPSBenchmark(backend, CLOPS)\n",
+                "run_clops = benchmark_clops.run()"
+            ]
+        },
+        {
+            "cell_type": "code",
+            "execution_count": null,
+            "id": "28d75dac",
+            "metadata": {},
+            "outputs": [],
+            "source": [
+                "result_clops = benchmark_clops.analyze()\n",
+                "fig_clops = plot_times(result_clops.dataset, result_clops.observations)\n",
+                "display(fig_clops[1])"
+            ]
+        },
+        {
+            "cell_type": "markdown",
+            "id": "61abb7bed3688593",
+            "metadata": {},
+            "source": [
+                "## Clifford Randomized Benchmarking"
+            ]
+        },
+        {
+            "cell_type": "markdown",
+            "id": "c3bb8c10",
+            "metadata": {},
+            "source": [
+                "The idea behind Clifford Randomized Benchmarking (CRB) is that under certain (simplified) types of noise, the average survival probability of an initial state $|0\\rangle$ under random sequences of Clifford gates and a final sequence inverse will decay exponentially in the length of the sequences. This can be written as\n",
+                "\n",
+                "$$\n",
+                "\\langle0|C_\\text{inv}C_m\\cdots{C}_2C_1|0\\rangle\\sim{A}p^m + B,\n",
+                "$$\n",
+                "\n",
+                "where $C_1, C_2, \\ldots, C_m$ is the random sequences of Clifford gates, $C_\\text{inv}=(C_1C_2\\cdots{C}_m)^{-1}$, $0\\leq{p}\\leq{1}$ and $0\\leq{A,B}\\leq1$ are constants isolating the effects of state-preparation and measurement (SPAM) errors ([Magesan,2012](https://journals.aps.org/pra/abstract/10.1103/PhysRevA.85.042311)). From such decay, one can in turn infer the average fidelity of the corresponding Clifford group. \n",
+                "\n",
+                "The main assumption we will make here is that the noise can be modeled as Markovian, time-stationary and gate-independent. \n",
+                "\n",
+                "The theory of CRB under these approximations, and the fact that the multi-qubit Clifford group is a **unitary 2-design** (i.e., uniformly averaging with two pairs of $C$, $C^{\\dagger}$ Clifford operators gives the same result as using fully random unitaries), ensures that the average fidelity of our gate set is given by\n",
+                "\n",
+                "$$\n",
+                "\\overline{F}_\\text{CRB}=p+2^{-n}(1-p).\n",
+                "$$\n",
+                "\n",
+                "CRB is not generally intended to work for $n>2$, both because of the scaling of the size of the $n$-qubit Clifford group in $n$, and because such gates have to eventually be transpiled to a native basis of 1Q and 2Q gates!\n",
+                "\n",
+                "It is important to mention that the average Clifford fidelity is related to the average fidelity of IQM's native gate set for single-qubit gates as ([Barends, 2014](https://arxiv.org/abs/1402.4848))\n",
+                "\n",
+                "$$\n",
+                "\\overline{F}_\\text{GATE} \\approx 1 - \\frac{1-\\overline{F}_\\text{CRB}}{1.875}.\n",
+                "$$\n",
+                "\n",
+                "This is because all the single-qubit Clifford gates can be decomposed using on average 1.875 gates from IQM's native set. This formula shows that the value of $\\overline{F}_\\text{GATE}$ will always be slightly higher than $\\overline{F}_\\text{CRB}$, so one must be careful when comparing with average fidelities reported in the specs of a QPU. "
+            ]
+        },
+        {
+            "cell_type": "code",
+            "execution_count": 18,
+            "id": "55abfb988cfefe67",
+            "metadata": {},
+            "outputs": [],
+            "source": [
+                "from iqm.benchmarks.randomized_benchmarking.clifford_rb.clifford_rb import CliffordRBConfiguration,CliffordRandomizedBenchmarking"
+            ]
+        },
+        {
+            "cell_type": "code",
+            "execution_count": 19,
+            "id": "c34f4b647d6c41b9",
+            "metadata": {},
+            "outputs": [],
+            "source": [
+                "CRB = CliffordRBConfiguration(\n",
+                "    qubits_array=[[0],[1],[2],[3],[4]],\n",
+                "    sequence_lengths=[2**(m+1)-1 for m in range(9)],\n",
+                "    num_circuit_samples=25,\n",
+                "    shots=2**8,\n",
+                "    calset_id=None,\n",
+                "    parallel_execution=False,\n",
+                ")"
+            ]
+        },
+        {
+            "cell_type": "markdown",
+            "id": "87a37049",
+            "metadata": {},
+            "source": [
+                "> If you want to modify the settings above, please refer to the documentation [here](https://iqm-finland.github.io/iqm-benchmarks/api/iqm.benchmarks.randomized_benchmarking.clifford_rb.clifford_rb.CliffordRBConfiguration.html#iqm.benchmarks.randomized_benchmarking.clifford_rb.clifford_rb.CliffordRBConfiguration)."
+            ]
+        },
+        {
+            "cell_type": "markdown",
+            "id": "d9594fe8",
+            "metadata": {},
+            "source": [
+                "Warning: The following code cell may take few minutes to run since it will compute the average fidelities for all the qubits in the QPU (and we set `parallel_execution=False`)."
+            ]
+        },
+        {
+            "cell_type": "code",
+            "execution_count": null,
+            "id": "5bb7f891ebb5acfb",
+            "metadata": {},
+            "outputs": [],
+            "source": [
+                "benchmark_clifford_rb = CliffordRandomizedBenchmarking(backend, CRB)\n",
+                "run_clifford_rb = benchmark_clifford_rb.run()"
+            ]
+        },
+        {
+            "cell_type": "code",
+            "execution_count": null,
+            "id": "14735341479e13cd",
+            "metadata": {},
+            "outputs": [],
+            "source": [
+                "result_clifford_rb = benchmark_clifford_rb.analyze()\n",
+                "for plot in result_clifford_rb.plots.values():\n",
+                "    display(plot)"
+            ]
+        },
+        {
+            "cell_type": "markdown",
+            "id": "3628adb59f63bfca",
+            "metadata": {},
+            "source": [
+                "## Interleaved Randomized Benchmarking (IRB)"
+            ]
+        },
+        {
+            "cell_type": "markdown",
+            "id": "5154992b",
+            "metadata": {},
+            "source": [
+                "Differently from the previous protocol, this benchmark aims at estimating the average fidelity of an **individual** quantum gate. This can be achieved interleaving random Clifford gates between the gate of interest. This method was introduced in [Magesan, 2012](https://journals.aps.org/prl/abstract/10.1103/PhysRevLett.109.080505), and just as CRB, it is robust with respect to SPAM errors. \n",
+                "\n",
+                "The protocol runs two sets of sequences, one solely made up of random Clifford gates, as in CRB, and one made up of random Clifford sequences but interleaving the gate of interest among these (and compiling the corresponding sequence inverse). IRB then extracts the corresponding decay parameters (where we expect the decay rate for IRB to be smaller than the CRB one, because the sequence is longer), and the average fidelity of the gate we wish to characterize is then calculated with a simple formula using the two decay parameters. \n"
+            ]
+        },
+        {
+            "cell_type": "code",
+            "execution_count": 22,
+            "id": "efa911273850ece0",
+            "metadata": {},
+            "outputs": [],
+            "source": [
+                "from iqm.benchmarks.randomized_benchmarking.interleaved_rb.interleaved_rb import InterleavedRBConfiguration, InterleavedRandomizedBenchmarking"
+            ]
+        },
+        {
+            "cell_type": "code",
+            "execution_count": 23,
+            "id": "41dbb8fa3ed3190",
+            "metadata": {},
+            "outputs": [],
+            "source": [
+                "IRB_CZ = InterleavedRBConfiguration(\n",
+                "    qubits_array=[[0,2],[1,2],[2,3],[2,4]],\n",
+                "    sequence_lengths=[2**(m+1)-1 for m in range(7)],\n",
+                "    num_circuit_samples=25,\n",
+                "    shots=2**8,\n",
+                "    calset_id=None,\n",
+                "    parallel_execution=False,\n",
+                "    interleaved_gate = \"CZGate\",\n",
+                "    interleaved_gate_params = None,\n",
+                "    simultaneous_fit = [\"amplitude\", \"offset\"],\n",
+                ")"
+            ]
+        },
+        {
+            "cell_type": "markdown",
+            "id": "9995ba2a",
+            "metadata": {},
+            "source": [
+                "> If you want to modify the settings above, please refer to the documentation [here](https://iqm-finland.github.io/iqm-benchmarks/api/iqm.benchmarks.randomized_benchmarking.interleaved_rb.interleaved_rb.InterleavedRBConfiguration.html#iqm.benchmarks.randomized_benchmarking.interleaved_rb.interleaved_rb.InterleavedRBConfiguration)."
+            ]
+        },
+        {
+            "cell_type": "markdown",
+            "id": "a905bbf2",
+            "metadata": {},
+            "source": [
+                "NB: Clifford RB is executed by default when running Interleaved RB!"
+            ]
+        },
+        {
+            "cell_type": "markdown",
+            "id": "4e8b9bd5",
+            "metadata": {},
+            "source": [
+                "Warning: The following code cells may take **several** minutes to run."
+            ]
+        },
+        {
+            "cell_type": "code",
+            "execution_count": null,
+            "id": "c9da15580b9948c8",
+            "metadata": {},
+            "outputs": [],
+            "source": [
+                "benchmark_irb_CZ = InterleavedRandomizedBenchmarking(backend, IRB_CZ)\n",
+                "run_irb_CZ = benchmark_irb_CZ.run()"
+            ]
+        },
+        {
+            "cell_type": "code",
+            "execution_count": null,
+            "id": "c53f2f4ec7629351",
+            "metadata": {},
+            "outputs": [],
+            "source": [
+                "result_irb_CZ = benchmark_irb_CZ.analyze()\n",
+                "for plot in result_irb_CZ.plots.values():\n",
+                "    display(plot)"
+            ]
+        },
+        {
+            "cell_type": "markdown",
+            "id": "4ee1e163",
+            "metadata": {},
+            "source": [
+                "## Q-Score"
+            ]
+        },
+        {
+            "cell_type": "markdown",
+            "id": "e62cba69",
+            "metadata": {},
+            "source": [
+                "*The Q-score measures the maximum number of qubits that can be used\n",
+                "effectively to solve the MaxCut combinatorial optimization problem with the Quantum Approximate\n",
+                "Optimization Algorithm* - [Martiel,2021](https://ieeexplore.ieee.org/document/9459509)\n",
+                "\n",
+                "The graphs chosen for the benchmark are random Erdős-Rényi graphs with 50% edge-probability between nodes.\n",
+                "The obtained cost of the solution, i.e. the average number of cut edges, must be above a certain threshold. Specifically, one has to find the cost of a graph to be above $\\beta\\geq 0.2$ on a scale where $\\beta = 0$ corresponds to a random solution and $\\beta = 1$ to an ideal solution. "
+            ]
+        },
+        {
+            "cell_type": "code",
+            "execution_count": null,
+            "id": "036d7839",
+            "metadata": {},
+            "outputs": [],
+            "source": [
+                "from iqm.benchmarks.optimization.qscore import QScoreConfiguration, QScoreBenchmark"
+            ]
+        },
+        {
+            "cell_type": "code",
+            "execution_count": null,
+            "id": "22b8116c",
+            "metadata": {},
+            "outputs": [],
+            "source": [
+                "QSCORE = QScoreConfiguration(\n",
+                "    num_instances = 100,\n",
+                "    num_qaoa_layers= 1,\n",
+                "    shots = 2**8,\n",
+                "    calset_id=None, \n",
+                "    min_num_nodes = 2,\n",
+                "    max_num_nodes = 5,\n",
+                "    use_virtual_node = True,\n",
+                "    use_classically_optimized_angles = True,\n",
+                "    choose_qubits_routine = \"custom\",\n",
+                "    custom_qubits_array=[[2],\n",
+                "                    [2, 0],\n",
+                "                    [2, 0, 1],\n",
+                "                    [2, 0, 1, 3],\n",
+                "                    [2, 0, 1, 3, 4]],\n",
+                "    seed = 1\n",
+                "    )"
+            ]
+        },
+        {
+            "cell_type": "markdown",
+            "id": "58813ef0",
+            "metadata": {},
+            "source": [
+                "> If you want to modify the settings above, please refer to the documentation [here](https://iqm-finland.github.io/iqm-benchmarks/api/iqm.benchmarks.optimization.qscore.QScoreConfiguration.html#iqm.benchmarks.optimization.qscore.QScoreConfiguration)."
+            ]
+        },
+        {
+            "cell_type": "markdown",
+            "id": "c5f14175",
+            "metadata": {},
+            "source": [
+                "Warning: The following code cell may take **several** minutes to run."
+            ]
+        },
+        {
+            "cell_type": "code",
+            "execution_count": null,
+            "id": "aed5ee90",
+            "metadata": {},
+            "outputs": [],
+            "source": [
+                "benchmark_qscore = QScoreBenchmark(backend, QSCORE)\n",
+                "run_qscore = benchmark_qscore.run()"
+            ]
+        },
+        {
+            "cell_type": "code",
+            "execution_count": null,
+            "id": "0bec0284",
+            "metadata": {},
+            "outputs": [],
+            "source": [
+                "result_qscore = benchmark_qscore.analyze()"
+            ]
+        },
+        {
+            "cell_type": "code",
+            "execution_count": null,
+            "id": "619342db",
+            "metadata": {},
+            "outputs": [],
+            "source": [
+                "result_qscore.plot_all()"
+            ]
+        },
+        {
+            "cell_type": "markdown",
+            "id": "70bdb002",
+            "metadata": {},
+            "source": [
+                "## Summary"
+            ]
+        },
+        {
+            "cell_type": "markdown",
+            "id": "c144b300",
+            "metadata": {},
+            "source": [
+                "Typical performance for IQM Spark is summarized in the table below and compared to the values obtained with your device. The typical single- and two-qubit gate fidelities reported below refer to the median over the 5 qubits and 4 couplings of the system, respectively."
+            ]
+        },
+        {
+            "cell_type": "code",
+            "execution_count": null,
+            "id": "d805a3d9",
+            "metadata": {},
+            "outputs": [],
+            "source": [
+                "import numpy as np\n",
+                "\n",
+                "### GHZ\n",
+                "obs_ghz = result_ghz.observations\n",
+                "fidelity = round(min([obs_ghz[i].value for i in range(len(obs_ghz)) if obs_ghz[i].name=='fidelity']),2)\n",
+                "\n",
+                "### QV\n",
+                "obs_qv = result_qv.observations\n",
+                "qv = max([obs_qv[i].value for i in range(len(obs_qv)) if obs_qv[i].name=='QV_result'])\n",
+                "\n",
+                "### CLOPS\n",
+                "obs_clops = result_clops.observations\n",
+                "clops = max([obs_clops[item]['clops_v']['value'] for item in obs_clops])\n",
+                "\n",
+                "### CRB\n",
+                "obs_crb = result_clifford_rb.observations\n",
+                "f_crb = round(np.median([obs_crb[i].value for i in range(len(obs_crb))]),3)\n",
+                "\n",
+                "### IRB\n",
+                "obs_irb = result_irb_CZ.observations\n",
+                "f_irb = round(np.median([obs_irb[i].value for i in range(len(obs_irb)) if obs_irb[i].name=='avg_gate_fidelity_interleaved']),3)\n",
+                "\n",
+                "### QS \n",
+                "obs_qs = result_qscore.observations\n",
+                "qs = np.argmin([obs_qs[i].value-0.2 for i in range(len(obs_qs)) if obs_qs[i].name == 'approximation_ratio' and obs_qs[i].value-0.2>0])+2\n",
+                "\n",
+                "\n",
+                "summary = {'5-qubit GHZ state fidelity': ['≥ 0.5', fidelity],\n",
+                "    'Quantum Volume': ['≥ 8', qv], \n",
+                "    'CLOPS': ['3000', clops], \n",
+                "    'Single-qubit gate fidelity': ['≥ 0.999', f_crb],\n",
+                "    'Two-qubit gate (CZ) fidelity': ['≥ 0.98', f_irb], \n",
+                "    'Q-Score': ['≥ 5', qs] \n",
+                "}\n",
+                "\n",
+                "print(\"{:<30} {:<15} {:<15}\".format('Benchmark', 'Typical', 'Your device'))\n",
+                "for k, v in summary.items():\n",
+                "    label, num = v\n",
+                "    print(\"{:<30} {:<15} {:<15}\".format(k, label, num))"
+            ]
+        }
+    ],
+    "metadata": {
+        "kernelspec": {
+            "display_name": "iqm-benchmarks",
+            "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.11.2"
+        }
+    },
+    "nbformat": 4,
+    "nbformat_minor": 5
+}

{iqm_benchmarks-2.13 → iqm_benchmarks-2.14}/docs/index.rst

@@ -16,6 +16,7 @@ Contents
 
    readme
    examples/examples
+   devices/devices
    development/development
    API
    license

{iqm_benchmarks-2.13 → iqm_benchmarks-2.14/src/iqm_benchmarks.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: iqm-benchmarks
-Version: 2.13
+Version: 2.14
 Summary: A package for implementation of Quantum Characterization, Verification and Validation (QCVV) techniques on IQM's hardware at gate level abstraction
 Author-email: IQM Finland Oy <developers@meetiqm.com>, Aniket Rath <aniket.rath@meetiqm.com>, Jami Rönkkö <jami@meetiqm.com>, Pedro Figueroa Romero <pedro.romero@meetiqm.com>, Vicente Pina Canelles <vicente.pina@meetiqm.com>, Raphael Brieger <raphael.brieger@meetiqm.com>, Stefan Seegerer <stefan.seegerer@meetiqm.com>, Miikka Koistinen <miikka@meetiqm.com>, Adrian Auer <adrian.auer@meetiqm.com>
 Project-URL: Homepage, https://github.com/iqm-finland/iqm-benchmarks

{iqm_benchmarks-2.13 → iqm_benchmarks-2.14}/src/iqm_benchmarks.egg-info/SOURCES.txt

@@ -28,6 +28,8 @@ docs/_templates/autosummary-module-template.rst
 docs/development/development.rst
 docs/development/generate_2qubit_cliffords.ipynb
 docs/development/how_to_make_your_own_benchmark.ipynb
+docs/devices/devices.rst
+docs/devices/spark.ipynb
 docs/examples/example_clifford_rb.ipynb
 docs/examples/example_clops.ipynb
 docs/examples/example_experiment_all.ipynb