精华内容
下载资源
问答
  • 推荐基础算法之矩阵分解MF矩阵分解是推荐系统中运用最广泛的协同过滤模型。顾名思义,其就是将一个矩阵分解为两个或多个矩阵,使得分解的矩阵能够通过相乘得到原始矩阵。在推荐系统中,常常根据用户对物品的评分得到...

    1e624a48fde007738ff7fe2bfd78cd41.png

    推荐基础算法之矩阵分解MF

    矩阵分解是推荐系统中运用最广泛的协同过滤模型。顾名思义,其就是将一个矩阵分解为两个或多个矩阵,使得分解的矩阵能够通过相乘得到原始矩阵。在推荐系统中,常常根据用户对物品的评分得到一个用户-物品评分矩阵R(如下表),但在这个矩阵在实际情况中是非常稀疏的,也就是在用户-物品的评分矩阵中只存在少部分用户对少部分物品进行评分的行为。

    d42143e72e7674ef30e046352d7f83f7.png

    上述表中,行代表用户U1,U2等,列代表物品D1,D2等。矩阵中的值

    代表用户
    对物品
    的打分,-表示用户
    未对物品
    打分。因此推荐系统中有一类问题就是要对未打分的物品进行评分预测。

    Basic Matrix Factorization(Funk-SVD)

    矩阵分解的目标就是希望通过现有稀疏的评分矩阵来预测用户对未打分物品的评分行为。在这里主要采用SVD(Singular Value Decomposition,奇异值分解)分解。传统的SVD方法主要是对稠密矩阵进行分解,对推荐系统中的User-Item评分矩阵来说会造成两个困难:

    • 1.评分矩阵本身比较稀疏,传统SVD首先需要填充评分矩阵,而如果一旦填充使其会变成一个稠密矩阵,这样不但增加了存储空间还增大了算法的复杂度,这在实际系统中是不可能被接收的
    • 2.简单粗暴的填充会导致数据失真

    上述问题导致了传统的SVD矩阵分解效果并不是很好。因此Simon Funk在博客上公开提出了一种Funk-SVD分解(这个也是被Yehuda Koren在Netflix Prize上用到,并称为隐语义模型(Latent Factor Model))。Funk-SVD的基本思想就是:既然评价指标是均方根误差(Root Mean Squared Error, RMSE),那么可以直接通过训练集中的观察值利用最小化RMSE学习用户特征矩阵P和物品特征矩阵Q。为方便表示,用U表示用户的集合,D表示物品的集合,R表示用户评分矩阵。通过这种方法用户和物品可以被映射到一个K维(K可以自己设置)的潜在特征空间。通过挖掘用户的潜在特征矩阵P(|U|xK维)和物品潜在特征矩阵Q(|D|xK维)来估计评分。即通过下式来得到评分矩阵:

    因此利用上述公式,可以计算出用户u对物品i的估计评分

    为:

    其中

    表示用户u的K维潜在特征,表达用户的内部特性;
    表示物品i的K维潜在特征,表达物品的内部特性。

    对于每个用户评分

    , 使用FunkSVD进行矩阵分解,对应的估计评分为
    ,采用均方差做损失函数为
    ,我们的期望就是使均方差误差尽可能的小,考虑到所有的用户和物品组合,我们的优化目标函数J(p,q)为:

    其中,M表示已有评分记录的(u,i)对。为了最小化上面的损失函数,我们可以利用随机梯度下降来优化。随机梯度下降的核心主要包括两个步骤 :求解损失函数的负梯度、根据负梯度的方向更新变量。

    1.求解损失函数的负梯度

    2.根据负梯度变化更新变量

    上式中

    是步长(learning rate)。通过迭代,直到上述均方误差收敛到最小值。最终可以得到矩阵
    ,然后对评分矩阵中的空白的评分通过
    来计算预测评分。

    Regularized Matrix Factorization

    在实际应用中,为了防止上述的求解结果出现过拟合的情况,需要加入一个

    的正则化项。因此修正目标函数J(p,q)为:

    其中

    是正则化参数,是用来控制用户和物品特征空间维数。加入正则化项后,仍然采用随机梯度下降来优化目标函数。

    1.求解损失函数的负梯度

    2.根据负梯度变化更新变量

    上式中

    是步长(learning rate)。同样最终得到矩阵
    ,然后对评分矩阵中的空白的评分通过
    来计算预测评分。

    BiasSVD Matrix Factorization

    BiasSVD矩阵分解主要是在上述正则化上的改进,即是在正则化矩阵上加入偏置约束。因为上述的矩阵分解主要是通过学习用户和物品的特征向量来进行评分预测,然而在实际的情况下,不是每个用户的评分习惯、每个商品的流行程度都是一样的。评分系统有一些和用户物品无关的因素,其中把用户有一些与物品无关的评分因素,称为用户偏置。把物品有一些与用户无关的评分因素,称为物品偏置。

    例如,对某些用户来讲,他的评分普遍偏高,而对另一些用户来讲,他的评分普遍偏低。假设他们对同一物品有相同的评分,但实际上对这个物品的喜好程度是不一样的。同样,对于物品来讲,受到大家欢迎的物品评分普遍高,而一些烂物品得到的评分不可能高。这些都是独立于用户或物品的因素,而与用户对物品的偏好无关。因此上述的偏置可表达如下:

    其中

    表示的是评分系统的平均分,
    表示的是用户u的偏置,
    表示的是物品i的偏置。

    因此观测到的评分应该由四部分组成:评分系统平均分

    、用户偏置
    ,物品偏置
    ,用户物品的喜好信息
    。即:

    , 加了偏置以后的目标函数J(p,q)如下:

    同样采用SGD来进行优化。其过程如下:

    1.求解损失函数的负梯度

    2.根据负梯度变化更新变量

    上式中

    是步长(learning rate)。同样最终得到矩阵
    ,然后对评分矩阵中的空白的评分通过
    来计算预测评分。由于带偏置的正则化矩阵分解考虑了额外的因素,因此在一些场景中会表现比较优异。

    参考文献

    Koren Y. Factorization meets the neighborhood: a multifaceted collaborative filtering model

    Koren Y, Bell R, Volinsky C. Matrix factorization techniques for recommender systems

    Funk-SVD

    参考博客

    矩阵分解在协同过滤推荐算法中的应用

    展开全文
  • 推荐系统入门(三):矩阵分解MF&因子分解机FM(附代码) 目录推荐系统入门(三):矩阵分解MF&因子分解机FM(附代码)一、 矩阵分解MF1. 隐含语义分析技术1.1 隐语义模型1.2 矩阵分解算法1.3 矩阵分解算法...

    推荐系统入门(三):矩阵分解MF&因子分解机FM(附代码)


    相关系列笔记:
    推荐系统入门(一):概述
    推荐系统入门(二):协同过滤(附代码)
    推荐系统入门(三):矩阵分解MF&因子分解机FM(附代码)
    推荐系统入门(四):Wide&Deep(附代码)
    推荐系统入门(五):GBDT+LR(附代码)
    推荐系统入门(六):新闻推荐实践1(附代码)
    推荐系统入门(七):新闻推荐实践2(附代码)
    推荐系统入门(八):新闻推荐实践3(附代码)
    推荐系统入门(九):新闻推荐实践4(附代码)
    推荐系统入门(十):新闻推荐实践5(附代码)

    一、 矩阵分解MF

      矩阵分解(Matrix Factorization,MF)技术实际上就是把用户-项目评分矩阵分解为若干个部分的组合,它在 Netfilx公司举办的推荐系统大赛上得到了广泛的应用,基于矩阵分解的推荐算法本质上是一种基于模型的协同过滤推荐算法
      基于矩阵分解的推荐算法,实现简单,预测准确度高,扩展性强,在一定程度上缓解了数据的稀疏性问题,但可解释性差

    1. 隐含语义分析技术

      随着用户和项目数量的急剧增长,用户和项目之间评分矩阵的维度也在在急剧增加。而由此带来的问题是计算用户与用户、项目与项目之间相似度矩阵的速度越来越慢,计算问题成为推荐系统的瓶颈。此外,随着评分矩阵越来越稀疏,推荐精度也会受到严重的影响。

      对推荐系统研究过程中有很多人提出给用户或项目进行分类,但是根据传统的推荐算法很难真正发掘出用户用户潜在的兴趣度。为了解决这个问题研究人员提出从数据出发,自动找出项目的分类信息和用户的兴趣度信息。因此,隐含语义分析技术(Latent Variable Analysis) 就出现了。

      隐语义模型(Latent Factor Model,LFM) 这个概念是由Netflix Prize冠军Koren在2006年提出的。隐语义模型使用一种替代的法则来发现潜在的主题或分类。隐含语义分析技术从诞生至今产生了很多著名的模型和算法。其中和该项技术相关且耳熟能详的名词有隐含主题模型(latent topic model)24、矩阵分解(matrix factorization)、pLSA、LDA 等。

      协同过滤算法的特点就是完全没有利用到物品本身或者是用户自身的属性,仅仅利用了用户与物品的交互信息就可以实现推荐,是一个可解释性很强,非常直观的模型,但是也存在一些问题, 第一个就是处理稀疏矩阵的能力比较弱,所以为了使得协同过滤更好处理稀疏矩阵问题, 增强泛化能力, 从协同过滤中衍生出矩阵分解模型或者叫隐语义模型, 两者差不多说的一个意思,就是在协同过滤共现矩阵的基础上, 使用更稠密的隐向量表示用户和物品,挖掘用户和物品的隐含兴趣和隐含特征,在一定程度上弥补协同过滤模型处理稀疏矩阵能力不足的问题

    1.1 隐语义模型

      隐语义模型最早在文本领域被提出,用于找到文本的隐含语义。在2006年, 被用于推荐中, 它的核心思想是通过隐含特征(latent factor)联系用户兴趣和物品(item), 基于用户的行为找出潜在的主题和分类, 然后对item进行自动聚类,划分到不同类别/主题(用户的兴趣)

      这么说可能有点抽象,所以下面拿**项亮老师《推荐系统实践》**里面的那个例子看一下:

      如果我们知道了用户A和用户B两个用户在豆瓣的读书列表, 从他们的阅读列表可以看出,用户A的兴趣涉及侦探小说、科普图书以及一些计算机技术书, 而用户B的兴趣比较集中在数学和机器学习方面。 那么如何给A和B推荐图书呢?

      先说说协同过滤算法, 这样好对比不同:

    • 对于UserCF,首先需要找到和他们看了同样书的其他用户(兴趣相似的用户),然后给他们推荐那些用户喜欢的其他书。
    • 对于ItemCF,需要给他们推荐和他们已经看的书相似的书,比如作者B看了很多关于数据挖掘的书,可以给他推荐机器学习或者模式识别方面的书。

      而如果是隐语义模型的话, 它会先通过一些角度把用户兴趣和这些书归一下类, 当来了用户之后, 首先得到他的兴趣分类, 然后从这个分类中挑选他可能喜欢的书籍。

      这里就看到了隐语义模型和协同过滤的不同, 这里说的角度其实就是这个隐含特征, 比如书籍的话它的内容、作者、年份、主题等都可以算隐含特征,如果这个例子还不是很清晰的话,那么下面再举个更为具体的例子,看看是如何通过隐含特征来划分开用户兴趣和物品的。但是在这之前,相信通过上面这个例子,我们已经隐隐约约感受到了协同过滤和隐语义模型的区别了,下面放上王喆老师《深度学习推荐系统》 的一个原理图作为对比,区别简直一目了然:

    在这里插入图片描述
      我们下面拿一个音乐评分的例子来具体看一下隐特征矩阵的含义。

      假设每个用户都有自己的听歌偏好, 比如A喜欢带有小清新的, 吉他伴奏的, 王菲的歌曲,如果一首歌正好是王菲唱的, 并且是吉他伴奏的小清新, 那么就可以将这首歌推荐给这个用户。 也就是说是小清新, 吉他伴奏, 王菲这些元素连接起了用户和歌曲。 当然每个用户对不同的元素偏好不同, 每首歌包含的元素也不一样, 所以我们就希望找到下面的两个矩阵

      1)潜在因子—— 用户矩阵Q
      这个矩阵表示不同用户对于不同元素的偏好程度, 1代表很喜欢, 0代表不喜欢, 比如下面这样:

    在这里插入图片描述
      2)潜在因子——音乐矩阵P
      表示每种音乐含有各种元素的成分,比如下表中,音乐A是一个偏小清新的音乐, 含有小清新的Latent Factor的成分是0.9,重口味的成分是0.1,优雅成分0.2…

    在这里插入图片描述

      利用上面的这两个矩阵, 我们就能得出张三对音乐A的喜欢程度

      张三对小清新的偏好 * 音乐A含有小清新的成分 + 张三对重口味的偏好 * 音乐A含有重口味的成分 + 张三对优雅的偏好 * 音乐A含有优雅的成分…,

      下面是对应的两个隐向量

    在这里插入图片描述
      根据隐向量其实就可以得到张三对音乐A的打分,即:

      0.6∗0.9+0.8∗0.1+0.1∗0.2+0.1∗0.4+0.7∗0=0.69

      按照这个计算方式, 每个用户对每首歌其实都可以得到这样的分数,最后就得到了我们的评分矩阵

    在这里插入图片描述
      这里的红色表示用户没有打分,我们通过隐向量计算得到的。

      上面例子中的小清晰、 重口味、 优雅这些就可以看做是隐含特征, 而通过这个隐含特征就可以把用户的兴趣和音乐的进行一个分类,其实就是找到了每个用户每个音乐的一个隐向量表达形式(embedding的原理其实也是这样,那里是找到每个词的隐向量表达),这个隐向量就可以反映出用户的兴趣和物品的风格,并能将相似的物品推荐给相似的用户等。有没有感觉到是把协同过滤算法进行了一种延伸,把用户的相似性和物品的相似性通过了一个叫做隐向量的方式进行表达

      但是,真实的情况下我们其实是没有上面那两个矩阵的,音乐那么多,用户那么多, 我们没有办法去找一些隐特征去表示出这些东西,另外一个问题就是即使能表示也不一定准,对于每个用户或者每个物品的风格,我们每个人都有不同的看法。所以事实上,我们有的只有用户的评分矩阵,也就是最后的结果,并且一般这种矩阵长这样:

    在这里插入图片描述
      这种矩阵非常的稀疏,如果直接基于用户相似性或者物品相似性去填充这个矩阵是不太容易的, 并且很容易出现长尾问题, 所以矩阵分解就可以比较容易的解决这个问题。

      矩阵分解模型其实就是在想办法基于这个评分矩阵去找到上面例子中的那两个矩阵, 也就是用户兴趣和物品的隐向量表达, 然后就把这个评分矩阵分解成Q和P两个矩阵乘积的形式, 这时候就可以基于这两个矩阵去预测某个用户对某个物品的评分了。 然后基于这个评分去进行推荐。这就是矩阵分解算法的原理

    1.2 矩阵分解算法

      在矩阵分解的算法框架下, 我们就可以通过分解协同过滤的共现矩阵来得到用户和物品的隐向量, 就是上面的用户矩阵Q和物品矩阵P,这也是“矩阵分解”名字的由来。

    在这里插入图片描述
      矩阵分解算法将 m×n 维的共享矩阵 R 分解成 m×k 维的用户矩阵 U 和 k×n 维的物品矩阵 V 相乘的形式。其中 m 是用户数量,n 是物品数量,k 是隐向量维度,也就是隐含特征个数,只不过这里的隐含特征变得不可解释了,即我们不知道具体含义了,要模型自己去学。k 的大小决定了隐向量表达能力的强弱,k 越大,表达信息就越强,理解起来就是把用户的兴趣和物品的分类划分的越具体。

      那么如果有了用户矩阵和物品矩阵的话,我们就知道了如果想计算用户 u 对物品 i 的评分, 只需要

    在这里插入图片描述
      这里的 pu 就是用户 u 的隐向量, 就类似与上面的张三向量,注意这是列向量, qi 是物品 i 的隐向量,就类似于上面的音乐A向量, 这个也是列向量,所以才用了 pTuqi 得到了一个数,也就是用户的最终评分, 计算过程其实和上面例子中一样。这里的 pu,k 和 qi,k 是模型的参数, 也正是我们想办法要计算的,pu,k 度量的是用户 u 的兴趣和第 k 个隐类的关系,而 qi,k 度量了第 k 个隐类和物品 i 之间的关系。

    1.3 矩阵分解算法求解

      谈到矩阵分解,最常用的方法是特征值分解(EVD)或者奇异值分解(SVD),但是这两种方式在这里不适用。

      首先是EVD,它要求分解的矩阵是方阵,显然用户-物品矩阵不满足这个要求,而传统的SVD分解,会要求原始矩阵是稠密的,而我们这里的这种矩阵一般情况下是非常稀疏的,如果想用奇异值分解,就必须对缺失的元素进行填充,而一旦补全,空间复杂度就会非常高,且补的不一定对。然后就是SVD分解计算复杂度非常高,而我们的用户-物品矩阵非常大,所以基本上无法使用。

    2. Funk-SVD算法

      2006年的Netflix Prize之后, Simon Funk公布了一个矩阵分解算法叫做Funk-SVD, 后来被Netflix Prize的冠军Koren称为Latent Factor Model ( LFM )。 Funk-SVD的思想很简单: 把求解上面两个矩阵的参数问题转换成一个最优化问题, 可以通过训练集里面的观察值利用最小化来学习用户矩阵和物品矩阵

      我们上面已经知道了,如果有了用户矩阵和物品矩阵的话,我们就知道了如果想计算用户 u 对物品i的评分,只需要

    在这里插入图片描述

      而现在,我们有真实的 ru,i, 但是没有pTuqi, 那么我们可以初始化一个啊,随机初始化一个用户矩阵 U 和一个物品矩阵 V ,然后不就有pTuqi了?当然你说,随机初始化的肯定不准啊,但是,有了 pTuqi之后,我们就可以计算一个猜测的 ^rui , 即

    在这里插入图片描述
      这时候,肯定是不准,那么这个猜测的和真实值之间就会有一个误差

    在这里插入图片描述
      有了误差,我们就可以计算出总的误差平方和

    在这里插入图片描述
      有了损失,我们就可以想办法进行训练,把SSE降到最小,那么我们的两个矩阵参数就可以算出来。所以就把这个问题转成了最优化的的问题,而我们的目标函数就是:

    在这里插入图片描述
      这里的 K 表示所有用户评分样本的集合。

      有了目标函数,那么我们就可以使用梯度下降算法来降低损失。那么我们需要对目标函数求偏导,得到梯度。我们的目标函数如果是上面的SSE,我们下面来推导一下最后的导数:

    在这里插入图片描述

      首先我们求SSE在 pu,k (也就是Q矩阵的第 u 行 k 列)的梯度:

    在这里插入图片描述
      然后求SSE在 qk,i 处(也就是V矩阵的第 k 行 i 列)的梯度:

    在这里插入图片描述
      为了让公式更为简单, 把前面的2给他越掉, 即可以令SSE等于:

    在这里插入图片描述
      这时候, 梯度就没有前面的系数了,有了梯度,接下来我们就可以用梯度下降算法更新梯度了:

    在这里插入图片描述
      这里的 η 是学习率,控制步长用的,但上面这个有个问题就是当参数很多的时候, 就是两个矩阵很大的时候,往往容易陷入过拟合的困境,这时候,就需要在目标函数上面加上正则化的损失,就变成了RSVD,关于RSVD的详细内容,可以参考下面给出的链接,由于篇幅原因,这里不再过多的赘述。

      但在实际中,单纯的 也是不够的,还要考虑其他的一些因素,比如一个评分系统,有些固有的属性和用户物品无关,而用户也有些属性和物品无关,物品也有些属性和用户无关。因此, Netfix Prize中提出了另一种LFM,在原来的基础上加了偏置项, 来消除用户和物品打分的偏差,即预测公式如下:

    在这里插入图片描述
      这个预测公式加入了3项偏置 μ,bu,bi , 作用如下:

    • μ : 训练集中所有记录的评分的全局平均数。在不同网站中,因为网站定位和销售物品不同,网站的整体评分分布也会显示差异。比如有的网站中用户就喜欢打高分,有的网站中用户就喜欢打低分。而全局平均数可以表示网站本身对用户评分的影响。
    • bu : 用户偏差系数,可以使用用户 u 给出的所有评分的均值,也可以当做训练参数。这一项表示了用户的评分习惯中和物品没有关系的那种因素。比如有些用户比较苛刻,对什么东西要求很高,那么他评分就会偏低,而有些用户比较宽容,对什么东西都觉得不错,那么评分就偏高
    • bi : 物品偏差系数, 可以使用物品 i 收到的所有评分的均值, 也可以当做训练参数。 这一项表示了物品接受的评分中和用户没有关系的因素。 比如有些物品本身质量就很高, 因此获得的评分相对比较高, 有的物品本身质量很差, 因此获得的评分相对较低。

      加了用户和物品的打分偏差之后, 矩阵分解得到的隐向量更能反映不同用户对不同物品的“真实”态度差异, 也就更容易捕捉评价数据中有价值的信息, 从而避免推荐结果有偏。 注意此时的SSE会发生变化:

    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述
      此时如果把 bu 和 bi 当做训练参数的话, 那么它俩的梯度是:

    在这里插入图片描述
      更新公式为:

    在这里插入图片描述
      而对于 pu,k 和 pk,i , 导数没有变化, 更新公式也没有变化。

    3. Bias SVD算法

      Bias SVD算法是在 LFM的预测评分公式中加入基准预测评分,从而组成的一种新算法。该算法是考虑到在推荐系统应用中,用户(项目)的某些属性与项目(用户)是无关的,同时,也需要考虑该推荐系统整体的一个评分水平,将这些影响因子考虑进去后,可得基准预测评分的公式为:

    在这里插入图片描述
      其中,u代表的是全局评分的平均值,表明全局评分会对预测评分产生一定的作用; bu是用户u的偏置向量,代表用户的属性因子,例如有的用户擅长打高分,有的用户则比较追求完美,打的分都比较低;bi是项目i的偏置向量,代表项目的属性因子,例如有的项目本身很优秀,则不管什么用户给的评分都相对高,但是也有的项目的质量本身就十分的劣质,那么用户就会给出很低的评分。

      将基准预测信息加入隐语义模型的预测模型后,得到 Bias SVD算法预测模型。其预测公式如下式所示:

    在这里插入图片描述
      对该公式进行求解的过程,同隐语义模型相同,首先需要最小化损失函数,该算法的损失函数为:

    在这里插入图片描述
      需要求解的参数有puf 、qif、bu和bi,故采用梯度下降法时,需要对这四个参数求偏导数,即:

    在这里插入图片描述
      从上面的公式可以得到puf 、qif、bu和bi的最快下降递推公式为:

    在这里插入图片描述
      其中,α为puf、qif、bu和bi的学习率。

    4. 编程实现

      我们这里用代码实现一下上面的算法来预测上一篇文章里面的那个预测Alice对物品5的评分, 看看矩阵分解到底是怎么进行预测或者是推荐的。 我把之前的例子拿过来:

    在这里插入图片描述
      任务就是根据这个评分矩阵, 猜测Alice对物品5的打分。

      在实现SVD之前, 先来回忆一下ItemCF和UserCF对于这个问题的做法, 首先ItemCF的做法,根据已有的用户打分计算物品之间的相似度,得到物品的相似度矩阵, 根据这个相似度矩阵,选择出前K个与物品5最相似的物品,然后基于Alice对这K个物品的得分,猜测Alice对物品5的得分,有一个加权的计算公式。 UserCF的做法是根据用户对其他物品的打分,计算用户之间的相似度,选择出与Alice最相近的K个用户, 然后基于那K个用户对物品5的打分计算出Alice对物品5的打分。但是,这两种方式有个问题, 就是如果矩阵非常稀疏的话,当然这个例子是个特例,一般矩阵都是非常稀疏的, 那么预测效果就不好,因为两个相似用户对同一物品打分的概率以及Alice同时对两个相似物品打分的概率可能都比较小。另外,这两种方法显然没有考虑到全局的物品或者用户,只是基于了最相似的例子,很可能有偏。

      那么SVD在解决这个问题上是这么做的: 1. 首先,它会先初始化用户矩阵P和物品矩阵Q, P的维度是[users_num, F], Q的维度是[item_nums, F],这个F是隐向量的维度。 也就是把通过隐向量的方式把用户的兴趣和F的特点关联了起来。初始化这两个矩阵的方式很多, 但根据经验, 随机数需要和1/sqrt(F)成正比下面代码中会发现。 2. 有了两个矩阵之后,我就可以根据用户已经打分的数据去更新参数,这就是训练模型的过程,方法很简单,就是遍历用户,对于每个用户,遍历它打分的物品,这样就拿到了该用户和物品的隐向量, 然后两者相乘加上偏置就是预测的评分, 这时候与真实评分有个差距, 根据上面的梯度下降就可以进行参数的更新

      这样训练完之后,我们就可以得到用户Alice和物品5的隐向量,根据这个就可以预测Alice对物品5的打分。下面的代码的逻辑就是上面这两步,这里使用带有偏置项和正则项的那个SVD算法

    class SVD():
        def __init__(self, rating_data, F=5, alpha=0.1, lmbda=0.1, max_iter=100):
            self.F = F           # 这个表示隐向量的维度
            self.P = dict()          #  用户矩阵P  大小是[users_num, F]
            self.Q = dict()     # 物品矩阵Q  大小是[item_nums, F]
            self.bu = dict()   # 用户偏差系数
            self.bi = dict()    # 物品偏差系数
            self.mu = 0.0        # 全局偏差系数
            self.alpha = alpha   # 学习率
            self.lmbda = lmbda    # 正则项系数
            self.max_iter = max_iter    # 最大迭代次数
            self.rating_data = rating_data # 评分矩阵
            
            # 初始化矩阵P和Q, 方法很多, 一般用随机数填充, 但随机数大小有讲究, 根据经验, 随机数需要和1/sqrt(F)成正比
            cnt = 0    # 统计总的打分数, 初始化mu用
            for user, items in self.rating_data.items():
                self.P[user] = [random.random() / math.sqrt(self.F)  for x in range(0, F)]
                self.bu[user] = 0
                cnt += len(items) 
                for item, rating in items.items():
                    if item not in self.Q:
                        self.Q[item] = [random.random() / math.sqrt(self.F) for x in range(0, F)]
                        self.bi[item] = 0
            self.mu /= cnt
            
        # 有了矩阵之后, 就可以进行训练, 这里使用随机梯度下降的方式训练参数P和Q
        def train(self):
            for step in range(self.max_iter):
                for user, items in self.rating_data.items():
                    for item, rui in items.items():
                        rhat_ui = self.predict(user, item)   # 得到预测评分
                        # 计算误差
                        e_ui = rui - rhat_ui
                        
                        self.bu[user] += self.alpha * (e_ui - self.lmbda * self.bu[user])
                        self.bi[item] += self.alpha * (e_ui - self.lmbda * self.bi[item])
                        # 随机梯度下降更新梯度
                        for k in range(0, self.F):
                            self.P[user][k] += self.alpha * (e_ui*self.Q[item][k] - self.lmbda * self.P[user][k])
                            self.Q[item][k] += self.alpha * (e_ui*self.P[user][k] - self.lmbda * self.Q[item][k])
                        
                self.alpha *= 0.1    # 每次迭代步长要逐步缩小
        
        # 预测user对item的评分, 这里没有使用向量的形式
        def predict(self, user, item):
            return sum(self.P[user][f] * self.Q[item][f] for f in range(0, self.F)) + self.bu[user] + self.bi[item] + self.mu   
    

      下面我建立一个字典来存放数据,之所以用字典,是因为很多时候矩阵非常的稀疏,如果用pandas的话,会出现很多Nan的值,反而不好处理。

    # 定义数据集, 也就是那个表格, 注意这里我们采用字典存放数据, 因为实际情况中数据是非常稀疏的, 很少有情况是现在这样
    def loadData():
        rating_data={1: {'A': 5, 'B': 3, 'C': 4, 'D': 4},
               2: {'A': 3, 'B': 1, 'C': 2, 'D': 3, 'E': 3},
               3: {'A': 4, 'B': 3, 'C': 4, 'D': 3, 'E': 5},
               4: {'A': 3, 'B': 3, 'C': 1, 'D': 5, 'E': 4},
               5: {'A': 1, 'B': 5, 'C': 5, 'D': 2, 'E': 1}
              }
        return rating_data
     
    # 接下来就是训练和预测
    rating_data = loadData()
    basicsvd = SVD(rating_data, F=10)
    basicsvd.train()
    for item in ['E']:
        print(item, basicsvd.predict(1, item))
     
    ## 结果:
    E 3.252210242858994
    

      通过这个方式,得到的预测评分是3.25,这个和隐向量的维度,训练次数和训练方式有关,这里只说一下这个东西应该怎么用,具体结果可以不用纠结。

    思考

      1.矩阵分解算法后续有哪些改进呢?针对这些改进,是为了解决什么的问题呢?请大家自行探索RSVD,消除用户和物品打分偏差等

      2.矩阵分解的优缺点分析

    o 优点:

    • 泛化能力强:一定程度上解决了稀疏问题
    • 空间复杂度低:由于用户和物品都用隐向量的形式存放,少了用户和物品相似度矩阵,空间复杂度由n^2降到了(n+m)*f
    • 更好的扩展性和灵活性:矩阵分解的最终产物是用户和物品隐向量,这个深度学习的embedding思想不谋而合,因此矩阵分解的结果非常便于与其他特征进行组合和拼接,并可以与深度学习无缝结合。

      但是,矩阵分解算法依然是只用到了评分矩阵,没有考虑到用户特征,物品特征和上下文特征,这使得矩阵分解丧失了利用很多有效信息的机会,同时在缺乏用户历史行为的时候,无法进行有效的推荐。所以为了解决这个问题,逻辑回归模型及后续的因子分解机模型,凭借其天然的融合不同特征的能力,逐渐在推荐系统领域得到了更广泛的应用。

    二、 因子分解机FM

      因子分解机(Factorization Machines)由 Steffen Rendle于2010年提出一种因子分解模型,其目的是解决传统的因子分解模型的一些缺点:首先,传统的因子模型,每遇到一种新问题,都需要在矩阵分解的基础上建立一个新模型(例如上一节的SVD),推导出新的参数学习算法,并在学习参数过程中调节各种参数。以至于这些因子分解模型对于那些对因子分解模型的使用不是很熟悉的人来说是费事、耗力、易错的。其次,传统的因子分解模型不能很好地利用特征工程法( feature engineering)来完成学习任务。在实际的机器学习任务中,常用的方法是首先用特征向量来表示数据,然后用一些开源工具 LibSVM或Weka等工具进行学习,方便地完成分类或决策任务

      FM的优势在于它能够通过特征向量去模拟因子分解模型它既结合了特征工程法的普遍性和适用性,又能够利用因子分解模型对不同类别的变量之间的交互作用(interaction)进行建模估计,借助开源实现工具 libFM,能够快速地完成学习任务,取得很好的精度。将这一模型命名为因子分解机,作者正是希望该模型能像支撑向量机那样简单、易用、高精度

    1. FM模型的引入

    1.1 逻辑回归模型及其缺点

      FM模型其实是一种思路,具体的应用稍少。一般来说做推荐CTR预估时最简单的思路就是将特征做线性组合(逻辑回归LR),传入sigmoid中得到一个概率值,本质上这就是一个线性模型,因为sigmoid是单调增函数不会改变里面的线性模型的CTR预测顺序,因此逻辑回归模型效果会比较差。也就是LR的缺点有:

    • 是一个线性模型
    • 每个特征对最终输出结果独立,需要手动特征交叉(xi*xj),比较麻烦

    1.2 二阶交叉项的考虑及改进

      LR模型的上述缺陷(主要是手动做特征交叉比较麻烦),干脆就考虑所有的二阶交叉项,也就是将目标函数由原来的

    在这里插入图片描述
      变为

    在这里插入图片描述
      但这个式子有一个问题,只有当xi与xj均不为0时这个二阶交叉项才会生效,后面这个特征交叉项本质是和多项式核SVM等价的,为了解决这个问题,我们的FM登场了!

      FM模型使用了如下的优化函数

    在这里插入图片描述
      事实上做的唯一改动就是把 wij 替换成了 <vi,vj> ,大家应该就看出来了,这实际上就有深度学习的意味在里面了,实质上就是给每个 xi 计算一个embedding,然后将两个向量之间的embedding做内积得到之前所谓的 wij 好处就是这个模型泛化能力强 ,即使两个特征之前从未在训练集中同时出现,我们也不至于像之前一样训练不出 wij ,事实上只需要 xi 和其他的 xk 同时出现过就可以计算出 xi 的embedding!

    2. FM公式的理解

      从公式来看,模型前半部分就是普通的LR线性组合,后半部分的交叉项:特征组合。首先,单从模型表达能力上来看,FM是要强于LR的,至少它不会比LR弱,当交叉项参数wij全为0的时候,整个模型就退化为普通的LR模型。对于有n个特征的模型,特征组合的参数数量共有1+2+3+⋯+n−1=n(n−1)/2个,并且任意两个参数之间是独立的。所以说特征数量比较多的时候,特征组合之后,维度自然而然就高了。

      定理:任意一个实对称矩阵(正定矩阵) W 都存在一个矩阵 V ,使得 W=V.VT 成立

      类似地,所有二次项参数 ωij 可以组成一个对称阵 W (为了方便说明FM的由来,对角元素可以设置为正实数),那么这个矩阵就可以分解为 W=VTV , V 的第 j 列( vj )便是第 j 维特征( xj )的隐向量。

    在这里插入图片描述
      需要估计的参数有 ω0∈R , ωi∈R , V∈R , <⋅,⋅> 是长度为 k 的两个向量的点乘,公式如下:

    在这里插入图片描述
      上面的公式中:

    • ω0 为全局偏置;
    • ωi 是模型第 i 个变量的权重;
    • ωij=<vi,vj> 特征 i 和 j 的交叉权重;
    • vi 是第 i 维特征的隐向量;
    • <⋅,⋅> 代表向量点积;
    • k(k<<n) 为隐向量的长度,包含 k 个描述特征的因子。

      FM模型中二次项的参数数量减少为 kn 个,远少于多项式模型的参数数量。另外,参数因子化使得xhxi 的参数和 xixj 的参数不再是相互独立的,因此我们可以在样本稀疏的情况下相对合理地估计FM的二次项参数。具体来说,xhxi和 xixj 的系数分别为 <vh,vi> 和 <vi,vj> ,它们之间有共同项 vi 。也就是说,所有包含“ xi 的非零组合特征”(存在某个 j≠i ,使得 xixj≠0 )的样本都可以用来学习隐向量 vi ,这很大程度上避免了数据稀疏性造成的影响。而在多项式模型中, whi 和 wij 是相互独立的。

      显而易见,FM的公式是一个通用的拟合方程,可以采用不同的损失函数用于解决regression、classification等问题,比如可以采用MSE(Mean Square Error)loss function来求解回归问题,也可以采用Hinge/Cross-Entropy loss来求解分类问题。当然,在进行二元分类时,FM的输出需要使用sigmoid函数进行变换,该原理与LR是一样的。直观上看,FM的复杂度是O(kn2) 。但是FM的二次项可以化简,其复杂度可以优化到 O(kn) 。由此可见,FM可以在线性时间对新样本作出预测。

      证明:

    在这里插入图片描述  解释:

    • vi,f是一个具体的值;
    • 第1个等号:对称矩阵 W 对角线上半部分;
    • 第2个等号:把向量内积 vi,vj 展开成累加和的形式;
    • 第3个等号:提出公共部分;
    • 第4个等号:i 和 j 相当于是一样的,表示成平方过程。

    3. FM模型的应用

      最直接的想法就是直接把FM得到的结果放进sigmoid中输出一个概率值,由此做CTR预估,事实上我们也可以做召回。

      由于FM模型是利用两个特征的Embedding做内积得到二阶特征交叉的权重,那么我们可以将训练好的FM特征取出离线存好,之后用来做KNN向量检索

      工业应用的具体操作步骤:

    • 离线训练好FM模型(学习目标可以是CTR)
    • 将训练好的FM模型Embedding取出
    • 将每个uid对应的Embedding做avg pooling(平均)形成该用户最终的Embedding,item也做同样的操作
    • 将所有的Embedding向量放入Faiss等
    • 线上uid发出请求,取出对应的user embedding,进行检索召回

    4. 代码实践

    4.1 调包实现

      调包版

      直接看Github官方仓库:https://github.com/coreylynch/pyFM,里面有介绍如何安装以及使用,下面搬运一遍:

      安装
      方法一:直接pip install

    pip install git+https://github.com/coreylynch/pyFM
    

      方法二:手动安装

      输入上面这行代码应能下载这个包并安装,如果安装失败可能是网络原因,这时可以考虑手动下载这个包然后手动python setup.py install安装,这时候通常会报错,去掉setup.py文件里面的libraries=[“m”]一行再重新安装即可

      具体操作是:

    • https://github.com/coreylynch/pyFM中手动下载包
    • 将包解压,更改里面的setup.py文件,去掉setup.py文件里面的libraries=[“m”]一行
    • cd到当前文件夹下python setup.py install

      测试
      这部分主要作为简单上手让读者了解如何使用这个包~
      第一步:导包

    from pyfm import pylibfm 
    from sklearn.feature_extraction import DictVectorizer 
    import numpy as np
    

      第二步:创建训练集并转换成one-hot编码的特征形式

    train = [
        {"user": "1", "item": "5", "age": 19},
        {"user": "2", "item": "43", "age": 33},
        {"user": "3", "item": "20", "age": 55},
        {"user": "4", "item": "10", "age": 20},
    ]
    v = DictVectorizer()
    X = v.fit_transform(train)
    print(X.toarray())
    

      看看结果,对比一下维度是否符合预期:

    [[19.  0.  0.  0.  1.  1.  0.  0.  0.]
     [33.  0.  0.  1.  0.  0.  1.  0.  0.]
     [55.  0.  1.  0.  0.  0.  0.  1.  0.]
     [20.  1.  0.  0.  0.  0.  0.  0.  1.]]
    

      第三步:创建标签
      这里简单创建了一个全1的标签:

    y = np.repeat(1.0,X.shape[0])
    y
    
    array([1., 1., 1., 1.])
    

      第四步:训练并预测
      就和调用sklearn的包是一样的用法:

    fm = pylibfm.FM()
    fm.fit(X,y)
    fm.predict(v.transform({"user": "1", "item": "10", "age": 24}))
    
    4.1.1 电影评分数据集实战

      数据集在这里下载,数据集本地具体保存路径读者自行阅读代码找找: http://www.grouplens.org/system/files/ml-100k.zip

      导包,并定义一个导入指定格式数据集的函数

    import numpy as np
    from sklearn.feature_extraction import DictVectorizer
    from pyfm import pylibfm
    
    # Read in data
    def loadData(filename,path="ml-100k/"):
        data = []
        y = []
        users=set()
        items=set()
        with open(path+filename) as f:
            for line in f:
                (user,movieid,rating,ts)=line.split('\t')
                data.append({ "user_id": str(user), "movie_id": str(movieid)})
                y.append(float(rating))
                users.add(user)
                items.add(movieid)
    
        return (data, np.array(y), users, items)
    

      导入训练集和测试集,并转换格式

    (train_data, y_train, train_users, train_items) = loadData("ua.base")
    (test_data, y_test, test_users, test_items) = loadData("ua.test")
    v = DictVectorizer()
    X_train = v.fit_transform(train_data)
    X_test = v.transform(test_data)
    

      训练模型并测试

    # Build and train a Factorization Machine
    fm = pylibfm.FM(num_factors=10, num_iter=100, verbose=True, task="regression", initial_learning_rate=0.001, learning_rate_schedule="optimal")
    fm.fit(X_train,y_train)
    

      预测结果打印误差

    preds = fm.predict(X_test)
    from sklearn.metrics import mean_squared_error
    print("FM MSE: %.4f" % mean_squared_error(y_test,preds))
    
    FM MSE: 0.8873
    
    4.1.2 分类任务实战

      导入数据

    import numpy as np
    from sklearn.feature_extraction import DictVectorizer
    from sklearn.cross_validation import train_test_split
    from pyfm import pylibfm
    
    from sklearn.datasets import make_classification
    
    X, y = make_classification(n_samples=1000,n_features=100, n_clusters_per_class=1)
    data = [ {v: k for k, v in dict(zip(i, range(len(i)))).items()}  for i in X]
    
    X_train, X_test, y_train, y_test = train_test_split(data, y, test_size=0.1, random_state=42)
    
    v = DictVectorizer()
    X_train = v.fit_transform(X_train)
    X_test = v.transform(X_test)
    

      建模型

      我们可以看到主要改变的参数是num_factors和tasks,读者可以想想为什么

    fm = pylibfm.FM(num_factors=50, num_iter=10, verbose=True, task="classification", initial_learning_rate=0.0001, learning_rate_schedule="optimal")
    fm.fit(X_train,y_train)
    

      由于是分类任务,误差函数肯定不一样

    from sklearn.metrics import log_loss
    print("Validation log loss: %.4f" % log_loss(y_test,fm.predict(X_test)))
    
    Validation log loss: 1.3678
    

    4.2 从零实现

      数据集介绍

      criteo:criteo是非常经典的点击率预估数据集,其中连续特征有13个,类别型特征有26个,没有提供特征的具体名称,特征分别如下:

    dense_feats:'I1', 'I2', 'I3', 'I4', 'I5', 'I6', 'I7', 'I8', 'I9', 'I10','I11', 'I12', 'I13'
    sparse_feats:  'C1', 'C2', 'C3', 'C4', 'C5', 'C6', 'C7', 'C8', 'C9', 'C10', 'C11', 'C12', 'C13', 'C14', 'C15', 'C16', 'C17', 'C18', 'C19', 'C20', 'C21', 'C22', 'C23', 'C24', 'C25', 'C26'
    

      代码参考源代码文档中的FM.py

    思考

      请大家思考一下FM存在的问题, 以及可以从哪些地方再进行改进?

    三、实战

      MF.py

    import pandas as pd
    import numpy as np
    import warnings
    import random, math, os
    from tqdm import tqdm
    
    from tensorflow.keras import *
    from tensorflow.keras.layers import *
    from tensorflow.keras.models import *
    from tensorflow.keras.callbacks import *
    import tensorflow.keras.backend as K
    
    from sklearn.model_selection import train_test_split
    from sklearn.preprocessing import LabelEncoder
    import faiss
    warnings.filterwarnings('ignore')
    
    # 评价指标
    # 推荐系统推荐正确的商品数量占用户实际点击的商品数量
    def Recall(Rec_dict, Val_dict):
        '''
        Rec_dict: 推荐算法返回的推荐列表, 形式:{uid: {item1, item2,...}, uid: {item1, item2,...}, ...} 
        Val_dict: 用户实际点击的商品列表, 形式:{uid: {item1, item2,...}, uid: {item1, item2,...}, ...}
        '''
        hit_items = 0
        all_items = 0
        for uid, items in Val_dict.items():
            rel_set = items
            rec_set = Rec_dict[uid]
            for item in rec_set:
                if item in rel_set:
                    hit_items += 1
            all_items += len(rel_set)
    
        return round(hit_items / all_items * 100, 2)
    
    # 推荐系统推荐正确的商品数量占给用户实际推荐的商品数
    def Precision(Rec_dict, Val_dict):
        '''
        Rec_dict: 推荐算法返回的推荐列表, 形式:{uid: {item1, item2,...}, uid: {item1, item2,...}, ...} 
        Val_dict: 用户实际点击的商品列表, 形式:{uid: {item1, item2,...}, uid: {item1, item2,...}, ...}
        '''
        hit_items = 0
        all_items = 0
        for uid, items in Val_dict.items():
            rel_set = items
            rec_set = Rec_dict[uid]
            for item in rec_set:
                if item in rel_set:
                    hit_items += 1
            all_items += len(rec_set)
    
        return round(hit_items / all_items * 100, 2)
    
    # 所有被推荐的用户中,推荐的商品数量占这些用户实际被点击的商品数量
    def Coverage(Rec_dict, Trn_dict):
        '''
        Rec_dict: 推荐算法返回的推荐列表, 形式:{uid: {item1, item2,...}, uid: {item1, item2,...}, ...} 
        Trn_dict: 训练集用户实际点击的商品列表, 形式:{uid: {item1, item2,...}, uid: {item1, item2,...}, ...}
        '''
        rec_items = set()
        all_items = set()
        for uid in Rec_dict:
            for item in Trn_dict[uid]:
                all_items.add(item)
            for item in Rec_dict[uid]:
                rec_items.add(item)
        return round(len(rec_items) / len(all_items) * 100, 2)
    
    # 使用平均流行度度量新颖度,如果平均流行度很高(即推荐的商品比较热门),说明推荐的新颖度比较低
    def Popularity(Rec_dict, Trn_dict):
        '''
        Rec_dict: 推荐算法返回的推荐列表, 形式:{uid: {item1, item2,...}, uid: {item1, item2,...}, ...} 
        Trn_dict: 训练集用户实际点击的商品列表, 形式:{uid: {item1, item2,...}, uid: {item1, item2,...}, ...}
        '''
        pop_items = {}
        for uid in Trn_dict:
            for item in Trn_dict[uid]:
                if item not in pop_items:
                    pop_items[item] = 0
                pop_items[item] += 1
        
        pop, num = 0, 0
        for uid in Rec_dict:
            for item in Rec_dict[uid]:
                pop += math.log(pop_items[item] + 1) # 物品流行度分布满足长尾分布,取对数可以使得平均值更稳定
                num += 1  
        return round(pop / num, 3)
    
    # 将几个评价指标指标函数一起调用
    def rec_eval(val_rec_items, val_user_items, trn_user_items):
        print('recall:',Recall(val_rec_items, val_user_items))
        print('precision',Precision(val_rec_items, val_user_items))
        print('coverage',Coverage(val_rec_items, trn_user_items))
        print('Popularity',Popularity(val_rec_items, trn_user_items)) 
    
    
    def get_data(root_path):
        # 读取数据时,定义的列名
        rnames = ['user_id','movie_id','rating','timestamp']
        data = pd.read_csv(os.path.join(root_path, 'ratings.dat'), sep='::', engine='python', names=rnames)
    
        lbe = LabelEncoder()
        data['user_id'] = lbe.fit_transform(data['user_id'])
        data['movie_id'] = lbe.fit_transform(data['movie_id']) 
    
        # 直接这么分是不是可能会存在验证集中的用户或者商品不在训练集合中呢?那这种的操作一半是怎么进行划分
        trn_data_, val_data_, _, _ = train_test_split(data, data, test_size=0.2)
    
        trn_data = trn_data_.groupby('user_id')['movie_id'].apply(list).reset_index()
        val_data = val_data_.groupby('user_id')['movie_id'].apply(list).reset_index()
    
        trn_user_items = {}
        val_user_items = {}
        
        # 将数组构造成字典的形式{user_id: [item_id1, item_id2,...,item_idn]}
        for user, movies in zip(*(list(trn_data['user_id']), list(trn_data['movie_id']))):
            trn_user_items[user] = set(movies)
    
        for user, movies in zip(*(list(val_data['user_id']), list(val_data['movie_id']))):
            val_user_items[user] = set(movies)
    
        return trn_user_items, val_user_items, trn_data_, val_data_, data
    
    # 矩阵分解模型
    def MF(n_users, n_items, embedding_dim=8):
        K.clear_session()
        input_users = Input(shape=[None, ])
        users_emb = Embedding(n_users, embedding_dim)(input_users)
        
        input_movies = Input(shape=[None, ])
        movies_emb = Embedding(n_items, embedding_dim)(input_movies)
        
        users = BatchNormalization()(users_emb)
        users = Reshape((embedding_dim, ))(users)
        
        movies = BatchNormalization()(movies_emb)
        movies = Reshape((embedding_dim, ))(movies)
        
        output = Dot(1)([users, movies])
        model = Model(inputs=[input_users, input_movies], outputs=output)
        model.compile(loss='mse', optimizer='adam')
        model.summary()
        
        # 为了方便获取模型中的某些层,进行如下属性设置
        model.__setattr__('user_input', input_users)
        model.__setattr__('user_embedding', users_emb)
        model.__setattr__('movie_input', input_movies)
        model.__setattr__('movie_embedding', movies_emb)
    
        return model
    
    
    if __name__ == "__main__":
        # K表示最终给用户推荐的商品数量,N表示候选推荐商品为用户交互过的商品相似商品的数量
        k = 80
        N = 10
    
        # 读取数据
        root_path = './data/ml-1m/'
        trn_user_items, val_user_items, trn_data, val_data, data = get_data(root_path)
    
        # 模型保存的名称
        # 定义模型训练时监控的相关参数
        model_path = 'mf.h5'
        checkpoint = ModelCheckpoint(model_path, monitor='val_loss', verbose=1, save_best_only=True, 
                                     mode='min', save_weights_only=True)
        reduce_lr = ReduceLROnPlateau(monitor='val_loss', factor=0.5, patience=3, min_lr=0.0001, verbose=1)
        earlystopping = EarlyStopping(monitor='val_loss', min_delta=0.0001, patience=5, verbose=1, mode='min')
        callbacks = [checkpoint, reduce_lr, earlystopping]
    
        # 计算user和item的数量
        n_users = trn_data['user_id'].max() + 1
        n_items = trn_data['movie_id'].max() + 1
        embedding_dim = 64 # 用户及商品的向量维度
        model = MF(n_users, n_items, embedding_dim) # 训练模型
    
        # 模型的输入是user_id和movie_id
        hist = model.fit([trn_data['user_id'].values, trn_data['movie_id'].values], 
                        trn_data['rating'].values, batch_size=256, epochs=1, validation_split=0.1,
                        callbacks=callbacks, verbose=1, shuffle=True)
    
        # 获取模型的Embedding层
        user_embedding_model = Model(inputs=model.user_input, outputs=model.user_embedding)
        item_embedding_model = Model(inputs=model.movie_input, outputs=model.movie_embedding)
        
        # 将验证集中的user_id进行排序,方便与faiss搜索的结果进行对应
        val_uids = sorted(val_data['user_id'].unique())
        trn_items = sorted(trn_data['movie_id'].unique())
        
        # 获取训练数据的实际索引与相对索引,
        # 实际索引指的是数据中原始的user_id
        # 相对索引指的是,排序后的位置索引,这个对应的是faiss库搜索得到的结果索引
        trn_items_dict = {}
        for i, item in enumerate(trn_items):
            trn_items_dict[i] = item
    
        # 获取训练集中的所有的商品,由于数据进行了训练和验证集的划分,所以实际的训练集中的商品可能不包含整个数据集中的所有商品
        # 但是为了在向量索引的时候方便与原始索引相对应
        items_dict = set(trn_data['movie_id'].unique())
    
        user_embs = user_embedding_model.predict([val_uids], batch_size=256).squeeze(axis=1)
        item_embs = item_embedding_model.predict([trn_items], batch_size=256).squeeze(axis=1)
        
        # 使用向量搜索库进行最近邻搜索
        index = faiss.IndexFlatIP(embedding_dim)
        index.add(item_embs)
        # ascontiguousarray函数将一个内存不连续存储的数组转换为内存连续存储的数组,使得运行速度更快。
        D, I = index.search(np.ascontiguousarray(user_embs), k)
    
        # 将推荐结果转换成可以计算评价指标的格式
        # 选择最相似的TopN个item
        val_rec = {}
        for i, u in enumerate(val_uids):
            items = list(map(lambda x: trn_items_dict[x], list(I[i]))) # 先将相对索引转换成原数据中的user_id
            items = list(filter(lambda x: x not in trn_user_items[u], items))[:N] # 过滤掉用户在训练集中交互过的商品id,并选择相似度最高的前N个
            val_rec[u] = set(items) # 将结果转换成统一的形式,便于计算模型的性能指标
    
        # 计算评价指标
        rec_eval(val_rec, val_user_items, trn_user_items)
    
    

      FM.py

    import pandas as pd
    import numpy as np 
    
    from tensorflow.keras import *
    from tensorflow.keras.layers import *
    from tensorflow.keras.models import *
    from tensorflow.keras.callbacks import *
    import tensorflow.keras.backend as K
    
    from sklearn.model_selection import train_test_split
    from sklearn.model_selection import train_test_split
    from sklearn.preprocessing import LabelEncoder
    from tqdm import tqdm
    
    # dense特征取对数  sparse特征进行类别编码
    def process_feat(data, dense_feats, sparse_feats):
        df = data.copy()
        # dense
        df_dense = df[dense_feats].fillna(0.0)
        for f in tqdm(dense_feats):
            df_dense[f] = df_dense[f].apply(lambda x: np.log(1 + x) if x > -1 else -1)
        
        # sparse
        df_sparse = df[sparse_feats].fillna('-1')
        for f in tqdm(sparse_feats):
            lbe = LabelEncoder()
            df_sparse[f] = lbe.fit_transform(df_sparse[f])
        
        df_new = pd.concat([df_dense, df_sparse], axis=1)
        return df_new
    
    # FM 特征组合层
    class crossLayer(layers.Layer):
        def __init__(self,input_dim, output_dim=10, **kwargs):
            super(crossLayer, self).__init__(**kwargs)
    
            self.input_dim = input_dim
            self.output_dim = output_dim
            # 定义交叉特征的权重
            self.kernel = self.add_weight(name='kernel', 
                                         shape=(self.input_dim, self.output_dim),
                                         initializer='glorot_uniform',
                                         trainable=True)
            
        def call(self, x): # 对照上述公式中的二次项优化公式一起理解
            a = K.pow(K.dot(x, self.kernel), 2)
            b = K.dot(K.pow(x, 2), K.pow(self.kernel, 2))
            return 0.5 * K.mean(a-b, 1, keepdims=True)
    
    # 定义FM模型
    def FM(feature_dim):
        inputs = Input(shape=(feature_dim, ))
        
        # 一阶特征
        linear = Dense(units=1, 
                       kernel_regularizer=regularizers.l2(0.01), 
                       bias_regularizer=regularizers.l2(0.01))(inputs)
        
        # 二阶特征
        cross = crossLayer(feature_dim)(inputs)
        add = Add()([linear, cross])  # 将一阶特征与二阶特征相加构建FM模型
        
        pred = Activation('sigmoid')(add)
        model = Model(inputs=inputs, outputs=pred)
        
        model.summary()    
        model.compile(loss='binary_crossentropy',
                      optimizer=optimizers.Adam(),
                      metrics=['binary_accuracy'])
        
        return model    
    
    
    # 读取数据
    print('loading data...')
    data = pd.read_csv('./data/kaggle_train.csv')
    
    # dense 特征开头是I,sparse特征开头是C,Label是标签
    cols = data.columns.values
    dense_feats = [f for f in cols if f[0] == 'I']
    sparse_feats = [f for f in cols if f[0] == 'C']
    
    # 对dense数据和sparse数据分别处理
    print('processing features')
    feats = process_feat(data, dense_feats, sparse_feats)
    
    # 划分训练和验证数据
    x_trn, x_tst, y_trn, y_tst = train_test_split(feats, data['Label'], test_size=0.2, random_state=2020)
    
    # 定义模型
    model = FM(feats.shape[1])
    
    # 训练模型
    model.fit(x_trn, y_trn, epochs=10, batch_size=128, validation_data=(x_tst, y_tst))
    

      结果:
    在这里插入图片描述
    在这里插入图片描述

    参考资料

    1. Datawhale组队学习:推荐系统基础
    2. 张川. 基于矩阵分解的协同过滤推荐算法研究[D].吉林大学,2013.
    展开全文
  • 推荐系统入门(三):矩阵分解MF&因子分解机FM(附代码)本文与 推荐系统入门(三):矩阵分解MF&因子分解机FM(附代码)为同一作者一、 矩阵分解MF矩阵分解(Matrix Factorization,MF)技术实际上就是把用户...

    861bac1f41cf9336a62dbeecb5de1399.png

    推荐系统入门(三):矩阵分解MF&因子分解机FM(附代码)

    本文与 推荐系统入门(三):矩阵分解MF&因子分解机FM(附代码)为同一作者

    一、 矩阵分解MF

    矩阵分解(Matrix Factorization,MF)技术实际上就是把用户-项目评分矩阵分解为若干个部分的组合,它在 Netfilx公司举办的推荐系统大赛上得到了广泛的应用,基于矩阵分解的推荐算法本质上是一种基于模型的协同过滤推荐算法

    基于矩阵分解的推荐算法,实现简单,预测准确度高,扩展性强,在一定程度上缓解了数据的稀疏性问题,但可解释性差

    1. 隐含语义分析技术

    随着用户和项目数量的急剧增长,用户和项目之间评分矩阵的维度也在在急剧增加。而由此带来的问题是计算用户与用户、项目与项目之间相似度矩阵的速度越来越慢,计算问题成为推荐系统的瓶颈。此外,随着评分矩阵越来越稀疏,推荐精度也会受到严重的影响。

    对推荐系统研究过程中有很多人提出给用户或项目进行分类,但是根据传统的推荐算法很难真正发掘出用户用户潜在的兴趣度。为了解决这个问题研究人员提出从数据出发,自动找出项目的分类信息和用户的兴趣度信息。因此,隐含语义分析技术(Latent Variable Analysis)就出现了。

    隐语义模型(Latent Factor Model,LFM)这个概念是由Netflix Prize冠军Koren在2006年提出的。隐语义模型使用一种替代的法则来发现潜在的主题或分类。隐含语义分析技术从诞生至今产生了很多著名的模型和算法。其中和该项技术相关且耳熟能详的名词有隐含主题模型(latent topic model)24、矩阵分解(matrix factorization)、pLSA、LDA 等。

    协同过滤算法的特点就是完全没有利用到物品本身或者是用户自身的属性,仅仅利用了用户与物品的交互信息就可以实现推荐,是一个可解释性很强,非常直观的模型,但是也存在一些问题, 第一个就是处理稀疏矩阵的能力比较弱,所以为了使得协同过滤更好处理稀疏矩阵问题, 增强泛化能力, 从协同过滤中衍生出矩阵分解模型或者叫隐语义模型, 两者差不多说的一个意思,就是在协同过滤共现矩阵的基础上, 使用更稠密的隐向量表示用户和物品,挖掘用户和物品的隐含兴趣和隐含特征,在一定程度上弥补协同过滤模型处理稀疏矩阵能力不足的问题。

    1.1 隐语义模型

    隐语义模型最早在文本领域被提出,用于找到文本的隐含语义。在2006年, 被用于推荐中, 它的核心思想是通过隐含特征(latent factor)联系用户兴趣和物品(item), 基于用户的行为找出潜在的主题和分类, 然后对item进行自动聚类,划分到不同类别/主题(用户的兴趣)

    这么说可能有点抽象,所以下面拿项亮老师《推荐系统实践》里面的那个例子看一下:

    如果我们知道了用户A和用户B两个用户在豆瓣的读书列表, 从他们的阅读列表可以看出,用户A的兴趣涉及侦探小说、科普图书以及一些计算机技术书, 而用户B的兴趣比较集中在数学和机器学习方面。 那么如何给A和B推荐图书呢?

    先说说协同过滤算法, 这样好对比不同:

    • 对于UserCF,首先需要找到和他们看了同样书的其他用户(兴趣相似的用户),然后给他们推荐那些用户喜欢的其他书。
    • 对于ItemCF,需要给他们推荐和他们已经看的书相似的书,比如作者B看了很多关于数据挖掘的书,可以给他推荐机器学习或者模式识别方面的书。

    而如果是隐语义模型的话, 它会先通过一些角度把用户兴趣和这些书归一下类, 当来了用户之后, 首先得到他的兴趣分类, 然后从这个分类中挑选他可能喜欢的书籍。

    这里就看到了隐语义模型和协同过滤的不同, 这里说的角度其实就是这个隐含特征, 比如书籍的话它的内容、作者、年份、主题等都可以算隐含特征,如果这个例子还不是很清晰的话,那么下面再举个更为具体的例子,看看是如何通过隐含特征来划分开用户兴趣和物品的。但是在这之前,相信通过上面这个例子,我们已经隐隐约约感受到了协同过滤和隐语义模型的区别了,下面放上王喆老师《深度学习推荐系统》的一个原理图作为对比,区别简直一目了然:

    698c69137796cf88641ea5dceefc7d98.png

    我们下面拿一个音乐评分的例子来具体看一下隐特征矩阵的含义。

    假设每个用户都有自己的听歌偏好, 比如A喜欢带有小清新的吉他伴奏的王菲的歌曲,如果一首歌正好是王菲唱的, 并且是吉他伴奏的小清新, 那么就可以将这首歌推荐给这个用户。 也就是说是小清新, 吉他伴奏, 王菲这些元素连接起了用户和歌曲。 当然每个用户对不同的元素偏好不同, 每首歌包含的元素也不一样, 所以我们就希望找到下面的两个矩阵

    1)潜在因子—— 用户矩阵Q

    这个矩阵表示不同用户对于不同元素的偏好程度, 1代表很喜欢, 0代表不喜欢, 比如下面这样:

    35705207f530aa2aff02fe96bab84b20.png

    2)潜在因子——音乐矩阵P

    表示每种音乐含有各种元素的成分,比如下表中,音乐A是一个偏小清新的音乐, 含有小清新的Latent Factor的成分是0.9,重口味的成分是0.1,优雅成分0.2.....

    99ed256ecda3b3e240083b26da05d5de.png

    利用上面的这两个矩阵, 我们就能得出张三对音乐A的喜欢程度:

    张三对小清新的偏好 * 音乐A含有小清新的成分 + 张三对重口味的偏好 * 音乐A含有重口味的成分 + 张三对优雅的偏好 * 音乐A含有优雅的成分....,

    下面是对应的两个隐向量

    40d51c073bb3591811dd69b37093b460.png

    根据隐向量其实就可以得到张三对音乐A的打分,即:

    0.6∗0.9+0.8∗0.1+0.1∗0.2+0.1∗0.4+0.7∗0=0.69

    按照这个计算方式, 每个用户对每首歌其实都可以得到这样的分数,最后就得到了我们的评分矩阵

    dc5f8abfda7c1c38c010b0953e1bc480.png

    这里的红色表示用户没有打分,我们通过隐向量计算得到的。

    上面例子中的小清晰、 重口味、 优雅这些就可以看做是隐含特征, 而通过这个隐含特征就可以把用户的兴趣和音乐的进行一个分类,其实就是找到了每个用户每个音乐的一个隐向量表达形式(embedding的原理其实也是这样,那里是找到每个词的隐向量表达),这个隐向量就可以反映出用户的兴趣和物品的风格,并能将相似的物品推荐给相似的用户等。有没有感觉到是把协同过滤算法进行了一种延伸,把用户的相似性和物品的相似性通过了一个叫做隐向量的方式进行表达。

    但是,真实的情况下我们其实是没有上面那两个矩阵的,音乐那么多,用户那么多, 我们没有办法去找一些隐特征去表示出这些东西,另外一个问题就是即使能表示也不一定准,对于每个用户或者每个物品的风格,我们每个人都有不同的看法。所以事实上,我们有的只有用户的评分矩阵,也就是最后的结果,并且一般这种矩阵长这样:

    e03e3d7a29789c0f60a34b9624db0292.png

    这种矩阵非常的稀疏,如果直接基于用户相似性或者物品相似性去填充这个矩阵是不太容易的, 并且很容易出现长尾问题, 所以矩阵分解就可以比较容易的解决这个问题。

    矩阵分解模型其实就是在想办法基于这个评分矩阵去找到上面例子中的那两个矩阵, 也就是用户兴趣和物品的隐向量表达, 然后就把这个评分矩阵分解成Q和P两个矩阵乘积的形式, 这时候就可以基于这两个矩阵去预测某个用户对某个物品的评分了。 然后基于这个评分去进行推荐。这就是矩阵分解算法的原理

    1.2 矩阵分解算法

    在矩阵分解的算法框架下, 我们就可以通过分解协同过滤的共现矩阵来得到用户和物品的隐向量, 就是上面的用户矩阵Q和物品矩阵P,这也是“矩阵分解”名字的由来。

    d23666b0b19256b5a0399da9488e6361.png

    矩阵分解算法将 m×n 维的共享矩阵 R 分解成 m×k 维的用户矩阵 U 和 k×n 维的物品矩阵 V 相乘的形式。其中 m 是用户数量,n 是物品数量,k 是隐向量维度,也就是隐含特征个数,只不过这里的隐含特征变得不可解释了,即我们不知道具体含义了,要模型自己去学。k 的大小决定了隐向量表达能力的强弱,k 越大,表达信息就越强,理解起来就是把用户的兴趣和物品的分类划分的越具体。

    那么如果有了用户矩阵和物品矩阵的话,我们就知道了如果想计算用户 u 对物品 i 的评分, 只需要

    081163c9d035bd775811605922a3f531.png

    这里的 pu 就是用户 u 的隐向量, 就类似与上面的张三向量,注意这是列向量, qi 是物品 i 的隐向量,就类似于上面的音乐A向量, 这个也是列向量,所以才用了 pTuqi 得到了一个数,也就是用户的最终评分, 计算过程其实和上面例子中一样。这里的 pu,k 和 qi,k 是模型的参数, 也正是我们想办法要计算的,pu,k 度量的是用户 u 的兴趣和第 k 个隐类的关系,而 qi,k 度量了第 k 个隐类和物品 i 之间的关系。

    1.3 矩阵分解算法求解

    谈到矩阵分解,最常用的方法是特征值分解(EVD)或者奇异值分解(SVD),但是这两种方式在这里不适用。

    首先是EVD,它要求分解的矩阵是方阵,显然用户-物品矩阵不满足这个要求,而传统的SVD分解,会要求原始矩阵是稠密的,而我们这里的这种矩阵一般情况下是非常稀疏的,如果想用奇异值分解,就必须对缺失的元素进行填充,而一旦补全,空间复杂度就会非常高,且补的不一定对。然后就是SVD分解计算复杂度非常高,而我们的用户-物品矩阵非常大,所以基本上无法使用。

    2. Funk-SVD算法

    2006年的Netflix Prize之后, Simon Funk公布了一个矩阵分解算法叫做Funk-SVD, 后来被Netflix Prize的冠军Koren称为Latent Factor Model ( LFM )。 Funk-SVD的思想很简单: 把求解上面两个矩阵的参数问题转换成一个最优化问题, 可以通过训练集里面的观察值利用最小化来学习用户矩阵和物品矩阵

    我们上面已经知道了,如果有了用户矩阵和物品矩阵的话,我们就知道了如果想计算用户 u 对物品i的评分,只需要

    ac657b62864227f2794da9e0eb7bba43.png

    而现在,我们有真实的 ru,i , 但是没有pTuqi, 那么我们可以初始化一个啊,随机初始化一个用户矩阵 U 和一个物品矩阵 V ,然后不就有pTuqi了?当然你说,随机初始化的肯定不准啊,但是,有了 pTuqi之后,我们就可以计算一个猜测的 ^rui , 即

    29f75d613bdfa105039e95d2cfa43777.png

    这时候,肯定是不准,那么这个猜测的和真实值之间就会有一个误差

    8a7d9824634e35110752efed694caaa7.png

    有了误差,我们就可以计算出总的误差平方和

    b70a31c6273ffbf1d98c07c925e33af0.png

    有了损失,我们就可以想办法进行训练,把SSE降到最小,那么我们的两个矩阵参数就可以算出来。所以就把这个问题转成了最优化的的问题,而我们的目标函数就是:

    55a82aa6470f66699869c297263571d5.png

    这里的 K 表示所有用户评分样本的集合。

    有了目标函数,那么我们就可以使用梯度下降算法来降低损失。那么我们需要对目标函数求偏导,得到梯度。我们的目标函数如果是上面的SSE,我们下面来推导一下最后的导数:

    7bc131f2cb40bf92995cc4125c89bb94.png

    首先我们求SSE在 pu,k (也就是Q矩阵的第 u 行 k 列)的梯度

    1cb44dd88c72da6b9f57edd20af7ce0b.png

    然后求SSE在 qk,i 处(也就是V矩阵的第 k 行 i 列)的梯度

    2411f2a288679c006bbbf794beb0b533.png

    为了让公式更为简单, 把前面的2给他越掉, 即可以令SSE等于:

    1ec13d1ecef69da0081a48ef85676f35.png

    这时候, 梯度就没有前面的系数了,有了梯度,接下来我们就可以用梯度下降算法更新梯度了:

    f19cfe48496807a3e534229f62bd97f7.png

    这里的 η 是学习率,控制步长用的,但上面这个有个问题就是当参数很多的时候, 就是两个矩阵很大的时候,往往容易陷入过拟合的困境,这时候,就需要在目标函数上面加上正则化的损失,就变成了RSVD,关于RSVD的详细内容,可以参考下面给出的链接,由于篇幅原因,这里不再过多的赘述。

    但在实际中,单纯的

    1e089a3f1fd960079151718d953de772.png

    也是不够的,还要考虑其他的一些因素,比如一个评分系统,有些固有的属性和用户物品无关,而用户也有些属性和物品无关,物品也有些属性和用户无关。因此, Netfix Prize中提出了另一种LFM,在原来的基础上加了偏置项, 来消除用户和物品打分的偏差,即预测公式如下:

    6f4cd0aaf416c1ba6a5cffd72074a998.png

    这个预测公式加入了3项偏置 μ,bu,bi , 作用如下:

    • μ : 训练集中所有记录的评分的全局平均数。在不同网站中,因为网站定位和销售物品不同,网站的整体评分分布也会显示差异。比如有的网站中用户就喜欢打高分,有的网站中用户就喜欢打低分。而全局平均数可以表示网站本身对用户评分的影响。
    • bu : 用户偏差系数,可以使用用户 u 给出的所有评分的均值,也可以当做训练参数。这一项表示了用户的评分习惯中和物品没有关系的那种因素。比如有些用户比较苛刻,对什么东西要求很高,那么他评分就会偏低,而有些用户比较宽容,对什么东西都觉得不错,那么评分就偏高
    • bi : 物品偏差系数, 可以使用物品 i 收到的所有评分的均值, 也可以当做训练参数。 这一项表示了物品接受的评分中和用户没有关系的因素。 比如有些物品本身质量就很高, 因此获得的评分相对比较高, 有的物品本身质量很差, 因此获得的评分相对较低。

    加了用户和物品的打分偏差之后, 矩阵分解得到的隐向量更能反映不同用户对不同物品的“真实”态度差异, 也就更容易捕捉评价数据中有价值的信息, 从而避免推荐结果有偏。 注意此时的SSE会发生变化:

    0f16b5bcf0c3d9e8fa0083d52adea445.png

    9f1d89cd46523f06b05db9d1ba953f5b.png

    74eebf6795a6b19b9ea4b519b6528623.png

    此时如果把 bu 和 bi 当做训练参数的话, 那么它俩的梯度是:

    a87ad248152f5d2e61c1e874317cf357.png

    更新公式为:

    52ea787f827986e326a6a2702798dcfc.png

    而对于 pu,k 和 pk,i , 导数没有变化, 更新公式也没有变化。

    3. Bias SVD算法

    Bias SVD算法是在 LFM的预测评分公式中加入基准预测评分,从而组成的一种新算法。该算法是考虑到在推荐系统应用中,用户(项目)的某些属性与项目(用户)是无关的,同时,也需要考虑该推荐系统整体的一个评分水平,将这些影响因子考虑进去后,可得基准预测评分的公式为:

    b01634e467f5e7c242aecd007df1519d.png

    其中,u代表的是全局评分的平均值,表明全局评分会对预测评分产生一定的作用; bu是用户u的偏置向量,代表用户的属性因子,例如有的用户擅长打高分,有的用户则比较追求完美,打的分都比较低;bi是项目i的偏置向量,代表项目的属性因子,例如有的项目本身很优秀,则不管什么用户给的评分都相对高,但是也有的项目的质量本身就十分的劣质,那么用户就会给出很低的评分。

    将基准预测信息加入隐语义模型的预测模型后,得到 Bias SVD算法预测模型。其预测公式如下式所示:

    877988083fee4b8dad39d5404b711b50.png

    对该公式进行求解的过程,同隐语义模型相同,首先需要最小化损失函数,该算法的损失函数为:

    5ed15a3a0f5c73106f5e79a9baa63763.png

    需要求解的参数有puf 、qif、bu和bi,故采用梯度下降法时,需要对这四个参数求偏导数,即:

    26a3b703c59fb10119b1286df7e99210.png

    从上面的公式可以得到puf 、qif、bu和bi的最快下降递推公式为:

    24da18ad98d4fdb5857cd0eb32c6039f.png

    其中,α为puf、qif、bu和bi的学习率。

    4. 编程实现

    我们这里用代码实现一下上面的算法来预测上一篇文章里面的那个预测Alice对物品5的评分, 看看矩阵分解到底是怎么进行预测或者是推荐的。 我把之前的例子拿过来:

    26701610269ba8d88af9cd0b97f48f88.png

    任务就是根据这个评分矩阵, 猜测Alice对物品5的打分。

    在实现SVD之前, 先来回忆一下ItemCF和UserCF对于这个问题的做法, 首先ItemCF的做法,根据已有的用户打分计算物品之间的相似度,得到物品的相似度矩阵, 根据这个相似度矩阵,选择出前K个与物品5最相似的物品,然后基于Alice对这K个物品的得分,猜测Alice对物品5的得分,有一个加权的计算公式。 UserCF的做法是根据用户对其他物品的打分,计算用户之间的相似度,选择出与Alice最相近的K个用户, 然后基于那K个用户对物品5的打分计算出Alice对物品5的打分。但是,这两种方式有个问题, 就是如果矩阵非常稀疏的话,当然这个例子是个特例,一般矩阵都是非常稀疏的, 那么预测效果就不好,因为两个相似用户对同一物品打分的概率以及Alice同时对两个相似物品打分的概率可能都比较小。另外,这两种方法显然没有考虑到全局的物品或者用户,只是基于了最相似的例子,很可能有偏。

    那么SVD在解决这个问题上是这么做的: 1. 首先,它会先初始化用户矩阵P和物品矩阵Q, P的维度是[users_num, F], Q的维度是[item_nums, F],这个F是隐向量的维度。 也就是把通过隐向量的方式把用户的兴趣和F的特点关联了起来。初始化这两个矩阵的方式很多, 但根据经验, 随机数需要和1/sqrt(F)成正比下面代码中会发现。 2. 有了两个矩阵之后,我就可以根据用户已经打分的数据去更新参数,这就是训练模型的过程,方法很简单,就是遍历用户,对于每个用户,遍历它打分的物品,这样就拿到了该用户和物品的隐向量, 然后两者相乘加上偏置就是预测的评分, 这时候与真实评分有个差距, 根据上面的梯度下降就可以进行参数的更新

    这样训练完之后,我们就可以得到用户Alice和物品5的隐向量,根据这个就可以预测Alice对物品5的打分。下面的代码的逻辑就是上面这两步,这里使用带有偏置项和正则项的那个SVD算法

    class SVD():
     def __init__(self, rating_data, F=5, alpha=0.1, lmbda=0.1, max_iter=100):
     self.F = F # 这个表示隐向量的维度
     self.P = dict() # 用户矩阵P 大小是[users_num, F]
     self.Q = dict() # 物品矩阵Q 大小是[item_nums, F]
     self.bu = dict() # 用户偏差系数
     self.bi = dict() # 物品偏差系数
     self.mu = 0.0 # 全局偏差系数
     self.alpha = alpha # 学习率
     self.lmbda = lmbda # 正则项系数
     self.max_iter = max_iter # 最大迭代次数
     self.rating_data = rating_data # 评分矩阵
     
     # 初始化矩阵P和Q, 方法很多, 一般用随机数填充, 但随机数大小有讲究, 根据经验, 随机数需要和1/sqrt(F)成正比
     cnt = 0 # 统计总的打分数, 初始化mu用
     for user, items in self.rating_data.items():
     self.P[user] = [random.random() / math.sqrt(self.F) for x in range(0, F)]
     self.bu[user] = 0
     cnt += len(items) 
     for item, rating in items.items():
     if item not in self.Q:
     self.Q[item] = [random.random() / math.sqrt(self.F) for x in range(0, F)]
     self.bi[item] = 0
     self.mu /= cnt
     
     # 有了矩阵之后, 就可以进行训练, 这里使用随机梯度下降的方式训练参数P和Q
     def train(self):
     for step in range(self.max_iter):
     for user, items in self.rating_data.items():
     for item, rui in items.items():
     rhat_ui = self.predict(user, item) # 得到预测评分
     # 计算误差
     e_ui = rui - rhat_ui
     
     self.bu[user] += self.alpha * (e_ui - self.lmbda * self.bu[user])
     self.bi[item] += self.alpha * (e_ui - self.lmbda * self.bi[item])
     # 随机梯度下降更新梯度
     for k in range(0, self.F):
     self.P[user][k] += self.alpha * (e_ui*self.Q[item][k] - self.lmbda * self.P[user][k])
     self.Q[item][k] += self.alpha * (e_ui*self.P[user][k] - self.lmbda * self.Q[item][k])
     
     self.alpha *= 0.1 # 每次迭代步长要逐步缩小
     
     # 预测user对item的评分, 这里没有使用向量的形式
     def predict(self, user, item):
     return sum(self.P[user][f] * self.Q[item][f] for f in range(0, self.F)) + self.bu[user] + self.bi[item] + self.mu 

    下面我建立一个字典来存放数据,之所以用字典,是因为很多时候矩阵非常的稀疏,如果用pandas的话,会出现很多Nan的值,反而不好处理。

    # 定义数据集, 也就是那个表格, 注意这里我们采用字典存放数据, 因为实际情况中数据是非常稀疏的, 很少有情况是现在这样
    def loadData():
     rating_data={1: {'A': 5, 'B': 3, 'C': 4, 'D': 4},
     2: {'A': 3, 'B': 1, 'C': 2, 'D': 3, 'E': 3},
      3: {'A': 4, 'B': 3, 'C': 4, 'D': 3, 'E': 5},
     4: {'A': 3, 'B': 3, 'C': 1, 'D': 5, 'E': 4},
     5: {'A': 1, 'B': 5, 'C': 5, 'D': 2, 'E': 1}
     }
     return rating_data
     
    # 接下来就是训练和预测
    rating_data = loadData()
    basicsvd = SVD(rating_data, F=10)
    basicsvd.train()
    for item in ['E']:
     print(item, basicsvd.predict(1, item))
     
    ## 结果:
    E 3.252210242858994

    通过这个方式,得到的预测评分是3.25,这个和隐向量的维度,训练次数和训练方式有关,这里只说一下这个东西应该怎么用,具体结果可以不用纠结。

    思考

    1. 矩阵分解算法后续有哪些改进呢?针对这些改进,是为了解决什么的问题呢?请大家自行探索RSVD,消除用户和物品打分偏差等。
    2. 矩阵分解的优缺点分析
    • 优点:
      • 泛化能力强:一定程度上解决了稀疏问题
      • 空间复杂度低:由于用户和物品都用隐向量的形式存放,少了用户和物品相似度矩阵,空间复杂度由n^2降到了(n+m)*f
      • 更好的扩展性和灵活性:矩阵分解的最终产物是用户和物品隐向量,这个深度学习的embedding思想不谋而合,因此矩阵分解的结果非常便于与其他特征进行组合和拼接,并可以与深度学习无缝结合。

    但是,矩阵分解算法依然是只用到了评分矩阵,没有考虑到用户特征,物品特征和上下文特征,这使得矩阵分解丧失了利用很多有效信息的机会,同时在缺乏用户历史行为的时候,无法进行有效的推荐。所以为了解决这个问题,逻辑回归模型及后续的因子分解机模型,凭借其天然的融合不同特征的能力,逐渐在推荐系统领域得到了更广泛的应用。

    二、 因子分解机FM

    因子分解机(Factorization Machines)由 Steffen Rendle于2010年提出一种因子分解模型,其目的是解决传统的因子分解模型的一些缺点:首先,传统的因子模型,每遇到一种新问题,都需要在矩阵分解的基础上建立一个新模型(例如上一节的SVD),推导出新的参数学习算法,并在学习参数过程中调节各种参数。以至于这些因子分解模型对于那些对因子分解模型的使用不是很熟悉的人来说是费事、耗力、易错的。其次,传统的因子分解模型不能很好地利用特征工程法( feature engineering)来完成学习任务。在实际的机器学习任务中,常用的方法是首先用特征向量来表示数据,然后用一些开源工具 LibSVM或Weka等工具进行学习,方便地完成分类或决策任务

    FM的优势在于它能够通过特征向量去模拟因子分解模型它既结合了特征工程法的普遍性和适用性,又能够利用因子分解模型对不同类别的变量之间的交互作用(interaction)进行建模估计,借助开源实现工具 libFM,能够快速地完成学习任务,取得很好的精度。将这一模型命名为因子分解机,作者正是希望该模型能像支撑向量机那样简单、易用、高精度。

    1. FM模型的引入

    1.1 逻辑回归模型及其缺点

    FM模型其实是一种思路,具体的应用稍少。一般来说做推荐CTR预估时最简单的思路就是将特征做线性组合(逻辑回归LR),传入sigmoid中得到一个概率值,本质上这就是一个线性模型,因为sigmoid是单调增函数不会改变里面的线性模型的CTR预测顺序,因此逻辑回归模型效果会比较差。也就是LR的缺点有:

    • 是一个线性模型
    • 每个特征对最终输出结果独立,需要手动特征交叉(xi*xj),比较麻烦

    1.2 二阶交叉项的考虑及改进

    LR模型的上述缺陷(主要是手动做特征交叉比较麻烦),干脆就考虑所有的二阶交叉项,也就是将目标函数由原来的

    3f4c2f244d04bf9a44f1ca486c558e9c.png

    变为

    40c7ee8ffde41aa0e3e0bfe686785f9e.png

    但这个式子有一个问题,只有当xi与xj均不为0时这个二阶交叉项才会生效,后面这个特征交叉项本质是和多项式核SVM等价的,为了解决这个问题,我们的FM登场了!

    FM模型使用了如下的优化函数

    3b674d9929954f4e89806136a0bcd7b4.png

    事实上做的唯一改动就是把 wij 替换成了 <vi,vj> ,大家应该就看出来了,这实际上就有深度学习的意味在里面了,实质上就是给每个 xi 计算一个embedding,然后将两个向量之间的embedding做内积得到之前所谓的 wij 好处就是这个模型泛化能力强 ,即使两个特征之前从未在训练集中同时出现,我们也不至于像之前一样训练不出 wij ,事实上只需要 xi 和其他的 xk 同时出现过就可以计算出 xi 的embedding!

    2. FM公式的理解

    从公式来看,模型前半部分就是普通的LR线性组合,后半部分的交叉项特征组合。首先,单从模型表达能力上来看,FM是要强于LR的,至少它不会比LR弱,当交叉项参数wij全为0的时候,整个模型就退化为普通的LR模型。对于有n个特征的模型,特征组合的参数数量共有1+2+3+⋯+n−1=n(n−1)/2个,并且任意两个参数之间是独立的。所以说特征数量比较多的时候,特征组合之后,维度自然而然就高了。

    定理:任意一个实对称矩阵(正定矩阵) W 都存在一个矩阵 V ,使得 W=V.VT 成立。

    类似地,所有二次项参数 ωij 可以组成一个对称阵 W (为了方便说明FM的由来,对角元素可以设置为正实数),那么这个矩阵就可以分解为 W=VTV , V 的第 j 列( vj )便是第 j 维特征( xj )的隐向量。

    241594291cce80f565e7b0af50dd91b1.png

    需要估计的参数有 ω0∈R , ωi∈R , V∈R , <⋅,⋅> 是长度为 k 的两个向量的点乘,公式如下:

    cd136f94301a3da3c967dc1b64af6f12.png

    上面的公式中:

    • ω0 为全局偏置;
    • ωi 是模型第 i 个变量的权重;
    • ωij=<vi,vj> 特征 i 和 j 的交叉权重;
    • vi 是第 i 维特征的隐向量;
    • <⋅,⋅> 代表向量点积;
    • k(k<<n) 为隐向量的长度,包含 k 个描述特征的因子。

    FM模型中二次项的参数数量减少为 kn 个,远少于多项式模型的参数数量。另外,参数因子化使得xhxi 的参数和 xixj 的参数不再是相互独立的,因此我们可以在样本稀疏的情况下相对合理地估计FM的二次项参数。具体来说,xhxi和 xixj 的系数分别为 <vh,vi> 和 <vi,vj> ,它们之间有共同项 vi 。也就是说,所有包含“ xi 的非零组合特征”(存在某个 j≠i ,使得 xixj≠0 )的样本都可以用来学习隐向量 vi ,这很大程度上避免了数据稀疏性造成的影响。而在多项式模型中, whi 和 wij 是相互独立的。

    显而易见,FM的公式是一个通用的拟合方程,可以采用不同的损失函数用于解决regression、classification等问题,比如可以采用MSE(Mean Square Error)loss function来求解回归问题,也可以采用Hinge/Cross-Entropy loss来求解分类问题。当然,在进行二元分类时,FM的输出需要使用sigmoid函数进行变换,该原理与LR是一样的。直观上看,FM的复杂度是O(kn2) 。但是FM的二次项可以化简,其复杂度可以优化到 O(kn) 。由此可见,FM可以在线性时间对新样本作出预测。

    证明

    c7eeec15b0f7f23b97b3efb81ff329db.png

    解释

    • vi,f是一个具体的值;
    • 第1个等号:对称矩阵 W 对角线上半部分;
    • 第2个等号:把向量内积 vi,vj 展开成累加和的形式;
    • 第3个等号:提出公共部分;
    • 第4个等号:i 和 j 相当于是一样的,表示成平方过程。

    3. FM模型的应用

    最直接的想法就是直接把FM得到的结果放进sigmoid中输出一个概率值,由此做CTR预估,事实上我们也可以做召回。

    由于FM模型是利用两个特征的Embedding做内积得到二阶特征交叉的权重,那么我们可以将训练好的FM特征取出离线存好,之后用来做KNN向量检索

    工业应用的具体操作步骤:

    • 离线训练好FM模型(学习目标可以是CTR)
    • 将训练好的FM模型Embedding取出
    • 将每个uid对应的Embedding做avg pooling(平均)形成该用户最终的Embedding,item也做同样的操作
    • 将所有的Embedding向量放入Faiss等
    • 线上uid发出请求,取出对应的user embedding,进行检索召回

    4. 代码实践

    4.1 调包实现

    调包版

    直接看Github官方仓库:https://github.com/coreylynch/pyFM,里面有介绍如何安装以及使用,下面搬运一遍:

    安装

    方法一:直接pip install

    pip install git+https://github.com/coreylynch/pyFM

    方法二:手动安装

    输入上面这行代码应能下载这个包并安装,如果安装失败可能是网络原因,这时可以考虑手动下载这个包然后手动python setup.py install安装,这时候通常会报错,去掉setup.py文件里面的libraries=[“m”]一行再重新安装即可

    具体操作是:

    • https://github.com/coreylynch/pyFM中手动下载包
    • 将包解压,更改里面的setup.py文件,去掉setup.py文件里面的libraries=[“m”]一行
    • cd到当前文件夹下python setup.py install

    测试

    这部分主要作为简单上手让读者了解如何使用这个包~

    第一步:导包

    from pyfm import pylibfm 
    from sklearn.feature_extraction import DictVectorizer 
    import numpy as np 

    第二步:创建训练集并转换成one-hot编码的特征形式

    train = [
     {"user": "1", "item": "5", "age": 19},
     {"user": "2", "item": "43", "age": 33},
     {"user": "3", "item": "20", "age": 55},
     {"user": "4", "item": "10", "age": 20},
    ]
    v = DictVectorizer()
    X = v.fit_transform(train)
    print(X.toarray())

    看看结果,对比一下维度是否符合预期:

    [[19. 0. 0. 0. 1. 1. 0. 0. 0.]
     [33. 0. 0. 1. 0. 0. 1. 0. 0.]
     [55. 0. 1. 0. 0. 0. 0. 1. 0.]
     [20. 1. 0. 0. 0. 0. 0. 0. 1.]]

    第三步:创建标签

    这里简单创建了一个全1的标签:

    y = np.repeat(1.0,X.shape[0])
    y
     
    array([1., 1., 1., 1.])

    第四步:训练并预测

    就和调用sklearn的包是一样的用法:

    fm = pylibfm.FM()
    fm.fit(X,y)
    fm.predict(v.transform({"user": "1", "item": "10", "age": 24}))

    4.1.1 电影评分数据集实战

    数据集在这里下载,数据集本地具体保存路径读者自行阅读代码找找: http://www.grouplens.org/system/files/ml-100k.zip

    导包,并定义一个导入指定格式数据集的函数

    import numpy as np
    from sklearn.feature_extraction import DictVectorizer
    from pyfm import pylibfm
     
    # Read in data
    def loadData(filename,path="ml-100k/"):
     data = []
     y = []
     users=set()
     items=set()
     with open(path+filename) as f:
     for line in f:
     (user,movieid,rating,ts)=line.split('t')
     data.append({ "user_id": str(user), "movie_id": str(movieid)})
     y.append(float(rating))
     users.add(user)
     items.add(movieid)
     
     return (data, np.array(y), users, items)

    导入训练集和测试集,并转换格式

    (train_data, y_train, train_users, train_items) = loadData("ua.base")
    (test_data, y_test, test_users, test_items) = loadData("ua.test")
    v = DictVectorizer()
    X_train = v.fit_transform(train_data)
    X_test = v.transform(test_data)

    训练模型并测试

    # Build and train a Factorization Machine
    fm = pylibfm.FM(num_factors=10, num_iter=100, verbose=True, task="regression", initial_learning_rate=0.001, learning_rate_schedule="optimal")
    fm.fit(X_train,y_train)
     

    预测结果打印误差

    preds = fm.predict(X_test)
    from sklearn.metrics import mean_squared_error
    print("FM MSE: %.4f" % mean_squared_error(y_test,preds))
    FM MSE: 0.8873

    4.1.2 分类任务实战

    导入数据

    import numpy as np
    from sklearn.feature_extraction import DictVectorizer
    from sklearn.cross_validation import train_test_split
    from pyfm import pylibfm
     
    from sklearn.datasets import make_classification
     
    X, y = make_classification(n_samples=1000,n_features=100, n_clusters_per_class=1)
    data = [ {v: k for k, v in dict(zip(i, range(len(i)))).items()} for i in X]
     
    X_train, X_test, y_train, y_test = train_test_split(data, y, test_size=0.1, random_state=42)
     
    v = DictVectorizer()
    X_train = v.fit_transform(X_train)
    X_test = v.transform(X_test)

    建模型

    我们可以看到主要改变的参数是num_factorstasks,读者可以想想为什么

    fm = pylibfm.FM(num_factors=50, num_iter=10, verbose=True, task="classification", initial_learning_rate=0.0001, learning_rate_schedule="optimal")
    fm.fit(X_train,y_train)

    由于是分类任务,误差函数肯定不一样

    from sklearn.metrics import log_loss
    print("Validation log loss: %.4f" % log_loss(y_test,fm.predict(X_test)))
     
    Validation log loss: 1.3678

    4.2 从零实现

    数据集介绍

    criteo:criteo是非常经典的点击率预估数据集,其中连续特征有13个,类别型特征有26个,没有提供特征的具体名称,特征分别如下:

    dense_feats:'I1', 'I2', 'I3', 'I4', 'I5', 'I6', 'I7', 'I8', 'I9', 'I10','I11', 'I12', 'I13'
    sparse_feats: 'C1', 'C2', 'C3', 'C4', 'C5', 'C6', 'C7', 'C8', 'C9', 'C10', 'C11', 'C12', 'C13', 'C14', 'C15', 'C16', 'C17', 'C18', 'C19', 'C20', 'C21', 'C22', 'C23', 'C24', 'C25', 'C26'

    代码参考源代码文档中的FM.py

    思考

    请大家思考一下FM存在的问题, 以及可以从哪些地方再进行改进?

    三、 实战

    MF.py

    import pandas as pd
    import numpy as np
    import warnings
    import random, math, os
    from tqdm import tqdm
    
    from tensorflow.keras import *
    from tensorflow.keras.layers import *
    from tensorflow.keras.models import *
    from tensorflow.keras.callbacks import *
    import tensorflow.keras.backend as K
    
    from sklearn.model_selection import train_test_split
    from sklearn.preprocessing import LabelEncoder
    import faiss
    warnings.filterwarnings('ignore')
    
    # 评价指标
    # 推荐系统推荐正确的商品数量占用户实际点击的商品数量
    def Recall(Rec_dict, Val_dict):
        '''
        Rec_dict: 推荐算法返回的推荐列表, 形式:{uid: {item1, item2,...}, uid: {item1, item2,...}, ...} 
        Val_dict: 用户实际点击的商品列表, 形式:{uid: {item1, item2,...}, uid: {item1, item2,...}, ...}
        '''
        hit_items = 0
        all_items = 0
        for uid, items in Val_dict.items():
            rel_set = items
            rec_set = Rec_dict[uid]
            for item in rec_set:
                if item in rel_set:
                    hit_items += 1
            all_items += len(rel_set)
    
        return round(hit_items / all_items * 100, 2)
    
    # 推荐系统推荐正确的商品数量占给用户实际推荐的商品数
    def Precision(Rec_dict, Val_dict):
        '''
        Rec_dict: 推荐算法返回的推荐列表, 形式:{uid: {item1, item2,...}, uid: {item1, item2,...}, ...} 
        Val_dict: 用户实际点击的商品列表, 形式:{uid: {item1, item2,...}, uid: {item1, item2,...}, ...}
        '''
        hit_items = 0
        all_items = 0
        for uid, items in Val_dict.items():
            rel_set = items
            rec_set = Rec_dict[uid]
            for item in rec_set:
                if item in rel_set:
                    hit_items += 1
            all_items += len(rec_set)
    
        return round(hit_items / all_items * 100, 2)
    
    # 所有被推荐的用户中,推荐的商品数量占这些用户实际被点击的商品数量
    def Coverage(Rec_dict, Trn_dict):
        '''
        Rec_dict: 推荐算法返回的推荐列表, 形式:{uid: {item1, item2,...}, uid: {item1, item2,...}, ...} 
        Trn_dict: 训练集用户实际点击的商品列表, 形式:{uid: {item1, item2,...}, uid: {item1, item2,...}, ...}
        '''
        rec_items = set()
        all_items = set()
        for uid in Rec_dict:
            for item in Trn_dict[uid]:
                all_items.add(item)
            for item in Rec_dict[uid]:
                rec_items.add(item)
        return round(len(rec_items) / len(all_items) * 100, 2)
    
    # 使用平均流行度度量新颖度,如果平均流行度很高(即推荐的商品比较热门),说明推荐的新颖度比较低
    def Popularity(Rec_dict, Trn_dict):
        '''
        Rec_dict: 推荐算法返回的推荐列表, 形式:{uid: {item1, item2,...}, uid: {item1, item2,...}, ...} 
        Trn_dict: 训练集用户实际点击的商品列表, 形式:{uid: {item1, item2,...}, uid: {item1, item2,...}, ...}
        '''
        pop_items = {}
        for uid in Trn_dict:
            for item in Trn_dict[uid]:
                if item not in pop_items:
                    pop_items[item] = 0
                pop_items[item] += 1
        
        pop, num = 0, 0
        for uid in Rec_dict:
            for item in Rec_dict[uid]:
                pop += math.log(pop_items[item] + 1) # 物品流行度分布满足长尾分布,取对数可以使得平均值更稳定
                num += 1  
        return round(pop / num, 3)
    
    # 将几个评价指标指标函数一起调用
    def rec_eval(val_rec_items, val_user_items, trn_user_items):
        print('recall:',Recall(val_rec_items, val_user_items))
        print('precision',Precision(val_rec_items, val_user_items))
        print('coverage',Coverage(val_rec_items, trn_user_items))
        print('Popularity',Popularity(val_rec_items, trn_user_items)) 
    
    
    def get_data(root_path):
        # 读取数据时,定义的列名
        rnames = ['user_id','movie_id','rating','timestamp']
        data = pd.read_csv(os.path.join(root_path, 'ratings.dat'), sep='::', engine='python', names=rnames)
    
        lbe = LabelEncoder()
        data['user_id'] = lbe.fit_transform(data['user_id'])
        data['movie_id'] = lbe.fit_transform(data['movie_id']) 
    
        # 直接这么分是不是可能会存在验证集中的用户或者商品不在训练集合中呢?那这种的操作一半是怎么进行划分
        trn_data_, val_data_, _, _ = train_test_split(data, data, test_size=0.2)
    
        trn_data = trn_data_.groupby('user_id')['movie_id'].apply(list).reset_index()
        val_data = val_data_.groupby('user_id')['movie_id'].apply(list).reset_index()
    
        trn_user_items = {}
        val_user_items = {}
        
        # 将数组构造成字典的形式{user_id: [item_id1, item_id2,...,item_idn]}
        for user, movies in zip(*(list(trn_data['user_id']), list(trn_data['movie_id']))):
            trn_user_items[user] = set(movies)
    
        for user, movies in zip(*(list(val_data['user_id']), list(val_data['movie_id']))):
            val_user_items[user] = set(movies)
    
        return trn_user_items, val_user_items, trn_data_, val_data_, data
    
    # 矩阵分解模型
    def MF(n_users, n_items, embedding_dim=8):
        K.clear_session()
        input_users = Input(shape=[None, ])
        users_emb = Embedding(n_users, embedding_dim)(input_users)
        
        input_movies = Input(shape=[None, ])
        movies_emb = Embedding(n_items, embedding_dim)(input_movies)
        
        users = BatchNormalization()(users_emb)
        users = Reshape((embedding_dim, ))(users)
        
        movies = BatchNormalization()(movies_emb)
        movies = Reshape((embedding_dim, ))(movies)
        
        output = Dot(1)([users, movies])
        model = Model(inputs=[input_users, input_movies], outputs=output)
        model.compile(loss='mse', optimizer='adam')
        model.summary()
        
        # 为了方便获取模型中的某些层,进行如下属性设置
        model.__setattr__('user_input', input_users)
        model.__setattr__('user_embedding', users_emb)
        model.__setattr__('movie_input', input_movies)
        model.__setattr__('movie_embedding', movies_emb)
    
        return model
    
    
    if __name__ == "__main__":
        # K表示最终给用户推荐的商品数量,N表示候选推荐商品为用户交互过的商品相似商品的数量
        k = 80
        N = 10
    
        # 读取数据
        root_path = './data/ml-1m/'
        trn_user_items, val_user_items, trn_data, val_data, data = get_data(root_path)
    
        # 模型保存的名称
        # 定义模型训练时监控的相关参数
        model_path = 'mf.h5'
        checkpoint = ModelCheckpoint(model_path, monitor='val_loss', verbose=1, save_best_only=True, 
                                     mode='min', save_weights_only=True)
        reduce_lr = ReduceLROnPlateau(monitor='val_loss', factor=0.5, patience=3, min_lr=0.0001, verbose=1)
        earlystopping = EarlyStopping(monitor='val_loss', min_delta=0.0001, patience=5, verbose=1, mode='min')
        callbacks = [checkpoint, reduce_lr, earlystopping]
    
        # 计算user和item的数量
        n_users = trn_data['user_id'].max() + 1
        n_items = trn_data['movie_id'].max() + 1
        embedding_dim = 64 # 用户及商品的向量维度
        model = MF(n_users, n_items, embedding_dim) # 训练模型
    
        # 模型的输入是user_id和movie_id
        hist = model.fit([trn_data['user_id'].values, trn_data['movie_id'].values], 
                        trn_data['rating'].values, batch_size=256, epochs=1, validation_split=0.1,
                        callbacks=callbacks, verbose=1, shuffle=True)
    
        # 获取模型的Embedding层
        user_embedding_model = Model(inputs=model.user_input, outputs=model.user_embedding)
        item_embedding_model = Model(inputs=model.movie_input, outputs=model.movie_embedding)
        
        # 将验证集中的user_id进行排序,方便与faiss搜索的结果进行对应
        val_uids = sorted(val_data['user_id'].unique())
        trn_items = sorted(trn_data['movie_id'].unique())
        
        # 获取训练数据的实际索引与相对索引,
        # 实际索引指的是数据中原始的user_id
        # 相对索引指的是,排序后的位置索引,这个对应的是faiss库搜索得到的结果索引
        trn_items_dict = {}
        for i, item in enumerate(trn_items):
            trn_items_dict[i] = item
    
        # 获取训练集中的所有的商品,由于数据进行了训练和验证集的划分,所以实际的训练集中的商品可能不包含整个数据集中的所有商品
        # 但是为了在向量索引的时候方便与原始索引相对应
        items_dict = set(trn_data['movie_id'].unique())
    
        user_embs = user_embedding_model.predict([val_uids], batch_size=256).squeeze(axis=1)
        item_embs = item_embedding_model.predict([trn_items], batch_size=256).squeeze(axis=1)
        
        # 使用向量搜索库进行最近邻搜索
        index = faiss.IndexFlatIP(embedding_dim)
        index.add(item_embs)
        # ascontiguousarray函数将一个内存不连续存储的数组转换为内存连续存储的数组,使得运行速度更快。
        D, I = index.search(np.ascontiguousarray(user_embs), k)
    
        # 将推荐结果转换成可以计算评价指标的格式
        # 选择最相似的TopN个item
        val_rec = {}
        for i, u in enumerate(val_uids):
            items = list(map(lambda x: trn_items_dict[x], list(I[i]))) # 先将相对索引转换成原数据中的user_id
            items = list(filter(lambda x: x not in trn_user_items[u], items))[:N] # 过滤掉用户在训练集中交互过的商品id,并选择相似度最高的前N个
            val_rec[u] = set(items) # 将结果转换成统一的形式,便于计算模型的性能指标
    
        # 计算评价指标
        rec_eval(val_rec, val_user_items, trn_user_items)
     

    FM.py

    import pandas as pd
    import numpy as np 
    
    from tensorflow.keras import *
    from tensorflow.keras.layers import *
    from tensorflow.keras.models import *
    from tensorflow.keras.callbacks import *
    import tensorflow.keras.backend as K
    
    from sklearn.model_selection import train_test_split
    from sklearn.model_selection import train_test_split
    from sklearn.preprocessing import LabelEncoder
    from tqdm import tqdm
    
    # dense特征取对数  sparse特征进行类别编码
    def process_feat(data, dense_feats, sparse_feats):
        df = data.copy()
        # dense
        df_dense = df[dense_feats].fillna(0.0)
        for f in tqdm(dense_feats):
            df_dense[f] = df_dense[f].apply(lambda x: np.log(1 + x) if x > -1 else -1)
        
        # sparse
        df_sparse = df[sparse_feats].fillna('-1')
        for f in tqdm(sparse_feats):
            lbe = LabelEncoder()
            df_sparse[f] = lbe.fit_transform(df_sparse[f])
        
        df_new = pd.concat([df_dense, df_sparse], axis=1)
        return df_new
    
    # FM 特征组合层
    class crossLayer(layers.Layer):
        def __init__(self,input_dim, output_dim=10, **kwargs):
            super(crossLayer, self).__init__(**kwargs)
    
            self.input_dim = input_dim
            self.output_dim = output_dim
            # 定义交叉特征的权重
            self.kernel = self.add_weight(name='kernel', 
                                         shape=(self.input_dim, self.output_dim),
                                         initializer='glorot_uniform',
                                         trainable=True)
            
        def call(self, x): # 对照上述公式中的二次项优化公式一起理解
            a = K.pow(K.dot(x, self.kernel), 2)
            b = K.dot(K.pow(x, 2), K.pow(self.kernel, 2))
            return 0.5 * K.mean(a-b, 1, keepdims=True)
    
    # 定义FM模型
    def FM(feature_dim):
        inputs = Input(shape=(feature_dim, ))
        
        # 一阶特征
        linear = Dense(units=1, 
                       kernel_regularizer=regularizers.l2(0.01), 
                       bias_regularizer=regularizers.l2(0.01))(inputs)
        
        # 二阶特征
        cross = crossLayer(feature_dim)(inputs)
        add = Add()([linear, cross])  # 将一阶特征与二阶特征相加构建FM模型
        
        pred = Activation('sigmoid')(add)
        model = Model(inputs=inputs, outputs=pred)
        
        model.summary()    
        model.compile(loss='binary_crossentropy',
                      optimizer=optimizers.Adam(),
                      metrics=['binary_accuracy'])
        
        return model    
    
    
    # 读取数据
    print('loading data...')
    data = pd.read_csv('./data/kaggle_train.csv')
    
    # dense 特征开头是I,sparse特征开头是C,Label是标签
    cols = data.columns.values
    dense_feats = [f for f in cols if f[0] == 'I']
    sparse_feats = [f for f in cols if f[0] == 'C']
    
    # 对dense数据和sparse数据分别处理
    print('processing features')
    feats = process_feat(data, dense_feats, sparse_feats)
    
    # 划分训练和验证数据
    x_trn, x_tst, y_trn, y_tst = train_test_split(feats, data['Label'], test_size=0.2, random_state=2020)
    
    # 定义模型
    model = FM(feats.shape[1])
    
    # 训练模型
    model.fit(x_trn, y_trn, epochs=10, batch_size=128, validation_data=(x_tst, y_tst))

    结果:

    63514d7209361da7aa015c06ae7669dc.png

    参考资料

    1.Datawhale组队学习:推荐系统基础

    2.张川. 基于矩阵分解的协同过滤推荐算法研究[D].吉林大学,2013.

    展开全文
  • 矩阵分解 Matrix Factorization 矩阵分解简介 矩阵分解,简单来说,就是把原来的大矩阵,近似分解成两个小矩阵的乘积,实际推荐计算时不再使用大矩阵,而是使用分解得到的两个小矩阵。 假设用户物品评分矩阵为 R...

    矩阵分解 Matrix Factorization

    矩阵分解简介

    矩阵分解,简单来说,就是把原来的大矩阵,近似分解成两个小矩阵的乘积,实际推荐计算时不再使用大矩阵,而是使用分解得到的两个小矩阵。

    假设用户物品评分矩阵为 R, 维度为mxn,即 m 个用户, n 个物品。选择一个很小的数 k,k 比 m 和 n 都小很多,然后通过算法生成两个矩阵 P 和 Q,这两个矩阵的要求如下:P 的维度是 mxk,Q 的维度是 nxk, P 和 Q 的转置相乘结果为 R,即R=P*Q^T。也就是说分解得到的矩阵P和Q可以还原成原始的矩阵R。

    用公式来描述就是:R_{m\times n} \approx P_{m\times k} \times Q_{n\times k}^{T} = \widehat{R}_{m\times n}

    其中 R 表示真实的用户评分矩阵,一般有很多缺失值(缺失值表示用户没有对该物品评分),带尖帽的 R 表示使用分解矩阵预测的用户评分矩阵,它补全了所有的缺失值。

    从另一个角度来看,矩阵分解就是把用户和物品都映射到一个 k 维空间中(这里映射后的结果用户用矩阵P表示,物品用矩阵Q表示),这个 k 维空间不是我们直接看得到的,也不一定具有非常好的可解释性,每一个维度也没有名字,所以常常叫做隐因子,或隐特征。用户向量代表了用户的兴趣,物品向量代表了物品的特点,且每一个维度相互对应,两个向量的内积表示用户对该物品的喜好程度。

    矩阵分解做评分预测

    通过矩阵分解,可以得到用户矩阵和物品矩阵。针对每个用户和物品,假设分解后得到的用户 u 的向量为 p_u,物品 i 的向量为 q_i,那么用户 u 对物品 i 的评分为:

    其中,K 表示隐因子个数。

    求矩阵P、Q的方法

    问题关键是如何求得P、Q矩阵,使得上述的评分预测得以实现?这个问题可以转化成机器学习问题,要解决机器学习问题,就需要寻找损失函数以及优化算法。

    这里单个用户对单个物品的真实评分与预测评分之间的差值记为 e{ui}:

    将所有用户对物品的真实评分与预测评分之间的差值的平方之和作为损失函数,即

    其中,R 表示所有的用户对所有物品的评分集合,K 表示隐因子个数。

    我们要做的就是求出用户向量 p_u 和物品向量 q_i ,来保证损失函数结果最小。

    求解损失函数优化算法常用的选择有两个,一个是梯度下降(GD),另一个是交替最小二乘(ALS) 。

    以梯度下降为例:

    1. 准备好用户物品的评分矩阵,每一条评分数据看做一条训练样本;
    2. 给分解后的 P 矩阵和 Q 矩阵随机初始化元素值;
    3. 用 P 和 Q 计算预测后的分数;
    4. 计算预测的分数和实际的分数误差;
    5. 沿着损失函数梯度下降的方向更新 P 和 Q 中的元素值;
    6. 重复步骤 3 到 5,直到达到停止条件。

    梯度下降算法的一个关键点在于计算损失函数对于每个参数的梯度。

    Done

    展开全文
  • 矩阵分解(Matrix Factorization)矩阵分解基本原理用户矩阵U与物品矩阵V求解实现矩阵分解Python代码参考 矩阵分解基本原理 将mn维的共现矩阵R分解为mk维的用户矩阵U和k*n维的物品矩阵V相乘的形式。其中m是用户数量...
  • 全面理解矩阵分解MF在推荐系统中的应用  那么,这是本系列的第二篇文章,讨论的是关于第一篇协同过滤之后的改进算法矩阵分解(MF),我会从多个方面讨论该算法的与案例以及它的优缺点。矩阵分解并不是某一种单一的...
  • 矩阵分解作用很多:矩阵填充(通过矩阵分解来填充原有矩阵,如als 就是填充原有矩阵),清理异常值与离群点,降维,压缩,个性化推荐,间接的特征组合(计算特征件相似度) ——————————————————...
  • 本篇博客将对矩阵分解进行介绍,同时介绍两种常用的用来解决矩阵分解问题的算法SGD(随机梯度下降)和ALS(交叉最小二乘)。这两种优化方法还能用来解决两种简单的推荐算法。 我们都将利用movielens数据集,对这些...
  • 矩阵分解模型(MF)

    2020-10-25 18:31:33
    协同过滤算法处理稀疏矩阵的能力比较弱,为增强泛化能力, 从协同过滤中衍生出矩阵分解模型(MF)或者叫隐语义模型。 隐语义模型最早在文本领域被提出,用于找到文本的隐含语义。2006年用于推荐中, 核心思想是通过...
  • 推荐系统之矩阵分解(MF)及其python实现

    千次阅读 多人点赞 2019-07-27 20:59:32
    目前推荐系统中用的最多的就是矩阵分解方法,在Netflix Prize推荐系统大赛中取得突出效果。以用户-项目评分矩阵为例,矩阵分解就是预测出评分矩阵中的缺失值,然后根据预测值以某种方式向用户推荐。今天以“用户-...
  • 矩阵分解(MF,SVD)和协同过滤(CF)

    万次阅读 2017-08-30 15:08:54
    本介绍了协同过滤算法中基于近邻的过滤,然后介绍了矩阵分解的SVD方法和公式推导,以及和PCA的关系。概率意义,求解方法。最后介绍了矩阵分解和Ridge回归的联系。
  • basic MF矩阵分解

    2019-12-11 22:55:23
    一 背景 对于推荐系统来说存在两大场景即评分预测(rating prediction)与Top-N推荐(item recommendation,item ranking...其中矩阵分解技术主要应用于该场景。Top-N推荐场景主要用于购物网站或者一般拿不到显式...
  • 一、基于投影梯度法的非负矩阵分解 论文:Projected gradient methods for non-negative matrix factorization  代码:Matlab及Python源码 二、基于类牛顿法的最小二乘矩阵近似解法 论文:Fast Newton-type ...

空空如也

空空如也

1 2 3 4 5 ... 13
收藏数 241
精华内容 96
关键字:

矩阵分解mf