Soup: afinar un modelo de 8.000 millones de parámetros en un portátil con 4 GB de gráfica

La cifra que ha puesto a este repositorio en tendencias es esta: un modelo de 8.000 millones de parámetros entrenándose en una gráfica de portátil de 4 GB. Concretamente, una RTX 3050 de portátil, con Llama 3.1 de 8B, a 119,6 tokens por segundo y con un pico de 3,32 GB de memoria.

Si has intentado alguna vez afinar un modelo, sabes por qué eso llama la atención. La regla no escrita decía que para tocar un 8B necesitabas una gráfica de 16 o 24 GB, o alquilar una por horas. Soup dice que no, y explica cómo.

Ayer hablé aquí de Unsloth, que ejecuta y entrena modelos desde una aplicación de escritorio. Soup va a lo mismo por el camino contrario: nada de interfaz, una orden en el terminal y un archivo de texto.

Qué es exactamente

Soup es una herramienta de línea de órdenes que hace una sola cosa: coger un modelo abierto, entrenarlo un poco más con tus ejemplos y devolverte el resultado. Todo lo que normalmente hay que decidir a mano —el tamaño de lote, la cuantización, qué gráfica usar— lo decide él.

Su promesa está en el propio repositorio: afinar sin SSH y sin infierno de configuración. Y no es una exageración de marketing: en equipos con experiencia, montar la infraestructura se come entre un 30 % y un 50 % del tiempo del entrenamiento. Eso es lo que se ataca aquí.

Toda la configuración cabe en un archivo así:

base: meta-llama/Llama-3.1-8B-Instruct
task: sft
data:
  train: ./data/train.jsonl
  format: alpaca
  val_split: 0.1
training:
  epochs: 3
  lr: 2e-5
  batch_size: auto
  lora:
    r: 64
    alpha: 16
  quantization: 4bit
output: ./output

Lo importante de ese archivo no es lo que pone, es lo que no pone. No hay rutas de servidor, ni claves, ni scripts de arranque.

Y antes de seguir, la aclaración de siempre, porque es el error más caro de todo este terreno: afinar no es enseñarle datos nuevos al modelo. Afinar cambia cómo se comporta —el formato, el tono, el criterio—, no le mete hechos en la cabeza de forma fiable. Si lo que quieres es que conozca tus documentos, lo que necesitas es una búsqueda sobre ellos, y eso está en qué es RAG. La base de lo otro, en qué es el fine-tuning.

El streaming de capas, que es el truco de la casa

Aquí está lo que diferencia a Soup del resto y merece explicarse despacio, porque es sencillo y elegante.

Cuando entrenas un modelo, normalmente todo el modelo tiene que estar cargado en la memoria de la gráfica. Un 8B en 4 bits ocupa unos 5 GB solo de estar ahí quieto, y a eso hay que sumarle lo que consume el propio entrenamiento. Con 4 GB de gráfica, no entras.

Lo que hace el streaming de capas es dejar el modelo congelado en la memoria normal del ordenador —la RAM, que es barata y sobra— e ir pasándole a la gráfica una capa cada vez. La gráfica solo tiene delante el trozo que está trabajando en ese instante. Cuando termina, entra el siguiente.

Es la diferencia entre necesitar una mesa donde quepa el mueble entero y necesitar una mesa donde quepa la pieza que estás lijando.

El detalle que hace creíble el asunto: el equipo dice haber verificado que el resultado es bit a bit idéntico al de un entrenamiento normal. No es una aproximación que degrada la calidad a cambio de memoria, es la misma cuenta hecha por partes.

Ahora la letra pequeña, que también está en el repositorio: el streaming de capas está en beta y hay que activarlo a mano con stream_layers: true. No viene puesto por defecto.

Qué te pide de verdad

Sin streaming de capas, las necesidades son las normales del oficio:

Memoria de la gráfica	Modelo máximo (QLoRA 4 bits)
8 GB	~7B (Llama 3.1 8B, Mistral 7B)
16 GB	~14B (Phi-4, Qwen2.5 14B)
24 GB	~34B (CodeLlama 34B)
48 GB	~70B (Llama 3.3 70B)

Y el resto de requisitos, sin adornos:

• Python 3.10 a 3.12. Con 3.13 no funciona todavía, y esto pilla a mucha gente con instalaciones recientes.
• Gráfica con CUDA para lo bueno. Hay soporte para Apple Silicon y para CPU, pero en CPU es tan lento que sirve para comprobar que arranca, no para trabajar.
• Funciona con cualquier modelo de texto de Hugging Face que cargue con AutoModelForCausalLM, así que la lista de modelos compatibles es enorme.

Cómo probarlo con Claude Code o Codex

La instalación es de tres órdenes:

pip install "soup-cli[train]"
soup init --template chat
soup train

Mi recomendación es no escribir tú el conjunto de datos a mano. Ese es exactamente el trabajo aburrido que un agente hace bien. Con Claude Code o Codex abiertos en la carpeta del proyecto:

Lee https://github.com/MakazhanAlpamys/Soup y prepárame un soup.yaml para
afinar un modelo de 7B con los ejemplos que tengo en ./ejemplos.
Convierte primero esos ejemplos al formato alpaca en ./data/train.jsonl
y dime cuántos han salido y cuáles has descartado por estar incompletos.

Ese "cuáles has descartado" no es un adorno: la calidad de un afinado depende casi por completo de la calidad de los ejemplos, y ahí es donde se pierde la gente.

El resto de órdenes útiles del ciclo completo:

soup chat --model ./output                    # probar el modelo afinado
soup serve --model ./output                   # levantarlo como API compatible con OpenAI
soup merge --adapter ./output                 # fundir el adaptador con el modelo base
soup export --model ./output --format gguf    # exportarlo para usarlo en otro programa

Ese soup serve es más importante de lo que parece: te deja enchufar el modelo afinado a cualquier herramienta que hable el formato de OpenAI, que a día de hoy son casi todas.

Cuándo no te compensa

• Si no tienes al menos 200 o 300 ejemplos buenos y consistentes. Con veinte no se afina nada, se ruidea.
• Si lo que necesitas es que conozca tus documentos. Otra vez: eso es búsqueda, no entrenamiento.
• Si vas con Python 3.13 y no quieres tocar tu entorno. Todavía no hay soporte.
• Si esperabas afinar un modelo grande en el portátil. El streaming de capas ensancha el cuello de botella, no lo elimina, y está en beta.
• Si buscas interfaz gráfica. Esto es terminal. Para lo otro está Unsloth.

Para quién sí: para quien tiene un formato propio y repetido —informes, fichas de paciente, respuestas tipo, clasificaciones de facturas— y quiere un modelo pequeño que lo replique sin explicárselo cada vez, con los datos sin salir del equipo. Ahí el ahorro es real y el modelo afinado gana a uno grande genérico.

Preguntas frecuentes

¿De verdad puedo entrenar un modelo de 8B con 4 GB de gráfica?

Según las mediciones del propio proyecto, sí, activando el streaming de capas: 3,32 GB de pico en una RTX 3050 de portátil. Es una función en beta y hay que activarla a mano, así que trátalo como algo prometedor y no como algo probado por todo el mundo.

¿Se pierde calidad al entrenar por capas?

El equipo dice haber comprobado que el resultado es idéntico bit a bit a un entrenamiento normal. Lo que sí pierdes es velocidad: mover capas entre la memoria del ordenador y la gráfica cuesta tiempo.

¿Qué diferencia hay entre esto y usar RAG?

Afinar cambia el comportamiento del modelo; RAG le da acceso a documentos. Si quieres que escriba como tu despacho, afina. Si quieres que sepa qué pone en tu manual interno, monta una búsqueda.

¿Mis datos salen del ordenador?

No, si entrenas en local. El modelo base sí se descarga de internet, pero tus ejemplos se quedan donde estén.

¿Es gratis?

El proyecto tiene licencia Apache 2.0 y no cuesta nada. Lo que pagas es el hardware y las horas de gráfica.