def test_stdgst_matrix(self): # Using matrix-based calculations target_model = std.target_model().copy() target_model.set_all_parameterizations("CPTP") target_model.set_simtype( 'matrix') # the default for 1Q, so we could remove this line results = pygsti.run_long_sequence_gst(self.ds, target_model, std.prepStrs, std.effectStrs, self.germs, self.maxLengths, advanced_options=self.advOpts, verbosity=4) #RUN BELOW LINES TO SAVE GATESET (UNCOMMENT to regenerate) #pygsti.io.write_model(results.estimates['default'].models['go0'], # compare_files + "/test2Qcalc_std_exact.model","Saved Standard-Calc 2Q test model") # Note: expected nSigma of 143 is so high b/c we use very high tol of 1e-2 => result isn't very good print("MISFIT nSigma = ", results.estimates['default'].misfit_sigma()) self.assertAlmostEqual(results.estimates['default'].misfit_sigma(), 143, delta=2.0) mdl_compare = pygsti.io.load_model(compare_files + "/test2Qcalc_std_exact.model") self.assertAlmostEqual( results.estimates['default'].models['go0'].frobeniusdist( mdl_compare), 0, places=3)
def test_reducedmod_map2(self): # Using sparse embedded matrices and map-based calcs target_model = pc.build_nqnoise_model(self.nQubits, geometry="line", max_idle_weight=1, maxhops=1, extra_weight_1_hops=0, extra_gate_weight=1, sparse=True, sim_type="map", verbosity=1) target_model.from_vector(self.rand_start206) results = pygsti.run_long_sequence_gst( self.redmod_ds, target_model, self.redmod_fiducials, self.redmod_fiducials, self.redmod_germs, self.redmod_maxLs, verbosity=4, advanced_options={'tolerance': 1e-3}) print("MISFIT nSigma = ", results.estimates['default'].misfit_sigma()) self.assertAlmostEqual(results.estimates['default'].misfit_sigma(), 1.0, delta=1.0) mdl_compare = pygsti.serialization.json.load( open(compare_files + "/test2Qcalc_redmod_exact.model")) self.assertAlmostEqual(np.linalg.norm( results.estimates['default'].models['go0'].to_vector() - mdl_compare.to_vector()), 0, places=1)
def test_reducedmod_cterm(self): # Using term-based calcs using map-based stabilizer-state propagation target_model = pc.build_nqnoise_model( self.nQubits, geometry="line", max_idle_weight=1, maxhops=1, extra_weight_1_hops=0, extra_gate_weight=1, sparse=False, verbosity=1, sim_type="termorder:1", parameterization="H+S clifford terms") target_model.from_vector(self.rand_start228) results = pygsti.run_long_sequence_gst( self.redmod_ds, target_model, self.redmod_fiducials, self.redmod_fiducials, self.redmod_germs, self.redmod_maxLs, verbosity=4, advanced_options={'tolerance': 1e-3}) print("MISFIT nSigma = ", results.estimates['default'].misfit_sigma()) self.assertAlmostEqual(results.estimates['default'].misfit_sigma(), 3.0, delta=1.0) mdl_compare = pygsti.serialization.json.load( open(compare_files + "/test2Qcalc_redmod_terms.model")) self.assertAlmostEqual(np.linalg.norm( results.estimates['default'].models['go0'].to_vector() - mdl_compare.to_vector()), 0, places=3)
def test_reducedmod_cterm_errorgens(self): # Using term-based calcs using map-based stabilizer-state propagation (same as above) # but w/errcomp_type=errogens Model termsim = pygsti.forwardsims.TermForwardSimulator(mode='taylor-order', max_order=1) target_model = build_XYCNOT_cloudnoise_model(self.nQubits, geometry="line", maxIdleWeight=1, maxhops=1, extraWeight1Hops=0, extraGateWeight=1, verbosity=1, evotype="stabilizer", simulator=termsim, parameterization="H+S", errcomp_type='errorgens') print("Num params = ", target_model.num_params) target_model.from_vector(self.rand_start36) results = pygsti.run_long_sequence_gst( self.redmod_ds, target_model, self.redmod_fiducials, self.redmod_fiducials, self.redmod_germs, self.redmod_maxLs, verbosity=4, advanced_options={'tolerance': 1e-3}) print("MISFIT nSigma = ", results.estimates[results.name].misfit_sigma()) self.assertAlmostEqual(results.estimates[results.name].misfit_sigma(), 0.0, delta=1.0)
def test_reducedmod_map2_errorgens(self): # Using sparse embedded matrices and map-based calcs (same as above) # but w/*errcomp_type=errogens* Model (maybe not really necessary to include?) target_model = build_XYCNOT_cloudnoise_model(self.nQubits, geometry="line", maxIdleWeight=1, maxhops=1, extraWeight1Hops=0, extraGateWeight=1, simulator="map", errcomp_type='errorgens', verbosity=1) print("Num params = ", target_model.num_params) target_model.from_vector(self.rand_start25) results = pygsti.run_long_sequence_gst( self.redmod_ds, target_model, self.redmod_fiducials, self.redmod_fiducials, self.redmod_germs, self.redmod_maxLs, verbosity=4, advanced_options={'tolerance': 1e-3}) print("MISFIT nSigma = ", results.estimates[results.name].misfit_sigma()) self.assertAlmostEqual(results.estimates[results.name].misfit_sigma(), 0.0, delta=1.0)
def test_time_dependent_gst_staticdata(self): #run GST in a time-dependent mode: prep_fiducials, meas_fiducials = std1Q_XYI.prepStrs, std1Q_XYI.effectStrs germs = std1Q_XYI.germs maxLengths = [1, 2] target_model = std1Q_XYI.target_model("full TP", sim_type="map") mdl_datagen = target_model.depolarize(op_noise=0.01, spam_noise=0.001) edesign = pygsti.protocols.StandardGSTDesign(target_model.create_processor_spec(), prep_fiducials, meas_fiducials, germs, maxLengths) # *sparse*, time-independent data ds = pygsti.data.simulate_data(mdl_datagen, edesign.all_circuits_needing_data, num_samples=10, sample_error="binomial", seed=1234, times=[0], record_zero_counts=False) data = pygsti.protocols.ProtocolData(edesign, ds) target_model.sim = pygsti.forwardsims.MapForwardSimulator(max_cache_size=0) # No caching allowed for time-dependent calcs self.assertEqual(ds.degrees_of_freedom(aggregate_times=False), 126) builders = pygsti.protocols.GSTObjFnBuilders([pygsti.objectivefns.TimeDependentPoissonPicLogLFunction.builder()], []) gst = pygsti.protocols.GateSetTomography(target_model, gaugeopt_suite=None, objfn_builders=builders) results = gst.run(data) # Normal GST used as a check - should get same answer since data is time-independent results2 = pygsti.run_long_sequence_gst(ds, target_model, prep_fiducials, meas_fiducials, germs, maxLengths, verbosity=3, advanced_options={'starting_point': 'target', 'always_perform_mle': True, 'only_perform_mle': True}, gauge_opt_params=False)
def test_reducedmod_matrix(self): # Using dense matrices and matrix-based calcs target_model = build_XYCNOT_cloudnoise_model(self.nQubits, geometry="line", maxIdleWeight=1, maxhops=1, extraWeight1Hops=0, extraGateWeight=1, simulator="matrix", verbosity=1) print("Num params = ", target_model.num_params) target_model.from_vector(self.rand_start25) results = pygsti.run_long_sequence_gst( self.redmod_ds, target_model, self.redmod_fiducials, self.redmod_fiducials, self.redmod_germs, self.redmod_maxLs, verbosity=4, advanced_options={'tolerance': 1e-3}) #RUN BELOW LINES TO SAVE GATESET (SAVE) if regenerate_references(): pygsti.serialization.json.dump( results.estimates[results.name].models['go0'], open(compare_files + "/test1Qcalc_redmod_exact.model", 'w')) print("MISFIT nSigma = ", results.estimates[results.name].misfit_sigma()) self.assertAlmostEqual(results.estimates[results.name].misfit_sigma(), 0.0, delta=1.0)
def test_reducedmod_map2(self): # Using sparse embedded matrices and map-based calcs target_model = build_XYCNOT_cloudnoise_model(self.nQubits, geometry="line", maxIdleWeight=1, maxhops=1, extraWeight1Hops=0, extraGateWeight=1, simulator="map", errcomp_type='gates', verbosity=1) print("Num params = ", target_model.num_params) target_model.from_vector(self.rand_start25) results = pygsti.run_long_sequence_gst( self.redmod_ds, target_model, self.redmod_fiducials, self.redmod_fiducials, self.redmod_germs, self.redmod_maxLs, verbosity=4, advanced_options={'tolerance': 1e-3}) print("MISFIT nSigma = ", results.estimates[results.name].misfit_sigma()) self.assertAlmostEqual(results.estimates[results.name].misfit_sigma(), 0.0, delta=1.0) mdl_compare = pygsti.serialization.json.load( open(compare_files + "/test1Qcalc_redmod_exact.model")) self.assertAlmostEqual(np.linalg.norm( results.estimates[results.name].models['go0'].to_vector() - mdl_compare.to_vector()), 0, places=1)
def test_stdgst_prunedpath(self): # Using term-based (path integral) calculation with path pruning # This performs a map-based unitary evolution along each path. target_model = std.target_model("static unitary", evotype='statevec') target_model.set_all_parameterizations("H+S") target_model.sim = pygsti.forwardsims.TermForwardSimulator( mode='pruned', max_order=3, desired_perr=0.01, allowed_perr=0.1, max_paths_per_outcome=1000, perr_heuristic='meanscaled', max_term_stages=5) target_model.from_vector( 1e-10 * np.ones(target_model.num_params) ) # to seed term calc (starting with perfect zeros causes trouble) results = pygsti.run_long_sequence_gst(self.ds, target_model, std.prep_fiducials(), std.meas_fiducials(), std.germs(), self.maxLengths, verbosity=3) #RUN BELOW LINES TO SAVE GATESET (SAVE) if regenerate_references(): pygsti.serialization.json.dump( results.estimates[results.name].models['go0'], open(compare_files + "/test1Qcalc_std_prunedpath.model", 'w')) print("MISFIT nSigma = ", results.estimates[results.name].misfit_sigma()) self.assertAlmostEqual(results.estimates[results.name].misfit_sigma(), 1, delta=1.0)
def test_stdgst_map(self): # Using map-based calculation target_model = std.target_model() target_model.set_all_parameterizations("CPTP") target_model.sim = 'map' results = pygsti.run_long_sequence_gst(self.ds, target_model, std.prep_fiducials(), std.meas_fiducials(), std.germs(), self.maxLengths, verbosity=4) print("MISFIT nSigma = ", results.estimates[results.name].misfit_sigma()) self.assertAlmostEqual(results.estimates[results.name].misfit_sigma(), 1.0, delta=2.0) mdl_compare = pygsti.serialization.json.load( open(compare_files + "/test1Qcalc_std_exact.model")) gsEstimate = results.estimates[results.name].models['go0'].copy() gsEstimate.set_all_parameterizations("full") gsEstimate = pygsti.algorithms.gaugeopt_to_target( gsEstimate, mdl_compare) self.assertAlmostEqual(gsEstimate.frobeniusdist(mdl_compare), 0, places=0)
def test_stdgst_terms(self): # Using term-based (path integral) calculation # This performs a map-based unitary evolution along each path. target_model = std.target_model().copy() target_model.set_all_parameterizations("H+S terms") target_model.set_simtype( 'termorder:1' ) # this is the default set by set_all_parameterizations above results = pygsti.run_long_sequence_gst(self.ds, target_model, std.prepStrs, std.effectStrs, self.germs, self.maxLengths, verbosity=4) #RUN BELOW LINES TO SAVE GATESET (UNCOMMENT to regenerate) #pygsti.io.json.dump(results.estimates['default'].models['go0'], # open(compare_files + "/test2Qcalc_std_terms.model",'w')) print("MISFIT nSigma = ", results.estimates['default'].misfit_sigma()) self.assertAlmostEqual(results.estimates['default'].misfit_sigma(), 5, delta=1.0) mdl_compare = pygsti.serialization.json.load( open(compare_files + "/test2Qcalc_std_terms.model")) self.assertAlmostEqual(np.linalg.norm( results.estimates['default'].models['go0'].to_vector() - mdl_compare.to_vector()), 0, places=3)
def test_stdgst_map(self): # Using map-based calculation target_model = std.target_model().copy() target_model.set_all_parameterizations("CPTP") target_model.set_simtype('map') results = pygsti.run_long_sequence_gst(self.ds, target_model, std.prepStrs, std.effectStrs, self.germs, self.maxLengths, advanced_options=self.advOpts, verbosity=4) #Note: expected nSigma of 143 is so high b/c we use very high tol of 1e-2 => result isn't very good print("MISFIT nSigma = ", results.estimates['default'].misfit_sigma()) self.assertAlmostEqual(results.estimates['default'].misfit_sigma(), 143, delta=2.0) mdl_compare = pygsti.io.load_model(compare_files + "/test2Qcalc_std_exact.model") self.assertAlmostEqual( results.estimates['default'].models['go0'].frobeniusdist( mdl_compare), 0, places=3)
def test_stdgst_terms(self): # Using term-based (path integral) calculation # This performs a map-based unitary evolution along each path. target_model = std.target_model("static unitary", evotype='statevec') target_model.set_all_parameterizations("H+S") target_model.sim = pygsti.forwardsims.TermForwardSimulator( mode='taylor-order', max_order=1) target_model._print_gpindices() target_model.from_vector( 1e-10 * np.ones(target_model.num_params) ) # to seed term calc (starting with perfect zeros causes trouble) results = pygsti.run_long_sequence_gst(self.ds, target_model, std.prep_fiducials(), std.meas_fiducials(), std.germs(), self.maxLengths, verbosity=4) #RUN BELOW LINES TO SAVE GATESET (SAVE) if regenerate_references(): pygsti.serialization.json.dump( results.estimates[results.name].models['go0'], open(compare_files + "/test1Qcalc_std_terms.model", 'w')) print("MISFIT nSigma = ", results.estimates[results.name].misfit_sigma()) self.assertAlmostEqual(results.estimates[results.name].misfit_sigma(), 1, delta=1.0) mdl_compare = pygsti.serialization.json.load( open(compare_files + "/test1Qcalc_std_terms.model")) # can't easily gauge opt b/c term-based models can't be converted to "full" #mdl_compare.set_all_parameterizations("full") # #gsEstimate = results.estimates[results.name].models['go0'].copy() #gsEstimate.set_all_parameterizations("full") #gsEstimate = pygsti.algorithms.gaugeopt_to_target(gsEstimate, mdl_compare) #self.assertAlmostEqual( gsEstimate.frobeniusdist(mdl_compare), 0, places=0) #A direct vector comparison works if python (&numpy?) versions are identical, but # gauge freedoms make this incorrectly fail in other cases - so just check sigmas print("VEC DIFF = ", (results.estimates[results.name].models['go0'].to_vector() - mdl_compare.to_vector())) self.assertAlmostEqual(np.linalg.norm( results.estimates[results.name].models['go0'].to_vector() - mdl_compare.to_vector()), 0, places=1)
def test_idletomog_gstdata_1Qofstd2Q(self): # perform idle tomography on first qubit of 2Q from pygsti.modelpacks.legacy import std2Q_XYICNOT as std2Q from pygsti.modelpacks.legacy import std1Q_XYI as std std2Q = pygsti.modelpacks.stdtarget.stdmodule_to_smqmodule(std2Q) std = pygsti.modelpacks.stdtarget.stdmodule_to_smqmodule(std) maxLens = [1, 2, 4] expList = pygsti.circuits.create_lsgst_circuits( std2Q.target_model(), std2Q.prepStrs, std2Q.effectStrs, std2Q.germs_lite, maxLens) mdl_datagen = std2Q.target_model().depolarize(0.01, 0.01) ds2Q = pygsti.data.simulate_data(mdl_datagen, expList, 1000, 'multinomial', seed=1234) #Just analyze first qubit (qubit 0) ds = pygsti.data.filter_dataset(ds2Q, (0, )) start = std.target_model() start.set_all_parameterizations("full TP") result = pygsti.run_long_sequence_gst( ds, start, std.prepStrs[0:4], std.effectStrs[0:4], std.germs_lite, maxLens, verbosity=3, advanced_options={'objective': 'chi2'}) report = pygsti.report.construct_standard_report( result, "Test GST Report w/Idle Tomog.: StdXYI from StdXYICNOT", advanced_options={'idt_idle_oplabel': ()}, verbosity=3) idt_sections = list( filter( lambda x: isinstance( x, pygsti.report.section.IdleTomographySection), report._sections)) self.assertEqual(len(idt_sections), 1) self.assertTrue( isinstance( report._global_qtys['top_switchboard'].idtresults.base[0], pygsti.extras.idletomography.idtresults.IdleTomographyResults))
def test_reducedmod_svterm(self): # Using term-based calcs using map-based state-vector propagation termsim = pygsti.forwardsims.TermForwardSimulator(mode='taylor-order', max_order=1) target_model = build_XYCNOT_cloudnoise_model(self.nQubits, geometry="line", maxIdleWeight=1, maxhops=1, extraWeight1Hops=0, extraGateWeight=1, evotype="statevec", verbosity=1, simulator=termsim, parameterization="H+S", errcomp_type='gates') print("Num params = ", target_model.num_params) target_model.from_vector(self.rand_start36) results = pygsti.run_long_sequence_gst( self.redmod_ds, target_model, self.redmod_fiducials, self.redmod_fiducials, self.redmod_germs, self.redmod_maxLs, verbosity=4, advanced_options={'tolerance': 1e-3}) #RUN BELOW LINES TO SAVE GATESET (SAVE) if regenerate_references(): pygsti.serialization.json.dump( results.estimates[results.name].models['go0'], open(compare_files + "/test1Qcalc_redmod_terms.model", 'w')) print("MISFIT nSigma = ", results.estimates[results.name].misfit_sigma()) self.assertAlmostEqual(results.estimates[results.name].misfit_sigma(), 0.0, delta=1.0) mdl_compare = pygsti.serialization.json.load( open(compare_files + "/test1Qcalc_redmod_terms.model")) self.assertAlmostEqual(np.linalg.norm( results.estimates[results.name].models['go0'].to_vector() - mdl_compare.to_vector()), 0, places=3)
def test_stdgst_matrix(self): # Using matrix-based calculations target_model = std.target_model() target_model.set_all_parameterizations("CPTP") target_model.sim = 'matrix' # the default for 1Q, so we could remove this line results = pygsti.run_long_sequence_gst(self.ds, target_model, std.prep_fiducials(), std.meas_fiducials(), std.germs(), self.maxLengths, verbosity=4) #CHECK that copy gives identical models - this is checked by other # unit tests but here we're using a true "GST model" - so do it again: print("CHECK COPY") mdl = results.estimates[results.name].models['go0'] mdl_copy = mdl.copy() print(mdl.strdiff(mdl_copy)) self.assertAlmostEqual(mdl.frobeniusdist(mdl_copy), 0, places=2) #RUN BELOW LINES TO SAVE GATESET (SAVE) if regenerate_references(): pygsti.serialization.json.dump( results.estimates[results.name].models['go0'], open(compare_files + "/test1Qcalc_std_exact.model", 'w')) print("MISFIT nSigma = ", results.estimates[results.name].misfit_sigma()) self.assertAlmostEqual(results.estimates[results.name].misfit_sigma(), 1.0, delta=2.0) mdl_compare = pygsti.serialization.json.load( open(compare_files + "/test1Qcalc_std_exact.model")) #gauge opt before compare gsEstimate = results.estimates[results.name].models['go0'].copy() gsEstimate.set_all_parameterizations("full") gsEstimate = pygsti.algorithms.gaugeopt_to_target( gsEstimate, mdl_compare) print(gsEstimate.strdiff(mdl_compare)) self.assertAlmostEqual(gsEstimate.frobeniusdist(mdl_compare), 0, places=1)
def test_reducedmod_prunedpath_svterm_errorgens(self): termsim = pygsti.forwardsims.TermForwardSimulator(mode='pruned') target_model = build_XYCNOT_cloudnoise_model(self.nQubits, geometry="line", maxIdleWeight=1, maxhops=1, extraWeight1Hops=0, extraGateWeight=1, verbosity=1, evotype="statevec", simulator=termsim, parameterization="H+S", errcomp_type='errorgens') #separately call set_simtype to set other params target_model.sim = pygsti.forwardsims.TermForwardSimulator( mode='pruned', max_order=3, desired_perr=0.01, allowed_perr=0.05, max_paths_per_outcome=1000, perr_heuristic='none', max_term_stages=5) print("Num params = ", target_model.num_params) target_model.from_vector(self.rand_start36) results = pygsti.run_long_sequence_gst( self.redmod_ds, target_model, self.redmod_fiducials, self.redmod_fiducials, self.redmod_germs, self.redmod_maxLs, verbosity=4, advanced_options={'tolerance': 1e-3}) print("MISFIT nSigma = ", results.estimates[results.name].misfit_sigma()) self.assertAlmostEqual(results.estimates[results.name].misfit_sigma(), 0.0, delta=1.0)
def test_idletomog_gstdata_std1Q(self): from pygsti.modelpacks.legacy import std1Q_XYI as std std = pygsti.modelpacks.stdtarget.stdmodule_to_smqmodule(std) maxLens = [1, 2, 4] expList = pygsti.circuits.create_lsgst_circuits( std.target_model(), std.prepStrs, std.effectStrs, std.germs_lite, maxLens) ds = pygsti.data.simulate_data(std.target_model().depolarize( 0.01, 0.01), expList, 1000, 'multinomial', seed=1234) result = pygsti.run_long_sequence_gst(ds, std.target_model(), std.prepStrs, std.effectStrs, std.germs_lite, maxLens, verbosity=3) #standard report will run idle tomography report = pygsti.report.construct_standard_report( result, "Test GST Report w/Idle Tomography Tab: StdXYI", advanced_options={'idt_idle_oplabel': ()}, verbosity=3) idt_sections = list( filter( lambda x: isinstance( x, pygsti.report.section.IdleTomographySection), report._sections)) self.assertEqual(len(idt_sections), 1) self.assertTrue( isinstance( report._global_qtys['top_switchboard'].idtresults.base[0], pygsti.extras.idletomography.idtresults.IdleTomographyResults))
def test_reducedmod_matrix(self): # Using dense matrices and matrix-based calcs target_model = pc.build_nqnoise_model(self.nQubits, geometry="line", max_idle_weight=1, maxhops=1, extra_weight_1_hops=0, extra_gate_weight=1, sparse=False, sim_type="matrix", verbosity=1) target_model.from_vector(self.rand_start206) results = pygsti.run_long_sequence_gst( self.redmod_ds, target_model, self.redmod_fiducials, self.redmod_fiducials, self.redmod_germs, self.redmod_maxLs, verbosity=4, advanced_options={'tolerance': 1e-3}) #RUN BELOW LINES TO SAVE GATESET (UNCOMMENT to regenerate) #pygsti.io.json.dump(results.estimates['default'].models['go0'], # open(compare_files + "/test2Qcalc_redmod_exact.model",'w')) print("MISFIT nSigma = ", results.estimates['default'].misfit_sigma()) self.assertAlmostEqual(results.estimates['default'].misfit_sigma(), 1.0, delta=1.0) mdl_compare = pygsti.serialization.json.load( open(compare_files + "/test2Qcalc_redmod_exact.model")) self.assertAlmostEqual( results.estimates['default'].models['go0'].frobeniusdist( mdl_compare), 0, places=3)
seed=1234) ds2 = pygsti.construction.simulate_data(gs_datagen2, listOfExperiments, n_samples=1000, sample_error="binomial", seed=1234) ds3 = ds1.copy_nonstatic() ds3.add_counts_from_dataset(ds2) ds3.done_adding_data() #Run GST on all three datasets gs_target.set_all_parameterizations("TP") results1 = pygsti.run_long_sequence_gst(ds1, gs_target, fiducials, fiducials, germs, maxLengths, verbosity=0) results2 = pygsti.run_long_sequence_gst(ds2, gs_target, fiducials, fiducials, germs, maxLengths, verbosity=0) results3 = pygsti.run_long_sequence_gst(ds3, gs_target, fiducials, fiducials, germs,
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(ReportBaseCase, cls).setUpClass() orig_cwd = os.getcwd() os.chdir(os.path.abspath(os.path.dirname(__file__))) os.chdir('..') # The test_packages directory target_model = std.target_model() datagen_gateset = target_model.depolarize(op_noise=0.05, spam_noise=0.1) datagen_gateset2 = target_model.depolarize(op_noise=0.1, spam_noise=0.05).rotate((0.15,-0.03,0.03)) #cls.specs = pygsti.construction.build_spam_specs(std.fiducials, effect_labels=['E0']) # #only use the first EVec op_labels = std.gates cls.lgstStrings = pygsti.circuits.create_lgst_circuits(std.fiducials, std.fiducials, op_labels) cls.maxLengthList = [1,2,4,8] cls.lsgstStrings = pygsti.circuits.create_lsgst_circuit_lists( op_labels, std.fiducials, std.fiducials, std.germs, cls.maxLengthList) cls.lsgstStructs = pygsti.circuits.make_lsgst_structs( op_labels, std.fiducials, std.fiducials, std.germs, cls.maxLengthList) # RUN BELOW LINES TO GENERATE ANALYSIS DATASET (SAVE) if regenerate_references(): ds = pygsti.data.simulate_data(datagen_gateset, cls.lsgstStrings[-1], num_samples=1000, sample_error='binomial', seed=100) ds.save(compare_files + "/reportgen.dataset") ds2 = pygsti.data.simulate_data(datagen_gateset2, cls.lsgstStrings[-1], num_samples=1000, sample_error='binomial', seed=100) ds2.save(compare_files + "/reportgen2.dataset") cls.ds = pygsti.data.DataSet(file_to_load_from=compare_files + "/reportgen.dataset") cls.ds2 = pygsti.data.DataSet(file_to_load_from=compare_files + "/reportgen2.dataset") mdl_lgst = pygsti.run_lgst(cls.ds, std.fiducials, std.fiducials, target_model, svd_truncate_to=4, verbosity=0) mdl_lgst_go = pygsti.gaugeopt_to_target(mdl_lgst, target_model, {'gates': 1.0, 'spam': 0.0}) cls.mdl_clgst = pygsti.contract(mdl_lgst_go, "CPTP") cls.mdl_clgst_tp = pygsti.contract(cls.mdl_clgst, "vSPAM") cls.mdl_clgst_tp.set_all_parameterizations("full TP") #Compute results for MC2GST lsgst_gatesets_prego, *_ = pygsti.run_iterative_gst( cls.ds, cls.mdl_clgst, cls.lsgstStrings, optimizer={'tol': 1e-5}, iteration_objfn_builders=['chi2'], final_objfn_builders=[], resource_alloc=None, verbosity=0 ) experiment_design = pygsti.protocols.StandardGSTDesign( target_model.create_processor_spec(), std.fiducials, std.fiducials, std.germs, cls.maxLengthList ) data = pygsti.protocols.ProtocolData(experiment_design, cls.ds) protocol = pygsti.protocols.StandardGST() cls.results = pygsti.protocols.gst.ModelEstimateResults(data, protocol) cls.results.add_estimate(pygsti.protocols.estimate.Estimate.create_gst_estimate( cls.results, target_model, cls.mdl_clgst,lsgst_gatesets_prego, {'objective': "chi2", 'min_prob_clip_for_weighting': 1e-4, 'prob_clip_interval': (-1e6,1e6), 'radius': 1e-4, 'weights': None, 'defaultDirectory': temp_files + "", 'defaultBasename': "MyDefaultReportName"} )) gaugeOptParams = collections.OrderedDict([ ('model', lsgst_gatesets_prego[-1]), #so can gauge-propagate CIs ('target_model', target_model), #so can gauge-propagate CIs ('cptp_penalty_factor', 0), ('gates_metric',"frobenius"), ('spam_metric',"frobenius"), ('item_weights', {'gates': 1.0, 'spam': 0.001}), ('return_all', True) ]) _, gaugeEl, go_final_gateset = pygsti.gaugeopt_to_target(**gaugeOptParams) gaugeOptParams['_gaugeGroupEl'] = gaugeEl #so can gauge-propagate CIs cls.results.estimates['default'].add_gaugeoptimized(gaugeOptParams, go_final_gateset) cls.results.estimates['default'].add_gaugeoptimized(gaugeOptParams, go_final_gateset, "go_dup") #Compute results for MLGST with TP constraint # Use run_long_sequence_gst with a non-mark dataset to trigger data scaling tp_target = target_model.copy(); tp_target.set_all_parameterizations("full TP") cls.ds3 = cls.ds.copy_nonstatic() cls.ds3.add_counts_from_dataset(cls.ds2) cls.ds3.done_adding_data() cls.results_logL = pygsti.run_long_sequence_gst(cls.ds3, tp_target, std.fiducials, std.fiducials, std.germs, cls.maxLengthList, verbosity=0, advanced_options={'tolerance': 1e-6, 'starting_point': 'LGST', 'on_bad_fit': ["robust","Robust","robust+","Robust+"], 'bad_fit_threshold': -1.0, 'germ_length_limits': {('Gx','Gi','Gi'): 2} }) #OLD #lsgst_gatesets_TP = pygsti.do_iterative_mlgst(cls.ds, cls.mdl_clgst_tp, cls.lsgstStrings, verbosity=0, # min_prob_clip=1e-4, prob_clip_interval=(-1e6,1e6), # returnAll=True) #TP initial model => TP output models #cls.results_logL = pygsti.objects.Results() #cls.results_logL.init_dataset(cls.ds) #cls.results_logL.init_circuits(cls.lsgstStructs) #cls.results_logL.add_estimate(target_model, cls.mdl_clgst_tp, # lsgst_gatesets_TP, # {'objective': "logl", # 'min_prob_clip': 1e-4, # 'prob_clip_interval': (-1e6,1e6), 'radius': 1e-4, # 'weights': None, 'defaultDirectory': temp_files + "", # 'defaultBasename': "MyDefaultReportName"}) # #tp_target = target_model.copy(); tp_target.set_all_parameterizations("full TP") #gaugeOptParams = gaugeOptParams.copy() #just to be safe #gaugeOptParams['model'] = lsgst_gatesets_TP[-1] #so can gauge-propagate CIs #gaugeOptParams['target_model'] = tp_target #so can gauge-propagate CIs #_, gaugeEl, go_final_gateset = pygsti.gaugeopt_to_target(**gaugeOptParams) #gaugeOptParams['_gaugeGroupEl'] = gaugeEl #so can gauge-propagate CIs #cls.results_logL.estimates['default'].add_gaugeoptimized(gaugeOptParams, go_final_gateset) # ##self.results_logL.options.precision = 3 ##self.results_logL.options.polar_precision = 2 os.chdir(orig_cwd)
def test_3Q(self): ##only test when reps are fast (b/c otherwise this test is slow!) #try: from pygsti.objects.replib 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, simulator="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, verbosity=1, roughNoise=(1234, 0.1), simulator="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()))) op_labels = target_model.primitive_op_labels line_labels = tuple(range(nQubits)) fids1Q = std1Q_XY.fiducials fiducials = [] for i in range(nQubits): fiducials.extend( pygsti.circuits.manipulate_circuits(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.circuits.to_circuits([(gl, ) for gl in op_labels], line_labels=line_labels) maxLs = [1] expList = pygsti.circuits.create_lsgst_circuits( mdl_datagen, prep_fiducials, meas_fiducials, germs, maxLs) self.assertTrue(Circuit((), line_labels) in expList) ds = pygsti.data.simulate_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.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.run_long_sequence_gst( ds, target_model, prep_fiducials, meas_fiducials, germs, maxLs, verbosity=5, advanced_options={ 'max_iterations': 2 }) #keep this short; don't care if it doesn't converge. print("DONE!")
def main(): gs_target = std1Q_XYI.gs_target fiducials = std1Q_XYI.fiducials germs = std1Q_XYI.germs maxLengths = [1, 2, 4] #maxLengths = [1, 2, 4, 8, 16, 32, 64] #Generate some data gs_datagen = gs_target.depolarize(gate_noise=0.1, spam_noise=0.001) gs_datagen = gs_datagen.rotate(rotate=0.04) listOfExperiments = pygsti.construction.create_lsgst_circuits( gs_target, fiducials, fiducials, germs, maxLengths) ds = pygsti.construction.simulate_data(gs_datagen, listOfExperiments, n_samples=1000, sample_error="binomial", seed=1234) #Run GST gs_target.set_all_parameterizations("TP") #TP-constrained results = pygsti.run_long_sequence_gst(ds, gs_target, fiducials, fiducials, germs, maxLengths, verbosity=0) with open('data/example_report_results.pkl', 'wb') as outfile: pickle.dump(results, outfile, protocol=2) # Case1: TP-constrained GST tpTarget = gs_target.copy() tpTarget.set_all_parameterizations("TP") results_tp = pygsti.run_long_sequence_gst(ds, tpTarget, fiducials, fiducials, germs, maxLengths, gauge_opt_params=False, verbosity=0) # Gauge optimize est = results_tp.estimates['default'] gsFinal = est.gatesets['final iteration estimate'] gsTarget = est.gatesets['target'] for spamWt in [1e-4, 1e-3, 1e-2, 1e-1, 1.0]: gs = pygsti.gaugeopt_to_target(gsFinal, gsTarget, { 'gates': 1, 'spam': spamWt }) est.add_gaugeoptimized({'item_weights': { 'gates': 1, 'spam': spamWt }}, gs, "Spam %g" % spamWt) #Case2: "Full" GST fullTarget = gs_target.copy() fullTarget.set_all_parameterizations("full") results_full = pygsti.run_long_sequence_gst(ds, fullTarget, fiducials, fiducials, germs, maxLengths, gauge_opt_params=False, verbosity=0) #Gauge optimize est = results_full.estimates['default'] gsFinal = est.gatesets['final iteration estimate'] gsTarget = est.gatesets['target'] for spamWt in [1e-4, 1e-3, 1e-2, 1e-1, 1.0]: gs = pygsti.gaugeopt_to_target(gsFinal, gsTarget, { 'gates': 1, 'spam': spamWt }) est.add_gaugeoptimized({'item_weights': { 'gates': 1, 'spam': spamWt }}, gs, "Spam %g" % spamWt) with open('data/full_report_results.pkl', 'wb') as outfile: pickle.dump((results_tp, results_full), outfile, protocol=2)
def testIntermediateMeas(self): # Mess with the target model to add some error to the povm and instrument self.assertEqual(self.target_model.num_params,92) # 4*3 + 16*5 = 92 mdl = self.target_model.depolarize(op_noise=0.01, spam_noise=0.01) gs2 = self.target_model.depolarize(max_op_noise=0.01, max_spam_noise=0.01, seed=1234) #another way to depolarize mdl.povms['Mdefault'].depolarize(0.01) # Introducing a rotation error to the measurement Uerr = pygsti.rotation_gate_mx([0, 0.02, 0]) # input angles are halved by the method E = np.dot(mdl.povms['Mdefault']['0'].T,Uerr).T # effect is stored as column vector Erem = self.povm_ident - E mdl.povms['Mdefault'] = pygsti.modelmembers.povms.UnconstrainedPOVM({'0': E, '1': Erem}, evotype='default') # Now add the post-measurement gates from the vector E0 and remainder = id-E0 Gmz_plus = np.dot(E,E.T) #since E0 is stored internally as column spamvec Gmz_minus = np.dot(Erem,Erem.T) mdl.instruments['Iz'] = pygsti.modelmembers.instruments.Instrument({'plus': Gmz_plus, 'minus': Gmz_minus}) self.assertEqual(mdl.num_params,92) # 4*3 + 16*5 = 92 #print(mdl) germs = std.germs fiducials = std.fiducials max_lengths = [1] #,2,4,8] glbls = list(mdl.operations.keys()) + list(mdl.instruments.keys()) lsgst_struct = pygsti.circuits.create_lsgst_circuits( glbls,fiducials,fiducials,germs,max_lengths) lsgst_struct2 = pygsti.circuits.create_lsgst_circuits( mdl,fiducials,fiducials,germs,max_lengths) #use mdl as source self.assertEqual(list(lsgst_struct), list(lsgst_struct2)) mdl_datagen = mdl ds = pygsti.data.simulate_data(mdl, lsgst_struct, 1000, 'none') #'multinomial') pygsti.io.write_dataset(temp_files + "/intermediate_meas_dataset.txt", ds) ds2 = pygsti.io.read_dataset(temp_files + "/intermediate_meas_dataset.txt") for opstr,dsRow in ds.items(): for lbl,cnt in dsRow.counts.items(): self.assertAlmostEqual(cnt, ds2[opstr].counts[lbl],places=2) #print(ds) #LGST mdl_lgst = pygsti.run_lgst(ds, fiducials, fiducials, self.target_model) #, guessModelForGauge=mdl_datagen) self.assertTrue("Iz" in mdl_lgst.instruments) mdl_opt = pygsti.gaugeopt_to_target(mdl_lgst, mdl_datagen) #, method="BFGS") print(mdl_datagen.strdiff(mdl_opt)) print("Frobdiff = ",mdl_datagen.frobeniusdist( mdl_lgst)) print("Frobdiff after GOpt = ",mdl_datagen.frobeniusdist(mdl_opt)) self.assertAlmostEqual(mdl_datagen.frobeniusdist(mdl_opt), 0.0, places=4) #print(mdl_lgst) #print(mdl_datagen) #DEBUG compiling w/dataset #dbList = pygsti.circuits.create_lsgst_circuits(self.target_model,fiducials,fiducials,germs,max_lengths) ##self.target_model.simplify_circuits(dbList, ds) #self.target_model.simplify_circuits([ pygsti.circuits.Circuit(None,stringrep="Iz") ], ds ) #assert(False),"STOP" #LSGST results = pygsti.run_long_sequence_gst(ds, self.target_model, fiducials, fiducials, germs, max_lengths) #print(results.estimates[results.name].models['go0']) mdl_est = results.estimates[results.name].models['go0'] mdl_est_opt = pygsti.gaugeopt_to_target(mdl_est, mdl_datagen) print("Frobdiff = ", mdl_datagen.frobeniusdist(mdl_est)) print("Frobdiff after GOpt = ", mdl_datagen.frobeniusdist(mdl_est_opt)) self.assertAlmostEqual(mdl_datagen.frobeniusdist(mdl_est_opt), 0.0, places=4) #LGST w/TP gates mdl_targetTP = self.target_model.copy() mdl_targetTP.set_all_parameterizations("full TP") self.assertEqual(mdl_targetTP.num_params,71) # 3 + 4*2 + 12*5 = 71 #print(mdl_targetTP) resultsTP = pygsti.run_long_sequence_gst(ds, mdl_targetTP, fiducials, fiducials, germs, max_lengths, verbosity=4) mdl_est = resultsTP.estimates[resultsTP.name].models['go0'] mdl_est_opt = pygsti.gaugeopt_to_target(mdl_est, mdl_datagen) print("TP Frobdiff = ", mdl_datagen.frobeniusdist(mdl_est)) print("TP Frobdiff after GOpt = ", mdl_datagen.frobeniusdist(mdl_est_opt)) self.assertAlmostEqual(mdl_datagen.frobeniusdist(mdl_est_opt), 0.0, places=4)
gs_datagen = gs_target.depolarize(gate_noise=0.1, spam_noise=0.001) ds = pygsti.construction.simulate_data(gs_datagen, listOfExperiments, n_samples=1000, sample_error="multinomial", seed=2016) start = time.time() ''' results = pygsti.run_long_sequence_gst(ds, gs_target, prep_fiducials, effect_fiducials, germs4, maxLengths, gaugeOptParams={'item_weights': {'spam':0.1,'gates': 1.0}}, advancedOptions={ 'depolarizeStart' : 0.1 }, mem_limit=3*(1024)**3, verbosity=3 ) ''' results = pygsti.run_long_sequence_gst( ds, gs_target, prep_fiducials, effect_fiducials, germs4, maxLengths, gauge_opt_params=None, advanced_options={'depolarizeStart': 0.1}, mem_limit=3 * (1024)**3, verbosity=3) end = time.time() print("Total time=%f hours" % ((end - start) / 3600.0)) #If you wanted to, you could pickle the results for later analysis: pickle.dump(results, open("gaugeopt/2qbit_results.pkl", "wb"))