peft

name	peft
description	Fine-tunes LLMs with Hugging Face PEFT (LoRA, QLoRA, IA3, multi-adapter serve) training under 1% of weights. Use when adapting 7B–70B models on limited GPU memory or serving multiple adapters from one base. Not for full-weight fine-tuning of small models and not for hosting Gradio demos (huggingface-spaces).
version	1.0.1
author	Orchestra Research
license	MIT
dependencies	["peft>=0.13.0","transformers>=4.45.0","torch>=2.0.0","bitsandbytes>=0.43.0"]
platforms	["linux","macos","windows"]
metadata	{"hermes":{"tags":["Fine-Tuning","PEFT","LoRA","QLoRA","Parameter-Efficient","Adapters","Low-Rank","Memory Optimization","Multi-Adapter"]}}

PEFT (Parameter-Efficient Fine-Tuning)

Fine-tune LLMs by training <1% of parameters using LoRA, QLoRA, and 25+ adapter methods. HuggingFace's official library integrated with the transformers ecosystem.

When to Use

Use PEFT/LoRA when:

• Fine-tuning 7B-70B models on consumer GPUs (RTX 4090, A100)
• Need to train <1% parameters (6 MB adapters vs 14 GB full model)
• Want fast iteration with multiple task-specific adapters
• Deploying multiple fine-tuned variants from one base model

Use QLoRA (PEFT + quantization) when:

• Fine-tuning 70B models on a single 24 GB GPU
• Memory is the primary constraint
• Can accept ~5% quality trade-off vs full fine-tuning

Use full fine-tuning instead when:

• Training small models (<1B parameters)
• Need maximum quality and have compute budget
• Significant domain shift requires updating all weights

Prerequisites

• Python 3.9+
• CUDA-enabled GPU (recommended) or CPU (slow)
• HuggingFace account with access to gated models (e.g., Llama 3.1 requires token)
• Windows host is primary (PowerShell). Use pip commands directly in PowerShell; for long paths, ensure long-path support is enabled.

Installation

# Basic installation
pip install peft

# With quantization support (recommended)
pip install peft bitsandbytes

# Full stack
pip install peft transformers accelerate bitsandbytes datasets

Procedure

1. LoRA Fine-Tuning (Standard)

from transformers import AutoModelForCausalLM, AutoTokenizer, TrainingArguments, Trainer
from peft import get_peft_model, LoraConfig, TaskType
from datasets import load_dataset
import torch

# Load base model
model_name = "meta-llama/Llama-3.1-8B"
model = AutoModelForCausalLM.from_pretrained(model_name, torch_dtype="auto", device_map="auto")
tokenizer = AutoTokenizer.from_pretrained(model_name)
tokenizer.pad_token = tokenizer.eos_token

# LoRA configuration
lora_config = LoraConfig(
    task_type=TaskType.CAUSAL_LM,
    r=,                          
    lora_alpha=,                 
    lora_dropout=,             
    target_modules=[, , , ],  
    bias=                    
)


model = get_peft_model(model, lora_config)
model.print_trainable_parameters()



dataset = load_dataset(, split=)

 ():
    text = 
     tokenizer(text, truncation=, max_length=, padding=)

tokenized = dataset.(tokenize, remove_columns=dataset.column_names)


training_args = TrainingArguments(
    output_dir=,
    num_train_epochs=,
    per_device_train_batch_size=,
    gradient_accumulation_steps=,
    learning_rate=,
    fp16=,
    logging_steps=,
    save_strategy=
)

trainer = Trainer(
    model=model,
    args=training_args,
    train_dataset=tokenized,
    data_collator= data: {: torch.stack([f[]  f  data]),
                                 : torch.stack([f[]  f  data]),
                                 : torch.stack([f[]  f  data])}
)

trainer.train()


model.save_pretrained()