def test_drift_characterization(self):
tds = pygsti.io.load_tddataset(compare_files +
"/timeseries_data_trunc.txt")
results_gst = drift.do_basic_drift_characterization(tds)
results_gst.any_drift_detect()
gstr = list(tds.keys())[0]
print(results_gst.global_drift_frequencies)
if bMPL:
results_gst.plot_power_spectrum()
results_gst.plot_power_spectrum(sequence=gstr, loc='upper right')
# This box constructs some GST objects, needed to create any sort of boxplot with GST data
# This manually specifies the germ and fiducial structure for the imported data.
fiducial_strs = ['{}', 'Gx', 'Gy', 'GxGx', 'GxGxGx', 'GyGyGy']
germ_strs = [
'Gi', 'Gx', 'Gy', 'GxGy', 'GxGyGi', 'GxGiGy', 'GxGiGi', 'GyGiGi',
'GxGxGiGy', 'GxGyGyGi', 'GxGxGyGxGyGy'
]
log2maxL = 1 # log2 of the maximum germ power
# Below we use the maxlength, germ and fuducial lists to create the GST structures needed for box plots.
fiducials = [
pygsti.objects.GateString(None, fs) for fs in fiducial_strs
]
germs = [pygsti.objects.GateString(None, gs) for gs in germ_strs]
max_lengths = [2**i for i in range(0, log2maxL)]
gssList = pygsti.construction.make_lsgst_structs(
std1Q_XYI.gates, fiducials, fiducials, germs, max_lengths)
w = pygsti.report.Workspace()
w.init_notebook_mode(connected=False, autodisplay=True)
# Create a boxplot of the maximum power in the power spectra for each sequence.
w.ColorBoxPlot('driftpwr',
gssList[-1],
None,
None,
driftresults=results_gst)
if bMPL:
results_gst.plot_most_drifty_probability(plot_data=True)
gstrs = [
pygsti.objects.GateString(None, '(Gx)^' + str(2**l))
for l in range(0, 1)
]
results_gst.plot_multi_estimated_probabilities(gstrs,
loc='upper right')
#More from bottom of tutorial:
fname = compare_files + "/timeseries_data_trunc.txt"
data_gst, indices_to_gstrs = drift.load_bitstring_data(fname)
gstrs_to_indices = results_gst.sequences_to_indices
parray_gst = drift.load_bitstring_probabilities(
fname, gstrs_to_indices)
def test_plot_creation(self):
w = pygsti.report.Workspace()
prepStrs = self.results.gatestring_lists['prep fiducials']
effectStrs = self.results.gatestring_lists['effect fiducials']
non_gatestring_strs = [ 'GxString', 'GyString' ]
plts = []
plts.append( w.BoxKeyPlot(prepStrs, effectStrs) )
plts.append( w.BoxKeyPlot(non_gatestring_strs, non_gatestring_strs) )
plts.append( w.ColorBoxPlot(("chi2","logl"), self.gss, self.ds, self.gs, boxLabels=True,
hoverInfo=True, sumUp=False, invert=False) )
plts.append( w.ColorBoxPlot(("chi2","logl"), self.gss, self.ds, self.gs, boxLabels=False,
hoverInfo=True, sumUp=True, invert=False) )
plts.append( w.ColorBoxPlot(("chi2","logl"), self.gss, self.ds, self.gs, boxLabels=False,
hoverInfo=True, sumUp=False, invert=True) )
plts.append( w.ColorBoxPlot(("chi2","logl"), self.gss, self.ds, self.gs, boxLabels=False,
hoverInfo=True, sumUp=False, invert=False, typ="scatter") )
mds = pygsti.objects.MultiDataSet()
mds.add_dataset("DS0",self.ds)
mds.add_dataset("DS1",self.ds)
dsc = pygsti.objects.DataComparator([self.ds,self.ds], gate_exclusions=['Gfoo'], gate_inclusions=['Gx','Gy','Gi'])
dsc2 = pygsti.objects.DataComparator(mds)
plts.append( w.ColorBoxPlot(("dscmp",), self.gss, None, self.gs, dscomparator=dsc) ) # dscmp with 'None' dataset specified
plts.append( w.ColorBoxPlot(("dscmp",), self.gss, None, self.gs, dscomparator=dsc2) )
tds = pygsti.io.load_tddataset(compare_files + "/timeseries_data_trunc.txt")
driftresults = drift.do_basic_drift_characterization(tds)
plts.append( w.ColorBoxPlot(("driftpv","driftpwr"), self.gss, self.ds, self.gs, boxLabels=False,
hoverInfo=True, sumUp=True, invert=False, driftresults=driftresults) )
with self.assertRaises(ValueError):
w.ColorBoxPlot(("foobar",), self.gss, self.ds, self.gs)
with self.assertRaises(ValueError):
w.ColorBoxPlot(("chi2",), self.gss, self.ds, self.gs, typ="foobar")
from pygsti.algorithms import directx as dx
#specs = pygsti.construction.build_spam_specs(
# prepStrs=prepStrs,
# effectStrs=effectStrs,
# prep_labels=list(self.gs.preps.keys()),
# effect_labels=self.gs.get_effect_labels() )
baseStrs = self.gss.get_basestrings()
directGatesets = dx.direct_mlgst_gatesets(
baseStrs, self.ds, prepStrs, effectStrs, self.tgt, svdTruncateTo=4)
plts.append( w.ColorBoxPlot(["chi2","logl","blank",'directchi2','directlogl'], self.gss,
self.ds, self.gs, boxLabels=False, directGSTgatesets=directGatesets) )
plts.append( w.ColorBoxPlot(["errorrate"], self.gss,
self.ds, self.gs, boxLabels=False, sumUp=True,
directGSTgatesets=directGatesets) )
gmx = np.identity(4,'d'); gmx[3,0] = 0.5
plts.append( w.MatrixPlot(gmx, -1,1, ['a','b','c','d'], ['e','f','g','h'], "X", "Y",
colormap = pygsti.report.colormaps.DivergingColormap(vmin=-2, vmax=2)) )
plts.append( w.MatrixPlot(gmx, -1,1, ['a','b','c','d'], ['e','f','g','h'], "X", "Y",colormap=None))
plts.append( w.GateMatrixPlot(gmx, -1,1, "pp", "in", "out", boxLabels=True) )
plts.append( w.PolarEigenvaluePlot([np.linalg.eigvals(self.gs.gates['Gx'])],["purple"],scale=1.5) )
plts.append( w.PolarEigenvaluePlot([np.linalg.eigvals(self.gs.gates['Gx'])],["purple"],amp=2.0) )
projections = np.zeros(16,'d')
plts.append( w.ProjectionsBoxPlot(projections, "pp", boxLabels=False) )
plts.append( w.ProjectionsBoxPlot(projections, "gm", boxLabels=True) )
plts.append( w.ProjectionsBoxPlot(np.zeros(9,'d'), "gm", boxLabels=True) ) # non-qubit case
plts.append( w.ProjectionsBoxPlot(np.zeros(64,'d'), "gm", boxLabels=True) ) # >2Q case
choievals = np.array([-0.03, 0.02, 0.04, 0.98])
choieb = np.array([0.05, 0.01, 0.02, 0.01])
plts.append( w.ChoiEigenvalueBarPlot(choievals, None) )
plts.append( w.ChoiEigenvalueBarPlot(choievals, choieb) )
plts.append( w.FitComparisonBarPlot(self.gss.Ls, self.results.gatestring_structs['iteration'],
self.results.estimates['default'].gatesets['iteration estimates'], self.ds,) )
plts.append( w.GramMatrixBarPlot(self.ds,self.tgt) )
plts.append( w.DatasetComparisonHistogramPlot(dsc, nbins=50, frequency=True,
log=True, display='pvalue'))
plts.append( w.DatasetComparisonHistogramPlot(dsc, nbins=None, frequency=True,
log=False, display='llr'))
with self.assertRaises(ValueError):
w.DatasetComparisonHistogramPlot(dsc, nbins=50, frequency=True,
log=False, display='foobar')
# Note: RandomizedBenchmarkingPlot is tested in extras/test_rb.py
#Now test table rendering in html
for i,plt in enumerate(plts):
print("Plot: %s" % str(type(plt)))
out_html = plt.render("html")
plt.saveas(temp_files + "/saved_plot_%d.html" % i)
plt.saveas(temp_files + "/saved_plot_%d.pkl" % i) #Note: plots don't need Pandas for pickling
if bLatex:
plt.saveas(temp_files + "/saved_plot_%d.pdf" % i)
with self.assertRaises(ValueError):
plt.saveas(temp_files + "/saved_plot_%d.foobar" % i) # Unknown file type
w.save_cache(temp_files + "/saved_workspace_cache1.pkl")
w.load_cache(temp_files + "/saved_workspace_cache1.pkl")
def test_single_sequence_1Q(self):
N = 5 # Counts per timestep
T = 100 # Number of timesteps
# The confidence of the statistical tests. Here we set it to 0.999, which means that
# if we detect drift we are 0.999 confident that we haven't incorrectly rejected the
# initial hypothesis of no drift.
confidence = 0.999
# A drifting probability to obtain the measurement outcome with index 1 (out of [0,1])
def pt_drift(t):
return 0.5 + 0.2 * np.cos(0.1 * t)
# A drift-free probability to obtain the measurement outcome with index 1 (out of [0,1])
def pt_nodrift(t):
return 0.5
# If we want the sequence to have a label, we define a list for this (here, a list of length 1).
# The labels can, but need not be, pyGSTi GateString objects.
sequences = [
pygsti.objects.GateString(None, 'Gx(Gi)^64Gx'),
]
# If we want the outcomes to have labels, we define a list for this.
outcomes = ['0', '1']
# Let's create some fake data by sampling from these p(t) at integer times. Here we have
# created a 1D array, but we could have instead created a 1 x 1 x 1 x T array.
data_1seq_drift = np.array(
[binomial(N, pt_drift(t)) for t in range(0, T)])
data_1seq_nodrift = np.array(
[binomial(N, pt_nodrift(t)) for t in range(0, T)])
# If we want frequencies in Hertz, we need to specify the timestep in seconds. If this isn't
# specified, the frequencies are given in 1/timestep with timestep defaulting to 1.
timestep = 1e-5
# We hand these 1D arrays to the analysis function, along with the number of counts, and other
# optional information
results_1seq_drift = drift.do_basic_drift_characterization(
data_1seq_drift,
counts=N,
outcomes=outcomes,
confidence=confidence,
timestep=timestep,
indices_to_sequences=sequences)
results_1seq_nodrift = drift.do_basic_drift_characterization(
data_1seq_nodrift,
counts=N,
outcomes=outcomes,
confidence=confidence,
timestep=timestep,
indices_to_sequences=sequences)
if bMPL:
results_1seq_drift.plot_power_spectrum()
results_1seq_nodrift.plot_power_spectrum()
print(results_1seq_drift.global_pvalue)
print(results_1seq_nodrift.global_pvalue)
# The power spectrum obtained after averaging over everthing
print(results_1seq_drift.global_power_spectrum[:4])
# The power spectrum obtained after averaging over everthing except sequence label
print(results_1seq_drift.ps_power_spectrum[0, :4])
# The power spectrum obtained after averaging over everthing except entity label
print(results_1seq_drift.pe_power_spectrum[0, :4])
# The power spectrum obtained after averaging over everthing except sequene and entity label
print(results_1seq_drift.pspe_power_spectrum[0, 0, :4])
# The two power spectra obtained after averaging over nothing
print(results_1seq_drift.pspepo_power_spectrum[0, 0, 0, :4])
print(results_1seq_drift.pspepo_power_spectrum[0, 0, 1, :4])
# Lets create an array of the true probability. This needs to be
# of dimension S x E x M x T
parray_1seq = np.zeros((1, 1, 2, T), float)
parray_1seq[0, 0, 0, :] = np.array([pt_drift(t) for t in range(0, T)])
parray_1seq[0, 0, 1, :] = 1 - parray_1seq[0, 0, 0, :]
# The measurement outcome index we want to look at (here the esimated p(t)
# for one index is just 1 - the p(t) for the other index, because we are
# looking at a two-outcome measurement).
outcome = 1
# If we hand the parray to the plotting function, it will also plot
# the true probability alongside our estimate from the data
if bMPL:
results_1seq_drift.plot_estimated_probability(sequence=0,
outcome=outcome,
parray=parray_1seq,
plot_data=True)
def test_single_sequence_multiQ(self):
outcomes = ['00', '01', '10', '11']
N = 10 # Counts per timestep
T = 1000 # Number of timesteps
# The drifting probabilities for the 4 outcomes
def pt00(t):
return (0.5 + 0.07 * np.cos(0.08 * t)) * (0.5 +
0.08 * np.cos(0.2 * t))
def pt01(t):
return (0.5 + 0.07 * np.cos(0.08 * t)) * (0.5 -
0.08 * np.cos(0.2 * t))
def pt10(t):
return (0.5 - 0.07 * np.cos(0.08 * t)) * (0.5 +
0.08 * np.cos(0.2 * t))
def pt11(t):
return (0.5 - 0.07 * np.cos(0.08 * t)) * (0.5 -
0.08 * np.cos(0.2 * t))
# Because of the type of input (>2 measurement outcomes), we must record the
# data in a 4D array (even though some of the dimensions are trivial)
data_multiqubit = np.zeros((1, 1, 4, T), float)
# Generate data from these p(t)
for t in range(0, T):
data_multiqubit[0, 0, :, t] = multinomial(
N,
[pt00(t), pt01(t), pt10(t), pt11(t)])
results_multiqubit_full = drift.do_basic_drift_characterization(
data_multiqubit, outcomes=outcomes, confidence=0.99)
print(results_multiqubit_full.global_drift_frequencies)
if bMPL:
results_multiqubit_full.plot_power_spectrum()
outcome = 0 # the outcome index associated with the '00' outcome
results_multiqubit_full.plot_power_spectrum(sequence=0,
entity=0,
outcome=outcome)
print(results_multiqubit_full.pspepo_drift_frequencies[0, 0, 0])
print(results_multiqubit_full.pspepo_drift_frequencies[0, 0, 1])
print(results_multiqubit_full.pspepo_drift_frequencies[0, 0, 2])
print(results_multiqubit_full.pspepo_drift_frequencies[0, 0, 3])
# Creates an array of the true probability.
parray_multiqubit_full = np.zeros((1, 1, 4, T), float)
parray_multiqubit_full[0, 0,
0, :] = np.array([pt00(t) for t in range(0, T)])
parray_multiqubit_full[0, 0,
1, :] = np.array([pt01(t) for t in range(0, T)])
parray_multiqubit_full[0, 0,
2, :] = np.array([pt10(t) for t in range(0, T)])
parray_multiqubit_full[0, 0,
3, :] = np.array([pt11(t) for t in range(0, T)])
if bMPL:
results_multiqubit_full.plot_estimated_probability(
sequence=0,
outcome=1,
plot_data=True,
parray=parray_multiqubit_full)
results_multiqubit_marg = drift.do_basic_drift_characterization(
data_multiqubit,
outcomes=outcomes,
marginalize='std',
confidence=0.99)
self.assertEqual(np.shape(results_multiqubit_marg.data),
(1, 2, 2, 1000))
if bMPL:
results_multiqubit_marg.plot_power_spectrum()
results_multiqubit_marg.plot_power_spectrum(sequence=0, entity=1)
results_multiqubit_marg.plot_power_spectrum(sequence=0, entity=0)
# Drift frequencies for the first qubit
print(results_multiqubit_marg.pe_drift_frequencies[0])
# Drift frequencies for the second qubit
print(results_multiqubit_marg.pe_drift_frequencies[1])
# Creates an array of the true probability.
parray_multiqubit_marg = np.zeros((1, 2, 2, T), float)
parray_multiqubit_marg[0, 0, 0, :] = np.array(
[pt00(t) + pt01(t) for t in range(0, T)])
parray_multiqubit_marg[0, 0, 1, :] = np.array(
[pt10(t) + pt11(t) for t in range(0, T)])
parray_multiqubit_marg[0, 1, 0, :] = np.array(
[pt00(t) + pt10(t) for t in range(0, T)])
parray_multiqubit_marg[0, 1, 1, :] = np.array(
[pt01(t) + pt11(t) for t in range(0, T)])
if bMPL:
results_multiqubit_marg.plot_estimated_probability(
sequence=0, entity=0, outcome=0, parray=parray_multiqubit_marg)
N = 10 # Counts per timestep
T = 1000 # Number of timesteps
outcomes = ['00', '01', '10', '11']
def pt_correlated00(t):
return 0.25 - 0.05 * np.cos(0.05 * t)
def pt_correlated01(t):
return 0.25 + 0.05 * np.cos(0.05 * t)
def pt_correlated10(t):
return 0.25 + 0.05 * np.cos(0.05 * t)
def pt_correlated11(t):
return 0.25 - 0.05 * np.cos(0.05 * t)
data_1seq_multiqubit = np.zeros((1, 1, 4, T), float)
for t in range(0, T):
pvec = [
pt_correlated00(t),
pt_correlated01(t),
pt_correlated10(t),
pt_correlated11(t)
]
data_1seq_multiqubit[0, 0, :, t] = multinomial(N, pvec)
results_correlatedrift_marg = drift.do_basic_drift_characterization(
data_1seq_multiqubit, outcomes=outcomes, marginalize='std')
results_correlatedrift_full = drift.do_basic_drift_characterization(
data_1seq_multiqubit, outcomes=outcomes, marginalize='none')
if bMPL:
results_correlatedrift_marg.plot_power_spectrum()
results_correlatedrift_full.plot_power_spectrum()