文章目录
摘要
本周阅读了一篇基于多时间嵌入的混合注意机制的顺序推荐的文章，为了解决以前模型的局限性，文章提出了MEANTIME（混合的Attention机制与多时间嵌入），它采用多种类型的时间嵌入，旨在捕捉各种模式，从用户的行为序列，和一个注意力结构，充分利用这种多样性。此外，还对self-attention的内容进行进一步的补充学习、复习。
Abstract
This week, an article on order recommendation based on multi-time embedded mixed Attention mechanism is readed. In order to solve the limitations of previous models, the author proposes MEANTIME (mixed attention mechanism and multi-time embedding), which uses various types of time embedding to capture various patterns, from the user’s behavior sequence and an attention structure, and make full use of this diversity. In addition, the content of self-attention is further supplemented and reviewed.
文献阅读
题目
引言
背景：从用户的历史记录中获取用户的偏好对于做出有效的推荐至关重要，因为用户的偏好和项目的特征都是动态的；此外，用户的偏好在很大程度上取决于上下文；因此，sequential recommendation旨在通过用户的历史记录来预测用户可能更喜欢的下一组事物。
问题：大多数顺序推荐算法忽略了interactions’ timestamp values，虽然TiSASRec成功地结合了时间信息，但它却仅限于单个嵌入方案。由于timestamp values中的信息十分重要，因此探索多种形式的时间嵌入是有益的，而且这些嵌入可以充分提取不同的模式，以及可以充分利用这些多样性的模型架构。
方案：论文提出了MEANTIME，它引入多个时间嵌入，以更好地编码序列中用户项交互的绝对位置和相对位置。此外，论文使用了多个单独处理每个位置嵌入的自注意头，专注于特定的用户行为模式。
贡献
1）论文提出多样化用于编码序列中用户项交互位置的嵌入方案，通过将多个内核应用于序列中时间戳的位置/值来创建唯一的嵌入矩阵来实现的。
2）论文提出了一种新的模型架构，该架构同时操作多个self-attention heads，其中每个头通过利用提出的位置嵌入从用户的行为中提取特定模式。
3）通过实验证明了论文方法在真实世界数据集上的有效性，以及提供了一项全面的消融研究，帮助了解模型中各个组件的影响。
相关工作
Temporal Recommendation
Temporal Recommendation包含上下文信息，对推荐性能非常关键。TimeSVD++和BPTF将时间因子引入到矩阵分解方法中，Time-LSTM为LSTM配备了几种形式的时间门，以更好地模拟用户交互序列中的时间间隔，。CTA在时间信息上使用多个参数化核函数来校准自注意机制。
Sequential Recommendation
Sequential Recommendation的目的是根据用户的顺序历史来推荐相关的项目。SASRec成功地采用了自我注意机制，这在NLP领域取得了巨大的成功。BERT 4 Rec通过采用Transformer 和基于Cloz任务的训练方法改进了SASRec。TiSASRec通过将时间戳信息合并到自注意操作中来增强SASRec。论文工作旨在进一步扩大这一趋势，提出了一种新的模型架构，使用多种类型的时间嵌入和self-attention操作，以更好地捕捉用户行为的不同模式。
方法
本文设计了一种新的模型架构，为每个注意力头部注入各种时间嵌入，如下图所示：
Problem Formulation
基于给定的历史（Vu，Tu），预测用户u可能在目标时间戳与之交互的下一个项目。
Input Embedding
相对嵌入通过利用时间差信息来编码序列中每个交互对之间的关系。首先，我们定义了一个时间差矩阵，其元素定义为dab=（ta − tb）/T，其中T为可调整的单位时间差。如下所示，编码函数：
每一个嵌入都提供了对时间数据的独特视图。例如：Sin捕获周期性事件，较大的时间间隔要么在Exp中迅速衰减为零，要么在Log中可管理地增加；Pos可以从以前的模型中学习模式；最后Con完全消除了位置偏差，因此注意力只能集中在项目之间的关系上。
Self-Attention Structure
Attention Architecture：基于自注意力机制的模型采用了简单的绝对位置编码，将EItem和EPos的总和作为输入；EPos被仅依赖于阵列的位置索引之间差异的相对位置嵌入ER所取代，并且位置信息不再用于键和值编码器；参数bI和bR分别用作全局内容/位置偏差。对于绝对嵌入，论文也采用了前面的结构。
Stacking Layers：将Position-wise前馈网络应用于self-attention的结果，以完成单层，然后堆叠L个这样的层，为每个子层应用残差连接以促进训练：
Prediction Layer：给定最后一层的输出，通过以下方式获得每个位置的项目得分分布：
Model Training
从（Vu，Tu）中对项目v和时间戳t的子序列进行采样，并以概率ρ用[MASK]随机屏蔽其中的一部分，将v转换为v’；然后我们将v′和t送到模型中以获得P，，损失函数如下：
实验
数据集
在四个不同领域具有稀疏性的数据集上评估了模型：MovieLens 1M、MovieLen 20M、Amazon Beauty和Amazon Game。其中遵循通用数据预处理过程，将每个数据集转换为隐式数据集，将每个数值评级或评论视为用户项交互的存在，最后按用户ID对交互进行分组，按时间戳对它们进行排序，丢弃了少于五次交互的用户和项目，以确保数据集的质量。
对于每个用户的项序列，将最后一个项用于测试，将倒数第二个项用于验证。剩下的用来训练。为了对排名列表进行评分，使用两个常用指标：Recall和Normalized Discounted Cumulative Gain (NDCG)。
Recall@K and NDCG@K都被设计为ground truth item在前k列表中排名较高时具有较大的值。设置K = 5和10。
实验过程
作者使用PyTorch实现了MEANTIME 1。
参数设置如下：
隐藏维度h ∈ {16，32，64，128}，头数n ∈ {2，4}，丢弃率∈ {0.2，0.5}，权重衰减wd ∈ {0，0.00001}。对所有基于transformer的模型使用相同的最大序列长度（MovieLens为N = 200，Amazon为N = 50）和层数（L = 2）
实验结果
与最好基线相比，论文提出的模型在所有指标和数据集中都具有最优的性能。
多时间嵌入的效果：
下图比较了在ML-1M和Amazon Game数据集上所有可能的时间嵌入组合情况，结果表明具有不同特征的数据集需要精心选择的时间嵌入，以提供对用户-项目交互上下文的正确看法。
深度学习
Self-attention
例子：
以两个词的输入为例来解释self-attention的大致过程：
此时每个词看的是整个输入序列，不再只看之前的序列，并且是并行计算，同时计算出所有的输出结果。
再以四输入四输出的例子进行补充说明：
其中只有Wq、Wk、Wv是机器需要学习的参数。
多头机制
CNN中，可以设置不同的filter来进行卷积，self-attention中也可以设置多组q，k，v的值得到不同的特征表达，这就是multi-headed机制。一般情况下，只做8组head即可，通过不同的head得到多个特征表达。多组结果z可以拼接在一起通过全连接层进行降维得到最终的结果。
堆叠多层
Self-attention输入输出都是向量，可以将self-attention也进行多层堆叠。10层以上都是很常见的。
补充说明：
结果需要通过Add和normalize，并且也可以类似CNN使用残差网络同等映射，以防在堆叠过程中出现结果变差的情况。
基于pytorch的transformer
掩码部分代码如下图
class Embeddings(nn.Module):
def __init__(self, d_model, vocab):
"""
类的初始化函数
d_model：指词嵌入的维度
vocab:指词表的大小
"""
super(Embeddings, self).__init__()
#之后就是调用nn中的预定义层Embedding，获得一个词嵌入对象self.lut
self.lut = nn.Embedding(vocab, d_model)
#最后就是将d_model传入类中
self.d_model =d_model
def forward(self, x):
"""
Embedding层的前向传播逻辑
参数x：这里代表输入给模型的单词文本通过词表映射后的one-hot向量
将x传给self.lut并与根号下self.d_model相乘作为结果返回
"""
embedds = self.lut(x)
return embedds * math.sqrt(self.d_model)
位置编码部分代码如下
class PositionalEncoding(nn.Module):
def __init__(self, d_model, dropout, max_len=5000):
"""
位置编码器类的初始化函数
共有三个参数，分别是
d_model：词嵌入维度
dropout: dropout触发比率
max_len：每个句子的最大长度
"""
super(PositionalEncoding, self).__init__()
self.dropout = nn.Dropout(p=dropout)
# Compute the positional encodings
# 注意下面代码的计算方式与公式中给出的是不同的，但是是等价的，你可以尝试简单推导证明一下。
# 这样计算是为了避免中间的数值计算结果超出float的范围，
pe = torch.zeros(max_len, d_model)
position = torch.arange(0, max_len).unsqueeze(1)
div_term = torch.exp(torch.arange(0, d_model, 2) *
-(math.log(10000.0) / d_model))
pe[:, 0::2] = torch.sin(position * div_term)
pe[:, 1::2] = torch.cos(position * div_term)
pe = pe.unsqueeze(0)
self.register_buffer('pe', pe)
def forward(self, x):
x = x + Variable(self.pe[:, :x.size(1)], requires_grad=False)
return self.dropout(x)
编码器代码如下
# 定义一个clones函数，来更方便的将某个结构复制若干份
def clones(module, N):
"Produce N identical layers."
return nn.ModuleList([copy.deepcopy(module) for _ in range(N)])
class Encoder(nn.Module):
"""
Encoder
The encoder is composed of a stack of N=6 identical layers.
"""
def __init__(self, layer, N):
super(Encoder, self).__init__()
# 调用时会将编码器层传进来，我们简单克隆N分，叠加在一起，组成完整的Encoder
self.layers = clones(layer, N)
self.norm = LayerNorm(layer.size)
def forward(self, x, mask):
"Pass the input (and mask) through each layer in turn."
for layer in self.layers:
x = layer(x, mask)
return self.norm(x)
编码器层代码如下
class EncoderLayer(nn.Module):
"EncoderLayer is made up of two sublayer: self-attn and feed forward"
def __init__(self, size, self_attn, feed_forward, dropout):
super(EncoderLayer, self).__init__()
self.self_attn = self_attn
self.feed_forward = feed_forward
self.sublayer = clones(SublayerConnection(size, dropout), 2)
self.size = size # embedding's dimention of model, 默认512
def forward(self, x, mask):
# attention sub layer
x = self.sublayer[0](x, lambda x: self.self_attn(x, x, x, mask))
# feed forward sub layer
z = self.sublayer[1](x, self.feed_forward)
return z
注意力机制层代码如下
def attention(query, key, value, mask=None, dropout=None):
"Compute 'Scaled Dot Product Attention'"
#首先取query的最后一维的大小，对应词嵌入维度
d_k = query.size(-1)
#按照注意力公式，将query与key的转置相乘，这里面key是将最后两个维度进行转置，再除以缩放系数得到注意力得分张量scores
scores = torch.matmul(query, key.transpose(-2, -1)) / math.sqrt(d_k)
#接着判断是否使用掩码张量
if mask is not None:
#使用tensor的masked_fill方法，将掩码张量和scores张量每个位置一一比较，如果掩码张量则对应的scores张量用-1e9这个置来替换
scores = scores.masked_fill(mask == 0, -1e9)
#对scores的最后一维进行softmax操作，使用F.softmax方法，这样获得最终的注意力张量
p_attn = F.softmax(scores, dim = -1)
#之后判断是否使用dropout进行随机置0
if dropout is not None:
p_attn = dropout(p_attn)
#最后，根据公式将p_attn与value张量相乘获得最终的query注意力表示，同时返回注意力张量
return torch.matmul(p_attn, value), p_attn
多头注意力机制代码如下
class MultiHeadedAttention(nn.Module):
def __init__(self, h, d_model, dropout=0.1):
#在类的初始化时，会传入三个参数，h代表头数，d_model代表词嵌入的维度，dropout代表进行dropout操作时置0比率，默认是0.1
super(MultiHeadedAttention, self).__init__()
#在函数中，首先使用了一个测试中常用的assert语句，判断h是否能被d_model整除，这是因为我们之后要给每个头分配等量的词特征，也就是embedding_dim/head个
assert d_model % h == 0
#得到每个头获得的分割词向量维度d_k
self.d_k = d_model // h
#传入头数h
self.h = h
#创建linear层，通过nn的Linear实例化，它的内部变换矩阵是embedding_dim x embedding_dim，然后使用，为什么是四个呢，这是因为在多头注意力中，Q,K,V各需要一个，最后拼接的矩阵还需要一个，因此一共是四个
self.linears = clones(nn.Linear(d_model, d_model), 4)
#self.attn为None，它代表最后得到的注意力张量，现在还没有结果所以为None
self.attn = None
self.dropout = nn.Dropout(p=dropout)
def forward(self, query, key, value, mask=None):
#前向逻辑函数，它输入参数有四个，前三个就是注意力机制需要的Q,K,V，最后一个是注意力机制中可能需要的mask掩码张量，默认是None
if mask is not None:
# Same mask applied to all h heads.
#使用unsqueeze扩展维度，代表多头中的第n头
mask = mask.unsqueeze(1)
#接着，我们获得一个batch_size的变量，他是query尺寸的第1个数字，代表有多少条样本
nbatches = query.size(0)
# 1) Do all the linear projections in batch from d_model => h x d_k
# 首先利用zip将输入QKV与三个线性层组到一起，然后利用for循环，将输入QKV分别传到线性层中，做完线性变换后，开始为每个头分割输入，这里使用view方法对线性变换的结构进行维度重塑，多加了一个维度h代表头，这样就意味着每个头可以获得一部分词特征组成的句子，其中的-1代表自适应维度，计算机会根据这种变换自动计算这里的值，然后对第二维和第三维进行转置操作，为了让代表句子长度维度和词向量维度能够相邻，这样注意力机制才能找到词义与句子位置的关系，从attention函数中可以看到，利用的是原始输入的倒数第一和第二维，这样我们就得到了每个头的输入
query, key, value = \
[l(x).view(nbatches, -1, self.h, self.d_k).transpose(1, 2)
for l, x in zip(self.linears, (query, key, value))]
# 2) Apply attention on all the projected vectors in batch.
# 得到每个头的输入后，接下来就是将他们传入到attention中，这里直接调用我们之前实现的attention函数，同时也将mask和dropout传入其中
x, self.attn = attention(query, key, value, mask=mask,
dropout=self.dropout)
# 3) "Concat" using a view and apply a final linear.
# 通过多头注意力计算后，我们就得到了每个头计算结果组成的4维张量，我们需要将其转换为输入的形状以方便后续的计算，因此这里开始进行第一步处理环节的逆操作，先对第二和第三维进行转置，然后使用contiguous方法。这个方法的作用就是能够让转置后的张量应用view方法，否则将无法直接使用，所以，下一步就是使用view重塑形状，变成和输入形状相同。
x = x.transpose(1, 2).contiguous() \
.view(nbatches, -1, self.h * self.d_k)
#最后使用线性层列表中的最后一个线性变换得到最终的多头注意力结构的输出
return self.linears[-1](x)
解码器整体结构代码结构如下
#使用类Decoder来实现解码器
class Decoder(nn.Module):
"Generic N layer decoder with masking."
def __init__(self, layer, N):
#初始化函数的参数有两个，第一个就是解码器层layer，第二个是解码器层的个数N
super(Decoder, self).__init__()
#首先使用clones方法克隆了N个layer，然后实例化一个规范化层，因为数据走过了所有的解码器层后最后要做规范化处理。
self.layers = clones(layer, N)
self.norm = LayerNorm(layer.size)
def forward(self, x, memory, src_mask, tgt_mask):
#forward函数中的参数有4个，x代表目标数据的嵌入表示，memory是编码器层的输出，source_mask，target_mask代表源数据和目标数据的掩码张量，然后就是对每个层进行循环，当然这个循环就是变量x通过每一个层的处理，得出最后的结果，再进行一次规范化返回即可。
for layer in self.layers:
x = layer(x, memory, src_mask, tgt_mask)
return self.norm(x)
解码器层代码如下
#使用DecoderLayer的类实现解码器层
class DecoderLayer(nn.Module):
"Decoder is made of self-attn, src-attn, and feed forward (defined below)"
def __init__(self, size, self_attn, src_attn, feed_forward, dropout):
#初始化函数的参数有5个，分别是size，代表词嵌入的维度大小，同时也代表解码器的尺寸，第二个是self_attn，多头自注意力对象，也就是说这个注意力机制需要Q=K=V，第三个是src_attn,多头注意力对象，这里Q!=K=V，第四个是前馈全连接层对象，最后就是dropout置0比率
super(DecoderLayer, self).__init__()
self.size = size
self.self_attn = self_attn
self.src_attn = src_attn
self.feed_forward = feed_forward
#按照结构图使用clones函数克隆三个子层连接对象
self.sublayer = clones(SublayerConnection(size, dropout), 3)
def forward(self, x, memory, src_mask, tgt_mask):
#forward函数中的参数有4个，分别是来自上一层的输入x，来自编码器层的语义存储变量memory，以及源数据掩码张量和目标数据掩码张量，将memory表示成m之后方便使用。
"Follow Figure 1 (right) for connections."
m = memory
#将x传入第一个子层结构，第一个子层结构的输入分别是x和self-attn函数，因为是自注意力机制，所以Q,K,V都是x，最后一个参数时目标数据掩码张量，这时要对目标数据进行遮掩，因为此时模型可能还没有生成任何目标数据。
#比如在解码器准备生成第一个字符或词汇时，我们其实已经传入了第一个字符以便计算损失，但是我们不希望在生成第一个字符时模型能利用这个信息，因此我们会将其遮掩，同样生成第二个字符或词汇时，模型只能使用第一个字符或词汇信息，第二个字符以及之后的信息都不允许被模型使用。
x = self.sublayer[0](x, lambda x: self.self_attn(x, x, x, tgt_mask))
#接着进入第二个子层，这个子层中常规的注意力机制，q是输入x;k,v是编码层输出memory，同样也传入source_mask，但是进行源数据遮掩的原因并非是抑制信息泄露，而是遮蔽掉对结果没有意义的padding。
x = self.sublayer[1](x, lambda x: self.src_attn(x, m, m, src_mask))
#最后一个子层就是前馈全连接子层，经过它的处理后就可以返回结果，这就是我们的解码器结构
return self.sublayer[2](x, self.feed_forward)
整体网络框架如下
# Model Architecture
#使用EncoderDecoder类来实现编码器-解码器结构
class EncoderDecoder(nn.Module):
"""
A standard Encoder-Decoder architecture.
Base for this and many other models.
"""
def __init__(self, encoder, decoder, src_embed, tgt_embed, generator):
#初始化函数中有5个参数，分别是编码器对象，解码器对象,源数据嵌入函数，目标数据嵌入函数，以及输出部分的类别生成器对象.
super(EncoderDecoder, self).__init__()
self.encoder = encoder
self.decoder = decoder
self.src_embed = src_embed # input embedding module(input embedding + positional encode)
self.tgt_embed = tgt_embed # ouput embedding module
self.generator = generator # output generation module
def forward(self, src, tgt, src_mask, tgt_mask):
"Take in and process masked src and target sequences."
#在forward函数中，有四个参数，source代表源数据，target代表目标数据,source_mask和target_mask代表对应的掩码张量,在函数中，将source source_mask传入编码函数，得到结果后与source_mask target 和target_mask一同传给解码函数
memory = self.encode(src, src_mask)
res = self.decode(memory, src_mask, tgt, tgt_mask)
return res
def encode(self, src, src_mask):
#编码函数，以source和source_mask为参数,使用src_embed对source做处理，然后和source_mask一起传给self.encoder
src_embedds = self.src_embed(src)
return self.encoder(src_embedds, src_mask)
def decode(self, memory, src_mask, tgt, tgt_mask):
#解码函数，以memory即编码器的输出，source_mask target target_mask为参数,使用tgt_embed对target做处理，然后和source_mask,target_mask,memory一起传给self.decoder
target_embedds = self.tgt_embed(tgt)
return self.decoder(target_embedds, memory, src_mask, tgt_mask)
# Full Model
def make_model(src_vocab, tgt_vocab, N=6, d_model=512, d_ff=2048, h=8, dropout=0.1):
"""
构建模型
params:
src_vocab:
tgt_vocab:
N: 编码器和解码器堆叠基础模块的个数
d_model: 模型中embedding的size，默认512
d_ff: FeedForward Layer层中embedding的size，默认2048
h: MultiHeadAttention中多头的个数，必须被d_model整除
dropout:
"""
c = copy.deepcopy
attn = MultiHeadedAttention(h, d_model)
ff = PositionwiseFeedForward(d_model, d_ff, dropout)
position = PositionalEncoding(d_model, dropout)
model = EncoderDecoder(
Encoder(EncoderLayer(d_model, c(attn), c(ff), dropout), N),
Decoder(DecoderLayer(d_model, c(attn), c(attn), c(ff), dropout), N),
nn.Sequential(Embeddings(d_model, src_vocab), c(position)),
nn.Sequential(Embeddings(d_model, tgt_vocab), c(position)),
Generator(d_model, tgt_vocab))
# This was important from their code.
# Initialize parameters with Glorot / fan_avg.
for p in model.parameters():
if p.dim() > 1:
nn.init.xavier_uniform_(p)
return model
总结
本周学习了transformer中的核心机制self-attention并进行手动模拟推导，这有利于进一步理解transformer。decoder与encoder类似，只是attention的计算略有不同以及添加了mask机制。在decoder中，只能利用序列中已得出的结果，不能用后面未推导出的部分。
1081
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
