def main(): sample_Total, training_input, test_input, class_labels = \ ad_hoc_data(training_size=20, test_size=10, n=2, # 2 is the dimension of each data point gap=0.3, PLOT_DATA=False) total_array, label_to_labelclass = get_points(test_input, class_labels) params = { 'problem': { 'name': 'svm_classification' }, 'backend': { 'name': 'local_qasm_simulator', 'shots': 1024 }, 'algorithm': { 'name': 'SVM_QKernel', 'print_info': True } } algo_input = get_input_instance('SVMInput') algo_input.training_dataset = training_input algo_input.test_dataset = test_input algo_input.datapoints = total_array result = run_algorithm(params, algo_input) print(result)
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_svm_qkernel_via_run_algorithm(self): params = { 'problem': { 'name': 'svm_classification', 'random_seed': self.random_seed }, 'algorithm': { 'name': 'SVM_QKernel' }, 'backend': { 'name': 'local_qasm_simulator', 'shots': 1024 } } result = run_algorithm(params, self.svm_input) 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 run(self, input, output=None): if input is None: raise ACQUAChemistryError("Missing input.") self._parser = InputParser(input) self._parser.parse() driver_return = self._run_driver_from_parser(self._parser, False) if driver_return[0] == ACQUAChemistry._DRIVER_RUN_TO_HDF5: logger.info('No further process.') return {'printable': [driver_return[1]]} data = run_algorithm(driver_return[1], driver_return[2], True) if not isinstance(data, dict): raise ACQUAChemistryError( "Algorithm run result should be a dictionary") if logger.isEnabledFor(logging.DEBUG): logger.debug('Algorithm returned: {}'.format( json.dumps(data, indent=4))) convert_json_to_dict(data) lines, result = self._format_result(data) logger.info('Processing complete. Final result available') result['printable'] = lines if output is not None: with open(output, 'w') as f: for line in lines: print(line, file=f) return result
def test_ee_via_run_algorithm_k4(self): params = {'algorithm': {'name': 'ExactEigensolver', 'k': 4}} result = run_algorithm(params, self.algo_input) 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_run_algorithm(self): filepath = self._get_resource_path('ExactEigensolver.json') params = None with open(filepath) as json_file: params = json.load(json_file) dict_ret = None try: dict_ret = run_algorithm(params, None, False) except Exception as e: self.fail(str(e)) self.assertIsInstance(dict_ret, dict)
def run_algorithm_from_json(self, params, output=None): ret = run_algorithm(params, None, True) if not isinstance(ret, dict): raise ACQUAChemistryError( "Algorithm run result should be a dictionary") logger.debug('Algorithm returned: {}'.format(json.dumps(ret, indent=4))) convert_json_to_dict(ret) print('Output:') if isinstance(ret, dict): for k, v in ret.items(): print("'{}': {}".format(k, v)) else: print(ret) return ret
def test_end2end_H2(self, name, optimizer, backend, mode, shots): optimizer_params = {'name': optimizer} if optimizer == 'COBYLA': optimizer_params['maxiter'] = 1000 elif optimizer == 'SPSA': optimizer_params['max_trials'] = 2000 optimizer_params['save_steps'] = 25 algo_params = {'problem': {'name': 'energy'}, 'backend': {'name': backend, 'shots': shots}, 'algorithm': {'name': 'VQE'}, 'optimizer': optimizer_params, 'variational_form': {'name': 'RYRZ', 'depth': 5, 'entanglement': 'full'} } results = run_algorithm(algo_params, self.algo_input) self.assertAlmostEqual(results['energy'], self.reference_energy)
def run(currentTest): params = { 'problem': { 'name': 'search' }, 'algorithm': { 'name': 'Grover' }, 'oracle': { 'name': 'SAT', 'cnf': currentTest }, 'backend': { 'name': 'local_qasm_simulator' } } result = run_algorithm(params) print(result['result'])
def runGrover(r=rules): params = { 'problem': { 'name': 'search' }, 'algorithm': { 'name': 'Grover' }, 'oracle': { 'name': 'SAT', 'cnf': r }, 'backend': { 'name': 'local_qasm_simulator' } } print("Starting Grover search") result = run_algorithm(params) print(result['result']) return result['result']
def main(): parser = argparse.ArgumentParser( description='QISKit ACQUA Command Line Tool') parser.add_argument('input', metavar='input', help='Algorithm JSON input file') parser.add_argument('-jo', metavar='output', help='Algorithm JSON output file name', required=False) args = parser.parse_args() preferences = Preferences() if preferences.get_logging_config() is None: logging_config = build_logging_config(['qiskit_acqua'], logging.INFO) preferences.set_logging_config(logging_config) preferences.save() set_logger_config(preferences.get_logging_config()) params = None with open(args.input) as json_file: params = json.load(json_file) ret = run_algorithm(params, None, True) if args.jo is not None: with open(args.jo, 'w') as f: print('{}'.format(ret), file=f) else: convert_json_to_dict(ret) print( '\n\n--------------------------------- R E S U L T ------------------------------------\n' ) if isinstance(ret, dict): for k, v in ret.items(): print("'{}': {}".format(k, v)) else: print(ret)
from qiskit_acqua.input import get_input_instance from qiskit_acqua import run_algorithm sample_Total, training_input, test_input, class_labels = \ Wine(training_size=40, test_size=10, n=2, # 2 is the dimension of each data point PLOT_DATA=False) total_array, label_to_labelclass = get_points(test_input, class_labels) params = { 'problem': { 'name': 'svm_classification' }, 'backend': { 'name': 'local_qasm_simulator', 'shots': 1000 }, 'algorithm': { 'name': 'QuantumSVM_OneAgainstRest', 'print_info': True } } algo_input = get_input_instance('SVMInput') algo_input.training_dataset = training_input algo_input.test_dataset = test_input algo_input.datapoints = total_array result = run_algorithm(params, algo_input) print(result)
'name': 'search' }, 'algorithm': { 'name': 'Grover' }, 'oracle': { 'name': 'SAT', 'cnf': risk_sat }, 'backend': { 'name': 'local_qasm_simulator' } } start = time.time() result = run_algorithm(params) end = time.time() print('job took {} seconds'.format(end - start)) answer = result['result'] print("{} or {}".format(answer, convert(answer))) # classical version search arr = np.zeros(NUM_ITEMS) db = [int(num) for num in arr] db[location] = 1 start = time.time() for i, val in enumerate(db): if val == 1: print(i) break
def maxCut(graph=None, n=5): G = graph # if Graph isn't provided, create a sample one if G is None: G = makeGraph(num=n) # colour every node red and show the starting graph colors = ['r' for _ in G.nodes()] pos = nx.spring_layout(G) default_axes = plt.axes(frameon=True) nx.draw_networkx(G, node_color=colors, node_size=600, alpha=.8, ax=default_axes, pos=pos) plt.show() # Computing the weight matrix from the graph and display it w = np.zeros([n, n]) for i in range(n): for j in range(n): temp = G.get_edge_data(i, j, default=0) if temp != 0: w[i, j] = temp['weight'] print(w) # Map to Ising problem qubitOp, offset = maxcut.get_maxcut_qubitops(w) algo_input = get_input_instance('EnergyInput') algo_input.qubit_op = qubitOp algorithm_cfg = {'name': 'VQE', 'operator_mode': 'grouped_paulis'} 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': { 'name': 'local_qasm_simulator', 'shots': 100 } } # run the algorithm and print the results result = run_algorithm(params, algo_input) x = maxcut.sample_most_likely(len(w), result['eigvecs'][0]) print('energy:', result['energy']) print('time:', result['eval_time']) print('maxcut objective:', result['energy'] + offset) print('solution:', maxcut.get_graph_solution(x)) print('solution objective:', maxcut.maxcut_value(x, w)) plot_histogram(result['eigvecs'][0]) # colour the nodes that don't recieve a freebie red, else blue colors = [ 'r' if maxcut.get_graph_solution(x)[i] == 0 else 'b' for i in range(n) ] nx.draw_networkx(G, node_color=colors, node_size=600, alpha=.8, pos=pos) plt.show()