Ejecutando un LLM de 2.78T parámetros en una sola CPU con 8GB de RAM
Descubre cómo un modelo Kimi K3 de 2.78 billones de parámetros se ejecuta en una sola CPU con solo 8.24 GB de RAM, usando C99 portátil y un inteligente flujo de memoria.
El mundo de la IA está obsesionado con la escala, pero ¿qué pasaría si pudieras ejecutar un modelo de 2.78 billones de parámetros en una máquina que ya posees? Eso es exactamente lo que logra el proyecto kimi-k3-in-c: un modelo Kimi K3 de 2.78T parámetros ejecutando inferencia en una sola CPU, usando solo 8.24 GB de RAM, sin GPU, sin BLAS y sin framework. Todo el motor es un binario C99 de 176 KB que transmite el modelo desde el disco, haciendo posible ejecutar IA de última generación en hardware que no es precisamente de última generación.
Esto no es un juguete ni una aproximación fuertemente cuantizada. La salida es byte-idéntica ya sea que lo ejecutes en una laptop con 8 GB de RAM o en una estación de trabajo con 224 GB. La única diferencia es la velocidad: 32.69 segundos por token en el extremo inferior, 19.21 segundos por token en el extremo superior. El proyecto logra esto mediante una combinación de ingeniería inteligente, un profundo entendimiento de la arquitectura del modelo y la disposición a desafiar suposiciones convencionales sobre lo que es necesario para la inferencia de LLM.
El Problema: Un Modelo Que No Cabe
Kimi K3 es un modelo de mezcla de expertos (MoE) con 2.78 billones de parámetros, distribuido como un checkpoint de 1.56 TB. Ninguna máquina de consumo puede tener eso en memoria. El enfoque ingenuo—cargar todo en RAM—requeriría 5.56 TB en precisión bfloat16. Eso no es solo poco práctico; es imposible para cualquiera que no tenga un centro de datos.
La idea clave es que los modelos MoE no necesitan todos sus parámetros activos a la vez. Para cualquier token dado, solo 16 de los 896 expertos por capa se activan. Eso es alrededor de 104 mil millones de parámetros activos de 2.78 billones—solo el 3.7%. El resto puede permanecer en el disco, siempre que sean accesibles cuando se necesiten.
Las Cuatro Reducciones
El proyecto logra su huella de memoria mediante cuatro reducciones clave:
- Expertos MXFP4: Los expertos enrutados se envían en un formato de punto flotante de 4 bits, ocupando solo 0.53125 bytes por peso en lugar de 2 bytes para bfloat16. Esto solo reduce los pesos de los expertos de 5.45 TB a 1.447 TB.
- Atención KDA: La Atención Delta de Kimi usa un estado recurrente de tamaño fijo que no crece con la longitud del contexto. Esto significa que 69 de las 93 capas tienen una huella de memoria constante sin importar cuánto texto les des.
- Atención MLA: La Atención Latente Multi-cabeza almacena en caché un solo latente de 576 dimensiones por posición en lugar de 96 cabezas de clave/valor separadas, reduciendo la caché KV en 53 veces.
- Transmisión del tronco: Las capas densas (el "tronco") se transmiten desde el disco capa por capa, usando un prefijo fijo y un solo búfer circular. Esto convierte el requisito de memoria de un piso fijo a un dial que puedes ajustar.
Cómo Funciona: La Arquitectura
El motor está escrito en C99 portátil, sin dependencias externas más allá de libm y OpenMP. El código es notablemente pequeño: seis archivos C compilados en un solo binario de 176 KB. Esto es posible porque el proyecto evita cualquier sobrecarga de framework e implementa cada kernel desde cero.
Leyendo el Checkpoint
El checkpoint de 1.56 TB consiste en 96 archivos safetensors. El motor lee los encabezados JSON para construir un índice de todos los 497,220 tensores, y luego lee solo los bytes que necesita bajo demanda. Esto se hace con lecturas O_DIRECT, omitiendo por completo la caché de páginas, lo que el proyecto encontró más rápido que las lecturas con búfer en su hardware de prueba.
La Caché de Expertos
Los expertos enrutados se cargan en una caché LRU con un tamaño configurable. Sin embargo, el proyecto descubrió un resultado sorprendente: la caché de expertos es casi inútil en tamaños pequeños. Debido al entrenamiento de Equilibrio de Cuantiles del modelo, el uso de expertos se aplana en el grupo, por lo que no hay un subconjunto caliente que la caché pueda explotar. La caché solo comienza a ayudar por encima de unos 36 GB de arena.
La Transmisión del Tronco
El tronco denso (108.81 GB) se lee capa por capa. El motor fija tantas capas como quepan en el presupuesto, y transmite el resto a través de un solo búfer circular. Debido a que el motor recorre las capas en un orden fijo, un prefijo fijo logra una tasa de aciertos determinista de N/93, que es mucho mejor de lo que una caché LRU lograría en un escaneo cíclico.
Validación: Probando que es Correcto
El proyecto no solo afirma que funciona; lo prueba mediante una rigurosa escalera de validación:
- Pruebas sin pesos: Un modelo oráculo de 13 capas con el mismo grafo de tensores que el real, verificado contra una referencia de PyTorch. Los tres caminos de ejecución (teacher forcing, decodificación voraz, decodificación incremental) producen IDs de token idénticos.
- Conformidad de capas: Las 93 capas del modelo completo se verifican contra una referencia de PyTorch, con un error en el peor caso de 0.00x el presupuesto de redondeo.
- Paridad de logits: Los logits del motor C coinciden con la referencia de torch elemento a elemento sobre la salida completa de vocabulario de 163,840, con una diferencia máxima de 7.87e-6.
- Escalera de memoria: Doce presupuestos de memoria diferentes, desde 8 GB hasta 224 GB, todos producen IDs de token byte-idénticos.
Rendimiento: Qué Esperar
En una sola CPU (AMD EPYC 7763, 124 núcleos), el motor logra:
- 8 GB de RAM: 32.69 s/token
- 32 GB de RAM: 31.44 s/token
- 64 GB de RAM: 28.60 s/token
- 128 GB de RAM: 29.40 s/token (nota el ruido)
- 224 GB de RAM: 19.21 s/token
El rendimiento está fuertemente limitado por E/S. Entre el 41% y el 61% del tiempo de pared se gasta esperando en el disco. Esto significa que el dispositivo de almacenamiento importa más que la CPU. Una unidad NVMe rápida es esencial para un buen rendimiento.
Comenzando
Para ejecutar esto tú mismo, necesitarás:
- Linux x86-64 con AVX2 y FMA
- Al menos 8 GB de RAM
- ~1.7 TB de espacio libre en disco
- GCC ≥ 9 o Clang ≥ 10
- Python 3.9+ (para herramientas de descarga y empaquetado)
Clona el repositorio, compila con make -j, y ejecuta make test para verificar que el motor funciona antes de descargar el checkpoint de 1.56 TB. Luego descarga el modelo, empaqueta el tronco, y ejecuta:
./bin/k3 ~/k3model --trunk ~/k3trunk --preset laptop \
--tok ~/k3model --prompt "La capital de Francia es" --gen 8 --incremental
Conclusión
El proyecto kimi-k3-in-c es una clase magistral en ingeniería de sistemas. Demuestra que con el enfoque correcto, incluso los modelos de IA más grandes pueden hacerse accesibles para hardware ordinario. Las conclusiones clave:
- La memoria es un dial, no un piso: Al transmitir el tronco, puedes intercambiar velocidad por uso de memoria.
- Entiende tu modelo: Las elecciones de arquitectura (KDA, MLA, MXFP4) se explotan al máximo.
- Mide todo: La rigurosa metodología de validación y medición del proyecto asegura que cada afirmación esté respaldada por datos.
Esto no es solo una curiosidad técnica; es un plano para hacer la IA más accesible. Si alguna vez has querido ejecutar un modelo de billones de parámetros en tu propia máquina, este proyecto muestra que es posible—y es de código abierto.