1. Antes de comenzar
En el codelab anterior, creaste una app para Android y iOS que usaba un modelo básico de etiquetado de imágenes que reconoce varios cientos de clases de imágenes. Reconoció una imagen de una flor de forma muy genérica, ya que vio pétalos, flor, planta y cielo.
Para actualizar la app y que reconozca flores específicas, como margaritas o rosas, necesitarás un modelo personalizado entrenado con muchos ejemplos de cada tipo de flor que quieras reconocer.
Requisitos previos
- El codelab anterior de esta ruta de aprendizaje
Qué compilarás y aprenderás
- Cómo entrenar un modelo personalizado de clasificador de imágenes con Model Maker de TensorFlow Lite
Requisitos
- No se necesita hardware en particular, ya que todo se puede completar con Google Colab en el navegador.
2. Comenzar
Todo el código para seguir el proceso se preparó para ti y está disponible para ejecutarse con Google Colab aquí. Si no tienes acceso a Google Colab, puedes clonar el repo y usar el notebook llamado CustomImageClassifierModel.ipynb, que se encuentra en el directorio ImageClassificationMobile->colab.
Si tienes muchos ejemplos de flores particulares, es relativamente fácil entrenar un modelo con Model Maker de TensorFlow Lite para que las reconozca.
La forma más fácil de hacerlo es crear un archivo .zip o .tgz que contenga las imágenes ordenadas en directorios. Por ejemplo, si usas imágenes de margaritas, dientes de león, rosas, girasoles y tulipanes, puedes organizarlas en directorios de la siguiente manera:
Comprímelo y alójalo en un servidor, y podrás entrenar modelos con él. Usarás uno que se preparó para ti en el resto de este lab.
En este lab, se supondrá que usas Google Colab para entrenar el modelo. Puedes encontrar Colab en colab.research.google.com. Si usas otro entorno, es posible que debas instalar muchas dependencias, entre ellas TensorFlow.
3. Instala y, luego, importa las dependencias
- Instala Model Maker de TensorFlow Lite. Puedes hacerlo con una instalación de pip. El &> /dev/null al final solo suprime el resultado. Model Maker genera mucha información que no es pertinente de inmediato. Se suprimió para que puedas concentrarte en la tarea que estás realizando.
# Install Model maker
!pip install -q tflite-model-maker &> /dev/null
- A continuación, deberás importar las bibliotecas que necesitas usar y asegurarte de que estás usando TensorFlow 2.x:
# Imports and check that we are using TF2.x
import numpy as np
import os
from tflite_model_maker import configs
from tflite_model_maker import ExportFormat
from tflite_model_maker import model_spec
from tflite_model_maker import image_classifier
from tflite_model_maker.image_classifier import DataLoader
import tensorflow as tf
assert tf.__version__.startswith('2')
tf.get_logger().setLevel('ERROR')
Ahora que el entorno está listo, es momento de comenzar a crear tu modelo.
4. Descarga y prepara tus datos
Si tus imágenes están organizadas en carpetas y esas carpetas están comprimidas, cuando descargues el archivo ZIP y lo descomprimas, tus imágenes se etiquetarán automáticamente según la carpeta en la que se encuentren. Se hará referencia a este directorio como data_path.
data_path = tf.keras.utils.get_file(
'flower_photos',
'https://storage.googleapis.com/download.tensorflow.org/example_images/flower_photos.tgz',
untar=True)
Luego, esta ruta de datos se puede cargar en un modelo de red neuronal para el entrenamiento con la clase ImageClassifierDataLoader de TensorFlow Lite Model Maker. Solo apunta a la carpeta y listo.
Un elemento importante en el entrenamiento de modelos con aprendizaje automático es no usar todos tus datos para el entrenamiento. Reserva una pequeña cantidad para probar el modelo con datos que no haya visto antes. Esto es fácil de hacer con el método de división del conjunto de datos que se devuelve de ImageClassifierDataLoader. Si pasas un 0.9, obtendrás el 90% de los datos como datos de entrenamiento y el 10% como datos de prueba:
data = DataLoader.from_folder(data_path)
train_data, test_data = data.split(0.9)
Ahora que tus datos están preparados, puedes crear un modelo con ellos.
5. Crea el modelo de clasificador de imágenes
Model Maker abstrae gran parte de los detalles específicos del diseño de la red neuronal, por lo que no tienes que ocuparte del diseño de la red ni de aspectos como las convoluciones, las funciones densas, relu, flatten, las funciones de pérdida y los optimizadores. Para un modelo predeterminado, puedes usar una sola línea de código para crear un modelo entrenando una red neuronal con los datos proporcionados:
model = image_classifier.create(train_data)
Cuando ejecutes este comando, verás un resultado similar al siguiente:
Model: "sequential_2"
_________________________________________________________________
Layer (type) Output Shape Param #
=================================================================
hub_keras_layer_v1v2_2 (HubK (None, 1280) 3413024
_________________________________________________________________
dropout_2 (Dropout) (None, 1280) 0
_________________________________________________________________
dense_2 (Dense) (None, 5) 6405
=================================================================
Total params: 3,419,429
Trainable params: 6,405
Non-trainable params: 3,413,024
_________________________________________________________________
None
Epoch 1/5
103/103 [===] - 15s 129ms/step - loss: 1.1169 - accuracy: 0.6181
Epoch 2/5
103/103 [===] - 13s 126ms/step - loss: 0.6595 - accuracy: 0.8911
Epoch 3/5
103/103 [===] - 13s 127ms/step - loss: 0.6239 - accuracy: 0.9133
Epoch 4/5
103/103 [===] - 13s 128ms/step - loss: 0.5994 - accuracy: 0.9287
Epoch 5/5
103/103 [===] - 13s 126ms/step - loss: 0.5836 - accuracy: 0.9385
La primera parte muestra la arquitectura de tu modelo. Lo que Model Maker hace en segundo plano se denomina aprendizaje por transferencia, que usa un modelo previamente entrenado existente como punto de partida y solo toma lo que ese modelo aprendió sobre cómo se construyen las imágenes y lo aplica para comprender estas 5 flores. Puedes ver esto en la primera línea que dice lo siguiente:
hub_keras_layer_v1v2_2 (HubK (None, 1280) 3413024
La clave es la palabra "Hub", que nos indica que este modelo proviene de TensorFlow Hub. De forma predeterminada, TensorFlow Lite Model Maker usa un modelo llamado "MobileNet", que está diseñado para reconocer 1,000 tipos de imágenes. La lógica aquí es que la metodología que usa, al aprender "características" para distinguir entre 1,000 clases, se puede reutilizar. Las mismas "características" se pueden asignar a nuestras 5 clases de flores, por lo que no es necesario aprenderlas desde cero.
El modelo pasó por 5 épocas, en las que una época es un ciclo de entrenamiento completo en el que la red neuronal intenta hacer coincidir las imágenes con sus etiquetas. Cuando pasó por 5 épocas, en alrededor de 1 minuto, tenía una precisión del 93.85% en los datos de entrenamiento. Dado que hay 5 clases, una suposición aleatoria tendría una precisión del 20%, por lo que esto es un avance. (También informa un número de "pérdida", pero puedes ignorarlo por ahora).
Anteriormente, dividiste los datos en datos de entrenamiento y de prueba, por lo que puedes tener una idea de cómo se comporta la red con los datos que no ha visto antes, un mejor indicador de cómo podría comportarse en el mundo real usando model.evaluate en los datos de prueba:
loss, accuracy = model.evaluate(test_data)
Esto generará un resultado similar al siguiente:
12/12 [===] - 5s 115ms/step - loss: 0.6622 - accuracy: 0.8801
Ten en cuenta la precisión aquí. Es del 88.01%, por lo que, si se usa el modelo predeterminado en el mundo real, se debería esperar ese nivel de precisión. No está mal para el modelo predeterminado que entrenaste en aproximadamente un minuto. Por supuesto, probablemente podrías hacer muchos ajustes para mejorar el modelo, y eso es una ciencia en sí misma.
6. Exporta el modelo
Ahora que el modelo está entrenado, el siguiente paso es exportarlo en el formato .tflite que puede usar una aplicación para dispositivos móviles. Model Maker proporciona un método de exportación sencillo que puedes usar. Solo tienes que especificar el directorio en el que se generará el resultado.
Este es el código:
model.export(export_dir='/mm_flowers')
Si ejecutas este código en Google Colab, puedes ver el modelo haciendo clic en el ícono de carpeta que se encuentra a la izquierda de la pantalla:
Aquí, verás una lista del directorio actual. Usa el botón indicado para subir un directorio:
En tu código, especificaste que se exportara al directorio mm_flowers. Ábrelo y verás un archivo llamado “model.tflite”. Este es tu modelo entrenado.
Selecciona el archivo y verás 3 puntos en el lado derecho. Haz clic en ellos para obtener un menú contextual y, desde allí, podrás descargar el modelo.
Después de unos segundos, el modelo se descargará en la carpeta de descargas.
7. Felicitaciones
Ahora puedes integrarlo en tu app para dispositivos móviles. Lo harás en el próximo lab.