如何保存和加载您的 Keras 深度学习模型

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 格式的注释,并添加了关于协议缓冲区的章节
Save and Load Your Keras Deep Learning Models

如何保存和加载 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 的依赖项安装。您也可以通过以下方式轻松安装它

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 后端提供的适当高效的计算。

模型以相同的方式进行评估,打印出相同的评估分数。

注意:考虑到算法或评估过程的随机性,或者数值精度的差异,您的结果可能会有所不同。请考虑运行几次示例并比较平均结果。

运行此示例将提供以下输出。

模型的 JSON 格式如下所示

将神经网络模型保存到 YAML

注意:此方法仅适用于 TensorFlow 2.5 或更早版本。如果您在更高版本的 TensorFlow 中运行它,您将看到一个 RuntimeError,消息为“Method model.to_yaml() 已由于任意代码执行的安全风险而被删除。请改用 model.to_json()。”

这个示例与上面的 JSON 示例非常相似,只是模型规范使用了 YAML 格式。

请注意,此示例假定您已安装 PyYAML 5

在此示例中,模型使用 YAML 描述,保存到文件 model.yaml,然后通过 model_from_yaml() 函数加载到新模型中。

权重以与上面 HDF5 格式相同的方式处理,作为 model.h5。

注意:考虑到算法或评估过程的随机性,或者数值精度的差异,您的结果可能会有所不同。请考虑运行几次示例并比较平均结果。

运行示例显示以下输出。

用 YAML 格式描述的模型如下所示

同时保存模型权重和架构

Keras 还支持一个更简单的接口,可以将模型权重和模型架构一起保存到一个 H5 文件中。

以这种方式保存模型包括您需要了解的有关模型的所有信息,包括

  • 模型权重
  • 模型架构
  • 模型编译细节(损失和指标)
  • 模型优化器状态

这意味着您可以直接加载和使用模型,而无需像上面示例中那样重新编译它。

注意:这是保存和加载 Keras 模型的首选方式。

如何保存 Keras 模型

您可以通过调用模型的 save() 函数并指定文件名来保存模型。

以下示例通过首先拟合模型,评估它,然后将其保存到文件 model.h5 来演示这一点。

注意:考虑到算法或评估过程的随机性,或者数值精度的差异,您的结果可能会有所不同。请考虑运行几次示例并比较平均结果。

运行示例会拟合模型,总结模型在训练数据集上的性能,并将模型保存到文件。

您稍后可以从文件中加载此模型并使用它。

请注意,在 Keras 库中,有另一个执行相同操作的函数,如下所示

如何加载 Keras 模型

您可以通过调用 load_model() 函数并传入文件名来加载保存的模型。该函数返回具有相同架构和权重的模型。

在这种情况下,您加载模型,总结架构,并在相同的数据集上评估它,以确认权重和架构相同。

运行示例首先加载模型,打印模型架构的摘要,然后评估加载的模型在相同数据集上的表现。

注意:考虑到算法或评估过程的随机性,或者数值精度的差异,您的结果可能会有所不同。请考虑运行几次示例并比较平均结果。

模型达到相同的准确率分数,本例中为 77%。

协议缓冲区格式

虽然使用 HDF5 格式保存和加载 Keras 模型是推荐的方式,但 TensorFlow 还支持另一种格式,即协议缓冲区。保存和加载协议缓冲区格式被认为更快,但这样做会生成多个文件。语法相同,只是您不需要为文件名提供 .h5 扩展名

这将创建一个名为“model”的目录,其中包含以下文件

这也是 TensorFlow v1.x 中保存模型所使用的格式。当您从 TensorFlow Hub 下载预训练模型时,您可能会遇到这种情况。

进一步阅读

  • Keras 文档中的“如何保存 Keras 模型?”
  • Keras 文档中的“关于 Keras 模型”

总结

在这篇文章中,您学习了如何序列化您的 Keras 深度学习模型。

您学习了如何将训练好的模型保存到文件中,然后加载它们并使用它们进行预测。

您还学习到模型权重可以轻松地使用 HDF5 格式存储,并且网络结构可以保存为 JSON 或 YAML 格式。

您对保存深度学习模型或本文有任何疑问吗?
在评论中提出您的问题,我将尽力回答。

对《如何保存和加载 Keras 深度学习模型》的 388 条回复

  1. Onkar 2016 年 8 月 31 日 下午 4:21 #

    嗨,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

    • Jason Brownlee 2016 年 9 月 1 日 上午 7:57 #

      抱歉 Onkar,故障不清楚。

      您能正常执行教程中的示例吗?

      • Ridhesh 2018 年 1 月 11 日 下午 4:12 #

        嗨,Jason,

        这篇帖子很棒,提供了有用的保存和评估模型的步骤。如何在不重新训练新数据的情况下,在新数据上运行已保存的模型?假设我有一个线性回归 y=mx+c,在给定 x 集上训练,一旦我获得了给定 y 和 x 的 m 和 c,我只需要输入新的 x 并获得具有相同 m 和 c 的预测 y。我无法以这种方式使用 LSTM 模型。

        提前感谢您的帮助和评论。

        • Jason Brownlee 2018 年 1 月 12 日 上午 5:52 #

          加载模型并进行预测

          model.predict(X)

          也许我没理解问题所在?

  2. Walid Ahmed 2016 年 9 月 27 日 上午 1:54 #

    您的代码运行良好,
    我尝试将保存模型添加到我的代码中,但文件实际上并未创建,尽管我没有收到错误消息

    请指教

    walid

    • Jason Brownlee 2016 年 9 月 27 日 上午 7:45 #

      我希望文件已创建。检查您的当前工作目录/源代码文件所在的目录。

  3. Peter 2016 年 9 月 27 日 下午 1:43 #

    嗨,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

    这里可能出了什么问题?

    谢谢,
    彼得

    • Jason Brownlee 2016 年 9 月 28 日 上午 7:37 #

      嗨 Peter,您可能使用的是 Python3,请尝试在 print 函数的参数周围添加括号。

  4. Deployment 2016年9月29日 上午1:03 #

    你好,

    您的博客和书籍都很棒,多亏了您,我终于让我的项目在Keras中运行起来了。

    我似乎找不到如何将Keras模型转换为无需安装Keras即可运行的独立代码。

    我能找到的最好方法是学习TensorFlow,在TF中构建一个等效模型,然后使用TF创建独立代码。

    Keras没有这样的功能吗?

    谢谢

    • Jason Brownlee 2016年9月29日 上午8:37 #

      您好,我的理解是,在预测中使用模型需要Keras。

      您可以尝试保存网络权重并在自己的代码中使用它们,但这会给自己带来很多工作。

      • vishnu prasad 2017年7月3日 上午11:00 #

        感谢Jason的精彩博客。
        保存此模型和重新加载只适用于Keras,还是也适用于其他sklearn模型,如kmeans等?
        当我使用了一些分类器,并且它们也进行了独热编码,比如工资等级或国家等时,假设您保存了模型,但如何对预期给出输出的输入数据应用相同的编码和特征缩放呢?
        例如,我可能基于国家、性别、吸烟和饮酒状况(如经常、偶尔、罕见等)训练了一个癌症结果模型。现在,当我获得新记录时,如何确保我的编码和特征缩放与我的训练集保持一致并将其转换为预测?
        提前感谢您的帮助。

  5. Davood 2016年11月22日 上午10:48 #

    你好 Jason,

    感谢您这个很棒且非常有用的网站。

    既然这里谈到了如何保存模型,我想知道如何以常规词嵌入文件(即文本文件或txt格式)中可见的方式保存嵌入层。假设我们是在模型中从头开始学习这些词嵌入,或者我们更新了在模型第一层中输入的预训练词嵌入。

    提前感谢您的回复。

    此致,
    Davood

    • Jason Brownlee 2016年11月23日 上午8:49 #

      Davood,我不确定我们是否需要保存嵌入层。

      我相信它们是确定性的,可以重新创建。

      • Davood 2016年11月23日 上午10:51 #

        我想我们应该能够在某个时候保存词嵌入(尽管并非总是需要!)。为了在(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`字典中。

        • Jason Brownlee 2016年11月24日 上午10:36 #

          非常棒,感谢Davood分享细节。

          • Davood 2016年11月29日 下午7:25 #

            Jason,非常欢迎。
            不过我还有另一个问题!
            假设我们在Keras中有两列网络,这两列完全相同。这两列将在顶部合并,然后输入到作为我们模型中输出层的密集层。我的问题是,虽然这里每列的第一层都是嵌入层,我们如何共享列中相似层的权重?无需多说,我们将嵌入层(第一层)设置为只有一个嵌入矩阵。我的意思是共享嵌入,类似于这样
            emb1 = Embedding(some_parameters_here)
            emb2 = emb1 # 而不是 emb2 = Embedding(some_other_parameters_here))。
            那这两层嵌入层之上的其他层呢?!如何共享它们的权重?
            提前感谢您的回答。

          • Jason Brownlee 2016年11月30日 上午7:55 #

            嗯,有意思,Davood。

            我认为,也可能错了,嵌入层是确定性的。它们没有状态,只有输入或输出的权重有状态。创建两个并排使用。试试看。

            我很想知道您进展如何?

  6. Chao 2016年12月6日 上午1:58 #

    你好Jason,感谢你的分享,对我帮助很大。我想问一个问题,为什么编译模型时优化器是adam,但编译加载模型时却使用rmsprop?

    • Jason Brownlee 2016年12月6日 上午9:53 #

      我建议尝试许多不同的优化器,看看您最喜欢哪个/哪个最适合您的问题。

      我发现ADAM速度快且效果好。

  7. kl 2016年12月13日 下午11:47 #

    我很难找到这个问题的答案

    Keras中的权重何时初始化?

    在编译时?(可能不是)

    在第一个epoch时?

    这对于恢复学习很重要

    • Jason Brownlee 2016年12月14日 上午8:28 #

      有趣的问题。

      我不知道。

      如果我不得不猜测,我会说在创建数据结构时,即在`model.compile()`时。

      可能值得在 Keras 邮件列表中提问——我很想知道答案。

  8. Soheil 2016年12月22日 下午8:44 #

    感谢您创建如此出色的博客。
    我用上面提到的代码保存了一个模型。但是当我再次加载它时,我遇到了以下错误。看起来网络架构没有正确保存?

    —————————————————————————
    异常回溯(最近一次调用)
    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层的模型中。

    • Jason Brownlee 2016年12月23日 上午5:31 #

      嗨,Soheil,

      看起来您加载权重的网络结构与权重结构不匹配。

      请仔细检查网络结构是否与您保存权重时使用的结构完全匹配。您甚至可以将此结构保存为json或yaml文件。

      • Edgard Gonzalez 2020年4月17日 下午9:48 #

        你好Jason!如何在jupyter中查看保存的权重结构?我遇到了和Soheil一样的问题,但是我的网络有17层。

        谢谢阅读!

        • Jason Brownlee 2020年4月18日 上午5:52 #

          权重是一个数组,您可以通过`.shape`属性总结它们的形状。

  9. prajnya 2017年1月24日 下午6:22 #

    嗨,Jason,

    我有一个问题。既然我已经保存了模型和权重,我是否可以在几天后回来,用我保存的初始权重再次训练模型?

    • Jason Brownlee 2017年1月25日 上午9:58 #

      好问题,prajnya。

      您可以加载已保存的权重,并继续使用新数据进行训练/更新或开始进行预测。

      • Tharun 2017年7月9日 上午2:31 #

        嗨,Jason,

        我尝试保存并加载一个训练了5000个epoch的模型,并在同一会话中将其性能与保存前5000个epoch后模型的性能进行比较。无论如何,使用上述代码,我最终得到了随机结果。但是,我只保存了权重,并再次实例化模型,然后使用参数“by_name”加载了权重model.load_weights('model.h5', by_name=True),此时准确率与模型在第一个epoch/迭代时的初始性能相同。但在任何情况下我都无法复现!请求您能否通过一篇文章澄清这一点,github上也有一个帖子,但尚未得到满意的解决!!!

        • Jason Brownlee 2017年7月9日 上午10:56 #

          很抱歉听到这个消息,我没有什么好主意。也许可以发布到stackoverflow?

      • Tharun 2017年7月9日 上午2:33 #

        GitHub帖子在https://github.com/fchollet/keras/issues/4875

  10. AKSHAY 2017年2月8日 下午6:06 #

    嗨,Jason,

    您的博客非常棒。感谢您记录详尽的工作。
    我有一个关于加载模型权重的问题。有没有办法将权重保存到一个变量中,而不是加载并将权重分配给不同的模型?
    我想对与中间隐藏层相关的权重进行一些操作。

    我曾期望使用ModelCheckpoint,但在从hdf5格式读取权重并将其保存到变量方面有点迷茫。您能帮我解决这个问题吗?

    谢谢

    • Jason Brownlee 2017年2月9日 上午7:24 #

      好问题,抱歉我没做过这个。

      我预计您可以使用 Keras API 提取它们,可能值得查看 GitHub 上的源代码。

  11. Patrick 2017年3月1日 上午3:53 #

    嗨 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')

    ——————————————————-

    • Jason Brownlee 2017年3月1日 上午8:42 #

      谢谢Patrick,我会尽快调查并更新帖子。

  12. Avik Moulik 2017年3月7日 上午8:11 #

    出现此错误

    NameError: name 'model_from_json' is not defined

    提前感谢任何帮助。

    • Jason Brownlee 2017年3月7日 上午9:38 #

      确认您已安装 Keras 1.2.2 或更高版本。

    • Giselle 2019年10月23日 上午8:29 #

      请务必先运行“from keras.models import model_from_json”

  13. Chan 2017年4月13日 上午4:58 #

    我已经将权重保存在txt文件中了。我可以使用它并加载权重吗?

    • Jason Brownlee 2017年4月13日 上午10:13 #

      您可能可以,我手头没有示例,抱歉。

  14. M Amer 2017年4月20日 上午2:45 #

    嗨,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: 配置文件中未找到模型。
    —————————————————————-

    请帮我解决这个问题…!!

    • Jason Brownlee 2017年4月20日 上午9:32 #

      抱歉,我手头不知道如何在 TensorFlow 中加载 Keras 模型。

    • Ravid 2017年4月28日 上午12:29 #

      M Amer,

      我正在尝试做同样的事情。如果您解决了,请告诉我们。

  15. M Amer 2017年4月21日 上午1:42 #

    嗨,Jason,
    我创建了Keras模型文件(.h5),但遗憾的是它无法加载。但我想加载它并将其转换为TensorFlow (.pb)模型。有什么解决方案吗?等待您的回复….

    • Jason Brownlee 2017年4月21日 上午8:39 #

      抱歉,我没有如何在TensorFlow中加载Keras模型的示例。

  16. Sanjay 2017年4月24日 上午2:41 #

    嗨,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

    • Jason Brownlee 2017年4月24日 上午5:38 #

      您还需要保存您的缩放器。

      也许您可以将其腌制,或者只保存缩放数据所需的系数(每个特征的最小值/最大值)。

  17. Rohit 2017年4月28日 下午9:01 #

    感谢您的有用信息。

    是否可以将此模型和权重加载到其他平台,例如Android或iOS。我相信模型和权重是语言无关的。

    有没有免费/开源的解决方案用于此目的?

    • Jason Brownlee 2017年4月29日 上午7:24 #

      我看不出为什么不行。抱歉,我不了解Android或iOS平台。

  18. Kshitij Deshmukh 2017年5月12日 下午11:57 #

    嗨,Jason,

    如何根据人脸识别编码创建模型,以便使用 Saver.save() 方法保存?

  19. Lotem 2017年5月15日 下午6:33 #

    嘿,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%的准确率。

    有什么想法吗?

    • Jason Brownlee 2017年5月16日 上午8:42 #

      我有。我不认为这与Python会话有关。

      凭直觉,我的直觉告诉我,保存的模型中有些不同。

      如果您在同一会话中保存和加载,结果是否与保存之前相同?如果您重复加载+测试过程几次呢?

      确认您也保存了嵌入层(我认为它可能需要保存)。

      确认您正在以完全相同的方式、相同的数据和相同的顺序评估它。

      神经网络是随机的,偏差可能会影响RNN的内部状态,并导致不同的结果,尽管可能不像您所报告的那么剧烈。

      • Hardik Raja 2022年9月6日 上午12:21 #

        我遇到了一个类似的问题,

        如果在同一会话中保存并加载,加载模型的结果与会话中已有的模型(保存之前)不同。

        理想情况下,训练好的模型(在会话/内存中)和加载的模型(保存和加载后)不应该相同吗?

        我搜索了,但尚未找到任何线索。任何帮助/线索都将不胜感激。提前感谢

        • James Carmichael 2022年9月6日 上午6:31 #

          你好 Hardik...以下资源可能会增加清晰度

          https://machinelearning.org.cn/stochastic-in-machine-learning/

          • Hardik Raja 2022年9月6日 下午5:03 #

            @James – 感谢您的快速回复。

            所以我明白了为什么两次预测,一次来自会话模型 (ANN),另一次来自加载模型(保存的会话模型)是不同的。

            但在我的情况下,会话模型 (ANN) 的结果非常糟糕(MAE 非常高),而加载模型(保存的会话模型)的结果令人满意(MAE 相当好)。我无法理解为什么会有如此巨大的差异?

  20. Carl 2017年5月26日 下午8:05 #

    我似乎收到一条错误消息

    RuntimeError: 无法创建属性(对象头消息太大)

    Github issues 指出该错误可能是由于网络太大造成的,这里就是这种情况……但是

    那我应该如何保存权重……Keras 似乎没有任何替代方法。

    • Jason Brownlee 2017 年 6 月 2 日 上午 11:54 #

      抱歉,我没有见过这个错误。

      尝试在你的系统上使用一个较小的网络保存权重,以缩小故障原因。

      • Naveen Raju 2020 年 7 月 21 日 下午 3:49 #

        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 保存权重,请你帮我解决一下。

        • Jason Brownlee 2020 年 7 月 22 日 上午 5:26 #

          也许可以尝试在 stackoverflow 上发布你的错误和代码。

  21. nguyennguyen 2017 年 6 月 2 日 下午 4:56 #

    大家好,
    我想知道如何在不停止服务的情况下更新模型值,比如我有一个更好的模型,版本 2,并且不需要停止服务,而之前使用的是 Keras 中的版本 1。我想说一个模块管理器模型,可以更新新版本模型,而不需要中断服务,或者类似的东西。谢谢。

  22. George 2017 年 6 月 6 日 下午 6:14 #

    嗨,Jason,
    你知道是否可以只保存模型,并且每次模型在验证集上的准确性提高时(在每个 epoch 之后)都保存吗?

    并且是否可以以比每个 epoch 更高的频率检查验证?

    谢谢!

  23. Prathap 2017 年 6 月 13 日 上午 5:45 #

    嗨,Jason博士,
    我正在使用 Keras 和 TensorFlow 后端。我已经按照你这里提到的方法保存了我的模型。但问题是加载权重所需的时间比预期要长。我只使用 CPU(而不是 GPU),因为我的模型是一种小型模型。你能告诉我如何提高模型的加载时间吗?与 sci-kit learn 的 pickled 模型的加载时间相比,这个时间非常长(将近 1 分钟)。

    • Jason Brownlee 2017 年 6 月 13 日 上午 8:26 #

      那可真够久的。

      确认是 Keras 导致的问题。

      也许是你的代码中其他地方的问题?

      也许你的硬盘非常慢?

      也许你的内存因为某些原因不足?

  24. Anastasios Selalmazidis 2017 年 6 月 18 日 上午 6:54 #

    嗨,Jason,

    网格搜索后如何保存模型?我一直收到错误:“AttributeError: ‘KerasClassifier’ object has no attribute ‘save’”

  25. AndreasM 2017 年 7 月 8 日 下午 2:02 #

    嗨,Jason,
    我有两个问题,
    1) 为什么你会在 load_weights() 之后第二次 compile() 模型来从文件中重新加载模型?
    2) 在这两个例子中,你都使用一个优化器在 fit() 之前 compile(),但在 load_weights() 之后传递了一个不同的优化器给 compile(),这没有问题吗?如果没有,那为什么我们要使用不同的优化器呢?

  26. Devakar 2017 年 7 月 18 日 下午 3:48 #

    我保存了模型和权重。然后我从其他 python 脚本上传模型,它不工作。为什么?

    如果保存和加载模型在同一个 python 脚本中,它就会工作。

    我对这种行为感到困惑。有什么帮助吗,谢谢。

  27. PandaN 2017 年 8 月 20 日 下午 8:34 #

    感谢这篇文章!很有帮助。
    不过我有个疑问——

    Keras 文档中提到:

    """
    你可以使用 model.save(filepath) 将 Keras 模型保存到一个 HDF5 文件中,该文件将包含

    – 模型的架构,允许重新创建模型
    – 模型的权重
    – 训练配置(损失、优化器)
    – 优化器的状态,允许从你离开的地方精确恢复训练。
    """

    如上所述,它还保存了训练配置(损失、优化器),为什么我们在加载模型和权重后还要再次编译?为什么我们不能直接在测试数据上进行评估?

    • Jason Brownlee 2017 年 8 月 21 日 上午 6:05 #

      自从我写这篇教程以来,API 已经发生了变化。你现在可以将模型保存在一个文件中,并且在加载后不再需要编译。

  28. jan balewski 2017 年 8 月 30 日 下午 4:15 #

    嗨,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() # 将打印

    • Jason Brownlee 2017 年 8 月 30 日 下午 4:21 #

      也许你可以使用函数式 API 定义你的模型,并将其保存为一个单独的模型。

      或者,你可以加载单独的模型,并使用函数式 API 将它们重新组合起来。

      我有一个关于函数式 API 的帖子计划发布,但在那之前,你可以在这里阅读它:
      https://keras.org.cn/getting-started/functional-api-guide/

      • jan balewski 2017 年 8 月 31 日 下午 12:23 #

        非常感谢 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() # 将打印

  29. Azam 2017 年 9 月 16 日 上午 3:49 #

    您好,我有一个五层模型。我保存了模型,然后我想只加载前四层。您能告诉我这是否可能吗?

    • Jason Brownlee 2017 年 9 月 16 日 上午 8:44 #

      我建议加载整个模型,然后重新定义它,移除你不想要的层。

  30. sirisha 2017 年 9 月 19 日 上午 10:39 #

    我训练了一个包含 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 Brownlee 2017 年 9 月 19 日 下午 3:46 #

      我不太确定我是否完全理解。

      通常,词嵌入是权重,必须作为模型的一部分在嵌入层中保存和加载。

      这有帮助吗?

      • sirisha 2017 年 9 月 19 日 下午 10:54 #

        如何检查嵌入层是否已保存?如果已保存,如何将未见文本文档作为输入传递给预测函数?

        • Jason Brownlee 2017 年 9 月 20 日 上午 5:56 #

          如果嵌入层是模型的一部分,并且你保存了模型,那么嵌入层将随模型一起保存。

          • Franco Arda 2018 年 7 月 23 日 下午 6:58 #

            感谢您,Jason,提供宝贵的答案!

            我花了一些时间才明白这一点。也就是说,在生产环境中,我只需调用我的模型 (h5) 即可获得词嵌入。

            生产代码很难:-/

          • PRAJWAL 2020 年 4 月 5 日 上午 2:33 #

            先生。您在 yolov3.weights 中保存所有项目权重的方式,如何保存我想要的那些项目。

          • Jason Brownlee 2020 年 4 月 5 日 上午 5:46 #

            我没有保存它们,我只是展示了如何加载它们。

  31. Arnab Ganguly 2017 年 9 月 21 日 上午 12:26 #

    嗨 Jason

    我能够加载权重和模型以及标签编码器,并且已经验证了测试集使用加载的模型给出了相同的预测。

    我的问题——即使搜索也找不到明确答案——是当有新的输入进来时,我如何对与此新输入相关的分类变量进行独热编码,以便列的顺序与训练数据完全匹配?

    如果无法做到这一点,我在一组新输入上的准确率接近 10%,而验证准确率是 89%。

    简单的问题是如何编码分类变量,以便新输入集合的输入数据与训练集匹配?可能不是一个真正的深度学习问题,但如果不这样做,我复杂的 LSTM 模型就无法工作。

    非常感谢您的帮助!

    • Jason Brownlee 2017 年 9 月 21 日 上午 5:44 #

      你必须使用与训练期间相同的编码。

      也许你使用自己的转换代码。
      也许你保存了转换对象。
      也许你根据训练数据在需要时重新创建转换并确认它是一致的。

      这有帮助吗?

  32. Arnab Ganguly 2017 年 9 月 21 日 下午 7:13 #

    嗨,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

    • Jason Brownlee 2017 年 9 月 22 日 上午 5:37 #

      我建议使用 sklearn 编码而不是 pandas 方法,这样你就可以保存对象和/或轻松地反转操作。

  33. Nirmesh 2017 年 9 月 23 日 下午 5:07 #

    你好,

    当我将此知识应用于我的代码时,我收到以下错误

    ##########
    跟踪(最近一次调用):
    文件“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: 无法创建组(符号表:无法初始化对象)

    #######################

    你能评论一下可能的原因吗?

    • Jason Brownlee 2017 年 9 月 24 日 上午 5:16 #

      抱歉,故障原因不明显。

      也许可以发布到 stackoverflow?

  34. Srinivas BN 2017 年 10 月 15 日 下午 5:02 #

    嗨,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]]]

    问题
    ========
    对于不同的输入值,我们期望在重新编译后得到不同的输出值。为什么我们得到任何输入值都相同的输出?

    • Jason Brownlee 2017 年 10 月 16 日 上午 5:42 #

      网络的输出应该具体(取决于)预测时提供的输入。

      如果不是这种情况,那么你的模型可能过度拟合了训练数据?

      • Srinivas BN 2017 年 10 月 16 日 下午 5:11 #

        嗨,布朗利,

        感谢您的快速回复。我无法理解“网络的输出应该具体(取决于)提供的输入”。你能详细解释一下吗?也许我没有正确理解上下文。

  35. Falgun 2017 年 11 月 9 日 上午 5:09 #

    嗨,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”

    你能帮忙吗?

    • Jason Brownlee 2017 年 11 月 9 日 上午 10:04 #

      “model”将是你训练好的模型的变量。

  36. Santanu Dutta 2017 年 11 月 13 日 上午 6:40 #

    很棒的帖子。我可以在本地保存和检索。但在 AWS lambda 中,由于 HDF5 格式,加载权重遇到了问题。你能提供任何解决方案或变通方法吗?

    • Jason Brownlee 2017 年 11 月 13 日 上午 10:23 #

      听到这个消息很遗憾。我本来以为 h5 格式是跨平台的。我相信它是。

      也许是 Python 2 与 Python 3 的问题。

  37. SHEKINA 2017 年 11 月 14 日 下午 6:26 #

    先生,
    请解释一下使用元启发式算法(如萤火虫算法、粒子群优化、头脑风暴优化等)进行特征选择的 python 代码……

    • Jason Brownlee 2017 年 11 月 15 日 上午 9:49 #

      感谢您的建议,我希望将来能涵盖这个话题。

  38. HyunWoo Cho 2017 年 12 月 14 日 下午 4:49 #

    加载模型和权重后,我需要编译模型进行评估吗?

    • Jason Brownlee 2017 年 12 月 15 日 上午 5:29 #

      我不再需要编译加载的模型了,API 已经改变了。

  39. Shabnam 2018 年 1 月 2 日 下午 5:07 #

    感谢 Jason 的帖子。我有一个问题。
    有没有类似的方法可以输出一个文件,表明模型已经编译?每次我运行文件时,都需要时间来编译模型,然后拟合和评估数据。我想更改参数/变量/超参数并再次运行文件,所以我想尽可能加快速度。

  40. Edoardo 2018 年 1 月 4 日 上午 3:25 #

    嗨,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

    如果可能的话,你能否提供一个在不同会话中保存和加载模型的示例?
    再次感谢

    • Jason Brownlee 2018 年 1 月 4 日上午 8:15 #

      有意思,我没有遇到过这个问题。

      一些可以探索的想法:

      – 你能否在不同的机器上重现相同的故障?例如在 AWS 上?
      – 你的所有库都是最新的吗?
      – 你是将权重和拓扑保存到一个文件中还是单独的文件中?
      – 你 100% 确定保存前后用于评估模型的数据是相同的吗?

  41. Tarun Madan 2018 年 1 月 18 日晚上 11:52 #

    嘿,Jason,这个教程很有帮助。

    但是,我有一个问题。我训练了一个 LSTM 模型用于序列分类问题,并观察到以下情况:

    在与训练模型相同的 python 会话中,我从加载的模型(使用 json 格式)获得了精确的结果(损失、准确率、预测概率)。但是,在新开的 python 会话中,结果并不完全相同,但非常接近。

    你能帮我理解为什么结果会略有不同吗?是否需要修复其他 random_seed 才能使结果完全匹配?

    期待您的回复。

    谢谢,
    Tarun

    • Jason Brownlee 2018 年 1 月 19 日上午 6:31 #

      内部状态肯定有一些随机性。

      我不太确定。有趣的发现!

  42. srishti 2018 年 2 月 7 日上午 2:35 #

    嗨!
    我需要将我的 LSTM 模型部署为 API,我该如何操作?

    非常感谢。

  43. vinay 2018 年 2 月 9 日下午 5:45 #

    我已经在 https://machinelearning.org.cn/save-load-keras-deep-learning-models/ 中看到了一个基本示例

    如何将模型保存为 ini 或 cfg 格式而不是 json

    • Jason Brownlee 2018 年 2 月 10 日上午 8:52 #

      抱歉,不支持其他格式。你可能需要编写自己的代码。

  44. Gaurav 2018 年 2 月 12 日下午 5:00 #

    嗨,Jason,

    我用 Keras 训练模型,验证准确率约为 50%,但当我按照你提到的代码保存并重新加载模型时,验证准确率只有 5%……加载的模型似乎表现得像未经训练的模型一样。

  45. Ayesha 2018 年 2 月 14 日下午 4:26 #

    嗨 Jason
    是否有可能在保存现有模型后,我想用新数据重新训练它。假设我的现有模型在 100 个数据集上进行了训练,但一段时间后,我想在新的 50 个数据集上重新训练它,以便它也能学习一些新的数据集以做出良好的预测。这意味着它现在将受到 150 个数据集的影响。

    需要你的帮助。

    提前感谢。

  46. simon 2018 年 2 月 21 日下午 6:39 #

    你好,

    有没有办法将 h5 和 json 文件转换为一个 hdf5 文件?
    我有很多对 h5 和 json 文件,但是当我需要将 keras 模型转换为 tensorflow pb 文件时,需要 hdf5 文件。

    谢谢,

  47. shan 2018 年 3 月 1 日上午 2:59 #

    你好,

    我正在将 keras 与 tensorflow 后端一起使用,但我的 .h5 文件无法保存,因为它显示未进行 UTF-8 编码 – 因此保存被禁用。

    你知道如何解决这个问题吗?

    谢谢

  48. luis 2018 年 3 月 3 日上午 5:07 #

    嗨,jason,非常感谢你提供的这个示例,它在处理保存和加载问题时最有帮助。我在将模型保存并加载到与训练模型不同的文件中后,遇到了拟合问题。它一直说模型未拟合。

    我尝试在创建和拟合模型的同一文件中进行预测,结果完美无缺。

    我保存拟合模型的文件

    我试图加载拟合模型的文件

    这给了我以下错误

    sklearn.exceptions.NotFittedError: 此 StandardScaler 实例尚未拟合。在使用此方法之前,请使用适当的参数调用 'fit'。

    -提前感谢

    • Jason Brownlee 2018 年 3 月 3 日上午 8:19 #

      听到这个消息我很难过,我没有见过这个故障。我很乐意提供帮助,但我无法为你调试你的示例,抱歉。

      • luis 2018 年 3 月 5 日上午 5:07 #

        我会继续努力的,无论如何还是谢谢你帮忙查看。

  49. Abhishek Kumar Soni 2018 年 3 月 18 日下午 3:17 #

    解释得很棒,先生。

  50. Hermesh 2018 年 3 月 20 日晚上 11:20 #

    嗨,Jason,
    非常感谢这篇出色的教程,非常有帮助。我们可以在 C++ 中加载保存的模型吗?我想用 Python 训练,然后在我自己的 C++ 程序中使用它进行预测。这可能吗?

  51. Rose 2018 年 3 月 24 日上午 7:32 #

    嗨,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/]???
    在本教程中,您使用了不同的命令来序列化模型,也使用了不同的命令来序列化权重。
    当您在提及的链接中保存模型时,单个文件将包含模型架构和权重,但在此教程中,您必须使用一些不同的命令来分别保存模型和保存权重。
    序列化模型和保存模型有什么区别??
    非常感谢您抽出时间指导我。
    我真的很感激。

    • Jason Brownlee 2018 年 3 月 25 日上午 6:23 #

      这篇帖子很好地总结了如何最终确定模型
      https://machinelearning.org.cn/train-final-machine-learning-model/

      通常,在所有可用数据上训练模型,然后将其保存到文件中。稍后加载它并用它开始对新数据进行预测。

      使用你喜欢的方法保存模型。你使用哪种方法并不重要。有些开发者对用于保存模型的文件类型有偏好。

      这有帮助吗?

  52. Rose 2018 年 3 月 25 日上午 9:17 #

    嗨,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 Brownlee 2018 年 3 月 26 日上午 9:55 #

      它们是等效的。选择你喜欢的方法,无论是保存到一个文件还是两个文件。

  53. Abdu 2018 年 4 月 14 日下午 2:15 #

    嗨,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])

    您的回复将不胜感激

    • Jason Brownlee 2018 年 4 月 15 日上午 6:21 #

      很抱歉,我无法为你调试你的代码。

      也许可以把你的代码发到 stackoverflow 上?

      • Abdu 2018 年 4 月 15 日上午 11:33 #

        代码运行良好。这个问题是许多使用 tensorflow-GPU 训练模型并保存权重以便稍后重新加载的人所面临的。有一个简单的修复方法,即重新训练模型一个 epoch 以恢复训练好的权重。我希望您能知道更好的方法。无论如何,谢谢。

  54. Brede 2018 年 4 月 16 日下午 6:52 #

    嗨,Jason,一如既往地感谢您提供精彩的内容。我在为一个工作项目时看到了这篇文章。您知道是否可以将权重上传到云存储(例如 Azure Blob 存储)吗?然后在需要使用权重时下载它们,并将其用于进一步训练?

    我目前的设置是按给定间隔保存我的权重,同时我也保存我的损失函数。然后我用我的损失值交叉检查,看看哪些权重是最好的(使用 GAN,所以最后一个权重不一定是最好的),并加载最好的模型。

    • Jason Brownlee 2018 年 4 月 17 日上午 5:56 #

      我想没问题,尽管我不知道“Azure Blob 存储”的具体细节。

      您可以毫无问题地将它们上传到 Amazon S3。

  55. Jeremiah 2018 年 5 月 10 日上午 3:07 #

    我真的非常感谢这个精彩的教程……这段代码帮了我很多

  56. Yuan Chen 2018 年 5 月 15 日上午 10:28 #

    嗨,Jason,

    您的博客在我的工作和学习中都帮了我很大的忙。我目前正在云端训练 Keras 模型,我遇到了直接将模型保存到 S3 的问题。
    你有什么解决方法吗?

    • Jason Brownlee 2018 年 5 月 15 日下午 2:43 #

      抱歉,我不知道如何直接保存到 S3。

  57. Gabriel C 2018 年 5 月 23 日上午 2:41 #

    我可以用同样的方法保存其他模型吗?
    LRN、SVM、KNN 模型,或者有其他方法吗?

  58. Nilanka 2018 年 5 月 24 日晚上 9:50 #

    谢谢 Jason。一篇非常需要且解释得很好的博客。

  59. Sharanya Desai 2018 年 6 月 2 日上午 9:19 #

    嗨,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)

  60. Narendra Chintala 2018 年 6 月 11 日上午 5:10 #

    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]]

    那是什么意思??

    如果我想知道模型预测的图像名称以及每个类别的概率,我该怎么做。

  61. Claude COULOMBE 2018 年 6 月 15 日上午 6:04 #

    很棒的博文和照片……我认出了2013年去世的魁北克雕塑家“罗伯特·鲁西尔”的作品。

  62. vamshi 2018年6月20日晚上8:55 #

    嗨,杰森,
    如何创建一个配置文件,以便我可以在不编辑原始CNN python脚本的情况下更改配置文件中的 epoch 大小、批处理大小、CNN 层数等?

    • Jason Brownlee 2018年6月21日上午6:18 #

      当然,这都只是代码。你可以用任何你想要的方式实现它。

  63. Ben 2018年6月28日上午3:51 #

    嗨 Jason,如果我在 Linux 操作系统上创建了一个 Keras 深度学习脚本,并且我的模型输出是 HD5……我该如何将其部署到另一台计算机上?

    我的 Linux 工作站位于办公室,我想在现场的 Windows 笔记本电脑上使用我的模型。我的 Windows 笔记本电脑上安装了 Keras,但是当我尝试使用 keras load_model 加载模型时,我收到一个错误,提示 Tensorflow 未安装。

    我甚至懒得在我的 Windows 笔记本电脑上尝试安装 TensorFlow,因为我认为 TensorFlow 不能在 Windows 上运行,对吗???有什么建议可以尝试吗??谢谢!

    • Jason Brownlee 2018年6月28日上午6:24 #

      该模型只是一个 n 维数字数组(权重)。

      您可以使用 Python 代码(或其他语言)手动进行预测,也可以使用 Keras+TF 库进行预测。

      如何部署模型实际上是一个工程决策。

      • Ben 2018年6月29日上午7:29 #

        你能给我一个建议(或链接到你的文章之一),告诉我如何在我的这边尝试一些不同的方法吗?除了 Keras load_model 方法之外,还有什么不同的方法可以在 Python 中保存深度学习模型?谢谢你……

  64. Ben Bartling 2018年7月11日上午6:24 #

    嗨,Jason,

    我对此有点了解……根据我所读到的,模型只是经过训练的权重。但是,如果一个深度学习模型是在 Keras 中训练的,是否还有其他方法可以在不使用 Keras 的情况下加载/保存模型?所有这些都源于想将模型部署到 Windows 操作系统,但模型是在 Linux 操作系统上训练的,当我使用 Keras load_model 方法时,我在 Windows 中收到一个错误,因为我没有安装 Tensorflow……

    我只是想弄清楚如果我无法在 Windows 操作系统上安装 Tensorflow,我能做些什么。谢谢!

    • Jason Brownlee 2018年7月11日下午2:51 #

      是的,理论上我不明白为什么你不能编写一些 Python 代码来使用已保存的 h5 中的权重进行预测。

      对于 MLP 来说这将非常容易,对于其他网络类型则需要一些工作。

      我没有这样做过,所以这只是一个即兴的意见。

      我之前已经成功地对 statsmodels 中的回归模型做过这个。

  65. Marwan 2018年7月13日下午7:10 #

    model.save('model.h5')

    ## 然后过了一会儿

    my_model = load_model('model.h5')

    ## 为什么这种方式会给我带来错误:
    NameError: name 'tf' is not defined

    • Jason Brownlee 2018年7月14日上午6:15 #

      抱歉,我没有见过这个错误。

      也许检查一下你是否安装了最新版本的库?

  66. Usman 2018年7月26日下午7:03 #

    我正在尝试在此页面保存模型:https://www.depends-on-the-definition.com/guide-sequence-tagging-neural-networks-python/
    代码的准确率约为98%,但是当我按照您上面描述的方式保存模型并重新运行代码以从加载的模块进行预测后,预测结果混乱,准确率在随机执行后下降到3%、4%、20%。我认为训练期间学习的嵌入没有保存。我还尝试使用 mode.save(path) 和 keras.reload_model() 保存整个模型,但它不起作用。
    我还尝试保存 word2idx 字典以保留词汇索引,但不幸的是,它不起作用。
    请帮我一下。谢谢

  67. Priyank 2018年9月14日下午7:39 #

    嘿 Jason,
    我有一个问题,我们能否在加载模型后再次训练它。例如,在执行 load_model 命令后,我们能否使用新数据再次训练同一个模型?如果可以,如何操作??

  68. Reza 2018年9月24日下午7:59 #

    你好,Jason。
    我正在使用 Keras 进行深度学习,并阅读您的 Keras 教程,我有一个问题想请教您。
    如果我们使用 Keras 构建和训练一个带有 CuDNN 层和 dropout 层的顺序深度网络,并且训练是在配备 GPU 的机器上完成的,我们打算部署这个模型,我们是否需要在配备 GPU 的 Docker 或任何其他容器上部署这个模型,或者是否有办法在轻量级的 CPU 机器上部署它,或者有什么其他技巧?
    谢谢。

    • Jason Brownlee 2018年9月25日上午6:19 #

      通常,Keras 模型可以在 CPU 或 GPU 上运行。我不知道 CuDNN 层的情况。

  69. Omkar Sunthankar 2018年10月4日下午7:34 #

    嗨 Jason,
    精彩的帖子,
    遇到一个错误。
    我训练了一个 LSTM 来预测 r、g、b 值。我将模型保存为 json,并将权重保存为 .h5 文件。但是当我再次加载它时,它给我的准确率相同,但预测结果却截然不同。我不确定问题出在哪里,验证准确率前后都相同。

  70. Youssef Eldakar 2018年10月5日凌晨12:52 #

    是否可以组合多个模型?我们可用的集群有多个节点,每个节点有2个GPU。我们正在考虑划分数据集,在每个节点上运行每个子集,保存模型,然后将所有保存的模型组合成一个以进行最终预测。这听起来是利用多个节点上更多GPU的正确想法吗?

    • Jason Brownlee 2018年10月5日上午5:38 #

      听起来像一个集成,也许可以尝试集成方法并与单个模型进行比较。如果看起来不错,那就加倍努力。

  71. FreedomFey 2018年10月9日下午5:02 #

    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))

    我保存了模型并加载它进行预测。
    我发现得分不一样。它下降了。为什么?

  72. zaheer 2018年10月18日下午9:24 #

    嗨。
    Jason,感谢您分享的帖子。它真的很有帮助。我有一个问题
    我有一个这样的列表。
    list=[1,2,3,[[3,4,5]]]
    我想把它转换成一个 ndarray。
    等待你的回复。

    • Jason Brownlee 2018年10月19日上午6:04 #

      也许可以将编程问题发布到 stackoverflow。

  73. Inas 2018年10月30日下午6:01 #

    我构建了一个模型并执行了 fit 函数,然后将该模型保存为 JSON 文件。当我加载保存的模型时,训练过的权重已加载,但如果我在另一个 Jupyter Notebook 单元格中检查权重,我发现权重和偏差返回到它们的初始未训练值?!!!!问题出在哪里?

    • Jason Brownlee 2018年10月31日上午6:21 #

      JSON只包含结构。您必须将权重保存到h5文件中。

  74. Adam 2018年10月30日下午8:32 #

    嗨 Jason

    在训练和保存加载的模型后,如何预测单个数据输入的输出?实际上,我需要知道如何对训练过的模型使用预测函数。

  75. Adam 2018年10月30日下午9:06 #

    我用以下方法进行预测

    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,)

    • Sjúrður 2018年10月31日上午6:15 #

      数组上的 reshape 方法不会原地重塑数组。您必须将返回的值赋给一个变量。

      所以只需更改

      AA.reshape(1, 8)

      推广到

      AA = AA.reshape(1, 8)

      它应该可以工作。

    • Jason Brownlee 2018年10月31日上午6:27 #

      我相信您的模型需要一维数组,而不是二维数组。

  76. MLT 2018年11月6日下午11:03 #

    嗨 Jason,非常感谢您的帖子。

    我可以问一下如何存储 lstm 模型吗?我尝试使用 model.save() 和 load_model()。我在训练后直接使用模型进行预测和加载模型进行预测之间得到了非常不同的结果。

    这可能是因为 LSTM 模型不仅包含模型和权重,还包含内部状态。是否有办法同时恢复内部状态?

    提前感谢。

  77. AMM 2018年11月20日下午5:54 #

    嗨,先生,非常感谢您非常有用的文章和您的回复。
    在我构建模型、编译、拟合之后,我将模型序列化为 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 Brownlee 2018年11月21日上午7:48 #

      也许尝试从命令行运行示例,并确保您的库是最新的?

      • Condy 2018年12月7日上午11:40 #

        好的,谢谢您的建议。

  78. Lina 2018年11月27日凌晨12:38 #

    嗨 Jason,我不太明白那一行
    loaded_model = model_from_json(loaded_model_json)
    model_from_json 部分从何而来?我应该如何定义它?
    谢谢你。

  79. Ola 2018年12月3日凌晨1:42 #

    嗨,Jason,
    感谢这个精彩的教程。我有一个问题,为什么您对初始编译和加载模型后的编译使用不同的优化器?
    非常感谢!

  80. Condy 2018年12月6日下午5:51 #

    嗨 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' 的定义

  81. Yogaraj 2018年12月6日下午7:27 #

    您好,先生,我开始学习机器学习,现在深入研究深度学习

    我使用 Keras 创建了自己的 CNN,并保存和加载了我创建的模型。

    现在,我不知道如何使用加载的模型进行预测……

    你能解释一下预测图像的代码吗

  82. Cheenu 2018年12月6日下午7:52 #

    太棒了,先生

  83. nandini 2018年12月13日下午9:03 #

    我能够加载 Keras 中已经训练过的模型。但是我们能否在已经训练过的模型上增加模型?
    如果模型获得新数据,它不应该从头开始,它必须与已经训练过的模型一起开始训练。

    请帮我解决这个需求。
    我希望在新数据上训练已经训练过的模型,而不是从头开始。

    • Jason Brownlee 2018年12月14日上午5:29 #

      是的,使用新数据再次调用 fit()。

      • nandini 2018年12月14日下午4:20 #

        它会运行良好,不会从头开始。

  84. Jonas Boecquaert 2019年1月17日下午8:58 #

    嗨,Jason,

    谢谢你的教程,它真的帮助了我。
    然而,有几件事我不明白。
    首次编译模型时,您使用“adam”作为优化器。
    但是当你加载保存的模型时,你却使用 RMSprop 作为优化器。
    这是为什么?难道不应该再次使用“adam”优化器吗,还是这不太重要?

    我还看到您发布了一个使用 Pickle 和 Joblib 序列化和保存模型的教程。
    是否有“最佳选择”来保存您的模型?使用 Pickle 或 Joblib 保存模型时,您似乎不会重新编译模型?这是为什么?是不是因为权重是单独保存到 h5 文件中的 json/yaml,而使用 Pickle/Joblib 时,权重是随主模型一起保存的?

    提前感谢您的时间,
    Jonas Boecquaert

    • Jason Brownlee 2019年1月18日上午5:36 #

      理想情况下应该使用相同的优化器,听起来像是个打字错误。不过没关系,它没有被使用。

      据我所知,你不能用 pickle 处理 Keras 模型。

  85. Afef 2019年1月21日下午11:27 #

    是否可以将整个模型(权重和架构)保存/加载到 json 文件?或者有没有可能在不使用 h5 文件的情况下保存整个模型?

    • Jason Brownlee 2019年1月22日上午6:23 #

      不,权重保存在 h5 中。您可以将整个模型通过 model.save() 保存到 h5。

      • Afef 2019年2月2日上午5:43 #

        好的。那么我能把这个H5文件转换成其他文件扩展名,比如.CSV或.mat吗?

        谢谢

        • Jason Brownlee 2019年2月2日上午6:26 #

          我不确定它是否是直接映射。

          您可以设计自己的映射,然后加载 h5 文件,枚举层和权重,并以您希望的任何格式输出。

          我没有工作示例,但这应该很简单。

  86. Nandini 2019年1月23日下午6:10 #

    我使用 keras 训练了 rnn(lstm) 模型分类,之后我对 X_test 数据进行了 model.predict_classes(X_test ),我得到了准确的结果,但是当从 h5 文件加载模型并从 json 文件加载配置到另一个文件时,我得到了随机预测。

    请就此问题给我建议,为什么我从文件加载后得不到正确的预测。

    • Jason Brownlee 2019年1月24日上午6:42 #

      抱歉,我没有见过这个问题,这听起来像是一个bug。也许使用有效的方法或者向 Keras 用户组报告这个bug?

  87. Jessie 2019年1月29日下午12:28 #

    在使用模型预测新的csv文件后,如何保存预测结果?另外,我的预测准确率很低,如何提高?

    请参阅此处的文档
    https://pandas.ac.cn/pandas-docs/stable/indexing.html#ix-indexer-is-deprecated
    (147725, 3, 14) (147725,)
    模型已从磁盘加载
    准确率:20.32%

    谢谢。

    • Jason Brownlee 2019年1月30日上午8:02 #

      预测结果将是一个numpy数组,您可以使用save()函数保存numpy数组
      https://docs.scipy.org.cn/doc/numpy/reference/generated/numpy.save.html

      • Jessie 2019年1月30日下午12:52 #

        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()

        像这样吗???

  88. Jessie 2019年1月30日下午1:22 #

    我应该保存哪个变量?

  89. Henry 2019年2月26日下午10:23 #

    看起来我们需要使用model.model来调用“to_json()”函数,请问您使用的是哪个版本?

  90. Ben 2019年3月1日上午2:17 #

    Jason,您能给我一个关于如何将Keras模型保存为pickle的提示吗?我正在使用您的帖子“使用Python中的Keras深度学习库进行回归教程”中的代码,并且模型是通过以下函数创建的:def larger_model():而不是model.fit方法......我有什么方法可以使用Keras API来保存pickle吗?谢谢

    • Jason Brownlee 2019年3月1日上午6:25 #

      我建议将模型保存为H5格式,而不是pickle,抱歉我无法帮助您使用pickle保存模型。

  91. ben 2019年3月7日上午8:57 #

    Jason,您好,我在Ubuntu中训练了一个模型,并保存了模型
    loaded_model.load_weights("demandFinal.h5")

    然后希望将该保存的.h5文件传输到我的Windows 10笔记本电脑(运行IPython anaconda 3.7发行版)上进行预测……但是我遇到了一些问题……

    除了Keras之外,我的Windows笔记本电脑上还需要安装Tensorflow等深度学习库吗?

    或者有没有其他方法可以保存模型,例如YML或json,以便在非创建模型的机器上使用该模型???

    谢谢..

    • Jason Brownlee 2019年3月7日下午2:30 #

      是的,后端(TensorFlow)和包装库(Keras)都需要安装。

  92. Radifan 2019年3月19日下午3:59 #

    嗨,Jason 先生

    我目前正在进行一个针对推文情感分析的二元分类深度学习项目,我训练了我的深度学习模型并保存了其模型和权重……问题是当我加载模型进行预测时,为什么这个模型总是对每个测试数据集给出相同的输出。例如:模型总是对所有测试数据集给出输出0,这导致我的准确率只有大约47% - 50%

    我尝试对我的数据集和模型参数进行了几次更改,例如创建平衡数据集、更改激活函数、学习率、 epoch 数量、批次大小、简化模型,但所有这些都没有显示出改进

    那么我该如何解决这个问题?

    谢谢..

  93. Tom F 2019年4月4日上午2:41 #

    感谢您的所有信息。我经常被引导到这里。

    Y_true 和 y_pred 是张量。它们与列表或 DataFrame 有何不同?我正在处理一个二元分类问题,所有模型都产生了太多的误报。我想要创建一个度量来最大化非误报。到目前为止,我只是返回

    K.sum(y_true – y_pred, axis = )

    我得到一个浮点数。我期望一个整数。使用 axis 1 或 0 会得到不同的结果,但我并不知道我是在哪个轴上求和。

    所有的指标都试图最大化吗?

  94. subhash inavolu 2019年4月5日下午6:28 #

    您不知道,我从您的博客中学到了多少……我是一名机械工程师,出于热情开始使用机器学习。每次我搜索机器学习相关内容时,您的博客都会是前三个结果之一(另一个是stackoverflow)。您真是把香蕉剥好皮喂到我们嘴里。干得太棒了,老板!!!!

  95. binF 2019年4月8日下午5:45 #

    嗨,Jason 先生
    我想问一下:模型可以重新加载并继续用于训练吗?这是基于之前的数据继续增加数据训练吗?换句话说,您可以使用大量数据进行预测并增加时间。在之前的基础上,是这样吗?谢谢!

    • Jason Brownlee 2019年4月9日上午6:21 #

      是的。您可以稍后加载模型并继续训练。

  96. Steve 2019年4月16日上午2:40 #

    嗨,Jason,

    我正在构建一个Conv1D模型进行多标签分类。
    首先,我将数据集分为70%训练集、20%测试集和10%验证集。
    训练一完成,我就进行测试,准确率达到了76%。
    但是,使用model.save(...)函数将模型保存到.h5文件后。并在不同的会话中加载此文件后,预测结果令人失望。现在在不同的数据集上的准确率约为25%。

    我使用相同的预处理步骤来清理评论。
    除了使用新的tokenizer实例来fit_on_texts,texts_to_sequences和pad_sequences,并使用与训练时使用的tokenizer相同的maxlen。

    如果您对这种准确率差异有任何建议,请告诉我。

    谢谢,
    Achira。

    • Jason Brownlee 2019年4月16日上午6:53 #

      如果您正在处理文本,您还必须以相同的方式在相同的数据上准备分词器,或者将分词器与模型一起保存。

  97. Steve 2019年4月17日下午2:30 #

    你好,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为类别数

    我有点卡在这个阶段,如果您能帮忙,我会很感激的 🙂

    谢谢!

    • Baptiste 2021年9月3日上午3:08 #

      天哪,你救了我这一周,史蒂夫,太感谢你了,应该说索引器是随机构建的

  98. Gaurav Mittal 2019年5月5日上午7:31 #

    Jason,您好,我创建了一个包含2个类别的Keras CNN序贯模型,现在想在不从头开始重新训练模型的情况下,向该模型添加2个类别。请问您是否有相关的博客/代码?

    • Jason Brownlee 2019年5月6日上午6:42 #

      很好的问题!

      也许您可以将所有权重作为起点,然后添加一个新的输出层。然后只训练输出层,并可能对其他层进行微调。

  99. jas 2019年7月15日下午8:45 #

    先生,您能告诉我如何通过使用.h5文件来预测我的数据吗?

  100. teimoor 2019年7月17日下午3:32 #

    你好,如何将lstm网络保存为numpy数组?我需要训练好的模型是numpy数组格式的,请帮帮我

    • Jason Brownlee 2019年7月18日上午8:18 #

      抱歉,您无法直接执行此操作。

      相反,我建议您将模型保存为H5文件。

  101. Amit Chaudhary 2019年7月22日下午7:08 #

    这两种方法中,哪种是保存和加载模型的首选方式?
    1. 分离模型结构和权重文件
    2. 单个文件包含两者

  102. zeinab 2019年8月4日下午6:03 #

    嗨,Jason,

    我创建了自己的Keras指标,名为correlation_coefficient。

    我成功保存了模型,并创建了一个model.h5文件。

    但是,当我尝试加载模型时,模型无法识别我的自定义指标,并出现以下错误

    ValueError: Unknown metric function:correlation_coefficient

    • Jason Brownlee 2019年8月5日上午6:49 #

      是的,您在加载模型时必须指定 custom_objects 参数,并传入一个字典,将函数名称映射到实际函数。

      例如

  103. Prem 2019年8月26日下午3:30 #

    嗨,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,您能帮我解决这个问题吗。

    • Jason Brownlee 2019年8月27日上午6:34 #

      抱歉,我无法帮助您解决此问题,也许可以尝试将代码和错误发布到stackoverflow?

  104. Anand 2019年8月29日下午5:31 #

    嗨,Jason,

    从保存的文件加载权重和模型后,如果我需要微调模型,该如何做?只是使用新数据集的fit命令吗?

    • Jason Brownlee 2019年8月30日上午6:15 #

      没错,使用fit命令并结合数据,也许可以降低学习率。

  105. Parikshit 2019年8月30日下午2:21 #

    嗨,Jason,

    我的模型在训练后输出.h5格式的权重,我希望将它们转换为.weight格式,有什么方法可以转换它们,或者有什么方法可以在训练时将权重保存为.weight格式

    • Jason Brownlee 2019年8月31日上午6:00 #

      .weight格式是什么?

      • Parikshit 2019年9月4日下午3:03 #

        这是一个包含从darknet框架获得的权重的文件

  106. SAYEED SHAFAYET CHOWDHURY 2019年9月3日下午10:32 #

    假设总epoch数为200,但训练时间太长,所以我首先想训练50个epoch,然后重新开始另一个训练,以此类推,但在所有训练阶段,训练数据都是相同的完整数据。在这种情况下,最后一个方法(权重和架构一起)会起作用吗?这与我一次性训练所有200个epoch而不是50个epoch * 4个阶段相同吗?

    • Jason Brownlee 2019年9月4日上午5:59 #

      是的,如果学习率恒定,对同一模型进行4次50个周期的运行与1次200个周期的运行是相同的。

  107. Mrig Nath 2019年9月10日下午2:57 #

    如何从json文件加载模型?

    • Jason Brownlee 2019年9月11日上午5:27 #

      如下

  108. Firas 2019年9月16日下午11:58 #

    你好 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 2019年9月17日上午6:29 #

      这很令人惊讶。

      您在保存前后是否在相同的数据上评估模型?

      您是否同时保存和加载了权重和结构?

  109. Cyp 2019年9月30日上午3:24 #

    你好 Jason Brownlee
    非常感谢您留下了这么好的教程

    我有一个问题,您还好吗?

    首先,这里是HDF文件,
    如果我们认为我们已经收集了新数据(分类是相同的)。

    那么当我加载该模型并将其应用于新数据进行预测时
    我们得到的值是否正确?

    我正在为此问题而苦恼。
    当新数据进来时,我们是否应该重新训练?

    谢谢!

    • Jason Brownlee 2019年9月30日上午6:18 #

      您可以决定在新数据到来时是否重新训练模型。

      只有当您能确认重新训练将使模型在未来表现更好时,重新训练才有意义。也许可以为您的特定数据集/领域测试这个想法。

  110. Dover 2019年11月13日上午6:21 #

    感谢您分享宝贵的机器学习经验。

    我有一个关于使用Keras和TensorFlow加载和使用预训练模型的问题。

    我加载并使用了.h5文件,但在我的笔记本电脑上需要半小时才能得到结果。但在另一台台式机上,只需1秒钟就能得到结果!您知道我的笔记本电脑出了什么问题吗?或者我应该修改哪些设置才能运行它?

    • Jason Brownlee 2019年11月13日下午1:40 #

      谢谢。

      这很奇怪。

      也许笔记本电脑的内存不足或CPU性能不够?

      • Dover 2019年11月16日上午6:59 #

        这我也猜到了,但是我的笔记本电脑有更好的内存和CPU。我也检查了不同的电脑。我发现在虚拟机、conda和virtualenv中,这些程序运行大约30分钟才能得到结果。我尝试在另一台电脑上用pip3命令安装tensorflow,它可以在1-2秒内得到结果。根据您的经验,通过pip3安装包并在终端直接运行是否会比在虚拟环境或PyCharm或Anaconda Spyder中更快?

        谢谢!

        • Jason Brownlee 2019年11月16日上午7:28 #

          我建议始终使用命令行。许多读者最终在使用笔记本和IDE时遇到问题。

  111. Tara Taji 2019年11月17日下午11:56 #

    嗨,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] 现有连接被远程主机强制关闭

    • Jason Brownlee 2019年11月18日上午6:46 #

      抱歉,我没有PyTorch的教程,也许可以尝试在stackoverflow上发帖?

  112. Marvin 2019年11月19日上午6:24 #

    为什么我总是收到这个异常

    JSONDecodeError: Expecting value: line 1 column 1 (char 0)

    当我尝试运行这个时

    loaded_model=model_from_json(loaded_model_json)

  113. Aristotelis Charalampakis 2019年12月28日下午7:35 #

    你好,

    我相信您是最适合回答以下问题的人:我不想仅仅保存模型,我实际上想创建一个函数来预测值,并可能在另一种语言中使用它,也就是说,我希望使用神经网络的权重和架构来编写一个简单的函数。这可能吗?

    感谢您的出色工作,非常有帮助!

    • Jason Brownlee 2019年12月29日上午6:02 #

      是的。

      您需要在程序中加载模型权重,并以与Keras代码相同的方式执行前向传播操作——对于MLP网络通常很简单,对于其他网络则更难。

  114. srinivas 2020年1月13日上午3:19 #

    嗨,Jason,
    实际上我为图像分类选择了6个类别的图像,但输出显示我有7个类别。我不知道为什么?我该如何解决这个问题。请帮帮我。
    谢谢你。

    • Jason Brownlee 2020年1月13日上午8:28 #

      也许可以仔细检查一下您的数据是否按预期加载。

  115. Srinivas 2020年1月13日上午4:59 #

    我选择了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)

    • Jason Brownlee 2020年1月13日上午8:30 #

      也许可以尝试将您的代码和问题发布到stackoverflow?

  116. rohit 2020年1月30日上午5:13 #

    你好,先生,我在导入文件时遇到了这个错误
    请帮帮我,先生

    >>> 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”
    >>>

  117. wasif 2020年2月3日上午4:11 #

    我有大量特征。我通过改变特征数量来训练几个keras模型,以查看这些特征对模型准确性的影响。最后,当我加载这些模型时,我不再知道模型是在哪些特征上训练的,因此当我进行预测时,我得到如下错误:

    检查输入时出错:预期dense_4_input的形状为(29,),但得到了形状为(47,)的数组

    有没有办法知道模型是在哪些确切的特征名称上训练的?我使用keras.models.load_model加载模型,使用keras.models.sequence.save(path)保存模型

    • Jason Brownlee 2020年2月3日上午5:47 #

      是的,您可以访问模型的第一层并访问其形状。

  118. raghu betageri 2020年2月3日下午11:55 #

    添加 from keras.models import model_from_json 来使用
    loaded_model = model_from_json(loaded_model_json)

  119. Maren 2020年2月17日上午3:48 #

    你好 Jason,很喜欢你的教程(也买了书)!
    我卡在加载一个以PReLU作为激活函数的模型上。我收到了ValueError。我尝试了
    model = load_model(‘model.h4’, custom_objects={‘…’:…}),但我未能正确定义custom_object。你知道如何加载PReLU吗?
    非常感谢!

    • Jason Brownlee 2020年2月17日上午7:51 #

      暂时不知道,抱歉。也许可以尝试在 Stack Overflow 上提问?

      • Maren 2020年2月18日下午6:04 #

        这个奏效了
        - 明确地将其作为层加载(从tensorflow.keras.layers import PReLU)
        - 然后将其作为custom_objects={‘PReLU’: PReLU}加载

  120. Ned 2020年2月23日上午7:54 #

    你好
    我正在遵循一个示例,第一步是使用这个类作为神经网络
    {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”
    你能帮帮我吗?

    • Jason Brownlee 2020年2月24日上午7:32 #

      你的例子看起来是 PyTorch,而这篇文章是关于 Keras 的。也许可以尝试在 Stack Overflow 上发布你的问题?

  121. farukgogh 2020年2月26日下午11:14 #

    嗨,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)

  122. Mohammed Samir 2020年3月4日上午3:06 #

    嗨,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: 无法在只读模式下创建组。

    我想知道解决方案是什么,或者我如何避免这种情况,

    此致,
    穆罕默德

    • Jason Brownlee 2020年3月4日上午5:58 #

      抱歉,我不知道原因,也许可以尝试将你的代码和错误发布到 Stack Overflow 上。

    • Livan 2020年3月31日上午1:57 #

      嗨,希望你一切都好。你找到解决方案了吗?我遇到了同样的问题。
      此致

  123. Mehmet 2020年3月7日下午1:48 #

    谢谢——解释得很清楚

  124. fifi 2020年3月10日下午7:10 #

    你好 Jason。我想问你为什么每次运行代码,结果都会改变?真的需要一个解释,因为输出将不一致

  125. Siddharth 2020年4月4日上午1:42 #

    嗨,Jason
    很棒的教程,但我有一个疑问,您在本教程中保存的权重是 .h5 格式的。
    但是,如果您想将它们保存为“.mat”格式,如何保存和加载权重?

  126. Kai 2020年4月4日下午9:34 #

    嗨 Jason,谢谢你的教程。

    我成功地使用了保存和加载模型来构建我的模型训练,使用了不同的数据批次。以前由于数据量太大,无法利用 GPU。
    基本上,我在将数据拆分为训练和验证数据之前,会随机化数据的索引。
    在每次训练迭代中,我都会取一部分训练数据,并进行15个 epoch。在所有训练迭代中,我都使用相同的验证数据进行验证。

    当我这样做时,准确性实际上反而下降了。我想知道如果我采用这种方法,验证数据是否应该始终保持不变?

    • Jason Brownlee 2020年4月5日上午5:44 #

      我不确定我是否理解。

      一般来说,测试和验证数据不得用于模型训练,以对模型进行公正的评估。

      • Kai 2020年4月5日下午12:37 #

        嗨 Jason,我就是这么做的。首先,我将数据分成了训练集和验证集。

        在训练数据样本中,我将它们分成块,然后逐块用于训练模型,因为数据量很大。

        但是对于每次训练,我都使用了相同的验证样本。我在想,既然我把训练数据切成了块,那么验证集占总数据集大小的25%是否合理呢?

        • Jason Brownlee 2020年4月5日下午1:42 #

          或许吧,只要验证集能代表更广泛的问题。

          过度关注验证集(试图优化其结果)会导致过拟合。

  127. gkrislara 2020年4月10日上午12:23 #

    你好,
    有没有关于冻结 Keras 模型的教程?

    • Jason Brownlee 2020年4月10日上午8:32 #

      嗯,我猜我在许多计算机视觉和 GAN 教程中展示了冻结层。

      也许可以尝试在博客上搜索一下。

  128. John 2020年4月14日上午2:01 #

    尊敬的Jason先生,

    感谢您免费提供所有在线资料。

    我的第一个深度学习代码运行完美,通过将 epoch 设置为 200,我能够将其准确率调整到 80.20%。

    在获得上述结果后,我开始考虑捕获模型并稍后加载它进行预测。在 Google 上进行了一些搜索后,我被引导回了这个网站。

    我尝试了示例,它运行完美。

    再次感谢。

  129. Aravind Kuchibhatla 2020年4月23日上午8:50 #

    嗨,谢谢你的文章。我使用了以下代码:keras.models.load_model(“modelS.h5”),但我收到了这个错误:ValueError: Unknown layer: KerasLayer。你有没有办法解决这个问题?

    • Jason Brownlee 2020年4月23日下午1:34 #

      我没有见过这个错误,也许可以尝试在 Stack Overflow 上发布你的代码和错误。

  130. Michael 2020年5月2日下午7:24 #

    你好,Jason,谢谢分享。
    当我想用多个文件训练模型时,我该怎么做?
    谢谢你

    • Jason Brownlee 2020年5月3日上午6:08 #

      将文件加载到内存中,将它们组合成一个数据集,然后用它们训练模型。

      • Zahid Akhtar 2020年5月5日下午7:27 #

        你好,jason 。 。 。
        我在做信用卡欺诈检测项目。 。 。我有 .h5 格式的模型,但我不明白接下来如何处理该 .h5 格式的模型,也就是说,我不明白如何将该模型部署到 Web 上。 。基本上,我想通过在网页上输入来检测交易是否是欺诈性的,但我不知道如何将该 model.h5 模型部署到该网页上。 。 。你能告诉我后续步骤和所需的工具吗?

        • Jason Brownlee 2020年5月6日上午6:25 #

          在您的自定义代码中加载模型,并使用应用程序中的数据调用它。

          在网页中使用模型更多是工程问题,而不是机器学习问题。

  131. Anand Kumar 2020年5月12日上午2:18 #

    我通过 model.save() 函数保存了模型,加载时我使用 keras.models.load_model(cnnmodel_path)。它在我的机器上运行良好,但当我在 Amazon ECS 实例上执行时,它抛出了一个异常“Cannot create group in read only mode.”(无法在只读模式下创建组)。

    • Jason Brownlee 2020年5月12日上午6:49 #

      这是一个奇怪的错误,也许可以尝试在 Stack Overflow 上搜索/发布?

  132. Rishav Chatterjee 2020年5月30日下午4:11 #

    你好,我正在使用 NER 并遵循以下链接中的代码:
    https://www.depends-on-the-definition.com/named-entity-recognition-with-residual-lstm-and-elmo/
    但是,我无法保存模型然后加载它。你能帮我解决这个问题吗?我对机器学习和这些主题是新手。

  133. Wiama 2020年6月12日下午10:29 #

    如果我们有模型的json文件描述和权重,我们可以继续/迁移训练新的数据集吗?

  134. kimhun 2020年7月4日下午10:35 #

    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’)

    但它发生了这个问题

    我该怎么解决它?

    • Jason Brownlee 2020年7月5日上午7:04 #

      也许确认模型是否已正确保存?例如,尝试再次保存并重新加载?

      或许确保你的库是最新的。

  135. JONATA PAULINO DA COSTA 2020年7月20日上午11:31 #

    当我尝试加载数据库时,它会显示以下错误
    ValueError: 无法将字符串转换为浮点数:‘\ufeff6,148,72,35,0,33.6,0.627,50,1’

    我从您在教程中提供的链接下载了数据库。我将其保存为csv,但出现了这个错误。

  136. sampriti 2020年7月22日上午7:07 #

    下面这行代码不起作用。

    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)。

  137. George 2020年7月22日上午10:30 #

    嗨 Jason,如何将 Keras 子类模型的权重保存为单个文件,它会保存为文件夹

    model.save_weights('./model_weights', save_format='tf')

    子类模型不能保存为 .h5 格式
    谢谢

    • Jason Brownlee 2020年7月22日下午1:41 #

      为什么不呢?我自己没试过,只是好奇。

      或许你可以手动检索权重矩阵并保存为二进制文件?

  138. Fateh Aliyev 2020年8月29日上午7:05 #

    你好,顺便说一句,这篇帖子很棒,但如果你有 k 折交叉验证,你会怎么做?我为每个折叠保存了权重,但我不知道如何将它们平均成一个 .h5 文件作为权重。我该如何将几个权重平均起来?

  139. MariosGavaletakis 2020年9月14日上午2:02 #

    不错的教程。

    我有一个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个模型都保存在内存中?如果是,有没有办法在下一次迭代开始前“清除内存”?

  140. Aicha Maaouia 2020年11月13日下午9:39 #

    嗨,Jason,

    感谢您的这个有用的教程,
    实际上,我在保存 h5 文件时遇到一个错误

    ErrorCode: 需要一个字节类对象,而不是“str”

    你能帮我解决这个问题吗?
    谢谢你

  141. Ahmed 2020年11月14日下午11:32 #

    我刚做了这个

    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”

    • Jason Brownlee 2020年11月15日上午6:26 #

      一些想法

      或许直接使用教程中演示的Keras API?
      或许使用Python 3.6,我不知道3.8是否受支持?

  142. Gholam Ali 2020年12月8日上午2:46 #

    嗨,Jason,
    非常感谢您提供的精彩教程。
    我根据您的教程,使用自己的二分类数据,构建了一个CNN模型+Google嵌入,测量了准确率(即精确度:0.7)。然后保存模型并加载,再使用相同的数据集让模型进行标注。我手动比较了结果,发现精确度只有0.15!
    这种差距有什么原因吗?
    谢谢你

    • Jason Brownlee 2020年12月8日 上午7:46 #

      不客气。

      一旦模型训练完成,它在相同的数据集上应该/会给出相同的性能。

      或许可以检查您的测试工具中是否存在错误,并确保您在每次加载模型时都没有重新训练模型。

  143. Abu-Abdurrahman 2020年12月10日 下午6:31 #

    嗨,Jason,
    感谢您提供如此精彩的内容。
    我训练了一个孪生网络,并尝试使用本文中提到的方法进行保存和加载,即使在我使用的lambda层存在的情况下,我仍然不断收到“SystemError: unknown opcode”的错误。

    我尝试了用TensorFlow 2.3训练和加载模型,但仍然收到相同的错误

  144. Irikio 2021年1月2日 上午10:27 #

    亲爱的 Jason,

    我非常感谢您精彩的内容;
    我发现加载训练好的tflearn模型有些困难。
    我以这种方式保存了我的模型:model.save('model.tflearn'),然后,我试图在一个新的notebook中加载它,首先我构建模型并定义它,这样我就可以将模型变量分配给model.load('model.tflearn'),但我收到了一系列错误,阻止我加载它。

    期待您的回复,

    • Jason Brownlee 2021年1月2日 下午12:05 #

      谢谢!

      很抱歉,也许可以尝试不用notebook运行代码。

  145. Matt 2021年2月10日 下午7:45 #

    感谢您的精彩教程,Jason!

    这真的帮助我轻松进入机器学习领域!

  146. Fatemeh 2021年3月3日 上午11:56 #

    嗨,Jason,
    谢谢您的帖子。我们如何提高load_model时间?我的模型很小。另外,我们如何使用模型权重来预测新图像?

    • Jason Brownlee 2021年3月3日 下午1:56 #

      不客气。

      也许可以使用更小的模型?
      也许更快的硬盘?

      • Fatemeh 2021年3月4日 上午6:04 #

        感谢您的回复。我使用了一个非常浅的DenseNet版本,它只有0.5M参数,文件大小也只有7MB。

  147. abatecaller 2021年3月9日 上午3:54 #

    如何保存和加载:CNN_LSTM多元多步时间序列模型的权重——运行30次并使用箱线图进行预测?

    • Jason Brownlee 2021年3月9日 上午5:24 #

      好问题,本教程向您展示如何保存和加载模型
      https://machinelearning.org.cn/save-load-keras-deep-learning-models/

      • abatecaller 2021年3月11日 上午2:16 #

        @Jason,保存所有30个权重——模型运行30次——的最佳方式是什么?
        (1)在循环中运行并在循环中保存。
        (2)有没有一种方法可以在循环外部创建模型函数,从而一次性保存所有30次运行及其权重。

        • Jason Brownlee 2021年3月11日 上午5:12 #

          你为什么要那样做?

          是的,在循环中调用 save() 并使用唯一的文件名。

  148. raymond 2021年3月29日 上午3:49 #

    感谢这些教程,它们真的很有帮助。我的问题是,如果我在不同的IDE上运行教程,我会得到非常不同的结果,例如,如果我在pycharm上运行序列化教程,我会得到大约37%的准确率,而使用spyder-ide运行相同的代码,我会得到大约78%的准确率,这可能是由什么引起的。我希望这些值彼此接近,因为它们是完全相同的代码。

  149. john 2021年4月25日 下午10:07 #

    先生,一个问题。如果我将模型的权重保存为.h5文件,我如何才能在磁盘上找到这个文件?它保存在我的电脑的哪个位置?我使用google collab的jupyter notebook来执行训练模拟。

    • Jason Brownlee 2021年4月26日 上午5:37 #

      您必须指定系统上的路径位置才能保存。

      如果您不指定路径,它将保存在与您的python文件相同的位置。

      我不建议使用notebook
      https://machinelearning.org.cn/faq/single-faq/why-dont-use-or-recommend-notebooks

      • Shubham 2021年4月26日 下午5:30 #

        你好 jason,

        我有一个小问题……假设我们为A类(例如钢笔)训练YOLO模型……我们得到权重文件,然后使用这个权重文件再次为B类(例如铅笔)训练模型……那么结果权重文件将能够检测A类和B类对象吗?
        例如,如果我们使用一张同时包含钢笔和铅笔的图片……它能识别它们两者吗?

  150. Krishnendu Das 2021年5月3日 下午5:03 #


    我安装了以下版本

    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 结束

  151. Chandra Sekhar Vorugunti 2021年5月4日 上午3:42 #

    嗨,Jason,精彩的讲座。我正在研究GAN,并训练了我的生成器,将架构存储在JSON文件中,将权重存储在.h5文件中。在测试期间,我加载了json架构和H5文件。现在您提到了如下的编译步骤

    loaded_model.compile(loss=’binary_crossentropy’, optimizer=’rmsprop’, metrics=[‘accuracy’])

    同样,为了编译我的生成器模型,如何编译?编译时使用哪个损失函数?因为生成器是使用重建损失等进行训练的,并且在训练中没有编译阶段,请指教。

    • Jason Brownlee 2021年5月4日 上午6:47 #

      谢谢!

      不再需要编译,只需加载并开始使用即可。

  152. Ronald Ssebadduka 2021年8月2日 下午1:57 #

    亲爱的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)

  153. manuela 2021年9月11日 上午3:20 #

    问题
    我有一个文件(model.h5),我想以源代码(file.ipynb)的形式打开它。这可能吗?

    • Adrian Tam
      Adrian Tam 2021年9月11日 上午6:43 #

      该模型似乎是一个以HDF5格式保存的Keras模型。尝试查找keras.models.load_model()函数。但如果文件没有完整的模型,您必须先获取原始模型源代码才能使用它。

  154. Baibhav Nag 2021年9月23日 下午4:04 #

    嗨 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'

    请告诉我问题出在哪里。这种方法不能保存混合模型吗?

  155. Greg 2021年9月29日 上午2:31 #

    model.to_json() 给我一个 NotImplementedError。我之前尝试过 .save(),但当我重新加载时,我得到了一个维度错误,这让我开始考虑保存权重。如果 to_json 和 save 对我不起作用,我该怎么办?

    • Adrian Tam
      Adrian Tam 2021年9月30日 上午12:59 #

      它已经说明了一切。to_json() 不支持此模型。save() 应该可以工作,但您必须将其加载回相同的模型中。如果出现任何问题(例如,某个层的尺寸不同),您将收到尺寸错误。

  156. Jagadeesh 2022年4月3日 上午12:55 #

    你好 Jason,

    正如讨论的那样
    https://machinelearning.org.cn/manually-optimize-neural-networks/?unapproved=654896&moderation-hash=fe3b8b1630d977e40be66ecc358cfaf7#comment-654896

    我们如何将手动神经网络保存为模型?

  157. Sajin 2022年4月7日 下午2:22 #

    来自json的模型在自定义层方面失败。有什么想法吗?

    • Adrian Tam
      Adrian Tam 2022年4月8日 上午5:23 #

      因为Keras默认情况下不会理解您的自定义层。您需要告诉Keras您是如何实现自定义层的。请参阅此处的示例:https://tensorflowcn.cn/guide/keras/save_and_serialize

  158. paul 2022年6月20日 下午8:56 #

    关于保存加载Keras深度学习模型的优秀博客。我们是技术新闻提供商之一,提供与技术工具最新发展相关的新闻。我们从各个跨国公司收集信息,并根据类别进行分配。

  159. Meenakshi 2023年1月8日 上午3:44 #

    @Jason Brownlee

    您能解释一下如何在Keras中重新训练/微调加载的模型吗?

  160. Meenakshi 2023年1月8日 下午9:13 #

    @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”)

  161. Ben White 2023年12月15日 下午9:02 #

    当你将权重与模型分开保存,然后重新组合时,计算机如何知道哪个权重属于哪个神经元?大概有一些位置信息……

    如果你能帮我解决这个问题,那就太好了。

留下回复

Machine Learning Mastery 是 Guiding Tech Media 的一部分,Guiding Tech Media 是一家领先的数字媒体出版商,专注于帮助人们了解技术。访问我们的公司网站以了解更多关于我们的使命和团队的信息。