TensorFlow.js: Vuelve a entrenar un modelo de detección de comentarios spam para manejar casos extremos

1. Antes de comenzar

Este codelab se diseñó a partir del resultado final del codelab anterior de esta serie para la detección de comentarios spam con TensorFlow.js.

En el último codelab, creaste una página web completamente funcional para un videoblog ficticio. Pudiste filtrar los comentarios en busca de spam antes de que se enviaran al servidor para su almacenamiento o a otros clientes conectados, mediante un modelo de detección de comentarios spam previamente entrenado con la tecnología de TensorFlow.js en el navegador.

El resultado final de ese codelab se muestra a continuación:

a4511e5d445706b1.gif

Si bien esto funcionó muy bien, hay casos extremos para explorar que no pudo detectar. Puedes volver a entrenar el modelo para dar cuenta de las situaciones que no pudo manejar.

Este codelab se enfoca en el uso del procesamiento de lenguaje natural (el arte de comprender el lenguaje humano con una computadora) y te muestra cómo modificar una app web existente que creaste (te recomendamos que realices los codelabs en orden) para abordar el verdadero problema del spam de comentarios, que muchos desarrolladores web seguramente encontrarán cuando trabajen en una de las crecientes cantidades de apps web populares que existen en la actualidad.

En este codelab, darás un paso más y reentrenarás tu modelo de AA para que tenga en cuenta los cambios en el contenido de los mensajes de spam que pueden evolucionar con el tiempo, según las tendencias actuales o los temas de discusión populares, lo que te permite mantener el modelo actualizado y tener en cuenta esos cambios.

Requisitos previos

  • Haber completado el primer codelab de esta serie
  • Conocimientos básicos de tecnologías web, como HTML, CSS y JavaScript

Qué compilarás

Volverás a usar el sitio web creado anteriormente para un videoblog con una sección de comentarios en tiempo real y lo actualizarás para cargar una versión personalizada del modelo de detección de spam con TensorFlow.js, de modo que funcione mejor en casos extremos en los que antes habría fallado. Por supuesto, como ingenieros y desarrolladores web, podrían cambiar esta UX hipotética para reutilizarla en cualquier sitio web en el que estén trabajando y adaptar la solución para que se ajuste a cualquier caso de uso de cliente; por ejemplo, un blog, un foro o algún tipo de CMS, como Drupal.

Vamos a hackear...

Qué aprenderás

Harás lo siguiente:

  • Identificar casos extremos en los que falló el modelo previamente entrenado
  • Vuelve a entrenar el modelo de clasificación de spam que se creó con Model Maker.
  • Exporta este modelo basado en Python al formato TensorFlow.js para usarlo en navegadores.
  • Actualiza el modelo alojado y su diccionario con el modelo recién entrenado y verifica los resultados

Para este lab, se supone que conocimientos de HTML5, CSS y JavaScript. También ejecutarás código de Python en un “colab” notebook para volver a entrenar el modelo que se creó con Model Maker, pero no se necesita estar familiarizado con Python para hacerlo.

2. Prepárate para codificar

Una vez más, usarás Glitch.com para alojar y modificar la aplicación web. Si aún no completaste el codelab de requisitos previos, puedes clonar el resultado final aquí como punto de partida. Si tienes preguntas sobre cómo funciona el código, te recomendamos que completes el codelab anterior, en el que se explicó cómo hacer que esta app web funcione antes de continuar.

En Glitch, solo debes hacer clic en el botón remix this para bifurcarlo y crear un nuevo conjunto de archivos que puedas editar.

3. Descubrir casos extremos en la solución anterior

Si abres el sitio web completo que clonaste y tratas de escribir algunos comentarios, notarás que la mayor parte del tiempo funciona según lo previsto, bloqueando los comentarios que suenan como spam como se espera y permite respuestas legítimas.

Sin embargo, si eres hábil y tratas de expresar algunas cosas para romper el modelo, es probable que tengas éxito en algún momento. Con un poco de prueba y error, puedes crear manualmente ejemplos como los que se muestran a continuación. Intenta pegarlos en la app web existente, revisa la consola y comprueba las probabilidades de que el comentario sea spam:

Comentarios legítimos publicados sin problemas (verdaderos negativos):

  1. “¡Vaya! Me encanta ese video, es un trabajo increíble”. Probabilidad de spam: 47.91854%
  2. “¡Me encantaron estas demostraciones! ¿Tienes más detalles?". Probabilidad de spam: 47.15898%
  3. “¿En qué sitio web puedo obtener más información?” Probabilidad de spam: 15.32495%

Excelente. Las probabilidades de todo lo anterior son bastante bajas y pasan con éxito el SPAM_THRESHOLD predeterminado de una probabilidad mínima del 75% antes de que se realice una acción (definida en el código script.js del codelab anterior).

Ahora, intentemos escribir algunos comentarios más provocativos que se marquen como spam a pesar de que no lo son...

Comentarios legítimos marcados como spam (falsos positivos):

  1. “¿Alguien puede vincular el sitio web de la mascarilla que usa?” Probabilidad de spam: 98.46466%
  2. "¿Puedo comprar esta canción en Spotify?" Que alguien me lo avise”. Probabilidad de spam: 94.40953%
  3. “¿Alguien puede comunicarse conmigo para brindarme información sobre cómo descargar TensorFlow.js?” Probabilidad de spam: 83.20084%

¡Ay, no! Parece que estos comentarios legítimos se marcan como spam cuando deberían permitirse. ¿Cómo puedes solucionarlo?

Una opción simple es aumentar el SPAM_THRESHOLD para que tenga más del 98.5% de confianza. En ese caso, estos comentarios clasificados incorrectamente se publicarían. Con eso en mente, continuemos con los otros resultados posibles que aparecen a continuación...

Comentarios de spam marcados como spam (verdaderos positivos):

  1. "Esto es genial, pero puedes consultar los vínculos de descarga que son mejores en mi sitio web". Probabilidad de spam: 99.77873%
  2. "Conozco que algunas personas que pueden conseguir algunos medicamentos solo ven mi archivo pr0 para obtener más información" Probabilidad de spam: 98.46955%
  3. “¡Mira mi perfil para descargar videos aún más increíbles que son aún mejores! http://example.com" Probabilidad de spam: 96.26383%

Muy bien. Esto funciona como se esperaba con nuestro umbral original del 75%. Sin embargo, como en el paso anterior cambiaste la seguridad de SPAM_THRESHOLD para que tenga más del 98.5% de confianza, esto significaría que se aceptarían 2 ejemplos, por lo que tal vez el umbral sea demasiado alto. ¿Quizás un 96% sea mejor? Sin embargo, si lo haces, uno de los comentarios de la sección anterior (falsos positivos) se marcaría como spam cuando fuera legítimo, ya que tenía una calificación del 98.46466%.

En este caso, probablemente lo mejor sea capturar todos estos comentarios de spam reales y simplemente volver a entrenarlos para las fallas anteriores. Cuando se establece el umbral en un 96%, se siguen capturando todos los verdaderos positivos y se eliminan 2 de los falsos positivos anteriores. No está mal por cambiar un solo número.

Continuemos...

Comentarios de spam que se pudieron publicar (falsos negativos):

  1. “Consulta mi perfil para descargar videos aún más increíbles que son mucho mejores” Probabilidad de spam: 7.54926%
  2. "Obtenga un descuento en nuestras clases de entrenamiento en el gimnasio, consulte el archivo" Probabilidad de spam: 17.49849%
  3. “Las acciones de GoOG ya están listos. Llega antes de que sea demasiado tarde". Probabilidad de spam: 20.42894%

Para estos comentarios, no puedes hacer nada simplemente cambiando aún más el valor de SPAM_THRESHOLD. Si reduces el umbral de spam del 96% al 9%, los comentarios genuinos se marcarán como spam, es decir, uno de ellos tendrá una calificación del 58%, incluso si es legítimo. La única forma de lidiar con comentarios como estos sería volver a entrenar el modelo con estos casos extremos incluidos en los datos de entrenamiento, de modo que aprenda a ajustar su visión del mundo para determinar lo que es spam o no.

Si bien la única opción que queda en este momento es volver a entrenar el modelo, también viste cómo puedes definir mejor el umbral cuando decides llamar a algo spam para mejorar también el rendimiento. Como ser humano, un 75% parece bastante seguro, pero para este modelo tuviste que aumentar más cerca del 81.5% a fin de ser más efectivo con las entradas de ejemplo.

No hay un valor mágico que funcione bien en diferentes modelos, y este valor límite debe establecerse por modelo después de experimentar con datos del mundo real para determinar qué funciona bien.

En algunas situaciones, tener un falso positivo (o negativo) podría tener consecuencias graves (p.ej., en la industria médica), por lo que podrías ajustar tu umbral para que sea muy alto y solicitar más revisiones manuales para las personas que no lo alcancen. Esta es tu opción como desarrollador y requiere un poco de experimentación.

4. Vuelve a entrenar el modelo de detección de comentarios spam

En la sección anterior, identificaste una serie de casos extremos que fallaban para el modelo y que la única opción era volver a entrenar el modelo para dar cuenta de estas situaciones. Con el tiempo, en un sistema de producción, podrías encontrar estos comentarios, ya que las personas marcan un comentario como spam de forma manual que se permitió o los moderadores que revisaban los comentarios marcados se dan cuenta de que algunos en realidad no son spam y podrían marcar esos comentarios para volver a entrenarlos. Si suponemos que recopilaste muchos datos nuevos para estos casos límite (para obtener mejores resultados, deberías tener algunas variaciones de estas oraciones nuevas si puedes), ahora continuaremos mostrándote cómo volver a entrenar el modelo con esos casos límite en mente.

Resumen del modelo prediseñado

El modelo creado previamente que usaste fue un modelo creado por un tercero a través de Model Maker, que usa una “incorporación de palabras promedio”. para que funcione el modelo.

Como el modelo se compiló con Model Maker, deberás cambiar brevemente a Python para volver a entrenar el modelo y, luego, exportarlo al formato TensorFlow.js para poder usarlo en el navegador. Afortunadamente, Model Maker hace que usar sus modelos sea muy simple, por lo que debería ser bastante fácil de seguir, y te guiaremos en el proceso, así que no te preocupes si nunca antes usaste Python.

Colaboraciones

Como en este codelab no te preocupa querer configurar un servidor Linux con todas las utilidades de Python instaladas, puedes simplemente ejecutar código a través del navegador web con un “notebook de Colab”. Estos notebooks pueden conectarse a un “backend” es decir, un servidor con elementos preinstalados, desde los que luego puedes ejecutar un código arbitrario dentro del navegador web y ver los resultados. Esto es muy útil para un prototipado rápido o para usar en instructivos como este.

Simplemente dirígete a colab.research.google.com y verás una pantalla de bienvenida como se muestra a continuación:

6b82258445885c50.png

Ahora, haz clic en el botón Nuevo notebook en la esquina inferior derecha de la ventana emergente. Deberías ver una cola en blanco como la siguiente:

2d52c8f7afa88564.png

¡Genial! El siguiente paso es conectar el Colab de frontend a algún servidor de backend para que puedas ejecutar el código de Python que escribirás. Para ello, haz clic en Conectar en la parte superior derecha y selecciona Conectarse a un entorno de ejecución alojado.

fa5f578a1a3d352b.png

Una vez conectado, deberías ver los íconos de RAM y disco en su lugar, de la siguiente manera:

541c9894fb39d4cb.png

¡Bien hecho! Ahora puedes comenzar a programar en Python para volver a entrenar el modelo de Model Maker. Simplemente, siga los pasos que se indican a continuación.

Paso 1

En la primera celda que esté vacía, copia el siguiente código. Instalará TensorFlow Lite Model Maker por ti con el administrador de paquetes de Python llamado “pip”. (es similar a npm, y es posible que la mayoría de los lectores de este codelab estén más familiarizados con el ecosistema de JS):

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

Sin embargo, pegar el código en la celda no lo ejecutará. A continuación, coloca el cursor del mouse sobre la celda gris en la que pegaste el código anterior y reproduce un pequeño fragmento de código aparecerá un ícono a la izquierda de la celda, tal como se destaca a continuación:

7ac5e3516bed6335.png Haz clic en el botón de reproducción para ejecutar el código que acabas de escribir en la celda.

Ahora, verás que se está instalando Model Maker:

651f21b04fb648cc.png

Una vez que se complete la ejecución de esta celda como se muestra, continúa con el siguiente paso.

Paso 2

A continuación, agrega una nueva celda de código como se muestra para poder pegar más código después de la primera celda y ejecutarlo por separado:

869904a9d774c455.png

La siguiente celda ejecutada tendrá una serie de importaciones que deberá usar el código del resto del notebook. Copia y pega lo siguiente en la nueva celda creada:

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

Es una práctica bastante estándar, incluso si no estás familiarizado con Python. Solo estás importando algunas utilidades y las funciones de Model Maker necesarias para el clasificador de spam. Esto también verificará si estás ejecutando TensorFlow 2.x, que es un requisito para usar Model Maker.

Finalmente, al igual que antes, ejecuta la celda presionando el botón "reproducir" cuando colocas el cursor sobre la celda y, luego, agrega una nueva celda de código para el siguiente paso.

Paso 3

A continuación, descargarás los datos de un servidor remoto a tu dispositivo y establecerás la variable training_data como la ruta de acceso del archivo local resultante descargado:

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)

Model Maker puede entrenar modelos a partir de archivos CSV simples, como el que se descarga. Solo debes especificar qué columnas contienen el texto y cuáles contienen las etiquetas. Verás cómo hacerlo en el Paso 5. Si lo deseas, puedes descargar el archivo CSV directamente para ver qué contiene.

Los interesados notarán que el nombre de este archivo es jm_blog_comments_extras.csv. Se trata de los datos de entrenamiento originales que usamos para generar el primer modelo de comentario spam combinado con los nuevos datos de casos extremos que descubriste, de modo que todo esté en un solo archivo. También necesitas los datos de entrenamiento originales que se usaron para entrenar el modelo, además de las oraciones nuevas de las que quieres aprender.

Opcional: Si descargas este archivo CSV y revisas las últimas líneas, verás ejemplos de casos extremos que antes no funcionaban correctamente. Acaban de agregarse al final de los datos de entrenamiento existentes que el modelo creado previamente usó para entrenarse a sí mismo.

Ejecuta esta celda y, cuando haya terminado, agrega una nueva, y dirígete al paso 4.

Paso 4

Cuando usas Model Maker, no creas modelos desde cero. Por lo general, usas modelos existentes que luego personalizarás según tus necesidades.

Model Maker proporciona varias incorporaciones de modelos de aprendizaje previo que puedes usar, pero la más simple y rápida para comenzar es average_word_vec, que es lo que usaste en el codelab anterior para compilar tu sitio web. Este es el código:

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

Ejecuta esa acción una vez que la pegaste en la celda nueva.

Conceptos básicos

num_words

parámetro

Esta es la cantidad de palabras que quieres que use el modelo. Tal vez pienses que cuanto más, mejor, pero, por lo general, hay un punto óptimo que se basa en la frecuencia con la que se usa cada palabra. Si usas cada palabra de todo el corpus, podrías terminar con el modelo tratando de aprender y equilibrar el peso de las palabras que solo se usan una vez, lo que no es muy útil. En cualquier corpus de texto, encontrarás que muchas palabras solo se usan una o dos veces y, por lo general, no vale la pena usarlas en tu modelo, ya que tienen un impacto insignificante en la opinión general. Por lo tanto, puedes ajustar tu modelo en función de la cantidad de palabras que desees con el parámetro num_words. Un número menor aquí tendrá un modelo más pequeño y rápido, pero podría ser menos preciso, ya que reconoce menos palabras. Un número mayor aquí tendrá un modelo más grande y potencialmente más lento. Encontrar el punto óptimo es clave, y depende de ti como ingeniero de aprendizaje automático descubrir qué funciona mejor para tu caso de uso.

Conceptos básicos

wordvec_dim

parámetro

El parámetro wordvec_dim es la cantidad de dimensiones que deseas usar para el vector de cada palabra. Estas dimensiones son, en esencia, las diferentes características (creadas por el algoritmo de aprendizaje automático durante el entrenamiento) que puede medir cualquier palabra determinada con la que el programa usará para probar y asociar mejor las palabras que son similares de alguna manera significativa.

Por ejemplo, si tuvieras una dimensión sobre qué tan "médico" una palabra era, una palabra como "píldoras", Puede tener una puntuación alta en esta dimensión y asociarse con otras palabras de puntuación alta, como “rayos X”, pero “gato” obtendrían una puntuación baja en esta dimensión. Podría resultar que una "dimensión médica" Es útil para determinar el spam cuando se combina con otras dimensiones que podría decidir usar y que son significativas.

En el caso de las palabras que obtuvieron una puntuación alta en la "dimensión médica" podría ser útil usar una segunda dimensión que relacione palabras con el cuerpo humano. Palabras como “pata”, “brazo” o “cuello” puede tener una puntuación alta aquí y también bastante alta en la dimensión médica.

El modelo puede usar estas dimensiones para habilitarla y detectar palabras que tienen más probabilidades de asociarse con el spam. Tal vez los correos electrónicos de spam tienen más probabilidades de contener palabras que son partes médicas y del cuerpo humano.

La regla de oro determinada a partir de la investigación es que la raíz cuarta de la cantidad de palabras funciona bien para este parámetro. Si estoy usando 2,000 palabras, un buen punto de partida para esto son 7 dimensiones. Si cambias la cantidad de palabras que usas, también puedes cambiar esta opción.

Conceptos básicos

seq_len

parámetro

Por lo general, los modelos son muy rígidos en lo que respecta a los valores de entrada. Para un modelo de lenguaje, esto significa que el modelo puede clasificar oraciones de una longitud particular y estática. Eso se determina con el parámetro seq_len, en el que significa "longitud de la secuencia". Cuando conviertes palabras en números (o tokens), una oración se convierte en una secuencia de esos tokens. Por lo tanto, tu modelo será entrenado (en este caso) para clasificar y reconocer oraciones que tengan 20 tokens. Si la oración es más larga, se truncará. Si es más corta, se rellenará, al igual que en el primer codelab de esta serie.

Paso 5: Carga los datos de entrenamiento

Antes, descargaste el archivo CSV. Es momento de usar un cargador de datos para convertir esto en datos de entrenamiento que el modelo pueda reconocer.

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)

Si abres el archivo CSV en un editor, verás que cada línea solo tiene dos valores, que se describen con texto en la primera línea del archivo. Por lo general, cada entrada se considera una "columna". Verás que el descriptor de la primera columna es commenttext y que la primera entrada de cada línea es el texto del comentario.

De manera similar, el descriptor de la segunda columna es spam, y verás que la segunda entrada en cada línea es TRUE o FALSE para indicar si ese texto se considera comentario spam o no. Las otras propiedades establecen la especificación del modelo que creaste en el paso 4, junto con un carácter delimitador, que en este caso es una coma cuando el archivo está separado por comas. También establecerás un parámetro de Shuffle para reorganizar de forma aleatoria los datos de entrenamiento, de modo que los elementos que hayan sido similares o recopilados se distribuyan de forma aleatoria en todo el conjunto de datos.

A continuación, usarás data.split() para dividir los datos en datos de entrenamiento y de prueba. El 0 .9 indica que el 90% del conjunto de datos se usará para el entrenamiento y el resto para las pruebas.

Paso 6: Compila el modelo

Agrega otra celda en la que agregaremos el código para compilar el modelo:

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

Esto crea un modelo clasificador de texto con Model Maker, y tú especificas los datos de entrenamiento que quieres usar (que se definió en el paso 4), la especificación del modelo (que también se estableció en el paso 4) y una cantidad de ciclos de entrenamiento, en este caso, 50.

El principio básico del aprendizaje automático es que es una forma de coincidencia de patrones. Inicialmente, cargará las ponderaciones previamente entrenadas de las palabras y tratará de agruparlas con una “predicción” de las que cuando se agrupan indican spam y las que no. La primera vez, es probable que se acerque a las 50:50, ya que el modelo solo se está iniciando como se muestra a continuación:

bbe4b896d8060bc4.png

Luego, medirá los resultados y cambiará los pesos del modelo para modificar su predicción, y volverá a intentarlo. Este es un ciclo de entrenamiento. Entonces, al especificar epochs=50, pasará por ese “bucle”. 50 veces, como se muestra a continuación:

4ed286d114960ca.png

Por lo tanto, cuando llegues al ciclo de entrenamiento número 50, el modelo informará un nivel de exactitud mucho mayor. En este caso, se muestra el 99.1%.

Paso 7: exporta el modelo

Una vez finalizado el entrenamiento, puedes exportar el modelo. TensorFlow entrena un modelo en su propio formato, que se debe convertir al formato TensorFlow.js para usarlo en una página web. Simplemente pega lo siguiente en una celda nueva y ejecútalo:

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

Después de ejecutar este código, si haces clic en el ícono de carpeta pequeña que se encuentra a la izquierda de Colab, puedes navegar a la carpeta a la que exportaste anteriormente (en el directorio raíz, es posible que debas subir de nivel) y buscar el paquete ZIP de los archivos exportados en ModelFiles.zip.

Descarga este archivo ZIP en tu computadora ahora, ya que usarás esos archivos como en el primer codelab:

cda3c681ebf144b4.png

¡Genial! Terminamos con Python. Ahora puedes volver al entorno de JavaScript que conoces y te encanta. ¡Vaya!

5. Entregar el nuevo modelo de aprendizaje automático

Ya estás casi listo para cargar el modelo. Antes de hacerlo, debes subir los archivos del modelo nuevo que descargaste antes en el codelab para que se aloje y se pueda usar en tu código.

Primero, si aún no lo hiciste, descomprime los archivos del modelo que acabas de descargar del notebook de Colab de Model Maker que acabas de ejecutar. Deberías ver los siguientes archivos dentro de las distintas carpetas:

3ace87c57b98cfbc.png

¿Qué obtienes aquí?

  • model.json: Este es uno de los archivos que conforman el modelo entrenado de TensorFlow.js. Harás referencia a este archivo específico en el código JS.
  • group1-shard1of1.bin: Es un archivo binario que contiene gran parte de los datos guardados del modelo de TensorFlow.js exportado y debe estar alojado en algún lugar de tu servidor para descargarlo en el mismo directorio que model.json anterior.
  • vocab: Este archivo extraño sin extensión es algo de Model Maker que nos muestra cómo codificar palabras en las oraciones para que el modelo entienda cómo usarlas. Profundizaremos más en este tema en la próxima sección.
  • labels.txt: Solo contiene los nombres de clase resultantes que el modelo predecirá. En este modelo, si abres este archivo en tu editor de texto, solo tendrá el valor “false”. y "verdadero" indicado que indica que "no es spam" o "spam" como resultado de la predicción.

Aloja los archivos del modelo de TensorFlow.js

Primero, coloca los archivos model.json y *.bin que se generaron en un servidor web para poder acceder a ellos a través de tu página web.

Borra los archivos de modelos existentes

A medida que compilas el resultado final del primer codelab de esta serie, primero debes borrar los archivos del modelo existentes subidos. Si usas Glitch.com, solo revisa el panel de archivos de la izquierda para model.json y group1-shard1of1.bin, haz clic en el menú desplegable de 3 puntos de cada archivo y selecciona delete como se muestra a continuación:

c72bfdc5a0db4d0d.png

Cómo subir archivos nuevos a Glitch

¡Genial! Ahora, sube los nuevos:

  1. Abre la carpeta assets en el panel izquierdo de tu proyecto de Glitch y borra los recursos antiguos que hayas subido si tienen el mismo nombre.
  2. Haz clic en Subir un recurso y selecciona group1-shard1of1.bin para subirlo a esta carpeta. Una vez que se suba, debería verse de la siguiente manera:

c6739dd30e6df977.png

  1. ¡Genial! Ahora, haz lo mismo con el archivo model.json, de manera que haya 2 archivos en tu carpeta de recursos de la siguiente manera:

b7858eb08bea9ac3.png

  1. Si haces clic en el archivo group1-shard1of1.bin que acabas de subir, podrás copiar la URL en su ubicación. Copia esta ruta de acceso ahora como se muestra a continuación:

19999f6644f61153.png

  1. Ahora, en la parte inferior izquierda de la pantalla, haz clic en Herramientas > Terminal: Espera a que se cargue la ventana de la terminal.
  2. Una vez cargado, escribe lo siguiente y, luego, presiona Intro para cambiar el directorio a la carpeta www:

terminal:

cd www
  1. A continuación, usa wget para descargar los 2 archivos que acabas de subir. Para ello, reemplaza las siguientes URLs por las que generaste para los archivos en la carpeta de recursos de Glitch (consulta la carpeta de recursos de la URL personalizada de cada archivo).

Ten en cuenta que el espacio entre las dos URLs y que las URLs que necesitarás utilizar serán diferentes a las que se muestran, pero se verán similares:

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

Exactamente Ya creaste una copia de los archivos que se subieron a la carpeta www.

Sin embargo, por el momento, se descargarán con nombres extraños. Si escribes ls en la terminal y presionas Intro, verás algo como esto:

6c417fdfc64762f1.png

  1. Usa el comando mv para cambiar el nombre de los archivos. Escribe lo siguiente en la consola y presiona Intro después de cada línea:

terminal:

mv *group1-shard1of1.bin* group1-shard1of1.bin
mv *model.json* model.json
  1. Por último, para actualizar el proyecto de Glitch, escribe refresh en la terminal y presiona Intro:

terminal:

refresh

Después de actualizar, deberías ver model.json y group1-shard1of1.bin en la carpeta www de la interfaz de usuario:

530bb651f4dbac64.png

¡Genial! El último paso es actualizar el archivo dictionary.js.

  1. Convierte el nuevo archivo de vocabulario que descargaste al formato JS correcto, ya sea manualmente a través del editor de texto o con esta herramienta, y guarda el resultado como dictionary.js en tu carpeta www. Si ya tienes un archivo dictionary.js, simplemente copia y pega el contenido nuevo sobre él y guárdalo.

¡Muy bien! Actualizaste con éxito todos los archivos modificados y, si ahora intentas usar el sitio web, notarás cómo el modelo que se volvió a entrenar debería tener en cuenta los casos extremos descubiertos y aprendidos como se muestra a continuación:

64e5cf6f6e158d6c.gif

Como puedes ver, los primeros 6 ahora clasifican correctamente como “no es spam” y el segundo lote de 6 se identifica como spam. ¡Perfecto!

Probemos algunas variaciones para ver si se generaliza bien. Originalmente, había una oración fallida como la siguiente:

"¡Las acciones de GOOG se dispararon de inmediato! Llega antes de que sea demasiado tarde".

Ahora se clasificó correctamente como spam, pero ¿qué sucede si lo cambias a:

"Entonces, ¡las acciones de XYZ acaban de aumentar de valor! ¡Compra algunos justo antes de que sea demasiado tarde!"

Aquí obtienes una predicción del 98% de las probabilidades de ser spam, que es correcta aunque hayas cambiado ligeramente el símbolo bursátil y la redacción.

Por supuesto, si realmente intentas romper este modelo nuevo, podrás hacerlo, y se reduce a recopilar aún más datos de entrenamiento para tener la mejor oportunidad de capturar más variaciones únicas para las situaciones comunes que probablemente te encuentres en línea. En un codelab futuro, te mostraremos cómo mejorar continuamente tu modelo con datos en vivo a medida que se marcan.

6. ¡Felicitaciones!

Felicitaciones. Lograste volver a entrenar un modelo de aprendizaje automático existente para que se actualice a sí mismo y funcione en los casos extremos que encontraste y, luego, implementaste esos cambios en el navegador con TensorFlow.js para una aplicación del mundo real.

Resumen

En este codelab, lograste lo siguiente:

  1. Se detectaron casos extremos que no funcionaban con el modelo de comentarios spam prediseñado
  2. Volviste a entrenar el modelo de Model Maker para tener en cuenta los casos extremos que descubriste
  3. Exportaste el modelo entrenado nuevo a formato TensorFlow.js
  4. Actualizaste tu aplicación web para usar los nuevos archivos

¿Qué sigue?

Esta actualización funciona muy bien, pero, al igual que con cualquier aplicación web, los cambios se producirán con el paso del tiempo. Sería mucho mejor si la app mejorara a sí misma de forma continua con el tiempo, en lugar de que tengamos que hacerlo manualmente cada vez. ¿Puedes pensar cómo puedes haber automatizado estos pasos para volver a entrenar automáticamente un modelo después de haber, por ejemplo, 100 comentarios nuevos marcados como clasificados de forma incorrecta? Ponte tu sombrero de ingeniería web habitual y probablemente puedas averiguar cómo crear una canalización para hacerlo automáticamente. Si no es así, no te preocupes. Presta atención al siguiente codelab de la serie, en el que se mostrará cómo hacerlo.

Comparte tus creaciones con nosotros

También puedes extender fácilmente lo que creaste hoy para otros casos de uso creativos, y te recomendamos que pienses de forma innovadora y sigas hackeando.

Recuerda etiquetarnos en redes sociales con el hashtag #MadeWithTFJS para tener la oportunidad de que tu proyecto se destaque en el blog de TensorFlow o incluso en eventos futuros. Nos encantaría ver tus productos.

Más codelabs de TensorFlow.js para obtener más información

Sitios web que puedes revisar