def test_objective(self):
"""Test objectives.
"""
x = Variable(complex=True)
with self.assertRaises(Exception) as cm:
Minimize(x)
self.assertEqual(str(cm.exception), "The 'minimize' objective must be real valued.")
with self.assertRaises(Exception) as cm:
cvx.Maximize(x)
self.assertEqual(str(cm.exception), "The 'maximize' objective must be real valued.")
def test_geo_mean(self) -> None:
"""Test domain for geo_mean
"""
dom = cp.geo_mean(self.x).domain
prob = Problem(Minimize(sum(self.x)), dom)
prob.solve(solver=cp.SCS, eps=1e-5)
self.assertAlmostEqual(prob.value, 0)
# No special case for only one weight.
dom = cp.geo_mean(self.x, [0, 2]).domain
dom.append(self.x >= -1)
prob = Problem(Minimize(sum(self.x)), dom)
prob.solve(solver=cp.SCS, eps=1e-5)
self.assertItemsAlmostEqual(self.x.value, [-1, 0])
dom = cp.geo_mean(self.z, [0, 1, 1]).domain
dom.append(self.z >= -1)
prob = Problem(Minimize(sum(self.z)), dom)
prob.solve(solver=cp.SCS, eps=1e-5)
self.assertItemsAlmostEqual(self.z.value, [-1, 0, 0])
def run_process(f, pipe):
xbar = Parameter(n, value=np.zeros(n))
u = Parameter(n, value=np.zeros(n))
f += (rho/2)*sum_squares(x - xbar + u)
prox = Problem(Minimize(f))
# ADMM loop.
while True:
prox.solve()
pipe.send(x.value)
xbar.value = pipe.recv()
u.value += x.value - xbar.value
def test_choose(self):
x = Variable(5,4)
p = Problem(Minimize(sum(1-x) + sum(x)),
[x == Choose(5,4,k=4)])
result = p.solve(method="admm", solver=CVXOPT)
self.assertAlmostEqual(result, 20)
for i in range(x.size[0]):
for j in range(x.size[1]):
v = x.value[i, j]
self.assertAlmostEqual(v*(1-v), 0)
self.assertAlmostEqual(x.value.sum(), 4)
def solveX(data):
a = data[0:3]
u = data[3:6]
z = data[6:9]
rho = data[9]
x = Variable(3, 1)
g = square(norm(x - a)) + rho / 2 * square(norm(x - z + u))
objective = Minimize(g)
p = Problem(objective, [])
result = p.solve()
return x.value
def sparse_system(self, solver):
m = 100
n = 80
np.random.seed(1)
density = 0.4
A = sp.rand(m, n, density)
b = np.random.randn(m)
p = Problem(Minimize(sum_squares(A @ self.xs - b)), [self.xs == 0])
self.solve_QP(p, solver)
self.assertAlmostEqual(b.T.dot(b), p.value, places=4)
def test_affine_atoms_canon(self):
"""Test canonicalization for affine atoms.
"""
# Scalar.
x = Variable()
expr = cvx.imag(x + 1j * x)
prob = Problem(Minimize(expr), [x >= 0])
result = prob.solve()
self.assertAlmostEqual(result, 0)
self.assertAlmostEqual(x.value, 0)
x = Variable(imag=True)
expr = 1j * x
prob = Problem(Minimize(expr), [cvx.imag(x) <= 1])
result = prob.solve()
self.assertAlmostEqual(result, -1)
self.assertAlmostEqual(x.value, 1j)
x = Variable(2)
expr = x / 1j
prob = Problem(Minimize(expr[0] * 1j + expr[1] * 1j),
[cvx.real(x + 1j) >= 1])
result = prob.solve()
self.assertAlmostEqual(result, -np.inf)
prob = Problem(Minimize(expr[0] * 1j + expr[1] * 1j),
[cvx.real(x + 1j) <= 1])
result = prob.solve()
self.assertAlmostEqual(result, -2)
self.assertItemsAlmostEqual(x.value, [1, 1])
prob = Problem(
Minimize(expr[0] * 1j + expr[1] * 1j),
[cvx.real(x + 1j) >= 1, cvx.conj(x) <= 0])
result = prob.solve()
self.assertAlmostEqual(result, np.inf)
x = Variable((2, 2))
y = Variable((3, 2), complex=True)
expr = cvx.vstack([x, y])
prob = Problem(Minimize(cvx.sum(cvx.imag(cvx.conj(expr)))),
[x == 0, cvx.real(y) == 0,
cvx.imag(y) <= 1])
result = prob.solve()
self.assertAlmostEqual(result, -6)
self.assertItemsAlmostEqual(y.value, 1j * np.ones((3, 2)))
self.assertItemsAlmostEqual(x.value, np.zeros((2, 2)))
x = Variable((2, 2))
y = Variable((3, 2), complex=True)
expr = cvx.vstack([x, y])
prob = Problem(Minimize(cvx.sum(cvx.imag(expr.H))),
[x == 0, cvx.real(y) == 0,
cvx.imag(y) <= 1])
result = prob.solve()
self.assertAlmostEqual(result, -6)
self.assertItemsAlmostEqual(y.value, 1j * np.ones((3, 2)))
self.assertItemsAlmostEqual(x.value, np.zeros((2, 2)))
def calc_Koopman(Yf,Yp,flag=1):
solver_instance = cvxpy.CVXOPT;
#solver_instance = cvxpy.ECOS;
if flag==1: # moore penrose inverse, plain ol' least squares Koopman
#Yp_inv = np.dot(np.transpose(Yp_final), np.linalg.inv( np.dot(Yp_final,np.transpose(Yp_final)) ) );
Yp_inv = np.linalg.pinv(Yp);
K = np.dot(Yf,Yp_inv);
if flag ==2: # cvx optimization approach - L2 + L1 lasso
norm1_term = 0.0;
all_col_handles = [None]*Yf.shape[0]
for i in range(0,Yf.shape[0]):
all_col_handles[i] = Variable(Yf.shape[0],1);
norm1_term = norm1_term + norm2(all_col_handles[i]);
operator = all_col_handles[0];
for i in range(1,Yf.shape[0]):
operator = cvxpy.hstack(operator,all_col_handles[i]);
print "[INFO]: CVXPY Koopman operator variable: " +repr(operator);
print "[INFO]: Yf.shape in calc_Koopman: " + repr(Yf.shape);
norm2_fit_term = norm2(norm2(Yf-operator*Yp,axis=0));
objective = Minimize(norm2_fit_term + norm1_term)
constraints = [];
prob = Problem(objective,constraints);
result = prob.solve(verbose=True,solver=solver_instance);
print "[INFO]: Finished executing cvx solver, printing CVXPY problem status"
print(prob.status);
K = operator.value;
if flag ==3:
operator = Variable(Yf.shape[0],Yf.shape[0])
objective = Minimize(cvxpynorm(operator,2))
constraints = [cvxpynorm(Yf-operator*Yp,'fro')/cvxpynorm(Yf,'fro')<0.01 ]
prob = Problem(objective, constraints)
result = prob.solve(verbose=True)#(solver=solver_instance);
print(prob.status);
K = operator.value;
return K;
def residual(self):
# TODO: The projection should be implemented directly.
from cvxpy import Minimize, Problem, Variable, hstack, norm2
if self.W.value is None or self.z.value is None:
return None
W = Variable(self.W.shape)
z = Variable(self.z.shape)
constr = [PowConeND(W, z, self.alpha, axis=self.axis)]
obj = Minimize(norm2(hstack([W.flatten(), z.flatten()]) -
hstack([self.W.flatten().value, self.z.flatten().value])))
problem = Problem(obj, constr)
return problem.solve(solver='SCS', eps=1e-8)
def quad_over_lin(self, solver):
p = Problem(Minimize(0.5 * quad_over_lin(abs(self.x - 1), 1)),
[self.x <= -1])
self.solve_QP(p, solver)
for var in p.variables():
self.assertItemsAlmostEqual(np.array([-1., -1.]),
var.value,
places=4)
for con in p.constraints:
self.assertItemsAlmostEqual(np.array([2., 2.]),
con.dual_value,
places=4)
def test_probability(self):
b = np.random.randn(self.A.shape[0])
obj = sum_squares(self.A * self.x - b)
cc = ChanceConstraint([self.x <= 0], 0.8)
pc = prob(self.x <= 0) <= 0.8
self.assertEqual(cc.size, pc.size)
self.assertEqual(cc.fraction, pc.fraction)
self.assertEqual(cc.max_violations, pc.max_violations)
self.assertAlmostEqual(
ccprob.Problem(Minimize(obj), [cc]).solve(),
ccprob.Problem(Minimize(obj), [pc]).solve())
cc = ChanceConstraint([self.x >= 0], 0.8)
pc = prob(self.x <= 0) >= 0.2
self.assertEqual(cc.size, pc.size)
self.assertEqual(cc.fraction, pc.fraction)
self.assertEqual(cc.max_violations, pc.max_violations)
self.assertAlmostEqual(
ccprob.Problem(Minimize(obj), [cc]).solve(),
ccprob.Problem(Minimize(obj), [pc]).solve())
def test_partial_optimize_eval_1norm(self):
# Evaluate the 1-norm in the usual way (i.e., in epigraph form).
dims = 3
x, t = Variable(dims), Variable(dims)
xval = [-5]*dims
p1 = Problem(Minimize(sum_entries(t)), [-t<=xval, xval<=t])
p1.solve()
# Minimize the 1-norm via partial_optimize.
p2 = Problem(Minimize(sum_entries(t)), [-t<=x, x<=t])
g = partial_optimize(p2, [t], [x])
p3 = Problem(Minimize(g), [x == xval])
p3.solve()
self.assertAlmostEqual(p1.value, p3.value)
# Try leaving out args.
# Minimize the 1-norm via partial_optimize.
g = partial_optimize(p2, opt_vars=[t])
p3 = Problem(Minimize(g), [x == xval])
p3.solve()
self.assertAlmostEqual(p1.value, p3.value)
# Minimize the 1-norm via partial_optimize.
g = partial_optimize(p2, dont_opt_vars=[x])
p3 = Problem(Minimize(g), [x == xval])
p3.solve()
self.assertAlmostEqual(p1.value, p3.value)
with self.assertRaises(Exception) as cm:
g = partial_optimize(p2)
self.assertEqual(str(cm.exception),
"partial_optimize called with neither opt_vars nor dont_opt_vars.")
with self.assertRaises(Exception) as cm:
g = partial_optimize(p2, [], [x])
self.assertEqual(str(cm.exception),
("If opt_vars and new_opt_vars are both specified, "
"they must contain all variables in the problem.")
)
def test_vector_lp(self):
for solver in self.solvers:
c = Constant(numpy.array([1, 2]))
p = Problem(Minimize(c.T * self.x), [self.x >= c])
result = p.solve(solver.name())
self.assertTrue(ConeMatrixStuffing().accepts(p))
p_new = ConeMatrixStuffing().apply(p)
self.assertTrue(solver.accepts(p_new[0]))
sltn = solve_wrapper(solver, p_new[0])
self.assertAlmostEqual(sltn.opt_val, result)
inv_sltn = ConeMatrixStuffing().invert(sltn, p_new[1])
p_new1 = ConeMatrixStuffing().apply(p)
self.assertTrue(solver.accepts(p_new1[0]))
sltn = solve_wrapper(solver, p_new1[0])
self.assertAlmostEqual(sltn.opt_val, result)
inv_sltn = ConeMatrixStuffing().invert(sltn, p_new1[1])
self.assertAlmostEqual(inv_sltn.opt_val, result)
self.assertItemsAlmostEqual(inv_sltn.primal_vars[self.x.id],
self.x.value)
A = Constant(numpy.array([[3, 5], [1, 2]]).T).value
Imat = Constant([[1, 0], [0, 1]])
p = Problem(Minimize(c.T * self.x + self.a), [
A * self.x >= [-1, 1], 4 * Imat * self.z == self.x,
self.z >= [2, 2], self.a >= 2
])
self.assertTrue(ConeMatrixStuffing().accepts(p))
result = p.solve(solver.name())
p_new = ConeMatrixStuffing().apply(p)
self.assertTrue(solver.accepts(p_new[0]))
sltn = solve_wrapper(solver, p_new[0])
self.assertAlmostEqual(sltn.opt_val, result, places=1)
inv_sltn = ConeMatrixStuffing().invert(sltn, p_new[1])
self.assertAlmostEqual(inv_sltn.opt_val, result, places=1)
for var in p.variables():
self.assertItemsAlmostEqual(inv_sltn.primal_vars[var.id],
var.value,
places=1)
def test_socp(self):
"""Test SOCP problems.
"""
for solver in self.solvers:
# Basic.
p = Problem(Minimize(self.b), [pnorm(self.x, p=2) <= self.b])
pmod = Problem(Minimize(self.b), [SOC(self.b, self.x)])
self.assertTrue(ConeMatrixStuffing().accepts(pmod))
p_new = ConeMatrixStuffing().apply(pmod)
if not solver.accepts(p_new[0]):
return
result = p.solve(solver.name())
sltn = solver.solve(p_new[0], False, False, {})
self.assertAlmostEqual(sltn.opt_val, result)
inv_sltn = ConeMatrixStuffing().invert(sltn, p_new[1])
self.assertAlmostEqual(inv_sltn.opt_val, result)
for var in p.variables():
self.assertItemsAlmostEqual(inv_sltn.primal_vars[var.id],
var.value)
# More complex.
p = Problem(Minimize(self.b), [
pnorm(self.x / 2 + self.y[:2], p=2) <= self.b + 5, self.x >= 1,
self.y == 5
])
pmod = Problem(Minimize(self.b), [
SOC(self.b + 5, self.x / 2 + self.y[:2]), self.x >= 1, self.y
== 5
])
self.assertTrue(ConeMatrixStuffing().accepts(pmod))
result = p.solve(solver.name())
p_new = ConeMatrixStuffing().apply(pmod)
sltn = solver.solve(p_new[0], False, False, {})
self.assertAlmostEqual(sltn.opt_val, result, places=2)
inv_sltn = ConeMatrixStuffing().invert(sltn, p_new[1])
self.assertAlmostEqual(inv_sltn.opt_val, result, places=2)
for var in p.variables():
self.assertItemsAlmostEqual(inv_sltn.primal_vars[var.id],
var.value,
places=2)
def smooth_ridge(self, solver):
numpy.random.seed(1)
n = 500
k = 50
eta = 1
A = numpy.ones((k, n))
b = numpy.ones((k, 1))
obj = sum_squares(A * self.xsr -
b) + eta * sum_squares(self.xsr[:-1] - self.xsr[1:])
p = Problem(Minimize(obj), [])
s = self.solve_QP(p, solver)
self.assertAlmostEqual(0, s.opt_val)
def test_gurobi_time_limit_no_solution(self) -> None:
"""Make sure that if Gurobi terminates due to a time limit before finding a solution:
1) no error is raised,
2) solver stats are returned.
The test is skipped if something changes on Gurobi's side so that:
- a solution is found despite a time limit of zero,
- a different termination criteria is hit first.
"""
from cvxpy import GUROBI
if GUROBI in INSTALLED_SOLVERS:
import gurobipy
objective = Minimize(self.x[0])
constraints = [self.x[0] >= 1]
prob = Problem(objective, constraints)
try:
prob.solve(solver=GUROBI, TimeLimit=0.0)
except Exception as e:
self.fail("An exception %s is raised instead of returning a result." % e)
extra_stats = None
solver_stats = getattr(prob, "solver_stats", None)
if solver_stats:
extra_stats = getattr(solver_stats, "extra_stats", None)
self.assertTrue(extra_stats, "Solver stats have not been returned.")
nb_solutions = getattr(extra_stats, "SolCount", None)
if nb_solutions:
self.skipTest("Gurobi has found a solution, the test is not relevant anymore.")
solver_status = getattr(extra_stats, "Status", None)
if solver_status != gurobipy.StatusConstClass.TIME_LIMIT:
self.skipTest("Gurobi terminated for a different reason than reaching time limit, "
"the test is not relevant anymore.")
else:
with self.assertRaises(Exception) as cm:
prob = Problem(Minimize(norm(self.x, 1)), [self.x == 0])
prob.solve(solver=GUROBI, TimeLimit=0)
self.assertEqual(str(cm.exception), "The solver %s is not installed." % GUROBI)
def rep_quad_form(self, solver) -> None:
"""A problem where the quad_form term is used multiple times.
"""
np.random.seed(0)
A = np.random.randn(5, 5)
z = np.random.randn(5)
P = A.T.dot(A)
q = -2 * P.dot(z)
qf = QuadForm(self.w, P)
p = Problem(Minimize(0.5 * qf + 0.5 * qf + q.T @ self.w))
self.solve_QP(p, solver)
for var in p.variables():
self.assertItemsAlmostEqual(z, var.value, places=4)
def residual(self):
# TODO(akshayka): The projection should be implemented directly.
from cvxpy import Problem, Minimize, Variable, norm2, hstack
if self.x.value is None or self.y.value is None or self.z.value is None:
return None
x = Variable(self.x.shape)
y = Variable(self.y.shape)
z = Variable(self.z.shape)
constr = [ExpCone(x, y, z)]
obj = Minimize(norm2(hstack([x, y, z]) -
hstack([self.x.value, self.y.value, self.z.value])))
problem = Problem(obj, constr)
return problem.solve()
def smooth_ridge(self, solver):
np.random.seed(1)
n = 200
k = 50
eta = 1
A = np.ones((k, n))
b = np.ones((k))
obj = sum_squares(A*self.xsr - b) + \
eta*sum_squares(self.xsr[:-1]-self.xsr[1:])
p = Problem(Minimize(obj), [])
self.solve_QP(p, solver)
self.assertAlmostEqual(0, p.value, places=4)
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 residual(self):
# TODO: The projection should be implemented directly.
from cvxpy import Minimize, Problem, Variable, hstack, norm2
if self.x.value is None or self.y.value is None or self.z.value is None:
return None
x = Variable(self.x.shape)
y = Variable(self.y.shape)
z = Variable(self.z.shape)
constr = [PowCone3D(x, y, z, self.alpha)]
obj = Minimize(norm2(hstack([x, y, z]) -
hstack([self.x.value, self.y.value, self.z.value])))
problem = Problem(obj, constr)
return problem.solve(solver='SCS', eps=1e-8)
def project_cvx(x, k):
'''
Exact Euclidean projection onto the boundary of the k uniform matroid polytope.
'''
from cvxpy import Variable, Minimize, sum_squares, Problem
import numpy as np
n = len(x)
p = Variable(n, 1)
objective = Minimize(sum_squares(p - x))
constraints = [sum(p) == k, p >= 0, p <= 1]
prob = Problem(objective, constraints)
prob.solve()
return np.reshape(np.array(p.value), x.shape)
def test_parametric(self):
"""Test solve parametric problem vs full problem"""
x = Variable()
a = 10
# b_vec = [-10, -2., 2., 3., 10.]
b_vec = [-10, -2.]
for solver in self.solvers:
print(solver)
# Solve from scratch with no parameters
x_full = []
obj_full = []
for b in b_vec:
obj = Minimize(a * (x ** 2) + b * x)
constraints = [0 <= x, x <= 1]
prob = Problem(obj, constraints)
prob.solve(solver=solver)
x_full += [x.value]
obj_full += [prob.value]
# Solve parametric
x_param = []
obj_param = []
b = Parameter()
obj = Minimize(a * (x ** 2) + b * x)
constraints = [0 <= x, x <= 1]
prob = Problem(obj, constraints)
for b_value in b_vec:
b.value = b_value
prob.solve(solver=solver)
x_param += [x.value]
obj_param += [prob.value]
print(x_full)
print(x_param)
for i in range(len(b_vec)):
self.assertItemsAlmostEqual(x_full[i], x_param[i], places=3)
self.assertAlmostEqual(obj_full[i], obj_param[i])
def test_power(self) -> None:
"""Test domain for power.
"""
opts = {'eps': 1e-8, 'max_iters': 100000}
dom = cp.sqrt(self.a).domain
Problem(Minimize(self.a), dom).solve(solver=cp.SCS, **opts)
self.assertAlmostEqual(self.a.value, 0)
dom = cp.square(self.a).domain
Problem(Minimize(self.a), dom + [self.a >= -100]).solve(solver=cp.SCS,
**opts)
self.assertAlmostEqual(self.a.value, -100)
dom = ((self.a)**-1).domain
Problem(Minimize(self.a), dom + [self.a >= -100]).solve(solver=cp.SCS,
**opts)
self.assertAlmostEqual(self.a.value, 0)
dom = ((self.a)**3).domain
Problem(Minimize(self.a), dom + [self.a >= -100]).solve(solver=cp.SCS,
**opts)
self.assertAlmostEqual(self.a.value, 0)
def __init__(self,
circle_list,
cij=None,
obj='ar0',
overlap=False,
min_edge=2,
verbose=False,
**kwargs):
"""
Weighted Circle Packing Problem
k -
eps -
min_edge -
"""
FormulationR2.__init__(self, circle_list, **kwargs)
# solver and record args
self._solve_args = {'method': 'dccp'}
self._in_dict = {'k': 1, 'min_edge': min_edge, 'eps': 1e-2}
# gather inputs
X = circle_list.point_vars
n = len(circle_list)
cij = cij if cij is not None else np.ones((n, n))
# compute radii
areas = np.asarray([x.area for x in circle_list.inputs])
r = np.sqrt(areas /
np.pi) # * np.log(1 + areas / (min_area - min_edge ** 2))
self.r = r
# indices of upper tris
inds = np.triu_indices(n, 1)
xi, xj = [x.tolist() for x in inds]
# gather inputs
weights = Parameter(shape=len(xi),
value=cij[inds],
name='cij',
nonneg=True)
radii = Parameter(shape=len(xi),
value=r[xi] + r[xj],
name='radii',
nonneg=True)
dists = cvx.norm(X[xi, :] - X[xj, :], 2, axis=1)
# constraints
self._constr.append(dists >= radii)
# objective
self._obj = Minimize(cvx.sum(cvx.multiply(weights, dists)))
def exp_cone(self):
"""Test exponential cone problems.
"""
for solver in self.solvers:
# Basic.
p = Problem(Minimize(self.b), [exp(self.a) <= self.b, self.a >= 1])
pmod = Problem(Minimize(self.b), [ExpCone(self.a, Constant(1), self.b), self.a >= 1])
self.assertTrue(ConeMatrixStuffing().accepts(pmod))
p_new = ConeMatrixStuffing().apply(pmod)
if not solver.accepts(p_new[0]):
return
result = p.solve(solver.name())
sltn = solver.solve(p_new[0], False, False, {})
self.assertAlmostEqual(sltn.opt_val, result, places=1)
inv_sltn = ConeMatrixStuffing().invert(sltn, p_new[1])
self.assertAlmostEqual(inv_sltn.opt_val, result, places=1)
for var in pmod.variables():
self.assertItemsAlmostEqual(inv_sltn.primal_vars[var.id],
var.value, places=1)
# More complex.
# TODO CVXOPT fails here.
if solver.name() == 'CVXOPT':
return
p = Problem(Minimize(self.b), [exp(self.a/2 + self.c) <= self.b+5,
self.a >= 1, self.c >= 5])
pmod = Problem(Minimize(self.b), [ExpCone(self.a/2 + self.c, Constant(1), self.b+5),
self.a >= 1, self.c >= 5])
self.assertTrue(ConeMatrixStuffing().accepts(pmod))
result = p.solve(solver.name())
p_new = ConeMatrixStuffing().apply(pmod)
sltn = solver.solve(p_new[0], False, False, {})
self.assertAlmostEqual(sltn.opt_val, result, places=0)
inv_sltn = ConeMatrixStuffing().invert(sltn, p_new[1])
self.assertAlmostEqual(inv_sltn.opt_val, result, places=0)
for var in pmod.variables():
self.assertItemsAlmostEqual(inv_sltn.primal_vars[var.id],
var.value, places=0)
def as_objective(self, **kwargs):
"""
main[selected] - branch[0]
selection can be written as Minimize(minimum(main[:] - branch[0]))
"""
Xmain, Ymain = self.inputs.vars
Xb, Yb = self._branch.vars
start_x, start_y = Xb[0], Yb[0]
o = Minimize(
cvx.sum_smallest(
cvx.norm1(Xmain - start_x) + cvx.norm1(Ymain - start_y), 1))
return o
def fit(self, X, y, sample_weight=None):
if sample_weight is None:
w = np.ones_like(y)
else:
w = sample_weight
X = np.asarray(X)
y = np.asarray(y)
m, n = X.shape
p = len(self.q)
# variables = []
# s_vars = []#Variable(m)
# t_vars = []#Variable(m)
# b_vars = []#Variable(n)
constraints = []
objective_function = 0.0
last_s = None
last_t = None
b_vars = []
for i in range(p):
s = Variable(m)
t = Variable(m)
b = Variable(n)
b_vars.append(b)
tau = self.q[i]
constraints.append(s >= 0)
constraints.append(t >= 0)
constraints.append(y - X * b == s - t)
objective_function += tau * w * s + \
(1 - tau) * w * t
if i >= 1 and self.prevent_crossing:
constraints.append(s <= last_s)
constraints.append(t >= last_t)
if self.lower_bound is not None:
constraints.append(X * b >= self.lower_bound)
if self.upper_bound is not None:
constraints.append(X * b <= self.upper_bound)
last_s = s
last_t = t
objective = Minimize(objective_function)
problem = Problem(objective, constraints)
if self.solver_options is None:
solver_options = {}
else:
solver_options = self.solver_options
problem.solve(**solver_options)
if problem.status != OPTIMAL:
raise ValueError('Problem status is: %s' % problem.status)
self.coef_ = np.array([np.ravel(b.value) for b in b_vars]).T
return self
def test_partial_problem(self):
"""Test domain for partial minimization/maximization problems.
"""
for obj in [Minimize((self.a)**-1), Maximize(log(self.a))]:
prob = Problem(obj, [self.x + self.a >= [5, 8]])
# Optimize over nothing.
expr = cvxpy.partial_optimize(prob, dont_opt_vars=[self.x, self.a])
dom = expr.domain
constr = [self.a >= -100, self.x >= 0]
prob = Problem(Minimize(sum_entries(self.x + self.a)),
dom + constr)
prob.solve()
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 = cvxpy.partial_optimize(prob, opt_vars=[self.x])
dom = expr.domain
constr = [self.a >= -100, self.x >= 0]
prob = Problem(Minimize(sum_entries(self.x + self.a)),
dom + constr)
prob.solve()
self.assertAlmostEqual(prob.value, 0)
assert self.a.value >= 0
self.assertItemsAlmostEqual(self.x.value, [0, 0])
# Optimize over x and a.
expr = cvxpy.partial_optimize(prob, opt_vars=[self.x, self.a])
dom = expr.domain
constr = [self.a >= -100, self.x >= 0]
prob = Problem(Minimize(sum_entries(self.x + self.a)),
dom + constr)
prob.solve()
self.assertAlmostEqual(self.a.value, -100)
self.assertItemsAlmostEqual(self.x.value, [0, 0])
def solve(self):
logging.info(self.name + " is solving proximal...")
# if not self.has_converged:
self.f = self.c.T @ self.x
self.rho = constants.RHO
self.f += (self.rho /
2) * sum_squares(self.x[self.dims] - self.xbar[self.dims] +
self.u[self.dims])
self.prox = Problem(Minimize(self.f),
[self.A @ self.x == self.b, self.x >= 0])
self.prox.solve()
logging.info(self.name + ' sends ' + str(self.x.value) + ' to master')
logging.info(self.name + "'s x[dims] = " +
str(self.x[self.dims].value))
return self.x.value, self.has_converged, self.prox.value, self.history
