def simulate_output_data(func, xvals, param_dict, **metadata):
"""Generate arbitrary fit data."""
__shots = 100000
expected_probs = func(xvals, **param_dict)
counts = np.asarray(expected_probs * __shots, dtype=int)
data = [{
"counts": {
"0": __shots - count,
"1": count
},
"metadata":
dict(xval=xi,
qubits=(0, ),
experiment_type="fake_experiment",
**metadata),
} for xi, count in zip(xvals, counts)]
expdata = ExperimentData(experiment=FakeExperiment())
for datum in data:
expdata.add_data(datum)
expdata.metadata["job_metadata"] = [{
"run_options": {
"meas_level": MeasLevel.CLASSIFIED
}
}]
return expdata
def test_t1_analysis(self):
"""
Test T1Analysis
"""
data = ExperimentData()
numbers = [
750, 1800, 2750, 3550, 4250, 4850, 5450, 5900, 6400, 6800, 7000,
7350, 7700
]
for i, count0 in enumerate(numbers):
data.add_data({
"counts": {
"0": count0,
"1": 10000 - count0
},
"metadata": {
"xval": 3 * i + 1,
"experiment_type": "T1",
"qubit": 0,
"unit": "ns",
"dt_factor_in_sec": None,
},
})
res = T1Analysis()._run_analysis(data)[0][0]
self.assertEqual(res.quality, "good")
self.assertAlmostEqual(res.value.value, 25e-9, delta=3)
def test_qv_failure_insufficient_confidence(self):
"""
Test that the quantum volume is unsuccessful when:
there are more than 100 trials, the heavy output probability mean is more than 2/3
but the confidence is not high enough
"""
dir_name = os.path.dirname(os.path.abspath(__file__))
insufficient_confidence_json = "qv_data_moderate_noise_100_trials.json"
with open(os.path.join(dir_name, insufficient_confidence_json),
"r") as json_file:
insufficient_confidence_data = json.load(json_file,
cls=ExperimentDecoder)
num_of_qubits = 4
backend = Aer.get_backend("aer_simulator")
qv_exp = QuantumVolume(num_of_qubits, seed=SEED)
exp_data = ExperimentData(experiment=qv_exp, backend=backend)
exp_data.add_data(insufficient_confidence_data)
qv_exp.run_analysis(exp_data)
qv_result = exp_data.analysis_results(1)
self.assertTrue(
qv_result.extra["success"] is False and qv_result.value == 1,
"quantum volume is successful with insufficient confidence",
)
def test_t1_low_quality(self):
"""
A test where the fit's quality will be low
"""
data = ExperimentData()
data._metadata = {
"job_metadata": [
{
"run_options": {
"meas_level": 2
},
},
]
}
for i in range(10):
data.add_data({
"counts": {
"0": 10,
"1": 10
},
"metadata": {
"xval": i * 1e-9,
"experiment_type": "T1",
"qubit": 0,
"unit": "s",
},
})
res, _ = T1Analysis()._run_analysis(data)
result = res[1]
self.assertEqual(result.quality, "bad")
def test_composite_single_kerneled_memory_marginalization(self):
"""Test the marginalization of level 1 data."""
test_data = ExperimentData()
datum = {
"memory": [
# qubit 0, qubit 1, qubit 2
[[0.0, 0.0], [1.0, 1.0], [2.0, 2.0]], # shot 1
[[0.1, 0.1], [1.1, 1.1], [2.1, 2.1]], # shot 2
[[0.2, 0.2], [1.2, 1.2], [2.2, 2.2]], # shot 3
[[0.3, 0.3], [1.3, 1.3], [2.3, 2.3]], # shot 4
[[0.4, 0.4], [1.4, 1.4], [2.4, 2.4]], # shot 5
],
"metadata": {
"experiment_type":
"ParallelExperiment",
"composite_index": [0, 1, 2],
"composite_metadata": [
{
"experiment_type": "FineXAmplitude",
"qubits": [0]
},
{
"experiment_type": "FineXAmplitude",
"qubits": [1]
},
{
"experiment_type": "FineXAmplitude",
"qubits": [2]
},
],
"composite_qubits": [[0], [1], [2]],
"composite_clbits": [[0], [1], [2]],
},
"shots":
5,
"meas_level":
1,
}
test_data.add_data(datum)
all_sub_data = CompositeAnalysis([])._marginalized_component_data(
test_data.data())
for idx, sub_data in enumerate(all_sub_data):
expected = {
"metadata": {
"experiment_type": "FineXAmplitude",
"qubits": [idx]
},
"memory": [
[[idx + 0.0, idx + 0.0]],
[[idx + 0.1, idx + 0.1]],
[[idx + 0.2, idx + 0.2]],
[[idx + 0.3, idx + 0.3]],
[[idx + 0.4, idx + 0.4]],
],
}
self.assertEqual(expected, sub_data[0])
def test_local_analysis(self):
"""Tests local mitigator generation from experimental data"""
qubits = [0, 1, 2]
run_data = [
{
"counts": {"000": 986, "010": 10, "100": 16, "001": 12},
"metadata": {"label": "000"},
"shots": 1024,
},
{
"counts": {"111": 930, "110": 39, "011": 24, "101": 29, "010": 1, "100": 1},
"metadata": {"label": "111"},
"shots": 1024,
},
]
expected_assignment_matrices = [
np.array([[0.98828125, 0.04003906], [0.01171875, 0.95996094]]),
np.array([[0.99023438, 0.02929688], [0.00976562, 0.97070312]]),
np.array([[0.984375, 0.02441406], [0.015625, 0.97558594]]),
]
run_meta = {"physical_qubits": qubits}
expdata = ExperimentData()
expdata.add_data(run_data)
expdata._metadata = run_meta
exp = ReadoutMitigationExperiment(qubits)
result = exp.analysis.run(expdata)
mitigator = result.analysis_results(0).value
self.assertEqual(len(qubits), mitigator._num_qubits)
self.assertEqual(qubits, mitigator._qubits)
self.assertTrue(matrix_equal(expected_assignment_matrices, mitigator._assignment_mats))
def test_qv_failure_insufficient_trials(self):
"""
Test that the quantum volume is unsuccessful when:
there is less than 100 trials
"""
dir_name = os.path.dirname(os.path.abspath(__file__))
insufficient_trials_json_file = "qv_data_70_trials.json"
with open(os.path.join(dir_name, insufficient_trials_json_file),
"r") as json_file:
insufficient_trials_data = json.load(json_file,
cls=ExperimentDecoder)
num_of_qubits = 3
backend = Aer.get_backend("aer_simulator")
qv_exp = QuantumVolume(num_of_qubits, seed=SEED)
exp_data = ExperimentData(experiment=qv_exp, backend=backend)
exp_data.add_data(insufficient_trials_data)
qv_exp.run_analysis(exp_data)
qv_result = exp_data.analysis_results(1)
self.assertTrue(
qv_result.extra["success"] is False and qv_result.value == 1,
"quantum volume is successful with less than 100 trials",
)
def test_t1_analysis(self):
"""
Test T1Analysis
"""
data = ExperimentData()
data._metadata = {"meas_level": 2}
numbers = [
750, 1800, 2750, 3550, 4250, 4850, 5450, 5900, 6400, 6800, 7000,
7350, 7700
]
for i, count0 in enumerate(numbers):
data.add_data({
"counts": {
"0": count0,
"1": 10000 - count0
},
"metadata": {
"xval": (3 * i + 1) * 1e-9,
"experiment_type": "T1",
"qubit": 0,
"unit": "s",
},
})
res, _ = T1Analysis()._run_analysis(data)
result = res[1]
self.assertEqual(result.quality, "good")
self.assertAlmostEqual(result.value.nominal_value, 25e-9, delta=3)
def _load_json_data(self, rb_exp_data_file_name: str):
"""
loader for the experiment data and configuration setup.
Args:
rb_exp_data_file_name(str): The file name that contain the experiment data.
Returns:
list: containing dict of the experiment setup configuration and list of dictionaries
containing the experiment results.
ExperimentData: ExperimentData object that was creates by the analysis function.
"""
expdata1 = ExperimentData()
self.assertTrue(
os.path.isfile(rb_exp_data_file_name),
"The file containing the experiment data doesn't exist."
" Please run the data generator.",
)
with open(rb_exp_data_file_name, "r") as json_file:
data = json.load(json_file)
# The experiment attributes added
exp_attributes = data[0]
# pylint: disable=protected-access, invalid-name
expdata1._metadata = data[0]
# The experiment data located in index [1] as it is a list of dicts
expdata1.add_data(data[1])
return data, exp_attributes, expdata1
def test_to_real(self):
"""Test scaling and conversion to real part."""
processor = DataProcessor("memory", [ToReal(scale=1e-3)])
exp_data = ExperimentData(FakeExperiment())
exp_data.add_data(self.result_lvl1)
# Test to real on a single datum
new_data = processor(exp_data.data(0))
expected_old = {
"memory": [
[[1103260.0, -11378508.0], [2959012.0, -16488753.0]],
[[442170.0, -19283206.0], [-5279410.0, -15339630.0]],
[[3016514.0, -14548009.0], [-3404756.0, -16743348.0]],
],
"metadata": {"experiment_type": "fake_test_experiment"},
"job_id": "job-123",
"meas_level": 1,
"shots": 3,
}
expected_new = np.array([[1103.26, 2959.012], [442.17, -5279.41], [3016.514, -3404.7560]])
self.assertEqual(exp_data.data(0), expected_old)
np.testing.assert_array_almost_equal(
unp.nominal_values(new_data),
expected_new,
)
self.assertTrue(np.isnan(unp.std_devs(new_data)).all())
# Test that we can call with history.
new_data, history = processor.call_with_history(exp_data.data(0))
self.assertEqual(exp_data.data(0), expected_old)
np.testing.assert_array_almost_equal(
unp.nominal_values(new_data),
expected_new,
)
self.assertEqual(history[0][0], "ToReal")
np.testing.assert_array_almost_equal(
unp.nominal_values(history[0][1]),
expected_new,
)
# Test to real on more than one datum
new_data = processor(exp_data.data())
expected_new = np.array(
[
[[1103.26, 2959.012], [442.17, -5279.41], [3016.514, -3404.7560]],
[[5131.962, 4438.87], [3415.985, 2942.458], [5199.964, 4030.843]],
]
)
np.testing.assert_array_almost_equal(
unp.nominal_values(new_data),
expected_new,
)
def test_to_imag(self):
"""Test that we can average the data."""
processor = DataProcessor("memory")
processor.append(ToImag(scale=1e-3))
exp_data = ExperimentData(FakeExperiment())
exp_data.add_data(self.result_lvl1)
new_data, error = processor(exp_data.data(0))
expected_old = {
"memory": [
[[1103260.0, -11378508.0], [2959012.0, -16488753.0]],
[[442170.0, -19283206.0], [-5279410.0, -15339630.0]],
[[3016514.0, -14548009.0], [-3404756.0, -16743348.0]],
],
"metadata": {
"experiment_type": "fake_test_experiment"
},
"job_id":
"job-123",
"meas_level":
1,
"shots":
3,
}
expected_new = np.array([
[-11378.508, -16488.753],
[-19283.206000000002, -15339.630000000001],
[-14548.009, -16743.348],
])
self.assertEqual(exp_data.data(0), expected_old)
self.assertTrue(np.allclose(new_data, expected_new))
self.assertIsNone(error)
# Test that we can call with history.
new_data, error, history = processor.call_with_history(
exp_data.data(0))
self.assertEqual(exp_data.data(0), expected_old)
self.assertTrue(np.allclose(new_data, expected_new))
self.assertEqual(history[0][0], "ToImag")
self.assertTrue(np.allclose(history[0][1], expected_new))
# Test to imaginary on more than one datum
new_data, error = processor(exp_data.data())
expected_new = np.array([
[[-11378.508, -16488.753], [-19283.206, -15339.630],
[-14548.009, -16743.348]],
[[-16630.257, -13752.518], [-16031.913, -15840.465],
[-14955.998, -14538.923]],
])
self.assertTrue(np.allclose(new_data, expected_new))
def test_qv_success(self):
"""
Test a successful run of quantum volume.
Compare the results to a pre-run experiment
"""
dir_name = os.path.dirname(os.path.abspath(__file__))
successful_json_file = "qv_data_moderate_noise_300_trials.json"
with open(os.path.join(dir_name, successful_json_file),
"r") as json_file:
successful_data = json.load(json_file, cls=ExperimentDecoder)
num_of_qubits = 4
backend = Aer.get_backend("aer_simulator")
qv_exp = QuantumVolume(range(num_of_qubits), seed=SEED)
exp_data = ExperimentData(experiment=qv_exp, backend=backend)
exp_data.add_data(successful_data)
qv_exp.analysis.run(exp_data)
results_json_file = "qv_result_moderate_noise_300_trials.json"
with open(os.path.join(dir_name, results_json_file), "r") as json_file:
successful_results = json.load(json_file, cls=ExperimentDecoder)
results = exp_data.analysis_results()
for result, reference in zip(results, successful_results):
if isinstance(result.value, UFloat):
# ufloat is distinguished by object id. so usually not identical to cache.
self.assertTupleEqual(
(result.value.n, result.value.s),
(reference["value"].n, reference["value"].s),
"result value is not the same as precalculated analysis",
)
else:
self.assertEqual(
result.value,
reference["value"],
"result value is not the same as precalculated analysis",
)
self.assertEqual(
result.name,
reference["name"],
"result name is not the same as precalculated analysis",
)
for key, value in reference["extra"].items():
if isinstance(value, float):
self.assertAlmostEqual(
result.extra[key],
value,
msg="result " + str(key) + " is not the same as the "
"pre-calculated analysis",
)
else:
self.assertTrue(
result.extra[key] == value,
"result " + str(key) + " is not the same as the "
"pre-calculated analysis",
)
class BaseDataProcessorTest(QiskitExperimentsTestCase):
"""Define some basic setup functionality for data processor tests."""
def setUp(self):
"""Define variables needed for most tests."""
super().setUp()
self.base_result_args = dict(
backend_name="test_backend",
backend_version="1.0.0",
qobj_id="id-123",
job_id="job-123",
success=True,
)
self.header = QobjExperimentHeader(
memory_slots=2,
metadata={"experiment_type": "fake_test_experiment"},
)
def create_experiment_data(self, iq_data: List[Any], single_shot: bool = False):
"""Populate avg_iq_data to use it for testing.
Args:
iq_data: A List of IQ data.
single_shot: Indicates if the data is single-shot or not.
"""
results = []
if not single_shot:
for circ_data in iq_data:
res = ExperimentResult(
success=True,
meas_level=1,
meas_return="avg",
data=ExperimentResultData(memory=circ_data),
header=self.header,
shots=1024,
)
results.append(res)
else:
for circ_data in iq_data:
res = ExperimentResult(
success=True,
meas_level=1,
meas_return="single",
data=ExperimentResultData(memory=circ_data),
header=self.header,
shots=1024,
)
results.append(res)
# pylint: disable=attribute-defined-outside-init
self.iq_experiment = ExperimentData(FakeExperiment())
self.iq_experiment.add_data(Result(results=results, **self.base_result_args))
def test_composite_avg_kerneled_memory_marginalization(self):
"""The the marginalization of level 1 averaged data."""
test_data = ExperimentData()
datum = {
"memory": [
[0.0, 0.1], # qubit 0
[1.0, 1.1], # qubit 1
[2.0, 2.1], # qubit 2
],
"metadata": {
"experiment_type":
"ParallelExperiment",
"composite_index": [0, 1, 2],
"composite_metadata": [
{
"experiment_type": "FineXAmplitude",
"qubits": [0]
},
{
"experiment_type": "FineXAmplitude",
"qubits": [1]
},
{
"experiment_type": "FineXAmplitude",
"qubits": [2]
},
],
"composite_qubits": [[0], [1], [2]],
"composite_clbits": [[0], [1], [2]],
},
"shots": 5,
"meas_level": 1,
}
test_data.add_data(datum)
all_sub_data = CompositeAnalysis([])._marginalized_component_data(
test_data.data())
for idx, sub_data in enumerate(all_sub_data):
expected = {
"metadata": {
"experiment_type": "FineXAmplitude",
"qubits": [idx]
},
"memory": [[idx + 0.0, idx + 0.1]],
}
self.assertEqual(expected, sub_data[0])
def test_bad_analysis(self):
"""Test the Rabi analysis."""
experiment_data = ExperimentData()
thetas = np.linspace(0.0, np.pi / 4, 31)
amplitudes = np.linspace(0.0, 0.95, 31)
experiment_data.add_data(
self.simulate_experiment_data(thetas, amplitudes, shots=200))
data_processor = DataProcessor("counts", [Probability(outcome="1")])
experiment_data = OscillationAnalysis().run(
experiment_data, data_processor=data_processor, plot=False)
result = experiment_data.analysis_results()
self.assertEqual(result[0].quality, "bad")
def test_good_analysis(self):
"""Test the Rabi analysis."""
experiment_data = ExperimentData()
thetas = np.linspace(-np.pi, np.pi, 31)
amplitudes = np.linspace(-0.25, 0.25, 31)
expected_rate, test_tol = 2.0, 0.2
experiment_data.add_data(
self.simulate_experiment_data(thetas, amplitudes, shots=400))
data_processor = DataProcessor("counts", [Probability(outcome="1")])
experiment_data = OscillationAnalysis().run(
experiment_data, data_processor=data_processor, plot=False)
result = experiment_data.analysis_results(0)
self.assertEqual(result.quality, "good")
self.assertAlmostEqual(result.value[1], expected_rate, delta=test_tol)
def create_data(xvals, d_theta, shots=1000, noise_seed=123):
"""Create experiment data for testing."""
np.random.seed(noise_seed)
noise = np.random.normal(0, 0.03, len(xvals))
yvals = 0.5 * np.cos(
(d_theta + np.pi) * xvals - np.pi / 2) + 0.5 + noise
results = []
for x, y in zip(xvals, yvals):
n1 = int(shots * y)
results.append({
"counts": {
"0": shots - n1,
"1": n1
},
"metadata": {
"xval": x
}
})
expdata = ExperimentData()
expdata.add_data(results)
return expdata
def test_qv_failure_insufficient_hop(self):
"""
Test that the quantum volume is unsuccessful when:
there are more than 100 trials, but the heavy output probability mean is less than 2/3
"""
dir_name = os.path.dirname(os.path.abspath(__file__))
insufficient_hop_json_file = "qv_data_high_noise.json"
with open(os.path.join(dir_name, insufficient_hop_json_file),
"r") as json_file:
insufficient_hop_data = json.load(json_file, cls=ExperimentDecoder)
num_of_qubits = 4
backend = Aer.get_backend("aer_simulator")
qv_exp = QuantumVolume(range(num_of_qubits), seed=SEED)
exp_data = ExperimentData(experiment=qv_exp, backend=backend)
exp_data.add_data(insufficient_hop_data)
qv_exp.analysis.run(exp_data)
qv_result = exp_data.analysis_results(1)
self.assertTrue(
qv_result.extra["success"] is False and qv_result.value == 1,
"quantum volume is successful with heavy output probability less than 2/3",
)
def test_t1_low_quality(self):
"""
A test where the fit's quality will be low
"""
data = ExperimentData()
for i in range(10):
data.add_data({
"counts": {
"0": 10,
"1": 10
},
"metadata": {
"xval": i,
"experiment_type": "T1",
"qubit": 0,
"unit": "ns",
"dt_factor_in_sec": None,
},
})
res = T1Analysis()._run_analysis(data)[0][0]
self.assertEqual(res.quality, "bad")
class TestAveragingAndSVD(BaseDataProcessorTest):
"""Test the averaging of single-shot IQ data followed by a SVD."""
def setUp(self):
"""Here, single-shots average to points at plus/minus 1.
The setting corresponds to four single-shots done on two qubits.
"""
super().setUp()
circ_es = ExperimentResultData(memory=[
[[1.1, 0.9], [-0.8, 1.0]],
[[1.2, 1.1], [-0.9, 1.0]],
[[0.8, 1.1], [-1.2, 1.0]],
[[0.9, 0.9], [-1.1, 1.0]],
])
self._sig_gs = np.array([1.0, -1.0]) / np.sqrt(2.0)
circ_gs = ExperimentResultData(memory=[
[[-1.1, -0.9], [0.8, -1.0]],
[[-1.2, -1.1], [0.9, -1.0]],
[[-0.8, -1.1], [1.2, -1.0]],
[[-0.9, -0.9], [1.1, -1.0]],
])
self._sig_es = np.array([-1.0, 1.0]) / np.sqrt(2.0)
circ_x90p = ExperimentResultData(memory=[
[[-1.0, -1.0], [1.0, -1.0]],
[[-1.0, -1.0], [1.0, -1.0]],
[[1.0, 1.0], [-1.0, 1.0]],
[[1.0, 1.0], [-1.0, 1.0]],
])
self._sig_x90 = np.array([0, 0])
circ_x45p = ExperimentResultData(memory=[
[[-1.0, -1.0], [1.0, -1.0]],
[[-1.0, -1.0], [1.0, -1.0]],
[[-1.0, -1.0], [1.0, -1.0]],
[[1.0, 1.0], [-1.0, 1.0]],
])
self._sig_x45 = np.array([0.5, -0.5]) / np.sqrt(2.0)
res_es = ExperimentResult(
shots=4,
success=True,
meas_level=1,
meas_return="single",
data=circ_es,
header=self.header,
)
res_gs = ExperimentResult(
shots=4,
success=True,
meas_level=1,
meas_return="single",
data=circ_gs,
header=self.header,
)
res_x90p = ExperimentResult(
shots=4,
success=True,
meas_level=1,
meas_return="single",
data=circ_x90p,
header=self.header,
)
res_x45p = ExperimentResult(
shots=4,
success=True,
meas_level=1,
meas_return="single",
data=circ_x45p,
header=self.header,
)
self.data = ExperimentData(FakeExperiment())
self.data.add_data(
Result(results=[res_es, res_gs, res_x90p, res_x45p],
**self.base_result_args))
def test_averaging(self):
"""Test that averaging of the datums produces the expected IQ points."""
processor = DataProcessor("memory", [AverageData(axis=1)])
# Test that we get the expected outcome for the excited state
processed = processor(self.data.data(0))
np.testing.assert_array_almost_equal(
unp.nominal_values(processed),
np.array([[1.0, 1.0], [-1.0, 1.0]]),
)
np.testing.assert_array_almost_equal(
unp.std_devs(processed),
np.array([[0.15811388300841894, 0.1], [0.15811388300841894, 0.0]])
/ 2.0,
)
# Test that we get the expected outcome for the ground state
processed = processor(self.data.data(1))
np.testing.assert_array_almost_equal(
unp.nominal_values(processed),
np.array([[-1.0, -1.0], [1.0, -1.0]]),
)
np.testing.assert_array_almost_equal(
unp.std_devs(processed),
np.array([[0.15811388300841894, 0.1], [0.15811388300841894, 0.0]])
/ 2.0,
)
def test_averaging_and_svd(self):
"""Test averaging followed by a SVD."""
processor = DataProcessor("memory", [AverageData(axis=1), SVD()])
# Test training using the calibration points
self.assertFalse(processor.is_trained)
processor.train([self.data.data(idx) for idx in [0, 1]])
self.assertTrue(processor.is_trained)
# Test the excited state
processed = processor(self.data.data(0))
np.testing.assert_array_almost_equal(
unp.nominal_values(processed),
self._sig_es,
)
# Test the ground state
processed = processor(self.data.data(1))
np.testing.assert_array_almost_equal(
unp.nominal_values(processed),
self._sig_gs,
)
# Test the x90p rotation
processed = processor(self.data.data(2))
np.testing.assert_array_almost_equal(
unp.nominal_values(processed),
self._sig_x90,
)
np.testing.assert_array_almost_equal(
unp.std_devs(processed),
np.array([0.25, 0.25]),
)
# Test the x45p rotation
processed = processor(self.data.data(3))
np.testing.assert_array_almost_equal(
unp.nominal_values(processed),
self._sig_x45,
)
np.testing.assert_array_almost_equal(
unp.std_devs(processed),
np.array([np.std([1, 1, 1, -1]) / np.sqrt(4.0) / 2] * 2),
)
def test_process_all_data(self):
"""Test that we can process all data at once."""
processor = DataProcessor("memory", [AverageData(axis=1), SVD()])
# Test training using the calibration points
self.assertFalse(processor.is_trained)
processor.train([self.data.data(idx) for idx in [0, 1]])
self.assertTrue(processor.is_trained)
all_expected = np.vstack((
self._sig_es.reshape(1, 2),
self._sig_gs.reshape(1, 2),
self._sig_x90.reshape(1, 2),
self._sig_x45.reshape(1, 2),
))
# Test processing of all data
processed = processor(self.data.data())
np.testing.assert_array_almost_equal(
unp.nominal_values(processed),
all_expected,
)
# Test processing of each datum individually
for idx, expected in enumerate(
[self._sig_es, self._sig_gs, self._sig_x90, self._sig_x45]):
processed = processor(self.data.data(idx))
np.testing.assert_array_almost_equal(
unp.nominal_values(processed),
expected,
)
def test_normalize(self):
"""Test that by adding a normalization node we get a signal between 1 and 1."""
processor = DataProcessor(
"memory", [AverageData(axis=1),
SVD(), MinMaxNormalize()])
self.assertFalse(processor.is_trained)
processor.train([self.data.data(idx) for idx in [0, 1]])
self.assertTrue(processor.is_trained)
# Test processing of all data
processed = processor(self.data.data())
np.testing.assert_array_almost_equal(
unp.nominal_values(processed),
np.array([[0.0, 1.0], [1.0, 0.0], [0.5, 0.5], [0.75, 0.25]]),
)
def test_distorted_iq_data(self):
"""Test if uncertainty can consider correlation.
SVD projects IQ data onto I-axis, and input different data sets that
have the same mean and same variance but squeezed along different axis.
"""
svd_node = SVD()
svd_node._scales = [1.0]
svd_node._main_axes = [np.array([1, 0])]
svd_node._means = [(0.0, 0.0)]
processor = DataProcessor("memory", [AverageData(axis=1), svd_node])
dist_i_axis = {
"memory": [[[-1, 0]], [[-0.5, 0]], [[0.0, 0]], [[0.5, 0]], [[1,
0]]]
}
dist_q_axis = {
"memory": [[[0, -1]], [[0, -0.5]], [[0, 0.0]], [[0, 0.5]], [[0,
1]]]
}
out_i = processor(dist_i_axis)
self.assertAlmostEqual(out_i[0].nominal_value, 0.0)
self.assertAlmostEqual(out_i[0].std_dev, 0.31622776601683794)
out_q = processor(dist_q_axis)
self.assertAlmostEqual(out_q[0].nominal_value, 0.0)
self.assertAlmostEqual(out_q[0].std_dev, 0.0)
def test_get_subset(self):
"""Test that get subset data from full data array."""
# data to analyze
fake_data = [
{
"data": 1,
"metadata": {
"xval": 1,
"type": 1,
"valid": True
}
},
{
"data": 2,
"metadata": {
"xval": 2,
"type": 2,
"valid": True
}
},
{
"data": 3,
"metadata": {
"xval": 3,
"type": 1,
"valid": True
}
},
{
"data": 4,
"metadata": {
"xval": 4,
"type": 3,
"valid": True
}
},
{
"data": 5,
"metadata": {
"xval": 5,
"type": 3,
"valid": True
}
},
{
"data": 6,
"metadata": {
"xval": 6,
"type": 4,
"valid": True
}
}, # this if fake
]
expdata = ExperimentData(experiment=FakeExperiment())
for datum in fake_data:
expdata.add_data(datum)
def _processor(datum):
return datum["data"], datum["data"] * 2
self.analysis.set_options(x_key="xval")
self.analysis._extract_curves(expdata, data_processor=_processor)
filt_data = self.analysis._data(series_name="curve1")
np.testing.assert_array_equal(filt_data.x,
np.asarray([1, 3], dtype=float))
np.testing.assert_array_equal(filt_data.y,
np.asarray([1, 3], dtype=float))
np.testing.assert_array_equal(filt_data.y_err,
np.asarray([2, 6], dtype=float))
filt_data = self.analysis._data(series_name="curve2")
np.testing.assert_array_equal(filt_data.x, np.asarray([2],
dtype=float))
np.testing.assert_array_equal(filt_data.y, np.asarray([2],
dtype=float))
np.testing.assert_array_equal(filt_data.y_err,
np.asarray([4], dtype=float))
filt_data = self.analysis._data(series_name="curve3")
np.testing.assert_array_equal(filt_data.x,
np.asarray([4, 5], dtype=float))
np.testing.assert_array_equal(filt_data.y,
np.asarray([4, 5], dtype=float))
np.testing.assert_array_equal(filt_data.y_err,
np.asarray([8, 10], dtype=float))
class TestAveragingAndSVD(BaseDataProcessorTest):
"""Test the averaging of single-shot IQ data followed by a SVD."""
def setUp(self):
"""Here, single-shots average to points at plus/minus 1.
The setting corresponds to four single-shots done on two qubits.
"""
super().setUp()
circ_es = ExperimentResultData(memory=[
[[1.1, 0.9], [-0.8, 1.0]],
[[1.2, 1.1], [-0.9, 1.0]],
[[0.8, 1.1], [-1.2, 1.0]],
[[0.9, 0.9], [-1.1, 1.0]],
])
self._sig_gs = np.array([[1.0], [-1.0]]) / np.sqrt(2.0)
circ_gs = ExperimentResultData(memory=[
[[-1.1, -0.9], [0.8, -1.0]],
[[-1.2, -1.1], [0.9, -1.0]],
[[-0.8, -1.1], [1.2, -1.0]],
[[-0.9, -0.9], [1.1, -1.0]],
])
self._sig_es = np.array([[-1.0], [1.0]]) / np.sqrt(2.0)
circ_x90p = ExperimentResultData(memory=[
[[-1.0, -1.0], [1.0, -1.0]],
[[-1.0, -1.0], [1.0, -1.0]],
[[1.0, 1.0], [-1.0, 1.0]],
[[1.0, 1.0], [-1.0, 1.0]],
])
self._sig_x90 = np.array([[0], [0]])
circ_x45p = ExperimentResultData(memory=[
[[-1.0, -1.0], [1.0, -1.0]],
[[-1.0, -1.0], [1.0, -1.0]],
[[-1.0, -1.0], [1.0, -1.0]],
[[1.0, 1.0], [-1.0, 1.0]],
])
self._sig_x45 = np.array([[0.5], [-0.5]]) / np.sqrt(2.0)
res_es = ExperimentResult(
shots=4,
success=True,
meas_level=1,
meas_return="single",
data=circ_es,
header=self.header,
)
res_gs = ExperimentResult(
shots=4,
success=True,
meas_level=1,
meas_return="single",
data=circ_gs,
header=self.header,
)
res_x90p = ExperimentResult(
shots=4,
success=True,
meas_level=1,
meas_return="single",
data=circ_x90p,
header=self.header,
)
res_x45p = ExperimentResult(
shots=4,
success=True,
meas_level=1,
meas_return="single",
data=circ_x45p,
header=self.header,
)
self.data = ExperimentData(FakeExperiment())
self.data.add_data(
Result(results=[res_es, res_gs, res_x90p, res_x45p],
**self.base_result_args))
def test_averaging(self):
"""Test that averaging of the datums produces the expected IQ points."""
processor = DataProcessor("memory", [AverageData(axis=1)])
# Test that we get the expected outcome for the excited state
processed, error = processor(self.data.data(0))
expected_avg = np.array([[1.0, 1.0], [-1.0, 1.0]])
expected_std = np.array([[0.15811388300841894, 0.1],
[0.15811388300841894, 0.0]]) / 2.0
self.assertTrue(np.allclose(processed, expected_avg))
self.assertTrue(np.allclose(error, expected_std))
# Test that we get the expected outcome for the ground state
processed, error = processor(self.data.data(1))
expected_avg = np.array([[-1.0, -1.0], [1.0, -1.0]])
expected_std = np.array([[0.15811388300841894, 0.1],
[0.15811388300841894, 0.0]]) / 2.0
self.assertTrue(np.allclose(processed, expected_avg))
self.assertTrue(np.allclose(error, expected_std))
def test_averaging_and_svd(self):
"""Test averaging followed by a SVD."""
processor = DataProcessor("memory", [AverageData(axis=1), SVD()])
# Test training using the calibration points
self.assertFalse(processor.is_trained)
processor.train([self.data.data(idx) for idx in [0, 1]])
self.assertTrue(processor.is_trained)
# Test the excited state
processed, error = processor(self.data.data(0))
self.assertTrue(np.allclose(processed, self._sig_es))
# Test the ground state
processed, error = processor(self.data.data(1))
self.assertTrue(np.allclose(processed, self._sig_gs))
# Test the x90p rotation
processed, error = processor(self.data.data(2))
self.assertTrue(np.allclose(processed, self._sig_x90))
self.assertTrue(np.allclose(error, np.array([0.25, 0.25])))
# Test the x45p rotation
processed, error = processor(self.data.data(3))
expected_std = np.array([np.std([1, 1, 1, -1]) / np.sqrt(4.0) / 2] * 2)
self.assertTrue(np.allclose(processed, self._sig_x45))
self.assertTrue(np.allclose(error, expected_std))
def test_process_all_data(self):
"""Test that we can process all data at once."""
processor = DataProcessor("memory", [AverageData(axis=1), SVD()])
# Test training using the calibration points
self.assertFalse(processor.is_trained)
processor.train([self.data.data(idx) for idx in [0, 1]])
self.assertTrue(processor.is_trained)
all_expected = np.vstack((
self._sig_es.reshape(1, 2),
self._sig_gs.reshape(1, 2),
self._sig_x90.reshape(1, 2),
self._sig_x45.reshape(1, 2),
)).T
# Test processing of all data
processed = processor(self.data.data())[0]
self.assertTrue(np.allclose(processed, all_expected))
# Test processing of each datum individually
for idx, expected in enumerate(
[self._sig_es, self._sig_gs, self._sig_x90, self._sig_x45]):
processed = processor(self.data.data(idx))[0]
self.assertTrue(np.allclose(processed, expected))
def test_normalize(self):
"""Test that by adding a normalization node we get a signal between 1 and 1."""
processor = DataProcessor(
"memory", [AverageData(axis=1),
SVD(), MinMaxNormalize()])
self.assertFalse(processor.is_trained)
processor.train([self.data.data(idx) for idx in [0, 1]])
self.assertTrue(processor.is_trained)
all_expected = np.array([[0.0, 1.0, 0.5, 0.75], [1.0, 0.0, 0.5, 0.25]])
# Test processing of all data
processed = processor(self.data.data())[0]
self.assertTrue(np.allclose(processed, all_expected))
class DataProcessorTest(BaseDataProcessorTest):
"""Class to test DataProcessor."""
def setUp(self):
"""Setup variables used for testing."""
super().setUp()
mem1 = ExperimentResultData(memory=[
[[1103260.0, -11378508.0], [2959012.0, -16488753.0]],
[[442170.0, -19283206.0], [-5279410.0, -15339630.0]],
[[3016514.0, -14548009.0], [-3404756.0, -16743348.0]],
])
mem2 = ExperimentResultData(memory=[
[[5131962.0, -16630257.0], [4438870.0, -13752518.0]],
[[3415985.0, -16031913.0], [2942458.0, -15840465.0]],
[[5199964.0, -14955998.0], [4030843.0, -14538923.0]],
])
res1 = ExperimentResult(shots=3,
success=True,
meas_level=1,
data=mem1,
header=self.header)
res2 = ExperimentResult(shots=3,
success=True,
meas_level=1,
data=mem2,
header=self.header)
self.result_lvl1 = Result(results=[res1, res2],
**self.base_result_args)
raw_counts1 = {"0x0": 4, "0x2": 6}
raw_counts2 = {"0x0": 2, "0x2": 8}
data1 = ExperimentResultData(counts=dict(**raw_counts1))
data2 = ExperimentResultData(counts=dict(**raw_counts2))
res1 = ExperimentResult(shots=9,
success=True,
meas_level=2,
data=data1,
header=self.header)
res2 = ExperimentResult(shots=9,
success=True,
meas_level=2,
data=data2,
header=self.header)
self.exp_data_lvl2 = ExperimentData(FakeExperiment())
self.exp_data_lvl2.add_data(
Result(results=[res1, res2], **self.base_result_args))
def test_empty_processor(self):
"""Check that a DataProcessor without steps does nothing."""
data_processor = DataProcessor("counts")
datum, error = data_processor(self.exp_data_lvl2.data(0))
self.assertEqual(datum, [{"00": 4, "10": 6}])
self.assertIsNone(error)
datum, error, history = data_processor.call_with_history(
self.exp_data_lvl2.data(0))
self.assertEqual(datum, [{"00": 4, "10": 6}])
self.assertEqual(history, [])
def test_to_real(self):
"""Test scaling and conversion to real part."""
processor = DataProcessor("memory", [ToReal(scale=1e-3)])
exp_data = ExperimentData(FakeExperiment())
exp_data.add_data(self.result_lvl1)
# Test to real on a single datum
new_data, error = processor(exp_data.data(0))
expected_old = {
"memory": [
[[1103260.0, -11378508.0], [2959012.0, -16488753.0]],
[[442170.0, -19283206.0], [-5279410.0, -15339630.0]],
[[3016514.0, -14548009.0], [-3404756.0, -16743348.0]],
],
"metadata": {
"experiment_type": "fake_test_experiment"
},
"job_id":
"job-123",
"meas_level":
1,
"shots":
3,
}
expected_new = np.array([[1103.26, 2959.012], [442.17, -5279.41],
[3016.514, -3404.7560]])
self.assertEqual(exp_data.data(0), expected_old)
self.assertTrue(np.allclose(new_data, expected_new))
self.assertIsNone(error)
# Test that we can call with history.
new_data, error, history = processor.call_with_history(
exp_data.data(0))
self.assertEqual(exp_data.data(0), expected_old)
self.assertTrue(np.allclose(new_data, expected_new))
self.assertEqual(history[0][0], "ToReal")
self.assertTrue(np.allclose(history[0][1], expected_new))
# Test to real on more than one datum
new_data, error = processor(exp_data.data())
expected_new = np.array([
[[1103.26, 2959.012], [442.17, -5279.41], [3016.514, -3404.7560]],
[[5131.962, 4438.87], [3415.985, 2942.458], [5199.964, 4030.843]],
])
self.assertTrue(np.allclose(new_data, expected_new))
def test_to_imag(self):
"""Test that we can average the data."""
processor = DataProcessor("memory")
processor.append(ToImag(scale=1e-3))
exp_data = ExperimentData(FakeExperiment())
exp_data.add_data(self.result_lvl1)
new_data, error = processor(exp_data.data(0))
expected_old = {
"memory": [
[[1103260.0, -11378508.0], [2959012.0, -16488753.0]],
[[442170.0, -19283206.0], [-5279410.0, -15339630.0]],
[[3016514.0, -14548009.0], [-3404756.0, -16743348.0]],
],
"metadata": {
"experiment_type": "fake_test_experiment"
},
"job_id":
"job-123",
"meas_level":
1,
"shots":
3,
}
expected_new = np.array([
[-11378.508, -16488.753],
[-19283.206000000002, -15339.630000000001],
[-14548.009, -16743.348],
])
self.assertEqual(exp_data.data(0), expected_old)
self.assertTrue(np.allclose(new_data, expected_new))
self.assertIsNone(error)
# Test that we can call with history.
new_data, error, history = processor.call_with_history(
exp_data.data(0))
self.assertEqual(exp_data.data(0), expected_old)
self.assertTrue(np.allclose(new_data, expected_new))
self.assertEqual(history[0][0], "ToImag")
self.assertTrue(np.allclose(history[0][1], expected_new))
# Test to imaginary on more than one datum
new_data, error = processor(exp_data.data())
expected_new = np.array([
[[-11378.508, -16488.753], [-19283.206, -15339.630],
[-14548.009, -16743.348]],
[[-16630.257, -13752.518], [-16031.913, -15840.465],
[-14955.998, -14538.923]],
])
self.assertTrue(np.allclose(new_data, expected_new))
def test_populations(self):
"""Test that counts are properly converted to a population."""
processor = DataProcessor("counts")
processor.append(Probability("00"))
# Test on a single datum.
new_data, error = processor(self.exp_data_lvl2.data(0))
self.assertEqual(new_data, 0.4)
self.assertEqual(error, np.sqrt(0.4 * (1 - 0.4) / 10))
# Test on all the data
new_data, error = processor(self.exp_data_lvl2.data())
self.assertTrue(np.allclose(new_data, np.array([0.4, 0.2])))
def test_validation(self):
"""Test the validation mechanism."""
for validate, error in [(False, AttributeError),
(True, DataProcessorError)]:
processor = DataProcessor("counts")
processor.append(Probability("00", validate=validate))
with self.assertRaises(error):
processor({"counts": [0, 1, 2]})
class DataProcessorTest(BaseDataProcessorTest):
"""Class to test DataProcessor."""
def setUp(self):
"""Setup variables used for testing."""
super().setUp()
mem1 = ExperimentResultData(memory=[
[[1103260.0, -11378508.0], [2959012.0, -16488753.0]],
[[442170.0, -19283206.0], [-5279410.0, -15339630.0]],
[[3016514.0, -14548009.0], [-3404756.0, -16743348.0]],
])
mem2 = ExperimentResultData(memory=[
[[5131962.0, -16630257.0], [4438870.0, -13752518.0]],
[[3415985.0, -16031913.0], [2942458.0, -15840465.0]],
[[5199964.0, -14955998.0], [4030843.0, -14538923.0]],
])
res1 = ExperimentResult(shots=3,
success=True,
meas_level=1,
data=mem1,
header=self.header)
res2 = ExperimentResult(shots=3,
success=True,
meas_level=1,
data=mem2,
header=self.header)
self.result_lvl1 = Result(results=[res1, res2],
**self.base_result_args)
raw_counts1 = {"0x0": 4, "0x2": 6}
raw_counts2 = {"0x0": 2, "0x2": 8}
data1 = ExperimentResultData(counts=dict(**raw_counts1))
data2 = ExperimentResultData(counts=dict(**raw_counts2))
res1 = ExperimentResult(shots=10,
success=True,
meas_level=2,
data=data1,
header=self.header)
res2 = ExperimentResult(shots=10,
success=True,
meas_level=2,
data=data2,
header=self.header)
self.exp_data_lvl2 = ExperimentData(FakeExperiment())
self.exp_data_lvl2.add_data(
Result(results=[res1, res2], **self.base_result_args))
def test_data_prep_level1_memory_single(self):
"""Format meas_level=1 meas_return=single."""
# slots = 3, shots = 2, circuits = 2
data_raw = [
{
"memory": [
[[0.1, 0.2], [0.3, 0.4], [0.5, 0.6]],
[[0.1, 0.2], [0.3, 0.4], [0.5, 0.6]],
],
},
{
"memory": [
[[0.7, 0.8], [0.9, 1.0], [1.1, 1.2]],
[[0.7, 0.8], [0.9, 1.0], [1.1, 1.2]],
],
},
]
formatted_data = DataProcessor("memory", [])._data_extraction(data_raw)
ref_data = np.array([
[
[
[ufloat(0.1, np.nan),
ufloat(0.2, np.nan)],
[ufloat(0.3, np.nan),
ufloat(0.4, np.nan)],
[ufloat(0.5, np.nan),
ufloat(0.6, np.nan)],
],
[
[ufloat(0.1, np.nan),
ufloat(0.2, np.nan)],
[ufloat(0.3, np.nan),
ufloat(0.4, np.nan)],
[ufloat(0.5, np.nan),
ufloat(0.6, np.nan)],
],
],
[
[
[ufloat(0.7, np.nan),
ufloat(0.8, np.nan)],
[ufloat(0.9, np.nan),
ufloat(1.0, np.nan)],
[ufloat(1.1, np.nan),
ufloat(1.2, np.nan)],
],
[
[ufloat(0.7, np.nan),
ufloat(0.8, np.nan)],
[ufloat(0.9, np.nan),
ufloat(1.0, np.nan)],
[ufloat(1.1, np.nan),
ufloat(1.2, np.nan)],
],
],
])
self.assertTupleEqual(formatted_data.shape, ref_data.shape)
np.testing.assert_array_equal(unp.nominal_values(formatted_data),
unp.nominal_values(ref_data))
# note that np.nan cannot be evaluated by "=="
self.assertTrue(np.isnan(unp.std_devs(formatted_data)).all())
def test_data_prep_level1_memory_average(self):
"""Format meas_level=1 meas_return=avg."""
# slots = 3, circuits = 2
data_raw = [
{
"memory": [[0.1, 0.2], [0.3, 0.4], [0.5, 0.6]],
},
{
"memory": [[0.7, 0.8], [0.9, 1.0], [1.1, 1.2]],
},
]
formatted_data = DataProcessor("memory", [])._data_extraction(data_raw)
ref_data = np.array([
[
[ufloat(0.1, np.nan), ufloat(0.2, np.nan)],
[ufloat(0.3, np.nan), ufloat(0.4, np.nan)],
[ufloat(0.5, np.nan), ufloat(0.6, np.nan)],
],
[
[ufloat(0.7, np.nan), ufloat(0.8, np.nan)],
[ufloat(0.9, np.nan), ufloat(1.0, np.nan)],
[ufloat(1.1, np.nan), ufloat(1.2, np.nan)],
],
])
self.assertTupleEqual(formatted_data.shape, ref_data.shape)
np.testing.assert_array_equal(unp.nominal_values(formatted_data),
unp.nominal_values(ref_data))
# note that np.nan cannot be evaluated by "=="
self.assertTrue(np.isnan(unp.std_devs(formatted_data)).all())
def test_data_prep_level2_counts(self):
"""Format meas_level=2."""
# slots = 2, shots=10, circuits = 2
data_raw = [
{
"counts": {
"00": 2,
"01": 3,
"10": 1,
"11": 4
},
},
{
"counts": {
"00": 3,
"01": 3,
"10": 2,
"11": 2
},
},
]
formatted_data = DataProcessor("counts", [])._data_extraction(data_raw)
ref_data = np.array(
[
{
"00": 2,
"01": 3,
"10": 1,
"11": 4
},
{
"00": 3,
"01": 3,
"10": 2,
"11": 2
},
],
dtype=object,
)
np.testing.assert_array_equal(formatted_data, ref_data)
def test_data_prep_level2_counts_memory(self):
"""Format meas_level=2 with having memory set."""
# slots = 2, shots=10, circuits = 2
data_raw = [
{
"counts": {
"00": 2,
"01": 3,
"10": 1,
"11": 4
},
"memory":
["00", "01", "01", "10", "11", "11", "00", "01", "11", "11"],
},
{
"counts": {
"00": 3,
"01": 3,
"10": 2,
"11": 2
},
"memory":
["00", "00", "01", "00", "10", "01", "01", "11", "10", "11"],
},
]
formatted_data = DataProcessor("memory", [])._data_extraction(data_raw)
ref_data = np.array(
[
["00", "01", "01", "10", "11", "11", "00", "01", "11", "11"],
["00", "00", "01", "00", "10", "01", "01", "11", "10", "11"],
],
dtype=object,
)
np.testing.assert_array_equal(formatted_data, ref_data)
def test_empty_processor(self):
"""Check that a DataProcessor without steps does nothing."""
data_processor = DataProcessor("counts")
datum = data_processor(self.exp_data_lvl2.data(0))
self.assertEqual(datum, {"00": 4, "10": 6})
datum, history = data_processor.call_with_history(
self.exp_data_lvl2.data(0))
self.assertEqual(datum, {"00": 4, "10": 6})
self.assertEqual(history, [])
def test_to_real(self):
"""Test scaling and conversion to real part."""
processor = DataProcessor("memory", [ToReal(scale=1e-3)])
exp_data = ExperimentData(FakeExperiment())
exp_data.add_data(self.result_lvl1)
# Test to real on a single datum
new_data = processor(exp_data.data(0))
expected_old = {
"memory": [
[[1103260.0, -11378508.0], [2959012.0, -16488753.0]],
[[442170.0, -19283206.0], [-5279410.0, -15339630.0]],
[[3016514.0, -14548009.0], [-3404756.0, -16743348.0]],
],
"metadata": {
"experiment_type": "fake_test_experiment"
},
"job_id":
"job-123",
"meas_level":
1,
"shots":
3,
}
expected_new = np.array([[1103.26, 2959.012], [442.17, -5279.41],
[3016.514, -3404.7560]])
self.assertEqual(exp_data.data(0), expected_old)
np.testing.assert_array_almost_equal(
unp.nominal_values(new_data),
expected_new,
)
self.assertTrue(np.isnan(unp.std_devs(new_data)).all())
# Test that we can call with history.
new_data, history = processor.call_with_history(exp_data.data(0))
self.assertEqual(exp_data.data(0), expected_old)
np.testing.assert_array_almost_equal(
unp.nominal_values(new_data),
expected_new,
)
self.assertEqual(history[0][0], "ToReal")
np.testing.assert_array_almost_equal(
unp.nominal_values(history[0][1]),
expected_new,
)
# Test to real on more than one datum
new_data = processor(exp_data.data())
expected_new = np.array([
[[1103.26, 2959.012], [442.17, -5279.41], [3016.514, -3404.7560]],
[[5131.962, 4438.87], [3415.985, 2942.458], [5199.964, 4030.843]],
])
np.testing.assert_array_almost_equal(
unp.nominal_values(new_data),
expected_new,
)
def test_to_imag(self):
"""Test that we can average the data."""
processor = DataProcessor("memory")
processor.append(ToImag(scale=1e-3))
exp_data = ExperimentData(FakeExperiment())
exp_data.add_data(self.result_lvl1)
new_data = processor(exp_data.data(0))
expected_old = {
"memory": [
[[1103260.0, -11378508.0], [2959012.0, -16488753.0]],
[[442170.0, -19283206.0], [-5279410.0, -15339630.0]],
[[3016514.0, -14548009.0], [-3404756.0, -16743348.0]],
],
"metadata": {
"experiment_type": "fake_test_experiment"
},
"job_id":
"job-123",
"meas_level":
1,
"shots":
3,
}
expected_new = np.array([
[-11378.508, -16488.753],
[-19283.206000000002, -15339.630000000001],
[-14548.009, -16743.348],
])
self.assertEqual(exp_data.data(0), expected_old)
np.testing.assert_array_almost_equal(
unp.nominal_values(new_data),
expected_new,
)
self.assertTrue(np.isnan(unp.std_devs(new_data)).all())
# Test that we can call with history.
new_data, history = processor.call_with_history(exp_data.data(0))
self.assertEqual(exp_data.data(0), expected_old)
np.testing.assert_array_almost_equal(
unp.nominal_values(new_data),
expected_new,
)
self.assertEqual(history[0][0], "ToImag")
np.testing.assert_array_almost_equal(
unp.nominal_values(history[0][1]),
expected_new,
)
# Test to imaginary on more than one datum
new_data = processor(exp_data.data())
expected_new = np.array([
[[-11378.508, -16488.753], [-19283.206, -15339.630],
[-14548.009, -16743.348]],
[[-16630.257, -13752.518], [-16031.913, -15840.465],
[-14955.998, -14538.923]],
])
np.testing.assert_array_almost_equal(
unp.nominal_values(new_data),
expected_new,
)
def test_populations(self):
"""Test that counts are properly converted to a population."""
processor = DataProcessor("counts")
processor.append(Probability("00", alpha_prior=1.0))
# Test on a single datum.
new_data = processor(self.exp_data_lvl2.data(0))
self.assertAlmostEqual(float(unp.nominal_values(new_data)), 0.41666667)
self.assertAlmostEqual(float(unp.std_devs(new_data)),
0.13673544235706114)
# Test on all the data
new_data = processor(self.exp_data_lvl2.data())
np.testing.assert_array_almost_equal(
unp.nominal_values(new_data),
np.array([0.41666667, 0.25]),
)
def test_validation(self):
"""Test the validation mechanism."""
for validate, error in [(False, AttributeError),
(True, DataProcessorError)]:
processor = DataProcessor("counts")
processor.append(Probability("00", validate=validate))
with self.assertRaises(error):
processor({"counts": [0, 1, 2]})
class TestIQSingleAvg(BaseDataProcessorTest):
"""Test the IQ data processing nodes single and average."""
def setUp(self):
"""Setup some IQ data."""
super().setUp()
mem_avg = ExperimentResultData(
memory=[[-539698.0, -153030784.0], [5541283.0, -160369600.0]])
mem_single = ExperimentResultData(memory=[
[[-56470872.0, -136691568.0], [-53407256.0, -176278624.0]],
[[-34623272.0, -151247824.0], [-36650644.0, -170559312.0]],
[[42658720.0, -153054640.0], [29689970.0, -174671824.0]],
[[-47387248.0, -177826640.0], [-62149124.0, -165909728.0]],
[[-51465408.0, -148338000.0], [23157112.0, -165826736.0]],
[[51426688.0, -142703104.0], [34330920.0, -185572592.0]],
])
res_single = ExperimentResult(
shots=3,
success=True,
meas_level=1,
meas_return="single",
data=mem_single,
header=self.header,
)
res_avg = ExperimentResult(shots=6,
success=True,
meas_level=1,
meas_return="avg",
data=mem_avg,
header=self.header)
# result_single = Result(results=[res_single], **self.base_result_args)
# result_avg = Result(results=[res_avg], **self.base_result_args)
self.exp_data_single = ExperimentData(FakeExperiment())
self.exp_data_single.add_data(
Result(results=[res_single], **self.base_result_args))
self.exp_data_avg = ExperimentData(FakeExperiment())
self.exp_data_avg.add_data(
Result(results=[res_avg], **self.base_result_args))
def test_avg_and_single(self):
"""Test that the different nodes process the data correctly."""
to_real = DataProcessor("memory", [ToReal(scale=1)])
to_imag = DataProcessor("memory", [ToImag(scale=1)])
# Test the real single shot node
new_data = to_real(self.exp_data_single.data(0))
expected = np.array([
[-56470872.0, -53407256.0],
[-34623272.0, -36650644.0],
[42658720.0, 29689970.0],
[-47387248.0, -62149124.0],
[-51465408.0, 23157112.0],
[51426688.0, 34330920.0],
])
np.testing.assert_array_almost_equal(
unp.nominal_values(new_data),
expected,
)
self.assertTrue(np.isnan(unp.std_devs(new_data)).all())
# Test the imaginary single shot node
new_data = to_imag(self.exp_data_single.data(0))
expected = np.array([
[-136691568.0, -176278624.0],
[-151247824.0, -170559312.0],
[-153054640.0, -174671824.0],
[-177826640.0, -165909728.0],
[-148338000.0, -165826736.0],
[-142703104.0, -185572592.0],
])
np.testing.assert_array_almost_equal(
unp.nominal_values(new_data),
expected,
)
# Test the real average node
new_data = to_real(self.exp_data_avg.data(0))
np.testing.assert_array_almost_equal(
unp.nominal_values(new_data),
np.array([-539698.0, 5541283.0]),
)
# Test the imaginary average node
new_data = to_imag(self.exp_data_avg.data(0))
np.testing.assert_array_almost_equal(
unp.nominal_values(new_data),
np.array([-153030784.0, -160369600.0]),
)
def test_composite_count_memory_marginalization(self, memory):
"""Test the marginalization of level two memory."""
test_data = ExperimentData()
# Simplified experimental data
datum = {
"counts": {
"0 0": 4,
"0 1": 1,
"1 0": 2,
"1 1": 3
},
"memory": memory,
"metadata": {
"experiment_type":
"ParallelExperiment",
"composite_index": [0, 1],
"composite_metadata": [
{
"experiment_type": "FineXAmplitude",
"qubits": [0]
},
{
"experiment_type": "FineXAmplitude",
"qubits": [1]
},
],
"composite_qubits": [[0], [1]],
"composite_clbits": [[0], [1]],
},
"shots": 10,
"meas_level": 2,
}
test_data.add_data(datum)
sub_data = CompositeAnalysis([])._marginalized_component_data(
test_data.data())
expected = [
[{
"metadata": {
"experiment_type": "FineXAmplitude",
"qubits": [0]
},
"counts": {
"0": 6,
"1": 4
},
"memory": ["0", "0", "1", "0", "0", "1", "1", "0", "0", "1"],
}],
[{
"metadata": {
"experiment_type": "FineXAmplitude",
"qubits": [1]
},
"counts": {
"0": 5,
"1": 5
},
"memory": ["0", "1", "1", "0", "0", "0", "1", "0", "1", "1"],
}],
]
self.assertListEqual(sub_data, expected)
class TestAvgDataAndSVD(BaseDataProcessorTest):
"""Test the SVD and normalization on averaged IQ data."""
def setUp(self):
"""Here, single-shots average to points at plus/minus 1.
The setting corresponds to four single-shots done on two qubits.
"""
super().setUp()
circ_es = ExperimentResultData(memory=[[1.0, 1.0], [-1.0, 1.0]])
self._sig_gs = np.array([1.0, -1.0]) / np.sqrt(2.0)
circ_gs = ExperimentResultData(memory=[[-1.0, -1.0], [1.0, -1.0]])
self._sig_es = np.array([-1.0, 1.0]) / np.sqrt(2.0)
circ_x90p = ExperimentResultData(memory=[[0.0, 0.0], [0.0, 0.0]])
self._sig_x90 = np.array([0, 0])
circ_x45p = ExperimentResultData(memory=[[-0.5, -0.5], [0.5, -0.5]])
self._sig_x45 = np.array([0.5, -0.5]) / np.sqrt(2.0)
res_es = ExperimentResult(
shots=4,
success=True,
meas_level=1,
meas_return="avg",
data=circ_es,
header=self.header,
)
res_gs = ExperimentResult(
shots=4,
success=True,
meas_level=1,
meas_return="avg",
data=circ_gs,
header=self.header,
)
res_x90p = ExperimentResult(
shots=4,
success=True,
meas_level=1,
meas_return="avg",
data=circ_x90p,
header=self.header,
)
res_x45p = ExperimentResult(
shots=4,
success=True,
meas_level=1,
meas_return="avg",
data=circ_x45p,
header=self.header,
)
self.data = ExperimentData(FakeExperiment())
self.data.add_data(
Result(results=[res_es, res_gs, res_x90p, res_x45p],
**self.base_result_args))
def test_normalize(self):
"""Test that by adding a normalization node we get a signal between 1 and 1."""
processor = DataProcessor("memory", [SVD(), MinMaxNormalize()])
self.assertFalse(processor.is_trained)
processor.train([self.data.data(idx) for idx in [0, 1]])
self.assertTrue(processor.is_trained)
# Test processing of all data
processed = processor(self.data.data())
np.testing.assert_array_almost_equal(
unp.nominal_values(processed),
np.array([[0.0, 1.0], [1.0, 0.0], [0.5, 0.5], [0.75, 0.25]]),
)
def test_correlated_analysis(self):
"""Tests correlated mitigator generation from experimental data"""
qubits = [0, 2, 3]
run_data = [
{
"counts": {
"000": 989,
"010": 12,
"100": 7,
"001": 15,
"101": 1
},
"metadata": {
"state_label": "000"
},
"shots": 1024,
},
{
"counts": {
"001": 971,
"101": 15,
"000": 36,
"011": 2
},
"metadata": {
"state_label": "001"
},
"shots": 1024,
},
{
"counts": {
"000": 30,
"010": 965,
"110": 15,
"011": 11,
"001": 2,
"100": 1
},
"metadata": {
"state_label": "010"
},
"shots": 1024,
},
{
"counts": {
"011": 955,
"111": 15,
"010": 26,
"001": 27,
"110": 1
},
"metadata": {
"state_label": "011"
},
"shots": 1024,
},
{
"counts": {
"100": 983,
"101": 8,
"110": 13,
"000": 20
},
"metadata": {
"state_label": "100"
},
"shots": 1024,
},
{
"counts": {
"101": 947,
"001": 34,
"100": 32,
"111": 11
},
"metadata": {
"state_label": "101"
},
"shots": 1024,
},
{
"counts": {
"100": 26,
"110": 965,
"010": 21,
"111": 11,
"000": 1
},
"metadata": {
"state_label": "110"
},
"shots": 1024,
},
{
"counts": {
"111": 938,
"011": 23,
"110": 35,
"101": 27,
"100": 1
},
"metadata": {
"state_label": "111"
},
"shots": 1024,
},
]
expected_assignment_matrix = np.array([
[
0.96582031, 0.03515625, 0.02929688, 0.0, 0.01953125, 0.0,
0.00097656, 0.0
],
[
0.01464844, 0.94824219, 0.00195312, 0.02636719, 0.0,
0.03320312, 0.0, 0.0
],
[
0.01171875, 0.0, 0.94238281, 0.02539062, 0.0, 0.0, 0.02050781,
0.0
],
[
0.0, 0.00195312, 0.01074219, 0.93261719, 0.0, 0.0, 0.0,
0.02246094
],
[
0.00683594, 0.0, 0.00097656, 0.0, 0.95996094, 0.03125,
0.02539062, 0.00097656
],
[
0.00097656, 0.01464844, 0.0, 0.0, 0.0078125, 0.92480469, 0.0,
0.02636719
],
[
0.0, 0.0, 0.01464844, 0.00097656, 0.01269531, 0.0, 0.94238281,
0.03417969
],
[
0.0, 0.0, 0.0, 0.01464844, 0.0, 0.01074219, 0.01074219,
0.91601562
],
])
run_meta = {"physical_qubits": qubits}
expdata = ExperimentData()
expdata.add_data(run_data)
expdata._metadata = run_meta
exp = CorrelatedReadoutError(qubits)
result = exp.analysis.run(expdata)
mitigator = result.analysis_results(0).value
self.assertEqual(len(qubits), mitigator._num_qubits)
self.assertEqual(qubits, mitigator._qubits)
self.assertTrue(
matrix_equal(expected_assignment_matrix,
mitigator.assignment_matrix()))
