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 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 test_eval_r(self): """ Test that eval_r is correct """ fitting_problem = FittingProblem() self.assertRaises(exceptions.FittingProblemError, fitting_problem.eval_r, params=[1, 2, 3], x=2) fitting_problem.function = lambda x, p1: x + p1 x_val = np.array([1, 8, 11]) y_val = np.array([6, 10, 20]) eval_result = fitting_problem.eval_r(x=x_val, y=y_val, params=[5]) self.assertTrue(all(eval_result == np.array([0, -3, 4]))) e_val = np.array([2, 4, 1]) eval_result = fitting_problem.eval_r(x=x_val, y=y_val, e=e_val, params=[5]) self.assertTrue(all(eval_result == np.array([0, -0.75, 4]))) fitting_problem.data_x = np.array([20, 21, 22]) fitting_problem.data_y = np.array([20, 30, 35]) eval_result = fitting_problem.eval_r(params=[5]) self.assertTrue(all(eval_result == np.array([-5, 4, 8]))) fitting_problem.data_e = np.array([2, 5, 10]) eval_result = fitting_problem.eval_r(params=[5]) self.assertTrue(all(eval_result == np.array([-2.5, 0.8, 0.8])))
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 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 test_eval_j(self): """ Test that eval_j is correct """ def f(x, p1, p2): return p1 * np.exp(p2 * x) def J(x, p): return np.column_stack( (-np.exp(p[1] * x), -x * p[0] * np.exp(p[1] * x))) fitting_problem = FittingProblem() fitting_problem.function = f fitting_problem.data_x = np.array([1, 2, 3, 4, 5]) fitting_problem.data_y = np.array([1, 2, 4, 8, 16]) params = [6, 0.1] eval_result = fitting_problem.eval_j(params=params) actual = J(x=fitting_problem.data_x, p=params) self.assertTrue(np.isclose(actual, eval_result).all())
def test_eval_r_norm(self): """ Test that eval_r_norm is correct """ fitting_problem = FittingProblem() fitting_problem.function = lambda x, p1: x + p1 x_val = np.array([1, 8, 11]) y_val = np.array([6, 10, 20]) e_val = np.array([0.5, 10, 0.1]) eval_result = fitting_problem.eval_r_norm(params=[5], x=x_val, y=y_val, e=e_val) self.assertEqual(eval_result, 1600.09) fitting_problem.data_x = x_val fitting_problem.data_y = y_val eval_result = fitting_problem.eval_r_norm(params=[5]) self.assertEqual(eval_result, 25)
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 test_correct_data_single_fit(self): """ Tests that correct data gives the expected result """ fitting_problem = FittingProblem(self.options) x_data = np.array([-0.5, 0.0, 1.0, 0.5, 1.5, 2.0, 2.5, 3.0, 4.0]) y_data = np.array([0.0, 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0]) e_data = np.array([1.0, 20.0, 30.0, 40.0, 50.0, 60.0, 70.0, 80.0, 9.0]) start_x = 0.5 end_x = 2.5 expected_x_data = np.array([0.5, 1.0, 1.5, 2.0, 2.5]) expected_y_data = np.array([3.0, 2.0, 4.0, 5.0, 6.0]) expected_e_data = np.array([40.0, 30.0, 50.0, 60.0, 70.0]) fitting_problem.data_x = x_data fitting_problem.data_y = y_data fitting_problem.data_e = e_data fitting_problem.start_x = start_x fitting_problem.end_x = end_x fitting_problem.correct_data() self.assertTrue( np.isclose(fitting_problem.data_x[fitting_problem.sorted_index], expected_x_data).all()) self.assertTrue( np.isclose(fitting_problem.data_y[fitting_problem.sorted_index], expected_y_data).all()) self.assertTrue( np.isclose(fitting_problem.data_e[fitting_problem.sorted_index], expected_e_data).all()) self.options.cost_func_type = "nlls" fitting_problem.correct_data() self.assertTrue( np.isclose(fitting_problem.data_x[fitting_problem.sorted_index], expected_x_data).all()) self.assertTrue( np.isclose(fitting_problem.data_y[fitting_problem.sorted_index], expected_y_data).all()) self.assertIs(fitting_problem.data_e, None)
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 test_correct_data_multi_fit(self): """ Tests correct data on a multifit problem. """ fitting_problem = FittingProblem(self.options) fitting_problem.multifit = True x_data = [ np.array([-0.5, 0.0, 1.0, 0.5, 1.5, 2.0, 2.5, 3.0, 4.0]), np.array([-0.5, 0.0, 1.0, 0.5, 1.4, 2.0, 2.5, 3.0, 4.0]), np.array([-0.5, 0.0, 1.0, 0.5, 1.7, 2.0, 2.5, 3.0, 4.0]) ] y_data = [ np.array([0.0, 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0]), np.array([0.0, 1.0, 2.0, 3.0, 24.0, 5.0, 6.0, 7.0, 8.0]), np.array([0.0, 1.0, 2.8, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0]) ] e_data = [ np.array([1.0, 20.0, 30.0, 40.0, 50.0, 60.0, 1.0, 6.0, 9.0]), np.array([1.0, 20.0, 30.0, 40.0, 50.0, 60.0, 1.0, 6.0, 9.0]), np.array([1.0, 20.0, 30.0, 40.0, 50.0, 60.0, 1.0, 6.0, 9.0]) ] start_x = [0.5, 1.1, 0.0] end_x = [2.5, 2.6, 1.0] expected_x_data = [ np.array([0.5, 1.0, 1.5, 2.0, 2.5]), np.array([1.4, 2.0, 2.5]), np.array([0.0, 0.5, 1.0]) ] expected_y_data = [ np.array([3.0, 2.0, 4.0, 5.0, 6.0]), np.array([24.0, 5.0, 6.0]), np.array([1.0, 3.0, 2.8]) ] expected_e_data = [ np.array([40.0, 30.0, 50.0, 60.0, 1.0]), np.array([50.0, 60.0, 1.0]), np.array([20.0, 40.0, 30.0]) ] fitting_problem.data_x = x_data fitting_problem.data_y = y_data fitting_problem.data_e = e_data fitting_problem.start_x = start_x fitting_problem.end_x = end_x fitting_problem.correct_data() for i in range(3): self.assertTrue( np.isclose( fitting_problem.data_x[i][fitting_problem.sorted_index[i]], expected_x_data[i]).all()) self.assertTrue( np.isclose( fitting_problem.data_y[i][fitting_problem.sorted_index[i]], expected_y_data[i]).all()) self.assertTrue( np.isclose( fitting_problem.data_e[i][fitting_problem.sorted_index[i]], expected_e_data[i]).all()) self.options.cost_func_type = "nlls" fitting_problem.correct_data() for i in range(3): self.assertTrue( np.isclose( fitting_problem.data_x[i][fitting_problem.sorted_index[i]], expected_x_data[i]).all()) self.assertTrue( np.isclose( fitting_problem.data_y[i][fitting_problem.sorted_index[i]], expected_y_data[i]).all()) self.assertIs(fitting_problem.data_e[i], None)
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