def optimal_entropy_cvxpy_batch(I, Sig, nsko, warm_start=None):
if type(I) == int:
lenI = 1
I = [I]
else:
lenI = len(I)
p = len(Sig)
I_PP = np.diag(np.tile(1, p)) #identity matrix
I_PI = I_PP[:, I]
I_IP = I_PI.transpose()
s0 = cp.Variable(lenI)
if warm_start is None:
Objective = cp.Minimize(-cp.log_det((
(nsko + 1) / nsko) * Sig - I_PI @ cp.diag(s0) @ I_IP) -
nsko * cp.sum(cp.log(s0)))
prob = cp.Problem(Objective, [
s0 >= 0.00001,
((nsko + 1) / nsko) * Sig >> I_PI @ cp.diag(s0) @ I_IP
])
prob.solve()
return s0.value
else:
if lenI == 1:
s0.value = np.array([warm_start])
else:
s0.value = warm_start
Objective = cp.Minimize(-cp.log_det((
(nsko + 1) / nsko) * Sig - I_PI @ cp.diag(s0) @ I_IP) -
nsko * cp.sum(cp.log(s0)))
prob = cp.Problem(
Objective,
[s0 >= 0, ((nsko + 1) / nsko) * Sig >> I_PI @ cp.diag(s0) @ I_IP])
prob.solve(solver=cp.SCS)
return s0.value
def test_dcp_curvature(self):
expr = 1 + cvx.exp(cvx.Variable())
self.assertEqual(expr.curvature, s.CONVEX)
expr = cvx.Parameter()*cvx.Variable(nonneg=True)
self.assertEqual(expr.curvature, s.AFFINE)
f = lambda x: x**2 + x**0.5 # noqa E731
expr = f(cvx.Constant(2))
self.assertEqual(expr.curvature, s.CONSTANT)
expr = cvx.exp(cvx.Variable())**2
self.assertEqual(expr.curvature, s.CONVEX)
expr = 1 - cvx.sqrt(cvx.Variable())
self.assertEqual(expr.curvature, s.CONVEX)
expr = cvx.log(cvx.sqrt(cvx.Variable()))
self.assertEqual(expr.curvature, s.CONCAVE)
expr = -(cvx.exp(cvx.Variable()))**2
self.assertEqual(expr.curvature, s.CONCAVE)
expr = cvx.log(cvx.exp(cvx.Variable()))
self.assertEqual(expr.is_dcp(), False)
expr = cvx.entr(cvx.Variable(nonneg=True))
self.assertEqual(expr.curvature, s.CONCAVE)
expr = ((cvx.Variable()**2)**0.5)**0
self.assertEqual(expr.curvature, s.CONSTANT)
def exact_uot(C, a, b, tau, vbo=False):
nr = len(a)
nc = len(b)
X = cp.Variable((nr, nc), nonneg=True)
row_sums = cp.sum(X, axis=1)
col_sums = cp.sum(X, axis=0)
obj = cp.sum(cp.multiply(X, C))
obj -= tau * cp.sum(cp.entr(row_sums))
obj -= tau * cp.sum(cp.entr(col_sums))
obj -= tau * cp.sum(cp.multiply(row_sums, cp.log(a)))
obj -= tau * cp.sum(cp.multiply(col_sums, cp.log(b)))
obj -= 2 * tau * cp.sum(X)
obj += tau * cp.sum(a) + tau * cp.sum(b)
prob = cp.Problem(cp.Minimize(obj))
prob.solve(solver='SCS', verbose=vbo)
# print('UOT optimal value:', prob.value)
return prob.value
def test_signed_curvature(self):
# Convex argument.
expr = cvx.abs(1 + cvx.exp(cvx.Variable()) )
self.assertEqual(expr.curvature, s.CONVEX)
expr = cvx.abs( -cvx.entr(cvx.Variable()) )
self.assertEqual(expr.curvature, s.UNKNOWN)
expr = cvx.abs( -cvx.log(cvx.Variable()) )
self.assertEqual(expr.curvature, s.UNKNOWN)
# Concave argument.
expr = cvx.abs( cvx.log(cvx.Variable()) )
self.assertEqual(expr.curvature, s.UNKNOWN)
expr = cvx.abs( -cvx.square(cvx.Variable()) )
self.assertEqual(expr.curvature, s.CONVEX)
expr = cvx.abs( cvx.entr(cvx.Variable()) )
self.assertEqual(expr.curvature, s.UNKNOWN)
# Affine argument.
expr = cvx.abs( cvx.NonNegative() )
self.assertEqual(expr.curvature, s.CONVEX)
expr = cvx.abs( -cvx.NonNegative() )
self.assertEqual(expr.curvature, s.CONVEX)
expr = cvx.abs( cvx.Variable() )
self.assertEqual(expr.curvature, s.CONVEX)
def test_signed_curvature(self):
# Convex argument.
expr = cvx.abs(1 + cvx.exp(cvx.Variable()))
self.assertEqual(expr.curvature, s.CONVEX)
expr = cvx.abs(-cvx.entr(cvx.Variable()))
self.assertEqual(expr.curvature, s.UNKNOWN)
expr = cvx.abs(-cvx.log(cvx.Variable()))
self.assertEqual(expr.curvature, s.UNKNOWN)
# Concave argument.
expr = cvx.abs(cvx.log(cvx.Variable()))
self.assertEqual(expr.curvature, s.UNKNOWN)
expr = cvx.abs(-cvx.square(cvx.Variable()))
self.assertEqual(expr.curvature, s.CONVEX)
expr = cvx.abs(cvx.entr(cvx.Variable()))
self.assertEqual(expr.curvature, s.UNKNOWN)
# Affine argument.
expr = cvx.abs(cvx.Variable(nonneg=True))
self.assertEqual(expr.curvature, s.CONVEX)
expr = cvx.abs(-cvx.Variable(nonneg=True))
self.assertEqual(expr.curvature, s.CONVEX)
expr = cvx.abs(cvx.Variable())
self.assertEqual(expr.curvature, s.CONVEX)
def getIndirectUtil(valuation, prices, budget, utility = "linear", rho = None):
"""
Given a vector of consumer valuations, v, a price vector, p, and a budget, compute the utility
of a utility-maximizing bundle. Mathematically, solve the linear program:
max_{x} xv
s.t. xp <= budget
:param valuation: a consumer's valuation for goods.
:param prices: prices of goods.
:param budget: the consumer's budget
:return:
"""
num_items = len(valuation)
x = cp.Variable(num_items)
if (utility == "linear"):
obj = cp.Maximize(x.T @ valuation)
elif (utility == "leontief"):
obj = cp.Maximize( cp.min( cp.multiply(x, 1/valuation) ) )
elif (utility == "cobb-douglas"):
obj = cp.Maximize( cp.sum(cp.multiply(valuation, cp.log(x))))
elif (utility == "ces"):
x_rho = cp.power(x, rho)
util = valuation.T @ x_rho
obj = cp.Maximize((1/rho)*cp.log(util))
else:
obj = cp.Maximize(x.T @ (valuation - prices))
constraints = [ (x.T @ prices) <= budget,
x >= 0]
prob = cp.Problem(obj, constraints)
return prob.solve()
def test_dcp_curvature(self):
expr = 1 + cvx.exp(cvx.Variable())
self.assertEqual(expr.curvature, s.CONVEX)
expr = cvx.Parameter()*cvx.NonNegative()
self.assertEqual(expr.curvature, s.AFFINE)
f = lambda x: x**2 + x**0.5
expr = f(cvx.Constant(2))
self.assertEqual(expr.curvature, s.CONSTANT)
expr = cvx.exp(cvx.Variable())**2
self.assertEqual(expr.curvature, s.CONVEX)
expr = 1 - cvx.sqrt(cvx.Variable())
self.assertEqual(expr.curvature, s.CONVEX)
expr = cvx.log( cvx.sqrt(cvx.Variable()) )
self.assertEqual(expr.curvature, s.CONCAVE)
expr = -( cvx.exp(cvx.Variable()) )**2
self.assertEqual(expr.curvature, s.CONCAVE)
expr = cvx.log( cvx.exp(cvx.Variable()) )
self.assertEqual(expr.is_dcp(), False)
expr = cvx.entr( cvx.NonNegative() )
self.assertEqual(expr.curvature, s.CONCAVE)
expr = ( (cvx.Variable()**2)**0.5 )**0
self.assertEqual(expr.curvature, s.CONSTANT)
def test_log_problem(self):
# Log in objective.
obj = cvx.Maximize(cvx.sum(cvx.log(self.x)))
constr = [self.x <= [1, math.e]]
p = cvx.Problem(obj, constr)
result = p.solve()
self.assertAlmostEqual(result, 1)
self.assertItemsAlmostEqual(self.x.value, [1, math.e])
# Log in constraint.
obj = cvx.Minimize(cvx.sum(self.x))
constr = [cvx.log(self.x) >= 0, self.x <= [1, 1]]
p = cvx.Problem(obj, constr)
result = p.solve()
self.assertAlmostEqual(result, 2)
self.assertItemsAlmostEqual(self.x.value, [1, 1])
# Index into log.
obj = cvx.Maximize(cvx.log(self.x)[1])
constr = [self.x <= [1, math.e]]
p = cvx.Problem(obj, constr)
result = p.solve()
self.assertAlmostEqual(result, 1)
# Scalar log.
obj = cvx.Maximize(cvx.log(self.x[1]))
constr = [self.x <= [1, math.e]]
p = cvx.Problem(obj, constr)
result = p.solve()
self.assertAlmostEqual(result, 1)
def get_RCK_weights(returns,
minimalWealthFraction=0.7,
confidence=0.3,
max_expo=0.25):
n = len(returns.columns)
pi = np.array([1. / len(returns)] * len(returns))
r = (returns + 1.).as_matrix().T
b_rck = cvx.Variable(n)
lambda_rck = cvx.Parameter(sign='positive')
lambda_rck.value = np.log(confidence) / np.log(minimalWealthFraction)
growth_rate = pi.T * cvx.log(r.T * b_rck)
risk_constraint = cvx.log_sum_exp(
np.log(pi) - lambda_rck * cvx.log(r.T * b_rck)) <= 0
constraints = [
cvx.sum_entries(b_rck) == 1, b_rck >= 0, b_rck <= max_expo,
risk_constraint
]
rck = cvx.Problem(cvx.Maximize(growth_rate), constraints)
rck.solve(verbose=False)
#print rck.value
#print b_rck.value
w = pd.Series(data=np.asarray(b_rck.value).flatten(),
index=returns.columns)
w = w / w.abs().sum()
return w
def test_log(self) -> None:
"""Test gradient for log.
"""
expr = cp.log(self.a)
self.a.value = 2
self.assertAlmostEqual(expr.grad[self.a], 1.0 / 2)
self.a.value = 3
self.assertAlmostEqual(expr.grad[self.a], 1.0 / 3)
self.a.value = -1
self.assertAlmostEqual(expr.grad[self.a], None)
expr = cp.log(self.x)
self.x.value = [3, 4]
val = np.zeros((2, 2)) + np.diag([1 / 3, 1 / 4])
self.assertItemsAlmostEqual(expr.grad[self.x].toarray(), val)
expr = cp.log(self.x)
self.x.value = [-1e-9, 4]
self.assertAlmostEqual(expr.grad[self.x], None)
expr = cp.log(self.A)
self.A.value = [[1, 2], [3, 4]]
val = np.zeros((4, 4)) + np.diag([1, 1 / 2, 1 / 3, 1 / 4])
self.assertItemsAlmostEqual(expr.grad[self.A].toarray(), val)
def bin_oligo_count(lib_lim, n_templates, G, D, n_bins=1e3):
if n_bins < lib_lim:
n_bins = int(n_bins)
else:
n_bins = int(lib_lim)
first_lower_bin = 0
bin_upper_lim = np.log(np.linspace(1, lib_lim, num=n_bins))
bin_lower_lim = np.array([bin_upper_lim[i-1] if i > 0 else first_lower_bin for i in range(n_bins)])
bins = cvxpy.Variable((n_templates, n_bins), boolean=True)
constraints = []
for s in range(len(G)):
log_n_seq = cvxpy.sum(G[s] * cvxpy.log(cvxpy.sum(D, axis=1)))
constraints.append(log_n_seq <= cvxpy.log(lib_lim))
constraints.append(bins[s, :] * bin_lower_lim <= log_n_seq)
constraints.append(bins[s, :] * bin_upper_lim >= log_n_seq)
constraints.append(cvxpy.sum(bins[s, :]) == 1)
lib_size = cvxpy.sum(bins * np.exp(bin_upper_lim))
constraints.append(lib_size <= lib_lim)
return constraints, lib_size
def get_inner_loss_cvx(logits, labels, div_type_cls, gamma):
"""Compute class-reweighted loss using CVX."""
num_classes = logits.shape[1]
ce_loss_all = -1 * (logits -
tf.reduce_logsumexp(logits, axis=1, keepdims=True))
ce_loss_all_numpy = ce_loss_all.numpy()
num_examples = logits.shape[0]
dim = num_classes
v = cp.Variable((num_examples, dim))
v.value = v.project(labels)
constraints = [v >= 0, cp.sum(v, axis=1) == 1]
if div_type_cls == 'l2':
constraints.append(cp.sum(cp.square(v - labels), axis=1) <= gamma)
elif div_type_cls == 'l1':
constraints.append(cp.sum(cp.abs(v - labels), axis=1) <= gamma)
elif div_type_cls == 'kl':
constraints.append(
cp.sum(cp.multiply(labels,
cp.log(labels + 1e-6) - cp.log(v + 1e-6)),
axis=1) <= gamma)
obj = cp.Minimize(cp.sum(cp.multiply(v, ce_loss_all_numpy)))
prob = cp.Problem(obj, constraints)
try:
prob.solve(warm_start=True)
except cp.error.SolverError:
v.value = v.project(labels)
prob.solve(solver='SCS', warm_start=True)
inner_loss = tf.reduce_sum(tf.multiply(v.value, ce_loss_all), axis=1)
return inner_loss
def test_log(self):
x = cp.Variable(4, pos=True)
c = cp.Parameter(4, pos=True)
expr = cp.log(cp.multiply(c, x))
self.assertTrue(expr.is_dgp(dpp=True))
expr = cp.log(c.T @ x)
self.assertFalse(expr.is_dgp(dpp=True))
def get_maximal_rectangle(coordinates):
"""
Find the largest, inscribed, axis-aligned rectangle.
:param coordinates:
A list of of [x, y] pairs describing a closed, convex polygon.
"""
coordinates = np.array(coordinates)
x_range = np.max(coordinates, axis=0)[0] - np.min(coordinates, axis=0)[0]
y_range = np.max(coordinates, axis=0)[1] - np.min(coordinates, axis=0)[1]
scale = np.array([x_range, y_range])
sc_coordinates = coordinates / scale
poly = Polygon(sc_coordinates)
inside_pt = (poly.representative_point().x, poly.representative_point().y)
A1, A2, B = pts_to_leq(sc_coordinates)
bl = cvxpy.Variable(2)
tr = cvxpy.Variable(2)
br = cvxpy.Variable(2)
tl = cvxpy.Variable(2)
obj = cvxpy.Maximize(cvxpy.log(tr[0] - bl[0]) + cvxpy.log(tr[1] - bl[1]))
constraints = [
bl[0] == tl[0],
br[0] == tr[0],
tl[1] == tr[1],
bl[1] == br[1],
]
for i in range(len(B)):
if inside_pt[0] * A1[i] + inside_pt[1] * A2[i] <= B[i]:
constraints.append(bl[0] * A1[i] + bl[1] * A2[i] <= B[i])
constraints.append(tr[0] * A1[i] + tr[1] * A2[i] <= B[i])
constraints.append(br[0] * A1[i] + br[1] * A2[i] <= B[i])
constraints.append(tl[0] * A1[i] + tl[1] * A2[i] <= B[i])
else:
constraints.append(bl[0] * A1[i] + bl[1] * A2[i] >= B[i])
constraints.append(tr[0] * A1[i] + tr[1] * A2[i] >= B[i])
constraints.append(br[0] * A1[i] + br[1] * A2[i] >= B[i])
constraints.append(tl[0] * A1[i] + tl[1] * A2[i] >= B[i])
prob = cvxpy.Problem(obj, constraints)
#prob.solve(solver=cvxpy.CVXOPT, verbose=False, max_iters=1000, reltol=1e-9)
#bottom_left = np.array(bl.value).T * scale
#top_right = np.array(tr.value).T * scale
#return list(bottom_left[0]), list(top_right[0])
prob.solve()
bottom_left = np.array(bl.value).T * scale
top_right = np.array(tr.value).T * scale
return bottom_left.tolist(), top_right.tolist()
def cvxprob(ar, qr, ir):
a = []
q = []
for n in range(M):
a.append(cp.Variable(shape=(K, 1)))
q.append(cp.Variable(shape=(K, 3)))
objfunc = []
for n in range(M):
for k in range(K):
term1 = 1
for j in range(K):
term1 += gamma * (2 * ar[n][j] * a[n][j] / (np.linalg.norm(qr[n][j] - s[k])))
term1 -= gamma * (ar[n][j] ** 2) * (cp.norm(q[n][j] - s[k]) ** 2) / (
np.linalg.norm(qr[n][j] - s[k]) ** 2)
objfunc.append(cp.log(term1))
objfunc.append(-1 * cp.log(1 + ir[n][k][0]))
objfunc.append(ir[n][k][0] / (1 + ir[n][k][0]))
term2 = 0
for j in range(K):
if j != k:
term2 -= gamma * cp.square(a[n][j]) / ((1 + ir[n][k][0]) * (
np.linalg.norm(qr[n][j] - s[k]) + 2 * (qr[n][j] - s[k]).transpose() * (
q[n][j] - qr[n][j])))
objfunc.append(term2)
constr = []
for n in range(M):
for k in range(K):
constr.append(q[n][k][2] <= hmax)
constr.append(q[n][k][2] >= hmin)
for n in range(1, M):
for k in range(K):
constr.append(cp.norm(q[n][k][0:1] - q[n - 1][k][0:1]) <= vl)
constr.append(q[n][k][2] - q[n][k - 1][2] <= va)
constr.append(q[n][k][2] - q[n][k - 1][2] >= -vd)
for n in range(M):
for k in range(K):
constr.append(a[n][k] <= math.sqrt(pmax))
constr.append(a[n][k] >= 0)
for n in range(M):
for k in range(K):
for j in range(k + 1, K):
if j != k:
constr.append(2 * (qr[n][k] - qr[n][j]).transpose() * (q[n][k] - q[n][j]) >= (
np.linalg.norm(qr[n][j] - s[k]) ** 2 + dmin ** 2))
obj = cp.Maximize(sum(objfunc))
prob = cp.Problem(obj, constr)
prob.solve()
print("status: ", prob.status)
return [av.value for av in a], [qv.value for qv in q]
def constr(self, x, phi, log_cash):
def to_constant(x):
"""return violation if constant, constraint if variable"""
return -x.value if x.is_constant() else x >= 0
expr1 = cvx.log(sum(a - a*b*cvx.inv_pos(x[g] + b)
for g, a, b in izip(self.goods, self.a, self.b)))
return [to_constant(expr1 - np.log(a) + cvx.log(x[g] + b) + phi[g] - log_cash)
for g, a, b in izip(self.goods, self.a, self.b)]
def constr(self, x, phi, log_cash):
expr1 = cvx.log(sum(a*cvx.sqrt(x[g]) for g, a in self.a.iteritems()))
def to_constant(x):
"""return violation if constant, constraint if variable"""
return -x.value if x.is_constant() else x >= 0
return [to_constant(expr1 - np.log(a) + (1-self.rho)*cvx.log(x[g]) +
phi[g] - log_cash)
for g, a in self.a.iteritems()]
def solve_w_max(policy_value, r0):
n = len(policy_value)
w = cp.Variable(n)
objective = cp.Maximize(policy_value @ w)
constraints = [w >= 0, sum(w) == 1, -cp.sum(cp.log(n * w)) <= -cp.log(r0)]
prob = cp.Problem(objective, constraints)
result = prob.solve(solver=cp.SCS)
if result == None:
print("None found CI_util.py line 84")
result = 1000
w_v = w.value
return result, w_v
def __init__(self, returns, indexReturns,regularizer,i):
#initiate a problem with data
numAssets = returns.shape[1]
self.x = cvx.Variable(numAssets)
self.index = i
self.t=cvx.Variable()
baseConstraints = [self.x>=0,self.t>=0,sum(self.x)==1]
#should have a check to see if i is in the range of num of assets
constraints = baseConstraints+ [cvx.log(self.x[i])+cvx.log(self.t)>= cvx.log(regularizer)]
TrackingErrorSquared = cvx.sum_squares(returns*self.x -indexReturns )
obj = cvx.Minimize( TrackingErrorSquared+self.t)
cvx.Problem.__init__(self,obj,constraints)
def __init__(self, K, J, **kwargs):
super().__init__(K, J, **kwargs)
self.z = cvx.Variable(nonneg=True)
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 = self.z
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)
if j == 0:
constraints.append(
cvx.sum(
cvx.log(1 + cvx.multiply(
cvx.multiply(self.rho[:, j], self.F[:, j]),
self.Pk[:, j]))) >= self.z)
else:
constraints.append(
cvx.sum(
cvx.log(1 + cvx.sum(cvx.multiply(
cvx.multiply(self.rho[:, :j + 1], self.
Pk[:, :j + 1]), self.F[:, :j + 1]),
axis=1)) -
cvx.log(1 + cvx.sum(cvx.multiply(
cvx.multiply(self.rho[:, :j], self.Fk[:, :j]),
self.Pk[:, :j]),
axis=1)) -
cvx.multiply(
cvx.multiply(
cvx.multiply(self.Fk[:, j], self.Pk[:, j]),
cvx.power((1 + cvx.sum(
cvx.multiply(
cvx.multiply(self.rho[:, :j],
self.Fk[:, :j]),
self.Pk[:, :j]))), -1)),
(self.F[:, j] - self.Fk[:, j]))) >= self.z)
self.prob = cvx.Problem(cvx.Maximize(self.obj), constraints)
def test():
"""Test my function with known right solution to problems"""
# the first problem to test with
print("Problem #1:\n")
print("19 0 81")
print("0 20 80")
# the right solution
x = cvxpy.Variable()
y = cvxpy.Variable()
prob = cvxpy.Problem(
cvxpy.Maximize(log(81 * x + 19) + log(80 * (1 - x) + 20)),
[0 <= x, x <= 1])
prob.solve()
print("\nSuppose to be:")
print(
f"Agent #1 gets 1.0000 of resource #1, 0.0000 of resource #2, {x.value:.4f} of resource #3."
)
print(
f"Agent #2 gets 0.0000 of resource #1, 1.0000 of resource #2, {1 - x.value:.4f} of resource #3."
)
# my function's solution
print("\nMy Function:")
solve_problem([[19, 0, 81], [0, 20, 80]])
# the seconf problem
print("\n\nProblem #2:\n")
print("19 0 0 81")
print("0 20 0 80")
print("0 0 40 60")
x = cvxpy.Variable()
y = cvxpy.Variable()
z = cvxpy.Variable()
prob = cvxpy.Problem(objective=cvxpy.Maximize(
log(81 * x + 19) + log(80 * y + 20) + log(60 * z + 40)),
constraints=[
0 <= x, x <= 1, 0 <= y, y <= 1, 0 <= z, z <= 1,
x + y + z == 1
])
prob.solve()
print("\nSuppose to be:")
print(
f"Agent #1 gets 1.0000 of resource #1, 0.0000 of resource #2, 0.0000 of resource #3, {x.value:.4f} of resource #4."
)
print(
f"Agent #2 gets 0.0000 of resource #1, 1.0000 of resource #2, 0.0000 of resource #3, {y.value:.4f} of resource #4."
)
print(
f"Agent #3 gets 0.0000 of resource #1, 0.0000 of resource #2, 1.0000 of resource #3, {z.value:.4f} of resource #4."
)
# my function's solution
print("\nMy Function:")
solve_problem([[19, 0, 0, 81], [0, 20, 0, 80], [0, 0, 40, 60]])
def get_maximal_rectangle(coordinates):
"""
Find the largest, inscribed, axis-aligned rectangle.
:param coordinates:
A list of of [x, y] pairs describing a closed, convex polygon.
"""
coordinates = np.array(coordinates)
x_range = np.max(coordinates, axis=0)[0]-np.min(coordinates, axis=0)[0]
y_range = np.max(coordinates, axis=0)[1]-np.min(coordinates, axis=0)[1]
scale = np.array([x_range, y_range])
sc_coordinates = coordinates/scale
poly = Polygon(sc_coordinates)
inside_pt = (poly.representative_point().x,
poly.representative_point().y)
A1, A2, B = pts_to_leq(sc_coordinates)
bl = cvxpy.Variable(2)
tr = cvxpy.Variable(2)
br = cvxpy.Variable(2)
tl = cvxpy.Variable(2)
obj = cvxpy.Maximize(cvxpy.log(tr[0] - bl[0]) + cvxpy.log(tr[1] - bl[1]))
constraints = [bl[0] == tl[0],
br[0] == tr[0],
tl[1] == tr[1],
bl[1] == br[1],
]
for i in range(len(B)):
if inside_pt[0] * A1[i] + inside_pt[1] * A2[i] <= B[i]:
constraints.append(bl[0] * A1[i] + bl[1] * A2[i] <= B[i])
constraints.append(tr[0] * A1[i] + tr[1] * A2[i] <= B[i])
constraints.append(br[0] * A1[i] + br[1] * A2[i] <= B[i])
constraints.append(tl[0] * A1[i] + tl[1] * A2[i] <= B[i])
else:
constraints.append(bl[0] * A1[i] + bl[1] * A2[i] >= B[i])
constraints.append(tr[0] * A1[i] + tr[1] * A2[i] >= B[i])
constraints.append(br[0] * A1[i] + br[1] * A2[i] >= B[i])
constraints.append(tl[0] * A1[i] + tl[1] * A2[i] >= B[i])
prob = cvxpy.Problem(obj, constraints)
prob.solve(solver=cvxpy.CVXOPT, verbose=False, max_iters=1000, reltol=1e-9)
bottom_left = np.array(bl.value).T * scale
top_right = np.array(tr.value).T * scale
return list(bottom_left[0]), list(top_right[0])
def likelihoodFromMatrix(obs, usri, alphai, lgStep, N, nbDistSample=1):
mat = getMatInter(obs, lgStep, usri, reduit=False)
L = 0
for c2 in mat:
for dt in mat[c2]:
#L += logF(dt, 0, alphai[c2], nbDistSample) * mat[c2][dt][1]
#L += logS(dt, 0, alphai[c2], nbDistSample) * mat[c2][dt][0]
L += cp.log(H(dt, 0, alphai[c2], nbDistSample)) * mat[c2][dt][1]
L += cp.log(1. -
H(dt, 0, alphai[c2], nbDistSample)) * mat[c2][dt][0]
return L
def cvx_problem_23(a_r, q_r, p_r, d, I):
"""
Convex optimization for problem 23
:param a_r: _a_ list in the last iteration
:type a_r: [1, UAV_num] * N (list)
:param q_r: trajectory in the last iteration
:type q_r: [dim, UAV_num] * N (list)
:param p_r: power vectors in the last iteration
:type p_r: [1, UAV_num] * N (list)
:param I: I in the last iteration
:type I: [1, UAV_num] * N (list)
:param d: distance matrices in the last iteration
:type d: [UAV_num, UAV_num] * N (list)
:return: a^{r+1}, q^{r+1}
"""
a = [cp.Variable(1, UAV_num)] * sample_num
q = [cp.Variable((dim, UAV_num))] * sample_num
obj_func = []
for n in range(sample_num):
for k in range(UAV_num):
term1 = 1
for j in range(UAV_num):
term1 += y * (2 * a_r[n][j]) / d[n][j][k] - p_r[n][j] * (
cp.norm(q[n][j] - s[k])**2) / (d[n][j][k]**2)
obj_func.append(cp.log(term1))
obj_func.append(-1 * cp.log(I[n][k] + 1) + I[n][k] / (1 + I[n][k]))
term2 = 0
for j in range(UAV_num):
if j != k:
j += cp.square(a[n][j]) / (d[n][j][k] + 2 * np.transpose(
(q_r[n][j] - s[k])) * (q[n][j] - q_r[n][j]))
obj_func.append(-1 * term2 * y / (1 + I[n][k]))
# TODO: add constraints
constr = []
for n in range(sample_num):
pass
prob = cp.Problem(cp.Maximize(cp.sum(obj_func)))
prob.solve()
return a, q
def __init__(self, returns, indexReturns, regularizer, i):
#initiate a problem with data
numAssets = returns.shape[1]
self.x = cvx.Variable(numAssets)
self.index = i
self.t = cvx.Variable()
baseConstraints = [self.x >= 0, self.t >= 0, sum(self.x) == 1]
#should have a check to see if i is in the range of num of assets
constraints = baseConstraints + [
cvx.log(self.x[i]) + cvx.log(self.t) >= cvx.log(regularizer)
]
TrackingErrorSquared = cvx.sum_squares(returns * self.x - indexReturns)
obj = cvx.Minimize(TrackingErrorSquared + self.t)
cvx.Problem.__init__(self, obj, constraints)
def get_underapprox_box_vol(activation_pattern, weights, biases, min_val,
max_val, additional_constraints, epsilon):
def get_w_t_x(weight_vector):
w_t_x = []
num_inputs = len(weight_vector)
for i in range(num_inputs):
coeff = weight_vector[i]
if coeff >= 0:
w_t_x.append(coeff * var_high[i])
else:
w_t_x.append(coeff * var_low[i])
return w_t_x
num_inputs = weights[0].shape[1]
var_low = cp.Variable(num_inputs)
var_high = cp.Variable(num_inputs)
constraints = []
for i in range(num_inputs):
d_low = var_low[i]
d_high = var_high[i]
constraints.append(d_low >= min_val)
constraints.append(d_high <= max_val)
constraints.append(d_high - d_low >= 0)
for layer_id, layer in enumerate(activation_pattern):
weight_matrix = weights[layer_id]
bias_vector = biases[layer_id]
for neuron_id, neuron in enumerate(layer):
if neuron == 2:
continue
weight_vector = weight_matrix[neuron_id]
b = bias_vector[neuron_id]
if neuron == 0:
w_t_x = get_w_t_x(weight_vector)
constraints.append(cp.sum(w_t_x) <= -1 * b)
elif neuron == 1:
w_t_x = get_w_t_x(-1 * weight_vector)
constraints.append(cp.sum(w_t_x) <= (b - UPPER_THRESH))
for constraint_id, constraint in enumerate(additional_constraints):
diff_weight, diff_bias = constraint
w_t_x = get_w_t_x(-1 * diff_weight)
rhs = -1 * epsilon + diff_bias - UPPER_THRESH
constraints.append(cp.sum(w_t_x) <= rhs)
obj = cp.Maximize(cp.sum(cp.log(var_high - var_low)))
prob = cp.Problem(obj, constraints)
# print (prob)
prob.solve(solver='ECOS')
result = prob.status
print(result)
under_approx_box = []
if result == cp.INFEASIBLE:
for i in range(num_inputs):
under_approx_box.append((0, 0))
return under_approx_box, -np.inf
assert result == cp.OPTIMAL, "The under-approximate constraint problem fails to give optimal solution"
sol_low = var_low.value
sol_high = var_high.value
for i in range(num_inputs):
under_approx_box.append((sol_low[i], sol_high[i]))
log_volume = np.sum(np.log(sol_high - sol_low + 1e-8))
return under_approx_box, log_volume
def SBvG_path(X, y, lambda_grid, solver='SCS'):
"""
solve:
min - log(rho) + 1/(2n) ||rho y - x phi||^2_2 + lambda_ ||phi||_1
for lambda in lambda_grid
"""
import cvxpy as cvx # nested import to make it optional
n_samples, n_featuresures = X.shape
lambda_ = cvx.Parameter(sign="Positive")
phi = cvx.Variable(n_featuresures)
rho = cvx.Variable(1)
objective = \
cvx.Minimize(- cvx.log(rho) +
cvx.sum_squares(rho * y - X * phi) / (2. * n_samples) +
lambda_ * cvx.norm(phi, 1))
prob = cvx.Problem(objective)
betas = np.zeros((len(lambda_grid), n_featuresures))
sigmas = np.zeros(len(lambda_grid))
for i, l in enumerate(lambda_grid):
lambda_.value = l
prob.solve(solver=solver)
this_sigma = 1. / rho.value
sigmas[i] = this_sigma
betas[i] = np.ravel(this_sigma * phi.value)
return np.array(betas), np.array(sigmas)
def _optimize(self, optimize_array, solver=cp.SCS):
"""
Calculates weights that maximize returns over the given array.
:param optimize_array: (np.array) Relative returns of the assets for a given time period.
:param solver: (cp.solver) Solver for cvxpy
:return: (np.array) Weights that maximize the returns for the given array.
"""
# Initialize weights for the optimization problem.
weights = cp.Variable(self.number_of_assets)
# Use cp.log and cp.sum to make the cost function a convex function.
# Multiplying continuous returns equates to summing over the log returns.
portfolio_return = cp.sum(cp.log(optimize_array @ weights))
# Optimization objective and constraints.
allocation_objective = cp.Maximize(portfolio_return)
allocation_constraints = [cp.sum(weights) == 1, cp.min(weights) >= 0]
# Define and solve the problem.
problem = cp.Problem(objective=allocation_objective,
constraints=allocation_constraints)
# Solve and return the resulting weights.
problem.solve(warm_start=True, solver=solver)
return weights.value
def remove_dc_from_spad_poisson(noisy_spad, bin_edges, lam=1e-1):
assert len(noisy_spad.shape) == 1
C = noisy_spad.shape[0]
assert bin_edges.shape == (C + 1, )
bin_widths = bin_edges[1:] - bin_edges[:-1]
spad_equalized = noisy_spad / bin_widths
orig_sum = np.sum(spad_equalized)
spad_normalized = spad_equalized / orig_sum
x = cp.Variable((C, ), "signal")
z = cp.Variable((1, ), "dc")
obj = -spad_normalized*cp.log(z + x) + cp.sum(z + x) + \
lam*cp.norm(x, 2)
# lam*cp.sum_squares(x)
# lam*cp.square(cp.norm(cp.multiply(bin_weight, x), 2))
# obj = -spad_equalized*cp.log(z + x) + cp.sum(z + x) + lam*cp.sum_squares(x)
constr = [z >= 0, x >= 0]
prob = cp.Problem(cp.Minimize(obj), constr)
prob.solve(verbose=False, gp=False)
# noise = np.exp(z.value)
# signal = np.exp(x.value)
noise = z.value
signal = x.value
# zero_out = x.value
# zero_out[zero_out < 1e0] = 0.
frac = orig_sum * np.sum(signal) / (np.sum(signal) +
len(spad_equalized) * noise)
denoised_spad = np.clip(frac * signal * bin_widths, a_min=0., a_max=None)
return denoised_spad
def constr(self, x, phi, log_cash):
def to_constant(x):
"""return violation if constant, constraint if variable"""
return -x.value if x.is_constant() else x >= 0
return [to_constant(cvx.log(x[g]) - np.log(a) + phi[g] - log_cash)
for g, a in self.a.iteritems()]
def optimize(self, beta_c, beta_d, weight):
'''
creates the objective function of the optimization problem!
'''
n = self.window[1] - self.window[0] + 1
p = cvx.Variable((n, 1))
z = cvx.Variable(1)
d = np.array([list(np.arange(1, n, 1))]).T
expr = (1.0 / beta_c) * (
cvx.sum(-1 * cvx.entr(p[1:, [0]]) -
beta_d * cvx.multiply(d, p[1:, [0]]))) - (1.0 / beta_c) * (
cvx.log(p[0, [0]]) + cvx.entr(p[0, [0]])) + weight * z
obj = cvx.Minimize(expr)
constraints = [cvx.sum(p) == 1, p >= 0, p <= 1, z >= 0]
for key, timePt in enumerate(
list(np.arange(self.window[0], self.window[1], 1))):
deltaPost = self.nowSt * cvx.sum(
p[:key + 1 + 1, [0]]) - self.nowE * cvx.sum(
cvx.multiply(self.Glists[timePt + 1], p[:key + 1 + 1,
[0]]))
deltaPre = self.nowSt * cvx.sum(
p[:key + 1, [0]]) - self.nowE * cvx.sum(
cvx.multiply(self.Glists[timePt], p[:key + 1, [0]]))
cexp = (self.load[timePt + 1] + deltaPost) - (self.load[timePt] +
deltaPre)
constraints = constraints + [cexp <= z]
for key, timePt in enumerate(
list(np.arange(self.window[0] + 1, self.window[1] + 1, 1))):
cexp2 = p[key + 1, [0]] - np.exp(beta_d * (key + 1)) * p[0, [0]]
constraints = constraints + [cexp2 >= 0]
prob = cvx.Problem(obj, constraints)
prob.solve()
return p.value, z.value, prob.status, prob.value
def objective_given_probs(dfProb, w, ret):
'''objective_given_probs is a helper function for optimal_bet_given_probs: returns the expected log return for a set of bets and probabilites of winning the bets
INPUTS:
dfProb: pandas df, should have 1 column, values should be probability of winning bets
w: cvxpy variable object, should be numBets x 1 in length
ret: return of a winning bet, should be 1-vig
Outputs:
obj: cvxpy expression, calculation of the expected log return for that set of bets
'''
numBets = dfProb.shape[0]
inds = [x for x in range(dfProb.shape[0])]
obj = 0.
#Iterate over all possible combinations
for r in range(numBets + 1):
for comb in itertools.combinations(inds, r=r):
prob = 0.
trues = np.zeros((numBets, 1))
for i in range(numBets):
if i in comb:
prob = prob + math.log(dfProb.values[i][0])
trues[i] = 1
else:
prob = prob + math.log(1 - dfProb.values[i][0])
prob = math.exp(prob)
#now add the the return for this combination
obj = obj + prob * (cp.log(1 + ret * cp.matmul(w.T, trues) -
cp.matmul(w.T, 1 - trues)))
return obj
def max_power_sum_allocation(instance, power:float) -> Allocation:
"""
Find the maximum of sum of utility to the given power.
* When power=1, it is equivalent to max-sum;
* When power -> 0, it converges to max-product;
* When power -> -infinity, it converges to leximin.
:param agents: a matrix v in which each row represents an agent, each column represents an object, and v[i][j] is the value of agent i to object j.
:return allocation_matrix: a matrix alloc of a similar shape in which alloc[i][j] is the fraction allocated to agent i from object j.
The allocation should maximize the product (= sum of logs) of utilities
>>> max_power_sum_allocation([ [3] , [5] ], 1).round(3).matrix
[[0.]
[1.]]
>>> max_power_sum_allocation([ [3] , [5] ], 0.1).round(3).matrix
[[0.486]
[0.514]]
>>> max_power_sum_allocation([ [3] , [5] ], 0).round(3).matrix
[[0.5]
[0.5]]
>>> max_power_sum_allocation([ [3] , [5] ], -0.1).round(3).matrix
[[0.512]
[0.488]]
>>> max_power_sum_allocation([ [3] , [5] ], -1).round(3).matrix
[[0.564]
[0.436]]
"""
if power>0:
welfare_function=lambda utilities: sum([utility**power for utility in utilities])
elif power<0:
welfare_function=lambda utilities: -sum([utility**power for utility in utilities])
else:
welfare_function=lambda utilities: sum([cvxpy.log(utility) for utility in utilities])
return max_welfare_allocation(instance,
welfare_function=welfare_function,
welfare_constraint_function=lambda utility: utility >= 0)
def construct_problem(self, mcrst):
actions = self.container[mcrst].keys()
ordered_actions = sorted(actions, reverse=True)
arriving_mcrst = self.calculate_arriving_mcrst_list(
mcrst) # list of indexes related to the arriving mcrsts.
I = self.fill_I(mcrst, ordered_actions
) # every row is ordered according to ordered_actions.
theta = cp.Variable((len(actions), self.i), nonneg=True)
objective = cp.Minimize(-cp.sum(cp.multiply(I, cp.log(theta))))
constraints = []
# Sum of rows must be equal to 1.
for k in range(len(actions)):
constraints.append(cp.sum(theta[k]) == 1)
# Lipschitz hypothesis between actions.
for i in range(len(actions) - 1):
for k2 in arriving_mcrst:
constraints.append(
theta[i][k2] - theta[i + 1][k2] <= self.L *
abs(ordered_actions[i] - ordered_actions[i + 1]))
constraints.append(
theta[i][k2] - theta[i + 1][k2] >= -self.L *
abs(ordered_actions[i] - ordered_actions[i + 1]))
problem = cp.Problem(objective, constraints)
return problem
def solve_s(xi, x_0, N, solver=None):
s = cvx.Variable(N)
obj = cvx.Maximize(cvx.sum_entries(cvx.log(x_0 + xi.T * s)))
constr = [0 <= s]
prob = cvx.Problem(obj, constr)
prob.solve(solver=solver)
return np.array(s.value).T[0]
def test_partial_problem(self) -> None:
"""Test domain for partial minimization/maximization problems.
"""
for obj in [Minimize((self.a)**-1), Maximize(cp.log(self.a))]:
orig_prob = Problem(obj, [self.x + self.a >= [5, 8]])
# Optimize over nothing.
expr = partial_optimize(orig_prob, dont_opt_vars=[self.x, self.a])
dom = expr.domain
constr = [self.a >= -100, self.x >= 0]
prob = Problem(Minimize(sum(self.x + self.a)), dom + constr)
prob.solve(solver=cp.SCS, eps=1e-6)
self.assertAlmostEqual(prob.value, 13)
assert self.a.value >= 0
assert np.all((self.x + self.a - [5, 8]).value >= -1e-3)
# Optimize over x.
expr = partial_optimize(orig_prob, opt_vars=[self.x])
dom = expr.domain
constr = [self.a >= -100, self.x >= 0]
prob = Problem(Minimize(sum(self.x + self.a)), dom + constr)
prob.solve(solver=cp.ECOS)
self.assertAlmostEqual(prob.value, 0)
assert self.a.value >= -1e-3
self.assertItemsAlmostEqual(self.x.value, [0, 0])
# Optimize over x and a.
expr = partial_optimize(orig_prob, opt_vars=[self.x, self.a])
dom = expr.domain
constr = [self.a >= -100, self.x >= 0]
prob = Problem(Minimize(sum(self.x + self.a)), dom + constr)
prob.solve(solver=cp.ECOS)
self.assertAlmostEqual(self.a.value, -100)
self.assertItemsAlmostEqual(self.x.value, [0, 0])
def pcp_4(ceei: bool = True):
"""
A power cone formulation of a Fisher market equilibrium pricing model.
ceei = Competitive Equilibrium from Equal Incomes
"""
# Generate test data
np.random.seed(0)
n_buyer = 4
n_items = 6
V = np.random.rand(n_buyer, n_items)
X = cp.Variable(shape=(n_buyer, n_items), nonneg=True)
u = cp.sum(cp.multiply(V, X), axis=1)
if ceei:
b = np.ones(n_buyer) / n_buyer
else:
b = np.array([0.3, 0.15, 0.2, 0.35])
log_objective = cp.Maximize(cp.sum(cp.multiply(b, cp.log(u))))
log_cons = [cp.sum(X, axis=0) <= 1]
log_prob = cp.Problem(log_objective, log_cons)
log_prob.solve(solver='SCS', eps=1e-8)
expect_X = X.value
z = cp.Variable()
pow_objective = (cp.Maximize(z), np.exp(log_prob.value))
pow_cons = [(cp.sum(X, axis=0) <= 1, None),
(PowConeND(W=u, z=z, alpha=b), None)]
pow_vars = [(X, expect_X)]
sth = STH.SolverTestHelper(pow_objective, pow_vars, pow_cons)
return sth
def water_filling(n,a,sum_x=1):
'''
Boyd and Vandenberghe, Convex Optimization, example 5.2 page 145
Water-filling.
This problem arises in information theory, in allocating power to a set of
n communication channels in order to maximise the total channel capacity.
The variable x_i represents the transmitter power allocated to the ith channel,
and log(α_i+x_i) gives the capacity or maximum communication rate of the channel.
The objective is to minimize -∑log(α_i+x_i) subject to the constraint ∑x_i = 1
'''
# Declare variables and parameters
x = cvx.Variable(n)
alpha = cvx.Parameter(n,sign='positive')
alpha.value = a
#alpha.value = np.ones(n)
# Choose objective function. Interpret as maximising the total communication rate of all the channels
obj = cvx.Maximize(cvx.sum_entries(cvx.log(alpha + x)))
# Declare constraints
constraints = [x >= 0, cvx.sum_entries(x) - sum_x == 0]
# Solve
prob = cvx.Problem(obj, constraints)
prob.solve()
if(prob.status=='optimal'):
return prob.status,prob.value,x.value
else:
return prob.status,np.nan,np.nan
def setup_class(self):
self.cvx = Variable()**2
self.ccv = Variable()**0.5
self.aff = Variable()
self.const = Constant(5)
self.unknown_curv = log(Variable()**3)
self.pos = Constant(1)
self.neg = Constant(-1)
self.zero = Constant(0)
self.unknown_sign = Parameter()
def kliep_learning(phi_te, phi_tr):
"""
solve the convex optimization problem using cvxpy
phi_te is kernel of test samples
phi_tr is kernel of training samples
"""
x = cvx.Variable(phi_te.shape[1])
objective = cvx.Maximize(cvx.sum_entries(cvx.log(phi_te*x)))
constraints = [cvx.sum_entries(phi_tr*x) == phi_tr.shape[0], x>=0]
prob = cvx.Problem(objective, constraints)
prob.solve()
return prob, x
def solveProblem(self):
x = cvx.Variable(self.numAssets)
t = cvx.Variable()
#optimalIndex = -1
optimalVal = np.float('inf')
optimalT = np.float('inf')
optimalSol = np.array([])
TrackingErrorSquared = cvx.sum_squares(self.returns*x -self.indexReturns )
obj = cvx.Minimize( TrackingErrorSquared+t)
baseConstraints = [x>=0,t>=0,sum(x)==1]
for i in range(self.numAssets):
constraints = baseConstraints+ [cvx.log(x[i])+cvx.log(t)>= cvx.log(self.regularizer)]
prob = cvx.Problem(obj,constraints)
prob.solve()
print("solved Problem %i. Optimal value: %s" % (i,prob.value))
card = np.sum([np.array(x.value).reshape(-1,) > self.threshold])
print("the cardinality of the solution is %s" % str(card))
upperBound = prob.value - t.value + self.regularizer*card
print("the upper bound of the solution is %s" % str(upperBound))
#update the upper bound
if upperBound < self.UpperBound:
self.UpperBound = upperBound
#update the lower bound
if prob.value < optimalVal:
optimalVal = prob.value
optimalSol = x.value
optimalT = t.value
self.OptimalValue = optimalVal
self.OptimalWeights = np.array(optimalSol).reshape(-1,)
self.t = optimalT
self.TrackingErrorSquared = self.OptimalValue - optimalT
def constr(self, x, phi, log_cash):
#compute expr1 just once to save time. not sure if this is true, though
expr1 = cvx.log(self.eval(x))
def to_constant(x):
"""
return violation if constant, constraint if variable"""
return -x.value if x.is_constant() else x >= 0
tmp = [to_constant(expr1 - np.log(a) + phi[g] - log_cash)
for g, a in izip(self.goods, self.a)]
return tmp
def check_center(val):
global obj_func, constr
res = True #common point was found
for ball in balls:
diff = np.subtract(ball[0], val)
if res:
diff_len = np.linalg.norm(diff)
if diff_len > ball[1]: #current point doesn't belong to this ball
p = sum(diff * val)
constr.append(diff * center >= p) #add cutting plane
obj_func += cvx.log(diff * center - p)
res = False #next we check if this plane intersects with other balls
else:
if sum(diff * val) - p + diff_len * ball[1] < 0: return None #no intersection
return res
def Hawkes_log_lik(T, alpha_opt, lambda_opt, lambda_ti, survival, for_cvx=False):
# The implementation has to be different for CVX and numpy versions because
# CVX variables cannot handle the vectorized operations of Numpy like
# np.sum and np.log.
L = 0
for i in range(len(lambda_ti)):
if for_cvx and len(lambda_ti) > 0:
L += CVX.sum_entries(CVX.log(lambda_opt + alpha_opt * lambda_ti[i]))
else:
L += np.sum(np.log(lambda_opt + alpha_opt * lambda_ti[i]))
L -= lambda_opt * T[i] + alpha_opt * survival[i]
return L
def form_agent_constr0(A, logB, x, phi):
""" This formulation seems to reduce the number of
variables, constraints, and NNZ in the A matrix.
"""
m,n = A.shape
constr = []
for i in range(m):
logcash = cvx.log_sum_exp(phi + logB[i,:])
ag_exp = cvx.log(x[i,:]*A[i,:]) - logcash
t = cvx.Variable()
constr += [ag_exp >= t]
for j in range(n):
expr = t >= np.log(A[i,j]) - phi[j]
constr += [expr]
return constr
def test_consistency(self):
"""Test case for non-deterministic behavior in cvxopt.
"""
import cvxpy
xs = [0, 1, 2, 3]
ys = [51, 60, 70, 75]
eta1 = cvxpy.Variable()
eta2 = cvxpy.Variable()
eta3 = cvxpy.Variable()
theta1s = [eta1 + eta3 * x for x in xs]
lin_parts = [theta1 * y + eta2 * y ** 2 for (theta1, y) in zip(theta1s, ys)]
g_parts = [-cvxpy.quad_over_lin(theta1, -4 * eta2) + 0.5 * cvxpy.log(-2 * eta2) for theta1 in theta1s]
objective = reduce(lambda x, y: x + y, lin_parts + g_parts)
problem = cvxpy.Problem(cvxpy.Maximize(objective))
problem.solve(verbose=True, solver=cvxpy.SCS)
assert problem.status == cvxpy.OPTIMAL, problem.status
return [eta1.value, eta2.value, eta3.value]
def foo_prox(a, b, x0, phi0, rho):
n = len(a)
x = cvx.Variable(n)
phi = cvx.Variable(n)
logb = np.log(b)
logcash = cvx.log_sum_exp(phi + logb)
ag_exp = cvx.log(x.T*a) - logcash
t = cvx.Variable()
constr = [x >= 0, ag_exp >= t]
for j in range(n):
expr = t >= np.log(a[j]) - phi[j]
constr += [expr]
obj = cvx.sum_squares(x-x0) + cvx.sum_squares(phi-phi0)
obj = obj*rho/2.0
prob = cvx.Problem(cvx.Minimize(obj), constr)
prob.solve(verbose=False, solver='ECOS')
return np.array(x.value).flatten(), np.array(phi.value).flatten()
def solveProblemWithClustering(self,n_clusters):
x = cvx.Variable(self.numAssets)
t = cvx.Variable()
optimalVal = np.float('inf')
optimalT = np.float('inf')
optimalSol = np.array([])
TrackingErrorSquared = cvx.sum_squares(self.returns*x -self.indexReturns )
obj = cvx.Minimize( TrackingErrorSquared+t)
constraints = [x>=0,t>=0,sum(x)==1,cvx.log(x[0])+cvx.log(t)>= cvx.log(self.regularizer)]
prob = cvx.Problem(obj,constraints)
labels = self._clusterReturns(n_clusters)
#loop through clusters, solve problem in each cluster
for index in range(n_clusters):
print("In cluster %i" % index)
cluster = np.where(labels==index)[0]
for i in cluster:
#warm start solve remaining problems in cluster
#update constraints
prob.constraints[-1] = cvx.log(x[i])+cvx.log(t)>= cvx.log(self.regularizer)
prob.solve(warm_start= True)
print("solved Problem %i. Optimal value: %s" % (i,prob.value))
optimalVal = prob.value
optimalSol = x.value
optimalT = t.value
if prob.value < optimalVal:
#optimalIndex = i
optimalVal = prob.value
optimalSol = x.value
optimalT = t.value
self.OptimalValue = optimalVal
self.OptimalWeights = np.array(optimalSol).reshape(-1,)
self.t = optimalT
self.TrackingErrorSquared = self.OptimalValue - optimalT
## part 1
acc_df_lp_center_stats, df_op = run_lp_center(A, b, c, x0.copy())
image_path = image_dir +'lp_-_part_1_-_centering.png'
_plot_lp_center(acc_df_lp_center_stats, df_op, image_path)
## compare against cvxpy
x = cvxpy.Variable(n,name='x')
A1 = cvxopt.matrix(A)
c1 = cvxopt.matrix(c)
ones = cvxopt.matrix(np.ones(n))
b1 = cvxpy.Variable(b.shape[0],name='b')
objective = cvxpy.Minimize(
c1.T*x -ones.T*cvxpy.log(x)
)
constraints = [A1*x == b1]
prob = cvxpy.Problem(objective,constraints)
p_star_1 = prob.solve()
acc_stats = []
for _, row in df_op.iterrows():
x_star, nu_star = row[['x_star','nu_star']]
in_domain = all(x_star > 0) # ie. in domain of objective
### check kkt conditions
## primal feasible (equality)
p_f_eq = np.allclose(np.dot(A,x_star),b)
import numpy as np
import cvxpy as cvx
m = 7 #number of balls
n = 4 #dimension of space, >= 2
def rand_ball(): return (np.random.uniform(0,4,n), 3) #center and radius
balls = [rand_ball() for i in range(m)] #you can specify your own balls here
box = max(ball[1]+abs(ball[0][i]) for i in range(n) for ball in balls) #half-size of the first container
center = cvx.Variable(n)
obj_func = sum(cvx.log(box + j * center[i]) for j in (-1,1) for i in range(n)) #logarithmic barriers
constr = [j * center[i] <= box for j in (-1,1) for i in range(n)] #define the domain of the objective
def check_center(val):
global obj_func, constr
res = True #common point was found
for ball in balls:
diff = np.subtract(ball[0], val)
if res:
diff_len = np.linalg.norm(diff)
if diff_len > ball[1]: #current point doesn't belong to this ball
p = sum(diff * val)
constr.append(diff * center >= p) #add cutting plane
obj_func += cvx.log(diff * center - p)
res = False #next we check if this plane intersects with other balls
else:
if sum(diff * val) - p + diff_len * ball[1] < 0: return None #no intersection
return res
val = np.zeros(n) #first iteration is obvious
for i in range(100): #prevent infinite loop
ok = check_center(val)
if ok != False: break #yeah!
obj = cvx.Maximize(obj_func)
prob = cvx.Problem(obj, constr)
[3.5000, 0.9900, 0.9700, 0.9800, 1.0100],
]
)
(m, n) = P.shape
x_unif = np.ones((n, 1)) / n
###################################################
## Insert the code
pi = np.ones((m, 1)) / m
y = cp.Variable(m)
x = cp.Variable(n)
constraints1 = [y == P * x]
constraints2 = [x >= 0, np.ones((1, n)) * x == 1]
constraints = constraints1 + constraints2
objective = cp.Minimize(-pi.T * cp.log(y))
pro = cp.Problem(objective, constraints)
pro.solve()
Rit = pi.T * np.log(P * x.value)
print x.value
print Rit
R_unif = pi.T * np.log(P * x_unif)
print x_unif
print R_unif
###################################################
N = 10
T = 200
w_opt = []
w_unif = []
# Do this only if the target_node wasn't the first node
# infected in the cascade.
# If it was the first node (else branch), then we cannot deduce
# anything about the incoming edges.
log_sum = 0
for j in range(len(c)):
t_j = c[j][0]
alpha_ji = Ai[c[j][1]]
if t_j < t_i:
# TODO
# expr += ...
# log_sum += ...
pass
expr += CVX.log(log_sum)
prob = CVX.Problem(CVX.Maximize(expr), constraints)
res = prob.solve(verbose=True)
probs.append(prob)
results.append(res)
if prob.status in [CVX.OPTIMAL, CVX.OPTIMAL_INACCURATE]:
A[:, target_node] = np.asarray(Ai.value).squeeze()
else:
A[:, target_node] = -1
A_soln = np.loadtxt('solution.csv', delimiter=',')
print(U.calc_score(A, A_soln))
def cvx_eval(self, x):
return sum(a*cvx.log(x[g]) for g, a in self.a.iteritems())
tau_1 = cvx.Variable(N) #tau_2 = cvx.Variable(N) tau_2 = np.zeros(N) print tau_2, b print b.shape, tau_2.shape #inv_alpha_1 = cvx.Variable(1) inv_alpha_1 = 0.5 # specify objective function #obj = cvx.Minimize(-cvx.sum_entries(cvx.log(tau_1)) - cvx.log_det(A - cvx.diag(tau_1))) #obj = cvx.Minimize(-cvx.sum_entries(cvx.log(tau_1)) - cvx.log_det(A - cvx.diag(tau_1))) # original #obj = cvx.Minimize( 0.5*N*(inv_alpha_1-1)*log_2_pi - 0.5*inv_alpha_1*(N*cvx.log(1/inv_alpha_1) + cvx.sum_entries(cvx.log(tau_1))) + 0.5*cvx.sum_entries(cvx.square(tau_2)/tau_1) + inv_alpha_1*cvx.sum_entries(log_normcdf(tau_2*cvx.sqrt(1/(inv_alpha_1*tau_1)))) +0.5*N*(1-inv_alpha_1)*cvx.log(1-inv_alpha_1) -0.5*(1-inv_alpha_1)*cvx.log_det(A-cvx.diag(tau_1)) + 0.5*cvx.matrix_frac(b-tau_2, A-cvx.diag(tau_1)) ) # modifications #obj = cvx.Minimize( 0.5*N*(inv_alpha_1-1)*log_2_pi - 0.5*inv_alpha_1*(-N*cvx.log(inv_alpha_1) + cvx.sum_entries(cvx.log(tau_1))) + 0.5*cvx.matrix_frac(tau_2, cvx.diag(tau_1)) + inv_alpha_1*cvx.sum_entries(log_normcdf(tau_2.T*cvx.inv_pos(cvx.sqrt(inv_alpha_1*tau_1)))) +0.5*N*(1-inv_alpha_1)*cvx.log(1-inv_alpha_1) -0.5*(1-inv_alpha_1)*cvx.log_det(A-cvx.diag(tau_1)) + 0.5*cvx.matrix_frac(b-tau_2, A-cvx.diag(tau_1)) ) obj = cvx.Minimize( 0.5*N*(inv_alpha_1-1)*log_2_pi - 0.5*inv_alpha_1*(-N*cvx.log(inv_alpha_1) + cvx.sum_entries(cvx.log(tau_1))) + 0.5*cvx.matrix_frac(tau_2, cvx.diag(tau_1)) + cvx.sum_entries(inv_alpha_1*log_normcdf(cvx.inv_pos(cvx.sqrt(inv_alpha_1*tau_1)))) )# +0.5*N*(1-inv_alpha_1)*cvx.log(1-inv_alpha_1) -0.5*(1-inv_alpha_1)*cvx.log_det(A-cvx.diag(tau_1)) + 0.5*cvx.matrix_frac(b-tau_2, A-cvx.diag(tau_1)) ) #def upper_bound_logpartition(tau, inv_alpha_1): # tau_1, tau_2 = tau[:D+N], tau[D+N:] # tau_1_N, tau_2_N = tau_1[D:], tau_2[D:] # first D values correspond to w # alpha_1 = 1.0 / inv_alpha_1 # inv_alpha_2 = 1 - inv_alpha_1 # if np.any(tau_1 <= 0): # integral_1 = INF2 # else: # integral_1 = inv_alpha_1 * (-0.5 * ((D+N)*np.log(alpha_1) + np.sum(np.log(tau_1)) ) \ # + np.sum(norm.logcdf(np.sqrt(alpha_1)*tau_2_N/np.sqrt(tau_1_N)))) \ # + 0.5 * np.sum(np.power(tau_2, 2) / tau_1) # mat = A - np.diag(tau_1) # sign, logdet = np.linalg.slogdet(mat)
def cvx_eval(self, x):
return sum(a*cvx.log(x[g] + b)
for g, a, b in izip(self.goods, self.a, self.b))
1.7095 2.1351 10.1296 4.0931 2.9001 9.9634;\
1.4289 3.5800 9.3459 3.8898 2.7663 15.1383;\
1.3046 3.5610 10.1179 4.3891 7.1302 3.8139;\
1.1897 2.7807 13.0112 4.2426 6.1611 29.6734'
W = np.matrix(W)
(W_min, W_max) = (1.0, 30.0)
# objective values for the different designs
# entry j gives the objective for design j
P = np.matrix('29.0148 46.3369 282.1749 78.5183 104.8087 253.5439')
D = np.matrix('15.9522 11.5012 4.8148 8.5697 8.0870 6.0273')
A = np.matrix('22.3796 38.7908 204.1574 62.5563 81.2272 200.5119')
# specifications
(P_spec, D_spec, A_spec) = (60.0, 10.0, 50.0)
theta = cvx.Variable(k)
obj = cvx.Minimize(0)
constraints = [cvx.log(P)*theta <= cvx.log(P_spec),
cvx.log(D)*theta <= cvx.log(D_spec),
cvx.log(A)*theta <= cvx.log(A_spec),
cvx.sum_entries(theta) == 1, theta >= 0]
prob = cvx.Problem(obj, constraints)
sol = prob.solve()
w = cvx.exp(cvx.log(W)*theta)
print('status: {}'.format(sol))
print('theta: {}'.format(theta.T.value))
print('w: {}'.format(w.T.value))
numAssets = returns.shape[1]
threshold = 1/(float(numAssets*10000))
regularizer = 0.02
for line in sys.stdin:
#Haven't decided how to split the data yet, so I'll just copy this part over from sparseIndex
#One idea is to assign an index to each symbol and have the input data be a list of indices.
line = line.strip()
try:
i = symbols.index(line)
except:
continue
#Solve problem
x = cvx.Variable(numAssets)
t = cvx.Variable()
TrackingErrorSquared = cvx.sum_squares(returns*x - indexReturns)
obj = cvx.Minimize( TrackingErrorSquared+t)
baseConstraints = [x>=0,t>=0,sum(x)==1]
constraints = baseConstraints+ [cvx.log(x[i])+cvx.log(t)>= cvx.log(regularizer)]
prob = cvx.Problem(obj,constraints)
prob.solve()
card = np.sum([np.array(x.value).reshape(-1,) > threshold])
upperBound = prob.value - t.value + regularizer*card
optimalWeights = str(np.array(x.value).reshape(-1,))
optimalWeights = re.sub('\n','',optimalWeights)
#optimalVal,optimalT,card,upperBound,optimalWeights
optimalWeights = re.sub('\[ {1,}','[',optimalWeights)
optimalWeights = re.sub('\s+',',',optimalWeights)
#Need dummy val to ensure that the correct reducer gets the values.
print "1\t{0}\t{1}\t{2}\t{3}\t{4}".format(prob.value,t.value,card,upperBound,optimalWeights)
from cvxpy import Variable, Problem, Minimize, log
import cvxopt
cvxopt.solvers.options['show_progress'] = False
# create problem data
m, n = 5, 10
A = cvxopt.normal(m,n)
tmp = cvxopt.uniform(n,1)
b = A*tmp
x = Variable(n)
p = Problem(
Minimize(-sum(log(x))),
[A*x == b]
)
status = p.solve()
cvxpy_x = x.value
def acent(A, b):
m, n = A.size
def F(x=None, z=None):
if x is None: return 0, cvxopt.matrix(1.0, (n,1))
if min(x) <= 0.0: return None
f = -sum(cvxopt.log(x))
Df = -(x**-1).T
if z is None: return f, Df
H = cvxopt.spdiag(z[0] * x**-2)
return f, Df, H
sol = cvxopt.solvers.cp(F, A=A, b=b)
def barrier_fcn_cvxpy(z, bm_minimizer):
return -1.0 * cvx.sum_entries(cvx.log(-1.0 * lin_ineq(z, bm_minimizer)))
