Usa el ajuste de hiperparámetro

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

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:

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

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

En las siguientes muestras de código, se ilustra cómo crear un trabajo de ajuste de hiperparámetros.

Console

En Google Cloud Console, 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.

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

    Ve a Canalizaciones de entrenamiento

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

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

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

    2. Selecciona Entrenamiento personalizado (avanzado).

    Haga clic en Continuar.

  4. En el paso Detalles del modelo, ingresa el nombre que desees, MODEL_NAME, para tu modelo. Haz clic en Continuar.

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

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

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

    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. En el campo Argumentos, puedes especificar argumentos para que Vertex AI los use cuando comience a ejecutar tu código de entrenamiento. El comportamiento de estos argumentos difiere según el tipo de contenedor que uses:

    Haz clic en Continuar.

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

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

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

    2. En la sección Grupo de trabajadores 0, especifica recursos de procesamiento para usar en el entrenamiento.

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

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

    Haz clic en Continuar.

  8. En el paso Contenedor de predicción, selecciona Sin contenedor de predicción.

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

LÍNEA DE REST Y CMD

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: Tu región.
  • PROJECT: Tu ID del proyecto o número de proyecto.
  • DISPLAY_NAME: Nombre visible para tu trabajo de ajuste de hiperparámetros.
  • Especifica tus métricas:
    • METRIC_ID: El nombre de esta métrica.
    • METRIC_GOAL: El objetivo de esta métrica. Puede ser MAXIMIZE o MINIMIZE.
  • Especifica tus hiperparámetros:
    • PARAMETER_ID: El nombre de este hiperparámetro.
    • PARAMETER_SCALE: Indica cómo se debe escalar el parámetro. Se deja sin configurar para los parámetros CATEGORICAL. Puede ser UNIT_LINEAR_SCALE, UNIT_LOG_SCALE, UNIT_REVERSE_LOG_SCALE, o SCALE_TYPE_UNSPECIFIED.
    • Si el tipo de hiperparámetro es DOUBLE, especifica los valores mínimos (DOUBLE_MIN_VALUE) y máximos (DOUBLE_MAX_VALUE) para este hiperparámetro.
    • Si el tipo de hiperparámetro es 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: La cantidad máxima de pruebas que se ejecutarán en este trabajo.
  • PARALLEL_TRIAL_COUNT: La cantidad máxima de pruebas que pueden ejecutarse en paralelo.
  • MAX_FAILED_TRIAL_COUNT: La cantidad de trabajos que pueden fallar antes de que falle el trabajo de ajuste de hiperparámetros.
  • Define el trabajo de entrenamiento personalizado de prueba:
    • MACHINE_TYPE: El tipo de máquina. Obtén más información sobre los tipos de máquinas disponibles para el entrenamiento.
    • ACCELERATOR_TYPE: El tipo de acelerador que se conectará a cada prueba (opcional).
    • ACCELERATOR_COUNT: La cantidad de aceleradores que se conectarán a cada prueba (opcional).
    • REPLICA_COUNT: La cantidad de réplicas de trabajadores que se deben usar para cada prueba.
    • Si tu aplicación de entrenamiento se ejecuta en un contenedor personalizado, especifica lo siguiente:
      • CUSTOM_CONTAINER_IMAGE_URI: El URI de una imagen de contenedor en Artifact Registry, Container Registry o Docker Hub que se ejecutará en cada réplica de trabajador.
      • CUSTOM_CONTAINER_COMMAND: El comando que se invocará cuando se inicie el contenedor. Este comando anula el punto de entrada predeterminado del contenedor.
      • CUSTOM_CONTAINER_ARGS: son los argumentos que se transmitirán cuando se inicia el contenedor (opcional).
    • 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:

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

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

En este ejemplo, se usa el SDK de Vertex AI para Python. Antes de ejecutar la siguiente muestra de código, debes configurar la autenticación.

from google.cloud import aiplatform

def create_hyperparameter_tuning_job_python_package_sample(
    project: str,
    display_name: str,
    executor_image_uri: str,
    package_uri: str,
    python_module: str,
    location: str = "us-central1",
    api_endpoint: str = "us-central1-aiplatform.googleapis.com",
):
    # The AI Platform services require regional API endpoints.
    client_options = {"api_endpoint": api_endpoint}
    # Initialize client that will be used to create and send requests.
    # This client only needs to be created once, and can be reused for multiple requests.
    client = aiplatform.gapic.JobServiceClient(client_options=client_options)

    # study_spec
    metric = {
        "metric_id": "val_rmse",
        "goal": aiplatform.gapic.StudySpec.MetricSpec.GoalType.MINIMIZE,
    }

    conditional_parameter_decay = {
        "parameter_spec": {
            "parameter_id": "decay",
            "double_value_spec": {"min_value": 1e-07, "max_value": 1},
            "scale_type": aiplatform.gapic.StudySpec.ParameterSpec.ScaleType.UNIT_LINEAR_SCALE,
        },
        "parent_discrete_values": {"values": [32, 64]},
    }
    conditional_parameter_learning_rate = {
        "parameter_spec": {
            "parameter_id": "learning_rate",
            "double_value_spec": {"min_value": 1e-07, "max_value": 1},
            "scale_type": aiplatform.gapic.StudySpec.ParameterSpec.ScaleType.UNIT_LINEAR_SCALE,
        },
        "parent_discrete_values": {"values": [4, 8, 16]},
    }
    parameter = {
        "parameter_id": "batch_size",
        "discrete_value_spec": {"values": [4, 8, 16, 32, 64, 128]},
        "scale_type": aiplatform.gapic.StudySpec.ParameterSpec.ScaleType.UNIT_LINEAR_SCALE,
        "conditional_parameter_specs": [
            conditional_parameter_decay,
            conditional_parameter_learning_rate,
        ],
    }

    # trial_job_spec
    machine_spec = {
        "machine_type": "n1-standard-4",
        "accelerator_type": aiplatform.gapic.AcceleratorType.NVIDIA_TESLA_K80,
        "accelerator_count": 1,
    }
    worker_pool_spec = {
        "machine_spec": machine_spec,
        "replica_count": 1,
        "python_package_spec": {
            "executor_image_uri": executor_image_uri,
            "package_uris": [package_uri],
            "python_module": python_module,
            "args": [],
        },
    }

    # hyperparameter_tuning_job
    hyperparameter_tuning_job = {
        "display_name": display_name,
        "max_trial_count": 4,
        "parallel_trial_count": 2,
        "study_spec": {
            "metrics": [metric],
            "parameters": [parameter],
            "algorithm": aiplatform.gapic.StudySpec.Algorithm.RANDOM_SEARCH,
        },
        "trial_job_spec": {"worker_pool_specs": [worker_pool_spec]},
    }
    parent = f"projects/{project}/locations/{location}"
    response = client.create_hyperparameter_tuning_job(
        parent=parent, hyperparameter_tuning_job=hyperparameter_tuning_job
    )
    print("response:", response)

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:

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 puede ver cómo recuperar un trabajo de ajuste de hiperparámetros mediante la biblioteca cliente de Vertex AI y la API de REST.

LÍNEA DE REST Y CMD

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

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

Para enviar tu solicitud, expande una de estas opciones:

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

En este ejemplo, se usa el SDK de Vertex AI para Python. Antes de ejecutar la siguiente muestra de código, debes configurar la autenticación.

from google.cloud import aiplatform

def get_hyperparameter_tuning_job_sample(
    project: str,
    hyperparameter_tuning_job_id: str,
    location: str = "us-central1",
    api_endpoint: str = "us-central1-aiplatform.googleapis.com",
):
    # The AI Platform services require regional API endpoints.
    client_options = {"api_endpoint": api_endpoint}
    # Initialize client that will be used to create and send requests.
    # This client only needs to be created once, and can be reused for multiple requests.
    client = aiplatform.gapic.JobServiceClient(client_options=client_options)
    name = client.hyperparameter_tuning_job_path(
        project=project,
        location=location,
        hyperparameter_tuning_job=hyperparameter_tuning_job_id,
    )
    response = client.get_hyperparameter_tuning_job(name=name)
    print("response:", response)

Cancela un trabajo de ajuste de hiperparámetros

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

LÍNEA DE REST Y CMD

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

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

Para enviar tu solicitud, expande una de estas opciones:

Deberías recibir un código de estado exitoso (2xx) y una respuesta vacía.

Python

En este ejemplo, se usa el SDK de Vertex AI para Python. Antes de ejecutar la siguiente muestra de código, debes configurar la autenticación.

from google.cloud import aiplatform

def cancel_hyperparameter_tuning_job_sample(
    project: str,
    hyperparameter_tuning_job_id: str,
    location: str = "us-central1",
    api_endpoint: str = "us-central1-aiplatform.googleapis.com",
):
    # The AI Platform services require regional API endpoints.
    client_options = {"api_endpoint": api_endpoint}
    # Initialize client that will be used to create and send requests.
    # This client only needs to be created once, and can be reused for multiple requests.
    client = aiplatform.gapic.JobServiceClient(client_options=client_options)
    name = client.hyperparameter_tuning_job_path(
        project=project,
        location=location,
        hyperparameter_tuning_job=hyperparameter_tuning_job_id,
    )
    response = client.cancel_hyperparameter_tuning_job(name=name)
    print("response:", response)

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.

LÍNEA DE REST Y CMD

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:

Deberías recibir un código de estado exitoso (2xx) y una respuesta vacía.

Python

En este ejemplo, se usa el SDK de Vertex AI para Python. Antes de ejecutar la siguiente muestra de código, debes configurar la autenticación.

from google.cloud import aiplatform

def delete_hyperparameter_tuning_job_sample(
    project: str,
    hyperparameter_tuning_job_id: str,
    location: str = "us-central1",
    api_endpoint: str = "us-central1-aiplatform.googleapis.com",
    timeout: int = 300,
):
    # The AI Platform services require regional API endpoints.
    client_options = {"api_endpoint": api_endpoint}
    # Initialize client that will be used to create and send requests.
    # This client only needs to be created once, and can be reused for multiple requests.
    client = aiplatform.gapic.JobServiceClient(client_options=client_options)
    name = client.hyperparameter_tuning_job_path(
        project=project,
        location=location,
        hyperparameter_tuning_job=hyperparameter_tuning_job_id,
    )
    response = client.delete_hyperparameter_tuning_job(name=name)
    print("Long running operation:", response.operation.name)
    delete_hyperparameter_tuning_job_response = response.result(timeout=timeout)
    print(
        "delete_hyperparameter_tuning_job_response:",
        delete_hyperparameter_tuning_job_response,
    )

¿Qué sigue?