Entrena un modelo de detección de comentarios spam con Model Maker de TensorFlow Lite

1. Antes de comenzar

En este codelab, revisarás el código creado con TensorFlow y Model Maker 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 revisas se proporciona aquí, pero es muy recomendable que lo sigas en Colaboratory.

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 en apps de Flutter. Si aún no has completado las actividades anteriores, hazlo ahora antes de continuar.

Qué aprenderás

Cómo instalar Model Maker TensorFlow Lite con Colab
Cómo descargar los datos del servidor de Colab a tu dispositivo
Cómo usar un cargador de datos
Cómo crear el modelo

Requisitos

Acceso a 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 ejecutaste 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 Colab a tu dispositivo y configurar la variable 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 necesitas especificar qué columnas contienen texto y cuáles contienen etiquetas, lo que verás más adelante en este codelab.

5. Incorporaciones aprendidas previamente

Por lo general, cuando usas Model Maker, no creas modelos desde cero, sino que usas modelos existentes y los personalizas según tus necesidades.

Los modelos de lenguaje, como este, implican el uso de incorporaciones previamente aprendidas. 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 a fin de 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 tienen vectores que se dirigen a una dirección similar, mientras que las palabras que no lo son dirigen 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, para que puedan llegar a una solución mucho más rápido que cuando comienzan desde cero.

Model Maker proporciona varias incorporaciones aprendidas previamente que puedes usar, pero la más simple y rápida para comenzar es la opción average_word_vec.

Este es el código para hacerlo:

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 debes especificar la cantidad de palabras que deseas que use tu modelo.

Es posible que pienses que “cuanto más, mejor”, pero, en general, hay una cantidad adecuada en función de la frecuencia con la que se utiliza 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, muchas palabras solo se usan una o dos veces, por lo que su inclusión en el modelo no vale la pena, ya que tienen un impacto insignificante en la opinión general.

Puedes usar el parámetro num_words para ajustar tu modelo en función de la cantidad de palabras que desees. Un número menor podría proporcionar un modelo más pequeño y rápido, pero podría ser menos preciso porque reconoce menos palabras. Por otro lado, un número más grande podría proporcionar un modelo más grande y más lento. Es importante 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 que se determina a partir de la investigación es que es la raíz cuarta de la cantidad de palabras. Por ejemplo, si usas 2,000 palabras, 7 es un buen punto de partida. Si cambias el número 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 puede clasificar oraciones de una longitud estática específica. 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. En este caso, tu modelo está entrenado para clasificar y reconocer oraciones con 20 tokens. Si la oración es más larga, se truncará. Si es más corta, se rellenará. Puedes ver un token <PAD> dedicado en el corpus que se usa 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 variable 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)

Este código crea un modelo clasificador de texto con Model Maker y debes especificar los datos de entrenamiento que deseas usar como configurados en el cuarto paso, la especificación del modelo configurada como en el cuarto paso y una cantidad de ciclos de entrenamiento, que, en este caso, es 50.

El principio básico del AA es que es una forma de coincidencia de patrones. Primero, carga los pesos previamente entrenados para las palabras y, luego, intenta agruparlos con una predicción de cuáles, cuando se agrupan, indican spam y cuáles no. La primera vez, es probable que se divida de manera uniforme, porque el modelo solo se está iniciando.

Luego, medirá los resultados de este ciclo de entrenamiento 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 exactitud mucho mayor. En este caso, muestra 99%.

Las cifras de exactitud de la validación suelen ser un poco más bajas que las de exactitud del entrenamiento, ya que son un indicador de cómo el modelo clasifica los datos que no vio antes. Usa el 10% de datos de prueba que reservaste antes.

8. Exporta el modelo

Ejecuta esta celda para especificar un directorio y exportar el modelo:

model.export(export_dire='/mm_spam_savedmodel', export_format=[ExportFormat.LABEL, ExportFormat.VOCAB, ExportFormat.SAVED_MODEL])

Comprime toda la carpeta de /mm_spam_savedmodel y descarga el archivo mm_spam_savedmodel.zip generado, que necesitas en el siguiente codelab.

# Rename the SavedModel subfolder to a version number
!mv /mm_spam_savedmodel/saved_model /mm_spam_savedmodel/123
!zip -r mm_spam_savedmodel.zip /mm_spam_savedmodel/

9. Felicitaciones

En este codelab, te guiamos a través del código de Python para crear y exportar tu modelo. Ahora tienes un modelo guardado, además de las etiquetas y el vocabulario al final. En el siguiente codelab, verás cómo usar este modelo para comenzar a clasificar los comentarios como spam.