TensorFlow.js: treinar novamente um modelo de detecção de spam de comentários para lidar com casos extremos

1. Antes de começar

Este codelab foi criado com base no resultado final do codelab anterior desta série para detecção de spam de comentários usando o TensorFlow.js.

No último codelab, você criou uma página da Web totalmente funcional para um videoblog fictício. Você conseguiu filtrar comentários para spam antes que eles fossem enviados ao servidor para armazenamento ou a outros clientes conectados, usando um modelo pré-treinado de detecção de spam de comentários com tecnologia do TensorFlow.js no navegador.

O resultado final desse codelab é mostrado abaixo:

Embora isso tenha funcionado muito bem, há casos extremos que não foram detectados. Você pode treinar o modelo novamente para lidar com as situações que ele não conseguiu processar.

Este codelab se concentra no uso do processamento de linguagem natural (a arte de entender a linguagem humana com um computador) e mostra como modificar um app da Web criado (é altamente recomendável fazer os codelabs em ordem) para resolver o problema real de spam de comentários, que muitos desenvolvedores da Web certamente vão encontrar ao trabalhar em um dos apps da Web populares que existem hoje.

Neste codelab, você vai dar um passo além e treinar novamente seu modelo de ML para considerar mudanças no conteúdo das mensagens de spam que podem evoluir com o tempo, com base nas tendências atuais ou em tópicos de discussão populares. Assim, você mantém o modelo atualizado e considera essas mudanças.

Pré-requisitos

• Concluiu o primeiro codelab desta série.
• Conhecimento básico de tecnologias da Web, incluindo HTML, CSS e JavaScript.

O que você vai criar

Você vai reutilizar o site criado anteriormente para um blog de vídeo fictício com uma seção de comentários em tempo real e fazer upgrade para carregar uma versão treinada personalizada do modelo de detecção de spam usando o TensorFlow.js. Assim, ele terá uma performance melhor em casos extremos em que falharia antes. É claro que, como desenvolvedores e engenheiros da Web, você pode mudar essa UX hipotética para reutilização em qualquer site em que esteja trabalhando no dia a dia e adaptar a solução para se adequar a qualquer caso de uso do cliente. Talvez seja um blog, um fórum ou alguma forma de CMS, como o Drupal, por exemplo.

Vamos começar a hackear…

O que você vai aprender

Você vai:

• Identificar casos extremos em que o modelo pré-treinado falhou
• Treine novamente o modelo de classificação de spam criado com o Model Maker.
• Exporte esse modelo baseado em Python para o formato TensorFlow.js para uso em navegadores.
• Atualize o modelo hospedado e o dicionário dele com o modelo recém-treinado e verifique os resultados.

Neste laboratório, presumimos que você tem familiaridade com HTML5, CSS e JavaScript. Você também vai executar um código em Python em um notebook "co lab" para treinar novamente o modelo criado com o Model Maker, mas não é necessário ter experiência com Python para fazer isso.

2. Configurar para programar

Mais uma vez, você vai usar o Glitch.com para hospedar e modificar o aplicativo da Web. Se você ainda não tiver concluído o codelab de pré-requisitos, clone o resultado final aqui como ponto de partida. Se você tiver dúvidas sobre como o código funciona, recomendamos concluir o codelab anterior, que explica como criar esse web app funcional, antes de continuar.

No Glitch, basta clicar no botão remixar isso para fazer um fork e criar um novo conjunto de arquivos que podem ser editados.

Alternativa: use seu editor da Web preferido ou trabalhe localmente Se você quiser baixar o código e trabalhar localmente com seu próprio servidor ou em um editor on-line diferente, recrie os arquivos mostrados em um ambiente Node.js Express de sua escolha e copie e cole o código do boilerplate do Glitch no seu ambiente local para cada arquivo.

3. Descobrir casos extremos na solução anterior

Se você abrir o site concluído que acabou de clonar e tentar digitar alguns comentários, vai notar que, na maior parte do tempo, ele funciona como esperado, bloqueando comentários que parecem spam e permitindo respostas legítimas.

No entanto, se você for esperto e tentar formular as coisas para quebrar o modelo, provavelmente vai conseguir em algum momento. Com um pouco de tentativa e erro, é possível criar exemplos manualmente, como os mostrados abaixo. Cole esses comandos no web app atual, verifique o console e confira as probabilidades de o comentário ser spam:

Comentários legítimos postados sem problemas (negativos verdadeiros):

1. "Uau, adorei o vídeo, trabalho incrível." Probabilidade de spam: 47,91854%
2. "Adorei essas demonstrações! Você tem mais detalhes?" Probabilidade de spam: 47,15898%
3. "Em qual site posso saber mais?" Probabilidade de spam: 15,32495%

Isso é ótimo. As probabilidades de tudo acima são bem baixas e passam pelo SPAM_THRESHOLD padrão de uma probabilidade mínima de 75% antes de uma ação ser realizada (definida no código script.js do codelab anterior).

Agora vamos tentar escrever comentários mais ousados que são marcados como spam, mesmo que não sejam...

Comentários legítimos marcados como spam (falsos positivos):

1. "Alguém pode enviar o link do site da máscara que ele está usando?" Probabilidade de spam: 98,46466%
2. "Posso comprar essa música no Spotify? Alguém me avise!" Probabilidade de spam: 94,40953%
3. "Alguém pode entrar em contato comigo com detalhes sobre como baixar o TensorFlow.js?" Probabilidade de spam: 83,20084%

Ah, não! Parece que esses comentários legítimos estão sendo marcados como spam quando deveriam ser permitidos. Como corrigir isso?

Uma opção simples é aumentar o SPAM_THRESHOLD para ter mais de 98,5% de confiança. Nesse caso, os comentários classificados incorretamente seriam postados. Com isso em mente, vamos continuar com os outros resultados possíveis abaixo...

Comentários de spam marcados como spam (verdadeiros positivos):

1. "Isso é legal, mas confira os links de download melhores no meu site!" Probabilidade de spam: 99,77873%
2. "Conheço pessoas que podem conseguir alguns remédios para você. Consulte meu perfil para mais detalhes". Probabilidade de spam: 98,46955%
3. "Acesse meu perfil para baixar vídeos ainda mais incríveis e melhores! http://example.com" Probabilidade de spam: 96,26383%

Ok, isso está funcionando conforme o esperado com nosso limite original de 75%, mas, considerando que na etapa anterior você mudou SPAM_THRESHOLD para ter mais de 98,5% de confiança, isso significa que dois exemplos seriam permitidos.Talvez o limite seja muito alto. Talvez 96% seja melhor? Mas, se você fizer isso, um dos comentários na seção anterior (falsos positivos) será marcado como spam, mesmo sendo legítimo, já que foi classificado em 98,46466%.

Nesse caso, é melhor capturar todos esses comentários de spam reais e simplesmente treinar novamente para as falhas acima. Ao definir o limite como 96%, todos os verdadeiros positivos ainda são capturados, e você elimina dois dos falsos positivos acima. Nada mal para mudar apenas um número.

Vamos continuar...

Comentários de spam que foram permitidos (falsos negativos):

1. "Acesse meu perfil para baixar vídeos ainda mais incríveis e melhores!" Probabilidade de spam: 7,54926%
2. "Receba um desconto nas nossas aulas de treinamento na academia. Confira o perfil!" Probabilidade de spam: 17,49849%
3. "Meu Deus, as ações da GOOG subiram muito! Aproveite antes que seja tarde demais!" Probabilidade de spam: 20,42894%

Para esses comentários, não é possível fazer nada apenas mudando o valor de SPAM_THRESHOLD. Diminuir o limite de spam de 96% para ~9% vai fazer com que comentários reais sejam marcados como spam. Um deles tem uma classificação de 58%, mesmo sendo legítimo. A única maneira de lidar com comentários como esses seria treinar o modelo novamente com esses casos extremos incluídos nos dados de treinamento para que ele aprenda a ajustar a visão do mundo sobre o que é spam ou não.

Embora a única opção restante no momento seja treinar novamente o modelo, você também viu como refinar o limite de quando decidir chamar algo de spam para melhorar a performance. Como humano, 75% parece bastante confiante, mas para esse modelo, você precisava aumentar para perto de 81,5% para ser mais eficaz com entradas de exemplo.

Não existe um valor mágico que funcione bem em diferentes modelos. Esse valor de limite precisa ser definido para cada modelo depois de testar dados reais para saber o que funciona bem.

Em algumas situações, ter um falso positivo (ou negativo) pode ter consequências graves (por exemplo, no setor médico). Por isso, ajuste seu limite para um valor muito alto e solicite mais revisões manuais para aqueles que não atendem ao limite. Essa é uma escolha sua como desenvolvedor e exige alguma experimentação.

4. Retreinar o modelo de detecção de spam de comentários

Na seção anterior, você identificou vários casos extremos que estavam falhando para o modelo, e a única opção era treinar novamente o modelo para considerar essas situações. Em um sistema de produção, você pode encontrar esses casos ao longo do tempo à medida que as pessoas sinalizam manualmente um comentário como spam que foi liberado ou quando os moderadores que analisam comentários sinalizados percebem que alguns não são spam e podem marcar esses comentários para treinamento. Supondo que você tenha coletado vários dados novos para esses casos extremos (para melhores resultados, tenha algumas variações dessas novas frases, se possível), vamos mostrar como treinar novamente o modelo considerando esses casos.

Resumo do modelo pré-criado

O modelo pré-criado usado foi criado por terceiros no Criador de modelos, que usa um modelo de "embedding da palavra médio" para funcionar.

Dica:embora o Model Maker tenha sido projetado para usuários do TF Lite (desenvolvedores de apps nativos), ele também permite a exportação para o formato de modelo do TensorFlow.js. Assim, podemos usar o modelo resultante criado para detecção de spam de comentários também no ambiente da Web.

Como o modelo foi criado com o Model Maker, você precisará mudar brevemente para o Python para retreinar o modelo e exportá-lo para o formato TensorFlow.js para poder usá-lo no navegador. Felizmente, o Model Maker facilita muito o uso dos modelos. Por isso, é fácil acompanhar este tutorial. Vamos guiar você pelo processo. Não se preocupe se você nunca usou Python antes.

Dica:os engenheiros de ML em JavaScript normalmente fazem todo o trabalho com o TensorFlow.js, talvez usando o Node.js para treinar modelos em um ambiente do lado do servidor. Hoje, vamos mostrar como usar o código do Model Maker para que você possa trabalhar com modelos criados em outras linguagens, como Python, e exportá-los para o TensorFlow.js. Essa é uma boa habilidade para aprender, já que muitas pesquisas são feitas inicialmente na academia, que geralmente usa Python na hora de escrever.

Colabs

Como neste codelab você não precisa configurar um servidor Linux com todos os utilitários Python instalados, basta executar o código pelo navegador da Web usando um "notebook do Colab". Esses notebooks podem se conectar a um "backend", que é simplesmente um servidor com algumas coisas pré-instaladas. Nele, você pode executar código arbitrário no navegador da Web e ver os resultados. Isso é muito útil para prototipagem rápida ou para uso em tutoriais como este.

Basta acessar colab.research.google.com para ver a tela de boas-vindas, como mostrado abaixo:

Agora clique no botão New Notebook na parte de baixo à direita da janela pop-up. Um Colab em branco vai aparecer assim:

Ótimo! A próxima etapa é conectar o Colab de front-end a um servidor de back-end para que você possa executar o código Python que vai escrever. Para fazer isso, clique em Conectar no canto superior direito e selecione Conectar ao ambiente de execução hospedado.

Depois de conectado, os ícones de RAM e disco vão aparecer no lugar dele, assim:

Bom trabalho! Agora você pode começar a programar em Python para treinar novamente o modelo do Model Maker. Basta seguir as etapas abaixo.

Etapa 1

Na primeira célula vazia, copie o código abaixo. Ele vai instalar o TensorFlow Lite Model Maker usando o gerenciador de pacotes do Python chamado "pip". Ele é semelhante ao npm, que a maioria dos leitores deste codelab conhece do ecossistema JS:

!apt-get install libasound-dev portaudio19-dev libportaudio2 libportaudiocpp0
!pip install -q tflite-model-maker

No entanto, colar o código na célula não o executa. Em seguida, passe o cursor sobre a célula cinza em que você colou o código acima. Um pequeno ícone de "play" vai aparecer à esquerda da célula, como destacado abaixo:

Clique no botão de reprodução para executar o código que acabou de ser digitado na célula.

Observação:é importante executar o código na ordem mostrada neste tutorial. Caso contrário, as bibliotecas importadas ou as variáveis calculadas que você usará mais tarde em outras células podem não estar disponíveis.

Agora você vai ver o Model Maker sendo instalado:

Quando a execução dessa célula for concluída, conforme mostrado, passe para a próxima etapa abaixo.

Etapa 2

Em seguida, adicione uma nova célula de código, conforme mostrado, para colar mais código após a primeira célula e executá-lo separadamente:

A próxima célula executada terá uma série de importações que o código no restante do notebook precisará usar. Copie e cole o código abaixo na nova célula criada:

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')

É algo bem padrão, mesmo que você não tenha familiaridade com Python. Você está apenas importando algumas utilidades e as funções do Model Maker necessárias para o classificador de spam. Isso também vai verificar se você está executando o TensorFlow 2.x, que é um requisito para usar o Model Maker.

Por fim, como antes, execute a célula pressionando o ícone de "play" ao passar o cursor sobre ela e adicione uma nova célula de código para a próxima etapa.

Etapa 3

Em seguida, você fará o download dos dados de um servidor remoto para seu dispositivo e definirá a variável training_data como o caminho do arquivo local resultante baixado:

data_file = tf.keras.utils.get_file(fname='comment-spam-extras.csv', origin='https://storage.googleapis.com/jmstore/TensorFlowJS/EdX/code/6.5/jm_blog_comments_extras.csv', extract=False)

O Model Maker pode treinar modelos em arquivos CSV simples como o que foi baixado. Basta especificar quais colunas contêm o texto e quais contêm os rótulos. Você vai aprender a fazer isso na etapa 5. Se quiser, faça o download direto do arquivo CSV para ver o que ele contém.

Os mais atentos vão notar que o nome desse arquivo é jm_blog_comments_extras.csv. Ele é simplesmente os dados de treinamento originais que usamos para gerar o primeiro modelo de spam de comentários combinado com os novos dados de casos extremos que você descobriu. Assim, tudo fica em um só arquivo. Além das novas frases, você também precisa dos dados de treinamento originais usados para treinar o modelo.

Opcional:se você baixar este arquivo CSV e verificar as últimas linhas, vai encontrar exemplos de casos extremos que não estavam funcionando corretamente antes. Eles foram adicionados ao final dos dados de treinamento que o modelo pré-criado usou para se treinar.

Execute essa célula e, quando ela terminar, adicione uma nova e vá para a etapa 4.

Etapa 4

Ao usar o Model Maker, você não cria modelos do zero. Em geral, você usa modelos existentes que personaliza de acordo com suas necessidades.

O Model Maker oferece várias embeddings de modelo pré-aprendidas que podem ser usadas, mas a mais simples e rápida é a average_word_vec, que você usou no codelab anterior para criar seu site. O código fica assim:

spec = model_spec.get('average_word_vec')
spec.num_words = 2000
spec.seq_len = 20
spec.wordvec_dim = 7

Cole e execute na nova célula.

Como entender o

num_words

parâmetro

É o número de palavras que você quer que o modelo use. Talvez você pense que quanto mais, melhor, mas geralmente há um ponto ideal com base na frequência de uso de cada palavra. Se você usar todas as palavras no corpus, o modelo poderá tentar aprender e equilibrar os pesos de palavras que são usadas apenas uma vez, o que não é muito útil. 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. Assim, é 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 aqui vai 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 potencialmente mais lento. Encontrar o ponto ideal é fundamental e depende de você, como engenheiro de machine learning, descobrir o que funciona melhor para seu caso de uso.

Como entender o

wordvec_dim

parâmetro

O parâmetro wordvec_dim é o número de dimensões que você quer usar para o vetor de cada palavra. Essas dimensões são essencialmente as diferentes características (criadas pelo algoritmo de aprendizado de máquina durante o treinamento) que qualquer palavra pode ter e que o programa usa para tentar associar melhor palavras semelhantes de alguma forma significativa.

Por exemplo, se você tivesse uma dimensão para o quanto uma palavra era "médica", uma palavra como "pílulas" poderia ter uma pontuação alta nessa dimensão e ser associada a outras palavras com pontuação alta, como "raio-x", mas "gato" teria uma pontuação baixa nessa dimensão. Uma "dimensão médica" pode ser útil para determinar spam quando combinada com outras dimensões potenciais que podem ser usadas e são significativas.

No caso de palavras com pontuação alta na "dimensão médica", uma segunda dimensão que correlaciona palavras ao corpo humano pode ser útil. Palavras como "perna", "braço" e "pescoço" podem ter uma pontuação alta aqui e também na dimensão médica.

O modelo pode usar essas dimensões para detectar palavras mais associadas a spam. Talvez os e-mails de spam tenham mais chances de conter palavras relacionadas a medicina e partes do corpo humano.

A regra de ouro determinada pela pesquisa é que a quarta raiz do número de palavras funciona bem para esse parâmetro. Então, se eu estiver usando 2.000 palavras, um bom ponto de partida para isso é 7 dimensões. Se mudar o número de palavras usadas, também poderá mudar essa configuração.

Como entender o

seq_len

parâmetro

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, que significa "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, ele vai receber padding, assim como no primeiro codelab desta série.

Etapa 5: carregar os dados de treinamento

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 especificação do modelo criada na etapa 4, além de um caractere delimitador, que, nesse caso, é uma vírgula, já que o arquivo é separado por vírgulas. Você também define um parâmetro de embaralhamento para reorganizar aleatoriamente os dados de treinamento. Assim, itens semelhantes ou coletados juntos são distribuídos aleatoriamente em todo o conjunto de dados.

Em seguida, use data.split() para dividir os dados em dados de treinamento e teste. O valor .9 indica que 90% do conjunto de dados serão usados para treinamento e o restante para teste.

Curiosidade:ao treinar modelos de machine learning, geralmente separamos de 10 a 20% dos dados originais para testar o modelo depois que ele é totalmente treinado. Isso nos permite testar o modelo resultante com dados que ele nunca viu antes. Isso permite testar a eficiência dele como se estivesse no mundo real. Se você treinar com todos os dados, poderá fazer um ajuste excessivo para considerar apenas esses dados e não criar um modelo generalizável que possa funcionar em circunstâncias não previstas.

Etapa 6: criar o modelo

Adicione outra célula em que vamos adicionar o código para criar o modelo:

model = text_classifier.create(train_data, model_spec=spec, epochs=50)

Isso cria um modelo de classificador de texto com o Model Maker, e você especifica os dados de treinamento que quer usar (definidos na etapa 4), a especificação do modelo (também configurada 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, conforme mostrado abaixo:

Em seguida, ele vai medir os resultados disso e mudar os pesos do modelo 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, conforme mostrado:

Quando você chega ao período 50, o modelo informa um nível de acurácia muito maior. Nesse caso, 99,1%.

Etapa 7: 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 do TensorFlow.js para uso em uma página da Web. Basta colar o seguinte em uma nova célula e executar:

model.export(export_dir="/js_export/", export_format=[ExportFormat.TFJS, ExportFormat.LABEL, ExportFormat.VOCAB])
!zip -r /js_export/ModelFiles.zip /js_export/

Depois de executar esse código, clique no pequeno ícone de pasta à esquerda do Colab para navegar até a pasta em que você fez a exportação acima (no diretório raiz, talvez seja necessário subir um nível) e encontrar o pacote ZIP dos arquivos exportados contidos em ModelFiles.zip.

Faça o download deste arquivo ZIP no seu computador agora, porque você vai usar esses arquivos da mesma forma que no primeiro codelab:

Ótimo! A parte em Python acabou. Agora você pode voltar para o JavaScript, que você conhece e adora. Ufa.

Dica:o notebook do Colab que você acabou de escrever será salvo na sua pasta do Google Drive por padrão em uma pasta chamada "Notebooks do Colab". Assim, você pode executar todo o código novamente com um novo arquivo CSV para treinar o modelo de novo. Se você optar por fazer isso depois, comece de cima para baixo e execute cada célula em ordem para evitar problemas. Você também pode editar qualquer célula antes de executá-la, se quiser.

5. Como disponibilizar o novo modelo de machine learning

Agora está quase tudo pronto para carregar o modelo. No entanto, antes disso, é necessário fazer upload dos novos arquivos de modelo baixados anteriormente no codelab para que eles sejam hospedados e possam ser usados no seu código.

Primeiro, se ainda não tiver feito isso, descompacte os arquivos do modelo que você acabou de baixar do notebook do Model Maker Colab. Você vai encontrar os seguintes arquivos nas várias pastas:

O que você tem aqui?

• model.json: um dos arquivos que compõem o modelo treinado do TensorFlow.js. Você vai fazer referência a esse arquivo específico no código JS.
• group1-shard1of1.bin: é um arquivo binário que contém grande parte dos dados salvos do modelo exportado do TensorFlow.js. Ele precisa ser hospedado em algum lugar do seu servidor para download no mesmo diretório de model.json acima.
• vocab: esse arquivo estranho sem extensão é algo do Model Maker que mostra como codificar palavras nas frases para que o modelo entenda como usá-las. Você vai se aprofundar mais nisso na próxima seção.
• labels.txt: contém apenas os nomes de classe resultantes que o modelo vai prever. Para esse modelo, se você abrir o arquivo no editor de texto, ele terá apenas "false" e "true" listados, indicando "not spam" ou "spam" como saída de previsão.

Hospedar os arquivos do modelo do TensorFlow.js

Primeiro, coloque os arquivos model.json e *.bin gerados em um servidor da Web para que você possa acessá-los pela sua página da Web.

Observação:se você não estiver usando o Glitch e estiver seguindo as instruções executando seu próprio servidor Node.js Express, basta colocar esses arquivos sem modificação na pasta www para veiculação. Siga as etapas de upload abaixo apenas se estiver usando o Glitch.com para hospedar os arquivos.

Excluir arquivos de modelo atuais

Como você está criando com base no resultado final do primeiro codelab desta série, primeiro exclua os arquivos de modelo enviados. Se você estiver usando o Glitch.com, basta verificar o painel de arquivos à esquerda para encontrar model.json e group1-shard1of1.bin, clicar no menu suspenso de três pontos de cada arquivo e selecionar excluir, conforme mostrado:

Fazer upload de novos arquivos para o Glitch

Ótimo! Agora faça upload dos novos:

1. Abra a pasta assets no painel à esquerda do projeto do Glitch e exclua os recursos antigos enviados se eles tiverem os mesmos nomes.
2. Clique em fazer upload de um recurso e selecione group1-shard1of1.bin para enviar para essa pasta. Depois de fazer o upload, ele vai ficar assim:

3. Ótimo! Agora faça o mesmo com o arquivo model.json. Assim, dois arquivos vão estar na pasta "assets", como mostrado abaixo:

4. Se você clicar no arquivo group1-shard1of1.bin que acabou de enviar, poderá copiar o URL do local dele. Copie este caminho agora, conforme mostrado:

5. Agora, na parte de baixo à esquerda da tela, clique em Ferramentas > Terminal. Aguarde o carregamento da janela do terminal.
6. Depois de carregar, digite o seguinte e pressione "Enter" para mudar o diretório para a pasta www:

terminal:

cd www

7. Em seguida, use wget para fazer o download dos dois arquivos que você acabou de enviar. Para isso, substitua os URLs abaixo pelos URLs gerados para os arquivos na pasta "assets" do Glitch. Verifique a pasta "assets" para conferir o URL personalizado de cada arquivo.

Observe o espaço entre os dois URLs e que os URLs que você precisará usar serão diferentes dos mostrados, mas terão uma aparência semelhante:

terminal

wget https://cdn.glitch.com/1cb82939-a5dd-42a2-9db9-0c42cab7e407%2Fmodel.json?v=1616111344958 https://cdn.glitch.com/1cb82939-a5dd-42a2-9db9-0c42cab7e407%2Fgroup1-shard1of1.bin?v=1616017964562

Demais! Agora você tem uma cópia dos arquivos enviados para a pasta www.

No entanto, por enquanto, eles serão baixados com nomes estranhos. Se você digitar ls no terminal e pressionar "Enter", vai aparecer algo assim:

8. Use o comando mv para renomear os arquivos. Digite o seguinte no console e pressione "Enter" após cada linha:

terminal:

mv *group1-shard1of1.bin* group1-shard1of1.bin
mv *model.json* model.json

9. Por fim, atualize o projeto do Glitch digitando refresh no terminal e pressionando "Enter":

terminal:

refresh

Ao atualizar, você vai ver model.json e group1-shard1of1.bin na pasta www da interface do usuário:

Ótimo! A última etapa é atualizar o arquivo dictionary.js.

10. Converta o novo arquivo de vocabulário baixado para o formato JS correto manualmente usando seu editor de texto ou usando esta ferramenta e salve a saída resultante como dictionary.js na pasta www. Se você já tiver um arquivo dictionary.js, basta copiar e colar o novo conteúdo nele e salvar.

Uhuuu! Você atualizou todos os arquivos alterados. Se tentar usar o site agora, vai notar como o modelo readequado consegue lidar com os casos extremos descobertos e aprendidos, conforme mostrado abaixo:

Como você pode ver, os seis primeiros agora são classificados corretamente como não sendo spam, e o segundo lote de seis é identificado como spam. Perfeito!

Vamos testar algumas variações também para ver se ele generalizou bem. Originalmente, havia uma frase com falha, como:

"meu deus, as ações da GOOG subiram muito! Aproveite antes que seja tarde demais!"

Agora, isso está classificado corretamente como spam, mas o que acontece se você mudar para:

As ações da XYZ acabaram de aumentar de valor! Compre antes que seja tarde demais!"

Aqui, você recebe uma previsão de 98% de probabilidade de ser spam, o que está correto, mesmo que você tenha mudado o símbolo da ação e o texto levemente.

É claro que, se você tentar quebrar esse novo modelo, vai conseguir. Para ter a melhor chance de capturar mais variações exclusivas para as situações comuns que você provavelmente vai encontrar on-line, é preciso coletar ainda mais dados de treinamento. Em um futuro codelab, vamos mostrar como melhorar continuamente seu modelo com dados ativos à medida que eles são sinalizados.

6. Parabéns!

Parabéns! Você conseguiu treinar novamente um modelo de machine learning para que ele funcione nos casos extremos encontrados e implantou essas mudanças no navegador com o TensorFlow.js para um aplicativo do mundo real.

Resumo

Neste codelab, você aprendeu a:

1. Casos extremos descobertos que não funcionavam ao usar o modelo predefinido de spam de comentários
2. Treinamos novamente o modelo do Model Maker para considerar os casos extremos que você descobriu.
3. Exportou o novo modelo treinado para o formato TensorFlow.js
4. Atualizou o web app para usar os novos arquivos

Qual é a próxima etapa?

Essa atualização funciona muito bem, mas, como em qualquer app da Web, as mudanças vão acontecer com o tempo. Seria muito melhor se o app se aprimorasse continuamente ao longo do tempo, em vez de precisarmos fazer isso manualmente a cada vez. Você consegue pensar em como automatizar essas etapas para treinar um modelo de novo automaticamente depois de ter, por exemplo, 100 novos comentários marcados como classificados incorretamente? Use seus conhecimentos de engenharia da Web para criar um pipeline que faça isso automaticamente. Se não, não se preocupe. Confira o próximo codelab da série para saber como fazer isso.

Compartilhe o que você sabe conosco

Você pode estender facilmente o que fez hoje para outros casos de uso criativos. Recomendamos que você pense fora da caixa e continue criando.

Marque-nos nas redes sociais usando a hashtag #MadeWithTFJS para que seu projeto tenha a chance de ser destacado no blog do TensorFlow ou até em eventos futuros. Adoraríamos ver o que você cria.

Mais codelabs do TensorFlow.js para continuar seu aprendizado

• Use o Firebase Hosting para implantar e hospedar um modelo do TensorFlow.js em grande escala.
• Faça uma webcam inteligente usando um modelo de detecção de objetos pronto com o TensorFlow.js

Sites para conferir

• Site oficial do TensorFlow.js
• Modelos prontos do TensorFlow.js
• API do TensorFlow.js
• Show & Tell do TensorFlow.js: inspire-se e veja o que outras pessoas criaram.