Esta página se ha traducido con Cloud Translation API.

Crear una tarea de ajuste de hiperparámetros

Los hiperparámetros son variables que rigen el proceso de entrenamiento de un modelo, como el tamaño del lote o el número de capas ocultas de una red neuronal profunda. El ajuste de hiperparámetros busca la mejor combinación de valores de hiperparámetros optimizando los valores de las métricas en una serie de pruebas. Las métricas son resúmenes escalares que se añaden al entrenador, como la precisión del modelo.

Consulta más información sobre el ajuste de hiperparámetros en Vertex AI. Para ver un ejemplo paso a paso, consulta el codelab de Vertex AI: ajuste de hiperparámetros.

En esta página se explica cómo hacer lo siguiente:

Prepara tu aplicación de entrenamiento para el ajuste de hiperparámetros actualizándola para que acepte hiperparámetros como argumentos de línea de comandos y envíe valores de métricas a Vertex AI.
Crea tu tarea de entrenamiento de hiperparámetros. Para obtener más información sobre las opciones de configuración, consulta Información sobre la configuración del ajuste de hiperparámetros.

Prepara tu solicitud de formación

En una tarea de ajuste de hiperparámetros, Vertex AI crea pruebas de tu tarea de entrenamiento con diferentes conjuntos de hiperparámetros y evalúa la eficacia de una prueba mediante las métricas que hayas especificado. Vertex AI transfiere los valores de los hiperparámetros a tu aplicación de entrenamiento como argumentos de línea de comandos. Para que Vertex AI evalúe la eficacia de una prueba, tu aplicación de entrenamiento debe enviar las métricas a Vertex AI.

En las siguientes secciones se describe lo siguiente:

Cómo pasa Vertex AI los hiperparámetros a tu aplicación de entrenamiento.
Opciones para transferir métricas de tu aplicación de entrenamiento a Vertex AI.

Para obtener más información sobre los requisitos de las aplicaciones de entrenamiento personalizadas que se ejecutan en Vertex AI, consulta Requisitos del código de entrenamiento.

Gestionar los argumentos de la línea de comandos de los hiperparámetros que quieras ajustar

Vertex AI define argumentos de línea de comandos cuando llama a tu aplicación de entrenamiento. Usa los argumentos de línea de comandos en tu código:

Define un nombre para cada argumento de hiperparámetro y analízalo con el analizador de argumentos que prefieras, como argparse. Usa los mismos nombres de argumentos al configurar el trabajo de entrenamiento de hiperparámetros.

Por ejemplo, si tu aplicación de entrenamiento es un módulo de Python llamado my_trainer y estás ajustando un hiperparámetro llamado learning_rate, Vertex AI inicia cada prueba con un comando como el siguiente:
```
python3 -m my_trainer --learning_rate learning-rate-in-this-trial
```
Vertex AI determina el learning-rate-in-this-trial y lo transfiere mediante el argumento learning_rate.
Asigna los valores de los argumentos de línea de comandos a los hiperparámetros de tu código de entrenamiento.

Más información sobre los requisitos para analizar argumentos de línea de comandos

Enviar métricas a Vertex AI

Para enviar tus métricas a Vertex AI, usa el cloudml-hypertunepaquete de Python. Esta biblioteca proporciona funciones auxiliares para registrar métricas en Vertex AI.

Más información sobre cómo generar informes de métricas de hiperparámetros

Crear una tarea de ajuste de hiperparámetros

En función de la herramienta que quieras usar para crear un HyperparameterTuningJob, selecciona una de las siguientes pestañas:

Consola

En la consola de Google Cloud , no puedes crear un recurso de HyperparameterTuningJob directamente. Sin embargo, puedes crear un recurso TrainingPipeline que cree un HyperparameterTuningJob.

En las siguientes instrucciones se describe cómo crear un TrainingPipeline que cree un HyperparameterTuningJob y no haga nada más. Si quieres usar otras funciones de TrainingPipeline, como entrenar con un conjunto de datos gestionado, consulta Crear pipelines de entrenamiento.

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

Ir a Flujos de procesamiento de entrenamiento
Haz clic en Crear para abrir el panel Entrenar modelo nuevo.
En el paso Método de entrenamiento, especifica los siguientes ajustes:
1. En la lista desplegable Conjunto de datos, selecciona Sin conjunto de datos gestionado.
2. Selecciona Entrenamiento personalizado (avanzado).
Haz clic en Continuar.
En el paso Detalles del modelo, elija Entrenar nuevo modelo o Entrenar nueva versión. Si seleccionas Entrenar nuevo modelo, introduce el nombre que quieras MODEL_NAME para tu modelo. Haz clic en Continuar.
En el paso Contenedor de entrenamiento, especifique los siguientes ajustes:
1. Selecciona si quieres usar un contenedor prediseñado o un contenedor personalizado para el entrenamiento.
2. En función de lo que elijas, haz una de las siguientes acciones:
  - Si quieres usar un contenedor prediseñado para el entrenamiento, proporciona a Vertex AI la información que necesita para usar el paquete de entrenamiento que has subido a Cloud Storage:
    1. Usa las listas desplegables Framework del modelo y Versión del framework del modelo para especificar el contenedor prediseñado que quieras usar.
    2. En el campo Ubicación del paquete, especifica el URI de Cloud Storage de la aplicación de entrenamiento de Python que has creado y subido. Este archivo suele terminar con .tar.gz.
    3. En el campo Módulo de Python, introduce el nombre del módulo del punto de entrada de tu aplicación de entrenamiento.
  - Si quieres usar un contenedor personalizado para el entrenamiento, en el campo Imagen de contenedor, especifica el URI de Artifact Registry o Docker Hub de la imagen de contenedor.
3. En el campo Directorio de salida del modelo, puedes especificar el URI de Cloud Storage de un directorio de un segmento al que tengas acceso. No es necesario que el directorio ya exista.
  
  Este valor se transfiere a Vertex AI en el campo baseOutputDirectory de la API, que define varias variables de entorno a las que puede acceder tu aplicación de entrenamiento cuando se ejecuta.
4. Opcional: En el campo Arguments (Argumentos), puedes especificar los argumentos que Vertex AI debe usar cuando empiece a ejecutar tu código de entrenamiento. La longitud máxima de todos los argumentos combinados es de 100.000 caracteres. El comportamiento de estos argumentos varía en función del tipo de contenedor que utilices:
  - Si usas un contenedor precompilado, Vertex AI pasará los argumentos como marcas de línea de comandos a tu módulo de Python.
  - Si usas un contenedor personalizado, Vertex AI sustituye la instrucción CMD de tu contenedor por losargumentos.
Haz clic en Continuar.
En el paso Ajuste de hiperparámetros, marca la casilla Habilitar ajuste de hiperparámetros y especifica los siguientes ajustes:
1. En la sección Nuevo hiperparámetro, especifica el Nombre del parámetro y el Tipo del hiperparámetro que quieras ajustar. En función del tipo que especifiques, configura los ajustes de hiperparámetros adicionales que aparezcan.
  
  Consulta más información sobre los tipos de hiperparámetros y sus configuraciones.
2. Si quieres ajustar más de un hiperparámetro, haz clic en Añadir nuevo parámetro y repite el paso anterior en la nueva sección que aparece.
  
  Repite este proceso con cada hiperparámetro que quieras optimizar.
3. En el campo Métrica que optimizar y en la lista desplegable Objetivo, especifique el nombre y el objetivo de la métrica que quiera optimizar.
4. En el campo Número máximo de pruebas, especifica el número máximo de pruebas que quieres que ejecute Vertex AI en tu tarea de ajuste de hiperparámetros.
5. En el campo Número máximo de pruebas paralelas, especifica el número máximo de pruebas que quieres que Vertex AI ejecute al mismo tiempo.
6. En la lista desplegable Algoritmo de búsqueda, especifica un algoritmo de búsqueda que Vertex AI pueda usar.
7. Ignora el interruptor Habilitar la detención anticipada, ya que no tiene ningún efecto.
Haz clic en Continuar.
En el paso Computación y precios, especifica los siguientes ajustes:
1. En la lista desplegable Región, selecciona una región que admita el entrenamiento personalizado.
2. En la sección Grupo de trabajadores 0, especifica los recursos de computación que quieres usar para el entrenamiento.
  
  Si especificas aceleradores, asegúrate de que el tipo de acelerador que elijas esté disponible en la región seleccionada.
  
  Si quieres llevar a cabo un entrenamiento distribuido, haz clic en Añadir más grupos de trabajo y especifica un conjunto adicional de recursos de computación para cada grupo de trabajo adicional que quieras.
Haz clic en Continuar.
En el paso Contenedor de predicción, selecciona Sin contenedor de predicción.
Haz clic en Iniciar entrenamiento para iniciar la canalización de entrenamiento personalizado.

gcloud

En los siguientes pasos se muestra cómo usar la CLI de Google Cloud para crear un HyperparameterTuningJob con una configuración relativamente mínima. Para obtener información sobre todas las opciones de configuración que puedes usar para esta tarea, consulta la documentación de referencia del comando gcloud ai hp-tuning-jobs create y del recurso de la API HyperparameterTuningJob.

Crea un archivo YAML llamado config.yaml con algunos campos de la API que quieras especificar para tu nuevo HyerparameterTuningJob:

config.yaml
```
studySpec:
  metrics:
  - metricId: METRIC_ID
    goal: METRIC_GOAL
  parameters:
  - parameterId: HYPERPARAMETER_ID
    doubleValueSpec:
      minValue: DOUBLE_MIN_VALUE
      maxValue: DOUBLE_MAX_VALUE
trialJobSpec:
  workerPoolSpecs:
    - machineSpec:
        machineType: MACHINE_TYPE
      replicaCount: 1
      containerSpec:
        imageUri: CUSTOM_CONTAINER_IMAGE_URI
```
Haz los cambios siguientes:
- METRIC_ID: el nombre de una métrica de hiperparámetro que se va a optimizar. Tu código de entrenamiento debe informar de esta métrica cuando se ejecute.
- METRIC_GOAL: el objetivo de la métrica de hiperparámetros, que puede ser MAXIMIZE o MINIMIZE.
- HYPERPARAMETER_ID: el nombre de un hiperparámetro que se va a ajustar. Tu código de entrenamiento debe analizar una marca de línea de comandos con este nombre. En este ejemplo, el hiperparámetro debe tomar valores de coma flotante. Consulta información sobre otros tipos de datos de hiperparámetros.
- DOUBLE_MIN_VALUE: el valor mínimo (un número) que quieres que Vertex AI pruebe para este hiperparámetro.
- DOUBLE_MAX_VALUE: el valor máximo (un número) que quieres que Vertex AI pruebe para este hiperparámetro.
- MACHINE_TYPE: el tipo de VM que se va a usar para el entrenamiento.
- CUSTOM_CONTAINER_IMAGE_URI: el URI de una imagen de contenedor Docker con tu código de entrenamiento. Consulta cómo crear una imagen de contenedor personalizada.
  
  En este ejemplo, debes usar un contenedor personalizado. Los recursos de HyperparameterTuningJob también admiten código de entrenamiento en una distribución de origen de Python en lugar de un contenedor personalizado.
En el mismo directorio que el archivo config.yaml, ejecuta el siguiente comando de shell:
```
gcloud ai hp-tuning-jobs create \
    --region=LOCATION \
    --display-name=DISPLAY_NAME \
    --max-trial-count=MAX_TRIAL_COUNT \
    --parallel-trial-count=PARALLEL_TRIAL_COUNT \
    --config=config.yaml
```
Haz los cambios siguientes:
- LOCATION: la región en la que quieres crear el HyperparameterTuningJob. Usa una región que admita el entrenamiento personalizado.
- DISPLAY_NAME: un nombre visible memorable que elijas para el HyperparameterTuningJob. Consulta el recurso REST.
- MAX_TRIAL_COUNT: el número máximo de pruebas que se pueden ejecutar.
- PARALLEL_TRIAL_COUNT: el número máximo de pruebas que se pueden ejecutar en paralelo.

REST

Usa el siguiente fragmento de código para crear una tarea de ajuste de hiperparámetros con el método create del recurso hyperparameterTuningJob.

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

LOCATION: la región en la que quieres crear el HyperparameterTuningJob. Usa una región que admita el entrenamiento personalizado.
PROJECT: tu ID de proyecto.
DISPLAY_NAME: un nombre visible memorable que elijas para el HyperparameterTuningJob. Consulta el recurso REST.
Especifique las métricas:
- METRIC_ID: el nombre de una métrica de hiperparámetro que se va a optimizar. Tu código de entrenamiento debe informar de esta métrica cuando se ejecute.
- METRIC_GOAL: el objetivo de la métrica de hiperparámetros, que puede ser MAXIMIZE o MINIMIZE.
Especifica los hiperparámetros:
- HYPERPARAMETER_ID: el nombre de un hiperparámetro que se va a ajustar. Tu código de entrenamiento debe analizar una marca de línea de comandos con este nombre.
- PARAMETER_SCALE: (opcional). Cómo se debe escalar el parámetro. No se define ningún valor para los parámetros CATEGORICAL. Puede ser UNIT_LINEAR_SCALE, UNIT_LOG_SCALE, UNIT_REVERSE_LOG_SCALE o SCALE_TYPE_UNSPECIFIED.
- Si el tipo de este hiperparámetro es DOUBLE, especifique los valores mínimo (DOUBLE_MIN_VALUE) y máximo (DOUBLE_MAX_VALUE) de este hiperparámetro.
- Si el tipo de este hiperparámetro es INTEGER, especifica los valores mínimo (INTEGER_MIN_VALUE) y máximo (INTEGER_MAX_VALUE) de este hiperparámetro.
- Si el tipo de este hiperparámetro es CATEGORICAL, especifica los valores aceptables (CATEGORICAL_VALUES) como un array de cadenas.
- Si el tipo de este hiperparámetro es DISCRETE, especifica los valores aceptables (DISCRETE_VALUES) como un array de números.
- Especifica hiperparámetros condicionales. Los hiperparámetros condicionales se añaden a una prueba cuando el valor del hiperparámetro principal coincide con la condición que especifiques. Consulta más información sobre los hiperparámetros condicionales.
  - CONDITIONAL_PARAMETER: el ParameterSpec del parámetro condicional. Esta especificación incluye el nombre, la escala y el intervalo de valores del parámetro, así como los parámetros condicionales que dependen de este hiperparámetro.
  - Si el tipo del hiperparámetro principal es INTEGER, especifica una lista de números enteros como INTEGERS_TO_MATCH. Si el valor del hiperparámetro principal coincide con uno de los valores especificados, este parámetro condicional se añade a la prueba.
  - Si el tipo del hiperparámetro principal es CATEGORICAL, especifica una lista de categorías como CATEGORIES_TO_MATCH. Si el valor del hiperparámetro principal coincide con uno de los valores especificados, este parámetro condicional se añade a la prueba.
  - Si el tipo del hiperparámetro principal es DISCRETE, especifica una lista de números enteros como DISCRETE_VALUES_TO_MATCH. Si el valor del hiperparámetro principal coincide con uno de los valores especificados, este parámetro condicional se añade a la prueba.
ALGORITHM: (opcional). Algoritmo de búsqueda que se va a usar en esta tarea de ajuste de hiperparámetros. Puede ser ALGORITHM_UNSPECIFIED, GRID_SEARCH o RANDOM_SEARCH.
MAX_TRIAL_COUNT: el número máximo de pruebas que se pueden ejecutar.
PARALLEL_TRIAL_COUNT: el número máximo de pruebas que se pueden ejecutar en paralelo.
MAX_FAILED_TRIAL_COUNT: número de tareas que pueden fallar antes de que falle la tarea de ajuste de hiperparámetros.
Define el trabajo de entrenamiento personalizado de prueba:
- MACHINE_TYPE: el tipo de VM que se va a usar para el entrenamiento.
- ACCELERATOR_TYPE: (opcional). Tipo de acelerador que se va a asociar a cada prueba.
- ACCELERATOR_COUNT: (opcional). Número de aceleradores que se van a asociar a cada prueba.
- REPLICA_COUNT: número de réplicas de trabajadores que se deben usar en cada prueba.
- Si tu aplicación de entrenamiento se ejecuta en un contenedor personalizado, especifica lo siguiente:
  - CUSTOM_CONTAINER_IMAGE_URI: el URI de una imagen de contenedor Docker con tu código de entrenamiento. Consulta cómo crear una imagen de contenedor personalizada.
  - CUSTOM_CONTAINER_COMMAND: (opcional). El comando que se invoca cuando se inicia el contenedor. Este comando anula el punto de entrada predeterminado del contenedor.
  - CUSTOM_CONTAINER_ARGS: (opcional). Los argumentos que se deben transferir al iniciar el contenedor.
- Si tu aplicación de entrenamiento es un paquete de Python que se ejecuta en un contenedor prediseñado, especifica lo siguiente:
  - PYTHON_PACKAGE_EXECUTOR_IMAGE_URI: el URI de la imagen del contenedor que ejecuta el paquete de Python proporcionado. Consulta más información sobre los contenedores prediseñados para el entrenamiento.
  - PYTHON_PACKAGE_URIS: la ubicación en Cloud Storage de los archivos del paquete de Python, que son el programa de entrenamiento y sus paquetes dependientes. El número máximo de URIs de paquetes es 100.
  - PYTHON_MODULE: el nombre del módulo de Python que se ejecutará después de instalar los paquetes.
  - PYTHON_PACKAGE_ARGS: (opcional). Argumentos de línea de comandos que se van a transferir al módulo de Python.
- SERVICE_ACCOUNT: (opcional). La cuenta de servicio que usará Vertex AI para ejecutar tu código. Más información sobre cómo adjuntar una cuenta de servicio personalizada
- TIMEOUT: (opcional). El tiempo máximo de ejecución de cada prueba.
Especifica los campos LABEL_NAME y LABEL_VALUE de las etiquetas que quieras aplicar a esta tarea de ajuste de hiperparámetros.

Método HTTP y URL:

POST https://LOCATION-aiplatform.googleapis.com/v1/projects/PROJECT/locations/LOCATION/hyperparameterTuningJobs

Cuerpo JSON de la solicitud:

{
  "displayName": DISPLAY_NAME,
  "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.

        "conditionalParameterSpecs": [
            "parameterSpec": {
              CONDITIONAL_PARAMETER
            }

            // Union field parent_value_condition can be only one of the following:
            "parentIntValues": {
                "values": [INTEGERS_TO_MATCH]
            }
            "parentCategoricalValues": {
                "values": [CATEGORIES_TO_MATCH]
            }
            "parentDiscreteValues": {
                "values": [DISCRETE_VALUES_TO_MATCH]
            }
            // End of list of possible types for union field parent_value_condition.
        ]
      }
    ],
    "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
      },
      "serviceAccount": SERVICE_ACCOUNT
  },
  "labels": {
    LABEL_NAME_1": LABEL_VALUE_1,
    LABEL_NAME_2": LABEL_VALUE_2
  }
}

Para enviar tu solicitud, despliega una de estas opciones:

curl (Linux, macOS o Cloud Shell)

Nota: En el siguiente comando se presupone que has iniciado sesión en la CLI de gcloud con tu cuenta de usuario ejecutando gcloud init o gcloud auth login , o bien usando Cloud Shell, que inicia sesión automáticamente en la CLI de gcloud . Para comprobar qué cuenta está activa, 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-aiplatform.googleapis.com/v1/projects/PROJECT/locations/LOCATION/hyperparameterTuningJobs"

PowerShell (Windows)

Nota: El siguiente comando presupone que has iniciado sesión en la CLI de gcloud con tu cuenta de usuario ejecutando gcloud init o gcloud auth login . Para comprobar qué cuenta está activa, 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-aiplatform.googleapis.com/v1/projects/PROJECT/locations/LOCATION/hyperparameterTuningJobs" | Select-Object -Expand Content

Deberías recibir una respuesta JSON similar a la siguiente:

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

Java

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

Para autenticarte en Vertex AI, configura las credenciales predeterminadas de la aplicación. Para obtener más información, consulta el artículo Configurar la autenticación en un entorno de desarrollo local.

import com.google.cloud.aiplatform.v1.AcceleratorType;
import com.google.cloud.aiplatform.v1.CustomJobSpec;
import com.google.cloud.aiplatform.v1.HyperparameterTuningJob;
import com.google.cloud.aiplatform.v1.JobServiceClient;
import com.google.cloud.aiplatform.v1.JobServiceSettings;
import com.google.cloud.aiplatform.v1.LocationName;
import com.google.cloud.aiplatform.v1.MachineSpec;
import com.google.cloud.aiplatform.v1.PythonPackageSpec;
import com.google.cloud.aiplatform.v1.StudySpec;
import com.google.cloud.aiplatform.v1.StudySpec.MetricSpec;
import com.google.cloud.aiplatform.v1.StudySpec.MetricSpec.GoalType;
import com.google.cloud.aiplatform.v1.StudySpec.ParameterSpec;
import com.google.cloud.aiplatform.v1.StudySpec.ParameterSpec.ConditionalParameterSpec;
import com.google.cloud.aiplatform.v1.StudySpec.ParameterSpec.ConditionalParameterSpec.DiscreteValueCondition;
import com.google.cloud.aiplatform.v1.StudySpec.ParameterSpec.DiscreteValueSpec;
import com.google.cloud.aiplatform.v1.StudySpec.ParameterSpec.DoubleValueSpec;
import com.google.cloud.aiplatform.v1.StudySpec.ParameterSpec.ScaleType;
import com.google.cloud.aiplatform.v1.WorkerPoolSpec;
import java.io.IOException;
import java.util.Arrays;

public class CreateHyperparameterTuningJobPythonPackageSample {

  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 executorImageUri = "EXECUTOR_IMAGE_URI";
    String packageUri = "PACKAGE_URI";
    String pythonModule = "PYTHON_MODULE";
    createHyperparameterTuningJobPythonPackageSample(
        project, displayName, executorImageUri, packageUri, pythonModule);
  }

  static void createHyperparameterTuningJobPythonPackageSample(
      String project,
      String displayName,
      String executorImageUri,
      String packageUri,
      String pythonModule)
      throws IOException {
    JobServiceSettings settings =
        JobServiceSettings.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 (JobServiceClient client = JobServiceClient.create(settings)) {
      // study spec
      MetricSpec metric =
          MetricSpec.newBuilder().setMetricId("val_rmse").setGoal(GoalType.MINIMIZE).build();

      // decay
      DoubleValueSpec doubleValueSpec =
          DoubleValueSpec.newBuilder().setMinValue(1e-07).setMaxValue(1).build();
      ParameterSpec parameterDecaySpec =
          ParameterSpec.newBuilder()
              .setParameterId("decay")
              .setDoubleValueSpec(doubleValueSpec)
              .setScaleType(ScaleType.UNIT_LINEAR_SCALE)
              .build();
      Double[] decayValues = {32.0, 64.0};
      DiscreteValueCondition discreteValueDecay =
          DiscreteValueCondition.newBuilder().addAllValues(Arrays.asList(decayValues)).build();
      ConditionalParameterSpec conditionalParameterDecay =
          ConditionalParameterSpec.newBuilder()
              .setParameterSpec(parameterDecaySpec)
              .setParentDiscreteValues(discreteValueDecay)
              .build();

      // learning rate
      ParameterSpec parameterLearningSpec =
          ParameterSpec.newBuilder()
              .setParameterId("learning_rate")
              .setDoubleValueSpec(doubleValueSpec) // Use the same min/max as for decay
              .setScaleType(ScaleType.UNIT_LINEAR_SCALE)
              .build();

      Double[] learningRateValues = {4.0, 8.0, 16.0};
      DiscreteValueCondition discreteValueLearning =
          DiscreteValueCondition.newBuilder()
              .addAllValues(Arrays.asList(learningRateValues))
              .build();
      ConditionalParameterSpec conditionalParameterLearning =
          ConditionalParameterSpec.newBuilder()
              .setParameterSpec(parameterLearningSpec)
              .setParentDiscreteValues(discreteValueLearning)
              .build();

      // batch size
      Double[] batchSizeValues = {4.0, 8.0, 16.0, 32.0, 64.0, 128.0};

      DiscreteValueSpec discreteValueSpec =
          DiscreteValueSpec.newBuilder().addAllValues(Arrays.asList(batchSizeValues)).build();
      ParameterSpec parameter =
          ParameterSpec.newBuilder()
              .setParameterId("batch_size")
              .setDiscreteValueSpec(discreteValueSpec)
              .setScaleType(ScaleType.UNIT_LINEAR_SCALE)
              .addConditionalParameterSpecs(conditionalParameterDecay)
              .addConditionalParameterSpecs(conditionalParameterLearning)
              .build();

      // trial_job_spec
      MachineSpec machineSpec =
          MachineSpec.newBuilder()
              .setMachineType("n1-standard-4")
              .setAcceleratorType(AcceleratorType.NVIDIA_TESLA_T4)
              .setAcceleratorCount(1)
              .build();

      PythonPackageSpec pythonPackageSpec =
          PythonPackageSpec.newBuilder()
              .setExecutorImageUri(executorImageUri)
              .addPackageUris(packageUri)
              .setPythonModule(pythonModule)
              .build();

      WorkerPoolSpec workerPoolSpec =
          WorkerPoolSpec.newBuilder()
              .setMachineSpec(machineSpec)
              .setReplicaCount(1)
              .setPythonPackageSpec(pythonPackageSpec)
              .build();

      StudySpec studySpec =
          StudySpec.newBuilder()
              .addMetrics(metric)
              .addParameters(parameter)
              .setAlgorithm(StudySpec.Algorithm.RANDOM_SEARCH)
              .build();
      CustomJobSpec trialJobSpec =
          CustomJobSpec.newBuilder().addWorkerPoolSpecs(workerPoolSpec).build();
      // hyperparameter_tuning_job
      HyperparameterTuningJob hyperparameterTuningJob =
          HyperparameterTuningJob.newBuilder()
              .setDisplayName(displayName)
              .setMaxTrialCount(4)
              .setParallelTrialCount(2)
              .setStudySpec(studySpec)
              .setTrialJobSpec(trialJobSpec)
              .build();
      LocationName parent = LocationName.of(project, location);
      HyperparameterTuningJob response =
          client.createHyperparameterTuningJob(parent, hyperparameterTuningJob);
      System.out.format("response: %s\n", response);
      System.out.format("Name: %s\n", response.getName());
    }
  }
}

Python

Para saber cómo instalar o actualizar el SDK de Vertex AI para Python, consulta Instalar el SDK de Vertex AI para Python. Para obtener más información, consulta la documentación de referencia de la API Python.

from google.cloud import aiplatform

from google.cloud.aiplatform import hyperparameter_tuning as hpt


def create_hyperparameter_tuning_job_sample(
    project: str,
    location: str,
    staging_bucket: str,
    display_name: str,
    container_uri: str,
):
    aiplatform.init(project=project, location=location, staging_bucket=staging_bucket)

    worker_pool_specs = [
        {
            "machine_spec": {
                "machine_type": "n1-standard-4",
                "accelerator_type": "NVIDIA_TESLA_K80",
                "accelerator_count": 1,
            },
            "replica_count": 1,
            "container_spec": {
                "image_uri": container_uri,
                "command": [],
                "args": [],
            },
        }
    ]

    custom_job = aiplatform.CustomJob(
        display_name='custom_job',
        worker_pool_specs=worker_pool_specs,
    )

    hpt_job = aiplatform.HyperparameterTuningJob(
        display_name=display_name,
        custom_job=custom_job,
        metric_spec={
            'loss': 'minimize',
        },
        parameter_spec={
            'lr': hpt.DoubleParameterSpec(min=0.001, max=0.1, scale='log'),
            'units': hpt.IntegerParameterSpec(min=4, max=128, scale='linear'),
            'activation': hpt.CategoricalParameterSpec(values=['relu', 'selu']),
            'batch_size': hpt.DiscreteParameterSpec(values=[128, 256], scale='linear')
        },
        max_trial_count=128,
        parallel_trial_count=8,
        labels={'my_key': 'my_value'},
    )

    hpt_job.run()

    print(hpt_job.resource_name)
    return hpt_job

Configuración de la tarea de entrenamiento de hiperparámetros

Las tareas de ajuste de hiperparámetros buscan la mejor combinación de hiperparámetros para optimizar tus métricas. Las tareas de ajuste de hiperparámetros lo hacen ejecutando varias pruebas de tu aplicación de entrenamiento con diferentes conjuntos de hiperparámetros.

Cuando configures una tarea de ajuste de hiperparámetros, debes especificar los siguientes detalles:

Los hiperparámetros que quieras optimizar y las métricas que quieras usar para evaluar las pruebas.

Más información sobre cómo seleccionar hiperparámetros y métricas
Detalles sobre el número de pruebas que se deben ejecutar como parte de este trabajo de ajuste, como los siguientes:
Detalles sobre el trabajo de entrenamiento personalizado que se ejecuta en cada prueba, como los siguientes:
- El tipo de máquina en el que se ejecutan las tareas de prueba y los aceleradores que usa la tarea.
  
  Nota: Vertex AI no admite trabajos de ajuste de hiperparámetros que requieran TPUs.
- Los detalles del trabajo de contenedor personalizado o paquete de Python.
  
  Más información sobre los requisitos de los códigos de entrenamiento

Limitar el número de pruebas

Decide cuántas pruebas quieres permitir que ejecute el servicio y define el valor de maxTrialCount en el objeto HyperparameterTuningJob.

Hay dos intereses contrapuestos que debes tener en cuenta a la hora de decidir cuántas pruebas permitir:

tiempo (y, por lo tanto, coste)
precisión

Cuantas más pruebas hagas, mejores serán los resultados, pero no siempre es así. Normalmente, hay un punto de rendimientos decrecientes a partir del cual las pruebas adicionales tienen poco o ningún efecto en la precisión. Antes de iniciar un trabajo con un gran número de pruebas, puede que quieras empezar con un número reducido de pruebas para evaluar el efecto que tienen los hiperparámetros elegidos en la precisión de tu modelo.

Para sacar el máximo partido al ajuste de hiperparámetros, no debes definir un valor máximo inferior a diez veces el número de hiperparámetros que utilices.

Pruebas paralelas

Puedes especificar cuántas pruebas se pueden ejecutar en paralelo configurando parallelTrialCount en HyperparameterTuningJob.

Ejecutar pruebas paralelas tiene la ventaja de reducir el tiempo que tarda la tarea de entrenamiento (tiempo real, el tiempo de procesamiento total necesario no suele cambiar). Sin embargo, si se ejecutan en paralelo, puede que se reduzca la eficacia general del trabajo de ajuste. Esto se debe a que el ajuste de hiperparámetros usa los resultados de pruebas anteriores para determinar los valores que se deben asignar a los hiperparámetros de las pruebas posteriores. Cuando se ejecutan en paralelo, algunas pruebas empiezan sin beneficiarse de los resultados de las pruebas que aún se están ejecutando.

Si usas pruebas paralelas, el servicio de ajuste de hiperparámetros aprovisiona varios clústeres de procesamiento de entrenamiento (o varias máquinas individuales en el caso de un entrenador de un solo proceso). La especificación del grupo de trabajo que definas para tu tarea se usará en cada clúster de entrenamiento.

Gestionar pruebas fallidas

Si las pruebas de ajuste de hiperparámetros finalizan con errores, puede que quieras terminar la tarea de entrenamiento antes de tiempo. Define el campo maxFailedTrialCount en HyperparameterTuningJob con el número de pruebas fallidas que quieras permitir. Cuando se produce un número de fallos igual a este, Vertex AI finaliza la tarea de entrenamiento. El valor de maxFailedTrialCount debe ser inferior o igual a maxTrialCount.

Si no defines maxFailedTrialCount o lo defines como 0, Vertex AI usa las siguientes reglas para gestionar las pruebas fallidas:

Si la primera prueba de tu tarea falla, Vertex AI la finalizará inmediatamente. Si se produce un error en la primera prueba, significa que hay un problema en el código de entrenamiento, por lo que es probable que también se produzcan errores en las siguientes pruebas. Si finalizas el trabajo, podrás diagnosticar el problema sin tener que esperar más pruebas y sin incurrir en costes mayores.
Si la primera prueba se realiza correctamente, Vertex AI puede finalizar el trabajo después de que se produzcan errores durante las pruebas posteriores en función de uno de los siguientes criterios:
- El número de pruebas fallidas ha aumentado demasiado.
- La proporción de pruebas fallidas con respecto a las pruebas correctas ha aumentado demasiado.

Estas reglas están sujetas a cambios. Para asegurar un comportamiento específico, define el campo maxFailedTrialCount.

Gestionar tareas de ajuste de hiperparámetros

En las siguientes secciones se describe cómo gestionar los trabajos de ajuste de hiperparámetros.

Obtener información sobre una tarea de ajuste de hiperparámetros

En los siguientes ejemplos de código se muestra cómo obtener un trabajo de ajuste de hiperparámetros.

gcloud

Usa el comando gcloud ai hp-tuning-jobs describe:

gcloud ai hp-tuning-jobs describe ID_OR_NAME \
    --region=LOCATION

Haz los cambios siguientes:

ID_OR_NAME: el nombre o el ID numérico de la HyperparameterTuningJob. El ID es la última parte del nombre.

Es posible que hayas visto el ID o el nombre al crear la HyperparameterTuningJob. Si no sabes el ID o el nombre, puedes ejecutar el comando gcloud ai hp-tuning-jobs list y buscar el recurso adecuado.
LOCATION: la región en la que se creó HyperparameterTuningJob.

REST

Usa el siguiente código de ejemplo para obtener una tarea de ajuste de hiperparámetros con el método get del recurso hyperparameterTuningJob.

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

LOCATION: la región en la que se creó HyperparameterTuningJob.
NAME: el nombre de la tarea de ajuste de hiperparámetros. El nombre del trabajo utiliza el siguiente formato: projects/{project}/LOCATIONS/{LOCATION}/hyperparameterTuningJobs/{hyperparameterTuningJob}.

Método HTTP y URL:

GET https://LOCATION-aiplatform.googleapis.com/v1/NAME

Para enviar tu solicitud, despliega una de estas opciones:

curl (Linux, macOS o Cloud Shell)

Ejecuta el comando siguiente:

curl -X GET \
     -H "Authorization: Bearer $(gcloud auth print-access-token)" \
     "https://LOCATION-aiplatform.googleapis.com/v1/NAME"

PowerShell (Windows)

Ejecuta el comando siguiente:

$cred = gcloud auth print-access-token
$headers = @{ "Authorization" = "Bearer $cred" }

Invoke-WebRequest `
    -Method GET `
    -Headers $headers `
    -Uri "https://LOCATION-aiplatform.googleapis.com/v1/NAME" | Select-Object -Expand Content

Deberías recibir una respuesta JSON similar a la siguiente:

{
  "name": "projects/12345/LOCATIONs/us-central1/hyperparameterTuningJobs/6789",
  "displayName": "my-hyperparameter-tuning-job",
  "studySpec": {
    "metrics": [
      {
        "metricId": "my_metric",
        "goal": "MINIMIZE"
      }
    ],
    "parameters": [
      {
        "parameterId": "my_parameter",
        "doubleValueSpec": {
          "minValue": 1e-05,
          "maxValue": 1
        }
      }
    ]
  },
  "maxTrialCount": 3,
  "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"
        }
      }
    ]
  },
  "trials": [
    {
      "id": "2",
      "state": "SUCCEEDED",
      "parameters": [
        {
          "parameterId": "my_parameter",
          "value": 0.71426874725564571
        }
      ],
      "finalMeasurement": {
        "stepCount": "2",
        "metrics": [
          {
            "metricId": "my_metric",
            "value": 0.30007445812225342
          }
        ]
      },
      "startTime": "2020-09-09T23:39:15.549112551Z",
      "endTime": "2020-09-09T23:47:08Z"
    },
    {
      "id": "3",
      "state": "SUCCEEDED",
      "parameters": [
        {
          "parameterId": "my_parameter",
          "value": 0.3078893356622992
        }
      ],
      "finalMeasurement": {
        "stepCount": "2",
        "metrics": [
          {
            "metricId": "my_metric",
            "value": 0.30000102519989014
          }
        ]
      },
      "startTime": "2020-09-09T23:49:22.451699360Z",
      "endTime": "2020-09-09T23:57:15Z"
    },
    {
      "id": "1",
      "state": "SUCCEEDED",
      "parameters": [
        {
          "parameterId": "my_parameter",
          "value": 0.500005
        }
      ],
      "finalMeasurement": {
        "stepCount": "2",
        "metrics": [
          {
            "metricId": "my_metric",
            "value": 0.30005377531051636
          }
        ]
      },
      "startTime": "2020-09-09T23:23:12.283374629Z",
      "endTime": "2020-09-09T23:36:56Z"
    }
  ],
  "state": "JOB_STATE_SUCCEEDED",
  "createTime": "2020-09-09T23:22:31.777386Z",
  "startTime": "2020-09-09T23:22:34Z",
  "endTime": "2020-09-10T01:31:24.271307Z",
  "updateTime": "2020-09-10T01:31:24.271307Z"
}

Java

import com.google.cloud.aiplatform.v1.HyperparameterTuningJob;
import com.google.cloud.aiplatform.v1.HyperparameterTuningJobName;
import com.google.cloud.aiplatform.v1.JobServiceClient;
import com.google.cloud.aiplatform.v1.JobServiceSettings;
import java.io.IOException;

public class GetHyperparameterTuningJobSample {

  public static void main(String[] args) throws IOException {
    // TODO(developer): Replace these variables before running the sample.
    String project = "PROJECT";
    String hyperparameterTuningJobId = "HYPERPARAMETER_TUNING_JOB_ID";
    getHyperparameterTuningJobSample(project, hyperparameterTuningJobId);
  }

  static void getHyperparameterTuningJobSample(String project, String hyperparameterTuningJobId)
      throws IOException {
    JobServiceSettings settings =
        JobServiceSettings.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 (JobServiceClient client = JobServiceClient.create(settings)) {
      HyperparameterTuningJobName name =
          HyperparameterTuningJobName.of(project, location, hyperparameterTuningJobId);
      HyperparameterTuningJob response = client.getHyperparameterTuningJob(name);
      System.out.format("response: %s\n", response);
    }
  }
}

Python

# Copyright 2022 Google LLC
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#     https://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.

from google.cloud import aiplatform


def get_hyperparameter_tuning_job_sample(
    project: str,
    hyperparameter_tuning_job_id: str,
    location: str = "us-central1",
):

    aiplatform.init(project=project, location=location)

    hpt_job = aiplatform.HyperparameterTuningJob.get(
        resource_name=hyperparameter_tuning_job_id,
    )

    return hpt_job

Cancelar una tarea de ajuste de hiperparámetros

En los siguientes ejemplos de código se muestra cómo cancelar un trabajo de ajuste de hiperparámetros.

gcloud

Usa el comando gcloud ai hp-tuning-jobs cancel:

gcloud ai hp-tuning-jobs cancel ID_OR_NAME \
    --region=LOCATION

Haz los cambios siguientes:

ID_OR_NAME: el nombre o el ID numérico de la HyperparameterTuningJob. El ID es la última parte del nombre.

Es posible que hayas visto el ID o el nombre al crear la HyperparameterTuningJob. Si no sabes el ID o el nombre, puedes ejecutar el comando gcloud ai hp-tuning-jobs list y buscar el recurso adecuado.
LOCATION: la región en la que se creó HyperparameterTuningJob.

REST

Usa el siguiente código de ejemplo para cancelar una tarea de ajuste de hiperparámetros con el método cancel del recurso hyperparameterTuningJob.

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

LOCATION: la región en la que se creó HyperparameterTuningJob.
NAME: el nombre de la tarea de ajuste de hiperparámetros. El nombre del trabajo utiliza el siguiente formato: projects/{project}/locations/{location}/hyperparameterTuningJobs/{hyperparameterTuningJob}.

Método HTTP y URL:

POST https://LOCATION-aiplatform.googleapis.com/v1/NAME:cancel

Para enviar tu solicitud, despliega una de estas opciones:

curl (Linux, macOS o Cloud Shell)

Ejecuta el comando siguiente:

curl -X POST \
     -H "Authorization: Bearer $(gcloud auth print-access-token)" \
     -H "Content-Type: application/json; charset=utf-8" \
     -d "" \
     "https://LOCATION-aiplatform.googleapis.com/v1/NAME:cancel"

PowerShell (Windows)

Ejecuta el comando siguiente:

$cred = gcloud auth print-access-token
$headers = @{ "Authorization" = "Bearer $cred" }

Invoke-WebRequest `
    -Method POST `
    -Headers $headers `
    -Uri "https://LOCATION-aiplatform.googleapis.com/v1/NAME:cancel" | Select-Object -Expand Content

Deberías recibir un código de estado que indique que la operación se ha realizado correctamente (2xx) y una respuesta vacía.

Python

from google.cloud import aiplatform


def cancel_hyperparameter_tuning_job_sample(
    project: str,
    hyperparameter_tuning_job_id: str,
    location: str = "us-central1",
):

    aiplatform.init(project=project, location=location)

    hpt_job = aiplatform.HyperparameterTuningJob.get(
        resource_name=hyperparameter_tuning_job_id,
    )

    hpt_job.cancel()

Eliminar una tarea de ajuste de hiperparámetros

En los siguientes ejemplos de código se muestra cómo eliminar un trabajo de ajuste de hiperparámetros con el SDK de Vertex AI para Python y la API REST.

REST

Usa el siguiente código de ejemplo para eliminar una tarea de ajuste de hiperparámetros con el método delete del recurso hyperparameterTuningJob.

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

LOCATION: tu región.
NAME: el nombre de la tarea de ajuste de hiperparámetros. El nombre del trabajo utiliza el siguiente formato: projects/{project}/LOCATIONs/{LOCATION}/hyperparameterTuningJobs/{hyperparameterTuningJob}.

Método HTTP y URL:

DELETE https://LOCATION-aiplatform.googleapis.com/v1/NAME

Para enviar tu solicitud, despliega una de estas opciones:

curl (Linux, macOS o Cloud Shell)

Ejecuta el comando siguiente:

curl -X DELETE \
     -H "Authorization: Bearer $(gcloud auth print-access-token)" \
     "https://LOCATION-aiplatform.googleapis.com/v1/NAME"

PowerShell (Windows)

Ejecuta el comando siguiente:

$cred = gcloud auth print-access-token
$headers = @{ "Authorization" = "Bearer $cred" }

Invoke-WebRequest `
    -Method DELETE `
    -Headers $headers `
    -Uri "https://LOCATION-aiplatform.googleapis.com/v1/NAME" | Select-Object -Expand Content

Deberías recibir un código de estado que indique que la operación se ha realizado correctamente (2xx) y una respuesta vacía.

Python

from google.cloud import aiplatform


def delete_hyperparameter_tuning_job_sample(
    project: str,
    hyperparameter_tuning_job_id: str,
    location: str = "us-central1",
):

    aiplatform.init(project=project, location=location)

    hpt_job = aiplatform.HyperparameterTuningJob.get(
        resource_name=hyperparameter_tuning_job_id,
    )

    hpt_job.delete()

Crear una tarea de ajuste de hiperparámetros

Prepara tu solicitud de formación

Gestionar los argumentos de la línea de comandos de los hiperparámetros que quieras ajustar

Enviar métricas a Vertex AI

Crear una tarea de ajuste de hiperparámetros

Consola

gcloud

`config.yaml`

REST

curl (Linux, macOS o Cloud Shell)

PowerShell (Windows)

Java

Python

Configuración de la tarea de entrenamiento de hiperparámetros

Limitar el número de pruebas

Pruebas paralelas

Gestionar pruebas fallidas

Gestionar tareas de ajuste de hiperparámetros

Obtener información sobre una tarea de ajuste de hiperparámetros

gcloud

REST

curl (Linux, macOS o Cloud Shell)

PowerShell (Windows)

Java

Python

Cancelar una tarea de ajuste de hiperparámetros

gcloud

REST

curl (Linux, macOS o Cloud Shell)

PowerShell (Windows)

Python

Eliminar una tarea de ajuste de hiperparámetros

REST

curl (Linux, macOS o Cloud Shell)

PowerShell (Windows)

Python

Siguientes pasos

Crear una tarea de ajuste de hiperparámetros Organízate con las colecciones Guarda y clasifica el contenido según tus preferencias.

Prepara tu solicitud de formación

Gestionar los argumentos de la línea de comandos de los hiperparámetros que quieras ajustar

Enviar métricas a Vertex AI

Crear una tarea de ajuste de hiperparámetros

Consola

gcloud

config.yaml

REST

curl (Linux, macOS o Cloud Shell)

PowerShell (Windows)

Java

Python

Configuración de la tarea de entrenamiento de hiperparámetros

Limitar el número de pruebas

Pruebas paralelas

Gestionar pruebas fallidas

Gestionar tareas de ajuste de hiperparámetros

Obtener información sobre una tarea de ajuste de hiperparámetros

gcloud

REST

curl (Linux, macOS o Cloud Shell)

PowerShell (Windows)

Java

Python

Cancelar una tarea de ajuste de hiperparámetros

gcloud

REST

curl (Linux, macOS o Cloud Shell)

PowerShell (Windows)

Python

Eliminar una tarea de ajuste de hiperparámetros

REST

curl (Linux, macOS o Cloud Shell)

PowerShell (Windows)

Python

Siguientes pasos

Crear una tarea de ajuste de hiperparámetros

`config.yaml`