pyGSTi 0.9.12.1__cp38-cp38-win_amd64.whl → 0.9.13__cp38-cp38-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',

pygsti/protocols/gst.py

@@ -38,6 +38,7 @@ from pygsti import baseobjs as _baseobjs
 from pygsti.processors import QuditProcessorSpec as _QuditProcessorSpec
 from pygsti.modelmembers import operations as _op
 from pygsti.models import Model as _Model
+from pygsti.models.explicitmodel import ExplicitOpModel as _ExplicitOpModel
 from pygsti.models.gaugegroup import GaugeGroup as _GaugeGroup, GaugeGroupElement as _GaugeGroupElement
 from pygsti.objectivefns import objectivefns as _objfns, wildcardbudget as _wild
 from pygsti.circuits.circuitlist import CircuitList as _CircuitList
@@ -595,7 +596,7 @@ class GSTBadFitOptions(_NicelySerializable):
         Actions to take when a GST fit is unsatisfactory. Allowed actions include:
         
         * 'wildcard': Find an admissable wildcard model.
-        * 'ddist_wildcard': Fits a single parameter wildcard model in which
+        * 'wildcard1d': Fits a single parameter wildcard model in which
           the amount of wildcard error added to an operation is proportional
           to the diamond distance between that operation and the target.
         * 'robust': scale data according out "robust statistics v1" algorithm,
@@ -639,10 +640,8 @@ class GSTBadFitOptions(_NicelySerializable):
 
     wildcard_methods: tuple, optional
         A list of the methods to use to optimize the wildcard error vector.  Default is `("neldermead",)`.
-        Options include `"neldermead"`, `"barrier"`, `"cvxopt"`, `"cvxopt_smoothed"`, `"cvxopt_small"`,
-        and `"cvxpy_noagg"`.  So many methods exist because different convex solvers behave differently
-        (unfortunately).  Leave as the default as a safe option, but `"barrier"` is pretty reliable and much
-        faster than `"neldermead"`, and is a good option so long as it runs.
+        Options include `"neldermead"`, `"barrier"`, and `"cvxpy_noagg"`.  Leave as the default as a safe option,
+        but `"barrier"` is pretty reliable and much faster than `"neldermead"`, and is a good option so long as it runs.
 
     wildcard_inadmissable_action: {"print", "raise"}, optional
         What to do when an inadmissable wildcard error vector is found.  The default just prints this
@@ -841,7 +840,9 @@ class GSTGaugeOptSuite(_NicelySerializable):
           - "varyValidSpamWt" : varies spam weight with SPAM penalty == 1.
           - "toggleValidSpam" : toggles spame penalty (0 or 1); fixed SPAM wt.
           - "unreliable2Q" : adds branch to a spam suite that weights 2Q gates less
-          - "none" : no gauge optimizations are performed.
+          - "none" : no gauge optimizations are performed. When passed individually
+             (not in a list with other suite names) then this results in an empty
+             GSTGaugeOptSuite object (w/gaugeopt_suite_names set to None).
 
     gaugeopt_argument_dicts : dict, optional
         A dictionary whose string-valued keys label different gauge optimizations (e.g. within a
@@ -872,8 +873,11 @@ class GSTGaugeOptSuite(_NicelySerializable):
     def __init__(self, gaugeopt_suite_names=None, gaugeopt_argument_dicts=None, gaugeopt_target=None):
         super().__init__()
         if gaugeopt_suite_names is not None:
-            self.gaugeopt_suite_names = (gaugeopt_suite_names,) \
-                if isinstance(gaugeopt_suite_names, str) else tuple(gaugeopt_suite_names)
+            if gaugeopt_suite_names == 'none':
+                self.gaugeopt_suite_names = None
+            else:
+                self.gaugeopt_suite_names = (gaugeopt_suite_names,) \
+                    if isinstance(gaugeopt_suite_names, str) else tuple(gaugeopt_suite_names)
         else:
             self.gaugeopt_suite_names = None
 
@@ -951,6 +955,8 @@ class GSTGaugeOptSuite(_NicelySerializable):
                 if hasattr(goparams, 'keys'):  # goparams is a simple dict
                     gaugeopt_suite_dict[lbl] = goparams.copy()
                     gaugeopt_suite_dict[lbl].update({'verbosity': printer})
+                elif goparams is None:
+                    gaugeopt_suite_dict[lbl] = None
                 else:  # assume goparams is an iterable
                     assert(isinstance(goparams, (list, tuple))), \
                         "If not a dictionary, gauge opt params should be a list or tuple of dicts!"
@@ -963,7 +969,13 @@ class GSTGaugeOptSuite(_NicelySerializable):
         if self.gaugeopt_target is not None:
             assert(isinstance(self.gaugeopt_target, _Model)), "`gaugeopt_target` must be None or a Model"
             for goparams in gaugeopt_suite_dict.values():
-                goparams_list = [goparams] if hasattr(goparams, 'keys') else goparams
+                if hasattr(goparams, 'keys'):
+                    goparams_list = [goparams] 
+                elif goparams is None: #edge case for 'none' suite
+                    continue
+                else:
+                    goparams_list = goparams
+
                 for goparams_dict in goparams_list:
                     if 'target_model' in goparams_dict:
                         _warnings.warn(("`gaugeOptTarget` argument is overriding"
@@ -1088,8 +1100,8 @@ class GSTGaugeOptSuite(_NicelySerializable):
         elif suite_name == "unreliable2Q":
             raise ValueError(("unreliable2Q is no longer a separate 'suite'.  You should precede it with the suite"
                               " name, e.g. 'stdgaugeopt-unreliable2Q' or 'varySpam-unreliable2Q'"))
-        elif suite_name == "none":
-            pass  # add nothing
+        elif suite_name == 'none':
+            gaugeopt_suite_dict[root_lbl] = None
         else:
             raise ValueError("Unknown gauge-optimization suite '%s'" % suite_name)
 
@@ -1122,6 +1134,9 @@ class GSTGaugeOptSuite(_NicelySerializable):
             for lbl, goparams in self.gaugeopt_argument_dicts.items():
                 goparams_list = [goparams] if hasattr(goparams, 'keys') else goparams
                 serialize_list = []
+                if lbl == 'trivial_gauge_opt':
+                    dicts_to_serialize[lbl] = None
+                    continue
                 for goparams_dict in goparams_list:
                     to_add = goparams_dict.copy()
                     if 'target_model' in to_add:
@@ -1153,6 +1168,9 @@ class GSTGaugeOptSuite(_NicelySerializable):
     def _from_nice_serialization(cls, state):  # memo holds already de-serialized objects
         gaugeopt_argument_dicts = {}
         for lbl, serialized_goparams_list in state['gaugeopt_argument_dicts'].items():
+            if lbl == 'trivial_gauge_opt':
+                gaugeopt_argument_dicts[lbl] = None
+                continue
             goparams_list = []
             for serialized_goparams in serialized_goparams_list:
                 to_add = serialized_goparams.copy()
@@ -1232,15 +1250,16 @@ class GateSetTomography(_proto.Protocol):
 
         if isinstance(optimizer, _opt.Optimizer):
             self.optimizer = optimizer
-            if isinstance(optimizer, _opt.CustomLMOptimizer) and optimizer.first_fditer is None:
-                #special behavior: can set optimizer's first_fditer to `None` to mean "fill with default"
+            if hasattr(optimizer,'first_fditer') and optimizer.first_fditer is None:
+                # special behavior: can set optimizer's first_fditer to `None` to mean "fill with default"
                 self.optimizer = _copy.deepcopy(optimizer)  # don't mess with caller's optimizer
                 self.optimizer.first_fditer = default_first_fditer
         else:
-            if optimizer is None: optimizer = {}
+            if optimizer is None:
+                optimizer = {}
             if 'first_fditer' not in optimizer:  # then add default first_fditer value
                 optimizer['first_fditer'] = default_first_fditer
-            self.optimizer = _opt.CustomLMOptimizer.cast(optimizer)
+            self.optimizer = _opt.SimplerLMOptimizer.cast(optimizer)
 
         self.objfn_builders = GSTObjFnBuilders.cast(objfn_builders)
 
@@ -1439,10 +1458,13 @@ class GateSetTomography(_proto.Protocol):
             target_model = self.gaugeopt_suite.gaugeopt_target
         elif self.initial_model.target_model is not None:
             target_model = self.initial_model.target_model.copy()
-        elif self.initial_model.model is not None and self.gaugeopt_suite.is_empty() is False:
+        elif self.initial_model.model is not None:
             # when we desparately need a target model but none have been specifically given: use initial model
             target_model = self.initial_model.model.copy()
         else:
+            msg = 'Could not identify a suitable target model, this may result'\
+                 +' in unexpected behavior or missing plots in reports.'
+            _warnings.warn(msg)
             target_model = None
 
         if target_model is not None and simulator is not None:
@@ -1451,10 +1473,22 @@ class GateSetTomography(_proto.Protocol):
         estimate = _Estimate.create_gst_estimate(ret, target_model, mdl_start, mdl_lsgst_list, parameters)
         ret.add_estimate(estimate, estimate_key=self.name)
 
-        return _add_gaugeopt_and_badfit(ret, self.name, target_model,
-                                        self.gaugeopt_suite, self.unreliable_ops,
-                                        self.badfit_options, self.optimizer, resource_alloc, printer)
-
+        #Add some better handling for when gauge optimization is turned off (current code path isn't working.)
+        if not self.gaugeopt_suite.is_empty() or len(self.badfit_options.actions) > 0:  # maybe add flag to do this even when empty?
+            ret = _add_gaugeopt_and_badfit(ret, self.name, target_model,
+                                           self.gaugeopt_suite, self.unreliable_ops,
+                                           self.badfit_options, self.optimizer, 
+                                           resource_alloc, printer)
+        else:
+            #add a model to the estimate that we'll call the trivial gauge optimized model which
+            #will be set to be equal to the final iteration estimate.
+            ret.estimates[self.name].models['trivial_gauge_opt'] = mdl_lsgst_list[-1]
+            #and add a key for this to the goparameters dict (this is what the report
+            #generation looks at to determine the names of the gauge optimized models).
+            #Set the value to None as a placeholder.
+            ret.estimates[self.name].goparameters['trivial_gauge_opt'] = None
+        
+        return ret
 
 class LinearGateSetTomography(_proto.Protocol):
     """
@@ -1504,6 +1538,10 @@ class LinearGateSetTomography(_proto.Protocol):
         self.oplabel_aliases = None
         self.unreliable_ops = ('Gcnot', 'Gcphase', 'Gms', 'Gcn', 'Gcx', 'Gcz')
 
+        self.auxfile_types['target_model'] = 'serialized-object'
+        self.auxfile_types['gaugeopt_suite'] = 'serialized-object'
+        self.auxfile_types['badfit_options'] = 'serialized-object'
+
     def check_if_runnable(self, data):
         """
         Raises a ValueError if LGST cannot be run on data
@@ -1612,9 +1650,22 @@ class LinearGateSetTomography(_proto.Protocol):
                                    'final iteration estimate': mdl_lgst},
                              parameters)
         ret.add_estimate(estimate, estimate_key=self.name)
-        return _add_gaugeopt_and_badfit(ret, self.name, target_model, self.gaugeopt_suite,
+
+        #Add some better handling for when gauge optimization is turned off (current code path isn't working.)
+        if not self.gaugeopt_suite.is_empty():
+            ret = _add_gaugeopt_and_badfit(ret, self.name, target_model, self.gaugeopt_suite,
                                         self.unreliable_ops, self.badfit_options,
                                         None, resource_alloc, printer)
+        else:
+            #add a model to the estimate that we'll call the trivial gauge optimized model which
+            #will be set to be equal to the final iteration estimate.
+            ret.estimates[self.name].models['trivial_gauge_opt'] = mdl_lgst
+            #and add a key for this to the goparameters dict (this is what the report
+            #generation looks at to determine the names of the gauge optimized models).
+            #Set the value to None as a placeholder.
+            ret.estimates[self.name].goparameters['trivial_gauge_opt'] = None
+
+        return ret
 
 
 class StandardGST(_proto.Protocol):
@@ -1646,6 +1697,14 @@ class StandardGST(_proto.Protocol):
         optimization (only), and is useful when you want to gauge optimize toward
         something other than the *ideal* target gates.
 
+    target_model : Model, optional (default None)
+        If specified use this Model as the target model. Depending on other
+        specified keyword arguments this model may be used as the target for
+        the purposes of gauge optimization, report generation/analysis, and
+        initial seeding for optimization. (For almost all of these it may be the
+        case that other keyword argument values override this for certain
+        tasks).
+
     models_to_test : dict, optional
         A dictionary of Model objects representing (gate-set) models to
         test against the data.  These Models are essentially hypotheses for
@@ -1694,12 +1753,12 @@ class StandardGST(_proto.Protocol):
         self.target_model = target_model
         self.gaugeopt_suite = GSTGaugeOptSuite.cast(gaugeopt_suite)
         self.objfn_builders = GSTObjFnBuilders.cast(objfn_builders) if (objfn_builders is not None) else None
-        self.optimizer = _opt.CustomLMOptimizer.cast(optimizer)
+        self.optimizer = _opt.SimplerLMOptimizer.cast(optimizer)
         self.badfit_options = GSTBadFitOptions.cast(badfit_options)
         self.verbosity = verbosity
 
         if not isinstance(optimizer, _opt.Optimizer) and isinstance(optimizer, dict) \
-           and 'first_fditer' not in optimizer:  # then a dict was cast into a CustomLMOptimizer above.
+           and 'first_fditer' not in optimizer:  # then a dict was cast into an Optimizer above.
             # by default, set special "first_fditer=auto" behavior (see logic in GateSetTomography.__init__)
             self.optimizer.first_fditer = None
 
@@ -1713,11 +1772,6 @@ class StandardGST(_proto.Protocol):
         #Advanced options that could be changed by users who know what they're doing
         self.starting_point = {}  # a dict whose keys are modes
 
-    #def run_using_germs_and_fiducials(self, dataset, target_model, prep_fiducials, meas_fiducials, germs, max_lengths):
-    #    design = StandardGSTDesign(target_model, prep_fiducials, meas_fiducials, germs, max_lengths)
-    #    data = _proto.ProtocolData(design, dataset)
-    #    return self.run(data)
-
     def run(self, data, memlimit=None, comm=None, checkpoint=None, checkpoint_path=None,
             disable_checkpointing=False, simulator: Optional[ForwardSimulator.Castable]=None):
         """
@@ -1864,7 +1918,7 @@ class StandardGST(_proto.Protocol):
 
                     #Try to interpret `mode` as a parameterization
                     parameterization = mode  # for now, 1-1 correspondence
-                    initial_model = target_model
+                    initial_model = target_model.copy()
 
                     try:
                         initial_model.set_all_parameterizations(parameterization)
@@ -1961,7 +2015,7 @@ def _add_gaugeopt_and_badfit(results, estlbl, target_model, gaugeopt_suite,
     profiler = resource_alloc.profiler
 
     #Do final gauge optimization to *final* iteration result only
-    if gaugeopt_suite:
+    if gaugeopt_suite is not None and not gaugeopt_suite.is_empty():
         model_to_gaugeopt = results.estimates[estlbl].models['final iteration estimate']
         if gaugeopt_suite.gaugeopt_target is None:  # add a default target model to gauge opt if needed
             #TODO: maybe make these two lines into a method of GSTGaugeOptSuite for adding a target model?
@@ -1970,7 +2024,7 @@ def _add_gaugeopt_and_badfit(results, estlbl, target_model, gaugeopt_suite,
         _add_gauge_opt(results, estlbl, gaugeopt_suite,
                        model_to_gaugeopt, unreliable_ops, comm, printer - 1)
         profiler.add_time('%s: gauge optimization' % estlbl, tref); tref = _time.time()
-        
+
         _add_badfit_estimates(results, estlbl, badfit_options, optimizer, resource_alloc, printer, gaugeopt_suite= gaugeopt_suite)
         profiler.add_time('%s: add badfit estimates' % estlbl, tref); tref = _time.time()
     else:
@@ -2039,26 +2093,31 @@ def _add_gauge_opt(results, base_est_label, gaugeopt_suite, starting_model,
 
         printer.log("-- Performing '%s' gauge optimization on %s estimate --" % (go_label, base_est_label), 2)
 
-        #Get starting model
-        results.estimates[base_est_label].add_gaugeoptimized(goparams, None, go_label, comm, printer - 3)
+        #add logic for the case where no gauge optimization is performed.
+        if go_label == 'none':
+            results.estimates[base_est_label].add_gaugeoptimized(goparams, starting_model, go_label, comm, printer - 3)
+        else:
+            results.estimates[base_est_label].add_gaugeoptimized(goparams, None, go_label, comm, printer - 3)
+        
+        #Get starting model for next stage
         mdl_start = results.estimates[base_est_label].retrieve_start_model(goparams)
-
-        #Gauge optimize data-scaled estimate also
-        for suffix in ROBUST_SUFFIX_LIST:
-            robust_est_label = base_est_label + suffix
-            if robust_est_label in results.estimates:
-                mdl_start_robust = results.estimates[robust_est_label].retrieve_start_model(goparams)
-
-                if mdl_start_robust.frobeniusdist(mdl_start) < 1e-8:
-                    printer.log("-- Conveying '%s' gauge optimization from %s to %s estimate --" %
-                                (go_label, base_est_label, robust_est_label), 2)
-                    params = results.estimates[base_est_label].goparameters[go_label]  # no need to copy here
-                    gsopt = results.estimates[base_est_label].models[go_label].copy()
-                    results.estimates[robust_est_label].add_gaugeoptimized(params, gsopt, go_label, comm, printer - 3)
-                else:
-                    printer.log("-- Performing '%s' gauge optimization on %s estimate --" %
-                                (go_label, robust_est_label), 2)
-                    results.estimates[robust_est_label].add_gaugeoptimized(goparams, None, go_label, comm, printer - 3)
+        if mdl_start is not None:
+            #Gauge optimize data-scaled estimate also
+            for suffix in ROBUST_SUFFIX_LIST:
+                robust_est_label = base_est_label + suffix
+                if robust_est_label in results.estimates:
+                    mdl_start_robust = results.estimates[robust_est_label].retrieve_start_model(goparams)
+
+                    if mdl_start_robust.frobeniusdist(mdl_start) < 1e-8:
+                        printer.log("-- Conveying '%s' gauge optimization from %s to %s estimate --" %
+                                    (go_label, base_est_label, robust_est_label), 2)
+                        params = results.estimates[base_est_label].goparameters[go_label]  # no need to copy here
+                        gsopt = results.estimates[base_est_label].models[go_label].copy()
+                        results.estimates[robust_est_label].add_gaugeoptimized(params, gsopt, go_label, comm, printer - 3)
+                    else:
+                        printer.log("-- Performing '%s' gauge optimization on %s estimate --" %
+                                    (go_label, robust_est_label), 2)
+                        results.estimates[robust_est_label].add_gaugeoptimized(goparams, None, go_label, comm, printer - 3)
 
 
 def _add_badfit_estimates(results, base_estimate_label, badfit_options,
@@ -2301,9 +2360,16 @@ def _compute_wildcard_budget_1d_model(estimate, objfn_cache, mdc_objfn, paramete
     if gaugeopt_suite is None or gaugeopt_suite.gaugeopt_suite_names is None:
         gaugeopt_labels = None
         primitive_ops = list(ref.keys())
+        if sum([v**2 for v in ref.values()]) < 1e-4:
+            _warnings.warn("Reference values for 1D wildcard budget are all near-zero!"
+                           "This usually indicates an incorrect target model and will likely cause problems computing alpha.")
+
     else:
         gaugeopt_labels = gaugeopt_suite.gaugeopt_suite_names
         primitive_ops = list(ref[list(gaugeopt_labels)[0]].keys())
+        if sum([v**2 for v in ref[list(gaugeopt_labels)[0]].values()]) < 1e-4:
+            _warnings.warn("Reference values for 1D wildcard budget are all near-zero!"
+                           "This usually indicates an incorrect target model and will likely cause problems computing alpha.")
 
     if gaugeopt_labels is None:
         wcm = _wild.PrimitiveOpsSingleScaleWildcardBudget(primitive_ops, [ref[k] for k in primitive_ops],
@@ -2328,21 +2394,38 @@ def _compute_1d_reference_values_and_name(estimate, badfit_options, gaugeopt_sui
         if gaugeopt_suite is None or gaugeopt_suite.gaugeopt_suite_names is None:
             final_model = estimate.models['final iteration estimate']
             target_model = estimate.models['target']
-            gaugeopt_model = _alg.gaugeopt_to_target(final_model, target_model)
+
+            if isinstance(final_model, _ExplicitOpModel):
+                gaugeopt_model = _alg.gaugeopt_to_target(final_model, target_model)
+                operations_dict = gaugeopt_model.operations
+                targetops_dict = target_model.operations
+                preps_dict = gaugeopt_model.preps
+                targetpreps_dict = target_model.preps
+                povmops_dict = gaugeopt_model.povms
+            else:
+                # Local/cloud noise models don't have default_gauge_group attribute and can't be gauge
+                #  optimized - at least not easily.
+                gaugeopt_model = final_model
+                operations_dict = gaugeopt_model.operation_blks['gates']
+                targetops_dict = target_model.operation_blks['gates']
+                preps_dict = gaugeopt_model.prep_blks['layers']
+                targetpreps_dict = target_model.prep_blks['layers']
+                povmops_dict = {}  # HACK - need to rewrite povm_diamonddist below to work
+
             dd = {}
-            for key, op in gaugeopt_model.operations.items():
-                dd[key] = 0.5 * _tools.diamonddist(op.to_dense(), target_model.operations[key].to_dense())
+            for key, op in operations_dict.items():
+                dd[key] = 0.5 * _tools.diamonddist(op.to_dense(), targetops_dict[key].to_dense())
                 if dd[key] < 0:  # indicates that diamonddist failed (cvxpy failure)
                     _warnings.warn(("Diamond distance failed to compute %s reference value for 1D wildcard budget!"
                                     " Falling back to trace distance.") % str(key))
-                    dd[key] = _tools.jtracedist(op.to_dense(), target_model.operations[key].to_dense())
+                    dd[key] = _tools.jtracedist(op.to_dense(), targetops_dict[key].to_dense())
 
             spamdd = {}
-            for key, op in gaugeopt_model.preps.items():
+            for key, op in preps_dict.items():
                 spamdd[key] = _tools.tracedist(_tools.vec_to_stdmx(op.to_dense(), 'pp'),
-                                               _tools.vec_to_stdmx(target_model.preps[key].to_dense(), 'pp'))
+                                               _tools.vec_to_stdmx(targetpreps_dict[key].to_dense(), 'pp'))
 
-            for key in gaugeopt_model.povms.keys():
+            for key in povmops_dict.keys():
                 spamdd[key] = 0.5 * _tools.optools.povm_diamonddist(gaugeopt_model, target_model, key)
 
             dd['SPAM'] = sum(spamdd.values())
@@ -2589,23 +2672,14 @@ def _compute_wildcard_budget(objfn_cache, mdc_objfn, parameters, badfit_options,
             elif method_name == "barrier":
                 _opt.optimize_wildcard_budget_barrier(budget, L1weights, mdc_objfn, two_dlogl_threshold,
                                                       redbox_threshold, printer, **method_options)
-            elif method_name == "cvxopt":
-                _opt.optimize_wildcard_budget_cvxopt(budget, L1weights, mdc_objfn, two_dlogl_threshold,
-                                                     redbox_threshold, printer, **method_options)
-            elif method_name == "cvxopt_smoothed":
-                _opt.optimize_wildcard_budget_cvxopt_smoothed(budget, L1weights, mdc_objfn,
-                                                              two_dlogl_threshold, redbox_threshold,
-                                                              printer, **method_options)
-            elif method_name == "cvxopt_small":
-                _opt.optimize_wildcard_budget_cvxopt_zeroreg(budget, L1weights, mdc_objfn,
-                                                             two_dlogl_threshold, redbox_threshold, printer,
-                                                             **method_options)
             elif method_name == "cvxpy_noagg":
                 _opt.optimize_wildcard_budget_percircuit_only_cvxpy(budget, L1weights, mdc_objfn,
                                                                     redbox_threshold, printer,
                                                                     **method_options)
             elif method_name == "none":
                 pass
+            elif method_name in ("cvxopt", "cvxopt_smoothed", "cvxopt_small"):
+                raise ValueError(f"Support for {method_name} was removed in pyGSTi release 0.9.13.")
             else:
                 raise ValueError("Invalid wildcard method name: %s" % method_name)
 

pygsti/protocols/modeltest.py

@@ -100,6 +100,7 @@ class ModelTest(_proto.Protocol):
                  set_trivial_gauge_group=True, verbosity=2, name=None):
 
         from .gst import GSTBadFitOptions as _GSTBadFitOptions
+        from .gst import GSTGaugeOptSuite as _GSTGaugeOptSuite
 
         if set_trivial_gauge_group:
             model_to_test = model_to_test.copy()
@@ -109,7 +110,7 @@ class ModelTest(_proto.Protocol):
         super().__init__(name)
         self.model_to_test = model_to_test
         self.target_model = target_model
-        self.gaugeopt_suite = gaugeopt_suite
+        self.gaugeopt_suite = _GSTGaugeOptSuite.cast(gaugeopt_suite)
         self.badfit_options = _GSTBadFitOptions.cast(badfit_options)
         self.verbosity = verbosity
 
@@ -127,12 +128,6 @@ class ModelTest(_proto.Protocol):
         self.circuit_weights = None
         self.unreliable_ops = ('Gcnot', 'Gcphase', 'Gms', 'Gcn', 'Gcx', 'Gcz')
 
-    #def run_using_germs_and_fiducials(self, model, dataset, target_model, prep_fiducials,
-    #                                  meas_fiducials, germs, maxLengths):
-    #    from .gst import StandardGSTDesign as _StandardGSTDesign
-    #    design = _StandardGSTDesign(target_model, prep_fiducials, meas_fiducials, germs, maxLengths)
-    #    return self.run(_proto.ProtocolData(design, dataset))
-
     def run(self, data, memlimit=None, comm=None, checkpoint=None, checkpoint_path=None, disable_checkpointing=False,
             simulator: Optional[ForwardSimulator.Castable]=None):
         """
@@ -179,6 +174,7 @@ class ModelTest(_proto.Protocol):
         the_model = self.model_to_test
         if simulator is not None:
             the_model.sim = simulator
+            
         target_model = self.target_model  # can be None; target model isn't necessary
 
         #Create profiler
@@ -281,8 +277,8 @@ class ModelTest(_proto.Protocol):
             models['target'] = target_model
         ret.add_estimate(_Estimate(ret, models, parameters, extra_parameters=extra_parameters), estimate_key=self.name)
 
-        #Add some better handling for when gauge optimization is turned off (current code path isn't working.
-        if self.gaugeopt_suite is not None:
+        #Add some better handling for when gauge optimization is turned off (current code path isn't working.)
+        if not self.gaugeopt_suite.is_empty():
             ret= _add_gaugeopt_and_badfit(ret, self.name, target_model, self.gaugeopt_suite,
                                             self.unreliable_ops, self.badfit_options,
                                             None, resource_alloc, printer)
@@ -293,8 +289,8 @@ class ModelTest(_proto.Protocol):
             #and add a key for this to the goparameters dict (this is what the report
             #generation looks at to determine the names of the gauge optimized models).
             #Set the value to None as a placeholder.
-            from .gst import GSTGaugeOptSuite
             ret.estimates[self.name].goparameters['trivial_gauge_opt']= None
+        
         return ret