• 协同过滤算法

    1.1 你听说过推荐算法么

    假如我是豆瓣的CEO，很多豆瓣的用户在豆瓣电影上都会对电影进行评分。那么根据这个评分数据，我们有可能知道这些用户除了自己评过分的电影之外还喜欢或讨厌哪些电影吗？这就是一个典型的推荐问题，解决这一类问题的算法被称为推荐算法。

    1.2 什么是协同过滤

    协同过滤的英文全称是Collaborative Filtering，简称CF。注意，这不是一款游戏！从字面上分析，协同就是寻找共同点，过滤就是筛选出优质的内容。

    1.3 协同过滤的分类

    一般来说，协同过滤推荐分为三种类型：

    1. 基于用户(user-based)的协同过滤，通过计算用户和用户的相似度找到跟用户A相似的用户B, C, D...再把这些用户喜欢的内容推荐给A；

    2. 基于物品(item-based)的协同过滤，通过计算物品和物品的相似度找到跟物品1相似的物品2, 3, 4...再把这些物品推荐给看过物品1的用户们；

    3. 基于模型(model based)的协同过滤。主流的方法可以分为：矩阵分解，关联算法，聚类算法，分类算法，回归算法，神经网络。

    1.4 矩阵分解

    矩阵分解 (decomposition, factorization)是将矩阵拆解为数个矩阵的乘积。比如豆瓣电影有m个用户，n个电影。那么用户对电影的评分可以形成一个m行n列的矩阵R，我们可以找到一个m行k列的矩阵U，和一个k行n列的矩阵I，通过U * I来得到矩阵R。

    1.5 ALS

    如果想通过矩阵分解的方法实现基于模型的协同过滤，ALS是一个不错的选择，其英文全称是Alternating Least Square，翻译过来是交替最小二乘法。假设用户为a，物品为b，评分矩阵为R(m, n)，可分解为用户矩阵U(k, m)和物品矩阵I(k, n)，其中m, n, k代表矩阵的维度。前方小段数学公式低能预警：

    1.6 求解用户矩阵U和物品矩阵I

    矩阵R是已知的，我们随机生成用户矩阵U，

    1. 利用1.5中的式5、R和U求出I

    2. 利用1.5中的式6、R和I求出U

    如此交替地执行步骤1和步骤2，直到算法收敛或者迭代次数超过了最大限制，最终我们用RMSE来评价模型的好坏。

    2. 实现篇

    本人用全宇宙最简单的编程语言——Python实现了ALS算法，没有依赖任何第三方库，便于学习和使用。

    2.1 创建ALS类

    初始化，存储用户ID、物品ID、用户ID与用户矩阵列号的对应关系、物品ID与物品矩阵列号的对应关系、用户已经看过哪些物品、评分矩阵的Shape以及RMSE。

    1. class ALS(object):
    2.     def __init__(self):
    3.         self.user_ids = None
    4.         self.item_ids = None
    5.         self.user_ids_dict = None
    6.         self.item_ids_dict = None
    7.         self.user_matrix = None
    8.         self.item_matrix = None
    9.         self.user_items = None
    10.         self.shape = None
    11.         self.rmse = None

    2.2 数据预处理

    对训练数据进行处理，得到用户ID、物品ID、用户ID与用户矩阵列号的对应关系、物品ID与物品矩阵列号的对应关系、评分矩阵的Shape、评分矩阵及评分矩阵的转置。

    1. def _process_data(self, X):
    2.     self.user_ids = tuple((set(map(lambda x: x[0], X))))
    3.     self.user_ids_dict = dict(map(lambda x: x[::-1],
    4.                                     enumerate(self.user_ids)))
    5.  
    6.     self.item_ids = tuple((set(map(lambda x: x[1], X))))
    7.     self.item_ids_dict = dict(map(lambda x: x[::-1],
    8.                                     enumerate(self.item_ids)))
    9.  
    10.     self.shape = (len(self.user_ids), len(self.item_ids))
    11.  
    12.     ratings = defaultdict(lambda: defaultdict(int))
    13.     ratings_T = defaultdict(lambda: defaultdict(int))
    14.     for row in X:
    15.         user_id, item_id, rating = row
    16.         ratings[user_id][item_id] = rating
    17.         ratings_T[item_id][user_id] = rating
    18.  
    19.     err_msg = "Length of user_ids %d and ratings %d not match!" % (
    20.         len(self.user_ids), len(ratings))
    21.     assert len(self.user_ids) == len(ratings), err_msg
    22.  
    23.     err_msg = "Length of item_ids %d and ratings_T %d not match!" % (
    24.         len(self.item_ids), len(ratings_T))
    25.     assert len(self.item_ids) == len(ratings_T), err_msg
    26.     return ratings, ratings_T

    2.3 用户矩阵乘以评分矩阵

    实现稠密矩阵与稀疏矩阵的矩阵乘法，得到用户矩阵与评分矩阵的乘积。

    1. def _users_mul_ratings(self, users, ratings_T):
    2.  
    3.     def f(users_row, item_id):
    4.         user_ids = iter(ratings_T[item_id].keys())
    5.         scores = iter(ratings_T[item_id].values())
    6.         col_nos = map(lambda x: self.user_ids_dict[x], user_ids)
    7.         _users_row = map(lambda x: users_row[x], col_nos)
    8.         return sum(a * b for a, b in zip(_users_row, scores))
    9.  
    10.     ret = [[f(users_row, item_id) for item_id in self.item_ids]
    11.             for users_row in users.data]
    12.     return Matrix(ret)

    2.4 物品矩阵乘以评分矩阵

    实现稠密矩阵与稀疏矩阵的矩阵乘法，得到物品矩阵与评分矩阵的乘积。

    1. def _items_mul_ratings(self, items, ratings):
    2.  
    3.     def f(items_row, user_id):
    4.         item_ids = iter(ratings[user_id].keys())
    5.         scores = iter(ratings[user_id].values())
    6.         col_nos = map(lambda x: self.item_ids_dict[x], item_ids)
    7.         _items_row = map(lambda x: items_row[x], col_nos)
    8.         return sum(a * b for a, b in zip(_items_row, scores))
    9.  
    10.     ret = [[f(items_row, user_id) for user_id in self.user_ids]
    11.             for items_row in items.data]
    12.     return Matrix(ret)

    2.5 生成随机矩阵

    1. def _gen_random_matrix(self, n_rows, n_colums):
    2.     data = [[random() for _ in range(n_colums)] for _ in range(n_rows)]
    3.     return Matrix(data)

    2.6 计算RMSE

    1. def _get_rmse(self, ratings):
    2.         m, n = self.shape
    3.         mse = 0.0
    4.         n_elements = sum(map(len, ratings.values()))
    5.         for i in range(m):
    6.             for j in range(n):
    7.                 user_id = self.user_ids[i]
    8.                 item_id = self.item_ids[j]
    9.                 rating = ratings[user_id][item_id]
    10.                 if rating > 0:
    11.                     user_row = self.user_matrix.col(i).transpose
    12.                     item_col = self.item_matrix.col(j)
    13.                     rating_hat = user_row.mat_mul(item_col).data[0][0]
    14.                     square_error = (rating - rating_hat) ** 2
    15.                     mse += square_error / n_elements
    16.         return mse ** 0.5

    2.7 训练模型

    1. 数据预处理
    2. 变量k合法性检查
    3. 生成随机矩阵U
    4. 交替计算矩阵U和矩阵I，并打印RMSE信息，直到迭代次数达到max_iter
    5. 保存最终的RMSE
    1. def fit(self, X, k, max_iter=10):
    2.     ratings, ratings_T = self._process_data(X)
    3.     self.user_items = {k: set(v.keys()) for k, v in ratings.items()}
    4.     m, n = self.shape
    5.  
    6.     error_msg = "Parameter k must be less than the rank of original matrix"
    7.     assert k < min(m, n), error_msg
    8.  
    9.     self.user_matrix = self._gen_random_matrix(k, m)
    10.  
    11.     for i in range(max_iter):
    12.         if i % 2:
    13.             items = self.item_matrix
    14.             self.user_matrix = self._items_mul_ratings(
    15.                 items.mat_mul(items.transpose).inverse.mat_mul(items),
    16.                 ratings
    17.             )
    18.         else:
    19.             users = self.user_matrix
    20.             self.item_matrix = self._users_mul_ratings(
    21.                 users.mat_mul(users.transpose).inverse.mat_mul(users),
    22.                 ratings_T
    23.             )
    24.         rmse = self._get_rmse(ratings)
    25.         print("Iterations: %d, RMSE: %.6f" % (i + 1, rmse))
    26.  
    27.     self.rmse = rmse

    2.8 预测一个用户

    预测一个用户感兴趣的内容，剔除用户已看过的内容。然后按感兴趣分值排序，取出前n_items个内容。

    1. def _predict(self, user_id, n_items):
    2.     users_col = self.user_matrix.col(self.user_ids_dict[user_id])
    3.     users_col = users_col.transpose
    4.  
    5.     items_col = enumerate(users_col.mat_mul(self.item_matrix).data[0])
    6.     items_scores = map(lambda x: (self.item_ids[x[0]], x[1]), items_col)
    7.     viewed_items = self.user_items[user_id]
    8.     items_scores = filter(lambda x: x[0] not in viewed_items, items_scores)
    9.  
    10.     return sorted(items_scores, key=lambda x: x[1], reverse=True)[:n_items]

    2.9 预测多个用户

    循环调用2.8，预测多个用户感兴趣的内容。

    1. def predict(self, user_ids, n_items=10):
    2.     return [self._predict(user_id, n_items) for user_id in user_ids]

    3 效果评估

    3.1 main函数

    使用电影评分数据集，训练模型并统计RMSE。

    1. @run_time
    2. def main():
    3.     print("Tesing the accuracy of ALS...")
    4.  
    5.     X = load_movie_ratings()
    6.  
    7.     model = ALS()
    8.     model.fit(X, k=3, max_iter=5)
    9.     print()
    10.  
    11.     print("Showing the predictions of users...")
    12.  
    13.     user_ids = range(1, 5)
    14.     predictions = model.predict(user_ids, n_items=2)
    15.     for user_id, prediction in zip(user_ids, predictions):
    16.         _prediction = [format_prediction(item_id, score)
    17.                        for item_id, score in prediction]
    18.         print("User id:%d recommedation: %s" % (user_id, _prediction))

    3.2 效果展示

    设置k=3，迭代5次，并展示了前4个用户的推荐内容，最终RMSE为0.370，运行时间46.5秒，效果还算不错~

     

     数据资源链接：

    recommend-CF/ml-1m at master · iamccme/recommend-CF · GitHub

    基于物品的协同过滤算法,方法为ItemCF

    1. import sys
    2. import random
    3. import math
    4. from operator import itemgetter
    5.  
    6. def ReadData(file,data):
    7.     ''' 读取评分数据
    8.         @param file  评分数据文件
    9.         @param data 储存评分数据的List
    10.     '''
    11.     for line in file :
    12.         line = line.strip('\n')
    13.         linelist = line.split("::")
    14.         data.append([linelist[0],linelist[1]])
    15.  
    16. def SplitData(data, M, key, seed):
    17.     ''' 将数据分为训练集和测试集
    18.         @param data   储存训练和测试数据的List
    19.         @param M      将数据分为M份
    20.         @param key    选取第key份数据做为测试数据
    21.         @param seed   随机种子
    22.         @return train 训练数据集Dict
    23.         @return test  测试数据集Dict
    24.     '''
    25.     test = dict ()
    26.     train = dict ()
    27.     random.seed(seed)
    28.     for user,item in data:
    29.         if random.randint(0,M) == key:
    30.             if user in test:
    31.                 test[user].append(item)
    32.             else:
    33.                 test[user] = []
    34.         else:
    35.             if  user in train:
    36.                 train[user].append(item)
    37.             else:
    38.                 train[user] = []
    39.     return train, test
    40.       
    41. def UserSimilarityOld(train):
    42.     W = dict()
    43.     for u in train.keys():
    44.         W[u] = dict()
    45.         for v in train.keys():
    46.             if u == v:
    47.                 continue
    48.             W[u][v]  = len(list(set(train[u]) & set(train[v])))
    49.             W[u][v] /= math.sqrt(len(train[u]) * len(train[v]) * 1.0)
    50.     return W
    51.  
    52. def ItemSimilarity(train):
    53.     ''' 计算物品相似度
    54.         @param train 训练数据集Dict
    55.         @return W    记录用户相似度的二维矩阵
    56.     '''
    57.     C = dict()
    58.     N = dict()
    59.     #计算没两个item共有的user数目
    60.     for u, items in train.items():
    61.         for i in items:
    62.             if i not in N:
    63.                 N[i] = 0
    64.             N[i] += 1
    65.             for j in items:
    66.                 if i == j: 
    67.                     continue
    68.                 if i not in C :
    69.                     C[i] = dict()
    70.                 if j not in C[i]:
    71.                     C[i][j] = 0
    72.                 C[i][j] += 1
    73.  
    74.     W = dict()
    75.     for i, related_items in C.items():
    76.         for j, cij in related_items.items():
    77.             if i not in W :
    78.                 W[i] = dict()
    79.             W[i][j] = cij / math.sqrt(N[i] * N[j])
    80.  
    81.     return W
    82.  
    83.  
    84.  
    85. def Coverage(train, test, W, N, K):
    86.     ''' 获取推荐结果
    87.         @param user  输入的用户
    88.         @param train 训练数据集Dict
    89.         @param W     记录用户相似度的二维矩阵
    90.         @param N     推荐结果的数目
    91.         @param K     选取近邻的数目
    92.     '''
    93.     recommned_items = set()
    94.     all_items = set()
    95.  
    96.     for user in train.keys():
    97.         for item in train[user]:
    98.             all_items.add(item)
    99.  
    100.         rank = GetRecommendation(user, train, W, N, K)
    101.         for item, pui in rank:
    102.             recommned_items.add(item)
    103.  
    104.     print 'len: ',len(recommned_items),'\n'
    105.     return len(recommned_items) / (len(all_items) * 1.0)
    106.  
    107.  
    108.         
    109. def GetRecommendation(user, train ,W, N, K):
    110.     ''' 获取推荐结果
    111.         @param user  输入的用户
    112.         @param train 训练数据集Dict
    113.         @param W     记录用户相似度的二维矩阵
    114.         @param N     推荐结果的数目
    115.         @param K     选取近邻的数目
    116.     '''
    117.     rank = dict()
    118.     ru = train[user]
    119.     for i in  ru:
    120.         for j,wj in sorted(W[i].items(), key=itemgetter(1),\
    121.             reverse = True)[0:K]:
    122.             if j in ru:
    123.                 continue
    124.             if j in rank:
    125.                 rank[j] += wj
    126.             else:
    127.                 rank[j] = 0
    128.  
    129.     rank = sorted(rank.items(), key=itemgetter(1), reverse = True)[0:N]
    130.     return rank
    131.  
    132.  
    133.         
    134.  
    135. def Recall(train, test, W, N, K):
    136.     ''' 计算推荐结果的召回率
    137.         @param train 训练数据集Dict
    138.         @param test  测试数据集Dict
    139.         @param W     记录用户相似度的二维矩阵
    140.         @param N     推荐结果的数目
    141.         @param K     选取近邻的数目
    142.     '''
    143.     hit = 0
    144.     all = 0
    145.     for user in train.keys():
    146.         if user in test:
    147.             tu = test[user]
    148.             rank = GetRecommendation(user, train, W, N, K)
    149.             for item, pui in rank:
    150.                 if item in tu:
    151.                     hit+= 1
    152.             all += len(tu)
    153.     print(hit)
    154.     print(all)
    155.     return hit/(all * 1.0)
    156.         
    157. def Precision(train, test, W, N, K):
    158.     ''' 计算推荐结果的准确率
    159.         @param train 训练数据集Dict
    160.         @param test  测试数据集Dict
    161.         @param W     记录用户相似度的二维矩阵
    162.         @param N     推荐结果的数目
    163.         @param K     选取近邻的数目
    164.     '''
    165.     hit = 0
    166.     all = 0
    167.     for user in train.keys():
    168.         if user in test:
    169.             tu = test[user]
    170.             rank = GetRecommendation(user, train, W, N, K)
    171.             for item, pui in rank:
    172.                 if item in tu:
    173.                     hit+= 1
    174.             all += N
    175.     print(hit)
    176.     print(all)
    177.     return hit/(all * 1.0)
    178.  
    179. def Popularity(train, test, W, N, K):
    180.     ''' 计算推荐结果的流行度
    181.         @param train 训练数据集Dict
    182.         @param test  测试数据集Dict
    183.         @param W     记录用户相似度的二维矩阵
    184.         @param N     推荐结果的数目
    185.         @param K     选取近邻的数目
    186.     '''
    187.     item_popularity = dict()
    188.     for user, items in train.items():
    189.         for item in items:
    190.             if item not in item_popularity:
    191.                 item_popularity[item] = 0
    192.             item_popularity[item] += 1
    193.  
    194.     ret = 0
    195.     n = 0
    196.     for user in train.keys():
    197.         rank = GetRecommendation(user, train, W, N, K)
    198.         for item, pui in rank:
    199.             ret += math.log(1+ item_popularity[item])
    200.             n += 1
    201.     ret /= n * 1.0
    202.     return ret
    203.  
    204.  
    205.  
    206. if __name__ == '__main__': 
    207.      data = []
    208.      M = 7
    209.      key = 1
    210.      seed = 1
    211.      N = 10
    212.      K = 10
    213.      W = dict()
    214.      rank = dict()
    215.  
    216.      print("this is the main function")
    217.      file = open('./ml-1m/rating.dat')
    218.      ReadData(file,data)
    219.      train,test = SplitData(data, M, key, seed)
    220.      W = ItemSimilarity(train)
    221.      recall = Recall(train, test, W, N, K)
    222.      precision = Precision(train, test, W, N, K)
    223.      popularity = Popularity(train, test, W, N, K)
    224.      coverage = Coverage(train, test, W, N, K)
    225.      print 'recall: ',recall,'\n'
    226.      print 'precision: ',precision,'\n'
    227.      print 'Popularity: ',popularity,'\n'
    228.      print 'coverage: ', coverage,'\n'
    229. else :
    230.      print("this is not the main function")

    基于用户的协同过滤算法UserCF

    1. import sys
    2. import random
    3. import math
    4. from operator import itemgetter
    5.  
    6.  
    7. def ReadData(file,data):
    8.     ''' 读取评分数据
    9.         @param file  评分数据文件
    10.         @param data 储存评分数据的List
    11.     '''
    12.     for line in file:
    13.         line = line.strip('\n')
    14.         linelist = line.split("::")
    15.         data.append([linelist[0],linelist[1]])
    16.  
    17. def SplitData(data, M, key, seed):
    18.     ''' 将数据分为训练集和测试集
    19.         @param data   储存训练和测试数据的List
    20.         @param M      将数据分为M份
    21.         @param key    选取第key份数据做为测试数据
    22.         @param seed   随机种子
    23.         @return train 训练数据集Dict
    24.         @return test  测试数据集Dict
    25.     '''
    26.     test = dict ()
    27.     train = dict ()
    28.     random.seed(seed)
    29.     for user,item in data:
    30.         if random.randint(0,M) == key:
    31.             if user in test:
    32.                 test[user].append(item)
    33.             else:
    34.                 test[user] = []
    35.         else:
    36.             if  user in train:
    37.                 train[user].append(item)
    38.             else:
    39.                 train[user] = []
    40.     return train, test
    41.  
    42. def UserSimilarity(train):
    43.     ''' 计算用户相似度
    44.         @param train 训练数据集Dict
    45.         @return W    记录用户相似度的二维矩阵
    46.     '''
    47.     #建立物品到用户之间的倒查表，降低计算用户相似度的时间复杂性
    48.     item_users = dict()
    49.     for u, items in train.items():
    50.         for i in items:
    51.             if(i not in item_users):
    52.                 item_users[i] = set()
    53.             item_users[i].add(u)
    54.         C = dict()
    55.         N = dict()
    56.         #计算用户之间共有的item的数目
    57.         for i, users in item_users.items():
    58.             for u in users:
    59.                 if(u not in N):
    60.                     N[u] = 1
    61.                 N[u] += 1
    62.                 for v in users:
    63.                     if u == v:
    64.                         continue
    65.                     if(u not in C):
    66.                         C[u] = dict()
    67.                     if(v not in C[u]):
    68.                         C[u][v] = 0
    69.                     #对热门物品进行了惩罚，采用这种方法被称做UserCF-IIF
    70.                     C[u][v] += (1 / math.log(1+len(users)))
    71.     W = dict()
    72.     for u, related_users in C.items():
    73.         for v, cuv in related_users.items():
    74.             if(u not in W):
    75.                 W[u] = dict()
    76.             #利用余弦相似度计算用户之间的相似度
    77.             W[u][v] =  cuv / math.sqrt(N[u] * N[v])
    78.  
    79.     return W
    80.  
    81.  
    82. def Coverage(train, test, W, N, K):
    83.     ''' 获取推荐结果
    84.         @param user  输入的用户
    85.         @param train 训练数据集Dict
    86.         @param W     记录用户相似度的二维矩阵
    87.         @param N     推荐结果的数目
    88.         @param K     选取近邻的数目
    89.     '''
    90.     recommned_items = set()
    91.     all_items = set()
    92.  
    93.     for user in train.keys():
    94.         for item in train[user]:
    95.             all_items.add(item)
    96.  
    97.         rank = GetRecommendation(user, train, W, N, K)
    98.         for item, pui in rank:
    99.             recommned_items.add(item)
    100.  
    101.     #print 'len: ',len(recommned_items),'\n'
    102.     return len(recommned_items) / (len(all_items) * 1.0)
    103.  
    104. def GetRecommendation(user, train ,W, N, K):
    105.     ''' 获取推荐结果
    106.         @param user  输入的用户
    107.         @param train 训练数据集Dict
    108.         @param W     记录用户相似度的二维矩阵
    109.         @param N     推荐结果的数目
    110.         @param K     选取近邻的数目
    111.     '''
    112.     rank = dict()
    113.     interacted_items = train[user]
    114.     #选取K个近邻计算得分
    115.     for v,wuv in sorted(W[user].items(), key=itemgetter(1),\
    116.         reverse = True)[0:K]:
    117.         for i in train[v]:
    118.             if i in interacted_items:
    119.                 continue
    120.             if i in rank:
    121.                 rank[i] += wuv
    122.             else:
    123.                 rank[i] = 0
    124.  
    125.     #取得分最高的N个item作为推荐结果 
    126.     rank = sorted(rank.items(), key=itemgetter(1), reverse = True)[0:N]
    127.  
    128.     return rank
    129.  
    130. def Recall(train, test, W, N, K):
    131.     ''' 计算推荐结果的召回率
    132.         @param train 训练数据集Dict
    133.         @param test  测试数据集Dict
    134.         @param W     记录用户相似度的二维矩阵
    135.         @param N     推荐结果的数目
    136.         @param K     选取近邻的数目
    137.     '''
    138.     hit = 0
    139.     all = 0
    140.     for user in train.keys():
    141.         if user in test:
    142.             tu = test[user]
    143.             rank = GetRecommendation(user, train, W, N, K)
    144.             for item, pui in rank:
    145.                 if item in tu:
    146.                     hit+= 1
    147.             all += len(tu)
    148.     #print(hit)
    149.     #print(all)
    150.     return hit/(all * 1.0)
    151.         
    152. def Precision(train, test, W, N, K):
    153.     ''' 计算推荐结果的准确率
    154.         @param train 训练数据集Dict
    155.         @param test  测试数据集Dict
    156.         @param W     记录用户相似度的二维矩阵
    157.         @param N     推荐结果的数目
    158.         @param K     选取近邻的数目
    159.     '''
    160.     hit = 0
    161.     all = 0
    162.     for user in train.keys():
    163.         if user in test:
    164.             tu = test[user]
    165.             rank = GetRecommendation(user, train, W, N, K)
    166.             for item, pui in rank:
    167.                 if item in tu:
    168.                     hit+= 1
    169.             all += N
    170.     #print(hit)
    171.     #print(all)
    172.     return hit/(all * 1.0)
    173.  
    174. def Popularity(train, test, W, N, K):
    175.     ''' 计算推荐结果的流行度
    176.         @param train 训练数据集Dict
    177.         @param test  测试数据集Dict
    178.         @param W     记录用户相似度的二维矩阵
    179.         @param N     推荐结果的数目
    180.         @param K     选取近邻的数目
    181.     '''
    182.     item_popularity = dict()
    183.     for user, items in train.items():
    184.         for item in items:
    185.             if item not in item_popularity:
    186.                 item_popularity[item] = 0
    187.             item_popularity[item] += 1
    188.  
    189.     ret = 0
    190.     n = 0
    191.     for user in train.keys():
    192.         rank = GetRecommendation(user, train, W, N, K)
    193.         for item, pui in rank:
    194.             ret += math.log(1+ item_popularity[item])
    195.             n += 1
    196.     ret /= n * 1.0
    197.     return ret
    198.  
    199.  
    200.  
    201. if __name__ == '__main__':
    202.      data = []
    203.      M = 8
    204.      key = 1
    205.      seed = 1
    206.      N = 10
    207.      K = 80
    208.      W = dict()
    209.      rank = dict()
    210.  
    211.      print("this is the main function")
    212.      file = open('./ml-1m/rat.dat')
    213.      ReadData(file,data)
    214.      train,test = SplitData(data, M, key, seed)
    215.      W = UserSimilarity(train)
    216.      recall = Recall(train, test, W, N, K)
    217.      precision = Precision(train, test, W, N, K)
    218.      popularity = Popularity(train, test, W, N, K)
    219.      coverage = Coverage(train, test, W, N, K)
    220.      print 'recall: ',recall,'\n'
    221.      print 'precision: ',precision,'\n'
    222.      print 'Popularity: ',popularity,'\n'
    223.      print 'coverage: ', coverage,'\n'
    224. else :
    225.      print("this is not the main function")

  • 相关阅读:
    Functional Programming in Java venkat(14) Being Lazy
    OpenCV 4.x 版本的新特性都有哪些？
    【SpringCloud-学习笔记】Ribbon负载均衡
    Linux服务器安装MariaDB数据库，配置linux防火墙策略
    论文翻译：2022_DeepFilterNet2: Towards Real-Time Speech Enhancement On Embedded Devices For Fullband Audio
    学术报告系列(六) - Autonomous Driving on the journey to full autonomy
    Hive矢量化
    [笔记] 线性筛质数（素数）
    电脑不小心删除的文件怎么恢复?
    JDK：Font.canDisplay()是如何生效的
  • 原文地址：https://blog.csdn.net/sikh_0529/article/details/126861978