def test_hhl_random_hermitian(self): self.log.debug('Testing HHL with random hermitian matrix') hermitian_params = self.params hermitian_params['eigs']['num_ancillae'] = 4 n = 2 np.random.seed(0) matrix = rmg.random_hermitian(n, eigrange=[0, 1]) vector = random(n) algo_input = LinearSystemInput() algo_input.matrix = matrix algo_input.vector = vector # run ExactLSsolver ref_result = run_algorithm(self.els_params, algo_input) ref_solution = ref_result['solution'] ref_normed = ref_solution / np.linalg.norm(ref_solution) # run hhl hhl_result = run_algorithm(hermitian_params, algo_input) hhl_solution = hhl_result['solution'] hhl_normed = hhl_solution / np.linalg.norm(hhl_solution) # compare result fidelity = state_fidelity(ref_normed, hhl_normed) np.testing.assert_approx_equal(fidelity, 1, significant=2) self.log.debug('HHL solution vector: {}'.format(hhl_solution)) self.log.debug('algebraic solution vector: {}'.format(ref_normed)) self.log.debug('fidelity HHL to algebraic: {}'.format(fidelity)) self.log.debug('probability of result: {}'.format( hhl_result["probability_result"]))
def test_hhl_negative_eigs(self): self.log.debug('Testing HHL with matrix with negative eigenvalues') neg_params = self.params neg_params['eigs']['num_ancillae'] = 4 neg_params['eigs']['negative_evals'] = True neg_params['reciprocal']['negative_evals'] = True n = 2 np.random.seed(0) matrix = rmg.random_diag(n, eigrange=[-1, 1]) vector = random(n) algo_input = LinearSystemInput() algo_input.matrix = matrix algo_input.vector = vector # run ExactLSsolver ref_result = run_algorithm(self.els_params, algo_input) ref_solution = ref_result['solution'] ref_normed = ref_solution / np.linalg.norm(ref_solution) # run hhl hhl_result = run_algorithm(neg_params, algo_input) hhl_solution = hhl_result["solution"] hhl_normed = hhl_solution / np.linalg.norm(hhl_solution) # compare results fidelity = state_fidelity(ref_normed, hhl_normed) np.testing.assert_approx_equal(fidelity, 1, significant=3) self.log.debug('HHL solution vector: {}'.format(hhl_solution)) self.log.debug('algebraic solution vector: {}'.format(ref_normed)) self.log.debug('fidelity HHL to algebraic: {}'.format(fidelity)) self.log.debug('probability of result: {}'.format( hhl_result["probability_result"]))
def test_hhl_diagonal_other_dim(self, n, num_ancillary): self.log.debug('Testing HHL with matrix dimension other than 2**n') dim_params = self.params dim_params['eigs']['num_ancillae'] = num_ancillary dim_params['eigs']['negative_evals'] = True dim_params['reciprocal']['negative_evals'] = True np.random.seed(0) matrix = rmg.random_diag(n, eigrange=[0, 1]) vector = random(n) algo_input = LinearSystemInput() algo_input.matrix = matrix algo_input.vector = vector # run ExactLSsolver ref_result = run_algorithm(self.els_params, algo_input) ref_solution = ref_result['solution'] ref_normed = ref_solution / np.linalg.norm(ref_solution) # run hhl hhl_result = run_algorithm(dim_params, algo_input) hhl_solution = hhl_result['solution'] hhl_normed = hhl_solution / np.linalg.norm(hhl_solution) # compare result fidelity = state_fidelity(ref_normed, hhl_normed) np.testing.assert_approx_equal(fidelity, 1, significant=1) self.log.debug('HHL solution vector: {}'.format(hhl_solution)) self.log.debug('algebraic solution vector: {}'.format(ref_solution)) self.log.debug('fidelity HHL to algebraic: {}'.format(fidelity)) self.log.debug('probability of result: {}'.format( hhl_result["probability_result"]))
def test_hhl_diagonal_qasm(self, vector): self.log.debug('Testing HHL simple test with qasm simulator') qasm_params = self.params matrix = [[1, 0], [0, 1]] qasm_params['input'] = { 'name': 'LinearSystemInput', 'matrix': matrix, 'vector': vector } qasm_params['reciprocal']['scale'] = 0.5 qasm_params['backend']['name'] = 'qasm_simulator' qasm_params['backend']['shots'] = 1000 # run ExactLSsolver self.els_params['input'] = qasm_params['input'] ref_result = run_algorithm(self.els_params) ref_solution = ref_result['solution'] ref_normed = ref_solution / np.linalg.norm(ref_solution) # run hhl hhl_result = run_algorithm(qasm_params) hhl_solution = hhl_result['solution'] hhl_normed = hhl_solution / np.linalg.norm(hhl_solution) # compare results fidelity = state_fidelity(ref_normed, hhl_normed) self.assertGreater(fidelity, 0.8) self.log.debug('HHL solution vector: {}'.format(hhl_solution)) self.log.debug('algebraic solution vector: {}'.format(ref_normed)) self.log.debug('fidelity HHL to algebraic: {}'.format(fidelity)) self.log.debug('probability of result: {}'.format( hhl_result["probability_result"]))
def test_hhl_diagonal_longdivison(self, vector): self.log.debug('Testing HHL simple test in mode LongDivision and ' 'statevector simulator') ld_params = self.params matrix = [[1, 0], [0, 1]] ld_params['input'] = { 'name': 'LinearSystemInput', 'matrix': matrix, 'vector': vector } ld_params['reciprocal']['name'] = 'LongDivision' ld_params['reciprocal']['scale'] = 1.0 # run ExactLSsolver self.els_params['input'] = ld_params['input'] ref_result = run_algorithm(self.els_params) ref_solution = ref_result['solution'] ref_normed = ref_solution / np.linalg.norm(ref_solution) # run hhl hhl_result = run_algorithm(ld_params) hhl_solution = hhl_result['solution'] hhl_normed = hhl_solution / np.linalg.norm(hhl_solution) # compare results fidelity = state_fidelity(ref_normed, hhl_normed) np.testing.assert_approx_equal(fidelity, 1, significant=5) self.log.debug('HHL solution vector: {}'.format(hhl_solution)) self.log.debug('algebraic solution vector: {}'.format(ref_normed)) self.log.debug('fidelity HHL to algebraic: {}'.format(fidelity)) self.log.debug('probability of result: {}'.format( hhl_result["probability_result"]))
def test_hhl_diagonal_negative(self, vector): self.log.debug('Testing HHL simple test in mode Lookup with ' 'statevector simulator') neg_params = self.params matrix = [[1, 0], [0, 1]] neg_params['input'] = { 'name': 'LinearSystemInput', 'matrix': matrix, 'vector': vector } neg_params['eigs']['negative_evals'] = True neg_params['reciprocal']['negative_evals'] = True neg_params['eigs']['num_ancillae'] = 4 # run ExactLSsolver self.els_params['input'] = neg_params['input'] ref_result = run_algorithm(self.els_params) ref_solution = ref_result['solution'] ref_normed = ref_solution / np.linalg.norm(ref_solution) # run hhl hhl_result = run_algorithm(neg_params) hhl_solution = hhl_result['solution'] hhl_normed = hhl_solution / np.linalg.norm(hhl_solution) # compare results fidelity = state_fidelity(ref_normed, hhl_normed) np.testing.assert_approx_equal(fidelity, 1, significant=5) self.log.debug('HHL solution vector: {}'.format(hhl_solution)) self.log.debug('algebraic solution vector: {}'.format(ref_normed)) self.log.debug('fidelity HHL to algebraic: {}'.format(fidelity)) self.log.debug('probability of result: {}'.format( hhl_result["probability_result"]))
def test_qgan_training_run_algo_torch(self): try: algo_input = QGANInput(self._real_data, self._bounds) trained_statevector = run_algorithm(params=self._params_torch, algo_input=algo_input, backend=BasicAer.get_backend('statevector_simulator')) trained_qasm = run_algorithm(self._params_torch, algo_input, backend=BasicAer.get_backend('qasm_simulator')) self.assertAlmostEqual(trained_qasm['rel_entr'], trained_statevector['rel_entr'], delta=0.1) except Exception as e: self.skipTest("Torch may not be installed: '{}'".format(str(e)))
def test_qgan_training_run_algo_numpy(self): algo_input = QGANInput(self._real_data, self._bounds) trained_statevector = run_algorithm( params=self._params_numpy, algo_input=algo_input, backend=BasicAer.get_backend('statevector_simulator')) trained_qasm = run_algorithm( self._params_numpy, algo_input, backend=BasicAer.get_backend('qasm_simulator')) self.assertAlmostEqual(trained_qasm['rel_entr'], trained_statevector['rel_entr'], delta=0.1)
def test_hhl_diagonal_qasm(self, vector): self.log.debug('Testing HHL simple test with qasm simulator') qasm_params = self.params matrix = [[1, 0], [0, 1]] qasm_params['input'] = { 'name': 'LinearSystemInput', 'matrix': matrix, 'vector': vector } qasm_params['backend']['name'] = 'qasm_simulator' qasm_params['backend']['shots'] = 600 # run hhl result = run_algorithm(qasm_params) hhl_solution = result["solution_hhl"] hhl_normed = hhl_solution / np.linalg.norm(hhl_solution) # linear algebra solution linalg_solution = np.linalg.solve(matrix, vector) linalg_normed = linalg_solution / np.linalg.norm(linalg_solution) # compare result fidelity = abs(linalg_normed.dot(hhl_normed.conj()))**2 self.assertTrue(fidelity > 0.8) self.log.debug('HHL solution vector: {}'.format(hhl_solution)) self.log.debug('algebraic solution vector: {}'.format(linalg_solution)) self.log.debug('fidelity HHL to algebraic: {}'.format(fidelity)) self.log.debug('probability of result: {}'.format( result["probability_result"]))
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 ) params = { 'problem': {'name': 'classification', 'random_seed': self.seed, 'skip_qobj_validation': True }, 'algorithm': {'name': 'VQC'}, 'backend': {'provider': 'qiskit.BasicAer', 'name': 'statevector_simulator'}, 'optimizer': {'name': 'COBYLA', 'maxiter': 100}, 'variational_form': {'name': 'RYRZ', 'depth': 3}, 'feature_map': {'name': 'RawFeatureVector', 'feature_dimension': feature_dim} } result = run_algorithm(params, ClassificationInput(training_input, test_input)) self.log.debug(result['testing_accuracy']) self.assertGreater(result['testing_accuracy'], 0.8)
def test_vertex_cover_vqe(self): algorithm_cfg = { 'name': 'VQE', 'operator_mode': 'grouped_paulis', 'max_evals_grouped': 2 } optimizer_cfg = {'name': 'SPSA', 'max_trials': 200} var_form_cfg = { 'name': 'RYRZ', 'depth': 3, } params = { 'problem': { 'name': 'ising', 'random_seed': 100 }, 'algorithm': algorithm_cfg, 'optimizer': optimizer_cfg, 'variational_form': var_form_cfg } backend = BasicAer.get_backend('qasm_simulator') result = run_algorithm(params, self.algo_input, backend=backend) x = vertex_cover.sample_most_likely(len(self.w), result['eigvecs'][0]) sol = vertex_cover.get_graph_solution(x) oracle = self.brute_force() self.assertEqual(np.count_nonzero(sol), oracle)
def test_ee_via_run_algorithm(self): params = {'algorithm': {'name': 'ExactEigensolver'}} result = run_algorithm(params, self.algo_input) 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_set_packing_vqe(self): try: from qiskit import Aer except Exception as e: self.skipTest( "Aer doesn't appear to be installed. Error: '{}'".format( str(e))) return algorithm_cfg = { 'name': 'VQE', 'operator_mode': 'grouped_paulis', 'max_evals_grouped': 2 } optimizer_cfg = {'name': 'SPSA', 'max_trials': 200} var_form_cfg = {'name': 'RY', 'depth': 5, 'entanglement': 'linear'} params = { 'problem': { 'name': 'ising', 'random_seed': 100 }, 'algorithm': algorithm_cfg, 'optimizer': optimizer_cfg, 'variational_form': var_form_cfg } backend = Aer.get_backend('qasm_simulator') result = run_algorithm(params, self.algo_input, backend=backend) x = setpacking.sample_most_likely(len(self.list_of_subsets), result['eigvecs'][0]) ising_sol = setpacking.get_solution(x) oracle = self.brute_force() self.assertEqual(np.count_nonzero(ising_sol), oracle)
def test_qsvm_variational_statevector_via_run_algorithm(self): np.random.seed(self.random_seed) params = { 'problem': { 'name': 'svm_classification', 'random_seed': self.random_seed }, 'algorithm': { 'name': 'QSVM.Variational' }, 'backend': { 'provider': 'qiskit.BasicAer', 'name': 'statevector_simulator' }, 'optimizer': { 'name': 'COBYLA' }, 'variational_form': { 'name': 'RYRZ', 'depth': 3 }, 'feature_map': { 'name': 'SecondOrderExpansion', 'depth': 2 } } result = run_algorithm(params, self.svm_input) ref_train_loss = 0.1059404 np.testing.assert_array_almost_equal(result['training_loss'], ref_train_loss, decimal=4) self.assertEqual(result['testing_accuracy'], 0.5)
def test_partition_vqe(self): algorithm_cfg = { 'name': 'VQE', 'operator_mode': 'grouped_paulis', 'max_evals_grouped': 2 } optimizer_cfg = {'name': 'SPSA', 'max_trials': 200} var_form_cfg = {'name': 'RY', 'depth': 5, 'entanglement': 'linear'} params = { 'problem': { 'name': 'ising', 'random_seed': 100 }, 'algorithm': algorithm_cfg, 'optimizer': optimizer_cfg, 'variational_form': var_form_cfg } backend = BasicAer.get_backend('qasm_simulator') result = run_algorithm(params, self.algo_input, backend=backend) x = partition.sample_most_likely(result['eigvecs'][0]) self.assertNotEqual(x[0], x[1]) self.assertNotEqual(x[2], x[1]) # hardcoded oracle
def test_hhl_diagonal_sv(self, vector): self.log.debug('Testing HHL simple test in mode Lookup with ' 'statevector simulator') matrix = [[1, 0], [0, 1]] self.params['input'] = { 'name': 'LinearSystemInput', 'matrix': matrix, 'vector': vector } # run hhl result = run_algorithm(self.params) hhl_solution = result['solution_hhl'] hhl_normed = hhl_solution/np.linalg.norm(hhl_solution) # linear algebra solution linalg_solution = np.linalg.solve(matrix, vector) linalg_normed = linalg_solution/np.linalg.norm(linalg_solution) # compare result fidelity = state_fidelity(linalg_normed, hhl_normed) np.testing.assert_approx_equal(fidelity, 1, significant=5) self.log.debug('HHL solution vector: {}'.format(hhl_solution)) self.log.debug('algebraic solution vector: {}'.format(linalg_solution)) self.log.debug('fidelity HHL to algebraic: {}'.format(fidelity)) self.log.debug('probability of result: {}'. format(result["probability_result"]))
def test_portfolio_diversification(self): """ portfolio diversification test """ # Something of an integration test # Solve the problem in a classical fashion via CPLEX and compare the solution # Note that CPLEX uses a completely different integer linear programming formulation. x = None try: classical_optimizer = ClassicalOptimizer(self.instance, self.n, self.q) x, classical_cost = classical_optimizer.cplex_solution() except Exception: # pylint: disable=broad-except # This test should not focus on the availability of CPLEX, so we just eat the exception. self.skipTest("CPLEX may be missing.") # Solve the problem using the exact eigensolver params = { 'problem': { 'name': 'ising' }, 'algorithm': { 'name': 'ExactEigensolver' } } result = run_algorithm(params, self.algo_input) quantum_solution = get_portfoliodiversification_solution( self.instance, self.n, self.q, result) ground_level = get_portfoliodiversification_value( self.instance, self.n, self.q, quantum_solution) if x is not None: np.testing.assert_approx_equal(ground_level, classical_cost) np.testing.assert_array_almost_equal(quantum_solution, x, 5)
def test_qsvm_kernel_binary_via_run_algorithm(self): training_input = {'A': np.asarray([[0.6560706, 0.17605998], [0.14154948, 0.06201424], [0.80202323, 0.40582692], [0.46779595, 0.39946754], [0.57660199, 0.21821317]]), 'B': np.asarray([[0.38857596, -0.33775802], [0.49946978, -0.48727951], [-0.30119743, -0.11221681], [-0.16479252, -0.08640519], [0.49156185, -0.3660534]])} test_input = {'A': np.asarray([[0.57483139, 0.47120732], [0.48372348, 0.25438544], [0.08791134, 0.11515506], [0.45988094, 0.32854319], [0.53015085, 0.41539212]]), 'B': np.asarray([[-0.06048935, -0.48345293], [-0.01065613, -0.33910828], [-0.17323832, -0.49535592], [0.14043268, -0.87869109], [-0.15046837, -0.47340207]])} total_array = np.concatenate((test_input['A'], test_input['B'])) params = { 'problem': {'name': 'svm_classification', 'random_seed': self.random_seed}, 'backend': {'shots': self.shots}, 'algorithm': { 'name': 'QSVM.Kernel' } } backend = BasicAer.get_backend('qasm_simulator') algo_input = SVMInput(training_input, test_input, total_array) result = run_algorithm(params, algo_input, backend=backend) self.assertEqual(result['testing_accuracy'], 0.6) self.assertEqual(result['predicted_classes'], ['A', 'A', 'A', 'A', 'A', 'A', 'B', 'A', 'A', 'A'])
def test_exact_cover_vqe(self): """ Exact Cover VQE test """ algorithm_cfg = {'name': 'VQE', 'max_evals_grouped': 2} optimizer_cfg = {'name': 'COBYLA'} var_form_cfg = {'name': 'RYRZ', 'depth': 5} params = { 'problem': { 'name': 'ising', 'random_seed': 10598 }, 'algorithm': algorithm_cfg, 'optimizer': optimizer_cfg, 'variational_form': var_form_cfg } backend = BasicAer.get_backend('statevector_simulator') result = run_algorithm(params, self.algo_input, backend=backend) x = sample_most_likely(result['eigvecs'][0]) ising_sol = exact_cover.get_solution(x) oracle = self._brute_force() self.assertEqual( exact_cover.check_solution_satisfiability(ising_sol, self.list_of_subsets), oracle)
def test_clique_vqe(self): algorithm_cfg = { 'name': 'VQE', 'operator_mode': 'matrix', 'max_evals_grouped': 2 } optimizer_cfg = { 'name': 'COBYLA' } var_form_cfg = { 'name': 'RY', 'depth': 5, 'entanglement': 'linear' } params = { 'problem': {'name': 'ising', 'random_seed': 10598}, 'algorithm': algorithm_cfg, 'optimizer': optimizer_cfg, 'variational_form': var_form_cfg } backend = BasicAer.get_backend('statevector_simulator') result = run_algorithm(params, self.algo_input, backend=backend) x = clique.sample_most_likely(len(self.w), 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_hhl_diagonal_longdivison_sv(self, vector): self.log.debug('Testing HHL simple test in mode LongDivision and ' 'statevector simulator') ld_params = self.params matrix = [[1, 0], [0, 1]] ld_params['input'] = { 'name': 'LinearSystemInput', 'matrix': matrix, 'vector': vector } ld_params['reciprocal']['name'] = 'LongDivision' ld_params['reciprocal']['scale'] = 1.0 # run hhl result = run_algorithm(ld_params) hhl_solution = result["solution_hhl"] hhl_normed = hhl_solution / np.linalg.norm(hhl_solution) # linear algebra solution linalg_solution = np.linalg.solve(matrix, vector) linalg_normed = linalg_solution / np.linalg.norm(linalg_solution) # compare result fidelity = abs(linalg_normed.dot(hhl_normed.conj()))**2 np.testing.assert_approx_equal(fidelity, 1, significant=5) self.log.debug('HHL solution vector: {}'.format(hhl_solution)) self.log.debug('algebraic solution vector: {}'.format(linalg_solution)) self.log.debug('fidelity HHL to algebraic: {}'.format(fidelity)) self.log.debug('probability of result: {}'.format( result["probability_result"]))
def test_set_packing_vqe(self): algorithm_cfg = { 'name': 'VQE', 'operator_mode': 'grouped_paulis', 'batch_mode': True } optimizer_cfg = {'name': 'SPSA', 'max_trials': 200} var_form_cfg = {'name': 'RY', 'depth': 5, 'entanglement': 'linear'} params = { 'problem': { 'name': 'ising', 'random_seed': 100 }, 'algorithm': algorithm_cfg, 'optimizer': optimizer_cfg, 'variational_form': var_form_cfg } backend = Aer.get_backend('qasm_simulator') result = run_algorithm(params, self.algo_input, backend=backend) x = setpacking.sample_most_likely(len(self.list_of_subsets), result['eigvecs'][0]) ising_sol = setpacking.get_solution(x) oracle = self.brute_force() self.assertEqual(np.count_nonzero(ising_sol), oracle)
def test_qsvm_variational_with_minibatching(self): np.random.seed(self.random_seed) params = { 'problem': {'name': 'svm_classification', 'random_seed': self.random_seed}, 'algorithm': {'name': 'QSVM.Variational', 'minibatch_size': 2}, 'backend': {'provider': 'qiskit.BasicAer', 'name': 'qasm_simulator', 'shots': 1024}, 'optimizer': {'name': 'SPSA', 'max_trials': 30, 'save_steps': 1}, 'variational_form': {'name': 'RYRZ', 'depth': 3}, 'feature_map': {'name': 'SecondOrderExpansion', 'depth': 2} } result = run_algorithm(params, self.svm_input) # The results will differ from the above even though the batch size is larger than the trainingset size due # to the shuffle during minibatching # minibatching_ref_opt_params = np.asarray([-18.8965, -36.9197, 2.3568, 14.9087, 43.8633, 7.1394, # 12.1298, 23.7219, 36.5693, 21.0561, 37.5775, -22.4538, # 41.1386, -54.3177, -27.3063, 31.3858]) minibatching_ref_opt_params = np.array([2.4271, -21.5146, 4.4769, 21.0945, 8.4016, -9.7612, 13.9343, 42.8698, 16.8601, -22.8767, 19.5411, -27.62, 3.423, -25.9107, 21.0475, 21.895]) # minibatching_ref_train_loss = 1.02335933 minibatching_ref_train_loss = 0.6519675 np.testing.assert_array_almost_equal(result['opt_params'], minibatching_ref_opt_params, decimal=4) np.testing.assert_array_almost_equal(result['training_loss'], minibatching_ref_train_loss, decimal=8) # self.assertEqual(result['testing_accuracy'], .5) self.assertEqual(result['testing_accuracy'], 0.0)
def classical_svm(train_input, test_input, class_labels, n): temp = [test_input[k] for k in test_input] total_array = np.concatenate(temp) # Select parameters based on number of classes in data if len(class_labels) > 2: aqua_dict = { 'problem': {'name': 'classification', 'random_seed': 100}, 'algorithm': { 'name': 'SVM' }, 'multiclass_extension': {'name': 'AllPairs'} } else: aqua_dict = { 'problem': {'name': 'classification', 'random_seed': 100}, 'algorithm': { 'name': 'SVM' } } algo_input = ClassificationInput algo_input.training_dataset = train_input algo_input.test_dataset = test_input algo_input.datapoints = total_array # Run the classical SVM algorithm result = run_algorithm(aqua_dict, algo_input) # Print model values # for k,v in result.items(): # print("'{}' : {}".format(k, v)) return result
def test_qsvm_kernel_multiclass_all_pairs(self): backend = BasicAer.get_backend('qasm_simulator') training_input = {'A': np.asarray([[0.6560706, 0.17605998], [0.25776033, 0.47628296], [0.8690704, 0.70847635]]), 'B': np.asarray([[0.38857596, -0.33775802], [0.49946978, -0.48727951], [0.49156185, -0.3660534]]), 'C': np.asarray([[-0.68088231, 0.46824423], [-0.56167659, 0.65270294], [-0.82139073, 0.29941512]])} test_input = {'A': np.asarray([[0.57483139, 0.47120732], [0.48372348, 0.25438544], [0.48142649, 0.15931707]]), 'B': np.asarray([[-0.06048935, -0.48345293], [-0.01065613, -0.33910828], [0.06183066, -0.53376975]]), 'C': np.asarray([[-0.74561108, 0.27047295], [-0.69942965, 0.11885162], [-0.66489165, 0.1181712]])} total_array = np.concatenate((test_input['A'], test_input['B'], test_input['C'])) params = { 'problem': {'name': 'svm_classification', 'random_seed': self.random_seed}, 'algorithm': { 'name': 'QSVM.Kernel', }, 'backend': {'shots': self.shots}, 'multiclass_extension': {'name': 'AllPairs'}, 'feature_map': {'name': 'SecondOrderExpansion', 'depth': 2, 'entangler_map': [[0, 1]]} } algo_input = SVMInput(training_input, test_input, total_array) result = run_algorithm(params, algo_input, backend=backend) self.assertAlmostEqual(result['testing_accuracy'], 0.444444444, places=4, msg='Please ensure you are using C++ simulator') self.assertEqual(result['predicted_classes'], ['A', 'A', 'C', 'A', 'A', 'A', 'A', 'C', 'C'])
def test_hhl_negative_eigs_sv(self): self.log.debug('Testing HHL with matrix with negative eigenvalues') neg_params = self.params neg_params['eigs']['num_ancillae'] = 4 neg_params['eigs']['negative_evals'] = True neg_params['reciprocal']['negative_evals'] = True n = 2 matrix = rmg.random_diag(n, eigrange=[-1, 1]) vector = random(2) algo_input = LinearSystemInput() algo_input.matrix = matrix algo_input.vector = vector # run hhl result = run_algorithm(neg_params, algo_input) hhl_solution = result["solution_hhl"] hhl_normed = hhl_solution / np.linalg.norm(hhl_solution) # linear algebra solution linalg_solution = np.linalg.solve(matrix, vector) linalg_normed = linalg_solution / np.linalg.norm(linalg_solution) # compare result fidelity = abs(linalg_normed.dot(hhl_normed.conj()))**2 np.testing.assert_approx_equal(fidelity, 1, significant=3) self.log.debug('HHL solution vector: {}'.format(hhl_solution)) self.log.debug('algebraic solution vector: {}'.format(linalg_solution)) self.log.debug('fidelity HHL to algebraic: {}'.format(fidelity)) self.log.debug('probability of result: {}'.format( result["probability_result"]))
def test_vqe_via_run_algorithm(self): coupling_map = [[0, 1]] basis_gates = ['u1', 'u2', 'u3', 'cx', 'id'] params = { 'algorithm': { 'name': 'VQE' }, 'backend': { 'name': 'statevector_simulator', 'provider': 'qiskit.Aer', 'shots': 1, 'coupling_map': coupling_map, 'basis_gates': basis_gates }, } result = run_algorithm(params, self.algo_input) self.assertAlmostEqual(result['energy'], -1.85727503) np.testing.assert_array_almost_equal(result['eigvals'], [-1.85727503], 5) np.testing.assert_array_almost_equal(result['opt_params'], [ -0.58294401, -1.86141794, -1.97209632, -0.54796022, -0.46945572, 2.60114794, -1.15637845, 1.40498879, 1.14479635, -0.48416694, -0.66608349, -1.1367579, -2.67097002, 3.10214631, 3.10000313, 0.37235089 ], 5) self.assertIn('eval_count', result) self.assertIn('eval_time', result)
def test_hhl_random_hermitian_sv(self): self.log.debug('Testing HHL with random hermitian matrix') hermitian_params = self.params hermitian_params['eigs']['num_ancillae'] = 4 n = 2 matrix = rmg.random_hermitian(n, eigrange=[0, 1]) vector = random(2) algo_input = LinearSystemInput() algo_input.matrix = matrix algo_input.vector = vector # run hhl result = run_algorithm(hermitian_params, algo_input) hhl_solution = result["solution_hhl"] hhl_normed = hhl_solution / np.linalg.norm(hhl_solution) # linear algebra solution linalg_solution = np.linalg.solve(matrix, vector) linalg_normed = linalg_solution / np.linalg.norm(linalg_solution) # compare result fidelity = abs(linalg_normed.dot(hhl_normed.conj()))**2 np.testing.assert_approx_equal(fidelity, 1, significant=2) self.log.debug('HHL solution vector: {}'.format(hhl_solution)) self.log.debug('algebraic solution vector: {}'.format(linalg_solution)) self.log.debug('fidelity HHL to algebraic: {}'.format(fidelity)) self.log.debug('probability of result: {}'.format( result["probability_result"]))
def test_graph_partition_vqe(self): algorithm_cfg = { 'name': 'VQE', 'operator_mode': 'matrix', 'batch_mode': True } optimizer_cfg = {'name': 'SPSA', 'max_trials': 300} var_form_cfg = {'name': 'RY', 'depth': 5, 'entanglement': 'linear'} params = { 'problem': { 'name': 'ising', 'random_seed': 10598 }, 'algorithm': algorithm_cfg, 'optimizer': optimizer_cfg, 'variational_form': var_form_cfg } backend = get_aer_backend('statevector_simulator') result = run_algorithm(params, self.algo_input, backend=backend) x = graphpartition.sample_most_likely(result['eigvecs'][0]) # check against the oracle ising_sol = graphpartition.get_graph_solution(x) np.testing.assert_array_equal(ising_sol, [1, 0, 0, 1]) oracle = self.brute_force() self.assertEqual(graphpartition.objective_value(x, self.w), oracle)
def test_hhl_diagonal_negative_sv(self, vector): self.log.debug('Testing HHL simple test in mode Lookup with ' 'statevector simulator') neg_params = self.params matrix = [[1, 0], [0, 1]] neg_params['input'] = { 'name': 'LinearSystemInput', 'matrix': matrix, 'vector': vector } neg_params['eigs']['negative_evals'] = True neg_params['reciprocal']['negative_evals'] = True neg_params['eigs']['num_ancillae'] = 4 # run hhl result = run_algorithm(neg_params) hhl_solution = result["solution_hhl"] hhl_normed = hhl_solution / np.linalg.norm(hhl_solution) # linear algebra solution linalg_solution = np.linalg.solve(matrix, vector) linalg_normed = linalg_solution / np.linalg.norm(linalg_solution) # compare result fidelity = abs(linalg_normed.dot(hhl_normed.conj()))**2 np.testing.assert_approx_equal(fidelity, 1, significant=5) self.log.debug('HHL solution vector: {}'.format(hhl_solution)) self.log.debug('algebraic solution vector: {}'.format(linalg_solution)) self.log.debug('fidelity HHL to algebraic: {}'.format(fidelity)) self.log.debug('probability of result: {}'.format( result["probability_result"]))