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]