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_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 test_psd_var(self):
"""Test PSD variable.
"""
s = cp.Variable((2, 2), PSD=True)
var_dict = {s.id: s}
obj = cp.Maximize(cp.minimum(s[0, 1], 10))
const = [cp.diag(s) == np.ones(2)]
problem = cp.Problem(obj, const)
data, _, _ = problem.get_problem_data(solver=cp.SCS)
param_cone_prog = data[cp.settings.PARAM_PROB]
solver = SCS()
raw_solution = solver.solve_via_data(data,
warm_start=False,
verbose=False,
solver_opts={})['x']
sltn_dict = param_cone_prog.split_solution(raw_solution,
active_vars=var_dict)
self.assertEqual(sltn_dict[s.id].shape, s.shape)
sltn_value = sltn_dict[s.id]
adjoint = param_cone_prog.split_adjoint(sltn_dict)
self.assertEqual(adjoint.shape, raw_solution.shape)
self.assertTrue(any(sltn_value[0, 0] == adjoint))
self.assertTrue(any(sltn_value[1, 1] == adjoint))
# off-diagonals of adjoint will be scaled by two
self.assertTrue(any(2 * np.isclose(sltn_value[0, 1], adjoint)))
self.assertTrue(any(2 * np.isclose(sltn_value[1, 0], adjoint)))
problem.solve(solver=cp.SCS)
self.assertItemsAlmostEqual(s.value, sltn_value)
def test_minimum(self):
x = cp.Variable(pos=True)
y = cp.Variable(pos=True)
alpha = cp.Parameter(pos=True, value=1.0, name='alpha')
beta = cp.Parameter(pos=True, value=3.0, name='beta')
prod1 = x * y**alpha
prod2 = beta * x * y**alpha
posy = prod1 + prod2
obj = cp.Maximize(cp.minimum(prod1, prod2, 1 / posy))
constr = [x == alpha, y == 4.0]
dgp = cp.Problem(obj, constr)
dgp.solve(SOLVER, gp=True, enforce_dpp=True)
# prod1 = 1*4, prod2 = 3*4 = 12, 1/posy = 1/(3 +12)
self.assertAlmostEqual(dgp.value, 1.0 / (4.0 + 12.0))
self.assertAlmostEqual(x.value, 1.0)
self.assertAlmostEqual(y.value, 4.0)
alpha.value = 2.0
# prod1 = 2*16, prod2 = 3*2*16 = 96, 1/posy = 1/(32 +96)
dgp.solve(SOLVER, gp=True, enforce_dpp=True)
self.assertAlmostEqual(dgp.value, 1.0 / (32.0 + 96.0))
self.assertAlmostEqual(x.value, 2.0)
self.assertAlmostEqual(y.value, 4.0)
def test_minimum(self) -> None:
"""Test domain for minimum.
"""
b = Variable()
expr = cp.minimum(self.a, b)
self.a.value = 2
b.value = 4
self.assertAlmostEqual(expr.grad[self.a], 1)
self.assertAlmostEqual(expr.grad[b], 0)
self.a.value = 3
b.value = 0
self.assertAlmostEqual(expr.grad[self.a], 0)
self.assertAlmostEqual(expr.grad[b], 1)
self.a.value = -1
b.value = 2
self.assertAlmostEqual(expr.grad[self.a], 1)
self.assertAlmostEqual(expr.grad[b], 0)
y = Variable(2)
expr = cp.minimum(self.x, y)
self.x.value = [3, 4]
y.value = [5, -5]
val = np.zeros((2, 2)) + np.diag([1, 0])
self.assertItemsAlmostEqual(expr.grad[self.x].toarray(), val)
val = np.zeros((2, 2)) + np.diag([0, 1])
self.assertItemsAlmostEqual(expr.grad[y].toarray(), val)
expr = cp.minimum(self.x, y)
self.x.value = [-1e-9, 4]
y.value = [1, 4]
val = np.zeros((2, 2)) + np.diag([1, 1])
self.assertItemsAlmostEqual(expr.grad[self.x].toarray(), val)
val = np.zeros((2, 2)) + np.diag([0, 0])
self.assertItemsAlmostEqual(expr.grad[y].toarray(), val)
expr = cp.minimum(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([1, 0, 1, 0])
self.assertItemsAlmostEqual(expr.grad[self.A].toarray(), val)
val = np.zeros((4, 4)) + np.diag([0, 1, 0, 1])
self.assertItemsAlmostEqual(expr.grad[self.B].toarray(), val)
def test_basic_minimum(self):
x, y = cp.Variable(2)
expr = cp.minimum(cp.ceil(x), cp.ceil(y))
problem = cp.Problem(cp.Maximize(expr), [x >= 11.9, x <= 15.8, y >= 17.4])
self.assertTrue(problem.is_dqcp())
problem.solve(qcp=True)
self.assertEqual(problem.objective.value, 16.0)
self.assertLess(x.value, 16.0)
self.assertGreater(x.value, 14.9)
self.assertGreater(y.value, 17.3)
def test_minimum(self):
x = cvxpy.Variable(pos=True)
y = cvxpy.Variable(pos=True)
prod1 = x * y**0.5
prod2 = 3.0 * x * y**0.5
posy = prod1 + prod2
obj = cvxpy.Maximize(cvxpy.minimum(prod1, prod2, 1 / posy))
constr = [x == 1.0, y == 4.0]
dgp = cvxpy.Problem(obj, constr)
dgp.solve(SOLVER, gp=True)
self.assertAlmostEqual(dgp.value, 1.0 / (2.0 + 6.0))
self.assertAlmostEqual(x.value, 1.0)
self.assertAlmostEqual(y.value, 4.0)
def test_psd_constraint(self):
"""Test PSD constraint.
"""
s = cp.Variable((2, 2))
obj = cp.Maximize(cp.minimum(s[0, 1], 10))
const = [s >> 0, cp.diag(s) == np.ones(2)]
prob = cp.Problem(obj, const)
r = prob.solve(solver=cp.SCS)
s = s.value
print(const[0].residual)
print("value", r)
print("s", s)
print("eigs", np.linalg.eig(s + s.T)[0])
eigs = np.linalg.eig(s + s.T)[0]
self.assertEqual(np.all(eigs >= 0), True)
def revenue(x, p, p_disc, q, vec=False):
r = np.zeros_like(x)
# idx = np.where(x <= q)
# r[idx] = (p * x)[idx]
# idx = np.where(x >= q)
# r[idx] = (p * q + p_disc * (x - q))[idx]
if vec:
r = np.minimum(p * x, p * q + p_disc * (x - q))
return r
else:
r = 0
for i in range(len(p)):
r += cp.minimum(p[i] * x[i],
p[i] * q[i] + p_disc[i] * (x[i] - q[i]))
return r
def test_minimum(self):
x = cvxpy.Variable(pos=True)
y = cvxpy.Variable(pos=True)
z = cvxpy.Variable(pos=True)
monomial = 5.0 * (x**0.1) * y**(-0.1) * z**(3)
posynomial = 5.0 * x * y + 1.2 * y * y
another_posynomial = posynomial * posynomial
expr = cvxpy.minimum(monomial, 1 / posynomial, 1 / another_posynomial)
self.assertTrue(expr.is_dgp())
self.assertTrue(not expr.is_log_log_convex())
self.assertTrue(expr.is_log_log_concave())
expr = (1 / posynomial) * expr
self.assertTrue(expr.is_dgp())
self.assertTrue(not expr.is_log_log_convex())
self.assertTrue(expr.is_log_log_concave())
expr = expr**2
self.assertTrue(expr.is_dgp())
self.assertTrue(not expr.is_log_log_convex())
self.assertTrue(expr.is_log_log_concave())
def opt(d, u):
x = cp.Variable(d)
# Predictions
ux = cp.multiply(d, (x @ u[:-1] + u[-1]))
if abs_act:
y = cp.sum(ux)
else:
y = cp.sum(cp.multiply((d + 1) / 2, (x @ u[:-1] + u[-1])))
# Constraints
constraints = [ux >= 0, x <= upper, x >= lower]
prob = cp.Problem(cp.Minimize(cp.minimum(y)), constraints)
t0 = time.time()
prob.solve()
print(
f'Status: {prob.status}, Value: {prob.value}, Time: {time.time()-t0}s'
)
if prob.status.lower() == 'infeasible':
return None
return x.value, y.value
def stability_lmi(self,
cA0,
cA1,
cA2,
cB,
synthesize_control=True,
epsilon=1e-9):
"""
Solve an LMI to check the stability of an interval controller
:param cA0: extended nominal matrix
:param cA1: extended state matrix uncertainty
:param cA2: extended state matrix uncertainty
:param cB: extended control matrix
:param synthesize_control: if true, the controls will be synthesized via the LMI
:param epsilon: accuracy for checking that a matrix is positive definite.
:return: whether the controlled system is stable
"""
import cvxpy as cp
np.set_printoptions(precision=2)
p = cB.shape[0] // 2
q = cB.shape[1]
# Optimisation variables
P = cp.Variable((2 * p, 2 * p), diag=True)
Q = cp.Variable((2 * p, 2 * p), diag=True)
Qp = cp.Variable((2 * p, 2 * p), diag=True)
Qn = cp.Variable((2 * p, 2 * p), diag=True)
Zp = cp.Variable((2 * p, 2 * p), diag=True)
Zn = cp.Variable((2 * p, 2 * p), diag=True)
Psi = cp.Variable((2 * p, 2 * p), diag=True)
Psi_p = cp.Variable((2 * p, 2 * p), diag=True)
Psi_n = cp.Variable((2 * p, 2 * p), diag=True)
Gamma = cp.Variable((2 * p, 2 * p), diag=True)
Omega = Q + cp.minimum(Qp, Qn) + 2 * cp.minimum(Psi_p, Psi_n)
# Constraints
if synthesize_control:
# In fact P is P^{-1}
# In fact Zp is Zp^{-1}
# In fact Zn is Zn^{-1}
U0 = cp.Variable((q, 2 * p))
U1 = cp.Variable((q, 2 * p))
U2 = cp.Variable((q, 2 * p))
Pi_11 = P * cA0.T + cA0 * P + U0.T * cB.T + cB * U0 + Q
Pi_12 = cA1 * Zp + cB * U1 + P * cA0.T + U0.T * cB.T + Psi_p
Pi_13 = cA2 * Zn + cB * U2 - P * cA0.T - U0.T * cB.T - Psi_n
Pi_22 = Zp * cA1.T + cA1 * Zp + U1.T * cB.T + cB * U1 + Qp
Pi_23 = cA2 * Zn + cB * U2 - Zp * cA1.T - U1.T * cB.T + Psi
Pi_33 = Qn - Zn * cA2.T - cA2 * Zn - U2.T * cB.T - cB * U2
Id = np.eye(2 * p)
Pi = cp.bmat([ # Block matrix
[Pi_11, Pi_12, Pi_13, Id], [Pi_12.T, Pi_22, Pi_23, Id],
[Pi_13.T, Pi_23.T, Pi_33, -Id], [Id, Id, -Id, -Gamma]
])
constraints = [
P >= epsilon, Zp >= epsilon, Zn >= epsilon, Gamma >= epsilon,
Omega >= epsilon, Pi << 0
]
else:
Ups_11 = cA0.T * P + P * cA0 + Q
Ups_12 = cA0.T * Zp + P * cA1 + Psi_p
Ups_13 = P * cA2 - cA0.T * Zn - Psi_n
Ups_22 = Zp * cA1 + cA1.T * Zp + Qp
Ups_23 = Zp * cA2 - cA1.T * Zn + Psi
Ups_33 = Qn - Zn * cA2 - cA2.T * Zn
Ups = cp.bmat([ # Block matrix
[Ups_11, Ups_12, Ups_13, P], [Ups_12.T, Ups_22, Ups_23, Zp],
[Ups_13.T, Ups_23.T, Ups_33, -Zn], [P, Zp, -Zn, -Gamma]
])
U0, U1, U2 = None, None, None
constraints = [
P >= epsilon,
P + cp.minimum(Zp, Zn) >= epsilon,
Ups << 0,
Gamma >= epsilon,
Omega >= epsilon,
]
prob = cp.Problem(cp.Minimize(0), constraints=constraints)
prob.solve(solver=cp.SCS, verbose=True)
logger.debug("Status: {}".format(prob.status))
success = prob.status == "optimal"
if success:
logger.debug("- P + min(Zp, Zn): {}".format(
np.diagonal(
P.value.todense() +
np.minimum(Zp.value.todense(), Zn.value.todense()))))
logger.debug("- Gamma: {}".format(Gamma.value))
logger.debug("- Omega: {}".format(Omega.value))
P = P.value.todense()
Zp = Zp.value.todense()
Zn = Zn.value.todense()
if synthesize_control:
P = np.linalg.inv(P)
Zp = np.linalg.inv(Zp)
Zn = np.linalg.inv(Zn)
logger.debug("- U0:".format(U0.value))
logger.debug("- U1:".format(U1.value))
logger.debug("- U2:".format(U2.value))
self.K0 = U0.value @ P
self.K1 = U1.value @ Zp
self.K2 = U2.value @ Zn
self.compute_attraction_basin(cB, Gamma.value.todense(),
Omega.value, P, Zp, Zn)
return success
def get_allocation(self, unflattened_throughputs, scale_factors,
unflattened_priority_weights, cluster_spec):
all_throughputs, index = \
self.flatten(d=unflattened_throughputs,
cluster_spec=cluster_spec,
priority_weights=unflattened_priority_weights)
if all_throughputs is None or len(all_throughputs) == 0: return None
(m, n) = all_throughputs[0].shape
(job_ids, single_job_ids, worker_types, relevant_combinations) = index
x = cp.Variable((m, n))
# Row i of scale_factors_array is the scale_factor of job
# combination i repeated len(worker_types) times.
scale_factors_array = self.scale_factors_array(scale_factors, job_ids,
m, n)
throughputs_no_packed_jobs = np.zeros((len(single_job_ids), n))
for i, single_job_id in enumerate(single_job_ids):
for j, worker_type in enumerate(worker_types):
throughputs_no_packed_jobs[i, j] = \
unflattened_throughputs[single_job_id][worker_type]
proportional_throughputs = self._proportional_policy.get_throughputs(
throughputs_no_packed_jobs, (single_job_ids, worker_types),
cluster_spec)
objective_terms = []
# Multiply throughputs by scale_factors to ensure that scale_factor
# is taken into account while allocating times to different jobs.
# A job run on 1 GPU should receive `scale_factor` more time than
# a job run on `scale_factor` GPUs.
for i in range(len(all_throughputs)):
indexes = relevant_combinations[single_job_ids[i]]
proportional_throughput = proportional_throughputs[i]
objective_terms.append(
cp.sum(
cp.multiply(
np.multiply(all_throughputs[i][indexes],
scale_factors_array[indexes]), x[indexes]))
/ proportional_throughput)
if len(objective_terms) == 1:
objective = cp.Maximize(objective_terms[0])
else:
objective = cp.Maximize(cp.minimum(*objective_terms))
# Make sure the allocation can fit in the cluster.
constraints = self.get_base_constraints(x, single_job_ids,
scale_factors_array,
relevant_combinations)
# Explicitly constrain all allocation values with an effective scale
# factor of 0 to be 0.
# NOTE: This is not strictly necessary because these allocation values
# do not affect the optimal allocation for nonzero scale factor
# combinations.
for i in range(m):
for j in range(n):
if scale_factors_array[i, j] == 0:
constraints.append(x[i, j] == 0)
cvxprob = cp.Problem(objective, constraints)
result = cvxprob.solve(solver=self._solver)
if cvxprob.status != "optimal":
print('WARNING: Allocation returned by policy not optimal!')
return self.unflatten(x.value.clip(min=0.0).clip(max=1.0), index)
def left(self):
return cvx.minimum(self.b1.x, self.b2.x)
def bottom(self):
return cvx.minimum(self.b1.y, self.b2.y)
def u(_r):
u = cp.minimum(*(y(_r) for y in ys))
return u
def train_erm_min_welfare(X, L_mat, U_mat, groups, lamb=1000):
L_X = np.matmul(X, L_mat.T)
U_X = np.matmul(X, U_mat.T)
n, d = L_X.shape
n, m = X.shape
# For each group, compute its U_X and L_X matrix
num_groups = len(groups.keys())
group_ids = groups.keys()
group_sizes = [groups[i].shape[0] for i in range(num_groups)]
group_LX, group_UX = {}, {}
for i in range(num_groups):
group_LX[i] = np.matmul(groups[i], L_mat.T)
group_UX[i] = np.matmul(groups[i], U_mat.T)
# Constructing argmax/min labels used repeatedly
y = np.argmin(L_X, axis=1)
s, b = [], []
for i in range(num_groups):
s.append(np.argmin(group_UX[i], axis=1))
b.append(np.argmax(group_UX[i], axis=1))
learned_betas = []
learned_predictions = {h: [] for h in range(num_groups)}
learned_predictions_all = []
def_alphas = get_default_alpha_arr(K)
def get_min_welf_estimate(given_Beta):
for i in range(num_groups):
# First compute the utility group i has for itself
USFii = 0
concave_p = 0
min_welf = 100
for t in range(k):
for li in range(group_sizes[i]):
USFii += def_alphas[t] * group_UX[i][
li, learned_predictions[i][t][li]]
for li in range(group_sizes[i]):
concave_version_p = np.min(group_UX[i][li, :] - np.matmul(given_Beta,groups[i][li,:])) + \
np.matmul(given_Beta[b[i][li],:],groups[i][li,:])
concave_p += def_alphas[k] * concave_version_p
USFii = USFii * (1 / group_sizes[i])
concave_p = concave_p * (1 / group_sizes[i])
min_welf = min(min_welf, USFii + concave_p)
return min_welf
# Run code to compute the mixture iteratively
for k in range(K):
Beta = cp.Variable(
(d, m)) # The parameters of the one-vs-all classifier
# Solve relaxed convexified optimization problem
loss_objective = 0
for i in range(n):
# construct list with entries L(x_i, y) + beta_y^T x_i - beta_{y_i}^T x_i; for each y and y_i defined appropriately
loss_objective += get_convex_version(X, L_X, Beta, y, i)
loss_objective = (1 / n) * loss_objective
# Our Envy-Free Objective is over groups - so iterate over them
for i in range(num_groups):
# First compute the utility group i has for itself
USFii = 0
concave_p = 0
min_welf = 100
for t in range(k):
for li in range(group_sizes[i]):
USFii += def_alphas[t] * group_UX[i][
li, learned_predictions[i][t][li]]
for li in range(group_sizes[i]):
concave_version_p = cp.min(group_UX[i][li, :] - cp.matmul(Beta,groups[i][li,:])) + \
cp.matmul(Beta[b[i][li],:],groups[i][li,:])
concave_p += def_alphas[k] * concave_version_p
USFii = USFii * (1 / group_sizes[i])
concave_p = concave_p * (1 / group_sizes[i])
min_welf = cp.minimum(min_welf, USFii + concave_p)
#objective = cp.Maximize((1/100)*((-1/10)*loss_objective + lamb*min_welf))
objective = cp.Maximize(lamb * min_welf)
prob = cp.Problem(objective)
# Solving the problem
try:
#results = prob.solve(solver=cp.SCS, verbose=False)#, feastol=1e-5, abstol=1e-5)
resuls = prob.solve(verbose=False)
except:
return 0, 0, 0, 0
Beta_value = np.array(Beta.value)
#print("beta: ", Beta_value)
learned_betas.append(Beta_value)
min_welfare_estimate = get_min_welf_estimate(Beta_value)
#print("Min welfare estimate: " , min_welfare_estimate)
all_predictions = predictions(Beta_value, X)
learned_predictions_all.append(all_predictions)
for h in range(num_groups):
learned_predictions[h].append(predictions(Beta_value, groups[h]))
# We now solve for the optimal alpha values
alphas = cp.Variable(K)
alpha_loss = 0
alpha_losses = []
min_welfares = []
for k in range(K):
alpha_loss = 0
for i in range(n):
alpha_loss += L_X[i, learned_predictions_all[k][i]]
alpha_losses.append(alpha_loss)
#print("Hello: ", alpha_losses)
for i in range(num_groups):
utls = []
total_ii_utl = 0
for li in range(group_sizes[i]):
total_ii_utl += group_UX[i][li, learned_predictions[i][k][li]]
#print("k: ", k, "i: ", i, "utl: ", total_ii_utl)
utls.append(total_ii_utl / group_sizes[i])
min_welfares.append(min(utls))
objective = cp.Maximize(-cp.sum(cp.multiply(alpha_losses, alphas))\
+ lamb*cp.sum(cp.multiply(min_welfares, alphas)))
constraints = []
for k in range(K):
constraints.append(alphas[k] >= 0)
constraints.append(cp.sum(alphas) == 1)
prob = cp.Problem(objective, constraints)
#try:
results = prob.solve(cp.SCS, verbose=False) #, feastol=1e-5, abstol=1e-5)
#except:
#return 0,0,0,0
opt_alphas = np.array(alphas.value).flatten()
#print("XIS")
#print(np.array(xis.value))
return learned_betas, learned_predictions_all, learned_predictions, opt_alphas
# w - how much AD puts in A
# x - how much BC puts in C
a = u +v +w + 100
b = x + 100 - u
c = 200 -v -x
d = 100-w
#a,b,c,d - how much budget each item gets
num_of_participants = 5
donations=[]
for i in range(num_of_participants):
donations.append(100)
utilities = [cvxpy.minimum(a,b), cvxpy.minimum(a,c), cvxpy.minimum(a,d), cvxpy.minimum(b,c), a]
# here is another example -
# a = v +w + 100
# b = x + u
# c = 200 -v -x
# d = 100-w + 100 - u
#
# num_of_participants = 5
# donations=[]
# for i in range(num_of_participants):
# donations.append(100)
# utilities = [cvxpy.minimum(b,d), cvxpy.minimum(a,c), cvxpy.minimum(a,d), cvxpy.minimum(b,c), a]
def fit(self, train_vectors, train_labels, train_features_13, test_vectors, test_labels, test_features_13, weights):
c0 = 100
c1 = 10
c2 = 10
train_labels = np.expand_dims(train_labels, axis=1)
n = len(train_vectors[0])
beta = cp.Variable((n+1, 1))
# lambd = cp.Parameter(nonneg=True)
lambd = 1
Y = train_labels
X = train_vectors
X = cp.hstack([X, np.ones((len(X),1))])
N = len(train_labels)
N0 = len(train_labels[train_features_13 == 0])
N1 = len(train_labels[train_features_13 == 1])
x0 = X[train_features_13 == 0]
y0 = Y[train_features_13 == 0]
x1 = X[train_features_13 == 1]
y1 = Y[train_features_13 == 1]
# log_likelihood = cp.sum(
# (-cp.reshape(cp.multiply(Y, X @ beta), (len(Y),)) +
# cp.log_sum_exp(cp.hstack([np.zeros((len(Y), 1)), X @ beta]), axis=1))) + \
# lambd * cp.norm(beta[0:-1], 2)
# log_likelihood = cp.sum(
# (cp.multiply(-cp.reshape(cp.multiply(Y, X @ beta), (len(Y),)) +
# cp.log_sum_exp(cp.hstack([np.zeros((len(Y), 1)), X @ beta]), axis=1), weights))) + \
# lambd * cp.norm(beta[0:-1], 2)
log_likelihood = cp.sum(cp.multiply(cp.reshape(cp.logistic(cp.multiply(-Y, X@beta)), (len(Y),)), weights))\
+ lambd * cp.norm(beta[0:-1], 2)
# print(np.shape(np.zeros((len(y0), 1))))
problem = cp.Problem(cp.Minimize(log_likelihood),
[
# (N1 / float(N)) * cp.sum(cp.minimum(
# np.zeros((len(y0), 1)), cp.multiply(y0, (x0 @ beta)))) \
# >= (N0 / float(N)) * cp.sum(cp.minimum(
# np.zeros((len(y1), 1)), cp.multiply(y1, (x1 @ beta))))-c0,
#
# (N1 / float(N)) * cp.sum(cp.minimum(
# np.zeros((len(y0), 1)), cp.multiply(y0, (x0 @ beta)))) \
# <= (N0 / float(N)) * cp.sum(cp.minimum(
# np.zeros((len(y1), 1)), cp.multiply(y1, (x1 @ beta)))) + c0,
#
#
#
# (N1 / float(N)) * cp.sum(cp.minimum(
# np.zeros((len(y0), 1)), cp.multiply((1-y0)/2*y0, (x0 @ beta)))) \
# >= (N0 / float(N)) * cp.sum(cp.minimum(
# np.zeros((len(y1), 1)), cp.multiply((1-y1)/2*y1, (x1 @ beta)))) - c1,
#
# (N1 / float(N)) * cp.sum(cp.minimum(
# np.zeros((len(y0), 1)), cp.multiply((1-y0)/2*y0, (x0 @ beta)))) \
# <= (N0 / float(N)) * cp.sum(cp.minimum(
# np.zeros((len(y1), 1)), cp.multiply((1-y1)/2*y1, (x1 @ beta)))) + c1,
#
#
#
# (N1 / float(N)) * cp.sum(cp.minimum(
# np.zeros((len(y0), 1)), cp.multiply((1 + y0) / 2 * y0, (x0 @ beta)))) \
# >= (N0 / float(N)) * cp.sum(cp.minimum(
# np.zeros((len(y1), 1)), cp.multiply((1 + y1) / 2 * y1, (x1 @ beta)))) - c2,
#
# (N1 / float(N)) * cp.sum(cp.minimum(
# np.zeros((len(y0), 1)), cp.multiply((1 + y0) / 2 * y0, (x0 @ beta)))) \
# <= (N0 / float(N)) * cp.sum(cp.minimum(
# np.zeros((len(y1), 1)), cp.multiply((1 + y1) / 2 * y1, (x1 @ beta)))) + c2
(N1 / float(N)) * cp.sum(cp.minimum(
0, cp.multiply(y0, (x0 @ beta)))) \
>= (N0 / float(N)) * cp.sum(cp.minimum(
0, cp.multiply(y1, (x1 @ beta))))-c0,
(N1 / float(N)) * cp.sum(cp.minimum(
0, cp.multiply(y0, (x0 @ beta)))) \
<= (N0 / float(N)) * cp.sum(cp.minimum(
0, cp.multiply(y1, (x1 @ beta)))) + c0,
(N1 / float(N)) * cp.sum(cp.minimum(
0, cp.multiply((1-y0)/2.0, cp.multiply(y0, x0 @ beta)))) \
>= (N0 / float(N)) * cp.sum(cp.minimum(
0, cp.multiply((1-y1)/2.0, cp.multiply(y1, x1 @ beta)))) - c1,
(N1 / float(N)) * cp.sum(cp.minimum(
0, cp.multiply((1-y0)/2.0, cp.multiply(y0, x0 @ beta)))) \
<= (N0 / float(N)) * cp.sum(cp.minimum(
0, cp.multiply((1-y1)/2.0,cp.multiply(y1, x1 @ beta)))) + c1,
(N1 / float(N)) * cp.sum(cp.minimum(
0, cp.multiply((1 + y0) / 2.0, cp.multiply( y0, x0 @ beta)))) \
>= (N0 / float(N)) * cp.sum(cp.minimum(
0, cp.multiply((1 + y1) / 2.0 , cp.multiply(y1, x1 @ beta)))) - c2,
(N1 / float(N)) * cp.sum(cp.minimum(
0, cp.multiply((1 + y0) / 2.0,cp.multiply( y0, x0 @ beta)))) \
<= (N0 / float(N)) * cp.sum(cp.minimum(
0, cp.multiply((1 + y1) / 2.0 ,cp.multiply( y1, x1 @ beta)))) + c2
])
problem.solve(method='dccp')
print(beta.value)
self.beta = beta.value
loss = self.predict(test_vectors, test_labels, test_features_13)
print(loss)
return loss
P_ad = np.random.uniform(size=(m, 1))
P_time = np.random.uniform(size=(1, n))
P = P_ad.dot(P_time)
T = np.sin(np.linspace(-2 * np.pi / 2, 2 * np.pi - 2 * np.pi / 2, n)) * SCALE
T += -np.min(T) + SCALE
c = np.random.uniform(size=(m,))
c *= 0.6 * T.sum() / c.sum()
c = 1000 * np.round(c / 1000)
R = np.array([np.random.lognormal(c.min() / c[i]) for i in range(m)])
# Form and solve the optimal advertising problem.
import cvxpy as cp
D = cp.Variable((m, n))
Si = [cp.minimum(R[i] * P[i, :] * D[i, :].T, B[i]) for i in range(m)]
prob = cp.Problem(cp.Maximize(cp.sum(Si)),
[D >= 0,
D.T @ np.ones(m) <= T,
D @ np.ones(n) >= c])
prob.solve()
# Plot traffic.
import matplotlib.pyplot as plt
# %matplotlib inline
# %config InlineBackend.figure_format = 'svg'
plt.plot(T)
plt.xlabel('Hour')
plt.ylabel("Traffic")
plt.show()
import numpy as np
import cvxpy as cp
from data.opt_funding_data import n, T, rp, rn, E, C, P, M, A
np.set_printoptions(precision=6, suppress=True)
x = cp.Variable(n)
E = [0] + list(E)
I = [0] + list(A @ x)
B = [None] * (T + 1)
B[0] = cp.Variable()
for t in range(T + 1):
before = B[t] - E[t] + I[t]
B[t + 1] = cp.minimum((1 + rp) * before, (1 + rn) * before)
#B = cp.hstack(B)
constraints = [
B[-1] + I[-1] - E[-1] >= 0,
B[0] >= 0,
x >= 0,
]
obj = cp.Minimize(x @ P + B[0])
problem = cp.Problem(obj, constraints)
problem.solve()
print(problem.value)
def u(r):
u = cp.minimum(beta0 * r + intercept1, r, beta2 * r,
beta3 * r + intercept)
return u
def _to_cvxpy(self):
import cvxpy as cvx
return cvx.minimum(self.f1._to_cvxpy(), self.f2._to_cvxpy())
def get_constraint_list_cov(x_train, y_train, x_control_train, sensitive_attrs_to_cov_thresh, cons_type, w):
"""
get the list of constraints to be fed to the minimizer
cons_type == 0: means the whole combined misclassification constraint (without FNR or FPR)
cons_type == 1: FPR constraint
cons_type == 2: FNR constraint
cons_type == 4: both FPR as well as FNR constraints
sensitive_attrs_to_cov_thresh: is a dict like {s: {cov_type: val}}
s is the sensitive attr
cov_type is the covariance type. contains the covariance for all misclassifications, FPR and for FNR etc
"""
constraints = []
for attr in sensitive_attrs_to_cov_thresh.keys():
attr_arr = x_control_train[attr]
attr_arr_transformed, index_dict = ut.get_one_hot_encoding(attr_arr)
if index_dict is None: # binary attribute, in this case, the attr_arr_transformed is the same as the attr_arr
s_val_to_total = {ct:{} for ct in [0,1,2]} # constrain type -> sens_attr_val -> total number
s_val_to_avg = {ct:{} for ct in [0,1,2]}
cons_sum_dict = {ct:{} for ct in [0,1,2]} # sum of entities (females and males) in constraints are stored here
for v in set(attr_arr):
s_val_to_total[0][v] = sum(x_control_train[attr] == v)
s_val_to_total[1][v] = sum(np.logical_and(x_control_train[attr] == v, y_train == -1)) # FPR constraint so we only consider the ground truth negative dataset for computing the covariance
s_val_to_total[2][v] = sum(np.logical_and(x_control_train[attr] == v, y_train == +1))
for ct in [0,1,2]:
s_val_to_avg[ct][0] = s_val_to_total[ct][1] / float(s_val_to_total[ct][0] + s_val_to_total[ct][1]) # N1/N in our formulation, differs from one constraint type to another
s_val_to_avg[ct][1] = 1.0 - s_val_to_avg[ct][0] # N0/N
for v in set(attr_arr):
idx = x_control_train[attr] == v
#################################################################
# #DCCP constraints
dist_bound_prod = cvxpy.multiply(y_train[idx], x_train[idx] @ w) # y.f(x)
cons_sum_dict[0][v] = cvxpy.sum( cvxpy.minimum(0, dist_bound_prod) ) * (s_val_to_avg[0][v] / len(x_train)) # avg misclassification distance from boundary
cons_sum_dict[1][v] = cvxpy.sum( cvxpy.minimum(0, cvxpy.multiply( (1 - y_train[idx])/2.0, dist_bound_prod) ) ) * (s_val_to_avg[1][v] / sum(y_train == -1)) # avg false positive distance from boundary (only operates on the ground truth neg dataset)
cons_sum_dict[2][v] = cvxpy.sum( cvxpy.minimum(0, cvxpy.multiply( (1 + y_train[idx])/2.0, dist_bound_prod) ) ) * (s_val_to_avg[2][v] / sum(y_train == +1)) # avg false negative distance from boundary
#################################################################
if cons_type == 4:
cts = [1,2]
elif cons_type in [0,1,2]:
cts = [cons_type]
else:
raise Exception("Invalid constraint type")
#################################################################
#DCCP constraints
for ct in cts:
thresh = abs(sensitive_attrs_to_cov_thresh[attr][ct][1] - sensitive_attrs_to_cov_thresh[attr][ct][0])
constraints.append( cons_sum_dict[ct][1] <= cons_sum_dict[ct][0] + thresh )
constraints.append( cons_sum_dict[ct][1] >= cons_sum_dict[ct][0] - thresh )
#################################################################
else: # otherwise, its a categorical attribute, so we need to set the cov thresh for each value separately
# need to fill up this part
raise Exception("Fill the constraint code for categorical sensitive features... Exiting...")
sys.exit(1)
return constraints
# x - how much BC puts in C
a = u + v + w + 100
b = x + 100 - u
c = 200 - v - x
d = 100 - w
#a,b,c,d - how much budget each item gets
num_of_participants = 5
donations = []
for i in range(num_of_participants):
donations.append(100)
utilities = [
cvxpy.minimum(a, b),
cvxpy.minimum(a, c),
cvxpy.minimum(a, d),
cvxpy.minimum(b, c), a
]
# here is another example -
# a = v +w + 100
# b = x + u
# c = 200 -v -x
# d = 100-w + 100 - u
#
# num_of_participants = 5
# donations=[]
# for i in range(num_of_participants):
# donations.append(100)
def _init_edge_deps(self):
self.delays = defaultdict(lambda: cvxpy.Variable(integer=True))
self.delay_violations = []
for edge in self.edges:
src_node = self.id_to_node_lookup[edge.src]
dst_node = self.id_to_node_lookup[edge.dst]
# if they're not in the same partition, then guarantee inequality.
enforce_inequality: int
if not self._possible_in_same_partition(src_node, dst_node):
enforce_inequality = 1
else:
dst_candidates = self._candidate_partitions(dst_node)
inequalities = []
for partition_type in self._candidate_partitions(src_node):
src_row = self._get_row(partition_type, src_node)
if partition_type not in dst_candidates:
inequalities.append(cvxpy.sum(src_row))
continue
dst_row = self._get_row(partition_type, dst_node)
inequalities.append(
cvxpy.sum(cvxpy.maximum(src_row - dst_row, 0)))
enforce_inequality = cvxpy.maximum(*inequalities,
0) if inequalities else 0
self.delay_violations.append(
self._project_to_bool(
cvxpy.maximum(
self.delays[src_node] + enforce_inequality -
self.delays[dst_node], 0), self.num_nodes * 2))
# for each node, compute its partition delay. Then constrain that the partition delay and actual delay are
# close.
partition_delays = {
partition_type: cvxpy.Variable(shape=count, nonneg=True)
for partition_type, count in self.partition_counts.items()
}
max_delay = 4 * sum(self.partition_counts.values())
for partition_delay in partition_delays.values():
self._add_constraint(partition_delay <= max_delay)
for node in self.nodes:
target_delay_min = [max_delay]
target_delay_max = [0]
for partition_type, node_to_loc in self.node_to_loc_map.items():
if node not in node_to_loc:
continue
loc = node_to_loc[node]
row = self.partition_matrices[partition_type][loc, :]
activation = row * -max_delay + max_delay
target_delay_min.append(
cvxpy.min(partition_delays[partition_type] + activation))
activation = row * max_delay - max_delay
target_delay_max.append(
cvxpy.max(partition_delays[partition_type] + activation))
target_min = cvxpy.minimum(*target_delay_min)
self._add_pseudo_constraint(
cvxpy.maximum(self.delays[node] - target_min, 0))
target_max = cvxpy.maximum(*target_delay_max)
self._add_pseudo_constraint(
cvxpy.maximum(target_max - self.delays[node], 0))
def test_minimum_sign(self):
# Two args.
self.assertEqual(cp.minimum(1, 2).sign, s.NONNEG)
self.assertEqual(cp.minimum(1, Variable()).sign, s.UNKNOWN)
self.assertEqual(cp.minimum(1, -2).sign, s.NONPOS)
self.assertEqual(cp.minimum(1, 0).sign, s.ZERO)
self.assertEqual(cp.minimum(Variable(), 0).sign, s.NONPOS)
self.assertEqual(cp.minimum(Variable(), Variable()).sign, s.UNKNOWN)
self.assertEqual(cp.minimum(Variable(), -2).sign, s.NONPOS)
self.assertEqual(cp.minimum(0, 0).sign, s.ZERO)
self.assertEqual(cp.minimum(0, -2).sign, s.NONPOS)
self.assertEqual(cp.minimum(-3, -2).sign, s.NONPOS)
# Many args.
self.assertEqual(
cp.minimum(-2, Variable(), 0, -1, Variable(), 1).sign, s.NONPOS)
# Promotion.
self.assertEqual(cp.minimum(-1, Variable(2)).sign, s.NONPOS)
self.assertEqual(cp.minimum(-1, Variable(2)).shape, (2, ))
def integer_opt(number_of_pet, number_of_pcs, pet_power_demand, block_cdq,
pet_state, pet_lat, pet_lon, number_of_region, pet_region,
pet_soc, pet_pick_up_probability, block_plq, plq_arrival_rate,
delay_aware_arrival_rate, block_delay_aware,
pet_remaining_power, V, per_service_fee, pev_arrival_rate,
cdq_service_rate, pcs_cost, max_soc, acceptance):
# Variable.
y = cv.Variable((number_of_pcs, number_of_pet), boolean=True)
x = cv.multiply(acceptance, y)
# Objective function
# Section: cdq
cdq_arrival_rate = cv.sum(cv.multiply(pet_power_demand, x),
axis=1,
keepdims=True) + pev_arrival_rate
section_cdq_1 = cdq_arrival_rate - cdq_service_rate
section_cdq = cv.sum(cv.multiply(section_cdq_1, block_cdq))
# section_plq
# pick up constraint
pet = pd.DataFrame(pet_state, columns=['state'])
pet['soc'] = pet_soc
pet['state'] = pet_state
pet['pick_up_probability'] = pet_pick_up_probability
# pet_pick_up_ini = pet.apply(lambda x: np.random.choice([0, 1], p=[
# 1-x['pick_up_probability'], x['pick_up_probability']]) if ((x['state'] == 0) & (x['soc'] > 1.5)) else 0, axis=1).values.reshape(1, number_of_pet)
pet_region_matrix = np.zeros((number_of_region, number_of_pet))
for i in range(number_of_pet):
for j in range(number_of_region):
if pet_region[i] == j:
pet_region_matrix[j, i] = 1
pass
pass
pass
pet_recommended = cv.sum(x, axis=0, keepdims=True)
pet_non_recommended = (np.ones((1, number_of_pet)) - pet_recommended)
pet_available_ini = np.where(((pet['state'] == 0) & (pet['soc'] > 0.15)),
1, 0).reshape(1, number_of_pet)
pet_available = cv.multiply(pet_available_ini, pet_non_recommended)
# pet_pick_up = cv.multiply(pet_non_recommended, pet_pick_up_ini)
pet_available_region = pet_region_matrix @ pet_available.T
pet_pick_up_region = cv.minimum(pet_available_region, block_plq)
section_plq_2 = plq_arrival_rate - pet_pick_up_region
section_plq = cv.sum(cv.multiply(block_plq, section_plq_2))
# Section: Delay aware
section_delay_aware = cv.sum(
cv.multiply(block_delay_aware,
(delay_aware_arrival_rate - pet_pick_up_region)))
# section: profit
section_profit = cv.sum(
cv.multiply(cdq_arrival_rate, per_service_fee) - pcs_cost)
# objects = - V * section_profit
# objects = section_cdq - V * section_profit
objects = (section_plq + section_delay_aware +
section_cdq) - V * section_profit
constraints_2_right = np.full((number_of_pet, 1), 1)
state_test = np.where((pet_state == 0), 1, 0)
# SOC
constraints_4_right = np.full((number_of_pcs, number_of_pet), 0)
soc_test = np.where((pet_remaining_power < 0), 1, 0)
# rem * x ==0
# column sum
constraints_5_right = np.full((1, number_of_pet), 1)
constraints_6_right = np.full((number_of_pet, 1), 1)
constraints_7_right = np.full((number_of_pet, 1), 1)
soc_range_test = np.where((pet_soc > 0.1), 1, 0)
soc_state_test = np.where((pet_state == 2), 1, 0)
soc_1 = np.where((pet_soc > max_soc), 1, 0)
constraints = [
state_test + pet_non_recommended.T >= constraints_2_right,
cv.multiply(soc_test, x) == constraints_4_right,
pet_recommended <= constraints_5_right,
soc_1 + pet_recommended.T <= constraints_6_right,
soc_range_test + soc_state_test + pet_recommended.T >=
constraints_7_right
]
# constraints = [cv.multiply(soc_test, x) == constraints_4_right]
problem = cv.Problem(cv.Minimize(objects), constraints)
problem.solve(solver=cv.CPLEX)
return x.value, pet_pick_up_region.value
