RUNLOCALAIv38
->Will it run?Best GPUCompareTroubleshootGet startedLearnPulseModelsHardwareToolsBench
Run check
RUNLOCALAI

Independently operated catalog for local-AI hardware and software. Hand-written verdicts. Source-cited claims. Reproducible commands when we have them.

OP·Eruo Fredoline
DIR
  • Models
  • Hardware
  • Tools
  • Benchmarks
TOOLS
  • Will it run?
  • Compare hardware
  • Cost vs cloud
  • Choose my GPU
  • Prompting kits
  • Quick answers
REF
  • All buyer guides
  • Learn local AI
  • Methodology
  • Glossary
  • Errors KB
  • Trust
  • Suggest a feature
EDITOR
  • About
  • Author
  • How we make money
  • Editorial policy
  • Contact
LEGAL
  • Privacy
  • Terms
  • Sitemap
MAIL · MONTHLY DIGEST
Get monthly local AI changes
Monthly recap. No spam.
DISCLOSURE

Some links on this site are affiliate links (Amazon Associates and other first-class retailers). When you buy through them, we earn a small commission at no extra cost to you. Affiliate links do not influence our verdicts — there are cards we rate highly that we don't have affiliate relationships with, and cards that sell well that we refuse to recommend. How we make money →

© 2026 runlocalai.coIndependently operated
RUNLOCALAI · v38
Glossary / Large language models / QLoRA
Large language models

QLoRA

QLoRA combines LoRA fine-tuning with 4-bit quantization of the base model. Introduced by Tim Dettmers in 2023, it dropped the VRAM cost of fine-tuning by ~4× and made consumer-GPU fine-tuning of 70B models possible for the first time.

The technique: the base model is loaded in 4-bit NF4 (a normalized float-4 format), only the LoRA adapter weights are kept in FP16, and gradients flow only through the adapter. Forward passes dequantize on-the-fly.

Practical impact: a Llama 3.1 70B QLoRA fine-tune fits on a single RTX 4090 (24 GB) where full fine-tuning would need 8× A100s. Tools like Unsloth optimize QLoRA further, achieving 2× speed over the reference HuggingFace implementation.

Practical example

A team wants to fine-tune Llama 3.1 70B on a proprietary support-ticket dataset but only has access to a single RTX 4090. Full fine-tuning is a non-starter — optimizer states and gradients for 70B parameters alone would need multiple A100-class GPUs. With QLoRA, they load the base model in 4-bit NF4 (roughly 40GB, still needing to be offloaded or split, but far more tractable than FP16), attach small LoRA adapters in FP16, and train only those adapters while the frozen base stays quantized. Using Unsloth's optimized kernels cuts training time further versus a reference HuggingFace TRL run. The resulting adapter file is typically tens to a couple hundred MB — small enough to version-control and swap at inference time — while the quality gap versus a full fine-tune is often small enough to be worth the massive compute savings.

Related terms

Fine-tuningLoRA (Low-Rank Adaptation)Quantization

See also

tool: unsloth

Reviewed by Eruo Fredoline. See our editorial policy.

Buyer guides
  • Best GPU for local AI →
  • Best laptop for local AI →
  • Best Mac for local AI →
When it doesn't work
  • CUDA out of memory →
  • Ollama running slowly →
  • ROCm not detected →