Entrena un modelo de reconocimiento de acciones de video

En esta página, se muestra cómo entrenar un modelo de reconocimiento de acciones de AutoML a partir de un conjunto de datos de video con la consola de Google Cloud o la API de Vertex AI.

Entrena un modelo de AutoML

Consola de Google Cloud

  1. En la sección Vertex AI de la consola de Google Cloud, ve a la página Conjuntos de datos.

    Ir a la página Conjuntos de datos

  2. Haz clic en el nombre del conjunto de datos que deseas usar para entrenar tu modelo a fin de abrir su página de detalles.

  3. Haga clic en Entrenar un modelo nuevo.

  4. Ingresa el nombre visible de tu modelo nuevo.

  5. Si deseas configurar el forma en que se dividen los datos de entrenamiento, expande Opciones avanzadas y selecciona una opción de división de datos. Obtenga más información.

  6. Haz clic en Continuar.

  7. Selecciona el método de entrenamiento de modelos.

    • AutoML es una buena opción para una amplia gama de casos de uso.
    • Seq2seq+ es una buena opción para experimentar. Es probable que el algoritmo converja más rápido que AutoML porque su arquitectura es más simple y usa un espacio de búsqueda más pequeño. Nuestros experimentos demuestran que Seq2Seq+ funciona bien con un presupuesto pequeño y en conjuntos de datos de menos de 1 GB de tamaño.
    Haz clic en Continuar.

  8. Haga clic en Comenzar entrenamiento.

    El entrenamiento de modelos puede tardar muchas horas, según el tamaño y la complejidad de tus datos y tu presupuesto de entrenamiento, si especificaste uno. Puedes cerrar esta pestaña y regresar a ella más tarde. Recibirás un correo electrónico cuando tu modelo haya finalizado el entrenamiento.

    Varios minutos después de que comienza el entrenamiento, puedes verificar la estimación de la hora de procesamiento de nodo del entrenamiento con la información de las propiedades del modelo. Si cancelas el entrenamiento, no se aplicarán cargos por el producto actual.

API

REST

Antes de usar cualquiera de los datos de solicitud a continuación, realiza los siguientes reemplazos:

  • PROJECT: El ID del proyecto.
  • LOCATION: Región en la que se encuentra el conjunto de datos y se crea el modelo. Por ejemplo, us-central1.
  • TRAINING_PIPELINE_DISPLAY_NAME: Obligatorio. Un nombre visible para TrainingPipeline.
  • DATASET_ID: ID del conjunto de datos de entrenamiento.
  • TRAINING_FRACTION, TEST_FRACTION: El objeto fractionSplit es opcional. La usas para controlar tu división de datos. Si deseas obtener más información a fin de controlar la división de datos, consulta Acerca de las divisiones de datos para los modelos de AutoML. Por ejemplo:
    • {"trainingFraction": "0.8","validationFraction": "0","testFraction": "0.2"}
  • MODEL_DISPLAY_NAME: Nombre visible del modelo entrenado
  • MODEL_DESCRIPTION: Es una descripción del modelo.
  • MODEL_LABELS: Cualquier conjunto de pares clave-valor para organizar los modelos. Por ejemplo:
    • "env": "prod"
    • "nivel": "backend"
  • EDGE_MODEL_TYPE:
    • MOBILE_VERSATILE_1: Uso general
  • PROJECT_NUMBER: El número de proyecto de tu proyecto generado de forma automática

Método HTTP y URL: 

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

Cuerpo JSON de la solicitud:

{
  "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 tu solicitud, elige una de estas opciones:

curl

Guarda el cuerpo de la solicitud en un archivo llamado request.json y ejecuta el siguiente 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-aiplatform.googleapis.com/beta1/projects/PROJECT/locations/LOCATION/trainingPipelines"

PowerShell

Guarda el cuerpo de la solicitud en un archivo llamado request.json y ejecuta el siguiente 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-aiplatform.googleapis.com/beta1/projects/PROJECT/locations/LOCATION/trainingPipelines" | Select-Object -Expand Content

La respuesta contiene información sobre las especificaciones y los TRAININGPIPELINE_ID.

Java

Antes de probar este ejemplo, sigue las instrucciones de configuración para Java incluidas en la guía de inicio rápido de Vertex AI sobre cómo usar bibliotecas cliente. Para obtener más información, consulta la documentación de referencia de la API de Vertex AI Java.

Para autenticarte en Vertex AI, configura las credenciales predeterminadas de la aplicación. Si deseas obtener más información, consulta Configura la autenticación para un entorno de desarrollo 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

Si deseas obtener información para instalar o actualizar el SDK de Vertex AI para Python, consulta Instala el SDK de Vertex AI para Python. Si deseas obtener más información, consulta la documentación de referencia de la API de 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)

Controla la división de datos mediante REST

Puedes controlar cómo se dividen los datos de entrenamiento entre los conjuntos de entrenamiento, validación y prueba. Cuando uses la API de Vertex AI, usa el objeto Split para determinar la división de datos. El objeto Split se puede incluir en el objeto InputConfig como uno de varios tipos de objeto, cada uno de los cuales proporciona una forma diferente de dividir los datos de entrenamiento. Puedes seleccionar solo un método.

  • FractionSplit:
    • TRAINING_FRACTION: La fracción de los datos de entrenamiento que se usarán para el conjunto de entrenamiento.
    • VALIDATION_FRACTION: La fracción de los datos de entrenamiento que se usarán para el conjunto de validación. No se usa para datos de video.
    • TEST_FRACTION: La fracción de los datos de entrenamiento que se usarán para el conjunto de prueba.

    Si se especifican cualquiera de las fracciones, se deben especificar todas. Las fracciones deben sumar hasta 1.0. Los valores predeterminados para las fracciones difieren según tu tipo de datos. Obtenga más información. 

    "fractionSplit": {
  "trainingFraction": TRAINING_FRACTION,
  "validationFraction": VALIDATION_FRACTION,
  "testFraction": TEST_FRACTION
},
  • FilterSplit:
    • TRAINING_FILTER: los elementos de datos que coinciden con este filtro se usan para el conjunto de entrenamiento.
    • VALIDATION_FILTER: los elementos de datos que coinciden con este filtro se usan para el conjunto de validación. Debe ser “-” para los datos de video.
    • TEST_FILTER: los elementos de datos que coinciden con este filtro se usan para el conjunto de prueba.

    Estos filtros se pueden usar con la etiqueta ml_use o con cualquier etiqueta que apliques a tus datos. Obtén más información sobre cómo usar la etiqueta de ml-use y otras etiquetas a fin de filtrar tus datos.

    En el siguiente ejemplo, se muestra cómo usar el objeto filterSplit con la etiqueta ml_use, con el conjunto de validación incluido:

    "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
Crear conjunto de datos
Siguiente
Evaluar el modelo