keras框架

keras.legacy.layers.merge

Help on function merge in module keras.legacy.layers:merge(inputs, mode='sum', concat_axis=-1, dot_axes=-1, output_shape=None, output_mask=None, arguments=None, name=None)    Functional merge, to apply to Keras tensors (NOT layers).    Returns a Keras tensor.    # Example    ```python    tensor_a = Input(shape=(32,))    tensor_b = Input(shape=(32,))    merged_tensor = merge([tensor_a, tensor_b], mode='concat', concat_axis=1)    ```    # Arguments        mode: String or lambda/function. If string, must be one            of: 'sum', 'mul', 'concat', 'ave', 'cos', 'dot', 'max'.            If lambda/function, it should take as input a list of tensors            and return a single tensor.        concat_axis: Integer, axis to use in mode `concat`.        dot_axes: Integer or tuple of integers,            axes to use in mode `dot` or `cos`.        output_shape: Shape tuple (tuple of integers), or lambda/function            to compute output_shape (only if merge mode is a lambda/function).            If the latter case, it should take as input a list of shape tuples            (1:1 mapping to input tensors) and return a single shape tuple,            including the batch size            (same convention as the `compute_output_shape` method of layers).        node_indices: Optional list of integers containing            the output node index for each input layer            (in case some input layers have multiple output nodes).            will default to an array of 0s if not provided.        tensor_indices: Optional list of indices of output tensors            to consider for merging            (in case some input layer node returns multiple tensors).

concat_feat = merge([concat_feat, x], mode='concat', concat_axis=concat_axis, name='concat_'+str(stage)+'_'+str(branch))

keras.legacy.layers.merge.concatenate()

>>> import keras.legacy.layers as layers>>> dir(layers)['AtrousConvolution1D', 'AtrousConvolution2D', 'Highway', 'InputSpec', 'K', 'Layer', 'MaxoutDense', 'Merge', '__builtins__', '__doc__', '__file__', '__name__', '__package__', 'activations', 'constraints', 'func_dump', 'func_load', 'initializers', 'inspect', 'merge', 'python_types', 'regularizers', 'warnings']>>>>>> dir(layers.Merge)['__call__', '__class__', '__delattr__', '__dict__', '__doc__', '__format__', '__getattribute__', '__hash__', '__init__', '__module__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__', '_add_inbound_node', '_arguments_validation', '_get_node_attribute_at_index', 'add_loss', 'add_update', 'add_weight', 'assert_input_compatibility', 'build', 'built', 'call', 'compute_mask', 'compute_output_shape', 'constraints', 'count_params', 'from_config', 'get_config', 'get_input_at', 'get_input_mask_at', 'get_input_shape_at', 'get_losses_for', 'get_output_at', 'get_output_mask_at', 'get_output_shape_at', 'get_updates_for', 'get_weights', 'input', 'input_mask', 'input_shape', 'losses', 'non_trainable_weights', 'output', 'output_mask', 'output_shape', 'set_weights', 'trainable_weights', 'updates', 'weights']

def concatenate(inputs, axis=-1, **kwargs):    """Functional interface to the `Concatenate` layer.    # Arguments        inputs: A list of input tensors (at least 2).        axis: Concatenation axis.        **kwargs: Standard layer keyword arguments.    # Returns        A tensor, the concatenation of the inputs alongside axis `axis`.    """    return Concatenate(axis=axis, **kwargs)(inputs)

x = layers.concatenate(        [branch1x1, branch5x5, branch3x3dbl, branch_pool],        axis=channel_axis,        name='mixed1')

---

保存导入模型

你可以使用model.save(filepath)将Keras模型和权重保存在一个HDF5文件中，该文件将包含：

• 模型的结构，以便重构该模型
• 模型的权重
• 训练配置（损失函数，优化器等）
• 优化器的状态，以便于从上次训练中断的地方开始

使用keras.models.load_model(filepath)来重新实例化你的模型，如果文件中存储了训练配置的话，该函数还会同时完成模型的编译

from keras.models import load_modelmodel.save('my_model.h5')  # creates a HDF5 file 'my_model.h5'del model  # deletes the existing model# returns a compiled model# identical to the previous onemodel = load_model('my_model.h5')

如果你只是希望保存模型的结构，而不包含其权重或配置信息，可以使用：

# save as JSONjson_string = model.to_json()# save as YAMLyaml_string = model.to_yaml()

这项操作将把模型序列化为json或yaml文件，这些文件对人而言也是友好的，如果需要的话你甚至可以手动打开这些文件并进行编辑。
当然，你也可以从保存好的json文件或yaml文件中载入模型：

# model reconstruction from JSON:from keras.models import model_from_jsonmodel = model_from_json(json_string)# model reconstruction from YAMLmodel = model_from_yaml(yaml_string)

如果需要保存模型的权重，可通过下面的代码利用HDF5进行保存。注意，在使用前需要确保你已安装了HDF5和其Python库h5py
model.save_weights('my_model_weights.h5')
如果你需要在代码中初始化一个完全相同的模型，请使用：
model.load_weights('my_model_weights.h5')
如果你需要加载权重到不同的网络结构（有些层一样）中，例如fine-tune或transfer-learning，你可以通过层名字来加载模型：
model.load_weights('my_model_weights.h5', by_name=True)

"""假如原模型为：    model = Sequential()    model.add(Dense(2, input_dim=3, name="dense_1"))    model.add(Dense(3, name="dense_2"))    ...    model.save_weights(fname)"""# new modelmodel = Sequential()model.add(Dense(2, input_dim=3, name="dense_1"))  # will be loadedmodel.add(Dense(10, name="new_dense"))  # will not be loaded# load weights from first model; will only affect the first layer, dense_1.model.load_weights(fname, by_name=True)

model.save('model.h5')
model.load_weights('model.h5')
- 导入.h5格式文件

import h5pyimport numpy as npfrom sklearn.utils import shuffleX_train = []X_test = []for filename in ["gap_ResNet50.h5", "gap_Xception.h5", "gap_InceptionV3.h5"]:    with h5py.File(filename, 'r') as h:        X_train.append(np.array(h['train']))        X_test.append(np.array(h['test']))        y_train = np.array(h['label'])X_train = np.concatenate(X_train, axis=1)X_test = np.concatenate(X_test, axis=1)X_train, y_train = shuffle(X_train, y_train)

如何利用Keras处理超过机器内存的数据集？
可以使用model.train_on_batch(X,y)和model.test_on_batch(X,y)

---

模型可视化

keras.utils.vis_utils模块提供了画出Keras模型的函数（利用graphviz）
该函数将画出模型结构图，并保存成图片：

from keras.utils import plot_modelplot_model(model, to_file='model.png')

plot_model(model, to_file='model.png', show_shapes=False, show_layer_names=True)
plot_model接收两个可选参数：
show_shapes：指定是否显示输出数据的形状，默认为False
show_layer_names:指定是否显示层名称,默认为True
我们也可以直接获取一个pydot.Graph对象，然后按照自己的需要配置它，例如，如果要在ipython中展示图片

from IPython.display import SVGfrom keras.utils.vis_utils import model_to_dotSVG(model_to_dot(model).create(prog='dot', format='svg'))

Tips】依赖 pydot-ng 和 graphviz，若出现错误，用命令行输入pip install pydot-ng & brew install graphviz

#from keras.utils.visualize_util import plot from keras.utils.vis_utils import plot_modelfrom IPython.display import Imageplot_model(model, to_file="model.png", show_shapes=True)Image('model.png')

from keras.models import Sequentialfrom keras.layers import Dense, Activationimport keras# For a single-input model with 10 classes (categorical classification):model = Sequential()model.add(Dense(64, activation='relu', input_dim=100))model.add(Dense(64, activation='relu'))model.add(Dense(32, activation='relu'))model.add(Dense(10, activation='softmax'))model.compile(optimizer='rmsprop',              loss='categorical_crossentropy',              metrics=['accuracy'])#from keras.utils.visualize_util import plot from keras.utils.vis_utils import plot_modelfrom IPython.display import Imageplot_model(model, to_file="model.png", show_shapes=True)Image('model.png')# Generate dummy dataimport numpy as npdata = np.random.random((1000, 100))labels = np.random.randint(10, size=(1000, 1))# Convert labels to categorical one-hot encodingone_hot_labels = keras.utils.to_categorical(labels, num_classes=10)# Train the model, iterating on the data in batches of 32 samplesmodel.fit(data, one_hot_labels, epochs=100, batch_size=32)

---

序贯模型

序贯模型是多个网络层的线性堆叠，也就是“一条路走到黑”。
可以通过向Sequential模型传递一个layer的list来构造该模型：

from keras.models import Sequentialfrom keras.layers import Dense, Activationmodel = Sequential([Dense(32, units=784),Activation('relu'),Dense(10),Activation('softmax'),])

    也可以通过.add()方法一个个的将layer加入模型中：

model = Sequential()model.add(Dense(32, input_shape=(784,)))model.add(Activation('relu'))

Sequential模型方法

• add
  add(self, layer)
  向模型中添加一个层
  layer: Layer对象
• pop
  pop(self)
  弹出模型最后的一层，无返回值
• compile
  compile(self, 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
  模型在使用前必须编译，否则在调用fit或evaluate时会抛出异常。

model = Sequential()model.add(Dense(32, input_shape=(500,)))model.add(Dense(10, activation='softmax'))model.compile(optimizer='rmsprop',      loss='categorical_crossentropy',      metrics=['accuracy'])

• 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)

  本函数将模型训练nb_epoch轮，其参数有：
  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开始训练，在继续之前的训练时有用。

• evaluate
  evaluate(self, x, y, batch_size=32, verbose=1, sample_weight=None)
  本函数返回一个测试误差的标量值（如果模型没有其他评价指标），或一个标量的list（如果模型还有其他的评价指标）。model.metrics_names将给出list中各个值的含义。
• predict
  predict(self, x, batch_size=32, verbose=0)
  本函数按batch获得输入数据对应的输出，函数的返回值是预测值的numpy array
• fit_generator
  fit_generator(self, generator, steps_per_epoch, epochs=1, verbose=1, callbacks=None,
validation_data=None, validation_steps=None, class_weight=None, max_q_size=10,
workers=1, pickle_safe=False, initial_epoch=0)
  利用Python的生成器，逐个生成数据的batch并进行训练。生成器与模型将并行执行以提高效率。例如，该函数允许我们在CPU上进行实时的数据提升，同时在GPU上进行模型训练
  函数的参数是：
  generator：生成器函数，生成器的输出应该为：
  一个形如（inputs，targets）的tuple
  一个形如（inputs, targets,sample_weight）的tuple。所有的返回值都应该包含相同数目的样本。生成器将无限在数据集上循环。每个epoch以经过模型的样本数达到samples_per_epoch时，记一个epoch结束
  steps_per_epoch：整数，当生成器返回steps_per_epoch次数据时计一个epoch结束，执行下一个epoch
  epochs：整数，数据迭代的轮数
  verbose：日志显示，0为不在标准输出流输出日志信息，1为输出进度条记录，2为每个epoch输出一行记录
  validation_data：具有以下三种形式之一
  生成验证集的生成器
  一个形如（inputs,targets）的tuple
  一个形如（inputs,targets，sample_weights）的tuple
  validation_steps: 当validation_data为生成器时，本参数指定验证集的生成器返回次数
  class_weight：规定类别权重的字典，将类别映射为权重，常用于处理样本不均衡问题。
  sample_weight：权值的numpy array，用于在训练时调整损失函数（仅用于训练）。可以传递一个1D的与样本等长的向量用于对样本进行1对1的加权，或者在面对时序数据时，传递一个的形式为（samples，sequence_length）的矩阵来为每个时间步上的样本赋不同的权。这种情况下请确定在编译模型时添加了sample_weight_mode=’temporal’。
  workers：最大进程数
  max_q_size：生成器队列的最大容量
  pickle_safe: 若为真，则使用基于进程的线程。由于该实现依赖多进程，不能传递non picklable（无法被pickle序列化）的参数到生成器中，因为无法轻易将它们传入子进程中。
  initial_epoch: 从该参数指定的epoch开始训练，在继续之前的训练时有用。

def generate_arrays_from_file(path):    while 1:            f = open(path)            for line in f:                # create Numpy arrays of input data                # and labels, from each line in the file                x, y = process_line(line)                yield (x, y)        f.close()model.fit_generator(generate_arrays_from_file('/my_file.txt'),        samples_per_epoch=10000, epochs=10)

• 例子
  卷积神经网络：

import numpy as npimport kerasfrom keras.models import Sequentialfrom keras.layers import Dense, Dropout, Flattenfrom keras.layers import Conv2D, MaxPooling2Dfrom keras.optimizers import SGD# Generate dummy datax_train = np.random.random((100, 100, 100, 3))y_train = keras.utils.to_categorical(np.random.randint(10, size=(100, 1)), num_classes=10)x_test = np.random.random((20, 100, 100, 3))y_test = keras.utils.to_categorical(np.random.randint(10, size=(20, 1)), num_classes=10)model = Sequential()# input: 100x100 images with 3 channels -> (100, 100, 3) tensors.# this applies 32 convolution filters of size 3x3 each.model.add(Conv2D(32, (3, 3), activation='relu', input_shape=(100, 100, 3)))model.add(Conv2D(32, (3, 3), activation='relu'))model.add(MaxPooling2D(pool_size=(2, 2)))model.add(Dropout(0.25))model.add(Conv2D(64, (3, 3), activation='relu'))model.add(Conv2D(64, (3, 3), activation='relu'))model.add(MaxPooling2D(pool_size=(2, 2)))model.add(Dropout(0.25))model.add(Flatten())model.add(Dense(256, activation='relu'))model.add(Dropout(0.5))model.add(Dense(10, activation='softmax'))sgd = SGD(lr=0.01, decay=1e-6, momentum=0.9, nesterov=True)model.compile(loss='categorical_crossentropy', optimizer=sgd)model.fit(x_train, y_train, batch_size=32, epochs=10)score = model.evaluate(x_test, y_test, batch_size=32)

使用LSTM的序列分类

from keras.models import Sequentialfrom keras.layers import Dense, Dropoutfrom keras.layers import Embeddingfrom keras.layers import LSTMmodel = Sequential()model.add(Embedding(max_features, output_dim=256))model.add(LSTM(128))model.add(Dropout(0.5))model.add(Dense(1, activation='sigmoid'))model.compile(loss='binary_crossentropy',              optimizer='rmsprop',              metrics=['accuracy'])model.fit(x_train, y_train, batch_size=16, epochs=10)score = model.evaluate(x_test, y_test, batch_size=16)

---

函数式模型

函数式模型称作Functional，但它的类名是Model，因此我们有时候也用Model来代表函数式模型。
Keras函数式模型接口是用户定义多输出模型、非循环有向模型或具有共享层的模型等复杂模型的途径。一句话，只要你的模型不是类似VGG一样一条路走到黑的模型，或者你的模型需要多于一个的输出，那么你总应该选择函数式模型。函数式模型是最广泛的一类模型，序贯模型（Sequential）只是它的一种特殊情况。

• 我们使用Model来初始化一个函数式模型

from keras.models import Modelfrom keras.layers import Input, Densea = Input(shape=(32,))b = Dense(32)(a)model = Model(inputs=a, outputs=b)

在这里，我们的模型以a为输入，以b为输出，同样我们可以构造拥有多输入和多输出的模型
model = Model(inputs=[a1, a2], outputs=[b1, b3, b3])

Model模型方法

• compile
  compile(self, optimizer, loss, metrics=None, loss_weights=None, sample_weight_mode=None)
  本函数编译模型以供训练，参数有：
  optimizer：优化器，为预定义优化器名或优化器对象，参考优化器
  loss：损失函数，为预定义损失函数名或一个目标函数，参考损失函数
  metrics：列表，包含评估模型在训练和测试时的性能的指标，典型用法是metrics=[‘accuracy’]如果要在多输出模型中为不同的输出指定不同的指标，可像该参数传递一个字典，例如metrics={‘ouput_a’: ‘accuracy’}
  sample_weight_mode：如果你需要按时间步为样本赋权（2D权矩阵），将该值设为“temporal”。默认为“None”，代表按样本赋权（1D权）。如果模型有多个输出，可以向该参数传入指定sample_weight_mode的字典或列表。在下面fit函数的解释中有相关的参考内容。
  kwargs：使用TensorFlow作为后端请忽略该参数，若使用Theano作为后端，kwargs的值将会传递给 K.function

• fit
  fit(self, x=None, y=None, batch_size=32, epochs=1, verbose=1, callbacks=None,
validation_split=0.0, validation_data=None, shuffle=True, class_weight=None,
sample_weight=None, initial_epoch=0)

• evaluate
  evaluate(self, x, y, batch_size=32, verbose=1, sample_weight=None)

• predict
  predict(self, x, batch_size=32, verbose=0)

• fit_generator
  fit_generator(self, generator, steps_per_epoch, epochs=1, verbose=1, callbacks=None,
validation_data=None, validation_steps=None, class_weight=None,
max_q_size=10, workers=1, pickle_safe=False, initial_epoch=0)

• 例子

全连接网络

from keras.layers import Input, Densefrom keras.models import Model# This returns a tensorinputs = Input(shape=(784,))# a layer instance is callable on a tensor, and returns a tensorx = Dense(64, activation='relu')(inputs)x = Dense(64, activation='relu')(x)predictions = Dense(10, activation='softmax')(x)# This creates a model that includes# the Input layer and three Dense layersmodel = Model(inputs=inputs, outputs=predictions)model.compile(optimizer='rmsprop',              loss='categorical_crossentropy',              metrics=['accuracy'])model.fit(data, labels)  # starts training

多输入和多输出模型
使用函数式模型的一个典型场景是搭建多输入、多输出的模型。

from keras.layers import Input, Embedding, LSTM, Densefrom keras.models import Model# Headline input: meant to receive sequences of 100 integers, between 1 and 10000.# Note that we can name any layer by passing it a "name" argument.main_input = Input(shape=(100,), dtype='int32', name='main_input')# This embedding layer will encode the input sequence# into a sequence of dense 512-dimensional vectors.x = Embedding(output_dim=512, input_dim=10000, input_length=100)(main_input)# A LSTM will transform the vector sequence into a single vector,# containing information about the entire sequencelstm_out = LSTM(32)(x)auxiliary_output = Dense(1, activation='sigmoid', name='aux_output')(lstm_out)auxiliary_input = Input(shape=(5,), name='aux_input')x = keras.layers.concatenate([lstm_out, auxiliary_input])# We stack a deep densely-connected network on topx = Dense(64, activation='relu')(x)x = Dense(64, activation='relu')(x)x = Dense(64, activation='relu')(x)# And finally we add the main logistic regression layermain_output = Dense(1, activation='sigmoid', name='main_output')(x)model = Model(inputs=[main_input, auxiliary_input], outputs=[main_output, auxiliary_output])model.compile(optimizer='rmsprop', loss='binary_crossentropy',              loss_weights=[1., 0.2])model.fit([headline_data, additional_data], [labels, labels],          epochs=50, batch_size=32)             

因为我们输入和输出是被命名过的（在定义时传递了“name”参数），我们也可以用下面的方式编译和训练模型：

model.compile(optimizer='rmsprop',              loss={'main_output': 'binary_crossentropy', 'aux_output': 'binary_crossentropy'},              loss_weights={'main_output': 1., 'aux_output': 0.2})# And trained it via:model.fit({'main_input': headline_data, 'aux_input': additional_data},          {'main_output': labels, 'aux_output': labels},          epochs=50, batch_size=32)

• 共享层

import kerasfrom keras.layers import Input, LSTM, Densefrom keras.models import Modeltweet_a = Input(shape=(140, 256))tweet_b = Input(shape=(140, 256))# This layer can take as input a matrix# and will return a vector of size 64shared_lstm = LSTM(64)# When we reuse the same layer instance# multiple times, the weights of the layer# are also being reused# (it is effectively *the same* layer)encoded_a = shared_lstm(tweet_a)encoded_b = shared_lstm(tweet_b)# We can then concatenate the two vectors:merged_vector = keras.layers.concatenate([encoded_a, encoded_b], axis=-1)# And add a logistic regression on toppredictions = Dense(1, activation='sigmoid')(merged_vector)# We define a trainable model linking the# tweet inputs to the predictionsmodel = Model(inputs=[tweet_a, tweet_b], outputs=predictions)model.compile(optimizer='rmsprop',              loss='binary_crossentropy',              metrics=['accuracy'])model.fit([data_a, data_b], labels, epochs=10)

• 层“节点”的概念
  无论何时，当你在某个输入上调用层时，你就创建了一个新的张量（即该层的输出），同时你也在为这个层增加一个“（计算）节点”。这个节点将输入张量映射为输出张量。当你多次调用该层时，这个层就有了多个节点，其下标分别为0，1，2…

如果层只与一个输入相连，那没有任何困惑的地方。.output将会返回该层唯一的输出

a = Input(shape=(140, 256))lstm = LSTM(32)encoded_a = lstm(a)assert lstm.output == encoded_a

但当层与多个输入相连时，会出现问题

a = Input(shape=(140, 256))b = Input(shape=(140, 256))lstm = LSTM(32)encoded_a = lstm(a)encoded_b = lstm(b)lstm.output

上面这段代码会报错
通过下面这种调用方式即可解决

assert lstm.get_output_at(0) == encoded_aassert lstm.get_output_at(1) == encoded_b

---

常用层

• 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)

Dense就是常用的全连接层，所实现的运算是output = activation(dot(input, kernel)+bias)。其中activation是逐元素计算的激活函数，kernel是本层的权值矩阵，bias为偏置向量，只有当use_bias=True才会添加。

如果本层的输入数据的维度大于2，则会先被压为与kernel相匹配的大小。

参数：

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对象
输入：
形如(batch_size, …, input_dim)的nD张量，最常见的情况为(batch_size, input_dim)的2D张量

输出：
形如(batch_size, …, units)的nD张量，最常见的情况为(batch_size, units)的2D张量

# as first layer in a sequential model:model = Sequential()model.add(Dense(32, input_shape=(16,)))# now the model will take as input arrays of shape (*, 16)# and output arrays of shape (*, 32)# after the first layer, you don't need to specify# the size of the input anymore:model.add(Dense(32))

• Activation层
  keras.layers.core.Activation(activation)
  参数
  activation：将要使用的激活函数，为预定义激活函数名或一个Tensorflow/Theano的函数。

• 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：整数，使用的随机数种子

• 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)
  参数：
  target_shape：目标shape，为整数的tuple，不包含样本数目的维度（batch大小）

# as first layer in a Sequential modelmodel = 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 modelmodel.add(Reshape((6, 2)))# now: model.output_shape == (None, 6, 2)# also supports shape inference using `-1` as dimensionmodel.add(Reshape((-1, 2, 2)))# now: model.output_shape == (None, 3, 2, 2)

• Lambda层
  keras.layers.core.Lambda(function, output_shape=None, mask=None, arguments=None)
  本函数用以对上一层的输出施以任何Theano/TensorFlow表达式
  参数：
  function：要实现的函数，该函数仅接受一个变量，即上一层的输出
  output_shape：函数应该返回的值的shape，可以是一个tuple，也可以是一个根据输入shape计算输出shape的函数
  mask: 掩膜
  arguments：可选，字典，用来记录向函数中传递的其他关键字参数

• Conv2D层
  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)
  二维卷积层，即对图像的空域卷积。该层对二维输入进行滑动窗卷积，当使用该层作为第一层时，应提供input_shape参数。例如input_shape = (128,128,3)代表128*128的彩色RGB图像（data_format='channels_last'）

参数:
filters：卷积核的数目（即输出的维度）
kernel_size：单个整数或由两个整数构成的list/tuple，卷积核的宽度和长度。如为单个整数，则表示在各个空间维度的相同长度。
strides：单个整数或由两个整数构成的list/tuple，为卷积的步长。如为单个整数，则表示在各个空间维度的相同步长。任何不为1的strides均与任何不为1的dilation_rate均不兼容
padding：补0策略，为“valid”, “same” 。“valid”代表只进行有效的卷积，即对边界数据不处理。“same”代表保留边界处的卷积结果，通常会导致输出shape与输入shape相同。
activation：激活函数，为预定义的激活函数名（参考激活函数），或逐元素（element-wise）的Theano函数。如果不指定该参数，将不会使用任何激活函数（即使用线性激活函数：a(x)=x）
dilation_rate：单个整数或由两个个整数构成的list/tuple，指定dilated convolution中的膨胀比例。任何不为1的dilation_rate均与任何不为1的strides均不兼容。
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”。
use_bias:布尔值，是否使用偏置项
kernel_initializer：权值初始化方法，为预定义初始化方法名的字符串，或用于初始化权重的初始化器。参考initializers
bias_initializer：权值初始化方法，为预定义初始化方法名的字符串，或用于初始化权重的初始化器。参考initializers
kernel_regularizer：施加在权重上的正则项，为Regularizer对象
bias_regularizer：施加在偏置向量上的正则项，为Regularizer对象
activity_regularizer：施加在输出上的正则项，为Regularizer对象
kernel_constraints：施加在权重上的约束项，为Constraints对象
bias_constraints：施加在偏置上的约束项，为Constraints对象
输入shape：
‘channels_first’模式下，输入形如（samples,channels，rows，cols）的4D张量

‘channels_last’模式下，输入形如（samples，rows，cols，channels）的4D张量

注意这里的输入shape指的是函数内部实现的输入shape，而非函数接口应指定的input_shape，请参考下面提供的例子。

输出shape：
‘channels_first’模式下，为形如（samples，nb_filter, new_rows, new_cols）的4D张量

‘channels_last’模式下，为形如（samples，new_rows, new_cols，nb_filter）的4D张量

输出的行列数可能会因为填充方法而改变

• 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，步长值。
border_mode：‘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”。
输入shape：
‘channels_first’模式下，为形如（samples，channels, rows，cols）的4D张量
‘channels_last’模式下，为形如（samples，rows, cols，channels）的4D张量

输出shape：
‘channels_first’模式下，为形如（samples，channels, pooled_rows, pooled_cols）的4D张量
‘channels_last’模式下，为形如（samples，pooled_rows, pooled_cols，channels）的4D张量

• GRU层–门限循环单元
  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)

  参数：
  units：输出维度
  activation：激活函数，为预定义的激活函数名（参考激活函数）
  use_bias: 布尔值，是否使用偏置项
  kernel_initializer：权值初始化方法，为预定义初始化方法名的字符串，或用于初始化权重的初始化器。参考initializers
  recurrent_initializer：循环核的初始化方法，为预定义初始化方法名的字符串，或用于初始化权重的初始化器。参考initializers
  bias_initializer：权值初始化方法，为预定义初始化方法名的字符串，或用于初始化权重的初始化器。参考initializers
  kernel_regularizer：施加在权重上的正则项，为Regularizer对象
  bias_regularizer：施加在偏置向量上的正则项，为Regularizer对象
  recurrent_regularizer：施加在循环核上的正则项，为Regularizer对象
  activity_regularizer：施加在输出上的正则项，为Regularizer对象
  kernel_constraints：施加在权重上的约束项，为Constraints对象
  recurrent_constraints：施加在循环核上的约束项，为Constraints对象
  bias_constraints：施加在偏置上的约束项，为Constraints对象
  dropout：0~1之间的浮点数，控制输入线性变换的神经元断开比例
  recurrent_dropout：0~1之间的浮点数，控制循环状态的线性变换的神经元断开比例

• LSTM层–Keras长短期记忆模型

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)
参数：

units：输出维度
activation：激活函数，为预定义的激活函数名（参考激活函数）
recurrent_activation: 为循环步施加的激活函数（参考激活函数）
use_bias: 布尔值，是否使用偏置项
kernel_initializer：权值初始化方法，为预定义初始化方法名的字符串，或用于初始化权重的初始化器。参考initializers
recurrent_initializer：循环核的初始化方法，为预定义初始化方法名的字符串，或用于初始化权重的初始化器。参考initializers
bias_initializer：权值初始化方法，为预定义初始化方法名的字符串，或用于初始化权重的初始化器。参考initializers
kernel_regularizer：施加在权重上的正则项，为Regularizer对象
bias_regularizer：施加在偏置向量上的正则项，为Regularizer对象
recurrent_regularizer：施加在循环核上的正则项，为Regularizer对象
activity_regularizer：施加在输出上的正则项，为Regularizer对象
kernel_constraints：施加在权重上的约束项，为Constraints对象
recurrent_constraints：施加在循环核上的约束项，为Constraints对象
bias_constraints：施加在偏置上的约束项，为Constraints对象
dropout：0~1之间的浮点数，控制输入线性变换的神经元断开比例
recurrent_dropout：0~1之间的浮点数，控制循环状态的线性变换的神经元断开比例

---

目标函数objectives

目标函数，或称损失函数，是编译一个模型必须的两个参数之一：
model.compile(loss='mean_squared_error', optimizer='sgd')
可以通过传递预定义目标函数名字指定目标函数，也可以传递一个Theano/TensroFlow的符号函数作为目标函数，该函数对每个数据点应该只返回一个标量值，并以下列两个参数为参数：
y_true：真实的数据标签，Theano/TensorFlow张量
y_pred：预测值，与y_true相同shape的Theano/TensorFlow张量
可用的目标函数：
mean_squared_error或mse
mean_absolute_error或mae
mean_absolute_percentage_error或mape
mean_squared_logarithmic_error或msle
squared_hinge
hinge
categorical_hinge
binary_crossentropy（亦称作对数损失，logloss）
logcosh
categorical_crossentropy：亦称作多类的对数损失，注意使用该目标函数时，需要将标签转化为形如(nb_samples, nb_classes)的二值序列
sparse_categorical_crossentrop：如上，但接受稀疏标签。注意，使用该函数时仍然需要你的标签与输出值的维度相同，你可能需要在标签数据上增加一个维度：np.expand_dims(y,-1)
kullback_leibler_divergence:从预测值概率分布Q到真值概率分布P的信息增益,用以度量两个分布的差异.
poisson：即(predictions - targets * log(predictions))的均值
cosine_proximity：即预测值与真实标签的余弦距离平均值的相反数

优化器optimizers

from keras import optimizersmodel = Sequential()model.add(Dense(64, kernel_initializer='uniform', input_shape=(10,)))model.add(Activation('tanh'))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()之前初始化一个优化器对象，然后传入该函数（如上所示），也可以在调用model.compile()时传递一个预定义优化器名。在后者情形下，优化器的参数将使用默认值。
model.compile(loss='mean_squared_error', optimizer='sgd')

• SGD–随机梯度下降法，支持动量参数，支持学习衰减率，支持Nesterov动量
  keras.optimizers.SGD(lr=0.01, momentum=0.0, decay=0.0, nesterov=False)
  参数
  lr：大或等于0的浮点数，学习率
  momentum：大或等于0的浮点数，动量参数
  decay：大或等于0的浮点数，每次更新后的学习率衰减值
  nesterov：布尔值，确定是否使用Nesterov动量

• RMSprop
  keras.optimizers.RMSprop(lr=0.001, rho=0.9, epsilon=1e-06)

• Adagrad
  keras.optimizers.Adagrad(lr=0.01, epsilon=1e-06)

• Adadelta
  keras.optimizers.Adadelta(lr=1.0, rho=0.95, epsilon=1e-06)

• Adam
  keras.optimizers.Adam(lr=0.001, beta_1=0.9, beta_2=0.999, epsilon=1e-08)

• Adamax
  keras.optimizers.Adamax(lr=0.002, beta_1=0.9, beta_2=0.999, epsilon=1e-08)
  Adamax优化器来自于Adam的论文的Section7，该方法是基于无穷范数的Adam方法的变体。

激活函数Activations

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

from keras.layers import Activation, Densemodel.add(Dense(64))model.add(Activation('tanh'))

等价于

model.add(Dense(64, activation='tanh'))

预定义激活函数：
softmax：对输入数据的最后一维进行softmax，输入数据应形如(nb_samples, nb_timesteps, nb_dims)或(nb_samples,nb_dims)
elu
selu: 可伸缩的指数线性单元（Scaled Exponential Linear Unit），参考Self-Normalizing Neural Networks
softplus
softsign
relu
tanh
sigmoid
hard_sigmoid
linear

---

参考http://keras-cn.readthedocs.io/en/latest/