コード例 #1
0
ファイル: cbp.py プロジェクト: voidoutpost/qcml
          norm(u,v) <= radii*c

          # rctheta is going to be a diagonal matrix
          # rctheta[i]*c[i] <= u[i] implemented with rctheta a diag matrix
          rctheta*c <= u
    """)

    # More natural formulation would be:
    # minimize 1/(sqrt(2)*noisesigma) * (data - (dictc*c + dictu(u + dictv*v)) + lambda'*c)
    # subject to
    #   sqrt(u.^2 + v.^2) <= radii.*c
    #   radii.*cos(theta) <= u

    raw_input("press ENTER to canonicalize....")
    p.canonicalize()

    raw_input("press ENTER to generate code....")
    if m and n: p.dims = {'m': m, 'n': n}
    p.codegen(args.codegen)

    raw_input("press ENTER for raw code....")
    p.printsource()

    #socp_data = p.prob2socp(params=locals())
    #import ecos
    #sol = ecos.ecos(**socp_data)
    #my_vars = p.socp2prob(sol['x'])
    #pr.disable()
    #ps = pstats.Stats(pr)
    #ps.sort_stats('cumulative').print_stats(.5)
コード例 #2
0
ファイル: svm.py プロジェクト: chinasaur/qcml
    # a QCML model is specified by strings
    #   the parser parses each model line by line and builds an internal
    #   representation of an SOCP
    s = """
    dimensions m n
    variable a(n)
    variable b
    parameter X(m,n)      # positive samples
    parameter Y(m,n)      # negative samples
    parameter gamma positive
    minimize (norm(a) + gamma*sum(pos(1 - X*a + b) + pos(1 + Y*a - b)))
    """
    print s

    raw_input("press ENTER to parse....")
    p = QCML(debug=True)
    p.parse(s)

    raw_input("press ENTER to canonicalize....")
    p.canonicalize()

    raw_input("press ENTER to generate code....")
    p.dims = {'n': n, 'm': m}
    p.codegen("python")

    raw_input("press ENTER to solve with ECOS....")
    socp_data = p.prob2socp(params=locals())
    import ecos
    sol = ecos.solve(**socp_data)
コード例 #3
0
for i in range(m):
    a = np.random.randn(n)
    a = a / np.linalg.norm(a)
    bi = 1 + np.random.rand(1)

    A[i, :] = a
    b[i] = bi

q = QCML()
q.parse('''
        dimensions m n
        variables x(n) r
        parameters A(m,n) b(m)
        maximize r
        A*x + r <= b
        ''')
q.canonicalize()
q.dims = {'m': m, 'n': n}
q.codegen("python")
socp_data = q.prob2socp(locals())

# stuffed variable size
n = socp_data['G'].shape[1]

ecos_sol = ecos.solve(**socp_data)
socp_sol = ecos_sol['x']

prob_sol_x = q.socp2prob(ecos_sol['x'])['x']
prob_sol_r = q.socp2prob(ecos_sol['x'])['r']
コード例 #4
0
    for i in xrange(T):
        objective += ["square(norm(Q*x%i)) + square(norm(R*u%i))" % (i,i)]

    #objective += ["square(norm(Q*x%i))" % T]
    problem += ["minimize (1/2)*(" + ' + '.join(objective) + ")"]

    s = '\n'.join(map(lambda x:'    ' + x, problem))
    print s

    raw_input("press ENTER to parse....")
    p = QCML(debug=True)
    p.parse(s)

    raw_input("press ENTER to canonicalize....")
    p.canonicalize()

    raw_input("press ENTER to generate code....")
    p.dims = {'n': n, 'm': m}
    p.codegen("python")

    raw_input("press ENTER to solve with ECOS....")
    socp_data = p.prob2socp(params=locals())
    import ecos
    sol = ecos.solve(**socp_data)






コード例 #5
0
n = 20
A = np.random.randn(m, n)
b = np.random.randn(m)

q = QCML()

q.parse('''
dimensions m n
variable x(n)
parameters A(m,n) b(m)
minimize norm1(x)
A*x == b
''')
q.canonicalize()
q.dims = {'m': m, 'n': n}
q.codegen('python')

socp_vars = q.prob2socp(locals())

# convert to CSR for fast row slicing to distribute problem
socp_vars['A'] = socp_vars['A'].tocsr()
socp_vars['G'] = socp_vars['G'].tocsr()

# the size of the stuffed x or v
n = socp_vars['A'].shape[1]

ecos_sol = ecos.solve(**socp_vars)

# solution to transformed socp (stuffed)
socp_sol = ecos_sol['x']
# solution to original problem (unstuffed)
コード例 #6
0
ファイル: svm.py プロジェクト: voidoutpost/qcml
    parameter Y(m,n)      # negative samples
    parameter gamma positive
    minimize (norm(a) + gamma*sum(pos(1 - X*a + b) + pos(1 + Y*a - b)))
    """
    print s

    raw_input("press ENTER to parse....")
    p = QCML(debug=True)
    p.parse(s)

    raw_input("press ENTER to canonicalize....")
    p.canonicalize()

    raw_input("press ENTER to generate code....")
    p.dims = {'n': n, 'm': m}
    p.codegen("python")

    raw_input("press ENTER to solve with ECOS....")
    socp_data = p.prob2socp(params=locals())
    import ecos
    sol = ecos.solve(**socp_data)

    raw_input("press ENTER to generate operator....")
    p.codegen("operator")
    other = p.prob2socp(params=locals())

    x = randn(204, )
    y = randn(403, )

    raw_input(
        "press ENTER to check operator G does the same thing as matrix G....")
コード例 #7
0
ファイル: main.py プロジェクト: cvxgrp/qcml
    p.parse("""
        dimensions m n
        variable a(n)
        variable b
        parameter X(m,n)      # positive samples
        parameter Y(m,n)      # negative samples
        parameter gamma positive

        minimize (norm(a) + gamma*sum(pos(1 - X*a + b) + pos(1 + Y*a - b)))
    """)

    p.canonicalize()
    p.dims = {'m':m,'n':n}
    if not args.cvx:
        p.codegen("python")
    else:
        p.codegen("matlab",cone_size=q)
    #p.prettyprint()

elif args.portfolio:
    p.parse("""
        dimensions m n

        variable x(n)
        parameter mu(n)
        parameter gamma positive
        parameter F(n,m)
        parameter D(n,n)
        dual variables u v
        maximize (mu'*x - gamma*(square(norm(F'*x)) + square(norm(D*x))))
コード例 #8
0
ファイル: lasso.py プロジェクト: chinasaur/qcml
    minimize (square(norm(A*x - b)) + gamma*norm1(x))
    """
    print s

    raw_input("press ENTER to parse....")
    p = QCML(debug=True)
    p.parse(s)

    raw_input("press ENTER to canonicalize....")
    p.canonicalize()

    raw_input("press ENTER to solve the problem....")
    res = p.solve()

    raw_input("press ENTER to generate C code and save it....")
    p.codegen("C")
    p.save("lasso")

    raw_input("press ENTER to write the test C program....")
    c_template = """
#include <stdio.h>
#include "lasso.h"
#include "ecos.h"

int read_file(const char * file, void *x, size_t size, size_t num)
{
  FILE *f;
  f = fopen(file, "rb");
  if (!f)
  {
    printf("Unable to open %%s!\\n", file);
コード例 #9
0
ファイル: lasso.py プロジェクト: nkhuyu/qcml
    minimize (square(norm(A*x - b)) + gamma*norm1(x))
    """
    print s

    raw_input("press ENTER to parse....")
    p = QCML(debug=True)
    p.parse(s)

    raw_input("press ENTER to canonicalize....")
    p.canonicalize()

    raw_input("press ENTER to solve the problem....")
    res = p.solve()

    raw_input("press ENTER to generate C code and save it....")
    p.codegen("C")
    print p.prob2socp.source
    p.save("lasso")

    raw_input("press ENTER to write the test C program....")
    c_template = """
#include <stdio.h>
#include "lasso.h"
#include "ecos.h"

int read_file(const char * file, void *x, size_t size, size_t num)
{
  FILE *f;
  f = fopen(file, "rb");
  if (!f)
  {
コード例 #10
0
parameter g(mn)
parameter mu positive
parameter D(two_mn, mn)
parameter blurmat(mn,mn)
minimize mu*norm(blurmat*x - g) + norm(D*x)
"""

D = sp.vstack([dxmat, dymat]).tocsc()
blurred = blurmat*imgvec + 5*np.random.randn(rows*cols)
from qcml import QCML
import ecos
p = QCML()
p.parse(text)
p.canonicalize()
dims = {'mn':rows*cols, 'two_mn':D.shape[0]}
p.codegen("python")  # this creates a solver in Python calling CVXOPT
socp_data = p.prob2socp({'blurmat':blurmat,
                         'g':blurred,
                         'D':D,
                         'mu':25}, dims)
# sol = ecos.solve(**socp_data)
print socp_data
A = socp_data['G']
c = socp_data['c']
b = socp_data['h']
data = {'A':A, 'c':c, 'b':b}
cone = socp_data['dims']
sol = scs.solve(data, cone, opts = None, USE_INDIRECT = False)
my_vars = p.socp2prob(sol['x'], {'mn': rows*cols})
print my_vars
x = my_vars['x'].reshape(rows,cols)
コード例 #11
0
    p.parse("""
        dimensions m n
        variable a(n)
        variable b
        parameter X(m,n)      # positive samples
        parameter Y(m,n)      # negative samples
        parameter gamma positive

        minimize (norm(a) + gamma*sum(pos(1 - X*a + b) + pos(1 + Y*a - b)))
    """)

    p.canonicalize()
    p.dims = {'m':m,'n':n}
    if args.cvx:
        p.codegen("python")
    else:
        p.codegen("matlab",cone_size=q)
    #p.prettyprint()

elif args.portfolio:
    p.parse("""
        dimensions m n

        variable x(n)
        parameter mu(n)
        parameter gamma positive
        parameter F(n,m)
        parameter D(n,n)
        maximize (mu'*x - gamma*(square(norm(F'*x)) + square(norm(D*x))))
            sum(x) == 1
コード例 #12
0
ファイル: lasso.py プロジェクト: lcampbell/qcml
    minimize (square(norm(A*x - b)) + gamma*norm1(x))
    """
    print s

    raw_input("press ENTER to parse....")
    p = QCML(debug=True)
    p.parse(s)

    raw_input("press ENTER to canonicalize....")
    p.canonicalize()

    raw_input("press ENTER to solve the problem....")
    res = p.solve()

    raw_input("press ENTER to generate C code....")
    p.codegen("C", name="lasso")

    raw_input("press ENTER to write the test C program....")
    c_template = """
#include <stdio.h>
#include "lasso.h"
#include "ecos.h"

int read_file(const char * file, void *x, size_t size, size_t num)
{
  FILE *f;
  f = fopen(file, "rb");
  if (!f)
  {
    printf("Unable to open %%s!\\n", file);
    return 1;
コード例 #13
0
ファイル: cbp.py プロジェクト: alexvoronov/qcml
          norm(u,v) <= radii*c

          # rctheta is going to be a diagonal matrix
          # rctheta[i]*c[i] <= u[i] implemented with rctheta a diag matrix
          rctheta*c <= u
    """)

    # More natural formulation would be:
    # minimize 1/(sqrt(2)*noisesigma) * (data - (dictc*c + dictu(u + dictv*v)) + lambda'*c)
    # subject to
    #   sqrt(u.^2 + v.^2) <= radii.*c
    #   radii.*cos(theta) <= u

    raw_input("press ENTER to canonicalize....")
    p.canonicalize()

    raw_input("press ENTER to generate code....")
    if m and n: p.dims = {'m': m, 'n': n}
    p.codegen(args.codegen)

    raw_input("press ENTER for raw code....")
    p.printsource()

    #socp_data = p.prob2socp(params=locals())
    #import ecos
    #sol = ecos.ecos(**socp_data)
    #my_vars = p.socp2prob(sol['x'])
    #pr.disable()
    #ps = pstats.Stats(pr)
    #ps.sort_stats('cumulative').print_stats(.5)
コード例 #14
0
ファイル: svm.py プロジェクト: nkhuyu/qcml
    parameter Y(m,n)      # negative samples
    parameter gamma positive
    minimize (norm(a) + gamma*sum(pos(1 - X*a + b) + pos(1 + Y*a - b)))
    """
    print s

    raw_input("press ENTER to parse....")
    p = QCML(debug=True)
    p.parse(s)

    raw_input("press ENTER to canonicalize....")
    p.canonicalize()

    raw_input("press ENTER to generate code....")
    p.dims = {"n": n, "m": m}
    p.codegen("python")

    raw_input("press ENTER to solve with ECOS....")
    socp_data = p.prob2socp(params=locals())
    import ecos

    sol = ecos.solve(**socp_data)

    raw_input("press ENTER to generate operator....")
    p.codegen("operator")
    other = p.prob2socp(params=locals())

    x = randn(204)
    y = randn(403)

    raw_input("press ENTER to check operator G does the same thing as matrix G....")