加载训练好的 Keras 模型并继续训练
Loading a trained Keras model and continue training
我想知道是否可以保存部分训练的 Keras 模型并在再次加载模型后继续训练。
这样做的原因是我以后会有更多的训练数据，我不想再重新训练整个模型。
我正在使用的功能是：
#Partly train model
model.fit(first_training, first_classes, batch_size=32, nb_epoch=20)
#Save partly trained model
model.save('partly_trained.h5')
#Load partly trained model
from keras.models import load_model
model = load_model('partly_trained.h5')
#Continue training
model.fit(second_training, second_classes, batch_size=32, nb_epoch=20)
编辑 1：添加了完整的示例
第一个数据集经过 10 个时期后，最后一个时期的损失将为 0.0748，精度为 0.9863。
保存、删除和重新加载模型后，在第二个数据集上训练的模型的损失和准确率分别为 0.1711 和 0.9504。
这是新的训练数据还是完全重新训练的模型造成的？
"""
Model by: http://machinelearningmastery.com/
"""
# load (downloaded if needed) the MNIST dataset
import numpy
from keras.datasets import mnist
from keras.models import Sequential
from keras.layers import Dense
from keras.utils import np_utils
from keras.models import load_model
numpy.random.seed(7)
def baseline_model():
model = Sequential()
model.add(Dense(num_pixels, input_dim=num_pixels, init='normal', activation='relu'))
model.add(Dense(num_classes, init='normal', activation='softmax'))
model.compile(loss='categorical_crossentropy', optimizer='adam', metrics=['accuracy'])
return model
if __name__ == '__main__':
# load data
(X_train, y_train), (X_test, y_test) = mnist.load_data()
# flatten 28*28 images to a 784 vector for each image
num_pixels = X_train.shape[1] * X_train.shape[2]
X_train = X_train.reshape(X_train.shape[0], num_pixels).astype('float32')
X_test = X_test.reshape(X_test.shape[0], num_pixels).astype('float32')
# normalize inputs from 0-255 to 0-1
X_train = X_train / 255
X_test = X_test / 255
# one hot encode outputs
y_train = np_utils.to_categorical(y_train)
y_test = np_utils.to_categorical(y_test)
num_classes = y_test.shape[1]
# build the model
model = baseline_model()
#Partly train model
dataset1_x = X_train[:3000]
dataset1_y = y_train[:3000]
model.fit(dataset1_x, dataset1_y, nb_epoch=10, batch_size=200, verbose=2)
# Final evaluation of the model
scores = model.evaluate(X_test, y_test, verbose=0)
print("Baseline Error: %.2f%%" % (100-scores[1]*100))
#Save partly trained model
model.save('partly_trained.h5')
del model
#Reload model
model = load_model('partly_trained.h5')
#Continue training
dataset2_x = X_train[3000:]
dataset2_y = y_train[3000:]
model.fit(dataset2_x, dataset2_y, nb_epoch=10, batch_size=200, verbose=2)
scores = model.evaluate(X_test, y_test, verbose=0)
print("Baseline Error: %.2f%%" % (100-scores[1]*100))
编辑 2：tensorflow.keras 备注
对于 tensorflow.keras 将参数 nb_epochs 更改为模型拟合中的时期。导入和基本模型函数是：
import numpy
from tensorflow.keras.datasets import mnist
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Dense
from tensorflow.keras.utils import to_categorical
from tensorflow.keras.models import load_model
numpy.random.seed(7)
def baseline_model():
model = Sequential()
model.add(Dense(num_pixels, input_dim=num_pixels, activation='relu'))
model.add(Dense(num_classes, activation='softmax'))
model.compile(loss='categorical_crossentropy', optimizer='adam', metrics=['accuracy'])
return model
实际上 - model.save 会保存您的案例中重新开始训练所需的所有信息。唯一可能被重新加载模型破坏的是你的优化器状态。要检查 - 尝试 save 并重新加载模型并在训练数据上对其进行训练。
请注意，Keras 有时会在加载模型时出现问题，如 here 中所示。
这可能解释了您不是从相同的训练准确度开始的情况。
问题可能是您使用了不同的优化器 - 或者您的优化器使用了不同的参数。我刚刚使用自定义预训练模型遇到了同样的问题，使用
reduce_lr = ReduceLROnPlateau(monitor='loss', factor=lr_reduction_factor,
patience=patience, min_lr=min_lr, verbose=1)
对于预训练模型，原始学习率从 0.0003 开始，在预训练期间降低到 min_learning 率，即 0.000003
我刚刚将该行复制到使用预训练模型的脚本中，但准确度非常差。直到我注意到预训练模型的最后一个学习率是最小学习率，即 0.000003。如果我从那个学习率开始，我得到的准确度与预训练模型的输出完全相同——这是有道理的，因为从比预训练模型中使用的最后一个学习率大 100 倍的学习率开始模型将导致 GD 的巨大超调，从而导致准确度大幅下降。
以上都有帮助，您必须在保存模型和权重时从与 LR 相同的学习率（）恢复。直接在优化器上设置它。
请注意，不能保证从那里改进，因为模型可能已达到局部最小值，这可能是全局的。没有必要恢复模型以搜索另一个局部最小值，除非您打算以受控方式提高学习率并将模型推到不远处可能更好的最小值。
您可能也遇到了概念漂移，请参阅Should you retrain a model when new observations are available. There's also the concept of catastrophic forgetting which a bunch of academic papers discuss. Here's one with MNIST Empirical investigation of catastrophic forgetting
以上大部分回答都涵盖了要点。如果你使用的是最近的 Tensorflow（TF2.1 或以上），那么下面的例子会对你有所帮助。模型部分代码来自Tensorflow官网
import tensorflow as tf
from tensorflow import keras
mnist = tf.keras.datasets.mnist
(x_train, y_train),(x_test, y_test) = mnist.load_data()
x_train, x_test = x_train / 255.0, x_test / 255.0
def create_model():
model = tf.keras.models.Sequential([
tf.keras.layers.Flatten(input_shape=(28, 28)),
tf.keras.layers.Dense(512, activation=tf.nn.relu),
tf.keras.layers.Dropout(0.2),
tf.keras.layers.Dense(10, activation=tf.nn.softmax)
])
model.compile(optimizer='adam', loss='sparse_categorical_crossentropy',metrics=['accuracy'])
return model
# Create a basic model instance
model=create_model()
model.fit(x_train, y_train, epochs = 10, validation_data = (x_test,y_test),verbose=1)
请将模型保存为*.tf格式。根据我的经验，如果您定义了任何 custom_loss，*.h5 格式将不会保存优化器状态，因此如果您想从我们离开的地方重新训练模型，则不会达到您的目的。
# saving the model in tensorflow format
model.save('./MyModel_tf',save_format='tf')
# loading the saved model
loaded_model = tf.keras.models.load_model('./MyModel_tf')
# retraining the model
loaded_model.fit(x_train, y_train, epochs = 10, validation_data = (x_test,y_test),verbose=1)
这种方法将在我们保存模型之前离开的地方重新开始训练。正如其他人所提到的，如果你想保存最佳模型的权重或者你想在每个时期保存模型的权重，你需要使用带有 save_weights_only=True、save_freq='epoch' 等选项的 keras 回调函数 (ModelCheckpoint)，和 save_best_only.
如果您使用的是 TF2，请使用新的 saved_model 方法（格式 pb）。更多信息可用 here and here。
model.fit(x=X_train, y=y_train, epochs=10,callbacks=[model_callback])#your first training
tf.saved_model.save(model, save_to_dir_path) #save the model
del model #to delete the model
model = tf.keras.models.load_model(save_to_dir_path)
model.fit(x=X_train, y=y_train, epochs=10,callbacks=[model_callback])#your second training
我想知道是否可以保存部分训练的 Keras 模型并在再次加载模型后继续训练。
这样做的原因是我以后会有更多的训练数据，我不想再重新训练整个模型。
我正在使用的功能是：
#Partly train model
model.fit(first_training, first_classes, batch_size=32, nb_epoch=20)
#Save partly trained model
model.save('partly_trained.h5')
#Load partly trained model
from keras.models import load_model
model = load_model('partly_trained.h5')
#Continue training
model.fit(second_training, second_classes, batch_size=32, nb_epoch=20)
编辑 1：添加了完整的示例
第一个数据集经过 10 个时期后，最后一个时期的损失将为 0.0748，精度为 0.9863。
保存、删除和重新加载模型后，在第二个数据集上训练的模型的损失和准确率分别为 0.1711 和 0.9504。
这是新的训练数据还是完全重新训练的模型造成的？
"""
Model by: http://machinelearningmastery.com/
"""
# load (downloaded if needed) the MNIST dataset
import numpy
from keras.datasets import mnist
from keras.models import Sequential
from keras.layers import Dense
from keras.utils import np_utils
from keras.models import load_model
numpy.random.seed(7)
def baseline_model():
model = Sequential()
model.add(Dense(num_pixels, input_dim=num_pixels, init='normal', activation='relu'))
model.add(Dense(num_classes, init='normal', activation='softmax'))
model.compile(loss='categorical_crossentropy', optimizer='adam', metrics=['accuracy'])
return model
if __name__ == '__main__':
# load data
(X_train, y_train), (X_test, y_test) = mnist.load_data()
# flatten 28*28 images to a 784 vector for each image
num_pixels = X_train.shape[1] * X_train.shape[2]
X_train = X_train.reshape(X_train.shape[0], num_pixels).astype('float32')
X_test = X_test.reshape(X_test.shape[0], num_pixels).astype('float32')
# normalize inputs from 0-255 to 0-1
X_train = X_train / 255
X_test = X_test / 255
# one hot encode outputs
y_train = np_utils.to_categorical(y_train)
y_test = np_utils.to_categorical(y_test)
num_classes = y_test.shape[1]
# build the model
model = baseline_model()
#Partly train model
dataset1_x = X_train[:3000]
dataset1_y = y_train[:3000]
model.fit(dataset1_x, dataset1_y, nb_epoch=10, batch_size=200, verbose=2)
# Final evaluation of the model
scores = model.evaluate(X_test, y_test, verbose=0)
print("Baseline Error: %.2f%%" % (100-scores[1]*100))
#Save partly trained model
model.save('partly_trained.h5')
del model
#Reload model
model = load_model('partly_trained.h5')
#Continue training
dataset2_x = X_train[3000:]
dataset2_y = y_train[3000:]
model.fit(dataset2_x, dataset2_y, nb_epoch=10, batch_size=200, verbose=2)
scores = model.evaluate(X_test, y_test, verbose=0)
print("Baseline Error: %.2f%%" % (100-scores[1]*100))
编辑 2：tensorflow.keras 备注
对于 tensorflow.keras 将参数 nb_epochs 更改为模型拟合中的时期。导入和基本模型函数是：
import numpy
from tensorflow.keras.datasets import mnist
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Dense
from tensorflow.keras.utils import to_categorical
from tensorflow.keras.models import load_model
numpy.random.seed(7)
def baseline_model():
model = Sequential()
model.add(Dense(num_pixels, input_dim=num_pixels, activation='relu'))
model.add(Dense(num_classes, activation='softmax'))
model.compile(loss='categorical_crossentropy', optimizer='adam', metrics=['accuracy'])
return model
实际上 - model.save 会保存您的案例中重新开始训练所需的所有信息。唯一可能被重新加载模型破坏的是你的优化器状态。要检查 - 尝试 save 并重新加载模型并在训练数据上对其进行训练。
请注意，Keras 有时会在加载模型时出现问题，如 here 中所示。 这可能解释了您不是从相同的训练准确度开始的情况。
问题可能是您使用了不同的优化器 - 或者您的优化器使用了不同的参数。我刚刚使用自定义预训练模型遇到了同样的问题，使用
reduce_lr = ReduceLROnPlateau(monitor='loss', factor=lr_reduction_factor,
patience=patience, min_lr=min_lr, verbose=1)
对于预训练模型，原始学习率从 0.0003 开始，在预训练期间降低到 min_learning 率，即 0.000003
我刚刚将该行复制到使用预训练模型的脚本中，但准确度非常差。直到我注意到预训练模型的最后一个学习率是最小学习率，即 0.000003。如果我从那个学习率开始，我得到的准确度与预训练模型的输出完全相同——这是有道理的，因为从比预训练模型中使用的最后一个学习率大 100 倍的学习率开始模型将导致 GD 的巨大超调，从而导致准确度大幅下降。
以上都有帮助，您必须在保存模型和权重时从与 LR 相同的学习率（）恢复。直接在优化器上设置它。
请注意，不能保证从那里改进，因为模型可能已达到局部最小值，这可能是全局的。没有必要恢复模型以搜索另一个局部最小值，除非您打算以受控方式提高学习率并将模型推到不远处可能更好的最小值。
您可能也遇到了概念漂移，请参阅Should you retrain a model when new observations are available. There's also the concept of catastrophic forgetting which a bunch of academic papers discuss. Here's one with MNIST Empirical investigation of catastrophic forgetting
以上大部分回答都涵盖了要点。如果你使用的是最近的 Tensorflow（TF2.1 或以上），那么下面的例子会对你有所帮助。模型部分代码来自Tensorflow官网
import tensorflow as tf
from tensorflow import keras
mnist = tf.keras.datasets.mnist
(x_train, y_train),(x_test, y_test) = mnist.load_data()
x_train, x_test = x_train / 255.0, x_test / 255.0
def create_model():
model = tf.keras.models.Sequential([
tf.keras.layers.Flatten(input_shape=(28, 28)),
tf.keras.layers.Dense(512, activation=tf.nn.relu),
tf.keras.layers.Dropout(0.2),
tf.keras.layers.Dense(10, activation=tf.nn.softmax)
])
model.compile(optimizer='adam', loss='sparse_categorical_crossentropy',metrics=['accuracy'])
return model
# Create a basic model instance
model=create_model()
model.fit(x_train, y_train, epochs = 10, validation_data = (x_test,y_test),verbose=1)
请将模型保存为*.tf格式。根据我的经验，如果您定义了任何 custom_loss，*.h5 格式将不会保存优化器状态，因此如果您想从我们离开的地方重新训练模型，则不会达到您的目的。
# saving the model in tensorflow format
model.save('./MyModel_tf',save_format='tf')
# loading the saved model
loaded_model = tf.keras.models.load_model('./MyModel_tf')
# retraining the model
loaded_model.fit(x_train, y_train, epochs = 10, validation_data = (x_test,y_test),verbose=1)
这种方法将在我们保存模型之前离开的地方重新开始训练。正如其他人所提到的，如果你想保存最佳模型的权重或者你想在每个时期保存模型的权重，你需要使用带有 save_weights_only=True、save_freq='epoch' 等选项的 keras 回调函数 (ModelCheckpoint)，和 save_best_only.
如果您使用的是 TF2，请使用新的 saved_model 方法（格式 pb）。更多信息可用 here and here。
model.fit(x=X_train, y=y_train, epochs=10,callbacks=[model_callback])#your first training
tf.saved_model.save(model, save_to_dir_path) #save the model
del model #to delete the model
model = tf.keras.models.load_model(save_to_dir_path)
model.fit(x=X_train, y=y_train, epochs=10,callbacks=[model_callback])#your second training