《NAIS：Neural Attentive Item Similarity Model for Recommendation》

Posted 2023-05-02

参考技术A 在篇文章中，提出了一个神经网络模型Neural Attentive Item Similarity model（NAIS）基于项目的CF. 设计NAIS的关键是一个attention network，它能够 区分用户配置文件中哪些历史项对预测更重要 。 与最先进的基于项目的CF方法因子项相似性模型（FISM）相比，我们的NAIS具有更强的表示能力，只有少数附加参数由attention network带来。 两个公共基准的广泛实验证明了NAIS的有效性。 这项工作是第一次尝试设计基于CF神经网络模型，为神经推荐系统的未来发展开辟了新的研究可能性。

在本文中，大佬们提出了一个增强的项目相似性模型，通过 区分受影响项目的不同重要性 ，有助于用户的偏好。NAIS模型建立在FISM之上，在线预测的高效率方面保留了与FISM相同的优点，同时通过了解交互项目的不同重要性，比FISM更具表现力。

基于项目的CF的预测模型是：

其中 表示用户 已交互的项目集； 是一个0或者1的值，代表用户 是否与 有互动； 代表项目 和 的相似性。

 SLIM (shortfor Sparse LInear Method)——通过它来学习项目的相似性优化推荐感知目标函数。

目标函数来最小化如下：

其中， 代表用户的数量； 代表项目的数量； 代表项目之间的相似矩阵； 和 都是正则化参数。

SLIM是存在某些局限性的，因此提出了FISM：

其中， 是一种超参数，控制标准化效应， 表示embedding向量。

虽然FISM在基于项目的CF方法中提供了先进的性能，但作者们认为其表示能力可以通过在获得用户表示时对用户的所有历史项目的等同处理来限制。 但是这种假设对于真实世界的数据是违反直觉的，并且可能降低模型保真度。提出的NAIS模型 通过区分历史项目与神经注意网络的重要性 来解决FISM的这种局限性。

最初的关注点是模型的不同部分可以为最终预测做出不同的贡献（即参与）。 在基于项目的CF的场景中，我们可以通过为每个项目分配个性化的权重，直观地允许历史项目对用户的表示做出不同的贡献

其中 是一种可训练的参数，表示在预测用户 对目标项目 的偏好时项目 的attention权重。这就存在一个问题，如果一个项目对 从未在训练数据中共同发生（即，没有用户与 和 没有相互作用，则 就无法计算出来，估计将是一个微不足道的数字。

为了解决以上问题，作者们考虑把 与 相关联起来。这种参数化的优点是即使一对 从未共同发生过，只要从数据中可靠地学习了 ，它们仍然可以很好地估计 。

作者们考虑两种方式定义attention网络：

其中 和 分别是将输入投影到隐藏层的权重矩阵和偏向量，而 是将隐藏层投影到输出attention权重的向量。 将隐藏层的大小称为“attention factor”，其中较大的值为attention网络带来更强的表示能力。 使用Rectified Linear Unit（ReLU）作为隐藏层的激活函数。

把总体设计写成如下形式：

遗憾的是，作者们发现这种标准的解决方案在实践中并不能很好地发挥作用，后来意外地发现问题源于softmax功能。虽然使用softmax可以正确地标准化注意力。但是，这样的用户历史数据不再存在场景，自用户的历史长度（即历史数量）用户消费的项目可能有很大差异。定性说来，softmax函数执行L1归一化关注重量，可能会过度惩罚多数历史悠久的活跃用户。

我们建议平滑softmax，以减轻对活跃用户的attention惩罚，同时减少attention权重的差异。 形式上，NAIS的预测模型如下：

其中， 是平滑指数，设置在 范围内。当 设置为 时，它恢复了softmax功能; 当 小于 时，分母的值将被抑制，attention权重不会因为用户的活跃而受到过度惩罚。

损失函数：

其中 代表训练集数量。 将预测 ，就是用户 将与项目 交互的可能概率值。

此外，结构图如下所示。

时间复杂度分析。 评估NAIS预测的总时间复杂度可降为 ，是FISM的一倍。

实习个性化分析。 对于实时个性化，需要实时监控用户行为，用户在对某个商品交互后，实施推荐系统同时更新用户的推荐列表。因为重新训练整个模型不现实，一般都选择更新模型参数，然而因为用户行为可能并行发生，更新模型的固有参数会发生冲突，虽然可以通过分布式结构来解决但是分布式往往需要更多的消耗。本文的算法在实时问题上有很好的解决方式，首先用户的特征可以直接通过加法更新，时间消耗基本是常数级的。

attention功能的选择。 从公式中可以看出，本文设计了两种不同的注意力模型结构，一种是直接将 和 直接连接在一起，组成不同shape的特征矩阵，另一种则是计算 和 的点乘。前者保留了商品特征的原始结构，但是因为矩阵的结构发生变化可能导致网络难以收敛。后者的矩阵结构满足学习的目标，但是丢失了学习的商品特征。两种结构各有利弊，也是作者设计两种模型的原因。

数据集如下 ：

评估协议：

我们采用leave-one-out（留一法）来做评估。将每个用户的最新交互作为测试数据，并使用剩下的交互进行培训。具体而言，每个测试实例与99个随机采样的负实例配对；然后，每个方法输出100个实例的预测分数(1个正加上99个负)，以及每个测试实例性能由位置10的命中率(HR)和标准化的折扣累积增益(NDCG)来判断。其中HR@10可以被解释为一种基于召回的度量，它指示成功推荐的用户百分比。(也就是说，正实例出现在前10位)，NDCG@10是一种基于精度的度量方法，它说明了正实例的预测位置，越大越好。

对比的推荐系统方法有如下 ：Pop、Item KNN、FISM、MF-BPR、MF-eALS、MLP

参数设置：

对于每种方法，我们首先在没有正则化的情况下对其进行训练；如果观察到过拟合(即训练损失不断减少，但性能变差)，则调整正则化系数。 在 范围内。文中报告了NAIS在以下默认设置下的性能：1) ，2) ，3) ，4)Adagrad，学习速率为 ，5)预训练使用FISM嵌入。

上图显示了FISM的稳定性能和我们的两个NAIS方法在embedding大小为16的结果。当epoch大于2左右时，NAIS的HR和NDCG都远超过FISM。我们可以清楚地看到使用attention网络的有效性。

从上表可以看出，NAIS模型在两个数据集中的表现是最好的（embedding size=16）。下面我们来看看embedding size为其他的对比。

我们可以看到，性能趋势一般与embedding size=16的观察结果一致。我们的NAIS方法在大多数情况下都能达到最好的性能，唯一的例外是embedding size8，其中MLP的性能最好。这是因为当嵌入尺寸很小时，线性模型受到小embedding size的限制，而非线性模型则是有限的。ELS比线性模型更容易表现出更强的表示能力。

上图展现了无论attention因子的怎么设置，两种NAIS方法都优于FISM。在这两种方法中，NAIS-prod受attention因子的影响较小，而NAIS-concat受attention因子的影响较大。使用一个大型的 可以补偿两者之间的性能差距.这意味着使用表达模型来学习注意力权重是有用的。

上图是关于参数 设置的对比图，可以很明显地看到，当 时，NAIS开始出现大幅度地性能下降，这就验证了当时增加这个平滑指数的必要性。

参考：

论文调研--NAIS -TKDE2018 -

[CIKM2019] AutoInt: Automatic Feature Interaction Learning via Self-Attentive Neural Networks

像CTR预估这种任务在推荐系统或者在线广告当中十分常见，但是这个问题也非常具有挑战性，比如所使用的输入特征都是离散并且高维的，有效的预测依赖于高阶组合特征（又称交叉特征）。因此，人们一直在努力寻找稀疏和高维原始特征的低维表示及其有意义的组合。

这篇论文提出了AutoInt来学习高阶特征的交叉表示。并且提出了一个具有残差连接的多头自关注力神经网络，以明确地模拟低维空间中的特征互动。通过多头自关注神经网络的不同层，可以对输入特征的不同顺序组合进行建模，另外还可以提供更强的解释性。整个模型可以以端到端的方式在大规模原始数据上进行有效的拟合。

其他方法的缺点

这篇论文也提到了传统的FM模型的缺点，受到其多项式拟合时间的限制，它只对低阶特征的相互作用建模有效，而对高阶特征的相互作用则不切实际。

再就是兴起的深度模型的缺点，首先，全连接的神经网络在学习特征交叉的相互作用方面被证明是低效的。其次，由于这些模型是以隐含的方式学习特征的相互作用，它们对哪些特征组合是有意义的缺乏良好的解释。

因此，这篇论文正在寻找一种能够明确地对不同顺序的特征组合进行建模的方法，将整个特征表示为低维空间，同时提供良好的模型解释能力。

这篇论文能够处理分类特征和数字特征，具体来说，分类和数字特征首先被嵌入到低维空间中，这就降低了输入特征的维度，同时允许不同类型的特征通过向量运算相互影响。

内容

这篇论文以CTR预估作为问题的背景，首先是一些基本的定义，将用户向量\\(u\\)和物品向量\\(v\\)进行级联成新的向量\\(x\\)，通过这个向量\\(x\\)对用户点击物品的概率进行估计。一种最直接最简单的办法就是直接把向量\\(x\\)当成输入特征进行逻辑回归。然而，通常来说，向量\\(x\\)一般是稀疏的并且高维的，非常容易过拟合。因此，将输入特征在低维空间进行表示是很有必要的。

然后这里定义了p-order Combinatorial Feature，我这里翻译为p阶组合特征。假设我们有输入向量\\(x\\in \\mathbb{R}^n\\)，那么我们定义p阶组合特征为\\(g(x_{i_1},x_{i_1},...,x_{i_p})\\)，其中，\\(g(\\cdot)\\)代表非加性函数，可以使叉乘或者点乘等操作。\\(g(\\cdot)\\)对多少个特征点进行操作，所得到的结果就是多少阶。这很好理解。

这里目标就有两个，生成有效的高阶特征向量，并且映射到低维空间当中。

AutoInt可以自动学习特征交叉的过程，编码成能够将不同的特征域映射到相同的低维特征空间当中，然后将映射后的特征送入到注意力层当中学习特征交叉，不同的特征交叉的效果通过映射，投影到不同的子空间中的方式由注意力机制进行评价。

如下图所示，是本篇论文AutoInt的模型图。

输入层

我们接着介绍上图的每一层，从下到上首先是输入层

\\[\\mathbf{x}=[\\mathbf{x_1};\\mathbf{x_2};...;\\mathbf{x_M}] \\]

如果\\(\\mathbf{x_i}\\)是种类的话，就使用one-hot向量进行表示，如果\\(\\mathbf{x_i}\\)是数值类型的话，我们就使用标量进行表示。

编码层

然后是编码层，由于种类特征是使用one-hot这种稀疏的特征进行表示的，我们对每个种类特征进行了映射编码，

\\[\\mathbf{e_i}=\\mathbf{V_i}\\mathbf{x_i} \\]

那么，\\(\\mathbf{V_i}\\)在这里就是编码矩阵。

这里也会有一种情况出现，那就是可能输入的种类特征是multi-hot向量表示的，比如从属多个类别，那么映射的函数发生了一点修改，

\\[\\mathbf{e_i}=\\frac{1}{q}\\mathbf{V_i}\\mathbf{x_i} \\]

这里的\\(q\\)表示了multi-hot特征向量中有多少个值。

为了使得种类特征和数值型特征能够进行交互，那么我们需要将数值型特征也映射到相同的低维空间当中。那么方程可以表示为

\\[\\mathbf{e_m}=\\mathbf{v_m}x_m \\]

其中，\\(x_m\\)是数值型的特征。那么，所有的编码层工作都介绍完毕。

交互层

本文使用的是多头自注意力网络，它在对复杂关系进行建模时有着良好的表现。这篇论文用了Key-Value注意力网络来决定哪些特征组合是有意义的。我们以特征\\(m\\)举例来说，我们首先定义在明确的注意力头\\(h\\)下的特征\\(m\\)与特征\\(k\\)之间的关系：

\\[\\alpha_{\\mathbf{m,k}}^{(\\mathbf{h})}=\\frac{\\exp(\\psi^{(h)}(\\mathbf{e_m,e_k}))}{\\sum_{l=1}^{M}\\exp(\\psi^{(h)}(\\mathbf{e_m,e_l}))} \\]

\\[\\psi^{(h)}(\\mathbf{e_m,e_k})=<\\mathbf{W_{Query}^{(h)}e_m,W_{Key}^{(h)}e_k}> \\]

这里的\\(\\psi(\\cdot)\\)指的是注意力函数，用来表示两个特征的相似性，可以用神经网络表示，或者简单地内积也可以。这篇论文使用了内积的形式。这两个\\(\\mathbf{W}\\)是权重矩阵，或者说是转换矩阵，将特征向量投影到新的空间当中。然后我们用所有相关的特征在注意力头\\(h\\)下对特征\\(m\\)进行更新

\\[\\mathbf{\\widetilde{e}_m^{h}}=\\sum_{k=1}^{M}\\alpha_{\\mathbf{m,k}}^{(\\mathbf{h})}(\\mathbf{W_{Value}^{(h)}e_k}) \\]

上述特征包含了特征\\(m\\)以及相关特征（在注意力头\\(h\\)的作用下）的一种组合表示，这样我们就可以得到在不同子空间当中新的离散特征交互的表示方式。

我们把所有注意力头学习的特征进行组合：

\\[\\mathbf{\\widetilde{e}_m}=\\mathbf{\\widetilde{e}_m^{(1)}}\\oplus\\mathbf{\\widetilde{e}_m^{(2)}}\\oplus\\cdots\\oplus\\mathbf{\\widetilde{e}_m^{(H)}} \\]

这里的\\(\\oplus\\)代表的级联操作，\\(H\\)表示的注意力头的数量。

为了保持原有的学习到的组合特征，这里就加入了喜闻乐见的残差表示，那么公式发生了进行了进一步变化：

\\[\\mathbf{\\widetilde{e}_m^{RES}}=ReLU(\\mathbf{\\widetilde{e}_m}+W_{Res}\\mathbf{e_m}) \\]

这样通过交互层的特征就被完整的表示了出来。这种交互的层可以进行叠加，形成随意阶的组合特征。整个交互层可以通过如下图进行表示。

输出层

交互层的输出是从残差模块里面的原生特征以及经过多头注意力机制的组合特征，为了进行CTR预估，我们简单地将他们进行级联（concatenate）操作，然后进行一次非线性映射进行预测。

\\[\\hat y=\\sigma(\\mathbf{w^T}(\\mathbf{e_{1}^{Res}}\\oplus\\mathbf{e_{2}^{Res}}\\oplus\\cdots\\oplus\\mathbf{e_{M}^{Res}})+b) \\]

训练

这里的优化目标就是log损失函数：

\\[Logloss=-\\frac{1}{N}\\sum_{j=1}^{N}(y_j\\log(\\hat y_j)+(1-y_j)\\log(1-\\hat y_j)) \\]

在这里所需要优化的目标就是各种投影方程以及偏置项。

代码

import torch
import torch.nn as nn
import torch.nn.functional as F
from torch.nn.init import xavier_normal_, constant_

from recbole.model.abstract_recommender import ContextRecommender
from recbole.model.layers import MLPLayers

class AutoInt(ContextRecommender):
    """ AutoInt is a novel CTR prediction model based on self-attention mechanism,
    which can automatically learn high-order feature interactions in an explicit fashion.

    """

    def __init__(self, config, dataset):
        super(AutoInt, self).__init__(config, dataset)

        # load parameters info
        self.attention_size = config[\'attention_size\']
        self.dropout_probs = config[\'dropout_probs\']
        self.n_layers = config[\'n_layers\']
        self.num_heads = config[\'num_heads\']
        self.mlp_hidden_size = config[\'mlp_hidden_size\']
        self.has_residual = config[\'has_residual\']

        # define layers and loss
        self.att_embedding = nn.Linear(self.embedding_size, self.attention_size)
        self.embed_output_dim = self.num_feature_field * self.embedding_size
        self.atten_output_dim = self.num_feature_field * self.attention_size
        size_list = [self.embed_output_dim] + self.mlp_hidden_size
        self.mlp_layers = MLPLayers(size_list, dropout=self.dropout_probs[1])
        # multi-head self-attention network
        self.self_attns = nn.ModuleList([
            nn.MultiheadAttention(self.attention_size, self.num_heads, dropout=self.dropout_probs[0])
            for _ in range(self.n_layers)
        ])
        self.attn_fc = torch.nn.Linear(self.atten_output_dim, 1)
        self.deep_predict_layer = nn.Linear(self.mlp_hidden_size[-1], 1)
        if self.has_residual:
            self.v_res_res_embedding = torch.nn.Linear(self.embedding_size, self.attention_size)

        self.dropout_layer = nn.Dropout(p=self.dropout_probs[2])
        self.sigmoid = nn.Sigmoid()
        self.loss = nn.BCELoss()

        # parameters initialization
        self.apply(self._init_weights)

    def _init_weights(self, module):
        if isinstance(module, nn.Embedding):
            xavier_normal_(module.weight.data)
        elif isinstance(module, nn.Linear):
            xavier_normal_(module.weight.data)
            if module.bias is not None:
                constant_(module.bias.data, 0)

    def autoint_layer(self, infeature):
        """ Get the attention-based feature interaction score

        Args:
            infeature (torch.FloatTensor): input feature embedding tensor. shape of[batch_size,field_size,embed_dim].

        Returns:
            torch.FloatTensor: Result of score. shape of [batch_size,1] .
        """

        att_infeature = self.att_embedding(infeature)
        cross_term = att_infeature.transpose(0, 1)
        for self_attn in self.self_attns:
            cross_term, _ = self_attn(cross_term, cross_term, cross_term)
        cross_term = cross_term.transpose(0, 1)
        # Residual connection
        if self.has_residual:
            v_res = self.v_res_embedding(infeature)
            cross_term += v_res
        # Interacting layer
        cross_term = F.relu(cross_term).contiguous().view(-1, self.atten_output_dim)
        batch_size = infeature.shape[0]
        att_output = self.attn_fc(cross_term) + self.deep_predict_layer(self.mlp_layers(infeature.view(batch_size, -1)))
        return att_output

    def forward(self, interaction):
        autoint_all_embeddings = self.concat_embed_input_fields(interaction)  # [batch_size, num_field, embed_dim]
        output = self.first_order_linear(interaction) + self.autoint_layer(autoint_all_embeddings)
        return self.sigmoid(output.squeeze(1))

    def calculate_loss(self, interaction):
        label = interaction[self.LABEL]
        output = self.forward(interaction)
        return self.loss(output, label)

    def predict(self, interaction):
        return self.forward(interaction)