Crea un trabajo 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 la cantidad 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 métricas en una serie de pruebas. Las métricas son resúmenes escalares que agregas a tu entrenador, como la exactitud del modelo.

Obtén más información sobre el ajuste de hiperparámetros en Vertex AI. Para obtener un ejemplo paso a paso, consulta el codelab de ajuste de hiperparámetros de IA de Vertex.

En esta página, se muestra cómo realizar las siguientes acciones:

Prepara tu aplicación de entrenamiento para el ajuste de hiperparámetros mediante su actualización a aceptar hiperparámetros como argumentos de línea de comandos y, luego, informar los valores de métricas a AI Platform
Crea tu trabajo 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 aplicación de entrenamiento

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

En las siguientes secciones, se describe lo siguiente:

Cómo Vertex AI pasa hiperparámetros a tu aplicación de entrenamiento.
Opciones para pasar 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 personalizado que se ejecutan en Vertex AI, consulta los requisitos de código de entrenamiento.

Controla los argumentos de la línea de comandos de los hiperparámetros que deseas ajustar

Vertex AI establece argumentos de la 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, usa el analizador de argumentos que prefieras, como argparse. Usa los mismos nombres de argumentos cuando configures 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 ajustas 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 pasa con el argumento learning_rate.
Asigna los valores de los argumentos de la línea de comandos a los hiperparámetros en el código de entrenamiento.

Obtén más información sobre los requisitos para analizar los argumentos de la línea de comandos.

Informa tus métricas a Vertex AI

Para informar tus métricas a Vertex AI, usa el paquete de Python cloudml-hypertune. Esta biblioteca proporciona funciones auxiliares para informar las métricas a Vertex AI.

Obtén más información para informar métricas de hiperparámetros.

Crea un trabajo de ajuste de hiperparámetros

Según la herramienta que desees usar para crear un HyperparameterTuningJob, selecciona una de las siguientes pestañas:

Consola

En la consola de Google Cloud, no puedes crear un recurso 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 realice ninguna otra acción. Si deseas usar características de TrainingPipeline adicionales, como el entrenamiento con un conjunto de datos administrado, consulta Crea canalizaciones de entrenamiento.

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.

Nota: Puedes escribir model.new en un navegador para ir directamente a la página de creación del modelo.
En el paso Método de entrenamiento, especifica las siguientes opciones de configuración:
1. 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, puedes especificar 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.
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ámetro, selecciona la casilla de verificación Habilitar ajuste de hiperparámetro y especifica la siguiente configuración:
1. En la sección Nuevo hiperparámetro, especifica el Nombre del parámetro y el Tipo de un hiperparámetro que deseas ajustar. Según el tipo que especifiques, establece la configuración adicional de hiperparámetros que aparece.
  
  Obtén más información sobre los tipos de hiperparámetros y sus opciones configuración.
2. Si deseas ajustar más de un hiperparámetro, haz clic en Agregar nuevo parámetro y repite el paso anterior en la sección nueva que aparece.
  
  Repite esto para cada hiperparámetro que desees ajustar.
3. En el campo Métrica para optimizar y en la lista desplegable Objetivo, especifica el nombre y el objetivo de la métrica que deseas optimizar.
4. En el campo Cantidad máxima de pruebas, especifica la cantidad máxima de pruebas que deseas que Vertex AI ejecute para tu trabajo de ajuste de hiperparámetros.
5. En el campo Cantidad máxima de pruebas paralelas, especifica la cantidad máxima de pruebas que Vertex AI podrá ejecutar al mismo tiempo.
6. En la lista desplegable Algoritmo de búsqueda, especifica un algoritmo de búsqueda para que use Vertex AI.
7. Omite la opción Habilitar la interrupción anticipada, que no tiene efecto.
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, selecciona Sin contenedor de predicción.
Haz clic en Comenzar el entrenamiento para comenzar la canalización de entrenamiento personalizada.

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 en esta tarea, consulta la documentación de referencia del comando gcloud ai hp-tuning-jobs create y el recurso de API HyperparameterTuningJob.

Crea un archivo YAML llamado config.yaml con algunos campos de API que desees especificar para el HyerparameterTuningJob nuevo:

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
```
Reemplaza lo siguiente:
- METRIC_ID: Es el nombre de una métrica de hiperparámetro para optimizar. Tu código de entrenamiento debe informar esta métrica cuando se ejecuta.
- METRIC_GOAL: Es el objetivo para tu métrica de hiperparámetro, ya sea MAXIMIZE o MINIMIZE.
- HYPERPARAMETER_ID: Es el nombre de un hiperparámetro que se va a ajustar. El código de entrenamiento debe analizar una función experimental de línea de comandos con este nombre. Para este ejemplo, el hiperparámetro debe tomar valores de punto flotante. Obtén más información sobre otros tipos de datos de hiperparámetros.
- DOUBLE_MIN_VALUE: Es el valor mínimo (un número) que quieres que Vertex AI pruebe para este hiperparámetro.
- DOUBLE_MAX_VALUE: Es el valor máximo (un número) que deseas que Vertex AI pruebe para este hiperparámetro.
- MACHINE_TYPE: Es el tipo de VM que se usará para el entrenamiento.
- CUSTOM_CONTAINER_IMAGE_URI: Es el URI de una imagen de contenedor de Docker con el código de entrenamiento. Obtén más información sobre cómo crear una imagen de contenedor personalizada.
  
  Para este ejemplo, debes usar un contenedor personalizado. Los recursos HyperparameterTuningJob también admiten el código de entrenamiento en una distribución de origen de Python en lugar de un contenedor personalizado.
En el mismo directorio que tu 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
```
Reemplaza lo siguiente:
- LOCATION: Es la región en la que deseas crear el HyperparameterTuningJob. Usa una región que admita el entrenamiento personalizado.
- DISPLAY_NAME: Es un nombre visible que puedes recordar para el HyperparameterTuningJob. Obtén más información sobre los requisitos de nombres de los recursos.
- MAX_TRIAL_COUNT: Es la cantidad máxima de pruebas que se deben ejecutar.
- PARALLEL_TRIAL_COUNT: Es la cantidad máxima de pruebas que se deben ejecutar en paralelo.

REST

Usa la siguiente muestra de código para crear un trabajo de ajuste de hiperparámetros mediante el método create del recurso hyperparameterTuningJob.

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

LOCATION: Es la región en la que deseas crear el HyperparameterTuningJob. Usa una región que admita el entrenamiento personalizado.
PROJECT: El ID del proyecto.
DISPLAY_NAME: Es un nombre visible que puedes recordar para el HyperparameterTuningJob. Obtén más información sobre los requisitos de nombres de los recursos.
Especifica tus métricas:
- METRIC_ID: Es el nombre de una métrica de hiperparámetro para optimizar. Tu código de entrenamiento debe informar esta métrica cuando se ejecuta.
- METRIC_GOAL: Es el objetivo para tu métrica de hiperparámetro, ya sea MAXIMIZE o MINIMIZE.
Especifica tus hiperparámetros:
- HYPERPARAMETER_ID: Es el nombre de un hiperparámetro que se va a ajustar. El código de entrenamiento debe analizar una función experimental de línea de comandos con este nombre.
- 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 INTEGER, 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.
- Especifica hiperparámetros condicionales. Los hiperparámetros condicionales se agregan a una prueba cuando el valor del hiperparámetro superior coincide con la condición que especificas. Obtén más información sobre los hiperparámetros condicionales.
  - CONDITIONAL_PARAMETER: El ParameterSpec del parámetro condicional. Esta especificación incluye el escalamiento, el rango de valores y el nombre del parámetro y cualquier parámetro condicional que depende de este hiperparámetro.
  - Si el tipo del hiperparámetro superior es un NÚMERO ENTERO, debes especificar una lista de números enteros como INTEGERS_TO_MATCH. Si el valor del hiperparámetro superior coincide con uno de los valores especificados, este parámetro condicional se agrega a la prueba.
  - Si el tipo de hiperparámetro principal es CATEGÓRICO, especifica una lista de categorías como CATEGORIES_TO_MATCH. Si el valor del hiperparámetro superior coincide con uno de los valores especificados, este parámetro condicional se agrega a la prueba.
  - Si el tipo de hiperparámetro principal es DISCRETO, especifica una lista de números enteros como DISCRETE_VALUES_TO_MATCH. Si el valor del hiperparámetro superior coincide con uno de los valores especificados, este parámetro condicional se agrega a la prueba.
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: Es la cantidad máxima de pruebas que se deben ejecutar.
PARALLEL_TRIAL_COUNT: Es la cantidad máxima de pruebas que se deben ejecutar 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: Es el tipo de VM que se usará para el entrenamiento.
- ACCELERATOR_TYPE: El tipo de acelerador que se conectará a cada prueba (opcional).
- ACCELERATOR_COUNT: La cantidad de aceleradores que se conectarán a cada prueba (opcional).
- REPLICA_COUNT: La cantidad de réplicas de trabajadores que se deben usar para cada prueba.
- Si tu aplicación de entrenamiento se ejecuta en un contenedor personalizado, especifica lo siguiente:
  - CUSTOM_CONTAINER_IMAGE_URI: Es el URI de una imagen de contenedor de Docker con el código de entrenamiento. Obtén más información sobre cómo crear una imagen de contenedor personalizada.
  - 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. Obtén más información sobre los contenedores compilados previamente 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: Argumentos de la línea de comandos que se pasarán al módulo de Python (opcional).
- SERVICE_ACCOUNT: La cuenta de servicio que Vertex AI usará para ejecutar tu código. Obtén más información para vincular una cuenta de servicio personalizada.
- 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.

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, expande una de estas opciones:

curl (Linux, macOS o Cloud Shell)

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

Guarda el cuerpo de la solicitud en un archivo llamado request.json y ejecuta el siguiente comando:

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

PowerShell (Windows)

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 que se muestra a continuación:

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

Si deseas obtener información para instalar o actualizar el SDK de Python, consulta Instala el SDK de Vertex AI para Python. Si deseas obtener más información, consulta la documentación de referencia de la API de Python.

from google.cloud import aiplatform

from google.cloud.aiplatform 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 del trabajo de entrenamiento de hiperparámetros

Los trabajos de ajuste de hiperparámetros buscan la mejor combinación de hiperparámetros para optimizar tus métricas. Los trabajos de ajuste de hiperparámetros hacen esto mediante la ejecución de varias pruebas de tu aplicación de entrenamiento con diferentes conjuntos de hiperparámetros.

Cuando configuras un trabajo de ajuste de hiperparámetros, debes especificar los siguientes detalles:

Los hiperparámetros que deseas ajustar y las métricas que deseas usar para evaluar las pruebas.

Obtén más información para seleccionar hiperparámetros y métricas.
Detalles sobre la cantidad de pruebas que se ejecutarán como parte de este trabajo de ajuste, como se muestra a continuación:
Detalles sobre el trabajo de entrenamiento personalizado que se ejecuta para cada prueba, como los siguientes:
- El tipo de máquina en el que se ejecutan los trabajos de prueba y los aceleradores que usa el trabajo.
  
  Nota: En la actualidad, Vertex AI no admite trabajos de ajuste de hiperparámetros que requieren TPU.
- Los detalles del trabajo del paquete de Python o del contenedor personalizado.
  
  Obtén más información sobre los requisitos de los códigos de entrenamiento.

Limita la cantidad de pruebas

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

Hay dos intereses que compiten entre sí y que se deben tener en cuenta cuando decides cuántas pruebas se deben permitir:

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

Por lo general, aumentar la cantidad de pruebas produce mejores resultados, pero no siempre es así. Suele haber un punto a partir del cual el rendimiento decrece, y las pruebas adicionales tienen poco o ningún efecto sobre la precisión. Antes de comenzar un trabajo con una gran cantidad de pruebas, puedes comenzar con una pequeña cantidad de pruebas para evaluar el efecto que tienen los hiperparámetros elegidos en la precisión de tu modelo.

Para aprovechar al máximo el ajuste del hiperparámetro, no debes establecer tu valor máximo inferior a diez veces la cantidad de hiperparámetros que usas.

Pruebas paralelas

Puedes especificar cuántas pruebas se pueden ejecutar en paralelo si configuras parallelTrialCount en el HyperparameterTuningJob.

La ejecución de pruebas paralelas tiene el beneficio de reducir el tiempo que toma el trabajo de entrenamiento (nos referimos al tiempo real, ya que el tiempo total de procesamiento requerido no suele cambiar). Sin embargo, ejecutar en paralelo puede reducir la efectividad del trabajo de ajuste en general. Esto se debe a que el ajuste de hiperparámetros usa los resultados de las pruebas anteriores para informar los valores que se les deben asignar a los hiperparámetros de las pruebas posteriores. Cuando se ejecutan en paralelo, algunas pruebas comienzan sin tener el beneficio de los resultados de cualquier prueba que aún se esté ejecutando.

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

Controla pruebas con errores

Si las pruebas de ajuste de hiperparámetros generan errores, es posible que desees finalizar el trabajo de entrenamiento antes de tiempo. Configura el campo maxFailedTrialCount de HyperparameterTuningJob en el número de pruebas con errores que deseas permitir. Después de que falle esta cantidad de pruebas, Vertex AI finaliza el trabajo de entrenamiento. El valor maxFailedTrialCount debe ser menor o igual que maxTrialCount.

Si no estableces el valor maxFailedTrialCount, o si lo estableces en 0, Vertex AI usa las siguientes reglas para procesar las pruebas con errores:

Si la primera prueba de tu trabajo falla, Vertex AI finaliza el trabajo de inmediato. Un error durante la primera prueba sugiere la existencia de un problema en tu código de entrenamiento, por lo que es probable que otras pruebas también fallen. Terminar el trabajo te permite diagnosticar el problema sin esperar más pruebas y, además, sin que se generen más costos.
Si la primera prueba se completa, Vertex AI puede finalizar el trabajo después de que se generen errores durante pruebas posteriores en función de uno de los siguientes criterios:
- La cantidad de pruebas con errores aumentó demasiado.
- La proporción de pruebas con errores frente a pruebas exitosas aumentó demasiado.

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

Administra trabajos de ajuste de hiperparámetros

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

Recupera información sobre un trabajo de ajuste de hiperparámetros

En las siguientes muestras de código, se ilustra cómo recuperar 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

Reemplaza lo siguiente:

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

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

REST

Usa la siguiente muestra de código para recuperar un trabajo de ajuste de hiperparámetros mediante el método get del recurso hyperparameterTuningJob.

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

LOCATION: Es la región en la que se creó el HyperparameterTuningJob.
NAME: el nombre del trabajo de ajuste de hiperparámetros. El nombre del trabajo usa 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, expande una de estas opciones:

curl (Linux, macOS o Cloud Shell)

Ejecuta el siguiente comando:

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

PowerShell (Windows)

Ejecuta el siguiente comando:

$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 que se muestra a continuación:

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

Cancela un trabajo de ajuste de hiperparámetros

En las siguientes muestras de código, se ilustra 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

Reemplaza lo siguiente:

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

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

REST

Usa la siguiente muestra de código para cancelar un trabajo de ajuste de hiperparámetros mediante el método cancel del recurso hyperparameterTuningJob.

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

LOCATION: Es la región en la que se creó el HyperparameterTuningJob.
NAME: el nombre del trabajo de ajuste de hiperparámetros. El nombre del trabajo usa 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, expande una de estas opciones:

curl (Linux, macOS o Cloud Shell)

Ejecuta el siguiente comando:

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 siguiente comando:

$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 exitoso (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()

Borra un trabajo de ajuste de hiperparámetros

En las siguientes muestras de código, se explica cómo borrar un trabajo de ajuste de hiperparámetros con el SDK de Vertex AI para Python y la API de REST.

REST

Usa la siguiente muestra de código para borrar un trabajo de ajuste de hiperparámetros mediante el método delete del recurso hyperparameterTuningJob.

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

LOCATION: Tu región.
NAME: el nombre del trabajo de ajuste de hiperparámetros. El nombre del trabajo usa 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, expande una de estas opciones:

curl (Linux, macOS o Cloud Shell)

Ejecuta el siguiente comando:

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

PowerShell (Windows)

Ejecuta el siguiente comando:

$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 exitoso (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()

¿Qué sigue?

Obtén más información sobre los conceptos relacionados con el ajuste de hiperparámetros.

Crea un trabajo de ajuste de hiperparámetros

Prepara tu aplicación de entrenamiento

Controla los argumentos de la línea de comandos de los hiperparámetros que deseas ajustar

Informa tus métricas a Vertex AI

Crea un trabajo de ajuste de hiperparámetros

Consola

gcloud

config.yaml

REST

curl (Linux, macOS o Cloud Shell)

PowerShell (Windows)

Java

Python

Configuración del trabajo de entrenamiento de hiperparámetros

Limita la cantidad de pruebas

Pruebas paralelas

Controla pruebas con errores

Administra trabajos de ajuste de hiperparámetros

Recupera información sobre un trabajo de ajuste de hiperparámetros

gcloud

REST

curl (Linux, macOS o Cloud Shell)

PowerShell (Windows)

Java

Python

Cancela un trabajo de ajuste de hiperparámetros

gcloud

REST

curl (Linux, macOS o Cloud Shell)

PowerShell (Windows)

Python

Borra un trabajo de ajuste de hiperparámetros

REST

curl (Linux, macOS o Cloud Shell)

PowerShell (Windows)

Python

¿Qué sigue?

`config.yaml`