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])