def mv_mk(v):
vsum = regparam * v
for i in range(len(X1)):
X1i = X1[i]
X2i = X2[i]
v_after = sampled_kronecker_products.sampled_vec_trick(v, X2i, X1i, self.input2_inds, self.input1_inds)
v_after = sampled_kronecker_products.sampled_vec_trick(v_after, X2i.T, X1i.T, None, None, self.input2_inds, self.input1_inds)
vsum = vsum + v_after
return vsum
def cgcb(v):
if self.compute_risk:
P = sampled_kronecker_products.sampled_vec_trick(v, K2, K1, self.input2_inds, self.input1_inds, self.input2_inds, self.input1_inds)
z = (Y - P)
Ka = sampled_kronecker_products.sampled_vec_trick(v, K2, K1, self.input2_inds, self.input1_inds, self.input2_inds, self.input1_inds)
loss = (np.dot(z,z)+regparam*np.dot(v,Ka))
print("loss", 0.5*loss)
if loss < self.bestloss:
self.A = v.copy()
self.bestloss = loss
else:
self.A = v
if not self.callbackfun is None:
self.predictor = KernelPairwisePredictor(self.A, self.input1_inds, self.input2_inds)
self.callbackfun.callback(self)
def mv_mk(v):
vsum = regparam * v
for i in range(len(K1)):
K1i = K1[i]
K2i = K2[i]
inds2 = self.input2_inds[i]
inds1 = self.input1_inds[i]
vsum += weights[i] * sampled_kronecker_products.sampled_vec_trick(v, K2i, K1i, inds2, inds1, inds2, inds1)
return vsum
def cgcb(v):
if self.compute_risk:
P = sampled_kronecker_products.sampled_vec_trick(v, X2, X1, self.input2_inds, self.input1_inds)
z = (Y - P)
loss = (np.dot(z,z)+regparam*np.dot(v,v))
if loss < self.bestloss:
self.W = v.copy().reshape((x1fsize, x2fsize), order = 'F')
self.bestloss = loss
else:
self.W = v.reshape((x1fsize, x2fsize), order = 'F')
if not self.callbackfun is None:
self.predictor = LinearPairwisePredictor(self.W)
self.callbackfun.callback(self)
def inner_predict(K1pred,
K2pred,
row_inds_K1training,
row_inds_K2training,
row_inds_K1pred=None,
row_inds_K2pred=None):
if len(K1pred.shape) == 1:
K1pred = K1pred.reshape(1, K1pred.shape[0])
if len(K2pred.shape) == 1:
K2pred = K2pred.reshape(1, K2pred.shape[0])
if row_inds_K1pred is not None:
row_inds_K1pred = np.array(row_inds_K1pred, dtype=np.int32)
row_inds_K2pred = np.array(row_inds_K2pred, dtype=np.int32)
P = sampled_kronecker_products.sampled_vec_trick(
self.A, K2pred, K1pred, row_inds_K2pred, row_inds_K1pred,
row_inds_K2training, row_inds_K1training)
else:
P = sampled_kronecker_products.sampled_vec_trick(
self.A, K2pred, K1pred, None, None, row_inds_K2training,
row_inds_K1training)
#P = P.reshape((K1pred.shape[0], K2pred.shape[0]), order = 'F')
P = np.array(P)
return P
def predict(self,
X1pred,
X2pred,
row_inds_X1pred=None,
row_inds_X2pred=None):
"""Computes predictions for test examples.
Parameters
----------
X1pred : array-like, shape = [n_samples1, n_features1]
the first part of the test data matrix
X2pred : array-like, shape = [n_samples2, n_features2]
the second part of the test data matrix
row_inds_X1pred : list of indices, shape = [n_test_pairs], optional
maps rows of X1pred to vector of predictions P. If not supplied, predictions are computed for all possible test pair combinations.
row_inds_X2pred : list of indices, shape = [n_test_pairs], optional
maps rows of X2pred to vector of predictions P. If not supplied, predictions are computed for all possible test pair combinations.
Returns
----------
P : array, shape = [n_test_pairs] or [n_samples1*n_samples2]
predictions, either ordered according to the supplied row indices, or if no such are supplied by default
prediction for (X1[i], X2[j]) maps to P[i + j*n_samples1].
"""
if len(X1pred.shape) == 1:
if self.W.shape[0] > 1:
X1pred = X1pred[np.newaxis, ...]
else:
X1pred = X1pred[..., np.newaxis]
if len(X2pred.shape) == 1:
if self.W.shape[1] > 1:
X2pred = X2pred[np.newaxis, ...]
else:
X2pred = X2pred[..., np.newaxis]
if row_inds_X1pred is None:
P = np.dot(np.dot(X1pred, self.W), X2pred.T)
else:
P = sampled_kronecker_products.sampled_vec_trick(
self.W.reshape((self.W.shape[0] * self.W.shape[1]), order='F'),
X2pred, X1pred, np.array(row_inds_X2pred, dtype=np.int32),
np.array(row_inds_X1pred, dtype=np.int32), None, None)
return P.ravel(order='F')
def __init__(self, **kwargs):
Y = kwargs["Y"]
self.input1_inds = np.array(kwargs["label_row_inds"], dtype = np.int32)
self.input2_inds = np.array(kwargs["label_col_inds"], dtype = np.int32)
Y = array_tools.as_2d_array(Y)
self.Y = np.mat(Y)
self.trained = False
if "regparam" in kwargs:
self.regparam = kwargs["regparam"]
else:
self.regparam = 0.
if CALLBACK_FUNCTION in kwargs:
self.callbackfun = kwargs[CALLBACK_FUNCTION]
else:
self.callbackfun = None
if "compute_risk" in kwargs:
self.compute_risk = kwargs["compute_risk"]
else:
self.compute_risk = False
regparam = self.regparam
if 'K1' in kwargs:
K1 = kwargs['K1']
K2 = kwargs['K2']
if 'maxiter' in kwargs: maxiter = int(kwargs['maxiter'])
else: maxiter = None
Y = np.array(self.Y).ravel(order = 'F')
self.bestloss = float("inf")
def mv(v):
return sampled_kronecker_products.sampled_vec_trick(v, K2, K1, self.input2_inds, self.input1_inds, self.input2_inds, self.input1_inds) + regparam * v
def mv_mk(v):
vsum = regparam * v
for i in range(len(K1)):
K1i = K1[i]
K2i = K2[i]
inds2 = self.input2_inds[i]
inds1 = self.input1_inds[i]
vsum += weights[i] * sampled_kronecker_products.sampled_vec_trick(v, K2i, K1i, inds2, inds1, inds2, inds1)
return vsum
def mvr(v):
raise Exception('You should not be here!')
def cgcb(v):
if self.compute_risk:
P = sampled_kronecker_products.sampled_vec_trick(v, K2, K1, self.input2_inds, self.input1_inds, self.input2_inds, self.input1_inds)
z = (Y - P)
Ka = sampled_kronecker_products.sampled_vec_trick(v, K2, K1, self.input2_inds, self.input1_inds, self.input2_inds, self.input1_inds)
loss = (np.dot(z,z)+regparam*np.dot(v,Ka))
print("loss", 0.5*loss)
if loss < self.bestloss:
self.A = v.copy()
self.bestloss = loss
else:
self.A = v
if not self.callbackfun is None:
self.predictor = KernelPairwisePredictor(self.A, self.input1_inds, self.input2_inds)
self.callbackfun.callback(self)
if isinstance(K1, (list, tuple)):
if 'weights' in kwargs: weights = kwargs['weights']
else: weights = np.ones((len(K1)))
G = LinearOperator((len(self.input1_inds[0]), len(self.input1_inds[0])), matvec = mv_mk, rmatvec = mvr, dtype = np.float64)
else:
weights = None
G = LinearOperator((len(self.input1_inds), len(self.input1_inds)), matvec = mv, rmatvec = mvr, dtype = np.float64)
self.A = minres(G, self.Y, maxiter = maxiter, callback = cgcb, tol=1e-20)[0]
self.predictor = KernelPairwisePredictor(self.A, self.input1_inds, self.input2_inds, weights)
else:
X1 = kwargs['X1']
X2 = kwargs['X2']
self.X1, self.X2 = X1, X2
if 'maxiter' in kwargs: maxiter = int(kwargs['maxiter'])
else: maxiter = None
if isinstance(X1, (list, tuple)):
raise NotImplementedError("Got list or tuple as X1 but multiple kernel learning has not been implemented for the proal case yet.")
x1tsize, x1fsize = X1[0].shape #m, d
x2tsize, x2fsize = X2[0].shape #q, r
else:
x1tsize, x1fsize = X1.shape #m, d
x2tsize, x2fsize = X2.shape #q, r
kronfcount = x1fsize * x2fsize
Y = np.array(self.Y).ravel(order = 'F')
self.bestloss = float("inf")
def mv(v):
v_after = sampled_kronecker_products.sampled_vec_trick(v, X2, X1, self.input2_inds, self.input1_inds)
v_after = sampled_kronecker_products.sampled_vec_trick(v_after, X2.T, X1.T, None, None, self.input2_inds, self.input1_inds) + regparam * v
return v_after
def mv_mk(v):
vsum = regparam * v
for i in range(len(X1)):
X1i = X1[i]
X2i = X2[i]
v_after = sampled_kronecker_products.sampled_vec_trick(v, X2i, X1i, self.input2_inds, self.input1_inds)
v_after = sampled_kronecker_products.sampled_vec_trick(v_after, X2i.T, X1i.T, None, None, self.input2_inds, self.input1_inds)
vsum = vsum + v_after
return vsum
def mvr(v):
raise Exception('You should not be here!')
return None
def cgcb(v):
if self.compute_risk:
P = sampled_kronecker_products.sampled_vec_trick(v, X2, X1, self.input2_inds, self.input1_inds)
z = (Y - P)
loss = (np.dot(z,z)+regparam*np.dot(v,v))
if loss < self.bestloss:
self.W = v.copy().reshape((x1fsize, x2fsize), order = 'F')
self.bestloss = loss
else:
self.W = v.reshape((x1fsize, x2fsize), order = 'F')
if not self.callbackfun is None:
self.predictor = LinearPairwisePredictor(self.W)
self.callbackfun.callback(self)
if isinstance(X1, (list, tuple)):
G = LinearOperator((kronfcount, kronfcount), matvec = mv_mk, rmatvec = mvr, dtype = np.float64)
vsum = np.zeros(kronfcount)
v_init = np.array(self.Y).reshape(self.Y.shape[0])
for i in range(len(X1)):
X1i = X1[i]
X2i = X2[i]
vsum += sampled_kronecker_products.sampled_vec_trick(v_init, X2i.T, X1i.T, None, None, self.input2_inds, self.input1_inds)
v_init = vsum
else:
G = LinearOperator((kronfcount, kronfcount), matvec = mv, rmatvec = mvr, dtype = np.float64)
v_init = np.array(self.Y).reshape(self.Y.shape[0])
v_init = sampled_kronecker_products.sampled_vec_trick(v_init, X2.T, X1.T, None, None, self.input2_inds, self.input1_inds)
v_init = np.array(v_init).reshape(kronfcount)
if 'warm_start' in kwargs:
x0 = np.array(kwargs['warm_start']).reshape(kronfcount, order = 'F')
else:
x0 = None
minres(G, v_init, x0 = x0, maxiter = maxiter, callback = cgcb, tol=1e-20)[0].reshape((x1fsize, x2fsize), order='F')
self.predictor = LinearPairwisePredictor(self.W)
if not self.callbackfun is None:
self.callbackfun.finished(self)
def mv(v):
v_after = sampled_kronecker_products.sampled_vec_trick(v, X2, X1, self.input2_inds, self.input1_inds)
v_after = sampled_kronecker_products.sampled_vec_trick(v_after, X2.T, X1.T, None, None, self.input2_inds, self.input1_inds) + regparam * v
return v_after
def mv(v):
return sampled_kronecker_products.sampled_vec_trick(v, K2, K1, self.input2_inds, self.input1_inds, self.input2_inds, self.input1_inds) + regparam * v
