Crear canalizaciones de entrenamiento

Las canalizaciones de entrenamiento te permiten realizar entrenamiento personalizado de aprendizaje automático (AA) y crear de forma automática un recurso Model en función del resultado de tu entrenamiento.

Antes de crear una canalización

Antes de crear una canalización 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 ejecutar Vertex AI. Si creas una aplicación de entrenamiento de Python mediante TensorFlow, scikit-learn o XGBoost, puedes usar nuestros contenedores compilados con anterioridad para ejecutar tu código. Si no estás seguro de cuál de estas opciones elegir, consulta los requisitos de código de entrenamiento para obtener más información.

Opciones de canalización de entrenamiento

Una canalización de entrenamiento encapsula trabajos de entrenamiento con pasos adicionales. En esta guía, se explican dos canalizaciones de entrenamiento diferentes:

• Inicia un CustomJob y sube el modelo resultante a Vertex AI.
• Inicia un trabajo de ajuste de hiperparámetros y sube el modelo resultante a Vertex AI

Además, puedes usar conjuntos de datos administrados en tu canalización de entrenamiento. Obtén más información para configurar tu canalización de entrenamiento para usar un conjunto de datos administrado.

Qué incluye un CustomJob

Cuando creas un trabajo personalizado, especificas la configuración que necesita Vertex AI para ejecutar tu código de entrenamiento, incluido lo siguiente:

• Un grupo de trabajadores para el entrenamiento de nodo único (WorkerPoolSpec) o varios grupos de trabajadores para el entrenamiento distribuido
• Configuración opcional para configurar la programación de trabajos (Scheduling), establecer ciertas variables de entorno para tu código de entrenamiento, usar una cuenta de servicio y usar intercambio de tráfico entre redes de VPC

En los grupos de trabajadores, puedes especificar la siguiente configuración:

• Tipos de máquinas y aceleradores
• Configuración de qué tipo de código de entrenamiento ejecuta el grupo de trabajadores: una aplicación de entrenamiento de Python (PythonPackageSpec) o un contenedor personalizado (ContainerSpec).

Si deseas crear un trabajo personalizado independiente fuera de una canalización de Vertex AI Training, consulta la guía sobre trabajos personalizados.

Configura tu canalización para usar un conjunto de datos administrado

En tu canalización de entrenamiento, puedes configurar tu trabajo de entrenamiento personalizado o trabajo de ajuste de hiperparámetros para usar un conjunto de datos administrado. Los conjuntos de datos administrados te permiten administrar tus conjuntos de datos con tus aplicaciones y modelos de entrenamiento.

Para usar un conjunto de datos administrado en tu canalización de entrenamiento:

1. Crea el conjunto de datos.
2. Actualiza tu aplicación de entrenamiento para usar un conjunto de datos administrado. Para obtener más información, consulta cómo pasa Vertex AI el conjunto de datos a la aplicación de entrenamiento.

3. Especifica un conjunto de datos administrado cuando crees tu canalización de entrenamiento. Por ejemplo, si creas tu canalización de entrenamiento con la API de REST, especifica la configuración del conjunto de datos en la sección inputDataConfig.

   Debes crear la canalización de entrenamiento en la misma región en la que creaste el conjunto de datos.

Si quieres obtener más información, consulta la referencia de la API de TrainingPipeline.

Configura el entrenamiento distribuido

Dentro de tu canalización de entrenamiento, puedes configurar trabajo de entrenamiento personalizado o tu trabajo de ajuste de hiperparámetros a fin de obtener un entrenamiento distribuido mediante la especificación de varios grupos de trabajadores.

En todos los ejemplos de esta página, se muestran trabajos de entrenamiento de una sola réplica con un grupo de trabajadores. A fin de modificarlos para el entrenamiento distribuido, sigue estos pasos:

• Usa tu primer grupo de trabajadores para configurar la réplica principal y establece el recuento de réplicas en 1.
• Agrega más grupos de trabajadores para configurar réplicas de trabajadores, réplicas del servidor de parámetros o réplicas de evaluadores si tu framework de aprendizaje automático admite estas tareas adicionales del clúster para el entrenamiento distribuido.

Obtén más información sobre cómo usar el entrenamiento distribuido.

Carga de modelos y trabajos personalizados

Esta canalización de entrenamiento encapsula un trabajo personalizado con un paso de conveniencia adicional que facilita la implementación del modelo en Vertex AI después del entrenamiento. En esta canalización de entrenamiento, se realizan dos tareas principales:

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

2. Una vez finalizado el trabajo personalizado, la canalización de entrenamiento encuentra los artefactos del modelo que crea tu aplicación de entrenamiento en el directorio de salida que especificaste en el bucket de Cloud Storage. Usa estos artefactos a fin de crear un recurso del modelo, que te prepara para la implementación del modelo.

Hay dos formas diferentes de configurar la ubicación para los artefactos del modelo:

• Si configuras un baseOutputDirectory para tu trabajo de entrenamiento, asegúrate de que el código de entrenamiento guarde los artefactos de ese modelo en esa ubicación con la variable de entorno $AIP_MODEL_DIR. que estableció 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.

  Nota: Si usas el SDK de Vertex AI para Python, puedes omitir el atributo base_output_dir. En este caso, Vertex AI genera los artefactos de tu modelo en un directorio con marca de tiempo en el directorio de etapa de pruebas. Para obtener detalles, consulta:

  • CustomJob
  • CustomContainerTrainingJob

  • CustomPythonPackageTrainingJob

• Si configuras el campo modelToUpload.artifactUri, la canalización de entrenamiento sube los artefactos del modelo desde ese URI. Debes establecer este campo si no configuraste baseOutputDirectory.

Si especificas baseOutputDirectory y modelToUpload.artifactUri, Vertex AI usa modelToUpload.artifactUri.

Para crear este tipo de canalización de entrenamiento, sigue estos pasos:

Console

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

   Ve a Canalizaciones de entrenamiento

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

3. En el paso Método de entrenamiento, especifica las siguientes opciones de configuración:

   1. Si deseas usar un conjunto de datos administrado para el entrenamiento, especifica un Conjunto de datos y un conjunto de anotaciones.

      De lo contrario, en la lista desplegable Conjunto de datos, selecciona No hay ningún conjunto de datos administrado.

   2. Selecciona Entrenamiento personalizado (avanzado).

   Haz clic en Continuar.

4. En el paso Detalles del modelo, elige Entrenar modelo nuevo o Entrenar versión nueva. Si seleccionas el modelo nuevo, ingresa el nombre que desees, MODEL_NAME, para el modelo. Haz clic en Continuar.

5. En el paso Contenedor de entrenamiento, especifica la siguiente configuración:

   1. Selecciona si deseas usar un contenedor compilado previamente o un contenedor personalizado para el entrenamiento.

   2. Según tu elección, realiza una de las siguientes acciones:

      • Si deseas usar un contenedor compilado previamente para el entrenamiento, proporciona a Vertex AI la información que necesita a fin de usar el paquete de entrenamiento que subiste a Cloud Storage:

        1. Usa las listas desplegables del framework del modelo y la versión del framework del modelo para especificar el contenedor compilado previamente que deseas utilizar.

        2. En el campo Ubicación del paquete, especifica el URI de Cloud Storage de la aplicación de entrenamiento de Python que creaste y subiste. Por lo general, este archivo termina en .tar.gz.

        3. En el campo Módulo de Python, ingresa el nombre del módulo del punto de entrada de tu aplicación de entrenamiento.

      • Si deseas usar un contenedor personalizado para el entrenamiento, en el campo Imagen de contenedor, especifica el Artifact Registry o el URI de Docker Hub de tu imagen de contenedor.

   3. En el campo Directorio de resultado del modelo, especifica el URI de Cloud Storage de un directorio en un bucket al que tengas acceso. No es necesario que el directorio ya esté creado.

      Este valor se pasa a Vertex AI en el campo de API baseOutputDirectory, que establece distintas 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).

      Cuando no usas el ajuste de hiperparámetros, Vertex AI espera encontrar artefactos del modelo en BASE_OUTPUT_DIRECTORY/model/.

   4. Opcional: En el campo Argumentos, puedes especificar argumentos para que Vertex AI los use cuando comience a ejecutar tu código de entrenamiento. La longitud máxima para todos los argumentos combinados es de 100,000 caracteres. El comportamiento de estos argumentos difiere según el tipo de contenedor que uses:

      • Si usas un contenedor compilado previamente, Vertex AI pasa los argumentos como marcas de línea de comandos a tu módulo de Python.

      • Si usas un contenedor personalizado, Vertex AI anula la instrucción CMD de tu contenedor con los argumentos.

   Haz clic en Continuar.

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

7. En el paso Procesamiento y precio, especifica las siguientes opciones de configuración:

   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 recursos de procesamiento para usar en el entrenamiento.

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

      Si quieres realizar un entrenamiento distribuido, haz clic en Agregar más grupos de trabajadores y especifica un conjunto adicional de recursos de procesamiento para cada grupo de trabajadores adicional que quieras.

   Haz clic en Continuar.

8. En el paso Contenedor de predicción, especifica la siguiente configuración:

   1. Selecciona si deseas usar un contenedor compilado previamente o un contenedor personalizado para entregar predicciones de tu modelo entrenado.

   2. Según tu elección, realiza una de las siguientes acciones:

      • Si deseas usar un contenedor compilado previamente para entregar predicciones, usa los campos framework del modelo, la versión del framework del modelo y el tipo de acelerador para elegir qué contenedor de predicción compilado previamente se usará en la predicción.

        Haz coincidir el framework del modelo y la versión del framework del modelo con el marco de trabajo de aprendizaje automático que usaste para el entrenamiento. Solo debes especificar un tipo de acelerador si luego deseas usar GPU para predicciones en línea o por lotes.

      • Si deseas usar un contenedor personalizado para entregar predicciones, haz lo siguiente:

        1. En el campo Imagen de contenedor, especifica el URI de Artifact Registry de tu imagen de contenedor.

        2. De forma opcional, puedes especificar un Comando para anular la instrucción ENTRYPOINT del contenedor.

   3. El campo Directorio de modelos contiene el valor que configuraste en el campo Directorio del modelo de salida del paso Entrenamiento del contenedor. Cambiar cualquiera de estos campos tiene el mismo efecto. Consulta la instrucción anterior para obtener más información sobre este campo.

   4. Deja en blanco los campos de la sección Esquema de predicción.

9. Haz clic en Comenzar el entrenamiento para comenzar la canalización de entrenamiento personalizada.

REST

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

Nota: Si deseas configurar esta canalización para crear una versión del modelo nueva, puedes agregar el PARENT_MODEL en el campo trainingPipeline.

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

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

• LOCATION_ID: La región en la que se ejecuta el código de entrenamiento y Model se almacena.
• PROJECT_ID: ID del proyecto
• TRAINING_PIPELINE_NAME: Obligatorio. Un nombre visible para trainingPipeline.
• Si tu aplicación de entrenamiento usa un conjunto de datos de Vertex AI, especifica lo siguiente:
  • DATASET_ID: El ID del conjunto de datos.
  • ANNOTATIONS_FILTER: Filtra el conjunto de datos según las anotaciones que especifiques.
  • ANNOTATION_SCHEMA_URI: Filtra el conjunto de datos según el URI de 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 según 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 el modelo.
      • TEST_FRACTION: La fracción del conjunto de datos que se usará para evaluar el modelo.
    • Para dividir el conjunto de datos según los filtros, especifica lo siguiente:
      • TRAINING_FILTER: Filtra el conjunto de datos a elementos de datos para usar en el entrenamiento del modelo.
      • VALIDATION_FILTER: Filtra el conjunto de datos a elementos de datos para usar en la validación del modelo.
      • TEST_FILTER: Filtra el conjunto de datos a elementos de datos para usar en la evaluación del modelo.
    • Para usar una división predefinida, especifica lo siguiente:
      • PREDEFINED_SPLIT_KEY: El nombre de la columna que se usará para dividir el conjunto de datos. Los valores aceptables en esta columna incluyen “training”, “validation” y “test”.
    • Para dividir el conjunto de datos según la marca de tiempo en los elementos de datos, especifica lo siguiente:
      • TIMESTAMP_TRAINING_FRACTION: La fracción del conjunto de datos que se usará para entrenar tu modelo.
      • TIMESTAMP_VALIDATION_FRACTION: La fracción del conjunto de datos que se 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: El 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 divide 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: El tipo de acelerador que se conectará a cada prueba (opcional).
  • ACCELERATOR_COUNT: La cantidad de aceleradores que se conectarán a cada prueba (opcional).
  • REPLICA_COUNT: La cantidad de réplicas de trabajadores que se deben usar para cada prueba.
  • Si tu aplicación de entrenamiento se ejecuta en un contenedor personalizado, especifica lo siguiente:
    • CUSTOM_CONTAINER_IMAGE_URI: Es el URI de una imagen de contenedor en Artifact Registry o Docker Hub que se ejecutará en cada réplica de trabajador.
    • CUSTOM_CONTAINER_COMMAND: El comando que se invocará cuando se inicie el contenedor. Este comando anula el punto de entrada predeterminado del contenedor.
    • CUSTOM_CONTAINER_ARGS: son los argumentos que se transmitirán cuando se inicia el contenedor (opcional). La longitud máxima para 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 compilado previamente, especifica lo siguiente:
    • PYTHON_PACKAGE_EXECUTOR_IMAGE_URI: El URI de la imagen de contenedor que ejecuta el paquete de Python proporcionado. Consulte los contenedores precompilados 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. La cantidad máxima de URI de paquete es 100.
    • PYTHON_MODULE: El nombre del módulo de Python que se ejecutará después de instalar los paquetes.
    • PYTHON_PACKAGE_ARGS: son los argumentos de la línea de comandos que se pasarán al módulo de Python. La longitud máxima para todos los argumentos combinados es de 100,000 caracteres.
  • TIMEOUT: es el tiempo máximo de ejecución para el trabajo.
• MODEL_NAME: Un nombre visible para el modelo subido (creado) con TrainingPipeline.
• MODEL_DESCRIPTION: Una descripción del modelo.
• IMAGE_URI: El URI de la imagen de contenedor que se usará para ejecutar predicciones. Por ejemplo, us-docker.pkg.dev/vertex-ai/prediction/tf2-cpu.2-1:latest. Usa contenedores compilados previamente o contenedores personalizados.
• modelToUpload.labels: Cualquier conjunto de pares clave-valor para organizar los modelos. Por ejemplo:
  • "env": "prod"
  • "tier": "backend"
• Especifica LABEL_NAME y LABEL_VALUE para las etiquetas que deseas 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

Nota: Con el siguiente comando, se supone que accediste a la CLI de gcloud con tu cuenta de usuario a través de la ejecución de gcloud init o gcloud auth login, o a través del uso de Cloud Shell, que accede de forma automática a la CLI de gcloud. Para comprobar la cuenta activa actual, ejecuta gcloud auth list.

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

Nota: En el siguiente comando, se supone que accediste a la CLI de gcloud con tu cuenta de usuario a través de la ejecución de gcloud init o gcloud auth login . Para comprobar la cuenta activa actual, ejecuta gcloud auth list.

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 y los TRAININGPIPELINE_ID.

Respuesta

{
  "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 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.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

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.

En los siguientes ejemplos, se muestra cómo usar el SDK de Vertex AI para Python a fin de crear una canalización de entrenamiento personalizado. Elige si planeas usar un contenedor personalizado o un contenedor compilado previamente para el entrenamiento:

Contenedor previamente compilado

Cuando usas el SDK de Vertex AI para Python a fin de crear una canalización de entrenamiento que ejecute el código de Python en un contenedor compilado previamente, puedes proporcionar el código de entrenamiento de una de las siguientes maneras:

• Especifica el URI de un paquete de distribución de fuente 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 de acceso 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 la secuencia de comandos como una distribución de fuente y la sube al bucket de Cloud Storage que elijas.

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

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

Paquete

En la siguiente muestra, se usa la clase 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

Secuencia de comandos

En la siguiente muestra, se usa la clase 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

Contenedor personalizado

En la siguiente muestra, se usa la clase 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

Carga de modelos y trabajos de ajuste de hiperparámetros

Esta canalización de entrenamiento encapsula un trabajo de ajuste de hiperparámetros con un paso de conveniencia adicional que facilita la implementación del modelo en Vertex AI después del entrenamiento. En esta canalización de entrenamiento, se realizan dos tareas principales:

1. La canalización de entrenamiento crea un recurso de trabajo de ajuste de hiperparámetros. El trabajo de ajuste de hiperparámetros crea varias pruebas. Para cada prueba, un trabajo personalizado ejecuta tu aplicación de entrenamiento mediante los recursos de procesamiento y los hiperparámetros que especificas.

2. Una vez que se completa el trabajo de ajuste de hiperparámetros, la canalización de entrenamiento busca los artefactos de modelo de la mejor prueba, dentro del directorio de salida (baseOutputDirectory) que especificaste en el bucket de Cloud Storage. La canalización de entrenamiento usa estos artefactos a fin de crear un recurso de modelo, que te preparará para la implementación del modelo.

Para esta canalización de entrenamiento, debes especificar un baseOutputDirectory en el que Vertex AI busque los artefactos de modelo de la mejor prueba.

Los trabajos de ajuste de hiperparámetros tienen una configuración adicional. Obtén más información sobre la configuración de HyperparameterTuningJob.

REST

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

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

• LOCATION_ID: La región del proyecto.
• PROJECT_ID: ID del proyecto
• TRAINING_PIPELINE_NAME: Obligatorio. Un nombre visible para trainingPipeline.
• Si tu aplicación de entrenamiento usa un conjunto de datos de Vertex AI, especifica lo siguiente:
  • DATASET_ID: El ID del conjunto de datos.
  • ANNOTATIONS_FILTER: Filtra el conjunto de datos según las anotaciones que especifiques.
  • ANNOTATION_SCHEMA_URI: Filtra el conjunto de datos según el URI de 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 según 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 el modelo.
      • TEST_FRACTION: La fracción del conjunto de datos que se usará para evaluar el modelo.
    • Para dividir el conjunto de datos según los filtros, especifica lo siguiente:
      • TRAINING_FILTER: Filtra el conjunto de datos a elementos de datos para usar en el entrenamiento del modelo.
      • VALIDATION_FILTER: Filtra el conjunto de datos a elementos de datos para usar en la validación del modelo.
      • TEST_FILTER: Filtra el conjunto de datos a elementos de datos para usar en la evaluación del modelo.
    • Para usar una división predefinida, especifica lo siguiente:
      • PREDEFINED_SPLIT_KEY: El nombre de la columna que se usará para dividir el conjunto de datos. Los valores aceptables en esta columna incluyen “training”, “validation” y “test”.
    • Para dividir el conjunto de datos según la marca de tiempo en los elementos de datos, especifica lo siguiente:
      • TIMESTAMP_TRAINING_FRACTION: La fracción del conjunto de datos que se usará para entrenar tu modelo.
      • TIMESTAMP_VALIDATION_FRACTION: La fracción del conjunto de datos que se 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: El 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, luego de que se divide en conjuntos de entrenamiento, validación y prueba.
• Especifica tu trabajo de ajuste de hiperparámetros:
  • Especifica tus métricas:
    • METRIC_ID: El nombre de esta métrica.
    • METRIC_GOAL: el objetivo de esta métrica. Puede ser MAXIMIZE o MINIMIZE.
  • Especifica tus hiperparámetros:
    • PARAMETER_ID: El nombre de este hiperparámetro.
    • PARAMETER_SCALE: Indica cómo se debe escalar el parámetro. Se deja sin configurar 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 hiperparámetro es DOUBLE, especifica los valores mínimos (DOUBLE_MIN_VALUE) y máximos (DOUBLE_MAX_VALUE) para este hiperparámetro.
    • Si el tipo de hiperparámetro es un NÚMERO ENTERO, especifica los valores mínimos (INTEGER_MIN_VALUE) y máximos (INTEGER_MAX_VALUE) para este hiperparámetro.
    • Si el tipo de hiperparámetro es CATEGORICAL, especifica los valores aceptables (CATEGORICAL_VALUES) como un array de strings.
    • Si el tipo de hiperparámetro es DISCRETE, especifica los valores aceptables (DISCRETE_VALUES) como un array de números.
  • ALGORITHM: El algoritmo de búsqueda que se usará en este trabajo de ajuste de hiperparámetros (opcional). Puede ser ALGORITHM_UNSPECIFIED, GRID_SEARCH o RANDOM_SEARCH.
  • MAX_TRIAL_COUNT: La cantidad máxima de pruebas que se ejecutarán en este trabajo.
  • PARALLEL_TRIAL_COUNT: la cantidad máxima de pruebas que pueden ejecutarse en paralelo.
  • MAX_FAILED_TRIAL_COUNT: la cantidad de trabajos que pueden fallar antes de que falle el trabajo 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: El tipo de acelerador que se conectará a cada prueba (opcional).
    • ACCELERATOR_COUNT: La cantidad de aceleradores que se conectarán a cada prueba (opcional).
    • REPLICA_COUNT: La cantidad de réplicas de trabajadores que se deben usar para cada prueba.
    • Si tu aplicación de entrenamiento se ejecuta en un contenedor personalizado, especifica lo siguiente:
      • CUSTOM_CONTAINER_IMAGE_URI: Es el URI de una imagen de contenedor en Artifact Registry o Docker Hub que se ejecuta en cada réplica de trabajador.
      • CUSTOM_CONTAINER_COMMAND: El comando que se invocará cuando se inicie el contenedor. Este comando anula el punto de entrada predeterminado del contenedor.
      • CUSTOM_CONTAINER_ARGS: son los argumentos que se transmitirán cuando se inicia el contenedor (opcional).
    • Si tu aplicación de entrenamiento es un paquete de Python que se ejecuta en un contenedor compilado previamente, especifica lo siguiente:
      • PYTHON_PACKAGE_EXECUTOR_IMAGE_URI: El URI de la imagen de contenedor que ejecuta el paquete de Python proporcionado. Consulta los contenedores precompilados disponibles para el entrenamiento.
      • PYTHON_PACKAGE_URIS: La ubicación de Cloud Storage de los archivos de paquete de Python, que son el programa de entrenamiento y sus paquetes dependientes La cantidad máxima de URI de paquete es 100.
      • PYTHON_MODULE: El nombre del módulo de Python que se ejecutará después de instalar los paquetes.
      • PYTHON_PACKAGE_ARGS: son los argumentos de la línea de comandos que se pasarán al módulo de Python.
  • Obtén más información sobre las opciones de programación de trabajos.
  • TIMEOUT: El tiempo máximo de ejecución para cada prueba (opcional).
  • Especifica LABEL_NAME y LABEL_VALUE para las etiquetas que deseas aplicar a este trabajo de ajuste de hiperparámetros.
• MODEL_NAME: Un nombre visible para el modelo subido (creado) con TrainingPipeline.
• MODEL_DESCRIPTION: Opcional Es una descripción del modelo.
• PREDICTION_IMAGE_URI: Obligatorio. Especifica una de las dos opciones siguientes:
  • El URI de imagen del contenedor compilado previamente para usar en la predicción, como “tf2-cpu.2-1:latest”.
  • El URI de imagen de tu propio contenedor personalizado para usar en la predicción.
• modelToUpload.labels: Opcional Cualquier conjunto de pares clave-valor para organizar tus modelos. Por ejemplo:
  • "env": "prod"
  • "tier": "backend"
• Especifica LABEL_NAME y LABEL_VALUE para las etiquetas que deseas 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

Nota: Con el siguiente comando, se supone que accediste a la CLI de gcloud con tu cuenta de usuario a través de la ejecución de gcloud init o gcloud auth login, o a través del uso de Cloud Shell, que accede de forma automática a la CLI de gcloud. Para comprobar la cuenta activa actual, ejecuta gcloud auth list.

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

Nota: En el siguiente comando, se supone que accediste a la CLI de gcloud con tu cuenta de usuario a través de la ejecución de gcloud init o gcloud auth login . Para comprobar la cuenta activa actual, ejecuta gcloud auth list.

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 y los TRAININGPIPELINE_ID.

Respuesta

{
  "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",
}

Supervisa el entrenamiento

Para ver los registros de entrenamiento, haz lo siguiente:

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

   Ir a la página de entrenamiento

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

3. Haz clic en Ver registros.

También puedes usar una shell interactiva para inspeccionar los contenedores de entrenamiento mientras se ejecuta la canalización de entrenamiento.

Observa tu modelo entrenado

Cuando se completa la canalización de entrenamiento personalizada, puedes encontrar el modelo entrenado en la consola de Google Cloud, en la página Modelos de la sección Vertex AI.

Ir a la página Modelos

¿Qué sigue?

• Obtén más información sobre cómo identificar los cuellos de botella de rendimiento de entrenamiento a fin de entrenar modelos más rápido y de manera más económica con Cloud Profiler.
• Implementa tu modelo en un extremo.
• Crea un trabajo de ajuste de hiperparámetros.
• Obtén más información para programar trabajos de entrenamiento personalizados según la disponibilidad de recursos.