Keras 是什么?
Keras: 基于 Theano 和 TensorFlow 的深度学习库
Keras 是一个高层神经网络 API,Keras 由纯 Python 编写而成并基 https://baike.baidu.com/item/Tensorflow ,Theano 以及 CNTK 后端. Keras 为支持快速实验而生, 能够把你的 idea 迅速转换为结果, 如果你有如下需求, 请选择 Keras:
简易和快速的原型设计(keras 具有高度模块化, 极简, 和可扩充特性)
支持 CNN 和 RNN, 或二者的结合
无缝 CPU 和 GPU 切换
如果还没有配置 keras 可以这个博客配置:
2018 最新 win10 安装 tensorflow1.4(GPU/CPU)+cuda8.0+cudnn8.0-v6 + keras 安装 CUDA 失败 导入 tensorflow 失败报错问题解决
kears 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 )
参数:
units: 大于 0 的整数, 代表该层的输出维度.
activation: 激活函数, 为预定义的激活函数名 (参考激活函数), 或逐元素(element-wise) 的 Theano 函数. 如果不指定该参数, 将不会使用任何激活函数(即使用线性激活函数: a(x)=x)
use_bias: 布尔值, 是否使用偏置项
kernel_initializer: 权值初始化方法, 为预定义初始化方法名的字符串, 或用于初始化权重的初始化器. 参考 initializers
bias_initializer: 权值初始化方法, 为预定义初始化方法名的字符串, 或用于初始化权重的初始化器. 参考 initializers
kernel_regularizer: 施加在权重上的正则项, 为 Regularizer 对象
bias_regularizer: 施加在偏置向量上的正则项, 为 Regularizer 对象
activity_regularizer: 施加在输出上的正则项, 为 Regularizer 对象
kernel_constraints: 施加在权重上的约束项, 为 Constraints 对象
bias_constraints: 施加在偏置上的约束项, 为 Constraints 对象
input_dim: 可以指定输入数据的维度
kears Conv2D()函数 -- 卷积层
若不懂卷积概念可看: 深度学习 (二) 神经网络中的卷积和反卷积原理
- keras.layers.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)
2D 卷积层 (例如对图像的空间卷积).
该层创建了一个卷积核, 该卷积核对层输入进行卷积, 以生成输出张量. 如果 use_bias 为 True, 则会创建一个偏置向量并将其添加到输出中. 最后, 如果 activation 不是 None, 它也会应用于输出.
当使用该层作为模型第一层时, 需要提供 input_shape 参数 (整数元组, 不包含样本表示的轴), 例如, input_shape=(128, 128, 3) 表示 128x128 RGB 图像, 在 data_format="channels_last" 时.
参数
filters: 整数, 输出空间的维度 (即卷积中滤波器的输出数量).
kernel_size: 一个整数, 或者 2 个整数表示的元组或列表, 指明 2D 卷积窗口的宽度和高度. 可以是一个整数, 为所有空间维度指定相同的值.
strides: 一个整数, 或者 2 个整数表示的元组或列表, 指明卷积沿宽度和高度方向的步长. 可以是一个整数, 为所有空间维度指定相同的值. 指定任何 stride 值 != 1 与指定 dilation_rate 值 != 1 两者不兼容.
padding: "valid" 或 "same" (大小写敏感).
data_format: 字符串, channels_last (默认) 或 channels_first 之一, 表示输入中维度的顺序. channels_last 对应输入尺寸为
(batch, height, width, channels)
, channels_first 对应输入尺寸为
(batch, channels, height, width)
. 它默认为从 Keras 配置文件 ~/.keras/keras.JSON 中 找到的 image_data_format 值. 如果你从未设置它, 将使用 "channels_last".
dilation_rate: 一个整数或 2 个整数的元组或列表, 指定膨胀卷积的膨胀率. 可以是一个整数, 为所有空间维度指定相同的值. 当前, 指定任何 dilation_rate 值 != 1 与 指定 stride 值 != 1 两者不兼容.
activation: 要使用的激活函数 (详见 https://keras.io/zh/activations/ ). 如果你不指定, 则不使用激活函数 (即线性激活: a(x) = x).
use_bias: 布尔值, 该层是否使用偏置向量.
kernel_initializer: kernel 权值矩阵的初始化器 (详见 https://keras.io/zh/initializers/ ).
bias_initializer: 偏置向量的初始化器 (详见 https://keras.io/zh/initializers/ ).
kernel_regularizer: 运用到 kernel 权值矩阵的正则化函数 (详见 https://keras.io/zh/regularizers/ ).
bias_regularizer: 运用到偏置向量的正则化函数 (详见 https://keras.io/zh/regularizers/ ).
activity_regularizer: 运用到层输出 (它的激活值) 的正则化函数 (详见 https://keras.io/zh/regularizers/ ).
kernel_constraint: 运用到 kernel 权值矩阵的约束函数 (详见 https://keras.io/zh/constraints/ ).
bias_constraint: 运用到偏置向量的约束函数 (详见 https://keras.io/zh/constraints/ ).
输入尺寸
如果 data_format='channels_first', 输入 4D 张量, 尺寸为
- (samples, channels, rows, cols)
- .
如果 data_format='channels_last', 输入 4D 张量, 尺寸为
- (samples, rows, cols, channels)
- .
输出尺寸
如果 data_format='channels_first', 输出 4D 张量, 尺寸为
- (samples, filters, new_rows, new_cols)
- .
如果 data_format='channels_last', 输出 4D 张量, 尺寸为
- (samples, new_rows, new_cols, filters)
- .
别看上面的参数一堆吓死人, 其实我们在实际运用的时候用的就只有几个而已:
- inputs = Input(shape=(n_ch,patch_height,patch_width))
- conv1 = Conv2D(32, (3, 3), activation='relu', padding='same',data_format='channels_first')(inputs) #这个小括号填 inputs 是代表这层模型连接在 inputs 之后
当然还可以用 kears 内置的序贯模型 add 添加构成模型图:
- model = Sequential()
- # Dense(64) is a fully-connected layer with 64 hidden units.
- # in the first layer, you must specify the expected input data shape:
- # here, 20-dimensional vectors.
- model.add(Dense(64, activation='relu', input_dim=20))
kears MaxPooling2D()函数 -- 池化层
若不懂池化概念可看: 深度学习 (一) 神经网络中的池化与反池化原理
keras.layers.pooling.MaxPooling2D( pool_size=(2, 2), strides=None, padding='valid', data_format=None )
参数:
pool_size: 整数或长为 2 的整数 tuple, 代表在两个方向 (竖直, 水平) 上的下采样因子, 如取 (2,2) 将使图片在两个维度上均变为原长的一半. 为整数意为各个维度值相同且为该数字.
strides: 整数或长为 2 的整数 tuple, 或者 None, 步长值.
padding:'valid'或者'same'
data_format: 字符串,"channels_first" 或 "channels_last" 之一, 代表图像的通道维的位置. 该参数是 Keras 1.x 中的 image_dim_ordering,"channels_last" 对应原本的 "tf","channels_first" 对应原本的 "th". 以 128x128 的 RGB 图像为例,"channels_first" 应将数据组织为(3,128,128), 而 "channels_last" 应将数据组织为(128,128,3). 该参数的默认值是~/.keras/keras.JSON 中设置的值, 若从未设置过, 则为 "channels_last".
还是一样的好多东西默认就行了, 下面就是一个 2*2 的池化层:
pool1 = MaxPooling2D((2, 2))(conv1)
kears model.compile()函数 -- 配置模型
model.compile(optimizer, loss, metrics=None, sample_weight_mode=None)
编译用来配置模型的学习过程, 其参数有
optimizer: 字符串 (预定义优化器名) 或优化器对象, 参考优化器
loss: 字符串 (预定义损失函数名) 或目标函数, 参考损失函数
metrics: 列表, 包含评估模型在训练和测试时的网络性能的指标, 典型用法是 metrics=['accuracy']
sample_weight_mode: 如果你需要按时间步为样本赋权(2D 权矩阵), 将该值设为 "temporal". 默认为 "None", 代表按样本赋权(1D 权). 在下面 fit 函数的解释中有相关的参考内容.
kwargs: 使用 TensorFlow 作为后端请忽略该参数, 若使用 Theano 作为后端, kwargs 的值将会传递给 K.function
示例代码:
model.compile(optimizer='sgd', loss='categorical_crossentropy',metrics=['accuracy'])
kears model.fit()函数 -- 模型运行函数
- fit(self, x, y, batch_size=32, epochs=10, verbose=1, callbacks=None, validation_split=0.0,
- validation_data=None, shuffle=True, class_weight=None, sample_weight=None, initial_epoch=0 )
x: 输入数据. 如果模型只有一个输入, 那么 x 的类型是 numpy array, 如果模型有多个输入, 那么 x 的类型应当为 list,list 的元素是对应于各个输入的 numpy array
y: 标签, numpy array
batch_size: 整数, 指定进行梯度下降时每个 batch 包含的样本数. 训练时一个 batch 的样本会被计算一次梯度下降, 使目标函数优化一步.
epochs: 整数, 训练的轮数, 每个 epoch 会把训练集轮一遍.
verbose: 日志显示, 0 为不在标准输出流输出日志信息, 1 为输出进度条记录, 2 为每个 epoch 输出一行记录
callbacks:list, 其中的元素是 keras.callbacks.Callback 的对象. 这个 list 中的回调函数将会在训练过程中的适当时机被调用, 参考回调函数
validation_split:0~1 之间的浮点数, 用来指定训练集的一定比例数据作为验证集. 验证集将不参与训练, 并在每个 epoch 结束后测试的模型的指标, 如损失函数, 精确度等. 注意, validation_split 的划分在 shuffle 之前, 因此如果你的数据本身是有序的, 需要先手工打乱再指定 validation_split, 否则可能会出现验证集样本不均匀.
validation_data: 形式为 (X,y) 的 tuple, 是指定的验证集. 此参数将覆盖 validation_spilt.
shuffle: 布尔值或字符串, 一般为布尔值, 表示是否在训练过程中随机打乱输入样本的顺序. 若为字符串 "batch", 则是用来处理 HDF5 数据的特殊情况, 它将在 batch 内部将数据打乱.
class_weight: 字典, 将不同的类别映射为不同的权值, 该参数用来在训练过程中调整损失函数(只能用于训练)
sample_weight: 权值的 numpy array, 用于在训练时调整损失函数 (仅用于训练). 可以传递一个 1D 的与样本等长的向量用于对样本进行 1 对 1 的加权, 或者在面对时序数据时, 传递一个的形式为(samples,sequence_length) 的矩阵来为每个时间步上的样本赋不同的权. 这种情况下请确定在编译模型时添加了 sample_weight_mode='temporal'.
initial_epoch: 从该参数指定的 epoch 开始训练, 在继续之前的训练时有用.
参数虽多, 但是很多都可以省略看代码示例:
model.fit(patches_imgs_train, patches_masks_train, epochs=N_epochs, batch_size=batch_size, verbose=1, shuffle=True, validation_split=0.1, callbacks=[checkpointer])
kears predict()函数 -- 测试数据
- predictions = model.predict(patches_imgs_test, batch_size=32, verbose=2)
- print("predicted images size :")
- print(predictions.shape)
kears load_weights()函数 -- 直接导入训练好的模型
- # 加载训练好的模型
- model.load_weights('./weights.h5')
kears Dropout()函数 -- 抛弃一些参数防止过拟合
Dropout(x)
X 可以取 0--1 之间, 代表百分比抛弃数据
Dropout(0.5)随机抛弃百分之五十的数据
kears UpSampling2D()函数 -- 上采样函数
- UpSampling2D(size=(2, 2))
- size(x,y)
x 代表行放大倍数 这里取 2 的话代表原来的一行变成了两行 (就是一行那么粗, 变成了两行那么粗)
y 代表列放大倍数 这里取 2 的话代表原来的一列变成了两行 (就是一列那么粗, 变成了两列那么粗)
size(2,2)其实就等于将原图放大四倍(水平两倍, 垂直两倍) 32*32 变成 62*64 的图像
kears Model()函数 -- 代表模型图
- inputs = Input((n_ch, patch_height, patch_width))
- conv1 = Convolution2D(32, 3, 3, activation='relu', border_mode='same')(inputs)
- conv1 = Dropout(0.2)(conv1)
- conv1 = Convolution2D(32, 3, 3, activation='relu', border_mode='same')(conv1)
- up1 = UpSampling2D(size=(2, 2))(conv1)
- #
- conv2 = Convolution2D(16, 3, 3, activation='relu', border_mode='same')(up1)
- conv2 = Dropout(0.2)(conv2)
- conv2 = Convolution2D(16, 3, 3, activation='relu', border_mode='same')(conv2)
- pool1 = MaxPooling2D(pool_size=(2, 2))(conv2)
- #
- conv3 = Convolution2D(32, 3, 3, activation='relu', border_mode='same')(pool1)
- conv3 = Dropout(0.2)(conv3)
- conv3 = Convolution2D(32, 3, 3, activation='relu', border_mode='same')(conv3)
- pool2 = MaxPooling2D(pool_size=(2, 2))(conv3)
- #
- conv4 = Convolution2D(64, 3, 3, activation='relu', border_mode='same')(pool2)
- conv4 = Dropout(0.2)(conv4)
- conv4 = Convolution2D(64, 3, 3, activation='relu', border_mode='same')(conv4)
- pool3 = MaxPooling2D(pool_size=(2, 2))(conv4)
- #
- conv5 = Convolution2D(128, 3, 3, activation='relu', border_mode='same')(pool3)
- conv5 = Dropout(0.2)(conv5)
- conv5 = Convolution2D(128, 3, 3, activation='relu', border_mode='same')(conv5)
- #
- up2 = merge([UpSampling2D(size=(2, 2))(conv5), conv4], mode='concat', concat_axis=1)
- conv6 = Convolution2D(64, 3, 3, activation='relu', border_mode='same')(up2)
- conv6 = Dropout(0.2)(conv6)
- conv6 = Convolution2D(64, 3, 3, activation='relu', border_mode='same')(conv6)
- #
- up3 = merge([UpSampling2D(size=(2, 2))(conv6), conv3], mode='concat', concat_axis=1)
- conv7 = Convolution2D(32, 3, 3, activation='relu', border_mode='same')(up3)
- conv7 = Dropout(0.2)(conv7)
- conv7 = Convolution2D(32, 3, 3, activation='relu', border_mode='same')(conv7)
- #
- up4 = merge([UpSampling2D(size=(2, 2))(conv7), conv2], mode='concat', concat_axis=1)
- conv8 = Convolution2D(16, 3, 3, activation='relu', border_mode='same')(up4)
- conv8 = Dropout(0.2)(conv8)
- conv8 = Convolution2D(16, 3, 3, activation='relu', border_mode='same')(conv8)
- #
- pool4 = MaxPooling2D(pool_size=(2, 2))(conv8)
- conv9 = Convolution2D(32, 3, 3, activation='relu', border_mode='same')(pool4)
- conv9 = Dropout(0.2)(conv9)
- conv9 = Convolution2D(32, 3, 3, activation='relu', border_mode='same')(conv9)
- #
- conv10 = Convolution2D(2, 1, 1, activation='relu', border_mode='same')(conv9)
- conv10 = core.Reshape((2,patch_height*patch_width))(conv10)
- conv10 = core.Permute((2,1))(conv10)
- ############
- conv10 = core.Activation('softmax')(conv10)
- model = Model(input=inputs, output=conv10)
将模型的输入和输出给 model 函数就会自己组建模型运行图结构
kears Embedding()函数 -- 嵌入层
- 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)
作用: 嵌入层将正整数 (下标) 转换为具有固定大小的向量, 如[[4],[20]]->[[0.25,0.1],[0.6,-0.2]].Embedding 层只能作为模型的第一层.
input_dim: 大或等于 0 的整数, 字典长度, 即输入数据最大下标 + 1, 就是矩阵中的最大值
output_dim: 大于 0 的整数, 代表全连接嵌入的维度
embeddings_initializer: 嵌入矩阵的初始化方法, 为预定义初始化方法名的字符串, 或用于初始化权重的初始化器. 参考 initializers
embeddings_regularizer: 嵌入矩阵的正则项, 为 Regularizer 对象
embeddings_constraint: 嵌入矩阵的约束项, 为 Constraints 对象
mask_zero: 布尔值, 确定是否将输入中的'0'看作是应该被忽略的'填充'(padding)值, 该参数在使用递归层处理变长输入时有用. 设置为 True 的话, 模型中后续的层必须都支持 masking, 否则会抛出异常. 如果该值为 True, 则下标 0 在字典中不可用, input_dim 应设置为 | vocabulary| + 2.
input_length: 当输入序列的长度固定时, 该值为其长度. 如果要在该层后接 Flatten 层, 然后接 Dense 层, 则必须指定该参数, 否则 Dense 层的输出维度无法自动推断.
关于 embeding 作用的详细介绍: http://spaces.ac.cn/archives/4122/
kears normalization()函数 -- 标准化
- 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)
该层在每个 batch 上将前一层的激活值重新规范化, 即使得其输出数据的均值接近 0, 其标准差接近 1
参数
axis: 整数, 指定要规范化的轴, 通常为特征轴. 例如在进行
data_format="channels_first
的 2D 卷积后, 一般会设 axis=1.
momentum: 动态均值的动量
epsilon: 大于 0 的小浮点数, 用于防止除 0 错误
center: 若设为 True, 将会将 beta 作为偏置加上去, 否则忽略参数 beta
scale: 若设为 True, 则会乘以 gamma, 否则不使用 gamma. 当下一层是线性的时, 可以设 False, 因为 scaling 的操作将被下一层执行.
beta_initializer:beta 权重的初始方法
gamma_initializer: gamma 的初始化方法
moving_mean_initializer: 动态均值的初始化方法
moving_variance_initializer: 动态方差的初始化方法
beta_regularizer: 可选的 beta 正则
gamma_regularizer: 可选的 gamma 正则
beta_constraint: 可选的 beta 约束
gamma_constraint: 可选的 gamma 约束
输入 shape
任意, 当使用本层为模型首层时, 指定 input_shape 参数时有意义.
输出 shape
与输入 shape 相同
kears plot()函数 -- 画出模型图
plot(model, to_file='./'+name_experiment+'/'+name_experiment + '_model.PNG')
kears 中可以将自己建立的模型图画出来, 传进去一个模型, 指定画出文件的路径和名字即可
kears ModelCheckpoint()函数 -- 保存模型参数
- checkpointer = ModelCheckpoint(filepath='./'+name_experiment+'/'+name_experiment +'_best_weights.h5', verbose=1, monitor='val_loss', mode='auto', save_best_only=True)
- model.fit(patches_imgs_train, patches_masks_train, epochs=N_epochs, batch_size=batch_size, verbose=1, shuffle=True, validation_split=0.1, callbacks=[checkpointer])
ModelCheckpoint 函数可以指定一定训练次数后保存中间训练的最佳参数
ModelCheckpoint 函数作为 model.fit()函数中回调函数使用
kears merge()函数 -- 融合层
Merge 层提供了一系列用于融合两个层或两个张量的层对象和方法. 以大写首字母开头的是 Layer 类, 以小写字母开头的是张量的函数. 小写字母开头的张量函数在内部实际上是调用了大写字母开头的层.
- Add
- keras.layers.Add()
添加输入列表的图层.
该层接收一个相同 shape 列表张量, 并返回它们的和, shape 不变.
- Example
- import keras
- input1 = keras.layers.Input(shape=(16,))
- x1 = keras.layers.Dense(8, activation='relu')(input1)
- input2 = keras.layers.Input(shape=(32,))
- x2 = keras.layers.Dense(8, activation='relu')(input2)
- added = keras.layers.Add()([x1, x2]) # equivalent to added = keras.layers.add([x1, x2])
- out = keras.layers.Dense(4)(added)
- model = keras.models.Model(inputs=[input1, input2], outputs=out)
- SubStract
- keras.layers.Subtract()
两个输入的层相减.
它将大小至少为 2, 相同 Shape 的列表张量作为输入, 并返回一个张量(输入[0] - 输入[1]), 也是相同的 Shape.
- Example
- import keras
- input1 = keras.layers.Input(shape=(16,))
- x1 = keras.layers.Dense(8, activation='relu')(input1)
- input2 = keras.layers.Input(shape=(32,))
- x2 = keras.layers.Dense(8, activation='relu')(input2)
- # Equivalent to subtracted = keras.layers.subtract([x1, x2])
- subtracted = keras.layers.Subtract()([x1, x2])
- out = keras.layers.Dense(4)(subtracted)
- model = keras.models.Model(inputs=[input1, input2], outputs=out)
- Multiply
- keras.layers.Multiply()
该层接收一个列表的同 shape 张量, 并返回它们的逐元素积的张量, shape 不变.
- Average
- keras.layers.Average()
该层接收一个列表的同 shape 张量, 并返回它们的逐元素均值, shape 不变.
- Maximum
- keras.layers.Maximum()
该层接收一个列表的同 shape 张量, 并返回它们的逐元素最大值, shape 不变.
- Concatenate
- keras.layers.Concatenate(axis=-1)
该层接收一个列表的同 shape 张量, 并返回它们的按照给定轴相接构成的向量.
参数
axis: 想接的轴
**kwargs: 普通的 Layer 关键字参数
- Dot
- keras.layers.Dot(axes, normalize=False)
计算两个 tensor 中样本的张量乘积. 例如, 如果两个张量 a 和 b 的 shape 都为 (batch_size, n), 则输出为形如(batch_size,1) 的张量, 结果张量每个 batch 的数据都是 a[i,:]和 b[i,:]的矩阵 (向量) 点积.
参数
axes: 整数或整数的 tuple, 执行乘法的轴.
normalize: 布尔值, 是否沿执行成绩的轴做 L2 规范化, 如果设为 True, 那么乘积的输出是两个样本的余弦相似性.
**kwargs: 普通的 Layer 关键字参数
- add
- keras.layers.add(inputs)
Add 层的函数式包装
参数:
inputs: 长度至少为 2 的张量列表 A
**kwargs: 普通的 Layer 关键字参数
返回值
输入列表张量之和
- Example
- import keras
- input1 = keras.layers.Input(shape=(16,))
- x1 = keras.layers.Dense(8, activation='relu')(input1)
- input2 = keras.layers.Input(shape=(32,))
- x2 = keras.layers.Dense(8, activation='relu')(input2)
- added = keras.layers.add([x1, x2])
- out = keras.layers.Dense(4)(added)
- model = keras.models.Model(inputs=[input1, input2], outputs=out)
- subtract
- keras.layers.subtract(inputs)
Subtract 层的函数式包装
参数:
inputs: 长度至少为 2 的张量列表 A
**kwargs: 普通的 Layer 关键字参数
返回值
输入张量列表的差别
- Example
- import keras
- input1 = keras.layers.Input(shape=(16,))
- x1 = keras.layers.Dense(8, activation='relu')(input1)
- input2 = keras.layers.Input(shape=(32,))
- x2 = keras.layers.Dense(8, activation='relu')(input2)
- subtracted = keras.layers.subtract([x1, x2])
- out = keras.layers.Dense(4)(subtracted)
- model = keras.models.Model(inputs=[input1, input2], outputs=out)
- multiply
- keras.layers.multiply(inputs)
Multiply 的函数式包装
参数:
inputs: 长度至少为 2 的张量列表
**kwargs: 普通的 Layer 关键字参数
返回值
输入列表张量之逐元素积
- average
- keras.layers.average(inputs)
Average 的函数包装
参数:
inputs: 长度至少为 2 的张量列表
**kwargs: 普通的 Layer 关键字参数
返回值
输入列表张量之逐元素均值
- maximum
- keras.layers.maximum(inputs)
Maximum 的函数包装
参数:
inputs: 长度至少为 2 的张量列表
**kwargs: 普通的 Layer 关键字参数
返回值
输入列表张量之逐元素均值
- concatenate
- keras.layers.concatenate(inputs, axis=-1)
Concatenate 的函数包装
参数
inputs: 长度至少为 2 的张量列
axis: 相接的轴
**kwargs: 普通的 Layer 关键字参数
- dot
- keras.layers.dot(inputs, axes, normalize=False)
Dot 的函数包装
参数
inputs: 长度至少为 2 的张量列
axes: 整数或整数的 tuple, 执行乘法的轴.
normalize: 布尔值, 是否沿执行成绩的轴做 L2 规范化, 如果设为 True, 那么乘积的输出是两个样本的余弦相似性.
**kwargs: 普通的 Layer 关键字参数
kears core()模块函数 -- 常用层
Activation 层
keras.layers.core.Activation(activation)
激活层对一个层的输出施加激活函数
参数
activation: 将要使用的激活函数, 为预定义激活函数名或一个 Tensorflow/Theano 的函数. 参考激活函数
输入 shape
任意, 当使用激活层作为第一层时, 要指定 input_shape
输出 shape
与输入 shape 相同
Dropout 层
keras.layers.core.Dropout(rate, noise_shape=None, seed=None)
为输入数据施加 Dropout.Dropout 将在训练过程中每次更新参数时按一定概率 (rate) 随机断开输入神经元, Dropout 层用于防止过拟合.
参数
rate:0~1 的浮点数, 控制需要断开的神经元的比例
noise_shape: 整数张量, 为将要应用在输入上的二值 Dropout mask 的 shape, 例如你的输入为(batch_size, timesteps, features), 并且你希望在各个时间步上的 Dropout mask 都相同, 则可传入 noise_shape=(batch_size, 1, features).
seed: 整数, 使用的随机数种子
参考文献
Dropout: A Simple Way to Prevent Neural Networks from Overfitting
Flatten 层
keras.layers.core.Flatten()
Flatten 层用来将输入 "压平", 即把多维的输入一维化, 常用在从卷积层到全连接层的过渡. Flatten 不影响 batch 的大小.
例子
- model = Sequential()
- model.add(Convolution2D(64, 3, 3,
- border_mode='same',
- input_shape=(3, 32, 32)))
- # now: model.output_shape == (None, 64, 32, 32)
- model.add(Flatten())
- # now: model.output_shape == (None, 65536)
Reshape 层
keras.layers.core.Reshape(target_shape)
Reshape 层用来将输入 shape 转换为特定的 shape
参数
target_shape: 目标 shape, 为整数的 tuple, 不包含样本数目的维度(batch 大小)
输入 shape
任意, 但输入的 shape 必须固定. 当使用该层为模型首层时, 需要指定 input_shape 参数
输出 shape
(batch_size,)+target_shape
例子
- # as first layer in a Sequential model
- model = Sequential()
- model.add(Reshape((3, 4), input_shape=(12,)))
- # now: model.output_shape == (None, 3, 4)
- # note: `None` is the batch dimension
- # as intermediate layer in a Sequential model
- model.add(Reshape((6, 2)))
- # now: model.output_shape == (None, 6, 2)
- # also supports shape inference using `-1` as dimension
- model.add(Reshape((-1, 2, 2)))
- # now: model.output_shape == (None, 3, 2, 2)
Permute 层
keras.layers.core.Permute(dims)
Permute 层将输入的维度按照给定模式进行重排, 例如, 当需要将 RNN 和 CNN 网络连接时, 可能会用到该层.
参数
dims: 整数 tuple, 指定重排的模式, 不包含样本数的维度. 重拍模式的下标从 1 开始. 例如 (2,1) 代表将输入的第二个维度重拍到输出的第一个维度, 而将输入的第一个维度重排到第二个维度
例子
- model = Sequential()
- model.add(Permute((2, 1), input_shape=(10, 64)))
- # now: model.output_shape == (None, 64, 10)
- # note: `None` is the batch dimension
输入 shape
任意, 当使用激活层作为第一层时, 要指定 input_shape
输出 shape
与输入相同, 但是其维度按照指定的模式重新排列
RepeatVector 层
keras.layers.core.RepeatVector(n)
RepeatVector 层将输入重复 n 次
参数
n: 整数, 重复的次数
输入 shape
形如 (nb_samples, features) 的 2D 张量
输出 shape
形如 (nb_samples, n, features) 的 3D 张量
例子
- model = Sequential()
- model.add(Dense(32, input_dim=32))
- # now: model.output_shape == (None, 32)
- # note: `None` is the batch dimension
- model.add(RepeatVector(3))
- # now: model.output_shape == (None, 3, 32)
Lambda 层
keras.layers.core.Lambda(function, output_shape=None, mask=None, arguments=None)
本函数用以对上一层的输出施以任何 Theano/TensorFlow 表达式
参数
function: 要实现的函数, 该函数仅接受一个变量, 即上一层的输出
output_shape: 函数应该返回的值的 shape, 可以是一个 tuple, 也可以是一个根据输入 shape 计算输出 shape 的函数
mask: 掩膜
arguments: 可选, 字典, 用来记录向函数中传递的其他关键字参数
例子
- # add a x -> x^2 layer
- model.add(Lambda(lambda x: x ** 2))
- # add a layer that returns the concatenation
- # of the positive part of the input and
- # the opposite of the negative part
- def antirectifier(x):
- x -= K.mean(x, axis=1, keepdims=True)
- x = K.l2_normalize(x, axis=1)
- pos = K.relu(x)
- neg = K.relu(-x)
- return K.concatenate([pos, neg], axis=1)
- def antirectifier_output_shape(input_shape):
- shape = list(input_shape)
- assert len(shape) == 2 # only valid for 2D tensors
- shape[-1] *= 2
- return tuple(shape)
- model.add(Lambda(antirectifier,
- output_shape=antirectifier_output_shape))
输入 shape
任意, 当使用该层作为第一层时, 要指定 input_shape
输出 shape
由 output_shape 参数指定的输出 shape, 当使用 tensorflow 时可自动推断
ActivityRegularizer 层
keras.layers.core.ActivityRegularization(l1=0.0, l2=0.0)
经过本层的数据不会有任何变化, 但会基于其激活值更新损失函数值
参数
l1:1 范数正则因子(正浮点数)
l2:2 范数正则因子(正浮点数)
输入 shape
任意, 当使用该层作为第一层时, 要指定 input_shape
输出 shape
与输入 shape 相同
Masking 层
keras.layers.core.Masking(mask_value=0.0)
使用给定的值对输入的序列信号进行 "屏蔽", 用以定位需要跳过的时间步
对于输入张量的时间步, 即输入张量的第 1 维度 (维度从 0 开始算, 见例子), 如果输入张量在该时间步上都等于 mask_value, 则该时间步将在模型接下来的所有层(只要支持 masking) 被跳过(屏蔽).
如果模型接下来的一些层不支持 masking, 却接受到 masking 过的数据, 则抛出异常.
例子
考虑输入数据 x 是一个形如 (samples,timesteps,features) 的张量, 现将其送入 LSTM 层. 因为你缺少时间步为 3 和 5 的信号, 所以你希望将其掩盖. 这时候应该:
赋值 x[:,3,:] = 0.,x[:,5,:] = 0.
在 LSTM 层之前插入 mask_value=0. 的 Masking 层
- model = Sequential()
- model.add(Masking(mask_value=0., input_shape=(timesteps, features)))
- model.add(LSTM(32))
参考网址链接: https://keras-cn.readthedocs.io/en/latest/
来源: https://www.cnblogs.com/DOMLX/p/9769301.html