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.

Importante: Configura tu VM de Compute Engine, tu nodo de Cloud TPU y tu depósito Cloud Storage en la misma región/zona para reducir la latencia y los costos de red.

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:

   [e-mail]
   

5. Crea un bucket de Cloud Storage con el siguiente comando:

   Nota: En el siguiente comando, reemplaza bucket-name por el nombre que deseas asignar a tu bucket.

   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.

   Nota: En este instructivo, se usa TensorFlow 1.15.5, que se basa en la imagen de Debian 10 y tiene el valor predeterminado de Python 3.6. Las versiones anteriores de TensorFlow 1.15.x se basaban en Debian 9 y eran predeterminadas de Python 3.5.

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

   Nota: Si no estás conectado a la instancia de Compute Engine, puedes conectarte mediante la ejecución de los siguientes comandos:

   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.

   Nota: En los siguientes comandos, reemplaza bucket-name por el nombre de tu bucket.

   (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

Nota: En el comando de evaluación anterior, eval_timeout se configura como 200, lo que finaliza la evaluación después de 200 segundos. Esto es necesario porque el bucle de evaluación está diseñado para ejecutarse en paralelo con el entrenamiento, en el que se siguen verificando los nuevos puntos de control para la evaluación. Es posible que la secuencia de comandos aparezca en espera si el bucle de evaluación está esperando que se escriba un nuevo punto de control. De forma predeterminada, el bucle de evaluación se detiene después de 50,000 pasos de entrenamiento.

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
   

Nota: Para conocer los límites de almacenamiento gratuito y otra información sobre precios, consulta la guía de precios de Cloud Storage.

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

• Obtén más información sobre ctpu y sobre cómo instalarla en una máquina local.
• Experimenta con más muestras de TPU.
• Explora las herramientas de TPU en TensorBoard.