def test_measurement_error_mitigation_with_diff_qubit_order(self):
""" measurement error mitigation with different qubit order"""
# pylint: disable=import-outside-toplevel
try:
from qiskit import Aer
from qiskit.providers.aer import noise
except ImportError as ex: # pylint: disable=broad-except
self.skipTest(
"Aer doesn't appear to be installed. Error: '{}'".format(
str(ex)))
return
aqua_globals.random_seed = 0
# build noise model
noise_model = noise.NoiseModel()
read_err = noise.errors.readout_error.ReadoutError([[0.9, 0.1],
[0.25, 0.75]])
noise_model.add_all_qubit_readout_error(read_err)
backend = Aer.get_backend('qasm_simulator')
quantum_instance = QuantumInstance(
backend=backend,
seed_simulator=1679,
seed_transpiler=167,
shots=1000,
noise_model=noise_model,
measurement_error_mitigation_cls=CompleteMeasFitter,
cals_matrix_refresh_period=0)
# circuit
qc1 = QuantumCircuit(2, 2)
qc1.h(0)
qc1.cx(0, 1)
qc1.measure(0, 0)
qc1.measure(1, 1)
qc2 = QuantumCircuit(2, 2)
qc2.h(0)
qc2.cx(0, 1)
qc2.measure(1, 0)
qc2.measure(0, 1)
# this should run smoothly
quantum_instance.execute([qc1, qc2])
self.assertGreater(quantum_instance.time_taken, 0.)
quantum_instance.reset_execution_results()
# failure case
qc3 = QuantumCircuit(3, 3)
qc3.h(2)
qc3.cx(1, 2)
qc3.measure(2, 1)
qc3.measure(1, 2)
self.assertRaises(AquaError, quantum_instance.execute, [qc1, qc3])
def test_measurement_error_mitigation_auto_refresh(self):
""" measurement error mitigation auto refresh test """
try:
# pylint: disable=import-outside-toplevel
from qiskit import Aer
from qiskit.providers.aer import noise
except ImportError as ex: # pylint: disable=broad-except
self.skipTest(
"Aer doesn't appear to be installed. Error: '{}'".format(
str(ex)))
return
aqua_globals.random_seed = 0
# build noise model
noise_model = noise.NoiseModel()
read_err = noise.errors.readout_error.ReadoutError([[0.9, 0.1],
[0.25, 0.75]])
noise_model.add_all_qubit_readout_error(read_err)
backend = Aer.get_backend('qasm_simulator')
quantum_instance = QuantumInstance(
backend=backend,
seed_simulator=1679,
seed_transpiler=167,
noise_model=noise_model,
measurement_error_mitigation_cls=CompleteMeasFitter,
cals_matrix_refresh_period=0)
oracle = LogicalExpressionOracle('a & b & c')
grover = Grover(oracle)
_ = grover.run(quantum_instance)
self.assertGreater(quantum_instance.time_taken, 0.)
quantum_instance.reset_execution_results()
cals_matrix_1, timestamp_1 = quantum_instance.cals_matrix(
qubit_index=[0, 1, 2])
time.sleep(15)
aqua_globals.random_seed = 2
quantum_instance.set_config(seed_simulator=111)
_ = grover.run(quantum_instance)
cals_matrix_2, timestamp_2 = quantum_instance.cals_matrix(
qubit_index=[0, 1, 2])
diff = cals_matrix_1 - cals_matrix_2
total_diff = np.sum(np.abs(diff))
self.assertGreater(total_diff, 0.0)
self.assertGreater(timestamp_2, timestamp_1)
def test_wo_backend_options(self):
""" without backend options test """
quantum_instance = QuantumInstance(self.backend,
seed_transpiler=self.random_seed,
seed_simulator=self.random_seed,
shots=1024)
# run without backend_options and without noise
res_wo_bo = quantum_instance.execute(self.qc).get_counts(self.qc)
self.assertGreater(quantum_instance.time_taken, 0.)
quantum_instance.reset_execution_results()
quantum_instance.skip_qobj_validation = True
res_wo_bo_skip_validation = quantum_instance.execute(
self.qc).get_counts(self.qc)
self.assertGreater(quantum_instance.time_taken, 0.)
quantum_instance.reset_execution_results()
self.assertTrue(_compare_dict(res_wo_bo, res_wo_bo_skip_validation))
def test_measurement_error_mitigation(self):
""" measurement error mitigation test """
try:
# pylint: disable=import-outside-toplevel
from qiskit import Aer
from qiskit.providers.aer import noise
except ImportError as ex: # pylint: disable=broad-except
self.skipTest(
"Aer doesn't appear to be installed. Error: '{}'".format(
str(ex)))
return
aqua_globals.random_seed = 0
# build noise model
noise_model = noise.NoiseModel()
read_err = noise.errors.readout_error.ReadoutError([[0.9, 0.1],
[0.25, 0.75]])
noise_model.add_all_qubit_readout_error(read_err)
backend = Aer.get_backend('qasm_simulator')
quantum_instance = QuantumInstance(backend=backend,
seed_simulator=167,
seed_transpiler=167,
noise_model=noise_model)
qi_with_mitigation = \
QuantumInstance(backend=backend,
seed_simulator=167,
seed_transpiler=167,
noise_model=noise_model,
measurement_error_mitigation_cls=CompleteMeasFitter)
oracle = LogicalExpressionOracle('a & b & c')
grover = Grover(oracle)
result_wo_mitigation = grover.run(quantum_instance)
self.assertGreater(quantum_instance.time_taken, 0.)
quantum_instance.reset_execution_results()
prob_top_meas_wo_mitigation = result_wo_mitigation.measurement[
result_wo_mitigation.top_measurement]
result_w_mitigation = grover.run(qi_with_mitigation)
prob_top_meas_w_mitigation = \
result_w_mitigation.measurement[result_w_mitigation.top_measurement]
self.assertGreaterEqual(prob_top_meas_w_mitigation,
prob_top_meas_wo_mitigation)
def test_measurement_error_mitigation_with_vqe(self):
""" measurement error mitigation test with vqe """
try:
# pylint: disable=import-outside-toplevel
from qiskit import Aer
from qiskit.providers.aer import noise
except ImportError as ex: # pylint: disable=broad-except
self.skipTest(
"Aer doesn't appear to be installed. Error: '{}'".format(
str(ex)))
return
aqua_globals.random_seed = 0
# build noise model
noise_model = noise.NoiseModel()
read_err = noise.errors.readout_error.ReadoutError([[0.9, 0.1],
[0.25, 0.75]])
noise_model.add_all_qubit_readout_error(read_err)
backend = Aer.get_backend('qasm_simulator')
quantum_instance = QuantumInstance(
backend=backend,
seed_simulator=167,
seed_transpiler=167,
noise_model=noise_model,
measurement_error_mitigation_cls=CompleteMeasFitter)
h2_hamiltonian = -1.052373245772859 * (I ^ I) \
+ 0.39793742484318045 * (I ^ Z) \
- 0.39793742484318045 * (Z ^ I) \
- 0.01128010425623538 * (Z ^ Z) \
+ 0.18093119978423156 * (X ^ X)
optimizer = SPSA(maxiter=200)
var_form = EfficientSU2(2, reps=1)
vqe = VQE(
var_form=var_form,
operator=h2_hamiltonian,
quantum_instance=quantum_instance,
optimizer=optimizer,
)
result = vqe.compute_minimum_eigenvalue()
self.assertGreater(quantum_instance.time_taken, 0.)
quantum_instance.reset_execution_results()
self.assertAlmostEqual(result.eigenvalue.real, -1.86, places=2)
def test_w_backend_options(self):
""" with backend options test """
# run with backend_options
quantum_instance = QuantumInstance(
self.backend,
seed_transpiler=self.random_seed,
seed_simulator=self.random_seed,
shots=1024,
backend_options={'initial_statevector': [.5, .5, .5, .5]})
res_w_bo = quantum_instance.execute(self.qc).get_counts(self.qc)
self.assertGreater(quantum_instance.time_taken, 0.)
quantum_instance.reset_execution_results()
quantum_instance.skip_qobj_validation = True
res_w_bo_skip_validation = quantum_instance.execute(
self.qc).get_counts(self.qc)
self.assertGreater(quantum_instance.time_taken, 0.)
quantum_instance.reset_execution_results()
self.assertTrue(_compare_dict(res_w_bo, res_w_bo_skip_validation))
class TestBernoulli(QiskitAquaTestCase):
"""Tests based on the Bernoulli A operator.
This class tests
* the estimation result
* the constructed circuits
"""
def setUp(self):
super().setUp()
self._statevector = QuantumInstance(
backend=BasicAer.get_backend('statevector_simulator'),
seed_simulator=2,
seed_transpiler=2)
self._unitary = QuantumInstance(
backend=BasicAer.get_backend('unitary_simulator'),
shots=1,
seed_simulator=42,
seed_transpiler=91)
def qasm(shots=100):
return QuantumInstance(
backend=BasicAer.get_backend('qasm_simulator'),
shots=shots,
seed_simulator=2,
seed_transpiler=2)
self._qasm = qasm
@idata(
[[0.2, AmplitudeEstimation(2), {
'estimation': 0.5,
'mle': 0.2
}], [0.49,
AmplitudeEstimation(3), {
'estimation': 0.5,
'mle': 0.49
}],
[0.2,
MaximumLikelihoodAmplitudeEstimation(2), {
'estimation': 0.2
}],
[0.49,
MaximumLikelihoodAmplitudeEstimation(3), {
'estimation': 0.49
}],
[0.2,
IterativeAmplitudeEstimation(0.1, 0.1), {
'estimation': 0.2
}],
[
0.49,
IterativeAmplitudeEstimation(0.001, 0.01), {
'estimation': 0.49
}
]])
@unpack
def test_statevector(self, prob, qae, expect):
""" statevector test """
# construct factories for A and Q
qae.state_preparation = BernoulliStateIn(prob)
qae.grover_operator = BernoulliGrover(prob)
result = qae.run(self._statevector)
self.assertGreater(self._statevector.time_taken, 0.)
self._statevector.reset_execution_results()
for key, value in expect.items():
self.assertAlmostEqual(value,
getattr(result, key),
places=3,
msg="estimate `{}` failed".format(key))
@idata([[
0.2, 100,
AmplitudeEstimation(4), {
'estimation': 0.14644,
'mle': 0.193888
}
], [0.0, 1000,
AmplitudeEstimation(2), {
'estimation': 0.0,
'mle': 0.0
}],
[
0.2, 100,
MaximumLikelihoodAmplitudeEstimation(4), {
'estimation': 0.199606
}
],
[
0.8, 10,
IterativeAmplitudeEstimation(0.1, 0.05), {
'estimation': 0.811711
}
]])
@unpack
def test_qasm(self, prob, shots, qae, expect):
""" qasm test """
# construct factories for A and Q
qae.state_preparation = BernoulliStateIn(prob)
qae.grover_operator = BernoulliGrover(prob)
result = qae.run(self._qasm(shots))
for key, value in expect.items():
self.assertAlmostEqual(value,
getattr(result, key),
places=3,
msg="estimate `{}` failed".format(key))
@data(True, False)
def test_qae_circuit(self, efficient_circuit):
"""Test circuits resulting from canonical amplitude estimation.
Build the circuit manually and from the algorithm and compare the resulting unitaries.
"""
prob = 0.5
for m in [2, 5]:
qae = AmplitudeEstimation(m, BernoulliStateIn(prob))
angle = 2 * np.arcsin(np.sqrt(prob))
# manually set up the inefficient AE circuit
qr_eval = QuantumRegister(m, 'a')
qr_objective = QuantumRegister(1, 'q')
circuit = QuantumCircuit(qr_eval, qr_objective)
# initial Hadamard gates
for i in range(m):
circuit.h(qr_eval[i])
# A operator
circuit.ry(angle, qr_objective)
if efficient_circuit:
qae.grover_operator = BernoulliGrover(prob)
for power in range(m):
circuit.cry(2 * 2**power * angle, qr_eval[power],
qr_objective[0])
else:
oracle = QuantumCircuit(1)
oracle.x(0)
oracle.z(0)
oracle.x(0)
state_preparation = QuantumCircuit(1)
state_preparation.ry(angle, 0)
grover_op = GroverOperator(oracle, state_preparation)
for power in range(m):
circuit.compose(grover_op.power(2**power).control(),
qubits=[qr_eval[power], qr_objective[0]],
inplace=True)
# fourier transform
iqft = QFT(m, do_swaps=False).inverse()
circuit.append(iqft.to_instruction(), qr_eval)
actual_circuit = qae.construct_circuit(measurement=False)
self.assertEqual(Operator(circuit), Operator(actual_circuit))
@data(True, False)
def test_iqae_circuits(self, efficient_circuit):
"""Test circuits resulting from iterative amplitude estimation.
Build the circuit manually and from the algorithm and compare the resulting unitaries.
"""
prob = 0.5
for k in [2, 5]:
qae = IterativeAmplitudeEstimation(
0.01, 0.05, state_preparation=BernoulliStateIn(prob))
angle = 2 * np.arcsin(np.sqrt(prob))
# manually set up the inefficient AE circuit
q_objective = QuantumRegister(1, 'q')
circuit = QuantumCircuit(q_objective)
# A operator
circuit.ry(angle, q_objective)
if efficient_circuit:
qae.grover_operator = BernoulliGrover(prob)
circuit.ry(2 * k * angle, q_objective[0])
else:
oracle = QuantumCircuit(1)
oracle.x(0)
oracle.z(0)
oracle.x(0)
state_preparation = QuantumCircuit(1)
state_preparation.ry(angle, 0)
grover_op = GroverOperator(oracle, state_preparation)
for _ in range(k):
circuit.compose(grover_op, inplace=True)
actual_circuit = qae.construct_circuit(k, measurement=False)
self.assertEqual(Operator(circuit), Operator(actual_circuit))
@data(True, False)
def test_mlae_circuits(self, efficient_circuit):
""" Test the circuits constructed for MLAE """
prob = 0.5
for k in [2, 5]:
qae = MaximumLikelihoodAmplitudeEstimation(
k, state_preparation=BernoulliStateIn(prob))
angle = 2 * np.arcsin(np.sqrt(prob))
# compute all the circuits used for MLAE
circuits = []
# 0th power
q_objective = QuantumRegister(1, 'q')
circuit = QuantumCircuit(q_objective)
circuit.ry(angle, q_objective)
circuits += [circuit]
# powers of 2
for power in range(k):
q_objective = QuantumRegister(1, 'q')
circuit = QuantumCircuit(q_objective)
# A operator
circuit.ry(angle, q_objective)
# Q^(2^j) operator
if efficient_circuit:
qae.grover_operator = BernoulliGrover(prob)
circuit.ry(2 * 2**power * angle, q_objective[0])
else:
oracle = QuantumCircuit(1)
oracle.x(0)
oracle.z(0)
oracle.x(0)
state_preparation = QuantumCircuit(1)
state_preparation.ry(angle, 0)
grover_op = GroverOperator(oracle, state_preparation)
for _ in range(2**power):
circuit.compose(grover_op, inplace=True)
actual_circuits = qae.construct_circuits(measurement=False)
for actual, expected in zip(actual_circuits, circuits):
self.assertEqual(Operator(actual), Operator(expected))
class TestSineIntegral(QiskitAquaTestCase):
"""Tests based on the A operator to integrate sin^2(x).
This class tests
* the estimation result
* the confidence intervals
"""
def setUp(self):
super().setUp()
self._statevector = QuantumInstance(
backend=BasicAer.get_backend('statevector_simulator'),
seed_simulator=123,
seed_transpiler=41)
def qasm(shots=100):
return QuantumInstance(
backend=BasicAer.get_backend('qasm_simulator'),
shots=shots,
seed_simulator=7192,
seed_transpiler=90000)
self._qasm = qasm
@idata([
[2, AmplitudeEstimation(2), {
'estimation': 0.5,
'mle': 0.270290
}],
[4,
MaximumLikelihoodAmplitudeEstimation(4), {
'estimation': 0.272675
}],
[3,
IterativeAmplitudeEstimation(0.1, 0.1), {
'estimation': 0.272082
}],
])
@unpack
def test_statevector(self, n, qae, expect):
""" Statevector end-to-end test """
# construct factories for A and Q
qae.state_preparation = SineIntegral(n)
result = qae.run(self._statevector)
self.assertGreater(self._statevector.time_taken, 0.)
self._statevector.reset_execution_results()
for key, value in expect.items():
self.assertAlmostEqual(value,
getattr(result, key),
places=3,
msg="estimate `{}` failed".format(key))
@idata([
[4, 10,
AmplitudeEstimation(2), {
'estimation': 0.5,
'mle': 0.333333
}],
[
3, 10,
MaximumLikelihoodAmplitudeEstimation(2), {
'estimation': 0.256878
}
],
[
3, 1000,
IterativeAmplitudeEstimation(0.01, 0.01), {
'estimation': 0.271790
}
],
])
@unpack
def test_qasm(self, n, shots, qae, expect):
"""QASM simulator end-to-end test."""
# construct factories for A and Q
qae.state_preparation = SineIntegral(n)
result = qae.run(self._qasm(shots))
for key, value in expect.items():
self.assertAlmostEqual(value,
getattr(result, key),
places=3,
msg="estimate `{}` failed".format(key))
@idata([
[
AmplitudeEstimation(3), 'mle', {
'likelihood_ratio': [0.24947346406470136, 0.3003771197734433],
'fisher': [0.24861769995820207, 0.2999286066724035],
'observed_fisher': [0.24845622030041542, 0.30009008633019013]
}
],
[
MaximumLikelihoodAmplitudeEstimation(3), 'estimation', {
'likelihood_ratio': [0.25987941798909114, 0.27985361366769945],
'fisher': [0.2584889015125656, 0.2797018754936686],
'observed_fisher': [0.2659279996107888, 0.2722627773954454]
}
],
])
@unpack
def test_confidence_intervals(self, qae, key, expect):
"""End-to-end test for all confidence intervals."""
n = 3
qae.state_preparation = SineIntegral(n)
# statevector simulator
result = qae.run(self._statevector)
self.assertGreater(self._statevector.time_taken, 0.)
self._statevector.reset_execution_results()
methods = ['lr', 'fi',
'oi'] # short for likelihood_ratio, fisher, observed_fisher
alphas = [0.1, 0.00001, 0.9] # alpha shouldn't matter in statevector
for alpha, method in zip(alphas, methods):
confint = qae.confidence_interval(alpha, method)
# confidence interval based on statevector should be empty, as we are sure of the result
self.assertAlmostEqual(confint[1] - confint[0], 0.0)
self.assertAlmostEqual(confint[0], getattr(result, key))
# qasm simulator
shots = 100
alpha = 0.01
result = qae.run(self._qasm(shots))
for method, expected_confint in expect.items():
confint = qae.confidence_interval(alpha, method)
self.assertEqual(confint, expected_confint)
self.assertTrue(confint[0] <= getattr(result, key) <= confint[1])
def test_iqae_confidence_intervals(self):
"""End-to-end test for the IQAE confidence interval."""
n = 3
qae = IterativeAmplitudeEstimation(0.1,
0.01,
state_preparation=SineIntegral(n))
expected_confint = [0.19840508760087738, 0.35110155403424115]
# statevector simulator
result = qae.run(self._statevector)
self.assertGreater(self._statevector.time_taken, 0.)
self._statevector.reset_execution_results()
confint = result.confidence_interval
# confidence interval based on statevector should be empty, as we are sure of the result
self.assertAlmostEqual(confint[1] - confint[0], 0.0)
self.assertAlmostEqual(confint[0], result.estimation)
# qasm simulator
shots = 100
result = qae.run(self._qasm(shots))
confint = result.confidence_interval
self.assertEqual(confint, expected_confint)
self.assertTrue(confint[0] <= result.estimation <= confint[1])
