def test_exact_eval(self): """ exact eval test """ depth = 1 var_form = RYRZ(self.qubit_op.num_qubits, depth) circuit = var_form.construct_circuit( np.array(np.random.randn(var_form.num_parameters))) run_config = RunConfig(shots=1) backend = BasicAer.get_backend('statevector_simulator') matrix_mode = self.qubit_op.eval('matrix', circuit, backend, run_config=run_config)[0] non_matrix_mode = self.qubit_op.eval('paulis', circuit, backend, run_config=run_config)[0] diff = abs(matrix_mode - non_matrix_mode) self.assertLess( diff, 0.01, "Values: ({} vs {})".format(matrix_mode, non_matrix_mode)) run_config = RunConfig(shots=1) compile_config = {'pass_manager': PassManager()} non_matrix_mode = self.qubit_op.eval('paulis', circuit, backend, run_config=run_config, compile_config=compile_config)[0] diff = abs(matrix_mode - non_matrix_mode) self.assertLess( diff, 0.01, "Without any pass manager, Values: ({} vs {})".format( matrix_mode, non_matrix_mode))
def test_submit_multiple_circuits(self): """ submit multiple circuits test """ num_qubits = 4 pauli_term = [] for pauli_label in itertools.product('IXYZ', repeat=num_qubits): coeff = np.random.random(1)[0] pauli_term.append([coeff, Pauli.from_label(pauli_label)]) op = Operator(paulis=pauli_term) depth = 1 var_form = RYRZ(op.num_qubits, depth) circuit = var_form.construct_circuit( np.array(np.random.randn(var_form.num_parameters))) run_config = RunConfig(shots=1) backend = BasicAer.get_backend('statevector_simulator') non_matrix_mode = op.eval('paulis', circuit, backend, run_config=run_config)[0] matrix_mode = op.eval('matrix', circuit, backend, run_config=run_config)[0] self.assertAlmostEqual(matrix_mode, non_matrix_mode, 6)
def setUp(self): super().setUp() seed = 0 np.random.seed(seed) aqua_globals.random_seed = seed self.num_qubits = 3 paulis = [ Pauli.from_label(pauli_label) for pauli_label in itertools.product('IXYZ', repeat=self.num_qubits) ] weights = np.random.random(len(paulis)) self.qubit_op = WeightedPauliOperator.from_list(paulis, weights) self.var_form = RYRZ(self.qubit_op.num_qubits, 1) qasm_simulator = BasicAer.get_backend('qasm_simulator') self.quantum_instance_qasm = QuantumInstance(qasm_simulator, shots=65536, seed_simulator=seed, seed_transpiler=seed) statevector_simulator = BasicAer.get_backend('statevector_simulator') self.quantum_instance_statevector = QuantumInstance( statevector_simulator, shots=1, seed_simulator=seed, seed_transpiler=seed)
def setUp(self): super().setUp() seed = 0 aqua_globals.random_seed = seed self.num_qubits = 3 paulis = [ Pauli.from_label(pauli_label) for pauli_label in itertools.product('IXYZ', repeat=self.num_qubits) ] weights = aqua_globals.random.random(len(paulis)) self.qubit_op = WeightedPauliOperator.from_list(paulis, weights) warnings.filterwarnings('ignore', category=DeprecationWarning) self.var_form = RYRZ(self.qubit_op.num_qubits, 1) warnings.filterwarnings('always', category=DeprecationWarning) qasm_simulator = BasicAer.get_backend('qasm_simulator') self.quantum_instance_qasm = QuantumInstance(qasm_simulator, shots=65536, seed_simulator=seed, seed_transpiler=seed) statevector_simulator = BasicAer.get_backend('statevector_simulator') self.quantum_instance_statevector = \ QuantumInstance(statevector_simulator, shots=1, seed_simulator=seed, seed_transpiler=seed)
def energy_opt(parameters): var_form = RYRZ(qubitOp.num_qubits, depth=1, entanglement="linear") #var_form = UCCSD(qubitOp.num_qubits, depth=1, num_orbitals=num_spin_orbitals, num_particles=num_particles, # active_occupied=None, active_unoccupied=None, initial_state=HF_state, # qubit_mapping="jordan_wigner", two_qubit_reduction = False, num_time_slices = 1, shallow_circuit_concat = True, z2_symmetries = None) circuit = var_form.construct_circuit(parameters) energy = E(circuit, qubitOp, qr_size) if plottingTime: values.append(energy) print(energy) return energy
def test_vqc_with_max_evals_grouped(self, use_circuits): """ 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) # 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) # set up algorithm vqc = VQC(optimizer, feature_map, var_form, self.training_data, self.testing_data, max_evals_grouped=2) # sort parameters for reproducibility if use_circuits: vqc._feature_map_params = list(x) vqc._var_form_params = list(theta) 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_saving_and_loading_one_circ(self): """ Saving and Loading one Circ test """ with tempfile.NamedTemporaryFile(suffix='.inp', delete=True) as cache_tmp_file: cache_tmp_file_name = cache_tmp_file.name var_form = RYRZ(num_qubits=4, depth=5) backend = BasicAer.get_backend('statevector_simulator') params0 = aqua_globals.random.random_sample( var_form.num_parameters) circ0 = var_form.construct_circuit(params0) qi0 = QuantumInstance(backend, circuit_caching=True, cache_file=cache_tmp_file_name, skip_qobj_deepcopy=True, skip_qobj_validation=True, seed_simulator=self.seed, seed_transpiler=self.seed) _ = qi0.execute([circ0]) with open(cache_tmp_file_name, "rb") as cache_handler: saved_cache = pickle.load(cache_handler, encoding="ASCII") self.assertIn('qobjs', saved_cache) self.assertIn('mappings', saved_cache) qobjs = [Qobj.from_dict(qob) for qob in saved_cache['qobjs']] self.assertTrue(isinstance(qobjs[0], Qobj)) self.assertGreaterEqual(len(saved_cache['mappings'][0][0]), 50) qi1 = QuantumInstance(backend, circuit_caching=True, cache_file=cache_tmp_file_name, skip_qobj_deepcopy=True, skip_qobj_validation=True, seed_simulator=self.seed, seed_transpiler=self.seed) params1 = aqua_globals.random.random_sample( var_form.num_parameters) circ1 = var_form.construct_circuit(params1) qobj1 = qi1.circuit_cache.load_qobj_from_cache( [circ1], 0, run_config=qi1.run_config) self.assertTrue(isinstance(qobj1, Qobj)) _ = qi1.execute([circ1]) self.assertEqual(qi0.circuit_cache.mappings, qi1.circuit_cache.mappings) self.assertLessEqual(qi1.circuit_cache.misses, 0)
def test_vqc_minibatching_no_gradient_support(self): """ vqc minibatching with no gradient support test """ n_dim = 2 # dimension of each data point seed = 1024 aqua_globals.random_seed = seed _, training_input, test_input, _ = ad_hoc_data(training_size=6, test_size=3, n=n_dim, gap=0.3, 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_minibatching_with_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 = L_BFGS_B(maxfun=100) feature_map = SecondOrderExpansion(feature_dimension=num_qubits, depth=2) var_form = RYRZ(num_qubits=num_qubits, depth=2) vqc = VQC(optimizer, feature_map, var_form, training_input, test_input, minibatch_size=2) # TODO: cache only work with optimization_level 0 quantum_instance = QuantumInstance(backend, seed_simulator=seed, seed_transpiler=seed, optimization_level=0) 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_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_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_vqc_minibatching_no_gradient_support(self): """ vqc minibatching with no gradient support test """ n_dim = 2 # dimension of each data point seed = 1024 np.random.seed(seed) _, training_input, test_input, _ = _ad_hoc_data(training_size=8, test_size=4, n=n_dim, gap=0.3) aqua_globals.random_seed = seed backend = BasicAer.get_backend('statevector_simulator') num_qubits = n_dim optimizer = 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_vqc_minibatching_with_gradient_support(self): """ vqc minibatching with 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=4, test_size=2, n=n_dim, gap=0.3, plot_data=False) backend = BasicAer.get_backend('statevector_simulator') num_qubits = n_dim optimizer = L_BFGS_B(maxfun=30) feature_map = SecondOrderExpansion(feature_dimension=num_qubits, depth=2) var_form = RYRZ(num_qubits=num_qubits, depth=1) 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 = 0.5 self.log.debug(result['testing_accuracy']) self.assertAlmostEqual(result['testing_accuracy'], vqc_accuracy, places=3)
def test_create_from_paulis_0(self): """Test with single paulis.""" num_qubits = 3 for pauli_label in itertools.product('IXYZ', repeat=num_qubits): coeff = np.random.random(1)[0] pauli_term = [coeff, Pauli.from_label(pauli_label)] op = Operator(paulis=[pauli_term]) depth = 1 var_form = RYRZ(op.num_qubits, depth) circuit = var_form.construct_circuit(np.array(np.random.randn(var_form.num_parameters))) run_config = {'shots': 1} backend = BasicAer.get_backend('statevector_simulator') non_matrix_mode = op.eval('paulis', circuit, backend, run_config=run_config)[0] matrix_mode = op.eval('matrix', circuit, backend, run_config=run_config)[0] self.assertAlmostEqual(matrix_mode, non_matrix_mode, 6)
def test_vqc_minibatching_with_gradient_support(self, use_circuits): """ vqc minibatching with 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=4, test_size=2, n=n_dim, gap=0.3, plot_data=False) backend = BasicAer.get_backend('statevector_simulator') num_qubits = n_dim optimizer = L_BFGS_B(maxfun=30) feature_map = SecondOrderExpansion(feature_dimension=num_qubits, depth=2) var_form = RYRZ(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) # set up algorithm vqc = VQC(optimizer, feature_map, var_form, training_input, test_input, minibatch_size=2) # sort parameters for reproducibility if use_circuits: vqc._feature_map_params = list(x) vqc._var_form_params = list(theta) quantum_instance = QuantumInstance(backend, seed_simulator=seed, seed_transpiler=seed) result = vqc.run(quantum_instance) vqc_accuracy = 0.5 self.log.debug(result['testing_accuracy']) self.assertAlmostEqual(result['testing_accuracy'], vqc_accuracy, places=3)
def test_deprecated_variational_forms(self): """Test running the VQE on a deprecated VariationalForm object.""" warnings.filterwarnings('ignore', category=DeprecationWarning) wavefunction = RYRZ(2) vqe = VQE(self.h2_op, wavefunction, L_BFGS_B()) warnings.filterwarnings('always', category=DeprecationWarning) result = vqe.run(self.statevector_simulator) self.assertAlmostEqual(result.eigenvalue.real, self.h2_energy)
def test_create_from_matrix(self): """Test with matrix initialization.""" for num_qubits in range(1, 3): m_size = np.power(2, num_qubits) matrix = np.random.rand(m_size, m_size) op = Operator(matrix=matrix) depth = 1 var_form = RYRZ(op.num_qubits, depth) circuit = var_form.construct_circuit(np.array(np.random.randn(var_form.num_parameters))) backend = BasicAer.get_backend('statevector_simulator') run_config = {'shots': 1} non_matrix_mode = op.eval('paulis', circuit, backend, run_config=run_config)[0] matrix_mode = op.eval('matrix', circuit, backend, run_config=run_config)[0] self.assertAlmostEqual(matrix_mode, non_matrix_mode, 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 test_vqe(self, var_form_type): """ VQE test """ var_form = RYRZ(self.qubit_op.num_qubits) if var_form_type is QuantumCircuit: params = ParameterVector('θ', var_form.num_parameters) var_form = var_form.construct_circuit(params) vqe = VQE(self.qubit_op, var_form, L_BFGS_B()) result = vqe.run(QuantumInstance(BasicAer.get_backend('statevector_simulator'), basis_gates=['u1', 'u2', 'u3', 'cx', 'id'], coupling_map=[[0, 1]], seed_simulator=aqua_globals.random_seed, seed_transpiler=aqua_globals.random_seed)) self.assertAlmostEqual(result.eigenvalue.real, -1.85727503) np.testing.assert_array_almost_equal(result.eigenvalue.real, -1.85727503, 5) self.assertEqual(len(result.optimal_point), 16) self.assertIsNotNone(result.cost_function_evals) self.assertIsNotNone(result.optimizer_time)
def getDefaultVQC(optimiser,feature_map): var_form = RYRZ( num_qubits=int(args.numberQbits), depth=int(args.varFormDepth), entanglement='full', entanglement_gate='cx', ) vqc = VQC(optimiser, feature_map, var_form, trainDict, testDict, max_evals_grouped=1,minibatch_size=int(args.minibatchsize)) return vqc
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_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_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 solve_maxcut_vqe(graph, solve_type): backend = get_compute_backend(solve_type) operator, offset = get_operator(graph) vqe = VQE( operator, RYRZ(graph.number_of_nodes(), depth=3, entanglement="linear"), L_BFGS_B(maxfun=6000), ) result = vqe.run(QuantumInstance(backend)) return result
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_readme_sample(self): """ readme sample test """ # pylint: disable=import-outside-toplevel # --- Exact copy of sample code ---------------------------------------- from qiskit.chemistry import FermionicOperator from qiskit.chemistry.drivers import PySCFDriver, UnitsType from qiskit.aqua.operators import Z2Symmetries # Use PySCF, a classical computational chemistry software # package, to compute the one-body and two-body integrals in # molecular-orbital basis, necessary to form the Fermionic operator driver = PySCFDriver(atom='H .0 .0 .0; H .0 .0 0.735', unit=UnitsType.ANGSTROM, basis='sto3g') molecule = driver.run() num_particles = molecule.num_alpha + molecule.num_beta num_spin_orbitals = molecule.num_orbitals * 2 # Build the qubit operator, which is the input to the VQE algorithm in Aqua ferm_op = FermionicOperator(h1=molecule.one_body_integrals, h2=molecule.two_body_integrals) map_type = 'PARITY' qubit_op = ferm_op.mapping(map_type) qubit_op = Z2Symmetries.two_qubit_reduction(qubit_op, num_particles) num_qubits = qubit_op.num_qubits # setup a classical optimizer for VQE from qiskit.aqua.components.optimizers import L_BFGS_B optimizer = L_BFGS_B() # setup the initial state for the variational form from qiskit.chemistry.components.initial_states import HartreeFock init_state = HartreeFock(num_qubits, num_spin_orbitals, num_particles) # setup the variational form for VQE from qiskit.aqua.components.variational_forms import RYRZ var_form = RYRZ(num_qubits, initial_state=init_state) # setup and run VQE from qiskit.aqua.algorithms import VQE algorithm = VQE(qubit_op, var_form, optimizer) # set the backend for the quantum computation from qiskit import Aer backend = Aer.get_backend('statevector_simulator') result = algorithm.run(backend) print(result['energy']) # ---------------------------------------------------------------------- self.assertAlmostEqual(result['energy'], -1.8572750301938803, places=6)
def test_vqe_optimizers(self, optimizer_cls, places, max_evals_grouped): """ VQE Optimizers test """ result = VQE(self.qubit_op, RYRZ(self.qubit_op.num_qubits), optimizer_cls(), max_evals_grouped=max_evals_grouped).run( QuantumInstance(BasicAer.get_backend('statevector_simulator'), shots=1, seed_simulator=aqua_globals.random_seed, seed_transpiler=aqua_globals.random_seed)) self.assertAlmostEqual(result.eigenvalue.real, -1.85727503, places=places)
def test_vqc_minibatching_with_gradient_support(self, mode): """ vqc minibatching with 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=4, test_size=2, n=n_dim, gap=0.3, plot_data=False) backend = BasicAer.get_backend('statevector_simulator') optimizer = L_BFGS_B(maxfun=30) # set up data encoding circuit data_preparation = self.data_preparation[mode] # set up wavefunction if mode == 'wrapped': warnings.filterwarnings('ignore', category=DeprecationWarning) wavefunction = RYRZ(2, depth=1) else: wavefunction = TwoLocal(2, ['ry', 'rz'], 'cz', reps=1, insert_barriers=True) theta = ParameterVector('theta', wavefunction.num_parameters) resorted = [] for i in range(4): layer = wavefunction.ordered_parameters[4 * i:4 * (i + 1)] resorted += layer[::2] resorted += layer[1::2] wavefunction.assign_parameters(dict(zip(resorted, theta)), inplace=True) if mode == 'circuit': wavefunction = QuantumCircuit(2).compose(wavefunction) # set up algorithm vqc = VQC(optimizer, data_preparation, wavefunction, training_input, test_input, minibatch_size=2) if mode in ['circuit', 'library']: vqc._feature_map_params = self._sorted_data_params vqc._var_form_params = list(theta) else: warnings.filterwarnings('always', category=DeprecationWarning) quantum_instance = QuantumInstance(backend, seed_simulator=seed, seed_transpiler=seed) result = vqc.run(quantum_instance) vqc_accuracy = 0.5 self.log.debug(result['testing_accuracy']) self.assertAlmostEqual(result['testing_accuracy'], vqc_accuracy, places=3)
def test_real_eval(self): depth = 1 var_form = RYRZ(self.qubitOp.num_qubits, depth) circuit = var_form.construct_circuit(np.array(np.random.randn(var_form.num_parameters))) # self.qubitOp.coloring = None run_config_ref = {'shots': 1} run_config = {'shots': 10000} reference = self.qubitOp.eval('matrix', circuit, get_aer_backend( 'statevector_simulator'), run_config=run_config_ref)[0] reference = reference.real backend = get_aer_backend('qasm_simulator') paulis_mode = self.qubitOp.eval('paulis', circuit, backend, run_config=run_config) grouped_paulis_mode = self.qubitOp.eval('grouped_paulis', circuit, backend, run_config=run_config) paulis_mode_p_3sigma = paulis_mode[0] + 3 * paulis_mode[1] paulis_mode_m_3sigma = paulis_mode[0] - 3 * paulis_mode[1] grouped_paulis_mode_p_3sigma = grouped_paulis_mode[0] + 3 * grouped_paulis_mode[1] grouped_paulis_mode_m_3sigma = grouped_paulis_mode[0] - 3 * grouped_paulis_mode[1] self.assertLessEqual(reference, paulis_mode_p_3sigma.real) self.assertGreaterEqual(reference, paulis_mode_m_3sigma.real) self.assertLessEqual(reference, grouped_paulis_mode_p_3sigma.real) self.assertGreaterEqual(reference, grouped_paulis_mode_m_3sigma.real) run_config = {'shots': 10000} compile_config = {'pass_manager': PassManager()} paulis_mode = self.qubitOp.eval('paulis', circuit, backend, run_config=run_config, compile_config=compile_config) grouped_paulis_mode = self.qubitOp.eval('grouped_paulis', circuit, backend, run_config=run_config, compile_config=compile_config) paulis_mode_p_3sigma = paulis_mode[0] + 3 * paulis_mode[1] paulis_mode_m_3sigma = paulis_mode[0] - 3 * paulis_mode[1] grouped_paulis_mode_p_3sigma = grouped_paulis_mode[0] + 3 * grouped_paulis_mode[1] grouped_paulis_mode_m_3sigma = grouped_paulis_mode[0] - 3 * grouped_paulis_mode[1] self.assertLessEqual(reference, paulis_mode_p_3sigma.real, "Without any pass manager") self.assertGreaterEqual(reference, paulis_mode_m_3sigma.real, "Without any pass manager") self.assertLessEqual(reference, grouped_paulis_mode_p_3sigma.real, "Without any pass manager") self.assertGreaterEqual(reference, grouped_paulis_mode_m_3sigma.real, "Without any pass manager")
def test_vqe(self): """ VQE test """ quantum_instance = QuantumInstance(BasicAer.get_backend('statevector_simulator'), basis_gates=['u1', 'u2', 'u3', 'cx', 'id'], coupling_map=[[0, 1]], seed_simulator=aqua_globals.random_seed, seed_transpiler=aqua_globals.random_seed) vqe = VQE(var_form=RYRZ(self.qubit_op.num_qubits), optimizer=L_BFGS_B(), quantum_instance=quantum_instance) output = vqe.compute_minimum_eigenvalue(self.qubit_op) self.assertAlmostEqual(output.eigenvalue, -1.85727503)