TensorFlow 2.0 został wydany w 2019 roku i zawierał ścisłą integrację Keras , domyślne wykonywanie i wykonywanie funkcji Pythonic , a także inne nowe funkcje i ulepszenia .
Ten przewodnik zawiera kompleksowy przegląd techniczny TF 2.x w TFX.
Którą wersję zastosować?
TFX jest kompatybilny z TensorFlow 2.x, a interfejsy API wysokiego poziomu, które istniały w TensorFlow 1.x (w szczególności estymatory) nadal działają.
Rozpocznij nowe projekty w TensorFlow 2.x
Ponieważ TensorFlow 2.x zachowuje wysokie możliwości TensorFlow 1.x, używanie starszej wersji w nowych projektach nie ma korzyści, nawet jeśli nie planujesz korzystać z nowych funkcji.
Dlatego jeśli rozpoczynasz nowy projekt TFX, zalecamy użycie TensorFlow 2.x. Możesz chcieć zaktualizować swój kod później, gdy dostępna będzie pełna obsługa 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, gdy staną się one dostępne w TF 2.x, możesz postępować zgodnie z instrukcjami dotyczącymi migracji do TF 2.x.
Taksator
Interfejs API estymatora został zachowany w TensorFlow 2.x, ale nie jest przedmiotem 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 estymator: Przykład taksówki (Estymator)
Keras z model_to_estimator
Modele Keras można opakować za pomocą funkcji tf.keras.estimator.model_to_estimator , która pozwala im działać tak, jakby były estymatorami. Aby tego użyć:
- Zbuduj model Kerasa.
- Przekaż skompilowany model do
model_to_estimator. - Użyj wyniku
model_to_estimatorw Trainerze w sposób, w jaki 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 Trainera, reszta potoku pozostaje niezmieniona.
Natywne Keras (tj. Keras bez model_to_estimator )
Przykłady i Colab
Oto kilka przykładów z natywnym Kerasem:
- Penguin ( plik modułu ): kompleksowy przykład „Witaj, świecie”.
- MNIST ( plik modułu ): Kompleksowy przykład obrazu i TFLite.
- Taxi ( plik modułu ): kompleksowy przykład z zaawansowanym wykorzystaniem transformacji.
Mamy również Keras Colab na komponenty.
Komponenty TFX
W poniższych sekcjach wyjaśniono, jak powiązane komponenty TFX obsługują natywny 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, przy użyciu operacji TensorFlow i tf.Transform .
Funkcja serwująca i funkcja eval zostały zmienione dla natywnego Keras. Szczegóły zostaną omówione w kolejnych sekcjach dotyczących trenera i ewaluatora.
Trener
Aby skonfigurować natywny Keras, GenericExecutor musi być ustawiony na komponent Trainer, aby zastąpić domyślny executor oparty na estymatorze. Aby uzyskać szczegółowe informacje, sprawdź tutaj .
Plik modułu Keras z transformacją
Plik modułu szkoleniowego musi zawierać run_fn , który zostanie wywołany przez GenericExecutor . Typowy run_fn Keras będzie wyglądał następująco:
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 potrzebny jest podpis obsługujący podczas eksportowania przeszkolonego modelu, aby model mógł przyjmować surowe przykłady do przewidywania. Typowa funkcja serwowania wyglądałaby następująco:
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 wyciągnięcia wniosków, korzystając z warstwy tft.TransformFeaturesLayer . Poprzedni _serving_input_receiver_fn , który był wymagany w przypadku 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)
Strategia.tf.distribute
W tej chwili TFX obsługuje tylko strategie pojedynczego pracownika (np. MirroredStrategy , OneDeviceStrategy ).
Aby zastosować strategię dystrybucji, utwórz odpowiednią strategię tf.distribute.Strategy i przenieś tworzenie i kompilację modelu Keras w zakres strategii.
Na przykład zamień powyższy model = _build_keras_model() na:
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ś widzieć w dzienniku informację Using MirroredStrategy with devices (...) .
Oceniający
W TFMA v0.2x ModelValidator i Evaluator zostały połączone w jeden nowy komponent Evaluator . Nowy komponent Evaluator może przeprowadzać zarówno ocenę pojedynczego modelu, jak i walidację bieżącego modelu w porównaniu z poprzednimi modelami. Dzięki tej zmianie komponent Pusher zużywa teraz wynik błogosławieństwa z narzędzia Evaluator zamiast ModelValidator.
Nowy Evaluator obsługuje modele Keras i Estimator. Zapisane modele _eval_input_receiver_fn i eval, które były wymagane wcześniej, nie będą już potrzebne w Keras, ponieważ narzędzie oceniające jest teraz oparte na tym samym SavedModel , który jest używany do udostępniania.