def callback(self, learner):
self.round = self.round + 1
tp = KernelPairwisePredictor(learner.A, learner.input1_inds,
learner.input2_inds).predict(
K_test1, K_test2)
print(
str(self.round) + ' ' +
str(np.mean(np.abs(tp -
ordrls_testpred.ravel(order='F')))))
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 __init__(self, **kwargs):
self.Y = kwargs["Y"]
#self.Y = array_tools.as_2d_array(Y)
self.trained = False
if "regparam" in kwargs:
self.regparam = kwargs["regparam"]
else:
self.regparam = 0.
regparam = self.regparam
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
if 'K1' in kwargs or 'pko' in kwargs:
if 'pko' in kwargs:
pko = kwargs['pko']
else:
self.input1_inds = np.array(kwargs["label_row_inds"],
dtype=np.int32)
self.input2_inds = np.array(kwargs["label_col_inds"],
dtype=np.int32)
K1 = kwargs['K1']
K2 = kwargs['K2']
if 'weights' in kwargs: weights = kwargs['weights']
else: weights = None
pko = pairwise_kernel_operator.PairwiseKernelOperator(
K1, K2, self.input1_inds, self.input2_inds,
self.input1_inds, self.input2_inds, weights)
self.pko = pko
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 pko.matvec(v) + regparam * v
def mvr(v):
raise Exception('This function should not be called!')
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.pko.weights)
self.callbackfun.callback(self)
G = LinearOperator((self.Y.shape[0], self.Y.shape[0]),
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.pko.original_col_inds_K1,
self.pko.original_col_inds_K2, self.pko.weights)
if not self.callbackfun is None:
self.callbackfun.finished(self)
else:
self.input1_inds = np.array(kwargs["label_row_inds"],
dtype=np.int32)
self.input2_inds = np.array(kwargs["label_col_inds"],
dtype=np.int32)
X1 = kwargs['X1']
X2 = kwargs['X2']
self.X1, self.X2 = X1, X2
if 'maxiter' in kwargs: maxiter = int(kwargs['maxiter'])
else: maxiter = None
if 'weights' in kwargs: weights = kwargs['weights']
else: weights = None
Y = np.array(self.Y).ravel(order='F')
self.bestloss = float("inf")
def mv(v):
v_after = pko.matvec(v)
v_after = pko.rmatvec(v_after) + regparam * v
return v_after
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(pko.shape, order='F')
self.bestloss = loss
else:
self.W = v
if not self.callbackfun is None:
self.predictor = LinearPairwisePredictor(self.W)
self.callbackfun.callback(self)
v_init = np.array(self.Y).reshape(self.Y.shape[0])
pko = pairwise_kernel_operator.PairwiseKernelOperator(
X1, X2, self.input1_inds, self.input2_inds, None, None,
weights)
G = LinearOperator((pko.shape[1], pko.shape[1]),
matvec=mv,
dtype=np.float64)
v_init = pko.rmatvec(v_init)
'''if 'warm_start' in kwargs:
x0 = np.array(kwargs['warm_start']).reshape(kronfcount, order = 'F')
else:
x0 = None'''
minres(G, v_init, maxiter=maxiter, callback=cgcb, tol=1e-20
) #[0].reshape((pko_T.shape[0], pko.shape[1]), order='F')
self.predictor = LinearPairwisePredictor(self.W, self.input1_inds,
self.input2_inds, weights)
if not self.callbackfun is None:
self.callbackfun.finished(self)
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 __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 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 __init__(self, **kwargs):
self.Y = kwargs["Y"]
#self.Y = array_tools.as_2d_array(Y)
self.trained = False
if "regparam" in kwargs:
self.regparam = kwargs["regparam"]
else:
self.regparam = 0.
regparam = self.regparam
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
if 'K1' in kwargs or 'pko' in kwargs:
if 'pko' in kwargs:
pko = kwargs['pko']
else:
self.input1_inds = np.array(kwargs["label_row_inds"],
dtype=np.int32)
self.input2_inds = np.array(kwargs["label_col_inds"],
dtype=np.int32)
K1 = kwargs['K1']
K2 = kwargs['K2']
if 'weights' in kwargs: weights = kwargs['weights']
else: weights = None
pko = pairwise_kernel_operator.PairwiseKernelOperator(
K1, K2, self.input1_inds, self.input2_inds,
self.input1_inds, self.input2_inds, weights)
self.pko = pko
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 pko.matvec(v) + regparam * v
def mvr(v):
raise Exception('This function should not be called!')
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.pko.col_inds_K1, self.pko.col_inds_K2,
self.pko.weights)
self.callbackfun.callback(self)
G = LinearOperator((self.Y.shape[0], self.Y.shape[0]),
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.pko.col_inds_K1,
self.pko.col_inds_K2,
self.pko.weights)
else: #Primal case. Does not work with the operator interface yet.
self.input1_inds = np.array(kwargs["label_row_inds"],
dtype=np.int32)
self.input2_inds = np.array(kwargs["label_col_inds"],
dtype=np.int32)
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 primal case yet."
)
if 'weights' in kwargs: weights = kwargs['weights']
else: weights = np.ones((len(X1)))
x1tsize, x1fsize = X1[0].shape #m, d
x2tsize, x2fsize = X2[0].shape #q, r
else:
weights = None
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 mvr(v):
raise Exception('This function should not be called!')
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)
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, self.input1_inds,
self.input2_inds, weights)
if not self.callbackfun is None:
self.callbackfun.finished(self)
def __init__(self, **kwargs):
self.resource_pool = kwargs
Y = kwargs[TRAIN_LABELS]
self.label_row_inds = np.array(kwargs["label_row_inds"],
dtype=np.int32)
self.label_col_inds = np.array(kwargs["label_col_inds"],
dtype=np.int32)
self.Y = Y
self.trained = False
if "regparam" in kwargs:
self.regparam = kwargs["regparam"]
else:
self.regparam = 1.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 not 'K1' in self.resource_pool:
self.regparam = regparam
X1 = self.resource_pool['X1']
X2 = self.resource_pool['X2']
self.X1, self.X2 = X1, X2
if 'maxiter' in self.resource_pool:
maxiter = int(self.resource_pool['maxiter'])
else:
maxiter = 1000
if 'inneriter' in self.resource_pool:
inneriter = int(self.resource_pool['inneriter'])
else:
inneriter = 50
x1tsize, x1fsize = X1.shape #m, d
x2tsize, x2fsize = X2.shape #q, r
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)
fdim = X1.shape[1] * X2.shape[1]
w = np.zeros(fdim)
#np.random.seed(1)
#w = np.random.random(fdim)
self.bestloss = float("inf")
def mv(v):
return hessian(w, v, X1, X2, Y, rowind, colind, lamb)
for i in range(maxiter):
g = gradient(w, X1, X2, Y, rowind, colind, lamb)
G = LinearOperator((fdim, fdim),
matvec=mv,
rmatvec=mv,
dtype=np.float64)
self.best_residual = float("inf")
self.w_new = qmr(G, g, tol=1e-10, maxiter=inneriter)[0]
if np.all(w == w - self.w_new):
break
w = w - self.w_new
if self.compute_risk:
P = sampled_kronecker_products.sampled_vec_trick(
w, X1, X2, rowind, colind)
z = (1. - Y * P)
z = np.where(z > 0, z, 0)
loss = 0.5 * (np.dot(z, z) + lamb * np.dot(w, w))
if loss < self.bestloss:
self.W = w.reshape((x1fsize, x2fsize), order='F')
self.bestloss = loss
else:
self.W = w.reshape((x1fsize, x2fsize), order='F')
if self.callbackfun is not None:
self.callbackfun.callback(self)
self.predictor = LinearPairwisePredictor(self.W)
else:
K1 = self.resource_pool['K1']
K2 = self.resource_pool['K2']
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
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)
self.bestloss = float("inf")
def func(a):
P = sampled_kronecker_products.sampled_vec_trick(
a, K2, K1, colind, rowind, colind, rowind)
z = (1. - Y * P)
z = np.where(z > 0, z, 0)
Ka = sampled_kronecker_products.sampled_vec_trick(
a, K2, K1, colind, rowind, colind, rowind)
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 = sampled_kronecker_products.sampled_vec_trick(
v, K2, K1, cols, rows, colind, rowind)
p[sv] = A
return p + lamb * v
def mv_mk(v):
rows = rowind[sv]
cols = colind[sv]
p = np.zeros(len(rowind))
skpsum = np.zeros(len(sv))
for i in range(len(K1)):
K1i = K1[i]
K2i = K2[i]
skpsum += weights[
i] * sampled_kronecker_products.sampled_vec_trick(
v, K2i, K1i, cols, rows, colind, rowind)
p[sv] = skpsum
return p + lamb * v
def rv(v):
rows = rowind[sv]
cols = colind[sv]
p = sampled_kronecker_products.sampled_vec_trick(
v[sv], K2, K1, colind, rowind, cols, rows)
return p + lamb * v
def rv_mk(v):
rows = rowind[sv]
cols = colind[sv]
psum = np.zeros(len(v))
for i in range(len(K1)):
K1i = K1[i]
K2i = K2[i]
psum += weights[
i] * sampled_kronecker_products.sampled_vec_trick(
v[sv], K2i, K1i, colind, rowind, cols, rows)
return psum + lamb * v
for i in range(maxiter):
if isinstance(K1, (list, tuple)):
if 'weights' in kwargs: weights = kwargs['weights']
else: weights = np.ones((len(K1)))
A = LinearOperator((ddim, ddim),
matvec=mv_mk,
rmatvec=rv_mk,
dtype=np.float64)
P = np.zeros(ddim)
for i in range(len(K1)):
K1i = K1[i]
K2i = K2[i]
prod_i = weights[
i] * sampled_kronecker_products.sampled_vec_trick(
a, K2i, K1i, colind, rowind, colind, rowind)
P += prod_i
else:
weights = None
A = LinearOperator((ddim, ddim),
matvec=mv,
rmatvec=rv,
dtype=np.float64)
P = sampled_kronecker_products.sampled_vec_trick(
a, K2, K1, colind, rowind, colind, rowind)
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
self.a_new = qmr(A, B, tol=1e-10, maxiter=inneriter)[0]
if np.all(a == a - self.a_new):
break
a = a - self.a_new
if self.compute_risk:
loss = func(a)
if loss < self.bestloss:
self.A = a
self.bestloss = loss
else:
self.A = a
self.predictor = KernelPairwisePredictor(a, rowind, colind)
if self.callbackfun is not None:
self.callbackfun.callback(self)
self.predictor = KernelPairwisePredictor(a, rowind, colind)
if self.callbackfun is not None:
self.callbackfun.finished(self)