Rejoignez la communauté SIG TFX-Addons et contribuez à rendre TFX encore meilleur ! Rejoignez SIG TFX-Addons

Le composant Tuner TFX Pipeline

Le composant Tuner règle les hyperparamètres du modèle.

Composant Tuner et bibliothèque KerasTuner

Le composant Tuner utilise largement l'API Python KerasTuner pour régler les hyperparamètres.

Composant

Le tuner prend:

  • tf.Exemples utilisés pour la formation et l'évaluation.
  • Un fichier de module fourni par l'utilisateur (ou module fn) qui définit la logique de réglage, y compris la définition du modèle, l'espace de recherche d'hyperparamètres, l'objectif, etc.
  • Définition de Protobuf des arguments de train et des arguments d'évaluation .
  • (Facultatif) Définition Protobuf des arguments de réglage.
  • (Facultatif) graphique de transformation produit par un composant Transform en amont.
  • (Facultatif) Un schéma de données créé par un composant de pipeline SchemaGen et éventuellement modifié par le développeur.

Avec les données, le modèle et l'objectif donnés, Tuner ajuste les hyperparamètres et émet le meilleur résultat.

Instructions

Une fonction de module utilisateur tuner_fn avec la signature suivante est requise pour Tuner:

...
from kerastuner.engine import base_tuner

TunerFnResult = NamedTuple('TunerFnResult', [('tuner', base_tuner.BaseTuner),
                                             ('fit_kwargs', Dict[Text, Any])])

def tuner_fn(fn_args: FnArgs) -> TunerFnResult:
  """Build the tuner using the KerasTuner API.
  Args:
    fn_args: Holds args as name/value pairs.

      - working_dir: working dir for tuning.
      - train_files: List of file paths containing training tf.Example data.
      - eval_files: List of file paths containing eval tf.Example data.
      - train_steps: number of train steps.
      - eval_steps: number of eval steps.
      - schema_path: optional schema of the input data.
      - transform_graph_path: optional transform graph produced by TFT.
  Returns:
    A namedtuple contains the following:
      - tuner: A BaseTuner that will be used for tuning.
      - fit_kwargs: Args to pass to tuner's run_trial function for fitting the
                    model , e.g., the training and validation dataset. Required
                    args depend on the above tuner's implementation.
  """
  ...

Dans cette fonction, vous définissez à la fois les espaces de recherche du modèle et des hyperparamètres, et choisissez l'objectif et l'algorithme pour le réglage. Le composant Tuner prend ce code de module comme entrée, ajuste les hyperparamètres et émet le meilleur résultat.

Le formateur peut prendre les hyperparamètres de sortie de Tuner comme entrée et les utiliser dans son code de module utilisateur. La définition du pipeline ressemble à ceci:

...
tuner = Tuner(
    module_file=module_file,  # Contains `tuner_fn`.
    examples=transform.outputs['transformed_examples'],
    transform_graph=transform.outputs['transform_graph'],
    train_args=trainer_pb2.TrainArgs(num_steps=20),
    eval_args=trainer_pb2.EvalArgs(num_steps=5))

trainer = Trainer(
    module_file=module_file,  # Contains `run_fn`.
    examples=transform.outputs['transformed_examples'],
    transform_graph=transform.outputs['transform_graph'],
    schema=schema_gen.outputs['schema'],
    # This will be passed to `run_fn`.
    hyperparameters=tuner.outputs['best_hyperparameters'],
    train_args=trainer_pb2.TrainArgs(num_steps=100),
    eval_args=trainer_pb2.EvalArgs(num_steps=5))
...

Vous ne souhaiterez peut-être pas régler les hyperparamètres chaque fois que vous réentraînez votre modèle. Une fois que vous avez utilisé Tuner pour déterminer un bon ensemble d'hyperparamètres, vous pouvez supprimer Tuner de votre pipeline et utiliser ImporterNode pour importer l'artefact Tuner d'une exécution d'entraînement précédente pour le transmettre à Trainer.

hparams_importer = ImporterNode(
    instance_name='import_hparams',
    # This can be Tuner's output file or manually edited file. The file contains
    # text format of hyperparameters (kerastuner.HyperParameters.get_config())
    source_uri='path/to/best_hyperparameters.txt',
    artifact_type=HyperParameters)

trainer = Trainer(
    ...
    # An alternative is directly use the tuned hyperparameters in Trainer's user
    # module code and set hyperparameters to None here.
    hyperparameters = hparams_importer.outputs['result'])

Réglage sur Google Cloud Platform (GCP)

Lorsqu'il est exécuté sur Google Cloud Platform (GCP), le composant Tuner peut bénéficier de deux services:

AI Platform Vizier comme backend du réglage des hyperparamètres

AI Platform Vizier est un service géré qui effectue une optimisation de la boîte noire, basée sur la technologie Google Vizier .

CloudTuner est une implémentation de KerasTuner qui communique avec le service AI Platform Vizier en tant que backend d'étude. Étant donné que CloudTuner est une sous-classe de kerastuner.Tuner , il peut être utilisé comme remplacement tuner_fn dans le module tuner_fn et s'exécuter en tant que partie du composant TFX Tuner.

Vous trouverez ci-dessous un extrait de code qui montre comment utiliser CloudTuner . Notez que la configuration de CloudTuner nécessite des éléments spécifiques à GCP, tels que project_id et region .

...
from tensorflow_cloud import CloudTuner

...
def tuner_fn(fn_args: FnArgs) -> TunerFnResult:
  """An implementation of tuner_fn that instantiates CloudTuner."""

  ...
  tuner = CloudTuner(
      _build_model,
      hyperparameters=...,
      ...
      project_id=...,       # GCP Project ID
      region=...,           # GCP Region where Vizier service is run.
  )

  ...
  return TuneFnResult(
      tuner=tuner,
      fit_kwargs={...}
  )

Réglage parallèle sur le flock de travailleurs distribués de Cloud AI Platform Training

Le framework KerasTuner en tant qu'implémentation sous-jacente du composant Tuner a la capacité d'effectuer une recherche d'hyperparamètres en parallèle. Bien que le composant Stock Tuner n'ait pas la capacité d'exécuter plus d'un moteur de recherche en parallèle, en utilisant le composant Tuner d'extension Google Cloud AI Platform , il offre la possibilité d'exécuter un réglage en parallèle, en utilisant une tâche de formation AI Platform en tant que floc de travailleurs distribués. directeur. TuneArgs est la configuration donnée à ce composant. Il s'agit d'un remplacement instantané du composant Tuner d'origine.

tuner = google_cloud_ai_platform.Tuner(
    ...   # Same kwargs as the above stock Tuner component.
    tune_args=proto.TuneArgs(num_parallel_trials=3),  # 3-worker parallel
    custom_config={
        # Configures Cloud AI Platform-specific configs . For for details, see
        # https://cloud.google.com/ai-platform/training/docs/reference/rest/v1/projects.jobs#traininginput.
        TUNING_ARGS_KEY:
            {
                'project': ...,
                'region': ...,
                # Configuration of machines for each master/worker in the flock.
                'masterConfig': ...,
                'workerConfig': ...,
                ...
            }
    })
...

Le comportement et la sortie du composant d'extension Tuner sont les mêmes que ceux du composant stock Tuner, sauf que plusieurs recherches d'hyperparamètres sont exécutées en parallèle sur différentes machines de travail, et par conséquent, les num_trials seront terminés plus rapidement. Ceci est particulièrement efficace lorsque l'algorithme de recherche est parallélisable de manière embarrassante, comme RandomSearch . Cependant, si l'algorithme de recherche utilise des informations issues des résultats d'essais antérieurs, comme l'algorithme Google Vizier implémenté dans AI Platform Vizier, une recherche excessivement parallèle affecterait négativement l'efficacité de la recherche.

Exemple E2E

Exemple E2E CloudTuner sur GCP

Tutoriel KerasTuner

Tutoriel CloudTuner

Proposition

Plus de détails sont disponibles dans la référence de l'API Tuner .