def classifier2(Y, soft=False):
M = Y.size[0]
# K = Y*X' / sigma
K = matrix(theta, (width, M))
blas.gemm(X,
Y,
K,
transB='T',
alpha=1.0 / sigma,
beta=-1.0,
m=width)
K = exp(K)
K = div(K - K**-1, K + K**-1)
# complete K
lapack.potrs(L11, K)
K = matrix([K, matrix(0., (N - width, M))], (N, M))
chompack.trsm(Lc, K, trans='N')
chompack.trsm(Lc, K, trans='T')
x = matrix(b, (M, 1))
blas.gemv(K, z, x, trans='T', beta=1.0)
if soft: return x
else: return matrix([2 * (xk > 0.0) - 1 for xk in x])
def classifier2(Y, soft=False):
M = Y.size[0]
# K = Y*X' / sigma
K = matrix(0.0, (width, M))
blas.gemm(X, Y, K, transB='T', alpha=1.0 / sigma, m=width)
# c[i] = ||Yi||^2 / sigma
ones = matrix(1.0, (max(width, n, M), 1))
c = Y**2 * ones[:n]
blas.scal(1.0 / sigma, c)
# Kij := Kij - 0.5 * (ci + aj)
# = || yi - xj ||^2 / (2*sigma)
blas.ger(ones[:width], c, K, alpha=-0.5)
blas.ger(a[:width], ones[:M], K, alpha=-0.5)
# Kij = exp(Kij)
K = exp(K)
# complete K
lapack.potrs(L11, K)
K = matrix([K, matrix(0., (N - width, M))], (N, M))
chompack.trsm(Lc, K, trans='N')
chompack.trsm(Lc, K, trans='T')
x = matrix(b, (M, 1))
blas.gemv(K, z, x, trans='T', beta=1.0)
if soft: return x
else: return matrix([2 * (xk > 0.0) - 1 for xk in x])
def classifier2(Y, soft=False):
M = Y.size[0]
W = matrix(0., (width, M))
blas.gemm(X, Y, W, transB='T', alpha=1.0 / sigma, m=width)
lapack.potrs(L11, W)
W = matrix([W, matrix(0., (N - width, M))])
chompack.trsm(Lc, W, trans='N')
chompack.trsm(Lc, W, trans='T')
x = matrix(b, (M, 1))
blas.gemv(W, z, x, trans='T', beta=1.0)
if soft: return x
else: return matrix([2 * (xk > 0.0) - 1 for xk in x])
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)
def test_trsm(self):
L = cp.cspmatrix(self.symb) + self.A
cp.cholesky(L)
B = cp.eye(self.symb.n)
Bt = matrix(B)[self.symb.p, :]
Lt = matrix(L.spmatrix(reordered=True, symmetric=False))
cp.trsm(L, B)
blas.trsm(Lt, Bt)
diff = list((B - Bt[self.symb.ip, :])[:])
self.assertAlmostEqualLists(diff, len(diff) * [0.0])
B = cp.eye(self.symb.n)
Bt = matrix(B)[self.symb.p, :]
Lt = matrix(L.spmatrix(reordered=True, symmetric=False))
cp.trsm(L, B, trans='T')
blas.trsm(Lt, Bt, transA='T')
diff = list(B - Bt[self.symb.ip, :])[:]
self.assertAlmostEqualLists(diff, len(diff) * [0.0])
def test_trsm(self):
L = cp.cspmatrix(self.symb) + self.A
cp.cholesky(L)
B = cp.eye(self.symb.n)
Bt = matrix(B)[self.symb.p,:]
Lt = matrix(L.spmatrix(reordered=True,symmetric=False))
cp.trsm(L, B)
blas.trsm(Lt,Bt)
diff = list((B-Bt[self.symb.ip,:])[:])
self.assertAlmostEqualLists(diff, len(diff)*[0.0])
B = cp.eye(self.symb.n)
Bt = matrix(B)[self.symb.p,:]
Lt = matrix(L.spmatrix(reordered=True,symmetric=False))
cp.trsm(L, B, trans = 'T')
blas.trsm(Lt,Bt,transA='T')
diff = list(B-Bt[self.symb.ip,:])[:]
self.assertAlmostEqualLists(diff, len(diff)*[0.0])
def completion(X):
"""
Returns maximum-determinant positive definite completion of X
if it exists, and otherwise an exception is raised.
"""
from cvxopt.amd import order
n = X.size[0]
Xt = chompack.tril(X)
p = order(Xt)
# Xc,N = chompack.embed(Xt,p)
# L = chompack.completion(Xc)
symb = chompack.symbolic(Xt,p)
L = chompack.cspmatrix(symb) + Xt
chompack.completion(L)
Xt = matrix(0.,(n,n))
Xt[::n+1] = 1.
# chompack.solve(L, Xt, mode=0)
# chompack.solve(L, Xt, mode=1)
chompack.trsm(L, Xt)
chompack.trsm(L, Xt, trans = 'T')
return Xt
def completion(X):
"""
Returns maximum-determinant positive definite completion of X
if it exists, and otherwise an exception is raised.
"""
from cvxopt.amd import order
n = X.size[0]
Xt = chompack.tril(X)
p = order(Xt)
# Xc,N = chompack.embed(Xt,p)
# L = chompack.completion(Xc)
symb = chompack.symbolic(Xt, p)
L = chompack.cspmatrix(symb) + Xt
chompack.completion(L)
Xt = matrix(0., (n, n))
Xt[::n + 1] = 1.
# chompack.solve(L, Xt, mode=0)
# chompack.solve(L, Xt, mode=1)
chompack.trsm(L, Xt)
chompack.trsm(L, Xt, trans='T')
return Xt
def __init__(self, X, V, a=None, p=None):
self._n = X.size[0]
self._V = +V
assert X.size[0] == X.size[1], 'X must be a square matrix'
assert X.size[0] == V.size[
0], 'V must have have the same number of rows as X'
assert isinstance(V, matrix), 'V must be a dense matrix'
if isinstance(X, cspmatrix) and X.is_factor is False:
self._L0 = X.copy()
cp.cholesky(self._L0)
cp.trsm(self._L0, self._V)
elif isinstance(X, cspmatrix) and X.is_factor is True:
self._L0 = X
cp.trsm(self._L0, self._V)
elif isinstance(X, spmatrix):
symb = symbolic(X, p=p)
self._L0 = cspmatrix(symb) + X
cp.cholesky(self._L0)
cp.trsm(self._L0, self._V)
elif isinstance(X, matrix):
raise NotImplementedError
else:
raise TypeError
if a is None: a = matrix(1.0, (self._n, 1))
self._L = matrix(0.0, V.size)
self._B = matrix(0.0, V.size)
pfchol(a, self._V, self._L, self._B)
return
def trsm(self, B, trans='N'):
r"""
Solves a triangular system of equations with multiple righthand
sides. Computes
.. math::
B &:= L^{-1} B \text{ if trans is 'N'}
B &:= L^{-T} B \text{ if trans is 'T'}
"""
if trans == 'N':
cp.trsm(self._L0, B)
pftrsm(self._V, self._L, self._B, B, trans='N')
elif trans == 'T':
pftrsm(self._V, self._L, self._B, B, trans='T')
cp.trsm(self._L0, B, trans='T')
elif type(trans) is str:
raise ValueError("trans must be 'N' or 'T'")
else:
raise TypeError("trans must be 'N' or 'T'")
return
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
print("Projected inverse/completion : err = %.3e" % (blas.nrm2(tmp)))
# Compute norm of error: L - Lc2
tmp = (L.spmatrix()-Lc2.spmatrix()).V
print("Projected inverse/completion (upd) : err = %.3e" % (blas.nrm2(tmp)))
# Compute norm of error: At - U
tmp = (At-U).spmatrix().V
print("Hessian factors NN/TN/TI/NI : err = %.3e" % (blas.nrm2(tmp)))
# Test triangular matrix products and solve
p = L.symb.p
B = eye(n)
trsm(L, B)
print("trsm, trans = 'N' : err = %.3e" % (blas.nrm2(L.spmatrix(reordered = True)*B[p,p] - eye(n))))
B = eye(n)
trsm(L, B, trans = 'T')
print("trsm, trans = 'T' : err = %.3e" % (blas.nrm2(L.spmatrix(reordered = True).T*B[p,p] - eye(n))))
B = eye(n)
trmm(L, B)
print("trmm, trans = 'N' : err = %.3e" % (blas.nrm2(L.spmatrix(reordered = True) - B[p,p])))
B = eye(n)
trmm(L, B, trans = 'T')
print("trmm, trans = 'T' : err = %.3e" % (blas.nrm2(L.spmatrix(reordered = True).T - B[p,p])))
B = eye(n)
