def build(self):
self._model = LightFM(no_components=self.rank,
item_alpha=self.item_alpha,
user_alpha=self.user_alpha,
loss=self.loss,
learning_rate=self.learning_rate,
learning_schedule=self.learning_schedule,
max_sampled=self.max_sampled,
random_state=self.seed)
fit = getattr(self._model, self.fit_method)
matrix = self.get_training_matrix()
if self.item_features is not None:
item_features = self.item_features.reindex(
self.data.index.itemid.old.values, fill_value=[])
self._item_features_csr, self.item_feature_labels = stack_features(
item_features,
add_identity=self.item_identity,
normalize=True,
dtype='f4')
if self.user_features is not None:
user_features = self.user_features.reindex(
self.data.index.userid.training.old.values, fill_value=[])
self._user_features_csr, self.user_feature_labels = stack_features(
user_features,
add_identity=self.user_identity,
normalize=True,
dtype='f4')
with Timer(self.method, verbose=self.verbose):
fit(matrix,
item_features=self._item_features_csr,
user_features=self._user_features_csr)
def build(self):
user_item_matrix = self.get_training_matrix()
if self.implicit:
# np.sign allows for negative values as well
user_item_matrix.data = np.sign(user_item_matrix.data)
with Timer(self.method, verbose=self.verbose):
i2i_matrix = user_item_matrix.T.dot(user_item_matrix) # gives CSC format
i2i_matrix.setdiag(0) # exclude "self-links"
i2i_matrix.eliminate_zeros()
self._i2i_matrix = i2i_matrix
def build(self):
# define iALS model instance
self._model = implicit.als.AlternatingLeastSquares(factors=self.rank,
regularization=self.regularization,
iterations=self.num_epochs)
# prepare input matrix for learning the model
matrix = self.get_training_matrix() # user_by_item sparse matrix
matrix.data = self.confidence(matrix.data, alpha=self.alpha, weight=self.weight_func)
with Timer(self.method, verbose=self.verbose):
# build the model
# implicit takes item_by_user matrix as input, need to transpose
self._model.fit(matrix.T)
def build(self):
idx, val, shp = self.data.to_coo(tensor_mode=True)
with Timer(self.method, verbose=self.verbose):
users_factors, items_factors, feedback_factors, core = \
tucker_als(idx, val, shp, self.mlrank,
growth_tol=self.growth_tol,
iters=self.num_iters,
batch_run=not self.show_output)
self.factors[self.data.fields.userid] = users_factors
self.factors[self.data.fields.itemid] = items_factors
self.factors[self.data.fields.feedback] = feedback_factors
self.factors['core'] = core
def build(self):
idx, val, shp = self.data.to_coo(tensor_mode=True)
with Timer(self.method, verbose=self.verbose):
(users_factors, items_factors, feedback_factors,
core) = hooi(idx,
val,
shp,
self.mlrank,
growth_tol=self.growth_tol,
num_iters=self.num_iters,
verbose=self.show_output,
parallel_ttm=self.parallel_ttm,
seed=self.seed)
self.factors[self.data.fields.userid] = users_factors
self.factors[self.data.fields.itemid] = items_factors
self.factors[self.data.fields.feedback] = feedback_factors
self.factors['core'] = core
def build(self, operator=None, return_factors='vh'):
if operator is not None:
svd_matrix = operator
else:
svd_matrix = self.get_training_matrix(dtype=np.float64)
svd_params = dict(k=self.rank, return_singular_vectors=return_factors)
with Timer(self.method, verbose=self.verbose):
user_factors, sigma, item_factors = svds(svd_matrix, **svd_params)
if user_factors is not None:
user_factors = np.ascontiguousarray(user_factors[:, ::-1])
if item_factors is not None:
item_factors = np.ascontiguousarray(item_factors[::-1, :]).T
if sigma is not None:
sigma = np.ascontiguousarray(sigma[::-1])
self.factors[self.data.fields.userid] = user_factors
self.factors[self.data.fields.itemid] = item_factors
self.factors['singular_values'] = sigma