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 desenvolvido com base no resultado final do codelab anterior desta série para a 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 blog de vídeos fictícios. Você podia filtrar comentários de spam antes que eles fossem enviados para o servidor para armazenamento ou para outros clientes conectados, usando um modelo de detecção de spam de comentários pré-treinado com tecnologia TensorFlow.js no navegador.

O resultado final do codelab é mostrado abaixo:

ee0f13398ea4e91e.gif

Embora isso tenha funcionado muito bem, existem casos extremos que não conseguimos detectar. É possível treinar novamente o modelo para considerar as situações em que ele não foi capaz de lidar.

Este codelab se concentra no uso de processamento de linguagem natural (a arte de entender a linguagem humana com um computador) e mostra como modificar um app da Web existente que você criou (é altamente recomendável que vocêfazer os codelabs na ordem ), para enfrentar o verdadeiro problema do spam de comentários, que muitos desenvolvedores encontrarão certamente quando trabalham em um dos aplicativos cada vez mais conhecidos da Web.

Neste codelab, você vai além, treinando 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 nos tópicos de discussão mais usados, para que você mantenha o modelo atualizado e considere essas mudanças.

Prerequisites

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

O que você criará

Você reutilizará o site criado anteriormente para um blog de vídeo fictício com uma seção de comentários em tempo real e fará um upgrade para carregar uma versão treinada e personalizada do modelo de detecção de spam usando o TensorFlow.js. Assim, ele tem um desempenho melhor nos casos extremos em que teria falhado anteriormente. de dados. É claro que, como desenvolvedores e engenheiros da Web, é possível mudar essa UX hipotética para reutilização em qualquer site em que você esteja trabalhando no dia a dia e adaptar a solução para atender a qualquer caso de uso do cliente, como um blog, fórum ou do CMS, como o Drupal.

Vamos hackear...

O que você aprenderá

Você vai:

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

Para este laboratório, é preciso ter familiaridade com HTML5, CSS e JavaScript. Você também executará alguns códigos Python por meio de um notebook “co lab” para treinar novamente o modelo que foi criado com o Model Maker, mas não é necessário conhecer o Python para fazer isso.

2. Começar a configurar o código

Mais uma vez, você usará o Glitch.com para hospedar e modificar o aplicativo da Web. Se você ainda não concluiu o pré-requisito do codelab, clone o resultado final aqui como ponto de partida. Se você tem dúvidas sobre como o código funciona, é altamente recomendável concluir o codelab anterior que mostrou como criar esse app da Web em funcionamento antes de continuar.

No Glitch, basta clicar no botão remixar este para bifurcá-lo e criar um novo conjunto de arquivos que você pode editar.

3. Descobrir casos extremos na solução anterior

Se você abrir o site pronto que acabou de clonar e digitar alguns comentários, perceberá que, na maior parte do tempo, ele funciona da maneira esperada, bloqueando os comentários que parecem spam como esperado e permitindo respostas legítimas.

Mas se você usar as técnicas e frases adequadas para quebrar o modelo, provavelmente terá sucesso em algum momento. Com um pouco de tentativa e erro, você pode criar exemplos manualmente, como os mostrados abaixo. Tente colá-los no app da Web existente, verificar o console e ver as probabilidades de voltar se o comentário for spam:

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

  1. "Uau, adoro esse vídeo, trabalho incrível." Probabilidade de spam: 47,91854%
  2. "Gostei muito das demonstrações. Quer saber mais detalhes?" Probabilidade de spam: 47,15898%
  3. "Qual site posso acessar para saber mais?" Probabilidade de spam: 15,32495%

Isso é ótimo. As probabilidades para todos os itens acima são muito baixas e alcançam o SPAM_THRESHOLD padrão de uma probabilidade mínima de 75% antes que a ação seja realizada (definida no código script.js do codelab anterior).

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

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

  1. "Alguém pode vincular o site da máscara que está usando?" Probabilidade de spam: 98,46466%
  2. "Posso comprar esta 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 fazer o download do TensorFlow.js?" Probabilidade de spam: 83,20084%

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

Uma opção simples é aumentar a SPAM_THRESHOLD para que tenha mais de 98,5% de confiança. Nesse caso, os comentários classificados incorretamente serão 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 no meu site que estão melhores!" Probabilidade de spam: 99,77873%
  2. "Conheço algumas pessoas que podem pegar alguns medicamentos para você ver meu pr0file e ver mais detalhes" Spam de probabilidade: 98,46955%
  3. "Veja meu perfil para fazer download de um vídeo ainda mais incrível, que é ainda melhor! http://example.com" Probabilidade de spam: 96,26383%

Ok, isso está funcionando conforme o esperado com nosso limite original de 75%. No entanto, na etapa anterior, você alterou SPAM_THRESHOLD para mais de 98, 5% confiante. Isso significa que dois exemplos seriam permitidos. é muito alta. Talvez 96% seja melhor? Mas se você fizer isso, um dos comentários na seção anterior (falsos positivos) será marcado como spam quando for legítimo, tendo sido avaliado como 98,46466%.

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

Vamos continuar...

Comentários com spam que podiam ser postados (falsos negativos):

  1. "Acesse meu perfil para fazer o download de um conteúdo ainda mais incrível que é ainda melhor!" Probabilidade de spam: 7,54926%
  2. "Ganhe um desconto nas aulas de treinamento de academia e veja o pr0file." Probabilidade de spam: 17,49849%
  3. "Ações no GOOG acabaram! Chegar tarde demais!" Probabilidade de spam: 20,42894%

Para esses comentários, não há nada que você possa fazer. Basta mudar ainda mais o valor de SPAM_THRESHOLD. Diminuir o limite de spam de 96% para 9% leva a comentários genuínos marcados como spam. Um deles tem uma classificação de 58%, mesmo que seja legítimo. A única maneira de lidar com comentários como esses é treinar novamente o modelo com casos extremos incluídos nos dados de treinamento para aprender a ajustar a visão do mundo sobre o que é spam ou não.

Embora a única opção disponível agora seja treinar novamente o modelo, você também viu como refinar o limite de quando decide chamar algo de spam para melhorar o desempenho. Para os humanos, 75% parece um pouco confiante, mas, para esse modelo, seria necessário se aproximar de 81,5% para ser mais eficaz com exemplos de entrada.

Não há um valor mágico que funcione bem em modelos diferentes. Esse valor de limite precisa ser definido por modelo após o teste com dados reais para saber o que funciona bem.

Algumas vezes, um falso positivo (ou negativo) pode ter consequências graves (por exemplo, no setor médico). Por isso, você pode ajustar seu limite para um valor muito alto e solicitar avaliações manuais para quem não atende ao limite. Essa é sua escolha como desenvolvedor e requer alguma experimentação.

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

Na seção anterior, você identificou vários casos extremos que falharam no modelo, e a única opção era treiná-lo novamente de acordo com essas situações. Em um sistema de produção, isso pode acontecer ao longo do tempo, porque as pessoas sinalizam manualmente os comentários sinalizados como spam e os moderadores que analisam os comentários percebem que não se trata de um spam e podem marcá-los para novo treinamento. Supondo que você coletou muitos dados novos para esses casos extremos (para melhores resultados, você deve ter algumas variações dessas frases novas, se possível), mostraremos como treinar novamente o modelo com esses casos extremos em mente.

Resumo do modelo predefinido

O modelo predefinido que você usou foi criado por terceiros por meio do Model Maker, que usa um modelo de "incorporação de palavras média" para funcionar.

Como o modelo foi criado com o Model Maker, é necessário mudar rapidamente para o Python e treiná-lo novamente. Em seguida, exporte o modelo criado para o formato TensorFlow.js para usá-lo no navegador. Felizmente, o Model Maker facilita o uso de modelos, então é muito fácil acompanhar esse processo. Orientaremos você ao longo do processo, então não se preocupe se nunca usou o Python.

Colabs (em inglês)

Como você não está muito preocupado com este codelab e quer configurar um servidor Linux com todos os diversos utilitários do Python instalados, basta executar o código pelo navegador da Web usando um "Colab Notebook". Esses notebooks podem se conectar a um "back-end", que é simplesmente um servidor com alguns elementos pré-instalados. Neles, é possível executar um código arbitrário no navegador da Web e ver os resultados. Isso é muito útil para uma prototipagem rápida ou usada em tutoriais como este.

Acesse colab.research.google.com e uma tela de boas-vindas será exibida:

b2df89c1f7b38cc9.png

Agora, clique no botão New Notebook no canto inferior direito da janela pop-up. Você verá um colab em branco assim:

94a875f67d6e34f6.png

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

f4fcd56ae53527bd.png

Depois de conectado, você verá os ícones de RAM e disco no lugar, como este:

d979e93ba595d1de.png

Ótimo 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 instalará o TensorFlow Lite Model Maker para você usando o gerenciador de pacotes Python, conhecido como "pip". Ele é semelhante ao npm, que pode ser melhor para a maioria dos leitores deste codelab:

!pip install -q tflite-model-maker

Colar o código na célula não o executará. Em seguida, passe o cursor sobre a célula cinza em que você colou o código acima. Um pequeno ícone "Reproduzir" será exibido à esquerda da célula, conforme destacado abaixo:

be966130d68b5aac.png Clique no botão "Assistir" para executar o código digitado na célula.

Você verá o Model Maker instalado:

376bc0fbde89a60d.png

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

Etapa 2

Em seguida, adicione uma nova célula de código, como mostrado, para colar mais código depois da primeira célula e execute-a separadamente:

7ec405d0d82b2143.png

A próxima célula executada terá várias importações que o código no restante do notebook precisará usar. Copie e cole o conteúdo 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')

Coisas padrão, mesmo que você não conheça o Python. Você está apenas importando alguns utilitários e as funções do Model Maker necessárias para o classificador de spam. Isso também 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 reprodução ao passar o mouse sobre ela. Em seguida, 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 para ser o caminho do arquivo local resultante salvo:

data_file = tf.keras.utils.get_file(fname='comment-spam-extras.csv', origin='https://storage.googleapis.com/laurencemoroney-blog.appspot.com/jm_blog_comments_extras.csv', extract=False)

O Model Maker pode treinar modelos a partir de arquivos CSV simples como o transferido por download. Basta especificar quais colunas contêm o texto e quais contêm os rótulos. Veja como fazer isso na Etapa 5. Se quiser, faça o download direto do arquivo CSV para ver o conteúdo.

Se quiser ver o nome do arquivo, observe que ele é jm_blog_comments_extras.csv. Ele é apenas o dado de treinamento original que usamos para gerar o primeiro modelo de spam de comentários. combinados com os novos dados de caso de borda que você descobriu para que tudo esteja em um único arquivo. Você precisa dos dados de treinamento originais usados para treinar o modelo, além das novas frases que quer aprender.

Opcional:se você fizer o download deste arquivo CSV e conferir as últimas linhas, verá exemplos de casos extremos que não estavam funcionando corretamente. Eles acabaram de ser adicionados ao final dos dados de treinamento existentes que o modelo predefinido usou para se treinar.

Execute esta célula e, em seguida, adicione outra célula e siga para a etapa 4.

Etapa 4

Ao usar o Model Maker, você não cria modelos do zero. Geralmente, você usa os modelos atuais que serão personalizados de acordo com suas necessidades.

O Model Maker oferece várias incorporações de modelo pré-aprendidas que podem ser usadas, mas a mais simples e rápida é a average_word_vec, que foi usada 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

Execute o comando depois que você colar a célula na nova célula.

Noções básicas sobre a

num_words

parâmetro

Esse é o número de palavras que você quer que o modelo use. Você pode achar que, quanto melhor, melhor, mas há um ponto ideal com base na frequência de cada palavra usada. Se você usar todas as palavras no corpus, poderá acabar com o modelo tentando aprender e equilibrar os pesos das palavras que são usadas apenas uma vez. Isso não é muito útil. 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. Portanto, é possível ajustar o modelo com o número desejado de palavras usando o parâmetro num_words. Um número menor aqui terá 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 potencialmente mais lento. Encontrar o ponto ideal é fundamental e cabe a você como engenheiro de machine learning descobrir o que funciona melhor no seu caso de uso.

Noções básicas sobre a

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 características (criadas pelo algoritmo de aprendizado de máquina durante o treinamento) de que qualquer palavra pode ser medida com a qual o programa usará para tentar associar melhor as palavras que são semelhantes de alguma forma significativa.

Por exemplo, se você tiver uma dimensão do nível "médico" de uma palavra, uma palavra como "pílulas" poderá ter uma pontuação alta nessa dimensão e ser associada a outras palavras com pontuação alta, como "Xray", mas "gato"". baixa nessa dimensão. Pode ser útil usar uma "dimensão médica" para determinar spam quando ela é combinada com outras dimensões em potencial que ela pode usar e que são importantes.

No caso de palavras que têm uma alta pontuação na "dimensão médica", pode ser útil usar uma segunda dimensão que correlaciona palavras com o corpo humano. Palavras como "pera", "arm", "pescoço" podem apresentar uma alta pontuação aqui e também bastante altas na dimensão médica.

O modelo pode usar essas dimensões para detectar palavras com maior probabilidade de serem associadas a spam. Talvez os e-mails com spam tenham mais chance de conter palavras que façam parte do corpo médico e humano.

A regra geral é determinada pela quarta raiz do número de palavras para esse parâmetro. Portanto, se eu estiver usando 2.000 palavras, um bom ponto de partida para isso são as sete dimensões. Se você mudar o número de palavras usadas, também poderá mudar essa configuração.

Noções básicas sobre a

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 de um determinado tamanho estático. Isso é determinado pelo parâmetro seq_len, em que ele significa "sequência de 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á acolchoado, 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 possa reconhecer.

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 você verá que 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 que você criou na etapa 4, além de um caractere delimitador, que, neste caso, é uma vírgula, já que o arquivo é separado por vírgulas. Você também define um parâmetro embaralhado para reorganizar aleatoriamente os dados de treinamento. Assim, itens que podem ser semelhantes ou coletados juntos são distribuídos aleatoriamente por todo o conjunto de dados.

Use data.split() para dividir os dados em dados de treinamento e teste. O valor 9 indica que 90% do conjunto de dados será usado para treinamento, e o restante para testes.

Etapa 6: criar o modelo

Adicione outra célula onde adicionaremos 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 (definido na etapa 4), a especificação do modelo (que também foi configurada na etapa 4) e vários períodos, em Nesse caso, o caso 50.

O princípio básico do aprendizado de máquina é que ele é uma forma de correspondência de padrões. Inicialmente, a tabela carregará as ponderações pré-treinadas e tentará agrupá-las com uma "previsão" de quais palavras foram agrupadas e quais não estão. Na primeira vez, é provável que esteja próximo dos 50:50, já que o modelo só está começando como mostrado abaixo:

d6c8116f8e7e781b.png

Em seguida, ele medirá os resultados disso e mudará os pesos do modelo para ajustar a previsão. Depois disso, ele tentará novamente. Isso é um período. Ao especificar épocas=50, ela passará por esse "loop" 50 vezes, conforme mostrado:

fc7bf6a948b7aa26.png

Assim, quando você chegar à época 50, o modelo informará um nível de precisão muito maior. Nesse caso, temos 99,1%.

Etapa 7: exportar o modelo

Depois que o treinamento terminar, será possível exportar o modelo. O TensorFlow treina um modelo no próprio formato. É preciso convertê-lo no formato TensorFlow.js para usá-lo em uma página da Web. Cole o seguinte em uma nova célula e execute-o:

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

Após executar esse código, se você clicar no pequeno ícone de pasta à esquerda do Colab, poderá navegar até a pasta exportada acima (no diretório raiz, talvez seja necessário subir um nível) e encontrar o pacote zip da pasta arquivos exportados contidos em ModelFiles.zip.

Faça o download desse arquivo no seu computador para usá-lo da mesma forma que no primeiro codelab:

a9d8595a3e2564dc.png

Ótimo. A parte em Python terminou, agora é possível voltar para a terra do JavaScript que você conhece e adora. Ufa.

5. Exibir o novo modelo de machine learning

Está quase tudo pronto para carregar o modelo. Antes de fazer isso, é necessário fazer upload dos novos arquivos de modelo transferidos anteriormente no codelab para que eles sejam hospedados e possam ser usados no seu código.

Primeiro, descompacte os arquivos do modelo que você acabou de instalar no notebook do Model Maker Colab caso ainda não tenha feito isso. Você verá os seguintes arquivos nas pastas:

5634d536ef8be9ca.png

O que você tem aqui?

  • model.json: é um dos arquivos que compõem o modelo treinado do TensorFlow.js. Você fará 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 e precisará ser hospedado em algum lugar do servidor para download no mesmo diretório que model.json acima.
  • vocab: esse arquivo estranho sem extensão é algo do Model Maker que nos mostra como codificar palavras nas frases para que o modelo entenda como usá-las. Você vai ver mais detalhes na próxima seção.
  • labels.txt: contém simplesmente os nomes de classes resultantes que o modelo prevê. Para esse modelo, se você abrir esse arquivo no seu editor de texto, ele terá "false" e "true" listados, indicando "não é spam" ou "spam" como a saída da previsão.

Hospedar os arquivos de modelo do TensorFlow.js

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

Excluir arquivos de modelo existentes

Como você está desenvolvendo o resultado final do primeiro codelab desta série, primeiro é necessário excluir os arquivos de modelo atuais enviados. Se você estiver usando Glitch.com, verifique o painel de arquivos à esquerda de model.json e group1-shard1of1.bin, clique no menu suspenso de três pontos para cada arquivo e selecione delete conforme mostrado:

7412b0b795d3b84f.png

Como fazer upload de novos arquivos para o Glitch

Ótimo. Agora, faça o upload dos novos registros:

  1. Abra a pasta assets no painel esquerdo do projeto Glitch e exclua todos os recursos antigos enviados se eles tiverem os mesmos nomes.
  2. Clique em Fazer upload de um recurso e selecione group1-shard1of1.bin para fazer o upload na pasta. Ele ficará assim após o upload:

25a2251c7f165184.png

  1. Ótimo. Agora faça o mesmo com o arquivo model.json para que dois arquivos fiquem na pasta de recursos, como este:

51a6dbd5d3097ffc.png.

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

92ded8d46442c404.png

  1. Agora, no canto inferior esquerdo da tela, clique em Ferramentas > Terminal. Aguarde a janela de terminal ser carregada.
  2. Depois de carregar, digite o seguinte e pressione Enter para mudar o diretório para a pasta www:

terminal:

cd www
  1. Em seguida, use a wget para fazer o download dos dois arquivos que você acabou de enviar substituindo os URLs abaixo pelos que você gerou para os arquivos na pasta de recursos no Glitch (verifique a pasta de recursos do URL personalizado de cada arquivo).

O espaço entre os dois URLs e os URLs que você precisa usar são diferentes dos mostrados, mas serão semelhantes:

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! Você fez uma cópia dos arquivos enviados para a pasta www.

No entanto, agora será feito um download com nomes estranhos. Se você digitar ls no terminal e pressionar Enter, verá algo parecido com isto:

9cc90f1d053f517f.png

  1. 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
  1. Por fim, atualize o projeto do Glitch digitando refresh no terminal e pressione Enter:

terminal:

refresh

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

50dd98c0a8f3e629.png

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

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

Uhuuu! Você atualizou todos os arquivos alterados. Agora, se tentar usar o site, perceberá que o modelo treinado novamente pode explicar os casos extremos descobertos e aprendidos da seguinte forma:

3ece5dbd0a673987.gif.

Como você pode ver, as seis primeiras agora são classificadas corretamente como não spam, e o segundo lote de seis é identificado como spam. Perfeito!

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

"Uau, que ações em GOOG acabou de disparar! Chegue tarde demais!"

Agora ele está classificado corretamente como spam, mas o que acontecerá se você alterar para:

"Então, o estoque XYZ aumentou em valor! Compre algumas logo antes que seja tarde demais."

Aqui, você prevê uma probabilidade de 98% de ser spam, mesmo que você tenha mudado o símbolo de ações e o texto um pouco.

É claro que se você realmente tentar romper esse novo modelo, conseguirá e coletará ainda mais dados de treinamento para ter mais chances de capturar variações únicas para as situações comuns que você provavelmente encontrará on-line. Em um codelab futuro, mostraremos como melhorar continuamente seu modelo com dados ativos à medida que ele for sinalizado.

6. Parabéns!

Parabéns! Você conseguiu treinar novamente um modelo de machine learning que é atualizado para funcionar nos casos extremos que encontrou e implantou essas alterações no navegador com o TensorFlow.js para um aplicativo real.

Resumo

Neste codelab, você:

  1. Foram encontrados casos extremos que não estavam funcionando ao usar o modelo predefinido de spam de comentários
  2. Retreinado do modelo do Model Maker para considerar os casos extremos que você descobriu
  3. Exportou o novo modelo treinado para o formato do TensorFlow.js
  4. Seu app da Web foi atualizado para usar os novos arquivos

Qual é a próxima etapa?

Portanto, essa atualização funciona muito bem, mas, assim como qualquer app da Web, as mudanças aparecerão com o tempo. Seria muito melhor se o app fosse aprimorado continuamente ao longo do tempo, em vez de precisar fazer isso manualmente toda vez. Você consegue pensar em como pode automatizar essas etapas para treinar automaticamente um modelo depois de, por exemplo, 100 novos comentários marcados como classificados incorretamente? Coloque tudo como você trabalha com engenharia da Web e descubra como criar um pipeline para fazer isso automaticamente. Se não, não se preocupe. Fique atento ao próximo codelab da série que mostra como fazer isso.

Compartilhe o que você sabe conosco

É fácil estender o que você fez hoje para outros casos de uso de criativo. Além disso, recomendamos que você pense fora da caixa e continue a invadir.

Lembre-se de nos marcar nas mídias sociais usando o#MadeWithTFJS hashtag para ter uma chance de seu projeto ser destacado naBlog do TensorFlow ou até mesmofuturos eventos de dados. Adoraríamos ver o que você fará.

Mais codelabs do TensorFlow.js para continuar seu aprendizado

Sites para conferir