def solve_problem_min_cost_s_t_model(self, model, x, tol): ''' Fucntion solve the optimization problem find the x' that minimize the cost function with constrain of the model predict x' as positive. :param model: The model that the player wants to get positive prediction. :param x: Current player's vector features. :param tol: Small tolerance for optimization needs. That indicates how much x' should be above the model intercept. :return: Tuple: (x', cost(x, x')). ''' x_t = cp.Variable(len(x)) func_to_solve = cp.Minimize(self.cost_factor * (cp.maximum( (1 - self.epsilon) * self.a.T @ (x_t - x), 0) + self.epsilon * cp.sum( (x_t - x)**2))) constrains = [x_t @ model.coef_[0] >= -model.intercept_ + tol] prob = cp.Problem(func_to_solve, constrains) try: prob.solve() if x_t is None: print("couldn't solve this problem") return cost = cp.maximum((1 - self.epsilon) * self.a.T @ (x_t - x), 0) + self.epsilon * cp.sum((x_t - x)**2) cost *= self.cost_factor return x_t, cost except: print('solver failed') return x, None
def op_func(self, A, B, estimate_loss): """ Solves the convex optimzation problem Args: A: Exponent of power-law equation B: of power-law equation estimate_loss: estimated loss on given data using power-law equation Return: Number of examples to collect for the slices within the budget """ x = cp.Variable(self.num_class, integer=True) for i in range(self.num_class): loss = cp.multiply(B[i], cp.power((x[i] + self.data_num_array[i]), A[i])) counter_loss = (np.sum(estimate_loss) - estimate_loss[i]) / (self.num_class - 1) if i == 0: ob_func = loss + self.Lambda * cp.maximum( 0, (loss / counter_loss) - 1) else: ob_func += loss + self.Lambda * cp.maximum( 0, (loss / counter_loss) - 1) constraints = [cp.sum(cp.multiply(x, self.cost_func)) <= self.budget ] + [x >= 0] objective = cp.Minimize(ob_func) prob = cp.Problem(objective, constraints) prob.solve(solver="ECOS_BB") return np.add(x.value, 0.5).astype(int)
def test_rank_one_nmf(self): X = cp.Variable((3, 3), pos=True) x = cp.Variable((3, ), pos=True) y = cp.Variable((3, ), pos=True) xy = cp.vstack([x[0] * y, x[1] * y, x[2] * y]) R = cp.maximum(cp.multiply(X, (xy)**(-1.0)), cp.multiply(X**(-1.0), xy)) objective = cp.sum(R) constraints = [ X[0, 0] == 1.0, X[0, 2] == 1.9, X[1, 1] == 0.8, X[2, 0] == 3.2, X[2, 1] == 5.9, x[0] * x[1] * x[2] == 1.0, ] # smoke test. prob = cp.Problem(cp.Minimize(objective), constraints) prob.solve(SOLVER, gp=True) optimal_value = prob.value param = cp.Parameter(value=-2.0) R = cp.maximum(cp.multiply(X, (xy)**(param)), cp.multiply(X**(param), xy)) objective = cp.sum(R) prob = cp.Problem(cp.Minimize(objective), constraints) prob.solve(SOLVER, gp=True, enforce_dpp=True) # now change param to point to known_value, and check we recover the # correct optimal value param.value = -1.0 prob.solve(SOLVER, gp=True, enforce_dpp=True) self.assertAlmostEqual(prob.value, optimal_value)
def peak(rates, infrastructure, interface, baseline_peak=0, **kwargs): agg_power = aggregate_power(rates, infrastructure) max_power = cp.max(agg_power) prev_peak = interface.get_prev_peak() * infrastructure.voltages[0] / 1000 if baseline_peak > 0: return cp.maximum(max_power, baseline_peak, prev_peak) else: return cp.maximum(max_power, prev_peak)
def test_elemwise_arg_count(self) -> None: """Test arg count for max and min variants. """ error_message = r"__init__\(\) missing 1 required positional argument: 'arg2'" with pytest.raises(TypeError, match=error_message): cp.maximum(1) with pytest.raises(TypeError, match=error_message): cp.minimum(1)
def test_maximum(self) -> None: """Test domain for maximum. """ b = Variable() expr = cp.maximum(self.a, b) self.a.value = 2 b.value = 4 self.assertAlmostEqual(expr.grad[self.a], 0) self.assertAlmostEqual(expr.grad[b], 1) self.a.value = 3 b.value = 0 self.assertAlmostEqual(expr.grad[self.a], 1) self.assertAlmostEqual(expr.grad[b], 0) self.a.value = -1 b.value = 2 self.assertAlmostEqual(expr.grad[self.a], 0) self.assertAlmostEqual(expr.grad[b], 1) y = Variable(2) expr = cp.maximum(self.x, y) self.x.value = [3, 4] y.value = [5, -5] val = np.zeros((2, 2)) + np.diag([0, 1]) self.assertItemsAlmostEqual(expr.grad[self.x].toarray(), val) val = np.zeros((2, 2)) + np.diag([1, 0]) self.assertItemsAlmostEqual(expr.grad[y].toarray(), val) expr = cp.maximum(self.x, y) self.x.value = [-1e-9, 4] y.value = [1, 4] val = np.zeros((2, 2)) + np.diag([0, 1]) self.assertItemsAlmostEqual(expr.grad[self.x].toarray(), val) val = np.zeros((2, 2)) + np.diag([1, 0]) self.assertItemsAlmostEqual(expr.grad[y].toarray(), val) expr = cp.maximum(self.A, self.B) self.A.value = [[1, 2], [3, 4]] self.B.value = [[5, 1], [3, 2.3]] val = np.zeros((4, 4)) + np.diag([0, 1, 1, 1]) self.assertItemsAlmostEqual(expr.grad[self.A].toarray(), val) val = np.zeros((4, 4)) + np.diag([1, 0, 0, 0]) self.assertItemsAlmostEqual(expr.grad[self.B].toarray(), val) # cummax expr = cp.cummax(self.x) self.x.value = [2, 1] val = np.zeros((2, 2)) val[0, 0] = 1 self.assertItemsAlmostEqual(expr.grad[self.x].toarray(), val) expr = cp.cummax(self.x[:, None], axis=1) self.x.value = [2, 1] val = np.eye(2) self.assertItemsAlmostEqual(expr.grad[self.x].toarray(), val)
def test_elemwise_arg_count(self): """Test arg count for max and min variants. """ with self.assertRaises(Exception) as cm: cp.maximum(1) self.assertTrue(str(cm.exception) in ( "__init__() takes at least 3 arguments (2 given)", "__init__() missing 1 required positional argument: 'arg2'")) with self.assertRaises(Exception) as cm: cp.minimum(1) self.assertTrue(str(cm.exception) in ( "__init__() takes at least 3 arguments (2 given)", "__init__() missing 1 required positional argument: 'arg2'"))
def maximize_features_against_binary_model(self, x: np.array, trained_model, tolerance=1e-9): x_tag = cp.Variable(len(x)) func_to_solve = cp.Minimize(cp.maximum(self.cost_factor * self.a.T @ (x_tag - x), 0)) constrains = [x_tag @ trained_model.coef_[0] >= -trained_model.intercept_ + tolerance] prob = cp.Problem(func_to_solve, constrains) prob.solve() cost_result = cp.maximum(self.cost_factor * self.a.T @ (x_tag.value - x), 0) if x_tag is None: print("couldn't solve this problem") return if trained_model.predict(x_tag.value.reshape(1, -1))[0] == 1 and cost_result.value < 2: return x_tag.value else: return x
def difference_magnitude(self, other): # TODO: assert type(other) is QuadraticForm, \ 'Quadratic forms can only be compared among themselves' assert self.n == other.n, \ 'Quadratic forms must have the same dimension' if (self.b is None and self.c is None and other.b is None and other.c is None): lbd = cvx.Variable() mid_matrix = self.Q - lbd * other.Q con = [lbd >= 0] else: mid_matrix = self.Q - other.Q con = [] mu_pos = cvx.Variable() mu_neg = cvx.Variable() con.append(mid_matrix << mu_pos * np.eye(self.n)) con.append(mid_matrix >> -mu_neg * np.eye(self.n)) con += [mu_pos >= 0, mu_neg >= 0] prob = cvx.Problem(cvx.Minimize(cvx.maximum(mu_pos, mu_neg)), con) prob.solve() if prob.status != 'optimal': if 'innacurate' in prob.status: logging.warning('Problem status is %s', prob.status) else: raise ETCUtilError( 'This shouldn' 't be happening. Problem status is %s', prob.status) return prob.value
def test_rank_one_nmf(self) -> None: X = cp.Variable((3, 3), pos=True) x = cp.Variable((3, ), pos=True) y = cp.Variable((3, ), pos=True) xy = cp.vstack([x[0] * y, x[1] * y, x[2] * y]) a = cp.Parameter(value=-1.0) b = cp.Parameter(pos=True, shape=(6, ), value=np.array([1.0, 1.9, 0.8, 3.2, 5.9, 1.0])) R = cp.maximum(cp.multiply(X, (xy)**(a)), cp.multiply(X**(a), xy)) objective = cp.sum(R) constraints = [ X[0, 0] == b[0], X[0, 2] == b[1], X[1, 1] == b[2], X[2, 0] == b[3], X[2, 1] == b[4], x[0] * x[1] * x[2] == b[5], ] problem = cp.Problem(cp.Minimize(objective), constraints) # SCS struggles to solves this problem (solved/inaccurate, unless # max_iters is very high like 10000) gradcheck(problem, gp=True, solve_methods=[s.SCS], atol=1e-2, max_iters=1000) perturbcheck(problem, gp=True, solve_methods=[s.SCS], atol=1e-2, max_iters=1000)
def offline_dynamic_provision(df, verbose): p = 0.4 / 2 a = 4 / 2 b = 4 / 2 y = df.to_list() x = cp.Variable(672) cost = 0 for i in range(1, 672): cost += p * x[i] + a * cp.maximum( 0, y[i - 1] - x[i]) + b * cp.abs(x[i] - x[i - 1]) objective = cp.Minimize(cost) constraints = [x[0] == 0, x[1:] >= 0] problem = cp.Problem(objective, constraints) result = problem.solve() opt = pd.Series(np.array(x.value), index=df.index) opt_dict['Offline Dynamic'] = result decision_dict['Offline Dynamic'] = opt if (verbose == True): print("\nThe optimal value is", result) print("First 15 optimal values of x is") print(x.value[0:15]) plot_graph_offline('dynamic', opt) else: return opt
def _init_input_constraints(self): input_constraints = { "s": self.constraints.sin, "v": self.constraints.vin } node_push_map = { "s": defaultdict(set), "v": defaultdict(set) } for src, dst, tp, _ in self.edges: if dst not in self.node_to_loc_map: continue node_push_map[tp][src].add(dst) for tp, push_map in node_push_map.items(): if not push_map: continue movement = [] for src, destinations in push_map.items(): if not self._is_internal_node(src): # we use this to filter out all of the contributions within a partition. # since external nodes aren't in any relevant partition, they always contribute. base_filter = np.zeros(self.partitions) else: base_filter = self.node_to_partition_matrix[self.node_to_loc_map[src], :] contributions = functools.reduce(operator.add, [ self.node_to_partition_matrix[self.node_to_loc_map[dst]] for dst in destinations]) movement.append(cvxpy.maximum(self._project_to_bool(contributions) - base_filter, 0)) self.to_print["output - " + tp] = movement self._add_constraint( functools.reduce(operator.add, movement) <= input_constraints[tp])
def rhc_fixed_window(y, predictionHorizon, prediction_algo): T = 4; p = 0.4/2; a = 4/2; b = 4/2; optValues = np.zeros(T); for horizonStart in range(0, T): horizonEnd = horizonStart + predictionHorizon windowY = y[horizonStart: horizonEnd] obj = 0; x = cp.Variable(predictionHorizon) for i in range(0, predictionHorizon): obj += p * x[i] + a * cp.maximum(0, windowY[i] - x[i]) if i == 0: obj += b * cp.abs(x[i]); #because x(0) is 0 else: obj += b * cp.abs(x[i] - x[i - 1]) objective = cp.Minimize(obj) problem = cp.Problem(objective) result = problem.solve() optValues[horizonStart] = x.value[0]; obj = 0; for i in range(0, T): obj += p * optValues[i] + a * max(0, y[i] - optValues[i]) if i == 0: obj += b * abs(optValues[i]); #because x(0) is 0 else: obj += b * abs(optValues[i] - optValues[i - 1]) return obj
def solve_problem_max_model_s_t_cost(self, model, x, spare_cost, tol=0.00001): x_t = cp.Variable(len(x)) func_to_solve = cp.Maximize( x_t @ model.coef_[0] + model.intercept_) constrains = [self.cost_factor * (cp.maximum((1 - self.epsilon) * self.a.T @ (x_t - x), 0) + self.epsilon * cp.sum((x_t - x) ** 2)) <= spare_cost - tol] prob = cp.Problem(func_to_solve, constrains) prob.solve() if x_t.value is None: print("couldn't solve this problem") return None cost = cp.maximum((1 - self.epsilon) * self.a.T @ (x_t - x), 0) + self.epsilon * cp.sum( (x_t - x) ** 2) cost *= self.cost_factor return x_t, cost
def test_maximum(self): x = cp.Variable(pos=True) y = cp.Variable(pos=True) alpha = cp.Parameter(value=0.5) beta = cp.Parameter(pos=True, value=3.0) kappa = cp.Parameter(pos=True, value=1.0) tau = cp.Parameter(pos=True, value=4.0) prod1 = x * y**alpha prod2 = beta * x * y**alpha obj = cp.Minimize(cp.maximum(prod1, prod2)) constr = [x == kappa, y == tau] problem = cp.Problem(obj, constr) self.assertTrue(problem.is_dgp(dpp=True)) problem.solve(SOLVER, gp=True, enforce_dpp=True) # max(1*2, 3*1*2) = 6 self.assertAlmostEqual(problem.value, 6.0, places=4) self.assertAlmostEqual(x.value, 1.0) self.assertAlmostEqual(y.value, 4.0) alpha.value = 2 beta.value = 0.5 kappa.value = 2.0 # x tau.value = 3.0 # y problem.solve(SOLVER, gp=True, enforce_dpp=True) # max(2*9, 0.5*2*9) == 18 self.assertAlmostEqual(problem.value, 18.0, places=4) self.assertAlmostEqual(x.value, 2.0) self.assertAlmostEqual(y.value, 3.0)
def train(self, X, Y): '''Assumes that each row is a sample''' # Create two optimization variables. w = cp.Variable(X.shape[1]) b = cp.Variable() # Create constraints. constraints = self._create_cons(Y, X, w, b) # Form objective. obj = (1/2)*cp.norm(w,2) if self.soft: obj = obj/(self.C) for i in range(X.shape[0]): temp = cp.maximum(0, 1 - Y[i] * (w @ np.squeeze(X[i, :]) + b)) obj = obj + temp obj = cp.Minimize(obj) # Form and solve problem. prob = cp.Problem(obj, constraints) prob.solve() # Returns the optimal value. # storing for future accesses self.obj = obj self.constraints = constraints self.prob = prob self.w = w self.b = b
def _init_output_constraints(self): output_constraints = { "s": self.constraints.sout, "v": self.constraints.vout } # for each node, if it's used anywhere not in the same partition, then it counts. # an external output automatically counts nodes_with_external_outputs = { "s": set(), "v": set() } for src, dst, tp, _ in self.edges: if self._is_internal_node(src) and not self._is_internal_node(dst): nodes_with_external_outputs[tp].add(src) node_push_map = { "s": defaultdict(set), "v": defaultdict(set) } for src, dst, tp, _ in self.edges: # don't count external nodes if not self._is_internal_node(src): continue # if a node already pushes out to an external node, we know it's guaranteed to have an output. if src in nodes_with_external_outputs[tp]: continue node_push_map[tp][self.node_to_loc_map[src]].add(self.node_to_loc_map[dst]) for tp, push_map in node_push_map.items(): if not push_map: continue exports = [] for src_loc, destination_locs in push_map.items(): src_partition = self.node_to_partition_matrix[src_loc, :] destination_vec = sum(self.node_to_partition_matrix[dst] for dst in destination_locs) has_exports = self._project_to_bool( cvxpy.sum(cvxpy.maximum(destination_vec - src_partition * self.num_nodes, 0))) # has_exports && src_partition exports.append(cvxpy.maximum(has_exports + src_partition - 1, 0)) total_movement = functools.reduce(operator.add, exports) for src in nodes_with_external_outputs[tp]: total_movement += self.node_to_partition_matrix[self.node_to_loc_map[src], :] self._add_constraint(total_movement <= output_constraints[tp])
def test_parallel_vs_serial_learning(self): """Test parallel VS serial learning""" # Generate data np.random.seed(1) T = 5 M = 2. h = 1. c = 1. p = 1. x_init = 2. radius = 2. n_train = 1000 # Number of samples # Define problem x = cp.Variable(T + 1) u = cp.Variable(T) # Define parameter and sampling points d = cp.Parameter(T, nonneg=True, name="d") d_bar = 3. * np.ones(T) X_d = uniform_sphere_sample(d_bar, radius, n=n_train) df = pd.DataFrame({'d': list(X_d)}) # Constaints constraints = [x[0] == x_init] for t in range(T): constraints += [x[t + 1] == x[t] + u[t] - d[t]] constraints += [u >= 0, u <= M] # Objective cost = cp.sum(cp.maximum(h * x, -p * x)) + c * cp.sum(u) # Define problem cvxpy_problem = cp.Problem(cp.Minimize(cost), constraints) problem = Problem(cvxpy_problem) # Solve for all theta in serial results_serial = problem.solve_parametric(df, parallel=False) # Solve for all theta in parallel results_parallel = problem.solve_parametric(df, parallel=True) # Assert all results match for i in range(n_train): serial = results_serial[i] parallel = results_parallel[i] # Compare x npt.assert_array_almost_equal(serial['x'], parallel['x'], decimal=TOL) # Compare cost npt.assert_array_almost_equal(serial['cost'], parallel['cost'], decimal=TOL) # Compare strategy self.assertTrue(serial['strategy'] == parallel['strategy'])
def _stamp_preference_constraints(self, X, x_sensitive, w, cons_type, s_val_to_cons_sum=None): """ No need to pass s_val_to_cons_sum for preferred treatment (envy free) constraints # 1 - pref imp, 2 - EF, 3 - pref imp & EF """ assert cons_type in self.VALID_PREFERED_CONSTRAINTS assert cons_type == self.CONSTRAINT_PREFERED_TREATMENT or s_val_to_cons_sum is not None assert set(x_sensitive) == w.keys() group_labels = set(x_sensitive) prod_dict = {} for z in group_labels: idx = x_sensitive == z Xz = X[idx, :] nz = float(Xz.shape[0]) if self.sparse_formulation: Uz, mz = np.unique( Xz, axis=0 ) #dropping duplicates so that we have fewer constraints Tz = Uz * mz[:, np.newaxis] prod_dict[z] = { o: cp.sum(cp.pos(Tz * wo)) / nz for o, wo in w.items() } else: prod_dict[z] = { o: cp.sum(cp.maximum(0.0, Xz * wo)) / nz for o, wo in w.items() } constraints = [] if cons_type == self.CONSTRAINT_PREFERED_IMPACT: for z in group_labels: constraints.append(prod_dict[z][z] >= s_val_to_cons_sum[z][z]) elif cons_type == self.CONSTRAINT_PREFERED_TREATMENT: for z in group_labels: other_groups = set(group_labels) - {z} for o in other_groups: constraints.append(prod_dict[z][z] >= prod_dict[z][o]) elif cons_type == self.CONSTRAINT_PREFERED_BOTH: for z in group_labels: constraints.append(prod_dict[z][z] >= s_val_to_cons_sum[z][z]) #preferred impact other_groups = set(group_labels) - {z} for o in other_groups: constraints.append(prod_dict[z][z] >= prod_dict[z][o]) return constraints
def _init_edge_deps(self): filtered_edges = [edge for edge in self.edges if self._is_internal_node(edge.src) and self._is_internal_node(edge.dst)] for src, dst, _, _ in filtered_edges: # If either end is a retime node, then we make sure that it can't merge. twiddle = src in self.retime_nodes or dst in self.retime_nodes # self._add_constraint( # self.node_partitions[self.node_to_loc_map[src]] + twiddle <= self.node_partitions[ # self.node_to_loc_map[dst]]) self._add_pseudo_constraint(cvxpy.maximum(self.node_partitions[self.node_to_loc_map[src]] + twiddle - self.node_partitions[self.node_to_loc_map[dst]], 0))
def setup_solver_cvx(self): c = self.constvars imagedims = c['imagedims'] n_image = c['n_image'] d_image = c['d_image'] l_labels = c['l_labels'] l_shm = c['l_shm'] self.cvx_x = Variable( ('p', (l_shm, d_image, n_image)), ('q0', (n_image, )), ('q1', (l_labels, n_image)), ('q2', (l_labels, n_image)), ) self.cvx_y = Variable( ('u1', (n_image, l_labels)), ('v', (n_image, l_shm)), ('misc', (n_image, )), ) p, q0, q1, q2 = [cvxVariable(*a['shape']) for a in self.cvx_x.vars()] self.cvx_vars = p + [q0, q1, q2] fid_fun_dual = 0 for i in range(n_image): for k in range(l_labels): fid_fun_dual += -1.0/c['b'][k]*(cvx.power(q2[k,i],2)/2 \ + cvx.maximum(q2[k,i]*c['b'][k]*c['f1'][i,k], q2[k,i]*c['b'][k]*c['f2'][i,k])) self.cvx_obj = cvx.Maximize(fid_fun_dual - cvx.sum(q0)) div_op = sparse_div_op(imagedims) self.cvx_dual = True self.cvx_constr = [] # u1_constr for i in range(n_image): self.cvx_constr.append(c['b'] * q0[i] - q1[:, i] >= 0) # v_constr for i in range(n_image): for k in range(l_shm): Yk = cvx.vec(c['Y'][:, k]) self.cvx_constr.append( Yk.T*(c['M'][k]*q2[:,i] + q1[:,i]) \ - cvxOp(div_op, p[k], i) == 0) # additional inequality constraints for i in range(n_image): self.cvx_constr.append(sum(cvx.sum_squares(p[k][:,i]) \ for k in range(l_shm)) <= c['lbd']**2)
def test_basic_maximum(self): x, y = cp.Variable(2) expr = cp.maximum(cp.ceil(x), cp.ceil(y)) problem = cp.Problem(cp.Minimize(expr), [x >= 12, x <= 17, y >= 17.4]) self.assertTrue(problem.is_dqcp()) problem.solve(SOLVER, qcp=True) self.assertEqual(problem.objective.value, 18.0) self.assertLess(x.value, 17.1) self.assertGreater(x.value, 11.9) self.assertGreater(y.value, 17.3)
def get_cost(s): ''' get total cost for a series of height differences given the corresponding cost function ''' relu = lambda u: cp.maximum(0, u) fill_cost = lambda u: 2 * relu(u)**2 + 30 * relu(u) cut_cost = lambda u: 12 * relu(-u)**2 + relu(-u) fill_costs = np.vectorize(fill_cost)(s) cut_costs = np.vectorize(cut_cost)(s) return cp.sum(fill_costs + cut_costs)
def test_basic_composition(self): x, y = cp.Variable(2) expr = cp.maximum(cp.ceil(cp.ceil(x)), cp.ceil(cp.ceil(y))) problem = cp.Problem(cp.Minimize(expr), [x >= 12, x <= 17, y >= 17.4]) self.assertTrue(problem.is_dqcp()) problem.solve(SOLVER, qcp=True) self.assertEqual(problem.objective.value, 18.0) self.assertLess(x.value, 17.1) self.assertGreater(x.value, 11.9) self.assertGreater(y.value, 17.3) # This problem should have the same solution. expr = cp.maximum(cp.floor(cp.ceil(x)), cp.floor(cp.ceil(y))) problem = cp.Problem(cp.Minimize(expr), [x >= 12, x <= 17, y >= 17.4]) self.assertTrue(problem.is_dqcp()) problem.solve(SOLVER, qcp=True) self.assertEqual(problem.objective.value, 18.0) self.assertLess(x.value, 17.1) self.assertGreater(x.value, 11.9) self.assertGreater(y.value, 17.3)
def solve_problem_min_cost_s_t_model(self, model, x, tol): x_t = cp.Variable(len(x)) func_to_solve = cp.Minimize(self.cost_factor * (cp.maximum( (1 - self.epsilon) * self.a.T @ (x_t - x), 0) + self.epsilon * cp.sum( (x_t - x)**2))) constrains = [x_t @ model.coef_[0] >= -model.intercept_ + tol] prob = cp.Problem(func_to_solve, constrains) try: prob.solve() if x_t is None: print("couldn't solve this problem") return cost = cp.maximum((1 - self.epsilon) * self.a.T @ (x_t - x), 0) + self.epsilon * cp.sum((x_t - x)**2) cost *= self.cost_factor return x_t, cost except: print('solver faild') return x, None
def _init_output_costs(self, cost: Cost, matrix: cvxpy.Variable, loc_map: typing.Dict[Node, int], edge_type: EdgeType): # for each node, for count number of distinct out_ids that aren't in the same partition. edge_map = defaultdict(list) edge_srcs = {} for edge in (edge for edge in self.edges if edge.tp == edge_type): edge_map[edge.out_id].append(edge.dst) edge_srcs[edge.out_id] = edge.src movement = [] for out_id in edge_srcs: src_node = self.id_to_node_lookup[edge_srcs[out_id]] if src_node not in loc_map: continue src_row = self._get_row_or_zeroes(matrix, loc_map, src_node) dst_nodes = [ self.id_to_node_lookup[dst] for dst in edge_map[out_id] ] if any(node not in loc_map for node in dst_nodes): # if a node can't be in this partition type, then we have to export. movement.append(src_row) else: num_outputs = len(dst_nodes) matrix_sum = sum( self._get_row_or_zeroes(matrix, loc_map, dst) for dst in dst_nodes) num_out_of_partition_type_nodes = num_outputs - cvxpy.sum( matrix_sum) out_of_partition_type_movement = self._project_to_bool( num_out_of_partition_type_nodes, num_outputs) in_partition_type_movement = cvxpy.sum( cvxpy.maximum( self._project_to_bool(matrix_sum, self.num_nodes) - src_row, 0)) has_movement = self._project_to_bool( out_of_partition_type_movement + in_partition_type_movement, cost.value) movement.append(cvxpy.maximum(has_movement + src_row - 1, 0)) if movement: self._add_constraint(sum(movement) <= cost.value)
def d(): x = cp.Variable() y = cp.Variable() obj = cp.Minimize(0) constraints = [ cp.norm(cp.vstack([cp.maximum(x, 1), cp.maximum(y, 2)])) <= 3 * x + y ] problem = cp.Problem(obj, constraints) print(f"d before: {problem.is_dcp()}") x = cp.Variable() y = cp.Variable() a = cp.Variable() b = cp.Variable() obj = cp.Minimize(0) constraints = [ cp.norm(cp.vstack([a, b])) <= 3 * x + y, a >= cp.maximum(x, 1), b >= cp.maximum(y, 2), ] problem = cp.Problem(obj, constraints) print(f"d after: {problem.is_dcp()}") problem.solve()
def get_sensitive_attr_cov(dist_dict): """ computes the ramp function for each group to estimate the acceptance rate """ s_val_to_cons_sum = {0:{}, 1:{}} # s_attr_group (0/1) -> w_group (0/1) -> ramp approx for s_val in dist_dict.keys(): for w_group in dist_dict[s_val].keys(): fx = dist_dict[s_val][w_group] s_val_to_cons_sum[s_val][w_group] = cvx.sum( cvx.maximum(0, fx) ) / fx.shape[0] return s_val_to_cons_sum
def test_maximum(self) -> None: x = cp.Variable(pos=True) y = cp.Variable(pos=True) a = cp.Parameter(value=0.5) b = cp.Parameter(pos=True, value=3.0) c = cp.Parameter(pos=True, value=1.0) d = cp.Parameter(pos=True, value=4.0) prod1 = x * y**a prod2 = b * x * y**a obj = cp.Minimize(cp.maximum(prod1, prod2)) constr = [x == c, y == d] problem = cp.Problem(obj, constr) gradcheck(problem, gp=True, atol=1e-3) perturbcheck(problem, gp=True, atol=1e-3)
def offline_dynamic_provision_fixed_window(y): p = 0.4/2 a = 4/2 b = 4/2 x = cp.Variable(4) cost = 0 for i in range(1,4): cost += p*x[i] + a*cp.maximum(0, y[i-1] - x[i]) + b*cp.abs(x[i]-x[i-1]) objective = cp.Minimize(cost) constraints = [x[0] == 0, x[1:] >= 0] problem = cp.Problem(objective, constraints) result = problem.solve() opt = np.array(x.value) opt = np.insert(opt, 0, 0., axis=0) return opt