def run(self, M): """ Performs the optimization. Args: M: number of measurements per iteration Returns: (best_params, cost_history) where best_params: calculated values for ["θ_y", "θ_x"] (as list) cost_history: costs for each iteration (as list) """ # Clear costs log self.cost_history = [] # Use SPSA as our classical optimizer optimizer = SPSA() # Define cost function def cost_(params): return self.cost(params, M) # Randomize initial point initial_point = [np.random.rand() * np.pi for _ in range(2)] # Perform optimization best_params, _, _ = optimizer.optimize( num_vars=2, objective_function=cost_, variable_bounds=[(0, 2 * np.pi)] * 2, initial_point=initial_point) return best_params, self.cost_history
def __init__( self, max_iter=200, # Minimizer iterations. n_g=1, # Averaging number ): from qiskit.aqua.components.optimizers import SPSA self.optimizer = SPSA(max_trials=max_iter, last_avg=n_g)
def optimize(self, maxiter=500): thetas = np.array(self.qri.generate(self.num_qubits)) / 32 spsa = SPSA(maxiter=maxiter) minima, _, _ = spsa.optimize(self.num_qubits, self._objective_fn, initial_point=thetas) self.minima = list(minima)
def minimize(self, cost_function, initial_params=None): """ Minimizes given cost function using optimizers from Qiskit Aqua. Args: cost_function(): python method which takes numpy.ndarray as input initial_params(np.ndarray): initial parameters to be used for optimization Returns: optimization_results(scipy.optimize.OptimizeResults): results of the optimization. """ history = [] if self.method == "SPSA": optimizer = SPSA(**self.options) elif self.method == "ADAM" or self.method == "AMSGRAD": if self.method == "AMSGRAD": self.options["amsgrad"] = True optimizer = ADAM(**self.options) number_of_variables = len(initial_params) if self.keep_value_history: cost_function_wrapper = recorder(cost_function) else: cost_function_wrapper = _CostFunctionWrapper(cost_function) gradient_function = None if hasattr(cost_function, "gradient") and callable( getattr(cost_function, "gradient")): gradient_function = cost_function.gradient solution, value, nit = optimizer.optimize( num_vars=number_of_variables, objective_function=cost_function_wrapper, initial_point=initial_params, gradient_function=gradient_function, ) if self.keep_value_history: nfev = len(cost_function_wrapper.history) history = cost_function_wrapper.history else: nfev = cost_function_wrapper.number_of_calls history = [] return optimization_result( opt_value=value, opt_params=solution, nit=nit, history=history, nfev=nfev, )
def test_vqc_with_max_evals_grouped(self): """ 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) feature_map = SecondOrderExpansion( feature_dimension=get_feature_dimension(self.training_data), depth=2) var_form = RYRZ(num_qubits=feature_map.num_qubits, depth=3) vqc = VQC(optimizer, feature_map, var_form, self.training_data, self.testing_data, max_evals_grouped=2) 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) np.testing.assert_array_almost_equal(result['opt_params'], self.ref_opt_params, decimal=8) np.testing.assert_array_almost_equal(result['training_loss'], self.ref_train_loss, decimal=8) self.assertEqual(1.0, result['testing_accuracy'])
def test_set_packing_vqe(self): """ set packing vqe 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 aqua_globals.random_seed = 50 result = VQE(self.qubit_op, RY(self.qubit_op.num_qubits, depth=5, entanglement='linear'), SPSA(max_trials=200), max_evals_grouped=2).run( QuantumInstance( Aer.get_backend('qasm_simulator'), seed_simulator=aqua_globals.random_seed, seed_transpiler=aqua_globals.random_seed)) x = sample_most_likely(result['eigvecs'][0]) ising_sol = set_packing.get_solution(x) oracle = self._brute_force() self.assertEqual(np.count_nonzero(ising_sol), oracle)
def test_with_aer_qasm(self): """Test VQE with Aer's 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) wavefunction = self.ry_wavefunction vqe = VQE(self.h2_op, wavefunction, optimizer, expectation=PauliExpectation()) quantum_instance = QuantumInstance( backend, seed_simulator=aqua_globals.random_seed, seed_transpiler=aqua_globals.random_seed) result = vqe.run(quantum_instance) self.assertAlmostEqual(result.eigenvalue.real, -1.86305, places=2)
def test_h2_one_qubit_qasm(self): """Test H2 with tapering and qasm backend""" two_qubit_reduction = True qubit_mapping = 'parity' core = Hamiltonian(transformation=TransformationType.FULL, qubit_mapping=QubitMappingType.PARITY, two_qubit_reduction=two_qubit_reduction, freeze_core=False, orbital_reduction=[]) qubit_op, _ = core.run(self.molecule) num_orbitals = core.molecule_info['num_orbitals'] num_particles = core.molecule_info['num_particles'] # tapering z2_symmetries = Z2Symmetries.find_Z2_symmetries(qubit_op) # know the sector tapered_op = z2_symmetries.taper(qubit_op)[1] var_form = RY(tapered_op.num_qubits, depth=1) optimizer = SPSA(max_trials=50) eom_vqe = QEomVQE(tapered_op, var_form, optimizer, num_orbitals=num_orbitals, num_particles=num_particles, qubit_mapping=qubit_mapping, two_qubit_reduction=two_qubit_reduction, z2_symmetries=tapered_op.z2_symmetries, untapered_op=qubit_op) backend = BasicAer.get_backend('qasm_simulator') quantum_instance = QuantumInstance(backend, shots=65536) result = eom_vqe.run(quantum_instance) np.testing.assert_array_almost_equal(self.reference, result['energies'], decimal=2)
def test_vqe_2_iqpe(self): """ vqe to iqpe test """ backend = BasicAer.get_backend('qasm_simulator') num_qbits = self.qubit_op.num_qubits wavefunction = TwoLocal(num_qbits, ['ry', 'rz'], 'cz', reps=3, insert_barriers=True) optimizer = SPSA(maxiter=10) algo = VQE(self.qubit_op, wavefunction, optimizer) quantum_instance = QuantumInstance(backend, seed_simulator=self.seed, seed_transpiler=self.seed) result = algo.run(quantum_instance) self.log.debug('VQE result: %s.', result) ref_eigenval = -1.85727503 # Known reference value num_time_slices = 1 num_iterations = 6 param_dict = result.optimal_parameters state_in = VarFormBased(wavefunction, param_dict) iqpe = IQPE(self.qubit_op, state_in, num_time_slices, num_iterations, expansion_mode='suzuki', expansion_order=2, shallow_circuit_concat=True) quantum_instance = QuantumInstance(backend, shots=100, seed_transpiler=self.seed, seed_simulator=self.seed) result = iqpe.run(quantum_instance) 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=num_iterations + 3, fractional_part_only=True)) self.assertAlmostEqual(result.eigenvalue.real, ref_eigenval.real, delta=1e-2)
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.energy, -1.138, places=2)
def test_vqc_statevector(self, mode): """ vqc statevector test """ aqua_globals.random_seed = 2752 optimizer = SPSA(max_trials=100, 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('statevector_simulator'), seed_simulator=aqua_globals.random_seed, seed_transpiler=aqua_globals.random_seed) result = vqc.run(quantum_instance) with self.subTest('training loss'): self.assertGreater(result['training_loss'], 0.10, 2) with self.subTest('accuracy'): self.assertEqual(result['testing_accuracy'], 0.0 if mode == 'wrapped' else 0.5)
def test_set_packing_vqe(self): """ set packing vqe 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 wavefunction = TwoLocal(rotation_blocks='ry', entanglement_blocks='cz', reps=3, entanglement='linear') result = VQE(self.qubit_op, wavefunction, SPSA(maxiter=200), max_evals_grouped=2).run( QuantumInstance( Aer.get_backend('qasm_simulator'), seed_simulator=aqua_globals.random_seed, seed_transpiler=aqua_globals.random_seed)) x = sample_most_likely(result.eigenstate) ising_sol = set_packing.get_solution(x) oracle = self._brute_force() self.assertEqual(np.count_nonzero(ising_sol), oracle)
def run_IBM(H=None, backend=None, num_samples=100, qaoa_steps=3, variables=None): num_vars = len(list(H.linear)) qubit_op, offset = get_ising_opt_qubitops(H, variables) if backend == None: backend = BasicAer.get_backend('qasm_simulator') quantum_instance = QuantumInstance(backend) spsa = SPSA(max_trials=10) qaoa = QAOA(qubit_op, spsa, qaoa_steps) result = qaoa.run(quantum_instance) circ = qaoa.get_optimal_circuit() q = circ.qregs[0] c = ClassicalRegister(num_vars, 'c') circ.cregs.append(c) circ.measure(q, c) job = execute(circ, backend, shots=num_samples, memory=True) return job.result().get_counts(circ)
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:]) # Fix the random seed of SPSA (Optional) from qiskit.aqua import aqua_globals aqua_globals.random_seed = 123 # --- Exact copy of sample code ---------------------------------------- import networkx as nx import numpy as np from qiskit.optimization import QuadraticProgram from qiskit.optimization.algorithms import MinimumEigenOptimizer from qiskit import BasicAer from qiskit.aqua.algorithms import QAOA from qiskit.aqua.components.optimizers import SPSA # Generate a graph of 4 nodes n = 4 graph = nx.Graph() graph.add_nodes_from(np.arange(0, n, 1)) elist = [(0, 1, 1.0), (0, 2, 1.0), (0, 3, 1.0), (1, 2, 1.0), (2, 3, 1.0)] graph.add_weighted_edges_from(elist) # Compute the weight matrix from the graph w = nx.adjacency_matrix(graph) # Formulate the problem as quadratic program problem = QuadraticProgram() _ = [problem.binary_var('x{}'.format(i)) for i in range(n)] # create n binary variables linear = w.dot(np.ones(n)) quadratic = -w problem.maximize(linear=linear, quadratic=quadratic) # Fix node 0 to be 1 to break the symmetry of the max-cut solution problem.linear_constraint([1, 0, 0, 0], '==', 1) # Run quantum algorithm QAOA on qasm simulator spsa = SPSA(maxiter=250) backend = BasicAer.get_backend('qasm_simulator') qaoa = QAOA(optimizer=spsa, p=5, quantum_instance=backend) algorithm = MinimumEigenOptimizer(qaoa) result = algorithm.solve(problem) print(result) # prints solution, x=[1, 0, 1, 0], the cost, fval=4 # ---------------------------------------------------------------------- np.testing.assert_array_almost_equal(result.x, [1, 0, 1, 0]) self.assertAlmostEqual(result.fval, 4.0)
def setUp(self): super().setUp() self.seed = 50 aqua_globals.random_seed = self.seed self.training_data = { 'A': np.asarray([[2.95309709, 2.51327412], [3.14159265, 4.08407045]]), 'B': np.asarray([[4.08407045, 2.26194671], [4.46106157, 2.38761042]]) } self.testing_data = { 'A': np.asarray([[3.83274304, 2.45044227]]), 'B': np.asarray([[3.89557489, 0.31415927]]) } self.ref_opt_params = np.array([ 0.47352206, -3.75934473, 1.72605939, -4.17669389, 1.28937435, -0.05841719, -0.29853266, -2.04139334, 1.00271775, -1.48133882, -1.18769138, 1.17885493, 7.58873883, -5.27078091, 2.5306601, -4.67393152 ]) self.ref_opt_params = np.array([ 4.40301812e-01, 2.10844304, -2.10118578, -5.25903194, 2.07617769, -9.25865371, -5.33834788, 8.59005180, 3.39886480, 6.33839643, 1.24425033, -1.39701513e+01, -7.16008545e-03, 3.36206032, 4.38001391, -3.47098082 ]) self.ref_train_loss = 0.5869304 self.ref_prediction_a_probs = [[0.8984375, 0.1015625]] self.ref_prediction_a_label = [0] self.ryrz_wavefunction = TwoLocal(2, ['ry', 'rz'], 'cz', reps=3, insert_barriers=True) self.data_preparation = ZZFeatureMap(2, reps=2) self.statevector_simulator = QuantumInstance( BasicAer.get_backend('statevector_simulator'), shots=1, seed_simulator=self.seed, seed_transpiler=self.seed) self.qasm_simulator = QuantumInstance( BasicAer.get_backend('qasm_simulator'), shots=1024, seed_simulator=self.seed, seed_transpiler=self.seed) self.spsa = SPSA(maxiter=10, save_steps=1, c0=4.0, c1=0.1, c2=0.602, c3=0.101, c4=0.0, skip_calibration=True)
def test_feature_map_without_parameters_warns(self): """Test that specifying a feature map with 0 parameters raises a warning.""" aqua_globals.random_seed = self.seed var_form = QuantumCircuit(1) var_form.ry(Parameter('a'), 0) feature_map = QuantumCircuit(1) optimizer = SPSA() with self.assertWarns(UserWarning): _ = VQC(optimizer, feature_map, var_form, self.training_data, self.testing_data)
def test_vqe_qasm(self): backend = BasicAer.get_backend('qasm_simulator') num_qubits = self.algo_input.qubit_op.num_qubits var_form = RY(num_qubits, 3) optimizer = SPSA(max_trials=300, last_avg=5) algo = VQE(self.algo_input.qubit_op, var_form, optimizer, max_evals_grouped=1) quantum_instance = QuantumInstance(backend, shots=10000, optimization_level=0) result = algo.run(quantum_instance) self.assertAlmostEqual(result['energy'], -1.85727503, places=2)
def test_save_and_load_model(self): """ save and load model test """ np.random.seed(self.random_seed) aqua_globals.random_seed = self.random_seed backend = BasicAer.get_backend('qasm_simulator') num_qubits = 2 optimizer = SPSA(max_trials=10, save_steps=1, c0=4.0, skip_calibration=True) 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, self.training_data, self.testing_data) quantum_instance = QuantumInstance(backend, shots=1024, seed_simulator=self.random_seed, seed_transpiler=self.random_seed) result = vqc.run(quantum_instance) np.testing.assert_array_almost_equal(result['opt_params'], self.ref_opt_params, decimal=4) np.testing.assert_array_almost_equal(result['training_loss'], self.ref_train_loss, decimal=8) self.assertEqual(1.0, result['testing_accuracy']) file_path = self._get_resource_path('vqc_test.npz') vqc.save_model(file_path) self.assertTrue(os.path.exists(file_path)) loaded_vqc = VQC(optimizer, feature_map, var_form, self.training_data, None) loaded_vqc.load_model(file_path) np.testing.assert_array_almost_equal( loaded_vqc.ret['opt_params'], self.ref_opt_params, decimal=4) loaded_test_acc = loaded_vqc.test(vqc.test_dataset[0], vqc.test_dataset[1], quantum_instance) self.assertEqual(result['testing_accuracy'], loaded_test_acc) predicted_probs, predicted_labels = loaded_vqc.predict(self.testing_data['A'], quantum_instance) np.testing.assert_array_almost_equal(predicted_probs, self.ref_prediction_a_probs, decimal=8) np.testing.assert_array_equal(predicted_labels, self.ref_prediction_a_label) if quantum_instance.has_circuit_caching: self.assertLess(quantum_instance._circuit_cache.misses, 3) if os.path.exists(file_path): try: os.remove(file_path) except Exception: # pylint: disable=broad-except pass
def test_vqe_2_iqpe(self): """ vqe to iqpe test """ backend = BasicAer.get_backend('qasm_simulator') num_qbits = self.algo_input.qubit_op.num_qubits var_form = RYRZ(num_qbits, 3) optimizer = SPSA(max_trials=10) # optimizer.set_options(**{'max_trials': 500}) algo = VQE(self.algo_input.qubit_op, var_form, optimizer) quantum_instance = QuantumInstance(backend, seed_simulator=self.seed, seed_transpiler=self.seed) result = algo.run(quantum_instance) self.log.debug('VQE result: %s.', result) ref_eigenval = -1.85727503 num_time_slices = 1 num_iterations = 6 state_in = VarFormBased(var_form, result['opt_params']) iqpe = IQPE(self.algo_input.qubit_op, state_in, num_time_slices, num_iterations, expansion_mode='suzuki', expansion_order=2, shallow_circuit_concat=True) quantum_instance = QuantumInstance(backend, shots=100, seed_transpiler=self.seed, seed_simulator=self.seed) result = iqpe.run(quantum_instance) 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 + result['translation']) * result['stretch'], max_num_digits=num_iterations + 3, fractional_part_only=True)) np.testing.assert_approx_equal(result['energy'], ref_eigenval, significant=2)
def test_basic_aer_qasm(self): """Test the VQE on BasicAer's QASM simulator.""" optimizer = SPSA(max_trials=300, last_avg=5) wavefunction = self.ry_wavefunction vqe = VQE(self.h2_op, wavefunction, optimizer, max_evals_grouped=1) # TODO benchmark this later. result = vqe.run(self.qasm_simulator) self.assertAlmostEqual(result.eigenvalue.real, -1.86823, places=2)
def run_simulation(self, backend): seed = int(os.environ.get("SEED", "40598")) n = int(os.environ.get("N", "4")) # # Random 3-regular graph with 12 nodes # graph = nx.random_regular_graph(3, n, seed=seed) for e in graph.edges(): graph[e[0]][e[1]]["weight"] = 1.0 # Compute the weight matrix from the graph w = np.zeros([n, n]) for i in range(n): for j in range(n): temp = graph.get_edge_data(i, j, default=0) if temp != 0: w[i, j] = temp["weight"] # Create an Ising Hamiltonian with docplex. mdl = Model(name="max_cut") mdl.node_vars = mdl.binary_var_list(list(range(n)), name="node") maxcut_func = mdl.sum(w[i, j] * mdl.node_vars[i] * (1 - mdl.node_vars[j]) for i in range(n) for j in range(n)) mdl.maximize(maxcut_func) qubit_op, offset = docplex.get_operator(mdl) aqua_globals.random_seed = seed # Run quantum algorithm QAOA on qasm simulator spsa = SPSA(max_trials=250) qaoa = QAOA(qubit_op, spsa, p=5, max_evals_grouped=4) quantum_instance = QuantumInstance( backend, shots=1024, seed_simulator=seed, seed_transpiler=seed, optimization_level=0, ) result = qaoa.run(quantum_instance) x = sample_most_likely(result["eigvecs"][0]) result["solution"] = max_cut.get_graph_solution(x) result["solution_objective"] = max_cut.max_cut_value(x, w) result["maxcut_objective"] = result["energy"] + offset """ print("energy:", result["energy"]) print("time:", result["eval_time"]) print("max-cut objective:", result["energy"] + offset) print("solution:", max_cut.get_graph_solution(x)) print("solution objective:", max_cut.max_cut_value(x, w)) """ return result
def make_opt(opt_str): if opt_str == "spsa": optimizer = SPSA(max_trials=100, save_steps=1, c0=4.0, skip_calibration=True) elif opt_str == "cobyla": optimizer = COBYLA(maxiter=1000, disp=False, rhobeg=1.0, tol=None) elif opt_str == "adam": optimizer = ADAM(maxiter=10000, tol=1e-6, lr=1e-3, beta_1=0.9, beta_2=0.99, noise_factor=1e-8, eps=1e-10) else: print('error in building OPTIMIZER: {} IT DOES NOT EXIST'.format(opt_str)) sys.exit(1) return optimizer
def test_vqe_2_iqpe(self): backend = get_aer_backend('qasm_simulator') num_qbits = self.algo_input.qubit_op.num_qubits var_form = RYRZ(num_qbits, 3) optimizer = SPSA(max_trials=10) # optimizer.set_options(**{'max_trials': 500}) algo = VQE(self.algo_input.qubit_op, var_form, optimizer, 'paulis') quantum_instance = QuantumInstance(backend) result = algo.run(quantum_instance) self.log.debug('VQE result: {}.'.format(result)) self.ref_eigenval = -1.85727503 num_time_slices = 50 num_iterations = 11 state_in = VarFormBased(var_form, result['opt_params']) iqpe = IQPE(self.algo_input.qubit_op, state_in, num_time_slices, num_iterations, expansion_mode='suzuki', expansion_order=2, shallow_circuit_concat=True) quantum_instance = QuantumInstance(backend, shots=100, pass_manager=PassManager(), seed_mapper=self.random_seed) result = iqpe.run(quantum_instance) 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 + result['translation']) * result['stretch'], max_num_digits=num_iterations + 3, fractional_part_only=True))) np.testing.assert_approx_equal(self.ref_eigenval, result['energy'], significant=2)
def test_same_parameter_names_raises(self): """Test that the varform and feature map can have parameters with the same name.""" var_form = QuantumCircuit(1) var_form.ry(Parameter('a'), 0) feature_map = QuantumCircuit(1) feature_map.rz(Parameter('a'), 0) optimizer = SPSA() vqc = VQC(optimizer, feature_map, var_form, self.training_data, self.testing_data) with self.assertRaises(AquaError): _ = vqc.run(BasicAer.get_backend('statevector_simulator'))
def test_vqe_qasm(self): """ VQE QASM test """ backend = BasicAer.get_backend('qasm_simulator') num_qubits = self.qubit_op.num_qubits var_form = RY(num_qubits, 3) optimizer = SPSA(max_trials=300, last_avg=5) algo = VQE(self.qubit_op, var_form, optimizer, max_evals_grouped=1) quantum_instance = QuantumInstance(backend, shots=10000, seed_simulator=self.seed, seed_transpiler=self.seed) result = algo.run(quantum_instance) self.assertAlmostEqual(result.eigenvalue.real, -1.85727503, places=2)
def getOptimiser(name="SPSA", params={}): optimiser = None if 'SPSA' in name: #max_trials (int) – Maximum number of iterations to perform. #save_steps (int) – Save intermeditate info every save_steps step. #last_avg (int) – Averged parameters over the last_avg iterations. If last_avg = 1, only the last iteration is considered. #c0 (float) – The initial a. Step size to update paramters. #c1 (float) – The initial c. The step size used to approximate gradient. #c2 (float) – The alpha in the paper, and it is used to adjust a (c0) at each iteration. #c3 (float) – The gamma in the paper, and it is used to adjust c (c1) at each iteration. #c4 (float) – The parameter used to control a as well. #skip_calibration (bool) – skip calibration and use provided c(s) as is. optimiser = SPSA( max_trials=params["max_trials"], save_steps=params["save_steps"], ) elif 'COBYLA' in name: #maxiter (int) – Maximum number of function evaluations. #disp (bool) – Set to True to print convergence messages. #rhobeg (float) – Reasonable initial changes to the variables. #tol (float) – Final accuracy in the optimization (not precisely guaranteed). This is a lower bound on the size of the trust region. optimiser = COBYLA(maxiter=params["maxiter"], disp=True) elif 'L_BFGS_B' in name: #maxfun (int) – Maximum number of function evaluations. #maxiter (int) – Maximum number of iterations. #factr (float) – The iteration stops when (f^k - f^{k+1})/max{|f^k|, |f^{k+1}|,1} <= factr * eps, where eps is the machine precision, which is automatically generated by the code. Typical values for factr are: 1e12 for low accuracy; 1e7 for moderate accuracy; 10.0 for extremely high accuracy. See Notes for relationship to ftol, which is exposed (instead of factr) by the scipy.optimize.minimize interface to L-BFGS-B. #iprint (int) – Controls the frequency of output. iprint < 0 means no output; iprint = 0 print only one line at the last iteration; 0 < iprint < 99 print also f and |proj g| every iprint iterations; iprint = 99 print details of every iteration except n-vectors; iprint = 100 print also the changes of active set and final x; iprint > 100 print details of every iteration including x and g. #epsilon (float) – Step size used when approx_grad is True, for numerically calculating the gradient optimiser = L_BFGS_B( #maxfun=params["maxfun"], maxiter=params["maxiter"]) elif 'P_BFGS' in name: optimiser = P_BFGS(maxfun=params["maxfun"]) elif 'NELDER_MEAD' in name: #maxiter (int) – Maximum allowed number of iterations. If both maxiter and maxfev are set, minimization will stop at the first reached. #maxfev (int) – Maximum allowed number of function evaluations. If both maxiter and maxfev are set, minimization will stop at the first reached. #disp (bool) – Set to True to print convergence messages. #xatol (float) – Absolute error in xopt between iterations that is acceptable for convergence. #tol (float or None) – Tolerance for termination. #adaptive (bool) – Adapt algorithm parameters to dimensionality of problem. optimiser = NELDER_MEAD(maxiter=params["maxiter"], disp=True) elif 'SLSQP' in name: #maxiter (int) – Maximum number of iterations. #disp (bool) – Set to True to print convergence messages. #ftol (float) – Precision goal for the value of f in the stopping criterion. #tol (float or None) – Tolerance for termination. #eps (float) – Step size used for numerical approximation of the Jacobian. optimiser = SLSQP(maxiter=params["maxiter"]) print("Optimising with {0} - {1}".format(name, optimiser)) return optimiser
def test_partition_vqe(self): """ Partition VQE test """ aqua_globals.random_seed = 100 result = VQE(self.qubit_op, RY(self.qubit_op.num_qubits, depth=5, entanglement='linear'), SPSA(max_trials=200), max_evals_grouped=2).run( QuantumInstance(BasicAer.get_backend('qasm_simulator'), seed_simulator=aqua_globals.random_seed, seed_transpiler=aqua_globals.random_seed)) x = sample_most_likely(result['eigvecs'][0]) self.assertNotEqual(x[0], x[1]) self.assertNotEqual(x[2], x[1]) # hardcoded oracle
def test_end2end_h2(self, name, optimizer, backend, shots): """ end to end h2 """ del name # unused if optimizer == 'COBYLA': optimizer = COBYLA() optimizer.set_options(maxiter=1000) elif optimizer == 'SPSA': optimizer = SPSA(max_trials=2000) ryrz = RYRZ(self.qubit_op.num_qubits, depth=3, entanglement='full') vqe = VQE(self.qubit_op, ryrz, optimizer, aux_operators=self.aux_ops) quantum_instance = QuantumInstance(backend, shots=shots) results = vqe.run(quantum_instance) self.assertAlmostEqual(results['energy'], self.reference_energy, places=4)
def test_uccsd_hf_qasm(self): """ uccsd hf test with qasm_simulator. """ backend = BasicAer.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 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) run_config = RunConfig(shots=shots, max_credits=10, memory=False) quantum_instance = QuantumInstance(backend, run_config) results = vqe.run(quantum_instance) self.assertAlmostEqual(results['energy'], self.reference_energy, places=4)