1539

pending completion

Build # 1539

Build Type

Pull #514

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/fc42b9bf4ea688661c45a4d9fd29a7b131541dac">fc42b9bf4">&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/&lt;a class=&quot;double-link&quot; href=&quot;https://git">&lt;a class=</a>hub.com/fitbenchmarking/fitbenchmarking/commit/fc42b9bf4ea688661c45a4d9fd29a7b131541dac">fc42b9bf4</a><a href="https://github.com/fitbenchmarking/fitbenchmarking/commit/fc42b9bf4ea688661c45a4d9fd29a7b131541dac">&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/fc42b9bf4ea688661c45a4d9fd29a7b131541dac&quot;&gt;fc42b9bf4&lt;/a&gt;&lt;a href=&quot;https://github.com/fitbenchmarking/fitbenchmarking/commit/fc42b9bf4ea688661c45a4d9fd29a7b131541dac&quot;&gt;&amp;lt;a href=&amp;quot;https://github.com/fitbenchmarkin... (continued)

Pull Request Pull Request #514: Adding option toggle for 3rd party output

Run Details

15 of 15 new or added lines in 4 files covered. (100.0%)

1872 of 2210 relevant lines covered (84.71%)

0.85 hits per line

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

15.71

/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):
    """
    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

    :return: list of all results
    :rtype: list of fibenchmarking.utils.fitbm_result.FittingResult
    """
    grabbed_output = output_grabber.OutputGrabber(options)
    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)

            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(options)
    problem = controller.problem

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

fitbenchmarking / fitbenchmarking / 1539

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