矩阵分解（学习笔记）

最新推荐文章于 2022-08-16 10:10:13 发布

UCaoo

最新推荐文章于 2022-08-16 10:10:13 发布

阅读量607

点赞数

分类专栏： AI 文章标签：机器学习

原文链接：https://blog.csdn.net/google19890102/article/details/51124556

版权

AI 专栏收录该内容

6 篇文章 0 订阅

订阅专栏

矩阵分解

推荐系统
矩阵分解原理
矩阵分解算法

矩阵分解原理

在这里插入图片描述

基于矩阵分解的推荐算法
实例：

在推荐系统中，最重要的数据是用户对商品的打分数据
在这里插入图片描述

矩阵中，描述了5个用户(U1,U2,U3,U4 ,U5)对4个物品(D1,D2,D3,D4)的评分(1-5分)， - 表示没有评分，现在目的是预测缺失的评分，然后按预测的分数高低，给用户进行推荐。
如何预测缺失的评分呢？对于缺失的评分，可以转化为基于机器学习的回归问题，也就是连续值的预测。

进行矩阵分解：

矩阵分解是指将一个矩阵分解成两个或者多个矩阵的乘积。对于上述的用户-商品矩阵(评分矩阵)，记为 $R_{m×n}$ 。可以将其分解成两个或者多个矩阵的乘积，假设分解成两个矩阵 $P_{m×k}$ 和 $Q_{k×n}$ ，我们要使得矩阵 $P_{m×k}$ 和 $Q_{k×n}$ 的乘积能够还原原始的矩阵 $R_{m×n}$ ：

$R_{m\times n}\approx P_{m\times k}\times Q_{k\times n}=\hat{R}_{m\times n}$

其中，矩阵 $P_{m×k}$ 表示的是 $m$ 个用户与 $k$ 个主题之间的关系，而矩阵 $Q_{k×n}$ 表示的是 $k$ 个主题与 $n$ 个商品之间的关系。

那么接下来的问题是如何求解矩阵 $P_{m×k}$ 和 $Q_{k×n}$ 的每一个元素，可以将这个问题转化成机器学习中的回归问题进行求解（梯度下降）。

通常情况下,隐因子数量k的选取要远远低于用户和商品的数量,大矩阵分解成两个小矩阵实际上是用户和商品在k维隐因子空间上的映射,这个方法其实是也是一种"降维"(DimensionReduction)过程,同时将用户和商品的表示转化为在这个k维空间上的分布位置,商品和用户的距离越接近表示用户越有可能喜欢这商品,表现在数值上则是各项隐因子符合程度的正负性越一致.

损失函数：

可以使用原始的评分矩阵 $R_{m×n}$ 与重新构建的评分矩阵 $\hat{R}_{m\times n}$ 之间的误差的平方作为损失函数，即:

$e_{i,j}^2=\left ( r_{i,j}-\hat{r}_{i,j} \right )^2=\left (r_{i,j}-\sum_{k=1}^{K}p_{i,k}q_{k,j} \right )^2$

目标是求解所有的非“-”项的损失之和的最小值：

$min\; loss= \sum_{r_{i,j}\neq -}e_{i,j}^2$

梯度下降法求解：

求解损失函数的负梯度：

$\frac{\partial }{\partial p_{i,k}}e_{i,j}^2=-2\left ( r_{i,j}-\sum_{k=1}^{K}p_{i,k}q_{k,j} \right )q_{k,j}=-2e_{i,j}q_{k,j}$

$\frac{\partial }{\partial q_{k,j}}e_{i,j}^2=-2\left ( r_{i,j}-\sum_{k=1}^{K}p_{i,k}q_{k,j} \right )p_{i,k}=-2e_{i,j}p_{i,k}$

根据负梯度的方向更新变量：
${p_{i,k}}'=p_{i,k}-\alpha \frac{\partial }{\partial p_{i,k}}e_{i,j}^2=p_{i,k}+2\alpha e_{i,j}q_{k,j}$
${q_{k,j}}'=q_{k,j}-\alpha \frac{\partial }{\partial q_{k,j}}e_{i,j}^2=q_{k,j}+2\alpha e_{i,j}p_{i,k}$
通过迭代，直到算法最终收敛。

加入正则项的损失函数:

通常在求解的过程中，为了能够有较好的泛化能力，会在损失函数中加入正则项，以对参数进行约束，加入L2L2正则的损失函数为：

$E_{i,j}^2=\left (r_{i,j}-\sum_{k=1}^{K}p_{i,k}q_{k,j} \right )^2+\frac{\beta }{2}\sum_{k=1}^{K}\left ( p_{i,k}^2+q_{k,j}^2 \right )$

利用梯度下降法的求解过程为：

求解损失函数的负梯度：

$\frac{\partial }{\partial p_{i,k}}E_{i,j}^2=-2\left ( r_{i,j}-\sum_{k=1}^{K}p_{i,k}q_{k,j} \right )q_{k,j}+\beta p_{i,k}=-2e_{i,j}q_{k,j}+\beta p_{i,k}$

$\frac{\partial }{\partial q_{k,j}}E_{i,j}^2=-2\left ( r_{i,j}-\sum_{k=1}^{K}p_{i,k}q_{k,j} \right )p_{i,k}+\beta q_{k,j}=-2e_{i,j}p_{i,k}+\beta q_{k,j}$

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

${p_{i,k}}'=p_{i,k}-\alpha \left ( \frac{\partial }{\partial p_{i,k}}e_{i,j}^2+\beta p_{i,k} \right )=p_{i,k}+\alpha \left ( 2e_{i,j}q_{k,j}-\beta p_{i,k} \right )$

${q_{k,j}}'=q_{k,j}-\alpha \left ( \frac{\partial }{\partial q_{k,j}}e_{i,j}^2+\beta q_{k,j} \right )=q_{k,j}+\alpha \left ( 2e_{i,j}p_{i,k}-\beta q_{k,j} \right )$
通过迭代，直到算法最终收敛。

利用上述的过程，我们可以得到矩阵 $P_{m×k}$ 和 $Q_{k×n}$ ，这样便可以为用户i对商品j进行打分：
$\sum_{k=1}^{K}p_{i,k}q_{k,j}$

矩阵分解算法

from numpy import *
from pylab import *
def load_data(path):
    f = open(path)
    data = []
    for line in f.readlines():
        arr = []
        lines = line.strip().split("\t")
        for x in lines:
            if x != "-":
                arr.append(float(x))
            else:
                arr.append(float(0))
        #print arr
        data.append(arr)
    #print data
    return data

def gradAscent(data, K):
    dataMat = mat(data)
    print(dataMat)
    m, n = shape(dataMat)
    p = mat(random.random((m, K)))
    q = mat(random.random((K, n)))

    alpha = 0.0002
    beta = 0.02
    maxCycles = 10000

    for step in xrange(maxCycles):
        for i in xrange(m):
            for j in xrange(n):
                if dataMat[i,j] > 0:
                    #print dataMat[i,j]
                    error = dataMat[i,j]
                    for k in xrange(K):
                        error = error - p[i,k]*q[k,j]
                    for k in xrange(K):
                        p[i,k] = p[i,k] + alpha * (2 * error * q[k,j] - beta * p[i,k])
                        q[k,j] = q[k,j] + alpha * (2 * error * p[i,k] - beta * q[k,j])

        loss = 0.0
        for i in xrange(m):
            for j in xrange(n):
                if dataMat[i,j] > 0:
                    error = 0.0
                    for k in xrange(K):
                        error = error + p[i,k]*q[k,j]
                    loss = (dataMat[i,j] - error) * (dataMat[i,j] - error)
                    for k in xrange(K):
                        loss = loss + beta * (p[i,k] * p[i,k] + q[k,j] * q[k,j]) / 2

        if loss < 0.001:
            break
        #print step
        if step % 1000 == 0:
            print(loss)

    return p, q


if __name__ == "__main__":
    dataMatrix = load_data("./data")

    p, q = gradAscent(dataMatrix, 5)
    '''
    p = mat(ones((4,10)))
    print p
    q = mat(ones((10,5)))
    '''
    result = p * q
    #print p
    #print q

    print(result)



data = []

f = open("result")
for line in f.readlines():
    lines = line.strip()
    data.append(lines)

n = len(data)
x = range(n)
plot(x, data, color='r',linewidth=3)
plt.title('Convergence curve')
plt.xlabel('generation')
plt.ylabel('loss')
show()