用一个具体到数字的例子理解transformer——“The dog runs fast”这句话在transformer中如何翻译为“狗跑得快”？

假设我们要将英文句子 “The dog runs fast” 翻译成中文，设定词表大小 $V_{src}=10000$（源语言词表大小），$V_{tgt}=8000$（目标语言词表大小），模型维度 $d_{model}=512$，序列最大长度 $max\_le{n}_{src}=20$（源语言序列最大长度），$max\_le{n}_{tgt}=20$（目标语言序列最大长度），头的数量 $h=8$，头维度 $d_k=64$，前馈网络中间维度 $d_{f}f=2048$ 。

已知的矩阵

• 词嵌入矩阵
  • 对于源语言和目标语言的词嵌入矩阵（如 $E_{src}\in {\mathbb{R}}^{10000\times 512}$ 和 $E_{tgt}\in {\mathbb{R}}^{8000\times 512}$），维度依据词表大小和模型维度确定。这里的512是词向量（词嵌入）维度，不一定是512，比如glove词嵌入就有很多版本。词表维度也是方便计算假设的。
• 位置编码矩阵
  • 位置编码矩阵（如 $P{E}_{src}\in {\mathbb{R}}^{20\times 512}$ 和 $P{E}_{tgt}\in {\mathbb{R}}^{20\times 512}$）依据位置编码公式（$P{E}_{(pos,2i)}=\sin (pos/10000^{2i/512})$ 和 $P{E}_{(pos,2i+1)}=\cos (pos/10000^{2i/512})$）预先计算得出。

初始化之后慢慢训练得到的矩阵

• 多头注意力机制中的权重矩阵
  • 在多头注意力机制中，$W_Q,W_K,W_V\in {\mathbb{R}}^{512\times 64}$ 和 $W_O\in {\mathbb{R}}^{512\times 512}$ 这些权重矩阵需初始化，然后在训练过程中借助反向传播不断更新。其初始化通常采用随机初始化方式（如从正态分布或均匀分布中采样），训练时用损失函数计算梯度，用优化器（如 Adam）更新矩阵参数。
• 前馈神经网络中的权重矩阵
  • 前馈神经网络中的 $W_1\in {\mathbb{R}}^{512\times 2048}$ 和 $W_2\in {\mathbb{R}}^{2048\times 512}$ 以及偏置向量 $b_1$ 和 $b_2$ 同样初始化后经训练得到。在翻译任务重前馈神经网络可以使模型能学习到数据中的语义和语法等复杂模式。
• 层归一化中的参数
  • 层归一化中的 $\gamma$ 和 $\beta$ 参数可学习。初始化后在训练过程中调整，以适应数据分布特点，助力模型更好地训练和收敛。在 $LN(X)=\gamma \frac{X-\mu }{\sqrt{{\sigma }^2+ϵ}}+\beta$ 中，$\gamma$ 和 $\beta$ 会依据训练数据的统计特性（均值 $\mu$ 和方差 ${\sigma }^2$）以及模型训练目标进行更新。

  ---

  开始计算！！！！！！！！！！

1. 词嵌入

• 源语言词嵌入：源语言词嵌入矩阵 $E_{src}\in {\mathbb{R}}^{10000\times 512}$。假设 “The”、“dog”、“runs”、“fast” 在源语言词表中的索引分别为 $100$、$200$、$300$、$400$。对于单词 “The”，其嵌入向量 $x_{100}=E_{src}[100,:]\in {\mathbb{R}}^{512}$，同理可得其他单词的嵌入向量。整个源语言输入序列 $X_{src}\in {\mathbb{R}}^{1\times 4\times 512}$（这里假设 batch_size 为 1 ）。
• 目标语言词嵌入：在训练解码器时，目标语言输入序列同样需要词嵌入。目标语言词嵌入矩阵 $E_{tgt}\in {\mathbb{R}}^{8000\times 512}$。假设目标语言序列 “狗 跑 得 快” 的词在词表中索引分别为 $50$、$60$、$70$、$80$，其嵌入向量组成目标语言输入序列 $X_{tgt}\in {\mathbb{R}}^{1\times 4\times 512}$。

2. 位置编码

• 源语言位置编码：位置编码矩阵 $P{E}_{src}\in {\mathbb{R}}^{20\times 512}$。位置编码公式为：
  $P{E}_{(pos,2i)}=\sin (pos/10000^{2i/512})$
  $P{E}_{(pos,2i+1)}=\cos (pos/10000^{2i/512})$
  例如，第一个位置 $pos=0$ 时，$P{E}_{(0,0)}=\sin (0)$，$P{E}_{(0,1)}=\cos (0)$ 。源语言输入序列 $X_{src}$ 与位置编码相加：$X_{src}^{\prime }=X_{src}+P{E}_{src}[:,:4,:]$ ，得到 $X_{src}^{\prime }\in {\mathbb{R}}^{1\times 4\times 512}$。
• 目标语言位置编码：同理，目标语言位置编码矩阵 $P{E}_{tgt}\in {\mathbb{R}}^{20\times 512}$，目标语言输入序列 $X_{tgt}$ 与位置编码相加：$X_{tgt}^{\prime }=X_{tgt}+P{E}_{tgt}[:,:4,:]$ ，得到 $X_{tgt}^{\prime }\in {\mathbb{R}}^{1\times 4\times 512}$。

3. 编码器

多头注意力机制

• 计算注意力分数（Attention Scores）：将输入 $X_{src}^{\prime }$ 线性变换为查询（Query）、键（Key）和值（Value）矩阵：
  $Q=X_{src}^{\prime }{W}_Q$, $K=X_{src}^{\prime }{W}_K$, $V=X_{src}^{\prime }{W}_V$
  其中 $W_Q,W_K,W_V\in {\mathbb{R}}^{512\times 64}$。
  $Q\in {\mathbb{R}}^{1\times 4\times 64}$，$K\in {\mathbb{R}}^{1\times 4\times 64}$，$V\in {\mathbb{R}}^{1\times 4\times 64}$。
  注意力分数矩阵 $A$ 计算如下：
  $A=\text{Softmax}(\frac{Q{K}^T}{\sqrt{64}})$
  $Q{K}^T\in {\mathbb{R}}^{1\times 4\times 4}$，经过Softmax后 $A\in {\mathbb{R}}^{1\times 4\times 4}$。
• 计算注意力输出（Attention Output）：注意力输出 $Z$ 为：
  $Z=AV$
  $Z\in {\mathbb{R}}^{1\times 4\times 64}$。
• 多头拼接与线性变换：多头注意力有 $h=8$ 个头，每个头都进行上述计算，得到 $Z_1,Z_2,\cdots ,Z_8$，每个 $Z_i\in {\mathbb{R}}^{1\times 4\times 64}$。
  拼接后 $Z_{concat}=[Z_1;Z_2;\cdots ;Z_8]\in {\mathbb{R}}^{1\times 4\times 512}$。
  最终多头注意力输出：
  $\text{MultiHeadAttention}(X_{src}^{\prime })=Z_{concat}{W}_O$
  其中 $W_O\in {\mathbb{R}}^{512\times 512}$，输出 $\text{MultiHeadAttention}(X_{src}^{\prime })\in {\mathbb{R}}^{1\times 4\times 512}$。

前馈神经网络

$FFN(Z)=\text{ReLU}(Z{W}_1+b_1)W_2+b_2$
其中 $W_1\in {\mathbb{R}}^{512\times 2048}$，$W_2\in {\mathbb{R}}^{2048\times 512}$。
$Z\in {\mathbb{R}}^{1\times 4\times 512}$，$Z{W}_1+b_1\in {\mathbb{R}}^{1\times 4\times 2048}$，经过ReLU后维度不变，再乘以 $W_2$ 得到 $FFN(Z)\in {\mathbb{R}}^{1\times 4\times 512}$。

层归一化

对多头注意力输出或前馈神经网络输出进行层归一化：
$LN(X)=\gamma \frac{X-\mu }{\sqrt{{\sigma }^2+ϵ}}+\beta$
$\mu$ 和 ${\sigma }^2$ 是沿着特征维度（这里是 $512$ 维）计算的均值和方差，$\gamma$ 和 $\beta$ 是可学习参数，输出维度与输入 $X$ 相同，假设输入 $X\in {\mathbb{R}}^{1\times 4\times 512}$，输出也为 ${\mathbb{R}}^{1\times 4\times 512}$。

经过上述编码器处理后，最终编码器输出 $Z_{encoder}\in {\mathbb{R}}^{1\times 4\times 512}$。

4. 解码器

掩码多头注意力

• 计算注意力分数：先将输入 $X_{tgt}^{\prime }$ 线性变换为查询（Query）、键（Key）和值（Value）矩阵：
  $Q_{mask}=X_{tgt}^{\prime }{W}_{Q_{mask}}$, $K_{mask}=X_{tgt}^{\prime }{W}_{K_{mask}}$, $V_{mask}=X_{tgt}^{\prime }{W}_{V_{mask}}$
  其中 $W_{Q_{mask}},W_{K_{mask}},W_{V_{mask}}\in {\mathbb{R}}^{512\times 64}$。
  $Q_{mask}\in {\mathbb{R}}^{1\times 4\times 64}$，$K_{mask}\in {\mathbb{R}}^{1\times 4\times 64}$，$V_{mask}\in {\mathbb{R}}^{1\times 4\times 64}$。

计算注意力分数矩阵 $A_{mask}$ 时，引入掩码矩阵 $M$：
$A_{mask}=\text{Softmax}(\frac{Q_{mask}{K}_{mask}^T}{\sqrt{64}}+M)$
掩码矩阵 $M$ 是一个下三角矩阵（对于长度为 $L$ 的序列，$M_{ij}=-\infty$ 如果 $i>j$，$M_{ij}=0$ 如果 $i\le j$），这里 $M\in {\mathbb{R}}^{4\times 4}$。这样可以确保在计算注意力分数时，当前位置不会关注到未来位置的信息。经过Softmax后 $A_{mask}\in {\mathbb{R}}^{1\times 4\times 4}$。

• 计算注意力输出：注意力输出 $Z_{mask}$ 为：
  $Z_{mask}=A_{mask}{V}_{mask}$
  $Z_{mask}\in {\mathbb{R}}^{1\times 4\times 64}$。
• 多头拼接与线性变换：同样有 $h=8$ 个头，每个头都进行上述计算，得到 $Z_{mask1},Z_{mask2},\cdots ,Z_{mask8}$，每个 $Z_{maski}\in {\mathbb{R}}^{1\times 4\times 64}$。
  拼接后 $Z_{mask\_concat}=[Z_{mask1};Z_{mask2};\cdots ;Z_{mask8}]\in {\mathbb{R}}^{1\times 4\times 512}$。
  经过线性变换：
  $\text{MaskedMultiHeadAttention}(X_{tgt}^{\prime })=Z_{mask\_concat}{W}_{O_{mask}}$
  其中 $W_{O_{mask}}\in {\mathbb{R}}^{512\times 512}$，输出 $\text{MaskedMultiHeadAttention}(X_{tgt}^{\prime })\in {\mathbb{R}}^{1\times 4\times 512}$。

编码器 - 解码器注意力

• 计算注意力分数：将掩码多头注意力的输出 $Z_{mask\_out}$ 线性变换为查询矩阵 $Q_{enc-dec}$，编码器输出 $Z_{encoder}$ 线性变换为键矩阵 $K_{enc-dec}$ 和值矩阵 $V_{enc-dec}$：
  $Q_{enc-dec}=Z_{mask\_out}{W}_{Q_{enc-dec}}$, $K_{enc-dec}=Z_{encoder}{W}_{K_{enc-dec}}$, $V_{enc-dec}=Z_{encoder}{W}_{V_{enc-dec}}$
  其中 $W_{Q_{enc-dec}},W_{K_{enc-dec}},W_{V_{enc-dec}}\in {\mathbb{R}}^{512\times 64}$。
  $Q_{enc-dec}\in {\mathbb{R}}^{1\times 4\times 64}$，$K_{enc-dec}\in {\mathbb{R}}^{1\times 4\times 64}$，$V_{enc-dec}\in {\mathbb{R}}^{1\times 4\times 64}$。

计算注意力分数矩阵 $A_{enc-dec}$：
$A_{enc-dec}=\text{Softmax}(\frac{Q_{enc-dec}{K}_{enc-dec}^T}{\sqrt{64}})$
$Q_{enc-dec}{K}_{enc-dec}^T\in {\mathbb{R}}^{1\times 4\times 4}$，经过Softmax后 $A_{enc-dec}\in {\mathbb{R}}^{1\times 4\times 4}$。

• 计算注意力输出（Attention Output）：注意力输出 $Z_{enc-dec}$ 为：
  $Z_{enc-dec}=A_{enc-dec}{V}_{enc-dec}$
  $Z_{enc-dec}\in {\mathbb{R}}^{1\times 4\times 64}$。
• 多头拼接与线性变换：多头操作与前面类似，得到 $Z_{enc-dec\_concat}\in {\mathbb{R}}^{1\times 4\times 512}$，再经过线性变换：
  $\text{EncoderDecoderAttention}(Z_{mask\_out},Z_{encoder})=Z_{enc-dec\_concat}{W}_{O_{enc-dec}}$
  其中 $W_{O_{enc-dec}}\in {\mathbb{R}}^{512\times 512}$，输出 $\text{EncoderDecoderAttention}(Z_{mask\_out},Z_{encoder})\in {\mathbb{R}}^{1\times 4\times 512}$。

前馈神经网络与层归一化

与编码器中的前馈神经网络和层归一化类似。
前馈神经网络：
$FFN(Z_{enc-dec\_out})=\text{ReLU}(Z_{enc-dec\_out}{W}_1+b_1)W_2+b_2$
其中 $W_1\in {\mathbb{R}}^{512\times 2048}$，$W_2\in {\mathbb{R}}^{2048\times 512}$，输出 $FFN(Z_{enc-dec\_out})\in {\mathbb{R}}^{1\times 4\times 512}$。

然后进行层归一化，得到最终的解码器输出 $Outpu{t}_{decoder}\in {\mathbb{R}}^{1\times 4\times 512}$。

5. 最终输出

将解码器输出通过线性变换矩阵 $W_{final}\in {\mathbb{R}}^{512\times 8000}$，再经过Softmax函数得到输出概率分布，用于生成翻译结果。例如，输出 $logits\in {\mathbb{R}}^{1\times 4\times 8000}$，经过Softmax后得到每个位置对应目标语言词表中每个词的概率，从而选择概率最高的词作为翻译结果。

至此，完成了这句话的训练。好多句话经过这个流程后，需要训练的参数逐渐完善，然后输入一句新的话，经过上述流程就可以得到它的翻译了。

代码实现：

import tensorflow as tf
import numpy as np


def positional_encoding(position, d_model):
    angle_rates = 1 / np.power(10000, (2 * (np.arange(d_model)[np.newaxis, :] // 2)) / np.float32(d_model))
    angle_rads = np.arange(position)[:, np.newaxis] * angle_rates
    # 应用 sin 到偶数索引位置
    angle_rads[:, 0::2] = np.sin(angle_rads[:, 0::2])
    # 应用 cos 到奇数索引位置
    angle_rads[:, 1::2] = np.cos(angle_rads[:, 1::2])
    pos_encoding = angle_rads[np.newaxis,...]
    return tf.cast(pos_encoding, dtype=tf.float32)


def scaled_dot_product_attention(q, k, v, mask):
    matmul_qk = tf.matmul(q, k, transpose_b=True)
    dk = tf.cast(tf.shape(k)[-1], tf.float32)
    scaled_attention_logits = matmul_qk / tf.sqrt(dk)
    if mask is not None:
        scaled_attention_logits += (mask * -1e9)
    attention_weights = tf.nn.softmax(scaled_attention_logits, axis=-1)
    output = tf.matmul(attention_weights, v)
    return output, attention_weights


def point_wise_feed_forward_network(d_model, dff):
    return tf.keras.Sequential([
        tf.keras.layers.Dense(dff, activation='relu'),
        tf.keras.layers.Dense(d_model)
    ])


class MultiHeadAttention(tf.keras.layers.Layer):
    def __init__(self, d_model, num_heads):
        super(MultiHeadAttention, self).__init__()
        self.num_heads = num_heads
        self.d_model = d_model
        assert d_model % num_heads == 0
        self.depth = d_model // num_heads
        self.wq = tf.keras.layers.Dense(d_model)
        self.wk = tf.keras.layers.Dense(d_model)
        self.wv = tf.keras.layers.Dense(d_model)
        self.dense = tf.keras.layers.Dense(d_model)

    def split_heads(self, x, batch_size):
        x = tf.reshape(x, (batch_size, -1, self.num_heads, self.depth))
        return tf.transpose(x, perm=[0, 2, 1, 3])

    def call(self, v, k, q, mask):
        batch_size = tf.shape(q)[0]
        q = self.wq(q)
        k = self.wk(k)
        v = self.wv(v)
        q = self.split_heads(q, batch_size)
        k = self.split_heads(k, batch_size)
        v = self.split_heads(v, batch_size)
        scaled_attention, attention_weights = scaled_dot_product_attention(q, k, v, mask)
        scaled_attention = tf.transpose(scaled_attention, perm=[0, 2, 1, 3])
        concat_attention = tf.reshape(scaled_attention, (batch_size, -1, self.d_model))
        output = self.dense(concat_attention)
        return output, attention_weights


class EncoderLayer(tf.keras.layers.Layer):
    def __init__(self, d_model, num_heads, dff, rate=0.1):
        super(EncoderLayer, self).__init__()
        self.mha = MultiHeadAttention(d_model, num_heads)
        self.ffn = point_wise_feed_forward_network(d_model, dff)
        self.layernorm1 = tf.keras.layers.LayerNormalization(epsilon=1e-6)
        self.layernorm2 = tf.keras.layers.LayerNormalization(epsilon=1e-6)
        self.dropout1 = tf.keras.layers.Dropout(rate)
        self.dropout2 = tf.keras.layers.Dropout(rate)

    def call(self, x, training, mask):
        attn_output, _ = self.mha(x, x, x, mask)
        attn_output = self.dropout1(attn_output, training=training)
        out1 = self.layernorm1(x + attn_output)
        ffn_output = self.ffn(out1)
        ffn_output = self.dropout2(ffn_output, training=training)
        out2 = self.layernorm2(out1 + ffn_output)
        return out2


class DecoderLayer(tf.keras.layers.Layer):
    def __init__(self, d_model, num_heads, dff, rate=0.1):
        super(DecoderLayer, self).__init__()
        self.mha1 = MultiHeadAttention(d_model, num_heads)
        self.mha2 = MultiHeadAttention(d_model, num_heads)
        self.ffn = point_wise_feed_forward_network(d_model, dff)
        self.layernorm1 = tf.keras.layers.LayerNormalization(epsilon=1e-6)
        self.layernorm2 = tf.keras.layers.LayerNormalization(epsilon=1e-6)
        self.layernorm3 = tf.keras.layers.LayerNormalization(epsilon=1e-6)
        self.dropout1 = tf.keras.layers.Dropout(rate)
        self.dropout2 = tf.keras.layers.Dropout(rate)
        self.dropout3 = tf.keras.layers.Dropout(rate)

    def call(self, x, enc_output, training, look_ahead_mask, padding_mask):
        attn1, attn_weights_block1 = self.mha1(x, x, x, look_ahead_mask)
        attn1 = self.dropout1(attn1, training=training)
        out1 = self.layernorm1(x + attn1)
        attn2, attn_weights_block2 = self.mha2(enc_output, enc_output, out1, padding_mask)
        attn2 = self.dropout2(attn2, training=training)
        out2 = self.layernorm2(out1 + attn2)
        ffn_output = self.ffn(out2)
        ffn_output = self.dropout3(ffn_output, training=training)
        out3 = self.layernorm3(out2 + ffn_output)
        return out3, attn_weights_block1, attn_weights_block2


class Encoder(tf.keras.layers.Layer):
    def __init__(self, num_layers, d_model, num_heads, dff, input_vocab_size, maximum_position_encoding, rate=0.1):
        super(Encoder, self).__init__()
        self.d_model = d_model
        self.num_layers = num_layers
        self.embedding = tf.keras.layers.Embedding(input_vocab_size, d_model)
        self.pos_encoding = positional_encoding(maximum_position_encoding, self.d_model)
        self.enc_layers = [EncoderLayer(d_model, num_heads, dff, rate) for _ in range(num_layers)]
        self.dropout = tf.keras.layers.Dropout(rate)

    def call(self, x, training, mask):
        seq_len = tf.shape(x)[1]
        x = self.embedding(x)
        x *= tf.math.sqrt(tf.cast(self.d_model, tf.float32))
        x += self.pos_encoding[:, :seq_len, :]
        x = self.dropout(x, training=training)
        for i in range(self.num_layers):
            x = self.enc_layers[i](x, training, mask)
        return x


class Decoder(tf.keras.layers.Layer):
    def __init__(self, num_layers, d_model, num_heads, dff, target_vocab_size, maximum_position_encoding, rate=0.1):
        super(Decoder, self).__init__()
        self.d_model = d_model
        self.num_layers = num_layers
        self.embedding = tf.keras.layers.Embedding(target_vocab_size, d_model)
        self.pos_encoding = positional_encoding(maximum_position_encoding, self.d_model)
        self.dec_layers = [DecoderLayer(d_model, num_heads, dff, rate) for _ in range(num_layers)]
        self.dropout = tf.keras.layers.Dropout(rate)

    def call(self, x, enc_output, training, look_ahead_mask, padding_mask):
        seq_len = tf.shape(x)[1]
        x = self.embedding(x)
        x *= tf.math.sqrt(tf.cast(self.d_model, tf.float32))
        x += self.pos_encoding[:, :seq_len, :]
        x = self.dropout(x, training=training)
        for i in range(self.num_layers):
            x, block1, block2 = self.dec_layers[i](x, enc_output, training, look_ahead_mask, padding_mask)
        return x


class Transformer(tf.keras.Model):
    def __init__(self, num_layers, d_model, num_heads, dff, input_vocab_size, target_vocab_size, pe_input, pe_target, rate=0.1):
        super(Transformer, self).__init__()
        self.encoder = Encoder(num_layers, d_model, num_heads, dff, input_vocab_size, pe_input, rate)
        self.decoder = Decoder(num_layers, d_model, num_heads, dff, target_vocab_size, pe_target, rate)
        self.final_layer = tf.keras.layers.Dense(target_vocab_size)

    def call(self, inp, tar, training, enc_padding_mask, look_ahead_mask, dec_padding_mask):
        enc_output = self.encoder(inp, training, enc_padding_mask)
        dec_output = self.decoder(tar, enc_output, training, look_ahead_mask, dec_padding_mask)
        final_output = self.final_layer(dec_output)
        return final_output


# 示例使用
num_layers = 4
d_model = 128
dff = 512
num_heads = 8
input_vocab_size = 5000
target_vocab_size = 5000
dropout_rate = 0.1
input_sequence_length = 20
target_sequence_length = 20

transformer = Transformer(num_layers, d_model, num_heads, dff, input_vocab_size, target_vocab_size, input_sequence_length, target_sequence_length, dropout_rate)

input_tensor = tf.placeholder(tf.int32, shape=(None, input_sequence_length))
target_tensor = tf.placeholder(tf.int32, shape=(None, target_sequence_length))
enc_padding_mask = None  # 根据需要创建掩码
look_ahead_mask = None  # 根据需要创建掩码
dec_padding_mask = None  # 根据需要创建掩码

outputs = transformer(input_tensor, target_tensor, True, enc_padding_mask, look_ahead_mask, dec_padding_mask)
print(outputs)