def test_marginal_counts_result(self):
"""Test that a Result object containing counts marginalizes correctly."""
raw_counts_1 = {
"0x0": 4,
"0x1": 7,
"0x2": 10,
"0x6": 5,
"0x9": 11,
"0xD": 9,
"0xE": 8
}
data_1 = models.ExperimentResultData(counts=raw_counts_1)
exp_result_header_1 = QobjExperimentHeader(creg_sizes=[["c0", 4]],
memory_slots=4)
exp_result_1 = models.ExperimentResult(shots=54,
success=True,
data=data_1,
header=exp_result_header_1)
raw_counts_2 = {"0x2": 5, "0x3": 8}
data_2 = models.ExperimentResultData(counts=raw_counts_2)
exp_result_header_2 = QobjExperimentHeader(creg_sizes=[["c0", 2]],
memory_slots=2)
exp_result_2 = models.ExperimentResult(shots=13,
success=True,
data=data_2,
header=exp_result_header_2)
result = Result(results=[exp_result_1, exp_result_2],
**self.base_result_args)
expected_marginal_counts_1 = {"00": 4, "01": 27, "10": 23}
expected_marginal_counts_2 = {"0": 5, "1": 8}
expected_marginal_counts_none = {
"0000": 4,
"0001": 7,
"0010": 10,
"0110": 5,
"1001": 11,
"1101": 9,
"1110": 8,
}
self.assertEqual(
marginal_counts(result, [0, 1]).get_counts(0),
expected_marginal_counts_1)
self.assertEqual(
marginal_counts(result, [0]).get_counts(1),
expected_marginal_counts_2)
self.assertEqual(
marginal_counts(result, None).get_counts(0),
expected_marginal_counts_none)
def test_marginal_counts(self):
"""Test that counts are marginalized correctly."""
raw_counts = {
'0x0': 4,
'0x1': 7,
'0x2': 10,
'0x6': 5,
'0x9': 11,
'0xD': 9,
'0xE': 8
}
data = models.ExperimentResultData(counts=dict(**raw_counts))
exp_result_header = QobjExperimentHeader(creg_sizes=[['c0', 4]],
memory_slots=4)
exp_result = models.ExperimentResult(shots=54,
success=True,
data=data,
header=exp_result_header)
result = Result(results=[exp_result], **self.base_result_args)
expected_marginal_counts = {'00': 4, '01': 27, '10': 23}
self.assertEqual(marginal_counts(result.get_counts(), [0, 1]),
expected_marginal_counts)
self.assertEqual(marginal_counts(result.get_counts(), [1, 0]),
expected_marginal_counts)
def test_memory_counts_header(self):
"""Test that memory bitstrings are extracted properly with header."""
raw_memory = ["0x0", "0x0", "0x2", "0x2", "0x2", "0x2", "0x2"]
no_header_processed_memory = [
"0 0 00",
"0 0 00",
"0 0 10",
"0 0 10",
"0 0 10",
"0 0 10",
"0 0 10",
]
data = models.ExperimentResultData(memory=raw_memory)
exp_result_header = QobjExperimentHeader(creg_sizes=[["c0", 2],
["c0", 1],
["c1", 1]],
memory_slots=4)
exp_result = models.ExperimentResult(shots=14,
success=True,
meas_level=2,
memory=True,
data=data,
header=exp_result_header)
result = Result(results=[exp_result], **self.base_result_args)
self.assertEqual(result.get_memory(0), no_header_processed_memory)
def test_marginal_counts_result_creg_sizes(self):
"""Test that marginal_counts with Result input properly changes creg_sizes."""
raw_counts = {
"0x0": 4,
"0x1": 7,
"0x2": 10,
"0x6": 5,
"0x9": 11,
"0xD": 9,
"0xE": 8
}
data = models.ExperimentResultData(counts=dict(**raw_counts))
exp_result_header = QobjExperimentHeader(creg_sizes=[["c0", 1],
["c1", 3]],
memory_slots=4)
exp_result = models.ExperimentResult(shots=54,
success=True,
data=data,
header=exp_result_header)
result = Result(results=[exp_result], **self.base_result_args)
expected_marginal_counts = {"0 0": 14, "0 1": 18, "1 0": 13, "1 1": 9}
expected_creg_sizes = [["c0", 1], ["c1", 1]]
expected_memory_slots = 2
marginal_counts_result = marginal_counts(result, [0, 2])
self.assertEqual(marginal_counts_result.results[0].header.creg_sizes,
expected_creg_sizes)
self.assertEqual(marginal_counts_result.results[0].header.memory_slots,
expected_memory_slots)
self.assertEqual(marginal_counts_result.get_counts(0),
expected_marginal_counts)
def test_marginal_counts_result_format(self):
"""Test that marginal_counts with format_marginal true properly formats output."""
raw_counts_1 = {
"0x0": 4,
"0x1": 7,
"0x2": 10,
"0x6": 5,
"0x9": 11,
"0xD": 9,
"0x12": 8
}
data_1 = models.ExperimentResultData(counts=dict(**raw_counts_1))
exp_result_header_1 = QobjExperimentHeader(creg_sizes=[["c0", 2],
["c1", 3]],
memory_slots=5)
exp_result_1 = models.ExperimentResult(shots=54,
success=True,
data=data_1,
header=exp_result_header_1)
result = Result(results=[exp_result_1], **self.base_result_args)
expected_marginal_counts_1 = {
"0_0 _0": 14,
"0_0 _1": 18,
"0_1 _0": 5,
"0_1 _1": 9,
"1_0 _0": 8,
}
marginal_counts_result = marginal_counts(result.get_counts(),
[0, 2, 4],
format_marginal=True)
self.assertEqual(marginal_counts_result, expected_marginal_counts_1)
def _get_experiment_results(self, jobs: List[Dict[str, Any]]) -> List[ExperimentResult]:
""" Get results from experiments from the Quantum Inspire platform for one or more jobs.
:param jobs: A list of jobs
:raises QiskitBackendError: If an error occurred while executing the job on the Quantum Inspire backend.
:return:
A list of experiment results; containing the data, execution time, status, etc. for the list of jobs.
"""
results = [self.__api.get_result_from_job(job['id']) for job in jobs]
experiment_results = []
for result, job in zip(results, jobs):
if not result.get('histogram', {}):
raise QiskitBackendError(
'Result from backend contains no histogram data!\n{}'.format(result.get('raw_text')))
user_data = json.loads(str(job.get('user_data')))
measurements = user_data.pop('measurements')
histogram_obj, memory_data = self.__convert_result_data(result, measurements)
full_state_histogram_obj = self.__convert_histogram(result, measurements)
calibration = self.__api.get_calibration_from_result(result['id'])
experiment_result_data = ExperimentResultData(counts=histogram_obj,
memory=memory_data,
probabilities=full_state_histogram_obj,
calibration=calibration)
header = QobjExperimentHeader.from_dict(user_data)
experiment_result_dictionary = {'name': job.get('name'), 'seed': 42, 'shots': job.get('number_of_shots'),
'data': experiment_result_data, 'status': 'DONE', 'success': True,
'time_taken': result.get('execution_time_in_seconds'), 'header': header}
experiment_results.append(ExperimentResult(**experiment_result_dictionary))
return experiment_results
def test_marginal_counts(self):
"""Test that counts are marginalized correctly."""
raw_counts = {
"0x0": 4,
"0x1": 7,
"0x2": 10,
"0x6": 5,
"0x9": 11,
"0xD": 9,
"0xE": 8
}
data = models.ExperimentResultData(counts=dict(**raw_counts))
exp_result_header = QobjExperimentHeader(creg_sizes=[["c0", 4]],
memory_slots=4)
exp_result = models.ExperimentResult(shots=54,
success=True,
data=data,
header=exp_result_header)
result = Result(results=[exp_result], **self.base_result_args)
expected_marginal_counts = {"00": 4, "01": 27, "10": 23}
self.assertEqual(marginal_counts(result.get_counts(), [0, 1]),
expected_marginal_counts)
self.assertEqual(marginal_counts(result.get_counts(), [1, 0]),
expected_marginal_counts)
def test_marginal_counts_no_cregs(self):
"""Test that marginal_counts without cregs See qiskit-terra/6430."""
raw_counts_1 = {
"0x0": 4,
"0x1": 7,
"0x2": 10,
"0x6": 5,
"0x9": 11,
"0xD": 9,
"0x12": 8
}
data_1 = models.ExperimentResultData(counts=dict(**raw_counts_1))
exp_result_header_1 = QobjExperimentHeader(memory_slots=5)
exp_result_1 = models.ExperimentResult(shots=54,
success=True,
data=data_1,
header=exp_result_header_1)
result = Result(results=[exp_result_1], **self.base_result_args)
_ = marginal_counts(result, indices=[0])
marginal_counts_result = marginal_counts(result, indices=[0])
self.assertEqual(marginal_counts_result.get_counts(), {
"0": 27,
"1": 27
})
def test_counts_duplicate_name(self):
"""Test results containing multiple entries of a single name will warn."""
data = models.ExperimentResultData(counts=dict())
exp_result_header = QobjExperimentHeader(name='foo')
exp_result = models.ExperimentResult(shots=14, success=True,
data=data, header=exp_result_header)
result = Result(results=[exp_result] * 2, **self.base_result_args)
with self.assertWarnsRegex(UserWarning, r'multiple.*foo'):
result.get_counts('foo')
def new_fake_qobj():
"""Create fake `Qobj` and backend instances."""
backend = FakeBackend()
return Qobj(id='test-id',
config=QobjConfig(shots=1024, memory_slots=1, max_credits=100),
header=QobjHeader(backend_name=backend.name),
experiments=[
QobjExperiment(instructions=[],
header=QobjExperimentHeader(
compiled_circuit_qasm='fake-code'),
config=QobjItem(seed=123456))
])
def __init__(self):
qobj_id = "test_id"
config = QasmQobjConfig(shots=1024, memory_slots=1)
header = QobjHeader(backend_name=FakeQasmSimulator().name())
experiments = [
QasmQobjExperiment(
instructions=[QasmQobjInstruction(name="barrier", qubits=[1])],
header=QobjExperimentHeader(),
config=QasmQobjExperimentConfig(seed=123456),
)
]
super().__init__(qobj_id=qobj_id, config=config, experiments=experiments, header=header)
def test_counts_by_name(self):
"""Test that counts are extracted properly by name."""
raw_counts = {'0x0': 4, '0x2': 10}
processed_counts = {'0 0 00': 4, '0 0 10': 10}
data = models.ExperimentResultData(counts=dict(**raw_counts))
exp_result_header = QobjExperimentHeader(
creg_sizes=[['c0', 2], ['c0', 1], ['c1', 1]], memory_slots=4, name='a_name')
exp_result = models.ExperimentResult(shots=14, success=True, meas_level=2,
data=data, header=exp_result_header)
result = Result(results=[exp_result], **self.base_result_args)
self.assertEqual(result.get_counts('a_name'), processed_counts)
def test_marginal_distribution(self):
"""Test that counts are marginalized correctly."""
raw_counts = {
"0x0": 4,
"0x1": 7,
"0x2": 10,
"0x6": 5,
"0x9": 11,
"0xD": 9,
"0xE": 8
}
data = models.ExperimentResultData(counts=raw_counts)
exp_result_header = QobjExperimentHeader(creg_sizes=[["c0", 4]],
memory_slots=4)
exp_result = models.ExperimentResult(shots=54,
success=True,
data=data,
header=exp_result_header)
result = Result(results=[exp_result], **self.base_result_args)
expected_marginal_counts = {"00": 4, "01": 27, "10": 23}
expected_reverse = {"00": 4, "10": 27, "01": 23}
self.assertEqual(marginal_distribution(result.get_counts(), [0, 1]),
expected_marginal_counts)
self.assertEqual(marginal_distribution(result.get_counts(), [1, 0]),
expected_reverse)
# test with register spacing, bitstrings are in form of "00 00" for register split
data = models.ExperimentResultData(counts=raw_counts)
exp_result_header = QobjExperimentHeader(creg_sizes=[["c0", 2],
["c1", 2]],
memory_slots=4)
exp_result = models.ExperimentResult(shots=54,
success=True,
data=data,
header=exp_result_header)
result = Result(results=[exp_result], **self.base_result_args)
self.assertEqual(marginal_distribution(result.get_counts(), [0, 1]),
expected_marginal_counts)
self.assertEqual(marginal_distribution(result.get_counts(), [1, 0]),
expected_reverse)
def test_marginal_counts_result(self):
"""Test that a Result object containing counts marginalizes correctly."""
raw_counts_1 = {
'0x0': 4,
'0x1': 7,
'0x2': 10,
'0x6': 5,
'0x9': 11,
'0xD': 9,
'0xE': 8
}
data_1 = models.ExperimentResultData(counts=dict(**raw_counts_1))
exp_result_header_1 = QobjExperimentHeader(creg_sizes=[['c0', 4]],
memory_slots=4)
exp_result_1 = models.ExperimentResult(shots=54,
success=True,
data=data_1,
header=exp_result_header_1)
raw_counts_2 = {'0x2': 5, '0x3': 8}
data_2 = models.ExperimentResultData(counts=dict(**raw_counts_2))
exp_result_header_2 = QobjExperimentHeader(creg_sizes=[['c0', 2]],
memory_slots=2)
exp_result_2 = models.ExperimentResult(shots=13,
success=True,
data=data_2,
header=exp_result_header_2)
result = Result(results=[exp_result_1, exp_result_2],
**self.base_result_args)
expected_marginal_counts_1 = {'00': 4, '01': 27, '10': 23}
expected_marginal_counts_2 = {'0': 5, '1': 8}
self.assertEqual(
marginal_counts(result, [0, 1]).get_counts(0),
expected_marginal_counts_1)
self.assertEqual(
marginal_counts(result, [0]).get_counts(1),
expected_marginal_counts_2)
def new_fake_qobj():
"""Create fake `Qobj` and backend instances."""
backend = FakeQasmSimulator()
return QasmQobj(
qobj_id='test-id',
config=QasmQobjConfig(shots=1024, memory_slots=1, max_credits=100),
header=QobjHeader(backend_name=backend.name()),
experiments=[
QasmQobjExperiment(
instructions=[QasmQobjInstruction(name='barrier', qubits=[1])],
header=QobjExperimentHeader(),
config=QasmQobjExperimentConfig(seed_simulator=123456))
])
def test_marginal_counts_inplace_false(self):
"""Test marginal_counts(Result, inplace=False) """
raw_counts_1 = {'0x0': 4, '0x1': 7, '0x2': 10, '0x6': 5, '0x9': 11, '0xD': 9, '0xE': 8}
data_1 = models.ExperimentResultData(counts=dict(**raw_counts_1))
exp_result_header_1 = QobjExperimentHeader(creg_sizes=[['c0', 4]], memory_slots=4)
exp_result_1 = models.ExperimentResult(shots=54, success=True, data=data_1,
header=exp_result_header_1)
raw_counts_2 = {'0x2': 5, '0x3': 8}
data_2 = models.ExperimentResultData(counts=dict(**raw_counts_2))
exp_result_header_2 = QobjExperimentHeader(creg_sizes=[['c0', 2]], memory_slots=2)
exp_result_2 = models.ExperimentResult(shots=13, success=True, data=data_2,
header=exp_result_header_2)
result = Result(results=[exp_result_1, exp_result_2], **self.base_result_args)
expected_marginal_counts = {'0': 27, '1': 27}
self.assertEqual(marginal_counts(result, [0], inplace=False).get_counts(0),
expected_marginal_counts)
self.assertNotEqual(result.get_counts(0),
expected_marginal_counts)
def generate_qiskit_result(self):
"""Generate standard Result for testing"""
memory = [hex(ii) for ii in range(8)]
counts = {m: 1 for m in memory}
data_1 = models.ExperimentResultData(counts=counts, memory=memory)
exp_result_header_1 = QobjExperimentHeader(creg_sizes=[["c0", 4]],
memory_slots=4)
exp_result_1 = models.ExperimentResult(shots=8,
success=True,
data=data_1,
header=exp_result_header_1)
result = Result(results=[exp_result_1], **self.base_result_args)
return result
def test_counts_name_out(self):
"""Test that fails when get_count is called with a nonexistent name."""
raw_counts = {'0x0': 4, '0x2': 10}
data = models.ExperimentResultData(counts=dict(**raw_counts))
exp_result_header = QobjExperimentHeader(
creg_sizes=[['c0', 2], ['c0', 1], ['c1', 1]], memory_slots=4, name='a_name')
exp_result = models.ExperimentResult(shots=14, success=True, meas_level=2,
data=data, header=exp_result_header)
result = Result(results=[exp_result], **self.base_result_args)
with self.assertRaises(Exception) as context:
result.get_counts('another_name')
self.assertEqual('Data for experiment "another_name" could not be found.',
context.exception.message)
def test_marginal_counts_inplace_false(self):
"""Test marginal_counts(Result, inplace=False)"""
raw_counts_1 = {
"0x0": 4,
"0x1": 7,
"0x2": 10,
"0x6": 5,
"0x9": 11,
"0xD": 9,
"0xE": 8
}
data_1 = models.ExperimentResultData(counts=dict(**raw_counts_1))
exp_result_header_1 = QobjExperimentHeader(creg_sizes=[["c0", 4]],
memory_slots=4)
exp_result_1 = models.ExperimentResult(shots=54,
success=True,
data=data_1,
header=exp_result_header_1)
raw_counts_2 = {"0x2": 5, "0x3": 8}
data_2 = models.ExperimentResultData(counts=dict(**raw_counts_2))
exp_result_header_2 = QobjExperimentHeader(creg_sizes=[["c0", 2]],
memory_slots=2)
exp_result_2 = models.ExperimentResult(shots=13,
success=True,
data=data_2,
header=exp_result_header_2)
result = Result(results=[exp_result_1, exp_result_2],
**self.base_result_args)
expected_marginal_counts = {"0": 27, "1": 27}
self.assertEqual(
marginal_counts(result, [0], inplace=False).get_counts(0),
expected_marginal_counts)
self.assertNotEqual(result.get_counts(0), expected_marginal_counts)
def test_multiple_circuits_counts(self):
""""
Test that counts are returned either as a list or a single item.
Counts are returned as a list when multiple experiments are executed
and get_counts() is called with no arguments. In all the other cases
get_counts() returns a single item containing the counts for a
single experiment.
"""
raw_counts_1 = {'0x0': 5, '0x3': 12, '0x5': 9, '0xD': 6, '0xE': 2}
processed_counts_1 = {'0000': 5, '0011': 12, '0101': 9, '1101': 6, '1110': 2}
data_1 = models.ExperimentResultData(counts=dict(**raw_counts_1))
exp_result_header_1 = QobjExperimentHeader(creg_sizes=[['c0', 4]], memory_slots=4)
exp_result_1 = models.ExperimentResult(shots=14, success=True, meas_level=2, data=data_1,
header=exp_result_header_1)
raw_counts_2 = {'0x1': 0, '0x4': 3, '0x6': 6, '0xA': 1, '0xB': 2}
processed_counts_2 = {'0001': 0, '0100': 3, '0110': 6, '1010': 1, '1011': 2}
data_2 = models.ExperimentResultData(counts=dict(**raw_counts_2))
exp_result_header_2 = QobjExperimentHeader(creg_sizes=[['c0', 4]], memory_slots=4)
exp_result_2 = models.ExperimentResult(shots=14, success=True, meas_level=2, data=data_2,
header=exp_result_header_2)
raw_counts_3 = {'0xC': 27, '0xF': 20}
processed_counts_3 = {'1100': 27, '1111': 20}
data_3 = models.ExperimentResultData(counts=dict(**raw_counts_3))
exp_result_header_3 = QobjExperimentHeader(creg_sizes=[['c0', 4]], memory_slots=4)
exp_result_3 = models.ExperimentResult(shots=14, success=True, meas_level=2, data=data_3,
header=exp_result_header_3)
mult_result = Result(results=[exp_result_1, exp_result_2, exp_result_3],
**self.base_result_args)
sing_result = Result(results=[exp_result_1], **self.base_result_args)
self.assertEqual(mult_result.get_counts(), [processed_counts_1, processed_counts_2,
processed_counts_3])
self.assertEqual(sing_result.get_counts(), processed_counts_1)
def test_marginal_counts_result_format(self):
"""Test that marginal_counts with format_marginal true properly formats output."""
raw_counts_1 = {'0x0': 4, '0x1': 7, '0x2': 10, '0x6': 5, '0x9': 11, '0xD': 9, '0x12': 8}
data_1 = models.ExperimentResultData(counts=dict(**raw_counts_1))
exp_result_header_1 = QobjExperimentHeader(creg_sizes=[['c0', 2], ['c1', 3]],
memory_slots=5)
exp_result_1 = models.ExperimentResult(shots=54, success=True, data=data_1,
header=exp_result_header_1)
result = Result(results=[exp_result_1], **self.base_result_args)
expected_marginal_counts_1 = {'0_0 _0': 14, '0_0 _1': 18,
'0_1 _0': 5, '0_1 _1': 9, '1_0 _0': 8}
marginal_counts_result = marginal_counts(result.get_counts(), [0, 2, 4],
format_marginal=True)
self.assertEqual(marginal_counts_result, expected_marginal_counts_1)
def test_result_repr(self):
"""Test that repr is contstructed correctly for a results object."""
raw_counts = {'0x0': 4, '0x2': 10}
data = models.ExperimentResultData(counts=dict(**raw_counts))
exp_result_header = QobjExperimentHeader(
creg_sizes=[['c0', 2], ['c0', 1], ['c1', 1]], memory_slots=4)
exp_result = models.ExperimentResult(shots=14, success=True, meas_level=2,
data=data, header=exp_result_header)
result = Result(results=[exp_result], **self.base_result_args)
expected = ("Result(backend_name='test_backend', backend_version='1.0.0', "
"qobj_id='id-123', job_id='job-123', success=True, "
"results=[ExperimentResult(shots=14, success=True, "
"meas_level=2, data=ExperimentResultData(counts={'0x0': 4,"
" '0x2': 10}), header=QobjExperimentHeader(creg_sizes="
"[['c0', 2], ['c0', 1], ['c1', 1]], memory_slots=4))])")
self.assertEqual(expected, repr(result))
def test_counts_header(self):
"""Test that counts are extracted properly with header."""
raw_counts = {"0x0": 4, "0x2": 10}
processed_counts = {"0 0 00": 4, "0 0 10": 10}
data = models.ExperimentResultData(counts=dict(**raw_counts))
exp_result_header = QobjExperimentHeader(creg_sizes=[["c0", 2],
["c0", 1],
["c1", 1]],
memory_slots=4)
exp_result = models.ExperimentResult(shots=14,
success=True,
meas_level=2,
data=data,
header=exp_result_header)
result = Result(results=[exp_result], **self.base_result_args)
self.assertEqual(result.get_counts(0), processed_counts)
def get_experiment_results(self, qi_job: QIJob) -> List[ExperimentResult]:
""" Get results from experiments from the Quantum-inspire platform.
Args:
qi_job: A job that has already been submitted and which execution is completed.
Raises:
QisKitBackendError: If an error occurred during execution by the backend.
Returns:
A list of experiment results; containing the data, execution time, status, etc.
"""
jobs = self.__api.get_jobs_from_project(int(qi_job.job_id()))
results = [self.__api.get_result_from_job(job['id']) for job in jobs]
experiment_results = []
for result, job in zip(results, jobs):
if not result.get('histogram', {}):
raise QisKitBackendError(
'Result from backend contains no histogram data!\n{}'.
format(result.get('raw_text')))
user_data = json.loads(str(job.get('user_data')))
measurements = user_data.pop('measurements')
histogram_obj, memory_data = self.__convert_result_data(
result, measurements)
full_state_histogram_obj = self.__convert_histogram(
result, measurements)
experiment_result_data = ExperimentResultData(counts=histogram_obj,
memory=memory_data)
experiment_result_data.probabilities = full_state_histogram_obj
header = QobjExperimentHeader.from_dict(user_data)
experiment_result_dictionary = {
'name': job.get('name'),
'seed': 42,
'shots': job.get('number_of_shots'),
'data': experiment_result_data,
'status': 'DONE',
'success': True,
'time_taken': result.get('execution_time_in_seconds'),
'header': header
}
experiment_results.append(
ExperimentResult(**experiment_result_dictionary))
return experiment_results
def _generate_experiment_result(qlm_result, metadata):
"""
Generates a Qiskit experiment result.
Args:
qlm_result: qat.core.wrappers.Result object which data is aggregated
metadata: metadata of the circuit of the experiment
Returns:
An ExperimentResult structure.
"""
samples = [hex(s.state.state) for s in qlm_result.raw_data]
counts = dict(Counter(samples))
data = ExperimentResultData.from_dict({"counts": counts})
return ExperimentResult(
shots=len(qlm_result.raw_data),
success=True,
data=data,
header=QobjExperimentHeader(**metadata),
)
def test_marginal_counts_result_creg_sizes(self):
"""Test that marginal_counts with Result input properly changes creg_sizes."""
raw_counts = {'0x0': 4, '0x1': 7, '0x2': 10, '0x6': 5, '0x9': 11, '0xD': 9, '0xE': 8}
data = models.ExperimentResultData(counts=dict(**raw_counts))
exp_result_header = QobjExperimentHeader(creg_sizes=[['c0', 1], ['c1', 3]],
memory_slots=4)
exp_result = models.ExperimentResult(shots=54, success=True, data=data,
header=exp_result_header)
result = Result(results=[exp_result], **self.base_result_args)
expected_marginal_counts = {'0 0': 14, '0 1': 18, '1 0': 13, '1 1': 9}
expected_creg_sizes = [['c0', 1], ['c1', 1]]
expected_memory_slots = 2
marginal_counts_result = marginal_counts(result, [0, 2])
self.assertEqual(marginal_counts_result.results[0].header.creg_sizes,
expected_creg_sizes)
self.assertEqual(marginal_counts_result.results[0].header.memory_slots,
expected_memory_slots)
self.assertEqual(marginal_counts_result.get_counts(0),
expected_marginal_counts)
def from_dict(cls, data):
"""Create a new ExperimentResult object from a dictionary.
Args:
data (dict): A dictionary representing the ExperimentResult to
create. It will be in the same format as output by
:meth:`to_dict`
Returns:
ExperimentResult: The ``ExperimentResult`` object from the input
dictionary.
"""
in_data = copy.copy(data)
data_obj = ExperimentResultData.from_dict(in_data.pop("data"))
if "header" in in_data:
in_data["header"] = QobjExperimentHeader.from_dict(
in_data.pop("header"))
shots = in_data.pop("shots")
success = in_data.pop("success")
return cls(shots, success, data_obj, **in_data)
def _gen_debug_results(n_qubits: int, shots: int, index: int) -> Result:
raw_counts = {"0x0": shots}
raw_memory = ["0x0"] * shots
base_result_args = dict(
backend_name="test_backend",
backend_version="1.0.0",
qobj_id="id-123",
job_id="job-123",
success=True,
)
data = models.ExperimentResultData(counts=raw_counts, memory=raw_memory)
exp_result_header = QobjExperimentHeader(creg_sizes=[["c", n_qubits]],
memory_slots=n_qubits)
exp_result = models.ExperimentResult(
shots=shots,
success=True,
meas_level=2,
data=data,
header=exp_result_header,
memory=True,
)
results = [exp_result] * (index + 1)
return Result(results=results, **base_result_args)
def assemble_schedules(schedules, qobj_id, qobj_header, run_config):
"""Assembles a list of schedules into a qobj which can be run on the backend.
Args:
schedules (list[Schedule]): schedules to assemble
qobj_id (int): identifier for the generated qobj
qobj_header (QobjHeader): header to pass to the results
run_config (RunConfig): configuration of the runtime environment
Returns:
PulseQobj: the Qobj to be run on the backends
Raises:
QiskitError: when invalid schedules or configs are provided
"""
if hasattr(run_config, 'instruction_converter'):
instruction_converter = run_config.instruction_converter
else:
instruction_converter = InstructionToQobjConverter
qobj_config = run_config.to_dict()
qubit_lo_freq = qobj_config.get('qubit_lo_freq', None)
if qubit_lo_freq is None:
raise QiskitError('qubit_lo_freq must be supplied.')
meas_lo_freq = qobj_config.get('meas_lo_freq', None)
if meas_lo_freq is None:
raise QiskitError('meas_lo_freq must be supplied.')
qubit_lo_range = qobj_config.pop('qubit_lo_range', None)
meas_lo_range = qobj_config.pop('meas_lo_range', None)
meas_map = qobj_config.pop('meas_map', None)
# convert enums to serialized values
meas_return = qobj_config.get('meas_return', 'avg')
if isinstance(meas_return, MeasReturnType):
qobj_config['meas_return'] = meas_return.value
meas_level = qobj_config.get('meas_return', 2)
if isinstance(meas_level, MeasLevel):
qobj_config['meas_level'] = meas_level.value
instruction_converter = instruction_converter(PulseQobjInstruction, **qobj_config)
lo_converter = LoConfigConverter(PulseQobjExperimentConfig,
qubit_lo_range=qubit_lo_range,
meas_lo_range=meas_lo_range,
**qobj_config)
memory_slot_size = 0
# Pack everything into the Qobj
qobj_schedules = []
user_pulselib = {}
for idx, schedule in enumerate(schedules):
# instructions
max_memory_slot = 0
qobj_instructions = []
# Instructions are returned as tuple of shifted time and instruction
for shift, instruction in schedule.instructions:
# TODO: support conditional gate
if isinstance(instruction, DelayInstruction):
# delay instructions are ignored as timing is explicit within qobj
continue
elif isinstance(instruction, PulseInstruction):
name = instruction.command.name
if name in user_pulselib and instruction.command != user_pulselib[name]:
name = "{0}-{1:x}".format(name, hash(instruction.command.samples.tostring()))
instruction = PulseInstruction(
command=SamplePulse(name=name, samples=instruction.command.samples),
name=instruction.name,
channel=instruction.channels[0])
# add samples to pulse library
user_pulselib[name] = instruction.command
elif isinstance(instruction, AcquireInstruction):
max_memory_slot = max(max_memory_slot,
*[slot.index for slot in instruction.mem_slots])
if meas_map:
# verify all acquires satisfy meas_map
_validate_meas_map(instruction, meas_map)
converted_instruction = instruction_converter(shift, instruction)
qobj_instructions.append(converted_instruction)
# memory slot size is memory slot index + 1 because index starts from zero
exp_memory_slot_size = max_memory_slot + 1
memory_slot_size = max(memory_slot_size, exp_memory_slot_size)
# experiment header
# TODO: add other experimental header items (see circuit assembler)
qobj_experiment_header = QobjExperimentHeader(
memory_slots=exp_memory_slot_size,
name=schedule.name or 'Experiment-%d' % idx
)
qobj_schedules.append({
'header': qobj_experiment_header,
'instructions': qobj_instructions
})
# set number of memoryslots
qobj_config['memory_slots'] = memory_slot_size
# setup pulse_library
qobj_config['pulse_library'] = [PulseLibraryItem(name=pulse.name, samples=pulse.samples)
for pulse in user_pulselib.values()]
# create qobj experiment field
experiments = []
schedule_los = qobj_config.pop('schedule_los', [])
if len(schedule_los) == 1:
lo_dict = schedule_los[0]
# update global config
q_los = lo_converter.get_qubit_los(lo_dict)
if q_los:
qobj_config['qubit_lo_freq'] = q_los
m_los = lo_converter.get_meas_los(lo_dict)
if m_los:
qobj_config['meas_lo_freq'] = m_los
if schedule_los:
# multiple frequency setups
if len(qobj_schedules) == 1:
# frequency sweep
for lo_dict in schedule_los:
experiments.append(PulseQobjExperiment(
instructions=qobj_schedules[0]['instructions'],
header=qobj_schedules[0]['header'],
config=lo_converter(lo_dict)
))
elif len(qobj_schedules) == len(schedule_los):
# n:n setup
for lo_dict, schedule in zip(schedule_los, qobj_schedules):
experiments.append(PulseQobjExperiment(
instructions=schedule['instructions'],
header=schedule['header'],
config=lo_converter(lo_dict)
))
else:
raise QiskitError('Invalid LO setting is specified. '
'The LO should be configured for each schedule, or '
'single setup for all schedules (unique), or '
'multiple setups for a single schedule (frequency sweep),'
'or no LO configured at all.')
else:
# unique frequency setup
for schedule in qobj_schedules:
experiments.append(PulseQobjExperiment(
instructions=schedule['instructions'],
header=schedule['header'],
))
qobj_config = PulseQobjConfig(**qobj_config)
return PulseQobj(qobj_id=qobj_id,
config=qobj_config,
experiments=experiments,
header=qobj_header)
def _assemble_experiments(
schedules: List[Schedule], lo_converter: LoConfigConverter,
run_config: RunConfig
) -> Tuple[List[PulseQobjExperiment], Dict[str, Any]]:
"""Assembles a list of schedules into PulseQobjExperiments, and returns related metadata that
will be assembled into the Qobj configuration.
Args:
schedules: Schedules to assemble.
lo_converter: The configured frequency converter and validator.
run_config: Configuration of the runtime environment.
Returns:
The list of assembled experiments, and the dictionary of related experiment config.
Raises:
QiskitError: when frequency settings are not compatible with the experiments.
"""
freq_configs = [
lo_converter(lo_dict)
for lo_dict in getattr(run_config, 'schedule_los', [])
]
if len(schedules) > 1 and len(freq_configs) not in [0, 1, len(schedules)]:
raise QiskitError(
'Invalid frequency setting is specified. If the frequency is specified, '
'it should be configured the same for all schedules, configured for each '
'schedule, or a list of frequencies should be provided for a single '
'frequency sweep schedule.')
instruction_converter = getattr(run_config, 'instruction_converter',
InstructionToQobjConverter)
instruction_converter = instruction_converter(PulseQobjInstruction,
**run_config.to_dict())
compressed_schedules = reschedule.compress_pulses(schedules)
user_pulselib = {}
experiments = []
for idx, schedule in enumerate(compressed_schedules):
qobj_instructions, max_memory_slot = _assemble_instructions(
schedule, instruction_converter, run_config, user_pulselib)
# TODO: add other experimental header items (see circuit assembler)
qobj_experiment_header = QobjExperimentHeader(
memory_slots=max_memory_slot + 1, # Memory slots are 0 indexed
name=schedule.name or 'Experiment-%d' % idx)
experiment = PulseQobjExperiment(header=qobj_experiment_header,
instructions=qobj_instructions)
if freq_configs:
# This handles the cases where one frequency setting applies to all experiments and
# where each experiment has a different frequency
freq_idx = idx if len(freq_configs) != 1 else 0
experiment.config = freq_configs[freq_idx]
experiments.append(experiment)
# Frequency sweep
if freq_configs and len(experiments) == 1:
experiment = experiments[0]
experiments = []
for freq_config in freq_configs:
experiments.append(
PulseQobjExperiment(header=experiment.header,
instructions=experiment.instructions,
config=freq_config))
# Top level Qobj configuration
experiment_config = {
'pulse_library': [
PulseLibraryItem(name=name, samples=samples)
for name, samples in user_pulselib.items()
],
'memory_slots':
max([exp.header.memory_slots for exp in experiments])
}
return experiments, experiment_config
