Crear flujos de procesamiento de preparación

Los flujos de trabajo de entrenamiento te permiten llevar a cabo entrenamientos de aprendizaje automático personalizados y crear automáticamente un recurso Model basado en el resultado del entrenamiento.

Si tu tarea solo implica ejecutar un trabajo de entrenamiento y crear automáticamente un recurso de modelo sin organizar un flujo de trabajo completo, puede que sea suficiente con usar una canalización de entrenamiento independiente, tal como se describe en este documento. Sin embargo, si tu objetivo es crear un ciclo de vida de aprendizaje automático integral, sólido, automatizado y repetible que implique varios pasos (como el procesamiento de datos, el entrenamiento, la evaluación, el despliegue o la monitorización), te recomendamos que uses Vertex AI Pipelines, ya que está diseñado para la orquestación de flujos de trabajo.

Antes de crear una canalización

Antes de crear un flujo de procesamiento de entrenamiento en Vertex AI, debes crear una aplicación de entrenamiento de Python o un contenedor personalizado para definir el código de entrenamiento y las dependencias que quieras ejecutar en Vertex AI. Si creas una aplicación de entrenamiento de Python con PyTorch, TensorFlow, scikit-learn o XGBoost, puedes usar nuestros contenedores precompilados para ejecutar el código. Si no sabes cuál de estas opciones elegir, consulta los requisitos del código de formación para obtener más información.

Opciones de flujo de procesamiento de entrenamiento

Un flujo de procesamiento de entrenamiento encapsula las tareas de entrenamiento con pasos adicionales. En esta guía se explican dos pipelines de entrenamiento diferentes:

  • Lanza una CustomJob y sube el modelo resultante a Vertex AI
  • Iniciar una tarea de ajuste de hiperparámetros y subir el modelo resultante a Vertex AI

Además, puedes usar conjuntos de datos gestionados en tu canalización de entrenamiento. Consulta más información sobre cómo configurar tu canalización de entrenamiento para usar un conjunto de datos gestionado.

Qué incluye un CustomJob

Cuando creas un trabajo personalizado, especificas los ajustes que necesita Vertex AI para ejecutar tu código de entrenamiento, como los siguientes:

En los grupos de trabajadores, puede especificar los siguientes ajustes:

Si quieres crear una tarea personalizada independiente fuera de una canalización de entrenamiento de Vertex AI, consulta la guía sobre tareas personalizadas.

Configurar un flujo de procesamiento para usar un conjunto de datos gestionado

En tu flujo de procesamiento de entrenamiento, puedes configurar tu trabajo de entrenamiento personalizado o tu trabajo de ajuste de hiperparámetros para que use un conjunto de datos gestionado. Los conjuntos de datos gestionados te permiten gestionar tus conjuntos de datos con tus aplicaciones y modelos de entrenamiento.

Para usar un conjunto de datos gestionado en tu flujo de procesamiento de entrenamiento, sigue estos pasos:

  1. Crea tu conjunto de datos.
  2. Actualiza tu aplicación de entrenamiento para que use un conjunto de datos gestionado. Para obtener más información, consulta cómo transfiere Vertex AI tu conjunto de datos a tu aplicación de entrenamiento.

  3. Especifica un conjunto de datos gestionado al crear tu flujo de procesamiento de entrenamiento. Por ejemplo, si creas tu flujo de trabajo de entrenamiento con la API REST, especifica los ajustes del conjunto de datos en la sección inputDataConfig.

    Debes crear el flujo de procesamiento de entrenamiento en la misma región en la que hayas creado el conjunto de datos.

Para obtener más información, consulta la referencia de la API en TrainingPipeline.

Configurar el entrenamiento distribuido

En tu flujo de procesamiento de entrenamiento, puedes configurar tu tarea de entrenamiento personalizada o tu tarea de ajuste de hiperparámetros para el entrenamiento distribuido especificando varios grupos de trabajadores.

Todos los ejemplos de esta página muestran trabajos de entrenamiento de una sola réplica con un solo grupo de trabajadores. Para modificarlos para el entrenamiento distribuido, haz lo siguiente:

  • Usa tu primer grupo de trabajadores para configurar tu réplica principal y define el número de réplicas en 1.
  • Añade más grupos de trabajadores para configurar réplicas de trabajadores, réplicas de servidores de parámetros o réplicas de evaluadores si tu framework de aprendizaje automático admite estas tareas de clúster adicionales para el entrenamiento distribuido.

Más información sobre el entrenamiento distribuido

Subida de CustomJob y de modelos

Esta canalización de entrenamiento encapsula un trabajo personalizado con un paso adicional que facilita el despliegue del modelo en Vertex AI después del entrenamiento. Esta canalización de entrenamiento hace dos cosas principales:

  1. El flujo de procesamiento de entrenamiento crea un recurso CustomJob. El trabajo personalizado ejecuta la aplicación de entrenamiento con los recursos de computación que especifiques.

  2. Una vez que se completa el trabajo personalizado, la canalización de entrenamiento busca los artefactos del modelo que crea tu aplicación de entrenamiento en el directorio de salida que has especificado en tu bucket de Cloud Storage. Utiliza estos artefactos para crear un recurso de modelo, que te prepara para la implementación del modelo.

Hay dos formas de definir la ubicación de los artefactos de tu modelo:

  • Si defines un baseOutputDirectory para tu tarea de entrenamiento, asegúrate de que el código de entrenamiento guarde los artefactos del modelo en esa ubicación mediante la variable de entorno $AIP_MODEL_DIR definida por Vertex AI. Una vez que se completa el trabajo de entrenamiento, Vertex AI busca los artefactos del modelo resultante en gs://BASE_OUTPUT_DIRECTORY/model.

  • Si define el campo modelToUpload.artifactUri, la pipeline de entrenamiento sube los artefactos del modelo desde ese URI. Debes definir este campo si no has definido baseOutputDirectory.

Si especificas tanto baseOutputDirectory como modelToUpload.artifactUri, Vertex AI usará modelToUpload.artifactUri.

Para crear este tipo de flujo de procesamiento de entrenamiento, sigue estos pasos:

Consola

  1. En la Google Cloud consola, en la sección Vertex AI, ve a la página Flujos de procesamiento de entrenamiento.

    Ir a Flujos de procesamiento de entrenamiento

  2. Haz clic en Crear para abrir el panel Entrenar modelo nuevo.

  3. En el paso Método de entrenamiento, especifica los siguientes ajustes:

    1. Si quieres usar un conjunto de datos gestionado para el entrenamiento, especifica un conjunto de datos y un conjunto de anotaciones.

      De lo contrario, en la lista desplegable Conjunto de datos, selecciona Sin conjunto de datos gestionado.

    2. Selecciona Entrenamiento personalizado (avanzado).

    Haz clic en Continuar.

  4. En el paso Detalles del modelo, elija Entrenar nuevo modelo o Entrenar nueva versión. Si seleccionas Entrenar nuevo modelo, introduce el nombre que quieras MODEL_NAME para tu modelo. Haz clic en Continuar.

  5. En el paso Contenedor de entrenamiento, especifique los siguientes ajustes:

    1. Selecciona si quieres usar un contenedor prediseñado o un contenedor personalizado para el entrenamiento.

    2. En función de lo que elijas, haz una de las siguientes acciones:

    3. En el campo Directorio de salida del modelo, especifica el URI de Cloud Storage de un directorio de un segmento al que tengas acceso. No es necesario que el directorio ya exista.

      Este valor se transfiere a Vertex AI en el campo baseOutputDirectory de la API, que define varias variables de entorno a las que puede acceder tu aplicación de entrenamiento cuando se ejecuta.

      Al final del entrenamiento, Vertex AI busca artefactos del modelo en un subdirectorio de este URI para crear un Model. (Este subdirectorio está disponible para tu código de entrenamiento como la variable de entorno AIP_MODEL_DIR).

      Si no usas la optimización de hiperparámetros, Vertex AI espera encontrar los artefactos del modelo en BASE_OUTPUT_DIRECTORY/model/.

    4. Opcional: En el campo Arguments (Argumentos), puedes especificar los argumentos que Vertex AI debe usar cuando empiece a ejecutar tu código de entrenamiento. La longitud máxima de todos los argumentos combinados es de 100.000 caracteres. El comportamiento de estos argumentos varía en función del tipo de contenedor que utilices:

    Haz clic en Continuar.

  6. En el paso Ajuste de hiperparámetros, asegúrate de que la casilla Habilitar ajuste de hiperparámetros no esté marcada. Haz clic en Continuar.

  7. En el paso Computación y precios, especifica los siguientes ajustes:

    1. En la lista desplegable Región, selecciona una región que admita el entrenamiento personalizado.

    2. En la sección Grupo de trabajadores 0, especifica los recursos de computación que quieres usar para el entrenamiento.

      Si especificas aceleradores, asegúrate de que el tipo de acelerador que elijas esté disponible en la región seleccionada.

      Si quieres llevar a cabo un entrenamiento distribuido, haz clic en Añadir más grupos de trabajo y especifica un conjunto adicional de recursos de computación para cada grupo de trabajo adicional que quieras.

    Haz clic en Continuar.

  8. En el paso Contenedor de predicción, especifique los siguientes ajustes:

    1. Selecciona si quieres usar un contenedor predefinido o un contenedor personalizado para servir predicciones de tu modelo entrenado.

    2. En función de lo que elijas, haz una de las siguientes acciones:

    3. El campo Directorio del modelo contiene el valor que has definido anteriormente en el campo Directorio de salida del modelo del paso Contenedor de entrenamiento. Cambiar cualquiera de estos campos tiene el mismo efecto. Consulta las instrucciones anteriores para obtener más información sobre este campo.

    4. Deja en blanco los campos de la sección Predecir esquemas.

  9. Haz clic en Iniciar entrenamiento para iniciar la canalización de entrenamiento personalizado.

REST

Usa el siguiente fragmento de código para crear una canalización de entrenamiento con el método create del recurso trainingPipeline.

Nota: Si quieres configurar esta canalización para que cree una versión del modelo, puedes añadir PARENT_MODEL en el campo trainingPipeline.

Para obtener más información, consulta Control de versiones de modelos con el registro de modelos de Vertex AI.

Antes de usar los datos de la solicitud, haz las siguientes sustituciones:

  • LOCATION_ID: región en la que se ejecuta el código de entrenamiento y se almacena el Model.
  • PROJECT_ID: tu ID de proyecto.
  • TRAINING_PIPELINE_NAME: obligatorio. Nombre visible del recurso TrainingPipeline.
  • Si tu aplicación de entrenamiento usa un conjunto de datos de Vertex AI, especifica lo siguiente:
    • DATASET_ID: ID del conjunto de datos.
    • ANNOTATIONS_FILTER: filtra el conjunto de datos por las anotaciones que especifiques.
    • ANNOTATION_SCHEMA_URI: filtra el conjunto de datos por el URI del esquema de anotación especificado.
    • Usa una de las siguientes opciones para especificar cómo se dividen los elementos de datos en conjuntos de entrenamiento, validación y prueba.
      • Para dividir el conjunto de datos en función de las fracciones que definen el tamaño de cada conjunto, especifica lo siguiente:
        • TRAINING_FRACTION: la fracción del conjunto de datos que se usará para entrenar el modelo.
        • VALIDATION_FRACTION: la fracción del conjunto de datos que se usará para validar tu modelo.
        • TEST_FRACTION: la fracción del conjunto de datos que se usará para evaluar el modelo.
      • Para dividir el conjunto de datos en función de los filtros, especifica lo siguiente:
        • TRAINING_FILTER: filtra el conjunto de datos para obtener los elementos de datos que se usarán para entrenar tu modelo.
        • VALIDATION_FILTER: filtra el conjunto de datos para mostrar los elementos de datos que se van a usar para validar el modelo.
        • TEST_FILTER: filtra el conjunto de datos para obtener los elementos de datos que se usarán para evaluar el modelo.
      • Para usar una división predefinida, especifica lo siguiente:
        • PREDEFINED_SPLIT_KEY: nombre de la columna que se va a usar para dividir el conjunto de datos. Los valores aceptables en esta columna son `training`, `validation` y `test`.
      • Para dividir el conjunto de datos en función de la marca de tiempo de los elementos de datos, especifica lo siguiente:
        • TIMESTAMP_TRAINING_FRACTION: la fracción del conjunto de datos que se usará para entrenar el modelo.
        • TIMESTAMP_VALIDATION_FRACTION: la fracción del conjunto de datos que se va a usar para validar el modelo.
        • TIMESTAMP_TEST_FRACTION: la fracción del conjunto de datos que se usará para evaluar el modelo.
        • TIMESTAMP_SPLIT_KEY: nombre de la columna de marca de tiempo que se usará para dividir el conjunto de datos.
    • OUTPUT_URI_PREFIX: la ubicación de Cloud Storage en la que Vertex AI exporta tu conjunto de datos de entrenamiento una vez que se ha dividido en conjuntos de entrenamiento, validación y prueba.
  • Define el trabajo de entrenamiento personalizado:
    • MACHINE_TYPE: el tipo de máquina. Consulta los tipos de máquinas disponibles para el entrenamiento.
    • ACCELERATOR_TYPE: (opcional). Tipo de acelerador que se va a asociar a cada prueba.
    • ACCELERATOR_COUNT: (opcional). Número de aceleradores que se van a asociar a cada prueba.
    • REPLICA_COUNT: número de réplicas de trabajadores que se deben usar en cada prueba.
    • Si tu aplicación de entrenamiento se ejecuta en un contenedor personalizado, especifica lo siguiente:
      • CUSTOM_CONTAINER_IMAGE_URI: URI de una imagen de contenedor en Artifact Registry o Docker Hub que se va a ejecutar en cada réplica de trabajador.
      • CUSTOM_CONTAINER_COMMAND: (opcional). El comando que se invoca cuando se inicia el contenedor. Este comando anula el punto de entrada predeterminado del contenedor.
      • CUSTOM_CONTAINER_ARGS: (opcional). Los argumentos que se deben transferir al iniciar el contenedor. La longitud máxima de todos los argumentos combinados es de 100.000 caracteres.
    • Si tu aplicación de entrenamiento es un paquete de Python que se ejecuta en un contenedor prediseñado, especifica lo siguiente:
      • PYTHON_PACKAGE_EXECUTOR_IMAGE_URI: el URI de la imagen del contenedor que ejecuta el paquete de Python proporcionado. Consulta los contenedores prediseñados disponibles para el entrenamiento.
      • PYTHON_PACKAGE_URIS: la ubicación en Cloud Storage de los archivos del paquete de Python, que son el programa de entrenamiento y sus paquetes dependientes. El número máximo de URIs de paquetes es 100.
      • PYTHON_MODULE: el nombre del módulo de Python que se ejecutará después de instalar los paquetes.
      • PYTHON_PACKAGE_ARGS: (opcional). Argumentos de línea de comandos que se van a transferir al módulo de Python. La longitud máxima de todos los argumentos combinados es de 100.000 caracteres.
    • TIMEOUT: (opcional). Tiempo máximo de ejecución del trabajo.
  • MODEL_NAME: nombre visible del modelo subido (creado) por TrainingPipeline.
  • MODEL_DESCRIPTION: una descripción del modelo.
  • IMAGE_URI: URI de la imagen del contenedor que se va a usar para ejecutar predicciones. Por ejemplo, us-docker.pkg.dev/vertex-ai/prediction/tf2-cpu.2-1:latest. Usa contenedores prediseñados o contenedores personalizados.
  • modelToUpload.labels: cualquier conjunto de pares clave-valor para organizar tus modelos. Por ejemplo:
    • "env": "prod"
    • "tier": "backend"
  • Especifica el LABEL_NAME y el LABEL_VALUE de las etiquetas que quieras aplicar a esta canalización de entrenamiento.

Método HTTP y URL: 

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

Cuerpo JSON de la solicitud: 

{
  "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 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_ID-aiplatform.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION_ID/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_ID-aiplatform.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION_ID/trainingPipelines" | Select-Object -Expand Content

La respuesta contiene información sobre las especificaciones, así como el elemento TRAININGPIPELINE_ID.

Java

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

Para autenticarte en Vertex AI, configura las credenciales predeterminadas de la aplicación. Para obtener más información, consulta el artículo Configurar la autenticación en un entorno de desarrollo 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 cómo instalar o actualizar el SDK de Vertex AI para Python, consulta Instalar el SDK de Vertex AI para Python. Para obtener más información, consulta la documentación de referencia de la API Python.

En los siguientes ejemplos se muestra cómo usar el SDK de Vertex AI para Python para crear una canalización de entrenamiento personalizada. Elige si quieres usar un contenedor personalizado o un contenedor prediseñado para el entrenamiento:

Contenedor prediseñado

Cuando usas el SDK de Vertex AI para Python para crear una canalización de entrenamiento que ejecuta tu código de Python en un contenedor precompilado, puedes proporcionar tu código de entrenamiento de una de las siguientes formas:

  • Especifica el URI de un paquete de distribución de origen de Python en Cloud Storage.

    Esta opción también está disponible cuando creas una canalización de entrenamiento sin usar el SDK de Vertex AI para Python.

  • Especifica la ruta a una secuencia de comandos de Python en tu máquina local. Antes de crear una canalización de entrenamiento, el SDK de Vertex AI para Python empaqueta tu secuencia de comandos como una distribución de origen y la sube al segmento de Cloud Storage que elijas.

    Esta opción solo está disponible cuando se usa el SDK de Vertex AI para Python.

Para ver un código de muestra de cada una de estas opciones, selecciona la pestaña correspondiente:

Paquete

En el siguiente ejemplo se usa la CustomPythonPackageTrainingJobclase.

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

Secuencia de comandos

En el siguiente ejemplo se usa la CustomTrainingJobclase.

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

Contenedor personalizado

En el siguiente ejemplo se usa la CustomContainerTrainingJobclase.

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

Tarea de ajuste de hiperparámetros y subida de modelos

Esta canalización de entrenamiento encapsula una tarea de ajuste de hiperparámetros con un paso adicional que facilita el despliegue del modelo en Vertex AI después del entrenamiento. Este flujo de procesamiento de entrenamiento hace dos cosas principales:

  1. El flujo de procesamiento de entrenamiento crea un recurso de tarea de ajuste de hiperparámetros. La tarea de ajuste de hiperparámetros crea varias pruebas. En cada prueba, una tarea personalizada ejecuta tu aplicación de entrenamiento con los recursos de computación y los hiperparámetros que especifiques.

  2. Una vez que se completa la tarea de ajuste de hiperparámetros, la canalización de entrenamiento busca los artefactos del modelo de la mejor prueba en el directorio de salida (baseOutputDirectory) que hayas especificado para tu bucket de Cloud Storage. La canalización de entrenamiento usa estos artefactos para crear un recurso model, que te prepara para el despliegue del modelo.

En este flujo de trabajo de entrenamiento, debes especificar un baseOutputDirectory donde Vertex AI busque los artefactos del modelo de la mejor prueba.

Las tareas de ajuste de hiperparámetros tienen ajustes adicionales que se pueden configurar. Consulta más información sobre los ajustes de un HyperparameterTuningJob.

REST

Usa el siguiente fragmento de código para crear una canalización de entrenamiento con el método create del recurso trainingPipeline.

Antes de usar los datos de la solicitud, haz las siguientes sustituciones:

  • LOCATION_ID: la región de tu proyecto.
  • PROJECT_ID: tu ID de proyecto.
  • TRAINING_PIPELINE_NAME: obligatorio. Nombre visible del recurso TrainingPipeline.
  • Si tu aplicación de entrenamiento usa un conjunto de datos de Vertex AI, especifica lo siguiente:
    • DATASET_ID: ID del conjunto de datos.
    • ANNOTATIONS_FILTER: filtra el conjunto de datos por las anotaciones que especifiques.
    • ANNOTATION_SCHEMA_URI: filtra el conjunto de datos por el URI del esquema de anotación especificado.
    • Usa una de las siguientes opciones para especificar cómo se dividen los elementos de datos en conjuntos de entrenamiento, validación y prueba.
      • Para dividir el conjunto de datos en función de las fracciones que definen el tamaño de cada conjunto, especifica lo siguiente:
        • TRAINING_FRACTION: la fracción del conjunto de datos que se usará para entrenar el modelo.
        • VALIDATION_FRACTION: la fracción del conjunto de datos que se usará para validar tu modelo.
        • TEST_FRACTION: la fracción del conjunto de datos que se usará para evaluar el modelo.
      • Para dividir el conjunto de datos en función de los filtros, especifica lo siguiente:
        • TRAINING_FILTER: filtra el conjunto de datos para obtener los elementos de datos que se usarán para entrenar tu modelo.
        • VALIDATION_FILTER: filtra el conjunto de datos para mostrar los elementos de datos que se van a usar para validar el modelo.
        • TEST_FILTER: filtra el conjunto de datos para obtener los elementos de datos que se usarán para evaluar el modelo.
      • Para usar una división predefinida, especifica lo siguiente:
        • PREDEFINED_SPLIT_KEY: nombre de la columna que se va a usar para dividir el conjunto de datos. Los valores aceptables en esta columna son `training`, `validation` y `test`.
      • Para dividir el conjunto de datos en función de la marca de tiempo de los elementos de datos, especifica lo siguiente:
        • TIMESTAMP_TRAINING_FRACTION: la fracción del conjunto de datos que se usará para entrenar el modelo.
        • TIMESTAMP_VALIDATION_FRACTION: la fracción del conjunto de datos que se va a usar para validar el modelo.
        • TIMESTAMP_TEST_FRACTION: la fracción del conjunto de datos que se usará para evaluar el modelo.
        • TIMESTAMP_SPLIT_KEY: nombre de la columna de marca de tiempo que se usará para dividir el conjunto de datos.
    • OUTPUT_URI_PREFIX: la ubicación de Cloud Storage donde Vertex AI exporta tu conjunto de datos de entrenamiento después de dividirlo en conjuntos de entrenamiento, validación y prueba.
  • Especifica la tarea de ajuste de hiperparámetros:
    • Especifique las métricas:
      • METRIC_ID: nombre de esta métrica.
      • METRIC_GOAL: el objetivo de esta métrica. Puede ser MAXIMIZE o MINIMIZE.
    • Especifica los hiperparámetros:
      • PARAMETER_ID: el nombre de este hiperparámetro.
      • PARAMETER_SCALE: (opcional). Cómo se debe escalar el parámetro. No se define ningún valor para los parámetros CATEGORICAL. Puede ser UNIT_LINEAR_SCALE, UNIT_LOG_SCALE, UNIT_REVERSE_LOG_SCALE o SCALE_TYPE_UNSPECIFIED
      • Si el tipo de este hiperparámetro es DOUBLE, especifique los valores mínimo (DOUBLE_MIN_VALUE) y máximo (DOUBLE_MAX_VALUE) de este hiperparámetro.
      • Si el tipo de este hiperparámetro es INTEGER, especifica los valores mínimo (INTEGER_MIN_VALUE) y máximo (INTEGER_MAX_VALUE) de este hiperparámetro.
      • Si el tipo de este hiperparámetro es CATEGORICAL, especifica los valores aceptables (CATEGORICAL_VALUES) como un array de cadenas.
      • Si el tipo de este hiperparámetro es DISCRETE, especifica los valores aceptables (DISCRETE_VALUES) como un array de números.
    • ALGORITHM: (opcional). Algoritmo de búsqueda que se va a usar en esta tarea de ajuste de hiperparámetros. Puede ser ALGORITHM_UNSPECIFIED, GRID_SEARCH o RANDOM_SEARCH.
    • MAX_TRIAL_COUNT: número máximo de pruebas que se pueden ejecutar en este trabajo.
    • PARALLEL_TRIAL_COUNT: número máximo de pruebas que se pueden ejecutar en paralelo.
    • MAX_FAILED_TRIAL_COUNT: número de tareas que pueden fallar antes de que falle la tarea de ajuste de hiperparámetros.
    • Define el trabajo de entrenamiento personalizado de prueba:
      • MACHINE_TYPE: el tipo de máquina. Consulta los tipos de máquinas disponibles para el entrenamiento.
      • ACCELERATOR_TYPE: (opcional). Tipo de acelerador que se va a asociar a cada prueba.
      • ACCELERATOR_COUNT: (opcional). Número de aceleradores que se van a asociar a cada prueba.
      • REPLICA_COUNT: número de réplicas de trabajadores que se deben usar en cada prueba.
      • Si tu aplicación de entrenamiento se ejecuta en un contenedor personalizado, especifica lo siguiente:
        • CUSTOM_CONTAINER_IMAGE_URI: URI de una imagen de contenedor en Artifact Registry o Docker Hub que se va a ejecutar en cada réplica de trabajador.
        • CUSTOM_CONTAINER_COMMAND: (opcional). El comando que se invoca cuando se inicia el contenedor. Este comando anula el punto de entrada predeterminado del contenedor.
        • CUSTOM_CONTAINER_ARGS: (opcional). Los argumentos que se deben transferir al iniciar el contenedor.
      • Si tu aplicación de entrenamiento es un paquete de Python que se ejecuta en un contenedor prediseñado, especifica lo siguiente:
        • PYTHON_PACKAGE_EXECUTOR_IMAGE_URI: el URI de la imagen del contenedor que ejecuta el paquete de Python proporcionado. Consulta los contenedores prediseñados disponibles para el entrenamiento.
        • PYTHON_PACKAGE_URIS: la ubicación de Cloud Storage de los archivos del paquete de Python, que son el programa de entrenamiento y sus paquetes dependientes. El número máximo de URIs de paquetes es 100.
        • PYTHON_MODULE: el nombre del módulo de Python que se va a ejecutar después de instalar los paquetes.
        • PYTHON_PACKAGE_ARGS: (opcional). Argumentos de línea de comandos que se van a transferir al módulo de Python.
    • Consulta las opciones de programación de trabajos.
    • TIMEOUT: (opcional). El tiempo máximo de ejecución de cada prueba.
    • Especifica los campos LABEL_NAME y LABEL_VALUE de las etiquetas que quieras aplicar a esta tarea de ajuste de hiperparámetros.
  • MODEL_NAME: nombre visible del modelo subido (creado) por TrainingPipeline.
  • MODEL_DESCRIPTION: opcional. Descripción del modelo.
  • PREDICTION_IMAGE_URI: obligatorio. Especifique una de las dos opciones siguientes:
  • modelToUpload.labels: opcional. Cualquier conjunto de pares clave-valor para organizar tus modelos. Por ejemplo:
    • "env": "prod"
    • "tier": "backend"
  • Especifica el LABEL_NAME y el LABEL_VALUE de las etiquetas que quieras aplicar a esta canalización de entrenamiento.

Método HTTP y URL: 

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

Cuerpo JSON de la solicitud: 

{
  "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 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_ID-aiplatform.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION_ID/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_ID-aiplatform.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION_ID/trainingPipelines" | Select-Object -Expand Content

La respuesta contiene información sobre las especificaciones, así como el elemento TRAININGPIPELINE_ID.

Monitorizar el entrenamiento

Para ver los registros de entrenamiento, sigue estos pasos:

  1. En la Google Cloud consola, en la sección Vertex AI, ve a la página Entrenamiento.

    Ir a la página Formación

  2. Haz clic en el nombre del trabajo para ir a la página de trabajo personalizado.

  3. Haz clic en Ver registros.

También puedes usar un shell interactivo para inspeccionar tus contenedores de entrenamiento mientras se ejecuta la canalización de entrenamiento.

Ver el modelo entrenado

Cuando se complete el flujo de trabajo de entrenamiento personalizado, podrás encontrar el modelo entrenado en la Google Cloud consola, en la sección Vertex AI, en la página Modelos.

Ir a la página Modelos

Siguientes pasos