Crie uma tarefa de hiperaperfeiçoamento de parâmetros

Os hiperparâmetros são variáveis que regem o processo de preparação de um modelo, como o tamanho do lote ou o número de camadas ocultas numa rede neural profunda. O aperfeiçoamento de hiperparâmetros procura a melhor combinação de valores de hiperparâmetros otimizando os valores das métricas numa série de testes. As métricas são resumos escalares que adiciona ao seu preparador, como a precisão do modelo.

Saiba mais sobre o aperfeiçoamento de hiperparâmetros no Vertex AI. Para ver um exemplo passo a passo, consulte o Vertex AI: Hyperparameter Tuning codelab.

Esta página mostra como:

Prepare a sua candidatura à formação

Numa tarefa de hiperaperfeiçoamento dos parâmetros, o Vertex AI cria avaliações da sua tarefa de preparação com diferentes conjuntos de hiperparâmetros e avalia a eficácia de uma avaliação através das métricas que especificou. O Vertex AI transmite valores de hiperparâmetros à sua aplicação de preparação como argumentos de linha de comandos. Para que o Vertex AI avalie a eficácia de um teste, a sua aplicação de preparação tem de comunicar as métricas ao Vertex AI.

As secções seguintes descrevem:

  • Como o Vertex AI transmite hiperparâmetros à sua aplicação de preparação.
  • Opções para transmitir métricas da sua aplicação de preparação para o Vertex AI.

Para saber mais sobre os requisitos das aplicações de preparação personalizadas que são executadas no Vertex AI, leia o artigo Requisitos do código de preparação.

Processar os argumentos da linha de comandos para os hiperparâmetros que quer otimizar

O Vertex AI define argumentos de linha de comandos quando chama a sua aplicação de preparação. Use os argumentos da linha de comandos no seu código:

  1. Defina um nome para cada argumento de hiperparâmetro e analise-o usando o analisador de argumentos que preferir, como argparse. Use os mesmos nomes de argumentos ao configurar a tarefa de preparação de hiperparâmetros.

    Por exemplo, se a sua aplicação de preparação for um módulo Python denominado my_trainer e estiver a otimizar um hiperparâmetro denominado learning_rate, o Vertex AI inicia cada teste com um comando semelhante ao seguinte:

    python3 -m my_trainer --learning_rate learning-rate-in-this-trial

    A Vertex AI determina o learning-rate-in-this-trial e transmite-o através do argumento learning_rate.

  2. Atribua os valores dos argumentos da linha de comandos aos hiperparâmetros no código de preparação.

Saiba mais acerca dos requisitos para analisar argumentos da linha de comandos.

Comunique as suas métricas ao Vertex AI

Para comunicar as suas métricas ao Vertex AI, use o cloudml-hypertune pacote Python. Esta biblioteca fornece funções auxiliares para comunicar métricas à Vertex AI.

Saiba mais acerca dos relatórios de métricas de hiperparâmetros.

Crie uma tarefa de hiperaperfeiçoamento de parâmetros

Dependendo da ferramenta que quer usar para criar um HyperparameterTuningJob, selecione um dos seguintes separadores:

Consola

Na consola Google Cloud , não pode criar um recurso HyperparameterTuningJob diretamente. No entanto, pode criar um recurso TrainingPipeline que crie um HyperparameterTuningJob.

As instruções seguintes descrevem como criar um TrainingPipeline que cria um HyperparameterTuningJob e não faz mais nada. Se quiser usar funcionalidades TrainingPipeline adicionais, como a preparação com um conjunto de dados gerido, leia o artigo Criar pipelines de preparação.

  1. Na Google Cloud consola, na secção Vertex AI, aceda à página Pipelines de preparação.

    Aceda a Pipelines de formação

  2. Clique em Criar para abrir o painel Formar novo modelo.

  3. No passo Método de preparação, especifique as seguintes definições:

    1. Na lista pendente Conjunto de dados, selecione Nenhum conjunto de dados gerido.

    2. Selecione Preparação personalizada (avançada).

    Clique em Continuar.

  4. No passo Detalhes do modelo, escolha Treinar novo modelo ou Treinar nova versão. Se selecionar Preparar novo modelo, introduza um nome à sua escolha, MODEL_NAME, para o modelo. Clique em Continuar.

  5. No passo Contentor de preparação, especifique as seguintes definições:

    1. Selecione se quer usar um contentor pré-criado ou um contentor personalizado para a preparação.

    2. Consoante a sua escolha, opte por uma das seguintes ações:

    3. No campo Diretório de saída do modelo, pode especificar o URI do Cloud Storage de um diretório num contentor ao qual tem acesso. O diretório não tem de existir.

      Este valor é transmitido para a Vertex AI no campo baseOutputDirectoryAPI, que define várias variáveis de ambiente às quais a sua aplicação de preparação pode aceder quando é executada.

    4. Opcional: no campo Argumentos, pode especificar argumentos para o Vertex AI usar quando começar a executar o código de preparação. O comprimento máximo de todos os argumentos combinados é de 100 000 carateres. O comportamento destes argumentos difere consoante o tipo de contentor que está a usar:

    Clique em Continuar.

  6. No passo Ajuste de hiperparâmetros, selecione a caixa de verificação Ativar ajuste de hiperparâmetros e especifique as seguintes definições:

    1. Na secção Novo hiperparâmetro, especifique o Nome do parâmetro e o Tipo de um hiperparâmetro que quer otimizar. Consoante o tipo especificado, configure as definições de hiperparâmetros adicionais apresentadas.

      Saiba mais sobre os tipos de hiperparâmetros e as respetivas configurações.

    2. Se quiser otimizar mais do que um hiperparâmetro, clique em Adicionar novo parâmetro e repita o passo anterior na nova secção apresentada.

      Repita este procedimento para cada hiperparâmetro que quer otimizar.

    3. No campo Métrica a otimizar e na lista pendente Objetivo, especifique o nome e o objetivo da métrica que quer otimizar.

    4. No campo Número máximo de tentativas, especifique o número máximo de tentativas que quer que o Vertex AI execute para a tarefa de ajuste de hiperparâmetros.

    5. No campo Número máximo de tentativas paralelas, especifique o número máximo de tentativas que o Vertex AI pode executar em simultâneo.

    6. Na lista pendente Algoritmo de pesquisa, especifique um algoritmo de pesquisa para o Vertex AI usar.

    7. Ignore o botão Ativar paragem antecipada, que não tem efeito.

    Clique em Continuar.

  7. No passo Calcular e preços, especifique as seguintes definições:

    1. Na lista pendente Região, selecione uma "região que suporte a preparação personalizada"

    2. Na secção Worker pool 0, especifique os recursos de computação a usar para a preparação.

      Se especificar aceleradores, certifique-se de que o tipo de acelerador que escolher está disponível na região selecionada.

      Se quiser realizar treino distribuído, clique em Adicionar mais conjuntos de trabalhadores e especifique um conjunto adicional de recursos de computação para cada conjunto de trabalhadores adicional que quiser.

    Clique em Continuar.

  8. No passo Contentor de previsão, selecione Nenhum contentor de previsão.

  9. Clique em Iniciar preparação para iniciar o pipeline de preparação personalizado.

gcloud

Os passos seguintes mostram como usar a CLI Google Cloud para criar um HyperparameterTuningJob com uma configuração relativamente mínima. Para saber mais acerca de todas as opções de configuração que pode usar para esta tarefa, consulte a documentação de referência para o comando gcloud ai hp-tuning-jobs create e o recurso da API HyperparameterTuningJob.

  1. Crie um ficheiro YAML denominado config.yaml com alguns campos da API que quer especificar para o novo HyerparameterTuningJob:

    config.yaml
    studySpec:
  metrics:
  - metricId: METRIC_ID
    goal: METRIC_GOAL
  parameters:
  - parameterId: HYPERPARAMETER_ID
    doubleValueSpec:
      minValue: DOUBLE_MIN_VALUE
      maxValue: DOUBLE_MAX_VALUE
trialJobSpec:
  workerPoolSpecs:
    - machineSpec:
        machineType: MACHINE_TYPE
      replicaCount: 1
      containerSpec:
        imageUri: CUSTOM_CONTAINER_IMAGE_URI

    Substitua o seguinte:

  2. No mesmo diretório que o ficheiro config.yaml, execute o seguinte comando de shell:

    gcloud ai hp-tuning-jobs create \
    --region=LOCATION \
    --display-name=DISPLAY_NAME \
    --max-trial-count=MAX_TRIAL_COUNT \
    --parallel-trial-count=PARALLEL_TRIAL_COUNT \
    --config=config.yaml

    Substitua o seguinte:

REST

Use o seguinte exemplo de código para criar uma tarefa de otimização de hiperparâmetros com o método create do recurso hyperparameterTuningJob.

Antes de usar qualquer um dos dados do pedido, faça as seguintes substituições:

  • LOCATION: a região onde quer criar o HyperparameterTuningJob. Use uma região que suporte o treino personalizado.
  • PROJECT: o seu ID do projeto.
  • DISPLAY_NAME: um nome a apresentar memorável à sua escolha para o HyperparameterTuningJob. Consulte o recurso REST.
  • Especifique as suas métricas:
  • Especifique os hiperparâmetros:
    • HYPERPARAMETER_ID: o nome de um hiperparâmetro a ser ajustado. O seu código de preparação tem de analisar uma flag de linha de comandos com este nome.
    • PARAMETER_SCALE: (opcional.) Como o parâmetro deve ser dimensionado. Deixe não definido para parâmetros CATEGORICAL. Pode ser UNIT_LINEAR_SCALE, UNIT_LOG_SCALE, UNIT_REVERSE_LOG_SCALE ou SCALE_TYPE_UNSPECIFIED
    • Se o tipo deste hiperparâmetro for DOUBLE, especifique os valores mínimo (DOUBLE_MIN_VALUE) e máximo (DOUBLE_MAX_VALUE) para este hiperparâmetro.
    • Se o tipo deste hiperparâmetro for INTEGER, especifique os valores mínimo (INTEGER_MIN_VALUE) e máximo (INTEGER_MAX_VALUE) para este hiperparâmetro.
    • Se o tipo deste hiperparâmetro for CATEGORICAL, especifique os valores aceitáveis (CATEGORICAL_VALUES) como uma matriz de strings.
    • Se o tipo deste hiperparâmetro for DISCRETE, especifique os valores aceitáveis (DISCRETE_VALUES) como uma matriz de números.
    • Especifique hiperparâmetros condicionais. Os hiperparâmetros condicionais são adicionados a uma avaliação quando o valor do hiperparâmetro principal corresponde à condição especificada. Saiba mais sobre os hiperparâmetros condicionais.
      • CONDITIONAL_PARAMETER: O ParameterSpec do parâmetro condicional. Esta especificação inclui o nome, a escala, o intervalo de valores do parâmetro e quaisquer parâmetros condicionais que dependam deste hiperparâmetro.
      • Se o tipo do hiperparâmetro principal for INTEGER, especifique uma lista de números inteiros como o INTEGERS_TO_MATCH. Se o valor do hiperparâmetro principal corresponder a um dos valores especificados, este parâmetro condicional é adicionado ao teste.
      • Se o tipo do hiperparâmetro principal for CATEGORICAL, especifique uma lista de categorias como o CATEGORIES_TO_MATCH. Se o valor do hiperparâmetro principal corresponder a um dos valores especificados, este parâmetro condicional é adicionado ao teste.
      • Se o tipo do hiperparâmetro principal for DISCRETE, especifique uma lista de números inteiros como o DISCRETE_VALUES_TO_MATCH. Se o valor do hiperparâmetro principal corresponder a um dos valores especificados, este parâmetro condicional é adicionado ao teste.
  • ALGORITHM: (opcional.) O algoritmo de pesquisa a usar nesta tarefa de hiperaperfeiçoamento dos parâmetros. Pode ser ALGORITHM_UNSPECIFIED, GRID_SEARCH ou RANDOM_SEARCH.
  • MAX_TRIAL_COUNT: o número máximo de testes a executar.
  • PARALLEL_TRIAL_COUNT: o número máximo de testes a executar em paralelo.
  • MAX_FAILED_TRIAL_COUNT: o número de tarefas que podem falhar antes de a tarefa de aperfeiçoamento de hiperparâmetros falhar.
  • Defina a tarefa de formação personalizada de avaliação:
    • MACHINE_TYPE: o tipo de VM a usar para a preparação.
    • ACCELERATOR_TYPE: (opcional.) O tipo de acelerador a associar a cada avaliação.
    • ACCELERATOR_COUNT: (opcional.) O número de aceleradores a associar a cada avaliação.
    • REPLICA_COUNT: o número de réplicas de trabalhadores a usar para cada teste.
    • Se a sua aplicação de preparação for executada num contentor personalizado, especifique o seguinte:
      • CUSTOM_CONTAINER_IMAGE_URI: o URI de uma imagem de contentor do Docker com o seu código de preparação. Saiba como criar uma imagem de contentor personalizada.
      • CUSTOM_CONTAINER_COMMAND: (opcional.) O comando a invocar quando o contentor é iniciado. Este comando substitui o ponto de entrada predefinido do contentor.
      • CUSTOM_CONTAINER_ARGS: (opcional.) Os argumentos a transmitir quando iniciar o contentor.
    • Se a sua aplicação de preparação for um pacote Python executado num contentor pré-criado, especifique o seguinte:
      • PYTHON_PACKAGE_EXECUTOR_IMAGE_URI: o URI da imagem do contentor que executa o pacote Python fornecido. Saiba mais sobre os contentores pré-criados para preparação.
      • PYTHON_PACKAGE_URIS: a localização do Cloud Storage dos ficheiros do pacote Python, que são o programa de preparação e os respetivos pacotes dependentes. O número máximo de URIs de pacotes é 100.
      • PYTHON_MODULE: o nome do módulo Python a executar após a instalação dos pacotes.
      • PYTHON_PACKAGE_ARGS: (opcional.) Argumentos da linha de comandos a transmitir ao módulo Python.
    • SERVICE_ACCOUNT: (opcional.) A conta de serviço que o Vertex AI vai usar para executar o seu código. Saiba mais sobre como anexar uma conta de serviço personalizada.
    • TIMEOUT: (opcional.) O tempo de execução máximo para cada teste.
  • Especifique o LABEL_NAME e o LABEL_VALUE para quaisquer etiquetas que queira aplicar a esta tarefa de otimização de hiperparâmetros.

Método HTTP e URL: 

POST https://LOCATION-aiplatform.googleapis.com/v1/projects/PROJECT/locations/LOCATION/hyperparameterTuningJobs

Corpo JSON do pedido: 

{
  "displayName": DISPLAY_NAME,
  "studySpec": {
    "metrics": [
      {
        "metricId": METRIC_ID,
        "goal": METRIC_GOAL
      }
    ],
    "parameters": [
      {
        "parameterId": PARAMETER_ID,
        "scaleType": PARAMETER_SCALE,

        // Union field parameter_value_spec can be only one of the following:
        "doubleValueSpec": {
            "minValue": DOUBLE_MIN_VALUE,
            "maxValue": DOUBLE_MAX_VALUE
        },
        "integerValueSpec": {
            "minValue": INTEGER_MIN_VALUE,
            "maxValue": INTEGER_MAX_VALUE
        },
        "categoricalValueSpec": {
            "values": [
              CATEGORICAL_VALUES
            ]
        },
        "discreteValueSpec": {
            "values": [
              DISCRETE_VALUES
            ]
        }
        // End of list of possible types for union field parameter_value_spec.

        "conditionalParameterSpecs": [
            "parameterSpec": {
              CONDITIONAL_PARAMETER
            }

            // Union field parent_value_condition can be only one of the following:
            "parentIntValues": {
                "values": [INTEGERS_TO_MATCH]
            }
            "parentCategoricalValues": {
                "values": [CATEGORIES_TO_MATCH]
            }
            "parentDiscreteValues": {
                "values": [DISCRETE_VALUES_TO_MATCH]
            }
            // End of list of possible types for union field parent_value_condition.
        ]
      }
    ],
    "ALGORITHM": ALGORITHM
  },
  "maxTrialCount": MAX_TRIAL_COUNT,
  "parallelTrialCount": PARALLEL_TRIAL_COUNT,
  "maxFailedTrialCount": MAX_FAILED_TRIAL_COUNT,
  "trialJobSpec": {
      "workerPoolSpecs": [
        {
          "machineSpec": {
            "machineType": MACHINE_TYPE,
            "acceleratorType": ACCELERATOR_TYPE,
            "acceleratorCount": ACCELERATOR_COUNT
          },
          "replicaCount": REPLICA_COUNT,

          // Union field task can be only one of the following:
          "containerSpec": {
            "imageUri": CUSTOM_CONTAINER_IMAGE_URI,
            "command": [
              CUSTOM_CONTAINER_COMMAND
            ],
            "args": [
              CUSTOM_CONTAINER_ARGS
            ]
          },
          "pythonPackageSpec": {
            "executorImageUri": PYTHON_PACKAGE_EXECUTOR_IMAGE_URI,
            "packageUris": [
              PYTHON_PACKAGE_URIS
            ],
            "pythonModule": PYTHON_MODULE,
            "args": [
              PYTHON_PACKAGE_ARGS
            ]
          }
          // End of list of possible types for union field task.
        }
      ],
      "scheduling": {
        "TIMEOUT": TIMEOUT
      },
      "serviceAccount": SERVICE_ACCOUNT
  },
  "labels": {
    LABEL_NAME_1": LABEL_VALUE_1,
    LABEL_NAME_2": LABEL_VALUE_2
  }
}

Para enviar o seu pedido, expanda uma destas opções:

Deve receber uma resposta JSON semelhante à seguinte:

{
  "name": "projects/12345/locations/us-central1/hyperparameterTuningJobs/6789",
  "displayName": "myHyperparameterTuningJob",
  "studySpec": {
    "metrics": [
      {
        "metricId": "myMetric",
        "goal": "MINIMIZE"
      }
    ],
    "parameters": [
      {
        "parameterId": "myParameter1",
        "integerValueSpec": {
          "minValue": "1",
          "maxValue": "128"
        },
        "scaleType": "UNIT_LINEAR_SCALE"
      },
      {
        "parameterId": "myParameter2",
        "doubleValueSpec": {
          "minValue": 1e-07,
          "maxValue": 1
        },
        "scaleType": "UNIT_LINEAR_SCALE"
      }
    ],
    "ALGORITHM": "RANDOM_SEARCH"
  },
  "maxTrialCount": 20,
  "parallelTrialCount": 1,
  "trialJobSpec": {
    "workerPoolSpecs": [
      {
        "machineSpec": {
          "machineType": "n1-standard-4"
        },
        "replicaCount": "1",
        "pythonPackageSpec": {
          "executorImageUri": "us-docker.pkg.dev/vertex-ai/training/training-tf-cpu.2-1:latest",
          "packageUris": [
            "gs://my-bucket/my-training-application/trainer.tar.bz2"
          ],
          "pythonModule": "my-trainer.trainer"
        }
      }
    ]
  }
}

Java

Antes de experimentar este exemplo, siga as Javainstruções de configuração no início rápido do Vertex AI com bibliotecas de cliente. Para mais informações, consulte a documentação de referência da API Java Vertex AI.

Para se autenticar no Vertex AI, configure as Credenciais padrão da aplicação. Para mais informações, consulte o artigo Configure a autenticação para um ambiente de desenvolvimento local. 

import com.google.cloud.aiplatform.v1.AcceleratorType;
import com.google.cloud.aiplatform.v1.CustomJobSpec;
import com.google.cloud.aiplatform.v1.HyperparameterTuningJob;
import com.google.cloud.aiplatform.v1.JobServiceClient;
import com.google.cloud.aiplatform.v1.JobServiceSettings;
import com.google.cloud.aiplatform.v1.LocationName;
import com.google.cloud.aiplatform.v1.MachineSpec;
import com.google.cloud.aiplatform.v1.PythonPackageSpec;
import com.google.cloud.aiplatform.v1.StudySpec;
import com.google.cloud.aiplatform.v1.StudySpec.MetricSpec;
import com.google.cloud.aiplatform.v1.StudySpec.MetricSpec.GoalType;
import com.google.cloud.aiplatform.v1.StudySpec.ParameterSpec;
import com.google.cloud.aiplatform.v1.StudySpec.ParameterSpec.ConditionalParameterSpec;
import com.google.cloud.aiplatform.v1.StudySpec.ParameterSpec.ConditionalParameterSpec.DiscreteValueCondition;
import com.google.cloud.aiplatform.v1.StudySpec.ParameterSpec.DiscreteValueSpec;
import com.google.cloud.aiplatform.v1.StudySpec.ParameterSpec.DoubleValueSpec;
import com.google.cloud.aiplatform.v1.StudySpec.ParameterSpec.ScaleType;
import com.google.cloud.aiplatform.v1.WorkerPoolSpec;
import java.io.IOException;
import java.util.Arrays;

public class CreateHyperparameterTuningJobPythonPackageSample {

  public static void main(String[] args) throws IOException {
    // TODO(developer): Replace these variables before running the sample.
    String project = "PROJECT";
    String displayName = "DISPLAY_NAME";
    String executorImageUri = "EXECUTOR_IMAGE_URI";
    String packageUri = "PACKAGE_URI";
    String pythonModule = "PYTHON_MODULE";
    createHyperparameterTuningJobPythonPackageSample(
        project, displayName, executorImageUri, packageUri, pythonModule);
  }

  static void createHyperparameterTuningJobPythonPackageSample(
      String project,
      String displayName,
      String executorImageUri,
      String packageUri,
      String pythonModule)
      throws IOException {
    JobServiceSettings settings =
        JobServiceSettings.newBuilder()
            .setEndpoint("us-central1-aiplatform.googleapis.com:443")
            .build();
    String location = "us-central1";

    // Initialize client that will be used to send requests. This client only needs to be created
    // once, and can be reused for multiple requests. After completing all of your requests, call
    // the "close" method on the client to safely clean up any remaining background resources.
    try (JobServiceClient client = JobServiceClient.create(settings)) {
      // study spec
      MetricSpec metric =
          MetricSpec.newBuilder().setMetricId("val_rmse").setGoal(GoalType.MINIMIZE).build();

      // decay
      DoubleValueSpec doubleValueSpec =
          DoubleValueSpec.newBuilder().setMinValue(1e-07).setMaxValue(1).build();
      ParameterSpec parameterDecaySpec =
          ParameterSpec.newBuilder()
              .setParameterId("decay")
              .setDoubleValueSpec(doubleValueSpec)
              .setScaleType(ScaleType.UNIT_LINEAR_SCALE)
              .build();
      Double[] decayValues = {32.0, 64.0};
      DiscreteValueCondition discreteValueDecay =
          DiscreteValueCondition.newBuilder().addAllValues(Arrays.asList(decayValues)).build();
      ConditionalParameterSpec conditionalParameterDecay =
          ConditionalParameterSpec.newBuilder()
              .setParameterSpec(parameterDecaySpec)
              .setParentDiscreteValues(discreteValueDecay)
              .build();

      // learning rate
      ParameterSpec parameterLearningSpec =
          ParameterSpec.newBuilder()
              .setParameterId("learning_rate")
              .setDoubleValueSpec(doubleValueSpec) // Use the same min/max as for decay
              .setScaleType(ScaleType.UNIT_LINEAR_SCALE)
              .build();

      Double[] learningRateValues = {4.0, 8.0, 16.0};
      DiscreteValueCondition discreteValueLearning =
          DiscreteValueCondition.newBuilder()
              .addAllValues(Arrays.asList(learningRateValues))
              .build();
      ConditionalParameterSpec conditionalParameterLearning =
          ConditionalParameterSpec.newBuilder()
              .setParameterSpec(parameterLearningSpec)
              .setParentDiscreteValues(discreteValueLearning)
              .build();

      // batch size
      Double[] batchSizeValues = {4.0, 8.0, 16.0, 32.0, 64.0, 128.0};

      DiscreteValueSpec discreteValueSpec =
          DiscreteValueSpec.newBuilder().addAllValues(Arrays.asList(batchSizeValues)).build();
      ParameterSpec parameter =
          ParameterSpec.newBuilder()
              .setParameterId("batch_size")
              .setDiscreteValueSpec(discreteValueSpec)
              .setScaleType(ScaleType.UNIT_LINEAR_SCALE)
              .addConditionalParameterSpecs(conditionalParameterDecay)
              .addConditionalParameterSpecs(conditionalParameterLearning)
              .build();

      // trial_job_spec
      MachineSpec machineSpec =
          MachineSpec.newBuilder()
              .setMachineType("n1-standard-4")
              .setAcceleratorType(AcceleratorType.NVIDIA_TESLA_T4)
              .setAcceleratorCount(1)
              .build();

      PythonPackageSpec pythonPackageSpec =
          PythonPackageSpec.newBuilder()
              .setExecutorImageUri(executorImageUri)
              .addPackageUris(packageUri)
              .setPythonModule(pythonModule)
              .build();

      WorkerPoolSpec workerPoolSpec =
          WorkerPoolSpec.newBuilder()
              .setMachineSpec(machineSpec)
              .setReplicaCount(1)
              .setPythonPackageSpec(pythonPackageSpec)
              .build();

      StudySpec studySpec =
          StudySpec.newBuilder()
              .addMetrics(metric)
              .addParameters(parameter)
              .setAlgorithm(StudySpec.Algorithm.RANDOM_SEARCH)
              .build();
      CustomJobSpec trialJobSpec =
          CustomJobSpec.newBuilder().addWorkerPoolSpecs(workerPoolSpec).build();
      // hyperparameter_tuning_job
      HyperparameterTuningJob hyperparameterTuningJob =
          HyperparameterTuningJob.newBuilder()
              .setDisplayName(displayName)
              .setMaxTrialCount(4)
              .setParallelTrialCount(2)
              .setStudySpec(studySpec)
              .setTrialJobSpec(trialJobSpec)
              .build();
      LocationName parent = LocationName.of(project, location);
      HyperparameterTuningJob response =
          client.createHyperparameterTuningJob(parent, hyperparameterTuningJob);
      System.out.format("response: %s\n", response);
      System.out.format("Name: %s\n", response.getName());
    }
  }
}

Python

Para saber como instalar ou atualizar o SDK Vertex AI para Python, consulte o artigo Instale o SDK Vertex AI para Python. Para mais informações, consulte a Python documentação de referência da API. 

from google.cloud import aiplatform

from google.cloud.aiplatform import hyperparameter_tuning as hpt


def create_hyperparameter_tuning_job_sample(
    project: str,
    location: str,
    staging_bucket: str,
    display_name: str,
    container_uri: str,
):
    aiplatform.init(project=project, location=location, staging_bucket=staging_bucket)

    worker_pool_specs = [
        {
            "machine_spec": {
                "machine_type": "n1-standard-4",
                "accelerator_type": "NVIDIA_TESLA_K80",
                "accelerator_count": 1,
            },
            "replica_count": 1,
            "container_spec": {
                "image_uri": container_uri,
                "command": [],
                "args": [],
            },
        }
    ]

    custom_job = aiplatform.CustomJob(
        display_name='custom_job',
        worker_pool_specs=worker_pool_specs,
    )

    hpt_job = aiplatform.HyperparameterTuningJob(
        display_name=display_name,
        custom_job=custom_job,
        metric_spec={
            'loss': 'minimize',
        },
        parameter_spec={
            'lr': hpt.DoubleParameterSpec(min=0.001, max=0.1, scale='log'),
            'units': hpt.IntegerParameterSpec(min=4, max=128, scale='linear'),
            'activation': hpt.CategoricalParameterSpec(values=['relu', 'selu']),
            'batch_size': hpt.DiscreteParameterSpec(values=[128, 256], scale='linear')
        },
        max_trial_count=128,
        parallel_trial_count=8,
        labels={'my_key': 'my_value'},
    )

    hpt_job.run()

    print(hpt_job.resource_name)
    return hpt_job

Configuração da tarefa de preparação de hiperparâmetros

As tarefas de aperfeiçoamento de hiperparâmetros procuram a melhor combinação de hiperparâmetros para otimizar as suas métricas. As tarefas de otimização de hiperparâmetros fazem isto executando várias experiências da sua aplicação de preparação com diferentes conjuntos de hiperparâmetros.

Quando configura uma tarefa de ajuste de hiperparâmetros, tem de especificar os seguintes detalhes:

Limite o número de testes

Decida quantos testes quer permitir que o serviço execute e defina o valor maxTrialCount no objeto HyperparameterTuningJob.

Existem dois interesses concorrentes a ter em conta quando decidir quantas avaliações permitir:

  • tempo (e, por conseguinte, custo)
  • precisão

Geralmente, o aumento do número de tentativas produz melhores resultados, mas nem sempre é assim. Normalmente, existe um ponto de rendimentos decrescentes após o qual as tentativas adicionais têm pouco ou nenhum efeito na precisão. Antes de iniciar uma tarefa com um grande número de testes, é recomendável começar com um pequeno número de testes para avaliar o efeito que os hiperparâmetros escolhidos têm na precisão do modelo.

Para tirar o máximo partido do ajuste de hiperparâmetros, não deve definir o valor máximo inferior a dez vezes o número de hiperparâmetros que usa.

Testes paralelos

Pode especificar quantas experiências podem ser executadas em paralelo definindo parallelTrialCount no HyperparameterTuningJob.

A execução de testes paralelos tem a vantagem de reduzir o tempo necessário para a tarefa de preparação (tempo real: o tempo de processamento total necessário não é normalmente alterado). No entanto, a execução em paralelo pode reduzir a eficácia geral da tarefa de otimização. Isto deve-se ao facto de o ajuste de hiperparâmetros usar os resultados de tentativas anteriores para informar os valores a atribuir aos hiperparâmetros de tentativas subsequentes. Quando são executadas em paralelo, algumas avaliações começam sem ter a vantagem dos resultados de quaisquer avaliações ainda em execução.

Se usar experiências paralelas, o serviço de otimização de hiperparâmetros aprovisiona vários clusters de processamento de preparação (ou várias máquinas individuais no caso de um preparador de processo único). A especificação do conjunto de tarefas que define para a sua tarefa é usada para cada cluster de preparação individual.

Resolva falhas nas avaliações

Se as tentativas de otimização de hiperparâmetros terminarem com erros, é recomendável terminar a tarefa de preparação antecipadamente. Defina o campo maxFailedTrialCount no HyperparameterTuningJob para o número de testes falhados que quer permitir. Após este número de tentativas falhadas, o Vertex AI termina a tarefa de preparação. O valor de maxFailedTrialCount tem de ser igual ou inferior a maxTrialCount.

Se não definir maxFailedTrialCount ou se o definir como 0, o Vertex AI usa as seguintes regras para processar testes com falhas:

  • Se a primeira tentativa da tarefa falhar, o Vertex AI termina a tarefa imediatamente. A falha durante a primeira tentativa sugere um problema no seu código de preparação, pelo que é provável que as tentativas adicionais também falhem. Terminar a tarefa permite-lhe diagnosticar o problema sem esperar por mais testes e incorrer em custos mais elevados.
  • Se a primeira tentativa for bem-sucedida, o Vertex AI pode terminar a tarefa após falhas durante as tentativas subsequentes com base num dos seguintes critérios:
    • O número de tentativas falhadas aumentou demasiado.
    • A proporção de tentativas falhadas em relação a tentativas bem-sucedidas aumentou demasiado.

Estas regras estão sujeitas a alterações. Para garantir um comportamento específico, defina o campo maxFailedTrialCount.

Faça a gestão de tarefas de hiperaperfeiçoamento dos parâmetros

As secções seguintes descrevem como gerir as tarefas de ajuste de hiperparâmetros.

Obtenha informações sobre uma tarefa de hiperaperfeiçoamento dos parâmetros

Os seguintes exemplos de código demonstram como obter uma tarefa de ajuste de hiperparâmetros.

gcloud

Use o comando gcloud ai hp-tuning-jobs describe:

gcloud ai hp-tuning-jobs describe ID_OR_NAME \
    --region=LOCATION

Substitua o seguinte:

  • ID_OR_NAME: o nome ou o ID numérico do HyperparameterTuningJob. (O ID é a última parte do nome.)

    Pode ter visto o ID ou o nome quando criou o HyperparameterTuningJob. Se não souber o ID nem o nome, pode executar o comando gcloud ai hp-tuning-jobs list e procurar o recurso adequado.

  • LOCATION: a região onde o HyperparameterTuningJob foi criado.

REST

Use o seguinte exemplo de código para obter uma tarefa de ajuste de hiperparâmetros através do método get do recurso hyperparameterTuningJob.

Antes de usar qualquer um dos dados do pedido, faça as seguintes substituições:

  • LOCATION: a região onde o HyperparameterTuningJob foi criado.
  • NAME: o nome da tarefa de hiperaperfeiçoamento dos parâmetros. O nome da tarefa usa o seguinte formato projects/{project}/LOCATIONS/{LOCATION}/hyperparameterTuningJobs/{hyperparameterTuningJob}.

Método HTTP e URL: 

GET https://LOCATION-aiplatform.googleapis.com/v1/NAME

Para enviar o seu pedido, expanda uma destas opções:

Deve receber uma resposta JSON semelhante à seguinte:

{
  "name": "projects/12345/LOCATIONs/us-central1/hyperparameterTuningJobs/6789",
  "displayName": "my-hyperparameter-tuning-job",
  "studySpec": {
    "metrics": [
      {
        "metricId": "my_metric",
        "goal": "MINIMIZE"
      }
    ],
    "parameters": [
      {
        "parameterId": "my_parameter",
        "doubleValueSpec": {
          "minValue": 1e-05,
          "maxValue": 1
        }
      }
    ]
  },
  "maxTrialCount": 3,
  "parallelTrialCount": 1,
  "trialJobSpec": {
    "workerPoolSpecs": [
      {
        "machineSpec": {
          "machineType": "n1-standard-4"
        },
        "replicaCount": "1",
        "pythonPackageSpec": {
          "executorImageUri": "us-docker.pkg.dev/vertex-ai/training/training-tf-cpu.2-1:latest",
          "packageUris": [
            "gs://my-bucket/my-training-application/trainer.tar.bz2"
          ],
          "pythonModule": "my-trainer.trainer"
        }
      }
    ]
  },
  "trials": [
    {
      "id": "2",
      "state": "SUCCEEDED",
      "parameters": [
        {
          "parameterId": "my_parameter",
          "value": 0.71426874725564571
        }
      ],
      "finalMeasurement": {
        "stepCount": "2",
        "metrics": [
          {
            "metricId": "my_metric",
            "value": 0.30007445812225342
          }
        ]
      },
      "startTime": "2020-09-09T23:39:15.549112551Z",
      "endTime": "2020-09-09T23:47:08Z"
    },
    {
      "id": "3",
      "state": "SUCCEEDED",
      "parameters": [
        {
          "parameterId": "my_parameter",
          "value": 0.3078893356622992
        }
      ],
      "finalMeasurement": {
        "stepCount": "2",
        "metrics": [
          {
            "metricId": "my_metric",
            "value": 0.30000102519989014
          }
        ]
      },
      "startTime": "2020-09-09T23:49:22.451699360Z",
      "endTime": "2020-09-09T23:57:15Z"
    },
    {
      "id": "1",
      "state": "SUCCEEDED",
      "parameters": [
        {
          "parameterId": "my_parameter",
          "value": 0.500005
        }
      ],
      "finalMeasurement": {
        "stepCount": "2",
        "metrics": [
          {
            "metricId": "my_metric",
            "value": 0.30005377531051636
          }
        ]
      },
      "startTime": "2020-09-09T23:23:12.283374629Z",
      "endTime": "2020-09-09T23:36:56Z"
    }
  ],
  "state": "JOB_STATE_SUCCEEDED",
  "createTime": "2020-09-09T23:22:31.777386Z",
  "startTime": "2020-09-09T23:22:34Z",
  "endTime": "2020-09-10T01:31:24.271307Z",
  "updateTime": "2020-09-10T01:31:24.271307Z"
}

Java

Antes de experimentar este exemplo, siga as Javainstruções de configuração no início rápido do Vertex AI com bibliotecas de cliente. Para mais informações, consulte a documentação de referência da API Java Vertex AI.

Para se autenticar no Vertex AI, configure as Credenciais padrão da aplicação. Para mais informações, consulte o artigo Configure a autenticação para um ambiente de desenvolvimento local. 

import com.google.cloud.aiplatform.v1.HyperparameterTuningJob;
import com.google.cloud.aiplatform.v1.HyperparameterTuningJobName;
import com.google.cloud.aiplatform.v1.JobServiceClient;
import com.google.cloud.aiplatform.v1.JobServiceSettings;
import java.io.IOException;

public class GetHyperparameterTuningJobSample {

  public static void main(String[] args) throws IOException {
    // TODO(developer): Replace these variables before running the sample.
    String project = "PROJECT";
    String hyperparameterTuningJobId = "HYPERPARAMETER_TUNING_JOB_ID";
    getHyperparameterTuningJobSample(project, hyperparameterTuningJobId);
  }

  static void getHyperparameterTuningJobSample(String project, String hyperparameterTuningJobId)
      throws IOException {
    JobServiceSettings settings =
        JobServiceSettings.newBuilder()
            .setEndpoint("us-central1-aiplatform.googleapis.com:443")
            .build();
    String location = "us-central1";

    // Initialize client that will be used to send requests. This client only needs to be created
    // once, and can be reused for multiple requests. After completing all of your requests, call
    // the "close" method on the client to safely clean up any remaining background resources.
    try (JobServiceClient client = JobServiceClient.create(settings)) {
      HyperparameterTuningJobName name =
          HyperparameterTuningJobName.of(project, location, hyperparameterTuningJobId);
      HyperparameterTuningJob response = client.getHyperparameterTuningJob(name);
      System.out.format("response: %s\n", response);
    }
  }
}

Python

Para saber como instalar ou atualizar o SDK Vertex AI para Python, consulte o artigo Instale o SDK Vertex AI para Python. Para mais informações, consulte a Python documentação de referência da API. 

# Copyright 2022 Google LLC
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#     https://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.

from google.cloud import aiplatform


def get_hyperparameter_tuning_job_sample(
    project: str,
    hyperparameter_tuning_job_id: str,
    location: str = "us-central1",
):

    aiplatform.init(project=project, location=location)

    hpt_job = aiplatform.HyperparameterTuningJob.get(
        resource_name=hyperparameter_tuning_job_id,
    )

    return hpt_job

Cancele uma tarefa de hiperaperfeiçoamento de parâmetros

Os seguintes exemplos de código demonstram como cancelar uma tarefa de ajuste de hiperparâmetros.

gcloud

Use o comando gcloud ai hp-tuning-jobs cancel:

gcloud ai hp-tuning-jobs cancel ID_OR_NAME \
    --region=LOCATION

Substitua o seguinte:

  • ID_OR_NAME: o nome ou o ID numérico do HyperparameterTuningJob. (O ID é a última parte do nome.)

    Pode ter visto o ID ou o nome quando criou o HyperparameterTuningJob. Se não souber o ID nem o nome, pode executar o comando gcloud ai hp-tuning-jobs list e procurar o recurso adequado.

  • LOCATION: a região onde o HyperparameterTuningJob foi criado.

REST

Use o seguinte exemplo de código para cancelar uma tarefa de ajuste de hiperparâmetros através do método cancel do recurso hyperparameterTuningJob.

Antes de usar qualquer um dos dados do pedido, faça as seguintes substituições:

  • LOCATION: a região onde o HyperparameterTuningJob foi criado.
  • NAME: o nome da tarefa de hiperaperfeiçoamento dos parâmetros. O nome da tarefa usa o seguinte formato projects/{project}/locations/{location}/hyperparameterTuningJobs/{hyperparameterTuningJob}.

Método HTTP e URL: 

POST https://LOCATION-aiplatform.googleapis.com/v1/NAME:cancel

Para enviar o seu pedido, expanda uma destas opções:

Deve receber um código de estado de êxito (2xx) e uma resposta vazia.

Python

Para saber como instalar ou atualizar o SDK Vertex AI para Python, consulte o artigo Instale o SDK Vertex AI para Python. Para mais informações, consulte a Python documentação de referência da API. 

from google.cloud import aiplatform


def cancel_hyperparameter_tuning_job_sample(
    project: str,
    hyperparameter_tuning_job_id: str,
    location: str = "us-central1",
):

    aiplatform.init(project=project, location=location)

    hpt_job = aiplatform.HyperparameterTuningJob.get(
        resource_name=hyperparameter_tuning_job_id,
    )

    hpt_job.cancel()

Elimine uma tarefa de aperfeiçoamento de hiperparâmetros

Os exemplos de código seguintes demonstram como eliminar uma tarefa de ajuste de hiperparâmetros usando o SDK Vertex AI para Python e a API REST.

REST

Use o seguinte exemplo de código para eliminar uma tarefa de ajuste de hiperparâmetros através do método delete do recurso hyperparameterTuningJob.

Antes de usar qualquer um dos dados do pedido, faça as seguintes substituições:

  • LOCATION: a sua região.
  • NAME: o nome da tarefa de hiperaperfeiçoamento dos parâmetros. O nome da tarefa usa o seguinte formato projects/{project}/LOCATIONs/{LOCATION}/hyperparameterTuningJobs/{hyperparameterTuningJob}.

Método HTTP e URL: 

DELETE https://LOCATION-aiplatform.googleapis.com/v1/NAME

Para enviar o seu pedido, expanda uma destas opções:

Deve receber um código de estado de êxito (2xx) e uma resposta vazia.

Python

Para saber como instalar ou atualizar o SDK Vertex AI para Python, consulte o artigo Instale o SDK Vertex AI para Python. Para mais informações, consulte a Python documentação de referência da API. 

from google.cloud import aiplatform


def delete_hyperparameter_tuning_job_sample(
    project: str,
    hyperparameter_tuning_job_id: str,
    location: str = "us-central1",
):

    aiplatform.init(project=project, location=location)

    hpt_job = aiplatform.HyperparameterTuningJob.get(
        resource_name=hyperparameter_tuning_job_id,
    )

    hpt_job.delete()

O que se segue?