下面是一个YouTube视频，它确切地解释了你想做什么：Save and load a Keras model
Keras提供了三种不同的保存方法。这些在上面的视频链接中描述（有例子），以及下面。
首先，您收到错误的原因是您错误地调用了load_model。
若要保存和加载模型的权重，首先应使用

model.save_weights('my_model_weights.h5')

字符串
来保存权重，正如你所展示的。要加载权重，首先需要构建模型，然后在模型上调用load_weights，如

model.load_weights('my_model_weights.h5')

型
另一种保存技术是model.save(filepath)。此save函数可保存：

• 模型的体系结构，允许重新创建模型。
• 模型的权重。
• 训练配置（损失，优化器）。
• 优化器的状态，允许在您停止的地方完全恢复训练。

要加载此已保存的模型，应使用以下命令：

from keras.models import load_model
new_model = load_model(filepath)'

型
最后，model.to_json()只保存模型的架构。若要加载体系结构，可以使用

from keras.models import model_from_json
model = model_from_json(json_string)

型

加载权重需要先有模型。必须是：

existingModel.save_weights('weightsfile.h5')
existingModel.load_weights('weightsfile.h5')

字符串
如果你想保存和加载整个模型（包括模型的配置、权重和优化器状态，以便进一步训练）：

model.save_model('filename')
model = load_model('filename')

型

由于这个问题已经很老了，但仍然会出现在谷歌搜索中，我认为指出保存Keras模型的更新（和推荐）方法会很好。现在建议使用SavedModel格式，而不是像以前那样使用旧的h5格式保存它们，SavedModel格式实际上是一个包含模型配置和权重的字典。
更多信息可以在这里找到：https://www.tensorflow.org/guide/keras/save_and_serialize
要保存和加载的代码段可以在下面找到：

model.fit(test_input, test_target)
# Calling save('my_model') creates a SavedModel folder 'my_model'.
model.save('my_model')

# It can be used to reconstruct the model identically.
reconstructed_model = keras.models.load_model('my_model')

字符串
以下示例的输出：

的数据

从头开始加载模型需要从头开始构建模型，因此您可以尝试首先使用model.to_json()保存模型体系结构

model_architecture = model.to_json()

字符串
使用保存模型重量

model.save_weights('model_weights.h5')

型
为了加载权重，您需要首先使用保存的json文件重建模型。

from tensorflow.keras.models import model_from_json
model = model_from_json(model_architecture)

型
然后使用

model.load_weights('model_weights.h5')

型
你现在可以编译和测试模型，不需要重新训练，例如

model.compile(loss=keras.losses.SparseCategoricalCrossentropy(from_logits=True),
          optimizer=keras.optimizers.Adam(lr=0.001), metrics=["accuracy"])

model.evaluate(x_test, y_test, batch_size=32, verbose=2)

型

checkpoint_path = save_train_data + "/" + "model.{epoch:02d}-" + ".h5"
save_weight = MultiGPUCheckpointCallback(filepath=checkpoint_path,
                                         base_model=model,
                                         save_weights_only=True)

   history = model.fit(x=train_dataset, validation_data=valid_dataset,
                        steps_per_epoch=int(np.ceil(training_step_nums. / BATCH_SIZE)),
                        validation_steps=int(np.ceil(validation_nums / BATCH_SIZE)),
                        epochs=EPOCHES, verbose="auto", callbacks=[save_weight])

字符串
保存权重回调函数如下：

import warnings
import numpy as np
from keras.callbacks import Callback

class MultiGPUCheckpointCallback(Callback):
    def __init__(self, filepath, base_model, monitor='val_loss', verbose=0,
                 save_best_only=False, save_weights_only=False,
                 mode='auto', period=1):
        super(MultiGPUCheckpointCallback, self).__init__()
        self.base_model = base_model
        self.monitor = monitor
        self.verbose = verbose
        self.filepath = filepath
        self.save_best_only = save_best_only
        self.save_weights_only = save_weights_only
        self.period = period
        self.epochs_since_last_save = 0

        if mode not in ['auto', 'min', 'max']:
            warnings.warn('ModelCheckpoint mode %s is unknown, '
                          'fallback to auto mode.' % (mode),
                          RuntimeWarning)
            mode = 'auto'

        if mode == 'min':
            self.monitor_op = np.less
            self.best = np.Inf
        elif mode == 'max':
            self.monitor_op = np.greater
            self.best = -np.Inf
        else:
            if 'acc' in self.monitor or self.monitor.startswith('fmeasure'):
                self.monitor_op = np.greater
                self.best = -np.Inf
            else:
                self.monitor_op = np.less
                self.best = np.Inf

    def on_epoch_end(self, epoch, logs=None):
        logs = logs or {}
        self.epochs_since_last_save += 1
        if self.epochs_since_last_save >= self.period:
            self.epochs_since_last_save = 0
            filepath = self.filepath.format(epoch=epoch + 1, **logs)
            if self.save_best_only:
                current = logs.get(self.monitor)
                if current is None:
                    warnings.warn('Can save best model only with %s available, '
                                  'skipping.' % (self.monitor), RuntimeWarning)
                else:
                    if self.monitor_op(current, self.best):
                        if self.verbose > 0:
                            print('Epoch %05d: %s improved from %0.5f to %0.5f,'
                                  ' saving model to %s'
                                  % (epoch + 1, self.monitor, self.best,
                                     current, filepath))
                        self.best = current
                        if self.save_weights_only:
                            self.base_model.save_weights(filepath, overwrite=True)
                        else:
                            self.base_model.save(filepath, overwrite=True)
                    else:
                        if self.verbose > 0:
                            print('Epoch %05d: %s did not improve' %
                                  (epoch + 1, self.monitor))
            else:
                if self.verbose > 0:
                    print('Epoch %05d: saving model to %s' % (epoch + 1, filepath))
                if self.save_weights_only:
                    self.base_model.save_weights(filepath, overwrite=True)
                else:
                    self.base_model.save(filepath, overwrite=True)

型