Utiliser des espaces de recherche prédéfinis et une application d'entraînement prédéfinie

Ce guide explique comment exécuter une tâche Vertex AI Neural Architecture Search à l'aide des espaces de recherche et du code d'entraînement prédéfinis de Google basés sur TF-vision pour MnasNet et SpineNet. Reportez-vous au notebook de classification MnasNet et au notebook de détection d'objets SpineNet pour obtenir des exemples de bout en bout.

Préparation des données pour l'application d'entraînement prédéfinie

L'application d'entraînement Neural Architecture Search nécessite que vos données soient au format TFRecord et incluent tf.train.Example. Les exemples tf.train.Example doivent inclure les champs suivants :

'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)

Vous pouvez suivre les instructions de préparation des données ImageNet ici.

Pour convertir vos données personnalisées, utilisez le script d'analyse fourni avec l'exemple de code et les utilitaires que vous avez téléchargés. Pour personnaliser l'analyse de données, modifiez les fichiers tf_vision/dataloaders/*_input.py.

En savoir plus sur TFRecord et tf.train.Example.

Définir des variables d'environnement de test

Pour pouvoir exécuter vos tests, vous devez définir plusieurs variables d'environnement, y compris les suivantes :

TRAINER_DOCKER_ID : ${USER}_nas_experiment (format recommandé)
Emplacements Cloud Storage de vos ensembles de données d'entraînement et de validation utilisés pour le test. Exemples (CoCo pour la détection) :
- gs://cloud-samples-data/ai-platform/built-in/image/coco/train*
- gs://cloud-samples-data/ai-platform/built-in/image/coco/val*
Emplacement Cloud Storage pour le résultat du test. Format recommandé :
- gs://${USER}_nas_experiment
REGION: région qui doit être identique à la région du bucket de sortie du test. Exemple : us-central1.
PARAM_OVERRIDE : fichier .yaml qui remplace les paramètres de l'application d'entraînement prédéfinie. Neural Architecture Search fournit certaines configurations par défaut que vous pouvez utiliser :

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

Vous pouvez sélectionner et/ou modifier le fichier de remplacement correspondant aux exigences de votre entraînement. Réfléchissez aux éléments suivants :

Vous pouvez définir --accelerator_type sur GPU ou CPU. Pour n'exécuter que quelques époques afin d'effectuer des tests rapides à l'aide du processeur, vous pouvez définir l'option --accelerator_type="" et utiliser le fichier de configuration tf_vision/test_files/fast_nas_detection_spinenet_search_for_testing.yaml.
Nombre d'époques
Durée d'exécution de l'entraînement
Hyperparamètres, tels que le taux d'apprentissage

Pour obtenir la liste de tous les paramètres permettant de contrôler les tâches d'entraînement, consultez tf_vision/configs/. Voici les paramètres clés :

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

Créez un bucket Cloud Storage pour Neural Architecture Search afin de stocker les résultats de vos tâches (points de contrôle) :

gsutil mkdir $GCS_ROOT_DIR

Créer un conteneur d'entraînement et un conteneur pour le simulateur de latence

La commande suivante crée une image d'entraînement dans Google Cloud avec l'URI suivant : gcr.io/PROJECT_ID/TRAINER_DOCKER_ID, qui sera utilisée dans la tâche Neural Architecture Search à l'étape suivante.

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

Pour modifier l'espace de recherche et la récompense, mettez-les à jour dans votre fichier Python, puis recompilez l'image Docker.

Tester l'application d'entraînement en local

Étant donné que le lancement d'une tâche dans le service Google Cloud prend plusieurs minutes, il peut être plus pratique de tester le fichier Docker de l'application d'entraînement en local, par exemple pour valider le format TFRecord. En utilisant l'espace de recherche spinenet comme exemple, vous pouvez exécuter la tâche de recherche en local (le modèle sera échantillonné de manière aléatoire) :

# 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

training_data_path et validation_data_path sont les chemins d'accès à vos TFRecords.

Lancer une recherche d'étape 1 suivie d'un job d'entraînement d'étape 2 sur Google Cloud

Pour obtenir des exemples de bout en bout, reportez-vous au notebook de classification MnasNet et au notebook de détection d'objets SpineNet.

Vous pouvez définir les options --max_parallel_nas_trial et --max_nas_trial pour les personnaliser. Neural Architecture Search lance les max_parallel_nas_trial essais en parallèle et arrête après max_nas_trial essais.
Si l'option --target_device_latency_ms est définie, une tâche latency calculator distincte est lancée à l'aide de l'accélérateur spécifié par l'option --target_device_type.
Le contrôleur Neural Architecture Search fournira à chaque essai une suggestion pour un nouveau candidat en termes d'architecture via l'option --nas_params_str.
Chaque essai génère un graphique basé sur la valeur de l'option nas_params_str et démarre une tâche d'entraînement. Chaque essai enregistre également sa valeur dans un fichier JSON (dans os.path.join(nas_job_dir, str(trial_id), "nas_params_str.json")).

Récompense avec une contrainte de latence

Le notebook de classification MnasNet illustre un exemple de recherche de processeur cloud avec latence basée sur l'appareil.

Pour rechercher des modèles avec une contrainte de latence, l'application d'entraînement peut signaler une récompense en tant que fonction de justesse et de latence.

Dans le code source partagé, la récompense est calculée comme suit :

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)

Vous pouvez utiliser d'autres variantes du calcul reward sur la troisième page du document mnasnet.

target_device_type spécifie le type d'appareil cible compatible avec Google Cloud, par exemple NVIDIA_TESLA_P100.
use_prebuilt_latency_calculator utilise notre outil de calcul de latence prédéfini tf_vision/latency_computation_using_saved_model.py.
target_device_latency_ms spécifie la latence de l'appareil cible.

Pour en savoir plus sur la personnalisation de la fonction de calcul de la latence, consultez le fichier tf_vision/latency_computation_using_saved_model.py.

Surveiller la progression de votre tâche Neural Architecture Search

Dans Google Cloud Console, sur la page des tâches, le graphique affiche reward vs. trial number, tandis que la table affiche les récompenses de chaque essai. Les essais les plus concluants possèdent les récompenses les plus élevées.

Tracer une courbe d'entraînement de l'étape 2

Après l'entraînement de l'étape 2, vous utilisez Cloud Shell ou Google Cloud TensorBoard pour tracer la courbe d'entraînement en la pointant vers le répertoire de la tâche :

Déployer un modèle sélectionné

Pour créer un SavedModel, vous pouvez utiliser le script export_saved_model.py avec params_override=${GCS_ROOT_DIR}/${TRIAL_ID}/params.yaml.