def createPlot(exactGroundStateEnergy=-1.14, numberOfIterations=1000, bondLength=0.735, initialParameters=None, numberOfParameters=16, shotsPerPoint=1000, registerSize=12, map_type='jordan_wigner'): if initialParameters is None: initialParameters = np.random.rand(numberOfParameters) global qubitOp global qr_size global shots global values global plottingTime plottingTime = True shots = shotsPerPoint qr_size = registerSize optimizer = COBYLA(maxiter=numberOfIterations) iterations = [] values = [] for i in range(numberOfIterations): iterations.append(i + 1) #Build molecule with PySCF driver = PySCFDriver(atom="H .0 .0 .0; H .0 .0 " + str(bondLength), unit=UnitsType.ANGSTROM, charge=0, spin=0, basis='sto3g') molecule = driver.run() repulsion_energy = molecule.nuclear_repulsion_energy num_spin_orbitals = molecule.num_orbitals * 2 num_particles = molecule.num_alpha + molecule.num_beta #Map fermionic operator to qubit operator and start optimization ferOp = FermionicOperator(h1=molecule.one_body_integrals, h2=molecule.two_body_integrals) qubitOp = ferOp.mapping(map_type=map_type, threshold=0.00000001) sol_opt = optimizer.optimize(numberOfParameters, energy_opt, gradient_function=None, variable_bounds=None, initial_point=initialParameters) #Adjust values to obtain Energy Error for i in range(len(values)): values[i] = values[i] + repulsion_energy - exactGroundStateEnergy #Saving and Plotting Data filename = 'Energy Error - Iterations' with open(filename, 'wb') as f: pickle.dump([iterations, values], f) plt.plot(iterations, values) plt.ylabel('Energy Error') plt.xlabel('Iterations') plt.show()
def __init__(self, ansatz: Ansatz, budget=120): super().__init__(ansatz) self.__similarity_thresh = 1e-2 self.sweep_count = 1 self.maxiter = 200 self.budget = budget self.sweep_divisions = 4 self.optimizer = COBYLA(maxiter=self.maxiter, tol=1e-3) self.objective_function = None self.sweepspace_dimension = None self.num_vars = None
def main(): # Parse all command line arguments args = parser.parse_args() shots = args.shots seed = args.seed basis = args.bell logfile = args.logfile verbose = args.verbose # Define the logger logger = logging.getLogger('task2') if logfile: logger.addHandler(logging.FileHandler(logfile)) if verbose: logger.addHandler(logging.StreamHandler()) logger.setLevel(logging.DEBUG) np.random.seed(seed=seed) # Get the noise model device_backend = FakeVigo() noise_model = NoiseModel.from_backend(device_backend) coupling_map = device_backend.configuration().coupling_map basis_gates = noise_model.basis_gates backend = Aer.get_backend('qasm_simulator') statevector_backend = Aer.get_backend('statevector_simulator') circuit = build_circuit(measure=basis) circuit_for_counts = build_circuit(measure='computational') unmeasured_circuit = build_circuit(measure=None) # qiskit's COBYLA can't take args to pass to the objective function, so we freeze them with functools.partial optimizer = COBYLA(maxiter=1000, tol=1e-8, disp=True) for nshots in shots: logger.debug('====================================================================================') logger.debug(f'\nShots per iteration: {nshots}') logger.debug(circuit) partial_objective_function = partial(objective_function, circuit=circuit, shots=nshots, backend=backend, bell_basis=(basis == 'bell'), noise_model=noise_model, coupling_map=coupling_map, basis_gates=basis_gates) ret = optimizer.optimize(num_vars=2, objective_function=partial_objective_function, initial_point=np.random.rand(len(circuit.parameters))*4*np.pi - 2*np.pi) params = ret[0] logger.debug(f'\nParameters:\n{params}') logger.debug(f'\nStatevector:\n{execute_circuit(unmeasured_circuit, params, statevector_backend).result().get_statevector()}') logger.debug(f'\nSimulated results:\n{execute_circuit(circuit_for_counts, params, backend, nshots, noise_model, coupling_map, basis_gates).result().get_counts()}') logger.debug('====================================================================================\n') sys.exit(ExitStatus.success)
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_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)
def setUp(self): super().setUp() self.driver1 = HDF5Driver( hdf5_input=self.get_resource_path('test_oovqe_h4.hdf5')) self.driver2 = HDF5Driver( hdf5_input=self.get_resource_path('test_oovqe_lih.hdf5')) self.driver3 = HDF5Driver( hdf5_input=self.get_resource_path('test_oovqe_h4_uhf.hdf5')) self.energy1_rotation = -3.0104 self.energy1 = -2.77 # energy of the VQE with pUCCD ansatz and LBFGSB optimizer self.energy2 = -7.70 self.energy3 = -2.50 self.initial_point1 = [ 0.039374, -0.47225463, -0.61891996, 0.02598386, 0.79045546, -0.04134567, 0.04944946, -0.02971617, -0.00374005, 0.77542149 ] self.seed = 50 self.optimizer = COBYLA(maxiter=1) self.transformation1 = \ FermionicTransformation(qubit_mapping=FermionicQubitMappingType.JORDAN_WIGNER, two_qubit_reduction=False) self.transformation2 = \ FermionicTransformation(qubit_mapping=FermionicQubitMappingType.JORDAN_WIGNER, two_qubit_reduction=False, freeze_core=True) self.quantum_instance = QuantumInstance( BasicAer.get_backend('statevector_simulator'), shots=1, seed_simulator=self.seed, seed_transpiler=self.seed)
def simulate(self, var_params): """ Evaluate the parameterized circuit for the input amplitudes. Args: var_params (list): The initial amplitudes (float64). Returns: float64: The total energy (energy). Raise: ValueError: If the dimension of the amplitude list is incorrect. """ if len(var_params) != self.amplitude_dimension: raise ValueError("Incorrect dimension for amplitude list.") # Use the Qiskit VQE class to perform a single energy evaluation from qiskit.aqua.components.optimizers import COBYLA cobyla = COBYLA(maxiter=0) vqe = VQE(self.qubit_hamiltonian, self.var_form, cobyla, initial_point=var_params) quantum_instance = QuantumInstance(backend=self.backend, shots=1000000) results = vqe.run(quantum_instance) energy = results['eigvals'][0] + self.nuclear_repulsion_energy # Save the amplitudes so we have the optimal ones for RDM calculation self.optimized_amplitudes = var_params return energy
def test_vqc_statevector(self, mode): """ vqc statevector test """ aqua_globals.random_seed = 10598 optimizer = COBYLA() 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 in ['circuit', 'library']: vqc._feature_map_params = self._sorted_data_params vqc._var_form_params = self._sorted_wavefunction_params else: 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) ref_train_loss = 0.1059404 np.testing.assert_array_almost_equal(result['training_loss'], ref_train_loss, decimal=4) self.assertEqual(result['testing_accuracy'], 0.5)
def test_qaoa_qc_mixer(self, w, prob, solutions, convert_to_matrix_op): """ QAOA test with a mixer as a parameterized circuit""" seed = 0 aqua_globals.random_seed = seed self.log.debug( 'Testing %s-step QAOA with MaxCut on graph with ' 'a mixer as a parameterized circuit\n%s', prob, w) backend = BasicAer.get_backend('statevector_simulator') optimizer = COBYLA() qubit_op, _ = max_cut.get_operator(w) qubit_op = qubit_op.to_opflow() if convert_to_matrix_op: qubit_op = qubit_op.to_matrix_op() num_qubits = qubit_op.num_qubits mixer = QuantumCircuit(num_qubits) theta = Parameter('θ') mixer.rx(theta, range(num_qubits)) qaoa = QAOA(qubit_op, optimizer, prob, mixer=mixer) quantum_instance = QuantumInstance(backend, seed_simulator=seed, seed_transpiler=seed) result = qaoa.run(quantum_instance) x = sample_most_likely(result.eigenstate) graph_solution = max_cut.get_graph_solution(x) self.assertIn(''.join([str(int(i)) for i in graph_solution]), solutions)
def test_qaoa_qc_mixer_many_parameters(self): """ QAOA test with a mixer as a parameterized circuit with the num of parameters > 1. """ seed = 0 aqua_globals.random_seed = seed optimizer = COBYLA() qubit_op, _ = max_cut.get_operator(W1) qubit_op = qubit_op.to_opflow() num_qubits = qubit_op.num_qubits mixer = QuantumCircuit(num_qubits) for i in range(num_qubits): theta = Parameter('θ' + str(i)) mixer.rx(theta, range(num_qubits)) qaoa = QAOA(qubit_op, optimizer=optimizer, p=2, mixer=mixer) backend = BasicAer.get_backend('statevector_simulator') quantum_instance = QuantumInstance(backend, seed_simulator=seed, seed_transpiler=seed) result = qaoa.run(quantum_instance) x = sample_most_likely(result.eigenstate) print(x) graph_solution = max_cut.get_graph_solution(x) self.assertIn(''.join([str(int(i)) for i in graph_solution]), S1)
def setUp(self): super().setUp() self.energy1_rotation = -3.0104 self.energy1 = -2.77 # energy of the VQE with pUCCD ansatz and LBFGSB optimizer self.energy2 = -7.70 self.energy3 = -2.50 self.initial_point1 = [0.039374, -0.47225463, -0.61891996, 0.02598386, 0.79045546, -0.04134567, 0.04944946, -0.02971617, -0.00374005, 0.77542149] self.seed = 50 aqua_globals.random_seed = self.seed self.quantum_instance = QuantumInstance(BasicAer.get_backend('statevector_simulator'), shots=1, seed_simulator=self.seed, seed_transpiler=self.seed) self.optimizer = COBYLA(maxiter=1) self.qmolecule1, self.core1, self.qubit_op1, self.var_form1, self.algo1\ = self._create_components_for_tests(path='test_oovqe_h4.hdf5', freeze_core=False, two_qubit_reduction=False, initial_point=self.initial_point1) self.qmolecule2, self.core2, self.qubit_op2, self.var_form2, self.algo2\ = self._create_components_for_tests(path='test_oovqe_lih.hdf5', freeze_core=True, two_qubit_reduction=True, initial_point=None) self.qmolecule3, self.core3, self.qubit_op3, self.var_form3, self.algo3\ = self._create_components_for_tests(path='test_oovqe_h4_uhf.hdf5', freeze_core=False, two_qubit_reduction=False, initial_point=self.initial_point1)
def test_qaoa(self, w, prob, m, solutions): """ QAOA test """ seed = 0 aqua_globals.random_seed = seed os.environ.pop('QISKIT_AQUA_CIRCUIT_CACHE', None) self.log.debug('Testing %s-step QAOA with MaxCut on graph\n%s', prob, w) backend = BasicAer.get_backend('statevector_simulator') optimizer = COBYLA() qubit_op, offset = max_cut.get_qubit_op(w) qaoa = QAOA(qubit_op, optimizer, prob, mixer=m) # TODO: cache fails for QAOA since we construct the evolution circuit via instruction quantum_instance = QuantumInstance(backend, circuit_caching=False, seed_simulator=seed, seed_transpiler=seed) result = qaoa.run(quantum_instance) x = sample_most_likely(result['eigvecs'][0]) graph_solution = max_cut.get_graph_solution(x) self.log.debug('energy: %s', result['energy']) self.log.debug('time: %s', result['eval_time']) self.log.debug('maxcut objective: %s', result['energy'] + offset) self.log.debug('solution: %s', graph_solution) self.log.debug('solution objective: %s', max_cut.max_cut_value(x, w)) self.assertIn(''.join([str(int(i)) for i in graph_solution]), solutions) if quantum_instance.has_circuit_caching: self.assertLess(quantum_instance._circuit_cache.misses, 3)
def test_vqc_minibatching_no_gradient_support(self, mode): """ 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') optimizer = COBYLA(maxiter=40) 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, 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, optimization_level=0) result = vqc.run(quantum_instance) self.assertGreaterEqual(result['testing_accuracy'], 0.5)
def test_qaoa_initial_point(self, w, solutions, init_pt): """ Check first parameter value used is initial point as expected """ optimizer = COBYLA() qubit_op, _ = max_cut.get_operator(w) first_pt = [] def cb_callback(eval_count, parameters, mean, std): nonlocal first_pt if eval_count == 1: first_pt = list(parameters) quantum_instance = QuantumInstance( BasicAer.get_backend('statevector_simulator')) qaoa = QAOA(qubit_op, optimizer, initial_point=init_pt, callback=cb_callback, quantum_instance=quantum_instance) result = qaoa.compute_minimum_eigenvalue() x = sample_most_likely(result.eigenstate) graph_solution = max_cut.get_graph_solution(x) if init_pt is None: # If None the preferred initial point of QAOA variational form init_pt = [0.0, 0.0] # i.e. 0,0 should come through as the first point with self.subTest('Initial Point'): self.assertListEqual(init_pt, first_pt) with self.subTest('Solution'): self.assertIn(''.join([str(int(i)) for i in graph_solution]), solutions)
def test_qaoa(self, w, prob, m, solutions, convert_to_matrix_op): """ QAOA test """ seed = 0 aqua_globals.random_seed = seed self.log.debug('Testing %s-step QAOA with MaxCut on graph\n%s', prob, w) backend = BasicAer.get_backend('statevector_simulator') optimizer = COBYLA() qubit_op, offset = max_cut.get_operator(w) qubit_op = qubit_op.to_opflow() if convert_to_matrix_op: qubit_op = qubit_op.to_matrix_op() qaoa = QAOA(qubit_op, optimizer, prob, mixer=m) quantum_instance = QuantumInstance(backend, seed_simulator=seed, seed_transpiler=seed) result = qaoa.run(quantum_instance) x = sample_most_likely(result.eigenstate) graph_solution = max_cut.get_graph_solution(x) self.log.debug('energy: %s', result.eigenvalue.real) self.log.debug('time: %s', result.optimizer_time) self.log.debug('maxcut objective: %s', result.eigenvalue.real + offset) self.log.debug('solution: %s', graph_solution) self.log.debug('solution objective: %s', max_cut.max_cut_value(x, w)) self.assertIn(''.join([str(int(i)) for i in graph_solution]), solutions)
def test_callback(self): """Test the callback on VQE.""" history = {'eval_count': [], 'parameters': [], 'mean': [], 'std': []} def store_intermediate_result(eval_count, parameters, mean, std): history['eval_count'].append(eval_count) history['parameters'].append(parameters) history['mean'].append(mean) history['std'].append(std) optimizer = COBYLA(maxiter=3) wavefunction = self.ry_wavefunction vqe = VQE(self.h2_op, wavefunction, optimizer, callback=store_intermediate_result) vqe.run(self.qasm_simulator) self.assertTrue( all(isinstance(count, int) for count in history['eval_count'])) self.assertTrue( all(isinstance(mean, float) for mean in history['mean'])) self.assertTrue(all(isinstance(std, float) for std in history['std'])) for params in history['parameters']: self.assertTrue(all(isinstance(param, float) for param in params))
def test_vqe_callback(self, var_form_type): """ VQE Callback test """ history = {'eval_count': [], 'parameters': [], 'mean': [], 'std': []} def store_intermediate_result(eval_count, parameters, mean, std): history['eval_count'].append(eval_count) history['parameters'].append(parameters) history['mean'].append(mean) history['std'].append(std) backend = BasicAer.get_backend('qasm_simulator') num_qubits = self.qubit_op.num_qubits init_state = Zero(num_qubits) var_form = RY(num_qubits, depth=1, initial_state=init_state) if var_form_type is QuantumCircuit: params = ParameterVector('θ', var_form.num_parameters) var_form = var_form.construct_circuit(params) optimizer = COBYLA(maxiter=3) algo = VQE(self.qubit_op, var_form, optimizer, callback=store_intermediate_result, auto_conversion=False) aqua_globals.random_seed = 50 quantum_instance = QuantumInstance(backend, seed_transpiler=50, shots=1024, seed_simulator=50) algo.run(quantum_instance) self.assertTrue(all(isinstance(count, int) for count in history['eval_count'])) self.assertTrue(all(isinstance(mean, float) for mean in history['mean'])) self.assertTrue(all(isinstance(std, float) for std in history['std'])) for params in history['parameters']: self.assertTrue(all(isinstance(param, float) for param in params))
def test_h2_two_qubits_statevector(self): """Test H2 with parity mapping and statevector 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'] initial_state = HartreeFock(qubit_op.num_qubits, num_orbitals=num_orbitals, num_particles=num_particles, qubit_mapping=qubit_mapping, two_qubit_reduction=two_qubit_reduction) var_form = UCCSD(num_qubits=qubit_op.num_qubits, depth=1, 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_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(maxiter=2000) ryrz = TwoLocal(rotation_blocks=['ry', 'rz'], entanglement_blocks='cz') vqe = VQE(self.qubit_op, ryrz, optimizer, aux_operators=self.aux_ops) quantum_instance = QuantumInstance(backend, shots=shots) result = vqe.run(quantum_instance) self.assertAlmostEqual(result.eigenvalue.real, self.reference_energy, places=4)
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, 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) 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) self.log.debug(result['testing_accuracy']) self.assertGreaterEqual(result['testing_accuracy'], 0.5)
def test_vqc_with_raw_feature_vector_on_wine(self): """ vqc with raw features vector on wine test """ feature_dim = 4 # dimension of each data point training_dataset_size = 8 testing_dataset_size = 4 _, training_input, test_input, _ = _wine_data( training_size=training_dataset_size, test_size=testing_dataset_size, n=feature_dim ) aqua_globals.random_seed = self.seed feature_map = RawFeatureVector(feature_dimension=feature_dim) vqc = VQC(COBYLA(maxiter=100), feature_map, RYRZ(feature_map.num_qubits, depth=3), training_input, test_input) result = vqc.run(QuantumInstance(BasicAer.get_backend('statevector_simulator'), shots=1024, seed_simulator=aqua_globals.random_seed, seed_transpiler=aqua_globals.random_seed)) self.log.debug(result['testing_accuracy']) self.assertGreater(result['testing_accuracy'], 0.8)
def test_qaoa(self, w, p, m, solutions): self.log.debug('Testing {}-step QAOA with MaxCut on graph\n{}'.format( p, w)) np.random.seed(0) backend = BasicAer.get_backend('statevector_simulator') optimizer = COBYLA() qubitOp, offset = max_cut.get_max_cut_qubitops(w) qaoa = QAOA(qubitOp, optimizer, p, operator_mode='matrix', mixer=m) quantum_instance = QuantumInstance(backend) result = qaoa.run(quantum_instance) x = max_cut.sample_most_likely(result['eigvecs'][0]) graph_solution = max_cut.get_graph_solution(x) self.log.debug('energy: {}'.format(result['energy'])) self.log.debug('time: {}'.format(result['eval_time'])) self.log.debug('maxcut objective: {}'.format(result['energy'] + offset)) self.log.debug('solution: {}'.format(graph_solution)) self.log.debug('solution objective: {}'.format( max_cut.max_cut_value(x, w))) self.assertIn(''.join([str(int(i)) for i in graph_solution]), solutions) if quantum_instance.has_circuit_caching: self.assertLess(quantum_instance._circuit_cache.misses, 3)
def test_raw_feature_vector_on_wine(self, mode): """Test VQE on the wine dataset using the ``RawFeatureVector`` as data preparation.""" feature_dim = 4 # dimension of each data point training_dataset_size = 8 testing_dataset_size = 4 _, training_input, test_input, _ = wine( training_size=training_dataset_size, test_size=testing_dataset_size, n=feature_dim, plot_data=False) if mode == 'component': warnings.filterwarnings('ignore', category=DeprecationWarning) feature_map = LegacyRawFeatureVector(feature_dimension=feature_dim) else: 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(self.statevector_simulator) if mode == 'component': warnings.filterwarnings('always', category=DeprecationWarning) self.log.debug(result['testing_accuracy']) self.assertGreater(result['testing_accuracy'], 0.7)
def test_callback(self): """Test the callback function of the VQC.""" history = {'eval_count': [], 'parameters': [], 'cost': [], 'batch_index': []} def store_intermediate_result(eval_count, parameters, cost, batch_index): history['eval_count'].append(eval_count) history['parameters'].append(parameters) history['cost'].append(cost) history['batch_index'].append(batch_index) optimizer = COBYLA(maxiter=3) data_preparation = self.data_preparation wavefunction = self.ryrz_wavefunction # set up algorithm vqc = VQC(optimizer, data_preparation, wavefunction, self.training_data, self.testing_data, callback=store_intermediate_result) vqc.run(self.qasm_simulator) with self.subTest('eval count'): self.assertTrue(all(isinstance(count, int) for count in history['eval_count'])) with self.subTest('cost'): self.assertTrue(all(isinstance(cost, float) for cost in history['cost'])) with self.subTest('batch index'): self.assertTrue(all(isinstance(index, int) for index in history['batch_index'])) for params in history['parameters']: with self.subTest('params'): self.assertTrue(all(isinstance(param, float) for param in params))
def test_vqc_minibatching_no_gradient_support(self): n_dim = 2 # dimension of each data point seed = 1024 np.random.seed(seed) sample_Total, training_input, test_input, class_labels = 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 = COBYLA() 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) 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_qaoa(self, w, p, m, solutions): os.environ.pop('QISKIT_AQUA_CIRCUIT_CACHE', None) self.log.debug('Testing {}-step QAOA with MaxCut on graph\n{}'.format( p, w)) np.random.seed(0) backend = BasicAer.get_backend('statevector_simulator') optimizer = COBYLA() qubit_op, offset = max_cut.get_max_cut_qubitops(w) qaoa = QAOA(qubit_op, optimizer, p, mixer=m) # TODO: cache fails for QAOA since we construct the evolution circuit via instruction quantum_instance = QuantumInstance(backend, circuit_caching=False) result = qaoa.run(quantum_instance) x = max_cut.sample_most_likely(result['eigvecs'][0]) graph_solution = max_cut.get_graph_solution(x) self.log.debug('energy: {}'.format(result['energy'])) self.log.debug('time: {}'.format(result['eval_time'])) self.log.debug('maxcut objective: {}'.format(result['energy'] + offset)) self.log.debug('solution: {}'.format(graph_solution)) self.log.debug('solution objective: {}'.format( max_cut.max_cut_value(x, w))) self.assertIn(''.join([str(int(i)) for i in graph_solution]), solutions) if quantum_instance.has_circuit_caching: self.assertLess(quantum_instance._circuit_cache.misses, 3)
def createPlot1(bondLengthMin=0.5, bondLengthMax=1.5, numberOfPoints=10, initialParameters=None, numberOfParameters=16, shotsPerPoint=1000, registerSize=12, map_type='jordan_wigner'): if initialParameters is None: initialParameters = np.random.rand(numberOfParameters) global qubitOp global qr_size global shots shots = shotsPerPoint qr_size = registerSize optimizer = COBYLA(maxiter=20) bondLengths = [] values = [] delta = (bondLengthMax - bondLengthMin) / numberOfPoints for i in range(numberOfPoints): bondLengths.append(bondLengthMin + i * delta) for bondLength in bondLengths: driver = PySCFDriver(atom="H .0 .0 .0; H .0 .0 " + str(bondLength), unit=UnitsType.ANGSTROM, charge=0, spin=0, basis='sto3g') molecule = driver.run() repulsion_energy = molecule.nuclear_repulsion_energy num_spin_orbitals = molecule.num_orbitals * 2 num_particles = molecule.num_alpha + molecule.num_beta ferOp = FermionicOperator(h1=molecule.one_body_integrals, h2=molecule.two_body_integrals) qubitOp = ferOp.mapping(map_type=map_type, threshold=0.00000001) sol_opt = optimizer.optimize(numberOfParameters, energy_opt, gradient_function=None, variable_bounds=None, initial_point=initialParameters) values.append(sol_opt[1] + repulsion_energy) filename = 'Energy - BondLengths' with open(filename, 'wb') as f: pickle.dump([bondLengths, values], f) plt.plot(bondLengths, values) plt.ylabel('Ground State Energy') plt.xlabel('Bond Length') plt.show()
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 = get_aer_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) algo.random_seed = 50 run_config = RunConfig(shots=1024, seed=50) quantum_instance = QuantumInstance(backend, seed_mapper=50, run_config=run_config) 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.59622", "0.01546" ], [ "2", "[ 0.96608114 -1.70850424 -1.53640265 -0.65137839]", "-0.77452", "0.01692" ], [ "3", "[ 0.96608114 -0.70850424 -1.53640265 -0.65137839]", "-0.80327", "0.01519" ]] 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 if is_file_exist: os.remove(self._get_resource_path(tmp_filename))
def test_qaoa_initial_state(self, w, init_state): """ QAOA initial state test """ optimizer = COBYLA() qubit_op, _ = max_cut.get_operator(w) init_pt = [0.0, 0.0] # Avoid generating random initial point if init_state is None: initial_state = None else: initial_state = Custom(num_qubits=4, state_vector=init_state) quantum_instance = QuantumInstance( BasicAer.get_backend('statevector_simulator')) qaoa_zero_init_state = QAOA(qubit_op, optimizer, initial_point=init_pt, initial_state=Zero(qubit_op.num_qubits), quantum_instance=quantum_instance) qaoa = QAOA(qubit_op, optimizer, initial_point=init_pt, initial_state=initial_state, quantum_instance=quantum_instance) zero_circuits = qaoa_zero_init_state.construct_circuit(init_pt) custom_circuits = qaoa.construct_circuit(init_pt) self.assertEqual(len(zero_circuits), len(custom_circuits)) backend = BasicAer.get_backend('statevector_simulator') for zero_circ, custom_circ in zip(zero_circuits, custom_circuits): z_length = len(zero_circ.data) c_length = len(custom_circ.data) self.assertGreaterEqual(c_length, z_length) self.assertTrue(zero_circ.data == custom_circ.data[-z_length:]) custom_init_qc = custom_circ.copy() custom_init_qc.data = custom_init_qc.data[0:c_length - z_length] if initial_state is None: original_init_qc = QuantumCircuit(qubit_op.num_qubits) original_init_qc.h(range(qubit_op.num_qubits)) else: original_init_qc = initial_state.construct_circuit() job_init_state = execute(original_init_qc, backend) job_qaoa_init_state = execute(custom_init_qc, backend) statevector_original = job_init_state.result().get_statevector( original_init_qc) statevector_custom = job_qaoa_init_state.result().get_statevector( custom_init_qc) self.assertEqual(statevector_original.tolist(), statevector_custom.tolist())
def optimize(self): # Define objective function def objfunc(params): return -self.expectation(beta=params[0:self.p], gamma=params[self.p:2 * self.p]) # Optimize parameters optimizer = COBYLA(maxiter=1000, tol=0.0001) params = self.beta_val + self.gamma_val ret = optimizer.optimize(num_vars=2 * self.p, objective_function=objfunc, initial_point=params) self.beta_val = ret[0][0:self.p] self.gamma_val = ret[0][self.p:2 * self.p] self.error = ret[1] return