“让Keras更酷一些！”：层中层与mask

最新推荐文章于 2021-04-08 21:14:02 发布

PaperWeekly

最新推荐文章于 2021-04-08 21:14:02 发布

阅读量524

点赞数

原文链接：https://kexue.fm/archives/6810

版权

640?

这一篇“让 Keras 更酷一些！”将和读者分享两部分内容：第一部分是“层中层”，顾名思义，是在 Keras 中自定义层的时候，重用已有的层，这将大大减少自定义层的代码量；另外一部分就是应读者所求，介绍一下序列模型中的 mask 原理和方法。

作者丨苏剑林

单位丨追一科技

研究方向丨NLP，神经网络

个人主页丨kexue.fm

层中层

在《“让Keras更酷一些！”：精巧的层与花式的回调》[1] 一文中我们已经介绍过 Keras 自定义层的基本方法，其核心步骤是定义 build 和 call 两个函数，其中 build 负责创建可训练的权重，而 call 则定义具体的运算。

拒绝重复劳动

经常用到自定义层的读者可能会感觉到，在自定义层的时候我们经常在重复劳动，比如我们想要增加一个线性变换，那就要在 build 中增加一个 kernel 和 bias 变量（还要自定义变量的初始化、正则化等），然后在 call 里边用 K.dot 来执行，有时候还需要考虑维度对齐的问题，步骤比较繁琐。

但事实上，一个线性变换其实就是一个不加激活函数的 Dense 层罢了，如果在自定义层时能重用已有的层，那显然就可以大大节省代码量了。

事实上，只要你对 Python 面向对象编程比较熟悉，然后仔细研究 Keras 的 Layer 的源代码，就不难发现重用已有层的方法了。下面将它整理成比较规范的流程，供读者参考调用。

OurLayer

首先，我们定义一个新的 OurLayer 类：

class OurLayer(Layer):
    """定义新的Layer，增加reuse方法，允许在定义Layer时调用现成的层
    """
    def reuse(self, layer, *args, **kwargs):
        if not layer.built:
            if len(args) > 0:
                inputs = args[0]
            else:
                inputs = kwargs['inputs']
            if isinstance(inputs, list):
                input_shape = [K.int_shape(x) for x in inputs]
            else:
                input_shape = K.int_shape(inputs)
            layer.build(input_shape)
        outputs = layer.call(*args, **kwargs)
        for w in layer.trainable_weights:
            if w not in self._trainable_weights:
                self._trainable_weights.append(w)
        for w in layer.non_trainable_weights:
            if w not in self._non_trainable_weights:
                self._non_trainable_weights.append(w)
        return outputs

这个 OurLayer 类继承了原来的 Layer 类，为它增加了 reuse 方法，就是通过它我们可以重用已有的层。

下面是一个简单的例子，定义一个层，运算如下：

这里 f,g 是激活函数，其实就是两个 Dense 层的复合，如果按照标准的写法，我们需要在 build 那里定义好几个权重，定义权重的时候还需要根据输入来定义 shape，还要定义初始化等，步骤很多，但事实上这些在 Dense 层不都写好了吗，直接调用就可以了，参考调用代码如下：

class OurDense(OurLayer):
    """原来是继承Layer类，现在继承OurLayer类
    """
    def __init__(self, hidden_dimdim, output_dim,
                 hidden_activation='linear',
                 output_activation='linear', **kwargs):
        super(OurDense, self).__init__(**kwargs)
        self.hidden_dim = hidden_dim
        self.output_dim = output_dim
        self.hidden_activation = hidden_activation
        self.output_activation = output_activation
    def build(self, input_shape):
        """在build方法里边添加需要重用的层，
        当然也可以像标准写法一样条件可训练的权重。
        """
        super(OurDense, self).build(input_shape)
        self.h_dense = Dense(self.hidden_dimdim,
                             activation=self.hidden_activation)
        self.o_dense = Dense(self.output_dim,
                             activation=self.output_activation)
    def call(self, inputs):
        """直接reuse一下层，等价于o_dense(h_dense(inputs))
        """
        h = self.reuse(self.h_dense, inputs)
        o = self.reuse(self.o_dense, h)
        return o
    def compute_output_shape(self, input_shape):
        return input_shape[:-1] + (self.output_dim,)

是不是特别清爽？

Mask

这一节我们来讨论一下处理变长序列时的 padding 和 mask 问题。

证明你思考过

近来笔者开源的几个模型中大量地用到了 mask，不少读者似乎以前从未遇到过这个东西，各种疑问纷至沓来。本来，对一样新东西有所疑问是无可厚非的事情，但问题是不经思考的提问就显得很不负责任了。

我一直认为，在向别人提问的时候，需要同时去“证明”自己是思考过的，比如如果你要去解释关于 mask 的问题，我会先请你回答：mask 之前的序列大概是怎样的？mask 之后序列的哪些位置发生了变化？变成了怎么样？

这三个问题跟 mask 的原理没有关系，只是要你看懂 mask 做了什么运算，在此基础上，我们才能去讨论为什么要这样运算。如果你连运算本身都看不懂，那只有两条路可选了，一是放弃这个问题的理解，二是好好学几个月 Keras 咱们再来讨论。

下面假设读者已经看懂了 mask 的运算，然后我们来简单讨论一下 mask 的基本原理。

排除padding

mask 是伴随着 padding 出现的，因为神经网络的输入需要一个规整的张量，而文本通常都是不定长的，这样一来就需要裁剪或者填充的方式来使得它们变成定长，按照常规习惯，我们会使用 0 作为 padding 符号。

这里用简单的向量来描述 padding 的原理。假设有一个长度为 5 的向量：

经过 padding 变成长度为 8：

当你将这个长度为 8 的向量输入到模型中时，模型并不知道你这个向量究竟是“长度为 8 的向量”还是“长度为 5 的向量，填充了 3 个无意义的 0”。为了表示出哪些是有意义的，哪些是 padding 的，我们还需要一个 mask 向量（矩阵）：

这是一个 0/1 向量（矩阵），用 1 表示有意义的部分，用 0 表示无意义的 padding 部分。

所谓 mask，就是 x 和 m 的运算，来排除 padding 带来的效应。比如我们要求 x 的均值，本来期望的结果是：

640

但是由于向量已经经过 padding，直接算的话就得到：

640

会带来偏差。更严重的是，对于同一个输入，每次 padding 的零的数目可能是不固定的，因此同一个样本每次可能得到不同的均值，这是很不合理的。有了 mask 向量 m 之后，我们可以重写求均值的运算：

640

这里的 ⊗ 是逐位对应相乘的意思。这样一来，分子只对非 padding 部分求和，分母则是对非 padding 部分计数，不管你 padding 多少个零，最终算出来的结果都是一样的。

如果要求 x 的最大值呢？我们有 max([1,0,3,4,5])=max([1,0,3,4,5,0,0,0])=5，似乎不用排除 padding 效应了？在这个例子中是这样，但还有可能是：

经过 padding 后变成了：

如果直接对 padding 后的 x 求 max，那么得到的是 0，而 0 不在原来的范围内。这时候解决的方法是：让 padding 部分足够小，以至于 max（几乎）不能取到 padding 部分，比如：

正常来说，神经网络的输入输出的数量级不会很大，所以经过 640?wx_fmt=png 后，padding 部分在这个数量级中上，可以保证取 max 的话不会取到 padding 部分了。

处理 softmax 的 padding 也是如此。在 Attention 或者指针网络时，我们就有可能遇到对变长的向量做 softmax，如果直接对 padding 后的向量做 softmax，那么 padding 部分也会平摊一部分概率，导致实际有意义的部分概率之和都不等于 1 了。解决办法跟 max 时一样，让 padding 部分足够小足够小，使得 640?wx_fmt=png 足够接近于 0，以至于可以忽略：

上面几个算子的 mask 处理算是比较特殊的，其余运算的 mask 处理（除了双向 RNN），基本上只需要输出：

就行了，也就是让 padding 部分保持为 0。

Keras实现要点

Keras 自带了 mask 功能，但是不建议用，因为自带的 mask 不够清晰灵活，而且也不支持所有的层，强烈建议读者自己实现 mask。

近来开源的好几个模型都已经给出了足够多的 mask 案例，我相信读者只要认真去阅读源码，一定很容易理解 mask 的实现方式的，这里简单提一下几个要点。

一般来说 NLP 模型的输入是词 ID 矩阵，形状为 [batch_size, seq_len]，其中我会用 0 作为 padding 的 ID，而 1 作为 UNK 的 ID，剩下的就随意了，然后我就用一个 Lambda 层生成 mask 矩阵：

# x是词ID矩阵
mask = Lambda(lambda x: K.cast(K.greater(K.expand_dims(x, 2), 0), 'float32'))(x)

这样生成的 mask 矩阵大小是 [batch_size, seq_len, 1]，然后词 ID 矩阵经过 Embedding 层后的大小为 [batch_size, seq_len, word_size]，这样一来就可以用 mask 矩阵对输出结果就行处理了。这种写法只是我的习惯，并非就是唯一的标准。

结合：双向RNN

刚才我们的讨论排除了双向 RNN，这是因为 RNN 是递归模型，没办法简单地 mask（主要是逆向 RNN 这部分）。所谓双向 RNN，就是正反各做一次 RNN 然后拼接或者相加之类的。

假如我们要对 [1,0,3,4,5,0,0,0] 做逆向 RNN 运算时，最后输出的结果都会包含 padding 部分的 0（因为 padding 部分在一开始就参与了运算）。因此事后是没法排除的，只有在事前排除。

排除的方案是：要做逆向 RNN，先将 [1,0,3,4,5,0,0,0] 反转为 [5,4,3,0,1,0,0,0]，然后做一个正向 RNN，然后再把结果反转回去，要注意反转的时候只反转非 padding 部分（这样才能保证递归运算时 padding 部分始终不参与，并且保证跟正向 RNN 的结果对齐），这个 tensorflow 提供了现成的函数 tf.reverse_sequence()。

遗憾的是，Keras 自带的 Bidirectional 并没有这个功能，所以我重写了它，供读者参考：

class OurBidirectional(OurLayer):
    """自己封装双向RNN，允许传入mask，保证对齐
    """
    def __init__(self, layer, **args):
        super(OurBidirectional, self).__init__(**args)
        self.forward_layer = copy.deepcopy(layer)
        self.backward_layer = copy.deepcopy(layer)
        self.forward_layer.name = 'forward_' + self.forward_layer.name
        self.backward_layer.name = 'backward_' + self.backward_layer.name
    def reverse_sequence(self, x, mask):
        """这里的mask.shape是[batch_size, seq_len, 1]
        """
        seq_len = K.round(K.sum(mask, 1)[:, 0])
        seq_len = K.cast(seq_len, 'int32')
        return K.tf.reverse_sequence(x, seq_len, seq_dim=1)
    def call(self, inputs):
        x, mask = inputs
        x_forward = self.reuse(self.forward_layer, x)
        x_backward = self.reverse_sequence(x, mask)
        x_backward = self.reuse(self.backward_layer, x_backward)
        x_backward = self.reverse_sequence(x_backward, mask)
        x = K.concatenate([x_forward, x_backward], 2)
        return x * mask
    def compute_output_shape(self, input_shape):
        return (None, input_shape[0][1], self.forward_layer.units * 2)