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
L'accordeur 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 train et eval args.
- (Facultatif) Définition Protobuf des arguments de réglage.
- (Facultatif) graphe de transformation produit par un composant de transformation 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 règle 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 vous choisissez l'objectif et l'algorithme de réglage. Le composant Tuner prend ce code de module en entrée, règle 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 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 voudrez 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 de formation précédente pour alimenter 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'])
Réglage sur Google Cloud Platform (GCP)
Lorsqu'il s'exécute sur Google Cloud Platform (GCP), le composant Tuner peut tirer parti de deux services :
- AI Platform Vizier (via la mise en œuvre de CloudTuner)
- AI Platform Training (en tant que gestionnaire de troupeau pour le réglage distribué)
AI Platform Vizier en tant que 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 keras_tuner.Tuner , il peut être utilisé comme remplacement dans le module tuner_fn et exécuté 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 nœuds de calcul 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 plus d'un agent de recherche en parallèle, en utilisant le composant Tuner de l'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 comme un troupeau de travailleurs distribués. directeur. TuneArgs est la configuration donnée à ce composant. Il s'agit d'un remplacement direct 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 provenant de 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.
Liens
Exemple E2E CloudTuner sur GCP
Plus de détails sont disponibles dans la référence de l'API Tuner .