1. Antes de comenzar
En este codelab, revisarás el código creado con TensorFlow y Model Maker de TensorFlow Lite para crear un modelo con un conjunto de datos basado en comentarios spam. Los datos originales están disponibles en kaggle. Se recopilaron en un único archivo CSV y se limpiaron mediante la eliminación de texto incorrecto, marcas, palabras repetidas y mucho más. Esto facilitará enfocarse en el modelo, en lugar de en el texto.
El código que revisarás se proporciona aquí, pero es muy recomendable que lo sigas en Google Colab.
Requisitos previos
- Este codelab se redactó para desarrolladores experimentados que no han usado el aprendizaje automático.
- Este codelab es parte de la ruta de aprendizaje Comienza a usar la clasificación de texto para dispositivos móviles. Si aún no has completado las actividades anteriores, hazlo ahora antes de continuar.
Qué aprenderás
- Cómo instalar Model Maker de TensorFlow Lite con Google Colab
- Cómo descargar los datos del servidor de Cloud a tu dispositivo
- Cómo usar un cargador de datos
- Cómo crear el modelo
Requisitos
- Acceso a Google Colab
2. Instala Model Maker de TensorFlow Lite
Abre Colab. La primera celda del notebook instalará Model Maker de TensorFlow Lite:
!pip install -q tflite-model-maker
Cuando haya finalizado, avanza a la siguiente celda.
3. Importa el código
La siguiente celda contiene varias importaciones que deberá usar el código del notebook:
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')
También comprobará si estás ejecutando TensorFlow 2.x, que es un requisito para usar Model Maker.
4. Descarga los datos
A continuación, deberás descargar los datos del servidor de Cloud a tu dispositivo y configurar data_file para que haga referencia 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 sencillos como este. Solo debes especificar qué columnas contienen el texto y cuáles contienen las etiquetas. Más adelante en el codelab, verás cómo hacerlo.
5. Incorporaciones aprendidas previamente
Por lo general, cuando se usa Model Maker, no se compilan modelos desde cero. Se usan modelos existentes que se personalizan según tus necesidades.
Para los modelos de lenguaje, como este, esto implica usar incorporaciones aprendidas previamente. La idea detrás de una incorporación es que las palabras se conviertan en números. Cada número se otorga a cada palabra del corpus general. Una incorporación es un vector que se usa para determinar la opinión de una palabra mediante el establecimiento de una “dirección” para ella. Por ejemplo, las palabras que se usan con frecuencia en mensajes de comentarios spam terminarán teniendo vectores que se dirigen a una dirección similar, mientras que las palabras que no lo son dirigirán sus vectores en la dirección opuesta.
Cuando se usan incorporaciones ya aprendidas, se puede comenzar con un corpus o una colección de palabras, que ya tienen una opinión de un cuerpo de texto grande. Esto te permitirá llegar a una solución mucho más rápido que si comienzas desde cero.
Model Maker proporciona varias incorporaciones aprendidas previamente 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 tu modelo.
Podrías pensar que “cuanto más, mejor”, pero, por lo general, hay un número correcto según la frecuencia con la que se usa cada palabra. Si usas todas las palabras de todo el corpus, el modelo podría intentar aprender y establecer la dirección de las palabras que se usan solo una vez. En cualquier corpus de texto, encontrarás que muchas palabras solo se usan una o dos veces, y, por lo general, no vale la pena usarlas en tu modelo, ya que tienen un impacto insignificante en la opinión general. Puedes ajustar tu modelo en la cantidad de palabras que desees usando el parámetro num_words.
Un número más pequeño aquí podría dar un modelo más pequeño y rápido, pero podría ser menos preciso, ya que reconoce menos palabras. Un número más grande aquí tendrá un modelo más grande y lento. La clave es encontrar el punto óptimo.
El parámetro wordvec_dim
El parámetro wordved_dim es la cantidad de dimensiones que deseas usar para el vector de cada palabra. La regla general determinada a partir de la investigación es que es la cuarta raíz de la cantidad de palabras. Por ejemplo, si usas 2,000 palabras, un buen punto de partida es 7. Si cambias la cantidad de palabras que usas, también puedes cambiar esto.
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 lenguaje, esto significa que el modelo de lenguaje puede clasificar oraciones de una longitud estática y particular. Esto se determina mediante el parámetro seq_len o la longitud de la secuencia.
Cuando conviertes palabras en números (o tokens), una oración se convierte en una secuencia de esos tokens. Por lo tanto, tu modelo se entrenará (en este caso) para clasificar y reconocer oraciones que tengan 20 tokens. Si la oración es más larga, se truncará. Si es más corta, se rellenará. Verás un token <PAD> dedicado en el corpus que se usará para esto.
6. Usa un cargador de datos
Antes, descargaste el archivo CSV. Ahora, es el 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 comentario spam o no. Las otras propiedades establecen la model_spec que creaste antes, 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 como True.
Deberás retener una parte de los datos para probar el modelo. Divide los datos y deja un 90% para el entrenamiento y el otro 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% inferior del conjunto de datos, por lo que debes usar shuffle=True cuando cargues los datos para aleatorizarlos.
7. Crea el modelo
La siguiente celda se usa simplemente para 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 debes especificar los datos de entrenamiento que deseas usar (como se configuró en el paso 4), la especificación del modelo (como se configuró en el paso 4) y una cantidad de ciclos de entrenamiento, que, en este caso, es 50.
El principio básico del aprendizaje automático es que es una forma de coincidencia de patrones. Primero, cargará los pesos previamente entrenados para las palabras y, luego, intentará 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 50:50, ya que el modelo recién comienza.
Luego, medirá los resultados de esto y ejecutará el código de optimización para ajustar la predicción y, luego, volverá a intentarlo. Este es un ciclo de entrenamiento. Por lo tanto, si especificas epochs=50, pasará por ese “bucle” 50 veces.
Cuando llegues al ciclo de entrenamiento número 50, el modelo informará un nivel de precisión mucho más alto. En este caso, se muestra un 99%.
En el lado derecho, verás las cifras de exactitud de la validación. Por lo general, serán un poco más bajas que la exactitud del entrenamiento, ya que son un indicador de cómo el modelo clasifica los datos que no “vio” antes. Usa los datos de prueba del 10% que reservamos antes.
8. Exporta el modelo
Una vez que finalice el entrenamiento, podrás exportar el modelo.
TensorFlow entrena un modelo en su propio formato, y este debe convertirse al formato TFLITE para usarse en una app para dispositivos móviles. Model Maker controla esta complejidad por ti.
Simplemente exporta el modelo y especifica un directorio:
model.export(export_dir='/mm_spam')
Dentro de ese directorio, verás un archivo model.tflite. Descárgalo. 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 leer esos metadatos.
Estos metadatos son muy importantes, ya que incluyen un diccionario de tokens que representan palabras tal como las reconoce el modelo. ¿Recuerdas cuando aprendiste que las palabras se convierten en tokens y que, luego, estos tokens reciben vectores para su opinión? Tu app para dispositivos móviles deberá conocer estos tokens. Por ejemplo, si “dog” se tokenizó en 42 y tus usuarios escriben “dog” en una oración, tu app deberá convertir “dog” en 42 para que el modelo lo comprenda. Como desarrollador de Android, tendrás una “Biblioteca de tareas de TensorFlow Lite” que facilitará el uso de esto, pero en iOS deberás procesar el vocabulario, por lo que deberás tenerlo disponible. Model Maker puede exportarlo 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 guiamos a través del código de Python para crear y exportar tu modelo. Al final, tendrás un archivo .tflite.
En el siguiente codelab, verás cómo editar tu app para Android para usar este modelo y comenzar a clasificar los comentarios como spam.