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

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

@@ -2,6 +2,26 @@
 Changelog
 =========
 
+Version 1.5
+===========
+* fit results are no longer `BenchmarkObservation`, and instead are moved into the datasets.
+
+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.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: iqm-benchmarks
-Version: 1.3
+Version: 1.5
 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,14 +15,14 @@ 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
 Requires-Dist: scikit-optimize==0.10.2
 Requires-Dist: tabulate==0.9.0
-Requires-Dist: uncertainties==3.2.1
+Requires-Dist: uncertainties==3.2.2
 Requires-Dist: pycurl==7.45.3
 Requires-Dist: xarray==2024.6.0
 Requires-Dist: types-pycurl

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

@@ -31,14 +31,14 @@ 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",
     "scikit-optimize == 0.10.2",
     "tabulate == 0.9.0",
-    "uncertainties == 3.2.1",
+    "uncertainties == 3.2.2",
     "pycurl == 7.45.3",
     "xarray == 2024.6.0",
     "types-pycurl",

iqm_benchmarks-1.5/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.5}/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.5}/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.5}/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.5}/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)],
                     }
                 }