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

רכיב הצינור של Trainer TFX

רכיב הצינור Trainer TFX מאמן דגם TensorFlow.

מאמן ו- TensorFlow

Trainer עושה שימוש נרחב ב- Python TensorFlow API לצורך אימון מודלים.

רְכִיב

מאמן לוקח:

  • דוגמאות המשמשות לאימון ולהערכה.
  • קובץ מודול שסופק על ידי המשתמש המגדיר את לוגיקת המאמן.
  • סכימת נתונים שנוצרה על ידי רכיב צינור SchemaGen ושונתה באופן אופציונלי על ידי היזם.
  • הגדרת פרוטובוף לטיעונים ברכבת וטיעוני ערבות .
  • גרף טרנספורמציה (אופציונלי) המיוצר על ידי רכיב Transform במעלה הזרם.
  • (אופציונלי) מודלים מאומנים מראש המשמשים לתרחישים כגון התחלה חמה.
  • (אופציונלי) היפרפרמטרים, אשר יועברו לפונקציית מודול המשתמש. ניתן למצוא כאן את פרטי השילוב עם טיונר.

מאמן פולט: לפחות מודל אחד להסקה / הגשה (בדרך כלל ב- SavedModelFormat) ולחילופין מודל אחר להערכה (בדרך כלל EvalSavedModel).

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

מאמן מבוסס אומדן

כדי ללמוד על שימוש במודל מבוסס Estimator עם TFX ו- Trainer, ראה תכנון קוד דוגמנות TensorFlow עם tf.Estimator עבור TFX .

קביעת תצורה של רכיב מאמן

קוד פייתון DSL לצינור אופייני נראה כך:

from tfx.components import Trainer

...

trainer = Trainer(
      module_file=module_file,
      examples=transform.outputs['transformed_examples'],
      schema=infer_schema.outputs['schema'],
      base_model=latest_model_resolver.outputs['latest_model'],
      transform_graph=transform.outputs['transform_graph'],
      train_args=trainer_pb2.TrainArgs(num_steps=10000),
      eval_args=trainer_pb2.EvalArgs(num_steps=5000))

מאמן קורא למודול הדרכה, המצוין בפרמטר module_file . מודול אימונים טיפוסי נראה כך:

# TFX will call this function
def trainer_fn(trainer_fn_args, schema):
  """Build the estimator using the high level API.

  Args:
    trainer_fn_args: Holds args used to train the model as name/value pairs.
    schema: Holds the schema of the training examples.

  Returns:
    A dict of the following:

      - estimator: The estimator that will be used for training and eval.
      - train_spec: Spec for training.
      - eval_spec: Spec for eval.
      - eval_input_receiver_fn: Input function for eval.
  """
  # Number of nodes in the first layer of the DNN
  first_dnn_layer_size = 100
  num_dnn_layers = 4
  dnn_decay_factor = 0.7

  train_batch_size = 40
  eval_batch_size = 40

  tf_transform_output = tft.TFTransformOutput(trainer_fn_args.transform_output)

  train_input_fn = lambda: _input_fn(  # pylint: disable=g-long-lambda
      trainer_fn_args.train_files,
      tf_transform_output,
      batch_size=train_batch_size)

  eval_input_fn = lambda: _input_fn(  # pylint: disable=g-long-lambda
      trainer_fn_args.eval_files,
      tf_transform_output,
      batch_size=eval_batch_size)

  train_spec = tf.estimator.TrainSpec(  # pylint: disable=g-long-lambda
      train_input_fn,
      max_steps=trainer_fn_args.train_steps)

  serving_receiver_fn = lambda: _example_serving_receiver_fn(  # pylint: disable=g-long-lambda
      tf_transform_output, schema)

  exporter = tf.estimator.FinalExporter('chicago-taxi', serving_receiver_fn)
  eval_spec = tf.estimator.EvalSpec(
      eval_input_fn,
      steps=trainer_fn_args.eval_steps,
      exporters=[exporter],
      name='chicago-taxi-eval')

  run_config = tf.estimator.RunConfig(
      save_checkpoints_steps=999, keep_checkpoint_max=1)

  run_config = run_config.replace(model_dir=trainer_fn_args.serving_model_dir)
  warm_start_from = trainer_fn_args.base_model[
      0] if trainer_fn_args.base_model else None

  estimator = _build_estimator(
      # Construct layers sizes with exponetial decay
      hidden_units=[
          max(2, int(first_dnn_layer_size * dnn_decay_factor**i))
          for i in range(num_dnn_layers)
      ],
      config=run_config,
      warm_start_from=warm_start_from)

  # Create an input receiver for TFMA processing
  receiver_fn = lambda: _eval_input_receiver_fn(  # pylint: disable=g-long-lambda
      tf_transform_output, schema)

  return {
      'estimator': estimator,
      'train_spec': train_spec,
      'eval_spec': eval_spec,
      'eval_input_receiver_fn': receiver_fn
  }

מאמן גנרי

מאמן גנרי מאפשר למפתחים להשתמש בכל ממשק API של מודל TensorFlow עם רכיב המאמן. בנוסף לאומדני TensorFlow, מפתחים יכולים להשתמש בדגמי Keras או בלולאות אימון מותאמות אישית. לפרטים, אנא עיין ב- RFC למאמן גנרי .

קביעת תצורה של רכיב המאמן לשימוש ב- GenericExecutor

קוד DSL טיפוסי לצינור עבור המאמן הגנרי ייראה כך:

from tfx.components import Trainer
from tfx.components.base import executor_spec
from tfx.components.trainer.executor import GenericExecutor

...

trainer = Trainer(
    module_file=module_file,
    custom_executor_spec=executor_spec.ExecutorClassSpec(GenericExecutor),
    examples=transform.outputs['transformed_examples'],
    transform_graph=transform.outputs['transform_graph'],
    schema=infer_schema.outputs['schema'],
    train_args=trainer_pb2.TrainArgs(num_steps=10000),
    eval_args=trainer_pb2.EvalArgs(num_steps=5000))

מאמן קורא למודול הדרכה, המצוין בפרמטר module_file . במקום trainer_fn , run_fn נדרש בקובץ המודול אם ה- GenericExecutor צוין ב- custom_executor_spec .

אם לא משתמשים ברכיב הטרנספורמציה בצנרת, המאמן ייקח את הדוגמאות מ- ExampleGen ישירות:

trainer = Trainer(
    module_file=module_file,
    custom_executor_spec=executor_spec.ExecutorClassSpec(GenericExecutor),
    examples=example_gen.outputs['examples'],
    schema=infer_schema.outputs['schema'],
    train_args=trainer_pb2.TrainArgs(num_steps=10000),
    eval_args=trainer_pb2.EvalArgs(num_steps=5000))

הנה דוגמה לקובץ מודול עם run_fn .