Equipos para IA · Entrenamiento

Entrenamiento y fine-tuning: por qué 8B de parámetros piden 128 GB (y cómo bajarlos a 6)

Cuánta memoria pide entrenar un LLM y de dónde sale cada byte, qué recortan LoRA y QLoRA, cuánto tarda con la regla 6·N·D, y cuándo el multi-GPU o el cloud compensan.

Inferir un modelo es leer sus pesos. Entrenarlo es leerlos, calcular cuánto cambiarlos y guardar, para cada uno, el historial que necesita el optimizador. Eso multiplica la memoria por ocho respecto a la inferencia: un modelo de 8 000 millones de parámetros que cabe en una tarjeta de 16 GB se convierte en un problema de 128 GB. LoRA y QLoRA esquivan esa multiplicación; el multi-GPU la reparte.

De dónde salen los 16 bytes por parámetro

En precisión mixta el modelo vive por triplicado: una copia de los pesos en BF16 con la que se calcula (2 bytes por parámetro), un gradiente por peso, también en BF16 (2 bytes), y una copia maestra en FP32 sobre la que el optimizador aplica las actualizaciones (4 bytes). La maestra no es un capricho: una actualización pequeña sumada a un peso BF16, con 7 bits de mantisa, se redondea a cero y el modelo deja de aprender (precisión numérica).

A eso se suma el optimizador. Adam guarda dos estadísticas por parámetro, la media móvil del gradiente (momento) y la de su cuadrado (varianza), ambas en FP32: 8 bytes más. El paper de ZeRO lo resume en la fórmula que se cita en todas partes: 2Ψ + 2Ψ + 12Ψ = 16Ψ bytes, con Ψ el número de parámetros y 12 el multiplicador de los estados (maestra + momento + varianza).

Memoria de estados en full fine-tuning (precisión mixta + Adam)

GB ≈ parámetros × (2 pesos + 2 gradientes + 4 maestra + 8 Adam) ÷ 10⁹

Llama 3.1 8B: 8,03 × 10⁹ × 16 B = 128,5 GB

Llama 3.1 8B tiene 8,03mil millones de parámetros. Solo los estados ocupan 128,5GB, sin activaciones ni contexto CUDA: no cabe en ninguna GPU de consumo ni en una RTX PRO 6000 de 96 GB; hace falta una H200 de 141 GB o repartir. Con Llama 3.1 70B (70,55mil millones) son 1 129GB: ocho H200 o dieciséis H100.

Estos 16 bytes son el suelo, no el techo. Falta lo que ocupa cada secuencia mientras se procesa.

Las activaciones: el término que depende de ti

Para calcular el gradiente de una capa hace falta recordar lo que produjo en la pasada hacia delante. Esas activaciones se guardan para todas las capas hasta que la pasada hacia atrás las consume, y su tamaño escala con el lote, la longitud de secuencia y la anchura del modelo.

Para un transformer tipo Llama con atención fusionada (FlashAttention), la aproximación habitual son 34 bytes por token, unidad de anchura y capa, en BF16. En Llama 3.1 8B (anchura 4 096, 32 capas), una secuencia de 4 096 tokens ocupa 34 × 4 096 × 4 096 × 32 ≈ 18,3GB; una de 16 384, 73 GB: más que pesos, gradientes y Adam juntos.

34 B × 4 096 tokens × 4 096 de anchura × 32 capas ≈ 18,3 GB de activaciones

La solución clásica es el gradient checkpointing: guardar solo la entrada de cada bloque y recalcular el resto en la pasada hacia atrás. Chen et al. lo formularon en 2016 como memoria O(√n) para n capas al precio de una pasada hacia delante extra, y midieron un 30 % de tiempo adicional. En fine-tuning de LLM se activa casi siempre: un tercio más de tiempo por dividir las activaciones por diez o más.

  • Sin checkpointing
  • Con checkpointing
0204060801k10k100kLongitud de secuencia (tokens) (log)Activaciones (GB)Sin checkpointingCon checkpointing
Memoria de activaciones de Llama 3.1 8B en BF16 con lote de 1 secuencia, según longitud de secuencia, con y sin gradient checkpointing (estimación con la aproximación de 34 bytes por token, anchura y capa; fuente: Korthikanti et al. 2022, Chen et al. 2016).

Con checkpointing, la secuencia de 4 096 tokens baja a unos 1,6 GB: la entrada de cada bloque (2 bytes × 4 096 × 4 096 × 32 = 1 GB) más las activaciones de un solo bloque mientras se recalcula. Es el ajuste que más cambia la respuesta a “¿me cabe?”, y por eso es un control del estimador de memoria de entrenamiento.

LoRA: congelar el modelo y entrenar un parche

LoRA (Hu et al., 2021) no toca los pesos originales. A cada matriz W que quieras adaptar se le suma un producto de dos matrices pequeñas, B × A, de rango r (entre 8 y 64, típicamente), y solo se entrenan A y B. Si W es de 4 096 × 4 096 tiene 16,8 millones de valores; A y B con r = 16 suman 16 × (4 096 + 4 096) = 131 072, un 0,8 %. El base queda congelado en BF16: 2 bytes por parámetro, sin gradientes ni estados de Adam.

Parámetros entrenables de un adaptador LoRA

entrenables = r × (entrada + salida) por matriz adaptada

Llama 3.1 8B, r = 16 en las 7 matrices lineales de las 32 capas: 41,9 millones (0,5 % del modelo)

Por capa: q y o (4 096 × 4 096) aportan 131 072 cada una; k y v (4 096 × 1 024), 81 920; las tres del MLP (4 096 × 14 336), 294 912. Suman 1 310 720 por capa, 41,9 millones en 32 capas. A 16 bytes por parámetro (pesos, gradientes, maestra y Adam) ocupan 0,67GB. El 8B pasa de 128,5 GB a 16,1 GB de base congelada más 0,7 GB de adaptador más activaciones.

Dos matices de la documentación de PEFT. Los adaptadores se fusionan con el base tras entrenar (merge_and_unload), así que en inferencia no añaden latencia. Y LoRA ahorra memoria, no cálculo: la pasada hacia delante y el gradiente respecto a las activaciones se siguen calculando sobre el modelo entero; solo se ahorra el gradiente respecto a los pesos, más o menos un tercio del trabajo.

QLoRA: el modelo base en 4 bits

QLoRA (Dettmers et al., 2023) va un paso más allá: el base congelado se cuantiza a 4 bits (NF4, pensado para pesos con distribución normal), se cuantizan las propias constantes de cuantización (“doble cuantización”) y el optimizador se pagina a RAM en los picos. Los adaptadores siguen en BF16 y se calcula descuantizando al vuelo. La cifra del paper: un 65B afinado en una sola GPU de 48 GB con el rendimiento del fine-tuning en 16 bits.

Con 4 bits por peso más las constantes de escala (unos 0,13 bits por parámetro con doble cuantización), el base cuesta algo más de 0,5 bytes por parámetro. Embedding y capa de salida se quedan en 16 bits: en Llama 3.1 son 1 050 millones de parámetros (vocabulario de 128 256), 2,1 GB. El 8B queda en unos 5,7 GB de pesos; el 70B, en unos 40 GB. Con adaptador, activaciones con checkpointing y margen CUDA: el 8B en una tarjeta de 12 GB, el 70B en una de 48 GB.

Llama 3.1 8B: memoria de estados por método

050100150200Full fine-tuning (BF16 + Adam FP32)128,5 GBLoRA r = 16 (base BF16 congelada)16,8 GBQLoRA r = 16 (base NF4)6,4 GBGB

Añade 1-4 GB de activaciones con checkpointing y ~1 GB de contexto CUDA.

Memoria de estados (pesos, gradientes, maestra y optimizador, sin activaciones) para afinar Llama 3.1 8B según el método (cálculo con 16 B/parámetro para full fine-tuning; 2 B/parámetro base + adaptador r = 16 para LoRA; NF4 con doble cuantización y embeddings en BF16 para QLoRA. Fuentes: ZeRO, QLoRA, ficha del modelo).
70B full fine-tuning1 129GB16 B/parámetro · 8× H200 o 16× H100
70B LoRA142GBbase BF16 · 2× 80 GB o 1× RTX PRO 6000 justo
70B QLoRA40GBbase NF4 · una GPU de 48 GB

Cuánto cálculo hace falta: la regla 6·N·D

La memoria dice si cabe; el cálculo, cuánto tarda. La estimación estándar es de Kaplan et al. (2020): entrenar cuesta unos 6 FLOP por parámetro y token, 2 en la pasada hacia delante y 4 en la de atrás. Multiplica por los tokens del dataset y tienes el trabajo; divide entre lo que la GPU sostiene de verdad y tienes el tiempo. Ese “de verdad” es la MFU (utilización de FLOPS del modelo): 35-60 % del pico dense en entrenamientos bien optimizados; menos en un LoRA sobre una tarjeta de consumo.

Tiempo de entrenamiento

segundos = 6 × N × D ÷ (pico dense × MFU)

8B sobre 100 millones de tokens en una RTX 5090: 4,8 × 10¹⁸ ÷ (209,5 × 10¹² × 0,4) ≈ 16 h

6 × 8,03 × 10⁹ × 10⁸ = 4,8EFLOP de trabajo. La RTX 5090 rinde 209,5TFLOPS BF16 dense con acumulación FP32, que es la cifra honesta para entrenar; al 40 % de MFU son 83,8 TFLOPS sostenidos y 57 500 segundos, unas 16 horas. En una H100 SXM (989,5 TFLOPS dense) al mismo MFU: 3,4 horas. LoRA recorta el trabajo a unos 4 FLOP por parámetro y token, no a cero.

La misma cuenta explica por qué el preentrenamiento no es cosa de una workstation. Llama 3.1 8B se entrenó con 15 billones de tokens: 7,2 × 10²³ FLOP. Una H100 al 40 % tardaría 58 años; mil H100, tres semanas. El fine-tuning es factible en casa porque D es cinco órdenes de magnitud menor, no porque la GPU sea distinta.

Multi-GPU: tres formas de repartir y un cable que manda

Cuando no cabe en una tarjeta, o no llega a tiempo, se reparte. Hay tres ejes:

  • Data parallel: cada GPU tiene el modelo completo y procesa un trozo del lote; al final del paso se promedian los gradientes (all-reduce). Escala el caudal, no la memoria por GPU. ZeRO y FSDP trocean los estados: ZeRO-1 reparte el optimizador (de 16Ψ a unos 4Ψ bytes por GPU, 4×), ZeRO-2 añade los gradientes (8×) y ZeRO-3/FSDP también los pesos, con memoria por GPU proporcional al número de tarjetas.
  • Tensor parallel: cada matriz se parte entre GPUs. Es la única forma de bajar la memoria de una capa concreta, pero exige comunicación en cada bloque, varias veces por token.
  • Pipeline parallel: cada GPU se queda con un grupo de capas y se pasan las activaciones en cadena. Menos tráfico, pero burbujas si el lote es pequeño.

En todos los casos el tráfico entre GPUs es enorme. En data parallel, cada paso mueve unas dos veces el tamaño de los gradientes por GPU (un ring all-reduce envía y recibe 2 × (n−1)/n del tensor). Para el 8B en BF16, 16 GB de gradientes son unos 28 GB por GPU y paso con 8 tarjetas: 0,44 s por PCIe 5.0 ×16 a 63GB/s por dirección, 0,06 s por NVLink 4 a 450GB/s. Si el cálculo del paso dura un segundo, el primero pierde casi la mitad esperando; el segundo, un 6 %. NCCL solapa comunicación con cálculo cuando puede, pero no inventa ancho de banda.

Enlace entre GPUs

05001kNVLink 5 (B200)900 GB/sNVLink 4 (H100)450 GB/sPCIe 5.0 ×1663 GB/sNVLink bridge RTX 309056 GB/sPCIe 4.0 ×1632 GB/sGB/s
Ancho de banda por dirección de los enlaces que unen dos GPU (fuentes: PCI-SIG, NVIDIA; ver src/data/interconnects.json).

Ahí está la diferencia real entre consumo y datacenter para entrenar. Ninguna GeForce desde la RTX 3090 tiene NVLink, ni las RTX PRO Blackwell: dos RTX 5090 hablan por PCIe y, con los 24-28 lanes de una CPU de escritorio, a menudo a ×8 cada una. Una H100 SXM llega a 900 GB/s bidireccionales con sus vecinas y, vía NVSwitch, con las ocho del nodo. Por eso el tensor parallel entre dos 5090 decepciona y lo que funciona en casa es data parallel con FSDP (interconexión).

GPU 0RTX 5090 · gradientes 16 GBCPU / chipsetRyzen 9 9950X · 24 lanesGPU 1RTX 5090 · gradientes 16 GBPCIe 5.0 ×8 · 31,5 GB/sPCIe 5.0 ×8 · 31,5 GB/s
Ruta de los datos en un paso de data parallel con dos GPUs de consumo: el all-reduce de gradientes cruza PCIe y la CPU; con NVLink el cable sería directo (fuentes: PCI-SIG, NVIDIA).
Candidatas habituales para entrenar. Ojo con la columna FP16/BF16 dense: en las GeForce y RTX PRO es con acumulación FP16; con acumulación FP32 (entrenamiento) es la mitad (RTX 5090: 209,5; RTX 4090: 165,2; RTX 3090: 71,2). En H100/H200 la cifra ya es con FP32 (fuente: src/data/gpus.json, whitepapers de NVIDIA).
EquipoMemoria (GB)Ancho de banda (GB/s)FP16/BF16 dense (TFLOPS)InterconexiónTDP (W)
GeForce RTX 309024936142PCIe 4.0 x16 + NVLink de 2 vías (última GeForce con NVLink)350
GeForce RTX 4090241 008330PCIe 4.0 x16 (sin NVLink)450
GeForce RTX 5090321 792419PCIe 5.0 x16 (sin NVLink)575
NVIDIA RTX PRO 6000 Blackwell Workstation Edition961 792500PCIe 5.0 x16 (sin NVLink); soporta MIG (hasta 4 instancias)600
NVIDIA H100 SXM5 80 GB803 350990NVLink 4: 900 GB/s bidireccional por GPU (18 enlaces); PCIe 5.0 x16 (128 GB/s bidireccional)700
NVIDIA H200 SXM 141 GB1414 800990NVLink 4: 900 GB/s bidireccional por GPU; PCIe 5.0 x16 (128 GB/s bidireccional)700

Candidatas habituales para entrenar. Ojo con la columna FP16/BF16 dense: en las GeForce y RTX PRO es con acumulación FP16; con acumulación FP32 (entrenamiento) es la mitad (RTX 5090: 209,5; RTX 4090: 165,2; RTX 3090: 71,2). En H100/H200 la cifra ya es con FP32 (fuente: src/data/gpus.json, whitepapers de NVIDIA).

Cloud o local: dónde está el punto de equilibrio

Una H100 SXM se alquila a unos 3,99 $ por GPU-hora en nodos de 8 (Lambda, septiembre de 2026; una B200, 6,69 $). Una RTX 5090 cuesta 1 999 $ de lista y en BF16 dense rinde 4,7 veces menos, con menos de la mitad de memoria. El precio de una 5090 compra unas 500 horas de H100, que equivalen a unas 2 350 horas de la 5090: más de tres meses de entrenamiento continuo. Sin contar la electricidad (575 W × 24 h = 13,8 kWh, entre 2,5 y 4 € al día según tarifa), la fuente de 1 000 W ni que el equipo queda ocupado.

Lo local gana en tres casos: entrenas casi a diario (más de unos 100 días de GPU al año), los datos no pueden salir de casa, o haces QLoRA de 8-32B en la tarjeta que ya tienes para inferencia. El cloud gana cuando el trabajo es esporádico, necesitas más de 48 GB por GPU o el modelo pide varias GPUs unidas por NVLink, que en un escritorio no existe. La guía para elegir GPU baja este árbol al detalle de cada tarjeta.

Lo que debes recordar

  • Full fine-tuning con Adam en precisión mixta: 16 bytes por parámetro solo en estados (8B → 128,5 GB, 70B → 1 129 GB). Las activaciones se suman y escalan con secuencia × lote × anchura × capas.
  • Gradient checkpointing divide las activaciones por diez o más a cambio de un 30 % de tiempo.
  • LoRA congela el base (2 bytes por parámetro) y entrena un adaptador de menos del 1 %; QLoRA baja el base a 4 bits: 8B en unos 6 GB, 70B en unos 40 GB. Ahorran memoria, no cálculo.
  • Tiempo = 6·N·D ÷ (pico dense con acumulación FP32 × MFU de 35-60 %). Nunca con los “AI TOPS” de la ficha.
  • Multi-GPU sin NVLink es data parallel por PCIe: funciona con FSDP, pero el all-reduce puede costar tanto como el cálculo. El tensor parallel necesita enlace de datacenter.

Para mirar en una ficha técnica

  • Memoria (GB): la línea que decide. QLoRA de 8B: 12 GB; LoRA de 8B o QLoRA de 32B: 24 GB; QLoRA de 70B: 48 GB. Trampa: “compatible con IA” sin decir cuántos GB.
  • FP16/BF16 Tensor (TFLOPS): busca la cifra dense con acumulación FP32; si solo hay una y es muy alta, divide entre 2 (sparsity) y otra vez entre 2 (acumulación FP16). Trampa: “AI TOPS” (FP4 o INT8 sparse) como rendimiento de entrenamiento.
  • Interconexión: NVLink y cuántos GB/s; si no lo pone, es PCIe. Trampa: “multi-GPU ready” en tarjetas que solo hablan por PCIe ×8.
  • Lanes PCIe de la CPU: 24-28 en escritorio no dan para dos GPU a ×16 más NVMe; Threadripper o Xeon W sí. Trampa: tres ranuras ×16 físicas cableadas a ×8/×4.
  • TDP (W): 575 W por RTX 5090 más transitorios; dos tarjetas son una fuente de 1 500 W y una factura que comparar con el alquiler por horas.

Fuentes

  1. ZeRO: Memory Optimizations Toward Training Trillion Parameter Models (Rajbhandari et al., 2019) — desglose 2Ψ + 2Ψ + 12Ψ = 16Ψ bytes por parámetro en precisión mixta con Adam; reducciones de 4× (ZeRO-1), 8× (ZeRO-2) y proporcional al número de GPUs (ZeRO-3).
  2. QLoRA: Efficient Finetuning of Quantized LLMs (Dettmers et al., 2023) — fine-tuning de un 65B en una GPU de 48 GB; NF4, doble cuantización y optimizadores paginados.
  3. Scaling Laws for Neural Language Models (Kaplan et al., 2020) — estimación C ≈ 6N FLOP por token de entrenamiento.
  4. Training Deep Nets with Sublinear Memory Cost (Chen et al., 2016) — gradient checkpointing: memoria O(√n) a cambio de una pasada hacia delante extra, ~30 % de tiempo adicional.
  5. Reducing Activation Recomputation in Large Transformer Models (Korthikanti et al., 2022) — aproximación de 34·s·b·h bytes de activaciones por capa con atención fusionada.
  6. Hugging Face PEFT — LoRA conceptual guide — descomposición de rango r, base congelada, fusión de adaptadores sin latencia en inferencia.
  7. NVIDIA RTX Blackwell GPU Architecture (whitepaper) — RTX 5090: FP16/BF16 209,5 TFLOPS dense con acumulación FP32, 419 con FP16; 3 352 AI TOPS = FP4 sparse.
  8. NVIDIA H100 Tensor Core GPU — 989,5 TFLOPS BF16 dense, NVLink 4 a 900 GB/s bidireccionales, 80 GB HBM3.
  9. Lambda — GPU Cloud pricing — H100 SXM 3,99 $/GPU-h y B200 6,69 $/GPU-h en nodos de 8 (consultado el 22-09-2026).
  10. Meta — Llama 3.1 8B Instruct (ficha del modelo) — 8,03B parámetros, 32 capas, anchura 4 096, 8 KV heads, vocabulario 128 256, 15 billones de tokens de preentrenamiento.

Escribe para buscar en artículos, herramientas y glosario. Esc para cerrar.