Clasificación de imágenes con Google Coral

Introducción

En este proyecto, reentrenarás un modelo de aprendizaje automático (machine learning) utilizando un Coral TPU y, posteriormente, lo usarás para reconocer imágenes.

En este proyecto lograrás lo siguiente:

• Reentrenar un modelo de aprendizaje automático para que sea capaz de reconocer nuevas categorías de imágenes.

• Utilizar una Unidad de Procesamiento Tensorial (TPU) Coral para clasificar imágenes de manera rápida y eficiente.

• Tener la oportunidad de participar en la competencia Mission Space Lab y ejecutar tus propios algoritmos de aprendizaje automático en la Estación Espacial Internacional.

Configura Coral y reúne tus imágenes

Hay muchos modelos de aprendizaje automático que han sido entrenados para identificar diferentes clases de imágenes. Estos pueden ser reentrenados fácilmente para identificar nuevas clases.

En tu Raspberry Pi, a menos que estés ejecutando un AstroPi Kit OS, necesitarás instalar el software necesario para usar tu Coral TPU con Python. Si estás ejecutando el AstroPi Kit OS, deberías omitir este paso.

Con tu configuración de Raspberry Pi y tu Coral TPU desconectado, puedes abrir una terminal y ejecutar el siguiente comando. Esto instalará la librería de Python de Coral y sus dependencias.

wget -O - https://raw.githubusercontent.com/raspberrypilearning/image-id-coral/master/en/resources/install_script.sh 

¿Qué hay en ese script?

echo "deb https://packages.cloud.google.com/apt coral-edgetpu-stable main" | sudo tee /etc/apt/sources.list.d/coral-edgetpu.list
curl https://packages.cloud.google.com/apt/doc/apt-key.gpg | sudo apt-key add -
sudo apt-get update
sudo apt-get install libedgetpu1-std python3-pycoral -y

Una vez que el software haya sido instalado, puedes conectar tu dispositivo Coral a uno de los puertos USB. Recomendamos los puertos USB 3, los cuales puedes identificar porque son azules.

Puedes elegir reentrenar un modelo de aprendizaje automático de dos maneras diferentes, ya sea en tu computadora usando un script de Python o usando el sitio Teachable Machine de Google.

De cualquier manera, necesitarás un conjunto de imágenes clasificadas para comenzar. La forma más sencilla de clasificar imágenes es moverlas a directorios con nombre, donde el nombre del directorio es el nombre de la clase. Querrás tener algunas imágenes en un directorio separado para realizar pruebas.

Puedes crear directorios en tu computadora para todas tus diferentes clases de imágenes y mover manualmente tus colecciones de imágenes a los directorios.

Alternativamente, puedes descargar un conjunto de imágenes capturadas desde la ISS aquí que ya han sido clasificadas.

¿Cómo fueron tomadas estas imágenes?

Los conjuntos de imágenes disponibles para descargar han sido capturados utilizando una computadora Astro Pi en la ISS (Estación Espacial Internacional), a la cual hemos apodado “Izzy”.

Izzy tiene acoplada una cámara de infrarrojo cercano (near-infrared), la cual está orientada hacia la Tierra a través de una de las ventanas de la estación espacial.

Las imágenes obtenidas han sido clasificadas en tres categorías o clases: día, noche y crepúsculo. Además, se ha reservado un grupo de imágenes aparte para ser utilizadas exclusivamente en las pruebas (testing) del modelo.

A veces es muy útil saber si la ISS está pasando en ese momento por el día, la noche o el crepúsculo, ya que esto puede influir directamente en otras mediciones o experimentos que se estén realizando. Por lo tanto, entrenar un modelo para clasificar estas imágenes de forma automática resulta de gran utilidad.

Te enseñaremos a Reentrenar tu modelo tanto de forma Online como Offline.

Reentrena un modelo en línea con Teachable Machine

Teachable Machine te permite reentrenar fácilmente un modelo de reconocimiento de imágenes subiendo a su sitio imágenes que han sido clasificadas en categorías y usando sus servicios en la nube para crear un nuevo modelo.

• En una ventana del navegador, navega al sitio web de Teachable Machine.

• Haz clic en el botón Get Started (Empezar).
• Elige crear un Image Project (Proyecto de imagen).

Repite este paso para tus otros directorios de imágenes.

Haz clic en el botón Train Model para reentrenar un modelo de reconocimiento de imágenes existente.

Haz clic en el botón Export Model.

Selecciona las opciones Tensorflow Lite y EdgeTPU, y luego haz clic en Download my model (Descargar mi modelo).

Ahora tienes un archivo que se conoce como modelo. Puede ser utilizado por el Coral TPU para clasificar nuevas imágenes y decirte si fueron tomadas durante el día, la noche o el crepúsculo.

Reentrena un modelo offline en tu misma Raspberry Pi

También puedes reentrenar un modelo existente utilizando un script de Python, que se ejecutará utilizando tus directorios de imágenes almacenados localmente.

Para reentrenar un modelo en tu computadora, necesitarás tener tu Coral TPU conectado, tus directorios de imágenes organizados y un modelo preentrenado que hayas descargado.

Configura una estructura de directorios en tu computadora de manera que tengas directorios para data y models.

Dentro del directorio data, puedes mover tus directorios de imágenes clasificados y tu directorio de pruebas (tests).

Crea un archivo de texto dentro del directorio data que contenga las etiquetas de los directorios de imágenes correspondientes, junto con un orden. En este ejemplo, el archivo de texto se llama day-vs-night.txt.

day-vs-night.txt

0 day 
1 night 
2 twilight

Descarga un modelo de reconocimiento de imágenes preentrenado aquí.

Mueve el archivo del modelo a tu directorio models.

Descarga el script de entrenamiento aquí y muévelo a la carpeta principal.

Abre el script train.py utilizando un editor de texto o un IDE como Thonny.

• La línea 30 establece el nombre del modelo que se generará tras el reentrenamiento.

• La línea 33 requiere el nombre de tu archivo de etiquetas (label file).

Puedes cambiar estas líneas dependiendo del nombre de tu modelo tflite y de tu archivo de etiquetas.

train.py

# the absolute path for the directory where this Python script is stored
script_dir = Path(__file__).parent.resolve()
# specify the input and output (retrained) model
model_path = script_dir/'models'/'mobilenet_v1_1.0_224_l2norm_quant_edgetpu.tflite'
out_model_path = script_dir/'models'/'astropi-day-vs-nite.tflite'
# specify where the labels and labelled training data are
# note: this is the simple version, could accept command-line arguments
data_dir = script_dir/'data'
labels_path = data_dir/'day-vs-night.txt'

python3 train.py

Tu nuevo modelo se guardará en el directorio models.

¿Cuál es la diferencia entonces entre este modelo y Teachable Machine?

Cuando reentrenas el modelo en tu propia computadora, tienes la libertad de elegir el modelo base que vas a reentrenar. Con Teachable Machine, solo puedes usar el modelo que la plataforma ha elegido por ti.

Al entrenar en tu equipo, tienes la oportunidad de seleccionar entre una amplia variedad de modelos diferentes, algunos de los cuales pueden estar mucho mejor adaptados a la tarea específica que intentas lograr.

Probando tu nuevo modelo

El script que estás a punto de crear tomará una imagen de prueba y la pasará por el modelo que has reentrenado. Esto se hace en un intento de clasificar la imagen y proporcionará una puntuación (score) que indica qué tan confiado está el modelo de que la imagen ha sido identificada correctamente.

Nuevamente, en estos ejemplos, estamos utilizando las imágenes tomadas desde la ISS para clasificar si fueron capturadas durante el día, la noche o el crepúsculo.

1. Abre tu IDE de Python (como Thonny).
2. Crea un nuevo archivo llamado classify.py.
3. Guarda el archivo en el mismo directorio principal donde se encuentran tus carpetas data y models.

Agrega las importaciones a classify.py

Agrega las importaciones que se muestran a continuación al comienzo de tu archivo.

• pathlib: te permitirá navegar por la estructura de carpetas y directorios.

• PIL (Pillow): se utiliza para redimensionar las imágenes, asegurando que tengan el tamaño correcto para el modelo.

• pycoral: es la librería que permite al script comunicarse y procesar datos usando el Edge TPU.

classify.py

from pathlib import Path
from PIL import Image
from pycoral.adapters import common
from pycoral.adapters import classify
from pycoral.utils.edgetpu import make_interpreter
from pycoral.utils.dataset import read_label_file

Configuración de rutas en classify.py

La siguiente etapa es indicarle a tu script dónde se encuentran todos los archivos y directorios. Para lograrlo, utilizaremos pathlib para obtener el nombre de la carpeta donde se ha guardado el script.

Agrega la siguiente línea de código para resolver la ruta del directorio actual:

script_dir = Path(__file__).parent.resolve()

model_file = script_dir/'models/astropi-day-vs-nite.tflite' # name of model
data_dir = script_dir/'data'
label_file = data_dir/'day-vs-night.txt' # Name of your label file
image_file = data_dir/'tests'/'day_3.jpg' # Name of image for classification

Ahora, el intérprete de TensorFlow Lite debe configurarse para utilizar el Edge TPU de Coral.

Agrega las siguientes dos líneas para inicializar el intérprete:

interpreter = make_interpreter(f"{model_file}") 
interpreter.allocate_tensors()

Los modelos de aprendizaje automático prefieren que todas las imágenes tengan un tamaño fijo, ya que esto simplifica mucho el proceso de clasificación. Si un modelo ha sido entrenado con imágenes de 224 por 224 píxeles, lo ideal es que cualquier imagen que se le entregue tenga las mismas dimensiones.

Si necesitas que tu modelo identifique detalles más finos, este debería ser entrenado con imágenes de mayor resolución. Esto es crucial si intentas clasificar imágenes con características muy específicas, como líneas costeras en una foto de Astro Pi o el color de ojos en un retrato.

Agrega las siguientes líneas para obtener las dimensiones exactas que requiere tu modelo reentrenado y luego ajusta el tamaño de tu imagen de prueba a esas dimensiones utilizando PIL:

size = common.input_size(interpreter)
image = Image.open(image_file).convert('RGB').resize(size, Image.ANTIALIAS)

Ahora es necesario pasar la imagen por el modelo para ver qué tanto coincide con alguna de las clases para las que fue entrenado.

Agrega estas tres líneas en classify.py para clasificar tu imagen de prueba:

# classify.py
common.set_input(interpreter, image)
interpreter.invoke()
classes = classify.get_classes(interpreter, top_k=1)

# classify.py
labels = dataset.read_label_file(label_file)
for c in classes:
print(f'{labels.get(c.id, c.id)} {c.score:.5f}')

day: 0.99609

Mission Space Lab

Mission Space Lab es parte del European Astro Pi Challenge, un proyecto educativo de la ESA (Agencia Espacial Europea) realizado en colaboración con la Fundación Raspberry Pi para jóvenes de hasta 19 años en los Estados miembros de la ESA, Eslovenia, Letonia, Lituania y Canadá.

En Mission Space Lab, se invita a los equipos a escribir programas informáticos que resuelvan una tarea científica en el espacio: recopilar datos para calcular la velocidad a la que viaja la Estación Espacial Internacional (ISS) con la mayor precisión posible. Para lograrlo, los equipos escriben un programa en Python que utiliza primero los sensores o la cámara de las computadoras Astro Pi para obtener datos sobre la orientación y el movimiento de la ISS mientras orbita la Tierra, y luego calculan su velocidad basándose en esos datos.

Cada unidad Astro Pi tendrá conectado un acelerador de aprendizaje automático Coral (Coral Machine Learning Accelerator).

Si deseas participar en Mission Space Lab, puedes experimentar con las imágenes de día, noche y crepúsculo proporcionadas.

Otras aplicaciones de Machine Learning en la misión

Existen otras formas en las que podrías utilizar el Coral y el Aprendizaje Automático para tus programas de Mission Space Lab. Mediante el reconocimiento de imágenes, podrías intentar experimentar con la detección de:

• Océanos, tierra firme o líneas costeras.

• Cadenas montañosas, lagos o desiertos.

Si quieres aprender más sobre cómo usar Coral, consulta los ejemplos y la documentación en https://coral.ai.