def __init__(self, model: Model, mu, sigma, graph, bb_params):
self.model = model
self.pure_model = model.clone()
self.m, self.n = model.getVariable(
'I').getShape()[0], model.getVariable('Xi').getShape()[0]
self.mu, self.sigma = mu, sigma
self.graph = graph
self.roads = [(i, j) for i in range(self.m) for j in range(self.n)
if graph[i][j] == 1]
self.bb_params = bb_params
self.node_explored = 0
self.best_model = None
self.obj_ub = None
def __Select_Branching_Pos(self, solved_model: Model,
constr_z: Dict[int, int]) -> int:
"""
Ideally, branching position should come from a pricing problem
v1: randomly select one position from remaining branching position.
v2: argmax weighted average alpha_r (r: (i,j)\in roads) for each location i
:param node:
"""
from random import choice
r = len(self.roads)
if self.bb_params['select_branching_pos'] == 'v1':
# v1: randomly select one position from remaining branching position.
candidates = list(set(range(self.m)) - set(constr_z.keys()))
pos = choice(candidates)
if self.bb_params['select_branching_pos'] == 'v2':
# v2: argmax weighted average alpha_r (r: (i,j)\in roads) for each location i
sum_alpha_is = []
alpha = solved_model.getVariable('Alpha').level()[:r]
for i in set(range(self.m)) - set(constr_z.keys()):
sum_alpha_i = sum([
alpha[k] if x == i else 0
for k, (x, y) in enumerate(self.roads)
])
sum_alpha_is.append([i, sum_alpha_i])
pos = sorted(sum_alpha_is, key=lambda x: x[1], reverse=True)[0][0]
return pos
def __Update_Z_Constr(pure_model: Model, constr_z: Dict[int,
int]) -> Model:
Z = pure_model.getVariable('Z')
if len(constr_z) == 1:
for key, value in constr_z.items(): # only one iteration
pure_model.constraint('BB', Z.index(key),
Domain.equalsTo(value))
if len(constr_z) >= 2:
expression = Expr.vstack([Z.index(key) for key in constr_z.keys()])
values = [value for key, value in constr_z.items()]
pure_model.constraint('BB', expression, Domain.equalsTo(values))
return pure_model
