def solve(self): """ """ # Turn off display and heuristics grb.setParam('OutputFlag', 0) grb.setParam('Heuristics', 0) # Open log file logfile = open(self.tmp+'gurobi.log', 'w') # Pass data into my callback function self.model._lastiter = -grb.GRB.INFINITY self.model._lastnode = -grb.GRB.INFINITY self.model._logfile = logfile self.model._vars = self.model.getVars() # Solve model and capture solution information self.model.optimize(mycallback) # Close log file logfile.close() print('') print('Optimization complete') if self.model.SolCount == 0: print('No solution found, optimization status = %d' % self.model.Status) sys.exit(0) else: print('Solution found, objective = %g' % self.model.ObjVal) x_optimal = self.x.getAttr("x").tolist() z_optimal = self.z.getAttr("x").tolist() self.optimal_edges = [e for i,e in enumerate(self.edges) if x_optimal[i]>0.8] self.roots = [self.nodes[ind] for i,ind in enumerate(self.rindex) if z_optimal[i]<0.2] return
def __init__(self, mip=True, msg=True, timeLimit=None, epgap=None, **solverParams): """ Initializes the Gurobi solver_type. @param mip: if False the solver_type will solve a MIP as an LP @param msg: displays information from the solver_type to stdout @param timeLimit: sets the maximum time for solution @param epgap: sets the integer bound gap """ LpSolver.__init__(self, mip, msg) self.timeLimit = timeLimit self.epgap = epgap self.solveTime = 0.0 # set the output of gurobi if not self.msg: gurobipy.setParam("OutputFlag", 0) # set the gurobi parameter values for key, value in solverParams.items(): gurobipy.setParam(key, value)
def main(): setParam("LogFile", "/tmp/gurobi.log") for g in gen_benchmark_digraphs(): success, edgelist_per_cycle = get_all_cycles(g, cutoff=10000000) if not success: continue # too many simple cycles solve_cm(g, edgelist_per_cycle)
def __init__(self, mip=True, msg=True, timeLimit=None, epgap=None, **solverParams): """ Initializes the Gurobi solver. @param mip: if False the solver will solve a MIP as an LP @param msg: displays information from the solver to stdout @param timeLimit: sets the maximum time for solution @param epgap: sets the integer bound gap """ LpSolver.__init__(self, mip, msg, timeLimit=timeLimit, gapRel=epgap) #set the output of gurobi if not self.msg: gurobipy.setParam("OutputFlag", 0) # TODO: this does not follow the solvers interface # it solverParams should go to LpSolver # and have uniform naming # we should still leave this as a possibility # set the gurobi parameter values for key, value in solverParams.items(): gurobipy.setParam(key, value)
def __init__(self, mip=True, msg=True, timeLimit=None, epgap=None, gapRel=None, warmStart=False, logPath=None, **solverParams): """ :param bool mip: if False, assume LP even if integer variables :param bool msg: if False, no log is shown :param float timeLimit: maximum time for solver (in seconds) :param float gapRel: relative gap tolerance for the solver to stop (in fraction) :param bool warmStart: if True, the solver will use the current value of variables as a start :param str logPath: path to the log file :param float epgap: deprecated for gapRel """ if epgap is not None: warnings.warn("Parameter epgap is being depreciated for gapRel") if gapRel is not None: warnings.warn("Parameter gapRel and epgap passed, using gapRel") else: gapRel = epgap LpSolver.__init__(self, mip=mip, msg=msg, timeLimit=timeLimit, gapRel=gapRel, logPath=logPath, warmStart=warmStart) #set the output of gurobi if not self.msg: gurobipy.setParam("OutputFlag", 0) # set the gurobi parameter values for key,value in solverParams.items(): gurobipy.setParam(key, value)
def deduce_relevances(features, knowledgebase, regularization=1): gb.setParam('OutputFlag', 0) m = gb.Model('rar') solver_variables = {} for feature in features: solver_variables[feature] = m.addVar( name=feature, vtype=gb.GRB.CONTINUOUS, lb=0) vars_average = m.addVar(name='s', vtype=gb.GRB.CONTINUOUS) vars_sum = sum(solver_variables.values()) m.setObjective( vars_sum + regularization * _squared_dist( solver_variables.values(), vars_average), gb.GRB.MINIMIZE) m.addConstr(vars_average == (vars_sum / len(features))) for subset in knowledgebase: objective_vars = [solver_variables[f] for f in subset["features"]] objective_sum = sum(objective_vars) m.addConstr(objective_sum >= subset["score"]["relevance"]) m.optimize() max_x = max(1, max([v.x for v in m.getVars() if v.varName in features])) return { v.varName: v.x / max_x for v in m.getVars() if v.varName in features }
def run_IIS(g, loops, ub): from gurobipy import GRB, LinExpr, setParam from grb_set_cover import build_ilp #setParam("OutputFlag", 1) setParam("IISMethod", 0) #success, loops = get_all_cycles(g, cutoff=13747) # if all loops are needed #assert success, 'Too many cycles' loops = sorted( loops) # loops needs to be a list, and sorting for stability m, vrs = build_ilp(g, loops) a, y = [], [] for u, v, d in g.edges_iter(data=True): a.append(d['weight']), y.append(vrs[u, v]) lhs = LinExpr(a, y) m.addConstr(lhs, GRB.LESS_EQUAL, ub - 1) #m.update() #m.write('JacobsenInfeas.lp') m.computeIIS() keep = [ i for i, cn in enumerate(m.getConstrs()) if cn.getAttr('IISCONSTR') ] assert keep[-1] == len(loops) # The last one is the dummy constraint keep.pop() #print(keep) cyc_subset = [loops[i] for i in keep] #m, _ = build_ilp(g, cyc_subset) #m.update() #m.write('JacobsenMinimal.lp') _, obj = solve_cm(g, cyc_subset) print('Obj:', obj)
def __init__(self, initialSolution, constraints, findConstraints, numberOfCommodities, verbose=False): ''' create the necessary data structure to correctly handle the column generation procedure Parameters ---------- initialSolution : list list of initial solutions for each commodity (suppose that commodity k as solution initialSolution[k]) constraints : list of sets findConstraints : dictionnary links each edge in the graph to the constraint it goes through numberOfCommodities : int ''' if not verbose: gurobipy.setParam("LogToConsole", 0) self.model = gurobipy.Model("MasterProblem") self.constraints = constraints self.findConstraints_edges = findConstraints self.commodities = np.arange(numberOfCommodities) self.__setup(initialSolution) self.indexes = {x: 0 for x in self.commodities} self.stats = {"variablesAdded": [0 for x in self.commodities]}
def GbpACLP2(): # Cost Matrix Dij = np.random.randint(1, 20, 16) Dij = Dij.reshape(4, 4) # Minimum Separation Distance r = 10 service_nodes = range(len(Dij)) # 2. Create Model, Set MIP Focus, Add Variables, & Update Model m = gbp.Model(" -- ACLP2 -- ") # Set MIP Focus to 2 for optimality gbp.setParam('MIPFocus', 2) # Add Service Decision Variables serv_var = [] for orig in service_nodes: serv_var.append( m.addVar(vtype=gbp.GRB.BINARY, ub=1, name='x' + str(orig + 1))) # Update Model Variables m.update() # 4. Set Objective Function --> Maximize sited facilities with no overlap (r) m.setObjective(gbp.quicksum(serv_var[dest] for dest in service_nodes), gbp.GRB.MAXIMIZE) # 5. Add Constraints #Add Adjacency Pairwise Constraints for orig in service_nodes: for dest in service_nodes: if orig != dest and Dij[orig][dest] < r: m.addConstr((serv_var[orig] + serv_var[dest] <= 1)) else: pass # 6. Optimize and Print Results try: m.optimize() except Exception as e: print ' ################################################################' print ' < ISSUE : ', e, ' >' print ' ################################################################' t2 = time.time() - t1 print '**********************************************************************' selected = [] for v in m.getVars(): if v.x > 0: var = '%s' % v.VarName selected.append(v.x) print ' | ', var print ' | Selected Facility Locations ------------------------ ^^^^ ' print ' | Minimum Distance (r) ------------------------------- ', r print ' | Service Nodes -------------------------------------- ', len( service_nodes) print ' | Candidate Facilities Sited without (r) overlap ----- ', len( selected) print ' | Real Time to Optimize (sec.) ----------------------- ', t2 print '*****************************************************************************************' m.write("path.lp")
def available(self): """True if the solver is available""" try: gurobipy.setParam("_test", 0) except gurobipy.GurobiError as e: warnings.warn('GUROBI error: {}.'.format(e)) return False return True
def main(): setParam('LogFile', '/tmp/gurobi.log') #setParam('OutputFlag', 0) setParam('LogToConsole', 0) # solve_digraphs_as_rectangular_bipartite() real_main(use_min_degree=False) real_main(use_min_degree=True)
def GbpPdefSum(): # Distance Matrix --> 20x20 Cij = np.random.randint(100, 1000, 400) Cij = Cij.reshape(20, 20) # Service Nodes service_nodes = range(len(Cij)) # 2. Create Model, Set MIP Focus, Add Variables, & Update Model mPDPsum = gbp.Model(' -- p-Defense-Sum -- ') # Set MIP Focus to 2 for optimality gbp.setParam('MIPFocus', 2) # 3. Add Variables # Add Decision Variables # Service Facility IxJ serv_var = [] for dest in service_nodes: serv_var.append( mPDPsum.addVar(vtype=gbp.GRB.BINARY, ub=1, name='y' + str(dest + 1))) # Update Model Variables mPDPsum.update() # 4. Set Objective --> Maximize Sum of Distance mPDPsum.setObjective( gbp.quicksum(Cij[orig][dest] * serv_var[orig] for orig in service_nodes for dest in service_nodes), gbp.GRB.MAXIMIZE) # 5. Add Constriants # Add Facility Constraint --> [p=2] mPDPsum.addConstr( gbp.quicksum(serv_var[dest] for dest in service_nodes) == 2) # 6. Optimize and Print Results try: mPDPsum.optimize() except Exception as e: print ' ################################################################' print ' < ISSUE : ', e, ' >' print ' ################################################################' t2 = time.time() - t1 mPDPsum.write('path.lp') print '\n*************************************************************************' selected = [] for v in mPDPsum.getVars(): if v.x > 0: var = '%s' % v.VarName selected.append(var) print ' | ', var print ' | Selected Facility Locations -------------- ^^^^ ' print ' | Candidate Facilities [p] ----------------- ', len(selected) val = mPDPsum.objVal print ' | Objective Value -------------------------- ', val print ' | Real Time to Optimize (sec.) ------------- ', t2 print '*************************************************************************' print 'p-Defense-Sum Location Problem'
def main(): setParam("LogFile", "/tmp/gurobi.log") for g in gen_benchmark_digraphs(): #if g.graph['name'] == 'Problem 10 (opt=12)': #if g.graph['name'] != 'Problem 8 (opt=5)': #if g.graph['name'] != 'Subproblem 8 (opt=3)': # continue STATISICS.clear() # Problem 10 #----------- # Sparse cut #g.remove_edge(38, 36) #g.remove_edge(39, 34) #----------- # Peeling off the DAG of the bypasses #dag_connecting = [ (11,4), (17,16), (1,20), (26,25), (12,29), (35,34), # (21,38), (44,43), (30,48), (54,53), (39,57) ] #for e in dag_connecting: # g.remove_edge(*e) #----------- # Breaking the small bypasses #bypass_breakers = [ (17,11), (26,20), (35,29), (44,38), (54,48) ] #for e in bypass_breakers: # g.remove_edge(*e) #----------- # Problem 8 #g.remove_edge(4,6) #g.remove_edge(24,16) #g.remove_edge(17,22) #g.remove_edge(21,20) #g.remove_edge(2,6) #g.remove_edge(24,26) #iteratively_remove_runs_and_bypasses(g) #g.remove_edge(2,17) #g.remove_edge(8,27) #g.remove_edge(27,7) #g.remove_edge(8,14) # These latter two are insane but still OK #g.remove_edge(18,21) #plot(g, prog='sfdp') #----- #from utils import deserialize #g = deserialize('data/JacobsenILOSimpBounds_as_DAG.pkl.gz') #orig_input = deserialize('data/JacobsenILOSimpBounds_as_DAG.pkl.gz') # And toggle comment on the # <- lines !!! #----- orig_input = deepcopy(g) # <- simplify(g) print('Info on the original input:') print(orig_input.graph['name']) # <- print('Nodes:', orig_input.number_of_nodes()) print('Edges:', orig_input.number_of_edges()) print('Loops:', len(list(nx.simple_cycles(orig_input)))) # <- if 'max cycles' in STATISICS: print('Loop budget:', STATISICS['max cycles']) print('Cutoff:', STATISICS['max cutoff']) plot(orig_input, prog='sfdp')
def solve(self): """ """ grb.setParam('OutputFlag', 0) grb.setParam('Heuristics', 0) self.model.optimize() self.u_opt = np.array([int(self.u[i].getAttr("x")>0.5) \ for i in self.iter_EV]) self.W_opt = np.zeros(shape=(len(self.s),self.T),dtype=int) self.P_opt = np.zeros(shape=(len(self.s),self.T)) for i in self.iter_EV: for j in self.iter_trem: self.W_opt[i,j] = int(self.W[(i,j)].getAttr("x")>0.5) self.P_opt[i,j] = self.P[(i,j)].getAttr("x") return
def __init__(self, mip_gap: float = 0.1, timeout: Optional[int] = None, enable_logging: bool = False) -> None: """ Initialize the solver Parameters ---------- mip_gap: The gap used to determine when a solution to the mip has been found timeout: The time allowed for solving enable_logging: Whether gurobi logs should be shown """ self.mip_gap = mip_gap self.timeout = timeout gurobipy.setParam("OutputFlag", enable_logging)
def main(): if len(sys.argv) < 2: print('No instance specified!', file=sys.stderr) sys.exit(1) input_file = sys.argv[1] if len(sys.argv) < 3: configuration = 'ppa_star_hplus' else: configuration = sys.argv[2] constrained = True if len(sys.argv) < 4: total_amount_of_fluid = 10 elif sys.argv[3] == 'unconstrained': constrained = False total_amount_of_fluid = 0 else: total_amount_of_fluid = int(sys.argv[3]) if configuration not in solver_support.configs: print('Specified configuration name {0} not recognized'.format( configuration)) print('Available configurations are:') for cfg in configs: print('\t{0}'.format(cfg)) sys.exit(1) print('Configuration {0} is active'.format(configuration)) #if len(sys.argv) < 4 : # output_redirect = sys.stdout #else : # output_redirect = open( sys.argv[3], 'w' ) # set Gurobi parameters setParam('LogFile', '') setParam('LogToConsole', 0) setParam('OutputFlag', 0) logging.basicConfig( level='INFO', #level='DEBUG', format='%(asctime)s %(levelname)-8s %(message)s', stream=sys.stdout) task = hbw3.create_prob_from_file(input_file, total_amount_of_fluid, constrained) task.s0.check_valid() logging.info('Task initial state valid? %s' % task.s0.valid) if len(sys.argv) > 4: task.validate(sys.argv[4:]) sys.exit(0) solver_support.solve(configuration, task)
def main(): if len(sys.argv) < 2: print('Missing argument: input problem!', file=sys.stderr) sys.exit(1) instance = sys.argv[1] if not os.path.exists(instance): print('Could not find {0}'.format(instance), file=sys.stderr) sys.exit(1) if len(sys.argv) < 3: configuration = 'ppa_star_hplus' else: configuration = sys.argv[2] if configuration not in solver_support.configs: print('Specified configuration name {0} not recognized'.format( configuration)) print('Available configurations are:') for cfg in solver_support.configs: print('\t{0}'.format(cfg)) sys.exit(1) print('Configuration {0} is active'.format(configuration)) if len(sys.argv) < 4: output_redirect = sys.stdout else: output_redirect = open(sys.argv[3], 'w') # set Gurobi parameters setParam('LogFile', '') setParam('LogToConsole', 0) setParam('OutputFlag', 0) logging.basicConfig( level='INFO', #level='DEBUG', format='%(asctime)s %(levelname)-8s %(message)s', stream=output_redirect) task = parse_instance(instance) solver_support.solve(configuration, task)
def GuTransProb(Cij, Si, Dj): t1 = time.time() # Data Cij = Cij.reshape(matrix_rows,matrix_cols) Si = Si.reshape(matrix_rows,1) Dj = Dj.reshape(matrix_cols,1) # Indices & Variable Names supply_nodes = len(Cij) demand_nodes = len(Cij[0]) supply_nodes_range = range(len(Cij)) demand_nodes_range = range(len(Cij[0])) all_nodes_len = len(Cij) * len(Cij[0]) ALL_nodes_range = range(all_nodes_len) # Create Model, Set MIP Focus, Add Variables, & Update Model m = gbp.Model(' -- The Transportation Problem -- ') # Set MIP Focus to 2 for optimality gbp.setParam('MIPFocus', 2) descision_var = [] for orig in supply_nodes_range: descision_var.append([]) for dest in demand_nodes_range: descision_var[orig].append(m.addVar(vtype=gbp.GRB.CONTINUOUS, obj=Cij[orig][dest], name='x'+str(orig+10001)+'_'+str(dest+10001))) # Update Model Variables m.update() # Set Objective Function m.setObjective(gbp.quicksum(Cij[orig][dest]*descision_var[orig][dest] for orig in supply_nodes_range for dest in demand_nodes_range), gbp.GRB.MINIMIZE) # Add Supply Constraints for orig in supply_nodes_range: m.addConstr(gbp.quicksum(descision_var[orig][dest] for dest in demand_nodes_range) - Si[orig] <= 0) # Add Demand Constraints for orig in demand_nodes_range: m.addConstr(gbp.quicksum(descision_var[dest][orig] for dest in supply_nodes_range) - Dj[orig] >= 0) # Optimize and Print Results m.optimize() m.write('path.lp') t2 = time.time()-t1 print '******************************************************************************' print '| From SUPPLY Facility to DEMAND Facility x(Si)_(Dj) shipping # of units ' print '| ↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓' print '|' selected = {} Closed = [] for v in m.getVars(): var = '%s' % v.VarName if v.x > 0: units = '%i' % v.x selected[var] = units print '| Supply Facility #', var[1:6], 'is shipping', units, \ 'units to Demand Facility #', var[-5:] else: Closed.append([var[1:6], var[-5:]]) print '******************************************************************************' print ' | Objective Value --------------------- ', int(m.objVal) print ' | Supply Facilities ------------------- ', len(Si) print ' | Total Supply Units ------------------ ', Si.sum() print ' | Demand Facilites -------------------- ', len(Dj) print ' | Total Demand Units ------------------ ', Dj.sum() print ' | Total Potential Combinations -------- ', len(Si)*len(Dj) print ' | Actual Combinations ---------------- ', len(selected) print ' | Real Time to Optimize (sec.) -------- ', t2 print '******************************************************************************' print ' -- The Transportation Simplex with Gurobi --' print ' -- James Gaboardi, 2016 --'
class GUROBI(LpSolver): """ The Gurobi LP/MIP solver (via its python interface) The Gurobi variables are available (after a solve) in var.solverVar Constraints in constraint.solverConstraint and the Model is in prob.solverModel """ name = 'GUROBI' try: sys.path.append(gurobi_path) # to import the name into the module scope global gurobipy import gurobipy gurobipy.setParam("_test", 0) except: # FIXME: Bug because gurobi returns # a gurobi exception on failed imports def available(self): """True if the solver is available""" return False def actualSolve(self, lp, callback=None): """Solve a well formulated lp problem""" raise PulpSolverError("GUROBI: Not Available") else: def __init__(self, mip=True, msg=True, timeLimit=None, epgap=None, **solverParams): """ Initializes the Gurobi solver. @param mip: if False the solver will solve a MIP as an LP @param msg: displays information from the solver to stdout @param timeLimit: sets the maximum time for solution @param epgap: sets the integer bound gap """ LpSolver.__init__(self, mip, msg, timeLimit=timeLimit, gapRel=epgap) #set the output of gurobi if not self.msg: gurobipy.setParam("OutputFlag", 0) # TODO: this does not follow the solvers interface # it solverParams should go to LpSolver # and have uniform naming # we should still leave this as a possibility # set the gurobi parameter values for key, value in solverParams.items(): gurobipy.setParam(key, value) def findSolutionValues(self, lp): model = lp.solverModel solutionStatus = model.Status GRB = gurobipy.GRB # TODO: check status for Integer Feasible gurobiLpStatus = { GRB.OPTIMAL: constants.LpStatusOptimal, GRB.INFEASIBLE: constants.LpStatusInfeasible, GRB.INF_OR_UNBD: constants.LpStatusInfeasible, GRB.UNBOUNDED: constants.LpStatusUnbounded, GRB.ITERATION_LIMIT: constants.LpStatusNotSolved, GRB.NODE_LIMIT: constants.LpStatusNotSolved, GRB.TIME_LIMIT: constants.LpStatusNotSolved, GRB.SOLUTION_LIMIT: constants.LpStatusNotSolved, GRB.INTERRUPTED: constants.LpStatusNotSolved, GRB.NUMERIC: constants.LpStatusNotSolved, } if self.msg: print("Gurobi status=", solutionStatus) lp.resolveOK = True for var in lp.variables(): var.isModified = False status = gurobiLpStatus.get(solutionStatus, constants.LpStatusUndefined) lp.assignStatus(status) if status != constants.LpStatusOptimal: return status #populate pulp solution values for var, value in zip(lp.variables(), model.getAttr(GRB.Attr.X, model.getVars())): var.varValue = value # populate pulp constraints slack for constr, value in zip( lp.constraints.values(), model.getAttr(GRB.Attr.Slack, model.getConstrs())): constr.slack = value if not model.getAttr(GRB.Attr.IsMIP): for var, value in zip( lp.variables(), model.getAttr(GRB.Attr.RC, model.getVars())): var.dj = value #put pi and slack variables against the constraints for constr, value in zip( lp.constraints.values(), model.getAttr(GRB.Attr.Pi, model.getConstrs())): constr.pi = value return status def available(self): """True if the solver is available""" return True def callSolver(self, lp, callback=None): """Solves the problem with gurobi """ #solve the problem self.solveTime = -clock() lp.solverModel.optimize(callback=callback) self.solveTime += clock() def buildSolverModel(self, lp): """ Takes the pulp lp model and translates it into a gurobi model """ log.debug("create the gurobi model") lp.solverModel = gurobipy.Model(lp.name) log.debug("set the sense of the problem") if lp.sense == constants.LpMaximize: lp.solverModel.setAttr("ModelSense", -1) if self.timeLimit: lp.solverModel.setParam("TimeLimit", self.timeLimit) gapRel = self.optionsDict.get('gapRel') logPath = self.optionsDict.get('logPath') if gapRel: lp.solverModel.setParam("MIPGap", gapRel) if logPath: lp.solverModel.setParam("LogFile", logPath) log.debug("add the variables to the problem") for var in lp.variables(): lowBound = var.lowBound if lowBound is None: lowBound = -gurobipy.GRB.INFINITY upBound = var.upBound if upBound is None: upBound = gurobipy.GRB.INFINITY obj = lp.objective.get(var, 0.0) varType = gurobipy.GRB.CONTINUOUS if var.cat == constants.LpInteger and self.mip: varType = gurobipy.GRB.INTEGER var.solverVar = lp.solverModel.addVar(lowBound, upBound, vtype=varType, obj=obj, name=var.name) lp.solverModel.update() log.debug("add the Constraints to the problem") for name, constraint in lp.constraints.items(): #build the expression expr = gurobipy.LinExpr( list(constraint.values()), [v.solverVar for v in constraint.keys()]) if constraint.sense == constants.LpConstraintLE: relation = gurobipy.GRB.LESS_EQUAL elif constraint.sense == constants.LpConstraintGE: relation = gurobipy.GRB.GREATER_EQUAL elif constraint.sense == constants.LpConstraintEQ: relation = gurobipy.GRB.EQUAL else: raise PulpSolverError( 'Detected an invalid constraint type') constraint.solverConstraint = lp.solverModel.addConstr( expr, relation, -constraint.constant, name) lp.solverModel.update() def actualSolve(self, lp, callback=None): """ Solve a well formulated lp problem creates a gurobi model, variables and constraints and attaches them to the lp model which it then solves """ self.buildSolverModel(lp) #set the initial solution log.debug("Solve the Model using gurobi") self.callSolver(lp, callback=callback) #get the solution information solutionStatus = self.findSolutionValues(lp) for var in lp.variables(): var.modified = False for constraint in lp.constraints.values(): constraint.modified = False return solutionStatus def actualResolve(self, lp, callback=None): """ Solve a well formulated lp problem uses the old solver and modifies the rhs of the modified constraints """ log.debug("Resolve the Model using gurobi") for constraint in lp.constraints.values(): if constraint.modified: constraint.solverConstraint.setAttr( gurobipy.GRB.Attr.RHS, -constraint.constant) lp.solverModel.update() self.callSolver(lp, callback=callback) #get the solution information solutionStatus = self.findSolutionValues(lp) for var in lp.variables(): var.modified = False for constraint in lp.constraints.values(): constraint.modified = False return solutionStatus
http://www.apache.org/licenses/LICENSE-2.0 Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License. ''' import tempfile from collections import OrderedDict from .solver import Solver, Solution, Status, VarType from gurobipy import setParam, Model as GurobiModel, GRB, quicksum, read setParam("OutputFlag", 0) status_mapping = {GRB.OPTIMAL: Status.OPTIMAL, GRB.UNBOUNDED: Status.UNBOUNDED, GRB.INFEASIBLE: Status.INFEASIBLE} class GurobiSolver(Solver): """ Implements the solver interface using gurobipy. """ def __init__(self): Solver.__init__(self) self.problem = GurobiModel() def __getstate__(self):
import gurobipy as gp from gurobipy import GRB from math import ceil debug = False # debug = True try: # Create a new model m = gp.Model("level2") # This is required to allow for multiple train type. If the default value (-1) is used, we get error: # Error code 10020: Objective Q not PSD (diagonal adjustment of 2.3e+02 would be required). Set NonConvex parameter to 2 to solve model. # This is not in the base level 2 model. gp.setParam("NonConvex", 2) #### Initialize Data: #### ''' ---- Init data for locomotives ---- loco_types: The type of locomotive. Corresponds to a train type loco_Cfix: Fixed cost of a loco. i.e. cost to purchase one loco loco_Ckm: Cost of loco travelling 1km loco_speed: Average speed of locomotive e.g. locomotive 'a' costs 1000 to purchase and 2 per km to run, avg speed of 30km/h Note: I have set the fixed cost to zero since the locos are already owned, and this does not affect daily operation as much. The millions of dollars in fixed cost overshadows the cost of operating. ''' loco_types, loco_Cfix, loco_Ckm, loco_speed = gp.multidict({ 'a': [1000, 2, 40],
def find_path_aux(g, start, end, edge_budget, node_budget, time_limit, verbose=True): # Problem parameters N = g.number_of_nodes() S = start T = end EB = edge_budget NB = node_budget grb.setParam('OutputFlag', verbose) if verbose: print '(N, S, T, EB, NB) =', ','.join(map(str, [N, S, T, EB, NB])) # Model init model = grb.Model("Orienteering") # Weights and variables w = dict() t = dict() m = dict() x = dict() u = dict() # Read node weights for i, d in g.nodes(data=True): u[i] = model.addVar(vtype=grb.GRB.INTEGER, name='u_'+str(i)) try: w[i] = d['w'] except KeyError: w[i] = 0 try: m[i] = d['m'] except KeyError: m[i] = 0 # Read edge weights if g.is_directed(): dg = g else: dg = g.to_directed() for i, j, d in dg.edges(data=True): try: t[i,j] = d['t'] except KeyError: t[i,j] = 0 obj = w[j] if i == S: obj = w[i] + w[j] name = 'x_' + str(i) + '_' + str(j) x[i,j] = model.addVar(obj=obj, vtype=grb.GRB.BINARY, name=name) model.modelSense = grb.GRB.MAXIMIZE model.update() RN = range(1, N+1) # Path starts at S and ends at T model.addConstr(grb.quicksum(x[S,j] for j in RN if (S, j) in x) == 1) model.addConstr(grb.quicksum(x[i,T] for i in RN if (i, T) in x) == 1) # No edges "entering" S or "leaving" T for i in RN: if (i, S) in x: model.addConstr(x[i,S] == 0) if (T, i) in x: model.addConstr(x[T,i] == 0) # "Flow conservation" constraints for k in RN: if k != S and k != T: model.addConstr( grb.quicksum(x[i,k] for i in RN if (i, k) in x) <= 1) model.addConstr( grb.quicksum(x[k,j] for j in RN if (k, j) in x) <= 1) model.addConstr( grb.quicksum(x[i,k] for i in RN if i != T and (i, k) in x) + grb.quicksum(-x[k,j] for j in RN if j != S and (k, j) in x) == 0) # Edge budget constraint model.addConstr(grb.quicksum(t[i,j]*x[i,j] for (i, j) in x) <= EB) # Node budget constraint model.addConstr(grb.quicksum(m[j]*x[i,j] for (i, j) in x) <= NB) # Subtour elimination constraints (1) for k in RN: if k != S: model.addConstr(u[k] >= 2) model.addConstr(u[k] <= N) model.addConstr(u[S] == 1) # Subtour elimination constraints (2) for (i, j) in x: if i != S and j != S: model.addConstr(u[i] - u[j] + (N-1)*x[i,j] <= N-2) model.update() # Solve model.setParam('TimeLimit', time_limit) model.optimize() # Decode solution if (model.status != grb.GRB.status.OPTIMAL and model.status != grb.GRB.status.TIME_LIMIT and model.status != grb.GRB.status.INTERRUPTED): obj = None path = None else: obj = model.objVal nxt = dict() for i in RN: for j in RN: if (i, j) in x and x[i,j].x == 1: nxt[i] = j path = [S] v = S while v != T: v = nxt[v] path.append(v) return (model.status, obj, path)
def GbpStPrimLP(): # Constants Aij = np.random.randint(5, 50, 25) Aij = Aij.reshape(5, 5) AijSum = np.sum(Aij) Cj = np.random.randint(10, 20, 5) CjSum = np.sum(Cj) Bi = np.random.randint(10, 20, 5) BiSum = np.sum(Bi) # Matrix Shape rows = range(len(Aij)) cols = range(len(Aij[0])) # Instantiate Model mPrimal_Standard_GUROBI = gbp.Model(" -- Standard Primal Linear Programming Problem -- ") # Set Focus to Optimality gbp.setParam("MIPFocus", 2) # Decision Variables desc_var = [] for dest in cols: desc_var.append([]) desc_var[dest].append(mPrimal_Standard_GUROBI.addVar(vtype=gbp.GRB.CONTINUOUS, name="y" + str(dest + 1))) # Surplus Variables surp_var = [] for orig in rows: surp_var.append([]) surp_var[orig].append(mPrimal_Standard_GUROBI.addVar(vtype=gbp.GRB.CONTINUOUS, name="s" + str(orig + 1))) # Update Model mPrimal_Standard_GUROBI.update() # Objective Function mPrimal_Standard_GUROBI.setObjective(gbp.quicksum(Cj[dest] * desc_var[dest][0] for dest in cols), gbp.GRB.MINIMIZE) # Constraints for orig in rows: mPrimal_Standard_GUROBI.addConstr( gbp.quicksum(Aij[orig][dest] * desc_var[dest][0] for dest in cols) - surp_var[orig][0] - Bi[orig] == 0 ) # Optimize try: mPrimal_Standard_GUROBI.optimize() except Exception as e: print " ################################################################" print " < ISSUE : ", e, " >" print " ################################################################" # Write LP file mPrimal_Standard_GUROBI.write("LP.lp") print "\n*************************************************************************" print " | Decision Variables" for v in mPrimal_Standard_GUROBI.getVars(): print " | ", v.VarName, "=", v.x print "*************************************************************************" val = mPrimal_Standard_GUROBI.objVal print " | Objective Value ------------------ ", val print " | Aij Sum -------------------------- ", AijSum print " | Cj Sum --------------------------- ", CjSum print " | Bi Sum --------------------------- ", BiSum print " | Matrix Dimensions ---------------- ", Aij.shape print " | Date/Time ------------------------ ", dt.datetime.now() print "*************************************************************************" print "-- Gurobi Standard Primal Linear Programming Problem --"
import os import gurobipy as grb from gurobipy import GRB grb.setParam('OutputFlag', 0) grb.setParam('LogFile', os.getenv("HOME") + '/gurobi.log') try: os.unlink('gurobi.log') except: pass def generate_basic_lp(model, add_to_existing=False): """docstring for generate_basic_lp""" # we first initialise the linear program if hasattr(model, 'lp') and add_to_existing: pass else: model.lp = grb.Model('LP_' + model.name) model.lp.modelSense = GRB.MAXIMIZE # reaction fluxes are the variables in the linear model # we take the objective coefficient from the corresponding reaction property, # which generally be non-zero for only the biomass reaction for reaction in model.reactions(): if reaction.reversible: var = model.lp.addVar(reaction.lower_bound,
cmpl = model.cbGet(GRB.Callback.BARRIER_COMPL) print('%d %g %g %g %g %g' % (itcnt, primobj, dualobj, priminf, dualinf, cmpl)) elif where == GRB.Callback.MESSAGE: # Message callback msg = model.cbGet(GRB.Callback.MSG_STRING) model._logfile.write(msg) if len(sys.argv) < 2: print('Usage: callback.py filename') quit() # Turn off display and heuristics gp.setParam('OutputFlag', 0) gp.setParam('Heuristics', 0) # Read model from file model = gp.read(sys.argv[1]) # Open log file logfile = open('cb.log', 'w') # Pass data into my callback function model._lastiter = -GRB.INFINITY model._lastnode = -GRB.INFINITY model._logfile = logfile
class RelevanceOptimizer: gb.setParam('OutputFlag', 0) def _calculate_single_feature_relevance(self, columns, relevances, cost_matrix=None): # New approach, keep class relevances separate if cost_matrix is not None: for index, df in relevances.items(): df.index = [index] dataframe = pd.concat(relevances.values) classes = {col: dataframe[col] for col in dataframe.columns} else: classes = {'-1': relevances} single_relevances = defaultdict(int) for class_col, class_scores in classes.items(): # print(class_col) m = gb.Model('rar') n = len(columns) max_score = max(class_scores) solver_variables = {} for col in columns: solver_variables[col] = m.addVar(name='x_' + col, vtype=gb.GRB.CONTINUOUS, lb=0, ub=max_score) vars_average = m.addVar(name='s', vtype=gb.GRB.CONTINUOUS) vars_sum = sum(solver_variables.values()) m.addConstr(vars_average == (vars_sum / n)) m.setObjective( vars_sum + self.__squared_dist(solver_variables.values(), vars_average), gb.GRB.MINIMIZE) m.update() for (subset, score) in class_scores.iteritems(): objective_vars = map(lambda col: solver_variables[col], subset) objective_sum = sum(objective_vars) m.addConstr(objective_sum >= score) m.optimize() var_max = max(map(lambda v: v.x, solver_variables.values())) class_result = { k: (v.x / var_max) for k, v in solver_variables.items() } for k, v in solver_variables.items(): single_relevances[k] += (v.x / var_max) * ( 1 if cost_matrix is None else cost_matrix[class_col][0]) # print(str(v.x / var_max) + ' weighted to ' + # str((v.x / var_max) * (1 if cost_matrix is None else cost_matrix[class_col][0]))) for k in single_relevances.keys(): single_relevances[k] /= (1 if cost_matrix is None else cost_matrix.iloc[0].sum()) return single_relevances def __squared_dist(self, variables, mean): return sum(map(lambda v: (v - mean) * (v - mean), variables))
def GbpApC(): # 1. Create Data # Distance Matrix Dij = np.random.randint(100, 1000, 25) Dij = Dij.reshape(5, 5) rows, cols = Dij.shape client_nodes = range(rows) service_nodes = range(cols) # 2. Create Model, Set MIP Focus, Add Variables, & Update Model mPACP = gbp.Model(" -- P-Anti-Center -- ") # Set MIP Focus to 2 for optimality gbp.setParam('MIPFocus', 2) # Add Client Decision Variables client_var = [] for orig in client_nodes: client_var.append([]) for dest in service_nodes: client_var[orig].append( mPACP.addVar(vtype=gbp.GRB.BINARY, obj=Dij[orig][dest], name='x' + str(orig + 1) + '_' + str(dest + 1))) # Add Service Decision Variables serv_var = [] for dest in service_nodes: serv_var.append([]) serv_var[dest].append( mPACP.addVar(vtype=gbp.GRB.BINARY, name='y' + str(dest + 1))) # Add Minimized Maximum Average Variable W = mPACP.addVar(vtype=gbp.GRB.CONTINUOUS, name='W') # Update Model Variables mPACP.update() # 3. Set Objective Function mPACP.setObjective(W, gbp.GRB.MAXIMIZE) # 4. Add Constraints #Add Assignment Constraints for orig in client_nodes: mPACP.addConstr( gbp.quicksum(client_var[orig][dest] for dest in service_nodes) == 1) # Add Opening Constraints for dest in service_nodes: for orig in client_nodes: mPACP.addConstr((serv_var[dest] - client_var[orig][dest] >= 0)) # Add Facility Constraint --> [p=2] mPACP.addConstr( gbp.quicksum(serv_var[dest][0] for dest in service_nodes) == 2) # Add Maximized Maximum Time Constraint for orig in client_nodes: mPACP.addConstr( gbp.quicksum(Dij[orig][dest] * client_var[orig][dest] for dest in service_nodes) - W >= 0) # 5. Optimize and Print Results try: mPACP.optimize() except Exception as e: print ' ################################################################' print ' < ISSUE : ', e, ' >' print ' ################################################################' mPACP.write('path.lp') print '\n*************************************************************************' selected = [] for v in mPACP.getVars(): if 'x' in v.VarName: pass elif 'W' in v.VarName: pass elif v.x > 0: var = '%s' % v.VarName selected.append(var) print ' | ', var print ' | Selected Facility Locations -------------- ^^^^ ' print ' | Candidate Facilities [p] ----------------- ', len(selected) val = mPACP.objVal print ' | Objective Value(miles) ------------------- ', val print '*************************************************************************'
def algorithm_route_vi(data_with_route_variable, bool_display=True, bool_display_iteration=True): gp.setParam('OutputFlag', 0) link_node_pair = data_with_route_variable['link_node_pair'] link_capacity = data_with_route_variable['link_capacity'] link_free = data_with_route_variable['link_free_flow_time'] od_node_pair = data_with_route_variable['od_node_pair'] od_demand = data_with_route_variable['od_demand'] od_number = data_with_route_variable['od_number'] link_number = data_with_route_variable['link_number'] node_number = data_with_route_variable['node_number'] od_route_incidence = data_with_route_variable['od_route_incidence'] route_link_incidence = data_with_route_variable['route_link_incidence'] route_number = data_with_route_variable['route_number'] parameter = set_parameter() para_a = parameter['a'] para_b = parameter['b'] def cal_objective_value_from_route_flow(route_flow): link_flow = route_flow @ route_link_incidence objective_value = (link_free * link_flow + link_free * para_a / (para_b + 1) * link_capacity * ( (link_flow / link_capacity) ** (para_b + 1))).sum() return objective_value def cal_route_time(cf): rf = cf / 1 lf = rf @ route_link_incidence lt = link_free * (1 + para_a * (lf ** para_b) / (link_capacity ** para_b)) rt = route_link_incidence @ lt ct = rt + 0 return ct od_route_number = od_route_incidence.sum(axis=1) initial_route_flow = (od_demand / od_route_number) @ od_route_incidence optimal_value = cal_objective_value_from_route_flow(initial_route_flow) current_route_flow = initial_route_flow tolerance = 1e-15 iteration_number = 5000 termination_bool = False optimum_bool = False iteration_index = 0 while not (termination_bool or optimum_bool): current_route_cost = cal_route_time(current_route_flow) matrix_h = np.eye(route_number) rho = 0.1 matrix_quadratic = matrix_h / 2 vector_quadratic = rho * current_route_cost.reshape([1, route_number]) - matrix_h @ current_route_flow m = gp.Model() var = m.addMVar(shape=route_number, lb=0.0) m.addConstr(od_route_incidence @ var == od_demand) m.setObjective(var @ matrix_quadratic @ var + vector_quadratic @ var, GRB.MINIMIZE) m.optimize() new_route_flow = var.x temp_value = cal_objective_value_from_route_flow(new_route_flow) if iteration_index != 0: gap = np.abs((temp_value - optimal_value) / optimal_value) else: gap = 1 if gap < tolerance: optimum_bool = True elif iteration_index == iteration_number: termination_bool = True optimal_value = temp_value current_route_flow = new_route_flow iteration_index += 1 if bool_display_iteration: print('----iteration_of_algorithm_route_vi----') print(f'iteration_index:{iteration_index}') print(f'gap:{gap}') print(f'optimal_value:{optimal_value}') print('--------') if bool_display: print('----algorithm_route_vi----') print(f'iteration_index:{iteration_index}') print(f'optimum_bool:{optimum_bool}') print(f'gap:{gap}') print(f'current_route_flow:{current_route_flow}') print(f'cost:{cal_route_time(current_route_flow)}') print(f'optimal_value:{optimal_value}') print('--------') return current_route_flow, optimal_value
def GbpPrimCanCOMPLEX(): t1 = time.time() # Constants Aij = np.random.randint(5, 50, 250000) Aij = Aij.reshape(500, 500) AijSum = np.sum(Aij) Oij = np.random.randint(5, 10, 250000) Oij = Oij.reshape(500, 500) OijSum = np.sum(Oij) Cj = np.random.randint(10, 20, 500) CjSum = np.sum(Cj) Ej = np.random.randint(10, 20, 500) EjSum = np.sum(Ej) Gj = np.random.randint(10, 20, 500) GjSum = np.sum(Gj) Bi = np.random.randint(10, 20, 500) BiSum = np.sum(Bi) # Matrix Shape rows = range(len(Aij)) cols = range(len(Aij[0])) # Instantiate Model mPrimal_Canonical_GUROBI = gbp.Model(" -- Canonical Primal Linear Programming Problem -- ") # Set Focus to Optimality gbp.setParam("MIPFocus", 2) # Decision Variables desc_var = [] for dest in cols: desc_var.append([]) desc_var[dest].append(mPrimal_Canonical_GUROBI.addVar(vtype=gbp.GRB.CONTINUOUS, name="y" + str(dest + 1))) o_var = [] for dest in cols: o_var.append([]) o_var[dest].append(mPrimal_Canonical_GUROBI.addVar(vtype=gbp.GRB.CONTINUOUS, name="o" + str(dest + 1))) p_var = [] for dest in cols: p_var.append([]) p_var[dest].append(mPrimal_Canonical_GUROBI.addVar(vtype=gbp.GRB.CONTINUOUS, name="p" + str(dest + 1))) # Update Model mPrimal_Canonical_GUROBI.update() # Objective Function mPrimal_Canonical_GUROBI.setObjective( gbp.quicksum(Cj[dest] * desc_var[dest][0] for dest in cols) + gbp.quicksum(Ej[dest] * o_var[dest][0] for dest in cols) + gbp.quicksum(Gj[dest] * p_var[dest][0] for dest in cols), gbp.GRB.MINIMIZE, ) # Constraints for orig in rows: mPrimal_Canonical_GUROBI.addConstr( gbp.quicksum(Aij[orig][dest] * desc_var[dest][0] for dest in cols) + gbp.quicksum(Oij[orig][dest] * o_var[dest][0] for dest in cols) - Bi[orig] >= 2.5 ) for orig in rows: mPrimal_Canonical_GUROBI.addConstr( gbp.quicksum(Aij[orig][dest] * desc_var[dest][0] for dest in cols) + gbp.quicksum(Oij[orig][dest] * o_var[dest][0] for dest in cols) - Bi[orig] <= 150.006 ) for orig in rows: mPrimal_Canonical_GUROBI.addConstr( gbp.quicksum(desc_var[dest][0] for dest in cols) + gbp.quicksum(o_var[dest][0] for dest in cols) >= 7.25 ) for orig in rows: mPrimal_Canonical_GUROBI.addConstr( gbp.quicksum(desc_var[dest][0] for dest in cols) + gbp.quicksum(o_var[dest][0] for dest in cols) <= 47.29 ) for orig in rows: mPrimal_Canonical_GUROBI.addConstr( gbp.quicksum(Aij[orig][dest] * p_var[dest][0] for dest in cols) + gbp.quicksum(o_var[dest][0] for dest in cols) / Ej[orig] + Bi[orig] >= 1.7 ) # Optimize try: mPrimal_Canonical_GUROBI.optimize() except Exception as e: print " ################################################################" print " < ISSUE : ", e, " >" print " ################################################################" t2 = time.time() - t1 # Write LP file mPrimal_Canonical_GUROBI.write("LP.lp") print "\n*************************************************************************" print " | Decision Variables" for v in mPrimal_Canonical_GUROBI.getVars(): print " | ", v.VarName, "=", v.x print "*************************************************************************" val = mPrimal_Canonical_GUROBI.objVal print " | Objective Value ------------------ ", val print " | Aij Sum -------------------------- ", AijSum print " | Oij Sum -------------------------- ", OijSum print " | Cj Sum --------------------------- ", CjSum print " | Ej Sum --------------------------- ", EjSum print " | Bi Sum --------------------------- ", BiSum print " | Matrix Dimensions ---------------- ", Aij.shape print " | Build & Solve(sec.) -------------- ", t2 print " | Date/Time ------------------------ ", dt.datetime.now() print "*************************************************************************" print "-- Gurobi Canonical Primal Linear Programming Problem --"
# later version. # # qpsolvers is distributed in the hope that it will be useful, but WITHOUT ANY # WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR # A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more # details. # # You should have received a copy of the GNU Lesser General Public License # along with qpsolvers. If not, see <http://www.gnu.org/licenses/>. from numpy import empty from gurobipy import Model, QuadExpr, GRB, GurobiError, quicksum, setParam try: setParam('OutputFlag', 0) except GurobiError as e: print("GurobiError: {}".format(e)) def get_nonzero_rows(M): nonzero_rows = {} rows, cols = M.nonzero() for ij in zip(rows, cols): i, j = ij if i not in nonzero_rows: nonzero_rows[i] = [] nonzero_rows[i].append(j) return nonzero_rows
#!/usr/bin/env python3 # -*- coding: utf-8 -*- """ Created on Tue Aug 28 14:24:01 2018 @author: chrisr """ import numpy as np from types import SimpleNamespace import sklearn.linear_model as skl import gurobipy as gb gb.setParam('OutputFlag', 0) class linear_explanation: def __init__(self): return None def encode_pandas(self, inputs): """Build a training set of dummy encoded variables from existing input data""" self.cox=np.empty(inputs.columns.size,dtype=np.object) self.constraints=np.empty_like(self.cox) for i in range(inputs.columns.shape[0]): col=inputs[inputs.columns[i]] vals=np.minimum(col,0) normal=col[(col>=0)] scale=normal.max() if scale==0 or np.isnan(scale): scale=1 normal/=scale un=np.unique(vals)
def GbpPrimCan(): # Constants Aij = np.random.randint(5, 50, 25) Aij = Aij.reshape(5,5) AijSum = np.sum(Aij) Cj = np.random.randint(10, 20, 5) CjSum = np.sum(Cj) Bi = np.random.randint(10, 20, 5) BiSum = np.sum(Bi) # Matrix Shape rows = range(len(Aij)) cols = range(len(Aij[0])) # Instantiate Model mPrimal_Canonical_GUROBI = gbp.Model(' -- Canonical Primal Linear Programming Problem -- ') # Set Focus to Optimality gbp.setParam('MIPFocus', 2) # Decision Variables desc_var = [] for dest in cols: desc_var.append([]) desc_var[dest].append(mPrimal_Canonical_GUROBI.addVar( vtype=gbp.GRB.CONTINUOUS, name='y'+str(dest+1))) # Update Model mPrimal_Canonical_GUROBI.update() #Objective Function mPrimal_Canonical_GUROBI.setObjective(gbp.quicksum( Cj[dest]*desc_var[dest][0] for dest in cols), gbp.GRB.MINIMIZE) # Constraints for orig in rows: mPrimal_Canonical_GUROBI.addConstr(gbp.quicksum( Aij[orig][dest]*desc_var[dest][0] for dest in cols) - Bi[orig] >= 0) # Optimize try: mPrimal_Canonical_GUROBI.optimize() except Exception as e: print ' ################################################################' print ' < ISSUE : ', e, ' >' print ' ################################################################' # Write LP file mPrimal_Canonical_GUROBI.write('LP.lp') print '\n*************************************************************************' print ' | Decision Variables' for v in mPrimal_Canonical_GUROBI.getVars(): print ' | ', v.VarName, '=', v.x print '*************************************************************************' val = mPrimal_Canonical_GUROBI.objVal print ' | Objective Value ------------------ ', val print ' | Aij Sum -------------------------- ', AijSum print ' | Cj Sum --------------------------- ', CjSum print ' | Bi Sum --------------------------- ', BiSum print ' | Matrix Dimensions ---------------- ', Aij.shape print ' | Date/Time ------------------------ ', dt.datetime.now() print '*************************************************************************' print '-- Gurobi Canonical Primal Linear Programming Problem --'
def GuTSP(nodes, min_cost, max_cost): # 1. Read In (or Create)Data # CREATE # Cost Matrix Cij = np.random.randint(min_cost, max_cost, nodes**2) Cij = Cij.reshape(nodes,nodes) # Cost Sum CijSum = np.sum(Cij) tour_nodes = range(len(Cij[0])) # 2. Create Model, Set MIP Focus, Add Variables, & Update Model m = gbp.Model(' -- Branch and Bound Directed Traveling Salesperson Problem -- ') # Set MIP Focus to 2 for optimality gbp.setParam('MIPFocus', 2) # Add Decision Variables desc_var = [] for orig in tour_nodes: desc_var.append([]) for dest in tour_nodes: desc_var[orig].append(m.addVar(vtype=gbp.GRB.BINARY, obj=Cij[orig][dest], name='x'+str(orig+1)+'_'+str(dest+1))) # Update Model Variables m.update() # 3. Set Objective Function m.setObjective(gbp.quicksum(Cij[orig][dest]*desc_var[orig][dest] for orig in tour_nodes for dest in tour_nodes), gbp.GRB.MINIMIZE) # 4. Add Constraints #Add Assignment Constraints by summed rows x_ij for orig in tour_nodes: m.addConstr(gbp.quicksum(desc_var[orig][dest] for dest in tour_nodes) == 1) #Add Assignment Constraints by summed columns x_ji for orig in tour_nodes: m.addConstr(gbp.quicksum(desc_var[dest][orig] for dest in tour_nodes) == 1) # 5. Optimize and Print Results try: m.optimize() except Exception as e: print e t2 = time.time()-t1 print '**********************************************************************' print ' | Nodes on Path ---------------------------- ', len(Cij) val = m.objVal print ' | Objective Value -------------------------- ', val avg = float(m.objVal)/float(len(Cij)) print ' | Avg. Value / Arc ------------------------- ', avg print ' | Total Network Travel Cost ---------------- ', CijSum print ' | Real Time to Optimize (sec.) ------------- ', t2 print ' | ' print ' | Cij ', len(Cij)*' ↓' , ' Tour by Node Order' NoP = [] for v in m.getVars(): if v.x > 0: var = '%s' % v.VarName NoP.append(var) for i in range(len(NoP)): print ' | -- ', Cij[i], ' -- ', NoP[i] print ' | ^^^^ Tour by Node Order' print '**********************************************************************' print ' -- Branch and Bound Directed Traveling Salesperson Problem -- ' m.write('path_Gurobi_TSP.lp')
''' # Cost Matrix Cij = np.fromfile('path.txt', dtype=float, sep='\n') Cij = Cij.reshape(#,#) ''' # Cost Matrix Cij = np.random.randint(100, 1000, 25) Cij = Cij.reshape(5,5) client_nodes = range(len(Cij[0])) service_nodes = range(len(Cij)) # 2. Create Model, Set MIP Focus, Add Variables, & Update Model m = gbp.Model(' -- P-Center -- ') # Set MIP Focus to 2 for optimality gbp.setParam('MIPFocus', 2) # Add Client Decision Variables client_var = [] for orig in service_nodes: client_var.append([]) for dest in client_nodes: client_var[orig].append(m.addVar(vtype=gbp.GRB.BINARY, obj=Cij[orig][dest], name='x'+str(orig+1)+'_'+str(dest+1))) # Add Service Decision Variables serv_var = [] for dest in service_nodes: serv_var.append([]) serv_var[dest].append(m.addVar(vtype=gbp.GRB.BINARY, name='y'+str(dest+1))) # Add Minimized Maximum Average Variable
g = Graph() g.add_edges_from(e for e in izip(edgelist[::2], edgelist[1::2])) g.graph['name'] = str(i) _, _, _, tear_set, _ = solve_problem(g, set(irange(size))) assert opt == len(tear_set) print('Done with size', size) print_timestamp() print() ################################################################################ if __name__ == '__main__': from gurobipy import setParam setParam('LogFile', '/tmp/gurobi.log') setParam('LogToConsole', 0) #naughty_brute_force() #quit() #solve_difficult_for_ilp(solve_problem, log) solve_test_matrices(solve_problem, log) #quit() print('Started generative testing...') import os os.environ['HYPOTHESIS_STORAGE_DIRECTORY'] = '/tmp/ht' from hypothesis import given, Settings from hypothesis.strategies import integers
from typing import List, Tuple, Union, Dict from gurobipy import LinExpr, Var, Model, Env, GRB, setParam from RNN.MarabouRNNMultiDim import alpha_to_equation from maraboupy import MarabouCore from RNN.Bound import Bound random.seed(0) sign = lambda x: 1 if x >= 0 else -1 SMALL = 10 ** -4 LARGE = 10 ** 5 PRINT_GUROBI = False setParam('Threads', 1) setParam('NodefileStart', 0.5) STAT_TOTAL_COUNTER = 'total_gurobi_steps' STAT_FAIL_COUNTER = 'fail_gurobi_steps' STAT_TOTAL_TIME = 'time_gurobi_steps' STAT_IMPROVE_DECISION_TIME = 'time_gurobi_imporve_decision' STAT_CONTINUOUS_COUNTER_EXAMPLE = 'continuous_counter_examples' class GurobiSingleLayer: def __init__(self, rnnModel, xlim, polyhedron_max_dim, use_relu=True, use_counter_example=False, add_alpha_constraint=False, max_steps=5, layer_idx=0, debug=False, stats={}, **kwargs): '''
def gurobi_solve_qp(P, q, G=None, h=None, A=None, b=None, initvals=None, verbose=False): """ Solve a Quadratic Program defined as: .. math:: \\begin{split}\\begin{array}{ll} \\mbox{minimize} & \\frac{1}{2} x^T P x + q^T x \\\\ \\mbox{subject to} & G x \\leq h \\\\ & A x = h \\end{array}\\end{split} using `Gurobi <http://www.gurobi.com/>`_. Parameters ---------- P : array, shape=(n, n) Primal quadratic cost matrix. q : array, shape=(n,) Primal quadratic cost vector. G : array, shape=(m, n) Linear inequality constraint matrix. h : array, shape=(m,) Linear inequality constraint vector. A : array, shape=(meq, n), optional Linear equality constraint matrix. b : array, shape=(meq,), optional Linear equality constraint vector. initvals : array, shape=(n,), optional Warm-start guess vector (not used). verbose : bool, optional Set to `True` to print out extra information. Returns ------- x : array, shape=(n,) Solution to the QP, if found, otherwise ``None``. """ setParam('OutputFlag', 1 if verbose else 0) if initvals is not None: print("Gurobi: note that warm-start values are ignored by wrapper") n = P.shape[1] model = Model() x = { i: model.addVar(vtype=GRB.CONTINUOUS, name='x_%d' % i, lb=-GRB.INFINITY, ub=+GRB.INFINITY) for i in range(n) } model.update() # integrate new variables # minimize # 1/2 x.T * P * x + q * x obj = QuadExpr() rows, cols = P.nonzero() for i, j in zip(rows, cols): obj += 0.5 * x[i] * P[i, j] * x[j] for i in range(n): obj += q[i] * x[i] model.setObjective(obj, GRB.MINIMIZE) # subject to # G * x <= h if G is not None: G_nonzero_rows = get_nonzero_rows(G) for i, row in G_nonzero_rows.items(): model.addConstr(quicksum(G[i, j] * x[j] for j in row) <= h[i]) # subject to # A * x == b if A is not None: A_nonzero_rows = get_nonzero_rows(A) for i, row in A_nonzero_rows.items(): model.addConstr(quicksum(A[i, j] * x[j] for j in row) == b[i]) model.optimize() a = empty(n) for i in range(n): a[i] = model.getVarByName('x_%d' % i).x return a