iqm-benchmarks 2.42__py3-none-any.whl → 2.44__py3-none-any.whl

iqm/benchmarks/quantum_volume/clops.py

@@ -21,7 +21,6 @@ from math import floor, pi
 from time import perf_counter, strftime
 from typing import Any, Dict, List, Sequence, Tuple, Type
 
-import matplotlib as mpl
 from matplotlib.figure import Figure
 import matplotlib.pyplot as plt
 import numpy as np
@@ -178,8 +177,8 @@ def retrieve_clops_elapsed_times(job_meta: Dict[str, Dict[str, Any]]) -> Dict[st
                 # submit_i = datetime.strptime(x["submit_start"], job_time_format)
                 execution_f = datetime.strptime(x["execution_end"], job_time_format)
                 execution_i = datetime.strptime(x["execution_start"], job_time_format)
-                job_f = datetime.strptime(x["job_end"], job_time_format)
-                job_i = datetime.strptime(x["job_start"], job_time_format)
+                job_f = datetime.strptime(x["ready"], job_time_format)
+                job_i = datetime.strptime(x["received"], job_time_format)
 
                 all_job_elapsed[update][batch] = {
                     "job_total": job_f - job_i,

iqm/benchmarks/randomized_benchmarking/eplg/eplg.py

@@ -5,6 +5,7 @@ Error Per Layered Gate (EPLG).
 from time import strftime
 from typing import Dict, Optional, Sequence, Tuple, Type, cast
 
+from matplotlib.colors import to_rgba
 from matplotlib.figure import Figure
 import matplotlib.pyplot as plt
 import networkx as nx
@@ -76,38 +77,35 @@ def plot_layered_fidelities_graph(
     fig = plt.figure()
     ax = plt.axes()
 
-    if station is not None:
-        if station.lower() in GraphPositions.predefined_stations:
-            qubit_positions = GraphPositions.predefined_stations[station.lower()]
-        else:
-            if num_qubits in (20, 7):
-                station = "garnet" if num_qubits == 20 else "deneb"
-                qubit_positions = GraphPositions.predefined_stations[station]
-            else:
-                graph_backend = backend_coupling_map.graph.to_undirected(multigraph=False)
-                qubit_positions = GraphPositions.create_positions(graph_backend)
-    else:
-        graph_backend = backend_coupling_map.graph.to_undirected(multigraph=False)
-        if num_qubits in (20, 7):
-            station = "garnet" if num_qubits == 20 else "deneb"
-            qubit_positions = GraphPositions.predefined_stations[station]
-        else:
-            qubit_positions = GraphPositions.create_positions(graph_backend)
+    qubit_positions = GraphPositions.get_positions(
+        station=station, graph=backend_coupling_map.graph.to_undirected(multigraph=False), num_qubits=num_qubits
+    )
 
     # Normalize fidelity values to the range [0, 1] for color mapping
     norm = plt.Normalize(vmin=cast(float, min(fidelity_values)), vmax=cast(float, max(fidelity_values)))
-    edge_colors = [cmap(norm(fidelity_edges[edge])) for edge in qubit_pairs]
+    edge_colors = []
+    for edge in backend_coupling_map:
+        if edge in fidelity_edges:
+            edge_colors.append(cmap(norm(fidelity_edges[edge])))
+        elif (edge[1], edge[0]) in fidelity_edges:
+            edge_colors.append(cmap(norm(fidelity_edges[(edge[1], edge[0])])))
+        else:
+            edge_colors.append(to_rgba("lightgray"))
+
+    nodes = list(set(v for edge in backend_coupling_map for v in edge))
+    active_nodes = list(set(v for edge in qubit_pairs for v in edge))
+    node_colors = ["lightgray" if v not in active_nodes else "k" for v in nodes]
 
     nx.draw_networkx(
         rx_to_nx_graph(backend_coupling_map),
         pos=qubit_positions,
-        nodelist=list(range(num_qubits)),
-        labels={x: qubit_names[x] for x in range(num_qubits)},
+        nodelist=nodes,
+        edgelist=list(backend_coupling_map),
+        labels={x: qubit_names[x] for x in nodes},
         font_size=6.5,
-        edgelist=qubit_pairs,
         width=4.0,
         edge_color=edge_colors,
-        node_color="k",
+        node_color=node_colors,
         font_color="w",
         ax=ax,
     )
@@ -116,7 +114,7 @@ def plot_layered_fidelities_graph(
     sm = plt.cm.ScalarMappable(cmap=cmap, norm=norm)
     sm.set_array([])
     cbar = fig.colorbar(sm, ax=ax, shrink=0.5, label="Layered Fidelity (%)", format="%.2f")
-    cbar.set_ticks(np.linspace(min(fidelity_values), max(fidelity_values), 5, endpoint=True))
+    cbar.set_ticks(tuple(np.linspace(min(fidelity_values), max(fidelity_values), 5, endpoint=True)))
 
     station_string = "IQM Backend" if station is None else station.capitalize()
 
@@ -124,6 +122,7 @@ def plot_layered_fidelities_graph(
         f"EPLG estimate: {eplg_estimate['value']:.2e} +/- {eplg_estimate['uncertainty']:.2e}\n" if eplg_estimate else ""
     )
     plt.title(f"Layered fidelities for qubit pairs in {station_string}\n" f"{eplg_string}{timestamp}")
+    plt.gca().invert_yaxis()
     plt.close()
 
     return fig_name, fig
@@ -190,8 +189,8 @@ def eplg_analysis(run: BenchmarkRunResult) -> BenchmarkAnalysisResult:
         backend_num_qubits=backend_num_qubits,
         edge_list=edges,
         timestamp=timestamp,
-        disjoint_layers=disjoint_layers,
         station=backend_configuration_name,
+        disjoint_layers=disjoint_layers,
         qubit_names=qubit_names,
         is_eplg=True,
     )

iqm/benchmarks/utils.py

@@ -48,6 +48,9 @@ from iqm.qiskit_iqm.iqm_job import IQMJob
 from iqm.qiskit_iqm.iqm_provider import IQMProvider
 
 
+# pylint: disable=too-many-lines
+
+
 def timeit(f):
     """Calculates the amount of time a function takes to execute.
 
@@ -283,12 +286,18 @@ def get_active_qubits(qc: QuantumCircuit) -> List[int]:
     return list(active_qubits)
 
 
-def extract_fidelities(cal_url: str) -> tuple[list[list[int]], list[float], str]:
+def extract_fidelities(cal_url: str, all_metrics: bool = False) -> Union[
+    Tuple[List[List[int]], List[float], str, Dict[int, int]],
+    Tuple[List[List[int]], List[float], str, Dict[int, int], Dict[str, Dict[Union[int, Tuple[int, int]], float]]],
+]:
     """Returns couplings and CZ-fidelities from calibration data URL
 
     Args:
         cal_url: str
             The url under which the calibration data for the backend can be found
+        all_metrics: bool
+            If True, returns a dictionary with all metrics from the calibration data
+            Default is False
     Returns:
         list_couplings: List[List[int]]
             A list of pairs, each of which is a qubit coupling for which the calibration
@@ -297,6 +306,13 @@ def extract_fidelities(cal_url: str) -> tuple[list[list[int]], list[float], str]
             A list of CZ fidelities from the calibration url, ordered in the same way as list_couplings
         topology: str
             Name of the chip topology layout, currently either "star" or "crystal"
+        qubit_mapping: Dict[int, int]
+            Enumerating all calibrated qubits starting from 0. For instance if on a 5 qubit chip the qubits 2, 3 are calibrated,
+            the mapping will be {2: 0, 3: 1}.
+        metrics_dict: Dict
+            Dictionary of all metrics (returned only if all_metrics=True)
+            Format: {metric_name: {qubit: value}} for single qubit metrics
+            Format: {metric_name: {(qubit_1, qubit_2): value}} for two qubit metrics
     """
     headers = {"Accept": "application/json", "Authorization": "Bearer " + os.environ["IQM_TOKEN"]}
     r = requests.get(cal_url, headers=headers, timeout=60)
@@ -304,6 +320,7 @@ def extract_fidelities(cal_url: str) -> tuple[list[list[int]], list[float], str]
     cal_keys = {
         el2["key"]: (i, j) for i, el1 in enumerate(calibration["calibrations"]) for j, el2 in enumerate(el1["metrics"])
     }
+    resonator_names = ["COMPR", "COMP_R", "MPR1", "MPR_1"]
     list_couplings = []
     list_fids = []
     if "double_move_gate_fidelity" in cal_keys.keys():
@@ -313,18 +330,65 @@ def extract_fidelities(cal_url: str) -> tuple[list[list[int]], list[float], str]
         i, j = cal_keys["cz_gate_fidelity"]
         topology = "crystal"
     for item in calibration["calibrations"][i]["metrics"][j]["metrics"]:
-        qb1 = int(item["locus"][0][2:]) if item["locus"][0] != "COMP_R" else 0
-        qb2 = int(item["locus"][1][2:]) if item["locus"][1] != "COMP_R" else 0
-        if topology == "star":
-            list_couplings.append([qb1, qb2])
-        else:
-            list_couplings.append([qb1 - 1, qb2 - 1])
+        qb1 = (
+            int(item["locus"][0][2:])
+            if not any(resonator in item["locus"][0] for resonator in resonator_names)
+            else 0
+        )
+        qb2 = (
+            int(item["locus"][1][2:])
+            if not any(resonator in item["locus"][1] for resonator in resonator_names)
+            else 0
+        )
+        list_couplings.append([qb1, qb2])
         list_fids.append(float(item["value"]))
     calibrated_qubits = set(np.array(list_couplings).reshape(-1))
+
+    # Process all metrics if all_metrics is True
+    metrics_dict: Dict[str, Dict[Union[int, Tuple[int, int]], float]] = {}
+    for metric_key, (i, j) in cal_keys.items():
+        metric_data = calibration["calibrations"][i]["metrics"][j]["metrics"]
+        metrics_dict[metric_key] = {}
+
+        for item in metric_data:
+            # Determine if it's a single or two-qubit metric
+            if "component" in item:
+                # Single qubit metric
+                component = item["component"]
+                if not any(resonator in component for resonator in resonator_names):
+                    qb = int(component[2:])
+                    metrics_dict[metric_key][qb] = float(item["value"])
+                    calibrated_qubits.add(qb) # Add qubits that have a single qubit metric
+            if "locus" in item and len(item["locus"]) == 2:
+                # Two qubit metric
+                locus = item["locus"]
+                if not (any(resonator in locus[0] for resonator in resonator_names) or any(resonator in locus[1] for resonator in resonator_names)):
+                    qb1 = int(locus[0][2:])
+                    qb2 = int(locus[1][2:])
+                    metrics_dict[metric_key][(qb1, qb2)] = float(item["value"])
+
+    # Enumerate all calibrated qubits starting from 0
     qubit_mapping = {qubit: idx for idx, qubit in enumerate(calibrated_qubits)}
     list_couplings = [[qubit_mapping[edge[0]], qubit_mapping[edge[1]]] for edge in list_couplings]
 
-    return list_couplings, list_fids, topology
+    # Apply the qubit mapping to metrics_dict
+    remapped_metrics_dict = {}
+    for metric_key, metric_values in metrics_dict.items():
+        remapped_metrics_dict[metric_key] = {}
+        for key, value in metric_values.items():
+            if isinstance(key, tuple):
+                # Two-qubit metric
+                remapped_metrics_dict[metric_key][(qubit_mapping[key[0]], qubit_mapping[key[1]])] = value
+            else:
+                # Single-qubit metric
+                remapped_metrics_dict[metric_key][qubit_mapping[key]] = value
+    metrics_dict = remapped_metrics_dict
+
+    # If all_metrics is False, only return everything related to CZ fidelites
+    if not all_metrics:
+        return list_couplings, list_fids, topology, qubit_mapping
+
+    return list_couplings, list_fids, topology, qubit_mapping, metrics_dict
 
 
 # pylint: disable=too-many-branches