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 Exception 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.assertAlmostEqual(result.eigenvalue.real, -1.86, places=2)
def test_hhl_non_hermitian(self): """ hhl non hermitian test """ self.log.debug('Testing HHL with simple non-hermitian matrix') matrix = [[1, 1], [2, 1]] vector = [1, 0] # run NumPyLSsolver ref_result = NumPyLSsolver(matrix, vector).run() ref_solution = ref_result['solution'] ref_normed = ref_solution / np.linalg.norm(ref_solution) # run hhl orig_size = len(vector) matrix, vector, truncate_powerdim, truncate_hermitian = HHL.matrix_resize( matrix, vector) # Initialize eigenvalue finding module eigs = TestHHL._create_eigs(matrix, 6, True) num_q, num_a = eigs.get_register_sizes() # Initialize initial state module init_state = Custom(num_q, state_vector=vector) # Initialize reciprocal rotation module reci = LookupRotation(negative_evals=eigs._negative_evals, evo_time=eigs._evo_time) algo = HHL(matrix, vector, truncate_powerdim, truncate_hermitian, eigs, init_state, reci, num_q, num_a, orig_size) hhl_result = algo.run( QuantumInstance(BasicAer.get_backend('statevector_simulator'), seed_simulator=aqua_globals.random_seed, seed_transpiler=aqua_globals.random_seed)) hhl_solution = hhl_result['solution'] hhl_normed = hhl_solution / np.linalg.norm(hhl_solution) # compare result fidelity = state_fidelity(ref_normed, hhl_normed) self.assertGreater(fidelity, 0.8) self.log.debug('HHL solution vector: %s', hhl_solution) self.log.debug('algebraic solution vector: %s', ref_solution) self.log.debug('fidelity HHL to algebraic: %s', fidelity) self.log.debug('probability of result: %s', hhl_result["probability_result"])
def test_qsvm_binary(self): """ QSVM Binary test """ ref_kernel_training = np.array([[1., 0.85366667, 0.12341667, 0.36408333], [0.85366667, 1., 0.11141667, 0.45491667], [0.12341667, 0.11141667, 1., 0.667], [0.36408333, 0.45491667, 0.667, 1.]]) ref_kernel_testing = np.array([[0.14316667, 0.18208333, 0.4785, 0.14441667], [0.33608333, 0.3765, 0.02316667, 0.15858333]]) # ref_alpha = np.array([0.36064489, 1.49204209, 0.0264953, 1.82619169]) ref_alpha = np.array([0.34903335, 1.48325498, 0.03074852, 1.80153981]) # ref_bias = np.array([-0.03380763]) ref_bias = np.array([-0.03059226]) ref_support_vectors = np.array([[2.95309709, 2.51327412], [3.14159265, 4.08407045], [4.08407045, 2.26194671], [4.46106157, 2.38761042]]) backend = BasicAer.get_backend('qasm_simulator') num_qubits = 2 feature_map = SecondOrderExpansion(feature_dimension=num_qubits, depth=2, entangler_map=[[0, 1]]) svm = QSVM(feature_map, self.training_data, self.testing_data, None) quantum_instance = QuantumInstance(backend, shots=self.shots, seed_simulator=self.random_seed, seed_transpiler=self.random_seed) try: result = svm.run(quantum_instance) np.testing.assert_array_almost_equal( result['kernel_matrix_training'], ref_kernel_training, decimal=1) np.testing.assert_array_almost_equal( result['kernel_matrix_testing'], ref_kernel_testing, decimal=1) self.assertEqual(len(result['svm']['support_vectors']), 4) np.testing.assert_array_almost_equal( result['svm']['support_vectors'], ref_support_vectors, decimal=4) np.testing.assert_array_almost_equal(result['svm']['alphas'], ref_alpha, decimal=8) np.testing.assert_array_almost_equal(result['svm']['bias'], ref_bias, decimal=8) self.assertEqual(result['testing_accuracy'], 0.5) except NameError as ex: self.skipTest(str(ex))
def test_measurement_error_mitigation_with_dedicated_shots(self): """ measurement error mitigation with dedicated shots test """ # 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=100, 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) cals_matrix_1, timestamp_1 = quantum_instance.cals_matrix( qubit_index=[0, 1, 2]) quantum_instance.measurement_error_mitigation_shots = 1000 _ = 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_vqe_var_forms(self, depth, places): """ VQE Var Forms test """ aqua_globals.random_seed = self.seed result = VQE( self.qubit_op, RY(self.qubit_op.num_qubits, depth=depth, entanglement='sca', entanglement_gate='crx', skip_final_ry=True), L_BFGS_B()).run( QuantumInstance(BasicAer.get_backend('statevector_simulator'), shots=1, seed_simulator=aqua_globals.random_seed, seed_transpiler=aqua_globals.random_seed)) self.assertAlmostEqual(result.eigenvalue.real, -1.85727503, places=places)
def test_vqe(self, var_form_type): """ VQE test """ var_form = RYRZ(self.qubit_op.num_qubits) if var_form_type is QuantumCircuit: params = ParameterVector('θ', var_form.num_parameters) var_form = var_form.construct_circuit(params) vqe = VQE(self.qubit_op, var_form, L_BFGS_B()) result = vqe.run(QuantumInstance(BasicAer.get_backend('statevector_simulator'), basis_gates=['u1', 'u2', 'u3', 'cx', 'id'], coupling_map=[[0, 1]], seed_simulator=aqua_globals.random_seed, seed_transpiler=aqua_globals.random_seed)) self.assertAlmostEqual(result.eigenvalue.real, -1.85727503) np.testing.assert_array_almost_equal(result.eigenvalue.real, -1.85727503, 5) self.assertEqual(len(result.optimal_point), 16) self.assertIsNotNone(result.cost_function_evals) self.assertIsNotNone(result.optimizer_time)
def test_exact_cover_vqe(self): """ Exact Cover VQE test """ aqua_globals.random_seed = 10598 result = VQE(self.qubit_op, RYRZ(self.qubit_op.num_qubits, depth=5), COBYLA(), max_evals_grouped=2).run( QuantumInstance( BasicAer.get_backend('statevector_simulator'), seed_simulator=aqua_globals.random_seed, seed_transpiler=aqua_globals.random_seed)) x = sample_most_likely(result['eigvecs'][0]) ising_sol = exact_cover.get_solution(x) oracle = self._brute_force() self.assertEqual( exact_cover.check_solution_satisfiability(ising_sol, self.list_of_subsets), oracle)
def factorize(self): shor = Shor(self.factor) device = least_busy( self.__provider.backends( filters=lambda x: x.configuration().n_qubits >= 3 and not x. configuration().simulator and x.status().operational == True)) print("Running on current least busy device: ", device) quantum_instance = QuantumInstance(device, shots=1024, skip_qobj_validation=False) computation = shor.run(quantum_instance) if len(computation['factors']) == 0: print("Algorithm went wrong") return None, None result = computation['factors'][0] return result[0], result[1]
def test_bernstein_vazirani(self, bv_input, mct_mode, optimization, simulator): nbits = int(math.log(len(bv_input), 2)) # compute the ground-truth classically parameter = "" for i in reversed(range(nbits)): bit = bv_input[2**i] parameter += bit backend = BasicAer.get_backend(simulator) oracle = TruthTableOracle(bv_input, optimization=optimization, mct_mode=mct_mode) algorithm = BernsteinVazirani(oracle) quantum_instance = QuantumInstance(backend) result = algorithm.run(quantum_instance=quantum_instance) # print(result['circuit'].draw(line_length=10000)) self.assertEqual(result['result'], parameter)
def call_grover(truth_map: str, num_vertices: int, shots=1024) -> dict: """Call the simulation for grover's algorithm with the truth map and time its execution :param truth_map: The string bitmap :param num_vertices: Number of vertices of the graph for documentation purposes :return: the GroverResult item """ start = time() oracle = TruthTableOracle(truth_map) grover = Grover(oracle) # Wow that's nice that this already exists result = grover.run( QuantumInstance(BasicAer.get_backend('qasm_simulator'), shots=shots)) end = time() print('Grover\'s search on n = {} vertices:\nTime elapsed: {}s\n'.format( num_vertices, end - start)) return result
def setUp(self): super().setUp() self._statevector = QuantumInstance( backend=BasicAer.get_backend('statevector_simulator'), circuit_caching=False, seed_simulator=2, seed_transpiler=2) def qasm(shots=100): return QuantumInstance( backend=BasicAer.get_backend('qasm_simulator'), shots=shots, circuit_caching=False, seed_simulator=2, seed_transpiler=2) self._qasm = qasm
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))
def test_uccsd_hf_aer_qasm_snapshot(self): """ uccsd hf test with Aer qasm_simulator snapshot. """ try: # pylint: disable=import-outside-toplevel from qiskit import Aer except Exception as ex: # pylint: disable=broad-except self.skipTest("Aer doesn't appear to be installed. Error: '{}'".format(str(ex))) return backend = Aer.get_backend('qasm_simulator') optimizer = SPSA(maxiter=200, last_avg=5) solver = VQE(var_form=self.var_form, optimizer=optimizer, expectation=AerPauliExpectation(), quantum_instance=QuantumInstance(backend=backend)) gsc = GroundStateEigensolver(self.fermionic_transformation, solver) result = gsc.solve(self.driver) self.assertAlmostEqual(result.total_energies[0], self.reference_energy, places=3)
def test_uccsd_hf_aer_qasm_snapshot(self): """ uccsd hf test with Aer qasm_simulator snapshot. """ try: # pylint: disable=import-outside-toplevel from qiskit import Aer except Exception as ex: # pylint: disable=broad-except self.skipTest( "Aer doesn't appear to be installed. Error: '{}'".format( str(ex))) return backend = Aer.get_backend('qasm_simulator') algo = VQE(self.qubit_op, self.var_form, self.optimizer, expectation=AerPauliExpectation()) result = algo.run(QuantumInstance(backend)) result = self.core.process_algorithm_result(result) self.assertAlmostEqual(result.energy, self.reference_energy, places=6)
def test_vqe_callback(self): tmp_filename = 'vqe_callback_test.csv' is_file_exist = os.path.exists(self._get_resource_path(tmp_filename)) if is_file_exist: os.remove(self._get_resource_path(tmp_filename)) def store_intermediate_result(eval_count, parameters, mean, std): with open(self._get_resource_path(tmp_filename), 'a') as f: content = "{},{},{:.5f},{:.5f}".format(eval_count, parameters, mean, std) print(content, file=f, flush=True) backend = BasicAer.get_backend('qasm_simulator') num_qubits = self.algo_input.qubit_op.num_qubits init_state = Zero(num_qubits) var_form = RY(num_qubits, 1, initial_state=init_state) optimizer = COBYLA(maxiter=3) algo = VQE(self.algo_input.qubit_op, var_form, optimizer, 'paulis', callback=store_intermediate_result) aqua_globals.random_seed = 50 quantum_instance = QuantumInstance(backend, seed_transpiler=50, shots=1024, seed_simulator=50) algo.run(quantum_instance) is_file_exist = os.path.exists(self._get_resource_path(tmp_filename)) self.assertTrue(is_file_exist, "Does not store content successfully.") # check the content ref_content = [['1', '[-0.03391886 -1.70850424 -1.53640265 -0.65137839]', '-0.61121', '0.01572'], ['2', '[ 0.96608114 -1.70850424 -1.53640265 -0.65137839]', '-0.79235', '0.01722'], ['3', '[ 0.96608114 -0.70850424 -1.53640265 -0.65137839]', '-0.82829', '0.01529'] ] try: with open(self._get_resource_path(tmp_filename)) as f: idx = 0 for record in f.readlines(): eval_count, parameters, mean, std = record.split(",") self.assertEqual(eval_count.strip(), ref_content[idx][0]) self.assertEqual(parameters, ref_content[idx][1]) self.assertEqual(mean.strip(), ref_content[idx][2]) self.assertEqual(std.strip(), ref_content[idx][3]) idx += 1 finally: if is_file_exist: os.remove(self._get_resource_path(tmp_filename))
def test_application(self): """Test an end-to-end application.""" num_qubits = 3 # parameters for considered random distribution s_p = 2.0 # initial spot price vol = 0.4 # volatility of 40% r = 0.05 # annual interest rate of 4% t_m = 40 / 365 # 40 days to maturity # resulting parameters for log-normal distribution mu = ((r - 0.5 * vol ** 2) * t_m + np.log(s_p)) sigma = vol * np.sqrt(t_m) mean = np.exp(mu + sigma ** 2 / 2) variance = (np.exp(sigma ** 2) - 1) * np.exp(2 * mu + sigma ** 2) stddev = np.sqrt(variance) # lowest and highest value considered for the spot price; # in between, an equidistant discretization is considered. low = np.maximum(0, mean - 3 * stddev) high = mean + 3 * stddev bounds = (low, high) # construct circuit factory for uncertainty model uncertainty_model = LogNormalDistribution(num_qubits, mu=mu, sigma=sigma ** 2, bounds=bounds) # set the strike price (should be within the low and the high value of the uncertainty) strike_price = 1.896 # create amplitude function european_call_delta = EuropeanCallDelta(num_qubits, strike_price, bounds) # create state preparation state_preparation = european_call_delta.compose(uncertainty_model, front=True) # run amplitude estimation iae = IterativeAmplitudeEstimation(0.01, 0.05, state_preparation=state_preparation, objective_qubits=[num_qubits]) backend = QuantumInstance(Aer.get_backend('qasm_simulator'), seed_simulator=125, seed_transpiler=80) result = iae.run(backend) self.assertAlmostEqual(result.estimation, 0.8088790606143996)
def test_qpe(self, qubit_op, simulator, num_time_slices, n_ancillae): self.algorithm = 'QPE' self.log.debug('Testing QPE') self.qubit_op = qubit_op exact_eigensolver = ExactEigensolver(self.qubit_op, k=1) results = exact_eigensolver.run() self.ref_eigenval = results['eigvals'][0] self.ref_eigenvec = results['eigvecs'][0] self.log.debug('The exact eigenvalue is: {}'.format(self.ref_eigenval)) self.log.debug('The corresponding eigenvector: {}'.format(self.ref_eigenvec)) state_in = Custom(self.qubit_op.num_qubits, state_vector=self.ref_eigenvec) iqft = Standard(n_ancillae) qpe = QPE(self.qubit_op, state_in, iqft, num_time_slices, n_ancillae, expansion_mode='suzuki', expansion_order=2, shallow_circuit_concat=True) backend = BasicAer.get_backend(simulator) quantum_instance = QuantumInstance(backend, shots=100) # run qpe result = qpe.run(quantum_instance) # report result self.log.debug('top result str label: {}'.format(result['top_measurement_label'])) self.log.debug('top result in decimal: {}'.format(result['top_measurement_decimal'])) self.log.debug('stretch: {}'.format(result['stretch'])) self.log.debug('translation: {}'.format(result['translation'])) self.log.debug('final eigenvalue from QPE: {}'.format(result['energy'])) self.log.debug('reference eigenvalue: {}'.format(self.ref_eigenval)) self.log.debug('ref eigenvalue (transformed): {}'.format( (self.ref_eigenval + result['translation']) * result['stretch']) ) self.log.debug('reference binary str label: {}'.format(decimal_to_binary( (self.ref_eigenval.real + result['translation']) * result['stretch'], max_num_digits=n_ancillae + 3, fractional_part_only=True ))) np.testing.assert_approx_equal(result['energy'], self.ref_eigenval.real, significant=2)
def test_uvcc_vscf(self): """ uvcc vscf test """ co2_2modes_2modals_2body = [[[[[0, 0, 0]], 320.8467332810141], [[[0, 1, 1]], 1760.878530705873], [[[1, 0, 0]], 342.8218290247543], [[[1, 1, 1]], 1032.396323618631]], [[[[0, 0, 0], [1, 0, 0]], -57.34003649795117], [[[0, 0, 1], [1, 0, 0]], -56.33205925807966], [[[0, 1, 0], [1, 0, 0]], -56.33205925807966], [[[0, 1, 1], [1, 0, 0]], -60.13032761856809], [[[0, 0, 0], [1, 0, 1]], -65.09576309934431], [[[0, 0, 1], [1, 0, 1]], -62.2363839133389], [[[0, 1, 0], [1, 0, 1]], -62.2363839133389], [[[0, 1, 1], [1, 0, 1]], -121.5533969109279], [[[0, 0, 0], [1, 1, 0]], -65.09576309934431], [[[0, 0, 1], [1, 1, 0]], -62.2363839133389], [[[0, 1, 0], [1, 1, 0]], -62.2363839133389], [[[0, 1, 1], [1, 1, 0]], -121.5533969109279], [[[0, 0, 0], [1, 1, 1]], -170.744837386338], [[[0, 0, 1], [1, 1, 1]], -167.7433236025723], [[[0, 1, 0], [1, 1, 1]], -167.7433236025723], [[[0, 1, 1], [1, 1, 1]], -179.0536532281924]]] basis = [2, 2] bosonic_op = BosonicOperator(co2_2modes_2modals_2body, basis) qubit_op = bosonic_op.mapping('direct', threshold=1e-5) init_state = VSCF(basis) num_qubits = sum(basis) uvcc_varform = UVCC(num_qubits, basis, [0, 1], initial_state=init_state) q_instance = QuantumInstance(BasicAer.get_backend('statevector_simulator'), seed_transpiler=90, seed_simulator=12) optimizer = COBYLA(maxiter=1000) algo = VQE(qubit_op, uvcc_varform, optimizer) vqe_result = algo.run(q_instance) energy = vqe_result['optimal_value'] self.assertAlmostEqual(energy, self.reference_energy, places=4)
def test_measurement_error_mitigation_with_diff_qubit_order(self): """ measurement error mitigation with dedicated shots test """ # pylint: disable=import-outside-toplevel from qiskit import Aer from qiskit.providers.aer import noise 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]) # 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_vqc_minibatching_no_gradient_support(self, use_circuits): """ vqc minibatching with no gradient support test """ n_dim = 2 # dimension of each data point seed = 1024 aqua_globals.random_seed = seed _, training_input, test_input, _ = ad_hoc_data(training_size=6, test_size=3, n=n_dim, gap=0.3, plot_data=False) backend = BasicAer.get_backend('statevector_simulator') num_qubits = n_dim optimizer = COBYLA(maxiter=40) feature_map = SecondOrderExpansion(feature_dimension=num_qubits, depth=2) var_form = RYRZ(num_qubits=num_qubits, depth=3) # convert to circuit if circuits should be used if use_circuits: x = ParameterVector('x', feature_map.feature_dimension) feature_map = feature_map.construct_circuit(x) theta = ParameterVector('theta', var_form.num_parameters) var_form = var_form.construct_circuit(theta) # set up algorithm vqc = VQC(optimizer, feature_map, var_form, training_input, test_input, minibatch_size=2) # sort parameters for reproducibility if use_circuits: vqc._feature_map_params = list(x) vqc._var_form_params = list(theta) quantum_instance = QuantumInstance(backend, seed_simulator=seed, seed_transpiler=seed, optimization_level=0) result = vqc.run(quantum_instance) self.log.debug(result['testing_accuracy']) self.assertGreaterEqual(result['testing_accuracy'], 0.5)
def test_readme_sample(self): """ readme sample test """ # pylint: disable=import-outside-toplevel,redefined-builtin def print(*args): """ overloads print to log values """ if args: self.log.debug(args[0], *args[1:]) # --- Exact copy of sample code ---------------------------------------- from qiskit import BasicAer from qiskit.aqua import QuantumInstance, aqua_globals from qiskit.aqua.algorithms import VQC from qiskit.aqua.components.optimizers import COBYLA from qiskit.aqua.components.feature_maps import RawFeatureVector from qiskit.ml.datasets import wine from qiskit.circuit.library import TwoLocal seed = 1376 aqua_globals.random_seed = seed # Use Wine data set for training and test data feature_dim = 4 # dimension of each data point _, training_input, test_input, _ = wine(training_size=12, test_size=4, n=feature_dim) feature_map = RawFeatureVector(feature_dimension=feature_dim) vqc = VQC(COBYLA(maxiter=100), feature_map, TwoLocal(feature_map.num_qubits, ['ry', 'rz'], 'cz', reps=3), training_input, test_input) result = vqc.run( QuantumInstance(BasicAer.get_backend('statevector_simulator'), shots=1024, seed_simulator=seed, seed_transpiler=seed)) print('Testing accuracy: {:0.2f}'.format(result['testing_accuracy'])) # ---------------------------------------------------------------------- self.assertGreater(result['testing_accuracy'], 0.8)
def test_hhl_random_hermitian(self): """ hhl random hermitian test """ self.log.debug('Testing HHL with random hermitian matrix') n = 2 matrix = rmg.random_hermitian(n, eigrange=[0, 1]) vector = aqua_globals.random.random(n) # run NumPyLSsolver ref_result = NumPyLSsolver(matrix, vector).run() ref_solution = ref_result['solution'] ref_normed = ref_solution / np.linalg.norm(ref_solution) # run hhl orig_size = len(vector) matrix, vector, truncate_powerdim, truncate_hermitian = HHL.matrix_resize( matrix, vector) # Initialize eigenvalue finding module eigs = TestHHL._create_eigs(matrix, 4, False) num_q, num_a = eigs.get_register_sizes() # Initialize initial state module init_state = Custom(num_q, state_vector=vector) # Initialize reciprocal rotation module reci = LookupRotation(negative_evals=eigs._negative_evals, evo_time=eigs._evo_time) algo = HHL(matrix, vector, truncate_powerdim, truncate_hermitian, eigs, init_state, reci, num_q, num_a, orig_size) warnings.filterwarnings('ignore', category=DeprecationWarning) hhl_result = algo.run( QuantumInstance(BasicAer.get_backend('statevector_simulator'), seed_simulator=aqua_globals.random_seed, seed_transpiler=aqua_globals.random_seed)) warnings.filterwarnings('always', category=DeprecationWarning) hhl_solution = hhl_result['solution'] hhl_normed = hhl_solution / np.linalg.norm(hhl_solution) # compare result fidelity = state_fidelity(ref_normed, hhl_normed) np.testing.assert_approx_equal(fidelity, 1, significant=1)
def test_vqc_with_max_evals_grouped(self, mode): """ vqc with max evals grouped test """ aqua_globals.random_seed = self.seed optimizer = SPSA(max_trials=10, save_steps=1, c0=4.0, c1=0.1, c2=0.602, c3=0.101, c4=0.0, skip_calibration=True) data_preparation = self.data_preparation[mode] wavefunction = self.ryrz_wavefunction[mode] if mode == 'wrapped': warnings.filterwarnings('ignore', category=DeprecationWarning) # set up algorithm vqc = VQC(optimizer, data_preparation, wavefunction, self.training_data, self.testing_data, max_evals_grouped=2) if mode == 'wrapped': warnings.filterwarnings('always', category=DeprecationWarning) quantum_instance = QuantumInstance( BasicAer.get_backend('qasm_simulator'), shots=1024, seed_simulator=aqua_globals.random_seed, seed_transpiler=aqua_globals.random_seed) result = vqc.run(quantum_instance) with self.subTest('opt params'): np.testing.assert_array_almost_equal(result['opt_params'], self.ref_opt_params[mode], decimal=8) with self.subTest('training loss'): np.testing.assert_array_almost_equal(result['training_loss'], self.ref_train_loss[mode], decimal=8) with self.subTest('accuracy'): self.assertEqual(1.0 if mode == 'wrapped' else 0.5, result['testing_accuracy'])
def test_vqc_minibatching_with_gradient_support(self, mode): """ vqc minibatching with gradient support test """ n_dim = 2 # dimension of each data point seed = 1024 aqua_globals.random_seed = seed _, training_input, test_input, _ = ad_hoc_data(training_size=4, test_size=2, n=n_dim, gap=0.3, plot_data=False) backend = BasicAer.get_backend('statevector_simulator') optimizer = L_BFGS_B(maxfun=30) # set up data encoding circuit data_preparation = self.data_preparation[mode] # set up wavefunction if mode == 'wrapped': warnings.filterwarnings('ignore', category=DeprecationWarning) wavefunction = RYRZ(2, depth=1) else: wavefunction = TwoLocal(2, ['ry', 'rz'], 'cz', reps=1, insert_barriers=True) if mode == 'circuit': wavefunction = QuantumCircuit(2).compose(wavefunction) # set up algorithm vqc = VQC(optimizer, data_preparation, wavefunction, training_input, test_input, minibatch_size=2) if mode == 'wrapped': warnings.filterwarnings('always', category=DeprecationWarning) quantum_instance = QuantumInstance(backend, seed_simulator=seed, seed_transpiler=seed) result = vqc.run(quantum_instance) self.assertGreater(result['testing_accuracy'], 0.2)
def run(self, quantum_instance=None, **kwargs): """Execute the algorithm with selected backend. Args: quantum_instance (QuantumInstance or BaseBackend): the experiemental setting. Returns: dict: results of an algorithm. """ if not self.configuration.get('classical', False): if quantum_instance is None: AquaError( "Quantum device or backend is needed since you are running quantum algorithm." ) if isinstance(quantum_instance, BaseBackend): quantum_instance = QuantumInstance(quantum_instance) quantum_instance.set_config(**kwargs) self._quantum_instance = quantum_instance return self._run()
def test_gradient_wrapper(self, backend): """Test the gradient wrapper for probability gradients dp0/da = cos(a)sin(b) / 2 dp1/da = - cos(a)sin(b) / 2 dp0/db = sin(a)cos(b) / 2 dp1/db = - sin(a)cos(b) / 2 """ method = 'param_shift' a = Parameter('a') b = Parameter('b') params = [a, b] q = QuantumRegister(1) qc = QuantumCircuit(q) qc.h(q) qc.rz(params[0], q[0]) qc.rx(params[1], q[0]) op = CircuitStateFn(primitive=qc, coeff=1.) shots = 8000 backend = BasicAer.get_backend(backend) q_instance = QuantumInstance(backend=backend, shots=shots) if method == 'fin_diff': np.random.seed(8) prob_grad = Gradient(grad_method=method, epsilon=shots**(-1 / 6.)).gradient_wrapper( operator=op, bind_params=params, backend=q_instance) else: prob_grad = Gradient(grad_method=method).gradient_wrapper( operator=op, bind_params=params, backend=q_instance) values = [[np.pi / 4, 0], [np.pi / 4, np.pi / 4], [np.pi / 2, np.pi]] correct_values = [[[0, 0], [1 / (2 * np.sqrt(2)), -1 / (2 * np.sqrt(2))]], [[1 / 4, -1 / 4], [1 / 4, -1 / 4]], [[0, 0], [-1 / 2, 1 / 2]]] for i, value in enumerate(values): result = prob_grad(value) np.testing.assert_array_almost_equal(result, correct_values[i], decimal=1)
def test_vqe_qasm_snapshot_mode(self): """ VQE Aer qasm_simulator snapshot mode test """ try: # pylint: disable=import-outside-toplevel from qiskit import Aer except Exception as ex: # pylint: disable=broad-except self.skipTest("Aer doesn't appear to be installed. Error: '{}'".format(str(ex))) return backend = Aer.get_backend('qasm_simulator') num_qubits = self.qubit_op.num_qubits init_state = Zero(num_qubits) var_form = RY(num_qubits, 3, initial_state=init_state) optimizer = L_BFGS_B() algo = VQE(self.qubit_op, var_form, optimizer, max_evals_grouped=1) quantum_instance = QuantumInstance(backend, shots=1, seed_simulator=aqua_globals.random_seed, seed_transpiler=aqua_globals.random_seed) result = algo.run(quantum_instance) self.assertAlmostEqual(result.eigenvalue.real, -1.85727503, places=6)
def test_circuit_sampler2(self, method): """Test the probability gradient with the circuit sampler dp0/da = cos(a)sin(b) / 2 dp1/da = - cos(a)sin(b) / 2 dp0/db = sin(a)cos(b) / 2 dp1/db = - sin(a)cos(b) / 2 """ a = Parameter('a') b = Parameter('b') params = [a, b] q = QuantumRegister(1) qc = QuantumCircuit(q) qc.h(q) qc.rz(params[0], q[0]) qc.rx(params[1], q[0]) op = CircuitStateFn(primitive=qc, coeff=1.) shots = 8000 if method == 'fin_diff': np.random.seed(8) prob_grad = Gradient(grad_method=method, epsilon=shots ** (-1 / 6.)).convert( operator=op, params=params) else: prob_grad = Gradient(grad_method=method).convert(operator=op, params=params) values_dict = [{a: [np.pi / 4], b: [0]}, {params[0]: [np.pi / 4], params[1]: [np.pi / 4]}, {params[0]: [np.pi / 2], params[1]: [np.pi]}] correct_values = [[[0, 0], [1 / (2 * np.sqrt(2)), - 1 / (2 * np.sqrt(2))]], [[1 / 4, -1 / 4], [1 / 4, - 1 / 4]], [[0, 0], [- 1 / 2, 1 / 2]]] backend = BasicAer.get_backend('qasm_simulator') q_instance = QuantumInstance(backend=backend, shots=shots) for i, value_dict in enumerate(values_dict): sampler = CircuitSampler(backend=q_instance).convert(prob_grad, params=value_dict) result = sampler.eval() np.testing.assert_array_almost_equal(result[0], correct_values[i], decimal=1)
def test_clique_vqe(self): """ VQE Clique test """ aqua_globals.random_seed = 10598 result = VQE(self.qubit_op, RY(self.qubit_op.num_qubits, depth=5, entanglement='linear'), COBYLA(), max_evals_grouped=2).run( QuantumInstance( BasicAer.get_backend('statevector_simulator'), seed_simulator=aqua_globals.random_seed, seed_transpiler=aqua_globals.random_seed)) x = sample_most_likely(result.eigenstate) ising_sol = clique.get_graph_solution(x) np.testing.assert_array_equal(ising_sol, [1, 1, 1, 1, 1]) oracle = self._brute_force() self.assertEqual(clique.satisfy_or_not(ising_sol, self.w, self.k), oracle)
def test_vqe(self): """ VQE test """ result = VQE(self.qubit_op, RYRZ(self.qubit_op.num_qubits), L_BFGS_B()).run( QuantumInstance(BasicAer.get_backend('statevector_simulator'), basis_gates=['u1', 'u2', 'u3', 'cx', 'id'], coupling_map=[[0, 1]], seed_simulator=aqua_globals.random_seed, seed_transpiler=aqua_globals.random_seed)) self.assertAlmostEqual(result.eigenvalue.real, -1.85727503) np.testing.assert_array_almost_equal(result.eigenvalue.real, -1.85727503, 5) ref_opt_params = [-0.58294401, -1.86141794, -1.97209632, -0.54796022, -0.46945572, 2.60114794, -1.15637845, 1.40498879, 1.14479635, -0.48416694, -0.66608349, -1.1367579, -2.67097002, 3.10214631, 3.10000313, 0.37235089] np.testing.assert_array_almost_equal(result.optimal_point, ref_opt_params, 5) self.assertIsNotNone(result.cost_function_evals) self.assertIsNotNone(result.optimizer_time)