FAQ

如何保存keras模型

我们不推荐使用pickle或cPickle来保存Keras模型
1、你可以使用model.save(filepath)将Keras模型和权重保存在一个HDF5文件中，该文件将包含：

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

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

  1. from keras.models import load_model
  2. model.save('my_model.h5')  # creates a HDF5 file 'my_model.h5'
  3. del model  # deletes the existing model
  4. # returns a compiled model
  5. # identical to the previous one
  6. model = load_model('my_model.h5')

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

  1. # save as JSON
  2. json_string = model.to_json()
  3. # save as YAML
  4. yaml_string = model.to_yaml()
  6. # model reconstruction from JSON:
  7. from keras.models import model_from_json
  8. model = model_from_json(json_string)
  9. # model reconstruction from YAML
  10. model = model_from_yaml(yaml_string)

3、只保存模型权重
如果需要保存模型的权重，可通过下面的代码利用HDF5进行保存。注意，在使用前需要确保你已安装了HDF5和其Python库h5py.

  1. model.save_weights('my_model_weights.h5')
  2. # 如果你需要在代码中初始化一个完全相同的模型，请使用：
  3. model.load_weights('my_model_weights.h5')
  4. # 如果你需要加载权重到不同的网络结构（有些层一样）中，例如fine-tune或transfer-learning，你可以通过层名字来加载模型：
  5. model.load_weights('my_model_weights.h5', by_name=True)

如何在多张GPU卡上使用Keras

我们建议有多张GPU卡可用时，使用TnesorFlow后端。
有两种方法可以在多张GPU上运行一个模型：数据并行/设备并行
大多数情况下，你需要的很可能是“数据并行”
1、数据并行
数据并行将目标模型在多个设备上各复制一份，并使用每个设备上的复制品处理整个数据集的不同部分数据。Keras在keras.utils.multi_gpu_model中提供有内置函数，该函数可以产生任意模型的数据并行版本，最高支持在8片GPU上并行。 请参考utils中的multi_gpu_model文档。 下面是一个例子：

  1. from keras.utils import multi_gpu_model
  2. # Replicates `model` on 8 GPUs.
  3. # This assumes that your machine has 8 available GPUs.
  4. parallel_model = multi_gpu_model(model, gpus=8)
  5. parallel_model.compile(loss='categorical_crossentropy',
  6.                        optimizer='rmsprop')
  7. # This `fit` call will be distributed on 8 GPUs.
  8. # Since the batch size is 256, each GPU will process 32 samples.
  9. parallel_model.fit(x, y, epochs=20, batch_size=256)

如何获取中间层的输出？

1、一种简单的方法是创建一个新的Model，使得它的输出是你想要的那个输出

  1. from keras.models import Model
  3. model = ...  # create the original model
  5. layer_name = 'my_layer'
  6. intermediate_layer_model = Model(input=model.input,
  7.                                  output=model.get_layer(layer_name).output)
  8. intermediate_output = intermediate_layer_model.predict(data

2、此外，我们也可以建立一个Keras的函数来达到这一目的：

  1. from keras import backend as K
  3. # with a Sequential model
  4. get_3rd_layer_output = K.function([model.layers[0].input],
  5.                                   [model.layers[3].output])
  6. layer_output = get_3rd_layer_output([X])[0]

当然，我们也可以直接编写Theano和TensorFlow的函数来完成这件事。

注意，如果你的模型在训练和测试两种模式下不完全一致，例如你的模型中含有Dropout层，批规范化（BatchNormalization）层等组件，你需要在函数中传递一个 learning_phase 的标记，像这样：

  1. get_3rd_layer_output = K.function([model.layers[0].input, K.learning_phase()],
  2.                                   [model.layers[3].output])
  3. # output in test mode = 0
  4. layer_output = get_3rd_layer_output([X, 0])[0]
  6. # output in train mode = 1
  7. layer_output = get_3rd_layer_output([X, 1])[0]

如何在每个epoch后记录训练/测试的loss和正确率

model.fit在运行结束后返回一个History对象，其中含有的history属性包含了训练过程中损失函数的值以及其他度量指标。

  1. hist = model.fit(X, y, validation_split=0.2)
  2. print(hist.history)

当验证集的loss不再下降时，如何中断训练？

可以定义 EarlyStopping 来提前终止训练。

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

如何利用Keras处理超过机器内存的数据集？

示例：keras-cifar10-cnn
1、可以使用model.train_on_batch(X,y)和model.test_on_batch(X,y)
2、也可以编写一个每次产生一个batch样本的生成器函数，并调用model.fit_generator(data_generator, samples_per_epoch, nb_epoch)进行训练