[Bug] About Nonlinear inequality constraint and batch_limit

[minsu77]

🐛 Bug

Hi, first of all, thank you for providing so much useful information in this community.

I am trying to use a nonlinear inequality constraint (parameter constraint) like the picture above. So I made a callable function that returns a negative number when inside an infeasible region.

Since there are two input parameters, "batch_initial_condition" is arbitrarily configured as [1, 2] shape tensor. (shape: [Num_restarts, Input dimension] )

And I also entered "batch_limit" as 1. But I get "call() missing 1 required positional argument: 'y'" error comes out.
There is no error when only the callable function is evaluated separately (e.g., NonlinCon(0.55, 1) -> return "-1")

How can i solve this error?

def initialize_model(train_X, train_Y):
    model = SingleTaskGP(train_X, train_Y, outcome_transform=Standardize(m=train_Y.shape[-1]))
    mll = ExactMarginalLogLikelihood(model.likelihood, model)
    return mll, model

BATCH_SIZE = 1 
NUM_RESTARTS = 1
RAW_SAMPLES = 1024
MC_SAMPLES = 512

class NonlinCon:
    def __call__(self, x, y):
        if x <= 3/4 and 2*x + y >=2:
            return -1
        elif x > 3/4 and y >= 1/2:
            return -1 #negative : infeasible
        else:
            return 1 #positive : feasible
        
NonlinCon = NonlinCon()

batch_init = torch.tensor([[[0.5, 0.5]]]) # [1, 1, 2] tensor
#[Num_restarts, q, input_dimension]

def optimize_acqf_and_get_observation(acq_func):
    candidates, _ = optimize_acqf(
        acq_function=acq_func,
        bounds=standard_bounds,
        q=1,
        num_restarts=NUM_RESTARTS,
        options={"batch_limit": 1, "maxiter": 200},
        raw_samples=RAW_SAMPLES,  # used for intialization heuristic
        nonlinear_inequality_constraints=[NonlinCon], # list of nonlinear constraints
        batch_initial_conditions=batch_init,
        sequential=True,
    )
    new_x = candidates.detach()
    return new_x

max_evals = 25
d = 2

standard_bounds = torch.zeros(2, d)
standard_bounds[1] = 1

mll, model = initialize_model(train_X, train_Y)
fit_gpytorch_model(mll, optimizer=fit_gpytorch_torch)
qmc_sampler = SobolQMCNormalSampler(num_samples=MC_SAMPLES)
qEI = qExpectedImprovement(
    model=model,
    best_f=train_Y.max(),
    sampler=qmc_sampler,
)
new_x = optimize_acqf_and_get_observation(qEI)

ValueError: __call__() missing 1 required positional argument: 'y'

[Balandat]

I'll try to answer this, but can you in the future please provide a full runnable repro as well as the full stack trace? That makes it a lot easier to figure out what's going on.

I think the issue in your case is the definition of the nonlinear constraint callable. Check out the docstring here for what this should be (a callable that expects a single tensor rather than two python scalars): https://github.com/pytorch/botorch/blob/main/botorch/optim/optimize.py#L454-L461

[minsu77]

Thank you very much !! :)

[madhavkrishnan94]

I'll try to answer this, but can you in the future please provide a full runnable repro as well as the full stack trace? That makes it a lot easier to figure out what's going on.

I think the issue in your case is the definition of the nonlinear constraint callable. Check out the docstring here for what this should be (a callable that expects a single tensor rather than two python scalars): https://github.com/pytorch/botorch/blob/main/botorch/optim/optimize.py#L454-L461

Hello @Balandat, thanks for highlighting this.

So, the original post here should have passed only a single tensor x (consisting of all input dimensions) as argument to the callable and used x[0] and x[1] instead of x and y to define the constraints. Is my understanding correct?

If not, can you point me to a correct illustration of the nonlinear inequality constraint?

Thanks.

[Balandat]

So, the original post here should have passed only a single tensor x (consisting of all input dimensions) as argument to the callable and used x[0] and x[1] instead of x and y to define the constraints. Is my understanding correct?

Correct, your constraint should be sth like nl_con(X: Tensor) -> Tensor. But you'll want to make sure that the constraint is not +-1 but that you formulate it in such a way that it is binding when it returns zero, infeasible when negative, and feasible if positive. That will make it much easier for the underlying numerical optimizer.

[madhavkrishnan94]

So, the original post here should have passed only a single tensor x (consisting of all input dimensions) as argument to the callable and used x[0] and x[1] instead of x and y to define the constraints. Is my understanding correct?

Correct, your constraint should be sth like nl_con(X: Tensor) -> Tensor. But you'll want to make sure that the constraint is not +-1 but that you formulate it in such a way that it is binding when it returns zero, infeasible when negative, and feasible if positive. That will make it much easier for the underlying numerical optimizer.

Thanks for your reply.

The docs also mention that batch_initial_conditions need to be specified. Some other places mention the need to define a ic_generator. Can you shed some light on which one to specify along with nonlinear constraints?

Also, if there's a link to a tutorial/code snippet somewhere that illustrates the successful illustration of using the nonlinear inequality constraints, please share it.

Thanks in advance!

[Balandat]

The docs also mention that batch_initial_conditions need to be specified. Some other places mention the need to define a ic_generator. Can you shed some light on which one to specify along with nonlinear constraints?

Either one. If you define batch_initial_conditions then the optimization will just use those as the starting points. If you don't specify batch_initial_conditions, then you have to specify an ic_generator, which essentially is a callable that will generate feasible initial conditions.

Here is a snippet that provides batch_initial_conditions: Scipy non-linear inequality constraints.ipynb.txt

[madhavkrishnan94]

The docs also mention that batch_initial_conditions need to be specified. Some other places mention the need to define a ic_generator. Can you shed some light on which one to specify along with nonlinear constraints?

Either one. If you define batch_initial_conditions then the optimization will just use those as the starting points. If you don't specify batch_initial_conditions, then you have to specify an ic_generator, which essentially is a callable that will generate feasible initial conditions.

Here is a snippet that provides batch_initial_conditions: Scipy non-linear inequality constraints.ipynb.txt

Thanks for your reply, @Balandat .

At this point, I would like to take a step back just to ensure I am asking the right questions to solve my problem. In my case, I am looking to ensure I do not generate candidates in the infeasible region that is marked by the red rectangle as shown in the figure below, where A and B are two inputs.

So, the larger question is whether nonlinear inequality constraints in the manner you've described above (define callable with 0,1,-1) is the only way to go? Or can I do it with a combination of two linear inequality constraints (namely A < 4 and B < 3)?

I hope I have described sufficiently. I would love to hear your thoughts on this.

[Balandat]

Or can I do it with a combination of two linear inequality constraints (namely A < 4 and B < 3)?

No, unfortunately you can't do this. The issue is one word: In your case you actually want an "or" rather than "and". While "and" means intersection of half spaces (which are convex and perfectly fine as a set of linear constraints), "or" means the union of half spaces, and those sets are generally not convex. The optimizer will consider "and" between multiple constraints, not "or". and so you'll need to pass that in as a single non-linear (and non-convex) constraint.