def test_missing_attributesquantum_instance(self): """Test appropriate error is raised if the quantum instance is missing.""" pvqd = PVQD( self.ansatz, self.initial_parameters, optimizer=L_BFGS_B(maxiter=1), expectation=self.expectation, ) problem = EvolutionProblem(self.hamiltonian, time=0.01) attrs_to_test = [ ("optimizer", L_BFGS_B(maxiter=1)), ("quantum_instance", self.qasm_backend), ] for attr, value in attrs_to_test: with self.subTest(msg=f"missing: {attr}"): # set attribute to None to invalidate the setup setattr(pvqd, attr, None) with self.assertRaises(ValueError): _ = pvqd.evolve(problem) # set the correct value again setattr(pvqd, attr, value) with self.subTest(msg="all set again"): result = pvqd.evolve(problem) self.assertIsNotNone(result.evolved_state)
def test_with_aer_statevector(self): """Test VQE with Aer's statevector_simulator.""" try: # pylint: disable=import-outside-toplevel from qiskit.providers.aer 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') wavefunction = self.ry_wavefunction optimizer = L_BFGS_B() quantum_instance = QuantumInstance( backend, seed_simulator=algorithm_globals.random_seed, seed_transpiler=algorithm_globals.random_seed) vqe = VQE(var_form=wavefunction, optimizer=optimizer, max_evals_grouped=1, quantum_instance=quantum_instance) result = vqe.compute_minimum_eigenvalue(operator=self.h2_op) self.assertAlmostEqual(result.eigenvalue.real, self.h2_energy, places=6)
def test_with_aer_qasm_snapshot_mode(self): """Test the VQE using Aer's qasm_simulator snapshot mode.""" try: from qiskit.providers.aer 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 = L_BFGS_B() wavefunction = self.ry_wavefunction quantum_instance = QuantumInstance( backend, shots=1, seed_simulator=algorithm_globals.random_seed, seed_transpiler=algorithm_globals.random_seed) vqe = VQE(ansatz=wavefunction, optimizer=optimizer, expectation=AerPauliExpectation(), quantum_instance=quantum_instance) result = vqe.compute_minimum_eigenvalue(operator=self.h2_op) self.assertAlmostEqual(result.eigenvalue.real, self.h2_energy, places=6)
def test_basic_aer_statevector(self): """Test the VQE on BasicAer's statevector simulator.""" wavefunction = self.ryrz_wavefunction vqe = VQE(var_form=wavefunction, optimizer=L_BFGS_B(), quantum_instance=QuantumInstance( BasicAer.get_backend('statevector_simulator'), basis_gates=['u1', 'u2', 'u3', 'cx', 'id'], coupling_map=[[0, 1]], seed_simulator=algorithm_globals.random_seed, seed_transpiler=algorithm_globals.random_seed)) result = vqe.compute_minimum_eigenvalue(operator=self.h2_op) with self.subTest(msg='test eigenvalue'): self.assertAlmostEqual(result.eigenvalue.real, self.h2_energy) with self.subTest(msg='test dimension of optimal point'): self.assertEqual(len(result.optimal_point), 16) with self.subTest(msg='assert cost_function_evals is set'): self.assertIsNotNone(result.cost_function_evals) with self.subTest(msg='assert optimizer_time is set'): self.assertIsNotNone(result.optimizer_time)
def test_with_aer_qasm_snapshot_mode(self): """Test the VQE using Aer's qasm_simulator snapshot mode.""" 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 = L_BFGS_B() wavefunction = self.ry_wavefunction vqe = VQE(self.h2_op, wavefunction, optimizer, expectation=AerPauliExpectation()) quantum_instance = QuantumInstance( backend, shots=1, seed_simulator=aqua_globals.random_seed, seed_transpiler=aqua_globals.random_seed) result = vqe.run(quantum_instance) self.assertAlmostEqual(result.eigenvalue.real, self.h2_energy, places=6)
def test_basic_aer_statevector(self): """Test the VQE on BasicAer's statevector simulator.""" wavefunction = self.ryrz_wavefunction vqe = VQE( ansatz=wavefunction, optimizer=L_BFGS_B(), quantum_instance=QuantumInstance( BasicAer.get_backend("statevector_simulator"), basis_gates=["u1", "u2", "u3", "cx", "id"], coupling_map=[[0, 1]], seed_simulator=algorithm_globals.random_seed, seed_transpiler=algorithm_globals.random_seed, ), ) result = vqe.compute_minimum_eigenvalue(operator=self.h2_op) with self.subTest(msg="test eigenvalue"): self.assertAlmostEqual(result.eigenvalue.real, self.h2_energy) with self.subTest(msg="test dimension of optimal point"): self.assertEqual(len(result.optimal_point), 16) with self.subTest(msg="assert cost_function_evals is set"): self.assertIsNotNone(result.cost_function_evals) with self.subTest(msg="assert optimizer_time is set"): self.assertIsNotNone(result.optimizer_time)
def test_minibatching_gradient_based(self): """Test the minibatching option with a gradient-based optimizer.""" n_dim = 2 # dimension of each data point _, training_input, test_input, _ = ad_hoc_data(training_size=4, test_size=2, n=n_dim, gap=0.3, plot_data=False) optimizer = L_BFGS_B(maxfun=30) data_preparation = self.data_preparation wavefunction = TwoLocal(2, ['ry', 'rz'], 'cz', reps=1, insert_barriers=True) vqc = VQC(optimizer, data_preparation, wavefunction, training_input, test_input, minibatch_size=2) result = vqc.run(self.statevector_simulator) self.log.debug(result['testing_accuracy']) self.assertAlmostEqual(result['testing_accuracy'], 0.75, places=3)
def get_solver(self, problem, qubit_converter): particle_number = cast( ParticleNumber, problem.grouped_property_transformed.get_property( ParticleNumber), ) num_spin_orbitals = particle_number.num_spin_orbitals num_particles = (particle_number.num_alpha, particle_number.num_beta) initial_state = HartreeFock(num_spin_orbitals, num_particles, qubit_converter) ansatz = UCC( qubit_converter=qubit_converter, num_particles=num_particles, num_spin_orbitals=num_spin_orbitals, excitations="d", initial_state=initial_state, ) vqe = VQE( ansatz=ansatz, quantum_instance=self.minimum_eigensolver.quantum_instance, optimizer=L_BFGS_B(), ) return vqe
def test_warm_start(self, config): """Test VQC with warm_start=True.""" opt, q_i = config if q_i == "statevector": quantum_instance = self.sv_quantum_instance elif q_i == "qasm": quantum_instance = self.qasm_quantum_instance else: quantum_instance = None if opt == "bfgs": optimizer = L_BFGS_B(maxiter=5) elif opt == "cobyla": optimizer = COBYLA(maxiter=25) else: optimizer = None num_inputs = 2 feature_map = ZZFeatureMap(num_inputs) ansatz = RealAmplitudes(num_inputs, reps=1) # Construct the data. num_samples = 10 # pylint: disable=invalid-name X = algorithm_globals.random.random((num_samples, num_inputs)) y = 1.0 * (np.sum(X, axis=1) <= 1) while len(np.unique(y)) == 1: X = algorithm_globals.random.random((num_samples, num_inputs)) y = 1.0 * (np.sum(X, axis=1) <= 1) y = np.array([y, 1 - y ]).transpose() # VQC requires one-hot encoded input. # Initialize the VQC. classifier = VQC( feature_map=feature_map, ansatz=ansatz, optimizer=optimizer, warm_start=True, quantum_instance=quantum_instance, ) # Fit the VQC to the first half of the data. num_start = num_samples // 2 classifier.fit(X[:num_start, :], y[:num_start]) first_fit_final_point = classifier._fit_result.x # Fit the VQC to the second half of the data with a warm start. classifier.fit(X[num_start:, :], y[num_start:]) second_fit_initial_point = classifier._initial_point # Check the final optimization point from the first fit was used to start the second fit. np.testing.assert_allclose(first_fit_final_point, second_fit_initial_point) # Check score. score = classifier.score(X, y) self.assertGreater(score, 0.5)
def test_set_optimizer_to_none(self): """Tests that setting the optimizer to None results in the default behavior""" vqe = VQE( ansatz=self.ryrz_wavefunction, optimizer=L_BFGS_B(), quantum_instance=self.statevector_simulator, ) vqe.optimizer = None self.assertIsInstance(vqe.optimizer, SLSQP)
def _create_optimizer(self, opt: str) -> Optional[Optimizer]: if opt == "bfgs": optimizer = L_BFGS_B(maxiter=5) elif opt == "cobyla": optimizer = COBYLA(maxiter=25) else: optimizer = None return optimizer
def test_classifier_with_circuit_qnn_and_cross_entropy(self, config): """ Test Neural Network Classifier with Circuit QNN and Cross Entropy loss.""" opt, q_i = config if q_i == 'statevector': quantum_instance = self.sv_quantum_instance else: quantum_instance = self.qasm_quantum_instance if opt == 'bfgs': optimizer = L_BFGS_B(maxiter=5) else: optimizer = COBYLA(maxiter=25) loss = CrossEntropyLoss() num_inputs = 2 feature_map = ZZFeatureMap(num_inputs) ansatz = RealAmplitudes(num_inputs, reps=1) # construct circuit qc = QuantumCircuit(num_inputs) qc.append(feature_map, range(2)) qc.append(ansatz, range(2)) # construct qnn def parity(x): return '{:b}'.format(x).count('1') % 2 output_shape = 2 qnn = CircuitQNN(qc, input_params=feature_map.parameters, weight_params=ansatz.parameters, sparse=False, interpret=parity, output_shape=output_shape, quantum_instance=quantum_instance) # construct classifier - note: CrossEntropy requires eval_probabilities=True! classifier = NeuralNetworkClassifier(qnn, optimizer=optimizer, loss=loss, one_hot=True) # construct data num_samples = 5 X = np.random.rand(num_samples, num_inputs) # pylint: disable=invalid-name y = 1.0 * (np.sum(X, axis=1) <= 1) y = np.array([y, 1 - y]).transpose() # fit to data classifier.fit(X, y) # score score = classifier.score(X, y) self.assertGreater(score, 0.5)
def test_set_ansatz_to_none(self): """Tests that setting the ansatz to None results in the default behavior""" vqd = VQD( k=1, ansatz=self.ryrz_wavefunction, optimizer=L_BFGS_B(), quantum_instance=self.statevector_simulator, ) vqd.ansatz = None self.assertIsInstance(vqd.ansatz, RealAmplitudes)
def test_batches_with_incomplete_labels(self, config): """Test VQC when some batches do not include all possible labels.""" opt, q_i = config if q_i == "statevector": quantum_instance = self.sv_quantum_instance elif q_i == "qasm": quantum_instance = self.qasm_quantum_instance else: quantum_instance = None if opt == "bfgs": optimizer = L_BFGS_B(maxiter=5) elif opt == "cobyla": optimizer = COBYLA(maxiter=25) else: optimizer = None num_inputs = 2 feature_map = ZZFeatureMap(num_inputs) ansatz = RealAmplitudes(num_inputs, reps=1) # Construct the data. features = algorithm_globals.random.random((15, num_inputs)) target = np.asarray([0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2]) num_classes = len(np.unique(target)) # One-hot encode the target. target_onehot = np.zeros((target.size, int(target.max() + 1))) target_onehot[np.arange(target.size), target.astype(int)] = 1 # Initialize the VQC. classifier = VQC( feature_map=feature_map, ansatz=ansatz, optimizer=optimizer, warm_start=True, quantum_instance=quantum_instance, ) classifier._get_interpret = self.get_num_classes( classifier._get_interpret) # Fit the VQC to the first third of the data. classifier.fit(features[:5, :], target_onehot[:5]) # Fit the VQC to the second third of the data with a warm start. classifier.fit(features[5:10, :], target_onehot[5:10]) # Fit the VQC to the third third of the data with a warm start. classifier.fit(features[10:, :], target_onehot[10:]) # Check all batches assume the correct number of classes self.assertTrue( (np.asarray(self.num_classes_by_batch) == num_classes).all())
def get_solver(self, transformation): num_orbitals = transformation.molecule_info['num_orbitals'] num_particles = transformation.molecule_info['num_particles'] initial_state = HartreeFock(num_orbitals, num_particles) var_form = UCCSD(num_orbitals, num_particles, initial_state=initial_state) vqe = VQE(var_form=var_form, quantum_instance=self._quantum_instance, optimizer=L_BFGS_B()) return vqe
def compile_unitary( self, target_matrix: np.ndarray, approximate_circuit: ApproximateCircuit, approximating_objective: ApproximatingObjective, initial_point: Optional[np.ndarray] = None, ) -> None: """ Approximately compiles a circuit represented as a unitary matrix by solving an optimization problem defined by ``approximating_objective`` and using ``approximate_circuit`` as a template for the approximate circuit. Args: target_matrix: a unitary matrix to approximate. approximate_circuit: a template circuit that will be filled with the parameter values obtained in the optimization procedure. approximating_objective: a definition of the optimization problem. initial_point: initial values of angles/parameters to start optimization from. """ matrix_dim = target_matrix.shape[0] # check if it is actually a special unitary matrix target_det = np.linalg.det(target_matrix) if not np.isclose(target_det, 1): su_matrix = target_matrix / np.power(target_det, (1 / matrix_dim)) global_phase_required = True else: su_matrix = target_matrix global_phase_required = False # set the matrix to approximate in the algorithm approximating_objective.target_matrix = su_matrix optimizer = self._optimizer or L_BFGS_B(maxiter=1000) if initial_point is None: np.random.seed(self._seed) initial_point = np.random.uniform( 0, 2 * np.pi, approximating_objective.num_thetas) opt_result = optimizer.minimize( fun=approximating_objective.objective, x0=initial_point, jac=approximating_objective.gradient, ) approximate_circuit.build(opt_result.x) approx_matrix = Operator(approximate_circuit).data if global_phase_required: alpha = np.angle( np.trace(np.dot(approx_matrix.conj().T, target_matrix))) approximate_circuit.global_phase = alpha
def test_vqc(self, config): """Test VQC.""" opt, q_i = config if q_i == "statevector": quantum_instance = self.sv_quantum_instance elif q_i == "qasm": quantum_instance = self.qasm_quantum_instance else: quantum_instance = None if opt == "bfgs": optimizer = L_BFGS_B(maxiter=5) elif opt == "cobyla": optimizer = COBYLA(maxiter=25) else: optimizer = None num_inputs = 2 feature_map = ZZFeatureMap(num_inputs) ansatz = RealAmplitudes(num_inputs, reps=1) # fix the initial point initial_point = np.array([0.5] * ansatz.num_parameters) # construct classifier - note: CrossEntropy requires eval_probabilities=True! classifier = VQC( feature_map=feature_map, ansatz=ansatz, optimizer=optimizer, quantum_instance=quantum_instance, initial_point=initial_point, ) # construct data num_samples = 5 # pylint: disable=invalid-name X = algorithm_globals.random.random((num_samples, num_inputs)) y = 1.0 * (np.sum(X, axis=1) <= 1) while len(np.unique(y)) == 1: X = algorithm_globals.random.random((num_samples, num_inputs)) y = 1.0 * (np.sum(X, axis=1) <= 1) y = np.array([y, 1 - y]).transpose() # VQC requires one-hot encoded input # fit to data classifier.fit(X, y) # score score = classifier.score(X, y) self.assertGreater(score, 0.5)
def test_stable_set_vqe(self): """ VQE Stable set test """ q_i = QuantumInstance(BasicAer.get_backend('statevector_simulator'), seed_simulator=algorithm_globals.random_seed, seed_transpiler=algorithm_globals.random_seed) result = VQE(EfficientSU2(reps=3, entanglement='linear'), L_BFGS_B(maxfun=6000), quantum_instance=q_i).compute_minimum_eigenvalue( self.qubit_op) x = sample_most_likely(result.eigenstate) self.assertAlmostEqual(result.eigenvalue, -39.5) self.assertAlmostEqual(result.eigenvalue + self.offset, -38.0) ising_sol = stable_set.get_graph_solution(x) np.testing.assert_array_equal(ising_sol, [1, 1, 0, 1, 1]) self.assertEqual(stable_set.stable_set_value(x, self.w), (4.0, False))
def test_statevector(self): """Test running the VQC on BasicAer's Statevector simulator.""" optimizer = L_BFGS_B(maxfun=200) data_preparation = self.data_preparation wavefunction = self.ryrz_wavefunction vqc = VQC(optimizer, data_preparation, wavefunction, self.training_data, self.testing_data) result = vqc.run(self.statevector_simulator) with self.subTest(msg='check training loss'): self.assertLess(result['training_loss'], 0.12) with self.subTest(msg='check testing accuracy'): self.assertEqual(result['testing_accuracy'], 0.5)
def test_vqr(self, config): """Test VQR.""" opt, q_i, has_ansatz = config if q_i == "statevector": quantum_instance = self.sv_quantum_instance else: quantum_instance = self.qasm_quantum_instance if opt == "bfgs": optimizer = L_BFGS_B(maxiter=5) elif opt == "cobyla": optimizer = COBYLA(maxiter=25) else: optimizer = None num_qubits = 1 # construct simple feature map param_x = Parameter("x") feature_map = QuantumCircuit(num_qubits, name="fm") feature_map.ry(param_x, 0) if has_ansatz: param_y = Parameter("y") ansatz = QuantumCircuit(num_qubits, name="vf") ansatz.ry(param_y, 0) initial_point = np.zeros(ansatz.num_parameters) else: ansatz = None # we know it will be RealAmplitudes initial_point = np.zeros(4) # construct regressor regressor = VQR( feature_map=feature_map, ansatz=ansatz, optimizer=optimizer, quantum_instance=quantum_instance, initial_point=initial_point, ) # fit to data regressor.fit(self.X, self.y) # score score = regressor.score(self.X, self.y) self.assertGreater(score, 0.5)
def test_sparse_arrays(self, q_i, loss): """Tests classifier with sparse arrays as features and labels.""" optimizer = L_BFGS_B(maxiter=5) quantum_instance = self._create_quantum_instance(q_i) qnn, _, num_parameters = self._create_circuit_qnn(quantum_instance) classifier = self._create_classifier(qnn, num_parameters, optimizer, loss, one_hot=True) features = scipy.sparse.csr_matrix([[0, 0], [1, 1]]) labels = scipy.sparse.csr_matrix([[1, 0], [0, 1]]) # fit to data classifier.fit(features, labels) # score score = classifier.score(features, labels) self.assertGreater(score, 0.5)
def test_invalid_num_timestep(self): """Test raises if the num_timestep is not positive.""" pvqd = PVQD( self.ansatz, self.initial_parameters, num_timesteps=0, optimizer=L_BFGS_B(), quantum_instance=self.sv_backend, expectation=self.expectation, ) problem = EvolutionProblem( self.hamiltonian, time=0.01, aux_operators=[self.hamiltonian, self.observable]) with self.assertRaises(ValueError): _ = pvqd.evolve(problem)
def run(self, unitary, **options): # Runtime imports to avoid the overhead of these imports for # plugin discovery and only use them if the plugin is run/used from qiskit.algorithms.optimizers import L_BFGS_B from qiskit.transpiler.synthesis.aqc.aqc import AQC from qiskit.transpiler.synthesis.aqc.cnot_structures import make_cnot_network from qiskit.transpiler.synthesis.aqc.cnot_unit_circuit import CNOTUnitCircuit from qiskit.transpiler.synthesis.aqc.cnot_unit_objective import DefaultCNOTUnitObjective num_qubits = int(round(np.log2(unitary.shape[0]))) config = options.get("config") or {} network_layout = config.get("network_layout", "spin") connectivity_type = config.get("connectivity_type", "full") depth = config.get("depth", 0) cnots = make_cnot_network( num_qubits=num_qubits, network_layout=network_layout, connectivity_type=connectivity_type, depth=depth, ) optimizer = config.get("optimizer", L_BFGS_B(maxiter=1000)) seed = config.get("seed") aqc = AQC(optimizer, seed) approximate_circuit = CNOTUnitCircuit(num_qubits=num_qubits, cnots=cnots) approximating_objective = DefaultCNOTUnitObjective( num_qubits=num_qubits, cnots=cnots) initial_point = config.get("initial_point") aqc.compile_unitary( target_matrix=unitary, approximate_circuit=approximate_circuit, approximating_objective=approximating_objective, initial_point=initial_point, ) dag_circuit = circuit_to_dag(approximate_circuit) return dag_circuit
def test_regressor_with_opflow_qnn(self, config): """ Test Neural Network Regressor with Opflow QNN (Two Layer QNN).""" opt, q_i = config num_qubits = 1 # construct simple feature map param_x = Parameter('x') feature_map = QuantumCircuit(num_qubits, name='fm') feature_map.ry(param_x, 0) # construct simple feature map param_y = Parameter('y') var_form = QuantumCircuit(num_qubits, name='vf') var_form.ry(param_y, 0) if q_i == 'statevector': quantum_instance = self.sv_quantum_instance else: quantum_instance = self.qasm_quantum_instance if opt == 'bfgs': optimizer = L_BFGS_B(maxiter=5) else: optimizer = COBYLA(maxiter=25) # construct QNN regression_opflow_qnn = TwoLayerQNN(num_qubits, feature_map, var_form, quantum_instance=quantum_instance) # construct the regressor from the neural network regressor = NeuralNetworkRegressor( neural_network=regression_opflow_qnn, loss='l2', optimizer=optimizer) # fit to data regressor.fit(self.X, self.y) # score the result score = regressor.score(self.X, self.y) self.assertGreater(score, 0.5)
def get_solver(self, problem, qubit_converter): q_molecule_transformed = cast( QMolecule, problem.molecule_data_transformed) num_molecular_orbitals = q_molecule_transformed.num_molecular_orbitals num_particles = (q_molecule_transformed.num_alpha, q_molecule_transformed.num_beta) num_spin_orbitals = 2 * num_molecular_orbitals initial_state = HartreeFock(num_spin_orbitals, num_particles, qubit_converter) ansatz = UCC(qubit_converter=qubit_converter, num_particles=num_particles, num_spin_orbitals=num_spin_orbitals, excitations='d', initial_state=initial_state) vqe = VQE(ansatz=ansatz, quantum_instance=self._quantum_instance, optimizer=L_BFGS_B()) return vqe
def test_vqe_optimizer(self): """Test running same VQE twice to re-use optimizer, then switch optimizer""" vqe = VQE( optimizer=SLSQP(), quantum_instance=QuantumInstance(BasicAer.get_backend("statevector_simulator")), ) def run_check(): result = vqe.compute_minimum_eigenvalue(operator=self.h2_op) 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 test_pvqd(self, hamiltonian_type, expectation_cls, gradient, backend_type, num_timesteps): """Test a simple evolution.""" time = 0.02 if hamiltonian_type == "ising": hamiltonian = self.hamiltonian elif hamiltonian_type == "ising_matrix": hamiltonian = self.hamiltonian.to_matrix_op() else: # hamiltonian_type == "pauli": hamiltonian = X ^ X # parse input arguments if gradient: optimizer = GradientDescent(maxiter=1) else: optimizer = L_BFGS_B(maxiter=1) backend = self.sv_backend if backend_type == "sv" else self.qasm_backend expectation = expectation_cls() # run pVQD keeping track of the energy and the magnetization pvqd = PVQD( self.ansatz, self.initial_parameters, num_timesteps=num_timesteps, optimizer=optimizer, quantum_instance=backend, expectation=expectation, ) problem = EvolutionProblem( hamiltonian, time, aux_operators=[hamiltonian, self.observable]) result = pvqd.evolve(problem) self.assertTrue(len(result.fidelities) == 3) self.assertTrue(np.all(result.times == [0.0, 0.01, 0.02])) self.assertTrue(np.asarray(result.observables).shape == (3, 2)) num_parameters = self.ansatz.num_parameters self.assertTrue( len(result.parameters) == 3 and np.all([ len(params) == num_parameters for params in result.parameters ]))
def test_with_aer_statevector(self): """Test VQE with Aer's statevector_simulator.""" backend = Aer.get_backend("aer_simulator_statevector") wavefunction = self.ry_wavefunction optimizer = L_BFGS_B() quantum_instance = QuantumInstance( backend, seed_simulator=algorithm_globals.random_seed, seed_transpiler=algorithm_globals.random_seed, ) vqe = VQE( ansatz=wavefunction, optimizer=optimizer, max_evals_grouped=1, quantum_instance=quantum_instance, ) result = vqe.compute_minimum_eigenvalue(operator=self.h2_op) self.assertAlmostEqual(result.eigenvalue.real, self.h2_energy, places=6)
def get_solver(self, transformation): num_orbitals = transformation.molecule_info['num_orbitals'] num_particles = transformation.molecule_info['num_particles'] qubit_mapping = transformation.qubit_mapping two_qubit_reduction = transformation.molecule_info[ 'two_qubit_reduction'] z2_symmetries = transformation.molecule_info['z2_symmetries'] initial_state = HartreeFock(num_orbitals, num_particles, qubit_mapping, two_qubit_reduction, z2_symmetries.sq_list) 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, z2_symmetries=z2_symmetries) vqe = VQE(var_form=var_form, quantum_instance=self._quantum_instance, optimizer=L_BFGS_B()) return vqe
def test_vqc(self, config): """ Test VQC.""" opt, q_i = config if q_i == 'statevector': quantum_instance = self.sv_quantum_instance else: quantum_instance = self.qasm_quantum_instance if opt == 'bfgs': optimizer = L_BFGS_B(maxiter=5) else: optimizer = COBYLA(maxiter=25) num_inputs = 2 feature_map = ZZFeatureMap(num_inputs) ansatz = RealAmplitudes(num_inputs, reps=1) # construct classifier - note: CrossEntropy requires eval_probabilities=True! classifier = VQC(feature_map=feature_map, ansatz=ansatz, optimizer=optimizer, quantum_instance=quantum_instance) # construct data num_samples = 5 X = np.random.rand(num_samples, num_inputs) # pylint: disable=invalid-name y = 1.0 * (np.sum(X, axis=1) <= 1) while len(np.unique(y)) == 1: X = np.random.rand(num_samples, num_inputs) # pylint: disable=invalid-name y = 1.0 * (np.sum(X, axis=1) <= 1) y = np.array([y, 1 - y]).transpose() # VQC requires one-hot encoded input # fit to data classifier.fit(X, y) # score score = classifier.score(X, y) self.assertGreater(score, 0.5)