def test_eoh(self): SIZE = 2 temp = np.random.random((2**SIZE, 2**SIZE)) h1 = temp + temp.T qubitOp = Operator(matrix=h1) temp = np.random.random((2**SIZE, 2**SIZE)) h1 = temp + temp.T evoOp = Operator(matrix=h1) state_in = get_initial_state_instance('CUSTOM') state_in.init_args(SIZE, state='random') evo_time = 1 num_time_slices = 100 eoh = get_algorithm_instance('EOH') eoh.setup_quantum_backend(skip_transpiler=True) # self.log.debug('state_out:\n\n') eoh.init_args(qubitOp, 'paulis', state_in, evoOp, evo_time, num_time_slices) ret = eoh.run() self.log.debug('Evaluation result: {}'.format(ret))
def test_svm_qkernel_directly(self): svm = get_algorithm_instance("QSVM.Kernel") svm.setup_quantum_backend(backend='local_qasm_simulator_py', shots=1024) svm.random_seed = self.random_seed params = { 'problem': {'name': 'svm_classification', 'random_seed': self.random_seed}, 'algorithm': {'name': 'QSVM.Kernel'}, 'backend': {'name': 'local_qasm_simulator_py', 'shots': 1024}, 'multiclass_extension': {'name': 'AllPairs', 'estimator': 'QKernalSVM_Estimator'}, } svm.init_params(params, self.svm_input) result = svm.run() np.testing.assert_array_almost_equal( result['kernel_matrix_training'], self.ref_kernel_matrix_training, decimal=4) np.testing.assert_array_almost_equal( result['kernel_matrix_testing'], self.ref_kernel_matrix_testing, decimal=4) self.assertEqual(len(result['svm']['support_vectors']), 4) np.testing.assert_array_almost_equal( result['svm']['support_vectors'], self.ref_support_vectors, decimal=4) np.testing.assert_array_almost_equal(result['svm']['alphas'], self.ref_alpha, decimal=4) np.testing.assert_array_almost_equal(result['svm']['bias'], self.ref_bias, decimal=4) self.assertEqual(result['test_success_ratio'], 0.0)
def test_svm_variational_directly(self): np.random.seed(self.random_seed) svm = get_algorithm_instance("QSVM.Variational") svm.random_seed = self.random_seed svm.setup_quantum_backend(backend='local_qasm_simulator', shots=1024) optimizer = get_optimizer_instance('SPSA') optimizer.init_args(max_trials=10, c0=4.0, skip_calibration=True) optimizer.set_options(save_steps=1) num_qubits = 2 feature_map = get_feature_map_instance('SecondOrderExpansion') feature_map.init_args(num_qubits=num_qubits, depth=2) var_form = get_variational_form_instance('RYRZ') var_form.init_args(num_qubits=num_qubits, depth=3) svm.init_args(self.training_data, self.testing_data, None, optimizer, feature_map, var_form) result = svm.run() 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'], 0.5)
def test_ee_direct(self): algo = get_algorithm_instance('ExactEigensolver') algo.init_args(self.algo_input.qubit_op, k=1, aux_operators=[]) result = algo.run() self.assertAlmostEqual(result['energy'], -1.85727503) np.testing.assert_array_almost_equal(result['energies'], [-1.85727503]) np.testing.assert_array_almost_equal(result['eigvals'], [-1.85727503+0j])
def test_svm_qkernel_binary_directly(self): svm = get_algorithm_instance("QSVM.Kernel") svm.random_seed = self.random_seed svm.setup_quantum_backend(backend='local_qasm_simulator_py', shots=self.shots) num_qubits = 2 feature_map = get_feature_map_instance('SecondOrderExpansion') feature_map.init_args(num_qubits=num_qubits, depth=2, entangler_map={0: [1]}) svm.init_args(self.training_data, self.testing_data, None, feature_map, None) result = svm.run() np.testing.assert_array_almost_equal(result['kernel_matrix_training'], self.ref_kernel_matrix_training, decimal=4) np.testing.assert_array_almost_equal(result['kernel_matrix_testing'], self.ref_kernel_matrix_testing, decimal=4) self.assertEqual(len(result['svm']['support_vectors']), 4) np.testing.assert_array_almost_equal(result['svm']['support_vectors'], self.ref_support_vectors, decimal=4) np.testing.assert_array_almost_equal(result['svm']['alphas'], self.ref_alpha, decimal=4) np.testing.assert_array_almost_equal(result['svm']['bias'], self.ref_bias, decimal=4) self.assertEqual(result['testing_accuracy'], 0.5)
def test_ee_direct_k4(self): algo = get_algorithm_instance('ExactEigensolver') algo.init_args(self.algo_input.qubit_op, k=4, aux_operators=[]) result = algo.run() self.assertAlmostEqual(result['energy'], -1.85727503) self.assertEqual(len(result['eigvals']), 4) self.assertEqual(len(result['eigvecs']), 4) np.testing.assert_array_almost_equal(result['energies'], [-1.85727503, -1.24458455, -0.88272215, -0.22491125])
def test_cplex_ising_direct(self): algo = get_algorithm_instance('CPLEX.Ising') algo.init_args(self.algo_input.qubit_op, display=0) result = algo.run() self.assertEqual(result['energy'], -20.5) x_dict = result['x_sol'] x = np.array([x_dict[i] for i in sorted(x_dict.keys())]) np.testing.assert_array_equal(maxcut.get_graph_solution(x), [1, 0, 1, 1]) self.assertEqual(maxcut.maxcut_value(x, self.w), 24)
def test_vqe_direct(self): num_qbits = self.algo_input.qubit_op.num_qubits init_state = get_initial_state_instance('ZERO') init_state.init_args(num_qbits) var_form = get_variational_form_instance('RY') var_form.init_args(num_qbits, 3, initial_state=init_state) optimizer = get_optimizer_instance('L_BFGS_B') optimizer.init_args() algo = get_algorithm_instance('VQE') algo.setup_quantum_backend(backend='local_statevector_simulator') algo.init_args(self.algo_input.qubit_op, 'matrix', var_form, optimizer) result = algo.run() self.assertAlmostEqual(result['energy'], -1.85727503)
def test_grover(self, input_file, incremental=True, num_iterations=1): input_file = self._get_resource_path(input_file) # get ground-truth with open(input_file) as f: buf = f.read() if incremental: self.log.debug( 'Testing incremental Grover search on SAT problem instance: \n{}' .format(buf, )) else: self.log.debug( 'Testing Grover search with {} iteration(s) on SAT problem instance: \n{}' .format( num_iterations, buf, )) header = buf.split('\n')[0] self.assertGreaterEqual(header.find('solution'), 0, 'Ground-truth info missing.') self.groundtruth = [ ''.join([ '1' if i > 0 else '0' for i in sorted( [int(v) for v in s.strip().split() if v != '0'], key=abs) ])[::-1] for s in header.split('solutions:' if header.find( 'solutions:') >= 0 else 'solution:')[-1].split(',') ] sat_oracle = get_oracle_instance('SAT') sat_oracle.init_args(buf) grover = get_algorithm_instance('Grover') grover.setup_quantum_backend(backend='qasm_simulator', shots=100) grover.init_args(sat_oracle, num_iterations=num_iterations, incremental=incremental) ret = grover.run() self.log.debug('Ground-truth Solutions: {}.'.format(self.groundtruth)) self.log.debug('Measurement result: {}.'.format( ret['measurements'])) top_measurement = max(ret['measurements'].items(), key=operator.itemgetter(1))[0] self.log.debug('Top measurement: {}.'.format(top_measurement)) if ret['oracle_evaluation']: self.assertIn(top_measurement, self.groundtruth) self.log.debug('Search Result: {}.'.format(ret['result'])) else: self.assertEqual(self.groundtruth, ['']) self.log.debug('Nothing found.')
def test_svm_qkernel_directly(self): svm = get_algorithm_instance("SVM_QKernel") svm.setup_quantum_backend(backend='local_qasm_simulator', shots=1024) svm.random_seed = self.random_seed svm.init_args(self.training_data, self.testing_data, None, print_info=False) result = svm.run() np.testing.assert_array_almost_equal( result['kernel_matrix_training'], self.ref_kernel_matrix_training, decimal=4) np.testing.assert_array_almost_equal( result['kernel_matrix_testing'], self.ref_kernel_matrix_testing, decimal=4) self.assertEqual(len(result['svm']['support_vectors']), 4) np.testing.assert_array_almost_equal( result['svm']['support_vectors'], self.ref_support_vectors, decimal=4) self.assertEqual(result['test_success_ratio'], 0.5)
def test_qaoa(self, w, p, solutions): self.log.debug('Testing {}-step QAOA with MaxCut on graph\n{}'.format(p, w)) np.random.seed(0) optimizer = get_optimizer_instance('COBYLA') qubitOp, offset = maxcut.get_maxcut_qubitops(w) qaoa = get_algorithm_instance('QAOA') qaoa.init_args(qubitOp, 'matrix', p, optimizer) qaoa.setup_quantum_backend(backend='local_statevector_simulator', shots=100) result = qaoa.run() x = maxcut.sample_most_likely(result['eigvecs'][0]) graph_solution = maxcut.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(maxcut.maxcut_value(x, w))) self.assertIn(''.join([str(int(i)) for i in graph_solution]), solutions)
def calcular_energia_clasico(propiedadesmolecula, operadorqubit, energy_shift, supervisorderesultados=None): """Esta función usa obtiene la energía de enlace menor mediante el cálculo del menor autovalor del sistema""" exact_eigensolver = get_algorithm_instance('ExactEigensolver') exact_eigensolver.init_args(operadorqubit, k=1) ret = exact_eigensolver.run() if supervisorderesultados: eventoderesultados = Evento("evento de resultados") eventoderesultados.registro(supervisorderesultados) eventoderesultados.anunciarse({ "mensaje": "The computed energy is: {:.12f}".format(ret["eigvals"][0].real) }) eventoderesultados.anunciarse({ "mensaje": "The total ground state energy is: {:.12f}".format( ret["eigvals"][0].real + energy_shift + propiedadesmolecula["energia_de_repulsion_nuclear"]) }) eventoderesultados.dar_de_baja_todos()
def test_grover(self, input_file, num_iterations=1): self.log.debug( 'Testing Grover search with {} iteration(s) on SAT problem instance: \n{}' .format( num_iterations, open(input_file).read(), )) # get ground-truth with open(input_file) as f: header = f.readline() self.assertGreaterEqual(header.find('solution'), 0, 'Ground-truth info missing.') self.groundtruth = [ ''.join([ '1' if i > 0 else '0' for i in sorted( [int(v) for v in s.strip().split() if v != '0'], key=abs) ])[::-1] for s in header.split('solutions:' if header.find( 'solutions:') >= 0 else 'solution:')[-1].split(',') ] sat_oracle = get_oracle_instance('SAT') with open(input_file) as f: sat_oracle.init_args(f.read()) grover = get_algorithm_instance('Grover') grover.setup_quantum_backend(backend='local_qasm_simulator', shots=100) grover.init_args(sat_oracle, num_iterations=num_iterations) ret = grover.run() self.log.debug('Ground-truth Solutions: {}.'.format(self.groundtruth)) self.log.debug('Measurement result: {}.'.format( ret['measurements'])) top_measurement = max(ret['measurements'].items(), key=operator.itemgetter(1))[0] self.log.debug('Top measurement: {}.'.format(top_measurement)) self.log.debug('Search Result: {}.'.format(ret['result'])) self.assertIn(top_measurement, self.groundtruth)
def test_vqe_2_iqpe(self): num_qbits = self.algo_input.qubit_op.num_qubits var_form = get_variational_form_instance('RYRZ') var_form.init_args(num_qbits, 3) optimizer = get_optimizer_instance('SPSA') optimizer.init_args(max_trials=10) # optimizer.set_options(**{'max_trials': 500}) algo = get_algorithm_instance('VQE') algo.setup_quantum_backend(backend='qasm_simulator') algo.init_args(self.algo_input.qubit_op, 'paulis', var_form, optimizer) result = algo.run() self.log.debug('VQE result: {}.'.format(result)) self.ref_eigenval = -1.85727503 num_time_slices = 50 num_iterations = 11 state_in = VarFormBased() state_in.init_args(var_form, result['opt_params']) iqpe = get_algorithm_instance('IQPE') iqpe.setup_quantum_backend(backend='qasm_simulator', shots=100, skip_transpiler=True) iqpe.init_args( self.algo_input.qubit_op, state_in, num_time_slices, num_iterations, paulis_grouping='random', expansion_mode='suzuki', expansion_order=2, ) result = iqpe.run() 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)
n = 2 # dimension of each data point training_dataset_size = 20 testing_dataset_size = 10 sample_Total, training_input, test_input, class_labels = datasets.userDefinedData( file='bank1000.csv', location='', training_size=training_dataset_size, test_size=testing_dataset_size, class_labels=[0, 1], n=n, PLOT_DATA=False) datapoints, class_to_label = split_dataset_to_data_and_labels(test_input) svm = get_algorithm_instance("QSVM.Kernel") svm.random_seed = 10598 svm.setup_quantum_backend(backend='statevector_simulator') feature_map = get_feature_map_instance('SecondOrderExpansion') feature_map.init_args(num_qubits=2, depth=2, entanglement='linear') svm.init_args(training_input, test_input, datapoints[0], feature_map) print("Running algo") result = svm.run() print("kernel matrix during the training:") kernel_matrix = result['kernel_matrix_training'] img = plt.imshow(np.asmatrix(kernel_matrix), interpolation='nearest',
def test_qpe(self, qubitOp): self.algorithm = 'QPE' self.log.debug('Testing QPE') self.qubitOp = qubitOp exact_eigensolver = get_algorithm_instance('ExactEigensolver') exact_eigensolver.init_args(self.qubitOp, k=1) results = exact_eigensolver.run() w = results['eigvals'] v = results['eigvecs'] self.qubitOp._check_representation('matrix') np.testing.assert_almost_equal(self.qubitOp.matrix @ v[0], w[0] * v[0]) np.testing.assert_almost_equal( expm(-1.j * self.qubitOp.matrix) @ v[0], np.exp(-1.j * w[0]) * v[0]) self.ref_eigenval = w[0] self.ref_eigenvec = v[0] self.log.debug('The exact eigenvalue is: {}'.format( self.ref_eigenval)) self.log.debug('The corresponding eigenvector: {}'.format( self.ref_eigenvec)) num_time_slices = 50 num_iterations = 12 iqpe = get_algorithm_instance('IQPE') iqpe.setup_quantum_backend(backend='local_qasm_simulator', shots=100, skip_transpiler=True) state_in = get_initial_state_instance('CUSTOM') state_in.init_args(self.qubitOp.num_qubits, state_vector=self.ref_eigenvec) iqpe.init_args( self.qubitOp, state_in, num_time_slices, num_iterations, paulis_grouping='random', expansion_mode='suzuki', expansion_order=2, ) result = iqpe.run() # self.log.debug('operator paulis:\n{}'.format(self.qubitOp.print_operators('paulis'))) # self.log.debug('qpe circuit:\n\n{}'.format(result['circuit']['complete'].qasm())) 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 configurar_VQE(operadorqubit, UCCSD, cobyla, backend): """Esta función obtiene una instancia configurada del algoritmo VQE""" VQE = get_algorithm_instance('VQE') VQE.setup_quantum_backend(backend) VQE.init_args(operadorqubit, 'matrix', UCCSD, cobyla) return VQE
def test_qpe(self, distance): self.algorithm = 'QPE' self.log.debug( 'Testing End-to-End with QPE on H2 with inter-atomic distance {}.'. format(distance)) cfg_mgr = ConfigurationManager() pyscf_cfg = OrderedDict([('atom', 'H .0 .0 .0; H .0 .0 {}'.format(distance)), ('unit', 'Angstrom'), ('charge', 0), ('spin', 0), ('basis', 'sto3g')]) section = {} section['properties'] = pyscf_cfg try: driver = cfg_mgr.get_driver_instance('PYSCF') except ModuleNotFoundError: self.skipTest('PYSCF driver does not appear to be installed') self.molecule = driver.run(section) ferOp = FermionicOperator(h1=self.molecule._one_body_integrals, h2=self.molecule._two_body_integrals) self.qubitOp = ferOp.mapping( map_type='PARITY', threshold=1e-10).two_qubit_reduced_operator(2) exact_eigensolver = get_algorithm_instance('ExactEigensolver') exact_eigensolver.init_args(self.qubitOp, k=1) results = exact_eigensolver.run() self.reference_energy = results['energy'] self.log.debug('The exact ground state energy is: {}'.format( results['energy'])) num_particles = self.molecule._num_alpha + self.molecule._num_beta two_qubit_reduction = True num_orbitals = self.qubitOp.num_qubits + (2 if two_qubit_reduction else 0) qubit_mapping = 'parity' num_time_slices = 50 n_ancillae = 9 qpe = get_algorithm_instance('QPE') qpe.setup_quantum_backend(backend='local_qasm_simulator', shots=100, skip_transpiler=True) state_in = get_initial_state_instance('HartreeFock') state_in.init_args(self.qubitOp.num_qubits, num_orbitals, qubit_mapping, two_qubit_reduction, num_particles) iqft = get_iqft_instance('STANDARD') iqft.init_args(n_ancillae) qpe.init_args(self.qubitOp, state_in, iqft, num_time_slices, n_ancillae, paulis_grouping='random', expansion_mode='suzuki', expansion_order=2) result = qpe.run() self.log.debug('measurement results: {}'.format( result['measurements'])) 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 energy from QPE: {}'.format(result['energy'])) self.log.debug('reference energy: {}'.format( self.reference_energy)) self.log.debug('ref energy (transformed): {}'.format( (self.reference_energy + result['translation']) * result['stretch'])) self.log.debug('ref binary str label: {}'.format( decimal_to_binary((self.reference_energy + result['translation']) * result['stretch'], max_num_digits=n_ancillae + 3, fractional_part_only=True))) np.testing.assert_approx_equal(result['energy'], self.reference_energy, significant=2)