iqm-benchmarks 1.3__tar.gz → 1.4__tar.gz

{iqm_benchmarks-1.3 → iqm_benchmarks-1.4}/CHANGELOG.rst

@@ -2,6 +2,20 @@
 Changelog
 =========
 
+Version 1.4
+===========
+
+* Renames:
+  * AnalysisResult -> BenchmarkAnalysisResult
+  * RunResult -> BenchmarkRunResult
+* Adds BenchmarkObservation class, and modifies BenchmarkAnalysisResult so observations now accepts a list[BenchmarkObservation].
+* Adds BenchmarkObservationIdentifier class.
+* Rebases RandomizedBenchmarking benchmarks, QuantumVolume, GHZ and CLOPS to use the new Observation class.
+* Fixes serialization of some circuits.
+* Adds AVAILABLE_BENCHMARKS to map a benchmark name to its class in __init__.
+* Adds benchmarks and configurations to __init__ for public import.
+* Other fixes.
+
 Version 1.3
 ===========
 

{iqm_benchmarks-1.3 → iqm_benchmarks-1.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: iqm-benchmarks
-Version: 1.3
+Version: 1.4
 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>
 Project-URL: Homepage, https://github.com/iqm-finland/iqm-benchmarks
@@ -15,8 +15,8 @@ Requires-Dist: lmfit==1.3.1
 Requires-Dist: matplotlib==3.9.0
 Requires-Dist: more-itertools==10.1.0
 Requires-Dist: mthree==2.6.3
-Requires-Dist: networkx==2.8.8
-Requires-Dist: numpy>=1.24.2
+Requires-Dist: networkx==3.3
+Requires-Dist: numpy>=1.25.2
 Requires-Dist: qiskit==0.45.3
 Requires-Dist: qiskit-aer==0.13.3
 Requires-Dist: qiskit-iqm==15.1

{iqm_benchmarks-1.3 → iqm_benchmarks-1.4}/pyproject.toml

@@ -31,8 +31,8 @@ dependencies = [
     "matplotlib == 3.9.0",
     "more-itertools == 10.1.0",
     "mthree == 2.6.3",
-    "networkx==2.8.8",
-    "numpy >= 1.24.2",
+    "networkx==3.3",
+    "numpy >= 1.25.2",
     "qiskit == 0.45.3",
     "qiskit-aer == 0.13.3",
     "qiskit-iqm == 15.1",

iqm_benchmarks-1.4/src/iqm/benchmarks/__init__.py

@@ -0,0 +1,55 @@
+# Copyright 2024 IQM Benchmarks developers
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+"""
+IQM's Python Library Benchmarking Suite QCVV.
+"""
+
+from importlib.metadata import PackageNotFoundError, version
+
+from .benchmark_definition import (
+    Benchmark,
+    BenchmarkAnalysisResult,
+    BenchmarkObservation,
+    BenchmarkObservationIdentifier,
+    BenchmarkRunResult,
+)
+from .entanglement.ghz import GHZBenchmark, GHZConfiguration
+from .quantum_volume.clops import CLOPSBenchmark, CLOPSConfiguration
+from .quantum_volume.quantum_volume import QuantumVolumeBenchmark, QuantumVolumeConfiguration
+from .randomized_benchmarking.clifford_rb.clifford_rb import CliffordRandomizedBenchmarking, CliffordRBConfiguration
+from .randomized_benchmarking.interleaved_rb.interleaved_rb import (
+    InterleavedRandomizedBenchmarking,
+    InterleavedRBConfiguration,
+)
+from .randomized_benchmarking.mirror_rb.mirror_rb import MirrorRandomizedBenchmarking, MirrorRBConfiguration
+
+
+AVAILABLE_BENCHMARKS = {
+    GHZBenchmark.name: GHZBenchmark,
+    CLOPSBenchmark.name: CLOPSBenchmark,
+    QuantumVolumeBenchmark.name: QuantumVolumeBenchmark,
+    CliffordRandomizedBenchmarking.name: CliffordRandomizedBenchmarking,
+    InterleavedRandomizedBenchmarking.name: InterleavedRandomizedBenchmarking,
+    MirrorRandomizedBenchmarking.name: MirrorRandomizedBenchmarking,
+}
+
+try:
+    # Change here if project is renamed and does not equal the package name
+    dist_name = "iqm-benchmarks"
+    __version__ = version(dist_name)
+except PackageNotFoundError:  # pragma: no cover
+    __version__ = "unknown"
+finally:
+    del version, PackageNotFoundError

{iqm_benchmarks-1.3 → iqm_benchmarks-1.4}/src/iqm/benchmarks/benchmark_definition.py

@@ -21,7 +21,7 @@ import copy
 from copy import deepcopy
 from dataclasses import dataclass, field
 import functools
-from typing import Any, Dict, List, Union
+from typing import Any, Dict, List, Optional, Union
 import uuid
 
 from matplotlib.figure import Figure
@@ -35,7 +35,44 @@ from iqm.qiskit_iqm.iqm_provider import IQMBackend, IQMFacadeBackend
 
 
 @dataclass
-class RunResult:
+class BenchmarkObservationIdentifier:
+    """Identifier for observations for ease of use
+
+    Attributes:
+        qubit_indices: list containing the indices of the qubits the observation was executed on.
+    """
+
+    qubit_indices: list[int]
+
+    @property
+    def string_identifier(self) -> str:
+        """String version of the qubit indices for ease of use
+
+        Returns:
+            A string of the qubit indices
+        """
+        return str(self.qubit_indices)
+
+
+@dataclass
+class BenchmarkObservation:
+    """Dataclass to store the main results of a single run of a Benchmark
+
+    Attributes:
+        name: name of the observation
+        value: value of the observation
+        identifier: identifier, which should be a string of the qubit layout
+        uncertainty: uncertainty of the observation
+    """
+
+    name: str
+    value: Any
+    identifier: BenchmarkObservationIdentifier
+    uncertainty: Optional[Any] = None
+
+
+@dataclass
+class BenchmarkRunResult:
     """
     A dataclass that stores the results of a single run of a Benchmark.
 
@@ -47,7 +84,7 @@ class RunResult:
 
 
 @dataclass
-class AnalysisResult:
+class BenchmarkAnalysisResult:
     """
     A dataclass storing the results of the analysis.
 
@@ -58,7 +95,7 @@ class AnalysisResult:
 
     dataset: xr.Dataset
     plots: dict[str, Figure] = field(default_factory=lambda: ({}))
-    observations: dict[str, Any] = field(default_factory=lambda: ({}))
+    observations: list[BenchmarkObservation] = field(default_factory=lambda: [])
 
     def plot(self, plot_name: str):
         """
@@ -78,7 +115,7 @@ class AnalysisResult:
             plt.show()
 
     @classmethod
-    def from_run_result(cls, run: RunResult):
+    def from_run_result(cls, run: BenchmarkRunResult):
         """
         Creates a new ``AnalysisResult`` from a ``RunResult``.
 
@@ -88,7 +125,7 @@ class AnalysisResult:
         return cls(dataset=run.dataset)
 
 
-def default_analysis_function(result: AnalysisResult) -> AnalysisResult:
+def default_analysis_function(result: BenchmarkAnalysisResult) -> BenchmarkAnalysisResult:
     """
     The default analysis that only pass the result through.
     """
@@ -201,7 +238,7 @@ class Benchmark(ABC):
         # From exa_support MR
         self.options = copy.copy(self.default_options) if self.default_options else {}
         self.options.update(kwargs)
-        self.runs: list[RunResult] = []
+        self.runs: list[BenchmarkRunResult] = []
 
     @classmethod
     @abstractmethod
@@ -224,7 +261,7 @@ class Benchmark(ABC):
             the benchmark results.
         """
 
-    def run(self, calibration_set_id: str | uuid.UUID | None = None) -> RunResult:
+    def run(self, calibration_set_id: str | uuid.UUID | None = None) -> BenchmarkRunResult:
         """
         Runs the benchmark using the given backend and calibration_set_id.
 
@@ -236,13 +273,15 @@ class Benchmark(ABC):
             RunResult: The result of the benchmark run.
         """
         backend_for_execute = copy.copy(self.backend)
-        backend_for_execute.run = functools.partial(self.backend.run, calibration_set_id=calibration_set_id)  # type: ignore
+        backend_for_execute.run = functools.partial(
+            self.backend.run, calibration_set_id=calibration_set_id
+        )  # type: ignore
         dataset = self.execute(backend_for_execute)
-        run = RunResult(dataset)
+        run = BenchmarkRunResult(dataset)
         self.runs.append(run)
         return run
 
-    def analyze(self, run_index=-1) -> AnalysisResult:
+    def analyze(self, run_index=-1) -> BenchmarkAnalysisResult:
         """
         The default analysis for the benchmark.
 
@@ -259,6 +298,6 @@ class Benchmark(ABC):
             the ``analysis_function`` field.
         """
         run = self.runs[run_index]
-        result = AnalysisResult.from_run_result(run)
+        result = BenchmarkAnalysisResult.from_run_result(run)
         updated_result = self.analysis_function(result)
         return updated_result

{iqm_benchmarks-1.3 → iqm_benchmarks-1.4}/src/iqm/benchmarks/entanglement/ghz.py

@@ -31,9 +31,15 @@ from qiskit_aer import Aer
 from scipy.spatial.distance import hamming
 import xarray as xr
 
-from iqm.benchmarks import Benchmark
 from iqm.benchmarks.benchmark import BenchmarkConfigurationBase
-from iqm.benchmarks.benchmark_definition import AnalysisResult, RunResult, add_counts_to_dataset
+from iqm.benchmarks.benchmark_definition import (
+    Benchmark,
+    BenchmarkAnalysisResult,
+    BenchmarkObservation,
+    BenchmarkObservationIdentifier,
+    BenchmarkRunResult,
+    add_counts_to_dataset,
+)
 from iqm.benchmarks.logging_config import qcvv_logger
 from iqm.benchmarks.readout_mitigation import apply_readout_error_mitigation
 from iqm.benchmarks.utils import (
@@ -231,7 +237,7 @@ def fidelity_ghz_coherences(dataset: xr.Dataset, qubit_layout: List[int]) -> Lis
     return [fidelity]
 
 
-def fidelity_analysis(run: RunResult) -> AnalysisResult:
+def fidelity_analysis(run: BenchmarkRunResult) -> BenchmarkAnalysisResult:
     """Analyze counts and compute the state fidelity
 
     Args:
@@ -242,12 +248,12 @@ def fidelity_analysis(run: RunResult) -> AnalysisResult:
         AnalysisResult
             An object containing the dataset, plots, and observations
     """
-    observations = {}
     dataset = run.dataset
     routine = dataset.attrs["fidelity_routine"]
     qubit_layouts = dataset.attrs["custom_qubits_array"]
     backend_name = dataset.attrs["backend_name"]
 
+    observation_list: list[BenchmarkObservation] = []
     for qubit_layout in qubit_layouts:
         if routine == "randomized_measurements":
             ideal_simulator = Aer.get_backend("statevector_simulator")
@@ -261,16 +267,33 @@ def fidelity_analysis(run: RunResult) -> AnalysisResult:
                     ideal_probabilities.append(
                         dict(sorted(ideal_simulator.run(deflated_qc).result().get_counts().items()))
                     )
-                result_dict = fidelity_ghz_randomized_measurements(
-                    dataset, qubit_layout, ideal_probabilities, len(qubit_layout)
+                observation_list.extend(
+                    [
+                        BenchmarkObservation(
+                            name=key, identifier=BenchmarkObservationIdentifier(qubit_layout), value=value
+                        )
+                        for key, value in fidelity_ghz_randomized_measurements(
+                            dataset, qubit_layout, ideal_probabilities, len(qubit_layout)
+                        ).items()
+                    ]
                 )
         else:  # default routine == "coherences":
             fidelity = fidelity_ghz_coherences(dataset, qubit_layout)
-            result_dict = {"fidelity": fidelity[0]}
+            observation_list.extend(
+                [
+                    BenchmarkObservation(
+                        name="fidelity", identifier=BenchmarkObservationIdentifier(qubit_layout), value=fidelity[0]
+                    )
+                ]
+            )
             if len(fidelity) > 1:
-                result_dict.update({"fidelity_rem": fidelity[1]})
-        observations[str(qubit_layout)] = result_dict
-    return AnalysisResult(dataset=dataset, observations=observations)
+
+                observation_list.append(
+                    BenchmarkObservation(
+                        name="fidelity_rem", identifier=BenchmarkObservationIdentifier(qubit_layout), value=fidelity[1]
+                    )
+                )
+    return BenchmarkAnalysisResult(dataset=dataset, observations=observation_list)
 
 
 def generate_ghz_linear(num_qubits: int) -> QuantumCircuit:
@@ -506,6 +529,7 @@ class GHZBenchmark(Benchmark):
     """The GHZ Benchmark estimates the quality of generated Greenberger-Horne-Zeilinger states"""
 
     analysis_function = staticmethod(fidelity_analysis)
+    name = "ghz"
 
     def __init__(self, backend: IQMBackendBase, configuration: "GHZConfiguration"):
         """Construct the GHZBenchmark class.
@@ -541,9 +565,9 @@ class GHZBenchmark(Benchmark):
 
         self.timestamp = strftime("%Y%m%d-%H%M%S")
 
-    @staticmethod
-    def name() -> str:
-        return "ghz"
+    # @staticmethod
+    # def name() -> str:
+    #     return "ghz"
 
     def generate_native_ghz(self, qubit_layout: List[int], qubit_count: int, routine: str) -> QuantumCircuit:
         """
@@ -704,7 +728,7 @@ class GHZBenchmark(Benchmark):
 
         for key, value in self.configuration:
             if key == "benchmark":  # Avoid saving the class object
-                dataset.attrs[key] = value.name()
+                dataset.attrs[key] = value.name
             else:
                 dataset.attrs[key] = value
         dataset.attrs[f"backend_name"] = self.backend.name

{iqm_benchmarks-1.3 → iqm_benchmarks-1.4}/src/iqm/benchmarks/quantum_volume/clops.py

@@ -31,7 +31,7 @@ import xarray as xr
 
 from iqm.benchmarks import Benchmark
 from iqm.benchmarks.benchmark import BenchmarkConfigurationBase
-from iqm.benchmarks.benchmark_definition import AnalysisResult, RunResult
+from iqm.benchmarks.benchmark_definition import BenchmarkAnalysisResult, BenchmarkRunResult
 from iqm.benchmarks.logging_config import qcvv_logger
 from iqm.benchmarks.utils import (
     count_2q_layers,
@@ -222,7 +222,7 @@ def retrieve_clops_elapsed_times(job_meta: Dict[str, Dict[str, Any]]) -> Dict[st
     return overall_elapsed
 
 
-def clops_analysis(run: RunResult) -> AnalysisResult:
+def clops_analysis(run: BenchmarkRunResult) -> BenchmarkAnalysisResult:
     """Analysis function for a CLOPS (v or h) experiment
 
     Args:
@@ -252,7 +252,8 @@ def clops_analysis(run: RunResult) -> AnalysisResult:
 
     transpiled_qc_list = []
     for _, value in dataset.attrs["transpiled_circuits"].items():
-        transpiled_qc_list.extend(value)
+        for _, transpiled_circuit in value.items():
+            transpiled_qc_list.extend(transpiled_circuit)
 
     # CLOPS_V
     clops_v: float = num_circuits * num_updates * num_shots * depth / clops_time
@@ -310,7 +311,7 @@ def clops_analysis(run: RunResult) -> AnalysisResult:
     # Sort the final dataset
     dataset.attrs = dict(sorted(dataset.attrs.items()))
 
-    return AnalysisResult(dataset=dataset, plots=plots, observations=observations)
+    return BenchmarkAnalysisResult(dataset=dataset, plots=plots, observations=observations)
 
 
 class CLOPSBenchmark(Benchmark):
@@ -396,8 +397,15 @@ class CLOPSBenchmark(Benchmark):
 
         """
         qcvv_logger.info(f"Adding all circuits to the dataset")
-        dataset.attrs["untranspiled_circuits"] = self.untranspiled_circuits
-        dataset.attrs["transpiled_circuits"] = self.transpiled_circuits
+        for key, circuit in zip(
+            ["transpiled_circuits", "untranspiled_circuits"], [self.transpiled_circuits, self.untranspiled_circuits]
+        ):
+            dictionary = {}
+            for outer_key, outer_value in circuit.items():
+                dictionary[str(outer_key)] = {
+                    str(inner_key): inner_values for inner_key, inner_values in outer_value.items()
+                }
+            dataset.attrs[key] = dictionary
 
     def append_parameterized_unitary(
         self,
@@ -614,8 +622,11 @@ class CLOPSBenchmark(Benchmark):
             # Sort circuits according to their final measurement mappings
             (sorted_transpiled_qc_list, _), self.time_sort_batches = sort_batches_by_final_layout(transpiled_qc_list)
 
-        self.untranspiled_circuits.update({tuple(self.qubits): qc_list})
-        self.transpiled_circuits.update(sorted_transpiled_qc_list)
+        self.untranspiled_circuits.update({str(self.qubits): {str(self.qubits): qc_list}})
+        self.transpiled_circuits.update(
+            {str(self.qubits): {str(key): value for key, value in sorted_transpiled_qc_list.items()}}
+        )
+        # self.transpiled_circuits[str(self.qubits)].update(sorted_transpiled_qc_list)
 
         return sorted_transpiled_qc_list
 

{iqm_benchmarks-1.3 → iqm_benchmarks-1.4}/src/iqm/benchmarks/quantum_volume/quantum_volume.py

@@ -33,9 +33,15 @@ import xarray as xr
 # import iqm.diqe.executors.dynamical_decoupling.dd_high_level as dd
 # from iqm.diqe.executors.dynamical_decoupling.dynamical_decoupling_core import DDStrategy
 # from iqm.diqe.mapomatic import evaluate_costs, get_calibration_fidelities, get_circuit, matching_layouts
-from iqm.benchmarks import AnalysisResult, Benchmark, RunResult
 from iqm.benchmarks.benchmark import BenchmarkConfigurationBase
-from iqm.benchmarks.benchmark_definition import add_counts_to_dataset
+from iqm.benchmarks.benchmark_definition import (
+    Benchmark,
+    BenchmarkAnalysisResult,
+    BenchmarkObservation,
+    BenchmarkObservationIdentifier,
+    BenchmarkRunResult,
+    add_counts_to_dataset,
+)
 from iqm.benchmarks.logging_config import qcvv_logger
 from iqm.benchmarks.readout_mitigation import apply_readout_error_mitigation
 from iqm.benchmarks.utils import (  # execute_with_dd,
@@ -281,7 +287,7 @@ def plot_hop_threshold(
     return fig_name, fig
 
 
-def qv_analysis(run: RunResult) -> AnalysisResult:
+def qv_analysis(run: BenchmarkRunResult) -> BenchmarkAnalysisResult:
     """Analysis function for a Quantum Volume experiment
 
     Args:
@@ -291,8 +297,8 @@ def qv_analysis(run: RunResult) -> AnalysisResult:
     """
 
     plots = {}
-    observations = {}
-    dataset = run.dataset
+    observations: list[BenchmarkObservation] = []
+    dataset = run.dataset.copy(deep=True)
     backend_name = dataset.attrs["backend_name"]
     execution_timestamp = dataset.attrs["execution_timestamp"]
     num_circuits = dataset.attrs["num_circuits"]
@@ -333,17 +339,24 @@ def qv_analysis(run: RunResult) -> AnalysisResult:
         # Compute the HO probabilities
         qv_result = compute_heavy_output_probabilities(execution_results[str(qubits)], ideal_heavy_outputs[str(qubits)])
 
-        processed_results = {
-            "average_heavy_output_probability": {
-                "value": cumulative_hop(qv_result)[-1],
-                "uncertainty": cumulative_std(qv_result)[-1],
-            },
-            "is_successful": {"value": str(is_successful(qv_result, num_sigmas)), "uncertainty": np.NaN},
-            "QV_result": {
-                "value": 2 ** len(qubits) if is_successful(qv_result, num_sigmas) else 1,
-                "uncertainty": np.NaN,
-            },
-        }
+        observations = [
+            BenchmarkObservation(
+                name="average_heavy_output_probability",
+                value=cumulative_hop(qv_result)[-1],
+                uncertainty=cumulative_std(qv_result)[-1],
+                identifier=BenchmarkObservationIdentifier(qubits),
+            ),
+            BenchmarkObservation(
+                name="is_succesful",
+                value=is_successful(qv_result, num_sigmas),
+                identifier=BenchmarkObservationIdentifier(qubits),
+            ),
+            BenchmarkObservation(
+                name="QV_result",
+                value=2 ** len(qubits) if is_successful(qv_result) else 1,
+                identifier=BenchmarkObservationIdentifier(qubits),
+            ),
+        ]
 
         dataset.attrs[qubits_idx].update(
             {
@@ -354,9 +367,6 @@ def qv_analysis(run: RunResult) -> AnalysisResult:
             }
         )
 
-        # UPDATE OBSERVATIONS
-        observations.update({qubits_idx: processed_results})
-
         fig_name, fig = plot_hop_threshold(
             qubits,
             depth[str(qubits)],
@@ -370,7 +380,7 @@ def qv_analysis(run: RunResult) -> AnalysisResult:
         plots[fig_name] = fig
 
     if not rem:
-        return AnalysisResult(dataset=dataset, plots=plots, observations=observations)
+        return BenchmarkAnalysisResult(dataset=dataset, plots=plots, observations=observations)
 
     # When REM is set to True, do the post-processing with the adjusted quasi-probabilities
     mit_shots = dataset.attrs["mit_shots"]
@@ -388,18 +398,6 @@ def qv_analysis(run: RunResult) -> AnalysisResult:
             ideal_heavy_outputs[str(qubits)],
         )
 
-        rem_results = {
-            "REM_average_heavy_output_probability": {
-                "value": cumulative_hop(qv_result_rem)[-1],
-                "uncertainty": cumulative_std(qv_result_rem)[-1],
-            },
-            "REM_is_successful": {"value": str(is_successful(qv_result_rem)), "uncertainty": np.NaN},
-            "REM_QV_result": {
-                "value": 2 ** len(qubits) if is_successful(qv_result_rem, num_sigmas) else 1,
-                "uncertainty": np.NaN,
-            },
-        }
-
         dataset.attrs[qubits_idx].update(
             {
                 "sorted_qc_list_indices": (sorted_qc_list_indices if physical_layout == "batching" else None),
@@ -410,7 +408,26 @@ def qv_analysis(run: RunResult) -> AnalysisResult:
         )
 
         # UPDATE OBSERVATIONS
-        observations.update({qubits_idx: rem_results})
+        observations.extend(
+            [
+                BenchmarkObservation(
+                    name="REM_average_heavy_output_probability",
+                    value=cumulative_hop(qv_result_rem)[-1],
+                    uncertainty=cumulative_std(qv_result_rem)[-1],
+                    identifier=BenchmarkObservationIdentifier(qubits),
+                ),
+                BenchmarkObservation(
+                    name="REM_is_succesful",
+                    value=is_successful(qv_result_rem, num_sigmas),
+                    identifier=BenchmarkObservationIdentifier(qubits),
+                ),
+                BenchmarkObservation(
+                    name="REM_QV_result",
+                    value=2 ** len(qubits) if is_successful(qv_result_rem) else 1,
+                    identifier=BenchmarkObservationIdentifier(qubits),
+                ),
+            ]
+        )
 
         fig_name_rem, fig_rem = plot_hop_threshold(
             qubits,
@@ -424,7 +441,7 @@ def qv_analysis(run: RunResult) -> AnalysisResult:
         )
         plots[fig_name_rem] = fig_rem
 
-    return AnalysisResult(dataset=dataset, plots=plots, observations=observations)
+    return BenchmarkAnalysisResult(dataset=dataset, plots=plots, observations=observations)
 
 
 class QuantumVolumeBenchmark(Benchmark):
@@ -509,8 +526,15 @@ class QuantumVolumeBenchmark(Benchmark):
 
         """
         qcvv_logger.info(f"Adding all circuits to the dataset")
-        dataset.attrs["untranspiled_circuits"] = self.untranspiled_circuits
-        dataset.attrs["transpiled_circuits"] = self.transpiled_circuits
+        for key, circuit in zip(
+            ["transpiled_circuits", "untranspiled_circuits"], [self.transpiled_circuits, self.untranspiled_circuits]
+        ):
+            dictionary = {}
+            for outer_key, outer_value in circuit.items():
+                dictionary[str(outer_key)] = {
+                    str(inner_key): inner_values for inner_key, inner_values in outer_value.items()
+                }
+            dataset.attrs[key] = dictionary
 
     # def get_mapomatic_average_qv_scores(self) -> List[List[int]]:
     #     """Estimate the average mapomatic scores for N quantum volume circuit samples
@@ -786,7 +810,9 @@ class QuantumVolumeBenchmark(Benchmark):
                         "time_submit": job_dict["time_submit"],
                         "time_retrieve": time_retrieve,
                         "all_job_metadata": all_job_metadata,
-                        "sorted_qc_list_indices": sorted_qc_list_indices[str(qubits)],
+                        "sorted_qc_list_indices": {
+                            str(key): value for key, value in sorted_qc_list_indices[str(qubits)].items()
+                        },
                         "operation_counts": all_op_counts[str(qubits)],
                     }
                 }

{iqm_benchmarks-1.3 → iqm_benchmarks-1.4}/src/iqm/benchmarks/randomized_benchmarking/clifford_rb/clifford_rb.py

@@ -23,9 +23,15 @@ import numpy as np
 from qiskit import QuantumCircuit
 import xarray as xr
 
-from iqm.benchmarks import AnalysisResult, Benchmark, RunResult
 from iqm.benchmarks.benchmark import BenchmarkConfigurationBase
-from iqm.benchmarks.benchmark_definition import add_counts_to_dataset
+from iqm.benchmarks.benchmark_definition import (
+    Benchmark,
+    BenchmarkAnalysisResult,
+    BenchmarkObservation,
+    BenchmarkObservationIdentifier,
+    BenchmarkRunResult,
+    add_counts_to_dataset,
+)
 from iqm.benchmarks.logging_config import qcvv_logger
 from iqm.benchmarks.randomized_benchmarking.randomized_benchmarking_common import (
     exponential_rb,
@@ -45,7 +51,7 @@ from iqm.benchmarks.utils import retrieve_all_counts, retrieve_all_job_metadata,
 from iqm.qiskit_iqm.iqm_backend import IQMBackendBase
 
 
-def clifford_rb_analysis(run: RunResult) -> AnalysisResult:
+def clifford_rb_analysis(run: BenchmarkRunResult) -> BenchmarkAnalysisResult:
     """Analysis function for a Clifford RB experiment
 
     Args:
@@ -53,8 +59,9 @@ def clifford_rb_analysis(run: RunResult) -> AnalysisResult:
     Returns:
         AnalysisResult corresponding to Clifford RB
     """
-    dataset = run.dataset
-    observations = {}
+    dataset = run.dataset.copy(deep=True)
+    observations: list[BenchmarkObservation] = []
+    obs_dict = {}
     plots = {}
 
     is_parallel_execution = dataset.attrs["parallel_execution"]
@@ -139,13 +146,24 @@ def clifford_rb_analysis(run: RunResult) -> AnalysisResult:
             }
         )
 
-        observations.update({qubits_idx: processed_results})
+        obs_dict.update({qubits_idx: processed_results})
+        observations.extend(
+            [
+                BenchmarkObservation(
+                    name=key,
+                    identifier=BenchmarkObservationIdentifier(qubits),
+                    value=values["value"],
+                    uncertainty=values["uncertainty"],
+                )
+                for key, values in processed_results.items()
+            ]
+        )
 
         # Generate individual decay plots
-        fig_name, fig = plot_rb_decay("clifford", [qubits], dataset, observations)
+        fig_name, fig = plot_rb_decay("clifford", [qubits], dataset, obs_dict)
         plots[fig_name] = fig
 
-    return AnalysisResult(dataset=dataset, observations=observations, plots=plots)
+    return BenchmarkAnalysisResult(dataset=dataset, observations=observations, plots=plots)
 
 
 class CliffordRandomizedBenchmarking(Benchmark):
@@ -176,7 +194,7 @@ class CliffordRandomizedBenchmarking(Benchmark):
         self.session_timestamp = strftime("%Y%m%d-%H%M%S")
         self.execution_timestamp = ""
 
-    def add_all_meta_to_dataset(self, dataset: xr.Dataset):
+    def add_all_metadata_to_dataset(self, dataset: xr.Dataset):
         """Adds all configuration metadata and circuits to the dataset variable
         Args:
             dataset (xr.Dataset): The xarray dataset
@@ -215,7 +233,7 @@ class CliffordRandomizedBenchmarking(Benchmark):
         validate_rb_qubits(self.qubits_array, backend)
 
         dataset = xr.Dataset()
-        self.add_all_meta_to_dataset(dataset)
+        self.add_all_metadata_to_dataset(dataset)
 
         clifford_1q_dict, clifford_2q_dict = import_native_gate_cliffords()
 

{iqm_benchmarks-1.3 → iqm_benchmarks-1.4}/src/iqm/benchmarks/randomized_benchmarking/interleaved_rb/interleaved_rb.py

@@ -24,9 +24,15 @@ import numpy as np
 from qiskit import QuantumCircuit
 import xarray as xr
 
-from iqm.benchmarks import AnalysisResult, Benchmark, RunResult
 from iqm.benchmarks.benchmark import BenchmarkConfigurationBase
-from iqm.benchmarks.benchmark_definition import add_counts_to_dataset
+from iqm.benchmarks.benchmark_definition import (
+    Benchmark,
+    BenchmarkAnalysisResult,
+    BenchmarkObservation,
+    BenchmarkObservationIdentifier,
+    BenchmarkRunResult,
+    add_counts_to_dataset,
+)
 from iqm.benchmarks.logging_config import qcvv_logger
 from iqm.benchmarks.randomized_benchmarking.randomized_benchmarking_common import (
     exponential_rb,
@@ -48,7 +54,7 @@ from iqm.qiskit_iqm.iqm_backend import IQMBackendBase
 
 
 # pylint: disable=too-many-statements, too-many-branches
-def interleaved_rb_analysis(run: RunResult) -> AnalysisResult:
+def interleaved_rb_analysis(run: BenchmarkRunResult) -> BenchmarkAnalysisResult:
     """Analysis function for an Interleaved RB experiment
 
     Args:
@@ -56,8 +62,9 @@ def interleaved_rb_analysis(run: RunResult) -> AnalysisResult:
     Returns:
         AnalysisResult corresponding to Interleaved RB
     """
-    dataset = run.dataset
-    observations: Dict[int, Any] = {}
+    dataset = run.dataset.copy(deep=True)
+    obs_dict: Dict[int, Any] = {}
+    observations: list[BenchmarkObservation] = []
     plots: Dict[str, Figure] = {}
 
     is_parallel_execution = dataset.attrs["parallel_execution"]
@@ -165,6 +172,18 @@ def interleaved_rb_analysis(run: RunResult) -> AnalysisResult:
                 "fit_offset": {"value": popt["offset"].value, "uncertainty": popt["offset"].stderr},
             }
 
+            observations.extend(
+                [
+                    BenchmarkObservation(
+                        name=f"{key}_{rb_type}",
+                        identifier=BenchmarkObservationIdentifier(qubits),
+                        value=values["value"],
+                        uncertainty=values["uncertainty"],
+                    )
+                    for key, values in processed_results[rb_type].items()
+                ]
+            )
+
             dataset.attrs[qubits_idx].update(
                 {
                     rb_type: {
@@ -183,7 +202,7 @@ def interleaved_rb_analysis(run: RunResult) -> AnalysisResult:
                 }
             )
 
-        observations.update({qubits_idx: processed_results})
+        obs_dict.update({qubits_idx: processed_results})
 
         # Generate decay plots
         if interleaved_gate_parameters is None:
@@ -196,19 +215,19 @@ def interleaved_rb_analysis(run: RunResult) -> AnalysisResult:
             "irb",
             [qubits],
             dataset,
-            observations,
+            obs_dict,
             interleaved_gate=interleaved_gate_string,
         )
         plots[fig_name] = fig
 
     # Rearrange observations
-    observations_refactored: Dict[int, Dict[str, Dict[str, float]]] = {}
-    for k, o in observations.items():
-        observations_refactored[k] = {}
-        for rb_type in o.keys():
-            observations_refactored[k].update({f"{k}_{rb_type}": v for k, v in o[rb_type].items()})
+    # observations_refactored: Dict[int, Dict[str, Dict[str, float]]] = {}
+    # for k, o in obs_dict.items():
+    #     observations_refactored[k] = {}
+    #     for rb_type in o.keys():
+    #         observations_refactored[k].update({f"{k}_{rb_type}": v for k, v in o[rb_type].items()})
 
-    return AnalysisResult(dataset=dataset, observations=observations_refactored, plots=plots)
+    return BenchmarkAnalysisResult(dataset=dataset, observations=observations, plots=plots)
 
 
 class InterleavedRandomizedBenchmarking(Benchmark):
@@ -216,14 +235,14 @@ class InterleavedRandomizedBenchmarking(Benchmark):
 
     analysis_function = staticmethod(interleaved_rb_analysis)
 
-    name: str = "clifford_rb"
+    name: str = "interleaved_clifford_rb"
 
     def __init__(self, backend_arg: IQMBackendBase | str, configuration: "InterleavedRBConfiguration"):
         """Construct the InterleavedRandomizedBenchmark class
 
         Args:
             backend_arg (IQMBackendBase | str): the backend to execute Clifford RB on
-            configuration (CliffordRBConfiguration): The Clifford RB configuration
+            configuration (InterleavedRBConfiguration): The Clifford RB configuration
         """
         super().__init__(backend_arg, configuration)
 

{iqm_benchmarks-1.3 → iqm_benchmarks-1.4}/src/iqm/benchmarks/randomized_benchmarking/mirror_rb/mirror_rb.py

@@ -15,9 +15,9 @@ from qiskit_aer import Aer
 from scipy.spatial.distance import hamming
 import xarray as xr
 
-from iqm.benchmarks import AnalysisResult, Benchmark, RunResult
+from iqm.benchmarks import BenchmarkAnalysisResult, BenchmarkRunResult
 from iqm.benchmarks.benchmark import BenchmarkConfigurationBase
-from iqm.benchmarks.benchmark_definition import add_counts_to_dataset
+from iqm.benchmarks.benchmark_definition import Benchmark, add_counts_to_dataset
 from iqm.benchmarks.logging_config import qcvv_logger
 from iqm.benchmarks.randomized_benchmarking.randomized_benchmarking_common import (
     exponential_rb,
@@ -404,7 +404,7 @@ def list_to_numcircuit_times_numpauli_matrix(
 
 
 # pylint: disable=too-many-statements
-def mrb_analysis(run: RunResult) -> AnalysisResult:
+def mrb_analysis(run: BenchmarkRunResult) -> BenchmarkAnalysisResult:
     """Analysis function for a MRB experiment
 
     Args:
@@ -414,7 +414,7 @@ def mrb_analysis(run: RunResult) -> AnalysisResult:
     """
     plots = {}
     observations = {}
-    dataset = run.dataset
+    dataset = run.dataset.copy(deep=True)
 
     shots = dataset.attrs["shots"]
     num_circuit_samples = dataset.attrs["num_circuit_samples"]
@@ -468,7 +468,7 @@ def mrb_analysis(run: RunResult) -> AnalysisResult:
             # Execute the quantum circuits on the simulated, ideal backend
             # pylint: disable=unbalanced-tuple-unpacking
             all_noiseless_jobs, _ = submit_execute(
-                {tuple(qubits): transpiled_circuits[str(qubits)][depth]},
+                {tuple(qubits): transpiled_circuits[str(qubits)][str(depth)]},
                 simulator,
                 shots,
                 calset_id=None,
@@ -554,7 +554,7 @@ def mrb_analysis(run: RunResult) -> AnalysisResult:
     )
     plots[fig_name] = fig
 
-    return AnalysisResult(dataset=dataset, plots=plots, observations=observations)
+    return BenchmarkAnalysisResult(dataset=dataset, plots=plots, observations=observations)
 
 
 class MirrorRandomizedBenchmarking(Benchmark):
@@ -564,7 +564,7 @@ class MirrorRandomizedBenchmarking(Benchmark):
 
     analysis_function = staticmethod(mrb_analysis)
 
-    name: str = "mrb"
+    name: str = "mirror_rb"
 
     def __init__(self, backend_arg: IQMBackendBase | str, configuration: "MirrorRBConfiguration"):
         """Construct the MirrorRandomizedBenchmarking class
@@ -617,8 +617,15 @@ class MirrorRandomizedBenchmarking(Benchmark):
             dataset (xr.Dataset):  The xarray dataset
         """
         qcvv_logger.info(f"Adding all circuits to the dataset")
-        dataset.attrs["untranspiled_circuits"] = self.untranspiled_circuits
-        dataset.attrs["transpiled_circuits"] = self.transpiled_circuits
+        for key, circuit in zip(
+            ["transpiled_circuits", "untranspiled_circuits"], [self.transpiled_circuits, self.untranspiled_circuits]
+        ):
+            dictionary = {}
+            for outer_key, outer_value in circuit.items():
+                dictionary[str(outer_key)] = {
+                    str(inner_key): inner_values for inner_key, inner_values in outer_value.items()
+                }
+            dataset.attrs[key] = dictionary
 
     def submit_single_mrb_job(
         self,
@@ -733,10 +740,10 @@ class MirrorRandomizedBenchmarking(Benchmark):
                 qcvv_logger.info(f"Job for layout {qubits} & depth {depth} submitted successfully!")
 
             self.untranspiled_circuits[str(qubits)] = {
-                d: mrb_untranspiled_circuits_lists[d] for d in assigned_mrb_depths[str(qubits)]
+                str(d): mrb_untranspiled_circuits_lists[d] for d in assigned_mrb_depths[str(qubits)]
             }
             self.transpiled_circuits[str(qubits)] = {
-                d: mrb_transpiled_circuits_lists[d] for d in assigned_mrb_depths[str(qubits)]
+                str(d): mrb_transpiled_circuits_lists[d] for d in assigned_mrb_depths[str(qubits)]
             }
 
             dataset.attrs[qubits_idx] = {"qubits": qubits}

{iqm_benchmarks-1.3 → iqm_benchmarks-1.4}/src/iqm_benchmarks.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: iqm-benchmarks
-Version: 1.3
+Version: 1.4
 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>
 Project-URL: Homepage, https://github.com/iqm-finland/iqm-benchmarks
@@ -15,8 +15,8 @@ Requires-Dist: lmfit==1.3.1
 Requires-Dist: matplotlib==3.9.0
 Requires-Dist: more-itertools==10.1.0
 Requires-Dist: mthree==2.6.3
-Requires-Dist: networkx==2.8.8
-Requires-Dist: numpy>=1.24.2
+Requires-Dist: networkx==3.3
+Requires-Dist: numpy>=1.25.2
 Requires-Dist: qiskit==0.45.3
 Requires-Dist: qiskit-aer==0.13.3
 Requires-Dist: qiskit-iqm==15.1

{iqm_benchmarks-1.3 → iqm_benchmarks-1.4}/src/iqm_benchmarks.egg-info/SOURCES.txt

@@ -63,8 +63,8 @@ src/mGST/optimization.py
 src/mGST/qiskit_interface.py
 src/mGST/reporting/figure_gen.py
 src/mGST/reporting/reporting.py
-tests/ghz_test.py
-tests/gst_test.py
-tests/qscore_test.py
-tests/qv_test.py
-tests/rb_test.py
+tests/test_ghz.py
+tests/test_gst.py
+tests/test_qscore.py
+tests/test_qv.py
+tests/test_rb.py

{iqm_benchmarks-1.3 → iqm_benchmarks-1.4}/src/iqm_benchmarks.egg-info/requires.txt

@@ -2,8 +2,8 @@ lmfit==1.3.1
 matplotlib==3.9.0
 more-itertools==10.1.0
 mthree==2.6.3
-networkx==2.8.8
-numpy>=1.24.2
+networkx==3.3
+numpy>=1.25.2
 qiskit==0.45.3
 qiskit-aer==0.13.3
 qiskit-iqm==15.1

iqm_benchmarks-1.3/src/iqm/benchmarks/__init__.py

@@ -1,31 +0,0 @@
-# Copyright 2024 IQM Benchmarks developers
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-"""
-IQM's Python Library Benchmarking Suite QCVV.
-"""
-
-from importlib.metadata import PackageNotFoundError, version
-
-from .benchmark_definition import AnalysisResult, Benchmark, RunResult
-
-
-try:
-    # Change here if project is renamed and does not equal the package name
-    dist_name = "iqm-benchmarks"
-    __version__ = version(dist_name)
-except PackageNotFoundError:  # pragma: no cover
-    __version__ = "unknown"
-finally:
-    del version, PackageNotFoundError