矩阵分解的推荐算法

一、简介

推荐算法（recommendation algorithm）就是利用用户的一些行为，通过一些数学算法，推测出用户可能喜欢的东西。目前应用推荐算法比较好的地方主要是网络，其中淘宝、拼多多和京东等做的都非常好。
 推荐算法主要分为6种：
 1.基于内容的推荐(Content-Based Recommendation)
 2.基于协同过滤的推荐(Collaborative Filtering Recommendation)
 3.基于关联规则的推荐(Association Rule-Based Recommendation)
 4.基于效用的推荐(Utility-Based Recommendation)
 5.基于知识的推荐(Knowledge-Based Recommendation)
 6.组合推荐(Hybrid Recommendation)
 详细了解可参考：推荐算法百度百科

我们现在要解决的问题是对未评价的商品进行评分的预测，如下图所示：

 其中，$U_1、U_2、U_3、U_4、U_5$代表用户，$D_1、D_2、D_3、D_4$代表商品。可以看到有的商品用户没有给出评价，我们需要做的事情就是通过推荐算法，将未评价的分数猜测出来。

二、算法原理

1.定义类似于上图的评分矩阵R。
 R矩阵维度为$N\ast M$（$N$行$M$列的矩阵），我们可以将$R$分解为$P$矩阵和$Q$矩阵，其中P矩阵维度为$N\ast K$，$Q$矩阵维度为$M\ast K$（$Q$矩阵需要转置一下），于是有：
$$R\approx \hat{R}=P\ast Q^T$$
 对于$P$，$Q$矩阵的解释，直观上，$P$矩阵是$N$个用户对$K$个主题的关系，$Q$矩阵是$K$个主题跟$M$个物品的关系，至于$K$个主题具体是什么，在算法里面$K$是一个参数，需要调节的，通常$10\sim 100$之间。

2.对于 $\hat{R}$ 矩阵：
$${\hat{r}}_{ij}=p_i^T{q}_j=\sum _{k=1}^K{p}_{ik}{q}_{kj}$$
$\hat{R}$ 与 $R$ 的维度相同，其中 $\widehat{r_{ij}}$ 是 $\hat{R}$ 第 $i$ 行第 $j$ 列的元素值。

3.求损失函数并更新变量：
使用原始的评分矩阵$R$与重新构建的评分矩阵$\hat{R}$之间的误差的平方作为损失函数，即：
$$e_{ij}^2=(r_{ij}-{\hat{r}}_{ij}{)}^2=(r_{ij}-\sum _{k=1}^K{p}_{ik}{q}_{kj}{)}^2$$
通过梯度下降法，更新变量：

• 求导：

$$\frac{\partial }{{\partial }_{pik}}{e}_{ij}^2=-2(r_{ij}-\sum _{k=1}^K{p}_{ik}{q}_{kj})q_{kj}=-2e_{ij}{q}_{kj}$$

$$\frac{\partial }{{\partial }_{qkj}}{e}_{ij}^2=-2(r_{ij}-\sum _{k=1}^K{p}_{ik}{q}_{kj})p_{ik}=-2e_{ij}{p}_{ik}$$

• 根据负梯度的方向更新变量：

$$p_{ik}^{\prime }=p_{ik}-\alpha \frac{\partial }{\partial p_{ik}}{e}_{ij}^2=p_{ik}+2\alpha e_{ij}{q}_{kj}$$

$$q_{kj}^{\prime }=q_{kj}-\alpha \frac{\partial }{\partial q_{kj}}{e}_{ij}^2=q_{kj}+2\alpha e_{ij}{p}_{ik}$$

4.在损失函数中加入正则化惩罚项：
 通常在求解的过程中，为了能够有较好的泛化能力，会在损失函数中加入正则项，以对参数进行约束。加入正则项后的计算过程如下：
$$E_{ij}^2=(r_{ij}-\sum _{k=1}^K{p}_{ik}{q}_{kj}{)}^2+\frac{\beta }{2}\sum _{k=1}^K(p_{ik}^2+q_{kj}^2)$$
通过梯度下降法，更新变量：

• 求导：

$$\frac{\partial }{\partial p_{ik}}{E}_{ij}^2=-2(r_{ij}-\sum _{k=1}^K{p}_{ik}{q}_{kj})q_{kj}+\beta p_{ik}=-2e_{ij}{q}_{kj}+\beta p_{ik}$$

$$\frac{\partial }{\partial q_{kj}}{E}_{ij}^2=-2(r_{ij}-\sum _{k=1}^K{p}_{ik}{q}_{kj})p_{ik}+\beta q_{kj}=-2e_{ij}{p}_{ik}+\beta q_{kj}$$

• 根据负梯度的方向更新变量：

$$p_{ik}^{\prime }=p_{ik}-\alpha (\frac{\partial }{\partial p_{ik}}{e}_{ij}^2+\beta p_{ik})=p_{ik}+\alpha (2e_{ij}{q}_{kj}-\beta p_{ik})$$

$$q_{kj}^{\prime }=q_{kj}-\alpha (\frac{\partial }{\partial q_{kj}}{e}_{ij}^2+\beta q_{kj})=q_{kj}+\alpha (2e_{ij}{p}_{ik}-\beta q_{kj})$$

5.算法终止：
每次更新完 $\hat{R}$ 后，计算一次$loss$值，若$loss$值非常小或者到达最大迭代次数，结束算法。于是就得到了我们最终的预测矩阵 $\hat{R}$。

三、算法python实现

import numpy as np
import math
import matplotlib.pyplot as plt


R = np.array([[5, 3, 0, 1], # 用户商品评分，0代表未参与评分
              [4, 0, 0, 1],
              [1, 1, 0, 5],
              [1, 0, 0, 4],
              [0, 1, 5, 4]])
N = R.shape[0]  # 用户数
M = R.shape[1]  # 商品数
K = 5           # 主题数
# 定义P和Q矩阵
P = np.random.rand(N, K)    # 初始化P和 Q
Q = np.random.rand(K, M)

def getLoss(R, P, Q, N, M, K, beta):    # 损失函数
    loss = 0.
    for i in range(N):
        for j in range(M):
            if (R[i][j] == 0):
                continue
            sum = sum2 = 0
            for k in range(K):
                sum += P[i][k] * Q[k][j]
                sum2 += P[i][k] * P[i][k] + Q[k][j] * Q[k][j]
            loss += math.pow(R[i][j] - sum, 2) + beta * sum2 / 2
    return loss
def matrix_composition(R, P, Q, N, M, K, alpha = 0.0002, beta = 0.002): # 矩阵分解
    loss_list = []
    for step in range(5000):    # 规定梯度下降次数
        loss = getLoss(R, P, Q, N, M, K, beta)
        if(loss < 0.001):   # 损失值可以忽略不计
            break
        if(step % 20 == 0): # 每20次记录一下loss变化
            plt.scatter(step, loss)
        # if(step % 1000 == 0):   # 调试
        #     print(loss)
        # update
        for i in range(N):
            for j in range(M):
                if(R[i][j] == 0):   # 只看有评分的
                    continue
                sum = 0
                for k in range(K):
                    sum += P[i][k] * Q[k][j]
                for k in range(K):  # 更新变量
                    P[i][k] += alpha * (2 * (R[i][j] - sum) * Q[k][j] - beta * P[i][k])
                    Q[k][j] += alpha * (2 * (R[i][j] - sum) * P[i][k] - beta * Q[k][j])
    return P, Q



if __name__ == '__main__':
    print('评分矩阵')
    print(R)
    P, Q = matrix_composition(R, P, Q, N, M, K)
    print('P和Q矩阵如下')
    print(P)
    print()
    print(Q)
    print()
    print(np.dot(P, Q)) # 矩阵计算
    plt.show()