Calculadora de VRAM para fine-tuning (LoRA, QLoRA, completo)

Ver resultados · 11,9 GB

Configuración del entrenamiento

Método

La base congelada se guarda en NF4 de 4 bits con doble cuantización; solo se entrenan los adaptadores.

Módulos con LoRA
Pesos del adaptador

PEFT crea los pesos del adaptador en fp32; el SFTTrainer de TRL los pasa a bf16 cuando el modelo base está cuantizado (QLoRA). Elige fp32 si usas PEFT sin TRL.

Optimizador

Memoria de GPU estimada

VRAM total
Parámetros entrenables
41,94 M (0,52 %)
Pesos, gradientes y optimizador
6,2 GB
Activaciones
0,8 GB

La GPU más pequeña de la lista en la que cabe: RTX 3060 12GB (12 GB), con 1,0 GB de margen.

Sin gradient checkpointing: 21,1 GB.

Modelo: 8.030.261.248 parámetros, 32 capas, tamaño oculto 4096, vocabulario 128.256.

prepare_model_for_kbit_training de PEFT pasa los embeddings y la capa de salida a fp32: suma 2,1 GB si tu script la llama.

Es una estimación, no una medición: la memoria de las activaciones depende del framework y de sus kernels. Datos de modelos y lista de GPU revisados el 2026-10-24.

Desglose de la memoria

Desglose de la memoria
ParteReglaMemoriaProporción
Pesos base congelados (NF4 de 4 bits)0.5 B×Ψlin0.5\,\text{B} \times \Psi_{\text{lin}}3,49 GB29,3 %
Constantes de cuantización0.127 bit×Ψlin0.127\,\text{bit} \times \Psi_{\text{lin}}0,11 GB0,93 %
Embeddings y capa de salida (bf16)2 B×Ψemb2\,\text{B} \times \Psi_{\text{emb}}2,10 GB17,6 %
Pesos de los adaptadores LoRA2 B×ΨLoRA2\,\text{B} \times \Psi_{\text{LoRA}}0,08 GB0,7 %
Gradientes de los adaptadores2 B×ΨLoRA2\,\text{B} \times \Psi_{\text{LoRA}}0,08 GB0,7 %
Estados del optimizador (adaptadores)8 B×ΨLoRA8\,\text{B} \times \Psi_{\text{LoRA}}0,34 GB2,8 %
Activaciones (con checkpointing)2sbhL+34sbh2sbhL + 34sbh0,82 GB6,9 %
Logits de salida para la pérdida10 B×sbV10\,\text{B} \times sbV2,63 GB22 %
Contexto y kernels de CUDA1.3 GB1.3\,\text{GB}1,30 GB10,9 %
Margen de seguridad10 %10\,\%0,97 GB8,1 %
VRAM total11,92 GB100 %

Ψ\Psi es el número de parámetros, Ψlin\Psi_{\text{lin}} los de las capas lineales, Ψemb\Psi_{\text{emb}} los de los embeddings y la capa de salida y ΨLoRA\Psi_{\text{LoRA}} los de los adaptadores; ss es la longitud de secuencia, bb el micro-batch, hh el tamaño oculto, LL el número de capas, VV el vocabulario y NN el número de GPU. B son bytes; GB son mil millones de bytes.

En qué GPU cabe

  • RTX 3060 12GB 12 GB (12,9 GB)1,0 GB libres
  • RTX 4060 Ti 16GB 16 GB (17,2 GB)5,3 GB libres
  • RTX 4080 16 GB (17,2 GB)5,3 GB libres
  • Tesla P100 16GB 16 GB (17,2 GB)5,3 GB libres
  • RTX 3090 24 GB (25,8 GB)13,9 GB libres
  • RTX 4090 24 GB (25,8 GB)13,9 GB libres
  • Tesla P40 24 GB (25,8 GB)13,9 GB libres
  • MI50 32GB 32 GB (34,4 GB)22,5 GB libres
  • RTX 5090 32 GB (34,4 GB)22,5 GB libres
  • Tesla V100 32GB 32 GB (34,4 GB)22,5 GB libres
  • A100 40GB 40 GB (42,9 GB)31,0 GB libres
  • L40S 48 GB (51,5 GB)39,6 GB libres
  • RTX 4090 48GB 48 GB (51,5 GB)39,6 GB libres
  • RTX A6000 48 GB (51,5 GB)39,6 GB libres
  • A100 80GB 80 GB (85,9 GB)74,0 GB libres
  • H100 80GB 80 GB (85,9 GB)74,0 GB libres
  • H100 NVL 94 GB (100,9 GB)89,0 GB libres
  • RTX PRO 6000 96 GB (103,1 GB)91,2 GB libres
  • DGX Spark GB10 128 GB (137,4 GB)125,5 GB libres
  • H200 141 GB (151,4 GB)139,5 GB libres
  • B200 180 GB (193,3 GB)181,4 GB libres

Memoria nominal según las fichas técnicas de los fabricantes. Los fabricantes cuentan en gigabytes binarios, así que una tarjeta de 24 GB guarda 25.800 millones de bytes (entre paréntesis); la comparación usa esa cifra, porque el contexto de CUDA ya está incluido en el total. La MI50 no tiene versión CUDA de bitsandbytes (QLoRA, AdamW de 8 bits); la V100 y las tarjetas Pascal (P40, P100) no tienen bf16, y en fp16 la memoria es la misma.

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 d×kd \times k recibe r(d+k)r(d + k) 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, 4+8/64+32/(64⋅256)≈4,1274 + 8/64 + 32/(64 \cdot 256) \approx 4{,}127 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 34 sbh34\,sbh bytes para una longitud de secuencia ss, un micro-batch bb y un tamaño oculto hh (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, 2 sbh2\,sbh, 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 WW los pesos, GG los gradientes, OO los estados del optimizador y la copia maestra, AA las activaciones y Λ\Lambda los logits, más 1,3 GB para el contexto de CUDA y un margen del 10%:

M=(W+G+O+A+Λ)×1,1+1,3 GBM = (W + G + O + A + \Lambda) \times 1{,}1 + 1{,}3\ \text{GB}

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

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ámetroValorSi se omite
methodMétodouno de: full, lora, qlorapredeterminado: qlora
architectureModelo personalizadouno de: preset, custompredeterminado: preset
modelModelouno 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 = presetpredeterminado: llama3.1-8b
parameters_billionsParámetrosnúmero; permitido 0.01–2000; se usa con architecture = customobligatorio
layersCapasnúmero entero; permitido 1–512; se usa con architecture = customobligatorio
hidden_sizeTamaño oculto (hidden size)número entero; permitido 64–65536; se usa con architecture = customobligatorio
vocabulary_sizeTamaño del vocabularionúmero entero; permitido 1–2000000; se usa con architecture = customobligatorio
tied_embeddingsEmbeddings compartidos (tie_word_embeddings)true o false; se usa con architecture = custompredeterminado: false
optimizerOptimizadoruno de: adamw, adamw_8bit, sgdpredeterminado: adamw
master_weightsGuardar una copia maestra de los pesos en fp32true o false; se usa con method = fullpredeterminado: true
lora_rankRango de LoRA (r)número entero; permitido 1–1024; se usa con method = lora, qlorapredeterminado: 16
lora_targetsMódulos con LoRAuno de: qv, attention, all; se usa con method = lora, qlorapredeterminado: all
adapter_precisionPesos del adaptadoruno de: fp32, bf16; se usa con method = lora, qlorapredeterminado: bf16
sequence_lengthLongitud de secuencia (tokens)número entero; permitido 1–1048576predeterminado: 2048
batch_sizeMicro-batch por GPUnúmero entero; permitido 1–1024predeterminado: 1
gradient_checkpointingGradient checkpointingtrue o falsepredeterminado: true
fused_lossKernel fusionado de entropía cruzada (Liger, Unsloth)true o falsepredeterminado: false
gpu_countNúmero de GPUnúmero entero; permitido 1–1024predeterminado: 1
zero_stageParticionado (etapa de ZeRO)uno de: 0, 1, 2, 3predeterminado: 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&parameters_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"]