def load_expectation(filename): """ Load an expected fitting problem from a json file. :param filename: The path to the expectation file :type filename: string :return: A fitting problem to test against :rtype: fitbenchmarking.parsing.FittingProblem """ with open(filename, 'r') as f: expectation_dict = load(f) expectation = FittingProblem(OPTIONS) expectation.name = expectation_dict['name'] expectation.start_x = expectation_dict['start_x'] expectation.end_x = expectation_dict['end_x'] expectation.data_x = np.array(expectation_dict['data_x']) expectation.data_y = np.array(expectation_dict['data_y']) expectation.data_e = expectation_dict['data_e'] if expectation.data_e is not None: expectation.data_e = np.array(expectation.data_e) expectation.starting_values = expectation_dict['starting_values'] expectation.value_ranges = expectation_dict['value_ranges'] return expectation
def test_verify_problem(self): """ Test that verify only passes if all required values are set. """ fitting_problem = FittingProblem(self.options) with self.assertRaises(exceptions.FittingProblemError): fitting_problem.verify() self.fail('verify() passes when no values are set.') fitting_problem.starting_values = [OrderedDict([('p1', 1), ('p2', 2)])] with self.assertRaises(exceptions.FittingProblemError): fitting_problem.verify() self.fail('verify() passes starting values are set.') fitting_problem.data_x = np.array([1, 2, 3, 4, 5]) with self.assertRaises(exceptions.FittingProblemError): fitting_problem.verify() self.fail('verify() passes when data_x is set.') fitting_problem.data_y = np.array([1, 2, 3, 4, 5]) with self.assertRaises(exceptions.FittingProblemError): fitting_problem.verify() self.fail('verify() passes when data_y is set.') fitting_problem.function = lambda x, p1, p2: p1 + p2 try: fitting_problem.verify() except exceptions.FittingProblemError: self.fail('verify() fails when all required values set.') fitting_problem.data_x = [1, 2, 3] with self.assertRaises(exceptions.FittingProblemError): fitting_problem.verify() self.fail('verify() passes for x values not numpy.')
def parse(self): """ Parse the NIST problem file into a Fitting Problem. :return: The fully parsed fitting problem :rtype: fitbenchmarking.parsing.fitting_problem.FittingProblem """ fitting_problem = FittingProblem() equation, data, starting_values, name = self._parse_line_by_line() data = self._parse_data(data) fitting_problem.data_x = data[:, 1] fitting_problem.data_y = data[:, 0] if len(data[0, :]) > 2: fitting_problem.data_e = data[:, 2] fitting_problem.name = name # String containing a mathematical expression fitting_problem.equation = self._parse_equation(equation) fitting_problem.starting_values = starting_values fitting_problem.function = \ nist_func_definition(function=fitting_problem.equation, param_names=starting_values[0].keys()) return fitting_problem
def test_verify_problem(self): """ Test that verify only passes if all required values are set. """ fitting_problem = FittingProblem() with self.assertRaises(TypeError): fitting_problem.verify() self.fail('verify() passes when no values are set.') fitting_problem.starting_values = [['p1', [1]], ['p2', [2]]] with self.assertRaises(TypeError): fitting_problem.verify() self.fail('verify() passes starting values are set.') fitting_problem.data_x = np.array([1, 2, 3, 4, 5]) with self.assertRaises(TypeError): fitting_problem.verify() self.fail('verify() passes when data_x is set.') fitting_problem.data_y = np.array([1, 2, 3, 4, 5]) with self.assertRaises(TypeError): fitting_problem.verify() self.fail('verify() passes when data_y is set.') fitting_problem.functions = [[lambda x, p1, p2: p1 + p2, [1, 2]]] try: fitting_problem.verify() except TypeError: self.fail('verify() fails when all required values set.') fitting_problem.data_x = [1, 2, 3] with self.assertRaises(TypeError): fitting_problem.verify() self.fail('verify() passes for x values not numpy.')
def test_get_function_params(self): """ Tests that the function params is formatted correctly """ fitting_problem = FittingProblem(self.options) expected_function_def = 'a=1, b=2.0, c=3.3, d=4.99999' fitting_problem.starting_values = [ OrderedDict([('a', 0), ('b', 0), ('c', 0), ('d', 0)]) ] params = [1, 2.0, 3.3, 4.99999] function_def = fitting_problem.get_function_params(params=params) self.assertEqual(function_def, expected_function_def)
def test_get_function_def(self): """ Tests that the function def is formatted correctly """ fitting_problem = FittingProblem() expected_function_def = \ 'test_function | a=1, b=2.0, c=3.3, d=4.99999999' fitting_problem.equation = 'test_function' fitting_problem.starting_values = [['a', [0]], ['b', [0]], ['c', [0]], ['d', [0]]] params = [1, 2.0, 3.3, 4.99999999] function_def = fitting_problem.get_function_def(params=params) self.assertEqual(function_def, expected_function_def)
def setup_nist_expected_problem(self): prob = FittingProblem() prob.name = 'Misra1a' prob.equation = 'b1*(1-exp(-b2*x))' prob.starting_values = [['b1', [500.0, 250.0]], ['b2', [0.0001, 0.0005]]] data_pattern = self.setup_misra1a_expected_data_points() prob.data_x = data_pattern[:, 1] prob.data_y = data_pattern[:, 0] prob.ref_residual_sum_sq = 1.2455138894e-01 return prob
def generate_mock_results(self): """ Generates results to test against :return: A list of results objects along with expected values for normallised accuracy and runtimes :rtype: tuple(list of FittingResults, list of list of float, list of list of float) """ self.num_problems = 4 self.num_minimizers = 2 results = [] options = Options() problem = FittingProblem(options) problem.starting_values = [{'a': 1, 'b': 2, 'c': 3}] acc_in = [[1, 5], [7, 3], [10, 8], [2, 3]] runtime_in = [[float('Inf'), 2.2e-3], [3.0e-10, 5.0e-14], [6.9e-7, 4.3e-5], [1.6e-13, 1.8e-13]] acc_expected = [] runtime_expected = [] for i in range(self.num_problems): acc_results = acc_in[i][:] acc_expected.append(list(acc_results) / np.min(acc_results)) runtime_results = runtime_in[i][:] runtime_expected.append( list(runtime_results) / np.min(runtime_results)) prob_results = [] cost_func = NLLSCostFunc(problem) jac = Scipy(cost_func) jac.method = "2-point" for j in range(self.num_minimizers): minimizer = 'min_{}'.format(j) prob_results.append( FittingResult(options=options, cost_func=cost_func, jac=jac, initial_params=[1, 2, 3], params=[1, 2, 3], chi_sq=acc_results[j], runtime=runtime_results[j], minimizer=minimizer)) results.append(prob_results) return results, acc_expected, runtime_expected
def test_eval_starting_params(self): """ Test that eval_starting_params returns the correct result """ fitting_problem = FittingProblem() self.assertRaises(exceptions.FittingProblemError, fitting_problem.eval_starting_params, param_set=0) fitting_problem.function = lambda x, p1: x + p1 fitting_problem.starting_values = [ OrderedDict([('p1', 3)]), OrderedDict([('p1', 7)]) ] fitting_problem.data_x = np.array([1]) eval_result = fitting_problem.eval_starting_params(0) self.assertTrue(all(eval_result == np.array([4]))) eval_result = fitting_problem.eval_starting_params(1) self.assertTrue(all(eval_result == np.array([8])))
def parse(self): """ Get data into a Fitting Problem via cutest. :return: The fully parsed fitting problem :rtype: fitbenchmarking.parsing.fitting_problem.FittingProblem """ self.mastsif_dir = TemporaryDirectory() # set the MASTSIF environment variable so that pycutest # can find the sif files os.environ["MASTSIF"] = self.mastsif_dir.name self._num_params = None # get just the short filename (minus the .SIF) fp = FittingProblem(self.options) # Collect x and create new file with blank y fname, fp.data_x, fp.data_y, fp.data_e = self._setup_data() self._p = _import_problem(fname) fp.name = self._p.name fp.function = self._function # self._p.objcons fp.jacobian = self._jacobian # self._p.lagjac fp.equation = None fp.starting_values = self._get_starting_values() fp.start_x = None fp.end_x = None fp.format = "cutest" # Create a list of x and f (function evaluation) and x and g (Jacobian # evaluation). # If a new x is given we will create and parse a new file self._cache_f = [(fp.data_x, self._p.objcons)] self._cache_g = [(fp.data_x, self._p.lagjac)] return fp
def parse(self): """ Parse the Fitbenchmark problem file into a Fitting Problem. :return: The fully parsed fitting problem :rtype: fitbenchmarking.parsing.fitting_problem.FittingProblem """ fitting_problem = FittingProblem() self._entries = self._get_fitbenchmark_data_problem_entries() self._parsed_func = self._parse_function() fitting_problem.name = self._entries['name'] data_points = self._get_data_points() fitting_problem.data_x = data_points[:, 0] fitting_problem.data_y = data_points[:, 1] if data_points.shape[1] > 2: fitting_problem.data_e = data_points[:, 2] # String containing the function name(s) and the starting parameter # values for each function self._mantid_equation = self._entries['function'] fitting_problem.functions = self._fitbenchmark_func_definitions() # Print number of equations until better way of doing this is looked at equation_count = len(self._parsed_func) fitting_problem.equation = '{} Functions'.format(equation_count) fitting_problem.starting_values = self._get_starting_values() # start and end values in x range if 'fit_parameters' in self._entries: start_x, end_x = self._get_x_range() fitting_problem.start_x = start_x fitting_problem.end_x = end_x return fitting_problem
def parse(self): """ Parse the NIST problem file into a Fitting Problem. :return: The fully parsed fitting problem :rtype: fitbenchmarking.parsing.fitting_problem.FittingProblem """ fitting_problem = FittingProblem(self.options) equation, data, starting_values, name = self._parse_line_by_line() data = self._parse_data(data) fitting_problem.data_x = data[:, 1] fitting_problem.data_y = data[:, 0] if len(data[0, :]) > 2: fitting_problem.data_e = data[:, 2] fitting_problem.name = name # String containing a mathematical expression fitting_problem.equation = self._parse_equation(equation) fitting_problem.starting_values = starting_values fitting_problem.function = \ nist_func_definition(function=fitting_problem.equation, param_names=starting_values[0].keys()) fitting_problem.format = "nist" try: jacobian = self._parse_jacobian(name) fitting_problem.jacobian = \ nist_jacobian_definition(jacobian=jacobian, param_names=starting_values[0].keys()) except NoJacobianError: LOGGER.warn("WARNING: Could not find analytic Jacobian " "information for {} problem".format(name)) return fitting_problem
def parse(self): fitting_problem = FittingProblem() equation, data, starting_values, name = self._parse_line_by_line() data = self._parse_data(data) fitting_problem.data_x = data[:, 1] fitting_problem.data_y = data[:, 0] if len(data[0, :]) > 2: fitting_problem.data_e = data[:, 2] fitting_problem.name = name # String containing a mathematical expression fitting_problem.equation = self._parse_equation(equation) fitting_problem.starting_values = starting_values fitting_problem.functions = \ nist_func_definitions(function=fitting_problem.equation, startvals=fitting_problem.starting_values) return fitting_problem
def parse(self): """ Parse the Fitbenchmark problem file into a Fitting Problem. :return: The fully parsed fitting problem :rtype: fitbenchmarking.parsing.fitting_problem.FittingProblem """ # pylint: disable=attribute-defined-outside-init fitting_problem = FittingProblem(self.options) self._entries = self._get_data_problem_entries() software = self._entries['software'].lower() if not (software in import_success and import_success[software][0]): error = import_success[software][1] raise MissingSoftwareError('Requirements are missing for {} parser' ': {}'.format(software, error)) self._parsed_func = self._parse_function() if software == 'mantid' and self._entries['input_file'][0] == '[': fitting_problem.multifit = True # NAME fitting_problem.name = self._entries['name'] # DATA data_points = [_get_data_points(p) for p in self._get_data_file()] # FUNCTION if software == 'mantid': fitting_problem.function = self._create_mantid_function() fitting_problem.format = 'mantid' elif software == 'sasview': fitting_problem.function = self._create_sasview_function() fitting_problem.format = 'sasview' # EQUATION equation_count = len(self._parsed_func) if equation_count == 1: fitting_problem.equation = self._parsed_func[0]['name'] else: fitting_problem.equation = '{} Functions'.format(equation_count) # STARTING VALUES fitting_problem.starting_values = self._get_starting_values() # PARAMETER RANGES vr = _parse_range(self._entries.get('parameter_ranges', '')) fitting_problem.value_ranges = vr if vr != {} else None # FIT RANGES fit_ranges_str = self._entries.get('fit_ranges', '') # this creates a list of strs like '{key: val, ...}' and parses each fit_ranges = [ _parse_range('{' + r.split('}')[0] + '}') for r in fit_ranges_str.split('{')[1:] ] if fitting_problem.multifit: num_files = len(data_points) fitting_problem.data_x = [d[:, 0] for d in data_points] fitting_problem.data_y = [d[:, 1] for d in data_points] fitting_problem.data_e = [ d[:, 2] if d.shape[1] > 2 else None for d in data_points ] if not fit_ranges: fit_ranges = [{} for _ in range(num_files)] fitting_problem.start_x = [ f['x'][0] if 'x' in f else None for f in fit_ranges ] fitting_problem.end_x = [ f['x'][1] if 'x' in f else None for f in fit_ranges ] else: fitting_problem.data_x = data_points[0][:, 0] fitting_problem.data_y = data_points[0][:, 1] if data_points[0].shape[1] > 2: fitting_problem.data_e = data_points[0][:, 2] if fit_ranges and 'x' in fit_ranges[0]: fitting_problem.start_x = fit_ranges[0]['x'][0] fitting_problem.end_x = fit_ranges[0]['x'][1] if software == 'mantid': # String containing the function name(s) and the starting parameter # values for each function. fitting_problem.additional_info['mantid_equation'] \ = self._entries['function'] if fitting_problem.multifit: fitting_problem.additional_info['mantid_ties'] \ = self._parse_ties() return fitting_problem
def parse(self): """ Parse the Fitbenchmark problem file into a Fitting Problem. :return: The fully parsed fitting problem :rtype: fitbenchmarking.parsing.fitting_problem.FittingProblem """ fitting_problem = FittingProblem() self._entries = self._get_data_problem_entries() software = self._entries['software'].lower() if not (software in import_success and import_success[software][0]): e = import_success[software][1] raise MissingSoftwareError('Requirements are missing for {} parser' ': {}'.format(software, e)) self._parsed_func = self._parse_function() # NAME fitting_problem.name = self._entries['name'] # DATA data_points = self._get_data_points() fitting_problem.data_x = data_points[:, 0] fitting_problem.data_y = data_points[:, 1] if data_points.shape[1] > 2: fitting_problem.data_e = data_points[:, 2] # FUNCTION if software == 'mantid': fitting_problem.function = self._create_mantid_function() elif software == 'sasview': fitting_problem.function = self._create_sasview_function() # EQUATION equation_count = len(self._parsed_func) if equation_count == 1: fitting_problem.equation = self._parsed_func[0]['name'] else: fitting_problem.equation = '{} Functions'.format(equation_count) if software == 'mantid': # String containing the function name(s) and the starting parameter # values for each function fitting_problem._mantid_equation = self._entries['function'] # STARTING VALUES fitting_problem.starting_values = self._get_starting_values() # PARAMETER RANGES vr = self._parse_range('parameter_ranges') fitting_problem.value_ranges = vr if vr != {} else None # FIT RANGES fit_ranges = self._parse_range('fit_ranges') try: fitting_problem.start_x = fit_ranges['x'][0] fitting_problem.end_x = fit_ranges['x'][1] except KeyError: pass return fitting_problem