def graph_implementation(arg_objs, size, data=None):
"""Sum the linear expression's entries.
Parameters
----------
arg_objs : list
LinExpr for each argument.
size : tuple
The size of the resulting expression.
data :
Additional data required by the atom.
Returns
-------
tuple
(LinOp for objective, list of constraints)
"""
axis = data[0]
if axis is None:
obj = lu.sum_entries(arg_objs[0])
elif axis == 1:
const_size = (arg_objs[0].size[1], 1)
ones = lu.create_const(np.ones(const_size), const_size)
obj = lu.rmul_expr(arg_objs[0], ones, size)
else: # axis == 0
const_size = (1, arg_objs[0].size[0])
ones = lu.create_const(np.ones(const_size), const_size)
obj = lu.mul_expr(ones, arg_objs[0], size)
return (obj, [])
def graph_implementation(arg_objs, size, data=None):
"""Reduces the atom to an affine expression and list of constraints.
Parameters
----------
arg_objs : list
LinExpr for each argument.
size : tuple
The size of the resulting expression.
data :
Additional data required by the atom.
Returns
-------
tuple
(LinOp for objective, list of constraints)
"""
# min sum_entries(t) + kq
# s.t. x <= t + q
# 0 <= t
x = arg_objs[0]
k = lu.create_const(data[0], (1, 1))
q = lu.create_var((1, 1))
t = lu.create_var(x.size)
sum_t = lu.sum_entries(t)
obj = lu.sum_expr([sum_t, lu.mul_expr(k, q, (1, 1))])
prom_q = lu.promote(q, x.size)
constr = [lu.create_leq(x, lu.sum_expr([t, prom_q])),
lu.create_geq(t)]
return (obj, constr)
def graph_implementation(arg_objs, size, data=None):
"""Reduces the atom to an affine expression and list of constraints.
Parameters
----------
arg_objs : list
LinExpr for each argument.
size : tuple
The size of the resulting expression.
data :
Additional data required by the atom.
Returns
-------
tuple
(LinOp for objective, list of constraints)
"""
# min sum_entries(t) + kq
# s.t. x <= t + q
# 0 <= t
x = arg_objs[0]
k = lu.create_const(data[0], (1, 1))
q = lu.create_var((1, 1))
t = lu.create_var(x.size)
sum_t = lu.sum_entries(t)
obj = lu.sum_expr([sum_t, lu.mul_expr(k, q, (1, 1))])
prom_q = lu.promote(q, x.size)
constr = [lu.create_leq(x, lu.sum_expr([t, prom_q])), lu.create_geq(t)]
return (obj, constr)
def graph_implementation(arg_objs, size, data=None):
"""Sum the linear expression's entries.
Parameters
----------
arg_objs : list
LinExpr for each argument.
size : tuple
The size of the resulting expression.
data :
Additional data required by the atom.
Returns
-------
tuple
(LinOp for objective, list of constraints)
"""
axis = data[0]
if axis is None:
obj = lu.sum_entries(arg_objs[0])
elif axis == 1:
const_size = (arg_objs[0].size[1], 1)
ones = lu.create_const(np.ones(const_size), const_size)
obj = lu.rmul_expr(arg_objs[0], ones, size)
else: # axis == 0
const_size = (1, arg_objs[0].size[0])
ones = lu.create_const(np.ones(const_size), const_size)
obj = lu.mul_expr(ones, arg_objs[0], size)
return (obj, [])
def graph_implementation(arg_objs, size, data=None):
"""Reduces the atom to an affine expression and list of constraints.
Parameters
----------
arg_objs : list
LinExpr for each argument.
size : tuple
The size of the resulting expression.
data :
Additional data required by the atom.
Returns
-------
tuple
(LinOp for objective, list of constraints)
"""
x = arg_objs[0]
t = lu.create_var((1, 1))
# sum(exp(x - t))
prom_t = lu.promote(t, x.size)
expr = lu.sub_expr(x, prom_t)
obj, constraints = exp.graph_implementation([expr], x.size)
obj = lu.sum_entries(obj)
# obj <= 1
one = lu.create_const(1, (1, 1))
constraints += [lu.create_leq(obj, one)]
return (t, constraints)
def test_sum(self):
"""Test sum entries op.
"""
shape = (5, 5)
x = create_var(shape)
expr = sum_entries(x, (1, 1))
self.assertEqual(expr.shape, (1, 1))
self.assertEqual(len(expr.args), 1)
self.assertEqual(expr.type, SUM_ENTRIES)
def graph_implementation(arg_objs, size, data=None):
"""Reduces the atom to an affine expression and list of constraints.
Parameters
----------
arg_objs : list
LinExpr for each argument.
size : tuple
The size of the resulting expression.
data :
Additional data required by the atom.
Returns
-------
tuple
(LinOp for objective, list of constraints)
"""
x = arg_objs[0]
axis = data[0]
t = lu.create_var(size)
# sum(exp(x - t)) <= 1
if axis is None:
prom_t = lu.promote(t, x.size)
expr = lu.sub_expr(x, prom_t)
obj, constraints = exp.graph_implementation([expr], x.size)
obj = lu.sum_entries(obj)
elif axis == 0:
prom_size = (x.size[0], 1)
ones = lu.create_const(np.ones(prom_size), prom_size)
prom_t = lu.mul_expr(ones, t, x.size)
expr = lu.sub_expr(x, prom_t)
obj, constraints = exp.graph_implementation([expr], x.size)
const_size = (1, x.size[0])
ones = lu.create_const(np.ones(const_size), const_size)
obj = lu.mul_expr(ones, obj, size)
else: # axis == 1
prom_size = (1, x.size[1])
ones = lu.create_const(np.ones(prom_size), prom_size)
prom_t = lu.rmul_expr(t, ones, x.size)
expr = lu.sub_expr(x, prom_t)
obj, constraints = exp.graph_implementation([expr], x.size)
const_size = (x.size[1], 1)
ones = lu.create_const(np.ones(const_size), const_size)
obj = lu.rmul_expr(obj, ones, size)
ones = lu.create_const(np.ones(size), size)
constraints += [lu.create_leq(obj, ones)]
return (t, constraints)
def graph_implementation(arg_objs, size, data=None):
"""Reduces the atom to an affine expression and list of constraints.
Parameters
----------
arg_objs : list
LinExpr for each argument.
size : tuple
The size of the resulting expression.
data :
Additional data required by the atom.
Returns
-------
tuple
(LinOp for objective, list of constraints)
"""
x = arg_objs[0]
axis = data[0]
t = lu.create_var(size)
# sum(exp(x - t)) <= 1
if axis is None:
prom_t = lu.promote(t, x.size)
expr = lu.sub_expr(x, prom_t)
obj, constraints = exp.graph_implementation([expr], x.size)
obj = lu.sum_entries(obj)
elif axis == 0:
prom_size = (x.size[0], 1)
ones = lu.create_const(np.ones(prom_size), prom_size)
prom_t = lu.mul_expr(ones, t, x.size)
expr = lu.sub_expr(x, prom_t)
obj, constraints = exp.graph_implementation([expr], x.size)
const_size = (1, x.size[0])
ones = lu.create_const(np.ones(const_size), const_size)
obj = lu.mul_expr(ones, obj, size)
else: # axis == 1
prom_size = (1, x.size[1])
ones = lu.create_const(np.ones(prom_size), prom_size)
prom_t = lu.rmul_expr(t, ones, x.size)
expr = lu.sub_expr(x, prom_t)
obj, constraints = exp.graph_implementation([expr], x.size)
const_size = (x.size[1], 1)
ones = lu.create_const(np.ones(const_size), const_size)
obj = lu.rmul_expr(obj, ones, size)
ones = lu.create_const(np.ones(size), size)
constraints += [lu.create_leq(obj, ones)]
return (t, constraints)
def graph_implementation(arg_objs, size, data=None):
"""Sum the linear expression's entries.
Parameters
----------
arg_objs : list
LinExpr for each argument.
size : tuple
The size of the resulting expression.
data :
Additional data required by the atom.
Returns
-------
tuple
(LinOp for objective, list of constraints)
"""
return (lu.sum_entries(arg_objs[0]), [])
def graph_implementation(arg_objs, size, data=None):
"""Sum the linear expression's entries.
Parameters
----------
arg_objs : list
LinExpr for each argument.
size : tuple
The size of the resulting expression.
data :
Additional data required by the atom.
Returns
-------
tuple
(LinOp for objective, list of constraints)
"""
return (lu.sum_entries(arg_objs[0]), [])
def graph_implementation(self,
arg_objs,
shape: Tuple[int, ...],
data=None) -> Tuple[lo.LinOp, List[Constraint]]:
"""Sum the linear expression's entries.
Parameters
----------
arg_objs : list
LinExpr for each argument.
shape : tuple
The shape of the resulting expression.
data :
Additional data required by the atom.
Returns
-------
tuple
(LinOp for objective, list of constraints)
"""
axis = data[0]
keepdims = data[1]
if axis is None:
obj = lu.sum_entries(arg_objs[0], shape=shape)
elif axis == 1:
if keepdims:
const_shape = (arg_objs[0].shape[1], 1)
else:
const_shape = (arg_objs[0].shape[1], )
ones = lu.create_const(np.ones(const_shape), const_shape)
obj = lu.rmul_expr(arg_objs[0], ones, shape)
else: # axis == 0
if keepdims:
const_shape = (1, arg_objs[0].shape[0])
else:
const_shape = (arg_objs[0].shape[0], )
ones = lu.create_const(np.ones(const_shape), const_shape)
obj = lu.mul_expr(ones, arg_objs[0], shape)
return (obj, [])
def graph_implementation(arg_objs, shape, data=None):
"""Sum the linear expression's entries.
Parameters
----------
arg_objs : list
LinExpr for each argument.
shape : tuple
The shape of the resulting expression.
data :
Additional data required by the atom.
Returns
-------
tuple
(LinOp for objective, list of constraints)
"""
obj = lu.sum_entries(arg_objs[0],
shape=shape,
axis=data[0],
keepdims=data[1])
return (obj, [])
def graph_implementation(arg_objs, size, data=None):
r"""Reduces the atom to an affine expression and list of constraints.
Parameters
----------
arg_objs : list
LinExpr for each argument.
size : tuple
The size of the resulting expression.
data :
Additional data required by the atom.
Returns
-------
tuple
(LinOp for objective, list of constraints)
Notes
-----
Implementation notes.
- For general :math:`p \geq 1`, the inequality :math:`\|x\|_p \leq t`
is equivalent to the following convex inequalities:
.. math::
|x_i| &\leq r_i^{1/p} t^{1 - 1/p}\\
\sum_i r_i &= t.
These inequalities happen to also be correct for :math:`p = +\infty`,
if we interpret :math:`1/\infty` as :math:`0`.
- For general :math:`0 < p < 1`, the inequality :math:`\|x\|_p \geq t`
is equivalent to the following convex inequalities:
.. math::
r_i &\leq x_i^{p} t^{1 - p}\\
\sum_i r_i &= t.
- For general :math:`p < 0`, the inequality :math:`\|x\|_p \geq t`
is equivalent to the following convex inequalities:
.. math::
t &\leq x_i^{-p/(1-p)} r_i^{1/(1 - p)}\\
\sum_i r_i &= t.
Although the inequalities above are correct, for a few special cases, we can represent the p-norm
more efficiently and with fewer variables and inequalities.
- For :math:`p = 1`, we use the representation
.. math::
x_i &\leq r_i\\
-x_i &\leq r_i\\
\sum_i r_i &= t
- For :math:`p = \infty`, we use the representation
.. math::
x_i &\leq t\\
-x_i &\leq t
Note that we don't need the :math:`r` variable or the sum inequality.
- For :math:`p = 2`, we use the natural second-order cone representation
.. math::
\|x\|_2 \leq t
Note that we could have used the set of inequalities given above if we wanted an alternate decomposition
of a large second-order cone into into several smaller inequalities.
"""
p = data[0]
x = arg_objs[0]
t = lu.create_var((1, 1))
constraints = []
# first, take care of the special cases of p = 2, inf, and 1
if p == 2:
return t, [SOC(t, [x])]
if p == np.inf:
t_ = lu.promote(t, x.size)
return t, [lu.create_leq(x, t_), lu.create_geq(lu.sum_expr([x, t_]))]
# we need an absolute value constraint for the symmetric convex branches (p >= 1)
# we alias |x| as x from this point forward to make the code pretty :)
if p >= 1:
absx = lu.create_var(x.size)
constraints += [lu.create_leq(x, absx), lu.create_geq(lu.sum_expr([x, absx]))]
x = absx
if p == 1:
return lu.sum_entries(x), constraints
# now, we take care of the remaining convex and concave branches
# to create the rational powers, we need a new variable, r, and
# the constraint sum(r) == t
r = lu.create_var(x.size)
t_ = lu.promote(t, x.size)
constraints += [lu.create_eq(lu.sum_entries(r), t)]
# make p a fraction so that the input weight to gm_constrs
# is a nice tuple of fractions.
p = Fraction(p)
if p < 0:
constraints += gm_constrs(t_, [x, r], (-p / (1 - p), 1 / (1 - p)))
if 0 < p < 1:
constraints += gm_constrs(r, [x, t_], (p, 1 - p))
if p > 1:
constraints += gm_constrs(x, [r, t_], (1 / p, 1 - 1 / p))
return t, constraints
def graph_implementation(arg_objs, size, data=None):
"""Reduces the atom to an affine expression and list of constraints.
Creates the equivalent problem::
maximize sum(log(D[i, i]))
subject to: D diagonal
diag(D) = diag(Z)
Z is upper triangular.
[D Z; Z.T A] is positive semidefinite
The problem computes the LDL factorization:
.. math::
A = (Z^TD^{-1})D(D^{-1}Z)
This follows from the inequality:
.. math::
\det(A) >= \det(D) + \det([D, Z; Z^T, A])/\det(D)
>= \det(D)
because (Z^TD^{-1})D(D^{-1}Z) is a feasible D, Z that achieves
det(A) = det(D) and the objective maximizes det(D).
Parameters
----------
arg_objs : list
LinExpr for each argument.
size : tuple
The size of the resulting expression.
data :
Additional data required by the atom.
Returns
-------
tuple
(LinOp for objective, list of constraints)
"""
A = arg_objs[0] # n by n matrix.
n, _ = A.size
X = lu.create_var((2 * n, 2 * n))
X, constraints = Semidef(2 * n).canonical_form
Z = lu.create_var((n, n))
D = lu.create_var((n, 1))
# Require that X and A are PSD.
constraints += [SDP(A)]
# Fix Z as upper triangular, D as diagonal,
# and diag(D) as diag(Z).
Z_lower_tri = lu.upper_tri(lu.transpose(Z))
constraints.append(lu.create_eq(Z_lower_tri))
# D[i, i] = Z[i, i]
constraints.append(lu.create_eq(D, lu.diag_mat(Z)))
# Fix X using the fact that A must be affine by the DCP rules.
# X[0:n, 0:n] == D
index.block_eq(X, lu.diag_vec(D), constraints, 0, n, 0, n)
# X[0:n, n:2*n] == Z,
index.block_eq(X, Z, constraints, 0, n, n, 2 * n)
# X[n:2*n, n:2*n] == A
index.block_eq(X, A, constraints, n, 2 * n, n, 2 * n)
# Add the objective sum(log(D[i, i])
obj, constr = log.graph_implementation([D], (n, 1))
return (lu.sum_entries(obj), constraints + constr)
def graph_implementation(arg_objs, size, data=None):
"""Reduces the atom to an affine expression and list of constraints.
Creates the equivalent problem::
maximize sum(log(D[i, i]))
subject to: D diagonal
diag(D) = diag(Z)
Z is upper triangular.
[D Z; Z.T A] is positive semidefinite
The problem computes the LDL factorization:
.. math::
A = (Z^TD^{-1})D(D^{-1}Z)
This follows from the inequality:
.. math::
\det(A) >= \det(D) + \det([D, Z; Z^T, A])/\det(D)
>= \det(D)
because (Z^TD^{-1})D(D^{-1}Z) is a feasible D, Z that achieves
det(A) = det(D) and the objective maximizes det(D).
Parameters
----------
arg_objs : list
LinExpr for each argument.
size : tuple
The size of the resulting expression.
data :
Additional data required by the atom.
Returns
-------
tuple
(LinOp for objective, list of constraints)
"""
A = arg_objs[0] # n by n matrix.
n, _ = A.size
X = lu.create_var((2*n, 2*n))
Z = lu.create_var((n, n))
D = lu.create_var((n, n))
# Require that X and A are PSD.
constraints = [SDP(X), SDP(A)]
# Fix Z as upper triangular, D as diagonal,
# and diag(D) as diag(Z).
for i in xrange(n):
for j in xrange(n):
if i != j:
# D[i, j] == 0
Dij = index.get_index(D, constraints, i, j)
constraints.append(lu.create_eq(Dij))
if i > j:
# Z[i, j] == 0
Zij = index.get_index(Z, constraints, i, j)
constraints.append(lu.create_eq(Zij))
# D[i, i] = Z[i, i]
constraints.append(lu.create_eq(lu.diag_mat(D), lu.diag_mat(Z)))
# Fix X using the fact that A must be affine by the DCP rules.
# X[0:n, 0:n] == D
index.block_eq(X, D, constraints, 0, n, 0, n)
# X[0:n, n:2*n] == Z,
index.block_eq(X, Z, constraints, 0, n, n, 2*n)
# X[n:2*n, n:2*n] == A
index.block_eq(X, A, constraints, n, 2*n, n, 2*n)
# Add the objective sum(log(D[i, i])
diag = lu.diag_mat(D)
obj, constr = log.graph_implementation([diag], (n, 1))
return (lu.sum_entries(obj), constraints + constr)
def graph_implementation(arg_objs, size, data=None):
r"""Reduces the atom to an affine expression and list of constraints.
Parameters
----------
arg_objs : list
LinExpr for each argument.
size : tuple
The size of the resulting expression.
data :
Additional data required by the atom.
Returns
-------
tuple
(LinOp for objective, list of constraints)
Notes
-----
Implementation notes.
For general ``p``, the p-norm is equivalent to the following convex inequalities:
.. math::
x_i &\leq r_i\\
-x_i &\leq r_i\\
r_i &\leq s_i^{1/p} t^{1 - 1/p}\\
\sum_i s_i &\leq t,
where :math:`p \geq 1`.
These inequalities are also correct for :math:`p = +\infty` if we interpret :math:`1/\infty` as :math:`0`.
Although the inequalities above are correct, for a few special cases, we can represent the p-norm
more efficiently and with fewer variables and inequalities.
- For :math:`p = 1`, we use the representation
.. math::
x_i &\leq r_i\\
-x_i &\leq r_i\\
\sum_i r_i &\leq t
- For :math:`p = \infty`, we use the representation
.. math::
x_i &\leq t\\
-x_i &\leq t
Note that we don't need the :math:`s` variables or the sum inequality.
- For :math:`p = 2`, we use the natural second-order cone representation
.. math::
\|x\|_2 \leq t
Note that we could have used the set of inequalities given above if we wanted an alternate decomposition
of a large second-order cone into into several smaller inequalities.
"""
p, w = data
x = arg_objs[0]
t = None # dummy value so linter won't complain about initialization
if p != 1:
t = lu.create_var((1, 1))
if p == 2:
return t, [SOC(t, [x])]
if p == np.inf:
r = lu.promote(t, x.size)
else:
r = lu.create_var(x.size)
constraints = [lu.create_geq(lu.sum_expr([x, r])),
lu.create_leq(x, r)]
if p == 1:
return lu.sum_entries(r), constraints
if p == np.inf:
return t, constraints
# otherwise do case of general p
s = lu.create_var(x.size)
# todo: no need to run gm_constr to form the tree each time. we only need to form the tree once
constraints += gm_constrs(r, [s, lu.promote(t, x.size)], w)
constraints += [lu.create_leq(lu.sum_entries(s), t)]
return t, constraints
