soogo.model.rbf module

Radial Basis Function model.

class soogo.model.rbf.MedianLpfFilter

Bases: RbfFilter

Filter values by replacing large function values by the median of all.

This strategy was proposed by [1] based on results from [2]. Use this strategy to reduce oscillations of the interpolator, especially if the range target function is large. This filter may reduce the quality of the approximation by the surrogate.

References

[1]

Gutmann, HM. A Radial Basis Function Method for Global Optimization. Journal of Global Optimization 19, 201–227 (2001). https://doi.org/10.1023/A:1011255519438

[2]

Björkman, M., Holmström, K. Global Optimization of Costly Nonconvex Functions Using Radial Basis Functions. Optimization and Engineering 1, 373–397 (2000). https://doi.org/10.1023/A:1011584207202

__call__(x) → ndarray

Call self as a function.

Return type:

ndarray

class soogo.model.rbf.RbfFilter

Bases: object

Base filter class for the RBF target training set. Trivial identity filter.

__call__(x) → ndarray

Call self as a function.

Return type:

ndarray

class soogo.model.rbf.RbfModel(kernel: ~soogo.model.rbf_kernel.RadialBasisFunction = <soogo.model.rbf_kernel.CubicRadialBasisFunction object>, iindex: tuple[int, ...] = (), filter: ~soogo.model.rbf.RbfFilter | None = None)

Bases: Surrogate

Radial Basis Function model.

\[f(x) = \sum_{i=1}^{m} \beta_i \phi(\|x - x_i\|) + \sum_{i=1}^{n} \beta_{m+i} p_i(x),\]

where:

• \(m\) is the number of sampled points.

• \(x_i\) are the sampled points.

• \(\beta_i\) are the coefficients of the RBF model.

• \(\phi\) is the kernel function.

• \(p_i\) are the basis functions of the polynomial tail.

• \(n\) is the dimension of the polynomial tail.

This implementation focuses on quick successive updates of the model, which is essential for the good performance of active learning processes.

Parameters:

• kernel (RadialBasisFunction) – Kernel function \(\phi\) used in the RBF model. (default: <soogo.model.rbf_kernel.CubicRadialBasisFunction object at 0x7f33de78a570>)

• iindex (tuple[int, ...]) – Indices of integer variables in the feature space. (default: ())

• filter (Optional[RbfFilter]) – Filter to be used in the target (image) space. (default: None)

kernel

Kernel function \(\phi\) used in the RBF model.

filter

Filter to be used in the target (image) space.

property X: ndarray

Get the training data points.

Returns:

m-by-d matrix with m training points in a d-dimensional space.

property Y: ndarray

Get f(x) for the sampled points.

__call__(x: ndarray, i: int = -1, return_dist: bool = False) → ndarray | Tuple[ndarray, ndarray]

Evaluates the model at one or multiple points.

Parameters:

• x (ndarray) – m-by-d matrix with m point coordinates in a d-dimensional space.

• i (int) – Index of the target dimension to evaluate. If -1, evaluate all. (default: -1)

• return_dist (bool) – If True, returns the distance matrix between the input points and the training points. (default: False)

Return type:

Union[ndarray, Tuple[ndarray, ndarray]]

Returns:

• Value for the RBF model on each of the input points.

• Matrix D where D[i, j] is the distance between the i-th

  input point and the j-th training point.

check_initial_design(sample: ndarray) → bool

Check if the sample is able to generate a valid surrogate.

Parameters:

sample (ndarray) – m-by-d matrix with m training points in a d-dimensional space.

Return type:

bool

eval_kernel(x, y=None)

Evaluate the kernel function at a pair (x,y).

The structure of the kernel is the same as the one passed as parameter but with optimized hyperparameters.

Parameters:

• x – First entry in the tuple (x,y).

• y – Second entry in the tuple (x,y). If None, use x. (default: None)

Returns:

Kernel evaluation result.

hessp(x: ndarray, v: ndarray) → ndarray

Evaluates the Hessian of the model at x in the direction of v.

\[H(f)(x) v = \sum_{i=1}^{m} \beta_i \left( \phi''(r_i)\frac{(x^Tv)x}{r_i^2} + \frac{\phi'(r_i)}{r_i} \left(v - \frac{(x^Tv)x}{r_i^2}\right) \right) + \sum_{i=1}^{n} \beta_{m+i} H(p_i)(x) v.\]

where \(r_i = \|x - x_i\|\).

Parameters:

• x (ndarray) – Point in a d-dimensional space.

• v (ndarray) – Direction in which the Hessian is evaluated.

Return type:

ndarray

property iindex: tuple[int, ...]

Return iindex, the sequence of integer variable indexes.

jac(x: ndarray) → ndarray

Evaluates the derivative of the model at one point.

\[\nabla f(x) = \sum_{i=1}^{m} \beta_i \frac{\phi'(r_i)}{r_i} x + \sum_{i=1}^{n} \beta_{m+i} \nabla p_i(x).\]

where \(r_i = \|x - x_i\|\).

Parameters:

x (ndarray) – Point in a d-dimensional space.

Return type:

ndarray

min_design_space_size(dim: int) → int

Return the minimum design space size for a given space dimension.

Return type:

int

mu_measure(x: ndarray) → ndarray

Compute the value of abs(mu) for an RBF model.

The mu measure was first defined in [3] with suggestions of usage for global optimization with RBF functions. In [4], the authors detail the strategy to make the evaluations computationally viable.

The current implementation, uses a different strategy than that from Björkman and Holmström (2000), where a single LDLt factorization is used instead of the QR and Cholesky factorizations. The new algorithm’s performs 10 times less operations than the former. Like the former, the new algorithm is also able to use high-intensity linear algebra operations when the routine is called with multiple points \(x\) are evaluated at once.

Note

Before calling this method, the model must be prepared with prepare_mu_measure().

Parameters:

x (ndarray) – m-by-d matrix with m point coordinates in a d-dimensional space.

Return type:

ndarray

Returns:

The value of abs(mu) for every point in x.

References

[3]

Gutmann, HM. A Radial Basis Function Method for Global Optimization. Journal of Global Optimization 19, 201–227 (2001). https://doi.org/10.1023/A:1011255519438

[4]

Björkman, M., Holmström, K. Global Optimization of Costly Nonconvex Functions Using Radial Basis Functions. Optimization and Engineering 1, 373–397 (2000). https://doi.org/10.1023/A:1011584207202

polynomial_tail(x: ndarray) → ndarray

Computes the polynomial tail matrix for a given set of points.

Parameters:

x (ndarray) – m-by-d matrix with m point coordinates in a d-dimensional space.

Return type:

ndarray

polynomial_tail_size() → int

Get the dimension of the polynomial tail.

Return type:

int

prepare_mu_measure()

Prepare the model for mu measure computation.

This routine computes the LDLt factorization of the matrix A, which is used to compute the mu measure. The factorization is computed only once and can be reused for multiple calls to mu_measure().

reserve(maxeval: int, dim: int, ntarget: int = 1) → None

Reserve space for the RBF model.

This routine avoids successive dynamic memory allocations with successive calls of update(). If the input maxeval is smaller than the current number of sample points, nothing is done.

Parameters:

• maxeval (int) – Maximum number of function evaluations.

• dim (int) – Dimension of the domain space.

• ntarget (int) – Dimension of the target space. (default: 1)

Return type:

None

reset_data() → None

Reset the surrogate model training data.

This method is used to clear the training data of the surrogate model, allowing it to be reused for a new optimization run.

Return type:

None

update(xNew: ndarray, fx) → None

Updates the model with new pairs of data (x,y).

Parameters:

• xNew (ndarray) – m-by-d matrix with m point coordinates in a d-dimensional space.

• fx – Function values on the sampled points.

Return type:

None