deep learning 13. transformer 代码详细解析之decoder

开始的话：
从基础做起，不断学习，坚持不懈，加油。
一位爱生活爱技术来自火星的程序汪

$bert$系列：

1. $bert$ 语料生成
2. $bert$ $loss解析$
3. $bert$ $transformer$详细解析之$encoder$
4. $bert$ $transformer$详细解析之$decoder$

话不多说，直接开始今天的主要内容。

    def decode(self, targets, encoder_outputs, attention_bias):
        """
        :param targets:  [batch_size, target_length]
        :param encoder_outputs: [batch_size, input_length, hidden_size]
        :param attention_bias:  [batch_size, 1, 1, input_length]
        :return: [batch_size, target_length, vocab_size]
        """
        with tf.name_scope('decode'):
            #   [batch_size, target_length, hidden_size]
            decoder_inputs = self.embedding_layer(targets)
            with tf.name_scope('shift_targets'):
                #   pad embedding value 0 at the head of sequence and remove eos_id
                decoder_inputs = tf.pad(decoder_inputs, [[0, 0], [1, 0], [0, 0]])[:, :-1, :]
            with tf.name_scope('add_pos_embedding'):
                length = tf.shape(decoder_inputs)[1]
                position_decode = model_utils.get_position_encoding(length, self.params.get('hidden_size'))
                decoder_inputs = tf.add(decoder_inputs, position_decode)

            if self.train:
                decoder_inputs = tf.nn.dropout(decoder_inputs, 1. - self.params.get('encoder_decoder_dropout'))

            decoder_self_attention_bias = model_utils.get_decoder_self_attention_bias(length)

            outputs = self.decoder_stack(
                decoder_inputs,
                encoder_outputs,
                decoder_self_attention_bias,
                attention_bias
            )

            #   [batch_size, target_length, vocab_size]
            logits = self.embedding_layer.linear(outputs)

            return logits

输入参数的$shape$已经在代码中给出了详细的注释。
$ok$ 我们一步一步来看看代码。

1、$embedding$_$layer$

和$encoder$中是一样的，这里就不再说明了，有疑问的请看上一节内容。最后返回的$shape$就是[ $batch$_$size$, $sequence$ _$length$, $hidden$ _$size$]。

2、$pad$

decoder_inputs = tf.pad(decoder_inputs, [[0, 0], [1, 0], [0, 0]])[:, :-1, :]

这个方法还是比较好理解的吧。$shape$为[ $batch$_$size$, $sequence$ _$length$, $hidden$ $size$]，$rank$为3，第一维不$pad$，最后一维也不pad，中间这个维度$pad$，并且是前面$pad$，后面不$pad$。所以$pad$之后的维度为[$batch$$size$, $sequence$ _$length$+1, $hidden$ $size$]，然后 在在第二维度去掉了最后一个值（代表的就是[$EOS$]这个标志位）,这样$shape$仍然为 [$batch$$size$, $sequence$ _$length$, $hidden$ _$size$]。

3、$get$_$position$ _$encoding$

这一个步骤和上一节的操作也是一样的，也就不再细说了。返回的$shape$为[$sequence$ _$length$, $hidden$ $size$] ，然后和$embedding$的输出做$add$，做简单的相加。最后返回的$shape$为 [ $batch$$size$, $sequence$ _$length$, $hidden$ _$size$]。然后再加了一个$dropout$层。

4、$get$_$decoder$ _$bias$

def get_decoder_self_attention_bias(length):
    with tf.name_scope("decoder_self_attention_bias"):
        valid_locs = tf.matrix_band_part(tf.ones([length, length]), -1, 0)
        valid_locs = tf.reshape(valid_locs, [1, 1, length, length])
        decoder_bias = _NEG_INF * (1.0 - valid_locs)
    return decoder_bias

$Lower$ $triangular$ $part$，就和下面这个一样。

				[[1. 0. 0. 0. 0.]
                 [1. 1. 0. 0. 0.]
                 [1. 1. 1. 0. 0.]
                 [1. 1. 1. 1. 0.]
                 [1. 1. 1. 1. 1.]]

最后的输出就如下面这样,成为了一个$Upper$ $triangular$ $part$

tf.Tensor(
[[[[-0.e+00 -1.e+09 -1.e+09 -1.e+09 -1.e+09]
   [-0.e+00 -0.e+00 -1.e+09 -1.e+09 -1.e+09]
   [-0.e+00 -0.e+00 -0.e+00 -1.e+09 -1.e+09]
   [-0.e+00 -0.e+00 -0.e+00 -0.e+00 -1.e+09]
   [-0.e+00 -0.e+00 -0.e+00 -0.e+00 -0.e+00]]]], shape=(1, 1, 5, 5), dtype=float32)

5、$decoder$_$stack$

$ok$，我们来看下$deocder$_$stack$

    def decode(self, targets, encoder_outputs, attention_bias):
        """
        :param targets:  [batch_size, target_length]
        :param encoder_outputs: [batch_size, input_length, hidden_size]
        :param attention_bias:  [batch_size, 1, 1, input_length]
        :return: [batch_size, target_length, vocab_size]
        """
        with tf.name_scope('decode'):
            #   [batch_size, target_length, hidden_size]
            decoder_inputs = self.embedding_layer(targets)
            with tf.name_scope('shift_targets'):
                #   pad embedding value 0 at the head of sequence and remove eos_id
                decoder_inputs = tf.pad(decoder_inputs, [[0, 0], [1, 0], [0, 0]])[:, :-1, :]
            with tf.name_scope('add_pos_embedding'):
                length = tf.shape(decoder_inputs)[1]
                position_decode = model_utils.get_position_encoding(length, self.params.get('hidden_size'))
                decoder_inputs = tf.add(decoder_inputs, position_decode)

            if self.train:
                decoder_inputs = tf.nn.dropout(decoder_inputs, 1. - self.params.get('encoder_decoder_dropout'))

            decoder_self_attention_bias = model_utils.get_decoder_self_attention_bias(length)

            outputs = self.decoder_stack(
                decoder_inputs,
                encoder_outputs,
                decoder_self_attention_bias,
                attention_bias
            )

            #   [batch_size, target_length, vocab_size]
            logits = self.embedding_layer.linear(outputs)

            return logits

class DecoderStack(tf.layers.Layer):
    def __init__(self, params, train):
        super(DecoderStack, self).__init__()
        self.params = params
        self.train = train
        self.layers = list()
        for _ in range(self.params.get('num_blocks')):
            self_attention_layer = SelfAttention(
                hidden_size=self.params.get('hidden_size'),
                num_heads=self.params.get('num_heads'),
                attention_dropout=self.params.get('attention_dropout'),
                train=self.train
            )

            vanilla_attention_layer = AttentionLayer(
                hidden_size=self.params.get('hidden_size'),
                num_heads=self.params.get('num_heads'),
                attention_dropout=self.params.get('attention_dropout'),
                train=self.train
            )

            ffn_layer = FFNLayer(
                hidden_size=self.params.get('hidden_size'),
                filter_size=self.params.get('filter_size'),
                relu_dropout=self.params.get('relu_dropout'),
                train=self.train,
                allow_pad=self.params.get('allow_ffn_pad')
            )

            self.layers.append(
                [
                    PrePostProcessingWrapper(self_attention_layer, self.params, self.train),
                    PrePostProcessingWrapper(vanilla_attention_layer, self.params, self.train),
                    PrePostProcessingWrapper(ffn_layer, self.params, self.train)
                ]
            )

        self.output_norm = LayerNormalization(self.params.get('hidden_size'))

5.1 $self$_$attention$

这一部分和$encoder$的$self$_$attention$是一模一样的，
$Q、K、V=decoder$ $inputs$，具体计算过程也是一毛一样的。
唯一不同的是$bias$是 $get$$decoder$ _$bias$产生的

5.2 $vanilla$_$attention$

这个$attention$的不同之处在于，做的是$decoder$对$encoder$的$attention$。似乎这是这是很重要的一个$attention$，将$encoder$和$decoder$做了对齐。

$Q=decoder$ _$inputs$
$K、V=encoder$ _$inputs$

1. $Q$的$shape$为[$B$,$T_d$,$D$]，而$K、V$的$shape$为 [$B$,$T_e$,$D$]
2. 对$Q、K、V$分别做$split$ _$head$操作。$Qshape$为[$B$, $H$, $T_d$, $D//H$] ，$K、Vshape$为[$B$, $H$, $T_e$, $D//H$] 其中 $H$ 表示 $num$ _$heads$,
3. $Q=scale(Q)$
4. $logits=tf.matmul(Q,K,transpos{e}_b=True)$，返回$shape$为[$B$, $H$，$T_d$, $T_e$]
5. $logits=tf.add(logits,bias)$，这个 $bias$ 就是最开始第一节第一步求得的 $attention$_$bias$。$shape$为 [$B$, $1$, $1$, $T_e$]。最终返回$shape$为[$B$, $H$，$T_d$, $T_e$]
6. $weights=tf.nn.softmax(logits)$
7. $dropout(weights)$
8. $attention$_$output=tf.matmul(weights,V)$，weights$shape$为[$B$, $H$, $T_d$, $T_e$],V=[$B$,$H$,$T_e$,$D//H$]，最终为[$B$, $H$, $T_d$, $D//H$],
9. $out=combine(heads)$ 返回$shape$为[$B$, $T_d$, $D$]
10. $dense(out,D)$ 返回$shape$为[$B$, $T_d$, $D$]

5.3 $feed$ _$forward$

和 $encoder$ 的是一样的。

5.4 $norm$

和 $encoder$ 的是一样的。

5.5 $linear$

    def linear(self, inputs):
        """
        :param inputs:  a tensor with shape [batch_size, length, hidden_size]
        :return: float32 tensor with shape [batch_size, length, vocab_size]
        """

        with tf.name_scope('pre_softmax_linear'):
            batch_size = tf.shape(inputs)[0]
            length = tf.shape(inputs)[1]

            inputs = tf.reshape(inputs, [-1, self.hidden_size])
            """
                inputs              [batch_size, length, hidden_size]
                shared_weights      [vocab_size, hidden_size]
                transpose           [hidden_size, vocab_size]
                logits              [batch_size, length, vocab_size]
            """
            logits = tf.matmul(inputs, self.shared_weights, transpose_b=True)

            return tf.reshape(logits, [batch_size, length, self.vocab_size])

这个就不细说了。值得注意的是：$shared$_$weights$，是$embedidng$时候初始化的向量。最后输出的，也就是每个位置在$vocab$上的概率分布。

最后：
一直没提到的

class PrePostProcessingWrapper(object):
    """Wrapper class that applies layer pre-processing and post-processing."""

    def __init__(self, layer, params, train):
        self.layer = layer
        self.postprocess_dropout = params["layer_postprocess_dropout"]
        self.train = train

        # Create normalization layer
        self.layer_norm = LayerNormalization(params["hidden_size"])

    def __call__(self, x, *args, **kwargs):
        # Preprocessing: apply layer normalization
        y = self.layer_norm(x)

        # Get layer output
        y = self.layer(y, *args, **kwargs)

        # Postprocessing: apply dropout and residual connection
        if self.train:
            y = tf.nn.dropout(y, 1 - self.postprocess_dropout)
        return x + y

这个$wrapper$

1. 先对输入做了一个$norm$，和前面提到的$norm$是一样的。
2. 然后拿到$layer$的输出
3. 对结果加了一个$dropout$
4. 最后和输入相加，做了一个$residual$。

这个操作是对每一个$layer$的输入输出都操作了。

谢谢

更多代码请移步我的个人$github$，会不定期更新。
欢迎关注