¡El Día de la Comunidad de ML es el 9 de noviembre! Únase a nosotros para recibir actualizaciones de TensorFlow, JAX, y más Más información

Clasificación de texto con TensorFlow Lite Model Maker

Ver en TensorFlow.org Ejecutar en Google Colab Ver fuente en GitHub Descargar cuaderno

La biblioteca fabricante TensorFlow Lite modelo simplifica el proceso de adaptación y la conversión de un modelo de datos de entrada TensorFlow particulares al implementar este modelo para aplicaciones de LD en el dispositivo.

Este cuaderno muestra un ejemplo de un extremo a otro que utiliza la biblioteca Model Maker para ilustrar la adaptación y conversión de un modelo de clasificación de texto de uso común para clasificar reseñas de películas en un dispositivo móvil. El modelo de clasificación de texto clasifica el texto en categorías predefinidas. Las entradas deben ser texto preprocesado y las salidas son las probabilidades de las categorías. El conjunto de datos utilizado en este tutorial son reseñas de películas positivas y negativas.

Prerrequisitos

Instale los paquetes requeridos

Para ejecutar este ejemplo, instalar los paquetes necesarios, incluyendo el paquete de fabricante Modelo de la cesión temporal de GitHub .

pip install -q tflite-model-maker

Importe los paquetes necesarios.

import numpy as np
import os

from tflite_model_maker import model_spec
from tflite_model_maker import text_classifier
from tflite_model_maker.config import ExportFormat
from tflite_model_maker.text_classifier import AverageWordVecSpec
from tflite_model_maker.text_classifier import DataLoader

import tensorflow as tf
assert tf.__version__.startswith('2')
tf.get_logger().setLevel('ERROR')
/tmpfs/src/tf_docs_env/lib/python3.7/site-packages/numba/core/errors.py:168: UserWarning: Insufficiently recent colorama version found. Numba requires colorama >= 0.3.9
  warnings.warn(msg)

Descargue los datos de entrenamiento de muestra.

En este tutorial, vamos a utilizar el SST-2 (Stanford sentimiento Treebank) que es una de las tareas en el pegamento de referencia. Contiene 67,349 reseñas de películas para entrenamiento y 872 reseñas de películas para pruebas. El conjunto de datos tiene dos clases: críticas de películas positivas y negativas.

data_dir = tf.keras.utils.get_file(
      fname='SST-2.zip',
      origin='https://dl.fbaipublicfiles.com/glue/data/SST-2.zip',
      extract=True)
data_dir = os.path.join(os.path.dirname(data_dir), 'SST-2')
Downloading data from https://dl.fbaipublicfiles.com/glue/data/SST-2.zip
7446528/7439277 [==============================] - 2s 0us/step
7454720/7439277 [==============================] - 2s 0us/step

El conjunto de datos SST-2 se almacena en formato TSV. La única diferencia entre TSV y CSV es que TSV utiliza una pestaña \t carácter delimitador como su lugar de una coma , en el formato CSV.

Aquí están las primeras 5 líneas del conjunto de datos de entrenamiento. label = 0 significa negativo, label = 1 significa positivo.

frase etiqueta
ocultar nuevas secreciones de las unidades parentales 0
no contiene ingenio, solo bromas laboriosas 0
que ama a sus personajes y comunica algo bastante hermoso sobre la naturaleza humana 1
permanece completamente satisfecho de seguir siendo el mismo durante todo 0
sobre los peores clichés de la venganza de los nerds que los cineastas pudieron sacar a la luz 0

A continuación, vamos a cargar el conjunto de datos en una trama de datos pandas y cambiar los nombres de las etiquetas actuales ( 0 y 1 ) a una las más legible ( negative y positive ) y los utilizan para el entrenamiento del modelo.

import pandas as pd

def replace_label(original_file, new_file):
  # Load the original file to pandas. We need to specify the separator as
  # '\t' as the training data is stored in TSV format
  df = pd.read_csv(original_file, sep='\t')

  # Define how we want to change the label name
  label_map = {0: 'negative', 1: 'positive'}

  # Excute the label change
  df.replace({'label': label_map}, inplace=True)

  # Write the updated dataset to a new file
  df.to_csv(new_file)

# Replace the label name for both the training and test dataset. Then write the
# updated CSV dataset to the current folder.
replace_label(os.path.join(os.path.join(data_dir, 'train.tsv')), 'train.csv')
replace_label(os.path.join(os.path.join(data_dir, 'dev.tsv')), 'dev.csv')

Inicio rápido

Hay cinco pasos para entrenar un modelo de clasificación de texto:

Paso 1. Elija una arquitectura de modelo de clasificación de texto.

Aquí utilizamos la arquitectura de modelo de incrustación de palabras promedio, que producirá un modelo pequeño y rápido con una precisión decente.

spec = model_spec.get('average_word_vec')

Modelo Maker también es compatible con otras arquitecturas como modelo BERT . Si usted está interesado en aprender sobre otra arquitectura, ver el Elija una arquitectura modelo de texto clasificador sección de abajo.

Paso 2. Cargar los datos de entrenamiento y de prueba, luego de preproceso de acuerdo a un determinado model_spec .

Model Maker puede tomar datos de entrada en formato CSV. Cargaremos el conjunto de datos de entrenamiento y prueba con el nombre de etiqueta legible por humanos que se creó anteriormente.

Cada arquitectura de modelo requiere que los datos de entrada se procesen de una manera particular. DataLoader lee el requisito de model_spec y automáticamente ejecuta el procesamiento previo necesario.

train_data = DataLoader.from_csv(
      filename='train.csv',
      text_column='sentence',
      label_column='label',
      model_spec=spec,
      is_training=True)
test_data = DataLoader.from_csv(
      filename='dev.csv',
      text_column='sentence',
      label_column='label',
      model_spec=spec,
      is_training=False)

Paso 3. Entrena el modelo de TensorFlow con los datos de entrenamiento.

El promedio palabra incrustación uso modelo batch_size = 32 por defecto. Por lo tanto, verá que se necesitan 2104 pasos para revisar las 67,349 oraciones en el conjunto de datos de entrenamiento. Entrenaremos el modelo durante 10 épocas, lo que significa pasar 10 veces por el conjunto de datos de entrenamiento.

model = text_classifier.create(train_data, model_spec=spec, epochs=10)
Epoch 1/10
2104/2104 [==============================] - 7s 3ms/step - loss: 0.6694 - accuracy: 0.5844
Epoch 2/10
2104/2104 [==============================] - 6s 3ms/step - loss: 0.5232 - accuracy: 0.7468
Epoch 3/10
2104/2104 [==============================] - 6s 3ms/step - loss: 0.4200 - accuracy: 0.8097
Epoch 4/10
2104/2104 [==============================] - 6s 3ms/step - loss: 0.3808 - accuracy: 0.8339
Epoch 5/10
2104/2104 [==============================] - 6s 3ms/step - loss: 0.3598 - accuracy: 0.8468
Epoch 6/10
2104/2104 [==============================] - 6s 3ms/step - loss: 0.3480 - accuracy: 0.8536
Epoch 7/10
2104/2104 [==============================] - 6s 3ms/step - loss: 0.3374 - accuracy: 0.8588
Epoch 8/10
2104/2104 [==============================] - 6s 3ms/step - loss: 0.3308 - accuracy: 0.8640
Epoch 9/10
2104/2104 [==============================] - 6s 3ms/step - loss: 0.3248 - accuracy: 0.8665
Epoch 10/10
2104/2104 [==============================] - 6s 3ms/step - loss: 0.3192 - accuracy: 0.8682

Paso 4. Evalúe el modelo con los datos de prueba.

Después de entrenar el modelo de clasificación de texto usando las oraciones en el conjunto de datos de entrenamiento, usaremos las 872 oraciones restantes en el conjunto de datos de prueba para evaluar cómo se desempeña el modelo contra nuevos datos que nunca antes había visto.

Como el tamaño de lote predeterminado es 32, se necesitarán 28 pasos para revisar las 872 oraciones en el conjunto de datos de prueba.

loss, acc = model.evaluate(test_data)
28/28 [==============================] - 0s 2ms/step - loss: 0.5198 - accuracy: 0.8314

Paso 5. Exportar como modelo de TensorFlow Lite.

Exportemos la clasificación de texto que hemos entrenado en el formato TensorFlow Lite. Especificaremos qué carpeta exportar el modelo. De forma predeterminada, el modelo flotante TFLite se exporta para la arquitectura de modelo de incrustación de palabras promedio.

model.export(export_dir='average_word_vec')
2021-10-07 11:59:17.166040: W tensorflow/python/util/util.cc:348] Sets are not currently considered sequences, but this may change in the future, so consider avoiding using them.
2021-10-07 11:59:17.713200: W tensorflow/compiler/mlir/lite/python/tf_tfl_flatbuffer_helpers.cc:351] Ignored output_format.
2021-10-07 11:59:17.713245: W tensorflow/compiler/mlir/lite/python/tf_tfl_flatbuffer_helpers.cc:354] Ignored drop_control_dependency.

Puede descargar el archivo de modelo de TensorFlow Lite con la barra lateral izquierda de Colab. Entra en el average_word_vec carpeta que hemos especificado en export_dir parámetro anterior, haga clic en el model.tflite archivo y seleccione Download para descargarlo en su ordenador local.

Este modelo se puede integrar en un Android o una aplicación para iOS usando la API NLClassifier de la biblioteca de tareas Lite TensorFlow .

Ver la aplicación de ejemplo Clasificación TFLite texto para más detalles sobre cómo se utiliza el modelo en una aplicación de trabajo.

Nota 1: El enlace de modelos de Android Studio aún no admite la clasificación de texto, así que utilice la biblioteca de tareas de TensorFlow Lite.

Nota 2: Hay una model.json archivo en la misma carpeta con el modelo TFLite. Contiene la representación JSON del metadatos incluido dentro del modelo TensorFlow Lite. Los metadatos del modelo ayudan a la biblioteca de tareas de TFLite a saber qué hace el modelo y cómo preprocesar / postprocesar los datos para el modelo. No es necesario descargar la model.json archivo ya que es sólo para fines informativos y su contenido está ya dentro del archivo TFLite.

Nota 3: Si se entrena un modelo de clasificación de texto usando MobileBERT o la arquitectura BERT-Base, tendrá que utilizar la API BertNLClassifier en lugar de integrar el modelo entrenado en una aplicación móvil.

Las siguientes secciones recorren el ejemplo paso a paso para mostrar más detalles.

Elija una arquitectura modelo para Text Classifier

Cada model_spec objeto representa un modelo específico para el clasificador de texto. TensorFlow Lite Modelo Fabricante actualmente soporta MobileBERT , incrustaciones de palabras promediado y BERT-Base modelos.

Modelo admitido Nombre de model_spec descripcion del modelo Tamaño del modelo
Promedio de incrustación de palabras 'average_word_vec' Promedio de incrustaciones de palabras de texto con activación RELU. <1 MB
MobileBERT 'mobilebert_classifier' 4,3 veces más pequeño y 5,5 veces más rápido que BERT-Base mientras logra resultados competitivos, adecuado para aplicaciones en el dispositivo. 25 MB con cuantificación
100 MB sin cuantificación
Base BERT 'bert_classifier' Modelo BERT estándar que se usa ampliamente en tareas de PNL. 300 MB

En el inicio rápido, usamos el modelo de inserción de palabras promedio. Interruptor Vamos a MobileBERT para entrenar un modelo con mayor precisión.

mb_spec = model_spec.get('mobilebert_classifier')

Cargar datos de entrenamiento

Puede cargar su propio conjunto de datos para trabajar con este tutorial. Sube tu conjunto de datos usando la barra lateral izquierda en Colab.

Subir archivo

Si prefiere no cargar el conjunto de datos a la nube, también puede ejecutar localmente la biblioteca siguiendo la guía .

Para simplificarlo, reutilizaremos el conjunto de datos SST-2 descargado anteriormente. Vamos a usar la DataLoader.from_csv método para cargar los datos.

Tenga en cuenta que, dado que hemos cambiado la arquitectura del modelo, tendremos que volver a cargar el conjunto de datos de prueba y entrenamiento para aplicar la nueva lógica de preprocesamiento.

train_data = DataLoader.from_csv(
      filename='train.csv',
      text_column='sentence',
      label_column='label',
      model_spec=mb_spec,
      is_training=True)
test_data = DataLoader.from_csv(
      filename='dev.csv',
      text_column='sentence',
      label_column='label',
      model_spec=mb_spec,
      is_training=False)

La biblioteca fabricante modelo también apoya la from_folder() método para cargar datos. Asume que los datos de texto de la misma clase están en el mismo subdirectorio y que el nombre de la subcarpeta es el nombre de la clase. Cada archivo de texto contiene una muestra de reseña de películas. Los class_labels parámetro se utiliza para especificar qué las subcarpetas.

Entrena un modelo de TensorFlow

Entrene un modelo de clasificación de texto utilizando los datos de entrenamiento.

model = text_classifier.create(train_data, model_spec=mb_spec, epochs=3)
Epoch 1/3
1403/1403 [==============================] - 333s 198ms/step - loss: 0.3631 - test_accuracy: 0.8448
Epoch 2/3
1403/1403 [==============================] - 270s 193ms/step - loss: 0.1300 - test_accuracy: 0.9537
Epoch 3/3
1403/1403 [==============================] - 272s 194ms/step - loss: 0.0755 - test_accuracy: 0.9762

Examine la estructura detallada del modelo.

model.summary()
Model: "model"
__________________________________________________________________________________________________
Layer (type)                    Output Shape         Param #     Connected to                     
==================================================================================================
input_word_ids (InputLayer)     [(None, 128)]        0                                            
__________________________________________________________________________________________________
input_mask (InputLayer)         [(None, 128)]        0                                            
__________________________________________________________________________________________________
input_type_ids (InputLayer)     [(None, 128)]        0                                            
__________________________________________________________________________________________________
hub_keras_layer_v1v2 (HubKerasL (None, 512)          24581888    input_word_ids[0][0]             
                                                                 input_mask[0][0]                 
                                                                 input_type_ids[0][0]             
__________________________________________________________________________________________________
dropout_1 (Dropout)             (None, 512)          0           hub_keras_layer_v1v2[0][0]       
__________________________________________________________________________________________________
output (Dense)                  (None, 2)            1026        dropout_1[0][0]                  
==================================================================================================
Total params: 24,582,914
Trainable params: 24,582,914
Non-trainable params: 0
__________________________________________________________________________________________________

Evaluar el modelo

Evalúe el modelo que acabamos de entrenar utilizando los datos de prueba y mida la pérdida y el valor de precisión.

loss, acc = model.evaluate(test_data)
28/28 [==============================] - 10s 55ms/step - loss: 0.4050 - test_accuracy: 0.9002

Exportar como modelo de TensorFlow Lite

Convertir el modelo entrenado a formato modelo TensorFlow Lite con metadatos para que pueda utilizar más tarde en una aplicación ML en el dispositivo. El archivo de etiqueta y el archivo de vocabulario están incrustados en metadatos. El nombre de archivo por defecto es TFLite model.tflite .

En muchas aplicaciones de aprendizaje automático en el dispositivo, el tamaño del modelo es un factor importante. Por lo tanto, se recomienda que aplique cuantificar el modelo para hacerlo más pequeño y potencialmente ejecutar más rápido. La técnica de cuantificación posterior al entrenamiento predeterminada es la cuantificación de rango dinámico para los modelos BERT y MobileBERT.

model.export(export_dir='mobilebert/')
2021-10-07 12:15:39.015005: W tensorflow/compiler/mlir/lite/python/tf_tfl_flatbuffer_helpers.cc:351] Ignored output_format.
2021-10-07 12:15:39.015063: W tensorflow/compiler/mlir/lite/python/tf_tfl_flatbuffer_helpers.cc:354] Ignored drop_control_dependency.
2021-10-07 12:15:39.015073: W tensorflow/compiler/mlir/lite/python/tf_tfl_flatbuffer_helpers.cc:360] Ignored change_concat_input_ranges.

El archivo de modelo TensorFlow Lite se puede integrar en una aplicación móvil usando la API BertNLClassifier en TensorFlow Biblioteca de tareas Lite . Tenga en cuenta que esto es diferente de la NLClassifier API utilizado para integrar la clasificación de texto entrenado con la arquitectura media palabra modelo vectorial.

Los formatos de exportación pueden ser uno o una lista de los siguientes:

De forma predeterminada, exporta solo el archivo de modelo de TensorFlow Lite que contiene los metadatos del modelo. También puede optar por exportar otros archivos relacionados con el modelo para un mejor examen. Por ejemplo, exportar solo el archivo de etiqueta y el archivo de vocabulario de la siguiente manera:

model.export(export_dir='mobilebert/', export_format=[ExportFormat.LABEL, ExportFormat.VOCAB])

Se puede evaluar el modelo TFLite con evaluate_tflite método para medir su precisión. Convertir el modelo entrenado de TensorFlow al formato TFLite y aplicar la cuantificación puede afectar su precisión, por lo que se recomienda evaluar la precisión del modelo TFLite antes de la implementación.

accuracy = model.evaluate_tflite('mobilebert/model.tflite', test_data)
print('TFLite model accuracy: ', accuracy)
TFLite model accuracy:  {'accuracy': 0.9036697247706422}

Uso avanzado

El create función es la función de controlador que utiliza la biblioteca modelista para crear modelos. El model_spec parámetro define la especificación del modelo. Los AverageWordVecSpec y BertClassifierSpec clases están soportadas actualmente. El create de función consta de los pasos siguientes:

  1. Crea el modelo para el clasificador de texto de acuerdo con model_spec .
  2. Entrena el modelo clasificador. Las épocas por defecto y el tamaño de lote predeterminado se establecen por los default_training_epochs y default_batch_size variables en el model_spec objeto.

Esta sección cubre temas de uso avanzado como ajustar el modelo y los hiperparámetros de entrenamiento.

Personalizar los hiperparámetros del modelo MobileBERT

Los parámetros del modelo que puede ajustar son:

  • seq_len : Longitud de la secuencia de alimentación en el modelo.
  • initializer_range : La desviación estándar de la truncated_normal_initializer para inicializar todas las matrices de peso.
  • trainable : Boolean que especifica si la capa pre-entrenado es entrenable.

Los parámetros de la canalización de entrenamiento que puede ajustar son:

  • model_dir : La ubicación de los archivos de modelo de punto de control. Si no se establece, se utilizará un directorio temporal.
  • dropout_rate : La tasa de abandono.
  • learning_rate : La tasa de aprendizaje inicial para el optimizador de Adán.
  • tpu : la dirección de TPU para conectarse a.

Por ejemplo, se puede establecer el seq_len=256 (por defecto es 128). Esto permite que el modelo clasifique texto más extenso.

new_model_spec = model_spec.get('mobilebert_classifier')
new_model_spec.seq_len = 256

Personalizar los hiperparámetros del modelo de incrustación de palabras promedio

Se puede ajustar la infraestructura de modelo como el wordvec_dim y los seq_len variables en el AverageWordVecSpec clase.

Por ejemplo, se puede entrenar el modelo con un valor mayor de wordvec_dim . Observe que debe construir un nuevo model_spec si modifica el modelo.

new_model_spec = AverageWordVecSpec(wordvec_dim=32)

Obtenga los datos preprocesados.

new_train_data = DataLoader.from_csv(
      filename='train.csv',
      text_column='sentence',
      label_column='label',
      model_spec=new_model_spec,
      is_training=True)

Entrena el nuevo modelo.

model = text_classifier.create(new_train_data, model_spec=new_model_spec)
Epoch 1/3
2104/2104 [==============================] - 8s 4ms/step - loss: 0.6604 - accuracy: 0.5970
Epoch 2/3
2104/2104 [==============================] - 6s 3ms/step - loss: 0.4807 - accuracy: 0.7696
Epoch 3/3
2104/2104 [==============================] - 6s 3ms/step - loss: 0.3962 - accuracy: 0.8233

Ajustar los hiperparámetros de entrenamiento

También puede sintonizar los hiperparámetros formación como epochs y batch_size que afectan la exactitud del modelo. Por ejemplo,

  • epochs : más épocas podrían lograr una mayor precisión, pero pueden dar lugar a un ajuste por exceso.
  • batch_size : el número de muestras a utilizar en un solo paso de formación.

Por ejemplo, puedes entrenar con más épocas.

model = text_classifier.create(new_train_data, model_spec=new_model_spec, epochs=20)
Epoch 1/20
2104/2104 [==============================] - 7s 3ms/step - loss: 0.6621 - accuracy: 0.5950
Epoch 2/20
2104/2104 [==============================] - 6s 3ms/step - loss: 0.4874 - accuracy: 0.7679
Epoch 3/20
2104/2104 [==============================] - 6s 3ms/step - loss: 0.3993 - accuracy: 0.8215
Epoch 4/20
2104/2104 [==============================] - 6s 3ms/step - loss: 0.3657 - accuracy: 0.8397
Epoch 5/20
2104/2104 [==============================] - 7s 3ms/step - loss: 0.3471 - accuracy: 0.8509
Epoch 6/20
2104/2104 [==============================] - 6s 3ms/step - loss: 0.3359 - accuracy: 0.8572
Epoch 7/20
2104/2104 [==============================] - 7s 3ms/step - loss: 0.3261 - accuracy: 0.8624
Epoch 8/20
2104/2104 [==============================] - 6s 3ms/step - loss: 0.3190 - accuracy: 0.8666
Epoch 9/20
2104/2104 [==============================] - 6s 3ms/step - loss: 0.3142 - accuracy: 0.8681
Epoch 10/20
2104/2104 [==============================] - 6s 3ms/step - loss: 0.3096 - accuracy: 0.8703
Epoch 11/20
2104/2104 [==============================] - 6s 3ms/step - loss: 0.3062 - accuracy: 0.8738
Epoch 12/20
2104/2104 [==============================] - 6s 3ms/step - loss: 0.3043 - accuracy: 0.8736
Epoch 13/20
2104/2104 [==============================] - 6s 3ms/step - loss: 0.3008 - accuracy: 0.8751
Epoch 14/20
2104/2104 [==============================] - 6s 3ms/step - loss: 0.2991 - accuracy: 0.8767
Epoch 15/20
2104/2104 [==============================] - 6s 3ms/step - loss: 0.2981 - accuracy: 0.8772
Epoch 16/20
2104/2104 [==============================] - 6s 3ms/step - loss: 0.2948 - accuracy: 0.8783
Epoch 17/20
2104/2104 [==============================] - 6s 3ms/step - loss: 0.2936 - accuracy: 0.8799
Epoch 18/20
2104/2104 [==============================] - 6s 3ms/step - loss: 0.2919 - accuracy: 0.8811
Epoch 19/20
2104/2104 [==============================] - 6s 3ms/step - loss: 0.2904 - accuracy: 0.8813
Epoch 20/20
2104/2104 [==============================] - 6s 3ms/step - loss: 0.2889 - accuracy: 0.8818

Evalúe el modelo recién reentrenado con 20 épocas de entrenamiento.

new_test_data = DataLoader.from_csv(
      filename='dev.csv',
      text_column='sentence',
      label_column='label',
      model_spec=new_model_spec,
      is_training=False)

loss, accuracy = model.evaluate(new_test_data)
28/28 [==============================] - 0s 2ms/step - loss: 0.4911 - accuracy: 0.8291

Cambiar la arquitectura del modelo

Puede cambiar el modelo cambiando el model_spec . A continuación se muestra cómo cambiar al modelo BERT-Base.

Cambiar el model_spec al modelo BERT-Base para el clasificador de texto.

spec = model_spec.get('bert_classifier')

Los pasos restantes son los mismos.

Personalice la cuantificación posterior al entrenamiento en el modelo TensorFlow Lite

Después de la formación de cuantificación es una técnica de conversión que puede reducir el tamaño del modelo y la latencia de la inferencia, además de mejorar la velocidad de la CPU y el acelerador de hardware inferencia, con un poco de degradación en la precisión del modelo. Por lo tanto, se usa ampliamente para optimizar el modelo.

La biblioteca Model Maker aplica una técnica de cuantificación posterior al entrenamiento predeterminada al exportar el modelo. Si desea personalizar la cuantificación posterior al entrenamiento, Modelo Maker soporta múltiples opciones después de la formación de cuantificación utilizando QuantizationConfig también. Tomemos como ejemplo la cuantificación de float16. Primero, defina la configuración de cuantificación.

config = QuantizationConfig.for_float16()

Luego exportamos el modelo de TensorFlow Lite con dicha configuración.

model.export(export_dir='.', tflite_filename='model_fp16.tflite', quantization_config=config)

Lee mas

Usted puede leer nuestra clasificación de texto ejemplo para aprender detalles técnicos. Para obtener más información, consulte: