def test_MHRWParams(self):
# default constructor
mhrw = tomographer.MHRWParams()
# constructor with parameters
mhrw = tomographer.MHRWParams({'step_size': 0.01}, 100, 500, 32768)
# constructor with keyword arguments
mhrw = tomographer.MHRWParams(step_size=0.01,
n_sweep=100,
n_therm=500,
n_run=32768)
# make sure params are stored correctly
self.assertAlmostEqual(mhrw.mhwalker_params["step_size"], 0.01)
self.assertEqual(mhrw.n_sweep, 100)
self.assertEqual(mhrw.n_therm, 500)
self.assertEqual(mhrw.n_run, 32768)
# attributes should be writable
mhrw.mhwalker_params = {'step_size': 0.06}
self.assertAlmostEqual(mhrw.mhwalker_params["step_size"], 0.06)
mhrw.n_sweep = 200
self.assertEqual(mhrw.n_sweep, 200)
mhrw.n_therm = 1024
self.assertEqual(mhrw.n_therm, 1024)
mhrw.n_run = 8192
self.assertEqual(mhrw.n_run, 8192)
def test_rand_walk(self):
r = None
with tomographer.jpyutil.RandWalkProgressBar(
"random walk in progress") as prg:
# just run tomorun on some arbitrary data to get some stuff to check
mhrw_params = tomographer.MHRWParams(step_size=0.04,
n_sweep=25,
n_run=8192,
n_therm=500)
hist_params = tomographer.UniformBinsHistogramParams(0.985, 1, 20)
binning_num_levels = 7
r = tomographer.tomorun.tomorun(
dim=2,
Emn=[
np.array([[0.5, -0.5j], [0.5j, 0.5]]),
np.array([[0.5, 0.5j], [-0.5j, 0.5]])
],
Nm=np.array([500, 0]),
fig_of_merit="obs-value",
observable=np.array([[0.5, -0.5j], [0.5j, 0.5]]),
num_repeats=2,
binning_num_levels=binning_num_levels,
mhrw_params=mhrw_params,
hist_params=hist_params,
progress_fn=prg.progress_fn,
)
prg.displayFinalInfo(r['final_report_runs'])
def test_custom_figofmerit(self):
print("test_custom_figofmerit()")
num_repeats = 2
hist_params = tomographer.HistogramParams(0.99, 1, 20)
r = tomographer.tomorun.tomorun(
dim=2,
Emn=self.Emn,
Nm=self.Nm,
fig_of_merit=lambda T: npl.norm(np.dot(T, T.T.conj())), # purity
ref_state=self.rho_ref,
num_repeats=num_repeats,
mhrw_params=tomographer.MHRWParams(step_size=0.04,
n_sweep=25,
n_run=8192,
n_therm=1024),
hist_params=hist_params,
progress_fn=lambda report: print(report.getHumanReport()),
progress_interval_ms=100)
print(r['final_report'])
# just make sure that less than 1% of points are out of [0.99,1]
self.assertLess(r['final_histogram'].off_chart, 0.01)
def do_tomorun():
d = {}
d['result'] = tomographer.tomorun.tomorun(
dim=2,
Emn=[
# +Y
np.array([[0.5, -0.5j], [0.5j, 0.5]]),
# -Y
np.array([[0.5, 0.5j], [-0.5j, 0.5]])
],
Nm=np.array([423, 87]),
fig_of_merit="obs-value",
observable=np.array([[0.5, -0.5j], [0.5j, 0.5]]),
mhrw_params=tomographer.MHRWParams(step_size=0.1,
n_sweep=10,
n_run=32768,
n_therm=500),
hist_params=tomographer.UniformBinsHistogramParams(0.7, 0.9, 20),
progress_fn=lambda x: print(x.getHumanReport()))
# save all of this stuff as a pickle
with open(os.path.join(pickledatadir, 'tomorun.pickle'), 'wb') as f:
pickle.dump(d, f, 2)
def test_mhwalker_param_2(self):
print("test_mhwalker_param_2()")
num_repeats = 2
hist_params = tomographer.HistogramParams(0.99, 1, 10)
r = tomographer.tomorun.tomorun(
dim=2,
Emn=self.Emn,
Nm=self.Nm,
fig_of_merit="fidelity",
ref_state=self.rho_ref,
num_repeats=num_repeats,
# understands step size given as keyword argument? ---
mhrw_params=tomographer.MHRWParams(step_size=0.04,
n_sweep=25,
n_therm=1024,
n_run=1024),
# ---
hist_params=hist_params,
ctrl_step_size_params={'enabled': False},
ctrl_converged_params={'enabled': False},
)
print(r['final_report'])
for rw in r['runs_results']:
self.assertAlmostEqual(rw.mhrw_params.mhwalker_params["step_size"],
0.04)
def test_error_in_callback(self):
print("test_error_in_callback()")
num_repeats = 2
hist_params = tomographer.HistogramParams(0.985, 1, 200)
class Ns:
pass
#
# Make sure an error in the callback raises an Exception
#
def progress_callback(fullstatusreport):
error - xxx(xyz) # error -- raises a Python exception
print(fullstatusreport.getHumanReport())
intvl_ms = 200
with self.assertRaises(Exception):
r = tomographer.tomorun.tomorun(
dim=2,
Emn=self.Emn,
Nm=self.Nm,
fig_of_merit="obs-value",
observable=self.rho_ref,
num_repeats=num_repeats,
mhrw_params=tomographer.MHRWParams(step_size=0.04,
n_sweep=25,
n_run=4 * 32768,
n_therm=1024),
hist_params=hist_params,
progress_fn=progress_callback,
progress_interval_ms=intvl_ms,
)
def test_mhwalker_param_5(self):
print("test_mhwalker_param_5()")
num_repeats = 2
hist_params = tomographer.HistogramParams(0.99, 1, 10)
r = tomographer.tomorun.tomorun(
dim=2,
Emn=self.Emn,
Nm=self.Nm,
fig_of_merit="fidelity",
ref_state=self.rho_ref,
num_repeats=num_repeats,
# understands missing key? ---
mhrw_params=tomographer.MHRWParams({}, 25, 500, 1024),
# ---
hist_params=hist_params,
ctrl_step_size_params={'enabled': True}, # auto-adjust
ctrl_converged_params={'enabled': False},
)
print(r['final_report'])
for rw in r['runs_results']:
self.assertLessEqual(rw.mhrw_params.mhwalker_params["step_size"],
0.1)
self.assertGreaterEqual(
rw.mhrw_params.mhwalker_params["step_size"], 0.005)
def test_fields(self):
def prg_callback(x):
print(x.getHumanReport())
# just run tomorun on some arbitrary data to get some stuff to check
mhrw_params = tomographer.MHRWParams(step_size=0.04,
n_sweep=25,
n_run=8192,
n_therm=500)
hist_params = tomographer.HistogramParams(0.985, 1, 20)
binning_num_levels = 7
r = tomographer.tomorun.tomorun(
dim=2,
Emn=[
np.array([[0.5, -0.5j], [0.5j, 0.5]]),
np.array([[0.5, 0.5j], [-0.5j, 0.5]])
],
Nm=np.array([500, 0]),
fig_of_merit="obs-value",
observable=np.array([[0.5, -0.5j], [0.5j, 0.5]]),
num_repeats=2,
binning_num_levels=binning_num_levels,
mhrw_params=mhrw_params,
hist_params=hist_params,
ctrl_step_size_params={'enable': False},
progress_interval_ms=500,
progress_fn=prg_callback,
)
# check that all fields are there and display meaningful values
runres = r['runs_results'][0]
self.assertAlmostEqual(runres.mhrw_params.mhwalker_params["step_size"],
mhrw_params.mhwalker_params["step_size"])
self.assertEqual(runres.mhrw_params.n_sweep, mhrw_params.n_sweep)
self.assertEqual(runres.mhrw_params.n_therm, mhrw_params.n_therm)
self.assertEqual(runres.mhrw_params.n_run, mhrw_params.n_run)
self.assertGreater(runres.acceptance_ratio, 0.2)
self.assertLess(runres.acceptance_ratio, 0.4)
stats_results = runres.stats_results
self.assertEqual(stats_results.histogram.numBins(),
hist_params.num_bins)
npt.assert_array_equal(stats_results.error_levels.shape,
[hist_params.num_bins, binning_num_levels + 1])
# the last error level should be the reported error bar:
npt.assert_array_almost_equal(
stats_results.error_levels[:, binning_num_levels],
stats_results.histogram.delta)
for c in stats_results.converged_status:
self.assertIn(c, (tomographer.BinningAnalysis.CONVERGED,
tomographer.BinningAnalysis.NOT_CONVERGED,
tomographer.BinningAnalysis.UNKNOWN_CONVERGENCE))
def test_values_light(self):
print("test_values_light()")
num_repeats = 8
hist_params = tomographer.HistogramParams(0.985, 1, 200)
r = tomographer.tomorun.tomorun(
dim=2,
Emn=self.Emn,
Nm=self.Nm,
fig_of_merit="fidelity",
ref_state=self.rho_ref,
num_repeats=num_repeats,
mhrw_params=tomographer.MHRWParams(step_size=0.04,
n_sweep=25,
n_run=32768,
n_therm=1024),
jumps_method="light",
hist_params=hist_params,
progress_fn=lambda report: print(report.getHumanReport()),
progress_interval_ms=500,
ctrl_converged_params={
'max_allowed_not_converged': 1,
'max_allowed_unknown_notisolated': 1,
'max_allowed_unknown': 3,
})
print("Final report of runs :\n{}".format(r['final_report_runs']))
print("Final report of everything :\n{}".format(r['final_report']))
final_histogram = r['final_histogram']
self.assertTrue(
isinstance(final_histogram, tomographer.AveragedErrorBarHistogram))
simple_final_histogram = r['simple_final_histogram']
self.assertTrue(
isinstance(simple_final_histogram,
tomographer.AveragedSimpleRealHistogram))
print("Tomorun completed in {} seconds".format(r['elapsed_seconds']))
for k in range(num_repeats):
runres = r['runs_results'][k]
self.assertTrue(
isinstance(runres,
tomographer.mhrwtasks.MHRandomWalkTaskResult))
# now, check the actual values of the result
pok = AnalyticalSolutionFn(np.sum(self.Nm))
# can't be too picky on chi2, because this test will run many times (so it's bound
# to fail at some point!)
self.assertLess(pok.get_histogram_chi2_red(final_histogram), 5)
npt.assert_array_almost_equal(final_histogram.bins,
simple_final_histogram.bins)
def test_pickle(self):
hist = tomographer.HistogramWithErrorBars(0, 1, 3)
stats_results = tomographer.ValueHistogramWithBinningMHRWStatsCollectorResult(
hist, np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9], [10, 11, 12]]),
np.array([
tomographer.BinningAnalysis.CONVERGED,
tomographer.BinningAnalysis.NOT_CONVERGED,
tomographer.BinningAnalysis.UNKNOWN_CONVERGENCE
]))
mhrw_task_result = tomographer.mhrwtasks.MHRandomWalkTaskResult(
stats_results, tomographer.MHRWParams(0.03, 37, 400, 65538), 0.27)
# see http://pybind11.readthedocs.io/en/master/advanced/classes.html#pickling-support
try:
import cPickle as pickle
except:
import pickle
s = pickle.dumps(mhrw_task_result, 2)
print("PICKLE:\n" + str(s))
mhrw_task_result2 = pickle.loads(s)
m = mhrw_task_result
m2 = mhrw_task_result2
self.assertAlmostEqual(m.acceptance_ratio, m2.acceptance_ratio)
self.assertAlmostEqual(m.mhrw_params.mhwalker_params,
m2.mhrw_params.mhwalker_params)
self.assertEqual(m.mhrw_params.n_sweep, m2.mhrw_params.n_sweep)
self.assertEqual(m.mhrw_params.n_therm, m2.mhrw_params.n_therm)
self.assertEqual(m.mhrw_params.n_run, m2.mhrw_params.n_run)
npt.assert_array_almost_equal(m.stats_results.histogram.bins,
m2.stats_results.histogram.bins)
npt.assert_array_almost_equal(m.stats_results.histogram.delta,
m2.stats_results.histogram.delta)
npt.assert_array_almost_equal(m.stats_results.error_levels,
m2.stats_results.error_levels)
npt.assert_array_equal(m.stats_results.converged_status,
m2.stats_results.converged_status)
summary = m2.stats_results.errorBarConvergenceSummary()
self.assertEqual(summary.n_bins, m.stats_results.histogram.numBins())
self.assertEqual(summary.n_converged, 1)
self.assertEqual(summary.n_unknown, 1)
self.assertEqual(summary.n_unknown_isolated, 0)
self.assertEqual(summary.n_not_converged, 1)
# pickle the summary itself?
s2 = pickle.dumps(summary, 2)
print("PICKLE OF SUMMARY:\n" + str(s2))
summary2 = pickle.loads(s2)
self.assertEqual(summary2.n_bins, m.stats_results.histogram.numBins())
self.assertEqual(summary2.n_converged, 1)
self.assertEqual(summary2.n_unknown, 1)
self.assertEqual(summary2.n_unknown_isolated, 0)
self.assertEqual(summary2.n_not_converged, 1)
def test_custom_figofmerit_parallel(self):
print("test_custom_figofmerit_parallel()")
num_repeats = 8
hist_params = tomographer.HistogramParams(0.99, 1, 20)
mhrw_params = tomographer.MHRWParams(step_size=0.04,
n_sweep=25,
n_run=8192,
n_therm=1024)
class Ns:
pass
glob = Ns()
glob.saw_parallel_runs = False
def is_running(w):
if w is None:
return False
return w.data['kstep'] > (mhrw_params.n_therm +
2) * mhrw_params.n_sweep
def prg_fn(report):
print(report.getHumanReport())
num_running = sum([(1 if is_running(w) else 0)
for w in report.workers])
if num_running > 1:
glob.saw_parallel_runs = num_running
raise Exception("Done, test passed.")
try:
r = tomographer.tomorun.tomorun(
dim=2,
Emn=self.Emn,
Nm=self.Nm,
fig_of_merit=lambda T: npl.norm(np.dot(T, T.T.conj())
), # purity
ref_state=self.rho_ref,
num_repeats=num_repeats,
mhrw_params=mhrw_params,
hist_params=hist_params,
progress_fn=prg_fn,
progress_interval_ms=50,
ctrl_step_size_params={'enabled': False},
)
except Exception as e:
if 'Done, test passed' not in str(e):
raise
self.assertGreaterEqual(glob.saw_parallel_runs, 2)
def test_base_seed(self):
print("test_base_seed()")
hist_params = tomographer.HistogramParams(0.985, 1, 50)
samples = []
def save_sample(T):
samples.append(T)
return 0
# momentarily disable warnings because tomorun will warn about binning levels too low
oldlevel = logging.getLogger("tomographer").level
try:
logging.getLogger("tomographer").level = logging.ERROR
runs_samples = []
for n in range(64):
# reset samples list, go
print("Tomorun run #", n)
samples = []
res = tomographer.tomorun.tomorun(
dim=2,
Emn=self.Emn,
Nm=self.Nm,
fig_of_merit=save_sample,
num_repeats=1,
mhrw_params=tomographer.MHRWParams(
step_size=0.04,
n_sweep=25,
n_therm=10, # don't let it thermalize too much
n_run=1024,
),
hist_params=hist_params,
ctrl_step_size_params={'enabled': False},
ctrl_converged_params={'enabled': False},
rng_base_seed=n)
runs_samples.append(samples[10])
finally:
logging.getLogger("tomographer").level = oldlevel
avgT = sum(runs_samples) / len(runs_samples)
print("avgT = ", repr(avgT))
spread = np.prod([npl.norm(T - avgT) for T in runs_samples])
print("spread = ", repr(spread))
self.assertGreater(spread, 0.2)
def test_errbar_convergence(self):
print("test_errbar_convergence()")
num_repeats = 2
hist_params = tomographer.HistogramParams(0.995, 1, 100)
r = tomographer.tomorun.tomorun(
dim=2,
Emn=self.Emn,
Nm=self.Nm,
fig_of_merit="fidelity",
ref_state=self.rho_ref,
num_repeats=num_repeats,
mhrw_params=tomographer.MHRWParams(
step_size=0.04,
n_sweep=25,
n_run=8192, # controller will keep running as necessary
n_therm=1024),
hist_params=hist_params,
ctrl_converged_params={
'max_allowed_unknown': 2,
'max_allowed_unknown_notisolated': 2,
'max_allowed_not_converged': 0,
# run as long as necessary
'max_add_run_iters': -1
},
progress_fn=lambda report: print(report.getHumanReport()),
progress_interval_ms=50)
print("Final report of runs :\n{}".format(r['final_report_runs']))
# inspect the task runs
for k in range(num_repeats):
runres = r['runs_results'][k]
# check that bins have converged as required
self.assertLessEqual(
(runres.stats_results.converged_status ==
tomographer.BinningAnalysis.NOT_CONVERGED *
np.ones([hist_params.num_bins], dtype=int)).sum(), 0)
self.assertLessEqual(
(runres.stats_results.converged_status ==
tomographer.BinningAnalysis.UNKNOWN_CONVERGENCE *
np.ones([hist_params.num_bins], dtype=int)).sum(), 2)
def test_too_few_runs(self):
print("test_too_few_runs()")
num_repeats = 2
hist_params = tomographer.HistogramParams(0.99, 1, 10)
r = tomographer.tomorun.tomorun(
dim=2,
Emn=self.Emn,
Nm=self.Nm,
fig_of_merit="fidelity",
ref_state=self.rho_ref,
num_repeats=num_repeats,
mhrw_params=tomographer.MHRWParams(0.04, 25, 500,
100), # 100 is too few runs
hist_params=hist_params,
ctrl_step_size_params={'enabled': False},
ctrl_converged_params={'enabled': False},
)
def test_callback(self):
print("test_callback()")
num_repeats = 2
hist_params = tomographer.HistogramParams(0.985, 1, 200)
class Ns:
pass
glob = Ns()
glob.num_callback_calls = 0
def progress_callback(fullstatusreport):
glob.num_callback_calls += 1
print(fullstatusreport.getHumanReport())
intvl_ms = 200
r = tomographer.tomorun.tomorun(
dim=2,
Emn=self.Emn,
Nm=self.Nm,
fig_of_merit="obs-value",
observable=self.rho_ref,
num_repeats=num_repeats,
mhrw_params=tomographer.MHRWParams(step_size=0.04,
n_sweep=25,
n_run=4 * 32768,
n_therm=1024),
hist_params=hist_params,
progress_fn=progress_callback,
progress_interval_ms=intvl_ms,
ctrl_converged_params={'enabled': False},
)
# we have the total elapsed time in r['elapsed_seconds']
print("Total elapsed: {:.2g} seconds".format(r['elapsed_seconds']))
nc = 1000 * r['elapsed_seconds'] / intvl_ms
self.assertGreaterEqual(glob.num_callback_calls, 1)
self.assertLessEqual(glob.num_callback_calls, nc + 2)
def test_convergence_control_2(self):
print("test_convergence_control_2()")
num_repeats = 2
hist_params = tomographer.HistogramParams(0.985, 1, 50)
class Ns:
pass
glob = Ns()
glob.num_callback_calls = 0
def check_prg(report):
glob.num_callback_calls += 1
for r in report.workers:
if r is not None and r.fraction_done > 1:
raise AssertionError(
"Control is disabled, random walk should not go past 100%"
)
r = tomographer.tomorun.tomorun(
dim=2,
Emn=self.Emn,
Nm=self.Nm,
fig_of_merit="obs-value",
observable=self.rho_ref,
num_repeats=num_repeats,
mhrw_params=tomographer.MHRWParams(
step_size=0.1, # too high
n_sweep=100,
n_run=1024, # little
n_therm=1024), # little
hist_params=hist_params,
progress_fn=check_prg,
progress_interval_ms=1,
ctrl_converged_params={'enabled': False},
# keep step size a little off, to prevent bins from converging too nicely:
ctrl_step_size_params={'enabled': False},
)
# make sure progress reporter was called often enough
self.assertGreaterEqual(glob.num_callback_calls, 10)
def sampling(d, mmts, data, N, samplesize=2000):
#r = None # global variable
samples = []
def store_sample_figofmerit(T):
samples.append(T)
return 0
with tomographer.jpyutil.RandWalkProgressBar() as prg:
r = tomographer.tomorun.tomorun(
# the dimension of the quantum system
dim=d,
# the tomography data
Emn=mmts,
Nm=data * N,
# Random Walk parameters: step size, sweep size, number of thermalization sweeps, number of live sweeps
mhrw_params=tomographer.MHRWParams(0.01, 100, 2000, samplesize),
fig_of_merit=store_sample_figofmerit,
rng_base_seed=None,
progress_fn=prg.progress_fn)
prg.displayFinalInfo(r['final_report_runs'])
return samples
def test_chokes_on_extra_args(self):
# just make sure that tomorun() raises an exception if unexpected arguments are
# provided.
with self.assertRaises(tomographer.tomorun.TomorunInvalidInputError):
res = tomographer.tomorun.tomorun(
dim=2,
Emn=self.Emn,
Nm=self.Nm,
fig_of_merit='obs-value',
observable=self.rho_ref,
num_repeats=1,
mhrw_params=tomographer.MHRWParams(
step_size=0.04,
n_sweep=25,
n_therm=1024,
n_run=1024,
),
hist_params=tomographer.HistogramParams(),
base_seed=1234567890, # misspelled, should be "rng_base_seed"
abc_wrong={'x': 'y'} # just an additional arg
)
def do_numerics():
r = None
with tomographer.jpyutil.RandWalkProgressBar() as prg:
r = tomographer.tomorun.tomorun(
dim=dim,
Emn=Emn,
Nm=Nm,
jumps_method='light',
fig_of_merit='obs-value',
observable=proj_W,
hist_params=tomographer.HistogramParams(0.99908, 0.99911, 200),
mhrw_params=tomographer.MHRWParams(0.1, 50, 4096, 65536),
binning_num_levels=12,
ctrl_converged_params={
'enabled': True,
'max_allowed_not_converged': 20,
'max_allowed_unknown': 20,
'max_allowed_unknown_notisolated': 30
},
progress_fn=prg.progress_fn,
progress_interval_ms=2000,
)
prg.displayFinalInfo(r['final_report_runs'])
run_data = {
'd': {
'dim': dim,
'Emn': Emn,
'Nm': Nm,
'psi_W': psi_W,
'proj_W': proj_W
},
'r': r
}
with open(CACHE_FILE_NAME, 'wb') as f:
pickle.dump(run_data, f, 2)
return run_data
def test_verbose_logging_2(self):
print("test_verbose_logging_2()")
oldlevel = tomographer.cxxlogger.level
try:
logging.getLogger().setLevel(1) # LONGDEBUG
tomographer.cxxlogger.level = 1 # LONGDEBUG
def raise_stop_iter(T):
raise StopIteration
def prg_fn(report):
logging.getLogger("prg_fn").debug(report.getHumanReport())
# test: gets interrupted (test fix for some SEGFAULT I'm getting?)
with self.assertRaises(StopIteration):
r = tomographer.tomorun.tomorun(
dim=2,
Emn=self.Emn,
Nm=self.Nm,
fig_of_merit=raise_stop_iter,
num_repeats=4,
hist_params=tomographer.HistogramParams(0.99, 1, 20),
mhrw_params=tomographer.MHRWParams(
step_size=0.04,
# keep it REAL SHORT because we'll have tons of messages
n_sweep=5,
n_run=10,
n_therm=20),
progress_fn=prg_fn,
progress_interval_ms=50,
ctrl_step_size_params={'enabled': False},
)
finally:
# restore level
logging.getLogger().setLevel(oldlevel)
tomographer.cxxlogger.level = oldlevel
def test_stepsize_control_2(self):
print("test_stepsize_control_2()")
num_repeats = 2
hist_params = tomographer.HistogramParams(0.985, 1, 50)
orig_step_size = 0.5
orig_n_therm = 2
r = tomographer.tomorun.tomorun(
dim=2,
Emn=self.Emn,
Nm=self.Nm,
fig_of_merit="obs-value",
observable=self.rho_ref,
num_repeats=num_repeats,
mhrw_params=tomographer.MHRWParams(
step_size=orig_step_size, # must be adjusted
n_sweep=2,
n_run=1024,
n_therm=orig_n_therm),
hist_params=hist_params,
progress_fn=lambda report: print(report.getHumanReport()),
progress_interval_ms=100,
ctrl_step_size_params={'enabled': False},
ctrl_converged_params={'enabled': False},
)
for runres in r['runs_results']:
print("Step size is ",
runres.mhrw_params.mhwalker_params['step_size'])
print("and n_therm is ", runres.mhrw_params.n_therm)
# make sure it wasn't adjusted
self.assertAlmostEqual(
runres.mhrw_params.mhwalker_params['step_size'],
orig_step_size)
self.assertEqual(runres.mhrw_params.n_therm, orig_n_therm)
def test_stepsize_control_1(self):
print("test_stepsize_control_1()")
num_repeats = 2
hist_params = tomographer.HistogramParams(0.985, 1, 50)
r = tomographer.tomorun.tomorun(
dim=2,
Emn=self.Emn,
Nm=self.Nm,
fig_of_merit="obs-value",
observable=self.rho_ref,
num_repeats=num_repeats,
mhrw_params=tomographer.MHRWParams(
step_size=0.5, # must be adjusted
n_sweep=2,
n_run=1024,
n_therm=1),
hist_params=hist_params,
progress_fn=lambda report: print(report.getHumanReport()),
progress_interval_ms=100,
ctrl_step_size_params={'enabled': True},
ctrl_converged_params={'enabled': False},
)
for runres in r['runs_results']:
print("Step size is ",
runres.mhrw_params.mhwalker_params['step_size'])
print("and n_therm is ", runres.mhrw_params.n_therm)
self.assertLessEqual(
runres.mhrw_params.mhwalker_params['step_size'], 0.1)
self.assertGreaterEqual(
runres.mhrw_params.mhwalker_params['step_size'], 0.01)
self.assertGreaterEqual(runres.acceptance_ratio, 0.2)
self.assertLessEqual(runres.acceptance_ratio, 0.4)
self.assertGreaterEqual(runres.mhrw_params.n_therm,
20) # make sure it was adjusted
def test_convergence_control_1(self):
print("test_convergence_control_1()")
num_repeats = 2
hist_params = tomographer.HistogramParams(0.985, 1, 50)
r = tomographer.tomorun.tomorun(
dim=2,
Emn=self.Emn,
Nm=self.Nm,
fig_of_merit="obs-value",
observable=self.rho_ref,
num_repeats=num_repeats,
mhrw_params=tomographer.MHRWParams(
step_size=0.04,
n_sweep=25,
n_run=1024, # ridicoulously low
n_therm=200),
hist_params=hist_params,
progress_fn=lambda report: print(report.getHumanReport()),
progress_interval_ms=100,
ctrl_converged_params={
'enabled': True,
'max_allowed_unknown': 1,
'max_allowed_unknown_notisolated': 1,
'max_allowed_not_converged': 1,
# run as long as is necessary
'max_add_run_iters': -1
},
)
for runres in r['runs_results']:
summary = runres.stats_results.errorBarConvergenceSummary()
self.assertLessEqual(summary.n_unknown, 1)
self.assertLessEqual(
summary.n_unknown - summary.n_unknown_isolated, 1)
self.assertLessEqual(summary.n_not_converged, 1)
def test_verbose_logging(self):
print("test_verbose_logging()")
oldlevel = tomographer.cxxlogger.level
try:
logging.getLogger().setLevel(1) # LONGDEBUG
tomographer.cxxlogger.level = 1 # LONGDEBUG
def prg_fn(report):
logging.getLogger("prg_fn").debug(report.getHumanReport())
r = tomographer.tomorun.tomorun(
dim=2,
Emn=self.Emn,
Nm=self.Nm,
fig_of_merit=lambda T: npl.norm(np.dot(T, T.T.conj())
), # purity
ref_state=self.rho_ref,
num_repeats=4,
hist_params=tomographer.HistogramParams(0.99, 1, 20),
mhrw_params=tomographer.MHRWParams(
step_size=0.04,
# keep it REAL SHORT because we'll have tons of messages
n_sweep=5,
n_run=10,
n_therm=20),
progress_fn=prg_fn,
progress_interval_ms=50,
ctrl_step_size_params={'enabled': False},
)
finally:
# restore level
logging.getLogger().setLevel(oldlevel)
tomographer.cxxlogger.level = oldlevel
np.array([[.5, -.5], [-.5, .5]]), # -X
np.array([[.5, -.5j], [.5j, .5]]), # +Y
np.array([[.5, .5j], [-.5j, .5]]), # -Y
np.array([[1, 0], [0, 0]]), # +Z
np.array([[0, 0], [0, 1]])
], # -Z
Nm=np.array([262, 238, 231, 269, 483, 17]), # plug in real data here
# figure of merit: fidelity-squared to pure |0> state
fig_of_merit="obs-value",
observable=np.array([[1, 0], [0, 0]]),
# histogram parameters
hist_params=tomographer.HistogramParams(min=0.9, max=1.0, num_bins=40),
# settings of the random walk
mhrw_params=tomographer.MHRWParams(
step_size=0.035, # adjust such that accept. ratio ~ 0.25
n_sweep=30, # set such that step_size*n_sweep ~ 1
n_therm=500,
n_run=32768),
# our progress callback
progress_fn=prg.progress_fn)
# Check the final report of runs to make sure error bars have (mostly all) converged,
# and to verify the acceptance ratio is more or less in the range [0.2, 0.4]
prg.displayFinalInfo(r['final_report_runs'])
# The final histogram, as a `tomographer.AveragedErrorBarHistogram` instance:
final_histogram = r['final_histogram']
# For a quick visual text-based representation of the histogram, use prettyPrint():
#
#print("Finished. Here is the final histogram:")
#print(final_histogram.prettyPrint())
logger = logging.getLogger(__name__)
import numpy as np
import my_custom_module
import tomographer
#
# Some minimal example data
#
Emn = [np.array([[1, 0], [0, 0]]), np.array([[0, 0], [0, 1]])]
Nm = np.array([98, 2])
r = my_custom_module.run(
2,
Emn=Emn,
Nm=Nm,
mhrw_params=tomographer.MHRWParams(step_size=0.01,
n_sweep=100,
n_therm=256,
n_run=8192),
hist_params=tomographer.HistogramParams(min=0.8, max=1.0, num_bins=40),
progress_fn=lambda report: print(report.getHumanReport()),
)
print(r['final_report_runs'])
print("... and here is the final histogram:")
print(r['final_histogram'].prettyPrint())
# ## Bipartite sampling method
# In[5]:
r_naive = load_from_cache('r_naive')
if r_naive is None:
# perform calculation
with tomographer.jpyutil.RandWalkProgressBar() as prg:
r_naive = QPtomographer.bistates.run(
dimX=4,
dimY=4,
Emn=d.Emn,
Nm=np.array(d.Nm),
hist_params=tomographer.UniformBinsHistogramParams(0.1, 0.3, 100),
mhrw_params=tomographer.MHRWParams(0.001, 1000, 2048, 32768),
progress_fn=prg.progress_fn,
progress_interval_ms=2000,
)
prg.displayFinalInfo(r_naive['final_report_runs'])
save_to_cache('r_naive', r_naive)
print_report(r_naive)
# In[6]:
a_naive = do_analysis(r_naive, 'st., std.', plots=True)
# ## Bipartite sampling method, optimized
# In[7]:
[ 0, 0, 0, 0],
[ 0.95, 0, 0, 1],
]), dims=[[2,2],[2,2]])
d = QPtomographer.util.simulate_process_measurements(sigmareal_X, Ereal_XY, PauliMeasSettings, PauliMeasSettings,
NumSamplesPerSetting)
# Naive, bipartite sampling method
r_naiveopt = None
with tomographer.jpyutil.RandWalkProgressBar() as prg:
r_naiveopt = QPtomographer.bistates.run(
dimX=2, dimY=2, Emn=d.Emn, Nm=np.array(d.Nm),
hist_params=tomographer.HistogramParams(0, 0.2, 50),
mhrw_params=tomographer.MHRWParams(0.008, 512, 32768, 32768), # thermalize a lot
progress_fn=prg.progress_fn,
jumps_method='light' # use optimized random walk
)
prg.displayFinalInfo(r_naiveopt['final_report_runs'])
print("Calculation ran for {!s} seconds".format(datetime.timedelta(seconds=r_naiveopt['elapsed_seconds'])))
print(r_naiveopt['final_report_runs'])
analysis_naiveopt = tomographer.querrorbars.HistogramAnalysis(r_naiveopt['final_histogram'],
threshold_fraction=1e-3)
analysis_naiveopt.plot()
# Channel-space method
# Now, we're ready to run our tomography procedure. We'll be estimating
# the expectation value of the entanglement witness.
r = None # global variable
with tomographer.jpyutil.RandWalkProgressBar() as prg:
r = tomographer.tomorun.tomorun(
# the dimension of the quantum system
dim=4,
# the tomography data
Nm=Nm,
Emn=Emn,
# Histogram: values in [1.6, 2.0] split into 50 bins
hist_params=tomographer.UniformBinsHistogramParams(1.6,2,50),
# Random Walk parameters: step size, sweep size, number of thermalization sweeps, number of live sweeps
mhrw_params=tomographer.MHRWParams(0.009,240,2048,32768),
# figure of merit:
fig_of_merit="obs-value",
observable=EntglWitness.data.toarray(),
#num_repeats=12, # default value = auto-detect number of CPU's
progress_fn=prg.progress_fn
)
prg.displayFinalInfo(r['final_report_runs'])
# In[14]:
# Collect the histogram
final_histogram = r['final_histogram']
