change datasetconstruction.mix_dataset. Leave comments about efficiency elsewhere.

Author: rileyjmurray

pygsti/data/datasetconstruction.py

@@ -209,14 +209,27 @@ def simulate_data(model_or_dataset, circuit_list, num_samples,
     return dataset
 
 
-def mix_datasets(dsa, dsb, p, integral=True):
+def mix_datasets(dsa, dsb, p, integral=True, choose_machine=False, seed=None):
     dsc = dsa.copy_nonstatic()
     # arr = _np.array(dsc.repData).ravel()
     # print((arr, arr.size))
     # print((dsb.repData, dsb.repData.size))
+    num_circuits = len(dsb)
+    if choose_machine:
+        if seed is None:
+            _warnings.warn('Set the random seed! Using 42.')
+            seed = 42
+        rngstate = _np.random.default_rng(seed)
+        interp_weights = rngstate.uniform(low=0, high=1, size=num_circuits)
+        interp_weights[interp_weights < p] = 0.0
+        interp_weights[interp_weights > 0] = 1.0 
+    else:
+        interp_weights = p * _np.ones(num_circuits)
+
     for i, (_, dsrow) in enumerate(dsb.items()):
-        interpolated = p*dsc.repData[i] + (1-p)*dsrow.reps
-        if integral:
+        p_i = interp_weights[i]
+        interpolated = p_i * dsc.repData[i] + (1-p_i) * dsrow.reps
+        if integral and (not choose_machine):
             assert interpolated.size == 2
             total = int(_np.ceil((_np.sum(interpolated))))
             j = _np.argmin(interpolated)

pygsti/objectivefns/objectivefns.py

@@ -4597,6 +4597,10 @@ def _dterms_fill_penalty(self, paramvec, terms_jac):
             #   Ideally we'd have put in the effort to do this earlier when doing finite-difference to get
             #   the Jacobian of terms. But we start with a simple implementation.
             #
+            #       --> TODO: change so that if callable_penalty has a grad method then we'll call it instead
+            #                 of relying on finite-differences over all model parameters. This would help when
+            #                 the penalty is constant w.r.t. some params (like those that only appear in SPAM).
+            #
             terms_jac[off:off+1, :] = 0.0
             if self.callable_penalty_factor:
                 vec0 = self.model.to_vector()

pygsti/tools/rbtheory.py

@@ -323,6 +323,14 @@ def L_matrix(model, target_model, weights=None):  # noqa N802
             weights[key] = 1.
 
     normalizer = _np.sum(_np.array([weights[key] for key in list(target_model.operations.keys())]))
+    # TODO: improve efficiency
+    #
+    #   1. Accumuate the summands in this list comprehension in-place. (Might already happen but that's non-obvious)
+    #   2. Use the fact that target gates are unitary and so their superoperator representation inverses should
+    #      be their transposes.
+    #   3. Have the option to return this matrix as an implicit abstract linear operator, so that anyone who wants
+    #      eigenvalue info can try to get it from an iterative method instead of a full eigendecomposition.
+    #   
     L_matrix = (1 / normalizer) * _np.sum(
         weights[key] * _np.kron(
             model.operations[key].to_dense(on_space='HilbertSchmidt').T,