Ajuda a proteger a Grande Barreira de Corais com TensorFlow em Kaggle Junte Desafio

O componente Tuner TFX Pipeline

O componente Tuner ajusta os hiperparâmetros para o modelo.

Componente Tuner e biblioteca KerasTuner

O componente Tuner faz uso extensivo do Python KerasTuner API para hiperparâmetros ajuste.

Componente

O sintonizador leva:

  • tf.Exemplos usados ​​para treinamento e avaliação.
  • Um arquivo de módulo fornecido pelo usuário (ou módulo fn) que define a lógica de ajuste, incluindo definição de modelo, espaço de pesquisa de hiperparâmetro, objetivo etc.
  • Protobuf definição de args trem e args eval.
  • (Opcional) Protobuf definição de args de ajuste.
  • (Opcional) gráfico de transformação produzido por um componente Transform upstream.
  • (Opcional) Um esquema de dados criado por um componente de pipeline SchemaGen e opcionalmente alterado pelo desenvolvedor.

Com os dados, modelo e objetivo fornecidos, o Tuner sintoniza os hiperparâmetros e emite o melhor resultado.

Instruções

A função módulo de usuário tuner_fn com a seguinte assinatura é necessário para 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.
  """
  ...

Nesta função, você define os espaços de pesquisa do modelo e do hiperparâmetro e escolhe o objetivo e o algoritmo para ajuste. O componente Tuner recebe este código do módulo como entrada, ajusta os hiperparâmetros e emite o melhor resultado.

O Trainer pode pegar os hiperparâmetros de saída do Sintonizador como entrada e utilizá-los em seu código de módulo de usuário. A definição do pipeline é semelhante a esta:

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

Você pode não querer ajustar os hiperparâmetros toda vez que treinar novamente seu modelo. Depois de ter utilizado Tuner para determinar um bom conjunto de hiperparâmetros, você pode remover Tuner do seu gasoduto eo uso ImporterNode para importar o artefato Tuner de um treinamento prévio correr para alimentação para instrutor.

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'])

Ajuste no Google Cloud Platform (GCP)

Quando executado no Google Cloud Platform (GCP), o componente Tuner pode tirar proveito de dois serviços:

AI Platform Vizier como back-end do ajuste de hiperparâmetros

AI Platform Vizier é um serviço gerenciado que executa otimização de caixa preta, com base no Google Vizier tecnologia.

CloudTuner é uma implementação do KerasTuner que fala ao serviço AI Platform Vizier como o backend estudo. Desde CloudTuner é uma subclasse de keras_tuner.Tuner , ele pode ser usado como um substituto no tuner_fn módulo, e executar como parte do componente TFX Tuner.

Abaixo está um trecho de código que mostra como usar CloudTuner . Observe que a configuração para CloudTuner requer itens que são específicos para GCP, como o 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={...}
  )

Ajuste paralelo no rebanho de trabalhadores distribuídos do Cloud AI Platform Training

A estrutura KerasTuner como a implementação subjacente do componente Tuner tem a capacidade de conduzir pesquisas de hiperparâmetros em paralelo. Enquanto o componente de estoque Tuner não tem capacidade de executar mais de um trabalhador de pesquisa em paralelo, usando a componente de extensão Tuner Google Cloud AI Platform , que oferece a capacidade de executar ajuste paralelo, usando um Job Training AI Plataforma como um rebanho trabalhador distribuídos Gerente. TuneArgs é a configuração dada a esse componente. Esta é uma substituição instantânea do componente Tuner de estoque.

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': ...,
                ...
            }
    })
...

O comportamento ea saída do componente de extensão Tuner é o mesmo que o componente de estoque Tuner, exceto que várias pesquisas hiperparâmetro são executados em paralelo em diferentes máquinas de trabalho, e, como resultado, os num_trials será concluído mais rapidamente. Isto é particularmente eficaz quando o algoritmo de busca é embaraçosamente paralelizável, como RandomSearch . No entanto, se o algoritmo de pesquisa usar informações de resultados de testes anteriores, como o algoritmo Google Vizier implementado no AI Platform Vizier, uma pesquisa excessivamente paralela afetaria negativamente a eficácia da pesquisa.

Exemplo E2E

E2E CloudTuner no Exemplo de GCP

Tutorial do KerasTuner

Tutorial CloudTuner

Proposta

Mais detalhes estão disponíveis no referência Tuner API .