keras常用代码模块介绍——layer模块

相比TensorFlow，keras更加简便易学，学习成本更低，大家只要做到对常用代码模块有所了解，基本就可以按照自己的思路搭建想要的模型。其实这个系列的文章是自己学习过程的笔记而已，部分内容摘抄自官网，也有很多自己不懂的地方，但也希望能帮助大家快速对keras有个认识。

1.通用层

每一个layer的实例都可以使用以下方法：

layer.get_weights()#获取当前层的权重
layer.set_weights()#从numpy中载入权重
layer.get_config()#获取当前层配置信息
layer.input#获取当前层的输入
layer.output#获取当前层的输出
layer.input_shape#获取当前层的输入形状
layer.output_shape#获取当前层的输出形状

通用层的方法其本质都是为了让你检查数据、保存数据用的，方便中间代码的调试过程。

2.高级激活层

说到高级激活了，应该会比较高大上，其实就是对常用的RELU、TANH等函数进行一下稍微的改变而已。这个层封装在keras.layers.advanced_activations里，具体有啥来看一下：

keras.layers.advanced_activations.LeakyReLU(alpha=0.3)#x<0返回x*alpha,x>0返回x
keras.layers.advanced_activations.PReLU(alpha_initializer='zeros', alpha_regularizer=None, alpha_constraint=None, shared_axes=None)#规则和上一个相同，只不过这个时候的alpha变为了一个和x相同形状的、可训练的向量
keras.layers.advanced_activations.ELU(alpha=1.0)#x<0时，f(x) = alpha * (exp(x) - 1.), x>=0时，f(x) = x
keras.layers.advanced_activations.ThresholdedReLU(theta=1.0)#x > theta时，f(x) = x，x<= theata时，f(x) = 0

3.卷积层

这一层只有做卷积神经网络的时候才有用，卷积的方法也是千千万万，但是基本思路是一样的。这一层的方法都在keras.layers.convolutional里，具体的方法方面明显参数变多了。最常用的是Conv1D和Conv2D。

keras.layers.convolutional.Conv1D(filters, kernel_size, strides=1, padding='valid', dilation_rate=1, 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)#参数不重要，和我们讲卷积神经网络原理时看到的一样。
keras.layers.convolutional.Conv2D(filters, kernel_size, strides=(1, 1), padding='valid', data_format=None, dilation_rate=(1, 1), 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)#对二维参数的卷积，就是处理图像的时候经常用
keras.layers.convolutional.Conv3D(filters, kernel_size, strides=(1, 1, 1), padding='valid', data_format=None, dilation_rate=(1, 1, 1), 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)#三维卷积，也是针对图像来的
keras.layers.convolutional.SeparableConv2D(filters, kernel_size, strides=(1, 1), padding='valid', data_format=None, depth_multiplier=1, activation=None, use_bias=True, depthwise_initializer='glorot_uniform', pointwise_initializer='glorot_uniform', bias_initializer='zeros', depthwise_regularizer=None, pointwise_regularizer=None, bias_regularizer=None, activity_regularizer=None, depthwise_constraint=None, pointwise_constraint=None, bias_constraint=None)#可分离卷积，就是卷积过程分两步，可能是计算效率更高。
keras.layers.convolutional.Conv2DTranspose(filters, kernel_size, strides=(1, 1), padding='valid', data_format=None, 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)#这是一个反卷积的情况，就是讲卷积以后的向量反向变换回去。

除此之外，卷积层里还有很多辅助的方法，可以帮助开发者做各种操作。

keras.layers.convolutional.Cropping1D(cropping=(1, 1))#参数为在指定的位置要裁多少元素
keras.layers.convolutional.Cropping2D(cropping=((0, 0), (0, 0)), data_format=None)#图像元素的裁剪
keras.layers.convolutional.Cropping3D(cropping=((1, 1), (1, 1), (1, 1)), data_format=None)#三维方向进行裁剪
keras.layers.convolutional.UpSampling1D(size=2)#将元素重复多少步
keras.layers.convolutional.UpSampling2D(size=(2, 2), data_format=None)#将元素在二维方向上重复多少步
keras.layers.convolutional.UpSampling3D(size=(2, 2, 2), data_format=None)#讲元素在三维方向上重复多少步
keras.layers.convolutional.ZeroPadding1D(padding=1)#一维方向首尾填充0
keras.layers.convolutional.ZeroPadding2D(padding=(1, 1), data_format=None)#二维方向首尾填充0
keras.layers.convolutional.ZeroPadding2D(padding=(1, 1), data_format=None)#三维方向首尾填充0

4.池化层

池化层紧跟卷积层，是对数据降维的一个过程，常用的最大池化和平均池化，但是有学者证明最大池化效果更好，所以通常采用最大池化。

keras.layers.MaxPooling2D(pool_size=(2, 2), strides=None, padding='valid', data_format=None)
keras.layers.AveragePooling2D(pool_size=(2, 2), strides=None, padding='valid', data_format=None)
keras.layers.GlobalMaxPooling2D(data_format=None)
keras.layers.GlobalAveragePooling2D(data_format=None)

global的池化一般用于最后一层，就是将每一个特征图作为一个特征点，然后可以避免送入全连接层的元素太多，有时候也可以替代全连接层使用。

5.其他常用层

这些层都在keras.layers.core，基本建模涉及到数据的转换和处理的时候都会用到这些层。

5.1 dense层

全连接层就是实现点乘加偏置操作

keras.layers.core.Dense(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)

5.2 Activation层

把激活函数加入这一层

keras.layers.core.Activation(activation)

5.3 Dropout层

为了要减少操作要经常性的删除一些不用的元素，dropout层就是以一定概率删除一些层

keras.layers.core.Dropout(rate, noise_shape=None, seed=None)

5.4 Flatten层

这个和numpy的flatten是一样的，就是将多维数据拉平，方便后续操作。

keras.layers.core.Flatten()

5.5 Reshape层

这个是对输入的形状进行重排，排列成自己想要成为的样子。

keras.layers.core.Reshape(target_shape)

5.6 Permute层

维度交换层，两个维护互相交换，为了计算方便，可以满足矩阵乘法的法则。RNN和CNN进行连接的时候可能会用到该层，这一层的其他使用场景也很多。

keras.layers.core.Permute(dims)

5.7 RepeatVector层

将输入重复n次。

keras.layers.core.RepeatVector(n)

5.8 Lambda层

这个lambda和lambda表达式的lambda是一样的，用于推广函数应用的。

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

5.9 ActivityRegularizer

对权重加l1和l2损失的。

keras.layers.core.ActivityRegularization(l1=0.0, l2=0.0)

5.10 Masking层

在神经网络或者说人工智能里，mask都是都是屏蔽信号用的，就是说到了这一步计算不起作用。

keras.layers.core.Masking(mask_value=0.0)

6 embedding层

这个层是一个词向量嵌入的层，怎么说更好呢，就是你有一堆词，扔进embedding里就成了用一堆向量表示的词，一个词用好几个数字表示。embedding层是这样的，keras.layers.embeddings。

keras.layers.embeddings.Embedding(input_dim, output_dim, embeddings_initializer='uniform', embeddings_regularizer=None, activity_regularizer=None, embeddings_constraint=None, mask_zero=False, input_length=None)

7.LocallyConnceted

局部连接层，和卷积很像，只不过是权重不共享，每一部分用的权值都是不同的。这一层放在keras.layers.local里。

7.1 LocallyConnected1D层

和Conv1D类似，同样权值是不共享的。

keras.layers.local.LocallyConnected1D(filters, kernel_size, strides=1, padding='valid', data_format=None, 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)

7.2 LocallyConnected2D层

和Conv2D类似，同样权值是不共享的。

keras.layers.local.LocallyConnected2D(filters, kernel_size, strides=(1, 1), padding='valid', data_format=None, 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)

8.Merge层

Merge层用于两个张量的拼接，也是比较常用的操作，都是layer里已大写字母开头的方法。

8.1 Add层

顾名思义，两个相同维度的张量相加，返回一个新的tensor。

keras.layers.Add()

8.2 SubStract层

这一层和add相对应，是减的，返回的也是一个新tensor。

keras.layers.SubStract()

8.3 Multiply层

这个乘法到了keras都是点乘，就是元素乘

keras.layers.Multiply()

8.4 Average层

返回平均值

keras.layers.Average()

8.5 Maximum层

返回逐元素对比的最大值

keras.layers.Maximum()

8.6 Concatenate层

按照指定的轴将tensor拼接到一起,axis=0行拼接，axis=-1列拼接

keras.layers.Concatenate(axis = -1)

8.7 Dot层

dot在神经网络中的意思是对应位置相乘相加，所以dot层就是相乘相加的一个过程。

keras.layers.Dot(axes, normalize=False)

8.8 add层

Add层的函数式包装，方便使用和运算。

keras.layers.add(inputs)#inputs是两个以上的张量

同理8.2-8.7都有这么一个包装函数，看你需要自己使用。

9.Noise层

这一层是为了增加模型的鲁棒性而添加的，方法都包装在keras.layers.noise这里边。

9.1 GaussianNoise层

加入符合正态分布的噪声，主要是为防止过拟合。

keras.layers.noise.GaussianNoise(stddev)

9.2 GaussianDropout层

加入以1为均值，标准差为sqrt(rate/(1-rate)的乘性高斯噪声，只在训练时候起作用。

keras.layers.noise.GaussianDropout(rate)

9.3 Alpha Dropout层

Alpha Dropout是一种保持输入均值和方差不变的Dropout，具体用法尚未探索到，先留着，后续解决。

keras.layers.noise.AlphaDropout(rate, noise_shape=None, seed=None)

10.规范化层

做标准化用的，将数据转化到0-1之间。

keras.layers.normalization.BatchNormalization(axis=-1, momentum=0.99, epsilon=0.001, center=True, scale=True, beta_initializer='zeros', gamma_initializer='ones', moving_mean_initializer='zeros', moving_variance_initializer='ones', beta_regularizer=None, gamma_regularizer=None, beta_constraint=None, gamma_constraint=None)

11.recurrent层

这一个是针对循环神经网络的层，里边包括了RNN、LSTM等，全都封装在keras.layers.recurrent里。

11.1 Recurrent层

这个是recurrent层的抽象，不能直接用。

keras.layers.recurrent.Recurrent(return_sequences=False, go_backwards=False, stateful=False, unroll=False, implementation=0)

这里这个return_sequences是关键参数，为False是输出最后一层的参数，为True是输出所有层的参数。

11.2 SimpleRNN层

简单的RNN。

keras.layers.SimpleRNN(units, activation='tanh', recurrent_activation='hard_sigmoid', use_bias=True, kernel_initializer='glorot_uniform', recurrent_initializer='orthogonal', bias_initializer='zeros', kernel_regularizer=None, recurrent_regularizer=None, bias_regularizer=None, activity_regularizer=None, kernel_constraint=None, recurrent_constraint=None, bias_constraint=None, dropout=0.0, recurrent_dropout=0.0, implementation=1, return_sequences=False, return_state=False, go_backwards=False, stateful=False, unroll=False)

11.2 GRU层

rnn的改进,参数和SimpleRnn差不多。

keras.layers.recurrent.GRU(units, activation='tanh', recurrent_activation='hard_sigmoid', use_bias=True, kernel_initializer='glorot_uniform', recurrent_initializer='orthogonal', bias_initializer='zeros', kernel_regularizer=None, recurrent_regularizer=None, bias_regularizer=None, activity_regularizer=None, kernel_constraint=None, recurrent_constraint=None, bias_constraint=None, dropout=0.0, recurrent_dropout=0.0)

11.3 LSTM层

rnn的另一种改进。

keras.layers.recurrent.LSTM(units, activation='tanh', recurrent_activation='hard_sigmoid', use_bias=True, kernel_initializer='glorot_uniform', recurrent_initializer='orthogonal', bias_initializer='zeros', unit_forget_bias=True, kernel_regularizer=None, recurrent_regularizer=None, bias_regularizer=None, activity_regularizer=None, kernel_constraint=None, recurrent_constraint=None, bias_constraint=None, dropout=0.0, recurrent_dropout=0.0)

11.4 ConvLSTM2D层

ConvLSTM2D是一个LSTM网络，但它的输入变换和循环变换是通过卷积实现的，这个不太理解，也不咋用。

keras.layers.ConvLSTM2D(filters, kernel_size, strides=(1, 1), padding='valid', data_format=None, dilation_rate=(1, 1), activation='tanh', recurrent_activation='hard_sigmoid', use_bias=True, kernel_initializer='glorot_uniform', recurrent_initializer='orthogonal', bias_initializer='zeros', unit_forget_bias=True, kernel_regularizer=None, recurrent_regularizer=None, bias_regularizer=None, activity_regularizer=None, kernel_constraint=None, recurrent_constraint=None, bias_constraint=None, return_sequences=False, go_backwards=False, stateful=False, dropout=0.0, recurrent_dropout=0.0)

11.5 SimpleRNN/GRU/LSTMCell层

cell类，其实就是将一个细胞单元表示出来。

keras.layers.LSTMCell(units, activation='tanh', recurrent_activation='hard_sigmoid', use_bias=True, kernel_initializer='glorot_uniform', recurrent_initializer='orthogonal', bias_initializer='zeros', unit_forget_bias=True, kernel_regularizer=None, recurrent_regularizer=None, bias_regularizer=None, kernel_constraint=None, recurrent_constraint=None, bias_constraint=None, dropout=0.0, recurrent_dropout=0.0, implementation=1)

11.6 StackedRNNCells层

将多个层包装成一个层。

keras.layers.StackedRNNCells(cells)

11.7 CuDNNGRU/LSTM层

基于CuDNN的快速GRU/LSTM实现，只能在GPU上运行，只能使用tensoflow为后端

keras.layers.CuDNNGRU(units, kernel_initializer='glorot_uniform', recurrent_initializer='orthogonal', bias_initializer='zeros', kernel_regularizer=None, recurrent_regularizer=None, bias_regularizer=None, activity_regularizer=None, kernel_constraint=None, recurrent_constraint=None, bias_constraint=None, return_sequences=False, return_state=False, stateful=False)

12.Wrapper层

用于给各个层进行相关的包装操作。

12.1 TimeDistributed层

该包装器可以把一个层应用到输入的每一个时间步上。

keras.layers.wrappers.TimeDistributed(layer)

12.2 Bidirectional层

用于包装双向RNN和LSTM。

keras.layers.wrappers.Bidirectional(layer, merge_mode='concat', weights=None)

此外你还可以编写自己的层，给一个小案例进行参考。

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

class MyLayer(Layer):

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

    def build(self, input_shape):
        # Create a trainable weight variable for this layer.
        self.kernel = self.add_weight(name='kernel', 
                                      shape=(input_shape[1], self.output_dim),
                                      initializer='uniform',
                                      trainable=True)
        super(MyLayer, self).build(input_shape)  # Be sure to call this somewhere!

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

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