Sobre esta herramienta
Hacer fine-tuning de un modelo de lenguaje exige mucha más memoria de GPU que ejecutarlo. Además de los pesos, la GPU guarda gradientes, estados del optimizador y las activaciones de cada capa hasta el paso hacia atrás. Esta calculadora suma esas partes para el ajuste completo, LoRA y QLoRA, con un modelo de la lista o uno que describas tú, y muestra qué GPU habituales tienen espacio para el resultado.
Cada parte aparece con su regla y su fuente, porque las calculadoras de fine-tuning suelen discrepar el doble: una cuenta 18 bytes por parámetro, otra 12, una olvida los logits, otra da por hecho el checkpointing. Aquí cada supuesto es un ajuste que puedes ver y cambiar.
Cómo se estima la memoria
El ajuste completo con precisión mixta guarda, por cada parámetro, 2 bytes de pesos en bf16, 2 bytes de gradientes, 4 bytes de copia maestra en fp32 y 8 bytes de momento y varianza de AdamW: 16 bytes, la cuenta del artículo de ZeRO (Rajbhandari et al., 2020). AdamW de 8 bits guarda 2 bytes de estado en lugar de 8, y SGD con momento 4. Las etapas 1, 2 y 3 de ZeRO reparten entre las GPU primero los estados del optimizador, luego los gradientes y después los pesos.
LoRA congela el modelo base a 2 bytes por parámetro y entrena dos matrices pequeñas junto a cada peso adaptado: un peso de recibe parámetros de adaptador (Hu et al., 2021). Solo ellos tienen gradientes y estados del optimizador: PEFT los crea en fp32 (16 bytes cada uno con AdamW), y el SFTTrainer de TRL los pasa a bf16 con modelos cuantizados (12 bytes). QLoRA guarda las capas lineales congeladas en NormalFloat de 4 bits con doble cuantización, bits por parámetro (Dettmers et al., 2023), mientras los embeddings y la capa de salida siguen en bf16.
Las activaciones dependen de los datos. Cada capa guarda unos bytes para una longitud de secuencia , un micro-batch y un tamaño oculto (Korthikanti et al., 2022); FlashAttention elimina el término de la matriz de atención. El gradient checkpointing guarda solo la entrada de cada capa, , y recalcula las capas de una en una. La pérdida añade unos 10 bytes por token y entrada del vocabulario para los logits, salvo que un kernel fusionado los calcule por partes. Con los pesos, los gradientes, los estados del optimizador y la copia maestra, las activaciones y los logits, más 1,3 GB para el contexto de CUDA y un margen del 10%:
Por qué discrepan las calculadoras de fine-tuning y qué queda fuera
Tres supuestos explican casi toda la diferencia entre calculadoras, y aquí cada uno es un ajuste. Bytes por parámetro: la guía de entrenamiento de Hugging Face cuenta 18 para AdamW con precisión mixta (gradientes en fp32 y una segunda copia de los pesos), el artículo de ZeRO 16, y los «más de 780 GB» del artículo de QLoRA para el ajuste de 16 bits de LLaMA 65B corresponden a 12, sin copia maestra; desactiva los pesos maestros para reproducirlo. Logits: con el vocabulario de Llama 3, de 128.256 tokens, los logits de 2048 tokens ocupan 2,6 GB, algo que los kernels fusionados de entropía cruzada evitan. Checkpointing: en Llama 3.1 8B con 2048 tokens, desactivarlo sube las activaciones de 0,8 a 9,1 GB.
No se modelan: los búferes efímeros dentro de una operación (el peso descuantizado de una capa en QLoRA, la capa que reúne ZeRO-3), la descarga a la CPU y los optimizadores paginados, los modelos mixture-of-experts, los codificadores de visión ni el entrenamiento por preferencias como DPO, que mantiene un segundo modelo de referencia. Usa el resultado para planificar y comprueba los primeros pasos con torch.cuda.max_memory_allocated().
Ejemplo
Comprobación con el artículo de QLoRA. LLaMA 65B tiene 65.290 millones de parámetros, 80 capas y un tamaño oculto de 8192. Con QLoRA, adaptadores de rango 64 en bf16 en todas las capas lineales, como en el artículo, y secuencias de 512 tokens: los pesos de 4 bits ocupan 32,38 GB, las constantes de cuantización 1,03 GB y los embeddings en bf16 1,05 GB; los 799,5 millones de parámetros de los adaptadores ocupan 1,60 GB, sus gradientes 1,60 GB y sus estados de AdamW 6,40 GB; las activaciones con checkpointing 0,81 GB y los logits 0,16 GB. Son 45,0 GB de tensores, y 50,8 GB con el contexto de 1,3 GB y el margen del 10%. Una tarjeta de 48 GB guarda 51.500 millones de bytes, así que cabe en una sola GPU de 48 GB, como en el artículo, con 0,7 GB de sobra; los optimizadores paginados del artículo dan más holgura, porque pasan los 6,4 GB de estados del optimizador a la memoria de la CPU cuando a la GPU le falta espacio.
Comprobación con el artículo de ZeRO. Para un modelo de 7500 millones de parámetros en 64 GPU, el artículo da 120 GB de estados del modelo por GPU sin particionar, 31,4 GB en la etapa 1, 16,6 GB en la etapa 2 y 1,88 GB en la etapa 3. Las reglas de esta página dan 120; 31,41; 16,64 y 1,875 GB.
Llama 3.1 8B. LoRA de rango 16 en todas las capas lineales (41,9 millones de parámetros de adaptador en bf16), 2048 tokens, micro-batch de 1 y checkpointing: 16,06 GB de pesos congelados, 0,50 GB para los adaptadores con sus gradientes y estados del optimizador, 0,82 GB de activaciones y 2,63 GB de logits, 23,3 GB en total. Unsloth indica 22 GB como mínimo para LoRA de 16 bits con un modelo de 8B. La misma ejecución con QLoRA necesita 11,9 GB, o 9,0 GB con una pérdida fusionada.
Preguntas frecuentes
¿Cuánta VRAM necesito para hacer fine-tuning de un modelo de 7B u 8B?
Con QLoRA, unos 9 a 12 GB con 2048 tokens y un micro-batch de 1: 11,9 GB con la configuración por defecto y 9,0 GB con una pérdida fusionada. Una tarjeta de 12 GB (12.900 millones de bytes) va justa; con 16 GB queda margen para secuencias más largas. LoRA de 16 bits necesita unos 23 GB, es decir, una tarjeta de 24 GB. El ajuste completo con AdamW necesita unos 146 GB, es decir, varias GPU con ZeRO o FSDP. Las secuencias más largas y los lotes más grandes añaden memoria de activaciones; la calculadora muestra cuánta.
¿Qué diferencia de memoria hay entre LoRA y QLoRA?
Las dos entrenan los mismos adaptadores pequeños; la diferencia está en el modelo base congelado. LoRA lo mantiene en bf16, a 2 bytes por parámetro, y QLoRA en NF4 de 4 bits, a unos 0,52 bytes. En Llama 3.1 8B son 16,1 GB frente a 5,7 GB, embeddings en bf16 incluidos. QLoRA entrena algo más despacio porque cada capa se descuantiza sobre la marcha.
¿Por qué el ajuste completo necesita 16 bytes por parámetro?
El entrenamiento con precisión mixta calcula en bf16 (2 bytes de pesos y 2 de gradientes por parámetro), pero actualiza una copia maestra en fp32 (4 bytes), y AdamW guarda dos estadísticas en fp32 por parámetro, el momento y la varianza (8 bytes). Por eso un modelo de 8B necesita unos 128 GB antes de las activaciones. AdamW de 8 bits lo deja en 10 bytes por parámetro, y ZeRO o FSDP reparten el total entre las GPU.
¿El gradient checkpointing reduce la memoria?
Sí, reduce la memoria de las activaciones. En Llama 3.1 8B con 2048 tokens, las activaciones bajan de 9,1 a 0,8 GB, porque solo se guarda la entrada de cada capa y el resto se recalcula en el paso hacia atrás. El precio es un paso hacia delante adicional: Korthikanti et al. midieron hasta un 30 a 40% más de tiempo de entrenamiento.
¿Cómo reparto el fine-tuning entre varias GPU?
Con DeepSpeed ZeRO o PyTorch FSDP. La etapa 1 reparte los estados del optimizador, la etapa 2 también los gradientes y la etapa 3 (particionado completo de FSDP) también los pesos. El ajuste completo de Llama 3.1 8B en ocho GPU con la etapa 3 necesita unos 22,8 GB por GPU. Las activaciones no se reparten: cada GPU procesa su propio micro-batch. Introduce el número de GPU para ver la memoria que necesita cada una.
Fuentes
- Rajbhandari et al. (2020), ZeRO: Memory Optimizations Toward Training Trillion Parameter Models
- Hu et al. (2021), LoRA: Low-Rank Adaptation of Large Language Models
- Dettmers et al. (2023), QLoRA: Efficient Finetuning of Quantized LLMs
- Korthikanti et al. (2022), Reducing Activation Recomputation in Large Transformer Models
- Hugging Face Transformers: GPU memory usage in training
- Hugging Face PEFT: LoRA developer guide
Enlace con tus valores
Añade estos parámetros a la dirección de esta página para abrirla con los valores ya rellenados, por ejemplo para compartir un cálculo o enlazarlo desde un asistente de IA. El resultado se calcula en el navegador: el HTML de la página muestra un ejemplo con los valores predeterminados y la herramienta añade el atributo data-url-params cuando se aplican los valores del enlace.
| Parámetro | Valor | Si se omite |
|---|---|---|
methodMétodo | uno de: full, lora, qlora | predeterminado: qlora |
architectureModelo personalizado | uno de: preset, custom | predeterminado: preset |
modelModelo | uno de: llama3.2-1b, llama3.2-3b, qwen3-4b, mistral-7b-v0.3, qwen2.5-7b, llama3.1-8b, qwen3-8b, phi-4, qwen3-14b, qwen3-32b, llama3.3-70b, llama-2-7b, llama-7b, llama-65b; se usa con architecture = preset | predeterminado: llama3.1-8b |
parameters_billionsParámetros | número; permitido 0.01–2000; se usa con architecture = custom | obligatorio |
layersCapas | número entero; permitido 1–512; se usa con architecture = custom | obligatorio |
hidden_sizeTamaño oculto (hidden size) | número entero; permitido 64–65536; se usa con architecture = custom | obligatorio |
vocabulary_sizeTamaño del vocabulario | número entero; permitido 1–2000000; se usa con architecture = custom | obligatorio |
tied_embeddingsEmbeddings compartidos (tie_word_embeddings) | true o false; se usa con architecture = custom | predeterminado: false |
optimizerOptimizador | uno de: adamw, adamw_8bit, sgd | predeterminado: adamw |
master_weightsGuardar una copia maestra de los pesos en fp32 | true o false; se usa con method = full | predeterminado: true |
lora_rankRango de LoRA (r) | número entero; permitido 1–1024; se usa con method = lora, qlora | predeterminado: 16 |
lora_targetsMódulos con LoRA | uno de: qv, attention, all; se usa con method = lora, qlora | predeterminado: all |
adapter_precisionPesos del adaptador | uno de: fp32, bf16; se usa con method = lora, qlora | predeterminado: bf16 |
sequence_lengthLongitud de secuencia (tokens) | número entero; permitido 1–1048576 | predeterminado: 2048 |
batch_sizeMicro-batch por GPU | número entero; permitido 1–1024 | predeterminado: 1 |
gradient_checkpointingGradient checkpointing | true o false | predeterminado: true |
fused_lossKernel fusionado de entropía cruzada (Liger, Unsloth) | true o false | predeterminado: false |
gpu_countNúmero de GPU | número entero; permitido 1–1024 | predeterminado: 1 |
zero_stageParticionado (etapa de ZeRO) | uno de: 0, 1, 2, 3 | predeterminado: 0 |
Ejemplos
?method=qlora&model=llama-65b&lora_rank=64&adapter_precision=bf16&sequence_length=512?method=lora&model=llama3.1-8b&lora_rank=16&lora_targets=all&sequence_length=2048&batch_size=1?method=full&model=llama3.1-8b&gpu_count=8&zero_stage=3?method=qlora&architecture=custom¶meters_billions=12&layers=48&hidden_size=3840&vocabulary_size=262144&tied_embeddings=true
Escribe los decimales con punto. Codifica un espacio como %20, + como %2B, # como %23 y & como %26.
Elementos del resultado: [data-result-block="fine-tuning-vram"]