1 对协同过滤的简单回顾

还是以之前的例子为例：

任务就是根据这个评分矩阵，猜测Alice对物品5的打分。

在这里插入图片描述
首先ItemCF的做法，根据已有的用户打分计算物品之间的相似度，得到物品的相似度矩阵，根据这个相似度矩阵，选择出前K个与物品5最相似的物品，然后基于Alice对这K个物品的得分，猜测Alice对物品5的得分，有一个加权的计算公式。

UserCF的做法是根据用户对其他物品的打分，计算用户之间的相似度，选择出与Alice最相近的K个用户，然后基于那K个用户对物品5的打分计算出Alice对物品5的打分。

But，这两种方式有个问题，就是如果矩阵非常稀疏的话，当然这个例子是个特例，一般矩阵都是非常稀疏的，那么预测效果就不好，因为两个相似用户对同一物品打分的概率以及Alice同时对两个相似物品打分的概率可能都比较小。另外，这两种方法显然没有考虑到全局的物品或者用户，只是基于了最相似的例子，很可能有偏。

2 矩阵分解的基本步骤

首先，它会先初始化用户矩阵P和物品矩阵Q， P的维度是[users_num, F], Q的维度是[item_nums, F]，这个F是隐向量的维度。也就是把通过隐向量的方式把用户的兴趣和F的特点关联了起来。初始化这两个矩阵的方式很多，但根据经验，随机数需要和1/sqrt(F)成正比。下面代码中会发现。
有了两个矩阵之后，我就可以根据用户已经打分的数据去更新参数，这就是训练模型的过程，方法很简单，就是遍历用户，对于每个用户，遍历它打分的物品，这样就拿到了该用户和物品的隐向量，然后两者相乘加上偏置就是预测的评分，这时候与真实评分有个差距，根据上面的梯度下降就可以进行参数的更新

这样训练完之后，我们就可以得到用户Alice和物品5的隐向量，根据这个就可以预测Alice对物品5的打分。

3 矩阵分解的简单实现

import random
import math

class BasicSVD():
    def __init__(self, rating_data, F=5, alpha=0.1, lmbda=0.1, max_iter=100):
        self.F = F           # 这个表示隐向量的维度
        self.P = dict()          #  用户矩阵P  大小是[users_num, F]
        self.Q = dict()     # 物品矩阵Q  大小是[item_nums, F]
        self.bu = dict()   # 用户偏差系数
        self.bi = dict()    # 物品偏差系数
        self.mu = 1.0        # 全局偏差系数
        self.alpha = alpha   # 学习率
        self.lmbda = lmbda    # 正则项系数
        self.max_iter = max_iter    # 最大迭代次数
        self.rating_data = rating_data # 评分矩阵
        
        # 初始化矩阵P和Q, 方法很多， 一般用随机数填充， 但随机数大小有讲究， 根据经验， 随机数需要和1/sqrt(F)成正比
        cnt = 0    # 统计总的打分数， 初始化mu用
        for user, items in self.rating_data.items():
            self.P[user] = [random.random() / math.sqrt(self.F)  for x in range(0, F)]
            self.bu[user] = 0
            cnt += len(items) 
            for item, rating in items.items():
                if item not in self.Q:
                    self.Q[item] = [random.random() / math.sqrt(self.F) for x in range(0, F)]
                    self.bi[item] = 0
        self.mu /= cnt
        
    # 有了矩阵之后， 就可以进行训练, 这里使用随机梯度下降的方式训练参数P和Q
    def train(self):
        for step in range(self.max_iter):
            for user, items in self.rating_data.items():
                for item, rui in items.items():
                    rhat_ui = self.predict(user, item)   # 得到预测评分
                    # 计算误差
                    e_ui = rui - rhat_ui
                    
                    self.bu[user] += self.alpha * (e_ui - self.lmbda * self.bu[user])
                    self.bi[item] += self.alpha * (e_ui - self.lmbda * self.bi[item])
                    # 随机梯度下降更新梯度
                    for k in range(0, self.F):
                        self.P[user][k] += self.alpha * (e_ui*self.Q[item][k] - self.lmbda * self.P[user][k])
                        self.Q[item][k] += self.alpha * (e_ui*self.P[user][k] - self.lmbda * self.Q[item][k])
                    
            self.alpha *= 0.1    # 每次迭代步长要逐步缩小
    
    # 预测user对item的评分， 这里没有使用向量的形式
    def predict(self, user, item):
        return sum(self.P[user][f] * self.Q[item][f] for f in range(0, self.F)) + self.bu[user] + self.bi[item] + self.mu   

# 定义数据集， 也就是那个表格， 注意这里我们采用字典存放数据， 因为实际情况中数据是非常稀疏的， 很少有情况是现在这样
def loadData():
    rating_data={1: {'A': 5, 'B': 3, 'C': 4, 'D': 4},
           2: {'A': 3, 'B': 1, 'C': 2, 'D': 3, 'E': 3},
           3: {'A': 4, 'B': 3, 'C': 4, 'D': 3, 'E': 5},
           4: {'A': 3, 'B': 3, 'C': 1, 'D': 5, 'E': 4},
           5: {'A': 1, 'B': 5, 'C': 5, 'D': 2, 'E': 1}
          }
    return rating_data
 
# 接下来就是训练和预测
rating_data = loadData()
basicsvd = BasicSVD(rating_data, F=10)
basicsvd.train()
for item in ['E']:
    print(item, basicsvd.predict(1, item))