דף זה תורגם על ידי Cloud Translation API.

TensorFlow 2.x ב-TFX

TensorFlow 2.0 שוחרר בשנת 2019 , עם אינטגרציה הדוקה של Keras , ביצוע להוט כברירת מחדל, וביצוע פונקציות Pythonic , בין שאר התכונות והשיפורים החדשים .

מדריך זה מספק סקירה טכנית מקיפה של TF 2.x ב-TFX.

באיזו גרסה להשתמש?

TFX תואם ל-TensorFlow 2.x, וממשקי ה-API ברמה גבוהה שהיו קיימים ב-TensorFlow 1.x (במיוחד Estimators) ממשיכים לעבוד.

התחל פרויקטים חדשים ב- TensorFlow 2.x

מכיוון ש-TensorFlow 2.x שומר על היכולות ברמה גבוהה של TensorFlow 1.x, אין יתרון לשימוש בגרסה הישנה יותר בפרויקטים חדשים, גם אם אינכם מתכננים להשתמש בתכונות החדשות.

לכן, אם אתה מתחיל פרויקט TFX חדש, אנו ממליצים להשתמש ב- TensorFlow 2.x. ייתכן שתרצה לעדכן את הקוד שלך מאוחר יותר כאשר תמיכה מלאה ב-Keras ותכונות חדשות אחרות תהיה זמינה, והיקף השינויים יהיה מוגבל הרבה יותר אם תתחיל עם TensorFlow 2.x, במקום לנסות לשדרג מ-TensorFlow 1.x ב- העתיד.

המרת פרויקטים קיימים ל- TensorFlow 2.x

הקוד שנכתב עבור TensorFlow 1.x תואם במידה רבה ל-TensorFlow 2.x וימשיך לעבוד ב-TFX.

עם זאת, אם תרצה לנצל את היתרונות של שיפורים ותכונות חדשות כאשר הם הופכים לזמינים ב-TF 2.x, תוכל לבצע את ההוראות להעברה ל-TF 2.x.

אומדן

ה-API של Estimator נשמר ב-TensorFlow 2.x, אך אינו המוקד של תכונות חדשות ופיתוח. קוד שנכתב ב-TensorFlow 1.x או 2.x באמצעות Estimators ימשיך לעבוד כצפוי ב-TFX.

הנה דוגמה מקצה לקצה של TFX באמצעות אומדן טהור: דוגמה למונית (אומדן)

Keras עם `model_to_estimator`

ניתן לעטוף את דגמי Keras עם הפונקציה tf.keras.estimator.model_to_estimator , המאפשרת להם לעבוד כאילו היו אומדנים. כדי להשתמש בזה:

בנה דגם של קרס.
העבירו את המודל המלודר לתוך model_to_estimator .
השתמש בתוצאה של model_to_estimator ב-Trainer, כמו שאתה משתמש בדרך כלל באומד.

# 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,
      ...
  }

מלבד קובץ מודול המשתמש של Trainer, שאר הצינור נשאר ללא שינוי.

Native Keras (כלומר Keras ללא `model_to_estimator` )

דוגמאות וקולאב

להלן מספר דוגמאות עם Keras מקורי:

פינגווין ( קובץ מודול ): 'שלום עולם' דוגמה מקצה לקצה.
MNIST ( קובץ מודול ): תמונה ודוגמה מקצה לקצה של TFLite.
מונית ( קובץ מודול ): דוגמה מקצה לקצה עם שימוש מתקדם ב-Transform.

יש לנו גם קרס קולאב לכל רכיב.

רכיבי TFX

הסעיפים הבאים מסבירים כיצד רכיבי TFX קשורים תומכים ב-Keras מקוריות.

שינוי צורה

ל-Transform יש כרגע תמיכה ניסיונית עבור דגמי Keras.

ניתן להשתמש ברכיב Transform עצמו עבור Keras מקורי ללא שינוי. ההגדרה preprocessing_fn נשארת זהה, באמצעות TensorFlow ו- tf.Transform ops.

פונקציית ההגשה ופונקציית eval משתנים עבור Keras ילידים. פרטים יידונו בחלקי המאמן והמעריך הבאים.

מְאַמֵן

כדי להגדיר את ה-Keras מקורי, יש להגדיר את GenericExecutor עבור רכיב Trainer כדי להחליף את ברירת המחדל של ה-Executor המבוסס על Estimator. לפרטים, אנא בדוק כאן .

קובץ Keras Module עם Transform

קובץ מודול האימון חייב להכיל run_fn אשר ייקרא על ידי GenericExecutor , run_fn טיפוסי של Keras ייראה כך:

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)

ב- run_fn למעלה, יש צורך בחתימת הגשה בעת ייצוא המודל המאומן, כך שהמודל יוכל לקחת דוגמאות גולמיות לחיזוי. פונקציית הגשה טיפוסית תיראה כך:

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

בפונקציית ההגשה לעיל, יש להחיל טרנספורמציות tf.Transform על הנתונים הגולמיים לצורך הסקת מסקנות, באמצעות שכבת tft.TransformFeaturesLayer . ה _serving_input_receiver_fn הקודם שנדרש עבור Estimators לא יהיה עוד צורך עם Keras.

קובץ Keras Module ללא טרנספורמציה

זה דומה לקובץ המודול המוצג לעיל, אך ללא השינויים:

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

בשלב זה TFX תומך רק באסטרטגיות עובד בודד (למשל, MirroredStrategy , OneDeviceStrategy ).

כדי להשתמש באסטרטגיית הפצה, צור אסטרטגיה מתאימה של tf.distribute. והעבר את היצירה וההידור של מודל Keras בתוך היקף אסטרטגיה.

לדוגמה, החלף 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(...)

כדי לאמת את ההתקן (CPU/GPU) המשמש את MirroredStrategy , הפעל רישום זרימת טנסור ברמת המידע:

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

ואתה אמור להיות מסוגל לראות Using MirroredStrategy with devices (...) ביומן.

מעריך

ב-TFMA v0.2x, ModelValidator ו-Evaluator שולבו לרכיב Evaluator חדש אחד. רכיב ה-Evaluator החדש יכול לבצע גם הערכת מודל בודד וגם לאמת את המודל הנוכחי בהשוואה למודלים קודמים. עם השינוי הזה, רכיב ה-Pusher צורך כעת תוצאת ברכה מ-Evaluator במקום ModelValidator.

ה-Evaluator החדש תומך במודלים של Keras וכן במודלים של Estimator. המודל _eval_input_receiver_fn ו-eval שמור שנדרשו בעבר לא יהיו נחוצים יותר עם Keras, שכן Evaluator מבוסס כעת על אותו SavedModel המשמש להגשה.

ראה מעריך למידע נוסף .