Gurobi 问题 - 添加带有回调函数的用户剪切

Question

I am currently working on a MILP formulation that I want to solve using Gurobi with a branch-and-cut approach. My model is a variation of a classic Pickup and Delivery Problem with Time Windows (PDPTW), for which several classes of valid inequalities are defined. As the branch-and-bound solver runs, I want to add those inequalities (ie, I want to add cuts), if certain conditions in the current node are met. My issue is as follows:

My variables are defined as dictionaries, which makes it easy to use them when formulating constraints because I can easily use their original indexing. An example of how I define variables is provided below

tauOD = {}
# Start- End-Service time of trucks
for i in range(0,Nt):
    tauOD[i,0]=model.addVar(lb=0.0, ub=truckODTime[i][0],
                             vtype=GRB.CONTINUOUS,name='tauOD[%s,%s]'%(i,0))
    tauOD[i,1]=model.addVar(lb=0.0, ub=truckODTime[i][1],
                             vtype=GRB.CONTINUOUS,name='tauOD[%s,%s]'%(i,1))

Once my model is defined in terms of variables, constraints, and cost function, in a classic branch-and-bound problem I would simply use model.optimize() to start the process. In this case, I am using the command model.optimize(my_callback), where my_callback is the callback function I defined to add cuts. My issue is that the callback function, for some reasons, does not like model variables defined as dictionaries. The only workaround I found is as follows:

model._vars = model.getVars() #---> added this call right before the optimization starts
model.optimize(mycallback)

and then inside the callback I can now retrieve variables using their ordering, not their indices as follows:

def mycallback(model,where):
    if where == GRB.Callback.MIPNODE:
        status = model.cbGet(GRB.Callback.MIPNODE_STATUS)
        # If current node was solved to optimality, add cuts to strenghten
        # linear relaxation
        if status == GRB.OPTIMAL:
            this_Sol =  model.cbGetNodeRel(model._vars) # Get variables of current solution
            # Adding a cut
            model.cbCut(lhs=this_Sol[123]+this_Sol[125],sense=GRB.LESS_EQUAL,rhs=1) #---> Dummy cut just 
                                                                                    # for illustration 
                                                                                    # purposes

The aforementioned cut is just a dummy example to show that I can add cuts using the order variables are sequenced in my solution, and not their indexing. As example, I would like to be able to write a constraint inside my callback as

x[0,3,0] + x[0,5,0] <= 1

but the only thing I can do is to write

this_Sol[123] + this_Sol[125] <= 1 (assuming x[0,3,0] is the 124-th variable of my solution vector, and x[0,5,0] is the 126-th). Although knowing the order of variables is doable, because it depends on how I create them when setting up the model, it is a much more challenging process (and error-prone) rather than being able to use the indices, as I do when defining the original constraints of my model (see below for an example):

###################
### CONSTRAINTS ###
###################
# For each truck, one active connection from origin depot
for i in range(0,Nt):
    thisLHS = LinExpr()
    for j in range(0,sigma):
        thisLHS += x[0,j+1,i]
    thisLHS += x[0,2*sigma+1,i]
    model.addConstr(lhs=thisLHS, sense=GRB.EQUAL, rhs=1,
                            name='C1_'+str(i))

Did any of you experience a similar problem? A friend of mine told me that Gurobi, for some reasons, does not like variables defined as dictionaries inside a callback function, but I do not know how to circumvent this. Any help would be greatly appreciated. Thanks!

Alessandro

Answer 1

You should make a copy of the variables by their dicts.

To get the variable index, you also have to make a copy of the lists os indexes.

Try this:

model._I = model.I
model._J = model.J
model._K = model.K
model._x = model.x

You need theses indexes lists so you can loop each target variable x to verify some condition. As you would do writing a normal constraint for your model.

Then inside your callback you can make the index iterations:

def mycallback(model,where):
    if where == GRB.Callback.MIPNODE:

        x = model.cbGetSolution(model._x)

        for i in model._I:
            if sum([x[i,j,k] for j in model._J for k in model._K]) > 1:
                Add_the_cut()