Example #1
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)
Example #2
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
Example #3
0
def solve(cvxpy_prob, **kwargs):
    # Nothing to do in this case
    if not cvxpy_prob.variables():
        return OPTIMAL, cvxpy_prob.objective.value

    solver_params = solver_params_pb2.SolverParams(**kwargs)
    if solver_params.warm_start:
        problem = problem_cache.get(id(cvxpy_prob))
        if not problem:
            problem = compile_problem(cvxpy_prob, solver_params)
            problem_cache[id(cvxpy_prob)] = problem
    else:
        problem = compile_problem(cvxpy_prob, solver_params)

    t0 = time.time()
    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,
            problem.expression_data(),
            {})
        status = OPTIMAL
    else:
        data = problem.expression_data()
        status_str, values = _solve.solve(
            problem.SerializeToString(),
            parameter_values(cvxpy_prob, data),
            solver_params.SerializeToString(),
            data)
        status = cvxpy_status(SolverStatus.FromString(status_str))
    t1 = time.time()

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

    set_solution(cvxpy_prob, values)
    return status, cvxpy_prob.objective.value
Example #4
0
def solve(cvxpy_prob, **kwargs):
    # Nothing to do in this case
    if not cvxpy_prob.variables():
        return OPTIMAL, cvxpy_prob.objective.value

    solver_params = solver_params_pb2.SolverParams(**kwargs)
    if solver_params.warm_start:
        problem = problem_cache.get(id(cvxpy_prob))
        if not problem:
            problem = compile_problem(cvxpy_prob, solver_params)
            problem_cache[id(cvxpy_prob)] = problem
    else:
        problem = compile_problem(cvxpy_prob, solver_params)

    t0 = time.time()
    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, problem.expression_data(), {})
        status = OPTIMAL
    else:
        data = problem.expression_data()
        status_str, values = _solve.solve(problem.SerializeToString(),
                                          parameter_values(cvxpy_prob, data),
                                          solver_params.SerializeToString(),
                                          data)
        status = cvxpy_status(SolverStatus.FromString(status_str))
    t1 = time.time()

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

    set_solution(cvxpy_prob, values)
    return status, cvxpy_prob.objective.value
Example #5
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)