সাহায্য Kaggle উপর TensorFlow সঙ্গে গ্রেট বেরিয়ার রিফ রক্ষা চ্যালেঞ্জ যোগদান

মডেল চেকপয়েন্ট স্থানান্তরিত

TensorFlow.org এ দেখুন GitHub এ দেখুন নোটবুক ডাউনলোড করুন

ওভারভিউ

এই নির্দেশিকাটি অনুমান আপনি একটি মডেল যে সংরক্ষণ করে এবং সঙ্গে লোড চেকপয়েন্ট আছে tf.compat.v1.Saver , এবং কোড ব্যবহার TF2 মাইগ্রেট করতে চান tf.train.Checkpoint এপিআই, বা ব্যবহারের পূর্ব বিদ্যমান আপনার 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 চেকপয়েন্ট লোড করা হয়নি। উভয় APIই আগ্রহী এবং গ্রাফ মোডের সাথে সামঞ্জস্যপূর্ণ, তাই আপনি মাইগ্রেশনের যেকোনো পর্যায়ে সেগুলি ব্যবহার করতে পারেন।

নীচে বিভিন্ন মডেলের সাথে একই চেকপয়েন্ট ব্যবহার করার উদাহরণ রয়েছে৷ প্রথমত, সঙ্গে একটি 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:1361: 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 যুক্তি আপনি নির্ধারণ করতে পারেন।
  • Keras মডেলের একটি নিতে name যুক্তি যা তারা তাদের ভেরিয়েবলের জন্য উপসর্গ হিসাবে সেট।
  • v1.name_scope ফাংশন পরিবর্তনশীল নাম উপসর্গ সেট করতে ব্যবহার করা যাবে। এই থেকে ভিন্ন tf.variable_scope । এটি শুধুমাত্র নামগুলিকে প্রভাবিত করে এবং ভেরিয়েবল এবং পুনরায় ব্যবহার ট্র্যাক করে না।

tf.compat.v1.keras.utils.track_tf1_style_variables প্রসাধক একটি shim যে সাহায্য করে আপনি, পরিবর্তনশীল নাম এবং TF1 চেকপয়েন্ট সামঞ্জস্য বজায় রাখা এর নামকরণ এবং পুনরায় ব্যবহার করার শব্দার্থবিদ্যা রেখে হয় tf.variable_scope এবং tf.compat.v1.get_variable অপরিবর্তিত। দেখুন মডেল ম্যাপিং নির্দেশিকা আরও তথ্যের জন্য।

দ্রষ্টব্য 1: আপনি যদি শিম ব্যবহার করেন তবে আপনার চেকপয়েন্টগুলি লোড করার জন্য TF2 API ব্যবহার করুন (এমনকি প্রাক-প্রশিক্ষিত TF1 চেকপয়েন্ট ব্যবহার করার সময়ও)।

অধ্যায় চেকপয়েন্ট Keras দেখুন।

উল্লেখ্য 2: যখন মাইগ্রেট tf.Variable থেকে get_variable :

আপনার shim-সজ্জিত স্তর বা মডিউল কিছু ভেরিয়েবল (অথবা Keras স্তর / মডেল) ব্যবহার নিয়ে গঠিত তাহলে tf.Variable পরিবর্তে tf.compat.v1.get_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 যখন একটি গ্রাফ / সেশন মধ্যে, কারণ এটি পরিবর্তে একটি বরাদ্দ অপ তৈরি পরিবর্তনশীল initializers মান স্থাপন নামক ইন করতে হবে।

আপনি ব্যবহার করতে পারেন assignment_map কিভাবে ভেরিয়েবল লোড করা হয় কনফিগার করতে যুক্তি। ডকুমেন্টেশন থেকে:

অ্যাসাইনমেন্ট মানচিত্র নিম্নলিখিত সিনট্যাক্স সমর্থন করে:

  • 'checkpoint_scope_name/': 'scope_name/' - বর্তমান সমস্ত ভেরিয়েবল লোড করা হবে scope_name থেকে checkpoint_scope_name ম্যাচিং টেন্সর নামের সাথে।
  • 'checkpoint_scope_name/some_other_variable': 'scope_name/variable_name' - হবে আরম্ভ scope_name/variable_name থেকে পরিবর্তনশীল checkpoint_scope_name/some_other_variable
  • '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]

সঙ্গে লোড হচ্ছে 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: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 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)

চূড়ান্ত মান v হওয়া উচিত 16 , উষ্ণ-শুরু থেকে হওয়ার পর est-tf1 , তারপর একটি অতিরিক্ত 5 ধাপের জন্য প্রশিক্ষণ দিয়েছিলেন। ট্রেন পদক্ষেপ মান থেকে বেশি বহন করে না warm_start চেকপয়েন্ট।

চেকপয়েন্টিং কেরাস

Keras নির্মিত মডেল এখনও ব্যবহার tf1.train.Saver এবং tf.train.Checkpoint লোড পূর্ব বিদ্যমান ওজন হবে। যখন আপনার মডেল সম্পূর্ণরূপে আসেন করা হয়, এ স্যুইচ model.save_weights এবং model.load_weights , বিশেষ করে যদি আপনি ব্যবহার করছেন ModelCheckpoint কলব্যাক যখন প্রশিক্ষণ।

চেকপয়েন্ট এবং কেরাস সম্পর্কে আপনার কিছু জিনিস জানা উচিত:

সূচনা বনাম বিল্ডিং

Keras মডেল এবং স্তর সম্পূর্ণরূপে নির্মিত হওয়ার আগে দুই পদক্ষেপের মধ্য দিয়ে যেতে হবে। : প্রথম পাইথন বস্তুর আরম্ভের হয় 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 এবং model.load_weights । লক্ষ্য করুন Checkpoint(model) != Checkpoint(model=model)

Keras এর সঙ্গে TF2 চেকপয়েন্ট কাজ 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]