keras实现自定义层的关键步骤解析

 

前言：Keras提供众多常见的已编写好的层对象，例如常见的卷积层、池化层等，我们可以直接通过以下代码调用。Keras中的层大致上分为两种类型：

第一种是带有训练参数的：比如Dense层、Conv2D层，等等，我们在训练的过程中需要训练层的权重和偏置项；

第二种是不带训练参数的：比如dropout层、flatten层、等等，我们不需要训练它的权重，只需要对输入进行加工处理再输出就行了。

我们在实际应用中，我们经常需要自己构建一些层对象，已满足某些自定义网络的特殊需求。，也无非就是上面两种，一种是带有参数的，一种是不带参数的，不管是哪一种，幸运的是，Keras对自定义层都提供了良好的支持。

一、Lambda层

二、自定义层

    2.1 Dense层解析

    2.2 三个核心方法的解析

        （1）build方法

        （2）call方法

        （3）compute_output_shape方法

    2.3 基类Layer中的定义

一、Lambda层

对于简单、无状态的自定义操作，你也许可以通过 layers.core.Lambda 层来实现。即使用keras.core.lambda()
如果我们的自定义层中不包含可训练的权重，而只是对上一层输出做一些函数变换，那么我们可以直接使用keras.core模块（该模块包含常见的基础层，如Dense、Activation等）下的lambda函数：

keras.layers.core.Lambda(function, output_shape=None, mask=None, arguments=None)

参数说明： 
function：要实现的函数，该函数仅接受一个变量，即上一层的输出 
output_shape：函数应该返回的值的shape，可以是一个tuple，也可以是一个根据输入shape计算输出shape的函数 
mask: 掩膜 
arguments：可选，字典，用来记录向函数中传递的其他关键字参数

注意：也不是说对于没有训练参数的层就一定要用Lambda层，我也可以使用自定义的层，只不过是没必要那么复杂而已。

二、自定义层

但是对于那些包含了可训练权重的自定义层，你应该自己实现这种层。在这种情况下，我们需要定义的是一个全新的、拥有可训练权重的层，这个时候我们就需要使用下面的方法。即通过编写自定义层，从Layer中继承。

（下面的内容来自官方文档，有部分是自己的注解，后面着重总结的）

这是一个 Keras2.0 中，Keras 层的骨架（如果你用的是旧的版本，请更新到新版）。你只需要实现三个方法即可:

要定制自己的层，需要实现下面三个方法

• build(input_shape)：这是定义权重的方法，可训练的权应该在这里被加入列表self.trainable_weights中。其他的属性还包括self.non_trainabe_weights（列表）和self.updates（需要更新的形如（tensor,new_tensor）的tuple的列表）。这个方法必须设置self.built = True，可通过调用super([layer],self).build()实现。
• call(x)：这是定义层功能的方法，除非你希望你写的层支持masking，否则你只需要关心call的第一个参数：输入张量。
• compute_output_shape(input_shape)：如果你的层修改了输入数据的shape，你应该在这里指定shape变化的方法，这个函数使得Keras可以做自动shape推断。
   

from keras import backend as K
from keras.engine.topology import Layer

class MyLayer(Layer):

    def __init__(self, output_dim, **kwargs):
        self.output_dim = output_dim
        super(MyLayer, self).__init__(**kwargs)

    def build(self, input_shape):
        # 为该层创建一个可训练的权重
        self.kernel = self.add_weight(name='kernel', 
                                      shape=(input_shape[1], self.output_dim),
                                      initializer='uniform',
                                      trainable=True)
        super(MyLayer, self).build(input_shape)  # 一定要在最后调用它

    def call(self, x):
        return K.dot(x, self.kernel)

    def compute_output_shape(self, input_shape):
        return (input_shape[0], self.output_dim)

还可以定义具有多个输入张量和多个输出张量的 Keras 层。 为此，你应该假设方法 build(input_shape)，call(x) 和 compute_output_shape(input_shape) 的输入输出都是列表。 这里是一个例子，与上面那个相似：

from keras import backend as K
from keras.engine.topology import Layer

class MyLayer(Layer):

    def __init__(self, output_dim, **kwargs):
        self.output_dim = output_dim
        super(MyLayer, self).__init__(**kwargs)

    def build(self, input_shape):
        assert isinstance(input_shape, list)
        # 为该层创建一个可训练的权重
        self.kernel = self.add_weight(name='kernel',
                                      shape=(input_shape[0][1], self.output_dim),
                                      initializer='uniform',
                                      trainable=True)
        super(MyLayer, self).build(input_shape)  # 一定要在最后调用它

    def call(self, x):
        assert isinstance(x, list)
        a, b = x
        return [K.dot(a, self.kernel) + b, K.mean(b, axis=-1)]

    def compute_output_shape(self, input_shape):
        assert isinstance(input_shape, list)
        shape_a, shape_b = input_shape
        return [(shape_a[0], self.output_dim), shape_b[:-1]]

上面的文字都是来自文档，这里没有给出具体的实现功能，我下面以keras自己实显得Dense层为例来加以说明：

2.1 Dense层解析

from .. import backend as K
from .. import activations
from .. import initializers
from .. import regularizers
from .. import constraints
from ..engine.base_layer import InputSpec
from ..engine.base_layer import Layer
from ..utils.generic_utils import func_dump
from ..utils.generic_utils import func_load
from ..utils.generic_utils import deserialize_keras_object
from ..utils.generic_utils import has_arg
from ..utils import conv_utils
from ..legacy import interfaces

class Dense(Layer):
   """
   继承自Layer层，这里的大片说明文档我省略了，因为它的功能我们都知道，我们重点看功能是怎么实现的
   """
   """Dense类的构造函数，一般包涵kernel，bias的initializer初始化、regularizer正则化、约束项constraint等内容。
注意：下面的activations、initializers、regularizers、constraints等都是在来自于上面import导入的模块哦
   """
    @interfaces.legacy_dense_support
    def __init__(self, units,
                 activation=None,
                 use_bias=True,
                 kernel_initializer='glorot_uniform',
                 bias_initializer='zeros',
                 kernel_regularizer=None,
                 bias_regularizer=None,
                 activity_regularizer=None,
                 kernel_constraint=None,
                 bias_constraint=None,
                 **kwargs):
        if 'input_shape' not in kwargs and 'input_dim' in kwargs:
            kwargs['input_shape'] = (kwargs.pop('input_dim'),)
        super(Dense, self).__init__(**kwargs) # 调用父类的构造函数
        self.units = units
        self.activation = activations.get(activation)
        self.use_bias = use_bias
        self.kernel_initializer = initializers.get(kernel_initializer)
        self.bias_initializer = initializers.get(bias_initializer)
        self.kernel_regularizer = regularizers.get(kernel_regularizer)
        self.bias_regularizer = regularizers.get(bias_regularizer)
        self.activity_regularizer = regularizers.get(activity_regularizer)
        self.kernel_constraint = constraints.get(kernel_constraint)
        self.bias_constraint = constraints.get(bias_constraint)
        self.input_spec = InputSpec(min_ndim=2)
        self.supports_masking = True

    """
    这是第一个必须要实现的方法————在这里定义权重以及偏置项
    这里需要注意的是 self.add_weight()这个方法是哪里来的，他其实是定义在基类Layer里面的一个方法，后面会说到。一般的格式为如下：
    self.weight=self.add_weight(self,name,shape,dtype=None,initializer=None,regularizer=None,trainable=True,constraint=None)
当然这里的initializer、regularizer、trainable、constraint这几个参数一般都是来自构造函数。
    """
    def build(self, input_shape):
        assert len(input_shape) >= 2
        input_dim = input_shape[-1]

        self.kernel = self.add_weight(shape=(input_dim, self.units),
                                      initializer=self.kernel_initializer,
                                      name='kernel',
                                      regularizer=self.kernel_regularizer,
                                      constraint=self.kernel_constraint)
        if self.use_bias:
            self.bias = self.add_weight(shape=(self.units,),
                                        initializer=self.bias_initializer,
                                        name='bias',
                                        regularizer=self.bias_regularizer,
                                        constraint=self.bias_constraint)
        else:
            self.bias = None
        self.input_spec = InputSpec(min_ndim=2, axes={-1: input_dim})

        self.built = True  # 最后这句话一定要加上

    """
    call是这个层的功能实现的地方，他接受的参数是inputs，返回output，这是搭建model的关键所在，在这个函数里面实现这个层的运算
    """
    def call(self, inputs):
        output = K.dot(inputs, self.kernel)
        if self.use_bias:
            output = K.bias_add(output, self.bias, data_format='channels_last')
        if self.activation is not None:
            output = self.activation(output)
        return output
    """
    这个函数是告诉我经过运算之后热输出的形状
    """
    def compute_output_shape(self, input_shape):
        assert input_shape and len(input_shape) >= 2
        assert input_shape[-1]
        output_shape = list(input_shape)
        output_shape[-1] = self.units
        return tuple(output_shape)
    
    """ 
    这个是方面获取这个层的配置信息的。可以不要。
    """
    def get_config(self):
        config = {
            'units': self.units,
            'activation': activations.serialize(self.activation),
            'use_bias': self.use_bias,
            'kernel_initializer': initializers.serialize(self.kernel_initializer),
            'bias_initializer': initializers.serialize(self.bias_initializer),
            'kernel_regularizer': regularizers.serialize(self.kernel_regularizer),
            'bias_regularizer': regularizers.serialize(self.bias_regularizer),
            'activity_regularizer':
                regularizers.serialize(self.activity_regularizer),
            'kernel_constraint': constraints.serialize(self.kernel_constraint),
            'bias_constraint': constraints.serialize(self.bias_constraint)
        }
        base_config = super(Dense, self).get_config()
        return dict(list(base_config.items()) + list(config.items()))

2.2 三个核心方法的解析

（1）build方法——定义这个曾“固有的”权重信息（记者这里面定义kernel，bias信息），定义这个方法时候的几个注意点

第一：函数原型为 def build(self, input_shape): 及接受input_shape参数

第二：权重的定义方式。self.weight=self.add_weight(... ...)

"""
权重定义的一般的格式为如下：
    self.weight=self.add_weight(self,name,shape,dtype=None,initializer=None,regularizer=None,trainable=True,constraint=None)
当然这里的initializer、regularizer、trainable、constraint这几个参数一般都是来自构造函数。
"""
def build(self, input_shape):
    self.kernel = self.add_weight(shape=(input_dim, self.units),
                                      initializer=self.kernel_initializer,
                                      name='kernel',
                                      regularizer=self.kernel_regularizer,
                                      constraint=self.kernel_constraint)

    self.bias = self.add_weight(shape=(self.units,),
                                        initializer=self.bias_initializer,
                                        name='bias',
                                        regularizer=self.bias_regularizer,
                                        constraint=self.bias_constraint)
    self.built = True  # 最后这句话一定要加上

第三：最后一定要加一句话

self.built = True  或者是
super(MyLayer, self).build(input_shape)  # 一定要在最后调用它

 （2）call方法——这是“层功能”的实现方法，定义这个方法时候的几个注意点

他接受的参数为inputs，输出为output,这是我们后面可以通过Dense(... ...)(x) 这样操作的关键。定义如下：

def call(self, inputs):
    ... ...
    return output

（3）compute_output_shape方法——如果你的层更改了输入张量的形状，你应该在这里定义形状变化的逻辑，这让Keras能够自动推断各层的形状。

它接受input_shape参数，返回更改之后的形状output_shape，定义如下：

def compute_output_shape(self, input_shape):
    ... ...
    return tuple(output_shape)

2.3 基类Layer中的定义

虽然在自定义类的时候，上面的三个方法，build、call、compute_outout_shape 是必须要有的，但是还有很多其他的方法和属性可以帮助我们更好的实现自定义层。下面来该概括性的看一下：

class Layer(object):
    def __init__(self, **kwargs):
     
    @staticmethod
    def _node_key(layer, node_index):

    @property
    def losses(self):
    
    @property
    def updates(self):
      
    @property
    def built(self):
       
    @built.setter
    def built(self, value):
   
    @property
    def trainable_weights(self):

    @trainable_weights.setter
    def trainable_weights(self, weights):
    
    @property
    def non_trainable_weights(self):
      
    @non_trainable_weights.setter
    def non_trainable_weights(self, weights):

    @interfaces.legacy_add_weight_support
    def add_weight(self,name,shape,dtype=None,initializer=None,regularizer=None,
                   trainable=True,
                   constraint=None):
     
    def assert_input_compatibility(self, inputs):
       
    def call(self, inputs, **kwargs):
      
    def __call__(self, inputs, **kwargs):

    def _add_inbound_node(self, input_tensors, output_tensors,
                          input_masks, output_masks,
                          input_shapes, output_shapes, arguments=None):

    def compute_output_shape(self, input_shape):
     
    def compute_mask(self, inputs, mask=None):

    def _get_node_attribute_at_index(self, node_index, attr, attr_name):

    def get_input_shape_at(self, node_index):

    def get_output_shape_at(self, node_index):
       
    def get_input_at(self, node_index):
       
    def get_output_at(self, node_index):

    def get_input_mask_at(self, node_index):
      
    def get_output_mask_at(self, node_index):
       
    @property
    def input(self):

    @property
    def output(self):

    @property
    def input_mask(self):

    @property
    def output_mask(self):
        
    @property
    def input_shape(self):
       
    @property
    def output_shape(self):

    def add_loss(self, losses, inputs=None):

    def add_update(self, updates, inputs=None):

    def get_updates_for(self, inputs):
       
    def get_losses_for(self, inputs):

    @property
    def weights(self):

    def set_weights(self, weights):
       
    def get_weights(self):
       
    def get_config(self):
        
    @classmethod
    def from_config(cls, config):

    def count_params(self):