Transcript
00:00:00Este es un modelo de lenguaje de 28,9 millones de parámetros generando texto en este instante, palabra por palabra,
00:00:08en un chip que cuesta unos ocho dólares. Sin Wi-Fi, sin enviar nada a ningún servidor,
00:00:14todo ocurre dentro de un ESP32S3, un microcontrolador con menos RAM que una computadora
00:00:22de los 90. Es una locura. ¿Cómo es esto posible? ¿Cuál es el truco y cómo podemos
00:00:29construir algo similar? Bueno, son excelentes preguntas que abordaremos en el video
00:00:34de hoy. Va a ser muy divertido, así que vamos a ello. El ESP32S3 es un chip que te ofrece
00:00:46512 kilobytes de SRAM, que es la memoria rápida con la que puede procesar. Normalmente,
00:00:54si intentaras ejecutar un LLM dentro de él, todo el modelo tendría que caber justo ahí.
00:01:00El último modelo de lenguaje ejecutado en un chip así alcanzó un máximo de 260 000 parámetros. Así que este
00:01:08tiene unas 110 veces más, y quien lo logró fue el desarrollador ucraniano Slava S.
00:01:16Entonces, ¿cuál es el truco de magia? ¿Cómo lo hicieron? ¿Cómo metieron un modelo de 28,9 millones de parámetros en un chip de 8 dólares?
00:01:24Bueno, la solución se basa en una idea que Google usó en Gemma: los embeddings por capa. La mayoría de los
00:01:31parámetros de un modelo de lenguaje no calculan nada. Están en una tabla de embeddings que solo se lee.
00:01:37Si la mayoría de tus parámetros solo se consultan, no necesitan memoria rápida. Así que puedes
00:01:44dejar esa tabla en una memoria flash lenta y barata, y solo extraer las filas que el token actual necesita. Y la
00:01:52pequeña parte que realmente calcula y piensa el siguiente token, la cabeza de atención y feed-forward, se queda en la SRAM.
00:01:59Bien, esa es la parte del procesamiento. Pero la duda sigue en pie: ¿cómo metemos un modelo tan grande en un chip tan diminuto?
00:02:05La tabla de 25 millones de filas vive en la memoria flash. Y ese es el bloque más grande de los
00:02:1228,9 millones de parámetros del modelo. La memoria flash es barata y enorme en este chip en particular: tiene 16 megabytes.
00:02:20Así que, en lugar de intentar meter esa tabla en los mismos 512 kilobytes de SRAM,
00:02:26se queda almacenada en la flash. Solo extraemos unas seis filas, una para cada una de las seis capas del modelo.
00:02:33Eso son unos 450 bytes en total. Ahora, antes de entusiasmarnos demasiado, debo aclarar que
00:02:40este es un modelo muy simple y básico. No será el típico LLM estilo GPT. No te generará código
00:02:47ni responderá preguntas sobre temas complejos. Porque si intentaras entrenar un modelo normal de este tamaño
00:02:53en un conjunto de datos común, 28 millones de parámetros solo darían texto incomprensible. Pero este modelo está entrenado en
00:03:01Tiny Stories, un conjunto de datos de investigadores de Microsoft, redactado de forma lo bastante simple como para que
00:03:08incluso un modelo diminuto, de pocos millones de parámetros, aprenda a escribir historias coherentes. Y ejecutarlo en C puro,
00:03:15en un chip sin sistema operativo ni intérprete de Python, es una idea inspirada en el famoso proyecto
00:03:22Llama2.c de Andrei Karpathy, que demostró que podías entrenar un modelo de lenguaje pequeño y hacer
00:03:28inferencia usando tan solo unas pocas cientos de líneas de C portable. Ese es el plano fundamental en el que
00:03:35se basa todo este proyecto. Sin Karpathy, esto probablemente ni siquiera sería posible. Así que así es como funciona en
00:03:40resumen. Ahora intentemos construirlo nosotros mismos y ejecutarlo en el chip para ver cómo se comporta.
00:03:47Para construir esto nosotros mismos, lo primero que necesitas es el hardware adecuado, específicamente un ESP32S3
00:03:54con 16 megabytes de memoria flash y 8 megabytes de PSRAM. Esa es la variante N16R8. Y esto es de verdad
00:04:03muy importante, porque ¿recuerdas cuando hablamos de la tabla de 25 millones de filas en la memoria flash? Bueno,
00:04:10una vez entrenada y exportada, ocupa unos 15 megabytes. Las placas con 4 u 8 megabytes de flash
00:04:17simplemente no podrán almacenarla. Así que si estás buscando una placa para seguir el tutorial, esa es la especificación
00:04:22clave que debes verificar primero. Cuando revisé las instrucciones originales del proyecto, la configuración estaba dispersa
00:04:28en varios archivos y daba por sentados bastantes conocimientos previos. Así que,
00:04:34en lugar de explicarlo tal como está escrito, preparé un único script automatizado que lo hace
00:04:40todo: verifica la placa, instala el toolchain, prepara los datos, entrena, exporta, verifica,
00:04:47compila y lo flashea todo de una sola vez. Así que ejecutemos ese script. Un rápido aviso:
00:04:55si estás siguiendo el proceso, todo el script tarda unos 25 minutos en terminar. Probablemente sea el mismo
00:05:00tiempo que te tomaría hacerlo paso a paso, debido a la gran cantidad de comandos individuales
00:05:05que tendrías que supervisar. La mayor parte del tiempo se va en entrenar el modelo Tiny Stories,
00:05:11lo cual toma unos 13 minutos en mi MacBook. Cuando termina el entrenamiento, verás que los LED del panel
00:05:18empiezan a parpadear. Esa es la señal de que estamos a punto de cargar el modelo. Y una vez cargado,
00:05:24aquí podemos ver el primer ejemplo básico de una historia sobre una niña. Y efectivamente,
00:05:29obtenemos unos nueve tokens por segundo. Pero notarás que en cierto punto
00:05:33reiniciará la historia de nuevo. El modelo entra en una especie de bucle. Y si quieres
00:05:39darle un prompt personalizado, también incluyo un script de ejemplo que puedes usar para probar tus propios
00:05:44prompts. Para este ejemplo, empecemos una historia sobre un robot. Otra cosa a considerar es que si
00:05:50cambias el prompt, tendrás que volver a flashear el ESP32. Esa es una limitación de este método:
00:05:56solo puede reproducir un prompt preflasheado a la vez. Como pueden ver,
00:06:02obtenemos una mención del robot en la historia, y la historia sí es algo diferente esta vez.
00:06:08Pero miren lo que pasa al final del párrafo: volvemos a la historia de la niña.
00:06:13No tengo idea de por qué sucede esto, pero está claro que el modelo tiende a desviarse hacia esa
00:06:19historia específica de la niña. Hagamos otro ejemplo. Esta vez usemos la
00:06:24famosa frase que aparece al principio de cada película de Star Wars, a ver a dónde nos
00:06:30lleva. Este caso es interesante: vemos que el modelo vuelve a derivar inmediatamente hacia
00:06:36la narrativa de la niña. Asumo que, para un modelo de este tamaño, ni siquiera entiende
00:06:42lo que es una galaxia. Probablemente por eso ignora nuestro prompt específico en este caso. Y,
00:06:47una vez más, vemos que el siguiente párrafo comienza la misma historia. Así que, aunque este experimento es
00:06:53impresionante y ver un modelo generar nueve tokens por segundo en un microchip tan pequeño es asombroso,
00:06:59sigue siendo una prueba de concepto bastante limitada. Como vimos, no importa lo que le pidas al modelo, siempre
00:07:06volverá a contar cuentos, porque para eso fue entrenado. Pero si este experimento
00:07:11te pareció interesante, hice otro video en esta misma línea donde probé si una Raspberry Pi de primera
00:07:18generación podía ejecutar un LLM real localmente. Échale un vistazo a ese video si te interesa. Y ahí lo
00:07:24tienen, amigos. Así es como se ejecuta un modelo de lenguaje de 28,9 millones de parámetros en un chip ESP32. Lo probamos
00:07:32y funciona. Mis reconocimientos a Slava por crear este proyecto. ¿Ustedes qué opinan de este experimento?
00:07:38¿Ven algún caso de uso en el mundo real donde una implementación así sea útil? Déjenos sus
00:07:43comentarios abajo. Y amigos, si les gusta este tipo de análisis técnico,
00:07:48déjenmelo saber dándole al botón de me gusta debajo del video. Tampoco olviden
00:07:53suscribirse a nuestro canal. Ha sido Andres de Betterstack y los veré en los próximos videos.
Community Posts
No posts yet. Be the first to write about this video!
Write about this video