Esta página foi traduzida pela API Cloud Translation.

Crie pipelines de preparação

Os pipelines de preparação permitem-lhe realizar uma preparação de aprendizagem automática (ML) personalizada e criar automaticamente um recurso Model com base no resultado da preparação.

Se a sua tarefa envolver apenas a execução de um trabalho de preparação e a criação automática de um recurso de modelo sem orquestrar um fluxo de trabalho completo, a utilização de um pipeline de preparação autónomo, conforme descrito neste documento, pode ser suficiente. No entanto, se o seu objetivo for criar um ciclo de vida de ML completo, automatizado e repetível que envolva vários passos (como processamento de dados, preparação, avaliação, implementação ou monitorização), a Vertex AI Pipelines é a abordagem recomendada, uma vez que foi concebida para a orquestração de fluxos de trabalho.

Antes de criar um pipeline

Antes de criar um pipeline de preparação no Vertex AI, tem de criar uma aplicação de preparação Python ou um contentor personalizado para definir o código de preparação e as dependências que quer executar no Vertex AI. Se criar uma aplicação de preparação Python com o PyTorch, o TensorFlow, o scikit-learn ou o XGBoost, pode usar os nossos contentores pré-criados para executar o seu código. Se não tiver a certeza de qual destas opções escolher, consulte os requisitos do código de formação para saber mais.

Opções do pipeline de preparação

Um pipeline de preparação encapsula tarefas de preparação com passos adicionais. Este guia explica dois pipelines de preparação diferentes:

Inicie um CustomJob e carregue o modelo resultante para o Vertex AI
Inicie uma tarefa de aperfeiçoamento de hiperparâmetros e carregue o modelo resultante para o Vertex AI

Além disso, pode usar conjuntos de dados geridos no seu pipeline de preparação. Saiba mais sobre como configurar o pipeline de preparação para usar um conjunto de dados gerido.

O que um `CustomJob` inclui

Quando cria uma tarefa personalizada, especifica as definições de que o Vertex AI precisa para executar o seu código de preparação, incluindo:

Um conjunto de trabalhadores para o treino de nó único (WorkerPoolSpec) ou vários conjuntos de trabalhadores para o treino distribuído
Definições opcionais para configurar o agendamento de tarefas (Scheduling), definir determinadas variáveis de ambiente para o seu código de preparação, usar uma conta de serviço personalizada e usar o peering de redes da VPC

Nos conjuntos de trabalhadores, pode especificar as seguintes definições:

Tipos de máquinas e aceleradores
Configuração do tipo de código de preparação que o conjunto de trabalhadores executa: uma aplicação de preparação Python (PythonPackageSpec) ou um contentor personalizado (ContainerSpec)

Se quiser criar uma tarefa personalizada autónoma fora de um pipeline do Vertex AI Training, consulte o guia sobre tarefas personalizadas.

Configure o seu pipeline para usar um conjunto de dados gerido

No pipeline de treino, pode configurar a tarefa de treino personalizada ou a tarefa de ajuste de hiperparâmetros para usar um conjunto de dados gerido. Os conjuntos de dados geridos permitem-lhe gerir os seus conjuntos de dados com as suas aplicações de preparação e modelos.

Para usar um conjunto de dados gerido no seu pipeline de preparação:

Crie o seu conjunto de dados.
Atualize a sua aplicação de preparação para usar um conjunto de dados gerido. Para mais informações, consulte como a Vertex AI transmite o seu conjunto de dados à sua aplicação de preparação.
Especifique um conjunto de dados gerido quando criar o pipeline de preparação. Por exemplo, se criar o pipeline de preparação através da API REST, especifique as definições do conjunto de dados na secção inputDataConfig.

Tem de criar o pipeline de preparação na mesma região onde criou o conjunto de dados.

Para saber mais, consulte a referência da API em TrainingPipeline.

Configure a preparação distribuída

No pipeline de preparação, pode configurar a tarefa de preparação personalizada ou a tarefa de ajuste de hiperparâmetros para preparação distribuída especificando vários conjuntos de trabalhadores.

Todos os exemplos nesta página mostram tarefas de preparação de réplica única com um conjunto de trabalhadores. Para os modificar para o treino distribuído:

Use o primeiro conjunto de trabalhadores para configurar a réplica principal e defina o número de réplicas como 1.
Adicione mais pools de trabalhadores para configurar réplicas de trabalhadores, réplicas de servidores de parâmetros ou réplicas de avaliadores, se a sua framework de aprendizagem automática suportar estas tarefas de cluster adicionais para a preparação distribuída.

Saiba mais sobre a utilização da preparação distribuída.

CustomJob e carregamento de modelos

Este pipeline de preparação encapsula uma tarefa personalizada com um passo de conveniência adicional que facilita a implementação do seu modelo no Vertex AI após a preparação. Esta pipeline de preparação faz duas coisas principais:

O pipeline de preparação cria um recurso CustomJob. A tarefa personalizada executa a aplicação de preparação com os recursos de computação que especificar.
Após a conclusão da tarefa personalizada, o pipeline de preparação encontra os artefactos do modelo que a sua aplicação de preparação cria no diretório de saída que especificou para o seu contentor do Cloud Storage. Usa estes artefactos para criar um recurso de modelo, que lhe permite fazer a implementação do modelo.

Existem duas formas diferentes de definir a localização dos artefactos do modelo:

Se definir um baseOutputDirectory para a sua tarefa de preparação, certifique-se de que o código de preparação guarda os artefactos do modelo nessa localização, usando a variável de ambiente $AIP_MODEL_DIR definida pelo Vertex AI. Após a conclusão da tarefa de preparação, o Vertex AI procura os artefactos do modelo resultantes em gs://BASE_OUTPUT_DIRECTORY/model.
Nota: se estiver a usar o SDK Vertex AI para Python, pode omitir o atributo base_output_dir. Neste caso, o Vertex AI envia os artefactos do modelo para um diretório com indicação de data/hora no diretório de preparação. Para ver detalhes, consulte:
Se definir o campo modelToUpload.artifactUri, o pipeline de preparação carrega os artefactos do modelo a partir desse URI. Tem de definir este campo se não tiver definido baseOutputDirectory.

Se especificar baseOutputDirectory e modelToUpload.artifactUri, o Vertex AI usa modelToUpload.artifactUri.

Para criar este tipo de pipeline de preparação:

Consola

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

Aceda a Pipelines de formação
Clique em Criar para abrir o painel Formar novo modelo.
No passo Método de preparação, especifique as seguintes definições:
1. Se quiser usar um conjunto de dados gerido para a preparação, especifique um conjunto de dados e um conjunto de anotações.
  
  Caso contrário, na lista pendente Conjunto de dados, selecione Nenhum conjunto de dados gerido.
2. Selecione Preparação personalizada (avançada).
Clique em Continuar.
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.
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:
  - Se quiser usar um contentor pré-criado para a preparação, forneça ao Vertex AI as informações necessárias para usar o pacote de preparação que carregou para o Cloud Storage:
    1. Use as listas pendentes Estrutura do modelo e Versão da estrutura do modelo para especificar o recipiente predefinido que quer usar.
    2. No campo Localização do pacote, especifique o URI do Cloud Storage da aplicação de preparação Python que criou e carregou. Normalmente, este ficheiro termina com .tar.gz.
    3. No campo Módulo Python, introduza o nome do módulo do ponto de entrada da sua aplicação de preparação.
  - Se quiser usar um contentor personalizado para a preparação, no campo Imagem do contentor, especifique o URI do Artifact Registry ou do Docker Hub da imagem do contentor.
3. No campo Diretório de saída do modelo, especifique 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.
  
  No final da preparação, o Vertex AI procura artefactos do modelo num subdiretório deste URI para criar um Model. (Este subdiretório está disponível para o seu código de preparação como a variável de ambiente AIP_MODEL_DIR.)
  
  Quando não usa a otimização de hiperparâmetros, o Vertex AI espera encontrar artefactos do modelo em BASE_OUTPUT_DIRECTORY/model/.
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:
  - Se estiver a usar um contentor pré-criado, o Vertex AI transmite os argumentos como flags de linha de comandos ao seu módulo Python.
  - Se estiver a usar um contentor personalizado, o Vertex AI substitui a instrução CMD do seu contentor pelos argumentos.
Clique em Continuar.
No passo Aperfeiçoamento de hiperparâmetros, certifique-se de que a caixa de verificação Ativar aperfeiçoamento de hiperparâmetros não está selecionada. Clique em Continuar.
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.
No passo Contentor de previsão, especifique as seguintes definições:
1. Selecione se quer usar um contentor pré-criado ou um contentor personalizado para publicar previsões a partir do seu modelo preparado.
2. Consoante a sua escolha, opte por uma das seguintes ações:
  - Se quiser usar um contentor pré-criado para publicar previsões, use os campos Framework do modelo, Versão da framework do modelo e Tipo de acelerador para escolher que contentor de previsão pré-criado usar para a previsão.
    
    Faça corresponder a Framework do modelo e a Versão da framework do modelo à framework de aprendizagem automática que usou para a preparação. Especifique apenas um tipo de acelerador se quiser usar GPUs para previsões online ou em lote mais tarde.
  - Se quiser usar um contentor personalizado para publicar previsões, faça o seguinte:
    1. No campo Imagem do contentor, especifique o URI do Artifact Registry da sua imagem do contentor.
    2. Opcionalmente, pode especificar um comando para substituir a instrução do recipiente.ENTRYPOINT
3. O campo Diretório do modelo contém o valor que definiu anteriormente no campo Diretório de saída do modelo do passo Recipiente de preparação. A alteração de qualquer um destes campos tem o mesmo efeito. Consulte a instrução anterior para mais informações sobre este campo.
4. Deixe os campos na secção Esquemas de previsão em branco.
Clique em Iniciar preparação para iniciar o pipeline de preparação personalizado.

REST

Use o seguinte exemplo de código para criar um pipeline de preparação com o método create do recurso trainingPipeline.

Nota: se quiser definir este pipeline para criar uma nova versão do modelo, pode adicionar opcionalmente o PARENT_MODEL no campo trainingPipeline.

Para saber mais, consulte o artigo Controlo de versões de modelos com o Registo de modelos Vertex AI.

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

LOCATION_ID: a região onde o código de preparação é executado e o Model é armazenado.
PROJECT_ID: o ID do seu projeto.
TRAINING_PIPELINE_NAME: obrigatório. Um nome a apresentar para o trainingPipeline.
Se a sua aplicação de preparação usar um conjunto de dados do Vertex AI, especifique o seguinte:
- DATASET_ID: o ID do conjunto de dados.
- ANNOTATIONS_FILTER: filtra o conjunto de dados pelas anotações que especificar.
- ANNOTATION_SCHEMA_URI: filtra o conjunto de dados pelo URI do esquema de anotação especificado.
- Use uma das seguintes opções para especificar como os itens de dados são divididos em conjuntos de preparação, validação e teste.
  - Para dividir o conjunto de dados com base em frações que definem o tamanho de cada conjunto, especifique o seguinte:
    - TRAINING_FRACTION: a fração do conjunto de dados a usar para preparar o seu modelo.
    - VALIDATION_FRACTION: a fração do conjunto de dados a usar para validar o seu modelo.
    - TEST_FRACTION: a fração do conjunto de dados a usar para avaliar o modelo.
  - Para dividir o conjunto de dados com base em filtros, especifique o seguinte:
    - TRAINING_FILTER: filtra o conjunto de dados para itens de dados a usar para a preparação do seu modelo.
    - VALIDATION_FILTER: filtra o conjunto de dados para itens de dados a usar para validar o seu modelo.
    - TEST_FILTER: filtra o conjunto de dados para itens de dados a usar para avaliar o seu modelo.
  - Para usar uma divisão predefinida, especifique o seguinte:
    - PREDEFINED_SPLIT_KEY: o nome da coluna a usar para dividir o conjunto de dados. Os valores aceitáveis nesta coluna incluem `training`, `validation` e `test`.
  - Para dividir o conjunto de dados com base na data/hora dos itens de dados, especifique o seguinte:
    - TIMESTAMP_TRAINING_FRACTION: a fração do conjunto de dados a usar para preparar o seu modelo.
    - TIMESTAMP_VALIDATION_FRACTION: a fração do conjunto de dados a usar para validar o seu modelo.
    - TIMESTAMP_TEST_FRACTION: a fração do conjunto de dados a usar para avaliar o modelo.
    - TIMESTAMP_SPLIT_KEY: o nome da coluna de data/hora a usar para dividir o conjunto de dados.
- OUTPUT_URI_PREFIX: A localização do Cloud Storage onde o Vertex AI exporta o seu conjunto de dados de preparação, depois de ser dividido em conjuntos de preparação, validação e teste.
Defina a tarefa de formação personalizada:
- MACHINE_TYPE: o tipo de máquina. Consulte os tipos de máquinas disponíveis para 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 no Artifact Registry ou Docker Hub que vai ser executada em cada réplica do trabalhador.
  - 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. O comprimento máximo de todos os argumentos combinados é de 100 000 carateres.
- 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. Consulte os contentores pré-criados disponíveis 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. O comprimento máximo de todos os argumentos combinados é de 100 000 carateres.
- TIMEOUT: (opcional.) O tempo de execução máximo da tarefa.
MODEL_NAME: um nome a apresentar para o modelo carregado (criado) pela TrainingPipeline.
MODEL_DESCRIPTION: uma descrição do modelo.
IMAGE_URI: o URI da imagem do contentor a usar para executar previsões. Por exemplo, us-docker.pkg.dev/vertex-ai/prediction/tf2-cpu.2-1:latest. Use contentores pré-criados ou contentores personalizados.
modelToUpload.labels: qualquer conjunto de pares de chave-valor para organizar os seus modelos. Por exemplo:
- "env": "prod"
- "tier": "backend"
Especifique o LABEL_NAME e o LABEL_VALUE para todas as etiquetas que quer aplicar a este pipeline de preparação.

Método HTTP e URL:

POST https://LOCATION_ID-aiplatform.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION_ID/trainingPipelines

Corpo JSON do pedido:

{
  "displayName": "TRAINING_PIPELINE_NAME",
  "inputDataConfig": {
    "datasetId": DATASET_ID,
    "annotationsFilter": ANNOTATIONS_FILTER,
    "annotationSchemaUri": ANNOTATION_SCHEMA_URI,

    // Union field split can be only one of the following:
    "fractionSplit": {
      "trainingFraction": TRAINING_FRACTION,
      "validationFraction": VALIDATION_FRACTION,
      "testFraction": TEST_FRACTION
    },
    "filterSplit": {
      "trainingFilter": TRAINING_FILTER,
      "validationFilter": VALIDATION_FILTER,
      "testFilter": TEST_FILTER
    },
    "predefinedSplit": {
      "key": PREDEFINED_SPLIT_KEY
    },
    "timestampSplit": {
      "trainingFraction": TIMESTAMP_TRAINING_FRACTION,
      "validationFraction": TIMESTAMP_VALIDATION_FRACTION,
      "testFraction": TIMESTAMP_TEST_FRACTION,
      "key": TIMESTAMP_SPLIT_KEY
    }
    // End of list of possible types for union field split.
    "gcsDestination": {
      "outputUriPrefix": OUTPUT_URI_PREFIX
    }
  },
  "trainingTaskDefinition": "gs://google-cloud-aiplatform/schema/trainingjob/definition/custom_task_1.0.0.yaml",
  "trainingTaskInputs": {
    "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
      }
    }
  },
  "modelToUpload": {
    "displayName": "MODEL_NAME",
    "predictSchemata": {},
    "containerSpec": {
      "imageUri": "IMAGE_URI"
    }
  },
  "labels": {
    LABEL_NAME_1": LABEL_VALUE_1,
    LABEL_NAME_2": LABEL_VALUE_2
  }
}

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

curl

Nota: O comando seguinte pressupõe que tem sessão iniciada na CLI gcloud com a sua conta de utilizador executando gcloud init ou gcloud auth login, ou usando o Cloud Shell, que inicia automaticamente sessão na CLI gcloud. Pode verificar a conta atualmente ativa executando o comando gcloud auth list.

Guarde o corpo do pedido num ficheiro com o nome request.json, e execute o seguinte comando:

curl -X POST \
     -H "Authorization: Bearer $(gcloud auth print-access-token)" \
     -H "Content-Type: application/json; charset=utf-8" \
     -d @request.json \
     "https://LOCATION_ID-aiplatform.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION_ID/trainingPipelines"

PowerShell

Nota: O comando seguinte pressupõe que iniciou sessão na CLI do Google Cloud com a sua conta de utilizador executando gcloud init ou gcloud auth login .gcloud Pode verificar a conta atualmente ativa executando o comando gcloud auth list.

Guarde o corpo do pedido num ficheiro com o nome request.json, e execute o seguinte comando:

$cred = gcloud auth print-access-token
$headers = @{ "Authorization" = "Bearer $cred" }

Invoke-WebRequest `
    -Method POST `
    -Headers $headers `
    -ContentType: "application/json; charset=utf-8" `
    -InFile request.json `
    -Uri "https://LOCATION_ID-aiplatform.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION_ID/trainingPipelines" | Select-Object -Expand Content

A resposta contém informações sobre as especificações, bem como o TRAININGPIPELINE_ID.

Resposta


{
  "name": "projects/PROJECT_ID/locations/LOCATION_ID/trainingPipelines/TRAININGPIPELINE_ID",
  "displayName": "TRAINING_PIPELINE_NAME",
  "input_data_config" {
    "dataset_id": "1234567891011121314"
    "gcs_destination" {
      "output_uri_prefix": "gs://BUCKET_NAME/data/20200915191342"
    }
    "annotation_schema_uri": "gs://google-cloud-aiplatform/schema/dataset/annotation/image_classification_1.0.0.yaml"
  },
  "trainingTaskDefinition": "gs://google-cloud-aiplatform/schema/trainingjob/definition/custom_task_1.0.0.yaml",
  "trainingTaskInputs": {
    "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://BUCKET_NAME/training/hello-custom-training-1.0.tar.gz"
          ],
          "pythonModule": "trainer.task",
          "args": [
            "--model-dir=gs://BUCKET_NAME/output/"
          ]
        }
      }
    ]
  },
  "trainingTaskMetadata": {
    "backingCustomJob": "projects/PROJECT_ID/locations/LOCATION_ID/customJobs/CUSTOM_JOB_ID"
  },
  "modelToUpload": {
    "displayName": "MODEL_NAME",
    "predictSchemata": {},
    "containerSpec": {
      "imageUri": "us-docker.pkg.dev/vertex-ai/prediction/tf2-cpu.2-1:latest"
    }
  },
  "state": "PIPELINE_STATE_PENDING",
  "createTime": "2020-09-15T19:09:54.342080Z",
  "startTime": "2020-09-15T19:13:42.991045Z",
}

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.LocationName;
import com.google.cloud.aiplatform.v1.Model;
import com.google.cloud.aiplatform.v1.ModelContainerSpec;
import com.google.cloud.aiplatform.v1.PipelineServiceClient;
import com.google.cloud.aiplatform.v1.PipelineServiceSettings;
import com.google.cloud.aiplatform.v1.TrainingPipeline;
import com.google.gson.JsonArray;
import com.google.gson.JsonObject;
import com.google.protobuf.Value;
import com.google.protobuf.util.JsonFormat;
import java.io.IOException;

public class CreateTrainingPipelineCustomJobSample {

  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 modelDisplayName = "MODEL_DISPLAY_NAME";
    String containerImageUri = "CONTAINER_IMAGE_URI";
    String baseOutputDirectoryPrefix = "BASE_OUTPUT_DIRECTORY_PREFIX";
    createTrainingPipelineCustomJobSample(
        project, displayName, modelDisplayName, containerImageUri, baseOutputDirectoryPrefix);
  }

  static void createTrainingPipelineCustomJobSample(
      String project,
      String displayName,
      String modelDisplayName,
      String containerImageUri,
      String baseOutputDirectoryPrefix)
      throws IOException {
    PipelineServiceSettings settings =
        PipelineServiceSettings.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 (PipelineServiceClient client = PipelineServiceClient.create(settings)) {
      JsonObject jsonMachineSpec = new JsonObject();
      jsonMachineSpec.addProperty("machineType", "n1-standard-4");

      // A working docker image can be found at
      // gs://cloud-samples-data/ai-platform/mnist_tfrecord/custom_job
      // This sample image accepts a set of arguments including model_dir.
      JsonObject jsonContainerSpec = new JsonObject();
      jsonContainerSpec.addProperty("imageUri", containerImageUri);
      JsonArray jsonArgs = new JsonArray();
      jsonArgs.add("--model_dir=$(AIP_MODEL_DIR)");
      jsonContainerSpec.add("args", jsonArgs);

      JsonObject jsonJsonWorkerPoolSpec0 = new JsonObject();
      jsonJsonWorkerPoolSpec0.addProperty("replicaCount", 1);
      jsonJsonWorkerPoolSpec0.add("machineSpec", jsonMachineSpec);
      jsonJsonWorkerPoolSpec0.add("containerSpec", jsonContainerSpec);

      JsonArray jsonWorkerPoolSpecs = new JsonArray();
      jsonWorkerPoolSpecs.add(jsonJsonWorkerPoolSpec0);

      JsonObject jsonBaseOutputDirectory = new JsonObject();
      // The GCS location for outputs must be accessible by the project's AI Platform
      // service account.
      jsonBaseOutputDirectory.addProperty("output_uri_prefix", baseOutputDirectoryPrefix);

      JsonObject jsonTrainingTaskInputs = new JsonObject();
      jsonTrainingTaskInputs.add("workerPoolSpecs", jsonWorkerPoolSpecs);
      jsonTrainingTaskInputs.add("baseOutputDirectory", jsonBaseOutputDirectory);

      Value.Builder trainingTaskInputsBuilder = Value.newBuilder();
      JsonFormat.parser().merge(jsonTrainingTaskInputs.toString(), trainingTaskInputsBuilder);
      Value trainingTaskInputs = trainingTaskInputsBuilder.build();
      String trainingTaskDefinition =
          "gs://google-cloud-aiplatform/schema/trainingjob/definition/custom_task_1.0.0.yaml";
      String imageUri = "gcr.io/cloud-aiplatform/prediction/tf-cpu.1-15:latest";
      ModelContainerSpec containerSpec =
          ModelContainerSpec.newBuilder().setImageUri(imageUri).build();
      Model modelToUpload =
          Model.newBuilder()
              .setDisplayName(modelDisplayName)
              .setContainerSpec(containerSpec)
              .build();
      TrainingPipeline trainingPipeline =
          TrainingPipeline.newBuilder()
              .setDisplayName(displayName)
              .setTrainingTaskDefinition(trainingTaskDefinition)
              .setTrainingTaskInputs(trainingTaskInputs)
              .setModelToUpload(modelToUpload)
              .build();
      LocationName parent = LocationName.of(project, location);
      TrainingPipeline response = client.createTrainingPipeline(parent, trainingPipeline);
      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.

Os exemplos seguintes mostram como usar o SDK Vertex AI para Python para criar um pipeline de preparação personalizado. Escolha se planeia usar um contentor personalizado ou um contentor pré-criado para a preparação:

Contentor pré-criado

Quando usa o SDK do Vertex AI para Python para criar um pipeline de preparação que executa o seu código Python num contentor pré-criado, pode fornecer o seu código de preparação de uma das seguintes formas:

Especifique o URI de um pacote de distribuição de origem Python no Cloud Storage.

(Esta opção também está disponível quando cria um pipeline de preparação sem usar o SDK Vertex AI para Python.)
Especifique o caminho para um script Python na sua máquina local. Antes de criar um pipeline de preparação, o SDK Vertex AI para Python compacta o seu script como uma distribuição de origem e carrega-o para o contentor do Cloud Storage da sua escolha.

(Esta opção só está disponível quando usa o SDK da Vertex AI para Python.)

Para ver um exemplo de código para cada uma destas opções, selecione o separador correspondente:

Pacote

O exemplo seguinte usa a classe CustomPythonPackageTrainingJob.

def create_training_pipeline_custom_package_job_sample(
    project: str,
    location: str,
    staging_bucket: str,
    display_name: str,
    python_package_gcs_uri: str,
    python_module_name: str,
    container_uri: str,
    model_serving_container_image_uri: str,
    dataset_id: Optional[str] = None,
    model_display_name: Optional[str] = None,
    args: Optional[List[Union[str, float, int]]] = None,
    replica_count: int = 1,
    machine_type: str = "n1-standard-4",
    accelerator_type: str = "ACCELERATOR_TYPE_UNSPECIFIED",
    accelerator_count: int = 0,
    training_fraction_split: float = 0.8,
    validation_fraction_split: float = 0.1,
    test_fraction_split: float = 0.1,
    sync: bool = True,
    tensorboard_resource_name: Optional[str] = None,
    service_account: Optional[str] = None,
):
    aiplatform.init(project=project, location=location, staging_bucket=staging_bucket)

    job = aiplatform.CustomPythonPackageTrainingJob(
        display_name=display_name,
        python_package_gcs_uri=python_package_gcs_uri,
        python_module_name=python_module_name,
        container_uri=container_uri,
        model_serving_container_image_uri=model_serving_container_image_uri,
    )

    # This example uses an ImageDataset, but you can use another type
    dataset = aiplatform.ImageDataset(dataset_id) if dataset_id else None

    model = job.run(
        dataset=dataset,
        model_display_name=model_display_name,
        args=args,
        replica_count=replica_count,
        machine_type=machine_type,
        accelerator_type=accelerator_type,
        accelerator_count=accelerator_count,
        training_fraction_split=training_fraction_split,
        validation_fraction_split=validation_fraction_split,
        test_fraction_split=test_fraction_split,
        sync=sync,
        tensorboard=tensorboard_resource_name,
        service_account=service_account,
    )

    model.wait()

    print(model.display_name)
    print(model.resource_name)
    print(model.uri)
    return model

Script

O exemplo seguinte usa a classe CustomTrainingJob.

def create_training_pipeline_custom_job_sample(
    project: str,
    location: str,
    staging_bucket: str,
    display_name: str,
    script_path: str,
    container_uri: str,
    model_serving_container_image_uri: str,
    dataset_id: Optional[str] = None,
    model_display_name: Optional[str] = None,
    args: Optional[List[Union[str, float, int]]] = None,
    replica_count: int = 0,
    machine_type: str = "n1-standard-4",
    accelerator_type: str = "ACCELERATOR_TYPE_UNSPECIFIED",
    accelerator_count: int = 0,
    training_fraction_split: float = 0.8,
    validation_fraction_split: float = 0.1,
    test_fraction_split: float = 0.1,
    sync: bool = True,
    tensorboard_resource_name: Optional[str] = None,
    service_account: Optional[str] = None,
):
    aiplatform.init(project=project, location=location, staging_bucket=staging_bucket)

    job = aiplatform.CustomTrainingJob(
        display_name=display_name,
        script_path=script_path,
        container_uri=container_uri,
        model_serving_container_image_uri=model_serving_container_image_uri,
    )

    # This example uses an ImageDataset, but you can use another type
    dataset = aiplatform.ImageDataset(dataset_id) if dataset_id else None

    model = job.run(
        dataset=dataset,
        model_display_name=model_display_name,
        args=args,
        replica_count=replica_count,
        machine_type=machine_type,
        accelerator_type=accelerator_type,
        accelerator_count=accelerator_count,
        training_fraction_split=training_fraction_split,
        validation_fraction_split=validation_fraction_split,
        test_fraction_split=test_fraction_split,
        sync=sync,
        tensorboard=tensorboard_resource_name,
        service_account=service_account,
    )

    model.wait()

    print(model.display_name)
    print(model.resource_name)
    print(model.uri)
    return model

Contentor personalizado

O exemplo seguinte usa a classe CustomContainerTrainingJob.

def create_training_pipeline_custom_container_job_sample(
    project: str,
    location: str,
    staging_bucket: str,
    display_name: str,
    container_uri: str,
    model_serving_container_image_uri: str,
    dataset_id: Optional[str] = None,
    model_display_name: Optional[str] = None,
    args: Optional[List[Union[str, float, int]]] = None,
    replica_count: int = 1,
    machine_type: str = "n1-standard-4",
    accelerator_type: str = "ACCELERATOR_TYPE_UNSPECIFIED",
    accelerator_count: int = 0,
    training_fraction_split: float = 0.8,
    validation_fraction_split: float = 0.1,
    test_fraction_split: float = 0.1,
    sync: bool = True,
    tensorboard_resource_name: Optional[str] = None,
    service_account: Optional[str] = None,
):
    aiplatform.init(project=project, location=location, staging_bucket=staging_bucket)

    job = aiplatform.CustomContainerTrainingJob(
        display_name=display_name,
        container_uri=container_uri,
        model_serving_container_image_uri=model_serving_container_image_uri,
    )

    # This example uses an ImageDataset, but you can use another type
    dataset = aiplatform.ImageDataset(dataset_id) if dataset_id else None

    model = job.run(
        dataset=dataset,
        model_display_name=model_display_name,
        args=args,
        replica_count=replica_count,
        machine_type=machine_type,
        accelerator_type=accelerator_type,
        accelerator_count=accelerator_count,
        training_fraction_split=training_fraction_split,
        validation_fraction_split=validation_fraction_split,
        test_fraction_split=test_fraction_split,
        sync=sync,
        tensorboard=tensorboard_resource_name,
        service_account=service_account,
    )

    model.wait()

    print(model.display_name)
    print(model.resource_name)
    print(model.uri)
    return model

Tarefa de hiperaperfeiçoamento dos parâmetros e carregamento do modelo

Este pipeline de preparação encapsula uma tarefa de ajuste de hiperparâmetros com um passo de conveniência adicional que facilita a implementação do seu modelo no Vertex AI após a preparação. Este pipeline de preparação faz duas coisas principais:

O pipeline de preparação cria um recurso de tarefa de hiperaperfeiçoamento dos parâmetros. A tarefa de hiperaperfeiçoamento dos parâmetros cria várias experiências. Para cada teste, um trabalho personalizado executa a sua aplicação de preparação usando os recursos de computação e os hiperparâmetros que especificar.
Após a conclusão da tarefa de otimização de hiperparâmetros, o pipeline de preparação encontra os artefactos do modelo da melhor tentativa no diretório de saída (baseOutputDirectory) que especificou para o seu contentor do Cloud Storage. O pipeline de preparação usa estes artefactos para criar um recurso de modelo, o que lhe permite fazer a implementação do modelo.

Para este pipeline de preparação, tem de especificar um baseOutputDirectory onde o Vertex AI procura os artefactos do modelo da melhor tentativa.

As tarefas de hiperaperfeiçoamento dos parâmetros têm definições adicionais para configurar. Saiba mais acerca das definições de um HyperparameterTuningJob.

REST

Use o seguinte exemplo de código para criar um pipeline de preparação com o método create do recurso trainingPipeline.

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

LOCATION_ID: a região do seu projeto.
PROJECT_ID: o ID do seu projeto.
TRAINING_PIPELINE_NAME: obrigatório. Um nome a apresentar para o trainingPipeline.
Se a sua aplicação de preparação usar um conjunto de dados do Vertex AI, especifique o seguinte:
- DATASET_ID: o ID do conjunto de dados.
- ANNOTATIONS_FILTER: filtra o conjunto de dados pelas anotações que especificar.
- ANNOTATION_SCHEMA_URI: filtra o conjunto de dados pelo URI do esquema de anotação especificado.
- Use uma das seguintes opções para especificar como os itens de dados são divididos em conjuntos de preparação, validação e teste.
  - Para dividir o conjunto de dados com base em frações que definem o tamanho de cada conjunto, especifique o seguinte:
    - TRAINING_FRACTION: a fração do conjunto de dados a usar para preparar o seu modelo.
    - VALIDATION_FRACTION: a fração do conjunto de dados a usar para validar o seu modelo.
    - TEST_FRACTION: a fração do conjunto de dados a usar para avaliar o modelo.
  - Para dividir o conjunto de dados com base em filtros, especifique o seguinte:
    - TRAINING_FILTER: filtra o conjunto de dados para itens de dados a usar para a preparação do seu modelo.
    - VALIDATION_FILTER: filtra o conjunto de dados para itens de dados a usar para validar o seu modelo.
    - TEST_FILTER: filtra o conjunto de dados para itens de dados a usar para avaliar o seu modelo.
  - Para usar uma divisão predefinida, especifique o seguinte:
    - PREDEFINED_SPLIT_KEY: o nome da coluna a usar para dividir o conjunto de dados. Os valores aceitáveis nesta coluna incluem `training`, `validation` e `test`.
  - Para dividir o conjunto de dados com base na data/hora dos itens de dados, especifique o seguinte:
    - TIMESTAMP_TRAINING_FRACTION: a fração do conjunto de dados a usar para preparar o seu modelo.
    - TIMESTAMP_VALIDATION_FRACTION: a fração do conjunto de dados a usar para validar o seu modelo.
    - TIMESTAMP_TEST_FRACTION: a fração do conjunto de dados a usar para avaliar o modelo.
    - TIMESTAMP_SPLIT_KEY: o nome da coluna de data/hora a usar para dividir o conjunto de dados.
- OUTPUT_URI_PREFIX: A localização do Cloud Storage onde o Vertex AI exporta o seu conjunto de dados de preparação, depois de ter sido dividido em conjuntos de preparação, validação e teste.
Especifique a tarefa de hiperaperfeiçoamento dos parâmetros:
- Especifique as suas métricas:
  - METRIC_ID: o nome desta métrica.
  - METRIC_GOAL: o objetivo desta métrica. Pode ser MAXIMIZE ou MINIMIZE.
- Especifique os hiperparâmetros:
  - PARAMETER_ID: o nome deste hiperparâmetro.
  - 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.
- 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 nesta tarefa.
- PARALLEL_TRIAL_COUNT: o número máximo de testes que podem ser executados 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 máquina. Consulte os tipos de máquinas disponíveis para 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 no Artifact Registry ou Docker Hub que vai ser executada em cada réplica de worker.
    - 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. Consulte os contentores pré-criados disponíveis 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.
- Saiba mais sobre as opções de agendamento de tarefas.
- 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.
MODEL_NAME: um nome a apresentar para o modelo carregado (criado) pela TrainingPipeline.
MODEL_DESCRIPTION: opcional. Uma descrição do modelo.
PREDICTION_IMAGE_URI: obrigatório. Especifique uma das duas opções seguintes:
- O URI da imagem do contentor pré-criado a usar para a previsão, como "tf2-cpu.2-1:latest".
- O URI da imagem do seu próprio contentor personalizado para usar na previsão.
modelToUpload.labels: opcional. Qualquer conjunto de pares de chave-valor para organizar os seus modelos. Por exemplo:
- "env": "prod"
- "tier": "backend"
Especifique o LABEL_NAME e o LABEL_VALUE para todas as etiquetas que quer aplicar a este pipeline de preparação.

Método HTTP e URL:

POST https://LOCATION_ID-aiplatform.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION_ID/trainingPipelines

Corpo JSON do pedido:

{
  "displayName": "TRAINING_PIPELINE_NAME",
  "inputDataConfig": {
    "datasetId": DATASET_ID,
    "annotationsFilter": ANNOTATIONS_FILTER,
    "annotationSchemaUri": ANNOTATION_SCHEMA_URI,

    // Union field split can be only one of the following:
    "fractionSplit": {
      "trainingFraction": TRAINING_FRACTION,
      "validationFraction": VALIDATION_FRACTION,
      "testFraction": TEST_FRACTION
    },
    "filterSplit": {
      "trainingFilter": TRAINING_FILTER,
      "validationFilter": VALIDATION_FILTER,
      "testFilter": TEST_FILTER
    },
    "predefinedSplit": {
      "key": PREDEFINED_SPLIT_KEY
    },
    "timestampSplit": {
      "trainingFraction": TIMESTAMP_TRAINING_FRACTION,
      "validationFraction": TIMESTAMP_VALIDATION_FRACTION,
      "testFraction": TIMESTAMP_TEST_FRACTION,
      "key": TIMESTAMP_SPLIT_KEY
    }
    // End of list of possible types for union field split.
    "gcsDestination": {
      "outputUriPrefix": OUTPUT_URI_PREFIX
    }
  },
  "trainingTaskDefinition": "gs://google-cloud-aiplatform/schema/trainingjob/definition/hyperparameter_tuning_task_1.0.0.yaml",
  "trainingTaskInputs": {
    "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.
      }
    ],
    "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
      }
    },
    "labels": {
      LABEL_NAME_1": LABEL_VALUE_1,
      LABEL_NAME_2": LABEL_VALUE_2
    }
  },
  "modelToUpload": {
    "displayName": "MODEL_NAME",
    "description": "MODEL_DESCRIPTION",
    "predictSchemata": {},
    "containerSpec": {
      "imageUri": "PREDICTION_IMAGE_URI"
    }
  },
  "labels": {
    LABEL_NAME_1": LABEL_VALUE_1,
    LABEL_NAME_2": LABEL_VALUE_2
  }
}

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

curl

Guarde o corpo do pedido num ficheiro com o nome request.json, e execute o seguinte comando:

curl -X POST \
     -H "Authorization: Bearer $(gcloud auth print-access-token)" \
     -H "Content-Type: application/json; charset=utf-8" \
     -d @request.json \
     "https://LOCATION_ID-aiplatform.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION_ID/trainingPipelines"

PowerShell

Guarde o corpo do pedido num ficheiro com o nome request.json, e execute o seguinte comando:

$cred = gcloud auth print-access-token
$headers = @{ "Authorization" = "Bearer $cred" }

Invoke-WebRequest `
    -Method POST `
    -Headers $headers `
    -ContentType: "application/json; charset=utf-8" `
    -InFile request.json `
    -Uri "https://LOCATION_ID-aiplatform.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION_ID/trainingPipelines" | Select-Object -Expand Content

A resposta contém informações sobre as especificações, bem como o TRAININGPIPELINE_ID.

Resposta


{
  "name": "projects/PROJECT_ID/locations/LOCATION_ID/trainingPipelines/TRAININGPIPELINE_ID",
  "displayName": "TRAINING_PIPELINE_NAME",
  "input_data_config" {
    "dataset_id": "1234567891011121314"
    "gcs_destination" {
      "output_uri_prefix": "gs://BUCKET_NAME/data/20200915191342"
    }
    "annotation_schema_uri": "gs://google-cloud-aiplatform/schema/dataset/annotation/image_classification_1.0.0.yaml"
  },
  "trainingTaskDefinition": "gs://google-cloud-aiplatform/schema/trainingjob/definition/custom_task_1.0.0.yaml",
  "trainingTaskInputs": {
    "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"
        }
      }
    ]
  },
  "state": "PIPELINE_STATE_PENDING",
  "createTime": "2020-09-15T19:09:54.342080Z",
  "startTime": "2020-09-15T19:13:42.991045Z",
}

Monitorize a formação

Para ver os registos de preparação, faça o seguinte:

Na Google Cloud consola, na secção Vertex AI, aceda à página Preparação.

Aceda à página Formação
Clique no nome da tarefa para aceder à página de tarefas personalizadas.
Clique em Ver registos.

Também pode usar uma shell interativa para inspecionar os contentores de preparação enquanto o pipeline de preparação está em execução.

Veja o modelo preparado

Quando o pipeline de preparação personalizado estiver concluído, pode encontrar o modelo preparado na Google Cloud consola, na secção do Vertex AI, na página Modelos.

Aceda à página Modelos

O que se segue?

Saiba como identificar gargalos de desempenho do treino para treinar modelos mais rapidamente e a um custo inferior através do Cloud Profiler.
Implemente o seu modelo num ponto final.
Crie uma tarefa de hiperaperfeiçoamento dos parâmetros.
Saiba como agendar tarefas de preparação personalizadas com base na disponibilidade de recursos.

Crie pipelines de preparação Mantenha tudo organizado com as coleções Salve e categorize o conteúdo com base nas suas preferências.

Antes de criar um pipeline

Opções do pipeline de preparação

O que um CustomJob inclui

Configure o seu pipeline para usar um conjunto de dados gerido

Configure a preparação distribuída

CustomJob e carregamento de modelos

Consola

REST

curl

PowerShell

Resposta

Java

Python

Contentor pré-criado

Pacote

Script

Contentor personalizado

Tarefa de hiperaperfeiçoamento dos parâmetros e carregamento do modelo

REST

curl

PowerShell

Resposta

Monitorize a formação

Veja o modelo preparado

O que se segue?

Crie pipelines de preparação

O que um `CustomJob` inclui