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_vqc_callback(self, use_circuits): """ vqc callback test """ 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) aqua_globals.random_seed = self.seed backend = BasicAer.get_backend('qasm_simulator') num_qubits = 2 optimizer = COBYLA(maxiter=3) feature_map = SecondOrderExpansion(feature_dimension=num_qubits, depth=2) var_form = RY(num_qubits=num_qubits, depth=1) # convert to circuit if circuits should be used if use_circuits: x = ParameterVector('x', feature_map.feature_dimension) feature_map = feature_map.construct_circuit(x) theta = ParameterVector('theta', var_form.num_parameters) var_form = var_form.construct_circuit(theta) vqc = VQC(optimizer, feature_map, var_form, self.training_data, self.testing_data, callback=store_intermediate_result) quantum_instance = QuantumInstance(backend, shots=1024, seed_simulator=self.seed, seed_transpiler=self.seed) vqc.run(quantum_instance) self.assertTrue( all(isinstance(count, int) for count in history['eval_count'])) self.assertTrue( all(isinstance(cost, float) for cost in history['cost'])) self.assertTrue( all(isinstance(index, int) for index in history['batch_index'])) for params in history['parameters']: self.assertTrue(all(isinstance(param, float) for param in params))
def test_vqe_caching_direct(self, max_evals_grouped): self._build_refrence_result(backends=['statevector_simulator']) backend = BasicAer.get_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, max_evals_grouped=max_evals_grouped) quantum_instance_caching = QuantumInstance( backend, circuit_caching=True, skip_qobj_deepcopy=True, skip_qobj_validation=True, optimization_level=self.optimization_level) result_caching = algo.run(quantum_instance_caching) self.assertLessEqual(quantum_instance_caching.circuit_cache.misses, 0) self.assertAlmostEqual( self.reference_vqe_result['statevector_simulator']['energy'], result_caching['energy']) speedup_min = 3 speedup = result_caching['eval_time'] / self.reference_vqe_result[ 'statevector_simulator']['eval_time'] self.assertLess(speedup, speedup_min)
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_vqe_qasm(self, var_form_type): """ VQE QASM test """ backend = BasicAer.get_backend('qasm_simulator') num_qubits = self.qubit_op.num_qubits var_form = RY(num_qubits, depth=3) if var_form_type is QuantumCircuit: params = ParameterVector('θ', var_form.num_parameters) var_form = var_form.construct_circuit(params) 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 test_vqe_reuse(self): """ Test vqe reuse """ vqe = VQE() with self.assertRaises(AquaError): _ = vqe.run() num_qubits = self.qubit_op.num_qubits var_form = RY(num_qubits, depth=3) vqe.var_form = var_form with self.assertRaises(AquaError): _ = vqe.run() vqe.operator = self.qubit_op with self.assertRaises(AquaError): _ = vqe.run() qinst = QuantumInstance(BasicAer.get_backend('statevector_simulator')) vqe.quantum_instance = qinst result = vqe.run() self.assertAlmostEqual(result.eigenvalue.real, -1.85727503, places=5) operator = MatrixOperator(np.array([[1, 0, 0, 0], [0, -1, 0, 0], [0, 0, 2, 0], [0, 0, 0, 3]])) vqe.operator = operator result = vqe.run() self.assertAlmostEqual(result.eigenvalue.real, -1.0, places=5)
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_caching_direct(self, batch_mode=True): backend = BasicAer.get_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) quantum_instance_caching = QuantumInstance(backend, circuit_caching=True, skip_qobj_deepcopy=True, skip_qobj_validation=True) result_caching = algo.run(quantum_instance_caching) self.assertLessEqual(quantum_instance_caching.circuit_cache.misses, 0) self.assertAlmostEqual( self.reference_vqe_result['statevector_simulator']['energy'], result_caching['energy']) speedup_check = 3 self.log.info( result_caching['eval_time'], self.reference_vqe_result['statevector_simulator']['eval_time'] / speedup_check)
def test_saving_and_loading(self): backend = BasicAer.get_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') fd, cache_tmp_file = tempfile.mkstemp(suffix='.inp') os.close(fd) quantum_instance_caching = QuantumInstance(backend, circuit_caching=True, cache_file=cache_tmp_file, skip_qobj_deepcopy=True, skip_qobj_validation=True) algo.run(quantum_instance_caching) self.assertLessEqual(quantum_instance_caching.circuit_cache.misses, 0) is_file_exist = os.path.exists(cache_tmp_file) self.assertTrue(is_file_exist, "Does not store content successfully.") circuit_cache_new = CircuitCache(skip_qobj_deepcopy=True, cache_file=cache_tmp_file) self.assertEqual(quantum_instance_caching.circuit_cache.mappings, circuit_cache_new.mappings) self.assertLessEqual(circuit_cache_new.misses, 0) if is_file_exist: os.remove(cache_tmp_file)
def test_saving_and_loading_e2e(self): backend = BasicAer.get_backend('statevector_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 = L_BFGS_B(maxiter=10) algo = VQE(self.algo_input.qubit_op, var_form, optimizer) with tempfile.NamedTemporaryFile(suffix='.inp', delete=True) as cache_tmp_file: cache_tmp_file_name = cache_tmp_file.name quantum_instance_caching = QuantumInstance( backend, circuit_caching=True, cache_file=cache_tmp_file_name, skip_qobj_deepcopy=True, skip_qobj_validation=True, optimization_level=self.optimization_level) algo.run(quantum_instance_caching) self.assertLessEqual(quantum_instance_caching.circuit_cache.misses, 0) is_file_exist = os.path.exists(cache_tmp_file_name) self.assertTrue(is_file_exist, "Does not store content successfully.") circuit_cache_new = CircuitCache(skip_qobj_deepcopy=True, cache_file=cache_tmp_file_name) self.assertEqual(quantum_instance_caching.circuit_cache.mappings, circuit_cache_new.mappings) self.assertLessEqual(circuit_cache_new.misses, 0)
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_nft(self): """ Test NFT optimizer by using it """ result = VQE(self.qubit_op, RY(self.qubit_op.num_qubits), NFT()).run( QuantumInstance(BasicAer.get_backend('statevector_simulator'), seed_simulator=aqua_globals.random_seed, seed_transpiler=aqua_globals.random_seed)) self.assertAlmostEqual(result.eigenvalue.real, -1.857275, places=6)
def setUp(self): super().setUp() self.seed = 50 aqua_globals.random_seed = self.seed pauli_dict = { 'paulis': [{ "coeff": { "imag": 0.0, "real": -1.052373245772859 }, "label": "II" }, { "coeff": { "imag": 0.0, "real": 0.39793742484318045 }, "label": "IZ" }, { "coeff": { "imag": 0.0, "real": -0.39793742484318045 }, "label": "ZI" }, { "coeff": { "imag": 0.0, "real": -0.01128010425623538 }, "label": "ZZ" }, { "coeff": { "imag": 0.0, "real": 0.18093119978423156 }, "label": "XX" }] } self.qubit_op = WeightedPauliOperator.from_dict(pauli_dict).to_opflow() num_qubits = self.qubit_op.num_qubits ansatz = TwoLocal(num_qubits, rotation_blocks=['ry', 'rz'], entanglement_blocks='cz') warnings.filterwarnings('ignore', category=DeprecationWarning) self.ryrz_wavefunction = { 'wrapped': RYRZ(num_qubits), 'circuit': QuantumCircuit(num_qubits).compose(ansatz), 'library': ansatz } ansatz = ansatz.copy() ansatz.rotation_blocks = 'ry' self.ry_wavefunction = { 'wrapped': RY(num_qubits), 'circuit': QuantumCircuit(num_qubits).compose(ansatz), 'library': ansatz } warnings.filterwarnings('always', category=DeprecationWarning)
def make_varfor(var_str, feature_dim, vdepth): if var_str == "ryrz": var_form = RYRZ(num_qubits=feature_dim, depth=vdepth, entanglement='full', entanglement_gate='cz') if var_str == "ry": var_form = RY(num_qubits=feature_dim, depth=vdepth, entanglement='full', entanglement_gate='cz') else: print('error in building VARIATIONAL FORM {}'.format(var_str)) sys.exit(1) return var_form
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_aqgd(self): """ test AQGD optimizer by using it """ result = VQE(self.qubit_op, RY(self.qubit_op.num_qubits), AQGD(momentum=0.0)).run( QuantumInstance( BasicAer.get_backend('statevector_simulator'), seed_simulator=aqua_globals.random_seed, seed_transpiler=aqua_globals.random_seed)) self.assertAlmostEqual(result['energy'], -1.85727, places=5)
def test_qsvm_variational_callback(self): tmp_filename = 'qsvm_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, cost, batch_index): with open(self._get_resource_path(tmp_filename), 'a') as f: content = "{},{},{:.5f},{}".format(eval_count, parameters, cost, batch_index) print(content, file=f, flush=True) np.random.seed(self.random_seed) backend = BasicAer.get_backend('qasm_simulator') num_qubits = 2 optimizer = COBYLA(maxiter=3) feature_map = SecondOrderExpansion(num_qubits=num_qubits, depth=2) var_form = RY(num_qubits=num_qubits, depth=1) svm = QSVMVariational(optimizer, feature_map, var_form, self.training_data, self.testing_data, callback=store_intermediate_result) svm.random_seed = self.random_seed quantum_instance = QuantumInstance(backend, shots=1024, seed=self.random_seed, seed_mapper=self.random_seed) svm.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 = [ # ["0", "[ 0.18863864 -1.08197582 1.74432295 1.29765602]", "0.53367", "0"], # ["1", "[ 1.18863864 -1.08197582 1.74432295 1.29765602]", "0.57261", "1"], # ["2", "[ 0.18863864 -0.08197582 1.74432295 1.29765602]", "0.47137", "2"] # ] ref_content = [ ['0', '[ 0.18863864 -1.08197582 1.74432295 1.29765602]', '0.54802', '0'], ['1', '[ 1.18863864 -1.08197582 1.74432295 1.29765602]', '0.53862', '1'], ['2', '[ 1.18863864 -0.08197582 1.74432295 1.29765602]', '0.47278', '2'], ] try: with open(self._get_resource_path(tmp_filename)) as f: idx = 0 for record in f.readlines(): eval_count, parameters, cost, batch_index = record.split(",") self.assertEqual(eval_count.strip(), ref_content[idx][0]) self.assertEqual(parameters, ref_content[idx][1]) self.assertEqual(cost.strip(), ref_content[idx][2]) self.assertEqual(batch_index.strip(), ref_content[idx][3]) idx += 1 finally: if is_file_exist: os.remove(self._get_resource_path(tmp_filename))
def test_vqe_direct(self, max_evals_grouped): backend = BasicAer.get_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, 'paulis', max_evals_grouped=max_evals_grouped) quantum_instance = QuantumInstance(backend) result = algo.run(quantum_instance) self.assertAlmostEqual(result['energy'], -1.85727503) if quantum_instance.has_circuit_caching: self.assertLess(quantum_instance._circuit_cache.misses, 3)
def test_vqe_callback(self): """ VQE Callback test """ 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 file: content = "{},{},{:.5f},{:.5f}".format(eval_count, parameters, mean, std) print(content, file=file, flush=True) backend = BasicAer.get_backend('qasm_simulator') num_qubits = self.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.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) is_file_exist = os.path.exists(self.get_resource_path(tmp_filename)) self.assertTrue(is_file_exist, "Does not store content successfully.") # check the content ref_content = [['1', '[-0.03391886 -1.70850424 -1.53640265 -0.65137839]', '-0.61121', '0.01572'], ['2', '[ 0.96608114 -1.70850424 -1.53640265 -0.65137839]', '-0.79235', '0.01722'], ['3', '[ 0.96608114 -0.70850424 -1.53640265 -0.65137839]', '-0.82829', '0.01529'] ] try: with open(self.get_resource_path(tmp_filename)) as file: idx = 0 for record in file.readlines(): eval_count, parameters, mean, std = record.split(",") self.assertEqual(eval_count.strip(), ref_content[idx][0]) self.assertEqual(parameters, ref_content[idx][1]) self.assertEqual(mean.strip(), ref_content[idx][2]) self.assertEqual(std.strip(), ref_content[idx][3]) idx += 1 finally: if is_file_exist: os.remove(self.get_resource_path(tmp_filename))
def test_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 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_vqc_callback(self): """ vqc callback test """ tmp_filename = 'qvqc_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, cost, batch_index): with open(self._get_resource_path(tmp_filename), 'a') as file: content = "{},{},{:.5f},{}".format(eval_count, parameters, cost, batch_index) print(content, file=file, flush=True) np.random.seed(self.random_seed) aqua_globals.random_seed = self.random_seed backend = BasicAer.get_backend('qasm_simulator') num_qubits = 2 optimizer = COBYLA(maxiter=3) feature_map = SecondOrderExpansion(feature_dimension=num_qubits, depth=2) var_form = RY(num_qubits=num_qubits, depth=1) vqc = VQC(optimizer, feature_map, var_form, self.training_data, self.testing_data, callback=store_intermediate_result) quantum_instance = QuantumInstance(backend, shots=1024, seed_simulator=self.random_seed, seed_transpiler=self.random_seed) vqc.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 = [ ['0', '[-0.58205563 -2.97987177 -0.73153057 1.06577518]', '0.46841', '0'], ['1', '[ 0.41794437 -2.97987177 -0.73153057 1.06577518]', '0.31861', '1'], ['2', '[ 0.41794437 -1.97987177 -0.73153057 1.06577518]', '0.45975', '2'], ] try: with open(self._get_resource_path(tmp_filename)) as file: idx = 0 for record in file.readlines(): eval_count, parameters, cost, batch_index = record.split(",") self.assertEqual(eval_count.strip(), ref_content[idx][0]) self.assertEqual(parameters, ref_content[idx][1]) self.assertEqual(cost.strip(), ref_content[idx][2]) self.assertEqual(batch_index.strip(), ref_content[idx][3]) idx += 1 finally: if is_file_exist: os.remove(self._get_resource_path(tmp_filename))
def test_vqe_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, 'paulis', batch_mode=batch_mode) quantum_instance = QuantumInstance(backend) result = algo.run(quantum_instance) self.assertAlmostEqual(result['energy'], -1.85727503)
def test_vqe_qasm_snapshot_mode(self, var_form_type): """ VQE Aer qasm_simulator snapshot mode test """ try: # pylint: disable=import-outside-toplevel from qiskit import Aer except Exception as ex: # pylint: disable=broad-except self.skipTest("Aer doesn't appear to be installed. Error: '{}'".format(str(ex))) return backend = Aer.get_backend('qasm_simulator') num_qubits = self.qubit_op.num_qubits init_state = Zero(num_qubits) var_form = RY(num_qubits, depth=3, initial_state=init_state) if var_form_type is QuantumCircuit: params = ParameterVector('θ', var_form.num_parameters) var_form = var_form.construct_circuit(params) optimizer = L_BFGS_B() algo = VQE(self.qubit_op, var_form, optimizer, max_evals_grouped=1) quantum_instance = QuantumInstance(backend, shots=1, seed_simulator=aqua_globals.random_seed, seed_transpiler=aqua_globals.random_seed) result = algo.run(quantum_instance) self.assertAlmostEqual(result.eigenvalue.real, -1.85727503, places=6)
def test_vqe_aer_mode(self): try: from qiskit import Aer except Exception as e: self.skipTest("Aer doesn't appear to be installed. Error: '{}'".format(str(e))) return backend = Aer.get_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, max_evals_grouped=1) quantum_instance = QuantumInstance(backend) result = algo.run(quantum_instance) self.assertAlmostEqual(result['energy'], -1.85727503, places=6)
def test_clique_vqe(self): """ VQE Clique test """ aqua_globals.random_seed = 10598 result = VQE(self.qubit_op, RY(self.qubit_op.num_qubits, depth=5, entanglement='linear'), COBYLA(), max_evals_grouped=2).run( QuantumInstance(BasicAer.get_backend('statevector_simulator'), seed_simulator=aqua_globals.random_seed, seed_transpiler=aqua_globals.random_seed)) x = sample_most_likely(result['eigvecs'][0]) ising_sol = clique.get_graph_solution(x) np.testing.assert_array_equal(ising_sol, [1, 1, 1, 1, 1]) oracle = self._brute_force() self.assertEqual(clique.satisfy_or_not(ising_sol, self.w, self.k), oracle)
def test_vqe_qasm(self): """ VQE QASM test """ backend = BasicAer.get_backend('qasm_simulator') num_qubits = self.qubit_op.num_qubits var_form = RY(num_qubits, num_qubits) optimizer = SPSA(max_trials=300, last_avg=5) quantum_instance = QuantumInstance(backend, shots=10000, seed_simulator=self.seed, seed_transpiler=self.seed) vqe = VQE(var_form=var_form, optimizer=optimizer, max_evals_grouped=1, quantum_instance=quantum_instance) output = vqe.compute_minimum_eigenvalue(self.qubit_op) self.assertAlmostEqual(output.eigenvalue, -1.85727503, places=1)
def test_vqe_var_forms(self, depth, places): """ VQE Var Forms test """ aqua_globals.random_seed = self.seed result = VQE( self.qubit_op, RY(self.qubit_op.num_qubits, depth=depth, entanglement='sca', entanglement_gate='crx', skip_final_ry=True), L_BFGS_B()).run( QuantumInstance(BasicAer.get_backend('statevector_simulator'), shots=1, seed_simulator=aqua_globals.random_seed, seed_transpiler=aqua_globals.random_seed)) self.assertAlmostEqual(result['energy'], -1.85727503, places=places)
def test_vqe_qasm_snapshot_mode(self): """ VQE Aer qasm_simulator snapshot mode test """ try: # pylint: disable=import-outside-toplevel from qiskit import Aer except Exception as ex: # pylint: disable=broad-except self.skipTest("Aer doesn't appear to be installed. Error: '{}'".format(str(ex))) return backend = Aer.get_backend('qasm_simulator') num_qubits = self.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, max_evals_grouped=1) quantum_instance = QuantumInstance(backend, shots=1) result = algo.run(quantum_instance) self.assertAlmostEqual(result['energy'], -1.85727503, places=6)
def setUp(self): super().setUp() try: self.driver = PySCFDriver(atom='H .0 .0 .0; H .0 .0 0.735', unit=UnitsType.ANGSTROM, charge=0, spin=0, basis='sto3g') except QiskitChemistryError: self.skipTest('PYSCF driver does not appear to be installed') self.npme = NumPyMinimumEigensolver() self.vqe = VQE(var_form=RY(2)) self.vqe.set_backend(BasicAer.get_backend('statevector_simulator')) self.reference_energy = -1.137306