Ejecuta Inception en Cloud TPU

Configúralo en 1 para que se muestre el bloque de limpieza #}

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

Renuncia de responsabilidad

En este instructivo se utiliza un conjunto de datos de terceros. Google no hace ninguna declaración ni entrega garantía alguna acerca de la validez o cualquier otro aspecto de este conjunto de datos.

Descripción del modelo

Inception v3 es un modelo de reconocimiento de imágenes muy utilizado que puede alcanzar una exactitud considerable. El modelo representa la culminación de muchas ideas que desarrollaron varios investigadores durante años. Se basa en el documento original "Rethinking the Inception Architecture for Computer Vision" (Reformulación de la arquitectura de Inception para la visión artificial) de Szegedy y otros.

El modelo tiene una combinación de bloques de compilación simétricos y asimétricos, que incluyen los siguientes elementos:

convolutions (convoluciones)
average pooling (reducción promedio)
max pooling (reducción máxima)
concats (concatenaciones)
dropouts (retiradas)
fully connected layers (capas completamente conectadas)

Las pérdidas se calculan a través de Softmax.

En la siguiente imagen, se ve el modelo en un nivel alto:

Puedes encontrar más información acerca del modelo en GitHub.

El modelo se compila con la API de Estimator de alto nivel.

Esta API simplifica considerablemente la creación de modelos, ya que encapsula la mayoría de las funciones de bajo nivel, lo que permite a los usuarios enfocarse en el desarrollo del modelo y no en el funcionamiento interno del hardware subyacente que lleva a cabo la ejecución.

Objetivos

Crear un depósito de Cloud Storage para almacenar el resultado de tu modelo y tu conjunto de datos
Ejecutar el trabajo de entrenamiento
Verificar los resultados de salida

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.

Es posible que los usuarios nuevos de Google Cloud califiquen para obtener una prueba gratuita.

Antes de comenzar

Antes de comenzar este instructivo, verifica que tu proyecto de Google Cloud esté configurado correctamente.

Accede a tu Cuenta de Google.
Si todavía no tienes una cuenta, regístrate para obtener una nueva.

En la página de selección de proyectos de Cloud Console, selecciona o crea un proyecto de Cloud.

Nota: Si no planeas conservar los recursos que creaste durante este procedimiento, crea un proyecto en lugar de seleccionar uno existente. Cuando termines, puedes borrar el proyecto y quitar todos los recursos asociados con él.

Ir a la página Selector de proyectos

Asegúrate de que la facturación esté habilitada para tu proyecto de Google Cloud. Obtén información sobre cómo confirmar que tienes habilitada la facturación para tu proyecto.

En esta explicación, se usan componentes facturables de Google Cloud. Consulta la página de precios de Cloud TPU para calcular los costos. Asegúrate de limpiar los recursos que crees cuando hayas terminado de usarlos para evitar cargos innecesarios.

Configura tus recursos

En esta sección, se proporciona información sobre cómo configurar los recursos de Cloud Storage, VM y Cloud TPU para instructivos.

Abre una ventana de Cloud Shell.

Abre Cloud Shell
Crea una variable para el ID de tu proyecto.
```
export PROJECT_ID=project-id
```
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}
```
Crea un depósito de Cloud Storage con el siguiente comando: Reemplaza bucket-name por un nombre para tu depósito.
```
gsutil mb -p ${PROJECT_ID} -c standard -l us-central1 -b on gs://bucket-name
```
En este depósito de Cloud Storage se almacenan los datos que usas para entrenar tu modelo y los resultados del entrenamiento. La herramienta ctpu up que se usa en este instructivo configura los permisos predeterminados para la cuenta de servicio de Cloud TPU. Si quieres contar con permisos más detallados, revisa los permisos de nivel de acceso.

La ubicación del depósito debe estar en la misma región que tu máquina virtual (VM) y tu nodo TPU. Las VM y los nodos TPU se encuentran en zonas específicas, que son subdivisiones dentro de una región.
Inicia los recursos de Compute Engine necesarios para este instructivo con el comando ctpu up.
```
ctpu up --zone=us-central1-b \
  --vm-only \
  --machine-type=n1-standard-8 \
  --tf-version=1.15.3 \
  --name=inception-tutorial
```
Para obtener más información sobre la utilidad de CTPU, consulta la Referencia de CTPU.
Cuando se te solicite, presiona y a fin de crear tus recursos de Cloud TPU.
Nota: La primera vez que ejecutas ctpu up en un proyecto, tarda unos 5 minutos en realizar las tareas de inicio, como la propagación de llaves SSH y la activación de la API.
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. Si no estás conectado a la instancia de Compute Engine, puedes hacerlo mediante la ejecución del siguiente comando:
```
gcloud compute ssh inception-tutorial --zone=us-central1-b
```
A partir de este momento, el prefijo (vm)$ indica que debes ejecutar el comando en la instancia de VM de Compute Engine.
Crea una variable de entorno para el depósito de almacenamiento. Reemplaza bucket-name por el nombre del depósito de Cloud Storage.
```
(vm)$ export STORAGE_BUCKET=gs://bucket-name
```
Crea una variable de entorno para el nombre de la TPU.
```
(vm)$ export TPU_NAME=inception-tutorial
```

Conjunto de datos de entrenamiento

La aplicación de entrenamiento espera que tus datos de entrenamiento sean accesibles en Cloud Storage. La aplicación de entrenamiento también usa tu depósito de Cloud Storage para almacenar puntos de control durante el entrenamiento.

ImageNet es una base de datos de imágenes. Las imágenes de la base de datos están organizadas en forma jerárquica, y cada nodo está representado por cientos y miles de imágenes.

En este instructivo, se usa una versión de demostración del conjunto de datos completo de ImageNet, denominado fake_imagenet. Esta versión de demostración te permite probar el instructivo, sin necesitar el almacenamiento o el tiempo requerido para descargar y ejecutar un modelo en la base de datos completa de ImageNet. A continuación, se encuentran las instrucciones a fin de usar el conjunto de datos fake_imagenet generado de forma aleatoria para probar el modelo. Como alternativa, puedes usar el conjunto de datos de ImageNet completo.

Se usa la variable de entorno DATA_DIR que se describe a continuación para especificar qué conjunto de datos se usará en el entrenamiento.

Ten en cuenta que el conjunto de datos fake_imagenet solo sirve para comprender cómo usar Cloud TPU y validar el rendimiento de extremo a extremo. Los números de exactitud y el modelo guardado no serán significativos.

El conjunto de datos fake_imagenet se encuentra en esta ubicación de Cloud Storage:

gs://cloud-tpu-test-datasets/fake_imagenet

Configura TensorBoard (opcional)

TensorBoard ofrece un paquete de herramientas diseñado para presentar los datos de TensorFlow visualmente. Cuando se lo utiliza en la supervisión, TensorBoard puede servir para identificar cuellos de botella en el procesamiento y sugerir formas de mejorar el rendimiento.

Si no necesitas supervisar los resultados del modelo en este momento, puedes omitir los pasos de configuración de TensorBoard.

Si deseas supervisar los resultados y el rendimiento del modelo, sigue la guía sobre cómo configurar TensorBoard.

Ejecuta el modelo

Ya estás listo para entrenar y evaluar el modelo de Inception v3 con el conjunto de datos de ImageNet.

El modelo Inception v4 está preinstalado en tu VM de Compute Engine, en el directorio /usr/share/tpu/models/experimental/inception/.

En los pasos que siguen, el prefijo (vm)$ indica que debes ejecutar el comando en la VM de Compute Engine:

Configura una variable del entorno DATA_DIR que contenga uno de los siguientes valores:
- Si usas el conjunto de datos fake_imagenet, ingresa el valor siguiente:
```
(vm)$ export DATA_DIR=gs://cloud-tpu-test-datasets/fake_imagenet
```
- Si subiste un conjunto de datos de entrenamiento en tu depósito de Cloud Storage:
```
(vm)$ export DATA_DIR=${STORAGE_BUCKET}/data
```
Ejecuta el modelo de Inception v3:
```
(vm)$ python /usr/share/tpu/models/experimental/inception/inception_v3.py \
    --tpu=$TPU_NAME \
    --learning_rate=0.165 \
    --train_steps=250000 \
    --iterations=500 \
    --use_tpu=True \
    --use_data=real \
    --mode=train_and_eval \
    --train_steps_per_eval=2000 \
    --data_dir=${DATA_DIR} \
    --model_dir=${STORAGE_BUCKET}/inception
```
- --tpu especifica el nombre de Cloud TPU. Ten en cuenta que ctpu pasa este nombre a la VM de Compute Engine como una variable de entorno (TPU_NAME).
- --use_data especifica qué tipo de datos debe usar el programa durante el entrenamiento, el falso o el real. El valor predeterminado es el falso.
- --data_dir especifica la ruta de Cloud Storage para la entrada de entrenamiento. La aplicación ignora este parámetro cuando usas datos de fake_imagenet.
- --model_dir especifica el directorio en el cual se almacenan puntos de control y resúmenes durante el entrenamiento del modelo. 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.

Próximos pasos

Inception v3 funciona con imágenes de 299x299. El tamaño del lote de entrenamiento predeterminado es 1024, lo que significa que cada iteración opera en 1024 de esas imágenes.

Puedes usar la marca --mode para seleccionar uno de los tres modos de operación: train, eval y train_and_eval:

--mode=train o --mode=eval especifican si se trata de un trabajo de solo entrenamiento o de solo evaluación.
--mode=train_and_eval especifica que se trata de un trabajo híbrido que se ocupa del entrenamiento y la evaluación.

Los trabajos de solo entrenamiento se ejecutan durante la cantidad de pasos definida en train_steps y pueden abarcar el conjunto de entrenamiento completo si lo deseas.

Los trabajos de train_and_eval alternan entre segmentos de entrenamiento y evaluación. Cada ciclo de entrenamiento se ejecuta por train_steps_per_eval. Luego, sigue un trabajo de evaluación, que usa los pesos que se entrenaron hasta ese momento.

La cantidad de ciclos de entrenamiento se define mediante la función floor de train_steps dividida por train_steps_per_eval.

floor(train_steps / train_steps_per_eval)

De manera predeterminada, los modelos basados en la API de Estimator generan un informe sobre los valores de pérdida cada cierta cantidad de pasos. El informe tendrá el siguiente formato:

step = 15440, loss = 12.6237

Debate: modificaciones en el modelo específicas de TPU

Las modificaciones específicas necesarias para que los modelos basados en la API de Estimator sean aceptables en TPU son inesperadamente pocas. El programa importa las siguientes bibliotecas:

from google.third_party.tensorflow.contrib.tpu.python.tpu import tpu_config
from google.third_party.tensorflow.contrib.tpu.python.tpu import tpu_estimator
from google.third_party.tensorflow.contrib.tpu.python.tpu import tpu_optimizer

La función CrossShardOptimizer une el optimizador, como se muestra en el siguiente ejemplo:

if FLAGS.use_tpu:
  optimizer = tpu_optimizer.CrossShardOptimizer(optimizer)

La función que define el modelo muestra una especificación de Estimator por medio de los siguientes comandos:

return tpu_estimator.TPUEstimatorSpec(
    mode=mode, loss=loss, train_op=train_op, eval_metrics=eval_metrics)

La función principal define una configuración compatible con Estimator por medio de los siguientes comandos:

run_config = tpu_config.RunConfig(
    master=tpu_grpc_url,
    evaluation_master=tpu_grpc_url,
    model_dir=FLAGS.model_dir,
    save_checkpoints_secs=FLAGS.save_checkpoints_secs,
    save_summary_steps=FLAGS.save_summary_steps,
    session_config=tf.ConfigProto(
        allow_soft_placement=True,
        log_device_placement=FLAGS.log_device_placement),
    tpu_config=tpu_config.TPUConfig(
        iterations_per_loop=iterations,
        num_shards=FLAGS.num_shards,
        per_host_input_for_training=per_host_input_for_training))

El programa usa esta configuración definida y una función de definición del modelo para crear un objeto de Estimator:

inception_classifier = tpu_estimator.TPUEstimator(
    model_fn=inception_model_fn,
    use_tpu=FLAGS.use_tpu,
    config=run_config,
    params=params,
    train_batch_size=FLAGS.train_batch_size,
    eval_batch_size=eval_batch_size,
    batch_axis=(batch_axis, 0))

Los trabajos de solo entrenamiento solo necesitan llamar a la función de entrenamiento:

inception_classifier.train(
    input_fn=imagenet_train.input_fn, steps=FLAGS.train_steps)

Los trabajos de solo evaluación obtienen sus datos de puntos de control disponibles y esperan a que se habilite uno nuevo:

for checkpoint in get_next_checkpoint():
  eval_results = inception_classifier.evaluate(
      input_fn=imagenet_eval.input_fn,
      steps=eval_steps,
      hooks=eval_hooks,
      checkpoint_path=checkpoint)

Cuando eliges la opción train_and_eval, los trabajos de entrenamiento y de evaluación se ejecutan en paralelo. Durante la evaluación, se cargan las variables entrenables desde el último punto de control disponible. Los ciclos de entrenamiento y de evaluación se repiten según lo que especifiques en las marcas:

for cycle in range(FLAGS.train_steps // FLAGS.train_steps_per_eval):
  inception_classifier.train(
      input_fn=imagenet_train.input_fn, steps=FLAGS.train_steps_per_eval)

  eval_results = inception_classifier.evaluate(
      input_fn=imagenet_eval.input_fn, steps=eval_steps, hooks=eval_hooks)

Si usaste el conjunto de datos fake_imagenet para entrenar el modelo, debes realizar una limpieza.

Usa el conjunto de datos completo de ImageNet

El conjunto de datos de ImageNet consta de tres partes: datos de entrenamiento, datos de validación y etiquetas de imagen.

Los datos de entrenamiento contienen 1,000 categorías y 1.2 millones de imágenes, todo esto empaquetado para que se pueda descargar con facilidad. Los datos de validación y de prueba no se encuentran en los datos de entrenamiento de ImageNet (se quitaron los duplicados).

Los datos de validación y prueba constan de 150,000 fotos, recopiladas de Flickr y otros motores de búsqueda, etiquetados a mano con la presencia o ausencia de 1,000 categorías de objetos. Las 1,000 categorías de objetos contienen nodos internos y nodos de hoja de ImageNet, pero no se superponen entre sí. Se lanzó un subconjunto aleatorio de 50,000 imágenes con etiquetas como datos de validación junto con una lista de las 1,000 categorías. Las imágenes restantes se usan para la evaluación y se publicaron sin etiquetas.

Pasos para procesar previamente el conjunto de datos ImageNet completo

Hay cinco pasos a fin de preparar el conjunto de datos ImageNet completo para que lo use un modelo de aprendizaje automático:

Verifica que tengas espacio en el destino de descarga.
Configura los directorios de destino.
Regístrate en el sitio de ImageNet y solicita permiso de descarga.
Descarga el conjunto de datos en el disco local o en la VM de Compute Engine.

Nota: La descarga a una VM de Compute Engine mediante Cloud Shell tarda mucho más que hacerlo en tu máquina local (aproximadamente 40 horas en comparación con 7 horas). Sin embargo, si descargas a una máquina local, debes copiar los archivos a una VM de Compute Engine para procesarlos previamente y subirlos a Cloud Storage antes de usarlos a fin de ejecutar tu modelo. Copiar todos los archivos de entrenamiento y validación desde tu máquina local a la VM lleva aproximadamente 13 horas. El enfoque menos complicado y que se recomienda es descargar en la VM.
Ejecuta la secuencia de comandos de procesamiento previo y carga.

Verifica los requisitos de espacio

Ya sea que descargues el conjunto de datos en tu máquina local o en una VM de Compute Engine, necesitarás alrededor de 300 GB de espacio disponible en el destino de descarga. En una VM, puedes verificar el almacenamiento disponible con el comando df -ha.

Puedes aumentar el tamaño del disco de VM mediante uno de los siguientes métodos:

Especifica la marca --disk-size-gb en la línea de comandos de ctpu up con el tamaño, en GB, que desees asignar.
Sigue la guía de Compute Engine para agregar un disco a la VM.
- Configura Cuando se borra la instancia en Borrar disco a fin de garantizar que se quite el disco cuando eliminas la VM.
- Anota la ruta de acceso al disco nuevo. Por ejemplo: /mnt/disks/mnt-dir.

Configura los directorios de destino

En tu máquina local o VM de Compute Engine, configura la estructura de directorios para almacenar los datos descargados.

Crea y exporta un directorio de inicio para el conjunto de datos ImageNet.

Crea un directorio, por ejemplo, imagenet en tu directorio principal de tu VM o máquina local. En este directorio, crea dos subdirectorios: train y validation. Exporta el directorio principal como IMAGENET_HOME:
```
export IMAGENET_HOME=~/imagenet
```

Regístrate y solicita permiso para descargar el conjunto de datos

Regístrate en el sitio web de Imagenet. No puedes descargar el conjunto de datos hasta que ImageNet confirme tu registro y te envíe un correo electrónico de confirmación. Si no recibes el correo electrónico de confirmación en un par de días, comunícate con el equipo de asistencia de ImageNet para ver por qué no se confirmó tu registro. Después de confirmar tu registro, ve al sitio de descarga.

Descarga el conjunto de datos ImageNet

Desde el sitio de descarga, ve a la sección Imágenes en la página y haz clic derecho en “Imágenes de entrenamiento (tarea 1 y 2)”. Esto te dará la URL necesaria para descargar la parte más grande del conjunto de entrenamiento. Guarda la URL.

Haz clic derecho en “Imágenes de entrenamiento (tarea 3)” para obtener la URL del segundo conjunto de entrenamiento. Guarda la URL.

Haz clic derecho en “Validation images (all tasks)” para obtener la URL del conjunto de datos de validación. Guarda la URL.

Si descargas los archivos de ImageNet en tu máquina local, después de que se complete la descarga, deberás copiar los directorios en tu máquina local al directorio $IMAGENET_HOME correspondiente de tu VM de Compute Engine. Copiar el conjunto de datos de ImageNet de un host local a tu VM lleva aproximadamente 13 horas.

Por ejemplo, el siguiente comando copia todos los archivos de $IMAGENET_HOME de tu máquina local a tu VM que muestra el mensaje de shell username@vm-name:
```
gcloud compute scp --recurse $IMAGENET_HOME username@vm-name:~/imagenet
```
Desde $IMAGENET_HOME, usa wget para descargar los archivos de entrenamiento y validación con las URL guardadas.

El archivo “Imágenes de entrenamiento (tarea 1 y 2)” es el gran conjunto de entrenamiento. Es de 138 GB. Si se descarga en una VM de Compute Engine con Cloud Shell, el tiempo estimado de descarga es de aproximadamente 40 horas. Para este archivo particularmente grande, puedes anteponer nohup en el comando o usar screen para evitar que se interrumpa la descarga si Cloud Shell se desconecta.
```
cd $IMAGENET_HOME \
nohup wget http://image-net.org/challenges/LSVRC/2012/dd31405981ef5f776aa17412e1f0c112/ILSVRC2012_img_train.tar
```
Así se descarga un archivo tar grande: ILSVRC2012_img_train.tar.

Desde $IMAGENET_HOME en la VM, extrae los directorios de entrenamiento individuales en el directorio $IMAGENET_HOME/train con el siguiente comando. La extracción toma entre 1 y 3 horas.
```
tar xf ILSVRC2012_img_train.tar
```
El archivo “Imágenes de entrenamiento (tarea 3)” es de 728 MB, así que solo toma unos minutos en descargarse, por lo que no necesitas tomar precauciones por si pierdes la conexión de Cloud Shell.

Cuando descargas este archivo, se extraen los directorios de entrenamiento individuales en el directorio $IMAGENET_HOME/train existente.
```
wget http://www.image-net.org/challenges/LSVRC/2012/dd31405981ef5f776aa17412e1f0c112/ILSVRC2012_img_train_t3.tar
```
El archivo “Imágenes de validación (todas las tareas)” es de 6 GB, por lo que te recomendamos usar nohup o screen para evitar la interrupción de la descarga si Cloud Shell se desconecta.
```
wget http://www.image-net.org/challenges/LSVRC/2012/dd31405981ef5f776aa17412e1f0c112/ILSVRC2012_img_val.tar
```
Esta descarga demora aproximadamente 30 minutos. Cuando descargas este archivo, se extraen los directorios de validación individuales en el directorio $IMAGENET_HOME/validation.

Si descargaste los archivos de validación en tu máquina local, debes copiar el directorio $IMAGENET_HOME/validation en tu máquina local en el directorio $IMAGENET_HOME/validation en la VM de Compute Engine. Esta operación de copia demora alrededor de 30 minutos.

Descarga el archivo de etiquetas. Esto solo toma unos segundos.
```
wget -O $IMAGENET_HOME/synset_labels.txt \
https://raw.githubusercontent.com/tensorflow/models/master/research/inception/inception/data/imagenet_2012_validation_synset_labels.txt
```
Si descargaste el archivo de etiquetas en tu máquina local, debes copiarlo en el directorio $IMAGENET_HOME en tu máquina local en $IMAGENET_HOME en tu VM de Compute Engine. Esta operación de copia toma unos segundos.

Los nombres de los subdirectorios de entrenamiento (por ejemplo, n03062245) son “ID de WordNet” (wnid). La API de ImageNet muestra la asignación de ID de WordNet a sus etiquetas de validación asociadas en el archivo synset_labels.txt. Un synset en este contexto es un grupo de imágenes visualmente similares.

Procesa el conjunto de datos de Imagenet y, de manera opcional, súbelo a Cloud Storage

Descarga la secuencia de comandos de imagenet_to_gcs.py desde GitHub:

wget https://raw.githubusercontent.com/tensorflow/tpu/master/tools/datasets/imagenet_to_gcs.py

Si subes el conjunto de datos a Cloud Storage, especifica la ubicación del depósito de almacenamiento para subir el conjunto de datos de ImageNet:
```
export STORAGE_BUCKET=gs://bucket-name
```
Si subes el conjunto de datos a Cloud Storage, especifica un directorio de datos de depósito de almacenamiento para almacenar el conjunto de datos:
```
(vm)$ export DATA_DIR=$STORAGE_BUCKET/dataset-directory
```
Ejecuta la secuencia de comandos para procesar previamente el conjunto de datos sin procesar como TFRecords y subirlo a Cloud Storage con el siguiente comando:
Nota: Si no deseas subir archivos a Cloud Storage, especifica --nogcs_upload como otro parámetro y no incluyas los parámetros --project ni --gcs_outpu_path.
```
 python3 imagenet_to_gcs.py \
  --project=$PROJECT \
  --gcs_output_path=$DATA_DIR  \
  --raw_data_dir=$IMAGENET_HOME \
  --local_scratch_dir=$IMAGENET_HOME/tf_records
```

La secuencia de comandos genera un conjunto de directorios (para entrenamiento y validación), como los que se muestran a continuación:

${DATA_DIR}/train-00000-of-01024
${DATA_DIR}/train-00001-of-01024
 ...
${DATA_DIR}/train-01023-of-01024

${DATA_DIR}/validation-00000-of-00128
S{DATA_DIR}/validation-00001-of-00128
 ...
${DATA_DIR}/validation-00127-of-00128

Una vez que los datos se hayan subido a tu depósito de Cloud, ejecuta tu modelo y configura --data_dir=${DATA_DIR}.

Realiza una limpieza

Para evitar que se apliquen cargos a tu cuenta de GCP por los recursos usados en este tema, realiza los siguientes pasos:

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.
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 [optional: --zone]
```
Importante: Si estableciste el nombre de los recursos TPU cuando ejecutaste ctpu up, debes especificar ese nombre con la marca --name cuando ejecutes ctpu delete para cerrar los recursos TPU.
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 --zone=europe-west4-a
```
```
2018/04/28 16:16:23 WARNING: Setting zone to "--zone=europe-west4-a"
No instances currently exist.
    Compute Engine VM:     --
    Cloud TPU:             --
```
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
```

Inception v4

El modelo de Inception v4 es un modelo de red neuronal profunda que usa los bloques de compilación de Inception v3 para alcanzar una mayor exactitud que Inception v3. Se describe en el artículo "Inception-v4, Inception ResNet and the Impact of Residual Connections on Learning" (Inception-v4, Inception Res-Net y el impacto de las conexiones residuales en el aprendizaje) de Szegedy y otros.

El modelo Inception v4 está preinstalado en tu VM de Compute Engine, en el directorio /usr/share/tpu/models/experimental/inception/.

En los pasos que siguen, el prefijo (vm)$ indica que debes ejecutar el comando en la VM de Compute Engine:

Si estás ejecutando TensorBoard en tu pestaña de Cloud Shell, necesitas trabajar en otra pestaña. Abre otra pestaña en tu Cloud Shell y usa ctpu en el shell nuevo para conectarte a tu VM de Compute Engine:
```
$ ctpu up
```
Configura una variable del entorno DATA_DIR que contenga uno de los siguientes valores:
- Si usas el conjunto de datos fake_imagenet, ingresa el valor siguiente:
```
(vm)$ export DATA_DIR=gs://cloud-tpu-test-datasets/fake_imagenet
```
- Si subiste un conjunto de datos de entrenamiento en tu depósito de Cloud Storage:
```
(vm)$ export DATA_DIR=${STORAGE_BUCKET}/data
```
Ejecuta el modelo de Inception v4:
```
(vm)$ python /usr/share/tpu/models/experimental/inception/inception_v4.py \
    --tpu=$TPU_NAME \
    --learning_rate=0.36 \
    --train_steps=1000000 \
    --iterations=500 \
    --use_tpu=True \
    --use_data=real \
    --train_batch_size=256 \
    --mode=train_and_eval \
    --train_steps_per_eval=2000 \
    --data_dir=${DATA_DIR} \
    --model_dir=${STORAGE_BUCKET}/inception
```
- --tpu especifica el nombre de Cloud TPU. Ten en cuenta que ctpu pasa este nombre a la VM de Compute Engine como una variable de entorno (TPU_NAME).
- --use_data especifica qué tipo de datos debe usar el programa durante el entrenamiento, el falso o el real. El valor predeterminado es el falso.
- --train_batch_size especifica que el tamaño del lote de entrenamiento será 256. Como el modelo de Inception v4 es mayor que Inception v3, debe ejecutarse con un tamaño de lote menor por núcleo TPU.
- --data_dir especifica la ruta de Cloud Storage para la entrada de entrenamiento. La aplicación ignora este parámetro cuando usas datos de fake_imagenet.
- --model_dir especifica el directorio en el cual se almacenan puntos de control y resúmenes durante el entrenamiento del modelo. 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.

Limpieza

¿Qué sigue?

## Qué sigue {: #whats-next } En este instructivo, entrenaste el modelo de Inception con un conjunto de datos de muestra. Los resultados de esta capacitación (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 al 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 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 de 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.

Profundiza tus conocimientos con la vista avanzada de Inception v3 en Cloud TPU.
Obtén más información sobre ctpu y sobre cómo instalarla en una máquina local.
Explora las herramientas de TPU en TensorBoard.