अनुमानक से केरस एपीआई में माइग्रेट करें

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

यह मार्गदर्शिका दर्शाती है कि कैसे TensorFlow 1 के tf.estimator.Estimator API से TensorFlow 2 के tf.keras API में माइग्रेट किया जाए। सबसे पहले, आप tf.estimator.Estimator के साथ प्रशिक्षण और मूल्यांकन के लिए एक बुनियादी मॉडल स्थापित और चलाएंगे। फिर, आप tf.keras API के साथ TensorFlow 2 में समान चरणों का प्रदर्शन करेंगे। आप यह भी सीखेंगे कि tf.keras.Model को उपवर्गित करके और tf.keras.Model का उपयोग करके प्रशिक्षण चरण को कैसे अनुकूलित किया tf.GradientTape ।

  • TensorFlow 1 में, उच्च-स्तरीय tf.estimator.Estimator API आपको एक मॉडल को प्रशिक्षित और मूल्यांकन करने देता है, साथ ही अनुमान लगाता है और आपके मॉडल को सहेजता है (सेवारत के लिए)।
  • TensorFlow 2 में, उपरोक्त कार्यों को करने के लिए Keras API का उपयोग करें, जैसे कि मॉडल निर्माण , ग्रेडिएंट एप्लिकेशन, प्रशिक्षण , मूल्यांकन और भविष्यवाणी।

(मॉडल/चेकपॉइंट सेविंग वर्कफ़्लोज़ को TensorFlow 2 में माइग्रेट करने के लिए, SavedModel और Checkpoint माइग्रेशन गाइड देखें।)

सेट अप

आयात और एक साधारण डेटासेट से शुरू करें:

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

features = [[1., 1.5], [2., 2.5], [3., 3.5]]
labels = [[0.3], [0.5], [0.7]]
eval_features = [[4., 4.5], [5., 5.5], [6., 6.5]]
eval_labels = [[0.8], [0.9], [1.]]

TensorFlow 1: tf.estimator.Estimator . के साथ ट्रेन और मूल्यांकन करें

यह उदाहरण दिखाता है कि TensorFlow 1 में tf.estimator.Estimator के साथ प्रशिक्षण और मूल्यांकन कैसे करें।

कुछ कार्यों को परिभाषित करके प्रारंभ करें: प्रशिक्षण डेटा के लिए एक इनपुट फ़ंक्शन, मूल्यांकन डेटा के लिए एक मूल्यांकन इनपुट फ़ंक्शन, और एक मॉडल फ़ंक्शन जो Estimator को बताता है कि सुविधाओं और लेबल के साथ प्रशिक्षण सेशन को कैसे परिभाषित किया जाता है:

def _input_fn():
  return tf1.data.Dataset.from_tensor_slices((features, labels)).batch(1)

def _eval_input_fn():
  return tf1.data.Dataset.from_tensor_slices(
      (eval_features, eval_labels)).batch(1)

def _model_fn(features, labels, mode):
  logits = tf1.layers.Dense(1)(features)
  loss = tf1.losses.mean_squared_error(labels=labels, predictions=logits)
  optimizer = tf1.train.AdagradOptimizer(0.05)
  train_op = optimizer.minimize(loss, global_step=tf1.train.get_global_step())
  return tf1.estimator.EstimatorSpec(mode, loss=loss, train_op=train_op)

अपने Estimator को त्वरित करें, और मॉडल को प्रशिक्षित करें:

estimator = tf1.estimator.Estimator(model_fn=_model_fn)
estimator.train(_input_fn)

INFO:tensorflow:Using default config.
WARNING:tensorflow:Using temporary folder as model directory: /tmp/tmpeovq622_
INFO:tensorflow:Using config: {'_model_dir': '/tmp/tmpeovq622_', '_tf_random_seed': None, '_save_summary_steps': 100, '_save_checkpoints_steps': None, '_save_checkpoints_secs': 600, '_session_config': allow_soft_placement: true
graph_options {
  rewrite_options {
    meta_optimizer_iterations: ONE
  }
}
, '_keep_checkpoint_max': 5, '_keep_checkpoint_every_n_hours': 10000, '_log_step_count_steps': 100, '_train_distribute': None, '_device_fn': None, '_protocol': None, '_eval_distribute': None, '_experimental_distribute': None, '_experimental_max_worker_delay_secs': None, '_session_creation_timeout_secs': 7200, '_checkpoint_save_graph_def': True, '_service': None, '_cluster_spec': ClusterSpec({}), '_task_type': 'worker', '_task_id': 0, '_global_id_in_cluster': 0, '_master': '', '_evaluation_master': '', '_is_chief': True, '_num_ps_replicas': 0, '_num_worker_replicas': 1}
WARNING:tensorflow:From /tmpfs/src/tf_docs_env/lib/python3.7/site-packages/tensorflow/python/training/training_util.py:236: Variable.initialized_value (from tensorflow.python.ops.variables) is deprecated and will be removed in a future version.
Instructions for updating:
Use Variable.read_value. Variables in 2.X are initialized automatically both in eager and graph (inside tf.defun) contexts.
INFO:tensorflow:Calling model_fn.
WARNING:tensorflow:From /tmpfs/src/tf_docs_env/lib/python3.7/site-packages/tensorflow/python/training/adagrad.py:77: calling Constant.__init__ (from tensorflow.python.ops.init_ops) with dtype is deprecated and will be removed in a future version.
Instructions for updating:
Call initializer instance with the dtype argument instead of passing it to the constructor
INFO:tensorflow:Done calling model_fn.
INFO:tensorflow:Create CheckpointSaverHook.
INFO:tensorflow:Graph was finalized.
INFO:tensorflow:Running local_init_op.
INFO:tensorflow:Done running local_init_op.
INFO:tensorflow:Calling checkpoint listeners before saving checkpoint 0...
INFO:tensorflow:Saving checkpoints for 0 into /tmp/tmpeovq622_/model.ckpt.
INFO:tensorflow:Calling checkpoint listeners after saving checkpoint 0...
INFO:tensorflow:loss = 2.0834494, step = 0
INFO:tensorflow:Calling checkpoint listeners before saving checkpoint 3...
INFO:tensorflow:Saving checkpoints for 3 into /tmp/tmpeovq622_/model.ckpt.
INFO:tensorflow:Calling checkpoint listeners after saving checkpoint 3...
INFO:tensorflow:Loss for final step: 9.88002.
<tensorflow_estimator.python.estimator.estimator.Estimator at 0x7fbd06673350>

मूल्यांकन सेट के साथ कार्यक्रम का मूल्यांकन करें:

estimator.evaluate(_eval_input_fn)

INFO:tensorflow:Calling model_fn.
INFO:tensorflow:Done calling model_fn.
INFO:tensorflow:Starting evaluation at 2021-10-26T01:32:58
INFO:tensorflow:Graph was finalized.
INFO:tensorflow:Restoring parameters from /tmp/tmpeovq622_/model.ckpt-3
INFO:tensorflow:Running local_init_op.
INFO:tensorflow:Done running local_init_op.
INFO:tensorflow:Inference Time : 0.10194s
INFO:tensorflow:Finished evaluation at 2021-10-26-01:32:58
INFO:tensorflow:Saving dict for global step 3: global_step = 3, loss = 20.543152
INFO:tensorflow:Saving 'checkpoint_path' summary for global step 3: /tmp/tmpeovq622_/model.ckpt-3
{'loss': 20.543152, 'global_step': 3}

TensorFlow 2: बिल्ट-इन केरस विधियों के साथ ट्रेन और मूल्यांकन करें

यह उदाहरण दर्शाता है कि TensorFlow 2 में Keras Model.fit और Model.evaluate के साथ प्रशिक्षण और मूल्यांकन कैसे करें।

  • tf.data.Dataset APIs के साथ डेटासेट पाइपलाइन तैयार करके प्रारंभ करें।
  • एक रैखिक ( tf.keras.layers.Dense ) परत के साथ एक सरल केरस अनुक्रमिक मॉडल को परिभाषित करें।
  • Adagrad अनुकूलक को त्वरित करें ( tf.keras.optimizers.Adagrad )।
  • optimizer वैरिएबल और माध्य-वर्ग त्रुटि ( "mse" ) नुकसान को Model.compile में पास करके प्रशिक्षण के लिए मॉडल को कॉन्फ़िगर करें।
dataset = tf.data.Dataset.from_tensor_slices((features, labels)).batch(1)
eval_dataset = tf.data.Dataset.from_tensor_slices(
      (eval_features, eval_labels)).batch(1)

model = tf.keras.models.Sequential([tf.keras.layers.Dense(1)])
optimizer = tf.keras.optimizers.Adagrad(learning_rate=0.05)

model.compile(optimizer=optimizer, loss="mse")

इसके साथ, आप Model.fit पर कॉल करके मॉडल को प्रशिक्षित करने के लिए तैयार हैं:

model.fit(dataset)

3/3 [==============================] - 0s 2ms/step - loss: 0.2785
<keras.callbacks.History at 0x7fbc4b320350>

अंत में, Model.evaluate के साथ मॉडल का मूल्यांकन करें:

model.evaluate(eval_dataset, return_dict=True)

3/3 [==============================] - 0s 1ms/step - loss: 0.0451
{'loss': 0.04510306194424629}

TensorFlow 2: कस्टम प्रशिक्षण चरण और अंतर्निहित Keras विधियों के साथ प्रशिक्षण और मूल्यांकन करें

TensorFlow 2 में, आप tf.GradientTape के साथ अपना स्वयं का कस्टम प्रशिक्षण चरण फ़ंक्शन भी लिख सकते हैं ताकि आगे और पीछे के पास प्रदर्शन किया जा सके, जबकि अभी भी अंतर्निहित प्रशिक्षण समर्थन, जैसे tf.keras.callbacks.Callback और tf.distribute.Strategy का लाभ उठा सकते हैं। tf.distribute.Strategy । ( मॉडल.फिट में क्या होता है, इसे कस्टमाइज़ करने और स्क्रैच से कस्टम ट्रेनिंग लूप लिखने के बारे में और जानें।)

इस उदाहरण में, tf.keras.Sequential को उप-वर्गीकृत करके एक कस्टम tf.keras.Model बनाकर प्रारंभ करें, जो tf.keras.Sequential को ओवरराइड Model.train_step है। ( tf.keras.Model उपवर्गीकरण के बारे में अधिक जानें)। उस वर्ग के अंदर, एक कस्टम train_step फ़ंक्शन को परिभाषित करें जो डेटा के प्रत्येक बैच के लिए एक प्रशिक्षण चरण के दौरान फॉरवर्ड पास और बैकवर्ड पास करता है।

class CustomModel(tf.keras.Sequential):
  """A custom sequential model that overrides `Model.train_step`."""

  def train_step(self, data):
    batch_data, labels = data

    with tf.GradientTape() as tape:
      predictions = self(batch_data, training=True)
      # Compute the loss value (the loss function is configured
      # in `Model.compile`).
      loss = self.compiled_loss(labels, predictions)

    # Compute the gradients of the parameters with respect to the loss.
    gradients = tape.gradient(loss, self.trainable_variables)
    # Perform gradient descent by updating the weights/parameters.
    self.optimizer.apply_gradients(zip(gradients, self.trainable_variables))
    # Update the metrics (includes the metric that tracks the loss).
    self.compiled_metrics.update_state(labels, predictions)
    # Return a dict mapping metric names to the current values.
    return {m.name: m.result() for m in self.metrics}

अगला, पहले की तरह:

  • tf.data.Dataset के साथ डेटासेट पाइपलाइन तैयार करें।
  • एक tf.keras.layers.Dense लेयर के साथ एक साधारण मॉडल को परिभाषित करें।
  • इंस्टैंटियेट एडग्रेड ( tf.keras.optimizers.Adagrad )
  • नुकसान फ़ंक्शन के रूप में माध्य-वर्ग त्रुटि ( "mse" ) का उपयोग करते हुए, Model.compile के साथ प्रशिक्षण के लिए मॉडल को कॉन्फ़िगर करें।
dataset = tf.data.Dataset.from_tensor_slices((features, labels)).batch(1)
eval_dataset = tf.data.Dataset.from_tensor_slices(
      (eval_features, eval_labels)).batch(1)

model = CustomModel([tf.keras.layers.Dense(1)])
optimizer = tf.keras.optimizers.Adagrad(learning_rate=0.05)

model.compile(optimizer=optimizer, loss="mse")

मॉडल को प्रशिक्षित करने के लिए Model.fit को कॉल करें:

model.fit(dataset)

3/3 [==============================] - 0s 2ms/step - loss: 0.0587
<keras.callbacks.History at 0x7fbc3873f1d0>

और, अंत में, Model.evaluate के साथ प्रोग्राम का मूल्यांकन करें:

model.evaluate(eval_dataset, return_dict=True)

3/3 [==============================] - 0s 2ms/step - loss: 0.0197
{'loss': 0.019738242030143738}

अगले कदम

अतिरिक्त केरस संसाधन जो आपको उपयोगी लग सकते हैं:

निम्नलिखित मार्गदर्शिकाएँ tf.estimator API से वितरण रणनीति कार्यप्रवाहों को स्थानांतरित करने में सहायता कर सकती हैं: