सहायता Kaggle पर TensorFlow साथ ग्रेट बैरियर रीफ की रक्षा चैलेंज में शामिल हों

मॉडल सहेजें और लोड करें

TensorFlow.org पर देखें Google Colab में चलाएं GitHub पर स्रोत देखें नोटबुक डाउनलोड करें

प्रशिक्षण के दौरान और बाद में मॉडल प्रगति को बचाया जा सकता है। इसका मतलब है कि एक मॉडल फिर से शुरू कर सकता है जहां उसने छोड़ा था और लंबे प्रशिक्षण समय से बच सकता है। बचत का अर्थ यह भी है कि आप अपने मॉडल को साझा कर सकते हैं और दूसरे आपके काम को फिर से बना सकते हैं। अनुसंधान मॉडल और तकनीकों को प्रकाशित करते समय, अधिकांश मशीन लर्निंग प्रैक्टिशनर साझा करते हैं:

  • मॉडल बनाने के लिए कोड, और
  • मॉडल के लिए प्रशिक्षित वजन, या पैरामीटर

इस डेटा को साझा करने से दूसरों को यह समझने में मदद मिलती है कि मॉडल कैसे काम करता है और नए डेटा के साथ इसे स्वयं आज़माएं।

विकल्प

आपके द्वारा उपयोग किए जा रहे API के आधार पर TensorFlow मॉडल को सहेजने के विभिन्न तरीके हैं। यह मार्गदर्शिका TensorFlow में मॉडल बनाने और प्रशिक्षित करने के लिए tf.keras , एक उच्च-स्तरीय API का उपयोग करती है। अन्य तरीकों के लिए TensorFlow सेव एंड रिस्टोर गाइड या सेविंग इन बेसब्री देखें।

सेट अप

इंस्टॉल और आयात

TensorFlow और निर्भरताएँ स्थापित और आयात करें:

pip install pyyaml h5py  # Required to save models in HDF5 format
import os

import tensorflow as tf
from tensorflow import keras

print(tf.version.VERSION)
2.6.0

एक उदाहरण डेटासेट प्राप्त करें

भार को बचाने और लोड करने का तरीका प्रदर्शित करने के लिए, आप MNIST डेटासेट का उपयोग करेंगे। इन रनों को गति देने के लिए, पहले 1000 उदाहरणों का उपयोग करें:

(train_images, train_labels), (test_images, test_labels) = tf.keras.datasets.mnist.load_data()

train_labels = train_labels[:1000]
test_labels = test_labels[:1000]

train_images = train_images[:1000].reshape(-1, 28 * 28) / 255.0
test_images = test_images[:1000].reshape(-1, 28 * 28) / 255.0
Downloading data from https://storage.googleapis.com/tensorflow/tf-keras-datasets/mnist.npz
11493376/11490434 [==============================] - 0s 0us/step
11501568/11490434 [==============================] - 0s 0us/step

एक मॉडल को परिभाषित करें

एक साधारण अनुक्रमिक मॉडल बनाकर प्रारंभ करें:

# Define a simple sequential model
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

# Create a basic model instance
model = create_model()

# Display the model's architecture
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
_________________________________________________________________

प्रशिक्षण के दौरान चौकियों को बचाएं

आप किसी प्रशिक्षित मॉडल को फिर से प्रशिक्षित किए बिना उपयोग कर सकते हैं, या प्रशिक्षण प्रक्रिया के बाधित होने की स्थिति में जहां आपने छोड़ा था, वहां से पिक-अप प्रशिक्षण ले सकते हैं। tf.keras.callbacks.ModelCheckpoint कॉलबैक आपको प्रशिक्षण के दौरान और अंत में मॉडल को लगातार सहेजने की अनुमति देता है।

चेकपॉइंट कॉलबैक उपयोग

एक tf.keras.callbacks.ModelCheckpoint कॉलबैक बनाएं जो केवल प्रशिक्षण के दौरान वजन बचाता है:

checkpoint_path = "training_1/cp.ckpt"
checkpoint_dir = os.path.dirname(checkpoint_path)

# Create a callback that saves the model's weights
cp_callback = tf.keras.callbacks.ModelCheckpoint(filepath=checkpoint_path,
                                                 save_weights_only=True,
                                                 verbose=1)

# Train the model with the new callback
model.fit(train_images, 
          train_labels,  
          epochs=10,
          validation_data=(test_images, test_labels),
          callbacks=[cp_callback])  # Pass callback to training

# This may generate warnings related to saving the state of the optimizer.
# These warnings (and similar warnings throughout this notebook)
# are in place to discourage outdated usage, and can be ignored.
Epoch 1/10
32/32 [==============================] - 1s 7ms/step - loss: 1.1073 - sparse_categorical_accuracy: 0.6970 - val_loss: 0.6858 - val_sparse_categorical_accuracy: 0.8060

Epoch 00001: saving model to training_1/cp.ckpt
Epoch 2/10
32/32 [==============================] - 0s 3ms/step - loss: 0.4064 - sparse_categorical_accuracy: 0.8920 - val_loss: 0.5468 - val_sparse_categorical_accuracy: 0.8370

Epoch 00002: saving model to training_1/cp.ckpt
Epoch 3/10
32/32 [==============================] - 0s 3ms/step - loss: 0.2853 - sparse_categorical_accuracy: 0.9260 - val_loss: 0.4540 - val_sparse_categorical_accuracy: 0.8520

Epoch 00003: saving model to training_1/cp.ckpt
Epoch 4/10
32/32 [==============================] - 0s 3ms/step - loss: 0.2085 - sparse_categorical_accuracy: 0.9530 - val_loss: 0.4369 - val_sparse_categorical_accuracy: 0.8520

Epoch 00004: saving model to training_1/cp.ckpt
Epoch 5/10
32/32 [==============================] - 0s 4ms/step - loss: 0.1573 - sparse_categorical_accuracy: 0.9690 - val_loss: 0.4295 - val_sparse_categorical_accuracy: 0.8580

Epoch 00005: saving model to training_1/cp.ckpt
Epoch 6/10
32/32 [==============================] - 0s 4ms/step - loss: 0.1141 - sparse_categorical_accuracy: 0.9780 - val_loss: 0.4432 - val_sparse_categorical_accuracy: 0.8540

Epoch 00006: saving model to training_1/cp.ckpt
Epoch 7/10
32/32 [==============================] - 0s 3ms/step - loss: 0.0844 - sparse_categorical_accuracy: 0.9850 - val_loss: 0.4102 - val_sparse_categorical_accuracy: 0.8630

Epoch 00007: saving model to training_1/cp.ckpt
Epoch 8/10
32/32 [==============================] - 0s 4ms/step - loss: 0.0597 - sparse_categorical_accuracy: 0.9940 - val_loss: 0.4085 - val_sparse_categorical_accuracy: 0.8700

Epoch 00008: saving model to training_1/cp.ckpt
Epoch 9/10
32/32 [==============================] - 0s 3ms/step - loss: 0.0497 - sparse_categorical_accuracy: 0.9970 - val_loss: 0.4164 - val_sparse_categorical_accuracy: 0.8670

Epoch 00009: saving model to training_1/cp.ckpt
Epoch 10/10
32/32 [==============================] - 0s 3ms/step - loss: 0.0398 - sparse_categorical_accuracy: 0.9990 - val_loss: 0.4289 - val_sparse_categorical_accuracy: 0.8670

Epoch 00010: saving model to training_1/cp.ckpt
<keras.callbacks.History at 0x7f271e52a8d0>

यह TensorFlow चेकपॉइंट फ़ाइलों का एक एकल संग्रह बनाता है जो प्रत्येक युग के अंत में अद्यतन किए जाते हैं:

os.listdir(checkpoint_dir)
['cp.ckpt.index', 'cp.ckpt.data-00000-of-00001', 'checkpoint']

जब तक दो मॉडल समान आर्किटेक्चर साझा करते हैं, आप उनके बीच भार साझा कर सकते हैं। इसलिए, किसी मॉडल को केवल वज़न से पुनर्स्थापित करते समय, मूल मॉडल के समान आर्किटेक्चर वाला मॉडल बनाएं और फिर उसका वज़न सेट करें।

अब एक नए, अप्रशिक्षित मॉडल का पुनर्निर्माण करें और परीक्षण सेट पर इसका मूल्यांकन करें। एक अप्रशिक्षित मॉडल मौका स्तरों पर प्रदर्शन करेगा (~ 10% सटीकता):

# Create a basic model instance
model = create_model()

# Evaluate the 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.3458 - sparse_categorical_accuracy: 0.0820
Untrained model, accuracy:  8.20%

फिर चेकपॉइंट से वज़न लोड करें और पुनर्मूल्यांकन करें:

# Loads the weights
model.load_weights(checkpoint_path)

# Re-evaluate the model
loss, acc = model.evaluate(test_images, test_labels, verbose=2)
print("Restored model, accuracy: {:5.2f}%".format(100 * acc))
32/32 - 0s - loss: 0.4289 - sparse_categorical_accuracy: 0.8670
Restored model, accuracy: 86.70%

चेकपॉइंट कॉलबैक विकल्प

कॉलबैक चौकियों के लिए अद्वितीय नाम प्रदान करने और चेकपॉइंटिंग आवृत्ति को समायोजित करने के लिए कई विकल्प प्रदान करता है।

एक नए मॉडल को प्रशिक्षित करें, और हर पांच युग में एक बार विशिष्ट नामित चौकियों को बचाएं:

# Include the epoch in the file name (uses `str.format`)
checkpoint_path = "training_2/cp-{epoch:04d}.ckpt"
checkpoint_dir = os.path.dirname(checkpoint_path)

batch_size = 32

# Create a callback that saves the model's weights every 5 epochs
cp_callback = tf.keras.callbacks.ModelCheckpoint(
    filepath=checkpoint_path, 
    verbose=1, 
    save_weights_only=True,
    save_freq=5*batch_size)

# Create a new model instance
model = create_model()

# Save the weights using the `checkpoint_path` format
model.save_weights(checkpoint_path.format(epoch=0))

# Train the model with the new callback
model.fit(train_images, 
          train_labels,
          epochs=50, 
          batch_size=batch_size, 
          callbacks=[cp_callback],
          validation_data=(test_images, test_labels),
          verbose=0)
WARNING:tensorflow:Unresolved object in checkpoint: (root).optimizer.iter
WARNING:tensorflow:Unresolved object in checkpoint: (root).optimizer.beta_1
WARNING:tensorflow:Unresolved object in checkpoint: (root).optimizer.beta_2
WARNING:tensorflow:Unresolved object in checkpoint: (root).optimizer.decay
WARNING:tensorflow:Unresolved object in checkpoint: (root).optimizer.learning_rate
WARNING:tensorflow:A checkpoint was restored (e.g. tf.train.Checkpoint.restore or tf.keras.Model.load_weights) but not all checkpointed values were used. See above for specific issues. Use expect_partial() on the load status object, e.g. tf.train.Checkpoint.restore(...).expect_partial(), to silence these warnings, or use assert_consumed() to make the check explicit. See https://www.tensorflow.org/guide/checkpoint#loading_mechanics for details.

Epoch 00005: saving model to training_2/cp-0005.ckpt

Epoch 00010: saving model to training_2/cp-0010.ckpt

Epoch 00015: saving model to training_2/cp-0015.ckpt

Epoch 00020: saving model to training_2/cp-0020.ckpt

Epoch 00025: saving model to training_2/cp-0025.ckpt

Epoch 00030: saving model to training_2/cp-0030.ckpt

Epoch 00035: saving model to training_2/cp-0035.ckpt

Epoch 00040: saving model to training_2/cp-0040.ckpt

Epoch 00045: saving model to training_2/cp-0045.ckpt

Epoch 00050: saving model to training_2/cp-0050.ckpt
<keras.callbacks.History at 0x7f271cc3a190>
प्लेसहोल्डर17

अब, परिणामी चौकियों को देखें और नवीनतम चुनें:

os.listdir(checkpoint_dir)
['cp-0050.ckpt.index',
 'cp-0010.ckpt.index',
 'cp-0005.ckpt.index',
 'cp-0045.ckpt.data-00000-of-00001',
 'cp-0030.ckpt.index',
 'cp-0045.ckpt.index',
 'cp-0025.ckpt.index',
 'cp-0005.ckpt.data-00000-of-00001',
 'cp-0035.ckpt.index',
 'cp-0010.ckpt.data-00000-of-00001',
 'cp-0030.ckpt.data-00000-of-00001',
 'cp-0035.ckpt.data-00000-of-00001',
 'cp-0000.ckpt.index',
 'cp-0020.ckpt.index',
 'cp-0050.ckpt.data-00000-of-00001',
 'cp-0040.ckpt.index',
 'cp-0025.ckpt.data-00000-of-00001',
 'cp-0000.ckpt.data-00000-of-00001',
 'cp-0020.ckpt.data-00000-of-00001',
 'cp-0015.ckpt.data-00000-of-00001',
 'checkpoint',
 'cp-0015.ckpt.index',
 'cp-0040.ckpt.data-00000-of-00001']
latest = tf.train.latest_checkpoint(checkpoint_dir)
latest
'training_2/cp-0050.ckpt'

परीक्षण करने के लिए, मॉडल को रीसेट करें और नवीनतम चेकपॉइंट लोड करें:

# Create a new model instance
model = create_model()

# Load the previously saved weights
model.load_weights(latest)

# Re-evaluate the model
loss, acc = model.evaluate(test_images, test_labels, verbose=2)
print("Restored model, accuracy: {:5.2f}%".format(100 * acc))
32/32 - 0s - loss: 0.5194 - sparse_categorical_accuracy: 0.8660
Restored model, accuracy: 86.60%

ये फाइलें क्या हैं?

उपरोक्त कोड वजन को चेकपॉइंट -स्वरूपित फाइलों के संग्रह में संग्रहीत करता है जिसमें बाइनरी प्रारूप में केवल प्रशिक्षित वजन होता है। चौकियों में शामिल हैं:

  • एक या अधिक शार्क जिनमें आपके मॉडल का भार होता है।
  • एक इंडेक्स फ़ाइल जो इंगित करती है कि कौन से वज़न किस शार्ड में संग्रहीत हैं।

यदि आप किसी मॉडल को एक मशीन पर प्रशिक्षण दे रहे हैं, तो आपके पास प्रत्यय के साथ एक शार्ड होगा: .data-00000-of-00001

मैन्युअल रूप से वज़न बचाएं

Model.save_weights विधि से वज़न को मैन्युअल रूप से सहेजना। डिफ़ॉल्ट रूप से, tf.keras और विशेष रूप से save_weights एक .ckpt एक्सटेंशन के साथ TensorFlow चेकपॉइंट प्रारूप का उपयोग करता है ( .h5 में .h5 एक्सटेंशन के साथ सहेजना मॉडल सहेजें और क्रमबद्ध करें गाइड में शामिल है):

# Save the weights
model.save_weights('./checkpoints/my_checkpoint')

# Create a new model instance
model = create_model()

# Restore the weights
model.load_weights('./checkpoints/my_checkpoint')

# Evaluate the model
loss, acc = model.evaluate(test_images, test_labels, verbose=2)
print("Restored model, accuracy: {:5.2f}%".format(100 * acc))
32/32 - 0s - loss: 0.5194 - sparse_categorical_accuracy: 0.8660
Restored model, accuracy: 86.60%

पूरे मॉडल को सेव करें

मॉडल के आर्किटेक्चर, वज़न और प्रशिक्षण कॉन्फ़िगरेशन को एक फ़ाइल/फ़ोल्डर में सहेजने के लिए model.save को कॉल करें। यह आपको एक मॉडल निर्यात करने की अनुमति देता है ताकि इसका उपयोग मूल पायथन कोड * तक पहुंच के बिना किया जा सके। चूंकि ऑप्टिमाइज़र-स्टेट वापस आ गया है, आप ठीक वहीं से प्रशिक्षण फिर से शुरू कर सकते हैं जहाँ आपने छोड़ा था।

एक संपूर्ण मॉडल को दो अलग-अलग फ़ाइल स्वरूपों ( SavedModel और HDF5 ) में सहेजा जा सकता है। TensorFlow SavedModel स्वरूप TF2.x में डिफ़ॉल्ट फ़ाइल स्वरूप है। हालाँकि, मॉडलों को HDF5 स्वरूप में सहेजा जा सकता है। संपूर्ण मॉडल को दो फ़ाइल स्वरूपों में सहेजने के बारे में अधिक विवरण नीचे वर्णित है।

एक पूर्ण-कार्यात्मक मॉडल को सहेजना बहुत उपयोगी है—आप उन्हें TensorFlow.js (सेव्ड मॉडल , HDF5 ) में लोड कर सकते हैं और फिर उन्हें वेब ब्राउज़र में प्रशिक्षित और चला सकते हैं, या TensorFlow Lite (सेव्ड मॉडल , HDF5 ) का उपयोग करके मोबाइल उपकरणों पर चलने के लिए परिवर्तित कर सकते हैं। )

*कस्टम ऑब्जेक्ट (जैसे उपवर्ग मॉडल या परतें) को सहेजते और लोड करते समय विशेष ध्यान देने की आवश्यकता होती है। नीचे कस्टम ऑब्जेक्ट सहेजना अनुभाग देखें

सहेजा गया मॉडल प्रारूप

सहेजे गए मॉडल प्रारूप मॉडल को क्रमबद्ध करने का एक और तरीका है। इस प्रारूप में सहेजे गए मॉडल tf.keras.models.load_model का उपयोग करके पुनर्स्थापित किए जा सकते हैं और TensorFlow सर्विंग के साथ संगत हैं। सेव्डमॉडल गाइड इस बारे में विस्तार से बताता है कि सेव्डमॉडल की सेवा/निरीक्षण कैसे करें। नीचे दिया गया अनुभाग मॉडल को सहेजने और पुनर्स्थापित करने के चरणों को दिखाता है।

# Create and train a new model instance.
model = create_model()
model.fit(train_images, train_labels, epochs=5)

# Save the entire model as a SavedModel.
!mkdir -p saved_model
model.save('saved_model/my_model')
Epoch 1/5
32/32 [==============================] - 0s 2ms/step - loss: 1.2016 - sparse_categorical_accuracy: 0.6480
Epoch 2/5
32/32 [==============================] - 0s 2ms/step - loss: 0.4371 - sparse_categorical_accuracy: 0.8770
Epoch 3/5
32/32 [==============================] - 0s 2ms/step - loss: 0.2941 - sparse_categorical_accuracy: 0.9230
Epoch 4/5
32/32 [==============================] - 0s 2ms/step - loss: 0.2033 - sparse_categorical_accuracy: 0.9490
Epoch 5/5
32/32 [==============================] - 0s 2ms/step - loss: 0.1621 - sparse_categorical_accuracy: 0.9640
2021-10-26 01:31:11.741740: W tensorflow/python/util/util.cc:348] Sets are not currently considered sequences, but this may change in the future, so consider avoiding using them.
INFO:tensorflow:Assets written to: saved_model/my_model/assets

SavedModel प्रारूप एक निर्देशिका है जिसमें प्रोटोबफ बाइनरी और एक TensorFlow चेकपॉइंट होता है। सहेजे गए मॉडल निर्देशिका का निरीक्षण करें:

# my_model directory
ls saved_model

# Contains an assets folder, saved_model.pb, and variables folder.
ls saved_model/my_model
my_model
assets  keras_metadata.pb  saved_model.pb  variables

सहेजे गए मॉडल से एक नया केरस मॉडल पुनः लोड करें:

new_model = tf.keras.models.load_model('saved_model/my_model')

# Check its architecture
new_model.summary()
Model: "sequential_5"
_________________________________________________________________
Layer (type)                 Output Shape              Param #   
=================================================================
dense_10 (Dense)             (None, 512)               401920    
_________________________________________________________________
dropout_5 (Dropout)          (None, 512)               0         
_________________________________________________________________
dense_11 (Dense)             (None, 10)                5130      
=================================================================
Total params: 407,050
Trainable params: 407,050
Non-trainable params: 0
_________________________________________________________________

पुनर्स्थापित मॉडल मूल मॉडल के समान तर्कों के साथ संकलित किया गया है। लोड किए गए मॉडल के साथ मूल्यांकन और भविष्यवाणी चलाने का प्रयास करें:

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

print(new_model.predict(test_images).shape)
32/32 - 0s - loss: 0.4271 - sparse_categorical_accuracy: 0.8630
Restored model, accuracy: 86.30%
(1000, 10)
प्लेसहोल्डर33

एचडीएफ5 प्रारूप

केरस एचडीएफ5 मानक का उपयोग करते हुए एक बुनियादी बचत प्रारूप प्रदान करता है।

# Create and train a new model instance.
model = create_model()
model.fit(train_images, train_labels, epochs=5)

# Save the entire model to a HDF5 file.
# The '.h5' extension indicates that the model should be saved to HDF5.
model.save('my_model.h5')
34 एल10एन-प्लेसहोल्डर
Epoch 1/5
32/32 [==============================] - 0s 2ms/step - loss: 1.1418 - sparse_categorical_accuracy: 0.6670
Epoch 2/5
32/32 [==============================] - 0s 2ms/step - loss: 0.4352 - sparse_categorical_accuracy: 0.8730
Epoch 3/5
32/32 [==============================] - 0s 2ms/step - loss: 0.2826 - sparse_categorical_accuracy: 0.9320
Epoch 4/5
32/32 [==============================] - 0s 2ms/step - loss: 0.2112 - sparse_categorical_accuracy: 0.9430
Epoch 5/5
32/32 [==============================] - 0s 2ms/step - loss: 0.1652 - sparse_categorical_accuracy: 0.9660

अब, उस फ़ाइल से मॉडल को फिर से बनाएँ:

# Recreate the exact same model, including its weights and the optimizer
new_model = tf.keras.models.load_model('my_model.h5')

# Show the model architecture
new_model.summary()
WARNING:tensorflow:Unresolved object in checkpoint: (root).optimizer.iter
WARNING:tensorflow:Unresolved object in checkpoint: (root).optimizer.beta_1
WARNING:tensorflow:Unresolved object in checkpoint: (root).optimizer.beta_2
WARNING:tensorflow:Unresolved object in checkpoint: (root).optimizer.decay
WARNING:tensorflow:Unresolved object in checkpoint: (root).optimizer.learning_rate
WARNING:tensorflow:A checkpoint was restored (e.g. tf.train.Checkpoint.restore or tf.keras.Model.load_weights) but not all checkpointed values were used. See above for specific issues. Use expect_partial() on the load status object, e.g. tf.train.Checkpoint.restore(...).expect_partial(), to silence these warnings, or use assert_consumed() to make the check explicit. See https://www.tensorflow.org/guide/checkpoint#loading_mechanics for details.
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
_________________________________________________________________

इसकी शुद्धता की जाँच करें:

loss, acc = new_model.evaluate(test_images, test_labels, verbose=2)
print('Restored model, accuracy: {:5.2f}%'.format(100 * acc))
32/32 - 0s - loss: 0.4063 - sparse_categorical_accuracy: 0.8690
Restored model, accuracy: 86.90%

केरस मॉडलों को उनकी वास्तुकला का निरीक्षण करके बचाता है। यह तकनीक सब कुछ बचाती है:

  • वजन मान
  • मॉडल की वास्तुकला
  • मॉडल का प्रशिक्षण कॉन्फ़िगरेशन (जिसे आप .compile() विधि में पास करते हैं)
  • ऑप्टिमाइज़र और उसकी स्थिति, यदि कोई हो (यह आपको प्रशिक्षण को फिर से शुरू करने में सक्षम बनाता है जहाँ आपने छोड़ा था)

केरस v1.x अनुकूलक ( tf.compat.v1.train से) को सहेजने में सक्षम नहीं है क्योंकि वे चौकियों के साथ संगत नहीं हैं। v1.x ऑप्टिमाइज़र के लिए, आपको लोड करने के बाद मॉडल को फिर से संकलित करने की आवश्यकता है - ऑप्टिमाइज़र की स्थिति खो देने के बाद।

कस्टम ऑब्जेक्ट सहेजा जा रहा है

यदि आप सहेजे गए मॉडल प्रारूप का उपयोग कर रहे हैं, तो आप इस अनुभाग को छोड़ सकते हैं। HDF5 और SavedModel के बीच महत्वपूर्ण अंतर यह है कि HDF5 मॉडल आर्किटेक्चर को बचाने के लिए ऑब्जेक्ट कॉन्फिग का उपयोग करता है, जबकि SavedModel निष्पादन ग्राफ को बचाता है। इस प्रकार, सहेजे गए मॉडल मूल कोड की आवश्यकता के बिना उप-वर्ग मॉडल और कस्टम परतों जैसी कस्टम ऑब्जेक्ट्स को सहेजने में सक्षम हैं।

कस्टम ऑब्जेक्ट को HDF5 में सहेजने के लिए, आपको निम्न कार्य करने होंगे:

  1. अपने ऑब्जेक्ट में get_config विधि को परिभाषित करें, और वैकल्पिक रूप से from_config क्लासमेथोड को परिभाषित करें।
    • get_config(self) ऑब्जेक्ट को फिर से बनाने के लिए आवश्यक मापदंडों का JSON-serializable शब्दकोश देता है।
    • from_config(cls, config) एक नई वस्तु बनाने के लिए get_config से लौटाए गए कॉन्फ़िगरेशन का उपयोग करता है। डिफ़ॉल्ट रूप से, यह फ़ंक्शन कॉन्फ़िगरेशन को इनिशियलाइज़ेशन kwargs ( return cls(**config) ) के रूप में उपयोग करेगा।
  2. मॉडल लोड करते समय ऑब्जेक्ट को custom_objects तर्क पर पास करें। तर्क एक शब्दकोश होना चाहिए जो स्ट्रिंग वर्ग के नाम को पायथन वर्ग में मैप करता हो। जैसे tf.keras.models.load_model(path, custom_objects={'CustomLayer': CustomLayer})

कस्टम ऑब्जेक्ट और get_config के उदाहरणों के लिए स्क्रैच ट्यूटोरियल से राइटिंग लेयर्स और मॉडल देखें।

# MIT License
#
# Copyright (c) 2017 François Chollet
#
# Permission is hereby granted, free of charge, to any person obtaining a
# copy of this software and associated documentation files (the "Software"),
# to deal in the Software without restriction, including without limitation
# the rights to use, copy, modify, merge, publish, distribute, sublicense,
# and/or sell copies of the Software, and to permit persons to whom the
# Software is furnished to do so, subject to the following conditions:
#
# The above copyright notice and this permission notice shall be included in
# all copies or substantial portions of the Software.
#
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
# THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
# FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
# DEALINGS IN THE SOFTWARE.