iqm-benchmarks 2.44__py3-none-any.whl → 2.46__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)}

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:
@@ -436,12 +436,11 @@ def qscore_analysis(run: BenchmarkRunResult) -> BenchmarkAnalysisResult:
         instances_with_edges = set(range(num_instances)) - set(no_edge_instances)
         num_instances_with_edges = len(instances_with_edges)
         execution_results = xrvariable_to_counts(dataset, num_nodes, num_instances_with_edges)
-
         for inst_idx, instance in enumerate(list(instances_with_edges)):
             cut_sizes = run_QAOA(
                 execution_results[inst_idx],
                 graph_list[instance],
-                qubit_to_node_list[instance],
+                qubit_to_node_list[inst_idx],
                 use_classically_optimized_angles,
                 num_qaoa_layers,
                 virtual_node_list[instance],
@@ -790,6 +789,7 @@ class QScoreBenchmark(Benchmark):
             qubit_to_node_list = []
             no_edge_instances = []
             qc_all = []  # all circuits, including those with no edges
+            start_seed = seed
             for instance in range(self.num_instances):
                 qcvv_logger.debug(f"Executing graph {instance} with {num_nodes} nodes.")
                 graph = nx.generators.erdos_renyi_graph(num_nodes, 0.5, seed=seed)
@@ -848,6 +848,7 @@ class QScoreBenchmark(Benchmark):
                     qubit_to_node_list.append(qubit_to_node_copy)
                 else:
                     qc_all.append([])
+                    no_edge_instances.append(instance)
 
                 seed += 1
                 qcvv_logger.debug(f"Solved the MaxCut on graph {instance+1}/{self.num_instances}.")
@@ -902,7 +903,7 @@ class QScoreBenchmark(Benchmark):
                 {
                     num_nodes: {
                         "qubit_set": qubit_set_list,
-                        "seed_start": seed,
+                        "seed_start": start_seed,
                         "graph": graph_list,
                         "virtual_nodes": virtual_node_list,
                         "qubit_to_node": qubit_to_node_list,
@@ -914,7 +915,7 @@ class QScoreBenchmark(Benchmark):
 
             qcvv_logger.debug(f"Adding counts for the random graph for {num_nodes} nodes to the dataset")
             dataset, _ = add_counts_to_dataset(execution_results, str(num_nodes), dataset)
-            self.untranspiled_circuits.circuit_groups.append(CircuitGroup(name=str(num_nodes), circuits=qc_all))
+            self.untranspiled_circuits.circuit_groups.append(CircuitGroup(name=str(num_nodes), circuits=qc_list))
             self.transpiled_circuits.circuit_groups.append(
                 CircuitGroup(name=str(num_nodes), circuits=qc_transpiled_list)
             )

{iqm_benchmarks-2.44.dist-info → iqm_benchmarks-2.46.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: iqm-benchmarks
-Version: 2.44
+Version: 2.46
 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>, Adrian Auer <adrian.auer@meetiqm.com>, Raphael Brieger <raphael.brieger@meetiqm.com>, Alessio Calzona <alessio.calzona@meetiqm.com>, Pedro Figueroa Romero <pedro.romero@meetiqm.com>, Amin Hosseinkhani <amin.hosseinkhani@meetiqm.com>, Miikka Koistinen <miikka@meetiqm.com>, Nadia Milazzo <nadia.milazzo@meetiqm.com>, Vicente Pina Canelles <vicente.pina@meetiqm.com>, Aniket Rath <aniket.rath@meetiqm.com>, Jami Rönkkö <jami@meetiqm.com>, Stefan Seegerer <stefan.seegerer@meetiqm.com>
 Project-URL: Homepage, https://github.com/iqm-finland/iqm-benchmarks
@@ -63,7 +63,7 @@ Below is a list of the benchmarks currently available in the suite:
 * Gates / Layers:
   - Standard Clifford Randomized Benchmarking [[Phys. Rev. A 85, 042311](https://journals.aps.org/pra/abstract/10.1103/PhysRevA.85.042311) (2012)]
   - Interleaved Randomized Benchmarking [[Phys. Rev. Lett. 109, 080505](https://doi.org/10.1103/PhysRevLett.109.080505) (2012)]
-  - Compressive Gate Set Tomography [[PRX Quantum 4, 010325](https://journals.aps.org/prxquantum/abstract/10.1103/PRXQuantum.4.010325) (2023)]
+  - Compressive Gate Set Tomography [[PRX Quantum 4, 010325](https://journals.aps.org/prxquantum/abstract/10.1103/PRXQuantum.4.010325) (2023)] (Optional dependencies required)
   - Mirror Randomized Benchmarking [[Phys. Rev. Lett. 129, 150502](https://journals.aps.org/prl/abstract/10.1103/PhysRevLett.129.150502) (2022)]
   - Error Per Layered Gate [[arXiv:2311.05933 [quant-ph]](https://arxiv.org/abs/2311.05933) (2023)]
 * Holistic:

{iqm_benchmarks-2.44.dist-info → iqm_benchmarks-2.46.dist-info}/RECORD

@@ -1,6 +1,6 @@
 iqm/benchmarks/__init__.py,sha256=-drZ_whue067Tu4I9RxBCqrrzu38Tm5Kqf9jHTftUPk,3070
 iqm/benchmarks/benchmark.py,sha256=3E7g7RQjCIGIpSI1gOSrI3V9SAVs-XEOMrPgToK_7vw,4972
-iqm/benchmarks/benchmark_definition.py,sha256=e4xe0wlWKZqj48_6-zTglMaMeoiA9aGkHrrSgoCfPkM,11271
+iqm/benchmarks/benchmark_definition.py,sha256=7sq9_Y0iu1ZJOjG0gAVpm_BK3hbJBa6bdcRKhcVFOJw,11321
 iqm/benchmarks/circuit_containers.py,sha256=anEtZEsodYqOX-34oZRmuKGeEpp_VfgG5045Mz4-4hI,7562
 iqm/benchmarks/logging_config.py,sha256=U7olP5Kr75AcLJqNODf9VBhJLVqIvA4AYR6J39D5rww,1052
 iqm/benchmarks/readout_mitigation.py,sha256=Q2SOGWTNgmklOYkNxepAaSaXlxSj0QQyymYY1bOkT8A,11756
@@ -10,13 +10,13 @@ iqm/benchmarks/utils_shadows.py,sha256=e77PV_uaAO5m_woox9lAzompKAvFeDJ-0AKJrNJ7N
 iqm/benchmarks/coherence/__init__.py,sha256=yeyhk-_Lp8IbJ-f5lQj0HP5Q1HSKK_FzuXHazotUrVY,704
 iqm/benchmarks/coherence/coherence.py,sha256=zX_6A8vCS2zeWesMDXPFZBfrJ8wUG90JI9_tFsonwXk,21191
 iqm/benchmarks/compressive_gst/__init__.py,sha256=LneifgYXtcwo2jcXo7GdUEHL6_peipukShhkrdaTRCA,929
-iqm/benchmarks/compressive_gst/compressive_gst.py,sha256=2kiRttog4jR-vtMHu847GTFe5qL_i_uYr_4WMGqt9Ww,25653
-iqm/benchmarks/compressive_gst/gst_analysis.py,sha256=g0kEovWbetoDRvX7JFrS9oOoNrqBxaFmprujJi7qQbU,36297
+iqm/benchmarks/compressive_gst/compressive_gst.py,sha256=c33PUisGlmPUkt4Nx2Xqmduji5qFCrWT9jMcoThcs7U,27992
+iqm/benchmarks/compressive_gst/gst_analysis.py,sha256=H6EQGbpI_sig69Jy6hflg6alMTtjB0t9tHftygzA2YA,41240
 iqm/benchmarks/entanglement/__init__.py,sha256=sHVVToRWRCz0LSntk1rQaoSNNeyZLPoiTjUKWZWrk1E,778
-iqm/benchmarks/entanglement/ghz.py,sha256=nJ0gsLRfl50mcGrBVWjx22gXY9fwn9-sO3St2SbM4MA,41254
+iqm/benchmarks/entanglement/ghz.py,sha256=7QI7r9x5VEYQu5kqmdsLV9nq3eedYV_WRVqCQTbjapk,41294
 iqm/benchmarks/entanglement/graph_states.py,sha256=saoAw2QF8j7W4nZMOElnjuNylqDAbY9cBwBypWZKUz8,62521
 iqm/benchmarks/optimization/__init__.py,sha256=_ajW_OibYLCtzU5AUv5c2zuuVYn8ZNeZUcUUSIGt51M,747
-iqm/benchmarks/optimization/qscore.py,sha256=D2BVVNAqO32uGu5_kLVl2XJUOBlRl1C-c6zYenaCBMg,37259
+iqm/benchmarks/optimization/qscore.py,sha256=55NdsDsY9hwQLIZZdmf46BhU4C0hxjV5CCNYZnyoMAI,37372
 iqm/benchmarks/quantum_volume/__init__.py,sha256=i-Q4SpDWELBw7frXnxm1j4wJRcxbIyrS5uEK_v06YHo,951
 iqm/benchmarks/quantum_volume/clops.py,sha256=QS9iK-gtop0zix6IBeUumQeG01-0dXsv0jsYSDhgEu0,31071
 iqm/benchmarks/quantum_volume/quantum_volume.py,sha256=pro7Lz-A5pPpT9UZ8wtXKTyhdWmTjQjRHt4BylDR-3U,36553
@@ -35,18 +35,18 @@ iqm/benchmarks/randomized_benchmarking/interleaved_rb/__init__.py,sha256=sq6MgN_
 iqm/benchmarks/randomized_benchmarking/interleaved_rb/interleaved_rb.py,sha256=TaR1YFWBhOgm1hmEQzuwLYpp0yl0Xpuo3jAT6YhiXpc,28471
 iqm/benchmarks/randomized_benchmarking/mirror_rb/__init__.py,sha256=jRKbivWCZ3xdO1k0sx-ygC3s5DUkGSModd975PoAtcg,692
 iqm/benchmarks/randomized_benchmarking/mirror_rb/mirror_rb.py,sha256=n_5gt9636ZDMsM9hC3Zm5qP2bQr2sy41zxGhOh0XMjI,32932
-iqm_benchmarks-2.44.dist-info/licenses/LICENSE,sha256=2Ncb40-hqkTil78RPv3-YiJfKaJ8te9USJgliKqIdSY,11558
+iqm_benchmarks-2.46.dist-info/licenses/LICENSE,sha256=2Ncb40-hqkTil78RPv3-YiJfKaJ8te9USJgliKqIdSY,11558
 mGST/LICENSE,sha256=TtHNq55cUcbglb7uhVudeBLUh_qPdUoAEvU0BBwFz-k,1098
 mGST/README.md,sha256=v_5kw253csHF4-RfE-44KqFmBXIsSMRmOtN0AUPrRxE,5050
-mGST/additional_fns.py,sha256=_SEJ10FRNM7_CroysT8hCLZTfpm6ZhEIDCY5zPTnhjo,31390
-mGST/algorithm.py,sha256=mXcDG9_0j3hVjxLyc585dsj_yvydfrWNlCrcnUOQHPw,26625
+mGST/additional_fns.py,sha256=MV0Pm5ap59IjhT_E3QhsZyM7lXOF1RZ9SD11zoaf43A,31781
+mGST/algorithm.py,sha256=2xeIiPP1ae8IgBgrc7boTk-NyirUMJimcZTvKMbZqKY,27504
 mGST/compatibility.py,sha256=00DsPnNfOtrQcDTvxBDs-0aMhmuXmOIIxl_Ohy-Emkg,8920
-mGST/low_level_jit.py,sha256=uE1D3v01FbPpsbP92C4220OQalzOfxgL1Ku89BNkxLY,27377
-mGST/optimization.py,sha256=YHwkzIkYvsZOPjclR-BCQWh24jeqjuXp0BB0WX5Lwow,10559
-mGST/qiskit_interface.py,sha256=ajx6Zn5FnrX_T7tMP8xnBLyG4c2ddFRm0Fu2_3r1t30,10118
-mGST/reporting/figure_gen.py,sha256=6Xd8vwfy09hLY1YbJY6TRevuMsQSU4MsWqemly3ZO0I,12970
-mGST/reporting/reporting.py,sha256=B8NWfpZrrSmyH7lwZxd0EbZMYLsAGK1YsHRB4D5qXH4,26002
-iqm_benchmarks-2.44.dist-info/METADATA,sha256=g7tbfF4edqqPEnS50lTJ_0pdp9KzCKMs4RNUQeCxUcU,10872
-iqm_benchmarks-2.44.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-iqm_benchmarks-2.44.dist-info/top_level.txt,sha256=3G23Z-1LGf-IOzTCUl6QwWqiQ3USz25Zt90Ihq192to,9
-iqm_benchmarks-2.44.dist-info/RECORD,,
+mGST/low_level_jit.py,sha256=Ih1MxcwU0GnSRu0TI9GaYxpB94CMuJ8Is1eTeOwsfA8,30772
+mGST/optimization.py,sha256=x9tJ9wMQ5aONWpNpBMVtK0rwE6DRcOU33htNgrt0tx4,11015
+mGST/qiskit_interface.py,sha256=uCdn-Q9CXI2f4FQSxGUy8GmmzQhr9NhCOFb2VPj0gTs,10061
+mGST/reporting/figure_gen.py,sha256=xFPAHx1Trdqz7swn0kRqwc_jbRaNxhG9Nvx0jeitooo,25847
+mGST/reporting/reporting.py,sha256=Wss1-zFsMEhzrrXKfP-RICau80ezjDIzcN555KhSehc,34160
+iqm_benchmarks-2.46.dist-info/METADATA,sha256=si3yJgRHE9BhCYE9di9FKDsw_dIXUUm39MmvoggV_1c,10905
+iqm_benchmarks-2.46.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+iqm_benchmarks-2.46.dist-info/top_level.txt,sha256=3G23Z-1LGf-IOzTCUl6QwWqiQ3USz25Zt90Ihq192to,9
+iqm_benchmarks-2.46.dist-info/RECORD,,

mGST/additional_fns.py

@@ -2,8 +2,10 @@
 Utility functions used by mGST modules
 """
 
+import contextlib
 import os
 import random
+import sys
 import warnings
 
 import numpy as np
@@ -13,6 +15,18 @@ from scipy.linalg import expm, qr
 from mGST.low_level_jit import Mp_norm_lower, MVE_lower, contract, local_basis
 
 
+@contextlib.contextmanager
+def suppress_stdout():
+    """Context manager to temporarily suppress stdout output."""
+    with open(os.devnull, "w", encoding="utf-8") as devnull:
+        old_stdout = sys.stdout
+        sys.stdout = devnull
+        try:
+            yield
+        finally:
+            sys.stdout = old_stdout
+
+
 def transp(dim1, dim2):
     """Superoperator of a map that performs the transpose operation
 
@@ -261,6 +275,10 @@ def random_gs(d, r, rK, n_povm):
         The second axis enumerates Kraus operators for a gate specified by the first axis.
     X: 3D numpy array
         Array where random CPT superoperators are stacked along the first axis.
+    E: 2D numpy array
+        Randomly generated POVM elements stacked along the first axis.
+    rho: 1D numpy array
+        Random initial state vector
 
     Notes:
         The Kraus operators are generated from random unitaries, see function randKrausSet
@@ -327,7 +345,7 @@ def perturbed_target_init(X_target, rK):
     """
     d, r, _ = X_target.shape
     pdim = int(np.sqrt(r))
-    K_perturb = randKrausSet(d, r, rK, a=0.1)
+    K_perturb = randKrausSet(d, r, rK, a=0.05)
     X_perturb = np.einsum("ijkl,ijnm -> iknlm", K_perturb, K_perturb.conj()).reshape((d, r, r))
     X_init = np.einsum("ikl,ilm ->ikm", X_perturb, X_target)
     K_init = Kraus_rep(X_init, d, pdim, rK)
@@ -627,8 +645,7 @@ def sampled_measurements(y, n):
         y_new = np.maximum(np.minimum(y, 1), 0)
         if np.sum(np.abs(y_new - y)) > 1e-6:
             warnings.warn(
-                f"Warning: Probabilities capped to interval [0,1]",
-                f"l1-difference to input:%f" % np.sum(np.abs(y_new - y)),
+                f"Warning: Probabilities capped to interval [0,1], l1-difference to input: {np.sum(np.abs(y_new - y))}"
             )
         y = y_new
     rng = np.random.default_rng()
@@ -723,24 +740,22 @@ def is_positive(X, E, rho):
     eigvals = np.array([la.eigvals(X_choi[i]) for i in range(d)])
     partial_traces = np.einsum("aiikl -> akl", X.reshape(d, pdim, pdim, pdim, pdim))
     povm_eigvals = np.array([la.eigvals(E[i].reshape(pdim, pdim)) for i in range(n_povm)])
-    if np.any(np.imag(eigvals.reshape(-1) > 1e-10)):
-        print("Gates are not all hermitian.")
-    else:
-        for i in range(d):
-            print(f"Gate %i positive:" % i, np.all(eigvals[i, :] > -1e-10))
-            print(f"Gate %i trace preserving:" % i, la.norm(partial_traces[i] - np.eye(pdim)) < 1e-10)
-    print(f"Initial state positive:", np.all(la.eigvals(rho.reshape(pdim, pdim)) > -1e-10))
-    print(f"Initial state normalization:", np.trace(rho.reshape(pdim, pdim)))
-    print(
-        "fPOVM valid:",
-        np.all(
-            [
-                la.norm(np.sum(E, axis=0).reshape(pdim, pdim) - np.eye(pdim)) < 1e-10,
-                np.all(povm_eigvals.reshape(-1) > -1e-10),
-            ]
-        ),
-    )
 
+    # Check if gates are hermitian
+    assert np.all(np.imag(eigvals.reshape(-1)) < 1e-10)
+
+    # Check if gates are positive and trace preserving
+    for i in range(d):
+        assert np.all(eigvals[i, :] > -1e-10)
+        assert la.norm(partial_traces[i] - np.eye(pdim)) < 1e-10
+
+    # Initial state positivity and normalization
+    assert np.all(la.eigvals(rho.reshape(pdim, pdim)) > -1e-10)
+    assert np.abs(np.trace(rho.reshape(pdim, pdim))) - 1 < 1e-10
+
+    # POVM positivity and normalization
+    assert la.norm(np.sum(E, axis=0).reshape(pdim, pdim) - np.eye(pdim)) < 1e-6
+    assert np.all(povm_eigvals.reshape(-1) > -1e-10)
 
 def tvd(X, E, rho, J, y_data):
     """Return the total variation distance between model probabilities for the circuits in J

mGST/algorithm.py

@@ -28,7 +28,7 @@ from mGST.optimization import (
 from mGST.reporting.figure_gen import plot_objf
 
 
-def A_SFN_riem_Hess(K, A, B, y, J, d, r, n_povm, lam=1e-3):
+def A_SFN_riem_Hess(K, A, B, y, J, d, r, n_povm, lam=1e-3, mle=False):
     """Riemannian saddle free Newton step on the POVM parametrization
 
     Parameters
@@ -73,7 +73,7 @@ def A_SFN_riem_Hess(K, A, B, y, J, d, r, n_povm, lam=1e-3):
     Fyy = np.zeros((n_povm, r, n_povm, r)).astype(np.complex128)
 
     X = np.einsum("ijkl,ijnm -> iknlm", K, K.conj()).reshape((d, r, r))
-    dA_, dMdM, dMconjdM, dconjdA = ddA_derivs(X, A, B, J, y, r, pdim, n_povm)
+    dA_, dMdM, dMconjdM, dconjdA = ddA_derivs(X, A, B, J, y, r, pdim, n_povm, mle=mle)
 
     # Second derivatives
     for i in range(n_povm):
@@ -133,12 +133,12 @@ def A_SFN_riem_Hess(K, A, B, y, J, d, r, n_povm, lam=1e-3):
 
     Delta = tangent_proj(A, Delta_A, 1, n_povm)[0]
 
-    a = minimize(lineobjf_A_geodesic, 1e-9, args=(Delta, X, A, rho, J, y), method="COBYLA").x
+    a = minimize(lineobjf_A_geodesic, 1e-9, args=(Delta, X, A, rho, J, y, mle), method="COBYLA").x
     A_new = update_A_geodesic(A, Delta, a)
     return A_new
 
 
-def B_SFN_riem_Hess(K, A, B, y, J, d, r, n_povm, lam=1e-3):
+def B_SFN_riem_Hess(K, A, B, y, J, d, r, n_povm, lam=1e-3, mle=False):
     """Riemannian saddle free Newton step on the initial state parametrization
 
     Parameters
@@ -180,11 +180,9 @@ def B_SFN_riem_Hess(K, A, B, y, J, d, r, n_povm, lam=1e-3):
     E = np.array([(A[i].T.conj() @ A[i]).reshape(-1) for i in range(n_povm)])
     H = np.zeros((2, nt, 2, nt)).astype(np.complex128)
     P_T = np.zeros((2, nt, 2, nt)).astype(np.complex128)
-    Fyconjy = np.zeros((r, r)).astype(np.complex128)
-    Fyy = np.zeros((r, r)).astype(np.complex128)
 
     X = np.einsum("ijkl,ijnm -> iknlm", K, K.conj()).reshape((d, r, r))
-    dB_, dMdM, dMconjdM, dconjdB = ddB_derivs(X, A, B, J, y, r, pdim)
+    dB_, dMdM, dMconjdM, dconjdB = ddB_derivs(X, A, B, J, y, r, pdim, mle=mle)
 
     # Second derivatives
     Fyconjy = dMconjdM + dconjdB
@@ -241,14 +239,15 @@ def B_SFN_riem_Hess(K, A, B, y, J, d, r, n_povm, lam=1e-3):
     Delta = (H_abs_inv @ G)[:nt]
     # Projection onto tangent space
     Delta = Delta - Y * (Y.T.conj() @ Delta + Delta.T.conj() @ Y) / 2
-    res = minimize(lineobjf_B_geodesic, 1e-9, args=(Delta, X, E, B, J, y), method="COBYLA", options={"maxiter": 20})
+    res = minimize(
+        lineobjf_B_geodesic, 1e-9, args=(Delta, X, E, B, J, y, mle), method="COBYLA", options={"maxiter": 20}
+    )
     a = res.x
-
     B_new = update_B_geodesic(B, Delta, a)
     return B_new
 
 
-def gd(K, E, rho, y, J, d, r, rK, fixed_gates, ls="COBYLA"):
+def gd(K, E, rho, y, J, d, r, rK, fixed_gates, ls="COBYLA", mle=False):
     """Do Riemannian gradient descent optimization step on gates
 
     Parameters
@@ -291,7 +290,7 @@ def gd(K, E, rho, y, J, d, r, rK, fixed_gates, ls="COBYLA"):
     Delta = np.zeros((d, n, pdim)).astype(np.complex128)
     X = np.einsum("ijkl,ijnm -> iknlm", K, K.conj()).reshape((d, r, r))
 
-    dK_ = dK(X, K, E, rho, J, y, d, r, rK)
+    dK_ = dK(X, K, E, rho, J, y, d, r, rK, mle=mle)
     for k in np.where(~fixed_gates)[0]:
         # derivative
         Fy = dK_[k].reshape(n, pdim)
@@ -299,14 +298,20 @@ def gd(K, E, rho, y, J, d, r, rK, fixed_gates, ls="COBYLA"):
         # Riem. gradient taken from conjugate derivative
         rGrad = 2 * (Fy.conj() - Y @ Fy.T @ Y)
         Delta[k] = rGrad
-    res = minimize(lineobjf_isom_geodesic, 1e-8, args=(Delta, K, E, rho, J, y), method=ls, options={"maxiter": 200})
+
+    # Additional projection onto tangent space to avoid numerical instability
+    Delta = tangent_proj(K, Delta, d, rK)
+
+    res = minimize(
+        lineobjf_isom_geodesic, 1e-8, args=(Delta, K, E, rho, J, y, mle), method=ls, options={"maxiter": 200}
+    )
     a = res.x
     K_new = update_K_geodesic(K, Delta, a)
 
     return K_new
 
 
-def SFN_riem_Hess(K, E, rho, y, J, d, r, rK, lam=1e-3, ls="COBYLA", fixed_gates=None):
+def SFN_riem_Hess(K, E, rho, y, J, d, r, rK, lam=1e-3, ls="COBYLA", fixed_gates=None, mle=False):
     """Riemannian saddle free Newton step on each gate individually
 
     Parameters
@@ -355,8 +360,8 @@ def SFN_riem_Hess(K, E, rho, y, J, d, r, rK, lam=1e-3, ls="COBYLA", fixed_gates=
         fixed_gates = []
 
     # compute derivatives
-    dK_, dM10, dM11 = dK_dMdM(X, K, E, rho, J, y, d, r, rK)
-    dd, dconjd = ddM(X, K, E, rho, J, y, d, r, rK)
+    dK_, dM10, dM11 = dK_dMdM(X, K, E, rho, J, y, d, r, rK, mle=mle)
+    dd, dconjd = ddM(X, K, E, rho, J, y, d, r, rK, mle=mle)
 
     # Second derivatives
     Fyconjy = dM11.reshape(d, nt, d, nt) + np.einsum("ijklmnop->ikmojlnp", dconjd).reshape((d, nt, d, nt))
@@ -408,14 +413,16 @@ def SFN_riem_Hess(K, E, rho, y, J, d, r, rK, lam=1e-3, ls="COBYLA", fixed_gates=
 
     Delta = tangent_proj(K, Delta_K, d, rK)
 
-    res = minimize(lineobjf_isom_geodesic, 1e-8, args=(Delta, K, E, rho, J, y), method=ls, options={"maxiter": 200})
+    res = minimize(
+        lineobjf_isom_geodesic, 1e-8, args=(Delta, K, E, rho, J, y, mle), method=ls, options={"maxiter": 200}
+    )
     a = res.x
     K_new = update_K_geodesic(K, Delta, a)
 
     return K_new
 
 
-def SFN_riem_Hess_full(K, E, rho, y, J, d, r, rK, lam=1e-3, ls="COBYLA"):
+def SFN_riem_Hess_full(K, E, rho, y, J, d, r, rK, lam=1e-3, ls="COBYLA", mle=False):
     """Riemannian saddle free Newton step on product manifold of all gates
 
     Parameters
@@ -459,8 +466,8 @@ def SFN_riem_Hess_full(K, E, rho, y, J, d, r, rK, lam=1e-3, ls="COBYLA"):
     X = np.einsum("ijkl,ijnm -> iknlm", K, K.conj()).reshape((d, r, r))
 
     # compute derivatives
-    dK_, dM10, dM11 = dK_dMdM(X, K, E, rho, J, y, d, r, rK)
-    dd, dconjd = ddM(X, K, E, rho, J, y, d, r, rK)
+    dK_, dM10, dM11 = dK_dMdM(X, K, E, rho, J, y, d, r, rK, mle=mle)
+    dd, dconjd = ddM(X, K, E, rho, J, y, d, r, rK, mle=mle)
 
     # Second derivatives
     Fyconjy = dM11.reshape(d, nt, d, nt) + np.einsum("ijklmnop->ikmojlnp", dconjd).reshape((d, nt, d, nt))
@@ -522,13 +529,13 @@ def SFN_riem_Hess_full(K, E, rho, y, J, d, r, rK, lam=1e-3, ls="COBYLA"):
 
     # Delta_K is already in tangent space but not to sufficient numerical accuracy
     Delta = tangent_proj(K, Delta_K, d, rK)
-    res = minimize(lineobjf_isom_geodesic, 1e-8, args=(Delta, K, E, rho, J, y), method=ls, options={"maxiter": 20})
+    res = minimize(lineobjf_isom_geodesic, 1e-8, args=(Delta, K, E, rho, J, y, mle), method=ls, options={"maxiter": 20})
     a = res.x
     K_new = update_K_geodesic(K, Delta, a)
     return K_new
 
 
-def optimize(y, J, d, r, rK, n_povm, method, K, rho, A, B, fixed_elements):
+def optimize(y, J, d, r, rK, n_povm, method, K, rho, A, B, fixed_elements, mle=False):
     """Full gate set optimization update alternating on E, K and rho
 
     Parameters
@@ -578,27 +585,27 @@ def optimize(y, J, d, r, rK, n_povm, method, K, rho, A, B, fixed_elements):
         A_new = A
         E_new = np.array([(A_new[i].T.conj() @ A_new[i]).reshape(-1) for i in range(n_povm)])
     else:
-        A_new = A_SFN_riem_Hess(K, A, B, y, J, d, r, n_povm)
+        A_new = A_SFN_riem_Hess(K, A, B, y, J, d, r, n_povm, mle=mle)
         E_new = np.array([(A_new[i].T.conj() @ A_new[i]).reshape(-1) for i in range(n_povm)])
-
     if any(((f"G%i" % i in fixed_elements) for i in range(d))):
         fixed_gates = np.array([(f"G%i" % i in fixed_elements) for i in range(d)])
         if method == "SFN":
-            K_new = SFN_riem_Hess(K, E_new, rho, y, J, d, r, rK, lam=1e-3, ls="COBYLA", fixed_gates=fixed_gates)
+            K_new = SFN_riem_Hess(
+                K, E_new, rho, y, J, d, r, rK, lam=1e-3, ls="COBYLA", fixed_gates=fixed_gates, mle=mle
+            )
         else:
-            K_new = gd(K, E_new, rho, y, J, d, r, rK, ls="COBYLA", fixed_gates=fixed_gates)
+            K_new = gd(K, E_new, rho, y, J, d, r, rK, ls="COBYLA", fixed_gates=fixed_gates, mle=mle)
     else:
         if method == "SFN":
-            K_new = SFN_riem_Hess_full(K, E_new, rho, y, J, d, r, rK, lam=1e-3, ls="COBYLA")
+            K_new = SFN_riem_Hess_full(K, E_new, rho, y, J, d, r, rK, lam=1e-3, ls="COBYLA", mle=mle)
         else:
             fixed_gates = np.array([(f"G%i" % i in fixed_elements) for i in range(d)])
-            K_new = gd(K, E_new, rho, y, J, d, r, rK, fixed_gates=fixed_gates, ls="COBYLA")
-
+            K_new = gd(K, E_new, rho, y, J, d, r, rK, fixed_gates=fixed_gates, ls="COBYLA", mle=mle)
     if "rho" in fixed_elements:
         rho_new = rho
         B_new = B
     else:
-        B_new = B_SFN_riem_Hess(K_new, A_new, B, y, J, d, r, n_povm, lam=1e-3)
+        B_new = B_SFN_riem_Hess(K_new, A_new, B, y, J, d, r, n_povm, lam=1e-3, mle=mle)
         rho_new = (B_new @ B_new.T.conj()).reshape(-1)
     X_new = np.einsum("ijkl,ijnm -> iknlm", K_new, K_new.conj()).reshape((d, r, r))
     return K_new, X_new, E_new, rho_new, A_new, B_new
@@ -609,13 +616,13 @@ def run_mGST(
     method="SFN",
     max_inits=10,
     max_iter=200,
-    final_iter=70,
-    target_rel_prec=1e-4,
-    threshold_multiplier=3,
+    final_iter=120,
+    target_rel_prec=1e-5,
+    threshold_multiplier=5,
     fixed_elements=None,
     init=None,
-    testing=False,
-):  # pylint: disable=too-many-branches
+    verbose_level=0,
+):  # pylint: disable=too-many-branches, too-many-statements
     """Main mGST routine
 
     Parameters
@@ -653,11 +660,11 @@ def run_mGST(
 
     Returns
     -------
-    K : numpy array
+    K: numpy array
         Updated estimates of Kraus operators
-    X : numpy array
+    X: numpy array
         Updated estimates of superoperatos corresponding to K_new
-    E : numpy array
+    E: numpy array
         Updated POVM estimate
     rho : numpy array
         Updated initial state estimate
@@ -682,7 +689,8 @@ def run_mGST(
         )
 
     success = False
-    qcvv_logger.info(f"Starting mGST optimization...")
+    if verbose_level > 0:
+        qcvv_logger.info(f"Starting mGST optimization...")
 
     if init:
         K, E = (init[0], init[1])
@@ -698,8 +706,8 @@ def run_mGST(
             A = np.array([la.cholesky(E[k].reshape(pdim, pdim) + 1e-14 * np.eye(pdim)).T.conj() for k in range(n_povm)])
             B = la.cholesky(rho.reshape(pdim, pdim))
             res_list = [objf(X, E, rho, J, y)]
-            with logging_redirect_tqdm(loggers=[qcvv_logger]):
-                for _ in trange(max_iter):
+            with logging_redirect_tqdm(loggers=[qcvv_logger] if verbose_level > 0 else None):
+                for _ in trange(max_iter, disable=verbose_level == 0):
                     yb, Jb = batch(y, J, bsize)
                     K, X, E, rho, A, B = optimize(yb, Jb, d, r, rK, n_povm, method, K, rho, A, B, fixed_elements)
                     res_list.append(objf(X, E, rho, J, y))
@@ -707,29 +715,37 @@ def run_mGST(
                         qcvv_logger.info(f"Batch optimization successful, improving estimate over full data....")
                         success = True
                         break
-            if testing:
-                plot_objf(res_list, delta, f"Objective function for batch optimization")
+            if verbose_level == 2:
+                plot_objf(res_list, f"Objective function for batch optimization", delta=delta)
             if success:
                 break
-            qcvv_logger.info(f"Run {i+1}/{max_inits} failed, trying new initialization...")
+            if verbose_level > 0:
+                qcvv_logger.info(f"Run {i+1}/{max_inits} failed, trying new initialization...")
 
-    if not success and max_inits > 0:
+    if not success and init is None and verbose_level > 0:
         qcvv_logger.info(f"Success threshold not reached, attempting optimization over full data set...")
-    with logging_redirect_tqdm(loggers=[qcvv_logger]):
-        for _ in trange(final_iter):
-            K, X, E, rho, A, B = optimize(y, J, d, r, rK, n_povm, method, K, rho, A, B, fixed_elements)
+    with logging_redirect_tqdm(loggers=[qcvv_logger] if verbose_level > 0 else None):
+        res_list_mle = []
+        for _ in trange(final_iter, disable=verbose_level == 0):
+            K, X, E, rho, A, B = optimize(y, J, d, r, rK, n_povm, method, K, rho, A, B, fixed_elements, mle=True)
             res_list.append(objf(X, E, rho, J, y))
-            if len(res_list) >= 2 and np.abs(res_list[-2] - res_list[-1]) < delta * target_rel_prec:
+            res_list_mle.append(objf(X, E, rho, J, y, mle=True))
+            if (
+                len(res_list_mle) >= 2
+                and np.abs(res_list_mle[-2] - res_list_mle[-1]) < res_list_mle[-1] * target_rel_prec
+            ):
                 break
-    if testing:
-        plot_objf(res_list, delta, f"Objective function over batches and full data")
-    if success or (res_list[-1] < delta):
-        qcvv_logger.info(f"Convergence criterion satisfied")
-    else:
+    if verbose_level == 2:
+        plot_objf(res_list, f"Least squares error over batches and full data", delta=delta)
+        plot_objf(res_list_mle, f"Negative log-likelihood over full data")
+    if verbose_level > 0:
+        if success or (res_list[-1] < delta):
+            qcvv_logger.info(f"Convergence criterion satisfied")
+        else:
+            qcvv_logger.warning(
+                f"Convergence criterion not satisfied. Potential causes include too low max_iterations, bad initialization or model mismatch."
+            )
         qcvv_logger.info(
-            f"Convergence criterion not satisfied, inspect results and consider increasing max_iter or using new initializations.",
+            f"Final objective {Decimal(res_list[-1]):.2e} in time {(time.time() - t0):.2f}s",
         )
-    qcvv_logger.info(
-        f"Final objective {Decimal(res_list[-1]):.2e} in time {(time.time() - t0):.2f}s",
-    )
     return K, X, E, rho, res_list