Ejemplo n.º 1
0
def test_least_abs_deviations():
    problem = compiler.compile_problem(cvxpy_expr.convert_problem(
        least_abs_dev.create(m=10, n=5)))
    assert_items_equal(
        prox_ops(problem.objective),
        [Prox.CONSTANT, Prox.NORM_1])
    assert_equal(1, len(problem.constraint))
Ejemplo n.º 2
0
def write_problem(cvxpy_prob, location, name):
    """Utility function to write problems for analysis."""

    mem_prefix = "/mem/"
    file_prefix = "/local" + location + "/"

    def rewrite_location(name):
        assert name[:len(mem_prefix)] == mem_prefix
        return file_prefix + name[len(mem_prefix):]

    makedirs_existok(location)
    prob_proto = cvxpy_expr.convert_problem(cvxpy_prob)
    prob_proto = compiler.compile_problem(prob_proto)

    modify_data_location(prob_proto.objective, rewrite_location)
    for constraint in prob_proto.constraint:
        modify_data_location(constraint, rewrite_location)

    with open(os.path.join(location, name), "w") as f:
        f.write(prob_proto.SerializeToString())

    for name, value in list(constant.global_data_map.items()):
        assert name[:len(mem_prefix)] == mem_prefix
        filename = os.path.join(location, name[len(mem_prefix):])
        makedirs_existok(os.path.dirname(filename))
        with open(filename, "w") as f:
            f.write(value)
Ejemplo n.º 3
0
def test_tv_denoise():
    problem = compiler.compile_problem(cvxpy_expr.convert_problem(
        tv_denoise.create(n=10, lam=1)))
    assert_items_equal(
        prox_ops(problem.objective),
        3*[Prox.SUM_SQUARE] + [Prox.AFFINE] + [Prox.SECOND_ORDER_CONE])
    assert_equal(2, len(problem.constraint))
Ejemplo n.º 4
0
def write_problem(cvxpy_prob, location, name):
    """Utility function to write problems for analysis."""

    mem_prefix = "/mem/"
    file_prefix = "/local" + location + "/"

    def rewrite_location(name):
        assert name[: len(mem_prefix)] == mem_prefix
        return file_prefix + name[len(mem_prefix) :]

    makedirs_existok(location)
    prob_proto = cvxpy_expr.convert_problem(cvxpy_prob)
    prob_proto = compiler.compile_problem(prob_proto)

    modify_data_location(prob_proto.objective, rewrite_location)
    for constraint in prob_proto.constraint:
        modify_data_location(constraint, rewrite_location)

    with open(os.path.join(location, name), "w") as f:
        f.write(prob_proto.SerializeToString())

    for name, value in constant.global_data_map.items():
        assert name[: len(mem_prefix)] == mem_prefix
        filename = os.path.join(location, name[len(mem_prefix) :])
        makedirs_existok(os.path.dirname(filename))
        with open(filename, "w") as f:
            f.write(value)
Ejemplo n.º 5
0
def test_tv_1d():
    problem = compiler.compile_problem(cvxpy_expr.convert_problem(
        tv_1d.create(n=10)))
    assert_items_equal(
        prox_ops(problem.objective),
        [Prox.TOTAL_VARIATION_1D] + [Prox.SUM_SQUARE])
    assert_equal(1, len(problem.constraint))
Ejemplo n.º 6
0
def test_tv_denoise():
    problem = compiler.compile_problem(
        cvxpy_expr.convert_problem(tv_denoise.create(n=10, lam=1)))
    assert_items_equal(
        prox_ops(problem.objective),
        3 * [Prox.SUM_SQUARE] + [Prox.AFFINE] + [Prox.SECOND_ORDER_CONE])
    assert_equal(2, len(problem.constraint))
Ejemplo n.º 7
0
def test_basis_pursuit():
    problem = compiler.compile_problem(cvxpy_expr.convert_problem(
        basis_pursuit.create(m=10, n=30)))
    assert_items_equal(
        prox_ops(problem.objective),
        [Prox.CONSTANT, Prox.NORM_1])
    assert_equal(2, len(problem.constraint))
Ejemplo n.º 8
0
def eval_prox(prox_function_type, prob, v_map, lam=1, epigraph=False):
    """Evaluate a single proximal operator."""

    problem = compiler.compile_problem(cvxpy_expr.convert_problem(prob))
    validate.check_sum_of_prox(problem)

    # Get the first non constant objective term
    if len(problem.objective.arg) != 1:
        raise ProblemError("prox does not have single f", problem)

    if problem.constraint:
        raise ProblemError("prox has constraints", problem)

    f_expr = problem.objective.arg[0]
    if (f_expr.expression_type != Expression.PROX_FUNCTION or
        f_expr.prox_function.prox_function_type != prox_function_type or
        f_expr.prox_function.epigraph != epigraph):
        raise ProblemError("prox did not compile to right type", problem)

    v_bytes_map = {cvxpy_expr.variable_id(var):
                   numpy.array(val, dtype=numpy.float64).tobytes(order="F")
                   for var, val in v_map.iteritems()}

    values = _solve.eval_prox(
        f_expr.SerializeToString(),
        lam,
        constant.global_data_map,
        v_bytes_map)

    cvxpy_solver.set_solution(prob, values)
Ejemplo n.º 9
0
def compile_problem(cvxpy_prob, solver_params):
    t0 = time.time()
    problem = cvxpy_expr.convert_problem(cvxpy_prob)
    problem = compiler.compile_problem(problem, solver_params)
    t1 = time.time()

    if solver_params.verbose:
        print "Epsilon %s" % __version__
        print "Compiled prox-affine form:"
        print text_format.format_problem(problem),
        print "Epsilon compile time: %.4f seconds" % (t1-t0)
        print
    logging.debug("Compiled prox-affine form:\n%s",
                  text_format.format_problem(problem))
    logging.info("Epsilon compile time: %.4f seconds", t1-t0)

    return problem
Ejemplo n.º 10
0
def compile_problem(cvxpy_prob, solver_params):
    t0 = time.time()
    problem = cvxpy_expr.convert_problem(cvxpy_prob)
    problem = compiler.compile_problem(problem, solver_params)
    t1 = time.time()

    if solver_params.verbose:
        print "Epsilon %s" % __version__
        print "Compiled prox-affine form:"
        print text_format.format_problem(problem),
        print "Epsilon compile time: %.4f seconds" % (t1 - t0)
        print
    logging.debug("Compiled prox-affine form:\n%s",
                  text_format.format_problem(problem))
    logging.info("Epsilon compile time: %.4f seconds", t1 - t0)

    return problem
Ejemplo n.º 11
0
def solve(cvxpy_prob, **kwargs):
    """Solve optimziation problem."""

    # Nothing to do in this case
    if not cvxpy_prob.variables():
        return OPTIMAL, cvxpy_prob.objective.value

    params = solver_params_pb2.SolverParams(**kwargs)

    t0 = time.time()
    problem = cvxpy_expr.convert_problem(cvxpy_prob)
    problem = compiler.compile_problem(problem, params)
    t1 = time.time()

    if params.verbose:
        print "Epsilon %s" % __version__
        print "Compiled prox-affine form:"
        print text_format.format_problem(problem),
        print "Epsilon compile time: %.4f seconds" % (t1 - t0)
        print
    logging.debug("Compiled prox-affine form:\n%s", text_format.format_problem(problem))
    logging.info("Epsilon compile time: %.4f seconds", t1 - t0)

    if len(problem.objective.arg) == 1 and not problem.constraint:
        # TODO(mwytock): Should probably parameterize the proximal operators so
        # they can take A=0 instead of just using a large lambda here
        lam = 1e12
        values = _solve.eval_prox(problem.objective.arg[0].SerializeToString(), lam, constant.global_data_map, {})
        status = OPTIMAL
    else:
        params = solver_params_pb2.SolverParams(**kwargs)
        status_str, values = _solve.prox_admm_solve(
            problem.SerializeToString(), params.SerializeToString(), constant.global_data_map
        )
        status = cvxpy_status(SolverStatus.FromString(status_str))
    t2 = time.time()

    logging.info("Epsilon solve time: %.4f seconds", t2 - t1)
    if params.verbose:
        print "Epsilon solve time: %.4f seconds" % (t2 - t1)

    set_solution(cvxpy_prob, values)
    return status, cvxpy_prob.objective.value
Ejemplo n.º 12
0
def eval_prox_impl(prob,
                   v_map,
                   lam=1,
                   prox_function_type=None,
                   epigraph=False):
    """Evaluate a single proximal operator."""

    problem = compiler.compile_problem(cvxpy_expr.convert_problem(prob))
    validate.check_sum_of_prox(problem)

    # Get the first non constant objective term
    if len(problem.objective.arg) != 1:
        raise ProblemError("prox does not have single f", problem)

    if problem.constraint:
        raise ProblemError("prox has constraints", problem)

    f_expr = problem.objective.arg[0]
    if f_expr.expression_type != Expression.PROX_FUNCTION:
        raise ProblemError("prox did not compile to right type", problem)

    if prox_function_type is not None and (
            f_expr.prox_function.prox_function_type != prox_function_type
            or f_expr.prox_function.epigraph != epigraph):
        raise ProblemError("prox did not compile to right type", problem)

    v_bytes_map = {
        cvxpy_expr.variable_id(var):
        numpy.array(val, dtype=numpy.float64).tobytes(order="F")
        for var, val in v_map.iteritems()
    }

    values = _solve.eval_prox(f_expr.SerializeToString(), lam,
                              problem.expression_data(), v_bytes_map)

    cvxpy_solver.set_solution(prob, values)
Ejemplo n.º 13
0
def test_basis_pursuit():
    problem = compiler.compile_problem(
        cvxpy_expr.convert_problem(basis_pursuit.create(m=10, n=30)))
    assert_items_equal(prox_ops(problem.objective),
                       [Prox.CONSTANT, Prox.NORM_1])
    assert_equal(2, len(problem.constraint))
Ejemplo n.º 14
0
def test_tv_1d():
    problem = compiler.compile_problem(
        cvxpy_expr.convert_problem(tv_1d.create(n=10)))
    assert_items_equal(prox_ops(problem.objective),
                       [Prox.TOTAL_VARIATION_1D] + [Prox.SUM_SQUARE])
    assert_equal(1, len(problem.constraint))
Ejemplo n.º 15
0
from epopt import tree_format
from epopt.compiler import compiler
from epopt.problems import *

FORMATTERS = {
    "text": text_format.format_problem,
    "tree": tree_format.format_problem,
}

if __name__ == "__main__":
    parser = argparse.ArgumentParser()
    parser.add_argument("problem")
    parser.add_argument("kwargs", help="Problem arg, e.g. {\"m\": 10}")
    parser.add_argument("--format", default="text")
    args = parser.parse_args()

    formatter = FORMATTERS[args.format]

    cvxpy_prob = locals()[args.problem].create(**json.loads(args.kwargs))
    problem = cvxpy_expr.convert_problem(cvxpy_prob)

    print "original:"
    print formatter(problem)

    for transform in compiler.TRANSFORMS:
        problem = transform(problem)

        print
        print ".".join((transform.__module__, transform.__name__)) + ":"
        print formatter(problem)
Ejemplo n.º 16
0
def test_least_abs_deviations():
    problem = compiler.compile_problem(
        cvxpy_expr.convert_problem(least_abs_dev.create(m=10, n=5)))
    assert_items_equal(prox_ops(problem.objective),
                       [Prox.CONSTANT, Prox.NORM_1])
    assert_equal(1, len(problem.constraint))
Ejemplo n.º 17
0
#!/usr/bin/env python

import numpy as np
import cvxpy as cp

from epopt import cvxpy_expr
from epopt import expression_vis
from epopt.compiler import canonicalize

if __name__ == "__main__":
    n = 5
    x = cp.Variable(n)

    # Lasso expression tree
    m = 10
    A = np.random.randn(m, n)
    b = np.random.randn(m)
    lam = 1
    f = cp.sum_squares(A * x - b) + lam * cp.norm1(x)
    prob0 = cvxpy_expr.convert_problem(cp.Problem(cp.Minimize(f)))[0]
    expression_vis.graph(prob0.objective).write("expr_lasso.dot")

    # Canonicalization of a more complicated example
    c = np.random.randn(n)
    f = cp.exp(cp.norm(x) + c.T * x) + cp.norm1(x)
    prob0 = cvxpy_expr.convert_problem(cp.Problem(cp.Minimize(f)))[0]
    expression_vis.graph(prob0.objective).write("expr_epigraph.dot")
    prob1 = canonicalize.transform(prob0)
    expression_vis.graph(prob1.objective).write("expr_epigraph_canon.dot")
Ejemplo n.º 18
0
#!/usr/bin/env python

import numpy as np
import cvxpy as cp

from epopt import cvxpy_expr
from epopt import expression_vis
from epopt.compiler import canonicalize

if __name__ == "__main__":
    n = 5
    x = cp.Variable(n)

    # Lasso expression tree
    m = 10
    A = np.random.randn(m,n)
    b = np.random.randn(m)
    lam = 1
    f = cp.sum_squares(A*x - b) + lam*cp.norm1(x)
    prob0 = cvxpy_expr.convert_problem(cp.Problem(cp.Minimize(f)))[0]
    expression_vis.graph(prob0.objective).write("expr_lasso.dot")

    # Canonicalization of a more complicated example
    c = np.random.randn(n)
    f = cp.exp(cp.norm(x) + c.T*x) + cp.norm1(x)
    prob0 = cvxpy_expr.convert_problem(cp.Problem(cp.Minimize(f)))[0]
    expression_vis.graph(prob0.objective).write("expr_epigraph.dot")
    prob1 = canonicalize.transform(prob0)
    expression_vis.graph(prob1.objective).write("expr_epigraph_canon.dot")