Latent-factor method

Latent-factor method

 上课所提到的电影推荐算法通过找到用户A的相似用户B进而向A推荐B喜欢的电影或找到A喜欢的电影C的相似电影来做推荐。而潜在因子方法是通过用户的潜在因子矩阵得知用户的电影偏好，通过电影的潜在因子矩阵得知电影的风格类型，两者相匹配得到用户喜欢的电影。
 用具体例子说明潜在因子矩阵：
 假设电影的类型分为恐怖，喜剧，科幻，用0~1范围内的数字表示用户对电影的喜欢程度或电影的符合程度，0表示不感兴趣或不符合，1表示非常喜欢或非常符合。那么用户A和B对各类型的喜欢程度可能如下：

	恐怖	喜剧	科幻
A	0.9	0.1	0.7
B	0	0.9	0.3

 可以看出用户A喜欢恐怖、科幻的电影，而B更喜欢喜剧电影。
 假设电影C、D分别为科幻恐怖电影和喜剧电影，那么它们的符合程度可能如下：

	恐怖	喜剧	科幻
C	0.8	0	0.8
D	0	0.9	0.1

 将用户表里的每一行视为一个向量${\mathbf{p}}_u$，电影表的每一行视为一个向量${\mathbf{q}}_i$，它们的内积${\mathbf{p}}_u^T{\mathbf{q}}_i$可以反映用户的喜欢程度。
 例如用户A对C的喜欢程度：${\mathbf{p}}_a^T{\mathbf{q}}_c=0.9\ast 0.8+0.7\ast 0.8=1.28$，A对D的喜欢程度：${\mathbf{p}}_a^T{\mathbf{q}}_d=0.1\ast 0.9+0.7\ast 0.1=0.16$，用户B对C的喜欢程度：${\mathbf{p}}_b^T{\mathbf{q}}_c=0.3\ast 0.8=0.24$，B对D的喜欢程度：${\mathbf{p}}_b^T{\mathbf{q}}_d=0.9\ast 0.9+0.3\ast 0.1=0.84$。可以看出A更喜欢C，B更喜欢D。推荐系统就能利用这些内积来进行推荐。潜在因子矩阵即这两张表的矩阵形式$\mathbf{P}$和$\mathbf{Q}$。
 实际中我们不能直接获得潜在因子，而是获得用户对电影的总评价。如：

	C	D
A	1.28	0.16
B	0.24	0.84

 其矩阵形式记作矩阵$\mathbf{R}$。而且这个表往往大且稀疏，因为用户很多，但用户不是常常都会对电影做出评价。潜在因子方法所做的就是将矩阵R分解为潜在因子矩阵P和Q，即$\mathbf{R}=\mathbf{PQ}$。
 首先定义R矩阵在(u,i)位置上的$r_{ui}$为用户u对电影i的感兴趣程度，而${\hat{r}}_{ui}$为预测，我们通过潜在因子做出预测：
$${\hat{r}}_{ui}={\mathbf{p}}_u^T{\mathbf{q}}_i=\sum _k^K{p}_{uk}{q}_{ki}$$
 ${\mathbf{p}}_u$和${\mathbf{q}}_i$为潜在因子矩阵P，Q的一行，$p_{uk}$表示用户u对电影分类k的喜欢程度，$q_{ki}$表示电影i对k分类的匹配程度，K为总类数。
 我们希望用户的评价$\mathbf{R}$和我们的预测$\hat{\mathbf{R}}$接近，可以通过最小化损失函数，损失函数L选择均方误差MSE：
$$\underset{P,Q}{\min }L=\sum _{(u,i)}(r_{ui}-{\mathbf{p}}_u^T{\mathbf{q}}_i{)}^2$$
 损失函数也可以加入正则化项防止过拟合，加入后如下：
$$L=\sum _{(u,i)}(r_{ui}-{\mathbf{p}}_u^T{\mathbf{q}}_i{)}^2+\lambda \sum _u||{\mathbf{p}}_u|{|}^2+\lambda \sum _i||{\mathbf{q}}_i|{|}^2$$

求解方法

交替最小二乘法

 由于矩阵P和Q都未知，都需要求解，所以我们可以在求解P时固定Q，转换成最小二乘法问题，反之求Q时固定P，交替执行来求解直至误差满足条件或到达迭代上限。
 具体过程如下：
 1.指定$\mathbf{Q}$初值${\mathbf{Q}}_0$，可以随机生成
 2.固定${\mathbf{Q}}_0$，求解${\mathbf{P}}_0$
 3.固定${\mathbf{P}}_0$，求解${\mathbf{Q}}_1$
 4.固定${\mathbf{Q}}_1$，求解${\mathbf{P}}_1$
 …（不断重复）
 5.满足误差需求或迭代上限，迭代结束。

 具体过程：
 固定Q，求解P时，$\underset{P,Q}{\min }L$可以转化为：
$$\underset{P}{\min }[\sum _{u,i}(r_{ui}-{\mathbf{p}}_u^T{\mathbf{q}}_i{)}^2]+\lambda \sum _u||{\mathbf{p}}_u|{|}^2=\sum _u\underset{P}{\min }[\sum _i(r_{ui}-{\mathbf{p}}_u^T{\mathbf{q}}_i{)}^2]+\lambda ||{\mathbf{p}}_u|{|}^2]$$
 令$l_u({\mathbf{p}}_u)=\sum _i(r_{ui}-{\mathbf{p}}_u^T{\mathbf{q}}_{\mathbf{i}}{)}^2+\lambda ||{\mathbf{p}}_u|{|}^2$
 问题转化为最小化$l_u({\mathbf{p}}_u)$
 求偏导得：
$$\frac{\partial l_u}{\partial {\mathbf{p}}_u}=2(\sum _i{\mathbf{p}}_u^T{\mathbf{q}}_i{\mathbf{q}}_i-\sum _i{r}_{ui}{\mathbf{q}}_i+\lambda {\mathbf{p}}_u)$$
 令偏导值为0，有：
$$(\sum _i{\mathbf{q}}_i{\mathbf{q}}_i^T+\lambda \mathbf{I}){\mathbf{p}}_u=\sum _i{r}_{ui}{\mathbf{q}}_i$$
$$(\mathbf{Q}{\mathbf{Q}}^T+\lambda \mathbf{I}){\mathbf{p}}_u=\mathbf{Q}{\mathbf{r}}_u$$
$${\mathbf{p}}_u=(\mathbf{Q}{\mathbf{Q}}^T+\lambda \mathbf{I}{)}^{-1}\mathbf{Q}{\mathbf{r}}_u$$
 求出每一行${\mathbf{p}}_u$就可以得到$\mathbf{P}$
 固定P则可以得到：
$${\mathbf{q}}_i=(\mathbf{P}{\mathbf{P}}^T+\lambda \mathbf{I}{)}^{-1}\mathbf{P}{\mathbf{r}}_i$$

梯度下降法

 也可以通过梯度下降法求解。使用梯度下降算法：
 1.求L的偏导
$$\frac{\partial L}{\partial p_{uk}}=-2(r_{ui}-\sum _{k=1}^K{p}_{uk}{q}_{ki})q_{ki}+2\lambda p_{uk}$$
$$\frac{\partial L}{\partial q_{ki}}=-2(r_{ui}-\sum _{k=1}^K{p}_{uk}{q}_{ki})p_{uk}+2\lambda p_{ki}$$
 转换成对向量求偏导
$$\frac{\partial L}{\partial {\mathbf{p}}_u}=\sum _{i}2({\mathbf{p}}_u^T{\mathbf{q}}_i-r_{ui}){\mathbf{q}}_i+2\lambda {\mathbf{p}}_u$$
 对${\mathbf{q}}_i$类似

 2.迭代更新
$${\mathbf{p}}_u={\mathbf{p}}_u-\alpha \frac{\partial L}{\partial {\mathbf{p}}_u}$$
 对${\mathbf{q}}_i$类似
 其中$\alpha$为学习率，$\lambda$为正则化系数。

代码实现

import numpy as np
import pandas as pd
 

# R：评分矩阵
# K：电影种类数
# epochs: 最大迭代次数
# alpha：学习率
# lamda：正则化系数
# P：用户潜在因子矩阵
# Q：电影潜在因子矩阵
# M：用户数
# N：电影数

def LFM( R, K=3, epochs=1000, alpha=0.0001, lamda=0.001 ):
#     初始化
    M = len(R)
    N = len(R[0])
    P = np.random.rand(M, K)
    Q = np.random.rand(K, N)
    
    for epoch in range(epochs):
        for u in range(M):
            for i in range(N):
                if R[u][i] > 0:
                    eui = np.dot( P[u,:], Q[:,i] ) - R[u][i]
                    for k in range(K):
                        P[u][k] = P[u][k] - alpha * ( 2 * eui * Q[k][i] + 2 * lamda * P[u][k] )
                        Q[k][i] = Q[k][i] - alpha * ( 2 * eui * P[u][k] + 2 * lamda * Q[k][i] )

        R_ = np.dot( P, Q )
        
        Loss = 0
        for u in range(M):
            for i in range(N):
                if R[u][i] > 0:
                    Loss += ( np.dot( P[u,:], Q[:,i] ) - R[u][i] ) ** 2
                    # 加上正则化项
                    for k in range(K):
                        Loss += lamda * ( P[u][k] ** 2 + Q[k][i] ** 2 )
        if Loss < 0.0001:
            break
        
    return P, Q.T, Loss

测试：
使用了上课的例子

R=[[5,4,4,0,5],[0,3,5,3,4],[5,2,0,2,3],
   [0,2,3,1,2],[4,0,5,4,5],[5,3,0,3,5],
   [3,2,3,2,0],[5,3,4,0,5],[4,2,5,4,0],
   [5,0,5,3,4]]
R = np.array(R)

K = 5
epochs = 5000
alpha = 0.0003
lamda = 0.001
P, Q, Loss = LFM(R, K, epochs, alpha, lamda)
 
print(P)
print(Q)
print(Loss)
 
R_ = P.dot(Q.T)
 
print(R)
print(R_)

结果如下：