深度學習-Tensorflow2.2-模型保存與恢復{9}-保存與恢復-21

模型保存(tf.keras保存模型)

• 保存
  • Tf.Keras 模型保存為 HDF5 文件
  • Keras 使用了 h5py Python 包。
  • h5py 是 Keras 的依賴項，應默認被安裝
• 保存/加載整個模型

  • 不建議使用 pickle 或 cPickle 來保存模型。

  • 使用 model.save(‘path/to/my_model.h5’) 將整個模型保存到單個 HDF5 文件中。

  • 包括以下內容：

    • · 模型的結構，允許重新創建模型
    • · 模型的權重
    • · 訓練配置項（損失函數，優化器）
    • · 優化器狀態，允許准確地從你上次結束的地方繼續訓練。

  • 保存/加載整個模型可使我們在不訪問原始 python 代碼的情況下使用模型。還可以從中斷的位置恢復訓練。

  • 保存完整模型會非常有用——我們可以在 TensorFlow.js (HDF5, Saved Model) 加載保存的模型，然后在 web 瀏覽器中訓練和運行它們，或者使用 TensorFlow Lite 將它們轉換為在移動設備上運行(HDF5, Saved Model)

  • 重新創建完全相同的模型，包括其權重和優化程序new_model = tf.keras.models.load_model(‘my_model.h5’)

  • Keras 通過檢查網絡結構來保存模型。

  • 目前，它無法保存 Tensorflow 優化器（調用自tf.train）。使用這些優化器的時候，需要在加載后重新編譯模型，否則將失去優化器的狀態。

  • 通過 saved_model 格式保存（實驗性的，未來可能變化）：tf.keras.experimental.export_saved_model(model, saved_model_path)

  • 通過 saved_model 格式恢復：new_model =tf.keras.experimental.load_from_saved_model(sav
    ed_model_path)

  • 通過 saved_model 格式恢復：saved_model 格式包含完整的TensorFlow程序，是tensorflow對象的獨立序列化格式，包括權重和計算。它不需要運行原始模型構建代碼，這使得它可用於共享或部署（使用TFLite，TensorFlow.js，TensorFlow服務）

• 只保存/加載模型的結構
  • 保存模型的結構，而非其權重或訓練配置項:Config = model.get_config()
  • 得到的是一個Python Dict，它使我們可以重新創建相同的結構的模型
  • 加載模型的結構，而非其權重或訓練配置項:Reinitialized_model = tf.keras.Model.from_config(config)
  • 保存模型的結構，也可以使用json字符串，方便保存到磁盤:json_string = model.to_json()
  • Reinitialized_model = tf.keras.models.model_from_json(json_string )
  • 只保存模型的權重:model.save_weights(‘my_model_weights.h5’)
  • 只加載模型的權重 :model.load_weights(‘my_model_weights.h5’)
  • 注意保存和加載模型的權重 :既可以使用HDF5格式也可以使用SavedModel格式，取決於后綴，也可以通過 save_format參數來顯式指定。
  • 參數可以取： tf 或 h5
• 在訓練期間保存模型
  • tf.keras.callbacks.ModelCheckpoint 允許在訓練的過程中和結束時回調保存的模型。

例子

import os
import tensorflow as tf
import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
os.environ['TF_FORCE_GPU_ALLOW_GROWTH'] = 'true'

gpu_ok = tf.test.is_gpu_available()
print("tf version:", tf.__version__)
print("use GPU", gpu_ok) # 判斷是否使用gpu進行訓練

# 下載數據集並划分為訓練集和測試集
(train_image,train_lable),(test_image,test_label) = tf.keras.datasets.fashion_mnist.load_data()

# 歸一化
train_image=train_image/255
test_image=test_image/255

# 建立模型
model = tf.keras.Sequential()
model.add(tf.keras.layers.Flatten(input_shape=(28,28))) # 28*28
model.add(tf.keras.layers.Dense(128,activation="relu"))
model.add(tf.keras.layers.Dense(10,activation="softmax"))

# 編譯模型
model.compile(optimizer="adam",
             loss="sparse_categorical_crossentropy",
             metrics=["acc"]
             )

# 使用訓練集訓練模型
model.fit(train_image,train_lable,epochs=5)

# 使用測試集進行評價
model.evaluate(test_image,test_label)

保存整個模型
整個模型可以保存到一個文件中，其中包含權重值、模型配置乃至優化器配置。這樣，您就可以為模型設置檢查點，並稍后從完全相同的狀態繼續訓練，而無需訪問原始代碼。

在 Keras 中保存完全可正常使用的模型非常有用，您可以在 TensorFlow.js 中加載它們，然后在網絡瀏覽器中訓練和運行它們。

Keras 使用 HDF5 標准提供基本的保存格式。

# 保存模型:此方法保存以下所有內容：
# 1.權重值 2.模型配置（架構） 3.優化器配置
model.save("./save/less_model.h5")

# 加載模型
new_model = tf.keras.models.load_model("./save/less_model.h5")
new_model.summary()# 查看模型架構

# 使用測試集進行評價
new_model.evaluate(test_image,test_label)

僅保存架構
有時我們只對模型的架構感興趣，而無需保存權重值或優化器。在這種情況下，可以僅保存模型的“配置” 。

• 保存架構只需要使用with open 文件操作方法把json_config 把配置寫入磁盤就行

json_config = model.to_json()

json_config

# 重建模型
reinitialized_model = tf.keras.models.model_from_json(json_config)
reinitialized_model.summary()

# 編譯
reinitialized_model.compile(optimizer="adam",
             loss="sparse_categorical_crossentropy",
             metrics=["acc"]
             )

# 使用測試集進行評價 因權重是隨機的所以准確率稍微降低了
reinitialized_model.evaluate(test_image,test_label)

僅保存權重
有時我們只需要保存模型的狀態（其權重值），而對模型架構不感興趣。在這種情況下，可以通過get_weights()獲取權重值，並通過set_weights()設置權重值

weights = model.get_weights()

# 加載權重
reinitialized_model.set_weights(weights)

# 使用測試集進行評價 
reinitialized_model.evaluate(test_image,test_label)

# 把權重保存到磁盤上
model.save_weights("./save/less_weights.h5")

# 從磁盤上加載權重
reinitialized_model.load_weights("./save/less_weights.h5")
# 使用測試集進行評價 
reinitialized_model.evaluate(test_image,test_label)

在訓練期間保存檢查點
在訓練期間或訓練結束時自動保存檢查點。這樣一來，您便可以使用經過訓練的模型，而無需重新訓練該模型，或從上次暫停的地方繼續訓練，以防訓練過程中斷。

回調函數：tf.keras.callbacks.ModelCheckpoint

Checkpoint_path = "./save/cp.cpkt" # 定義路徑

cp_callback = tf.keras.callbacks.ModelCheckpoint(Checkpoint_path,
                                                 save_weights_only=True)# 只保存權重save_weights_only=True

# 建立模型
model = tf.keras.Sequential()
model.add(tf.keras.layers.Flatten(input_shape=(28,28))) # 28*28
model.add(tf.keras.layers.Dense(128,activation="relu"))
model.add(tf.keras.layers.Dense(10,activation="softmax"))

# 編譯模型
model.compile(optimizer="adam",
             loss="sparse_categorical_crossentropy",
             metrics=["acc"]
             )

# 使用訓練集訓練模型
model.fit(train_image,train_lable,epochs=5,callbacks=[cp_callback]) # 每訓練一個epoch后保存一次

# 使用檢查點文件
model.load_weights(Checkpoint_path)

model.evaluate(test_image,test_label)

自定義中保存模型

import os
import tensorflow as tf
import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
os.environ['TF_FORCE_GPU_ALLOW_GROWTH'] = 'true'

gpu_ok = tf.test.is_gpu_available()
print("tf version:", tf.__version__)
print("use GPU", gpu_ok) # 判斷是否使用gpu進行訓練

(train_image, train_lable), (test_image, test_label) = tf.keras.datasets.fashion_mnist.load_data()

train_image = train_image/255
test_image = test_image/255

model = tf.keras.Sequential()
model.add(tf.keras.layers.Flatten(input_shape=(28,28)))  # 28*28
model.add(tf.keras.layers.Dense(128, activation='relu'))
model.add(tf.keras.layers.Dense(10))

optimizer = tf.keras.optimizers.Adam()

loss_func = tf.keras.losses.SparseCategoricalCrossentropy(from_logits=True)

def loss(model, x, y):
    y_ = model(x)
    return loss_func(y, y_)

def train_step(model, images, labels):
    with tf.GradientTape() as t:
        pred = model(images)
        loss_step = loss_func(labels, pred)
    grads = t.gradient(loss_step, model.trainable_variables)
    optimizer.apply_gradients(zip(grads, model.trainable_variables))
    train_loss(loss_step)
    train_accuracy(labels, pred)

train_loss = tf.keras.metrics.Mean('train_loss', dtype=tf.float32)
train_accuracy = tf.keras.metrics.SparseCategoricalAccuracy('train_accuracy')
test_loss = tf.keras.metrics.Mean('test_loss', dtype=tf.float32)
test_accuracy = tf.keras.metrics.SparseCategoricalAccuracy('test_accuracy')

cp_dir = './save' # 存儲路徑
cp_prefix = os.path.join(cp_dir, 'ckpt')

checkpoint = tf.train.Checkpoint(optimizer=optimizer,
                                 model=model 
) # 需要保存的參數

dataset = tf.data.Dataset.from_tensor_slices((train_image, train_lable))

dataset = dataset.shuffle(10000).batch(32)

def train():
    for epoch in range(5):
        for (batch, (images, labels)) in enumerate(dataset):
            train_step(model, images, labels)
        print('Epoch{} loss is {}'.format(epoch, train_loss.result()))
        print('Epoch{} Accuracy is {}'.format(epoch, train_accuracy.result()))
        train_loss.reset_states()
        train_accuracy.reset_states()
        if (epoch + 1) % 2 == 0:
            checkpoint.save(file_prefix = cp_prefix)

train()

tf.train.latest_checkpoint(cp_dir)

# 恢復模型 
checkpoint.restore(tf.train.latest_checkpoint(cp_dir)) # 取出最新的檢查點

tf.argmax(model(train_image, training=False), axis=-1).numpy() # 取出預測值

train_lable # 實際值

# 求出正確率
(tf.argmax(model(train_image, training=False), axis=-1).numpy() == train_lable).sum()/len(train_lable)