def calculate_results(delay_dutation, job_id_path, save_data_path, backend,
simulator, nseed):
exp_data = pickle_load(job_id_path)
job_sim = simulator.retrieve_job(exp_data["simulator"]["job_id"])
job_delay_before = [
backend.retrieve_job(job_id)
for job_id in exp_data["delay_before"]["job_id"]
]
job_delay_after = [
backend.retrieve_job(job_id)
for job_id in exp_data["delay_after"]["job_id"]
]
delay_duration_list = exp_data["delay_duration_list"]
eval_delay = EvaluateDelay(job_sim,
job_delay_before,
job_delay_after,
delay_duration_list,
nseed=nseed,
initial_layout=[0])
counts_before_list_list, counts_after_list_list = eval_delay.evaluate(
) # return [[seed1 counts_dict], [seed2 counts_dict], ... ]
# calculate mean and sem (standard error mean) of counts
counts_before_list_mean, counts_before_list_sem = eval_delay.stat(
counts_before_list_list)
counts_after_list_mean, counts_after_list_sem = eval_delay.stat(
counts_after_list_list)
# calculate jsd
before_jsd_all, before_jsd_mean, before_jsd_sem = eval_delay.js_divergence(
counts_before_list_list)
after_jsd_all, after_jsd_mean, after_jsd_sem = eval_delay.js_divergence(
counts_after_list_list)
save_data = {
"before_op": {
"counts_list_all": counts_before_list_list,
"counts_list_mean": counts_before_list_mean,
"counts_list_sem": counts_before_list_sem,
"jsd_all": before_jsd_all,
"jsd_mean": before_jsd_mean,
"jsd_sem": before_jsd_sem,
},
"after_op": {
"counts_list_all": counts_after_list_list,
"counts_list_mean": counts_after_list_mean,
"counts_list_sem": counts_after_list_sem,
"jsd_all": after_jsd_all,
"jsd_mean": after_jsd_mean,
"jsd_sem": after_jsd_sem,
},
"delay_duration": delay_dutation,
"nseed": nseed
}
pickle_dump(save_data, save_data_path)
return save_data
def result(dir_path, backend_name, save_path=None):
# get path to this file and parent dir
job_files = glob.glob(dir_path + '/*.pickle')
# job_files = job_dir
# open job files
job_id_set = []
bench_name_list = []
for job_file in job_files:
job_data = pickle_load(job_file)
job_id_set.append(job_data["job"])
bench_name_list.append(job_data["bench_names"])
# load ibmq backend
backend = get_IBM_backend(backend_name)
simulator = get_IBM_backend('ibmq_qasm_simulator')
# retrieve jobs and results
# simulator
counts_sim_set = _retrieve_result(job_id_set,
bench_name_list,
device=simulator,
type='simulator')
# Dense layout
counts_dense_set = _retrieve_result(job_id_set,
bench_name_list,
device=backend,
type='dense')
# noise-adaptive layout
counts_noise_set = _retrieve_result(job_id_set,
bench_name_list,
device=backend,
type='noise')
# sabre layout
counts_sabre_set = _retrieve_result(job_id_set,
bench_name_list,
device=backend,
type='sabre')
# xtalk adaptive transpiler
counts_xtalk_set = _retrieve_result(job_id_set,
bench_name_list,
device=backend,
type='xtalk')
if save_path:
dir_path = os.path.dirname(save_path)
if not os.path.exists(dir_path):
print('make directory: ', dir_path)
os.mkdir(dir_path)
_save_results(counts_sim_set, counts_dense_set, counts_noise_set,
counts_sabre_set, counts_xtalk_set, save_path)
def plot_sched(data_path, save_dir):
data = pickle_load(data_path)
data_nonsched = data['nonsched']
data_alap = data['alap']
i = 0
for _nonsched, _alap in zip(data_nonsched, data_alap):
save_path = save_dir + '/' + str(i) + '.png'
_plot(_nonsched, _alap, save_path)
i += 1
def result_sched(dir_path, backend_name, save_path=None):
# get path to this file and parent dir
job_files = glob.glob(dir_path+'/*.pickle')
# job_files = job_dir
# open job files
job_id_set = []
bench_name_list = []
for job_file in job_files:
job_data = pickle_load(job_file)
job_id_set.append(job_data["job"])
bench_name_list.append(job_data["bench_names"])
# load ibmq backend
backend = get_IBM_backend(backend_name)
simulator = get_IBM_backend('ibmq_qasm_simulator')
# retrieve jobs and get load results
# simulator
counts_sim_set = _retrieve_load_result(job_id_set, bench_name_list, device=simulator, type='simulator')
# pprint(counts_sim_set)
# nonsched layout
counts_set_nonsched = _retrieve_load_result(job_id_set, bench_name_list, device=backend, type='nonsched')
# pprint(counts_set_nonsched)
jsd_nonsched = _analyze_results(counts_sim_set, counts_set_nonsched)
pprint(jsd_nonsched)
# alap adaptive transpiler
counts_set_alap = _retrieve_load_result(job_id_set, bench_name_list, device=backend, type='alap')
# print(counts_set_alap)
jsd_alap = _analyze_results(counts_sim_set, counts_set_alap)
pprint(jsd_alap)
eval_dict = {
'nonsched': jsd_nonsched,
'alap': jsd_alap
}
if save_path:
dir_path = os.path.dirname(save_path)
if not os.path.exists(dir_path):
print('make directory: ', dir_path)
os.mkdir(dir_path)
pickle_dump(eval_dict, save_path)
def plot_xtalk(data_path, save_dir):
data = pickle_load(data_path)
print(data)
data_dense = data['dense']
data_noise = data['noise']
data_sabre = data['sabre']
data_xtalk = data['xtalk']
i = 0
for _dense, _noise, _sabre, _xtalk in zip(data_dense, data_noise,
data_sabre, data_xtalk):
try:
save_path = save_dir + '_nonlabel/' + str(i) + '.png'
_plot(_dense, _noise, _sabre, _xtalk, save_path)
except:
print("failed: ", i)
i += 1
def test_transpile_on_regurated_hw():
multi_circuit_components = {"QFT_2": 1, "Toffoli": 3}
jobfile_dir = "/Users/Yasuhiro/Documents/aqua/gp/experiments/test/test_jobfile/"
benchmark = CompilerBenchmark(backend_name="ibmq_toronto",
reservations=False)
xtalk_row_value = pickle_load(
"/Users/Yasuhiro/Documents/aqua/gp/errors_information/toronto_from20201030/xtalk_data_daily/epc/2020-10-30.pickle"
)
xtalk_prop = value_to_ratio(xtalk_row_value, threshold=1.25)
pprint(xtalk_prop)
multi_circ = benchmark.run(multi_circuit_components, jobfile_dir,
xtalk_prop)
for circ in multi_circ:
print(
"#################################################################"
)
print(circ)
def execute_set4():
# prepare benchmark qc
name_list_set = load_gspread(worksheet_name='set_4', num_set=11, num_qc=4)
qc_path = '/Users/Yasuhiro/Documents/aqua/gp/experiments/xtalk_compiler/benchmark_qc/qasmbench.pickle'
for label, name_list in enumerate(name_list_set):
qasmbench = PrepQASMBench(name_list, qc_path)
qc_list = qasmbench.qc_list()
# prepare execution environment
backend = get_IBM_backend('ibmq_toronto')
simulator = get_IBM_backend('ibmq_qasm_simulator')
shots_single=8192
shots_multi=8192
xtalk_prop = pickle_load('/Users/Yasuhiro/Documents/aqua/gp/errors_information/toronto_from20201224/xtalk_data_daily/ratio/2021-01-12.pickle')
save_path = '/Users/Yasuhiro/Documents/aqua/gp/experiments/xtalk_compiler/ibmq_toronto/job_id/2021-01-12_set4/'+ str(label) +'.pickle'
data = execute_xtalk(name_list, qc_list, backend, simulator, shots_single, shots_multi, xtalk_prop, save_path)
pprint(data)
def test_evaluate_delay():
backend = get_IBM_backend("ibmq_rome")
simulator = get_IBM_backend("ibmq_qasm_simulator")
# load experiments data
data_path = "/Users/Yasuhiro/Documents/aqua/gp/experiments/waiting_duration/job_id/2020-11-10_qc_name_is_ibmq_rome.pickle"
exp_data = pickle_load(data_path)
job_sim = simulator.retrieve_job(exp_data["simulator"]["job_id"])
job_delay_op = [backend.retrieve_job(job_id) for job_id in exp_data["delay_op"]["job_id"]]
job_delay_meas = [backend.retrieve_job(job_id) for job_id in exp_data["delay_meas"]["job_id"]]
delay_duration_list = exp_data["delay_duration_list"]
initial_layout=[0, 1, 2]
eval_delay = EvaluateDelay(job_sim, job_delay_op, job_delay_meas, delay_duration_list, nseed=1, initial_layout=initial_layout)
op_list, meas_list = eval_delay.evaluate()
jsd_list_list, mean_list, sem_list = eval_delay.js_divergence(op_list)
print(jsd_list_list, mean_list, sem_list)
def execute_set6(today):
experiments_path = '/Users/rum/Documents/aqua/gp/experiments'
errorinfo_path = '/Users/rum/Documents/aqua/gp/errors_information'
# prepare benchmark qc
name_list_set = load_gspread(worksheet_name='set_6',
num_set=7,
num_qc=6,
shift=6)
qc_path = experiments_path + '/xtalk_compiler/benchmark_qc/qasmbench.pickle'
#################
pointer = 0
#################
for label, name_list in enumerate(name_list_set):
try:
qasmbench = PrepQASMBench(name_list, qc_path)
qc_list = qasmbench.qc_list()
# prepare execution environment
backend = get_IBM_backend('ibmq_toronto')
simulator = get_IBM_backend('ibmq_qasm_simulator')
shots_single = 8192
shots_multi = 8192
xtalk_prop = pickle_load(
errorinfo_path +
'/toronto_from20201224/xtalk_data_daily/ratio/' + str(today) +
'.pickle')
save_path = experiments_path + '/xtalk_compiler/ibmq_toronto/job_id/' + str(
today) + '_set6/' + str(label + pointer) + '.pickle'
data = execute_xtalk(qc_list, backend, simulator, shots_single,
shots_multi, xtalk_prop, save_path)
pprint(data)
except:
print('Failed: set6 label:', label, ' ', name_list)
def evaluate(self, experiments_data_path_list: list):
obj_list = []
for experiments_data_path in experiments_data_path_list:
exp_data = pickle_load(experiments_data_path)
job_sim = self.simulator.retrieve_job(exp_data["simulator"]["job_id"])
job_delay_before = [self.backend.retrieve_job(job_id) for job_id in exp_data["delay_before"]["job_id"]]
job_delay_after = [self.backend.retrieve_job(job_id) for job_id in exp_data["delay_after"]["job_id"]]
delay_duration_list = exp_data["delay_duration_list"]
eval_delay = EvaluateDelay(job_sim, job_delay_before, job_delay_after, delay_duration_list, nseed=self.nseed, initial_layout=self.initial_layout_list)
counts_before_list_list, counts_after_list_list = eval_delay.evaluate() # return [[seed1 counts_dict], [seed2 counts_dict], ... ]
before_jsd_all, before_jsd_mean, before_jsd_sem = eval_delay.js_divergence(counts_before_list_list)
after_jsd_all, after_jsd_mean, after_jsd_sem = eval_delay.js_divergence(counts_mean_list_list)
obj = {
"before_op": {
"jsd_add": before_jsd_all,
"jsd_mean": before_jsd_mean,
"jsd_sem": before_jsd_sem,
},
"after_op": {
"jsd_add": after_jsd_all,
"jsd_mean": after_jsd_mean,
"jsd_sem": after_jsd_sem,
},
"nseed": self.nseed
}
obj_list.append(obj)
# save as pickle file
path_to_dir = "/Users/Yasuhiro/Documents/aqua/gp/experiments/waiting_duration/data/jsd/plus_state_decay/"
file_name = self.backend_name + "_" + str(date.today()) + "_qubit-" + str(i) + ".pickle"
save_path = path_to_dir + file_name
pickle_dump(obj, save_path)
return obj_list
savedata_path_e5 = save_data_path(date, "e5", initial_state, initial_layout) # + # e5 = calculate_results(delay_duration_e5, jobid_path_e5, savedata_path_e5, backend, simulator, nseed) # pprint(e5) # - savedata_path_e4 = save_data_path(date, "e4", initial_state, initial_layout) # + # e4 = calculate_results(delay_duration_e4, jobid_path_e4, savedata_path_e4, backend, simulator, nseed) # pprint(e4) # - # ## Plot results from experiments.waiting_duration import plot_decay, save_plot_path save_plot_path_e6 = save_plot_path(date, "e6", initial_state, initial_layout) e6 = pickle_load(savedata_path_e6) plot_decay(e6, delay_duration_e6, save_plot_path_e6, ymin=0, ymax=0.8) save_plot_path_e5 = save_plot_path(date, "e5", initial_state, initial_layout) e5 = pickle_load(savedata_path_e5) plot_decay(e5, delay_duration_e5, save_plot_path_e5, ymin=0, ymax=0.5) save_plot_path_e4 = save_plot_path(date, "e4", initial_state, initial_layout) e4 = pickle_load(savedata_path_e4) plot_decay(e4, delay_duration_e4, save_plot_path_e4, ymin=0, ymax=0.25)
backend=backend,
simulator=simulator,
initial_layout=initial_layout,
delay_duration_list=delay_duration_e4,
nseed=nseed,
)
# ## calculate results
# +
path_ = "/Users/Yasuhiro/Documents/aqua/gp/experiments/waiting_duration/job_id/" + backend_name + "/" + str(
date.today()) + "_pulse state_e6_" + backend_name + "_["
_path = "].pickle"
experiments_data_path = path_ + str(0) + _path
exp_data = pickle_load(experiments_data_path)
job_sim = simulator.retrieve_job(exp_data["simulator"]["job_id"])
job_delay_before = [
backend.retrieve_job(job_id)
for job_id in exp_data["delay_before"]["job_id"]
]
job_delay_after = [
backend.retrieve_job(job_id)
for job_id in exp_data["delay_after"]["job_id"]
]
delay_duration_list = exp_data["delay_duration_list"]
eval_delay = EvaluateDelay(job_sim,
job_delay_before,
job_delay_after,
delay_duration_list,
def plot_pst(data_path, save_path):
data = pickle_load(data_path)
df = _process_data(data)
_plot(df, save_path)
def _run_experiments(
multi_circuit_components,
backend=None,
crosstalk_prop=None,
crosstalk_info_filepath=None,
returnCircuit=False,
onlyCircuit=False,
multi_opt=False,
basis_gates=None,
coupling_map=None, # circuit transpile options
backend_properties=None,
initial_layout=None,
seed_transpiler=None,
optimization_level=None,
pass_manager=None,
qobj_id=None,
qobj_header=None,
shots=1024, # common run options
memory=False,
max_credits=10,
seed_simulator=None,
default_qubit_los=None,
default_meas_los=None, # schedule run options
schedule_los=None,
meas_level=MeasLevel.CLASSIFIED,
meas_return=MeasReturnType.AVERAGE,
memory_slots=None,
memory_slot_size=100,
rep_time=None,
rep_delay=None,
parameter_binds=None,
schedule_circuit=False,
inst_map=None,
meas_map=None,
scheduling_method=None,
init_qubits=None,
**run_config
):
circuit_list = make_benckmarks(multi_circuit_components)
if crosstalk_prop is None and isinstance(crosstalk_info_filepath, str):
cprop = pickle_load(crosstalk_info_filepath)
else:
cprop = crosstalk_prop
experiments = multitasking_transpile(
multi_circuits=circuit_list,
backend=backend,
backend_properties=backend_properties,
multi_opt=multi_opt,
crosstalk_prop=cprop,
optimization_level=optimization_level,
)
if not onlyCircuit:
qobj = assemble(
experiments,
qobj_id=qobj_id,
qobj_header=qobj_header,
shots=shots,
memory=memory,
max_credits=max_credits,
seed_simulator=seed_simulator,
default_qubit_los=default_qubit_los,
default_meas_los=default_meas_los,
schedule_los=schedule_los,
meas_level=meas_level,
meas_return=meas_return,
memory_slots=memory_slots,
memory_slot_size=memory_slot_size,
rep_time=rep_time,
rep_delay=rep_delay,
parameter_binds=parameter_binds,
backend=backend,
init_qubits=init_qubits,
**run_config
)
# executing the circuits on the backend and returning the job
start_time = time()
job = backend.run(qobj, **run_config)
end_time = time()
_log_submission_time(start_time, end_time)
if returnCircuit:
return job, experiments
return job
return experiments
