Il componente Tuner ottimizza gli iperparametri per il modello.
Componente Tuner e libreria KerasTuner
Il componente Tuner fa ampio uso dell'API Python KerasTuner per l'ottimizzazione degli iperparametri.
Componente
Il sintonizzatore richiede:
- tf.Esempi utilizzati per la formazione e la valutazione.
- Un file di modulo fornito dall'utente (o modulo fn) che definisce la logica di ottimizzazione, inclusa la definizione del modello, lo spazio di ricerca degli iperparametri, l'obiettivo ecc.
- Definizione del protobuf degli argomenti train e degli argomenti eval.
- (Facoltativo) Definizione Protobuf degli argomenti di ottimizzazione.
- (Facoltativo) grafico di trasformazione prodotto da un componente di trasformazione upstream.
- (Facoltativo) Uno schema di dati creato da un componente della pipeline SchemaGen e facoltativamente modificato dallo sviluppatore.
Con i dati, il modello e l'obiettivo forniti, Tuner ottimizza gli iperparametri e produce il risultato migliore.
Istruzioni
Per Tuner è richiesta una funzione del modulo utente tuner_fn con la seguente firma:
...
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.
"""
...
In questa funzione definisci sia lo spazio di ricerca del modello che quello degli iperparametri e scegli l'obiettivo e l'algoritmo per l'ottimizzazione. Il componente Tuner accetta questo codice del modulo come input, ottimizza gli iperparametri e produce il risultato migliore.
Il trainer può prendere gli iperparametri di output del sintonizzatore come input e utilizzarli nel codice del modulo utente. La definizione della pipeline è simile alla seguente:
...
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))
...
Potrebbe non essere necessario ottimizzare gli iperparametri ogni volta che si riqualifica il modello. Dopo aver utilizzato Tuner per determinare un buon set di iperparametri, puoi rimuovere Tuner dalla pipeline e utilizzare ImporterNode per importare l'artefatto Tuner da un'esecuzione di training precedente per inviarlo a 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'])
Ottimizzazione su Google Cloud Platform (GCP)
Quando viene eseguito su Google Cloud Platform (GCP), il componente Tuner può usufruire di due servizi:
- AI Platform Visir (tramite l'implementazione di CloudTuner)
- Formazione sulla piattaforma AI (come gestore dello stormo per la messa a punto distribuita)
AI Platform Vizier come backend dell'ottimizzazione degli iperparametri
AI Platform Vizier è un servizio gestito che esegue l'ottimizzazione della scatola nera, basato sulla tecnologia Google Vizier .
CloudTuner è un'implementazione di KerasTuner che comunica con il servizio AI Platform Vizier come backend dello studio. Poiché CloudTuner è una sottoclasse di keras_tuner.Tuner , può essere utilizzato come sostituto immediato nel modulo tuner_fn ed eseguito come parte del componente TFX Tuner.
Di seguito è riportato uno snippet di codice che mostra come utilizzare CloudTuner . Tieni presente che la configurazione di CloudTuner richiede elementi specifici di GCP, come project_id e 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={...}
)
Ottimizzazione parallela sulla piattaforma Cloud AI Formazione di gruppi di lavoratori distribuiti
Il framework KerasTuner come implementazione sottostante del componente Tuner ha la capacità di condurre la ricerca degli iperparametri in parallelo. Sebbene il componente Tuner standard non abbia la capacità di eseguire più di un operatore di ricerca in parallelo, utilizzando il componente Tuner dell'estensione Google Cloud AI Platform , offre la possibilità di eseguire l'ottimizzazione parallela, utilizzando un lavoro di formazione di AI Platform come uno stormo di lavoratori distribuito manager. TuneArgs è la configurazione data a questo componente. Si tratta di una sostituzione immediata del componente sintonizzatore di serie.
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': ...,
...
}
})
...
Il comportamento e l'output del componente Tuner dell'estensione sono gli stessi del componente Tuner standard, ad eccezione del fatto che più ricerche di iperparametri vengono eseguite in parallelo su diverse macchine lavoratore e, di conseguenza, num_trials verranno completate più velocemente. Ciò è particolarmente efficace quando l'algoritmo di ricerca è parallelizzabile in modo imbarazzante, come RandomSearch . Tuttavia, se l’algoritmo di ricerca utilizza informazioni provenienti da risultati di sperimentazioni precedenti, come fa l’algoritmo di Google Vizier implementato nella piattaforma AI Vizier, una ricerca eccessivamente parallela influirebbe negativamente sull’efficacia della ricerca.
Collegamenti
Esempio di E2E CloudTuner su GCP
Maggiori dettagli sono disponibili nel riferimento API Tuner .