Beispiel #1
0
    def __init__(self,
                 train_file,
                 test_file=None,
                 metadata_file=None,
                 similarity_matrix_file=None,
                 ranking_file=None,
                 neighbors=30,
                 rank_number=10,
                 similarity_metric="correlation",
                 space_type='\t'):
        ItemKNN.__init__(self,
                         train_file,
                         test_file=test_file,
                         ranking_file=ranking_file,
                         neighbors=neighbors,
                         rank_number=rank_number,
                         similarity_metric=similarity_metric,
                         space_type=space_type)

        if metadata_file is None and similarity_matrix_file is None:
            print(
                "This algorithm needs a similarity matrix or a metadata file!")
            sys.exit(0)

        if metadata_file is not None:
            self.metadata = ReadFile(
                metadata_file, space_type=space_type).read_metadata(self.items)
            self.matrix = self.metadata['matrix'].T
        self.similarity_matrix_file = similarity_matrix_file
Beispiel #2
0
 def get_itemknn(self):
     ItemKNN(train_file=self.train_file,
             test_file=self.test_file,
             output_file=self.output_file,
             rank_length=self.rank_length,
             similarity_metric=self.similarity_metric,
             k_neighbors=int(self.k_neighbors),
             sep=self.sep,
             output_sep=self.output_sep).compute(verbose_evaluation=False)
    def generate_recommendation(self):
        self.ranking = []
        for n, train_file in enumerate(self.gb_train_files):
            if self.recommender == 'UserKNN':
                rec = UserKNN(train_file=train_file,
                              similarity_metric=self.similarity_metric,
                              as_binary=True,
                              as_similar_first=False)
                rec.compute(verbose=False, verbose_evaluation=False)
                self.ranking += rec.ranking

            elif self.recommender == 'ItemKNN':
                rec = ItemKNN(train_file=train_file,
                              test_file=self.test_file,
                              similarity_metric=self.similarity_metric,
                              as_binary=True)
                rec.compute(verbose=False, verbose_evaluation=False)
                self.ranking += rec.ranking

            elif self.recommender == 'MostPopular':
                rec = MostPopular(train_file=train_file,
                                  test_file=self.test_file,
                                  as_binary=True)
                rec.compute(verbose=False, verbose_evaluation=False)
                self.ranking += rec.ranking

            elif self.recommender == 'BPRMF':
                rec = BprMF(train_file=train_file,
                            test_file=self.test_file,
                            batch_size=4)
                rec.compute(verbose=False, verbose_evaluation=False)
                self.ranking += rec.ranking
            else:
                raise ValueError(
                    'Error: Recommender not implemented or not exist!')

        self.ranking = sorted(self.ranking, key=lambda x: (x[0], -x[2]))
from caserec.recommenders.item_recommendation.itemknn import ItemKNN
from caserec.recommenders.item_recommendation.most_popular import MostPopular
from caserec.utils.cross_validation import CrossValidation

db = 'u.data'
folds_path = ''

metrics = ('PREC', 'RECALL', 'NDCG', 'MAP')

recommender = ItemKNN()
CrossValidation(input_file=db,
                recommender=recommender,
                dir_folds=folds_path,
                header=1,
                k_folds=5).compute(metrics=metrics)

recommender = MostPopular()
CrossValidation(input_file=db,
                recommender=recommender,
                dir_folds=folds_path,
                header=1,
                k_folds=5).compute(metrics=metrics)
te_film = '../../../datasets/filmtrust/folds1/0/test.dat'

metadata_item = '../../../datasets/ml-100k/metadata_movies.csv'
sm_item = '../../../datasets/ml-100k/ItemSimilarity.csv'
metadata_user = '******'
sm_user = '******'

label_set1 = '../../../datasets/filmtrust/folds1/0/labeled_set_1.dat'
label_set2 = '../../../datasets/filmtrust/folds1/0/labeled_set_2.dat'
ensemble = '../../../datasets/filmtrust/folds1/0/ensemble_set.dat'

train_list = [tr]
'''单独运行'''
UserKNN(tr_film, te_film, as_similar_first=True).compute()

ItemKNN(tr_film, te_film, as_similar_first=True).compute()

# ContentBased(tr, te, similarity_file=sm_item).compute()

# BprMF(tr, te).compute()

# MostPopular(tr, te, as_binary=True).compute()

# PaCoRecommender(tr, te, as_binary=True).compute()

# ItemAttributeKNN(tr, te, similarity_file=sm_item, as_similar_first=True).compute()

# UserAttributeKNN(tr, te, similarity_file=sm_user, as_similar_first=True).compute()

# GroupBasedRecommender(train_list, te).compute()
'''交叉验证'''
"""

# # Cross Validation
# recommender = UserKNN(as_binary=True)
#
# CrossValidation(input_file=db, recommender=recommender, dir_folds=folds_path, header=1, k_folds=5).compute()
#
# # Simple
# UserKNN(tr, te, as_binary=True).compute()
# UserAttributeKNN(tr, te, metadata_file=metadata_user).compute()
# UserAttributeKNN(tr, te, similarity_file=sm_user).compute()
"""

    ItemKNN

"""

# # Cross Validation
recommender = ItemKNN(as_binary=True)
#
CrossValidation(input_file=db,
                recommender=recommender,
                dir_folds=folds_path,
                header=1,
                k_folds=5).compute()
#
# # Simple
# ItemKNN(tr, te, as_binary=True).compute()
ItemAttributeKNN(tr, te, metadata_file=metadata_item).compute()
# ItemAttributeKNN(tr, te, similarity_file=sm_item).compute()