1. Antes de comenzar
En el codelab anterior, creaste una app para iOS y Android que usaba un modelo básico de etiquetado de imágenes que reconoce cientos de clases de imágenes. Reconocía una imagen de una flor de forma muy genérica: ver pétalos, una flor, una planta y el cielo.
Para actualizar la app y que reconozca flores, margaritas o rosas específicas, por ejemplo, necesitarás un modelo personalizado que se entrenó con muchos ejemplos de cada tipo de flor que quieres reconocer.
Requisitos previos
- El codelab anterior de esta ruta de aprendizaje.
Qué compilarás y aprenderás
- Cómo entrenar un modelo personalizado clasificador de imágenes con Model Maker de TensorFlow Lite.
Requisitos
- No se necesita ningún hardware en particular; todo se puede completar con Google Colab en el navegador.
2. Comenzar
Todo el código que viene ya se preparó para ti y se puede ejecutar 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 en particular, es relativamente fácil entrenar un modelo con TensorFlow Lite Model maker para reconocerlos.
La forma más sencilla 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, girasol y tulipanes, puedes organizarlas en directorios como el siguiente:
Comprímelo y alójalo en un servidor para poder entrenar modelos con él. Utilizarás una que preparamos en el resto de este lab.
En este lab, se presupone 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, no menos que TensorFlow.
3. Cómo instalar e importar dependencias
- Instala Model Maker de TensorFlow Lite. Puedes hacerlo con una instalación pip. El &> /dev/null at the end just suppresses the output. Model Maker genera muchos elementos que no son relevantes de inmediato. Se suprimió para que puedas enfocarte en la tarea en cuestión.
# 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 el modelo.
4. Descarga y prepara tus datos
Si las imágenes están organizadas en carpetas y esas carpetas están comprimidas, si descargas el archivo ZIP y lo descomprimes, las imágenes se etiquetarán automáticamente según la carpeta en la que se encuentran. 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)
Esta ruta de datos se puede cargar en un modelo de red neuronal para entrenarlo con la clase ImageClassifierDataLoader de Model Maker de TensorFlow Lite. Solo apúntala a la carpeta y listo.
Un elemento importante en el entrenamiento de modelos con aprendizaje automático es no usar todos los datos para el entrenamiento. Espera un poco 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 proviene de ImageClassifierDataLoader. Si pasas un 0.9, obtendrás el 90% de ellos 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 clasificador de imágenes
Model Maker abstrae muchos detalles específicos del diseño de la red neuronal para que no tengas que lidiar con el diseño de la red, como las convoluciones, denso, ReLU, compactación, funciones de pérdida y 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 esto, 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 es mostrar la arquitectura de tu modelo. Lo que Model Maker hace en segundo plano se llama aprendizaje por transferencia, que usa un modelo existente previamente entrenado como punto de partida y simplemente toma lo que ese modelo aprendió sobre cómo se construyen las imágenes y las aplica para comprender estas 5 flores. Puedes ver esto en la primera línea que dice:
hub_keras_layer_v1v2_2 (HubK (None, 1280) 3413024
La clave es la palabra “hub”, que nos dice que este modelo provino 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 los “atributos” para distinguir entre 1,000 clases, se pueden reutilizar. Los mismos “atributos” se pueden asignar a nuestras 5 clases de flores, por lo que no es necesario que se aprendan desde cero.
El modelo pasó por 5 ciclos de entrenamiento, en los que un ciclo de entrenamiento es un ciclo completo de entrenamiento en el que la red neuronal intenta hacer coincidir las imágenes con sus etiquetas. En el momento en que pasó por 5 ciclos de entrenamiento, 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 sería un 20% precisa, ¡así que es un progreso! (También informa un número de "pérdida", pero puedes ignorarlo con seguridad por ahora).
Anteriormente, dividiste los datos en datos de entrenamiento y de prueba, de modo que puedas obtener un indicador del rendimiento de la red con datos que no habías visto antes. Un mejor indicador de su rendimiento en el mundo real usando model.evaluate en los datos de prueba:
loss, accuracy = model.evaluate(test_data)
Esto mostrará un resultado similar al siguiente:
12/12 [===] - 5s 115ms/step - loss: 0.6622 - accuracy: 0.8801
Observa la precisión aquí. Es del 88.01%, por lo que usar el modelo predeterminado en el mundo real debería esperar ese nivel de exactitud. Eso no es malo para el modelo predeterminado que entrenaste en aproximadamente un minuto. Es probable que puedas hacer muchos ajustes para mejorar el modelo, ¡y eso es una ciencia en sí mismo!
6. Exporta el modelo
Ahora que el modelo está entrenado, el siguiente paso es exportarlo en formato .tflite, que puede usar una aplicación para dispositivos móviles. El creador de modelos proporciona un método de exportación fácil que puedes usar; simplemente especifica el directorio al que quieres que se genere la salida.
Este es el código:
model.export(export_dir='/mm_flowers')
Si ejecutas esto en Google Colab, puedes ver el modelo haciendo clic en el ícono de carpeta que se encuentra a la izquierda de la pantalla:
Desde aquí, obtendrás una lista del directorio actual. Usa el botón indicado para moverte hacia “arriba” un directorio:
En el código que especificaste, exportar al directorio mm_flowers Ábrelo y verás un archivo llamado "model.tflite". Este es el modelo entrenado.
Selecciona el archivo y verás 3 puntos emergentes a la derecha. Haz clic en ellos para obtener un menú contextual y descargar el modelo desde allí.
Después de unos momentos, el modelo se descargará en tu carpeta de descargas.
7. Felicitaciones
Ya está todo listo para integrarla a tu app para dispositivos móviles. Lo harás en el siguiente lab.