इस पेज का अनुवाद Cloud Translation API से किया गया है.
Switch to English

प्रशिक्षण चौकियों

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

वाक्यांश "सेविंग ए टेन्सरफ्लो मॉडल" का अर्थ आमतौर पर दो चीजों में से एक होता है:

  1. चौकी, या
  2. SavedModel।

चेकपॉइंट एक मॉडल द्वारा उपयोग किए जाने वाले सभी मापदंडों ( tf.Variable ऑब्जेक्ट्स) के सटीक मूल्य को कैप्चर करता है। चेकपॉइंट में मॉडल द्वारा परिभाषित गणना का कोई विवरण शामिल नहीं है और इस प्रकार आमतौर पर केवल तब उपयोगी होता है जब स्रोत कोड जो सहेजे गए पैरामीटर मान का उपयोग करेगा उपलब्ध है।

दूसरी ओर SavedModel प्रारूप में पैरामीटर मान (चेकपॉइंट) के अलावा मॉडल द्वारा परिभाषित संगणना का क्रमबद्ध विवरण शामिल है। इस प्रारूप में मॉडल स्रोत कोड से स्वतंत्र हैं जिसने मॉडल बनाया है। वे इस प्रकार TensorFlow सर्विंग, TensorFlow Lite, TensorFlow.js, या अन्य प्रोग्रामिंग भाषाओं (C, C ++, Java, Go, Rust, C # आदि TorsorFlow APIs) के माध्यम से तैनाती के लिए उपयुक्त हैं।

यह गाइड लेखन और पढ़ने वाली चौकियों के लिए एपीआई को कवर करता है।

सेट अप

import tensorflow as tf
class Net(tf.keras.Model):
  """A simple linear model."""

  def __init__(self):
    super(Net, self).__init__()
    self.l1 = tf.keras.layers.Dense(5)

  def call(self, x):
    return self.l1(x)
net = Net()

tf.keras ट्रेनिंग एपीआई से बचत

बचाने और बहाल करने पर tf.keras गाइड देखें।

tf.keras.Model.save_weights एक TensorFlow चेकपॉइंट बचाता है।

net.save_weights('easy_checkpoint')

लेखन चौकियों

एक TensorFlow मॉडल की लगातार स्थिति tf.Variable वस्तुओं में संग्रहीत की जाती है। इनका निर्माण सीधे किया जा सकता है, लेकिन अक्सर उच्च स्तरीय एपीआई जैसे tf.keras.layers या tf.keras.Model के माध्यम से बनाया जाता है।

चर को प्रबंधित करने का सबसे आसान तरीका उन्हें पायथन ऑब्जेक्ट्स से जोड़ना है, फिर उन वस्तुओं को संदर्भित करना है।

के उपवर्गों tf.train.Checkpoint , tf.keras.layers.Layer , और tf.keras.Model स्वचालित रूप से उनकी विशेषताओं करने के लिए आवंटित चर ट्रैक। निम्नलिखित उदाहरण एक सरल रैखिक मॉडल का निर्माण करता है, फिर उन चौकियों को लिखता है जिसमें सभी मॉडल के चर के लिए मान होते हैं।

आप Model.save_weights साथ एक मॉडल-चेकपॉइंट को आसानी से सहेज सकते हैं

मैनुअल चेकपॉइंटिंग

सेट अप

tf.train.Checkpoint की सभी विशेषताओं को प्रदर्शित करने में मदद करने के लिए एक खिलौना डाटासेट और अनुकूलन कदम को परिभाषित करें:

def toy_dataset():
  inputs = tf.range(10.)[:, None]
  labels = inputs * 5. + tf.range(5.)[None, :]
  return tf.data.Dataset.from_tensor_slices(
    dict(x=inputs, y=labels)).repeat().batch(2)
def train_step(net, example, optimizer):
  """Trains `net` on `example` using `optimizer`."""
  with tf.GradientTape() as tape:
    output = net(example['x'])
    loss = tf.reduce_mean(tf.abs(output - example['y']))
  variables = net.trainable_variables
  gradients = tape.gradient(loss, variables)
  optimizer.apply_gradients(zip(gradients, variables))
  return loss

चौकी वस्तुएं बनाएं

मैन्युअल रूप से एक चौकी बनाने के लिए आपको एक tf.train.Checkpoint ऑब्जेक्ट की आवश्यकता होगी। जहाँ आप जिन वस्तुओं को जांचना चाहते हैं, वे ऑब्जेक्ट पर विशेषताओं के रूप में सेट हैं।

एक tf.train.CheckpointManager कई चौकियों के प्रबंधन के लिए भी सहायक हो सकता है।

opt = tf.keras.optimizers.Adam(0.1)
dataset = toy_dataset()
iterator = iter(dataset)
ckpt = tf.train.Checkpoint(step=tf.Variable(1), optimizer=opt, net=net, iterator=iterator)
manager = tf.train.CheckpointManager(ckpt, './tf_ckpts', max_to_keep=3)

मॉडल को प्रशिक्षित और जांचना

निम्न प्रशिक्षण पाश मॉडल और एक अनुकूलक का एक उदाहरण बनाता है, फिर उन्हें एक tf.train.Checkpoint ऑब्जेक्ट में tf.train.Checkpoint है। यह डेटा के प्रत्येक बैच पर एक लूप में प्रशिक्षण कदम कहता है, और समय-समय पर डिस्क पर चौकियों को लिखता है।

12c03b387
train_and_checkpoint(net, manager)
Initializing from scratch.
Saved checkpoint for step 10: ./tf_ckpts/ckpt-1
loss 28.15
Saved checkpoint for step 20: ./tf_ckpts/ckpt-2
loss 21.56
Saved checkpoint for step 30: ./tf_ckpts/ckpt-3
loss 15.00
Saved checkpoint for step 40: ./tf_ckpts/ckpt-4
loss 8.52
Saved checkpoint for step 50: ./tf_ckpts/ckpt-5
loss 3.25

पुनर्स्थापित करें और प्रशिक्षण जारी रखें

पहले के बाद आप एक नया मॉडल और प्रबंधक पास कर सकते हैं, लेकिन पिकअप प्रशिक्षण बिल्कुल वही है जहाँ आपने छोड़ा था:

opt = tf.keras.optimizers.Adam(0.1)
net = Net()
dataset = toy_dataset()
iterator = iter(dataset)
ckpt = tf.train.Checkpoint(step=tf.Variable(1), optimizer=opt, net=net, iterator=iterator)
manager = tf.train.CheckpointManager(ckpt, './tf_ckpts', max_to_keep=3)

train_and_checkpoint(net, manager)
Restored from ./tf_ckpts/ckpt-5
Saved checkpoint for step 60: ./tf_ckpts/ckpt-6
loss 1.76
Saved checkpoint for step 70: ./tf_ckpts/ckpt-7
loss 0.65
Saved checkpoint for step 80: ./tf_ckpts/ckpt-8
loss 0.51
Saved checkpoint for step 90: ./tf_ckpts/ckpt-9
loss 0.34
Saved checkpoint for step 100: ./tf_ckpts/ckpt-10
loss 0.25

tf.train.CheckpointManager ऑब्जेक्ट पुरानी चौकियों को हटा देता है। ऊपर यह केवल तीन सबसे हाल की चौकियों को रखने के लिए कॉन्फ़िगर किया गया है।

print(manager.checkpoints)  # List the three remaining checkpoints
['./tf_ckpts/ckpt-8', './tf_ckpts/ckpt-9', './tf_ckpts/ckpt-10']

ये पथ, जैसे './tf_ckpts/ckpt-10' , डिस्क पर फ़ाइलें नहीं हैं। इसके बजाय वे एक index फ़ाइल और एक या अधिक डेटा फ़ाइलों के लिए उपसर्ग हैं जिनमें चर मान शामिल हैं। इन उपसर्गों को एक एकल checkpoint फ़ाइल ( './tf_ckpts/checkpoint' ) में एक साथ समूहीकृत किया जाता है, जहाँ CheckpointManager अपनी स्थिति बचाता है।

ls ./tf_ckpts
checkpoint           ckpt-8.data-00000-of-00001  ckpt-9.index
ckpt-10.data-00000-of-00001  ckpt-8.index
ckpt-10.index            ckpt-9.data-00000-of-00001

यांत्रिकी लोड हो रहा है

TensorFlow नामांकित किनारों के साथ एक निर्देशित ग्राफ़ को लोड करके ऑब्जेक्ट से शुरू करके चेकपॉइंट किए गए मानों के लिए चर से मेल खाता है। एज नाम आमतौर पर ऑब्जेक्ट्स में विशेषता नामों से आते हैं, उदाहरण के लिए self.l1 = tf.keras.layers.Dense(5) में "l1"tf.train.Checkpoint अपने कीवर्ड तर्क नामों का उपयोग करता है, जैसे कि tf.train.Checkpoint(step=...) में "step"

ऊपर दिए गए उदाहरण से निर्भरता ग्राफ इस प्रकार है:

उदाहरण प्रशिक्षण पाश के लिए निर्भरता ग्राफ का दृश्य

लाल रंग में ऑप्टिमाइज़र के साथ, नीले रंग में नियमित चर और नारंगी में ऑप्टिमाइज़र स्लॉट चर। अन्य नोड्स, उदाहरण के लिए tf.train.Checkpoint प्रतिनिधित्व करते हैं, काले हैं।

स्लॉट चर अनुकूलक के राज्य का हिस्सा हैं, लेकिन एक विशिष्ट चर के लिए बनाए जाते हैं। उदाहरण के लिए, ऊपर 'm' किनारे गति के अनुरूप हैं, जिसे एडम अनुकूलक प्रत्येक चर के लिए ट्रैक करता है। स्लॉट चर केवल एक चेकपॉइंट में सहेजे जाते हैं यदि चर और अनुकूलक दोनों को बचाया जाएगा, इस प्रकार धराशायी किनारों।

कॉलिंग restore() को tf.train.Checkpoint ऑब्जेक्ट अनुरोधित पुनर्स्थापनाओं को कतार में tf.train.Checkpoint , जैसे ही Checkpoint ऑब्जेक्ट से मिलान पथ होता है, वैरिएबल मान को पुनर्स्थापित करता है। उदाहरण के लिए, हम ऊपर दिए गए मॉडल से सिर्फ पूर्वाग्रह को लोड कर सकते हैं जो कि नेटवर्क और परत के माध्यम से एक पथ को फिर से जोड़कर परिभाषित करता है।

to_restore = tf.Variable(tf.zeros([5]))
print(to_restore.numpy())  # All zeros
fake_layer = tf.train.Checkpoint(bias=to_restore)
fake_net = tf.train.Checkpoint(l1=fake_layer)
new_root = tf.train.Checkpoint(net=fake_net)
status = new_root.restore(tf.train.latest_checkpoint('./tf_ckpts/'))
print(to_restore.numpy())  # We get the restored value now
[0. 0. 0. 0. 0.]
[3.5548685 2.8931093 2.3509905 3.5525272 4.017799 ]

इन नई वस्तुओं के लिए निर्भरता ग्राफ हमारे द्वारा लिखे गए बड़े चेकपॉइंट का बहुत छोटा सबग्राफ है। इसमें केवल पूर्वाग्रह और एक बचत काउंटर शामिल है जो tf.train.Checkpoint नंबर चौकियों के लिए उपयोग करता है।

पूर्वाग्रह चर के लिए एक उपसमूह का दृश्य

restore() एक स्थिति ऑब्जेक्ट लौटाता है, जिसमें वैकल्पिक दावे हैं। हमारे नए Checkpoint में हमारे द्वारा बनाई गई सभी वस्तुओं को बहाल कर दिया गया है, इसलिए status.assert_existing_objects_matched() पास।

status.assert_existing_objects_matched()
<tensorflow.python.training.tracking.util.CheckpointLoadStatus at 0x7fea0c3c3860>

चेकपॉइंट में कई ऑब्जेक्ट हैं जो मेल नहीं खाते हैं, जिसमें परत के कर्नेल और ऑप्टिमाइज़र के चर शामिल हैं। status.assert_consumed() केवल तभी गुजरता है यदि चेकपॉइंट और प्रोग्राम बिल्कुल मेल खाते हैं, और यहां एक अपवाद फेंक देंगे।

विलंबित पुनर्स्थापन

TensorFlow में Layer ऑब्जेक्ट इनपुट शेप के उपलब्ध होने पर वेरिएबल्स के निर्माण में देरी कर सकते हैं। उदाहरण के लिए, एक Dense परत के कर्नेल का आकार परत के इनपुट और आउटपुट आकार दोनों पर निर्भर करता है, और इसलिए एक निर्माता तर्क के रूप में आवश्यक आउटपुट आकृति अपने आप ही चर बनाने के लिए पर्याप्त जानकारी नहीं है। चूँकि Layer कॉल करने से वेरिएबल का मान भी पढ़ता है, वैरिएबल के निर्माण और उसके पहले उपयोग के बीच एक रिस्टोर होना चाहिए।

इस मुहावरे का समर्थन करने के लिए, tf.train.Checkpoint कतारें पुनर्स्थापित करती हैं जो अभी तक एक मिलान चर नहीं है।

delayed_restore = tf.Variable(tf.zeros([1, 5]))
print(delayed_restore.numpy())  # Not restored; still zeros
fake_layer.kernel = delayed_restore
print(delayed_restore.numpy())  # Restored
[[0. 0. 0. 0. 0.]]
[[4.453001  4.6668463 4.9372597 4.90143   4.9549575]]

मैन्युअल रूप से चौकियों का निरीक्षण किया

tf.train.list_variables चेकपॉइंट कुंजियों और tf.train.list_variables आकार चर में सूचीबद्ध करता है। चेकपॉइंट कुंजियाँ ऊपर दिखाए गए ग्राफ़ में पथ हैं।

tf.train.list_variables(tf.train.latest_checkpoint('./tf_ckpts/'))
[('_CHECKPOINTABLE_OBJECT_GRAPH', []),
 ('iterator/.ATTRIBUTES/ITERATOR_STATE', [1]),
 ('net/l1/bias/.ATTRIBUTES/VARIABLE_VALUE', [5]),
 ('net/l1/bias/.OPTIMIZER_SLOT/optimizer/m/.ATTRIBUTES/VARIABLE_VALUE', [5]),
 ('net/l1/bias/.OPTIMIZER_SLOT/optimizer/v/.ATTRIBUTES/VARIABLE_VALUE', [5]),
 ('net/l1/kernel/.ATTRIBUTES/VARIABLE_VALUE', [1, 5]),
 ('net/l1/kernel/.OPTIMIZER_SLOT/optimizer/m/.ATTRIBUTES/VARIABLE_VALUE',
  [1, 5]),
 ('net/l1/kernel/.OPTIMIZER_SLOT/optimizer/v/.ATTRIBUTES/VARIABLE_VALUE',
  [1, 5]),
 ('optimizer/beta_1/.ATTRIBUTES/VARIABLE_VALUE', []),
 ('optimizer/beta_2/.ATTRIBUTES/VARIABLE_VALUE', []),
 ('optimizer/decay/.ATTRIBUTES/VARIABLE_VALUE', []),
 ('optimizer/iter/.ATTRIBUTES/VARIABLE_VALUE', []),
 ('optimizer/learning_rate/.ATTRIBUTES/VARIABLE_VALUE', []),
 ('save_counter/.ATTRIBUTES/VARIABLE_VALUE', []),
 ('step/.ATTRIBUTES/VARIABLE_VALUE', [])]

सूची और शब्दकोश ट्रैकिंग

जैसा कि self.l1 = tf.keras.layers.Dense(5) जैसे प्रत्यक्ष विशेषता असाइनमेंट के साथ, सूचियों और शब्दकोशों को विशेषताओं पर असाइन करना उनकी सामग्री को ट्रैक करेगा।

save = tf.train.Checkpoint()
save.listed = [tf.Variable(1.)]
save.listed.append(tf.Variable(2.))
save.mapped = {'one': save.listed[0]}
save.mapped['two'] = save.listed[1]
save_path = save.save('./tf_list_example')

restore = tf.train.Checkpoint()
v2 = tf.Variable(0.)
assert 0. == v2.numpy()  # Not restored yet
restore.mapped = {'two': v2}
restore.restore(save_path)
assert 2. == v2.numpy()

आप सूचियों और शब्दकोशों के लिए आवरण वस्तुओं को देख सकते हैं। ये रैपर अंतर्निहित डेटा-संरचनाओं के जांच योग्य संस्करण हैं। विशेषता आधारित लोडिंग की तरह, ये रैपर जैसे ही कंटेनर में जोड़े जाते हैं, वैरिएबल के मान को पुनर्स्थापित करते हैं।

restore.listed = []
print(restore.listed)  # ListWrapper([])
v1 = tf.Variable(0.)
restore.listed.append(v1)  # Restores v1, from restore() in the previous cell
assert 1. == v1.numpy()
ListWrapper([])

समान ट्रैकिंग स्वचालित रूप से tf.keras.Model उपवर्गों पर लागू tf.keras.Model , और इसका उपयोग परतों की सूचियों को ट्रैक करने के लिए उदाहरण के लिए किया जा सकता है।

एस्टिमेटर के साथ ऑब्जेक्ट-आधारित चौकियों को सहेजना

एस्टिमेटर गाइड देखें।

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

import tensorflow.compat.v1 as tf_compat
def model_fn(features, labels, mode):
  net = Net()
  opt = tf.keras.optimizers.Adam(0.1)
  ckpt = tf.train.Checkpoint(step=tf_compat.train.get_global_step(),
                             optimizer=opt, net=net)
  with tf.GradientTape() as tape:
    output = net(features['x'])
    loss = tf.reduce_mean(tf.abs(output - features['y']))
  variables = net.trainable_variables
  gradients = tape.gradient(loss, variables)
  return tf.estimator.EstimatorSpec(
    mode,
    loss=loss,
    train_op=tf.group(opt.apply_gradients(zip(gradients, variables)),
                      ckpt.step.assign_add(1)),
    # Tell the Estimator to save "ckpt" in an object-based format.
    scaffold=tf_compat.train.Scaffold(saver=ckpt))

tf.keras.backend.clear_session()
est = tf.estimator.Estimator(model_fn, './tf_estimator_example/')
est.train(toy_dataset, steps=10)
INFO:tensorflow:Using default config.
INFO:tensorflow:Using config: {'_model_dir': './tf_estimator_example/', '_tf_random_seed': None, '_save_summary_steps': 100, '_save_checkpoints_steps': None, '_save_checkpoints_secs': 600, '_session_config': allow_soft_placement: true
graph_options {
  rewrite_options {
    meta_optimizer_iterations: ONE
  }
}
, '_keep_checkpoint_max': 5, '_keep_checkpoint_every_n_hours': 10000, '_log_step_count_steps': 100, '_train_distribute': None, '_device_fn': None, '_protocol': None, '_eval_distribute': None, '_experimental_distribute': None, '_experimental_max_worker_delay_secs': None, '_session_creation_timeout_secs': 7200, '_service': None, '_cluster_spec': ClusterSpec({}), '_task_type': 'worker', '_task_id': 0, '_global_id_in_cluster': 0, '_master': '', '_evaluation_master': '', '_is_chief': True, '_num_ps_replicas': 0, '_num_worker_replicas': 1}
WARNING:tensorflow:From /tmpfs/src/tf_docs_env/lib/python3.6/site-packages/tensorflow/python/training/training_util.py:236: Variable.initialized_value (from tensorflow.python.ops.variables) is deprecated and will be removed in a future version.
Instructions for updating:
Use Variable.read_value. Variables in 2.X are initialized automatically both in eager and graph (inside tf.defun) contexts.
INFO:tensorflow:Calling model_fn.
INFO:tensorflow:Done calling model_fn.
INFO:tensorflow:Create CheckpointSaverHook.
INFO:tensorflow:Graph was finalized.
INFO:tensorflow:Running local_init_op.
INFO:tensorflow:Done running local_init_op.
INFO:tensorflow:Calling checkpoint listeners before saving checkpoint 0...
INFO:tensorflow:Saving checkpoints for 0 into ./tf_estimator_example/model.ckpt.
INFO:tensorflow:Calling checkpoint listeners after saving checkpoint 0...
INFO:tensorflow:loss = 4.388644, step = 0
INFO:tensorflow:Calling checkpoint listeners before saving checkpoint 10...
INFO:tensorflow:Saving checkpoints for 10 into ./tf_estimator_example/model.ckpt.
INFO:tensorflow:Calling checkpoint listeners after saving checkpoint 10...
INFO:tensorflow:Loss for final step: 34.98601.

<tensorflow_estimator.python.estimator.estimator.EstimatorV2 at 0x7fea648fbf60>

tf.train.Checkpoint इसके बाद Estimator की चौकियों को अपने model_dir से लोड कर सकती है।

opt = tf.keras.optimizers.Adam(0.1)
net = Net()
ckpt = tf.train.Checkpoint(
  step=tf.Variable(1, dtype=tf.int64), optimizer=opt, net=net)
ckpt.restore(tf.train.latest_checkpoint('./tf_estimator_example/'))
ckpt.step.numpy()  # From est.train(..., steps=10)
10

सारांश

TensorFlow ऑब्जेक्ट्स उन चरों के मूल्यों को सहेजने और पुनर्स्थापित करने के लिए एक आसान स्वचालित तंत्र प्रदान करते हैं।