def test_grouped_pauli_expectation(self): """ grouped pauli expectation test """ two_qubit_H2 = (-1.052373245772859 * I ^ I) + \ (0.39793742484318045 * I ^ Z) + \ (-0.39793742484318045 * Z ^ I) + \ (-0.01128010425623538 * Z ^ Z) + \ (0.18093119978423156 * X ^ X) wf = CX @ (H ^ I) @ Zero expect_op = PauliExpectation(group_paulis=False).convert(~StateFn(two_qubit_H2) @ wf) self.sampler._extract_circuitstatefns(expect_op) num_circuits_ungrouped = len(self.sampler._circuit_ops_cache) self.assertEqual(num_circuits_ungrouped, 5) expect_op_grouped = PauliExpectation(group_paulis=True).convert(~StateFn(two_qubit_H2) @ wf) q_instance = QuantumInstance(BasicAer.get_backend('statevector_simulator'), seed_simulator=self.seed, seed_transpiler=self.seed) sampler = CircuitSampler(q_instance) sampler._extract_circuitstatefns(expect_op_grouped) num_circuits_grouped = len(sampler._circuit_ops_cache) self.assertEqual(num_circuits_grouped, 2)
def test_vqe_caching_direct(self, batch_mode): backend = get_aer_backend('statevector_simulator') num_qubits = self.algo_input.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.algo_input.qubit_op, var_form, optimizer, 'matrix', batch_mode=batch_mode) circuit_cache = CircuitCache(skip_qobj_deepcopy=True) quantum_instance_caching = QuantumInstance(backend, circuit_cache=circuit_cache, skip_qobj_validation=True) result_caching = algo.run(quantum_instance_caching) self.assertLessEqual(circuit_cache.misses, 1) self.assertAlmostEqual( self.reference_vqe_result['statevector_simulator']['energy'], result_caching['energy'])
def test_graph_partition_vqe(self): """ Graph Partition VQE test """ aqua_globals.random_seed = 10213 wavefunction = RealAmplitudes(self.qubit_op.num_qubits, insert_barriers=True, reps=5, entanglement='linear') result = VQE(self.qubit_op, wavefunction, SPSA(maxiter=300), 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) # check against the oracle ising_sol = graph_partition.get_graph_solution(x) self.assertEqual(graph_partition.objective_value(np.array([0, 1, 0, 1]), self.w), graph_partition.objective_value(ising_sol, self.w)) oracle = self._brute_force() self.assertEqual(graph_partition.objective_value(x, self.w), oracle)
def test_graph_partition_vqe(self): """ Graph Partition VQE test """ aqua_globals.random_seed = 10598 result = VQE(self.qubit_op, RY(self.qubit_op.num_qubits, depth=5, entanglement='linear'), SPSA(max_trials=300), 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]) # check against the oracle ising_sol = graph_partition.get_graph_solution(x) np.testing.assert_array_equal(ising_sol, [0, 1, 0, 1]) oracle = self._brute_force() self.assertEqual(graph_partition.objective_value(x, self.w), oracle)
def test_uccsd_hf_aer_qasm(self): """ uccsd hf test with Aer qasm_simulator. """ 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=PauliExpectation(), quantum_instance=QuantumInstance(backend=backend, seed_simulator=aqua_globals.random_seed, seed_transpiler=aqua_globals.random_seed)) gsc = GroundStateEigensolver(self.fermionic_transformation, solver) result = gsc.solve(self.driver) self.assertAlmostEqual(result.total_energies[0], -1.138, places=2)
def setUp(self): super().setUp() aqua_globals.random_seed = 8 try: self.driver = PySCFDriver(atom='H .0 .0 .0; H .0 .0 0.75', unit=UnitsType.ANGSTROM, charge=0, spin=0, basis='sto3g') except QiskitChemistryError: self.skipTest('PYSCF driver does not appear to be installed') self.reference_energies = [-1.8427016, -1.8427016 + 0.5943372, -1.8427016 + 0.95788352, -1.8427016 + 1.5969296] self.transformation = \ FermionicTransformation(qubit_mapping=FermionicQubitMappingType.JORDAN_WIGNER) solver = NumPyEigensolver() self.ref = solver self.quantum_instance = QuantumInstance(BasicAer.get_backend('statevector_simulator'), seed_transpiler=90, seed_simulator=12)
def test_saving_and_loading_one_circ(self): """ Saving and Loading one Circ test """ with tempfile.NamedTemporaryFile(suffix='.inp', delete=True) as cache_tmp_file: cache_tmp_file_name = cache_tmp_file.name var_form = RYRZ(num_qubits=4, depth=5) backend = BasicAer.get_backend('statevector_simulator') params0 = aqua_globals.random.random_sample( var_form.num_parameters) circ0 = var_form.construct_circuit(params0) qi0 = QuantumInstance(backend, circuit_caching=True, cache_file=cache_tmp_file_name, skip_qobj_deepcopy=True, skip_qobj_validation=True, seed_simulator=self.seed, seed_transpiler=self.seed) _ = qi0.execute([circ0]) with open(cache_tmp_file_name, "rb") as cache_handler: saved_cache = pickle.load(cache_handler, encoding="ASCII") self.assertIn('qobjs', saved_cache) self.assertIn('mappings', saved_cache) qobjs = [Qobj.from_dict(qob) for qob in saved_cache['qobjs']] self.assertTrue(isinstance(qobjs[0], Qobj)) self.assertGreaterEqual(len(saved_cache['mappings'][0][0]), 50) qi1 = QuantumInstance(backend, circuit_caching=True, cache_file=cache_tmp_file_name, skip_qobj_deepcopy=True, skip_qobj_validation=True, seed_simulator=self.seed, seed_transpiler=self.seed) params1 = aqua_globals.random.random_sample( var_form.num_parameters) circ1 = var_form.construct_circuit(params1) qobj1 = qi1.circuit_cache.load_qobj_from_cache( [circ1], 0, run_config=qi1.run_config) self.assertTrue(isinstance(qobj1, Qobj)) _ = qi1.execute([circ1]) self.assertEqual(qi0.circuit_cache.mappings, qi1.circuit_cache.mappings) self.assertLessEqual(qi1.circuit_cache.misses, 0)
def test_vqc_minibatching_no_gradient_support(self): """ 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) 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) vqc = VQC(optimizer, feature_map, var_form, training_input, test_input, minibatch_size=2) quantum_instance = QuantumInstance(backend, seed_simulator=seed, seed_transpiler=seed, optimization_level=0) result = vqc.run(quantum_instance) vqc_accuracy = 0.666 self.log.debug(result['testing_accuracy']) self.assertGreaterEqual(result['testing_accuracy'], vqc_accuracy)
def test_grover(self, input_test, sol, oracle_cls, mct_mode, simulator, optimization, lam, rotation_counts): """ grover test """ groundtruth = sol oracle = oracle_cls(input_test, optimization=optimization) grover = Grover(oracle, incremental=True, lam=lam, rotation_counts=rotation_counts, mct_mode=mct_mode) backend = BasicAer.get_backend(simulator) quantum_instance = QuantumInstance(backend, shots=1000) ret = grover.run(quantum_instance) self.log.debug('Ground-truth Solutions: %s.', groundtruth) self.log.debug('Top measurement: %s.', ret.top_measurement) if ret.oracle_evaluation: self.assertIn(ret.top_measurement, groundtruth) self.log.debug('Search Result: %s.', ret.assignment) else: self.assertEqual(groundtruth, []) self.log.debug('Nothing found.')
def test_grover(self, input, sol, oracle_cls, mct_mode, simulator, optimization='off'): self.groundtruth = sol if optimization == 'off': oracle = oracle_cls(input, optimization='off') else: oracle = oracle_cls(input, optimization='qm-dlx' if oracle_cls == TTO else 'espresso') grover = Grover(oracle, incremental=True, mct_mode=mct_mode) backend = BasicAer.get_backend(simulator) quantum_instance = QuantumInstance(backend, shots=1000, circuit_caching=False) ret = grover.run(quantum_instance) self.log.debug('Ground-truth Solutions: {}.'.format(self.groundtruth)) self.log.debug('Top measurement: {}.'.format(ret['top_measurement'])) if ret['oracle_evaluation']: self.assertIn(ret['top_measurement'], self.groundtruth) self.log.debug('Search Result: {}.'.format(ret['result'])) else: self.assertEqual(self.groundtruth, []) self.log.debug('Nothing found.')
def test_vqc_minibatching_with_gradient_support(self): """ vqc minibatching with gradient support test """ n_dim = 2 # dimension of each data point seed = 1024 np.random.seed(seed) _, training_input, test_input, _ = _ad_hoc_data(training_size=8, test_size=4, n=n_dim, gap=0.3) aqua_globals.random_seed = seed backend = BasicAer.get_backend('statevector_simulator') num_qubits = n_dim optimizer = L_BFGS_B(maxfun=100) feature_map = SecondOrderExpansion(feature_dimension=num_qubits, depth=2) var_form = RYRZ(num_qubits=num_qubits, depth=2) vqc = VQC(optimizer, feature_map, var_form, training_input, test_input, minibatch_size=2) quantum_instance = QuantumInstance(backend, seed_simulator=seed, seed_transpiler=seed) result = vqc.run(quantum_instance) vqc_accuracy_threshold = 0.8 self.log.debug(result['testing_accuracy']) self.assertGreater(result['testing_accuracy'], vqc_accuracy_threshold)
def test_custom_excitation_pool(self): """ Test custom excitation pool """ class CustomFactory(VQEUCCSDFactory): """A custom MES factory.""" def get_solver(self, transformation): solver = super().get_solver(transformation) # Here, we can create essentially any custom excitation pool. # For testing purposes only, we simply select some hopping operator already # available in the variational form object. # pylint: disable=no-member custom_excitation_pool = [solver.var_form._hopping_ops[2]] solver.var_form.excitation_pool = custom_excitation_pool return solver solver = CustomFactory(QuantumInstance(BasicAer.get_backend('statevector_simulator'))) calc = AdaptVQE(self.transformation, solver) res = calc.solve(self.driver) self.assertAlmostEqual(res.electronic_energies[0], self.expected, places=6)
def test_qpe(self, qubit_op, simulator, num_time_slices, n_ancillae): """ QPE test """ self.log.debug('Testing QPE') exact_eigensolver = ExactEigensolver(qubit_op, k=1) results = exact_eigensolver.run() ref_eigenval = results['eigvals'][0] ref_eigenvec = results['eigvecs'][0] self.log.debug('The exact eigenvalue is: %s', ref_eigenval) self.log.debug('The corresponding eigenvector: %s', ref_eigenvec) state_in = Custom(qubit_op.num_qubits, state_vector=ref_eigenvec) iqft = Standard(n_ancillae) qpe = QPE(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: %s', result['top_measurement_label']) self.log.debug('top result in decimal: %s', result['top_measurement_decimal']) self.log.debug('stretch: %s', result['stretch']) self.log.debug('translation: %s', result['translation']) self.log.debug('final eigenvalue from QPE: %s', result['energy']) self.log.debug('reference eigenvalue: %s', ref_eigenval) self.log.debug('ref eigenvalue (transformed): %s', (ref_eigenval + result['translation']) * result['stretch']) self.log.debug('reference binary str label: %s', decimal_to_binary( (ref_eigenval.real + result['translation']) * result['stretch'], max_num_digits=n_ancillae + 3, fractional_part_only=True )) np.testing.assert_approx_equal(result['energy'], ref_eigenval.real, significant=2)
def test_qsvm_setup_data(self, data_preparation_type): """ QSVM Setup Data test """ ref_kernel_testing = np.array( [[0.1443953, 0.18170069, 0.47479649, 0.14691763], [0.33041779, 0.37663733, 0.02115561, 0.16106199]]) 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('statevector_simulator') data_preparation = self.data_preparation[data_preparation_type] try: if data_preparation_type == 'wrapped': warnings.filterwarnings('ignore', category=DeprecationWarning) svm = QSVM(data_preparation) if data_preparation_type == 'wrapped': warnings.filterwarnings('always', category=DeprecationWarning) svm.setup_training_data(self.training_data) svm.setup_test_data(self.testing_data) quantum_instance = QuantumInstance( backend, seed_transpiler=self.random_seed, seed_simulator=self.random_seed) result = svm.run(quantum_instance) np.testing.assert_array_almost_equal( result['kernel_matrix_testing'], ref_kernel_testing, decimal=4) self.assertEqual(len(result['svm']['support_vectors']), 4) np.testing.assert_array_almost_equal( result['svm']['support_vectors'], ref_support_vectors, decimal=4) self.assertEqual(result['testing_accuracy'], 0.5) except NameError as ex: self.skipTest(str(ex))
def test_uccsd_hf_qpUCCD(self): """ paired uccd test """ optimizer = SLSQP(maxiter=100) initial_state = HartreeFock( self.fermionic_transformation.molecule_info['num_orbitals'], self.fermionic_transformation.molecule_info['num_particles'], qubit_mapping=self.fermionic_transformation._qubit_mapping, two_qubit_reduction=self.fermionic_transformation. _two_qubit_reduction) var_form = UCCSD( num_orbitals=self.fermionic_transformation. molecule_info['num_orbitals'], num_particles=self.fermionic_transformation. molecule_info['num_particles'], active_occupied=None, active_unoccupied=None, initial_state=initial_state, qubit_mapping=self.fermionic_transformation._qubit_mapping, two_qubit_reduction=self.fermionic_transformation. _two_qubit_reduction, num_time_slices=1, shallow_circuit_concat=False, method_doubles='pucc', excitation_type='d') solver = VQE( var_form=var_form, optimizer=optimizer, quantum_instance=QuantumInstance( backend=BasicAer.get_backend('statevector_simulator'))) gsc = GroundStateEigensolver(self.fermionic_transformation, solver) result = gsc.solve(self.driver) self.assertAlmostEqual(result.energy, self.reference_energy_pUCCD, places=6)
def test_qpe(self, qubit_op, simulator, num_time_slices, n_ancillae): """Test the QPE algorithm.""" self.log.debug('Testing QPE') qubit_op = self._dict[qubit_op] exact_eigensolver = NumPyMinimumEigensolver(qubit_op) results = exact_eigensolver.run() ref_eigenval = results.eigenvalue ref_eigenvec = results.eigenstate self.log.debug('The exact eigenvalue is: %s', ref_eigenval) self.log.debug('The corresponding eigenvector: %s', ref_eigenvec) state_in = Custom(qubit_op.num_qubits, state_vector=ref_eigenvec) iqft = QFT(n_ancillae, do_swaps=False).inverse().reverse_bits() qpe = QPE(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, seed_transpiler=1, seed_simulator=1) # run qpe result = qpe.run(quantum_instance) # report result self.log.debug('top result str label: %s', result.top_measurement_label) self.log.debug('top result in decimal: %s', result.top_measurement_decimal) self.log.debug('stretch: %s', result.stretch) self.log.debug('translation: %s', result.translation) self.log.debug('final eigenvalue from QPE: %s', result.eigenvalue) self.log.debug('reference eigenvalue: %s', ref_eigenval) self.log.debug('ref eigenvalue (transformed): %s', (ref_eigenval + result.translation) * result.stretch) self.log.debug('reference binary str label: %s', decimal_to_binary( (ref_eigenval.real + result.translation) * result.stretch, max_num_digits=n_ancillae + 3, fractional_part_only=True )) self.assertAlmostEqual(result.eigenvalue.real, ref_eigenval.real, delta=2e-2)
def test_qsvm_multiclass_error_correcting_code(self, use_circuits): """ QSVM Multiclass error Correcting Code test """ training_input = {'A': np.asarray([[0.6560706, 0.17605998], [0.25776033, 0.47628296], [0.8690704, 0.70847635]]), 'B': np.asarray([[0.38857596, -0.33775802], [0.49946978, -0.48727951], [0.49156185, -0.3660534]]), 'C': np.asarray([[-0.68088231, 0.46824423], [-0.56167659, 0.65270294], [-0.82139073, 0.29941512]])} test_input = {'A': np.asarray([[0.57483139, 0.47120732], [0.48372348, 0.25438544], [0.48142649, 0.15931707]]), 'B': np.asarray([[-0.06048935, -0.48345293], [-0.01065613, -0.33910828], [0.06183066, -0.53376975]]), 'C': np.asarray([[-0.74561108, 0.27047295], [-0.69942965, 0.11885162], [-0.66489165, 0.1181712]])} total_array = np.concatenate((test_input['A'], test_input['B'], test_input['C'])) aqua_globals.random_seed = self.random_seed feature_map = SecondOrderExpansion(feature_dimension=get_feature_dimension(training_input), depth=2, entangler_map=[[0, 1]]) if use_circuits: x = ParameterVector('x', feature_map.feature_dimension) feature_map = feature_map.construct_circuit(x) feature_map.ordered_parameters = list(x) try: svm = QSVM(feature_map, training_input, test_input, total_array, multiclass_extension=ErrorCorrectingCode(code_size=5)) quantum_instance = QuantumInstance(BasicAer.get_backend('qasm_simulator'), shots=self.shots, seed_simulator=aqua_globals.random_seed, seed_transpiler=aqua_globals.random_seed) result = svm.run(quantum_instance) self.assertAlmostEqual(result['testing_accuracy'], 0.444444444, places=4) self.assertEqual(result['predicted_classes'], ['A', 'A', 'C', 'A', 'A', 'A', 'A', 'C', 'C']) except NameError as ex: self.skipTest(str(ex))
def test_tapered_op(self): # set_qiskit_chemistry_logging(logging.DEBUG) tapered_ops = [] for coeff in itertools.product([1, -1], repeat=len(self.sq_list)): tapered_op = Operator.qubit_tapering(self.qubit_op, self.cliffords, self.sq_list, list(coeff)) tapered_ops.append((list(coeff), tapered_op)) smallest_idx = 0 # Prior knowledge of which tapered_op has ground state the_tapered_op = tapered_ops[smallest_idx][1] the_coeff = tapered_ops[smallest_idx][0] optimizer = SLSQP(maxiter=1000) init_state = HartreeFock(num_qubits=the_tapered_op.num_qubits, num_orbitals=self.core._molecule_info['num_orbitals'], qubit_mapping=self.core._qubit_mapping, two_qubit_reduction=self.core._two_qubit_reduction, num_particles=self.core._molecule_info['num_particles'], sq_list=self.sq_list) var_form = UCCSD(num_qubits=the_tapered_op.num_qubits, depth=1, num_orbitals=self.core._molecule_info['num_orbitals'], num_particles=self.core._molecule_info['num_particles'], active_occupied=None, active_unoccupied=None, initial_state=init_state, qubit_mapping=self.core._qubit_mapping, two_qubit_reduction=self.core._two_qubit_reduction, num_time_slices=1, cliffords=self.cliffords, sq_list=self.sq_list, tapering_values=the_coeff, symmetries=self.symmetries) algo = VQE(the_tapered_op, var_form, optimizer, 'matrix') backend = BasicAer.get_backend('statevector_simulator') quantum_instance = QuantumInstance(backend=backend) algo_result = algo.run(quantum_instance) lines, result = self.core.process_algorithm_result(algo_result) self.assertAlmostEqual(result['energy'], self.reference_energy, places=6)
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 ExactLSsolver ref_result = ExactLSsolver(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_hhl_diagonal_longdivison(self, vector): """ hhl diagonal long division test """ self.log.debug('Testing HHL simple test in mode LongDivision and statevector simulator') matrix = [[1, 0], [0, 1]] # run ExactLSsolver ref_result = ExactLSsolver(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, 3, False) num_q, num_a = eigs.get_register_sizes() # Initialize initial state module init_state = Custom(num_q, state_vector=vector) # Initialize reciprocal reci = LongDivision(scale=1.0, 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 results fidelity = state_fidelity(ref_normed, hhl_normed) np.testing.assert_approx_equal(fidelity, 1, significant=5) self.log.debug('HHL solution vector: %s', hhl_solution) self.log.debug('algebraic solution vector: %s', ref_normed) self.log.debug('fidelity HHL to algebraic: %s', fidelity) self.log.debug('probability of result: %s', hhl_result["probability_result"])
def test_application(self): """Test an end-to-end application.""" a_n = np.eye(2) b = np.zeros(2) num_qubits = [2, 2] # specify the lower and upper bounds for the different dimension bounds = [(0, 0.12), (0, 0.24)] mu = [0.12, 0.24] sigma = 0.01 * np.eye(2) # construct corresponding distribution dist = NormalDistribution(num_qubits, mu, sigma, bounds=bounds) # specify cash flow c_f = [1.0, 2.0] # specify approximation factor rescaling_factor = 0.125 # get fixed income circuit appfactory fixed_income = FixedIncomeExpectedValue(num_qubits, a_n, b, c_f, rescaling_factor, bounds) # build state preparation operator state_preparation = fixed_income.compose(dist, front=True) # run simulation iae = IterativeAmplitudeEstimation( epsilon=0.01, alpha=0.05, state_preparation=state_preparation, post_processing=fixed_income.post_processing) backend = QuantumInstance(Aer.get_backend('qasm_simulator'), seed_simulator=2, seed_transpiler=2) result = iae.run(backend) # compare to precomputed solution self.assertAlmostEqual(result.estimation, 2.3389012822103044)
def test_vqc_on_wine(self, mode): """Test VQE on the wine test using circuits as feature map and variational form.""" aqua_globals.random_seed = 27521 if mode == 'wrapped' else 2752 feature_dim = 4 # dimension of each data point training_dataset_size = 6 testing_dataset_size = 3 _, training_input, test_input, _ = wine( training_size=training_dataset_size, test_size=testing_dataset_size, n=feature_dim, plot_data=False) ref_accuracy = 0.2 if mode == 'wrapped': warnings.filterwarnings('ignore', category=DeprecationWarning) data_preparation = SecondOrderExpansion(feature_dim) wavefunction = RYRZ(feature_dim, depth=1) else: data_preparation = ZZFeatureMap(feature_dim) wavefunction = TwoLocal(feature_dim, ['ry', 'rz'], 'cz', reps=1, insert_barriers=True) if mode == 'circuit': data_preparation = QuantumCircuit(feature_dim).compose( data_preparation) wavefunction = QuantumCircuit(feature_dim).compose( wavefunction) vqc = VQC(COBYLA(maxiter=100), data_preparation, wavefunction, training_input, test_input) if mode == 'wrapped': warnings.filterwarnings('always', category=DeprecationWarning) result = vqc.run( QuantumInstance(BasicAer.get_backend('statevector_simulator'), shots=1024, seed_simulator=aqua_globals.random_seed, seed_transpiler=aqua_globals.random_seed)) self.assertGreater(result['testing_accuracy'], ref_accuracy)
def test_h2_two_qubits_statevector(self): """Test H2 with parity mapping and statevector backend.""" two_qubit_reduction = True qubit_mapping = 'parity' warnings.filterwarnings('ignore', category=DeprecationWarning) core = Hamiltonian(transformation=TransformationType.FULL, qubit_mapping=QubitMappingType.PARITY, two_qubit_reduction=two_qubit_reduction, freeze_core=False, orbital_reduction=[]) warnings.filterwarnings('always', category=DeprecationWarning) qubit_op, _ = core.run(self.molecule) num_orbitals = core.molecule_info['num_orbitals'] num_particles = core.molecule_info['num_particles'] initial_state = HartreeFock(num_orbitals=num_orbitals, num_particles=num_particles, qubit_mapping=qubit_mapping, two_qubit_reduction=two_qubit_reduction) var_form = UCCSD(num_orbitals=num_orbitals, num_particles=num_particles, initial_state=initial_state, qubit_mapping=qubit_mapping, two_qubit_reduction=two_qubit_reduction) optimizer = COBYLA(maxiter=1000, tol=1e-8) eom_vqe = QEomVQE(qubit_op, var_form, optimizer, num_orbitals=num_orbitals, num_particles=num_particles, qubit_mapping=qubit_mapping, two_qubit_reduction=two_qubit_reduction) backend = BasicAer.get_backend('statevector_simulator') quantum_instance = QuantumInstance(backend) result = eom_vqe.run(quantum_instance) np.testing.assert_array_almost_equal(self.reference, result['energies'], decimal=4)
def test_vqe(self): """Test VQE with gradients""" method = 'lin_comb' backend = 'qasm_simulator' q_instance = QuantumInstance(BasicAer.get_backend(backend), seed_simulator=79, seed_transpiler=2) # Define the Hamiltonian h2_hamiltonian = -1.05 * (I ^ I) + 0.39 * (I ^ Z) - 0.39 * (Z ^ I) \ - 0.01 * (Z ^ Z) + 0.18 * (X ^ X) h2_energy = -1.85727503 # Define the Ansatz wavefunction = QuantumCircuit(2) params = ParameterVector('theta', length=8) itr = iter(params) wavefunction.ry(next(itr), 0) wavefunction.ry(next(itr), 1) wavefunction.rz(next(itr), 0) wavefunction.rz(next(itr), 1) wavefunction.cx(0, 1) wavefunction.ry(next(itr), 0) wavefunction.ry(next(itr), 1) wavefunction.rz(next(itr), 0) wavefunction.rz(next(itr), 1) # Conjugate Gradient algorithm optimizer = CG(maxiter=10) grad = Gradient(grad_method=method) # Gradient callable vqe = VQE(h2_hamiltonian, wavefunction, optimizer=optimizer, gradient=grad) result = vqe.run(q_instance) np.testing.assert_almost_equal(result['optimal_value'], h2_energy, decimal=0)
def test_vqc(self, mode): """ vqc 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) 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_expected_value(self, simulator): # can be used in case a principal component analysis has been done to derive the uncertainty model, ignored in this example. A = np.eye(2) b = np.zeros(2) # specify the number of qubits that are used to represent the different dimenions of the uncertainty model num_qubits = [2, 2] # specify the lower and upper bounds for the different dimension low = [0, 0] high = [0.12, 0.24] mu = [0.12, 0.24] sigma = 0.01 * np.eye(2) # construct corresponding distribution u = MultivariateNormalDistribution(num_qubits, low, high, mu, sigma) # specify cash flow cf = [1.0, 2.0] # specify approximation factor c_approx = 0.125 # get fixed income circuit appfactory fixed_income = FixedIncomeExpectedValue(u, A, b, cf, c_approx) # set number of evaluation qubits (samples) m = 5 # construct amplitude estimation ae = AmplitudeEstimation(m, fixed_income) # run simulation quantum_instance = QuantumInstance( BasicAer.get_backend('statevector_simulator')) result = ae.run(quantum_instance=quantum_instance) # compare to precomputed solution self.assertEqual(0.0, np.round(result['estimation'] - 2.4600, decimals=4))
def test_uccsd_hf_aer_statevector(self): """ uccsd hf test with Aer statevector """ 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('statevector_simulator') solver = VQE(var_form=self.var_form, optimizer=self.optimizer, 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=6)
def test_vqe_optimizer(self): """ Test running same VQE twice to re-use optimizer, then switch optimizer """ vqe = VQE(self.h2_op, optimizer=SLSQP(), quantum_instance=QuantumInstance( BasicAer.get_backend('statevector_simulator'))) def run_check(): result = vqe.compute_minimum_eigenvalue() self.assertAlmostEqual(result.eigenvalue.real, -1.85727503, places=5) run_check() with self.subTest('Optimizer re-use'): run_check() with self.subTest('Optimizer replace'): vqe.optimizer = L_BFGS_B() run_check()
def main(): def tadaa(string): print(string) def incoming(string): input(string) API = "26f2e1b4b40ea8d23675f7c644437f38a7b16ba89d09963345b4549c37763401e9a00aa81041e9d3f560c71cb24c1d02a6c142f2cac3d6fa668f786c0e467e49" IBMQ.enable_account(API) provider = IBMQ.get_provider(hub="ibm-q") backend = provider.get_backend("ibmq_qasm_simulator") tadaa("\n Shor Algorithm") tadaa("\n --------------") tadaa("\n Executing.....") factors = Shor(21) result_dict = factors.run( QuantumInstance(backend, shots=1, skip_qobj_validation=False)) result = result_dict['factors'] # Get factors from results tadaa(result) tadaa("\n Press any ket to close.") incoming()
def test_end2end_h2(self, name, optimizer, backend, mode, shots): if optimizer == 'COBYLA': optimizer = COBYLA() optimizer.set_options(maxiter=1000) elif optimizer == 'SPSA': optimizer = SPSA(max_trials=2000) ryrz = RYRZ(self.algo_input.qubit_op.num_qubits, depth=3, entanglement='full') vqe = VQE(self.algo_input.qubit_op, ryrz, optimizer, mode, aux_operators=self.algo_input.aux_ops) quantum_instance = QuantumInstance(backend, shots=shots) results = vqe.run(quantum_instance) self.assertAlmostEqual(results['energy'], self.reference_energy, places=4)