矩阵分解

阅读数: 10000次 2022-01-23

矩阵分解

Question

下面有几部电影以及不同的用户给他们的评分

	A	B	C	D
U1	5	3	0	1
U2	4	0	0	1
U2	1	1	0	5
U4	1	0	0	4
U5	0	1	5	4

A,B,C,D代表不同的电影。U代表用户，在这里电影的评分最高为5分，0代表该位用户没有看过这部电影，我们的目的就是通过矩阵分解预测该位用户对该电影的评分。

Talk about

我们如何用矩阵分解来解决问题呢，简单来说就是：我们把原始矩阵分解成两个矩阵，然后这两个矩阵的乘积的结果为我们所预测的结果，那么我们用什么来进行呢，在这里用梯度下降来解决，我们都知道要进行梯度下降，肯定要对其求导，然后再不断迭代，所以我们首先需要构造损失函数。

Loss Function

构造损失函数

以上面的评分为例来说明：使用原有的评分矩阵Rm×n与重新构建的评分矩阵R^m×n进行相减求的误差的平方作为损失函数，即为
$$
e_{ij}^2=(r_{ij}-r_{ij}*)^2=(r_{ij}-\sum_{i=1}^np_{ik}q_{kj})^2
$$

对损失函数求导

$$
\frac{\partial}{p_{ik}}e^2_{ij}=2(r_{ij}-\sum_{i=1}^np_{ik}q_{kj})(-q_{kj})=-2e_{ij}q_{kj}
$$

$$
\frac{\partial}{q_{kj}}e^2_{ij}=2(r_{ij}-\sum_{i=1}^np_{ik}q_{kj})(-p_{ik})=-2e_{ij}p_{ik}
$$

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

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

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

通过不断迭代，不断更新值,可以通过迭代次数和阈值作为限制条件,下面是对上面例子的代码

代码

from math import *
import numpy as np
import matplotlib.pyplot as plt
def matrix_factorization(R,P,Q,steps=5000,alpha=0.0002,beta=0.02): #steps：梯度下降次数；alpha：步长；beta：β。
    Q=Q.T                                       #新生成的Q的转置矩阵
    result=[]                                   #用于储存加入正则化后的损失函数求和后的值
    for step in range(steps):                   #梯度下降，steps迭代次数
        for i in range(len(R)):                 #len(R)代表矩阵的行数
            for j in range(len(R[i])):          #取每一行的列数
                    eij=R[i][j]-np.dot(P[i,:],Q[:,j])       #np.dot表示矩阵相乘,求得真实值与预测值之间的差
                    for k in range(K):
                      if R[i][j]>0:        #限制评分大于零
                        P[i][k]=P[i][k]+alpha*2*eij*Q[k][j]  #没加入正则化，并对损失函数求导，然后更新变量P
                        Q[k][j]=Q[k][j]+alpha*2*eij*P[i][k]  #没加入正则化，并对损失函数求导，然后更新变量Q
        eR=np.dot(P,Q)
        e=0                    #用来保存损失函数求和后的值
        for i in range(len(R)):#每一行循环
            for j in range(len(R[i])):#每一列循环
              if R[i][j]>0:
                    e=e+pow(R[i][j]-np.dot(P[i,:],Q[:,j]),2)      #损失函数求和
        result.append(e)
        if e<0.001:           #判断是否收敛，0.001为阈值
            break
    return P,Q.T,result

if __name__ == '__main__':   #主函数
    R=[                 #原始矩阵
        [5,3,0,1],
        [4,0,0,1],
        [1,1,0,5],
        [1,0,0,4],
        [0,1,5,4]
    ]
    R=np.array(R)

    #将原来的矩阵进行分解，分解为两个矩阵
    N=len(R)    #原矩阵R的行数
    M=len(R[0]) #原矩阵R的列数,在这里求列数和行数，是为了P和Q相乘后与原矩阵具有相同的行和列
    K=3
    P=np.random.rand(N,K) #随机生成一个 N行 K列的矩阵
    Q=np.random.rand(M,K) #随机生成一个 M行 K列的矩阵
    nP,nQ,result=matrix_factorization(R,P,Q)#nP=P，nQ=nQ.T,result=result
    print("输出原矩阵：")
    print(R)         #输出原矩阵
    R_MF=np.dot(nP,nQ.T)#矩阵的乘积
    print("输出新矩阵：")
    print(R_MF)      #输出新矩阵
    #画图
    plt.plot(range(len(result)),result)
    plt.xlabel("time")
    plt.ylabel("loss")
    plt.show()

代码结果

输出原矩阵：
[[5 3 0 1]
 [4 0 0 1]
 [1 1 0 5]
 [1 0 0 4]
 [0 1 5 4]]
输出新矩阵：
[[5.00452459 2.99057377 3.34415894 1.0000094 ]
 [3.99644395 2.12740953 3.02596381 0.9991391 ]
 [1.00818826 0.98214524 3.93019007 4.99980818]
 [0.99558104 0.61151817 3.4695008  3.99900839]
 [2.8523312  1.0204692  4.99359687 4.00306171]]

在结果中，从0到现在的评分，而现在的评分便是根据矩阵分解来预测的值，每次运行的结果都不会一样，大家可以自己在电脑上跑一遍。

Assignment

Question

	音乐A	音乐B	音乐C	音乐D
张三	2	1	0	0
李四	0	1	1	0
王五	0	0	1	1

用矩阵分解来解决问题，并且预测评分为0的该为用户的评分

Code

代码：

import random
from math import *
import numpy as np
import matplotlib.pyplot as plt

#原始矩阵
R=[
    [2,1,0,0],
    [0,1,1,0],
    [0,0,1,1],
    ]
#矩阵分解
i=len(R) #矩阵的行数
j=len(R[1]) #矩阵列数
K=4 #自定义
#初始化矩阵P,Q
P=np.random.rand(i,K)
Q=np.random.rand(j,K)

def matrix_factorization(R,P,Q,steps=5000,alpha=0.002,beta=0.02):
    Q=Q.T    #把矩阵Q进行转置
    result=[] #用来存放损失值
    for num in range(steps):  #循环次数
        for m in range(i):
            for n in range(j):
                emn=R[m][n]-np.dot(P[m,:],Q[:,n])   #求真实值与预测值之间的差
                for k in range(K):
                    if R[m][n]>0:
                        P[m][k]=P[m][k]+2*alpha*emn*Q[k][n]  #不断进行迭代
                        Q[k][n]=Q[k][n]+2*alpha*emn*P[m][k]
        er=np.dot(P,Q)
        errs=0
        for m in range(i):
            for n in range(j):
                if R[m][n]>0:
                    errs=errs+pow(R[m][n]-np.dot(P[m,:],Q[:,n]),2)
        result.append(errs)
        if e<0.01:
            break
    return P,Q,result


if __name__ == '__main__':   #主函数

    nP, nQ, result = matrix_factorization(R,P,Q)  # nP=P，nQ=nQ.T,result=result
    print("输出原矩阵：")
    print(R)  # 输出原矩阵
    PQ = np.dot(nP, nQ)  # 矩阵的乘积
    print("输出新矩阵：")
    print(PQ)  # 输出新矩阵

    # 画图
    plt.plot(range(len(result)), result)
    plt.xlabel("time")
    plt.ylabel("loss")
    plt.show()

运行结果：

输出原矩阵：
[[2, 1, 0, 0], [0, 1, 1, 0], [0, 0, 1, 1]]
输出新矩阵：
[[1.99999868 1.00000397 1.05918112 1.35555345]
 [2.02415177 0.99999573 1.00000269 1.60004216]
 [1.61464006 1.01358857 0.99999818 1.00000057]]