keras文档快速问答（翻译自Keras FAQ: Frequently Asked Keras Questions）

本文主要介绍keras的一些常见问题，翻译自keras文档，官方文档在更新，可能会存在不同，具体内容可查看原文地址：https://keras.io/getting-started/faq/#how-can-i-obtain-the-output-of-an-intermediate-layer

应该引用keras吗？

• 如果keras在研究中给与你帮助，请在出版物中引用keras。BibTeX格式如下：

@misc{chollet2015keras,
  title={Keras},
  author={Chollet, Fran\c{c}ois and others},
  year={2015},
  publisher={GitHub},
  howpublished={\url{https://github.com/fchollet/keras}},
}

如何在GPU上运行keras？

• 如果运行后端为TensorFlow或者CNTK，当检测到GPU时，你的代码会自动使用GPU运行。
• 如果运行后端为Theano，可以使用以下方法：
  方法1：使用Theano标记。

THEANO_FLAGS=device=gpu,floatX=float32 python my_keras_script.py

根据你的设备识别’gpu’可能需要改变（比如‘gpu0’，‘gpu1’等）。
方法2：设置.theanorc文件。
方法3：在代码开端手动设置theano.config.device, theano.config.floatX，如下：

import theano
theano.config.device = 'gpu'
theano.config.floatX = 'float32'

“sample”“batch”“epoch”的含义？

• 下面是正确使用keras需要知道和理解的一些常规定义：
• Sample（样本）：数据集的一个元素。比如，在卷积网络中一个图片是一个sample；语音识别模型中一个音频是一个sample。
• Batch：N个sample的集合。batch中的样本是并行单独处理的，训练过程中，一个batch产生一次更新。一个batch比一个单独的输入更能近似输入数据的分布，batch的规模越大，近似度越高；然而，batch处理时间更长且只更新一次参数。比如，在评估或者预测的时候，建议batch的规模尽可能大（不超过电脑内存就行），可以提升评估或者预测速度。
• Epoch：一个截止，一般定义为：一次处理完整个数据集。把训练过程分为不同的阶段，有利于记录和周期评估；当使用evaluation_data 或者evaluation_split时，评估会在每次epoch之后进行。在keras中，在每次epoch之后，可以特别添加callbacks，比如学习率的改变、模型检查、模型保存等。

如何保存keras模型？

• 不建议使用 pickle 或者 cPickle保存keras模型。
• 可以使用model.save(filepath)以单独的HDF5文件保存keras模型，包含以下信息：
  模型的结构，允许重建模型；
  模型的权重；
  训练配置：损失，优化器等；
  优化器的状态，允许重新训练中断的进程。
• 可以使用keras.models.load_model(filepath)加载模型。load_model会使用保存的配置编译模型。
• Example：

from keras.models import load_model

model.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 one
model = load_model('my_model.h5')

• 如果只需要保存模型的结构，不需要训练配置和权重，可以这样做：

# save as JSON
json_string = model.to_json()

# save as YAML
yaml_string = model.to_yaml()

生成的JSON/YAML文件是人工可读的且能够手动编辑。利用这些数据可以建立新的模型：

# model reconstruction from JSON:
from keras.models import model_from_json
model = model_from_json(json_string)

# model reconstruction from YAML
from keras.models import model_from_yaml
model = model_from_yaml(yaml_string)

• 如果需要保存模型权重，可以使用HDF5文件（先安装HDF5和Python库h5py）：

model.save_weights('my_model_weights.h5')

• 可以应用具有相同结构的模型加载权重参数：

model.load_weights('my_model_weights.h5')

• 如果需要加载权重到一个不同结构的模型（有一些相同的层），比如fine-tuning或者迁移学习，可以通过 layer name加载权重：

model.load_weights('my_model_weights.h5', by_name=True)

举例：

"""
Assume original model looks like this:
    model = Sequential()
    model.add(Dense(2, input_dim=3, name='dense_1'))
    model.add(Dense(3, name='dense_2'))
    ...
    model.save_weights(fname)
"""

# new model
model = Sequential()
model.add(Dense(2, input_dim=3, name='dense_1'))  # will be loaded
model.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)

为什么训练损失比测试损失高？

• keras模型有两种模式：训练和测试。正则化方法比如DropOut和L1/L2权重正则化，在测试阶段是没有的。
• 而且，训练损失是训练数据每个batch的平均损失。因为模型一直在变化，第一个batch的损失一般比最后一个batch高；另一方面，测试损失是应用最后一个batch后的模型计算得到，产生的损失较小。

如何得到keras中间层的输出？

• 一个简单的方法是创建新模型，输出感兴趣的层：

from keras.models import Model

model = ...  # create the original model

layer_name = 'my_layer'
intermediate_layer_model = Model(inputs=model.input,
                                 outputs=model.get_layer(layer_name).output)
intermediate_output = intermediate_layer_model.predict(data)

• 另外一种选择，可以创建一个keras function函数，返回特定层的输出，比如：

from keras import backend as K

# with a Sequential model
get_3rd_layer_output = K.function([model.layers[0].input],
                                  [model.layers[3].output])
layer_output = get_3rd_layer_output([x])[0]

• 相似的，也可以创建一个Theano和TensorFlow function。
• 注意模型在训练和测试阶段有不同的表现（比如是否使用DropOut，BatchNormalization），需要在function中通过learning phase flag：

get_3rd_layer_output = K.function([model.layers[0].input, K.learning_phase()],[model.layers[3].output])

# output in test mode = 0
layer_output = get_3rd_layer_output([x, 0])[0]

# output in train mode = 1
layer_output = get_3rd_layer_output([x, 1])[0]

没有相应的内存载入数据如何使用keras？

• 使用批训练：model.train_on_batch(x, y)和model.test_on_batch(x, y).
• 此外，可以写一个生成器来产生训练数据的batches，使用以下方法：model.fit_generator(data_generator, steps_per_epoch, epochs).
• 批训练方法可以在例子中查看：CIFAR10 example.https://github.com/fchollet/keras/blob/master/examples/cifar10_cnn.py

当验证集损失不再下降的时候如何中段训练进程？

• 使用EarlyStopping callback:

from keras.callbacks import EarlyStopping
early_stopping = EarlyStopping(monitor='val_loss', patience=2)
model.fit(x, y, validation_split=0.2, callbacks=[early_stopping])

验证集validation split是如何计算的？

• 如果在model.fit中设置了validation_split，比如等于0.1，那么验证集数据使用的是数据集最后10%；如果设置为0.25，使用数据集最后25%，以此类推。注意在提取验证集之前数据并没有被打乱，因此验证集就是输入数据的最后x%的样本。
• 对于所有的迭代，有相同的验证集。

训练过程中数据是打乱的吗？

• 是的，如果shuffle 设置为True（默认值），训练集数据在每次迭代中被随机打乱。
• 验证集不会被打乱。

每次迭代如何记录训练/验证损失/正确率？

• model.fit会返回一个History，有属性值history，包含了一些列的损失及其他值。

hist = model.fit(x, y, validation_split=0.2)
print(hist.history)

如何冻结（freeze）keras层？

• 冻结某一层意味着从训练中将其移除，比如其权值不会再更新。这个方法在fine-tuning一个模型的时候很有用，或者对于文本输入使用fixed embeddings时。
• 通过trainable（布尔值）对特定层进行构造，使某一层不可被训练：

frozen_layer = Dense(32, trainable=False)

• 除此之外，可以在实例化之后设置trainable的属性值为True或者False，需要在修正trainable属性值之后编译模型。例如：

x = Input(shape=(32,))
layer = Dense(32)
layer.trainable = False
y = layer(x)

frozen_model = Model(x, y)
# in the model below, the weights of `layer` will not be updated during training
frozen_model.compile(optimizer='rmsprop', loss='mse')

layer.trainable = True
trainable_model = Model(x, y)
# with this model the weights of the layer will be updated during training
# (which will also affect the above model since it uses the same layer instance)
trainable_model.compile(optimizer='rmsprop', loss='mse')

frozen_model.fit(data, labels)  # this does NOT update the weights of `layer`
trainable_model.fit(data, labels)  # this updates the weights of `layer`

如何从序贯模型中移除其中一层？

• 在序贯模型中，可以通过.pop()移除最后一个添加的层：

model = Sequential()
model.add(Dense(32, activation='relu', input_dim=784))
model.add(Dense(32, activation='relu'))

print(len(model.layers))  # "2"

model.pop()
print(len(model.layers))  # "1"

在keras中如何使用预训练模型？

• 对于以下的图像分类模型，代码和预训练参数是可获取的：
  Xception；
  VGG16；
  VGG19；
  ResNet50；
  Inception v3；
• 它们可以通过keras.applications模块被载入：

from keras.applications.xception import Xception
from keras.applications.vgg16 import VGG16
from keras.applications.vgg19 import VGG19
from keras.applications.resnet50 import ResNet50
from keras.applications.inception_v3 import InceptionV3

model = VGG16(weights='imagenet', include_top=True)

• 对于一些简单的使用样例，可以参考Applications模块文档：https://keras.io/applications/
• 对于如何应用预训练模型进行特征提取或者fine-tuning，可以参考一下博客：https://blog.keras.io/building-powerful-image-classification-models-using-very-little-data.html
• VGG16模型是一些keras例子的基础：
  Style transfer：
  https://github.com/fchollet/keras/blob/master/examples/neural_style_transfer.py
  Feature visualization
  https://github.com/fchollet/keras/blob/master/examples/conv_filter_visualization.py
  Deep dream
  https://github.com/fchollet/keras/blob/master/examples/deep_dream.py

keras如何使用HDF5输入？

• 可以在keras.utils.io_utils使用HDF5Matrix类。
  https://keras.io/utils/#hdf5matrix
• 也可以直接使用HDF5数据集：

import h5py
with h5py.File('input/file.hdf5', 'r') as f:
    x_data = f['x_data']
    model.predict(x_data)