def P(u, v, alpha=1.0, beta=0.0):
"""
v := alpha * [ Qc^-1, 0, 0; 0, 0, 0; 0, 0, 0 ] * u + beta * v
"""
v *= beta
base.symv(Qinv, u, v, alpha=alpha, beta=1.0)
def checksol(sol, A, B, C = None, d = None, G = None, h = None):
"""
Check optimality conditions
C * x + G' * z + A'(Z) + d = 0
G * x <= h
z >= 0, || Z || < = 1
z' * (h - G*x) = 0
tr (Z' * (A(x) + B)) = || A(x) + B ||_*.
"""
p, q = B.size
n = A.size[1]
if G is None: G = spmatrix([], [], [], (0, n))
if h is None: h = matrix(0.0, (0, 1))
m = h.size[0]
if C is None: C = spmatrix(0.0, [], [], (n,n))
if d is None: d = matrix(0.0, (n, 1))
if sol['status'] is 'optimal':
res = +d
base.symv(C, sol['x'], res, beta = 1.0)
base.gemv(G, sol['z'], res, beta = 1.0, trans = 'T')
base.gemv(A, sol['Z'], res, beta = 1.0, trans = 'T')
print "Dual residual: %e" %blas.nrm2(res)
if m:
print "Minimum primal slack (scalar inequalities): %e" \
%min(h - G*sol['x'])
print "Minimum dual slack (scalar inequalities): %e" \
%min(sol['z'])
if p:
s = matrix(0.0, (p,1))
X = matrix(A*sol['x'], (p, q)) + B
lapack.gesvd(+X, s)
nrmX = sum(s)
lapack.gesvd(+sol['Z'], s)
nrmZ = max(s)
print "Norm of Z: %e" %nrmZ
print "Nuclear norm of A(x) + B: %e" %nrmX
print "Inner product of Z and A(x) + B: %e" \
%blas.dot(sol['Z'], X)
elif sol['status'] is 'primal infeasible':
res = matrix(0.0, (n,1))
base.gemv(G, sol['z'], res, beta = 1.0, trans = 'T')
print "Dual residual: %e" %blas.nrm2(res)
print "h' * z = %e" %blas.dot(h, sol['z'])
print "Minimum dual slack (scalar inequalities): %e" \
%min(sol['z'])
else:
pass
def checksol(sol, A, B, C=None, d=None, G=None, h=None):
"""
Check optimality conditions
C * x + G' * z + A'(Z) + d = 0
G * x <= h
z >= 0, || Z || < = 1
z' * (h - G*x) = 0
tr (Z' * (A(x) + B)) = || A(x) + B ||_*.
"""
p, q = B.size
n = A.size[1]
if G is None: G = spmatrix([], [], [], (0, n))
if h is None: h = matrix(0.0, (0, 1))
m = h.size[0]
if C is None: C = spmatrix(0.0, [], [], (n, n))
if d is None: d = matrix(0.0, (n, 1))
if sol['status'] is 'optimal':
res = +d
base.symv(C, sol['x'], res, beta=1.0)
base.gemv(G, sol['z'], res, beta=1.0, trans='T')
base.gemv(A, sol['Z'], res, beta=1.0, trans='T')
print "Dual residual: %e" % blas.nrm2(res)
if m:
print "Minimum primal slack (scalar inequalities): %e" \
%min(h - G*sol['x'])
print "Minimum dual slack (scalar inequalities): %e" \
%min(sol['z'])
if p:
s = matrix(0.0, (p, 1))
X = matrix(A * sol['x'], (p, q)) + B
lapack.gesvd(+X, s)
nrmX = sum(s)
lapack.gesvd(+sol['Z'], s)
nrmZ = max(s)
print "Norm of Z: %e" % nrmZ
print "Nuclear norm of A(x) + B: %e" % nrmX
print "Inner product of Z and A(x) + B: %e" \
%blas.dot(sol['Z'], X)
elif sol['status'] is 'primal infeasible':
res = matrix(0.0, (n, 1))
base.gemv(G, sol['z'], res, beta=1.0, trans='T')
print "Dual residual: %e" % blas.nrm2(res)
print "h' * z = %e" % blas.dot(h, sol['z'])
print "Minimum dual slack (scalar inequalities): %e" \
%min(sol['z'])
else:
pass
def softmargin_completion(Q, d, gamma):
"""
Solves the QP
minimize (1/2)*y'*Qc^{-1}*y + gamma*sum(v)
subject to diag(d)*(y + b*ones) + v >= 1
v >= 0
(with variables y, b, v) and its dual, the 'soft-margin' SVM problem,
maximize -(1/2)*z'*Qc*z + d'*z
subject to 0 <= diag(d)*z <= gamma*ones
sum(z) = 0
(with variables z).
Qc is the max determinant completion of Q.
Input arguments.
Q is a sparse N x N sparse matrix with chordal sparsity pattern
and a positive definite completion
d is an N-vector of labels -1 or 1.
gamma is a positive parameter.
F is the chompack pattern corresponding to Q. If F is None, the
pattern is computed.
Output.
z, y, b, v, optval, L, iters
"""
if verbose: solvers.options['show_progress'] = True
else: solvers.options['show_progress'] = False
N = Q.size[0]
p = chompack.maxcardsearch(Q)
symb = chompack.symbolic(Q, p)
Qc = chompack.cspmatrix(symb) + Q
# Qinv is the inverse of the max. determinant p.d. completion of Q
Lc = Qc.copy()
chompack.completion(Lc)
Qinv = Lc.copy()
chompack.llt(Qinv)
Qinv = Qinv.spmatrix(reordered=False)
Qinv = chompack.symmetrize(Qinv)
def P(u, v, alpha=1.0, beta=0.0):
"""
v := alpha * [ Qc^-1, 0, 0; 0, 0, 0; 0, 0, 0 ] * u + beta * v
"""
v *= beta
base.symv(Qinv, u, v, alpha=alpha, beta=1.0)
def G(u, v, alpha=1.0, beta=0.0, trans='N'):
"""
If trans is 'N':
v := alpha * [ -diag(d), -d, -I; 0, 0, -I ] * u + beta * v.
If trans is 'T':
v := alpha * [ -diag(d), 0; -d', 0; -I, -I ] * u + beta * v.
"""
v *= beta
if trans is 'N':
v[:N] -= alpha * (base.mul(d, u[:N] + u[N]) + u[-N:])
v[-N:] -= alpha * u[-N:]
else:
v[:N] -= alpha * base.mul(d, u[:N])
v[N] -= alpha * blas.dot(d, u, n=N)
v[-N:] -= alpha * (u[:N] + u[N:])
K = spmatrix(0.0, Qinv.I, Qinv.J)
dy1, dy2 = matrix(0.0, (N, 1)), matrix(0.0, (N, 1))
def Fkkt(W):
"""
Custom KKT solver for
[ Qinv 0 0 -D 0 ] [ ux_y ] [ bx_y ]
[ 0 0 0 -d' 0 ] [ ux_b ] [ bx_b ]
[ 0 0 0 -I -I ] [ ux_v ] = [ bx_v ]
[ -D -d -I -D1 0 ] [ uz_z ] [ bz_z ]
[ 0 0 -I 0 -D2 ] [ uz_w ] [ bz_w ]
with D1 = diag(d1), D2 = diag(d2), d1 = W['d'][:N]**2,
d2 = W['d'][N:])**2.
"""
d1, d2 = W['d'][:N]**2, W['d'][N:]**2
d3, d4 = (d1 + d2)**-1, (d1**-1 + d2**-1)**-1
# Factor the chordal matrix K = Qinv + (D_1+D_2)^-1.
K.V = Qinv.V
K[::N + 1] = K[::N + 1] + d3
L = chompack.cspmatrix(symb) + K
chompack.cholesky(L)
# Solve (Qinv + (D1+D2)^-1) * dy2 = (D1 + D2)^{-1} * 1
blas.copy(d3, dy2)
chompack.trsm(L, dy2, trans='N')
chompack.trsm(L, dy2, trans='T')
def g(x, y, z):
# Solve
#
# [ K d3 ] [ ux_y ]
# [ ] [ ] =
# [ d3' 1'*d3 ] [ ux_b ]
#
# [ bx_y ] [ D ]
# [ ] - [ ] * D3 * (D2 * bx_v + bx_z - bx_w).
# [ bx_b ] [ d' ]
x[:N] -= mul(d, mul(d3, mul(d2, x[-N:]) + z[:N] - z[-N:]))
x[N] -= blas.dot(d, mul(d3, mul(d2, x[-N:]) + z[:N] - z[-N:]))
# Solve dy1 := K^-1 * x[:N]
blas.copy(x, dy1, n=N)
chompack.trsm(L, dy1, trans='N')
chompack.trsm(L, dy1, trans='T')
# Find ux_y = dy1 - ux_b * dy2 s.t
#
# d3' * ( dy1 - ux_b * dy2 + ux_b ) = x[N]
#
# i.e. x[N] := ( x[N] - d3'* dy1 ) / ( d3'* ( 1 - dy2 ) ).
x[N] = ( x[N] - blas.dot(d3, dy1) ) / \
( blas.asum(d3) - blas.dot(d3, dy2) )
x[:N] = dy1 - x[N] * dy2
# ux_v = D4 * ( bx_v - D1^-1 (bz_z + D * (ux_y + ux_b))
# - D2^-1 * bz_w )
x[-N:] = mul(
d4, x[-N:] - div(z[:N] + mul(d, x[:N] + x[N]), d1) -
div(z[N:], d2))
# uz_z = - D1^-1 * ( bx_z - D * ( ux_y + ux_b ) - ux_v )
# uz_w = - D2^-1 * ( bx_w - uz_w )
z[:N] += base.mul(d, x[:N] + x[N]) + x[-N:]
z[-N:] += x[-N:]
blas.scal(-1.0, z)
# Return W['di'] * uz
blas.tbmv(W['di'], z, n=2 * N, k=0, ldA=1)
return g
q = matrix(0.0, (2 * N + 1, 1))
if weights is 'proportional':
dlist = list(d)
C1 = 0.5 * N * gamma / dlist.count(1)
C2 = 0.5 * N * gamma / dlist.count(-1)
gvec = matrix([C1 if w == 1 else C2 for w in dlist], (N, 1))
del dlist
q[-N:] = gvec
elif weights is 'equal':
q[-N:] = gamma
h = matrix(0.0, (2 * N, 1))
h[:N] = -1.0
sol = solvers.coneqp(P, q, G, h, kktsolver=Fkkt)
u = matrix(0.0, (N, 1))
y, b, v = sol['x'][:N], sol['x'][N], sol['x'][N + 1:]
z = mul(d, sol['z'][:N])
base.symv(Qinv, y, u)
optval = 0.5 * blas.dot(y, u) + gamma * sum(v)
return y, b, v, z, optval, Lc, sol['iterations']
def Pf(u, v, alpha = 1.0, beta = 0.0):
base.symv(C, u[0], v[0], alpha = alpha, beta = beta)
blas.scal(beta, v[1])
blas.scal(beta, v[2])
def Pf(u, v, alpha=1.0, beta=0.0):
base.symv(C, u[0], v[0], alpha=alpha, beta=beta)
blas.scal(beta, v[1])
blas.scal(beta, v[2])
def fP(x, y, alpha=1.0, beta=0.0):
base.symv(P, x, y, alpha=alpha, beta=beta)
