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

TF2 ওয়ার্কফ্লোতে TF1.x মডেল ব্যবহার করুন

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

এই নির্দেশিকাটি একটি মডেলিং কোড শিমের একটি ওভারভিউ এবং উদাহরণ প্রদান করে যা আপনি আপনার বিদ্যমান TF1.x মডেলগুলিকে TF2 ওয়ার্কফ্লোতে ব্যবহার করতে পারেন যেমন আপনার মডেলিং কোডে ন্যূনতম পরিবর্তন সহ উদগ্রীব সম্পাদন, tf.function এবং বিতরণ কৌশলগুলি।

ব্যবহারের সুযোগ

এই নির্দেশিকায় বর্ণিত শিমটি TF1.x মডেলগুলির জন্য ডিজাইন করা হয়েছে যা নির্ভর করে:

  1. tf.compat.v1.get_variable এবং tf.compat.v1.variable_scope পরিবর্তনশীল সৃষ্টি এবং পুনরায় ব্যবহার নিয়ন্ত্রণ করতে, এবং
  2. গ্রাফ-সংগ্রহ ভিত্তিক API যেমন tf.compat.v1.global_variables() , tf.compat.v1.trainable_variables , tf.compat.v1.losses.get_regularization_losses() , এবং tf.compat.v1.get_collection() ট্র্যাক রাখতে ওজন এবং নিয়মিতকরণের ক্ষতি

এর মধ্যে রয়েছে tf.compat.v1.layer , tf.contrib.layers API, এবং TensorFlow - Slim-এর উপরে নির্মিত বেশিরভাগ মডেল।

নিম্নলিখিত TF1.x মডেলের জন্য শিম প্রয়োজনীয় নয় :

  1. স্ট্যান্ড-অ্যালোন কেরাস মডেল যা ইতিমধ্যেই যথাক্রমে model.trainable_weights এবং model.losses এর মাধ্যমে তাদের সমস্ত প্রশিক্ষণযোগ্য ওজন এবং নিয়মিতকরণের ক্ষতিগুলি ট্র্যাক করে।
  2. tf.Module s যারা ইতিমধ্যেই module.trainable_variables এর মাধ্যমে তাদের সমস্ত প্রশিক্ষণযোগ্য ওজন ট্র্যাক করে এবং শুধুমাত্র ওজন তৈরি করে যদি সেগুলি ইতিমধ্যে তৈরি না হয়ে থাকে।

এই মডেলগুলি TF2-এ কাজ করতে পারে আগ্রহী এবং tf.function এর বাইরে।

সেটআপ

TensorFlow এবং অন্যান্য নির্ভরতা আমদানি করুন।

pip uninstall -y -q tensorflow
# Install tf-nightly as the DeterministicRandomTestTool is available only in
# Tensorflow 2.8

pip install -q tf-nightly
import tensorflow as tf
import tensorflow.compat.v1 as v1
import sys
import numpy as np

from contextlib import contextmanager

track_tf1_style_variables ডেকোরেটর

এই নির্দেশিকায় বর্ণিত মূল শিমটি হল tf.compat.v1.keras.utils.track_tf1_style_variables , একটি ডেকোরেটর যা আপনি tf.keras.layers.Layer এবং tf.Module এর সাথে সম্পর্কিত পদ্ধতিতে TF1.x-স্টাইল ওজন এবং ট্র্যাক করতে ব্যবহার করতে পারেন নিয়মিতকরণ ক্ষতি ক্যাপচার.

tf.compat.v1.keras.utils.track_tf1_style_variables সহ একটি tf.keras.layers.Layer 's বা tf.Module এর কল পদ্ধতিগুলিকে tf.compat.v1.get_variable tf.compat.v1.keras.utils.track_tf1_style_variables এবং এক্সটেনশন tf.compat.v1.layers ) সবসময় প্রতিটি কলে একটি নতুন ভেরিয়েবল তৈরি করার পরিবর্তে সজ্জিত পদ্ধতির ভিতরে সঠিকভাবে কাজ করা। এটি লেয়ার বা মডিউলটিকে সজ্জিত পদ্ধতির ভিতরে get_variable এর মাধ্যমে তৈরি বা অ্যাক্সেস করা যেকোন ওজনকে অন্তর্নিহিতভাবে ট্র্যাক করার কারণ করবে।

স্ট্যান্ডার্ড layer.variable / module.variable /etc-এর অধীনে ওজন ট্র্যাক করার পাশাপাশি। বৈশিষ্ট্য, যদি পদ্ধতিটি একটি tf.keras.layers.Layer এর অন্তর্গত হয়, তাহলে get_variable বা tf.compat.v1.layers আর্গুমেন্টের মাধ্যমে নির্দিষ্ট করা যেকোনো রেগুলারাইজেশন লস স্ট্যান্ডার্ড layer.losses প্রপার্টির অধীনে লেয়ার দ্বারা ট্র্যাক করা হবে।

এই ট্র্যাকিং প্রক্রিয়াটি কেরাস স্তরগুলির ভিতরে tf.Module শৈলী মডেল-ফরোয়ার্ড-পাস কোডের বড় ক্লাসগুলি ব্যবহার করতে সক্ষম করে বা TF2 তে tf. মডিউলগুলি এমনকি TF2 আচরণগুলি সক্ষম করেও।

ব্যবহারের উদাহরণ

নীচের ব্যবহারের উদাহরণগুলি tf.keras.layers.Layer পদ্ধতিগুলিকে সাজাতে ব্যবহৃত মডেলিং শিমগুলি প্রদর্শন করে, তবে যেখানে তারা বিশেষভাবে কেরাস বৈশিষ্ট্যগুলির সাথে ইন্টারঅ্যাক্ট করছে তা ছাড়া তারা tf.Module পদ্ধতিগুলিকে সাজানোর সময়ও প্রযোজ্য।

tf.compat.v1.get_variable দিয়ে তৈরি লেয়ার

কল্পনা করুন যে আপনি একটি স্তর সরাসরি tf.compat.v1.get_variable এর উপরে প্রয়োগ করেছেন:

def dense(self, inputs, units):
  out = inputs
  with tf.compat.v1.variable_scope("dense"):
    # The weights are created with a `regularizer`,
    kernel = tf.compat.v1.get_variable(
        shape=[out.shape[-1], units],
        regularizer=tf.keras.regularizers.L2(),
        initializer=tf.compat.v1.initializers.glorot_normal,
        name="kernel")
    bias = tf.compat.v1.get_variable(
        shape=[units,],
        initializer=tf.compat.v1.initializers.zeros,
        name="bias")
    out = tf.linalg.matmul(out, kernel)
    out = tf.compat.v1.nn.bias_add(out, bias)
  return out

এটিকে একটি স্তরে পরিণত করতে শিম ব্যবহার করুন এবং এটিকে ইনপুটগুলিতে কল করুন৷

class DenseLayer(tf.keras.layers.Layer):

  def __init__(self, units, *args, **kwargs):
    super().__init__(*args, **kwargs)
    self.units = units

  @tf.compat.v1.keras.utils.track_tf1_style_variables
  def call(self, inputs):
    out = inputs
    with tf.compat.v1.variable_scope("dense"):
      # The weights are created with a `regularizer`,
      # so the layer should track their regularization losses
      kernel = tf.compat.v1.get_variable(
          shape=[out.shape[-1], self.units],
          regularizer=tf.keras.regularizers.L2(),
          initializer=tf.compat.v1.initializers.glorot_normal,
          name="kernel")
      bias = tf.compat.v1.get_variable(
          shape=[self.units,],
          initializer=tf.compat.v1.initializers.zeros,
          name="bias")
      out = tf.linalg.matmul(out, kernel)
      out = tf.compat.v1.nn.bias_add(out, bias)
    return out

layer = DenseLayer(10)
x = tf.random.normal(shape=(8, 20))
layer(x)
WARNING:tensorflow:From /tmp/ipykernel_27038/795621215.py:7: The name tf.keras.utils.track_tf1_style_variables is deprecated. Please use tf.compat.v1.keras.utils.track_tf1_style_variables instead.
<tf.Tensor: shape=(8, 10), dtype=float32, numpy=
array([[-0.51018804, -0.58145535,  0.25050664, -0.09880018,  0.71741414,
        -0.08512568,  0.33404148,  0.50894034,  0.19362557,  0.03945067],
       [-0.66160053,  0.43442816, -0.6187523 ,  0.00753711,  1.3946855 ,
         0.22528797,  0.55661404, -1.6155301 ,  1.5854199 , -0.4165327 ],
       [ 0.15855707,  0.43848652,  0.04762229,  0.22020248,  0.88300526,
         0.31525093, -0.10912375,  0.03332198,  1.3462385 , -0.37986106],
       [ 0.02546233, -0.01084138,  0.0417656 ,  1.1082407 ,  0.926408  ,
         0.46938205,  1.0183189 ,  1.2039868 , -0.09619217, -0.50863194],
       [-1.6222394 ,  0.17156005, -0.07482994,  0.646423  ,  1.0284312 ,
         2.3619173 ,  0.6322627 ,  0.5350776 , -2.2700598 , -0.8211552 ],
       [-1.1044651 ,  0.7303245 ,  1.0183476 ,  1.2858934 ,  0.4575533 ,
         0.93400717,  0.5323913 , -0.01242167,  0.8308919 ,  0.03202473],
       [ 0.3880633 , -1.2345276 ,  0.7713047 , -0.33720714,  1.0418141 ,
        -1.055242  , -1.6942265 ,  1.705035  ,  0.8671215 ,  0.8162696 ],
       [ 0.02216246, -0.5235669 ,  0.01065174, -1.1682817 ,  0.44079733,
         0.25890222, -1.0779501 ,  0.37716752, -0.27636313, -0.6359312 ]],
      dtype=float32)>

স্ট্যান্ডার্ড কেরাস লেয়ারের মতো ট্র্যাক করা ভেরিয়েবল এবং ক্যাপচার করা রেগুলারাইজেশন লস অ্যাক্সেস করুন।

layer.trainable_variables
layer.losses
2021-12-04 02:24:42.941890: W tensorflow/python/util/util.cc:368] Sets are not currently considered sequences, but this may change in the future, so consider avoiding using them.
[<tf.Tensor: shape=(), dtype=float32, numpy=0.10789324>]

প্রতিবার আপনি লেয়ারটিকে কল করার সময় ওজনগুলি পুনরায় ব্যবহার করা হয় তা দেখতে, সমস্ত ওজন শূন্যে সেট করুন এবং স্তরটিকে আবার কল করুন।

print("Resetting variables to zero:", [var.name for var in layer.trainable_variables])

for var in layer.trainable_variables:
  var.assign(var * 0.0)

# Note: layer.losses is not a live view and
# will get reset only at each layer call
print("layer.losses:", layer.losses)
print("calling layer again.")
out = layer(x)
print("layer.losses: ", layer.losses)
out
Resetting variables to zero: ['dense/bias:0', 'dense/kernel:0']
layer.losses: [<tf.Tensor: shape=(), dtype=float32, numpy=0.0>]
calling layer again.
layer.losses:  [<tf.Tensor: shape=(), dtype=float32, numpy=0.0>]
<tf.Tensor: shape=(8, 10), dtype=float32, numpy=
array([[0., 0., 0., 0., 0., 0., 0., 0., 0., 0.],
       [0., 0., 0., 0., 0., 0., 0., 0., 0., 0.],
       [0., 0., 0., 0., 0., 0., 0., 0., 0., 0.],
       [0., 0., 0., 0., 0., 0., 0., 0., 0., 0.],
       [0., 0., 0., 0., 0., 0., 0., 0., 0., 0.],
       [0., 0., 0., 0., 0., 0., 0., 0., 0., 0.],
       [0., 0., 0., 0., 0., 0., 0., 0., 0., 0.],
       [0., 0., 0., 0., 0., 0., 0., 0., 0., 0.]], dtype=float32)>

আপনি রূপান্তরিত স্তরটি সরাসরি কেরাস কার্যকরী মডেল নির্মাণেও ব্যবহার করতে পারেন।

inputs = tf.keras.Input(shape=(20))
outputs = DenseLayer(10)(inputs)
model = tf.keras.Model(inputs=inputs, outputs=outputs)

x = tf.random.normal(shape=(8, 20))
model(x)

# Access the model variables and regularization losses
model.weights
model.losses
[<tf.Tensor: shape=(), dtype=float32, numpy=0.1345337>]

tf.compat.v1.layers সহ নির্মিত মডেল

কল্পনা করুন যে আপনি একটি স্তর বা মডেল সরাসরি tf.compat.v1.layers এর উপরে প্রয়োগ করেছেন:

def model(self, inputs, units):
  with tf.compat.v1.variable_scope('model'):
    out = tf.compat.v1.layers.conv2d(
        inputs, 3, 3,
        kernel_regularizer="l2")
    out = tf.compat.v1.layers.flatten(out)
    out = tf.compat.v1.layers.dense(
        out, units,
        kernel_regularizer="l2")
    return out

এটিকে একটি স্তরে পরিণত করতে শিম ব্যবহার করুন এবং এটিকে ইনপুটগুলিতে কল করুন৷

class CompatV1LayerModel(tf.keras.layers.Layer):

  def __init__(self, units, *args, **kwargs):
    super().__init__(*args, **kwargs)
    self.units = units

  @tf.compat.v1.keras.utils.track_tf1_style_variables
  def call(self, inputs):
    with tf.compat.v1.variable_scope('model'):
      out = tf.compat.v1.layers.conv2d(
          inputs, 3, 3,
          kernel_regularizer="l2")
      out = tf.compat.v1.layers.flatten(out)
      out = tf.compat.v1.layers.dense(
          out, self.units,
          kernel_regularizer="l2")
      return out

layer = CompatV1LayerModel(10)
x = tf.random.normal(shape=(8, 5, 5, 5))
layer(x)
/tmpfs/src/tf_docs_env/lib/python3.7/site-packages/ipykernel_launcher.py:12: UserWarning: `tf.layers.conv2d` is deprecated and will be removed in a future version. Please Use `tf.keras.layers.Conv2D` instead.
  if sys.path[0] == '':
/tmpfs/src/tf_docs_env/lib/python3.7/site-packages/keras/legacy_tf_layers/convolutional.py:575: UserWarning: `layer.apply` is deprecated and will be removed in a future version. Please use `layer.__call__` method instead.
  return layer.apply(inputs)
/tmpfs/src/tf_docs_env/lib/python3.7/site-packages/ipykernel_launcher.py:13: UserWarning: `tf.layers.flatten` is deprecated and will be removed in a future version. Please use `tf.keras.layers.Flatten` instead.
  del sys.path[0]
/tmpfs/src/tf_docs_env/lib/python3.7/site-packages/keras/legacy_tf_layers/core.py:541: UserWarning: `layer.apply` is deprecated and will be removed in a future version. Please use `layer.__call__` method instead.
  return layer.apply(inputs)
/tmpfs/src/tf_docs_env/lib/python3.7/site-packages/ipykernel_launcher.py:16: UserWarning: `tf.layers.dense` is deprecated and will be removed in a future version. Please use `tf.keras.layers.Dense` instead.
  app.launch_new_instance()
/tmpfs/src/tf_docs_env/lib/python3.7/site-packages/keras/legacy_tf_layers/core.py:261: UserWarning: `layer.apply` is deprecated and will be removed in a future version. Please use `layer.__call__` method instead.
  return layer.apply(inputs)
<tf.Tensor: shape=(8, 10), dtype=float32, numpy=
array([[ 2.4439096 , -0.2912227 ,  1.5531251 ,  1.284059  ,  0.10077369,
        -0.4231838 ,  1.0458903 , -0.01530766,  0.07358164, -0.6108157 ],
       [-0.4576063 ,  0.34942552,  2.3044965 ,  1.1483003 , -1.2211238 ,
         0.5634397 ,  0.73821646, -0.07581732,  0.5747937 , -0.66470885],
       [-2.2948585 , -2.709268  ,  1.7494816 , -0.9808065 , -2.9099958 ,
         0.5067346 , -1.011502  ,  2.559535  , -3.0888772 ,  0.3522656 ],
       [ 1.7788265 ,  0.8846102 ,  0.45562026,  0.01498583, -0.12482446,
        -0.32868862, -0.7743829 ,  2.3106992 , -0.0997327 , -0.7715093 ],
       [ 0.40295708,  0.04771695, -0.21336336, -0.13069987,  2.279875  ,
         2.7284563 ,  0.6444641 , -1.1919906 ,  0.96321577,  1.0182515 ],
       [ 0.47900966,  0.04906505,  1.1335449 ,  0.2907704 ,  0.7732022 ,
         0.68217   ,  0.51932573, -0.45156685,  2.081223  ,  1.068861  ],
       [ 0.10084352,  1.6456002 ,  0.63820475,  1.5959243 ,  0.22463399,
         0.07713126,  0.7467398 , -1.5435244 ,  1.2494736 , -0.07683721],
       [ 2.1396816 ,  1.5613532 , -1.1726325 , -0.88917583,  1.6447946 ,
        -1.0071977 , -1.8496083 ,  1.1887017 ,  2.1971662 ,  2.1175954 ]],
      dtype=float32)>

স্ট্যান্ডার্ড কেরাস লেয়ারের মতো ট্র্যাক করা ভেরিয়েবল এবং ক্যাপচার করা রেগুলারাইজেশন লস অ্যাক্সেস করুন।

layer.trainable_variables
layer.losses
[<tf.Tensor: shape=(), dtype=float32, numpy=0.03623246>,
 <tf.Tensor: shape=(), dtype=float32, numpy=0.14618248>]

প্রতিবার আপনি লেয়ারটিকে কল করার সময় ওজনগুলি পুনরায় ব্যবহার করা হয় তা দেখতে, সমস্ত ওজন শূন্যে সেট করুন এবং স্তরটিকে আবার কল করুন।

print("Resetting variables to zero:", [var.name for var in layer.trainable_variables])

for var in layer.trainable_variables:
  var.assign(var * 0.0)

out = layer(x)
print("layer.losses: ", layer.losses)
out
Resetting variables to zero: ['model/conv2d/bias:0', 'model/conv2d/kernel:0', 'model/dense/bias:0', 'model/dense/kernel:0']
layer.losses:  [<tf.Tensor: shape=(), dtype=float32, numpy=0.0>, <tf.Tensor: shape=(), dtype=float32, numpy=0.0>]
/tmpfs/src/tf_docs_env/lib/python3.7/site-packages/ipykernel_launcher.py:12: UserWarning: `tf.layers.conv2d` is deprecated and will be removed in a future version. Please Use `tf.keras.layers.Conv2D` instead.
  if sys.path[0] == '':
/tmpfs/src/tf_docs_env/lib/python3.7/site-packages/ipykernel_launcher.py:13: UserWarning: `tf.layers.flatten` is deprecated and will be removed in a future version. Please use `tf.keras.layers.Flatten` instead.
  del sys.path[0]
/tmpfs/src/tf_docs_env/lib/python3.7/site-packages/ipykernel_launcher.py:16: UserWarning: `tf.layers.dense` is deprecated and will be removed in a future version. Please use `tf.keras.layers.Dense` instead.
  app.launch_new_instance()
<tf.Tensor: shape=(8, 10), dtype=float32, numpy=
array([[0., 0., 0., 0., 0., 0., 0., 0., 0., 0.],
       [0., 0., 0., 0., 0., 0., 0., 0., 0., 0.],
       [0., 0., 0., 0., 0., 0., 0., 0., 0., 0.],
       [0., 0., 0., 0., 0., 0., 0., 0., 0., 0.],
       [0., 0., 0., 0., 0., 0., 0., 0., 0., 0.],
       [0., 0., 0., 0., 0., 0., 0., 0., 0., 0.],
       [0., 0., 0., 0., 0., 0., 0., 0., 0., 0.],
       [0., 0., 0., 0., 0., 0., 0., 0., 0., 0.]], dtype=float32)>

আপনি রূপান্তরিত স্তরটি সরাসরি কেরাস কার্যকরী মডেল নির্মাণেও ব্যবহার করতে পারেন।

inputs = tf.keras.Input(shape=(5, 5, 5))
outputs = CompatV1LayerModel(10)(inputs)
model = tf.keras.Model(inputs=inputs, outputs=outputs)

x = tf.random.normal(shape=(8, 5, 5, 5))
model(x)
/tmpfs/src/tf_docs_env/lib/python3.7/site-packages/ipykernel_launcher.py:12: UserWarning: `tf.layers.conv2d` is deprecated and will be removed in a future version. Please Use `tf.keras.layers.Conv2D` instead.
  if sys.path[0] == '':
/tmpfs/src/tf_docs_env/lib/python3.7/site-packages/keras/legacy_tf_layers/base.py:573: UserWarning: `layer.updates` will be removed in a future version. This property should not be used in TensorFlow 2.0, as `updates` are applied automatically.
  _add_elements_to_collection(self.updates, tf.compat.v1.GraphKeys.UPDATE_OPS)
/tmpfs/src/tf_docs_env/lib/python3.7/site-packages/ipykernel_launcher.py:13: UserWarning: `tf.layers.flatten` is deprecated and will be removed in a future version. Please use `tf.keras.layers.Flatten` instead.
  del sys.path[0]
/tmpfs/src/tf_docs_env/lib/python3.7/site-packages/ipykernel_launcher.py:16: UserWarning: `tf.layers.dense` is deprecated and will be removed in a future version. Please use `tf.keras.layers.Dense` instead.
  app.launch_new_instance()
<tf.Tensor: shape=(8, 10), dtype=float32, numpy=
array([[ 0.19487001,  0.54727787,  1.1044168 , -0.6613899 , -0.26437742,
        -1.1580509 , -0.24707682,  0.97752655,  0.59436107,  0.13125825],
       [ 0.48974586, -1.3510125 ,  0.7186962 , -0.8996632 , -0.60448873,
         0.06332532,  0.31494308,  0.23021704, -1.9166642 ,  0.3890404 ],
       [-0.06499191, -0.21485235,  0.01158494,  1.4407377 , -0.0488929 ,
        -0.37594396, -0.4386894 , -0.08751169,  1.0905663 , -1.5450519 ],
       [-2.2749739 , -2.4603422 , -1.3834419 , -2.8800466 ,  0.8954872 ,
        -3.0429187 , -0.7885461 ,  1.6037437 , -3.1845028 , -1.0725503 ],
       [ 0.98735195, -0.45159122,  0.892656  ,  0.477053  ,  0.31193537,
        -0.44723228, -0.01815075, -0.47465172, -1.665448  , -2.105824  ],
       [-2.5408387 , -1.7552321 , -1.924145  , -0.6395873 ,  0.4081779 ,
        -0.48731515, -3.2637763 , -1.4409767 , -2.032539  ,  0.10204412],
       [ 2.1583526 ,  0.78955674, -0.07266375,  0.06652926,  2.1300716 ,
        -1.6256162 ,  0.56154627, -0.76179224,  2.2985756 , -1.5504618 ],
       [ 2.062847  ,  0.971378  , -1.0830508 ,  1.8224751 , -0.3542943 ,
         0.74113446, -0.6204865 ,  1.4503044 , -0.4979878 , -0.4383126 ]],
      dtype=float32)>
# Access the model variables and regularization losses
model.weights
model.losses
[<tf.Tensor: shape=(), dtype=float32, numpy=0.03079858>,
 <tf.Tensor: shape=(), dtype=float32, numpy=0.12991619>]

ব্যাচ স্বাভাবিকীকরণ আপডেট এবং মডেল training args ক্যাপচার

TF1.x-এ, আপনি এইভাবে ব্যাচ স্বাভাবিকীকরণ করেন:

  x_norm = tf.compat.v1.layers.batch_normalization(x, training=training)

  # ...

  update_ops = tf.compat.v1.get_collection(tf.GraphKeys.UPDATE_OPS)
  train_op = optimizer.minimize(loss)
  train_op = tf.group([train_op, update_ops])

মনে রাখবেন যে:

  1. ব্যাচ নর্মালাইজেশন মুভিং এভারেজ আপডেটগুলি get_collection দ্বারা ট্র্যাক করা হয় যা লেয়ার থেকে আলাদাভাবে বলা হয়েছিল
  2. tf.compat.v1.layers.batch_normalization জন্য একটি training যুক্তি প্রয়োজন (TF-Slim ব্যাচ স্বাভাবিককরণ স্তরগুলি ব্যবহার করার সময় সাধারণত is_training বলা হয়)

TF2-এ, আগ্রহী সম্পাদন এবং স্বয়ংক্রিয় নিয়ন্ত্রণ নির্ভরতার কারণে, ব্যাচ স্বাভাবিককরণ মুভিং এভারেজ আপডেটগুলি এখনই কার্যকর করা হবে। আপডেট সংগ্রহ থেকে আলাদাভাবে সংগ্রহ করার এবং সুস্পষ্ট নিয়ন্ত্রণ নির্ভরতা হিসাবে তাদের যোগ করার দরকার নেই।

অতিরিক্তভাবে, আপনি যদি আপনার tf.keras.layers.Layer এর ফরোয়ার্ড পাস পদ্ধতিকে একটি training যুক্তি দেন, তাহলে কেরাস বর্তমান প্রশিক্ষণের পর্যায় এবং যেকোনো নেস্টেড স্তরগুলিকে পাস করতে সক্ষম হবে ঠিক যেমন এটি অন্য কোনো স্তরের জন্য করে। কেরাস কীভাবে training আর্গুমেন্ট পরিচালনা করে সে সম্পর্কে আরও তথ্যের জন্য tf.keras.Model এর API ডক্স দেখুন।

আপনি যদি tf.Module পদ্ধতিগুলি সাজান, তাহলে আপনাকে নিশ্চিত করতে হবে যে প্রয়োজন অনুযায়ী সমস্ত training আর্গুমেন্ট ম্যানুয়ালি পাস করা যাবে। যাইহোক, ব্যাচ নর্মালাইজেশন মুভিং এভারেজ আপডেট এখনও স্বয়ংক্রিয়ভাবে প্রয়োগ করা হবে সুস্পষ্ট নিয়ন্ত্রণ নির্ভরতার প্রয়োজন ছাড়াই।

নিম্নলিখিত কোড স্নিপেটগুলি প্রদর্শন করে যে কীভাবে শিমে ব্যাচের স্বাভাবিককরণ স্তরগুলি এম্বেড করা যায় এবং কেরাস মডেলে এটি কীভাবে ব্যবহার করে ( tf.keras.layers.Layer ক্ষেত্রে প্রযোজ্য)।

class CompatV1BatchNorm(tf.keras.layers.Layer):

  @tf.compat.v1.keras.utils.track_tf1_style_variables
  def call(self, inputs, training=None):
    print("Forward pass called with `training` =", training)
    with v1.variable_scope('batch_norm_layer'):
      return v1.layers.batch_normalization(x, training=training)
print("Constructing model")
inputs = tf.keras.Input(shape=(5, 5, 5))
outputs = CompatV1BatchNorm()(inputs)
model = tf.keras.Model(inputs=inputs, outputs=outputs)

print("Calling model in inference mode")
x = tf.random.normal(shape=(8, 5, 5, 5))
model(x, training=False)

print("Moving average variables before training: ",
      {var.name: var.read_value() for var in model.non_trainable_variables})

# Notice that when running TF2 and eager execution, the batchnorm layer directly
# updates the moving averages while training without needing any extra control
# dependencies
print("calling model in training mode")
model(x, training=True)

print("Moving average variables after training: ",
      {var.name: var.read_value() for var in model.non_trainable_variables})
/tmpfs/src/tf_docs_env/lib/python3.7/site-packages/ipykernel_launcher.py:7: UserWarning: `tf.layers.batch_normalization` is deprecated and will be removed in a future version. Please use `tf.keras.layers.BatchNormalization` instead. In particular, `tf.control_dependencies(tf.GraphKeys.UPDATE_OPS)` should not be used (consult the `tf.keras.layers.BatchNormalization` documentation).
  import sys
/tmpfs/src/tf_docs_env/lib/python3.7/site-packages/keras/legacy_tf_layers/normalization.py:463: UserWarning: `layer.apply` is deprecated and will be removed in a future version. Please use `layer.__call__` method instead.
  return layer.apply(inputs, training=training)
Constructing model
Forward pass called with `training` = None
Calling model in inference mode
Forward pass called with `training` = False
Moving average variables before training:  {'batch_norm_layer/batch_normalization/moving_mean:0': <tf.Tensor: shape=(5,), dtype=float32, numpy=array([0., 0., 0., 0., 0.], dtype=float32)>, 'batch_norm_layer/batch_normalization/moving_variance:0': <tf.Tensor: shape=(5,), dtype=float32, numpy=array([1., 1., 1., 1., 1.], dtype=float32)>}
calling model in training mode
Forward pass called with `training` = True
Moving average variables after training:  {'batch_norm_layer/batch_normalization/moving_mean:0': <tf.Tensor: shape=(5,), dtype=float32, numpy=
array([-0.00177554, -0.00036542, -0.00099426, -0.00112544,  0.0008541 ],
      dtype=float32)>, 'batch_norm_layer/batch_normalization/moving_variance:0': <tf.Tensor: shape=(5,), dtype=float32, numpy=
array([1.0005339, 1.0003369, 0.9976748, 1.0001523, 1.0009514],
      dtype=float32)>}

পরিবর্তনশীল-স্কোপ ভিত্তিক পরিবর্তনশীল পুনঃব্যবহার

get_variable এর উপর ভিত্তি করে ফরওয়ার্ড পাসে যেকোন ভেরিয়েবল সৃষ্টি একই ভেরিয়েবলের নামকরণ বজায় রাখবে এবং TF1.x-এ ভেরিয়েবল স্কোপের যে শব্দার্থবিদ্যা আছে তা পুনরায় ব্যবহার করবে। যতক্ষণ না উপরে উল্লিখিত হিসাবে স্বয়ংক্রিয়-উত্পন্ন নাম সহ যে কোনও tf.compat.v1.layers এর জন্য আপনার কাছে অন্তত একটি খালি বাইরের সুযোগ থাকে ততক্ষণ এটি সত্য।

উদগ্রীব মৃত্যুদন্ড এবং tf.function

উপরে যেমন দেখা গেছে, tf.keras.layers.Layer এবং tf.Module এর জন্য সজ্জিত পদ্ধতিগুলি আগ্রহী সম্পাদনের ভিতরে চলে এবং tf.function এর সাথে সামঞ্জস্যপূর্ণ। এর মানে আপনি pdb এবং অন্যান্য ইন্টারেক্টিভ টুল ব্যবহার করতে পারেন আপনার ফরোয়ার্ড পাসের মাধ্যমে যখন এটি চলছে।

বিতরণ কৌশল

@track_tf1_style_variables এর ভিতরে get_variable এর জন্য কল করা - সজ্জিত স্তর বা মডিউল পদ্ধতিগুলি হুডের নীচে স্ট্যান্ডার্ড tf.Variable . ভ্যারিয়েবল পরিবর্তনশীল সৃষ্টি ব্যবহার করে। এর মানে আপনি tf.distribute এর সাথে উপলব্ধ বিভিন্ন বন্টন কৌশল যেমন MirroredStrategy এবং TPUStrategy এর সাথে ব্যবহার করতে পারেন।

সজ্জিত কলে tf.Variable s, tf.Module s, tf.keras.layers এবং tf.keras.models করা

tf.compat.v1.keras.utils.track_tf1_style_variables tf.compat.v1.get_variable মাধ্যমে তৈরি (এবং পুনরায় ব্যবহার করা) ভেরিয়েবলের স্বয়ংক্রিয় অন্তর্নিহিত ট্র্যাকিং যোগ করবে। এটি সরাসরি tf.Variable . ভ্যারিয়েবল কল দ্বারা তৈরি ওজন ক্যাপচার করবে না, যেমন সাধারণ কেরাস স্তরগুলি এবং বেশিরভাগ tf.Module . মডিউলগুলি দ্বারা ব্যবহৃত। এই বিভাগটি এই নেস্টেড কেসগুলি কীভাবে পরিচালনা করতে হয় তা বর্ণনা করে৷

(প্রাক-বিদ্যমান ব্যবহার) tf.keras.layers এবং tf.keras.models

নেস্টেড কেরাস স্তর এবং মডেলগুলির পূর্ব-বিদ্যমান ব্যবহারের জন্য, tf.compat.v1.keras.utils.get_or_create_layer ব্যবহার করুন। এটি শুধুমাত্র বিদ্যমান TF1.x নেস্টেড কেরাস ব্যবহারের স্থানান্তর সহজ করার জন্য সুপারিশ করা হয়; নতুন কোডে tf.Variables এবং tf.Modules-এর জন্য নীচে বর্ণিত হিসাবে স্পষ্ট বৈশিষ্ট্য সেটিং ব্যবহার করা উচিত।

tf.compat.v1.keras.utils.get_or_create_layer ব্যবহার করতে, আপনার নেস্টেড মডেলটিকে একটি পদ্ধতিতে তৈরি করে এমন কোডটি মোড়ানো করুন এবং এটিকে পদ্ধতিতে পাস করুন। উদাহরণ:

class NestedModel(tf.keras.Model):

  def __init__(self, units, *args, **kwargs):
    super().__init__(*args, **kwargs)
    self.units = units

  def build_model(self):
    inp = tf.keras.Input(shape=(5, 5))
    dense_layer = tf.keras.layers.Dense(
        10, name="dense", kernel_regularizer="l2",
        kernel_initializer=tf.compat.v1.ones_initializer())
    model = tf.keras.Model(inputs=inp, outputs=dense_layer(inp))
    return model

  @tf.compat.v1.keras.utils.track_tf1_style_variables
  def call(self, inputs):
    # Get or create a nested model without assigning it as an explicit property
    model = tf.compat.v1.keras.utils.get_or_create_layer(
        "dense_model", self.build_model)
    return model(inputs)

layer = NestedModel(10)
layer(tf.ones(shape=(5,5)))
<tf.Tensor: shape=(5, 10), dtype=float32, numpy=
array([[5., 5., 5., 5., 5., 5., 5., 5., 5., 5.],
       [5., 5., 5., 5., 5., 5., 5., 5., 5., 5.],
       [5., 5., 5., 5., 5., 5., 5., 5., 5., 5.],
       [5., 5., 5., 5., 5., 5., 5., 5., 5., 5.],
       [5., 5., 5., 5., 5., 5., 5., 5., 5., 5.]], dtype=float32)>

এই পদ্ধতিটি নিশ্চিত করে যে এই নেস্টেড স্তরগুলি সঠিকভাবে পুনরায় ব্যবহার করা হয়েছে এবং টেনসরফ্লো দ্বারা ট্র্যাক করা হয়েছে। মনে রাখবেন যে @track_tf1_style_variables ডেকোরেটর এখনও উপযুক্ত পদ্ধতিতে প্রয়োজন। মডেল বিল্ডার পদ্ধতিটি get_or_create_layer এ পাস করা হয়েছে (এই ক্ষেত্রে, self.build_model ), কোন যুক্তি গ্রহণ করা উচিত নয়।

ওজন ট্র্যাক করা হয়:

assert len(layer.weights) == 2
weights = {x.name: x for x in layer.variables}

assert set(weights.keys()) == {"dense/bias:0", "dense/kernel:0"}

layer.weights
[<tf.Variable 'dense/kernel:0' shape=(5, 10) dtype=float32, numpy=
 array([[1., 1., 1., 1., 1., 1., 1., 1., 1., 1.],
        [1., 1., 1., 1., 1., 1., 1., 1., 1., 1.],
        [1., 1., 1., 1., 1., 1., 1., 1., 1., 1.],
        [1., 1., 1., 1., 1., 1., 1., 1., 1., 1.],
        [1., 1., 1., 1., 1., 1., 1., 1., 1., 1.]], dtype=float32)>,
 <tf.Variable 'dense/bias:0' shape=(10,) dtype=float32, numpy=array([0., 0., 0., 0., 0., 0., 0., 0., 0., 0.], dtype=float32)>]

এবং নিয়মিতকরণের ক্ষতিও:

tf.add_n(layer.losses)
<tf.Tensor: shape=(1,), dtype=float32, numpy=array([0.5], dtype=float32)>

ইনক্রিমেন্টাল মাইগ্রেশন: tf.Variables এবং tf.Modules

আপনি যদি আপনার সাজানো পদ্ধতিতে tf.Variable কল বা tf.Module s এম্বেড করতে চান (উদাহরণস্বরূপ, আপনি যদি এই গাইডে পরে বর্ণিত নন-লেগেসি TF2 API-তে ক্রমবর্ধমান স্থানান্তর অনুসরণ করেন), আপনাকে এখনও স্পষ্টভাবে এইগুলি ট্র্যাক করতে হবে, নিম্নলিখিত প্রয়োজনীয়তা সঙ্গে:

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

এটি নিশ্চিত করে যে ওজন প্রতিটি কল নতুন তৈরি করা হয়নি এবং সঠিকভাবে পুনরায় ব্যবহার করা হয়েছে। উপরন্তু, এটি নিশ্চিত করে যে বিদ্যমান ওজন এবং নিয়মিতকরণের ক্ষতি ট্র্যাক করা হয়।

এটি কীভাবে দেখতে পারে তার একটি উদাহরণ এখানে রয়েছে:

class NestedLayer(tf.keras.layers.Layer):

  def __init__(self, units, *args, **kwargs):
    super().__init__(*args, **kwargs)
    self.units = units

  @tf.compat.v1.keras.utils.track_tf1_style_variables
  def __call__(self, inputs):
    out = inputs
    with tf.compat.v1.variable_scope("inner_dense"):
      # The weights are created with a `regularizer`,
      # so the layer should track their regularization losses
      kernel = tf.compat.v1.get_variable(
          shape=[out.shape[-1], self.units],
          regularizer=tf.keras.regularizers.L2(),
          initializer=tf.compat.v1.initializers.glorot_normal,
          name="kernel")
      bias = tf.compat.v1.get_variable(
          shape=[self.units,],
          initializer=tf.compat.v1.initializers.zeros,
          name="bias")
      out = tf.linalg.matmul(out, kernel)
      out = tf.compat.v1.nn.bias_add(out, bias)
    return out

class WrappedDenseLayer(tf.keras.layers.Layer):

  def __init__(self, units, **kwargs):
    super().__init__(**kwargs)
    self.units = units
    # Only create the nested tf.variable/module/layer/model
    # once, and then reuse it each time!
    self._dense_layer = NestedLayer(self.units)

  @tf.compat.v1.keras.utils.track_tf1_style_variables
  def call(self, inputs):
    with tf.compat.v1.variable_scope('outer'):
      outputs = tf.compat.v1.layers.dense(inputs, 3)
      outputs = tf.compat.v1.layers.dense(inputs, 4)
      return self._dense_layer(outputs)

layer = WrappedDenseLayer(10)

layer(tf.ones(shape=(5, 5)))
/tmpfs/src/tf_docs_env/lib/python3.7/site-packages/ipykernel_launcher.py:38: UserWarning: `tf.layers.dense` is deprecated and will be removed in a future version. Please use `tf.keras.layers.Dense` instead.
/tmpfs/src/tf_docs_env/lib/python3.7/site-packages/ipykernel_launcher.py:39: UserWarning: `tf.layers.dense` is deprecated and will be removed in a future version. Please use `tf.keras.layers.Dense` instead.
<tf.Tensor: shape=(5, 10), dtype=float32, numpy=
array([[-0.4987283 ,  0.06630042, -0.09875254,  0.20954818,  0.03599668,
         0.3980474 ,  0.11181635,  0.6891558 , -0.33903462,  0.15674731],
       [-0.4987283 ,  0.06630042, -0.09875254,  0.20954818,  0.03599668,
         0.3980474 ,  0.11181635,  0.6891558 , -0.33903462,  0.15674731],
       [-0.4987283 ,  0.06630042, -0.09875254,  0.20954818,  0.03599668,
         0.3980474 ,  0.11181635,  0.6891558 , -0.33903462,  0.15674731],
       [-0.4987283 ,  0.06630042, -0.09875254,  0.20954818,  0.03599668,
         0.3980474 ,  0.11181635,  0.6891558 , -0.33903462,  0.15674731],
       [-0.4987283 ,  0.06630042, -0.09875254,  0.20954818,  0.03599668,
         0.3980474 ,  0.11181635,  0.6891558 , -0.33903462,  0.15674731]],
      dtype=float32)>

মনে রাখবেন যে নেস্টেড মডিউলটির সুস্পষ্ট ট্র্যাকিং প্রয়োজন যদিও এটি track_tf1_style_variables ডেকোরেটর দিয়ে সজ্জিত। এর কারণ হল সজ্জিত পদ্ধতি সহ প্রতিটি মডিউল/স্তর এর সাথে যুক্ত নিজস্ব পরিবর্তনশীল স্টোর রয়েছে।

ওজন সঠিকভাবে ট্র্যাক করা হয়:

assert len(layer.weights) == 6
weights = {x.name: x for x in layer.variables}

assert set(weights.keys()) == {"outer/inner_dense/bias:0",
                               "outer/inner_dense/kernel:0",
                               "outer/dense/bias:0",
                               "outer/dense/kernel:0",
                               "outer/dense_1/bias:0",
                               "outer/dense_1/kernel:0"}

layer.trainable_weights
[<tf.Variable 'outer/inner_dense/bias:0' shape=(10,) dtype=float32, numpy=array([0., 0., 0., 0., 0., 0., 0., 0., 0., 0.], dtype=float32)>,
 <tf.Variable 'outer/inner_dense/kernel:0' shape=(4, 10) dtype=float32, numpy=
 array([[-0.20786692,  0.14702448, -0.2577947 ,  0.1885891 ,  0.28935957,
          0.02086618, -0.20579144, -0.7509229 , -0.23490003,  0.00370591],
        [ 0.09247629, -0.37428686, -0.6002815 , -0.2702465 ,  0.20350575,
          0.34964404, -0.32633537,  0.50722903, -0.0419833 , -0.61815673],
        [ 0.24821116,  0.15504731, -0.12409697, -0.2506969 ,  0.22316858,
         -0.44847375, -0.08295754, -0.8262154 ,  0.7674222 , -0.40613693],
        [-0.7447006 ,  0.2992331 , -0.45639235,  0.0669547 ,  0.39443025,
          0.3182467 ,  0.10884362,  0.5395837 ,  0.32210502, -0.30076835]],
       dtype=float32)>,
 <tf.Variable 'outer/dense/bias:0' shape=(3,) dtype=float32, numpy=array([0., 0., 0.], dtype=float32)>,
 <tf.Variable 'outer/dense/kernel:0' shape=(5, 3) dtype=float32, numpy=
 array([[ 0.6283595 , -0.80413634, -0.5471641 ],
        [ 0.25296038, -0.7657203 ,  0.5884425 ],
        [-0.7180575 , -0.29509914,  0.44014376],
        [ 0.81024987,  0.39888996,  0.80002993],
        [-0.32921118, -0.7010279 ,  0.820375  ]], dtype=float32)>,
 <tf.Variable 'outer/dense_1/bias:0' shape=(4,) dtype=float32, numpy=array([0., 0., 0., 0.], dtype=float32)>,
 <tf.Variable 'outer/dense_1/kernel:0' shape=(5, 4) dtype=float32, numpy=
 array([[ 0.7941524 , -0.58552563,  0.46828055, -0.44095916],
        [-0.16019303,  0.27973688, -0.60373306, -0.20117629],
        [ 0.6345844 ,  0.30732214,  0.18921828,  0.37930095],
        [-0.50815696, -0.2471816 , -0.10282421,  0.21441567],
        [-0.71987414,  0.18304104, -0.5701992 ,  0.4926386 ]],
       dtype=float32)>]

পাশাপাশি নিয়মিতকরণের ক্ষতি:

layer.losses
[<tf.Tensor: shape=(), dtype=float32, numpy=0.058749676>]

মনে রাখবেন যে NestedLayer যদি পরিবর্তে একটি নন- tf.Module হয়, তাহলে ভেরিয়েবলগুলি এখনও ট্র্যাক করা হবে কিন্তু নিয়মিতকরণের ক্ষতিগুলি স্বয়ংক্রিয়ভাবে ট্র্যাক করা হবে না, তাই আপনাকে স্পষ্টভাবে সেগুলিকে আলাদাভাবে ট্র্যাক করতে হবে৷

পরিবর্তনশীল নাম নির্দেশিকা

স্পষ্ট tf.Variable কল এবং কেরাস স্তরগুলি একটি ভিন্ন স্তরের নাম / পরিবর্তনশীল নামের অটোজেনারেশন পদ্ধতি ব্যবহার করে যা আপনি get_variable এবং variable_scopes এর সংমিশ্রণ থেকে ব্যবহার করতে পারেন। যদিও শিম আপনার ভেরিয়েবলের নামগুলিকে get_variable দ্বারা তৈরি ভেরিয়েবলের সাথে মিলে যাবে এমনকি TF1.x গ্রাফ থেকে TF2 এজার এক্সিকিউশন এবং tf.function এ যাওয়ার সময়ও, এটি tf. ভ্যারিয়েবল কল এবং tf.Variable লেয়ারগুলির জন্য তৈরি ভেরিয়েবল নামের জন্য একই গ্যারান্টি দিতে পারে না আপনি আপনার পদ্ধতি ডেকোরেটর মধ্যে এম্বেড. এমনকি একাধিক ভেরিয়েবলের জন্য TF2 এজার এক্সিকিউশন এবং tf.function এ একই নাম শেয়ার করা সম্ভব।

এই নির্দেশিকাটিতে পরে সঠিকতা যাচাইকরণ এবং TF1.x চেকপয়েন্ট ম্যাপ করার বিভাগগুলি অনুসরণ করার সময় আপনার এটির সাথে বিশেষ যত্ন নেওয়া উচিত।

সজ্জিত পদ্ধতিতে tf.compat.v1.make_template ব্যবহার করা

tf.compat.v1.make_template ব্যবহার না করে সরাসরি tf.compat.v1.keras.utils.track_tf1_style_variables ব্যবহার করার পরামর্শ দেওয়া হচ্ছে, কারণ এটি TF2 এর উপরে একটি পাতলা স্তর

পূর্ববর্তী TF1.x কোডের জন্য এই বিভাগে নির্দেশিকা অনুসরণ করুন যা আগে থেকেই tf.compat.v1.make_template এর উপর নির্ভরশীল ছিল।

কারণ tf.compat.v1.make_template কোড যা get_variable ব্যবহার করে, track_tf1_style_variables ডেকোরেটর আপনাকে এই টেমপ্লেটগুলি লেয়ার কলে ব্যবহার করতে এবং ওজন এবং নিয়মিতকরণের ক্ষতি সফলভাবে ট্র্যাক করতে দেয়।

যাইহোক, নিশ্চিত করুন যে make_template শুধুমাত্র একবার কল করুন এবং তারপর প্রতিটি লেয়ার কলে একই টেমপ্লেট পুনরায় ব্যবহার করুন। অন্যথায়, আপনি প্রতিবার লেয়ারটিকে কল করার সময় একটি নতুন টেমপ্লেট তৈরি করা হবে এবং একটি নতুন সেট ভেরিয়েবল সহ।

উদাহরণ স্বরূপ,

class CompatV1TemplateScaleByY(tf.keras.layers.Layer):

  def __init__(self, **kwargs):
    super().__init__(**kwargs)
    def my_op(x, scalar_name):
      var1 = tf.compat.v1.get_variable(scalar_name,
                            shape=[],
                            regularizer=tf.compat.v1.keras.regularizers.L2(),
                            initializer=tf.compat.v1.constant_initializer(1.5))
      return x * var1
    self.scale_by_y = tf.compat.v1.make_template('scale_by_y', my_op, scalar_name='y')

  @tf.compat.v1.keras.utils.track_tf1_style_variables
  def call(self, inputs):
    with tf.compat.v1.variable_scope('layer'):
      # Using a scope ensures the `scale_by_y` name will not be incremented
      # for each instantiation of the layer.
      return self.scale_by_y(inputs)

layer = CompatV1TemplateScaleByY()

out = layer(tf.ones(shape=(2, 3)))
print("weights:", layer.weights)
print("regularization loss:", layer.losses)
print("output:", out)
weights: [<tf.Variable 'layer/scale_by_y/y:0' shape=() dtype=float32, numpy=1.5>]
regularization loss: [<tf.Tensor: shape=(), dtype=float32, numpy=0.022499999>]
output: tf.Tensor(
[[1.5 1.5 1.5]
 [1.5 1.5 1.5]], shape=(2, 3), dtype=float32)

নেটিভ TF2 তে ক্রমবর্ধমান স্থানান্তর

আগেই উল্লেখ করা হয়েছে, track_tf1_style_variables আপনাকে TF2-শৈলী অবজেক্ট-ভিত্তিক tf.Variable / tf.keras.layers.Layer / tf.Module ব্যবহারকে লিগ্যাসি tf.compat.v1.get_variable / tf.compat.v1.layers -style মিশ্রিত করতে দেয়। একই সজ্জিত মডিউল/স্তরের ভিতরে ব্যবহার।

এর মানে হল যে আপনি আপনার TF1.x মডেলটিকে সম্পূর্ণ-TF2-সামঞ্জস্যপূর্ণ করার পরে, আপনি নেটিভ (non- tf.compat.v1 ) TF2 এপিআইগুলির সাথে সমস্ত নতুন মডেলের উপাদান লিখতে পারেন এবং তাদের আপনার পুরানো কোডের সাথে ইন্টারঅপারেটিং করতে পারেন৷

যাইহোক, আপনি যদি আপনার পুরানো মডেলের উপাদানগুলিকে পরিবর্তন করতে থাকেন, তাহলে আপনি আপনার উত্তরাধিকার-শৈলী tf.compat.v1 ব্যবহারকে ক্রমবর্ধমানভাবে স্যুইচ করতে বেছে নিতে পারেন বিশুদ্ধ-নেটিভ অবজেক্ট-ওরিয়েন্টেড API-এ যা নতুন লিখিত TF2 কোডের জন্য সুপারিশ করা হয়।

tf.compat.v1.get_variable ব্যবহারকে হয় self.add_weight কল দিয়ে প্রতিস্থাপন করা যেতে পারে যদি আপনি কেরাস লেয়ার/মডেল সাজিয়ে থাকেন, অথবা tf.Variable কল দিয়ে যদি আপনি Keras অবজেক্ট বা tf.Module s সাজিয়ে থাকেন।

ফাংশনাল-স্টাইল এবং অবজেক্ট-ওরিয়েন্টেড tf.compat.v1.layers সাধারণত সমতুল্য tf.keras.layers লেয়ার দিয়ে প্রতিস্থাপিত হতে পারে যার কোনো যুক্তি পরিবর্তনের প্রয়োজন নেই।

বিশুদ্ধ-নেটিভ এপিআই-এ আপনার ক্রমবর্ধমান স্থানান্তরের সময় আপনি আপনার মডেলের অংশগুলি বা সাধারণ প্যাটার্নগুলিকে পৃথক স্তর/মডিউলগুলিতে বিবেচনা করতে পারেন, যা নিজেরাই track_tf1_style_variables ব্যবহার করতে পারে।

স্লিম এবং contrib.layers এর উপর একটি নোট

প্রচুর পরিমাণে পুরানো TF 1.x কোড স্লিম লাইব্রেরি ব্যবহার করে, যা tf.contrib.layers হিসাবে TF 1.x দিয়ে প্যাকেজ করা হয়েছিল। স্লিম ব্যবহার করে কোডকে নেটিভ TF 2-এ রূপান্তর v1.layers রূপান্তরের চেয়ে বেশি জড়িত। প্রকৃতপক্ষে, আপনার স্লিম কোডকে প্রথমে v1.layers রূপান্তর করা, তারপর Keras-এ রূপান্তর করা বোধগম্য হতে পারে। নীচে স্লিম কোড রূপান্তর করার জন্য কিছু সাধারণ নির্দেশিকা রয়েছে।

  • নিশ্চিত করুন যে সমস্ত যুক্তি স্পষ্ট। সম্ভব হলে arg_scopes সরান। আপনার যদি এখনও সেগুলি ব্যবহার করার প্রয়োজন হয়, normalizer_fn এবং activation_fn তাদের নিজস্ব স্তরগুলিতে বিভক্ত করুন।
  • বিভাজ্য রূপান্তর স্তরগুলি এক বা একাধিক ভিন্ন কেরা স্তরে মানচিত্র করে (গভীরভাবে, পয়েন্টওয়াইজ, এবং বিভাজ্য কেরাস স্তর)।
  • Slim এবং v1.layers এর বিভিন্ন আর্গুমেন্টের নাম এবং ডিফল্ট মান আছে।
  • মনে রাখবেন কিছু আর্গুমেন্টের বিভিন্ন স্কেল আছে।

চেকপয়েন্ট সামঞ্জস্য উপেক্ষা করে নেটিভ TF2-এ স্থানান্তর

নিম্নলিখিত কোড নমুনা চেকপয়েন্ট সামঞ্জস্য বিবেচনা না করে বিশুদ্ধ-নেটিভ API-এ একটি মডেলের ক্রমবর্ধমান পদক্ষেপ প্রদর্শন করে।

class CompatModel(tf.keras.layers.Layer):

  def __init__(self, units, *args, **kwargs):
    super().__init__(*args, **kwargs)
    self.units = units

  @tf.compat.v1.keras.utils.track_tf1_style_variables
  def call(self, inputs, training=None):
    with tf.compat.v1.variable_scope('model'):
      out = tf.compat.v1.layers.conv2d(
          inputs, 3, 3,
          kernel_regularizer="l2")
      out = tf.compat.v1.layers.flatten(out)
      out = tf.compat.v1.layers.dropout(out, training=training)
      out = tf.compat.v1.layers.dense(
          out, self.units,
          kernel_regularizer="l2")
      return out

এরপর, compat.v1 এপিআইগুলিকে তাদের নেটিভ অবজেক্ট-ওরিয়েন্টেড সমতুল্য দিয়ে টুকরো টুকরো পদ্ধতিতে প্রতিস্থাপন করুন। লেয়ার কনস্ট্রাক্টরে তৈরি কেরাস অবজেক্টে কনভোলিউশন লেয়ার স্যুইচ করে শুরু করুন।

class PartiallyMigratedModel(tf.keras.layers.Layer):

  def __init__(self, units, *args, **kwargs):
    super().__init__(*args, **kwargs)
    self.units = units
    self.conv_layer = tf.keras.layers.Conv2D(
      3, 3,
      kernel_regularizer="l2")

  @tf.compat.v1.keras.utils.track_tf1_style_variables
  def call(self, inputs, training=None):
    with tf.compat.v1.variable_scope('model'):
      out = self.conv_layer(inputs)
      out = tf.compat.v1.layers.flatten(out)
      out = tf.compat.v1.layers.dropout(out, training=training)
      out = tf.compat.v1.layers.dense(
          out, self.units,
          kernel_regularizer="l2")
      return out

v1.keras.utils.DeterministicRandomTestTool ক্লাসটি যাচাই করতে ব্যবহার করুন যে এই ক্রমবর্ধমান পরিবর্তন মডেলটিকে আগের মতো একই আচরণের সাথে ছেড়ে দেয়।

random_tool = v1.keras.utils.DeterministicRandomTestTool(mode='num_random_ops')
with random_tool.scope():
  layer = CompatModel(10)

  inputs = tf.random.normal(shape=(10, 5, 5, 5))
  original_output = layer(inputs)

  # Grab the regularization loss as well
  original_regularization_loss = tf.math.add_n(layer.losses)

print(original_regularization_loss)
tf.Tensor(0.17953834, shape=(), dtype=float32)
/tmpfs/src/tf_docs_env/lib/python3.7/site-packages/ipykernel_launcher.py:12: UserWarning: `tf.layers.conv2d` is deprecated and will be removed in a future version. Please Use `tf.keras.layers.Conv2D` instead.
  if sys.path[0] == '':
/tmpfs/src/tf_docs_env/lib/python3.7/site-packages/ipykernel_launcher.py:13: UserWarning: `tf.layers.flatten` is deprecated and will be removed in a future version. Please use `tf.keras.layers.Flatten` instead.
  del sys.path[0]
/tmpfs/src/tf_docs_env/lib/python3.7/site-packages/ipykernel_launcher.py:14: UserWarning: `tf.layers.dropout` is deprecated and will be removed in a future version. Please use `tf.keras.layers.Dropout` instead.
  
/tmpfs/src/tf_docs_env/lib/python3.7/site-packages/keras/legacy_tf_layers/core.py:413: UserWarning: `layer.apply` is deprecated and will be removed in a future version. Please use `layer.__call__` method instead.
  return layer.apply(inputs, training=training)
/tmpfs/src/tf_docs_env/lib/python3.7/site-packages/ipykernel_launcher.py:17: UserWarning: `tf.layers.dense` is deprecated and will be removed in a future version. Please use `tf.keras.layers.Dense` instead.
random_tool = v1.keras.utils.DeterministicRandomTestTool(mode='num_random_ops')
with random_tool.scope():
  layer = PartiallyMigratedModel(10)

  inputs = tf.random.normal(shape=(10, 5, 5, 5))
  migrated_output = layer(inputs)

  # Grab the regularization loss as well
  migrated_regularization_loss = tf.math.add_n(layer.losses)

print(migrated_regularization_loss)
tf.Tensor(0.17953834, shape=(), dtype=float32)
/tmpfs/src/tf_docs_env/lib/python3.7/site-packages/ipykernel_launcher.py:14: UserWarning: `tf.layers.flatten` is deprecated and will be removed in a future version. Please use `tf.keras.layers.Flatten` instead.
  
/tmpfs/src/tf_docs_env/lib/python3.7/site-packages/ipykernel_launcher.py:15: UserWarning: `tf.layers.dropout` is deprecated and will be removed in a future version. Please use `tf.keras.layers.Dropout` instead.
  from ipykernel import kernelapp as app
/tmpfs/src/tf_docs_env/lib/python3.7/site-packages/ipykernel_launcher.py:18: UserWarning: `tf.layers.dense` is deprecated and will be removed in a future version. Please use `tf.keras.layers.Dense` instead.
# Verify that the regularization loss and output both match
np.testing.assert_allclose(original_regularization_loss.numpy(), migrated_regularization_loss.numpy())
np.testing.assert_allclose(original_output.numpy(), migrated_output.numpy())

আপনি এখন সমস্ত পৃথক compat.v1.layers কে নেটিভ কেরাস স্তর দিয়ে প্রতিস্থাপন করেছেন।

class NearlyFullyNativeModel(tf.keras.layers.Layer):

  def __init__(self, units, *args, **kwargs):
    super().__init__(*args, **kwargs)
    self.units = units
    self.conv_layer = tf.keras.layers.Conv2D(
      3, 3,
      kernel_regularizer="l2")
    self.flatten_layer = tf.keras.layers.Flatten()
    self.dense_layer = tf.keras.layers.Dense(
      self.units,
      kernel_regularizer="l2")

  @tf.compat.v1.keras.utils.track_tf1_style_variables
  def call(self, inputs):
    with tf.compat.v1.variable_scope('model'):
      out = self.conv_layer(inputs)
      out = self.flatten_layer(out)
      out = self.dense_layer(out)
      return out
random_tool = v1.keras.utils.DeterministicRandomTestTool(mode='num_random_ops')
with random_tool.scope():
  layer = NearlyFullyNativeModel(10)

  inputs = tf.random.normal(shape=(10, 5, 5, 5))
  migrated_output = layer(inputs)

  # Grab the regularization loss as well
  migrated_regularization_loss = tf.math.add_n(layer.losses)

print(migrated_regularization_loss)
tf.Tensor(0.17953834, shape=(), dtype=float32)
# Verify that the regularization loss and output both match
np.testing.assert_allclose(original_regularization_loss.numpy(), migrated_regularization_loss.numpy())
np.testing.assert_allclose(original_output.numpy(), migrated_output.numpy())

অবশেষে, যেকোন অবশিষ্ট (আর প্রয়োজন নেই) variable_scope ব্যবহার এবং track_tf1_style_variables ডেকোরেটর উভয়ই সরিয়ে ফেলুন।

আপনার কাছে এখন মডেলটির একটি সংস্করণ বাকি রয়েছে যা সম্পূর্ণরূপে নেটিভ API ব্যবহার করে৷

class FullyNativeModel(tf.keras.layers.Layer):

  def __init__(self, units, *args, **kwargs):
    super().__init__(*args, **kwargs)
    self.units = units
    self.conv_layer = tf.keras.layers.Conv2D(
      3, 3,
      kernel_regularizer="l2")
    self.flatten_layer = tf.keras.layers.Flatten()
    self.dense_layer = tf.keras.layers.Dense(
      self.units,
      kernel_regularizer="l2")

  def call(self, inputs):
    out = self.conv_layer(inputs)
    out = self.flatten_layer(out)
    out = self.dense_layer(out)
    return out
random_tool = v1.keras.utils.DeterministicRandomTestTool(mode='num_random_ops')
with random_tool.scope():
  layer = FullyNativeModel(10)

  inputs = tf.random.normal(shape=(10, 5, 5, 5))
  migrated_output = layer(inputs)

  # Grab the regularization loss as well
  migrated_regularization_loss = tf.math.add_n(layer.losses)

print(migrated_regularization_loss)
tf.Tensor(0.17953834, shape=(), dtype=float32)
# Verify that the regularization loss and output both match
np.testing.assert_allclose(original_regularization_loss.numpy(), migrated_regularization_loss.numpy())
np.testing.assert_allclose(original_output.numpy(), migrated_output.numpy())

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

নেটিভ TF2 API-তে উপরোক্ত স্থানান্তর প্রক্রিয়া পরিবর্তনশীল নাম (যেহেতু কেরাস এপিআইগুলি খুব ভিন্ন ওজনের নাম তৈরি করে) এবং অবজেক্ট-ভিত্তিক পাথ যা মডেলের বিভিন্ন ওজনের দিকে নির্দেশ করে উভয়ই পরিবর্তন করেছে। এই পরিবর্তনগুলির প্রভাব হল যে তারা বিদ্যমান TF1-শৈলীর নাম-ভিত্তিক চেকপয়েন্ট বা TF2-স্টাইল অবজেক্ট-ভিত্তিক চেকপয়েন্ট উভয়ই ভেঙে ফেলবে।

যাইহোক, কিছু ক্ষেত্রে, আপনি আপনার আসল নাম-ভিত্তিক চেকপয়েন্ট নিতে সক্ষম হতে পারেন এবং TF1.x চেকপয়েন্ট পুনঃব্যবহারের নির্দেশিকাতে বিশদ বিবরণের মতো পদ্ধতির সাথে তাদের নতুন নামের সাথে ভেরিয়েবলের একটি ম্যাপিং খুঁজে পেতে পারেন।

এটিকে কার্যকর করার জন্য কিছু টিপস নিম্নরূপ:

  • ভেরিয়েবলের এখনও একটি name যুক্তি আছে যা আপনি সেট করতে পারেন।
  • কেরাস মডেলগুলি একটি name যুক্তিও নেয় যা তারা তাদের ভেরিয়েবলের উপসর্গ হিসাবে সেট করে।
  • v1.name_scope ফাংশন পরিবর্তনশীল নামের উপসর্গ সেট করতে ব্যবহার করা যেতে পারে। এটি tf.variable_scope থেকে খুব আলাদা। এটি শুধুমাত্র নামগুলিকে প্রভাবিত করে এবং ভেরিয়েবল এবং পুনরায় ব্যবহার ট্র্যাক করে না।

উপরের পয়েন্টারগুলি মাথায় রেখে, নিম্নলিখিত কোড নমুনাগুলি এমন একটি ওয়ার্কফ্লো প্রদর্শন করে যা আপনি একই সাথে চেকপয়েন্ট আপডেট করার সময় একটি মডেলের অংশ ক্রমবর্ধমানভাবে আপডেট করতে আপনার কোডের সাথে মানিয়ে নিতে পারেন।

  1. ফাংশনাল-স্টাইল tf.compat.v1.layers কে তাদের অবজেক্ট-ওরিয়েন্টেড সংস্করণে স্যুইচ করে শুরু করুন।
class FunctionalStyleCompatModel(tf.keras.layers.Layer):

  @tf.compat.v1.keras.utils.track_tf1_style_variables
  def call(self, inputs, training=None):
    with tf.compat.v1.variable_scope('model'):
      out = tf.compat.v1.layers.conv2d(
          inputs, 3, 3,
          kernel_regularizer="l2")
      out = tf.compat.v1.layers.conv2d(
          out, 4, 4,
          kernel_regularizer="l2")
      out = tf.compat.v1.layers.conv2d(
          out, 5, 5,
          kernel_regularizer="l2")
      return out

layer = FunctionalStyleCompatModel()
layer(tf.ones(shape=(10, 10, 10, 10)))
[v.name for v in layer.weights]
/tmpfs/src/tf_docs_env/lib/python3.7/site-packages/ipykernel_launcher.py:8: UserWarning: `tf.layers.conv2d` is deprecated and will be removed in a future version. Please Use `tf.keras.layers.Conv2D` instead.
  
/tmpfs/src/tf_docs_env/lib/python3.7/site-packages/ipykernel_launcher.py:11: UserWarning: `tf.layers.conv2d` is deprecated and will be removed in a future version. Please Use `tf.keras.layers.Conv2D` instead.
  # This is added back by InteractiveShellApp.init_path()
/tmpfs/src/tf_docs_env/lib/python3.7/site-packages/ipykernel_launcher.py:14: UserWarning: `tf.layers.conv2d` is deprecated and will be removed in a future version. Please Use `tf.keras.layers.Conv2D` instead.
['model/conv2d/bias:0',
 'model/conv2d/kernel:0',
 'model/conv2d_1/bias:0',
 'model/conv2d_1/kernel:0',
 'model/conv2d_2/bias:0',
 'model/conv2d_2/kernel:0']
  1. এর পরে, compat.v1.layer অবজেক্ট এবং compat.v1.get_variable দ্বারা তৈরি যেকোন ভেরিয়েবলকে tf.keras.layers.Layer / tf.Module অবজেক্টের বৈশিষ্ট্য হিসাবে বরাদ্দ করুন যার পদ্ধতিটি track_tf1_style_variables দিয়ে সজ্জিত (উল্লেখ্য যে যেকোন অবজেক্ট-ভিত্তিক TF2 স্টাইল চেকপয়েন্ট এখন পরিবর্তনশীল নাম এবং নতুন অবজেক্ট-ওরিয়েন্টেড পাথ উভয়ই সংরক্ষণ করবে)।
class OOStyleCompatModel(tf.keras.layers.Layer):

  def __init__(self, *args, **kwargs):
    super().__init__(*args, **kwargs)
    self.conv_1 = tf.compat.v1.layers.Conv2D(
          3, 3,
          kernel_regularizer="l2")
    self.conv_2 = tf.compat.v1.layers.Conv2D(
          4, 4,
          kernel_regularizer="l2")

  @tf.compat.v1.keras.utils.track_tf1_style_variables
  def call(self, inputs, training=None):
    with tf.compat.v1.variable_scope('model'):
      out = self.conv_1(inputs)
      out = self.conv_2(out)
      out = tf.compat.v1.layers.conv2d(
          out, 5, 5,
          kernel_regularizer="l2")
      return out

layer = OOStyleCompatModel()
layer(tf.ones(shape=(10, 10, 10, 10)))
[v.name for v in layer.weights]
/tmpfs/src/tf_docs_env/lib/python3.7/site-packages/ipykernel_launcher.py:19: UserWarning: `tf.layers.conv2d` is deprecated and will be removed in a future version. Please Use `tf.keras.layers.Conv2D` instead.
['model/conv2d/kernel:0',
 'model/conv2d/bias:0',
 'model/conv2d_1/kernel:0',
 'model/conv2d_1/bias:0',
 'model/conv2d_2/bias:0',
 'model/conv2d_2/kernel:0']
  1. পরিবর্তনশীল নাম (compat.v1.layers-এর জন্য), অথবা অবজেক্ট-ওরিয়েন্টেড অবজেক্ট গ্রাফ দ্বারা উভয় পাথ সংরক্ষণ করতে এই পয়েন্টে একটি লোড করা চেকপয়েন্ট পুনরায় সংরক্ষণ করুন।
weights = {v.name: v for v in layer.weights}
assert weights['model/conv2d/kernel:0'] is layer.conv_1.kernel
assert weights['model/conv2d_1/bias:0'] is layer.conv_2.bias
  1. আপনি এখন অবজেক্ট-ওরিয়েন্টেড compat.v1.layers নেটিভ কেরাস স্তরগুলির জন্য অদলবদল করতে পারেন যখন এখনও সম্প্রতি-সংরক্ষিত চেকপয়েন্ট লোড করতে সক্ষম হন। প্রতিস্থাপিত স্তরগুলির স্বয়ংক্রিয়-উত্পন্ন variable_scopes রেকর্ড করে আপনি অবশিষ্ট compat.v1.layers এর জন্য পরিবর্তনশীল নামগুলি সংরক্ষণ করেছেন তা নিশ্চিত করুন৷ এই সুইচ করা স্তর/ভেরিয়েবলগুলি এখন পরিবর্তনশীল নামের পাথের পরিবর্তে চেকপয়েন্টে ভেরিয়েবলের জন্য অবজেক্ট অ্যাট্রিবিউট পাথ ব্যবহার করবে।

সাধারণভাবে, আপনি বৈশিষ্ট্যের সাথে সংযুক্ত ভেরিয়েবলে compat.v1.get_variable এর ব্যবহার প্রতিস্থাপন করতে পারেন:

  • tf.Variable , OR ব্যবহার করে তাদের স্যুইচ করা হচ্ছে
  • tf.keras.layers.Layer.add_weight ব্যবহার করে তাদের আপডেট করা হচ্ছে। মনে রাখবেন যে আপনি যদি সমস্ত স্তরগুলিকে একযোগে স্যুইচ না করেন তবে এটি অবশিষ্ট compat.v1.layers জন্য স্বয়ংক্রিয়-উত্পন্ন স্তর/ভেরিয়েবল নামকরণ পরিবর্তন করতে পারে যেগুলির name যুক্তি নেই৷ যদি তাই হয়, তাহলে আপনাকে অবশ্যই অবশিষ্ট compat.v1.layers এর জন্য পরিবর্তনশীল নামগুলিকে ম্যানুয়ালি খোলা এবং বন্ধ করে একটি variable_scope সরিয়ে compat.v1.layer এর জেনারেট করা স্কোপের নামের সাথে একই রাখতে হবে। অন্যথায় বিদ্যমান চেকপয়েন্ট থেকে পাথ বিবাদ হতে পারে এবং চেকপয়েন্ট লোডিং ভুল আচরণ করবে।
def record_scope(scope_name):
  """Record a variable_scope to make sure future ones get incremented."""
  with tf.compat.v1.variable_scope(scope_name):
    pass

class PartiallyNativeKerasLayersModel(tf.keras.layers.Layer):

  def __init__(self, *args, **kwargs):
    super().__init__(*args, **kwargs)
    self.conv_1 = tf.keras.layers.Conv2D(
          3, 3,
          kernel_regularizer="l2")
    self.conv_2 = tf.keras.layers.Conv2D(
          4, 4,
          kernel_regularizer="l2")

  @tf.compat.v1.keras.utils.track_tf1_style_variables
  def call(self, inputs, training=None):
    with tf.compat.v1.variable_scope('model'):
      out = self.conv_1(inputs)
      record_scope('conv2d') # Only needed if follow-on compat.v1.layers do not pass a `name` arg
      out = self.conv_2(out)
      record_scope('conv2d_1') # Only needed if follow-on compat.v1.layers do not pass a `name` arg
      out = tf.compat.v1.layers.conv2d(
          out, 5, 5,
          kernel_regularizer="l2")
      return out

layer = PartiallyNativeKerasLayersModel()
layer(tf.ones(shape=(10, 10, 10, 10)))
[v.name for v in layer.weights]
/tmpfs/src/tf_docs_env/lib/python3.7/site-packages/ipykernel_launcher.py:26: UserWarning: `tf.layers.conv2d` is deprecated and will be removed in a future version. Please Use `tf.keras.layers.Conv2D` instead.
['partially_native_keras_layers_model/model/conv2d_13/kernel:0',
 'partially_native_keras_layers_model/model/conv2d_13/bias:0',
 'partially_native_keras_layers_model/model/conv2d_14/kernel:0',
 'partially_native_keras_layers_model/model/conv2d_14/bias:0',
 'model/conv2d_2/bias:0',
 'model/conv2d_2/kernel:0']

ভেরিয়েবলগুলি তৈরি করার পরে এই ধাপে একটি চেকপয়েন্ট সংরক্ষণ করা হলে এটি শুধুমাত্র বর্তমানে উপলব্ধ অবজেক্ট পাথগুলিকে ধারণ করবে।

অবশিষ্ট compat.v1.layers এর জন্য স্বয়ংক্রিয়ভাবে তৈরি হওয়া ওজনের নামগুলি সংরক্ষণ করতে আপনি সরানো compat.v1.layers এর স্কোপ রেকর্ড করেছেন তা নিশ্চিত করুন।

weights = set(v.name for v in layer.weights)
assert 'model/conv2d_2/kernel:0' in weights
assert 'model/conv2d_2/bias:0' in weights
  1. উপরের ধাপগুলি পুনরাবৃত্তি করুন যতক্ষণ না আপনি আপনার মডেলের সমস্ত compat.v1.layers এবং compat.v1.get_variable s সম্পূর্ণ-নেটিভ সমতুল্য দিয়ে প্রতিস্থাপন করছেন।
class FullyNativeKerasLayersModel(tf.keras.layers.Layer):

  def __init__(self, *args, **kwargs):
    super().__init__(*args, **kwargs)
    self.conv_1 = tf.keras.layers.Conv2D(
          3, 3,
          kernel_regularizer="l2")
    self.conv_2 = tf.keras.layers.Conv2D(
          4, 4,
          kernel_regularizer="l2")
    self.conv_3 = tf.keras.layers.Conv2D(
          5, 5,
          kernel_regularizer="l2")


  def call(self, inputs, training=None):
    with tf.compat.v1.variable_scope('model'):
      out = self.conv_1(inputs)
      out = self.conv_2(out)
      out = self.conv_3(out)
      return out

layer = FullyNativeKerasLayersModel()
layer(tf.ones(shape=(10, 10, 10, 10)))
[v.name for v in layer.weights]
['fully_native_keras_layers_model/model/conv2d_16/kernel:0',
 'fully_native_keras_layers_model/model/conv2d_16/bias:0',
 'fully_native_keras_layers_model/model/conv2d_17/kernel:0',
 'fully_native_keras_layers_model/model/conv2d_17/bias:0',
 'fully_native_keras_layers_model/model/conv2d_18/kernel:0',
 'fully_native_keras_layers_model/model/conv2d_18/bias:0']

নতুন আপডেট করা চেকপয়েন্ট এখনও আপনার প্রত্যাশা অনুযায়ী আচরণ করে তা নিশ্চিত করতে পরীক্ষা করতে ভুলবেন না। আপনার স্থানান্তরিত কোড সঠিকভাবে চলছে তা নিশ্চিত করতে এই প্রক্রিয়ার প্রতিটি ক্রমবর্ধমান ধাপে বৈধতা সংখ্যাসূচক সঠিকতা নির্দেশিকাতে বর্ণিত কৌশলগুলি প্রয়োগ করুন।

TF1.x থেকে TF2 আচরণ পরিবর্তন পরিচালনা করা মডেলিং শিমস দ্বারা আচ্ছাদিত নয়

এই নির্দেশিকায় বর্ণিত মডেলিং শিমগুলি নিশ্চিত করতে পারে যে get_variable , tf.compat.v1.layers , এবং variable_scope শব্দার্থবিদ্যার সাহায্যে তৈরি ভেরিয়েবল, স্তর এবং নিয়মিতকরণের ক্ষয়ক্ষতি আগের মতোই কাজ করা চালিয়ে যেতে পারে যখন উদগ্রীব নির্বাহ এবং tf.function ব্যবহার করে সংগ্রহের উপর নির্ভর করুন।

এটি সমস্ত TF1.x-নির্দিষ্ট শব্দার্থকে কভার করে না যেগুলির উপর আপনার মডেল ফরওয়ার্ড পাসগুলি নির্ভর করতে পারে৷ কিছু কিছু ক্ষেত্রে, আপনার মডেল ফরওয়ার্ড পাস টিএফ২-এ নিজে থেকে চালানোর জন্য শিমগুলি অপর্যাপ্ত হতে পারে। TF1.x এবং TF2 এর মধ্যে আচরণগত পার্থক্য সম্পর্কে আরও জানতে TF1.x বনাম TF2 আচরণ নির্দেশিকা পড়ুন।