Se usó la API de Cloud Translation para traducir esta página.

Cómo usar los espacios de búsqueda compilados previamente y un entrenador compilado previamente

En esta guía, se muestra cómo ejecutar un trabajo de Búsqueda de arquitectura neuronal de Vertex AI con los espacios de búsqueda compilados previamente de Google y el código del entrenador compilado previamente en función de TF-vision para MnasNet y SpineNet. Consulta el notebook de clasificación de MnasNet y el notebook de detección de objetos de SpineNet para ver ejemplos de extremo a extremo.

Preparación de datos para el entrenador precompilados

El entrenador previamente compilado de la Búsqueda de arquitectura neuronal requiere que tus datos estén en formato TFRecord, y que contengan tf.train.Example. Los tf.train.Example deben incluir los siguientes campos:

'image/encoded': tf.FixedLenFeature(tf.string)
'image/height': tf.FixedLenFeature(tf.int64)
'image/width': tf.FixedLenFeature(tf.int64)

# For image classification only.
'image/class/label': tf.FixedLenFeature(tf.int64)

# For object detection only.
'image/object/bbox/xmin': tf.VarLenFeature(tf.float32)
'image/object/bbox/xmax': tf.VarLenFeature(tf.float32)
'image/object/bbox/ymin': tf.VarLenFeature(tf.float32)
'image/object/bbox/ymax': tf.VarLenFeature(tf.float32)
'image/object/class/label': tf.VarLenFeature(tf.int64)

Puedes seguir las instrucciones para la preparación de datos de ImageNet aquí.

Para convertir tus datos personalizados, usa la secuencia de comandos de análisis que se incluye en el código de muestra y las utilidades que descargaste. Para personalizar el análisis de datos, modifica los archivos tf_vision/dataloaders/*_input.py.

Más información sobre TFRecord y tf.train.Example.

Define las variables de entorno del experimento

Antes de ejecutar los experimentos, deberás definir una serie de variables de entorno, incluidas las siguientes:

TRAINER_DOCKER_ID: ${USER}_nas_experiment (formato recomendado)
Ubicaciones de Cloud Storage de tus conjuntos de datos de entrenamiento y validación que usará el experimento. Por ejemplo (CoCo para la detección):
- gs://cloud-samples-data/ai-platform/built-in/image/coco/train*
- gs://cloud-samples-data/ai-platform/built-in/image/coco/val*
Ubicación de Cloud Storage para el resultado del experimento. Formato recomendado:
- gs://${USER}_nas_experiment
REGION: Una región que debe ser la misma que la región del bucket de salida del experimento. Por ejemplo: us-central1.
PARAM_OVERRIDE: Un archivo .yaml que anule los parámetros del entrenador compilado previamente. La Búsqueda de arquitectura neuronal proporciona algunas configuraciones predeterminadas que puedes usar:

PROJECT_ID=PROJECT_ID
TRAINER_DOCKER_ID=TRAINER_DOCKER_ID
LATENCY_CALCULATOR_DOCKER_ID=LATENCY_CALCULATOR_DOCKER_ID
GCS_ROOT_DIR=OUTPUT_DIR
REGION=REGION
PARAM_OVERRIDE=tf_vision/configs/experiments/spinenet_search_gpu.yaml
TRAINING_DATA_PATH=gs://PATH_TO_TRAINING_DATA
VALIDATION_DATA_PATH=gs://PATH_TO_VALIDATION_DATA

Recomendamos que selecciones o modifices el archivo de anulación que coincida con tus requisitos de entrenamiento. Tenga en cuenta lo siguiente:

Puedes configurar --accelerator_type para elegir entre GPU o CPU. A fin de ejecutar solo algunas ciclos de entrenamiento para pruebas rápidas con CPU, puedes configurar la marca --accelerator_type="" y usar el archivo de configuración tf_vision/test_files/fast_nas_detection_spinenet_search_for_testing.yaml.
Cantidad de ciclos de entrenamiento
Entorno de ejecución del entrenamiento
Hiperparámetros como la tasa de aprendizaje

Si deseas obtener una lista de todos los parámetros para controlar los trabajos de entrenamiento, consulta tf_vision/configs/. Los siguientes son los parámetros clave:

task:
  train_data:
    global_batch_size: 80
  validation_data:
    global_batch_size: 16
  init_checkpoint: null
trainer:
  train_steps: 16634
  steps_per_loop: 1386
  optimizer_config:
    learning_rate:
      cosine:
        initial_learning_rate: 0.16
        decay_steps: 16634
      type: 'cosine'
    warmup:
      type: 'linear'
      linear:
        warmup_learning_rate: 0.0067
        warmup_steps: 1386

Crea un bucket de Cloud Storage para Neural Architecture Search a fin de almacenar los resultados de tu trabajo (es decir, puntos de control):

gcloud storage buckets create $GCS_ROOT_DIR

Compila un contenedor de entrenador y un contenedor de calculadora de latencia

Con el siguiente comando, se compilará una imagen de entrenador en Google Cloud con el siguiente URI: gcr.io/PROJECT_ID/TRAINER_DOCKER_ID, que se usará en el trabajo de Búsqueda de arquitectura neuronal en el siguiente paso.

python3 vertex_nas_cli.py build \
--project_id=PROJECT_ID \
--trainer_docker_id=TRAINER_DOCKER_ID \
--latency_calculator_docker_id=LATENCY_CALCULATOR_DOCKER_ID \
--trainer_docker_file=tf_vision/nas_multi_trial.Dockerfile \
--latency_calculator_docker_file=tf_vision/latency_computation_using_saved_model.Dockerfile

Para cambiar el espacio de búsqueda y la recompensas, actualízalos en tu archivo de Python y, luego, vuelve a compilar la imagen de Docker.

Prueba el entrenador de forma local

Debido a que iniciar un trabajo en el servicio de Google Cloud lleva varios minutos, puede ser más conveniente probar el Docker del entrenador de forma local, por ejemplo, validar el formato TFRecord. Usa el espacio de búsqueda spinenet como ejemplo. Puedes ejecutar el trabajo de búsqueda de manera local (el modelo se someterá a un muestreo de forma aleatoria):

# Define the local job output dir.
JOB_DIR="/tmp/iod_${search_space}"

python3 vertex_nas_cli.py search_in_local \
--project_id=PROJECT_ID \
--trainer_docker_id=TRAINER_DOCKER_ID \
--prebuilt_search_space=spinenet \
--use_prebuilt_trainer=True \
--local_output_dir=${JOB_DIR} \
--search_docker_flags \
params_override="tf_vision/test_files/fast_nas_detection_spinenet_search_for_testing.yaml" \
training_data_path=TEST_COCO_TF_RECORD \
validation_data_path=TEST_COCO_TF_RECORD \
model=retinanet

Las rutas de acceso a tus TFRecords son training_data_path y validation_data_path.

Inicia una búsqueda de etapa 1 seguida de un trabajo de entrenamiento de etapa 2 en Google Cloud

Debes consultar el notebook de clasificación de MnasNet y el notebook de detección de objetos de SpineNet para ver ejemplos de extremo a extremo.

Puedes configurar las marcas --max_parallel_nas_trial y --max_nas_trial para personalizar. La Búsqueda de arquitectura neuronal iniciará pruebas max_parallel_nas_trial en paralelo y finalizará después de las pruebas max_nas_trial.
Si se establece la marca --target_device_latency_ms, se iniciará un trabajo de latency calculator separado con el acelerador que especifica la marca --target_device_type.
El controlador de Búsqueda de arquitectura neuronal proporcionará cada prueba con una sugerencia para un candidato de arquitectura nuevo a través del --nas_params_str de FLAG.
Cada prueba compilará un grafo en función del valor del nas_params_str de FLAG y, luego, iniciará un trabajo de entrenamiento. Cada prueba también guarda su valor en un archivo json (en os.path.join(nas_job_dir, str(trial_id), "nas_params_str.json")).

Recompensa con una restricción de latencia

El notebook de clasificación de MnasNet muestra un ejemplo de una búsqueda restringida en la latencia basada en dispositivos de nube-CPU.

Para buscar modelos con restricción de latencia, el entrenador puede informar la recompensa como una función de precisión y latencia.

En el código fuente compartido, la recompensa se calcula de la siguiente manera:

def compute_reward(target_latency, accuracy, inference_latency, weight=0.07):
  """Compute reward from accuracy and latency."""
  speed_ratio = target_latency / inference_latency
  return accuracy * (speed_ratio**weight)

Puedes usar otras variantes del cálculo de reward en la página 3 de el documento de mnasnet.

target_device_type especifica el tipo de dispositivo de destino que es compatible con Google Cloud, como NVIDIA_TESLA_P100.
use_prebuilt_latency_calculator usa nuestra calculadora de latencia precompilada tf_vision/latency_computation_using_saved_model.py.
target_device_latency_ms especifica la latencia del dispositivo de destino.

Para obtener información sobre cómo personalizar la función de cálculo de latencia, consulta tf_vision/latency_computation_using_saved_model.py.

Supervisa el progreso de tu trabajo de Búsqueda de arquitectura neuronal

En la consola de Google Cloud, en la página del trabajo, el gráfico muestra el reward vs. trial number, mientras que la tabla muestra las recompensas de cada prueba. Puedes encontrar las pruebas principales con la recompensa más alta.

Traza una curva de entrenamiento de etapa 2

Después del entrenamiento de etapa 2, usa Cloud Shell o Google Cloud TensorBoard para trazar la curva de entrenamiento. Para ello, apúntala al directorio del trabajo:

Implementa un modelo seleccionado

Para crear un modelo guardado, puedes usar la secuencia de comandos export_saved_model.py con params_override=${GCS_ROOT_DIR}/${TRIAL_ID}/params.yaml.