Keras 是一个用于深度学习的简单而强大的 Python 库。
由于深度学习模型可能需要数小时、数天甚至数周才能训练完成,因此了解如何从磁盘保存和加载它们非常重要。
在这篇文章中,您将学习如何将您的 Keras 模型保存到文件中,然后再次加载它们以进行预测。
阅读本教程后,您将了解
- 如何将模型权重和模型架构保存在单独的文件中
- 如何将模型架构保存为 YAML 和 JSON 格式
- 如何将模型权重和架构保存到单个文件中以供以后使用
用我的新书《Python 深度学习》启动您的项目,其中包括所有示例的分步教程和 Python 源代码文件。
让我们开始吧。
- 2017 年 3 月更新:添加了先安装 h5py 的说明
- 2017 年 3 月更新:更新了示例以适应 Keras API 的更改
- 2018年3月更新:添加了下载数据集的备用链接
- 2019 年 5 月更新:添加了将模型保存和加载到单个文件的部分
- 2019 年 9 月更新:添加了关于使用 PyYAML 版本 5 的注释
- 2022 年 6 月更新:添加了关于已弃用 YAML 格式的注释,并添加了关于协议缓冲区的章节

如何保存和加载 Keras 深度学习模型
图片由 Ray Harrington 拍摄,保留部分权利。
教程概述
如果您是Keras或深度学习的新手,请参阅此分步Keras教程。
Keras 将模型架构的保存和模型权重的保存分离开来。
模型权重以 HDF5 格式保存。这种网格格式非常适合存储多维数字数组。
模型结构可以使用两种不同的格式进行描述和保存:JSON 和 YAML。
在这篇文章中,您将看到三个保存和加载模型到文件的示例
- 将模型保存到 JSON
- 将模型保存到 YAML
- 将模型保存到 HDF5
前两个示例分别保存模型架构和权重。在所有情况下,模型权重都保存为 HDF5 格式文件。
这些示例将使用在 Pima Indians 糖尿病发作二分类数据集上训练的相同简单网络。这是一个包含所有数值数据的小数据集,易于使用。您可以下载此数据集并将其放置在您的工作目录中,文件名为“pima-indians-diabetes.csv”(更新:从此处下载)。
确认您已安装 TensorFlow v2.x(例如,截至 2022 年 6 月的 v2.9)。
注意:保存模型需要安装 h5py 库。它通常作为 TensorFlow 的依赖项安装。您也可以通过以下方式轻松安装它
1 |
sudo pip install h5py |
Python 深度学习需要帮助吗?
参加我的免费为期两周的电子邮件课程,发现 MLP、CNN 和 LSTM(附代码)。
立即点击注册,还将免费获得本课程的 PDF 电子书版本。
将神经网络模型保存到 JSON
JSON 是一种用于分层描述数据的简单文件格式。
Keras 提供了使用 to_json() 函数以 JSON 格式描述任何模型的能力。它可以保存到文件中,然后通过 model_from_json() 函数加载,该函数将从 JSON 规范创建新模型。
权重使用 save_weights() 函数直接从模型中保存,然后使用对称的 load_weights() 函数加载。
以下示例在 Pima Indians 数据集上训练并评估一个简单模型。然后将模型转换为 JSON 格式并写入本地目录中的 model.json。网络权重写入本地目录中的 model.h5。
从保存的文件中加载模型和权重数据,并创建一个新模型。在使用加载的模型之前编译它是很重要的。这样,使用模型进行的预测就可以使用 Keras 后端提供的适当高效的计算。
模型以相同的方式进行评估,打印出相同的评估分数。
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 |
# 用于 Pima Indians 数据集的 MLP 序列化为 JSON 和 HDF5 from tensorflow.keras.models import Sequential, model_from_json from tensorflow.keras.layers import Dense import numpy import os # 设置随机种子以保证结果可复现 numpy.random.seed(7) # 加载皮马印第安人糖尿病数据集 dataset = numpy.loadtxt("pima-indians-diabetes.csv", delimiter=",") # 分割为输入 (X) 和输出 (Y) 变量 X = dataset[:,0:8] Y = dataset[:,8] # 创建模型 model = Sequential() model.add(Dense(12, input_dim=8, activation='relu')) model.add(Dense(8, activation='relu')) model.add(Dense(1, activation='sigmoid')) # 编译模型 model.compile(loss='binary_crossentropy', optimizer='adam', metrics=['accuracy']) # 拟合模型 model.fit(X, Y, epochs=150, batch_size=10, verbose=0) # 评估模型 scores = model.evaluate(X, Y, verbose=0) print("%s: %.2f%%" % (model.metrics_names[1], scores[1]*100)) # 将模型序列化为JSON model_json = model.to_json() with open("model.json", "w") as json_file: json_file.write(model_json) # 将权重序列化为HDF5 model.save_weights("model.h5") print("Saved model to disk") # 稍后... # 加载 json 并创建模型 json_file = open('model.json', 'r') loaded_model_json = json_file.read() json_file.close() loaded_model = model_from_json(loaded_model_json) # 将权重加载到新模型中 loaded_model.load_weights("model.h5") print("Loaded model from disk") # 评估加载的模型在测试数据上的表现 loaded_model.compile(loss='binary_crossentropy', optimizer='rmsprop', metrics=['accuracy']) score = loaded_model.evaluate(X, Y, verbose=0) print("%s: %.2f%%" % (loaded_model.metrics_names[1], score[1]*100)) |
注意:考虑到算法或评估过程的随机性,或者数值精度的差异,您的结果可能会有所不同。请考虑运行几次示例并比较平均结果。
运行此示例将提供以下输出。
1 2 3 4 |
acc: 78.78% 模型已保存到磁盘 模型已从磁盘加载 acc: 78.78% |
模型的 JSON 格式如下所示
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 |
{ "class_name":"Sequential", "config":{ "name":"sequential_1", "layers":[ { "class_name":"Dense", "config":{ "name":"dense_1", "trainable":true, "batch_input_shape":[ null, 8 ], "dtype":"float32", "units":12, "activation":"relu", "use_bias":true, "kernel_initializer":{ "class_name":"VarianceScaling", "config":{ "scale":1.0, "mode":"fan_avg", "distribution":"uniform", "seed":null } }, "bias_initializer":{ "class_name":"Zeros", "config":{ } }, "kernel_regularizer":null, "bias_regularizer":null, "activity_regularizer":null, "kernel_constraint":null, "bias_constraint":null } }, { "class_name":"Dense", "config":{ "name":"dense_2", "trainable":true, "dtype":"float32", "units":8, "activation":"relu", "use_bias":true, "kernel_initializer":{ "class_name":"VarianceScaling", "config":{ "scale":1.0, "mode":"fan_avg", "distribution":"uniform", "seed":null } }, "bias_initializer":{ "class_name":"Zeros", "config":{ } }, "kernel_regularizer":null, "bias_regularizer":null, "activity_regularizer":null, "kernel_constraint":null, "bias_constraint":null } }, { "class_name":"Dense", "config":{ "name":"dense_3", "trainable":true, "dtype":"float32", "units":1, "activation":"sigmoid", "use_bias":true, "kernel_initializer":{ "class_name":"VarianceScaling", "config":{ "scale":1.0, "mode":"fan_avg", "distribution":"uniform", "seed":null } }, "bias_initializer":{ "class_name":"Zeros", "config":{ } }, "kernel_regularizer":null, "bias_regularizer":null, "activity_regularizer":null, "kernel_constraint":null, "bias_constraint":null } } ] }, "keras_version":"2.2.5", "backend":"tensorflow" } |
将神经网络模型保存到 YAML
注意:此方法仅适用于 TensorFlow 2.5 或更早版本。如果您在更高版本的 TensorFlow 中运行它,您将看到一个 RuntimeError,消息为“Method model.to_yaml() 已由于任意代码执行的安全风险而被删除。请改用 model.to_json()。”
这个示例与上面的 JSON 示例非常相似,只是模型规范使用了 YAML 格式。
请注意,此示例假定您已安装 PyYAML 5
1 |
sudo pip install PyYAML |
在此示例中,模型使用 YAML 描述,保存到文件 model.yaml,然后通过 model_from_yaml() 函数加载到新模型中。
权重以与上面 HDF5 格式相同的方式处理,作为 model.h5。
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 |
# 用于 Pima Indians 数据集的 MLP 序列化为 YAML 和 HDF5 from tensorflow.keras.models import Sequential, model_from_yaml from tensorflow.keras.layers import Dense import numpy import os # 设置随机种子以保证结果可复现 seed = 7 numpy.random.seed(seed) # 加载皮马印第安人糖尿病数据集 dataset = numpy.loadtxt("pima-indians-diabetes.csv", delimiter=",") # 分割为输入 (X) 和输出 (Y) 变量 X = dataset[:,0:8] Y = dataset[:,8] # 创建模型 model = Sequential() model.add(Dense(12, input_dim=8, activation='relu')) model.add(Dense(8, activation='relu')) model.add(Dense(1, activation='sigmoid')) # 编译模型 model.compile(loss='binary_crossentropy', optimizer='adam', metrics=['accuracy']) # 拟合模型 model.fit(X, Y, epochs=150, batch_size=10, verbose=0) # 评估模型 scores = model.evaluate(X, Y, verbose=0) print("%s: %.2f%%" % (model.metrics_names[1], scores[1]*100)) # 将模型序列化为 YAML model_yaml = model.to_yaml() with open("model.yaml", "w") as yaml_file: yaml_file.write(model_yaml) # 将权重序列化为HDF5 model.save_weights("model.h5") print("Saved model to disk") # 稍后... # 加载 YAML 并创建模型 yaml_file = open('model.yaml', 'r') loaded_model_yaml = yaml_file.read() yaml_file.close() loaded_model = model_from_yaml(loaded_model_yaml) # 将权重加载到新模型中 loaded_model.load_weights("model.h5") print("Loaded model from disk") # 评估加载的模型在测试数据上的表现 loaded_model.compile(loss='binary_crossentropy', optimizer='rmsprop', metrics=['accuracy']) score = loaded_model.evaluate(X, Y, verbose=0) print("%s: %.2f%%" % (loaded_model.metrics_names[1], score[1]*100)) |
注意:考虑到算法或评估过程的随机性,或者数值精度的差异,您的结果可能会有所不同。请考虑运行几次示例并比较平均结果。
运行示例显示以下输出。
1 2 3 4 |
acc: 78.78% 模型已保存到磁盘 模型已从磁盘加载 acc: 78.78% |
用 YAML 格式描述的模型如下所示
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 |
后端: tensorflow 类名: Sequential 配置 层 - 类名: Dense 配置 激活: relu 活动正则化器: null 批输入形状: !!python/tuple - null - 8 偏置约束: null 偏置初始化器 类名: Zeros 配置: {} 偏置正则化器: null 数据类型: float32 核约束: null 核初始化器 类名: VarianceScaling 配置 分布: uniform 模式: fan_avg 比例: 1.0 种子: null 核正则化器: null 名称: dense_1 可训练: true 单元: 12 使用偏置: true - 类名: Dense 配置 激活: relu 活动正则化器: null 偏置约束: null 偏置初始化器 类名: Zeros 配置: {} 偏置正则化器: null 数据类型: float32 核约束: null 核初始化器 类名: VarianceScaling 配置 分布: uniform 模式: fan_avg 比例: 1.0 种子: null 核正则化器: null 名称: dense_2 可训练: true 单元: 8 使用偏置: true - 类名: Dense 配置 激活: sigmoid 活动正则化器: null 偏置约束: null 偏置初始化器 类名: Zeros 配置: {} 偏置正则化器: null 数据类型: float32 核约束: null 核初始化器 类名: VarianceScaling 配置 分布: uniform 模式: fan_avg 比例: 1.0 种子: null 核正则化器: null 名称: dense_3 可训练: true 单元: 1 使用偏置: true 名称: sequential_1 keras_version: 2.2.5 |
同时保存模型权重和架构
Keras 还支持一个更简单的接口,可以将模型权重和模型架构一起保存到一个 H5 文件中。
以这种方式保存模型包括您需要了解的有关模型的所有信息,包括
- 模型权重
- 模型架构
- 模型编译细节(损失和指标)
- 模型优化器状态
这意味着您可以直接加载和使用模型,而无需像上面示例中那样重新编译它。
注意:这是保存和加载 Keras 模型的首选方式。
如何保存 Keras 模型
您可以通过调用模型的 save() 函数并指定文件名来保存模型。
以下示例通过首先拟合模型,评估它,然后将其保存到文件 model.h5 来演示这一点。
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 |
# 用于 Pima Indians 数据集的 MLP 保存到单个文件 从 numpy 导入 loadtxt from tensorflow.keras.models import Sequential from tensorflow.keras.layers import Dense # 加载皮马印第安人糖尿病数据集 dataset = loadtxt("pima-indians-diabetes.csv", delimiter=",") # 分割为输入 (X) 和输出 (Y) 变量 X = dataset[:,0:8] Y = dataset[:,8] # 定义模型 model = Sequential() model.add(Dense(12, input_dim=8, activation='relu')) model.add(Dense(8, activation='relu')) model.add(Dense(1, activation='sigmoid')) # 编译模型 model.compile(loss='binary_crossentropy', optimizer='adam', metrics=['accuracy']) # 拟合模型 model.fit(X, Y, epochs=150, batch_size=10, verbose=0) # 评估模型 scores = model.evaluate(X, Y, verbose=0) print("%s: %.2f%%" % (model.metrics_names[1], scores[1]*100)) # 将模型和架构保存到单个文件 model.save("model.h5") print("Saved model to disk") |
注意:考虑到算法或评估过程的随机性,或者数值精度的差异,您的结果可能会有所不同。请考虑运行几次示例并比较平均结果。
运行示例会拟合模型,总结模型在训练数据集上的性能,并将模型保存到文件。
1 2 |
acc: 77.73% 模型已保存到磁盘 |
您稍后可以从文件中加载此模型并使用它。
请注意,在 Keras 库中,有另一个执行相同操作的函数,如下所示
1 2 3 4 |
... # 等同于: model.save("model.h5") from tensorflow.keras.models import save_model save_model(model, "model.h5") |
如何加载 Keras 模型
您可以通过调用 load_model() 函数并传入文件名来加载保存的模型。该函数返回具有相同架构和权重的模型。
在这种情况下,您加载模型,总结架构,并在相同的数据集上评估它,以确认权重和架构相同。
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 |
# 加载并评估保存的模型 从 numpy 导入 loadtxt from tensorflow.keras.models import load_model # 加载模型 model = load_model('model.h5') # 总结模型。 model.summary() # 加载数据集 dataset = loadtxt("pima-indians-diabetes.csv", delimiter=",") # 分割为输入 (X) 和输出 (Y) 变量 X = dataset[:,0:8] Y = dataset[:,8] # 评估模型 score = model.evaluate(X, Y, verbose=0) print("%s: %.2f%%" % (model.metrics_names[1], score[1]*100)) |
运行示例首先加载模型,打印模型架构的摘要,然后评估加载的模型在相同数据集上的表现。
注意:考虑到算法或评估过程的随机性,或者数值精度的差异,您的结果可能会有所不同。请考虑运行几次示例并比较平均结果。
模型达到相同的准确率分数,本例中为 77%。
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 |
_________________________________________________________________ 层 (类型) 输出形状 参数数量 ================================================================= dense_1 (Dense) (None, 12) 108 _________________________________________________________________ dense_2 (Dense) (None, 8) 104 _________________________________________________________________ dense_3 (Dense) (None, 1) 9 ================================================================= 总参数: 221 可训练参数: 221 不可训练参数: 0 _________________________________________________________________ acc: 77.73% |
协议缓冲区格式
虽然使用 HDF5 格式保存和加载 Keras 模型是推荐的方式,但 TensorFlow 还支持另一种格式,即协议缓冲区。保存和加载协议缓冲区格式被认为更快,但这样做会生成多个文件。语法相同,只是您不需要为文件名提供 .h5 扩展名
1 2 3 4 5 6 7 8 9 |
# 将模型和架构保存到单个文件 model.save("model") # ... 稍后 # 加载模型 model = load_model('model') # 打印摘要 model.summary() |
这将创建一个名为“model”的目录,其中包含以下文件
1 2 3 4 5 6 7 |
模型/ |-- 资产/ |-- keras_metadata.pb |-- saved_model.pb `-- 变量/ |-- variables.data-00000-of-00001 `-- variables.index |
这也是 TensorFlow v1.x 中保存模型所使用的格式。当您从 TensorFlow Hub 下载预训练模型时,您可能会遇到这种情况。
进一步阅读
- Keras 文档中的“如何保存 Keras 模型?”
- Keras 文档中的“关于 Keras 模型”
总结
在这篇文章中,您学习了如何序列化您的 Keras 深度学习模型。
您学习了如何将训练好的模型保存到文件中,然后加载它们并使用它们进行预测。
您还学习到模型权重可以轻松地使用 HDF5 格式存储,并且网络结构可以保存为 JSON 或 YAML 格式。
您对保存深度学习模型或本文有任何疑问吗?
在评论中提出您的问题,我将尽力回答。
嗨,Jason,
感谢您通过此博客分享知识。这对我帮助很大。
谢谢您的努力。
我有一个问题。当我执行 keras 代码来加载 YAML / JSON 数据时,我看到以下错误。
回溯(最近一次调用)
文件“simple_rnn.py”,第 158 行,位于
loaded_model = model_from_yaml(loaded_model_yaml)
文件“/usr/local/lib/python2.7/dist-packages/Keras-1.0.4-py2.7.egg/keras/models.py”,第 26 行,位于 model_from_yaml
return layer_from_config(config, custom_objects=custom_objects)
文件“/usr/local/lib/python2.7/dist-packages/Keras-1.0.4-py2.7.egg/keras/utils/layer_utils.py”,第 35 行,位于 layer_from_config
return layer_class.from_config(config[‘config’])
文件“/usr/local/lib/python2.7/dist-packages/Keras-1.0.4-py2.7.egg/keras/models.py”,第 781 行,位于 from_config
layer = get_or_create_layer(first_layer)
文件“/usr/local/lib/python2.7/dist-packages/Keras-1.0.4-py2.7.egg/keras/models.py”,第 765 行,位于 get_or_create_layer
layer = layer_from_config(layer_data)
文件“/usr/local/lib/python2.7/dist-packages/Keras-1.0.4-py2.7.egg/keras/utils/layer_utils.py”,第 35 行,位于 layer_from_config
return layer_class.from_config(config[‘config’])
文件“/usr/local/lib/python2.7/dist-packages/Keras-1.0.4-py2.7.egg/keras/engine/topology.py”,第 896 行,位于 from_config
return cls(**config)
文件“/usr/local/lib/python2.7/dist-packages/Keras-1.0.4-py2.7.egg/keras/layers/recurrent.py”,第 290 行,位于 __init__
self.init = initializations.get(init)
文件“/usr/local/lib/python2.7/dist-packages/Keras-1.0.4-py2.7.egg/keras/initializations.py”,第 109 行,位于 get
‘initialization’, kwargs=kwargs)
文件“/usr/local/lib/python2.7/dist-packages/Keras-1.0.4-py2.7.egg/keras/utils/generic_utils.py”,第 14 行,位于 get_from_module
str(identifier))
异常: 无效初始化
原因可能是什么?文件保存正常,但在加载模型时遇到此问题。
您能给我一些提示吗?
谢谢,
Onkar
抱歉 Onkar,故障不清楚。
您能正常执行教程中的示例吗?
嗨,Jason,
这篇帖子很棒,提供了有用的保存和评估模型的步骤。如何在不重新训练新数据的情况下,在新数据上运行已保存的模型?假设我有一个线性回归 y=mx+c,在给定 x 集上训练,一旦我获得了给定 y 和 x 的 m 和 c,我只需要输入新的 x 并获得具有相同 m 和 c 的预测 y。我无法以这种方式使用 LSTM 模型。
提前感谢您的帮助和评论。
加载模型并进行预测
model.predict(X)
也许我没理解问题所在?
您的代码运行良好,
我尝试将保存模型添加到我的代码中,但文件实际上并未创建,尽管我没有收到错误消息
请指教
walid
我希望文件已创建。检查您的当前工作目录/源代码文件所在的目录。
嗨,Jason,
感谢您创建这些有价值的内容。
在我的 Mac(OSX10.11)上,脚本运行正常,直到最后一行,它给出了以下语法错误
>>> print “%s: %.2f%%” % (loaded_model.metrics_names[1], score[1]*100)
文件“”,第 1 行
print “%s: %.2f%%” % (loaded_model.metrics_names[1], score[1]*100)
^
SyntaxError: invalid syntax
这里可能出了什么问题?
谢谢,
彼得
嗨 Peter,您可能使用的是 Python3,请尝试在 print 函数的参数周围添加括号。
你好,
您的博客和书籍都很棒,多亏了您,我终于让我的项目在Keras中运行起来了。
我似乎找不到如何将Keras模型转换为无需安装Keras即可运行的独立代码。
我能找到的最好方法是学习TensorFlow,在TF中构建一个等效模型,然后使用TF创建独立代码。
Keras没有这样的功能吗?
谢谢
您好,我的理解是,在预测中使用模型需要Keras。
您可以尝试保存网络权重并在自己的代码中使用它们,但这会给自己带来很多工作。
感谢Jason的精彩博客。
保存此模型和重新加载只适用于Keras,还是也适用于其他sklearn模型,如kmeans等?
当我使用了一些分类器,并且它们也进行了独热编码,比如工资等级或国家等时,假设您保存了模型,但如何对预期给出输出的输入数据应用相同的编码和特征缩放呢?
例如,我可能基于国家、性别、吸烟和饮酒状况(如经常、偶尔、罕见等)训练了一个癌症结果模型。现在,当我获得新记录时,如何确保我的编码和特征缩放与我的训练集保持一致并将其转换为预测?
提前感谢您的帮助。
您可以保存sklearn模型
https://machinelearning.org.cn/save-load-machine-learning-models-python-scikit-learn/
您知道是否可以用keras加载已保存的sklearn模型吗?那会怎么操作?
没有,抱歉。
你好 Jason,
感谢您这个很棒且非常有用的网站。
既然这里谈到了如何保存模型,我想知道如何以常规词嵌入文件(即文本文件或txt格式)中可见的方式保存嵌入层。假设我们是在模型中从头开始学习这些词嵌入,或者我们更新了在模型第一层中输入的预训练词嵌入。
提前感谢您的回复。
此致,
Davood
Davood,我不确定我们是否需要保存嵌入层。
我相信它们是确定性的,可以重新创建。
我想我们应该能够在某个时候保存词嵌入(尽管并非总是需要!)。为了在(2D)空间中可视化/映射它们或测试它们的代数词类比,这些都是这种需求的一些例子。
我找到了这个问题的答案,我在这里分享一下
如果我们训练一个嵌入层`emb`(例如`emb = Embedding(some_parameters_here)`),我们可以通过`my_embeddings = emb.get_weights()`获取生成的词-维度矩阵。然后,我们可以做正常的numpy操作,比如`np.save("my_embeddings.npy", my_matrix)`来保存这个矩阵;或者使用Python中其他内置的`write_to_a_file`函数来存储这个矩阵的每一行以及其关联的词。这些词及其索引通常存储在代码中的某个`word_index`字典中。
非常棒,感谢Davood分享细节。
Jason,非常欢迎。
不过我还有另一个问题!
假设我们在Keras中有两列网络,这两列完全相同。这两列将在顶部合并,然后输入到作为我们模型中输出层的密集层。我的问题是,虽然这里每列的第一层都是嵌入层,我们如何共享列中相似层的权重?无需多说,我们将嵌入层(第一层)设置为只有一个嵌入矩阵。我的意思是共享嵌入,类似于这样
emb1 = Embedding(some_parameters_here)
emb2 = emb1 # 而不是 emb2 = Embedding(some_other_parameters_here))。
那这两层嵌入层之上的其他层呢?!如何共享它们的权重?
提前感谢您的回答。
嗯,有意思,Davood。
我认为,也可能错了,嵌入层是确定性的。它们没有状态,只有输入或输出的权重有状态。创建两个并排使用。试试看。
我很想知道您进展如何?
你好Jason,感谢你的分享,对我帮助很大。我想问一个问题,为什么编译模型时优化器是adam,但编译加载模型时却使用rmsprop?
我建议尝试许多不同的优化器,看看您最喜欢哪个/哪个最适合您的问题。
我发现ADAM速度快且效果好。
我很难找到这个问题的答案
Keras中的权重何时初始化?
在编译时?(可能不是)
在第一个epoch时?
这对于恢复学习很重要
有趣的问题。
我不知道。
如果我不得不猜测,我会说在创建数据结构时,即在`model.compile()`时。
可能值得在 Keras 邮件列表中提问——我很想知道答案。
感谢您创建如此出色的博客。
我用上面提到的代码保存了一个模型。但是当我再次加载它时,我遇到了以下错误。看起来网络架构没有正确保存?
—————————————————————————
异常回溯(最近一次调用)
in ()
1 # 将权重加载到新模型中
----> 2 modelN.load_weights(“model41.h5”)
3 print(“从磁盘加载模型”)
C:\Anaconda2\envs\py35\lib\site-packages\keras\engine\topology.py in load_weights(self, filepath, by_name)
2518 self.load_weights_from_hdf5_group_by_name(f)
2519 else
-> 2520 self.load_weights_from_hdf5_group(f)
2521
2522 if hasattr(f, ‘close’)
C:\Anaconda2\envs\py35\lib\site-packages\keras\engine\topology.py in load_weights_from_hdf5_group(self, f)
2570 ‘包含’ + str(len(layer_names)) +
2571 ‘层到具有’ +
-> 2572 str(len(flattened_layers)) + ‘层的模型中。’)
2573
2574 # 我们在一个后端调用中批量分配权重值
异常:您正在尝试将包含4层的权重文件加载到具有5层的模型中。
嗨,Soheil,
看起来您加载权重的网络结构与权重结构不匹配。
请仔细检查网络结构是否与您保存权重时使用的结构完全匹配。您甚至可以将此结构保存为json或yaml文件。
你好Jason!如何在jupyter中查看保存的权重结构?我遇到了和Soheil一样的问题,但是我的网络有17层。
谢谢阅读!
权重是一个数组,您可以通过`.shape`属性总结它们的形状。
嗨,Jason,
我有一个问题。既然我已经保存了模型和权重,我是否可以在几天后回来,用我保存的初始权重再次训练模型?
好问题,prajnya。
您可以加载已保存的权重,并继续使用新数据进行训练/更新或开始进行预测。
嗨,Jason,
我尝试保存并加载一个训练了5000个epoch的模型,并在同一会话中将其性能与保存前5000个epoch后模型的性能进行比较。无论如何,使用上述代码,我最终得到了随机结果。但是,我只保存了权重,并再次实例化模型,然后使用参数“by_name”加载了权重model.load_weights('model.h5', by_name=True),此时准确率与模型在第一个epoch/迭代时的初始性能相同。但在任何情况下我都无法复现!请求您能否通过一篇文章澄清这一点,github上也有一个帖子,但尚未得到满意的解决!!!
很抱歉听到这个消息,我没有什么好主意。也许可以发布到stackoverflow?
GitHub帖子在https://github.com/fchollet/keras/issues/4875
嗨,Jason,
您的博客非常棒。感谢您记录详尽的工作。
我有一个关于加载模型权重的问题。有没有办法将权重保存到一个变量中,而不是加载并将权重分配给不同的模型?
我想对与中间隐藏层相关的权重进行一些操作。
我曾期望使用ModelCheckpoint,但在从hdf5格式读取权重并将其保存到变量方面有点迷茫。您能帮我解决这个问题吗?
谢谢
好问题,抱歉我没做过这个。
我预计您可以使用 Keras API 提取它们,可能值得查看 GitHub 上的源代码。
嗨 Jason
非常感谢您出色的教程!非常感谢……
关于保存和加载:Keras目前似乎将模型和权重保存在HD5中,而不仅仅是权重。
https://keras.org.cn/getting-started/faq/#how-can-i-save-a-keras-model
这导致了更简单的导入/导出代码片段
——————————————————-
from keras.models import load_model
model.save('my_model.h5') # 创建一个 HDF5 文件 'my_model.h5'
del model # 删除现有模型
# 返回一个已编译的模型
# 与之前的模型完全相同
model = load_model('my_model.h5')
——————————————————-
谢谢Patrick,我会尽快调查并更新帖子。
出现此错误
NameError: name 'model_from_json' is not defined
提前感谢任何帮助。
确认您已安装 Keras 1.2.2 或更高版本。
请务必先运行“from keras.models import model_from_json”
我已经将权重保存在txt文件中了。我可以使用它并加载权重吗?
您可能可以,我手头没有示例,抱歉。
嗨,Jason,
感谢您这篇出色的教程。
我想将这个 Keras 模型 (model.h5) 转换为 TensorFlow 模型 (filename.pb),因为我想在 Android 中使用它。我使用了 GitHub 代码,如下:
=========================================
import keras
import tensorflow
from keras import backend as K
from tensorflow.contrib.session_bundle import exporter
from keras.models import model_from_config, Sequential
print(“正在加载模型以导出为 Protocol Buffer 格式…”)
model_path = “C:/Users/User/buildingrecog/model.h5”
model = keras.models.load_model(model_path)
K.set_learning_phase(0) # 从现在开始,所有新操作都将在测试模式下进行
sess = K.get_session()
# 序列化模型并获取其权重,以便快速重新构建
config = model.get_config()
weights = model.get_weights()
# 重新构建一个学习阶段现在硬编码为 0 的模型
new_model = Sequential.model_from_config(config)
new_model.set_weights(weights)
export_path = “C:/Users/User/buildingrecog/khi_buildings.pb” # 导出图的保存路径
export_version = 1 # 版本号(整数)
saver = tensorflow.train.Saver(sharded=True)
model_exporter = exporter.Exporter(saver)
signature = exporter.classification_signature(input_tensor=model.input, scores_tensor=model.output)
model_exporter.init(sess.graph.as_graph_def(), default_graph_signature=signature)
model_exporter.export(export_path, tensorflow.constant(export_version), sess)
———————————————————————————–
但出现了以下错误…
=====================
正在加载模型以导出为 Protocol Buffer 格式…
—————————————————————————
ValueError 回溯 (最近一次调用)
in ()
7 print(“正在加载模型以导出为 Protocol Buffer 格式…”)
8 model_path = “C:/Users/User/buildingrecog/model.h5”
----> 9 model = keras.models.load_model(model_path)
10
11 K.set_learning_phase(0) # 从现在开始,所有新操作都将在测试模式下进行
C:\Users\User\Anaconda3\lib\site-packages\keras\models.py in load_model(filepath, custom_objects)
228 model_config = f.attrs.get(‘model_config’)
229 if model_config is None
–> 230 raise ValueError(‘配置文件中未找到模型。’)
231 model_config = json.loads(model_config.decode(‘utf-8’))
232 model = model_from_config(model_config, custom_objects=custom_objects)
ValueError: 配置文件中未找到模型。
—————————————————————-
请帮我解决这个问题…!!
抱歉,我手头不知道如何在 TensorFlow 中加载 Keras 模型。
M Amer,
我正在尝试做同样的事情。如果您解决了,请告诉我们。
嗨,Jason,
我创建了Keras模型文件(.h5),但遗憾的是它无法加载。但我想加载它并将其转换为TensorFlow (.pb)模型。有什么解决方案吗?等待您的回复….
抱歉,我没有如何在TensorFlow中加载Keras模型的示例。
嗨,Jason,
我加载用标准化(StandardScaler)处理过的模型时遇到了问题。加载模型时也需要应用标准化(StandarScaler)吗?
这是代码片段:1) 保存和 2) 加载
保存
import numpy as np
import matplotlib.pyplot as plt
import pandas as pd
# 导入数据集
dataset = pd.read_csv('Churn_Modelling.csv')
X = dataset.iloc[:, 3:13].values
y = dataset.iloc[:, 13].values
# 编码分类数据
from sklearn.preprocessing import LabelEncoder, OneHotEncoder
labelencoder_X_1 = LabelEncoder()
X[:, 1] = labelencoder_X_1.fit_transform(X[:, 1])
labelencoder_X_2 = LabelEncoder()
X[:, 2] = labelencoder_X_2.fit_transform(X[:, 2])
onehotencoder = OneHotEncoder(categorical_features = [1])
X = onehotencoder.fit_transform(X).toarray()
X = X[:, 1:]
# 将数据集拆分为训练集和测试集
from sklearn.model_selection import train_test_split
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size = 0.2, random_state = 0)
# 特征缩放
from sklearn.preprocessing import StandardScaler
sc = StandardScaler()
X_train = sc.fit_transform(X_train)
X_test = sc.transform(X_test)
# 导入 Keras 库和包
import keras
来自 keras.models import Sequential
from keras.layers import Dense
# 初始化 ANN
classifier = Sequential()
classifier.add(Dense(units = 6, kernel_initializer = 'uniform', activation = 'relu', input_dim = 11))
classifier.add(Dense(units = 6, kernel_initializer = 'uniform', activation = 'relu'))
classifier.add(Dense(units = 1, kernel_initializer = 'uniform', activation = 'sigmoid'))
classifier.compile(optimizer = 'adam', loss = 'binary_crossentropy', metrics = ['accuracy'])
# 将 ANN 拟合到训练集
classifier.fit(X_train, y_train, batch_size = 10, epochs = 1)
# 预测测试集结果
y_pred = classifier.predict(X_test)
y_pred = (y_pred > 0.5)
# 保存您的模型
classifier.save("ann_churn_model_v1.h5")
加载
import numpy as np
import matplotlib.pyplot as plt
import pandas as pd
# 重用 churn_model_v1.h5
import keras
from keras.models import load_model
classifier = load_model("ann_churn_model_v1.h5")
# 特征缩放——这里我有一个问题,加载模型后是否需要应用 StandardScaler?
from sklearn.preprocessing import StandardScaler
#sc = StandardScaler()
new_prediction = classifier.predict(sc.transform(np.array([[0.0, 0.0, 600, 1, 40, 3, 60000, 2, 1, 1, 50000]])))
new_prediction = (new_prediction > 0.5)
谢谢,
Sanj
您还需要保存您的缩放器。
也许您可以将其腌制,或者只保存缩放数据所需的系数(每个特征的最小值/最大值)。
感谢您的有用信息。
是否可以将此模型和权重加载到其他平台,例如Android或iOS。我相信模型和权重是语言无关的。
有没有免费/开源的解决方案用于此目的?
我看不出为什么不行。抱歉,我不了解Android或iOS平台。
嗨,Jason,
如何根据人脸识别编码创建模型,以便使用 Saver.save() 方法保存?
Saver.save() 是什么?
嘿,Jason,您尝试过保存模型,关闭 Python 会话,然后打开一个新的 Python 会话并加载模型吗?
使用 Python 3.5,如果我在一个会话中保存训练好的模型并在另一个会话中加载它,我的准确率会急剧下降,预测变得随机(就好像模型没有训练一样)。
这就是我正在尝试做的事情
”’
embedding_size = 64
hidden_size = 64
input_length = 100
learning_rate = 0.1
patience = 3
num_labels = 6
batch_size= 50
epochs = 100
seq_len = 100′
model = Sequential()
model.add(Embedding(vocab_size, embedding_size, input_length=input_length))
model.add(Bidirectional(GRU(hidden_size, return_sequences=True, activation="tanh")))
model.add(TimeDistributed(Dense(num_labels, activation='softmax')))
optimizer = Adagrad(lr=learning_rate)
model.compile(loss='categorical_crossentropy', optimizer=optimizer, metrics=['categorical_accuracy'])
callbacks = [EarlyStopping(monitor='val_loss', patience=patience, verbose=0)]
model.fit(x_train, y_train, batch_size=batch_size, epochs = epochs, callbacks=callbacks, validation_data=[x_dev, y_dev])
model.save("model.h5″)
”’
此时评估模型会给我带来约70%的准确率。
然后我退出python,打开一个新的python会话,然后尝试
”’
model2 = load_mode('model_full.h5′)
”’
此时评估模型会给我带来约20%的准确率。
有什么想法吗?
我有。我不认为这与Python会话有关。
凭直觉,我的直觉告诉我,保存的模型中有些不同。
如果您在同一会话中保存和加载,结果是否与保存之前相同?如果您重复加载+测试过程几次呢?
确认您也保存了嵌入层(我认为它可能需要保存)。
确认您正在以完全相同的方式、相同的数据和相同的顺序评估它。
神经网络是随机的,偏差可能会影响RNN的内部状态,并导致不同的结果,尽管可能不像您所报告的那么剧烈。
我遇到了一个类似的问题,
如果在同一会话中保存并加载,加载模型的结果与会话中已有的模型(保存之前)不同。
理想情况下,训练好的模型(在会话/内存中)和加载的模型(保存和加载后)不应该相同吗?
我搜索了,但尚未找到任何线索。任何帮助/线索都将不胜感激。提前感谢
你好 Hardik...以下资源可能会增加清晰度
https://machinelearning.org.cn/stochastic-in-machine-learning/
@James – 感谢您的快速回复。
所以我明白了为什么两次预测,一次来自会话模型 (ANN),另一次来自加载模型(保存的会话模型)是不同的。
但在我的情况下,会话模型 (ANN) 的结果非常糟糕(MAE 非常高),而加载模型(保存的会话模型)的结果令人满意(MAE 相当好)。我无法理解为什么会有如此巨大的差异?
我似乎收到一条错误消息
RuntimeError: 无法创建属性(对象头消息太大)
Github issues 指出该错误可能是由于网络太大造成的,这里就是这种情况……但是
那我应该如何保存权重……Keras 似乎没有任何替代方法。
抱歉,我没有见过这个错误。
尝试在你的系统上使用一个较小的网络保存权重,以缩小故障原因。
attr = h5a.create(self._id, self._e(tempname), htype, space)
File “h5py\_objects.pyx”, line 54, in h5py._objects.with_phil.wrapper
File “h5py\_objects.pyx”, line 55, in h5py._objects.with_phil.wrapper
文件“h5py\h5a.pyx”,第 47 行,在 h5py.h5a.create 中
RuntimeError: 无法创建属性(对象头消息太大)
我正在尝试保存 SeRexNext-101 的权重,在此过程中我遇到了错误。
https://github.com/qubvel/classification_models/blob/master/tests/test_models.py
@Jason Brownlee 你可以尝试从这个 github 保存权重,请你帮我解决一下。
也许可以尝试在 stackoverflow 上发布你的错误和代码。
大家好,
我想知道如何在不停止服务的情况下更新模型值,比如我有一个更好的模型,版本 2,并且不需要停止服务,而之前使用的是 Keras 中的版本 1。我想说一个模块管理器模型,可以更新新版本模型,而不需要中断服务,或者类似的东西。谢谢。
你有几个选择。
你可以替换权重并继续使用拓扑。你可以替换拓扑和权重。
你也可以从现有的权重集继续学习,请参阅此帖子
https://machinelearning.org.cn/update-lstm-networks-training-time-series-forecasting/
非常感谢你,Jason。
不客气。
嗨,Jason,
你知道是否可以只保存模型,并且每次模型在验证集上的准确性提高时(在每个 epoch 之后)都保存吗?
并且是否可以以比每个 epoch 更高的频率检查验证?
谢谢!
我想是这样,George,回调函数是高度可配置的
https://keras.org.cn/callbacks/#modelcheckpoint
嗨,Jason博士,
我正在使用 Keras 和 TensorFlow 后端。我已经按照你这里提到的方法保存了我的模型。但问题是加载权重所需的时间比预期要长。我只使用 CPU(而不是 GPU),因为我的模型是一种小型模型。你能告诉我如何提高模型的加载时间吗?与 sci-kit learn 的 pickled 模型的加载时间相比,这个时间非常长(将近 1 分钟)。
那可真够久的。
确认是 Keras 导致的问题。
也许是你的代码中其他地方的问题?
也许你的硬盘非常慢?
也许你的内存因为某些原因不足?
嗨,Jason,
网格搜索后如何保存模型?我一直收到错误:“AttributeError: ‘KerasClassifier’ object has no attribute ‘save’”
嗨,Jason,
我有两个问题,
1) 为什么你会在 load_weights() 之后第二次 compile() 模型来从文件中重新加载模型?
2) 在这两个例子中,你都使用一个优化器在 fit() 之前 compile(),但在 load_weights() 之后传递了一个不同的优化器给 compile(),这没有问题吗?如果没有,那为什么我们要使用不同的优化器呢?
以前需要编译加载的模型。
我保存了模型和权重。然后我从其他 python 脚本上传模型,它不工作。为什么?
如果保存和加载模型在同一个 python 脚本中,它就会工作。
我对这种行为感到困惑。有什么帮助吗,谢谢。
具体是什么问题?有错误吗?
感谢这篇文章!很有帮助。
不过我有个疑问——
Keras 文档中提到:
"""
你可以使用 model.save(filepath) 将 Keras 模型保存到一个 HDF5 文件中,该文件将包含
– 模型的架构,允许重新创建模型
– 模型的权重
– 训练配置(损失、优化器)
– 优化器的状态,允许从你离开的地方精确恢复训练。
"""
如上所述,它还保存了训练配置(损失、优化器),为什么我们在加载模型和权重后还要再次编译?为什么我们不能直接在测试数据上进行评估?
自从我写这篇教程以来,API 已经发生了变化。你现在可以将模型保存在一个文件中,并且在加载后不再需要编译。
嗨,Jason,
我是 Keras 新手,我非常喜欢你的简短教程——我学到了很多。
也许你可以给我一些建议,如何在更复杂的情况下推广保存/加载网络配置的概念,当两个 Sequential 网络合并成新的 Sequential 网络时,比如这样:
model1 = Sequential()
…
model2 = Sequential()
…
model3 = Sequential()
model3.add(Merge([model1, model2], mode=’concat’))
…
我可以单独保存/加载每个 model[1-3]。但是当我将这 3 个部分重新加载回来后,我不知道如何将它们重新组合在一起?你能帮我如何在从 Yaml 读取 3 个子网络后执行等效的
model3.add(Merge([model1, model2], mode=’concat’)) 吗?
下面是一个简单的玩具代码,只缺少最后一步。
提前感谢
Jan
– – –
cat toy-2LSTM-save-model.py
#!/usr/bin/env python
"""
定义具有 Merge() 的多分支 Sequential 网络
将网络保存到 yaml,
读回它(并丢失一些部分)
"""
import os, time
import warnings
os.environ[‘TF_CPP_MIN_LOG_LEVEL’] = ‘3’ #隐藏凌乱的 TensorFlow 警告
warnings.filterwarnings(“ignore”) #隐藏凌乱的 Numpy 警告
from keras.datasets import mnist
from keras import utils as np_utils
from keras.models import Sequential, load_model, model_from_yaml
from keras.callbacks import EarlyStopping, ModelCheckpoint
from keras.layers import Dense, Dropout, Merge, LSTM
import yaml
print(‘build_model:’)
inp_sh1=(10, 20)
inp_sh2=(11, 22)
print(‘build_model inp1:’,inp_sh1,’ inp2:’,inp_sh2)
lstm_na=30
lstm_nb=40
dens_nc=30
model1 = Sequential()
model1.add(LSTM(lstm_na, input_shape=inp_sh1))
model2 = Sequential()
model2.add(LSTM(lstm_nb, input_shape=inp_sh2 ))
model3 = Sequential()
model3.add(Merge([model1, model2], mode=’concat’))
model3.add(Dense(1, activation=’sigmoid’)) # 只预测 0/1
# 编译模型
model3.compile(loss=’binary_crossentropy’, optimizer=’adam’, metrics=[‘accuracy’])
print(‘input1:’,inp_sh1, ‘input2:’,inp_sh2)
print(‘1st LSTM branch:’)
model1.summary() # 将打印
print(‘2nd LSTM branch:’)
model2.summary()
print(‘final Dense branch:’)
model3.summary()
print(“———– 将模型保存为 YAML ———–“)
yamlRec1 = model1.to_yaml()
yamlRec2 = model2.to_yaml()
yamlRec3 = model3.to_yaml()
with open(‘jan.model1.yaml’, ‘w’) as outfile:
yaml.dump(yamlRec1, outfile)
with open(‘jan.model2.yaml’, ‘w’) as outfile:
yaml.dump(yamlRec2, outfile)
with open(‘jan.model3.yaml’, ‘w’) as outfile:
yaml.dump(yamlRec3, outfile)
print(“———– 从 YAML 读取模型 ———–“)
with open(‘jan.model1.yaml’, ‘r’) as inpfile:
yamlRec1b=yaml.load(inpfile)
model1b = model_from_yaml(yamlRec1b)
model1b.summary() # 将打印
with open(‘jan.model2.yaml’, ‘r’) as inpfile:
yamlRec2b=yaml.load(inpfile)
model2b = model_from_yaml(yamlRec2b)
model2b.summary() # 将打印
with open(‘jan.model3.yaml’, ‘r’) as inpfile:
yamlRec3b=yaml.load(inpfile)
model3b = model_from_yaml(yamlRec3b)
model3b.summary() # 将打印
也许你可以使用函数式 API 定义你的模型,并将其保存为一个单独的模型。
或者,你可以加载单独的模型,并使用函数式 API 将它们重新组合起来。
我有一个关于函数式 API 的帖子计划发布,但在那之前,你可以在这里阅读它:
https://keras.org.cn/getting-started/functional-api-guide/
非常感谢 Jason!
在我切换到 net = concatenate([net1,net2]) 后,它运行得非常顺利。
我附上了一个可用的玩具示例。请随意删除我之前不工作的代码。
再次感谢
Jan
– – – – –
import yaml
from keras.layers import Dense, LSTM, Input, concatenate
from keras.models import Model, load_model, model_from_yaml
input1 = Input(shape=(10,11), name=’inp1′)
input2 = Input(shape=(20,22), name=’inp2′)
print(‘build_model inp1:’,input1.get_shape(),’ inp2:’,input2.get_shape())
net1= LSTM(60) (input1)
net2= LSTM(40) (input2)
net = concatenate([net1,net2],name=’concat-jan’)
net=Dense(30, activation=’relu’)(net)
outputs=Dense(1, activation=’sigmoid’)(net) # 只预测 0/1
model = Model(inputs=[input1,input2], outputs=outputs)
# 编译模型
model.compile(loss=’binary_crossentropy’, optimizer=’adam’, metrics=[‘accuracy’])
model.summary() # 将打印
print(“———– 将模型保存为 YAML ———–“)
yamlRec = model.to_yaml()
with open(‘jan.model.yaml’, ‘w’) as outfile:
yaml.dump(yamlRec, outfile)
print(“———– 从 YAML 读取模型 ———–“)
with open(‘jan.model.yaml’, ‘r’) as inpfile:
yamlRec4=yaml.load(inpfile)
model4 = model_from_yaml(yamlRec4)
model4.summary() # 将打印
干得好,Jan!
您好,我有一个五层模型。我保存了模型,然后我想只加载前四层。您能告诉我这是否可能吗?
我建议加载整个模型,然后重新定义它,移除你不想要的层。
我训练了一个包含 3 个卷积层和 3 个最大池化层的 CNN 用于文本分类。首先从包含 1000 篇文档的数据集中选择前 n 个单词,然后通过在 Glove 嵌入中查找这些单词并附加相应的词向量(如果找到该单词),构建它们的嵌入矩阵。
我测试了验证准确性。我将模型保存为 h5 格式。
现在,我想在另一个 python 文件中加载模型,并用于预测未见文档的类别标签。我使用了以下代码:
from keras.models import load_model
import keras.preprocessing.text
from keras.preprocessing.text import Tokenizer
from keras.preprocessing.sequence import pad_sequences
import numpy as np
import json
MAX_NUMBER_OF_WORDS= 20000
MAX_SEQUENCE_LENGTH = 1000
model1 = load_model(‘my_model.h5’)
f = open(‘/home/siri/Japan_Project/preprocessing/complete_data_stop_words/technology/X.txt’, encoding=’latin-1′)
text = f.read()
#print(text.shape)
tokenizer = Tokenizer(num_words=MAX_NUMBER_OF_WORDS)
tokenizer.fit_on_texts(text)
print(‘\n text = ‘)
print(text)
sequence_list = tokenizer.texts_to_sequences(text)
print(‘\n text to sequences= ‘)
print(sequence_list)
data = pad_sequences(sequence_list, maxlen=MAX_SEQUENCE_LENGTH)
print(data)
print(‘\n np.array(data)’)
print(np.array(data))
prediction = model1.predict(np.array(data))
print(prediction)
y_classes = prediction.argmax(axis=-1)
with open(‘data.json’, ‘r’) as fp:
labels_index = json.load(fp)
print(y_classes)
for k, v in labels_index.items():
print(“\n key= “,k,”val= “,v)
print(‘\n printing class label=’)
for k, v in labels_index.items():
if y_classes[0]==v:
print(“\n key= “,k,”val= “,v)
我的疑问是,我现在没有使用词嵌入作为模型输入,而是使用了 numpy.array(data)。这正确吗?我们能否将词嵌入作为 Keras 的预测函数的输入。
我还在训练后将类别标签索引(类别标签字典)保存到 data.json 文件中,并在这个文件中重新加载它,以了解预测的类别标签。这正确吗?
我不太确定我是否完全理解。
通常,词嵌入是权重,必须作为模型的一部分在嵌入层中保存和加载。
这有帮助吗?
如何检查嵌入层是否已保存?如果已保存,如何将未见文本文档作为输入传递给预测函数?
如果嵌入层是模型的一部分,并且你保存了模型,那么嵌入层将随模型一起保存。
感谢您,Jason,提供宝贵的答案!
我花了一些时间才明白这一点。也就是说,在生产环境中,我只需调用我的模型 (h5) 即可获得词嵌入。
生产代码很难:-/
先生。您在 yolov3.weights 中保存所有项目权重的方式,如何保存我想要的那些项目。
我没有保存它们,我只是展示了如何加载它们。
嗨 Jason
我能够加载权重和模型以及标签编码器,并且已经验证了测试集使用加载的模型给出了相同的预测。
我的问题——即使搜索也找不到明确答案——是当有新的输入进来时,我如何对与此新输入相关的分类变量进行独热编码,以便列的顺序与训练数据完全匹配?
如果无法做到这一点,我在一组新输入上的准确率接近 10%,而验证准确率是 89%。
简单的问题是如何编码分类变量,以便新输入集合的输入数据与训练集匹配?可能不是一个真正的深度学习问题,但如果不这样做,我复杂的 LSTM 模型就无法工作。
非常感谢您的帮助!
你必须使用与训练期间相同的编码。
也许你使用自己的转换代码。
也许你保存了转换对象。
也许你根据训练数据在需要时重新创建转换并确认它是一致的。
这有帮助吗?
嗨,Jason,
我正在使用 pd.get_dummies 将其转换为独热编码矩阵。我如何重用它,因为它不是 Label Encoder 或 One Hot Encoder?我的训练集有 24000 行和 5255 列
当我使用 pd.get_dummies 对 3 个新项目进行操作时,我将得到一个 3 行 6 列的矩阵,这无法输入到模型中,因为模型期望 5255 行。用零填充以弥补不足只会破坏情况,输出准确率在 10% 左右,而验证准确率是 89%;在验证期间没有问题,因为在 pd.get_dummies 执行并将输入 X 转换为独热编码矩阵之后才进行训练测试分割。这似乎是一个奇怪的问题,因为所有使用训练模型进行预测的人都会遇到任何独热编码模型的相同问题,因此应该在网上找到一个简单的解决方案。
有没有办法将 pd.get_dummies 转换为编码器类型对象,然后重新加载并在实时数据上重新使用它。那会使生活变得非常简单……
请告诉我。
谢谢
Arnab
我建议使用 sklearn 编码而不是 pandas 方法,这样你就可以保存对象和/或轻松地反转操作。
你好,
当我将此知识应用于我的代码时,我收到以下错误
##########
跟踪(最近一次调用):
文件“DNNrect_VC_VC_Challenge.py”,第 198 行,在
model.save(path + SRC[sr] + ‘-‘ + TGT[tg] + ‘/DNNerect_25/’+str(NUTTS[nutt])+’/model.hdf5’)
文件“/usr/local/lib/python2.7/dist-packages/keras/engine/topology.py”,第 2429 行,在保存中
save_model(self, filepath, overwrite)
文件“/usr/local/lib/python2.7/dist-packages/keras/models.py”,第 109 行,在 save_model 中
topology.save_weights_to_hdf5_group(model_weights_group, model_layers)
文件“/usr/local/lib/python2.7/dist-packages/keras/engine/topology.py”,第 2708 行,在 save_weights_to_hdf5_group 中
g = f.create_group(layer.name)
文件“/usr/lib/python2.7/dist-packages/h5py/_hl/group.py”,第 41 行,在 create_group 中
gid = h5g.create(self.id, name, lcpl=lcpl)
文件“h5g.pyx”,第 145 行,在 h5py.h5g.create (h5py/h5g.c:2536) 中
ValueError: 无法创建组(符号表:无法初始化对象)
#######################
你能评论一下可能的原因吗?
抱歉,故障原因不明显。
也许可以发布到 stackoverflow?
嗨,Jason,
首先非常感谢你尝试写这篇有价值的博客。非常感谢你。我有一个问题如下:
1) 我正在使用下面的代码训练数据和目标值到 RNN,使用 Keras 训练 1000000 个 epoch,并按照你在此博客中提到的使用 JSON 和 HDF5 将训练好的模型和权重保存到磁盘。“这部分工作正常”,我能够在同一个工作目录中生成 model.h5 和 model.json。现在,通过在同一个目录中使用另一个 python 程序,我想使用训练好的模型和权重,但我传入训练好的模型的任何值,我都会得到与训练时相同的输出。我尝试使用新值进行编译,但也没有帮助。我能做些什么吗?这是我的代码:
rnn3.py [第一个文件,训练 1000000 个 epoch]
=========================================
import numpy as np
来自 keras.models import Sequential
from keras.layers import Dense
from keras.layers import LSTM
from keras.models import model_from_json
data =[688,694.5,700.95,693,665.25,658,660.4,656.5,654.8,652.9,660,642.5,
655,684,693.8,676.2,673.7,676,676,679.5,681.75,675,657,654.1,657,647.1,647.65,
651,639.95,636.95,635,635.5,640.15,636,624,629.95,632.9,622.45,630.1,625,607.4,
600,604.8,616,610.25,585,559.4,567,573,569.7,553.25,560.8,566.95,555,548.9,
554.4,558,562.3,564,557.55,562.1,564.9,565]
target = [691.6,682.3,690.8,697.25,691.45,661,659,660.8,652.55,649.7,649.35,654.1,639.75,654,687.1,687.65,676.4,672.9,678.95,
677.7,679.65,682.9,662.6,655.4,652.8,653,652.1,646.55,651.2,638.05,638.65,630.2,635.85,639,634.6,619.6,621.55,625.65,
625.4,631.2,623.75,596.75,604.35,605.05,616.45,600.05,575.85,559.3,569.25,572.4,567.1,551.9,561.25,565.75,552.95,548.5,
553.25,557.2,571.2,563.3,559.8,558.4,563.95]
#data = [688,694.5,700.95,693,665.25,658,660.4,656.5,654.8,652.9]
data = np.array(data, dtype=float)
#target = [691.6,682.3,690.8,697.25,691.45,661,659,660.8,652.55,649.7]
target = np.array(target,dtype=float)
data = data.reshape((1,1,len(data)))
target = target.reshape((1,1,len(target)))
#x_test=[688,694.5,700.95,693,665.25,658,660.4,656.5,654.8,652.9]
x_test =[688,694.5,700.95,693,665.25,658,660.4,656.5,654.8,652.9,660,642.5,
655,684,693.8,676.2,673.7,676,676,679.5,681.75,675,657,654.1,657,647.1,647.65,
651,639.95,636.95,635,635.5,640.15,636,624,629.95,632.9,622.45,630.1,625,607.4,
600,604.8,616,610.25,585,559.4,567,573,569.7,553.25,560.8,566.95,555,548.9,
554.4,558,562.3,564,557.55,562.1,564.9,565]
x_test=np.array(x_test).reshape((1,1,len(x_test)))
#y_test=[660,642.5,655,684,693.8,676.2,673.7,676,676,679.5]
y_test =[700.95,693,665.25,658,660.4,656.5,654.8,652.9,660,642.5,
655,684,693.8,676.2,673.7,676,676,679.5,681.75,675,657,654.1,657,647.1,647.65,
651,639.95,636.95,635,635.5,640.15,636,624,629.95,632.9,622.45,630.1,625,607.4,
600,604.8,616,610.25,585,559.4,567,573,569.7,553.25,560.8,566.95,555,548.9,
554.4,558,562.3,564,557.55,562.1,564.9,565,688,694.5]
y_test=np.array(y_test).reshape((1,1,len(y_test)))
model = Sequential()
model.add(LSTM(len(data),input_shape=(1,63),return_sequences=True))
model.add(Dense(63))
model.compile(loss=’mean_absolute_error’, optimizer=’adam’,metrics=[‘accuracy’])
model.fit(data,target, nb_epoch=1000000, batch_size=1, verbose=2,validation_data=(x_test,y_test))
# 将模型序列化为JSON
model_json = model.to_json()
with open(“model.json”, “w”) as json_file:
json_file.write(model_json)
# 将权重序列化为HDF5
model.save_weights(“model.h5”)
print(“Saved model to disk”)
# 加载 json 并创建模型
json_file = open(‘model.json’, ‘r’)
loaded_model_json = json_file.read()
json_file.close()
loaded_model = model_from_json(loaded_model_json)
# 将权重加载到新模型中
loaded_model.load_weights(“model.h5”)
print(“Loaded model from disk”)
# 在测试数据上评估加载的模型
loaded_model.compile(loss=’binary_crossentropy’,optimizer=’rmsprop’,metrics=[‘accuracy’])
score = loaded_model.evaluate(data,target, verbose=0)
predict = loaded_model.predict(y_test)
print(predict)
predict = loaded_model.predict(x_test)
print(predict)
我从 rnn4.py 得到的输出
====================
[[[ 691.59997559 682.30004883 690.80004883 697.24987793 691.45007324
661.00012207 658.99987793 660.80004883 652.55004883 649.70007324
649.34997559 654.09997559 639.75 654. 687.09997559
687.65002441 676.40002441 672.90002441 678.95007324 677.70007324
679.65002441 682.90002441 662.59997559 655.40002441 652.80004883
652.99987793 652.09997559 646.55004883 651.20007324 638.05004883
638.65002441 630.20007324 635.84997559 639. 634.59997559
619.59997559 621.55004883 625.65002441 625.40002441 631.20007324
623.74987793 596.74987793 604.34997559 605.05004883 616.45007324
600.05004883 575.84997559 559.30004883 569.25 572.40002441
567.09997559 551.90002441 561.25012207 565.75012207 552.95007324
548.50012207 553.24987793 557.20007324 571.20007324 563.30004883
559.80004883 558.40002441 563.95007324]]]
[[[ 691.59997559 682.30004883 690.80004883 697.24987793 691.45007324
661.00012207 658.99987793 660.80004883 652.55004883 649.70007324
649.34997559 654.09997559 639.75 654. 687.09997559
687.65002441 676.40002441 672.90002441 678.95007324 677.70007324
679.65002441 682.90002441 662.59997559 655.40002441 652.80004883
652.99987793 652.09997559 646.55004883 651.20007324 638.05004883
638.65002441 630.20007324 635.84997559 639. 634.59997559
619.59997559 621.55004883 625.65002441 625.40002441 631.20007324
623.74987793 596.74987793 604.34997559 605.05004883 616.45007324
600.05004883 575.84997559 559.30004883 569.25 572.40002441
567.09997559 551.90002441 561.25012207 565.75012207 552.95007324
548.50012207 553.24987793 557.20007324 571.20007324 563.30004883
559.80004883 558.40002441 563.95007324]]]
rnn4.py [与 rnn3.py 位于同一目录中的第二个文件,希望重用 model.h5 和 model.json]
======================================================================from keras.models import model_from_json
import numpy as np
#x_test =[688,694.5,700.95,693,665.25,658,660.4,656.5,654.8,652.9,660,642.5,
#655,684,693.8,676.2,673.7,676,676,679.5,681.75,675,657,654.1,657,647.1,647.65,
#651,639.95,636.95,635,635.5,640.15,636,624,629.95,632.9,622.45,630.1,625,607.4,
#600,604.8,616,610.25,585,559.4,567,573,569.7,553.25,560.8,566.95,555,548.9,
#554.4,558,562.3,564,557.55,562.1,564.9,565]
x_test =[[i for i in range(63)]]
x_test=np.array(x_test).reshape((1,1,63))
# 加载 json 并创建模型
json_file = open(‘model.json’, ‘r’)
loaded_model_json = json_file.read()
json_file.close()
loaded_model = model_from_json(loaded_model_json)
# 将权重加载到新模型中
loaded_model.load_weights(“model.h5”)
print(“Loaded model from disk”)
loaded_model.compile(loss=’binary_crossentropy’,optimizer=’rmsprop’,metrics=[‘accuracy’])
predict = loaded_model.predict(x_test)
print(predict)
我从 rnn4.py 得到的输出
==================
[[[ 691.59997559 682.30004883 690.80004883 697.24987793 691.45007324
661.00012207 658.99987793 660.80004883 652.55004883 649.70007324
649.34997559 654.09997559 639.75 654. 687.09997559
687.65002441 676.40002441 672.90002441 678.95007324 677.70007324
679.65002441 682.90002441 662.59997559 655.40002441 652.80004883
652.99987793 652.09997559 646.55004883 651.20007324 638.05004883
638.65002441 630.20007324 635.84997559 639. 634.59997559
619.59997559 621.55004883 625.65002441 625.40002441 631.20007324
623.74987793 596.74987793 604.34997559 605.05004883 616.45007324
600.05004883 575.84997559 559.30004883 569.25 572.40002441
567.09997559 551.90002441 561.25012207 565.75012207 552.95007324
548.50012207 553.24987793 557.20007324 571.20007324 563.30004883
559.80004883 558.40002441 563.95007324]]]
问题
========
对于不同的输入值,我们期望在重新编译后得到不同的输出值。为什么我们得到任何输入值都相同的输出?
网络的输出应该具体(取决于)预测时提供的输入。
如果不是这种情况,那么你的模型可能过度拟合了训练数据?
嗨,布朗利,
感谢您的快速回复。我无法理解“网络的输出应该具体(取决于)提供的输入”。你能详细解释一下吗?也许我没有正确理解上下文。
这表明你的网络存在问题,因为不同的输入应该给出不同的输出。
我不知道问题可能是什么,我没有能力调试你的代码。也许这些资源会有所帮助:
https://machinelearning.org.cn/get-help-with-keras/
嗨,Jason,
感谢这篇精彩的帖子。对机器学习新手非常有帮助。
我正在尝试运行下面的代码
model_json = model.to_json()
with open(“model.json”, “w”) as json_file:
json_file.write(model_json)
出现错误“NameError: name ‘model’ is not defined”
你能帮忙吗?
“model”将是你训练好的模型的变量。
很棒的帖子。我可以在本地保存和检索。但在 AWS lambda 中,由于 HDF5 格式,加载权重遇到了问题。你能提供任何解决方案或变通方法吗?
听到这个消息很遗憾。我本来以为 h5 格式是跨平台的。我相信它是。
也许是 Python 2 与 Python 3 的问题。
先生,
请解释一下使用元启发式算法(如萤火虫算法、粒子群优化、头脑风暴优化等)进行特征选择的 python 代码……
感谢您的建议,我希望将来能涵盖这个话题。
加载模型和权重后,我需要编译模型进行评估吗?
我不再需要编译加载的模型了,API 已经改变了。
感谢 Jason 的帖子。我有一个问题。
有没有类似的方法可以输出一个文件,表明模型已经编译?每次我运行文件时,都需要时间来编译模型,然后拟合和评估数据。我想更改参数/变量/超参数并再次运行文件,所以我想尽可能加快速度。
我相信你不再需要编译模型了。
嗨,Jason,
感谢这个博客为开发者提供的宝贵帮助,
我遇到了与上面 @Lotem 相同的问题。
我有一个脚本,它构建了一个模型(准确率为 60%),并将其保存到不同的目录中。
然而,当我将模型加载到另一个脚本中时,准确率却下降到 55%,预测值也不同了。
我已经检查过权重,它们是相同的,
我已经为两个文件都设置了
from numpy.random import seed
seed(1)
from tensorflow import set_random_seed
set_random_seed(2)
,但我仍然无法让加载的模型给出相同的准确率。
我还应该提一下,数据集包含相同的特征。
任何帮助都将不胜感激,因为我一直在原地打转,查看了
https://github.com/keras-team/keras/issues/4875
https://github.com/keras-team/keras/issues/7676
如果可能的话,你能否提供一个在不同会话中保存和加载模型的示例?
再次感谢
有意思,我没有遇到过这个问题。
一些可以探索的想法:
– 你能否在不同的机器上重现相同的故障?例如在 AWS 上?
– 你的所有库都是最新的吗?
– 你是将权重和拓扑保存到一个文件中还是单独的文件中?
– 你 100% 确定保存前后用于评估模型的数据是相同的吗?
嘿,Jason,这个教程很有帮助。
但是,我有一个问题。我训练了一个 LSTM 模型用于序列分类问题,并观察到以下情况:
在与训练模型相同的 python 会话中,我从加载的模型(使用 json 格式)获得了精确的结果(损失、准确率、预测概率)。但是,在新开的 python 会话中,结果并不完全相同,但非常接近。
你能帮我理解为什么结果会略有不同吗?是否需要修复其他 random_seed 才能使结果完全匹配?
期待您的回复。
谢谢,
Tarun
内部状态肯定有一些随机性。
我不太确定。有趣的发现!
嗨!
我需要将我的 LSTM 模型部署为 API,我该如何操作?
非常感谢。
对此我没有资料,抱歉。不过我这里有关于模型投入生产的一般资料,你可能感兴趣
https://machinelearning.org.cn/deploy-machine-learning-model-to-production/
我已经在 https://machinelearning.org.cn/save-load-keras-deep-learning-models/ 中看到了一个基本示例
如何将模型保存为 ini 或 cfg 格式而不是 json
抱歉,不支持其他格式。你可能需要编写自己的代码。
嗨,Jason,
我用 Keras 训练模型,验证准确率约为 50%,但当我按照你提到的代码保存并重新加载模型时,验证准确率只有 5%……加载的模型似乎表现得像未经训练的模型一样。
这很奇怪。我自己没有见过这种情况。也许可以尝试将其作为故障发布到 Keras 问题列表。
https://machinelearning.org.cn/get-help-with-keras/
嗨 Jason
是否有可能在保存现有模型后,我想用新数据重新训练它。假设我的现有模型在 100 个数据集上进行了训练,但一段时间后,我想在新的 50 个数据集上重新训练它,以便它也能学习一些新的数据集以做出良好的预测。这意味着它现在将受到 150 个数据集的影响。
需要你的帮助。
提前感谢。
是的,这里有一个更新模型的示例
https://machinelearning.org.cn/update-lstm-networks-training-time-series-forecasting/
你好,
有没有办法将 h5 和 json 文件转换为一个 hdf5 文件?
我有很多对 h5 和 json 文件,但是当我需要将 keras 模型转换为 tensorflow pb 文件时,需要 hdf5 文件。
谢谢,
是的,Keras 有一个新的 API 可以将模型保存和加载到一个文件中。
https://keras.org.cn/getting-started/faq/#how-can-i-save-a-keras-model
你好,
我正在将 keras 与 tensorflow 后端一起使用,但我的 .h5 文件无法保存,因为它显示未进行 UTF-8 编码 – 因此保存被禁用。
你知道如何解决这个问题吗?
谢谢
我没有见过这种情况。也许可以尝试发布到 Keras 列表。
https://machinelearning.org.cn/get-help-with-keras/
嗨,jason,非常感谢你提供的这个示例,它在处理保存和加载问题时最有帮助。我在将模型保存并加载到与训练模型不同的文件中后,遇到了拟合问题。它一直说模型未拟合。
我尝试在创建和拟合模型的同一文件中进行预测,结果完美无缺。
我保存拟合模型的文件
我试图加载拟合模型的文件
这给了我以下错误
sklearn.exceptions.NotFittedError: 此 StandardScaler 实例尚未拟合。在使用此方法之前,请使用适当的参数调用 'fit'。
-提前感谢
听到这个消息我很难过,我没有见过这个故障。我很乐意提供帮助,但我无法为你调试你的示例,抱歉。
我会继续努力的,无论如何还是谢谢你帮忙查看。
解释得很棒,先生。
谢谢你。
嗨,Jason,
非常感谢这篇出色的教程,非常有帮助。我们可以在 C++ 中加载保存的模型吗?我想用 Python 训练,然后在我自己的 C++ 程序中使用它进行预测。这可能吗?
也许可以。我没有做过。
嘿,你找到在 C++ 中使用训练好的 Python 模型的方法了吗!
https://github.com/Dobiasd/frugally-deep 太棒了。
感谢分享。
嗨,Jason,
感谢这个很棒的教程。
我也读过这篇 [https://machinelearning.org.cn/make-predictions-long-short-term-memory-models-keras/]。但我不知道哪篇教程适合创建模型 =(最终化模型以将其重用于许多未见数据)??
在上面的链接中,我们应该编写 model.save('lstm_model.h5') 来构建一个最终化的模型,并且必须应用 "model = load_model('lstm_model.h5')" 命令来加载它,但在此教程中,您使用了不同的命令来序列化和加载最终模型,例如这些序列化模型的命令 [[model_json = model.to_json()
with open(“model.json”, “w”) as json_file:
json_file.write(model_json)
# 将权重序列化为HDF5
model.save_weights(“model.h5”)
print("Saved model to disk")]]
在本教程中,您使用了不同的命令来序列化模型,也使用了不同的命令来序列化权重
您还应用了不同的命令来加载最终模型,也应用了不同的命令来加载权重,例如 [[ # load json and create model
json_file = open(‘model.json’, ‘r’)
loaded_model_json = json_file.read()
json_file.close()
loaded_model = model_from_json(loaded_model_json)
# 将权重加载到新模型中
loaded_model.load_weights(“model.h5”)
print("Loaded model from disk")]].
我搞不清楚哪个链接适合保存和加载最终化模型(以便多次重用模型来预测未见数据)。是这个链接 = [https://machinelearning.org.cn/save-load-keras-deep-learning-models/] 还是这个 [https://machinelearning.org.cn/make-predictions-long-short-term-memory-models-keras/]???
在本教程中,您使用了不同的命令来序列化模型,也使用了不同的命令来序列化权重。
当您在提及的链接中保存模型时,单个文件将包含模型架构和权重,但在此教程中,您必须使用一些不同的命令来分别保存模型和保存权重。
序列化模型和保存模型有什么区别??
非常感谢您抽出时间指导我。
我真的很感激。
这篇帖子很好地总结了如何最终确定模型
https://machinelearning.org.cn/train-final-machine-learning-model/
通常,在所有可用数据上训练模型,然后将其保存到文件中。稍后加载它并用它开始对新数据进行预测。
使用你喜欢的方法保存模型。你使用哪种方法并不重要。有些开发者对用于保存模型的文件类型有偏好。
这有帮助吗?
嗨,Jason,
我真的很感谢你的回复,但我已经读过这个链接 [https://machinelearning.org.cn/train-final-machine-learning-model/]。
我想您没有理解我的目的。如果我想清楚地提出我的问题,我应该这样说:[此链接中描述的方法有什么区别:(https://machinelearning.org.cn/save-load-keras-deep-learning-models/) 和此链接中解释的方法:(https://machinelearning.org.cn/make-predictions-long-short-term-memory-models-keras/)?
这两种方法都适合保存和加载深度模型吗?
如果我以这种方式保存:(model.save('lstm_model.h5')),然后以这种方式加载模型 (model = load_model('lstm_model.h5')),那么权重和模型架构会随上述命令一起保存到文件中吗?权重和模型架构会随给定命令一起加载吗?
我希望我的问题表达清楚了。
任何回答都将不胜感激
它们是等效的。选择你喜欢的方法,无论是保存到一个文件还是两个文件。
嗨,Jason,
我在加载模型时遇到了一点问题。问题基本上是你的方法导致了以下编译器错误。
ValueError: 两个形状的维度 0 必须相等,但它们是 4096 和 1000。形状是 [4096,5] 和 [1000,5]。对于 'Assign_30' (op: 'Assign'),输入形状为:[4096,5], [1000,5]。
我想最好我也把我创建模型的代码包括进去。
import keras
from keras import backend as K
from keras.models import Sequential, Model
from keras.layers import Activation, Dense
from keras.optimizers import Adam
from keras.metrics import categorical_crossentropy
from keras.preprocessing.image import ImageDataGenerator
from keras.preprocessing import image
from keras.applications.vgg16 import VGG16
train_data_dir = './data/train'
validation_data_dir = './data/validation'
test_path = './data/test'
# 我们图像的维度。
img_width, img_height = 224, 224
if K.image_data_format() == 'channels_first'
input_shape = (3, img_width, img_height)
else
input_shape = (img_width, img_height, 3)
nb_train_samples = 5400
nb_validation_samples = 2000
top_epochs = 10
fit_epochs = 10
batch_size = 20
train_generator = ImageDataGenerator().flow_from_directory(
train_data_dir,
target_size=(img_height, img_width),
batch_size=batch_size,
classes=['backpack', 'Baseball', 'Coffee-mug', 'orange', 'running-shoe'])
validation_generator = ImageDataGenerator().flow_from_directory(
validation_data_dir,
target_size=(img_height, img_width),
batch_size=batch_size,
classes=['backpack', 'Baseball', 'Coffee-mug', 'orange', 'running-shoe'])
vgg16_model = VGG16()
model = Sequential()
for layer in vgg16_model.layers
model.add(layer)
model.layers.pop()
`for layer in model.layers`
layer.trainable = False
model.add(Dense(5, activation=’softmax’))
model.compile(Adam(lr=.0001), loss='categorical_crossentropy', metrics=['accuracy'])
model.fit_generator(train_generator, steps_per_epoch=270,
validation_data=validation_generator, validation_steps=100, epochs=top_epochs, verbose=2)
test_batches = ImageDataGenerator().flow_from_directory(test_path, target_size=(img_width,img_height), classes=['backpack', 'Baseball', 'Coffee-mug', 'orange', 'running-shoe'], batch_size=50)
predictions = model.predict_generator(test_batches, steps=1, verbose=0)
predictions
model.save('classes.h5')
model.save_weights('classes-weights.h5')
model_json=model.to_json()
with open("classes.json","w") as json_file
json_file.write(model_json)
训练和测试后的输出如下:
训练
Epoch 10/10 – 91s – loss: 0.0775 – acc: 0.9985 – val_loss: 0.2168 – val_acc: 0.9570
测试
array([[0.01292046, 0.01129738, 0.9499369 , 0.01299447, 0.01285083],
[0.02066054, 0.9075736 , 0.02441081, 0.02221865, 0.02513652],
[0.01651708, 0.01449703, 0.01844079, 0.93347657, 0.01706842],
[0.01643269, 0.01293082, 0.01643352, 0.01377147, 0.94043154],
[0.02066054, 0.9075736 , 0.02441081, 0.02221865, 0.02513652],
[0.01651708, 0.01449703, 0.01844079, 0.93347657, 0.01706842],
[0.02066054, 0.9075736 , 0.02441081, 0.02221865, 0.02513652],
[0.9319746 , 0.0148032 , 0.02086181, 0.01540569, 0.01695477],
[0.01643269, 0.01293082, 0.01643352, 0.01377147, 0.94043154],
[0.02066054, 0.9075736 , 0.02441081, 0.02221865, 0.02513652],
[0.01643282, 0.01293091, 0.01643365, 0.01377157, 0.940431 ],
[0.01292046, 0.01129738, 0.9499369 , 0.01299447, 0.01285083],
[0.01292046, 0.01129738, 0.9499369 , 0.01299447, 0.01285083],
[0.01651709, 0.01449704, 0.0184408 , 0.93347657, 0.01706843],
[0.01692604, 0.0131789 , 0.01675364, 0.01416142, 0.93898004],
[0.02066054, 0.9075736 , 0.02441081, 0.02221865, 0.02513652],
[0.01292046, 0.01129738, 0.9499369 , 0.01299447, 0.01285083],
[0.02066054, 0.9075736 , 0.02441081, 0.02221865, 0.02513652],
[0.9319746 , 0.0148032 , 0.02086181, 0.01540569, 0.01695477],
[0.01651708, 0.01449703, 0.01844079, 0.93347657, 0.01706842],
[0.01643269, 0.01293082, 0.01643352, 0.01377147, 0.94043154],
[0.01651708, 0.01449703, 0.01844079, 0.93347657, 0.01706842],
[0.01643269, 0.01293082, 0.01643352, 0.01377147, 0.94043154],
[0.9319746 , 0.0148032 , 0.02086181, 0.01540569, 0.01695477],
[0.01651708, 0.01449703, 0.01844079, 0.93347657, 0.01706842],
[0.01643269, 0.01293082, 0.01643352, 0.01377147, 0.94043154],
[0.01292046, 0.01129738, 0.9499369 , 0.01299447, 0.01285083],
[0.9319746 , 0.0148032 , 0.02086181, 0.01540569, 0.01695477],
[0.01292046, 0.01129738, 0.9499369 , 0.01299447, 0.01285083],
[0.01651708, 0.01449703, 0.01844079, 0.93347657, 0.01706842],
[0.9319746 , 0.0148032 , 0.02086181, 0.01540569, 0.01695477],
[0.01292046, 0.01129738, 0.9499369 , 0.01299447, 0.01285083],
[0.01643269, 0.01293082, 0.01643352, 0.01377147, 0.94043154],
[0.01643269, 0.01293082, 0.01643352, 0.01377147, 0.94043154],
[0.02984857, 0.01736826, 0.9126526 , 0.01986017, 0.02027044],
[0.9319746 , 0.0148032 , 0.02086181, 0.01540569, 0.01695477],
[0.02066054, 0.9075736 , 0.02441081, 0.02221865, 0.02513652],
[0.02066054, 0.9075736 , 0.02441081, 0.02221865, 0.02513652],
[0.9319746 , 0.0148032 , 0.02086181, 0.01540569, 0.01695477],
[0.01651708, 0.01449703, 0.01844079, 0.93347657, 0.01706842],
[0.01653831, 0.01302506, 0.01664082, 0.01386674, 0.9399291 ],
[0.0165362 , 0.01452375, 0.01846231, 0.9333804 , 0.01709736],
[0.02066054, 0.9075736 , 0.02441081, 0.02221865, 0.02513652],
[0.9319746 , 0.0148032 , 0.02086181, 0.01540569, 0.01695477],
[0.01643269, 0.01293082, 0.01643352, 0.01377147, 0.94043154],
[0.01651708, 0.01449703, 0.01844079, 0.93347657, 0.01706842],
[0.9319746 , 0.0148032 , 0.02086181, 0.01540569, 0.01695477],
[0.02066054, 0.9075736 , 0.02441081, 0.02221865, 0.02513652],
[0.01292046, 0.01129738, 0.9499369 , 0.01299447, 0.01285083],
[0.9316361 , 0.01485772, 0.02102509, 0.01546398, 0.0170171 ]],
dtype=float32)
两者都非常好。
我之所以包含上面这些,是因为当我尝试如下加载模型时,代码可以编译,但模型的表现非常糟糕,就像从未训练过一样。
import keras
from keras.models import Sequential, Model
from keras.layers import Activation, Dense
from keras.optimizers import Adam
from keras.metrics import categorical_crossentropy
from keras.applications.vgg16 import VGG16
from keras.models import load_model
from keras.preprocessing import image
from keras.applications.vgg16 import preprocess_input, decode_predictions
import numpy as np
import sys
import os
os.environ['TF_CPP_MIN_LOG_LEVEL']='1' # 抑制 GPU 信息
vgg16_model = VGG16()
model = Sequential()
for layer in vgg16_model.layers
model.add(layer)
model.layers.pop()
`for layer in model.layers`
layer.trainable = False
model.add(Dense(5, activation=’softmax’))
model.compile(Adam(lr=.0001), loss='categorical_crossentropy', metrics=['accuracy'])
model.load_weights('classes-weights.h5')
img = image.load_img('n07747607_30848.JPEG', target_size=(224, 224))
x = image.img_to_array(img)
x = np.expand_dims(x, axis=0)
x = preprocess_input(x)
preds = model.predict(x)
print(preds[0])
您的回复将不胜感激
很抱歉,我无法为你调试你的代码。
也许可以把你的代码发到 stackoverflow 上?
代码运行良好。这个问题是许多使用 tensorflow-GPU 训练模型并保存权重以便稍后重新加载的人所面临的。有一个简单的修复方法,即重新训练模型一个 epoch 以恢复训练好的权重。我希望您能知道更好的方法。无论如何,谢谢。
抱歉,我没有遇到过这个问题。
嗨,Jason,一如既往地感谢您提供精彩的内容。我在为一个工作项目时看到了这篇文章。您知道是否可以将权重上传到云存储(例如 Azure Blob 存储)吗?然后在需要使用权重时下载它们,并将其用于进一步训练?
我目前的设置是按给定间隔保存我的权重,同时我也保存我的损失函数。然后我用我的损失值交叉检查,看看哪些权重是最好的(使用 GAN,所以最后一个权重不一定是最好的),并加载最好的模型。
我想没问题,尽管我不知道“Azure Blob 存储”的具体细节。
您可以毫无问题地将它们上传到 Amazon S3。
我真的非常感谢这个精彩的教程……这段代码帮了我很多
谢谢,听到这个我很高兴。
嗨,Jason,
您的博客在我的工作和学习中都帮了我很大的忙。我目前正在云端训练 Keras 模型,我遇到了直接将模型保存到 S3 的问题。
你有什么解决方法吗?
抱歉,我不知道如何直接保存到 S3。
我可以用同样的方法保存其他模型吗?
LRN、SVM、KNN 模型,或者有其他方法吗?
你可以使用 pickle 来保存/加载其他模型,这里有说明
https://machinelearning.org.cn/save-load-machine-learning-models-python-scikit-learn/
谢谢 Jason。一篇非常需要且解释得很好的博客。
很高兴它有帮助。
嗨,Jason,
我正在加载 VGG16 预训练模型,添加几个全连接层并微调基础 VGG16 的最后 5 层。我正在多个 GPU 上训练我的模型。我在训练前后保存了模型。尽管 layers.trainable = True,权重仍然相同。
请帮忙!
这是代码
from keras import applications
from keras import Model
model = applications.VGG16(weights = "imagenet", include_top = False, input_shape = (224,224,3))
model.save('./before_training')
`for layer in model.layers`
layer.trainable = False
for layer in model.layers[-5:]
layer.trainable = True
x = model.output
x = Flatten()(x)
x = Dense(1024, activation = "relu")(x)
x = Dropout(0.5)(x)
x = Dense(1024, activation = "relu")(x)
predictions = Dense(2, activation = "softmax")(x)
model_final = Model(input = model.input, output = predictions)
from keras.utils import multi_gpu_model
parallel_model = multi_gpu_model(model_final, gpus = 4)
parallel_model.compile(loss = "categorical_crossentropy" ..... )
datagen = ImageDataGenerator(....)
early = EarlyStopping(...)
train_generator = datagen.flow_from_directory(train_data_dir,...)
validation_generator = datagen.flow_from_directory(test_data_dir,...)
parallel_model.fit_generator(train_generator, validation_data = valiudation_generator,...)
model_final.save('./after_training)
这很令人惊讶。
我有一些建议可能会有所帮助
https://machinelearning.org.cn/faq/single-faq/can-you-read-review-or-debug-my-code
if test_image.size != target_size
test_image = test_image.resize(target_size)
x = image.img_to_array(test_image)
x = np.expand_dims(x, axis=0)
x = preprocess_input(x)
preds = loaded_model.predict_classes(x)
print(preds)
我使用了上面的代码来预测单张图片,我得到了这样的输出
[[1]]
那是什么意思??
如果我想知道模型预测的图像名称以及每个类别的概率,我该怎么做。
它预测的是类别 1。
这篇帖子会告诉你如何预测概率
https://machinelearning.org.cn/how-to-make-classification-and-regression-predictions-for-deep-learning-models-in-keras/
很棒的博文和照片……我认出了2013年去世的魁北克雕塑家“罗伯特·鲁西尔”的作品。
谢谢,观察得很仔细!
嗨,杰森,
如何创建一个配置文件,以便我可以在不编辑原始CNN python脚本的情况下更改配置文件中的 epoch 大小、批处理大小、CNN 层数等?
当然,这都只是代码。你可以用任何你想要的方式实现它。
嗨 Jason,如果我在 Linux 操作系统上创建了一个 Keras 深度学习脚本,并且我的模型输出是 HD5……我该如何将其部署到另一台计算机上?
我的 Linux 工作站位于办公室,我想在现场的 Windows 笔记本电脑上使用我的模型。我的 Windows 笔记本电脑上安装了 Keras,但是当我尝试使用
keras load_model
加载模型时,我收到一个错误,提示 Tensorflow 未安装。我甚至懒得在我的 Windows 笔记本电脑上尝试安装 TensorFlow,因为我认为 TensorFlow 不能在 Windows 上运行,对吗???有什么建议可以尝试吗??谢谢!
该模型只是一个 n 维数字数组(权重)。
您可以使用 Python 代码(或其他语言)手动进行预测,也可以使用 Keras+TF 库进行预测。
如何部署模型实际上是一个工程决策。
你能给我一个建议(或链接到你的文章之一),告诉我如何在我的这边尝试一些不同的方法吗?除了 Keras load_model 方法之外,还有什么不同的方法可以在 Python 中保存深度学习模型?谢谢你……
是的,我的意思是你可以使用原始权重遍历输入通过网络的前向传播。
如果你是新手,这篇帖子可能会给你一些想法
https://machinelearning.org.cn/implement-backpropagation-algorithm-scratch-python/
嗨,Jason,
我对此有点了解……根据我所读到的,模型只是经过训练的权重。但是,如果一个深度学习模型是在 Keras 中训练的,是否还有其他方法可以在不使用 Keras 的情况下加载/保存模型?所有这些都源于想将模型部署到 Windows 操作系统,但模型是在 Linux 操作系统上训练的,当我使用 Keras load_model 方法时,我在 Windows 中收到一个错误,因为我没有安装 Tensorflow……
我只是想弄清楚如果我无法在 Windows 操作系统上安装 Tensorflow,我能做些什么。谢谢!
是的,理论上我不明白为什么你不能编写一些 Python 代码来使用已保存的 h5 中的权重进行预测。
对于 MLP 来说这将非常容易,对于其他网络类型则需要一些工作。
我没有这样做过,所以这只是一个即兴的意见。
我之前已经成功地对 statsmodels 中的回归模型做过这个。
model.save('model.h5')
## 然后过了一会儿
my_model = load_model('model.h5')
## 为什么这种方式会给我带来错误:
NameError: name 'tf' is not defined
抱歉,我没有见过这个错误。
也许检查一下你是否安装了最新版本的库?
我正在尝试在此页面保存模型:https://www.depends-on-the-definition.com/guide-sequence-tagging-neural-networks-python/
代码的准确率约为98%,但是当我按照您上面描述的方式保存模型并重新运行代码以从加载的模块进行预测后,预测结果混乱,准确率在随机执行后下降到3%、4%、20%。我认为训练期间学习的嵌入没有保存。我还尝试使用 mode.save(path) 和 keras.reload_model() 保存整个模型,但它不起作用。
我还尝试保存 word2idx 字典以保留词汇索引,但不幸的是,它不起作用。
请帮我一下。谢谢
听到这个消息我很难过,也许有一个bug。
我建议发布到 Keras 支持
https://machinelearning.org.cn/get-help-with-keras/
嘿 Jason,
我有一个问题,我们能否在加载模型后再次训练它。例如,在执行 load_model 命令后,我们能否使用新数据再次训练同一个模型?如果可以,如何操作??
是的,加载它并再次调用 fit()。
你好,Jason。
我正在使用 Keras 进行深度学习,并阅读您的 Keras 教程,我有一个问题想请教您。
如果我们使用 Keras 构建和训练一个带有 CuDNN 层和 dropout 层的顺序深度网络,并且训练是在配备 GPU 的机器上完成的,我们打算部署这个模型,我们是否需要在配备 GPU 的 Docker 或任何其他容器上部署这个模型,或者是否有办法在轻量级的 CPU 机器上部署它,或者有什么其他技巧?
谢谢。
通常,Keras 模型可以在 CPU 或 GPU 上运行。我不知道 CuDNN 层的情况。
嗨 Jason,
精彩的帖子,
遇到一个错误。
我训练了一个 LSTM 来预测 r、g、b 值。我将模型保存为 json,并将权重保存为 .h5 文件。但是当我再次加载它时,它给我的准确率相同,但预测结果却截然不同。我不确定问题出在哪里,验证准确率前后都相同。
有趣,我没见过这个问题。
也许可以尝试在 Keras 用户组上发帖
https://machinelearning.org.cn/get-help-with-keras/
是否可以组合多个模型?我们可用的集群有多个节点,每个节点有2个GPU。我们正在考虑划分数据集,在每个节点上运行每个子集,保存模型,然后将所有保存的模型组合成一个以进行最终预测。这听起来是利用多个节点上更多GPU的正确想法吗?
听起来像一个集成,也许可以尝试集成方法并与单个模型进行比较。如果看起来不错,那就加倍努力。
json_file = open('DNN061061.json', 'r')
loaded_model_json = json_file.read()
json_file.close()
DNN = model_from_json(loaded_model_json)
# 将权重加载到新模型中
DNN.load_weights("DNN061061.h5")
print(“Loaded model from disk”)
# 评估加载的模型在测试数据上的表现
DNN.compile(loss='categorical_crossentropy', optimizer='adam', metrics=['accuracy'])
score = DNN.evaluate(X, Y, verbose=0)
print("%s: %.2f%%" % (loaded_model.metrics_names[1], score[1]*100))
我保存了模型并加载它进行预测。
我发现得分不一样。它下降了。为什么?
这很令人惊讶。也许这是一个bug?尝试发布到 Keras 用户组或 Stack Overflow?
https://machinelearning.org.cn/get-help-with-keras/
嗨。
Jason,感谢您分享的帖子。它真的很有帮助。我有一个问题
我有一个这样的列表。
list=[1,2,3,[[3,4,5]]]
我想把它转换成一个 ndarray。
等待你的回复。
也许可以将编程问题发布到 stackoverflow。
我构建了一个模型并执行了 fit 函数,然后将该模型保存为 JSON 文件。当我加载保存的模型时,训练过的权重已加载,但如果我在另一个 Jupyter Notebook 单元格中检查权重,我发现权重和偏差返回到它们的初始未训练值?!!!!问题出在哪里?
JSON只包含结构。您必须将权重保存到h5文件中。
嗨 Jason
在训练和保存加载的模型后,如何预测单个数据输入的输出?实际上,我需要知道如何对训练过的模型使用预测函数。
我在这里展示了如何进行预测
https://machinelearning.org.cn/how-to-make-classification-and-regression-predictions-for-deep-learning-models-in-keras/
我用以下方法进行预测
print(X[5])
AA = np.array(X[5]) ;
AA.reshape(1, 8)
print(AA)
prediction = model.predict(AA)
print(prediction)
但我收到此错误
ValueError: Error when checking input: expected dense_1_input to have shape (8,) but got array with shape (1,)
数组上的 reshape 方法不会原地重塑数组。您必须将返回的值赋给一个变量。
所以只需更改
AA.reshape(1, 8)
推广到
AA = AA.reshape(1, 8)
它应该可以工作。
我相信您的模型需要一维数组,而不是二维数组。
嗨 Jason,非常感谢您的帖子。
我可以问一下如何存储 lstm 模型吗?我尝试使用 model.save() 和 load_model()。我在训练后直接使用模型进行预测和加载模型进行预测之间得到了非常不同的结果。
这可能是因为 LSTM 模型不仅包含模型和权重,还包含内部状态。是否有办法同时恢复内部状态?
提前感谢。
是的,使用 save() 和 load_model()。
我预计内部状态在模型保存时会清除。如果您需要此状态,您可以单独保存它。
我建议在 Keras 用户组上发布一个关于这个的问题
https://machinelearning.org.cn/get-help-with-keras/
嗨,先生,非常感谢您非常有用的文章和您的回复。
在我构建模型、编译、拟合之后,我将模型序列化为 JSON,将权重序列化为 hdf5,如上所述。模型保存到 json 文件中,但权重无法保存,我得到一个乱码和问号的不可读文件,并收到错误消息
模型已保存到磁盘
忽略的异常: <bound method BaseSession.__del__ of >
回溯(最近一次调用)
File “C:\Users\SONY\PycharmProjects\multiclass_face_recognition\venv\lib\site-packages\tensorflow\python\client\session.py”, line 702, in __del__
File “C:\Users\SONY\PycharmProjects\multiclass_face_recognition\venv\lib\site-packages\tensorflow\python\framework\c_api_util.py”, line 31, in __init__
TypeError: ‘NoneType’ object is not callable
Process finished with exit code 0
请您帮我解决这个问题,我将不胜感激。非常感谢。
也许尝试从命令行运行示例,并确保您的库是最新的?
好的,谢谢您的建议。
嗨 Jason,我不太明白那一行
loaded_model = model_from_json(loaded_model_json)
model_from_json 部分从何而来?我应该如何定义它?
谢谢你。
这是一个我们从 Keras 库导入的函数。
嗨,Jason,
感谢这个精彩的教程。我有一个问题,为什么您对初始编译和加载模型后的编译使用不同的优化器?
非常感谢!
完全没有理由,抱歉造成困惑。
嗨 Jason,
我只是想创建并加载基于 Keras 构建的 yolo3 模型,例如:
# 将模型序列化为 YAML
model_yaml = model.to_yaml()
with open(“model.yaml”, “w”) as yaml_file
yaml_file.write(model_yaml)
model.save_weights(“model.h5”)
# 加载 YAML 并创建模型
yaml_file = open('model.yaml', 'r')
loaded_model_yaml = yaml_file.read()
yaml_file.close()
loaded_model = model_from_yaml(loaded_model_yaml)
# 将权重加载到新模型中
loaded_model.load_weights(“model.h5”)
但出现了一些错误,如下所示:
回溯(最近一次调用)
File "D:/softwaree/MyPrgrams/VOCdefects/train.py", line 291, in
yolo.runTrain()
File "D:/softwaree/MyPrgrams/VOCdefects/train.py", line 270, in runTrain
loaded_model = model_from_yaml(loaded_model_yaml)
File "D:\softwares setup\anaconda3.5\lib\site-packages\keras\models.py", line 330, in model_from_yaml
return layer_module.deserialize(config, custom_objects=custom_objects)
File "D:\softwares setup\anaconda3.5\lib\site-packages\keras\layers\__init__.py", line 55, in deserialize
printable_module_name='layer')
File "D:\softwares setup\anaconda3.5\lib\site-packages\keras\utils\generic_utils.py", line 140, in deserialize_keras_object
list(custom_objects.items())))
File "D:\softwares setup\anaconda3.5\lib\site-packages\keras\engine\topology.py", line 2500, in from_config
process_node(layer, node_data)
File "D:\softwares setup\anaconda3.5\lib\site-packages\keras\engine\topology.py", line 2459, in process_node
layer(input_tensors, **kwargs)
File "D:\softwares setup\anaconda3.5\lib\site-packages\keras\engine\topology.py", line 603, in __call__
output = self.call(inputs, **kwargs)
File "D:\softwares setup\anaconda3.5\lib\site-packages\keras\layers\core.py", line 651, in call
return self.function(inputs, **arguments)
File "D:\softwaree\MyPrgrams\VOCdefects\yolo3\model.py", line 375, in yolo_loss
grid, raw_pred, pred_xy, pred_wh = yolo_head(yolo_outputs[l],
NameError: name 'yolo_head' is not defined。
我不知道为什么会出现错误,因为我在 model.py 中找到了 'yolo_head' 的定义
也许把你的问题发布到stackoverflow上?
您好,先生,我开始学习机器学习,现在深入研究深度学习
我使用 Keras 创建了自己的 CNN,并保存和加载了我创建的模型。
现在,我不知道如何使用加载的模型进行预测……
你能解释一下预测图像的代码吗
也许这个教程会有帮助
https://machinelearning.org.cn/how-to-make-classification-and-regression-predictions-for-deep-learning-models-in-keras/
太棒了,先生
谢谢,我很高兴它有所帮助。
我能够加载 Keras 中已经训练过的模型。但是我们能否在已经训练过的模型上增加模型?
如果模型获得新数据,它不应该从头开始,它必须与已经训练过的模型一起开始训练。
请帮我解决这个需求。
我希望在新数据上训练已经训练过的模型,而不是从头开始。
是的,使用新数据再次调用 fit()。
它会运行良好,不会从头开始。
嗨,Jason,
谢谢你的教程,它真的帮助了我。
然而,有几件事我不明白。
首次编译模型时,您使用“adam”作为优化器。
但是当你加载保存的模型时,你却使用 RMSprop 作为优化器。
这是为什么?难道不应该再次使用“adam”优化器吗,还是这不太重要?
我还看到您发布了一个使用 Pickle 和 Joblib 序列化和保存模型的教程。
是否有“最佳选择”来保存您的模型?使用 Pickle 或 Joblib 保存模型时,您似乎不会重新编译模型?这是为什么?是不是因为权重是单独保存到 h5 文件中的 json/yaml,而使用 Pickle/Joblib 时,权重是随主模型一起保存的?
提前感谢您的时间,
Jonas Boecquaert
理想情况下应该使用相同的优化器,听起来像是个打字错误。不过没关系,它没有被使用。
据我所知,你不能用 pickle 处理 Keras 模型。
是否可以将整个模型(权重和架构)保存/加载到 json 文件?或者有没有可能在不使用 h5 文件的情况下保存整个模型?
不,权重保存在 h5 中。您可以将整个模型通过 model.save() 保存到 h5。
好的。那么我能把这个H5文件转换成其他文件扩展名,比如.CSV或.mat吗?
谢谢
我不确定它是否是直接映射。
您可以设计自己的映射,然后加载 h5 文件,枚举层和权重,并以您希望的任何格式输出。
我没有工作示例,但这应该很简单。
我使用 keras 训练了 rnn(lstm) 模型分类,之后我对 X_test 数据进行了 model.predict_classes(X_test ),我得到了准确的结果,但是当从 h5 文件加载模型并从 json 文件加载配置到另一个文件时,我得到了随机预测。
请就此问题给我建议,为什么我从文件加载后得不到正确的预测。
抱歉,我没有见过这个问题,这听起来像是一个bug。也许使用有效的方法或者向 Keras 用户组报告这个bug?
在使用模型预测新的csv文件后,如何保存预测结果?另外,我的预测准确率很低,如何提高?
请参阅此处的文档
https://pandas.ac.cn/pandas-docs/stable/indexing.html#ix-indexer-is-deprecated
(147725, 3, 14) (147725,)
模型已从磁盘加载
准确率:20.32%
谢谢。
预测结果将是一个numpy数组,您可以使用save()函数保存numpy数组
https://docs.scipy.org.cn/doc/numpy/reference/generated/numpy.save.html
from tempfile import TemporaryFile
aa=[x for x in range(200)]
plt.plot(aa, inv_y[:200], marker='.', label="actual")
plt.plot(aa, inv_yhat[:200], 'r', label="prediction")
plt.ylabel('Global_active_power', size=15)
plt.xlabel('Time step', size=15)
plt.legend(fontsize=15)
plt.show()
model_yaml = model.to_yaml()
np.save(outfile, yaml_file)
with open("/model.yaml", "w") as yaml_file
yaml_file.write(model_yaml)
yaml_file.close()
# 将权重序列化为HDF5
model.save_weights("/model.h5")
print(“Saved model to disk”)
outfile = TemporaryFile()
像这样吗???
我应该保存哪个变量?
看起来我们需要使用model.model来调用“to_json()”函数,请问您使用的是哪个版本?
该示例适用于Keras 2,有关to_json()的更多信息,请参阅
https://keras.org.cn/models/about-keras-models/
Jason,您能给我一个关于如何将Keras模型保存为pickle的提示吗?我正在使用您的帖子“使用Python中的Keras深度学习库进行回归教程”中的代码,并且模型是通过以下函数创建的:
def larger_model():
而不是model.fit
方法......我有什么方法可以使用Keras API来保存pickle吗?谢谢我建议将模型保存为H5格式,而不是pickle,抱歉我无法帮助您使用pickle保存模型。
Jason,您好,我在Ubuntu中训练了一个模型,并保存了模型
loaded_model.load_weights("demandFinal.h5")
然后希望将该保存的.h5文件传输到我的Windows 10笔记本电脑(运行IPython anaconda 3.7发行版)上进行预测……但是我遇到了一些问题……
除了Keras之外,我的Windows笔记本电脑上还需要安装Tensorflow等深度学习库吗?
或者有没有其他方法可以保存模型,例如YML或json,以便在非创建模型的机器上使用该模型???
谢谢..
是的,后端(TensorFlow)和包装库(Keras)都需要安装。
嗨,Jason 先生
我目前正在进行一个针对推文情感分析的二元分类深度学习项目,我训练了我的深度学习模型并保存了其模型和权重……问题是当我加载模型进行预测时,为什么这个模型总是对每个测试数据集给出相同的输出。例如:模型总是对所有测试数据集给出输出0,这导致我的准确率只有大约47% - 50%
我尝试对我的数据集和模型参数进行了几次更改,例如创建平衡数据集、更改激活函数、学习率、 epoch 数量、批次大小、简化模型,但所有这些都没有显示出改进
那么我该如何解决这个问题?
谢谢..
我有一些建议和系统化的方法可以尝试,请看这里
https://machinelearning.org.cn/start-here/#better
哇,太棒了,这正是我需要的……谢谢先生
很高兴听到这个消息。
感谢您的所有信息。我经常被引导到这里。
Y_true 和 y_pred 是张量。它们与列表或 DataFrame 有何不同?我正在处理一个二元分类问题,所有模型都产生了太多的误报。我想要创建一个度量来最大化非误报。到目前为止,我只是返回
K.sum(y_true – y_pred, axis = )
我得到一个浮点数。我期望一个整数。使用 axis 1 或 0 会得到不同的结果,但我并不知道我是在哪个轴上求和。
所有的指标都试图最大化吗?
也许可以从现有的指标(例如精确率或召回率)开始,您可以从这里开始
https://machinelearning.org.cn/how-to-calculate-precision-recall-f1-and-more-for-deep-learning-models/
您不知道,我从您的博客中学到了多少……我是一名机械工程师,出于热情开始使用机器学习。每次我搜索机器学习相关内容时,您的博客都会是前三个结果之一(另一个是stackoverflow)。您真是把香蕉剥好皮喂到我们嘴里。干得太棒了,老板!!!!
谢谢,很高兴这些教程有帮助!
嗨,Jason 先生
我想问一下:模型可以重新加载并继续用于训练吗?这是基于之前的数据继续增加数据训练吗?换句话说,您可以使用大量数据进行预测并增加时间。在之前的基础上,是这样吗?谢谢!
是的。您可以稍后加载模型并继续训练。
嗨,Jason,
我正在构建一个Conv1D模型进行多标签分类。
首先,我将数据集分为70%训练集、20%测试集和10%验证集。
训练一完成,我就进行测试,准确率达到了76%。
但是,使用model.save(...)函数将模型保存到.h5文件后。并在不同的会话中加载此文件后,预测结果令人失望。现在在不同的数据集上的准确率约为25%。
我使用相同的预处理步骤来清理评论。
除了使用新的tokenizer实例来fit_on_texts,texts_to_sequences和pad_sequences,并使用与训练时使用的tokenizer相同的maxlen。
如果您对这种准确率差异有任何建议,请告诉我。
谢谢,
Achira。
如果您正在处理文本,您还必须以相同的方式在相同的数据上准备分词器,或者将分词器与模型一起保存。
你好,Jason。
我想我找到了问题所在。是的,您说得对。
模型的保存和加载工作正常,符合预期。
但问题在于文本数据的分词和将标签转换为分类。
1) 是的,使用训练设置中的相同分词器实例是有效的,但我尝试使用pickle保存分词器实例,但这没有任何改变。保存和加载的代码如下。或者您对保存分词器有什么建议吗?
# 保存
with open('tokenizer.pickle', 'wb') as handle
pickle.dump(tokenizer_train, handle, protocol=pickle.HIGHEST_PROTOCOL)
# 加载分词器
tokenizer = Tokenizer()
with open('tokenizer.pickle', 'rb') as handle
tokenizer = pickle.load(handle)
2) 我正在使用to_categorical将标签(0到5)转换为one hot向量。我在训练会话和测试会话中都使用了下面的代码片段。但是,在测试时,这样做会给我错误的准确率,而使用训练会话中已经转换过的值则会给我正确的准确率。您认为我们也需要以某种方式保存这个吗?
test_revs = pd.read_csv('hotel_reviews_test.csv') # 从csv中获取评论到数据框
test_revs.loc[:, 'rating'] = test_revs['rating'].apply(points_to_class)
Y_test = to_categorical(test_revs['rating'], 5) # 转换为one hot向量,5为类别数
我有点卡在这个阶段,如果您能帮忙,我会很感激的 🙂
谢谢!
天哪,你救了我这一周,史蒂夫,太感谢你了,应该说索引器是随机构建的
Jason,您好,我创建了一个包含2个类别的Keras CNN序贯模型,现在想在不从头开始重新训练模型的情况下,向该模型添加2个类别。请问您是否有相关的博客/代码?
很好的问题!
也许您可以将所有权重作为起点,然后添加一个新的输出层。然后只训练输出层,并可能对其他层进行微调。
先生,您能告诉我如何通过使用.h5文件来预测我的数据吗?
是的,您可以按照此过程进行操作
https://machinelearning.org.cn/start-here/#process
你好,如何将lstm网络保存为numpy数组?我需要训练好的模型是numpy数组格式的,请帮帮我
抱歉,您无法直接执行此操作。
相反,我建议您将模型保存为H5文件。
这两种方法中,哪种是保存和加载模型的首选方式?
1. 分离模型结构和权重文件
2. 单个文件包含两者
两者合一的单个文件。
嗨,Jason,
我创建了自己的Keras指标,名为correlation_coefficient。
我成功保存了模型,并创建了一个model.h5文件。
但是,当我尝试加载模型时,模型无法识别我的自定义指标,并出现以下错误
ValueError: Unknown metric function:correlation_coefficient
是的,您在加载模型时必须指定 custom_objects 参数,并传入一个字典,将函数名称映射到实际函数。
例如
嗨,Jason,
我有一个sklearn模型和一个keras序贯模型,这两个模型我都使用base64编码保存了(Keras_model.fit(X_train, y_train, batch_size = 100, epochs = 200) 和 randomForest.fit(X_train, y_train)),
我通过保存然后编码为base64,将Keras_model和randomForest读取为字节,
在本地脚本中读取这两个模型进行预测时,它工作得很好,
但在Flask API中,randomForest可以工作,但Keras模型显示
from tensorflow.core.framework.graph_pb2 import *
from google.protobuf import descriptor as _descriptor
ImportError: cannot import name ‘descriptor’ from ‘google.protobuf’ (unknown location)
使用python 3.7,您能帮我解决这个问题吗。
抱歉,我无法帮助您解决此问题,也许可以尝试将代码和错误发布到stackoverflow?
嗨,Jason,
从保存的文件加载权重和模型后,如果我需要微调模型,该如何做?只是使用新数据集的fit命令吗?
没错,使用fit命令并结合数据,也许可以降低学习率。
嗨,Jason,
我的模型在训练后输出.h5格式的权重,我希望将它们转换为.weight格式,有什么方法可以转换它们,或者有什么方法可以在训练时将权重保存为.weight格式
.weight格式是什么?
这是一个包含从darknet框架获得的权重的文件
假设总epoch数为200,但训练时间太长,所以我首先想训练50个epoch,然后重新开始另一个训练,以此类推,但在所有训练阶段,训练数据都是相同的完整数据。在这种情况下,最后一个方法(权重和架构一起)会起作用吗?这与我一次性训练所有200个epoch而不是50个epoch * 4个阶段相同吗?
是的,如果学习率恒定,对同一模型进行4次50个周期的运行与1次200个周期的运行是相同的。
如何从json文件加载模型?
如下
你好 Jason,
非常感谢您分享您的知识和专业经验!
我正在使用一个具有2个输出(即预测)的LSTM Keras模型,用于槽位和意图填充。当我保存然后加载它(以json、yaml和单个文件格式)时,它提供了随机结果。这似乎是模型与加载的权重不匹配:模型在保存前有84%的准确率,加载后只有20%。
我不明白哪里出了问题.. 提前感谢您的帮助。
这是我的代码:
—— 代码——
inputs = Input(shape=(20, 300))
x = LSTM(64, return_sequences=True)(inputs)
x = Dropout(0.3)(x)
a = LSTM(64, return_sequences=True)(x)
a = Dropout(0.3)(a)
b = LSTM(64, return_sequences=False)(x)
b = Dropout(0.3)(b)
main_output = Dense(57, activation='softmax', name='main_output')(a)
auxiliary_output = Dense(12, activation='softmax', name='aux_output')(b)
model = Model(inputs=inputs, outputs=[main_output, auxiliary_output])
这很令人惊讶。
您在保存前后是否在相同的数据上评估模型?
您是否同时保存和加载了权重和结构?
你好 Jason Brownlee
非常感谢您留下了这么好的教程
我有一个问题,您还好吗?
首先,这里是HDF文件,
如果我们认为我们已经收集了新数据(分类是相同的)。
那么当我加载该模型并将其应用于新数据进行预测时
我们得到的值是否正确?
我正在为此问题而苦恼。
当新数据进来时,我们是否应该重新训练?
谢谢!
您可以决定在新数据到来时是否重新训练模型。
只有当您能确认重新训练将使模型在未来表现更好时,重新训练才有意义。也许可以为您的特定数据集/领域测试这个想法。
感谢您分享宝贵的机器学习经验。
我有一个关于使用Keras和TensorFlow加载和使用预训练模型的问题。
我加载并使用了.h5文件,但在我的笔记本电脑上需要半小时才能得到结果。但在另一台台式机上,只需1秒钟就能得到结果!您知道我的笔记本电脑出了什么问题吗?或者我应该修改哪些设置才能运行它?
谢谢。
这很奇怪。
也许笔记本电脑的内存不足或CPU性能不够?
这我也猜到了,但是我的笔记本电脑有更好的内存和CPU。我也检查了不同的电脑。我发现在虚拟机、conda和virtualenv中,这些程序运行大约30分钟才能得到结果。我尝试在另一台电脑上用pip3命令安装tensorflow,它可以在1-2秒内得到结果。根据您的经验,通过pip3安装包并在终端直接运行是否会比在虚拟环境或PyCharm或Anaconda Spyder中更快?
谢谢!
我建议始终使用命令行。许多读者最终在使用笔记本和IDE时遇到问题。
嗨,Jason,
我正在使用python 3和spyder。
我正在尝试将VGG 19用于我的应用程序,但我没有使用Keras
我正在使用PyTorch。
但h5py文件因连接重置而无法下载。
我想要下载并保存权重。
你能告诉我这些权重应该保存在哪里以及如何运行程序吗。
提前感谢。
我收到以下堆栈跟踪
runfile(‘C:/Users/CoE10/Anaconda3/Lib/TST/TransferLearning_VGG_UCUM.py’, wdir=’C:/Users/CoE10/Anaconda3/Lib/TST’)
Downloading: “https://download.pytorch.org/models/alexnet-owt-4df8aa71.pth” to C:\Users\CoE10/.cache\torch\checkpoints\alexnet-owt-4df8aa71.pth
15.0%
回溯(最近一次调用)
File “”, line 1, in
runfile(‘C:/Users/CoE10/Anaconda3/Lib/TST/TransferLearning_VGG_UCUM.py’, wdir=’C:/Users/CoE10/Anaconda3/Lib/TST’)
File “C:\Users\CoE10\Anaconda3\envs\tarakeras\lib\site-packages\spyder_kernels\customize\spydercustomize.py”, line 827, in runfile
execfile(filename, namespace)
File “C:\Users\CoE10\Anaconda3\envs\tarakeras\lib\site-packages\spyder_kernels\customize\spydercustomize.py”, line 110, in execfile
exec(compile(f.read(), filename, 'exec'), namespace)
File “C:/Users/CoE10/Anaconda3/Lib/TST/TransferLearning_VGG_UCUM.py”, line 43, in
model=models.alexnet(pretrained=True)
File “C:\Users\CoE10\Anaconda3\envs\tarakeras\lib\site-packages\torchvision\models\alexnet.py”, line 63, in alexnet
progress=progress)
File “C:\Users\CoE10\Anaconda3\envs\tarakeras\lib\site-packages\torch\hub.py”, line 485, in load_state_dict_from_url
download_url_to_file(url, cached_file, hash_prefix, progress=progress)
File “C:\Users\CoE10\Anaconda3\envs\tarakeras\lib\site-packages\torch\hub.py”, line 406, in download_url_to_file
buffer = u.read(8192)
File “C:\Users\CoE10\Anaconda3\envs\tarakeras\lib\http\client.py”, line 457, in read
n = self.readinto(b)
File “C:\Users\CoE10\Anaconda3\envs\tarakeras\lib\http\client.py”, line 501, in readinto
n = self.fp.readinto(b)
File “C:\Users\CoE10\Anaconda3\envs\tarakeras\lib\socket.py”, line 589, in readinto
return self._sock.recv_into(b)
File “C:\Users\CoE10\Anaconda3\envs\tarakeras\lib\ssl.py”, line 1071, in recv_into
return self.read(nbytes, buffer)
File “C:\Users\CoE10\Anaconda3\envs\tarakeras\lib\ssl.py”, line 929, in read
return self._sslobj.read(len, buffer)
ConnectionResetError: [WinError 10054] 现有连接被远程主机强制关闭
抱歉,我没有PyTorch的教程,也许可以尝试在stackoverflow上发帖?
为什么我总是收到这个异常
JSONDecodeError: Expecting value: line 1 column 1 (char 0)
当我尝试运行这个时
loaded_model=model_from_json(loaded_model_json)
很抱歉听到这个消息,我在这里有一些建议。
https://machinelearning.org.cn/faq/single-faq/why-does-the-code-in-the-tutorial-not-work-for-me
你好,
我相信您是最适合回答以下问题的人:我不想仅仅保存模型,我实际上想创建一个函数来预测值,并可能在另一种语言中使用它,也就是说,我希望使用神经网络的权重和架构来编写一个简单的函数。这可能吗?
感谢您的出色工作,非常有帮助!
是的。
您需要在程序中加载模型权重,并以与Keras代码相同的方式执行前向传播操作——对于MLP网络通常很简单,对于其他网络则更难。
嗨,Jason,
实际上我为图像分类选择了6个类别的图像,但输出显示我有7个类别。我不知道为什么?我该如何解决这个问题。请帮帮我。
谢谢你。
也许可以仔细检查一下您的数据是否按预期加载。
我选择了6个类别,但输出返回了7个类别。我该如何解决我的问题。
我的代码是
my_model.compile(optimizer='adam', loss='binary_crossentropy',
metrics=['accuracy'])
from tensorflow.python.keras.applications.vgg16 import preprocess_input
from tensorflow.python.keras.preprocessing.image import ImageDataGenerator
# 设置数据生成器
data_generator = ImageDataGenerator(preprocessing_function=preprocess_input)
# 从目录获取训练图像批次
#train_generator = data_generator.flow_from_directory(
# 'data/train',
# target_size=(178, 218),
# batch_size=12,
# class_mode='categorical')
# 从目录获取验证图像批次
validation_generator = data_generator.flow_from_directory(
‘data/test’,
target_size=(178, 218),
batch_size=12,
class_mode='categorical')
history = my_model.fit_generator(
validation_generator,
epochs=10,
steps_per_epoch=500,
validation_data=validation_generator,
validation_steps=667, callbacks=cb_list)
####### 测试 ################################
# 加载已保存的模型
from keras.models import load_model
import os
os.chdir(‘data\\data4\\’)
saved_model = load_model(‘data’)
# 生成测试图像集数据
test_generator = data_generator.flow_from_directory(
‘data/test’,
target_size=(178, 218),
batch_size=1,
class_mode=’categorical’,
shuffle=False)
# 获取最后一层全连接层的预测激活值
import numpy as np
test_generator.reset()
pred=saved_model.predict_generator(test_generator, verbose=1, steps=1000)
# 确定每个样本的最大激活值
predicted_class_indices=np.argmax(pred,axis=1)
# 将每个预测值标记到正确的类别
labels = (test_generator.class_indices)
labels = dict((v,k) for k,v in labels.items())
predictions = [labels[k] for k in predicted_class_indices]
# 将文件名格式化为简单类型
filenames=test_generator.filenames
filenz=[0]
for i in range(0,len(filenames))
filenz.append(filenames[i].split(‘\\’)[0])
filenz=filenz[1:]
# 确定测试集准确率
match=[]
for i in range(0,len(filenames))
match.append(filenz[i]==predictions[i])
match.count(True)/1000
输出
找到840张图片,属于7个类别。
第 1/10 纪元
500/500 [==============================] – 499秒 997毫秒/步 – 损失:0.4227 – 准确率:0.8276 – 验证损失:0.3815 – 验证准确率:0.8548
Epoch 00001: 验证损失从inf改进到0.38155,模型保存到data/test.h5
第 2/10 纪元
500/500 [==============================] – 656秒 1秒/步 – 损失:0.3420 – 准确率:0.8580 – 验证损失:10.1089 – 验证准确率:0.2443
Epoch 00002: 验证损失未从0.38155改进
第 3/10 纪元
449/500 [=========================>....] – ETA: 4:26 – 损失:0.3308 – 准确率:0.8616
请帮我如何获得正确的类别数量(6)
也许可以尝试将您的代码和问题发布到stackoverflow?
你好,先生,我在导入文件时遇到了这个错误
请帮帮我,先生
>>> from keras.models import load_model
使用 TensorFlow 后端。
>>> model = load_model(‘models/_mini_XCEPTION.106-0.65.hdf5′)
回溯(最近一次调用)
File “”, line 1, in
文件“C:\Users\abc\.conda\envs\tensorflow_env\lib\site-packages\keras\engine\saving.py”,第419行,在load_model中
model = _deserialize_model(f, custom_objects, compile)
文件“C:\Users\abc\.conda\envs\tensorflow_env\lib\site-packages\keras\engine\saving.py”,第225行,在_deserialize_model中
model = model_from_config(model_config, custom_objects=custom_objects)
文件“C:\Users\abc\.conda\envs\tensorflow_env\lib\site-packages\keras\engine\saving.py”,第458行,在model_from_config中
return deserialize(config, custom_objects=custom_objects)
文件“C:\Users\abc\.conda\envs\tensorflow_env\lib\site-packages\keras\layers\__init__.py”,第55行,在deserialize中
printable_module_name='layer')
文件“C:\Users\abc\.conda\envs\tensorflow_env\lib\site-packages\keras\utils\generic_utils.py”,第145行,在deserialize_keras_object中
list(custom_objects.items())))
文件“C:\Users\abc\.conda\envs\tensorflow_env\lib\site-packages\keras\engine\network.py”,第1022行,在from_config中
process_layer(layer_data)
文件“C:\Users\abc\.conda\envs\tensorflow_env\lib\site-packages\keras\engine\network.py”,第1008行,在process_layer中
custom_objects=custom_objects)
文件“C:\Users\abc\.conda\envs\tensorflow_env\lib\site-packages\keras\layers\__init__.py”,第55行,在deserialize中
printable_module_name='layer')
文件“C:\Users\abc\.conda\envs\tensorflow_env\lib\site-packages\keras\utils\generic_utils.py”,第147行,在deserialize_keras_object中
return cls.from_config(config[‘config’])
文件“C:\Users\abc\.conda\envs\tensorflow_env\lib\site-packages\keras\engine\base_layer.py”,第1109行,在from_config中
return cls(**config)
文件“C:\Users\abc\.conda\envs\tensorflow_env\lib\site-packages\keras\legacy\interfaces.py”,第91行,在wrapper中
return func(*args, **kwargs)
文件“C:\Users\abc\.conda\envs\tensorflow_env\lib\site-packages\keras\engine\input_layer.py”,第87行,在__init__中
name=self.name)
文件“C:\Users\abc\.conda\envs\tensorflow_env\lib\site-packages\keras\backend\tensorflow_backend.py”,第517行,在placeholder中
x = tf.placeholder(dtype, shape=shape, name=name)
AttributeError: 模块“tensorflow”没有属性“placeholder”
>>>
尝试更新到tensorflow 2和keras 2.3。
我有大量特征。我通过改变特征数量来训练几个keras模型,以查看这些特征对模型准确性的影响。最后,当我加载这些模型时,我不再知道模型是在哪些特征上训练的,因此当我进行预测时,我得到如下错误:
检查输入时出错:预期dense_4_input的形状为(29,),但得到了形状为(47,)的数组
有没有办法知道模型是在哪些确切的特征名称上训练的?我使用keras.models.load_model加载模型,使用keras.models.sequence.save(path)保存模型
是的,您可以访问模型的第一层并访问其形状。
添加 from keras.models import model_from_json 来使用
loaded_model = model_from_json(loaded_model_json)
谢谢。
你好 Jason,很喜欢你的教程(也买了书)!
我卡在加载一个以PReLU作为激活函数的模型上。我收到了ValueError。我尝试了
model = load_model(‘model.h4’, custom_objects={‘…’:…}),但我未能正确定义custom_object。你知道如何加载PReLU吗?
非常感谢!
暂时不知道,抱歉。也许可以尝试在 Stack Overflow 上提问?
这个奏效了
- 明确地将其作为层加载(从tensorflow.keras.layers import PReLU)
- 然后将其作为custom_objects={‘PReLU’: PReLU}加载
干得好!
你好
我正在遵循一个示例,第一步是使用这个类作为神经网络
{class Net(nn.Module)
def __init__(self)
# 定义网络的所有参数
super(Net, self).__init__()
self.fc1 = nn.Linear(28 * 28 * 1, 200)
self.fc2 = nn.Linear(200,10)
def forward(self, x)
# 进行前向传播
x = F.relu(self.fc1(x))
x = self.fc2(x)
return x
}
然后在下一步中,使用它并在这行代码中将其称为“model”
{optimizer = optim.Adam(model.parameters(), lr=3e-4)
}
当我运行整个代码时,它失败了,因为出现了这个错误:model未定义或parameters()缺少1个必需的位置参数:“self”
你能帮帮我吗?
你的例子看起来是 PyTorch,而这篇文章是关于 Keras 的。也许可以尝试在 Stack Overflow 上发布你的问题?
嗨,Jason,
我将模型保存为H5格式,我的问题是,在加载保存的模型后,使用相同的数据集和相同的数据增强选择、批次大小等。在新训练中,损失值并没有从保存模型的上一个epoch值继续,而是从头开始,就像之前从未训练过一样。
这种情况有什么问题?
给出示例代码,假设保存的模型是Model-A.h5
trained_model=keras.models.load_model(‘Model-A.h5’)
train_datagen = ImageDataGenerator(与预训练模型中相同)
validation_datagen = ImageDataGenerator(与预训练模型中相同)
train_generator = train_datagen.flow_from_directory(‘datafile’,
target_size=(image_size, image_size),
batch_size=train_batchsize,
class_mode=’binary’,
shuffle=True)
validation_generator = validation_datagen.flow_from_directory(…….)
trained_model.fit_generator(
train_generator,
steps_per_epoch=train_generator.samples/train_generator.batch_size ,
epochs=…,
validation_data=validation_generator,
validation_steps=validation_generator.samples/validation_generator.batch_size)
加载模型后,您必须使用较小的学习率以避免“冲刷掉”您开始时的权重。
谢谢你,Jason!
亲爱的 Jason,
当我使用 H5 文件加载模型时,模型之前已经使用学习率编译过。
加载后,我们不会再次使用 model.compile(),对吗?
那么我如何在代码中添加一个较小的学习率呢?
谢谢你
你可以重新设置学习率并再次编译。
请参阅此处设置学习率
https://machinelearning.org.cn/understand-the-dynamics-of-learning-rate-on-deep-learning-neural-networks/
不客气。
嗨,Jason,
非常感谢这个博客。
我再次加载模型时遇到了问题。看起来保存模型没有问题,但当我再次加载它时,我遇到了以下错误
—————————————————————————
ValueError 回溯 (最近一次调用)
in
4 from keras.models import load_model
5
—-> 6 model_24=load_model(“dove_model_24.h5”)
~\Anaconda3\lib\site-packages\keras\engine\saving.py in load_wrapper(*args, **kwargs)
490 os.remove(tmp_filepath)
491 return res
–> 492 return load_function(*args, **kwargs)
493
494 return load_wrapper
~\Anaconda3\lib\site-packages\keras\engine\saving.py in load_model(filepath, custom_objects, compile)
582 if H5Dict.is_supported_type(filepath)
583 with H5Dict(filepath, mode=’r’) as h5dict
–> 584 model = _deserialize_model(h5dict, custom_objects, compile)
585 elif hasattr(filepath, ‘write’) and callable(filepath.write)
586 def load_function(h5file)
~\Anaconda3\lib\site-packages\keras\engine\saving.py in _deserialize_model(h5dict, custom_objects, compile)
268 return obj
269
–> 270 model_config = h5dict[‘model_config’]
271 if model_config is None
272 raise ValueError(‘No model found in config.’)
~\Anaconda3\lib\site-packages\keras\utils\io_utils.py in __getitem__(self, attr)
316 else
317 if self.read_only
–> 318 raise ValueError(‘Cannot create group in read-only mode.’)
319 val = H5Dict(self.data.create_group(attr))
320 return val
ValueError: 无法在只读模式下创建组。
我想知道解决方案是什么,或者我如何避免这种情况,
此致,
穆罕默德
抱歉,我不知道原因,也许可以尝试将你的代码和错误发布到 Stack Overflow 上。
嗨,希望你一切都好。你找到解决方案了吗?我遇到了同样的问题。
此致
谢谢——解释得很清楚
不客气。
你好 Jason。我想问你为什么每次运行代码,结果都会改变?真的需要一个解释,因为输出将不一致
这是预料之中的,你可以在这里了解更多
https://machinelearning.org.cn/faq/single-faq/why-do-i-get-different-results-each-time-i-run-the-code
嗨,Jason
很棒的教程,但我有一个疑问,您在本教程中保存的权重是 .h5 格式的。
但是,如果您想将它们保存为“.mat”格式,如何保存和加载权重?
抱歉,我对 .mat 格式不了解。
嗨 Jason,谢谢你的教程。
我成功地使用了保存和加载模型来构建我的模型训练,使用了不同的数据批次。以前由于数据量太大,无法利用 GPU。
基本上,我在将数据拆分为训练和验证数据之前,会随机化数据的索引。
在每次训练迭代中,我都会取一部分训练数据,并进行15个 epoch。在所有训练迭代中,我都使用相同的验证数据进行验证。
当我这样做时,准确性实际上反而下降了。我想知道如果我采用这种方法,验证数据是否应该始终保持不变?
我不确定我是否理解。
一般来说,测试和验证数据不得用于模型训练,以对模型进行公正的评估。
嗨 Jason,我就是这么做的。首先,我将数据分成了训练集和验证集。
在训练数据样本中,我将它们分成块,然后逐块用于训练模型,因为数据量很大。
但是对于每次训练,我都使用了相同的验证样本。我在想,既然我把训练数据切成了块,那么验证集占总数据集大小的25%是否合理呢?
或许吧,只要验证集能代表更广泛的问题。
过度关注验证集(试图优化其结果)会导致过拟合。
你好,
有没有关于冻结 Keras 模型的教程?
嗯,我猜我在许多计算机视觉和 GAN 教程中展示了冻结层。
也许可以尝试在博客上搜索一下。
尊敬的Jason先生,
感谢您免费提供所有在线资料。
我的第一个深度学习代码运行完美,通过将 epoch 设置为 200,我能够将其准确率调整到 80.20%。
在获得上述结果后,我开始考虑捕获模型并稍后加载它进行预测。在 Google 上进行了一些搜索后,我被引导回了这个网站。
我尝试了示例,它运行完美。
再次感谢。
不客气。
干得好!
嗨,谢谢你的文章。我使用了以下代码:keras.models.load_model(“modelS.h5”),但我收到了这个错误:ValueError: Unknown layer: KerasLayer。你有没有办法解决这个问题?
我没有见过这个错误,也许可以尝试在 Stack Overflow 上发布你的代码和错误。
你好,Jason,谢谢分享。
当我想用多个文件训练模型时,我该怎么做?
谢谢你
将文件加载到内存中,将它们组合成一个数据集,然后用它们训练模型。
你好,jason 。 。 。
我在做信用卡欺诈检测项目。 。 。我有 .h5 格式的模型,但我不明白接下来如何处理该 .h5 格式的模型,也就是说,我不明白如何将该模型部署到 Web 上。 。基本上,我想通过在网页上输入来检测交易是否是欺诈性的,但我不知道如何将该 model.h5 模型部署到该网页上。 。 。你能告诉我后续步骤和所需的工具吗?
在您的自定义代码中加载模型,并使用应用程序中的数据调用它。
在网页中使用模型更多是工程问题,而不是机器学习问题。
我通过 model.save() 函数保存了模型,加载时我使用 keras.models.load_model(cnnmodel_path)。它在我的机器上运行良好,但当我在 Amazon ECS 实例上执行时,它抛出了一个异常“Cannot create group in read only mode.”(无法在只读模式下创建组)。
这是一个奇怪的错误,也许可以尝试在 Stack Overflow 上搜索/发布?
你好,我正在使用 NER 并遵循以下链接中的代码:
https://www.depends-on-the-definition.com/named-entity-recognition-with-residual-lstm-and-elmo/
但是,我无法保存模型然后加载它。你能帮我解决这个问题吗?我对机器学习和这些主题是新手。
也许直接联系作者。
如果我们有模型的json文件描述和权重,我们可以继续/迁移训练新的数据集吗?
当然,加载它并继续训练。
ValueError 回溯 (最近一次调用)
in
1
2 from keras.models import load_model
----> 3 model = load_model('mnist_mlp_model.h8')
4
5 yhat = model_predict(model, history, cfg)
C:\ProgramData\Anaconda3\lib\site-packages\keras\engine\saving.py in load_model(filepath, custom_objects, compile)
262
263 # set weights
----> 264 load_weights_from_hdf5_group(f['model_weights'], model.layers)
265
266 if compile
C:\ProgramData\Anaconda3\lib\site-packages\keras\engine\saving.py in load_weights_from_hdf5_group(f, layers, reshape)
899 'containing ' + str(len(layer_names)) +
900 ' layers into a model with ' +
----> 901 str(len(filtered_layers)) + ' layers.')
902
903 # We batch weight value assignments in a single backend call
ValueError: 您正在尝试将包含6层权重的权重文件加载到0层模型中。
你好,我叫kimhun
我遇到了这样的问题;
当我加载已保存的模型 -> model = load_model(‘mnist_mlp_model.h8’)
但它发生了这个问题
我该怎么解决它?
也许确认模型是否已正确保存?例如,尝试再次保存并重新加载?
或许确保你的库是最新的。
当我尝试加载数据库时,它会显示以下错误
ValueError: 无法将字符串转换为浮点数:‘\ufeff6,148,72,35,0,33.6,0.627,50,1’
我从您在教程中提供的链接下载了数据库。我将其保存为csv,但出现了这个错误。
听到这个问题我很抱歉,也许可以尝试再次下载数据集?
也许这里的某些建议会有所帮助
https://machinelearning.org.cn/faq/single-faq/why-does-the-code-in-the-tutorial-not-work-for-me
下面这行代码不起作用。
loaded_model = model_from_yaml(loaded_model_yaml)
ConstructorError: 无法为标签“tag:yaml.org,2002:python/object/apply:tensorflow.python.framework.tensor_shape.TensorShape”确定构造函数
在“”,第4行,第22列
build_input_shape: !!python/object/apply:tensorflow …
^
请注意:我确实安装了PyYAML(版本>=5)。
很抱歉听到你遇到麻烦,这里有一些建议
https://machinelearning.org.cn/faq/single-faq/why-does-the-code-in-the-tutorial-not-work-for-me
嗨 Jason,如何将 Keras 子类模型的权重保存为单个文件,它会保存为文件夹
model.save_weights('./model_weights', save_format='tf')
子类模型不能保存为 .h5 格式
谢谢
为什么不呢?我自己没试过,只是好奇。
或许你可以手动检索权重矩阵并保存为二进制文件?
你好,顺便说一句,这篇帖子很棒,但如果你有 k 折交叉验证,你会怎么做?我为每个折叠保存了权重,但我不知道如何将它们平均成一个 .h5 文件作为权重。我该如何将几个权重平均起来?
丢弃交叉验证过程中的所有模型。它们仅用于估计模型性能。
然后用所有可用数据训练一个最终模型。这可能会有所帮助
https://machinelearning.org.cn/how-to-make-classification-and-regression-predictions-for-deep-learning-models-in-keras/
不错的教程。
我有一个3次重复的for循环,每次我都用不同的数据集但相同的架构结构来训练模型。我的代码是
# 构建模型……
epochs = 80
batch_size = 32
# 配置模型
model.compile(loss=”categorical_crossentropy”, optimizer=”adam”, metrics=[“accuracy”])
# 检查点 – 根据min_validation_loss创建回调列表
checkpoint = ModelCheckpoint(‘best_model.h5′, monitor=’val_loss’, verbose=1,
save_best_only=True, save_weights_only=False, mode=’min’)
# 用于绘制指标的TensorBoard
tensorboard = TensorBoard(log_dir=log_directory)
# 训练模型
history = model.fit(xtrain, ytrain, batch_size=batch_size, epochs=epochs,
validation_split=0.2, verbose=0, callbacks=[checkpoint, tensorboard])
# 加载保存的模型
saved_model = load_model(‘best_model.h5’)
我的代码运行并在尝试训练第三个模型时崩溃,错误是
InternalError: 复制输入张量从 /job:localhost/replica:0/task:0/device:CPU:0 到 /job:localhost/replica:0/task:0/device:GPU:0 时失败,以便运行 GatherV2: 目标张量未初始化。 [Op:GatherV2]
我的问题是
我是否将所有3个模型都保存在内存中?如果是,有没有办法在下一次迭代开始前“清除内存”?
或许可以尝试移除TensorBoard?
嗨,Jason,
感谢您的这个有用的教程,
实际上,我在保存 h5 文件时遇到一个错误
ErrorCode: 需要一个字节类对象,而不是“str”
你能帮我解决这个问题吗?
谢谢你
很抱歉听到你遇到麻烦,也许这些建议会有所帮助
https://machinelearning.org.cn/faq/single-faq/why-does-the-code-in-the-tutorial-not-work-for-me
我遇到了完全相同的错误,你找到解决方案了吗?
我刚做了这个
model.save(modelSavePath, save_format=’h5′)
model = tf.keras.models.load_model(modelLoadPath)
最后几行错误如下:
文件“/usr/local/lib/python3.8/site-packages/tensorflow/python/ops/init_ops_v2.py”,第545行,在__call__中
fan_in, fan_out = _compute_fans(scale_shape)
文件“/usr/local/lib/python3.8/site-packages/tensorflow/python/ops/init_ops.py”,第1425行,在_compute_fans中
return int(fan_in), int(fan_out)
TypeError: int()参数必须是字符串、字节类对象或数字,而不是“NoneType”
一些想法
或许直接使用教程中演示的Keras API?
或许使用Python 3.6,我不知道3.8是否受支持?
嗨,Jason,
非常感谢您提供的精彩教程。
我根据您的教程,使用自己的二分类数据,构建了一个CNN模型+Google嵌入,测量了准确率(即精确度:0.7)。然后保存模型并加载,再使用相同的数据集让模型进行标注。我手动比较了结果,发现精确度只有0.15!
这种差距有什么原因吗?
谢谢你
不客气。
一旦模型训练完成,它在相同的数据集上应该/会给出相同的性能。
或许可以检查您的测试工具中是否存在错误,并确保您在每次加载模型时都没有重新训练模型。
嗨,Jason,
感谢您提供如此精彩的内容。
我训练了一个孪生网络,并尝试使用本文中提到的方法进行保存和加载,即使在我使用的lambda层存在的情况下,我仍然不断收到“SystemError: unknown opcode”的错误。
我尝试了用TensorFlow 2.3训练和加载模型,但仍然收到相同的错误
有时,当保存带有自定义层的模型时,您必须在加载模型时导入并指定自定义层的名称。
具体来说,通过函数的“custom_objects”参数
https://tensorflowcn.cn/api_docs/python/tf/keras/models/load_model
亲爱的 Jason,
感谢您的快速回复。我找到了一个解决办法。请看我的GitHub评论:
https://github.com/keras-team/keras/issues/9595#issuecomment-742413448
很高兴听到您解决了问题。
亲爱的 Jason,
我非常感谢您精彩的内容;
我发现加载训练好的tflearn模型有些困难。
我以这种方式保存了我的模型:model.save('model.tflearn'),然后,我试图在一个新的notebook中加载它,首先我构建模型并定义它,这样我就可以将模型变量分配给model.load('model.tflearn'),但我收到了一系列错误,阻止我加载它。
期待您的回复,
谢谢!
很抱歉,也许可以尝试不用notebook运行代码。
感谢您的精彩教程,Jason!
这真的帮助我轻松进入机器学习领域!
不客气!
嗨,Jason,
谢谢您的帖子。我们如何提高load_model时间?我的模型很小。另外,我们如何使用模型权重来预测新图像?
不客气。
也许可以使用更小的模型?
也许更快的硬盘?
感谢您的回复。我使用了一个非常浅的DenseNet版本,它只有0.5M参数,文件大小也只有7MB。
太棒了!
如何保存和加载:CNN_LSTM多元多步时间序列模型的权重——运行30次并使用箱线图进行预测?
好问题,本教程向您展示如何保存和加载模型
https://machinelearning.org.cn/save-load-keras-deep-learning-models/
@Jason,保存所有30个权重——模型运行30次——的最佳方式是什么?
(1)在循环中运行并在循环中保存。
(2)有没有一种方法可以在循环外部创建模型函数,从而一次性保存所有30次运行及其权重。
你为什么要那样做?
是的,在循环中调用 save() 并使用唯一的文件名。
感谢这些教程,它们真的很有帮助。我的问题是,如果我在不同的IDE上运行教程,我会得到非常不同的结果,例如,如果我在pycharm上运行序列化教程,我会得到大约37%的准确率,而使用spyder-ide运行相同的代码,我会得到大约78%的准确率,这可能是由什么引起的。我希望这些值彼此接近,因为它们是完全相同的代码。
这是我在这里回答的一个常见问题
https://machinelearning.org.cn/faq/single-faq/why-do-i-get-different-results-each-time-i-run-the-code
先生,一个问题。如果我将模型的权重保存为.h5文件,我如何才能在磁盘上找到这个文件?它保存在我的电脑的哪个位置?我使用google collab的jupyter notebook来执行训练模拟。
您必须指定系统上的路径位置才能保存。
如果您不指定路径,它将保存在与您的python文件相同的位置。
我不建议使用notebook
https://machinelearning.org.cn/faq/single-faq/why-dont-use-or-recommend-notebooks
你好 jason,
我有一个小问题……假设我们为A类(例如钢笔)训练YOLO模型……我们得到权重文件,然后使用这个权重文件再次为B类(例如铅笔)训练模型……那么结果权重文件将能够检测A类和B类对象吗?
例如,如果我们使用一张同时包含钢笔和铅笔的图片……它能识别它们两者吗?
也许可以尝试一下。
嗨
我安装了以下版本
Python –3.8.5
tensorflow — 2.4.1
Keras –2.4.0
我正在尝试加载YOLO模型,但出现如下错误
D:\Anaconda3\python.exe D:/Python_project/PY_worrks/AI-work/Keras_module/Autonomous_driving_application_Car_detection/Autonomous_driving_application_Car_detection.py
2021-05-03 11:54:11.870644: W tensorflow/stream_executor/platform/default/dso_loader.cc:60] 无法加载动态库 'cudart64_110.dll';dlerror: 未找到 cudart64_110.dll
2021-05-03 11:54:11.871551: I tensorflow/stream_executor/cuda/cudart_stub.cc:29] 如果您的机器上没有设置GPU,请忽略上述cudart dlerror。
回溯(最近一次调用)
文件“D:/Python_project/PY_worrks/AI-work/Keras_module/Autonomous_driving_application_Car_detection/Autonomous_driving_application_Car_detection.py”,第227行,位于
yolo_model = load_model("yolo.h5")
文件“D:\Anaconda3\lib\site-packages\tensorflow\python\keras\saving\save.py”,第206行,位于load_model
返回 hdf5_format.load_model_from_hdf5(filepath, custom_objects,
文件“D:\Anaconda3\lib\site-packages\tensorflow\python\keras\saving\hdf5_format.py”,第183行,位于load_model_from_hdf5
模型 = model_config_lib.model_from_config(model_config,
文件“D:\Anaconda3\lib\site-packages\tensorflow\python\keras\saving\model_config.py”,第64行,位于model_from_config
return deserialize(config, custom_objects=custom_objects)
文件“D:\Anaconda3\lib\site-packages\tensorflow\python\keras\layers\serialization.py”,第173行,位于反序列化
返回 generic_utils.deserialize_keras_object(
文件“D:\Anaconda3\lib\site-packages\tensorflow\python\keras\utils\generic_utils.py”,第354行,位于deserialize_keras_object
返回 cls.from_config(
文件“D:\Anaconda3\lib\site-packages\tensorflow\python\keras\engine\training.py”,第2261行,位于from_config
返回 functional.Functional.from_config(
文件“D:\Anaconda3\lib\site-packages\tensorflow\python\keras\engine\functional.py”,第668行,位于from_config
input_tensors, output_tensors, created_layers = reconstruct_from_config(
文件“D:\Anaconda3\lib\site-packages\tensorflow\python\keras\engine\functional.py”,第1275行,位于reconstruct_from_config
process_layer(layer_data)
文件“D:\Anaconda3\lib\site-packages\tensorflow\python\keras\engine\functional.py”,第1257行,位于process_layer
layer = deserialize_layer(layer_data, custom_objects=custom_objects)
文件“D:\Anaconda3\lib\site-packages\tensorflow\python\keras\layers\serialization.py”,第173行,位于反序列化
返回 generic_utils.deserialize_keras_object(
文件“D:\Anaconda3\lib\site-packages\tensorflow\python\keras\utils\generic_utils.py”,第354行,位于deserialize_keras_object
返回 cls.from_config(
文件“D:\Anaconda3\lib\site-packages\tensorflow\python\keras\layers\core.py”,第1019行,位于from_config
function = cls._parse_function_from_config(
文件“D:\Anaconda3\lib\site-packages\tensorflow\python\keras\layers\core.py”,第1071行,位于_parse_function_from_config
function = generic_utils.func_load(
文件“D:\Anaconda3\lib\site-packages\tensorflow\python\keras\utils\generic_utils.py”,第457行,位于func_load
code = marshal.loads(raw_code)
ValueError: bad marshal data (unknown type code)
进程以退出代码 1 结束
很抱歉听到这个消息,也许这些提示会有帮助。
https://machinelearning.org.cn/faq/single-faq/why-does-the-code-in-the-tutorial-not-work-for-me
嗨,Jason,精彩的讲座。我正在研究GAN,并训练了我的生成器,将架构存储在JSON文件中,将权重存储在.h5文件中。在测试期间,我加载了json架构和H5文件。现在您提到了如下的编译步骤
loaded_model.compile(loss=’binary_crossentropy’, optimizer=’rmsprop’, metrics=[‘accuracy’])
同样,为了编译我的生成器模型,如何编译?编译时使用哪个损失函数?因为生成器是使用重建损失等进行训练的,并且在训练中没有编译阶段,请指教。
谢谢!
不再需要编译,只需加载并开始使用即可。
亲爱的Jason,根据您的教程,我制作并保存了我的全部代码,如下所示:
import pandas as pd
import numpy as np
from sklearn.model_selection import train_test_split
df=pd.read_csv(‘Al-Besharah Data.csv’)
df.head()
X=df.iloc[:,:-1]
Y=df.iloc[:,-1].values
from sklearn.preprocessing import MinMaxScaler
缩放器 = MinMaxScaler()
Xnorm = pd.DataFrame(data = scaler.fit_transform(X))
Yshape = pd.DataFrame(data = Y.reshape(-1,1))
Ynorm = pd.DataFrame(data = scaler.fit_transform(Yshape))
XTrain,XTest,YTrain,YTest=train_test_split(Xnorm,Ynorm,train_size=0.7,random_state=2)
import keras.backend as K
def r2(y_true, y_pred)
SS_res = K.sum(K.square(y_true – y_pred))
SS_tot = K.sum(K.square(y_true – K.mean(y_true)))
return ( 1 – SS_res/(SS_tot + K.epsilon()) )
来自 keras.models import Sequential
from keras.layers import Dense
from keras.callbacks import EarlyStopping
model1 = Sequential()
model1.add(Dense(100,activation=’relu’,input_dim=4))
model1.add(Dense(100,activation=’relu’))
model1.add(Dense(1))
np.random.seed(50)
model1.compile(optimizer=’adam’,loss=’mean_squared_error’,metrics=[‘mse’,r2])
early_stopping_monitor = EarlyStopping(monitor =”val_loss”,
mode =”min”, patience = 5,
restore_best_weights = True)
history=model1.fit(XTrain,YTrain,epochs=5000,
batch_size=64,validation_data=(XTest,YTest),
callbacks=[early_stopping_monitor]);
import matplotlib.pyplot as plt
plt.plot(history.history[‘r2’])
plt.plot(history.history[‘val_r2’],’r–‘)
plt.title(‘Model accuracy’)
plt.ylabel(‘Accuracy value’)
plt.xlabel(‘# epochs’)
plt.legend([‘train’,’test’],loc =’lower right’)
plt.show()
import matplotlib.pyplot as plt
plt.plot(history.history[‘loss’])
plt.plot(history.history[‘val_loss’],’r–‘)
plt.title(‘Model Loss’)
plt.ylabel(‘Loss value’)
plt.xlabel(‘# epochs’)
plt.legend([‘train’,’test’],loc =’upper right’)
plt.show()
from sklearn.metrics import r2_score
y_train_pred = model1.predict(XTrain)
y_test_pred = model1.predict(XTest)
y_pred = model1.predict(Xnorm)
r2_score(YTrain,y_train_pred),r2_score(YTest,y_test_pred),r2_score(Ynorm,y_pred)
#保存整个模型
model1.save("model1.h5")
我相信这保存了包括权重和架构在内的整个模型。除此之外,我尝试加载模型并将其用于预测新数据集,但我得到的错误是:
ValueError: 未知指标函数:r2。请确保将此对象传递给`custom_objects`参数。
我是这样尝试加载代码的:
import pandas as pd
from sklearn.model_selection import train_test_split
from tensorflow import keras
model2=keras.models.load_model(‘model1.h5’)
df=pd.read_csv(‘Al-Besharah Data.csv’)
df.head()
X=df.iloc[:,:-1]
Y=df.iloc[:,-1].values
from sklearn.preprocessing import MinMaxScaler
缩放器 = MinMaxScaler()
Xnorm = pd.DataFrame(data = scaler.fit_transform(X))
Yshape = pd.DataFrame(data = Y.reshape(-1,1))
Ynorm = pd.DataFrame(data = scaler.fit_transform(Yshape))
XTrain,XTest,YTrain,YTest=train_test_split(Xnorm,Ynorm,train_size=0.7,random_state=2)
干得好。
问题
我有一个文件(model.h5),我想以源代码(file.ipynb)的形式打开它。这可能吗?
该模型似乎是一个以HDF5格式保存的Keras模型。尝试查找keras.models.load_model()函数。但如果文件没有完整的模型,您必须先获取原始模型源代码才能使用它。
嗨 Jason
我的问题是,我构建了一个混合了两个CNN模型的模型。我按照这里描述的方法保存并加载了它。但随后它给我一个这样的错误:-
AttributeError Traceback (最近一次调用)
in ()
----> 1 predictions = model_1.predict_proba([video_features_arr_norm,audio_features_arr])
AttributeError: 'Functional' object has no attribute 'predict_proba'
请告诉我问题出在哪里。这种方法不能保存混合模型吗?
我想你的模型不支持 predict_proba(),而且并非所有模型都支持。在这种情况下,你需要自己编写函数作为替代。请看这个问题:https://stackoverflow.com/questions/63649503/attributeerror-functional-object-has-no-attribute-predict-proba
model.to_json() 给我一个 NotImplementedError。我之前尝试过 .save(),但当我重新加载时,我得到了一个维度错误,这让我开始考虑保存权重。如果 to_json 和 save 对我不起作用,我该怎么办?
它已经说明了一切。to_json() 不支持此模型。save() 应该可以工作,但您必须将其加载回相同的模型中。如果出现任何问题(例如,某个层的尺寸不同),您将收到尺寸错误。
你好 Jason,
正如讨论的那样
https://machinelearning.org.cn/manually-optimize-neural-networks/?unapproved=654896&moderation-hash=fe3b8b1630d977e40be66ecc358cfaf7#comment-654896
我们如何将手动神经网络保存为模型?
来自json的模型在自定义层方面失败。有什么想法吗?
因为Keras默认情况下不会理解您的自定义层。您需要告诉Keras您是如何实现自定义层的。请参阅此处的示例:https://tensorflowcn.cn/guide/keras/save_and_serialize
关于保存加载Keras深度学习模型的优秀博客。我们是技术新闻提供商之一,提供与技术工具最新发展相关的新闻。我们从各个跨国公司收集信息,并根据类别进行分配。
@Jason Brownlee
您能解释一下如何在Keras中重新训练/微调加载的模型吗?
嗨,Meenakshi……以下资源可能对您有用
https://machinelearning.org.cn/how-to-train-an-object-detection-model-with-keras/
@James Carmichael
加载模型后,我想用我的数据集微调该模型,然后对其进行评估。
请帮助。
如同上面的代码
# 将模型序列化为JSON
model_json = model.to_json()
with open(“model.json”, “w”) as json_file:
json_file.write(model_json)
# 将权重序列化为HDF5
model.save_weights(“model.h5”)
print(“Saved model to disk”)
# 之后…
# 加载 json 并创建模型
json_file = open(‘model.json’, ‘r’)
loaded_model_json = json_file.read()
json_file.close()
loaded_model = model_from_json(loaded_model_json)
# 将权重加载到新模型中
loaded_model.load_weights(“model.h5”)
print(“Loaded model from disk”)
当你将权重与模型分开保存,然后重新组合时,计算机如何知道哪个权重属于哪个神经元?大概有一些位置信息……
如果你能帮我解决这个问题,那就太好了。