deep learning 12. transformer 代码详细解析之encoder

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

$bert$系列：

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

结合着自己 $github$（地址见文末尾）上的$transformer$代码，详细分析下代码和逻辑。

    def __call__(self, feature, targets=None):
        initializer = tf.variance_scaling_initializer(
            scale=self.params.get('initializer_gain'),
            mode='fan_avg',
            distribution='uniform'
        )

        with tf.variable_scope('transformer', initializer=initializer):
            #   [batch_size, 1, 1, length]
            attention_bias = model_utils.get_padding_bias(feature)

            encoder_outputs = self.encode(feature, attention_bias)

            if targets is None:
                return self.predict(encoder_outputs, attention_bias)

            logits = self.decode(targets, encoder_outputs, attention_bias)
            return logits

主要$call()$ 方法入口。（为了代码不那么长去掉了代码中的注释）

def get_padding_bias(x):
    with tf.name_scope("attention_bias"):
        padding = get_padding(x)
        attention_bias = padding * _NEG_INF
        attention_bias = tf.expand_dims(
            tf.expand_dims(attention_bias, axis=1), axis=1)
    return attention_bias

$get$_$padding()$ 方法代码如下，主要目的是拿到$attention$ _$bias$：

def get_padding(x, padding_value=0):
    with tf.name_scope("padding"):
        return tf.to_float(tf.equal(x, padding_value))

$x$的$shape$为[$batch$_$size$, $sequence$ $length$],是已经$padding$过的数据。经过这个方法，就能知道哪些是$padding$，哪些是$non$-$padding$的数据了。返回$shape$为[$batch$$size$, $sequence$ $length$]。其中 $0$ ->$non$-$padding$，$1$ ->$padding$。
_NEG_INF = -1e9，$padding$ $bias$肯定就是给 $padding$加上 $bias$了，这个值就是给 $padding$设置的 $bias$。
最后返回的$shape$为 [$batch$$size$, $1$, $1$, $sequence$ _$length$]。

第一步：$encoder$

    def encode(self, inputs, attention_bias):
        with tf.name_scope('encode'):
            #   [batch_size, length, hidden_size]
            embedded_inputs = self.embedding_layer(inputs)
            #   [batch_size, length]
            inputs_padding = model_utils.get_padding(inputs)
            with tf.name_scope('add_pos_embedding'):
                length = tf.shape(embedded_inputs)[1]
                #   use sin cos calculate position embeddings
                pos_encoding = model_utils.get_position_encoding(length, self.params.get('hidden_size'))
                encoder_inputs = tf.add(embedded_inputs, pos_encoding)
            if self.train:
                encoder_inputs = tf.nn.dropout(encoder_inputs, 1 - self.params.get('encoder_decoder_dropout'))
            return self.encoder_stack(encoder_inputs, attention_bias, inputs_padding)

$ok$ 一步一步来解析吧！

1.1 $embedding$_$layer$

主要实现代码如下：

    def call(self, inputs, **kwargs):
        with tf.name_scope('embedding'):
            mask = tf.to_float(tf.not_equal(inputs, 0))
            embeddings = tf.gather(self.shared_weights, inputs)
            embeddings *= tf.expand_dims(mask, -1)
            embeddings *= self.hidden_size ** 0.5
            return embeddings

这段代码还是比较简单的对吧，理解起来。$mask$的作用就是让$padding$的部分都为$0$。最后对$embedding$的部分进行了一个$scale$。最后返回的$shape$为 [ $batch$_$size$, $sequence$ _$length$, $hidden$ _$size$]。

1.2 $get$_$padding$

def get_padding(x, padding_value=0):
    with tf.name_scope("padding"):
        return tf.to_float(tf.equal(x, padding_value))

和上面$attention$_$bias$的逻辑一样。这里返回的是[$batch$ _$size$, $sequence$ _$length$]。其中 $0$ ->$non$-$padding$，$1$ ->$padding$。

1.3 $get$$position$$encoding$

def get_position_encoding( length, hidden_size, min_timescale=1.0, max_timescale=1.0e4):
    position = tf.to_float(tf.range(length))
    num_timescales = hidden_size // 2
    log_timescale_increment = (
            math.log(float(max_timescale) / float(min_timescale)) / (tf.to_float(num_timescales) - 1))
    inv_timescales = min_timescale * tf.exp(tf.to_float(tf.range(num_timescales)) * -log_timescale_increment)
    scaled_time = tf.expand_dims(position, 1) * tf.expand_dims(inv_timescales, 0)

    signal = tf.concat([tf.sin(scaled_time), tf.cos(scaled_time)], axis=1)
    return signal

算的是$cos$和$sin$的值作为$sequence$_$length$的$position$编码。返回的$shape$为[$sequence$ _$length$, $hidden$ $size$] 。然后和$embedding$的输出做$add$，做简单的相加。最后返回的$shape$为 [ $batch$$size$, $sequence$ _$length$, $hidden$ _$size$]。然后再加了一个$dropout$层，接着扔进 $encoder$ _$stack$中。

1.4 $encoder$_$stack$

class EncoderStack(tf.layers.Layer):
    def __init__(self, params, train):
        super(EncoderStack, 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
            )
           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(ffn_layer, self.params, self.train)
                ]
            )
        self.output_norm = LayerNormalization(self.params.get('hidden_size'))

结构很简单，就是一个$self$_$attention$层 + $feed$ _$ward$层 + $norm$层。

    def call(self, encoder_inputs, attention_bias, inputs_padding):
        """
        :param encoder_inputs: [batch_size, input_length, hidden_size]
        :param attention_bias: [batch_size, 1, 1, inputs_length]
        :param inputs_padding: [batch_size, length]
        :return: [batch_size, input_length, hidden_size]
        """
        for n, layer in enumerate(self.layers):
            self_attention_layer = layer[0]
            ffn_layer = layer[1]
            with tf.variable_scope('encoder_stack_lay_{}'.format(n)):
                with tf.variable_scope('self_attention'):
                    encoder_inputs = self_attention_layer(encoder_inputs, attention_bias)
                with tf.variable_scope('ffn'):
                    encoder_inputs = ffn_layer(encoder_inputs, inputs_padding)
        return self.output_norm(encoder_inputs)

主要$call()$的输入参数已经在代码中给出了注释。

1.4.1 $self$_$attention$

对于$self$_$attention$层的详细解释在$github$中已经逐步添加了注释，很清晰明了，这里就不再多做细说。主要流程是：

1. $Q、K、V=encoder$_$inputs$，$shape$都为[$B$, $T$, $D$]。看得懂吧，这样表达简单点。
2. 对$Q、K、V$分别做$split$ _$head$操作。$shape$都为[$B$, $H$, $T$, $D//H$] 其中 $H$ 表示 $num$ _$heads$
3. $Q=scale(Q)$
4. $logits=tf.matmul(Q,K,transpos{e}_b=True)$，返回$shape$为[$B$, $H$，$T$, $T$]
5. $logits=tf.add(logits,bias)$，这个 $bias$ 就是第一步求得的 $attention$_$bias$
6. $weights=tf.nn.softmax(logits)$
7. $dropout(weights)$
8. $attention$_$output=tf.matmul(weights,V)$，返回$shape$为[$B$, $H$, $T$, $D//H$]
9. $out=combine(heads)$ 返回$shape$为[$B$, $T$, $D$]
10. $dense(out,D)$ 返回$shape$为[$B$, $T$, $D$]

这样一个$self$-$attention$的流程就走完了。

1.4.2 $feed$ _$ward$

    def call(self, inputs, padding=None):
        padding = padding if self.allow_pad else None
        batch_size = tf.shape(inputs)[0]
        length = tf.shape(inputs)[1]
        if padding is not None:
            with tf.name_scope('remove_padding'):
                pad_mask = tf.reshape(padding, [-1])         
                non_pad_ids = tf.to_int32(tf.where(pad_mask < 1e-9))
                inputs = tf.reshape(inputs, [-1, self.hidden_size])             
                inputs = tf.gather_nd(params=inputs, indices=non_pad_ids)
                inputs.set_shape([None, self.hidden_size])
                inputs = tf.expand_dims(inputs, axis=0)
        outputs = self.filter_layer(inputs)
        if self.train:
            outputs = tf.nn.dropout(outputs, 1.0 - self.relu_dropout)
        outputs = self.output_layer(outputs)
        if padding is not None:
            with tf.name_scope('re_add_padding'):
                outputs = tf.squeeze(outputs, axis=0)
                outputs = tf.scatter_nd(
                    indices=non_pad_ids,
                    updates=outputs,
                    shape=[batch_size * length, self.hidden_size]
                )
                outputs = tf.reshape(outputs, [batch_size, length, self.hidden_size])
        return outputs

这里的 $padding$ 就是：上面1.2 $get$_$padding()$求出的结果。

1.4.3 $norm$

    def call(self, x, epsilon=1e-6):
        mean = tf.reduce_mean(x, axis=[-1], keepdims=True)
        variance = tf.reduce_mean(tf.square(x - mean), axis=[-1], keepdims=True)
        norm_x = (x - mean) * tf.rsqrt(variance + epsilon)
        return norm_x * self.scale + self.bias

这个很好理解的对吧，求均值和方差，然后$norm$。

这样一个$encoder$流程就完了。还是比较简单的，不得不佩服$google$大佬的强悍。

下一节会将$decoder$部分。

谢谢

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