这个文篇包含了两类mask，一类是 padding mask ，另一类则是 future mask ，第一类是用来减小padding的反向梯度的避免网络主要训练padding符号，第二类是用来遮挡后面的符号，前面的符号只能和之前的做线性或者非线性运算，不能和以后的符号有关系。

要提到transformer的attention的mask，就需要先来看看train的过程，mask主要是用来缩小某些符号在训练的时梯度，像padding符号，可能很多很多，网络绝大多数时间都用来训练pad符号去了的，梯度主要往pad下降去了的，导致网络训练很难收敛，甚至不能收敛的，此时就需要使用mask来避免pad符号对train的影响。

RNN或者LSTM内避免pad符号的影响可以参考这个：

numpy实现RNN和LSTM循环神经网络产生古诗 - 知乎 (zhihu.com)

transformer在train模型的时候，输入的数据是(batchsize, sequence_length, embed_dim)，这是已经做了embedding以后的结果，没有做embedding之前，是(batchsize, sequence_length)的样子，sequence_length是定长的但句子是不定长的，通常在train的时候，传入的数据，是文本段或者句子，但是每个句子或者文本段的长度都是不相同的，输入的时候要批量train，就需要padding句子或者段到等长，也就是sequence_length的长度。

Example：两个句子做输入

输入的数据
但是每个句子或者文本段

分词以及映射

首先需要做映射，字符或者词映射到数字，这边首先分词，【“输入的数据”】分词到【“输入 的 数据”】，【“但是每个句子或者文本段”】分词到【”但是 每个 句子 或者 文本 段 ”】，然后映射到数字即可,【“输入 的 数据 ” 】映射到 [0, 1, 2,]，【”但是 每个 句子 或者 文本 段 ”】映射到 [3, 4, 5, 6, 7, 10]，拿到的数组是[[0, 1, 2],[3, 4, 5, 6, 7, 10]]，这样的数组是不能送入网络train的，主要是大小不相同。需要做padding才可以，这里两个句子映射到不同的数字，主要是两个句子没有相同的词，所以数字都不相同。若是有相同的词，就需要映射到相同的数字才可以。

输入 的 数据  =====>   [0, 1, 2]
但是每个句子或者文本段 ======> [3, 4, 5, 6, 7, 10]

padding

首个句子需要做padding，少了三个数字，就需要padding三个pad符号，通常这个符号是记作""，也就是分词，然后padding，然后映射到数字就可以，padding符号映射到数字 666。padding以后就得到[[0, 1, 2, 666, 666, 666], [3, 4, 5, 6, 7, 10]]，数组的大小是 2行6列，可以送到网络train

输入 的 数据 <PAD> <PAD> <PAD> =====>   [0, 1, 2, 666, 666, 666]
但是每个句子或者文本段 ======> [3, 4, 5, 6, 7, 10]

Embedding+Position_embedding

下面需要做的就是Embedding，Embedding层映射数字到向量，向量一般都是小数，最后还需要和position_embedding相加，拿到最后的输入，假设已经拿到了最后的输入向量，也就是经过了Embedding和position_embedding相加的向量，而且简便起见的话，这里假设只有一个输入句子，也就是batch=1，既然batch=1，那么就不需要进行pad了，可以直接送入到网络进行train，不妨假设输入的句子是：

输入 的 数据 =====>   [0, 1, 2]

embed_dim=2，也就是一个数字映射到2dim的向量，经过Embedding和position_embedding相加以后拿到的向量是，也就是【输入】对应到token【 $a_1,a_2$ 】，【的】对应到token【 $d_1,d_2$】，【数据】对应到token【 $c_1,c_2$ 】。大小是1个batch3行2列即 [1, 3, 2]，每一行对应一个token

$\left[\begin{array}{c}输入\\ 的\\ 数据\end{array}\right]=\left[\begin{array}{c}0\\ 1\\ 2\end{array}\right]=\left[\begin{array}{cc}{a}_1& a_2\\ d_1& d_2\\ c_1& c_2\end{array}\right]$

在attention计算以前的话，还需要在最后一个dim做layer_norm，也就是对每个token做layer_norm操作，但是要简便起见，这边省略掉这个步骤，其实对每个token做layer_norm操作，不同的token之间是没有影响的，也就是a还是a,d还是d。像 $[a_1,a_2]$ 做layer_norm，也就是归一化操作，其他的token并不会影响到a。也就是，仍然是每一行对应一个token，(1, 3, 2)

KaTeX parse error: Expected 'EOF', got '_' at position 12: \text{layer_̲norm}\left(\lef…

Attention

这边开始做attention运算， $\text{attention}(Q,K,V)=\text{Softmax}\left(\frac{Q\cdot K^T}{\sqrt{d_i}}\right)\cdot V$

上面已经提到了，可以忽略掉layer_norm操作，不会影响对token的理解，所以这里假设对应的输入向量，还是

$IN=\left[\begin{array}{c}输入\\ 的\\ 数据\end{array}\right]=\left[\begin{array}{cc}{a}_1& a_2\\ d_1& d_2\\ c_1& c_2\end{array}\right]$ ，不妨假设这里的输入向量是：IN

$\text{attention}(Q,K,V)$ 的 $Q，K，V$ 都是使用了full connect拿到的，也就是

$Q=f{c}_1(\left(\left[\begin{array}{cc}{a}_1& a_2\\ d_1& d_2\\ c_1& c_2\end{array}\right]\right)$ $K=f{c}_2(\left(\left[\begin{array}{cc}{a}_1& a_2\\ d_1& d_2\\ c_1& c_2\end{array}\right]\right)$ $V=f{c}_3(\left(\left[\begin{array}{cc}{a}_1& a_2\\ d_1& d_2\\ c_1& c_2\end{array}\right]\right)$

这边用Q来做example，这里不妨假设full connect的dim是2行2列，也就是[2, 2]，输出是[1, 3, 2]

$Q=\left[\begin{array}{cc}{a}_1& a_2\\ d_1& d_2\\ c_1& c_2\end{array}\right]\cdot \left[\begin{array}{cc}{Q}_0& Q_1\\ Q_2& Q_3\end{array}\right]=\left[\begin{array}{cc}{a}_1{Q}_0+a_2{Q}_2& a_1{Q}_1+a_2{Q}_3\\ d_1{Q}_0+d_2{Q}_2& d_1{Q}_1+d_2{Q}_3\\ c_1{Q}_0+c_2{Q}_2& c_1{Q}_1+c_2{Q}_3\end{array}\right]$

可见，仍然是每一行对应一个token，而且每行的token只是自身的线性组合，不同的token之间并没有发生交互，也就是 $Q、K、V$ 的计算过程并不涉及到不同的token，而是每个token自身的线性组合

像第一行的token，还是a之间的组合并不涉及到d和c

上面还可以对 $Q、K、V$ 做简化版的表示，也就是向量化表示，看起来更加的直观，而且 表达了参加运算的向量或者权重矩阵 ，输出是[1, 3, 2]

$Q=\left[\begin{array}{cc}{a}_1& a_2\\ d_1& d_2\\ c_1& c_2\end{array}\right]\cdot \left[\begin{array}{cc}{Q}_0& Q_1\\ Q_2& Q_3\end{array}\right]=\left[\begin{array}{cc}{a}_1{Q}_0+a_2{Q}_2& a_1{Q}_1+a_2{Q}_3\\ d_1{Q}_0+d_2{Q}_2& d_1{Q}_1+d_2{Q}_3\\ c_1{Q}_0+c_2{Q}_2& c_1{Q}_1+c_2{Q}_3\end{array}\right]=\left[\begin{array}{cc}a{Q}^1& a{Q}^2\\ d{Q}^1& d{Q}^2\\ c{Q}^1& c{Q}^2\end{array}\right]$

$K=\left[\begin{array}{cc}{a}_1& a_2\\ d_1& d_2\\ c_1& c_2\end{array}\right]\cdot \left[\begin{array}{cc}{K}_0& K_1\\ K_2& K_3\end{array}\right]=\left[\begin{array}{cc}{a}_1{K}_0+a_2{K}_2& a_1{K}_1+a_2{K}_3\\ d_1{K}_0+d_2{K}_2& d_1{K}_1+d_2{K}_3\\ c_1{K}_0+c_2{K}_2& c_1{K}_1+c_2{K}_3\end{array}\right]=\left[\begin{array}{cc}a{K}^1& a{K}^2\\ d{K}^1& d{K}^2\\ c{K}^1& c{K}^2\end{array}\right]$

$V=\left[\begin{array}{cc}{a}_1& a_2\\ d_1& d_2\\ c_1& c_2\end{array}\right]\cdot \left[\begin{array}{cc}{V}_0& V_1\\ V_2& V_3\end{array}\right]=\left[\begin{array}{cc}{a}_1{V}_0+a_2{V}_2& a_1{V}_1+a_2{V}_3\\ d_1{V}_0+d_2{V}_2& d_1{V}_1+d_2{V}_3\\ c_1{V}_0+c_2{V}_2& c_1{V}_1+c_2{V}_3\end{array}\right]=\left[\begin{array}{cc}a{V}^1& a{V}^2\\ d{V}^1& d{V}^2\\ c{V}^1& c{V}^2\end{array}\right]$

拿到了 $Q、K、V$ 以后，就可以开始attention的运算了的 $\text{attention}(Q,K,V)=\text{Softmax}\left(\frac{Q\cdot K^T}{\sqrt{d_i}}\right)\cdot V$ ，首先来算出 $Q\cdot K^T$ ，输出是[1, 3, 3]

$Q\cdot K^T=$ $\left[\begin{array}{cc}a{Q}^1& a{Q}^2\\ d{Q}^1& d{Q}^2\\ c{Q}^1& c{Q}^2\end{array}\right]\cdot \left[\begin{array}{ccc}a{K}^1& d{K}^1& c{K}^1\\ a{K}^2& d{K}^2& c{K}^2\end{array}\right]$

$=\left[\begin{array}{ccc}a{Q}^{1}a{K}^1+a{Q}^{2}a{K}^2& a{Q}^{1}d{K}^1+a{Q}^{2}d{K}^2& a{Q}^{1}c{K}^1+a{Q}^{2}c{K}^2\\ d{Q}^{1}a{K}^1+d{Q}^{2}a{K}^2& d{Q}^{1}d{K}^1+d{Q}^{2}d{K}^2& d{Q}^{1}c{K}^1+d{Q}^{2}c{K}^2\\ c{Q}^{1}a{K}^1+c{Q}^{2}a{K}^2& c{Q}^{1}d{K}^1+c{Q}^{2}d{K}^2& c{Q}^{1}c{K}^1+c{Q}^{2}c{K}^2\end{array}\right]$

可见此时得到的就是不同的token之间的交互运算的结果， $Q\cdot K^T$ 内的每个计算结果，除去对角线的数字是同一个token内的运算，其他的数字都是不同的token之间运算得到的，像1行3列，就是token【a,c】之间的运算

上述式子看起来有些臃肿，不太方便观察，继续来做向量化的简化操作，表达了参加运算的向量或者权重矩阵，输出是[1, 3, 3]

$Q\cdot K^T=$ $\left[\begin{array}{ccc}aQaK& aQdK& aQcK\\ dQaK& dQdK& dQcK\\ cQaK& cQdK& cQcK\end{array}\right]$

$\text{attention}(Q,K,V)=\text{Softmax}\left(\frac{Q\cdot K^T}{\sqrt{d_i}}\right)\cdot V$ ，除以 $\sqrt{d_i}$ 是防止数值过大exp指数过大的，矩阵运算是相乘相加，累加会导致数值变大很多，所以需要除以一个常数，防止数值过大，导致exp指数运算结果越界的。

所以这里可以忽略掉除，不妨假设此时的运算公式变到了

： $\text{attention}(Q,K,V{)}^{\prime }=\text{Softmax}\left(Q\cdot K^T\right)\cdot V$

$\text{Softmax}\left(Q\cdot K^T\right)$ 是在最后一个dim运算的，也就是token层次来运算的，也就归一化的方向是最后一个dim，此时每一行都被归一化了，输出是[1, 3, 3]

$\text{Softmax}\left(Q\cdot K^T\right)=\left[\begin{array}{ccc}Softmax(a{Q}^{1}a{K}^1+a{Q}^{2}a{K}^2& a{Q}^{1}d{K}^1+a{Q}^{2}d{K}^2& a{Q}^{1}c{K}^1+a{Q}^{2}c{K}^2)\\ Softmax(d{Q}^{1}a{K}^1+d{Q}^{2}a{K}^2& d{Q}^{1}d{K}^1+d{Q}^{2}d{K}^2& d{Q}^{1}c{K}^1+d{Q}^{2}c{K}^2)\\ Softmax(c{Q}^{1}a{K}^1+c{Q}^{2}a{K}^2& c{Q}^{1}d{K}^1+c{Q}^{2}d{K}^2& c{Q}^{1}c{K}^1+c{Q}^{2}c{K}^2)\end{array}\right]$

$=\left[\begin{array}{ccc}(a{Q}^{1}a{K}^1+a{Q}^{2}a{K}^2{)}_s& (a{Q}^{1}d{K}^1+a{Q}^{2}d{K}^2{)}_s& (a{Q}^{1}c{K}^1+a{Q}^{2}c{K}^2{)}_s\\ (d{Q}^{1}a{K}^1+d{Q}^{2}a{K}^2{)}_s& (d{Q}^{1}d{K}^1+d{Q}^{2}d{K}^2{)}_s& (d{Q}^{1}c{K}^1+d{Q}^{2}c{K}^2{)}_s\\ (c{Q}^{1}a{K}^1+c{Q}^{2}a{K}^2{)}_s& (c{Q}^{1}d{K}^1+c{Q}^{2}d{K}^2{)}_s& (c{Q}^{1}c{K}^1+c{Q}^{2}c{K}^2{)}_s\end{array}\right]$

$=\left[\begin{array}{ccc}(aQaK{)}_s& (aQdK{)}_s& (aQcK{)}_s\\ (dQaK{)}_s& (dQdK{)}_s& (dQcK{)}_s\\ (cQaK{)}_s& (cQdK{)}_s& (cQcK{)}_s\end{array}\right]$

最后来运算得到 $\text{attention}(Q,K,V{)}^{\prime }=\text{Softmax}\left(Q\cdot K^T\right)\cdot V$ ，输出是[1, 3, 2]

$=\left[\begin{array}{ccc}(aQaK{)}_s& (aQdK{)}_s& (aQcK{)}_s\\ (dQaK{)}_s& (dQdK{)}_s& (dQcK{)}_s\\ (cQaK{)}_s& (cQdK{)}_s& (cQcK{)}_s\end{array}\right]\cdot \left[\begin{array}{cc}a{V}^1& a{V}^2\\ d{V}^1& d{V}^2\\ c{V}^1& c{V}^2\end{array}\right]$

$=\left[\begin{array}{cc}(aQaK{)}_{s}a{V}^1+(aQdK{)}_{s}d{V}^1+(aQcK{)}_{s}c{V}^1& (aQaK{)}_{s}a{V}^2+(aQdK{)}_{s}d{V}^2+(aQcK{)}_{s}c{V}^2\\ (dQaK{)}_{s}a{V}^1+(dQdK{)}_{s}d{V}^1+(dQcK{)}_{s}c{V}^1& (dQaK{)}_{s}a{V}^2+(dQdK{)}_{s}d{V}^2+(dQcK{)}_{s}c{V}^2\\ (cQaK{)}_{s}a{V}^1+(cQdK{)}_{s}d{V}^1+(cQcK{)}_{s}c{V}^1& (cQaK{)}_{s}a{V}^2+(cQdK{)}_{s}d{V}^2+(cQcK{)}_{s}c{V}^2\end{array}\right]$

从上述式子可见，最后的结果的每个数字，都是每个token之间，每个权重矩阵之间运算得到的结果

上面的运算没有用到mask的，实际mask作用的地方是在softmax前一步：

$\text{attention}(Q,K,V)=\text{Softmax}\left(\frac{Q\cdot K^T}{\sqrt{d_i}}+\text{mask}\right)\cdot V$

现在回到最开始的输入， $\left[\begin{array}{c}输入\\ 的\\ 数据\end{array}\right]=\left[\begin{array}{c}0\\ 1\\ 2\end{array}\right]=\left[\begin{array}{cc}{a}_1& a_2\\ d_1& d_2\\ c_1& c_2\end{array}\right]$ ，输入是三个token[3, 2]，输出也是三个token[3, 2]

上面提到了mask是用来防止pad对梯度的影响，不同的句子之间长度不同，需要Pad的内容非常多，导致了pad很多，从而每个batch的pad的token数量很多的，总体pad占比很大的，pad的梯度累加以后很大，会导致train不收敛，很难train的，所以要防止pad对梯度的影响，需要mask掉部分pad的梯度，也就是阻止某些Pad参加运算的，从而达到缩小pad梯度的目的。

若是从bert的source codes来看实践的操作，bert对pad这个token的mask操作方式是构造方阵的

具体的实现方式见下面，假设现在输入的是

输入 的 <PAD> ====== [0, 1, 666]

$\left[\begin{array}{c}输入\\ 的\\ \text{<PAD>}\end{array}\right]=\left[\begin{array}{c}0\\ 1\\ 666\end{array}\right]=\left[\begin{array}{cc}{a}_1& a_2\\ d_1& d_2\\ c_1& c_2\end{array}\right]$

现在来按照bert的方式来构造mask

第一步： 输入mask，也就是pad的地方置0，其他地方置1，大小是[batchsize, sequence_length]，这里的batchsize=1，sequence_length=3，所以输入的 input_mask = [[1, 1, 0]]，这里的0就是

第二步： 得到attention累加时的mask，根据上面推导的过程，可以得知累加的大小是[sequence_length, sequence_length]，也就是sequence_length大小的方阵，

若input是[1, 3]，输入embedding是[1, 3, 2]， $Q{K}^T$ 是[1, 3, 3]，则input_mask大小是[1, 3]，累加mask是[1, 3, 3]

若input是[2, 3]，输入embedding是[2, 3, 2]， $Q{K}^T$ 是[2, 3, 3]，则input_mask大小是[2, 3]，累加mask是[2, 3, 3]

KaTeX parse error: Expected 'EOF', got '_' at position 14: 若 \text{input_̲mask}=[[1, 1, 0…

KaTeX parse error: Expected 'EOF', got '_' at position 14: 若 \text{input_̲mask} = [[1, 1,…

codes是

bert/modeling.py at master · google-research/bert (github.com)

def create_masks(input_mask):
    input_mask = np.array(input_mask)
    n, sequence_length = input_mask.shape
    k1 = input_mask[:, None, :]
    k2 = np.ones_like(input_mask)[:, :, None]
    k3 = k1 * k2
    k = (1.0 - k3) * (-1e6)
    return k

现在拿到了mask的，input_mask = [[1, 1, 0]]

$\text{mask}=\left[\begin{array}{ccc}0& 0& -1e6\\ 0& 0& -1e6\\ 0& 0& -1e6\end{array}\right]$ ，输入是： $\left[\begin{array}{c}输入\\ 的\\ \text{<PAD>}\end{array}\right]=\left[\begin{array}{c}0\\ 1\\ 666\end{array}\right]=\left[\begin{array}{cc}{a}_1& a_2\\ d_1& d_2\\ c_1& c_2\end{array}\right]$

仍然是三个token，但是最后一个变到了pad，根据上面的运算输出可知：输出是[1, 3, 3]

$Q\cdot K^T=$ $\left[\begin{array}{cc}a{Q}^1& a{Q}^2\\ d{Q}^1& d{Q}^2\\ c{Q}^1& c{Q}^2\end{array}\right]\cdot \left[\begin{array}{ccc}a{K}^1& d{K}^1& c{K}^1\\ a{K}^2& d{K}^2& c{K}^2\end{array}\right]$

$=\left[\begin{array}{ccc}a{Q}^{1}a{K}^1+a{Q}^{2}a{K}^2& a{Q}^{1}d{K}^1+a{Q}^{2}d{K}^2& a{Q}^{1}c{K}^1+a{Q}^{2}c{K}^2\\ d{Q}^{1}a{K}^1+d{Q}^{2}a{K}^2& d{Q}^{1}d{K}^1+d{Q}^{2}d{K}^2& d{Q}^{1}c{K}^1+d{Q}^{2}c{K}^2\\ c{Q}^{1}a{K}^1+c{Q}^{2}a{K}^2& c{Q}^{1}d{K}^1+c{Q}^{2}d{K}^2& c{Q}^{1}c{K}^1+c{Q}^{2}c{K}^2\end{array}\right]$

$Q\cdot K^T=\left[\begin{array}{ccc}aQaK& aQdK& aQcK\\ dQaK& dQdK& dQcK\\ cQaK& cQdK& cQcK\end{array}\right]$

然后加上得到的mask就是 $Q\cdot K^T+\text{mask}$ ，相加得到了-1e6，忽略掉aQcK，dQcK，cQcK的reason是相对-1e6来说，它们很小的所以可以忽略掉， $aQcK-1e6\approx-1e6$

$\left[\begin{array}{ccc}aQaK& aQdK& aQcK\\ dQaK& dQdK& dQcK\\ cQaK& cQdK& cQcK\end{array}\right]+\left[\begin{array}{ccc}0& 0& -1e6\\ 0& 0& -1e6\\ 0& 0& -1e6\end{array}\right]$ $=\left[\begin{array}{ccc}aQaK& aQdK& -1e6\\ dQaK& dQdK& -1e6\\ cQaK& cQdK& -1e6\end{array}\right]$

然后对每个token做softmax操作归一化，也就是对每行做softmax，axis = -1，softmax以后-1e6会被归一化到0

$\text{softmax}\left(Q\cdot K^T+\text{mask},-1\right)=\left[\begin{array}{ccc}\text{Softmax(}aQaK& aQdK& -1e6)\\ \text{Softmax(}dQaK& dQdK& -1e6)\\ \text{Softmax(}cQaK& cQdK& -1e6)\end{array}\right]$

$=\left[\begin{array}{ccc}(aQaK{)}_s& (aQdK{)}_s& 0\\ (dQaK{)}_s& (dQdK{)}_s& 0\\ (cQaK{)}_s& (cQdK{)}_s& 0\end{array}\right]$

最后就是算 $\text{attention}(Q,K,V)=\text{Softmax}\left(Q\cdot K^T+\text{mask}\right)\cdot V$ ，上面已算过了代入得

$=\left[\begin{array}{ccc}(aQaK{)}_s& (aQdK{)}_s& 0\\ (dQaK{)}_s& (dQdK{)}_s& 0\\ (cQaK{)}_s& (cQdK{)}_s& 0\end{array}\right]\cdot \left[\begin{array}{cc}a{V}^1& a{V}^2\\ d{V}^1& d{V}^2\\ c{V}^1& c{V}^2\end{array}\right]$

$=\left[\begin{array}{cc}(aQaK{)}_{s}a{V}^1+(aQdK{)}_{s}d{V}^1+0& (aQaK{)}_{s}a{V}^2+(aQdK{)}_{s}d{V}^2+0\\ (dQaK{)}_{s}a{V}^1+(dQdK{)}_{s}d{V}^1+0& (dQaK{)}_{s}a{V}^2+(dQdK{)}_{s}d{V}^2+0\\ (cQaK{)}_{s}a{V}^1+(cQdK{)}_{s}d{V}^1+0& (cQaK{)}_{s}a{V}^2+(cQdK{)}_{s}d{V}^2+0\end{array}\right]$

和之前运算得到的结果相比较，可以发现的，少了很多和c也就是相关的内容，此时c的梯度就变少了，累加的梯度变小了，网络在train的时候会少关注，不会因过多，网络train的时候往的梯度方向下降，这样就可以正常训练网络，这里要特别注意的是， 含c的项是减少了，并不是全部删除了 ，所以网络在train的时候c还是有梯度的，但是变小很多了，下面的式子内有10个含c的项，上面加上了mask以后，含c的项可以发现只有2+2个了，10变到了2+2，可见变少了很多，所以c的累加梯度也变小了很多的，mask只能减小梯度，并不能完全删除的。

$=\left[\begin{array}{cc}(aQaK{)}_{s}a{V}^1+(aQdK{)}_{s}d{V}^1+(aQcK{)}_{s}c{V}^1& (aQaK{)}_{s}a{V}^2+(aQdK{)}_{s}d{V}^2+(aQcK{)}_{s}c{V}^2\\ (dQaK{)}_{s}a{V}^1+(dQdK{)}_{s}d{V}^1+(dQcK{)}_{s}c{V}^1& (dQaK{)}_{s}a{V}^2+(dQdK{)}_{s}d{V}^2+(dQcK{)}_{s}c{V}^2\\ (cQaK{)}_{s}a{V}^1+(cQdK{)}_{s}d{V}^1+(cQcK{)}_{s}c{V}^1& (cQaK{)}_{s}a{V}^2+(cQdK{)}_{s}d{V}^2+(cQcK{)}_{s}c{V}^2\end{array}\right]$

现在来考虑embed_dim=1的情况，也就是position_embedding=1, words_embedding=1

所以假设输入的是，由没有符号，所以mask是全0

输入 - [0]
的   - [1]

$\left[\begin{array}{c}输入\\ 的\end{array}\right]=\left[\begin{array}{c}0\\ 1\end{array}\right]=\left[\begin{array}{c}{a}_1\\ d_1\end{array}\right]$ [1, 2, 1]，即batchsize=1, sequence_length = 2, embed_dim = 1

所以Q、K、V运算的full connect的矩阵大小就是[1, 1]，也就是一个数字

拿到的Q、K、V的大小是[1, 2, 1]， mask = [1, 2, 2] = 0

$Q=\left[\begin{array}{c}{a}_1\\ d_1\end{array}\right]\cdot \left[\begin{array}{c}{Q}_0\end{array}\right]=\left[\begin{array}{c}{a}_1{Q}_0\\ d_1{Q}_0\end{array}\right]$ $K=\left[\begin{array}{c}{a}_1{K}_0\\ d_1{K}_0\end{array}\right]$ $V=\left[\begin{array}{c}{a}_1{V}_0\\ d_1{V}_0\end{array}\right]$

$Q\cdot K^T=\left[\begin{array}{c}{a}_1{Q}_0\\ d_1{Q}_0\end{array}\right]\cdot \left[\begin{array}{cc}{a}_1{K}_0& d_1{K}_0\end{array}\right]=\left[\begin{array}{cc}{a}_1^2{K}_0& a_1{d}_1{Q}_0{K}_0\\ d_1{a}_1{K}_0{Q}_0& d_1^2{Q}_0{K}_0\end{array}\right]$

现在来算最后的输出 $\text{attention}(Q,K,V)=\text{Softmax}\left(Q\cdot K^T+\text{mask}\right)\cdot V$

$\text{Softmax}\left(Q\cdot K^T+\text{mask}\right)=\left[\begin{array}{cc}\text{Softmax}(a_1^2{K}_0& a_1{d}_1{Q}_0{K}_0)\\ \text{Softmax}(d_1{a}_1{K}_0{Q}_0& d_1^2{Q}_0{K}_0)\end{array}\right]$

$=\left[\begin{array}{cc}(a_1^2{K}_0{)}_s& (a_1{d}_1{Q}_0{K}_0{)}_s\\ (d_1{a}_1{K}_0{Q}_0{)}_s& (d_1^2{Q}_0{K}_0{)}_s\end{array}\right]$

$\text{Softmax}\left(Q\cdot K^T+\text{mask}\right)\cdot V=\left[\begin{array}{cc}(a_1^2{K}_0{)}_s& (a_1{d}_1{Q}_0{K}_0{)}_s\\ (d_1{a}_1{K}_0{Q}_0{)}_s& (d_1^2{Q}_0{K}_0{)}_s\end{array}\right]\cdot \left[\begin{array}{c}{a}_1{V}_0\\ d_1{V}_0\end{array}\right]$

$=\left[\begin{array}{c}(a_1^2{K}_0{)}_s{a}_1{V}_0+(a_1{d}_1{Q}_0{K}_0{)}_s{d}_1{V}_0\\ (d_1{a}_1{K}_0{Q}_0{)}_s{a}_1{V}_0+(d_1^2{Q}_0{K}_0{)}_s{d}_1{V}_0\end{array}\right]$ ，即输出[1, 2, 1]

若是存在个，mask此时就不是全0

像输入 $\left[\begin{array}{c}输入\\ <PAD>\end{array}\right]=\left[\begin{array}{cc}0& 666\end{array}\right]=\left[\begin{array}{c}{a}_1\\ d_1\end{array}\right]$ [1,2,1]，input_mask的shape和输入相同的[1, 2, 1]

mask的shape是[1, 2, 2]

KaTeX parse error: Expected 'EOF', got '_' at position 14: 若 \text{input_̲mask}=[[1, 0]] …

那么得到的输出就是

$\text{Softmax}\left(Q\cdot K^T+\text{mask}\right)=\left[\begin{array}{cc}\text{Softmax}(a_1^2{K}_0& -1e6)\\ \text{Softmax}(d_1{a}_1{K}_0{Q}_0& -1e6)\end{array}\right]=\left[\begin{array}{cc}(a_1^2{K}_0{)}_s& 0\\ (d_1{a}_1{K}_0{Q}_0{)}_s& 0\end{array}\right]$

$\text{Softmax}\left(Q\cdot K^T+\text{mask}\right)\cdot V=\left[\begin{array}{cc}(a_1^2{K}_0{)}_s& 0\\ (d_1{a}_1{K}_0{Q}_0{)}_s& 0\end{array}\right]\cdot \left[\begin{array}{c}{a}_1{V}_0\\ d_1{V}_0\end{array}\right]$

$=\left[\begin{array}{c}(a_1^2{K}_0{)}_s{a}_1{V}_0+0\\ (d_1{a}_1{K}_0{Q}_0{)}_s{a}_1{V}_0+0\end{array}\right]$

此时的项减少了2项，还剩一项的呢，所以达到了减少梯度的目的

RNN或者LSTM内避免pad符号的影响可以参考这个：

numpy实现RNN和LSTM循环神经网络产生古诗 - 知乎 (zhihu.com)

下一篇：
transformer网络内attention使用的mask第二篇 https://blog.csdn.net/m0_50617544/article/details/132182164

参考：

bert/modeling.py at master · google-research/bert (github.com)

Masking in Transformers’ self-attention mechanism | by Samuel Kierszbaum, PhD | Analytics Vidhya | Medium

BrianPulfer/PapersReimplementations: Personal short implementations of Machine Learning papers (github.com)

How Do Self-Attention Masks Work? | by Gabriel Mongaras | MLearning.ai | Medium

Your Repositories (github.com)

https://zhuanlan.zhihu.com/p/645442074