iqm-benchmarks 2.43__py3-none-any.whl → 2.45__py3-none-any.whl

iqm/benchmarks/entanglement/ghz.py

@@ -96,7 +96,7 @@ def fidelity_ghz_randomized_measurements(
         p_sum = []
         for sb in c_id_keys:
             for sa in c_keys:
-                exponent = hamming(list(sa), list(sb)) * num_qubits
+                exponent = hamming(np.array(list(sa)), np.array(list(sb))) * num_qubits
                 p_sum.append(np.power(-2, -exponent) * probabilities_sample[sa] * ideal_probabilities[u][sb])
         fid_rm.append((2**num_qubits) * sum(p_sum))
     values = {"fidelity": np.mean(fid_rm)}
@@ -117,7 +117,7 @@ def fidelity_ghz_randomized_measurements(
             p_sum = []
             for sb in c_id_keys:
                 for sa in c_keys:
-                    exponent = hamming(list(sa), list(sb)) * num_qubits
+                    exponent = hamming(np.array(list(sa)), np.array(list(sb))) * num_qubits
                     p_sum.append(np.power(-2, -exponent) * probabilities_sample[sa] * ideal_probabilities[u][sb])
             fid_rm_rem.append((2**num_qubits) * sum(p_sum))
         values = values | {"fidelity_rem": np.mean(fid_rm_rem)}
@@ -145,7 +145,6 @@ def fidelity_ghz_coherences(dataset: xr.Dataset, qubit_layout: List[int], circui
     phases = [np.pi * i / (num_qubits + 1) for i in range(2 * num_qubits + 2)]
     idx = BenchmarkObservationIdentifier(qubit_layout).string_identifier
     transpiled_circuits = circuits["transpiled_circuits"]
-    num_shots = dataset.attrs["shots"]
     num_circuits = len(transpiled_circuits[f"{qubit_layout}_native_ghz"].circuits)
 
     # Computing the phase acquired by the |11...1> component for each interval
@@ -155,8 +154,9 @@ def fidelity_ghz_coherences(dataset: xr.Dataset, qubit_layout: List[int], circui
     counts = xrvariable_to_counts(dataset, f"{idx}", num_circuits)
     all_zero_probability_list = []  # An ordered list for storing the probabilities of returning to the |00..0> state
     for count in counts[1:]:
+        normalization = np.sum(list(count.values()))
         if "0" * num_qubits in count.keys():
-            probability = count["0" * num_qubits] / num_shots
+            probability = count["0" * num_qubits] / normalization
         else:
             probability = 0
         all_zero_probability_list.append(probability)
@@ -165,7 +165,7 @@ def fidelity_ghz_coherences(dataset: xr.Dataset, qubit_layout: List[int], circui
     i_n = np.abs(np.dot(complex_coefficients, np.array(all_zero_probability_list))) / (len(phases))
 
     # Extracting the probabilities of the 00...0 and 11...1 bit strings
-    probs_direct = {label: count / num_shots for label, count in counts[0].items()}
+    probs_direct = {label: count / np.sum(list(counts[0].values())) for label, count in counts[0].items()}
 
     # Computing GHZ state fidelity from i_n and the probabilities according to the method in [Mooney, 2021]
     p0 = probs_direct["0" * num_qubits] if "0" * num_qubits in probs_direct.keys() else 0

iqm/benchmarks/entanglement/graph_states.py

@@ -439,34 +439,29 @@ def plot_max_negativities_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:
-            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 negativity values to the range [0, 1] for color mapping
     norm = plt.Normalize(vmin=cast(float, min(negativity_values)), vmax=cast(float, max(negativity_values)))
-    edge_colors = [cmap(norm(negativity_edges[edge])) for edge in qubit_pairs]
+    edge_colors = [
+        cmap(norm(negativity_edges[edge])) if edge in qubit_pairs else "lightgray" for edge in backend_coupling_map
+    ]  #
+    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,
     )
@@ -490,6 +485,8 @@ def plot_max_negativities_graph(
             f"{shots_string}; Bootstraps: {num_bootstraps}"
             f"\n{timestamp}"
         )
+    # Invert y-axis to match the intended qubit positions
+    plt.gca().invert_yaxis()
     plt.close()
 
     return fig_name, fig
@@ -955,7 +952,7 @@ def negativity_analysis(run: BenchmarkRunResult) -> BenchmarkAnalysisResult:
     dataset = run.dataset.copy(deep=True)
     qcvv_logger.info("Dataset imported OK")
     backend_name = dataset.attrs["backend_name"]
-    coupling_map = dataset.attrs["coupling_map"]
+    coupling_map_full = dataset.attrs["coupling_map_full"]
     qubit_names = dataset.attrs["qubit_names"]
     execution_timestamp = dataset.attrs["execution_timestamp"]
     tomography = dataset.attrs["tomography"]
@@ -1004,7 +1001,7 @@ def negativity_analysis(run: BenchmarkRunResult) -> BenchmarkAnalysisResult:
 
     fig_name, fig = plot_max_negativities_graph(
         negativities=max_negativities,
-        backend_coupling_map=coupling_map,
+        backend_coupling_map=coupling_map_full,
         qubit_names=qubit_names,
         timestamp=execution_timestamp,
         tomography=tomography,
@@ -1066,8 +1063,11 @@ class GraphStateBenchmark(Benchmark):
         dataset.attrs["execution_timestamp"] = self.execution_timestamp
         dataset.attrs["backend_configuration_name"] = self.backend_configuration_name
         dataset.attrs["backend_name"] = self.backend.name
-        dataset.attrs["qubit_names"] = {qubit: self.backend.index_to_qubit_name(qubit) for qubit in self.qubits}
+        dataset.attrs["qubit_names"] = {
+            qubit: self.backend.index_to_qubit_name(qubit) for qubit in np.arange(self.backend.num_qubits)
+        }
         dataset.attrs["coupling_map"] = self.coupling_map
+        dataset.attrs["coupling_map_full"] = self.backend.coupling_map
 
         for key, value in self.configuration:
             if key == "benchmark":  # Avoid saving the class object

iqm/benchmarks/optimization/qscore.py

@@ -83,9 +83,9 @@ def calculate_optimal_angles_for_QAOA_p1(graph: Graph) -> List[float]:
     x_init = [0.15, -0.28]
 
     minimizer_kwargs = {"method": "L-BFGS-B", "bounds": bounds}
-    res = basinhopping(get_expected_zz_edgedensity, x_init, minimizer_kwargs=minimizer_kwargs, niter=10, T=2)
+    res = basinhopping(get_expected_zz_edgedensity, x_init, minimizer_kwargs=minimizer_kwargs, niter=10, T=2)  # type: ignore
 
-    return res.x
+    return list(res.x)
 
 
 def cut_cost_function(x: str, graph: Graph) -> int:

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