tensorflow训练好的模型的保存与加载

1.先来安装一下需要模块 h5py

!pip install pyyaml h5py

2.导入需要的块

import os
import tensorflow as tf 
from tensorflow import keras
tf.__version__

3.下载数据集

(train_images, train_labels), (test_images, test_labels) = tf.keras.datasets.mnist.load_data()
train_labels = train_labels[:1000]
test_labels = test_labels[:1000]
#图片像素值是0~255之间，除以255后就是0~1之间， 就等于正规化了
train_images = train_images[:1000].reshape(-1, 28*28)/255
test_images = test_images[:1000].reshape(-1, 28*28)/255

4.建立模型函数

def create_model():
    model = tf.keras.models.Sequential([
        keras.layers.Dense(512, activation='relu', input_shape=(784,)),
        keras.layers.Dropout(0.2),
        keras.layers.Dense(10)
    ])
    model.compile(optimizer='adam',
                 loss=tf.losses.SparseCategoricalCrossentropy(from_logits=True),
                 metrics=[tf.metrics.SparseCategoricalAccuracy()])
    return model
model = create_model()
model.summary()

运行结果：
Model: “sequential”

---

Layer (type) Output Shape Param #

dense (Dense) (None, 512) 401920

dropout (Dropout) (None, 512) 0

dense_1 (Dense) (None, 10) 5130

=================================================================
Total params: 407,050
Trainable params: 407,050
Non-trainable params: 0

---

5. 建立callback对像，用来保存模型

checkpoint_path = 'train_1/cp.ckpt'
checkpoint_dir = os.path.dirname(checkpoint_path)
cp_callback = tf.keras.callbacks.ModelCheckpoint(filepath=checkpoint_path,
                                                save_weights_only=True,
                                                verbose=1)

6.训练模型，利用上面的callback对像将每次的模型参数保存起来

model.fit(train_images,
          train_labels,
          epochs=10,
          validation_data=(test_images, test_labels),
          callbacks=[cp_callback]
         )

运行结果：
Epoch 1/10
26/32 [=>…] - ETA: 0s - loss: 1.2783 - sparse_categorical_accuracy: 0.6190
Epoch 1: saving model to train_1\cp.ckpt
32/32 [] - 2s 24ms/step - loss: 1.1724 - sparse_categorical_accuracy: 0.6540 - val_loss: 0.7471 - val_sparse_categorical_accuracy: 0.7720
Epoch 2/10
29/32 [>…] - ETA: 0s - loss: 0.4310 - sparse_categorical_accuracy: 0.8836
Epoch 2: saving model to train_1\cp.ckpt
32/32 [] - 1s 16ms/step - loss: 0.4393 - sparse_categorical_accuracy: 0.8810 - val_loss: 0.5445 - val_sparse_categorical_accuracy: 0.8420
Epoch 3/10
28/32 [=>…] - ETA: 0s - loss: 0.3115 - sparse_categorical_accuracy: 0.9196
Epoch 3: saving model to train_1\cp.ckpt
32/32 [] - 1s 17ms/step - loss: 0.3100 - sparse_categorical_accuracy: 0.9190 - val_loss: 0.4756 - val_sparse_categorical_accuracy: 0.8470
Epoch 4/10
29/32 [>…] - ETA: 0s - loss: 0.2209 - sparse_categorical_accuracy: 0.9537
Epoch 4: saving model to train_1\cp.ckpt
32/32 [] - 1s 17ms/step - loss: 0.2129 - sparse_categorical_accuracy: 0.9560 - val_loss: 0.4474 - val_sparse_categorical_accuracy: 0.8480
Epoch 5/10
29/32 [>…] - ETA: 0s - loss: 0.1490 - sparse_categorical_accuracy: 0.9709
Epoch 5: saving model to train_1\cp.ckpt
32/32 [] - 0s 15ms/step - loss: 0.1568 - sparse_categorical_accuracy: 0.9680 - val_loss: 0.4371 - val_sparse_categorical_accuracy: 0.8530
Epoch 6/10
28/32 [=>…] - ETA: 0s - loss: 0.1235 - sparse_categorical_accuracy: 0.9766
Epoch 6: saving model to train_1\cp.ckpt
32/32 [] - 1s 18ms/step - loss: 0.1242 - sparse_categorical_accuracy: 0.9770 - val_loss: 0.4137 - val_sparse_categorical_accuracy: 0.8700
Epoch 7/10
28/32 [=>…] - ETA: 0s - loss: 0.0813 - sparse_categorical_accuracy: 0.9900
Epoch 7: saving model to train_1\cp.ckpt
32/32 [] - 0s 15ms/step - loss: 0.0867 - sparse_categorical_accuracy: 0.9880 - val_loss: 0.3981 - val_sparse_categorical_accuracy: 0.8680
Epoch 8/10
28/32 [=>…] - ETA: 0s - loss: 0.0726 - sparse_categorical_accuracy: 0.9922
Epoch 8: saving model to train_1\cp.ckpt
32/32 [] - 1s 18ms/step - loss: 0.0716 - sparse_categorical_accuracy: 0.9920 - val_loss: 0.4304 - val_sparse_categorical_accuracy: 0.8590
Epoch 9/10
29/32 [>…] - ETA: 0s - loss: 0.0502 - sparse_categorical_accuracy: 0.9957
Epoch 9: saving model to train_1\cp.ckpt
32/32 [] - 0s 15ms/step - loss: 0.0530 - sparse_categorical_accuracy: 0.9940 - val_loss: 0.4048 - val_sparse_categorical_accuracy: 0.8700
Epoch 10/10
30/32 [=>…] - ETA: 0s - loss: 0.0415 - sparse_categorical_accuracy: 0.9990
Epoch 10: saving model to train_1\cp.ckpt
32/32 [============================] - 1s 18ms/step - loss: 0.0436 - sparse_categorical_accuracy: 0.9980 - val_loss: 0.4064 - val_sparse_categorical_accuracy: 0.8680
<keras.callbacks.History at 0x1f846018a60>
7.用os.listdir查看一下目录下的内容

os.listdir(checkpoint_dir)

[‘checkpoint’, ‘cp.ckpt.data-00000-of-00001’, ‘cp.ckpt.index’]

8.新建一个没有训练的实例化模型来看一下准确率有多少

model = create_model()
loss, acc = model.evaluate(test_images, test_labels, verbose=2)
print('Untrained model, accuracy:{:5.2f}%'.format(100*acc))

运行结果：
32/32 - 0s - loss: 2.3725 - sparse_categorical_accuracy: 0.0990 - 292ms/epoch - 9ms/step
Untrained model, accuracy: 9.90%
@()@可以看出准确率只有9.9%

9.让我们加载一下第6步训练好的模型来做一下测试：

model.load_weights(checkpoint_path)
loss, acc = model.evaluate(test_images, test_labels, verbose=2)
print('Restored model, accuracy:{:5.2f}%'.format(100*acc))

32/32 - 0s - loss: 0.4064 - sparse_categorical_accuracy: 0.8680 - 136ms/epoch - 4ms/step
Restored model, accuracy:86.80
@()@可以看出准确率与第6步的最后准确率差不多为86.8%

10. 重新建一个保存模型的对目录

checkpoint_path = 'training_2/cp-{epoch:04d}.ckpt'
checkpoint_dir = os.path.dirname(checkpoint_path)
batch_size = 32
checkpoint_path

11.重新建一个保存模型的对像

cp_callback = tf.keras.callbacks.ModelCheckpoint(
    filepath=checkpoint_path,
    verbose=1,
    save_weights_only=True,
    save_freq=5*batch_size    
)

12.重新实像化一个模型来训练，并将每次训练的模型保存成ckpt格式的文件

model = create_model()
model.save_weights(checkpoint_path.format(epoch=0))

13.再一次训练模型

model.fit(train_images,
          train_labels,
          epochs=50,
          batch_size=batch_size,
          callbacks=[cp_callback],
          validation_data=(test_images, test_labels),
          verbose=0
         )

运行结果：
Epoch 5: saving model to training_2\cp-0005.ckpt

Epoch 10: saving model to training_2\cp-0010.ckpt

Epoch 15: saving model to training_2\cp-0015.ckpt

Epoch 20: saving model to training_2\cp-0020.ckpt

Epoch 25: saving model to training_2\cp-0025.ckpt

Epoch 30: saving model to training_2\cp-0030.ckpt

Epoch 35: saving model to training_2\cp-0035.ckpt

Epoch 40: saving model to training_2\cp-0040.ckpt

Epoch 45: saving model to training_2\cp-0045.ckpt

Epoch 50: saving model to training_2\cp-0050.ckpt
<keras.callbacks.History at 0x1f84819ac70>

14.查看一下目录下面的文件

os.listdir(checkpoint_dir)

[‘checkpoint’,
‘cp-0000.ckpt.data-00000-of-00001’,
‘cp-0000.ckpt.index’,
‘cp-0005.ckpt.data-00000-of-00001’,
‘cp-0005.ckpt.index’,
‘cp-0010.ckpt.data-00000-of-00001’,
‘cp-0010.ckpt.index’,
‘cp-0015.ckpt.data-00000-of-00001’,
‘cp-0015.ckpt.index’,
‘cp-0020.ckpt.data-00000-of-00001’,
‘cp-0020.ckpt.index’,
‘cp-0025.ckpt.data-00000-of-00001’,
‘cp-0025.ckpt.index’,
‘cp-0030.ckpt.data-00000-of-00001’,
‘cp-0030.ckpt.index’,
‘cp-0035.ckpt.data-00000-of-00001’,
‘cp-0035.ckpt.index’,
‘cp-0040.ckpt.data-00000-of-00001’,
‘cp-0040.ckpt.index’,
‘cp-0045.ckpt.data-00000-of-00001’,
‘cp-0045.ckpt.index’,
‘cp-0050.ckpt.data-00000-of-00001’,
‘cp-0050.ckpt.index’]

15.用tf.train.latest_checkpoint方法来调出最后一次的保存的模型

latest = tf.train.latest_checkpoint(checkpoint_dir)
latest

运行结果：
‘training_2\cp-0050.ckpt’
@()@我们刚才训练了50轮，上面保存的是第50轮时的模型参数

16.再实例化一个模型，加载刚才训练好的模型来做一下测试

model = create_model()
model.load_weights(latest)
loss, acc = model.evaluate(test_images, test_labels)

运行结果：
32/32 [==============================] - 0s 6ms/step - loss: 0.4901 - sparse_categorical_accuracy: 0.8800
@()@这个准确率是88%，还不错

17.再来做个测试，用新实例化的模型做测试看 一下结果

model = create_model()
loss, acc = model.evaluate(test_images, test_labels, verbose=2)
print('Restored model , accuracy :{:5.2f}%'.format(100*acc))

运行结果：
32/32 - 0s - loss: 2.3740 - sparse_categorical_accuracy: 0.0780 - 428ms/epoch - 13ms/step
Restored model , accuracy : 7.80%
@()@可以看出，准确率又回到了7.8%， 没训练的就是不一样

18.下面用测试集训练一下模型并保存起来

model = create_model()
model.fit(test_images, train_labels, epochs=5)

Epoch 1/5
32/32 [] - 1s 11ms/step - loss: 2.3827 - sparse_categorical_accuracy: 0.1000
Epoch 2/5
32/32 [] - 0s 11ms/step - loss: 2.1427 - sparse_categorical_accuracy: 0.2330
Epoch 3/5
32/32 [] - 0s 12ms/step - loss: 2.0369 - sparse_categorical_accuracy: 0.2840
Epoch 4/5
32/32 [] - 0s 11ms/step - loss: 1.8927 - sparse_categorical_accuracy: 0.3620
Epoch 5/5
32/32 [==============================] - 0s 11ms/step - loss: 1.7910 - sparse_categorical_accuracy: 0.4170
<keras.callbacks.History at 0x1f848234220>
@()@经过5轮的训练准确率达到41.7%

19.把刚才的模型保存到指定的目录

!mkdir -p saved_model
model.save('svaed_model/my_model')

output_folder1 = 'svaed_model2'
model.save(filepath=output_folder1,save_format='tf')

运行结果:
INFO:tensorflow:Assets written to: svaed_model2\assets

20.加载一下刚才的模型

new_model = tf.keras.models.load_model(r'svaed_model2/')
new_model.summary()

运行结果：
Model: “sequential_6”

---

Layer (type) Output Shape Param #

dense_12 (Dense) (None, 512) 401920

dropout_6 (Dropout) (None, 512) 0

dense_13 (Dense) (None, 10) 5130

=================================================================
Total params: 407,050
Trainable params: 407,050
Non-trainable params: 0

---

21.看一下损失函数与精度

loss, acc = model.evaluate(test_images, test_labels, verbose=2)
print('Restored model , accuracy :{:5.2f}%'.format(100*acc))

运行结果：
32/32 - 1s - loss: 2.4994 - sparse_categorical_accuracy: 0.1250 - 514ms/epoch - 16ms/step
Restored model , accuracy :12.50%

@()@tensorflow保存模型到此结束

引用：
https://tensorflow.google.cn/tutorials/keras/save_and_load?hl=zh-cn