def chp_unit0(self, unit): self.chpunits.append(unit) unit.isopen = cvx.Bool() unit.mmain = cvx.Variable(self.T) unit.p1 = cvx.Variable(self.T) unit.p2 = cvx.Variable(self.T) unit.p3 = cvx.Variable(self.T) unit.h1 = cvx.Variable(self.T) unit.pschedule = unit.p1 + unit.p2 + unit.p3 unit.hschedule = unit.h1 unit.cost = sum(map(unit.costfun, unit.mmain)) self.TEG += unit.pschedule self.TTG += unit.hschedule self.totalcost += unit.cost self.constraints += [unit.mmain == unit.p1] self.constraints += [unit.p1 == unit.p2] self.constraints += [unit.p2 == unit.p3 / 0.8 + unit.h1 / 4.66] self.constraints += [unit.p3 / 0.8 >= unit.p2 * 0.15] self.constraints += [unit.p1 >= 0] self.constraints += [unit.p2 >= 0] self.constraints += [unit.p3 >= 0] self.constraints += [unit.h1 >= 0] self.constraints += [ unit.pschedule >= unit.pbound[0] * unit.isopen, unit.pschedule <= unit.pbound[1] * unit.isopen ]
def test_CBC(self): A = cvxpy.Bool(1,name='A') B = cvxpy.Variable(1,name='B') constr = [] constr.append(-1 <= B) constr.append(B <= 5) obj = cvxpy.Maximize(A - B) problem = cvxpy.Problem(obj, constr) ret = problem.solve(solver=cvxpy.CBC) self.assertTrue(problem.status in [cvxpy.OPTIMAL, cvxpy.OPTIMAL_INACCURATE])
def evaluate(gt_rels, gt_pms, pred_dsms, seq_len, appx=False, prec_pred_pms=None): # metrics ACC, IHA, CSA, NE, NA, PA, NDCG, KT = 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0 rows, cols, n, samples = seq_len, seq_len, pow(seq_len, 2), gt_pms.shape[0] if prec_pred_pms is None: pred_pms = np.zeros(pred_dsms.shape, np.int) else: pred_pms = prec_pred_pms # Find the closest permutation matrix from the predicted var = cvx.Bool(n) par = cvx.Parameter(n) Rnorm = np.fromfunction(lambda i, j: j//cols == i, (rows, n), dtype=int).astype(np.float) Cnorm = np.hstack([np.identity(cols) for c in range(cols)]).astype(np.float) A = np.vstack((Rnorm, Cnorm)) prob = cvx.Problem(cvx.Minimize(cvx.norm(var - par)), [A * var == 1]) appx_count = 1 if prec_pred_pms is None: for idx, dsm in enumerate(pred_dsms): if appx: if appx_count % 100 == 0: print("{} samples has benn approximated".format(appx_count)) appx_count += 1 try: par.value = dsm prob.solve() dsm = np.array(var.value, dtype=np.float).ravel() except: print("Optimization failed with dsm={}".format(dsm)) pred_pms[idx] = (dsm.reshape(rows, cols).argmax(axis=1)[:, None] == np.arange(seq_len)).flatten().astype(int) if len(np.unique(pred_pms[idx].reshape(rows, cols).argmax(axis=0))) < seq_len or len(np.unique(pred_pms[idx].reshape(rows, cols).argmax(axis=1))) < seq_len: NA += 1.0 # compute non-accpeted matrix NA = NA/samples # Compute Normalization error NE = np.mean(np.linalg.norm(1 - np.dot(pred_dsms, A.T), ord=1, axis=1)/A.shape[0]) # Averaged Cossine Similarity dots = inner1d(gt_pms, pred_dsms) norms = np.multiply(np.linalg.norm(gt_pms, ord=2, axis=1), np.linalg.norm(pred_dsms, ord=2, axis=1)) CSA = np.mean(np.divide(dots, norms)) # Permutation prediction evaluation ACC, IHA = perm_eval(gt_pms, pred_pms, seq_len) # Ranking Evaluation PA, NDCG, KT = rank_eval(gt_rels, gt_pms, pred_pms) return ACC, IHA, CSA, NE, NA, PA, NDCG, KT
def pc_unit(self, unit): self.pcunits.append(unit) unit.isopen = cvx.Bool() unit.mmain = cvx.Variable(self.T) unit.pschedule = cvx.Variable(self.T) unit.cost = sum(map(unit.costfun, unit.mmain)) self.TEG += unit.pschedule self.totalcost += unit.cost self.constraints += [unit.mmain == unit.pschedule / 2.8] self.constraints += [ unit.pschedule >= unit.pbound[0] * unit.isopen, unit.pschedule <= unit.pbound[1] * unit.isopen ]
def __init__(self, perm_len): # define opt problem for inference self._rows, self._cols, self._n, = perm_len, perm_len, pow(perm_len, 2) self._var = cvx.Bool(self._n) self._par = cvx.Parameter(self._n) Rnorm = np.fromfunction(lambda i, j: j // self._cols == i, (self._rows, self._n), dtype=int).astype(np.float) Cnorm = np.hstack([np.identity(self._cols) for c in range(self._cols)]).astype(np.float) self._A = np.vstack((Rnorm, Cnorm)) self._prob = cvx.Problem(cvx.Minimize(cvx.norm(self._var - self._par)), [self._A * self._var == 1])
def buildProblem(N, MLigne, MDiag): #Cost of problem ML = cvxpy.Bool(N, N) MD = cvxpy.Bool(N, N) cost = cvxpy.sum_entries(ML) + cvxpy.sum_entries(MD) costObject = cvxpy.Maximize(cost) constraints = [] constraints.append(ML >= MLigne) constraints.append(MD >= MDiag) inveye = np.fliplr(np.eye(N, N)) for i in range(N): inveye2 = np.fliplr(np.eye(i + 1, i + 1)) constraints.append(cvxpy.sum_entries(ML[i, :]) <= 1) constraints.append(cvxpy.sum_entries(ML[:, i]) <= 1) if i >= 1: #constraints.append(cvxpy.trace(MD[:i+1, :i+1]) <= 1) constraints.append(cvxpy.trace(MD[:i + 1, :i + 1] * inveye2) <= 1) #constraints.append(cvxpy.trace(inveye * MD[:i+1, :i+1] * inveye) <= 1) constraints.append( cvxpy.trace((inveye * MD)[:i + 1, :i + 1] * inveye2) <= 1) constraints.append( cvxpy.trace((MD * inveye)[:i + 1, :i + 1] * inveye2) <= 1) constraints.append( cvxpy.trace((inveye * MD * inveye)[:i + 1, :i + 1] * inveye2) <= 1) problem = cvxpy.Problem(costObject, constraints) val = problem.solve(solver=cvxpy.GLPK_MI) return int(np.round(val)), np.round(ML.value), np.round(MD.value)
def test_CBC_packaging_simple(self): num_states = 5 A = cvxpy.Bool(num_states,name='A') B = cvxpy.Variable(num_states,name='B') constr = [] for i in range(1,num_states): constr.append(1.0*A[i-1] + 1.0*A[i] <= 1.0) for i in range(num_states): constr.append(B[i] <= i) objs = [] for i in range(num_states): objs.append(cvxpy.Maximize(A[i] - B[i])) problem = cvxpy.Problem(sum(objs), constr) ret = problem.solve(solver=cvxpy.CBC) self.assertTrue(problem.status in [cvxpy.OPTIMAL, cvxpy.OPTIMAL_INACCURATE])
def control(s1, gs, ob): w = cvxpy.Variable(2, T) v = cvxpy.Variable(2, T) s = cvxpy.Variable(2, T) u = cvxpy.Variable(2, T) nob = len(ob) o = cvxpy.Bool(4 * nob, T) constraints = [cvxpy.abs(u) <= u_max] constraints.append(s[:, 0] == s1) obj = [] for t in range(T): constraints.append(s[:, t] - gs <= w[:, t]) constraints.append(-s[:, t] + gs <= w[:, t]) constraints.append(u[:, t] <= v[:, t]) constraints.append(-u[:, t] <= v[:, t]) obj.append(t * q.T * w[:, t] + r.T * v[:, t]) # obstable avoidanse for io in range(nob): ind = io * 4 constraints.append(sum(o[ind:ind + 4, t]) <= 3) constraints.append(s[0, t] <= ob[io, 0] + M * o[ind + 0, t]) constraints.append(-s[0, t] <= -ob[io, 1] + M * o[ind + 1, t]) constraints.append(s[1, t] <= ob[io, 2] + M * o[ind + 2, t]) constraints.append(-s[1, t] <= -ob[io, 3] + M * o[ind + 3, t]) for t in range(T - 1): constraints.append(s[:, t + 1] == A * s[:, t] + B * u[:, t]) objective = cvxpy.Minimize(sum(obj)) prob = cvxpy.Problem(objective, constraints) prob.solve(solver=cvxpy.GUROBI) s_p = s.value u_p = u.value print("status:" + prob.status) return s_p, u_p
def chp_unit4(self, unit): self.chpunits.append(unit) unit.isopen = cvx.Bool() unit.mmain = cvx.Variable(self.T) unit.p1 = cvx.Variable(self.T) unit.p2 = cvx.Variable(self.T) unit.p3 = cvx.Variable(self.T) unit.h1 = cvx.Variable(self.T) unit.hr = cvx.Variable(self.T) unit.hs = cvx.Variable(self.T) unit.H = cvx.Variable(self.T + 1) unit.h0 = unit.hr - unit.hs unit.pschedule = unit.p1 + unit.p2 + unit.p3 unit.hschedule = unit.h1 + unit.hr unit.cost = sum(map(unit.costfun, unit.mmain)) self.TEG += unit.pschedule self.TTG += unit.hschedule self.totalcost += unit.cost self.constraints += [unit.mmain == unit.p1] self.constraints += [unit.p1 == unit.p2] self.constraints += [ unit.p2 == unit.p3 / 0.8 + (unit.h1 + unit.hs) / 4.66 ] self.constraints += [unit.p3 / 0.8 >= unit.p2 * 0.15] self.constraints += [unit.p1 >= 0] self.constraints += [unit.p2 >= 0] self.constraints += [unit.p3 >= 0] self.constraints += [unit.h1 >= 0] self.constraints += [unit.hr >= 0, unit.hr <= unit.hrmax] self.constraints += [unit.hs >= 0, unit.hs <= unit.hsmax] self.constraints += [ unit.H[0] == unit.Hmax / 2, unit.H >= 0, unit.H <= unit.Hmax ] for i in range(self.T): self.constraints += [ unit.H[i + 1] == unit.H[i] * (1 - unit.Hloss) + (unit.hs[i] - unit.hr[i]) ] self.constraints += [ unit.pschedule >= unit.pbound[0] * unit.isopen, unit.pschedule <= unit.pbound[1] * unit.isopen ]
'C:/Users/J/Desktop/Businesses/Meal_Maker/Scraped_Data/combined_nutrition_small/nutrition_sm_processed_ss.csv', encoding='ISO-8859-1') num_reqs_df = pd.read_csv("../desktop-meal-maker/num_reqs_df.csv") df['p_accept'] = .5 + np.random.rand(len(df), 1) * .01 #meals_df=df[df.food_type_grp=='grocery'] meals_df = df[df.food_type_grp == 'grocery'] del df reqs_df = num_reqs_df oth_relax = .01 P = 10 mac_relax = 0.03 x = cvxpy.Bool(len(meals_df)) m = meals_df['p_accept'].as_matrix().astype(float) # p(acceptance) # Setting constraint variables c = meals_df['carb_g'].as_matrix().astype(float) # carbs f = meals_df['fat_g'].as_matrix().astype(float) # fat p = meals_df['protein_g'].as_matrix().astype(float) # protein ''' ca = meals_df['calcium_mg'].as_matrix() # calcium i = meals_df['iron_mg'].as_matrix() # iron s = meals_df['sodium_mg'].as_matrix() # sodium v_a = meals_df['vit_a_mcg'].as_matrix() # vitamin A v_c = meals_df['vit_c_mg'].as_matrix() # vitamin C ch = meals_df['cholesterol_mg'].as_matrix() # cholesterol f = meals_df['fiber_g'].as_matrix() # fiber sa = meals_df['saturated_fat_g'].as_matrix() # saturated fat
def __init__(self, agl, mintime, N, micp=False): """ Parameters ---------- agl : float Initial altitude above ground level (AGL). mintime : bool If True, use a minimum time cost, otherwise minimum fuel. N : int, optional Number of time nodes for discretization. micp : bool, optional Set to ``True`` to solve the problem via mixed-integer programming. """ super(Lander, self).__init__() if micp: cvx_opts = dict(solver=cvx.GUROBI, verbose=False, LogFile='') else: cvx_opts = dict(solver=cvx.ECOS, verbose=False) # Physical parameters self.omega = 2 * np.pi / (24 * 3600 + 39 * 60 + 35 ) # [rad/s] Mars spin self.mass = 1700. # [kg] Lander mass self.g = 3.71 # [m/s^2] Mars surface gravity self.R = 3396.2e3 # [m] Mars radius #Tmax = 21500. # [N] Maximum thrust #amax = Tmax/self.mass; # [m/s^2] Maximum acceleration self.rho1 = [ 4, 8 ] #[s_*amax for s_ in [0.2,0.6]] # [m/s^2] Smallest acceleration self.rho2 = [ 8, 12 ] #[s_*amax for s_ in [0.6,0.9]] # [m/s^2] Largest control acceleration self.gs = np.deg2rad(10) # [rad] Smallest glideslope angle # Boundary conditions r0 = np.array([1500., agl]) v0 = np.array([50., -70.]) rf = np.array([0., 0.]) vf = np.array([0., 0.]) # Thruster layout self.theta = [120., 10.] # [rad] Gimbal angles of [low,high] thrust modes cone_parameters = [ dict(alpha=theta, roll=0, twod=True) for theta in self.theta ] self.C = [tools.make_cone(**param) for param in cone_parameters] eps = np.sqrt(np.finfo(np.float64).eps) # Machine epsilon for i in range(len(self.C)): # Clean up small coefficients self.C[i][np.abs(self.C[i]) < eps] = 0 self.M = len(self.C) # Number of thrusters self.K = 1 # How many thrusters can be simultaneously active # Setup dynamical system S = np.array([[0, 1], [-1, 0]]) Ac = np.block([[np.zeros((2, 2)), np.eye(2)], [self.omega**2 * np.eye(2), 2 * self.omega * S]]) Bc = np.row_stack([np.zeros((2, 2)), np.eye(2)]) wc = np.row_stack([np.zeros((3, 1)), self.omega**2 * self.R - self.g]) self.A, self.B, self.w = Ac, Bc, wc nx, nu = Ac.shape[1], Bc.shape[1] A = cvx.Parameter(nx, nx) B = cvx.Parameter(nx, nu) w = cvx.Parameter(nx, 1) # Scaling Dx = np.concatenate(np.abs([r0, v0])) Dx[Dx == 0] = 1 Dx[0] = r0[1] * np.tan(np.pi / 2 - self.gs) self.Dx = np.diag(Dx) self.Du = [np.diag([rho2 for _ in range(nu)]) for rho2 in self.rho2] self.tfmax = 100. # Optimization problem common parts self.N = N # Temporal solution x = [cvx.Parameter(nx) ] + [self.Dx * cvx.Variable(nx) for _ in range(1, self.N + 1)] xi = [cvx.Parameter()] + [cvx.Variable() for _ in range(1, self.N + 1)] u = [[self.Du[i] * cvx.Variable(nu) for __ in range(self.N)] for i in range(self.M)] sigma = [cvx.Variable(self.N) for _ in range(self.M)] gamma = [ cvx.Bool(self.N) if micp else cvx.Variable(self.N) for _ in range(self.M) ] dt = cvx.Parameter() # Cost components ximax = self.tfmax * np.max(self.rho2) Dxi = la.inv(self.Dx) time_penalty = dt * self.N * ximax / self.tfmax input_penalty = xi[-1] wx = 1e-3 * ximax state_penalty = sum([ cvx.abs(dt * Dxi[0, 0] * x[k][0]) + 1e-3 * cvx.abs(dt * Dxi[1, 1] * x[k][1]) for k in range(self.N + 1) ]) if mintime: self.zeta = 0 cost = time_penalty + wx * state_penalty else: self.zeta = 1 cost = input_penalty + wx * state_penalty self.constraints = [] self.dual2idx = dict() def add_constraint(new_constraints, dual): """ Add constraint(s). Parameters ---------- new_constraints : list List of constraints to add. dual : str Dual variable name. """ idx_start = len(self.constraints) self.constraints += new_constraints idx_end = len(self.constraints) if dual not in self.dual2idx: self.dual2idx[dual] = range(idx_start, idx_end) else: self.dual2idx[dual] += range(idx_start, idx_end) add_constraint([ x[k + 1] == A * x[k] + B * sum([u[i][k] for i in range(self.M)]) + w for k in range(self.N) ], 'lambda') add_constraint([ xi[k + 1] == xi[k] + sum([dt * sigma[i][k] for i in range(self.M)]) for k in range(self.N) ], 'eta') x[0].value = np.concatenate([r0, v0]) xi[0].value = 0 add_constraint([x[-1] == np.concatenate([rf, vf])], 'nu_xN') for i in range(self.M): add_constraint( [cvx.norm2(u[i][k]) <= sigma[i][k] for k in range(self.N)], 'lambda_1_%d' % (i + 1)) add_constraint([ gamma[i][k] * self.rho1[i] <= sigma[i][k] for k in range(self.N) ], 'lambda_2_%d' % (i + 1)) add_constraint([ sigma[i][k] <= gamma[i][k] * self.rho2[i] for k in range(self.N) ], 'lambda_3_%d' % (i + 1)) if not micp: add_constraint([gamma[i][k] >= 0 for k in range(self.N)], 'dummy_1_%d' % (i + 1)) add_constraint([gamma[i][k] <= 1 for k in range(self.N)], 'dummy_2_%d' % (i + 1)) add_constraint([self.C[i] * u[i][k] <= 0 for k in range(self.N)], 'lambda_4_%d' % (i + 1)) add_constraint([ sum([gamma[i][k] for i in range(self.M)]) <= self.K for k in range(self.N) ], 'dummy_3_%d' % (i + 1)) self.Ex = np.column_stack([np.eye(2), np.zeros((2, 2))]) gs = np.pi / 2 - self.gs add_constraint([ np.array([0, 1]).dot(self.Ex) * x[k] >= cvx.norm2(self.Ex * x[k]) * np.cos(gs) for k in range(self.N) ], 'dummy_4') # Problem oracle problem = cvx.Problem(cvx.Minimize(cost), self.constraints) def extract_variables(): primal = dict() dual = dict() misc = dict() # Primal variables primal['x'] = np.column_stack( [tools.cvx2arr(x[k]) for k in range(self.N + 1)]) primal['u'] = [ np.column_stack( [tools.cvx2arr(u[i][k]) for k in range(self.N)]) for i in range(self.M) ] primal['sigma'] = [ np.array([sigma[i][k].value for k in range(self.N)]) for i in range(self.M) ] primal['gamma'] = [ np.array([gamma[i][k].value for k in range(self.N)]) for i in range(self.M) ] # Dual variables if not micp: for name in self.dual2idx.keys(): dual[name] = np.column_stack([ tools.cvx2arr(self.constraints[k], dual=True) for k in self.dual2idx[name] ]) # Other (derived) variables misc['y'] = np.row_stack([ self.Bd.T.dot(dual['lambda'][:, k]) for k in range(self.N) ]) return primal, dual, misc def solve(tf): dt.value = tf / float(self.N) A.value, B.value = tools.discretize(Ac, Bc, dt.value) ___, w.value = tools.discretize(Ac, wc, dt.value) self.Ad = np.array(A.value) self.Bd = np.array(B.value) self.wd = np.array(w.value) t = np.array([k * dt.value for k in range(self.N + 1)]) try: J = problem.solve(**cvx_opts) solver_time = problem.solver_stats.solve_time if problem.status == 'infeasible': return problem.status, np.inf, t, None, None, None, solver_time else: # All good, return solution primal, dual, misc = extract_variables() return problem.status, J, t, primal, dual, misc, solver_time except cvx.SolverError: return 'error', np.inf, t, None, None, None, 0. self.solve = lambda tf: solve(tf)
w_data = [] # Trend t_data = [] for rider in riders: v_data.append(float(rider['value'])) w_data.append(0.01 * float(rider['popularity'])) t_data.append(float(rider['growth_tot'])) v = np.array(v_data) w = np.array(w_data) t = np.array(t_data) print t x = cvx.Bool(len(riders)) popularity = cvx.Variable() cost = cvx.Variable() growth = cvx.Variable() objective = cvx.Maximize(popularity) constraints = [] constraints.append(popularity == w * x) constraints.append(growth == t * x) constraints.append(cost == v * x) constraints.append(cost <= 62100000) constraints.append(sum(x) == 9)
used = set(x for l in lineups_unique for x in l) for id in used: n = sum(list(l).count(id) for l in lineups_unique) id_count[id] = n id_prop[id] = float(n) / float(len(lineups_unique)) print 'setting exposure limits' for k in id_prop.keys(): pos = pos_dict[k]['pos'] if id_prop[k] > MAX_EXPOSURE[pos]: player_pool = player_pool.loc[player_pool['pool_id'] != k] costs = np.array(player_pool.loc[:, 'cst_fd']).astype(int) selection = cvxpy.Bool(len(costs)) new_lineup = False while new_lineup == False: # get indices of players to select constraints = get_constraints(n_start, roster_todraft, player_pool, budget, selection, costs, team_limit=False) sel_index = get_selection_indices(player_pool, selection, constraints, n_start)
Created on Mon Aug 13 10:59:26 2018 @author: "Anirban Das" """ import cvxpy import numpy as np # The data for the Knapsack problem # P is total weight capacity of sack # weights and utilities are also specified P = 165 weights = np.array([23, 31, 29, 44, 53, 38, 63, 85, 89, 82]) utilities = np.array([92, 57, 49, 68, 60, 43, 67, 84, 87, 72]) # The variable we are solving for selection = cvxpy.Bool(len(weights)) # The sum of the weights should be less than or equal to P weight_constraint = weights * selection <= P # Our total utility is the sum of the item utilities total_utility = utilities * selection # We tell cvxpy that we want to maximize total utility # subject to weight_constraint. All constraints in # cvxpy must be passed as a list knapsack_problem = cvxpy.Problem(cvxpy.Maximize(total_utility), [weight_constraint]) # Solving the problem knapsack_problem.solve(solver=cvxpy.GLPK_MI)
def __init__(self): # Data # ---- # Definition of the STN (order in the list matters!) self.units = ['Heater', 'Reactor 1', 'Reactor 2', 'Column'] self.tasks = ['Heat', 'Rea. 1', 'Rea. 2', 'Rea. 3', 'Sep.'] self.states = ['Feed A', 'Feed B', 'Feed C', 'Hot A', 'Intermediate AB', 'Intermediate BC', 'Impure E', 'Product 1', 'Product 2'] self.input_states = [0, 1, 2] # indices of the input states self.horizon = 11 # horizon in number of of steps # Aliases self.I = self.units.__len__() self.J = self.tasks.__len__() self.S = self.states.__len__() self.T = self.horizon # Units capability (what tasks can be processed on which unit) # row = unit, column = task self.J_i = np.array([[1, 0, 0, 0, 0], [0, 1, 1, 1, 0], [0, 1, 1, 1, 0], [0, 0, 0, 0, 1]]) # Recipes and timing # fractions of input state s (column) required to execute task j (row) self.rho_in = np.array([[1, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0.5, 0.5, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0.4, 0, 0.6, 0, 0, 0], [0, 0, 0.2, 0, 0.8, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 1, 0, 0]]) # fractions of output state s (column) produced by task j (row) self.rho_out = np.array([[0, 0, 0, 1, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 1, 0, 0, 0], [0, 0, 0, 0, 0.6, 0, 0, 0.4, 0], [0, 0, 0, 0, 0, 0, 1, 0, 0], [0, 0, 0, 0, 0.1, 0, 0, 0, 0.9]]) # time (in # of steps) required to produce output state s (column) from task j (row) self.P = np.array([[0, 0, 0, 1, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 2, 0, 0, 0], [0, 0, 0, 0, 2, 0, 0, 2, 0], [0, 0, 0, 0, 0, 0, 1, 0, 0], [0, 0, 0, 0, 2, 0, 0, 0, 1]]) # total execution time of task j (row-wise max of P) self.P_j = np.amax(self.P, axis=1) # Capacities # max capacity of unit i (row) to process task j (column), in e.g. kg self.V_max = np.array([[100, 100, 100, 100, 100], [80, 80, 80, 80, 80], [50, 50, 50, 50, 50], [200, 200, 200, 200, 200]]) self.V_min = np.array([[0, 0, 0, 0, 0], [0, 0, 0, 0, 0], [0, 0, 0, 0, 0], [0, 0, 0, 0, 0]]) # storage capacity for state s self.C_max = np.array([np.infty, np.infty, np.infty, 100, 200, 150, 100, np.infty, np.infty]) self.C_min = np.array([0, 0, 0, 0, 0, 0, 0, 0, 0]) # objective to maximize (revenue from the states) self.c = np.array([0, 0, 0, -1, -1, -1, -1, 10, 10]) # Optimization problem structure (cvx.Problem type) self.model = 0 # Optimization Variables # ---------------------- self.x_ijt = {} # allocation variable (bool) self.y_ijt = {} # batch size [kg] self.y_s = {} # state quantity [kg] for i in range(self.I): for j in range(self.J): for t in range(self.T): self.x_ijt[i,j,t] = cvx.Bool() # we separate creation of x_ijt and y_ijt in two loops, so that the optimization variables # in the standard model do not get mixed up for i in range(self.I): for j in range(self.J): for t in range(self.T): self.y_ijt[i,j,t] = cvx.Variable() # state equations are eliminated to allow for the robust counterpart. We only store # the initial state y_s(t=0), which we name y_s for s in range(self.S): self.y_s[s] = cvx.Variable() # auxiliary expressions used in the state equations self.y_st_inflow = {} self.y_st_outflow = {} # Attributes # ---------- # to store results self.X_ijt = np.zeros((self.I,self.J,self.T)) self.Y_ijt = np.zeros((self.I,self.J,self.T)) self.Y_st = np.zeros((self.S,self.T)) self.Y_st_inflow = np.zeros((self.S,self.T)) self.Y_st_outflow = np.zeros((self.S,self.T)) # to store the standard model # min c_x'*x + c_y'*y # s.t. A_eq*x + B_eq*y = b_eq # A_ineq*x + B_ineq*y <= b_ineq # x \in {0,1} self.c_x = 0 self.c_y = 0 self.A_eq = 0 self.A_ineq = 0 self.B_eq = 0 self.B_ineq = 0 self.b_eq = 0 self.b_ineq = 0 self.bool_ix = 0 self.cont_ix = 0 self.m_eq = 0 self.m_ineq = 0
obsVerts.append(np.asarray([[coord_of_obst_list[i][0], coord_of_obst_list[i][0], coord_of_obst_list[i][2], coord_of_obst_list[i][2], coord_of_obst_list[i][0]], [coord_of_obst_list[i][1], coord_of_obst_list[i][3], coord_of_obst_list[i][3], coord_of_obst_list[i][1], coord_of_obst_list[i][1]]])) # Defining the system matrices A = np.matrix('1,0,1,0;0,1,0,1;0,0,1,0;,0,0,0,1') B = np.matrix('0.5,0;0,0.5;1,0;0,1') #Defining the buffer buffer = np.matrix('1;1;1;1') buffer = buffer/(precision*2*np.sqrt(2)) # Defining the decision variables X = cvx.Variable(4,N+1) U = cvx.Variable(2,N) #Defining the Boolean slack variables b_p = cvx.Bool(4*num_obst,(precision-1)*(N)) b_p1 = cvx.Bool(4*num_obst,N) b_p2 = cvx.Bool(4*num_obst,N) b_qq = cvx.Bool(3) # Big-M M = 2000 # Define dynamic constraints ## Initial condition con = [X[:,0] == np.matrix('0;0;0;0')] ## Dynamics con.extend([X[:,i+1] == A*X[:,i] + B*U[:,i] for i in range(N)]) ## Input constraints con.extend([cvx.norm(U[:,i],np.inf) <= max_inp for i in range(N)])
def optimize(n_cluster, error_cons, pred_file, label_file, solution_file, ifInt=0, obj='balance', singleCluster=False): # Problem data. n_class = 1000 #mapping = np.genfromtxt('9cluster.csv',delimiter=',') #ori_label = np.genfromtxt('label_squeezenet_9cluster.csv', delimiter=',') ori_pred = np.genfromtxt(pred_file, delimiter=',') ori_top1_pred = ori_pred.argmax(1) class_label = np.genfromtxt(label_file, delimiter=',') ori_top1_pred, class_label = map_to_cluster(ori_top1_pred, class_label) # Construct the problem. if ifInt: P = cvx.Bool(n_cluster, n_class) constraints = [] use_solver = cvx.GUROBI else: P = cvx.Variable(n_cluster, n_class) constraints = [0 <= P, P <= 1] use_solver = cvx.ECOS if singleCluster: constraints.append(cvx.sum_entries(P, axis=0) <= 1) # Objective function if obj == 'sum': obj_func = cvx.sum_entries(P) elif obj == 'sum_sq': obj_func = cvx.sum_squares(cvx.sum_entries(P, axis=1)) elif obj == 'max': obj_func = cvx.max_entries(cvx.sum_entries(P, axis=1)) elif obj == 'max_sq': obj_func = cvx.max_entries(cvx.power(cvx.sum_entries(P, axis=1), 2)) else: obj_func = cvx.sum_squares( cvx.sum_entries(P, axis=1) - n_class / float(n_cluster)) objective = cvx.Minimize(obj_func) # Error rate constraint error_constraint = 0 for cluster, label in zip(ori_top1_pred, class_label): error_constraint += P[cluster, label] error_constraint = 1.0 - 1.0 / len(class_label) * error_constraint constraints.append(error_constraint <= error_cons) # The optimal objective is returned by prob.solve(). prob = cvx.Problem(objective, constraints) result = prob.solve(solver=use_solver) save_mat(solution_file, P.value) print 'status:', prob.status print 'optimal value: ', prob.value print 'Optimal P matrix:', P.value print 'Error rate constraint dual value: ', constraints[-1].dual_value print 'Error rate constraint {0}:{1} <= {2}'.format( constraints[-1].value, error_constraint.value, error_cons)
gt_rels = result_dict.get("gt_rels", None) gt_pms = result_dict.get("gt_pms", None) pred_dsms = result_dict.get("pred_dsms", None) diffs = result_dict.get("sal_map", None) seq_len = np.sqrt(gt_pms.shape[1]) assert round(seq_len) == seq_len seq_len = int(seq_len) print("\n>>> Evaluating file {} whose sequence lenght is {} <<<".format(result_file, seq_len)) print("GT relevance shape: {}".format(gt_rels.shape)) print("GT PMs Mtrices: {}".format(gt_pms.shape)) print("Pred DSMs Mtrices: {}".format(pred_dsms.shape)) # Create the permutation matrix approximation problem rows, cols, n, samples = seq_len, seq_len, pow(seq_len, 2), gt_pms.shape[0] pred_pms = np.zeros(pred_dsms.shape, np.int) var = cvx.Bool(n) par = cvx.Parameter(n) Rnorm = np.fromfunction(lambda i, j: j//cols == i, (rows, n), dtype=int).astype(np.float) Cnorm = np.hstack([np.identity(cols) for c in range(cols)]).astype(np.float) A = np.vstack((Rnorm, Cnorm)) prob = cvx.Problem(cvx.Minimize(cvx.norm(var - par)), [A * var == 1]) # solve for idx, dsm in enumerate(pred_dsms): if idx % 100 == 0: print(os.getpid()) print("{} samples processed".format(idx)) try: par.value = dsm prob.solve()
def __init__(self, micp=False): """ Parameters ---------- micp : bool, optional Set to ``True`` to solve the problem via mixed-integer programming. """ super(Docker, self).__init__() if micp: cvx_opts = dict(solver=cvx.GUROBI, verbose=False, LogFile='') else: cvx_opts = dict(solver=cvx.ECOS, verbose=False) # cvx_opts = dict(solver=cvx.GUROBI,verbose=False,Presolve=1,LogFile='',threads=1) # Physical parameters self.omega = np.array( [0. * 2 * np.pi / 60., 0. * 2 * np.pi / 60., 1. * 2 * np.pi / 60.]) # [rad/s] Space station spin self.rho1 = 1e-3 # [m/s^2] Smallest control acceleration self.rho2 = 1e-2 # [m/s^2] Largest control acceleration # Boundary conditions r0 = np.array([5., 5., 1e2]) v0 = np.array([0., 0., 0.]) #-np.cross(self.omega,r0) rf = np.array([0., 0., 0.]) vf = np.array([0., 0., -1e-2]) # RCS layout cone_angle = 0. # [deg] Thruster cone angle theta = phi = 30 # [deg] Basic pitch, roll for lower thrusters theta_up = phi_up = 40 # [deg] Basic pitch, roll for upper thrusters cone_parameters = [ dict(alpha=cone_angle, roll=phi_up, pitch=theta_up, yaw=0), dict(alpha=cone_angle, roll=-phi_up, pitch=theta_up, yaw=0), dict(alpha=cone_angle, roll=-phi_up, pitch=-theta_up, yaw=0), dict(alpha=cone_angle, roll=phi_up, pitch=-theta_up, yaw=0), dict(alpha=cone_angle, roll=phi + (180 - 2 * phi), pitch=-theta, yaw=0), dict(alpha=cone_angle, roll=-phi - (180 - 2 * phi), pitch=-theta, yaw=0), dict(alpha=cone_angle, roll=-phi - (180 - 2 * phi), pitch=theta, yaw=0), dict(alpha=cone_angle, roll=phi + (180 - 2 * phi), pitch=theta, yaw=0), dict(alpha=cone_angle, roll=90, pitch=0, yaw=0), dict(alpha=cone_angle, roll=-90, pitch=0, yaw=0), dict(alpha=cone_angle, roll=0, pitch=90, yaw=0), dict(alpha=cone_angle, roll=0, pitch=-90, yaw=0) ] self.C = [tools.make_cone(**param) for param in cone_parameters] eps = np.sqrt(np.finfo(np.float64).eps) # Machine epsilon for i in range(len(self.C)): # Clean up small coefficients self.C[i][np.abs(self.C[i]) < eps] = 0 self.M = len(self.C) # Number of thrusters self.K = 4 # How many thrusters can be simultaneously active # Setup dynamical system S = lambda w: np.array([[0, -w[2], w[1]], [w[2], 0, -w[0]], [-w[1], w[0], 0]]) Ac = np.block([[np.zeros((3, 3)), np.eye(3)], [-mpow(S(self.omega), 2), -2 * S(self.omega)]]) Bc = np.row_stack([np.zeros((3, 3)), np.eye(3)]) self.A, self.B = Ac, Bc nx, nu = Ac.shape[1], Bc.shape[1] A = cvx.Parameter(nx, nx) B = cvx.Parameter(nx, nu) # Scaling Dx = np.concatenate(np.abs([r0, v0])) Dx[Dx == 0] = 1 self.Dx = np.diag(Dx) self.Du = np.diag([self.rho2 for _ in range(nu)]) # Optimization problem common parts self.N = 300 # Temporal solution x = [cvx.Parameter(nx) ] + [self.Dx * cvx.Variable(nx) for _ in range(1, self.N + 1)] xi = [cvx.Parameter()] + [cvx.Variable() for _ in range(1, self.N + 1)] u = [[self.Du * cvx.Variable(nu) for __ in range(self.N)] for _ in range(self.M)] unorm = [cvx.Variable(self.N) for _ in range(self.M)] sigma = [cvx.Variable(self.N) for _ in range(self.M)] gamma = [ cvx.Bool(self.N) if micp else cvx.Variable(self.N) for _ in range(self.M) ] dt = cvx.Parameter() cost = dt * self.N # minimum time: dt self.constraints = [] self.dual2idx = dict() def add_constraint(new_constraints, dual): """ Add constraint(s). Parameters ---------- new_constraints : list List of constraints to add. dual : str Dual variable name. """ idx_start = len(self.constraints) self.constraints += new_constraints idx_end = len(self.constraints) if dual not in self.dual2idx: self.dual2idx[dual] = range(idx_start, idx_end) else: self.dual2idx[dual] += range(idx_start, idx_end) add_constraint([ x[k + 1] == A * x[k] + B * sum([u[i][k] for i in range(self.M)]) for k in range(self.N) ], 'nu_x') add_constraint([ xi[k + 1] == xi[k] + dt * sum([sigma[i][k] for i in range(self.M)]) for k in range(self.N) ], 'nu_xi') x[0].value = np.concatenate([r0, v0]) xi[0].value = 0 add_constraint([x[-1] == np.concatenate([rf, vf])], 'nu_xN') for i in range(self.M): add_constraint([unorm[i][k] <= sigma[i][k] for k in range(self.N)], 'lambda_sigma') add_constraint([ u[i][k] == -unorm[i][k] * self.C[i][-1] for k in range(self.N) ], 'lambda_unorm') add_constraint([ gamma[i][k] * self.rho1 <= sigma[i][k] for k in range(self.N) ], 'lambda_rho1') add_constraint([ sigma[i][k] <= gamma[i][k] * self.rho2 for k in range(self.N) ], 'lambda_rho2') if not micp: add_constraint([gamma[i][k] >= 0 for k in range(self.N)], 'lambda_gamma_low') add_constraint([gamma[i][k] <= 1 for k in range(self.N)], 'lambda_gamma_high') add_constraint([self.C[i] * u[i][k] <= 0 for k in range(self.N)], 'lambda_u') add_constraint([ sum([gamma[i][k] for i in range(self.M)]) <= self.K for k in range(self.N) ], 'lambda_sum_gamma') # Problem 2 oracle problem = cvx.Problem(cvx.Minimize(cost), self.constraints) def extract_variables(): primal = dict() dual = dict() misc = dict() # Primal variables primal['x'] = np.column_stack( [tools.cvx2arr(x[k]) for k in range(self.N + 1)]) primal['u'] = [ np.column_stack( [tools.cvx2arr(u[i][k]) for k in range(self.N)]) for i in range(self.M) ] primal['sigma'] = [ np.array([sigma[i][k].value for k in range(self.N)]) for i in range(self.M) ] primal['gamma'] = [ np.array([gamma[i][k].value for k in range(self.N)]) for i in range(self.M) ] # Dual variables if not micp: for name in self.dual2idx.keys(): dual[name] = np.column_stack([ tools.cvx2arr(self.constraints[k], dual=True) for k in self.dual2idx[name] ]) # Other (derived) variables misc['y'] = np.row_stack( [self.Bd.T.dot(dual['nu_x'][:, k]) for k in range(self.N)]) return primal, dual, misc def solve(tf): dt.value = tf / float(self.N) A.value, B.value = tools.discretize(Ac, Bc, dt.value) self.Ad = np.array(A.value) self.Bd = np.array(B.value) t = np.array([k * dt.value for k in range(self.N + 1)]) try: J = problem.solve(**cvx_opts) solver_time = problem.solver_stats.solve_time if problem.status == 'infeasible': return problem.status, np.inf, t, None, None, None, solver_time else: # All good, return solution primal, dual, misc = extract_variables() return problem.status, J, t, primal, dual, misc, solver_time except cvx.SolverError: return 'error', np.inf, t, None, None, None, 0. self.solve = lambda tf: solve(tf)
def test_CBC_hard(self): num_states = 5 x = cvxpy.Bool(num_states,name='x') sw_on = cvxpy.Bool(num_states,name='sw_on') sw_off = cvxpy.Bool(num_states,name='sw_off') sw_stay_on = cvxpy.Bool(num_states,name='sw_stay_on') sw_stay_off = cvxpy.Bool(num_states,name='sw_stay_off') fl = cvxpy.Variable(num_states,name='float') constr = [] # can only be one transition type constr.append(sw_on*1.0 + sw_off*1.0 + sw_stay_on*1.0 + sw_stay_off*1.0 == 1) for i in range(num_states): # if switching on, must be now on constr.append(x[i] >= sw_on[i]) # if switchin on, must have been off previously if i>0: constr.append((1-x[i-1]) >= sw_on[i]) # if switching off, must be now off constr.append((1-x[i]) >= sw_off[i]) # if switchin off, must have been on previously if i>0: constr.append(x[i-1] >= sw_off[i]) # if staying on, must be now on constr.append(x[i] >= sw_stay_on[i]) # if staying on, must have been on previously if i>0: constr.append(x[i-1] >= sw_stay_on[i]) # if staying, must be now off constr.append((1-x[i]) >= sw_stay_off[i]) # if staying off, must have been off previously if i>0: constr.append((1-x[i-1]) >= sw_stay_off[i]) # random stuff constr.append(x[1] == 1) constr.append(x[3] == 0) for i in range(num_states): constr.append(fl[i] <= i*sw_on[i]) constr.append(fl[i] >= -i) obj = cvxpy.Maximize(sum(sw_off) + sum(sw_on)) for i in range(num_states): if i%2 == 0: obj += cvxpy.Maximize(fl[i]) else: obj += cvxpy.Maximize(-1*fl[i]) problem = cvxpy.Problem(obj, constr) ret = problem.solve(solver=cvxpy.CBC) self.assertTrue(problem.status in [cvxpy.OPTIMAL, cvxpy.OPTIMAL_INACCURATE]) print(' | '.join(['i','x','sw_on','sw_off','stay_on','stay_off','float'])) for i in range(num_states): row = ' | '.join([ '%1d' % i, '%1d' % int(round(x[i].value)), '%5d' % int(round(sw_on[i].value)), '%6d' % int(round(sw_off[i].value)), '%7d' % int(round(sw_stay_on[i].value)), '%8d' % int(round(sw_stay_off[i].value)), '%f' % fl[i].value ]) print(row)
def __init__(self, d, dataset_name=None, X=None, use_slab=False, constrain_max_loss=False, use_l2=False, x_pos_tuple=None, x_neg_tuple=None, model_type='svm'): self.use_slab = use_slab self.constrain_max_loss = constrain_max_loss self.use_l2 = use_l2 self.dataset = dataset_name # creating variables with shape of "d" # need to deal with some binary feature attibutes if dataset_name == "adult": # ---- adult ----- # attributes 0-3 are continuous and represent: "age", "capital-gain", "capital-loss", "hours-per-week" # attributes 4-11 are binary representing the work class. # attributes 12-26: education background # attributes 27-32: martial status # attributes 33-46: occupation # attributes 47-51: relationship # 52-56: race # bool_inds = np.array([0]*d) # bool_inds[4:] = bool_inds[4:] + 1 # print("the bolean indices are:",tuple(bool_inds)) # self.cvx_x_pos = cvx.Variable(d, boolean = tuple([bool_inds])) self.cvx_x_pos_real = cvx.Variable(4) self.cvx_x_neg_real = cvx.Variable(4) self.cvx_x_pos_binary = cvx.Bool(d - 4) self.cvx_x_neg_binary = cvx.Bool(d - 4) # used for the binary constraints arr = np.array([0] * (d - 4)) arr[0:8] = 1 self.cvx_work_class = cvx.Parameter(d - 4, value=arr) arr = np.array([0] * (d - 4)) arr[8:23] = 1 self.cvx_education = cvx.Parameter(d - 4, value=arr) arr = np.array([0] * (d - 4)) arr[23:29] = 1 self.cvx_martial = cvx.Parameter(d - 4, value=arr) arr = np.array([0] * (d - 4)) arr[29:43] = 1 self.cvx_occupation = cvx.Parameter(d - 4, value=arr) arr = np.array([0] * (d - 4)) arr[43:48] = 1 self.cvx_relationship = cvx.Parameter(d - 4, value=arr) arr = np.array([0] * (d - 4)) arr[48:53] = 1 self.cvx_race = cvx.Parameter(d - 4, value=arr) else: self.cvx_x_pos = cvx.Variable(d) self.cvx_x_neg = cvx.Variable(d) self.cvx_g = cvx.Parameter(d) self.cvx_theta = cvx.Parameter(d) self.cvx_bias = cvx.Parameter(1) self.cvx_epsilon_pos = cvx.Parameter(1) self.cvx_epsilon_neg = cvx.Parameter(1) self.cvx_centroid_pos = cvx.Parameter(d) self.cvx_centroid_neg = cvx.Parameter(d) if use_l2: self.cvx_sphere_radius_pos = cvx.Parameter(1) self.cvx_sphere_radius_neg = cvx.Parameter(1) if use_slab: self.cvx_centroid_vec = cvx.Parameter(d) self.cvx_slab_radius_pos = cvx.Parameter(1) self.cvx_slab_radius_neg = cvx.Parameter(1) if constrain_max_loss: self.cvx_max_loss_pos = cvx.Parameter(1) self.cvx_max_loss_neg = cvx.Parameter(1) self.cvx_err = cvx.Variable(d) self.objective = cvx.Minimize(cvx.pnorm(self.cvx_err, 2)) # version 0.4 is below if dataset_name == 'adult': self.constraints = [ self.cvx_g - self.cvx_epsilon_pos * cvx.vstack(self.cvx_x_pos_real,self.cvx_x_pos_binary) +\ self.cvx_epsilon_neg * cvx.vstack(self.cvx_x_neg_real,self.cvx_x_neg_binary) == self.cvx_err, cvx_dot(self.cvx_theta, cvx.vstack(self.cvx_x_pos_real,self.cvx_x_pos_binary)) + self.cvx_bias < 1, # margin constraint, ideally should be 1 -(cvx_dot(self.cvx_theta, cvx.vstack(self.cvx_x_neg_real,self.cvx_x_neg_binary)) + self.cvx_bias) < 1 , # ideally should be 1 ] else: if model_type == 'svm': self.constraints = [ self.cvx_g - self.cvx_epsilon_pos * self.cvx_x_pos + self.cvx_epsilon_neg * self.cvx_x_neg == self.cvx_err, cvx_dot(self.cvx_theta, self.cvx_x_pos) + self.cvx_bias < 1, # margin constraint, ideally should be 1 -(cvx_dot(self.cvx_theta, self.cvx_x_neg) + self.cvx_bias) < 1, # ideally should be 1 ] # cvx 1.0 version # if model_type == 'svm': # self.constraints = [ # self.cvx_g - self.cvx_epsilon_pos * self.cvx_x_pos + self.cvx_epsilon_neg * self.cvx_x_neg == self.cvx_err, # cvx_dot(self.cvx_theta, self.cvx_x_pos) + self.cvx_bias <= 1, # margin constraint, ideally should be 1 # -(cvx_dot(self.cvx_theta, self.cvx_x_neg) + self.cvx_bias) <= 1 , # ideally should be 1 # ] elif model_type == 'lr': # lr is not convex, cannot support it now pos_margin = cvx_dot(self.cvx_x_pos, self.cvx_theta) + self.cvx_bias neg_margin = -cvx_dot(self.cvx_x_neg, self.cvx_theta) + self.cvx_bias pos_grad = -sigmoid(-pos_margin) * self.cvx_x_pos neg_grad = sigmoid(-neg_margin) * self.cvx_x_neg self.constraints = [ self.cvx_g - self.cvx_epsilon_pos * pos_grad + self.cvx_epsilon_neg * neg_grad == self.cvx_err ] else: print("Please use common linear classifier!") raise NotImplementedError if use_slab: self.constraints.append( cvx_dot(self.cvx_centroid_vec, self.cvx_x_pos - self.cvx_centroid_pos) < self.cvx_slab_radius_pos) self.constraints.append( -cvx_dot(self.cvx_centroid_vec, self.cvx_x_pos - self.cvx_centroid_pos) < self.cvx_slab_radius_pos) self.constraints.append( cvx_dot(self.cvx_centroid_vec, self.cvx_x_neg - self.cvx_centroid_neg) < self.cvx_slab_radius_neg) self.constraints.append( -cvx_dot(self.cvx_centroid_vec, self.cvx_x_neg - self.cvx_centroid_neg) < self.cvx_slab_radius_neg) if dataset_name in ['mnist_17', 'enron', 'imdb']: self.constraints.append(self.cvx_x_pos >= 0) self.constraints.append(self.cvx_x_neg >= 0) # additional constraints on synthetic dataset if x_pos_tuple: assert x_neg_tuple != None self.x_pos_min, self.x_pos_max = x_pos_tuple self.x_neg_min, self.x_neg_max = x_neg_tuple if dataset_name == 'adult': self.constraints.append(self.cvx_x_pos_real >= self.x_pos_min) self.constraints.append(self.cvx_x_pos_real <= self.x_pos_max) self.constraints.append(self.cvx_x_neg_real >= self.x_neg_min) self.constraints.append(self.cvx_x_neg_real <= self.x_neg_max) else: self.constraints.append(self.cvx_x_pos >= self.x_pos_min) self.constraints.append(self.cvx_x_pos <= self.x_pos_max) self.constraints.append(self.cvx_x_neg >= self.x_neg_min) self.constraints.append(self.cvx_x_neg <= self.x_neg_max) if constrain_max_loss: self.constraints.append(1 - (cvx_dot(self.cvx_theta, self.cvx_x_pos) + self.cvx_bias) < self.cvx_max_loss_pos) self.constraints.append(1 + (cvx_dot(self.cvx_theta, self.cvx_x_neg) + self.cvx_bias) < self.cvx_max_loss_neg) if dataset_name in ['mnist_17']: self.constraints.append(self.cvx_x_pos <= 1) self.constraints.append(self.cvx_x_neg <= 1) if dataset_name == 'adult': # binary featutre constraints: beacuse of one-hot encoding self.constraints.append( cvx_dot(self.cvx_work_class, self.cvx_x_pos_binary) == 1) self.constraints.append( cvx_dot(self.cvx_work_class, self.cvx_x_neg_binary) == 1) self.constraints.append( cvx_dot(self.cvx_education, self.cvx_x_pos_binary) == 1) self.constraints.append( cvx_dot(self.cvx_education, self.cvx_x_neg_binary) == 1) self.constraints.append( cvx_dot(self.cvx_martial, self.cvx_x_pos_binary) == 1) self.constraints.append( cvx_dot(self.cvx_martial, self.cvx_x_neg_binary) == 1) self.constraints.append( cvx_dot(self.cvx_occupation, self.cvx_x_pos_binary) == 1) self.constraints.append( cvx_dot(self.cvx_occupation, self.cvx_x_neg_binary) == 1) self.constraints.append( cvx_dot(self.cvx_relationship, self.cvx_x_pos_binary) == 1) self.constraints.append( cvx_dot(self.cvx_relationship, self.cvx_x_neg_binary) == 1) self.constraints.append( cvx_dot(self.cvx_race, self.cvx_x_pos_binary) == 1) self.constraints.append( cvx_dot(self.cvx_race, self.cvx_x_neg_binary) == 1) # If we pass in X, do the LP/integer constraint if (X is not None) and (dataset_name in ['enron', 'imdb']): if sparse.issparse(X): X_max = np.max(X, axis=0).toarray().reshape(-1) else: X_max = np.max(X, axis=0).reshape(-1) X_max[X_max < 1] = 1 X_max[X_max > 50] = 50 self.constraints.append(self.cvx_x_pos <= X_max) self.constraints.append(self.cvx_x_neg <= X_max) kmax = int(np.ceil(np.max(X_max))) self.cvx_env_pos = cvx.Variable(d) self.cvx_env_neg = cvx.Variable(d) for k in range(1, kmax + 1): active = k <= (X_max) self.constraints.append( self.cvx_env_pos[active] >= self.cvx_x_pos[active] * (2 * k - 1) - k * (k - 1)) self.constraints.append( self.cvx_env_neg[active] >= self.cvx_x_neg[active] * (2 * k - 1) - k * (k - 1)) if use_l2: self.constraints.append( (cvx.sum_entries(self.cvx_env_pos) - 2 * cvx_dot(self.cvx_centroid_pos, self.cvx_x_pos) + cvx.sum_squares(self.cvx_centroid_pos)) < ( self.cvx_sphere_radius_pos**2)) self.constraints.append( (cvx.sum_entries(self.cvx_env_neg) - 2 * cvx_dot(self.cvx_centroid_neg, self.cvx_x_neg) + cvx.sum_squares(self.cvx_centroid_neg)) < ( self.cvx_sphere_radius_neg**2)) else: if use_l2: self.constraints.append( cvx.pnorm(self.cvx_x_pos - self.cvx_centroid_pos, 2)**2 < self.cvx_sphere_radius_pos**2) self.constraints.append( cvx.pnorm(self.cvx_x_neg - self.cvx_centroid_neg, 2)**2 < self.cvx_sphere_radius_neg**2)
def solve(n_p, n_d, n_s, G, T, M, indisp, forced, slot_choice, demand, prop=0.5, hist=None): """ Solves the Integer Programming problem that generates a schedule. The current constraints are, maximum of one man per slot... Args: n_p (int): the number of people in the list n_d (int): the number of days being considered n_s (int): the number of slots of work per day G (ndarray): A np array (colum vector) of 1s and 0s representing the gender of each person in the list, 1 for man and 0 for woman T (ndarray): A np array (colum vector) representing the teacher status of each person in the list, 1 for teacher and 0 for auxiliar M (ndarray): A np array (colum vector) representing the maturity status of each person in the list, 1 for mature and 0 otherwise indisp (list): List of tuples corresponding to the the date indisponibilities in the form (person, day) forced (list): Similarly to indisp, this list contains the tuples of people that we want to force to be present in a given slot in the solution. In this case the tuples are (person, day*n_s+slot). slot_choice (ndarray): A somewhat dense matrix of shape (n_p, n_s) representing the disponibility of each person to work on each slot. 1 means available, 0 otherwise demand (ndarray): A (n_d*n_s) column vector of the demand of people for each slot. prop (float): Maximum proportion of men in each slot Returns: solution (ndarray): A matrix of shape (n_p, n_d*n_s) where xij = 1 represents a person p working on day j//n_s on slot j%n_s """ # TODO Change the disp matrix to slots? Maybe add another constraint # source, specifically targeting the day and slot. # To fix someone on a specific role you can set the other slots to 0 # every day. X = cvx.Bool(n_p, n_d * n_s) if demand is not None: # print('demand is not None, but is: ', demand) demand_constr = [] for s in range(n_d * n_s): demand_constr.append(cvx.sum_entries(X[:, s]) == demand[s]) # This is just an example, I need to change the rest of the code to use it else: demand_constr = [1 > 0] # Date Indisponibility constraints ind_constr = [] for p, d in indisp: # Check if the list is being correctly appended: The elements, not the list ind_constr = ind_constr + [X[p, d * n_s + k] == 0 for k in range(n_s)] # Gender constraints gend_constr = [] for s in range(n_d * n_s): if demand[s] > 1: gend_constr.append(G.reshape(1, n_p) * X[:, s] <= prop * demand[s]) # Teacher constraints teach_constr = [] for s in range(n_d * n_s): if demand[s] > 1: teach_constr.append(T.reshape(1, n_p) * X[:, s] == 1) # Maturity constraints matur_constr = [] for s in range(n_d * n_s): if demand[s] > 1: matur_constr.append(M.reshape(1, n_p) * X[:, s] >= 1) # No Repeat constraints no_rep_constr = [] for d in range(n_d): for p in range(n_p): no_rep_constr.append( cvx.sum_entries(X[p, d * n_s:n_s * (d + 1)]) <= 1) # Slot (Activity) choice constraint slot_constr = [] for p in range(n_p): for s in range(n_s): slot_constr = slot_constr + [ X[p, s + n_s * d] <= slot_choice[p, s] for d in range(n_d) ] # Forced constraint force_constr = [] for p, d in forced: force_constr.append(X[p, d] == 1) constraints = (demand_constr + ind_constr + gend_constr + teach_constr + matur_constr + no_rep_constr + slot_constr + force_constr) # Objective Function obj = cvx.Minimize(cvx.max_entries(cvx.sum_entries(X, axis=1))) prob = cvx.Problem(obj, constraints) prob.solve(solver=cvx.GLPK_MI) sol = X.value value = prob.value if sol is not None: # Gets rids of the residues, rounds everything to zero or one sol = np.int8(sol.round(2)) value = int(round(value)) return prob.status, sol, value
# # A sample code to solve a knapsack_problem with cvxpy # # Author: Atsushi Sakai (@Atsushi_twi) # import cvxpy import numpy as np import random import time N_item = 30000 size = np.array([random.randint(1, 50) for i in range(N_item)]) weight = np.array([random.randint(1, 50) for i in range(N_item)]) capacity = 1000 x = cvxpy.Bool(size.shape[0]) objective = cvxpy.Maximize(weight * x) constraints = [capacity >= size * x] start = time.time() prob = cvxpy.Problem(objective, constraints) prob.solve(solver=cvxpy.ECOS_BB) elapsed_time = time.time() - start print("elapsed_time:{0}".format(elapsed_time) + "[sec]") result = [round(ix[0, 0]) for ix in x.value] print("status:", prob.status) print("optimal value", prob.value)
def addBinVar(self): self._boolid += 1 return cvxpy.Bool()
for i in range(N - 1): obsRHS = np.column_stack((obsRHS, obsRHS_1)) # Vertices of the obstacle obsVerts = np.asarray([[3.5, 3.5, 6.5, 6.5, 3.5], [3.5, 6.5, 6.5, 3.5, 3.5]]) #### Define the system matrices (as matrix types so we can multiply) #### A = np.matrix( np.array([[1, 0, 1, 0], [0, 1, 0, 1], [0, 0, 1, 0], [0, 0, 0, 1]])) B = np.matrix(np.array([[0.5, 0], [0, 0.5], [1, 0], [0, 1]])) # Define the decision variables X = cvx.Variable(4, N + 1) # States U = cvx.Variable(2, N) # Inputs b = cvx.Bool(4, N) # Binary Variables #### Define the Big-M constraint here #### M = 100 #### Define dynamic constraints here #### ## Initial condition con = [X[:, 0] == np.matrix('0;0;0;0')] ## Dynamics con.extend([A * X[:, 0:15] + B * U == X[:, 1:16]]) ## Input constraints con.extend([cvx.norm(U, "inf") <= 0.5])
def get_infected_dataset(self, new_train_data, new_train_labels): n, m = np.shape(new_train_data) svc = SVC(C=self.a, kernel='linear') svc.fit(new_train_data, new_train_labels) w_old = svc.coef_[0] b_old = svc.intercept_[0] b_t = 1000 h_hat = {} #cvx.Variable((n, n, m)) for k in range(m): h_hat[k] = cvx.Variable(n, n) g = cvx.Variable(n, n) b = cvx.Variable() a_slack = cvx.Variable(n) c_slack = cvx.Variable(n) c_dual = cvx.Variable(n) z = cvx.Bool(n) labels = cvx.Constant(np.array(new_train_labels)) data = cvx.Constant(np.array(new_train_data)) cons = [ a_slack >= -1, c_dual >= 0, #c_dual <= self.a*(1-z), # todo: double check labels * c_dual == 0, c_slack >= 0, #c_slack <= b_t*z ] w = {} for j in range(m): num1 = c_dual.T * cvx.vstack( [labels[i] * data[i, j] for i in range(n)]) num2 = labels * cvx.diag(h_hat[j]) w[j] = self.a * (num1 + num2) for i in range(n): g_add = 0 for k in range(n): h_kij = cvx.vstack([h_hat[j][k, i] for j in range(m)]) g_add += (data[k, :] * h_kij) * labels[k] + labels[k] * g[k, i] cons.append(c_dual[i] <= self.a * (1 - z[i])) cons.append(c_slack[i] <= b_t * z[i]) cons.append(a_slack[i] >= labels[i] * (data[i, :] * np.array(list(w)) + b)) cons.append( labels[i] * (data[i, :] * np.array(list(w)) + g_add + b) >= 1 - c_slack[i]) cons.append(labels[i] * (data[i, :] * np.array(list(w)) + g_add + b) - 1 + c_slack[i] <= b_t * z[i]) for j in range(n): cons.append(g[i, j] >= -c_dual[i] * (self.eps**2)) cons.append(g[i, j] <= c_dual[i] * (self.eps**2)) for k in range(m): cons.append(h_hat[k][j, i] >= -self.eps * c_dual[j]) cons.append(h_hat[k][j, i] <= self.eps * c_dual[j]) obj = cvx.Minimize(cvx.sum_entries(a_slack)) prob = cvx.Problem(obj, cons) prob.solve() print(prob.status) # print(prob.value) # recovering infected dataset h = [] infected_dataset = [] n_sup = 0 for i in range(n): hi = [(h_hat[j][i, i].value / c_dual[i].value if c_dual[i].value != 0 else 0.0) for j in range(m)] h.append(hi) print(c_dual[i].value) if c_dual[i].value != 0: n_sup += 1 infected_dataset.append( [new_train_data[i, j] + hi[j] for j in range(m)]) print('w0= ', w[0].value, 'w1= ', w[1].value, 'b= ', b.value) print('support vectors: ', n_sup) return np.array(infected_dataset), np.linalg.norm(h) / n