12110078619

Committed 01 Dec 2024 11:38PM UTC coverage: 89.812% (-1.6%) from 91.458%

Build # 12110078619

Build Type

Pull #1290

github

Specific Base 5920df

Committed by

pre-commit-ci[bot]

Commit Message

[pre-commit.ci] auto fixes from pre-commit.com hooks

for more information, see https://pre-commit.ci

Pull Request Pull Request #1290: Add partial support for galahad

Run Details

42 of 134 new or added lines in 19 files covered. (31.34%)

9 existing lines in 5 files now uncovered.

4822 of 5369 relevant lines covered (89.81%)

0.9 hits per line

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

0.0

/fitbenchmarking/controllers/galahad_controller.py

1	"""
2	Implements a controller for the GALAHAD fitting software.
3	"""
4
NEW 5	from typing import Any, Callable, Dict	×
6
NEW 7	import numpy as np	×
NEW 8	from galahad import arc, bgo, dgo, nls, trb, tru	×
9
NEW 10	from fitbenchmarking.controllers.base_controller import Controller	×
NEW 11	from fitbenchmarking.utils.exceptions import IncompatibleMinimizerError	×
12
13
NEW 14	class GalahadController(Controller):	×
15	"""
16	Controller for the GALAHAD fitting software.
17	"""
18
NEW 19	algorithm_check = {	×
20	"all": ["arc", "bgo", "dgo", "nls", "trb", "tru"],
21	"ls": ["nls"],
22	"deriv_free": [],
23	"general": [],
24	"simplex": [],
25	"trust_region": ["trb", "tru"],
26	"levenberg-marquardt": [],
27	"gauss_newton": [],
28	"bfgs": [],
29	"conjugate_gradient": [],
30	"steepest_descent": [],
31	"global_optimization": ["bgo", "dgo"],
32	"MCMC": [],
33	}
34
NEW 35	jacobian_enabled_solvers = ["arc", "bgo", "dgo", "nls", "trb", "tru"]	×
NEW 36	hessian_enabled_solvers = ["arc", "bgo", "dgo", "nls", "trb", "tru"]	×
37
NEW 38	support_for_bounds = True	×
NEW 39	no_bounds_minimizers = ["arc", "tru", "nls"]	×
NEW 40	bounds_required_minimizers = ["bgo", "dgo"]	×
41
NEW 42	def __init__(self, cost_func):	×
43	"""
44	Initialises variable used for temporary storage.
45
46	:param cost_func: Cost function object selected from options.
47	:type cost_func: subclass of
48	:class:`~fitbenchmarking.cost_func.base_cost_func.CostFunc`
49
50	"""
NEW 51	super().__init__(cost_func)	×
52
NEW 53	self._num_vars = len(self.cost_func.problem.param_names)	×
NEW 54	self._hessian: "Callable" = self._noop	×
NEW 55	self._initial_params_array = np.zeros(self._num_vars)	×
NEW 56	self._module = arc	×
NEW 57	self._jacobian = self.cost_func.jac_cost	×
NEW 58	self._P = self._eval_hes_res_product	×
NEW 59	self._result = [0]	×
NEW 60	self._minimizer = ""	×
NEW 61	self._variant = ""	×
62
NEW 63	def setup(self):	×
64	"""
65	Setup problem ready to be run with GALAHAD
66	"""
NEW 67	minimizer: "str" = self.minimizer	×
NEW 68	variant: "str" = ""	×
NEW 69	try:	×
NEW 70	minimizer, variant = minimizer.split("_", 1)	×
NEW 71	except ValueError:	×
NEW 72	pass	×
73
NEW 74	self._module = {	×
75	"arc": arc,
76	"bgo": bgo,
77	"dgo": dgo,
78	"nls": nls,
79	"trb": trb,
80	"tru": tru,
81	}[minimizer]
82
NEW 83	has_hessian = self.cost_func.hessian is not None	×
NEW 84	self._jacobian = self.cost_func.jac_cost	×
85
NEW 86	x_l, x_u = ([], [])	×
NEW 87	if self.value_ranges is None:	×
NEW 88	x_l = np.repeat(-np.inf, self._num_vars)	×
NEW 89	x_u = np.repeat(np.inf, self._num_vars)	×
90	else:
NEW 91	x_l, x_u = zip(*self.value_ranges)	×
92
NEW 93	x_l = np.array(x_l)	×
NEW 94	x_u = np.array(x_u)	×
95
NEW 96	opts = self._module.initialize()	×
NEW 97	kwargs: "Dict[str, Any]" = {	×
98	"options": opts,
99	}
100
NEW 101	if minimizer in ["arc", "tru"]:	×
NEW 102	kwargs.update(	×
103	{
104	"n": self._num_vars,
105	"H_type": "dense" if has_hessian else "absent",
106	"H_ne": 10,
107	"H_row": None,
108	"H_col": None,
109	"H_ptr": None,
110	}
111	)
NEW 112	elif minimizer in ["bgo", "dgo", "trb"]:	×
NEW 113	kwargs.update(	×
114	{
115	"n": self._num_vars,
116	"x_l": x_l,
117	"x_u": x_u,
118	"H_type": "dense" if has_hessian else "absent",
119	"H_ne": 10,
120	"H_row": None,
121	"H_col": None,
122	"H_ptr": None,
123	}
124	)
125
NEW 126	elif minimizer in ["nls"]:	×
NEW 127	if not has_hessian:	×
NEW 128	raise IncompatibleMinimizerError(	×
129	"Requires hessian information (for now)"
130	)
NEW 131	kwargs.update(	×
132	{
133	"n": self._num_vars,
134	"m": self.data_x.shape[0],
135	"J_type": "dense",
136	"J_ne": 10,
137	"J_row": None,
138	"J_col": None,
139	"J_ptr": None,
140	"H_type": "dense",
141	"H_ne": 10,
142	"H_row": None,
143	"H_col": None,
144	"H_ptr": None,
145	"w": np.ones(self.data_x.shape[0]),
146	"P_type": "dense_by_columns",
147	"P_ne": 10,
148	"P_row": None,
149	"P_col": None,
150	"P_ptr": None,
151	}
152	)
NEW 153	self._jacobian = self._jac	×
154
NEW 155	if has_hessian:	×
NEW 156	self._hessian = self._hes	×
NEW 157	self._P = self._eval_hes_res_product	×
158	else:
NEW 159	self._hessian = self._noop	×
160
NEW 161	self._module.load(**kwargs)	×
162
NEW 163	self._initial_params_array = np.array(self.initial_params)	×
NEW 164	self._minimizer = minimizer	×
NEW 165	self._variant = variant	×
166
NEW 167	def fit(self):	×
168	"""
169	Run problem with GALAHAD.
170	"""
NEW 171	kwargs = {}	×
NEW 172	if self._minimizer in ["arc", "bgo", "dgo", "trb", "tru"]:	×
NEW 173	kwargs = {	×
174	"n": self._num_vars,
175	"H_ne": int(self._num_vars * (self._num_vars + 1) / 2),
176	"x": self._initial_params_array,
177	"eval_f": self.cost_func.eval_cost,
178	"eval_g": self._jacobian,
179	"eval_h": self._hessian,
180	}
NEW 181	elif self._minimizer in ["nls"]:	×
NEW 182	m = self.data_x.shape[0]	×
NEW 183	kwargs = {	×
184	"n": self._num_vars,
185	"m": m,
186	"x": self._initial_params_array,
187	"eval_c": self.cost_func.eval_r,
188	"J_ne": self._num_vars * m,
189	"eval_j": self._jacobian,
190	"H_ne": int(self._num_vars * (self._num_vars + 1) / 2),
191	"eval_h": self._hessian,
192	"P_ne": self._num_vars * m,
193	"eval_hprod": self._P,
194	}
195
NEW 196	self._result = self._module.solve(**kwargs)	×
197
NEW 198	def cleanup(self):	×
199	"""
200	Convert the result to a numpy array and populate the variables results
201	will be read from.
202	"""
NEW 203	status_map = {	×
204	0: 0, # Success
205	-1: 3, # Alloc error
206	-2: 3, # Dealloc error
207	-3: 3, # Bad hessian format
208	-7: 3, # Unbounded objective
209	-9: 3, # Analysis failed (linear solve)
210	-10: 3, # Factorisation failed (linear solve)
211	-11: 3, # Solve failed (linear solve)
212	-15: 3, # Preconditioner not pos def
213	-16: 2, # Ill-conditioned
214	-17: 0, # Computed step too small to make further
215	# progress
216	-18: 1, # Too many iterations
217	-19: 3, # Max runtime
218	-82: 3, # Killed by user
219	}
NEW 220	info = self._module.information()	×
NEW 221	self._module.terminate()	×
NEW 222	self.final_params = self._result[0]	×
NEW 223	self.flag = status_map[info["status"]]	×
224
NEW 225	def _jac(self, p):	×
NEW 226	tmp: "np.ndarray" = self.cost_func.jac_res(p)	×
NEW 227	return np.ravel(tmp)	×
228
NEW 229	def _hes(self, p):	×
NEW 230	tmp: "np.ndarray" = self.cost_func.hes_cost(p)	×
NEW 231	return tmp[np.tril_indices(tmp.shape[0])]	×
232
NEW 233	def _eval_hes_res_product(self, p, v):	×
NEW 234	H, _ = self.cost_func.hes_res(p)	×
NEW 235	n = len(v)	×
NEW 236	P = np.zeros(n * H.shape[-1])	×
NEW 237	for i in range(H.shape[-1]):	×
NEW 238	P[i * n : (i + 1) * n] = np.dot(H[..., i], v)	×
239
NEW 240	return P	×
241
NEW 242	def _noop(self, *args):	×
NEW 243	return None	×

fitbenchmarking / fitbenchmarking / 12110078619

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