TensorFlow 2.0 został wydany w 2019 roku , ze ścisłą integracją Keras , domyślnym szybkim wykonaniem i wykonaniem funkcji Pythonic , a także innymi nowymi funkcjami i ulepszeniami .
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, w jaki sposób 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.