def test_mrcompletion(self):
Ac = cp.cspmatrix(self.symb) + self.A
Y = cp.mrcompletion(Ac)
C = Y * Y.T
Ap = cp.cspmatrix(Ac.symb)
Ap.add_projection(C, beta=0.0, reordered=True)
diff = list((Ac.spmatrix() - Ap.spmatrix()).V)
self.assertAlmostEqualLists(diff, len(diff) * [0.0])
U = normal(17, 2)
cp.syr2(Ac, U[:, 0], U[:, 0], alpha=0.5, beta=0.0)
cp.syr2(Ac, U[:, 1], U[:, 1], alpha=0.5, beta=1.0)
Y = cp.mrcompletion(Ac)
Ap.add_projection(Y * Y.T, beta=0.0, reordered=True)
diff = list((Ac.spmatrix() - Ap.spmatrix()).V)
self.assertAlmostEqualLists(diff, len(diff) * [0.0])
Ap.add_projection(U * U.T, beta=0.0, reordered=False)
diff = list((Ac.spmatrix() - Ap.spmatrix()).V)
self.assertAlmostEqualLists(diff, len(diff) * [0.0])
def kernel_matrix(X,
kernel,
sigma=1.0,
theta=1.0,
degree=1,
V=None,
width=None):
"""
Computes the kernel matrix or a partial kernel matrix.
Input arguments.
X is an N x n matrix.
kernel is a string with values 'linear', 'rfb', 'poly', or 'tanh'.
'linear': k(u,v) = u'*v/sigma.
'rbf': k(u,v) = exp(-||u - v||^2 / (2*sigma)).
'poly': k(u,v) = (u'*v/sigma)**degree.
'tanh': k(u,v) = tanh(u'*v/sigma - theta). kernel is a
sigma and theta are positive numbers.
degree is a positive integer.
V is an N x N sparse matrix (default is None).
width is a positive integer (default is None).
Output.
Q, an N x N matrix or sparse matrix.
If V is a sparse matrix, a partial kernel matrix with the sparsity
pattern V is returned.
If width is specified and V = 'band', a partial kernel matrix
with band sparsity is returned (width is the half-bandwidth).
a, an N x 1 matrix with the products <xi,xi>/sigma.
"""
N, n = X.size
#### dense (full) kernel matrix
if V is None:
if verbose: print("building kernel matrix ..")
# Qij = xi'*xj / sigma
Q = matrix(0.0, (N, N))
blas.syrk(X, Q, alpha=1.0 / sigma)
a = Q[::N + 1] # ai = ||xi||**2 / sigma
if kernel == 'linear':
pass
elif kernel == 'rbf':
# Qij := Qij - 0.5 * ( ai + aj )
# = -||xi - xj||^2 / (2*sigma)
ones = matrix(1.0, (N, 1))
blas.syr2(a, ones, Q, alpha=-0.5)
Q = exp(Q)
elif kernel == 'tanh':
Q = exp(Q - theta)
Q = div(Q - Q**-1, Q + Q**-1)
elif kernel == 'poly':
Q = Q**degree
else:
raise ValueError('invalid kernel type')
#### general sparse partial kernel matrix
elif type(V) is cvxopt.base.spmatrix:
if verbose: print("building projected kernel matrix ...")
Q = +V
base.syrk(X, Q, partial=True, alpha=1.0 / sigma)
# ai = ||xi||**2 / sigma
a = matrix(Q[::N + 1], (N, 1))
if kernel == 'linear':
pass
elif kernel == 'rbf':
ones = matrix(1.0, (N, 1))
# Qij := Qij - 0.5 * ( ai + aj )
# = -||xi - xj||^2 / (2*sigma)
p = chompack.maxcardsearch(V)
symb = chompack.symbolic(Q, p)
Qc = chompack.cspmatrix(symb) + Q
chompack.syr2(Qc, a, ones, alpha=-0.5)
Q = Qc.spmatrix(reordered=False)
Q.V = exp(Q.V)
elif kernel == 'tanh':
v = +Q.V
v = exp(v - theta)
v = div(v - v**-1, v + v**-1)
Q.V = v
elif kernel == 'poly':
Q.V = Q.V**degree
else:
raise ValueError('invalid kernel type')
#### banded partial kernel matrix
elif V == 'band' and width is not None:
# Lower triangular part of band matrix with bandwidth 2*w+1.
if verbose: print("building projected kernel matrix ...")
I = [i for k in range(N) for i in range(k, min(width + k + 1, N))]
J = [k for k in range(N) for i in range(min(width + 1, N - k))]
V = matrix(0.0, (len(I), 1))
oy = 0
for k in range(N): # V[:,k] = Xtrain[k:k+w, :] * Xtrain[k,:].T
m = min(width + 1, N - k)
blas.gemv(X,
X,
V,
m=m,
ldA=N,
incx=N,
offsetA=k,
offsetx=k,
offsety=oy)
oy += m
blas.scal(1.0 / sigma, V)
# ai = ||xi||**2 / sigma
a = matrix(V[[i for i in range(len(I)) if I[i] == J[i]]], (N, 1))
if kernel == 'linear':
Q = spmatrix(V, I, J, (N, N))
elif kernel == 'rbf':
Q = spmatrix(V, I, J, (N, N))
ones = matrix(1.0, (N, 1))
# Qij := Qij - 0.5 * ( ai + aj )
# = -||xi - xj||^2 / (2*sigma)
symb = chompack.symbolic(Q)
Qc = chompack.cspmatrix(symb) + Q
chompack.syr2(Qc, a, ones, alpha=-0.5)
Q = Qc.spmatrix(reordered=False)
Q.V = exp(Q.V)
elif kernel == 'tanh':
V = exp(V - theta)
V = div(V - V**-1, V + V**-1)
Q = spmatrix(V, I, J, (N, N))
elif kernel == 'poly':
Q = spmatrix(V**degree, I, J, (N, N))
else:
raise ValueError('invalid kernel type')
else:
raise TypeError('invalid type V')
return Q, a
