def func(a):
#REPLACE
P = sparse_kronecker_multiplication_tools_python.x_gets_C_times_M_kron_N_times_B_times_v(a, K2, K1, rowind, colind, rowind, colind)
z = (1. - Y*P)
z = np.where(z>0, z, 0)
Ka = sparse_kronecker_multiplication_tools_python.x_gets_C_times_M_kron_N_times_B_times_v(a, K2, K1, rowind, colind, rowind, colind)
return 0.5*(np.dot(z,z)+lamb*np.dot(a, Ka))
def hessian(u):
P = sparse_kronecker_multiplication_tools_python.x_gets_C_times_M_kron_N_times_B_times_v(a, K2, K1, rowind, colind, rowind, colind)
z = (1. - Y*P)
z = np.where(z>0, z, 0)
sv = np.nonzero(z)[0]
v = sparse_kronecker_multiplication_tools_python.x_gets_C_times_M_kron_N_times_B_times_v(u, K2, K1, rowind[sv], colind[sv], rowind, colind)
v_after = sparse_kronecker_multiplication_tools_python.x_gets_C_times_M_kron_N_times_B_times_v(v, K2, K1, rowind, colind, rowind[sv], colind[sv])
return v_after + lamb * sparse_kronecker_multiplication_tools_python.x_gets_C_times_M_kron_N_times_B_times_v(u, K2, K1, rowind, colind, rowind[sv], colind[sv])
def dual_gradient(a, K1, K2, Y, rowind, colind, lamb):
P = sparse_kronecker_multiplication_tools_python.x_gets_C_times_M_kron_N_times_B_times_v(a, K2, K1, rowind, colind, rowind, colind)
z = (1. - Y*P)
z = np.where(z>0, z, 0)
sv = np.nonzero(z)[0]
v = P[sv]-Y[sv]
v_after = sparse_kronecker_multiplication_tools_python.x_gets_C_times_M_kron_N_times_B_times_v(v, K2, K1, rowind, colind, rowind[sv], colind[sv])
Ka = sparse_kronecker_multiplication_tools_python.x_gets_C_times_M_kron_N_times_B_times_v(a, K2, K1, rowind, colind, rowind, colind)
return v_after + lamb*Ka
def dual_rls_objective(a, K1, K2, Y, rowind, colind, lamb):
#dual form of the objective function for regularized least squares
#a: current dual solution
#K1: samples x samples kernel matrix for domain 1
#K2: samples x samples kernel matrix for domain 2
#rowind: row indices for training pairs
#colind: column indices for training pairs
#lamb: regularization parameter
P = sparse_kronecker_multiplication_tools_python.x_gets_C_times_M_kron_N_times_B_times_v(a, K2, K1, rowind, colind, rowind, colind)
z = (Y - P)
Ka = sparse_kronecker_multiplication_tools_python.x_gets_C_times_M_kron_N_times_B_times_v(a, K2, K1, rowind, colind, rowind, colind)
return 0.5*(np.dot(z,z)+lamb*np.dot(a, Ka))
def dual_svm_objective(a, K1, K2, Y, rowind, colind, lamb):
#dual form of the objective function for support vector machine
#a: current dual solution
#K1: samples x samples kernel matrix for domain 1
#K2: samples x samples kernel matrix for domain 2
#rowind: row indices for training pairs
#colind: column indices for training pairs
#lamb: regularization parameter
P = sparse_kronecker_multiplication_tools_python.x_gets_C_times_M_kron_N_times_B_times_v(a, K2, K1, rowind, colind, rowind, colind)
z = (1. - Y*P)
z = np.where(z>0, z, 0)
Ka = sparse_kronecker_multiplication_tools_python.x_gets_C_times_M_kron_N_times_B_times_v(a, K2, K1, rowind, colind, rowind, colind)
return 0.5*(np.dot(z,z)+lamb*np.dot(a, Ka))
def mv(v):
rows = rowind[sv]
cols = colind[sv]
p = np.zeros(len(rowind))
A = sparse_kronecker_multiplication_tools_python.x_gets_C_times_M_kron_N_times_B_times_v(v, K2, K1, rows, cols, rowind, colind)
p[sv] = A
return p + lamb * v
def predictWithKernelMatrices(self, K1pred, K2pred, row_inds = None, col_inds = None):
"""Computes predictions for test examples.
Parameters
----------
K1pred: {array-like, sparse matrix}, shape = [n_samples1, n_basis_functions1]
the first part of the test data matrix
K2pred: {array-like, sparse matrix}, shape = [n_samples2, n_basis_functions2]
the second part of the test data matrix
Returns
----------
P: array, shape = [n_samples1, n_samples2]
predictions
"""
if row_inds == None:
P = sparse_kronecker_multiplication_tools_python.x_gets_A_kron_B_times_sparse_v(self.A, K1pred, K2pred.T, self.label_row_inds, self.label_col_inds)
P = P.reshape((K1pred.shape[0], K2pred.shape[0]), order='F')
else:
P = sparse_kronecker_multiplication_tools_python.x_gets_C_times_M_kron_N_times_B_times_v(
self.A,
K2pred,
K1pred,
np.array(row_inds, dtype = np.int32),
np.array(col_inds, dtype = np.int32),
self.label_row_inds,
self.label_col_inds)
P = np.array(P)
return P
def predictWithKernelMatrices(self,
K1pred,
K2pred,
row_inds=None,
col_inds=None):
"""Computes predictions for test examples.
Parameters
----------
K1pred: {array-like, sparse matrix}, shape = [n_samples1, n_basis_functions1]
the first part of the test data matrix
K2pred: {array-like, sparse matrix}, shape = [n_samples2, n_basis_functions2]
the second part of the test data matrix
Returns
----------
P: array, shape = [n_samples1, n_samples2]
predictions
"""
if row_inds == None:
P = sparse_kronecker_multiplication_tools_python.x_gets_A_kron_B_times_sparse_v(
self.A, K1pred, K2pred.T, self.label_row_inds,
self.label_col_inds)
P = P.reshape((K1pred.shape[0], K2pred.shape[0]), order='F')
else:
P = sparse_kronecker_multiplication_tools_python.x_gets_C_times_M_kron_N_times_B_times_v(
self.A, K2pred, K1pred, np.array(row_inds, dtype=np.int32),
np.array(col_inds, dtype=np.int32), self.label_row_inds,
self.label_col_inds)
return P
def predictWithKernelMatricesAlt(self, K1pred, K2pred, row_inds = None, col_inds = None):
#transposes wrong probably
P = sparse_kronecker_multiplication_tools_python.x_gets_C_times_M_kron_N_times_B_times_v(self.A, K2pred, K1pred, np.array(row_inds, dtype=np.int32), np.array(col_inds, dtype=np.int32), self.label_row_inds, self.label_col_inds)
return P
def rv(v):
rows = rowind[sv]
cols = colind[sv]
p = sparse_kronecker_multiplication_tools_python.x_gets_C_times_M_kron_N_times_B_times_v(v[sv], K2, K1, rowind, colind, rows, cols)
return p + lamb * v
def solve_dual(self, regparam):
self.regparam = regparam
K1 = self.resource_pool['kmatrix1']
K2 = self.resource_pool['kmatrix2']
#X1 = self.resource_pool['xmatrix1']
#X2 = self.resource_pool['xmatrix2']
#self.X1, self.X2 = X1, X2
#x1tsize, x1fsize = X1.shape #m, d
#x2tsize, x2fsize = X2.shape #q, r
if 'maxiter' in self.resource_pool: maxiter = int(self.resource_pool['maxiter'])
else: maxiter = 100
if 'inneriter' in self.resource_pool: inneriter = int(self.resource_pool['inneriter'])
else: inneriter = 1000
lsize = len(self.label_row_inds) #n
label_row_inds = np.array(self.label_row_inds, dtype = np.int32)
label_col_inds = np.array(self.label_col_inds, dtype = np.int32)
Y = self.Y
rowind = label_row_inds
colind = label_col_inds
lamb = self.regparam
rowind = np.array(rowind, dtype = np.int32)
colind = np.array(colind, dtype = np.int32)
ddim = len(rowind)
a = np.zeros(ddim)
a_new = np.zeros(ddim)
def func(a):
#REPLACE
#P = np.dot(X,v)
P = sparse_kronecker_multiplication_tools_python.x_gets_C_times_M_kron_N_times_B_times_v(a, K2, K1, rowind, colind, rowind, colind)
z = (1. - Y*P)
z = np.where(z>0, z, 0)
Ka = sparse_kronecker_multiplication_tools_python.x_gets_C_times_M_kron_N_times_B_times_v(a, K2, K1, rowind, colind, rowind, colind)
return 0.5*(np.dot(z,z)+lamb*np.dot(a, Ka))
def mv(v):
rows = rowind[sv]
cols = colind[sv]
p = np.zeros(len(rowind))
A = sparse_kronecker_multiplication_tools_python.x_gets_C_times_M_kron_N_times_B_times_v(v, K2, K1, rows, cols, rowind, colind)
p[sv] = A
return p + lamb * v
def rv(v):
rows = rowind[sv]
cols = colind[sv]
p = sparse_kronecker_multiplication_tools_python.x_gets_C_times_M_kron_N_times_B_times_v(v[sv], K2, K1, rowind, colind, rows, cols)
return p + lamb * v
ssize = 1.0
for i in range(maxiter):
P = sparse_kronecker_multiplication_tools_python.x_gets_C_times_M_kron_N_times_B_times_v(a, K2, K1, rowind, colind, rowind, colind)
z = (1. - Y*P)
z = np.where(z>0, z, 0)
sv = np.nonzero(z)[0]
B = np.zeros(P.shape)
B[sv] = P[sv]-Y[sv]
B = B + lamb*a
#solve Ax = B
A = LinearOperator((ddim, ddim), matvec=mv, rmatvec=rv, dtype=np.float64)
#a_new = lsqr(A, B, iter_lim=inneriter)[0]
#def callback(xk):
# residual = np.linalg.norm(A.dot(xk)-B)
# print "redidual is", residual
a_new = bicgstab(A, B, maxiter=inneriter)[0]
#a_new = bicgstab(A, B, x0=a, tol=0.01, callback=callback)[0]
#a_new = lsmr(A, B, maxiter=inneriter)[0]
ssize = 1.0
a = a - ssize*a_new
#print "dual objective", func(a), ssize
#print "dual objective 2", dual_objective(a, K1, K2, Y, rowind, colind, lamb)
#print "gradient norm", np.linalg.norm(dual_gradient(a, K1, K2, Y, rowind, colind, lamb))
self.A = a
self.dual_model = KernelPairwiseModel(a, rowind, colind)
self.callback()
#w = sparse_kronecker_multiplication_tools_python.x_gets_A_kron_B_times_sparse_v(a, X1.T, X2, rowind, colind)
#P2 = sparse_kronecker_multiplication_tools_python.x_gets_subset_of_A_kron_B_times_v(self.W.ravel(), X2, X1.T, colind, rowind)
#z2 = (1. - Y*P)
#z2 = np.where(z2>0, z2, 0)
#print np.dot(z2,z2)
#self.W = w.reshape((x1fsize, x2fsize), order='F')
#print w
#print self.W.ravel()
#assert False
#p = func(a)
#print p[-10:]
#P2 = sparse_kronecker_multiplication_tools_python.x_gets_subset_of_A_kron_B_times_v(self.W.ravel(), X2, X1.T, colind, rowind)
#print "predictions 2", P2
#print "diff", P1-P2
#z2 = (1. - Y*P)
#z2 = np.where(z2>0, z2, 0)
#print np.dot(z2,z2)
#print i
#self.model = LinearPairwiseModel(self.W, X1.shape[1], X2.shape[1])
self.dual_model = KernelPairwiseModel(a, rowind, colind)
#z = np.where(a!=0, a, 0)
#sv = np.nonzero(z)[0]
#self.model = KernelPairwiseModel([sv], rowind[sv], colind[sv])
self.finished()
def rv(v):
return sparse_kronecker_multiplication_tools_python.x_gets_C_times_M_kron_N_times_B_times_v(v, K2, K1, rowind, colind, rowind, colind)
