推荐算法的Python实现——MF(矩阵分解)

本文涉及的产品
云原生网关 MSE Higress,422元/月
服务治理 MSE Sentinel/OpenSergo,Agent数量 不受限
注册配置 MSE Nacos/ZooKeeper,118元/月
简介: 推荐算法的Python实现——MF(矩阵分解)

1. 数据集


本博客用Movielens-1m数据集的ratings.dat作为推荐数据来训练MF推荐模型。第一列是用户id(user_id)、第二列是物品id(item_id)、第三列是用户对物品的评分(score)、第四列是时间戳(timestamp)。


在Movielens-1m数据集中,注意ratings.dat是用::作为分隔符的。。


2. 代码


import numpy as np
from tqdm import tqdm
def loadData(dataset_path, split="::"):
    '''
    加载数据
    :param dataset_path: 数据文件地址
    :return: 以用户id排序为主,同时按用户评分时间序列化的数据列表
    '''
    data_item_list = []
    # 一条数据项(data_item)内所包含的信息按顺序展示为:
    # userId::movieId::rating::timestamp (ml-1m)
    for data_item in open(dataset_path):
        # data_item_list存储的是元组类型的数据项:[(6040, 858, 4, 956703932), (1, 593, 3, 1112484661), ...]
        temp_tuple = list(data_item.strip().split(split)[:4])  # 分隔符,ml-1m上是"::",ml-20m上是","
        temp_tuple[0] = int(temp_tuple[0])  # 用户ID
        temp_tuple[1] = int(temp_tuple[1])  # 物品ID
        temp_tuple[2] = int(temp_tuple[2])  # 物品评分,ml-1m上评分是int,ml-20m上评分是float
        temp_tuple[3] = int(temp_tuple[3])  # 时间戳
        data_item_list.append(tuple(temp_tuple))
    # 根据该数据项产生的时间(timestamp:tup[3])和该数据项的用户id(userId:tup[0])对data_item_list进行排序
    data_item_list = sorted(data_item_list, key=lambda tup: tup[3])
    data_item_list = sorted(data_item_list, key=lambda tup: tup[0])
    return data_item_list  # 所返回的data_item_list是以用户id排序为主,同时按用户评分时间序列化的
def getUIMat(data):
    # 构造U-I评分矩阵
    user_list = [i[0] for i in data]
    item_list = [i[1] for i in data]
    UI_matrix = np.zeros((max(user_list) + 1, max(item_list) + 1))
    # 遍历历史数据,令uimat[u][i] = r
    for each_interaction in tqdm(data, total=len(data)):
        UI_matrix[each_interaction[0]][each_interaction[1]] = each_interaction[2]
    return UI_matrix
class MF():
    def __init__(self, R, K, alpha, beta, iterations):
        """
        执行矩阵分解,预测矩阵中的0项。
        参数
        - R (ndarray)   : user-item 评分矩阵
        - K (int)       : 隐特征维度
        - alpha (float) : 学习率
        - beta (float)  : 正则化参数
        """
        self.R = R
        self.num_users, self.num_items = R.shape
        self.K = K
        self.alpha = alpha
        self.beta = beta
        self.iterations = iterations
    def train(self):
        # 初始化用户和项目隐特征矩阵
        self.P = np.random.normal(scale=1./self.K, size=(self.num_users, self.K))
        self.Q = np.random.normal(scale=1./self.K, size=(self.num_items, self.K))
        # 初始化 biases
        self.b_u = np.zeros(self.num_users)
        self.b_i = np.zeros(self.num_items)
        self.b = np.mean(self.R[np.where(self.R != 0)])
        # 构建训练样本
        self.samples = [
            (i, j, self.R[i, j])
            for i in range(self.num_users)
            for j in range(self.num_items)
            if self.R[i, j] > 0
        ]
        # 迭代进行随机梯度下降
        training_process = []
        for i in tqdm(range(self.iterations), total=self.iterations):
            np.random.shuffle(self.samples)
            self.sgd()
            mse = self.mse()
            training_process.append((i, mse))
            # 每完成10%的训练迭代,就输出一次损失
            if (i == 0) or ((i+1) % (self.iterations / 10) == 0):
                print("Iteration: %d ; error = %.4f" % (i+1, mse))
        return training_process
    def mse(self):
        """
        均方误差损失
        """
        xs, ys = self.R.nonzero()
        predicted = self.full_matrix()
        error = 0
        for x, y in zip(xs, ys):
            error += pow(self.R[x, y] - predicted[x, y], 2)
        return np.sqrt(error)
    def sgd(self):
        """
        随机梯度下降
        """
        for i, j, r in self.samples:
            # 计算预测值和error
            prediction = self.get_rating(i, j)
            e = (r - prediction)
            # 更新 biases
            self.b_u[i] += self.alpha * (e - self.beta * self.b_u[i])
            self.b_i[j] += self.alpha * (e - self.beta * self.b_i[j])
            # 更新 user 和 item 隐特征矩阵
            self.P[i, :] += self.alpha * (e * self.Q[j, :] - self.beta * self.P[i,:])
            self.Q[j, :] += self.alpha * (e * self.P[i, :] - self.beta * self.Q[j,:])
    def get_rating(self, i, j):
        """
        获取预测评分 r_ij,其中i是用户id,j是项目id
        """
        prediction = self.b + self.b_u[i] + self.b_i[j] + self.P[i, :].dot(self.Q[j, :].T)
        return prediction
    def full_matrix(self):
        """
        获取完整的预测矩阵
        """
        return self.b + self.b_u[:,np.newaxis] + self.b_i[np.newaxis:,] + self.P.dot(self.Q.T)
if __name__ == "__main__":
    obs_dataset = loadData('./ratings.dat')  # 读取数据 ratings.dat
    R = getUIMat(obs_dataset) # 获取交互矩阵
    # alpha是学习率,不宜过大;beta是正则化系数,不宜过小
    mf = MF(R, K=2, alpha=0.1, beta=0.3, iterations=100)
    mf.train()
    # ------ 进行推荐 ------ #
    # 给用户1推荐top10
    each_user = 1
    user_ratings = mf.full_matrix()[each_user].tolist()
    topN = [(i, user_ratings.index(i)) for i in user_ratings] # 关联项目id及其评分
    topN = [i[1] for i in sorted(topN, key=lambda x:x[0], reverse=True)][:10]
    print("------ user ------")
    print(each_user)
    print("------ temp_topN ------")
    print(topN)
    # 给所有用户推荐Top10
    # user_list = [i[0] for i in obs_dataset]
    # for each_user in tqdm(list(set(user_list)), total=len(list(set(user_list)))):
    #     user_ratings = mf.full_matrix()[each_user].tolist()
    #     topN = [(i, user_ratings.index(i)) for i in user_ratings]  # 关联项目id及其评分
    #     # 对TopN列表排序,取出index,即项目id
    #     topN = [i[1] for i in sorted(topN, key=lambda x:x[0], reverse=True)][:10]
    #     print("------ each_user ------")
    #     print(each_user)
    #     print("------ temp_topN ------")
    #     print(temp_topN)


对用户1(user_id=1)产生一次推荐的输出结果(示例):


Iteration: 1 ; error = 19.0769
 10%|■■■■■■■■                                                                     | 1/10 [00:13<02:04, 13.79s/it] 
 Iteration: 2 ; error = 11.2177
 20%|■■■■■■■■■■■■■■■■                                                             | 2/10 [00:27<01:51, 13.90s/it] 
 Iteration: 3 ; error = 7.8996
 30%|■■■■■■■■■■■■■■■■■■■■■■■■                                                     | 3/10 [00:41<01:37, 13.89s/it] 
 Iteration: 4 ; error = 6.0109
 40%|■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■                                             | 4/10 [00:55<01:23, 13.91s/it] 
 Iteration: 5 ; error = 4.7724
 50%|■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■                                     | 5/10 [01:09<01:09, 13.90s/it] 
 Iteration: 6 ; error = 3.9248
 60%|■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■                             | 6/10 [01:23<00:55, 13.94s/it] 
 Iteration: 7 ; error = 3.2809
 70%|■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■                     | 7/10 [01:37<00:41, 13.99s/it] 
 Iteration: 8 ; error = 2.7991
 80%|■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■             | 8/10 [01:51<00:27, 13.97s/it] 
 Iteration: 9 ; error = 2.4106
 90%|■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■     | 9/10 [02:05<00:13, 13.90s/it] 
 Iteration: 10 ; error = 2.0992
------ user ------
1
------ temp_topN ------
[579, 1618, 2131, 576, 309, 892, 513, 1563, 106, 346]
相关实践学习
基于MSE实现微服务的全链路灰度
通过本场景的实验操作,您将了解并实现在线业务的微服务全链路灰度能力。
相关文章
|
22天前
|
机器学习/深度学习 人工智能 算法
猫狗宠物识别系统Python+TensorFlow+人工智能+深度学习+卷积网络算法
宠物识别系统使用Python和TensorFlow搭建卷积神经网络,基于37种常见猫狗数据集训练高精度模型,并保存为h5格式。通过Django框架搭建Web平台,用户上传宠物图片即可识别其名称,提供便捷的宠物识别服务。
229 55
|
11天前
|
存储 缓存 监控
局域网屏幕监控系统中的Python数据结构与算法实现
局域网屏幕监控系统用于实时捕获和监控局域网内多台设备的屏幕内容。本文介绍了一种基于Python双端队列(Deque)实现的滑动窗口数据缓存机制,以处理连续的屏幕帧数据流。通过固定长度的窗口,高效增删数据,确保低延迟显示和存储。该算法适用于数据压缩、异常检测等场景,保证系统在高负载下稳定运行。 本文转载自:https://www.vipshare.com
103 66
|
1天前
|
机器学习/深度学习 人工智能 算法
基于Python深度学习的眼疾识别系统实现~人工智能+卷积网络算法
眼疾识别系统,本系统使用Python作为主要开发语言,基于TensorFlow搭建卷积神经网络算法,并收集了4种常见的眼疾图像数据集(白内障、糖尿病性视网膜病变、青光眼和正常眼睛) 再使用通过搭建的算法模型对数据集进行训练得到一个识别精度较高的模型,然后保存为为本地h5格式文件。最后使用Django框架搭建了一个Web网页平台可视化操作界面,实现用户上传一张眼疾图片识别其名称。
14 4
基于Python深度学习的眼疾识别系统实现~人工智能+卷积网络算法
|
2月前
|
搜索推荐 Python
利用Python内置函数实现的冒泡排序算法
在上述代码中,`bubble_sort` 函数接受一个列表 `arr` 作为输入。通过两层循环,外层循环控制排序的轮数,内层循环用于比较相邻的元素并进行交换。如果前一个元素大于后一个元素,就将它们交换位置。
142 67
|
2月前
|
存储 搜索推荐 Python
用 Python 实现快速排序算法。
快速排序的平均时间复杂度为$O(nlogn)$,空间复杂度为$O(logn)$。它在大多数情况下表现良好,但在某些特殊情况下可能会退化为最坏情况,时间复杂度为$O(n^2)$。你可以根据实际需求对代码进行调整和修改,或者尝试使用其他优化策略来提高快速排序的性能
129 61
|
2月前
|
算法 数据安全/隐私保护 开发者
马特赛特旋转算法:Python的随机模块背后的力量
马特赛特旋转算法是Python `random`模块的核心,由松本真和西村拓士于1997年提出。它基于线性反馈移位寄存器,具有超长周期和高维均匀性,适用于模拟、密码学等领域。Python中通过设置种子值初始化状态数组,经状态更新和输出提取生成随机数,代码简单高效。
123 63
|
1月前
|
机器学习/深度学习 人工智能 算法
【宠物识别系统】Python+卷积神经网络算法+深度学习+人工智能+TensorFlow+图像识别
宠物识别系统,本系统使用Python作为主要开发语言,基于TensorFlow搭建卷积神经网络算法,并收集了37种常见的猫狗宠物种类数据集【'阿比西尼亚猫(Abyssinian)', '孟加拉猫(Bengal)', '暹罗猫(Birman)', '孟买猫(Bombay)', '英国短毛猫(British Shorthair)', '埃及猫(Egyptian Mau)', '缅因猫(Maine Coon)', '波斯猫(Persian)', '布偶猫(Ragdoll)', '俄罗斯蓝猫(Russian Blue)', '暹罗猫(Siamese)', '斯芬克斯猫(Sphynx)', '美国斗牛犬
167 29
【宠物识别系统】Python+卷积神经网络算法+深度学习+人工智能+TensorFlow+图像识别
|
8天前
|
算法 网络协议 Python
探秘Win11共享文件夹之Python网络通信算法实现
本文探讨了Win11共享文件夹背后的网络通信算法,重点介绍基于TCP的文件传输机制,并提供Python代码示例。Win11共享文件夹利用SMB协议实现局域网内的文件共享,通过TCP协议确保文件传输的完整性和可靠性。服务器端监听客户端连接请求,接收文件请求并分块发送文件内容;客户端则连接服务器、接收数据并保存为本地文件。文中通过Python代码详细展示了这一过程,帮助读者理解并优化文件共享系统。
|
12天前
|
算法
|
13天前
|
存储 算法 Python
文件管理系统中基于 Python 语言的二叉树查找算法探秘
在数字化时代,文件管理系统至关重要。本文探讨了二叉树查找算法在文件管理中的应用,并通过Python代码展示了其实现过程。二叉树是一种非线性数据结构,每个节点最多有两个子节点。通过文件名的字典序构建和查找二叉树,能高效地管理和检索文件。相较于顺序查找,二叉树查找每次比较可排除一半子树,极大提升了查找效率,尤其适用于海量文件管理。Python代码示例包括定义节点类、插入和查找函数,展示了如何快速定位目标文件。二叉树查找算法为文件管理系统的优化提供了有效途径。
45 5