माइग्रेटिंग मॉडल चौकियों

TensorFlow.org पर देखें Google Colab में चलाएं गिटहब पर देखें नोटबुक डाउनलोड करें

अवलोकन

यह मार्गदर्शिका मानती है कि आपके पास एक मॉडल है जो tf.compat.v1.Saver के साथ चौकियों को सहेजता और लोड करता है, और कोड को TF2 tf.train.Checkpoint API का उपयोग करके माइग्रेट करना चाहते हैं, या अपने TF2 मॉडल में पहले से मौजूद चौकियों का उपयोग करना चाहते हैं।

नीचे कुछ सामान्य परिदृश्य दिए गए हैं जिनका आप सामना कर सकते हैं:

परिद्रश्य 1

पिछले प्रशिक्षण रन से मौजूदा TF1 चौकियां हैं जिन्हें लोड करने या TF2 में बदलने की आवश्यकता है।

परिदृश्य 2

आप अपने मॉडल को इस तरह से समायोजित कर रहे हैं कि परिवर्तनशील नामों और पथों को बदलने का जोखिम है (जैसे कि जब get_variable से स्पष्ट tf.Variable निर्माण की ओर बढ़ते हुए), और रास्ते में मौजूदा चौकियों की बचत/लोडिंग को बनाए रखना चाहते हैं।

मॉडल माइग्रेशन के दौरान चेकपॉइंट संगतता कैसे बनाए रखें पर अनुभाग देखें

परिदृश्य 3

आप अपने प्रशिक्षण कोड और चौकियों को TF2 में स्थानांतरित कर रहे हैं, लेकिन आपकी अनुमान पाइपलाइन को अभी (उत्पादन स्थिरता के लिए) TF1 चौकियों की आवश्यकता है।

विकल्प 1

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

विकल्प 2

TF2 चेकपॉइंट को TF1 में बदलें।

नीचे दिए गए उदाहरण TF1/TF2 में चेकपॉइंट को सहेजने और लोड करने के सभी संयोजनों को दिखाते हैं, इसलिए आपके पास अपने मॉडल को माइग्रेट करने का तरीका निर्धारित करने में कुछ लचीलापन है।

सेट अप

import tensorflow as tf
import tensorflow.compat.v1 as tf1

def print_checkpoint(save_path):
  reader = tf.train.load_checkpoint(save_path)
  shapes = reader.get_variable_to_shape_map()
  dtypes = reader.get_variable_to_dtype_map()
  print(f"Checkpoint at '{save_path}':")
  for key in shapes:
    print(f"  (key='{key}', shape={shapes[key]}, dtype={dtypes[key].name}, "
          f"value={reader.get_tensor(key)})")

TF1 से TF2 में परिवर्तन

यदि आप इस बारे में उत्सुक हैं कि TF1 और TF2 के बीच क्या परिवर्तन हुआ है और "नाम-आधारित" (TF1) बनाम "वस्तु-आधारित" (TF2) चौकियों से हमारा क्या तात्पर्य है, तो यह खंड शामिल है।

दो प्रकार की चौकियों को वास्तव में एक ही प्रारूप में सहेजा जाता है, जो अनिवार्य रूप से एक कुंजी-मूल्य तालिका है। अंतर यह है कि कुंजियाँ कैसे उत्पन्न होती हैं।

नामित-आधारित चौकियों की कुंजियाँ चरों के नाम हैं । ऑब्जेक्ट-आधारित चौकियों में कुंजियाँ रूट ऑब्जेक्ट से वेरिएबल तक के पथ को संदर्भित करती हैं (नीचे दिए गए उदाहरण इसका अर्थ बेहतर ढंग से समझने में मदद करेंगे)।

सबसे पहले, कुछ चौकियों को बचाएं:

with tf.Graph().as_default() as g:
  a = tf1.get_variable('a', shape=[], dtype=tf.float32, 
                       initializer=tf1.zeros_initializer())
  b = tf1.get_variable('b', shape=[], dtype=tf.float32, 
                       initializer=tf1.zeros_initializer())
  c = tf1.get_variable('scoped/c', shape=[], dtype=tf.float32, 
                       initializer=tf1.zeros_initializer())
  with tf1.Session() as sess:
    saver = tf1.train.Saver()
    sess.run(a.assign(1))
    sess.run(b.assign(2))
    sess.run(c.assign(3))
    saver.save(sess, 'tf1-ckpt')

print_checkpoint('tf1-ckpt')

Checkpoint at 'tf1-ckpt':
  (key='scoped/c', shape=[], dtype=float32, value=3.0)
  (key='a', shape=[], dtype=float32, value=1.0)
  (key='b', shape=[], dtype=float32, value=2.0)

a = tf.Variable(5.0, name='a')
b = tf.Variable(6.0, name='b')
with tf.name_scope('scoped'):
  c = tf.Variable(7.0, name='c')

ckpt = tf.train.Checkpoint(variables=[a, b, c])
save_path_v2 = ckpt.save('tf2-ckpt')
print_checkpoint(save_path_v2)

Checkpoint at 'tf2-ckpt-1':
  (key='variables/2/.ATTRIBUTES/VARIABLE_VALUE', shape=[], dtype=float32, value=7.0)
  (key='variables/0/.ATTRIBUTES/VARIABLE_VALUE', shape=[], dtype=float32, value=5.0)
  (key='_CHECKPOINTABLE_OBJECT_GRAPH', shape=[], dtype=string, value=b"\n!\n\r\x08\x01\x12\tvariables\n\x10\x08\x02\x12\x0csave_counter\n\x15\n\x05\x08\x03\x12\x010\n\x05\x08\x04\x12\x011\n\x05\x08\x05\x12\x012\nI\x12G\n\x0eVARIABLE_VALUE\x12\x0csave_counter\x1a'save_counter/.ATTRIBUTES/VARIABLE_VALUE\n=\x12;\n\x0eVARIABLE_VALUE\x12\x01a\x1a&variables/0/.ATTRIBUTES/VARIABLE_VALUE\n=\x12;\n\x0eVARIABLE_VALUE\x12\x01b\x1a&variables/1/.ATTRIBUTES/VARIABLE_VALUE\nD\x12B\n\x0eVARIABLE_VALUE\x12\x08scoped/c\x1a&variables/2/.ATTRIBUTES/VARIABLE_VALUE")
  (key='variables/1/.ATTRIBUTES/VARIABLE_VALUE', shape=[], dtype=float32, value=6.0)
  (key='save_counter/.ATTRIBUTES/VARIABLE_VALUE', shape=[], dtype=int64, value=1)

यदि आप tf2-ckpt में कुंजियों को देखते हैं, तो वे सभी प्रत्येक चर के ऑब्जेक्ट पथ को संदर्भित करते हैं। उदाहरण के लिए, चर a variables सूची में पहला तत्व है, इसलिए इसकी कुंजी variables/0/... बन जाती है (.ATTRIBUTES/VARIABLE_VALUE स्थिरांक को अनदेखा करने के लिए स्वतंत्र महसूस करें)।

नीचे दिए गए Checkpoint ऑब्जेक्ट का करीब से निरीक्षण:

a = tf.Variable(0.)
b = tf.Variable(0.)
c = tf.Variable(0.)
root = ckpt = tf.train.Checkpoint(variables=[a, b, c])
print("root type =", type(root).__name__)
print("root.variables =", root.variables)
print("root.variables[0] =", root.variables[0])

root type = Checkpoint
root.variables = ListWrapper([<tf.Variable 'Variable:0' shape=() dtype=float32, numpy=0.0>, <tf.Variable 'Variable:0' shape=() dtype=float32, numpy=0.0>, <tf.Variable 'Variable:0' shape=() dtype=float32, numpy=0.0>])
root.variables[0] = <tf.Variable 'Variable:0' shape=() dtype=float32, numpy=0.0>

नीचे दिए गए स्निपेट के साथ प्रयोग करने का प्रयास करें और देखें कि ऑब्जेक्ट संरचना के साथ चेकपॉइंट कुंजियां कैसे बदलती हैं:

module = tf.Module()
module.d = tf.Variable(0.)
test_ckpt = tf.train.Checkpoint(v={'a': a, 'b': b}, 
                                c=c,
                                module=module)
test_ckpt_path = test_ckpt.save('root-tf2-ckpt')
print_checkpoint(test_ckpt_path)

Checkpoint at 'root-tf2-ckpt-1':
  (key='v/a/.ATTRIBUTES/VARIABLE_VALUE', shape=[], dtype=float32, value=0.0)
  (key='save_counter/.ATTRIBUTES/VARIABLE_VALUE', shape=[], dtype=int64, value=1)
  (key='v/b/.ATTRIBUTES/VARIABLE_VALUE', shape=[], dtype=float32, value=0.0)
  (key='module/d/.ATTRIBUTES/VARIABLE_VALUE', shape=[], dtype=float32, value=0.0)
  (key='_CHECKPOINTABLE_OBJECT_GRAPH', shape=[], dtype=string, value=b"\n,\n\x05\x08\x01\x12\x01c\n\n\x08\x02\x12\x06module\n\x05\x08\x03\x12\x01v\n\x10\x08\x04\x12\x0csave_counter\n:\x128\n\x0eVARIABLE_VALUE\x12\x08Variable\x1a\x1cc/.ATTRIBUTES/VARIABLE_VALUE\n\x07\n\x05\x08\x05\x12\x01d\n\x0e\n\x05\x08\x06\x12\x01a\n\x05\x08\x07\x12\x01b\nI\x12G\n\x0eVARIABLE_VALUE\x12\x0csave_counter\x1a'save_counter/.ATTRIBUTES/VARIABLE_VALUE\nA\x12?\n\x0eVARIABLE_VALUE\x12\x08Variable\x1a#module/d/.ATTRIBUTES/VARIABLE_VALUE\n<\x12:\n\x0eVARIABLE_VALUE\x12\x08Variable\x1a\x1ev/a/.ATTRIBUTES/VARIABLE_VALUE\n<\x12:\n\x0eVARIABLE_VALUE\x12\x08Variable\x1a\x1ev/b/.ATTRIBUTES/VARIABLE_VALUE")
  (key='c/.ATTRIBUTES/VARIABLE_VALUE', shape=[], dtype=float32, value=0.0)

TF2 इस तंत्र का उपयोग क्यों करता है?

क्योंकि TF2 में कोई और वैश्विक ग्राफ नहीं है, चर नाम अविश्वसनीय हैं और कार्यक्रमों के बीच असंगत हो सकते हैं। TF2 ऑब्जेक्ट-ओरिएंटेड मॉडलिंग दृष्टिकोण को प्रोत्साहित करता है जहां चर परतों के स्वामित्व में होते हैं, और परतें एक मॉडल के स्वामित्व में होती हैं:

variable = tf.Variable(...)
layer.variable_name = variable
model.layer_name = layer

मॉडल माइग्रेशन के दौरान चेकपॉइंट संगतता कैसे बनाए रखें

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

लचीलेपन को बढ़ाने के क्रम में चेकपॉइंट संगतता बनाए रखने के तीन तरीके नीचे दिए गए हैं:

  1. मॉडल में पहले की तरह ही चर नाम हैं ।
  2. मॉडल में अलग-अलग चर नाम होते हैं, और एक असाइनमेंट मैप बनाए रखता है जो चेकपॉइंट में चर नामों को नए नामों से मैप करता है।
  3. मॉडल के अलग-अलग चर नाम हैं, और एक TF2 चेकपॉइंट ऑब्जेक्ट को बनाए रखता है जो सभी चर को संग्रहीत करता है।

जब चर नाम मेल खाते हैं

लंबा शीर्षक: चर नामों का मिलान होने पर चौकियों का पुन: उपयोग कैसे करें।

संक्षिप्त उत्तर: आप पहले से मौजूद चेकपॉइंट को सीधे tf1.train.Saver या tf.train.Checkpoint से लोड कर सकते हैं।

यदि आप tf.compat.v1.keras.utils.track_tf1_style_variables का उपयोग कर रहे हैं, तो यह सुनिश्चित करेगा कि आपके मॉडल चर नाम पहले जैसे ही हैं। आप मैन्युअल रूप से यह भी सुनिश्चित कर सकते हैं कि चर नाम मेल खाते हैं।

जब माइग्रेट किए गए मॉडल में चर नाम मेल खाते हैं, तो आप चेकपॉइंट को लोड करने के लिए सीधे tf.train.Checkpoint या tf.compat.v1.train.Saver का उपयोग कर सकते हैं। दोनों एपीआई उत्सुक और ग्राफ मोड के साथ संगत हैं, इसलिए आप माइग्रेशन के किसी भी चरण में उनका उपयोग कर सकते हैं।

नीचे विभिन्न मॉडलों के साथ एक ही चौकी का उपयोग करने के उदाहरण दिए गए हैं। सबसे पहले, tf1 चेकपॉइंट को tf1.train.Saver से सेव करें:

with tf.Graph().as_default() as g:
  a = tf1.get_variable('a', shape=[], dtype=tf.float32, 
                       initializer=tf1.zeros_initializer())
  b = tf1.get_variable('b', shape=[], dtype=tf.float32, 
                       initializer=tf1.zeros_initializer())
  c = tf1.get_variable('scoped/c', shape=[], dtype=tf.float32, 
                       initializer=tf1.zeros_initializer())
  with tf1.Session() as sess:
    saver = tf1.train.Saver()
    sess.run(a.assign(1))
    sess.run(b.assign(2))
    sess.run(c.assign(3))
    save_path = saver.save(sess, 'tf1-ckpt')
print_checkpoint(save_path)

Checkpoint at 'tf1-ckpt':
  (key='scoped/c', shape=[], dtype=float32, value=3.0)
  (key='a', shape=[], dtype=float32, value=1.0)
  (key='b', shape=[], dtype=float32, value=2.0)

नीचे दिया गया उदाहरण उत्सुक मोड में चेकपॉइंट लोड करने के लिए tf.compat.v1.Saver का उपयोग करता है:

a = tf.Variable(0.0, name='a')
b = tf.Variable(0.0, name='b')
with tf.name_scope('scoped'):
  c = tf.Variable(0.0, name='c')

# With the removal of collections in TF2, you must pass in the list of variables
# to the Saver object:
saver = tf1.train.Saver(var_list=[a, b, c])
saver.restore(sess=None, save_path=save_path)
print(f"loaded values of [a, b, c]:  [{a.numpy()}, {b.numpy()}, {c.numpy()}]")

# Saving also works in eager (sess must be None).
path = saver.save(sess=None, save_path='tf1-ckpt-saved-in-eager')
print_checkpoint(path)

WARNING:tensorflow:Saver is deprecated, please switch to tf.train.Checkpoint or tf.keras.Model.save_weights for training checkpoints. When executing eagerly variables do not necessarily have unique names, and so the variable.name-based lookups Saver performs are error-prone.
INFO:tensorflow:Restoring parameters from tf1-ckpt
loaded values of [a, b, c]:  [1.0, 2.0, 3.0]
Checkpoint at 'tf1-ckpt-saved-in-eager':
  (key='scoped/c', shape=[], dtype=float32, value=3.0)
  (key='a', shape=[], dtype=float32, value=1.0)
  (key='b', shape=[], dtype=float32, value=2.0)

अगला स्निपेट TF2 API tf.train.Checkpoint का उपयोग करके चेकपॉइंट को लोड करता है:

a = tf.Variable(0.0, name='a')
b = tf.Variable(0.0, name='b')
with tf.name_scope('scoped'):
  c = tf.Variable(0.0, name='c')

# Without the name_scope, name="scoped/c" works too:
c_2 = tf.Variable(0.0, name='scoped/c')

print("Variable names: ")
print(f"  a.name = {a.name}")
print(f"  b.name = {b.name}")
print(f"  c.name = {c.name}")
print(f"  c_2.name = {c_2.name}")

# Restore the values with tf.train.Checkpoint
ckpt = tf.train.Checkpoint(variables=[a, b, c, c_2])
ckpt.restore(save_path)
print(f"loaded values of [a, b, c, c_2]:  [{a.numpy()}, {b.numpy()}, {c.numpy()}, {c_2.numpy()}]")

Variable names: 
  a.name = a:0
  b.name = b:0
  c.name = scoped/c:0
  c_2.name = scoped/c:0
WARNING:tensorflow:From /tmpfs/src/tf_docs_env/lib/python3.7/site-packages/tensorflow/python/training/tracking/util.py:1345: NameBasedSaverStatus.__init__ (from tensorflow.python.training.tracking.util) is deprecated and will be removed in a future version.
Instructions for updating:
Restoring a name-based tf.train.Saver checkpoint using the object-based restore API. This mode uses global names to match variables, and so is somewhat fragile. It also adds new restore ops to the graph each time it is called when graph building. Prefer re-encoding training checkpoints in the object-based format: run save() on the object-based saver (the same one this message is coming from) and use that checkpoint in the future.
loaded values of [a, b, c, c_2]:  [1.0, 2.0, 3.0, 3.0]

TF2 में चर नाम

  • वेरिएबल्स में अभी भी एक name तर्क है जिसे आप सेट कर सकते हैं।
  • केरस मॉडल एक name तर्क भी लेते हैं जिसके रूप में वे अपने चर के लिए उपसर्ग के रूप में सेट करते हैं।
  • v1.name_scope फ़ंक्शन का उपयोग चर नाम उपसर्गों को सेट करने के लिए किया जा सकता है। यह tf.variable_scope से बहुत अलग है। यह केवल नामों को प्रभावित करता है, और चर और पुन: उपयोग को ट्रैक नहीं करता है।

tf.compat.v1.keras.utils.track_tf1_style_variables डेकोरेटर एक शिम है जो tf.variable_scope और tf.compat.v1.get_variable के नामकरण और पुन: उपयोग शब्दार्थ को अपरिवर्तित रखते हुए, चर नाम और TF1 चेकपॉइंट संगतता बनाए रखने में आपकी सहायता करता है। अधिक जानकारी के लिए मॉडल मैपिंग गाइड देखें।

नोट 1: यदि आप शिम का उपयोग कर रहे हैं, तो अपनी चौकियों को लोड करने के लिए TF2 API का उपयोग करें (यहां तक ​​कि पूर्व-प्रशिक्षित TF1 चौकियों का उपयोग करते समय भी)।

अनुभाग चेकपॉइंट केरस देखें।

नोट 2: tf.Variable से get_variable में माइग्रेट करते समय:

यदि आपके शिम- tf.compat.v1.get_variable लेयर या मॉड्यूल में कुछ वेरिएबल्स (या केरस लेयर्स/मॉडल) हैं जो tf.compat.v1.get_variable के बजाय tf.Variable का उपयोग करते हैं और ऑब्जेक्ट ओरिएंटेड तरीके से गुणों के रूप में संलग्न/ट्रैक किए जाते हैं, तो उनके पास भिन्न हो सकते हैं उत्सुक निष्पादन के दौरान बनाम TF1.x ग्राफ़/सत्रों में चर नामकरण शब्दार्थ।

संक्षेप में, हो सकता है कि नाम TF2 में चलने के दौरान आपकी अपेक्षा के अनुरूप न हों।

असाइनमेंट मैप्स को बनाए रखना

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

आप इन नक्शों का उपयोग tf.compat.v1.train.init_from_checkpoint , tf.compat.v1.train.Saver , और tf.train.load_checkpoint के साथ उन मॉडलों में भार लोड करने के लिए कर सकते हैं जिनमें वेरिएबल या स्कोप नाम बदल गए होंगे।

इस खंड के उदाहरण पहले सहेजे गए चेकपॉइंट का उपयोग करेंगे:

print_checkpoint('tf1-ckpt')

Checkpoint at 'tf1-ckpt':
  (key='scoped/c', shape=[], dtype=float32, value=3.0)
  (key='a', shape=[], dtype=float32, value=1.0)
  (key='b', shape=[], dtype=float32, value=2.0)

init_from_checkpoint के साथ लोड हो रहा है

tf1.train.init_from_checkpoint को ग्राफ़/सत्र में कॉल किया जाना चाहिए, क्योंकि यह एक असाइन ऑप बनाने के बजाय वैरिएबल इनिशियलाइज़र में मान रखता है।

चर कैसे लोड किए जाते हैं, इसे कॉन्फ़िगर करने के लिए आप assignment_map तर्क का उपयोग कर सकते हैं। दस्तावेज़ीकरण से:

असाइनमेंट मैप निम्नलिखित सिंटैक्स का समर्थन करता है:

  • 'checkpoint_scope_name/': 'scope_name/' - वर्तमान scope_name में सभी चरों को checkpoint_scope_name से मिलान करने वाले टेंसर नामों के साथ लोड करेगा।
  • 'checkpoint_scope_name/some_other_variable': 'scope_name/variable_name' - checkpoint_scope_name/some_other_variable से scope_name/variable_name वैरिएबल प्रारंभ करेगा।
  • 'scope_variable_name': variable - चेकपॉइंट से दिए गए tf.Variable ऑब्जेक्ट को टेंसर 'scope_variable_name' के साथ इनिशियलाइज़ करेगा।
  • 'scope_variable_name': list(variable) - चेकपॉइंट से टेन्सर 'scope_variable_name' के साथ विभाजित चर की सूची प्रारंभ करेगा।
  • '/': 'scope_name/' - चेकपॉइंट के रूट से मौजूदा scope_name में सभी वेरिएबल्स को लोड करेगा (उदाहरण के लिए कोई स्कोप नहीं)।
# Restoring with tf1.train.init_from_checkpoint:

# A new model with a different scope for the variables.
with tf.Graph().as_default() as g:
  with tf1.variable_scope('new_scope'):
    a = tf1.get_variable('a', shape=[], dtype=tf.float32, 
                        initializer=tf1.zeros_initializer())
    b = tf1.get_variable('b', shape=[], dtype=tf.float32, 
                        initializer=tf1.zeros_initializer())
    c = tf1.get_variable('scoped/c', shape=[], dtype=tf.float32, 
                        initializer=tf1.zeros_initializer())
  with tf1.Session() as sess:
    # The assignment map will remap all variables in the checkpoint to the
    # new scope:
    tf1.train.init_from_checkpoint(
        'tf1-ckpt',
        assignment_map={'/': 'new_scope/'})
    # `init_from_checkpoint` adds the initializers to these variables.
    # Use `sess.run` to run these initializers.
    sess.run(tf1.global_variables_initializer())

    print("Restored [a, b, c]: ", sess.run([a, b, c]))

Restored [a, b, c]:  [1.0, 2.0, 3.0]

tf1.train.Saver के साथ लोड हो रहा है

init_from_checkpoint के विपरीत, tf.compat.v1.train.Saver ग्राफ़ और उत्सुक मोड दोनों में चलता है। var_list तर्क वैकल्पिक रूप से एक शब्दकोश को स्वीकार करता है, सिवाय इसके कि इसे चर नामों को tf.Variable ऑब्जेक्ट में मैप करना होगा।

# Restoring with tf1.train.Saver (works in both graph and eager):

# A new model with a different scope for the variables.
with tf1.variable_scope('new_scope'):
  a = tf1.get_variable('a', shape=[], dtype=tf.float32, 
                      initializer=tf1.zeros_initializer())
  b = tf1.get_variable('b', shape=[], dtype=tf.float32, 
                      initializer=tf1.zeros_initializer())
  c = tf1.get_variable('scoped/c', shape=[], dtype=tf.float32, 
                        initializer=tf1.zeros_initializer())
# Initialize the saver with a dictionary with the original variable names:
saver = tf1.train.Saver({'a': a, 'b': b, 'scoped/c': c})
saver.restore(sess=None, save_path='tf1-ckpt')
print("Restored [a, b, c]: ", [a.numpy(), b.numpy(), c.numpy()])

WARNING:tensorflow:Saver is deprecated, please switch to tf.train.Checkpoint or tf.keras.Model.save_weights for training checkpoints. When executing eagerly variables do not necessarily have unique names, and so the variable.name-based lookups Saver performs are error-prone.
INFO:tensorflow:Restoring parameters from tf1-ckpt
Restored [a, b, c]:  [1.0, 2.0, 3.0]
प्लेसहोल्डर22

tf.train.load_checkpoint के साथ लोड हो रहा है

यह विकल्प आपके लिए है यदि आपको चर मानों पर सटीक नियंत्रण की आवश्यकता है। फिर, यह ग्राफ और उत्सुक मोड दोनों में काम करता है।

# Restoring with tf.train.load_checkpoint (works in both graph and eager):

# A new model with a different scope for the variables.
with tf.Graph().as_default() as g:
  with tf1.variable_scope('new_scope'):
    a = tf1.get_variable('a', shape=[], dtype=tf.float32, 
                        initializer=tf1.zeros_initializer())
    b = tf1.get_variable('b', shape=[], dtype=tf.float32, 
                        initializer=tf1.zeros_initializer())
    c = tf1.get_variable('scoped/c', shape=[], dtype=tf.float32, 
                        initializer=tf1.zeros_initializer())
  with tf1.Session() as sess:
    # It may be easier writing a loop if your model has a lot of variables.
    reader = tf.train.load_checkpoint('tf1-ckpt')
    sess.run(a.assign(reader.get_tensor('a')))
    sess.run(b.assign(reader.get_tensor('b')))
    sess.run(c.assign(reader.get_tensor('scoped/c')))
    print("Restored [a, b, c]: ", sess.run([a, b, c]))

Restored [a, b, c]:  [1.0, 2.0, 3.0]

TF2 चेकपॉइंट ऑब्जेक्ट को बनाए रखना

यदि माइग्रेशन के दौरान चर और कार्यक्षेत्र के नाम बहुत बदल सकते हैं, तो tf.train.Checkpoint और TF2 चौकियों का उपयोग करें। TF2 चर नामों के बजाय ऑब्जेक्ट संरचना का उपयोग करता है ( TF1 से TF2 में परिवर्तन में अधिक विवरण)।

संक्षेप में, चेकपॉइंट को सहेजने या पुनर्स्थापित करने के लिए tf.train.Checkpoint बनाते समय, सुनिश्चित करें कि यह समान क्रम (सूचियों के लिए) और कुंजियों ( Checkpoint प्रारंभकर्ता के लिए शब्दकोशों और कीवर्ड तर्कों के लिए) का उपयोग करता है। चेकपॉइंट संगतता के कुछ उदाहरण:

ckpt = tf.train.Checkpoint(foo=[var_a, var_b])

# compatible with ckpt
tf.train.Checkpoint(foo=[var_a, var_b])

# not compatible with ckpt
tf.train.Checkpoint(foo=[var_b, var_a])
tf.train.Checkpoint(bar=[var_a, var_b])

नीचे दिए गए कोड नमूने दिखाते हैं कि "समान" tf.train.Checkpoint का उपयोग कैसे करें। विभिन्न नामों के साथ चर लोड करने के लिए चेकपॉइंट। सबसे पहले, एक TF2 चेकपॉइंट सहेजें:

with tf.Graph().as_default() as g:
  a = tf1.get_variable('a', shape=[], dtype=tf.float32, 
                       initializer=tf1.constant_initializer(1))
  b = tf1.get_variable('b', shape=[], dtype=tf.float32, 
                       initializer=tf1.constant_initializer(2))
  with tf1.variable_scope('scoped'):
    c = tf1.get_variable('c', shape=[], dtype=tf.float32, 
                        initializer=tf1.constant_initializer(3))
  with tf1.Session() as sess:
    sess.run(tf1.global_variables_initializer())
    print("[a, b, c]: ", sess.run([a, b, c]))

    # Save a TF2 checkpoint
    ckpt = tf.train.Checkpoint(unscoped=[a, b], scoped=[c])
    tf2_ckpt_path = ckpt.save('tf2-ckpt')
    print_checkpoint(tf2_ckpt_path)

[a, b, c]:  [1.0, 2.0, 3.0]
Checkpoint at 'tf2-ckpt-1':
  (key='unscoped/1/.ATTRIBUTES/VARIABLE_VALUE', shape=[], dtype=float32, value=2.0)
  (key='unscoped/0/.ATTRIBUTES/VARIABLE_VALUE', shape=[], dtype=float32, value=1.0)
  (key='_CHECKPOINTABLE_OBJECT_GRAPH', shape=[], dtype=string, value=b"\n,\n\n\x08\x01\x12\x06scoped\n\x0c\x08\x02\x12\x08unscoped\n\x10\x08\x03\x12\x0csave_counter\n\x07\n\x05\x08\x04\x12\x010\n\x0e\n\x05\x08\x05\x12\x010\n\x05\x08\x06\x12\x011\nI\x12G\n\x0eVARIABLE_VALUE\x12\x0csave_counter\x1a'save_counter/.ATTRIBUTES/VARIABLE_VALUE\nA\x12?\n\x0eVARIABLE_VALUE\x12\x08scoped/c\x1a#scoped/0/.ATTRIBUTES/VARIABLE_VALUE\n<\x12:\n\x0eVARIABLE_VALUE\x12\x01a\x1a%unscoped/0/.ATTRIBUTES/VARIABLE_VALUE\n<\x12:\n\x0eVARIABLE_VALUE\x12\x01b\x1a%unscoped/1/.ATTRIBUTES/VARIABLE_VALUE")
  (key='scoped/0/.ATTRIBUTES/VARIABLE_VALUE', shape=[], dtype=float32, value=3.0)
  (key='save_counter/.ATTRIBUTES/VARIABLE_VALUE', shape=[], dtype=int64, value=1)

आप tf.train.Checkpoint का उपयोग करना जारी रख सकते हैं, भले ही चर/दायरे के नाम बदल जाएं:

with tf.Graph().as_default() as g:
  a = tf1.get_variable('a_different_name', shape=[], dtype=tf.float32, 
                       initializer=tf1.zeros_initializer())
  b = tf1.get_variable('b_different_name', shape=[], dtype=tf.float32, 
                       initializer=tf1.zeros_initializer())
  with tf1.variable_scope('different_scope'):
    c = tf1.get_variable('c', shape=[], dtype=tf.float32, 
                        initializer=tf1.zeros_initializer())
  with tf1.Session() as sess:
    sess.run(tf1.global_variables_initializer())
    print("Initialized [a, b, c]: ", sess.run([a, b, c]))

    ckpt = tf.train.Checkpoint(unscoped=[a, b], scoped=[c])
    # `assert_consumed` validates that all checkpoint objects are restored from
    # the checkpoint. `run_restore_ops` is required when running in a TF1
    # session.
    ckpt.restore(tf2_ckpt_path).assert_consumed().run_restore_ops()

    # Removing `assert_consumed` is fine if you want to skip the validation.
    # ckpt.restore(tf2_ckpt_path).run_restore_ops()

    print("Restored [a, b, c]: ", sess.run([a, b, c]))

Initialized [a, b, c]:  [0.0, 0.0, 0.0]
Restored [a, b, c]:  [1.0, 2.0, 3.0]

और उत्सुक मोड में:

a = tf.Variable(0.)
b = tf.Variable(0.)
c = tf.Variable(0.)
print("Initialized [a, b, c]: ", [a.numpy(), b.numpy(), c.numpy()])

# The keys "scoped" and "unscoped" are no longer relevant, but are used to
# maintain compatibility with the saved checkpoints.
ckpt = tf.train.Checkpoint(unscoped=[a, b], scoped=[c])

ckpt.restore(tf2_ckpt_path).assert_consumed().run_restore_ops()
print("Restored [a, b, c]: ", [a.numpy(), b.numpy(), c.numpy()])

Initialized [a, b, c]:  [0.0, 0.0, 0.0]
Restored [a, b, c]:  [1.0, 2.0, 3.0]

अनुमानक में TF2 चौकियां

ऊपर दिए गए अनुभाग बताते हैं कि अपने मॉडल को माइग्रेट करते समय चेकपॉइंट संगतता कैसे बनाए रखें। ये अवधारणाएं अनुमानक मॉडल के लिए भी लागू होती हैं, हालांकि जिस तरह से चेकपॉइंट को सहेजा/लोड किया जाता है वह थोड़ा अलग होता है। जब आप TF2 API का उपयोग करने के लिए अपने अनुमानक मॉडल को माइग्रेट करते हैं, तो आप TF1 से TF2 चौकियों पर स्विच करना चाह सकते हैं, जबकि मॉडल अभी भी अनुमानक का उपयोग कर रहा है । यह खंड दिखाता है कि यह कैसे करना है।

tf.estimator.Estimator और MonitoredSession में एक बचत तंत्र है जिसे scaffold कहा जाता है, एक tf.compat.v1.train.Scaffold वस्तु। Scaffold में एक tf1.train.Saver या tf.train.Checkpoint हो सकता है, जो Estimator और MonitoredSession किए गए सत्र को TF1- या TF2-शैली की चौकियों को बचाने में सक्षम बनाता है।

# A model_fn that saves a TF1 checkpoint
def model_fn_tf1_ckpt(features, labels, mode):
  # This model adds 2 to the variable `v` in every train step.
  train_step = tf1.train.get_or_create_global_step()
  v = tf1.get_variable('var', shape=[], dtype=tf.float32, 
                       initializer=tf1.constant_initializer(0))
  return tf.estimator.EstimatorSpec(
      mode,
      predictions=v,
      train_op=tf.group(v.assign_add(2), train_step.assign_add(1)),
      loss=tf.constant(1.),
      scaffold=None
  )

!rm -rf est-tf1
est = tf.estimator.Estimator(model_fn_tf1_ckpt, 'est-tf1')

def train_fn():
  return tf.data.Dataset.from_tensor_slices(([1,2,3], [4,5,6]))
est.train(train_fn, steps=1)

latest_checkpoint = tf.train.latest_checkpoint('est-tf1')
print_checkpoint(latest_checkpoint)

INFO:tensorflow:Using default config.
INFO:tensorflow:Using config: {'_model_dir': 'est-tf1', '_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, '_checkpoint_save_graph_def': True, '_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.7/site-packages/tensorflow/python/training/training_util.py:401: 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 est-tf1/model.ckpt.
INFO:tensorflow:Calling checkpoint listeners after saving checkpoint 0...
INFO:tensorflow:loss = 1.0, step = 0
INFO:tensorflow:Calling checkpoint listeners before saving checkpoint 1...
INFO:tensorflow:Saving checkpoints for 1 into est-tf1/model.ckpt.
INFO:tensorflow:Calling checkpoint listeners after saving checkpoint 1...
INFO:tensorflow:Loss for final step: 1.0.
Checkpoint at 'est-tf1/model.ckpt-1':
  (key='var', shape=[], dtype=float32, value=2.0)
  (key='global_step', shape=[], dtype=int64, value=1)

# A model_fn that saves a TF2 checkpoint
def model_fn_tf2_ckpt(features, labels, mode):
  # This model adds 2 to the variable `v` in every train step.
  train_step = tf1.train.get_or_create_global_step()
  v = tf1.get_variable('var', shape=[], dtype=tf.float32, 
                       initializer=tf1.constant_initializer(0))
  ckpt = tf.train.Checkpoint(var_list={'var': v}, step=train_step)
  return tf.estimator.EstimatorSpec(
      mode,
      predictions=v,
      train_op=tf.group(v.assign_add(2), train_step.assign_add(1)),
      loss=tf.constant(1.),
      scaffold=tf1.train.Scaffold(saver=ckpt)
  )

!rm -rf est-tf2
est = tf.estimator.Estimator(model_fn_tf2_ckpt, 'est-tf2',
                             warm_start_from='est-tf1')

def train_fn():
  return tf.data.Dataset.from_tensor_slices(([1,2,3], [4,5,6]))
est.train(train_fn, steps=1)

latest_checkpoint = tf.train.latest_checkpoint('est-tf2')
print_checkpoint(latest_checkpoint)  

assert est.get_variable_value('var_list/var/.ATTRIBUTES/VARIABLE_VALUE') == 4

INFO:tensorflow:Using default config.
INFO:tensorflow:Using config: {'_model_dir': 'est-tf2', '_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, '_checkpoint_save_graph_def': True, '_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}
INFO:tensorflow:Calling model_fn.
INFO:tensorflow:Done calling model_fn.
INFO:tensorflow:Warm-starting with WarmStartSettings: WarmStartSettings(ckpt_to_initialize_from='est-tf1', vars_to_warm_start='.*', var_name_to_vocab_info={}, var_name_to_prev_var_name={})
INFO:tensorflow:Warm-starting from: est-tf1
INFO:tensorflow:Warm-starting variables only in TRAINABLE_VARIABLES.
INFO:tensorflow:Warm-started 1 variables.
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 est-tf2/model.ckpt.
INFO:tensorflow:Calling checkpoint listeners after saving checkpoint 0...
INFO:tensorflow:loss = 1.0, step = 0
INFO:tensorflow:Calling checkpoint listeners before saving checkpoint 1...
INFO:tensorflow:Saving checkpoints for 1 into est-tf2/model.ckpt.
INFO:tensorflow:Calling checkpoint listeners after saving checkpoint 1...
INFO:tensorflow:Loss for final step: 1.0.
Checkpoint at 'est-tf2/model.ckpt-1':
  (key='var_list/var/.ATTRIBUTES/VARIABLE_VALUE', shape=[], dtype=float32, value=4.0)
  (key='_CHECKPOINTABLE_OBJECT_GRAPH', shape=[], dtype=string, value=b"\n\x18\n\x08\x08\x01\x12\x04step\n\x0c\x08\x02\x12\x08var_list\n@\x12>\n\x0eVARIABLE_VALUE\x12\x0bglobal_step\x1a\x1fstep/.ATTRIBUTES/VARIABLE_VALUE\n\t\n\x07\x08\x03\x12\x03var\n@\x12>\n\x0eVARIABLE_VALUE\x12\x03var\x1a'var_list/var/.ATTRIBUTES/VARIABLE_VALUE")
  (key='step/.ATTRIBUTES/VARIABLE_VALUE', shape=[], dtype=int64, value=1)

est-tf1 से वार्म-स्टार्ट होने के बाद v का अंतिम मान 16 होना चाहिए, फिर अतिरिक्त 5 चरणों के लिए प्रशिक्षित किया जाना चाहिए। ट्रेन के चरण का मान warm_start चेकपॉइंट से आगे नहीं बढ़ता है।

चेकपॉइंटिंग केरा

केरस के साथ निर्मित मॉडल अभी भी पहले से मौजूद वजन को लोड करने के लिए tf1.train.Saver और tf.train.Checkpoint का उपयोग करते हैं। जब आपका मॉडल पूरी तरह से माइग्रेट हो जाता है, तो model.save_weights और model.load_weights का उपयोग करने के लिए स्विच करें, खासकर यदि आप प्रशिक्षण के दौरान ModelCheckpoint कॉलबैक का उपयोग कर रहे हैं।

चौकियों और केरस के बारे में कुछ बातें जो आपको जाननी चाहिए:

इनिशियलाइज़ेशन बनाम बिल्डिंग

केरस मॉडल और परतों को पूरी तरह से बनने से पहले दो चरणों से गुजरना होगा। सबसे पहले पायथन ऑब्जेक्ट का इनिशियलाइज़ेशन है: layer = tf.keras.layers.Dense(x) । दूसरा निर्माण चरण है, जिसमें अधिकांश भार वास्तव में बनाए जाते हैं: layer.build(input_shape) । आप इसे कॉल करके या एक train चलाकर, eval या predict स्टेप (केवल पहली बार) चलाकर भी एक मॉडल बना सकते हैं।

यदि आप पाते हैं कि model.load_weights(path).assert_consumed() एक त्रुटि उत्पन्न कर रहा है, तो यह संभावना है कि मॉडल/लेयर्स का निर्माण नहीं किया गया है।

केरस TF2 चौकियों का उपयोग करता है

tf.train.Checkpoint(model).write model.save_weights बराबर है। tf.train.Checkpoint(model).read .read और model.load_weights के साथ भी ऐसा ही है। ध्यान दें कि Checkpoint(model) != Checkpoint(model=model) ।

TF2 चौकियां Keras के build() चरण के साथ काम करती हैं

tf.train.Checkpoint.restore में एक तंत्र है जिसे आस्थगित बहाली कहा जाता है जो tf.Module और Keras वस्तुओं को चर मानों को संग्रहीत करने की अनुमति देता है यदि चर अभी तक नहीं बनाया गया है। यह आरंभिक मॉडल को वज़न लोड करने और उसके बाद निर्माण करने की अनुमति देता है।

m = YourKerasModel()
status = m.load_weights(path)

# This call builds the model. The variables are created with the restored
# values.
m.predict(inputs)

status.assert_consumed()

इस तंत्र के कारण, हम अत्यधिक अनुशंसा करते हैं कि आप Keras मॉडल के साथ TF2 चेकपॉइंट लोडिंग API का उपयोग करें (यहां तक ​​कि मॉडल मैपिंग शिम में पहले से मौजूद TF1 चौकियों को पुनर्स्थापित करते समय भी)। चेकपॉइंट गाइड में और देखें।

कोड के टुकड़े

नीचे दिए गए स्निपेट चेकपॉइंट सेविंग एपीआई में TF1/TF2 संस्करण संगतता दिखाते हैं।

TF2 में TF1 चेकपॉइंट सहेजें

a = tf.Variable(1.0, name='a')
b = tf.Variable(2.0, name='b')
with tf.name_scope('scoped'):
  c = tf.Variable(3.0, name='c')

saver = tf1.train.Saver(var_list=[a, b, c])
path = saver.save(sess=None, save_path='tf1-ckpt-saved-in-eager')
print_checkpoint(path)

WARNING:tensorflow:Saver is deprecated, please switch to tf.train.Checkpoint or tf.keras.Model.save_weights for training checkpoints. When executing eagerly variables do not necessarily have unique names, and so the variable.name-based lookups Saver performs are error-prone.
Checkpoint at 'tf1-ckpt-saved-in-eager':
  (key='scoped/c', shape=[], dtype=float32, value=3.0)
  (key='a', shape=[], dtype=float32, value=1.0)
  (key='b', shape=[], dtype=float32, value=2.0)

TF2 में TF1 चेकपॉइंट लोड करें

a = tf.Variable(0., name='a')
b = tf.Variable(0., name='b')
with tf.name_scope('scoped'):
  c = tf.Variable(0., name='c')
print("Initialized [a, b, c]: ", [a.numpy(), b.numpy(), c.numpy()])
saver = tf1.train.Saver(var_list=[a, b, c])
saver.restore(sess=None, save_path='tf1-ckpt-saved-in-eager')
print("Restored [a, b, c]: ", [a.numpy(), b.numpy(), c.numpy()])

Initialized [a, b, c]:  [0.0, 0.0, 0.0]
WARNING:tensorflow:Saver is deprecated, please switch to tf.train.Checkpoint or tf.keras.Model.save_weights for training checkpoints. When executing eagerly variables do not necessarily have unique names, and so the variable.name-based lookups Saver performs are error-prone.
INFO:tensorflow:Restoring parameters from tf1-ckpt-saved-in-eager
Restored [a, b, c]:  [1.0, 2.0, 3.0]

TF1 में TF2 चेकपॉइंट सहेजें

with tf.Graph().as_default() as g:
  a = tf1.get_variable('a', shape=[], dtype=tf.float32, 
                       initializer=tf1.constant_initializer(1))
  b = tf1.get_variable('b', shape=[], dtype=tf.float32, 
                       initializer=tf1.constant_initializer(2))
  with tf1.variable_scope('scoped'):
    c = tf1.get_variable('c', shape=[], dtype=tf.float32, 
                        initializer=tf1.constant_initializer(3))
  with tf1.Session() as sess:
    sess.run(tf1.global_variables_initializer())
    ckpt = tf.train.Checkpoint(
        var_list={v.name.split(':')[0]: v for v in tf1.global_variables()})
    tf2_in_tf1_path = ckpt.save('tf2-ckpt-saved-in-session')
    print_checkpoint(tf2_in_tf1_path)

Checkpoint at 'tf2-ckpt-saved-in-session-1':
  (key='var_list/scoped.Sc/.ATTRIBUTES/VARIABLE_VALUE', shape=[], dtype=float32, value=3.0)
  (key='var_list/b/.ATTRIBUTES/VARIABLE_VALUE', shape=[], dtype=float32, value=2.0)
  (key='var_list/a/.ATTRIBUTES/VARIABLE_VALUE', shape=[], dtype=float32, value=1.0)
  (key='_CHECKPOINTABLE_OBJECT_GRAPH', shape=[], dtype=string, value=b"\n \n\x0c\x08\x01\x12\x08var_list\n\x10\x08\x02\x12\x0csave_counter\n\x1c\n\x05\x08\x03\x12\x01a\n\x05\x08\x04\x12\x01b\n\x0c\x08\x05\x12\x08scoped/c\nI\x12G\n\x0eVARIABLE_VALUE\x12\x0csave_counter\x1a'save_counter/.ATTRIBUTES/VARIABLE_VALUE\n<\x12:\n\x0eVARIABLE_VALUE\x12\x01a\x1a%var_list/a/.ATTRIBUTES/VARIABLE_VALUE\n<\x12:\n\x0eVARIABLE_VALUE\x12\x01b\x1a%var_list/b/.ATTRIBUTES/VARIABLE_VALUE\nK\x12I\n\x0eVARIABLE_VALUE\x12\x08scoped/c\x1a-var_list/scoped.Sc/.ATTRIBUTES/VARIABLE_VALUE")
  (key='save_counter/.ATTRIBUTES/VARIABLE_VALUE', shape=[], dtype=int64, value=1)

TF1 में TF2 चेकपॉइंट लोड करें

with tf.Graph().as_default() as g:
  a = tf1.get_variable('a', shape=[], dtype=tf.float32, 
                       initializer=tf1.constant_initializer(0))
  b = tf1.get_variable('b', shape=[], dtype=tf.float32, 
                       initializer=tf1.constant_initializer(0))
  with tf1.variable_scope('scoped'):
    c = tf1.get_variable('c', shape=[], dtype=tf.float32, 
                        initializer=tf1.constant_initializer(0))
  with tf1.Session() as sess:
    sess.run(tf1.global_variables_initializer())
    print("Initialized [a, b, c]: ", sess.run([a, b, c]))
    ckpt = tf.train.Checkpoint(
        var_list={v.name.split(':')[0]: v for v in tf1.global_variables()})
    ckpt.restore('tf2-ckpt-saved-in-session-1').run_restore_ops()
    print("Restored [a, b, c]: ", sess.run([a, b, c]))

Initialized [a, b, c]:  [0.0, 0.0, 0.0]
Restored [a, b, c]:  [1.0, 2.0, 3.0]

चेकपॉइंट रूपांतरण

आप चौकियों को लोड करके और फिर से सहेज कर TF1 और TF2 के बीच चौकियों को परिवर्तित कर सकते हैं। एक विकल्प tf.train.load_checkpoint है, जो नीचे दिए गए कोड में दिखाया गया है।

TF1 चेकपॉइंट को TF2 में बदलें

def convert_tf1_to_tf2(checkpoint_path, output_prefix):
  """Converts a TF1 checkpoint to TF2.

  To load the converted checkpoint, you must build a dictionary that maps
  variable names to variable objects.
  ```
  ckpt = tf.train.Checkpoint(vars={name: variable})  
  ckpt.restore(converted_ckpt_path)

    ```

    Args:
      checkpoint_path: Path to the TF1 checkpoint.
      output_prefix: Path prefix to the converted checkpoint.

    Returns:
      Path to the converted checkpoint.
    """
    vars = {}
    reader = tf.train.load_checkpoint(checkpoint_path)
    dtypes = reader.get_variable_to_dtype_map()
    for key in dtypes.keys():
      vars[key] = tf.Variable(reader.get_tensor(key))
    return tf.train.Checkpoint(vars=vars).save(output_prefix)
  ```

Convert the checkpoint saved in the snippet `Save a TF1 checkpoint in TF2`:


```python
# Make sure to run the snippet in `Save a TF1 checkpoint in TF2`.
print_checkpoint('tf1-ckpt-saved-in-eager')
converted_path = convert_tf1_to_tf2('tf1-ckpt-saved-in-eager', 
                                     'converted-tf1-to-tf2')
print("\n[Converted]")
print_checkpoint(converted_path)

# Try loading the converted checkpoint.
a = tf.Variable(0.)
b = tf.Variable(0.)
c = tf.Variable(0.)
ckpt = tf.train.Checkpoint(vars={'a': a, 'b': b, 'scoped/c': c})
ckpt.restore(converted_path).assert_consumed()
print("\nRestored [a, b, c]: ", [a.numpy(), b.numpy(), c.numpy()])

Checkpoint at 'tf1-ckpt-saved-in-eager':
  (key='scoped/c', shape=[], dtype=float32, value=3.0)
  (key='a', shape=[], dtype=float32, value=1.0)
  (key='b', shape=[], dtype=float32, value=2.0)

[Converted]
Checkpoint at 'converted-tf1-to-tf2-1':
  (key='vars/scoped.Sc/.ATTRIBUTES/VARIABLE_VALUE', shape=[], dtype=float32, value=3.0)
  (key='vars/b/.ATTRIBUTES/VARIABLE_VALUE', shape=[], dtype=float32, value=2.0)
  (key='vars/a/.ATTRIBUTES/VARIABLE_VALUE', shape=[], dtype=float32, value=1.0)
  (key='_CHECKPOINTABLE_OBJECT_GRAPH', shape=[], dtype=string, value=b"\n\x1c\n\x08\x08\x01\x12\x04vars\n\x10\x08\x02\x12\x0csave_counter\n\x1c\n\x0c\x08\x03\x12\x08scoped/c\n\x05\x08\x04\x12\x01a\n\x05\x08\x05\x12\x01b\nI\x12G\n\x0eVARIABLE_VALUE\x12\x0csave_counter\x1a'save_counter/.ATTRIBUTES/VARIABLE_VALUE\nG\x12E\n\x0eVARIABLE_VALUE\x12\x08Variable\x1a)vars/scoped.Sc/.ATTRIBUTES/VARIABLE_VALUE\n?\x12=\n\x0eVARIABLE_VALUE\x12\x08Variable\x1a!vars/a/.ATTRIBUTES/VARIABLE_VALUE\n?\x12=\n\x0eVARIABLE_VALUE\x12\x08Variable\x1a!vars/b/.ATTRIBUTES/VARIABLE_VALUE")
  (key='save_counter/.ATTRIBUTES/VARIABLE_VALUE', shape=[], dtype=int64, value=1)

Restored [a, b, c]:  [1.0, 2.0, 3.0]

TF2 चेकपॉइंट को TF1 में बदलें

def convert_tf2_to_tf1(checkpoint_path, output_prefix):
  """Converts a TF2 checkpoint to TF1.

  The checkpoint must be saved using a 
  `tf.train.Checkpoint(var_list={name: variable})`

  To load the converted checkpoint with `tf.compat.v1.Saver`:
  ```
  saver = tf.compat.v1.train.Saver(var_list={name: variable}) 

  # An alternative, if the variable names match the keys:
  saver = tf.compat.v1.train.Saver(var_list=[variables]) 
  saver.restore(sess, output_path)

    ```
    """
    vars = {}
    reader = tf.train.load_checkpoint(checkpoint_path)
    dtypes = reader.get_variable_to_dtype_map()
    for key in dtypes.keys():
      # Get the "name" from the 
      if key.startswith('var_list/'):
        var_name = key.split('/')[1]
        # TF2 checkpoint keys use '/', so if they appear in the user-defined name,
        # they are escaped to '.S'.
        var_name = var_name.replace('.S', '/')
        vars[var_name] = tf.Variable(reader.get_tensor(key))

    return tf1.train.Saver(var_list=vars).save(sess=None, save_path=output_prefix)
  ```

Convert the checkpoint saved in the snippet `Save a TF2 checkpoint in TF1`:


```python
# Make sure to run the snippet in `Save a TF2 checkpoint in TF1`.
print_checkpoint('tf2-ckpt-saved-in-session-1')
converted_path = convert_tf2_to_tf1('tf2-ckpt-saved-in-session-1',
                                    'converted-tf2-to-tf1')
print("\n[Converted]")
print_checkpoint(converted_path)

# Try loading the converted checkpoint.
with tf.Graph().as_default() as g:
  a = tf1.get_variable('a', shape=[], dtype=tf.float32, 
                       initializer=tf1.constant_initializer(0))
  b = tf1.get_variable('b', shape=[], dtype=tf.float32, 
                       initializer=tf1.constant_initializer(0))
  with tf1.variable_scope('scoped'):
    c = tf1.get_variable('c', shape=[], dtype=tf.float32, 
                        initializer=tf1.constant_initializer(0))
  with tf1.Session() as sess:
    saver = tf1.train.Saver([a, b, c])
    saver.restore(sess, converted_path)
    print("\nRestored [a, b, c]: ", sess.run([a, b, c]))

Checkpoint at 'tf2-ckpt-saved-in-session-1':
  (key='var_list/scoped.Sc/.ATTRIBUTES/VARIABLE_VALUE', shape=[], dtype=float32, value=3.0)
  (key='var_list/b/.ATTRIBUTES/VARIABLE_VALUE', shape=[], dtype=float32, value=2.0)
  (key='var_list/a/.ATTRIBUTES/VARIABLE_VALUE', shape=[], dtype=float32, value=1.0)
  (key='_CHECKPOINTABLE_OBJECT_GRAPH', shape=[], dtype=string, value=b"\n \n\x0c\x08\x01\x12\x08var_list\n\x10\x08\x02\x12\x0csave_counter\n\x1c\n\x05\x08\x03\x12\x01a\n\x05\x08\x04\x12\x01b\n\x0c\x08\x05\x12\x08scoped/c\nI\x12G\n\x0eVARIABLE_VALUE\x12\x0csave_counter\x1a'save_counter/.ATTRIBUTES/VARIABLE_VALUE\n<\x12:\n\x0eVARIABLE_VALUE\x12\x01a\x1a%var_list/a/.ATTRIBUTES/VARIABLE_VALUE\n<\x12:\n\x0eVARIABLE_VALUE\x12\x01b\x1a%var_list/b/.ATTRIBUTES/VARIABLE_VALUE\nK\x12I\n\x0eVARIABLE_VALUE\x12\x08scoped/c\x1a-var_list/scoped.Sc/.ATTRIBUTES/VARIABLE_VALUE")
  (key='save_counter/.ATTRIBUTES/VARIABLE_VALUE', shape=[], dtype=int64, value=1)
WARNING:tensorflow:Saver is deprecated, please switch to tf.train.Checkpoint or tf.keras.Model.save_weights for training checkpoints. When executing eagerly variables do not necessarily have unique names, and so the variable.name-based lookups Saver performs are error-prone.

[Converted]
Checkpoint at 'converted-tf2-to-tf1':
  (key='scoped/c', shape=[], dtype=float32, value=3.0)
  (key='a', shape=[], dtype=float32, value=1.0)
  (key='b', shape=[], dtype=float32, value=2.0)
INFO:tensorflow:Restoring parameters from converted-tf2-to-tf1

Restored [a, b, c]:  [1.0, 2.0, 3.0]