Ejecuta Deeplab v3 en Cloud TPU

En este instructivo, se muestra cómo entrenar el modelo de Deeplab-v3 en Cloud TPU.

En las siguientes instrucciones, se supone que ya estás familiarizado con la ejecución de un modelo en Cloud TPU. Si es la primera vez que usas 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.

Este es un modelo de segmentación semántica de imágenes. Los modelos de segmentación semántica de imágenes se enfocan en identificar y localizar múltiples objetos en una sola imagen. Este tipo de modelo se usa con frecuencia en aplicaciones de aprendizaje automático, como la conducción autónoma, el procesamiento de imágenes geoespaciales y las imágenes médicas.

En este instructivo, ejecutarás un modelo de entrenamiento con el conjunto de datos de PASCAL VOC 2012. Para obtener más información sobre este conjunto de datos, consulta la página de inicio de las clases de objetos visuales de PASCAL.

Objetivos

  • Crear un bucket de Cloud Storage para almacenar el resultado de tu modelo y tu conjunto de datos
  • Instala los paquetes necesarios.
  • Descarga y convierte el conjunto de datos PASCAL VOC 2012
  • Entrena el modelo de Deeplab
  • Evaluar el modelo de Deeplab

Costos

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

  • Compute Engine
  • Cloud TPU
  • Cloud Storage

Para generar una estimación de costos en función del uso previsto, usa la calculadora de precios. Es posible que los usuarios nuevos de Google Cloud califiquen para obtener una prueba gratuita.

Antes de comenzar

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

  1. Abre una ventana de Cloud Shell.

    Abra Cloud Shell

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

    export PROJECT_ID=project-id
    
  3. Configura la CLI de Google Cloud para usar el proyecto en el que deseas crear Cloud TPU.

    gcloud config set project ${PROJECT_ID}
    

    La primera vez que ejecutes este comando en una VM de Cloud Shell nueva, se mostrará la página Authorize Cloud Shell. Haz clic en Authorize en la parte inferior de la página para permitir que gcloud realice llamadas a la API de GCP con tus credenciales.

  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 bucket de Cloud Storage con el siguiente comando:

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

    Este bucket de Cloud Storage almacena los datos que usas para entrenar tu modelo y los resultados del entrenamiento.

    A fin de que Cloud TPU lea y escriba en el bucket de almacenamiento, la cuenta de servicio de tu proyecto necesita permisos de lectura/escritura o de administrador. Consulta la sección sobre depósitos de almacenamiento para ver y configurar esos permisos.

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

    $ ctpu up --project=${PROJECT_ID} \
     --zone=us-central1-b \
     --machine-type=n1-standard-8 \
     --vm-only \
     --tf-version=1.15.5 \
     --name=deeplab-tutorial
    

    Descripciones de las marcas de comandos

    project
    El ID de tu proyecto de GCP
    zone
    La zona en la que planeas crear tu Cloud TPU.
    machine-type
    El tipo de máquina de la VM de Compute Engine que se creará.
    vm-only
    Crea solo una VM. De forma predeterminada, el comando ctpu up crea una VM y una Cloud TPU.
    tf-version
    La versión de ctpu de TensorFlow se instala en la VM.
    name
    El nombre de la Cloud TPU que se creará.
  7. Aparece la configuración que especificaste. Ingresa y para aprobar o n para cancelar.

  8. 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 deeplab-tutorial --zone=us-central1-b
    

Mientras sigues estas instrucciones, ejecuta cada comando que comience con (vm)$ en la ventana de sesión de VM.

Instala paquetes adicionales

Para este modelo, necesitas instalar los siguientes paquetes adicionales en tu instancia de Compute Engine:

  • jupyter
  • matplotlib
  • PrettyTable
  • tf_slim
  (vm)$ pip3 install --user jupyter
  (vm)$ pip3 install --user matplotlib
  (vm)$ pip3 install --user PrettyTable
  (vm)$ pip3 install --user tf_slim
  1. Crea variables de entorno para el bucket de almacenamiento y el nombre de la TPU.

    (vm)$ export STORAGE_BUCKET=gs://bucket-name
    
    (vm)$ export TPU_NAME=deeplab-tutorial
    (vm)$ export DATA_DIR=${STORAGE_BUCKET}/deeplab_data
    (vm)$ export MODEL_DIR=${STORAGE_BUCKET}/deeplab_model
    (vm)$ export PYTHONPATH=${PYTHONPATH}:/usr/share/models/research:/usr/share/models/research/slim
    

Prepara el conjunto de datos

  1. Descarga y convierte el conjunto de datos PASCAL VOC 2012

    Este modelo usa el conjunto de datos PASCAL VOC 2012 para el entrenamiento y evaluación. Ejecuta la siguiente secuencia de comandos para descargar el conjunto de datos y convertirlo al formato TFRecord de TensorFlow:

     (vm)$ bash /usr/share/models/research/deeplab/datasets/download_and_convert_voc2012.sh
    
  2. Descarga el punto de control previamente entrenado

    En este paso, debes descargar un punto de control previamente entrenado de resnet 101 modificado. Para empezar, descarga el punto de control:

     (vm)$ wget http://download.tensorflow.org/models/resnet_v1_101_2018_05_04.tar.gz
    

    Luego, extrae el contenido del archivo tar:

     (vm)$ tar -vxf resnet_v1_101_2018_05_04.tar.gz
    
  3. Sube datos a tu bucket de Cloud Storage

    Ahora, podrás subir tus datos al bucket de Cloud Storage que creaste con anterioridad:

    (vm)$ gsutil -m cp -r pascal_voc_seg/tfrecord ${DATA_DIR}/tfrecord
    
    (vm)$ gsutil -m cp -r resnet_v1_101 ${DATA_DIR}
    

Crea un recurso de Cloud TPU

Ejecuta el siguiente comando para crear tu Cloud TPU.

  (vm)$ ctpu up --project=${PROJECT_ID} \
  --tpu-only \
  --tf-version=1.15.5 \
  --tpu-size=v3-8 \
  --name=deeplab-tutorial

Entrena el modelo

Ejecuta la secuencia de comandos de entrenamiento para 2,000 pasos de entrenamiento. Este proceso tardará unos 20 minutos. Para ejecutarse hasta la convergencia, quita la marca --train_steps=2000 de la línea de comandos de la secuencia de comandos de entrenamiento. Ejecutar hasta la convergencia lleva alrededor de 10 horas.

(vm)$ python3 /usr/share/tpu/models/experimental/deeplab/main.py \
--mode='train' \
--num_shards=8 \
--alsologtostderr=true \
--model_dir=${MODEL_DIR} \
--dataset_dir=${DATA_DIR}/tfrecord \
--init_checkpoint=${DATA_DIR}/resnet_v1_101/model.ckpt \
--model_variant=resnet_v1_101_beta \
--image_pyramid=1. \
--aspp_with_separable_conv=false \
--multi_grid=1 \
--multi_grid=2 \
--multi_grid=4 \
--decoder_use_separable_conv=false \
--train_split='train' \
--train_steps=2000 \
--tpu=${TPU_NAME}

Evaluar el modelo en un dispositivo de Cloud TPU

Una vez finalizado el entrenamiento, puedes evaluar el modelo. Para hacerlo, cambia la marca --mode de train a eval:

(vm)$ python3 /usr/share/tpu/models/experimental/deeplab/main.py \
--mode='eval' \
--num_shards=8 \
--alsologtostderr=true \
--model_dir=${MODEL_DIR} \
--dataset_dir=${DATA_DIR}/tfrecord \
--init_checkpoint=${DATA_DIR}/resnet_v1_101/model.ckpt \
--model_variant=resnet_v1_101_beta \
--image_pyramid=1. \
--aspp_with_separable_conv=false \
--multi_grid=1 \
--multi_grid=2 \
--multi_grid=4 \
--decoder_use_separable_conv=false \
--train_split='train' \
--tpu=${TPU_NAME} \
--eval_timeout=200

Limpia

Para evitar que se apliquen cargos a tu cuenta de Google Cloud por los recursos usados en este instructivo, borra el proyecto que contiene los recursos o conserva el proyecto y borra los recursos individuales.

  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 Cloud Shell, ejecuta ctpu delete con la marca --zone que usaste cuando configuraste la Cloud TPU para borrar la VM de Compute Engine y la Cloud TPU:

    $ ctpu delete --project=${PROJECT_ID} \
      --zone=us-central1-b \
      --name=deeplab-tutorial
    
  3. Ejecuta ctpu status para asegurarte de no tener instancias asignadas y así evitar cargos innecesarios por el uso de TPU. La eliminación puede tomar varios minutos. Una respuesta como la que se muestra a continuación indica que no hay más instancias asignadas:

    $ ctpu status --project=${PROJECT_ID} \
      --name=deeplab-tutorial \
      --zone=us-central1-b
    
    2018/04/28 16:16:23 WARNING: Setting zone to "us-central1-b"
    No instances currently exist.
            Compute Engine VM:     --
            Cloud TPU:             --
    
  4. Ejecuta gsutil como se muestra y reemplaza bucket-name por el nombre del bucket de Cloud Storage que creaste para este instructivo:

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

¿Qué sigue?

Los instructivos de TensorFlow Cloud TPU suelen entrenar el modelo con un conjunto de datos de muestra. Los resultados de este entrenamiento no se pueden usar para la inferencia. Si quieres usar un modelo para la inferencia, puedes entrenar los datos en un conjunto de datos público o en tu propio conjunto de datos. Por lo general, los modelos de TensorFlow 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 tú mismo el conjunto de datos en formato TFRecord. 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 para 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.