Transformer

发表于 2024-05-12 分类于深度学习， Transformer 本文字数： 6.1k

transformer

本文是对 Transformer 的学习笔记，其中的所有代码均出自于 Github，仅用于辅助理解使用。

本文的组织方式是根据 Transformer 的架构图逐个介绍，然后介绍其训练和推理的过程，最后介绍一些细节。

由于在 NLP 领域的零基础以及 DL 的薄弱基础，学习原始的 Transformer 都耗费了 3 天的时间，以此篇论文作为阶段性的总结。

Input Embedding

将输入的文本序列转化为通过 Embedding Matrix $E$ 转化为矩阵 $X$

$E$ 记录了词汇库中的所有词汇的 Embedding Vector，其大小是 $d_{m o d e l} \times n_{v o c a b}$ ，也就是向量长度x单词数量；
输入的文本序列根据 $E$ 中为每个单词指定的向量进行拼接；
$E$ 是随着训练的进行逐渐学习的，它的实际形式是一个神经网络的参数。

随着训练的进行，单词所对应的向量在高维（GPT3: 12288维）空间中：

意义相近的单词位置相近，它们向量上的差距可以表示它们实际概念上的差距；
$E (q u e e n) - E (k i n g) \approx E (m a l e) - E (m a n)$
$E (w o r d)$ 表示某个 $w o r d$ 的嵌入向量；

这代表着，我们可以利用这些量化后的概念差距，来将一个领域内的变化转化到另一个领域内的变化。比如我们可以直接用性别概念的差距，来将 Father 转化为 Mother

F a t h e r + (M a l e - F e m a l e) \approx M o t h e r

让蕴含着相同概念的单词有着相同的方向（在某个投影上它们指向同一方向），比如 (周润发, 刘德华, 男性) 都在某个投影中指向同一个方向，以及(周润发, 刘德华, 演员) (周润发, 刘德华, 四大天王)。

可以用点积（元素相乘再相加，结果是标量）来衡量向量之间的对齐程度。相近时点积为正，垂直时点积为0，相反时点积为负。

Positional Encoding

在经过 Input Embedding 后，得到的 $X$ 中每一列都是 Embedding Vector。然而此时每个单词都出现在一个具体的序列中，它们在这个序列中的位置也同样影响着它们所表达的意思。我们需要将单词在序列中的位置信息进行编码，再传递给下一步的神经网络。

Transformer 所使用的编码方式为：

\begin{array}{r} P E_{(p o s, 2 i)} = \sin (\frac{p o s}{10000^{2 i / d_{m o d e l}}}) \\ P E_{(p o s, 2 i + 1)} = \cos (\frac{p o s}{10000^{2 i / d_{m o d e l}}}) \end{array}

其中 pos 表示序列中的第 pos 个单词， $i$ 表示编码后的向量的第 $i$ 个元素（特征维度索引）。也就是说，位置编码的每个维度对应于一个正弦曲线。这些波长形成一个从 $2 π$ 到 $10000 \cdot 2 π$ 的集合级数。选择这个函数是因为假设它会让模型很容易学习关注单词的相对位置，因为对任意确定的偏移 $k$ , $P E_{p o s + k}$ 可以表示为 $P E_{p o s}$ 的线性函数。

在输入下一步之前，我们将 Positional Encoding 和 Input Embedding 相加。为了避免他们的尺度相差过大， Input Embedding 会乘以 $\sqrt{d_{m o d e l}}$ 。

PE 具有平移可加性。平移可加性指的是：两个位置之间的距离（ $p o s$ 之间的差距），可以用位置编码向量之间的“差”来表达。设位置为 $p o s_{1}$ 、 $p o s_{2} = p o s_{1} + Δ$ ，我们看正余弦函数的性质：

\sin (p o s_{2}) = \sin (p o s_{1} + Δ) = \sin (p o s_{1}) \cos (Δ) + \cos (p o s_{1}) \sin (Δ)

\cos (p o s_{2}) = \cos (p o s_{1} + Δ) = \cos (p o s_{1}) \cos (Δ) - \sin (p o s_{1}) \sin (Δ)

也就是说：两个位置的编码之间的差异是有规律的，可以被神经网络学习到。

为什么要用 $10000^{\frac{2 i}{d}}$ ？这是为了让每一个特征维度都拥有不同的频率（频谱）

维度越小（靠前），频率越高（周期越短）
维度越大（靠后），频率越低（周期越长）

这样，位置编码整体上就可以覆盖从细粒度的局部位置到粗粒度的全局距离。举个例子：

当 $i = 0$ ，指数是 0 → 频率是 $\frac{1}{1}$
当 $i = d / 2$ ，指数是 1 → 频率是 $\frac{1}{10000}$

这种方法的优点是：

可以扩展到未知的序列长度。例如：当我们的模型需要翻译一个句子，而这个句子的长度大于训练集中所有句子的长度，这时，这种位置编码的方法也可以生成这个长度的位置编码向量。因为位置编码是基于数学公式生成的，而不是训练学来的，所以即使遇到训练时没见过的位置，也能生成合理的位置向量。
能编码相对位置信息：位置 $p o s + k$ 的编码可以表示为位置 $p o s$ 的编码的线性组合（三角函数加法公式）
值域稳定： $[0, 1]$

def position_embedding(seq_len, d_model): # -> (seq_len,d_model)
    # 生成 0 ~ seq_len 的计数数组
    position = torch.arange(seq_len, dtype=torch.float).unsqueeze(1)
    # 注意下面式子中的 i 表示的是特征维度
    # 计算 1/10000^{2i/d_model} = exp(log((10000^{-2i/d_model}))) =exp(-2*i*log(10000)/d_model)
    # 0,2,4,...
    i = torch.arange(0, d_model, 2).float()
    # (d_model/2,)
    div_term = torch.exp(i*(-math.log(10000))/d_model)
    pe = torch.zeros((seq_len, d_model))
    # (seq_len, 1) x (d_model/2,)
    # 广播成：(seq_len, 1) x (1, d_model/2)
    # 得到：(seq_len, d_model/2)
    pe[:, 0::2] = torch.sin(position * div_term)
    pe[:, 1::2] = torch.cos(position * div_term)
    return pe

Encoder-Decoder

Encoder: 输入是一个序列的 token 表示，通常使用词嵌入（word embeddings）来表示每个 token。这些嵌入被加上位置编码（position encodings）以表示它们在序列中的位置。Encoder 的输出是经过一系列自注意力层和前馈神经网络层处理后的编码表示。

Decoder 的输入也是一个序列的 token 表示，类似于 Encoder，它也使用词嵌入或者子词嵌入来表示每个 token，并加上位置编码。但是，Decoder 还接收来自 Encoder 的编码表示作为额外的输入，以帮助生成输出序列（如在翻译任务中，Encoder 输入的是一种语言下的文本序列，Decoder 输出的就是另外一种语言下的序列）。Decoder 的输出是经过一系列自注意力层、编码-解码注意力层和前馈神经网络层处理后的表示，通常用于生成目标序列的 token。

Encoder

Encoder 由 N 个相同的层组成，每个层又分为两个 sub-layer:

多头注意力
前馈神经网络

Encoder 的作用是将输入的文本序列转化为其潜在表征，Decoder 的作用是将 Encoder 输出的潜在表征转化为目标文本序列。

Multi-head Attention

在输入 X 的 Embeding 后，会分别乘以 $W^{Q}$ $W^{K}$ $W^{V}$ （也就是全连接层）来得到 Q K V

多头注意力是注意力机制的一个变种。传统的单头注意力机制在输入 Q ( $b \times d_{k}$ ), K ( $b \times d_{k}$ ), V ( $d_{k} \times d_{k}$ ) 之后，只会直接根据 Q, K 的匹配程度计算每个 K 的权重，再根据每个 K 的权重及每个 K 对应的 V 计算加权和。对于单头注意力机制， $d_{k} = d_{m o d e l}$ 。

对于点积注意机制，也就是：

Attention (Q, K, V) = softmax (\frac{Q K^{T}}{\sqrt{d_{k}}}) V

除以 $\sqrt{d_{k}}$ 是为了让数值更加稳定。当 $d_{k}$ 比较大的时候，会导致计算出来的点积之间的差距比较大，进而导致 Softmax 后最大的接近于 1，其余接近于 0，这种时候会导致梯度消失，除以 $\sqrt{d_{k}}$ 即可解决这个问题。

Note

随着维度 $d_{k}$ 的增加，点积 $Q K^{⊤}$ 的期望值和方差也会增大。例如：

假设 $q$ 和 $k$ 是独立且均值为 0、方差为 1 的向量。
那么 $q \cdot k = \sum_{i = 1}^{d_{k}} q_{i} k_{i}$ 的期望是 0，方差是 $d_{k}$ 。

V a r (q k) = \sum_{i} V a r (q_{i} k_{i}) = \sum_{i} E [(q_{i} k_{i})^{2}] - E [(q_{i} k_{i})]^{2} = \sum_{i}^{d_{k}} 1 = d_{k}

通过乘以 $1 / \sqrt{d_{k}}$ ，可以让方差重新变回常数 1

V a r (C A) = C^{2} V a r (A)

由于 QKV 都是矩阵，所以 $Attention (Q, K, V)$ 的结果也是矩阵。 $Q K^{T}$ 的结果就是 Q 和 K 中所有行向量的点积。也就是 $Q K_{i, j}^{T} = Q_{i} \cdot K_{i}$ 。

$Attention (Q, K, V)$ 得到的矩阵也称为注意力权重矩阵（Attention weight matrix），它决定了在处理输入序列的时候，对不同 token 的关注程度。也就是给定 Q（query，查询），在模型内置的 K（key）-V（value）矩阵中，用 Q 匹配 K 得到这个 Q 对应的 V 和这个 V 权重，进而得到这个 Q 所代表的 X 给模型带来的信息。其中，Q 匹配 K 所得到的权重，可进一步可视化为注意力图（Attention Map）

AttentionMap (Q, K) = softmax (\frac{Q K^{T}}{\sqrt{d_{k}}})

然而，单头注意力的空间表示有限，多头注意力机制允许模型同时关注来自不同位置的不同表示子空间的信息，如果只有一个注意力头，向量的表示能力会下降。具体来说，在多头注意力机制拿到 Q K V 后，它并不直接计算点积，而是先将 Q K V 分别经过一个的线性全连接层后，再分解为 $h$ 个不同的 Q K V 来进行普通的注意力机制的计算。

这个步骤相当于我们希望线性全连接层能够将 Q K V 映射至 $h$ 个不同的低维空间，每个空间中计算注意力机制的 Qi Ki Vi 维度为 $d_{k} = d_{m o d e l} / h$ ，然后在每个头（也就是一个低维空间中）计算注意力（每个头中得到的结果形状为 $b \times d_{k}$ ）。在此之后，将所有头的结果拼接起来，这样维度就回到了 $b \times d_{m o d e l}$ ，最后再经过一次 $d_{m o d e l}$ 到 $d_{m o d e l}$ 的映射，得到多头注意力的输出。

\begin{array}{r} MutliHead (Q, K, V) = Concat (h e a d_{1}, . . ., h e a d_{h}) W^{O} \\ h e a d_{i} = Attention (Q W_{i}^{Q}, K W_{i}^{K}, V W_{i}^{V}) \end{array}

multi-head attention

注意并不是将同一个 Q K V 映射 h 遍，而是直接通过一次的线性映射再分成 h 块

def attention(query, key, value, mask=None, dropout=None):
    "Compute 'Scaled Dot Product Attention' 既能处理 3 维，也能处理 2 维。3 维即多头的情况，2 维即单头的情况"
    d_k = query.size(-1)
    # transpose(-2, -1) 方法，key 张量的倒数第二个维度变为了倒数第一个维度
    # key 张量倒数两个维度就是一个个（共 h 个）具体的 K
    scores = torch.matmul(query, key.transpose(-2, -1)) \
             / math.sqrt(d_k)
    if mask is not None:
        scores = scores.masked_fill(mask == 0, -1e9)
    p_attn = F.softmax(scores, dim = -1)
    if dropout is not None:
        p_attn = dropout(p_attn)
    return torch.matmul(p_attn, value), p_attn

class MultiHeadedAttention(nn.Module):
    def __init__(self, h, d_model, dropout=0.1):
        "Take in model size and number of heads."
        super(MultiHeadedAttention, self).__init__()
        assert d_model % h == 0
        # We assume d_v always equals d_k
        self.d_k = d_model // h
        self.h = h
        # 总共需要 4 个线性映射，前 3 个用于映射 Q K V，最后一个用于输出的映射
        self.linears = clones(nn.Linear(d_model, d_model), 4)
        self.attn = None
        self.dropout = nn.Dropout(p=dropout)
        
    def forward(self, query, key, value, mask=None):
        if mask is not None:
            mask = mask.unsqueeze(1)
        nbatches = query.size(0)
        
        # 1) Do all the linear projections in batch from d_model => h x d_k 
        # 分别映射 Q K V，并将其划分 b x {} x h x d_k 块
        # 之所以要划分为  b x {} x h x d_k 这样的形状，是想要直观地得到 h x d_k，也就是分别 h 个 Q K V
        # 拆分一下就是
        # query = self.linears[0](x).view(nbatches, -1, self.h, self.d_k).transpose(1, 2)
		# 从 view 的最后两维可以非常直观地看到是分成了 h 个 query
        # 再转置就变成了 h 个 Q，用于下一步的 attention 函数便于其无论单头还是多头情况下都可以直接取最后两维
        
        # 为什么不直接使用 b x h x -1 x d_k 呢?
        # 对于原来的矩阵 Q，其经过映射后得到的矩阵 Q^，在 view 的时候是先抽取(h, -1 ,d_k) 个元素，组成最外层的维度 bx(h x -1 x d_k)
        # 再逐步向内取的，下一步是 b x h x (-1, d_k) 
		# 导致模型的计算并不直观 因为我们是想将 Q^ 切成 h x d_k (h x d_k = model)，进而导致模型的行为不符合多头注意力的的行为
        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. 
        x, self.attn = attention(query, key, value, mask=mask, 
                                 dropout=self.dropout)
        
        # 3) "Concat" using a view and apply a final linear. 
        x = x.transpose(1, 2).contiguous() \
             .view(nbatches, -1, self.h * self.d_k)
        return self.linears[-1](x)

Add & Norm

Add 即 ResNet 中的“短接”（Shortcut Connection），将一个子层的输出及其输入加起来再交给下一个子层。

Norm 是指 Layer Normalization。对于一批输入的数据（batch_size x dim），对每一行（每个样本）做标准化，把每一行都变成均值为 0 方差为 1 的向量。对于文本序列，其输入是三维的 (batch_size x seq(n) x embedding dim(d))，也同样是取每个样本(1 x seq x embedding dim)做标准化。Transformer 使用 Layer Norm 的原因在于对于文本样本，其每个样本的长度是不确定的，所以会在有些样本的最后填充 0，进而影响 Batch Norm 的效果 (batch_sze x seq x 1)。因为当样本长度差值比较大的时候，Batch Norm 的切片方式计算出来的均值和方差抖动比较大。

class LayerNorm(nn.Module):
    "Construct a layernorm module (See citation for details)."
    def __init__(self, features, eps=1e-6):
        super(LayerNorm, self).__init__()
        self.a_2 = nn.Parameter(torch.ones(features))
        self.b_2 = nn.Parameter(torch.zeros(features))
        self.eps = eps

    def forward(self, x):
        mean = x.mean(-1, keepdim=True)
        std = x.std(-1, keepdim=True)
        return self.a_2 * (x - mean) / (std + self.eps) + self.b_2
    
class SublayerConnection(nn.Module):
    """
    A residual connection followed by a layer norm.
    Note for code simplicity the norm is first as opposed to last.
    """
    def __init__(self, size, dropout):
        super(SublayerConnection, self).__init__()
        self.norm = LayerNorm(size)
        self.dropout = nn.Dropout(dropout)

    def forward(self, x, sublayer):
        "Apply residual connection to any sublayer with the same size."
        return x + self.dropout(sublayer(self.norm(x)))

Position-wise FFN

就是一个简单的 MLP 网络，但是它是作用在每一个位置（也就是每个单词）上的，同一个 MLP，分别作用于每一个位置，所以其输入是 $d_{m o d e l}$ 长度的。

class PositionwiseFeedForward(nn.Module):
    "Implements FFN equation."
    def __init__(self, d_model, d_ff, dropout=0.1):
        super(PositionwiseFeedForward, self).__init__()
        self.w_1 = nn.Linear(d_model, d_ff)
        self.w_2 = nn.Linear(d_ff, d_model)
        self.dropout = nn.Dropout(dropout)

    def forward(self, x):
        return self.w_2(self.dropout(F.relu(self.w_1(x))))

实际计算上，就是对最后两维做 MLP，所以在实现上只需要直接输入一个 MLP 并得到输出即可，Pytorch 会默认在最后两个维度进行 MLP。

FFN 的作用是对每个位置上的向量做独立的非线性变换，增强模型的表示能力，使得每个 token 的表示能够通过非线性投影捕捉更复杂的特征。

Decoder

Input & Output

训练阶段：

Decoder 的输入是 完整的目标序列的前缀，例如，如果目标是 y = [<S>, y₁, y₂, y₃, y₄. <E>]，那训练时 decoder 输入是左移版本（[<S>, y₁, y₂, y₃]）来预测 [y₂, y₃, y₄, <E>]]，输入和输出的长度是一样的
训练阶段为了防止模型看到后面的词，使用 masked self-attention，只允许每个位置看自己和前面的词。
所有输出可以并行生成，即每个位置可以一起训练。

推理阶段：

Decoder 没有目标序列可用，只能一步一步生成。
初始只输入 [<BOS>]（开始符），生成 y₁；
然后再输入 [<BOS>, y₁]，生成 y₂，依此类推。
因此，推理是自回归的（auto-regressive），不能并行生成，只能一步一步生成每个 token，每次在取出的序列中取最后一个加入输入序列。

Masked Multi-head Attention

在训练的时候，一个句子输入到模型中，我们会让模型逐个预测这个句子的每个词

比如 I am a student

我们会一次性让模型预测 am, a, student, 以此提高样本的利用效率。所以，我们在计算注意力机制的时候，我们并不希望在计算 I 的下一个单词的时候，就知道 $Q_{(I)}$ 对于 $K_{(a m)}$ 的点积，这相当于提前向模型泄漏了后面的句子组成。此时只应该知道 $Q_{(I)}$ 和 $K_{(I)}$ 。所以我们一次性计算出来 Q-K 矩阵后，应该将对角线以下的部分进行遮蔽。

在预测 I 的下一列时，只给出 I 的这一列作为上下文信息，并给模型预测下一个词。一般将要遮蔽的元素在 softmax 前设置为 $- \infin$ ，这样 Softmax 后就变成 0。

K Q	I	am	a
I
am	x
a	x	x
teacher	x	x	x

Cross Attention

Decoder 的第一层 Self-Attention 是为了理解自身已生成的序列，而第二层 Cross-Attention 才是为了引入 Encoder 的外部上下文信息来辅助预测。解码器的第二块的KV来自于编码器。

Cross-Attention 使用三个矩阵：Decoder当前输入表示为 $Q \in R^{n_{q} \times d_{m o d e l}}$ ，Encoder输出作为 $K, V \in R^{n_{k} \times d}$ 。

Encoder 输出的每个 token 向量本身同时携带其语义内容（V）和其可被匹配的语义特征（K），虽然初始输入一样，但 Transformer 中的注意力机制通常会对 K、V 各自做一次线性变换，通过不同的投影矩阵 $W^{K}, W^{V}$ ，它们在语义空间中可以被分化开来。

Linear & Softmax

Decoder通过所有块后输出 $b \times s e q \times d_{m o d e l}$ 的向量，而后，我们需要将其通过一个线性层转为 $b \times s e q \times n_{v o c a b}$ 的向量，再经过 softmax 转化为每个词的概率。

Training Process

Transformer 训练的目标是通过对源序列与目标序列的学习，生成目标序列。

训练过程中，模型对数据的处理过程如下，大体可分为 6 个步骤：

在送入第一个编码器之前，输入序列首先被转换为嵌入（带有位置编码），产生词嵌入表示之后送入第一个编码器；
由各编码器组成的编码器堆栈按照顺序对第一步中的输出进行处理，产生输入序列的编码表示；
在右侧的解码器堆栈中，目标序列首先加一个句首标记，被转换成嵌入（带位置编码），产生词嵌入表示，之后送入第一个解码器；
由各解码器组成的解码器堆栈，将第三步的词嵌入表示，与编码器生成的潜在表示一起处理（用作 Q K），产生目标序列的解码表示；
输出层将其转换为词概率和最终的输出序列；
损失函数将这个输出序列与训练数据中的目标序列进行比较。这个损失被用来产生梯度，在反向传播过程中训练模型。

Inference Process

推理过程中的数据流转如下：

第一步与训练过程相同：输入序列首先被转换为嵌入（带有位置编码），产生词嵌入表示，之后送入第一个编码器。
第二步也与训练过程相同：由各编码器组成的编码器堆栈按照顺序对第一步中的输出进行处理，产生输入序列的编码表示。
从第三步开始变得不一样了：在第一个时间步，使用一个只有句首符号的空序列转换为嵌入(带有位置编码)，并被送入解码器。
由各解码器组成的解码器堆栈，将第三步的空序列嵌入与编码器的输出一起处理，产生目标序列第一个词的解码表示。
输出层将其转换为词概率和第一个目标单词。
将这一步产生的目标单词填入解码器输入的序列中的第二个时间步位置。在第二个时间步，解码器输入序列包含句首符号产生的 token 和第一个时间步产生的目标单词。
回到第 3 个步骤，与之前一样，将新的解码器序列输入模型。然后取输出的第二个词并将其附加到解码器序列中。重复这个步骤，直到它预测出一个句末标记。需要明确的是，由于编码器序列在每次迭代中都不会改变，我们不必每次都重复第 1 和第 2 步。

Detail

Self Attention

编码器在计算 Q K V 的时候，直接使用源序列作为输入。

解码器块在计算第一个 Q K V 的时候，直接使用目标序列作为输入。

Padding and Padding Mask

文本序列不定长，所以需要将其填充到相同的长度，这个填充操作即为 Padding。

由于 Padding 是没有意义的，所以我们并不希望 Attention 将 Padding 看做单词来计算。所以除了 Masked Multi-head Attention 之外，我们还需要为 Padding 添加一个 Mask，这个 Mask 用来指示当前序列中 Padding 的位置。

def attention(query, key, value, mask=None, dropout=None):
    """
    既能处理 3 维，也能处理 2 维。3 维即多头的情况，2 维即单头的情况
    """ 
    d_k = query.size(-1)
    # transpose(-2, -1) 方法对最后的两个维度进行转置
    # 之所以使用 -2 -1 是为了考虑多头注意力的情况
    # 无论单头还是多头 最后两个维度的数据一定是一个 K 矩阵
    scores = torch.matmul(query, key.transpose(-2, -1)) \
             / math.sqrt(d_k)
    if mask is not None:
        # 这里的 mask 有两个用途
        # 一种是在 Masked Multi-head Attention 中去除 Attention 机制
        # 另一种就是本节说的为 Padding 添加的 Mask
        scores = scores.masked_fill(mask == 0, -1e9)
    p_attn = F.softmax(scores, dim = -1)
    if dropout is not None:
        p_attn = dropout(p_attn)
    return torch.matmul(p_attn, value), p_attn

Label Smoothing

Label Smoothing 是一种正则化手段，它可以避免 One-hot 编码那样让交叉熵函数走向极端。

当模型输出并经过 Softmax 后，会形成一个对词汇库内的所有词的概率。而如果此时我们将正确答案使用独热编码，那在计算的时候，其它词的概率会因为乘以 0 而被忽略，只有正确的词影响到最终的交叉熵。这会导致模型过分注重此时的正确词汇，进而导致模型的过拟合。

Label Smoothing 在编码正确答案的时候，并不使用 one-hot 编码，而是将正确答案的概率设定为 $1 - s m o o t h i n g$ ， $s m o o t h i n g$ 是超参数。然后再将 $s m o o t h i n g$ 概率分给其它单词。

由于标签平滑的存在，如果模型对于某个单词特别有信心，输出特别大的概率，反而会提高损失。因为它使得其它单词的概率变得很小，进而与标签平滑后生成目标分布差异增加。

Parallel Training

Transformer 的训练是非常高效的，因为当我们给定一个输入序列和一个输出序列的时候，这些数据只需要通过模型一次就可以完成多次计算。

考虑两个序列：

源序列：I am a student
目标序列：我是学生

在 Encoder 对源序列生成潜在表征时，其输出一个张量 $b \times s e q \times b_{m o d e l}$ ，其中 $s e q \times b_{m o d e l}$ 表示这个句子被划分为的子序列的，也就是

I
I am
I am a

以上三种情况下，后面一个单词蕴含的上下文信息。在经过解码器后，解码器会同时输出以上三种情况下的下一个单词，并一次性计算损失，因此其训练十分高效。