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 a partir de 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 que no funciona, marcas, palabras repetidas y mucho más. Esto facilitará enfocarse en el modelo, en lugar de en el texto.
Si bien el código que revisarás se proporciona aquí, te recomendamos 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 el 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')
Esto también verificará si estás ejecutando TensorFlow 2.x, que es un requisito para usar Model Maker.
4. Descarga los datos
A continuación, descargarás los datos del servidor de Cloud a 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 sencillos como este. Solo debes especificar qué columnas contienen el texto y cuáles contienen las etiquetas. Verás cómo hacerlo más adelante en el codelab.
5. Incorporaciones aprendidas previamente
Por lo general, cuando se usa Model Maker, no se crean modelos desde cero. Usas modelos existentes que se personalizan según tus 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 conviertan en números, y a cada palabra del corpus general se les asigna un número. Una incorporación es un vector que se usa para determinar la opinión de una palabra estableciendo una “dirección” para la palabra. Por ejemplo, las palabras que se usan con frecuencia en los mensajes de spam de comentarios terminarán teniendo sus vectores apuntando en una dirección similar, y las palabras que no lo harán en la dirección opuesta.
Con las incorporaciones aprendidas previamente, puedes comenzar con un corpus o una colección de palabras a las que se les aprendió la opinión de un gran conjunto de texto. Así, llegarás a una solución mucho más rápido que si empiezas 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: «mientras más, mejor», pero, por lo general, hay una cifra correcta
según la frecuencia de uso de cada palabra. Si usas cada palabra de todo el corpus, podrías terminar con el modelo intentando aprender y establecer la dirección de las palabras que solo se usan 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 con el parámetro num_words.
Un número menor aquí podría brindar 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 ideal es clave.
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 que se determina a partir de la investigación es que es la raíz cuarta del número 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 esta opción.
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 puede clasificar oraciones de una longitud particular y estática. 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 será entrenado (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á. En el corpus, verás un token <PAD> dedicado 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 el model_spec que creaste antes, junto con un carácter delimitador, que en este caso es una coma porque 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 tú especificas los datos de entrenamiento que quieres usar (como se configura en el paso 4), la especificación del modelo (como se configura 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 coincidencia de patrones. Inicialmente, cargará las ponderaciones previamente entrenadas de las palabras y tratará de agruparlas con una predicción de cuáles, cuando se agrupan, indican spam y cuáles no. La primera vez, es probable que se acerque a las 50:50, ya que el modelo recién se está iniciando.
Luego, medirá los resultados, 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.
Para cuando llegues al ciclo de entrenamiento número 50, el modelo informará 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. Estos suelen ser un poco más bajos que la exactitud del entrenamiento, ya que son un indicador de cómo el modelo clasifica los datos que no “haya visto” anteriormente. Usa el 10% de los datos de prueba que reservamos antes.
8. Exporta el modelo
Una vez finalizado el entrenamiento, puedes exportar el modelo.
TensorFlow entrena un modelo en su propio formato, que se debe convertir al formato TFLITE para usarlo en una app para dispositivos móviles. Model Maker se encarga de esta complejidad por ti.
Solo exporta el modelo y especifica 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 convierten en tokens, y estos tokens luego reciben vectores para su opinión? Tu app para dispositivos móviles debe conocer estos tokens. Por ejemplo, si "perro" se le asignó un token de 42, y sus usuarios escribieron “perro” en una oración, tu app deberá convertir “perro” a 42 para que el modelo lo entienda. Como desarrollador de Android, tendrás la "Biblioteca de tareas de TensorFlow Lite" eso facilita el uso, pero en iOS
deberás procesar el vocabulario, así que debes tenerlo disponible. Model Maker puede exportar esto por ti especificando 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 compilar y exportar tu modelo. Tendrá un archivo .tflite al final.
En el siguiente codelab, aprenderás a editar tu app para Android con el objetivo de usar este modelo y comenzar a clasificar comentarios de spam.