Python实现协同过滤推荐算法，用的大一些的数据集就报错MemoryError

Posted 2023-03-16

本人刚学Python，毕业设计要实现基于用户的协同过滤推荐算法，用Movielens 100K的数据集运行没问题，但是换成1M或者其他大的数据集就出现下面的错误，急求大神帮忙解决啊！

Traceback (most recent call last):
File "E:\Python\CF.py", line 149, in <module>
testUserBasedCF()
File "E:\Python\CF.py", line 140, in testUserBasedCF
cf.userSimilarityBest()
File "E:\Python\CF.py", line 59, in userSimilarityBest
count[u].setdefault(v,0)
MemoryError

能私下里详细和我说更好！

python虽然易用，但是内存占用比较多；所以如果你有C/C++/Java基础，考虑用这些语言来实现；

CF算法需要计算大量的相似度，如果能把中间结果存起来，或者简化计算过程（如，你可能会重复计算一个item的均值）可以省下不少内存；（个人试过计算1w个用户Pearson是没问题的）

如果内存实在不够用，那就用时间换空间，把中间计算结果分成小文件存到磁盘上，用的时候再读取。

供参考。

追问

因为某种原因必须要Python呀，大神能给我具体指导一下么，求联系方式！

参考技术A 内存过了,跑的时候,看一下进程用的资源追问

4G内存啊，跑的时候能关的都关了，我在想是不是代码的问题？

追答

这个问题肯定是内存的，以前遇到过很多次，先查查，运行前后的内存

python 实现协同过滤推荐算法

测试数据
http://grouplens.org/datasets/movielens/

#!/usr/bin/python3
# -*- coding: utf-8 -*-
from numpy import *
import time
from texttable import Texttable

# 协同过滤推荐算法主要分为：
# 1、基于用户。根据相邻用户，预测当前用户没有偏好的未涉及物品，计算得到一个排序的物品列表进行推荐
# 2、基于物品。如喜欢物品A的用户都喜欢物品C，那么可以知道物品A与物品C的相似度很高，而用户C喜欢物品A，那么可以推断出用户C也可能喜欢物品C。
# 不同的数据、不同的程序猿写出的协同过滤推荐算法不同，但其核心是一致的：
#   1、收集用户的偏好
#       1)不同行为分组
#       2)不同分组进行加权计算用户的总喜好
#       3)数据去噪和归一化
#   2、找到相似用户(基于用户)或者物品(基于物品)
#   3、计算相似度并进行排序。根据相似度为用户进行推荐
# 本次实例过程：
# 1、初始化数据
#     获取movies和ratings
#     转换成数据userDict  表示某个用户的所有电影的评分集合，并对评分除以5进行归一化
#     转换成数据ItemUser  表示某部电影参与评分的所有用户集合
# 2、计算所有用户与userId的相似度
#     找出所有观看电影与userId有交集的用户
#     对这些用户循环计算与userId的相似度
#         获取A用户与userId的并集。格式为:'电影ID',[A用户的评分,userId的评分]，没有评分记为0
#         计算A用户与userId的余弦距离，越大越相似
# 3、根据相似度生成推荐电影列表
# 4、输出推荐列表和准确率


class CF:

    def __init__(self, movies, ratings, k=5, n=10):
        self.movies = movies
        self.ratings = ratings
        # 邻居个数
        self.k = k
        # 推荐个数
        self.n = n
        # 用户对电影的评分
        # 数据格式'UserID：用户ID':[(MovieID：电影ID,Rating：用户对电影的评星)]
        self.userDict = 
        # 对某电影评分的用户
        # 数据格式：'MovieID：电影ID',[UserID：用户ID]
        # '1',[1,2,3..],...
        self.ItemUser = 
        # 邻居的信息
        self.neighbors = []
        # 推荐列表
        self.recommandList = []
        self.cost = 0.0

    # 基于用户的推荐
    # 根据对电影的评分计算用户之间的相似度
    def recommendByUser(self, userId):
        self.formatRate()
        # 推荐个数 等于 本身评分电影个数，用户计算准确率
        self.n = len(self.userDict[userId])
        self.getNearestNeighbor(userId)
        self.getrecommandList(userId)
        self.getPrecision(userId)

    # 获取推荐列表
    def getrecommandList(self, userId):
        self.recommandList = []
        # 建立推荐字典
        recommandDict = 
        for neighbor in self.neighbors:
            movies = self.userDict[neighbor[1]]
            for movie in movies:
                if(movie[0] in recommandDict):
                    recommandDict[movie[0]] += neighbor[0]
                else:
                    recommandDict[movie[0]] = neighbor[0]

        # 建立推荐列表
        for key in recommandDict:
            self.recommandList.append([recommandDict[key], key])
        self.recommandList.sort(reverse=True)
        self.recommandList = self.recommandList[:self.n]

    # 将ratings转换为userDict和ItemUser
    def formatRate(self):
        self.userDict = 
        self.ItemUser = 
        for i in self.ratings:
            # 评分最高为5 除以5 进行数据归一化
            temp = (i[1], float(i[2]) / 5)
            # 计算userDict '1':[(1,5),(2,5)...],'2':[...]...
            if(i[0] in self.userDict):
                self.userDict[i[0]].append(temp)
            else:
                self.userDict[i[0]] = [temp]
            # 计算ItemUser '1',[1,2,3..],...
            if(i[1] in self.ItemUser):
                self.ItemUser[i[1]].append(i[0])
            else:
                self.ItemUser[i[1]] = [i[0]]

    # 找到某用户的相邻用户
    def getNearestNeighbor(self, userId):
        neighbors = []
        self.neighbors = []
        # 获取userId评分的电影都有那些用户也评过分
        for i in self.userDict[userId]:
            for j in self.ItemUser[i[0]]:
                if(j != userId and j not in neighbors):
                    neighbors.append(j)
        # 计算这些用户与userId的相似度并排序
        for i in neighbors:
            dist = self.getCost(userId, i)
            self.neighbors.append([dist, i])
        # 排序默认是升序，reverse=True表示降序
        self.neighbors.sort(reverse=True)
        self.neighbors = self.neighbors[:self.k]

    # 格式化userDict数据
    def formatuserDict(self, userId, l):
        user = 
        for i in self.userDict[userId]:
            user[i[0]] = [i[1], 0]
        for j in self.userDict[l]:
            if(j[0] not in user):
                user[j[0]] = [0, j[1]]
            else:
                user[j[0]][1] = j[1]
        return user

    # 计算余弦距离
    def getCost(self, userId, l):
        # 获取用户userId和l评分电影的并集
        # '电影ID'：[userId的评分，l的评分] 没有评分为0
        user = self.formatuserDict(userId, l)
        x = 0.0
        y = 0.0
        z = 0.0
        for k, v in user.items():
            x += float(v[0]) * float(v[0])
            y += float(v[1]) * float(v[1])
            z += float(v[0]) * float(v[1])
        if(z == 0.0):
            return 0
        return z / sqrt(x * y)

    # 推荐的准确率
    def getPrecision(self, userId):
        user = [i[0] for i in self.userDict[userId]]
        recommand = [i[1] for i in self.recommandList]
        count = 0.0
        if(len(user) >= len(recommand)):
            for i in recommand:
                if(i in user):
                    count += 1.0
            self.cost = count / len(recommand)
        else:
            for i in user:
                if(i in recommand):
                    count += 1.0
            self.cost = count / len(user)

    # 显示推荐列表
    def showTable(self):
        neighbors_id = [i[1] for i in self.neighbors]
        table = Texttable()
        table.set_deco(Texttable.HEADER)
        table.set_cols_dtype(["t", "t", "t", "t"])
        table.set_cols_align(["l", "l", "l", "l"])
        rows = []
        rows.append([u"movie ID", u"Name", u"release", u"from userID"])
        for item in self.recommandList:
            fromID = []
            for i in self.movies:
                if i[0] == item[1]:
                    movie = i
                    break
            for i in self.ItemUser[item[1]]:
                if i in neighbors_id:
                    fromID.append(i)
            movie.append(fromID)
            rows.append(movie)
        table.add_rows(rows)
        print(table.draw())


# 获取数据
def readFile(filename):
    files = open(filename, "r", encoding="utf-8")
    # 如果读取不成功试一下
    # files = open(filename, "r", encoding="iso-8859-15")
    data = []
    for line in files.readlines():
        item = line.strip().split("::")
        data.append(item)
    return data

# -------------------------开始-------------------------------
start = time.clock()
movies = readFile("/home/hadoop/Python/CF/movies.dat")
ratings = readFile("/home/hadoop/Python/CF/ratings.dat")
demo = CF(movies, ratings, k=20)
demo.recommendByUser("100")
print("推荐列表为：")
demo.showTable()
print("处理的数据为%d条" % (len(demo.ratings)))
print("准确率： %.2f %%" % (demo.cost * 100))
end = time.clock()
print("耗费时间： %f s" % (end - start))