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:

Crea el conjunto de datos.
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.
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:

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.
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:
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

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
Haz clic en Crear para abrir el panel Entrenar modelo nuevo.
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.
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.
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.
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.
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.
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.
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: El URI de una imagen de contenedor en Artifact Registry, Container 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 \
     "/proxy/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 "/proxy/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:

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.
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: El URI de una imagen de contenedor en Artifact�Registry, Container�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

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 \
     "/proxy/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 "/proxy/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:

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
Haz clic en el nombre de tu trabajo para ir a la p�gina del trabajo personalizado.
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.

Crear canalizaciones de entrenamiento

Antes de crear una canalizaci�n

Opciones de canalizaci�n de entrenamiento

Qu� incluye un CustomJob

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

Configura el entrenamiento distribuido

Carga de modelos y trabajos personalizados

Console

REST

curl

PowerShell

Respuesta

Java

Python

Contenedor previamente compilado

Paquete

Secuencia de comandos

Contenedor personalizado

Carga de modelos y trabajos de ajuste de hiperpar�metros

REST

curl

PowerShell

Respuesta

Supervisa el entrenamiento

Observa tu modelo entrenado

�Qu� sigue?

Qu� incluye un `CustomJob`