1. Antes de comenzar
Este codelab se diseñó para desarrollar el resultado final del codelab anterior de esta serie a fin de detectar comentarios spam mediante TensorFlow.js.
En el último codelab, creaste una página web completamente funcional para un blog de video ficticio. Pudiste filtrar los comentarios en busca de spam antes de que se enviaran al servidor para su almacenamiento, o bien a otros clientes conectados, con 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:
Si bien esto funcionó muy bien, existen casos extremos para explorar que no se pudo detectar. Puedes volver a entrenar el modelo para dar cuenta de las situaciones que no pudo controlar.
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 lo hagas).realizar los codelabs en orden ), para abordar el problema real del spam de comentarios, que muchos desarrolladores web seguramente encontrarán mientras trabajan en una de las crecientes apps web populares que existe en la actualidad.
En este codelab, irás un paso más allá y reentrenarás tu modelo de AA para que responda a 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 conversación populares que te permiten mantener el modelo actualizado y tener en cuenta esos cambios.
Requisitos previos
- Completaste el primer codelab de esta serie.
- Conocimientos básicos de tecnologías web, como HTML, CSS y JavaScript
Qué compilarás
Reutilizará el sitio web compilado anteriormente para un blog de video ficticio con una sección de comentarios en tiempo real y lo actualizará 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, puedes cambiar esta UX hipotética para volver a usarla en cualquier sitio web en el que estés trabajando a diario y adaptar la solución a todos los casos de uso del cliente. Tal vez sea un blog, un foro o algún tipo de CMS, como Drupal.
¡Comencemos!
Qué aprenderá
Realizará lo siguiente:
- Identifica los 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 de TensorFlow.js para usarlo en navegadores.
- Actualizar el modelo alojado y su diccionario con el modelo recién entrenado y verificar los resultados
Para este lab, se asume que tiene conocimientos de HTML5, CSS y JavaScript. También ejecutará un código de Python mediante un notebook de “co lab” para volver a entrenar el modelo que se creó con Model Maker, pero no es necesario que tenga conocimientos de Python para hacerlo.
2. Configura el código
Una vez más, usarán Glitch.com para alojar y modificar la aplicación web. Si todavía no completaste el codelab de requisitos previos, puedes clonar el resultado final aquí como tu punto de partida. Si tienes preguntas sobre el funcionamiento del código, te recomendamos que completes el codelab anterior, en el que se explica cómo crear esta aplicación web que funciona antes de continuar.
En Glitch, haz clic en el botón remix this para bifurcarlo y crear un nuevo conjunto de archivos que puedes editar.
3. Descubre casos extremos en la solución anterior
Si abres el sitio web completo que acabas de clonar y tratas de escribir algunos comentarios, notarás que, en la mayoría de los casos, funciona según lo previsto, bloqueando los comentarios que suenan como spam y que se permiten las respuestas legítimas.
Sin embargo, si se vuelve intuitivo y trata de decir algo para romper el modelo, es probable que tenga éxito en algún momento. Con un poco de prueba y error, puede crear manualmente ejemplos como los que se muestran a continuación. Intenta pegarlos en la app web existente, revisa la consola y consulta las probabilidades de que el comentario vuelva a ser spam:
Comentarios legítimos publicados sin problemas (verdaderos negativos):
- “Vaya, me encanta ese video. Es un trabajo increíble”. Probabilidad de spam: 47.91854%
- “¡Me encantan estas demostraciones! ¿Tiene más detalles?”. Probabilidad de spam: 47.15898%
- "¿Qué sitio web puedo visitar para obtener más información?" Spam de probabilidad: 15.32495%
Esto es genial, ya que las probabilidades de todas las anteriores son bastante bajas y se completan correctamente con el SPAM_THRESHOLD predeterminado de una probabilidad mínima del 75% antes de que se tome alguna medida (definido en el código script.js del codelab anterior).
Ahora, intentemos escribir algunos comentarios más atrevidos que se marquen como spam aunque no lo sean...
Comentarios legítimos marcados como spam (falsos positivos):
- ¿Puede alguien vincular el sitio web de la mascarilla que tiene? Probabilidad de spam: 98.46466%
- “¿Puedo comprar esta canción en Spotify? ¡Avísanos! Probabilidad de spam: 94.40953%
- "¿Alguien puede comunicarse conmigo para brindarme detalles sobre cómo descargar TensorFlow.js?" Probabilidad de spam: 83.20084%
¡Ay, no! Parece que estos comentarios legítimos se están marcando como spam cuando se deben permitir. ¿Cómo puede solucionar eso?
Una opción simple es aumentar el SPAM_THRESHOLD para tener más de un 98.5% de confianza. En ese caso, se publicarán estos comentarios mal clasificados. Con eso en mente, continuemos con los demás resultados posibles que aparecen a continuación...
Comentarios de spam marcados como spam (verdaderos positivos):
- “Esto es genial, pero consulta los vínculos de descarga de mi sitio web que son mejores”. Spam de probabilidad: 99.77873%
- "Conozco a algunas personas que pueden comprarles medicamentos solo ven mi pr0archivo para obtener detalles" Probabilidad de spam: 98.46955%
- "Ve mi perfil para descargar videos aún más increíbles que son aún mejores". http://example.com" Probabilidad de spam: 96.26383%
Entonces, esto funciona según lo esperado con nuestro umbral original del 75%, pero dado que en el paso anterior cambiaste SPAM_THRESHOLD para tener más de 98.5%, esto significaría que se pasen 2 ejemplos aquí, así que tal vez el umbral es demasiado alta. ¿Quizás el 96% es mejor? Sin embargo, si lo haces, uno de los comentarios de la sección anterior (falsos positivos) se marcaría como spam cuando era legítimo, ya que se calificaba con un 98.46466%.
En este caso, probablemente sea la mejor opción para capturar todos estos comentarios de spam reales y simplemente volver a entrenar para los errores anteriores. Si estableces el umbral en 96%, se captarán todos los verdaderos positivos y se eliminarán 2 de los falsos positivos anteriores. No está mal para cambiar solo un número.
Continuemos...
Comentarios spam que se pudieron publicar (falsos negativos):
- “Consulta mi perfil para descargar videos aún más asombrosos que son aún mejores”. Probabilidad de spam: 7.54926%
- "Obtén un descuento en nuestras clases de entrenamiento en gimnasios: consulta el pr0archivo" Probabilidad de spam: 17.49849%
- “¡Increíble! Acaban de ponerse en marcha. ¡Llega antes de tiempo!”. Probabilidad de spam: 20.42894%
Para estos comentarios, no puedes hacer nada simplemente cambiando el valor de SPAM_THRESHOLD. Si reduces el umbral de spam del 96% al 9%, los comentarios genuinos se marcarán como spam. Sin embargo, uno de ellos tiene una calificación del 58%, incluso si es legítimo. La única forma de abordar los comentarios como estos sería volver a entrenar el modelo con los casos extremos incluidos en los datos de entrenamiento para que aprenda a ajustar su visión del mundo respecto de lo que es spam o no.
Si bien la única opción que se encuentra en este momento es volver a entrenar el modelo, también vio cómo puede definir mejor el umbral de cuándo decide llamar a algo spam para mejorar también el rendimiento. Como humano, el 75% parece bastante seguro, pero para este modelo debía aumentar más cerca del 81.5% para ser más efectivo con las entradas de ejemplo.
No hay un valor mágico que funcione bien en diferentes modelos, y este valor de umbral debe establecerse en función del modelo después de experimentar con datos reales para lo que funciona bien.
Puede haber algunas situaciones en las que tener un falso positivo (o negativo) tenga consecuencias graves (p.ej., en el sector médico), por lo que es posible que ajuste su límite para que sea muy alto y solicite más revisiones manuales a quienes no lo alcancen. Esta es la opción que elegirá usted como desarrollador y requiere cierta experimentación.
4. Vuelve a entrenar el modelo de detección de spam de comentarios
En la sección anterior, identificaste una cantidad de casos extremos que fallaban en el modelo, donde la única opción era volver a entrenar el modelo para tener en cuenta estas situaciones. Con un tiempo, en un sistema de producción, a medida que las personas marcan un comentario como spam de forma manual o los moderadores lo revisan, se dan cuenta de que, en realidad, no son spam y que pueden marcar los comentarios para volver a entrenarlos. Suponiendo que recopilaste muchos datos nuevos para estos casos extremos (para obtener mejores resultados, debes tener algunas variaciones de estas oraciones nuevas si puedes), continuaremos mostrándote cómo volver a entrenar el modelo con esos casos extremos en mente.
Resumen del modelo creado previamente
El modelo prediseñado que usaste fue un modelo creado por un tercero a través de Model Maker que usa un modelo de "incorporación promedio de palabras" para funcionar.
Como el modelo se compiló con Model Maker, deberás cambiar brevemente a Python para volver a entrenarlo y, luego, exportarlo al formato de TensorFlow.js para poder usarlo en el navegador. Afortunadamente, Model Maker hace que sea muy fácil usar sus modelos, así que debería ser bastante fácil seguirlo y te guiaremos a través del proceso, así que no te preocupes si nunca usaste Python.
Colaboraciones
Como en este codelab no te preocupa mucho la tarea de configurar un servidor de Linux con todas las utilidades de Python instaladas, puedes ejecutar el código mediante el navegador web usando un “notebook de Colab”. Estos notebooks pueden conectarse a un "backend", que es simplemente un servidor con algunos elementos preinstalados, desde los cuales puedes ejecutar código arbitrario en el navegador web y ver los resultados. Esto es muy útil para la creación de prototipos rápidos o para su uso en instructivos como este.
Simplemente ve a colab.research.google.com y verás una pantalla de bienvenida como se muestra a continuación:
Ahora, haga clic en el botón New Notebook, en la esquina inferior derecha de la ventana emergente, y debería ver un Colab en blanco como el siguiente:
¡Genial! El siguiente paso es conectar el Colab de frontend a algún servidor de backend para poder ejecutar el código de Python que escribirás. Para ello, haz clic en Conectar en la parte superior derecha y selecciona Conectar al entorno de ejecución alojado.
Una vez conectado, deberías ver los íconos de RAM y de disco en su lugar, como se muestra a continuación:
¡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 vacía, copia el siguiente código. Este instalará TensorFlow Lite Model Maker por ti mediante el administrador de paquetes de Python, llamado “pip” (es similar al de npm, con el que la mayoría de los lectores de este codelab pueden estar más familiarizados con el ecosistema de JS):
!pip install -q tflite-model-maker
Sin embargo, pegar el código en la celda no lo ejecutará. Luego, coloque el cursor sobre la celda gris en la que pegó el código anterior, y aparecerá un pequeño ícono de "reproducir" a la izquierda de la celda, como se muestra a continuación:
Haz clic en el botón de reproducción para ejecutar el código que acabas de escribir en la celda.
Ahora verás cómo se instala el creador de modelos:
Una vez que se complete la ejecución de esta celda, como se muestra, continúa con el siguiente paso.
Paso 2
Luego, agrega una celda de código nueva como se muestra para que puedas pegar más código después de la primera celda y ejecutarla por separado:
La siguiente celda ejecutada tendrá varias importaciones que el código del resto del notebook deberá usar. Copie y pegue 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')
Bastante estándar, incluso si no estás familiarizado con Python. Solo importarás algunas utilidades y las funciones de Model Maker necesarias para el clasificador de spam. Esto también comprobará si estás ejecutando TensorFlow 2.x, que es un requisito para usar Model Maker.
Por último, tal como antes, ejecuta la celda presionando el ícono de "reproducir" cuando coloques 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 en tu dispositivo y establecerás la variable training_data en la ruta del archivo local resultante:
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)
Model Maker puede entrenar modelos a partir de archivos CSV simples, como el que se descargó. Solo debe especificar qué columnas contienen el texto y cuáles contienen las etiquetas. En el paso 5, se explica cómo hacerlo. Si lo desea, puede descargar el archivo CSV directamente para ver qué contiene.
El guardián entre ustedes notará que el nombre de este archivo es jm_blog_comments_extras.csv. Este archivo es simplemente los datos originales de entrenamiento que usamos para generar el primer modelo de comentarios spam. se combinan con los nuevos datos de casos extremos que descubrieron, de modo que estén en un solo archivo. Necesitas los datos de entrenamiento originales que se usaron para entrenar el modelo, además de las oraciones nuevas que quieres aprender.
Opcional: Si descargas este archivo CSV y revisas las últimas líneas, verás ejemplos de casos extremos que no funcionaban correctamente. Se acaban de agregar al final de los datos de entrenamiento existentes que el modelo prediseñado usaba para entrenarse.
Ejecuta esta celda y, cuando termine de ejecutarla, agrega una celda nueva y continúa con el paso 4.
Paso 4
Cuando usas Model Maker, no compilas modelos desde cero. Por lo general, usas modelos existentes que luego personalizarás según tus necesidades.
Model Maker proporciona varias incorporaciones de modelos previamente aprendidos 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 función en la celda nueva.
Información sobre el
num_words
parámetro
Esta es la cantidad de palabras que quieres que use el modelo. Quizás creas que cuanto mejor, mejor, pero, por lo general, hay un punto óptimo en función de la frecuencia con la que se usa cada palabra. Si usas todas las palabras de todo el corpus, podrías terminar con el modelo que intenta aprender y equilibrar las ponderaciones de las palabras que se usan solo una vez. Esto no es muy útil. En cualquier corpus de texto, descubrirás que muchas palabras solo se usan una o dos veces y, por lo general, no vale la pena incluirlos en tu modelo, ya que tienen un impacto insignificante en la opinión general. Por lo tanto, puedes ajustar el modelo en función de la cantidad de palabras que desees con el parámetro num_words. Un número más pequeño tendrá un modelo más pequeño y rápido, pero podría ser menos preciso, ya que reconoce menos palabras. Un número más grande tendrá un modelo más grande y potencialmente más lento. Encontrar el punto óptimo es clave, como ingeniero de aprendizaje automático, decidir qué funciona mejor para tu caso de uso.
Información sobre el
wordvec_dim
parámetro
El parámetro wordvec_dim es la cantidad de dimensiones que deseas usar para el vector de cada palabra. Básicamente, estas dimensiones son diferentes características (creadas por el algoritmo de aprendizaje automático durante el entrenamiento) que pueden medir cualquier palabra determinada para que el programa intente identificarlas y asociarlas de manera significativa.
Por ejemplo, si tuviera una dimensión sobre qué tan "médico" era una palabra, una palabra como "píldoras" podría obtener una puntuación alta en esta dimensión y asociarse con otras palabras con puntuaciones altas como "xray", pero "gato" tendría una puntuación en esta dimensión. Es posible que una "dimensión médica" sea útil para determinar el spam cuando se combina con otras dimensiones potenciales que puede decidir usar.
En el caso de las palabras que tienen una puntuación alta en la "dimensión médica", podría resultar útil una segunda dimensión que correlaciona las palabras con el cuerpo humano. Las palabras como "pierna", "brazos", "cuello" pueden obtener una puntuación alta en este caso y, además, en la dimensión médica.
El modelo puede usar estas dimensiones para luego detectar palabras que estén asociadas con el spam. Es posible que los correos electrónicos de spam tengan más probabilidades de contener palabras que contengan partes médicas y humanas.
La regla general que se determina a partir de las investigaciones es que la cuarta raíz de la cantidad de palabras funciona bien para este parámetro. Entonces, si uso 2,000 palabras, un buen punto de partida para esto son 7 dimensiones. Si cambias el número de palabras que usas, también puedes hacerlo.
Información sobre el
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 idioma, esto significa que el modelo de lenguaje puede clasificar oraciones de una longitud estática y en particular. Esto se determina mediante el parámetro seq_len, que significa "longitud de la secuencia". Cuando convierte palabras en números (o tokens), una oración se convierte en una secuencia de estos tokens. Por lo tanto, se entrenará (en este caso) para que clasifique y reconozca oraciones con 20 tokens. Si la oración es más larga, se truncará. Si es más corto, se rellenará, como en el primer codelab de esta serie.
Paso 5: Carga los datos de entrenamiento
Anteriormente, descargaste el archivo CSV. Ahora, es momento de usar un cargador de datos para convertir esto en datos de entrenamiento que el modelo puede 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 observarás que la segunda entrada de cada línea es TRUE o FALSE para indicar si ese texto es spam spam o no. Las otras propiedades establecen la especificación de modelo que creó en el paso 4, junto con un carácter delimitador, que en este caso es una coma, ya que el archivo está separado por comas. También configurará un parámetro Shuffle para reorganizar de forma aleatoria los datos de entrenamiento a fin de que los elementos que hayan sido similares o recopilados se repartan de forma aleatoria a lo largo del conjunto de datos.
Luego, usarás data.split() para dividir los datos en datos de entrenamiento y pruebas. El .9 indica que el 90% del conjunto de datos se usará para el entrenamiento y el resto para pruebas.
Paso 6: Compila el modelo
Agrega otra celda en la que agregaremos 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 especificas los datos de entrenamiento que deseas usar (que se definieron en el paso 4), la especificación del modelo (que también se configuró 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 comparación de patrones. Inicialmente, cargará las ponderaciones previamente entrenadas para las palabras y tratará de agruparlas con una "predicción" de aquellas que, cuando se agrupan, indican spam y cuáles no. La primera vez, es probable que esté cerca de los 50:50, ya que el modelo solo se está iniciando como se muestra a continuación:
Luego, medirá los resultados de esto y cambiará los pesos del modelo para ajustar su predicción, y volverá a intentarlo. Esta es una época. Por lo tanto, si especificas lifecycles=50, este pasará por el “bucle” 50 veces, como se muestra a continuación:
Por lo tanto, para cuando llegues a la época 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 debe convertirse al formato de TensorFlow.js para usarlo en una página web. Simplemente pegue lo siguiente en una celda nueva y ejecútelo:
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 la carpeta pequeña a la izquierda de Colab, puedes navegar a la carpeta que exportaste antes (en el directorio raíz, es posible que debas subir un nivel) y buscar el paquete ZIP del archivos exportados en ModelFiles.zip.
Descarga este archivo ZIP en tu computadora, ya que los usarás como en el primer codelab:
¡Genial! La parte de Python ya finalizó; ahora puede volver a la tierra de JavaScript que ya conoce y le gusta. ¡Vaya!
5. Deriva del nuevo modelo de aprendizaje automático
Ya está casi listo para cargar el modelo. Para ello, primero debes subir los nuevos archivos del modelo descargados anteriormente en el codelab a fin de que estén alojados y se puedan usar en tu código.
Primero, si aún no lo hiciste, descomprime los archivos para el modelo que acabas de descargar del notebook de Colab para Model Maker que acabas de ejecutar. Deberías ver los siguientes archivos en sus distintas carpetas:
¿Qué tienes aquí?
model.json: Este es uno de los archivos que componen el modelo entrenado de TensorFlow.js. Harás referencia a este archivo específico en el código de JS.group1-shard1of1.bin: Este es un archivo binario que contiene gran parte de los datos guardados del modelo de TensorFlow.js exportado y deberá alojarse en tu servidor para descargarse en el mismo directorio quemodel.json.vocab: Este archivo extraño sin extensión es algo de Model Maker que muestra cómo codificar palabras en las oraciones para que el modelo comprenda cómo se usan. Profundizaremos más en este tema en la siguiente sección.labels.txt: Simplemente contiene los nombres de clase resultantes que el modelo predecirá. Para este modelo, si abres este archivo en tu editor de texto, solo tiene una lista de las etiquetas "false" y "true" que indican "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 que puedas acceder a ellos a través de tu página web.
Cómo borrar archivos de modelo existentes
A medida que compiles sobre el resultado final del primer codelab de esta serie, primero debes borrar los archivos de modelo existentes subidos. Si usas Glitch.com, solo debes verificar el panel de archivos de la izquierda de model.json y group1-shard1of1.bin, hacer clic en el menú desplegable del menú de 3 puntos para cada archivo y seleccionar delete como se muestra a continuación:
Cómo subir nuevos archivos a Glitch
¡Genial! Ahora suba los nuevos:
- Abre la carpeta assets que se encuentra en el panel izquierdo de tu proyecto de Glitch y borra los activos antiguos que tengan los mismos nombres.
- Haga clic en Subir un elemento y seleccione
group1-shard1of1.binpara subirlo a esta carpeta. Ahora, debería verse así:
- ¡Genial! Ahora, haga lo mismo con el archivo model.json para que haya 2 archivos en su carpeta de elementos, como se muestra a continuación:
- Si haces clic en el archivo
group1-shard1of1.binque acabas de subir, podrás copiar la URL a su ubicación. Copia esta ruta de acceso como se muestra a continuación:
- Ahora, en la parte inferior izquierda de la pantalla, haz clic en Herramientas > Terminal. Espera a que se cargue la ventana de la terminal.
- Cuando termine de cargarse, escriba lo siguiente y presione Intro para cambiar el directorio a la carpeta
www:
terminal:
cd www
- Luego, usa
wgetpara descargar los 2 archivos subidos. Para ello, reemplaza las URL que se indican a continuación con las URL que generaste para los archivos de la carpeta de elementos en Glitch (verifica la carpeta de elementos para ver la URL personalizada de cada archivo).
Ten en cuenta que el espacio entre las dos URL y que deberás usar será diferente de las que se muestran, pero será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 Creaste una copia de los archivos subidos a la carpeta www.
Sin embargo, en este momento se descargarán con nombres extraños. Si escribes ls en la terminal y presionas Intro, verás algo como esto:
- Usa el comando
mvpara cambiar el nombre de los archivos. Escriba lo siguiente en la consola y presione Intro después de cada línea:
terminal:
mv *group1-shard1of1.bin* group1-shard1of1.bin
mv *model.json* model.json
- Por último, para actualizar el proyecto de Glitch, escribe
refreshen 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:
¡Genial! El último paso es actualizar el archivo dictionary.js.
- Convierte el nuevo archivo de vocabulario descargado al formato JS correcto de forma manual, por medio de tu editor de texto, o usa esta herramienta y guarda el resultado resultante como
dictionary.jsen tu carpetawww. Si ya tienes un archivodictionary.js, puedes copiar y pegar el contenido nuevo sobre él y guardarlo.
¡Hurra! Actualizaste correctamente todos los archivos modificados. Si ahora intentas usar el sitio web, notarás que el modelo que se volvió a entrenar debería poder responder a los casos extremos descubiertos y aprendidos, como se muestra a continuación:
Como puedes ver, los primeros 6 se clasifican correctamente como no spam y el segundo lote de 6 se identifica como spam. ¡Perfecto!
Probemos algunas variaciones también para ver si se generalizó bien. Originalmente, había una oración con errores, por ejemplo:
"Increíble, ¡supera GOOG! ¡Llegue antes de tiempo!"
Esto se clasifica correctamente como spam, pero ¿qué sucede si lo cambias a lo siguiente?
"Y, por lo tanto, las acciones de XYZ aumentaron. ¡Compre justo antes de que sea demasiado tarde!"
Aquí, obtendrás una predicción del 98% de probabilidades de que sea spam. Esto es correcto, aunque cambiaste el símbolo de acciones y la redacción levemente.
Por supuesto, si realmente intenta romper este nuevo modelo, podrá hacerlo y, a partir de esto, recopilará aún más datos de entrenamiento para tener la mejor oportunidad de capturar variaciones únicas de las situaciones comunes que puede encontrar en línea. En un codelab futuro, te mostraremos cómo mejorar continuamente tu modelo con datos activos a medida que se marcan.
6. ¡Felicitaciones!
Felicitaciones, logró volver a entrenar un modelo de aprendizaje automático existente para que se actualice a fin de que funcione con los casos extremos que encontró y, luego, implementó esos cambios en el navegador con TensorFlow.js para una aplicación real.
Resumen
En este codelab, lograste lo siguiente:
- Se descubrieron casos extremos que no funcionaban al utilizar el modelo de comentarios spam hechos previamente.
- Se volvió a entrenar el modelo de Model Maker para que tenga en cuenta los casos extremos que descubriste.
- Se exportó el nuevo modelo entrenado al formato de TensorFlow.js
- Actualizaste tu aplicación web para usar los nuevos archivos.
¿Qué sigue?
Por lo tanto, 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 continuamente con el tiempo en lugar de tener que hacerlo de forma manual cada vez. ¿Cómo crees que automatizaste estos pasos para volver a entrenar automáticamente un modelo después de tener, por ejemplo, 100 comentarios nuevos marcados como incorrectos? Ponte tu sombrero de ingeniería web y probablemente sepas cómo crear una canalización para hacerlo automáticamente. Si no, no te preocupes. Busca el próximo codelab de la serie que te mostrará cómo hacerlo.
Comparte tus creaciones con nosotros
También puedes ampliar fácilmente lo que creaste hoy para otros casos de uso creativo. Te recomendamos pensar de manera creativa y seguir hackeando.
Recuerda etiquetarnos en redes sociales con el hashtag #MadeWithTFJS para tener la oportunidad de que se incluya tu proyecto en el blog de TensorFlow o, incluso, en eventos futuros. Nos encantaría ver tus creaciones.
Más codelabs de TensorFlow.js para aprender más
- Usa Firebase Hosting para implementar y alojar un modelo de TensorFlow.js a gran escala.
- Crea una cámara web inteligente con un modelo de detección de objetos prediseñado con TensorFlow.js
Sitios web que puedes revisar
- Sitio web oficial de TensorFlow.js
- Modelos prediseñados de TensorFlow.js
- API de TensorFlow.js
- TensorFlow.js Show & Tell: Inspírate y mira lo que hicieron otras personas.