1. Antes de começar
Neste codelab, você vai analisar o código criado com o TensorFlow e o TensorFlow Lite Model Maker para criar um modelo com um conjunto de dados baseado em spam de comentários. Os dados originais estão disponíveis no Kaggle. Eles foram reunidos em um único CSV e limpos 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ê vai analisar é indicado aqui, mas é altamente recomendável que você o acompanhe no Google Colab.
Pré-requisitos
- Este codelab foi escrito para desenvolvedores experientes que ainda não conhecem o machine learning.
- Este codelab faz parte do Programa de treinamentos "Introdução à 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ê vai 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
O que é necessário
- 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 vai verificar se você está executando o TensorFlow 2.x, que é um requisito para usar o Model Maker.
4. Fazer 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ê vai aprender a fazer isso mais adiante no codelab.
5. Embeddings pré-aprendidas
Geralmente, quando você usa o Model Maker, 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 embeddings pré-aprendidas. A ideia por trás de uma incorporação é que as palavras sejam convertidas em números, com cada palavra no seu corpus recebendo um número. Uma embedding é um vetor usado para determinar o sentimento em uma palavra estabelecendo uma "direção" até ela. Por exemplo, as palavras usadas com frequência em mensagens de spam de comentários têm os vetores apontados para uma direção semelhante, e as palavras não apontadas têm os vetores para a direção oposta.
Ao usar embeddings pré-aprendidas, você começa com um corpus ou coleção de palavras cujo sentimento já foi aprendido em um grande corpo de texto. Isso vai ajudar você a encontrar uma solução muito mais rápido do que começar do zero.
O Model Maker oferece várias embeddings pré-aprendidas que podem ser usadas, mas a mais simples e rápida é a opção 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 especifica o número de palavras que quer que seu modelo use.
Talvez você pense "quanto mais, melhor", mas geralmente há um número certo com base na frequência de uso de cada palavra. Se você utilizar todas as palavras no corpus, o modelo poderá tentar aprender e estabelecer a direção das palavras que são aplicadas apenas uma vez. Em qualquer corpus de texto, muitas palavras são usadas apenas uma ou duas vezes. Geralmente, não vale a pena usá-las no modelo, já que elas têm um impacto insignificante no sentimento geral. É possível ajustar seu modelo com base no número de palavras que você quer usando o parâmetro num_words.
Um número menor pode gerar um modelo menor e mais rápido, mas pode ser menos preciso porque reconhece menos palavras. Um número maior aqui vai resultar em 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 de ouro determinada pela pesquisa é que ela é a quarta raiz do número de palavras. Por exemplo, se você estiver usando 2.000 palavras, um bom ponto de partida é 7. Se mudar o número de palavras, também poderá mudar essa configuraçã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 com uma duração estática específica. 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. Assim, seu modelo será treinado (neste caso) para classificar e reconhecer frases com 20 tokens. Se a frase for mais longa que isso, ela será truncada. Se for menor, terá padding. Você vai encontrar 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 o model_spec criado anteriormente, além de um caractere delimitador, que, nesse 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 (configurados na etapa 4), o modelo (configurado na etapa 4) e um número de períodos, que é 50 nesse caso.
O princípio básico do aprendizado de máquina é que ele é uma forma de correspondência de padrões. Inicialmente, ele carrega as ponderações pré-treinadas das palavras e tenta agrupá-las com uma previsão de quais indicam spam ou não. Na primeira vez, é provável que ele seja dividido uniformemente porque o modelo está apenas começando.
Em seguida, ele vai medir os resultados e executar o código de otimização para ajustar a previsão. Depois disso, você pode tentar novamente. Isso é um período. Se você especificar "epochs=50", o modelo vai passar por esse "loop" 50 vezes.
Quando você chega ao período 50, o modelo informa um nível de acurácia muito maior. Nesse caso, 99%.
No lado direito, você vai encontrar os números de acurácia da validação. Esses valores geralmente são um pouco menores do que a acurácia do treinamento, já que indicam como o modelo classifica os dados que não foram "vistos" antes. Ele usa os dados de teste de 10% que determinamos anteriormente.
8. Exportar o modelo
Depois que o treinamento for concluído, você poderá exportar o modelo.
O TensorFlow treina um modelo no próprio formato, que precisa ser convertido para o formato TFLITE para ser usado em um app para dispositivos móveis. O Model Maker lida com essa complexidade para você.
Basta exportar o modelo, especificando um diretório:
model.export(export_dir='/mm_spam')
Nesse diretório, você vai encontrar um arquivo model.tflite. faça o download, Você vai precisar dele no próximo codelab, em que vai adicioná-lo ao seu app Android.
Considerações sobre o iOS
O modelo .tflite que você acabou de exportar funciona bem para 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 da forma como o modelo as reconhece. Lembra quando você aprendeu que as palavras se tornam tokens, e esses tokens recebem vetores para o sentimento deles? Seu app para dispositivos móveis precisará conhecer esses tokens. Por exemplo, se "cachorro" foi tokenizado como 42 e os usuários digitarem "cachorro" em uma frase, seu app precisará converter "cachorro" em 42 para que o modelo entenda. Como desenvolvedor Android, você terá uma "Biblioteca de tarefas do TensorFlow Lite" que facilita o uso, mas no iOS é necessário processar o vocabulário, então ele precisa estar disponível. O Model Maker pode exportar isso para você especificando o parâmetro export_format. Para receber os rótulos e o vocabulário do seu modelo, use o seguinte:
model.export(export_dir='/mm_spam/',
export_format=[ExportFormat.LABEL, ExportFormat.VOCAB])
9. Parabéns
Este codelab mostrou o código Python para criar e exportar seu modelo. Você terá um arquivo .tflite no final.
No próximo codelab, você vai aprender a editar seu app Android para usar esse modelo e começar a classificar comentários de spam.