metrics_optimizers.ipynb

Kernel: Python 3

Copyright 2021 The TensorFlow Authors.

#@title Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# https://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.

Migrar métricas y optimizadores

Ver en TensorFlow.org

Ejecutar en Google Colab

Ver código fuente en GitHub

Descargar bloc de notas

En TF1, tf.metrics es el namespace de la API para todas las funciones de métricas. Cada una de las métricas es una función que toma label y prediction como parámetros de entrada y devuelve como resultado el tensor de métricas correspondiente. En TF2, tf.keras.metrics contiene todas las funciones y objetos de métricas. El objeto Metric puede usarse con tf.keras.Model y tf.keras.layers.layer para calcular valores de métricas.

Preparación

Empecemos con un par de imports TensorFlow necesarios,

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

y prepara algunos datos sencillos para la demostración:

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 con Estimator

En TF1, las métricas pueden añadirse a EstimatorSpec como eval_metric_ops, y la operación se genera mediante todas las funciones de métricas definidas en tf.metrics. Puedes seguir el ejemplo para ver cómo usar 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.math.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)

estimator.evaluate(_eval_input_fn)

También se pueden añadir métricas al estimador directamente mediante 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)

TF2: API de métricas Keras con tf.keras.Model

En TF2, tf.keras.metrics contiene todas las clases y funciones de métricas. Están diseñadas con un estilo OOP y se integran estrechamente con otras APIs tf.keras. Todas las métricas se pueden encontrar en el namespace tf.keras.metrics, y suele haber un mapeo directo entre tf.compat.v1.metrics con tf.keras.metrics.

En el siguiente ejemplo, las métricas se añaden en el método model.compile(). Los usuarios sólo tienen que crear la instancia de métricas, sin especificar la etiqueta ni el tensor de predicción. El modelo Keras dirigirá la salida del modelo y la etiqueta al objeto métrica.

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

Con la ejecución eager activada, las instancias tf.keras.metrics.Metric pueden usarse directamente para evaluar datos numpy o tensores eager. Los objetos tf.keras.metrics.Metric son contenedores con estado. El valor de la métrica puede actualizarse mediante metric.update_state(y_true, y_pred), y el resultado puede recuperarse mediante 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()

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

Para obtener más información sobre tf.keras.metrics.Metric, consulta la documentación de la API en tf.keras.metrics.Metric, así como la guía de migración.

Migrar optimizadores TF1.x a optimizadores Keras

Los optimizadores de tf.compat.v1.train, como el optimizador Adam y el optimizador de descenso gradiente, tienen equivalentes en tf.keras.optimizers.

La tabla siguiente resume cómo puedes convertir estos optimizadores heredados en sus equivalentes de Keras. Puedes reemplazar directamente la versión TF1.x por la versión TF2, a menos que se requieran pasos adicionales (como actualizar la tasa de aprendizaje predeterminada).

Ten en cuenta que convertir tus optimizadores puede hacer incompatibles los puntos de verificación previos.

TF1.x	TF2	Pasos adicionales
`tf.v1.train.GradientDescentOptimizer`	`tf.keras.optimizers.SGD`	Ninguno
`tf.v1.train.MomentumOptimizer`	`tf.keras.optimizers.SGD`	Incluye el argumento "momentum"
`tf.v1.train.AdamOptimizer`	`tf.keras.optimizers.Adam`	Cambia el nombre de los argumentos "beta1" y "beta2" a "beta_1" y "beta_2".
`tf.v1.train.RMSPropOptimizer`	`tf.keras.optimizers.RMSprop`	Cambia el nombre del argumento "decay" por "rho".
`tf.v1.train.AdadeltaOptimizer`	`tf.keras.optimizers.Adadelta`	Ninguno
`tf.v1.train.AdagradOptimizer`	`tf.keras.optimizers.Adagrad`	Ninguno
`tf.v1.train.FtrlOptimizer`	`tf.keras.optimizers.Ftrl`	Elimina los argumentos "accum_name" y "linear_name"
`tf.contrib.AdamaxOptimizer`	`tf.keras.optimizers.Adamax`	Cambia el nombre de los argumentos "beta1" y "beta2" a "beta_1" y "beta_2".
`tf.contrib.Nadam`	`tf.keras.optimizers.Nadam`	Cambia el nombre de los argumentos "beta1" y "beta2" a "beta_1" y "beta_2".

Nota: En TF2, todos los épsilones (constantes numéricas de estabilidad) ahora están predeterminados a 1e-7 en lugar de 1e-8. Esta diferencia es insignificante en la mayoría de los casos que se usan.