Ta strona została przetłumaczona przez Cloud Translation API.
Switch to English

TensorFlow 2.x w TFX

TensorFlow 2.0 został wydany w 2019 roku , ze ścisłą integracją Keras , domyślnym chętnym wykonywaniem i wykonywaniem funkcji Pythonic , a także innymi nowymi funkcjami i ulepszeniami .

Ten przewodnik zawiera kompleksowy przegląd techniczny TF 2.x w TFX.

Której wersji użyć?

TFX jest kompatybilny z TensorFlow 2.x, a interfejsy API wysokiego poziomu, które istniały w TensorFlow 1.x (szczególnie estymatory), nadal działają.

Rozpocznij nowe projekty w TensorFlow 2.x

Ponieważ TensorFlow 2.x zachowuje zaawansowane możliwości TensorFlow 1.x, nie ma korzyści z używania starszej wersji w nowych projektach, nawet jeśli nie planujesz używać nowych funkcji.

Dlatego jeśli rozpoczynasz nowy projekt TFX, zalecamy użycie TensorFlow 2.x. Możesz zaktualizować swój kod później, gdy dostępne będzie pełne wsparcie dla Keras i innych nowych funkcji, a zakres zmian będzie znacznie bardziej ograniczony, jeśli zaczniesz od TensorFlow 2.x, zamiast próbować uaktualnić z TensorFlow 1.x w przyszłość.

Konwersja istniejących projektów do TensorFlow 2.x

Kod napisany dla TensorFlow 1.x jest w dużej mierze kompatybilny z TensorFlow 2.x i będzie nadal działał w TFX.

Jeśli jednak chcesz skorzystać z ulepszeń i nowych funkcji, które staną się dostępne w TF 2.x, możesz postępować zgodnie z instrukcjami migracji do TF 2.x.

Taksator

Estimator API został zachowany w TensorFlow 2.x, ale nie jest celem nowych funkcji i rozwoju. Kod napisany w TensorFlow 1.x lub 2.x przy użyciu estymatorów będzie nadal działał zgodnie z oczekiwaniami w TFX.

Oto kompleksowy przykład TFX wykorzystujący czysty Estimator: Przykład Taxi (Estimator)

Keras z model_to_estimator

Modele Keras można tf.keras.estimator.model_to_estimator za tf.keras.estimator.model_to_estimator funkcji tf.keras.estimator.model_to_estimator , która pozwala im działać tak, jakby były Estimerami. Aby tego użyć:

  1. Zbuduj model Keras.
  2. Przekaż skompilowany model do model_to_estimator .
  3. Użyj wyniku model_to_estimator w Trainer, tak jak zwykle używasz Estymatora.
# 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,
      ...
  }

Poza plikiem modułu użytkownika Trainer, reszta potoku pozostaje niezmieniona. Oto kompleksowy przykład TFX przy użyciu Keras z modelem_to_estimator: Przykład Iris (model_to_estimator)

Native Keras (tj. Keras bez model_to_estimator )

Przykłady i Colab

Oto kilka przykładów z rodzimym Kerasem:

Mamy również komponent Keras Colab .

Składniki TFX

W poniższych sekcjach wyjaśniono, w jaki sposób powiązane składniki TFX obsługują natywne Keras.

Przekształcać

Transform ma obecnie eksperymentalną obsługę modeli Keras.

Sam komponent Transform może być używany dla natywnych Keras bez zmian. Definicja preprocessing_fn pozostaje taka sama, używając operacji TensorFlow i tf.Transform .

Funkcja obsługująca i funkcja eval zostały zmienione dla natywnych Keras. Szczegóły zostaną omówione w następnych sekcjach dla trenerów i ewaluatorów.

Trener

Aby skonfigurować natywne Keras, GenericExecutor musi być ustawiony tak, aby komponent Trainer zastąpił domyślny executor oparty na estymatorze. Aby uzyskać szczegółowe informacje, sprawdź tutaj .

Plik modułu Keras z Transform

Plik modułu szkoleniowego musi zawierać run_fn który zostanie wywołany przez GenericExecutor , typowy run_fn Keras wyglądałby tak:

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)

W powyższym run_fn podpis obsługujący jest potrzebny podczas eksportowania wytrenowanego modelu, aby model mógł brać surowe przykłady do prognozowania. Typowa funkcja serwująca wyglądałaby tak:

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

W powyższej funkcji obsługującej transformacje tf.Transform należy zastosować do surowych danych w celu wnioskowania, używając warstwy tft.TransformFeaturesLayer . Poprzedni _serving_input_receiver_fn który był wymagany dla estymatorów, nie będzie już potrzebny w Keras.

Plik modułu Keras bez transformacji

Jest to podobne do pliku modułu pokazanego powyżej, ale bez przekształceń:

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

Obecnie TFX obsługuje tylko strategie pojedynczego pracownika (np. MirroredStrategy , OneDeviceStrategy ).

Aby użyć strategii dystrybucji, utwórz odpowiednią tf.distribute.Strategy i przenieś tworzenie i kompilację modelu Keras do zakresu strategii.

Na przykład zamień powyższy model = _build_keras_model() :

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

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

Aby zweryfikować urządzenie (CPU / GPU) używane przez MirroredStrategy , włącz rejestrowanie tensorflow na poziomie informacyjnym:

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

i powinieneś być w stanie zobaczyć Using MirroredStrategy with devices (...) w dzienniku.

Ewaluator

W TFMA v0.2x, ModelValidator i Evaluator zostały połączone w jeden nowy komponent Evaluator . Nowy komponent Ewaluator może przeprowadzić zarówno ocenę pojedynczego modelu, jak i zweryfikować bieżący model w porównaniu z poprzednimi modelami. Dzięki tej zmianie składnik Pusher zużywa teraz wynik błogosławieństwa z oceny zamiast z ModelValidator.

Nowy Ewaluator obsługuje modele Keras, a także modele Estymatora. _eval_input_receiver_fn i eval zapisany model, które były wymagane wcześniej, nie będą już potrzebne w Keras, ponieważ Evaluator jest teraz oparty na tym samym SavedModel który jest używany do SavedModel .

Aby uzyskać więcej informacji, zobacz Ewaluator .