def test_qsvm_variational_directly(self): np.random.seed(self.random_seed) backend = get_aer_backend('qasm_simulator') num_qubits = 2 optimizer = SPSA(max_trials=10, c0=4.0, skip_calibration=True) optimizer.set_options(save_steps=1) feature_map = SecondOrderExpansion(num_qubits=num_qubits, depth=2) var_form = RYRZ(num_qubits=num_qubits, depth=3) svm = QSVMVariational(optimizer, feature_map, var_form, self.training_data, self.testing_data) svm.random_seed = self.random_seed quantum_instance = QuantumInstance(backend, shots=1024, seed=self.random_seed, seed_mapper=self.random_seed) result = svm.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(result['testing_accuracy'], 1.0) file_path = self._get_resource_path('qsvm_variational_test.npz') svm.save_model(file_path) self.assertTrue(os.path.exists(file_path)) loaded_svm = QSVMVariational(optimizer, feature_map, var_form, self.training_data, None) loaded_svm.load_model(file_path) np.testing.assert_array_almost_equal(loaded_svm.ret['opt_params'], self.ref_opt_params, decimal=4) loaded_test_acc = loaded_svm.test(svm.test_dataset[0], svm.test_dataset[1], quantum_instance) self.assertEqual(result['testing_accuracy'], loaded_test_acc) if os.path.exists(file_path): try: os.remove(file_path) except: pass
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, paulis_grouping='random', expansion_mode='suzuki', expansion_order=2, shallow_circuit_concat=True) quantum_instance = QuantumInstance(backend, shots=100, pass_manager=PassManager(), seed=self.random_seed, 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_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) quantum_instance = QuantumInstance(backend, shots=shots) results = vqe.run(quantum_instance) self.assertAlmostEqual(results['energy'], self.reference_energy, places=6)
def test_spsa(self): optimizer = SPSA(max_trials=10000) res = self._optimize(optimizer) self.assertLessEqual(res[2], 100000)
p += 1 np.savez(data_file, seqs=seq_array, costs=cost_array, coeffs=coeff_arr, inserts=insert_vals, times=np.array(times), states=np.array(states), angles=np.array(angle_arr), energies=np.array(energies)) for s in alignment: print(s) # VQE if method == "VQE": opt = SPSA(max_trials=100) trial = RY(Hamilt.num_qubits, depth=10, entanglement='linear') solver = VQE(Hamilt, trial, opt, "paulis") simulator = IBMQ.get_backend(backend) instance = QuantumInstance(backend=simulator, shots=1024) print("Starting job") result = solver.run(instance) print("Job finished?") state = result["eigvecs"][0] energy = result["eigvals"][0] + shift positions = MSA_column.sample_most_likely(state, rev_inds) for (key, value) in positions.items(): print(key, value)