तिथि को रक्षित करें! Google I / O 18-20 मई को पंजीकृत करता है
इस पेज का अनुवाद Cloud Translation API से किया गया है.
Switch to English

अपने TensorFlow 1 कोड को TensorFlow 2 में माइग्रेट करें

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

यह मार्गदर्शिका निम्न-स्तरीय TensorFlow API के उपयोगकर्ताओं के लिए है। यदि आप उच्च-स्तरीय APIs ( tf.keras ) का उपयोग कर रहे हैं, तो आपके कोड को पूरी तरह से TensorFlow 2.x संगत बनाने के लिए आपको बहुत कम या कोई भी कार्रवाई करने की आवश्यकता नहीं हो सकती है:

TensorFlow 2.x में 1.x कोड, अनमॉडिफाइड (कंट्री को छोड़कर ) चलाना अभी भी संभव है:

import tensorflow.compat.v1 as tf
tf.disable_v2_behavior()

हालाँकि, यह आपको TensorFlow 2.x में किए गए कई सुधारों का लाभ नहीं उठाने देता। यह मार्गदर्शिका आपको अपना कोड अपग्रेड करने में मदद करेगी, जिससे यह सरल, अधिक निष्पादक और बनाए रखने में आसान होगा।

स्वचालित रूपांतरण स्क्रिप्ट

इस गाइड में वर्णित परिवर्तनों को लागू करने का प्रयास करने से पहले पहला कदम, अपग्रेड स्क्रिप्ट को चलाने का प्रयास करना है।

यह आपके कोड को TensorFlow 2.x में अपग्रेड करने पर एक प्रारंभिक पास निष्पादित करेगा लेकिन यह आपके कोड को v2 के लिए मुहावरेदार नहीं बना सकता है। आपका कोड अभी भी प्लेसहोल्डर, सत्र, संग्रह और अन्य tf.compat.v1 शैली की कार्यक्षमता तक पहुंचने के लिए tf.compat.v1 समापन बिंदु का उपयोग कर सकता है।

शीर्ष-स्तरीय व्यवहार परिवर्तन

यदि TensorFlow में अपने कोड का उपयोग कर काम करता है 2.x tf.compat.v1.disable_v2_behavior , वहां अभी भी वैश्विक व्यवहार में परिवर्तन आप पता करना पड़ सकता है कर रहे हैं। प्रमुख परिवर्तन हैं:

  • उत्सुक निष्पादन, v1.enable_eager_execution() : कोई भी कोड जो स्पष्ट रूप से tf.Graph का उपयोग करता है वह विफल हो जाएगा। इस कोड with tf.Graph().as_default() संदर्भ के with tf.Graph().as_default() सुनिश्चित करें।

  • संसाधन चर, v1.enable_resource_variables() : कुछ कोड TensorFlow संदर्भ चर द्वारा सक्षम गैर-निर्धारक व्यवहारों पर निर्भर हो सकते हैं। संसाधन चर को लिखे जाने के दौरान लॉक किया जाता है, और इसलिए अधिक सहज स्थिरता गारंटी प्रदान करता है।

    • यह किनारे के मामलों में व्यवहार को बदल सकता है।
    • यह अतिरिक्त प्रतियां बना सकता है और उच्चतर मेमोरी उपयोग कर सकता है।
    • इस का उपयोग कर निष्क्रिय किया जा सकता है use_resource=False tf.Variable कंस्ट्रक्टर को use_resource=False
  • Tensor शेप्स, v1.enable_v2_tensorshape() : TensorFlow 2.x टेंसर आकृतियों के व्यवहार को सरल करता है। इसके बजाय t.shape[0].value आप कह सकते हैं t.shape[0] । ये परिवर्तन छोटे होने चाहिए, और यह उन्हें ठीक करने के लिए समझ में आता है। उदाहरण के लिए TensorShape अनुभाग देखें।

  • नियंत्रण प्रवाह, v1.enable_control_flow_v2() : TensorFlow 2.x नियंत्रण प्रवाह कार्यान्वयन को सरल बनाया गया है, और इसलिए विभिन्न ग्राफ अभ्यावेदन का उत्पादन करता है। कृपया किसी भी समस्या के लिए बग दर्ज करें।

TensorFlow 2.x के लिए कोड बनाएँ

यह गाइड TensorFlow 1.x कोड को TensorFlow 2.x में परिवर्तित करने के कई उदाहरणों से गुजरेगा। ये परिवर्तन आपके कोड को प्रदर्शन अनुकूलन और सरलीकृत API कॉल का लाभ उठाने देंगे।

प्रत्येक मामले में, पैटर्न है:

1. बदलें v1.Session.run कॉल

प्रत्येक v1.Session.run कॉल को पायथन फ़ंक्शन द्वारा प्रतिस्थापित किया जाना चाहिए।

  • feed_dict और v1.placeholder फ़ंक्शन तर्क बन जाते हैं।
  • fetches फ़ंक्शन का रिटर्न मान बन जाता है।
  • रूपांतरण के दौरान उत्सुक निष्पादन मानक पायथन टूल्स जैसे pdb साथ आसान डिबगिंग की अनुमति देता है।

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

ध्यान दें कि:

  • v1.Session.run विपरीत, एक tf.function में एक निश्चित रिटर्न हस्ताक्षर है और हमेशा सभी आउटपुट देता है। यदि यह प्रदर्शन समस्याओं का कारण बनता है, तो दो अलग-अलग कार्य बनाएं।

  • tf.control_dependencies या इसी तरह के संचालन के लिए कोई आवश्यकता नहीं है: एक tf.function व्यवहार करता है जैसे कि यह लिखित आदेश में चलाया गया था। tf.Variable कार्य और tf.assert s, उदाहरण के लिए, स्वचालित रूप से निष्पादित होते हैं।

परिवर्तित मॉडल अनुभाग में इस रूपांतरण प्रक्रिया का एक कार्यशील उदाहरण है।

2. चर और नुकसान को ट्रैक करने के लिए पायथन वस्तुओं का उपयोग करें

सभी नाम-आधारित वैरिएबल ट्रैकिंग TensorFlow 2.x में दृढ़ता से हतोत्साहित है। चर ट्रैक करने के लिए पायथन ऑब्जेक्ट्स का उपयोग करें।

उपयोग tf.Variable के बजाय v1.get_variable

प्रत्येक v1.variable_scope को पायथन ऑब्जेक्ट में परिवर्तित किया जाना चाहिए। आमतौर पर यह निम्नलिखित में से एक होगा:

यदि आपको चर की सूचियों (जैसे tf.Graph.get_collection(tf.GraphKeys.VARIABLES) ) को एकत्रित करने की आवश्यकता है, तो .variables और Layer और Model ऑब्जेक्ट की .trainable_variables विशेषताओं का उपयोग करें।

ये Layer और Model वर्ग कई अन्य गुणों को लागू करते हैं जो वैश्विक संग्रह की आवश्यकता को दूर करते हैं। उनकी .losses संपत्ति tf.GraphKeys.LOSSES संग्रह का उपयोग करने के लिए एक प्रतिस्थापन हो सकती है।

अधिक विवरण के लिए केर गाइडों का संदर्भ लें।

3. अपने प्रशिक्षण छोरों को अपग्रेड करें

उच्चतम-स्तरीय API का उपयोग करें जो आपके उपयोग के मामले में काम करता है। अपने स्वयं के प्रशिक्षण छोरों के निर्माण पर tf.keras.Model.fit को प्राथमिकता tf.keras.Model.fit

ये उच्च स्तर के कार्य निम्न-स्तरीय विवरणों का एक बहुत प्रबंधन करते हैं जो कि यदि आप अपना स्वयं का प्रशिक्षण लूप लिखते हैं तो याद रखना आसान हो सकता है। उदाहरण के लिए, वे स्वचालित रूप से नियमितीकरण नुकसान एकत्र करते हैं, और मॉडल को कॉल करते समय training=True तर्क सेट करते हैं।

4. अपने डेटा इनपुट पाइपलाइनों को अपग्रेड करें

डेटा इनपुट के लिए tf.data डेटासेट का उपयोग करें। ये ऑब्जेक्ट कुशल, अभिव्यंजक हैं, और टेंसरफ़्लो के साथ अच्छी तरह से एकीकृत हैं।

उन्हें सीधे tf.keras.Model.fit पद्धति में पास किया जा सकता है।

model.fit(dataset, epochs=5)

उन्हें सीधे मानक पायथन से अधिक पुनरावृत्त किया जा सकता है:

for example_batch, label_batch in dataset:
    break

5. compat.v1 बंद करें compat.v1 प्रतीक

tf.compat.v1 मॉड्यूल में पूर्ण TensorFlow 1.x API शामिल है, जिसका मूल शब्दार्थ है।

TensorFlow 2.x उन्नयन स्क्रिप्ट प्रतीकों को उनके v2 समकक्षों में बदल देगा यदि ऐसा रूपांतरण सुरक्षित है, अर्थात, यदि यह निर्धारित कर सकता है कि TensorFlow 2.x संस्करण का व्यवहार बिल्कुल समतुल्य है (उदाहरण के लिए, यह v1.arg_max नाम बदल v1.arg_max tf.argmax , क्योंकि वे एक ही फ़ंक्शन हैं)।

अपग्रेड स्क्रिप्ट को एक कोड के साथ किया जाने के बाद, यह संभावना है कि compat.v1 कई उल्लेख हैं compat.v1 । यह कोड से गुजरने के लायक है और इन्हें मैन्युअल रूप से v2 समतुल्य में परिवर्तित किया जाना चाहिए (यदि एक है तो लॉग में इसका उल्लेख किया जाना चाहिए)।

परिवर्तित मॉडल

निम्न-स्तरीय चर और ऑपरेटर निष्पादन

निम्न-स्तरीय API उपयोग के उदाहरणों में शामिल हैं:

  • पुन: उपयोग को नियंत्रित करने के लिए चर स्कोप का उपयोग करना।
  • v1.get_variable साथ चर बनाना।
  • संग्रह को स्पष्ट रूप से एक्सेस करना।
  • इस तरह से तरीकों के साथ संग्रह तक पहुँचने:

  • ग्राफ़ इनपुट सेट अप करने के लिए v1.placeholder का उपयोग करना।

  • Session.run साथ निष्पादित रेखांकन।

  • मैन्युअल रूप से वैरिएबल प्रारंभ करना।

परिवर्तित करने से पहले

यहाँ ये पैटर्न TensorFlow 1.x का उपयोग करते हुए कोड में कैसा दिख सकता है

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

import tensorflow_datasets as tfds
g = v1.Graph()

with g.as_default():
  in_a = v1.placeholder(dtype=v1.float32, shape=(2))
  in_b = v1.placeholder(dtype=v1.float32, shape=(2))

  def forward(x):
    with v1.variable_scope("matmul", reuse=v1.AUTO_REUSE):
      W = v1.get_variable("W", initializer=v1.ones(shape=(2,2)),
                          regularizer=lambda x:tf.reduce_mean(x**2))
      b = v1.get_variable("b", initializer=v1.zeros(shape=(2)))
      return W * x + b

  out_a = forward(in_a)
  out_b = forward(in_b)
  reg_loss=v1.losses.get_regularization_loss(scope="matmul")

with v1.Session(graph=g) as sess:
  sess.run(v1.global_variables_initializer())
  outs = sess.run([out_a, out_b, reg_loss],
                feed_dict={in_a: [1, 0], in_b: [0, 1]})

print(outs[0])
print()
print(outs[1])
print()
print(outs[2])
[[1. 0.]
 [1. 0.]]

[[0. 1.]
 [0. 1.]]

1.0

परिवर्तित करने के बाद

परिवर्तित कोड में:

  • चर स्थानीय पायथन ऑब्जेक्ट हैं।
  • forward फ़ंक्शन अभी भी गणना को परिभाषित करता है।
  • Session.run कॉल को forward करने के लिए कॉल के साथ बदल दिया जाता है।
  • वैकल्पिक tf.function डेकोरेटर को प्रदर्शन के लिए जोड़ा जा सकता है।
  • नियमितताओं की गणना किसी भी वैश्विक संग्रह का जिक्र किए बिना, मैन्युअल रूप से की जाती है।
  • सत्र या प्लेसहोल्डर का कोई उपयोग नहीं है
W = tf.Variable(tf.ones(shape=(2,2)), name="W")
b = tf.Variable(tf.zeros(shape=(2)), name="b")

@tf.function
def forward(x):
  return W * x + b

out_a = forward([1,0])
print(out_a)
tf.Tensor(
[[1. 0.]
 [1. 0.]], shape=(2, 2), dtype=float32)
out_b = forward([0,1])

regularizer = tf.keras.regularizers.l2(0.04)
reg_loss=regularizer(W)

tf.layers पर आधारित मॉडल

v1.layers मॉड्यूल का उपयोग परत-कार्यों को शामिल करने के लिए किया जाता है जो चर को परिभाषित करने और पुन: उपयोग करने के लिए v1.variable_scope पर निर्भर होते हैं।

परिवर्तित करने से पहले

def model(x, training, scope='model'):
  with v1.variable_scope(scope, reuse=v1.AUTO_REUSE):
    x = v1.layers.conv2d(x, 32, 3, activation=v1.nn.relu,
          kernel_regularizer=lambda x:0.004*tf.reduce_mean(x**2))
    x = v1.layers.max_pooling2d(x, (2, 2), 1)
    x = v1.layers.flatten(x)
    x = v1.layers.dropout(x, 0.1, training=training)
    x = v1.layers.dense(x, 64, activation=v1.nn.relu)
    x = v1.layers.batch_normalization(x, training=training)
    x = v1.layers.dense(x, 10)
    return x
train_data = tf.ones(shape=(1, 28, 28, 1))
test_data = tf.ones(shape=(1, 28, 28, 1))

train_out = model(train_data, training=True)
test_out = model(test_data, training=False)

print(train_out)
print()
print(test_out)
/tmpfs/src/tf_docs_env/lib/python3.6/site-packages/tensorflow/python/keras/legacy_tf_layers/convolutional.py:414: UserWarning: `tf.layers.conv2d` is deprecated and will be removed in a future version. Please Use `tf.keras.layers.Conv2D` instead.
  warnings.warn('`tf.layers.conv2d` is deprecated and '
/tmpfs/src/tf_docs_env/lib/python3.6/site-packages/tensorflow/python/keras/engine/base_layer.py:2273: UserWarning: `layer.apply` is deprecated and will be removed in a future version. Please use `layer.__call__` method instead.
  warnings.warn('`layer.apply` is deprecated and '
tf.Tensor([[0. 0. 0. 0. 0. 0. 0. 0. 0. 0.]], shape=(1, 10), dtype=float32)

tf.Tensor(
[[ 0.379358   -0.55901194  0.48704922  0.11619566  0.23902717  0.01691487
   0.07227738  0.14556988  0.2459927   0.2501198 ]], shape=(1, 10), dtype=float32)
/tmpfs/src/tf_docs_env/lib/python3.6/site-packages/tensorflow/python/keras/legacy_tf_layers/pooling.py:310: UserWarning: `tf.layers.max_pooling2d` is deprecated and will be removed in a future version. Please use `tf.keras.layers.MaxPooling2D` instead.
  warnings.warn('`tf.layers.max_pooling2d` is deprecated and '
/tmpfs/src/tf_docs_env/lib/python3.6/site-packages/tensorflow/python/keras/legacy_tf_layers/core.py:329: UserWarning: `tf.layers.flatten` is deprecated and will be removed in a future version. Please use `tf.keras.layers.Flatten` instead.
  warnings.warn('`tf.layers.flatten` is deprecated and '
/tmpfs/src/tf_docs_env/lib/python3.6/site-packages/tensorflow/python/keras/legacy_tf_layers/core.py:268: UserWarning: `tf.layers.dropout` is deprecated and will be removed in a future version. Please use `tf.keras.layers.Dropout` instead.
  warnings.warn('`tf.layers.dropout` is deprecated and '
/tmpfs/src/tf_docs_env/lib/python3.6/site-packages/tensorflow/python/keras/legacy_tf_layers/core.py:171: UserWarning: `tf.layers.dense` is deprecated and will be removed in a future version. Please use `tf.keras.layers.Dense` instead.
  warnings.warn('`tf.layers.dense` is deprecated and '
/tmpfs/src/tf_docs_env/lib/python3.6/site-packages/tensorflow/python/keras/legacy_tf_layers/normalization.py:308: 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).
  '`tf.layers.batch_normalization` is deprecated and '

परिवर्तित करने के बाद

ज्यादातर तर्क वही रहे। लेकिन अंतर नोटिस:

  • जब यह चलता है तो training तर्क मॉडल द्वारा प्रत्येक परत को दिया जाता है।
  • मूल model फ़ंक्शन (इनपुट x ) के लिए पहला तर्क चला गया है। ऐसा इसलिए है क्योंकि ऑब्जेक्ट परतें मॉडल को मॉडल को कॉल करने से अलग बनाती हैं।

यह भी ध्यान दें:

  • यदि आप tf.contrib से नियमित रूप से या initializers का उपयोग कर रहे हैं, तो इनमें दूसरों की तुलना में अधिक तर्क परिवर्तन हैं।
  • कोड अब संग्रह को नहीं लिखता है, इसलिए v1.losses.get_regularization_loss जैसे फ़ंक्शन अब इन मानों को वापस नहीं करेंगे, संभवतः आपके प्रशिक्षण छोरों को तोड़ देंगे।
model = tf.keras.Sequential([
    tf.keras.layers.Conv2D(32, 3, activation='relu',
                           kernel_regularizer=tf.keras.regularizers.l2(0.04),
                           input_shape=(28, 28, 1)),
    tf.keras.layers.MaxPooling2D(),
    tf.keras.layers.Flatten(),
    tf.keras.layers.Dropout(0.1),
    tf.keras.layers.Dense(64, activation='relu'),
    tf.keras.layers.BatchNormalization(),
    tf.keras.layers.Dense(10)
])

train_data = tf.ones(shape=(1, 28, 28, 1))
test_data = tf.ones(shape=(1, 28, 28, 1))
train_out = model(train_data, training=True)
print(train_out)
tf.Tensor([[0. 0. 0. 0. 0. 0. 0. 0. 0. 0.]], shape=(1, 10), dtype=float32)
test_out = model(test_data, training=False)
print(test_out)
tf.Tensor(
[[-0.2145557  -0.22979769 -0.14968733  0.01208701 -0.07569927  0.3475932
   0.10718458  0.03482988 -0.04309493 -0.10469118]], shape=(1, 10), dtype=float32)
# Here are all the trainable variables
len(model.trainable_variables)
8
# Here is the regularization loss
model.losses
[<tf.Tensor: shape=(), dtype=float32, numpy=0.08174552>]

मिश्रित चर और v1.layers

मौजूदा कोड अक्सर निम्न-स्तरीय TensorFlow 1.x चर और उच्च-स्तरीय v1.layers साथ संचालन को v1.layers

परिवर्तित करने से पहले

def model(x, training, scope='model'):
  with v1.variable_scope(scope, reuse=v1.AUTO_REUSE):
    W = v1.get_variable(
      "W", dtype=v1.float32,
      initializer=v1.ones(shape=x.shape),
      regularizer=lambda x:0.004*tf.reduce_mean(x**2),
      trainable=True)
    if training:
      x = x + W
    else:
      x = x + W * 0.5
    x = v1.layers.conv2d(x, 32, 3, activation=tf.nn.relu)
    x = v1.layers.max_pooling2d(x, (2, 2), 1)
    x = v1.layers.flatten(x)
    return x

train_out = model(train_data, training=True)
test_out = model(test_data, training=False)

परिवर्तित करने के बाद

इस कोड को परिवर्तित करने के लिए, लेयर मैपिंग लेयर्स के पैटर्न का पालन करें जैसा कि पिछले उदाहरण में किया गया है।

सामान्य पैटर्न है:

  • __init__ में परत पैरामीटर लीजिए।
  • निर्माण में चर build
  • call में गणना निष्पादित call , और परिणाम लौटाएं।

v1.variable_scope अनिवार्य रूप से अपनी खुद की एक परत है। इसलिए इसे tf.keras.layers.Layer रूप में फिर से tf.keras.layers.Layer । विवरण के लिए उपवर्ग गाइड के माध्यम से नई परतें और मॉडल बनाना देखें।

# Create a custom layer for part of the model
class CustomLayer(tf.keras.layers.Layer):
  def __init__(self, *args, **kwargs):
    super(CustomLayer, self).__init__(*args, **kwargs)

  def build(self, input_shape):
    self.w = self.add_weight(
        shape=input_shape[1:],
        dtype=tf.float32,
        initializer=tf.keras.initializers.ones(),
        regularizer=tf.keras.regularizers.l2(0.02),
        trainable=True)

  # Call method will sometimes get used in graph mode,
  # training will get turned into a tensor
  @tf.function
  def call(self, inputs, training=None):
    if training:
      return inputs + self.w
    else:
      return inputs + self.w * 0.5
custom_layer = CustomLayer()
print(custom_layer([1]).numpy())
print(custom_layer([1], training=True).numpy())
[1.5]
[2.]
train_data = tf.ones(shape=(1, 28, 28, 1))
test_data = tf.ones(shape=(1, 28, 28, 1))

# Build the model including the custom layer
model = tf.keras.Sequential([
    CustomLayer(input_shape=(28, 28, 1)),
    tf.keras.layers.Conv2D(32, 3, activation='relu'),
    tf.keras.layers.MaxPooling2D(),
    tf.keras.layers.Flatten(),
])

train_out = model(train_data, training=True)
test_out = model(test_data, training=False)

ध्यान देने योग्य कुछ बातें:

  • उपवर्गित केरस मॉडल और परतों को v1 ग्राफ़ (कोई स्वचालित नियंत्रण निर्भरता) और उत्सुक मोड में चलाने की आवश्यकता नहीं है:

    • ऑटोग्राफ और स्वचालित नियंत्रण निर्भरता प्राप्त करने के लिए call को tf.function में लपेटें।
  • call करने के लिए एक training तर्क को स्वीकार करने के लिए मत भूलना:

    • कभी-कभी यह एक tf.Tensor
    • कभी-कभी यह पायथन बूलियन होता है
  • निर्माता या में मॉडल चर बनाएं Model.build self.add_weight का उपयोग कर `:

    • Model.build आपके पास इनपुट आकार तक पहुंच है, इसलिए मिलान आकार के साथ वजन बना सकते हैं
    • tf.keras.layers.Layer.add_weight का उपयोग कर tf.keras.layers.Layer.add_weight को चर और नियमितीकरण नुकसान को ट्रैक करने की अनुमति देता है
  • अपनी वस्तुओं में tf.Tensors न रखें:

    • वे या तो tf.function या उत्सुक संदर्भ में निर्मित हो सकते हैं, और ये tf.function अलग तरह से व्यवहार करते हैं
    • राज्य के लिए tf.Variable s का उपयोग करें, वे हमेशा दोनों संदर्भों से उपयोग करने योग्य होते हैं
    • tf.Tensors केवल मध्यवर्ती मूल्यों के लिए हैं

स्लिम और contrib.layers पर एक नोट

पुराने TensorFlow 1.x कोड की एक बड़ी राशि का उपयोग करता है स्लिम पुस्तकालय है, जो के रूप में TensorFlow 1.x के साथ पैक किया गया था tf.contrib.layers । एक contrib मॉड्यूल के रूप में, यह अब TensorFlow 2.x में उपलब्ध नहीं है, यहां तक ​​कि tf.compat.v1 में भी। TensorFlow 2.x के लिए स्लिम का उपयोग कर कोड परिवर्तित करना v1.layers उपयोग करने वाले रिपॉजिटरी को परिवर्तित करने से अधिक शामिल है। वास्तव में, यह आपके स्लिम कोड को पहले v1.layers बदलने के लिए समझ में आता है, फिर v1.layers परिवर्तित हो सकता है।

  • arg_scopes निकालें, सभी args को स्पष्ट करने की आवश्यकता है।
  • यदि आप उनका उपयोग करते हैं, तो normalizer_fn और activation_fn को अपनी परतों में विभाजित करें।
  • एक या एक से अधिक अलग केरस परतों (डेप्थवाइज़, पॉइंटवाइज़ और वियोज्य केरस लेयर्स) के लिए अलग-अलग कंफ़र्टेबल लेयर्स मैप।
  • स्लिम और v1.layers विभिन्न तर्क नाम और डिफ़ॉल्ट मान हैं।
  • कुछ आर्गन्स में अलग-अलग पैमाने होते हैं।
  • यदि आप स्लिम प्री-प्रशिक्षित मॉडल का उपयोग करते हैं, तो Keras के पूर्व-ट्रैश किए गए मॉडल को tf.keras.applications या TF हब के TensorFlow 2.x SavedModels से मूल स्लिम कोड से निर्यात करके देखें।

कुछ tf.contrib लेयर को कोर TensorFlow में स्थानांतरित नहीं किया जा सकता है, बल्कि TensorFlow Addons पैकेज में ले जाया गया है।

प्रशिक्षण

tf.keras मॉडल को डेटा खिलाने के कई तरीके हैं। वे इनपुट के रूप में पायथन जनरेटर और नेम्पी सरणियों को स्वीकार करेंगे।

किसी मॉडल को डेटा खिलाने का अनुशंसित तरीका tf.data पैकेज का उपयोग करना है, जिसमें डेटा में हेरफेर करने के लिए उच्च प्रदर्शन वर्गों का संग्रह होता है।

यदि आप अभी भी tf.queue का उपयोग कर रहे हैं, तो ये अब केवल डेटा-संरचनाओं के रूप में समर्थित हैं, इनपुट पाइपलाइनों के रूप में नहीं।

TensorFlow डेटासेट का उपयोग करना

TensorFlow Datasets पैकेज ( tfds ) मेंtf.data.Dataset ऑब्जेक्ट के रूप में पूर्वनिर्धारित डेटासेट लोड करने के लिए उपयोगिताओं हैं।

इस उदाहरण के लिए, आप tfds का उपयोग करके MNIST डेटासेट लोड कर सकते हैं:

datasets, info = tfds.load(name='mnist', with_info=True, as_supervised=True)
mnist_train, mnist_test = datasets['train'], datasets['test']
Downloading and preparing dataset mnist/3.0.1 (download: 11.06 MiB, generated: 21.00 MiB, total: 32.06 MiB) to /home/kbuilder/tensorflow_datasets/mnist/3.0.1...
WARNING:absl:Dataset mnist is hosted on GCS. It will automatically be downloaded to your
local data directory. If you'd instead prefer to read directly from our public
GCS bucket (recommended if you're running on GCP), you can instead pass
`try_gcs=True` to `tfds.load` or set `data_dir=gs://tfds-data/datasets`.
Dataset mnist downloaded and prepared to /home/kbuilder/tensorflow_datasets/mnist/3.0.1. Subsequent calls will reuse this data.

फिर प्रशिक्षण के लिए डेटा तैयार करें:

  • प्रत्येक छवि को पुनः स्केल करें।
  • उदाहरणों के क्रम में फेरबदल करें।
  • छवियों और लेबल के बैचों को इकट्ठा करें।
BUFFER_SIZE = 10 # Use a much larger value for real code
BATCH_SIZE = 64
NUM_EPOCHS = 5


def scale(image, label):
  image = tf.cast(image, tf.float32)
  image /= 255

  return image, label

उदाहरण को छोटा रखने के लिए, डेटासेट को केवल 5 बैचों को वापस करने के लिए ट्रिम करें:

train_data = mnist_train.map(scale).shuffle(BUFFER_SIZE).batch(BATCH_SIZE)
test_data = mnist_test.map(scale).batch(BATCH_SIZE)

STEPS_PER_EPOCH = 5

train_data = train_data.take(STEPS_PER_EPOCH)
test_data = test_data.take(STEPS_PER_EPOCH)
image_batch, label_batch = next(iter(train_data))

केर प्रशिक्षण लूप का उपयोग करें

यदि आपको केरास के अंतर्निहित fit , evaluate और predict तरीकों का उपयोग करने की आवश्यकता है, तो आपको अपनी प्रशिक्षण प्रक्रिया के निम्न-स्तरीय नियंत्रण की आवश्यकता नहीं है। ये तरीके कार्यान्वयन (अनुक्रमिक, कार्यात्मक या उप-वर्ग) की परवाह किए बिना मॉडल को प्रशिक्षित करने के लिए एक समान इंटरफ़ेस प्रदान करते हैं।

इन विधियों के लाभों में शामिल हैं:

  • वे Numpy सरणियों, पायथन जनरेटर और, tf.data.Datasets स्वीकार करते हैं।
  • वे नियमितीकरण, और सक्रियण नुकसान को स्वचालित रूप से लागू करते हैं।
  • वे मल्टी-डिवाइस प्रशिक्षण के लिए tf.distribute समर्थन करते हैं।
  • वे घाटे और मैट्रिक्स के रूप में मनमाने ढंग से कॉलबल्स का समर्थन करते हैं।
  • वे tf.keras.callbacks.TensorBoard और कस्टम कॉलबैक जैसे कॉलबैक का समर्थन करते हैं।
  • वे प्रदर्शन कर रहे हैं, स्वचालित रूप से TensorFlow रेखांकन का उपयोग कर।

यहां एक Dataset का उपयोग करके एक मॉडल को प्रशिक्षित करने का एक उदाहरण है। (यह कैसे काम करता है, इसके विवरण के लिए, ट्यूटोरियल अनुभाग देखें।)

model = tf.keras.Sequential([
    tf.keras.layers.Conv2D(32, 3, activation='relu',
                           kernel_regularizer=tf.keras.regularizers.l2(0.02),
                           input_shape=(28, 28, 1)),
    tf.keras.layers.MaxPooling2D(),
    tf.keras.layers.Flatten(),
    tf.keras.layers.Dropout(0.1),
    tf.keras.layers.Dense(64, activation='relu'),
    tf.keras.layers.BatchNormalization(),
    tf.keras.layers.Dense(10)
])

# Model is the full model w/o custom layers
model.compile(optimizer='adam',
              loss=tf.keras.losses.SparseCategoricalCrossentropy(from_logits=True),
              metrics=['accuracy'])

model.fit(train_data, epochs=NUM_EPOCHS)
loss, acc = model.evaluate(test_data)

print("Loss {}, Accuracy {}".format(loss, acc))
Epoch 1/5
5/5 [==============================] - 1s 9ms/step - loss: 2.0191 - accuracy: 0.3608
Epoch 2/5
5/5 [==============================] - 0s 9ms/step - loss: 0.4736 - accuracy: 0.9059
Epoch 3/5
5/5 [==============================] - 0s 8ms/step - loss: 0.2973 - accuracy: 0.9626
Epoch 4/5
5/5 [==============================] - 0s 9ms/step - loss: 0.2108 - accuracy: 0.9911
Epoch 5/5
5/5 [==============================] - 0s 8ms/step - loss: 0.1791 - accuracy: 0.9874
5/5 [==============================] - 0s 6ms/step - loss: 1.5504 - accuracy: 0.7500
Loss 1.5504140853881836, Accuracy 0.75

अपना खुद का लूप लिखें

यदि केरेस मॉडल का प्रशिक्षण चरण आपके लिए काम करता है, लेकिन आपको उस चरण के बाहर अधिक नियंत्रण की आवश्यकता है, तो अपने स्वयं के डेटा-पुनरावृति लूप में tf.keras.Model.train_on_batch विधि का उपयोग करने पर विचार करें।

याद रखें: कई चीजों को tf.keras.callbacks.Callback रूप में लागू किया जा सकता है।

इस पद्धति में पिछले अनुभाग में वर्णित विधियों के कई फायदे हैं, लेकिन उपयोगकर्ता को बाहरी लूप का नियंत्रण देता है।

आप प्रशिक्षण के दौरान प्रदर्शन की जाँच करने के लिए tf.keras.Model.test_on_batch या tf.keras.Model.evaluate tf.keras.Model.test_on_batch भी उपयोग कर सकते हैं।

उपरोक्त मॉडल का प्रशिक्षण जारी रखने के लिए:

# Model is the full model w/o custom layers
model.compile(optimizer='adam',
              loss=tf.keras.losses.SparseCategoricalCrossentropy(from_logits=True),
              metrics=['accuracy'])

for epoch in range(NUM_EPOCHS):
  # Reset the metric accumulators
  model.reset_metrics()

  for image_batch, label_batch in train_data:
    result = model.train_on_batch(image_batch, label_batch)
    metrics_names = model.metrics_names
    print("train: ",
          "{}: {:.3f}".format(metrics_names[0], result[0]),
          "{}: {:.3f}".format(metrics_names[1], result[1]))
  for image_batch, label_batch in test_data:
    result = model.test_on_batch(image_batch, label_batch,
                                 # Return accumulated metrics
                                 reset_metrics=False)
  metrics_names = model.metrics_names
  print("\neval: ",
        "{}: {:.3f}".format(metrics_names[0], result[0]),
        "{}: {:.3f}".format(metrics_names[1], result[1]))
train:  loss: 0.138 accuracy: 1.000
train:  loss: 0.161 accuracy: 1.000
train:  loss: 0.159 accuracy: 0.969
train:  loss: 0.241 accuracy: 0.953
train:  loss: 0.172 accuracy: 0.969

eval:  loss: 1.550 accuracy: 0.800
train:  loss: 0.086 accuracy: 1.000
train:  loss: 0.094 accuracy: 1.000
train:  loss: 0.090 accuracy: 1.000
train:  loss: 0.119 accuracy: 0.984
train:  loss: 0.099 accuracy: 1.000

eval:  loss: 1.558 accuracy: 0.841
train:  loss: 0.076 accuracy: 1.000
train:  loss: 0.068 accuracy: 1.000
train:  loss: 0.061 accuracy: 1.000
train:  loss: 0.076 accuracy: 1.000
train:  loss: 0.076 accuracy: 1.000

eval:  loss: 1.536 accuracy: 0.841
train:  loss: 0.059 accuracy: 1.000
train:  loss: 0.056 accuracy: 1.000
train:  loss: 0.058 accuracy: 1.000
train:  loss: 0.054 accuracy: 1.000
train:  loss: 0.055 accuracy: 1.000

eval:  loss: 1.497 accuracy: 0.863
train:  loss: 0.053 accuracy: 1.000
train:  loss: 0.049 accuracy: 1.000
train:  loss: 0.044 accuracy: 1.000
train:  loss: 0.049 accuracy: 1.000
train:  loss: 0.045 accuracy: 1.000

eval:  loss: 1.463 accuracy: 0.878

प्रशिक्षण चरण को अनुकूलित करें

यदि आपको अधिक लचीलापन और नियंत्रण की आवश्यकता है, तो आप अपने स्वयं के प्रशिक्षण लूप को लागू करके यह कर सकते हैं। तीन चरण हैं:

  1. उदाहरणों के बैच पाने के लिए एक पायथन जनरेटर याtf.data.Dataset परtf.data.Dataset करें।
  2. ग्रेडिएंट इकट्ठा करने के लिएtf.GradientTape का उपयोग करें।
  3. मॉडल के चर में वजन अपडेट लागू करने के लिए tf.keras.optimizers से एक का उपयोग करें।

याद कीजिए:

  • हमेशा उपवर्ग परतों और मॉडल की call विधि पर एक training तर्क शामिल call
  • training तर्क के साथ मॉडल को सही ढंग से सेट करना सुनिश्चित करें।
  • उपयोग के आधार पर, मॉडल चर तब तक मौजूद नहीं हो सकते जब तक कि मॉडल डेटा बैच पर नहीं चलाया जाता।
  • आपको मॉडल के लिए नियमितीकरण के नुकसान जैसी चीजों को मैन्युअल रूप से संभालना होगा।

V1 के सापेक्ष सरलीकरण पर ध्यान दें:

  • वैरिएबल इनिशियलाइज़र चलाने की कोई आवश्यकता नहीं है। चर को सृष्टि पर आरम्भ किया जाता है।
  • मैन्युअल नियंत्रण निर्भरता को जोड़ने की कोई आवश्यकता नहीं है। यहां तक ​​कि tf.function ऑपरेशंस में भी उत्सुक मोड में कार्य किया जाता है।
model = tf.keras.Sequential([
    tf.keras.layers.Conv2D(32, 3, activation='relu',
                           kernel_regularizer=tf.keras.regularizers.l2(0.02),
                           input_shape=(28, 28, 1)),
    tf.keras.layers.MaxPooling2D(),
    tf.keras.layers.Flatten(),
    tf.keras.layers.Dropout(0.1),
    tf.keras.layers.Dense(64, activation='relu'),
    tf.keras.layers.BatchNormalization(),
    tf.keras.layers.Dense(10)
])

optimizer = tf.keras.optimizers.Adam(0.001)
loss_fn = tf.keras.losses.SparseCategoricalCrossentropy(from_logits=True)

@tf.function
def train_step(inputs, labels):
  with tf.GradientTape() as tape:
    predictions = model(inputs, training=True)
    regularization_loss=tf.math.add_n(model.losses)
    pred_loss=loss_fn(labels, predictions)
    total_loss=pred_loss + regularization_loss

  gradients = tape.gradient(total_loss, model.trainable_variables)
  optimizer.apply_gradients(zip(gradients, model.trainable_variables))

for epoch in range(NUM_EPOCHS):
  for inputs, labels in train_data:
    train_step(inputs, labels)
  print("Finished epoch", epoch)
Finished epoch 0
Finished epoch 1
Finished epoch 2
Finished epoch 3
Finished epoch 4

नई शैली के मैट्रिक्स और नुकसान

TensorFlow 2.x में, मैट्रिक्स और नुकसान ऑब्जेक्ट हैं। ये दोनों उत्सुकता से और tf.function s में काम करते हैं।

हानि ऑब्जेक्ट कॉल करने योग्य है, और तर्क के रूप में (y_true, y_pred) की अपेक्षा करता है:

cce = tf.keras.losses.CategoricalCrossentropy(from_logits=True)
cce([[1, 0]], [[-1.0,3.0]]).numpy()
4.01815

एक मीट्रिक वस्तु के निम्नलिखित तरीके हैं:

  • Metric.update_state() : नई टिप्पणियों को जोड़ें।
  • Metric.result() : देखे गए मानों को देखते हुए मीट्रिक का वर्तमान परिणाम प्राप्त करें।
  • Metric.reset_states() : सभी टिप्पणियों को साफ़ करें।

ऑब्जेक्ट ही कॉल करने योग्य है। कॉलिंग अद्यतन के साथ स्थिति को अपडेट करता है, जैसा कि update_state साथ है, और मीट्रिक का नया परिणाम देता है।

आपको मैन्युअल रूप से मीट्रिक के चर को इनिशियलाइज़ नहीं करना है, और क्योंकि TensorFlow 2.x में स्वचालित नियंत्रण निर्भरताएं हैं, इसलिए आपको उन लोगों के बारे में चिंता करने की आवश्यकता नहीं है।

नीचे दिया गया कोड कस्टम प्रशिक्षण लूप के भीतर देखे गए नुकसान का ट्रैक रखने के लिए एक मीट्रिक का उपयोग करता है।

# Create the metrics
loss_metric = tf.keras.metrics.Mean(name='train_loss')
accuracy_metric = tf.keras.metrics.SparseCategoricalAccuracy(name='train_accuracy')

@tf.function
def train_step(inputs, labels):
  with tf.GradientTape() as tape:
    predictions = model(inputs, training=True)
    regularization_loss=tf.math.add_n(model.losses)
    pred_loss=loss_fn(labels, predictions)
    total_loss=pred_loss + regularization_loss

  gradients = tape.gradient(total_loss, model.trainable_variables)
  optimizer.apply_gradients(zip(gradients, model.trainable_variables))
  # Update the metrics
  loss_metric.update_state(total_loss)
  accuracy_metric.update_state(labels, predictions)


for epoch in range(NUM_EPOCHS):
  # Reset the metrics
  loss_metric.reset_states()
  accuracy_metric.reset_states()

  for inputs, labels in train_data:
    train_step(inputs, labels)
  # Get the metric results
  mean_loss=loss_metric.result()
  mean_accuracy = accuracy_metric.result()

  print('Epoch: ', epoch)
  print('  loss:     {:.3f}'.format(mean_loss))
  print('  accuracy: {:.3f}'.format(mean_accuracy))
Epoch:  0
  loss:     0.139
  accuracy: 0.997
Epoch:  1
  loss:     0.116
  accuracy: 1.000
Epoch:  2
  loss:     0.105
  accuracy: 0.997
Epoch:  3
  loss:     0.089
  accuracy: 1.000
Epoch:  4
  loss:     0.078
  accuracy: 1.000

केरस मेट्रिक नाम

TensorFlow 2.x में, Keras मॉडल मीट्रिक नामों को संभालने के बारे में अधिक सुसंगत हैं।

अब जब आप मीट्रिक की सूची में एक स्ट्रिंग पास करते हैं, तो उस सटीक स्ट्रिंग का उपयोग मीट्रिक के name रूप में किया जाता है। ये नाम model.fit द्वारा लौटाए गए इतिहास ऑब्जेक्ट में दिखाई दे रहे हैं, और keras.callbacks को keras.callbacks गए लॉग में। मीट्रिक सूची में आपके द्वारा पारित स्ट्रिंग के लिए सेट किया गया है।

model.compile(
    optimizer = tf.keras.optimizers.Adam(0.001),
    loss = tf.keras.losses.SparseCategoricalCrossentropy(from_logits=True),
    metrics = ['acc', 'accuracy', tf.keras.metrics.SparseCategoricalAccuracy(name="my_accuracy")])
history = model.fit(train_data)
5/5 [==============================] - 1s 8ms/step - loss: 0.0901 - acc: 0.9923 - accuracy: 0.9923 - my_accuracy: 0.9923
history.history.keys()
dict_keys(['loss', 'acc', 'accuracy', 'my_accuracy'])

यह पिछले संस्करणों से भिन्न होता है जहाँ metrics=["accuracy"] परिणामस्वरूप dict_keys(['loss', 'acc'])

करैस आशावादी

में optimizers v1.train जैसे, v1.train.AdamOptimizer और v1.train.GradientDescentOptimizer , में समकक्ष है tf.keras.optimizers

v1.train को keras.optimizers बदलें

अपने ऑप्टिमाइज़र को परिवर्तित करते समय ध्यान रखने योग्य बातें हैं:

कुछ tf.keras.optimizers लिए नई चूक

के लिए कोई परिवर्तन नहीं हैं optimizers.SGD , optimizers.Adam , या optimizers.RMSprop

निम्नलिखित डिफ़ॉल्ट सीखने की दर बदल गई है:

टेंसरबोर्ड

TensorFlow 2.x में tf.summary API में महत्वपूर्ण बदलाव शामिल हैं, tf.summary उपयोग TensorBoard में विज़ुअलाइज़ेशन के लिए सारांश डेटा लिखने के लिए किया जाता है। नई tf.summary सामान्य परिचय के लिए, कई ट्यूटोरियल उपलब्ध हैं जो TensorFlow 2.x API का उपयोग करते हैं। इसमें TensorBoard TensorFlow 2.x माइग्रेशन गाइड शामिल है

बचत और लोडिंग

चेकपॉइंट संगतता

TensorFlow 2.x ऑब्जेक्ट-आधारित चौकियों का उपयोग करता है

पुरानी शैली के नाम-आधारित चौकियों को अभी भी लोड किया जा सकता है, अगर आप सावधान रहें। कोड रूपांतरण प्रक्रिया के परिणामस्वरूप चर नाम परिवर्तन हो सकते हैं, लेकिन वर्कअराउंड हैं।

चौकी में नामों के साथ नए मॉडल के नामों को लाइन करने के लिए सबसे सरल तरीका:

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

यदि वह आपके उपयोग के मामले में काम नहीं करता है, तो v1.train.init_from_checkpoint फ़ंक्शन v1.train.init_from_checkpoint । यह एक assignment_map तर्क लेता है, जो पुराने नामों से नए नामों तक मानचित्रण को निर्दिष्ट करता है।

TensorFlow एस्टीमेटर रिपॉजिटरी में TensorFlow 1.x से 2.0 तक प्रीमियर अनुमानकर्ताओं के लिए चौकियों को अपग्रेड करने के लिए रूपांतरण उपकरण शामिल है। यह एक उदाहरण के रूप में काम कर सकता है कि एक समान उपयोग के मामले के लिए एक उपकरण कैसे बनाया जाए।

सहेजे गए मॉडल संगतता

सहेजे गए मॉडल के लिए कोई महत्वपूर्ण संगतता चिंताएं नहीं हैं।

  • TensorFlow 1.x save_models TensorFlow 2.x में काम करता है।
  • यदि सभी ऑप्स समर्थित हैं तो TensorFlow 2.x save_models TensorFlow 1.x में काम करता है।

एक Graph.pb या Graph.pbtxt

Graph.pb एक कच्चे Graph.pb फ़ाइल को अपग्रेड करने का कोई सीधा तरीका नहीं है। आपकी सबसे अच्छी शर्त उस कोड को अपग्रेड करना है जो फ़ाइल उत्पन्न करता है।

लेकिन, यदि आप एक "स्थिर ग्राफ" (एक है tf.Graph जहां चर स्थिरांक में बदल दिया गया है), तो यह संभव एक में बदलने के लिए है concrete_function का उपयोग कर v1.wrap_function :

def wrap_frozen_graph(graph_def, inputs, outputs):
  def _imports_graph_def():
    tf.compat.v1.import_graph_def(graph_def, name="")
  wrapped_import = tf.compat.v1.wrap_function(_imports_graph_def, [])
  import_graph = wrapped_import.graph
  return wrapped_import.prune(
      tf.nest.map_structure(import_graph.as_graph_element, inputs),
      tf.nest.map_structure(import_graph.as_graph_element, outputs))

उदाहरण के लिए, यहां 2016 से इंसेप्शन v1 के लिए एक फ्रॉज्ड ग्राफ दिया गया है:

path = tf.keras.utils.get_file(
    'inception_v1_2016_08_28_frozen.pb',
    'http://storage.googleapis.com/download.tensorflow.org/models/inception_v1_2016_08_28_frozen.pb.tar.gz',
    untar=True)
Downloading data from http://storage.googleapis.com/download.tensorflow.org/models/inception_v1_2016_08_28_frozen.pb.tar.gz
24698880/24695710 [==============================] - 1s 0us/step

लोड tf.GraphDef :

graph_def = tf.compat.v1.GraphDef()
loaded = graph_def.ParseFromString(open(path,'rb').read())

इसे एक concrete_function में लपेटें:

inception_func = wrap_frozen_graph(
    graph_def, inputs='input:0',
    outputs='InceptionV1/InceptionV1/Mixed_3b/Branch_1/Conv2d_0a_1x1/Relu:0')

इनपुट के रूप में इसे टेंसर पास करें:

input_img = tf.ones([1,224,224,3], dtype=tf.float32)
inception_func(input_img).shape
TensorShape([1, 28, 28, 96])

आकलनकर्ता

अनुमान के साथ प्रशिक्षण

अनुमानक TensorFlow 2.x में समर्थित हैं।

जब आप input_fn उपयोग करते हैं, तो आप tf.estimator.TrainSpec tf.estimator.EvalSpec से input_fn, tf.estimator.TrainSpec , और tf.estimator.EvalSpec उपयोग कर सकते हैं।

ट्रेन के साथ input_fn और स्पेक्स का मूल्यांकन करने के लिए यहां एक उदाहरण दिया गया है।

Input_fn और ट्रेन / eval चश्मा बनाना

# Define the estimator's input_fn
def input_fn():
  datasets, info = tfds.load(name='mnist', with_info=True, as_supervised=True)
  mnist_train, mnist_test = datasets['train'], datasets['test']

  BUFFER_SIZE = 10000
  BATCH_SIZE = 64

  def scale(image, label):
    image = tf.cast(image, tf.float32)
    image /= 255

    return image, label[..., tf.newaxis]

  train_data = mnist_train.map(scale).shuffle(BUFFER_SIZE).batch(BATCH_SIZE)
  return train_data.repeat()

# Define train and eval specs
train_spec = tf.estimator.TrainSpec(input_fn=input_fn,
                                    max_steps=STEPS_PER_EPOCH * NUM_EPOCHS)
eval_spec = tf.estimator.EvalSpec(input_fn=input_fn,
                                  steps=STEPS_PER_EPOCH)

केरस मॉडल परिभाषा का उपयोग करना

TensorFlow 2.x में अपने अनुमानकों का निर्माण करने के तरीके में कुछ अंतर हैं।

यह अनुशंसा की जाती है कि आप tf.keras.estimator.model_to_estimator उपयोग करके अपने मॉडल को परिभाषित करें, फिर अपने मॉडल को एक अनुमानक में बदलने के लिए tf.keras.estimator.model_to_estimator उपयोगिता का उपयोग करें। नीचे दिए गए कोड से पता चलता है कि एक अनुमानक को बनाते और प्रशिक्षित करते समय इस उपयोगिता का उपयोग कैसे किया जाता है।

def make_model():
  return tf.keras.Sequential([
    tf.keras.layers.Conv2D(32, 3, activation='relu',
                           kernel_regularizer=tf.keras.regularizers.l2(0.02),
                           input_shape=(28, 28, 1)),
    tf.keras.layers.MaxPooling2D(),
    tf.keras.layers.Flatten(),
    tf.keras.layers.Dropout(0.1),
    tf.keras.layers.Dense(64, activation='relu'),
    tf.keras.layers.BatchNormalization(),
    tf.keras.layers.Dense(10)
  ])
model = make_model()

model.compile(optimizer='adam',
              loss=tf.keras.losses.SparseCategoricalCrossentropy(from_logits=True),
              metrics=['accuracy'])

estimator = tf.keras.estimator.model_to_estimator(
  keras_model = model
)

tf.estimator.train_and_evaluate(estimator, train_spec, eval_spec)
INFO:tensorflow:Using default config.
INFO:tensorflow:Using default config.
WARNING:tensorflow:Using temporary folder as model directory: /tmp/tmp0erq3im2
WARNING:tensorflow:Using temporary folder as model directory: /tmp/tmp0erq3im2
INFO:tensorflow:Using the Keras model provided.
INFO:tensorflow:Using the Keras model provided.
/tmpfs/src/tf_docs_env/lib/python3.6/site-packages/tensorflow/python/keras/backend.py:434: UserWarning: `tf.keras.backend.set_learning_phase` is deprecated and will be removed after 2020-10-11. To update it, simply pass a True/False value to the `training` argument of the `__call__` method of your layer or model.
  warnings.warn('`tf.keras.backend.set_learning_phase` is deprecated and '
INFO:tensorflow:Using config: {'_model_dir': '/tmp/tmp0erq3im2', '_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:Using config: {'_model_dir': '/tmp/tmp0erq3im2', '_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:Not using Distribute Coordinator.
INFO:tensorflow:Not using Distribute Coordinator.
INFO:tensorflow:Running training and evaluation locally (non-distributed).
INFO:tensorflow:Running training and evaluation locally (non-distributed).
INFO:tensorflow:Start train and evaluate loop. The evaluate will happen after every checkpoint. Checkpoint frequency is determined based on RunConfig arguments: save_checkpoints_steps None or save_checkpoints_secs 600.
INFO:tensorflow:Start train and evaluate loop. The evaluate will happen after every checkpoint. Checkpoint frequency is determined based on RunConfig arguments: save_checkpoints_steps None or save_checkpoints_secs 600.
WARNING:tensorflow:From /tmpfs/src/tf_docs_env/lib/python3.6/site-packages/tensorflow/python/training/training_util.py:236: Variable.initialized_value (from tensorflow.python.ops.variables) is deprecated and will be removed in a future version.
Instructions for updating:
Use Variable.read_value. Variables in 2.X are initialized automatically both in eager and graph (inside tf.defun) contexts.
WARNING:tensorflow:From /tmpfs/src/tf_docs_env/lib/python3.6/site-packages/tensorflow/python/training/training_util.py:236: Variable.initialized_value (from tensorflow.python.ops.variables) is deprecated and will be removed in a future version.
Instructions for updating:
Use Variable.read_value. Variables in 2.X are initialized automatically both in eager and graph (inside tf.defun) contexts.
INFO:tensorflow:Calling model_fn.
INFO:tensorflow:Calling model_fn.
INFO:tensorflow:Done calling model_fn.
INFO:tensorflow:Done calling model_fn.
INFO:tensorflow:Warm-starting with WarmStartSettings: WarmStartSettings(ckpt_to_initialize_from='/tmp/tmp0erq3im2/keras/keras_model.ckpt', vars_to_warm_start='.*', var_name_to_vocab_info={}, var_name_to_prev_var_name={})
INFO:tensorflow:Warm-starting with WarmStartSettings: WarmStartSettings(ckpt_to_initialize_from='/tmp/tmp0erq3im2/keras/keras_model.ckpt', vars_to_warm_start='.*', var_name_to_vocab_info={}, var_name_to_prev_var_name={})
INFO:tensorflow:Warm-starting from: /tmp/tmp0erq3im2/keras/keras_model.ckpt
INFO:tensorflow:Warm-starting from: /tmp/tmp0erq3im2/keras/keras_model.ckpt
INFO:tensorflow:Warm-starting variables only in TRAINABLE_VARIABLES.
INFO:tensorflow:Warm-starting variables only in TRAINABLE_VARIABLES.
INFO:tensorflow:Warm-started 8 variables.
INFO:tensorflow:Warm-started 8 variables.
INFO:tensorflow:Create CheckpointSaverHook.
INFO:tensorflow:Create CheckpointSaverHook.
INFO:tensorflow:Graph was finalized.
INFO:tensorflow:Graph was finalized.
INFO:tensorflow:Running local_init_op.
INFO:tensorflow:Running local_init_op.
INFO:tensorflow:Done running local_init_op.
INFO:tensorflow:Done running local_init_op.
INFO:tensorflow:Calling checkpoint listeners before saving checkpoint 0...
INFO:tensorflow:Calling checkpoint listeners before saving checkpoint 0...
INFO:tensorflow:Saving checkpoints for 0 into /tmp/tmp0erq3im2/model.ckpt.
INFO:tensorflow:Saving checkpoints for 0 into /tmp/tmp0erq3im2/model.ckpt.
INFO:tensorflow:Calling checkpoint listeners after saving checkpoint 0...
INFO:tensorflow:Calling checkpoint listeners after saving checkpoint 0...
INFO:tensorflow:loss = 2.4717796, step = 0
INFO:tensorflow:loss = 2.4717796, step = 0
INFO:tensorflow:Calling checkpoint listeners before saving checkpoint 25...
INFO:tensorflow:Calling checkpoint listeners before saving checkpoint 25...
INFO:tensorflow:Saving checkpoints for 25 into /tmp/tmp0erq3im2/model.ckpt.
INFO:tensorflow:Saving checkpoints for 25 into /tmp/tmp0erq3im2/model.ckpt.
INFO:tensorflow:Calling checkpoint listeners after saving checkpoint 25...
INFO:tensorflow:Calling checkpoint listeners after saving checkpoint 25...
INFO:tensorflow:Calling model_fn.
INFO:tensorflow:Calling model_fn.
INFO:tensorflow:Done calling model_fn.
/tmpfs/src/tf_docs_env/lib/python3.6/site-packages/tensorflow/python/keras/engine/training.py:2325: UserWarning: `Model.state_updates` will be removed in a future version. This property should not be used in TensorFlow 2.0, as `updates` are applied automatically.
  warnings.warn('`Model.state_updates` will be removed in a future version. '
INFO:tensorflow:Done calling model_fn.
INFO:tensorflow:Starting evaluation at 2021-01-06T02:31:17Z
INFO:tensorflow:Starting evaluation at 2021-01-06T02:31:17Z
INFO:tensorflow:Graph was finalized.
INFO:tensorflow:Graph was finalized.
INFO:tensorflow:Restoring parameters from /tmp/tmp0erq3im2/model.ckpt-25
INFO:tensorflow:Restoring parameters from /tmp/tmp0erq3im2/model.ckpt-25
INFO:tensorflow:Running local_init_op.
INFO:tensorflow:Running local_init_op.
INFO:tensorflow:Done running local_init_op.
INFO:tensorflow:Done running local_init_op.
INFO:tensorflow:Evaluation [1/5]
INFO:tensorflow:Evaluation [1/5]
INFO:tensorflow:Evaluation [2/5]
INFO:tensorflow:Evaluation [2/5]
INFO:tensorflow:Evaluation [3/5]
INFO:tensorflow:Evaluation [3/5]
INFO:tensorflow:Evaluation [4/5]
INFO:tensorflow:Evaluation [4/5]
INFO:tensorflow:Evaluation [5/5]
INFO:tensorflow:Evaluation [5/5]
INFO:tensorflow:Inference Time : 0.86556s
INFO:tensorflow:Inference Time : 0.86556s
INFO:tensorflow:Finished evaluation at 2021-01-06-02:31:18
INFO:tensorflow:Finished evaluation at 2021-01-06-02:31:18
INFO:tensorflow:Saving dict for global step 25: accuracy = 0.6, global_step = 25, loss = 1.6160676
INFO:tensorflow:Saving dict for global step 25: accuracy = 0.6, global_step = 25, loss = 1.6160676
INFO:tensorflow:Saving 'checkpoint_path' summary for global step 25: /tmp/tmp0erq3im2/model.ckpt-25
INFO:tensorflow:Saving 'checkpoint_path' summary for global step 25: /tmp/tmp0erq3im2/model.ckpt-25
INFO:tensorflow:Loss for final step: 0.37597787.
INFO:tensorflow:Loss for final step: 0.37597787.
({'accuracy': 0.6, 'loss': 1.6160676, 'global_step': 25}, [])

एक कस्टम model_fn का उपयोग करना

यदि आपके पास एक मौजूदा कस्टम अनुमानक model_fn जिसे आपको बनाए रखने की आवश्यकता है, तो आप एक model_fn मॉडल का उपयोग करने के लिए अपने model_fn को बदल सकते हैं।

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

न्यूनतम बदलाव के साथ कस्टम model_fn

TensorFlow 2.x में अपने कस्टम model_fn काम करने के लिए, यदि आप मौजूदा कोड में न्यूनतम परिवर्तन पसंद करते हैं, तो tf.compat.v1 प्रतीकों जैसे optimizers और metrics का उपयोग किया जा सकता है।

एक कस्टम मॉडल में model_fn मॉडल का उपयोग model_fn यदि यह एक कस्टम ट्रेनिंग लूप में उपयोग करने के समान है:

  • mode तर्क के आधार पर, उचित रूप से training चरण निर्धारित करें।
  • स्पष्ट रूप से अनुकूलक के लिए मॉडल के trainable_variables पास करें।

लेकिन एक कस्टम लूप के सापेक्ष महत्वपूर्ण अंतर हैं:

  • उपयोग करने के बजाय Model.losses , का उपयोग करते हुए घाटे को निकालने Model.get_losses_for
  • Model.get_updates_for का उपयोग करके मॉडल के अपडेट निकालें।

निम्न कोड इन सभी चिंताओं को दर्शाते हुए एक कस्टम model_fn से एक अनुमानक बनाता है।

def my_model_fn(features, labels, mode):
  model = make_model()

  optimizer = tf.compat.v1.train.AdamOptimizer()
  loss=tf.keras.losses.SparseCategoricalCrossentropy(from_logits=True)

  training = (mode == tf.estimator.ModeKeys.TRAIN)
  predictions = model(features, training=training)

  if mode == tf.estimator.ModeKeys.PREDICT:
    return tf.estimator.EstimatorSpec(mode=mode, predictions=predictions)

  reg_losses = model.get_losses_for(None) + model.get_losses_for(features)
  total_loss=loss_fn(labels, predictions) + tf.math.add_n(reg_losses)

  accuracy = tf.compat.v1.metrics.accuracy(labels=labels,
                                           predictions=tf.math.argmax(predictions, axis=1),
                                           name='acc_op')

  update_ops = model.get_updates_for(None) + model.get_updates_for(features)
  minimize_op = optimizer.minimize(
      total_loss,
      var_list=model.trainable_variables,
      global_step=tf.compat.v1.train.get_or_create_global_step())
  train_op = tf.group(minimize_op, update_ops)

  return tf.estimator.EstimatorSpec(
    mode=mode,
    predictions=predictions,
    loss=total_loss,
    train_op=train_op, eval_metric_ops={'accuracy': accuracy})

# Create the Estimator & Train
estimator = tf.estimator.Estimator(model_fn=my_model_fn)
tf.estimator.train_and_evaluate(estimator, train_spec, eval_spec)
INFO:tensorflow:Using default config.
INFO:tensorflow:Using default config.
WARNING:tensorflow:Using temporary folder as model directory: /tmp/tmpifj8mysl
WARNING:tensorflow:Using temporary folder as model directory: /tmp/tmpifj8mysl
INFO:tensorflow:Using config: {'_model_dir': '/tmp/tmpifj8mysl', '_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:Using config: {'_model_dir': '/tmp/tmpifj8mysl', '_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:Not using Distribute Coordinator.
INFO:tensorflow:Not using Distribute Coordinator.
INFO:tensorflow:Running training and evaluation locally (non-distributed).
INFO:tensorflow:Running training and evaluation locally (non-distributed).
INFO:tensorflow:Start train and evaluate loop. The evaluate will happen after every checkpoint. Checkpoint frequency is determined based on RunConfig arguments: save_checkpoints_steps None or save_checkpoints_secs 600.
INFO:tensorflow:Start train and evaluate loop. The evaluate will happen after every checkpoint. Checkpoint frequency is determined based on RunConfig arguments: save_checkpoints_steps None or save_checkpoints_secs 600.
INFO:tensorflow:Calling model_fn.
INFO:tensorflow:Calling model_fn.
INFO:tensorflow:Done calling model_fn.
INFO:tensorflow:Done calling model_fn.
INFO:tensorflow:Create CheckpointSaverHook.
INFO:tensorflow:Create CheckpointSaverHook.
INFO:tensorflow:Graph was finalized.
INFO:tensorflow:Graph was finalized.
INFO:tensorflow:Running local_init_op.
INFO:tensorflow:Running local_init_op.
INFO:tensorflow:Done running local_init_op.
INFO:tensorflow:Done running local_init_op.
INFO:tensorflow:Calling checkpoint listeners before saving checkpoint 0...
INFO:tensorflow:Calling checkpoint listeners before saving checkpoint 0...
INFO:tensorflow:Saving checkpoints for 0 into /tmp/tmpifj8mysl/model.ckpt.
INFO:tensorflow:Saving checkpoints for 0 into /tmp/tmpifj8mysl/model.ckpt.
INFO:tensorflow:Calling checkpoint listeners after saving checkpoint 0...
INFO:tensorflow:Calling checkpoint listeners after saving checkpoint 0...
INFO:tensorflow:loss = 3.0136237, step = 0
INFO:tensorflow:loss = 3.0136237, step = 0
INFO:tensorflow:Calling checkpoint listeners before saving checkpoint 25...
INFO:tensorflow:Calling checkpoint listeners before saving checkpoint 25...
INFO:tensorflow:Saving checkpoints for 25 into /tmp/tmpifj8mysl/model.ckpt.
INFO:tensorflow:Saving checkpoints for 25 into /tmp/tmpifj8mysl/model.ckpt.
INFO:tensorflow:Calling checkpoint listeners after saving checkpoint 25...
INFO:tensorflow:Calling checkpoint listeners after saving checkpoint 25...
INFO:tensorflow:Calling model_fn.
INFO:tensorflow:Calling model_fn.
INFO:tensorflow:Done calling model_fn.
INFO:tensorflow:Done calling model_fn.
INFO:tensorflow:Starting evaluation at 2021-01-06T02:31:20Z
INFO:tensorflow:Starting evaluation at 2021-01-06T02:31:20Z
INFO:tensorflow:Graph was finalized.
INFO:tensorflow:Graph was finalized.
INFO:tensorflow:Restoring parameters from /tmp/tmpifj8mysl/model.ckpt-25
INFO:tensorflow:Restoring parameters from /tmp/tmpifj8mysl/model.ckpt-25
INFO:tensorflow:Running local_init_op.
INFO:tensorflow:Running local_init_op.
INFO:tensorflow:Done running local_init_op.
INFO:tensorflow:Done running local_init_op.
INFO:tensorflow:Evaluation [1/5]
INFO:tensorflow:Evaluation [1/5]
INFO:tensorflow:Evaluation [2/5]
INFO:tensorflow:Evaluation [2/5]
INFO:tensorflow:Evaluation [3/5]
INFO:tensorflow:Evaluation [3/5]
INFO:tensorflow:Evaluation [4/5]
INFO:tensorflow:Evaluation [4/5]
INFO:tensorflow:Evaluation [5/5]
INFO:tensorflow:Evaluation [5/5]
INFO:tensorflow:Inference Time : 0.97406s
INFO:tensorflow:Inference Time : 0.97406s
INFO:tensorflow:Finished evaluation at 2021-01-06-02:31:21
INFO:tensorflow:Finished evaluation at 2021-01-06-02:31:21
INFO:tensorflow:Saving dict for global step 25: accuracy = 0.59375, global_step = 25, loss = 1.6248872
INFO:tensorflow:Saving dict for global step 25: accuracy = 0.59375, global_step = 25, loss = 1.6248872
INFO:tensorflow:Saving 'checkpoint_path' summary for global step 25: /tmp/tmpifj8mysl/model.ckpt-25
INFO:tensorflow:Saving 'checkpoint_path' summary for global step 25: /tmp/tmpifj8mysl/model.ckpt-25
INFO:tensorflow:Loss for final step: 0.35726172.
INFO:tensorflow:Loss for final step: 0.35726172.
({'accuracy': 0.59375, 'loss': 1.6248872, 'global_step': 25}, [])

TensorFlow 2.x प्रतीकों के साथ कस्टम model_fn

यदि आप सभी TensorFlow 1.x प्रतीकों से छुटकारा चाहते हैं और अपने कस्टम model_fn को TensorFlow 2.x में अपग्रेड करना चाहते हैं, तो आपको ऑप्टिमाइज़र और मैट्रिक्स को tf.keras.optimizers और tf.keras.metrics

उपरोक्त परिवर्तनों के अलावा कस्टम model_fn , और अधिक उन्नयन किए जाने की आवश्यकता है:

  • उपयोग tf.keras.optimizers के बजाय v1.train.Optimizer
  • स्पष्ट रूप से मॉडल के trainable_variables को tf.keras.optimizers
  • train_op/minimize_op गणना करने के train_op/minimize_op ,
    • Optimizer.get_updates उपयोग करें Optimizer.get_updates यदि हानि स्केलर लॉस Tensor ( Tensor नहीं)। लौटी सूची में पहला तत्व वांछित train_op/minimize_op
    • यदि नुकसान एक train_op/minimize_op करने योग्य है (जैसे कि कोई फ़ंक्शन), तो train_op/minimize_op पाने के लिए Optimizer.minimize का उपयोग Optimizer.minimize
  • का प्रयोग करें tf.keras.metrics बजाय tf.compat.v1.metrics मूल्यांकन के लिए।

my_model_fn के उपरोक्त उदाहरण के लिए, TensorFlow 2.x प्रतीकों वाला माइग्रेटेड कोड निम्नानुसार दिखाया गया है:

def my_model_fn(features, labels, mode):
  model = make_model()

  training = (mode == tf.estimator.ModeKeys.TRAIN)
  loss_obj = tf.keras.losses.SparseCategoricalCrossentropy(from_logits=True)
  predictions = model(features, training=training)

  # Get both the unconditional losses (the None part)
  # and the input-conditional losses (the features part).
  reg_losses = model.get_losses_for(None) + model.get_losses_for(features)
  total_loss=loss_obj(labels, predictions) + tf.math.add_n(reg_losses)

  # Upgrade to tf.keras.metrics.
  accuracy_obj = tf.keras.metrics.Accuracy(name='acc_obj')
  accuracy = accuracy_obj.update_state(
      y_true=labels, y_pred=tf.math.argmax(predictions, axis=1))

  train_op = None
  if training:
    # Upgrade to tf.keras.optimizers.
    optimizer = tf.keras.optimizers.Adam()
    # Manually assign tf.compat.v1.global_step variable to optimizer.iterations
    # to make tf.compat.v1.train.global_step increased correctly.
    # This assignment is a must for any `tf.train.SessionRunHook` specified in
    # estimator, as SessionRunHooks rely on global step.
    optimizer.iterations = tf.compat.v1.train.get_or_create_global_step()
    # Get both the unconditional updates (the None part)
    # and the input-conditional updates (the features part).
    update_ops = model.get_updates_for(None) + model.get_updates_for(features)
    # Compute the minimize_op.
    minimize_op = optimizer.get_updates(
        total_loss,
        model.trainable_variables)[0]
    train_op = tf.group(minimize_op, *update_ops)

  return tf.estimator.EstimatorSpec(
    mode=mode,
    predictions=predictions,
    loss=total_loss,
    train_op=train_op,
    eval_metric_ops={'Accuracy': accuracy_obj})

# Create the Estimator and train.
estimator = tf.estimator.Estimator(model_fn=my_model_fn)
tf.estimator.train_and_evaluate(estimator, train_spec, eval_spec)
INFO:tensorflow:Using default config.
INFO:tensorflow:Using default config.
WARNING:tensorflow:Using temporary folder as model directory: /tmp/tmpc93qfnv6
WARNING:tensorflow:Using temporary folder as model directory: /tmp/tmpc93qfnv6
INFO:tensorflow:Using config: {'_model_dir': '/tmp/tmpc93qfnv6', '_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:Using config: {'_model_dir': '/tmp/tmpc93qfnv6', '_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:Not using Distribute Coordinator.
INFO:tensorflow:Not using Distribute Coordinator.
INFO:tensorflow:Running training and evaluation locally (non-distributed).
INFO:tensorflow:Running training and evaluation locally (non-distributed).
INFO:tensorflow:Start train and evaluate loop. The evaluate will happen after every checkpoint. Checkpoint frequency is determined based on RunConfig arguments: save_checkpoints_steps None or save_checkpoints_secs 600.
INFO:tensorflow:Start train and evaluate loop. The evaluate will happen after every checkpoint. Checkpoint frequency is determined based on RunConfig arguments: save_checkpoints_steps None or save_checkpoints_secs 600.
INFO:tensorflow:Calling model_fn.
INFO:tensorflow:Calling model_fn.
INFO:tensorflow:Done calling model_fn.
INFO:tensorflow:Done calling model_fn.
INFO:tensorflow:Create CheckpointSaverHook.
INFO:tensorflow:Create CheckpointSaverHook.
INFO:tensorflow:Graph was finalized.
INFO:tensorflow:Graph was finalized.
INFO:tensorflow:Running local_init_op.
INFO:tensorflow:Running local_init_op.
INFO:tensorflow:Done running local_init_op.
INFO:tensorflow:Done running local_init_op.
INFO:tensorflow:Calling checkpoint listeners before saving checkpoint 0...
INFO:tensorflow:Calling checkpoint listeners before saving checkpoint 0...
INFO:tensorflow:Saving checkpoints for 0 into /tmp/tmpc93qfnv6/model.ckpt.
INFO:tensorflow:Saving checkpoints for 0 into /tmp/tmpc93qfnv6/model.ckpt.
INFO:tensorflow:Calling checkpoint listeners after saving checkpoint 0...
INFO:tensorflow:Calling checkpoint listeners after saving checkpoint 0...
INFO:tensorflow:loss = 2.5293791, step = 0
INFO:tensorflow:loss = 2.5293791, step = 0
INFO:tensorflow:Calling checkpoint listeners before saving checkpoint 25...
INFO:tensorflow:Calling checkpoint listeners before saving checkpoint 25...
INFO:tensorflow:Saving checkpoints for 25 into /tmp/tmpc93qfnv6/model.ckpt.
INFO:tensorflow:Saving checkpoints for 25 into /tmp/tmpc93qfnv6/model.ckpt.
INFO:tensorflow:Calling checkpoint listeners after saving checkpoint 25...
INFO:tensorflow:Calling checkpoint listeners after saving checkpoint 25...
INFO:tensorflow:Calling model_fn.
INFO:tensorflow:Calling model_fn.
INFO:tensorflow:Done calling model_fn.
INFO:tensorflow:Done calling model_fn.
INFO:tensorflow:Starting evaluation at 2021-01-06T02:31:24Z
INFO:tensorflow:Starting evaluation at 2021-01-06T02:31:24Z
INFO:tensorflow:Graph was finalized.
INFO:tensorflow:Graph was finalized.
INFO:tensorflow:Restoring parameters from /tmp/tmpc93qfnv6/model.ckpt-25
INFO:tensorflow:Restoring parameters from /tmp/tmpc93qfnv6/model.ckpt-25
INFO:tensorflow:Running local_init_op.
INFO:tensorflow:Running local_init_op.
INFO:tensorflow:Done running local_init_op.
INFO:tensorflow:Done running local_init_op.
INFO:tensorflow:Evaluation [1/5]
INFO:tensorflow:Evaluation [1/5]
INFO:tensorflow:Evaluation [2/5]
INFO:tensorflow:Evaluation [2/5]
INFO:tensorflow:Evaluation [3/5]
INFO:tensorflow:Evaluation [3/5]
INFO:tensorflow:Evaluation [4/5]
INFO:tensorflow:Evaluation [4/5]
INFO:tensorflow:Evaluation [5/5]
INFO:tensorflow:Evaluation [5/5]
INFO:tensorflow:Inference Time : 0.86534s
INFO:tensorflow:Inference Time : 0.86534s
INFO:tensorflow:Finished evaluation at 2021-01-06-02:31:25
INFO:tensorflow:Finished evaluation at 2021-01-06-02:31:25
INFO:tensorflow:Saving dict for global step 25: Accuracy = 0.59375, global_step = 25, loss = 1.7570661
INFO:tensorflow:Saving dict for global step 25: Accuracy = 0.59375, global_step = 25, loss = 1.7570661
INFO:tensorflow:Saving 'checkpoint_path' summary for global step 25: /tmp/tmpc93qfnv6/model.ckpt-25
INFO:tensorflow:Saving 'checkpoint_path' summary for global step 25: /tmp/tmpc93qfnv6/model.ckpt-25
INFO:tensorflow:Loss for final step: 0.47094986.
INFO:tensorflow:Loss for final step: 0.47094986.
({'Accuracy': 0.59375, 'loss': 1.7570661, 'global_step': 25}, [])

प्रेमाडे अनुमानक

tf.estimator.DNN* , tf.estimator.Linear* और tf.estimator.DNNLinearCombined* के परिवार में tf.estimator.DNN* अनुमानक अभी भी TensorFlow --x API में समर्थित हैं। हालाँकि, कुछ तर्क बदल गए हैं:

  1. input_layer_partitioner : v2 में निकाला गया।
  2. loss_reduction : पर अपडेट किया गया tf.keras.losses.Reduction बजाय tf.compat.v1.losses.Reduction । इसका डिफ़ॉल्ट मान भी tf.keras.losses.Reduction.SUM_OVER_BATCH_SIZE से tf.compat.v1.losses.Reduction.SUM बदल दिया गया है।
  3. optimizer , dnn_optimizer और linear_optimizer : इस तर्क को अद्यतन किया गया है tf.keras.optimizers के बजाय tf.compat.v1.train.Optimizer

उपरोक्त परिवर्तनों को माइग्रेट करने के लिए:

  1. input_layer_partitioner लिए किसी माइग्रेशन की आवश्यकता नहीं है क्योंकि Distribution Strategy TensorFlow 2.x में स्वचालित रूप से इसे संभाल लेगी।
  2. के लिए loss_reduction , जाँच tf.keras.losses.Reduction समर्थित विकल्प के लिए।
  3. optimizer तर्क के लिए:
    • यदि आप नहीं करते हैं: 1) optimizer में पास करें, dnn_optimizer या linear_optimizer तर्क, या 2) अपने कोड में string रूप में optimizer तर्क निर्दिष्ट करें, तो आपको कुछ भी बदलने की आवश्यकता नहीं है क्योंकि tf.keras.optimizers डिफ़ॉल्ट रूप से उपयोग किया जाता है ।
    • अन्यथा, आपको इसे tf.compat.v1.train.Optimizer से इसके संबंधित tf.keras.optimizers पर अपडेट करना होगा।

चेकपॉइंट कनवर्टर

keras.optimizers लिए माइग्रेशन TensorFlow 1.x का उपयोग करके सहेजी गई चौकियों को तोड़ देगा, क्योंकि tf.keras.optimizers चौकियों में सहेजे जाने के लिए चर का एक अलग सेट उत्पन्न करता है। TensorFlow 2.x पर अपने प्रवास के बाद पुराने चेकपॉइंट को पुन: प्रयोज्य बनाने के लिए, चेकपॉइंट कनवर्टर उपकरण का प्रयास करें।

 curl -O https://raw.githubusercontent.com/tensorflow/estimator/master/tensorflow_estimator/python/estimator/tools/checkpoint_converter.py
% Total    % Received % Xferd  Average Speed   Time    Time     Time  Current
                                 Dload  Upload   Total   Spent    Left  Speed
100 15165  100 15165    0     0  40656      0 --:--:-- --:--:-- --:--:-- 40656

उपकरण में अंतर्निहित मदद है:

 python checkpoint_converter.py -h
2021-01-06 02:31:26.297951: I tensorflow/stream_executor/platform/default/dso_loader.cc:49] Successfully opened dynamic library libcudart.so.11.0
usage: checkpoint_converter.py [-h]
                               {dnn,linear,combined} source_checkpoint
                               source_graph target_checkpoint

positional arguments:
  {dnn,linear,combined}
                        The type of estimator to be converted. So far, the
                        checkpoint converter only supports Canned Estimator.
                        So the allowed types include linear, dnn and combined.
  source_checkpoint     Path to source checkpoint file to be read in.
  source_graph          Path to source graph file to be read in.
  target_checkpoint     Path to checkpoint file to be written out.

optional arguments:
  -h, --help            show this help message and exit

टेनसॉरशेप

इस वर्ग को tf.compat.v1.Dimension ऑब्जेक्ट्स के बजाय int s पकड़ना सरल बनाया गया था। तो एक int पाने के लिए .value को कॉल करने की कोई आवश्यकता नहीं है।

व्यक्तिगत tf.compat.v1.Dimension वस्तुएं अभी भी tf.TensorShape.dims से सुलभ हैं।

निम्नलिखित TensorFlow 1.x और TensorFlow 2.x के बीच अंतर प्रदर्शित करता है।

# Create a shape and choose an index
i = 0
shape = tf.TensorShape([16, None, 256])
shape
TensorShape([16, None, 256])

यदि आपके पास TensorFlow 1.x में यह है:

value = shape[i].value

फिर TensorFlow 2.x में ऐसा करें:

value = shape[i]
value
16

यदि आपके पास TensorFlow 1.x में यह है:

for dim in shape:
    value = dim.value
    print(value)

फिर TensorFlow 2.x में ऐसा करें:

for value in shape:
  print(value)
16
None
256

यदि आपके पास TensorFlow 1.x में यह है (या किसी अन्य आयाम विधि का उपयोग किया है):

dim = shape[i]
dim.assert_is_compatible_with(other_dim)

फिर TensorFlow 2.x में ऐसा करें:

other_dim = 16
Dimension = tf.compat.v1.Dimension

if shape.rank is None:
  dim = Dimension(None)
else:
  dim = shape.dims[i]
dim.is_compatible_with(other_dim) # or any other dimension method
True
shape = tf.TensorShape(None)

if shape:
  dim = shape.dims[i]
  dim.is_compatible_with(other_dim) # or any other dimension method

एक tf.TensorShape का बूलियन मूल्य True यदि रैंक ज्ञात है, तो False है।

print(bool(tf.TensorShape([])))      # Scalar
print(bool(tf.TensorShape([0])))     # 0-length vector
print(bool(tf.TensorShape([1])))     # 1-length vector
print(bool(tf.TensorShape([None])))  # Unknown-length vector
print(bool(tf.TensorShape([1, 10, 100])))       # 3D tensor
print(bool(tf.TensorShape([None, None, None]))) # 3D tensor with no known dimensions
print()
print(bool(tf.TensorShape(None)))  # A tensor with unknown rank.
True
True
True
True
True
True

False

अन्य परिवर्तन

  • निकालें tf.colocate_with : TensorFlow के डिवाइस प्लेसमेंट एल्गोरिदम में काफी सुधार हुआ है। यह अब आवश्यक नहीं होना चाहिए। यदि इसे हटाने से प्रदर्शन में कमी होती है तो कृपया बग दर्ज करें

  • v1.ConfigProto उपयोग v1.ConfigProto के समतुल्य कार्यों से tf.config

निष्कर्ष

समग्र प्रक्रिया है:

  1. नवीनीकरण स्क्रिप्ट चलाएँ।
  2. विरोधाभास प्रतीकों को निकालें।
  3. अपने मॉडल को ऑब्जेक्ट ओरिएंटेड स्टाइल (Keras) पर स्विच करें।
  4. जहाँ आप कर सकते हैं tf.keras या tf.estimator प्रशिक्षण और मूल्यांकन छोरों का उपयोग करें।
  5. अन्यथा, कस्टम लूप का उपयोग करें, लेकिन सत्र और संग्रह से बचने के लिए सुनिश्चित करें।

कोड को मुहावरेदार TensorFlow 2.x में बदलने में थोड़ा काम लगता है, लेकिन हर परिवर्तन में परिणाम होता है:

  • कोड की कम लाइनें।
  • स्पष्टता और सरलता में वृद्धि।
  • आसान डिबगिंग।