PyBADS Example 1: Basic usage#
In this introductory example, we will show a simple usage of Bayesian Adaptive Direct Search (BADS) to perform optimization of a synthetic target function.
This notebook is Part 1 of a series of notebooks in which we present various example usages for BADS with the PyBADS package. The code used in this example is available as a script here.
import numpy as np
from pybads.bads import BADS
0. What is (Py)BADS?#
BADS is a fast hybrid Bayesian optimization algorithm designed to solve difficult optimization problems, in particular related to parameter estimation – aka model fitting – of computational models (e.g., via maximum-likelihood or maximum-a-posteriori estimation). PyBADS is its Python implementation.
BADS has been intensively tested for fitting a variety of computational models, and is currently used by many research groups around the world (see Google Scholar for many example applications). In our benchmark with real model-fitting problems, BADS performed on par or better than many other common and state-of-the-art optimizers, as shown in the original BADS paper.
BADS is particularly recommended when:
the objective function landscape is rough (nonsmooth), typically due to numerical approximations or noise;
the objective function is moderately expensive to compute (e.g., more than 0.1 second per function evaluation);
the gradient is unavailable;
the number of input parameters is up to about
D = 20or so.
BADS requires no specific tuning and runs off-the-shelf like other built-in Python optimizers (e.g., from scipy.optimize.minimize).
Note: If you are interested in estimating posterior distributions (i.e., uncertainty and error bars) over model parameters, and not just point estimates, you might also want to check out Variational Bayesian Monte Carlo for Python (PyVBMC), a package for Bayesian posterior and model inference which can be used in synergy with PyBADS.
Optimization problem#
Formally, the goal of BADS is to minimize a target (or objective) function \(f(\mathbf{x}): \mathbb{R}^D \rightarrow \mathbb{R}\), for \(\mathbf{x} \in \mathbb{R}^D\),
where \(D\) is the dimensionality of the problem and lower_bounds, upper_bounds are arrays representing lower/upper bound constraints, which can be set to infinite for unbounded parameters.
1. Problem setup#
Here we show PyBADS at work on Rosenbrock’s banana function in 2D as target function.
We specify wide hard bounds and tighter plausible bounds that (hopefully) contain the solution.
Hard lower/upper bounds
lower_bounds,upper_boundsare the actual optimization bounds; PyBADS will not evaluate the target function outside these bounds, but might evaluate the target on the bounds. You can use-np.infandnp.inffor unbounded parameters.Plausible lower/upper bounds
plausible_lower_bounds,plausible_upper_boundsrepresent our best guess at bounding the region where the solution might lie. The plausible bounds do not change the optimization problem, but help define the initial exploration and hyperparameters of PyBADS.
We set as starting point for the optimization \(\mathbf{x}_0 = (0, 0)\).
def rosenbrocks_fcn(x):
"""Rosenbrock's 'banana' function in any dimension."""
x_2d = np.atleast_2d(x)
return np.sum(100 * (x_2d[:, 0:-1]**2 - x_2d[:, 1:])**2 + (x_2d[:, 0:-1]-1)**2, axis=1)
target = rosenbrocks_fcn;
lower_bounds = np.array([-20, -20])
upper_bounds = np.array([20, 20])
plausible_lower_bounds = np.array([-5, -5])
plausible_upper_bounds = np.array([5, 5])
x0 = np.array([0, 0]); # Starting point
2. Initialize and run the optimization#
Then, we initialize a bads instance which takes care of the optimization. For now, we use default options.
To run the optimization, we simply call bads.optimize(), which returns an OptimizeResult object.
bads = BADS(target, x0, lower_bounds, upper_bounds, plausible_lower_bounds, plausible_upper_bounds)
optimize_result = bads.optimize()
Beginning optimization of a DETERMINISTIC objective function
Iteration f-count f(x) MeshScale Method Actions
0 2 1 1 Uncertainty test
0 6 1 1 Initial mesh Initial points
0 10 1 0.5 Refine grid Train
1 18 1 0.25 Refine grid Train
2 22 0.250428 0.25 Successful search (ES-wcm)
2 24 0.0851394 0.25 Successful search (ES-ell)
2 26 0.00997961 0.25 Incremental search (ES-ell)
2 27 0.000224117 0.25 Incremental search (ES-ell)
2 34 0.000224117 0.125 Refine grid
3 42 0.000224117 0.0625 Refine grid Train
4 44 7.97867e-05 0.0625 Incremental search (ES-wcm)
4 50 7.97867e-05 0.03125 Refine grid
5 58 7.97867e-05 0.0078125 Refine grid
6 66 7.97867e-05 0.00195312 Refine grid Train
Optimization terminated: change in the function value less than options['tol_fun'].
Function value at minimum: 7.97867122044391e-05
3. Results and conclusions#
We examine now the result of the optimization stored in optimize_result. The most important keys are the location of the minimum, optimize_result['x'], and the value of the function at the minimum, optimize_result['fval'].
x_min = optimize_result['x']
fval = optimize_result['fval']
print(f"BADS minimum at: x_min = {x_min.flatten()}, fval = {fval:.4g}")
print(f"total f-count: {optimize_result['func_count']}, time: {round(optimize_result['total_time'], 2)} s")
BADS minimum at: x_min = [1.00744247 1.01543427], fval = 7.979e-05
total f-count: 67, time: 1.34 s
For reference, the true minimum of the Rosenbrock function is at \(\textbf{x}^\star = [1, 1]\), where \(f^\star = 0\).
In conclusion, PyBADS found the solution with a fairly small number of function evaluations (f-count), which is particularly important if the target function is mildly-to-very expensive to compute as in many computational models.
Note: PyBADS by default does not aim for extreme numerical precision of the target (e.g., beyond the 2nd or 3rd decimal place), since in most realistic model-fitting problems a higher resolution is not particularly useful, e.g. due to noise or variability in the data.