La importancia de la participación de las partes interesadas y del cliente en la ciencia de datos

El primer desafío al lanzar es asegurarse de hacerlo al nivel correcto. Para comprender cómo su modelo de IA resuelve los problemas, los clientes primero deben comprender qué hace y cuáles son los problemas. Es posible que tengan un doctorado en ciencia de datos o que nunca antes hayan oído hablar de un modelo. No es necesario enseñarles álgebra lineal ni hablar sobre su solución en un documento técnico. Tu objetivo es transmitir el valor añadido de tu solución a todos los públicos.

Aquí es donde entra en juego una demostración práctica. Gradio es un paquete liviano de código abierto para realizar demostraciones prácticas [1]. Está bien documentado que las demostraciones en vivo pueden resultar más personales y ayudar a impulsar la conversación/generar nuevos clientes potenciales. [2]. Las demostraciones prácticas pueden ser cruciales para generar confianza y comprensión con los nuevos usuarios.. La confianza se genera al verlo usar la herramienta o, mejor aún, al probarla con sus propias aportaciones. Cuando los usuarios pueden hacer una demostración de la herramienta, saben que no existe un «Clever Hans» [3] proceso en marcha y lo que ven es lo que obtienen. La comprensión aumenta cuando los usuarios ven los patrones de “si esto, entonces aquello” en el funcionamiento de su solución.

Luego viene la otra cara… todo el mundo ha asistido a una mala demostración en vivo. Todos hemos aguantado o hecho que otros aguanten dificultades técnicas.

Pero las dificultades técnicas no son lo único que nos da motivos para temer las demostraciones en vivo. Algunos otros factores desagradables comunes son:

• Volcado de información: Presentar algo a los clientes nunca debería parecer un sermón. Agregar demostraciones que son inaccesibles puede dar a los clientes demasiadas cosas que aprender demasiado rápido.
• Desarrollando una demostración: Las demostraciones pueden tardar en construirse y, de hecho, ralentizar el desarrollo. La retroalimentación periódica en “mostrar y contar” es un problema particular para los equipos ágiles. Obtener contenido para mostrar y contar puede ser una dura prueba. Especialmente si los clientes se acostumbran a una demostración en vivo.
• Dependencias rotas: Si usted es responsable de desarrollar una demostración, puede confiar en que algunas cosas se mantengan constantes. Si cambian, tendrás que empezar de nuevo.

Presentando Gradio

Ahora a la parte técnica. Gradio es un marco para demostrar modelos de aprendizaje automático/IA y se integra con el resto del ecosistema de Hugging Face. El marco se puede implementar utilizando SDK de Python o JavaScript. Aquí usaremos Python. Antes de crear una demostración, a continuación se muestra un ejemplo de aplicación Gradio para el reconocimiento de entidades con nombre:

Puede implementar Gradio en cualquier lugar donde trabaje actualmente, y este es un beneficio clave de usar el marco. Si está creando rápidamente un prototipo de código en un cuaderno y desea recibir comentarios instantáneos de las partes interesadas/colegas, puede agregar una interfaz Gradio. En mi experiencia de uso de Gradio, lo he implementado en cuadernos de Jupyter y Google Colab. También puedes implementar Gradio como un sitio independiente, a través de un enlace público alojado en HuggingFace. Exploraremos las opciones de implementación más adelante.

Las demostraciones de Gradio nos ayudan a resolver los problemas anteriores y a superar el miedo a la demostración en vivo:

• Volcado de información: Gradio proporciona una interfaz sencilla que abstrae mucha de la información difícil. Los clientes no están sobrecargados con la tarea de averiguar cómo interactuar con nuestra herramienta. y qué es la herramienta de una vez.
• Desarrollando una demostración: Las demostraciones de Gradio tienen los mismos beneficios que StreamLit y ​​Shiny. El código de demostración es simple y se basa en el código Python que ya ha escrito para su producto. Esto significa que puede realizar cambios rápidamente y obtener comentarios instantáneos. También puedes ver la demostración desde el punto de vista del cliente.
• Dependencias rotas: Ningún marco superará las revisiones completas del proyecto. Gradio está diseñado para adaptarse a nuevos datos, tipos de datos e incluso nuevos modelos. La simplicidad y el rango de entradas/salidas permitidas significa que las demostraciones de Gradio se mantienen bastante constantes. No sólo eso, sino que si tienes muchas herramientas, muchos clientes y muchos proyectos, ¡la buena noticia es que la mayor parte de tu código de demostración no cambiará! ¡Puede simplemente cambiar una salida de texto a una salida de imagen y estará listo para pasar de LLM a Difusión estable!

Guía paso a paso para crear una demostración usando Gradio

La sección práctica de este artículo lo llevará desde un completo principiante hasta un experto en demostraciones en Gradio. Dicho esto, a veces menos puede ser más. Si estás buscando una demostración realmente simple para resaltar el impacto de tu trabajo por todos los medios, ¡cíñete a lo básico!

Para obtener más información sobre alternativas como StreamLit, consulte mi publicación anterior:

Los basicos

Comencemos con un ejemplo de estilo Hello World para que podamos aprender más sobre lo que constituye una demostración de Gradio. Contamos con tres componentes fundamentales:

1. Variables de entrada: proporcionamos cualquier cantidad de variables de entrada que los usuarios pueden ingresar usando botones, controles deslizantes u otros widgets de entrada en nuestra demostración.
2. Función: El autor de la demostración crea una función que hace el trabajo pesado. Aquí es donde cambia el código. entre las demostraciones más. La función transformará las variables de entrada en una salida que verá el usuario. Aquí es donde podemos llamar a un modelo, transformar datos o hacer cualquier otra cosa que necesitemos.
3. Interfaz: la interfaz combina las variables de entrada, los widgets de entrada, las funciones y los widgets de salida en una sola demostración.

Así que veamos cómo se ve en forma de código:

Esto nos da la siguiente demostración. Observe cómo la entrada y la salida son del tipo texto como lo definimos anteriormente:

Ahora que entendemos los componentes básicos de Gradio, seamos un poco más técnicos.

Para ver cómo podemos aplicar Gradio a un problema de aprendizaje automático, usaremos el algoritmo más simple que podamos. Una regresión lineal. Para el primer ejemplo. Construiremos una regresión lineal utilizando el conjunto de datos de precios de la vivienda de California. Primero, actualizamos el código básico para que la función haga una predicción basada en un modelo lineal:

Luego actualizamos la interfaz para que las entradas y salidas coincidan con lo que necesitamos. Tenga en cuenta que también utilizamos el Número escriba aquí como entrada:

Luego le damos a ejecutar y vemos cómo queda:

¡Por qué parar ahora! Nosotros podemos usar Bloques en Gradio para hacer nuestras demostraciones aún más complejas, reveladoras y atractivas.

Controlando la interfaz

Los bloques son más o menos exactamente como se describen. ellos son el edificio bloques de aplicaciones Gradio. Hasta ahora sólo hemos utilizado el nivel superior. Interfaz envoltura. En el siguiente ejemplo usaremos bloques que tienen un patrón de codificación ligeramente diferente. Actualicemos el último ejemplo para usar bloques para que podamos entender cómo funcionan:

En lugar de antes, cuando teníamos entradas, funciones e interfaz. Ahora hemos devuelto todo a su forma más básica en Gradio. ¡Ya no configuramos una interfaz y le pedimos que agregue entradas numéricas por nosotros! Ahora proporcionamos cada entrada numérica individual y una salida numérica. Construir así nos da mucho más control de la pantalla.

Con este nuevo control sobre la demo podremos incluso añadir nuevas pestañas. Las pestañas nos permiten controlar los flujos y la experiencia del usuario. Primero podemos explicar un concepto, como cómo se distribuyen nuestras predicciones. Luego, en la siguiente pestaña, tenemos un área completamente nueva para permitir a los usuarios solicitar al modelo sus propias predicciones. También podemos utilizar pestañas para superar dificultades técnicas. La primera pestaña brinda a los usuarios mucha información sobre el rendimiento del modelo. Todo esto se hace a través de funciones que se implementaron anteriormente. Si el código del modelo no se ejecuta ese día, todavía tenemos algo interesante que compartir. ¡No es perfecto, pero es mucho mejor que una pantalla en blanco!

Nota: ¡Esto no significa que podamos ocultar dificultades técnicas detrás de pestañas! Podemos simplemente usar pestañas para darle al público algo con qué continuar si todo lo demás falla. Luego, comparta la demostración cuando resolvamos los problemas técnicos.

¡Aumentar la complejidad muestra lo útil que puede ser Gradio para mostrar todo tipo de información! Hasta ahora nos hemos atenido a un modelo bastante simple. Exploremos ahora cómo usaríamos Gradio para algo un poco más complejo.

Gradio para modelos e imágenes de IA

La próxima aplicación analizará el uso de Gradio para demostrar la IA generativa. Una vez más, usaremos Bloques para construir la interfaz. Esta vez la demostración tendrá dos componentes principales:

1. Una pestaña de introducción que explica las limitaciones y los usos dentro y fuera del alcance del modelo.
2. Una pestaña de inspiración que muestra algunas imágenes generadas anteriormente.
3. Una pestaña interactiva donde los usuarios pueden enviar indicaciones para generar imágenes.

En este blog solo haremos una demostración de un modelo previamente entrenado. Para obtener más información sobre los modelos de difusión estable, incluidos conceptos clave y ajustes, consulte mi blog anterior:

Como se trata de una demostración, comenzaremos desde el componente más difícil. Esto garantiza que tendremos la mayor cantidad de tiempo para realizar el trabajo más difícil. Es probable que la pestaña interactiva sea la más desafiante, así que comenzaremos por ahí. Para que tengamos una idea de lo que buscamos, nuestra página de demostración terminará luciendo así:

Para lograr esto, el código de demostración combinará los dos ejemplos anteriores. Usaremos bloques, funciones, entradas y botones. Los botones nos permiten trabajar de forma similar a como antes donde teníamos entradas, salidas y funciones. Usamos botones como oyentes de eventos. Los oyentes de eventos ayudan a controlar nuestro flujo lógico.

Imaginemos que estamos intentando iniciar nuestra demostración. En tiempo de ejecución (tan pronto como comienza la demostración), no tenemos entradas. Como no tenemos información, el modelo que utiliza la demostración no tiene ningún mensaje. Sin ningún aviso, el modelo no puede generar una imagen. Esto causará un error. Para superar el error utilizamos un oyente de eventos. El botón escucha un evento, en este caso, un clic en el botón. Una vez que «escucha» el evento o se hace clic en él, desencadena una acción. En este caso, la acción enviará un mensaje completo al modelo.

Repasemos un código nuevo que usa botones y compárelo con el anterior. interfaz ejemplos:

El código del botón se parece al código de la interfaz, pero hay algunos cambios conceptuales importantes:

1. El código del botón utiliza bloques. Esto se debe a que mientras usamos el botón de manera similar a interfaz, Todavía necesitamos algo para determinar cómo se ve la demostración.
2. Los widgets de entrada y salida se utilizan como objetos en lugar de cadenas. Si regresa al primer ejemplo, nuestra aportación fue «texto» de tipo cadena pero aquí está inmediato de tipo gr.Texto().
3. Usamos botón.hacer clic() en lugar de Interfaz.lanzamiento(). Esto se debe a que la interfaz era nuestra demostración anterior. Esta vez el evento es el clic del botón.

Así es como termina luciendo la demostración: