def cost_state_old(s, state_considered, L, Q, gamma): """ Asscoiate each state and its child transition a cost Assumption: paralleltopes """ if s == s.goal: return 0 model = Model("trajectory of polytopes") p = {} for row in range(s.n): p[row] = model.addVar(lb=-1, ub=1) model.update() GLG = np.dot(state_considered.G.T, np.dot(L, state_considered.G)) theta = state_considered.successor[2] u = state_considered.successor[1] i = state_considered.mode theta_Q_theta = np.dot(theta.T, np.dot(Q, theta)) J = QuadExpr() for row in range(s.n): for k in range(s.n): J.add(p[row] * p[k] * GLG[row, k] + p[row] * p[k] * theta_Q_theta[row, k]) model.setParam('OutputFlag', False) model.setObjective(J) model.optimize() return model.ObjVal + np.asscalar( np.dot(state_considered.x.T, np.dot(L, state_considered.x)) + np.dot(u.T, np.dot(Q, u)) + gamma)
def point_trajectory_given_modes_and_central_traj(x_traj,list_of_cells,goal,eps=0,scale=[]): """ Description: Point Trajectory Optimization with the ordered list of polytopes given This is a convex program as mode sequence is already given list_of_cells: each cell has the following attributes: A,B,c, and polytope(H,h) """ model=Model("Fixed Mode Polytopic Trajectory") T=len(list_of_cells) n,m=list_of_cells[0].B.shape x=model.addVars(range(T+1),range(n),lb=-GRB.INFINITY,ub=GRB.INFINITY,name="x") u=model.addVars(range(T),range(m),lb=-GRB.INFINITY,ub=GRB.INFINITY,name="u") model.update() if len(scale)==0: scale=np.ones(x_traj[0].shape[0]) print "inside function epsilon is",eps for j in range(n): model.addConstr(x[0,j]<=x_traj[0][j]+eps*scale[j]) model.addConstr(x[0,j]>=x_traj[0][j]-eps*scale[j]) for t in range(T): cell=list_of_cells[t] A,B,c,_p=cell.A,cell.B,cell.c,cell.p for j in range(n): expr_x=LinExpr([(A[j,k],x[t,k]) for k in range(n)]) expr_u=LinExpr([(B[j,k],u[t,k]) for k in range(m)]) model.addConstr(x[t+1,j]==expr_x+expr_u+c[j,0]) x_t=np.array([x[t,j] for j in range(n)]).reshape(n,1) u_t=np.array([u[t,j] for j in range(m)]).reshape(m,1) xu=np.vstack((x_t,u_t)) subset_LP(model,xu,np.zeros((n+m,1)),Ball(1),_p) x_T=np.array([x[T,j] for j in range(n)]).reshape(n,1) z=zonotope(x_T,np.zeros((n,1))) subset_generic(model,z,goal) # Cost function J=QuadExpr() for t in range(T): for i in range(n): J.add(x[t,i]*x[t,i]-x[t,i]*x_traj[t][i]) model.setObjective(J) model.write("polytopic_trajectory.lp") model.setParam('TimeLimit', 150) model.optimize() x_num,u_num={},{} for t in range(T+1): x_num[t]=np.array([[x[t,j].X] for j in range(n)]) for t in range(T): u_num[t]=np.array([[u[t,i].X] for i in range(m) ]) return (x_num,u_num)
def calcDieselCost(ini, dieselGeneratorsVars, dieselStatusVars): dieselObjExp = QuadExpr() for index in range(len(ini.timestamps)): dieselObjExp.add( dieselGeneratorsVars[index, 0] * dieselGeneratorsVars[index, 0] * ini.dieselQuadraticCof * ini.dieselFuelPrice * ini.stepsizeHour) dieselObjExp.add(dieselGeneratorsVars[index, 0] * ini.dieselLinearCof * ini.dieselFuelPrice * ini.stepsizeHour) dieselObjExp.add(ini.dieselConstantCof * (1 - dieselStatusVars[index, 0]) * ini.dieselFuelPrice * ini.stepsizeHour) dieselObjExp.add(ini.startUpCost * dieselStatusVars[index, 1] / ini.startUpTimestepNumber) return dieselObjExp
def anchor_point(polytope): """ A point in H,h """ model = Model("Polytope Sampling") n = polytope.H.shape[1] x = np.empty((n, 1), dtype="object") rho = np.empty((polytope.H.shape[0], 1), dtype="object") for row in range(n): x[row, 0] = model.addVar(lb=-GRB.INFINITY, ub=GRB.INFINITY) for row in range(polytope.H.shape[0]): rho[row, 0] = model.addVar(lb=0, ub=GRB.INFINITY) model.update() J = QuadExpr(0) for row in range(polytope.H.shape[0]): a = LinExpr() for column in range(polytope.H.shape[1]): a.add(polytope.H[row, column] * x[column, 0]) model.addConstr(a + rho[row, 0] == polytope.h[row]) J.add(rho[row, 0] * rho[row, 0]) model.setParam('OutputFlag', False) model.setObjective(J) model.optimize() return valuation(x)
class BaseProblem: def __init__(self, index: int, scenario: float, probability: float, cfg: Config): self.cfg = cfg self.probability = probability self.index = index self.scenario = scenario self.objective = QuadExpr() # model.ModelSense is minimization by default self.model = Model(f"base_problem_{self.index}") self.x_1 = self.model.addVar(ub=self.cfg.area, name="x_1") self.x_2 = self.model.addVar(ub=self.cfg.area, name="x_2") self.x_3 = self.model.addVar(ub=self.cfg.area, name="x_3") self.model.addConstr(self.x_1 + self.x_2 + self.x_3 <= self.cfg.area) self.objective.add(self.x_1 * self.cfg.wheat.plant_cost * self.probability) self.objective.add(self.x_2 * self.cfg.corn.plant_cost * self.probability) self.objective.add(self.x_3 * self.cfg.beet.plant_cost * self.probability) self._corn_variables_constraint() self._wheat_variables_constraint() self._beet_variables_constraint() def _wheat_variables_constraint(self): y_11 = self.model.addVar(name=f"y_11_{self.index}") y_12 = self.model.addVar(name=f"y_12_{self.index}") self.objective.add(y_11 * self.cfg.wheat.buy_price * self.probability) self.objective.add(y_12 * -self.cfg.wheat.sell_price * self.probability) self.model.addConstr( self.cfg.wheat.requirement <= self.x_1 * self.cfg.wheat.produce_rate * (1 + self.scenario) + y_11 - y_12, name="wheat_produce_constraint", ) def _corn_variables_constraint(self): y_21 = self.model.addVar(name=f"y_21_{self.index}") y_22 = self.model.addVar(name=f"y_22_{self.index}") self.objective.add(y_21 * self.cfg.corn.buy_price * self.probability) self.objective.add(y_22 * -self.cfg.corn.sell_price * self.probability) self.model.addConstr( self.cfg.corn.requirement <= self.x_2 * self.cfg.corn.produce_rate * (1 + self.scenario) + y_21 - y_22, name="cron_produce_constraint", ) def _beet_variables_constraint(self): y_32 = self.model.addVar( ub=self.cfg.beet.max_demand, name=f"y_32_{self.index}", ) y_33 = self.model.addVar(name=f"y_33_{self.index}") self.objective.add(y_32 * -self.cfg.beet.sell_price_high * self.probability) self.objective.add(y_33 * -self.cfg.beet.sell_price_low * self.probability) self.model.addConstr( self.x_3 * self.cfg.beet.produce_rate * (1 + self.scenario) >= y_32 + y_33, name="beet_produce_constraint", ) def solve( self, _lambda: typing.Tuple[float, float, float], rou: float, x_hat_1: float, x_hat_2: float, x_hat_3: float, ): obj = self.objective.copy(1) obj.add(_lambda[0] * self.x_1) obj.add(_lambda[1] * self.x_2) obj.add(_lambda[2] * self.x_3) obj.add(rou / 2 * (self.x_1 - x_hat_1) * (self.x_1 - x_hat_1)) obj.add(rou / 2 * (self.x_2 - x_hat_2) * (self.x_2 - x_hat_2)) obj.add(rou / 2 * (self.x_3 - x_hat_3) * (self.x_3 - x_hat_3)) self.model.setObjective(obj) self.model.optimize() return ( self.model.objVal, self.x_1.x, self.x_2.x, self.x_3.x, )
def solve_problem(self, xs, mus, c, k): """Optimize via gurobi. Build and solve the constrained optimization problem at the basis of the fuzzy learning procedure using the gurobi API. :param xs: objects in training set. :type xs: iterable :param mus: membership values for the objects in `xs`. :type mus: iterable :param c: constant managing the trade-off in joint radius/error optimization. :type c: float :param k: kernel function to be used. :type k: :class:`mulearn.kernel.Kernel` :raises: ValueError if optimization fails or if gurobi is not installed :returns: list -- optimal values for the independent variables of the problem. """ if not gurobi_ok: raise ValueError('gurobi not available') m = len(xs) with Env(empty=True) as env: env.setParam('OutputFlag', 0) env.start() with Model('mulearn', env=env) as model: model.setParam('OutputFlag', 0) model.setParam('TimeLimit', self.time_limit) for i in range(m): if c < np.inf: model.addVar(name=f'chi_{i}', lb=-c * (1 - mus[i]), ub=c * mus[i], vtype=GRB.CONTINUOUS) else: model.addVar(name=f'chi_{i}', vtype=GRB.CONTINUOUS) model.update() chis = model.getVars() if self.initial_values is not None: for c, i in zip(chis, self.initial_values): c.start = i obj = QuadExpr() for i, j in it.product(range(m), range(m)): obj.add(chis[i] * chis[j], k.compute(xs[i], xs[j])) for i in range(m): obj.add(-1 * chis[i] * k.compute(xs[i], xs[i])) if self.adjustment and self.adjustment != 'auto': for i in range(m): obj.add(self.adjustment * chis[i] * chis[i]) model.setObjective(obj, GRB.MINIMIZE) constEqual = LinExpr() constEqual.add(sum(chis), 1.0) model.addConstr(constEqual, GRB.EQUAL, 1) try: model.optimize() except GurobiError as e: print(e.message) if self.adjustment == 'auto': s = e.message a = float(s[s.find(' of ') + 4:s.find(' would')]) logger.warning('non-diagonal Gram matrix, ' f'retrying with adjustment {a}') for i in range(m): obj.add(a * chis[i] * chis[i]) model.setObjective(obj, GRB.MINIMIZE) model.optimize() else: raise e if model.Status != GRB.OPTIMAL: raise ValueError('optimal solution not found!') return [ch.x for ch in chis]