Treinar um modelo de reconhecimento de ações em vídeo

Saiba nesta página como treinar um modelo de reconhecimento de ação do AutoML em um conjunto de dados de vídeo usando o console do Google Cloud ou a API Vertex AI.

Treinar um modelo do AutoML

Console do Google Cloud

  1. No Console do Google Cloud, na seção da Vertex AI, acesse a página Conjuntos de dados.

    Acessar a página "Conjuntos de dados"

  2. Clique no nome do conjunto de dados que você quer usar para treinar seu modelo para abrir a página de detalhes.

  3. Clique em Treinar novo modelo.

  4. Digite o nome de exibição do novo modelo.

  5. Se você quiser definir manualmente como os dados de treinamento são divididos, expanda as Opções avançadas e selecione uma opção de divisão de dados. Saiba mais.

  6. Clique em Continuar.

  7. Selecione o método de treinamento do modelo.

    • A AutoML é uma boa escolha para vários casos de uso.
    • Seq2seq+ é uma boa opção para experimentação. O algoritmo provavelmente terá uma convergência mais rápida do que o AutoML, porque a arquitetura dele é mais simples e usa um espaço de pesquisa menor. Nossos experimentos descobriram que o Seq2Seq+ tem um bom desempenho com um orçamento pequeno e com conjuntos de dados menores do que 1 GB.
    Clique em Continuar.

  8. Clique em Iniciar treinamento.

    O treinamento do modelo pode levar muitas horas dependendo do tamanho e da complexidade dos dados, além do orçamento de treinamento, se você tiver especificado um. Você pode fechar essa guia e voltar a ela mais tarde. Você receberá um e-mail quando o treinamento do seu modelo for concluído.

    Alguns minutos após o início do treinamento, é possível verificar a estimativa de hora do nó de treinamento a partir das informações de propriedade do modelo. Se você cancelar o treinamento, não haverá cobrança sobre o produto atual.

API

REST

Antes de usar os dados da solicitação abaixo, faça as substituições a seguir:

  • PROJECT: o ID do projeto.
  • LOCATION: região em que o conjunto de dados está localizado e o modelo é criado. Por exemplo, us-central1.
  • TRAINING_PIPELINE_DISPLAY_NAME: obrigatório. Um nome de exibição para o TrainingPipeline.
  • DATASET_ID: ID do conjunto de dados de treinamento;
  • TRAINING_FRACTION, TEST_FRACTION: o objeto fractionSplit é opcional; É usada para controlar a divisão de dados. Para mais informações sobre como controlar a divisão de dados, consulte Sobre divisões de dados para modelos do AutoML. Por exemplo:
    • {"trainingFraction": "0.8","validationFraction": "0","testFraction": "0.2"}
  • MODEL_DISPLAY_NAME: nome de exibição do modelo treinado.
  • MODEL_DESCRIPTION: uma descrição para o modelo.
  • MODEL_LABELS: qualquer conjunto de pares de chave-valor para organizar os modelos. Por exemplo:
    • "env": "prod"
    • "tier": "backend"
  • EDGE_MODEL_TYPE:
    • MOBILE_VERSATILE_1: uso geral
  • PROJECT_NUMBER: o número do projeto gerado automaticamente

Método HTTP e URL: 

POST https://LOCATION-aiplatform.googleapis.com/beta1/projects/PROJECT/locations/LOCATION/trainingPipelines

Corpo JSON da solicitação:

{
  "displayName": "TRAINING_PIPELINE_DISPLAY_NAME",
  "inputDataConfig": {
    "datasetId": "DATASET_ID",
    "fractionSplit": {
      "trainingFraction": "TRAINING_FRACTION",
      "validationFraction": "0",
      "testFraction": "TEST_FRACTION"
    }
  },
  "modelToUpload": {
    "displayName": "MODEL_DISPLAY_NAME",
    "description": "MODEL_DESCRIPTION",
    "labels": {
      "KEY": "VALUE"
    }
  },
  "trainingTaskDefinition": "gs://google-cloud-aiplatform/schema/trainingjob/definition/automl_video_object_tracking_1.0.0.yaml",
  "trainingTaskInputs": {
    "modelType": ["EDGE_MODEL_TYPE"],
  }
}

Para enviar a solicitação, escolha uma destas opções:

curl

Salve o corpo da solicitação em um arquivo com o nome request.json e execute o comando a seguir: 

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

PowerShell

Salve o corpo da solicitação em um arquivo com o nome request.json e execute o comando a seguir: 

$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-aiplatform.googleapis.com/beta1/projects/PROJECT/locations/LOCATION/trainingPipelines" | Select-Object -Expand Content

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

Java

Antes de testar esse exemplo, siga as instruções de configuração para Java no Guia de início rápido da Vertex AI sobre como usar bibliotecas de cliente. Para mais informações, consulte a documentação de referência da API Vertex AI para Java.

Para autenticar na Vertex AI, configure o Application Default Credentials. Para mais informações, consulte Configurar a autenticação para um ambiente de desenvolvimento local. 

import com.google.cloud.aiplatform.util.ValueConverter;
import com.google.cloud.aiplatform.v1.InputDataConfig;
import com.google.cloud.aiplatform.v1.LocationName;
import com.google.cloud.aiplatform.v1.Model;
import com.google.cloud.aiplatform.v1.PipelineServiceClient;
import com.google.cloud.aiplatform.v1.PipelineServiceSettings;
import com.google.cloud.aiplatform.v1.TrainingPipeline;
import com.google.cloud.aiplatform.v1.schema.trainingjob.definition.AutoMlVideoActionRecognitionInputs;
import com.google.cloud.aiplatform.v1.schema.trainingjob.definition.AutoMlVideoActionRecognitionInputs.ModelType;
import java.io.IOException;

public class CreateTrainingPipelineVideoActionRecognitionSample {

  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 datasetId = "DATASET_ID";
    String modelDisplayName = "MODEL_DISPLAY_NAME";
    createTrainingPipelineVideoActionRecognitionSample(
        project, displayName, datasetId, modelDisplayName);
  }

  static void createTrainingPipelineVideoActionRecognitionSample(
      String project, String displayName, String datasetId, String modelDisplayName)
      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)) {
      AutoMlVideoActionRecognitionInputs trainingTaskInputs =
          AutoMlVideoActionRecognitionInputs.newBuilder().setModelType(ModelType.CLOUD).build();

      InputDataConfig inputDataConfig =
          InputDataConfig.newBuilder().setDatasetId(datasetId).build();
      Model modelToUpload = Model.newBuilder().setDisplayName(modelDisplayName).build();
      TrainingPipeline trainingPipeline =
          TrainingPipeline.newBuilder()
              .setDisplayName(displayName)
              .setTrainingTaskDefinition(
                  "gs://google-cloud-aiplatform/schema/trainingjob/definition/"
                      + "automl_video_action_recognition_1.0.0.yaml")
              .setTrainingTaskInputs(ValueConverter.toValue(trainingTaskInputs))
              .setInputDataConfig(inputDataConfig)
              .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 o SDK da Vertex AI para Python, consulte Instalar o SDK da Vertex AI para Python. Para mais informações, consulte a documentação de referência da API Python. 

from google.cloud import aiplatform
from google.cloud.aiplatform.gapic.schema import trainingjob


def create_training_pipeline_video_action_recognition_sample(
    project: str,
    display_name: str,
    dataset_id: str,
    model_display_name: str,
    model_type: str,
    location: str = "us-central1",
    api_endpoint: str = "us-central1-aiplatform.googleapis.com",
):
    # The AI Platform services require regional API endpoints.
    client_options = {"api_endpoint": api_endpoint}
    # Initialize client that will be used to create and send requests.
    # This client only needs to be created once, and can be reused for multiple requests.
    client = aiplatform.gapic.PipelineServiceClient(client_options=client_options)
    training_task_inputs = trainingjob.definition.AutoMlVideoActionRecognitionInputs(
        # modelType can be either 'CLOUD' or 'MOBILE_VERSATILE_1'
        model_type=model_type,
    ).to_value()

    training_pipeline = {
        "display_name": display_name,
        "training_task_definition": "gs://google-cloud-aiplatform/schema/trainingjob/definition/automl_video_action_recognition_1.0.0.yaml",
        "training_task_inputs": training_task_inputs,
        "input_data_config": {"dataset_id": dataset_id},
        "model_to_upload": {"display_name": model_display_name},
    }
    parent = f"projects/{project}/locations/{location}"
    response = client.create_training_pipeline(
        parent=parent, training_pipeline=training_pipeline
    )
    print("response:", response)

Controlar a divisão de dados usando REST

É possível controlar como os dados de treinamento são divididos entre os conjuntos de treinamento, validação e teste. Ao usar a API Vertex AI, use o Splitobjeto para determinar a divisão de dados. O objeto Split pode ser incluído no objeto InputConfig como um dos vários tipos de objeto, cada um fornecendo uma maneira diferente de dividir os dados de treinamento. É possível selecionar apenas um método.

  • FractionSplit:
    • TRAINING_FRACTION: a fração dos dados de treinamento a ser usada para o conjunto de treinamento.
    • VALIDATION_FRACTION: a fração dos dados de treinamento a ser usada para o conjunto de validação. Não usada para dados de vídeo.
    • TEST_FRACTION: a fração dos dados de treinamento a ser usada para o conjunto de teste.

    Se alguma das frações for especificada, tudo deverá ser especificado. As frações precisam ser adicionadas a 1,0. Os valores padrão das frações variam de acordo com o tipo de dados. Saiba mais. 

    "fractionSplit": {
  "trainingFraction": TRAINING_FRACTION,
  "validationFraction": VALIDATION_FRACTION,
  "testFraction": TEST_FRACTION
},
  • FilterSplit:
    • TRAINING_FILTER: itens de dados que correspondem a esse filtro são usados no conjunto de treinamento.
    • VALIDATION_FILTER: os itens de dados que correspondem a esse filtro são usados no conjunto de validação. Precisa ser "-" para dados de vídeo.
    • TEST_FILTER: os itens de dados que correspondem a esse filtro são usados no conjunto de teste.

    Esses filtros podem ser usados com o rótulo ml_use ou com qualquer rótulo aplicado aos seus dados. Saiba mais sobre como usar o rótulo ml-use label e outros rótulos para filtrar os dados.

    O exemplo a seguir mostra como usar o objeto filterSplit com o rótulo ml_use, com o conjunto de validação incluído:

    "filterSplit": {
"trainingFilter": "labels.aiplatform.googleapis.com/ml_use=training",
"validationFilter": "labels.aiplatform.googleapis.com/ml_use=validation",
"testFilter": "labels.aiplatform.googleapis.com/ml_use=test"
}
Anterior
Criar conjunto de dados
Próxima
Avaliar o modelo