深度学习开发框架Keras入门(2)

1、Keras网络层layers

1.1 核心网络层Dense

Dense：

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

# 作为 Sequential 模型的第一层
model = Sequential()
model.add(Dense(32, input_shape=(16,)))
# 现在模型就会以尺寸为 (*, 16) 的数组作为输入，
# 其输出数组的尺寸为 (*, 32)

# 在第一层之后，你就不再需要指定输入的尺寸了：
model.add(Dense(32))

参数

• units: 正整数，输出空间维度。
• activation: 激活函数。 若不指定，则不使用激活函数 (即，「线性」激活: a(x) = x)。
• use_bias: 布尔值，该层是否使用偏置向量。
• kernel_initializer: kernel 权值矩阵的初始化器
• bias_initializer: 偏置向量的初始化器
• kernel_regularizer: 运用到 kernel 权值矩阵的正则化函数
• bias_regularizer: 运用到偏置向的的正则化函数
• activity_regularizer: 运用到层的输出的正则化函数 (它的 "activation")。
• kernel_constraint: 运用到 kernel 权值矩阵的约束函数
• bias_constraint: 运用到偏置向量的约束函数

Activation:将激活函数应用于输出

keras.layers.Activation(activation)

Dropout:

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

Dropout 包括在训练中每次更新时， 将输入单元的按比率随机设置为 0， 这有助于防止过拟合。

参数

• rate: 在 0 和 1 之间浮动。需要丢弃的输入比例。

• seed: 一个作为随机种子的 Python 整数。

Flatten:将输入展平。不影响批量大小。

keras.layers.Flatten(data_format=None)

model = Sequential()
model.add(Conv2D(64, (3, 3),
                 input_shape=(3, 32, 32), padding='same',))
# 现在：model.output_shape == (None, 64, 32, 32)

model.add(Flatten())
# 现在：model.output_shape == (None, 65536)

Input：Input() 用于实例化 Keras 张量。

keras.engine.input_layer.Input()

返回：一个张量

1.2 卷积层Convolutional

Conv1D:1D卷积层(例如时序卷积)

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

参数

• filters: 整数，输出空间的维度 （即卷积中滤波器的输出数量）。

• kernel_size: 一个整数，或者单个整数表示的元组或列表， 指明 1D 卷积窗口的长度。

• strides: 一个整数，或者单个整数表示的元组或列表， 指明卷积的步长。

• padding: "valid", "causal" 或 "same" 之一 (大小写敏感) "valid" 表示「不填充」。

• use_bias: 布尔值，该层是否使用偏置向量。

• kernel_initializer: kernel 权值矩阵的初始化器

• bias_initializer: 偏置向量的初始化器

• kernel_regularizer: 运用到 kernel 权值矩阵的正则化函数

• bias_regularizer: 运用到偏置向量的正则化函数

Conv2D:2D卷积层(例如对图像空间卷积)

该层创建了一个卷积核， 该卷积核对层输入进行卷积， 以生成输出张量。当使用该层作为模型第一层时，需要提供 input_shape 参数

参数

• filters: 整数，输出空间的维度 （即卷积中滤波器的输出数量）。
• kernel_size: 一个整数，或者 2 个整数表示的元组或列表， 指明 2D 卷积窗口的宽度和高度。 可以是一个整数，为所有空间维度指定相同的值
• strides: 一个整数，或者 2 个整数表示的元组或列表， 指明卷积沿宽度和高度方向的步长。
• padding: "valid" 或 "same" (大小写敏感)。

MaxPooling1D: 对于时序数据的最大池化

keras.layers.MaxPooling1D(pool_size=2, strides=None, padding='valid', data_format='channels_last')

参数

• pool_size: 整数，最大池化的窗口大小。
• strides: 整数，或者是 None。作为缩小比例的因数。 例如，2 会使得输入张量缩小一半。 如果是 None，那么默认值是 pool_size。
• padding: "valid" 或者 "same" （区分大小写）。

MaxPooling2D: 对于空间数据的最大池化

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

参数

• pool_size: 整数，或者 2 个整数表示的元组， 沿（垂直，水平）方向缩小比例的因数。 （2，2）会把输入张量的两个维度都缩小一半。

• strides: 整数，2 个整数表示的元组，或者是 None。 表示步长值。 如果是 None，那么默认值是 pool_size。

• padding: "valid" 或者 "same" （区分大小写）

AveragePooling2D: 对于空间数据的平均池化

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

参数

• pool_size: 整数，或者 2 个整数表示的元组， 沿（垂直，水平）方向缩小比例的因数。 （2，2）会把输入张量的两个维度都缩小一半。 如果只使用一个整数，那么两个维度都会使用同样的窗口长度。
• strides: 整数，2 个整数表示的元组，或者是 None。 表示步长值。 如果是 None，那么默认值是 pool_size。
• padding: "valid" 或者 "same" （区分大小写）

1.3 循环层

RNN: 循环网络层基类

keras.layers.RNN(cell, return_sequences=False, return_state=False, go_backwards=False, stateful=False, unroll=False)

参数

• cell: 一个 RNN 单元实例

• stateful: 布尔值 (默认 False)。 如果为 True，则批次中索引 i 处的每个样品的最后状态将用作下一批次中索引 i 样品的初始状态。

• input_dim: 输入的维度（整数）。 将此层用作模型中的第一层时，此参数（或者，关键字参数 input_shape）是必需的。

• input_length: 输入序列的长度，在恒定时指定。 如果你要在上游连接 Flatten 和 Dense 层， 则需要此参数（如果没有它，无法计算全连接输出的尺寸）。

SimpleRNN: 全连接的RNN，其输出将被反馈到输入。

keras.layers.SimpleRNN(units, activation='tanh', 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, return_sequences=False, return_state=False, go_backwards=False, stateful=False, unroll=False)

参数

• units: 正整数，输出空间的维度。
• activation: 要使用的激活函数。 默认：双曲正切（tanh）。 如果传入 None，则不使用激活函数 (即 线性激活：a(x) = x)。
• use_bias: 布尔值，该层是否使用偏置向量
• dropout: 在 0 和 1 之间的浮点数。 单元的丢弃比例，用于输入的线性转换。
• stateful: 布尔值 (默认 False)。 如果为 True，则批次中索引 i 处的每个样品 的最后状态将用作下一批次中索引 i 样品的初始状态。
• unroll: 布尔值 (默认 False)。 如果为 True，则网络将展开，否则将使用符号循环。 展开可以加速 RNN，但它往往会占用更多的内存。 展开只适用于短序列。

GRU: 门限循环单元网络

keras.layers.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, implementation=1, return_sequences=False, return_state=False, go_backwards=False, stateful=False, unroll=False, reset_after=False)

有两种变体。默认的是基于 1406.1078v3 的实现，同时在矩阵乘法之前将复位门应用于隐藏状态。 另一种则是基于 1406.1078v1 的实现，它包括顺序倒置的操作。

第二种变体与 CuDNNGRU(GPU-only) 兼容并且允许在 CPU 上进行推理。 因此它对于 kernel 和 recurrent_kernel 有可分离偏置。 使用 'reset_after'=True 和 recurrent_activation='sigmoid' 。

参数

• units: 正整数，输出空间的维度。
• activation: 要使用的激活函数。 默认：双曲正切 (tanh)。 如果传入 None，则不使用激活函数 (即 线性激活：a(x) = x)。
• dropout: 在 0 和 1 之间的浮点数。 单元的丢弃比例，用于输入的线性转换。
• stateful: 布尔值 (默认 False)。 如果为 True，则批次中索引 i 处的每个样品的最后状态 将用作下一批次中索引 i 样品的初始状态。
• unroll: 布尔值 (默认 False)。 如果为 True，则网络将展开，否则将使用符号循环。 展开可以加速 RNN，但它往往会占用更多的内存。 展开只适用于短序列。
• GRU 公约 (是否在矩阵乘法之前或者之后使用重置门)。 False =「之前」(默认)，Ture =「之后」( CuDNN 兼容)。

LSTM: 长短期记忆网络(Long short-Term Memory)

keras.layers.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, implementation=1, return_sequences=False, return_state=False, go_backwards=False, stateful=False, unroll=False)

参数

• units: 正整数，输出空间的维度。
• activation: 要使用的激活函数 。如果传入 None，则不使用激活函数 (即 线性激活：a(x) = x)。
• go_backwards: 布尔值 (默认 False)。 如果为 True，则向后处理输入序列并返回相反的序列。
• stateful: 布尔值 (默认 False)。 如果为 True，则批次中索引 i 处的每个样品的最后状态 将用作下一批次中索引 i 样品的初始状态。
• unroll: 布尔值 (默认 False)。 如果为 True，则网络将展开，否则将使用符号循环。 展开可以加速 RNN，但它往往会占用更多的内存。 展开只适用于短序列。

1.4 嵌入层Embedding

Embedding: 将正整数（索引值）转换为固定尺寸的稠密向量。 该层只能用作模型中的第一层。

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

参数

• input_dim: int > 0。词汇表大小， 即，最大整数 index + 1。
  • output_dim: int >= 0。词向量的维度
• input_length: 输入序列的长度，当它是固定的时。 如果你需要连接 Flatten 和 Dense 层，则这个参数是必须的 （没有它，dense 层的输出尺寸就无法计算）。

1.5 融合层Merge

Add： 计算输入张量列表的和。

它接受一个张量的列表， 所有的张量必须有相同的输入尺寸， 然后返回一个张量（和输入张量尺寸相同）。

keras.layers.Add()

例子：

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])
added = keras.layers.Add()([x1, x2])  

out = keras.layers.Dense(4)(added)
model = keras.models.Model(inputs=[input1, input2], outputs=out)

add: Add层的函数式接口

keras.layers.add(inputs)

参数

• inputs: 一个输入张量的列表（列表大小至少为 2）。

返回

一个张量，所有输入张量的和。

Dot：计算两个张量之间样本的点积。

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

例如，如果作用于输入尺寸为 (batch_size, n) 的两个张量 a 和 b， 那么输出结果就会是尺寸为 (batch_size, 1) 的一个张量。 在这个张量中，每一个条目 i 是 a[i] 和 b[i] 之间的点积。

参数

• axes: 整数或者整数元组， 一个或者几个进行点积的轴。
• normalize: 是否在点积之前对即将进行点积的轴进行 L2 标准化。 如果设置成 True，那么输出两个样本之间的余弦相似值。

1.6 高级激活层Advanced Activations

LeakReLU: 带泄漏的 ReLU。

keras.layers.LeakyReLU(alpha=0.3)

当神经元未激活时，它仍允许赋予一个很小的梯度： f(x) = alpha * x for x < 0, f(x) = x for x >= 0.

ThresholdedReLU: 带阈值的修正线性单元

keras.layers.ThresholdedReLU(theta=1.0)

形式： f(x) = x for x > theta, f(x) = 0 otherwise.

输入尺寸

可以是任意的。如果将这一层作为模型的第一层，则需要指定 input_shape 参数 （整数元组，不包含样本数量的维度

Softmax： Softmax 激活函数。

keras.layers.Softmax(axis=-1)

输入尺寸

可以是任意的。如果将这一层作为模型的第一层， 则需要指定 input_shape 参数 （整数元组，不包含样本数量的维度）。

输出尺寸

与输入相同。

参数

• axis: 整数，应用 softmax 标准化的轴。

ReLU：ReLU 激活函数。

keras.layers.ReLU(max_value=None, negative_slope=0.0, threshold=0.0)

使用默认值时，它返回逐个元素的 max(x，0)。

参数

• max_value: 浮点数，最大的输出值。
• negative_slope: float >= 0. 负斜率系数。
• threshold: float。"thresholded activation" 的阈值

否则：

• 如果 x >= max_value，返回 f(x) = max_value，
• 如果 threshold <= x < max_value，返回 f(x) = x,
• 否则，返回 f(x) = negative_slope * (x - threshold)。

1.7 编写自己的Keras层

在自定义层中实现三个方法：

• build(input_shape): 这是你定义权重的地方。这个方法必须设 self.built = True，可以通过调用 super([Layer], self).build() 完成。
• call(x): 这里是编写层的功能逻辑的地方。你只需要关注传入 call 的第一个参数：输入张量，除非你希望你的层支持masking。
• compute_output_shape(input_shape): 如果你的层更改了输入张量的形状，你应该在这里定义形状变化的逻辑，这让Keras能够自动推断各层的形状。

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)

2、数据预处理

2.1 序列预处理

TimeseriesGenerator: 用于生成批量时序数据的实用工具类。

keras.preprocessing.sequence.TimeseriesGenerator(data, targets, length, sampling_rate=1, stride=1, start_index=0, end_index=None, shuffle=False, reverse=False, batch_size=128)

这个类以一系列由相等间隔以及一些时间序列参数（例如步长、历史长度等）汇集的数据点作为输入，以生成用于训练/验证的批次数据。

参数

• data: 可索引的生成器（例如列表或 Numpy 数组），包含连续数据点（时间步）。数据应该是 2D 的，且第 0 个轴为时间维度。
• targets: 对应于 data 的时间步的目标值。它应该与 data 的长度相同。
• length: 输出序列的长度（以时间步数表示）。
• stride: 连续输出序列之间的周期. 对于周期 s, 连续输出样本将为 data[i], data[i+s], data[i+2*s] 等。
• start_index: 在 start_index 之前的数据点在输出序列中将不被使用。这对保留部分数据以进行测试或验证很有用。
• end_index: 在 end_index 之后的数据点在输出序列中将不被使用。这对保留部分数据以进行测试或验证很有用。
• shuffle: 是否打乱输出样本，还是按照时间顺序绘制它们。
• reverse: 布尔值: 如果 true, 每个输出样本中的时间步将按照时间倒序排列。
• batch_size: 每个批次中的时间序列样本数（可能除最后一个外）。

返回: 一个 Sequence实例。

例子：

from keras.preprocessing.sequence import TimeseriesGenerator
import numpy as np

data = np.array([[i] for i in range(50)])
targets = np.array([[i] for i in range(50)])

data_gen = TimeseriesGenerator(data, targets,
                               length=10, sampling_rate=2,
                               batch_size=2)
assert len(data_gen) == 20

batch_0 = data_gen[0]
x, y = batch_0
assert np.array_equal(x,np.array([[[0], [2], [4], [6], [8]],
                                [[1], [3], [5], [7], [9]]]))
assert np.array_equal(y,np.array([[10], [11]]))

skipgrams: 生成skipgram词对

keras.preprocessing.sequence.skipgrams(sequence, vocabulary_size, window_size=4, negative_samples=1.0, shuffle=True, categorical=False, sampling_table=None, seed=None)

该函数将一个单词索引序列（整数列表）转化为以下形式的单词元组：

• （单词, 同窗口的单词），标签为 1（正样本）。
• （单词, 来自词汇表的随机单词），标签为 0（负样本）。

参数

• sequence: 一个编码为单词索引（整数）列表的词序列（句子）。如果使用一个 sampling_table，词索引应该以一个相关数据集的词的排名匹配（例如，10 将会编码为第 10 个最长出现的词）。注意词汇表中的索引 0 是非单词，将被跳过。
• vocabulary_size: 整数，最大可能词索引 + 1
• window_size: 整数，采样窗口大小（技术上是半个窗口）。词 w_i 的窗口是 [i - window_size, i + window_size+1]。
• negative_samples: 大于等于 0 的浮点数。0 表示非负（即随机）采样。1 表示与正样本数相同。
• shuffle: 是否在返回之前将这些词语打乱。
• categorical: 布尔值。如果 False，标签将为整数（例如 [0, 1, 1 .. ]），如果 True，标签将为分类，例如 [[1,0],[0,1],[0,1] .. ]。
• sampling_table: 尺寸为 vocabulary_size 的 1D 数组，其中第 i 项编码了排名为 i 的词的采样概率。
• seed: 随机种子。

返回

couples, labels: 其中 couples 是整数对，labels 是 0 或 1。

2.2 文本预处理Text Preprocessing

Tokenizer: 文本标记实用类

keras.preprocessing.text.Tokenizer(num_words=None, 
                                   filters='!"#$%&()*+,-./:;<=>?@[\]^_`{|}~ ', 
                                   lower=True, 
                                   split=' ', 
                                   char_level=False, 
                                   oov_token=None, 
                                   document_count=0)

该类允许使用两种方法向量化一个文本语料库： 将每个文本转化为一个整数序列（每个整数都是词典中标记的索引）； 或者将其转化为一个向量，其中每个标记的系数可以是二进制值、词频、TF-IDF权重等。

参数

• num_words: 需要保留的最大词数，基于词频。只有最常出现的 num_words 词会被保留。
• filters: 一个字符串，其中每个元素是一个将从文本中过滤掉的字符。默认值是所有标点符号，加上制表符和换行符，减去 ' 字符。
• lower: 布尔值。是否将文本转换为小写。
• split: 字符串。按该字符串切割文本

One-hot: 将文本编码为大小为n的单词索引列表

keras.preprocessing.text.one_hot(text, n, 
                                 filters='!"#$%&()*+,-./:;<=>?@[\]^_`{|}~', 
                                 lower=True, 
                                 split=' ')

这是 hashing_trick 函数的一个封装， 使用 hash 作为散列函数；单词索引映射无保证唯一性。

参数

• text: 输入文本（字符串）。
• n: 整数。词汇表尺寸。
• filters: 要过滤的字符列表（或连接），如标点符号。默认：!"#$%&()*+,-./:;<=>?@[\]^_{|}~，包含基本标点符号，制表符和换行符。
• lower: 布尔值。是否将文本转换为小写。
• split: 字符串。按该字符串切割文本。

返回

[1, n] 之间的整数列表。每个整数编码一个词（唯一性无法保证）。

text_to_word_sequence: 将文本转换为单词（或标记）的序列。

keras.preprocessing.text.text_to_word_sequence(text, 
                                              filters='!"#$%&()*+,-./:;<=>?@[\]^_`{|}~ ', 
                                               lower=True, 
                                               split=' ')

参数

• text: 输入文本（字符串）。
• filters: 要过滤的字符列表（或连接），如标点符号。默认：!"#$%&()*+,-./:;<=>?@[\]^_{|}~，包含基本标点符号，制表符和换行符。
• lower: 布尔值。是否将文本转换为小写。
• split: 字符串。按该字符串切割文本。

返回

词或标记的列表

2.3 图像预处理

ImageDataGenerator类：通过实时数据增强生成张量图像数据批次。数据将不断循环（按批次）。

keras.preprocessing.image.ImageDataGenerator(featurewise_center=False,  
                                             samplewise_center=False, 
                                             featurewise_std_normalization=False, ....)

get_random_transform: 为转换生成随机参数

get_random_transform(img_shape, seed=None)

参数

• seed: 随机种子
• img_shape: 整数元组。被转换的图像的尺寸。

返回

包含随机选择的描述变换的参数的字典

random_transform: 将随机变换应用于图像

random_transform(x, seed=None)

参数

• x: 3D 张量，单张图像。
• seed: 随机种子。

返回

输入的随机转换版本（相同形状）

standardize: 将标准化配置应用于一批输入

standardize(x)

参数

• x: 需要标准化的一批输入。

返回

标准化后的输入。

3、损失函数losses

可用损失函数：mean_squared_error categorical_crossentropy

categorical_crossentropy(y_true,y_pred)

sparse_categorical_crossentropy

sparse_categorical_crossentropy(y_true,y_pred)

binary_crossentropy

binary_crossentropy(y_true,y_pred)

4、评价函数Metrics

评价函数用于评估当前训练模型的性能。当模型编译后（compile），评价函数应该作为 metrics 的参数来输入。

model.compile(loss='mean_squared_error',
              optimizer='sgd',
              metrics=['mae', 'acc'])

from keras import metrics

model.compile(loss='mean_squared_error',
              optimizer='sgd',
              metrics=[metrics.mae, metrics.categorical_accuracy])

5、优化器Optimizers

你可以先实例化一个优化器对象，然后将它传入 model.compile()，像上述示例中一样， 或者你可以通过名称来调用优化器。在后一种情况下，将使用优化器的默认参数

from keras import optimizers

model = Sequential()
model.add(Dense(64, kernel_initializer='uniform', input_shape=(10,)))
model.add(Activation('softmax'))

sgd = optimizers.SGD(lr=0.01, decay=1e-6, momentum=0.9, nesterov=True)
model.compile(loss='mean_squared_error', optimizer=sgd)

# 传入优化器名称: 默认参数将被采用
model.compile(loss='mean_squared_error', optimizer='sgd')

参数 clipnorm 和 clipvalue 能在所有的优化器中使用，用于控制梯度裁剪（Gradient Clipping）:

from keras import optimizers

# 所有参数梯度将被裁剪，让其l2范数最大为1：g * 1 / max(1, l2_norm)
sgd = optimizers.SGD(lr=0.01, clipnorm=1.)



from keras import optimizers

# 所有参数d 梯度将被裁剪到数值范围内：
# 最大值0.5
# 最小值-0.5
sgd = optimizers.SGD(lr=0.01, clipvalue=0.5)

SGD：随机梯度下降优化器

keras.optimizers.SGD(lr=0.01, momentum=0.0, decay=0.0, nesterov=False)

包含扩展功能的支持： - 动量（momentum）优化, - 学习率衰减（每次参数更新后） - Nestrov 动量 (NAG) 优化

参数

• lr: float >= 0. 学习率。
• momentum: float >= 0. 参数，用于加速 SGD 在相关方向上前进，并抑制震荡。
• decay: float >= 0. 每次参数更新后学习率衰减值。
• nesterov: boolean. 是否使用 Nesterov 动量。

RMSprop: RMSprop优化器，建议使用优化器的默认参数(除了学习率lr,它可被自由调节)

这个有阿虎器通常是训练循环神经网络RNN的不错选择

keras.optimizers.RMSprop(lr=0.001, rho=0.9, epsilon=None, decay=0.0)

参数

• lr: float >= 0. 学习率。
• rho: float >= 0. RMSProp梯度平方的移动均值的衰减率.
• epsilon: float >= 0. 模糊因子. 若为 None, 默认为 K.epsilon()。
• decay: float >= 0. 每次参数更新后学习率衰减值。

Adagrad: Adagrad优化器 建议使用优化器的默认参数。

Adagrad 是一种具有特定参数学习率的优化器，它根据参数在训练期间的更新频率进行自适应调整。参数接收的更新越多，更新越小。

keras.optimizers.Adagrad(lr=0.01, epsilon=None, decay=0.0)

参数

• lr: float >= 0. 学习率.
• epsilon: float >= 0. 若为 None, 默认为 K.epsilon().
• decay: float >= 0. 每次参数更新后学习率衰减值.

Adam: 优化器 默认参数遵循原论文中提供的值

keras.optimizers.Adam(lr=0.001, beta_1=0.9, beta_2=0.999, epsilon=None, decay=0.0, amsgrad=False)

参数

• lr: float >= 0. 学习率。
• beta_1: float, 0 < beta < 1. 通常接近于 1。
• beta_2: float, 0 < beta < 1. 通常接近于 1。
• epsilon: float >= 0. 模糊因子. 若为 None, 默认为 K.epsilon()。
• decay: float >= 0. 每次参数更新后学习率衰减值。
• amsgrad: boolean. 是否应用此算法的 AMSGrad 变种

6、激活函数Activations

激活函数可以通过设置单独的激活层实现，也可以在构造层对象时通过传递 activation 参数实现：

from keras.layers import Activation, Dense

model.add(Dense(64))
model.add(Activation('tanh'))
# 等价于
model.add(Dense(64,activation='tanh'))

预定义激活函数：

softmax：Softmax激活函数

keras.activations.softmax(x, axis=-1)

参数

• x：张量。
• axis：整数，代表softmax所作用的维度。

返回

softmax 变换后的张量。

异常

• ValueError：如果 dim(x) == 1。

elu: 指数线性单元

keras.activations.elu(x,alpha=1.0)

参数

• x：张量。
• alpha：一个标量，表示负数部分的斜率。

返回

线性指数激活：如果 x > 0，返回值为 x；如果 x < 0 返回值为 alpha * (exp(x)-1)

relu: 整流线性单元 使用默认值时，返回逐元素的 max(x, 0)

keras.activations.relu(x,alpah=0.0,max_value=None,threshold=0.0)

参数

• x: 张量。
• alpha：负数部分的斜率。默认为 0。
• max_value：输出的最大值。
• threshold: 浮点数。Thresholded activation 的阈值值。

返回：一个张量

tanh: keras.activations.tanh(x)

sigmoid: sigmoid(x)

7、回调函数Callback

回调函数是一个函数的合集，会在训练的阶段中所使用。你可以使用回调函数来查看训练模型的内在状态和统计。你可以传递一个列表的回调函数（作为 callbacks 关键字参数）到 Sequential 或 Model 类型的 .fit() 方法。在训练时，相应的回调函数的方法就会被在各自的阶段被调用。

Callback: 用来组件新的回调函数的抽象基类

keras.callback.Callback()

属性

• params: 字典。训练参数， (例如，verbosity, batch size, number of epochs...)。
• model: keras.models.Model 的实例。 指代被训练模型。

目前，Sequential 模型类的 .fit() 方法会在传入到回调函数的 logs 里面包含以下的数据：

• on_epoch_end: 包括 acc 和 loss 的日志， 也可以选择性的包括 val_loss（如果在 fit 中启用验证），和 val_acc（如果启用验证和监测精确值）。
• on_batch_begin: 包括 size 的日志，在当前批量内的样本数量。
• on_batch_end: 包括 loss 的日志，也可以选择性的包括 acc（如果启用监测精确值）

History: keras.callback.History()

把所有事件都记录到 History 对象的回调函数。

这个回调函数被自动启用到每一个 Keras 模型。History 对象会被模型的 fit 方法返回。