def __init__(self, dataPtr, lambda1=1e-2, rank=10):
"""Initialize parameters
Args:
dataPtr (DataPtr): An object of which contains X, Z side features and target matrix Y.
lambda1 (uint): Regularizer.
rank (uint): rank of the U, B, V parametrization.
"""
self.dataset = dataPtr
self.X = self.dataset.get_entity("row")
self.Z = self.dataset.get_entity("col")
self.rank = rank
self._loadTarget()
self.shape = (self.X.shape[0], self.Z.shape[0])
self.lambda1 = lambda1
self.nSamples = self.Y.data.shape[0]
self.W = None
self.optima_reached = False
self.manifold = Product([
Stiefel(self.X.shape[1], self.rank),
SymmetricPositiveDefinite(self.rank),
Stiefel(self.Z.shape[1], self.rank),
])
# +
import sys
sys.path.insert(0, "../..")
from autograd.scipy.special import logsumexp
import pymanopt
from pymanopt import Problem
from pymanopt.manifolds import Euclidean, Product, SymmetricPositiveDefinite
from pymanopt.optimizers import SteepestDescent
# (1) Instantiate the manifold
manifold = Product([SymmetricPositiveDefinite(D + 1, k=K), Euclidean(K - 1)])
# (2) Define cost function
# The parameters must be contained in a list theta.
@pymanopt.function.autograd(manifold)
def cost(S, v):
# Unpack parameters
nu = np.append(v, 0)
logdetS = np.expand_dims(np.linalg.slogdet(S)[1], 1)
y = np.concatenate([samples.T, np.ones((1, N))], axis=0)
# Calculate log_q
y = np.expand_dims(y, 0)
# 'Probability' of y belonging to each cluster
def setUp(self):
self.n = n = 15
self.manifold = SymmetricPositiveDefinite(n)
super().setUp()
def setUp(self):
self.n = n = 10
self.k = k = 3
self.manifold = SymmetricPositiveDefinite(n, k=k)
super().setUp()
def setUp(self):
self.n = n = 10
self.k = k = 3
self.man = SymmetricPositiveDefinite(n, k)
def setUp(self):
self.n = n = 15
self.man = SymmetricPositiveDefinite(n)
def fit(self, RLRMCdata, verbosity=0, _evaluate=False):
"""The underlying fit method for RLRMC
Args:
RLRMCdata (RLRMCdataset): the RLRMCdataset object.
verbosity (int): verbosity of Pymanopt. Possible values are 0 (least verbose), 1, or 2 (most verbose).
_evaluate (bool): flag to compute the per iteration statistics in train (and validation) datasets.
"""
# initialize the model
W0 = self._init_train(RLRMCdata.train)
self.user2id = RLRMCdata.user2id
self.item2id = RLRMCdata.item2id
self.id2user = RLRMCdata.id2user
self.id2item = RLRMCdata.id2item
# residual variable
residual_global = np.zeros(RLRMCdata.train.data.shape,
dtype=np.float64)
####################################
# Riemannian first-order algorithm #
####################################
solver = ConjugateGradientMS(
maxtime=self.max_time,
maxiter=self.maxiter,
linesearch=LineSearchBackTracking(),
) # , logverbosity=2)
# construction of manifold
manifold = Product([
Stiefel(self.model_param.get("num_row"), self.rank),
Stiefel(self.model_param.get("num_col"), self.rank),
SymmetricPositiveDefinite(self.rank),
])
problem = Problem(
manifold=manifold,
cost=lambda x: self._cost(
x,
RLRMCdata.train.data,
RLRMCdata.train.indices,
RLRMCdata.train.indptr,
residual_global,
),
egrad=lambda z: self._egrad(z, RLRMCdata.train.indices, RLRMCdata.
train.indptr, residual_global),
verbosity=verbosity,
)
if _evaluate:
residual_validation_global = np.zeros(
RLRMCdata.validation.data.shape, dtype=np.float64)
Wopt, self.stats = solver.solve(
problem,
x=W0,
compute_stats=lambda x, y, z: self._my_stats(
x,
y,
z,
residual_global,
RLRMCdata.validation.data,
RLRMCdata.validation.indices,
RLRMCdata.validation.indptr,
residual_validation_global,
),
)
else:
Wopt, self.stats = solver.solve(problem, x=W0)
self.L = np.dot(Wopt[0], Wopt[2])
self.R = Wopt[1]