def patternGenerationMIP(inp,
alphaI,
mainClass,
otherClass,
timeLimit=60,
solLimit=9999,
withPrinting=True,
display=4):
'''
Use (a modified version of) Bonates formulation to generate maximum-alpha-
patterns.
- mainClass : the set of points of the main class, i.e., the class point "alpha"
belongs to
- otherClass : the set of points of the opposite class.
The goal is to find a maximum-alpha-pattern, i.e., a patter that covers the max
number of points of the main class, while keeping the number of points of the other
class covered by the pattern below a given threshold value.
A new version here implements a relaxation of Bonates formulation. More
precisely, by relaxing variables z_b below, we no longer aim at maximize the
number of covered point (of the same class). What we are now doing here is
maximizing the percentage of literals of an observation covered by a pattern.
(We could call it PARTIAL COVERAGE as opposed to the FULL COVERAGE):
- partial coverage: z_b can now take fractional values, e.g., z_b = 0.9 would
imply that the point is covered up to a 90%. In other words, 90% of the literals
that define the pattern are also present in this observation. This might make
sense in the context of robust results, binarization, cut points, measurement
errors, etc.
- full coverage: when a point is fully covered by a pattern, w_b = 1 and, thus,
we count this point as covered (and we take it away from the set of points
for the next run of the pattern generation phase).
'''
nMain = len(mainClass)
nOther = len(otherClass)
nSupport = len(inp.support)
cpx = cplex.Cplex()
# define obj function direction
cpx.objective.set_sense(cpx.objective.sense.maximize)
# define variables
# variables z_b
cpx.variables.add(obj=[1] * nMain,
lb=[0] * nMain,
ub=[1] * nMain,
types=["C"] * nMain)
# variables s_i
cpx.variables.add(obj=[0] * nOther,
lb=[0] * nOther,
ub=[1] * nOther,
types=["C"] * nOther)
# variables y_i
cpx.variables.add(obj=[0] * nSupport,
lb=[0] * nSupport,
ub=[1] * nSupport,
types=["B"] * nSupport)
# create indexes (progressive values. Each var needs to have a unique identifier)
z_var = range(nMain)
s_var = range(nMain, nMain + nOther)
y_var = range(nMain + nOther, nMain + nOther + nSupport)
# count number of violations (fuzziness)
progr = 0
for i in otherClass:
index = [
y_var[k] for k in range(nSupport)
if (inp.Abin[alphaI][inp.support[k]] != inp.Abin[i][inp.support[k]]
)
]
value = [
1.0 for k in range(nSupport)
if (inp.Abin[alphaI][inp.support[k]] != inp.Abin[i][inp.support[k]]
)
]
index.append(s_var[progr])
value.append(1.0)
progr = progr + 1
fuzziness_constr = cplex.SparsePair(ind=index, val=value)
cpx.linear_constraints.add(lin_expr=[fuzziness_constr],
senses=["G"],
rhs=[1.0])
# max tollerance (for fuzzy patterns)
index = [s_var[i] for i in range(nOther)]
value = [1.0 for i in range(nOther)]
max_fuzziness = cplex.SparsePair(ind=index, val=value)
cpx.linear_constraints.add(lin_expr=[max_fuzziness],
senses=["L"],
rhs=[PHI * nOther])
count = 0
for i in mainClass:
# logical constraint 1 : set z_var to 0 if not covered
wb = sum(
[abs(inp.Abin[alphaI][k] - inp.Abin[i][k]) for k in inp.support])
index = [
y_var[k] for k in range(nSupport)
if inp.Abin[alphaI][inp.support[k]] != inp.Abin[i][inp.support[k]]
]
value = [
1.0 for k in range(nSupport)
if inp.Abin[alphaI][inp.support[k]] != inp.Abin[i][inp.support[k]]
]
index.append(z_var[count])
value.append(wb)
count += 1
logical1 = cplex.SparsePair(ind=index, val=value)
cpx.linear_constraints.add(lin_expr=[logical1], senses=["L"], rhs=[wb])
# logical constraint 2 : set z_var to 1 if covered
nEls = len(value)
value[nEls - 1] = 1.0
logical2 = cplex.SparsePair(ind=index, val=value)
cpx.linear_constraints.add(lin_expr=[logical2],
senses=["G"],
rhs=[1.0])
try:
cpx.parameters.mip.interval.set(100) # how often to print info
cpx.parameters.timelimit.set(timeLimit)
cpx.parameters.mip.limits.solutions.set(solLimit)
cpx.parameters.mip.display.set(display)
cpx.solve()
except CplexSolverError as e:
print("Exception raised during solve: " + e)
else:
# get solution
solution = cpx.solution
if withPrinting:
nCovered = solution.get_objective_value()
'''
print ("*** *** *** ub[{0:4d}] = {1:10.2f} with solution status = {2:20s}".\
format(0, nCovered, solution.status[solution.get_status()]))
'''
# get pattern
ySol = []
for i in range(nSupport):
if solution.get_values(
y_var[i]
) > 1.0 - cpx.parameters.mip.tolerances.integrality.get():
ySol.append(i)
pattern = [inp.support[k] for k in ySol]
signPattern = [inp.Abin[alphaI][inp.support[k]] for k in ySol]
# remove covered points of main class
zSol = []
for i in range(nMain):
if solution.get_values(
z_var[i]
) > 1.0 - cpx.parameters.mip.tolerances.integrality.get():
zSol.append(mainClass[i])
mainClass = [x for x in mainClass if x not in zSol]
return mainClass, pattern, signPattern, nCovered
def Separation(self):
# sep = 2
w = self.w
I = range(len(w))
Is = list(np.array_split(I, self.sep))
BigM = 100000
M = cplex.Cplex()
var = list(range(len(w)))
vals = np.zeros((len(w), len(var)))
np.fill_diagonal(vals, 1)
x_p = lambda p: 'x_%d' % (p)
x = [x_p(p) for p in range(len(var))]
M.variables.add(lb=[0] * len(x),
ub=[cplex.infinity] * len(x),
names=x,
obj=[1.] * len(x),
types=['C'] * len(x))
y_i = lambda i: 'y_%d' % (i)
y = [y_i(i) for i in I]
ys = [[y[i] for i in Is[j]] for j in range(self.sep)]
M.variables.add(
# lb=[0] * len(y),
# ub=[cplex.infinity] * len(y),
names=y,
obj=[BigM] * len(y),
types=['C'] * len(y))
M.linear_constraints.add(lin_expr=[
cplex.SparsePair(ind=x + [y[i]], val=list(vals[i]) + [1.0])
for i in I
],
senses=["G" for i in w],
rhs=[1. for i in w])
M.objective.set_sense(M.objective.sense.minimize)
M.set_log_stream(None)
M.set_error_stream(None)
M.set_warning_stream(None)
M.set_results_stream(None)
start = time.time()
mt = 0
st = 0
ite = 0
s2 = 0
solutions = []
iterations = []
penalty = 0.6
for twice in range(2):
for sec in range(self.sep):
print(ite)
criteria = True
y_fix = list(set(y) - set(list(ys[sec])))
I_fix = list(set(I) - set(list(Is[sec])))
# M.objective.set_linear(zip(y_fix, [BigM] * len(y_fix)))
M.variables.set_upper_bounds(zip(y_fix, np.zeros(len(y_fix))))
M.variables.set_lower_bounds(zip(y_fix, [0] * len(y_fix)))
while criteria:
ite += 1
if ite % 500 == 0:
penalty = penalty * 0.6
if penalty < 0.1:
penalty = 100
# print(penalty)
M.set_problem_type(M.problem_type.LP)
ct = time.time()
M.solve()
solutions.append(float(M.solution.get_objective_value()))
iterations.append(
float(
cplex._internal._procedural.getitcnt(
M._env._e, M._lp)))
mt += time.time() - ct
dual = list(M.solution.get_dual_values())
pi = dual
pi_ = [dual[i] * penalty for i in I_fix]
v = pi
W = self.W
pt = time.time()
#####################################################
# if ite >= 51 and ite<=162:
# S_obj, sol =binpacking.Knapsack2(v,w,W)
# s2 += time.time() - pt
# # else:
# aa = time.time()
# S_obj, sol = binpacking.KnapsackBnB(v, w, W)
# st += time.time() - pt
#####################################################
S_obj, sol = binpacking.KnapsackBnB(v, w, W)
if ite == 1000:
print(v, w, W)
print(time.time() - pt)
st += time.time() - pt
if S_obj - 0.00001 > 1.:
criteria = True
M.objective.set_linear(
list(
zip(
list(
map(lambda x: int(x + len(w)),
Is[sec])), pi_)))
# M.objective.set_linear(zip(y_fix, [BigM] * len(y_fix)))
newsub = sol
idx = M.variables.get_num()
M.variables.add(obj=[1.0])
M.linear_constraints.set_coefficients(
list(
zip(list(range(len(w))), [idx] * len(var),
newsub)))
var.append(idx)
# if ite >= 50:
# print('2')
else:
criteria = False
# M.write('1.lp')
if M.solution.get_values(ys[sec]) == [0] * len(ys[sec]):
print('dddd')
break
else:
continue
break
M.set_problem_type(M.problem_type.LP)
ct = time.time()
M.solve()
# M.write('sep.lp')
solutions.append(float(M.solution.get_objective_value()))
iterations.append(
float(cplex._internal._procedural.getitcnt(M._env._e, M._lp)))
print(s2)
mt += time.time() - ct
tt = time.time() - start
self.Separation_M = M
self.Separation_result = [
'Separation %s' % (self.sep), ite, mt, st, tt, mt / (st + mt),
solutions,
np.average(np.array(iterations))
]
def separate(self, ySol, y, LB):
cpx = self.cpx
T = self.T
numNodes = self.numNodes
inweights = self.inweights
outweights = self.outweights
combinatorialCutFound = False
# parameters
seed_set = map(lambda yi: yi[0],
filter(lambda yi: yi[1] > 1e-03, enumerate(ySol)))
S = len(seed_set)
senses_subprob = 'G' + 'L' * (T * numNodes) + 'E' * (numNodes + T * S)
rhsa = [LB]
rhsb = [0] * (T * numNodes)
rhsc = ySol
rhsd = [0] * (T * S)
rhs_subprob = rhsa + rhsb + rhsc + rhsd
# coefficients
coefficientsa = map(lambda i: (0, i, 1), xrange((T + 1) * numNodes))
coefficientsb = []
for t in xrange(1, T + 1):
for i in xrange(numNodes):
coefficientsb.extend(
map(
lambda j_wji:
(1 + (t - 1) * numNodes + i,
(t - 1) * numNodes + j_wji[0], -j_wji[1]),
inweights[i]))
coefficientsb.extend([(1 + (t - 1) * numNodes + i,
t * numNodes + i, 1)])
coefficientsc = map(lambda i: (1 + T * numNodes + i, i, 1),
xrange(numNodes))
coefficientsd = []
for t in xrange(1, T + 1):
coefficientsd.extend(
map(
lambda si_i:
(1 + (T + 1) * numNodes +
(t - 1) * S + si_i[0], t * numNodes + si_i[1], 1),
enumerate(seed_set)))
# all coefficients
coefficients = coefficientsa + coefficientsb + coefficientsc + coefficientsd
# Update constraints in the worker LP
cpx.linear_constraints.delete()
cpx.linear_constraints.add(senses=senses_subprob, rhs=rhs_subprob)
cpx.linear_constraints.set_coefficients(coefficients)
# Solve the worker LP
cpx.solve()
# A violated cut is available iff the subproblem is infeasible
print cpx.solution.get_status(), cpx.solution.get_status_string(
cpx.solution.get_status())
print 'seed set: ', seed_set
if cpx.solution.get_status() == 3:
print 'Generating combinatorial Benders cut'
self.cutLhs = cplex.SparsePair(ind=cutVarsList, val=cutCoefsList)
self.cutRhs = sum(su)
combinatorialCutFound = True
return combinatorialCutFound
def __init__(self,
numOfBoolVars,
numOfRealVars,
numOfConvexIFClauses,
maxNumberOfIterations=1000,
slackTolerance=1E-6,
counterExampleStrategy='IIS',
verbose='OFF',
profiling='true',
numberOfCores=2):
# TODO: check that numOfConvexIFConstraints > 0
# ------------ Initialize SAT Solvers ---------------------------------------
self.SATsolver = z3.Solver()
self.SATsolver.reset()
# ------------ Initialize Public Variables ------------------------------------
self.bVars = z3.BoolVector('b', numOfBoolVars)
self.rVars = ['x' + str(i) for i in range(0, numOfRealVars)]
self.convIFClauses = z3.BoolVector(
'bConv',
numOfConvexIFClauses) # Boolean abstraction of ConvIFClauses
self.counterExamples = list()
# ------------ Initialize Private Variables ------------------------------------
self.__convIFClauses = [
None
] * numOfConvexIFClauses # the actual ConvIFClauses
self.__slackIFVars = [
's' + str(i) + '_' for i in range(0, numOfConvexIFClauses)
] # list to hold "real-valued" slack variables
self.__slackIFVarsBound = [
't' + str(i) for i in range(0, numOfConvexIFClauses)
] # list to hold "real-valued" slack
# ------------ Initialize Solver Parameters ------------------------------------
self.maxNumberOfIterations = maxNumberOfIterations
self.slackTolerance = slackTolerance
self.counterExampleStrategy = counterExampleStrategy
self.verbose = verbose
self.profiling = profiling
self.numberOfCores = numberOfCores
self.slackRatio = 20
# ------------ Initialize Convex Solver ---------------------------------------
self.ConvSolver = cplex.Cplex()
self.ConvSolver.parameters.threads.set(numberOfCores)
self.ConvSolver.parameters.barrier.convergetol.set(self.slackTolerance)
self.ConvSolver.parameters.simplex.tolerances.optimality.set(
self.slackTolerance)
if self.verbose == 'OFF':
self.ConvSolver.set_results_stream(None) # set verbose = 0
self.ConvSolver.set_log_stream(None)
self.ConvSolver.objective.set_sense(
self.ConvSolver.objective.sense.minimize) # we minimize the slack
# CPLEX default LB is 0.0, we change it to -infinty. These variables do not appear in the optimization objective (only slack variables appear there, so we omit the "obj" parameter)
self.ConvSolver.variables.add(names=self.rVars,
ub=[cplex.infinity] * numOfRealVars,
lb=[-cplex.infinity] * numOfRealVars)
# add slack variabels
self.ConvSolver.variables.add(
names=self.__slackIFVars,
ub=[cplex.infinity] * numOfConvexIFClauses,
lb=[-cplex.infinity] * numOfConvexIFClauses)
if self.counterExampleStrategy == 'PREFIX' or self.counterExampleStrategy == 'SMC':
# our objective is to minimize the sum of absolute value of slack variabeles ,i.e., min |s_0| + |s_1| + ....
# the trick is to define new "bounding" variables t_0, t_1, .... and then minimze t_0 + t_1 + ...
# subject to |s_i| \le t_i which translates to s_i \le t_i and -s_i \le t_i
self.ConvSolver.variables.add(
obj=[1.0] * numOfConvexIFClauses,
names=self.__slackIFVarsBound,
ub=[cplex.infinity] * numOfConvexIFClauses,
lb=[-cplex.infinity] * numOfConvexIFClauses)
else:
# in IIS and trivial we do not minimize the sum of slack, it is just feasability.
# When using the IIS-based strategy, we would like to force infeasibility and leave the solver to relax the slack variables
# in order to discover conflicts. Thus, we put the upper bound equal to 0.0.
self.ConvSolver.variables.add(names=self.__slackIFVarsBound,
ub=[0.0] * numOfConvexIFClauses,
lb=[0.0] * numOfConvexIFClauses)
for slackIFcounter in range(0, numOfConvexIFClauses):
self.ConvSolver.linear_constraints.add(
lin_expr=[
cplex.SparsePair(ind=[
self.__slackIFVars[slackIFcounter],
self.__slackIFVarsBound[slackIFcounter]
],
val=[1.0, -1.0])
],
senses=['L'],
rhs=[0.0],
)
self.ConvSolver.linear_constraints.add(
lin_expr=[
cplex.SparsePair(ind=[
self.__slackIFVars[slackIFcounter],
self.__slackIFVarsBound[slackIFcounter]
],
val=[-1.0, -1.0])
],
senses=['L'],
rhs=[0.0],
)
def optimally_schedule_reduced_bias(show_probs, groups, wtc, otc,bc, nslots,seed, max_scenarios = 100000, delta_sim = 0):
# otc is transformed to otc / exp(shows)
# print(f'show_probs = {show_probs}')
# print(f'groups = {groups}')
# print(f'wtc = {wtc}')
# print(f'otc = {otc}')
# print(f'bc = {bc}')
print_steps = False
# First, find the scenarios
qs = [] # a list of sets of patients that show under a scenario
ps = [] # a list of probabilities
init = time.time()
distinct_groups = pd.Series(groups).unique()
ser = pd.Series(data=show_probs)
# otc /= ser.sum()
sorted_indices = list(ser.sort_values().index)
# Similar index (for each index i, the index of the other patient for constraint 4)
similar = {}
last_indx = -1
for iii in range(len(sorted_indices)):
i = sorted_indices[iii]
gr = groups[i]
# look for next patient in same group
j=-1
for jjj in range(iii+1,len(sorted_indices)):
if groups[sorted_indices[jjj]] == gr:
j = sorted_indices[jjj]
break
if j == -1: # i is the last one in its group
similar[i] = -1
continue
# check whether i is similar to j
if show_probs[j] - show_probs[i] <= delta_sim + 0.00000001 and groups[j] == groups[i]:
similar[i] = j
else:
similar[i] = -1
if print_steps:
print('Building scenarios')
totp = 0
for p,s in build_scenarios(show_probs, max_scenarios,seed):
qs.append(set()) # set of showing indices
ps.append(p)
totp+=p
for i in range(len(s)):
if s[i] == 1:
qs[-1].add(i)
#print(f'totp={totp}')
# if abs(totp-1) > 0.01:
# input('TOT P < 1!!!!!!')
S = len(qs) # number of scenarios
F = nslots # number of slots
N = len(show_probs) # number of patients
F_max = N
if print_steps:
print(f'Done in {time.time() - init}. Built {S} scenarios. Setting up problem...')
c = cplex.Cplex()
# if len(distinct_groups) > 2:
# input('MORE THAN 2 GROUPS!!! You should not use this model')
# variables
c.variables.add(names=[f'x{i}_{j}' for i in range(N) for j in range(F)],types=[c.variables.type.binary for i in range(N) for j in range(F)])
c.variables.add(names=[f'b{s}_{j}' for j in range(F_max) for s in range(S)],lb=[0 for j in range(F_max) for s in range(S)])
c.variables.add(names=[f'w{i}' for i in range(N)],lb=[0 for i in range(N)])
c.variables.add(names=[f'W_max' ], lb=[0] )
c.set_log_stream(None)
c.set_results_stream(None)
c.set_warning_stream(None)
c.parameters.timelimit.set(TIME_LIMIT_SECONDS)
# objective
if print_steps:
print(f'Setting up objective...')
c.objective.set_linear(f'W_max', bc)
for s in range(S):
tot_shows = len(qs[s]) #N^s
#print(f'Scenario {s} with probability {ps[s]} and tot_shows = {tot_shows}:')
#print(qs[s])
if tot_shows == 0:
continue
for j in range(F_max):
#print(f'scenario {s}, j={j}: adding b{s}_{j} * (ps_s={ps[s]}) * (wtc={wtc}) / (tot_shows={tot_shows})')
c.objective.set_linear(f'b{s}_{j}',ps[s] * wtc)
c.objective.set_linear(f'b{s}_{F-1}', ps[s] * (otc + wtc))
#print(f'scenario {s}: adding b{s}_{F-1} * (ps_s={ps[s]}) * (otc={otc})')
# constraint set (1)
if print_steps:
print(f'Setting up constraint set 1...')
for i in range(N):
c.linear_constraints.add(lin_expr=[cplex.SparsePair(
ind = [f'x{i}_{j}' for j in range(F)], val = [1.0 for j in range(F)])],
senses = ['E'],
rhs=[1],
names=[f'(1_{i})'])
# constraint set (2)
if print_steps:
print(f'Setting up constraint set 2...')
for s in range(S):
if print_steps and s % 1000 == 0:
print(f'Built constraints for {s} scenarios')
for j in range(0,F_max):
expr = []
if j < F:
expr = [f'x{i}_{j}' for i in qs[s]]
expr.append(f'b{s}_{j}')
if j >= 1:
expr.append(f'b{s}_{j-1}')
vals = []
if j <F:
vals = [-1.0 for i in qs[s]]
vals.append(1)
if j >=1 :
vals.append(-1)
c.linear_constraints.add(lin_expr=[cplex.SparsePair(expr,vals)],
senses=['G'],
rhs=[-1],
names=[f'(2_{s}_{j})'])
# constraint set (3)
if print_steps:
print(f'Setting up constraint set 3...')
# original constraint 3
if (N >= F):
for j in range(0, F):
c.linear_constraints.add(lin_expr=[cplex.SparsePair(
ind=[f'x{i}_{j}' for i in range(N)], val=[1.0 for i in range(N)])],
senses=['G'],
rhs=[1],
names=[f'(3_{j})'])
# constraint set (4)
if print_steps:
print(f'Setting up constraint set 4...')
for i1 in range(N):
i2 = similar[i1]
if i2 == -1:
continue
for j_prime in range(F-1):
expr = []
vals = []
# old and faster
expr = [f'x{i1}_{j}' for j in range(j_prime+1,F)]
# new and slower
#expr = [f'x{i1}_{j_prime}']
expr.extend([f'x{i2}_{j}' for j in range(0,j_prime+1)])
vals = [1 for i in range(len(expr))]
c.linear_constraints.add(lin_expr=[cplex.SparsePair(expr, vals)],
senses=['L'],
rhs=[1],
names=[f'(4_{i1}_{j_prime})'])
# constraint set (5e)
if print_steps:
print(f'Setting up constraint set 5e...')
for i in range(N):
scenarios_with_i = []
for s in range(S):
if i in qs[s]:
scenarios_with_i.append(s)
for j in range(F):
M = N - 1
expr = []
vals = []
expr = [f'w{i}', f'x{i}_{j}']
vals = [-1, M]
if j >= 1:
expr.extend ([f'b{s}_{j-1}' for s in scenarios_with_i])
vals.extend ([ps[s] for s in scenarios_with_i])
other_patients = []
for pp in range(N):
if pp != i:
other_patients.append(pp)
for k in other_patients:
coeff = 0
for s in scenarios_with_i:
if k in qs[s]:
coeff += ps[s] / 2
expr.append(f'x{k}_{j}')
vals.append(coeff)
c.linear_constraints.add(lin_expr=[cplex.SparsePair(expr, vals)],
senses=['L'],
rhs=[M],
names=[f'(5e_{i}_{j})'])
# FORCE x0_0: c.linear_constraints.add(lin_expr=[cplex.SparsePair(['x0_0'],[1])],senses=['G'],rhs=[1],names=['fake'])
# constraint set (5f)
# if print_steps:
# print(f'Setting up constraint set 5f...')
# for i in range(N):
# scenarios_with_i = []
# for s in range(S):
# if i in qs[s]:
# scenarios_with_i.append(s)
# for j in range(F):
# M = N - 1
# expr = []
# vals = []
# expr = [f'w{i}', f'x{i}_{j}']
# vals = [-1, -M]
# if j >= 1:
# expr.extend ([f'b{s}_{j-1}' for s in scenarios_with_i])
# vals.extend ([ps[s] for s in scenarios_with_i])
# other_patients = []
# for pp in range(N):
# if pp != i:
# other_patients.append(pp)
# for k in other_patients:
# coeff = 0
# for s in scenarios_with_i:
# if k in qs[s]:
# coeff += ps[s] / 2
# expr.append(f'x{k}_{j}')
# vals.append(coeff)
# c.linear_constraints.add(lin_expr=[cplex.SparsePair(expr, vals)],
# senses=['G'],
# rhs=[-M],
# names=[f'(5f_{i}_{j})'])
# constraint set (6)
if print_steps:
print(f'Setting up constraint set 6...')
exp_shows_in_general = pd.Series(show_probs).sum()
for y in distinct_groups:
exp_shows_in_group = 0
for i in range(N):
if groups[i] == y:
exp_shows_in_group += show_probs[i]
expr = [f'W_max']
vals = [exp_shows_in_group]
for i in range(N):
if groups[i] == y:
expr.append(f'w{i}')
vals.append(-exp_shows_in_general )
c.linear_constraints.add(lin_expr=[cplex.SparsePair(expr, vals)],
senses=['G'],
rhs=[0],
names=[f'(6_{y})'])
# c.write(filename='model.txt', filetype='lp')
if print_steps:
print(f'Solving...')
c.solve()
time_taken = time.time() - init
# c.solution.write('solution.txt')
#print(f'Value = {c.solution.get_objective_value()}')
solution = []
try:
waiting_times = c.solution.get_values([f'w{i}' for i in range(N)])
for i in range(N):
sols = c.solution.get_values([f'x{i}_{j}' for j in range(F)])
for j in range(F):
if sols[j] >= .9:
solution.append(j)
break
except:
import numpy as np
return np.nan, np.nan, np.nan, np.nan
return c.solution.get_objective_value(),c.solution.MIP.get_mip_relative_gap(), solution,waiting_times, time_taken
def create_fba_problem(sbml_file, biomass_reaction):
# load model
document = libsbml.readSBML(sbml_file)
sbml_model = document.getModel()
if sbml_model is None:
raise Exception('Unable to load model from provided file path.')
# load species and reactions
reactions = {
r[1].getId(): r[0]
for r in enumerate(sbml_model.getListOfReactions())
}
if biomass_reaction not in reactions:
raise Exception('Provided biomass reaction {} not in model {}.'.format(
biomass_reaction, sbml_model.getName()))
species = {
s[1].getId(): s[0]
for s in enumerate(sbml_model.getListOfSpecies())
}
reaction_ids = sorted(reactions, key=reactions.get, reverse=False)
species_ids = sorted(species, key=species.get, reverse=False)
N_reac = len(reactions)
N_spec = len(species)
# create necessary matrices and vectors:
# - stoichiometric matrix S
# - upper / lower bound vectors: UB / LB
# - right hand side vector: RHS
# - objective function vector
UB = np.zeros((N_reac, ))
LB = np.zeros((N_reac, ))
RHS = np.zeros((N_spec, ))
obj_fun_vec = np.zeros((N_reac, ))
obj_fun_vec[reactions[biomass_reaction]] = 1
rows = defaultdict(list)
values = defaultdict(list)
for r_idx, reaction in enumerate(sbml_model.getListOfReactions()):
plugin = reaction.getPlugin('fbc')
if plugin is None:
raise Exception('No fbc plugin defined for reaction {}. No way \
to determine reaction bounds.'.format(reaction.getName()))
reactants = {
r.getSpecies(): r.getStoichiometry()
for r in reaction.getListOfReactants()
}
products = {
p.getSpecies(): p.getStoichiometry()
for p in reaction.getListOfProducts()
}
reaction_species = list(set(reactants.keys() + products.keys()))
stoichiometries = []
for s in reaction_species:
stoich = products.get(s, 0) - reactants.get(s, 0)
stoichiometries.append(stoich)
for sp, stoich in zip(reaction_species, stoichiometries):
sp_idx = species[sp]
rows[sp_idx].append(r_idx)
values[sp_idx].append(stoich)
UB[r_idx] = sbml_model.getParameter(
plugin.getUpperFluxBound()).getValue()
LB[r_idx] = sbml_model.getParameter(
plugin.getLowerFluxBound()).getValue()
# create CPLEX objects
lp_problem = cplex.Cplex()
cplex_rows = []
for sp_idx in sorted(species.values()):
cplex_rows.append(cplex.SparsePair(rows[sp_idx], values[sp_idx]))
lp_problem.objective.set_sense(lp_problem.objective.sense.maximize)
lp_problem.variables.add(names=reaction_ids, obj=obj_fun_vec, ub=UB, lb=LB)
lp_problem.linear_constraints.add(names=species_ids,
rhs=RHS,
senses=['E'] * len(species),
lin_expr=cplex_rows)
lp_problem.set_results_stream(None)
return lp_problem
def _policy_improvement(self, convergence_mask):
converged_states = np.where(convergence_mask > 0.)[0]
c = cplex.Cplex()
c.set_log_stream(None)
c.set_error_stream(None)
c.set_warning_stream(None)
c.set_results_stream(None)
# Then update the policy.
for state in range(self.nb_states):
if np.sum(converged_states == state) > 0 and np.min(
self.unsafety_q[state, :]) <= 1. - self.confidence:
c.variables.delete()
c.linear_constraints.delete()
# Objective: Minimize -pi(*|x) * Q_L(x,*) for each x.
# Bounds: pi(a|x) >= 0 for all a (same as default setting)
obj = -(self.unsafety_q[state, :] -
np.min(self.unsafety_q[state, :]))
lb = [0.0] * self.nb_actions
indices = list(c.variables.add(obj=list(obj), lb=lb))
# Subject to: (1) sum(pi(*|x)) == 1, (2) pi(*|x) * Q_L(x,*) <= L_k(x) + epsilon
# (2) is inequality, (1) is equality constraint. ("L")
A = [cplex.SparsePair(indices[:], [1.] * self.nb_actions)]
b = [1.]
senses = ["E"]
# (2) only applies when the state is safe.
A.append(
cplex.SparsePair(indices[:],
list(self.lyapunov_q[state, :])))
b.append(
np.sum(
self.lyapunov_q[state, :] *
self.extended_policy[state, :], -1))
senses.append("L")
c.linear_constraints.add(lin_expr=A, senses=senses, rhs=b)
try:
c.solve()
_answer = np.array(c.solution.get_values())
if np.sum(_answer) == 1. and np.sum(
_answer > 1.) == 0 and np.sum(_answer < 0.) == 0:
self.extended_policy[state, :] = _answer
except CplexSolverError:
print(
"Error: unable to find feasible policy at [state ID: %d]."
% state)
else:
minimum_value = np.min(self.lyapunov_q[state, :])
optimal_actions = np.where(
self.lyapunov_q[state, :] == minimum_value)[0]
self.extended_policy[state, :] = 0.
self.extended_policy[
state, optimal_actions] = 1. / optimal_actions.size
self.extended_policy[self.nb_states +
state, :] = self.extended_policy[state, :]
return
def createConstraint(self, mind, mval, sense, rhs, name):
mConstraint = cplex.SparsePair(ind=mind, val=mval)
self.lp.linear_constraints.add(lin_expr=[mConstraint],
senses=[sense], rhs=[rhs],
names=[name])
def buildmodel(prob):
prob.objective.set_sense(prob.objective.sense.maximize)
colcnt = NUMVARS * NUMMONTHS * NUMPRODUCTS
obj = [0] * colcnt
lb = [0] * colcnt
ub = [0] * colcnt
ct = [0] * colcnt
rmatind = [0] * colcnt
rmatval = [0] * colcnt
ic_dict = {}
for m in range(NUMMONTHS):
for p in range(NUMPRODUCTS):
obj[varindex(m, p, BUY)] = -cost[m * NUMPRODUCTS + p]
lb[varindex(m, p, BUY)] = 0.0
ub[varindex(m, p, BUY)] = cplex.infinity
ct[varindex(m, p, BUY)] = "C"
obj[varindex(m, p, USE)] = 0.0
lb[varindex(m, p, USE)] = 20.0
ub[varindex(m, p, USE)] = cplex.infinity
ct[varindex(m, p, USE)] = "S"
obj[varindex(m, p, STORE)] = -5.0
lb[varindex(m, p, STORE)] = 0.0
ub[varindex(m, p, STORE)] = 1000.0
ct[varindex(m, p, STORE)] = "C"
if m == NUMMONTHS - 1:
lb[varindex(m, p, STORE)] = 500.0
ub[varindex(m, p, STORE)] = 500.0
obj[varindex(m, p, IS_USED)] = 0.0
lb[varindex(m, p, IS_USED)] = 0.0
ub[varindex(m, p, IS_USED)] = 1.0
ct[varindex(m, p, IS_USED)] = 'B'
prob.variables.add(obj=obj, lb=lb, ub=ub, types="".join(ct))
for m in range(NUMMONTHS):
for p in range(NUMPRODUCTS):
ic_dict["lin_expr"] = cplex.SparsePair(ind=[varindex(m, p, USE)],
val=[1.0])
ic_dict["rhs"] = 0.0
ic_dict["sense"] = "L"
ic_dict["indvar"] = varindex(m, p, IS_USED)
ic_dict["complemented"] = 1
prob.indicator_constraints.add(**ic_dict)
prob.linear_constraints.add(
lin_expr=[[[varindex(m, VEGOIL1, USE),
varindex(m, VEGOIL2, USE)], [1.0, 1.0]]],
senses="L",
rhs=[200.0])
prob.linear_constraints.add(lin_expr=[[[
varindex(m, OIL1, USE),
varindex(m, OIL2, USE),
varindex(m, OIL3, USE)
], [1.0, 1.0, 1.0]]],
senses="L",
rhs=[250.0])
prob.variables.add(obj=[150.0], types=[prob.variables.type.continuous])
last_column = prob.variables.get_num() - 1
for p in range(NUMPRODUCTS):
rmatind[p] = varindex(m, p, USE)
rmatval[p] = 1.0
rmatind[NUMPRODUCTS] = last_column
rmatval[NUMPRODUCTS] = -1.0
rm = [[rmatind[:NUMPRODUCTS + 1], rmatval[:NUMPRODUCTS + 1]]]
prob.linear_constraints.add(lin_expr=rm, senses="E", rhs=[0.0])
for p in range(NUMPRODUCTS):
rmatind[p] = varindex(m, p, USE)
rmatval[p] = hardness[p]
rmatind[NUMPRODUCTS] = last_column
rmatval[NUMPRODUCTS] = -3.0
prob.linear_constraints.add(
lin_expr=[[rmatind[:NUMPRODUCTS + 1], rmatval[:NUMPRODUCTS + 1]]],
senses="G",
rhs=[0.0])
rmatval[NUMPRODUCTS] = -6.0
prob.linear_constraints.add(
lin_expr=[[rmatind[:NUMPRODUCTS + 1], rmatval[:NUMPRODUCTS + 1]]],
senses="L",
rhs=[0.0])
for p in range(NUMPRODUCTS):
rmatind[p] = varindex(m, p, IS_USED)
rmatval[p] = 1.0
prob.linear_constraints.add(
lin_expr=[[rmatind[:NUMPRODUCTS], rmatval[:NUMPRODUCTS]]],
senses="L",
rhs=[3.0])
ic_dict["indvar"] = varindex(m, VEGOIL1, IS_USED)
ic_dict["rhs"] = 20.0
ic_dict["sense"] = "G"
ic_dict["complemented"] = 0
ic_dict["lin_expr"] = cplex.SparsePair(ind=[varindex(m, OIL3, USE)],
val=[1.0])
prob.indicator_constraints.add(**ic_dict)
ic_dict["indvar"] = varindex(m, VEGOIL2, IS_USED)
prob.indicator_constraints.add(**ic_dict)
for p in range(NUMPRODUCTS):
ind = []
val = []
if m != 0:
ind.append(varindex(m - 1, p, STORE))
val.append(1.0)
ind.append(varindex(m, p, BUY))
val.append(1.0)
ind.append(varindex(m, p, USE))
val.append(-1.0)
ind.append(varindex(m, p, STORE))
val.append(-1.0)
rhs = [0.0]
else:
ind.append(varindex(m, p, BUY))
val.append(1.0)
ind.append(varindex(m, p, USE))
val.append(-1.0)
ind.append(varindex(m, p, STORE))
val.append(-1.0)
rhs = [-500.0]
prob.linear_constraints.add(lin_expr=[[ind, val]],
senses="E",
rhs=rhs)
coef.append(1)
var.append("d_" + str(t) + "_" + str(N_v))
coef.append(-1 * native_feature_vector[i * 20 + j])
for k in range(0, N_ab):
for u in range(0, M):
#print "inside ab variables loop"
matrix = weights[((N_ab * 20 + N_v * 20) +
N_v * 20 * 20 * k +
20 * 20 * i):((N_ab * 20 + N_v * 20) +
N_v * 20 * 20 * k +
20 * 20 * (i + 1))]
Q_ki = numpy.reshape(matrix, (20, 20))
var.append("a_" + str(k) + "_" + str(u))
coef.append(-1 * Q_ki[u][j])
prob.linear_constraints.add(
lin_expr=[cplex.SparsePair(ind=var, val=coef)],
senses=["G"],
rhs=[right_hand_side])
for k in range(0, N_ab):
var = []
coef = []
for u in range(0, M):
var.append("a_" + str(k) + "_" + str(u))
coef.append(1)
prob.linear_constraints.add(lin_expr=[cplex.SparsePair(ind=var, val=coef)],
senses=["E"],
rhs=[1])
try:
prob.write("bilevel_%d_%d_%d.lp" % (alpha, sample, train_size))
def main(sysInfo):
start_time = time.clock()
setS = []
#start from j = 2
for j in range(2, 2): #sysInfo.nComponents >=2;
setSj = []
for i in itertools.combinations(list(range(sysInfo.nComponents)), j):
setSj.append(list(i))
setS.append(setSj)
coeA = []
#1 * nComponents
coeB = []
#1 * nComponents
coeCurrentToFail = []
coeNewToFail = []
for i in range(sysInfo.nComponents):
tmp = sysInfo.comInfoAll[i].currentToFail
coeCurrentToFail.append(tmp)
coeB.append(1 - tmp)
tmp1 = sysInfo.comInfoAll[i].newToFail
coeNewToFail.append(tmp1)
coeA.append(tmp - tmp1)
#get coefficient of X
coeX = []
for i in range(sysInfo.nComponents):
tmpi = (coeNewToFail[i] - coeCurrentToFail[i])\
*sysInfo.comInfoAll[i].cCM
tmpr = 1
for r in range(sysInfo.nComponents):
if r != i:
tmpr = tmpr * coeB[r]
else:
tmpr = tmpr * coeA[r]
tmpi = tmpi - tmpr * sysInfo.cS + sysInfo.comInfoAll[i].cPM
coeX.append(tmpi)
#get coefficient of u
coeU = []
if len(setS) > 0:
for j in range(len(setS)):
setSj = setS[j]
tmpj = []
for k in range(len(setSj)):
setSjk = setSj[k]
tmpk = 1
for i in range(sysInfo.nComponents):
if i in setSjk:
tmpk = tmpk * coeA[i]
else:
tmpk = tmpk * coeB[i]
tmpj.append(-tmpk * sysInfo.cS)
coeU.append(tmpj)
#constant term
consTerm = 0
tmp1 = 1
tmp2 = 0
for i in range(sysInfo.nComponents):
tmp1 = tmp1 * coeB[i]
tmp2 = coeCurrentToFail[i] * sysInfo.comInfoAll[i].cCM + tmp2
consTerm = tmp2 + sysInfo.cS - tmp1 * sysInfo.cS
#init cplex
cpx = cplex.Cplex()
cpx.objective.set_sense(cpx.objective.sense.minimize)
cpx.set_log_stream(None)
cpx.set_error_stream(None)
cpx.set_warning_stream(None)
cpx.set_results_stream(None)
#decision variables:
#x
varNameX = []
varX = []
for i in range(sysInfo.nComponents):
varNameX.append("x" + str(i))
varX.append(cpx.variables.get_num())
cpx.variables.add(obj=[coeX[i]],
lb=[0.0],
ub=[1.0],
types=["B"],
names=[varNameX[i]])
#y
varNameY = []
varY = []
for i in range(sysInfo.nComponents):
varNameY.append("y" + str(i))
varY.append(cpx.variables.get_num())
cpx.variables.add(
obj=[sysInfo.comInfoAll[i].cCM - sysInfo.comInfoAll[i].cPM],
lb=[0.0],
ub=[1.0],
types=["B"],
names=[varNameY[i]])
#z
varNameZ = "z"
varZ = [cpx.variables.get_num()]
cpx.variables.add(obj=[sysInfo.cS],
lb=[0.0],
ub=[1.0],
types=["B"],
names=[varNameZ])
#u
varNameU = []
varU = []
for j in range(len(coeU)):
for k in range(len(coeU[j])):
varNameU.append("u" + str(j) + str(k))
varU.append(cpx.variables.get_num())
cpx.variables.add(obj=[coeU[j][k]],
lb=[0.0],
ub=[1.0],
types=["B"],
names=[varNameU[-1]])
#constraints:
#1
for i in range(sysInfo.nComponents):
cpx.linear_constraints.add(
lin_expr=[cplex.SparsePair([varNameX[i], varNameZ], [1, -1])],
senses=["L"],
range_values=[0.0],
rhs=[0])
#2
for i in range(sysInfo.nComponents):
comIFrom = sysInfo.comInfoAll[i].initState
cpx.linear_constraints.add(
lin_expr=[cplex.SparsePair([varNameY[i]], [-comIFrom])],
senses=["L"],
range_values=[0.0],
rhs=[sysInfo.comInfoAll[i].nStates - 2 - comIFrom])
cpx.linear_constraints.add(
lin_expr=[cplex.SparsePair([varNameY[i], varNameX[i]], [1, -1])],
senses=["L"],
range_values=[0.0],
rhs=[0.0])
#new constraints: for u
idxTmp = -1
for j in range(len(setS)):
for k in range(len(setS[j])):
idxTmp += 1
nameVec = []
coeVec = []
for i in setS[j][k]:
nameVec.append(varNameX[i])
coeVec.append(1)
cpx.linear_constraints.add(lin_expr=[
cplex.SparsePair([varNameU[idxTmp], varNameX[i]], [1, -1])
],
senses=["L"],
range_values=[0.0],
rhs=[0.0])
nameVec.append(varNameU[idxTmp])
coeVec.append(-1)
cpx.linear_constraints.add(
lin_expr=[cplex.SparsePair(nameVec, coeVec)],
senses=["L"],
range_values=[0.0],
rhs=[len(setS[j][k]) - 1])
# j+2-1
end_time = time.clock()
time1 = end_time - start_time
start_time = time.clock()
cpx.solve()
solution = cpx.solution
solutionAll = solution.get_values()
#get X
minTmp = varX[0]
maxTmp = varX[-1] + 1
solutionXStage = solutionAll[minTmp:maxTmp]
#get Y
minTmp = varY[0]
maxTmp = varY[-1] + 1
solutionYStage = solutionAll[minTmp:maxTmp]
#get Z
minTmp = varZ[0]
maxTmp = varZ[-1] + 1
solutionZStage = solutionAll[minTmp:maxTmp]
#get u
# minTmp = varU[0];
# maxTmp = varU[-1] + 1;
#solutionUStage = solutionAll[minTmp:maxTmp];
objValue = solution.get_objective_value() + consTerm
end_time = time.clock()
sysInfo.time = end_time - start_time + time1
sysInfo.objValue = objValue
#print (solutionXStage);
#print (solutionYStage);
#print (solutionZStage);
#print (solutionUStage);
#print (objValue);
#print (time1,sysInfo.time);
N1 = []
N0 = []
for i in range(sysInfo.nComponents):
if solutionXStage[i] == 0:
N0.append(i)
else:
N1.append(i)
sysInfo.N0 = N0
sysInfo.N1 = N1
def heurestic(param):
# Parameters
N = param.N
P = param.P
L = sef.L
K = param.K
H = param.H
ql = param.ql
qk = param.qk
rk = param.rk
sk = param.sk
rh = param.rh
sh = param.sh
V = param.V
S = param.S
W = param.W
A = param.A
Com = param.Com
B = param.B
h = param.distance_matrix_PN
a = param.distance_matrix_SN
demand = param.demand
m = param.m
g = param.g
f = param.f
Btc = param.Btc
Ch = param.Ch
Pa = param.Pa
subtrees = param.subtrees
uprime = param.uprime
lprime = param.lprime
# Initiating variables
xijkt = [[[[0 for x in range(P)] for x in range(K * H)] for x in V]
for x in V]
zijktc = [[[[[0 for x in Com] for x in range(P)] for x in range(K * H)]
for x in V] for x in V]
ditc = [[[0 for x in Com] for x in range(P)] for x in V]
diktc = [[[[0 for x in Com] for x in range(P)] for x in range(K * H)]
for x in V]
rikt = [[[0 for x in range(P)] for x in range(K * H)] for x in V]
# Approx Algorithm
# The following code solves the delivery model i.e. delivery problems for secondary vehicles and finds the approximate values of the
# delivery variable at the optimal and finds the optimal primary objective.
for t in range(P):
if t == 0:
total_delivery = min(
K * H * qk, L * ql,
sum([m[i][t][c] for i in range(V[1], len(V)) for c in Com]))
else:
total_delivery = min(
K * H * qk, L * ql,
sum([m[i][t][c] for i in range(V[1], len(V)) for c in Com],
(sum([Btc[t][c] for c in Com]) - sum([
ditc[i][t - 1][c] for i in range(V[1], len(V))
for c in Com
])) / N))
mean_unsatisfied = (
sum([m[i][t][c] for i in range(V[1], len(V))
for c in Com]) - total_delivery) / float(N)
Least_int = math.ceil(mean_unsatisfied)
Greatest_int = math.floor(mean_unsatisfied)
Ubound = uprime * mean_unsatisfied
Lbound = lprime * mean_unsatisfied
if Least_int > Ubound or Greatest_int < Lbound:
print "change uprime and lprime, original model infeasible"
for i in range(V[1], len(V)):
for c in Com:
ditc[i][t][c] = m[i][t][c] - Least_int
else:
for i in range(V[1], len(V)):
for c in Com:
ditc[i][t][c] = m[i][t][c] - Least_int
leftover = total_delivery - sum(
[ditc[i][t][c] for i in range(V[1], len(V)) for c in Com])
vehicles_upto_number = [0 for x in V]
vehicles_for_number = [0 for x in V]
demand_upto = [0 for x in V]
demand_for = [0 for x in V]
dedicated_vehicles = [0 for x in V]
sharable_vehicles = [0 for x in V]
sharing_potential = [0 for x in V]
demand_sharing_potential_up = [0 for x in V]
demand_sharing_potential_down = [0 for x in V]
unshared_demand_up = [0 for x in V]
vehicles_upto_number.append(0)
vehicles_for_number.append(0)
for i in range(len(subtrees)):
if subtrees[i] != None:
dem1 = 0
dem2 = 0
for c in Com:
dem2 = dem2 + ditc[i][t][c]
for j in range(len(subtrees[i])):
for c in Com:
dem1 = dem1 + ditc[subtrees[i][j]][t][c]
demand_upto[i] = dem1 + dem2
demand_for[i] = dem2
vehicles_upto_number[i] = math.ceil((dem1 + dem2) / qk)
vehicles_for_number[i] = math.ceil(dem2 / qk)
dedicated_vehicles[i] = math.floor(dem2 + dem1 / qk)
sharable_vehicles[
i] = vehicles_upto_number[i] - dedicated_vehicles[i]
sharing_potential[
i] = vehicles_for_number[i] - dedicated_vehicles[i]
demand_sharing_potential_down[i] = dem2 - (math.floor(
dem2 / qk)) * qk
demand_sharing_potential_up[i] = dem2 + dem1 - (
math.floor(dem2 + dem1 / qk)) * qk
unshared_demand_up[i] = (math.floor((dem2 + dem1) / qk)) * qk
else:
if i != 0:
dem2 = 0
for c in Com:
dem2 = dem2 + ditc[i][t][c]
demand_upto[i] = dem1 + dem2
demand_for[i] = dem2
vehicles_upto_number[i] = math.ceil(dem2 / qk)
vehicles_for_number[i] = math.ceil(dem2 / qk)
dedicated_vehicles[i] = math.floor(dem2 / qk)
sharable_vehicles[
i] = vehicles_upto_number[i] - dedicated_vehicles[i]
sharing_potential[
i] = vehicles_for_number[i] - dedicated_vehicles[i]
demand_sharing_potential_up[i] = dem2 - (math.floor(
dem2 / qk)) * qk
demand_sharing_potential_down[i] = dem2 - (math.floor(
dem2 / qk)) * qk
unshared_demand_up[i] = (math.floor(dem2 / qk)) * qk
node_taken = [0 for j in V]
i = 1
while leftover > 0 and sum(node_taken) < N:
i = 1
while i < len(V) and leftover > 0:
c = random.choice(Com)
if math.floor((demand_upto[i] + 1) / float(qk)) == math.floor(
(demand_upto[i]) /
float(qk)) and ditc[i][t][c] < m[i][t][c]:
ditc[i][t][c] = ditc[i][t][c] + 1
leftover = leftover - 1
i = i + 1
else:
node_taken[i] == 1
i = i + 1
distance_from_depot = [0 for x in V]
for i in V:
if i == 0:
distance_from_depot[i] = 0
elif Pa[i] == None:
distance_from_depot[i] = 0
else:
distance_from_depot[i] = distance_matrix_tree[
Pa[i]][i] + distance_from_depot[Pa[i]]
sorted_distance = sorted(distance_from_depot)
sorted_node = []
for i in sorted_distance:
if i != 0:
j = 0
while j < len(distance_from_depot):
if distance_from_depot[j] == i and sorted_node.count(
j) == 0:
sorted_node.append(j)
j = len(distance_from_depot)
else:
j = j + 1
i = 1
while leftover != 0:
c = random.choice(Com)
if ditc[i][t][c] < m[i][t][c]:
ditc[sorted_node[i]][t][c] = ditc[sorted_node[i]][t][c] + 1
leftover = leftover - 1
if i == len(sorted_node):
i = 1
else:
i = i + 1
for i in range(len(subtrees)):
if subtrees[i] != None:
dem1 = 0
dem2 = 0
for c in Com:
dem2 = dem2 + ditc[i][t][c]
for j in range(len(subtrees[i])):
for c in Com:
dem1 = dem1 + ditc[subtrees[i][j]][t][c]
demand_upto[i] = dem1 + dem2
demand_for[i] = dem2
vehicles_upto_number[i] = math.ceil((dem1 + dem2) / qk)
vehicles_for_number[i] = math.ceil(dem2 / qk)
dedicated_vehicles[i] = math.floor(dem2 + dem1 / qk)
sharable_vehicles[
i] = vehicles_upto_number[i] - dedicated_vehicles[i]
sharing_potential[
i] = vehicles_for_number[i] - dedicated_vehicles[i]
demand_sharing_potential_down[i] = dem2 - (math.floor(
dem2 / qk)) * qk
demand_sharing_potential_up[i] = dem2 + dem1 - (
math.floor(dem2 + dem1 / qk)) * qk
unshared_demand_up[i] = (math.floor((dem2 + dem1) / qk)) * qk
else:
if i != 0:
dem2 = 0
for c in Com:
dem2 = dem2 + ditc[i][t][c]
vehicles_upto_number[i] = math.ceil(dem2 / qk)
vehicles_for_number[i] = math.ceil(dem2 / qk)
dedicated_vehicles[i] = math.floor(dem2 / qk)
sharable_vehicles[
i] = vehicles_upto_number[i] - dedicated_vehicles[i]
sharing_potential[
i] = vehicles_for_number[i] - dedicated_vehicles[i]
demand_sharing_potential_up[i] = dem2 - (math.floor(
dem2 / qk)) * qk
demand_sharing_potential_down[i] = dem2 - (math.floor(
dem2 / qk)) * qk
unshared_demand_up[i] = (math.floor(dem2 / qk)) * qk
# The folllowing code solves the secondary vehicle routing model
# It gives p=aprroximate solution for xijkt, zijktc, diiktc (these values are optimal for the given ditc. However since ditc is
# appriximate so these values are not gloabally optimal for the model)
pos_of_vehicle = [0 for x in range(K * H)]
vehicle_capacity_left = [qk for x in range(K * H)]
weight_carried = [0 for x in range(K * H)]
vehicles_at = [[] for x in V]
vehicles_for = [[] for x in V]
vehicle_path = [[] for x in range(K * H)]
demand_left = [[0 for x in Com] for x in V]
k = 0
for i in xrange(len(Ch) - 1, 0, -1):
if i != 0:
if Ch[i] != None:
for x in Ch[i]:
for c in Com:
demand_left[x][c] = ditc[x][t][c]
a = 0
while demand_left[x][c] > 0 and a < len(
vehicles_at[x]):
for c in Com:
diktc[x][vehicles_at[x][a]][t][c] = min(
demand_left[x][c],
vehicle_capacity_left[vehicles_at[x][a]])
weight_carried[
vehicles_at[x][a]] = weight_carried[
vehicles_at[x][a]] + diktc[x][
vehicles_at[x][a]][t][c]
vehicle_capacity_left[
vehicles_at[x][a]] = vehicle_capacity_left[
vehicles_at[x][a]] - diktc[x][
vehicles_at[x][a]][t][
c] # no need for this
demand_left[x][c] = demand_left[x][c] - diktc[
x][vehicles_at[x][a]][t][c]
a = a + 1
while sum([demand_left[x][c] for c in Com]) > 0:
(vehicles_at[x]).append(k)
for c in Com:
diktc[x][k][t][c] = min(
demand_left[x][c],
vehicle_capacity_left[k])
weight_carried[
k] = weight_carried[k] + diktc[x][k][t][c]
vehicle_capacity_left[
k] = vehicle_capacity_left[k] - diktc[x][
k][t][c] # no need for this
demand_left[x][
c] = demand_left[x][c] - diktc[x][k][t][c]
k = k + 1
b = 0
d = b + 1
while len(vehicles_at[x]
) != vehicles_upto_number[x] and b < len(
vehicles_at[x]):
if d < len(vehicles_at[x]):
if weight_carried[vehicles_at[x]
[b]] + weight_carried[
vehicles_at[x][c]] < qk:
redundant = vehicles_at[x][d]
shared = vehicles_at[x][b]
for c in Com:
diktc[x][shared][t][
c] = diktc[x][shared][t][
c] + diktc[x][redundant][t][c]
weight_carried[shared] = weight_carried[
shared] + weight_carried[redundant]
vehicle_capacity_left[
shared] = qk - weight_carried[
shared]
diktc[x][redundant][t][c] = 0
weight_carried[redundant] = 0
vehicle_capacity_left[redundant] = qk
for j in range(
len(vehicle_path[redundant]) - 1):
xijkt[vehicle_path[redundant][j]][
vehicle_path[redundant][
j + 1]][shared][t] = 1
xijkt[vehicle_path[redundant][
j + 1]][vehicle_path[redundant]
[j]][shared][t] = 1
xijkt[vehicle_path[redundant][j]][
vehicle_path[redundant][
j + 1]][redundant][t] = 0
xijkt[vehicle_path[redundant][
j + 1]][vehicle_path[redundant]
[j]][redundant][t] = 0
zijktc[vehicle_path[redundant][j]][
vehicle_path[redundant]
[j + 1]][shared][t][c] = zijktc[
vehicle_path[redundant]
[j]][vehicle_path[redundant][
j + 1]][redundant][t][c]
zijktc[vehicle_path[redundant][j]][
vehicle_path[redundant][
j + 1]][redundant][t][c] = 0
if j != 0:
diktc[j][shared][t][c] = diktc[j][
redundant][t][c]
diktc[j][redundant][t][c] = 0
b = 0
d = b + 1
else:
d = d + 1
else:
b = b + 1
d = b + 1
for y in range(len(vehicles_at[x])):
xijkt[x][i][vehicles_at[x][y]][t] = 1
xijkt[i][x][vehicles_at[x][y]][t] = 1
vehicles_at[i].append(vehicles_at[x][y])
for c in Com:
if len(vehicle_path[vehicles_at[x][y]]) == 0:
zijktc[i][x][vehicles_at[x][y]][t][
c] = diktc[x][vehicles_at[x][y]][t][c]
else:
zijktc[i][x][
vehicles_at[x][y]][t][c] = diktc[x][
vehicles_at[x]
[y]][t][c] + zijktc[x][
vehicle_path[vehicles_at[x][y]]
[0]][vehicles_at[x][y]][t][c]
vehicle_path[vehicles_at[x][y]].insert(0, x)
pop = len(vehicles_at[x])
for z in range(pop):
vehicles_at[x].pop()
for i in vehicle_path:
if i != None and len(i) != 0:
i.insert(0, Pa[i[0]])
for i in range(len(Pa)):
if i != 0:
if Pa[i] == None:
x = i
for c in Com:
demand_left[x][c] = ditc[x][t][c]
a = 0
while demand_left[x][c] > 0 and a < len(vehicles_at[x]):
for c in Com:
diktc[x][vehicles_at[x][a]][t][c] = min(
demand_left[x][c],
vehicle_capacity_left[vehicles_at[x][a]])
weight_carried[vehicles_at[x][a]] = weight_carried[
vehicles_at[x][a]] + diktc[x][vehicles_at[x]
[a]][t][c]
vehicle_capacity_left[
vehicles_at[x][a]] = vehicle_capacity_left[
vehicles_at[x][a]] - diktc[x][vehicles_at[
x][a]][t][c] # no need for this
demand_left[x][c] = demand_left[x][c] - diktc[x][
vehicles_at[x][a]][t][c]
a = a + 1
while sum([demand_left[x][c] for c in Com]) > 0:
if k < K * H:
(vehicles_at[x]).append(k)
for c in Com:
diktc[x][k][t][c] = min(
demand_left[x][c],
vehicle_capacity_left[k])
weight_carried[
k] = weight_carried[k] + diktc[x][k][t][c]
vehicle_capacity_left[
k] = vehicle_capacity_left[k] - diktc[x][
k][t][c] # no need for this
demand_left[x][
c] = demand_left[x][c] - diktc[x][k][t][c]
k = k + 1
else:
for j in range(len(vehicle_capacity_left)):
for c in Com:
diktc[x][j][t][c] = min(
demand_left[x][c],
vehicle_capacity_left[j])
weight_carried[j] = weight_carried[
j] + diktc[x][j][t][c]
vehicle_capacity_left[
j] = vehicle_capacity_left[j] - diktc[
x][j][t][c] # no need for this
demand_left[x][c] = demand_left[x][
c] - diktc[x][j][t][c]
# In the following code we formulate the primary vehicle routing model in cplex and solve it
model = cplex.Cplex()
for i in V:
yijlt.append([])
for j in V:
if S.count(i) != 0 and S.count(j) != 0:
if i != j:
yijlt[i].append([])
for l in range(L):
if yijlt[i][j] != None:
yijlt[i][j].append([])
for t in range(P):
varName = "y." + str(i) + "." + str(
j) + "." + str(l) + "." + str(t)
if len(yijlt[i][j]) != 0:
yijlt[i][j][l].append(varName)
model.variables.add(
obj=[h1[i][j]],
lb=[0.0],
ub=[1.0],
types=[model.variables.type.integer],
names=[varName])
else:
yijlt[i].append(None)
else:
yijlt[i].append(None)
for i in V:
vijltc.append([])
for j in V:
if i != j:
vijltc[i].append([])
for l in range(L):
if vijltc[i][j] != None:
vijltc[i][j].append([])
for t in range(P):
vijltc[i][j][l].append([])
for c in Com:
varName = "v." + str(i) + "." + str(
j) + "." + str(l) + "." + str(
t) + "." + str(c)
if len(vijltc[i][j][l]) != 0:
vijltc[i][j][l][t].append(varName)
model.variables.add(
obj=[0.0],
lb=[0.0],
ub=[cplex.infinity],
types=[model.variables.type.integer],
names=[varName])
else:
vijltc[i].append(None)
for i in V:
Ditc.append([])
for t in range(P):
Ditc[i].append([])
for c in Com:
varName = "D." + str(i) + "." + str(t) + "." + str(c)
Ditc[i][t].append(varName)
model.variables.add(obj=[0.0],
lb=[0.0],
ub=[cplex.infinity],
types=[model.variables.type.integer],
names=[varName])
for i in V:
Sitc.append([])
for t in range(P):
Sitc[i].append([])
for c in Com:
varName = "S." + str(i) + "." + str(t) + "." + str(c)
Sitc[i][t].append(varName)
model.variables.add(obj=[0.0],
lb=[0.0],
ub=[cplex.infinity],
types=[model.variables.type.integer],
names=[varName])
for j in S:
for t in range(P):
for l in range(L):
X = []
Y = []
for i in S:
if i != j:
X.append(yijlt[i][j][l][t])
X.append(yijlt[j][i][l][t])
Y.append(1)
Y.append(-1)
print X
print Y
model.linear_constraints.add(
lin_expr=[cplex.SparsePair(ind=X, val=Y)],
senses=["E"],
rhs=[0])
i = 0
for t in range(P):
for l in range(L):
X = []
for j in S:
if i != j:
X.append(yijlt[i][j][l][t])
model.linear_constraints.add(
lin_expr=[cplex.SparsePair(ind=X, val=[1] * len(X))],
senses=["E"],
rhs=[1])
for t in range(P):
for l in range(L):
for r in range(2, len(A) + 1):
for p in itertools.combinations(A, r):
X = []
for i in p:
for j in p:
if i != j:
X.append(yijlt[i][j][l][t])
if len(X) != 0:
model.linear_constraints.add(lin_expr=[
cplex.SparsePair(ind=X, val=[1] * len(X))
],
senses=["L"],
rhs=[len(X) - 1])
# Constraint Set 3
# Capacity
for i in S:
for l in range(L):
for t in range(P):
X = []
for j in S:
if i != j:
for c in Com:
X.append(vijltc[i][j][l][t][c])
model.linear_constraints.add(lin_expr=[
cplex.SparsePair(ind=X, val=[1] * len(X))
],
senses=["L"],
rhs=[ql])
# Constraint Set 4
# Time constraint
for l in range(L):
for t in range(P):
X = []
Y = []
for i in S:
for j in S:
if i != j:
X.append(yijlt[j][i][l][t])
Y.append(h1[i][j] + g[i])
model.linear_constraints.add(
lin_expr=[cplex.SparsePair(ind=X, val=Y)],
senses=["L"],
rhs=[rh * sh])
# Constraint 17
# Relation between movement and load variables
for i in S:
for j in A:
if i != j:
for l in range(L):
for t in range(P):
X = []
Y = []
X.append(yijlt[i][j][l][t])
Y.append(1)
for c in Com:
X.append(vijltc[i][j][l][t][c])
Y.append(-1)
model.linear_constraints.add(
lin_expr=[cplex.SparsePair(ind=X, val=Y)],
senses=["L"],
rhs=[0])
# Constraint 18
# Relation between movement and load variables
for i in S:
for j in A:
if i != j:
for l in range(L):
for t in range(P):
X = []
Y = []
X.append(yijlt[i][j][l][t])
Y.append(100000)
for c in Com:
X.append(vijltc[i][j][l][t][c])
Y.append(-1)
model.linear_constraints.add(
lin_expr=[cplex.SparsePair(ind=X, val=Y)],
senses=["G"],
rhs=[0])
j = 0
for i in S:
for t in range(P):
if i != j:
for l in range(L):
X = []
for c in Com:
X.append(vijltc[i][j][l][t][c])
model.linear_constraints.add(
lin_expr=[cplex.SparsePair(ind=X, val=[1] * len(X))],
senses=["E"],
rhs=[0])
##Constaint 20
# Supply Coordination
for i in S:
if i != 0:
for t in range(P):
for c in Com:
X = []
Y = []
for j in S:
if i != j:
for l in range(L):
X.append(vijltc[j][i][l][t][c])
X.append(vijltc[i][j][l][t][c])
Y.append(1)
Y.append(-1)
X.append(Ditc[i][t][c])
Y.append(-1)
model.linear_constraints.add(
lin_expr=[cplex.SparsePair(ind=X, val=Y)],
senses=["E"],
rhs=[0])
### Constraint 21
# Supply Coordination
for i in A:
for t in range(1, P):
for c in Com:
X = []
Y = []
Z = 0
X.append(Sitc[i][t][c])
Y.append(1)
X.append(Sitc[i][t - 1][c])
Y.append(-1)
for j in W:
if i != j:
for k in range(K * H):
Z = Z - zijktc[i][j][k][t][c]
Z = Z - ditc[i][t][c]
X.append(Ditc[i][t][c])
Y.append(-1)
model.linear_constraints.add(
lin_expr=[cplex.SparsePair(ind=X, val=Y)],
senses=["E"],
rhs=[Z])
t = 0
for i in A:
for c in Com:
X = []
Y = []
Z = 0
d
X.append(Sitc[i][t][c])
Y.append(1)
for j in W:
if i != j:
for k in range(K * H):
Z = Z - zijktc[i][j][k][t][c]
X.append(Ditc[i][t][c])
Z = Z - ditc[i][t][c]
Y.append(-1)
model.linear_constraints.add(
lin_expr=[cplex.SparsePair(ind=X, val=Y)],
senses=["E"],
rhs=[Z])
i = 0
for t in range(1, P):
for c in Com:
X = []
Y = []
X.append(Sitc[0][t][c])
Y.append(1)
X.append(Sitc[0][t - 1][c])
Y.append(-1)
for j in S:
if i != j:
for l in range(L):
X.append(vijltc[i][j][l][t][c])
Y.append(1)
model.linear_constraints.add(
lin_expr=[cplex.SparsePair(ind=X, val=Y)],
senses=["E"],
rhs=[Btc[t][c]])
# Amount stored in the helicopter depot in first period less than supply in first period
i = 0
t = 0
for c in Com:
X = []
Y = []
X.append(Sitc[i][t][c])
Y.append(1)
for j in A:
if i != j:
for l in range(L):
X.append(vijltc[i][j][l][t][c])
Y.append(1)
model.linear_constraints.add(lin_expr=[cplex.SparsePair(ind=X, val=Y)],
senses=["E"],
rhs=[Btc[t][c]])
model.parameters.timelimit.set(300)
try:
model.solve()
except CplexSolverError, e:
print "Exception raised during solve: " + e
def add_lazy_oa_cuts(self,
target_model,
dual_values,
solve_data,
config,
opt,
linearize_active=True,
linearize_violated=True):
"""Add oa_cuts through Cplex inherent function self.add()"""
for (constr,
dual_value) in zip(target_model.MindtPy_utils.constraint_list,
dual_values):
if constr.body.polynomial_degree() in (0, 1):
continue
constr_vars = list(identify_variables(constr.body))
jacs = solve_data.jacobians
# Equality constraint (makes the problem nonconvex)
if constr.has_ub() and constr.has_lb(
) and constr.upper == constr.lower:
sign_adjust = -1 if solve_data.objective_sense == minimize else 1
rhs = constr.lower if constr.has_lb() and constr.has_ub(
) else rhs
# since the cplex requires the lazy cuts in cplex type, we need to transform the pyomo expression into cplex expression
pyomo_expr = copysign(
1, sign_adjust * dual_value) * (sum(
value(jacs[constr][var]) * (var - value(var))
for var in list(EXPR.identify_variables(constr.body)))
+ value(constr.body) - rhs)
cplex_expr, _ = opt._get_expr_from_pyomo_expr(pyomo_expr)
cplex_rhs = -generate_standard_repn(pyomo_expr).constant
self.add(constraint=cplex.SparsePair(
ind=cplex_expr.variables, val=cplex_expr.coefficients),
sense="L",
rhs=cplex_rhs)
else: # Inequality constraint (possibly two-sided)
if constr.has_ub() \
and (linearize_active and abs(constr.uslack()) < config.zero_tolerance) \
or (linearize_violated and constr.uslack() < 0) \
or (config.linearize_inactive and constr.uslack() > 0):
pyomo_expr = sum(
value(jacs[constr][var]) * (var - var.value)
for var in constr_vars) + value(constr.body)
cplex_rhs = -generate_standard_repn(pyomo_expr).constant
cplex_expr, _ = opt._get_expr_from_pyomo_expr(pyomo_expr)
self.add(constraint=cplex.SparsePair(
ind=cplex_expr.variables, val=cplex_expr.coefficients),
sense="L",
rhs=constr.upper.value + cplex_rhs)
if constr.has_lb() \
and (linearize_active and abs(constr.lslack()) < config.zero_tolerance) \
or (linearize_violated and constr.lslack() < 0) \
or (config.linearize_inactive and constr.lslack() > 0):
pyomo_expr = sum(
value(jacs[constr][var]) * (var - self.get_values(
opt._pyomo_var_to_solver_var_map[var]))
for var in constr_vars) + value(constr.body)
cplex_rhs = -generate_standard_repn(pyomo_expr).constant
cplex_expr, _ = opt._get_expr_from_pyomo_expr(pyomo_expr)
self.add(constraint=cplex.SparsePair(
ind=cplex_expr.variables, val=cplex_expr.coefficients),
sense="G",
rhs=constr.lower.value + cplex_rhs)
def scalability_CPLEX(numberOfBoolVars, numOfRealVars, constraints,
max_sensors_under_attack, numberOfCores):
print '\n======================================================='
print ' TEST CPLEX'
print ' #Real Varabiles = ', numOfRealVars
print ' #Bool Varabiles = ', numberOfBoolVars
print ' #Bool Constraints = ', len(constraints)
print ' #Cores = ', numberOfCores
print '=======================================================\n'
mipSolver = cplex.Cplex()
rVars = ['x' + str(i) for i in range(0, numOfRealVars)]
bVars = ['b' + str(i) for i in range(0, numberOfBoolVars)]
mipSolver.variables.add(names=bVars,
types=[mipSolver.variables.type.binary] *
len(bVars))
mipSolver.variables.add(names=rVars,
ub=[cplex.infinity] * len(rVars),
lb=[-cplex.infinity] * len(rVars))
mipSolver.parameters.threads.set(numberOfCores)
mipSolver.parameters.timelimit.set(TIMEOUTE_LIMIT)
bigM = 1E6
#----------------------------------------------------------------------------
print '--> CPLEX: FEEDING CONSTRAINTS'
#----------------------------------------------------------------------------
convexIFCounter = 0
for constraint in constraints:
boolConstraint = constraint['bool']
#vars = ['b'+str(abs(i)-1) for i in boolConstraint]
#signs = [np.sign(i) for i in boolConstraint]
#numOfNegativeSigns = sum(x < 0 for x in signs)
#mipSolver.linear_constraints.add(lin_expr = [cplex.SparsePair(ind = vars,val = signs)],
# rhs = [1 -numOfNegativeSigns],
# senses = ['G'])
convexConstraint = constraint['convex']
clause = QPClause(convexConstraint['Q'], convexConstraint['c'],
convexConstraint['b'], rVars)
my_ind = ['x' + str(i) for i in range(0, numOfRealVars)
] + ['b' + str(abs(boolConstraint[0]))]
my_val = convexConstraint['c'] + [-1 * bigM]
mip_lin_expr = cplex.SparsePair(ind=my_ind, val=my_val)
mipSolver.quadratic_constraints.add(quad_expr=clause['quad_expr'],
lin_expr=mip_lin_expr,
rhs=clause['rhs'])
convexIFCounter = convexIFCounter + 1
# add constraint on maximum number of sensors being under attack
mipSolver.linear_constraints.add(
lin_expr=[cplex.SparsePair(ind=bVars, val=[1.0] * len(bVars))],
rhs=[max_sensors_under_attack + 1],
senses='L')
#----------------------------------------------------------------------------
print '--> CPLEX: SEARCHING FOR A SOLUTION'
#----------------------------------------------------------------------------
start = timeit.default_timer()
mipSolver.solve()
end = timeit.default_timer()
time_smt_MILP = end - start
print(mipSolver.solution.get_status(),
mipSolver.solution.get_status_string())
print 'CPLEX time = ', time_smt_MILP
return time_smt_MILP
def MCF(linkcaps, b_low, b_high, flow_group, pptc):
try:
prob = cplex.Cplex()
#set objective
obj = []
multi = []
for tc in pptc:
for path in pptc[tc]:
var_name = 'bpc_{}_{}_{}_{}'.format(tc.name, path.getNodes(), tc.src, tc.dst)
obj.append(var_name)
if tc.dst == 3:
multi.append(1)
else:
multi.append(1)
prob.variables.add(obj = multi, lb = [0.0]*len(obj), names = obj)
prob.objective.set_sense(prob.objective.sense.maximize)
#set flows that is already in flow_group
for tc in flow_group:
var_group = []
for path in flow_group[tc]:
var_name = 'bpc_{}_{}_{}_{}'.format(tc.name, path.getNodes(), tc.src, tc.dst)
var_group.append(var_name)
prob.linear_constraints.add(lin_expr=[cplex.SparsePair(ind=var_group, val=[1.0]*len(var_group))], senses=["E"], rhs=[tc.allocate_bw])
#set flows that is not in flow_group
for tc in pptc:
if tc not in flow_group:
upper_bound = min(tc.demand, b_high)
lower_bound = min(tc.demand, b_low)
var_group = []
for path in pptc[tc]:
var_name = 'bpc_{}_{}_{}_{}'.format(tc.name, path.getNodes(), tc.src, tc.dst)
var_group.append(var_name)
print var_group
print 'upper ',upper_bound
print 'lower ',lower_bound
prob.linear_constraints.add(lin_expr=[cplex.SparsePair(ind=var_group, val=[1.0]*len(var_group))], senses=["L"], rhs=[upper_bound], names=["u{}-{}".format(tc.src, tc.dst)])
prob.linear_constraints.add(lin_expr=[cplex.SparsePair(ind=var_group, val=[1.0]*len(var_group))], senses=["G"], rhs=[lower_bound], names=['l{}-{}'.format(tc.src, tc.dst)])
#set link capacity constraint
for link in linkcaps:
print link
u, v = link
cap = linkcaps[link]
link_cap_var = []
if cap > 0:
for tc in pptc:
for path in pptc[tc]:
if link in path.getLinks():
#print path.getNodes()
var_name = 'bpc_{}_{}_{}_{}'.format(tc.name, path.getNodes(), tc.src, tc.dst)
link_cap_var.append(var_name)
#print link_cap_var, ' cap:', cap
prob.linear_constraints.add(lin_expr=[cplex.SparsePair(ind=link_cap_var, val=[1.0] * len(link_cap_var))], senses=["L"], rhs=[cap])
prob.solve()
print("Solution status = ", prob.solution.get_status())
print("Obj ", prob.solution.get_objective_value())
numrows = prob.linear_constraints.get_num()
numcols = prob.variables.get_num()
for tc, paths in pptc.iteritems():
tc.tentative_bw = 0
for path in paths:
var_name = 'bpc_{}_{}_{}_{}'.format(tc.name, path.getNodes(), tc.src, tc.dst)
r = prob.solution.get_values(var_name)
tc.tentative_bw += r
path.bw = r
return (0, prob.solution.get_objective_value())
except CplexError as exc:
print exc.args[2]
return (exc.args[2], 0)
def runRMbeta(self, cut=0, lp_problem=False, debug=False, model_file=None):
"""Beta Model (RMbeta0)
Creates the Beta model proposed by Miyauchi and Sukegawa[1] and runs in CPLEX.
[1] Miyauchi, Atsushi, and Noriyoshi Sukegawa.
"Redundant constraints in the standard formulation for the clique partitioning problem."
Optimization Letters 9.1 (2015): 199-207.
Args:
cut(int,optional): The default value corresponds to the model proposed by Miyauchi and Sukegawa[1].
lp_problem (bool,optional): If True run as Linear Programming instead of ILP.
debug (bool,optional): Show debug information, mostly CPLEX output.
model_file (str,optional): Save the model to .lp format file.
Returns:
A Solution object.
"""
solution = None
############################
# Create IP Model
##############################
### MODELO CPLEX
try:
# Create cplex instance
my_prob = cplex.Cplex()
if debug == False:
# Disable cplex output
my_prob.set_log_stream(None)
my_prob.set_error_stream(None)
my_prob.set_warning_stream(None)
my_prob.set_results_stream(None)
# Define it as a maximization problem
my_prob.objective.set_sense(my_prob.objective.sense.maximize)
# Variables matrix
X = []
for i in range(self._n):
X.append([])
for j in range(self._n):
X[i].append(0)
# Create Objective Function
if lp_problem == True:
for i in range(self._n):
for j in range(i + 1, self._n):
var_name = "v." + str(i) + "." + str(j)
X[i][j] = my_prob.variables.get_num()
my_prob.variables.add(
obj=[self._S[i][j]],
lb=[0],
ub=[1],
names=[var_name],
types=[my_prob.variables.type.continuous])
else:
for i in range(self._n):
for j in range(i + 1, self._n):
var_name = "v." + str(i) + "." + str(j)
X[i][j] = my_prob.variables.get_num()
my_prob.variables.add(
obj=[self._S[i][j]],
lb=[0],
ub=[1],
names=[var_name],
types=[my_prob.variables.type.binary])
# Insert Constraints
for i in range(self._n):
for j in range(i + 1, self._n):
for k in range(j + 1, self._n):
if (self._S[i][j] + self._S[j][k] >= cut):
# Constraints
# dij + djk - dki <= 1
the_vars = []
the_coefs = []
the_vars.append(X[i][j])
the_coefs.append(1)
the_vars.append(X[j][k])
the_coefs.append(1)
the_vars.append(X[i][k])
the_coefs.append(-1)
my_prob.linear_constraints.add(lin_expr = \
[cplex.SparsePair(the_vars, the_coefs)],
senses = ["L"], rhs = [1])
if (self._S[i][j] + self._S[i][k] >= cut):
# dij - djk + dki <= 1
the_vars = []
the_coefs = []
the_vars.append(X[i][j])
the_coefs.append(1)
the_vars.append(X[j][k])
the_coefs.append(-1)
the_vars.append(X[i][k])
the_coefs.append(1)
my_prob.linear_constraints.add(lin_expr = \
[cplex.SparsePair(the_vars, the_coefs)],
senses = ["L"], rhs = [1])
if (self._S[j][k] + self._S[i][k] >= cut):
# -dij + djk + dki <= 1
the_vars = []
the_coefs = []
the_vars.append(X[i][j])
the_coefs.append(-1)
the_vars.append(X[j][k])
the_coefs.append(1)
the_vars.append(X[i][k])
the_coefs.append(1)
my_prob.linear_constraints.add(lin_expr = \
[cplex.SparsePair(the_vars, the_coefs)],
senses = ["L"], rhs = [1])
# Save model
if (model_file != None):
my_prob.write(model_file)
# Solve
time_solver = my_prob.get_time()
my_prob.solve()
time_solver = my_prob.get_time() - time_solver
# Number of constraints
num_rows = my_prob.linear_constraints.get_num()
# Number of Variaveis
num_cols = my_prob.variables.get_num()
# Objective value
objective = my_prob.solution.get_objective_value()
# Solution
x = my_prob.solution.get_values()
# Creating partition
groups = []
for i in range(self._n):
groups.append(-1)
groupID = 0
for i in range(self._n):
for j in range(i + 1, self._n):
index = X[i][j]
if x[index] > 0:
# Both objects don't have group, put then together on a new
if groups[i] == -1 and groups[j] == -1:
groups[i] = groupID
groups[j] = groupID
groupID = groupID + 1
else:
# If i object don't have group put him on j group
if groups[i] == -1:
groups[i] = groups[j]
else:
groups[j] = groups[i]
# The objects that remained alone create its own group
for i in range(len(groups)):
if groups[i] == -1:
groups[i] = groupID
groupID = groupID + 1
solution = {
'num_rows': num_rows,
'num_cols': num_cols,
'objective': objective,
'time_solver': time_solver,
'heuristic': None,
'groups': groups
}
except CplexError as exc:
print(exc)
return solution
def buildSolverModel(self, lp):
"""
Takes the pulp lp model and translates it into a cplex model
"""
model_variables = lp.variables()
self.n2v = dict((var.name, var) for var in model_variables)
if len(self.n2v) != len(model_variables):
raise PulpSolverError(
"Variables must have unique names for cplex solver")
log.debug("create the cplex model")
self.solverModel = lp.solverModel = cplex.Cplex()
log.debug("set the name of the problem")
if not self.mip:
self.solverModel.set_problem_name(lp.name)
log.debug("set the sense of the problem")
if lp.sense == constants.LpMaximize:
lp.solverModel.objective.set_sense(
lp.solverModel.objective.sense.maximize)
obj = [
float(lp.objective.get(var, 0.0)) for var in model_variables
]
def cplex_var_lb(var):
if var.lowBound is not None:
return float(var.lowBound)
else:
return -cplex.infinity
lb = [cplex_var_lb(var) for var in model_variables]
def cplex_var_ub(var):
if var.upBound is not None:
return float(var.upBound)
else:
return cplex.infinity
ub = [cplex_var_ub(var) for var in model_variables]
colnames = [var.name for var in model_variables]
def cplex_var_types(var):
if var.cat == constants.LpInteger:
return "I"
else:
return "C"
ctype = [cplex_var_types(var) for var in model_variables]
ctype = "".join(ctype)
lp.solverModel.variables.add(obj=obj,
lb=lb,
ub=ub,
types=ctype,
names=colnames)
rows = []
senses = []
rhs = []
rownames = []
for name, constraint in lp.constraints.items():
# build the expression
expr = [(var.name, float(coeff))
for var, coeff in constraint.items()]
if not expr:
# if the constraint is empty
rows.append(([], []))
else:
rows.append(list(zip(*expr)))
if constraint.sense == constants.LpConstraintLE:
senses.append("L")
elif constraint.sense == constants.LpConstraintGE:
senses.append("G")
elif constraint.sense == constants.LpConstraintEQ:
senses.append("E")
else:
raise PulpSolverError(
"Detected an invalid constraint type")
rownames.append(name)
rhs.append(float(-constraint.constant))
lp.solverModel.linear_constraints.add(lin_expr=rows,
senses=senses,
rhs=rhs,
names=rownames)
log.debug("set the type of the problem")
if not self.mip:
self.solverModel.set_problem_type(cplex.Cplex.problem_type.LP)
log.debug("set the logging")
if not self.msg:
self.setlogfile(None)
logPath = self.optionsDict.get("logPath")
if logPath is not None:
if self.msg:
warnings.warn(
"`logPath` argument replaces `msg=1`. The output will be redirected to the log file."
)
self.setlogfile(open(logPath, "w"))
gapRel = self.optionsDict.get("gapRel")
if gapRel is not None:
self.changeEpgap(gapRel)
if self.timeLimit is not None:
self.setTimeLimit(self.timeLimit)
if self.optionsDict.get("warmStart", False):
# We assume "auto" for the effort_level
effort = self.solverModel.MIP_starts.effort_level.auto
start = [(k, v.value()) for k, v in self.n2v.items()
if v.value() is not None]
if not start:
warnings.warn(
"No variable with value found: mipStart aborted")
return
ind, val = zip(*start)
self.solverModel.MIP_starts.add(
cplex.SparsePair(ind=ind, val=val), effort, "1")
def runRM(self, lp_problem=False, debug=False, model_file=None):
"""Original Model (RM)
Creates the original model of Regnier Problem and runs in CPLEX.
Args:
lp_problem (bool,optional): If True run as Linear Programming instead of ILP.
debug (bool,optional): Show debug information, mostly CPLEX output.
model_file (str,optional): Save the model to .lp format file.
Returns:
A Solution object.
"""
solution = None
############################
# Create IP Model
##############################
try:
# Create cplex instance
my_prob = cplex.Cplex()
if not debug:
# Disable cplex output
my_prob.set_log_stream(None)
my_prob.set_error_stream(None)
my_prob.set_warning_stream(None)
my_prob.set_results_stream(None)
# Define it as a maximization problem
my_prob.objective.set_sense(my_prob.objective.sense.maximize)
# Variables matrix
X = []
for i in range(self._n):
X.append([])
for j in range(self._n):
X[i].append(0)
# Create Objective Function
if lp_problem == True:
for i in range(self._n):
for j in range(i + 1, self._n):
var_name = "v." + str(i) + "." + str(j)
X[i][j] = my_prob.variables.get_num()
my_prob.variables.add(
obj=[self._S[i][j]],
lb=[0],
ub=[1],
names=[var_name],
types=[my_prob.variables.type.continuous])
else:
for i in range(self._n):
for j in range(i + 1, self._n):
var_name = "v." + str(i) + "." + str(j)
X[i][j] = my_prob.variables.get_num()
my_prob.variables.add(
obj=[self._S[i][j]],
lb=[0],
ub=[1],
names=[var_name],
types=[my_prob.variables.type.binary])
# Insert Constraints
for i in range(self._n):
for j in range(i + 1, self._n):
for k in range(j + 1, self._n):
# Constraints
# dij + djk - dki <= 1
the_vars = []
the_coefs = []
the_vars.append(X[i][j])
the_coefs.append(1)
the_vars.append(X[j][k])
the_coefs.append(1)
the_vars.append(X[i][k])
the_coefs.append(-1)
my_prob.linear_constraints.add(lin_expr = \
[cplex.SparsePair(the_vars, the_coefs)],
senses = ["L"], rhs = [1])
# dij - djk + dki <= 1
the_vars = []
the_coefs = []
the_vars.append(X[i][j])
the_coefs.append(1)
the_vars.append(X[j][k])
the_coefs.append(-1)
the_vars.append(X[i][k])
the_coefs.append(1)
my_prob.linear_constraints.add(lin_expr = \
[cplex.SparsePair(the_vars, the_coefs)],
senses = ["L"], rhs = [1])
# -dij + djk + dki <= 1
the_vars = []
the_coefs = []
the_vars.append(X[i][j])
the_coefs.append(-1)
the_vars.append(X[j][k])
the_coefs.append(1)
the_vars.append(X[i][k])
the_coefs.append(1)
my_prob.linear_constraints.add(lin_expr = \
[cplex.SparsePair(the_vars, the_coefs)],
senses = ["L"], rhs = [1])
# Save model
if (model_file != None):
my_prob.write(model_file)
# Solve
time_solver = my_prob.get_time()
my_prob.solve()
time_solver = my_prob.get_time() - time_solver
# Number of constraints
num_rows = my_prob.linear_constraints.get_num()
# Number of Variables
num_cols = my_prob.variables.get_num()
# Objective value
objective = my_prob.solution.get_objective_value()
# Solution
x = my_prob.solution.get_values()
# Creating partition
groups = []
for i in range(self._n):
groups.append(-1)
groupID = 0
for i in range(self._n):
for j in range(i + 1, self._n):
index = X[i][j]
if x[index] > 0:
# Both objects don't have group, put then together on a new
if groups[i] == -1 and groups[j] == -1:
groups[i] = groupID
groups[j] = groupID
groupID = groupID + 1
else:
# If i object don't have group put him on j group
if groups[i] == -1:
groups[i] = groups[j]
else:
groups[j] = groups[i]
# The objects that remained alone create its own group
for i in range(len(groups)):
if groups[i] == -1:
groups[i] = groupID
groupID = groupID + 1
# Make solution object to return
solution = {
'num_rows': num_rows,
'num_cols': num_cols,
'objective': objective,
'time_solver': time_solver,
'heuristic': None,
'groups': groups
}
except CplexError as exc:
print(exc)
return solution
master_prob = cplex.Cplex()
x = []
# Create problem variables
for i in range(n):
var_index = master_prob.variables.get_num()
var_name = 'x_' + str(i)
x.append(var_index)
#master_prob.variables.add(obj = [1.0], lb = [0.0], ub = [1.0], types = ['B'], names = [var_name])
master_prob.variables.add(obj = [1.0], lb = [0.0], ub = [1.0], names = [var_name])
# Create problem constraints
for i in range(m):
vars = [x[edges[i][0]], x[edges[i][1]], x[edges[i][2]]]
coefs = [1.0, 1.0, 1.0]
master_prob.linear_constraints.add(lin_expr = [cplex.SparsePair(vars, coefs)], senses = ['G'], rhs = [1.0], names = ['T_'+str(i)])
# lift and project loop
lift_and_project_cutting_plane_loop(master_prob, __MAX_ITER)
#master_prob.variables.set_types([(var_name, 'B') for var_name in master_prob.variables.get_names()])
#master_prob.solve()
print
print 'Final Solution:'
print
solution = master_prob.solution
print "\tCpx Objective value: " , solution.get_objective_value()
master_prob.write('./output/steiner_triple_master.lp')
def buildSolverModel(self, lp):
"""
Takes the pulp lp model and translates it into a cplex model
"""
model_variables = lp.variables()
self.n2v = dict((var.name, var) for var in model_variables)
if len(self.n2v) != len(model_variables):
raise PulpSolverError(
'Variables must have unique names for cplex solver')
log.debug("create the cplex model")
self.solverModel = lp.solverModel = cplex.Cplex()
log.debug("set the name of the problem")
if not self.mip:
self.solverModel.set_problem_name(lp.name)
log.debug("set the sense of the problem")
if lp.sense == constants.LpMaximize:
lp.solverModel.objective.set_sense(
lp.solverModel.objective.sense.maximize)
obj = [
float(lp.objective.get(var, 0.0)) for var in model_variables
]
def cplex_var_lb(var):
if var.lowBound is not None:
return float(var.lowBound)
else:
return -cplex.infinity
lb = [cplex_var_lb(var) for var in model_variables]
def cplex_var_ub(var):
if var.upBound is not None:
return float(var.upBound)
else:
return cplex.infinity
ub = [cplex_var_ub(var) for var in model_variables]
colnames = [var.name for var in model_variables]
def cplex_var_types(var):
if var.cat == constants.LpInteger:
return 'I'
else:
return 'C'
ctype = [cplex_var_types(var) for var in model_variables]
ctype = "".join(ctype)
lp.solverModel.variables.add(obj=obj,
lb=lb,
ub=ub,
types=ctype,
names=colnames)
rows = []
senses = []
rhs = []
rownames = []
for name, constraint in lp.constraints.items():
#build the expression
expr = [(var.name, float(coeff))
for var, coeff in constraint.items()]
if not expr:
#if the constraint is empty
rows.append(([], []))
else:
rows.append(list(zip(*expr)))
if constraint.sense == constants.LpConstraintLE:
senses.append('L')
elif constraint.sense == constants.LpConstraintGE:
senses.append('G')
elif constraint.sense == constants.LpConstraintEQ:
senses.append('E')
else:
raise PulpSolverError(
'Detected an invalid constraint type')
rownames.append(name)
rhs.append(float(-constraint.constant))
lp.solverModel.linear_constraints.add(lin_expr=rows,
senses=senses,
rhs=rhs,
names=rownames)
log.debug("set the type of the problem")
if not self.mip:
self.solverModel.set_problem_type(cplex.Cplex.problem_type.LP)
log.debug("set the logging")
if not self.msg:
self.solverModel.set_error_stream(None)
self.solverModel.set_log_stream(None)
self.solverModel.set_warning_stream(None)
self.solverModel.set_results_stream(None)
if self.logfilename is not None:
self.setlogfile(self.logfilename)
if self.epgap is not None:
self.changeEpgap(self.epgap)
if self.timeLimit is not None:
self.setTimeLimit(self.timeLimit)
if self.mip_start:
# We assume "auto" for the effort_level
effort = self.solverModel.MIP_starts.effort_level.auto
start = [(k, v.value()) for k, v in self.n2v.items()
if v.value() is not None]
ind, val = zip(*start)
self.solverModel.MIP_starts.add(
cplex.SparsePair(ind=ind, val=val), effort, '1')
def __prepareConvexProblem(self, convIFModel):
# Create a new instance of the convex solver. Initial solver contains the original convex constraints.
# Add names to these constraints and then use their names to the delete some constraints.
# Create a new CPLEX solver object from the origional data
constrainedConvSolver = cplex.Cplex(self.ConvSolver)
constrainedConvSolver.parameters.threads.set(self.numberOfCores)
if self.verbose == 'OFF':
constrainedConvSolver.set_results_stream(None)
constrainedConvSolver.set_log_stream(None)
end = timeit.default_timer()
# Extract only those constraints that are assigned to false
inactiveIFClauses = [i for i, x in enumerate(convIFModel) if x != True]
#activeIFClauses = [i for i, x in enumerate(convIFModel) if x == True]
# Delete the corresponding "slacked" constraints
for clauseIndex in inactiveIFClauses:
clause = self.__convIFClauses[clauseIndex]
if clause['type'] == 'LP':
constrainedConvSolver.linear_constraints.delete(clause['name'])
elif clause['type'] == 'QP':
constrainedConvSolver.quadratic_constraints.delete(
clause['name'])
#print constrainedConvSolver.linear_constraints.get_senses()
#print constrainedConvSolver.linear_constraints.get_rhs()
#print constrainedConvSolver.linear_constraints.get_rows()
if self.counterExampleStrategy == 'PREFIX':
activeIFClauses = [
i for i, x in enumerate(convIFModel) if x == True
]
print 'activeIFClauses = ', activeIFClauses
ii = [i * 27 for i in range(0, len(activeIFClauses))]
print[x - y for x, y in zip(activeIFClauses, ii)]
print 'activeIFClauses = ', activeIFClauses
#for activeIfClausecounter in range(1, len(activeIFClauses)):
pastSlackIndecies = list()
for activeIfClause in activeIFClauses:
if not pastSlackIndecies: # if is empty
pastSlackIndecies.append(activeIfClause)
continue
pastSlacks = [
self.__slackIFVarsBound[i] for i in pastSlackIndecies
]
currentSlack = [self.__slackIFVarsBound[activeIfClause]]
#print currentSlack, [pastSlacks[-1]]
#constrainedConvSolver.linear_constraints.add(
# lin_expr = [cplex.SparsePair(ind = currentSlack + pastSlacks,
# val = [-1] + [self.slackRatio]*len(pastSlacks))],
# senses = ['L'],
# rhs = [0.0],
# )
#print 'pastSlacks', pastSlacks, 'currentSlack', currentSlack, currentSlack + pastSlacks,[pastSlacks[-1]]
constrainedConvSolver.linear_constraints.add(
lin_expr=[
cplex.SparsePair(ind=currentSlack + [pastSlacks[-1]],
val=[-1] + [1])
],
senses=['L'],
rhs=[0.0],
)
pastSlackIndecies.append(activeIfClause)
#print constrainedConvSolver.linear_constraints.get_senses()
#print constrainedConvSolver.linear_constraints.get_rhs()
#print constrainedConvSolver.linear_constraints.get_rows()
return constrainedConvSolver
def CPLEX_MODEL_BoolRank(X):
"""
Builds Cplex object
:param X: nxm (0,1) matrix
:return cpx: Cplex object which containts (IP) to compute the Boolean rank of X
k = min(n,m)
(IP): min sum_l d_l
s.t. sum_l y_ilj >= 1 (i,j) s.t. x_ij=1
y_ilj = 0 (i,j) s.t. x_ij=0
y_ilj <= c_il l \in [k], (i,j) s.t. x_ij=1
y_ilj <= r_lj l \in [k], (i,j) s.t. x_ij=1
c_il + r_lj <= 1 l \in [k], (i,j) s.t. x_ij=0
c_il <= d_l i \in [n], l \in [k]
r_lj <= d_l l \in [k], j \in [m]
y_ilj \in [0,1] i \in [n], l \in [k], j \in [m]
c_il, r_lj, d_l \in {0,1} i \in [n], l \in [k], j \in [m]
"""
n, m = X.shape
k = min(n, m)
idx0 = np.transpose(np.where(X == 0))
idx1 = np.transpose(np.where(X == 1))
cpx = cplex.Cplex()
cpx.objective.set_sense(cpx.objective.sense.minimize)
# c_i,l
cpx.variables.add(
obj=[0 for i in range(n) for l in range(k)],
lb=[0 for i in range(n) for l in range(k)],
ub=[1 for i in range(n) for l in range(k)],
types=[cpx.variables.type.binary for i in range(n) for l in range(k)],
names=[
"c_" + str(i) + "," + str(l) for i in range(n) for l in range(k)
])
# r_l,j
cpx.variables.add(
obj=[0 for l in range(k) for j in range(m)],
lb=[0 for l in range(k) for j in range(m)],
ub=[1 for l in range(k) for j in range(m)],
types=[cpx.variables.type.binary for l in range(k) for j in range(m)],
names=[
"r_" + str(l) + "," + str(j) for l in range(k) for j in range(m)
])
# y_i,l,j
cpx.variables.add(
obj=[0 for i in range(n) for l in range(k) for j in range(m)],
lb=[0 for i in range(n) for l in range(k) for j in range(m)],
ub=[1 for i in range(n) for l in range(k) for j in range(m)],
types=[
cpx.variables.type.continuous for i in range(n) for l in range(k)
for j in range(m)
],
names=[
"y_" + str(i) + "," + str(l) + "," + str(j) for i in range(n)
for l in range(k) for j in range(m)
])
# d_l
cpx.variables.add(obj=[1 for l in range(k)],
lb=[0 for l in range(k)],
ub=[1 for l in range(k)],
types=[cpx.variables.type.binary for l in range(k)],
names=["d_" + str(l) for l in range(k)])
#CONSTRAINTS
# sum_l y_ilj => 1
cpx.linear_constraints.add(lin_expr=[
cplex.SparsePair(ind=[
"y_" + str(ij[0]) + "," + str(l) + "," + str(ij[1])
for l in range(k)
],
val=[-1 for l in range(k)]) for ij in idx1
],
rhs=[-1 for ij in idx1],
senses=["L" for ij in idx1],
names=[
"sum_l y_" + str(ij[0]) + ",l," +
str(ij[1]) + " <= 1" for ij in idx1
])
# y_i,l,j = 0
cpx.linear_constraints.add(
lin_expr=[
cplex.SparsePair(
ind=["y_" + str(ij[0]) + "," + str(l) + "," + str(ij[1])],
val=[1]) for l in range(k) for ij in idx0
],
rhs=[0 for l in range(k) for ij in idx0],
senses=["E" for l in range(k) for ij in idx0],
names=[
"y_" + str(ij[0]) + "," + str(l) + "," + str(ij[1]) + " = 0"
for l in range(k) for ij in idx0
])
# y_i,l,j <= c_i,l
cpx.linear_constraints.add(
lin_expr=[
cplex.SparsePair(ind=[
"y_" + str(ij[0]) + "," + str(l) + "," + str(ij[1]),
"c_" + str(ij[0]) + "," + str(l)
],
val=[1, -1]) for l in range(k) for ij in idx1
],
rhs=[0 for l in range(k) for ij in idx1],
senses=["L" for l in range(k) for ij in idx1],
names=[
"y_" + str(ij[0]) + "," + str(l) + "," + str(ij[1]) + " <= c_" +
str(ij[0]) + "," + str(l) for l in range(k) for ij in idx1
])
# y_i,l,j <= r_l,j
cpx.linear_constraints.add(
lin_expr=[
cplex.SparsePair(ind=[
"y_" + str(ij[0]) + "," + str(l) + "," + str(ij[1]),
"r_" + str(l) + "," + str(ij[1])
],
val=[1, -1]) for l in range(k) for ij in idx1
],
rhs=[0 for l in range(k) for ij in idx1],
senses=["L" for l in range(k) for ij in idx1],
names=[
"y_" + str(ij[0]) + "," + str(l) + "," + str(ij[1]) + " <= r_" +
str(l) + "," + str(ij[1]) for l in range(k) for ij in idx1
])
# c_i,l + r_l,j <= 1
cpx.linear_constraints.add(lin_expr=[
cplex.SparsePair(ind=[
"c_" + str(ij[0]) + "," + str(l), "r_" + str(l) + "," + str(ij[1])
],
val=[1, 1]) for l in range(k) for ij in idx0
],
rhs=[1 for l in range(k) for ij in idx0],
senses=["L" for l in range(k) for ij in idx0],
names=[
"c_" + str(ij[0]) + "," + str(l) + " + " +
"r_" + str(l) + "," + str(ij[1]) + " <= 1"
for l in range(k) for ij in idx0
])
# c_i,l <= d_l
cpx.linear_constraints.add(
lin_expr=[
cplex.SparsePair(ind=["c_" + str(i) + "," + str(l), "d_" + str(l)],
val=[1, -1]) for i in range(n) for l in range(k)
],
rhs=[0 for i in range(n) for l in range(k)],
senses=["L" for i in range(n) for l in range(k)],
names=[
"c_" + str(i) + "," + str(l) + " <= d_" + str(l) for i in range(n)
for l in range(k)
])
# r_l,j <= d_l
cpx.linear_constraints.add(
lin_expr=[
cplex.SparsePair(ind=["r_" + str(l) + "," + str(j), "d_" + str(l)],
val=[1, -1]) for j in range(m) for l in range(k)
],
rhs=[0 for j in range(m) for l in range(k)],
senses=["L" for j in range(m) for l in range(k)],
names=[
"r_" + str(l) + "," + str(j) + " <= d_" + str(l) for j in range(m)
for l in range(k)
])
# PARTIAL SYMMETRY BREAKING
# d_(l-1) => d_l
cpx.linear_constraints.add(
lin_expr=[
cplex.SparsePair(ind=["d_" + str(l - 1), "d_" + str(l)],
val=[1, -1]) for l in range(1, k)
],
rhs=[0 for l in range(1, k)],
senses=["G" for l in range(1, k)],
names=["d_" + str(l - 1) + " >= d_" + str(l) for l in range(1, k)])
return cpx
# ============================================================
# Establish the Linear Programming Model
myProblem = cplex.Cplex()
# Add the decision variables and set their lower bound and upper bound (if necessary)
myProblem.variables.add(names= ["x"+str(i) for i in range(num_decision_var)])
for i in range(num_decision_var):
myProblem.variables.set_lower_bounds(i, 0.0)
# Set the type of each variables
myProblem.variables.set_types(0, myProblem.variables.type.integer)
myProblem.variables.set_types(1, myProblem.variables.type.continuous)
# Add constraints
for i in range(num_constraints):
myProblem.linear_constraints.add(
lin_expr= [cplex.SparsePair(ind= [j for j in range(num_decision_var)], val= A[i])],
rhs= [b[i]],
names = ["c"+str(i)],
senses = [constraint_type[i]]
)
# Add objective function and set its sense
for i in range(num_decision_var):
myProblem.objective.set_linear([(i, c[i])])
myProblem.objective.set_sense(myProblem.objective.sense.maximize)
# Solve the model and print the answer
myProblem.solve()
print(myProblem.solution.get_values())
def separate(self, xSol):
sub_insts = self.instance
for instance in sub_insts:
for i in instance.sI:
instance.x[i] = max(xSol[i - 1], 0)
solve_all_instances(self.solver_manager, 'cplex', sub_insts)
subObj = 0
cutRhs = 0
cutLhs = 0
thecoefs = [0] * len(xSol)
for s, inst in enumerate(sub_insts, 1):
subObj += round(inst.oSub(), 4)
#print("obj. value for scenario "+str(s)+ " = "+inst.name+" is "+\
# str(subObj[s-1])+"("+str(1.0/self.numScen*subObj[s-1])+")")
cut = 0
#constraint g
for i in inst.scg:
cut += inst.dual[inst.cSg[i]]
#constraint p
for i in inst.sI:
for t in inst.sT:
cut += inst.dual[inst.cSp[i, t]] * (-1)
#constraint q,r,s,t
for i in inst.sI:
for t in inst.sT:
for r in inst.sR:
cut += inst.dual[inst.cSq[i, t, r]]
cut += inst.dual[inst.cSr[i, t, r]]
cut += inst.dual[inst.cSs[i, t, r]]
cut += inst.dual[inst.cSt[i, t, r]]
#constraint s1
for i in inst.sI:
for r in inst.sR_0:
cut += 2 * inst.dual[inst.cSs1[i, r]]
#constraint u
for t in inst.sT_0:
cut += inst.dual[inst.cSu[t]]
#constraint v
for i in inst.sI:
for t in inst.sT_ex:
for r in inst.sR:
cut += inst.dual[inst.cSv[i, t, r]]
cut = 1.0 / self.numScen * cut
#print ("added cut")
#print (cut)
cutRhs += cut
#constraint i
for i in inst.sI:
#print ("+%f*x[%d]" %(1.0/self.numScen*inst.dual[inst.cSi[i]],i)),
thecoefs[i - 1] = 1.0 / self.numScen * inst.dual[inst.cSi[i]]
theind = self.mstX[:]
theind.append(self.mstSita)
thecoefs.append(1.0)
cutLhs = cplex.SparsePair(ind=theind, val=thecoefs)
self.cutLhs = cutLhs
self.cutRhs = cutRhs
self.subObj = subObj
def Stabilization(self):
eps = 0.1
w = self.w
I = range(len(w))
M = cplex.Cplex()
var = list(range(len(w)))
vals = np.zeros((len(w), len(var)))
np.fill_diagonal(vals, 1)
x_p = lambda p: 'x_%d' % (p)
x = [x_p(p) for p in range(len(var))]
M.variables.add(lb=[0] * len(x),
ub=[cplex.infinity] * len(x),
names=x,
obj=[1.] * len(x),
types=['C'] * len(x))
dp_i = lambda i: 'dp_%d' % (i)
dp = [dp_i(i) for i in I]
M.variables.add(lb=[0] * len(dp),
ub=[eps] * len(dp),
names=dp,
obj=[0] * len(dp),
types=['C'] * len(dp))
dm_i = lambda i: 'dm_%d' % (i)
dm = [dm_i(i) for i in I]
M.variables.add(lb=[0] * len(dm),
ub=[eps] * len(dm),
names=dm,
obj=[0] * len(dm),
types=['C'] * len(dm))
M.linear_constraints.add(lin_expr=[
cplex.SparsePair(ind=x + [dm[i]] + [dp[i]],
val=list(vals[i]) + [-1.0] + [1.0]) for i in I
],
senses=["G" for i in w],
rhs=[1. for i in w])
# M.linear_constraints.add(lin_expr=[SparsePair()] * len(w),
# senses=["G"] * len(w),
# rhs=[1] * len(w))
# for i in range(len(w)):
# M.linear_constraints.set_coefficients(i, i, 1)
M.objective.set_sense(M.objective.sense.minimize)
M.set_log_stream(None)
M.set_error_stream(None)
M.set_warning_stream(None)
M.set_results_stream(None)
start = time.time()
mt = 0
st = 0
ite = 0
solutions = []
iterations = []
criteria = True
while criteria:
ite += 1
M.set_problem_type(M.problem_type.LP)
ct = time.time()
M.solve()
solutions.append(float(M.solution.get_objective_value()))
iterations.append(
float(cplex._internal._procedural.getitcnt(M._env._e, M._lp)))
mt += time.time() - ct
pi = list(M.solution.get_dual_values())[:len(w)]
dual = list(M.solution.get_dual_values())
v = pi
W = self.W
pt = time.time()
# print(w)
S_obj, sol = binpacking.KnapsackBnB(v, w, W)
# print(S_obj, sol)
st += time.time() - pt
if S_obj - 0.000001 > 1. or eps != 0:
criteria = True
newsub = sol
idx = M.variables.get_num()
M.variables.add(obj=[1.0])
M.linear_constraints.set_coefficients(
list(zip(list(range(len(w))), [idx] * len(var), newsub)))
var.append(idx)
if ite % 100 == 0:
eps *= 0.1
if ite == 600:
eps = 0
for dv in dm + dp:
M.variables.set_upper_bounds(dv, eps)
else:
criteria = False
M.set_problem_type(M.problem_type.LP)
ct = time.time()
M.solve()
# M.write('kelly.lp')
solutions.append(float(M.solution.get_objective_value()))
iterations.append(
float(cplex._internal._procedural.getitcnt(M._env._e, M._lp)))
mt += time.time() - ct
tt = time.time() - start
self.Stab_M = M
self.Stab_Result = [
'Stabilization', ite, mt, st, tt, mt / (st + mt), solutions,
np.average(np.array(iterations))
]
def createMasterILP(cpx, params):
cpx.objective.set_sense(cpx.objective.sense.minimize)
numComponents = params.numComp
numScen = params.numScen
setupCost = params.setupCost
cPR = params.PR_cost
cCR = params.CR_cost
kesi = params.kesi
"""
cCR=[]
cPR=[]
kesi=[]
for i in range(numComponents):
cCR.append((i+1)*2)
cPR.append(1)
kesi.append(0)
if i == 0:
kesi[i] = 1
"""
#variables
#for x
varNameX = []
x = []
for i in range(numComponents):
varNameX.append("x" + str(i))
x.append(cpx.variables.get_num())
cpx.variables.add(obj=[cPR[i]],
lb=[0.0],
ub=[1.0],
types=["B"],
names=[varNameX[i]])
params.x = x
#for sita
varNameSita = "sita"
sita = cpx.variables.get_num()
cpx.variables.add(obj=[1.0], lb=[-100000.0], names=[varNameSita])
params.sita = sita
#for z
varNameZ = "z"
cpx.variables.add(obj=[setupCost],
lb=[0.0],
ub=[1.0],
types=["B"],
names=[varNameZ])
#constraints
for i in range(numComponents):
cpx.linear_constraints.add(
lin_expr=[cplex.SparsePair([varNameX[i]], [1.0])],
senses=["G"],
range_values=[0.0],
rhs=[kesi[i]])
for i in range(numComponents):
cpx.linear_constraints.add(lin_expr=[
cplex.SparsePair([varNameX[i], varNameZ], [
-1.0,
1.0,
])
],
senses=["G"],
range_values=[0.0],
rhs=[0])
def chevy(self):
w = self.w
######### Master Problem ###########
M = cplex.Cplex()
# Parameters
var = list(range(len(w)))
alpha = 1.0
init_pi = sum(w) / 150
epsilon = 0.1
# decision varialbes types=["C"]*len(var)
M.variables.add(obj=[1] * len(var),
names=['x_' + str(i) for i in var],
lb=[0] * len(var))
M.variables.add(obj=[-init_pi], names='z', lb=[0])
M.variables.add(names=['y_' + str(i) for i in list(range(len(w)))],
lb=[0] * len(w))
# pattern constraints
vals = np.zeros((len(w), len(var)))
np.fill_diagonal(vals, 1)
M.linear_constraints.add(lin_expr=[
cplex.SparsePair(ind=['x_' + str(j)
for j in var] + ['y_' + str(i)] + ['z'],
val=list(vals[i]) + [-1.0] + [-1.0])
for i in range(len(w))
],
senses=["G" for i in w],
rhs=[0 for i in w])
# chebyshev constraint
M.linear_constraints.add(lin_expr=[
cplex.SparsePair(
ind=['x_' + str(j)
for j in var] + ['y_' + str(i)
for i in range(len(w))] + ['z'],
val=[1.0
for k in var] + [1.0
for l in w] + [alpha * len(w)**(1 / 2)])
],
senses=["G"],
rhs=[1.0])
M.objective.set_sense(M.objective.sense.minimize)
M.write('cheby.lp')
ite = 0
while True:
ite += 1
# M.write('cheby_m.lp')
M.set_log_stream(None)
M.set_error_stream(None)
M.set_warning_stream(None)
M.set_results_stream(None)
# M.write('cheby.lp')
self.chevy_M = M
M.solve()
v = [
pie for pie in M.solution.get_dual_values(list(range(len(w))))
]
# S.objective.set_linear(list(zip(list(range(len(w))), price)))
# # S.write('cheby_s.lp')
# S.set_log_stream(None)
# S.set_error_stream(None)
# S.set_warning_stream(None)
# S.set_results_stream(None)
# S.solve()
S_obj, sol = binpacking.KnapsackBnB(v, w, W)
print(sol)
if M.solution.get_objective_value(
) < epsilon * M.solution.get_values('z'):
break
if S_obj < 1 + 1.0e-6:
newsub = sol
idx = M.variables.get_num()
M.variables.add(obj=[1.0])
M.linear_constraints.set_coefficients(
list(zip(list(range(len(w))), [idx] * len(var), newsub)))
var.append(idx)
else:
new_pi = M.solution.get_dual_values()
M.objective.set_linear('z', -sum(new_pi))
M.variables.set_types(
list(zip(var, [M.variables.type.continuous] * len(var))))
M.solve()
self.chevy_M = M
self.chevy_result = [
'Separation %s' % (self.sep), ite, mt, st, tt, mt / (st + mt),
solutions,
np.average(np.array(iterations))
]
def setproblemdata(p,
Dual=set_dual,
C=set_C,
kernel=set_kernel,
degree=set_degree,
gamma=set_gamma):
if Dual == False:
print("Setting primal problem")
p.set_problem_name("SVMIP1_HM")
p.objective.set_sense(p.objective.sense.minimize)
my_colnames = [["w" + str(i) for i in range(1, X_train.shape[1] + 1)],
["b"],
["z" + str(i) for i in range(1, X_train.shape[0] + 1)]]
p.variables.add(types=[p.variables.type.continuous] *
len(my_colnames[0]),
names=my_colnames[0])
qmat = MatrixToList(np.identity(X_train.shape[1]))
p.objective.set_quadratic(qmat)
p.variables.add(obj=[0], types=p.variables.type.continuous, names="b")
p.variables.add(obj=[C] * len(my_colnames[2]),
types=[p.variables.type.binary] * len(my_colnames[2]),
names=my_colnames[2])
coefs = []
for i in range(X_train.shape[0]):
coefs.append([y_train[i] * X_train[i], y_train[i]])
coefs[i][0] = coefs[i][0].tolist()
wlist = my_colnames[0]
for n in range(X_train.shape[0]):
inds = flatten([wlist, "b"])
fcoefs = flatten(coefs[n])
p.indicator_constraints.add(indvar=my_colnames[2][n],
complemented=1,
rhs=1.0,
sense='G',
lin_expr=cplex.SparsePair(ind=inds,
val=fcoefs))
elif Dual == True:
print("Setting dual problem")
p.set_problem_name("SVMIP2_HM")
p.objective.set_sense(p.objective.sense.minimize)
my_colnames = [["a" + str(i) for i in range(1, X_train.shape[0] + 1)],
["b"],
["z" + str(i) for i in range(1, X_train.shape[0] + 1)]]
#Set the upper bound of a to "C" value
p.variables.add(types=[p.variables.type.continuous] *
len(my_colnames[0]),
names=my_colnames[0],
lb=[0] * len(my_colnames[0]),
ub=[C] * len(my_colnames[0]))
Kmat = Gram_Matrix(Kernel=kernel,
X_set=X_train,
Degree=degree,
Gamma=set_gamma)
Q = np.zeros(shape=(Kmat.shape[0], Kmat.shape[1]))
for i in range(Q.shape[0]):
for j in range(Q.shape[1]):
Q[i, j] = y_train[i] * y_train[j] * Kmat[i, j]
qmat = MatrixToList(Q)
p.objective.set_quadratic(qmat)
p.variables.add(obj=[0], types=p.variables.type.continuous, names="b")
p.variables.add(obj=[C] * len(my_colnames[2]),
types=[p.variables.type.binary] * len(my_colnames[2]),
names=my_colnames[2])
coefs = []
for i in range(X_train.shape[0]):
coefs.append([y_train[i] * Kmat[i, i] * y_train, y_train[i]])
coefs[i][0] = coefs[i][0].tolist()
alist = my_colnames[0]
for n in range(X_train.shape[0]):
inds = flatten([alist, "b"])
fcoefs = flatten(coefs[n])
p.indicator_constraints.add(indvar=my_colnames[2][n],
complemented=1,
rhs=1.0,
sense='G',
lin_expr=cplex.SparsePair(ind=inds,
val=fcoefs))
OptimizeProblem.variables.add(names=["s" + str(j) for j in range(slen * tc)], obj=s_obj,
types=[OptimizeProblem.variables.type.binary] * slen * tc)
OptimizeProblem.variables.add(names=["e" + str(j) for j in range(slen * (tc - 1))], obj=e_obj,
types=[OptimizeProblem.variables.type.continuous] * slen * (tc - 1))
OptimizeProblem.variables.add(names=["v" + str(j) for j in range(slen * (tc - 1))], obj=v_obj,
types=[OptimizeProblem.variables.type.continuous] * slen * (tc - 1))
OptimizeProblem.variables.add(names=["slack" + str(j) for j in range(2)], obj=slack_obj,
lb=np.zeros(2),
types=[OptimizeProblem.variables.type.continuous] * 2)
Variables_Num = OptimizeProblem.variables.get_num()
Variables_Name = OptimizeProblem.variables.get_names()
############# add equition constraints
for j in range(row_Eq):
OptimizeProblem.linear_constraints.add(lin_expr=[cplex.SparsePair(ind=[var for var in Variables_Name[0:-2]],val=Aeq[j, :])], rhs=[b_Eq[j]], senses=['E'],
names=['Eq' + str(j)])
# lin_expr=[cplex.SparsePair(ind=[var for var in Variables_Name[0:-2]],
# val=Aeq[j, :])], rhs=[b_Eq[j]], senses=['E'], names=['Eq' + str(j)])
############# add inequition constraints
for j in range(row_Ineq):
OptimizeProblem.linear_constraints.add(
lin_expr=[cplex.SparsePair(ind=[var for var in Variables_Name],
val=Aineq[j, :])], rhs=[b_Ineq[j]], senses=['L'], names=['Ineq' + str(j)])
# Solve the model and print the answer
OptimizeProblem.objective.set_sense(OptimizeProblem.objective.sense.maximize)
OptimizeProblem.solve()
Results = OptimizeProblem.solution.get_values()
Xvalues = Results[0:xlen * tc]
def patternGenerationMIP2(inp,
alphaI,
mainClass,
otherClass,
timeLimit=60,
solLimit=9999,
withPrinting=True,
display=4):
'''
Implementation aimed at minimizing the number of uncovered observations.
'''
nMain = len(mainClass)
nOther = len(otherClass)
nSupport = len(inp.A2[0])
n = len(inp.support)
if (2 * n != nSupport):
print("problem in MIP2")
exit(156)
alphaSet = [k for k in range(nSupport) if inp.A2[alphaI][k] == 1]
cpx = cplex.Cplex()
# define obj function direction
cpx.objective.set_sense(cpx.objective.sense.minimize)
# define variables x_j
cpx.variables.add(obj=[0] * nSupport,
lb=[0] * nSupport,
ub=[1] * nSupport,
types=["B"] * nSupport)
# define variables y_i
cpx.variables.add(obj=[1.0] * nMain,
lb=[0.0] * nMain,
ub=[n] * nMain,
types=["C"] * nMain)
# variables w_i
cpx.variables.add(obj=[0] * nOther,
lb=[0.0] * nOther,
ub=[1.0] * nOther,
types=["C"] * nOther)
# variable d
cpx.variables.add(obj=[0.0], lb=[1.0], ub=[n], types=["C"])
# create indexes (progressive values. Each var needs to have a unique identifier)
x_var = range(nSupport)
y_var = range(nSupport, nSupport + nMain)
w_var = range(nSupport + nMain, nSupport + nMain + nOther)
d_var = range(nSupport + nMain + nOther, nSupport + nMain + nOther + 1)
# pattern degree "d"
index = [x_var[j] for j in alphaSet]
value = [1.0 for j in alphaSet]
index.append(d_var[0])
value.append(-1.0)
d_constr = cplex.SparsePair(ind=index, val=value)
cpx.linear_constraints.add(lin_expr=[d_constr], senses=["E"], rhs=[0.0])
# covering constraint
progr = 0
for i in mainClass:
index = [x_var[j] for j in alphaSet]
value = [inp.A2[i][j] for j in alphaSet]
index.append(y_var[progr])
value.append(1.0)
index.append(d_var[0])
value.append(-1.0)
covering_constr = cplex.SparsePair(ind=index, val=value)
cpx.linear_constraints.add(lin_expr=[covering_constr],
senses=["G"],
rhs=[0.0])
progr += 1
# fuzziness constraint 1
progr = 0
for i in otherClass:
index = [x_var[j] for j in alphaSet]
value = [inp.A2[i][j] for j in alphaSet]
index.append(w_var[progr])
value.append(-1.0)
index.append(d_var[0])
value.append(-1.0)
fuzziness_constr = cplex.SparsePair(ind=index, val=value)
cpx.linear_constraints.add(lin_expr=[fuzziness_constr],
senses=["L"],
rhs=[-1.0])
progr += 1
# fuzziness constraint 2
index = [w_var[i] for i in range(nOther)]
value = [1.0 for i in range(nOther)]
max_fuzziness = cplex.SparsePair(ind=index, val=value)
cpx.linear_constraints.add(lin_expr=[max_fuzziness],
senses=["L"],
rhs=[PHI * nOther])
try:
cpx.parameters.mip.interval.set(100) # how often to print info
cpx.parameters.timelimit.set(timeLimit)
cpx.parameters.mip.limits.solutions.set(solLimit)
cpx.parameters.mip.display.set(display)
cpx.solve()
except CplexSolverError as e:
print("Exception raised during solve: " + e)
else:
# get solution
solution = cpx.solution
#if withPrinting:
nCovered = solution.get_objective_value()
#print ("*** *** *** ub[{0:4d}] = {1:10.2f} with solution status = {2:20s}".\
# format(0, nCovered, solution.status[solution.get_status()]))
# get pattern and sign
pattern = []
sign = []
for j in range(n):
if solution.get_values(
x_var[j]
) > 1.0 - cpx.parameters.mip.tolerances.integrality.get():
pattern.append(inp.support[j])
sign.append(inp.Abin[alphaI][inp.support[j]])
for j in range(n, nSupport):
if solution.get_values(
x_var[j]
) > 1.0 - cpx.parameters.mip.tolerances.integrality.get():
pattern.append(inp.support[j - n])
sign.append(inp.Abin[alphaI][inp.support[j - n]])
'''
print("PATTERN : ", pattern)
print("SIGN : ", sign)
input("aka")
'''
# remove covered point of main class
# VERIFY
ySolNeg = [] # points not covered when y_i > 0
for i in range(nMain):
if solution.get_values(
y_var[i]) > cpx.parameters.mip.tolerances.integrality.get(
):
ySolNeg.append(mainClass[i])
#print("Number of UNCOVERED points of MAIN class : ", len(ySolNeg))
#print("List of uncovered points ", ySolNeg)
nUncovered = 0
for i in mainClass:
if [inp.Abin[i][k] for k in pattern] != sign:
nUncovered += 1
if len(ySolNeg) > 0 and i not in ySolNeg:
print("discrepancy with cplex ... ")
print("y({0}) = 1".format(i))
print("point ", inp.Abin[i])
exit(156)
#print ("Nr. uncovered from cplex vs manual check", len(ySolNeg), nUncovered)
if (len(ySolNeg) != nUncovered):
print("check here h1")
exit(134)
ySol = [] # Rem: y_i = 0 ==> observation "i" is not covered
for i in range(nMain):
if solution.get_values(
y_var[i]) < cpx.parameters.mip.tolerances.integrality.get(
):
ySol.append(mainClass[i])
mainClass = [x for x in mainClass if x not in ySol]
return mainClass, pattern, sign, nCovered
