1. Antes de começar
Neste codelab, você analisará o código criado usando o TensorFlow e o TensorFlow Lite Model Maker para criar um modelo usando um conjunto de dados com base em spam de comentários. Os dados originais estão disponíveis no Kaggle. Elas foram reunidas em um único CSV e limpas com a remoção de texto corrompido, marcação, palavras repetidas e muito mais. Isso facilitará se concentrar no modelo em vez do texto.
O código que você analisará foi fornecido aqui, mas é altamente recomendável que você o acompanhe no Google Colab.
Prerequisites
- Este codelab foi escrito para desenvolvedores experientes que ainda não conhecem o machine learning.
- Este codelab faz parte do programa de primeiros passos da classificação de texto para dispositivos móveis. Se você ainda não concluiu as atividades anteriores, pare e faça isso agora:
O que você aprenderá
- Como instalar o TensorFlow Lite Model Maker usando o Google Colab
- Como fazer o download dos dados do servidor do Cloud para seu dispositivo.
- Como usar um carregador de dados
- Como criar o modelo
Pré-requisitos
- Acesso ao Google Colab
2. Instalar o TensorFlow Lite Model Maker
Abra o colab. A primeira célula no notebook vai instalar o TensorFLow Lite Model Maker para você:
!pip install -q tflite-model-maker
Quando esse processo for concluído, passe para a próxima célula.
3. Importar o código
A próxima célula tem uma série de importações que o código no notebook precisará usar:
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')
Isso também verificará se você está executando o TensorFlow 2.x, que é um requisito para usar o Model Maker.
4. Fazer o download dos dados
Em seguida, faça o download dos dados do servidor do Cloud para seu dispositivo e defina data_file para apontar para o arquivo 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)
O Model Maker pode treinar modelos em arquivos CSV simples como este. Basta especificar quais colunas contêm o texto e quais contêm os rótulos. Você aprenderá a fazer isso mais tarde no codelab.
5. Embeddings pré-aprendidas
Geralmente, ao usar o Model Maker, você não cria modelos do zero. É possível usar modelos personalizados de acordo com suas necessidades.
Para modelos de linguagem, como este, isso envolve o uso de incorporações pré-aprendidas. A ideia por trás de um embedding é que as palavras são convertidas em números, e cada palavra no seu corpus recebe um número. Um incorporação é um vetor usado para determinar o sentimento em uma palavra, estabelecendo uma "direção" para ela. Por exemplo, as palavras usadas com frequência em mensagens de spam de comentários farão com que os vetores delas apontem em uma direção semelhante, e as palavras que não usam apontem para a direção oposta.
Ao usar os embeddings pré-aprendidos, você começa com um corpus, ou coleção, de palavras que já tiveram o sentimento aprendido com um grande corpo de texto. Assim, você chegará a uma solução muito mais rapidamente do que começando do zero.
O Model Maker oferece vários embeddings predefinidos que você pode usar, mas o mais simples e rápido é average_word_vec.
O código fica assim:
spec = model_spec.get('average_word_vec')
spec.num_words = 2000
spec.seq_len = 20
spec.wordvec_dim = 7
Parâmetro num_words
Você também especificará o número de palavras que quer que o modelo use.
Você pode pensar: "quanto mais, melhor", mas geralmente há um número certo com base na frequência de uso de cada palavra. Se você usar todas as palavras no corpus, poderá acabar com o modelo tentando aprender e estabelecer a direção das palavras que são usadas apenas uma vez. Você verá em qualquer corpus de texto que muitas palavras são usadas apenas uma ou duas vezes, e geralmente não vale a pena usá-las no seu modelo, porque elas têm um impacto insignificante no sentimento geral. É possível ajustar o modelo com o número desejado de palavras usando o parâmetro num_words.
Um número menor aqui pode gerar um modelo menor e mais rápido, mas pode ser menos preciso, já que reconhece menos palavras. Um número maior aqui terá um modelo maior e mais lento. Encontrar o ponto ideal é fundamental.
Parâmetro wordvec_dim
O parâmetro wordved_dim é o número de dimensões que você quer usar para o vetor de cada palavra. A regra geral é determinada pela pesquisa e é a quarta raiz do número de palavras. Por exemplo, se você estiver usando 2000 palavras, um bom ponto de partida é 7. Se você mudar o número de palavras usadas, também poderá fazer essa alteração.
Parâmetro seq_len
Os modelos geralmente são muito rígidos quando se trata de valores de entrada. Para um modelo de linguagem, isso significa que ele pode classificar frases de um determinado tamanho estático. Isso é determinado pelo parâmetro seq_len ou pela duração da sequência.
Quando você converte palavras em números (ou tokens), uma frase se torna uma sequência desses tokens. Então, seu modelo será treinado, neste caso, para classificar e reconhecer frases com 20 tokens. Se a frase for maior que isso, ela ficará truncada. Se for menor, ele será preenchido. Você verá um token <PAD> dedicado no corpus que será usado para isso.
6. Usar um carregador de dados
Anteriormente, você fez o download do arquivo CSV. Agora é hora de usar um carregador de dados para transformá-lo em dados de treinamento que o modelo reconheça:
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)
Se você abrir o arquivo CSV em um editor, verá que cada linha tem apenas dois valores, que são descritos com texto na primeira linha. Normalmente, cada entrada é considerada uma coluna.
Você verá que o descritor da primeira coluna é commenttext e que a primeira entrada em cada linha é o texto do comentário. Da mesma forma, o descritor da segunda coluna é spam e a segunda entrada em cada linha é True ou False, para indicar se o texto é considerado spam de comentários ou não. As outras propriedades definem a model_spec, que você criou anteriormente, com um caractere delimitador, que, neste caso, é uma vírgula, já que o arquivo é separado por vírgulas. Você usará esses dados para treinar o modelo. Portanto, is_Training é definido como True.
Você precisará reter parte dos dados para testar o modelo. Divida os dados, sendo 90% deles para treinamento, e os outros 10% para teste/avaliação. Ao mesmo tempo, queremos garantir que os dados de teste sejam escolhidos aleatoriamente, e não os "10%" na parte inferior do conjunto de dados. Por isso, use shuffle=True ao carregar os dados para aleatorizá-los.
7. Criar o modelo
A próxima célula é simplesmente criar o modelo com uma única linha de código:
# Build the model
model = text_classifier.create(train_data, model_spec=spec, epochs=50,
validation_data=test_data)
Isso cria um modelo de classificador de texto com o Model Maker, e você especifica os dados de treinamento que quer usar (conforme configurado na etapa 4), a especificação do modelo (conforme configurado na etapa 4) e um número de períodos, nesse caso, 50
O princípio básico do aprendizado de máquina é que ele é uma forma de correspondência de padrões. Inicialmente, ela carregará os pesos pré-treinados das palavras e tentará agrupá-las com uma previsão de quais, quando agrupadas, indicam spam e quais não fazem isso. Na primeira vez, é provável que esteja perto dos 50:50, já que o modelo só está começando.
Depois, ele vai medir os resultados, executar o código de otimização para ajustar a previsão e tentar novamente. Isso é um período. Se você especificar "epochs=50", o modelo vai passar por esse "loop" 50 vezes.
Quando você chegar à época 50, o modelo informará um nível de precisão muito maior. Nesse caso, temos 99%.
No lado direito, você verá os valores de precisão da validação. Normalmente, elas são um pouco mais baixas do que a precisão do treinamento, já que são uma indicação de como o modelo classifica os dados que ainda não foram "vistos". Ele usa os dados de teste de 10% que separamos anteriormente.
8. Exportar o modelo
Depois que o treinamento terminar, será possível exportar o modelo.
O TensorFlow treina um modelo no próprio formato. Ele precisa ser convertido no formato TFLITE para ser usado em um app para dispositivos móveis. O Model Maker cuida dessa complexidade para você.
Basta exportar o modelo, especificando um diretório:
model.export(export_dir='/mm_spam')
Nesse diretório, você verá um arquivo model.tflite. Faça o download. Você precisará dele no próximo codelab, em que será adicionado ao app Android.
Considerações sobre o iOS
O modelo .tflite que você acabou de exportar funciona bem para o Android, porque os metadados sobre ele estão incorporados, e o Android Studio pode ler esses metadados.
Esses metadados são muito importantes porque incluem um dicionário de tokens que representam palavras conforme o modelo as reconhece. Lembra quando você aprendeu que as palavras se tornam tokens e que esses tokens recebem vetores para o sentimento delas? Seu app para dispositivos móveis precisará saber esses tokens. Por exemplo, se "cachorro" for tokenizado como 42 e os usuários digitarem "cachorro" em uma frase, o app precisará converter "cachorro" em 42 para que o modelo o entenda. Como desenvolvedor Android, você terá uma biblioteca de tarefas do TensorFlow Lite que facilita o uso. No iOS, no entanto, será necessário processar o vocabulário, portanto, será necessário disponibilizá-lo. O Model Maker pode exportar isso para você especificando o parâmetro export_format. Então, para ver os rótulos e o vocabulário do seu modelo, use:
model.export(export_dir='/mm_spam/',
export_format=[ExportFormat.LABEL, ExportFormat.VOCAB])
9. Parabéns
Este codelab guiou você pelo código Python para criar e exportar seu modelo. Ao final, você terá um arquivo .tflite.
No próximo codelab, você verá como editar seu app Android para usar esse modelo e começar a classificar comentários de spam.