def test_parse_problem_file(self): """ Tests the parse_problem_file method """ filename = os.path.join(os.path.dirname(__file__), 'nist', 'basic.dat') fitting_problem = parse_problem_file(filename, OPTIONS) self.assertEqual(fitting_problem.name, 'basic')
def setUp(self): """ Setting up FitBenchmarking results object """ self.options = Options() mock_problems_dir = os.path.dirname(inspect.getfile(mock_problems)) problem_dir = os.path.join(mock_problems_dir, "cubic.dat") self.problem = parse_problem_file(problem_dir, self.options) self.problem.correct_data() self.chi_sq = 10 self.minimizer = "test_minimizer" self.runtime = 0.01 self.params = np.array([1, 3, 4, 4]) self.initial_params = np.array([0, 0, 0, 0]) self.cost_func = NLLSCostFunc(self.problem) self.jac = Scipy(self.cost_func) self.jac.method = "2-point" self.result = FittingResult(options=self.options, cost_func=self.cost_func, jac=self.jac, chi_sq=self.chi_sq, runtime=self.runtime, minimizer=self.minimizer, initial_params=self.initial_params, params=self.params, error_flag=0) self.min_chi_sq = 0.1 self.result.min_chi_sq = self.min_chi_sq self.min_runtime = 1 self.result.min_runtime = self.min_runtime
def make_fitting_problem(): """ Helper function that returns a simple fitting problem """ bench_prob_dir = os.path.dirname(inspect.getfile(mock_problems)) fname = os.path.join(bench_prob_dir, 'cubic.dat') fitting_problem = parse_problem_file(fname) fitting_problem.correct_data(True) return fitting_problem
def make_fitting_problem(): """ Helper function that returns a simple fitting problem """ bench_prob_dir = os.path.dirname(inspect.getfile(benchmark_problems)) fname = os.path.join(bench_prob_dir, 'simple_tests', 'cubic.dat') fitting_problem = parse_problem_file(fname) return fitting_problem
def make_cost_func(file_name='cubic.dat'): """ Helper function that returns a simple fitting problem """ options = Options() bench_prob_dir = os.path.dirname(inspect.getfile(mock_problems)) fname = os.path.join(bench_prob_dir, file_name) fitting_problem = parse_problem_file(fname, options) fitting_problem.correct_data() cost_func = WeightedNLLSCostFunc(fitting_problem) return cost_func
def fitbenchmark_group(group_name, options, data_dir): """ Gather the user input and list of paths. Call benchmarking on these. :param group_name: is the name (label) for a group. E.g. the name for the group of problems in "NIST/low_difficulty" may be picked to be NIST_low_difficulty :type group_name: str :param options: dictionary containing software used in fitting the problem, list of minimizers and location of json file contain minimizers :type options: fitbenchmarking.utils.options.Options :param data_dir: full path of a directory that holds a group of problem definition files :type date_dir: str :return: prob_results array of fitting results for the problem group and the location of the results :rtype: tuple(list, str) """ grabbed_output = output_grabber.OutputGrabber() # Extract problem definitions problem_group = misc.get_problem_files(data_dir) results = [] template_prob_name = " Running data from: {}" for i, p in enumerate(problem_group): with grabbed_output: parsed_problem = parse_problem_file(p) parsed_problem.correct_data(options.use_errors) decorator = '#' * (len(template_prob_name) + len(parsed_problem.name) + 4) tmp_prob_name = template_prob_name.format(parsed_problem.name) print("\n{0}\n{1} {2}/{3}\n{0}\n".format(decorator, tmp_prob_name, i + 1, len(problem_group))) problem_results = fitbm_one_prob(problem=parsed_problem, options=options) # Convert from list of dict to list of list and store for r in problem_results: tmp_result = [] for s in options.software: tmp_result.extend(r[s]) results.append(tmp_result) return results
def fitbenchmark_group(group_name, options, data_dir): """ Gather the user input and list of paths. Call benchmarking on these. :param group_name: is the name (label) for a group. E.g. the name for the group of problems in "NIST/low_difficulty" may be picked to be NIST_low_difficulty :type group_name: str :param options: dictionary containing software used in fitting the problem, list of minimizers and location of json file contain minimizers :type options: fitbenchmarking.utils.options.Options :param data_dir: full path of a directory that holds a group of problem definition files :type date_dir: str :returns: tuple(prob_results, results_dir) array of fitting results for the problem group and the path to the results directory :rtype: (list of FittingResult, str) """ # Create results directory results_dir = create_dirs.results(options.results_dir) group_results_dir = create_dirs.group_results(results_dir, group_name) # Extract problem definitions problem_group = misc.get_problem_files(data_dir) results = [] for p in problem_group: parsed_problem = parse_problem_file(p) problem_results = fitbm_one_prob(problem=parsed_problem, options=options, directory=group_results_dir) # Convert from list of dict to list of list and store for r in problem_results: tmp_result = [] for s in options.software: tmp_result.extend(r[s]) results.append(tmp_result) return results
def loop_over_benchmark_problems(problem_group, options): """ Loops over benchmark problems :param problem_group: locations of the benchmark problem files :type problem_group: list :param options: FitBenchmarking options for current run :type options: fitbenchmarking.utils.options.Options :return: prob_results array of fitting results for the problem group, list of failed problems and dictionary of unselected minimizers, rst description of the cost function from the docstring :rtype: tuple(list, list, dict, str) """ grabbed_output = output_grabber.OutputGrabber(options) results = [] failed_problems = [] for i, p in enumerate(problem_group): problem_passed = True info_str = " Running data from: {} {}/{}".format( os.path.basename(p), i + 1, len(problem_group)) LOGGER.info('\n' + '#' * (len(info_str) + 1)) LOGGER.info(info_str) LOGGER.info('#' * (len(info_str) + 1)) try: with grabbed_output: parsed_problem = parse_problem_file(p, options) parsed_problem.correct_data() except Exception as e: info_str = " Could not run data from: {} {}/{}".format( p, i + 1, len(problem_group)) LOGGER.warn(e) problem_passed = False if problem_passed: ############################## # Loops over starting values # ############################## cost_func_cls = create_cost_func(options.cost_func_type) cost_func = cost_func_cls(parsed_problem) cost_func_description = cost_func.__doc__ problem_results, problem_fails, \ unselected_minimzers, minimizer_dict = \ loop_over_starting_values( cost_func, options, grabbed_output) results.extend(problem_results) failed_problems.extend(problem_fails) # If the results are an empty list then this means that all minimizers # raise an exception and the tables will produce errors if they run. if results == []: message = "The user chosen options and/or problem setup resulted in " \ "all minimizers and/or parsers raising an exception. " \ "This is likely due to the way `algorithm_type` was set " \ "in the options or the selected problem set requires " \ "additional software to be installed. Please review your " \ "options setup and/or problem set then re-run " \ "FitBenmarking." raise NoResultsError(message) return results, failed_problems, unselected_minimzers, \ minimizer_dict, cost_func_description