Keras源码阅读之自定义网络层Layer

Keras为我们提供了很多已经定义好的网络，比如Embdding层，LSTM层，GRU等。但是在有些情况下，这些预先定义好的网络层并不能很好的满足我们的需求，这个时候我们就需要自定义网络层。

当然，通过线上，我们可以很方便的查阅到大把资料关于使用keras定义自己的网络层，很多blog都直入主题，直接告诉我们自定义layer需要涉及到三个方法---------build()，call()，以及compute_output_shape()，处理好这几个方法，我们便可以实现我们所需要的功能。但是知其然也要知其所以然，因而今天我们通过阅读keras/engine/base_layer中的Layer类，来更好的理解整个网络层的运行过程。

class Layer(object):
    def __init__(self, **kwargs):
        pass

    @property
    def built(self):
        return self._built

    @built.setter
    def built(self, value):
        self._built = value

    def call(self, inputs, **kwargs):
        return inputs

    def __call__(self, inputs, **kwargs):
        return output

    def compute_output_shape(self, input_shape):
        return input_shape

    def build(self, input_shape):
        self.built = True

上面我将Layer类中的一些关键方法贴出来，为了更加直观理解，方法的具体内容都删了，后面具体分析的时候，在进行补充。

首先我们可以看到，在Layer类中有两个特殊的方法，__init__()和__call__()。

__init__()是构造方法，当我们建立类对象时，首先调用该方法初始化类对象。

__call__()是可调用方法，一旦实现该方法，我们的类对象在某些行为上可以表现的和函数一样。可以直接通过类对象object（）进行调用。下面举个例子。

class myObject:
    def __init__(self,mydata):
        self._mydata = mydata

    def common_method(self):
        print(self._mydata)

    def __call__(self):
        print(self._mydata)

obj = myObject(20)
obj.common_method()
obj()

##########  output  ##############
20
20

上面我们定义了一个类，我们可以发现可以直接通过类对象（）来调用__call__方法。【 obj()等价于obj.__call__() 】

这里我们也可以明白为什么平时可以直接使用例如 LSTM(32)(input）这种形式来添加网络层。其实这种形式本质是

output = LSTM(32)(input)
# 上述代码等价于
mylayer = LSTM(32)
output = mylayer.__call__(input)

上面的实例，我们也可以知道，在layer中__call__方法的参数是input，返回值是output。那么__call__方法究竟做了什么？下面贴关键源码（方便理解整个流程，贴完整的不易理解）感兴趣的可以对照源码理解。

def __call__(self, inputs, **kwargs):

        with K.name_scope(self.name):
            if not self.built:

                ###     somgthing    预处理   删去     ###

                # 调用build()方法，定义网络中需要使用到的参数。
                self.build(unpack_singleton(input_shapes))
                self.built = True
                if self._initial_weights is not None:
                    self.set_weights(self._initial_weights)

          
            # 调用call()方法得到output
            output = self.call(inputs, **kwargs)
            output_mask = self.compute_mask(inputs, previous_mask)

           #########  something   操作    删去  #################

            # 调用compute_output_shape()方法，得到输出的shape
            if all([s is not None
                    for s in to_list(input_shape)]):
                output_shape = self.compute_output_shape(input_shape)
            else:
                if isinstance(input_shape, list):
                    output_shape = [None for _ in input_shape]
                else:
                    output_shape = None

            # 通过node将该层和input层（上一层）连接起来。
            self._add_inbound_node(input_tensors=inputs,
                                   output_tensors=output,
                                   input_masks=previous_mask,
                                   output_masks=output_mask,
                                   input_shapes=input_shape,
                                   output_shapes=output_shape)

        return output

OK! 观察上述代码，我们可以知道在__call__()方法中有几个关键操作，调用build()，调用call()，调用compute_output_shape()，最后再利用node将该层和上一层链接起来（如何链接可以不用关心）。

emmmmmmm，到这里，其实就是整个网络层的运行流程了。大家看懂了就可以撤了。

（somebody :"。。。。。。。what Fuck! 你这讲的都是啥，我还云里雾里呢！"）

好吧，为了不让网友骂，我接着将build()等几个方法具体分析。

build()：我们知道，当我们定义网络层的时候，需要用到一些张量（tensor）来对我们的输入进行操作。比如权重信息Weights,偏差Biases。其实一个网络本身就可以理解为这些张量的集合。keras是如何在我们给定input以及output_dim的情况下定义这些张量的呢？这里主要就是build()方法的功劳了。build函数就是为该网络定义一层相应的张量的集合。在Layer类中有两个成员变量，分别是trainable_weights和non_trainable_weights，分别是指可以训练的参数的集合和不可训练的参数的集合。这两个参数都是list。在build中建立的张量通过add_weight()方法加入到上面两个张量集合中，进而建立网络层。需要注意的是，一个网络层的参数是固定的，我们不能重复添加，因此，build()方法最多只能调用一次。如何保证每个layer的build()最多调用一次？？？这是通过self._built变量来控制的。如果built变量为False，那么build()将会在__call__()中被调用，否则build()方法将不再会被调用。build()在被调用之后，built会被赋值为True，防止以后build（）被重复调用。这在__call__()方法中有体现。所以我们如何没有重新写__call__()方法，那么我们不用担心build()方法会被多次调用。但是如果重新写了__call__()方法，一定要注意在build()调用之后，将built置为True。【TIP：build只接受input一个参数，所以如果需要用到output_shape，可以在__init__()中将output_shape赋值给一个成员变量，这样就可以在build中直接使用output_shape的值了】。举个简单例子，以output=tanh(input*W+B),我们首先定义build()函数。这里用到的参数分别是W和B。假设输出的大小为output_dim，且已经在__init__()中已经初始化了。

def build(self,input_shape):
    # input_shape为（batch_size，input_dim）
    # output_dim为self.output_dim
    input_dim = input_shape[1]
    
    #添加权重W，W的形状为（input_dim，output_dim)
    self.W = self.add_Weight(name='simple_layer',
                            shape=(input_dim,self.output_dim),
                            initializer=self.kernel_initializer,
                            trainable='True')
    #添加偏差信息B，bias的形状为（output_dim，）
    if self.use_bias:
        self.B = self.add_weight(
            shape=(self.output_dim, ),
            initializer=self.bias_initializer,
            name='bias',)
    else:
        self.B = None
    # 没有重写__call__()函数，下面这一句可以不写，不过keras官方好像推荐写上。
    self.built = True

call(): 该方法是整个网络层的逻辑输出。通过build()，我们已经有了网络层的权重等信息，接下来便是通过input以及这些权重张量（W,B)等来获得输出了。如何得到output就要根据大家需要的功能来说了。//////该函数返回值是output，__call__()方法也是通过调用call()来获得输出output。

def call(self,inputs):
    outputs=K.tanh(K.dot(inputs,self.W)+self.B)  #这里的K是指keras.backend
    return outputs

comput_output_shape()：返回输出的形状，便于keras搭建下一层网络时，可以自行推导出输入的形状

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

好了，以上便大功告成了【第一次写blog，希望能帮助大家更好理解keras网络层的整个控制流程,语言组织能力比较差，还请见谅】

Keras源码阅读之自定义网络层Layer

猜你喜欢