Se usó la API de Cloud Translation para traducir esta página.
Switch to English

TensorFlow 2.x en TFX

TensorFlow 2.0 se lanzó en 2019 , con una estrecha integración de Keras , ejecución ávida de forma predeterminada y ejecución de funciones Pythonic , entre otras nuevas características y mejoras .

Esta guía proporciona una descripción técnica completa de TF 2.x en TFX.

¿Qué versión usar?

TFX es compatible con TensorFlow 2.xy las API de alto nivel que existían en TensorFlow 1.x (en particular Estimators) continúan funcionando.

Iniciar nuevos proyectos en TensorFlow 2.x

Dado que TensorFlow 2.x conserva las capacidades de alto nivel de TensorFlow 1.x, no hay ninguna ventaja en usar la versión anterior en nuevos proyectos, incluso si no planea usar las nuevas funciones.

Por lo tanto, si está comenzando un nuevo proyecto TFX, le recomendamos que use TensorFlow 2.x. Es posible que desee actualizar su código más adelante, ya que la compatibilidad total para Keras y otras funciones nuevas estén disponibles, y el alcance de los cambios será mucho más limitado si comienza con TensorFlow 2.x, en lugar de intentar actualizar desde TensorFlow 1.x en el futuro.

Conversión de proyectos existentes a TensorFlow 2.x

El código escrito para TensorFlow 1.x es en gran parte compatible con TensorFlow 2.xy seguirá funcionando en TFX.

Sin embargo, si desea aprovechar las mejoras y las nuevas funciones a medida que estén disponibles en TF 2.x, puede seguir las instrucciones para migrar a TF 2.x.

Estimador

La API de Estimator se mantuvo en TensorFlow 2.x, pero no es el foco de nuevas funciones y desarrollo. El código escrito en TensorFlow 1.xo 2.x con Estimadores seguirá funcionando como se esperaba en TFX.

A continuación, se muestra un ejemplo de TFX de un extremo a otro que utiliza Estimador puro: ejemplo de taxi (Estimador)

Keras con model_to_estimator

Los modelos de Keras se pueden envolver con la función tf.keras.estimator.model_to_estimator , que les permite trabajar como si fueran estimadores. Para usar esto:

  1. Construye un modelo de Keras.
  2. Pase el modelo compilado a model_to_estimator .
  3. Utilice el resultado de model_to_estimator en Trainer, de la forma en que normalmente utilizaría un Estimator.
# Build a Keras model.
def _keras_model_builder():
  """Creates a Keras model."""
  ...

  model = tf.keras.Model(inputs=inputs, outputs=output)
  model.compile()

  return model


# Write a typical trainer function
def trainer_fn(trainer_fn_args, schema):
  """Build the estimator, using model_to_estimator."""
  ...

  # Model to estimator
  estimator = tf.keras.estimator.model_to_estimator(
      keras_model=_keras_model_builder(), config=run_config)

  return {
      'estimator': estimator,
      ...
  }

Aparte del archivo de módulo de usuario de Trainer, el resto de la canalización permanece sin cambios.

Keras nativo (es decir, Keras sin model_to_estimator )

Ejemplos y Colab

Aquí hay varios ejemplos con Keras nativos:

También tenemos un Keras Colab por componente.

Componentes TFX

Las siguientes secciones explican cómo los componentes TFX relacionados son compatibles con Keras nativo.

Transformar

Transform tiene actualmente soporte experimental para modelos de Keras.

El componente Transform en sí mismo se puede usar para Keras nativos sin cambios. La definición de preprocessing_fn sigue siendo la misma, con las operaciones de TensorFlow y tf.Transform .

La función de servicio y la función de evaluación se cambian para los Keras nativos. Los detalles se discutirán en las siguientes secciones de Entrenador y Evaluador.

Entrenador

Para configurar Keras nativo, el GenericExecutor debe configurarse para que el componente Trainer reemplace al ejecutor predeterminado basado en Estimator. Para obtener más información, consulte aquí .

Archivo de módulo Keras con Transform

El archivo del módulo de entrenamiento debe contener un run_fn que será llamado por GenericExecutor , un típico run_fn Keras se vería así:

def run_fn(fn_args: TrainerFnArgs):
  """Train the model based on given args.

  Args:
    fn_args: Holds args used to train the model as name/value pairs.
  """
  tf_transform_output = tft.TFTransformOutput(fn_args.transform_output)

  # Train and eval files contains transformed examples.
  # _input_fn read dataset based on transformed schema from tft.
  train_dataset = _input_fn(fn_args.train_files, fn_args.data_accessor,
                            tf_transform_output.transformed_metadata.schema)
  eval_dataset = _input_fn(fn_args.eval_files, fn_args.data_accessor,
                           tf_transform_output.transformed_metadata.schema)

  model = _build_keras_model()

  model.fit(
      train_dataset,
      steps_per_epoch=fn_args.train_steps,
      validation_data=eval_dataset,
      validation_steps=fn_args.eval_steps)

  signatures = {
      'serving_default':
          _get_serve_tf_examples_fn(model,
                                    tf_transform_output).get_concrete_function(
                                        tf.TensorSpec(
                                            shape=[None],
                                            dtype=tf.string,
                                            name='examples')),
  }
  model.save(fn_args.serving_model_dir, save_format='tf', signatures=signatures)

En el run_fn anterior, se necesita una firma de servicio al exportar el modelo entrenado para que el modelo pueda tomar ejemplos sin procesar para la predicción. Una función de servicio típica se vería así:

def _get_serve_tf_examples_fn(model, tf_transform_output):
  """Returns a function that parses a serialized tf.Example."""

  # the layer is added as an attribute to the model in order to make sure that
  # the model assets are handled correctly when exporting.
  model.tft_layer = tf_transform_output.transform_features_layer()

  @tf.function
  def serve_tf_examples_fn(serialized_tf_examples):
    """Returns the output to be used in the serving signature."""
    feature_spec = tf_transform_output.raw_feature_spec()
    feature_spec.pop(_LABEL_KEY)
    parsed_features = tf.io.parse_example(serialized_tf_examples, feature_spec)

    transformed_features = model.tft_layer(parsed_features)

    return model(transformed_features)

  return serve_tf_examples_fn

En la función de servicio anterior, las transformaciones de tf.Transform deben aplicarse a los datos sin procesar para la inferencia, utilizando la capa tft.TransformFeaturesLayer . El _serving_input_receiver_fn anterior que era necesario para los Estimadores ya no será necesario con Keras.

Archivo de módulo de Keras sin transformar

Esto es similar al archivo de módulo que se muestra arriba, pero sin las transformaciones:

def _get_serve_tf_examples_fn(model, schema):

  @tf.function
  def serve_tf_examples_fn(serialized_tf_examples):
    feature_spec = _get_raw_feature_spec(schema)
    feature_spec.pop(_LABEL_KEY)
    parsed_features = tf.io.parse_example(serialized_tf_examples, feature_spec)
    return model(parsed_features)

  return serve_tf_examples_fn


def run_fn(fn_args: TrainerFnArgs):
  schema = io_utils.parse_pbtxt_file(fn_args.schema_file, schema_pb2.Schema())

  # Train and eval files contains raw examples.
  # _input_fn reads the dataset based on raw data schema.
  train_dataset = _input_fn(fn_args.train_files, fn_args.data_accessor, schema)
  eval_dataset = _input_fn(fn_args.eval_files, fn_args.data_accessor, schema)

  model = _build_keras_model()

  model.fit(
      train_dataset,
      steps_per_epoch=fn_args.train_steps,
      validation_data=eval_dataset,
      validation_steps=fn_args.eval_steps)

  signatures = {
      'serving_default':
          _get_serve_tf_examples_fn(model, schema).get_concrete_function(
              tf.TensorSpec(shape=[None], dtype=tf.string, name='examples')),
  }
  model.save(fn_args.serving_model_dir, save_format='tf', signatures=signatures)
tf.distribute.Strategy

En este momento, TFX solo admite estrategias de un solo trabajador (por ejemplo, MirroredStrategy , OneDeviceStrategy ).

Para utilizar una estrategia de distribución, cree una tf.distribute.Strategy adecuada y mueva la creación y compilación del modelo de Keras dentro del alcance de una estrategia.

Por ejemplo, reemplace el model = _build_keras_model() anterior model = _build_keras_model() con:

  mirrored_strategy = tf.distribute.MirroredStrategy()
  with mirrored_strategy.scope():
    model = _build_keras_model()

  # Rest of the code can be unchanged.
  model.fit(...)

Para verificar el dispositivo (CPU / GPU) utilizado por MirroredStrategy , habilite el registro de flujo tensorial de nivel de información:

import logging
logging.getLogger("tensorflow").setLevel(logging.INFO)

y debería poder ver Using MirroredStrategy with devices (...) en el registro.

Evaluador

En TFMA v0.2x, ModelValidator y Evaluator se han combinado en un solo nuevo componente Evaluator . El nuevo componente Evaluador puede realizar evaluaciones de un solo modelo y también validar el modelo actual en comparación con modelos anteriores. Con este cambio, el componente Pusher ahora consume un resultado de bendición de Evaluator en lugar de ModelValidator.

El nuevo evaluador es compatible con los modelos de Keras y con los modelos de estimador. El modelo guardado _eval_input_receiver_fn y eval que se requerían anteriormente ya no serán necesarios con Keras, ya que Evaluator ahora se basa en el mismo SavedModel que se usa para servir.

Consulte Evaluador para obtener más información .