def __init__(self, Data): self.Data = Data # model self.rent_model = tensorrec.TensorRec(n_components=5, loss_graph=tensorrec.loss_graphs.WMRBLossGraph()) self.rent_model.fit(interactions=self.Data.sparse_rent, user_features=self.Data.user_indicator_features_rent, item_features=self.Data.full_rentitem_features, n_sampled_items=self.Data.n_items_rent) self.deal_model = tensorrec.TensorRec(n_components=5, loss_graph=tensorrec.loss_graphs.WMRBLossGraph()) self.deal_model.fit(interactions=self.Data.sparse_deal, user_features=self.Data.user_indicator_features_deal, item_features=self.Data.full_dealitem_features, n_sampled_items=self.Data.n_items_deal)
def test_custom_loss_graph(self): import tensorflow as tf import tensorrec # Define a custom loss graph class SimpleLossGraph(tensorrec.loss_graphs.AbstractLossGraph): def connect_loss_graph(self, tf_prediction_serial, tf_interactions_serial, **kwargs): """ This loss function returns the absolute simple error between the predictions and the interactions. :param tf_prediction_serial: tf.Tensor The recommendation scores as a Tensor of shape [n_samples, 1] :param tf_interactions_serial: tf.Tensor The sample interactions corresponding to tf_prediction_serial as a Tensor of shape [n_samples, 1] :param kwargs: Other TensorFlow nodes. :return: A tf.Tensor containing the learning loss. """ return tf.reduce_mean(tf.abs(tf_interactions_serial - tf_prediction_serial)) # Build a model with the custom loss function model = tensorrec.TensorRec(loss_graph=SimpleLossGraph()) # Generate some dummy data interactions, user_features, item_features = tensorrec.util.generate_dummy_data(num_users=100, num_items=150, interaction_density=.05) # Fit the model for 5 epochs model.fit(interactions, user_features, item_features, epochs=5, verbose=True) self.assertIsNotNone(model)
def test_basic_usage(self): import numpy as np import tensorrec # Build the model with default parameters model = tensorrec.TensorRec() # Generate some dummy data interactions, user_features, item_features = tensorrec.util.generate_dummy_data(num_users=100, num_items=150, interaction_density=.05) # Fit the model for 5 epochs model.fit(interactions, user_features, item_features, epochs=5, verbose=True) # Predict scores and ranks for all users and all items predictions = model.predict(user_features=user_features, item_features=item_features) predicted_ranks = model.predict_rank(user_features=user_features, item_features=item_features) # Calculate and print the recall at 10 r_at_k = tensorrec.eval.recall_at_k(predicted_ranks, interactions, k=10) print(np.mean(r_at_k)) self.assertIsNotNone(predictions)
def test_custom_repr_graph(self): import tensorflow as tf import tensorrec # Define a custom representation function graph class TanhRepresentationGraph( tensorrec.representation_graphs.AbstractRepresentationGraph): def connect_representation_graph(self, tf_features, n_components, n_features, node_name_ending): """ This representation function embeds the user/item features by passing them through a single tanh layer. :param tf_features: tf.SparseTensor The user/item features as a SparseTensor of dimensions [n_users/items, n_features] :param n_components: int The dimensionality of the resulting representation. :param n_features: int The number of features in tf_features :param node_name_ending: String Either 'user' or 'item' :return: A tuple of (tf.Tensor, list) where the first value is the resulting representation in n_components dimensions and the second value is a list containing all tf.Variables which should be subject to regularization. """ tf_tanh_weights = tf.Variable( tf.random_normal([n_features, n_components], stddev=.5), name='tanh_weights_%s' % node_name_ending) tf_repr = tf.nn.tanh( tf.sparse_tensor_dense_matmul(tf_features, tf_tanh_weights)) # Return repr layer and variables return tf_repr, [tf_tanh_weights] # Build a model with the custom representation function model = tensorrec.TensorRec(user_repr_graph=TanhRepresentationGraph(), item_repr_graph=TanhRepresentationGraph()) # Generate some dummy data interactions, user_features, item_features = tensorrec.util.generate_dummy_data( num_users=100, num_items=150, interaction_density=.05) # Fit the model for 5 epochs model.fit(interactions, user_features, item_features, epochs=5, verbose=True) self.assertIsNotNone(model)
def interactions_list_to_sparse_matrix(interactions): users_column, items_column, ratings_column, _ = zip(*interactions) return sparse.coo_matrix((ratings_column, (users_column, items_column)), shape=(n_users, n_items)) # Create sparse matrices of interaction data sparse_train_ratings = interactions_list_to_sparse_matrix(train_ratings) sparse_test_ratings = interactions_list_to_sparse_matrix(test_ratings) # Construct indicator features for users and items user_indicator_features = sparse.identity(n_users) item_indicator_features = sparse.identity(n_items) # Build a matrix factorization collaborative filter model cf_model = tensorrec.TensorRec(n_components=5) # Fit the collaborative filter model print("Training collaborative filter") cf_model.fit(interactions=sparse_train_ratings, user_features=user_indicator_features, item_features=item_indicator_features) # Create sets of train/test interactions that are only ratings >= 4.0 sparse_train_ratings_4plus = sparse_train_ratings.multiply( sparse_train_ratings >= 4.0) sparse_test_ratings_4plus = sparse_test_ratings.multiply( sparse_test_ratings >= 4.0) # This method consumes item ranks for each user and prints out recall@10 train/test metrics
print("item features shape:", item_features.shape) pred_path = '/tmp2/bschang/amazon/pred/{}_bow.tf.pred'.format(c) start = time() print("Start training tensorrec...") print("params") print( "n_components: {}, epochs: {}, n_sample: {}, user_batch_size: {}, shuffle_batch: {}, method: {}" .format(K, epoch, n_sample, user_batch_size, shuffle_batch, method)) if user_batch_size is None: user_batch_size = len(user_set) if method == 'ranking': model = tensorrec.TensorRec( n_components=K, # user_repr_graph=NormalizedLinearRepresentationGraph(), item_repr_graph=NormalizedLinearRepresentationGraph(), loss_graph=BalancedWMRBLossGraph(), # loss_graph=BPRLossGraph(), normalize_users=True, normalize_items=True) elif method == 'mf': model = tensorrec.TensorRec(n_components=K, ) model.fit(ui_matrix, user_features, item_features, epochs=epoch, verbose=False, n_sampled_items=n_sample, user_batch_size=user_batch_size, shuffle_batch=shuffle_batch) end = time() print("Spend {0:.2f} secs for training tensorrec.".format(end - start))
import numpy as np import tensorrec model = tensorrec.TensorRec() interactions, user_features, item_features = tensorrec.util.generate_dummy_data( num_users=150, num_items=100, interaction_density=.05) model.fit(interactions, user_features, item_features, epochs=5, verbose=True) predictions = model.predict(user_features=user_features, item_features=item_features) predicted_ranks = model.predict_rank(user_features=user_features, item_features=item_features) r_at_k = tensorrec.eval.recall_at_k(predicted_ranks, interactions, k=10) print(np.mean(r_at_k))
######################### FUNCTION ############################################ ################### Recall at k for the whole dataset ######################## def rec_at_k(predictions, k, test_ratings): result = tensorrec.eval.recall_at_k(test_interactions=test_ratings, predicted_ranks=predictions, k=k).mean() return result ############################################################################### ####### Define the model cf_model = tensorrec.TensorRec( n_components=100, loss_graph=tensorrec.loss_graphs.WMRBLossGraph()) ############################# Generate Predictions and Evaluate ############## ###### Baseline model random_recs_5 = tensorrec.eval.eval_random_ranks_on_dataset(sp_dh_test_ratings, recall_k=5) random_recall_at_5, _, _ = random_recs_5 print("Baseline model recall@5:", random_recall_at_5) random_recs_10 = tensorrec.eval.eval_random_ranks_on_dataset( sp_dh_test_ratings, recall_k=10) random_recall_at_10, _, _ = random_recs_10 print("Baseline model recall@10:", random_recall_at_10) random_recs_20 = tensorrec.eval.eval_random_ranks_on_dataset(
# This method converts a list of (user, item, rating, time) to a sparse matrix def interactions_list_to_sparse_matrix(interactions): users_column, items_column, ratings_column, _ = zip(*interactions) return sparse.coo_matrix((ratings_column, (users_column, items_column)), shape=(n_users, n_items)) # Create sparse matrices of interaction data sparse_train_ratings = interactions_list_to_sparse_matrix(train_ratings) sparse_test_ratings = interactions_list_to_sparse_matrix(test_ratings) # Construct indicator features for users and items user_indicator_features = sparse.identity(n_users) item_indicator_features = sparse.identity(n_items) # Build a matrix factorization collaborative filter model cf_model = tensorrec.TensorRec(n_components=5) # Fit the collaborative filter model print("Training collaborative filter") cf_model.fit(interactions=sparse_train_ratings, user_features=user_indicator_features, item_features=item_indicator_features) # Create sets of train/test interactions that are only ratings >= 4.0 sparse_train_ratings_4plus = sparse_train_ratings.multiply( sparse_train_ratings >= 4.0) sparse_test_ratings_4plus = sparse_test_ratings.multiply( sparse_test_ratings >= 4.0) # This method consumes item ranks for each user and prints out recall@10 train/test metrics def check_results(ranks):
import tensorrec from flask import Flask, request, jsonify from scipy.sparse import csr_matrix from tensorrec.representation_graphs import ReLURepresentationGraph app = Flask(__name__) model = tensorrec.TensorRec(item_repr_graph=ReLURepresentationGraph(), user_repr_graph=ReLURepresentationGraph()) try: model = model.load_model('./model') except IOError: print("没有保存的模型检查点,初始化模型") @app.route('/ranks', methods=["POST"]) def fitModelAndUpateRanks(): input = request.get_json() print("INPUT: \n" + str(input) + "\n") interactions = input['interaction'] user_features = input['user'] item_features = input['product'] # 交互属性值 (矩阵大小用户数*商品数) interactions = csr_matrix( (interactions['data'], (interactions['row'], interactions['col']))) # 性别,余额数量级,积分数量级 user_features = csr_matrix( (user_features['data'], (user_features['row'], user_features['col']))) # 分类ID,价格,销量,访问量,好评率,产品得分 item_features = csr_matrix( (item_features['data'], (item_features['row'], item_features['col'])))
def fittingtheModel(user_Feature,product_Feature,interaction): model = tensorrec.TensorRec() #model.fit(interaction, user_Feature, product_Feature, epochs=3, verbose=True) model.fit(interaction, user_Feature, product_Feature, epochs=30,learning_rate=0.01, alpha=0.00001, verbose=True) print("fitting is done") return model
np.reshape(user_gender_features, (user_gender_features.shape[1], 1)), np.reshape(user_age_features, (user_age_features.shape[1], 1)) ]) full_user_features = sparse.hstack([ user_indicator_features, user_mood_features, user_temperament_features, np.reshape(user_age_features, (user_age_features.shape[1], 1)), np.reshape(user_timestamp_features, (user_timestamp_features.shape[1], 1)), np.reshape(user_gender_features, (user_gender_features.shape[1], 1)), np.reshape(user_is_active_features, (user_is_active_features.shape[1], 1)), np.reshape(user_reaction_features, (user_reaction_features.shape[1], 1)) ]) # Коллаборативная фильтрация print("RMSE matrix factorization collaborative filter (cut):") ranking_cf_model = tensorrec.TensorRec(n_components=5) ranking_cf_model.fit(interactions=sparse_train_ratings, user_features=cut_user_features, item_features=item_indicator_features) cut_cf_predicted_ranks = ranking_cf_model.predict_rank( user_features=cut_user_features, item_features=item_indicator_features) check_results(cut_cf_predicted_ranks, sparse_train_ratings, sparse_test_ratings) print("RMSE matrix factorization collaborative filter (full):") ranking_cf_full_model = tensorrec.TensorRec(n_components=5) ranking_cf_full_model.fit(interactions=sparse_train_ratings, user_features=full_user_features, item_features=item_indicator_features) predicted_ranks = ranking_cf_full_model.predict_rank( user_features=full_user_features, item_features=item_indicator_features)