এই পৃষ্ঠাটি Cloud Translation API অনুবাদ করেছে।

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

TensorFlow.org-এ দেখুন

Google Colab-এ চালান

GitHub এ দেখুন

নোটবুক ডাউনলোড করুন

ওভারভিউ

এই নির্দেশিকাটি অনুমান করে যে আপনার কাছে একটি মডেল আছে যা tf.compat.v1.Saver এর সাথে চেকপয়েন্টগুলি সংরক্ষণ করে এবং লোড করে এবং কোডটি TF2 tf.train.Checkpoint API ব্যবহার করে স্থানান্তর করতে চান, অথবা আপনার TF2 মডেলে আগে থেকে বিদ্যমান চেকপয়েন্টগুলি ব্যবহার করতে চান৷

নীচে কিছু সাধারণ পরিস্থিতি যা আপনি সম্মুখীন হতে পারেন:

দৃশ্যপট 1

পূর্ববর্তী ট্রেনিং রান থেকে বিদ্যমান TF1 চেকপয়েন্ট রয়েছে যেগুলি লোড করা বা TF2 তে রূপান্তর করা দরকার।

TF2 এ TF1 চেকপয়েন্ট লোড করতে, স্নিপেট দেখুন TF2 এ একটি TF1 চেকপয়েন্ট লোড করুন।
চেকপয়েন্টকে TF2 তে রূপান্তর করতে, চেকপয়েন্ট রূপান্তর দেখুন।

দৃশ্যকল্প 2

আপনি এমনভাবে আপনার মডেল সামঞ্জস্য করছেন যাতে পরিবর্তনশীল নাম এবং পথ পরিবর্তনের ঝুঁকি থাকে (যেমন যখন ক্রমবর্ধমানভাবে get_variable থেকে স্পষ্ট tf.Variable তৈরিতে স্থানান্তরিত হয়), এবং সেই পথে বিদ্যমান চেকপয়েন্টের সংরক্ষণ/লোডিং বজায় রাখতে চান।

মডেল মাইগ্রেশনের সময় কিভাবে চেকপয়েন্ট সামঞ্জস্য বজায় রাখা যায় সে বিষয়ে বিভাগটি দেখুন

দৃশ্যকল্প 3

আপনি আপনার প্রশিক্ষণ কোড এবং চেকপয়েন্টগুলিকে TF2 এ স্থানান্তরিত করছেন, কিন্তু আপনার অনুমান পাইপলাইনের জন্য আপাতত (উৎপাদন স্থিতিশীলতার জন্য) TF1 চেকপয়েন্ট প্রয়োজন।

বিকল্প 1

প্রশিক্ষণের সময় TF1 এবং TF2 উভয় চেকপয়েন্ট সংরক্ষণ করুন।

দেখুন TF2 এ একটি TF1 চেকপয়েন্ট সংরক্ষণ করুন

বিকল্প 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 এ কীগুলি দেখেন, সেগুলি প্রতিটি ভেরিয়েবলের অবজেক্ট পাথগুলিকে নির্দেশ করে। উদাহরণ স্বরূপ, variables তালিকার প্রথম উপাদান হল a হল, তাই এর কী 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

মডেল মাইগ্রেশনের সময় কিভাবে চেকপয়েন্ট সামঞ্জস্য বজায় রাখা যায়

মাইগ্রেশন প্রক্রিয়ার একটি গুরুত্বপূর্ণ ধাপ হল নিশ্চিত করা যে সমস্ত ভেরিয়েবল সঠিক মানগুলিতে শুরু করা হয়েছে , যা আপনাকে যাচাই করতে দেয় যে অপস/ফাংশনগুলি সঠিক গণনা করছে। এটি সম্পন্ন করার জন্য, আপনাকে অবশ্যই মাইগ্রেশনের বিভিন্ন পর্যায়ে মডেলগুলির মধ্যে চেকপয়েন্ট সামঞ্জস্যতা বিবেচনা করতে হবে। মূলত, এই বিভাগটি প্রশ্নের উত্তর দেয়, মডেল পরিবর্তন করার সময় আমি কীভাবে একই চেকপয়েন্ট ব্যবহার করতে পারি ।

নমনীয়তা বাড়ানোর জন্য নীচে চেকপয়েন্ট সামঞ্জস্য বজায় রাখার তিনটি উপায় রয়েছে:

মডেলটির আগের মতই পরিবর্তনশীল নাম রয়েছে।
মডেলটির বিভিন্ন পরিবর্তনশীল নাম রয়েছে এবং এটি একটি অ্যাসাইনমেন্ট মানচিত্র বজায় রাখে যা চেকপয়েন্টে পরিবর্তনশীল নামগুলিকে নতুন নামে ম্যাপ করে।
মডেলটির বিভিন্ন পরিবর্তনশীল নাম রয়েছে এবং এটি একটি 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.train.Saver দিয়ে একটি TF1 চেকপয়েন্ট সংরক্ষণ করুন:

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 ডেকোরেটর হল একটি শিম যা আপনাকে পরিবর্তনশীল নাম এবং TF1 চেকপয়েন্ট সামঞ্জস্য বজায় রাখতে সাহায্য করে, tf.variable_scope এবং tf.compat.v1.get_variable এর নামকরণ এবং শব্দার্থবিদ্যাকে অপরিবর্তিত রেখে। আরও তথ্যের জন্য মডেল ম্যাপিং গাইড দেখুন।

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

চেকপয়েন্ট কেরাস বিভাগটি দেখুন।

দ্রষ্টব্য 2: যখন tf.Variable থেকে get_variable এ স্থানান্তরিত হয়:

যদি আপনার শিম-সজ্জিত স্তর বা মডিউলে কিছু ভেরিয়েবল (বা কেরাস স্তর/মডেল) থাকে যেগুলি tf.compat.v1.get_variable এর পরিবর্তে tf.Variable ব্যবহার করে এবং একটি বস্তু ভিত্তিক উপায়ে বৈশিষ্ট্য/ট্র্যাক হিসাবে সংযুক্ত করা হয়, তবে তাদের আলাদা হতে পারে TF1.x গ্রাফ/সেশন বনাম উদগ্রীব সম্পাদনের সময় পরিবর্তনশীল নামকরণের শব্দার্থবিদ্যা।

সংক্ষেপে, নামগুলি TF2 এ চলাকালীন আপনি যা আশা করেন তা নাও হতে পারে ।

সতর্কতা: ভেরিয়েবলের সদৃশ নাম থাকতে পারে, যা সমস্যার কারণ হতে পারে যদি নাম-ভিত্তিক চেকপয়েন্টের একাধিক ভেরিয়েবলকে একই নামে ম্যাপ করতে হয়। আপনি tf.name_scope এবং লেয়ার কনস্ট্রাক্টর বা tf.Variable name আর্গুমেন্টগুলি ব্যবহার করে পরিবর্তনশীল নামগুলিকে সামঞ্জস্য করতে এবং কোনও সদৃশ নেই তা নিশ্চিত করতে স্পষ্টভাবে স্তর এবং পরিবর্তনশীল নামগুলি সামঞ্জস্য করতে সক্ষম হতে পারেন৷

অ্যাসাইনমেন্ট ম্যাপ বজায় রাখা

অ্যাসাইনমেন্ট ম্যাপ সাধারণত 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/' - checkpoint_scope_name থেকে বর্তমান 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 ' সহ প্রদত্ত tf. ভ্যারিয়েবল অবজেক্টকে আরম্ভ করবে।
'scope_variable_name': list(variable) - চেকপয়েন্ট থেকে 'স্কোপ_ভেরিয়েবল_নাম' টেনসর সহ পার্টিশন করা ভেরিয়েবলের তালিকা শুরু করবে।
'/': '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 বা TF2-শৈলীর চেকপয়েন্টগুলি সংরক্ষণ করতে অনুমানকারী এবং MonitoredSession করা সেশনকে সক্ষম করে।

# 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)

v এর চূড়ান্ত মান 16 হওয়া উচিত, est-tf1 থেকে উষ্ণ-শুরু করার পরে, তারপরে অতিরিক্ত 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 এবং model.load_weights এর সাথেও একই। নোট করুন যে Checkpoint(model) != Checkpoint(model=model) ।

TF2 চেকপয়েন্ট কেরাসের build() ধাপের সাথে কাজ করে

tf.train.Checkpoint.restore এ deferred restoration নামে একটি মেকানিজম রয়েছে যা 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()

এই পদ্ধতির কারণে, আমরা অত্যন্ত সুপারিশ করি যে আপনি কেরাস মডেলের সাথে 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]