pyGSTi 0.9.12__cp310-cp310-win_amd64.whl → 0.9.13__cp310-cp310-win_amd64.whl

pygsti/protocols/confidenceregionfactory.py

@@ -27,6 +27,7 @@ from pygsti.circuits.circuitlist import CircuitList as _CircuitList
 from pygsti.objectivefns.objectivefns import PoissonPicDeltaLogLFunction as _PoissonPicDeltaLogLFunction
 from pygsti.objectivefns.objectivefns import Chi2Function as _Chi2Function
 from pygsti.objectivefns.objectivefns import FreqWeightedChi2Function as _FreqWeightedChi2Function
+from pygsti.models.explicitmodel import ExplicitOpModel as _ExplicitOpModel
 
 
 # NON-MARKOVIAN ERROR BARS
@@ -482,9 +483,15 @@ class ConfidenceRegionFactory(_NicelySerializable):
             label = projection_type
 
         model = self.parent.models[self.model_lbl]
-        nongauge_space, gauge_space = model.compute_nongauge_and_gauge_spaces()
-        self.nNonGaugeParams = nongauge_space.shape[1]
-        self.nGaugeParams = model.num_params - self.nNonGaugeParams
+
+        if projection_type != 'none':
+            nongauge_space, gauge_space = model.compute_nongauge_and_gauge_spaces()
+            self.nNonGaugeParams = nongauge_space.shape[1]
+            self.nGaugeParams = model.num_params - self.nNonGaugeParams
+        else:
+            # no projection means we take the entire space as non-gauge
+            self.nNonGaugeParams = model.num_params
+            self.nGaugeParams = 0
 
         #Project Hessian onto non-gauge space
         if projection_type == 'none':
@@ -691,13 +698,13 @@ class ConfidenceRegionFactory(_NicelySerializable):
             sub_crf.project_hessian('none')
             crfv = sub_crf.view(level)
 
-            operationCIs = _np.concatenate([crfv.retrieve_profile_likelihood_confidence_intervals(gl).flatten()
+            operationCIs = _np.concatenate([crfv.retrieve_profile_likelihood_confidence_intervals(gl).ravel()
                                             for gl in model.operations])
             return _np.sqrt(_np.sum(operationCIs**2))
 
         #Run Minimization Algorithm
         startM = _np.zeros((self.nNonGaugeParams, self.nGaugeParams), 'd')
-        x0 = startM.flatten()
+        x0 = startM.ravel()
         print_obj_func = _opt.create_objfn_printer(_objective_func)
         minSol = _opt.minimize(_objective_func, x0,
                                method=method, maxiter=maxiter,
@@ -727,7 +734,7 @@ class ConfidenceRegionFactory(_NicelySerializable):
                                           self.circuit_list_lbl, projected_hessian, 0.0)
         sub_crf.project_hessian('none')
         crfv = sub_crf.view(level)
-        operationCIs = _np.concatenate([crfv.retrieve_profile_likelihood_confidence_intervals(gl).flatten()
+        operationCIs = _np.concatenate([crfv.retrieve_profile_likelihood_confidence_intervals(gl).ravel()
                                         for gl in model.operations])
         op_intrinsic_err = _np.sqrt(_np.mean(operationCIs**2))
 
@@ -738,7 +745,7 @@ class ConfidenceRegionFactory(_NicelySerializable):
                                           self.circuit_list_lbl, projected_hessian, 0.0)
         sub_crf.project_hessian('none')
         crfv = sub_crf.view(level)
-        spamCIs = _np.concatenate([crfv.retrieve_profile_likelihood_confidence_intervals(sl).flatten()
+        spamCIs = _np.concatenate([crfv.retrieve_profile_likelihood_confidence_intervals(sl).ravel()
                                    for sl in _itertools.chain(iter(model.preps),
                                                               iter(model.povms))])
         spam_intrinsic_err = _np.sqrt(_np.mean(spamCIs**2))
@@ -755,9 +762,9 @@ class ConfidenceRegionFactory(_NicelySerializable):
             sub_crf.project_hessian('none')
             crfv = sub_crf.view(level)
 
-            operationCIs = _np.concatenate([crfv.retrieve_profile_likelihood_confidence_intervals(gl).flatten()
+            operationCIs = _np.concatenate([crfv.retrieve_profile_likelihood_confidence_intervals(gl).ravel()
                                             for gl in model.operations])
-            spamCIs = _np.concatenate([crfv.retrieve_profile_likelihood_confidence_intervals(sl).flatten()
+            spamCIs = _np.concatenate([crfv.retrieve_profile_likelihood_confidence_intervals(sl).ravel()
                                        for sl in _itertools.chain(iter(model.preps),
                                                                   iter(model.povms))])
             op_err = _np.sqrt(_np.mean(operationCIs**2))
@@ -1068,11 +1075,18 @@ class ConfidenceRegionFactoryView(object):
             else:
                 # copy objects because we add eps to them below
                 typ, lbl = dependency
-                if typ == "gate": modelObj = mdl.operations[lbl]
-                elif typ == "prep": modelObj = mdl.preps[lbl]
-                elif typ == "povm": modelObj = mdl.povms[lbl]
-                elif typ == "instrument": modelObj = mdl.instruments[lbl]
-                else: raise ValueError("Invalid dependency type: %s" % typ)
+                if isinstance(mdl, _ExplicitOpModel):
+                    if typ == "gate": modelObj = mdl.operations[lbl]
+                    elif typ == "prep": modelObj = mdl.preps[lbl]
+                    elif typ == "povm": modelObj = mdl.povms[lbl]
+                    elif typ == "instrument": modelObj = mdl.instruments[lbl]
+                    else: raise ValueError("Invalid dependency type: %s" % typ)
+                else:
+                    if typ == "gate": modelObj = mdl.operation_blks['gates'][lbl]
+                    elif typ == "prep": modelObj = mdl.prep_blks['layers'][lbl]
+                    elif typ == "povm": modelObj = mdl.povm_blks['layers'][lbl]
+                    elif typ == "instrument": modelObj = mdl.instrument_blks['layers'][lbl]
+                    else: raise ValueError("Invalid dependency type: %s" % typ)
                 all_gpindices.extend(modelObj.gpindices_as_array())
 
         vec0 = mdl.to_vector()

pygsti/protocols/estimate.py

@@ -87,7 +87,6 @@ class Estimate(_MongoSerializable):
 
     @classmethod
     def _create_obj_from_doc_and_mongodb(cls, doc, mongodb, quick_load=False):
-        #def from_mongodb(cls, mongodb_collection, doc_id, ):
         ret = cls.__new__(cls)
         _MongoSerializable.__init__(ret, doc.get('_id', None))
         ret.__dict__.update(_io.read_auxtree_from_mongodb_doc(mongodb, doc, 'auxfile_types', quick_load=quick_load))
@@ -277,7 +276,10 @@ class Estimate(_MongoSerializable):
         Model
         """
         goparams_list = [goparams] if hasattr(goparams, 'keys') else goparams
-        return goparams_list[0].get('model', self.models['final iteration estimate'])
+        if goparams_list:
+            return goparams_list[0].get('model', self.models['final iteration estimate'])
+        else:
+            return None
 
     def add_gaugeoptimized(self, goparams, model=None, label=None, comm=None, verbosity=None):
         """
@@ -331,8 +333,14 @@ class Estimate(_MongoSerializable):
                 label = "go%d" % i; i += 1
                 if (label not in self._gaugeopt_suite.gaugeopt_argument_dicts) and \
                    (label not in self.models): break
-
-        goparams_list = [goparams] if hasattr(goparams, 'keys') else goparams
+        if hasattr(goparams, 'keys'):
+            goparams_list = [goparams]
+        elif goparams is None:
+            goparams_list = []
+            #since this will be empty much of the code/iteration below will
+            #be skipped.
+        else:
+            goparams_list = goparams
         ordered_goparams = []
         last_gs = None
 
@@ -350,11 +358,14 @@ class Estimate(_MongoSerializable):
         printer = _VerbosityPrinter.create_printer(max_vb, printer_comm)
         printer.log("-- Adding Gauge Optimized (%s) --" % label)
 
-        for i, gop in enumerate(goparams_list):
-
-            if model is not None:
-                last_gs = model  # just use user-supplied result
-            else:
+        if model is not None:
+            last_gs = model  # just use user-supplied result
+            #sort the parameters by name for consistency
+            for gop in goparams_list:
+                ordered_goparams.append(_collections.OrderedDict(
+                    [(k, gop[k]) for k in sorted(list(gop.keys()))]))
+        else:
+            for i, gop in enumerate(goparams_list):
                 from ..algorithms import gaugeopt_to_target as _gaugeopt_to_target
                 default_model = default_target_model = False
                 gop = gop.copy()  # so we don't change the caller's dict
@@ -398,14 +409,20 @@ class Estimate(_MongoSerializable):
                 if default_model: del gop['model']
                 if default_target_model: del gop['target_model']
 
-            #sort the parameters by name for consistency
-            ordered_goparams.append(_collections.OrderedDict(
-                [(k, gop[k]) for k in sorted(list(gop.keys()))]))
+                #sort the parameters by name for consistency
+                ordered_goparams.append(_collections.OrderedDict(
+                    [(k, gop[k]) for k in sorted(list(gop.keys()))]))
 
         assert(last_gs is not None)
         self.models[label] = last_gs
-        self._gaugeopt_suite.gaugeopt_argument_dicts[label] = ordered_goparams \
-            if len(goparams_list) > 1 else ordered_goparams[0]
+
+        if goparams_list: #only do this if goparams_list wasn't empty to begin with.
+            #which would be the case except for the special case where the label is 'none'.
+            self._gaugeopt_suite.gaugeopt_argument_dicts[label] = ordered_goparams \
+                if len(goparams_list) > 1 else ordered_goparams[0]
+        else:
+            self._gaugeopt_suite.gaugeopt_argument_dicts[label] = None
+
 
     def add_confidence_region_factory(self,
                                       model_label='final iteration estimate',