pyGSTi 0.9.12__cp38-cp38-win_amd64.whl → 0.9.13__cp38-cp38-win_amd64.whl

pygsti/forwardsims/matrixforwardsim.py

@@ -29,6 +29,8 @@ from pygsti.tools import mpitools as _mpit
 from pygsti.tools import sharedmemtools as _smt
 from pygsti.tools import slicetools as _slct
 from pygsti.tools.matrixtools import _fas
+from pygsti.tools import listtools as _lt
+from pygsti.circuits import CircuitList as _CircuitList
 
 _dummy_profiler = _DummyProfiler()
 
@@ -132,12 +134,18 @@ class SimpleMatrixForwardSimulator(_ForwardSimulator):
             obj_wrtFilter = []  # values = object-local param indices
             relevant_gpindices = []  # indices into original wrt_filter'd indices
 
-            gpindices = obj.gpindices_as_array()
+            if isinstance(obj.gpindices, slice):
+                gpindices_list = _slct.indices(obj.gpindices)
+            elif obj.gpindices is None:
+                gpindices_list = []
+            else:
+                gpindices_list = list(obj.gpindices)
+            gpindices_set = set(gpindices_list)
 
             for ii, i in enumerate(wrt_filter):
-                if i in gpindices:
+                if i in gpindices_set:
                     relevant_gpindices.append(ii)
-                    obj_wrtFilter.append(list(gpindices).index(i))
+                    obj_wrtFilter.append(gpindices_list.index(i))
             relevant_gpindices = _np.array(relevant_gpindices, _np.int64)
             if len(relevant_gpindices) == 1:
                 #Don't return a length-1 list, as this doesn't index numpy arrays
@@ -590,7 +598,7 @@ class SimpleMatrixForwardSimulator(_ForwardSimulator):
         use_scaling = False  # Hardcoded for now
         assert(time is None), "MatrixForwardSimulator cannot be used to simulate time-dependent circuits"
 
-        expanded_circuit_outcomes = circuit.expand_instruments_and_separate_povm(self.model, outcomes)
+        expanded_circuit_outcomes = self.model.expand_instruments_and_separate_povm(circuit, outcomes)
         outcome_to_index = {outc: i for i, outc in enumerate(outcomes)}
         for spc, spc_outcomes in expanded_circuit_outcomes.items():  # spc is a SeparatePOVMCircuit
             indices = [outcome_to_index[o] for o in spc_outcomes]
@@ -1025,7 +1033,7 @@ class MatrixForwardSimulator(_DistributableForwardSimulator, SimpleMatrixForward
         return hProdCache
 
     def create_layout(self, circuits, dataset=None, resource_alloc=None, array_types=('E',),
-                      derivative_dimension=None, verbosity=0):
+                      derivative_dimensions=None, verbosity=0, layout_creation_circuit_cache= None):
         """
         Constructs an circuit-outcome-probability-array (COPA) layout for a list of circuits.
 
@@ -1046,15 +1054,22 @@ class MatrixForwardSimulator(_DistributableForwardSimulator, SimpleMatrixForward
         array_types : tuple, optional
             A tuple of string-valued array types.  See :meth:`ForwardSimulator.create_layout`.
 
-        derivative_dimension : int, optional
+        derivative_dimensions : int or tuple[int], optional
             Optionally, the parameter-space dimension used when taking first
             and second derivatives with respect to the cirucit outcome probabilities.  This must be
             non-None when `array_types` contains `'ep'` or `'epp'` types.
+            If a tuple, then must be length 1.
 
         verbosity : int or VerbosityPrinter
             Determines how much output to send to stdout.  0 means no output, higher
             integers mean more output.
 
+        layout_creation_circuit_cache : dict, optional (default None)
+            A precomputed dictionary serving as a cache for completed
+            circuits. I.e. circuits with prep labels and POVM labels appended.
+            Along with other useful pre-computed circuit structures used in layout
+            creation.
+            
         Returns
         -------
         MatrixCOPALayout
@@ -1075,7 +1090,13 @@ class MatrixForwardSimulator(_DistributableForwardSimulator, SimpleMatrixForward
         printer = _VerbosityPrinter.create_printer(verbosity, resource_alloc)
         nprocs = resource_alloc.comm_size
         comm = resource_alloc.comm
-        num_params = derivative_dimension if (derivative_dimension is not None) else self.model.num_params
+        if isinstance(derivative_dimensions, int):
+            num_params = derivative_dimensions
+        elif isinstance(derivative_dimensions, tuple):
+            assert len(derivative_dimensions) == 1
+            num_params = derivative_dimensions[0]
+        else:
+            num_params = self.model.num_params
         C = 1.0 / (1024.0**3)
 
         if mem_limit is not None:
@@ -1098,7 +1119,8 @@ class MatrixForwardSimulator(_DistributableForwardSimulator, SimpleMatrixForward
         assert(_np.prod((na,) + npp) <= nprocs), "Processor grid size exceeds available processors!"
 
         layout = _MatrixCOPALayout(circuits, self.model, dataset, natoms,
-                                   na, npp, param_dimensions, param_blk_sizes, resource_alloc, verbosity)
+                                   na, npp, param_dimensions, param_blk_sizes, resource_alloc, verbosity, 
+                                   layout_creation_circuit_cache=layout_creation_circuit_cache)
 
         if mem_limit is not None:
             loc_nparams1 = num_params / npp[0] if len(npp) > 0 else 0
@@ -1125,13 +1147,6 @@ class MatrixForwardSimulator(_DistributableForwardSimulator, SimpleMatrixForward
                                                   (blk1, blk2), max_atom_cachesize,
                                                   self.model.evotype.minimal_dim(self.model.state_space))
 
-            #def approx_mem_estimate(natoms, np1, np2):
-            #    approx_cachesize = (num_circuits / natoms) * 1.3  # inflate expected # circuits per atom => cache_size
-            #    return _bytes_for_array_types(array_types, num_elements, num_elements / natoms,
-            #                                  num_circuits, num_circuits / natoms,
-            #                                  (num_params, num_params), (num_params / np1, num_params / np2),
-            #                                  approx_cachesize, self.model.state_space.dim)
-
             GB = 1.0 / 1024.0**3
             if mem_estimate > mem_limit:
                 raise MemoryError("Not enough memory for desired layout! (limit=%.1fGB, required=%.1fGB)" % (
@@ -1140,6 +1155,46 @@ class MatrixForwardSimulator(_DistributableForwardSimulator, SimpleMatrixForward
                 printer.log("   Esimated memory required = %.1fGB" % (mem_estimate * GB))
 
         return layout
+    
+    @staticmethod
+    def create_copa_layout_circuit_cache(circuits, model, dataset=None):
+        """
+        Helper function for pre-computing/pre-processing circuits structures
+        used in matrix layout creation.
+        """
+        cache = dict()
+        completed_circuits, split_circuits = model.complete_circuits(circuits, return_split=True)
+
+        cache['completed_circuits'] = {ckt: comp_ckt for ckt, comp_ckt in zip(circuits, completed_circuits)}
+        cache['split_circuits'] = {ckt: split_ckt for ckt, split_ckt in zip(circuits, split_circuits)}
+
+        if dataset is not None:
+            aliases = circuits.op_label_aliases if isinstance(circuits, _CircuitList) else None
+            ds_circuits = _lt.apply_aliases_to_circuits(circuits, aliases)
+            unique_outcomes_list = []
+            for ckt in ds_circuits:
+                ds_row = dataset[ckt]
+                unique_outcomes_list.append(ds_row.unique_outcomes if ds_row is not None else None)
+        else:
+            unique_outcomes_list = [None]*len(circuits)
+
+        expanded_circuit_outcome_list = model.bulk_expand_instruments_and_separate_povm(circuits, 
+                                                                                        observed_outcomes_list = unique_outcomes_list, 
+                                                                                        split_circuits = split_circuits)
+        
+        expanded_circuit_cache = {ckt: expanded_ckt for ckt,expanded_ckt in zip(circuits, expanded_circuit_outcome_list)}
+                    
+        cache['expanded_and_separated_circuits'] = expanded_circuit_cache
+
+        expanded_subcircuits_no_spam_cache = dict()
+        for expc_outcomes in cache['expanded_and_separated_circuits'].values():
+            for sep_povm_c, _ in expc_outcomes.items():  # for each expanded cir from unique_i-th circuit
+                exp_nospam_c = sep_povm_c.circuit_without_povm[1:] 
+                expanded_subcircuits_no_spam_cache[exp_nospam_c] = exp_nospam_c.expand_subcircuits()
+
+        cache['expanded_subcircuits_no_spam'] = expanded_subcircuits_no_spam_cache
+
+        return cache
 
     def _scale_exp(self, scale_exps):
         old_err = _np.seterr(over='ignore')
@@ -1187,7 +1242,8 @@ class MatrixForwardSimulator(_DistributableForwardSimulator, SimpleMatrixForward
         # dp_dOps[i,j] = dot( e, dot( d_gs, rho ) )[0,i,j,0]
         # dp_dOps      = squeeze( dot( e, dot( d_gs, rho ) ), axis=(0,3))
         old_err2 = _np.seterr(invalid='ignore', over='ignore')
-        dp_dOps = _np.squeeze(_np.dot(e, _np.dot(d_gs, rho)), axis=(0, 3)) * scale_vals[:, None]
+        path = _np.einsum_path('hk,ijkl,lm->ij', e, d_gs, rho, optimize='optimal')
+        dp_dOps = _np.einsum('hk,ijkl,lm->ij', e, d_gs, rho, optimize=path[0]) * scale_vals[:, None]
         _np.seterr(**old_err2)
         # may overflow, but OK ; shape == (len(circuit_list), nDerivCols)
         # may also give invalid value due to scale_vals being inf and dot-prod being 0. In
@@ -1227,7 +1283,6 @@ class MatrixForwardSimulator(_DistributableForwardSimulator, SimpleMatrixForward
             # dp_drhos[i,J0+J] = sum_kl e[0,k] gs[i,k,l] drhoP[l,J]
             # dp_drhos[i,J0+J] = dot(e, gs, drhoP)[0,i,J]
             # dp_drhos[:,J0+J] = squeeze(dot(e, gs, drhoP),axis=(0,))[:,J]
-
             dp_drhos = _np.zeros((nCircuits, nOpDerivCols))
             _fas(dp_drhos, [None, rho_gpindices],
                  _np.squeeze(_np.dot(_np.dot(e, gs),

pygsti/forwardsims/termforwardsim.py

@@ -214,7 +214,7 @@ class TermForwardSimulator(_DistributableForwardSimulator):
     @classmethod
     def _from_nice_serialization(cls, state):
         #Note: resets processor-distribution information
-        return cls(state['mode'], state['max_taylor_order'],
+        return cls(None, state['mode'], state['max_taylor_order'],
                    state['desired_pathintegral_approximation_error'],
                    state['allowed_pathintegral_approximation_error'],
                    state['minimum_retained_term_magnitude'],
@@ -243,16 +243,6 @@ class TermForwardSimulator(_DistributableForwardSimulator):
         # and this is done by the parent model which will cause _set_evotype to be called.
         return state
 
-    #OLD - now we have a _set_evotype method.
-    #@_ForwardSimulator.model.setter
-    #def model(self, val):
-    #    _ForwardSimulator.model.fset(self, val)  # set the base class property (self.model)
-    #
-    #    #Do some additional initialization
-    #    if self.model.evotype not in ("svterm", "cterm"):
-    #        #raise ValueError(f"Evolution type {self.model.evotype} is incompatible with term-based calculations")
-    #        _warnings.warn("Evolution type %s is incompatible with term-based calculations" % self.model.evotype)
-
     def copy(self):
         """
         Return a shallow copy of this TermForwardSimulator.
@@ -267,7 +257,7 @@ class TermForwardSimulator(_DistributableForwardSimulator):
                                     self.oob_check_interval, self.cache)
 
     def create_layout(self, circuits, dataset=None, resource_alloc=None, array_types=('E',),
-                      derivative_dimension=None, verbosity=0):
+                      derivative_dimension=None, verbosity=0, layout_creation_circuit_cache=None):
         """
         Constructs an circuit-outcome-probability-array (COPA) layout for a list of circuits.
 
@@ -296,6 +286,12 @@ class TermForwardSimulator(_DistributableForwardSimulator):
         verbosity : int or VerbosityPrinter
             Determines how much output to send to stdout.  0 means no output, higher
             integers mean more output.
+        
+        layout_creation_circuit_cache:
+            A precomputed dictionary serving as a cache for completed
+            circuits. I.e. circuits with prep labels and POVM labels appended.
+            Along with other useful pre-computed circuit structures used in layout
+            creation.
 
         Returns
         -------
@@ -330,6 +326,7 @@ class TermForwardSimulator(_DistributableForwardSimulator):
         printer.log("   %d atoms, parameter block size limits %s" % (natoms, str(param_blk_sizes)))
         assert(_np.prod((na,) + npp) <= nprocs), "Processor grid size exceeds available processors!"
 
+        # TODO: Layout circuit creation cache unused for TermCOPALayout
         layout = _TermCOPALayout(circuits, self.model, dataset, natoms, na, npp, param_dimensions,
                                  param_blk_sizes, resource_alloc, printer)
         #MEM debug_prof.print_memory("CreateLayout2 - nAtoms = %d" % len(layout.atoms), True)
@@ -409,105 +406,6 @@ class TermForwardSimulator(_DistributableForwardSimulator):
                 hpolys[0], hpolys[1], self.model.to_vector(), (nEls, len(wrtInds1), len(wrtInds2)))
         _fas(array_to_fill, [slice(0, array_to_fill.shape[0]), dest_param_slice1, dest_param_slice2], hprobs)
 
-    #DIRECT FNS - keep these around, but they need to be updated (as do routines in fastreplib.pyx)
-    #def _prs_directly(self, layout_atom, resource_alloc): #comm=None, mem_limit=None, reset_wts=True, repcache=None):
-    #    """
-    #    Compute probabilities of `layout`'s circuits using "direct" mode.
-    #
-    #    Parameters
-    #    ----------
-    #    layout : CircuitOutcomeProbabilityArrayLayout
-    #        The layout.
-    #
-    #    comm : mpi4py.MPI.Comm, optional
-    #        When not None, an MPI communicator for distributing the computation
-    #        across multiple processors.  Distribution is performed over
-    #        subtrees of eval_tree (if it is split).
-    #
-    #    mem_limit : int, optional
-    #        A rough memory limit in bytes.
-    #
-    #    reset_wts : bool, optional
-    #        Whether term magnitudes should be updated based on current term coefficients
-    #        (which are based on the current point in model-parameter space) or not.
-    #
-    #    repcache : dict, optional
-    #        A cache of term representations for increased performance.
-    #    """
-    #    prs = _np.empty(layout_atom.num_elements, 'd')
-    #    #print("Computing prs directly for %d circuits" % len(circuit_list))
-    #    if repcache is None: repcache = {}  # new repcache...
-    #    k = 0   # *linear* evaluation order so we know final indices are just running
-    #    for i in eval_tree.evaluation_order():
-    #        circuit = eval_tree[i]
-    #        #print("Computing prs directly: circuit %d of %d" % (i,len(circuit_list)))
-    #        assert(self.evotype == "svterm")  # for now, just do SV case
-    #        fastmode = False  # start with slow mode
-    #        wtTol = 0.1
-    #        rholabel = circuit[0]
-    #        opStr = circuit[1:]
-    #        elabels = eval_tree.simplified_circuit_elabels[i]
-    #        prs[k:k + len(elabels)] = replib.SV_prs_directly(self, rholabel, elabels, opStr,
-    #                                                         repcache, comm, mem_limit, fastmode, wtTol, reset_wts,
-    #                                                         self.times_debug)
-    #        k += len(elabels)
-    #    #print("PRS = ",prs)
-    #    return prs
-    #
-    #def _dprs_directly(self, eval_tree, wrt_slice, comm=None, mem_limit=None, reset_wts=True, repcache=None):
-    #    """
-    #    Compute probability derivatives of `eval_tree`'s circuits using "direct" mode.
-    #
-    #    Parameters
-    #    ----------
-    #    eval_tree : TermEvalTree
-    #        The evaluation tree.
-    #
-    #    wrt_slice : slice
-    #        A slice specifying which model parameters to differentiate with respect to.
-    #
-    #    comm : mpi4py.MPI.Comm, optional
-    #        When not None, an MPI communicator for distributing the computation
-    #        across multiple processors.  Distribution is performed over
-    #        subtrees of eval_tree (if it is split).
-    #
-    #    mem_limit : int, optional
-    #        A rough memory limit in bytes.
-    #
-    #    reset_wts : bool, optional
-    #        Whether term magnitudes should be updated based on current term coefficients
-    #        (which are based on the current point in model-parameter space) or not.
-    #
-    #    repcache : dict, optional
-    #        A cache of term representations for increased performance.
-    #    """
-    #    #Note: Finite difference derivatives are SLOW!
-    #    if wrt_slice is None:
-    #        wrt_indices = list(range(self.Np))
-    #    elif isinstance(wrt_slice, slice):
-    #        wrt_indices = _slct.indices(wrt_slice)
-    #    else:
-    #        wrt_indices = wrt_slice
-    #
-    #    eps = 1e-6  # HARDCODED
-    #    probs = self._prs_directly(eval_tree, comm, mem_limit, reset_wts, repcache)
-    #    dprobs = _np.empty((eval_tree.num_final_elements(), len(wrt_indices)), 'd')
-    #    orig_vec = self.to_vector().copy()
-    #    iParamToFinal = {i: ii for ii, i in enumerate(wrt_indices)}
-    #    for i in range(self.Np):
-    #        #print("direct dprobs cache %d of %d" % (i,self.Np))
-    #        if i in iParamToFinal:  # LATER: add MPI support?
-    #            iFinal = iParamToFinal[i]
-    #            vec = orig_vec.copy(); vec[i] += eps
-    #            self.from_vector(vec, close=True)
-    #            dprobs[:, iFinal] = (self._prs_directly(eval_tree,
-    #                                                   comm=None,
-    #                                                   mem_limit=None,
-    #                                                   reset_wts=False,
-    #                                                   repcache=repcache) - probs) / eps
-    #    self.from_vector(orig_vec, close=True)
-    #    return dprobs
-
     ## ----- Find a "minimal" path set (i.e. find thresholds for each circuit -----
     def _compute_pruned_pathmag_threshold(self, rholabel, elabels, circuit, polynomial_vindices_per_int,
                                           repcache, circuitsetup_cache,