How to correctly handle multiple nonlinear constraints in a multi-objective problem?

[Frxljord]

Hi, I'm new to Botorch and I'm trying to implement a multi-objective optimization of 2 objectives with 2 expensive constraint functions. My problem formulation returns the objective values (both to be maximized) and the slacks defined as

slack1 = T - self.min_thrust_required
slack2 = 1e6*self.material_tensile_strength/self.material_safety_factor - np.max(centrifugal_stress+bending_stress)

so that they are positive when the sample is feasible. Is adding

objective=IdentityMCMultiOutputObjective(outcomes=[0, 1])
constraints=[
    lambda Z: Z[..., 2],
    lambda Z: Z[..., 3],
]

to qLogNoisyExpectedHypervolumeImprovement parameters enough for the constraints to be properly used in the optimization loop? I know optimize_acqf has some parameter related to non-linear constraints but I can't really understand how to use them and if they are necessary if the constraints are already specified in qLogNoisyExpectedHypervolumeImprovement .

Thanks!

[saitcakmak]

Hi @Frxljord. Based on the docstrings, I think you need to negate the constraints, since the convention is that the negative values imply feasibility:

            constraints: A list of callables, each mapping a Tensor of dimension
                `sample_shape x batch-shape x q x m` to a Tensor of dimension
                `sample_shape x batch-shape x q`, where negative values imply
                feasibility.

I know optimize_acqf has some parameter related to non-linear constraints but I can't really understand how to use them and if they are necessary if the constraints are already specified in qLogNoisyExpectedHypervolumeImprovement .

The constraints in optimize_acqf are used to restrict the search space, i.e., they're parameter constraints. For outcome constraints, you do not need to provide them to the optimizer.

[Frxljord]

Thank you for your answer. Unfortunately, I get worse results by negating the constraints, with points that are often infeasible. I understand this is expected because of the poor GP understanding of the constraint functions, but when evaluating the constraint GPs at the new_x (next candidates), it returns infeasible values, so it appears the GP "knows" the points are infeasible yet returns them anyways. Is this normal? Is this due to optimization options in optimize_acqf? This is the code I use to evaluate the GP on the new candidates and obtain the predicted thrust and stress values.

new_x = unnormalize(candidates.detach(), problem.bounds)
new_x_norm = normalize(new_x, problem.bounds)

# Get model predictions
with torch.no_grad():
    posterior = model.posterior(new_x_norm)
    mean_pred = posterior.mean
    std_pred = posterior.variance.sqrt()

predicted_thrust = mean_pred[0, 2].item() + problem.min_thrust_required
predicted_thrust_std = std_pred[0, 2].item()

material_strength = 1e6 * problem.material_tensile_strength / problem.material_safety_factor
predicted_max_stress = material_strength - mean_pred[0, 3].item()
predicted_max_stress_std = std_pred[0, 3].item()

[Balandat]

when evaluating the constraint GPs at the new_x (next candidates), it returns infeasible values

Infeasible by what definition? Based on the Gaussian posterior prediction, what's the probability of infeasibility?