Applying nonlinear inequality constraints depending on categorical values

[mvincent-ethzBA]

Hi everyone, I'm kinda new and currently using Botorch for a university project. I've run into a problem I can't seem to fix on my own, and would like some help/clarification.

I have 1 categorical and 4 continuous input features, and want to apply to a continuous feature a constraint which is different depending on the value of the categorical feature. I've tried multiple different approaches, but everytime I run it I get the same error "ValueError: batch_initial_conditions must satisfy the non-linear inequality constraints". Every attempt I've made with a ic_generator that satisfies the constraint has also always eventually ended up with the same error. I'll paste the full code and traceback below, and I'd really be grateful for any help or tips you could send my way.

Here's the code (the constraint function is near the bottom):

# -*- coding: utf-8 -*-
"""
Created on Thu Oct 2 08:34:59 2025

@author: mvincent
"""
import torch
from botorch import fit_gpytorch_mll
from botorch.models.model_list_gp_regression import ModelListGP
from botorch.models.gp_regression_mixed import MixedSingleTaskGP
from gpytorch.mlls.exact_marginal_log_likelihood import ExactMarginalLogLikelihood
from botorch.utils.transforms import standardize
from botorch.utils.transforms import normalize
import time

# Begin time counting
start = time.time()

"""This here is the initialisation part, """
target       = 1 # 0 for Coefficient of Friction, 1 for Wear Resistance
num_restarts = 10 # currently low for testing purposes
q            = 1 
MC_SAMPLES   = 100 #currently low for testing purposes
bounds       = torch.tensor([[  5,   0,   5,   0],  
                             [150, 100, 200, 100]], dtype=torch.float)

# Define the training data: (5 inputs, 2 outputs)
inputFormCategorical  = torch.tensor([[0], #Categorical, should only take integer values 0, 1, 2, 3, 4
                                      [1],
                                      [2],
                                      [3],
                                      [4]])
inputDepth            = torch.tensor([[132], 
                                      [116],
                                      [ 58],
                                      [ 58],
                                      [ 60]])
inputContactarea      = torch.tensor([[58], 
                                      [74],
                                      [92],
                                      [92],
                                      [65]])
inputPeriod           = torch.tensor([[ 63], 
                                      [ 12],
                                      [160],
                                      [189],
                                      [ 99]])
inputOffsetHorizontal = torch.tensor([[75], 
                                      [ 3],
                                      [36],
                                      [36],
                                      [52]])

output_CoF     = torch.tensor([[104.0], # output - target (Coefficient of Friction) 
                               [114.3],
                               [116.0],
                               [116.0],
                               [ 88.3]])
output_WearRes = torch.tensor([[70.0],  # output - target (WearRes)
                               [38.0],
                               [78.0],
                               [78.0],
                               [80.0]])

# Construct input tensor for continuous features
input_continuous   = torch.cat((inputDepth, inputContactarea), 1) 
input_continuous   = torch.cat((input_continuous, inputPeriod), 1)
input_continuous   = torch.cat((input_continuous, inputOffsetHorizontal), 1) # n x (d_input - 1) tensor

# Normalize continuous inputs ONLY
input_continuous_norm = normalize(input_continuous, bounds)
input_continuous_norm = input_continuous_norm.double()
input_all_norm = torch.cat((inputFormCategorical.double(), input_continuous_norm), dim=1)

# Standardize outputs:
output_CoF_stand     = standardize(output_CoF)
output_WearRes_stand = standardize(output_WearRes)
output_CoF_stand     = output_CoF_stand.double()
output_WearRes_stand = output_WearRes_stand.double()

# Create and fit GPs using MixedSingleTaskGP for both continuous and categorical features, cat_dims=[0] defines which column has the categorical feature(s)
gp_CoF     = MixedSingleTaskGP(input_all_norm, output_CoF_stand,     cat_dims=[0])
gp_WearRes = MixedSingleTaskGP(input_all_norm, output_WearRes_stand, cat_dims=[0])

# Combine the models into a multi-output model using ModelListGP
model = ModelListGP(gp_CoF, gp_WearRes)

# Create Exact-MLL
mll_CoF     = ExactMarginalLogLikelihood(gp_CoF.likelihood,     gp_CoF)
mll_WearRes = ExactMarginalLogLikelihood(gp_WearRes.likelihood, gp_WearRes)

# Fit GPs
fit_gpytorch_mll(mll_CoF)
fit_gpytorch_mll(mll_WearRes)

# Define the objective to optimize
def objective(samples, X):
    return samples[..., target] # 0 for CoF, 1 for WearRes, defined at the beginning

from botorch.acquisition.objective import GenericMCObjective
from botorch.sampling.normal import SobolQMCNormalSampler
from botorch.acquisition import qLogExpectedImprovement
from botorch.optim import optimize_acqf_mixed

# Create a GenericMCObjective for the acquisition function
mc_objective = GenericMCObjective(objective)
qmc_sampler = SobolQMCNormalSampler(sample_shape=torch.Size([MC_SAMPLES]))

# Define the acquisition function (qLogExpectedImprovement) with the objective
qLogEI = qLogExpectedImprovement(
    model=model,  # Multi-output model
    best_f=output_WearRes_stand.max(),  # Best observed value for the first output, max if WearRes, min if CoF
    sampler=qmc_sampler,
    objective=mc_objective  
)

normalized_bounds = torch.tensor(
    [
        [0.0, 0.0, 0.0, 0.0, 0.0],  # Lower norm. bounds for the 4 continuous features + Categorical
        [4.0, 1.0, 1.0, 1.0, 1.0],  # Upper norm. bounds for the 4 continuous features + Categorical
    ], dtype=torch.double,
)

# Define the values of the fixed categoricals
FixedList = [ 
    {0: 0.0},
    {0: 1.0},
    {0: 2.0},
    {0: 3.0},
    {0: 4.0},
]

def constraint(X):
    category = X[..., 0].item()
    contactarea = X[..., 2]
    #print(category) # for debugging help
    thr = 1.0
    if category == 3:
        thr = 0.785
    return thr - contactarea #gives us an upper limit, since constraint feasible only if x >= 0

constraintsList = [(constraint, True)]

# Use optimize_acqf_mixed for mixed categoricals and continuous values
from botorch.optim.initializers import gen_batch_initial_conditions

candidate, acq_value = optimize_acqf_mixed(
    fixed_features_list=FixedList,
    acq_function=qLogEI,
    bounds=normalized_bounds, #check which is needed: bounds or normalized_bounds
    q=q,  # Number of candidate points to return
    num_restarts=num_restarts,  # Number of restarts for optimization
    raw_samples=MC_SAMPLES,  # Number of raw samples for optimization
    nonlinear_inequality_constraints=constraintsList,
    ic_generator=gen_batch_initial_conditions
)

# time only used for Info on how fast this whole thing is
torch.set_printoptions(profile='short', sci_mode=False)

# End time count
end = time.time()
time_taken = end - start

# extract acq_value as scalar
LogEI_value = acq_value.item()
EI_value = 2.71828 ** LogEI_value

# Print results to console
print(f"Elapsed Time (s): {time_taken}")
print(f"Optimal candidate: {candidate}")
#print(f"LogEI Acquisition Value: {LogEI_value}")
print(f"EI Acquisition Value: {EI_value}")

And here's the Traceback:

PS C:\Users\Startklar\Desktop\ETHZ\3rd Semester\Semesterarbeit> & C:/Users/Startklar/anaconda3/envs/SemesterThesis/python.exe "c:/Users/Startklar/Desktop/ETHZ/3rd Semester/Semesterarbeit/Python code/TestGithubHelp copy.py"
Traceback (most recent call last):
  File "c:\Users\Startklar\Desktop\ETHZ\3rd Semester\Semesterarbeit\Python code\TestGithubHelp copy.py", line 147, in <module>
    candidate, acq_value = optimize_acqf_mixed(
                           ~~~~~~~~~~~~~~~~~~~^
        fixed_features_list=FixedList,
        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    ...<6 lines>...
        ic_generator=gen_batch_initial_conditions
        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    )
    ^
  File "C:\Users\Startklar\anaconda3\envs\SemesterThesis\Lib\site-packages\botorch\optim\optimize.py", line 1145, in optimize_acqf_mixed
    candidates, acq_values = optimize_acqf(
                             ~~~~~~~~~~~~~^
        acq_function=acq_function,
        ^^^^^^^^^^^^^^^^^^^^^^^^^^
    ...<17 lines>...
        **ic_gen_kwargs,
        ^^^^^^^^^^^^^^^^
    )
    ^
  File "C:\Users\Startklar\anaconda3\envs\SemesterThesis\Lib\site-packages\botorch\optim\optimize.py", line 732, in optimize_acqf
    return _optimize_acqf(opt_inputs=opt_acqf_inputs)
  File "C:\Users\Startklar\anaconda3\envs\SemesterThesis\Lib\site-packages\botorch\optim\optimize.py", line 753, in _optimize_acqf
    return _optimize_acqf_batch(opt_inputs=opt_inputs)
  File "C:\Users\Startklar\anaconda3\envs\SemesterThesis\Lib\site-packages\botorch\optim\optimize.py", line 457, in _optimize_acqf_batch
    batch_candidates, batch_acq_values, ws = _optimize_batch_candidates()
                                             ~~~~~~~~~~~~~~~~~~~~~~~~~~^^
  File "C:\Users\Startklar\anaconda3\envs\SemesterThesis\Lib\site-packages\botorch\optim\optimize.py", line 434, in _optimize_batch_candidates
    ) = opt_inputs.gen_candidates(
        ~~~~~~~~~~~~~~~~~~~~~~~~~^
        batched_ics_,
        ^^^^^^^^^^^^^
    ...<6 lines>...
        **gen_kwargs,
        ^^^^^^^^^^^^^
    )
    ^
  File "C:\Users\Startklar\anaconda3\envs\SemesterThesis\Lib\site-packages\botorch\generation\gen.py", line 336, in gen_candidates_scipy
    constraints += make_scipy_nonlinear_inequality_constraints(
                   ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~^
        nonlinear_inequality_constraints=nl_ineq_constraints,
        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    ...<2 lines>...
        shapeX=candidates_.shape,
        ^^^^^^^^^^^^^^^^^^^^^^^^^
    )
    ^
  File "C:\Users\Startklar\anaconda3\envs\SemesterThesis\Lib\site-packages\botorch\optim\parameter_constraints.py", line 599, in make_scipy_nonlinear_inequality_constraints
    raise ValueError(
    ...<2 lines>...
    )
ValueError: `batch_initial_conditions` must satisfy the non-linear inequality constraints.

[esantorella]

Hi, there's a lot to look over here -- would you be able produce a more minimal reproducible example that comes as close as you can get to isolating the issue with a small number of lines of code?