推荐系统入门笔记八: 基于矩阵分解的协同过滤推荐

一.基于矩阵分解的CF算法简介

1. Traditional SVD

通常SVD矩阵分解指的是SVD（奇异值）分解技术，在这我们姑且将其命名为Traditional SVD（传统并经典着）其公式如下：
$$M_{m \times n}=U{m \times k}\sum{}{}_{k \times k}V_{k \times n}^T$$
Traditional SVD分解的形式为3个矩阵相乘，中间矩阵为奇异值矩阵。如果想运用SVD分解的话，有一个前提是要求矩阵是稠密的，即矩阵里的元素要非空，否则就不能运用SVD分解。

数据其实绝大多数情况下都是稀疏的，因此如果要使用Traditional SVD，一般的做法是先用均值或者其他统计学方法来填充矩阵，然后再运用Traditional SVD分解降维，但这样做明显对数据的原始性造成一定影响。

2. FunkSVD（LFM）

刚才提到的Traditional SVD首先需要填充矩阵，然后再进行分解降维，同时存在计算复杂度高的问题，因为要分解成3个矩阵，所以后来提出了Funk SVD的方法，它不在将矩阵分解为3个矩阵，Traditional SVD将分解为2个用户-隐含特征，项目-隐含特征的矩阵，Funk SVD也被称为最原始的LFM模型
$$\sum_{ij}(m_{ij}-q_i^Tp_i)^2$$
借鉴线性回归的思想，通过最小化观察数据的平方来寻求最优的用户和项目的隐含向量表示。同时为了避免过度拟合（Overfitting）观测数据，又提出了带有L2正则项的FunkSVD，上公式：

通过梯度下降或者随机梯度下降法来寻求最优解

3. BiasSVD

在FunkSVD提出来之后，出现了很多变形版本，其中一个相对成功的方法是BiasSVD，顾名思义，即带有偏置项的SVD分解：

它基于的假设和Baseline基准预测是一样的，但这里将Baseline的偏置引入到了矩阵分解中

4. SVD++

改进的BiasSVD，被称为SVD++，该算法是在BiasSVD的基础上添加了用户的隐式反馈信息：

显示反馈指的用户的评分这样的行为，隐式反馈指用户的浏览记录、购买记录、收听记录等。
SVD++是基于这样的假设：在BiasSVD基础上，认为用户对于项目的历史浏览记录、购买记录、收听记录等可以从侧面反映用户的偏好。

二.基于矩阵分解的CF算法LFM实现

1. LFM原理解析

LFM(latent factor model)隐语义模型核心思想是通过隐含特征联系用户和物品，如下图：

• P矩阵是User-LF矩阵,用户和隐含特征矩阵
• Q矩阵LF-Item矩阵,隐含特征和物品的矩阵
• R矩阵是User-Item矩阵,由\(P*Q\)得到

利用矩阵分解技术，将原始User-Item的评分矩阵（稠密/稀疏）分解为P和Q矩阵，然后利用\(P*Q\)还原出User-Item评分矩阵R。整个过程相当于降维处理，其中：

• 矩阵值\(P_{11}\) 表示用户1对隐含特征1的权重值
• 矩阵值\(Q_{11}\)表示隐含特征1在物品1上的权重值
• 矩阵值\(R_{11}\)就表示预测的用户1对物品1的评分，且\(R_{11}=\vec{P_{1,k}}\cdot \vec{Q_{k,1}}\)

利用LFM预测用户对物品的评分，k表示隐含特征数量：

$$ \hat {r}_{ui} =\vec {p_{uk}}\cdot \vec{q_{ik}} =\sum_{k=1}^{k}p_{uk}q{ik} $$

因此最终，我们的目标也就是要求出P矩阵和Q矩阵及其当中的每一个值，然后再对用户-物品的评分进行预测。

2. 损失函数

同样对于评分预测我们利用平方差来构建损失函数：

$$ Cost=\sum_{u,i\in R}(r_{ui}-\hat{r}_{ui})^2=\sum_{u,i\in R}(r_{ui}-\sum_{k=1}^{k}p_{uk}q_{ik})^2 $$

加入L2正则化：

$$ Cost=\sum_{u,i \in R}(r_{ui}-\sum_{k=1}^kp_{uk}q_{ik})^2+ \lambda(\sum_{U}p_{uk}^2+\sum_Iq_{ik}^2) $$

对损失函数求偏导：

3. 随机梯度下降法优化

同理：

随机梯度下降： 向量乘法 每一个分量相乘 求和

由于P矩阵和Q矩阵是两个不同的矩阵，通常分别采取不同的正则参数，如\(\lambda_1\)和\(\lambda_2\)

4. 算法实现

import pandas as pd
import numpy as np


class LFM(object):
    def __init__(self, alpha, reg_p, reg_q, number_LatentFactors=10, number_epochs=10,
                 columns=["uid", "iid", "rating"]):
        # 学习率
        self.alpha = alpha
        # P 的lambda
        self.reg_p = reg_p
        # q 的lambda
        self.reg_q = reg_q
        # 矩阵分解隐式类别数量
        self.number_LatentFactors = number_LatentFactors
        # 迭代次数
        self.number_epochs = number_epochs
        self.columns = columns

    def fit(self, dataset):
        # 加载数据
        self.dataset = pd.DataFrame(dataset)
        # 用户评分数据集
        self.user_ratings = dataset.groupby('userId').agg([list])
        # 电影评分数据集
        self.item_ratings = dataset.groupby('movieId').agg([list])
        # 平均评分
        self.global_mean = self.dataset['rating'].mean()
        # 计算的P和Q
        self.P, self.Q = self.sgd()

    def init_matrix(self):
        # 初始化P 和 Q, P

        P = dict(zip(self.user_ratings.index,
                     np.random.rand(len(self.user_ratings), self.number_LatentFactors).astype(np.float32)))
        Q = dict(zip(self.item_ratings.index,
                     np.random.rand(len(self.item_ratings), self.number_LatentFactors).astype(np.float32)))
        return P, Q

    def sgd(self):
        # 进行矩阵拆解
        # 初始化P和Q
        P, Q = self.init_matrix()
        # 迭代更新 P 和 Q 矩阵
        for i in range(self.number_epochs):
            print("iter%d" % i)
            error_list = []
            for uid, iid, r_ui in self.dataset.itertuples(index=False):
                # 用户
                v_pu = P[uid]
                v_qi = Q[iid]
                err = np.float32(r_ui - np.dot(v_pu, v_qi))
                v_pu += self.alpha * (err * v_qi - self.reg_p * v_pu)
                v_qi += self.alpha * (err * v_pu - self.reg_q * v_qi)
                # 更新P Q
                Q[uid] = v_pu
                P[iid] = v_qi
            error_list.append(err ** 2)
        return P, Q

    def predict(self, uid, iid):
        # 预测用户对物品的评分
        # 如果uid或iid不在，我们使用全剧平均分作为预测结果返回
        if uid not in self.user_ratings.index or iid not in self.item_ratings.index:
            return self.globalMean
        p_u = self.Q[uid]
        q_i = self.Q[iid]
        return np.dot(p_u, q_i)

    def test(self, testset):
        for uid, iid, real_rating in testset.itertuples(index=False):
            try:
                pred_rating = self.predict(uid, iid)
            except Exception as  e:
                print(e)
            else:
                yield uid, iid, real_rating, pred_rating


if __name__ == '__main__':
    dtype = [("userId", np.int32), ("movieId", np.int32), ("rating", np.float32)]
    dataset = pd.read_csv("E:/ml/recommand/ml-latest-small/ratings.csv", usecols=range(3), dtype=dict(dtype))

    lfm = LFM(0.02, 0.01, 0.01, 10, 20, ["userId", "movieId", "rating"])
    lfm.fit(dataset)
    predict_rating = lfm.predict(1, 1)
    print(predict_rating)

二.基于矩阵分解的CF算法BiasSvd

1. BiasSvd简介

BiasSvd就是Funk SVD矩阵分解基础上加上了偏置项。
利用BiasSvd预测用户对物品的评分，k表示隐含特征数量：

$$ \hat{r}_{ui}=\mu+b_u+b_i+\vec{p_{uk}}\cdot \vec{p_{ki}} \\=\mu +b_u+b_i+\sum_{k=1}^kp_{uk}q_{ik} $$

2. 损失函数

同样对于评分预测我们利用平方差来构建损失函数：

$$ Cost=\sum_{u,i \in R}(r_{ui}-\mu -b_u - b_i- \sum_{k=1}^{k}p_{uk}q_{ik})^2 $$

加入L2正则化：

$$ Cost=\sum_{ui \in R}(r_{ui}- \mu -b_u-b_i- \sum_{k=1}^{k}p_{uk}q_{ik})^2+ \lambda(\sum_{U}b_u^2+\sum_U b_u^2+ \sum_{I}b_i^2+\sum_u p_{uk}^2+\sum_I q_{ik}^2) $$

对损失函数求偏导：

随机梯度下降法优化
梯度下降更新参数\(p_{uk}\)：

同理：

随机梯度下降

由于P矩阵和Q矩阵是两个不同的矩阵，通常分别采取不同的正则参数，如\(\lambda_1\)和\(\lambda_2\)

3. 算法实现

import pandas as pd
import numpy as np


class BiasSvd():
    def __init__(self, alpha, reg_p, reg_q, reg_bu, reg_bi, number_LatentFactors=10, number_epochs=10,
                 columns=["uid", "iid", "rating"]):
        self.alpha = alpha
        self.reg_p = reg_p
        self.reg_q = reg_q
        self.reg_bu = reg_bu
        self.reg_bi = reg_bi
        self.number_LatentFactors = number_LatentFactors
        self.number_epochs = number_epochs
        self.columns = columns

    def fit(self, dataset):
        # 训练更新P,Q

        # 加载数据
        self.dataset = pd.DataFrame(dataset)
        # 获取用户评分数据集
        self.user_ratings = dataset.groupby('userId').agg(list)
        # 获取电影评分数据集
        self.item_ratings = dataset.groupby('movieId').agg(list)
        self.global_mean = dataset['rating'].mean()
        self.P, self.Q, self.bu, self.bi = self.sgd()

    def init_matrix(self):
        # 初始化用户-隐形特性的矩阵
        P = dict(zip(self.user_ratings.index, np.random.rand(len(self.user_ratings), self.number_LatentFactors)))
        # 初始化电影隐形特性矩阵
        Q = dict(zip(self.item_ratings.index, np.random.rand(len(self.item_ratings), self.number_LatentFactors)))
        return P, Q

    def sgd(self):
        # 拆解矩阵
        P, Q = self.init_matrix()

        # 初始化 bu bi 为0
        bu = dict(zip(self.user_ratings.index, np.zeros(len(self.user_ratings))))
        bi = dict(zip(self.item_ratings.index, np.zeros(len(self.item_ratings))))
        # 迭代更新参数
        for i in range(self.number_epochs):
            print("iter%d" % i)
            # 读取已有的评分,更新P,Q,bu,bi
            for uid, iid, r_ui in self.dataset.itertuples(index=False):
                v_pu = P[uid]
                v_qi = Q[iid]
                err = np.float32(r_ui - self.global_mean - bu[uid] - bi[iid] - np.dot(v_pu, v_qi))
                # 更新 v_pu
                v_pu += self.alpha * (err * v_qi - self.reg_p * v_pu)
                # 更新 v_qi
                v_qi += self.alpha * (err * v_pu - self.reg_q * v_qi)
                # 更新P,Q
                P[uid] = v_pu
                Q[iid] = v_qi
                # 更新bu bi
                bu[uid] += self.alpha * (err - self.reg_bu * bu[uid])
                bi[iid] += self.alpha * (err - self.reg_bi * bi[iid])
        return P, Q, bu, bi

    def predict(self, uid, iid):
        # 如果uid 或者iid 不存在,返回平均数
        if uid not in self.user_ratings.index or iid not in self.item_ratings.index:
            return self.globalMean
        p_u = self.P[uid]
        q_i = self.Q[iid]
        return self.global_mean + self.bu[uid] + self.bi[iid] + np.dot(p_u, q_i)


if __name__ == '__main__':
    watch_path = 'E:/ml/recommand/ml-latest-small/ratings.csv'
    dtype = [("userId", np.int32), ("movieId", np.int32), ("rating", np.float32)]
    dataset = pd.read_csv(watch_path, usecols=range(3), dtype=dict(dtype))
    bsvd = BiasSvd(0.02, 0.01, 0.01, 0.01, 0.01, 10, 20)
    bsvd.fit(dataset)
    predict_rating = bsvd.predict(1, 1)
    print((predict_rating))