def test_labels_with_time_and_arguments(self):
#Label with time and args
l = L('Gx',(0,1),time=1.2, args=('1.4','1.7'))
self.assertEqual(l.time, 1.2)
self.assertEqual(l.args,('1.4','1.7'))
self.assertEqual(tuple(l), ('Gx', 4, '1.4', '1.7', 0, 1) )
l2 = L(('Gx',';1.4',';1.7',0,1,'!1.25'))
self.assertEqual(tuple(l2), ('Gx', 4, '1.4', '1.7', 0, 1) )
l3 = L(('Gx',';','1.4',';','1.7',0,1,'!',1.3))
self.assertEqual(tuple(l3), ('Gx', 4, '1.4', '1.7', 0, 1) )
self.assertTrue(l == l2 == l3)
#Time without args
l = L('Gx',(0,1),time=1.2)
self.assertEqual(l.time, 1.2)
self.assertEqual(l.args,())
self.assertEqual(tuple(l), ('Gx', 0, 1) )
#Args without time
l = L('Gx',(0,1),args=('1.4',))
self.assertEqual(l.time, 0)
self.assertEqual(l.args,('1.4',))
self.assertEqual(tuple(l), ('Gx', 3, '1.4', 0, 1) )
def test_only_nonzero_time_is_printed(self):
l = L('GrotX',(0,1),args=('1.4',))
self.assertEqual(str(l), "GrotX;1.4:0:1") # make sure we don't print time when it's not given (i.e. zero)
self.assertEqual(l.time, 0.0) # BUT l.time is still 0, not None
l = L('GrotX',(0,1),args=('1.4',),time=0.2)
self.assertEqual(str(l), "GrotX;1.4:0:1!0.2") # make sure we do print time when it's nonzero
self.assertEqual(l.time, 0.2)
def test_layerlizzard(self):
#Test this here b/c auto-gators are associated with parallel operation labels
availability = {'Gcnot': [(0,1)]}
mdl = pc.build_cloudnoise_model_from_hops_and_weights(
2, ['Gx','Gy','Gcnot'], {}, None, availability,
None, "line", maxIdleWeight=1, maxhops=1,
extraWeight1Hops=0, extraGateWeight=1, sparse=True,
sim_type="map", parameterization="H+S")
# mdl[('Gx',0)].factorops # Composed([fullTargetOp,fullIdleErr,fullLocalErr])
self.assertEqual( set(mdl.get_primitive_op_labels()), set([L('Gx',0), L('Gy',0), L('Gx',1), L('Gy',1), L('Gcnot',(0,1))]))
#But we can *compute* with circuits containing parallel labels...
parallelLbl = L( [('Gx',0),('Gy',1)] )
with self.assertRaises(KeyError):
mdl.operation_blks[parallelLbl]
opstr = pygsti.obj.Circuit( (parallelLbl,) )
probs = mdl.probs(opstr)
print(probs)
expected = { ('00',): 0.25, ('01',): 0.25, ('10',): 0.25, ('11',): 0.25 }
for k,v in probs.items():
self.assertAlmostEqual(v, expected[k])
def test_prs(self):
self.fwdsim.prs(L('rho0'), [L('Mdefault_0')],
Ls('Gx', 'Gx'),
clipTo=(-1, 1))
self.fwdsim.prs(L('rho0'), [L('Mdefault_0')],
Ls('Gx', 'Gx'),
clipTo=(-1, 1),
bUseScaling=True)
def test_python_string_conversion(self):
mdl = pygsti.obj.Circuit(None, stringrep="Gx^3Gy^2GxGz")
op_labels = (L('Gx'), L('Gy'), L('Gz'))
pystr = mdl.to_pythonstr(op_labels)
self.assertEqual(pystr, "AAABBAC")
gs2_tup = pygsti.obj.Circuit.from_pythonstr(pystr, op_labels)
self.assertEqual(gs2_tup, tuple(mdl))
def test_circuit_init(self):
#Check that parallel gate labels get converted to circuits properly
gstr = pygsti.obj.GateString(((('Gx', 0), ('Gy', 1)), ('Gcnot', 0, 1)))
c = pygsti.obj.Circuit(gatestring=gstr, num_lines=2)
print(c)
self.assertEqual(c.line_items, [[L(
('Gx', 0)), L(
('Gcnot', 0, 1))], [L(
('Gy', 1)), L(('Gcnot', 0, 1))]])
def test_python_string_conversion(self):
gs = pygsti.obj.GateString(None, stringRepresentation="Gx^3Gy^2GxGz")
gate_labels = (L('Gx'), L('Gy'), L('Gz'))
pystr = gs.to_pythonstr(gate_labels)
self.assertEqual(pystr, "AAABBAC")
gs2_tup = pygsti.obj.GateString.from_pythonstr(pystr, gate_labels)
self.assertEqual(gs2_tup, tuple(gs))
def test_label_time_is_not_hashed(self):
#Ensure that time is not considered in the equality (or hashing) of labels - it's a
# tag-along "comment" that does not change the real value of a Label.
l1 = L('Gx',time=1.2)
l2 = L('Gx')
self.assertEqual(l1,l2)
self.assertTrue(l1.time != l2.time)
l1 = L('Gx',(0,),time=1.2)
l2 = L('Gx',(0,))
self.assertEqual(l1,l2)
self.assertTrue(l1.time != l2.time)
def test_model_with_lgst_circuit_estimates(self):
model = directx.model_with_lgst_circuit_estimates(self.strs,
self.ds,
self.prepStrs,
self.effectStrs,
self.tgt,
svdTruncateTo=4,
verbosity=10)
# TODO assert correctness
model = directx.model_with_lgst_circuit_estimates(
self.strs,
self.ds,
self.prepStrs,
self.effectStrs,
self.tgt,
includeTargetOps=False,
svdTruncateTo=4,
verbosity=10)
# TODO assert correctness
circuit_labels = [L('G0'), L('G1'), L('G2'), L('G3'), L('G4'), L('G5')]
# circuit_labels = [L('G0'), L('G1'), L('G2'), L('G3')]
model = directx.model_with_lgst_circuit_estimates(
self.strs,
self.ds,
self.prepStrs,
self.effectStrs,
self.tgt,
circuitLabels=circuit_labels,
includeTargetOps=False,
svdTruncateTo=4,
verbosity=10)
self.assertEqual(set(model.operations.keys()), set(circuit_labels))
def testLabels(self):
labels = []
labels.append(pygsti.obj.Label('Gx', 0)) # a LabelTup
labels.append(pygsti.obj.Label('Gx', (0, 1))) # a LabelTup
labels.append(pygsti.obj.Label(('Gx', 0, 1))) # a LabelTup
labels.append(pygsti.obj.Label('Gx')) # a LabelStr
labels.append(pygsti.obj.Label('Gx', None)) #still a LabelStr
labels.append(pygsti.obj.Label([('Gx', 0), ('Gy', 0)
])) # a LabelTupTup of LabelTup objs
labels.append(pygsti.obj.Label(
(('Gx', None), ('Gy', None)))) # a LabelTupTup of LabelStr objs
labels.append(pygsti.obj.Label([
('Gx', 0)
])) # just a LabelTup b/c only one component
labels.append(pygsti.obj.Label([L('Gx'), L('Gy')
])) # a LabelTupTup of LabelStrs
labels.append(pygsti.obj.Label(L('Gx'))) # Init from another label
for l in labels:
native = l.tonative()
print(l, " (", type(l), "): native =", native)
if isinstance(l, pygsti.baseobjs.label.LabelTupTup):
print(
" comps: ", ", ".join(
["%s (%s)" % (c, str(type(c))) for c in l.components]))
from_native = pygsti.obj.Label(native)
self.assertEqual(from_native, l)
s = pickle.dumps(l)
l2 = pickle.loads(s)
self.assertEqual(type(l), type(l2))
j = jsoncodec.encode_obj(l, False)
#print("Json: ",j)
l3 = jsoncodec.decode_obj(j, False)
#print("Unjsoned ", l3, " a ",type(l3))
self.assertEqual(type(l), type(l3))
def test_alias_manips(self):
orig_list = pygsti.construction.circuit_list([('Gx', 'Gx'),
('Gx', 'Gy'),
('Gx', 'Gx', 'Gx'),
('Gy', 'Gy'), ('Gi', )])
list0 = pygsti.construction.translate_circuit_list(orig_list, None)
self.assertEqual(list0, orig_list)
list1 = pygsti.construction.translate_circuit_list(
orig_list, {
L('Gx'): (L('Gx2'), ),
L('Gy'): (L('Gy'), )
})
list2 = pygsti.construction.translate_circuit_list(
orig_list, {L('Gi'): (L('Gx'), L('Gx'), L('Gx'), L('Gx'))})
print(list1)
expected_list1 = pygsti.construction.circuit_list([('Gx2', 'Gx2'),
('Gx2', 'Gy'),
('Gx2',
'Gx2', 'Gx2'),
('Gy', 'Gy'),
('Gi', )])
expected_list2 = pygsti.construction.circuit_list([('Gx', 'Gx'),
('Gx', 'Gy'),
('Gx', 'Gx', 'Gx'),
('Gy', 'Gy'),
('Gx', 'Gx', 'Gx',
'Gx')])
self.assertEqual(list1, expected_list1)
self.assertEqual(list2, expected_list2)
aliasDict1 = {'A': ('B', 'B')}
aliasDict2 = {'B': ('C', 'C')}
aliasDict3 = pygsti.construction.compose_alias_dicts(
aliasDict1, aliasDict2)
self.assertEqual(aliasDict3, {'A': ('C', 'C', 'C', 'C')})
def test_autogator(self):
#Test this here b/c auto-gators are associated with parallel gate labels
gs = pc.build_nqnoise_gateset(2,
"line", [(0, 1)],
maxIdleWeight=2,
maxhops=1,
extraWeight1Hops=0,
extraGateWeight=1,
verbosity=1,
sim_type="map",
parameterization="H+S",
sparse=True)
# gs[('Gx',0)].factorgates # Composed([fullTargetOp,fullIdleErr,fullLocalErr])
self.assertEqual(
set(gs.gates.keys()),
set([
L('Gi'),
L('Gx', 0),
L('Gy', 0),
L('Gx', 1),
L('Gy', 1),
L('Gcnot', (0, 1))
]))
#But we can *compute* with gatestrings containing parallel labels...
parallelLbl = L([('Gx', 0), ('Gy', 1)])
with self.assertRaises(KeyError):
gs.gates[parallelLbl]
gstr = pygsti.obj.GateString((parallelLbl, ))
probs = gs.probs(gstr)
print(probs)
expected = {
('00', ): 0.25,
('01', ): 0.25,
('10', ): 0.25,
('11', ): 0.25
}
for k, v in probs.items():
self.assertAlmostEqual(v, expected[k])
def setUpClass(cls):
"""
Handle all once-per-class (slow) computation and loading,
to avoid calling it for each test (like setUp). Store
results in class variable for use within setUp.
"""
super(CalcMethods1QTestCase, cls).setUpClass()
#Change to test_packages directory (since setUp hasn't been called yet...)
origDir = os.getcwd()
os.chdir(os.path.abspath(os.path.dirname(__file__)))
os.chdir('..') # The test_packages directory
#Standard GST dataset
cls.maxLengths = [1, 2, 4]
cls.mdl_datagen = std.target_model().depolarize(op_noise=0.1,
spam_noise=0.001)
cls.listOfExperiments = pygsti.construction.make_lsgst_experiment_list(
std.target_model(), std.prepStrs, std.effectStrs, std.germs,
cls.maxLengths)
#RUN BELOW FOR DATAGEN (UNCOMMENT to regenerate) (SAVE)
if os.environ.get(
'PYGSTI_REGEN_REF_FILES',
'no').lower() in ("yes", "1", "true",
"v2"): # "v2" to only gen version-dep files
ds = pygsti.construction.generate_fake_data(
cls.mdl_datagen,
cls.listOfExperiments,
nSamples=1000,
sampleError="multinomial",
seed=1234)
ds.save(compare_files +
"/calcMethods1Q.dataset%s" % cls.versionsuffix)
#DEBUG TEST- was to make sure data files have same info -- seemed ultimately unnecessary
#ds_swp = pygsti.objects.DataSet(fileToLoadFrom=compare_files + "/calcMethods1Q.datasetv3") # run in Python3
#pygsti.io.write_dataset(temp_files + "/dataset.3to2.txt", ds_swp) # run in Python3
#ds_swp = pygsti.io.load_dataset(temp_files + "/dataset.3to2.txt") # run in Python2
#ds_swp.save(compare_files + "/calcMethods1Q.dataset") # run in Python2
#assert(False),"STOP"
cls.ds = pygsti.objects.DataSet(
fileToLoadFrom=compare_files +
"/calcMethods1Q.dataset%s" % cls.versionsuffix)
#Reduced model GST dataset
cls.nQubits = 1 # can't just change this now - see opLabels below
cls.mdl_redmod_datagen = build_XYCNOT_cloudnoise_model(
cls.nQubits,
geometry="line",
maxIdleWeight=1,
maxhops=1,
extraWeight1Hops=0,
extraGateWeight=1,
sparse=False,
sim_type="matrix",
verbosity=1,
roughNoise=(1234, 0.01))
#Create a reduced set of fiducials and germs
opLabels = [('Gx', 0), ('Gy', 0)] # 1Q gate labels
fids1Q = std1Q_XY.fiducials[0:2] # for speed
cls.redmod_fiducials = []
for i in range(cls.nQubits):
cls.redmod_fiducials.extend(
pygsti.construction.manipulate_circuit_list(
fids1Q, [((L('Gx'), ), (L('Gx', i), )),
((L('Gy'), ), (L('Gy', i), ))]))
#print(redmod_fiducials, "Fiducials")
cls.redmod_germs = pygsti.construction.circuit_list([
(gl, ) for gl in opLabels
])
cls.redmod_maxLs = [1]
expList = pygsti.construction.make_lsgst_experiment_list(
opLabels, cls.redmod_fiducials, cls.redmod_fiducials,
cls.redmod_germs, cls.redmod_maxLs)
#RUN BELOW FOR DATAGEN (UNCOMMENT to regenerate) (SAVE)
if os.environ.get(
'PYGSTI_REGEN_REF_FILES',
'no').lower() in ("yes", "1", "true",
"v2"): # "v2" to only gen version-dep files
redmod_ds = pygsti.construction.generate_fake_data(
cls.mdl_redmod_datagen, expList, 1000, "round", seed=1234)
redmod_ds.save(compare_files + "/calcMethods1Q_redmod.dataset%s" %
cls.versionsuffix)
cls.redmod_ds = pygsti.objects.DataSet(
fileToLoadFrom=compare_files +
"/calcMethods1Q_redmod.dataset%s" % cls.versionsuffix)
#print(len(expList)," reduced model sequences")
#Random starting points - little kick so we don't get hung up at start
np.random.seed(1234)
cls.rand_start18 = np.random.random(18) * 1e-6
cls.rand_start25 = np.random.random(30) * 1e-6 # TODO: rename?
cls.rand_start36 = np.random.random(30) * 1e-6 # TODO: rename?
#Circuit Simulation circuits
cls.csim_nQubits = 3
cls.circuit1 = pygsti.obj.Circuit(('Gx', 'Gy'))
# now Circuit adds qubit labels... pygsti.obj.Circuit(layer_labels=('Gx','Gy'), num_lines=1) # 1-qubit circuit
cls.circuit3 = pygsti.obj.Circuit(layer_labels=[('Gxpi', 0),
('Gypi', 1),
('Gcnot', 1, 2)],
num_lines=3) # 3-qubit circuit
os.chdir(origDir) # return to original directory
def test_hoperation(self):
hg = self.fwdsim.hoperation(L('Gx'), flat=False)
hgflat = self.fwdsim.hoperation(L('Gx'), flat=True)
def test_3Q(self):
nQubits = 3
print("Constructing Target Gate Set")
gs_target = pygsti.construction.build_nqnoise_gateset(
nQubits,
geometry="line",
maxIdleWeight=1,
maxhops=1,
extraWeight1Hops=0,
extraGateWeight=1,
sparse=True,
sim_type="map",
verbosity=1)
#print("nElements test = ",gs_target.num_elements())
#print("nParams test = ",gs_target.num_params())
#print("nNonGaugeParams test = ",gs_target.num_nongauge_params())
print("Constructing Datagen Gate Set")
gs_datagen = pygsti.construction.build_nqnoise_gateset(
nQubits,
geometry="line",
maxIdleWeight=1,
maxhops=1,
extraWeight1Hops=0,
extraGateWeight=1,
sparse=True,
verbosity=1,
gateNoise=(1234, 0.1),
prepNoise=(456, 0.01),
povmNoise=(789, 0.01),
sim_type="map")
gs_test = gs_datagen
print(
"Constructed gateset with %d gates, dim=%d, and nParams=%d. Norm(paramvec) = %g"
% (len(gs_test.gates), gs_test.dim, gs_test.num_params(),
np.linalg.norm(gs_test.to_vector())))
gateLabels = list(gs_target.gates.keys())
fids1Q = std1Q_XY.fiducials
fiducials = []
for i in range(nQubits):
fiducials.extend(
pygsti.construction.manipulate_gatestring_list(
fids1Q, [((L('Gx'), ), (L('Gx', i), )),
((L('Gy'), ), (L('Gy', i), ))]))
print(len(fiducials), "Fiducials")
prep_fiducials = meas_fiducials = fiducials
#TODO: add fiducials for 2Q pairs (edges on graph)
germs = pygsti.construction.gatestring_list([(gl, )
for gl in gateLabels])
maxLs = [1]
expList = pygsti.construction.make_lsgst_experiment_list(
gs_datagen, prep_fiducials, meas_fiducials, germs, maxLs)
self.assertTrue(() in expList)
ds = pygsti.construction.generate_fake_data(gs_datagen,
expList,
1000,
"multinomial",
seed=1234)
print("Created Dataset with %d strings" % len(ds))
logL = pygsti.tools.logl(gs_datagen, ds, expList)
max_logL = pygsti.tools.logl_max(gs_datagen, ds, expList)
twoDeltaLogL = 2 * (max_logL - logL)
chi2 = pygsti.tools.chi2(gs_datagen, ds, expList)
dof = ds.get_degrees_of_freedom()
nParams = gs_datagen.num_params()
print("Datagen 2DeltaLogL = 2(%g-%g) = %g" %
(logL, max_logL, twoDeltaLogL))
print("Datagen chi2 = ", chi2)
print("Datagen expected DOF = ", dof)
print("nParams = ", nParams)
print("Expected 2DeltaLogL or chi2 ~= %g-%g =%g" %
(dof, nParams, dof - nParams))
#print("EXIT"); exit()
return
results = pygsti.do_long_sequence_gst(
ds,
gs_target,
prep_fiducials,
meas_fiducials,
germs,
maxLs,
verbosity=5,
advancedOptions={
'maxIterations': 2
}) #keep this short; don't care if it doesn't converge.
print("DONE!")
def test_circuit_init(self):
#Check that parallel operation labels get converted to circuits properly
opstr = pygsti.obj.Circuit( ((('Gx',0),('Gy',1)),('Gcnot',0,1)) )
c = pygsti.obj.Circuit(layer_labels=opstr, num_lines=2)
print(c._labels)
self.assertEqual(c._labels, ( L( (('Gx',0),('Gy',1)) ), L('Gcnot',(0,1)) ))
def test_direct_core(self):
mdl = directx.model_with_lgst_circuit_estimates(self.strs,
self.ds,
self.prepStrs,
self.effectStrs,
self.tgt,
includeTargetOps=True,
circuitLabels=None,
svdTruncateTo=4,
verbosity=10)
mdl = directx.model_with_lgst_circuit_estimates(self.strs,
self.ds,
self.prepStrs,
self.effectStrs,
self.tgt,
includeTargetOps=False,
circuitLabels=[
L('G0'),
L('G1'),
L('G2'),
L('G3'),
L('G4'),
L('G5')
],
svdTruncateTo=4,
verbosity=10)
self.assertEqual(
set(mdl.operations.keys()),
set([L('G0'), L('G1'),
L('G2'), L('G3'),
L('G4'), L('G5')]))
aliases = {'Gy2': ('Gy', )}
mdl = directx.model_with_lgst_circuit_estimates(
[pygsti.obj.Circuit(('Gy2', ))],
self.ds,
self.prepStrs,
self.effectStrs,
self.tgt,
includeTargetOps=True,
circuitLabels=None,
svdTruncateTo=4,
verbosity=10,
opLabelAliases=aliases)
def test_MLGST(self):
ds = self.ds
#pygsti.construction.generate_fake_data(self.datagen_gateset, self.lsgstStrings[-1],
# nSamples=1000, sampleError='binomial', seed=100)
mdl_lgst = pygsti.do_lgst(ds, self.fiducials, self.fiducials, self.model, svdTruncateTo=4, verbosity=0)
mdl_lgst_go = pygsti.gaugeopt_to_target(mdl_lgst,self.model, {'spam':1.0, 'gates': 1.0}, checkJac=True)
mdl_clgst = pygsti.contract(mdl_lgst_go, "CPTP")
mdl_clgst = mdl_clgst.depolarize(op_noise=0.02, spam_noise=0.02) # just to avoid infinity objective funct & jacs below
CM = pygsti.baseobjs.profiler._get_mem_usage()
mdl_single_mlgst = pygsti.do_mlgst(ds, mdl_clgst, self.lsgstStrings[0], minProbClip=1e-4,
probClipInterval=(-1e2,1e2), verbosity=0)
#this test often gives an assetion error "finite Jacobian has inf norm!" on Travis CI Python 3 case
try:
mdl_single_mlgst_cpsp = pygsti.do_mlgst(ds, mdl_clgst, self.lsgstStrings[0], minProbClip=1e-4,
probClipInterval=(-1e2,1e2), cptp_penalty_factor=1.0,
spam_penalty_factor=1.0, verbosity=10) #uses both penalty factors w/verbosity > 0
except ValueError: pass # ignore when assertions in customlm.py are disabled
except AssertionError:
pass # just ignore for now. FUTURE: see what we can do in custom LM about scaling large jacobians...
try:
mdl_single_mlgst_cp = pygsti.do_mlgst(ds, mdl_clgst, self.lsgstStrings[0], minProbClip=1e-4,
probClipInterval=(-1e2,1e2), cptp_penalty_factor=1.0,
verbosity=10)
except ValueError: pass # ignore when assertions in customlm.py are disabled
except AssertionError:
pass # just ignore for now. FUTURE: see what we can do in custom LM about scaling large jacobians...
try:
mdl_single_mlgst_sp = pygsti.do_mlgst(ds, mdl_clgst, self.lsgstStrings[0], minProbClip=1e-4,
probClipInterval=(-1e2,1e2), spam_penalty_factor=1.0,
verbosity=10)
except ValueError: pass # ignore when assertions in customlm.py are disabled
except AssertionError:
pass # just ignore for now. FUTURE: see what we can do in custom LM about scaling large jacobians...
mdl_mlegst = pygsti.do_iterative_mlgst(ds, mdl_clgst, self.lsgstStrings, verbosity=0,
minProbClip=1e-4, probClipInterval=(-1e2,1e2),
memLimit=CM + 1024**3)
maxLogL, all_gs_mlegst_tups = pygsti.do_iterative_mlgst(
ds, mdl_clgst, [ [mdl.tup for mdl in gsList] for gsList in self.lsgstStrings],
minProbClip=1e-4, probClipInterval=(-1e2,1e2), returnAll=True, returnMaxLogL=True)
mdl_mlegst_verb = self.runSilent(pygsti.do_iterative_mlgst, ds, mdl_clgst, self.lsgstStrings, verbosity=10,
minProbClip=1e-4, probClipInterval=(-1e2,1e2),
memLimit=CM + 1024**3)
self.assertAlmostEqual(mdl_mlegst.frobeniusdist(mdl_mlegst_verb),0, places=5)
self.assertAlmostEqual(mdl_mlegst.frobeniusdist(all_gs_mlegst_tups[-1]),0,places=5)
#Run internal checks on less max-L values (so it doesn't take forever)
mdl_mlegst_chk = pygsti.do_iterative_mlgst(ds, mdl_clgst, self.lsgstStrings[0:2], verbosity=0,
minProbClip=1e-4, probClipInterval=(-1e2,1e2),
check=True)
#Other option variations - just make sure they run at this point
mdl_mlegst_chk_opts = pygsti.do_iterative_mlgst(ds, mdl_clgst, self.lsgstStrings[0:2], verbosity=0,
minProbClip=1e-4, probClipInterval=(-1e2,1e2),
circuitSetLabels=["Set1","Set2"], useFreqWeightedChiSq=True,
circuitWeightsDict={ (L('Gx'),): 2.0 } )
aliased_list = [ pygsti.obj.Circuit( [ (x if x != L("Gx") else L("GA1")) for x in mdl]) for mdl in self.lsgstStrings[0] ]
mdl_withA1 = mdl_clgst.copy(); mdl_withA1.operations["GA1"] = mdl_clgst.operations["Gx"]
del mdl_withA1.operations["Gx"] # otherwise mdl_withA1 will have Gx params that we have no knowledge of!
mdl_mlegst_chk_opts2 = pygsti.do_mlgst(ds, mdl_withA1, aliased_list, minProbClip=1e-4,
probClipInterval=(-1e2,1e2), verbosity=10,
opLabelAliases={ L('GA1'): (L('Gx'),) })
#Other option variations - just make sure they run at this point
mdl_mlegst_chk_opts3 = pygsti.do_iterative_mlgst(ds, mdl_clgst, self.lsgstStrings[0:2], verbosity=0,
minProbClip=1e-4, probClipInterval=(-1e2,1e2),
circuitSetLabels=["Set1","Set2"], useFreqWeightedChiSq=True,
circuitWeightsDict={ (L('Gx'),): 2.0 }, alwaysPerformMLE=True )
#Forcing function used by linear response error bars
forcingfn_grad = np.ones((1,mdl_clgst.num_params()), 'd')
mdl_lsgst_chk_opts3 = pygsti.algorithms.core._do_mlgst_base(
ds, mdl_clgst, self.lsgstStrings[0], verbosity=0,
minProbClip=1e-4, probClipInterval=(-1e2,1e2),
forcefn_grad=forcingfn_grad)
with self.assertRaises(NotImplementedError):
# Non-poisson picture needs support for a non-leastsq solver (not impl yet)
mdl_lsgst_chk_opts4 = pygsti.algorithms.core._do_mlgst_base(
ds, mdl_clgst, self.lsgstStrings[0], verbosity=0, poissonPicture=False,
minProbClip=1e-4, probClipInterval=(-1e2,1e2),
forcefn_grad=forcingfn_grad) # non-poisson picture
#Check with small but ok memlimit -- not anymore since new mem estimation uses current memory, making this non-robust
#self.runSilent(pygsti.do_mlgst, ds, mdl_clgst, self.lsgstStrings[0], minProbClip=1e-6,
# probClipInterval=(-1e2,1e2), verbosity=4, memLimit=curMem+8500000) #invoke memory control
#non-Poisson picture - should use (-1,-1) model for consistency?
with self.assertRaises(NotImplementedError):
# Non-poisson picture needs support for a non-leastsq solver (not impl yet)
pygsti.do_mlgst(ds, mdl_clgst, self.lsgstStrings[0], minProbClip=1e-4,
probClipInterval=(-1e2,1e2), verbosity=0, poissonPicture=False)
try:
pygsti.do_mlgst(ds, mdl_clgst, self.lsgstStrings[0], minProbClip=1e-1, # 1e-1 b/c get inf Jacobians...
probClipInterval=(-1e2,1e2), verbosity=0, poissonPicture=False,
spam_penalty_factor=1.0, cptp_penalty_factor=1.0)
except ValueError: pass # ignore when assertions in customlm.py are disabled
except AssertionError:
pass # just ignore for now. FUTURE: see what we can do in custom LM about scaling large jacobians...
#Check errors:
with self.assertRaises(MemoryError):
pygsti.do_mlgst(ds, mdl_clgst, self.lsgstStrings[0], minProbClip=1e-4,
probClipInterval=(-1e2,1e2),verbosity=0, memLimit=1)
# RUN BELOW LINES TO SEED SAVED GATESET FILES
if os.environ.get('PYGSTI_REGEN_REF_FILES','no').lower() in ("yes","1","true"):
pygsti.io.write_model(mdl_mlegst,compare_files + "/mle_gst.model", "Saved MLE-GST Model")
mdl_mle_compare = pygsti.io.load_model(compare_files + "/mle_gst.model")
mdl_mlegst_go = pygsti.gaugeopt_to_target(mdl_mlegst, mdl_mle_compare, {'spam':1.0}, checkJac=True)
self.assertAlmostEqual( mdl_mlegst_go.frobeniusdist(mdl_mle_compare), 0, places=4)
def test_MC2GST(self):
ds = self.ds
#pygsti.construction.generate_fake_data(self.datagen_gateset, self.lsgstStrings[-1],
# nSamples=1000, sampleError='binomial', seed=100)
mdl_lgst = pygsti.do_lgst(ds, self.fiducials, self.fiducials, self.model, svdTruncateTo=4, verbosity=0)
mdl_lgst_go = pygsti.gaugeopt_to_target(mdl_lgst,self.model, {'spam':1.0, 'gates': 1.0}, checkJac=True)
mdl_clgst = pygsti.contract(mdl_lgst_go, "CPTP")
CM = pygsti.baseobjs.profiler._get_mem_usage()
mdl_single_lsgst = pygsti.do_mc2gst(ds, mdl_clgst, self.lsgstStrings[0], minProbClipForWeighting=1e-4,
probClipInterval=(-1e6,1e6), regularizeFactor=1e-3,
verbosity=0) #uses regularizeFactor
mdl_single_lsgst_cp = pygsti.do_mc2gst(ds, mdl_clgst, self.lsgstStrings[0], minProbClipForWeighting=1e-4,
probClipInterval=(-1e6,1e6), cptp_penalty_factor=1.0,
verbosity=0) #uses cptp_penalty_factor
mdl_single_lsgst_sp = pygsti.do_mc2gst(ds, mdl_clgst, self.lsgstStrings[0], minProbClipForWeighting=1e-4,
probClipInterval=(-1e6,1e6), spam_penalty_factor=1.0,
verbosity=0) #uses spam_penalty_factor
mdl_single_lsgst_cpsp = pygsti.do_mc2gst(ds, mdl_clgst, self.lsgstStrings[0], minProbClipForWeighting=1e-4,
probClipInterval=(-1e6,1e6), cptp_penalty_factor=1.0,
spam_penalty_factor=1.0, verbosity=0) #uses both penalty factors
mdl_single_lsgst_cpsp = self.runSilent(pygsti.do_mc2gst, ds, mdl_clgst, self.lsgstStrings[0], minProbClipForWeighting=1e-4,
probClipInterval=(-1e6,1e6), cptp_penalty_factor=1.0,
spam_penalty_factor=1.0, verbosity=10) #uses both penalty factors w/verbosity high
mdl_single_lsgst_cp = self.runSilent(pygsti.do_mc2gst, ds, mdl_clgst, self.lsgstStrings[0], minProbClipForWeighting=1e-4,
probClipInterval=(-1e6,1e6), cptp_penalty_factor=1.0,
verbosity=10) #uses cptp_penalty_factor w/verbosity high
mdl_single_lsgst_sp = self.runSilent(pygsti.do_mc2gst, ds, mdl_clgst, self.lsgstStrings[0], minProbClipForWeighting=1e-4,
probClipInterval=(-1e6,1e6), spam_penalty_factor=1.0,
verbosity=10) #uses spam_penalty_factor w/verbosity high
mdl_lsgst = pygsti.do_iterative_mc2gst(ds, mdl_clgst, self.lsgstStrings, verbosity=0,
minProbClipForWeighting=1e-6, probClipInterval=(-1e6,1e6),
memLimit=CM + 1024**3)
all_minErrs, all_gs_lsgst_tups = pygsti.do_iterative_mc2gst(
ds, mdl_clgst, [ [mdl.tup for mdl in gsList] for gsList in self.lsgstStrings],
minProbClipForWeighting=1e-6, probClipInterval=(-1e6,1e6), returnAll=True, returnErrorVec=True)
mdl_lsgst_verb = self.runSilent(pygsti.do_iterative_mc2gst, ds, mdl_clgst, self.lsgstStrings, verbosity=10,
minProbClipForWeighting=1e-6, probClipInterval=(-1e6,1e6),
memLimit=CM + 1024**3)
mdl_lsgst_reg = self.runSilent(pygsti.do_iterative_mc2gst,ds, mdl_clgst,
self.lsgstStrings, verbosity=10,
minProbClipForWeighting=1e-6,
probClipInterval=(-1e6,1e6),
regularizeFactor=10, memLimit=CM + 1024**3)
self.assertAlmostEqual(mdl_lsgst.frobeniusdist(mdl_lsgst_verb),0)
self.assertAlmostEqual(mdl_lsgst.frobeniusdist(all_gs_lsgst_tups[-1]),0)
#Run internal checks on less max-L values (so it doesn't take forever)
mdl_lsgst_chk = pygsti.do_iterative_mc2gst(ds, mdl_clgst, self.lsgstStrings[0:2], verbosity=0,
minProbClipForWeighting=1e-6, probClipInterval=(-1e6,1e6),
check=True, check_jacobian=True)
mdl_lsgst_chk_verb = self.runSilent(pygsti.do_iterative_mc2gst, ds, mdl_clgst, self.lsgstStrings[0:2], verbosity=10,
minProbClipForWeighting=1e-6, probClipInterval=(-1e6,1e6),
check=True, check_jacobian=True, memLimit=CM + 1024**3)
#Other option variations - just make sure they run at this point
mdl_lsgst_chk_opts = pygsti.do_iterative_mc2gst(ds, mdl_clgst, self.lsgstStrings[0:2], verbosity=0,
minProbClipForWeighting=1e-6, probClipInterval=(-1e6,1e6),
useFreqWeightedChiSq=True, circuitSetLabels=["Set1","Set2"],
circuitWeightsDict={ ('Gx',): 2.0 } )
aliased_list = [ pygsti.obj.Circuit( [ (x if x != L("Gx") else L("GA1")) for x in mdl]) for mdl in self.lsgstStrings[0] ]
mdl_withA1 = mdl_clgst.copy(); mdl_withA1.operations["GA1"] = mdl_clgst.operations["Gx"]
del mdl_withA1.operations["Gx"] # otherwise mdl_withA1 will have Gx params that we have no knowledge of!
mdl_lsgst_chk_opts2 = pygsti.do_mc2gst(ds, mdl_withA1, aliased_list, minProbClipForWeighting=1e-6,
probClipInterval=(-1e2,1e2), verbosity=10,
opLabelAliases={ L('GA1'): (L('Gx'),) })
#Check with small but ok memlimit -- not anymore since new mem estimation uses current memory, making this non-robust
#self.runSilent(pygsti.do_mc2gst,ds, mdl_clgst, self.lsgstStrings[0], minProbClipForWeighting=1e-6,
# probClipInterval=(-1e6,1e6), regularizeFactor=1e-3,
# verbosity=10, memLimit=CM + 1024**3)
#Check errors:
with self.assertRaises(MemoryError):
pygsti.do_mc2gst(ds, mdl_clgst, self.lsgstStrings[0], minProbClipForWeighting=1e-6,
probClipInterval=(-1e6,1e6), regularizeFactor=1e-3,
verbosity=0, memLimit=1)
with self.assertRaises(AssertionError):
pygsti.do_mc2gst(ds, mdl_clgst, self.lsgstStrings[0], minProbClipForWeighting=1e-6,
probClipInterval=(-1e6,1e6), regularizeFactor=1e-3,
verbosity=0, cptp_penalty_factor=1.0) #can't specify both cptp_penalty_factor and regularizeFactor
# RUN BELOW LINES TO SEED SAVED GATESET FILES
if os.environ.get('PYGSTI_REGEN_REF_FILES','no').lower() in ("yes","1","true"):
pygsti.io.write_model(mdl_lsgst,compare_files + "/lsgst.model", "Saved LSGST Model")
pygsti.io.write_model(mdl_lsgst_reg,compare_files + "/lsgst_reg.model", "Saved LSGST Model w/Regularization")
mdl_lsgst_compare = pygsti.io.load_model(compare_files + "/lsgst.model")
mdl_lsgst_reg_compare = pygsti.io.load_model(compare_files + "/lsgst_reg.model")
mdl_lsgst_go = pygsti.gaugeopt_to_target(mdl_lsgst, mdl_lsgst_compare, {'spam':1.0}, checkJac=True)
mdl_lsgst_reg_go = pygsti.gaugeopt_to_target(mdl_lsgst_reg, mdl_lsgst_reg_compare, {'spam':1.0}, checkJac=True)
self.assertAlmostEqual( mdl_lsgst_go.frobeniusdist(mdl_lsgst_compare), 0, places=4)
self.assertAlmostEqual( mdl_lsgst_reg_go.frobeniusdist(mdl_lsgst_reg_compare), 0, places=4)
# RUN BELOW LINES TO SEED SAVED GATESET FILES
if os.environ.get('PYGSTI_REGEN_REF_FILES','no').lower() in ("yes","1","true"):
mdl_lsgst_go = pygsti.gaugeopt_to_target(mdl_lsgst, self.model, {'spam':1.0})
pygsti.io.write_model(mdl_lsgst_go,compare_files + "/analysis.model", "Saved LSGST Analysis Model")
print("DEBUG: analysis.model = "); print(mdl_lgst_go)
def test_std_lists_and_structs(self):
gateLabels = [L('Gx'), L('Gy')]
strs = pygsti.construction.gatestring_list([('Gx', ), ('Gy', ),
('Gx', 'Gx')])
germs = pygsti.construction.gatestring_list([('Gx', 'Gy'),
('Gy', 'Gy')])
testFidPairs = [(0, 1)]
testFidPairsDict = {
(L('Gx'), L('Gy')): [(0, 0), (0, 1)],
(L('Gy'), L('Gy')): [(0, 0)]
}
# LSGST
maxLens = [1, 2]
lsgstLists = pygsti.construction.make_lsgst_lists(
std1Q_XY.gs_target,
strs,
strs,
germs,
maxLens,
fidPairs=None,
truncScheme="whole germ powers") #also try a GateSet as first arg
lsgstStructs = pygsti.construction.make_lsgst_structs(
std1Q_XY.gs_target,
strs,
strs,
germs,
maxLens,
fidPairs=None,
truncScheme="whole germ powers") #also try a GateSet as first arg
self.assertEqual(set(lsgstLists[-1]), set(lsgstStructs[-1].allstrs))
lsgstLists2 = pygsti.construction.make_lsgst_lists(
gateLabels,
strs,
strs,
germs,
maxLens,
fidPairs=None,
truncScheme="truncated germ powers")
lsgstStructs2 = pygsti.construction.make_lsgst_structs(
gateLabels,
strs,
strs,
germs,
maxLens,
fidPairs=None,
truncScheme="truncated germ powers")
self.assertEqual(set(lsgstLists2[-1]), set(lsgstStructs2[-1].allstrs))
lsgstLists3 = pygsti.construction.make_lsgst_lists(
gateLabels,
strs,
strs,
germs,
maxLens,
fidPairs=None,
truncScheme="length as exponent")
lsgstStructs3 = pygsti.construction.make_lsgst_structs(
gateLabels,
strs,
strs,
germs,
maxLens,
fidPairs=None,
truncScheme="length as exponent")
self.assertEqual(set(lsgstLists3[-1]), set(lsgstStructs3[-1].allstrs))
maxLens = [1, 2]
lsgstLists4 = pygsti.construction.make_lsgst_lists(
gateLabels,
strs,
strs,
germs,
maxLens,
fidPairs=None,
truncScheme="whole germ powers",
nest=False)
lsgstStructs4 = pygsti.construction.make_lsgst_structs(
gateLabels,
strs,
strs,
germs,
maxLens,
fidPairs=None,
truncScheme="whole germ powers",
nest=False)
self.assertEqual(set(lsgstLists4[-1]), set(lsgstStructs4[-1].allstrs))
lsgstLists5 = pygsti.construction.make_lsgst_lists(
gateLabels,
strs,
strs,
germs,
maxLens,
fidPairs=testFidPairs,
truncScheme="whole germ powers")
lsgstStructs5 = pygsti.construction.make_lsgst_structs(
gateLabels,
strs,
strs,
germs,
maxLens,
fidPairs=testFidPairs,
truncScheme="whole germ powers")
self.assertEqual(set(lsgstLists5[-1]), set(lsgstStructs5[-1].allstrs))
lsgstLists6 = pygsti.construction.make_lsgst_lists(
gateLabels,
strs,
strs,
germs,
maxLens,
fidPairs=testFidPairsDict,
truncScheme="whole germ powers")
lsgstStructs6 = pygsti.construction.make_lsgst_structs(
gateLabels,
strs,
strs,
germs,
maxLens,
fidPairs=testFidPairsDict,
truncScheme="whole germ powers")
self.assertEqual(set(lsgstLists6[-1]), set(lsgstStructs6[-1].allstrs))
lsgstExpList = pygsti.construction.make_lsgst_experiment_list(
gateLabels,
strs,
strs,
germs,
maxLens,
fidPairs=None,
truncScheme="whole germ powers")
lsgstExpListb = pygsti.construction.make_lsgst_experiment_list(
std1Q_XY.gs_target,
strs,
strs,
germs,
maxLens,
fidPairs=None,
truncScheme="whole germ powers") # with GateSet as first arg
with self.assertRaises(ValueError):
pygsti.construction.make_lsgst_lists(gateLabels,
strs,
strs,
germs,
maxLens,
fidPairs=None,
truncScheme="foobar")
with self.assertRaises(ValueError):
pygsti.construction.make_lsgst_structs(gateLabels,
strs,
strs,
germs,
maxLens,
fidPairs=None,
truncScheme="foobar")
lsgstLists7 = pygsti.construction.make_lsgst_lists(
gateLabels,
strs,
strs,
germs,
maxLens,
fidPairs=None,
truncScheme="whole germ powers",
keepFraction=0.5,
keepSeed=1234)
lsgstStructs7 = pygsti.construction.make_lsgst_structs(
gateLabels,
strs,
strs,
germs,
maxLens,
fidPairs=None,
truncScheme="whole germ powers",
keepFraction=0.5,
keepSeed=1234)
self.assertEqual(set(lsgstLists7[-1]), set(lsgstStructs7[-1].allstrs))
lsgstLists8 = pygsti.construction.make_lsgst_lists(
gateLabels,
strs,
strs,
germs,
maxLens,
fidPairs=testFidPairs,
truncScheme="whole germ powers",
keepFraction=0.7,
keepSeed=1234)
lsgstStructs8 = pygsti.construction.make_lsgst_structs(
gateLabels,
strs,
strs,
germs,
maxLens,
fidPairs=testFidPairs,
truncScheme="whole germ powers",
keepFraction=0.7,
keepSeed=1234)
self.assertEqual(set(lsgstLists8[-1]), set(lsgstStructs8[-1].allstrs))
# empty max-lengths ==> no output
lsgstStructs9 = pygsti.construction.make_lsgst_structs(
gateLabels, strs, strs, germs, [])
self.assertEqual(len(lsgstStructs9), 0)
# checks against datasets
ds = pygsti.objects.DataSet(
outcomeLabels=['0', '1']) # a dataset that is missing
ds.add_count_dict(('Gx', ), {
'0': 10,
'1': 90
}) # almost all our strings...
ds.done_adding_data()
lgst_strings = pygsti.construction.list_lgst_gatestrings(
strs, strs, gateLabels)
lsgstStructs10 = pygsti.construction.make_lsgst_structs(
gateLabels,
strs,
strs,
germs,
maxLens,
dscheck=ds,
actionIfMissing="drop",
verbosity=4)
self.assertEqual([pygsti.obj.GateString(('Gx', ))],
lsgstStructs10[-1].allstrs)
with self.assertRaises(ValueError):
pygsti.construction.make_lsgst_structs(
gateLabels, strs, strs, germs, maxLens,
dscheck=ds) #missing sequences
with self.assertRaises(ValueError):
pygsti.construction.make_lsgst_structs(
gateLabels,
strs,
strs,
germs,
maxLens,
dscheck=ds,
actionIfMissing="foobar") #invalid action
# ELGST
maxLens = [1, 2]
elgstLists = pygsti.construction.make_elgst_lists(
gateLabels, germs, maxLens, truncScheme="whole germ powers")
maxLens = [1, 2]
elgstLists2 = pygsti.construction.make_elgst_lists(
gateLabels,
germs,
maxLens,
truncScheme="whole germ powers",
nest=False,
includeLGST=False)
elgstLists2b = pygsti.construction.make_elgst_lists(
std1Q_XY.gs_target,
germs,
maxLens,
truncScheme="whole germ powers",
nest=False,
includeLGST=False) #with a GateSet as first arg
elgstExpLists = pygsti.construction.make_elgst_experiment_list(
gateLabels, germs, maxLens, truncScheme="whole germ powers")
with self.assertRaises(ValueError):
pygsti.construction.make_elgst_lists(gateLabels,
germs,
maxLens,
truncScheme="foobar")
def setUpClass(cls):
"""
Handle all once-per-class (slow) computation and loading,
to avoid calling it for each test (like setUp). Store
results in class variable for use within setUp.
"""
super(CalcMethods2QTestCase, cls).setUpClass()
#Change to test_packages directory (since setUp hasn't been called yet...)
origDir = os.getcwd()
os.chdir(os.path.abspath(os.path.dirname(__file__)))
os.chdir('..') # The test_packages directory
#Note: std is a 2Q model
cls.maxLengths = [1]
#cls.germs = std.germs_lite
cls.germs = pygsti.construction.circuit_list([
(gl, ) for gl in std.target_model().operations
])
cls.mdl_datagen = std.target_model().depolarize(op_noise=0.1,
spam_noise=0.001)
cls.listOfExperiments = pygsti.construction.make_lsgst_experiment_list(
std.target_model(), std.prepStrs, std.effectStrs, cls.germs,
cls.maxLengths)
#RUN BELOW FOR DATAGEN (UNCOMMENT to regenerate)
#ds = pygsti.construction.generate_fake_data(cls.mdl_datagen, cls.listOfExperiments,
# nSamples=1000, sampleError="multinomial", seed=1234)
#ds.save(compare_files + "/calcMethods2Q.dataset")
cls.ds = pygsti.objects.DataSet(fileToLoadFrom=compare_files +
"/calcMethods2Q.dataset")
cls.advOpts = {'tolerance': 1e-2}
#Reduced model GST dataset
cls.nQubits = 2
cls.mdl_redmod_datagen = pc.build_nqnoise_model(cls.nQubits,
geometry="line",
maxIdleWeight=1,
maxhops=1,
extraWeight1Hops=0,
extraGateWeight=1,
sparse=False,
sim_type="matrix",
verbosity=1,
gateNoise=(1234, 0.01),
prepNoise=(456, 0.01),
povmNoise=(789, 0.01))
#Create a reduced set of fiducials and germs
opLabels = list(cls.mdl_redmod_datagen.operations.keys())
fids1Q = std1Q_XY.fiducials[0:2] # for speed
cls.redmod_fiducials = []
for i in range(cls.nQubits):
cls.redmod_fiducials.extend(
pygsti.construction.manipulate_circuit_list(
fids1Q, [((L('Gx'), ), (L('Gx', i), )),
((L('Gy'), ), (L('Gy', i), ))]))
#print(redmod_fiducials, "Fiducials")
cls.redmod_germs = pygsti.construction.circuit_list([
(gl, ) for gl in opLabels
])
cls.redmod_maxLs = [1]
expList = pygsti.construction.make_lsgst_experiment_list(
cls.mdl_redmod_datagen, cls.redmod_fiducials, cls.redmod_fiducials,
cls.redmod_germs, cls.redmod_maxLs)
#RUN BELOW FOR DATAGEN (UNCOMMENT to regenerate)
#redmod_ds = pygsti.construction.generate_fake_data(cls.mdl_redmod_datagen, expList, 1000, "round", seed=1234)
#redmod_ds.save(compare_files + "/calcMethods2Q_redmod.dataset")
cls.redmod_ds = pygsti.objects.DataSet(fileToLoadFrom=compare_files +
"/calcMethods2Q_redmod.dataset")
#print(len(expList)," reduced model sequences")
#Random starting points - little kick so we don't get hung up at start
np.random.seed(1234)
cls.rand_start18 = np.random.random(18) * 1e-6
cls.rand_start206 = np.random.random(206) * 1e-6
cls.rand_start228 = np.random.random(228) * 1e-6
os.chdir(origDir) # return to original directory
def Ls(*args):
""" Convert args to a tuple to Labels """
return tuple([L(x) for x in args])
def test_ondemand_probabilities(self):
#First create a "sparse" dataset
# # Columns = 0 count, 1 count
dataset_txt = \
"""# Test Sparse format data set
{} 0:0 1:100
Gx 0:10 1:90 2:0
GxGy 0:40 1:60
Gx^4 0:100
"""
with open(temp_files + "/SparseDataset.txt", 'w') as f:
f.write(dataset_txt)
ds = pygsti.io.load_dataset(temp_files + "/SparseDataset.txt",
recordZeroCnts=False)
self.assertEqual(ds.get_outcome_labels(), [('0', ), ('1', ), ('2', )])
self.assertEqual(ds[()].outcomes,
[('1', )]) # only nonzero count is 1-count
self.assertEqual(
ds[()]['2'],
0) # but we can query '2' since it's a valid outcome label
gstrs = list(ds.keys())
raw_dict, elIndices, outcome_lookup, ntotal = std1Q_XYI.target_model(
).simplify_circuits(gstrs, ds)
print(
"Raw circuit -> elabels dict:\n", "\n".join(
["%s: %s" % (str(k), str(v)) for k, v in raw_dict.items()]))
print(
"\nElement indices lookup (orig opstr index -> element indices):\n",
elIndices)
print(
"\nOutcome lookup (orig opstr index -> list of outcome for each element):\n",
outcome_lookup)
print("\ntotal elements = ", ntotal)
self.assertEqual(raw_dict[('rho0', )], [L('Mdefault_1')])
self.assertEqual(raw_dict[(
'rho0',
'Gx',
)], [L('Mdefault_0'), L('Mdefault_1')])
self.assertEqual(raw_dict[('rho0', 'Gx', 'Gy')],
[L('Mdefault_0'), L('Mdefault_1')])
self.assertEqual(raw_dict[('rho0', ) + ('Gx', ) * 4],
[L('Mdefault_0')])
self.assertEqual(
elIndices,
collections.OrderedDict([(0, slice(0, 1, None)),
(1, slice(1, 3, None)),
(2, slice(3, 5, None)),
(3, slice(5, 6, None))]))
self.assertEqual(
outcome_lookup,
collections.OrderedDict([(0, [('1', )]), (1, [('0', ), ('1', )]),
(2, [('0', ), ('1', )]), (3, [('0', )])]))
self.assertEqual(ntotal, 6)
#A sparse dataset loading test using the more common format:
dataset_txt2 = \
"""## Columns = 0 count, 1 count
{} 0 100
Gx 10 90
GxGy 40 60
Gx^4 100 0
"""
with open(temp_files + "/SparseDataset2.txt", 'w') as f:
f.write(dataset_txt2)
ds = pygsti.io.load_dataset(temp_files + "/SparseDataset2.txt",
recordZeroCnts=True)
self.assertEqual(ds.get_outcome_labels(), [('0', ), ('1', )])
self.assertEqual(ds[()].outcomes, [
('0', ), ('1', )
]) # both outcomes even though only nonzero count is 1-count
with self.assertRaises(KeyError):
ds[(
)]['2'] # *can't* query '2' b/c it's NOT a valid outcome label here
def test_doperation(self):
dg = self.fwdsim.doperation(L('Gx'), flat=False)
dgflat = self.fwdsim.doperation(L('Gx'), flat=True)
def test_confidenceRegion(self):
res = pygsti.obj.Results()
res.init_dataset(self.ds)
res.init_circuits(self.gss)
#Add estimate for hessian-based CI --------------------------------------------------
res.add_estimate(stdxyi.target_model(), stdxyi.target_model(),
[self.model]*len(self.maxLengthList), parameters={'objective': 'logl'},
estimate_key="default")
est = res.estimates['default']
est.add_confidence_region_factory('final iteration estimate', 'final')
self.assertWarns(est.add_confidence_region_factory, 'final iteration estimate','final') #overwrites former
self.assertTrue( est.has_confidence_region_factory('final iteration estimate', 'final'))
cfctry = est.get_confidence_region_factory('final iteration estimate', 'final')
self.assertFalse( cfctry.can_construct_views() ) # b/c no hessian or LR enabled yet...
cfctry.compute_hessian(approximate=True)
cfctry.compute_hessian()
self.assertTrue( cfctry.has_hessian() )
self.assertFalse( cfctry.can_construct_views() ) # b/c hessian isn't projected yet...
mdl_dummy = cfctry.get_model() # test method
s = pickle.dumps(cfctry) # test pickle
pickle.loads(s)
cfctry.project_hessian('std')
cfctry.project_hessian('none')
cfctry.project_hessian('optimal gate CIs')
cfctry.project_hessian('intrinsic error')
with self.assertRaises(ValueError):
cfctry.project_hessian(95.0, 'normal', 'FooBar') #bad hessianProjection
self.assertTrue( cfctry.can_construct_views() )
ci_std = cfctry.view( 95.0, 'normal', 'std')
ci_noproj = cfctry.view( 95.0, 'normal', 'none')
ci_intrinsic = cfctry.view( 95.0, 'normal', 'intrinsic error')
ci_opt = cfctry.view( 95.0, 'normal', 'optimal gate CIs')
with self.assertRaises(ValueError):
cfctry.view(95.0, 'foobar') #bad region type
self.assertWarns(cfctry.view, 0.95, 'normal', 'none') # percentage < 1.0
#Add estimate for linresponse-based CI --------------------------------------------------
res.add_estimate(stdxyi.target_model(), stdxyi.target_model(),
[self.model]*len(self.maxLengthList), parameters={'objective': 'logl'},
estimate_key="linresponse")
estLR = res.estimates['linresponse']
#estLR.add_confidence_region_factory('final iteration estimate', 'final') #Could do this, but use alt. method for more coverage
with self.assertRaises(KeyError):
estLR.get_confidence_region_factory('final iteration estimate', 'final') #won't create by default
cfctryLR = estLR.get_confidence_region_factory('final iteration estimate', 'final', createIfNeeded=True) #now it will
self.assertTrue( estLR.has_confidence_region_factory('final iteration estimate', 'final'))
#cfctryLR = estLR.get_confidence_region_factory('final iteration estimate', 'final') #done by 'get' call above
self.assertFalse( cfctryLR.can_construct_views() ) # b/c no hessian or LR enabled yet...
cfctryLR.enable_linear_response_errorbars() #parent results object is used to automatically populate params
#self.assertTrue( cfctryLR.can_construct_views() )
ci_linresponse = cfctryLR.view( 95.0, 'normal', None)
mdl_dummy = cfctryLR.get_model() # test method
s = pickle.dumps(cfctryLR) # test pickle
pickle.loads(s)
#Add estimate for with bad objective ---------------------------------------------------------
res.add_estimate(stdxyi.target_model(), stdxyi.target_model(),
[self.model]*len(self.maxLengthList), parameters={'objective': 'foobar'},
estimate_key="foo")
est = res.estimates['foo']
est.add_confidence_region_factory('final iteration estimate', 'final')
with self.assertRaises(ValueError): # bad objective
est.get_confidence_region_factory('final iteration estimate', 'final').compute_hessian()
# Now test each of the views we created above ------------------------------------------------
for ci_cur in (ci_std, ci_noproj, ci_opt, ci_intrinsic, ci_linresponse):
s = pickle.dumps(ci_cur) # test pickle
pickle.loads(s)
#linear response CI doesn't support profile likelihood intervals
if ci_cur is not ci_linresponse: # (profile likelihoods not implemented in this case)
ar_of_intervals_Gx = ci_cur.get_profile_likelihood_confidence_intervals(L("Gx"))
ar_of_intervals_rho0 = ci_cur.get_profile_likelihood_confidence_intervals(L("rho0"))
ar_of_intervals_M0 = ci_cur.get_profile_likelihood_confidence_intervals(L("Mdefault"))
ar_of_intervals = ci_cur.get_profile_likelihood_confidence_intervals()
with self.assertRaises(ValueError):
ci_cur.get_profile_likelihood_confidence_intervals("foobar") #invalid label
def fnOfGate_float(mx,b):
return float(mx[0,0])
def fnOfGate_complex(mx,b):
return complex(mx[0,0] + 1.0j)
def fnOfGate_0D(mx,b):
return np.array( float(mx[0,0]) )
def fnOfGate_1D(mx,b):
return mx[0,:]
def fnOfGate_2D(mx,b):
return mx[:,:]
def fnOfGate_2D_complex(mx,b):
return np.array(mx[:,:] + 1j*mx[:,:],'complex')
def fnOfGate_3D(mx,b):
return np.zeros( (2,2,2), 'd') #just to test for error
fns = (fnOfGate_float, fnOfGate_0D, fnOfGate_1D,
fnOfGate_2D, fnOfGate_3D)
if ci_cur is not ci_linresponse: # complex functions not supported by linresponse CIs
fns += (fnOfGate_complex, fnOfGate_2D_complex)
for fnOfOp in fns:
FnClass = gsf.opfn_factory(fnOfOp)
FnObj = FnClass(self.model, 'Gx')
if fnOfOp is fnOfGate_3D:
with self.assertRaises(ValueError):
df = ci_cur.get_fn_confidence_interval(FnObj, verbosity=0)
else:
df = ci_cur.get_fn_confidence_interval(FnObj, verbosity=0)
df, f0 = self.runSilent(ci_cur.get_fn_confidence_interval,
FnObj, returnFnVal=True, verbosity=4)
##SHORT-CIRCUIT linear reponse here to reduce run time
if ci_cur is ci_linresponse: continue
def fnOfVec_float(v,b):
return float(v[0])
def fnOfVec_0D(v,b):
return np.array( float(v[0]) )
def fnOfVec_1D(v,b):
return np.array(v[:])
def fnOfVec_2D(v,b):
return np.dot(v.T,v)
def fnOfVec_3D(v,b):
return np.zeros( (2,2,2), 'd') #just to test for error
for fnOfVec in (fnOfVec_float, fnOfVec_0D, fnOfVec_1D, fnOfVec_2D, fnOfVec_3D):
FnClass = gsf.vecfn_factory(fnOfVec)
FnObj = FnClass(self.model, 'rho0', 'prep')
if fnOfVec is fnOfVec_3D:
with self.assertRaises(ValueError):
df = ci_cur.get_fn_confidence_interval(FnObj, verbosity=0)
else:
df = ci_cur.get_fn_confidence_interval(FnObj, verbosity=0)
df, f0 = self.runSilent(ci_cur.get_fn_confidence_interval,
FnObj, returnFnVal=True, verbosity=4)
for fnOfVec in (fnOfVec_float, fnOfVec_0D, fnOfVec_1D, fnOfVec_2D, fnOfVec_3D):
FnClass = gsf.vecfn_factory(fnOfVec)
FnObj = FnClass(self.model, 'Mdefault:0', 'effect')
if fnOfVec is fnOfVec_3D:
with self.assertRaises(ValueError):
df = ci_cur.get_fn_confidence_interval(FnObj, verbosity=0)
else:
df = ci_cur.get_fn_confidence_interval(FnObj, verbosity=0)
df, f0 = self.runSilent(ci_cur.get_fn_confidence_interval,
FnObj, returnFnVal=True, verbosity=4)
def fnOfSpam_float(rhoVecs, povms):
lbls = list(povms[0].keys())
return float( np.dot( rhoVecs[0].T, povms[0][lbls[0]] ) )
def fnOfSpam_0D(rhoVecs, povms):
lbls = list(povms[0].keys())
return np.array( float( np.dot( rhoVecs[0].T, povms[0][lbls[0]] ) ) )
def fnOfSpam_1D(rhoVecs, povms):
lbls = list(povms[0].keys())
return np.array( [ np.dot( rhoVecs[0].T, povms[0][lbls[0]] ), 0] )
def fnOfSpam_2D(rhoVecs, povms):
lbls = list(povms[0].keys())
return np.array( [[ np.dot( rhoVecs[0].T, povms[0][lbls[0]] ), 0],[0,0]] )
def fnOfSpam_3D(rhoVecs, povms):
return np.zeros( (2,2,2), 'd') #just to test for error
for fnOfSpam in (fnOfSpam_float, fnOfSpam_0D, fnOfSpam_1D, fnOfSpam_2D, fnOfSpam_3D):
FnClass = gsf.spamfn_factory(fnOfSpam)
FnObj = FnClass(self.model)
if fnOfSpam is fnOfSpam_3D:
with self.assertRaises(ValueError):
df = ci_cur.get_fn_confidence_interval(FnObj, verbosity=0)
else:
df = ci_cur.get_fn_confidence_interval(FnObj, verbosity=0)
df, f0 = self.runSilent(ci_cur.get_fn_confidence_interval,
FnObj, returnFnVal=True, verbosity=4)
def fnOfGateSet_float(mdl):
return float( mdl.operations['Gx'][0,0] )
def fnOfGateSet_0D(mdl):
return np.array( mdl.operations['Gx'][0,0] )
def fnOfGateSet_1D(mdl):
return np.array( mdl.operations['Gx'][0,:] )
def fnOfGateSet_2D(mdl):
return np.array( mdl.operations['Gx'] )
def fnOfGateSet_3D(mdl):
return np.zeros( (2,2,2), 'd') #just to test for error
for fnOfGateSet in (fnOfGateSet_float, fnOfGateSet_0D, fnOfGateSet_1D, fnOfGateSet_2D, fnOfGateSet_3D):
FnClass = gsf.modelfn_factory(fnOfGateSet)
FnObj = FnClass(self.model)
if fnOfGateSet is fnOfGateSet_3D:
with self.assertRaises(ValueError):
df = ci_cur.get_fn_confidence_interval(FnObj, verbosity=0)
else:
df = ci_cur.get_fn_confidence_interval(FnObj, verbosity=0)
df, f0 = self.runSilent(ci_cur.get_fn_confidence_interval,
FnObj, returnFnVal=True, verbosity=4)
def test_direct_core(self):
gs = directx.gateset_with_lgst_gatestring_estimates(
self.strs, self.ds, self.prepStrs, self.effectStrs, self.tgt, includeTargetGates=True,
gateStringLabels=None, svdTruncateTo=4, verbosity=10)
gs = directx.gateset_with_lgst_gatestring_estimates(
self.strs, self.ds, self.prepStrs, self.effectStrs, self.tgt, includeTargetGates=False,
gateStringLabels=[L('G0'),L('G1'),L('G2'),L('G3'),L('G4'),L('G5')], svdTruncateTo=4, verbosity=10)
self.assertEqual(set(gs.gates.keys()), set([L('G0'),L('G1'),L('G2'),L('G3'),L('G4'),L('G5')]))
aliases = {'Gy2': ('Gy',)}
gs = directx.gateset_with_lgst_gatestring_estimates(
[pygsti.obj.GateString(('Gy2',))], self.ds, self.prepStrs, self.effectStrs, self.tgt, includeTargetGates=True,
gateStringLabels=None, svdTruncateTo=4, verbosity=10, gateLabelAliases=aliases)
def test_3Q(self):
#only test when reps are fast (b/c otherwise this test is slow!)
try:
from pygsti.objects import fastreplib
except ImportError:
warnings.warn("Skipping test_3Q b/c no fastreps!")
return
nQubits = 3
print("Constructing Target LinearOperator Set")
target_model = build_XYCNOT_cloudnoise_model(nQubits,
geometry="line",
maxIdleWeight=1,
maxhops=1,
extraWeight1Hops=0,
extraGateWeight=1,
sparse=True,
sim_type="map",
verbosity=1)
#print("nElements test = ",target_model.num_elements())
#print("nParams test = ",target_model.num_params())
#print("nNonGaugeParams test = ",target_model.num_nongauge_params())
print("Constructing Datagen LinearOperator Set")
mdl_datagen = build_XYCNOT_cloudnoise_model(nQubits,
geometry="line",
maxIdleWeight=1,
maxhops=1,
extraWeight1Hops=0,
extraGateWeight=1,
sparse=True,
verbosity=1,
roughNoise=(1234, 0.1),
sim_type="map")
mdl_test = mdl_datagen
print(
"Constructed model with %d op-blks, dim=%d, and nParams=%d. Norm(paramvec) = %g"
% (len(mdl_test.operation_blks), mdl_test.dim,
mdl_test.num_params(), np.linalg.norm(mdl_test.to_vector())))
opLabels = target_model.get_primitive_op_labels()
line_labels = tuple(range(nQubits))
fids1Q = std1Q_XY.fiducials
fiducials = []
for i in range(nQubits):
fiducials.extend(
pygsti.construction.manipulate_circuit_list(
fids1Q, [((L('Gx'), ), (L('Gx', i), )),
((L('Gy'), ), (L('Gy', i), ))],
line_labels=line_labels))
print(len(fiducials), "Fiducials")
prep_fiducials = meas_fiducials = fiducials
#TODO: add fiducials for 2Q pairs (edges on graph)
germs = pygsti.construction.circuit_list([(gl, ) for gl in opLabels],
line_labels=line_labels)
maxLs = [1]
expList = pygsti.construction.make_lsgst_experiment_list(
mdl_datagen, prep_fiducials, meas_fiducials, germs, maxLs)
self.assertTrue(Circuit((), line_labels) in expList)
ds = pygsti.construction.generate_fake_data(mdl_datagen,
expList,
1000,
"multinomial",
seed=1234)
print("Created Dataset with %d strings" % len(ds))
logL = pygsti.tools.logl(mdl_datagen, ds, expList)
max_logL = pygsti.tools.logl_max(mdl_datagen, ds, expList)
twoDeltaLogL = 2 * (max_logL - logL)
chi2 = pygsti.tools.chi2(mdl_datagen, ds, expList)
dof = ds.get_degrees_of_freedom()
nParams = mdl_datagen.num_params()
print("Datagen 2DeltaLogL = 2(%g-%g) = %g" %
(logL, max_logL, twoDeltaLogL))
print("Datagen chi2 = ", chi2)
print("Datagen expected DOF = ", dof)
print("nParams = ", nParams)
print("Expected 2DeltaLogL or chi2 ~= %g-%g =%g" %
(dof, nParams, dof - nParams))
#print("EXIT"); exit()
return
results = pygsti.do_long_sequence_gst(
ds,
target_model,
prep_fiducials,
meas_fiducials,
germs,
maxLs,
verbosity=5,
advancedOptions={
'maxIterations': 2
}) #keep this short; don't care if it doesn't converge.
print("DONE!")
