Le composant Tuner ajuste 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 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 fournis, 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 keras_tuner.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 à régler. Le composant Tuner prend ce code de module en entrée, ajuste les hyperparamètres et émet le meilleur résultat.
Le formateur peut prendre les hyperparamètres de sortie de Tuner en entrée et les utiliser dans le code de son 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 ajuster les hyperparamètres à chaque fois que vous recyclez 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 afin de l'alimenter dans Trainer.
hparams_importer = Importer(
# This can be Tuner's output file or manually edited file. The file contains
# text format of hyperparameters (keras_tuner.HyperParameters.get_config())
source_uri='path/to/best_hyperparameters.txt',
artifact_type=HyperParameters,
).with_id('import_hparams')
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'])
Optimisation sur Google Cloud Platform (GCP)
Lorsqu'il est exécuté sur Google Cloud Platform (GCP), le composant Tuner peut profiter de deux services :
- AI Platform Vizier (via l'implémentation de CloudTuner)
- Formation AI Platform (en tant que gestionnaire de troupeaux pour le réglage distribué)
AI Platform Vizier comme backend du réglage des hyperparamètres
AI Platform Vizier est un service géré qui effectue une optimisation de 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 comme backend d'étude. Étant donné que CloudTuner est une sous-classe de keras_tuner.Tuner , il peut être utilisé en remplacement dans le module tuner_fn et s'exécuter dans le cadre 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 troupeau de travailleurs distribués 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 plusieurs agents 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 parallèle, en utilisant une tâche de formation AI Platform en tant que troupeau de travailleurs distribué. directeur. TuneArgs est la configuration donnée à ce composant. Il s'agit d'un remplacement immédiat 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 le résultat 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 provenant des résultats d'essais antérieurs, comme le fait l'algorithme Google Vizier implémenté dans AI Platform Vizier, une recherche excessivement parallèle affecterait négativement l'efficacité de la recherche.
Links
Exemple E2E CloudTuner sur GCP
Plus de détails sont disponibles dans la référence de l'API Tuner .