def execute_set3(xtalk_date, 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_3',
num_set=10,
num_qc=3,
shift=3)
qc_path = experiments_path + '/xtalk_compiler/benchmark_qc/qasmbench.pickle'
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(xtalk_date) + '.pickle')
save_path = experiments_path + '/xtalk_compiler/ibmq_toronto/job_id/' + str(
today) + '_set3/' + str(label) + '.pickle'
data = execute_xtalk(qc_list, backend, simulator, shots_single,
shots_multi, xtalk_prop, save_path)
pprint(data)
except:
print('Failed: set3 label:', label, ' ', name_list)
def execute_set4():
# prepare benchmark qc
name_list_set = load_gspread(worksheet_name='set_4',
num_set=11,
num_qc=4,
shift=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-19.pickle'
)
save_path = '/Users/Yasuhiro/Documents/aqua/gp/experiments/xtalk_compiler/ibmq_toronto/job_id/2021-01-19_set4/' + str(
label) + '.pickle'
data = execute_xtalk(qc_list, backend, simulator, shots_single,
shots_multi, xtalk_prop, save_path)
pprint(data)
def test_result_alap():
job_file_path = str(os.getcwd()) + "/test_jobfile/test_alap_job.pickle"
save_path = str(os.getcwd()) + "/test_jobfile/test_result_alap.pickle"
simulator = get_IBM_backend("ibmq_qasm_simulator")
paris = get_IBM_backend("ibmq_paris")
result_sim, result_list, result_alap_list, counts_sim, count_list, counts_alap_list, qc_names = result_alap(paris, simulator, job_file_path, save_path)
def result_xtalk(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')
# Dense layout
counts_set_dense = _retrieve_load_result(job_id_set, bench_name_list, device=backend, type='dense')
# print(counts_set_dense)
jsd_dense = _analyze_results(counts_sim_set, counts_set_dense)
pprint(jsd_dense)
# noise-adaptive layout
counts_set_noise = _retrieve_load_result(job_id_set, bench_name_list, device=backend, type='noise')
# print(counts_set_noise)
jsd_noise = _analyze_results(counts_sim_set, counts_set_noise)
pprint(jsd_noise)
# sabre layout
counts_set_sabre = _retrieve_load_result(job_id_set, bench_name_list, device=backend, type='sabre')
# print(counts_set_sabre)
jsd_sabre = _analyze_results(counts_sim_set, counts_set_sabre)
pprint(jsd_sabre)
# xtalk adaptive transpiler
counts_set_xtalk = _retrieve_load_result(job_id_set, bench_name_list, device=backend, type='xtalk')
# print(counts_set_xtalk)
jsd_xtalk = _analyze_results(counts_sim_set, counts_set_xtalk)
pprint(jsd_xtalk)
eval_dict = {
'dense': jsd_dense,
'noise': jsd_noise,
'sabre': jsd_sabre,
'xtalk': jsd_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)
pickle_dump(eval_dict, save_path)
def test_parse_job_files():
job_file_path = str(os.getcwd()) + "/test_jobfile/test_alap_job.pickle"
simulator = get_IBM_backend("ibmq_qasm_simulator")
paris = get_IBM_backend("ibmq_paris")
job_sim, jobs, jobs_alap, job_dict = parse_job_files(job_file_path, paris, simulator)
assert(isinstance(job_dict, dict))
def test_execute_alap():
simulator = get_IBM_backend('ibmq_qasm_simulator')
backend = get_IBM_backend('ibmq_paris')
instruction_durations = InstructionDurations.from_backend(backend)
path = str(os.getcwd()) + '/test_jobfile/test_alap_job.pickle'
execute_alap(
size='small',
names=['toffoli_n3', 'adder_n4 '],
backend=backend,
simulator=simulator,
shots = 1000,
nseed=1,
save_path=path,
instruction_durations=instruction_durations
)
def test_xtalkadaptivelayout():
name_list_set = load_gspread(worksheet_name='set_3', num_set=10, num_qc=3, shift=3)
name_list = name_list_set[9]
print(name_list)
qc_path = '/Users/Yasuhiro/Documents/aqua/gp/experiments/xtalk_compiler/benchmark_qc/qasmbench.pickle'
qasmbench = PrepQASMBench(name_list, qc_path)
qc_list = qasmbench.qc_list()
backend = get_IBM_backend('ibmq_toronto')
shots_multi = 1000
xtalk_prop = {(16, 19): {}, (1, 4): {(7, 10): 1.5523922159364776, (1, 4): 1.0}, (22, 25): {(4, 7): 1.373897836294811, (10, 12): 1.24005278534089, (12, 15): 1.2650717924862478, (14, 13): 1.2295727510296106, (22, 25): 1.0}, (11, 14): {}, (0, 1): {}, (1, 2): {}, (2, 3): {(5, 8): 1.9828579923816556, (19, 20): 1.187980385590695, (2, 3): 1.0}, (4, 7): {(10, 12): 1.4782839452414733, (4, 7): 1.0}, (3, 5): {(8, 11): 1.1101731182299803, (3, 5): 1.0}, (5, 8): {(2, 3): 3.8982912112371535, (5, 8): 1.0}, (7, 6): {}, (7, 10): {(1, 4): 1.384978600658456, (12, 15): 3.716655801629963, (16, 19): 1.0479045105542835, (7, 10): 1.0}, (8, 9): {}, (8, 11): {}, (10, 12): {(4, 7): 4.584756718619288, (14, 13): 3.3950730369059334, (15, 18): 3.7004301070979504, (10, 12): 1.0}, (12, 13): {(11, 14): 1.6664397082756501, (12, 13): 1.0}, (12, 15): {(7, 10): 3.399583065550418, (14, 13): 3.2251935324570224, (12, 15): 1.0}, (14, 13): {(8, 11): 3.704876525263742, (10, 12): 4.890490951462605, (12, 15): 7.076589040196085, (14, 13): 1.0}, (14, 16): {(8, 11): 1.0959863890724943, (14, 16): 1.0}, (15, 18): {(10, 12): 1.7782238443072769, (15, 18): 1.0}, (18, 17): {}, (18, 21): {(18, 21): 1.0}}
# transpile
qc_multi = multi_transpile(
qc_list, backend=backend,
instruction_durations=None,
basis_gates=['id', 'rz', 'sx', 'x', 'cx'],
layout_method='xtalk_adaptive', xtalk_prop=xtalk_prop,
)
# run combined qc job
# qobj_multi = assemble(experiments=qc_multi, backend=backend, shots=shots_multi)
# job_multi = backend.run(qobj_multi)
# print(job_multi.job_id())
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 test_delay_benchmark():
backend = get_IBM_backend("ibmq_paris")
simulator = get_IBM_backend("ibmq_qasm_simulator")
path = "/Users/Yasuhiro/Documents/aqua/gp/QASMBench/small/fredkin_n3/fredkin_n3.qasm"
qc = QuantumCircuit.from_qasm_file(path)
delay_duration_list = [
0, 1000, 2000, 3000, 4000, 5000, 6000, 7000, 8000, 9000, 10000
]
delay_benchmark = DelayBenchmark(qc)
delay_benchmark.compose(delay_duration_list)
job_id_sim, job_id_op, job_id_meas = delay_benchmark.run(
backend=backend, simulator=simulator, initial_layout=[0, 1, 2])
print(job_id_op, job_id_meas)
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)
from experiments.utils import get_IBM_backend, pickle_load
from experiments.waiting_duration.benchmarks import prepare_singleBench
from experiments.waiting_duration import execute_bench, save_jobid_path
from experiments.waiting_duration import calculate_results, save_data_path
# -
# user input
backend_name = "ibmq_toronto"
nseed = 5
date = "2020-11-24"
initial_layout = [0]
# +
# define backends
backend = get_IBM_backend(backend_name, reservations=True)
simulator = get_IBM_backend("ibmq_qasm_simulator")
# type of experiments
exp_type = "single_qubit"
initial_state = "plus_state"
# -
# ## backend properties
# +
print("####################### dutation time #######################")
dt = backend.configuration().dt
print("1 dt = ", dt, " sec")
print(" = ", dt * 10**10, "ns")
from pprint import pprint
from datetime import date
# import original packages
from experiments.utils import get_IBM_backend, pickle_load, pickle_dump
from experiments.waiting_duration import EvaluateDelay
from experiments.waiting_duration.benchmarks import prepare_QASMBench
from experiments.waiting_duration import execute_bench
# -
# user input
backend_name = "ibmq_paris"
nseed = 1
# prepare backend devices
backend = get_IBM_backend(backend_name)
simulator = get_IBM_backend("ibmq_qasm_simulator")
# ## Prepare benchmark circuits
circs = prepare_QASMBench("small")
# show circuit image
for circ in circs:
print("################################ " + str(circ.name) +
" ################################")
print(circ)
# ## Send job
# max(dt) = 1E6
def __init__(self, backend_name, nseed, reservations=False):
self.backend_name = backend_name
self.backend = get_IBM_backend(backend_name)
self.simulator = get_IBM_backend("ibmq_qasm_simulator")
self.nseed = nseed
