def __init__(self, graph, solver=None, verbosity=False):
"""
Ordinary Least-Squares optimizer for the odometric and distance measurements contained in a GaussianFactorGraph
graph instance is modified using the solution found by optimize() with each call to update()
:param graph: GaussianFactorGraph instance
:param solver: One of the supported CvxPy solvers, e.g. 'GUROBI' (default1), 'MOSEK' (default2), 'ECOS' (default3)
:param verbosity: Prints solver output to console if True
"""
assert isinstance(
graph, GaussianFactorGraph
), "Expected type GaussainFactorGraph for graph, got %s" % type(graph)
self.graph = graph
self.M = [] # estimated landmark positions
self.P = [] # estimated robot positions
self.res_d = [] # distance measurement residuals for a given solution
self.res_t = [
] # translation measurement residuals for a given solution
self._verbosity = verbosity # solver output printed to console when True
if 'GUROBI' in cp.installed_solvers():
self._solver = 'GUROBI'
elif 'MOSEK' in cp.installed_solvers():
self._solver = 'MOSEK'
else:
self._solver = 'ECOS'
if solver is not None:
self._solver = solver
def set_default_sdp_solver(solver_kwargs: dict):
"""Set default SDP solver from installed solvers."""
if "solver" in solver_kwargs:
return
if "CVXOPT" in cvxpy.installed_solvers():
solver_kwargs["solver"] = "CVXOPT"
elif "MOSEK" in cvxpy.installed_solvers():
solver_kwargs["solver"] = "MOSEK"
def test_advanced1(self):
"""Code from the advanced tutorial.
"""
# Solving a problem with different solvers.
x = cvx.Variable(2)
obj = cvx.Minimize(x[0] + cvx.norm(x, 1))
constraints = [x >= 2]
prob = cvx.Problem(obj, constraints)
# Solve with ECOS.
prob.solve(solver=cvx.ECOS)
print("optimal value with ECOS:", prob.value)
self.assertAlmostEqual(prob.value, 6)
# Solve with ECOS_BB.
prob.solve(solver=cvx.ECOS_BB)
print("optimal value with ECOS_BB:", prob.value)
self.assertAlmostEqual(prob.value, 6)
# Solve with CVXOPT.
if cvx.CVXOPT in cvx.installed_solvers():
prob.solve(solver=cvx.CVXOPT)
print("optimal value with CVXOPT:", prob.value)
self.assertAlmostEqual(prob.value, 6)
# Solve with SCS.
prob.solve(solver=cvx.SCS)
print("optimal value with SCS:", prob.value)
self.assertAlmostEqual(prob.value, 6, places=2)
if cvx.CPLEX in cvx.installed_solvers():
# Solve with CPLEX.
prob.solve(solver=cvx.CPLEX)
print("optimal value with CPLEX:", prob.value)
self.assertAlmostEqual(prob.value, 6)
if cvx.GLPK in cvx.installed_solvers():
# Solve with GLPK.
prob.solve(solver=cvx.GLPK)
print("optimal value with GLPK:", prob.value)
self.assertAlmostEqual(prob.value, 6)
# Solve with GLPK_MI.
prob.solve(solver=cvx.GLPK_MI)
print("optimal value with GLPK_MI:", prob.value)
self.assertAlmostEqual(prob.value, 6)
if cvx.GUROBI in cvx.installed_solvers():
# Solve with Gurobi.
prob.solve(solver=cvx.GUROBI)
print("optimal value with GUROBI:", prob.value)
self.assertAlmostEqual(prob.value, 6)
print(cvx.installed_solvers())
def distance_from_separating_hyperplane(self,tple): no_of_weights=self.dimensions no_of_tuple=self.dimensions weights=cvxpy.Variable(no_of_weights,1) tuple=numpy.array(tple) print "weights:",weights print "tuple:",tuple bias=self.bias svm_function = 0.0 for i in xrange(no_of_weights): svm_function += cvxpy.abs(weights[i,0]) objective=cvxpy.Minimize(cvxpy.abs(svm_function)*0.5) print "============================================" print "Objective Function" print "============================================" print objective constraint=0.0 constraints=[] for i,k in zip(xrange(no_of_weights),xrange(no_of_tuple)): constraint += weights[i,0]*tuple[k] constraint += bias print "constraint:",constraint constraints.append(cvxpy.abs(constraint) >= 1) print "============================================" print "Constraints" print "============================================" print constraints problem=cvxpy.Problem(objective,constraints) print "=====================================" print "Installed Solvers:" print "=====================================" print cvxpy.installed_solvers() print "Is Problem DCCP:",dccp.is_dccp(problem) print "=====================================" print "CVXPY args:" print "=====================================" result=problem.solve(solver=cvxpy.SCS,verbose=True,method='dccp') print "=====================================" print "Problem value:" print "=====================================" print problem.value print "=====================================" print "Result:" print "=====================================" print result return (result,tuple)
def from_file(cls, configID, configDir):
"""Alternative constructor for loading a configuration from a text file.
Loads a python file named <configID>.py with variables "solver", "verbose",
and "kwargs".
Parameters
----------
configID : string
A unique identifier for this config. Config file should be of the form <configID>.py.
configDir : string
The directory where the config files are located.
Returns
-------
SolverConfiguration - the newly created SolverConfiguration object.
"""
if configDir not in sys.path:
sys.path.insert(0, configDir)
configObj = __import__(configID)
try:
if configObj.config["solver"] in cvx.installed_solvers():
return cls(configID, configObj.config)
else:
return None
except: # pragma: no cover
warn("Could not import configuration: " + configID)
return None
def _load_solver_args(self):
"""
Loads the configuration
"""
solvers: List[str] = config.solvers
installed = cp.installed_solvers()
index = 0
while index < len(solvers):
if solvers[index] not in installed:
del solvers[index]
else:
index += 1
if solvers and solvers[0]:
solver = solvers[0]
else:
solver = None
options = {}
if 'all' in config.solver_options:
options.update(config.solver_options['all'])
if solver and solver in config.solver_options:
options.update(config.solver_options[solver])
if solver:
options['solver'] = solver
self.solver_args = options
self.logger.info(
'configured solver: %s, options: %s (installed solvers: %s)',
solver, options, ', '.join(installed))
def farmer_cvxpy():
print(cp.installed_solvers())
plants = ("wheat", "corn", "beet")
actions = ("buy", "sell")
prices = ("high", "low")
area = cp.Variable(len(plants), 'area', pos=True)
wheat_act = cp.Variable(len(actions), 'wheat', pos=True)
corn_act = cp.Variable(len(actions), 'corn', pos=True)
beet_price = cp.Variable(len(prices), 'beat', pos=True)
constraints = [
beet_price <= 6000,
]
constraints.append(cp.sum(area) <= 500)
constraints.append(2.5 * area[0] + wheat_act[0] - wheat_act[1] >= 200)
constraints.append(3 * area[1] + corn_act[0] - corn_act[1] >= 240)
constraints.append(beet_price[0] + beet_price[1] <= 20 * area[2])
grow_cost = cp.sum([150, 230, 260] * area)
wheat_cost = 238 * wheat_act[0] - 170 * wheat_act[1]
corn_cost = 210 * corn_act[0] - 150 * corn_act[1]
beet_cost = cp.sum(np.array([36, 10]) * beet_price)
prob = cp.Problem(
cp.Minimize(grow_cost + wheat_cost + corn_cost - beet_cost),
constraints)
prob.solve(verbose=True)
print(prob.value)
print(area.value)
print(wheat_act.value)
print(corn_act.value)
print(beet_price.value)
def test_lp_2(self):
"""Test a basic LP. (from test_solver.py::test_cvxopt_glpk)
"""
# Either the problem is solved or cp.CBC is not installed.
if cp.CBC in cp.installed_solvers():
prob = cp.Problem(cp.Minimize(cp.norm(self.x, 1)), [self.x == 0])
prob.solve(verbose=False, solver=cp.CBC)
self.assertAlmostEqual(prob.value, 0)
self.assertItemsAlmostEqual(self.x.value, [0, 0])
# Example from
# http://cvxopt.org/userguide/coneprog.html?highlight=solvers.lp#cvxopt.solvers.lp
objective = cp.Minimize(-4 * self.x[0] - 5 * self.x[1])
constraints = [
2 * self.x[0] + self.x[1] <= 3, self.x[0] + 2 * self.x[1] <= 3,
self.x[0] >= 0, self.x[1] >= 0
]
prob = cp.Problem(objective, constraints)
prob.solve(verbose=False, solver=cp.CBC)
self.assertAlmostEqual(prob.value, -9)
self.assertItemsAlmostEqual(self.x.value, [1, 1])
else:
with self.assertRaises(Exception) as cm:
prob = cp.Problem(cp.Minimize(cp.norm(self.x, 1)),
[self.x == 0])
prob.solve(verbose=False, solver=cp.CBC)
self.assertEqual(str(cm.exception),
"The solver %s is not installed." % cp.CBC)
def test_gurobi_socp(self):
"""Test a basic SOCP with Gurobi.
"""
if cvx.GUROBI in cvx.installed_solvers():
prob = cvx.Problem(cvx.Minimize(cvx.norm(self.x, 2)),
[self.x == 0])
prob.solve(solver=cvx.GUROBI)
self.assertAlmostEqual(prob.value, 0)
self.assertItemsAlmostEqual(self.x.value, [0, 0])
# Example from http://cvxopt.org/userguide/coneprog.html?highlight=solvers.lp#cvxopt.solvers.lp
objective = cvx.Minimize(-4 * self.x[0] - 5 * self.x[1])
constraints = [
2 * self.x[0] + self.x[1] <= 3,
(self.x[0] + 2 * self.x[1])**2 <= 9, self.x[0] >= 0,
self.x[1] >= 0
]
prob = cvx.Problem(objective, constraints)
prob.solve(solver=cvx.GUROBI)
self.assertAlmostEqual(prob.value, -9)
self.assertItemsAlmostEqual(self.x.value, [1, 1])
# Gurobi's default lower bound for a decision variable is zero
# This quick test ensures that the cvxpy interface for GUROBI does *not* have that bound
objective = cvx.Minimize(self.x[0])
constraints = [self.x[0] >= -100, self.x[0] <= -10, self.x[1] == 1]
prob = cvx.Problem(objective, constraints)
prob.solve(solver=cvx.GUROBI)
self.assertItemsAlmostEqual(self.x.value, [-100, 1])
# Boolean and integer version.
bool_var = cvx.Variable(boolean=True)
int_var = cvx.Variable(integer=True)
prob = cvx.Problem(cvx.Minimize(cvx.norm(self.x, 2)),
[self.x == bool_var, bool_var == 0])
prob.solve(solver=cvx.GUROBI)
self.assertAlmostEqual(prob.value, 0)
self.assertAlmostEqual(bool_var.value, 0)
self.assertItemsAlmostEqual(self.x.value, [0, 0])
# Example from http://cvxopt.org/userguide/coneprog.html?highlight=solvers.lp#cvxopt.solvers.lp
objective = cvx.Minimize(-4 * self.x[0] - 5 * self.x[1])
constraints = [
2 * self.x[0] + self.x[1] <= int_var,
(self.x[0] + 2 * self.x[1])**2 <= 9 * bool_var, self.x[0] >= 0,
self.x[1] >= 0, int_var == 3 * bool_var, int_var == 3
]
prob = cvx.Problem(objective, constraints)
prob.solve(solver=cvx.GUROBI)
self.assertAlmostEqual(prob.value, -9)
self.assertAlmostEqual(int_var.value, 3)
self.assertAlmostEqual(bool_var.value, 1)
self.assertItemsAlmostEqual(self.x.value, [1, 1])
else:
with self.assertRaises(Exception) as cm:
prob = cvx.Problem(cvx.Minimize(cvx.norm(self.x, 1)),
[self.x == 0])
prob.solve(solver=cvx.GUROBI)
self.assertEqual(str(cm.exception),
"The solver %s is not installed." % cvx.GUROBI)
def _check_for_sdp_solver(cls):
"""Check if CVXPY solver is available"""
if cls._HAS_SDP_SOLVER is None:
if _HAS_CVX:
# pylint:disable=import-error
import cvxpy
solvers = cvxpy.installed_solvers()
# Check for other SDP solvers cvxpy supports
if 'CVXOPT' in solvers or 'MOSEK' in solvers:
cls._HAS_SDP_SOLVER_NOT_SCS = True
cls._HAS_SDP_SOLVER = True
return
if 'SCS' in solvers:
# Try example problem to see if built with BLAS
# SCS solver cannot solver larger than 2x2 matrix
# problems without BLAS
try:
var = cvxpy.Variable((5, 5), PSD=True)
obj = cvxpy.Minimize(cvxpy.norm(var))
cvxpy.Problem(obj).solve(solver='SCS')
cls._HAS_SDP_SOLVER = True
return
except cvxpy.error.SolverError:
pass
cls._HAS_SDP_SOLVER = False
def _initialize_kwargs(self, kwargs):
if 'verbose' in kwargs:
assert isinstance(kwargs['verbose'],
bool), 'verbose needs to be True or False.'
self._verbose = kwargs['verbose']
if 'tol' in kwargs:
assert isinstance(kwargs['tol'],
int), 'tolerance needs to be an integer.'
self.tol = kwargs['tol']
if 'force_feasible_method' in kwargs:
assert isinstance(
kwargs['force_feasible_method'],
bool), 'force feasible method needs to be True or False.'
self.force_feasible_method = kwargs['force_feasible_method']
if 'ban_constraints' in kwargs:
assert isinstance(kwargs['ban_constraints'],
list), 'ban constraints needs to be a list.'
self.ban_constraints = kwargs['ban_constraints']
if 'normalize_c' in kwargs:
assert kwargs['normalize_c'] == 1 or kwargs['normalize_c'] == np.inf, 'normalize c with 1 or infinity norm.'
self.normalize_c = kwargs['normalize_c']
if 'solver' in kwargs:
if kwargs['solver'] in cvx.installed_solvers():
self.solver = getattr(cvx, kwargs['solver'])
else:
print('you do not have this solver.')
return kwargs
def test_cplex_params(self):
if cvx.CPLEX in cvx.installed_solvers():
import numpy.random as rnd
n = 10
m = 4
A = rnd.randn(m, n)
x = rnd.randn(n)
y = A.dot(x)
# Solve a simple basis pursuit problem for testing purposes.
z = cvx.Variable(n)
objective = cvx.Minimize(cvx.norm1(z))
constraints = [A * z == y]
problem = cvx.Problem(objective, constraints)
invalid_cplex_params = {"bogus": "foo"}
with self.assertRaises(ValueError):
problem.solve(solver=cvx.CPLEX,
cplex_params=invalid_cplex_params)
with self.assertRaises(ValueError):
problem.solve(solver=cvx.CPLEX, invalid_kwarg=None)
cplex_params = {
"advance": 0, # int param
"simplex.limits.iterations": 1000, # long param
"timelimit": 1000.0, # double param
"workdir": '"mydir"', # string param
}
problem.solve(solver=cvx.CPLEX, cplex_params=cplex_params)
def test_cplx_mats(self):
"""Test complex matrices.
"""
if cvx.SUPER_SCS in cvx.installed_solvers():
# Complex-valued matrix
K = np.matrix(np.random.rand(2, 2) +
1j * np.random.rand(2, 2)) # example matrix
n1 = la.svdvals(K).sum() # trace norm of K
# Dual Problem
X = cvx.Variable((2, 2), complex=True)
Y = cvx.Variable((2, 2), complex=True)
Z = cvx.Variable((2, 2))
# X, Y >= 0 so trace is real
objective = cvx.Minimize(
cvx.real(0.5 * cvx.trace(X) + 0.5 * cvx.trace(Y)))
constraints = [
cvx.bmat([[X, -K.H], [-K, Y]]) >> 0,
X >> 0,
Y >> 0,
]
problem = cvx.Problem(objective, constraints)
sol_scs = problem.solve(solver='SUPER_SCS')
self.assertEqual(constraints[0].dual_value.shape, (4, 4))
self.assertEqual(constraints[1].dual_value.shape, (2, 2))
self.assertEqual(constraints[2].dual_value.shape, (2, 2))
self.assertAlmostEqual(sol_scs, n1)
else:
pass
def test_cvxopt_options(self):
"""Test that all the CVXOPT solver options work.
"""
# TODO race condition when changing these values.
# 'maxiters'
# maximum number of iterations (default: 100).
# 'abstol'
# absolute accuracy (default: 1e-7).
# 'reltol'
# relative accuracy (default: 1e-6).
# 'feastol'
# tolerance for feasibility conditions (default: 1e-7).
# 'refinement'
# number of iterative refinement steps when solving KKT equations
# (default: 0 if the problem has no second-order cone
# or matrix inequality constraints; 1 otherwise).
if cvx.CVXOPT in cvx.installed_solvers():
EPS = 1e-7
prob = cvx.Problem(cvx.Minimize(cvx.norm(self.x, 1) + 1.0),
[self.x == 0])
for i in range(2):
prob.solve(solver=cvx.CVXOPT,
feastol=EPS,
abstol=EPS,
reltol=EPS,
max_iters=20,
verbose=True,
kktsolver="chol",
refinement=2,
warm_start=True)
self.assertAlmostEqual(prob.value, 1.0)
self.assertItemsAlmostEqual(self.x.value, [0, 0])
def test_cvxopt_dual(self):
"""Make sure CVXOPT's dual result matches other solvers
"""
if cvx.CVXOPT in cvx.installed_solvers():
constraints = [self.x == 0]
prob = cvx.Problem(cvx.Minimize(cvx.norm(self.x, 1)))
prob.solve(solver=cvx.CVXOPT)
duals_cvxopt = [x.dual_value for x in constraints]
prob.solve(solver=cvx.ECOS)
duals_ecos = [x.dual_value for x in constraints]
self.assertItemsAlmostEqual(duals_cvxopt, duals_ecos)
# Example from http://cvxopt.org/userguide/coneprog.html?highlight=solvers.lp#cvxopt.solvers.lp
objective = cvx.Minimize(-4 * self.x[0] - 5 * self.x[1])
constraints = [2 * self.x[0] + self.x[1] <= 3,
self.x[0] + 2 * self.x[1] <= 3,
self.x[0] >= 0,
self.x[1] >= 0]
prob = cvx.Problem(objective, constraints)
prob.solve(solver=cvx.CVXOPT)
duals_cvxopt = [x.dual_value for x in constraints]
prob.solve(solver=cvx.ECOS)
duals_ecos = [x.dual_value for x in constraints]
self.assertItemsAlmostEqual(duals_cvxopt, duals_ecos)
else:
pass
def _check_for_sdp_solver(cls):
"""Check if CVXPy solver is available"""
if cls._HAS_SDP_SOLVER is None:
cls._HAS_SDP_SOLVER = False
if HAS_CVXPY:
# pylint:disable=import-error
solvers = cvxpy.installed_solvers()
# Check for other SDP solvers cvxpy supports
for solver in ["CVXOPT", "MOSEK"]:
if solver in solvers:
cls._SDP_SOLVERS.add(solver)
cls._HAS_SDP_SOLVER = True
cls._HAS_SDP_SOLVER_NOT_SCS = True
if "SCS" in solvers:
# Try example problem to see if built with BLAS
# SCS solver cannot solver larger than 2x2 matrix
# problems without BLAS
try:
var = cvxpy.Variable((5, 5), PSD=True)
obj = cvxpy.Minimize(cvxpy.norm(var))
cvxpy.Problem(obj).solve(solver="SCS")
cls._SDP_SOLVERS.add("SCS")
cls._HAS_SDP_SOLVER = True
except cvxpy.error.SolverError:
pass
def test_xpress_socp(self):
"""Test a basic SOCP with Xpress.
"""
if cvx.XPRESS in cvx.installed_solvers():
prob = cvx.Problem(cvx.Minimize(cvx.norm(self.x, 2)), [self.x == 0])
prob.solve(solver=cvx.XPRESS)
self.assertAlmostEqual(prob.value, 0)
self.assertItemsAlmostEqual(self.x.value, [0, 0])
# Example from http://cvxopt.org/userguide/coneprog.html?highlight=solvers.lp#cvxopt.solvers.lp
objective = cvx.Minimize(-4 * self.x[0] - 5 * self.x[1])
constraints = [2 * self.x[0] + self.x[1] <= 3,
(self.x[0] + 2 * self.x[1])**2 <= 9,
self.x[0] >= 0,
self.x[1] >= 0]
prob = cvx.Problem(objective, constraints)
prob.solve(solver=cvx.XPRESS)
self.assertAlmostEqual(prob.value, -9)
self.assertItemsAlmostEqual(self.x.value, [1, 1])
objective = cvx.Minimize(self.x[0])
constraints = [self.x[0] >= -100, self.x[0] <= -10, self.x[1] == 1]
prob = cvx.Problem(objective, constraints)
prob.solve(solver=cvx.XPRESS)
self.assertItemsAlmostEqual(self.x.value, [-100, 1])
else:
with self.assertRaises(Exception) as cm:
prob = cvx.Problem(cvx.Minimize(cvx.norm(self.x, 1)), [self.x == 0])
prob.solve(solver=cvx.XPRESS)
self.assertEqual(str(cm.exception), "The solver %s is not installed." % cvx.XPRESS)
def test_key_error(self):
"""Test examples that caused key error.
"""
if cvx.CVXOPT in cvx.installed_solvers():
x = cvx.Variable()
u = -cvx.exp(x)
prob = cvx.Problem(cvx.Maximize(u), [x == 1])
prob.solve(verbose=True, solver=cvx.CVXOPT)
prob.solve(verbose=True, solver=cvx.CVXOPT)
###########################################
import numpy as np
kD = 2
Sk = cvx.Variable((kD, kD), PSD=True)
Rsk = cvx.Parameter((kD, kD))
mk = cvx.Variable((kD, 1))
musk = cvx.Parameter((kD, 1))
logpart = -0.5 * cvx.log_det(Sk) + 0.5 * cvx.matrix_frac(
mk, Sk) + (kD / 2.) * np.log(2 * np.pi)
linpart = mk.T * musk - 0.5 * cvx.trace(Sk * Rsk)
obj = logpart - linpart
prob = cvx.Problem(cvx.Minimize(obj), [Sk == Sk.T])
musk.value = np.ones((2, 1))
covsk = np.diag([0.3, 0.5])
Rsk.value = covsk + (musk.value * musk.value.T)
prob.solve(verbose=True, solver=cvx.CVXOPT)
print("second solve")
prob.solve(verbose=False, solver=cvx.CVXOPT)
def test_mosek_sdp(self):
"""Make sure Mosek's dual result matches other solvers
"""
# TODO: should work with PSD (>>, <<).
if cvx.MOSEK in cvx.installed_solvers():
# Test optimality gap for equilibration.
n = 3
Art = np.random.randn(n, n)
t = cvx.Variable()
d = cvx.Variable(n)
D = cvx.diag(d)
constr = [
Art * D * Art.T - np.eye(n) == cvx.Variable((n, n), PSD=True),
cvx.Variable((n, n),
PSD=True) == t * np.eye(n) - Art * D * Art.T,
d >= 0
]
prob = cvx.Problem(cvx.Minimize(t), constr)
prob.solve(solver=cvx.MOSEK)
else:
with self.assertRaises(Exception) as cm:
prob = cvx.Problem(cvx.Minimize(cvx.norm(self.x, 1)),
[self.x == 0])
prob.solve(solver=cvx.MOSEK)
self.assertEqual(str(cm.exception),
"The solver %s is not installed." % cvx.MOSEK)
def test_cvxopt_glpk(self):
"""Test a basic LP with GLPK.
"""
# Either the problem is solved or GLPK is not installed.
if cvx.GLPK in cvx.installed_solvers():
prob = cvx.Problem(cvx.Minimize(cvx.norm(self.x, 1)), [self.x == 0])
prob.solve(solver=cvx.GLPK)
self.assertAlmostEqual(prob.value, 0)
self.assertItemsAlmostEqual(self.x.value, [0, 0])
# Example from http://cvxopt.org/userguide/coneprog.html?highlight=solvers.lp#cvxopt.solvers.lp
objective = cvx.Minimize(-4 * self.x[0] - 5 * self.x[1])
constraints = [2 * self.x[0] + self.x[1] <= 3,
self.x[0] + 2 * self.x[1] <= 3,
self.x[0] >= 0,
self.x[1] >= 0]
prob = cvx.Problem(objective, constraints)
prob.solve(solver=cvx.GLPK)
self.assertAlmostEqual(prob.value, -9)
self.assertItemsAlmostEqual(self.x.value, [1, 1])
else:
with self.assertRaises(Exception) as cm:
prob = cvx.Problem(cvx.Minimize(cvx.norm(self.x, 1)), [self.x == 0])
prob.solve(solver=cvx.GLPK)
self.assertEqual(str(cm.exception), "The solver %s is not installed." % cvx.GLPK)
def test_cvxopt_glpk_mi(self):
"""Test a basic MILP with GLPK.
"""
# Either the problem is solved or GLPK is not installed.
if cvx.GLPK_MI in cvx.installed_solvers():
bool_var = cvx.Variable(boolean=True)
int_var = cvx.Variable(integer=True)
prob = cvx.Problem(cvx.Minimize(cvx.norm(self.x, 1)),
[self.x == bool_var, bool_var == 0])
prob.solve(solver=cvx.GLPK_MI, verbose=True)
self.assertAlmostEqual(prob.value, 0)
self.assertAlmostEqual(bool_var.value, 0)
self.assertItemsAlmostEqual(self.x.value, [0, 0])
# Example from http://cvxopt.org/userguide/coneprog.html?highlight=solvers.lp#cvxopt.solvers.lp
objective = cvx.Minimize(-4 * self.x[0] - 5 * self.x[1])
constraints = [2 * self.x[0] + self.x[1] <= int_var,
self.x[0] + 2 * self.x[1] <= 3*bool_var,
self.x[0] >= 0,
self.x[1] >= 0,
int_var == 3*bool_var,
int_var == 3]
prob = cvx.Problem(objective, constraints)
prob.solve(solver=cvx.GLPK_MI, verbose=True)
self.assertAlmostEqual(prob.value, -9)
self.assertAlmostEqual(int_var.value, 3)
self.assertAlmostEqual(bool_var.value, 1)
self.assertItemsAlmostEqual(self.x.value, [1, 1])
else:
with self.assertRaises(Exception) as cm:
prob = cvx.Problem(cvx.Minimize(cvx.norm(self.x, 1)), [self.x == 0])
prob.solve(solver=cvx.GLPK_MI)
self.assertEqual(str(cm.exception), "The solver %s is not installed." % cvx.GLPK_MI)
def test_kl_div(self):
"""Test a problem with kl_div.
"""
import numpy as np
import cvxpy as cp
kK = 50
kSeed = 10
prng = np.random.RandomState(kSeed)
#Generate a random reference distribution
npSPriors = prng.uniform(0.0, 1.0, (kK, 1))
npSPriors = npSPriors / np.sum(npSPriors)
#Reference distribution
p_refProb = cvx.Parameter((kK, 1), nonneg=True)
#Distribution to be estimated
v_prob = cvx.Variable((kK, 1))
objkl = 0.0
for k in range(kK):
objkl += cvx.kl_div(v_prob[k, 0], p_refProb[k, 0])
constrs = [sum(v_prob[k, 0] for k in range(kK)) == 1]
klprob = cvx.Problem(cvx.Minimize(objkl), constrs)
p_refProb.value = npSPriors
if cvx.CVXOPT in cvx.installed_solvers():
result = klprob.solve(solver=cvx.CVXOPT, verbose=True)
self.assertItemsAlmostEqual(v_prob.value, npSPriors)
result = klprob.solve(solver=cvx.SCS, verbose=True)
self.assertItemsAlmostEqual(v_prob.value, npSPriors, places=3)
result = klprob.solve(solver=cvx.ECOS, verbose=True)
self.assertItemsAlmostEqual(v_prob.value, npSPriors)
def test_advanced2(self):
"""Test code from the advanced section of the tutorial.
"""
x = cvx.Variable()
prob = cvx.Problem(cvx.Minimize(cvx.square(x)), [x == 2])
# Get ECOS arguments.
data, chain, inverse = prob.get_problem_data(cvx.ECOS)
# Get ECOS_BB arguments.
data, chain, inverse = prob.get_problem_data(cvx.ECOS_BB)
# Get CVXOPT arguments.
if cvx.CVXOPT in cvx.installed_solvers():
data, chain, inverse = prob.get_problem_data(cvx.CVXOPT)
# Get SCS arguments.
data, chain, inverse = prob.get_problem_data(cvx.SCS)
import ecos
# Get ECOS arguments.
data, chain, inverse = prob.get_problem_data(cvx.ECOS)
# Call ECOS solver.
solution = ecos.solve(data["c"], data["G"], data["h"],
ecos_conif.dims_to_solver_dict(data["dims"]),
data["A"], data["b"])
# Unpack raw solver output.
prob.unpack_results(solution, chain, inverse)
def test_xpress_dual(self):
"""Make sure Xpress' dual result matches other solvers
"""
if cvx.XPRESS in cvx.installed_solvers():
constraints = [self.x == 0]
prob = cvx.Problem(cvx.Minimize(cvx.norm(self.x, 1)))
prob.solve(solver=cvx.XPRESS)
duals_xpress = [x.dual_value for x in constraints]
prob.solve(solver=cvx.ECOS)
duals_ecos = [x.dual_value for x in constraints]
self.assertItemsAlmostEqual(duals_xpress, duals_ecos)
# Example from http://cvxopt.org/userguide/coneprog.html?highlight=solvers.lp#cvxopt.solvers.lp
objective = cvx.Minimize(-4 * self.x[0] - 5 * self.x[1])
constraints = [2 * self.x[0] + self.x[1] <= 3,
self.x[0] + 2 * self.x[1] <= 3,
self.x[0] >= 0,
self.x[1] >= 0]
prob = cvx.Problem(objective, constraints)
prob.solve(solver=cvx.XPRESS)
duals_xpress = [x.dual_value for x in constraints]
prob.solve(solver=cvx.ECOS)
duals_ecos = [x.dual_value for x in constraints]
self.assertItemsAlmostEqual(duals_xpress, duals_ecos)
else:
with self.assertRaises(Exception) as cm:
prob = cvx.Problem(cvx.Minimize(cvx.norm(self.x, 1)), [self.x == 0])
prob.solve(solver=cvx.XPRESS)
self.assertEqual(str(cm.exception), "The solver %s is not installed." % cvx.XPRESS)
def test_mosek_params(self):
if cvx.MOSEK in cvx.installed_solvers():
import numpy as np
import numpy.random as rnd
import mosek
n = 10
m = 4
A = rnd.randn(m, n)
x = rnd.randn(n)
y = A.dot(x)
# Solve a simple basis pursuit problem for testing purposes.
z = cvx.Variable(n)
objective = cvx.Minimize(cvx.norm1(z))
constraints = [A * z == y]
problem = cvx.Problem(objective, constraints)
invalid_mosek_params = {
"dparam.basis_tol_x": "1e-8"
}
with self.assertRaises(ValueError):
problem.solve(solver=cvx.MOSEK, mosek_params=invalid_mosek_params)
with self.assertRaises(ValueError):
problem.solve(solver=cvx.MOSEK, invalid_kwarg=None)
mosek_params = {
mosek.dparam.basis_tol_x: 1e-8,
"MSK_IPAR_INTPNT_MAX_ITERATIONS": 20
}
problem.solve(solver=cvx.MOSEK, mosek_params=mosek_params)
def test_mosek_exp(self):
"""
Formulate the following exponential cone problem with cvxpy
min 3 * x[0] + 2 * x[1] + x[2]
s.t. 0.1 <= x[0] + x[1] + x[2] <= 1
x >= 0
x[0] >= x[1] * exp(x[2] / x[1])
and solve with MOSEK and ECOS. Ensure that MOSEK and ECOS have the same
primal and dual solutions.
Note that the exponential cone constraint can be rewritten in terms of the
relative entropy cone. The correspondence is as follows:
x[0] >= x[1] * exp(x[2] / x[1])
iff
x[1] * log(x[1] / x[0]) + x[2] <= 0.
"""
if cvx.MOSEK in cvx.installed_solvers():
import mosek
if hasattr(mosek.conetype, 'pexp'):
# Formulate and solve the problem with CVXPY
x = cvx.Variable(shape=(3, 1))
constraints = [
cvx.sum(x) <= 1.0,
cvx.sum(x) >= 0.1, x >= 0.01,
cvx.kl_div(x[1], x[0]) + x[1] - x[0] + x[2] <= 0
]
obj = cvx.Minimize(3 * x[0] + 2 * x[1] + x[2])
prob = cvx.Problem(obj, constraints)
prob.solve(solver=cvx.MOSEK)
val_mosek = prob.value
x_mosek = x.value.flatten().tolist()
duals_mosek = [
np.array(c.dual_value).ravel().tolist()
for c in constraints
]
prob.solve(solver=cvx.ECOS)
val_ecos = prob.value
x_ecos = x.value.flatten().tolist()
duals_ecos = [
np.array(c.dual_value).ravel().tolist()
for c in constraints
]
# verify results
self.assertAlmostEqual(val_mosek, val_ecos)
self.assertItemsAlmostEqual(x_mosek, x_ecos, places=4)
self.assertEqual(len(duals_ecos), len(duals_mosek))
for i in range(len(duals_mosek)):
if isinstance(duals_mosek[i], float):
self.assertAlmostEqual(duals_mosek[i],
duals_ecos[i],
places=4)
else:
self.assertItemsAlmostEqual(duals_mosek[i],
duals_ecos[i],
places=4)
else:
pass
def __init__(self, graph, assoc_range=1, solver=None, verbosity=False):
"""
Occam Smoothing-And-Mapping optimizer for the odometric and distance factors contained in a GaussianFactorGraph
Corresponding paper explaining the procedure can be found here:
Landmark associations are uncovered automatically and stored in equivalence_pairs between calls to optimize()
graph instance is modified using the solution found by optimize() with each call to update()
:param graph: GaussianFactorGraph instance
:param assoc_range: Standard deviation (distance) between pairs of observations to the same landmark
:param solver: One of the supported CvxPy solvers, e.g. 'GUROBI' (default1), 'MOSEK' (default2), 'ECOS' (default3)
:param verbosity: Prints solver output to console if True
"""
assert isinstance(
graph, GaussianFactorGraph
), "Expected type GaussainFactorGraph for graph, got %s" % type(graph)
self.graph = graph
self.M = None # estimated landmark positions
self.P = None # estimated robot positions
self.res_d = None # distance measurement residuals for a given solution
self.res_t = None # translation measurement residuals for a given solution
self.equivalence_pairs = [] # equivalent LandmarkVariable pairs
self._sigma = assoc_range
self._verbosity = verbosity # solver output printed to console when True
if 'GUROBI' in cp.installed_solvers():
self._solver = 'GUROBI'
elif 'MOSEK' in cp.installed_solvers():
self._solver = 'MOSEK'
else:
self._solver = 'ECOS'
if solver is not None:
self._solver = solver
self._pre_optimizer = WeightedLeastSquares(graph,
solver=solver,
verbosity=verbosity)
def test_sdp_var(self):
"""Test sdp var.
"""
if cvx.SUPER_SCS in cvx.installed_solvers():
const = cvx.Constant([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
X = cvx.Variable((3, 3), PSD=True)
prob = cvx.Problem(cvx.Minimize(0), [X == const])
prob.solve(verbose=True, solver='SUPER_SCS')
self.assertEqual(prob.status, cvx.INFEASIBLE)
def test_sigma_max(self):
"""Test sigma_max.
"""
if cvx.SUPER_SCS in cvx.installed_solvers():
const = cvx.Constant([[1, 2, 3], [4, 5, 6]])
constr = [self.C == const]
prob = cvx.Problem(cvx.Minimize(cvx.norm(self.C, 2)), constr)
result = prob.solve(solver='SUPER_SCS')
self.assertAlmostEqual(result, cvx.norm(const, 2).value)
self.assertItemsAlmostEqual(self.C.value, const.value)
def test_warm_start(self):
"""Test warm starting.
"""
if cvx.SUPER_SCS in cvx.installed_solvers():
x = cvx.Variable(10)
obj = cvx.Minimize(cvx.sum(cvx.exp(x)))
prob = cvx.Problem(obj, [cvx.sum(x) == 1])
result = prob.solve(solver='SUPER_SCS', eps=1e-4)
result2 = prob.solve(solver='SUPER_SCS', warm_start=True, eps=1e-4)
self.assertAlmostEqual(result2, result, places=2)
def installed_solvers():
return cvx.installed_solvers()
import numpy as np import cvxpy as cvx import scipy as sp import matplotlib.pyplot as plt from mpl_toolkits.mplot3d.axes3d import Axes3D from RelativeMotion import * print cvx.installed_solvers() mu = 3.986*10**14 a = 6678*10**3 n = np.sqrt(mu/a**3) nu = 6 ny = 6 S = RelativeMotion() Ac = S.hcw(n) Bc = S.inputMats(nu) method = 'zoh' Ts = 10 sysc,sysd = S.discretizeSystem(n,nu,ny,Ts,method) t0 = 0 tf = int((2*np.pi/n)) x0 = 100 X0 = np.matrix([[x0,-100,300,0,-2*n*x0,0]]) Xf = np.matrix([[0,0,0,0,0,0]]) Umax= 0.1 sysc,sysd = S.discretizeSystem(n,nu,ny,Ts,method) X = S.discHCWSim_initial(X0,t0,tf,Ts,n,nu,ny,method)
def optimize_lineup(player_list, force_in=[], force_out=[], salary_cap=60000):
'''
Maximize fantasy points subject to salary cap and position constraints
Args:
player_list: list of dictionaries with keys: name, team, pos, salary
pred_points
force_in: list of player names to force in lineup
force_out: list of player names to exclude from lineup
'''
# You need a GUROBI license to run this code
if 'GUROBI' not in cvx.installed_solvers():
raise Exception('GUROBI license required to use this function!')
def position_constraint(player_list, pos):
'''
Helper function to create a sparse position constraint matrix
'''
A = np.array(map(lambda x: x['pos'] == pos, player_list),
dtype=np.intp)
return A
def force_constraint(player_list, force_list):
'''
Helper function to create a sparse matrix for force in/out player
constraint
'''
n_force = len(force_list)
n_players = len(player_list)
V = np.ones(n_force)
I = np.arange(n_force)
J = [i for (i, player) in enumerate(player_list)
if player['name'] in force_list]
return sparse.coo_matrix((V, (I, J)), shape=(n_force, n_players))
# Create constraint matrices
A_qb = position_constraint(player_list, 'QB')
A_rb = position_constraint(player_list, 'RB')
A_wr = position_constraint(player_list, 'WR')
A_te = position_constraint(player_list, 'TE')
A_k = position_constraint(player_list, 'K')
A_dst = position_constraint(player_list, 'D')
A_force_in = force_constraint(player_list, force_in)
A_force_out = force_constraint(player_list, force_out)
salary = np.array([player['salary'] for player in player_list])
pred_points = np.array([player['pred_points'] for player in player_list])
# Set up optimization problem and solve
players = cvx.Bool(len(player_list))
constraints = [A_qb*players == 1,
A_rb*players == 2,
A_wr*players == 3,
A_te*players == 1,
A_k*players == 1,
A_dst*players == 1,
salary.T*players <= salary_cap
]
if len(force_in) > 0:
constraints.append(A_force_in*players == np.ones(A_force_in.shape[0]))
if len(force_out) > 0:
constraints.append(A_force_out*players ==
np.zeros(A_force_out.shape[0]))
objective = cvx.Maximize(players.T*pred_points)
prob = cvx.Problem(objective, constraints)
prob.solve(solver=cvx.GUROBI, verbose=False)
# Raise an error if solver fails, or if optimal value is 'None'
if (players.value is None) or prob.status != 'optimal':
raise LineupError('Failed to Solve: check salary_cap!')
# Return lineup as a nice object
return Lineup(player_list, players.value)
