【DW推荐系统论文组队task1--NCF】

本文的创新点

总体原理：NCF模型基于神经网络可以学习任意函数的原理，用多层感知机来学习一个用户-项目的交互函数，代替传统CF任务中用来计算用户对目标项目预测分数的内积的方法（inner product）

1. 通过神经网络的结构来建模用户和项目的潜在特征，并将其用于CF任务
2. 将传统的方法MF和NCF联系起来，将MF方法变成了NCF的一个特例（注：MF即矩阵因子分解，通过用户、项目的ID信息构建embedding，然后对用户-项目交互矩阵做矩阵分解，通过这种方式得到潜在特征，但是得到的是低维特征），NCF使用多层感知机来发掘用户-项目之间的高维特征
3. 将多层感知机学习到的信息作为传统MF低维信息的一个补充，最终为用户、项目学习到一个更好的embedding，其中蕴含了更多的潜在特征

NOTE：本文附录的代码引用自Datawhale推荐系统论文组队学习task1中的代码实现

一、INTRODUCTION

文章首先介绍了在大规模使用神经网络之前最受欢迎的MF（matrix factorization） 技术，其主要原理是:
将用户和项目的ID信息映射到一个共享的潜在空间(latent space)里面（本质就是将一个矩阵分解成若干矩阵，因为矩阵代表的就是线性空间中的线性变换），然后在这个空间里面使用一个向量来表示用户和项目，然后使用向量内积的方式来表示用户和项目之间的交互情况。

虽然有一些模型使用了深度神经网络DNN来进行推荐任务的研究，但是这些模型只是建模了一些辅助信息，在衡量用户-项目的潜在特征的关系时还是基于MF的内积的方式，于是本文为了解决这些问题，提出了NCF模型来学习用户-项目之间的潜在关系，代替了MF中的内积的方式。

二、PRELIMINARIE

2.1 从隐式数据中学习

定义Y是一个M*N的用户-项目交互矩阵，矩阵中的元素根据用户和项目之间是否存在交互关系来定义，即：
$$y_{ui}=\{\begin{array}{ll}1,& \text{ if interaction ( user }u,\text{ item }i\text{ ) is observed }\\ 0,& \text{ otherwise. }\end{array}$$
用一个具体例子来演示：

需要注意的是，$y_{\text{ui }}$=1不代表用户真的喜欢这个物品，反之$y_{\text{ui }}$=0也不代表用户不喜欢目标物品，可能只是单纯的缺失数据。这也是隐式数据的一个特点，即数据的缺失（或者说用户单纯还不知道这个物品）导致了负反馈的缺失。
所以一个基于隐式反馈的推荐问题就可以被定义为对这些和用户没有交集的（即$y_{\text{ui }}$=0）的项目的评分预测

2.2 矩阵因子分解（MF）

基本原理：
将每个用户和物品和一个潜在特征的实值向量联系起来，分别定义为${\mathbf{p}}_u$和${\mathbf{q}}_i$，然后使用内积的方式来估算一个用户对一个项目的喜爱程度（可以理解为评分）：
$${\hat{y}}_{ui}=f\left(u,i\mid {\mathbf{p}}_u,{\mathbf{q}}_i\right)={\mathbf{p}}_u^T{\mathbf{q}}_i=\sum _{k=1}^K{p}_{uk}{q}_{ik}$$
其中${\hat{y}}_{ui}$代表预测评分，K是隐式空间的维度
下图是根据上一章节使用的用户-项目交互矩阵的例子，生成的一个用户的隐式空间：
（所谓隐式空间的本质就是个线性空间）

MF方法的局限性：
在低维的隐式空间中建模用户、项目的embedding，而且使用简单、不够灵活的内积的方式来估计复杂的用户-项目之间的关系（内积的方式是对用户、项目向量中元素的简单的线性组合）。虽然可以通过增加隐式空间的维度来提升推荐效果，但是在数据稀疏的情况下，会导致过拟合。

三、NCF Model

用文中的模型图来概括NCF模型：

上图的模型最终得到的预测结果可以用公式表示：

$${\hat{y}}_{ui}=f\left({\mathbf{P}}^T{\mathbf{v}}_u^U,{\mathbf{Q}}^T{\mathbf{v}}_i^I\mid \mathbf{P},\mathbf{Q},{\Theta }_f\right)$$

其中$\mathbf{P}\in {\mathbb{R}}^{M\times K}$和$\mathbf{Q}\in {\mathbb{R}}^{N\times K}$各自代表将用户和项目映射到隐式空间的矩阵，${\Theta }_f$代表预测函数f的中的可学习的参数。

其中$f\left({\mathbf{P}}^T{\mathbf{v}}_u^U,{\mathbf{Q}}^T{\mathbf{v}}_i^I\right)$可以定义如下：

$$f\left({\mathbf{P}}^T{\mathbf{v}}_u^U,{\mathbf{Q}}^T{\mathbf{v}}_i^I\right)={\varphi }_{\text{out }}\left({\varphi }_X\left(\dots {\varphi }_2\left({\varphi }_1\left({\mathbf{P}}^T{\mathbf{v}}_u^U,{\mathbf{Q}}^T{\mathbf{v}}_i^I\right)\right)\dots \right)\right)$$

其中${\varphi }_{\text{out }}$和${\varphi }_{\text{x }}$分别代表最后的输出层的激活函数和第x层的全连接层。

接下来详细介绍一下子模型的各层：

3.1 Input layer

输入层是根据用户、项目的ID顺序得到的独热编码，作为输入向量进行模型

3.2 Embedding layer

利用上述公式中的$\mathbf{P}\in {\mathbb{R}}^{M\times K}$和$\mathbf{Q}\in {\mathbb{R}}^{N\times K}$将输入层的独热编码进行映射得到一个初始的用户和项目的embedding，P，Q矩阵都是可以通过反向传播进行学习的

3.3 Neural CF layer 和 output layer

本质就是通过若干全连接层来逼近训练数据的真实概率分布（即最终得到的模型），层数不易过深，不然就会导致过拟合，其中的传播函数为：
$$\begin{array}{rl}{\mathbf{z}}_1& ={\varphi }_1\left({\mathbf{p}}_u,{\mathbf{q}}_i\right)=\left[\begin{array}{l}{\mathbf{p}}_u\\ {\mathbf{q}}_i\end{array}\right],\\ {\varphi }_2\left({\mathbf{z}}_1\right)& =a_2\left({\mathbf{W}}_2^T{\mathbf{z}}_1+{\mathbf{b}}_2\right),\\ & \cdots \cdots \\ {\varphi }_L\left({\mathbf{z}}_{L-1}\right)& =a_L\left({\mathbf{W}}_L^T{\mathbf{z}}_{L-1}+{\mathbf{b}}_L\right),\\ {\hat{y}}_{ui}& =\sigma \left({\mathbf{h}}^T{\varphi }_L\left({\mathbf{z}}_{L-1}\right)\right),\end{array}$$
主要过程就是先将初始生成的embedding做拼接，然后再输入到MLP中学习用户-项目的高维度关系，然后直接得到最终的预测分数，而不是通过内积的方式，其中${\hat{y}}_{ui}$就是最终的预测函数

四、GMF模型

本小节在整篇文章中的意义是证明NCF模型可以泛化到传统的MF模型中。
用${\mathbf{p}}_u$和${\mathbf{q}}_i$分别代替NCF传播公式中的${\mathbf{P}}^T{\mathbf{v}}_u^U,{\mathbf{Q}}^T{\mathbf{v}}_i^I$，然后设计一个GMF模型：
定义第一层CF层为：
$${\varphi }_1\left({\mathbf{p}}_u,{\mathbf{q}}_i\right)={\mathbf{p}}_u\odot {\mathbf{q}}_i$$
最终预测评分的公式为：
$${\hat{y}}_{ui}=a_{out}\left({\mathbf{h}}^T\left({\mathbf{p}}_u\odot {\mathbf{q}}_i\right)\right)$$
而传统的MF计算最终预测评分的公式为：
$${\hat{y}}_{ui}=f\left(u,i\mid {\mathbf{p}}_u,{\mathbf{q}}_i\right)={\mathbf{p}}_u^T{\mathbf{q}}_i=\sum _{k=1}^K{p}_{uk}{q}_{ik}$$
所以从上面两个式子对比可以看到，如果将GMF模型的预测函数中的$a_{out}$设置为等值函数（f(x) = x），将${\mathbf{h}}^T$设置为单位向量（即元素都为1），那么GMF模型就会退化变成MF模型，所以NCF模型可以泛化MF模型，MF模型是NCF模型基于线性关系的一个特例。

五、损失函数

本模型使用的损失函数是BPR损失函数，这种损失函数的核心思想是尽可能的扩大正样本（用户有过交互历史的）和负样本（无交互历史的）之间的评分差距，因为其认为用户曾经有过交互的项目评分应该比没有交互的评分要高
$$\text{ Loss }=\sum _{(u,i,j)\in O}-\ln \sigma (y(u,i)-y(u,j))+\beta \cdot \Vert \Theta {\Vert }^2$$
其中y(u,i)和y(u,j)各自代表用户对交互过的项目的预测评分，和没有交互过的项目的预测评分，$\theta$代表模型中的所有参数，$\beta$是L2正则化参数

六、CONCULSION

NCF模型之所以能够取得性能上的提升，主要思想是在MF将用户和项目的独热编码映射到隐式空间得到初始embedding之后，利用多层感知机能够逼近任意函数的原理去逼近训练数据的真实分布，从而学习到用户和项目的embedding之间的关系，然后取代了MF中使用的内积的方法，直接得出了用户对某一项目的分数预测结果。
本模型将MF的线性以及MLP的非线性进行了结合，通过MLP对高维特征的学习能力来弥补MF在高维隐式空间中学习能力不足的问题，本文是神经网络引入到CF任务中的一篇里程碑式的论文，对后续的NGCF，LightGCN等经典的基于图神经网络的CF模型都有着启发意义。

附录（NCF模型基于paddle的代码实现）

下面展示一些 内联代码片。

class NCF(paddle.nn.Layer):
    #模型初始化
    def __init__(self,
                embedding_dim = 16,#用户，物品的embedding维度，即向量的维度
                vocab_map = None,
                loss_fun = 'nn.BCELoss()'):#选用的损失函数
        super(NCF, self).__init__()#继承nn父类
        self.embedding_dim = embedding_dim
        self.vocab_map = vocab_map#映射表
        self.loss_fun = eval(loss_fun) # self.loss_fun  = paddle.nn.BCELoss()
        
        self.user_emb_layer = nn.Embedding(self.vocab_map['user_id'],
                                          self.embedding_dim)#模型图中的用户embedding生成层
        self.item_emb_layer = nn.Embedding(self.vocab_map['item_id'],
                                          self.embedding_dim)#模型图中的项目embedding生成层
        

        """
        模型结构中的mlp层
        """
        self.mlp = nn.Sequential(
            nn.Linear(2*self.embedding_dim,self.embedding_dim),#一个全连接层，linear(a,b),a是输入层维度，b是输出层维度
            nn.ReLU(), #非线性激活函数Relu
            nn.BatchNorm1D(self.embedding_dim), #批归一化层，可以加快模型的收敛速度和稳定性                                                                                                                 
            nn.Linear(self.embedding_dim,1),#又是一个全连接层，输出维度是1，代表这个全连接层是最后的输出层
            nn.Sigmoid() #sigmod激活函数，把全连接层的结果压缩到（0,1）区间之内，得出一个概率值
        )
    """
    向前传播函数
    """
    def forward(self,data):
        user_emb = self.user_emb_layer(data['user_id']) # [batch,emb] ，生成了用户的输入embedding
        item_emb = self.item_emb_layer(data['item_id']) # [batch,emb]， 生成了项目的输入embedding
        mlp_input = paddle.concat([user_emb, item_emb],axis=-1).squeeze(1)#经过全连接层生成最后的输出
        y_pred = self.mlp(mlp_input) #最终的预测值
        if 'label' in data.keys():
            loss = self.loss_fun(y_pred.squeeze(),data['label'])
            output_dict = {'pred':y_pred,'loss':loss}
        else:
            output_dict = {'pred':y_pred}
        return output_dict