1. Antes de comenzar
En este codelab, repasarás el código creado con TensorFlow y TensorFlow Lite Model Maker para crear un modelo con un conjunto de datos basado en comentarios spam. Los datos originales están disponibles en Kaggle. Se recopiló en un solo archivo CSV y se limpió quitando texto dañado, lenguaje de marcado, palabras repetidas y mucho más. Esto hará que sea más fácil enfocarse en el modelo en lugar del texto.
El código que vas a revisar se proporcionó aquí, pero es muy recomendable que cumplas con el código en Google Colab.
Requisitos previos
- Este codelab se redactó para desarrolladores experimentados que no tienen experiencia en el aprendizaje automático.
- Este codelab es parte de la ruta de introducción a la clasificación de texto para dispositivos móviles. Si aún no ha completado las actividades anteriores, hágalo ahora.
Qué aprenderás
- Cómo instalar TensorFlow Lite Model Maker con Google Colab
- Cómo descargar los datos del servidor de Cloud a tu dispositivo
- Cómo usar un cargador de datos
- Cómo compilar el modelo
Requisitos
- Acceso a Google Colab
2. Instala TensorFlow Lite Model Maker
Abre el Colab. La primera celda del notebook instalará TensorFLow Lite Maker por ti:
!pip install -q tflite-model-maker
Cuando haya finalizado, avance a la siguiente celda.
3. Importa el código
La siguiente celda contiene varias importaciones que el código del notebook deberá usar:
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 text_classifier
from tflite_model_maker.text_classifier import DataLoader
import tensorflow as tf
assert tf.__version__.startswith('2')
tf.get_logger().setLevel('ERROR')
Esto también comprobará si ejecutas TensorFlow 2.x, que es un requisito para usar Model Maker.
4. Descargar los datos
A continuación, descargarás los datos de Cloud Server en tu dispositivo y configurarás data_file para que apunte al archivo local:
data_file = tf.keras.utils.get_file(fname='comment-spam.csv',
origin='https://storage.googleapis.com/laurencemoroney-blog.appspot.com/lmblog_comments.csv',
extract=False)
Model Maker puede entrenar modelos a partir de archivos CSV simples como este. Solo debe especificar qué columnas contienen el texto y cuáles contienen las etiquetas. Más adelante, en el codelab, aprenderás a hacerlo.
5. Incorporaciones aprendidas previamente
En general, cuando usas Model Maker, no compilas modelos desde cero. Usará modelos existentes que pueda personalizar según sus necesidades.
Para los modelos de lenguaje, como este, esto implica el uso de incorporaciones previamente aprendidas. La idea detrás de una incorporación es que las palabras se convierten en números, y cada palabra de tu corpus general recibe un número. Una incorporación es un vector que se usa para determinar la opinión de una palabra al establecer una "dirección" para ella. Por ejemplo, las palabras que se usan con frecuencia en los mensajes de spam de comentarios terminan con sus vectores apuntando en una dirección similar, y las palabras que no lo hacen apuntarán en la dirección opuesta.
Con las incorporaciones previamente aprendidas, puedes comenzar con un corpus, o colección, de palabras que ya tienen una opinión de un cuerpo de texto grande. Esto te llevará a una solución mucho más rápida que comenzar desde cero.
Model Maker proporciona varias incorporaciones preaprendidas que puedes usar, pero la más simple y rápida para comenzar es average_word_vec.
Este es el código:
spec = model_spec.get('average_word_vec')
spec.num_words = 2000
spec.seq_len = 20
spec.wordvec_dim = 7
El parámetro num_words
También especificarás la cantidad de palabras que deseas que use el modelo.
Es posible que piense que "cuanto mejor, mejor", pero, en general, hay una cifra correcta según la frecuencia con la que se usa cada palabra. Si usas todas las palabras de todo el corpus, podrías terminar con el modelo que intenta aprender y establecer la dirección de las palabras que se usan solo una vez. En cualquier corpus de texto, descubrirás que muchas palabras solo se usan una o dos veces y, por lo general, no vale la pena incluirlos en tu modelo, ya que tienen un impacto insignificante en la opinión general. Puedes ajustar tu modelo en función de la cantidad de palabras que desees con el parámetro num_words.
Un número menor aquí podría darles un modelo más pequeño y rápido, pero podría ser menos preciso, ya que reconoce menos palabras. Un número mayor aquí tendrá un modelo más grande y más lento. Encontrar el punto óptimo es clave.
El parámetro palabravec_dim
El parámetro wordved_dim es la cantidad de dimensiones que deseas usar para el vector de cada palabra. La regla general se determina a partir de la investigación es que es la cuarta raíz de la cantidad de palabras. Por ejemplo, si utilizas 2,000 palabras, un buen punto de partida es el 7. Si cambias el número de palabras que usas, también puedes hacerlo.
El parámetro seq_len
Por lo general, los modelos son muy rígidos en lo que respecta a los valores de entrada. Para un modelo de idioma, esto significa que el modelo de lenguaje puede clasificar oraciones de una longitud estática y en particular. Esto se determina mediante el parámetro seq_len o la longitud de la secuencia.
Cuando convierte palabras en números (o tokens), una oración se convierte en una secuencia de esos tokens. Por lo tanto, se entrenará (en este caso) para que clasifique y reconozca oraciones con 20 tokens. Si la oración es más larga, se truncará. Si es más corto, se rellenará. Verás un token <PAD> dedicado en el corpus que se usará para este fin.
6. Usa un cargador de datos
Anteriormente, descargaste el archivo CSV. Ahora, es momento de usar un cargador de datos para convertir esto en datos de entrenamiento que el modelo puede reconocer:
data = DataLoader.from_csv(
filename=data_file,
text_column='commenttext',
label_column='spam',
model_spec=spec,
delimiter=',',
shuffle=True,
is_training=True)
train_data, test_data = data.split(0.9)
Si abres el archivo CSV en un editor, verás que cada línea solo tiene dos valores, que se describen con texto en la primera línea del archivo. Por lo general, cada entrada se considera una columna.
Verás que el descriptor de la primera columna es commenttext y que la primera entrada de cada línea es el texto del comentario. De manera similar, el descriptor de la segunda columna es spam, y observarás que la segunda entrada de cada línea es True o False, para indicar si ese texto se considera spam o no. Las otras propiedades establecen el model_spec que creaste anteriormente, junto con un carácter delimitador, que en este caso es una coma cuando el archivo está separado por comas. Usarás estos datos para entrenar el modelo, por lo que is_Training se establece en True.
Es importante que retengas una parte de los datos para probar el modelo. Dividir los datos con un 90% de entrenamiento para el entrenamiento y el otro un 10% para pruebas y evaluación Debido a esto, queremos asegurarnos de que los datos de prueba se elijan de forma aleatoria y que no sean el 10% más bajo del conjunto de datos, por lo que usas shuffle=True cuando cargas los datos para aleatorizarlos.
7. Crear el modelo
La siguiente celda consiste simplemente en compilar el modelo y es una sola línea de código:
# Build the model
model = text_classifier.create(train_data, model_spec=spec, epochs=50,
validation_data=test_data)
Esto crea un modelo clasificador de texto con Model Maker y especificas los datos de entrenamiento que deseas usar (como se configuraron en el paso 4), la especificación del modelo (como se configuró en el paso 4) y una cantidad de ciclos de entrenamiento, en este caso. 50
El principio básico del aprendizaje automático es que es una forma de comparación de patrones. Inicialmente, cargará los pesos previamente entrenados para las palabras y tratará de agruparlos con una predicción de cuáles, cuando se agrupan, indican spam y cuáles no. La primera vez, es probable que esté cerca de los 50:50, ya que el modelo solo se está iniciando.
Luego, medirá los resultados y ejecutará el código de optimización para ajustar su predicción y, luego, vuelva a intentarlo. Esta es una época. Por lo tanto, si especificas tempos=50, el bucle pasará a 50 veces.
Para el momento en que alcanzas la época 50, el modelo informa un nivel de exactitud mucho mayor. En este caso, se muestra el 99%.
En el lado derecho, verás las cifras de precisión de la validación. Por lo general, serán un poco más bajos que la precisión del entrenamiento, ya que son una indicación de cómo el modelo clasifica los datos que no ha “visto” anteriormente. Usa los datos de prueba del 10% que reservamos anteriormente.
8. Exporta el modelo
Una vez finalizado el entrenamiento, puedes exportar el modelo.
TensorFlow entrena un modelo en su propio formato. Este debe convertirse al formato TFLITE para usarse en una app para dispositivos móviles. Model Maker se encarga de esta complejidad por ti.
Simplemente exporte el modelo y especifique un directorio:
model.export(export_dir='/mm_spam')
Dentro de ese directorio, verás un archivo model.tflite. Descárgala. Lo necesitarás en el siguiente codelab, en el que lo agregarás a tu app para Android.
Consideraciones para iOS
El modelo .tflite que acabas de exportar funciona bien para Android, ya que los metadatos sobre el modelo están incorporados en él y Android Studio puede leerlos.
Estos metadatos son muy importantes, ya que incluyen un diccionario de tokens que representan palabras a medida que el modelo las reconoce. ¿Recuerdas cuando aprendiste que las palabras se convirtieron en tokens y que, luego, se les asignan vectores de su opinión? Su aplicación para dispositivos móviles necesitará conocer estos tokens. Por ejemplo, si "perro" tiene un token igual a 42, y los usuarios escriben "perro" en una oración, entonces tu app deberá convertir "perro" a 42 para que el modelo lo entienda. Como desarrollador de Android, contarás con una "Biblioteca de tareas de TensorFlow Lite" que facilitará el uso, pero en iOS deberás procesar el vocabulario, por lo que deberás tenerlo a disposición. Model Maker puede exportar esto por ti si especificas el parámetro export_format. Por lo tanto, para obtener las etiquetas y el vocabulario de tu modelo, puedes usar lo siguiente:
model.export(export_dir='/mm_spam/',
export_format=[ExportFormat.LABEL, ExportFormat.VOCAB])
9. Felicitaciones
En este codelab, te guiaremos por el código de Python para compilar y exportar tu modelo. Al final, aparecerá un archivo .tflite.
En el siguiente codelab, verás cómo editar tu app para Android a fin de usar este modelo, de modo que puedas comenzar a clasificar los comentarios spam.