def test_list_input(self) -> None:
"""Test that list input is rejected.
"""
with self.assertRaises(Exception) as cm:
cp.max([cp.Variable(), 1])
self.assertTrue(
str(cm.exception) in
("The input must be a single CVXPY Expression, not a list. "
"Combine Expressions using atoms such as bmat, hstack, and vstack."
))
with self.assertRaises(Exception) as cm:
cp.norm([1, cp.Variable()])
self.assertTrue(
str(cm.exception) in
("The input must be a single CVXPY Expression, not a list. "
"Combine Expressions using atoms such as bmat, hstack, and vstack."
))
x = cp.Variable()
y = cp.Variable()
with self.assertRaises(Exception) as cm:
cp.norm([x, y]) <= 1
self.assertTrue(
str(cm.exception) in
("The input must be a single CVXPY Expression, not a list. "
"Combine Expressions using atoms such as bmat, hstack, and vstack."
))
def max_min_dccp(n_samples, var_importance):
"""Solve MaxMin Diversity problem on hypercube
:nsamples : number of samples
:var_importance: list of floats, specifying importance of each variable
"""
radii = np.ones(n_samples) # radii
v_scale = cvx.vec(var_importance)
c = cvx.Variable((n_samples, len(var_importance)))
constr = []
for i in range(n_samples - 1):
for j in range(i + 1, n_samples):
# distance vector is scaled by variable importance
d = cvx.multiply(cvx.vec(c[i, :] - c[j, :]), v_scale)
constr.append(cvx.norm(d, 2) >= radii[i] + radii[j])
# minimize the size of the square to fit the given spheres
# (by minimzing the largest component of any center vector)
prob = cvx.Problem(
cvx.Minimize(cvx.max(cvx.max(cvx.abs(c), axis=1) + radii)), constr)
prob.solve(method='dccp', solver='ECOS', ep=1e-2, max_slack=1e-2)
l = cvx.max(cvx.max(cvx.abs(c), axis=1) + radii).value * 2
pi = np.pi
ratio = pi * cvx.sum(cvx.square(radii)).value / cvx.square(l).value
print("ratio =", ratio)
# shift to positive numbers
coords = c.value - np.min(c.value)
# scale maximum coordinate to 1
coords /= np.max(coords)
return coords
def one_shot_compressed_sensing_decode(x0, y, p_matrix, delta):
_size = y.shape[0]
_app = p_matrix.shape[0]
use = []
use.append(x0)
X = cvx.Variable((_app))
#print(k)
objective = cvx.Minimize(cvx.norm(X, 1))
#if abs(k)>p_matrix[-1]:
# constraints = [(X.T*p_matrix-k)<=delta, (X.T*p_matrix-k)>=-delta]
#else:
#constraints = [(X.T*p_matrix-k)<=delta, (X.T*p_matrix-k)>=-delta,cvx.max(X)<=1,cvx.min(X)>=-1]
constraints = [(X.T * p_matrix - k) <= delta,
(X.T * p_matrix - k) >= -delta,
cvx.max(X) <= 1,
cvx.min(X) >= -1]
prob = cvx.Problem(objective, constraints)
prob.solve(solver=cvx.ECOS_BB)
if X.value is None:
X = cvx.Variable((_app))
#constraints = [(X.T*p_matrix-k)<=20, (X.T*p_matrix-k)>=-20,cvx.max(X)<=1,cvx.min(X)>=-1]
#constraints = [(X.T*p_matrix-k)<=20, (X.T*p_matrix-k)>=-20]
constraints = [cvx.max(X) <= 1, cvx.min(X) >= -1]
prob = cvx.Problem(objective, constraints)
prob.solve(solver=cvx.ECOS_BB)
if X.value is None:
return []
print(X.value)
return np.abs(x0 - X.value)
def e19_controlled_load(self, verbose=False):
"""Implements the charging control for the PG&E E19 rate schedule. This is not specific to EVs but has been how
sites like Google campus traditionally are charged for their loads. It includes TOU and demand charges.
Please refer to the first control method, `sdge_controlled_load', for comments on the
optimization set up and constraints which are common between the two.
"""
peak_inds, partpeak_inds, offpeak_inds, energy_prices, rate_demand_peak, rate_demand_partpeak, rate_demand_overall = e19_values(
)
schedule = cvx.Variable((96, self.num_sessions))
obj = cvx.matmul(cvx.sum(schedule, axis=1),
energy_prices.reshape(
(np.shape(energy_prices)[0], 1))) # TOU
obj += rate_demand_overall * cvx.max(cvx.sum(
schedule, axis=1)) # Demand charge on the whole day
obj += rate_demand_peak * cvx.max(
cvx.sum(schedule[peak_inds, :],
axis=1)) # Peak period demand charge
obj += rate_demand_partpeak * cvx.max(
cvx.sum(schedule[partpeak_inds, :],
axis=1)) # Shoulder period demand charge
constraints = [schedule >= 0]
for i in range(self.num_sessions):
constraints += [
schedule[:, i] <= np.maximum(np.max(self.power[:, i]),
self.charge_rate)
]
if self.departure_inds[i] >= self.arrival_inds[i]:
if self.arrival_inds[i] > 0:
constraints += [
schedule[np.arange(0, int(self.arrival_inds[i])), i] <=
0
]
if self.departure_inds[i] < 96:
constraints += [
schedule[np.arange(int(self.departure_inds[i]), 96), i]
<= 0
]
else:
constraints += [
schedule[np.arange(int(self.departure_inds[i]
), int(self.arrival_inds[i])), i] <=
0
]
constraints += [0.25 * cvx.sum(schedule, axis=0) == self.energies]
prob = cvx.Problem(cvx.Minimize(obj), constraints)
result = prob.solve(solver=cvx.MOSEK)
# Not likely necessary since there is no cap constraint, but this was implemented just in case this method
# throws an error:
if verbose:
print('The objective result: ', result)
if schedule.value is None:
print('Optimization failed')
else:
self.e19_controlled_power = schedule.value
self.controlled_total_load = np.sum(schedule.value, axis=1)
def controlled_load(self, num_sessions, charge_rate, arrival_inds,
departure_inds, power, energies, energy_prices,
rate_demand_peak, rate_demand_partpeak,
rate_demand_overall, peak_inds, partpeak_inds):
"""
Predict controlled load
"""
schedule = cvx.Variable((96, num_sessions))
obj = cvx.matmul(
cvx.sum(schedule, axis=1),
energy_prices.reshape((np.shape(energy_prices)[0], 1)))
obj += rate_demand_overall * cvx.max(cvx.sum(schedule, axis=1))
obj += rate_demand_overall * cvx.max(cvx.sum(schedule, axis=1))
obj += rate_demand_peak * cvx.max(
cvx.sum(schedule[peak_inds, :], axis=1))
obj += rate_demand_partpeak * cvx.max(
cvx.sum(schedule[partpeak_inds, :], axis=1))
constraints = [schedule >= 0]
for i in range(num_sessions):
constraints += [
schedule[:, i] <= np.maximum(np.max(power[:, i]), charge_rate)
]
if departure_inds[i] >= arrival_inds[i]:
if arrival_inds[i] > 0:
constraints += [
schedule[np.arange(0, int(arrival_inds[i])), i] <= 0
]
if departure_inds[i] < 96:
constraints += [
schedule[np.arange(int(departure_inds[i]), 96), i] <= 0
]
else:
constraints += [
schedule[np.arange(int(departure_inds[i]
), int(arrival_inds[i])), i] <= 0
]
energies = 0.25 * np.sum(power, axis=0)
max_energies = np.zeros((num_sessions, ))
for i in range(num_sessions):
if departure_inds[i] >= arrival_inds[i]:
max_energies[i] = 0.25 * charge_rate * (departure_inds[i] -
arrival_inds[i])
else:
max_energies[i] = 0.25 * charge_rate * ((departure_inds[i]) +
(96 - arrival_inds[i]))
where_violation = np.where((max_energies - energies) < 0)[0]
energies[where_violation] = max_energies[where_violation]
constraints += [0.25 * cvx.sum(schedule, axis=0) == energies]
prob = cvx.Problem(cvx.Minimize(obj), constraints)
result = prob.solve(solver=cvx.MOSEK)
return schedule.value, power, len(where_violation)
def test_non_quadratic(self) -> None:
x = Variable()
y = Variable()
z = Variable()
s = cp.max(vstack([x, y, z]))**2
self.assertFalse(s.is_quadratic())
t = cp.max(vstack([x**2, power(y, 2), z]))
self.assertFalse(t.is_quadratic())
def cost(self):
power = -self.terminals[0].power_var
T, S = self.terminals[0].power_var.shape
# if self.energy is None:
# self.energy = cvx.Variable(self.terminals[0].power_var.shape)
cost = cvx.sum(0.25 * power * np.reshape(self.rate_e, (1, 96)))
cost += cvx.max(power[self.rate_d['max_demand_ind']
[0]]) * self.rate_d['max_demand']
cost += cvx.max(power[self.rate_d['max_peak_demand_ind']
[0]]) * self.rate_d['max_peak_demand']
cost += cvx.max(power[self.rate_d['max_part_peak_demand_ind']
[0]]) * self.rate_d['max_part_peak_demand']
cost = cvx.reshape(cost, (1, S))
return cost
def as_objective(self, **kwargs):
""" minimize the x and y domain projections
todo I am STUCK HERE
"""
centroids = np.asarray(self.space.faces.centroids)
n = self._area
mx = cvx.multiply(centroids[:, 0], self.stacked)
my = cvx.multiply(centroids[:, 1], self.stacked)
# my = cvx.multiply(centroids[:, 1], self.stacked)
u = Variable(shape=n)
ex = cvx.max(mx - cvx.sum(mx) / n)
ey = cvx.max(my - cvx.sum(my) / n)
return Minimize(ex + ey)
def __init__(self, K, J, **kwargs):
super().__init__(K, J, **kwargs)
self.F = cvx.Variable((self.K, self.J), nonneg=True)
self.Fk = cvx.Parameter((self.K, self.J), nonneg=True)
self.Pk = cvx.Parameter((self.K, self.J), nonneg=True)
self.Pmax = cvx.Parameter(nonneg=True)
self.N = cvx.Parameter(nonneg=True)
self.df = cvx.Parameter(nonneg=True)
self.rho = cvx.Parameter((self.K, self.J), nonneg=True)
self.lam = cvx.Parameter(nonneg=True)
self.obj = 0
for k in range(self.K):
num = 0
for j in range(self.J):
num += self.rho[k, j] * self.Pk[k, j] * self.F[k, j]
self.obj += cvx.log(1 + num) - (cvx.max(self.rho[k, :]) -
cvx.min(self.rho[k, :])) / 2
constraints = [ #cvx.norm(self.F - self.Fk, 1) <= self.delta,
cvx.sum(self.F, axis=0) <= self.N,
cvx.sum(self.F, axis=0) >= 1,
cvx.sum(self.F, axis=1) <= self.df, self.F <= 1
]
for j in range(self.J):
for k in range(self.K):
self.obj += self.lam * ((self.Fk[k, j]**2 - self.Fk[k, j]) +
(2 * self.Fk[k, j] - 1) *
(self.F[k, j] - self.Fk[k, j]))
constraints.append(self.Pk[:, j] * self.F[:, j] <= self.Pmax)
constraints.append(self.Pk[:, j] * self.F[:, j] >= 0)
self.prob = cvx.Problem(cvx.Maximize(self.obj), constraints)
def __init__(self, m, n, r, eps=1e-4):
cvxopt.glpk.options["msg_lev"] = "GLP_MSG_OFF"
self.m = m
self.n = n
self.r = r
self.eps = eps
self.last_move = None
self.a = cp.Parameter(m) # Adjustments
self.C = cp.Parameter((m, m)) # C: Gradient inner products, G^T G
self.Ca = cp.Parameter(m) # d_bal^TG
self.rhs = cp.Parameter(m) # RHS of constraints for balancing
self.alpha = cp.Variable(m) # Variable to optimize
obj_bal = cp.Maximize(self.alpha @ self.Ca) # objective for balance
constraints_bal = [self.alpha >= 0, cp.sum(self.alpha) == 1, # Simplex
self.C @ self.alpha >= self.rhs]
self.prob_bal = cp.Problem(obj_bal, constraints_bal) # LP balance
obj_dom = cp.Maximize(cp.sum(self.alpha @ self.C)) # obj for descent
constraints_res = [self.alpha >= 0, cp.sum(self.alpha) == 1, # Restrict
self.alpha @ self.Ca >= -cp.neg(cp.max(self.Ca)),
self.C @ self.alpha >= 0]
constraints_rel = [self.alpha >= 0, cp.sum(self.alpha) == 1, # Relaxed
self.C @ self.alpha >= 0]
self.prob_dom = cp.Problem(obj_dom, constraints_res) # LP dominance
self.prob_rel = cp.Problem(obj_dom, constraints_rel) # LP dominance
self.gamma = 0 # Stores the latest Optimum value of the LP problem
self.mu_rl = 0 # Stores the latest non-uniformity
def objective(self, **kwargs):
# minimze max(T_k ) if k is a source
# T_k = 0 if k is a sink
# T_k >= max( norm(x_j - x_k) + T_j | s.t. E arc from k to j )
# ->
# T_k >=
return Minimize(cvx.max())
def fit(self, x, y):
# Detect the number of samples and classes
nsamples = x.shape[0]
ncols = x.shape[1]
classes, cnt = np.unique(y, return_counts=True)
nclasses = len(classes)
# Convert classes to a categorical format
yc = keras.utils.to_categorical(y, num_classes=nclasses)
# Build a disciplined convex programming model
w = cp.Variable(shape=(ncols, nclasses))
constraints = []
# Additional variables representing the actual predictions.
log_reg = x @ w
Z = [cp.log_sum_exp(log_reg[i]) for i in range(nsamples)]
log_likelihood = cp.sum(
cp.sum([cp.multiply(yc[:, c], log_reg[:, c]) for c in range(nclasses)])) - cp.sum(Z)
reg = cp.max(cp.sum(log_reg), axis=0)
# Start the training process
obj_func = - log_likelihood / nsamples + self.alpha * reg
problem = cp.Problem(cp.Minimize(obj_func), constraints)
problem.solve()
self.weights = w.value
def nullspace(A, atol=1e-13, rtol=0):
A = np.atleast_2d(A)
u, s, vh = svd(A)
tol = max(atol, rtol * s[0])
nnz = (s >= tol).sum()
ns = vh[nnz:].conj().T
return ns
def one_shot_compressed_sensing_decode(x0,y,p_matrix,delta):
_app = p_matrix.shape[0]
#print(_app)
X = cvx.Variable((_app))
#print(k)
objective = cvx.Minimize(cvx.norm(X,1))
#print(y)
#if abs(k)>p_matrix[-1]:
# constraints = [(X.T*p_matrix-k)<=delta, (X.T*p_matrix-k)>=-delta]
#else:
#constraints = [(X.T*p_matrix-k)<=delta, (X.T*p_matrix-k)>=-delta,cvx.max(X)<=1,cvx.min(X)>=-1]
constraints = [(X.T*p_matrix-y)<=delta, (X.T*p_matrix-y)>=-delta,cvx.max(X)<=1,cvx.min(X)>=0]
prob = cvx.Problem(objective, constraints)
prob.solve(solver=cvx.ECOS_BB)
if X.value is None:
#print("error")
#print(x0.shape[0])
return x0.shape[0]
'''
X = cvx.Variable((_app))
#constraints = [(X.T*p_matrix-k)<=20, (X.T*p_matrix-k)>=-20,cvx.max(X)<=1,cvx.min(X)>=-1]
#constraints = [(X.T*p_matrix-k)<=20, (X.T*p_matrix-k)>=-20]
constraints = [cvx.max(X)<=1,cvx.min(X)>=-1]
prob = cvx.Problem(objective, constraints)
prob.solve(solver=cvx.ECOS_BB)
if X.value is None:
return []
'''
#print(X.value)
return np.sum(np.abs(x0-X.value))
def test_max(self) -> None:
x = cp.Variable(2, pos=True)
obj = cp.max((1 - 2 * cp.sqrt(x) + x) / x)
problem = cp.Problem(cp.Minimize(obj), [x[0] <= 0.5, x[1] <= 0.9])
self.assertTrue(problem.is_dqcp())
problem.solve(SOLVER, qcp=True)
self.assertAlmostEqual(problem.objective.value, 0.1715, places=3)
def get_diverse_teams_lineup(df, budget, pt_lim, teams):
N = len(df)
W = cp.Variable((N, 1), boolean=True)
constrs = [cp.matmul(W.T, df['cost'].values.reshape(N, 1))<=budget,
cp.matmul(W.T, df['proj'].values.reshape(N, 1))<=pt_lim,
cp.sum(W)==9,
cp.matmul(W.T, df['QB'].values.reshape(N, 1))==1,
cp.matmul(W.T, df['RB'].values.reshape(N, 1))<=3,
cp.matmul(W.T, df['WR'].values.reshape(N, 1))<=3,
cp.matmul(W.T, df['TE'].values.reshape(N, 1))<=2,
cp.matmul(W.T, df['TE'].values.reshape(N, 1))>=1,
cp.matmul(W.T, df['K'].values.reshape(N, 1))==1,
cp.matmul(W.T, df['DST'].values.reshape(N, 1))==1,
cp.max(cp.matmul(W.T, df.iloc[:, 10:-1]))<=1]
obj = cp.Maximize(cp.matmul(W.T, df['proj'].values.reshape(N, 1)))
prob = cp.Problem(obj, constrs)
prob.solve()
W.value = W.value.round()
idx = []
for i, w in enumerate(W.value):
if w == 1:
idx.append(i)
proj_pts = df.iloc[idx]['proj'].sum()
lineup = df.iloc[idx]['player team pos proj cost'.split()]
pos_map = {'QB': 1, 'RB': 2, 'WR': 3, 'TE': 4, 'K': 5, 'DST': 6}
pos_num = [pos_map[pos] for pos in lineup['pos'].values]
lineup['pos_num'] = pos_num
lineup = lineup.sort_values('pos_num')
lineup.drop('pos_num', axis=1, inplace=True)
lineup = lineup.append(lineup.sum(numeric_only=True), ignore_index=True)
return lineup, proj_pts
def test_max(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.max(cp.hstack([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 hinf_constraint(coefs, gamma, l1_trans=False):
# constrain the H_inf norm of the response [coefs] <= gamma
# using the equivalent SDP formulation from equation 4.42 of Dumitrescu
# returns a list a cvx expression constraints
T = len(coefs) - 1
m, n = coefs[0].shape # m >= n, enforcing constraint on transpose system
if l1_trans or T > 70:
print('using l1 of transpose instead of h inf norm')
ht_l1_norm = cvx.max(sum([cvx.norm(coef.T, p=1, axis=1) for coef in coefs]))
return [ht_l1_norm <= gamma], ht_l1_norm
constr = []
hcoefs = cvx.bmat([[coef.T] for coef in coefs])
Q = cvx.Variable((n*(T+1), n*(T+1)), PSD=True)
# constraint 4.39, part 1
# k == 0, diagonal of Q sums to gamma**2 I_n
constr.append(
sum([Q[n*t:n*(t+1), n*t:n*(t+1)] for t in range(T+1)]) == gamma**2*np.eye(n))
# k > 0, k-th off-diagonal of Q sums to 0
for k in range(1, T+1):
constr.append(
sum([Q[n*t:n*(t+1), n*(t+k):n*(t+1+k)] for t in range(T+1-k)]) == np.zeros((n, n)))
# constraint 4.39, constrain to be PSD
constr.append(
cvx.bmat([[Q, hcoefs], [hcoefs.T, np.eye(m)]]) == cvx.Variable((n*(T+1)+m, n*(T+1)+m), PSD=True))
return constr, (hcoefs, Q)
def execute(self):
# Zmienna decyzyjna
a = cvxpy.Variable((self.num_of_tasks, self.num_of_machines),
boolean=True)
# Czasy wykonywania zadań
sum = cvxpy.sum(a, axis=0, keepdims=True)
sum_matrix = cvxpy.hstack([sum for i in range(self.num_of_tasks)])
sum_matrix = cvxpy.reshape(sum_matrix,
(self.num_of_tasks, self.num_of_machines))
t = cvxpy.multiply(sum_matrix, self.t_peak)
max_time = cvxpy.max(t, axis=1)
# Koszty użycia maszyn
e = cvxpy.multiply(a, self.t_peak * self.p)
sum_of_expense = cvxpy.sum(e, axis=1)
# Funkcja celu
u = cvxpy.sum(max_time * self.w_t + sum_of_expense * self.w_e,
axis=0,
keepdims=True)
# Ograniczenia
subtasks_const = cvxpy.sum(a, axis=1).__eq__(self.tasks_subtasks)
time_const = max_time.__le__(self.T)
cost_const = sum_of_expense.__le__(self.M)
# Rozwiązanie problemu
problem = cvxpy.Problem(cvxpy.Minimize(u),
[subtasks_const, time_const, cost_const])
problem.solve(solver=cvxpy.GLPK_MI)
return a.value
def compute_structure_preserving_embedding(A, C = 100.0, verbose = False):
"""
Compute the structure-preserving embedding of a graph using CVXPY.
This does not actually scale beyond 10 x 10 or so.
Parameters
----------
A: (n_nodes x n_nodes) adjacency matrix
Returns
-------
E: (n_nodes x n_nodes) LLE embeddings
"""
n_nodes, _ = A.shape
K = cp.Variable((n_nodes, n_nodes), PSD = True)
xi = cp.Variable(1)
D = cp.bmat([[K[i, i] + K[j, j] - 2 * K[i, j] \
for j in range(n_nodes)] \
for i in range(n_nodes)])
M = cp.max(D, axis = 1)
objective = cp.Maximize(cp.trace(K @ A) - C * xi)
constraints = [cp.trace(K) <= 1, xi >= 0, cp.sum(K) == 0]
for i, j in itertools.combinations(range(n_nodes), 2):
constraints += [D[i, j] >= (1 - A[i, j]) * M[i] - xi]
problem = cp.Problem(objective, constraints)
result = problem.solve(verbose = verbose, solver = "SCS")
L, Z = np.linalg.eigh(K.value)
return Z
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_0D_conv(self) -> None:
"""Convolution with 0D input.
"""
x = cvx.Variable((1, )) # or cvx.Variable((1,1))
problem = cvx.Problem(
cvx.Minimize(cvx.max(cvx.conv([1.], cvx.multiply(1., x)))),
[x >= 0])
problem.solve(cvx.ECOS)
assert problem.status == cvx.OPTIMAL
def constraint_node(wi, wj, hi, hj):
wa = Variable(pos=True)
ha = Variable(pos=True)
ha = Variable(pos=True)
c = [
wa <= wi + wj,
ha <= cvx.max(hi + hj),
]
return
def solve_lp(payoff_matrix):
# This is a helper function to compute the ground truth solution of the matrix
# game. It's not used in the results presented.
x = cp.Variable(payoff_matrix.shape[1])
# The activity variables are created explicitly so we can access the duals.
activity = cp.Variable(payoff_matrix.shape[0])
prob = cp.Problem(cp.Minimize(cp.max(activity)),
[activity == payoff_matrix @ x,
cp.sum(x) == 1, x >= 0])
prob.solve(solver=cp.CVXOPT)
return prob.value, x.value, -prob.constraints[0].dual_value
def test_max(self):
"""Test max.
"""
# One arg, test sign.
self.assertEqual(cp.max(1).sign, s.NONNEG)
self.assertEqual(cp.max(-2).sign, s.NONPOS)
self.assertEqual(cp.max(Variable()).sign, s.UNKNOWN)
self.assertEqual(cp.max(0).sign, s.ZERO)
# Test with axis argument.
self.assertEqual(cp.max(Variable(2), axis=0, keepdims=True).shape, (1,))
self.assertEqual(cp.max(Variable(2), axis=1).shape, (2,))
self.assertEqual(cp.max(Variable((2, 3)), axis=0, keepdims=True).shape, (1, 3))
self.assertEqual(cp.max(Variable((2, 3)), axis=1).shape, (2,))
# Invalid axis.
with self.assertRaises(Exception) as cm:
cp.max(self.x, axis=4)
self.assertEqual(str(cm.exception),
"Invalid argument for axis.")
def test_max(self) -> None:
"""Test gradient for max
"""
expr = cp.max(self.x)
self.x.value = [2, 1]
self.assertItemsAlmostEqual(expr.grad[self.x].toarray(), [1, 0])
expr = cp.max(self.A)
self.A.value = np.array([[1, 2], [4, 3]])
self.assertItemsAlmostEqual(expr.grad[self.A].toarray(), [0, 1, 0, 0])
expr = cp.max(self.A, axis=0)
self.A.value = np.array([[1, 2], [4, 3]])
self.assertItemsAlmostEqual(expr.grad[self.A].toarray(),
np.array([[0, 0], [1, 0], [0, 0], [0, 1]]))
expr = cp.max(self.A, axis=1)
self.A.value = np.array([[1, 2], [4, 3]])
self.assertItemsAlmostEqual(expr.grad[self.A].toarray(),
np.array([[0, 0], [0, 1], [1, 0], [0, 0]]))
def _xxx(self, obj):
""" testing - todo remove"""
if obj == 'rect':
self._obj = Minimize(
cvx.max(cvx.abs(X[:, 0]) + r) + cvx.max(cvx.abs(X[:, 1]) + r))
elif obj == 'sqr':
self._obj = Minimize(cvx.max(cvx.max(cvx.abs(X), axis=1) + r))
else:
# f0 =
# f1 = Tij / Dij # - 1 # Tij / Dij is not convex ?
# f1 = 1 / Dij # , -1) # - 1
# vbar = Variable(n, boolean=True)
# f2 = 2 * cvx.sqrt(Cij * Tij) - 1
# f3 = Dij / Tij # * self._k
# if verbose is True:
# print('dij', Dij.curvature)
# print('f0', f0.curvature)
# print('f1', f1.curvature)
# print('f3', f3.curvature)
if obj == 'ar0':
print('ar0', f0.shape, cvx.sum(f0).curvature)
def cvar(v, lam, alpha):
m = v.shape[0]
p = cp.Variable(m, nonneg=True)
obj = v @ p + lam * cp.sum(cp.entr(p)) - lam * np.log(m)
constraints = [
cp.max(p) <= 1.0 / (alpha * m),
cp.sum(p) == 1,
]
problem = cp.Problem(cp.Maximize(obj), constraints)
problem.solve(solver=cp.MOSEK)
return p.value
def minpeak_controlled_load(self, verbose=False):
"""Implements the charging control for a simple peak minimization control. Please refer to the first control
method, `sdge_controlled_load', for comments on the optimization set up and constraints which are common
between the two.
"""
schedule = cvx.Variable((96, self.num_sessions))
obj = cvx.max(
cvx.sum(schedule, axis=1)
) # Minimize the peak total load reached at any time during the day
constraints = [schedule >= 0]
for i in range(self.num_sessions):
constraints += [
schedule[:, i] <= np.maximum(np.max(self.power[:, i]),
self.charge_rate)
]
if self.departure_inds[i] >= self.arrival_inds[i]:
if self.arrival_inds[i] > 0:
constraints += [
schedule[np.arange(0, int(self.arrival_inds[i])), i] <=
0
]
if self.departure_inds[i] < 96:
constraints += [
schedule[np.arange(int(self.departure_inds[i]), 96), i]
<= 0
]
else:
constraints += [
schedule[np.arange(int(self.departure_inds[i]
), int(self.arrival_inds[i])), i] <=
0
]
constraints += [0.25 * cvx.sum(schedule, axis=0) == self.energies]
prob = cvx.Problem(cvx.Minimize(obj), constraints)
result = prob.solve(solver=cvx.MOSEK)
self.minpeak_controlled_power = schedule.value
# Not likely necessary since there is no cap constraint, but this was implemented just in case this method
# throws an error:
try:
self.controlled_total_load = np.sum(schedule.value, axis=1)
except:
try:
self.controlled_total_load = -1 * np.ones((96, ))
except:
donothing = 1
def uniform_allocation():
P = cp.Variable((n,1), name="P")
x = np.ones((m,1))*B/m
log_p = -np.multiply(a, x)
source_node_logprob_constraint = [P[0] == np.log(1)]
node_logprob_constraints = [ P[this_node] >= cp.max(cp.vstack([P[prev_node] + log_p[edge_from_prev] for (edge_from_prev, prev_node) in find_prev_node_and_edge(this_node)])) for this_node in range(1,n)]
obj = cp.Minimize(P[-1])
constraints = source_node_logprob_constraint + node_logprob_constraints
prob = cp.Problem(obj, constraints)
prob.solve()
print("Status: " + str(prob.status))
print("uniform P_max = " + str(np.exp(P.value[-1])))
def test_max(self) -> None:
x = cp.Variable(pos=True)
y = cp.Variable(pos=True)
a = cp.Parameter(value=0.5)
b = cp.Parameter(pos=True, value=1.5)
c = cp.Parameter(pos=True, value=3.0)
d = cp.Parameter(pos=True, value=1.0)
prod1 = b * x * y**a
prod2 = c * x * y**b
obj = cp.Minimize(cp.max(cp.hstack([prod1, prod2])))
constr = [x == d, y == b]
problem = cp.Problem(obj, constr)
gradcheck(problem, gp=True)
perturbcheck(problem, gp=True)
def setUp(self):
from cvxopt import matrix, normal, spdiag, misc, lapack
from ubsdp import ubsdp
m, n = 10, 10
A = normal(m**2, n)
# Z0 random positive definite with maximum e.v. less than 1.0.
Z0 = normal(m,m)
Z0 = Z0 * Z0.T
w = matrix(0.0, (m,1))
a = +Z0
lapack.syev(a, w, jobz = 'V')
wmax = max(w)
if wmax > 0.9: w = (0.9/wmax) * w
Z0 = a * spdiag(w) * a.T
# c = -A'(Z0)
c = matrix(0.0, (n,1))
misc.sgemv(A, Z0, c, dims = {'l': 0, 'q': [], 's': [m]}, trans = 'T', alpha = -1.0)
# Z1 = I - Z0
Z1 = -Z0
Z1[::m+1] += 1.0
x0 = normal(n,1)
X0 = normal(m,m)
X0 = X0*X0.T
S0 = normal(m,m)
S0 = S0*S0.T
# B = A(x0) - X0 + S0
B = matrix(A*x0 - X0[:] + S0[:], (m,m))
X = ubsdp(c, A, B)
(self.m, self.n, self.c, self.A, self.B, self.Xubsdp) = (m, n, c, A, B, X)
__author__ = 'Xinyue'
import cvxpy as cvx
import numpy as np
import matplotlib.pyplot as plt
import dccp
np.random.seed(0)
n = 10
r = np.linspace(1, 5, n)
c = cvx.Variable((n,2))
constr = []
for i in range(n-1):
for j in range(i+1, n):
constr.append(cvx.norm(cvx.vec(c[i,:]-c[j,:]), 2) >= r[i]+r[j])
prob = cvx.Problem(cvx.Minimize(cvx.max(cvx.max(cvx.abs(c), axis=1) + r)), constr)
prob.solve(method = 'dccp', solver='ECOS', ep = 1e-2, max_slack = 1e-2)
l = cvx.max(cvx.max(cvx.abs(c),axis=1)+r).value*2
pi = np.pi
ratio = pi*cvx.sum(cvx.square(r)).value/cvx.square(l).value
print "ratio =", ratio
# plot
plt.figure(figsize=(5,5))
circ = np.linspace(0,2*pi)
x_border = [-l/2, l/2, l/2, -l/2, -l/2]
y_border = [-l/2, -l/2, l/2, l/2, -l/2]
for i in xrange(n):
plt.plot(c[i,0].value+r[i]*np.cos(circ),c[i,1].value+r[i]*np.sin(circ),'b')
plt.plot(x_border,y_border,'g')
plt.axes().set_aspect('equal')
plt.xlim([-l/2,l/2])
val_ls_reg = np.max(np.abs(log(A * matrix(p_ls_reg)))) print p_ls_reg print val_ls_reg ########################################################################################### # solution 4 # chebshev approximation p_chev = cp.Variable(m) objective = cp.Minimize(cp.norm(A * p_chev - ones((n, 1)), "inf")) constraints = [p_chev <= 1, p_chev >= 0] p4 = cp.Problem(objective, constraints) result = p4.solve() f_4 = np.max(np.abs(log(A * matrix(p_chev.value)))) print p_chev.value print f_4 ########################################################################################### # solution 5 # cvxpy u = cp.Variable(1) p_cp = cp.Variable(m) objective = cp.Minimize(u) constraints = [cp.max(matrix(A[i, :]) * p_cp, cp.inv_pos(matrix(A[i, :]) * p_cp)) <= u for i in range(n)] constraints.extend([p_cp <= 1, p_cp >= 0]) p5 = cp.Problem(objective, constraints) result = p5.solve() f_5 = np.max(np.abs(log(A * matrix(p_cp.value)))) print p_cp.value print f_5
from cvxpy import Minimize, Variable, Problem, max, abs, sum import numpy as np n = 3 N = 30 A = np.matrix([[-1, 0.4, 0.8], [1, 0, 0], [0, 1, 0]]) b = np.matrix([1, 0, 0.3]).T x0 = zeros((n, 1)) xdes = np.matrix([7, 2, -6]).T x = Variable(n, N + 1) u = Variable(1, N) objective = Minimize(sum(max(abs(u), 2 * abs(u) - 1))) constraints1 = [x[:, 1 : N + 1] == A * x[:, 0:N] + b * u] constraints2 = [x[:, 0] == x0] constraints3 = [x[:, N] == xdes] constraints = constraints1 + constraints2 + constraints3 prob1 = Problem(objective, constraints) prob1.solve() print u.value step(range(30), u.value.T)
#a1 = np.array([1,1]).T #a2 = np.array([1,-5]).T #a3 = np.array([-1,-1]).T #b1 = 0 #b2 = 0 #b3 = 0 ####################### a1 = cp.Variable(2,1) a2 = cp.Variable(2,1) a3 = cp.Variable(2,1) b1 = cp.Variable(1) b2 = cp.Variable(1) b3 = cp.Variable(1) obj = cp.Minimize(0) constraints1 = [a1.T*X-b1>=cp.max(a2.T*X-b2,a3.T*X-b3)+1] constraints2 = [a2.T*Y-b2>=cp.max(a1.T*Y-b1,a3.T*Y-b3)+1] constraints3 = [a3.T*Z-b3>=cp.max(a1.T*Z-b1,a2.T*Z-b2)+1] constraints4 =[a1+a2+a3==0] constraints5 =[b1+b2+b3==0] constraints = constraints1+constraints2+constraints3#+constraints4+constraints5 pro = cp.Problem(obj,constraints) pro.solve(solver=cp.CVXOPT) a1 = np.array(a1.value.T).flatten() a2 = np.array(a2.value.T).flatten() a3 = np.array(a3.value.T).flatten() b1 = b1.value b2 = b2.value b3 = b3.value ######################
x=Variable (m,1) objective = Minimize(normInf(matrix(A)*x-ones((n,1)))) constraints =[x>=0,x<=1] pro = Problem(objective, constraints) result = pro.solve() print x.value val_ls_chev = np.max(np.abs(log(A*matrix(x.value)))) print val_ls_chev #solution 5 cvxpy from cvxpy import max y=Variable (m,1) Am = matrix(A) qq = [max(Am[i,:]*y,inv_pos(Am[i,:]*y)) for i in range(n)] objective1 = Minimize(max(*qq)) constraints1 =[y>=0,y<=1] pro1 = Problem(objective1, constraints1) result1 = pro1.solve() print y.value val_ls_cvx = np.max(np.abs(log(A*matrix(y.value)))) print val_ls_cvx #solution 6 cvxpy equvelent z=Variable (m,1) u = Variable(1) qq = [(max(Am[i,:]*z,inv_pos(Am[i,:]*z))<=u) for i in range(n)] objective2 = Minimize(u) pp =[z>=0,z<=1]
