【推荐系统】基于用户的协同过滤算法（UserCF）的python实现_下载movielens数据集,并进行分析,要求如下 (1)下载数据集ml-latest-small.

1.数据集MovieLens

MovieLens数据集包含多个用户对多部电影的评级数据，也包括电影元数据信息和用户属性信息。这个数据集经常用来做推荐系统，机器学习算法的测试数据集。尤其在推荐系统领域.

数据集的下载地址为：http://files.grouplens.org/datasets/movielens/，有好几种版本，对应不同数据量，本文所用的数据为ml-latest-small.zip。本文主要使用其中ratings.csv、movies.csv两个数据表：

ratings数据
userId: 每个用户的id
movieId: 每部电影的id
rating: 用户评分，是5星制，按半颗星的规模递增(0.5 stars 5 stars)
timestamp: 自1970年1月1日零点后到用户提交评价的时间的秒数
数据排序的顺序按照userId，movieId排列的。

movies数据
movieId:每部电影的id
title:电影的标题
genres:电影的类别

关于协同过滤算法的知识点总结，见我另一篇文章：https://www.jianshu.com/p/d6b5ee721aea。同时，这篇文章涉及到的python语法、python库numpy、pandas、sklearn等的使用方法这里也不做赘述，基础较差的童鞋请参考相应的官方文档阅读此文。

2.数据处理

首先，我们定义我们数据的路径，并使用pandas读入：

import math
import numpy as np
import pandas as pd
from sklearn.model_selection import train_test_split

pd.set_option('display.max_rows', 500)
pd.set_option('display.max_columns', 500)
pd.set_option('display.width', 1000)

moviesPath = ".\\data\\movies.csv"
ratingsPath = ".\\data\\ratings.csv"
moviesDF = pd.read_csv(moviesPath, index_col=None)
ratingsDF = pd.read_csv(ratingsPath, index_col=None)
1
2
3
4
5
6
7
8
9
10
11
12
13

这里我们按照4:1的比例将数据集进行拆分，同时打印出总的用户和电影数量、训练集中的用户和电影数量以及测试集中的用户和电影数量：

trainRatingsDF, testRatingsDF = train_test_split(ratingsDF, test_size=0.2)
print("total_movie_count:" + str(len(set(ratingsDF['movieId'].values.tolist()))))
print("total_user_count:" + str(len(set(ratingsDF['userId'].values.tolist()))))
print("train_movie_count:" + str(len(set(trainRatingsDF['movieId'].values.tolist()))))
print("test_movie_count:" + str(len(set(testRatingsDF['movieId'].values.tolist()))))
print("train_user_count:" + str(len(set(trainRatingsDF['userId'].values.tolist()))))
print("test_user_count:" + str(len(set(testRatingsDF['userId'].values.tolist()))))
1
2
3
4
5
6
7

结果如下：

total_movie_count:9066
total_user_count:671
train_movie_count:8381
train_user_count:671
test_movie_count:4901
test_user_count:671
1
2
3
4
5
6

下面，使用pivot_table得到用户-电影的评分矩阵，本文中得到610*8981的评分矩阵

trainRatingsPivotDF = pd.pivot_table(trainRatingsDF[['userId', 'movieId', 'rating']], columns=['movieId'],
                                 index=['userId'], values='rating', fill_value=0)
1
2

得到电影id、用户id与其索引的映射关系：

# enumerate返回穷举序列号与值
# 8981部电影
moviesMap = dict(enumerate(list(trainRatingsPivotDF.columns)))
# 610个用户
usersMap = dict(enumerate(list(trainRatingsPivotDF.index)))
# 矩阵变成list 每一行变成list的一个值 长度为610 每个值大小为8981
ratingValues = trainRatingsPivotDF.values.tolist()
1
2
3
4
5
6
7
1
2
3
4
5
6
7

3.用户相似度计算

利用余弦相似度计算用户之间的相似度：

def calCosineSimilarity(list1, list2):
    res = 0
    denominator1 = 0
    denominator2 = 0
    for (val1, val2) in zip(list1, list2):
        res += (val1 * val2)
        denominator1 += val1 ** 2
        denominator2 += val2 ** 2
    return res / (math.sqrt(denominator1 * denominator2))
1
2
3
4
5
6
7
8
9
1
2
3
4
5
6
7
8
9

计算用户之间的相似度矩阵（610*610）：

# 根据用户对电影的评分，来判断每个用户间相似度
userSimMatrix = np.zeros((len(ratingValues), len(ratingValues)), dtype=np.float32)
for i in range(len(ratingValues) - 1):
    for j in range(i + 1, len(ratingValues)):
        userSimMatrix[i, j] = calCosineSimilarity(ratingValues[i], ratingValues[j])
        userSimMatrix[j, i] = userSimMatrix[i, j]
1
2
3
4
5
6

接下来，我们要找到与每个用户最相近的K个用户，用这K个用户的喜好来对目标用户进行物品推荐，这里K=10，下面的代码用来计算与每个用户最相近的10个用户：

# 找到与每个用户最相近的前K个用户
userMostSimDict = dict()
for i in range(len(ratingValues)):
    userMostSimDict[i] = sorted(enumerate(list(userSimMatrix[i])), key=lambda x: x[1], reverse=True)[:10]
1
2
3
4
1
2
3
4

4.推荐电影

得到了每个用户对应的10个兴趣最相近的用户之后，我们根据下面的公式计算用户对每个没有观看过的电影的兴趣分：

代码如下：

# 用这K个用户的喜好中目标用户没有看过的电影进行推荐
userRecommendValues = np.zeros((len(ratingValues), len(ratingValues[0])), dtype=np.float32)  # 610*8981

for i in range(len(ratingValues)):
    for j in range(len(ratingValues[i])):
        if ratingValues[i][j] == 0:
            val = 0
            for (user, sim) in userMostSimDict[i]:
                val += (ratingValues[user][j] * sim)
            userRecommendValues[i, j] = val
1
2
3
4
5
6
7
8
9
10

接下来为每个用户推荐10部电影：

userRecommendDict = dict()
for i in range(len(ratingValues)):
    userRecommendDict[i] = sorted(enumerate(list(userRecommendValues[i])), key=lambda x: x[1], reverse=True)[:10]
1
2
3

将以上代码中使用的索引首先转换为用户id与电影id，再将电影id转换成电影名：

# 将一开始的索引转换为原来用户id与电影id
userRecommendList = []
for key, value in userRecommendDict.items():
    user = usersMap[key]
    for (movieId, val) in value:
        userRecommendList.append([user, moviesMap[movieId]])

# 将推荐结果的电影id转换成对应的电影名
recommendDF = pd.DataFrame(userRecommendList, columns=['userId', 'movieId'])
recommendDF = pd.merge(recommendDF, moviesDF[['movieId', 'title']], on='movieId', how='inner')
print(recommendDF.tail(10))
1
2
3
4
5
6
7
8
9
10
11

最后，在经历一段较漫长的时间后，可以得到结果：

5.小结

本文代码实现起来比较简单，最后的结果我们可以看出UserCF在用户特征维度较高（本文有8981维）的情况下，算法效率还是挺低的。