Ejecuté un LLM local en una Raspberry Pi de hace 12 años (¡Y funcionó!)
BBetter Stack
컴퓨터/소프트웨어가전제품/카메라
Transcript
00:00:00Esta es la Raspberry Pi de primera generación, que salió allá por 2014.
00:00:05Tiene un procesador de un solo núcleo a 700 MHz y 512 MB de RAM.
00:00:12Para los estándares modernos, esto es básicamente una calculadora.
00:00:16Pero hoy vamos a ver si podemos llevar este hardware de 12 años
00:00:21a su límite absoluto ejecutando un modelo de lenguaje grande localmente.
00:00:26En este video, les mostraré cuál es el modelo diminuto que se puede ejecutar en una Raspberry Pi,
00:00:30veremos cómo rinde y les enseñaré a instalar todas las dependencias necesarias
00:00:35para que puedan probarlo ustedes mismos.
00:00:37Va a ser muy divertido, así que entremos en materia.
00:00:40Sinceramente, no creí que fuera posible encontrar un modelo
00:00:47lo suficientemente ligero para esta arquitectura.
00:00:49Pero tras investigar un poco, encontré un candidato.
00:00:52Les presento al Falcon H1 Tiny.
00:00:54Es un modelo increíblemente compacto con solo 90 millones de parámetros.
00:00:59Fue desarrollado por el Technology Innovation Institute en Abu Dhabi
00:01:03específicamente para explorar los límites inferiores extremos del modelado de lenguaje.
00:01:08Pero, ¿cómo pudieron hacer un modelo tan pequeño?
00:01:10¿Hay algún tipo de ingrediente secreto técnico detrás de esto?
00:01:13Bueno, en realidad no.
00:01:14Básicamente utilizan la misma arquitectura híbrida de Transformer más Mamba
00:01:19que empresas como IBM usaron para sus modelos diminutos Granite 4.
00:01:24Sobre los cuales también hice un video por si quieren echarle un vistazo.
00:01:27Pero aquí está la cuestión.
00:01:28Para lograr meter este modelo en la memoria, tenemos que hablar de cuantización.
00:01:33Ahora, los modelos Falcon están disponibles en versiones de 2, 4 y 8 bits.
00:01:38Podrían tener la tentación de probar la cuantización IQ o de importancia ultra ligera.
00:01:43Pero aquí está el truco.
00:01:45Esos métodos nuevos dependen de una manipulación de bits compleja
00:01:49que requiere instrucciones de CPU modernas para ser eficiente.
00:01:52En nuestro chip ARMv6 antiguo de la Raspberry Pi, esto no funcionará.
00:01:57Así que en su lugar, tenemos que ir con los modelos Q4 de la vieja escuela,
00:02:01que es el estándar de oro para nuestro caso.
00:02:04Utiliza un método de cuantización heredado de tamaño medio
00:02:07que el procesador de la Pi realmente puede manejar sin asfixiarse.
00:02:11Nos da la mejor relación de inteligencia por megabyte manteniendo la lógica intacta.
00:02:17Pero poner este modelo en marcha en esta Raspberry Pi de primera generación no es tarea fácil.
00:02:22Dado que la Pi utiliza la arquitectura ARMv6,
00:02:26carece de las instrucciones neon modernas de las que dependen casi todas las librerías de IA.
00:02:31Pero por suerte, existe llama.cpp, que podemos usar para ejecutar nuestra inferencia.
00:02:36Pero para hacerlo, tenemos que compilar su binario específicamente para nuestra ARMv6.
00:02:42Y si intentaras compilarlo directamente en la Pi,
00:02:45probablemente el compilador tardaría 18 horas en terminar.
00:02:49Eso si no falla antes por errores de falta de memoria.
00:02:53Así que para evitar eso, tenemos que ser un poco creativos.
00:02:56Necesitamos realizar una compilación cruzada de estos binarios en nuestra laptop usando doc_cross,
00:03:02apuntando específicamente al conjunto de instrucciones ARMv6 con la unidad matemática VFP habilitada,
00:03:08y luego copiarlos vía SSH para pasar directamente a la inferencia.
00:03:13Eso es exactamente lo que vamos a hacer ahora.
00:03:15Primero, necesitamos grabar el SO más ligero posible en nuestra Pi usando el Raspberry Pi Imager.
00:03:22Y para una placa con solo 512 megabytes de RAM, cada megabyte cuenta.
00:03:28Así que elegiré Raspberry Pi OS Lite, la versión de 32 bits,
00:03:32ya que no tiene interfaz de escritorio y consume una mínima fracción de memoria
00:03:38comparado con el SO estándar, dejando casi toda nuestra RAM disponible para el modelo.
00:03:44Y otra nota importante: asegúrense de usar los ajustes avanzados
00:03:47para preconfigurar su Wi-Fi y habilitar SSH.
00:03:51Porque en estas placas viejas, es mucho más fácil gestionarlo todo remotamente,
00:03:55así no tienen que pelear con esa terminal local tan lenta.
00:03:58Ahora, una vez arrancada la Pi y con la sesión SSH iniciada, debemos abordar el problema de ARMv6.
00:04:05Si intentáramos compilar llama.cpp aquí mismo,
00:04:08la Pi pasaría literalmente el próximo día y medio solo procesando cabeceras.
00:04:13Así que lo haremos en una laptop normal para acelerar el cálculo y ahorrar tiempo.
00:04:18Clonemos el código fuente de llama.cpp y creemos un directorio de compilación
00:04:23dedicado donde guardaremos la versión que usaremos en nuestra Raspberry Pi.
00:04:28Ahora, aquí hay otro problema.
00:04:29Mi Mac usa ARMv8, que es la versión de 64 bits, no la ARMv6 de 32 bits.
00:04:37Y tienen conjuntos de instrucciones diferentes.
00:04:40Para compilar binarios específicos para la Pi, necesitamos usar doccross,
00:04:45que es un conjunto de herramientas de compilación cruzada que corre en mi Mac,
00:04:48pero genera binarios específicos para la arquitectura antigua de la Pi.
00:04:53A continuación, debemos configurar la compilación.
00:04:55Y aquí es donde debemos ser extremadamente precisos.
00:04:58Tenemos que pasar algunas banderas muy específicas.
00:05:00Primero, desactivamos las librerías compartidas para crear un único binario portátil.
00:05:05Luego, desactivamos neon porque nuestra Pi carece de esas instrucciones matemáticas modernas.
00:05:10Y debemos desactivar OpenMP para mantener el consumo de memoria lo más bajo posible.
00:05:15Básicamente estamos eliminando cualquier lujo moderno
00:05:18para asegurar que el binario sea compatible con nuestra vieja placa Pi.
00:05:22Y ahora, si le damos a compilar, en unos dos minutos deberíamos tener un binario
00:05:26de llama completion optimizado y listo para ser copiado a nuestra placa Pi.
00:05:31Ahora usaré SSH para conectarme directamente a mi Pi a través de la red,
00:05:35crearé un directorio nuevo en la Pi y usaré SCP para copiar nuestro binario personalizado.
00:05:42Y una última cosa que debemos hacer aquí.
00:05:44Vamos a descargar los modelos Falcon de 2, 4 y 8 bits con cuantización antigua,
00:05:50porque los probaremos todos secuencialmente.
00:05:53Y luego los copiaremos a nuestra Pi uno por uno en la carpeta de modelos.
00:05:58Ahora viene la parte divertida.
00:05:59Pasemos a nuestra Pi y ejecutemos nuestra primera prueba de inferencia.
00:06:03Empezaremos con la compresión más agresiva, el modelo cuantizado de 2 bits.
00:06:07Y aquí necesitamos ejecutar este comando largo.
00:06:10Básicamente lo que hago es darle un prompt sencillo:
00:06:13“Hola, ¿cómo estás?” y limitar la salida a 32 tokens.
00:06:18Y especificamos exactamente un hilo porque, bueno, es todo lo que tenemos.
00:06:22También mantenemos el tamaño del contexto minúsculo en 128 tokens para ahorrar cada byte posible de RAM.
00:06:29Pero el flag más importante aquí es no M map.
00:06:32Normalmente llama.cpp usa mapeo de memoria para cargar modelos, lo cual es genial para GPUs de gama alta,
00:06:38pero es una pesadilla para nuestra placa Pi.
00:06:41En un sistema de 32 bits con solo 512 megabytes de RAM,
00:06:45M map puede fallar si no encuentra un bloque contiguo de espacio de direccionamiento.
00:06:50Al desactivarlo, forzamos al modelo a cargarse directamente en el heap,
00:06:55dándonos un control mucho más estable sobre nuestra memoria limitada.
00:06:58Dicho esto, ejecutemos el comando.
00:07:00Y ahí están, nuestros primeros tokens.
00:07:03Como podemos ver, la versión de 2 bits está sufriendo mucho.
00:07:08Primero, vemos que procesa un solo token aproximadamente cada tres segundos,
00:07:14lo cual es de esperar en una placa Raspberry Pi tan vieja.
00:07:18Pero lo más importante es que la respuesta no tiene ningún sentido.
00:07:21En un modelo de 90 millones de parámetros, los pesos están tan comprimidos
00:07:25que la lógica lingüística básicamente ha colapsado.
00:07:28Apenas es coherente, pero técnicamente está funcionando.
00:07:32Ahora veamos qué pasa si lo cambiamos por el modelo de 4 bits.
00:07:35Miren eso, ahora recibimos un saludo coherente.
00:07:40Así que es un éxito.
00:07:42Ya tenemos un modelo de IA real ejecutándose localmente en la Pi
00:07:47y respondiendo con lógica a nuestros prompts.
00:07:49¡Genial!
00:07:50Ahora vayamos un poco más allá.
00:07:53Veamos si la Pi puede manejar un modelo de 8 bits.
00:07:56Y esta vez voy a preguntarle algo más inteligente,
00:07:59como ¿cuál es la capital de Albania?
00:08:02Y bueno, eso está mal porque la capital de Albania es Tirana
00:08:08y eso claramente no es correcto.
00:08:10Pero si le pregunto cuál es la capital de Bélgica, responde correctamente.
00:08:15Esto nos muestra algo muy interesante.
00:08:17Parece que la reducción a 90 millones de parámetros tiene su costo.
00:08:22Puede tener conocimientos precisos sobre países más grandes y populares,
00:08:26pero carece de información sobre países y temas menos conocidos.
00:08:31Esa es simplemente la naturaleza del conocimiento.
00:08:33Hay un límite de información que cabe en esos 90 millones de parámetros.
00:08:38Pero aun así, el resultado es súper genial.
00:08:41Es una confirmación de que sí, existen modelos de IA lo bastante pequeños
00:08:46y ligeros como para correr en una Raspberry Pi de hace 12 años.
00:08:50¿Es rápido?
00:08:51Para nada.
00:08:52¿Es preciso?
00:08:53Puede que no.
00:08:54¿Deberían usarlo en producción?
00:08:55Probablemente no.
00:08:57A menos que quieran construir un robot muy, pero que muy lento.
00:09:02Pero lo más importante es que ahora sabemos que es teóricamente posible.
00:09:06Básicamente, eso es todo lo que quería demostrar en este video.
00:09:09Y para ser sincero, este experimento fue muy divertido.
00:09:13Ahí lo tienen, amigos.
00:09:14Esos son los modelos Falcon H1 Tiny.
00:09:17Probablemente los modelos de IA más pequeños que existen actualmente.
00:09:20Y ahora sabemos que, de hecho, son lo bastante pequeños para correr en una Raspberry Pi de primera generación,
00:09:25lo cual es genial.
00:09:27No puedo dejar de celebrar lo asombroso que es esto.
00:09:30Aunque la implementación práctica sea inútil, sigue siendo genial.
00:09:35Díganme, amigos, si tienen alguna ocurrencia graciosa,
00:09:37comentarios u observaciones sobre lo que acaban de ver.
00:09:40Pónganlos en la sección de comentarios aquí abajo.
00:09:42Y si les gustan este tipo de análisis técnicos,
00:09:45háganmelo saber dándole al botón de like debajo del video.
00:09:49Y tampoco olviden suscribirse a nuestro canal.
00:09:51Soy Andris de Better Stack, y nos vemos en los próximos videos.
Community Posts
No posts yet. Be the first to write about this video!
Write about this video