Entrena RetinaNet en Cloud TPU (TF 2.x)

En este documento se describe una implementación del modelo de detección de objetos RetinaNet. El código está disponible en GitHub.

En las siguientes instrucciones, se supone que ya estás familiarizado con la ejecución de un modelo en Cloud TPU. Si eres nuevo en Cloud TPU, puedes consultar la guía de inicio rápido para obtener una introducción básica.

Si planeas entrenar en una porción de pod de TPU, revisa la página sobre el entrenamiento en pods de TPU para comprender los cambios de parámetros necesarios cuando trabajas con porciones de pod.

Objetivos

  • Crear un depósito de Cloud Storage para almacenar el resultado de tu modelo y tu conjunto de datos
  • Preparar el conjunto de datos de COCO
  • Configurar una VM de Compute Engine y un nodo de Cloud TPU para entrenamiento y evaluación
  • Ejecutar el entrenamiento y la evaluación en un solo Cloud TPU o un pod de Cloud TPU

Costos

En este instructivo, se usan componentes facturables de Google Cloud, que incluyen los siguientes:

  • Compute Engine
  • Cloud TPU
  • Cloud Storage

Usa la calculadora de precios para generar una estimación de los costos según el uso previsto. Los usuarios nuevos de Google Cloud pueden ser elegibles para obtener una prueba gratuita.

Antes de comenzar

En esta sección, se proporciona información sobre cómo configurar el depósito de Cloud Storage y una VM de Compute Engine.

  1. Abre una ventana de Cloud Shell.

    Abre Cloud Shell

  2. Crea una variable para el ID de tu proyecto.

    export PROJECT_ID=project-id
    
  3. Configura la herramienta de línea de comandos gcloud para usar el proyecto en el que deseas crear Cloud TPU.

    gcloud config set project ${PROJECT_ID}
    
  4. Crea una cuenta de servicio para el proyecto de Cloud TPU.

    gcloud beta services identity create --service tpu.googleapis.com --project $PROJECT_ID
    

    El comando muestra una cuenta de servicio de Cloud TPU con el siguiente formato:

    service-PROJECT_NUMBER@cloud-tpu.iam.gserviceaccount.com
    

  5. Crea un depósito de Cloud Storage con el siguiente comando:

    gsutil mb -p ${PROJECT_ID} -c standard -l europe-west4 -b on gs://bucket-name
    

    Este depósito de Cloud Storage almacena los datos que usas para entrenar tu modelo y los resultados del entrenamiento. Con la herramienta ctpu up que se usa en este instructivo, se configuran los permisos predeterminados para la cuenta de servicio de Cloud TPU que configuraste en el paso anterior. Si quieres contar con permisos más detallados, revisa los permisos de nivel de acceso.

  6. Inicia una VM de Compute Engine con el comando ctpu up.

    $ ctpu up --vm-only \
    --name=retinanet-tutorial \
    --disk-size-gb=300 \
    --machine-type=n1-standard-8 \
    --zone=europe-west4-a \
    --tf-version=2.3
    

    Descripciones de las marcas de comandos

    vm-only
    Crea la VM sin crear una Cloud TPU. De forma predeterminada, el comando ctpu up crea una VM y una Cloud TPU.
    name
    El nombre de la Cloud TPU que se creará.
    disk-size-gb
    El tamaño del disco duro en GB de la VM creada por el comando ctpu up.
    machine-type
    El tipo de máquina de la VM de Compute Engine que se creará.
    zone
    Es la zona en la que deseas crear la Cloud TPU.
    tf-version
    La versión de Tensorflow ctpu se instala en la VM.

    Para obtener más información sobre la utilidad de CTPU, consulta la Referencia de CTPU.

  7. Cuando se te solicite, presiona y a fin de crear tus recursos de Cloud TPU.

    Cuando el comando ctpu up termine de ejecutarse, verifica que el indicador de shell haya cambiado de username@projectname a username@vm-name. Este cambio indica que accediste a tu VM de Compute Engine.

    gcloud compute ssh retinanet-tutorial --zone=europe-west4-a
    

    Mientras sigues estas instrucciones, ejecuta cada comando que comience con (vm)$ en tu instancia de Compute Engine.

  8. Instala paquetes adicionales

    La aplicación de entrenamiento RetinaNet requiere varios paquetes adicionales. Instálalos ahora:

    (vm)$ sudo apt-get install -y python3-tk
    (vm)$ pip3 install --user Cython matplotlib opencv-python-headless pyyaml Pillow
    
    (vm)$ pip3 install --user 'git+https://github.com/cocodataset/cocoapi#egg=pycocotools&subdirectory=PythonAPI'
    
    (vm)$ sudo pip3 install --user -r /usr/share/models/official/requirements.txt
    

Prepara el conjunto de datos COCO

El conjunto de datos COCO se almacenará en tu Cloud Storage, así que establece una variable de depósito de almacenamiento que especifique el nombre del depósito que creaste:

(vm)$ export STORAGE_BUCKET=gs://bucket-name
(vm)$ export DATA_DIR=${STORAGE_BUCKET}/coco

Ejecuta la secuencia de comandos download_and_preprocess_coco.sh para convertir el conjunto de datos COCO en un conjunto de TFRecords (*.tfrecord), que son compatibles con la aplicación de entrenamiento.

(vm)$ sudo bash /usr/share/tpu/tools/datasets/download_and_preprocess_coco.sh ./data/dir/coco

Esto instala las bibliotecas necesarias y ejecuta la secuencia de comandos de procesamiento previo. Como resultado, se muestra una serie de archivos *.tfrecord en tu directorio de datos local. La secuencia de comandos de conversión y descarga de COCO tarda alrededor de 1 hora en completarse.

Copia los datos en tu depósito de Cloud Storage

Después de convertir los datos en TFRecords, cópialos desde el almacenamiento local a tu depósito de Cloud Storage con el comando gsutil. También debes copiar los archivos de anotaciones. Estos archivos ayudan a validar el rendimiento del modelo.

(vm)$ gsutil -m cp ./data/dir/coco/*.tfrecord ${DATA_DIR}
(vm)$ gsutil cp ./data/dir/coco/raw-data/annotations/*.json ${DATA_DIR}

Establece el entorno de entrenamiento

  1. Crea una Cloud TPU con el comando ctpu up.

    (vm)$ ctpu up --tpu-only \
      --tpu-size=v3-8 \
      --zone=europe-west4-a \
      --name=retinanet-tutorial \
      --tf-version=2.3
    

    Para obtener más información sobre la utilidad de CTPU, consulta la Referencia de CTPU.

    Descripciones de las marcas de comandos

    tpu-only
    Crea una Cloud TPU sola. De forma predeterminada, el comando ctpu up crea una VM y una Cloud TPU.
    tpu-size
    El tipo de Cloud TPU que se creará.
    zone
    Es la zona en la que deseas crear la Cloud TPU.
    name
    El nombre de la Cloud TPU para crear.
    tf-version
    La versión de Tensorflow ctpu se instala en la VM.
    Parámetro Descripción

    Para obtener más información sobre la utilidad de CTPU, consulta la Referencia de CTPU.

  2. Cuando se te solicite, presiona y a fin de crear tus recursos de Cloud TPU.

    Cuando el comando ctpu up termine de ejecutarse, verifica que el indicador de shell haya cambiado de username@projectname a username@vm-name. Este cambio indica que accediste a tu VM de Compute Engine.

    gcloud compute ssh retinanet-tutorial --zone=europe-west4-a
    

    Mientras sigues estas instrucciones, ejecuta cada comando que comience con (vm)$ en tu instancia de Compute Engine.

  3. Crea una variable de entorno para el nombre de TPU.

    (vm)$ export TPU_NAME=retinanet-tutorial
    
  4. Agrega la carpeta /models de nivel superior a la ruta de Python con el comando siguiente:

    (vm)$ export PYTHONPATH="${PYTHONPATH}:/usr/share/models"
    

Entrenamiento de dispositivos de una sola Cloud TPU

Las siguientes secuencias de comandos de entrenamiento se ejecutaron en una Cloud TPU v3-8. Tomará más tiempo, pero también puedes ejecutarlas en una Cloud TPU v2-8.

Esta secuencia de comandos de muestra a continuación entrena solo en 10 pasos y lleva menos de 5 minutos para ejecutarse en un nodo TPU v3-8. El entrenamiento para la convergencia lleva alrededor de 22,500 pasos y aproximadamente 1 hora y media en una TPU de Cloud TPU v3-8.

  1. Configura las siguientes variables de entorno:

    (vm)$ export MODEL_DIR=${STORAGE_BUCKET}/retinanet-train
    (vm)$ export RESNET_CHECKPOINT=gs://cloud-tpu-checkpoints/retinanet/resnet50-checkpoint-2018-02-07
    (vm)$ export TRAIN_FILE_PATTERN=${DATA_DIR}/train-*
    (vm)$ export EVAL_FILE_PATTERN=${DATA_DIR}/val-*
    (vm)$ export VAL_JSON_FILE=${DATA_DIR}/instances_val2017.json
    
  2. Ejecuta la secuencia de comandos de entrenamiento:

    (vm)$ python3 /usr/share/models/official/vision/detection/main.py \
         --strategy_type=tpu \
         --tpu=${TPU_NAME} \
         --model_dir=${MODEL_DIR} \
         --mode="train" \
         --params_override="{ type: retinanet, train: { total_steps: 10, checkpoint: { path: ${RESNET_CHECKPOINT}, prefix: resnet50/ }, train_file_pattern: ${TRAIN_FILE_PATTERN} }, eval: { val_json_file: ${VAL_JSON_FILE}, eval_file_pattern: ${EVAL_FILE_PATTERN}, eval_samples: 5000 } }"
    

    Descripciones de las marcas de comandos

    strategy_type
    Para entrenar el modelo RetinaNet en una TPU, debes configurar distribution_strategy en tpu.
    tpu
    El nombre de Cloud TPU. Se configura con la variable de entorno TPU_NAME.
    model_dir
    El directorio en el que se almacenan puntos de control y resúmenes durante el entrenamiento del modelo. Si la carpeta no está, el programa crea una. Cuando se usa una Cloud TPU, el model_dir debe ser una ruta de Cloud Storage (gs://...). Puedes reutilizar una carpeta existente para cargar datos de puntos de control actuales y almacenar puntos de control adicionales siempre que los puntos de control anteriores se hayan creado mediante TPU del mismo tamaño y versión de TensorFlow.
    mode
    Configura esto como train para entrenar el modelo o eval para evaluarlo.
    params_override
    Una string JSON que anula los parámetros predeterminados de la secuencia de comandos. Para obtener más información sobre los parámetros de secuencia de comandos, consulta /usr/share/models/official/vision/detection/main.py.

Mientras se entrena el modelo, puedes ver el progreso mediante la visualización del resultado del registro. Un resultado similar al siguiente muestra que el entrenamiento progresa de forma normal:

31517803669, 'learning_rate': 0.08, 'box_loss': 0.0006472870009019971,
'l2_regularization_loss': 0.09328179806470871}
I0210 21:59:19.888985 139927795508992 distributed_executor.py:49]
Saving model as TF checkpoint: gs://bucket-eu/retinanet-model/ctl_step_2500.ckpt-5
I0210 22:01:07.714749 139927795508992 distributed_executor.py:446]
Train Step: 3000/22500  / loss = {'model_loss': 0.08362223953008652,
'total_loss': 0.17120523750782013, 'cls_loss': 0.057121846824884415,
'learning_rate': 0.08, 'box_loss': 0.0005300078773871064,
'l2_regularization_loss': 0.08758299797773361} / training metric =
{'model_loss': 0.08362223953008652, 'total_loss': 0.17120523750782013, 'cls_loss': 0.0
57121846824884415, 'learning_rate': 0.08, 'box_loss': 0.0005300078773871064,
'l2_regularization_loss': 0.08758299797773361}
I0210 22:01:15.813422 139927795508992 distributed_executor.py:49]
Saving model as TF checkpoint: gs://bucket-eu/retinanet-model/ctl_step_3000.ckpt-6

Evaluación de dispositivos de una sola Cloud TPU

En el siguiente procedimiento se usan los datos de evaluación de COCO. Toma alrededor de 10 minutos ejecutar los pasos de evaluación.

  1. Configura las siguientes variables de entorno:

    (vm)$ export EVAL_SAMPLES=5000
    
  2. Ejecuta la secuencia de comandos de evaluación:

    (vm)$ python3 /usr/share/models/official/vision/detection/main.py \
          --strategy_type=tpu \
          --tpu=${TPU_NAME} \
          --model_dir=${MODEL_DIR} \
          --mode="eval" \
          --params_override="{ type: retinanet, eval: { val_json_file: ${VAL_JSON_FILE}, eval_file_pattern: ${EVAL_FILE_PATTERN}, eval_samples: ${EVAL_SAMPLES} } }"
    

    Descripciones de las marcas de comandos

    strategy_type
    Para entrenar el modelo RetinaNet en una TPU, debes configurar distribution_strategy en tpu.
    tpu
    El nombre de Cloud TPU. Se configura con la variable de entorno TPU_NAME.
    model_dir
    El directorio en el que se almacenan puntos de control y resúmenes durante el entrenamiento del modelo. Si la carpeta no está, el programa crea una. Cuando se usa una Cloud TPU, el model_dir debe ser una ruta de Cloud Storage (gs://...). Puedes reutilizar una carpeta existente para cargar datos de puntos de control actuales y almacenar puntos de control adicionales siempre que los puntos de control anteriores se hayan creado mediante TPU del mismo tamaño y versión de TensorFlow.
    mode
    Configura model en eval para evaluar el modelo.
    params_override
    Una string JSON que anula los parámetros predeterminados de la secuencia de comandos. Para obtener más información sobre los parámetros de secuencia de comandos, consulta /usr/share/models/official/vision/detection/main.py.

    Al final de la evaluación, verás mensajes similares a los siguientes en la consola:

    Accumulating evaluation results...
    DONE (t=7.66s).
     Average Precision  (AP) @[ IoU=0.50:0.95 | area=   all | maxDets=100 ] = 0.000
     Average Precision  (AP) @[ IoU=0.50      | area=   all | maxDets=100 ] = 0.000
     Average Precision  (AP) @[ IoU=0.75      | area=   all | maxDets=100 ] = 0.000
     Average Precision  (AP) @[ IoU=0.50:0.95 | area= small | maxDets=100 ] = 0.000
     Average Precision  (AP) @[ IoU=0.50:0.95 | area=medium | maxDets=100 ] = 0.000
     Average Precision  (AP) @[ IoU=0.50:0.95 | area= large | maxDets=100 ] = 0.000
     Average Recall     (AR) @[ IoU=0.50:0.95 | area=   all | maxDets=  1 ] = 0.000
     Average Recall     (AR) @[ IoU=0.50:0.95 | area=   all | maxDets= 10 ] = 0.000
     Average Recall     (AR) @[ IoU=0.50:0.95 | area=   all | maxDets=100 ] = 0.000
     Average Recall     (AR) @[ IoU=0.50:0.95 | area= small | maxDets=100 ] = 0.000
     Average Recall     (AR) @[ IoU=0.50:0.95 | area=medium | maxDets=100 ] = 0.000
     Average Recall     (AR) @[ IoU=0.50:0.95 | area= large | maxDets=100 ] = 0.000
    

    En este punto, puedes finalizar este instructivo y limpiar tus recursos de GCP o puedes explorar con más detalle cómo ejecutar el modelo en los pods de Cloud TPU.

Escala tu modelo con pods de Cloud TPU

Puedes obtener resultados más rápidos si escalas tu modelo con pods de Cloud TPU. El modelo RetinaNet totalmente compatible puede funcionar con la porción de pod v2-32:

  1. Borra el recurso de Cloud TPU que creaste a fin de entrenar el modelo en un solo dispositivo.

    (vm)$ ctpu delete --tpu-only --zone=europe-west4-a --name=retinanet-tutorial
  2. Ejecuta el comando ctpu up, con el parámetro tpu-size para especificar el segmento pod que desea usar. Por ejemplo, el comando siguiente usa una porción de pod v2-32.

    (vm)$ ctpu up --tpu-only \
    --tpu-size=v2-32  \
    --zone=europe-west4-a \
    --name=retinanet-tutorial \
    --tf-version=2.3

    Descripciones de las marcas de comandos

    tpu-only
    Crea la Cloud TPU sola. De forma predeterminada, el comando ctpu up crea una VM y una Cloud TPU.
    tpu-size
    El tipo de Cloud TPU que se creará.
    zone
    Es la zona en la que deseas crear la Cloud TPU.
    name
    El nombre de la Cloud TPU para crear.
    tf-version
    La versión de Tensorflow ctpu se instala en la VM.

    Para obtener más información sobre la utilidad de CTPU, consulta la Referencia de CTPU.

  3. Configura la variable de nombre de Cloud TPU. Este será un nombre que establezcas con el parámetro --name o el nombre de usuario predeterminado:

    (vm)$ export TPU_NAME=retinanet-tutorial
    
  4. Configura la siguiente variable de entorno:

    (vm)$ export MODEL_DIR=${STORAGE_BUCKET}/retinanet-pod
    
  5. Ejecuta la secuencia de comandos de entrenamiento del pod en un nodo TPU v3-32:

    La siguiente secuencia de comandos de entrenamiento de muestra se ejecutó en un pod de Cloud TPU v2-32. Se entrena solo en 10 pasos y lleva menos de 5 minutos para ejecutarse. El entrenamiento para la convergencia requiere 2,109 pasos y tarda unos 50 minutos en un pod de TPU v2-32.

    (vm)$  python3 /usr/share/models/official/vision/detection/main.py \
        --strategy_type=tpu \
        --tpu=${TPU_NAME} \
        --model_dir=${MODEL_DIR} \
        --mode="train" \
        --params_override="{ type: retinanet, train: { total_steps: 10, batch_size: 256, checkpoint: { path: ${RESNET_CHECKPOINT}, prefix: resnet50/ }, train_file_pattern: ${TRAIN_FILE_PATTERN} }, eval: { val_json_file: ${VAL_JSON_FILE}, eval_file_pattern: ${EVAL_FILE_PATTERN}, eval_samples: 5000 } }"
    

    Descripciones de las marcas de comandos

    tpu
    Especifica el nombre de Cloud TPU. Se configura con la variable del entorno TPU_NAME.
    model_dir
    Especifica el directorio en el que se almacenan los puntos de control y los resúmenes durante el entrenamiento de modelos. Si la carpeta no existe, el programa crea una. Cuando se usa una Cloud TPU, el model_dir debe ser una ruta de Cloud Storage (gs://...). Puedes reutilizar una carpeta existente para cargar datos de puntos de control actuales y almacenar puntos de control adicionales siempre que los puntos de control anteriores se hayan creado mediante TPU del mismo tamaño y versión de TensorFlow.

Limpia

Sigue estos pasos para evitar que se apliquen cargos a tu cuenta de Google Cloud Platform por los recursos que usaste en este instructivo:

  1. Desconéctate de la VM de Compute Engine:

    (vm)$ exit
    

    El mensaje ahora debería mostrar username@projectname, que indica que estás en Cloud Shell.

  2. En tu VM o Cloud Shell, usa el comando siguiente para borrar tu VM y Cloud TPU:

    $ ctpu delete --name=retinanet-tutorial \
      --zone=europe-west4-a
    
  3. Ejecuta ctpu status y especifica tu zona para asegurarte de no tener instancias asignadas y así evitar cargos innecesarios por el uso de TPU. La eliminación puede tardar varios minutos. Una respuesta como la que se muestra a continuación indica que no hay más instancias asignadas:

    $ ctpu status --name=retinanet-tutorial \
      --zone=europe-west4-a
    
    2018/04/28 16:16:23 WARNING: Setting zone to "europe-west4-a"
    No instances currently exist.
        Compute Engine VM:     --
        Cloud TPU:             --
    
  4. Ejecuta gsutil como se muestra y reemplaza bucket-name por el nombre del depósito de Cloud Storage que creaste para este instructivo:

    $ gsutil rm -r gs://bucket-name
    

¿Qué sigue?

En este instructivo, entrenaste el modelo RetinaNet con un conjunto de datos de muestra. Los resultados de este entrenamiento (en la mayoría de los casos) no se pueden usar para la inferencia. Para usar un modelo de inferencia, puedes entrenar los datos en un conjunto de datos disponible públicamente o en tu propio conjunto de datos. Los modelos entrenados en Cloud TPU requieren que los conjuntos de datos tengan el formato TFRecord.

Puedes usar la muestra de la herramienta de conversión de conjuntos de datos para convertir un conjunto de datos de clasificación de imágenes en formato TFRecord. Si no usas un modelo de clasificación de imágenes, deberás convertir tu conjunto de datos en formato TFRecord tú mismo. Para obtener más información, consulta TFRecord y tf.Example.

Ajuste de hiperparámetros

Para mejorar el rendimiento del modelo con tu conjunto de datos, puedes ajustar los hiperparámetros del modelo. Puedes encontrar información sobre hiperparámetros comunes a todos los modelos compatibles con TPU en GitHub. La información sobre los hiperparámetros específicos del modelo se puede encontrar en el código fuente para cada modelo. Para obtener más información sobre el ajuste de hiperparámetros, consulta Descripción general del ajuste de hiperparámetros, Usa el servicio de ajuste de hiperparámetros y Ajusta los hiperparámetros.

Inferencia

Una vez que entrenaste tu modelo, puedes usarlo para la inferencia (también llamada predicción). AI Platform es una solución basada en la nube que sirve para desarrollar, entrenar e implementar modelos de aprendizaje automático. Una vez que se implementa un modelo, puedes usar el servicio de AI Platform Prediction.

Entrena con diferentes tamaños de imagen

Puedes explorar con una red troncal más grande (por ejemplo, ResNet-101 en lugar de ResNet-50). Una imagen de entrada más grande y una red troncal más potente producirán un modelo más lento, pero más preciso.

Usa una base diferente

De manera alternativa, puedes explorar con el entrenamiento previo de un modelo ResNet en tu propio conjunto de datos y usarlo como base para tu modelo RetinaNet. Con algo más de trabajo, también puedes intercambiar ResNet por una red troncal alternativa. Por último, si estás interesado en implementar tus propios modelos de detección de objetos, esta red puede ser una buena base para experimentar más.