1. Antes de começar
Neste codelab, você vai revisar o código criado com o TensorFlow e o TensorFlow Lite Model Maker para criar um modelo usando 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 textos corrompidos, marcações, palavras repetidas e muito mais. Isso facilitará se concentrar no modelo em vez do texto.
O código que você vai analisar foi disponibilizado aqui, mas é altamente recomendável acompanhar o código 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 aprendizagem "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 Google 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 verifica se você está executando o TensorFlow 2.x, que é um requisito para usar o Model Maker.
4. Fazer download dos dados
Em seguida, você fará o download dos dados do servidor do Cloud para seu dispositivo e definirá 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. Você só precisa especificar quais colunas contêm o texto e quais contêm os rótulos. Você verá como fazer isso mais adiante neste 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 embeddings pré-aprendidas. A ideia por trás da incorporação é que as palavras são convertidas em números, e cada palavra no corpus recebe um número. Um embedding é um vetor usado para determinar o sentimento de uma palavra estabelecendo uma "direção" para a palavra. Por exemplo, as palavras usadas com frequência em mensagens de spam de comentários acabam tendo seus vetores apontando para uma direção semelhante, e as palavras que não estão na direção oposta.
Ao usar embeddings pré-aprendidos, você começa com um corpus, ou coleção, de palavras que já tiveram sentimentos aprendidos com um grande corpo de texto. Isso levará você a uma solução muito mais rápido do que começar do zero.
O Model Maker oferece vários embeddings pré-aprendidos que podem ser usados, mas o mais simples e rápido de começar é 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 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 do corpus, o modelo poderá tentar aprender e estabelecer a direção das palavras que são usadas apenas uma vez. Em qualquer corpus de texto, é possível observar que muitas palavras são usadas apenas uma ou duas vezes. Geralmente, não vale a pena usá-las no modelo, porque elas têm um impacto insignificante no sentimento geral. É possível ajustar seu modelo no número de palavras que você quiser usando o parâmetro num_words.
Um número menor aqui pode resultar em 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 prática determinada pela pesquisa é que é a quarta raiz do número de palavras. Por exemplo, se estiver usando 2.000 palavras, um bom ponto de partida é 7. Se você mudar o número de palavras usadas, 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 um comprimento específico e 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. Assim, seu modelo será treinado (neste caso) para classificar e reconhecer frases com 20 tokens. Se a frase for mais longa do que isso, ela ficará truncada. Se for mais curto, terá padding. 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 o model_spec que você criou anteriormente com 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. Você especifica os dados de treinamento que quer usar (conforme definido na etapa 4), a especificação do modelo (como definido na etapa 4) e um número de períodos, neste caso, 50.
O princípio básico do machine learning é que ele é uma forma de correspondência de padrões. Inicialmente, ele carrega as ponderações pré-treinadas para as palavras e tenta agrupá-las com uma previsão de quais, quando agrupadas, indicam spam e quais não indicam. Na primeira vez, é provável que seja perto de 50:50, porque o modelo está apenas começando.
Em seguida, ele 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ê atinge o 50o período, o modelo relata um nível de acurácia muito maior. Neste caso, mostrar 99%!
No lado direito, você verá os números de precisão da validação. Normalmente, elas são um pouco menores do que a acurácia do treinamento, porque são uma indicação de como o modelo classifica os dados que não foram "vistos" antes. Ela usa os dados de teste de 10% definidos anteriormente.
8. Exportar o modelo
Quando o treinamento terminar, você poderá exportar o modelo.
O TensorFlow treina um modelo no próprio formato, e isso 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ê verá 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 do iOS
O modelo .tflite que você acabou de exportar funciona bem para Android, porque os metadados sobre o modelo sã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 à medida que o modelo as reconhece. Lembra-se de quando você aprendeu que as palavras se tornam tokens e esses tokens recebem vetores de acordo com o sentimento que eles expressam? Seu aplicativo para dispositivos móveis precisará conhecer esses tokens. Por exemplo, se "cachorro" foi tokenizado para 42, e seus usuários digitaram "cachorro" em uma frase, o aplicativo precisará converter "cachorro" a 42 para que o modelo a entenda. Como desenvolvedor Android, você terá uma "Biblioteca de tarefas do TensorFlow Lite" Isso facilita o uso do recurso. No iOS, é necessário processar o vocabulário e ele deve estar disponível. O Model Maker pode exportar isso para você especificando o parâmetro export_format. Portanto, para conseguir os rótulos e o vocabulário do seu modelo, você pode usar isto:
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 ao 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.