इस पेज का अनुवाद Cloud Translation API से किया गया है.

प्रभावी टेंसरफ़्लो 2

TensorFlow.org पर देखें

Google Colab में चलाएं

गिटहब पर देखें

नोटबुक डाउनलोड करें

अवलोकन

यह मार्गदर्शिका TensorFlow 2 (TF2) का उपयोग करके कोड लिखने के सर्वोत्तम अभ्यासों की एक सूची प्रदान करती है, यह उन उपयोगकर्ताओं के लिए लिखा गया है जिन्होंने हाल ही में TensorFlow 1 (TF1) से स्विच किया है। अपने TF1 कोड को TF2 में माइग्रेट करने के बारे में अधिक जानकारी के लिए मार्गदर्शिका के माइग्रेट अनुभाग देखें।

सेट अप

इस गाइड में उदाहरणों के लिए TensorFlow और अन्य निर्भरताएँ आयात करें।

import tensorflow as tf
import tensorflow_datasets as tfds

मुहावरेदार TensorFlow 2 के लिए अनुशंसाएँ

अपने कोड को छोटे मॉड्यूल में रिफलेक्टर करें

एक अच्छा अभ्यास यह है कि आप अपने कोड को छोटे कार्यों में पुन: सक्रिय करें जिन्हें आवश्यकतानुसार कहा जाता है। सर्वोत्तम प्रदर्शन के लिए, आपको गणना के सबसे बड़े ब्लॉक को सजाने की कोशिश करनी चाहिए जो आप tf.function में कर सकते हैं (ध्यान दें कि tf.function द्वारा बुलाए गए नेस्टेड पायथन फ़ंक्शंस को अपनी अलग सजावट की आवश्यकता नहीं होती है, जब तक कि आप अलग-अलग jit_compile का उपयोग नहीं करना चाहते। tf.function के लिए सेटिंग्स)। आपके उपयोग के मामले के आधार पर, यह कई प्रशिक्षण चरण या यहां तक कि आपका संपूर्ण प्रशिक्षण लूप भी हो सकता है। अनुमान के उपयोग के मामलों के लिए, यह एक एकल मॉडल फॉरवर्ड पास हो सकता है।

कुछ `tf.keras.optimizer` s . के लिए डिफ़ॉल्ट सीखने की दर को समायोजित करें

कुछ Keras अनुकूलकों की TF2 में सीखने की दर भिन्न होती है। यदि आप अपने मॉडलों के लिए अभिसरण व्यवहार में परिवर्तन देखते हैं, तो डिफ़ॉल्ट सीखने की दरों की जाँच करें।

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

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

optimizers.Adagrad । 0.01 से 0.001 . तक एडग्रेड
optimizers.Adadelta 1.0 से 0.001 . तक
optimizers.Adamax । 0.002 से 0.001 . तक एडमैक्स
optimizers.Nadam । 0.002 से 0.001 . तक

चरों को प्रबंधित करने के लिए `tf.Module` s और Keras परतों का उपयोग करें

tf.Module s और tf.keras.layers.Layer s सुविधाजनक variables और trainable_variables गुण प्रदान करते हैं, जो सभी आश्रित चर को पुनरावर्ती रूप से इकट्ठा करते हैं। इससे वेरिएबल को स्थानीय रूप से उस स्थान पर प्रबंधित करना आसान हो जाता है जहां उनका उपयोग किया जा रहा है।

Keras परतें/मॉडल tf.train.Checkpointable से विरासत में मिली हैं और @tf.function के साथ एकीकृत हैं, जो Keras ऑब्जेक्ट्स से सीधे चेकपॉइंट या सहेजे गए मॉडल को निर्यात करना संभव बनाता है। इन एकीकरणों का लाभ उठाने के लिए जरूरी नहीं कि आपको Keras के Model.fit API का उपयोग करना पड़े।

केरस गाइड में ट्रांसफर लर्निंग और फाइन-ट्यूनिंग पर अनुभाग पढ़ें और सीखें कि केरस का उपयोग करके प्रासंगिक चर का एक सबसेट कैसे एकत्र किया जाए।

`tf.data.Dataset` s और `tf.function` को मिलाएं

TensorFlow डेटासेट पैकेज ( 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']

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

प्रत्येक छवि को फिर से स्केल करें।
उदाहरणों के क्रम में फेरबदल करें।
छवियों और लेबलों के बैच एकत्र करें।

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

2021-12-08 17:15:01.637157: W tensorflow/core/kernels/data/cache_dataset_ops.cc:768] The calling iterator did not fully read the dataset being cached. In order to avoid unexpected truncation of the dataset, the partially cached contents of the dataset  will be discarded. This can happen if you have an input pipeline similar to `dataset.cache().take(k).repeat()`. You should use `dataset.take(k).cache().repeat()` instead.

स्मृति में फिट होने वाले प्रशिक्षण डेटा पर पुनरावृति करने के लिए नियमित पायथन पुनरावृत्ति का उपयोग करें। अन्यथा, tf.data.Dataset डिस्क से प्रशिक्षण डेटा स्ट्रीम करने का सबसे अच्छा तरीका है। डेटासेट पुनरावर्तनीय हैं (पुनरावर्तक नहीं) , और उत्सुक निष्पादन में अन्य पायथन पुनरावृत्तियों की तरह ही काम करते हैं। आप अपने कोड को tf.function में लपेटकर डेटासेट एसिंक प्रीफ़ेचिंग/स्ट्रीमिंग सुविधाओं का पूरी तरह से उपयोग कर सकते हैं, जो ऑटोग्राफ का उपयोग करके समान ग्राफ संचालन के साथ पायथन पुनरावृत्ति को प्रतिस्थापित करता है।

@tf.function
def train(model, dataset, optimizer):
  for x, y in dataset:
    with tf.GradientTape() as tape:
      # training=True is only needed if there are layers with different
      # behavior during training versus inference (e.g. Dropout).
      prediction = model(x, training=True)
      loss = loss_fn(prediction, y)
    gradients = tape.gradient(loss, model.trainable_variables)
    optimizer.apply_gradients(zip(gradients, model.trainable_variables))

यदि आप Model.fit API का उपयोग करते हैं, तो आपको डेटासेट पुनरावृत्ति के बारे में चिंता करने की आवश्यकता नहीं होगी।

model.compile(optimizer=optimizer, loss=loss_fn)
model.fit(dataset)

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

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

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

वे Numpy arrays, Python जनरेटर और, 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 [==============================] - 9s 7ms/step - loss: 1.5762 - accuracy: 0.4938
Epoch 2/5
2021-12-08 17:15:11.145429: W tensorflow/core/kernels/data/cache_dataset_ops.cc:768] The calling iterator did not fully read the dataset being cached. In order to avoid unexpected truncation of the dataset, the partially cached contents of the dataset  will be discarded. This can happen if you have an input pipeline similar to `dataset.cache().take(k).repeat()`. You should use `dataset.take(k).cache().repeat()` instead.
5/5 [==============================] - 0s 6ms/step - loss: 0.5087 - accuracy: 0.8969
Epoch 3/5
2021-12-08 17:15:11.559374: W tensorflow/core/kernels/data/cache_dataset_ops.cc:768] The calling iterator did not fully read the dataset being cached. In order to avoid unexpected truncation of the dataset, the partially cached contents of the dataset  will be discarded. This can happen if you have an input pipeline similar to `dataset.cache().take(k).repeat()`. You should use `dataset.take(k).cache().repeat()` instead.
5/5 [==============================] - 2s 5ms/step - loss: 0.3348 - accuracy: 0.9469
Epoch 4/5
2021-12-08 17:15:13.860407: W tensorflow/core/kernels/data/cache_dataset_ops.cc:768] The calling iterator did not fully read the dataset being cached. In order to avoid unexpected truncation of the dataset, the partially cached contents of the dataset  will be discarded. This can happen if you have an input pipeline similar to `dataset.cache().take(k).repeat()`. You should use `dataset.take(k).cache().repeat()` instead.
5/5 [==============================] - 0s 5ms/step - loss: 0.2445 - accuracy: 0.9688
Epoch 5/5
2021-12-08 17:15:14.269850: W tensorflow/core/kernels/data/cache_dataset_ops.cc:768] The calling iterator did not fully read the dataset being cached. In order to avoid unexpected truncation of the dataset, the partially cached contents of the dataset  will be discarded. This can happen if you have an input pipeline similar to `dataset.cache().take(k).repeat()`. You should use `dataset.take(k).cache().repeat()` instead.
5/5 [==============================] - 0s 6ms/step - loss: 0.2006 - accuracy: 0.9719
2021-12-08 17:15:14.717552: W tensorflow/core/kernels/data/cache_dataset_ops.cc:768] The calling iterator did not fully read the dataset being cached. In order to avoid unexpected truncation of the dataset, the partially cached contents of the dataset  will be discarded. This can happen if you have an input pipeline similar to `dataset.cache().take(k).repeat()`. You should use `dataset.take(k).cache().repeat()` instead.
5/5 [==============================] - 1s 4ms/step - loss: 1.4553 - accuracy: 0.5781
Loss 1.4552843570709229, Accuracy 0.578125
2021-12-08 17:15:15.862684: W tensorflow/core/kernels/data/cache_dataset_ops.cc:768] The calling iterator did not fully read the dataset being cached. In order to avoid unexpected truncation of the dataset, the partially cached contents of the dataset  will be discarded. This can happen if you have an input pipeline similar to `dataset.cache().take(k).repeat()`. You should use `dataset.take(k).cache().repeat()` instead.

प्रशिक्षण को अनुकूलित करें और अपना स्वयं का लूप लिखें

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

आप कई चीजों को tf.keras.callbacks.Callback के रूप में भी लागू कर सकते हैं।

इस पद्धति में पहले बताए गए कई फायदे हैं, लेकिन यह आपको ट्रेन के कदम और यहां तक कि बाहरी लूप पर भी नियंत्रण देता है।

एक मानक प्रशिक्षण लूप के तीन चरण हैं:

उदाहरणों के बैच प्राप्त करने के लिए पायथन जनरेटर या tf.data.Dataset पर पुनरावृति करें।
ग्रेडिएंट एकत्र करने के लिए tf.GradientTape का उपयोग करें।
मॉडल के वेरिएबल में वज़न अपडेट लागू करने के लिए tf.keras.optimizers में से किसी एक का उपयोग करें।

याद रखना:

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

परिवर्तनीय प्रारंभकर्ता चलाने या मैन्युअल नियंत्रण निर्भरता जोड़ने की कोई आवश्यकता नहीं है। 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)

2021-12-08 17:15:16.714849: W tensorflow/core/kernels/data/cache_dataset_ops.cc:768] The calling iterator did not fully read the dataset being cached. In order to avoid unexpected truncation of the dataset, the partially cached contents of the dataset  will be discarded. This can happen if you have an input pipeline similar to `dataset.cache().take(k).repeat()`. You should use `dataset.take(k).cache().repeat()` instead.
Finished epoch 0
2021-12-08 17:15:17.097043: W tensorflow/core/kernels/data/cache_dataset_ops.cc:768] The calling iterator did not fully read the dataset being cached. In order to avoid unexpected truncation of the dataset, the partially cached contents of the dataset  will be discarded. This can happen if you have an input pipeline similar to `dataset.cache().take(k).repeat()`. You should use `dataset.take(k).cache().repeat()` instead.
Finished epoch 1
2021-12-08 17:15:17.502480: W tensorflow/core/kernels/data/cache_dataset_ops.cc:768] The calling iterator did not fully read the dataset being cached. In order to avoid unexpected truncation of the dataset, the partially cached contents of the dataset  will be discarded. This can happen if you have an input pipeline similar to `dataset.cache().take(k).repeat()`. You should use `dataset.take(k).cache().repeat()` instead.
Finished epoch 2
2021-12-08 17:15:17.873701: W tensorflow/core/kernels/data/cache_dataset_ops.cc:768] The calling iterator did not fully read the dataset being cached. In order to avoid unexpected truncation of the dataset, the partially cached contents of the dataset  will be discarded. This can happen if you have an input pipeline similar to `dataset.cache().take(k).repeat()`. You should use `dataset.take(k).cache().repeat()` instead.
Finished epoch 3
Finished epoch 4
2021-12-08 17:15:18.344196: W tensorflow/core/kernels/data/cache_dataset_ops.cc:768] The calling iterator did not fully read the dataset being cached. In order to avoid unexpected truncation of the dataset, the partially cached contents of the dataset  will be discarded. This can happen if you have an input pipeline similar to `dataset.cache().take(k).repeat()`. You should use `dataset.take(k).cache().repeat()` instead.

पायथन नियंत्रण प्रवाह के साथ `tf.function` का लाभ उठाएं

tf.function डेटा-निर्भर नियंत्रण प्रवाह को tf.cond और tf. tf.while_loop जैसे ग्राफ़-मोड समकक्षों में परिवर्तित करने का एक तरीका प्रदान करता है।

अनुक्रम मॉडल में एक सामान्य स्थान जहां डेटा-निर्भर नियंत्रण प्रवाह दिखाई देता है। tf.keras.layers.RNN एक आरएनएन सेल को लपेटता है, जिससे आप पुनरावृत्ति को स्थिर या गतिशील रूप से अनियंत्रित कर सकते हैं। एक उदाहरण के रूप में, आप निम्नानुसार डायनेमिक अनरोल को फिर से लागू कर सकते हैं।

class DynamicRNN(tf.keras.Model):

  def __init__(self, rnn_cell):
    super(DynamicRNN, self).__init__(self)
    self.cell = rnn_cell

  @tf.function(input_signature=[tf.TensorSpec(dtype=tf.float32, shape=[None, None, 3])])
  def call(self, input_data):

    # [batch, time, features] -> [time, batch, features]
    input_data = tf.transpose(input_data, [1, 0, 2])
    timesteps =  tf.shape(input_data)[0]
    batch_size = tf.shape(input_data)[1]
    outputs = tf.TensorArray(tf.float32, timesteps)
    state = self.cell.get_initial_state(batch_size = batch_size, dtype=tf.float32)
    for i in tf.range(timesteps):
      output, state = self.cell(input_data[i], state)
      outputs = outputs.write(i, output)
    return tf.transpose(outputs.stack(), [1, 0, 2]), state

lstm_cell = tf.keras.layers.LSTMCell(units = 13)

my_rnn = DynamicRNN(lstm_cell)
outputs, state = my_rnn(tf.random.normal(shape=[10,20,3]))
print(outputs.shape)

(10, 20, 13)

अधिक जानकारी के लिए tf.function गाइड पढ़ें।

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

मेट्रिक्स और नुकसान दोनों वस्तुएं हैं जो उत्सुकता से और 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

प्लेसहोल्डर17

डेटा एकत्र करने और प्रदर्शित करने के लिए मीट्रिक का उपयोग करें

आप डेटा एकत्र करने के लिए tf.summary और सारांश लॉग करने के लिए tf.metrics का उपयोग कर सकते हैं और संदर्भ प्रबंधक का उपयोग करके इसे किसी लेखक को रीडायरेक्ट कर सकते हैं। सारांश सीधे लेखक को भेजे जाते हैं, जिसका अर्थ है कि आपको कॉलसाइट पर step मान प्रदान करना होगा।

summary_writer = tf.summary.create_file_writer('/tmp/summaries')
with summary_writer.as_default():
  tf.summary.scalar('loss', 0.1, step=42)

डेटा को सारांश के रूप में लॉग इन करने से पहले tf.metrics को एकत्रित करने के लिए उपयोग करें। मेट्रिक्स स्टेटफुल हैं; जब आप result विधि (जैसे Mean.result ) को कॉल करते हैं तो वे मान जमा करते हैं और एक संचयी परिणाम लौटाते हैं। Model.reset_states के साथ संचित मान साफ़ करें।

def train(model, optimizer, dataset, log_freq=10):
  avg_loss = tf.keras.metrics.Mean(name='loss', dtype=tf.float32)
  for images, labels in dataset:
    loss = train_step(model, optimizer, images, labels)
    avg_loss.update_state(loss)
    if tf.equal(optimizer.iterations % log_freq, 0):
      tf.summary.scalar('loss', avg_loss.result(), step=optimizer.iterations)
      avg_loss.reset_states()

def test(model, test_x, test_y, step_num):
  # training=False is only needed if there are layers with different
  # behavior during training versus inference (e.g. Dropout).
  loss = loss_fn(model(test_x, training=False), test_y)
  tf.summary.scalar('loss', loss, step=step_num)

train_summary_writer = tf.summary.create_file_writer('/tmp/summaries/train')
test_summary_writer = tf.summary.create_file_writer('/tmp/summaries/test')

with train_summary_writer.as_default():
  train(model, optimizer, dataset)

with test_summary_writer.as_default():
  test(model, test_x, test_y, optimizer.iterations)

TensorBoard को सारांश लॉग निर्देशिका की ओर इंगित करके जनरेट किए गए सारांश की कल्पना करें:

tensorboard --logdir /tmp/summaries

TensorBoard में विज़ुअलाइज़ेशन के लिए सारांश डेटा लिखने के लिए tf.summary API का उपयोग करें। अधिक जानकारी के लिए, tf.summary मार्गदर्शिका पढ़ें।

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

2021-12-08 17:15:19.339736: W tensorflow/core/kernels/data/cache_dataset_ops.cc:768] The calling iterator did not fully read the dataset being cached. In order to avoid unexpected truncation of the dataset, the partially cached contents of the dataset  will be discarded. This can happen if you have an input pipeline similar to `dataset.cache().take(k).repeat()`. You should use `dataset.take(k).cache().repeat()` instead.
Epoch:  0
  loss:     0.142
  accuracy: 0.991
2021-12-08 17:15:19.781743: W tensorflow/core/kernels/data/cache_dataset_ops.cc:768] The calling iterator did not fully read the dataset being cached. In order to avoid unexpected truncation of the dataset, the partially cached contents of the dataset  will be discarded. This can happen if you have an input pipeline similar to `dataset.cache().take(k).repeat()`. You should use `dataset.take(k).cache().repeat()` instead.
Epoch:  1
  loss:     0.125
  accuracy: 0.997
2021-12-08 17:15:20.219033: W tensorflow/core/kernels/data/cache_dataset_ops.cc:768] The calling iterator did not fully read the dataset being cached. In order to avoid unexpected truncation of the dataset, the partially cached contents of the dataset  will be discarded. This can happen if you have an input pipeline similar to `dataset.cache().take(k).repeat()`. You should use `dataset.take(k).cache().repeat()` instead.
Epoch:  2
  loss:     0.110
  accuracy: 0.997
2021-12-08 17:15:20.598085: W tensorflow/core/kernels/data/cache_dataset_ops.cc:768] The calling iterator did not fully read the dataset being cached. In order to avoid unexpected truncation of the dataset, the partially cached contents of the dataset  will be discarded. This can happen if you have an input pipeline similar to `dataset.cache().take(k).repeat()`. You should use `dataset.take(k).cache().repeat()` instead.
Epoch:  3
  loss:     0.099
  accuracy: 0.997
Epoch:  4
  loss:     0.085
  accuracy: 1.000
2021-12-08 17:15:20.981787: W tensorflow/core/kernels/data/cache_dataset_ops.cc:768] The calling iterator did not fully read the dataset being cached. In order to avoid unexpected truncation of the dataset, the partially cached contents of the dataset  will be discarded. This can happen if you have an input pipeline similar to `dataset.cache().take(k).repeat()`. You should use `dataset.take(k).cache().repeat()` instead.

प्लेसहोल्डर22

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

केरस मॉडल मीट्रिक नामों को संभालने के अनुरूप हैं। जब आप मीट्रिक की सूची में एक स्ट्रिंग पास करते हैं, तो उस सटीक स्ट्रिंग का उपयोग मीट्रिक के name के रूप में किया जाता है। ये नाम मॉडल.फिट द्वारा लौटाए गए इतिहास ऑब्जेक्ट में और model.fit को 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 5ms/step - loss: 0.0963 - acc: 0.9969 - accuracy: 0.9969 - my_accuracy: 0.9969
2021-12-08 17:15:21.942940: W tensorflow/core/kernels/data/cache_dataset_ops.cc:768] The calling iterator did not fully read the dataset being cached. In order to avoid unexpected truncation of the dataset, the partially cached contents of the dataset  will be discarded. This can happen if you have an input pipeline similar to `dataset.cache().take(k).repeat()`. You should use `dataset.take(k).cache().repeat()` instead.

history.history.keys()

dict_keys(['loss', 'acc', 'accuracy', 'my_accuracy'])

डिबगिंग

आकृतियों, डेटा प्रकारों और मूल्यों का निरीक्षण करने के लिए अपने कोड को चरण-दर-चरण चलाने के लिए उत्सुक निष्पादन का उपयोग करें। कुछ एपीआई, जैसे tf.function , tf.keras , आदि को प्रदर्शन और पोर्टेबिलिटी के लिए ग्राफ़ निष्पादन का उपयोग करने के लिए डिज़ाइन किया गया है। डिबगिंग करते समय, इस कोड के अंदर उत्सुक निष्पादन का उपयोग करने के लिए tf.config.run_functions_eagerly(True) का उपयोग करें।

उदाहरण के लिए:

@tf.function
def f(x):
  if x > 0:
    import pdb
    pdb.set_trace()
    x = x + 1
  return x

tf.config.run_functions_eagerly(True)
f(tf.constant(1))

>>> f()
-> x = x + 1
(Pdb) l
  6     @tf.function
  7     def f(x):
  8       if x > 0:
  9         import pdb
 10         pdb.set_trace()
 11  ->     x = x + 1
 12       return x
 13
 14     tf.config.run_functions_eagerly(True)
 15     f(tf.constant(1))
[EOF]

यह केरस मॉडल और अन्य एपीआई के अंदर भी काम करता है जो उत्सुक निष्पादन का समर्थन करते हैं:

class CustomModel(tf.keras.models.Model):

  @tf.function
  def call(self, input_data):
    if tf.reduce_mean(input_data) > 0:
      return input_data
    else:
      import pdb
      pdb.set_trace()
      return input_data // 2


tf.config.run_functions_eagerly(True)
model = CustomModel()
model(tf.constant([-2, -4]))

>>> call()
-> return input_data // 2
(Pdb) l
 10         if tf.reduce_mean(input_data) > 0:
 11           return input_data
 12         else:
 13           import pdb
 14           pdb.set_trace()
 15  ->       return input_data // 2
 16
 17
 18     tf.config.run_functions_eagerly(True)
 19     model = CustomModel()
 20     model(tf.constant([-2, -4]))

टिप्पणियाँ:

tf.keras.Model विधियाँ जैसे fit , evaluate , और ग्राफ़ के रूप में निष्पादन की predict tf.function के साथ हुड के नीचे।
tf.keras.Model.compile का उपयोग करते समय, Model तर्क को tf.function में लपेटे जाने से अक्षम करने के लिए run_eagerly = True सेट करें।
tf.data.experimental.enable_debug_mode के लिए डिबग मोड को सक्षम करने के लिए tf.data का उपयोग करें। अधिक जानकारी के लिए API दस्तावेज़ पढ़ें।

अपनी वस्तुओं में `tf.Tensors` न रखें

ये टेंसर ऑब्जेक्ट या तो tf.function या उत्सुक संदर्भ में बनाए जा सकते हैं, और ये टेंसर अलग तरह से व्यवहार करते हैं। हमेशा मध्यवर्ती मानों के लिए tf.Tensor s का उपयोग करें।

स्थिति को ट्रैक करने के लिए, tf.Variable s का उपयोग करें क्योंकि वे दोनों संदर्भों से हमेशा प्रयोग करने योग्य होते हैं। अधिक जानने के लिए tf.Variable मार्गदर्शिका पढ़ें।

संसाधन और आगे पढ़ना

TF2 का उपयोग करने के तरीके के बारे में अधिक जानने के लिए TF2 गाइड और ट्यूटोरियल पढ़ें।
यदि आपने पहले TF1.x का उपयोग किया है, तो यह अत्यधिक अनुशंसा की जाती है कि आप अपने कोड को TF2 में माइग्रेट करें। अधिक जानने के लिए प्रवासन मार्गदर्शिकाएँ पढ़ें।