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

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

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

  1. चौकियों, OR
  2. सहेजा गया मॉडल।

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

दूसरी ओर सेव्डमॉडल प्रारूप में पैरामीटर मान (चेकपॉइंट) के अलावा मॉडल द्वारा परिभाषित गणना का क्रमबद्ध विवरण शामिल है। इस प्रारूप में मॉडल मॉडल बनाने वाले स्रोत कोड से स्वतंत्र होते हैं। इस प्रकार वे TensorFlow Serving, TensorFlow Lite, TensorFlow.js, या अन्य प्रोग्रामिंग भाषाओं में प्रोग्राम (C, C++, Java, Go, Rust, C# आदि) TensorFlow 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 वस्तुओं। ये सीधे निर्माण किया जा सकता है, लेकिन अक्सर की तरह उच्च स्तरीय APIs के माध्यम से बनाई गई हैं 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 वस्तु। यह डेटा के प्रत्येक बैच पर प्रशिक्षण चरण को लूप में कॉल करता है, और समय-समय पर डिस्क पर चौकियों को लिखता है।

def train_and_checkpoint(net, manager):
  ckpt.restore(manager.latest_checkpoint)
  if manager.latest_checkpoint:
    print("Restored from {}".format(manager.latest_checkpoint))
  else:
    print("Initializing from scratch.")

  for _ in range(50):
    example = next(iterator)
    loss = train_step(net, example, opt)
    ckpt.step.assign_add(1)
    if int(ckpt.step) % 10 == 0:
      save_path = manager.save()
      print("Saved checkpoint for step {}: {}".format(int(ckpt.step), save_path))
      print("loss {:1.2f}".format(loss.numpy()))
train_and_checkpoint(net, manager)
Initializing from scratch.
Saved checkpoint for step 10: ./tf_ckpts/ckpt-1
loss 29.77
Saved checkpoint for step 20: ./tf_ckpts/ckpt-2
loss 23.18
Saved checkpoint for step 30: ./tf_ckpts/ckpt-3
loss 16.62
Saved checkpoint for step 40: ./tf_ckpts/ckpt-4
loss 10.16
Saved checkpoint for step 50: ./tf_ckpts/ckpt-5
loss 4.09

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

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

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.33
Saved checkpoint for step 70: ./tf_ckpts/ckpt-7
loss 0.90
Saved checkpoint for step 80: ./tf_ckpts/ckpt-8
loss 0.62
Saved checkpoint for step 90: ./tf_ckpts/ckpt-9
loss 0.27
Saved checkpoint for step 100: ./tf_ckpts/ckpt-10
loss 0.22

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

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

उदाहरण प्रशिक्षण लूप के लिए निर्भरता ग्राफ का विज़ुअलाइज़ेशन

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

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

कॉलिंग restore एक पर 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())  # This gets the restored value.
[0. 0. 0. 0. 0.]
[1.9851578 3.6375327 2.9331083 3.8130412 4.778274 ]

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

पूर्वाग्रह चर के लिए एक सबग्राफ का विज़ुअलाइज़ेशन

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

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

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

विलंबित बहाली

Layer TensorFlow में वस्तुओं अपनी पहली कॉल, जब इनपुट आकार उपलब्ध हैं करने के लिए चर के निर्माण में देरी हो सकती। उदाहरण के लिए एक के आकार 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.6800494 4.607369  4.8321466 4.816245  4.8435326]]

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

tf.train.load_checkpoint एक रिटर्न CheckpointReader कि चौकी सामग्री के निचले स्तर पहुँच देता है। इसमें चेकपॉइंट में प्रत्येक चर के लिए प्रत्येक चर की कुंजी से आकृति और dtype के लिए मैपिंग शामिल है। एक चर की कुंजी उसका ऑब्जेक्ट पथ है, जैसे ऊपर प्रदर्शित ग्राफ़ में।

reader = tf.train.load_checkpoint('./tf_ckpts/')
shape_from_key = reader.get_variable_to_shape_map()
dtype_from_key = reader.get_variable_to_dtype_map()

sorted(shape_from_key.keys())
['_CHECKPOINTABLE_OBJECT_GRAPH',
 'iterator/.ATTRIBUTES/ITERATOR_STATE',
 'net/l1/bias/.ATTRIBUTES/VARIABLE_VALUE',
 'net/l1/bias/.OPTIMIZER_SLOT/optimizer/m/.ATTRIBUTES/VARIABLE_VALUE',
 'net/l1/bias/.OPTIMIZER_SLOT/optimizer/v/.ATTRIBUTES/VARIABLE_VALUE',
 'net/l1/kernel/.ATTRIBUTES/VARIABLE_VALUE',
 'net/l1/kernel/.OPTIMIZER_SLOT/optimizer/m/.ATTRIBUTES/VARIABLE_VALUE',
 'net/l1/kernel/.OPTIMIZER_SLOT/optimizer/v/.ATTRIBUTES/VARIABLE_VALUE',
 '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']

तो अगर आप के मूल्य में रुचि रखते हैं net.l1.kernel आप निम्न कोड के साथ मूल्य प्राप्त कर सकते हैं:

key = 'net/l1/kernel/.ATTRIBUTES/VARIABLE_VALUE'

print("Shape:", shape_from_key[key])
print("Dtype:", dtype_from_key[key].name)
Shape: [1, 5]
Dtype: float32

यह भी एक प्रदान करता है get_tensor विधि आप एक चर के मूल्य का निरीक्षण करने के लिए अनुमति देता है:

reader.get_tensor(key)
array([[4.6800494, 4.607369 , 4.8321466, 4.816245 , 4.8435326]],
      dtype=float32)

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

जैसे प्रत्यक्ष विशेषता कार्य के रूप में 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 , और परतों की सूची पर नज़र रखने के उदाहरण के लिए इस्तेमाल किया जा सकता है।

सारांश

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