Entrare in sintonia con le prime donne in ML Simposio questo Martedì 19 ottobre alle 9 PST Registrarsi

Il componente della conduttura del sintonizzatore TFX

Il componente Tuner ottimizza gli iperparametri per il modello.

Componente Tuner e libreria KerasTuner

Il componente Tuner fa ampio uso di Python KerasTuner API per iperparametri tuning.

Componente

Il sintonizzatore richiede:

  • tf.Esempi utilizzati per l'addestramento 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.
  • Protobuf definizione di args treni e args eval.
  • (Opzionale) Protobuf definizione di args tuning.
  • (Facoltativo) grafico di trasformazione prodotto da un componente Trasforma a monte.
  • (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 sintonizza gli iperparametri ed emette il miglior risultato.

Istruzioni

Una funzione modulo utilizzatore tuner_fn con la seguente firma è necessaria per 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.
  """
  ...

In questa funzione, definisci sia il modello che gli spazi di ricerca degli iperparametri e scegli l'obiettivo e l'algoritmo per l'ottimizzazione. Il componente Tuner prende questo codice del modulo come input, regola gli iperparametri ed emette il miglior risultato.

Trainer può prendere gli iperparametri di output di Tuner come input e utilizzarli nel codice del modulo utente. La definizione della pipeline è simile a questa:

...
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))
...

Potresti non voler regolare gli iperparametri ogni volta che riaddestra il tuo modello. Una volta che avete utilizzato Tuner per determinare un buon set di iperparametri, è possibile rimuovere il sintonizzatore dalla pipeline e l'utilizzo ImporterNode per importare il manufatto Tuner da una precedente formazione correre al feed per 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 (keras_tuner.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'])

Ottimizzazione su Google Cloud Platform (GCP)

Quando è in esecuzione su Google Cloud Platform (GCP), il componente Tuner può usufruire di due servizi:

AI Platform Visir come backend per l'ottimizzazione degli iperparametri

AI Platform Visir è un servizio gestito che esegue l'ottimizzazione scatola nera, sulla base del Google visir tecnologia.

CloudTuner è un'implementazione di KerasTuner che parla al servizio AI Platform Visir come lo studio backend. Poiché CloudTuner è una sottoclasse di keras_tuner.Tuner , può essere utilizzato come un rimpiazzo nel tuner_fn modulo, ed eseguire come parte del componente TFX sintonizzatore.

Di seguito è riportato un frammento di codice che mostra come utilizzare CloudTuner . Si noti che la configurazione a CloudTuner richiede elementi peculiari GCP, come il 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 su Cloud AI Platform Formazione di un gruppo di lavoratori distribuiti

Il framework KerasTuner come implementazione sottostante del componente Tuner ha la capacità di condurre ricerche di iperparametri in parallelo. Mentre la componente magazzino Tuner non ha la capacità di eseguire più di un lavoratore di ricerca in parallelo, utilizzando il componente di estensione Tuner Google Cloud Platform IA , fornisce la possibilità di eseguire la sintonizzazione in parallelo, utilizzando un Job Training AI Platform come un gregge operaio distribuito manager. TuneArgs è la configurazione data a questo componente. Questa è una sostituzione drop-in del componente del 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'uscita del componente di estensione Tuner è lo stesso del componente magazzino sintonizzatore, tranne che più ricerche iperparametro sono eseguite in parallelo su diverse macchine lavoratori, e come risultato, i num_trials saranno completati velocemente. Ciò è particolarmente efficace quando l'algoritmo di ricerca è imbarazzante parallelizzabile, come ad esempio RandomSearch . Tuttavia, se l'algoritmo di ricerca utilizza informazioni dai risultati di prove precedenti, come fa l'algoritmo di Google Vizier implementato in AI Platform Vizier, una ricerca eccessivamente parallela influenzerebbe negativamente l'efficacia della ricerca.

E2E Esempio

E2E CloudTuner su esempio GCP

Tutorial KerasTuner

Tutorial CloudTuner

Proposta

Maggiori dettagli sono disponibili nel riferimento sintonizzatore API .