1541

pending completion

Build # 1541

Build Type

Pull #512

travis-ci

Committed by

web-flow

Commit Message

<a href="https://github.com/fitbenchmarking/fitbenchmarking/commit/<a class=hub.com/fitbenchmarking/fitbenchmarking/commit/<a class="double-link" href="https://git"><a class=hub.com/fitbenchmarking/fitbenchmarking/commit/<a class="double-link" href="https://git"><a class=hub.com/fitbenchmarking/fitbenchmarking/commit/<a class="double-link" href="https://git"><a class=hub.com/fitbenchmarking/fitbenchmarking/commit/4c6484adce11ee7222016e44d58a8fff83f156b7">4c6484adc">&lt;a href=&quot;https://github.com/fitbenchmarking/fitbenchmarking/commit/</a><a class="double-link" href="https://github.com/fitbenchmarking/fitbenchmarking/commit/&lt;a class=&quot;double-link&quot; href=&quot;https://git">&lt;a class=</a>hub.com/fitbenchmarking/fitbenchmarking/commit/&lt;a class=&quot;double-link&quot; href=&quot;https://git">&lt;a class=</a>hub.com/fitbenchmarking/fitbenchmarking/commit/&lt;a class=&quot;double-link&quot; href=&quot;https://git">&lt;a class=</a>hub.com/fitbenchmarking/fitbenchmarking/commit/&lt;a class=&quot;double-link&quot; href=&quot;https://git">&lt;a class=</a>hub.com/fitbenchmarking/fitbenchmarking/commit/4c6484adce11ee7222016e44d58a8fff83f156b7">4c6484adc</a><a href="https://github.com/fitbenchmarking/fitbenchmarking/commit/4c6484adce11ee7222016e44d58a8fff83f156b7">&quot;&gt;&amp;lt;a href=&amp;quot;https://github.com/fitbenchmarking/fitbenchmarking/commit/&lt;/a&gt;&lt;a class=&quot;double-link&quot; href=&quot;https://github.com/fitbenchmarking/fitbenchmarking/commit/&amp;lt;a class=&amp;quot;double-link&amp;quot; href=&amp;quot;https://git&quot;&gt;&amp;lt;a class=&lt;/a&gt;hub.com/fitbenchmarking/fitbenchmarking/commit/&amp;lt;a class=&amp;quot;double-link&amp;quot; href=&amp;quot;https://git&quot;&gt;&amp;lt;a class=&lt;/a&gt;hub.com/fitbenchmarking/fitbenchmarking/commit/&amp;lt;a class=&amp;quot;double-link&amp;quot; href=&amp;quot;https://git&quot;&gt;&amp;lt;a class=&lt;/a&gt;hub.com/fitbenchmarking/fitbenchmarking/commit/4c6484adce11ee7222016e44d58a8fff83f156b7&quot;&gt;4c6484adc&lt;/a&gt;&lt;a href=&quot;https://github.com/fitbenchmarking/fitbenchmarking/commit/4c6484adce11ee7222016e44d58a8fff83f156b7&quot;&gt;&amp;quot;&amp;gt;&amp;amp;lt;a href=&amp;amp;quot;https://github.com/fitbenchmarking/fitbenchmarking/commit/&amp;lt;/a&amp;gt;&amp;lt;a class=&amp;quot;double-link&amp;quot; href=&... (continued)

Pull Request Pull Request #512: Adding Jacobian class

Run Details

90 of 90 new or added lines in 19 files covered. (100.0%)

1916 of 2261 relevant lines covered (84.74%)

0.85 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

15.49

/fitbenchmarking/core/fitbenchmark_one_problem.py

"""
Fit benchmark one problem functions.
"""

from __future__ import absolute_import, division, print_function

import timeit
import warnings

import numpy as np

from fitbenchmarking.controllers.controller_factory import ControllerFactory
from fitbenchmarking.utils import fitbm_result, output_grabber
from fitbenchmarking.utils.exceptions import UnknownMinimizerError
from fitbenchmarking.utils.log import get_logger

LOGGER = get_logger()


def fitbm_one_prob(problem, options, jacobian):
    """
    Sets up the controller for a particular problem and fits the models
    provided in the problem object.

    :param problem: a problem object containing information used in fitting
    :type problem: FittingProblem
    :param options: all the information specified by the user
    :type options: fitbenchmarking.utils.options.Options
    :param jacobian: Jacobian class for the problem
    :type jacobian: fitbenchmarking.jacobian.base_controller.Jacobian subclass

    :return: list of all results
    :rtype: list of fibenchmarking.utils.fitbm_result.FittingResult
    """
    grabbed_output = output_grabber.OutputGrabber()
    results = []

    software = options.software
    if not isinstance(software, list):
        software = [software]

    name = problem.name
    num_start_vals = len(problem.starting_values)
    for i in range(num_start_vals):
        print("    Starting value: {0}/{1}".format(i + 1, num_start_vals))

        if num_start_vals > 1:
            problem.name = name + ', Start {}'.format(i + 1)

        for s in software:
            LOGGER.info("        Software: %s", s.upper())
            try:
                minimizers = options.minimizers[s]
            except KeyError:
                raise UnknownMinimizerError(
                    'No minimizer given for software: {}'.format(s))
            with grabbed_output:
                controller_cls = ControllerFactory.create_controller(
                    software=s)
                controller = controller_cls(problem=problem,
                                            jacobian=jacobian)

            controller.parameter_set = i
            problem_result = benchmark(controller=controller,
                                       minimizers=minimizers,
                                       options=options)

            results.extend(problem_result)

    # Reset problem.name
    problem.name = name
    return results


def benchmark(controller, minimizers, options):
    """
    Fit benchmark one problem, with one function definition and all
    the selected minimizers, using the chosen fitting software.

    :param controller: The software controller for the fitting
    :type controller: Object derived from BaseSoftwareController
    :param minimizers: array of minimizers used in fitting
    :type minimizers: list
    :param options: all the information specified by the user
    :type options: fitbenchmarking.utils.options.Options

    :return: list of all results
    :rtype: list of fibenchmarking.utils.fitbm_result.FittingResult
    """
    grabbed_output = output_grabber.OutputGrabber()
    problem = controller.problem
    jac = controller.jac

    results_problem = []
    num_runs = options.num_runs
    for minimizer in minimizers:
        LOGGER.info("            Minimizer: %s", minimizer)

        controller.minimizer = minimizer

        try:
            with grabbed_output:
                # Calls timeit repeat with repeat = num_runs and number = 1
                runtime_list = \
                    timeit.Timer(setup=controller.prepare,
                                 stmt=controller.fit).repeat(num_runs, 1)
                runtime = sum(runtime_list) / num_runs
                controller.cleanup()
        # Catching all exceptions as this means runtime cannot be calculated
        # pylint: disable=broad-except
        except Exception as excp:
            LOGGER.warn(str(excp))

            runtime = np.inf
            controller.flag = 3
            controller.final_params = None if not problem.multifit \
                else [None] * len(controller.data_x)

        controller.check_attributes()

        if controller.flag <= 2:
            ratio = np.max(runtime_list) / np.min(runtime_list)
            tol = 4
            if ratio > tol:
                warnings.warn('The ratio of the max time to the min is {0}'
                              ' which is  larger than the tolerance of {1},'
                              ' which may indicate that caching has occurred'
                              ' in the timing results'.format(ratio, tol))
            chi_sq = controller.eval_chisq(params=controller.final_params,
                                           x=controller.data_x,
                                           y=controller.data_y,
                                           e=controller.data_e)
        else:
            chi_sq = np.inf if not problem.multifit \
                else [np.inf] * len(controller.data_x)

        result_args = {'options': options,
                       'problem': problem,
                       'jac': jac,
                       'chi_sq': chi_sq,
                       'runtime': runtime,
                       'minimizer': minimizer,
                       'initial_params': controller.initial_params,
                       'params': controller.final_params,
                       'error_flag': controller.flag,
                       'name': problem.name}

        if problem.multifit:
            # Multi fit (will raise TypeError if these are not iterable)
            for i in range(len(chi_sq)):

                result_args.update({'dataset_id': i,
                                    'name': '{}, Dataset {}'.format(
                                        problem.name, (i + 1))})
                individual_result = fitbm_result.FittingResult(**result_args)
                results_problem.append(individual_result)
        else:
            # Normal fitting
            individual_result = fitbm_result.FittingResult(**result_args)

            results_problem.append(individual_result)

    return results_problem

1	"""
2	Fit benchmark one problem functions.
3	"""
4
5	from __future__ import absolute_import, division, print_function	1✔
6
7	import timeit	1✔
8	import warnings	1✔
9
10	import numpy as np	1✔
11
12	from fitbenchmarking.controllers.controller_factory import ControllerFactory	1✔
13	from fitbenchmarking.utils import fitbm_result, output_grabber	1✔
14	from fitbenchmarking.utils.exceptions import UnknownMinimizerError	1✔
15	from fitbenchmarking.utils.log import get_logger	1✔
16
17	LOGGER = get_logger()	1✔
18
19
20	def fitbm_one_prob(problem, options, jacobian):	1✔
21	"""
22	Sets up the controller for a particular problem and fits the models
23	provided in the problem object.
24
25	:param problem: a problem object containing information used in fitting
26	:type problem: FittingProblem
27	:param options: all the information specified by the user
28	:type options: fitbenchmarking.utils.options.Options
29	:param jacobian: Jacobian class for the problem
30	:type jacobian: fitbenchmarking.jacobian.base_controller.Jacobian subclass
31
32	:return: list of all results
33	:rtype: list of fibenchmarking.utils.fitbm_result.FittingResult
34	"""
35	grabbed_output = output_grabber.OutputGrabber()	×
36	results = []	×
37
38	software = options.software	×
39	if not isinstance(software, list):	×
40	software = [software]	×
41
42	name = problem.name	×
43	num_start_vals = len(problem.starting_values)	×
44	for i in range(num_start_vals):	×
45	print(" Starting value: {0}/{1}".format(i + 1, num_start_vals))	×
46
47	if num_start_vals > 1:	×
48	problem.name = name + ', Start {}'.format(i + 1)	×
49
50	for s in software:	×
51	LOGGER.info(" Software: %s", s.upper())	×
52	try:	×
53	minimizers = options.minimizers[s]	×
54	except KeyError:	×
55	raise UnknownMinimizerError(	×
56	'No minimizer given for software: {}'.format(s))
57	with grabbed_output:	×
58	controller_cls = ControllerFactory.create_controller(	×
59	software=s)
60	controller = controller_cls(problem=problem,	×
61	jacobian=jacobian)
62
63	controller.parameter_set = i	×
64	problem_result = benchmark(controller=controller,	×
65	minimizers=minimizers,
66	options=options)
67
68	results.extend(problem_result)	×
69
70	# Reset problem.name
71	problem.name = name	×
72	return results	×
73
74
75	def benchmark(controller, minimizers, options):	1✔
76	"""
77	Fit benchmark one problem, with one function definition and all
78	the selected minimizers, using the chosen fitting software.
79
80	:param controller: The software controller for the fitting
81	:type controller: Object derived from BaseSoftwareController
82	:param minimizers: array of minimizers used in fitting
83	:type minimizers: list
84	:param options: all the information specified by the user
85	:type options: fitbenchmarking.utils.options.Options
86
87	:return: list of all results
88	:rtype: list of fibenchmarking.utils.fitbm_result.FittingResult
89	"""
90	grabbed_output = output_grabber.OutputGrabber()	×
91	problem = controller.problem	×
92	jac = controller.jac	×
93
94	results_problem = []	×
95	num_runs = options.num_runs	×
96	for minimizer in minimizers:	×
97	LOGGER.info(" Minimizer: %s", minimizer)	×
98
99	controller.minimizer = minimizer	×
100
101	try:	×
102	with grabbed_output:	×
103	# Calls timeit repeat with repeat = num_runs and number = 1
104	runtime_list = \	×
105	timeit.Timer(setup=controller.prepare,
106	stmt=controller.fit).repeat(num_runs, 1)
107	runtime = sum(runtime_list) / num_runs	×
108	controller.cleanup()	×
109	# Catching all exceptions as this means runtime cannot be calculated
110	# pylint: disable=broad-except
111	except Exception as excp:	×
112	LOGGER.warn(str(excp))	×
113
114	runtime = np.inf	×
115	controller.flag = 3	×
116	controller.final_params = None if not problem.multifit \	×
117	else [None] * len(controller.data_x)
118
119	controller.check_attributes()	×
120
121	if controller.flag <= 2:	×
122	ratio = np.max(runtime_list) / np.min(runtime_list)	×
123	tol = 4	×
124	if ratio > tol:	×
125	warnings.warn('The ratio of the max time to the min is {0}'	×
126	' which is larger than the tolerance of {1},'
127	' which may indicate that caching has occurred'
128	' in the timing results'.format(ratio, tol))
129	chi_sq = controller.eval_chisq(params=controller.final_params,	×
130	x=controller.data_x,
131	y=controller.data_y,
132	e=controller.data_e)
133	else:
134	chi_sq = np.inf if not problem.multifit \	×
135	else [np.inf] * len(controller.data_x)
136
137	result_args = {'options': options,	×
138	'problem': problem,
139	'jac': jac,
140	'chi_sq': chi_sq,
141	'runtime': runtime,
142	'minimizer': minimizer,
143	'initial_params': controller.initial_params,
144	'params': controller.final_params,
145	'error_flag': controller.flag,
146	'name': problem.name}
147
148	if problem.multifit:	×
149	# Multi fit (will raise TypeError if these are not iterable)
150	for i in range(len(chi_sq)):	×
151
152	result_args.update({'dataset_id': i,	×
153	'name': '{}, Dataset {}'.format(
154	problem.name, (i + 1))})
155	individual_result = fitbm_result.FittingResult(**result_args)	×
156	results_problem.append(individual_result)	×
157	else:
158	# Normal fitting
159	individual_result = fitbm_result.FittingResult(**result_args)	×
160
161	results_problem.append(individual_result)	×
162
163	return results_problem	×

fitbenchmarking / fitbenchmarking / 1541

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous