Diese Seite wurde von der Cloud Translation API übersetzt.
Switch to English

TensorFlow 2.x in TFX

TensorFlow 2.0 wurde im Jahr 2019 veröffentlicht , mit dem engen Integration von Keras , eifrig Ausführung standardmäßig und Pythonic Funktionsausführung unter anderem neuen Funktionen und Verbesserungen .

Dieses Handbuch bietet einen umfassenden technischen Überblick über TF 2.x in TFX.

Welche Version soll verwendet werden?

TFX ist mit TensorFlow 2.x kompatibel, und die in TensorFlow 1.x vorhandenen High-Level-APIs (insbesondere Estimators) funktionieren weiterhin.

Starten Sie neue Projekte in TensorFlow 2.x.

Da TensorFlow 2.x die allgemeinen Funktionen von TensorFlow 1.x beibehält, bietet die Verwendung der älteren Version für neue Projekte keinen Vorteil, selbst wenn Sie nicht vorhaben, die neuen Funktionen zu verwenden.

Wenn Sie ein neues TFX-Projekt starten, empfehlen wir daher, TensorFlow 2.x zu verwenden. Möglicherweise möchten Sie Ihren Code später aktualisieren, sobald die vollständige Unterstützung für Keras und andere neue Funktionen verfügbar ist. Der Umfang der Änderungen wird erheblich eingeschränkt, wenn Sie mit TensorFlow 2.x beginnen, anstatt zu versuchen, ein Upgrade von TensorFlow 1.x in durchzuführen die Zukunft.

Konvertieren bestehender Projekte in TensorFlow 2.x.

Für TensorFlow 1.x geschriebener Code ist weitgehend mit TensorFlow 2.x kompatibel und funktioniert weiterhin in TFX.

Wenn Sie jedoch Verbesserungen und neue Funktionen nutzen möchten, sobald diese in TF 2.x verfügbar sind, können Sie den Anweisungen zur Migration auf TF 2.x folgen.

Schätzer

Die Estimator-API wurde in TensorFlow 2.x beibehalten, steht jedoch nicht im Mittelpunkt neuer Funktionen und Entwicklungen. In TensorFlow 1.x oder 2.x mit Estimators geschriebener Code funktioniert weiterhin wie in TFX erwartet.

Hier ist ein End-to-End-TFX-Beispiel mit reinem Estimator: Taxi-Beispiel (Estimator)

Keras mit model_to_estimator

Keras-Modelle können mit der Funktion tf.keras.estimator.model_to_estimator umbrochen werden, mit der sie so arbeiten können, als wären sie Schätzer. So verwenden Sie:

  1. Erstellen Sie ein Keras-Modell.
  2. model_to_estimator das kompilierte Modell an model_to_estimator .
  3. Verwenden Sie das Ergebnis von model_to_estimator in Trainer, wie Sie normalerweise einen Schätzer verwenden würden.
# 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,
      ...
  }

Abgesehen von der Benutzermoduldatei von Trainer bleibt der Rest der Pipeline unverändert. Hier ist ein End-to-End-TFX-Beispiel mit Keras mit model_to_estimator: Iris-Beispiel (model_to_estimator)

Native Keras (dh Keras ohne model_to_estimator )

Beispiele und Colab

Hier sind einige Beispiele mit nativen Keras:

Wir haben auch ein Keras Colab pro Komponente.

TFX-Komponenten

In den folgenden Abschnitten wird erläutert, wie verwandte TFX-Komponenten native Keras unterstützen.

Verwandeln

Transform bietet derzeit experimentelle Unterstützung für Keras-Modelle.

Die Transformationskomponente selbst kann ohne Änderung für native Keras verwendet werden. Die preprocessing_fn Definition bleibt die gleiche, mit TensorFlow und tf.Transform ops.

Die Serving-Funktion und die Eval-Funktion werden für native Keras geändert. Details werden in den folgenden Abschnitten zu Trainer und Evaluator erläutert.

Trainer

Um native Keras zu konfigurieren, muss der GenericExecutor für die GenericExecutor festgelegt werden, um den standardmäßigen Estimator-basierten Executor zu ersetzen. Für Details überprüfen Sie bitte hier .

Keras-Moduldatei mit Transform

Die Trainingsmoduldatei muss eine run_fn die vom GenericExecutor wird. Eine typische Keras- run_fn würde folgendermaßen aussehen:

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 feature_spec from tft.
  train_dataset = _input_fn(fn_args.train_files, tf_transform_output, 40)
  eval_dataset = _input_fn(fn_args.eval_files, tf_transform_output, 40)

  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)

In der obigen run_fn wird beim Exportieren des trainierten Modells eine Serving-Signatur benötigt, damit das Modell run_fn für die Vorhersage verwenden kann. Eine typische Servierfunktion würde folgendermaßen aussehen:

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

In der obigen Serving-Funktion müssen tf.Transform-Transformationen zur Inferenz unter Verwendung der tft.TransformFeaturesLayer auf die Rohdaten tft.TransformFeaturesLayer werden. Der vorherige _serving_input_receiver_fn der für Estimators erforderlich war, wird mit Keras nicht mehr benötigt.

Keras-Moduldatei ohne Transformation

Dies ähnelt der oben gezeigten Moduldatei, jedoch ohne die Transformationen:

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 feature_spec from schema.
  train_dataset = _input_fn(fn_args.train_files, schema, 40)
  eval_dataset = _input_fn(fn_args.eval_files, schema, 40)

  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

Derzeit unterstützt TFX nur Single-Worker-Strategien (z. B. MirroredStrategy , OneDeviceStrategy ).

Um eine Verteilungsstrategie zu verwenden, erstellen Sie eine geeignete tf.distribute.Strategy und verschieben Sie die Erstellung und Kompilierung des Keras-Modells in einen Strategiebereich.

Ersetzen Sie beispielsweise das obige model = _build_keras_model() durch:

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

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

Aktivieren Sie die Tensorflow-Protokollierung auf Informationsebene, um das von MirroredStrategy verwendete Gerät (CPU / GPU) zu überprüfen:

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

und Sie sollten in der Lage sein, die Using MirroredStrategy with devices (...) im Protokoll anzuzeigen.

Bewerter

In TFMA v0.2x wurden ModelValidator und Evaluator zu einer einzigen neuen Evaluator-Komponente kombiniert. Die neue Evaluator-Komponente kann sowohl eine Einzelmodellbewertung durchführen als auch das aktuelle Modell im Vergleich zu früheren Modellen validieren. Mit dieser Änderung verbraucht die Pusher-Komponente jetzt ein Segen-Ergebnis von Evaluator anstelle von ModelValidator.

Der neue Evaluator unterstützt sowohl Keras-Modelle als auch Estimator-Modelle. Das zuvor benötigte _eval_input_receiver_fn und eval-gespeicherte Modell wird mit Keras nicht mehr benötigt, da Evaluator jetzt auf demselben SavedModel basiert, das für die Bereitstellung verwendet wird.

Weitere Informationen finden Sie unter Evaluator .