def run_algorithm(params, algo_input=None, json_output=False): """ Run algorithm as named in params, using params and algo_input as input data and returning a result dictionary Args: params (dict): Dictionary of params for algo and dependent objects algo_input(algorithminput): Main input data for algorithm. Optional, an algo may run entirely from params json_output(bool): False for regular python dictionary return, True for json conversion Returns: Result dictionary containing result of algorithm computation """ _discover_on_demand() inputparser = InputParser(params) inputparser.parse() inputparser.validate_merge_defaults() logger.debug('Algorithm Input: {}'.format(json.dumps(inputparser.get_sections(), sort_keys=True, indent=4))) algo_name = inputparser.get_section_property(JSONSchema.ALGORITHM, JSONSchema.NAME) if algo_name is None: raise AlgorithmError('Missing algorithm name') if algo_name not in local_algorithms(): raise AlgorithmError('Algorithm "{0}" missing in local algorithms'.format(algo_name)) backend_cfg = None backend = inputparser.get_section_property(JSONSchema.BACKEND, JSONSchema.NAME) if backend is not None: backend_cfg = {k: v for k, v in inputparser.get_section(JSONSchema.BACKEND).items() if k != 'name'} backend_cfg['backend'] = backend algorithm = get_algorithm_instance(algo_name) algorithm.random_seed = inputparser.get_section_property(JSONSchema.PROBLEM, 'random_seed') if backend_cfg is not None: algorithm.setup_quantum_backend(**backend_cfg) algo_params = copy.deepcopy(inputparser.get_sections()) if algo_input is None: input_name = inputparser.get_section_property('input', JSONSchema.NAME) if input_name is not None: algo_input = get_input_instance(input_name) input_params = copy.deepcopy(inputparser.get_section_properties('input')) del input_params[JSONSchema.NAME] convert_json_to_dict(input_params) algo_input.from_params(input_params) algorithm.init_params(algo_params, algo_input) value = algorithm.run() if isinstance(value, dict) and json_output: convert_dict_to_json(value) return value
def run_algorithm_to_json(params, algo_input=None, jsonfile='algorithm.json'): """ Run algorithm as named in params, using params and algo_input as input data and save the combined input as a json file. This json is self-contained and can later be used as a basis to call run_algorithm Args: params (dict): Dictionary of params for algo and dependent objects algo_input(algorithminput): Main input data for algorithm. Optional, an algo may run entirely from params jsonfile(string): Name of file in which json should be saved Returns: Result dictionary containing the jsonfile name """ _discover_on_demand() inputparser = InputParser(params) inputparser.parse() inputparser.validate_merge_defaults() algo_params = copy.deepcopy(inputparser.get_sections()) if algo_input is not None: input_params = algo_input.to_params() convert_dict_to_json(input_params) algo_params['input'] = input_params algo_params['input']['name'] = algo_input.configuration['name'] logger.debug('Result: {}'.format(json.dumps(algo_params, sort_keys=True, indent=4))) with open(jsonfile, 'w') as fp: json.dump(algo_params, fp, sort_keys=True, indent=4) logger.info("Algorithm input file saved: '{}'".format(jsonfile)) return {'jsonfile': jsonfile}
def test_load_from_dict(self): json_dict = self.parser.get_sections() p = InputParser(json_dict) p.parse() dict1 = json.loads(json.dumps(self.parser.get_sections())) dict2 = json.loads(json.dumps(p.get_sections())) self.assertEqual(dict1, dict2)
def test_save(self): save_path = self._get_resource_path('output.txt') self.parser.save_to_file(save_path) p = InputParser(save_path) p.parse() os.remove(save_path) dict1 = json.loads(json.dumps(self.parser.get_sections())) dict2 = json.loads(json.dumps(p.get_sections())) self.assertEqual(dict1, dict2)
def run_algorithm(params, algo_input=None, json_output=False, backend=None): """ Run algorithm as named in params, using params and algo_input as input data and returning a result dictionary Args: params (dict): Dictionary of params for algo and dependent objects algo_input (AlgorithmInput): Main input data for algorithm. Optional, an algo may run entirely from params json_output (bool): False for regular python dictionary return, True for json conversion backend (BaseBackend): Backend object to be used in place of backend name Returns: Result dictionary containing result of algorithm computation """ _discover_on_demand() inputparser = InputParser(params) inputparser.parse() # before merging defaults attempts to find a provider for the backend in case no # provider was passed if backend is None and inputparser.get_section_property(JSONSchema.BACKEND, JSONSchema.PROVIDER) is None: backend_name = inputparser.get_section_property(JSONSchema.BACKEND, JSONSchema.NAME) if backend_name is not None: inputparser.set_section_property(JSONSchema.BACKEND, JSONSchema.PROVIDER, get_provider_from_backend(backend_name)) inputparser.validate_merge_defaults() logger.debug('Algorithm Input: {}'.format(json.dumps(inputparser.get_sections(), sort_keys=True, indent=4))) algo_name = inputparser.get_section_property(PluggableType.ALGORITHM.value, JSONSchema.NAME) if algo_name is None: raise AquaError('Missing algorithm name') if algo_name not in local_pluggables(PluggableType.ALGORITHM): raise AquaError('Algorithm "{0}" missing in local algorithms'.format(algo_name)) if algo_input is None: input_name = inputparser.get_section_property('input', JSONSchema.NAME) if input_name is not None: input_params = copy.deepcopy(inputparser.get_section_properties('input')) del input_params[JSONSchema.NAME] convert_json_to_dict(input_params) algo_input = get_pluggable_class(PluggableType.INPUT, input_name).from_params(input_params) algo_params = copy.deepcopy(inputparser.get_sections()) algorithm = get_pluggable_class(PluggableType.ALGORITHM, algo_name).init_params(algo_params, algo_input) random_seed = inputparser.get_section_property(JSONSchema.PROBLEM, 'random_seed') algorithm.random_seed = random_seed quantum_instance = None # setup backend backend_provider = inputparser.get_section_property(JSONSchema.BACKEND, JSONSchema.PROVIDER) backend_name = inputparser.get_section_property(JSONSchema.BACKEND, JSONSchema.NAME) if backend_provider is not None and backend_name is not None: # quantum algorithm backend_cfg = {k: v for k, v in inputparser.get_section(JSONSchema.BACKEND).items() if k not in [JSONSchema.PROVIDER, JSONSchema.NAME]} noise_params = backend_cfg.pop('noise_params', None) backend_cfg['config'] = {} backend_cfg['config']['noise_params'] = noise_params backend_cfg['seed'] = random_seed backend_cfg['seed_mapper'] = random_seed pass_manager = PassManager() if backend_cfg.pop('skip_transpiler', False) else None if pass_manager is not None: backend_cfg['pass_manager'] = pass_manager if backend is not None and isinstance(backend, BaseBackend): backend_cfg['backend'] = backend else: backend_cfg['backend'] = get_backend_from_provider(backend_provider, backend_name) quantum_instance = QuantumInstance(**backend_cfg) value = algorithm.run(quantum_instance) if isinstance(value, dict) and json_output: convert_dict_to_json(value) return value
class TestInputParser(QiskitAquaTestCase): """Input Parser and algorithms tests.""" def setUp(self): filepath = self._get_resource_path('H2-0.735.json') self.parser = InputParser(filepath) self.parser.parse() def test_save(self): save_path = self._get_resource_path('output.txt') self.parser.save_to_file(save_path) p = InputParser(save_path) p.parse() os.remove(save_path) dict1 = json.loads(json.dumps(self.parser.get_sections())) dict2 = json.loads(json.dumps(p.get_sections())) self.assertEqual(dict1, dict2) def test_load_from_dict(self): json_dict = self.parser.get_sections() p = InputParser(json_dict) p.parse() dict1 = json.loads(json.dumps(self.parser.get_sections())) dict2 = json.loads(json.dumps(p.get_sections())) self.assertEqual(dict1, dict2) def test_is_modified(self): json_dict = self.parser.get_sections() p = InputParser(json_dict) p.parse() p.set_section_property('optimizer', 'maxfun', 1002) self.assertTrue(p.is_modified()) self.assertEqual(p.get_section_property('optimizer', 'maxfun'), 1002) def test_validate(self): json_dict = self.parser.get_sections() p = InputParser(json_dict) p.parse() try: p.validate_merge_defaults() except Exception as e: self.fail(str(e)) p.set_section_property('optimizer', 'dummy', 1002) self.assertRaises(AquaError, p.validate_merge_defaults) 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)