def test_run_calibration_validation_fails():
engine = cg.Engine(
project_id='proj',
proto_version=cg.engine.engine.ProtoVersion.V2,
)
q1 = cirq.GridQubit(2, 3)
q2 = cirq.GridQubit(2, 4)
layer1 = cg.CalibrationLayer('xeb', cirq.Circuit(cirq.CZ(q1, q2)),
{'num_layers': 42})
layer2 = cg.CalibrationLayer('readout', cirq.Circuit(cirq.measure(q1, q2)),
{'num_samples': 4242})
with pytest.raises(ValueError, match='Processor id must be specified'):
_ = engine.run_calibration(layers=[layer1, layer2],
gate_set=cg.XMON,
job_id='job-id')
with pytest.raises(ValueError, match='Gate set must be specified'):
_ = engine.run_calibration(layers=[layer1, layer2],
processor_ids=['mysim'],
job_id='job-id')
with pytest.raises(ValueError, match='processor_id and processor_ids'):
_ = engine.run_calibration(
layers=[layer1, layer2],
processor_ids=['mysim'],
processor_id='mysim',
gate_set=cg.XMON,
job_id='job-id',
)
def test_run_calibration(client):
setup_run_circuit_with_result_(client, _CALIBRATION_RESULTS_V2)
engine = cg.Engine(project_id='proj',
proto_version=cg.engine.engine.ProtoVersion.V2)
q1 = cirq.GridQubit(2, 3)
q2 = cirq.GridQubit(2, 4)
layer1 = cg.CalibrationLayer('xeb', cirq.Circuit(cirq.CZ(q1, q2)),
{'num_layers': 42})
layer2 = cg.CalibrationLayer('readout', cirq.Circuit(cirq.measure(q1, q2)),
{'num_samples': 4242})
job = engine.run_calibration(layers=[layer1, layer2],
job_id='job-id',
processor_id='mysim')
results = job.calibration_results()
assert len(results) == 2
assert results[0].code == v2.calibration_pb2.SUCCESS
assert results[0].error_message == 'First success'
assert results[0].token == 'abc123'
assert len(results[0].metrics) == 1
assert len(results[0].metrics['fidelity']) == 1
assert results[0].metrics['fidelity'][(q1, q2)] == [0.75]
assert results[1].code == v2.calibration_pb2.SUCCESS
assert results[1].error_message == 'Second success'
# assert label is correct
client().create_job.assert_called_once_with(
project_id='proj',
program_id='prog',
job_id='job-id',
processor_ids=['mysim'],
run_context=util.pack_any(v2.run_context_pb2.RunContext()),
description=None,
labels={'calibration': ''},
)
def test_floquet_to_calibration_layer_with_measure_qubits():
qubits = tuple(cirq.GridQubit(0, index) for index in range(5))
q_00, q_01, q_02, q_03, _ = qubits
gate = cirq.FSimGate(theta=np.pi / 4, phi=0.0)
request = FloquetPhasedFSimCalibrationRequest(
gate=gate,
pairs=((q_00, q_01), (q_02, q_03)),
options=FloquetPhasedFSimCalibrationOptions(
characterize_theta=True,
characterize_zeta=True,
characterize_chi=False,
characterize_gamma=False,
characterize_phi=True,
measure_qubits=qubits,
),
)
assert request.to_calibration_layer() == cirq_google.CalibrationLayer(
calibration_type='floquet_phased_fsim_characterization',
program=cirq.Circuit(
[gate.on(q_00, q_01),
gate.on(q_02, q_03),
cirq.measure(*qubits)], ),
args={
'est_theta': True,
'est_zeta': True,
'est_chi': False,
'est_gamma': False,
'est_phi': True,
'readout_corrections': True,
'version': 2,
},
)
def test_floquet_to_calibration_layer_readout_thresholds():
q_00, q_01, q_02, q_03 = [cirq.GridQubit(0, index) for index in range(4)]
gate = cirq.FSimGate(theta=np.pi / 4, phi=0.0)
request = FloquetPhasedFSimCalibrationRequest(
gate=gate,
pairs=((q_00, q_01), (q_02, q_03)),
options=FloquetPhasedFSimCalibrationOptions(
characterize_theta=True,
characterize_zeta=True,
characterize_chi=False,
characterize_gamma=False,
characterize_phi=True,
readout_error_tolerance=0.4,
),
)
assert request.to_calibration_layer() == cirq_google.CalibrationLayer(
calibration_type='floquet_phased_fsim_characterization',
program=cirq.Circuit([gate.on(q_00, q_01),
gate.on(q_02, q_03)]),
args={
'est_theta': True,
'est_zeta': True,
'est_chi': False,
'est_gamma': False,
'est_phi': True,
'readout_corrections': True,
'readout_error_tolerance': 0.4,
'correlated_readout_error_tolerance': 7 / 6 * 0.4 - 1 / 6,
'version': 2,
},
)
def test_run_calibration(client):
client().create_program.return_value = (
'prog',
qtypes.QuantumProgram(name='projects/proj/programs/prog'),
)
client().create_job.return_value = (
'job-id',
qtypes.QuantumJob(name='projects/proj/programs/prog/jobs/job-id',
execution_status={'state': 'READY'}),
)
client().get_job.return_value = qtypes.QuantumJob(
execution_status={'state': 'SUCCESS'})
client().get_job_results.return_value = qtypes.QuantumResult(
result=_CALIBRATION_RESULTS_V2)
q1 = cirq.GridQubit(2, 3)
q2 = cirq.GridQubit(2, 4)
layer1 = cg.CalibrationLayer('xeb', cirq.Circuit(cirq.CZ(q1, q2)),
{'num_layers': 42})
layer2 = cg.CalibrationLayer('readout', cirq.Circuit(cirq.measure(q1, q2)),
{'num_samples': 4242})
processor = cg.EngineProcessor('proj', 'mysim', EngineContext())
job = processor.run_calibration(gate_set=cg.FSIM_GATESET,
layers=[layer1, layer2],
job_id='job-id')
results = job.calibration_results()
assert len(results) == 2
assert results[0].code == v2.calibration_pb2.SUCCESS
assert results[0].error_message == 'First success'
assert results[0].token == 'abc123'
assert len(results[0].metrics) == 1
assert len(results[0].metrics['fidelity']) == 1
assert results[0].metrics['fidelity'][(q1, q2)] == [0.75]
assert results[1].code == v2.calibration_pb2.SUCCESS
assert results[1].error_message == 'Second success'
# assert label is correct
client().create_job.assert_called_once_with(
project_id='proj',
program_id='prog',
job_id='job-id',
processor_ids=['mysim'],
run_context=_to_any(v2.run_context_pb2.RunContext()),
description=None,
labels={'calibration': ''},
)
def test_xeb_to_calibration_layer():
q_00, q_01, q_02, q_03 = [cirq.GridQubit(0, index) for index in range(4)]
gate = cirq.FSimGate(theta=np.pi / 4, phi=0.0)
request = XEBPhasedFSimCalibrationRequest(
gate=gate,
pairs=((q_00, q_01), (q_02, q_03)),
options=XEBPhasedFSimCalibrationOptions(
n_library_circuits=22,
fsim_options=XEBPhasedFSimCharacterizationOptions(
characterize_theta=True,
characterize_zeta=True,
characterize_chi=False,
characterize_gamma=False,
characterize_phi=True,
),
),
)
layer = request.to_calibration_layer()
assert layer == cirq_google.CalibrationLayer(
calibration_type='xeb_phased_fsim_characterization',
program=cirq.Circuit([gate.on(q_00, q_01),
gate.on(q_02, q_03)]),
args={
'n_library_circuits': 22,
'n_combinations': 10,
'cycle_depths': '5_25_50_100_200_300',
'fatol': 5e-3,
'xatol': 5e-3,
'characterize_theta': True,
'characterize_zeta': True,
'characterize_chi': False,
'characterize_gamma': False,
'characterize_phi': True,
'theta_default': 0.0,
'zeta_default': 0.0,
'chi_default': 0.0,
'gamma_default': 0.0,
'phi_default': 0.0,
},
)
# Serialize to proto
calibration = v2.calibration_pb2.FocusedCalibration()
new_layer = calibration.layers.add()
new_layer.calibration_type = layer.calibration_type
for arg in layer.args:
arg_to_proto(layer.args[arg], out=new_layer.args[arg])
cirq_google.SQRT_ISWAP_GATESET.serialize(layer.program,
msg=new_layer.layer)
with open(
os.path.dirname(__file__) +
'/test_data/xeb_calibration_layer.textproto') as f:
desired_textproto = f.read()
layer_str = str(new_layer)
# Fix precision issues
layer_str = re.sub(r'0.004999\d+', '0.005', layer_str)
assert layer_str == desired_textproto
