मेट्रिक्स और ऑप्टिमाइज़र माइग्रेट करें

TF1 में, tf.metrics सभी मीट्रिक फ़ंक्शंस के लिए API नामस्थान है। प्रत्येक मेट्रिक्स एक ऐसा फ़ंक्शन है जो इनपुट पैरामीटर के रूप में label और prediction लेता है और परिणाम के रूप में संबंधित मेट्रिक्स टेंसर देता है। TF2 में, tf.keras.metrics में सभी मीट्रिक फ़ंक्शन और ऑब्जेक्ट होते हैं। Metric ऑब्जेक्ट का उपयोग tf.keras.Model और tf.keras.layers.layer के साथ मीट्रिक मानों की गणना के लिए किया जा सकता है।

सेट अप

आइए कुछ आवश्यक TensorFlow आयातों के साथ शुरू करें,

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

और प्रदर्शन के लिए कुछ सरल डेटा तैयार करें:

features = [[1., 1.5], [2., 2.5], [3., 3.5]]
labels = [0, 0, 1]
eval_features = [[4., 4.5], [5., 5.5], [6., 6.5]]
eval_labels = [0, 1, 1]

TF1: अनुमानक के साथ tf.compat.v1.metrics

TF1 में, मीट्रिक को eval_metric_ops के रूप में EstimatorSpec में जोड़ा जा सकता है, और op tf.metrics में परिभाषित सभी मीट्रिक फ़ंक्शन के माध्यम से उत्पन्न होता है। tf.metrics.accuracy का उपयोग कैसे करें, यह देखने के लिए आप उदाहरण का अनुसरण कर सकते हैं।

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(2)(features)
  predictions = tf.argmax(input=logits, axis=1)
  loss = tf1.nn.sparse_softmax_cross_entropy_with_logits(labels=labels, logits=logits)
  optimizer = tf1.train.AdagradOptimizer(0.05)
  train_op = optimizer.minimize(loss, global_step=tf1.train.get_global_step())
  accuracy = tf1.metrics.accuracy(labels=labels, predictions=predictions)
  return tf1.estimator.EstimatorSpec(mode, 
                                     predictions=predictions,
                                     loss=loss, 
                                     train_op=train_op,
                                     eval_metric_ops={'accuracy': accuracy})

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/tmpnfk2kv3b
INFO:tensorflow:Using config: {'_model_dir': '/tmp/tmpnfk2kv3b', '_tf_random_seed': None, '_save_summary_steps': 100, '_save_checkpoints_steps': None, '_save_checkpoints_secs': 600, '_session_config': allow_soft_placement: true
graph_options {
  rewrite_options {
    meta_optimizer_iterations: ONE
  }
}
, '_keep_checkpoint_max': 5, '_keep_checkpoint_every_n_hours': 10000, '_log_step_count_steps': 100, '_train_distribute': None, '_device_fn': None, '_protocol': None, '_eval_distribute': None, '_experimental_distribute': None, '_experimental_max_worker_delay_secs': None, '_session_creation_timeout_secs': 7200, '_checkpoint_save_graph_def': True, '_service': None, '_cluster_spec': ClusterSpec({}), '_task_type': 'worker', '_task_id': 0, '_global_id_in_cluster': 0, '_master': '', '_evaluation_master': '', '_is_chief': True, '_num_ps_replicas': 0, '_num_worker_replicas': 1}
WARNING:tensorflow:From /tmpfs/src/tf_docs_env/lib/python3.7/site-packages/tensorflow/python/training/training_util.py:401: Variable.initialized_value (from tensorflow.python.ops.variables) is deprecated and will be removed in a future version.
Instructions for updating:
Use Variable.read_value. Variables in 2.X are initialized automatically both in eager and graph (inside tf.defun) contexts.
INFO:tensorflow:Calling model_fn.
WARNING:tensorflow:From /tmpfs/src/tf_docs_env/lib/python3.7/site-packages/tensorflow/python/training/adagrad.py:143: 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/tmpnfk2kv3b/model.ckpt.
INFO:tensorflow:Calling checkpoint listeners after saving checkpoint 0...
INFO:tensorflow:loss = 1.0451624, step = 0
INFO:tensorflow:Calling checkpoint listeners before saving checkpoint 3...
INFO:tensorflow:Saving checkpoints for 3 into /tmp/tmpnfk2kv3b/model.ckpt.
INFO:tensorflow:Calling checkpoint listeners after saving checkpoint 3...
INFO:tensorflow:Loss for final step: 0.54487616.
<tensorflow_estimator.python.estimator.estimator.Estimator at 0x7f894c163990>

estimator.evaluate(_eval_input_fn)

INFO:tensorflow:Calling model_fn.
INFO:tensorflow:Done calling model_fn.
INFO:tensorflow:Starting evaluation at 2021-11-19T02:25:11
INFO:tensorflow:Graph was finalized.
INFO:tensorflow:Restoring parameters from /tmp/tmpnfk2kv3b/model.ckpt-3
INFO:tensorflow:Running local_init_op.
INFO:tensorflow:Done running local_init_op.
INFO:tensorflow:Inference Time : 0.14330s
INFO:tensorflow:Finished evaluation at 2021-11-19-02:25:11
INFO:tensorflow:Saving dict for global step 3: accuracy = 0.6666667, global_step = 3, loss = 0.588699
INFO:tensorflow:Saving 'checkpoint_path' summary for global step 3: /tmp/tmpnfk2kv3b/model.ckpt-3
{'accuracy': 0.6666667, 'loss': 0.588699, 'global_step': 3}

साथ ही, tf.estimator.add_metrics() के माध्यम से सीधे अनुमानक में मेट्रिक्स जोड़े जा सकते हैं।

def mean_squared_error(labels, predictions):
  labels = tf.cast(labels, predictions.dtype)
  return {"mean_squared_error": 
          tf1.metrics.mean_squared_error(labels=labels, predictions=predictions)}

estimator = tf1.estimator.add_metrics(estimator, mean_squared_error)
estimator.evaluate(_eval_input_fn)

INFO:tensorflow:Using config: {'_model_dir': '/tmp/tmpnfk2kv3b', '_tf_random_seed': None, '_save_summary_steps': 100, '_save_checkpoints_steps': None, '_save_checkpoints_secs': 600, '_session_config': allow_soft_placement: true
graph_options {
  rewrite_options {
    meta_optimizer_iterations: ONE
  }
}
, '_keep_checkpoint_max': 5, '_keep_checkpoint_every_n_hours': 10000, '_log_step_count_steps': 100, '_train_distribute': None, '_device_fn': None, '_protocol': None, '_eval_distribute': None, '_experimental_distribute': None, '_experimental_max_worker_delay_secs': None, '_session_creation_timeout_secs': 7200, '_checkpoint_save_graph_def': True, '_service': None, '_cluster_spec': ClusterSpec({}), '_task_type': 'worker', '_task_id': 0, '_global_id_in_cluster': 0, '_master': '', '_evaluation_master': '', '_is_chief': True, '_num_ps_replicas': 0, '_num_worker_replicas': 1}
INFO:tensorflow:Calling model_fn.
INFO:tensorflow:Calling model_fn.
INFO:tensorflow:Done calling model_fn.
INFO:tensorflow:Done calling model_fn.
INFO:tensorflow:Starting evaluation at 2021-11-19T02:25:12
INFO:tensorflow:Graph was finalized.
INFO:tensorflow:Restoring parameters from /tmp/tmpnfk2kv3b/model.ckpt-3
INFO:tensorflow:Running local_init_op.
INFO:tensorflow:Done running local_init_op.
INFO:tensorflow:Inference Time : 0.14966s
INFO:tensorflow:Finished evaluation at 2021-11-19-02:25:12
INFO:tensorflow:Saving dict for global step 3: accuracy = 0.6666667, global_step = 3, loss = 0.588699, mean_squared_error = 0.33333334
INFO:tensorflow:Saving 'checkpoint_path' summary for global step 3: /tmp/tmpnfk2kv3b/model.ckpt-3
{'accuracy': 0.6666667,
 'loss': 0.588699,
 'mean_squared_error': 0.33333334,
 'global_step': 3}

TF2: केरस मेट्रिक्स एपीआई tf.keras.Model . के साथ

TF2 में, tf.keras.metrics में सभी मेट्रिक्स वर्ग और फ़ंक्शन शामिल हैं। वे OOP शैली में डिज़ाइन किए गए हैं और अन्य tf.keras API के साथ निकटता से एकीकृत हैं। सभी मेट्रिक्स tf.keras.metrics नेमस्पेस में पाए जा सकते हैं, और आमतौर पर tf.compat.v1.metrics के साथ tf.keras.metrics के बीच एक सीधा मैपिंग होता है।

निम्नलिखित उदाहरण में, मेट्रिक्स को 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)

inputs = tf.keras.Input((2,))
logits = tf.keras.layers.Dense(2)(inputs)
predictions = tf.argmax(input=logits, axis=1)
model = tf.keras.models.Model(inputs, predictions)
optimizer = tf.keras.optimizers.Adagrad(learning_rate=0.05)

model.compile(optimizer, loss='mse', metrics=[tf.keras.metrics.Accuracy()])

model.evaluate(eval_dataset, return_dict=True)

3/3 [==============================] - 0s 2ms/step - loss: 0.3333 - accuracy: 0.6667
{'loss': 0.3333333432674408, 'accuracy': 0.6666666865348816}

उत्सुक निष्पादन सक्षम होने के साथ, tf.keras.metrics.Metric उदाहरणों का उपयोग सीधे संख्यात्मक डेटा या उत्सुक टेंसर का मूल्यांकन करने के लिए किया जा सकता है। tf.keras.metrics.Metric ऑब्जेक्ट स्टेटफुल कंटेनर हैं। मीट्रिक मान metric.update_state(y_true, y_pred) के माध्यम से अपडेट किया जा सकता है, और परिणाम metrics.result() द्वारा पुनर्प्राप्त किया जा सकता है।

accuracy = tf.keras.metrics.Accuracy()

accuracy.update_state(y_true=[0, 0, 1, 1], y_pred=[0, 0, 0, 1])
accuracy.result().numpy()

0.75

accuracy.update_state(y_true=[0, 0, 1, 1], y_pred=[0, 0, 0, 0])
accuracy.update_state(y_true=[0, 0, 1, 1], y_pred=[1, 1, 0, 0])
accuracy.result().numpy()

0.41666666

tf.keras.metrics.Metric के बारे में अधिक जानकारी के लिए, कृपया tf.keras.metrics.Metric पर API दस्तावेज़ीकरण और साथ ही माइग्रेशन मार्गदर्शिका देखें।

TF1.x ऑप्टिमाइज़र को Keras ऑप्टिमाइज़र में माइग्रेट करें

tf.compat.v1.train में ऑप्टिमाइज़र, जैसे कि एडम ऑप्टिमाइज़र और ग्रेडिएंट डिसेंट ऑप्टिमाइज़र , tf.keras.optimizers में समकक्ष हैं।

नीचे दी गई तालिका संक्षेप में बताती है कि आप इन विरासती अनुकूलकों को उनके केरस समकक्षों में कैसे परिवर्तित कर सकते हैं। आप TF1.x संस्करण को सीधे TF2 संस्करण से बदल सकते हैं जब तक कि अतिरिक्त चरणों (जैसे डिफ़ॉल्ट सीखने की दर को अपडेट करना ) की आवश्यकता न हो।

ध्यान दें कि आपके अनुकूलक को परिवर्तित करने से पुराने चेकपॉइंट असंगत हो सकते हैं ।

TF1.x	TF2	अतिरिक्त कदम
`tf.v1.train.GradientDescentOptimizer`	tf.keras.optimizers.SGD	कोई नहीं
`tf.v1.train.MomentumOptimizer`	tf.keras.optimizers.SGD	`गति` तर्क शामिल करें
`tf.v1.train.AdamOptimizer`	tf.keras.optimizers.Adam	`beta1` और `beta2` तर्कों का नाम बदलकर `beta_1` और `beta_2` . करें
`tf.v1.train.RMSPropOptimizer`	tf.keras.optimizers.RMSprop	`क्षय` तर्क का नाम बदलकर `rho` कर दें
`tf.v1.train.AddeltaOptimizer`	tf.keras.optimizers.Adadelta	कोई नहीं
`tf.v1.train.AdagradOptimizer`	tf.keras.optimizers.Adagrad	कोई नहीं
`tf.v1.train.FtrlOptimizer`	tf.keras.optimizers.Ftrl	`accum_name` और `linear_name` तर्क हटाएं
`tf.contrib.AdamaxOptimizer`	tf.keras.optimizers.Adamax	`beta1` और `beta2` तर्कों का नाम बदलकर `beta_1` और `beta_2` कर दें
`tf.contrib.Nadam`	tf.keras.optimizers.Nadam	`beta1` और `beta2` तर्कों का नाम बदलकर `beta_1` और `beta_2` कर दें

नोट: TF2 में, सभी एप्सिलॉन (संख्यात्मक स्थिरता स्थिरांक) अब 1e- 1e-8 के बजाय 1e-7 पर डिफ़ॉल्ट हैं। अधिकांश उपयोग के मामलों में यह अंतर नगण्य है।