作者:Neel Kovelamudi,Francois Chollet
创建日期 2023/06/14
最后修改日期 2023/06/30
描述:保存、序列化和导出模型的完整指南。
Keras 模型包含多个组件
Keras API 将所有这些部分以统一的格式保存在一起,以 .keras
扩展名标记。这是一个 zip 归档文件,包含以下内容:
model.weights.h5
(用于整个模型),其中包含层及其权重的目录键。让我们看看它是如何工作的。
如果您只有 10 秒钟时间阅读本指南,以下是一些您需要了解的信息。
保存 Keras 模型
model = ... # Get model (Sequential, Functional Model, or Model subclass)
model.save('path/to/location.keras') # The file needs to end with the .keras extension
重新加载模型
model = keras.models.load_model('path/to/location.keras')
现在,让我们看看细节。
import numpy as np
import keras
from keras import ops
本节介绍如何将整个模型保存到单个文件中。该文件将包含:
compile()
)您可以使用 model.save()
或 keras.models.save_model()
(等效)保存模型。您可以使用 keras.models.load_model()
重新加载它。
Keras 3 中唯一支持的格式是“Keras v3”格式,它使用 .keras
扩展名。
示例
def get_model():
# Create a simple model.
inputs = keras.Input(shape=(32,))
outputs = keras.layers.Dense(1)(inputs)
model = keras.Model(inputs, outputs)
model.compile(optimizer=keras.optimizers.Adam(), loss="mean_squared_error")
return model
model = get_model()
# Train the model.
test_input = np.random.random((128, 32))
test_target = np.random.random((128, 1))
model.fit(test_input, test_target)
# Calling `save('my_model.keras')` creates a zip archive `my_model.keras`.
model.save("my_model.keras")
# It can be used to reconstruct the model identically.
reconstructed_model = keras.models.load_model("my_model.keras")
# Let's check:
np.testing.assert_allclose(
model.predict(test_input), reconstructed_model.predict(test_input)
)
4/4 ━━━━━━━━━━━━━━━━━━━━ 0s 8ms/step - loss: 0.4232
4/4 ━━━━━━━━━━━━━━━━━━━━ 0s 281us/step
4/4 ━━━━━━━━━━━━━━━━━━━━ 0s 373us/step
本节介绍在 Keras 保存和重新加载中处理自定义层、函数和模型的基本工作流程。
在保存包含自定义对象的模型(例如子类化的层)时,**必须**在对象类上定义 get_config()
方法。如果传递给自定义对象构造函数 (__init__()
方法) 的参数不是 Python 对象(任何不是基本类型,例如整数、字符串等的东西),那么**必须**还在 from_config()
类方法中显式地反序列化这些参数。
像这样
class CustomLayer(keras.layers.Layer):
def __init__(self, sublayer, **kwargs):
super().__init__(**kwargs)
self.sublayer = sublayer
def call(self, x):
return self.sublayer(x)
def get_config(self):
base_config = super().get_config()
config = {
"sublayer": keras.saving.serialize_keras_object(self.sublayer),
}
return {**base_config, **config}
@classmethod
def from_config(cls, config):
sublayer_config = config.pop("sublayer")
sublayer = keras.saving.deserialize_keras_object(sublayer_config)
return cls(sublayer, **config)
有关更多详细信息和示例,请参阅定义配置方法部分。
保存的 .keras
文件很轻量级,并且不会存储自定义对象的 Python 代码。因此,要重新加载模型,load_model
需要通过以下方法之一访问任何使用的自定义对象的定义:
以下是每个工作流程的示例
这是首选方法,因为自定义对象注册极大地简化了保存和加载代码。将 @keras.saving.register_keras_serializable
装饰器添加到自定义对象的类定义中,会在主列表中全局注册该对象,使 Keras 能够在加载模型时识别该对象。
让我们创建一个涉及自定义层和自定义激活函数的自定义模型来演示这一点。
示例
# Clear all previously registered custom objects
keras.saving.get_custom_objects().clear()
# Upon registration, you can optionally specify a package or a name.
# If left blank, the package defaults to `Custom` and the name defaults to
# the class name.
@keras.saving.register_keras_serializable(package="MyLayers")
class CustomLayer(keras.layers.Layer):
def __init__(self, factor):
super().__init__()
self.factor = factor
def call(self, x):
return x * self.factor
def get_config(self):
return {"factor": self.factor}
@keras.saving.register_keras_serializable(package="my_package", name="custom_fn")
def custom_fn(x):
return x**2
# Create the model.
def get_model():
inputs = keras.Input(shape=(4,))
mid = CustomLayer(0.5)(inputs)
outputs = keras.layers.Dense(1, activation=custom_fn)(mid)
model = keras.Model(inputs, outputs)
model.compile(optimizer="rmsprop", loss="mean_squared_error")
return model
# Train the model.
def train_model(model):
input = np.random.random((4, 4))
target = np.random.random((4, 1))
model.fit(input, target)
return model
test_input = np.random.random((4, 4))
test_target = np.random.random((4, 1))
model = get_model()
model = train_model(model)
model.save("custom_model.keras")
# Now, we can simply load without worrying about our custom objects.
reconstructed_model = keras.models.load_model("custom_model.keras")
# Let's check:
np.testing.assert_allclose(
model.predict(test_input), reconstructed_model.predict(test_input)
)
1/1 ━━━━━━━━━━━━━━━━━━━━ 0s 46ms/step - loss: 0.2571
1/1 ━━━━━━━━━━━━━━━━━━━━ 0s 11ms/step
1/1 ━━━━━━━━━━━━━━━━━━━━ 0s 12ms/step
load_model()
model = get_model()
model = train_model(model)
# Calling `save('my_model.keras')` creates a zip archive `my_model.keras`.
model.save("custom_model.keras")
# Upon loading, pass a dict containing the custom objects used in the
# `custom_objects` argument of `keras.models.load_model()`.
reconstructed_model = keras.models.load_model(
"custom_model.keras",
custom_objects={"CustomLayer": CustomLayer, "custom_fn": custom_fn},
)
# Let's check:
np.testing.assert_allclose(
model.predict(test_input), reconstructed_model.predict(test_input)
)
1/1 ━━━━━━━━━━━━━━━━━━━━ 0s 37ms/step - loss: 0.0535
1/1 ━━━━━━━━━━━━━━━━━━━━ 0s 12ms/step
1/1 ━━━━━━━━━━━━━━━━━━━━ 0s 12ms/step
自定义对象范围内的任何代码都将能够识别传递给范围参数的自定义对象。因此,在范围内加载模型将允许加载我们的自定义对象。
示例
model = get_model()
model = train_model(model)
model.save("custom_model.keras")
# Pass the custom objects dictionary to a custom object scope and place
# the `keras.models.load_model()` call within the scope.
custom_objects = {"CustomLayer": CustomLayer, "custom_fn": custom_fn}
with keras.saving.custom_object_scope(custom_objects):
reconstructed_model = keras.models.load_model("custom_model.keras")
# Let's check:
np.testing.assert_allclose(
model.predict(test_input), reconstructed_model.predict(test_input)
)
1/1 ━━━━━━━━━━━━━━━━━━━━ 0s 40ms/step - loss: 0.0868
1/1 ━━━━━━━━━━━━━━━━━━━━ 0s 11ms/step
1/1 ━━━━━━━━━━━━━━━━━━━━ 0s 11ms/step
本节介绍如何仅保存模型的配置,而不保存其状态。模型的配置(或架构)指定模型包含哪些层以及这些层如何连接。如果您拥有模型的配置,则可以使用新初始化的状态(没有权重或编译信息)创建模型。
以下序列化 API 可用:
keras.models.clone_model(model)
:创建模型的(随机初始化的)副本。get_config()
和 cls.from_config()
:分别检索层或模型的配置,并从其配置重新创建模型实例。keras.models.model_to_json()
和 keras.models.model_from_json()
:类似,但作为 JSON 字符串。keras.saving.serialize_keras_object()
:检索任何任意 Keras 对象的配置。keras.saving.deserialize_keras_object()
:从其配置重新创建对象实例。您可以通过 keras.models.clone_model()
对模型进行内存中克隆。这等效于获取配置,然后从其配置重新创建模型(因此它不会保留编译信息或层权重值)。
示例
new_model = keras.models.clone_model(model)
get_config()
和 from_config()
调用 model.get_config()
或 layer.get_config()
将分别返回一个包含模型或层配置的 Python 字典。您应该定义 get_config()
以包含模型或层的 __init__()
方法所需的参数。在加载时,from_config(config)
方法将使用这些参数调用 __init__()
以重建模型或层。
层示例
layer = keras.layers.Dense(3, activation="relu")
layer_config = layer.get_config()
print(layer_config)
{'name': 'dense_4', 'trainable': True, 'dtype': 'float32', 'units': 3, 'activation': 'relu', 'use_bias': True, 'kernel_initializer': {'module': 'keras.src.initializers.random_initializers', 'class_name': 'GlorotUniform', 'config': {'seed': None}, 'registered_name': 'GlorotUniform'}, 'bias_initializer': {'module': 'keras.src.initializers.constant_initializers', 'class_name': 'Zeros', 'config': {}, 'registered_name': 'Zeros'}, 'kernel_regularizer': None, 'bias_regularizer': None, 'kernel_constraint': None, 'bias_constraint': None}
现在让我们使用 from_config()
方法重建该层
new_layer = keras.layers.Dense.from_config(layer_config)
顺序模型示例
model = keras.Sequential([keras.Input((32,)), keras.layers.Dense(1)])
config = model.get_config()
new_model = keras.Sequential.from_config(config)
函数式模型示例
inputs = keras.Input((32,))
outputs = keras.layers.Dense(1)(inputs)
model = keras.Model(inputs, outputs)
config = model.get_config()
new_model = keras.Model.from_config(config)
to_json()
和 keras.models.model_from_json()
这类似于 get_config
/from_config
,除了它将模型转换为 JSON 字符串,然后可以在没有原始模型类的情况下加载它。它也特定于模型,它不适用于层。
示例
model = keras.Sequential([keras.Input((32,)), keras.layers.Dense(1)])
json_config = model.to_json()
new_model = keras.models.model_from_json(json_config)
keras.saving.serialize_keras_object()
和 keras.saving.deserialize_keras_object()
API 是通用 API,可用于序列化或反序列化任何 Keras 对象和任何自定义对象。它是保存模型架构的基础,并且位于 keras 中所有 serialize()
/deserialize()
调用的背后。
示例:
my_reg = keras.regularizers.L1(0.005)
config = keras.saving.serialize_keras_object(my_reg)
print(config)
{'module': 'keras.src.regularizers.regularizers', 'class_name': 'L1', 'config': {'l1': 0.004999999888241291}, 'registered_name': 'L1'}
请注意包含正确重建所需的所有信息的序列化格式:
module
包含对象来自的 Keras 模块或其他识别模块的名称。class_name
包含对象类的名称。config
包含重建对象所需的所有信息registered_name
。请参阅此处。现在我们可以重建正则化器了。
new_reg = keras.saving.deserialize_keras_object(config)
您可以选择仅保存和加载模型的权重。如果以下情况,这将很有用:
可以使用 get_weights()
和 set_weights()
在不同的对象之间复制权重
keras.layers.Layer.get_weights()
:返回权重值的 NumPy 数组列表。keras.layers.Layer.set_weights(weights)
:将模型权重设置为提供的权重值(作为 NumPy 数组)。示例
在内存中将权重从一层传输到另一层
def create_layer():
layer = keras.layers.Dense(64, activation="relu", name="dense_2")
layer.build((None, 784))
return layer
layer_1 = create_layer()
layer_2 = create_layer()
# Copy weights from layer 1 to layer 2
layer_2.set_weights(layer_1.get_weights())
在内存中将权重从一个模型传输到具有兼容架构的另一个模型
# Create a simple functional model
inputs = keras.Input(shape=(784,), name="digits")
x = keras.layers.Dense(64, activation="relu", name="dense_1")(inputs)
x = keras.layers.Dense(64, activation="relu", name="dense_2")(x)
outputs = keras.layers.Dense(10, name="predictions")(x)
functional_model = keras.Model(inputs=inputs, outputs=outputs, name="3_layer_mlp")
# Define a subclassed model with the same architecture
class SubclassedModel(keras.Model):
def __init__(self, output_dim, name=None):
super().__init__(name=name)
self.output_dim = output_dim
self.dense_1 = keras.layers.Dense(64, activation="relu", name="dense_1")
self.dense_2 = keras.layers.Dense(64, activation="relu", name="dense_2")
self.dense_3 = keras.layers.Dense(output_dim, name="predictions")
def call(self, inputs):
x = self.dense_1(inputs)
x = self.dense_2(x)
x = self.dense_3(x)
return x
def get_config(self):
return {"output_dim": self.output_dim, "name": self.name}
subclassed_model = SubclassedModel(10)
# Call the subclassed model once to create the weights.
subclassed_model(np.ones((1, 784)))
# Copy weights from functional_model to subclassed_model.
subclassed_model.set_weights(functional_model.get_weights())
assert len(functional_model.weights) == len(subclassed_model.weights)
for a, b in zip(functional_model.weights, subclassed_model.weights):
np.testing.assert_allclose(a.numpy(), b.numpy())
无状态层的情况
因为无状态层不会更改权重的顺序或数量,所以即使存在额外/缺少的无状态层,模型也可以具有兼容的架构。
inputs = keras.Input(shape=(784,), name="digits")
x = keras.layers.Dense(64, activation="relu", name="dense_1")(inputs)
x = keras.layers.Dense(64, activation="relu", name="dense_2")(x)
outputs = keras.layers.Dense(10, name="predictions")(x)
functional_model = keras.Model(inputs=inputs, outputs=outputs, name="3_layer_mlp")
inputs = keras.Input(shape=(784,), name="digits")
x = keras.layers.Dense(64, activation="relu", name="dense_1")(inputs)
x = keras.layers.Dense(64, activation="relu", name="dense_2")(x)
# Add a dropout layer, which does not contain any weights.
x = keras.layers.Dropout(0.5)(x)
outputs = keras.layers.Dense(10, name="predictions")(x)
functional_model_with_dropout = keras.Model(
inputs=inputs, outputs=outputs, name="3_layer_mlp"
)
functional_model_with_dropout.set_weights(functional_model.get_weights())
可以通过调用 model.save_weights(filepath)
将权重保存到磁盘。文件名应以 .weights.h5
结尾。
示例
# Runnable example
sequential_model = keras.Sequential(
[
keras.Input(shape=(784,), name="digits"),
keras.layers.Dense(64, activation="relu", name="dense_1"),
keras.layers.Dense(64, activation="relu", name="dense_2"),
keras.layers.Dense(10, name="predictions"),
]
)
sequential_model.save_weights("my_model.weights.h5")
sequential_model.load_weights("my_model.weights.h5")
请注意,更改 layer.trainable
可能会导致模型包含嵌套层时 layer.weights
顺序不同。
class NestedDenseLayer(keras.layers.Layer):
def __init__(self, units, name=None):
super().__init__(name=name)
self.dense_1 = keras.layers.Dense(units, name="dense_1")
self.dense_2 = keras.layers.Dense(units, name="dense_2")
def call(self, inputs):
return self.dense_2(self.dense_1(inputs))
nested_model = keras.Sequential([keras.Input((784,)), NestedDenseLayer(10, "nested")])
variable_names = [v.name for v in nested_model.weights]
print("variables: {}".format(variable_names))
print("\nChanging trainable status of one of the nested layers...")
nested_model.get_layer("nested").dense_1.trainable = False
variable_names_2 = [v.name for v in nested_model.weights]
print("\nvariables: {}".format(variable_names_2))
print("variable ordering changed:", variable_names != variable_names_2)
variables: ['kernel', 'bias', 'kernel', 'bias']
Changing trainable status of one of the nested layers...
variables: ['kernel', 'bias', 'kernel', 'bias']
variable ordering changed: False
从权重文件加载预训练权重时,建议将权重加载到原始检查点模型中,然后将所需的权重/层提取到新模型中。
示例
def create_functional_model():
inputs = keras.Input(shape=(784,), name="digits")
x = keras.layers.Dense(64, activation="relu", name="dense_1")(inputs)
x = keras.layers.Dense(64, activation="relu", name="dense_2")(x)
outputs = keras.layers.Dense(10, name="predictions")(x)
return keras.Model(inputs=inputs, outputs=outputs, name="3_layer_mlp")
functional_model = create_functional_model()
functional_model.save_weights("pretrained.weights.h5")
# In a separate program:
pretrained_model = create_functional_model()
pretrained_model.load_weights("pretrained.weights.h5")
# Create a new model by extracting layers from the original model:
extracted_layers = pretrained_model.layers[:-1]
extracted_layers.append(keras.layers.Dense(5, name="dense_3"))
model = keras.Sequential(extracted_layers)
model.summary()
Model: "sequential_4"
┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━┓ ┃ Layer (type) ┃ Output Shape ┃ Param # ┃ ┡━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━┩ │ dense_1 (Dense) │ (None, 64) │ 50,240 │ ├─────────────────────────────────┼───────────────────────────┼────────────┤ │ dense_2 (Dense) │ (None, 64) │ 4,160 │ ├─────────────────────────────────┼───────────────────────────┼────────────┤ │ dense_3 (Dense) │ (None, 5) │ 325 │ └─────────────────────────────────┴───────────────────────────┴────────────┘
Total params: 54,725 (213.77 KB)
Trainable params: 54,725 (213.77 KB)
Non-trainable params: 0 (0.00 B)
规格
get_config()
应返回一个 JSON 可序列化的字典,以便与 Keras 架构和模型保存 API 兼容。from_config(config)
(一个 classmethod
)应返回一个从配置创建的新层或模型对象。默认实现返回 cls(**config)
。注意:如果您的所有构造函数参数都已可序列化,例如字符串和整数,或者非自定义 Keras 对象,则无需覆盖 from_config
。但是,对于更复杂的对象(例如传递给 __init__
的层或模型),必须在 __init__
本身或覆盖 from_config()
方法中显式处理反序列化。
示例
@keras.saving.register_keras_serializable(package="MyLayers", name="KernelMult")
class MyDense(keras.layers.Layer):
def __init__(
self,
units,
*,
kernel_regularizer=None,
kernel_initializer=None,
nested_model=None,
**kwargs
):
super().__init__(**kwargs)
self.hidden_units = units
self.kernel_regularizer = kernel_regularizer
self.kernel_initializer = kernel_initializer
self.nested_model = nested_model
def get_config(self):
config = super().get_config()
# Update the config with the custom layer's parameters
config.update(
{
"units": self.hidden_units,
"kernel_regularizer": self.kernel_regularizer,
"kernel_initializer": self.kernel_initializer,
"nested_model": self.nested_model,
}
)
return config
def build(self, input_shape):
input_units = input_shape[-1]
self.kernel = self.add_weight(
name="kernel",
shape=(input_units, self.hidden_units),
regularizer=self.kernel_regularizer,
initializer=self.kernel_initializer,
)
def call(self, inputs):
return ops.matmul(inputs, self.kernel)
layer = MyDense(units=16, kernel_regularizer="l1", kernel_initializer="ones")
layer3 = MyDense(units=64, nested_model=layer)
config = keras.layers.serialize(layer3)
print(config)
new_layer = keras.layers.deserialize(config)
print(new_layer)
{'module': None, 'class_name': 'MyDense', 'config': {'name': 'my_dense_1', 'trainable': True, 'dtype': 'float32', 'units': 64, 'kernel_regularizer': None, 'kernel_initializer': None, 'nested_model': {'module': None, 'class_name': 'MyDense', 'config': {'name': 'my_dense', 'trainable': True, 'dtype': 'float32', 'units': 16, 'kernel_regularizer': 'l1', 'kernel_initializer': 'ones', 'nested_model': None}, 'registered_name': 'MyLayers>KernelMult'}}, 'registered_name': 'MyLayers>KernelMult'}
<MyDense name=my_dense_1, built=False>
请注意,对于 MyDense
,上面无需覆盖 from_config
,因为 hidden_units
、kernel_initializer
和 kernel_regularizer
分别是整数、字符串和内置 Keras 对象。这意味着 cls(**config)
的默认 from_config
实现将按预期工作。
对于更复杂的对象,例如传递给__init__
的层和模型,您必须显式地反序列化这些对象。让我们看一个需要覆盖from_config
的模型示例。
@keras.saving.register_keras_serializable(package="ComplexModels")
class CustomModel(keras.layers.Layer):
def __init__(self, first_layer, second_layer=None, **kwargs):
super().__init__(**kwargs)
self.first_layer = first_layer
if second_layer is not None:
self.second_layer = second_layer
else:
self.second_layer = keras.layers.Dense(8)
def get_config(self):
config = super().get_config()
config.update(
{
"first_layer": self.first_layer,
"second_layer": self.second_layer,
}
)
return config
@classmethod
def from_config(cls, config):
# Note that you can also use [`keras.saving.deserialize_keras_object`](/api/models/model_saving_apis/serialization_utils#deserializekerasobject-function) here
config["first_layer"] = keras.layers.deserialize(config["first_layer"])
config["second_layer"] = keras.layers.deserialize(config["second_layer"])
return cls(**config)
def call(self, inputs):
return self.first_layer(self.second_layer(inputs))
# Let's make our first layer the custom layer from the previous example (MyDense)
inputs = keras.Input((32,))
outputs = CustomModel(first_layer=layer)(inputs)
model = keras.Model(inputs, outputs)
config = model.get_config()
new_model = keras.Model.from_config(config)
序列化格式为通过@keras.saving.register_keras_serializable
注册的自定义对象提供了一个特殊的键。此registered_name
键允许在加载/反序列化时轻松检索,同时还允许用户添加自定义命名。
让我们看看上面定义的自定义层MyDense
序列化的配置。
示例:
layer = MyDense(
units=16,
kernel_regularizer=keras.regularizers.L1L2(l1=1e-5, l2=1e-4),
kernel_initializer="ones",
)
config = keras.layers.serialize(layer)
print(config)
{'module': None, 'class_name': 'MyDense', 'config': {'name': 'my_dense_2', 'trainable': True, 'dtype': 'float32', 'units': 16, 'kernel_regularizer': {'module': 'keras.src.regularizers.regularizers', 'class_name': 'L1L2', 'config': {'l1': 1e-05, 'l2': 0.0001}, 'registered_name': 'L1L2'}, 'kernel_initializer': 'ones', 'nested_model': None}, 'registered_name': 'MyLayers>KernelMult'}
如所示,registered_name
键包含Keras主列表的查找信息,包括包MyLayers
和我们在@keras.saving.register_keras_serializable
装饰器中提供的自定义名称KernelMult
。请再次查看自定义类定义/注册此处。
请注意,class_name
键包含类的原始名称,允许在from_config
中正确地重新初始化。
此外,请注意module
键为None
,因为这是一个自定义对象。