iqm-benchmarks 1.11__py3-none-any.whl → 2.0__py3-none-any.whl

iqm/benchmarks/__init__.py

@@ -25,6 +25,7 @@ from .benchmark_definition import (
     BenchmarkObservationIdentifier,
     BenchmarkRunResult,
 )
+from .circuit_containers import BenchmarkCircuit, CircuitGroup, Circuits
 from .entanglement.ghz import GHZBenchmark, GHZConfiguration
 from .quantum_volume.clops import CLOPSBenchmark, CLOPSConfiguration
 from .quantum_volume.quantum_volume import QuantumVolumeBenchmark, QuantumVolumeConfiguration

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, Optional, Union
+from typing import Any, Callable, Dict, List, Optional, Union
 import uuid
 
 from matplotlib.figure import Figure
@@ -29,6 +29,7 @@ import matplotlib.pyplot as plt
 import xarray as xr
 
 from iqm.benchmarks.benchmark import BenchmarkConfigurationBase
+from iqm.benchmarks.circuit_containers import BenchmarkCircuit, Circuits
 from iqm.benchmarks.utils import get_iqm_backend, timeit
 from iqm.qiskit_iqm.iqm_backend import IQMBackendBase
 from iqm.qiskit_iqm.iqm_provider import IQMBackend, IQMFacadeBackend
@@ -81,6 +82,7 @@ class BenchmarkRunResult:
     """
 
     dataset: xr.Dataset
+    circuits: Circuits
 
 
 @dataclass
@@ -94,6 +96,7 @@ class BenchmarkAnalysisResult:
     """
 
     dataset: xr.Dataset
+    circuits: Optional[Circuits] = field(default=None)
     plots: dict[str, Figure] = field(default_factory=lambda: ({}))
     observations: list[BenchmarkObservation] = field(default_factory=lambda: [])
 
@@ -122,14 +125,14 @@ class BenchmarkAnalysisResult:
         Args:
             run: A run for which analysis result is created.
         """
-        return cls(dataset=run.dataset)
+        return cls(dataset=run.dataset, circuits=Circuits)
 
 
-def default_analysis_function(result: BenchmarkAnalysisResult) -> BenchmarkAnalysisResult:
+def default_analysis_function(result: BenchmarkRunResult) -> BenchmarkAnalysisResult:
     """
     The default analysis that only pass the result through.
     """
-    return result
+    return BenchmarkAnalysisResult.from_run_result(result)
 
 
 def merge_datasets_dac(datasets: List[xr.Dataset]) -> xr.Dataset:
@@ -208,18 +211,19 @@ class Benchmark(ABC):
     accept ``AnalysisResult`` as its input and return the final result.
     """
 
-    analysis_function = staticmethod(default_analysis_function)
+    analysis_function: Callable[[BenchmarkRunResult], BenchmarkAnalysisResult] = staticmethod(default_analysis_function)
     default_options: dict[str, Any] | None = None
     options: dict[str, Any] | None = None
-    # name: str = "unnamed_benchmark"
 
-    def __init__(self, backend: Union[str, IQMBackendBase], configuration: "BenchmarkConfigurationBase", **kwargs):
+    def __init__(self, backend: Union[str, IQMBackendBase], configuration: BenchmarkConfigurationBase, **kwargs):
 
         # Ported from BenchmarkBase   # CHECK
         self.configuration = configuration
         self.serializable_configuration = deepcopy(self.configuration)
         self.serializable_configuration.benchmark = self.name
 
+        self.circuits = Circuits()
+
         if isinstance(backend, str):
             self.backend = get_iqm_backend(backend)
         else:
@@ -233,8 +237,8 @@ class Benchmark(ABC):
         self.routing_method = self.configuration.routing_method
         self.physical_layout = self.configuration.physical_layout
 
-        self.untranspiled_circuits: Dict[str, Dict[int, list]] = {}
-        self.transpiled_circuits: Dict[str, Dict[int, list]] = {}
+        self.transpiled_circuits: BenchmarkCircuit
+        self.untranspiled_circuits: BenchmarkCircuit
 
         # From exa_support MR
         self.options = copy.copy(self.default_options) if self.default_options else {}
@@ -278,7 +282,7 @@ class Benchmark(ABC):
             self.backend.run, calibration_set_id=calibration_set_id
         )  # type: ignore
         dataset = self.execute(backend_for_execute)
-        run = BenchmarkRunResult(dataset)
+        run = BenchmarkRunResult(dataset, self.circuits)
         self.runs.append(run)
         return run
 
@@ -299,6 +303,5 @@ class Benchmark(ABC):
             the ``analysis_function`` field.
         """
         run = self.runs[run_index]
-        result = BenchmarkAnalysisResult.from_run_result(run)
-        updated_result = self.analysis_function(result)
+        updated_result = self.analysis_function(run)
         return updated_result

iqm/benchmarks/benchmark_experiment.py

@@ -24,6 +24,7 @@ from time import strftime
 from typing import List, Optional, OrderedDict, Union
 
 from iqm.benchmarks.benchmark import BenchmarkBase, BenchmarkConfigurationBase
+from iqm.benchmarks.logging_config import qcvv_logger
 from iqm.benchmarks.utils import get_iqm_backend
 from iqm.qiskit_iqm.iqm_backend import IQMBackendBase
 
@@ -52,15 +53,14 @@ class BenchmarkExperiment:
         """
         self.timestamp = strftime("%Y%m%d-%H%M%S")
 
-        self.device_id = device_id if device_id is not None else backend
-
         if isinstance(backend, str):
             self.backend = get_iqm_backend(backend)
-
         else:
             assert isinstance(backend, IQMBackendBase)
             self.backend = backend
 
+        self.device_id = device_id if device_id is not None else self.backend.name
+
         benchmarks: OrderedDict[str, BenchmarkBase] = OrderedDict(
             (config.benchmark.name(), config.benchmark(self.backend, config)) for config in benchmark_configurations
         )
@@ -74,7 +74,7 @@ class BenchmarkExperiment:
         """Run the Benchmark experiment, and store the configuration, raw data, results and figures."""
 
         for name, benchmark in self.benchmarks.items():
-            print("\nNow executing " + name)
+            qcvv_logger.info("\nNow executing " + name)
             # Create the directory for results
             results_dir = f"Outputs/{self.device_id}/{self.timestamp}/{name}/"
             Path(results_dir).mkdir(parents=True, exist_ok=True)

iqm/benchmarks/circuit_containers.py

@@ -0,0 +1,221 @@
+# 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.
+
+"""
+This module contains classes to easily interact with quantum circuits
+"""
+
+from dataclasses import dataclass, field
+from typing import List, Optional, TypeAlias
+
+from qiskit.circuit import Qubit
+
+from iqm.qiskit_iqm.iqm_circuit import IQMCircuit
+
+
+QubitLayout: TypeAlias = tuple[Qubit, ...]
+QubitLayouts: TypeAlias = tuple[QubitLayout, ...]
+QubitLayoutIndices: TypeAlias = tuple[tuple[int, ...], ...]
+
+
+# pylint: disable=protected-access
+@dataclass
+class CircuitGroup:
+    """Group of `IQMCircuits`. It represents a list of circuits with a common purpose, typically executed in a batch.
+
+    Attributes:
+        circuits: List of `IQMCircuit`.
+        name: Name of the group.
+    """
+
+    circuits: List[IQMCircuit] = field(default_factory=list)
+    name: Optional[str] = field(default="")
+
+    @property
+    def qubit_layouts_by_index(self) -> QubitLayoutIndices:
+        """The qubit layouts contained in all the circuits, where the qubits are represented by an integer.
+
+        Returns:
+            All qubit layouts.
+        """
+        return tuple(tuple(int(qubit._index) for qubit in layout) for layout in self.qubit_layouts)
+
+    @property
+    def qubit_layouts(self) -> QubitLayouts:
+        """The qubit layouts contained in all the circuits, where the qubits are represented by an instance of `Qubit`.
+
+        Returns:
+            All qubit layouts.
+        """
+        qubit_layouts = tuple(map(lambda x: tuple(x._data.active_bits()[0]), self.circuits))
+        return qubit_layouts
+
+    @property
+    def qubits(self) -> set[Qubit]:
+        """The set of active qubits in all of the circuits
+
+        Returns:
+            A set of `Qubit`
+        """
+        qubit_set = set()
+        for circuit in self.circuits:
+            for qubit in circuit._data.active_bits()[0]:
+                qubit_set.add(qubit)
+        return qubit_set
+
+    def __setitem__(self, key: str, value: IQMCircuit) -> None:
+        value.name = key
+        return self.add_circuit(value)
+
+    def add_circuit(self, circuit: IQMCircuit):
+        """Adds a circuit to the internal list
+
+        Args:
+            circuit: Circuit to add.
+        """
+        self.circuits.append(circuit)
+
+    @property
+    def circuit_names(self) -> list[str]:
+        """Name of all the circuits contained in the group as a string
+
+        Returns:
+            List of strings
+        """
+        benchmark_circuit_names = list(map(lambda x: x.name, self.circuits))
+        return benchmark_circuit_names
+
+    def get_circuits_by_name(self, name: str) -> Optional[IQMCircuit]:
+        """Returns a list of the internal circuits that share the same name
+
+        Args:
+            name: Name of the circuit to return as a string
+
+        Returns:
+            The circuit with the desired name as a string, or None if they are not found.
+        """
+        benchmark_circuit_names = filter(lambda x: x.name == name, self.circuits)
+        return next(benchmark_circuit_names, None)
+
+    def __getitem__(self, key: str) -> Optional[IQMCircuit]:
+        return self.get_circuits_by_name(key)
+
+
+@dataclass
+class BenchmarkCircuit:
+    """A class grouping a list of `CircuitGroup` into a single purpose. This can typically represent, for example,
+    all of the transpiled circuits that are executed.
+
+    Attributes:
+        name: Name of the `BenchmarkCircuit`.
+        circuit_groups: List of `CircuitGroup` contained inside
+
+    """
+
+    name: str
+    circuit_groups: List[CircuitGroup] = field(default_factory=list)
+
+    def get_circuit_group_by_name(self, name: str) -> Optional[CircuitGroup]:
+        """Gets a `CircuitGroup` by name.
+
+        Args:
+            name: name of the group.
+
+        Returns:
+            The desired `CircuitGroup`, or None if it does not exist.
+
+        """
+        benchmark_circuit_names = filter(lambda x: x.name == name, self.circuit_groups)
+        next_value = next(benchmark_circuit_names, None)
+        return next_value
+
+    @property
+    def groups(self) -> List[CircuitGroup]:
+        """The circuit groups inside."""
+        return self.circuit_groups
+
+    @property
+    def group_names(self) -> List[str | None]:
+        """Names of all the contained `CircuitGroup`."""
+        return list(map(lambda x: x.name, self.circuit_groups)) if len(self.circuit_groups) > 0 else []
+
+    @property
+    def qubit_indices(self) -> set[int]:
+        """Set of all the qubits used in all the `CircuitGroup`, represented as an integer."""
+        qubit_set = set()
+        for circuit in self.circuit_groups:
+            for qubit_index in map(lambda x: x._index, circuit.qubits):
+                qubit_set.add(qubit_index)
+        return qubit_set
+
+    @property
+    def qubits(self) -> set[Qubit]:
+        """Set of all the qubits used in all the `CircuitGroup`, represented as an instance of `Qubit`."""
+        qubit_set: set[Qubit] = set()
+        for qubit in map(lambda x: x.qubits, self.circuit_groups):
+            qubit_set = qubit_set.union(qubit)
+        return qubit_set
+
+    @property
+    def qubit_layouts_by_index(self) -> set[QubitLayoutIndices]:
+        """Set of all the qubit layouts used, where the qubits are represented as an integer."""
+        layout_set = set()
+        for layout in map(lambda x: x.qubit_layouts_by_index, self.circuit_groups):
+            layout_set.add(layout)
+        return layout_set
+
+    @property
+    def qubit_layouts(self) -> set[QubitLayouts]:
+        """Set of all the qubit layouts used, where the qubits are represented as an instance of `Qubit`."""
+        layout_set = set()
+        for layout in map(lambda x: x.qubit_layouts, self.circuit_groups):
+            layout_set.add(layout)
+        return layout_set
+
+    def __setitem__(self, key: str, value: CircuitGroup) -> None:
+        value.name = key
+        return self.circuit_groups.append(value)
+
+    def __getitem__(self, key: str) -> CircuitGroup | None:
+        return self.get_circuit_group_by_name(key)
+
+
+@dataclass
+class Circuits:
+    """Container for all the `BenchmarkCircuit` that are generated in a single benchmark execution.
+
+    Attributes:
+        benchmark_circuits: List of `BenchmarkCircuit` contained.
+    """
+
+    benchmark_circuits: List[BenchmarkCircuit] = field(default_factory=list)
+
+    def __setitem__(self, key: str, value: BenchmarkCircuit) -> None:
+        value.name = key
+        return self.benchmark_circuits.append(value)
+
+    def __getitem__(self, key: str) -> BenchmarkCircuit | None:
+        return self.get_benchmark_circuits_by_name(key)
+
+    def get_benchmark_circuits_by_name(self, name: str) -> Optional[BenchmarkCircuit]:
+        """Returned the `BenchmarkCircuit` by name.
+
+        Args:
+            name: Name of the requested `BenchmarkCircuit` as a string
+
+        Returns:
+            The requested `BenchmarkCircuit` if it exists, None otherwise
+        """
+        benchmark_circuit_names = filter(lambda x: x.name == name, self.benchmark_circuits)
+        return next(benchmark_circuit_names, None)

iqm/benchmarks/compressive_gst/compressive_gst.py

@@ -30,12 +30,12 @@ The full benchmark executes the following steps:
 from typing import Any, Dict, List, Tuple, Type, Union
 
 import numpy as np
-from qiskit import QuantumCircuit
 from qiskit.circuit.library import CZGate, RGate
 import xarray as xr
 
 from iqm.benchmarks.benchmark import BenchmarkConfigurationBase
 from iqm.benchmarks.benchmark_definition import Benchmark, add_counts_to_dataset
+from iqm.benchmarks.circuit_containers import BenchmarkCircuit, CircuitGroup, Circuits
 from iqm.benchmarks.compressive_gst.gst_analysis import mgst_analysis
 from iqm.benchmarks.logging_config import qcvv_logger
 from iqm.benchmarks.utils import (
@@ -45,6 +45,7 @@ from iqm.benchmarks.utils import (
     submit_execute,
     timeit,
 )
+from iqm.qiskit_iqm import IQMCircuit as QuantumCircuit
 from iqm.qiskit_iqm.iqm_backend import IQMBackendBase
 from mGST import additional_fns, qiskit_interface
 from mGST.qiskit_interface import add_idle_gates, remove_idle_wires
@@ -156,8 +157,10 @@ class CompressiveGST(Benchmark):
                 drop_final_rz=False,
             )
             # Saving raw and transpiled circuits in a consistent format with other benchmarks
-            self.untranspiled_circuits.update({str(qubits): raw_qc_list})
-            self.transpiled_circuits.update({str(qubits): transpiled_qc_list})
+            self.transpiled_circuits.circuit_groups.append(CircuitGroup(name=str(qubits), circuits=raw_qc_list))
+            self.untranspiled_circuits.circuit_groups.append(
+                CircuitGroup(name=str(qubits), circuits=transpiled_qc_list)
+            )
 
     def add_configuration_to_dataset(self, dataset):  # CHECK
         """
@@ -186,13 +189,16 @@ class CompressiveGST(Benchmark):
         dataset = xr.Dataset()
         qcvv_logger.info(f"Now generating {self.configuration.num_circuits} random GST circuits...")
 
+        self.circuits = Circuits()
+        self.transpiled_circuits = BenchmarkCircuit(name="transpiled_circuits")
+        self.untranspiled_circuits = BenchmarkCircuit(name="untranspiled_circuits")
         # Generate circuits
         self.generate_meas_circuits()
 
         # Submit all
         all_jobs: Dict = {}
         for qubit_layout in self.qubit_layouts:
-            transpiled_circuit_dict = {tuple(qubit_layout): self.transpiled_circuits[str(qubit_layout)]}
+            transpiled_circuit_dict = {tuple(qubit_layout): self.transpiled_circuits[str(qubit_layout)].circuits}
             all_jobs[str(qubit_layout)], _ = submit_execute(
                 transpiled_circuit_dict,
                 backend,
@@ -207,6 +213,7 @@ class CompressiveGST(Benchmark):
             dataset, _ = add_counts_to_dataset(counts, str(qubit_layout), dataset)
 
         self.add_configuration_to_dataset(dataset)
+        self.circuits.benchmark_circuits = [self.transpiled_circuits, self.untranspiled_circuits]
         return dataset