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

pygsti/algorithms/rbfit.py

@@ -17,132 +17,6 @@ from pygsti.baseobjs.nicelyserializable import NicelySerializable as _NicelySeri
 from pygsti.tools import rbtools as _rbt
 
 
-# Obsolute function to be deleted.
-# def std_practice_analysis(RBSdataset, seed=[0.8, 0.95], bootstrap_samples=200, asymptote='std', rtype='EI',
-#                           datatype='auto'):
-#     """
-#     Implements a "standard practice" analysis of RB data. Fits the average success probabilities to the exponential
-#     decay A + Bp^m, using least-squares fitting, with (1) A fixed (as standard, to 1/2^n where n is the number of
-#     qubits the data is for), and (2) A, B and p all allowed to varying. Confidence intervals are also estimated using
-#     a standard non-parameteric boostrap.
-
-#     Parameters
-#     ----------
-#     RBSdataset : RBSummaryDataset
-#         An RBSUmmaryDataset containing the data to analyze
-
-#     seed : list, optional
-#         Seeds for the fit of B and p (A is seeded to the asymptote defined by `asympote`).
-
-#     bootstrap_samples : int, optional
-#         The number of samples in the bootstrap.
-
-#     asymptote : str or float, optional
-#         The A value for the fitting to A + Bp^m with A fixed. If a string must be 'std', in
-#         in which case A is fixed to 1/2^n.
-
-#     rtype : {'EI','AGI'}, optional
-#         The RB error rate rescaling convention. 'EI' results in RB error rates that are associated
-#         with the entanglement infidelity, which is the error probability with stochastic errors (and
-#         is equal to the diamond distance). 'AGI' results in RB error rates that are associated with
-#         average gate infidelity.
-
-#     Returns
-#     -------
-#     RBResults
-#         An object encapsulating the RB results (and data).
-
-#     """
-#     assert(datatype == 'raw' or datatype == 'adjusted' or datatype == 'auto'), "Unknown data type!"
-
-#     if datatype == 'auto':
-#         if RBSdataset.datatype == 'hamming_distance_counts':
-#             datatype = 'adjusted'
-#         else:
-#             datatype = 'raw'
-
-#     lengths = RBSdataset.lengths
-#     n = RBSdataset.num_qubits
-
-#     if isinstance(asymptote, str):
-#         assert(asymptote == 'std'), "If `asympotote` is a string it must be 'std'!"
-#         if datatype == 'raw':
-#             asymptote = 1 / 2**n
-#         elif datatype == 'adjusted':
-#             asymptote = 1 / 4**n
-
-#     if datatype == 'adjusted':
-#         ASPs = RBSdataset.adjusted_ASPs
-#     if datatype == 'raw':
-#         ASPs = RBSdataset.ASPs
-
-#     FF_results, FAF_results = std_least_squares_fit(lengths, ASPs, n, seed=seed, asymptote=asymptote,
-#                                                              ftype='full+FA', rtype=rtype)
-
-#     parameters = ['A', 'B', 'p', 'r']
-#     bootstraps_FF = {}
-#     bootstraps_FAF = {}
-
-#     if bootstrap_samples > 0:
-
-#         bootstraps_FF = {p: [] for p in parameters}
-#         bootstraps_FAF = {p: [] for p in parameters}
-#         failcount_FF = 0
-#         failcount_FAF = 0
-
-#         # Add bootstrapped data, if neccessary.
-#         RBSdataset.add_bootstrapped_datasets(samples=bootstrap_samples)
-
-#         for i in range(bootstrap_samples):
-
-#             if datatype == 'adjusted':
-#                 BS_ASPs = RBSdataset.bootstraps[i].adjusted_ASPs
-#             if datatype == 'raw':
-#                 BS_ASPs = RBSdataset.bootstraps[i].ASPs
-
-#             BS_FF_results, BS_FAF_results = std_least_squares_fit(lengths, BS_ASPs, n, seed=seed,
-#                                                                            asymptote=asymptote, ftype='full+FA',
-#                                                                            rtype=rtype)
-
-#             if BS_FF_results['success']:
-#                 for p in parameters:
-#                     bootstraps_FF[p].append(BS_FF_results['estimates'][p])
-#             else:
-#                 failcount_FF += 1
-#             if BS_FAF_results['success']:
-#                 for p in parameters:
-#                     bootstraps_FAF[p].append(BS_FAF_results['estimates'][p])
-#             else:
-#                 failcount_FAF += 1
-
-#         failrate_FF = failcount_FF / bootstrap_samples
-#         failrate_FAF = failcount_FAF / bootstrap_samples
-
-#         std_FF = {p: _np.std(_np.array(bootstraps_FF[p])) for p in parameters}
-#         std_FAF = {p: _np.std(_np.array(bootstraps_FAF[p])) for p in parameters}
-
-#     else:
-#         bootstraps_FF = None
-#         std_FF = None
-#         failrate_FF = None
-#         bootstraps_FAF = None
-#         std_FAF = None
-#         failrate_FAF = None
-
-#     fits = {}
-#     fits['full'] = FitResults('LS', FF_results['seed'], rtype, FF_results['success'], FF_results['estimates'],
-#                               FF_results['variable'], stds=std_FF, bootstraps=bootstraps_FF,
-#                               bootstraps_failrate=failrate_FF)
-
-#     fits['A-fixed'] = FitResults('LS', FAF_results['seed'], rtype, FAF_results['success'],
-#                                  FAF_results['estimates'], FAF_results['variable'], stds=std_FAF,
-#                                  bootstraps=bootstraps_FAF, bootstraps_failrate=failrate_FAF)
-
-#     results = SimpleRBResults(RBSdataset, rtype, fits)
-
-#     return results
-
-
 def std_least_squares_fit(lengths, asps, n, seed=None, asymptote=None, ftype='full', rtype='EI'):
     """
     Implements a "standard" least-squares fit of RB data.
@@ -469,111 +343,3 @@ class FitResults(_NicelySerializable):
         return cls(state['fit_type'], state['seed'], state['r_type'], state['success'],
                    state['estimates'], state['variable'], state['stds'],
                    state['bootstraps'], state['bootstraps_failrate'])
-
-# Obsolute RB results class
-# class SimpleRBResults(object):
-#     """
-#     An object to contain the results of an RB analysis.
-
-#     """
-
-#     def __init__(self, data, rtype, fits):
-#         """
-#         Initialize an RBResults object.
-
-#         Parameters
-#         ----------
-#         data : RBSummaryDataset
-#             The RB summary data that the analysis was performed for.
-
-#         rtype : {'IE','AGI'}
-#             The type of RB error rate, corresponding to different dimension-dependent
-#             re-scalings of (1-p), where p is the RB decay constant in A + B*p^m.
-
-#         fits : dict
-#             A dictionary containing FitResults objects, obtained from one or more
-#             fits of the data (e.g., a fit with all A, B and p as free parameters and
-#             a fit with A fixed to 1/2^n).
-#         """
-#         self.data = data
-#         self.rtype = rtype
-#         self.fits = fits
-
-#     def plot(self, fitkey=None, decay=True, success_probabilities=True, size=(8, 5), ylim=None, xlim=None,
-#              legend=True, title=None, figpath=None):
-#         """
-#         Plots RB data and, optionally, a fitted exponential decay.
-
-#         Parameters
-#         ----------
-#         fitkey : dict key, optional
-#             The key of the self.fits dictionary to plot the fit for. If None, will
-#             look for a 'full' key (the key for a full fit to A + Bp^m if the standard
-#             analysis functions are used) and plot this if possible. It otherwise checks
-#             that there is only one key in the dict and defaults to this. If there are
-#             multiple keys and none of them are 'full', `fitkey` must be specified when
-#             `decay` is True.
-
-#         decay : bool, optional
-#             Whether to plot a fit, or just the data.
-
-#         success_probabilities : bool, optional
-#             Whether to plot the success probabilities distribution, as a violin plot. (as well
-#             as the *average* success probabilities at each length).
-
-#         size : tuple, optional
-#             The figure size
-
-#         ylim, xlim : tuple, optional
-#             The x and y limits for the figure.
-
-#         legend : bool, optional
-#             Whether to show a legend.
-
-#         title : str, optional
-#             A title to put on the figure.
-
-#         figpath : str, optional
-#             If specified, the figure is saved with this filename.
-#         """
-
-#         # Future : change to a plotly plot.
-#         try: import matplotlib.pyplot as _plt
-#         except ImportError: raise ValueError("This function requires you to install matplotlib!")
-
-#         if decay and fitkey is None:
-#             allfitkeys = list(self.fits.keys())
-#             if 'full' in allfitkeys: fitkey = 'full'
-#             else:
-#                 assert(len(allfitkeys) == 1), \
-#                     "There are multiple fits and none have the key 'full'. Please specify the fit to plot!"
-#                 fitkey = allfitkeys[0]
-
-#         _plt.figure(figsize=size)
-#         _plt.plot(self.data.lengths, self.data.ASPs, 'o', label='Average success probabilities')
-
-#         if decay:
-#             lengths = _np.linspace(0, max(self.data.lengths), 200)
-#             A = self.fits[fitkey].estimates['A']
-#             B = self.fits[fitkey].estimates['B']
-#             p = self.fits[fitkey].estimates['p']
-#             _plt.plot(lengths, A + B * p**lengths,
-#                       label='Fit, r = {:.2} +/- {:.1}'.format(self.fits[fitkey].estimates['r'],
-#                                                               self.fits[fitkey].stds['r']))
-
-#         if success_probabilities:
-#             _plt.violinplot(list(self.data.success_probabilities), self.data.lengths, points=10, widths=1.,
-#                             showmeans=False, showextrema=False, showmedians=False)  # , label='Success probabilities')
-
-#         if title is not None: _plt.title(title)
-#         _plt.ylabel("Success probability")
-#         _plt.xlabel("RB sequence length $(m)$")
-#         _plt.ylim(ylim)
-#         _plt.xlim(xlim)
-
-#         if legend: _plt.legend()
-
-#         if figpath is not None: _plt.savefig(figpath, dpi=1000)
-#         else: _plt.show()
-
-#         return