Classificação de texto com o TensorFlow Lite Model Maker

Ver no TensorFlow.org Executar no Google Colab Ver fonte no GitHub Baixar caderno

A biblioteca do TensorFlow Lite Model Maker simplifica o processo de adaptação e conversão de um modelo do TensorFlow para dados de entrada específicos ao implantar este modelo para aplicativos de ML no dispositivo.

Este bloco de notas mostra um exemplo completo que utiliza a biblioteca Model Maker para ilustrar a adaptação e conversão de um modelo de classificação de texto comumente usado para classificar resenhas de filmes em um dispositivo móvel. O modelo de classificação de texto classifica o texto em categorias predefinidas. As entradas devem ser um texto pré-processado e as saídas são as probabilidades das categorias. O conjunto de dados usado neste tutorial são resenhas de filmes positivas e negativas.

Pré-requisitos

Instale os pacotes necessários

Para executar este exemplo, instale os pacotes necessários, incluindo o pacote Model Maker do repositório GitHub .

pip install -q tflite-model-maker

Importe os pacotes necessários.

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:154: UserWarning: Insufficiently recent colorama version found. Numba requires colorama >= 0.3.9
  warnings.warn(msg)

Baixe os dados de treinamento de amostra.

Neste tutorial, usaremos o SST-2 (Stanford Sentiment Treebank), que é uma das tarefas do benchmark GLUE . Ele contém 67.349 críticas de filmes para treinamento e 872 críticas de filmes para teste. O conjunto de dados tem duas classes: críticas positivas e negativas de filmes.

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

O conjunto de dados SST-2 é armazenado no formato TSV. A única diferença entre TSV e CSV é que o TSV usa um caractere tab \t como seu delimitador em vez de uma vírgula , no formato CSV.

Aqui estão as primeiras 5 linhas do conjunto de dados de treinamento. rótulo = 0 significa negativo, rótulo = 1 significa positivo.

sentença rótulo
esconder novas secreções das unidades parentais 0
não contém sagacidade, apenas piadas elaboradas 0
que ama seus personagens e comunica algo bastante bonito sobre a natureza humana 1
permanece totalmente satisfeito em permanecer o mesmo durante todo 0
sobre os piores clichês de vingança dos nerds que os cineastas poderiam desenterrar 0

Em seguida, carregaremos o conjunto de dados em um dataframe do Pandas e alteraremos os nomes dos rótulos atuais ( 0 e 1 ) para outros mais legíveis ( negative e positive ) e os usaremos para o treinamento do 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')

Começo rápido

Existem cinco etapas para treinar um modelo de classificação de texto:

Etapa 1. Escolha uma arquitetura de modelo de classificação de texto.

Aqui usamos a arquitetura de modelo de incorporação de palavras média, que produzirá um modelo pequeno e rápido com uma precisão decente.

spec = model_spec.get('average_word_vec')

Model Maker também oferece suporte a outras arquiteturas de modelo, como BERT . Se você estiver interessado em aprender sobre outra arquitetura, consulte a seção Escolha uma arquitetura de modelo para o classificador de texto abaixo.

Etapa 2. Carregue os dados de treinamento e teste e pré- model_spec os de acordo com um model_spec específico.

O Model Maker pode obter dados de entrada no formato CSV. Carregaremos o conjunto de dados de treinamento e teste com o nome do rótulo legível que foi criado anteriormente.

Cada arquitetura de modelo requer que os dados de entrada sejam processados ​​de uma maneira particular. DataLoader lê o requisito de model_spec e executa automaticamente o pré-processamento necessário.

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)

Etapa 3. Treine o modelo TensorFlow com os dados de treinamento.

O modelo médio de incorporação de palavras usa batch_size = 32 por padrão. Portanto, você verá que são necessárias 2.104 etapas para percorrer as 67.349 frases no conjunto de dados de treinamento. Vamos treinar o modelo por 10 épocas, o que significa passar pelo conjunto de dados de treinamento 10 vezes.

model = text_classifier.create(train_data, model_spec=spec, epochs=10)
Epoch 1/10
2104/2104 [==============================] - 8s 3ms/step - loss: 0.6808 - accuracy: 0.5622
Epoch 2/10
2104/2104 [==============================] - 6s 3ms/step - loss: 0.5791 - accuracy: 0.7025
Epoch 3/10
2104/2104 [==============================] - 6s 3ms/step - loss: 0.4578 - accuracy: 0.7896
Epoch 4/10
2104/2104 [==============================] - 6s 3ms/step - loss: 0.4040 - accuracy: 0.8222
Epoch 5/10
2104/2104 [==============================] - 6s 3ms/step - loss: 0.3768 - accuracy: 0.8380
Epoch 6/10
2104/2104 [==============================] - 6s 3ms/step - loss: 0.3614 - accuracy: 0.8481
Epoch 7/10
2104/2104 [==============================] - 6s 3ms/step - loss: 0.3490 - accuracy: 0.8553
Epoch 8/10
2104/2104 [==============================] - 6s 3ms/step - loss: 0.3420 - accuracy: 0.8600
Epoch 9/10
2104/2104 [==============================] - 6s 3ms/step - loss: 0.3354 - accuracy: 0.8630
Epoch 10/10
2104/2104 [==============================] - 6s 3ms/step - loss: 0.3293 - accuracy: 0.8660

Etapa 4. Avalie o modelo com os dados de teste.

Depois de treinar o modelo de classificação de texto usando as sentenças no conjunto de dados de treinamento, usaremos as 872 sentenças restantes no conjunto de dados de teste para avaliar o desempenho do modelo em relação a novos dados que ele nunca viu antes.

Como o tamanho do lote padrão é 32, serão necessários 28 passos para percorrer as 872 sentenças no conjunto de dados de teste.

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

Etapa 5. Exportar como um modelo TensorFlow Lite.

Vamos exportar a classificação de texto que treinamos no formato TensorFlow Lite. Vamos especificar qual pasta exportar o modelo. Por padrão, o modelo flutuante TFLite é exportado para a arquitetura de modelo de incorporação de palavras média.

model.export(export_dir='average_word_vec')

Você pode fazer o download do arquivo do modelo TensorFlow Lite usando a barra lateral esquerda do Colab. Vá para a pasta average_word_vec conforme especificamos no parâmetro export_dir acima, clique com o botão direito no arquivo model.tflite e escolha Download para baixá-lo para seu computador local.

Este modelo pode ser integrado a um aplicativo Android ou iOS usando a API NLClassifier da Biblioteca de Tarefas do TensorFlow Lite .

Consulte o aplicativo de amostra TFLite Text Classification para obter mais detalhes sobre como o modelo é usado em um aplicativo funcional.

Nota 1: o Android Studio Model Binding ainda não oferece suporte à classificação de texto, portanto, use a Biblioteca de Tarefas do TensorFlow Lite.

Nota 2: Existe um arquivo model.json na mesma pasta com o modelo TFLite. Ele contém a representação JSON dos metadados agrupados dentro do modelo TensorFlow Lite. Os metadados do modelo ajudam a Biblioteca de Tarefas TFLite a saber o que o modelo faz e como pré-processar / pós-processar dados para o modelo. Você não precisa baixar o arquivo model.json , pois é apenas para fins informativos e seu conteúdo já está dentro do arquivo TFLite.

Nota 3: Se você treinar um modelo de classificação de texto usando a arquitetura MobileBERT ou BERT-Base, você precisará usar a API BertNLClassifier para integrar o modelo treinado em um aplicativo móvel.

As seções a seguir percorrem o exemplo passo a passo para mostrar mais detalhes.

Escolha uma arquitetura de modelo para o Classificador de Texto

Cada objeto model_spec representa um modelo específico para o classificador de texto. O TensorFlow Lite Model Maker atualmente é compatível com MobileBERT , fazendo a média de embeddings de palavras e modelos de base de BERT .

Modelo Suportado Nome do model_spec Descrição do Modelo Tamanho do modelo
Média de incorporação de palavras 'average_word_vec' Fazendo a média de embeddings de palavras de texto com ativação RELU. <1 MB
MobileBERT 'mobilebert_classifier' 4,3x menor e 5,5x mais rápido que o BERT-Base, ao mesmo tempo que atinge resultados competitivos, adequado para aplicações no dispositivo. 25 MB com quantização
100 MB sem quantização
BERT-Base 'bert_classifier' Modelo de BERT padrão amplamente utilizado em tarefas de PNL. 300 MB

No início rápido, usamos o modelo médio de incorporação de palavras. Vamos mudar para MobileBERT para treinar um modelo com maior precisão.

mb_spec = model_spec.get('mobilebert_classifier')

Carregar dados de treinamento

Você pode carregar seu próprio conjunto de dados para trabalhar neste tutorial. Faça upload do seu conjunto de dados usando a barra lateral esquerda do Colab.

Subir arquivo

Se você preferir não fazer upload de seu conjunto de dados para a nuvem, também pode executar a biblioteca localmente, seguindo o guia .

Para simplificar, reutilizaremos o conjunto de dados SST-2 baixado anteriormente. Vamos usar o método DataLoader.from_csv para carregar os dados.

Observe que, como alteramos a arquitetura do modelo, precisaremos recarregar o conjunto de dados de treinamento e teste para aplicar a nova lógica de pré-processamento.

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)

A biblioteca do Model Maker também suporta o método from_folder() para carregar dados. Ele assume que os dados de texto da mesma classe estão no mesmo subdiretório e que o nome da subpasta é o nome da classe. Cada arquivo de texto contém uma amostra de revisão de filme. O parâmetro class_labels é usado para especificar quais as subpastas.

Treine um modelo TensorFlow

Treine um modelo de classificação de texto usando os dados de treinamento.

model = text_classifier.create(train_data, model_spec=mb_spec, epochs=3)
Epoch 1/3
1403/1403 [==============================] - 319s 191ms/step - loss: 0.3808 - test_accuracy: 0.8441
Epoch 2/3
1403/1403 [==============================] - 262s 187ms/step - loss: 0.1296 - test_accuracy: 0.9534
Epoch 3/3
1403/1403 [==============================] - 264s 188ms/step - loss: 0.0750 - test_accuracy: 0.9759

Examine a estrutura detalhada do 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
__________________________________________________________________________________________________

Avalie o modelo

Avalie o modelo que acabamos de treinar usando os dados de teste e meça o valor de perda e precisão.

loss, acc = model.evaluate(test_data)
28/28 [==============================] - 7s 50ms/step - loss: 0.3626 - test_accuracy: 0.9037

Exportar como um modelo TensorFlow Lite

Converta o modelo treinado para o formato de modelo TensorFlow Lite com metadados para que você possa usar posteriormente em um aplicativo de ML no dispositivo. O arquivo de etiqueta e o arquivo de vocabulário são incorporados aos metadados. O nome de arquivo TFLite padrão é model.tflite .

Em muitos aplicativos de ML no dispositivo, o tamanho do modelo é um fator importante. Portanto, é recomendado que você aplique quantizar o modelo para torná-lo menor e potencialmente rodar mais rápido. A técnica de quantização pós-treinamento padrão é a quantização de faixa dinâmica para os modelos BERT e MobileBERT.

model.export(export_dir='mobilebert/')

O arquivo de modelo do TensorFlow Lite pode ser integrado a um aplicativo móvel usando a API BertNLClassifier na Biblioteca de Tarefas do TensorFlow Lite . Observe que isso é diferente da API NLClassifier usada para integrar a classificação de texto treinada com a arquitetura de modelo de vetor de palavras média.

Os formatos de exportação podem ser um ou uma lista dos seguintes:

Por padrão, ele exporta apenas o arquivo de modelo do TensorFlow Lite que contém os metadados do modelo. Você também pode optar por exportar outros arquivos relacionados ao modelo para um melhor exame. Por exemplo, exportar apenas o arquivo de etiqueta e o arquivo de vocabulário da seguinte forma:

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

Você pode avaliar o modelo TFLite com o método evaluate_tflite para medir sua precisão. Converter o modelo TensorFlow treinado para o formato TFLite e aplicar a quantização pode afetar sua precisão, por isso é recomendado avaliar a precisão do modelo TFLite antes da implantação.

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

Uso Avançado

A função de create é a função de driver que a biblioteca Model Maker usa para criar modelos. O parâmetro model_spec define a especificação do modelo. Os AverageWordVecSpec e BertClassifierSpec aulas são suportadas atualmente. A função de create compreende as seguintes etapas:

  1. Cria o modelo para o classificador de texto de acordo com model_spec .
  2. Treina o modelo do classificador. As épocas padrão e o tamanho do lote padrão são definidas pelas default_training_epochs e default_batch_size variáveis no model_spec objeto.

Esta seção cobre tópicos de uso avançado, como ajuste do modelo e hiperparâmetros de treinamento.

Personalize os hiperparâmetros do modelo MobileBERT

Os parâmetros do modelo que você pode ajustar são:

  • seq_len : Comprimento da sequência para alimentar o modelo.
  • initializer_range : O desvio padrão do truncated_normal_initializer para inicializar todas as matrizes de peso.
  • trainable : booleano que especifica se a camada pré-treinada é treinável.

Os parâmetros do pipeline de treinamento que você pode ajustar são:

  • model_dir : a localização dos arquivos de ponto de verificação do modelo. Se não for definido, um diretório temporário será usado.
  • dropout_rate : a taxa de abandono.
  • learning_rate : A taxa de aprendizado inicial para o otimizador Adam.
  • tpu : endereço TPU ao qual se conectar.

Por exemplo, você pode definir o seq_len=256 (o padrão é 128). Isso permite que o modelo classifique textos mais longos.

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

Personalize a média dos hiperparâmetros do modelo de incorporação de palavras

Você pode ajustar a infraestrutura do modelo como as wordvec_dim e seq_len na classe AverageWordVecSpec .

Por exemplo, você pode treinar o modelo com um valor maior de wordvec_dim . Observe que você deve construir um novo model_spec se modificar o modelo.

new_model_spec = AverageWordVecSpec(wordvec_dim=32)

Obtenha os dados pré-processados.

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

Treine o novo modelo.

model = text_classifier.create(new_train_data, model_spec=new_model_spec)
Epoch 1/3
2104/2104 [==============================] - 9s 4ms/step - loss: 0.6725 - accuracy: 0.5775
Epoch 2/3
2104/2104 [==============================] - 7s 3ms/step - loss: 0.5202 - accuracy: 0.7484
Epoch 3/3
2104/2104 [==============================] - 7s 3ms/step - loss: 0.4149 - accuracy: 0.8130

Ajuste os hiperparâmetros de treinamento

Você também pode ajustar os hiperparâmetros de treinamento, como epochs e batch_size que afetam a precisão do modelo. Por exemplo,

  • epochs : mais épocas podem atingir uma melhor precisão, mas podem levar ao sobreajuste.
  • batch_size : o número de amostras a serem usadas em uma etapa de treinamento.

Por exemplo, você pode treinar com mais épocas.

model = text_classifier.create(new_train_data, model_spec=new_model_spec, epochs=20)
Epoch 1/20
2104/2104 [==============================] - 8s 3ms/step - loss: 0.6646 - accuracy: 0.5916
Epoch 2/20
2104/2104 [==============================] - 7s 3ms/step - loss: 0.4966 - accuracy: 0.7625
Epoch 3/20
2104/2104 [==============================] - 7s 3ms/step - loss: 0.4063 - accuracy: 0.8183
Epoch 4/20
2104/2104 [==============================] - 7s 3ms/step - loss: 0.3713 - accuracy: 0.8380
Epoch 5/20
2104/2104 [==============================] - 7s 3ms/step - loss: 0.3530 - accuracy: 0.8508
Epoch 6/20
2104/2104 [==============================] - 7s 3ms/step - loss: 0.3409 - accuracy: 0.8565
Epoch 7/20
2104/2104 [==============================] - 7s 3ms/step - loss: 0.3305 - accuracy: 0.8611
Epoch 8/20
2104/2104 [==============================] - 7s 3ms/step - loss: 0.3240 - accuracy: 0.8663
Epoch 9/20
2104/2104 [==============================] - 7s 3ms/step - loss: 0.3186 - accuracy: 0.8677
Epoch 10/20
2104/2104 [==============================] - 7s 3ms/step - loss: 0.3137 - accuracy: 0.8701
Epoch 11/20
2104/2104 [==============================] - 7s 3ms/step - loss: 0.3100 - accuracy: 0.8725
Epoch 12/20
2104/2104 [==============================] - 7s 3ms/step - loss: 0.3071 - accuracy: 0.8732
Epoch 13/20
2104/2104 [==============================] - 7s 3ms/step - loss: 0.3041 - accuracy: 0.8740
Epoch 14/20
2104/2104 [==============================] - 7s 3ms/step - loss: 0.3013 - accuracy: 0.8767
Epoch 15/20
2104/2104 [==============================] - 7s 3ms/step - loss: 0.2999 - accuracy: 0.8772
Epoch 16/20
2104/2104 [==============================] - 7s 3ms/step - loss: 0.2976 - accuracy: 0.8772
Epoch 17/20
2104/2104 [==============================] - 7s 3ms/step - loss: 0.2963 - accuracy: 0.8797
Epoch 18/20
2104/2104 [==============================] - 7s 3ms/step - loss: 0.2942 - accuracy: 0.8806
Epoch 19/20
2104/2104 [==============================] - 7s 3ms/step - loss: 0.2927 - accuracy: 0.8807
Epoch 20/20
2104/2104 [==============================] - 7s 3ms/step - loss: 0.2900 - accuracy: 0.8818

Avalie o modelo recém-treinado com 20 períodos de treinamento.

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.4985 - accuracy: 0.8326

Mudar a arquitetura do modelo

Você pode alterar o modelo alterando o model_spec . O seguinte mostra como mudar para o modelo BERT-Base.

Altere o model_spec para o modelo BERT-Base para o classificador de texto.

spec = model_spec.get('bert_classifier')

As etapas restantes são as mesmas.

Personalize a quantização pós-treinamento no modelo TensorFlow Lite

A quantização pós-treinamento é uma técnica de conversão que pode reduzir o tamanho do modelo e a latência de inferência, ao mesmo tempo que melhora a velocidade de inferência do acelerador de hardware e CPU, com um pouco de degradação na precisão do modelo. Portanto, é amplamente utilizado para otimizar o modelo.

A biblioteca do Model Maker aplica uma técnica de quantização pós-treinamento padrão ao exportar o modelo. Se você deseja personalizar a quantização pós-treinamento, o Model Maker oferece suporte a várias opções de quantização pós-treinamento usando QuantizationConfig também. Vamos tomar a quantização float16 como uma instância. Primeiro, defina a configuração de quantização.

config = QuantizationConfig.for_float16()

Em seguida, exportamos o modelo TensorFlow Lite com essa configuração.

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

Consulte Mais informação

Você pode ler nosso exemplo de classificação de texto para aprender detalhes técnicos. Para obter mais informações, consulte: