def decompositionFromPool(self, rpool):
kernel = rpool['kernel_obj']
self.X = array_tools.as_2d_array(rpool['X'], True)
if 'basis_vectors' in rpool:
basis_vectors = array_tools.as_2d_array(rpool['basis_vectors'], True)
if not self.X.shape[1] == basis_vectors.shape[1]:
raise Exception("X and basis_vectors have different number of columns")
else:
basis_vectors = None
if "bias" in rpool:
self.bias = float(rpool["bias"])
else:
self.bias = 1.
if basis_vectors is not None or self.X.shape[1] > self.X.shape[0]:
#First possibility: subset of regressors has been invoked
if basis_vectors is not None:
K_r = kernel.getKM(self.X).T
Krr = kernel.getKM(basis_vectors)
svals, evecs, U, Z = decomposeSubsetKM(K_r, Krr)
#Second possibility: dual mode if more attributes than examples
else:
K = kernel.getKM(self.X).T
svals, evecs = linalg.eig_psd(K)
U, Z = None, None
#Third possibility, primal decomposition
else:
#Invoking getPrimalDataMatrix adds the bias feature
X = getPrimalDataMatrix(self.X, self.bias)
evecs, svals, U = linalg.svd_economy_sized(X)
U, Z = None, None
return svals, evecs, U, Z
def decompositionFromPool(self, rpool):
kernel = rpool['kernel_obj']
self.X = array_tools.as_2d_array(rpool['X'], True)
if 'basis_vectors' in rpool:
basis_vectors = array_tools.as_2d_array(rpool['basis_vectors'],
True)
if not self.X.shape[1] == basis_vectors.shape[1]:
raise Exception(
"X and basis_vectors have different number of columns")
else:
basis_vectors = None
if "bias" in rpool:
self.bias = float(rpool["bias"])
else:
self.bias = 1.
if basis_vectors is not None or self.X.shape[1] > self.X.shape[0]:
#First possibility: subset of regressors has been invoked
if basis_vectors is not None:
K_r = kernel.getKM(self.X).T
Krr = kernel.getKM(basis_vectors)
svals, evecs, U, Z = decomposeSubsetKM(K_r, Krr)
#Second possibility: dual mode if more attributes than examples
else:
K = kernel.getKM(self.X).T
svals, evecs = linalg.eig_psd(K)
U, Z = None, None
#Third possibility, primal decomposition
else:
#Invoking getPrimalDataMatrix adds the bias feature
X = getPrimalDataMatrix(self.X, self.bias)
evecs, svals, U = linalg.svd_economy_sized(X)
U, Z = None, None
return svals, evecs, U, Z
def solve_linear_conditional_ranking(self, regparam):
"""Trains conditional ranking KronRLS, that ranks objects from
domain 2 against objects from domain 1.
Parameters
----------
regparam : float, optional
regularization parameter, regparam > 0 (default=1.0)
Notes
-----
Minimizes RankRLS type of loss. Currently only linear kernel
supported. Including the code here is a hack, this should
probably be implemented as an independent learner.
"""
self.regparam = regparam
X1, X2 = self.X1, self.X2
Y = self.Y.reshape((X1.shape[0], X2.shape[0]), order='F')
V, svals1, rsvecs1 = linalg.svd_economy_sized(X1)
svals1 = np.mat(svals1)
self.svals1 = svals1.T
self.evals1 = np.multiply(self.svals1, self.svals1)
self.V = V
self.rsvecs1 = np.mat(rsvecs1)
qlen = X2.shape[0]
onevec = (1. / np.math.sqrt(qlen)) * np.mat(np.ones((qlen, 1)))
C = np.mat(np.eye(qlen)) - onevec * onevec.T
U, svals2, rsvecs2 = linalg.svd_economy_sized(C * X2)
svals2 = np.mat(svals2)
self.svals2 = svals2.T
self.evals2 = np.multiply(self.svals2, self.svals2)
self.U = U
self.rsvecs2 = np.mat(rsvecs2)
self.VTYU = V.T * Y * C * U
kronsvals = self.svals1 * self.svals2.T
newevals = np.divide(kronsvals,
np.multiply(kronsvals, kronsvals) + regparam)
self.W = np.multiply(self.VTYU, newevals)
self.W = self.rsvecs1.T * self.W * self.rsvecs2
self.predictor = LinearPairwisePredictor(
np.array(self.W).ravel(order='F'))
def solve_linear_conditional_ranking(self, regparam):
"""Trains conditional ranking KronRLS, that ranks objects from
domain 2 against objects from domain 1.
Parameters
----------
regparam : float, optional
regularization parameter, regparam > 0 (default=1.0)
Notes
-----
Minimizes RankRLS type of loss. Currently only linear kernel
supported. Including the code here is a hack, this should
probably be implemented as an independent learner.
"""
self.regparam = regparam
X1, X2 = self.X1, self.X2
Y = self.Y.reshape((X1.shape[0], X2.shape[0]), order="F")
V, svals1, rsvecs1 = linalg.svd_economy_sized(X1)
svals1 = np.mat(svals1)
self.svals1 = svals1.T
self.evals1 = np.multiply(self.svals1, self.svals1)
self.V = V
self.rsvecs1 = np.mat(rsvecs1)
qlen = X2.shape[0]
onevec = (1.0 / np.math.sqrt(qlen)) * np.mat(np.ones((qlen, 1)))
C = np.mat(np.eye(qlen)) - onevec * onevec.T
U, svals2, rsvecs2 = linalg.svd_economy_sized(C * X2)
svals2 = np.mat(svals2)
self.svals2 = svals2.T
self.evals2 = np.multiply(self.svals2, self.svals2)
self.U = U
self.rsvecs2 = np.mat(rsvecs2)
self.VTYU = V.T * Y * C * U
kronsvals = self.svals1 * self.svals2.T
newevals = np.divide(kronsvals, np.multiply(kronsvals, kronsvals) + regparam)
self.W = np.multiply(self.VTYU, newevals)
self.W = self.rsvecs1.T * self.W * self.rsvecs2
self.predictor = LinearPairwisePredictor(np.array(self.W))
def decomposeSubsetKM(K_r, K_rr):
"""decomposes r*m kernel matrix, where r is the number of basis vectors and m the
number of training examples
@param K_r: r*m kernel matrix, where only the lines corresponding to basis vectors are present
@type K_r: numpy matrix
@param basis_vectors: the indices of the basis vectors
@type basis_vectors: list of integers
@return svals, evecs, U, C_T_inv
@rtype tuple of numpy matrices"""
try:
C = la.cholesky(K_rr)
except LinAlgError:
print("Warning: chosen basis vectors not linearly independent")
print("Shifting the diagonal of kernel matrix")
C = la.cholesky(K_rr+0.000000001 * np.eye(K_rr.shape[0]))
C_T_inv = la.inv(C.T)
H = np.dot(K_r.T, C_T_inv)
evecs, svals, U = linalg.svd_economy_sized(H)
return svals, evecs, U, C_T_inv
def decomposeSubsetKM(K_r, K_rr):
"""decomposes r*m kernel matrix, where r is the number of basis vectors and m the
number of training examples
@param K_r: r*m kernel matrix, where only the lines corresponding to basis vectors are present
@type K_r: numpy matrix
@param basis_vectors: the indices of the basis vectors
@type basis_vectors: list of integers
@return svals, evecs, U, C_T_inv
@rtype tuple of numpy matrices"""
try:
C = la.cholesky(K_rr)
except LinAlgError:
print("Warning: chosen basis vectors not linearly independent")
print("Shifting the diagonal of kernel matrix")
C = la.cholesky(K_rr + 0.000000001 * np.eye(K_rr.shape[0]))
C_T_inv = la.inv(C.T)
H = np.dot(K_r.T, C_T_inv)
evecs, svals, U = linalg.svd_economy_sized(H)
return svals, evecs, U, C_T_inv
def solve(self, regparam):
"""Re-trains KronRLS for the given regparam
Parameters
----------
regparam : float, optional
regularization parameter, regparam > 0
Notes
-----
Computational complexity of re-training:
m = n_samples1, n = n_samples2, d = n_features1, e = n_features2
O(ed^2 + de^2) Linear version (assumption: d < m, e < n)
O(m^3 + n^3) Kernel version
"""
self.regparam = regparam
if self.kernelmode:
K1, K2 = self.K1, self.K2
#assert self.Y.shape == (self.K1.shape[0], self.K2.shape[0]), 'Y.shape!=(K1.shape[0],K2.shape[0]). Y.shape=='+str(Y.shape)+', K1.shape=='+str(self.K1.shape)+', K2.shape=='+str(self.K2.shape)
if not self.trained:
self.trained = True
evals1, V = la.eigh(K1)
evals1 = np.mat(evals1).T
V = np.mat(V)
self.evals1 = evals1
self.V = V
evals2, U = la.eigh(K2)
evals2 = np.mat(evals2).T
U = np.mat(U)
self.evals2 = evals2
self.U = U
self.VTYU = V.T * self.Y * U
newevals = 1. / (self.evals1 * self.evals2.T + regparam)
self.A = np.multiply(self.VTYU, newevals)
self.A = self.V * self.A * self.U.T
self.A = np.asarray(self.A)
label_row_inds, label_col_inds = np.unravel_index(
np.arange(K1.shape[0] * K2.shape[0]),
(K1.shape[0], K2.shape[0]))
label_row_inds = np.array(label_row_inds, dtype=np.int32)
label_col_inds = np.array(label_col_inds, dtype=np.int32)
self.predictor = KernelPairwisePredictor(self.A.ravel(),
label_row_inds,
label_col_inds)
else:
X1, X2 = self.X1, self.X2
Y = self.Y.reshape((X1.shape[0], X2.shape[0]), order='F')
if not self.trained:
self.trained = True
V, svals1, rsvecs1 = linalg.svd_economy_sized(X1)
svals1 = np.mat(svals1)
self.svals1 = svals1.T
self.evals1 = np.multiply(self.svals1, self.svals1)
self.V = V
self.rsvecs1 = np.mat(rsvecs1)
if X1.shape == X2.shape and (X1 == X2).all():
svals2, U, rsvecs2 = svals1, V, rsvecs1
else:
U, svals2, rsvecs2 = linalg.svd_economy_sized(X2)
svals2 = np.mat(svals2)
self.svals2 = svals2.T
self.evals2 = np.multiply(self.svals2, self.svals2)
self.U = U
self.rsvecs2 = np.mat(rsvecs2)
self.VTYU = V.T * Y * U
kronsvals = self.svals1 * self.svals2.T
newevals = np.divide(kronsvals,
np.multiply(kronsvals, kronsvals) + regparam)
self.W = np.multiply(self.VTYU, newevals)
self.W = self.rsvecs1.T * self.W * self.rsvecs2
self.predictor = LinearPairwisePredictor(
np.array(self.W).ravel(order='F'))
def solve(self, regparam1, regparam2):
"""Re-trains TwoStepRLS for the given regparams
Parameters
----------
regparam1: float
regularization parameter 1, regparam1 > 0
regparam2: float
regularization parameter 2, regparam2 > 0
Notes
-----
Computational complexity of re-training:
m = n_samples1, n = n_samples2, d = n_features1, e = n_features2
O(ed^2 + de^2) Linear version (assumption: d < m, e < n)
O(m^3 + n^3) Kernel version
"""
self.regparam1 = regparam1
self.regparam2 = regparam2
if self.kernelmode:
K1, K2 = self.K1, self.K2
Y = self.Y.reshape((K1.shape[0], K2.shape[0]), order='F')
if not self.trained:
self.trained = True
evals1, V = linalg.eig_psd(K1)
evals1 = np.mat(evals1).T
evals1 = np.multiply(evals1, evals1)
V = np.mat(V)
self.evals1 = evals1
self.V = V
evals2, U = linalg.eig_psd(K2)
evals2 = np.mat(evals2).T
evals2 = np.multiply(evals2, evals2)
U = np.mat(U)
self.evals2 = evals2
self.U = U
self.VTYU = V.T * self.Y * U
self.newevals1 = 1. / (self.evals1 + regparam1)
self.newevals2 = 1. / (self.evals2 + regparam2)
newevals = self.newevals1 * self.newevals2.T
self.A = np.multiply(self.VTYU, newevals)
self.A = self.V * self.A * self.U.T
self.A = np.array(self.A)
label_row_inds, label_col_inds = np.unravel_index(np.arange(K1.shape[0] * K2.shape[0]), (K1.shape[0], K2.shape[0]))
label_row_inds = np.array(label_row_inds, dtype = np.int32)
label_col_inds = np.array(label_col_inds, dtype = np.int32)
self.predictor = KernelPairwisePredictor(self.A.ravel(), label_row_inds, label_col_inds)
else:
X1, X2 = self.X1, self.X2
Y = self.Y.reshape((X1.shape[0], X2.shape[0]), order='F')
if not self.trained:
self.trained = True
V, svals1, rsvecs1 = linalg.svd_economy_sized(X1)
svals1 = np.mat(svals1)
self.svals1 = svals1.T
self.evals1 = np.multiply(self.svals1, self.svals1)
self.V = V
self.rsvecs1 = np.mat(rsvecs1)
if X1.shape == X2.shape and (X1 == X2).all():
svals2, U, rsvecs2 = svals1, V, rsvecs1
else:
U, svals2, rsvecs2 = linalg.svd_economy_sized(X2)
svals2 = np.mat(svals2)
self.svals2 = svals2.T
self.evals2 = np.multiply(self.svals2, self.svals2)
self.U = U
self.rsvecs2 = np.mat(rsvecs2)
self.VTYU = V.T * Y * U
self.newevals1 = 1. / (self.evals1 + regparam1)
self.newevals2 = 1. / (self.evals2 + regparam2)
newevals = np.multiply(self.svals1, self.newevals1) * np.multiply(self.svals2, self.newevals2).T
self.W = np.multiply(self.VTYU, newevals)
self.W = self.rsvecs1.T * self.W * self.rsvecs2
#self.predictor = LinearPairwisePredictor(self.W)
self.predictor = LinearPairwisePredictor(np.array(self.W))
def solve(self, regparam1, regparam2):
"""Re-trains TwoStepRLS for the given regparams
Parameters
----------
regparam1: float
regularization parameter 1, regparam1 > 0
regparam2: float
regularization parameter 2, regparam2 > 0
Notes
-----
Computational complexity of re-training:
m = n_samples1, n = n_samples2, d = n_features1, e = n_features2
O(ed^2 + de^2) Linear version (assumption: d < m, e < n)
O(m^3 + n^3) Kernel version
"""
self.regparam1 = regparam1
self.regparam2 = regparam2
if self.kernelmode:
K1, K2 = self.K1, self.K2
Y = self.Y.reshape((K1.shape[0], K2.shape[0]), order='F')
if not self.trained:
self.trained = True
evals1, V = linalg.eig_psd(K1)
evals1 = np.mat(evals1).T
evals1 = np.multiply(evals1, evals1)
V = np.mat(V)
self.evals1 = evals1
self.V = V
evals2, U = linalg.eig_psd(K2)
evals2 = np.mat(evals2).T
evals2 = np.multiply(evals2, evals2)
U = np.mat(U)
self.evals2 = evals2
self.U = U
self.VTYU = V.T * self.Y * U
self.newevals1 = 1. / (self.evals1 + regparam1)
self.newevals2 = 1. / (self.evals2 + regparam2)
newevals = self.newevals1 * self.newevals2.T
self.A = np.multiply(self.VTYU, newevals)
self.A = self.V * self.A * self.U.T
self.A = np.array(self.A)
label_row_inds, label_col_inds = np.unravel_index(
np.arange(K1.shape[0] * K2.shape[0]),
(K1.shape[0], K2.shape[0]))
label_row_inds = np.array(label_row_inds, dtype=np.int32)
label_col_inds = np.array(label_col_inds, dtype=np.int32)
self.predictor = KernelPairwisePredictor(self.A.ravel(),
label_row_inds,
label_col_inds)
else:
X1, X2 = self.X1, self.X2
Y = self.Y.reshape((X1.shape[0], X2.shape[0]), order='F')
if not self.trained:
self.trained = True
V, svals1, rsvecs1 = linalg.svd_economy_sized(X1)
svals1 = np.mat(svals1)
self.svals1 = svals1.T
self.evals1 = np.multiply(self.svals1, self.svals1)
self.V = V
self.rsvecs1 = np.mat(rsvecs1)
if X1.shape == X2.shape and (X1 == X2).all():
svals2, U, rsvecs2 = svals1, V, rsvecs1
else:
U, svals2, rsvecs2 = linalg.svd_economy_sized(X2)
svals2 = np.mat(svals2)
self.svals2 = svals2.T
self.evals2 = np.multiply(self.svals2, self.svals2)
self.U = U
self.rsvecs2 = np.mat(rsvecs2)
self.VTYU = V.T * Y * U
self.newevals1 = 1. / (self.evals1 + regparam1)
self.newevals2 = 1. / (self.evals2 + regparam2)
newevals = np.multiply(self.svals1, self.newevals1) * np.multiply(
self.svals2, self.newevals2).T
self.W = np.multiply(self.VTYU, newevals)
self.W = self.rsvecs1.T * self.W * self.rsvecs2
#self.predictor = LinearPairwisePredictor(self.W)
self.predictor = LinearPairwisePredictor(np.array(self.W))
def solve(self, regparam):
"""Re-trains KronRLS for the given regparam
Parameters
----------
regparam : float, optional
regularization parameter, regparam > 0
Notes
-----
Computational complexity of re-training:
m = n_samples1, n = n_samples2, d = n_features1, e = n_features2
O(ed^2 + de^2) Linear version (assumption: d < m, e < n)
O(m^3 + n^3) Kernel version
"""
self.regparam = regparam
if self.kernelmode:
K1, K2 = self.K1, self.K2
# assert self.Y.shape == (self.K1.shape[0], self.K2.shape[0]), 'Y.shape!=(K1.shape[0],K2.shape[0]). Y.shape=='+str(Y.shape)+', K1.shape=='+str(self.K1.shape)+', K2.shape=='+str(self.K2.shape)
if not self.trained:
self.trained = True
evals1, V = la.eigh(K1)
evals1 = np.mat(evals1).T
V = np.mat(V)
self.evals1 = evals1
self.V = V
evals2, U = la.eigh(K2)
evals2 = np.mat(evals2).T
U = np.mat(U)
self.evals2 = evals2
self.U = U
self.VTYU = V.T * self.Y * U
newevals = 1.0 / (self.evals1 * self.evals2.T + regparam)
self.A = np.multiply(self.VTYU, newevals)
self.A = self.V * self.A * self.U.T
self.A = np.asarray(self.A)
label_row_inds, label_col_inds = np.unravel_index(
np.arange(K1.shape[0] * K2.shape[0]), (K1.shape[0], K2.shape[0])
)
label_row_inds = np.array(label_row_inds, dtype=np.int32)
label_col_inds = np.array(label_col_inds, dtype=np.int32)
self.predictor = KernelPairwisePredictor(self.A.ravel(), label_row_inds, label_col_inds)
else:
X1, X2 = self.X1, self.X2
Y = self.Y.reshape((X1.shape[0], X2.shape[0]), order="F")
if not self.trained:
self.trained = True
V, svals1, rsvecs1 = linalg.svd_economy_sized(X1)
svals1 = np.mat(svals1)
self.svals1 = svals1.T
self.evals1 = np.multiply(self.svals1, self.svals1)
self.V = V
self.rsvecs1 = np.mat(rsvecs1)
if X1.shape == X2.shape and (X1 == X2).all():
svals2, U, rsvecs2 = svals1, V, rsvecs1
else:
U, svals2, rsvecs2 = linalg.svd_economy_sized(X2)
svals2 = np.mat(svals2)
self.svals2 = svals2.T
self.evals2 = np.multiply(self.svals2, self.svals2)
self.U = U
self.rsvecs2 = np.mat(rsvecs2)
self.VTYU = V.T * Y * U
kronsvals = self.svals1 * self.svals2.T
newevals = np.divide(kronsvals, np.multiply(kronsvals, kronsvals) + regparam)
self.W = np.multiply(self.VTYU, newevals)
self.W = self.rsvecs1.T * self.W * self.rsvecs2
self.predictor = LinearPairwisePredictor(np.array(self.W))
