序列推荐_第一序列排名

note

• Comirec-SA基于attention的多兴趣建模，论文中先通过attention提取单一兴趣，再推广到多兴趣建模。另外使用贪心算法优化带有准确度+多样性的目标函数。
• DR把MIND的attention换成argmax（还有初始化方式不同、序列胶囊到兴趣胶囊用可学习权重矩阵替代的不同），SR则本质是多头注意力进行多兴趣建模。
• torch.einsum（Einstein summation convention，即爱因斯坦求和约定）可以写tensor运算和更高维度tensor写法更加简洁，如用torch.einsum("bij, bjk -> bik", batch_tensor_1, batch_tensor_2)进行batch内矩阵乘法运算。
• 注意力机制中最后对第一个维度seq进行sofjtmax归一化，即使得seq维度的元素之和为1。因为对于固定序列中不存在的位置负无穷mask掉了，所以缺失的位置经过softmax归一化后的数值为0。$$\mathrm{Softmax}\left(x_i\right)=\frac{\exp \left(x_i\right)}{{\sum }_j\exp \left(x_j\right)}$$

一、Comirec模型概览

第一部分和task5差不多，是同一篇论文Comirec-SA用self-attentive method代替之前DR多兴趣抽取层，

Comirec：Controllable Multi-Interest Framework for Recommendation
论文链接：https://arxiv.org/abs/2005.09347

Comirec是阿里发表在KDD 2020上的一篇工作，这篇论文对MIND多行为召回进行了扩展：

• 一方面改进了MIND中的动态路由算法，
• 另一方面提出了一种新的多兴趣召回方法，同时对推荐的多样性层面也做出了一定的贡献，通过一种贪心的做法，在损失较小的推荐效果的情况下可以显著的提高推荐的多样性(感觉非常非常牵强，我们这里就不介绍这个了)，从而极大的提高用户的使用体验，可以更进一步的探索用户的潜在兴趣。

1.1 Notation

假设一个用户集合 $u\in \mathcal{U}$ 和一个物品集合 $i\in \mathcal{I}$, 对于每一个用户, 定义用户序列 $\left(e_1^{(u)},e_2^{(u)},\dots ,e_n^{(u)}\right)$, 根据时间先后顺序排序，其中$e_t^{(u)}$ 记录了第 $t$ 个物品与用户交互。

1.2 模型框架

Comirec流程：

• 用户历史交互item ids经过embedding layer转为item embeddings；
• 把刚才的item embedding经过多兴趣抽取层（这里是self-attentive模块），得到K个interest embeddings；
• training：和之前MIND说的做法一样（取内积最大值），即选出与target item embedding最接近的interest embeddings，基于多分类任务，使用负采样sampled softmax loss；
• serving（predict）：对于每个用户的K个interest embedding进行top-N检索，即召回K X N个item。
• aggregation module：将K X N个item送入该模块得到N个item（选内积分数最高的N个，和MIND做法一致）：$$f(u,i)=\underset{1\le k\le K}{\max }\left({\mathbf{e}}_i^{\top }{\mathbf{v}}_u^{(k)}\right)$$

1.3 model training

和1.1说的一样，某用户经过多兴趣提取层后得到K个interest embeddings后，从中找出和target item i（即下面embedding为$e_i$）最接近，即内积最大的一个interest embeeding，方法如下$${\mathbf{v}}_u={\mathbf{V}}_u\left[:,\mathrm{argmax}\left({\mathbf{V}}_u^{\top }{\mathbf{e}}_i\right)\right],$$
和之前一样是结合负采样的最大似然法（后面代码用少量数据，直接交叉熵损失函数）。给出一个训练样本 $(u,i)$, 用户embedding ${\mathbf{v}}_u$, 和物品embedding ${\mathbf{e}}_i$，则用户与物品交互的似然函数：
$$P_{\theta }(i\mid u)=\frac{\exp \left({\mathbf{v}}_u^{\top }{\mathbf{e}}_i\right)}{{\sum }_{k\in I}\exp \left({\mathbf{v}}_u^{\top }{\mathbf{e}}_k\right)}$$
目标为最小化该似然函数：
$$\text{ loss }=\sum _{u\in \mathcal{U}}\sum _{i\in I_u}-\log P_{\theta }(i\mid u)$$

二、Comirec-SA模型

2.0 数据集划分

原论文是按照8:1:1划分训练集、验证集、测试集（按照用户划分，更具泛化能力）。

• 训练样本：全部点击序列$\left(e_1^{(u)},e_2^{(u)},\dots ,e_k^{(u)},\dots ,e_n^{(u)}\right)$，用前（n-1）个item预测第n个；
• 验证集合测试集则是使用用户前80%的点击序列作为模型输入，然后预测后面的点击序列。
• 在验证集合测试集中的用户是从未在训练集中出现过的。

2.1 基于Attention的单一兴趣建模

• 将用户的行为序列计作 $H\in {\mathbb{R}}^{d\times n}$,
  • 这里的 $n$ 表示用户行为序列的长度,
  • $d$ 表示Embedding向量的维度,
  • 这里的 $H$ 就代表着用户行为序列中所有Item的Embedding向量,
• 这里引入两个可学习参数 $W_1\in {\mathbb{R}}^{d_a\times d},w_2\in {\mathbb{R}}^{d_a}$, 通过引入Attention机制进行加权求和，凸显重要性高的特征。

在我们的Comirec-SA中, 我们的特征重要性 (也就是我们学习出来的Attention Score) 是针对序列中每个Item的Attention Score, 在有了Attention Score之后就可以对序列中的|tem进行加权求和得到序列的单一兴趣表征了。单一兴趣建模时的Attention Score计算:
$$a=\mathrm{softmax}{\left(w_2^T\tanh \left(W_{1}H\right)\right)}^T$$

• $a\in {\mathbb{R}}^n$, 这里的 $a$ 就是我们对序列的Attention Score（权重向量）, 再将 $a$ 与序列的所有Item的Embedding进行加权求和就可以得到单一兴趣的建模。

2.2 基于Attention的多兴趣建模

可以把 $1.1$单一兴趣建模中的 $w_2\in {\mathbb{R}}^{d_a}$ 扩充至 $W_2\in {\mathbb{R}}^{d_a\times K}$（可训练化参数）, 这里是因为在输入embedding中加入了可训练的position embedding，其维度和item embedding的维度一样都是$d$。

Attention Score的计算公式就变成:
$$A=\mathrm{softmax}{\left(W_2^T\tanh \left(W_{1}H\right)\right)}^T$$
其中：

• $A\in {\mathbb{R}}^{n\times K}$,
• 权重$W_2\in {\mathbb{R}}^{d_a\times K}$
• K是兴趣向量个数

这时我们可以通过如下式子得到用户的多兴趣表征：
$$V_u=HA$$
其中：

• ${\mathbf{H}}^{d\times n}$：用户行为序列的embedding矩阵，其中$n$为用户行为序列的长度，$d$为item embedding维度；
• $V_u\in {\mathbb{R}}^{d\times K}$, 即为 $\mathrm{K}$ 个兴趣表征, 其核心代码如下:

class MultiInterest_SA(nn.Layer):
    def __init__(self, embedding_dim, interest_num, d=None):
        super(MultiInterest_SA, self).__init__()
        self.embedding_dim = embedding_dim
        self.interest_num = interest_num
        if d == None:
            self.d = self.embedding_dim*4

        self.W1 = self.create_parameter(shape=[self.embedding_dim, self.d])
        self.W2 = self.create_parameter(shape=[self.d, self.interest_num]) 

    def forward(self, seq_emb, mask = None):
        ''' seq_emb : batch,seq,emb mask : batch,seq,1 '''
        H = paddle.einsum('bse, ed -> bsd', seq_emb, self.W1).tanh()
        mask = mask.unsqueeze(-1)
        A = paddle.einsum('bsd, dk -> bsk', H, self.W2) + -1.e9 * (1 - mask)
        A = F.softmax(A, axis=1)
        A = paddle.transpose(A,perm=[0, 2, 1])
        multi_interest_emb = paddle.matmul(A, seq_emb)
        return multi_interest_emb

首先来回顾单头和多头的注意力：

（1）K-Q-V注意力

1）自注意力机制

自注意力是指键(K)、查询(Q)和值(V)来自同一数据来源，即 K=Q=V。

Transformer 以特定方式执行此操作:
令 $x_1,x_2,\cdots ,x_T$ 是 Transformer 编码器的输入向量, 其中 $x_i\in R^d$, 则键 $(K)$ 、查询 $(Q)$ 、值 $(V)$ 是:
$$\begin{array}{rl}{k}_i& =K{x}_i\\ q_i& =Q{x}_i\\ v_i& =V{x}_i\end{array}$$

• 其中: 矩阵 $K\in R^{d\times d};Q\in R^{d\times d};V\in R^{d\times d}$ 。
• 这些矩阵允许将x向量的不同方面用于三个角色的每一个。

2）计算 K-Q-V 注意力（矩阵形式）：

令 $\mathrm{X}=\left[x_1,x_2,\cdots ,x_T\right]\in {\mathrm{R}}^{\mathrm{T}\times \mathrm{d}}$ 是输入向量的串联(拼接), 其中:

• $XK\in R^{T\times d},XQ\in R^{T\times d},XV\in R^{T\times d}$ 。
• 输出定义为: output = $\mathrm{softmax}\left(XQ(XK{)}^{\mathrm{T}}\times XV\right)$
• 即计算过程：首先, 在一个矩阵乘法中取查询和键的点积, 得到: $XQ(XK{)}^{\mathrm{T}}$；其次, 对上述结果进行 softmax 计算, 再乘以矩阵 $XV$, 得到: $\mathrm{softmax}\left(XQ(XK{)}^{\mathrm{T}}\right)\times XV$ ,如下图的（a）。

如果想一次查询（Q）句子中的多个位置：
对于单词 $\mathrm{i}$， self-attention 只 “看” $x_i^T{Q}^{T}K{x}_j$ 分数高的地方, 即单头注意力, 见上图的（b） 。但是, 若出于不同的原因想要关注不同的 $\mathrm{j}$，则可通过多个 $\mathrm{Q}、\mathrm{K}、\mathrm{V}$ 矩阵来定义多个注意力 “头”：

令: $Q_l,K_l,V_l\in R^{d\times d/h}$, 其中 $h$ 是注意力头的数量, $l$ 的范围从 1 到 $h$，则: 每个注意力头独立地计算注意力:$${\text{ output }}_l=\mathrm{softmax}\left(X{Q}_l{K}_l^T{X}^T\right)\ast X{V}_l$$

其中:output ${}_l\in R^{d/h}$

然后合并所有头的输出:$$\text{ output }=Y{\text{ [output }}_1,\dots ,{\text{ output }}_h\text{ ] }$$

其中: $Y\in R^{d\times d}$

因此, 每个头都可以 “看” 不同的事物, 并以不同的方式构建值 ( $\mathrm{V}$ ) 向量。多头注意力和单头自注意力有相同的计算量。最简单的多头注意力，即两头注意力（如上图的c）。

2.3 多样性控制

为了强化推荐item的多样性，作者将item的类别作为衡量多样性的基础。

问题定义：给定从用户 $u$ 的 $K$ 个兴趣中检索到一个集合 $\mathcal{M}$, 有 $K\cdot N$ 个物品, 找到一个输出集合 $\mathcal{S}$, 有 $N$ 个 物品 (Top-N) , 使预定义的值函数$Q(u,\mathcal{S})$最大化。

（1）多样性：作者使用$g(i,j)$用来衡量两个Item i， j之间的多样性：
$$g(i,j)=\sigma (CATE(i)\ne CATE(j))$$

• $CATE(i)$ 表示物品 $i$ 的类别
• $\sigma$ 为指示函数，这里就是如果两个item的类别不相同，那么其结果就是 1 , 反之就是 0
• 可以看出如果一个推荐集合中两两Item的多样性得分大的话, 那么可以认为这个推荐结果中的Item的类别分布较为分散, 也就可以认为推荐结果的多样性较高了,

（2）推荐精度：当推荐结果的多样性较高的时候, 往往推荐的精度就会下降, 这是一个Trade Off，可以构造如下的目标函数（包含多样性指标和推荐精度指标）：$$Q(u,\mathcal{S})=\sum _{i\in \mathcal{S}}f(u,i)+\lambda \sum _{i\in \mathcal{S}}\sum _{j\in \mathcal{S}}g(i,j)$$

• 通过 $\lambda$ 来控制这两部分的占比, $\lambda$ 越大则多样性更强，同事准确度会降低；
• 作者这里提出使用一种贪心的做法来进行目标函数的优化, 优化流程如下:

三、代码实践

3.1 MultiInterest_SA类定义

如上面介绍的SA运算：
$$A=\mathrm{softmax}{\left(W_2^T\tanh \left(W_{1}H\right)\right)}^T$$
可以得到 $A\in {\mathbb{R}}^{n\times K}$, 这时我们可以通过如下式子得到用户的多兴趣表征：
$$V_u=HA$$
注意：

• 两个维度不同的tensor也可以“做加减法”（指的是代码中的写法）, 比如[256, 20, 4]的tensor-[256, 20, 1]的tensor，后者会减在全部（4个）第2维度之上。
• 下面这里的paddle.einsum函数在tf和torch中都有，einsum（Einstein summation convention，即爱因斯坦求和约定）可以写tensor运算和更高维度tensor写法更加简洁。torch版本的多兴趣抽取层SA代码如下。
• 最后对第一个维度seq进行sofjtmax归一化，即使得seq维度的元素之和为1。因为对于固定序列中不存在的位置负无穷mask掉了，所以缺失的位置经过softmax归一化后的数值为0。$$\mathrm{Softmax}\left(x_i\right)=\frac{\exp \left(x_i\right)}{{\sum }_j\exp \left(x_j\right)}$$

class MultiInterest_SA(nn.Module):
    def __init__(self, embedding_dim, interest_num, d=None):
        super(MultiInterest_SA, self).__init__()
        self.embedding_dim = embedding_dim
        self.interest_num = interest_num
        if d == None:
            self.d = self.embedding_dim*4

        # self.W1 = self.create_parameter(shape=[self.embedding_dim, self.d])
        # self.W2 = self.create_parameter(shape=[self.d, self.interest_num])
        self.W1 = Parameter(torch.Tensor(self.embedding_dim, self.d))
        self.W2 = Parameter(torch.Tensor(self.d, self.interest_num))

    def forward(self, seq_emb, mask = None):
        ''' seq_emb : batch,seq,emb mask : batch,seq,1 '''
        H = torch.einsum('bse, ed -> bsd', seq_emb, self.W1).tanh()
        mask = mask.unsqueeze(-1)  # (batch, seq) -> (batch, seq, 1)
        # einsum 爱因斯坦求和约定
        # (batch_size, seq_len, interest_num) - (batch_size, seq_len, 1)负无穷,
        # 两个维度不同可以做减法, 比如[256, 20, 4]-[256, 20, 1]，后者会减在4个 全部之上
        A = torch.einsum('bsd, dk -> bsk', H, self.W2) + -1.e9 * (1 - mask)
        A = F.softmax(A, dim=1)
        A = torch.transpose(A, 2, 1)
        multi_interest_emb = torch.matmul(A, seq_emb)
        return multi_interest_emb

3.2 einsum函数的用法

einsum（Einstein summation convention，即爱因斯坦求和约定）的用法：

• $c_{ik}={\sum }_j{a}_{ij}{b}_{jk}$ 的写法如下：

c = np.dot(a, b)                 # 常规
c = np.einsum('ij,jk->ik', a, b) # einsum

• 再比如 $c_{\mathrm{kl}}={\sum }_{\mathrm{i}}{\sum }_{\mathrm{j}}{\mathrm{a}}_{\mathrm{ijk}}{\mathrm{b}}_{\mathrm{ijl}}$ ： c = np.einsum('ijk,jkl->kl', a, b)

import torch

# 1. 张量转置
A = torch.randn(3, 4, 5)
B = torch.einsum("ijk->ikj", A)
print(A.shape, "\n", B.shape, "\n", "======")  # (3, 4, 5) ; (3, 5, 4)

# 2. 取对角元素
A = torch.randn(5, 5)
B = torch.einsum("ii->i", A)
print(A.shape, "\n", B.shape, "\n", "======")

# 3. 求和降维
A = torch.randn(4, 5)
B = torch.einsum("ij->i", A)
print(A.shape, "\n", B.shape, "\n", "======")

# 4. 哈达玛积(两个矩阵维度相同)
A = torch.randn(3, 4)
B = torch.randn(3, 4)
C = torch.einsum("ij, ij->ij", A, B)
print(A.shape, "\n", B.shape, "\n", C.shape, "\n", "======")

# 5. 向量内积
A = torch.randn(10)
B = torch.randn(10)
#C=torch.dot(A,B)
C = torch.einsum("i,i->",A,B)

# 6. 向量外积
A = torch.randn(10)
B = torch.randn(5)
#C = torch.outer(A,B)
C = torch.einsum("i,j->ij",A,B)

# 7. 矩阵乘法
A = torch.randn(5,4)
B = torch.randn(4,6)
#C = torch.matmul(A,B)
C = torch.einsum("ik,kj->ij",A,B)

# 8. 张量缩并
A = torch.randn(3,4,5)
B = torch.randn(4,3,6)
#C = torch.tensordot(A,B,dims=[(0,1),(1,0)])
C = torch.einsum("ijk,jih->kh",A,B)

# 9. batch矩阵乘法
batch_tensor_1 = torch.arange(2 * 4 * 3).reshape(2, 4, 3)
batch_tensor_2 = torch.arange(2 * 3 * 4).reshape(2, 3, 4) 
torch.bmm(batch_tensor_1, batch_tensor_2)  # [2, 4, 4]
torch.einsum("bij, bjk -> bik", batch_tensor_1, batch_tensor_2) # [2, 4, 4]

3.3 Comirec-SA类定义

这部分和之前DR的类时一样的，改动的部分都体现在MultiInterest_SA上了。

class ComirecSA(nn.Layer):
    def __init__(self, config):
        super(ComirecSA, self).__init__()

        self.config = config
        self.embedding_dim = self.config['embedding_dim']
        self.max_length = self.config['max_length']
        self.n_items = self.config['n_items']

        self.item_emb = nn.Embedding(self.n_items, self.embedding_dim, padding_idx=0)
        self.multi_interest_layer = MultiInterest_SA(self.embedding_dim,interest_num=self.config['K'])
        self.loss_fun = nn.CrossEntropyLoss()
        self.reset_parameters()

    def calculate_loss(self,user_emb,pos_item):
        all_items = self.item_emb.weight
        scores = paddle.matmul(user_emb, all_items.transpose([1, 0]))
        return self.loss_fun(scores,pos_item)

    def output_items(self):
        return self.item_emb.weight

    def reset_parameters(self, initializer=None):
        for weight in self.parameters():
            paddle.nn.initializer.KaimingNormal(weight)

    def forward(self, item_seq, mask, item, train=True):

        if train:
            seq_emb = self.item_emb(item_seq)  # Batch,Seq,Emb
            item_e = self.item_emb(item).squeeze(1)

            multi_interest_emb = self.multi_interest_layer(seq_emb, mask)  # Batch,K,Emb

            cos_res = paddle.bmm(multi_interest_emb, item_e.squeeze(1).unsqueeze(-1))
            k_index = paddle.argmax(cos_res, axis=1)

            best_interest_emb = paddle.rand((multi_interest_emb.shape[0], multi_interest_emb.shape[2]))
            for k in range(multi_interest_emb.shape[0]):
                best_interest_emb[k, :] = multi_interest_emb[k, k_index[k], :]

            loss = self.calculate_loss(best_interest_emb,item)
            output_dict = { 
   
                'user_emb': multi_interest_emb,
                'loss': loss,
            }
        else:
            seq_emb = self.item_emb(item_seq)  # Batch,Seq,Emb
            multi_interest_emb = self.multi_interest_layer(seq_emb, mask)  # Batch,K,Emb
            output_dict = { 
   
                'user_emb': multi_interest_emb,
            }
        return output_dict

时间安排

Reference

[1] 多兴趣召回实践：Comirec-SA
论文：Controllable Multi-Interest Framework for Recommendation
链接：https://arxiv.org/abs/2005.09347
[2] 推荐场景中召回模型的演化过程. 京东大佬
[3] 原论文作者代码：https://github.com/THUDM/ComiRec/blob/a576eed8b605a531f2971136ce6ae87739d47693/src/train.py
[4] https://github.com/ShiningCosmos/pytorch_ComiRec/blob/main/ComiRec.py
[5] https://wangxiaocs.github.io/
[6] 推荐算法炼丹笔记：阿里序列化推荐算法ComiRec
[7] einsum is all you needed
[8] Understanding PyTorch einsum
[9] 矩阵操作万能函数 einsum 详细解析（通法教你如何看懂并写出einsum表达式）
[10] Sparse-Interest Network for Sequential Recommendation .AAAI 2021
[11] torch_rechub代码复现：https://github.com/datawhalechina/torch-rechub/blob/main/torch_rechub/models/matching/comirec.py

单头注意力机制：
$$Attention(Q,K,V)=\frac{Q{K}^T}{\sqrt{d_k}}\ast V$$
多头注意力机制：
$$MultiHead(Q,K,V)=Concat(hea{d}_1,...,hea{d}_h)\ast W^O$$
其中：
$$hea{d}_i=Attention(Q\ast W_i^Q,K\ast W_i^K,V\ast W_i^V)$$