医药类网站前置审批,网站开发所需要的知识,python安装wordpress,杭州网站建设慕枫目录
介绍
如何保存和加载模型
保存一个Keras模型
装回模型
设置
保存
例子#xff1a;
自定义对象
向 load_model() 传递自定义对象
使用自定义对象范围
模型序列化
APIs
内存模型克隆
任意对象序列化和反序列化
保存模型权重
内存中的权重传递接口
无状态层…目录
介绍
如何保存和加载模型
保存一个Keras模型
装回模型
设置
保存
例子
自定义对象
向 load_model() 传递自定义对象
使用自定义对象范围
模型序列化
APIs
内存模型克隆
任意对象序列化和反序列化
保存模型权重
内存中的权重传递接口
无状态层的情况
保存权重到存储介质与加载回权重的接口
迁移学习示例
处理自定义对象
定义配置方法
如何序列化自定义对象 政安晨的个人主页政安晨 欢迎 点赞✍评论⭐收藏 收录专栏: TensorFlow与Keras机器学习实战 希望政安晨的博客能够对您有所裨益如有不足之处欢迎在评论区提出指正 这篇文章是保存、序列化和导出模型的完整指南。
介绍 Keras 模型由多个组件组成 架构或配置指定模型包含哪些层以及它们如何连接。 一组权重值模型状态。 一个优化器通过编译模型定义。 一组损失和度量通过编译模型定义。 Keras API 将所有这些部分保存为统一格式以 .keras 扩展名标记。
这是一个由以下内容组成的压缩包 基于 JSON 的配置文件 (config.json)模型、层和其他可跟踪配置的记录。基于 H5 的状态文件如 model.weights.h5用于整个模型其中包含层及其权重的目录键。JSON 格式的元数据文件存储当前 Keras 版本等信息。 让我们来看看它是如何工作的
如何保存和加载模型
如果您只有 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
保存
本文将把整个模型保存到一个文件中。文件将包括 模型的架构/配置 模型的权重值在训练过程中学到的权重值 模型的编译信息如果调用了编译() 优化器及其状态如果有的话这样就可以在训练结束后重新开始训练 应用程序接口您可以使用 model.save() 或 keras.models.save_model()两者等效保存模型。您可以使用 keras.models.load_model() 加载模型。
Keras 3 中唯一支持的格式是使用 .keras 扩展名的 Keras v3 格式。
例子
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(optimizerkeras.optimizers.Adam(), lossmean_squared_error)return modelmodel 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)# Lets check:
np.testing.assert_allclose(model.predict(test_input), reconstructed_model.predict(test_input)
)
演绎结果 自定义对象
本文介绍在 Keras 保存和重新加载中处理自定义层、函数和模型的基本工作流程。 保存包含自定义对象如子类层的模型时必须在对象类上定义 get_config() 方法。如果传给自定义对象的构造函数__init__() 方法的参数不是 Python 对象除 ints、字符串等基本类型外的任何其他类型则还必须在 from_config() 类方法中显式地反序列化这些参数。 就像这样
class CustomLayer(keras.layers.Layer):def __init__(self, sublayer, **kwargs):super().__init__(**kwargs)self.sublayer layerdef 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}classmethoddef 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 需要通过以下方法之一访问任何自定义对象的定义 1. 注册自定义对象首选2. 加载时直接传递自定义对象或3. 使用自定义对象作用域 下面是每个工作流程的示例
注册自定义对象首选 这是首选方法因为自定义对象注册大大简化了保存和加载代码。在自定义对象的类定义中添加 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(packageMyLayers)
class CustomLayer(keras.layers.Layer):def __init__(self, factor):super().__init__()self.factor factordef call(self, x):return x * self.factordef get_config(self):return {factor: self.factor}keras.saving.register_keras_serializable(packagemy_package, namecustom_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, activationcustom_fn)(mid)model keras.Model(inputs, outputs)model.compile(optimizerrmsprop, lossmean_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 modeltest_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)# Lets check:
np.testing.assert_allclose(model.predict(test_input), reconstructed_model.predict(test_input)
) 向 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},
)# Lets check:
np.testing.assert_allclose(model.predict(test_input), reconstructed_model.predict(test_input)
) 使用自定义对象范围
自定义对象作用域中的任何代码都能识别传递给作用域参数的自定义对象。因此在作用域中加载模型将允许加载我们的自定义对象。
例子
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)# Lets check:
np.testing.assert_allclose(model.predict(test_input), reconstructed_model.predict(test_input)
) 模型序列化
本文只涉及保存模型的配置而不涉及其状态。模型的配置或架构规定了模型包含哪些层以及这些层的连接方式。如果有了模型的配置就可以用全新的初始化状态没有权重或编译信息来创建模型。
APIs
以下是可用的序列化 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 dict。您应该定义 get_config()使其包含模型或层的 __init__() 方法所需的参数。加载时from_config(config) 方法将使用这些参数调用 __init__() 来重构模型或层。 层示例
layer keras.layers.Dense(3, activationrelu)
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.initializers, class_name: GlorotUniform, config: {seed: None}, registered_name: None}, bias_initializer: {module: keras.initializers, class_name: Zeros, config: {}, registered_name: None}, 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 中所有序列化()/反序列化()调用的基础。
例子
my_reg keras.regularizers.L1(0.005)
config keras.saving.serialize_keras_object(my_reg)
print(config) 显示如下 {module: keras.regularizers, class_name: L1, config: {l1: 0.004999999888241291}, registered_name: None} 注意序列化格式其中包含正确重建所需的所有信息 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, activationrelu, namedense_2)layer.build((None, 784))return layerlayer_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,), namedigits)
x keras.layers.Dense(64, activationrelu, namedense_1)(inputs)
x keras.layers.Dense(64, activationrelu, namedense_2)(x)
outputs keras.layers.Dense(10, namepredictions)(x)
functional_model keras.Model(inputsinputs, outputsoutputs, name3_layer_mlp)# Define a subclassed model with the same architecture
class SubclassedModel(keras.Model):def __init__(self, output_dim, nameNone):super().__init__(namename)self.output_dim output_dimself.dense_1 keras.layers.Dense(64, activationrelu, namedense_1)self.dense_2 keras.layers.Dense(64, activationrelu, namedense_2)self.dense_3 keras.layers.Dense(output_dim, namepredictions)def call(self, inputs):x self.dense_1(inputs)x self.dense_2(x)x self.dense_3(x)return xdef 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,), namedigits)
x keras.layers.Dense(64, activationrelu, namedense_1)(inputs)
x keras.layers.Dense(64, activationrelu, namedense_2)(x)
outputs keras.layers.Dense(10, namepredictions)(x)
functional_model keras.Model(inputsinputs, outputsoutputs, name3_layer_mlp)inputs keras.Input(shape(784,), namedigits)
x keras.layers.Dense(64, activationrelu, namedense_1)(inputs)
x keras.layers.Dense(64, activationrelu, namedense_2)(x)# Add a dropout layer, which does not contain any weights.
x keras.layers.Dropout(0.5)(x)
outputs keras.layers.Dense(10, namepredictions)(x)
functional_model_with_dropout keras.Model(inputsinputs, outputsoutputs, name3_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,), namedigits),keras.layers.Dense(64, activationrelu, namedense_1),keras.layers.Dense(64, activationrelu, namedense_2),keras.layers.Dense(10, namepredictions),]
)
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, nameNone):super().__init__(namename)self.dense_1 keras.layers.Dense(units, namedense_1)self.dense_2 keras.layers.Dense(units, namedense_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 Falsevariable_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,), namedigits)x keras.layers.Dense(64, activationrelu, namedense_1)(inputs)x keras.layers.Dense(64, activationrelu, namedense_2)(x)outputs keras.layers.Dense(10, namepredictions)(x)return keras.Model(inputsinputs, outputsoutputs, name3_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, namedense_3))
model keras.Sequential(extracted_layers)
model.summary() 处理自定义对象
定义配置方法 Specifications: get_config() 应返回一个可序列化的 JSON 字典以便与 Keras 架构和模型保存 API 兼容。 from_config(config)类方法应返回根据配置创建的新层或模型对象。默认实现返回 cls(**config)。 注意
如果您的所有构造函数参数如字符串和 int 或非自定义 Keras 对象都已可序列化则无需重载 from_config。但是对于传递给 __init__ 的层或模型等更复杂的对象必须在 __init__ 本身或重载 from_config() 方法中明确处理反序列化。
例子
keras.saving.register_keras_serializable(packageMyLayers, nameKernelMult)
class MyDense(keras.layers.Layer):def __init__(self,units,*,kernel_regularizerNone,kernel_initializerNone,nested_modelNone,**kwargs):super().__init__(**kwargs)self.hidden_units unitsself.kernel_regularizer kernel_regularizerself.kernel_initializer kernel_initializerself.nested_model nested_modeldef get_config(self):config super().get_config()# Update the config with the custom layers parametersconfig.update({units: self.hidden_units,kernel_regularizer: self.kernel_regularizer,kernel_initializer: self.kernel_initializer,nested_model: self.nested_model,})return configdef build(self, input_shape):input_units input_shape[-1]self.kernel self.add_weight(namekernel,shape(input_units, self.hidden_units),regularizerself.kernel_regularizer,initializerself.kernel_initializer,)def call(self, inputs):return ops.matmul(inputs, self.kernel)layer MyDense(units16, kernel_regularizerl1, kernel_initializerones)
layer3 MyDense(units64, nested_modellayer)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: MyLayersKernelMult}}, registered_name: MyLayersKernelMult}
MyDense namemy_dense_1, builtFalse 请注意对于 MyDense 而言无需覆盖 from_config因为 hidden_units、kernel_initializer 和 kernel_regularizer 分别是 ints、字符串和 Keras 内置对象。
这意味着 cls(**config) 的默认 from_config 实现将如期工作。 对于更复杂的对象例如传递给 __init__ 的层和模型必须显式地反序列化这些对象。
下面我们来看一个需要重写 from_config 的模型示例。
例子
keras.saving.register_keras_serializable(packageComplexModels)
class CustomModel(keras.layers.Layer):def __init__(self, first_layer, second_layerNone, **kwargs):super().__init__(**kwargs)self.first_layer first_layerif second_layer is not None:self.second_layer second_layerelse: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 configclassmethoddef from_config(cls, config):# Note that you can also use [keras.saving.deserialize_keras_object](/api/models/model_saving_apis/serialization_utils#deserializekerasobject-function) hereconfig[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))# Lets make our first layer the custom layer from the previous example (MyDense)
inputs keras.Input((32,))
outputs CustomModel(first_layerlayer)(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(units16,kernel_regularizerkeras.regularizers.L1L2(l11e-5, l21e-4),kernel_initializerones,
)
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.regularizers, class_name: L1L2, config: {l1: 1e-05, l2: 0.0001}, registered_name: None}, kernel_initializer: ones, nested_model: None}, registered_name: MyLayersKernelMult} registered_name 关键字包含 Keras 主列表的查找信息包括 MyLayers 包和我们在 keras.saving.register_keras_serializable 装饰器中给出的自定义名称 KernelMult。 请注意class_name 关键字包含类的原始名称以便在 from_config 中重新初始化。 此外请注意 module 关键字为 None因为这是一个自定义对象。 这就是保存与加载模型的全部内容啦。呵呵
