saealib.ParEGOAcquisition#

class saealib.ParEGOAcquisition(alpha=0.05, rng=None, direction=None)[source]#

Bases: PointwiseAcquisition

ParEGO acquisition function for multi-objective Bayesian optimisation.

Scalarises objectives using the Augmented Tchebycheff function with a randomly sampled weight vector, then applies Expected Improvement on the scalarised prediction (Knowles 2006; a scalarization variant informed by Chugh 2020).

Scalarised objective (minimised):

g(f; w, z*) = max_i [w_i |f_i - z_i*|] + alpha * sum_i w_i |f_i - z_i*|

where z* is the component-wise minimum of the current archive and w is drawn uniformly from the (k-1)-simplex at each call to compute_reference.

Because saealib’s ABC receives (n_samples, n_obj) predictions rather than per-objective GP posteriors, the scalarised GP is approximated:

mu_s  = g(mu; w, z*)
std_s = (w . std).sum(axis=-1)   [linear-combination approximation]

EI is then computed on (mu_s, std_s) against the best scalarised archive value.

Parameters:

  • alpha (float) – Augmentation coefficient (rho in some references). Default: 0.05 (mlr3mbo convention).

  • rng (np.random.Generator or None) – Random number generator for weight sampling.

  • direction (np.ndarray or None) – Per-objective optimization direction (+1 = maximize, -1 = minimize). shape: (n_obj,). archive.f and the predicted mean are converted to minimize-space via direction_to_minimize_sign before the (minimize-only) scalarisation above runs. None (default) means already-minimize; when unset, it is auto-injected from problem.direction at run start.

References

[29]: Knowles, J. (2006). ParEGO: A hybrid algorithm with on-line landscape approximation for expensive multiobjective optimization problems. IEEE Transactions on Evolutionary Computation, 10(1), 50-66. (Conceptual origin.)

[30]: Chugh, T. (2020). Scalarizing functions in Bayesian multiobjective optimization. 2020 IEEE Congress on Evolutionary Computation (CEC), 1-8. (Scalarization-family reference; saealib uses the weighted augmentation variant documented above.)

Methods

__init__

compute_reference

Sample a new weight vector and compute the ideal point.

contract

Return the ParEGO acquisition contract.

evaluate

Reject prediction is None, resolve the reference, then score().

prepare

Delegate to compute_reference(archive, rng=ctx.rng if ctx else None).

score

Compute EI on the Augmented Tchebycheff scalarised prediction.

Method Details

ParEGOAcquisition.__init__(alpha=0.05, rng=None, direction=None)[source]#
Parameters:

  • alpha (float)

  • rng (Generator | None)

  • direction (ndarray | None)

Return type:

None

ParEGOAcquisition.compute_reference(archive, rng=None)[source]#

Sample a new weight vector and compute the ideal point.

Parameters:

  • archive (Archive) – Archive of evaluated solutions.

  • rng (np.random.Generator or None, optional) – Random number generator. When provided (e.g. ctx.rng), it is used instead of the instance-level _rng so all randomness flows through the master RNG.

Returns:

(z_star, weights, f_best_scalar) — component-wise minimum of archive objective values, a new weight vector drawn uniformly from the (k-1)-simplex, and the minimum scalarised archive value under these weights.

Return type:

tuple

ParEGOAcquisition.contract()[source]#

Return the ParEGO acquisition contract.

Return type:

ComponentContract

ParEGOAcquisition.evaluate(candidates_x, prediction, archive, ctx=None, *, prepared=<object object>)#

Reject prediction is None, resolve the reference, then score().

See AcquisitionFunction.evaluate() for the shared parameter contract, including the _UNSET vs. explicit prepared=None distinction.

Parameters:

  • candidates_x (np.ndarray)

  • prediction (SurrogatePrediction | None)

  • archive (Archive)

  • ctx (OptimizationState | None)

  • prepared (Any)

Return type:

AcquisitionResult

ParEGOAcquisition.prepare(archive, ctx=None)#

Delegate to compute_reference(archive, rng=ctx.rng if ctx else None).

Parameters:

  • archive (Archive)

  • ctx (OptimizationState | None)

Return type:

Any

ParEGOAcquisition.score(prediction, reference, rng=None)[source]#

Compute EI on the Augmented Tchebycheff scalarised prediction.

Parameters:

  • prediction (SurrogatePrediction) – Surrogate predictions. Must have std (has_uncertainty == True).

  • reference (tuple) – (z_star, weights, f_best_scalar) from compute_reference.

  • rng (Generator | None)

Returns:

EI scores. shape: (n_samples,). Higher is better.

Return type:

np.ndarray

Raises:

TypeError – If prediction does not contain uncertainty estimates.