实现自己的Keras层

一. 所有keras层的基类:Layer

keras的所有层的基类定义在keras/engine/topology.py文件中的Layer类中。

python语言基础

用到的装饰器：

• @property 让类函数能像类变量一样操作
• @interfaces.legacy_xxx_support 让函数支持keras 1.x的 API
• @classmothod 类函数，属于整个类，类似于C++/JAVA中的静态函数。类方法有类变量cls传入，从而可以用cls做一些相关的处理。子类继承时，调用该类方法时，传入的类变量cls是子类，而非父类。既可以在类内部使用self访问，也可以通过实例、类名访问。
• @staticmethod 将外部函数集成到类体中,既可以在类内部使用self访问，也可以通过实例、类名访问。基本上等同于一个全局函数。

magic函数:

• __call__ 让类的实例可以像函数一样调用，正是python的这种特性让我们可以像这样进行层之间的连接：

inputs = Input(shape=(784,))
# 前面的Dense(64, activation='relu')生成了类Dense的一个实例
# 后面的(input)将调用类Dense的__call__函数
x = Dense(64, activation='relu')(inputs) 

InputSpec: 确定层的ndim,dtype,shape，每一层都应有一个input_spec属性，保存InputSpec的实例的list(每一个输入tensor都对应一个)

重点关注以下函数

1. add_weight

每层的参数通过这个函数来设定。可以看到它最终调用的是 K.variable 来生成变量，打开 keras/backend/tensorflow_backend.py 可以看到它生成变量的方式：

v = tf.Variable(value, dtype=tf.as_dtype(dtype), name=name)

让人惊讶的是，keras从居然不是使用tf.get_variable的方式生成变量，可见keras在设计时就根本没有考虑到变量共享，从之前的经验来看，要用keras设计多GPU程序是非常棘手的。(要想让Keras支持多GPU并行，必须从这一步开始修改代码，而这里已经是keras非常底层的代码了。)

2. call / __call__

call是最重要的函数，它用于实现层的功能，子类必须实现。

魔法函数 __call__ 会将收到的输入传递给 call 函数，然后调用 call 函数实现具体的功能。

3. comput_output_shape

根据input_shape 计算输出的shape，子类必须实现。用于自动推断下一层的输入尺寸。

4. build

用来创建当前层的weights，子类必须实现。

5. get_config / from_config

get_config 返回一个字典，获取当前层的参数信息。

from_config 使用根据参数生成一个新的层。代码只有一行：

@classmethod
def from_config(cls, config):
    return cls(**config)

可见from_config是一个classmethod，根据传入的参数，使用当前类的构造函数来生成一个实例。通过子类调用时，cls是子类而不是基类Layer。

二、实现自己的keras层

官方文档的说明：

对于简单的定制操作，我们或许可以通过使用layers.core.Lambda层来完成。但对于任何具有可训练权重的定制层，你应该自己来实现。

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

代码示例(来自keras代码库)

最简单的层Activation层(没有参数)：

class Activation(Layer):
    def __init__(self, activation, **kwargs):
        super(Activation, self).__init__(**kwargs)
        self.supports_masking = True
        self.activation = activations.get(activation)

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

    def get_config(self):
        config = {'activation': activations.serialize(self.activation)}
        base_config = super(Activation, self).get_config()
        return dict(list(base_config.items()) + list(config.items()))

Dropout层：

class Dropout(Layer):
    @interfaces.legacy_dropout_support
    def __init__(self, rate, noise_shape=None, seed=None, **kwargs):
        super(Dropout, self).__init__(**kwargs)
        self.rate = min(1., max(0., rate))
        self.noise_shape = noise_shape
        self.seed = seed
        self.supports_masking = True

    def _get_noise_shape(self, inputs):
        if self.noise_shape is None:
            return self.noise_shape

        symbolic_shape = K.shape(inputs)
        noise_shape = [symbolic_shape[axis] if shape is None else shape
                       for axis, shape in enumerate(self.noise_shape)]
        return tuple(noise_shape)

    def call(self, inputs, training=None):
        if 0. < self.rate < 1.:
            noise_shape = self._get_noise_shape(inputs)

            def dropped_inputs():
                return K.dropout(inputs, self.rate, noise_shape,
                                 seed=self.seed)
            return K.in_train_phase(dropped_inputs, inputs,
                                    training=training)
        return inputs

    def get_config(self):
        config = {'rate': self.rate,
                  'noise_shape': self.noise_shape,
                  'seed': self.seed}
        base_config = super(Dropout, self).get_config()
        return dict(list(base_config.items()) + list(config.items()))

Dense 层：

class Dense(Layer):
    @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

    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

    def call(self, inputs):
        output = K.dot(inputs, self.kernel)
        if self.use_bias:
            output = K.bias_add(output, self.bias)
        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()))