def recommend_rival(self, n_folds, train_test_file_path, reader, recommendation_file_path): """ Prepare the predictions to take them to RiVaL Toolkit. :param n_folds: Number of folds. :param train_test_file_path: Path with train and input_test files. :param recommendation_file_path: Path where the suitable files to run RiVaL Toolkit are saved. :return: The suitable files to run RiVaL Toolkit are saved. """ for i in range(n_folds): print('Fold: ', i) timestart = time.time() # train file: train_file_name = train_test_file_path + 'train_bin_verified_sep_' + str(i) + '.csv' train_data = Dataset(reader=reader) raw_trainset = train_data.read_ratings(file_name=train_file_name) trainset = train_data.construct_trainset(raw_trainset) timeend = time.time() print('Train file loading time: ', (timeend - timestart), 'seconds') timestart = time.time() # Train recommendation input_model: self.model.fit(trainset) timeend = time.time() print('Training time: ', (timeend - timestart), 'seconds') # input_test file: timestart = time.time() test_file_name = train_test_file_path + 'test_bin_verified_sep_' + str(i) + '.csv' test_data = Dataset(reader=reader) raw_testset = test_data.read_ratings(file_name=test_file_name) testset = test_data.construct_testset(raw_testset) timeend = time.time() print('Load time of the input_test file: ', (timeend - timestart), 'seconds') # Predictions: timestart = time.time() predictions = self.model.test(testset) file_name = open(recommendation_file_path + 'recs_' + str(i) + '.csv', 'w') for pred in predictions: user_id = pred[0] item_id = pred[1] rating_real = pred[2] rating_estimated = pred[3] file_name.write(user_id + "\t" + item_id + "\t" + str(rating_estimated) + '\n') timeend = time.time() print('Prediction time: ', (timeend - timestart), 'seconds')
def create_train_set(self, train_data): ''' Function to create training set ------ Args: train_data: Training set in the form of list ------ Returns: Trainset object from surprise Basically a list with the following format: user, item, rating, timestamp ''' ds = Dataset(self.reader) return ds.construct_trainset(train_data)
def estimate_preference(self, user_id, item_id): """ Estimate the preference value by a specific user. :param user_id: Id of the user to recommend. :param item_id: Id of the item to recommend. :return: The estimate preference by the sepecific recommender. """ # train file: df_ratings = self.rating_data_model.df_ratings # A reader is still needed but only the rating_scale param is requiered. reader = Reader(rating_scale=(self.rating_data_model.get_min_preference(), self.rating_data_model.get_max_preference())) train_data = Dataset(reader=reader) # The columns must correspond to user id, item id and ratings (in that order). raw_trainset = train_data.load_from_df(df_ratings[['user_id', 'item_id', 'rating']], reader) trainset = train_data.construct_trainset(raw_trainset.raw_ratings) # Train recommendation input_model: self.model.fit(trainset) return float(self.model.estimate(u=user_id, i=item_id)[0])