def test_from_object_equal_to_from_string(result_obj_1, result_str_1,
result_str_3):
assert GateModelQuantumTaskResult.from_object(
result_obj_1) == GateModelQuantumTaskResult.from_string(result_str_1)
assert GateModelQuantumTaskResult.from_object(
GateModelTaskResult.parse_raw(result_str_3)
) == GateModelQuantumTaskResult.from_string(result_str_3)
def test_equality(result_str_1, result_str_2):
result_1 = GateModelQuantumTaskResult.from_string(result_str_1)
result_2 = GateModelQuantumTaskResult.from_string(result_str_1)
other_result = GateModelQuantumTaskResult.from_string(result_str_2)
non_result = "not a quantum task result"
assert result_1 == result_2
assert result_1 is not result_2
assert result_1 != other_result
assert result_1 != non_result
def test_result_circuit_cached(circuit_task):
_mock_metadata(circuit_task._aws_session, "COMPLETED")
expected = GateModelQuantumTaskResult.from_string(
MockS3.MOCK_S3_RESULT_GATE_MODEL)
circuit_task._result = expected
assert circuit_task.result() == expected
assert not circuit_task._aws_session.retrieve_s3_object_body.called
def test_async_result(circuit_task):
def set_result_from_callback(future):
# Set the result_from_callback variable in the enclosing functions scope
nonlocal result_from_callback
result_from_callback = future.result()
_mock_metadata(circuit_task._aws_session, "RUNNING")
_mock_s3(circuit_task._aws_session, MockS3.MOCK_S3_RESULT_GATE_MODEL)
future = circuit_task.async_result()
# test the different ways to get the result from async
# via callback
result_from_callback = None
future.add_done_callback(set_result_from_callback)
# via asyncio waiting for result
_mock_metadata(circuit_task._aws_session, "COMPLETED")
event_loop = asyncio.get_event_loop()
result_from_waiting = event_loop.run_until_complete(future)
# via future.result(). Note that this would fail if the future is not complete.
result_from_future = future.result()
expected = GateModelQuantumTaskResult.from_string(MockS3.MOCK_S3_RESULT_GATE_MODEL)
assert result_from_callback == expected
assert result_from_waiting == expected
assert result_from_future == expected
def test_result_is_cached(circuit_task, result_string):
_mock_metadata(circuit_task._aws_session, "COMPLETED")
_mock_s3(circuit_task._aws_session, result_string)
circuit_task.result()
_mock_s3(circuit_task._aws_session, "")
expected = GateModelQuantumTaskResult.from_string(MockS3.MOCK_S3_RESULT_GATE_MODEL)
assert circuit_task.result() == expected
def test_result_type_skips_computation_already_populated(calculate_result_types_mocked):
result_str = json.dumps(
{
"braketSchemaHeader": {
"name": "braket.task_result.gate_model_task_result",
"version": "1",
},
"measurements": [[0]],
"resultTypes": [
{"type": {"observable": ["z"], "targets": [0], "type": "variance"}, "value": 12.0}
],
"measuredQubits": [0],
"taskMetadata": {
"braketSchemaHeader": {"name": "braket.task_result.task_metadata", "version": "1"},
"id": "arn:aws:braket:us-east-1:1234567890:quantum-task/22a238b2-ae96",
"shots": 1,
"deviceId": "arn:aws:braket:::device/quantum-simulator/amazon/dm1",
"deviceParameters": {
"braketSchemaHeader": {
"name": "braket.device_schema.simulators."
"gate_model_simulator_device_parameters",
"version": "1",
},
"paradigmParameters": {
"braketSchemaHeader": {
"name": "braket.device_schema.gate_model_parameters",
"version": "1",
},
"qubitCount": 1,
"disableQubitRewiring": False,
},
},
"createdAt": "2022-01-12T06:05:22.633Z",
"endedAt": "2022-01-12T06:05:24.136Z",
"status": "COMPLETED",
},
"additionalMetadata": {
"action": {
"braketSchemaHeader": {"name": "braket.ir.openqasm.program", "version": "1"},
"source": "\nqubit[1] q;\nh q[0];\n#pragma braket result variance z(q[0])\n",
},
"simulatorMetadata": {
"braketSchemaHeader": {
"name": "braket.task_result.simulator_metadata",
"version": "1",
},
"executionDuration": 16,
},
},
}
)
res = GateModelQuantumTaskResult.from_string(result_str)
assert (
res.get_value_by_result_type(ResultType.Variance(observable=Observable.Z(), target=[0]))
== 12
)
calculate_result_types_mocked.assert_not_called()
def test_translate_result():
result_dict = _result_meta()
result_dict["resultTypes"] = [
{"type": {"targets": [0], "type": "probability"}, "value": [0.5, 0.5]}
]
targets = [0]
result_dict["measuredQubits"]: targets
result = GateModelQuantumTaskResult.from_string(json.dumps(result_dict))
mp = MeasurementProcess(ObservableReturnTypes.Probability, wires=Wires([0]))
translated = translate_result(result, mp, targets, frozenset())
assert (translated == result.result_types[0].value).all()
def test_from_string_simulator_only(result_obj_4, result_str_4):
result_obj = result_obj_4
result = GateModelQuantumTaskResult.from_string(result_str_4)
assert len(result.result_types) == len(result_obj.resultTypes)
for i in range(len(result.result_types)):
rt = result.result_types[i]
expected_rt = result_obj.resultTypes[i]
assert rt.type == expected_rt.type
if isinstance(rt.value, np.ndarray):
assert np.allclose(rt.value, expected_rt.value)
else:
assert rt.value == expected_rt.value
def test_from_string_measurement_probabilities(result_str_3):
result_obj = GateModelTaskResult.parse_raw(result_str_3)
task_result = GateModelQuantumTaskResult.from_string(result_str_3)
assert task_result.measurement_probabilities == result_obj.measurementProbabilities
shots = 100
measurement_list = [list("011000") for _ in range(shots)]
expected_measurements = np.asarray(measurement_list, dtype=int)
assert np.allclose(task_result.measurements, expected_measurements)
assert task_result.measurement_counts == Counter(["011000" for x in range(shots)])
assert not task_result.measurement_counts_copied_from_device
assert task_result.measurement_probabilities_copied_from_device
assert not task_result.measurements_copied_from_device
def test_timeout_completed(aws_session):
_mock_metadata(aws_session, "RUNNING")
_mock_s3(aws_session, MockS3.MOCK_S3_RESULT_GATE_MODEL)
# Setup the poll timing such that the timeout will occur after one API poll
quantum_task = AwsQuantumTask(
"foo:bar:arn",
aws_session,
poll_timeout_seconds=0.5,
poll_interval_seconds=1,
)
assert quantum_task.result() is None
_mock_metadata(aws_session, "COMPLETED")
assert quantum_task.state() == "COMPLETED"
assert quantum_task.result() == GateModelQuantumTaskResult.from_string(
MockS3.MOCK_S3_RESULT_GATE_MODEL)
# Cached status is still COMPLETED, so result should be fetched
_mock_metadata(aws_session, "RUNNING")
quantum_task._result = None
assert quantum_task.result() == GateModelQuantumTaskResult.from_string(
MockS3.MOCK_S3_RESULT_GATE_MODEL)
def test_result_circuit(circuit_task):
_mock_metadata(circuit_task._aws_session, "COMPLETED")
_mock_s3(circuit_task._aws_session, MockS3.MOCK_S3_RESULT_GATE_MODEL)
expected = GateModelQuantumTaskResult.from_string(
MockS3.MOCK_S3_RESULT_GATE_MODEL)
assert circuit_task.result() == expected
s3_bucket = circuit_task.metadata()["outputS3Bucket"]
s3_object_key = circuit_task.metadata()["outputS3Directory"]
circuit_task._aws_session.retrieve_s3_object_body.assert_called_with(
s3_bucket, f"{s3_object_key}/results.json")
def test_from_string_measurements(result_str_1):
result_obj = GateModelTaskResult.parse_raw(result_str_1)
task_result = GateModelQuantumTaskResult.from_string(result_str_1)
expected_measurements = np.asarray(result_obj.measurements, dtype=int)
assert task_result.task_metadata == result_obj.taskMetadata
assert task_result.additional_metadata == result_obj.additionalMetadata
assert np.array2string(task_result.measurements) == np.array2string(expected_measurements)
assert not task_result.measurement_counts_copied_from_device
assert not task_result.measurement_probabilities_copied_from_device
assert task_result.measurements_copied_from_device
assert task_result.measured_qubits == result_obj.measuredQubits
assert task_result.values == []
assert task_result.result_types == []
def test_successful(mock_create):
task_mock = Mock()
type(task_mock).id = PropertyMock(side_effect=uuid.uuid4)
task_mock.state.return_value = "COMPLETED"
result = GateModelQuantumTaskResult.from_string(MockS3.MOCK_S3_RESULT_GATE_MODEL)
task_mock.result.return_value = result
mock_create.return_value = task_mock
batch_size = 15
batch = AwsQuantumTaskBatch(
Mock(), "foo", _circuits(batch_size), S3_TARGET, 1000, max_parallel=10
)
assert batch.size == batch_size
assert not batch.unfinished
assert not batch.unsuccessful
assert batch.results() == [result for _ in range(batch_size)]
def test_retry(mock_create):
bad_task_mock = Mock()
type(bad_task_mock).id = PropertyMock(side_effect=uuid.uuid4)
bad_task_mock.state.return_value = random.choice(["CANCELLED", "FAILED"])
bad_task_mock.result.return_value = None
good_task_mock = Mock()
# task id already mocked when setting up bad_task_mock
good_task_mock.state.return_value = "COMPLETED"
result = GateModelQuantumTaskResult.from_string(
MockS3.MOCK_S3_RESULT_GATE_MODEL)
good_task_mock.result.return_value = result
mock_create.side_effect = [
bad_task_mock, good_task_mock, bad_task_mock, good_task_mock
]
batch = AwsQuantumTaskBatch(
Mock(),
"foo",
[Circuit().h(0).cnot(0, 1),
Circuit().h(1).cnot(0, 1)],
S3_TARGET,
1000,
max_parallel=10,
)
assert not batch.unfinished
assert batch.results(max_retries=0) == [None, result]
# Retrying should get rid of the failures
assert batch.results(fail_unsuccessful=True,
max_retries=3,
use_cached_value=False) == [
result,
result,
]
assert batch.unsuccessful == set()
# Don't retry if there's nothing to retry
mock_create.side_effect = [bad_task_mock]
assert batch.retry_unsuccessful_tasks()
assert batch.unsuccessful == set()
# Error if called before there are any results
batch._results = None
with pytest.raises(RuntimeError):
batch.retry_unsuccessful_tasks()
def test_translate_result_hamiltonian():
result_dict = _result_meta()
result_dict["resultTypes"] = [
{
"type": {"observable": ["x", "y"], "targets": [0, 1], "type": "expectation"},
"value": 2.0,
},
{
"type": {"observable": ["x"], "targets": [1], "type": "expectation"},
"value": 3.0,
},
]
targets = [0, 1]
result_dict["measuredQubits"]: targets
result = GateModelQuantumTaskResult.from_string(json.dumps(result_dict))
ham = qml.Hamiltonian((2, 1), (qml.PauliX(0) @ qml.PauliY(1), qml.PauliX(1)))
ham.return_type = ObservableReturnTypes.Expectation
translated = translate_result(result, ham, targets, frozenset())
expected = 2 * result.result_types[0].value + result.result_types[1].value
assert translated == expected
def test_shots_no_measurements_no_measurement_probs(malformatted_results_1):
GateModelQuantumTaskResult.from_string(malformatted_results_1)
def test_result_cached_future(circuit_task, result_string):
_mock_metadata(circuit_task._aws_session, "COMPLETED")
_mock_s3(circuit_task._aws_session, result_string)
circuit_task.result()
_mock_s3(circuit_task._aws_session, "")
expected = GateModelQuantumTaskResult.from_string(
MockS3.MOCK_S3_RESULT_GATE_MODEL)
assert circuit_task.result() == expected
@pytest.mark.parametrize(
"status, result",
[
("COMPLETED",
GateModelQuantumTaskResult.from_string(
MockS3.MOCK_S3_RESULT_GATE_MODEL)),
("FAILED", None),
],
)
def test_async_result(circuit_task, status, result):
def set_result_from_callback(future):
# Set the result_from_callback variable in the enclosing functions scope
nonlocal result_from_callback
result_from_callback = future.result()
_mock_metadata(circuit_task._aws_session, "RUNNING")
_mock_s3(circuit_task._aws_session, MockS3.MOCK_S3_RESULT_GATE_MODEL)
future = circuit_task.async_result()
# test the different ways to get the result from async
def test_execute_all_samples(mock_run):
result = GateModelQuantumTaskResult.from_string(
json.dumps({
"braketSchemaHeader": {
"name": "braket.task_result.gate_model_task_result",
"version": "1",
},
"measurements": [[0, 0, 1], [1, 0, 1], [1, 1, 0], [0, 0, 0]],
"resultTypes": [
{
"type": {
"observable": ["h", "i"],
"targets": [0, 1],
"type": "sample"
},
"value": [1, -1, 1, 1],
},
{
"type": {
"observable": [[[[0.0, 0.0], [1.0, 0.0]],
[[1.0, 0.0], [0.0, 0.0]]]],
"targets": [2],
"type":
"sample",
},
"value": [1, -1, 1, 1],
},
],
"measuredQubits": [0, 1, 3],
"taskMetadata": {
"braketSchemaHeader": {
"name": "braket.task_result.task_metadata",
"version": "1",
},
"id": "task_arn",
"shots": 0,
"deviceId": "default",
},
"additionalMetadata": {
"action": {
"braketSchemaHeader": {
"name": "braket.ir.jaqcd.program",
"version": "1"
},
"instructions": [{
"control": 0,
"target": 1,
"type": "cnot"
}],
},
},
}))
task = Mock()
task.result.return_value = result
mock_run.return_value = task
dev = _aws_device(wires=3)
with QuantumTape() as circuit:
qml.Hadamard(wires=0)
qml.CNOT(wires=[0, 1])
qml.sample(qml.Hadamard(0) @ qml.Identity(1))
qml.sample(qml.Hermitian(np.array([[0, 1], [1, 0]]), wires=[2]))
assert dev.execute(circuit).shape == (2, 4)
RESULT = GateModelQuantumTaskResult.from_string(
json.dumps({
"braketSchemaHeader": {
"name": "braket.task_result.gate_model_task_result",
"version": "1",
},
"measurements": [[0, 0, 0, 0], [1, 1, 1, 1], [1, 1, 0, 0],
[0, 0, 1, 1]],
"resultTypes": [
{
"type": {
"targets": [0],
"type": "probability"
},
"value": [0.5, 0.5]
},
{
"type": {
"observable": ["x"],
"targets": [1],
"type": "expectation"
},
"value": 0.0,
},
{
"type": {
"observable": ["y"],
"targets": [2],
"type": "variance"
},
"value": 0.1
},
{
"type": {
"observable": ["z"],
"targets": [3],
"type": "sample"
},
"value": [1, -1, 1, 1],
},
],
"measuredQubits": [0, 1, 2, 3],
"taskMetadata": {
"braketSchemaHeader": {
"name": "braket.task_result.task_metadata",
"version": "1"
},
"id": "task_arn",
"shots": 0,
"deviceId": "default",
},
"additionalMetadata": {
"action": {
"braketSchemaHeader": {
"name": "braket.ir.jaqcd.program",
"version": "1"
},
"instructions": [{
"control": 0,
"target": 1,
"type": "cnot"
}],
},
},
}))
def test_measurements_measured_qubits_mismatch(malformatted_results_2):
GateModelQuantumTaskResult.from_string(malformatted_results_2)
