def GbpDualStd(): # 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 mDual_Standard_GUROBI = gbp.Model( ' -- Standard Dual Linear Programming Problem -- ') # Set Focus to Optimality gbp.setParam('MIPFocus', 2) # Decision Variables desc_var = [] for orig in rows: desc_var.append([]) desc_var[orig].append( mDual_Standard_GUROBI.addVar(vtype=gbp.GRB.CONTINUOUS, name='u' + str(orig + 1))) # Slack Variables slack_var = [] for dest in cols: slack_var.append([]) slack_var[dest].append( mDual_Standard_GUROBI.addVar(vtype=gbp.GRB.CONTINUOUS, name='t' + str(dest + 1))) # Update Model mDual_Standard_GUROBI.update() #Objective Function mDual_Standard_GUROBI.setObjective( gbp.quicksum(Bi[orig] * desc_var[orig][0] for orig in rows), gbp.GRB.MAXIMIZE) # Constraints for dest in cols: mDual_Standard_GUROBI.addConstr( gbp.quicksum(Aij[orig][dest] * desc_var[orig][0] for orig in rows) + slack_var[dest][0] - Cj[dest] == 0) # Optimize try: mDual_Standard_GUROBI.optimize() except Exception as e: print ' ################################################################' print ' < ISSUE : ', e, ' >' print ' ################################################################' # Write LP file mDual_Standard_GUROBI.write('LP.lp') print '\n*************************************************************************' print ' | Decision Variables' for v in mDual_Standard_GUROBI.getVars(): print ' | ', v.VarName, '=', v.x print '*************************************************************************' val = mDual_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 Dual Linear Programming Problem --'
def solve_allocation(Robots, Pallets, dist): # Build useful data structures K = [k.name for k in Robots] C = [j.name for j in Pallets] J = [j.loc for j in Pallets ] L = list(set([l[0] for l in dist.keys()])) D = list(set([t.init_loc for t in Robots])) cap = {k.name : k.cap for k in Robots} loc = {j.name : j.loc for j in Pallets} init_loc = {k.name : k.init_loc for k in Robots} canCover = {j.name : [k.name for k in j.job.coveredBy] for j in Pallets} dur = {j.name : j.job.duration for j in Pallets} tStart = {j.name : j.tStart for j in Pallets} tEnd = {j.name : j.tEnd for j in Pallets} tDue = {j.name : j.tDue for j in Pallets} priority = {j.name : j.job.priority for j in Pallets} ### Create model m = gp.Model("trs0") ### Decision variables # Pallet-Robot assignment x = m.addVars(C, K, vtype=GRB.BINARY, name="x") # Robot assignment u = m.addVars(K, vtype=GRB.BINARY, name="u") # Edge-route assignment to Robot y = m.addVars(L, L, K, vtype=GRB.BINARY, name="y") # Robot cannot leave or return to an init_loc that is not its base for k in Robots: for d in D: if k.init_loc != d: for i in L: y[i,d,k.name].ub = 0 y[d,i,k.name].ub = 0 # Start time of service t = m.addVars(L, ub=600, name="t") # Lateness of service z = m.addVars(C, name="z") # Artificial variables to correct time window upper and lower limits xa = m.addVars(C, name="xa") xb = m.addVars(C, name="xb") # Unfilled jobs g = m.addVars(C, vtype=GRB.BINARY, name="g") ### Constraints # A Robot must be assigned to a job, or a gap is declared (1) m.addConstrs((gp.quicksum(x[j, k] for k in canCover[j]) + g[j] == 1 for j in C), name="assignToJob") # At most one Robot can be assigned to a job (2) m.addConstrs((x.sum(j, '*') <= 1 for j in C), name="assignOne") # Robot capacity constraints (3) capLHS = {k : gp.quicksum(dur[j]*x[j,k] for j in C) +\ gp.quicksum(dist[i,j]*y[i,j,k] for i in L for j in L) for k in K} m.addConstrs((capLHS[k] <= cap[k]*u[k] for k in K), name="techCapacity") # Robot tour constraints (4 and 5) m.addConstrs((y.sum('*', loc[j], k) == x[j,k] for k in K for j in C),\ name="techTour1") m.addConstrs((y.sum(loc[j], '*', k) == x[j,k] for k in K for j in C),\ name="techTour2") # Same init_loc constraints (6 and 7) m.addConstrs((gp.quicksum(y[j,init_loc[k],k] for j in J) == u[k] for k in K),\ name="sameinit_loc1") m.addConstrs((gp.quicksum(y[init_loc[k],j,k] for j in J) == u[k] for k in K),\ name="sameinit_loc2") # Temporal constraints (8) for Pallet locations M = {(i,j) : 600 + dur[i] + dist[loc[i], loc[j]] for i in C for j in C} m.addConstrs((t[loc[j]] >= t[loc[i]] + dur[i] + dist[loc[i], loc[j]]\ - M[i,j]*(1 - gp.quicksum(y[loc[i],loc[j],k] for k in K))\ for i in C for j in C), name="tempoPallet") # Temporal constraints (8) for init_loc locations M = {(i,j) : 600 + dist[i, loc[j]] for i in D for j in C} m.addConstrs((t[loc[j]] >= t[i] + dist[i, loc[j]]\ - M[i,j]*(1 - y.sum(i,loc[j],'*')) for i in D for j in C),\ name="tempoinit_loc") # Time window constraints (9 and 10) m.addConstrs((t[loc[j]] + xa[j] >= tStart[j] for j in C), name="timeWinA") m.addConstrs((t[loc[j]] - xb[j] <= tEnd[j] for j in C), name="timeWinB") # Lateness constraint (11) m.addConstrs((z[j] >= t[loc[j]] + dur[j] - tDue[j] for j in C),\ name="lateness") ### Objective function M = 6100 m.setObjective( gp.quicksum( 0.01 * M * priority[j] * (xa[j] + xb[j]) for j in C) + gp.quicksum( M * priority[j] * g[j] for j in C) + \ (10.*gp.quicksum(dist[i,j]*y[i,j,k] \ for i,j in dist.keys() for k in K)), GRB.MINIMIZE) m.write("TRS0.lp") m.optimize() # import pdb; pdb.set_trace() status = m.Status if status in [GRB.INF_OR_UNBD, GRB.INFEASIBLE, GRB.UNBOUNDED]: print("Model is either infeasible or unbounded.") sys.exit(0) elif status != GRB.OPTIMAL: print("Optimization terminated with status {}".format(status)) sys.exit(0) ### Print results # Assignments print("") for j in Pallets: if g[j.name].X > 0.5: jobStr = "Nobody assigned to {} ({}) in {}".format(j.name,j.job.name,j.loc) else: for k in K: if x[j.name,k].X > 0.5: jobStr = "{} assigned to {} ({}) in {}. Start at t={:.2f}.".format(k,j.name,j.job.name,j.loc,t[j.loc].X) if z[j.name].X > 1e-6: jobStr += " {:.2f} minutes late.".format(z[j.name].X) if xa[j.name].X > 1e-6: jobStr += " Start time corrected by {:.2f} minutes.".format(xa[j.name].X) if xb[j.name].X > 1e-6: jobStr += " End time corrected by {:.2f} minutes.".format(xb[j.name].X) print(jobStr) #import pdb; pdb.set_trace() # Robots print("") for k in Robots: if u[k.name].X > 0.5: cur = k.init_loc route = k.init_loc N = 15 while N>0: N -= 1 for j in Pallets: if y[cur,j.loc,k.name].X > 0.5: #route += " -> {} (dist={}, t={:.2f}, proc={})".format(j.loc, dist[cur,j.loc], t[j.loc].X, j.job.duration) route += " -> {} -> {} (dist={}, t={:.2f}, proc={})".format(j.pick, j.loc, dist[cur,j.loc], t[j.loc].X, j.job.duration) cur = j.loc for i in D: if y[cur,i,k.name].X > 0.5: # route += " -> {} (dist={})".format(i, dist[cur,i]) cur = i break if cur == k.init_loc: break print("{}'s route: {}".format(k.name, route)) else: print("{} is not used".format(k.name)) # Utilization print("") for k in K: used = capLHS[k].getValue() util = used / cap[k] if cap[k] > 0 else 0 print("{}'s utilization is {:.2%} ({:.2f}/{:.2f})".format(k, util,\ used, cap[k])) totUsed = sum(capLHS[k].getValue() for k in K) totCap = sum(cap[k] for k in K) totUtil = totUsed / totCap if totCap > 0 else 0 print("Total Robot utilization is {:.2%} ({:.2f}/{:.2f})".format(totUtil, totUsed, totCap))
# tupledict形式 inflow = { ('Pencils', 'Detroit'): 50, ('Pencils', 'Denver'): 60, ('Pencils', 'Boston'): -50, ('Pencils', 'New York'): -50, ('Pencils', 'Seattle'): -10, ('Pens', 'Detroit'): 60, ('Pens', 'Denver'): 40, ('Pens', 'Boston'): -40, ('Pens', 'New York'): -30, ('Pens', 'Seattle'): -30 } # Create optimization model m = gp.Model('netflow') # Create variables flow = m.addVars(commodities, arcs, obj=cost, name="flow") # Arc-capacity constraints m.addConstrs((flow.sum('*', i, j) <= capacity[i, j] for i, j in arcs), "cap") # Equivalent version using Python looping # for i, j in arcs: # m.addConstr(sum(flow[h, i, j] for h in commodities) <= capacity[i, j], # "cap[%s, %s]" % (i, j)) # Flow-conservation constraints m.addConstrs((flow.sum(h, '*', j) + inflow[h, j] == flow.sum(h, j, '*') for h in commodities for j in nodes), "node")
def MILP_method_for_incentive_synthesis(model, rewards, init, target, blocks, epsilon): # This function synthesizes a sequence of incentives for a given N-BMP instance # by solving the corresponding MILP # Inputs: # model: a class variable corresponding to the given MDP instance # rewards: a dict variable corresponding to reward functions of all possible agent types # init: a scalar variable corresponding to the initial state of the MDP # target: a list variable corresponding to the set of target states # blocks: a list variable corresponding to the set of absorbing states # epsilon: a scalar variable indicating the suboptimality of the solution MDP_m = MDP(model) num_of_states = len(MDP_m.states()) num_of_actions = len(MDP_m.actions()) num_of_types = len(rewards) # Construct initial distribution alpha = np.zeros((num_of_states, 1)) alpha[init] = 1 # Compute big-M parameters R_max = max([ rewards[i][max(rewards[i], key=rewards[i].get)] for i in range(num_of_types) ]) R_min = min([ rewards[i][min(rewards[i], key=rewards[i].get)] for i in range(num_of_types) ]) M_e = 2 * (R_max - R_min + epsilon) C = {} for pair in MDP_m.state_action_pairs(): array = [] for types in range(num_of_types): max_reward = R_min for act in MDP_m.active_actions()[pair[0]]: if rewards[types][(pair[0], act)] > max_reward: max_reward = rewards[types][(pair[0], act)] array.append(max_reward - rewards[types][pair]) C[pair] = max(array) + epsilon min_cost, _ = MDP_m.compute_min_cost_subject_to_max_reach( init, target, blocks, C) M_e_bar = min_cost M_e2_bar = num_of_states ## Compute max reachability probability and construct reach reward function max_reach, _ = MDP_m.compute_max_reach_value_and_policy( init, target, blocks) reach_rew = MDP_m.reward_for_reach(target) ##### Construct the optimization problem ## We implement the algorithm without using the variables Q_theta(s,a) and Q_{p,theta}(s,a). ## Note that the constraints (20b) and (20k) are redundant equality constraints which are ## just introduced to define these variables. m = gp.Model() # m.setParam( 'OutputFlag', False ) # Variables gamma = m.addVars(num_of_states, num_of_actions, lb=0.0, name='incentives') omega = m.addVar(lb=-GRB.INFINITY) X = m.addVars(num_of_types, num_of_states, num_of_actions, vtype=GRB.BINARY, name='actions') # binary variables V_theta = m.addVars(num_of_types, num_of_states, lb=-GRB.INFINITY, name='V_theta') V_p = m.addVars(num_of_types, num_of_states, lb=0.0, name='V_p') lambda_theta = m.addVars(num_of_types, num_of_states, num_of_actions, lb=0.0, name='lambda_theta') mu_theta = m.addVars(num_of_types, num_of_states, num_of_actions, name='mu_theta') sum_successor_p = {} dummy_integer_counter = {} sum_actions_counter = {} sum_mu_counter = {} total_reach_prob = {} for theta in range(num_of_types): for state in range(num_of_states): sum_mu_counter[(theta, state)] = gp.LinExpr() dummy_integer_counter[(theta, state)] = gp.LinExpr() sum_actions_counter[(theta, state)] = gp.LinExpr() for i, act in enumerate( model[0][state]): # available actions in a state sum_actions_counter[(theta, state)].add(mu_theta[theta, state, i], 1) dummy_integer_counter[(theta, state)].add(X[theta, state, i], 1) ################ McCormick envelopes for mu_theta variables ################ Corresponding constraints (20i), (20j) m.addConstr(0 <= mu_theta[theta, state, i]) m.addConstr( mu_theta[theta, state, i] <= M_e2_bar * X[theta, state, i]) m.addConstr( lambda_theta[theta, state, i] - M_e2_bar * (1 - X[theta, state, i]) <= mu_theta[theta, state, i]) m.addConstr( mu_theta[theta, state, i] <= lambda_theta[theta, state, i]) ################ Value function of the agent type theta ################ Corresponding constraints -- (20c), (20d) m.addConstr( V_theta[theta, state] >= rewards[theta][(state, act)] + gamma[state, i]) m.addConstr( V_theta[theta, state] <= rewards[theta][(state, act)] + gamma[state, i] + (1 - X[theta, state, i]) * M_e) ############## Uniqueness of the agent theta's optimal policy ################ Corresponding constraints -- (20e) for j, act2 in enumerate(model[0][state]): if act2 != act: m.addConstr( rewards[theta][(state,act2)]+gamma[state,j]+epsilon <= \ rewards[theta][(state,act)]+gamma[state,i]+(1-X[theta,state,i])*M_e) ############### Principal's total cost for type theta ############### Corresponding constraints -- (20l), (20m) sum_successor_p[(theta, state, i)] = gp.LinExpr() for k, succ in enumerate(model[1][(state, act)][1]): sum_successor_p[(theta, state, i)].add(V_p[theta, succ], model[1][(state, act)][0][k]) m.addConstr( V_p[theta, state] >= sum_successor_p[(theta, state, i)] + gamma[state, i] - (1 - X[theta, state, i]) * M_e_bar) m.addConstr( V_p[theta, state] <= sum_successor_p[(theta, state, i)] + gamma[state, i] + (1 - X[theta, state, i]) * M_e_bar) ################ Principal's flow constraint for type theta and state s ################ Corresponding constraint -- (20f) for pair in model[1]: if state in model[1][pair][1]: trans_prob = model[1][pair][1].index(state) act_index = model[0][pair[0]].index(pair[1]) sum_mu_counter[(theta, state)].add( mu_theta[theta, pair[0], act_index], model[1][pair][0][trans_prob]) if state not in target and state not in blocks: m.addConstr(sum_actions_counter[(theta, state)] - sum_mu_counter[(theta, state)] == alpha[state]) ################ Corresponding constraint -- (20o) m.addConstr(dummy_integer_counter[(theta, state)] == 1) ################ Principal's reachability constraint for type theta ################ Corresponding constraint -- (20h) total_reach_prob[theta] = gp.LinExpr() for pair in model[1]: index_action = model[0][pair[0]].index(pair[1]) total_reach_prob[theta].add(mu_theta[theta, pair[0], index_action], reach_rew[pair]) m.addConstr(total_reach_prob[theta] >= max_reach) ################ Corresponding constraint -- (20n) m.addConstr(omega >= V_p[theta, init]) m.setObjective(omega, GRB.MINIMIZE) m.setParam("IntFeasTol", 1e-4) # Optimize model m.optimize() incentivized_rewards = [{} for k in range(num_of_types)] incentive_amount = {} for i in range(num_of_types): for pair in model[1]: index_action = model[0][pair[0]].index(pair[1]) incentivized_rewards[i][pair] = rewards[i][pair] + gamma[ pair[0], index_action].x incentive_amount[pair] = gamma[pair[0], index_action].x compute_time = m.Runtime optimal_policy = [{} for k in range(num_of_types)] for types in range(num_of_types): for state in range(num_of_states): optimal_policy[types][state] = model[0][state][0] opt_reward = incentivized_rewards[types][( state, optimal_policy[types][state])] for action in model[0][state]: if incentivized_rewards[types][ (state, action)] - opt_reward >= epsilon / 10: optimal_policy[types][state] = action opt_reward = incentivized_rewards[types][(state, action)] return incentive_amount, incentivized_rewards, optimal_policy, compute_time
def solve(self, objective, constraints, cached_data, warm_start, verbose, solver_opts): """Returns the result of the call to the solver. Parameters ---------- objective : LinOp The canonicalized objective. constraints : list The list of canonicalized cosntraints. cached_data : dict A map of solver name to cached problem data. warm_start : bool Not used. verbose : bool Should the solver print output? solver_opts : dict Additional arguments for the solver. Returns ------- tuple (status, optimal value, primal, equality dual, inequality dual) """ import gurobipy # Get problem data data = self.get_problem_data(objective, constraints, cached_data) c = data[s.C] b = data[s.B] A = dok_matrix(data[s.A]) # Save the dok_matrix. data[s.A] = A data[s.BOOL_IDX] = solver_opts[s.BOOL_IDX] data[s.INT_IDX] = solver_opts[s.INT_IDX] n = c.shape[0] solver_cache = cached_data[self.name()] # TODO warmstart with SOC constraints. if warm_start and solver_cache.prev_result is not None \ and len(data[s.DIMS][s.SOC_DIM]) == 0: model = solver_cache.prev_result["model"] variables = solver_cache.prev_result["variables"] gur_constrs = solver_cache.prev_result["gur_constrs"] c_prev = solver_cache.prev_result["c"] A_prev = solver_cache.prev_result["A"] b_prev = solver_cache.prev_result["b"] # If there is a parameter in the objective, it may have changed. if len(lu.get_expr_params(objective)) > 0: c_diff = c - c_prev I_unique = list(set(np.where(c_diff)[0])) for i in I_unique: variables[i].Obj = c[i] else: # Stay consistent with Gurobi's representation of the problem c = c_prev # Get equality and inequality constraints. sym_data = self.get_sym_data(objective, constraints, cached_data) all_constrs, _, _ = self.split_constr(sym_data.constr_map) # If there is a parameter in the constraints, # A or b may have changed. if self._param_in_constr(all_constrs): A_diff = dok_matrix(A - A_prev) b_diff = b - b_prev # Figure out which rows of A and elements of b have changed try: idxs, _ = zip(*[x for x in A_diff.keys()]) except ValueError: idxs = [] I_unique = list(set(idxs) | set(np.where(b_diff)[0])) nonzero_locs = gurobipy.tuplelist(A.keys()) # Update locations which have changed for i in I_unique: # Remove old constraint if it exists if gur_constrs[i] is not None: model.remove(gur_constrs[i]) gur_constrs[i] = None # Add new constraint if nonzero_locs.select(i, "*"): expr_list = [] for loc in nonzero_locs.select(i, "*"): expr_list.append((A[loc], variables[loc[1]])) expr = gurobipy.LinExpr(expr_list) if i < data[s.DIMS][s.EQ_DIM]: ctype = gurobipy.GRB.EQUAL elif data[s.DIMS][s.EQ_DIM] <= i \ < data[s.DIMS][s.EQ_DIM] + data[s.DIMS][s.LEQ_DIM]: ctype = gurobipy.GRB.LESS_EQUAL gur_constrs[i] = model.addConstr(expr, ctype, b[i]) model.update() else: # Stay consistent with Gurobi's representation of the problem A = A_prev b = b_prev else: model = gurobipy.Model() variables = [] for i in range(n): # Set variable type. if i in data[s.BOOL_IDX]: vtype = gurobipy.GRB.BINARY elif i in data[s.INT_IDX]: vtype = gurobipy.GRB.INTEGER else: vtype = gurobipy.GRB.CONTINUOUS variables.append( model.addVar( obj=c[i], name="x_%d" % i, vtype=vtype, # Gurobi's default LB is 0 (WHY???) lb=-gurobipy.GRB.INFINITY, ub=gurobipy.GRB.INFINITY) ) model.update() eq_constrs = self.add_model_lin_constr(model, variables, range(data[s.DIMS][s.EQ_DIM]), gurobipy.GRB.EQUAL, A, b) leq_start = data[s.DIMS][s.EQ_DIM] leq_end = data[s.DIMS][s.EQ_DIM] + data[s.DIMS][s.LEQ_DIM] ineq_constrs = self.add_model_lin_constr(model, variables, range(leq_start, leq_end), gurobipy.GRB.LESS_EQUAL, A, b) soc_start = leq_end soc_constrs = [] new_leq_constrs = [] for constr_len in data[s.DIMS][s.SOC_DIM]: soc_end = soc_start + constr_len soc_constr, new_leq, new_vars = self.add_model_soc_constr( model, variables, range(soc_start, soc_end), A, b ) soc_constrs.append(soc_constr) new_leq_constrs += new_leq variables += new_vars soc_start += constr_len gur_constrs = eq_constrs + ineq_constrs + \ soc_constrs + new_leq_constrs model.update() # Set verbosity and other parameters model.setParam("OutputFlag", verbose) # TODO user option to not compute duals. model.setParam("QCPDual", True) for key, value in solver_opts.items(): model.setParam(key, value) results_dict = {} try: model.optimize() print(model) results_dict["primal objective"] = model.ObjVal results_dict["x"] = np.array([v.X for v in variables]) # Only add duals if not a MIP. # Not sure why we need to negate the following, # but need to in order to be consistent with other solvers. if not self.is_mip(data): vals = [] for lc in gur_constrs: if lc is not None: if isinstance(lc, gurobipy.QConstr): vals.append(lc.QCPi) else: vals.append(lc.Pi) else: vals.append(0) results_dict["y"] = -np.array(vals) results_dict["status"] = self.STATUS_MAP.get(model.Status, s.SOLVER_ERROR) except Exception: results_dict["status"] = s.SOLVER_ERROR results_dict["model"] = model results_dict["variables"] = variables results_dict["gur_constrs"] = gur_constrs results_dict[s.SOLVE_TIME] = model.Runtime return self.format_results(results_dict, data, cached_data)
def optimize_test_capacity_multiple_vaccines_robust(T, Delta, Capacity, Instance): m = gp.Model("vaccinations") Capacity = 2 * Capacity m.Params.LogToConsole = 0 vaccine = {"Pfizer", "Moderna", "Astrazeneca"} dicti = {} dict_B = {} dict_stocks = {} for i in vaccine: for j in range(0, T): dicti[(i, j)] = [j+1] for k in Instance: dict_stocks[(i,j,k)] = [j+1] combinations, time_frame = gp.multidict(dicti) combinations_stock, time_frame = gp.multidict(dict_stocks) first_doses = m.addVars(combinations, lb=0.0, vtype=GRB.INTEGER, name="First_Doses") second_doses = m.addVars(combinations, lb = 0.0, vtype=GRB.INTEGER, name="Second_Doses") stocks = m.addVars(combinations_stock, lb=0.0, vtype=GRB.INTEGER, name="Stocks") z = m.addVar(lb = 0.0, vtype = GRB.CONTINUOUS, name="Z") m.addConstrs( (first_doses.sum('*',j) + second_doses.sum('*', j) <= Capacity for j in range(0, T))) m.addConstrs( (first_doses[j, i] == second_doses[j,i+Delta[j]] for j, i in combinations if i < T-Delta[j] )) m.addConstrs( (first_doses[j, i] == 0 for j, i in combinations if i >= T-Delta[j] )) m.addConstrs( second_doses[j,i] == 0 for j, i in combinations if i < Delta[j]) #m.addConstrs( stocks[j, i, k] <= 10000 for j, i, k in combinations_stock if i == T-1) m.addConstrs( (first_doses[j,i] + 0 + stocks[j,i,k] == Instance[k][j][i] + 0 for j, i, k in combinations_stock if i == 0)) m.addConstrs( (first_doses[j,i] + 0 + stocks[j,i,k] == Instance[k][j][i] + stocks[j,i-1,k] for j, i, k in combinations_stock if i >= 1 and i < Delta[j])) m.addConstrs( (first_doses[j,i] + first_doses[j,i-Delta[j]] + stocks[j,i,k] == Instance[k][j][i] + stocks[j,i-1,k] for j, i, k in combinations_stock if i >= 1 and i >= Delta[j])) for k in Instance: m.addConstr( z >= (( 2 / (Instance[k]["TotalB"]) * (gp.quicksum(second_doses[j,i] * i for j,i in combinations) + ( Instance[k]["stock_values_Pfizer"]*(180 + 21) + (Instance[k]["stock_values_Moderna"])*(180 + 28) + (Instance[k]["stock_values_Astrazeneca"])*(180 + 78)))) - Instance[k]["Result"] ) ) m.setObjective( z , GRB.MINIMIZE) # m.addConstrs( stocks[j, i, k] <= 15000 for j, i, k in stocks_combinations if i == T-1) #m.addConstrs ( z >= ( ( (gp.quicksum(second_doses[j,i] * i for j,i in combinations))) ) for k in Instance ) #m.setObjective( gp.quicksum(second_doses[j,i] * i + Instance[0]['stock_values_Astrazeneca'] + Instance[0]['stock_values_Moderna'] + Instance[0]['stock_values_Pfizer'] for j,i in combinations ), GRB.MINIMIZE) m.optimize() if (m.solCount > 0): print(m.objVal) resultList = m.getAttr(GRB.Attr.X, m.getVars()) first_doses_dict = {} second_doses_dict = {} stocks_dict = {} '''for i in range(0, len(original_B)): first_doses_dict[list(original_B)[i]] = resultList[T*i:T*(i+1)] first_doses_values = resultList[T*i:T*(i+1)] for i in range(0, len(original_B)): second_doses_dict[list(original_B)[i]] = resultList[T*(i+len(original_B)):T*(i+1+len(original_B))] second_doses_values = resultList[T*(i+len(original_B)):T*(i+1+len(original_B))] for i in range(0, len(original_B)): stocks_dict[list(original_B)[i]] = resultList[T*(i+2*len(original_B)):T*(i+1+2*len(original_B))] stock_values = resultList[T*(i+2*len(original_B)):T*(i+1+2*len(original_B))]''' object_function_value = m.objVal return[first_doses_dict, second_doses_dict, stocks_dict, object_function_value] else: print("\n***** No solutions found *****")
# Step 3 BOFdat # Generation of the initial population population_name = r"C:\Users\maria.moscardo\Desktop\Internship\BOFdat_data\Populations\test_pop" path_to_model = r"C:\Users\maria.moscardo\Desktop\Internship\BOFdat_data\Recon204_final.xml" base_biomass_path = r"C:\Users\maria.moscardo\Desktop\Internship\BOFdat\data\bofdat_step2.csv" exp_essentiality_path = r"C:\Users\maria.moscardo\Desktop\Internship\BOFdat_data\Hela_EG.csv" # In[1]: # Set gurobi solver import gurobipy gurobipy.Model() import optlang.gurobi_interface as grb grb.Model() # In[ ]: from BOFdat import step3 step3.generate_initial_population(population_name, path_to_model, base_biomass_path, exp_essentiality_path, number_of_populations=5)
Aij = [] for i in Cij: if i <= S: outtext = 1 else: outtext = 0 Aij.append(outtext) Cij = np.array(Cij) Cij = Cij.reshape(5, 5) rows, cols = Cij.shape Aij = np.array(Aij) Aij = Aij.reshape(5, 5) client_nodes = range(len(Cij[0])) # 2. Create Model, Set MIP Focus, Add Variables, & Update Model m = gbp.Model(" -- SCLP -- ") # 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( m.addVar(vtype=gbp.GRB.BINARY, ub=1, name='x' + str(orig + 1))) # Update Model Variables m.update() # 4. Set Objective Function m.setObjective(gbp.quicksum(client_var[orig] for orig in client_nodes), gbp.GRB.MINIMIZE) # 5. Add Constraints
def TW(n,q): try: M = 1e4 E = 8 L = 24 ss = np.random.randint(1,4,n) s = list(ss) s.insert(0,0) # insert 0 at 0 s.append(0) # before and after add 0 element. pp = np.random.randint(10,60,n) p = list(pp) p.insert(0,0) p.append(0) # before and after add 0 element. subscript_i = len(s) # the number of nodes subscript_j = subscript_i subscript_k = len(q) u =24 m = gp.Model("dis1") x = m.addVars(subscript_i, subscript_j, subscript_k, vtype=GRB.BINARY, name="open") y = m.addVars(subscript_i, subscript_j, subscript_k, vtype=GRB.BINARY, name="time") T = m.addVars(subscript_i, subscript_j, subscript_k, vtype=GRB.BINARY, name="space") w = m.addVars(subscript_i,subscript_k, lb=0, name="start") m.update() # Set objective m.setObjective(gp.quicksum((x[i,j,k]*p[i]/q[k] + T[i,j,k]) for k in range(subscript_k) for i in range(subscript_i) for j in range(subscript_j)), GRB.MAXIMIZE) # Add constraints # constraint 1 m.addConstrs((gp.quicksum(x[i,j,k] for j in range(1,subscript_j) for k in range(subscript_k)) == 1) for i in range(1,subscript_i-1)) # constraint 2 m.addConstrs((gp.quicksum(x[i,j,k] for i in range(subscript_i)) == gp.quicksum(x[j,i,k] for i in range(subscript_i))) for j in range(1,subscript_j-1) for k in range(subscript_k)) # constraint 3 m.addConstrs((gp.quicksum(x[0,j,k] for j in range(1,subscript_j)) == 1) for k in range(subscript_k)) # constraint 4 m.addConstrs((gp.quicksum(x[i,subscript_j-1,k] for i in range(subscript_i-1)) == 1) for k in range(subscript_k)) # constraint 5 m.addConstrs((w[i,k] + s[i] -w[j,k]) <= ((1-x[i,j,k])*M) for k in range(subscript_k) for i in range(subscript_i) for j in range(subscript_j)) # constraint 6 m.addConstrs(w[0,k] == E for k in range(subscript_k)) m.addConstrs(w[subscript_i-1,k] == L for k in range(subscript_k)) # constructs 7 m.addConstrs(x[i,i,k] == 0 for i in range(subscript_i) for k in range(subscript_k)) # constructs 8 m.addConstrs(T[i,j,k] <= y[i,j,k] for i in range(subscript_i) for j in range(subscript_j) for k in range(subscript_k)) # constructs 9 m.addConstrs(T[i,j,k] >= y[i,j,k]- u*(1-x[i,j,k]) for i in range(subscript_i) for j in range(subscript_j) for k in range(subscript_k)) # constructs 10 m.addConstrs(T[i,j,k] <= u* x[i,j,k] for i in range(subscript_i) for j in range(subscript_j) for k in range(subscript_k)) m.write('dis2.lp') m.params.outputflag = 0 m.optimize() x_ijk = m.getAttr('X', x) w_ik = m.getAttr('X', w) route = [] serviceT = [] # Generate the route and Specific service time for k in range(subscript_k): route.append([0]) i = 0 serviceT.append([w_ik[i,k]]) terminate = True while terminate: for j in range(subscript_j): if x_ijk[i,j,k] >= 0.5: route[k].append(j) serviceT[k].append(w_ik[j,k]) i = j break if (i == subscript_i-1): terminate = False for i in range(subscript_i-2): print('Group {0} service time is {1}'.format(i+1, s[i+1])) print('The number of people is {0}'.format(p[i+1])) for i in range(len(route)): print('The room {0} serves: {1}'.format(i+1, route[i][1:-1])) print('Service start time is:' + str(serviceT[i][1:-1])) return m.objVal except gp.GurobiError as e: print('Main-Error code ' + str(e.errno) + ": " + str(e)) except AttributeError: print('Main-Encountered an attribute error')
import gurobipy as grb model = grb.Model() # 定义变量的下标 tl = [(1, 1), (1, 2), (1, 3), (2, 1), (2, 2), (2, 3), (3, 1), (3, 2), (3, 3)] vars = model.addVars(tl, name="d") # 基于元素下标的操作 print(sum(vars.select(1, '*'))) # 输出 # <gurobi.LinExpr: d[1,1] + d[1,2] + d[1,3]>
regions = list(set(order_regions.values())) # get stock for each product type in each region region_stock = { r: { k: sum([ warehouse_stock[w][k] for w in warehouses if warehouse_regions[w] == r ]) for k in products } for r in regions } #instantiate model object m = gp.Model('Model A') ## DECISION VARIABLES flow = {} # index is (warehouse, order, product) indices = [(i, j, k) for i in warehouses for j in orders for k in products if k in orders_data[j]] flow = m.addVars(indices, lb=0, vtype=GRB.INTEGER) #binary variable for incurring fixed cost fixed_cost_ind = m.addVars([(w, o) for w in warehouses for o in orders], vtype=GRB.BINARY) # use max stock as big M to activate fixed costs ind max_stock = max(warehouse_stock[w][k] for w in warehouses for k in products) # use max regional demand for big M in nonregional flow constraint
def insd(G, aa, c, sparsed=False): """ Построение таблицы с помощью метода INSD(improved normalized square difference). Решает систему G*x = c, где G - матрица and c - вектор ограничений. Parameters ---------- G : np.ndarray матрица коэффициентов для линейных ограничений aa: np.ndarray векторизованная базовая матрица c: np.ndarray вектор ограничений Returns ------- a: np.ndarray векторизованная матрица результата """ try: model = gr.Model("INSD") a = aa.astype(float) a[aa == 0] = 1e-10 at = a.flatten() # add variable z to model ( z_ij = x_ij/a_ij) z = model.addVars(len(at), lb=0., name='z') for i in range(len(z)): z[i].start = 1. model.update() # add function for minimization to model t = gr.QuadExpr() for i in range(len(at)): t.add(abs(at[i]) * (z[i] - 1.) * (z[i] - 1.)) model.setObjective(t) # add constraint G*(z.*a)=c if sparsed: for i in range(G.shape[0]): expr = gr.LinExpr() start = G.indptr[i] end = G.indptr[i + 1] idx = G.indices[start:end] coef = G.data[start:end] * at[idx] for j, k in enumerate(idx): expr.add(z[k], coef[j]) model.addLConstr(expr, gr.GRB.EQUAL, c[i]) else: cover_rows = [np.nonzero(row)[0] for row in G] for i in range(len(G)): expr = gr.LinExpr() idx = cover_rows[i] coef = G[i, idx] * at[idx] for j, k in enumerate(idx): expr.add(z[k], coef[j]) model.addLConstr(expr, gr.GRB.EQUAL, c[i]) # Set params model.setParam('BarConvTol', 1e-8) model.setParam('BarQCPConvTol', 1e-6) model.setParam('DualReductions', 0) # model.setParam('FeasibilityTol',0.01) model.setParam('OutputFlag', 0) model.optimize() result = np.array([v.x for v in model.getVars()]) return result * at except Exception as e: logging.error(traceback.format_exc()) return -1
def main(): # 前処理 # ============================================================================================== # ファイルロード # File1 = "book/exp_full_height.csv" File1 = "/Users/takedakiyoshi/lab/kline/KLINE/高さ制約を比較するフォルダ/exp_full_height.csv" # File2 = "data/hold_with_height.csv" File2 = "/Users/takedakiyoshi/lab/kline/KLINE/高さ制約を比較するフォルダ/hold_with_height.csv" File3 = "data/mainlamp.csv" File4 = "data/back_mainlamp.csv" File5 = "data/afr_mainlamp.csv" File6 = "data/stress_mainlamp.csv" File7 = "data/gangnum_2.csv" File8 = "data/gangnum_3.csv" # 注文情報の読み込み T, L, D, J, U, A, G, J_small, J_large, Port, Check_port, Booking, VehicleHeight = Read_booking( File1) # 船体情報の読み込み1 I, B, I_pair, I_next, I_same, I_lamp, I_deck, RT_benefit, delta_s, min_s, max_s, delta_h, max_h, Hold_encode, Hold, HoldHeight = Read_hold( File2) # 船体情報の読み込み2 Ml_Load, Ml_Back, Ml_Afr, Stress, GANG2, GANG3 \ = Read_other(File3, File4, File5, File6, File7, File8, Hold_encode) # ============================================== #print('-----Loaded threshold data-----') # print(delta_s) # print(delta_h) # print(min_s) # print(max_s) # print(max_h) # print("\n") #print('-----Loaded instance data-----') # print(I) # print(I_pair) # print(I_next) # print(I_same) # print(I_lamp) # print(I_deck) # print(J) # print(B) # print(A) # print("\n") # ============================================== J_t_load = [] # J_t_load:港tで積む注文の集合 J_t_keep = [] # J_t_keep:港tを通過する注文の集合 J_t_dis = [] # J_t_dis:港tで降ろす注文の集合 J_lk = [] # J_lk:J_t_load + J_t_keep J_ld = [] # J_ld:J_t_load + J_t_dis for t in T: J_load = [] J_keep = [] J_dis = [] lk = [] ld = [] tmp_load = list(Port.iloc[:, 0]) tmp_dis = list(Port.iloc[:, 1]) N = len(J) k = 0 for i in L: if k < i: k = i count = 0 for t_l in tmp_load: if t == t_l: J_load.append(count) lk.append(count) ld.append(count) count = count + 1 count = 0 for t_d in tmp_dis: if t == t_d: J_dis.append(count) ld.append(count) count = count + 1 for t_k in range(N): if t > tmp_load[t_k] and t < tmp_dis[t_k]: J_keep.append(J[t_k]) lk.append(t_k) J_t_load.append(J_load) J_t_keep.append(J_keep) J_t_dis.append(J_dis) J_lk.append(lk) J_ld.append(ld) # ============================================== # print(Port) # print(Booking) # print(T) # print(L) # print(D) # print(J) # print(U) # print(J_t_load) # print(J_t_keep) # print(J_t_dis) # print(J_lk) # print(J_ld) # print(gang_num) # print(J_large_divide) # print("\n") # ============================================== # モデリング1(定数・変数の設定) # ============================================================================================== # Gurobiパラメータ設定 GAP_SP = gp.Model() GAP_SP.setParam("TimeLimit", 7200) GAP_SP.setParam("MIPFocus", 1) GAP_SP.setParam("LPMethod", 1) GAP_SP.printStats() # ハイパーパラメータ設定 # 各目的関数の重み w1 = 1 w2 = 1 w3 = 1 w4 = 1 w5 = 0 # 最小分割RT v_min = 10 # 目的関数1のペナルティ penal1_z = 10 # 目的関数2のペナルティ penal2_load = 1 penal2_dis = 10 # 目的関数3のペナルティ penal3_m = 10 # 目的関数4のチェックポイント check_point = Check_port # 目的関数5のペナルティ penal5_k = 1000 # 最適化変数 # V_ij:注文jをホールドiにkRT割り当てる V_ij = {} for i in I: for j in J: V_ij[i, j] = GAP_SP.addVar(lb=0, ub=A[j], vtype=gp.GRB.CONTINUOUS, name=f"V_ij({i},{j})") # 目的関数1 # X_ij:注文jをホールドiに割り当てるなら1、そうでなければ0 X_ij = GAP_SP.addVars(I, J, vtype=gp.GRB.BINARY) # Y_keep_it:港tにおいてホールドiを通過する注文があるなら1、そうでなければ0 Y_keep_it = GAP_SP.addVars(I, T, vtype=gp.GRB.BINARY) # Y_it1t2:ホールドiにおいてt1で積んでt2で降ろす注文があるなら1、そうでなければ0 Y_it1t2 = GAP_SP.addVars(I, T, T, vtype=gp.GRB.BINARY) # Z_it1t2:ホールドiにおいてt2を通過する注文があるとき異なる乗せ港t1の数分のペナルティ Z_it1t2 = GAP_SP.addVars(I, L, D, vtype=gp.GRB.BINARY) OBJ1 = gp.quicksum(w1 * penal1_z * Z_it1t2[i, t1, t2] for i in I for t1 in L for t2 in D) # 目的関数2 # Y_load_i1i2t:港tにおいてホールドペア(i1,i2)で積む注文があるなら1 Y_load_i1i2t = GAP_SP.addVars(I, I, L, vtype=gp.GRB.BINARY) # Y_keep_i1i2t:港tにおいてホールドペア(i1,i2)を通過する注文があるなら1 Y_keep_i1i2t = GAP_SP.addVars(I, I, T, vtype=gp.GRB.BINARY) # Y_dis_i1i2t:港tにおいてホールドペア(i1,i2)で揚げる注文があるなら1 Y_dis_i1i2t = GAP_SP.addVars(I, I, D, vtype=gp.GRB.BINARY) # ホールドペア(i1,i2)においてtで注文を積む際に既にtで積んだ注文があるときのペナルティ Z1_i1i2t = GAP_SP.addVars(I, I, L, vtype=gp.GRB.BINARY) # ホールドペア(i1,i2)においてtで注文を揚げる際にtを通過する注文があるときのペナルティ Z2_i1i2t = GAP_SP.addVars(I, I, D, vtype=gp.GRB.BINARY) OBJ2_1 = gp.quicksum(penal2_load * Z1_i1i2t[i1, i2, t] for i1 in I for i2 in I for t in L) OBJ2_2 = gp.quicksum(penal2_dis * Z2_i1i2t[i1, i2, t] for i1 in I for i2 in I for t in D) OBJ2 = w2 * (OBJ2_1 + OBJ2_2) # 目的関数3 # M_it:港tにおいてホールドiが作業効率充填率を超えたら1 M_it = GAP_SP.addVars(I, T, vtype=gp.GRB.BINARY) # M_ijt:港tにおいてホールドiに自動車を積むまでに作業効率充填率を上回ったホールドに自動車を通すペナルティ M_ijt = GAP_SP.addVars(I, J, T, lb=0, vtype=gp.GRB.CONTINUOUS) OBJ3 = gp.quicksum(w3 * penal3_m * M_ijt[i, j, t] for i in I for j in J for t in T) # 目的関数4 # N_jt:チェックポイントにおけるホールドiの残容量 N_it = GAP_SP.addVars(I, check_point, lb=0, vtype=gp.GRB.CONTINUOUS) OBJ4 = gp.quicksum(w4 * N_it[i, t] * RT_benefit[i] for i in I for t in check_point) # 目的関数5 # K1_it:lampで繋がっている次ホールドが充填率75%を上回ったら1、そうでなければ0 K1_it = GAP_SP.addVars(I_lamp, L, vtype=gp.GRB.BINARY) # K2_it:ホールドiが1RT以上のスペースがあったら1、そうでなければ0 K2_it = GAP_SP.addVars(I, L, lb=0, vtype=gp.GRB.BINARY) # K3_it:目的関数5のペナルティ K3_it = GAP_SP.addVars(I_lamp, L, lb=0, vtype=gp.GRB.CONTINUOUS) OBJ5 = gp.quicksum(w5 * penal5_k * K3_it[i, t] for i in I_lamp for t in L) # 目的関数の設計 OBJ = OBJ1 + OBJ2 + OBJ3 - OBJ4 + OBJ5 GAP_SP.setObjective(OBJ, gp.GRB.MINIMIZE) # モデリング2(制約) # ============================================================================================== # 基本制約 # ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ # 高さ制約 # ホールドの高さ HoldHeightVar = [] for i in range(len(HoldHeight)): HoldHeightVar.append(GAP_SP.addVar(lb=0, vtype=gp.GRB.CONTINUOUS)) # 車の高さ VehicleHeightVar = [] for i in range(len(VehicleHeight)): VehicleHeightVar.append(GAP_SP.addVar(lb=0, vtype=gp.GRB.CONTINUOUS)) # 制約式 for i in range(len(HoldHeight)): for j in range(len(VehicleHeight)): GAP_SP.addConstr( VehicleHeightVar[j] * X_ij[i, j] <= HoldHeightVar[i]) # 割当てた注文がコンパートメント毎にリソースを超えない GAP_SP.addConstrs(gp.quicksum(V_ij[i, j] for j in J) <= B[i] for i in I) # 全注文内の自動車の台数を全て割り当てる GAP_SP.addConstrs(gp.quicksum(V_ij[i, j] for i in I) == A[j] for j in J) # VとXの制約 GAP_SP.addConstrs(V_ij[i, j] / A[j] <= X_ij[i, j] for i in I for j in J) # 目的関数の制約 # ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ # 目的関数1の制約 for t in T: GAP_SP.addConstrs(X_ij[i, j] <= Y_keep_it[i, t] for i in I for j in J_t_keep[t]) for t in D: t2 = t for t1 in L: J_sub = [] # J_sub:t1で積んでt2で揚げる注文の集合 for j in J_t_dis[t2]: if j in J_t_load[t1]: J_sub.append(j) GAP_SP.addConstrs(X_ij[i, j] <= Y_it1t2[i, t1, t2] for i in I for j in J_sub) GAP_SP.addConstrs(Z_it1t2[i, t1, t2] <= Y_it1t2[i, t1, t2] for i in I) GAP_SP.addConstrs(Z_it1t2[i, t1, t2] <= Y_keep_it[i, t2] for i in I) GAP_SP.addConstrs( Z_it1t2[i, t1, t2] >= Y_it1t2[i, t1, t2] + Y_keep_it[i, t2] - 1 for i in I) # 目的関数2の制約 for t in T: for i1, i2 in I_pair: GAP_SP.addConstrs( X_ij[i1, j] + X_ij[i2, j] <= 2 * Y_keep_i1i2t[i1, i2, t] for j in J_t_keep[t]) if t in L: GAP_SP.addConstrs( X_ij[i1, j] + X_ij[i2, j] <= 2 * Y_load_i1i2t[i1, i2, t] for j in J_t_load[t]) GAP_SP.addConstr( Z1_i1i2t[i1, i2, t] <= Y_load_i1i2t[i1, i2, t]) GAP_SP.addConstr( Z1_i1i2t[i1, i2, t] <= Y_keep_i1i2t[i1, i2, t]) GAP_SP.addConstr( Z1_i1i2t[i1, i2, t] >= Y_load_i1i2t[i1, i2, t] + Y_keep_i1i2t[i1, i2, t] - 1) if t in D: GAP_SP.addConstrs( X_ij[i1, j] + X_ij[i2, j] <= 2 * Y_dis_i1i2t[i1, i2, t] for j in J_t_dis[t]) GAP_SP.addConstr(Z2_i1i2t[i1, i2, t] <= Y_dis_i1i2t[i1, i2, t]) GAP_SP.addConstr( Z2_i1i2t[i1, i2, t] <= Y_keep_i1i2t[i1, i2, t]) GAP_SP.addConstr( Z2_i1i2t[i1, i2, t] >= Y_dis_i1i2t[i1, i2, t] + Y_keep_i1i2t[i1, i2, t] - 1) # 目的関数3の制約 for t in T: GAP_SP.addConstrs(M_it[i, t] >= -Stress[i] + (gp.quicksum(V_ij[i, j] for j in J_t_keep[t]) / B[i]) for i in I) for i1 in I: I_primetmp = [] for k in Ml_Load.iloc[i1, :]: I_primetmp.append(k) I_prime = [x for x in I_primetmp if str(x) != 'nan'] I_prime.pop(0) GAP_SP.addConstrs(M_ijt[i1, j, t] >= gp.quicksum(M_it[i2, t] for i2 in I_prime) for j in J_ld[t]) # 目的関数4の制約 for t in check_point: GAP_SP.addConstrs(N_it[i, t] <= B[i] - gp.quicksum(V_ij[i, j] for j in J_lk[t]) for i in I) # 目的関数5の制約 GAP_SP.addConstrs( K1_it[i, t] >= -0.75 + gp.quicksum(V_ij[i, j] for j in J_lk[t]) / B[i] for i in I_lamp for t in L) GAP_SP.addConstrs(K2_it[i, t] >= 1 - (gp.quicksum(V_ij[i, j] for j in J_lk[t]) + 1) / B[i] for i in I for t in L) for i in range(len(Ml_Back)): i1 = Ml_Back.iloc[i, 0] I_backtmp = [] for k in Ml_Back.iloc[i, :]: I_backtmp.append(k) I_back_i1 = [x for x in I_backtmp if str(x) != 'nan'] I_back_i1.pop(0) GAP_SP.addConstrs(K3_it[i1, t] >= len(I) * (K1_it[i1, t] - 1) + gp.quicksum(K2_it[i2, t] for i2 in I_back_i1) for t in L) # 特殊制約1(注文の分割制約) # ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ # J_smallを分割しない GAP_SP.addConstrs(gp.quicksum(X_ij[i, j] for i in I) == 1 for j in J_small) # 10RT以下に分割しない # GAP_SP.addConstrs(V_ij[i, j] + v_min * (1 - X_ij[i, j]) # >= v_min for i in I for j in J) # 特殊制約2(移動経路制約) # ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ # 港を通過する荷物が移動の邪魔をしない for t in T: for i1 in I: I_primetmp = [] Frtmp = [] for k in Ml_Load.iloc[i1, :]: I_primetmp.append(k) for k in Ml_Afr.iloc[i1, :]: Frtmp.append(k) I_prime = [int(x) for x in I_primetmp if str(x) != 'nan'] Fr = [x for x in Frtmp if str(x) != 'nan'] I_prime.pop(0) Fr.pop(0) N_prime = len(I_prime) for k in range(N_prime): i2 = int(I_prime[k]) GAP_SP.addConstrs( gp.quicksum(V_ij[i2, j1] for j1 in J_t_keep[t]) / B[i2] <= 1 + Fr[k] - X_ij[i1, j2] for j2 in J_ld[t]) # 特殊制約3(船体重心の制約) # ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ # 船の上下前後の配置バランスが閾値を超えない for t in T: # 荷物を全て降ろしたとき GAP_SP.addConstr( gp.quicksum(delta_h[i] * U[j] * G[j] * V_ij[i, j] / A[j] for j in J_t_keep[t] for i in I) <= max_h) GAP_SP.addConstr( gp.quicksum(delta_s[i] * U[j] * G[j] * V_ij[i, j] / A[j] for j in J_t_keep[t] for i in I) <= max_s) GAP_SP.addConstr( gp.quicksum(delta_s[i] * U[j] * G[j] * V_ij[i, j] / A[j] for j in J_t_keep[t] for i in I) >= min_s) # 荷物を全て載せたとき GAP_SP.addConstr( gp.quicksum(delta_h[i] * U[j] * G[j] * V_ij[i, j] / A[j] for j in J_lk[t] for i in I) <= max_h) GAP_SP.addConstr( gp.quicksum(delta_s[i] * U[j] * G[j] * V_ij[i, j] / A[j] for j in J_lk[t] for i in I) <= max_s) GAP_SP.addConstr( gp.quicksum(delta_s[i] * U[j] * G[j] * V_ij[i, j] / A[j] for j in J_lk[t] for i in I) >= min_s) # 特殊制約4(ギャングの制約) # ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ """ count = 0 for t in L: gang = gang_num[count] if gang == 2: gang_low = GANG2[0] gang_high = GANG2[1] #ギャングの担当領域毎に均等に注文を分ける GAP_SP.addConstr(gp.quicksum(V_ij[i1,j] for i1 in gang_low for j in J_t_load[t]) - gp.quicksum(V_ij[i2,j] for i2 in gang_high for j in J_t_load[t]) <= 100) GAP_SP.addConstr(gp.quicksum(V_ij[i1,j] for i1 in gang_low for j in J_t_load[t]) - gp.quicksum(V_ij[i2,j] for i2 in gang_high for j in J_t_load[t]) >= -100) if gang == 3: gang_low = GANG3[0] gang_mid = GANG3[1] gang_high = GANG3[2] #ギャングの担当領域毎に均等に注文を分ける GAP_SP.addConstr(gp.quicksum(V_ij[i1,j] for i1 in gang_low for j in J_t_load[t]) - gp.quicksum(V_ij[i2,j] for i2 in gang_mid for j in J_t_load[t]) <= 100) GAP_SP.addConstr(gp.quicksum(V_ij[i1,j] for i1 in gang_low for j in J_t_load[t]) - gp.quicksum(V_ij[i2,j] for i2 in gang_mid for j in J_t_load[t]) >= -100) GAP_SP.addConstr(gp.quicksum(V_ij[i1,j] for i1 in gang_low for j in J_t_load[t]) - gp.quicksum(V_ij[i2,j] for i2 in gang_high for j in J_t_load[t]) <= 100) GAP_SP.addConstr(gp.quicksum(V_ij[i1,j] for i1 in gang_low for j in J_t_load[t]) - gp.quicksum(V_ij[i2,j] for i2 in gang_high for j in J_t_load[t]) >= -100) GAP_SP.addConstr(gp.quicksum(V_ij[i1,j] for i1 in gang_mid for j in J_t_load[t]) - gp.quicksum(V_ij[i2,j] for i2 in gang_high for j in J_t_load[t]) <= 100) GAP_SP.addConstr(gp.quicksum(V_ij[i1,j] for i1 in gang_mid for j in J_t_load[t]) - gp.quicksum(V_ij[i2,j] for i2 in gang_high for j in J_t_load[t]) >= -100) """ # 最適化計算 # ============================================================================================== print( "\n========================= Solve Assignment Problem =========================" ) GAP_SP.optimize() # 解の保存 # ============================================================================================== # 目的関数の値 val_opt = GAP_SP.ObjVal # ペナルティ計算 print("-" * 65) print("penalty count => ") # OBJ1のペナルティ penal1 = 0 for i in I: for t1 in L: for t2 in D: if Z_it1t2[i, t1, t2].X > 0: penal1 = penal1 + Z_it1t2[i, t1, t2].X # OBJ2のペナルティ penal2_1 = penal2_2 = 0 for i1 in I: for i2 in I: for t in L: if Z1_i1i2t[i1, i2, t].X > 0: penal2_1 = penal2_1 + 1 # print(f"ホールド{i1},{i2}で積み地ペナルティ") for t in D: if Z2_i1i2t[i1, i2, t].X > 0: penal2_2 = penal2_2 + 1 # print(f"ホールド{i1},{i2}で揚げ地ペナルティ") # OBJ3のペナルティ penal3 = 0 for i in I: for j in J: for t in T: if M_ijt[i, j, t].X > 0: penal3 = penal3 + M_ijt[i, j, t].X # OBJ4のペナルティ benefit4 = 0 for t in check_point: for i in I: if N_it[i, t].X > 0: benefit4 = benefit4 + N_it[i, t].X # OBJ5のペナルティ penal5 = 0 for t in L: for i in I_lamp: if K3_it[i, t].X > 0: penal5 = penal5 + K3_it[i, t].X # 解の書き込み answer = [] assign = [] for i in I: for j in J: if V_ij[i, j].X > 0: # assign_data[ホールド番号、注文番号、積載RT,RT、ユニット数、積み地、揚げ地] answer.append([i, j]) assign.append([0, 0, V_ij[i, j].X, 0, 0, "L", "D"]) print("") print("[weight]") print(f"Object1's weight : {w1}") print(f"Object2's weight : {w2}") print(f"Object3's weight : {w3}") print(f"Object4's weight : {w4}") print(f"Object5's weight : {w5}") print("") print("[penalty & benefit]") print( f"Different discharge port in one hold : {penal1_z} × {penal1}" ) print( f"Different loading port in pair hold : {penal2_load} × {penal2_1}" ) print( f"Different discharge port in pair hold : {penal2_dis} × {penal2_2}" ) print( f"The number of cars passed holds that exceed threshold : {penal3_m} × {penal3}" ) print( f"The benefit remaining RT of hold near the entrance : {benefit4}") print( f"The penalty of total dead space : {penal5_k} × {penal5}" ) print("") print(f" => Total penalty is {val_opt}") print("-" * 65) # 残リソース I_left_data = Hold.iloc[:, 0:2] for k in range(len(assign)): key = Booking.columns.get_loc('Index') i_t = answer[k][0] j_t = int(Booking.iloc[answer[k][1], key]) # hold_ID assign[k][0] = Hold.iloc[i_t, 0] # order_ID assign[k][1] = Booking.iloc[j_t, Booking.columns.get_loc('Order_num')] # RT assign[k][3] = Booking.iloc[j_t, Booking.columns.get_loc('RT')] # Units(original booking) assign[k][4] = Booking.iloc[j_t, Booking.columns.get_loc('Units')] """ for j in range(len(divide_dic)): if assign[k][1] - 1 == divide_dic[j][0]: assign[k][3] = divide_dic[j][1] """ # L_port assign[k][5] = Booking.iloc[j_t, Booking.columns.get_loc('LPORT')] # D_port assign[k][6] = Booking.iloc[j_t, Booking.columns.get_loc('DPORT')] # 残リソース計算 I_left_data.iloc[answer[k][0], 1] = I_left_data.iloc[answer[k][0], 1] - assign[k][2] if I_left_data.iloc[answer[k][0], 1] < 0.1: I_left_data.iloc[answer[k][0], 1] = 0 csv = [] for k in range(len(assign)): if assign[k][2] > 0.1: csv.append(assign[k]) c_list = [] c_list.append("Hold_ID") c_list.append("Order_ID") c_list.append("Load_RT") c_list.append("RT_sum") c_list.append("Units") c_list.append("LPORT") c_list.append("DPORT") assign_data = pd.DataFrame(csv, columns=c_list) assign_data.to_excel('result/assignment.xlsx', index=False, columns=c_list) I_left_data.to_excel('result/leftRT.xlsx', index=False)
def _build_model(self): self.model = gb.Model() self._build_variables() self._build_objective() self._build_constraints()
@author: woute """ from Iteration import * import gurobipy as grb raw_input = ('Hit Enter to continue') row_loop = True #Same as 'Iteration.py' while row_loop == True: m = grb.Model('MinAllocCost') # DECISION VARIABLES tpre = {} #t_p^r,e tprb = {} #t_p^r,b fik = {} #f_i^k yak = {} #y_a^k ### CREATE INITIAL DECISION VARIABLES ########################################################################################### #t_p^r for economy for p in range(len(itinerary_no)): for r in list(r_obj[p]): tpre[p,r] = m.addVar(vtype=GRB.CONTINUOUS, lb=0, name="t_%s^{%s,e}"%(p,r)) tpre[r,p] = m.addVar(vtype=GRB.CONTINUOUS, lb=0,
#!/usr/bin/env python3 import gurobipy as gb m = gb.Model() x1 = m.addVar(lb=-gb.GRB.INFINITY, ub=gb.GRB.INFINITY, vtype=gb.GRB.CONTINUOUS) x2 = m.addVar(lb=-gb.GRB.INFINITY, ub=gb.GRB.INFINITY, vtype=gb.GRB.CONTINUOUS) m.update() m.addConstr(-4 * x1 - 9 * x2 <= -18) m.addConstr((3 / 2) * x1 - x2 <= 27 / 4) m.addConstr(-(8 / 17) * x1 + x2 <= 2) m.setObjective(-x1 + 2 * x2, sense=gb.GRB.MINIMIZE) m.optimize() print('') print('Optimal solution?: ', m.status == gb.GRB.OPTIMAL) print('Optimal objective: ', m.objVal) print('Solution: x1 = {0}, x2 = {1}'.format(x1.x, x2.x))
def optimize_test_capacity_multiple_vaccines(T, B, Delta, Capacity, heu_result, alpha): m = gp.Model("vaccinations") somma = sum(B["Pfizer"]) + sum(B["Astrazeneca"]) + sum(B["Moderna"]) m.Params.LogToConsole = 0 dicti = {} dict_B = {} for i in B: for j in range(0, T): dicti[(i, j)] = [j+1] dict_B[(i,j)] = B[i][j] original_B = B B = dict_B combinations, time_frame = gp.multidict(dicti) first_doses = m.addVars(combinations, lb=0.0, vtype=GRB.INTEGER, name="First_Doses") second_doses = m.addVars(combinations, lb = 0.0, vtype=GRB.INTEGER, name="Second_Doses") stocks = m.addVars(combinations, lb=0.0, vtype=GRB.INTEGER, name="Stocks") z = m.addVar(lb = 0.0, vtype = GRB.INTEGER, name="Z") m.addConstrs( (first_doses.sum('*',j) + second_doses.sum('*', j) <= Capacity for j in range(0, T))) m.addConstrs( (first_doses[j, i] == second_doses[j,i+Delta[j]] for j, i in combinations if i < T-Delta[j] )) m.addConstrs( (first_doses[j, i] == 0 for j, i in combinations if i >= T-Delta[j] )) m.addConstrs( second_doses[j,i] == 0 for j, i in combinations if i < Delta[j]) m.addConstrs( (first_doses[j,i] + 0 + stocks[j,i] == B[j,i] + 0 for j, i in combinations if i == 0)) m.addConstrs( (first_doses[j,i] + 0 + stocks[j,i] == B[j,i] + stocks[j,i-1] for j, i in combinations if i >= 1 and i < Delta[j])) m.addConstrs( (first_doses[j,i] + first_doses[j,i-Delta[j]] + stocks[j,i] == B[j,i] + stocks[j, i-1] for j, i in combinations if i >= 1 and i >= Delta[j])) for i in range(0, 180): m.addConstr( z >= first_doses["Astrazeneca",i] + first_doses["Moderna",i] + first_doses["Pfizer",i] + second_doses["Astrazeneca",i] + second_doses["Moderna",i] + second_doses["Pfizer",i]) # m.setObjective( alpha * (z / Capacity ) + (1-alpha) * ( ( ( gp.quicksum(second_doses[j,i] * i for j,i in combinations ) + stocks["Pfizer", T-1] * (180 + Delta["Pfizer"]) + stocks["Moderna", T-1] * (180 + Delta["Moderna"]) + stocks["Astrazeneca", T-1] * (180 + Delta["Astrazeneca"]) ) / (somma / 2) ) / heu_result ) + ( 1000 * ( stocks['Pfizer', T-1] + stocks['Moderna', T-1] + stocks['Astrazeneca', T-1]) ), GRB.MINIMIZE) m.setObjective( alpha * (z) + (1-alpha) * ( ( ( gp.quicksum(second_doses[j,i] * i for j,i in combinations ) + stocks["Pfizer", T-1] * (180 + Delta["Pfizer"]) + stocks["Moderna", T-1] * (180 + Delta["Moderna"]) + stocks["Astrazeneca", T-1] * (180 + Delta["Astrazeneca"]) ) / (1) ) / 1) + 1000 * (stocks["Astrazeneca", T-1] + stocks["Moderna", T-1] + stocks["Pfizer", T-1]) , GRB.MINIMIZE) m.optimize() if (m.solCount > 0): resultList = m.getAttr(GRB.Attr.X, m.getVars()) first_doses_dict = {} second_doses_dict = {} stocks_dict = {} for i in range(0, len(original_B)): first_doses_dict[list(original_B)[i]] = resultList[T*i:T*(i+1)] first_doses_values = resultList[T*i:T*(i+1)] for i in range(0, len(original_B)): second_doses_dict[list(original_B)[i]] = resultList[T*(i+len(original_B)):T*(i+1+len(original_B))] second_doses_values = resultList[T*(i+len(original_B)):T*(i+1+len(original_B))] for i in range(0, len(original_B)): stocks_dict[list(original_B)[i]] = resultList[T*(i+2*len(original_B)):T*(i+1+2*len(original_B))] stock_values = resultList[T*(i+2*len(original_B)):T*(i+1+2*len(original_B))] max_value = 0 for kk in range (0, 180): somma = second_doses["Astrazeneca", kk].X + second_doses["Moderna",kk].X + second_doses["Pfizer", kk].X + first_doses["Astrazeneca", kk].X + first_doses["Moderna",kk].X + first_doses["Pfizer", kk].X if somma > max_value: max_value = somma object_function_value = m.objVal return[first_doses_dict, second_doses_dict, stocks_dict, object_function_value, z.X] else: print("\n***** No solutions found *****")
from math import exp def f(u): return exp(-u) def g(u): return 2 * u * u - 4 * u try: # Create a new model m = gp.Model() # Create variables lb = 0.0 ub = 1.0 x = m.addVar(lb, ub, name='x') y = m.addVar(lb, ub, name='y') z = m.addVar(lb, ub, name='z') # Set objective for y m.setObjective(-y) # Add piecewise-linear objective functions for x and z
A[:,:-1]=mp B[:,:-1]=uc for loop in range(len(test_mean)): l[loop,int(alllabels[loop])]=1 l[loop,150]=0.5 # escalation and negative data set have ones on the last column for loop in range(len(test_mean), len(alllabels)): l[loop, 150]=1 #best result try: m = grby.Model("Optimal Threshold Problem") rowcount = len(A) ncl=151 # x = m.addVars(rowcount*ncl, vtype=GRB.BINARY, name="x") # b = m.addVar(lb=0.0, ub=1.0, vtype=GRB.CONTINUOUS, name="b") # c = m.addVar(lb=0.0, ub=1.0, vtype=GRB.CONTINUOUS, name="c") # d = m.addVar(lb=0.0, ub=3.0, vtype=GRB.CONTINUOUS, name="d") x = m.addVars(rowcount*ncl, vtype=GRB.BINARY, name="x") y = m.addVars(rowcount*ncl, vtype=GRB.BINARY, name="y") z = m.addVars(rowcount*ncl, vtype=GRB.BINARY, name="z") b = m.addVar(lb=0.0, ub=1.0, vtype=GRB.CONTINUOUS, name="b") c = m.addVar(lb=0.0, ub=1.0, vtype=GRB.CONTINUOUS, name="c")
def _construct_local_problem(self, scenario, lambda_k): # TODO I generate the entire local model every iteration, even though the only thing changing is the objective # It would be faster to store the model once it's generated the first time and then to just change the objective. ################################################################## # local optimization program (inner problem) for single scenario # ################################################################## scenario_program = gb.Model() # -- variables -- # x = {} for i in range(self.n_x): x[i] = scenario_program.addVar( obj=scenario.c[1][i] * scenario.probability - lambda_k[i], lb=scenario.lb[1][i], ub=scenario.ub[1][i], vtype=scenario.vtype[1][i], name='x{}'.format(i)) y = {} for i in range(self.n_y): y[i] = scenario_program.addVar(obj=scenario.c[2][i] * scenario.probability, lb=scenario.lb[2][i], ub=scenario.ub[2][i], vtype=scenario.vtype[2][i], name='y{}'.format(i)) scenario_program.update() # -- constraints -- # # first stage (sparse matrix) lhs = defaultdict(gb.LinExpr) for entry in scenario.A[1, 1].items(): row, column = entry[0] value = entry[1] lhs[row] = lhs[row] + value * x[column] for row, value in enumerate(scenario.b[1]): scenario_program.addConstr(lhs[row], scenario.b_sense[1][row], scenario.b[1][row], name='stage1_row{}'.format(row)) # constraints, second-stage; contribution to lhs from A[2,1] lhs_1 = defaultdict(gb.LinExpr) for entry in scenario.A[2, 1].items(): row, column = entry[0] value = entry[1] lhs_1[row] = lhs_1[row] + value * x[column] # contribution from A[2,2] lhs_2 = defaultdict(gb.LinExpr) for entry in scenario.A[2, 2].items(): row, column = entry[0] value = entry[1] lhs_2[row] = lhs_2[row] + value * y[column] for row, value in enumerate(scenario.b[2]): scenario_program.addConstr(lhs_1[row] + lhs_2[row], scenario.b_sense[2][row], scenario.b[2][row], name='stage2_sc{}_row{}'.format( scenario.scenario_id, row)) scenario_program.update() return scenario_program, x, y
def solve_optimization(x, mu, c=1.0, k=GaussianKernel(), tolerance=1e-4, adjustment=0): '''Builds and solves the constrained optimization problem on the basis of the fuzzy learning procedure. Arguments: - x: iterable of objects - mu: iterable of membership values for the objects in x - c: constant managing the trade-off in joint radius/error optimization - k: kernel function to be used - tolerance: tolerance to be used in order to clamp the problem solution to interval extremes - adjustment: diagonal adjustment in order to deal with non PSD matrices Returns: a lists containing the optimal values for the two sets of independent variables chis of the problem Throws: - ValueError if c is non-positive or if x and mu have different lengths ''' if c <= 0: raise ValueError('c should be positive') if len(x) != len(mu): raise ValueError('patterns and labels have different length') m = len(x) mu = np.array(mu) model = gpy.Model('possibility-learn') model.setParam('OutputFlag', 0) for i in range(m): if c < np.inf: model.addVar(name='chi_%d' % i, lb=-c * (1 - mu[i]), ub=c * mu[i], vtype=gpy.GRB.CONTINUOUS) else: model.addVar(name='chi_%d' % i, vtype=gpy.GRB.CONTINUOUS) model.update() chis = model.getVars() obj = gpy.QuadExpr() for i, j in it.product(range(m), range(m)): obj.add(chis[i] * chis[j], k.compute(x[i], x[j])) for i in range(m): obj.add(-1 * chis[i] * k.compute(x[i], x[i])) if adjustment: for i in range(m): obj.add(adjustment * chis[i] * chis[i]) model.setObjective(obj, gpy.GRB.MINIMIZE) constEqual = gpy.LinExpr() constEqual.add(sum(chis), 1.0) model.addConstr(constEqual, gpy.GRB.EQUAL, 1) model.optimize() if model.Status != gpy.GRB.OPTIMAL: raise ValueError('optimal solution not found!') chis_opt = [ chop(ch.x, l, u, tolerance) for ch, l, u in zip(chis, -c * (1 - np.array(mu)), c * np.array(mu)) ] return chis_opt
def interior_point_using_distance(coefficients, nCuts, dim, marker, weight, index=-1): ''' Get the interior point from the certain region described by marker. The returned point should be far from all the hyperplanes. coefficients: the coefficients of hyperplanes with the same order. For example, (a1, a2, a3, c) in the hyperplane (a1 * x1 + a2 * x2 + a3 * x3 + c = 0) nCuts: the number of the hyerplanes. Dim: the dimension of the space. marker: the sign of the hyperplane. weight: calcualte the norm 2 of the coefficients except the constant of all hyperplanes index: the hyperplane we want to trim. Usually index = -1, which means no hyperplane will be trimed. Here, we add the different weights for different hyperplanes when we calculate the distance. maximize z subject to A*x + b + weight*z <= np.spacing(1), for all sign >=0 -1*(A*x + b) + weight*z <= np.spacing(1), for all sign <= 0 ''' #Create a new model m = gb.Model('Interior_point') #Set parameters m.setParam('OutputFlag', False) x = [0 for i in xrange(dim)] for i in xrange(dim): x[i] = m.addVar(lb=-1e7, ub=1e7, vtype=gb.GRB.CONTINUOUS, name='x_%d' % (i)) obj = m.addVar(lb=0.0, vtype=gb.GRB.CONTINUOUS, name='objective') m.update() for i in xrange(nCuts): #hyperplane index is trimed, so there is no constraint for index hyperplane. if index != i: g_expr = gb.LinExpr() g_expr.addConstant(coefficients[i][-1]) for j in xrange(dim): g_expr.add(x[j] * coefficients[i][j]) if marker[i] == 0: m.addConstr(-1 * g_expr + weight[i] * obj <= np.spacing(0), name='qc_%d' % (i)) elif marker[i] == 1: m.addConstr(g_expr + weight[i] * obj <= np.spacing(0), name='qc_%d' % (i)) m.update() #Create the objective : maximize obj m.setObjective(obj, gb.GRB.MAXIMIZE) m.update() #Optimize the test problem. try: m.optimize() except gb.GurobiError as e: print e.message if m.Status == gb.GRB.OPTIMAL: xOpt = np.empty(dim) for i in xrange(dim): xOpt[i] = x[i].x return m.Status, xOpt, obj.x else: return m.Status, np.nan, np.nan
cut = [] for i,j in fullgraph.edges(): if i in subtourset and j not in subtourset: cut.append((i,j)) elif j in subtourset and i not in subtourset: cut.append((j,i)) #Add cut constraint varsx = Model.addVars(cut) for i,j in varsx.keys(): varsx[i,j] = vars[i,j] Model.addConstr(varsx.sum() >= 2) #Generate Gurobi model m = grb.Model() #Create variables - edges edgedict = dict(nx.get_edge_attributes(G, 'weight')) vars = m.addVars(edgedict.keys(), obj=edgedict, vtype=grb.GRB.BINARY, name='edge') for i,j in vars.keys(): vars[j,i] = vars[i,j] # edge in opposite direction is equal and referred to edge #Add initial constraints: Degree of each node = 2 m.addConstrs(vars.sum(i,'*') == 2 for i in G.nodes()) #First Iteration: m.optimize() FG = saveresult(draw=True) tour = findsubtour(FG, 'city 1')
def __init__(self, data, objective, nr_runways=1): """Represents an instance of the aircraft landing problem. - i as aircraft unique id within the problem instance - E as vector of earliest landing times - T as vector of target landing times - L as vector of latest landing times - h as vector of penalty costs per time unit before target landing time - g as vector of penalty cost per time unit after target landing time In addition, an instance can be solved for either one (default) or multiple runways which are treated equally. The problem can be solved for two objectives: - linear: minimize weighted earliness and lateness - non-linear: maximize utilization (earliness) Args: data (list of ints): instance data according to the specification of the OR library (see Beasley (1990)). objective (ALP.Objective): 'min_cost' for minimized weighted earliness and lateness or 'max_util' for maximized earliness nr_runways (int): number of equally treated runways the instance should be solved for """ # store persistent copy of input data self._data = copy.copy(data) # Parse input data self.E = list() self.T = list() self.L = list() self.S = list() self.h = list() self.g = list() self.nr_planes = int(data.pop(0)) int(data.pop(0)) # freeze time: discarded for i in range(self.nr_planes): int(data.pop(0)) # appearance time: discarded self.E.append(int(data.pop(0))) # earliest landing time self.T.append(int(data.pop(0))) # target landing time self.L.append(int(data.pop(0))) # latest landing time self.g.append(data.pop(0)) # penalty before target self.h.append(data.pop(0)) # penalty after target # separation times to preceeding aircraft self.S.append([int(data.pop(0)) for j in range(self.nr_planes)]) # fig = plt.figure() # ax = fig.add_subplot(111) # plt.plot(range(self.nr_planes),self.E) # plt.plot(range(self.nr_planes),self.T) # plt.plot(range(self.nr_planes),self.L) # plt.legend(["earliest landing time", "target landing time", "latest landing time"], loc="upper right") # plt.xlabel("planes") # plt.ylabel("time") # ax.xaxis.set_major_locator(MaxNLocator(integer=True)) # plt.savefig("Test_data.png") if nr_runways <= 0: raise ValueError("Illegal number of runways: %d" % nr_runways) else: self.nr_runways = nr_runways # Perform Pre-Processing self.U, self.V, self.W = self._preprocess_airplanes() # Configure linear program self._objective = objective self._mode = None # model is only solvable for linear objective if self._objective is ALP.Objective.min_cost: # maintain separate models to avoid re-building if mode is switched self._objectives = {ALP.Mode.normal: None, ALP.Mode.relaxed: None} self._normal_model = grb.Model() self._relaxed_model = grb.Model() self._constrs = { self._normal_model: dict(), self._relaxed_model: dict() } # store all constraints self._dvars = { self._normal_model: dict(), self._relaxed_model: dict() } # store all decision variables self._build_dynamic_model(self._normal_model) self._enforce_sep_time(self._normal_model) self._build_dynamic_model(self._relaxed_model) self._relax_sep_time(self._relaxed_model)
def pov_oracle_iter(e, cand, mu, stepsize): t0 = time.process_time() convex = False opp = cand.opp # if cand.id == "A": # A, B = cand, cand.opp # else: # B, A = cand, cand.opp m = gp.Model("POV") c = e.theta + (opp.goal - e.theta) * opp.p * opp.X u = cand.marginal_payoff(e, opp.X) # decision variables, bounded between 0 and 1 X = m.addVars([i for i in range(e.n)], name=["X" + str(i) for i in range(e.n)], ub=[1./cand.p[i] for i in range(e.n)]) # objective function obj = gp.QuadExpr() for i in range(e.n): y = 0 for j in range(e.n): y += e.P_T.item(i, j) * (e.theta[j] + (opp.goal - e.theta[j]) * opp.p[j] * opp.X[j] + (cand.goal-e.theta[j]) * cand.p[j]*X[j] \ + (2 * e.theta[j] - 1) * cand.p[j] * opp.p[j] * opp.X[j] * X[j]) obj += y * y # check if either A losing and optimizing for A, or B losing and optimizing for B if (mu < (e.n+1)/2 and cand.id == "A") or (mu > (e.n+1)/2 and cand.id == "B"): convex = True m.setObjective(obj, gp.GRB.MINIMIZE) else: convex = False m.setObjective(obj, gp.GRB.MAXIMIZE) m.params.NonConvex = 2 # budget constraint m.addConstr(X.sum() <= cand.k) # expected value constraint mean = gp.LinExpr() sign = 1 if cand.goal else -1 for i in range(e.n): mean += sign * X[i] * u[i] + e.alpha[i] * c[i] m.addConstr(mean == mu) # min/max opinion constraint m.addConstrs((X[i] <= cand.max_expenditure(e, opp.X, i) for i in range(e.n))) m.setParam("OutputFlag", 0); m.setParam('TimeLimit', 4*60) m.optimize() # for v in m.getVars(): # print('%s %g' % (v.varName, v.x)) # print('Obj: %g' % m.objVal) X_cand = [] for i, var in enumerate(m.getVars()): if var.x <=1: X_cand.append(var.x) else: X_cand.append(1/cand.p[i]) cand.X = X_cand print("Probability Xp", np.multiply(cand.X, cand.p)) assert all([x <=1.001 for x in list(np.multiply(cand.X, cand.p))]) assert all([x <=1 for x in list(np.multiply(cand.X, cand.p))]) print("Probability Xp", np.multiply(cand.X, cand.p)) t1 = time.process_time() return X_cand, convex, t1-t0
def solve(self, dict_data, sam, n_scenarios, time_limit=None, gap=None, verbose=False): nodes = range(dict_data['n_nodes']) scenarios = range(n_scenarios) problem_name = "StohasticSaphlp" logging.info("{}".format(problem_name)) model = gp.Model(problem_name) # Z is a vector that tells us the nodes which host a hub Z = model.addVars(dict_data['n_nodes'], lb=0, ub=1, vtype=GRB.INTEGER, name='Z') # X is a matrix which tells us which node is linked to a hub # (if Xik == 1, then node i is linked to a hub in node k, if Xik == 0 then no link b\w i and k) X = model.addVars(dict_data['n_nodes'], dict_data['n_nodes'], n_scenarios, lb=0, ub=1, vtype=GRB.INTEGER, name='X') # objective function 1st stage obj_funct = gp.quicksum(dict_data['f'][i] * Z[i] for i in nodes) # objective function 2nd stage - 1st term for s in scenarios: temp = 0 for i in nodes: for k in nodes: if i != k: temp += sam.c[i, k, s] * X[i, k, s] obj_funct += temp / n_scenarios # objective function 2nd stage - 2nd term A = 0 B = 0 C = 0 D = 0 for s in scenarios: s_term = 0 for i in nodes: for j in nodes: A = dict_data['d'][i, j] * Z[i] * Z[j] for l in nodes: if l != j: B += dict_data['d'][i, l] * Z[i] * X[j, l, s] for k in nodes: if i != k: C += dict_data['d'][k, j] * X[i, k, s] * Z[j] for l in nodes: for k in nodes: if i != k: if j != l: D += (dict_data['d'][k, l] * X[i, k, s] * X[j, l, s]) s_term += dict_data['alpha'] * sam.w[i, j, s] * (A + B + C + D) A = 0 B = 0 C = 0 D = 0 obj_funct += s_term / n_scenarios model.setObjective(obj_funct, GRB.MINIMIZE) # constraint equation 25 for s in scenarios: for i in nodes: sum_constr = 0 for k in nodes: if i != k: sum_constr += X[i, k, s] model.addConstr(sum_constr == (1 - Z[i]), f"only _one_hubs{s}") # constraint equation 26 for s in scenarios: for i in nodes: for k in nodes: if k != i: model.addConstr(X[i, k, s] <= Z[k], f"nodes_no connected{i, k, s}") model.update() if gap: model.setParam('MIPgap', gap) if time_limit: model.setParam(GRB.Param.TimeLimit, time_limit) if verbose: model.setParam('OutputFlag', 1) else: model.setParam('OutputFlag', 0) model.setParam('LogFile', './logs/gurobi.log') model.write("./logs/model.lp") start = time.time() model.optimize() end = time.time() comp_time = end - start solZ = np.zeros(shape=dict_data['n_nodes']) solX = np.zeros(shape=(dict_data['n_nodes'], dict_data['n_nodes'], n_scenarios)) of = -1 if model.status == GRB.Status.OPTIMAL: for k in nodes: grb_var1 = model.getVarByName(f"Z[{k}]") solZ[k] = grb_var1.X for s in scenarios: for i in nodes: for k in nodes: grb_var2 = model.getVarByName(f"X[{i},{k},{s}]") solX[i, k, s] = grb_var2.X of = model.getObjective().getValue() return of, solZ, solX, comp_time
def min_max_distance(pod_sites, blocks, distance, population, loadingSites, capacity, supplies, labor, cost, budget, opening_cost, bigM, max_days_open): ####### MODEL 2 m2 = gp.Model() ### Decision variables ## number of days POD is open for x2 = m2.addVars(pod_sites, vtype=GRB.CONTINUOUS, lb = 0.0) ## whether or not a block is assigned to a POD y2 = m2.addVars(pod_sites, blocks, vtype=GRB.BINARY) ## whether or not a POD is open z2 = m2.addVars(pod_sites, vtype=GRB.BINARY) ## M - the maximum distance any one car is allowed to travel M = m2.addVar(lb=0.0, obj=1.0, vtype=GRB.CONTINUOUS) ### Objective function ## want to minimize the total/weighted travel distance of Allegheny's population m2.setObjective(M) m2.modelSense = GRB.MINIMIZE ### Constraints ## all pod sites are bounded by a given capacity for i in pod_sites: #m1.addConstr(sum(y1[i, k]*population[k] for k in blocks) <= capacity[i]*x1[i]) m2.addConstr(sum(y2[i, k]*population[k] for k in blocks) == capacity[i]*x2[i]) m2.addConstr(z2[i]*bigM >= x2[i]) m2.addConstr(x2[i] <= max_days_open) ## each block is assigned to exactly 1 pod site for k in blocks: m2.addConstr(sum(y2[i, k] for i in pod_sites) == 1) # the total money used is at most the maximum budget m2.addConstr(sum(cost[i]*x2[i] + z2[i]*opening_cost for i in pod_sites) <= budget) for i in pod_sites: for k in blocks: ## max dist traveled for anyone is M m2.addConstr(distance[k, i]*y2[i,k] <= M) ## Solve m2.optimize() lst = [] lst_np = np.zeros([len(pod_sites), 1100]) pod_days = [] block_dist = [] #long_ls_vals = [] for i in pod_sites: for k in blocks: #if(x1[i].x >= 0): ## this will still print out all of them since weakly greater than 0. if(x2[i].x > 0): lst_np[i,k] = distance[k,i]*y2[i,k].x lst.append((budget, opening_cost, i, k, distance[k,i]*y2[i,k].x)) #long_ls_vals.append((budget, opening_cost, m1.objVal, i, x1[i].x, k, distance[k,i]*y1[i,k].x)) pod_days.append((i, x2[i].x)) for k in blocks: for i in pod_sites: if(y2[i, k].x > 0): block_dist.append((k, distance[k,i]*y2[i,k].x, i)) # Print optimized solution print(m2.objVal) return(m2.objVal, pod_days, block_dist)
} interest_rate = 0.03 additional_budget = 50 # creates lower triangular matrix needed in Value at Risk analysis in Q4 using Cholesky factorization # Note that this results in L to be in matrix format (i.e., not in the dataframe format anymore) L = np.linalg.cholesky(cov) ######################################## ########### MODEL ###################### ######################################## # Create an empty model m = gp.Model('portfolio') m.update() # ADD DECISION VARIABLES (AND FOR Q4 HELPER DECISION VARIABLES) HERE vars = pd.Series(m.addVars(projects, vtype=GRB.BINARY), index=projects) h = m.addVar() ######################################## #### CONSTRAINTS & OBJ FUNCTIONS ####### ######################################## # ADD CONSTRAINTS HERE for x in ther: m.addConstr(sum(vars * cost * (t_area == x)) <= t_bud[x], f'{x} budget') m.addConstr(sum(vars * (ttm == '1')) >= 0.15 * sum(vars), '1 year')
def lp_scheduler(M, DAG, M_SRC, M_SNK, G, P, C, S, R, L_SLO): print("M_SRC Source Nodes:") print(M_SRC) print("M_SNK Sink Nodes:") print(M_SNK) print("DAG:") print(DAG) P_conf = gp.tuplelist([(m, g, k) for m in M for g in G for k in range(len(P[m, g]))]) P_b = {(m, g, k): P[m, g][k][0] for m, g, k in P_conf} P_p = {(m, g, k): P[m, g][k][1] for m, g, k in P_conf} P_l = {(m, g, k): P[m, g][k][2] for m, g, k in P_conf} P_d = {(m, g, k): P[m, g][k][3] for m, g, k in P_conf} # print("P_conf PROFILE CONF:") # print(P_conf) # print("P_b BATCH:") # print(P_b) # print("P_p PARALLEL:") # print(P_p) # print("P_l Expected LATENCY:") # print(P_l) # print("P_d DURATION:") # print(P_d) C = {g: 1.0 for g in G} # print("COST:") # print(C) R_upper = {(m, g, k): R[m] for m, g, k in P_conf} # print("R_upper Input Rate ub:") # print(R_upper) # Constants capacity = 1.0 # Decision Variables model = gp.Model("Resource_Allocation") x = model.addVars(P_conf, vtype=GRB.BINARY, name='X') r = model.addVars(P_conf, vtype=GRB.INTEGER, ub=R_upper, name='R') u = model.addVars(P_conf, vtype=GRB.CONTINUOUS, ub=capacity, name='U') st = model.addVars(M, vtype=GRB.CONTINUOUS, ub=L_SLO, name='ST') l_max = model.addVar(vtype=GRB.CONTINUOUS, ub=L_SLO, name='L_max') model.update() # print("VARIABLE: X") # print(x) # print("VARIABLE: R") # print(r) # print("VARIABLE: U") # print(u) # print("VARIABLE: ST") # print(st) # print("VARIABLE: L_max") # print(l_max) # Objective Function obj = gp.quicksum( C[g] * x[m, g, k] for m, g, k in P_conf) model.setObjective(obj, GRB.MINIMIZE) # Constraints model.addConstrs( (gp.quicksum(x[m, g, k] for k in range(len(P[m, g]))) <= 1 for m in M for g in G), name="Constr1") model.addConstrs( (r[m, g, k] == 0 for m, g, k in P_conf if not x[m, g, k]), name="Constr2") model.addConstrs( (gp.quicksum(x[m, g, k] * r[m, g, k] for g in G for k in range(len(P[m, g])) if x[m, g, k]) == R[m] for m in M), name="Constr3") model.addConstrs( (u[m, g, k] == 0 for m, g, k in P_conf if not x[m, g, k]), name="Constr4") model.addConstrs( (u[m, g, k] == (r[m, g, k]/(P_b[m, g, k] * P_p[m, g, k] / P_d[m, g, k])) for m, g, k in P_conf if x[m, g, k]), name="Constr5") model.addConstrs( (gp.quicksum(u[m, g, k] for m in M for k in range(len(P[m, g]))) <= 1.0 for g in G), name="Constr6") model.addConstrs( (st[m] == 0.0 for m in M_SRC), name="Const7") model.addConstrs( (st[m] >= st[l] + (x[l, g, k] * P_l[l, g, k]) for l, m in DAG for temp, g, k in P_conf if temp == l), name='Constr8') model.addConstrs( (l_max >= st[m] + (x[m, g, k] * P_l[m, g, k]) for m in M_SNK for temp, g, k in P_conf if temp == m), name='Constr9') model.addConstr( (l_max <= L_SLO), name="Const10") model.Params.Threads = 1 # Run Optimization model.optimize() print('Runtime (in ms): ', model.Runtime*1000) model.printAttr('X') model.write('Resource_Allocation.lp')
# x + y + 2 z # subject to # x + 2 y + 3 z <= 4 # x + y >= 1 # x, y, z binary import gurobipy as gp from gurobipy import GRB import numpy as np import scipy.sparse as sp if __name__ == "__main__": try: # Create a new model m = gp.Model("matrix1") # Create variables x = m.addMVar(shape=3, vtype=GRB.BINARY, name="x") # Set objective obj = np.array([1.0, 1.0, 2.0]) m.setObjective(obj @ x, GRB.MAXIMIZE) # Build (sparse) constraint matrix val = np.array([1.0, 2.0, 3.0, -1.0, -1.0]) row = np.array([0, 0, 0, 1, 1]) col = np.array([0, 1, 2, 0, 1]) A = sp.csr_matrix((val, (row, col)), shape=(2, 3))