[{"data":1,"prerenderedAt":-1},["ShallowReactive",2],{"skill:01M71PRP9ZWQSV3D9S1QDMZWS1":3,"skill-same:01M71PRP9ZWQSV3D9S1QDMZWS1":90},{"skillNo":4,"name":5,"nameZh":6,"description":7,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":6,"repositoryNo":12,"starsCount":13,"licenseSpdxId":14,"licenseFileUrl":6,"sourceHtmlUrl":15,"categories":16,"keywords":17,"publishedAt":38,"linkOnly":39,"markdownContent":40,"markdownBody":41,"frontMatter":42,"refName":60,"commitSha":61,"skillDirectory":62,"forksCount":13,"repositoryHtmlUrl":63,"repositoryHomepageUrl":6,"ownerHtmlUrl":64,"ownerBlogUrl":6,"ownerDescription":6,"updatedAt":65,"install":66,"resources":79},"01M71PRP9ZWQSV3D9S1QDMZWS1","peft-fine-tuning",null,"Parameter-efficient fine-tuning for LLMs using LoRA, QLoRA, and 25+ methods. Use when fine-tuning large models (7B-70B) with limited GPU memory, when you need to train \u003C1% of parameters with minimal accuracy loss, or for multi-adapter serving. HuggingFace's official library integrated with transformers ecosystem.","gjbvsjjvgm-sketch\u002FWORM_V2_SOVEREIGN","gjbvsjjvgm-sketch","https:\u002F\u002Favatars.githubusercontent.com\u002Fu\u002F278511911?v=4","01M71F3JXKZQ70H2KCHHTXKZDA","01M71PENEVFN19DBZFNHJPCHQ7",0,"MIT","https:\u002F\u002Fgithub.com\u002Fgjbvsjjvgm-sketch\u002FWORM_V2_SOVEREIGN\u002Fblob\u002Fmain\u002Fcore\u002Fhermes-agent\u002Fskills\u002Fmlops\u002Ftraining\u002Fpeft\u002FSKILL.md",[],[18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37],"tuning","fine tuning","PEFT","peft fine tuning","minimal","accuracy","methods","Optimization","Bitsandbytes","for","orchestra","Memory Optimization","library","Transformers","llms","you","when","memory","official","ecosystem","2026-11-10 13:02:02",false,"---\nname: peft-fine-tuning\ndescription: Parameter-efficient fine-tuning for LLMs using LoRA, QLoRA, and 25+ methods. Use when fine-tuning large models (7B-70B) with limited GPU memory, when you need to train \u003C1% of parameters with minimal accuracy loss, or for multi-adapter serving. HuggingFace's official library integrated with transformers ecosystem.\nversion: 1.0.0\nauthor: Orchestra Research\nlicense: MIT\ndependencies: [peft>=0.13.0, transformers>=4.45.0, torch>=2.0.0, bitsandbytes>=0.43.0]\nmetadata:\n  hermes:\n    tags: [Fine-Tuning, PEFT, LoRA, QLoRA, Parameter-Efficient, Adapters, Low-Rank, Memory Optimization, Multi-Adapter]\n\n---\n\n# PEFT (Parameter-Efficient Fine-Tuning)\n\nFine-tune LLMs by training \u003C1% of parameters using LoRA, QLoRA, and 25+ adapter methods.\n\n## When to use PEFT\n\n**Use PEFT\u002FLoRA when:**\n- Fine-tuning 7B-70B models on consumer GPUs (RTX 4090, A100)\n- Need to train \u003C1% parameters (6MB adapters vs 14GB full model)\n- Want fast iteration with multiple task-specific adapters\n- Deploying multiple fine-tuned variants from one base model\n\n**Use QLoRA (PEFT + quantization) when:**\n- Fine-tuning 70B models on single 24GB GPU\n- Memory is the primary constraint\n- Can accept ~5% quality trade-off vs full fine-tuning\n\n**Use full fine-tuning instead when:**\n- Training small models (\u003C1B parameters)\n- Need maximum quality and have compute budget\n- Significant domain shift requires updating all weights\n\n## Quick start\n\n### Installation\n\n```bash\n# Basic installation\npip install peft\n\n# With quantization support (recommended)\npip install peft bitsandbytes\n\n# Full stack\npip install peft transformers accelerate bitsandbytes datasets\n```\n\n### LoRA fine-tuning (standard)\n\n```python\nfrom transformers import AutoModelForCausalLM, AutoTokenizer, TrainingArguments, Trainer\nfrom peft import get_peft_model, LoraConfig, TaskType\nfrom datasets import load_dataset\n\n# Load base model\nmodel_name = \"meta-llama\u002FLlama-3.1-8B\"\nmodel = AutoModelForCausalLM.from_pretrained(model_name, torch_dtype=\"auto\", device_map=\"auto\")\ntokenizer = AutoTokenizer.from_pretrained(model_name)\ntokenizer.pad_token = tokenizer.eos_token\n\n# LoRA configuration\nlora_config = LoraConfig(\n    task_type=TaskType.CAUSAL_LM,\n    r=16,                          # Rank (8-64, higher = more capacity)\n    lora_alpha=32,                 # Scaling factor (typically 2*r)\n    lora_dropout=0.05,             # Dropout for regularization\n    target_modules=[\"q_proj\", \"v_proj\", \"k_proj\", \"o_proj\"],  # Attention layers\n    bias=\"none\"                    # Don't train biases\n)\n\n# Apply LoRA\nmodel = get_peft_model(model, lora_config)\nmodel.print_trainable_parameters()\n# Output: trainable params: 13,631,488 || all params: 8,043,307,008 || trainable%: 0.17%\n\n# Prepare dataset\ndataset = load_dataset(\"databricks\u002Fdatabricks-dolly-15k\", split=\"train\")\n\ndef tokenize(example):\n    text = f\"### Instruction:\\n{example['instruction']}\\n\\n### Response:\\n{example['response']}\"\n    return tokenizer(text, truncation=True, max_length=512, padding=\"max_length\")\n\ntokenized = dataset.map(tokenize, remove_columns=dataset.column_names)\n\n# Training\ntraining_args = TrainingArguments(\n    output_dir=\".\u002Flora-llama\",\n    num_train_epochs=3,\n    per_device_train_batch_size=4,\n    gradient_accumulation_steps=4,\n    learning_rate=2e-4,\n    fp16=True,\n    logging_steps=10,\n    save_strategy=\"epoch\"\n)\n\ntrainer = Trainer(\n    model=model,\n    args=training_args,\n    train_dataset=tokenized,\n    data_collator=lambda data: {\"input_ids\": torch.stack([f[\"input_ids\"] for f in data]),\n                                 \"attention_mask\": torch.stack([f[\"attention_mask\"] for f in data]),\n                                 \"labels\": torch.stack([f[\"input_ids\"] for f in data])}\n)\n\ntrainer.train()\n\n# Save adapter only (6MB vs 16GB)\nmodel.save_pretrained(\".\u002Flora-llama-adapter\")\n```\n\n### QLoRA fine-tuning (memory-efficient)\n\n```python\nfrom transformers import AutoModelForCausalLM, BitsAndBytesConfig\nfrom peft import get_peft_model, LoraConfig, prepare_model_for_kbit_training\n\n# 4-bit quantization config\nbnb_config = BitsAndBytesConfig(\n    load_in_4bit=True,\n    bnb_4bit_quant_type=\"nf4\",           # NormalFloat4 (best for LLMs)\n    bnb_4bit_compute_dtype=\"bfloat16\",   # Compute in bf16\n    bnb_4bit_use_double_quant=True       # Nested quantization\n)\n\n# Load quantized model\nmodel = AutoModelForCausalLM.from_pretrained(\n    \"meta-llama\u002FLlama-3.1-70B\",\n    quantization_config=bnb_config,\n    device_map=\"auto\"\n)\n\n# Prepare for training (enables gradient checkpointing)\nmodel = prepare_model_for_kbit_training(model)\n\n# LoRA config for QLoRA\nlora_config = LoraConfig(\n    r=64,                              # Higher rank for 70B\n    lora_alpha=128,\n    lora_dropout=0.1,\n    target_modules=[\"q_proj\", \"v_proj\", \"k_proj\", \"o_proj\", \"gate_proj\", \"up_proj\", \"down_proj\"],\n    bias=\"none\",\n    task_type=\"CAUSAL_LM\"\n)\n\nmodel = get_peft_model(model, lora_config)\n# 70B model now fits on single 24GB GPU!\n```\n\n## LoRA parameter selection\n\n### Rank (r) - capacity vs efficiency\n\n| Rank | Trainable Params | Memory | Quality | Use Case |\n|------|-----------------|--------|---------|----------|\n| 4 | ~3M | Minimal | Lower | Simple tasks, prototyping |\n| **8** | ~7M | Low | Good | **Recommended starting point** |\n| **16** | ~14M | Medium | Better | **General fine-tuning** |\n| 32 | ~27M | Higher | High | Complex tasks |\n| 64 | ~54M | High | Highest | Domain adaptation, 70B models |\n\n### Alpha (lora_alpha) - scaling factor\n\n```python\n# Rule of thumb: alpha = 2 * rank\nLoraConfig(r=16, lora_alpha=32)  # Standard\nLoraConfig(r=16, lora_alpha=16)  # Conservative (lower learning rate effect)\nLoraConfig(r=16, lora_alpha=64)  # Aggressive (higher learning rate effect)\n```\n\n### Target modules by architecture\n\n```python\n# Llama \u002F Mistral \u002F Qwen\ntarget_modules = [\"q_proj\", \"v_proj\", \"k_proj\", \"o_proj\", \"gate_proj\", \"up_proj\", \"down_proj\"]\n\n# GPT-2 \u002F GPT-Neo\ntarget_modules = [\"c_attn\", \"c_proj\", \"c_fc\"]\n\n# Falcon\ntarget_modules = [\"query_key_value\", \"dense\", \"dense_h_to_4h\", \"dense_4h_to_h\"]\n\n# BLOOM\ntarget_modules = [\"query_key_value\", \"dense\", \"dense_h_to_4h\", \"dense_4h_to_h\"]\n\n# Auto-detect all linear layers\ntarget_modules = \"all-linear\"  # PEFT 0.6.0+\n```\n\n## Loading and merging adapters\n\n### Load trained adapter\n\n```python\nfrom peft import PeftModel, AutoPeftModelForCausalLM\nfrom transformers import AutoModelForCausalLM\n\n# Option 1: Load with PeftModel\nbase_model = AutoModelForCausalLM.from_pretrained(\"meta-llama\u002FLlama-3.1-8B\")\nmodel = PeftModel.from_pretrained(base_model, \".\u002Flora-llama-adapter\")\n\n# Option 2: Load directly (recommended)\nmodel = AutoPeftModelForCausalLM.from_pretrained(\n    \".\u002Flora-llama-adapter\",\n    device_map=\"auto\"\n)\n```\n\n### Merge adapter into base model\n\n```python\n# Merge for deployment (no adapter overhead)\nmerged_model = model.merge_and_unload()\n\n# Save merged model\nmerged_model.save_pretrained(\".\u002Fllama-merged\")\ntokenizer.save_pretrained(\".\u002Fllama-merged\")\n\n# Push to Hub\nmerged_model.push_to_hub(\"username\u002Fllama-finetuned\")\n```\n\n### Multi-adapter serving\n\n```python\nfrom peft import PeftModel\n\n# Load base with first adapter\nmodel = AutoPeftModelForCausalLM.from_pretrained(\".\u002Fadapter-task1\")\n\n# Load additional adapters\nmodel.load_adapter(\".\u002Fadapter-task2\", adapter_name=\"task2\")\nmodel.load_adapter(\".\u002Fadapter-task3\", adapter_name=\"task3\")\n\n# Switch between adapters at runtime\nmodel.set_adapter(\"task1\")  # Use task1 adapter\noutput1 = model.generate(**inputs)\n\nmodel.set_adapter(\"task2\")  # Switch to task2\noutput2 = model.generate(**inputs)\n\n# Disable adapters (use base model)\nwith model.disable_adapter():\n    base_output = model.generate(**inputs)\n```\n\n## PEFT methods comparison\n\n| Method | Trainable % | Memory | Speed | Best For |\n|--------|------------|--------|-------|----------|\n| **LoRA** | 0.1-1% | Low | Fast | General fine-tuning |\n| **QLoRA** | 0.1-1% | Very Low | Medium | Memory-constrained |\n| AdaLoRA | 0.1-1% | Low | Medium | Automatic rank selection |\n| IA3 | 0.01% | Minimal | Fastest | Few-shot adaptation |\n| Prefix Tuning | 0.1% | Low | Medium | Generation control |\n| Prompt Tuning | 0.001% | Minimal | Fast | Simple task adaptation |\n| P-Tuning v2 | 0.1% | Low | Medium | NLU tasks |\n\n### IA3 (minimal parameters)\n\n```python\nfrom peft import IA3Config\n\nia3_config = IA3Config(\n    target_modules=[\"q_proj\", \"v_proj\", \"k_proj\", \"down_proj\"],\n    feedforward_modules=[\"down_proj\"]\n)\nmodel = get_peft_model(model, ia3_config)\n# Trains only 0.01% of parameters!\n```\n\n### Prefix Tuning\n\n```python\nfrom peft import PrefixTuningConfig\n\nprefix_config = PrefixTuningConfig(\n    task_type=\"CAUSAL_LM\",\n    num_virtual_tokens=20,      # Prepended tokens\n    prefix_projection=True       # Use MLP projection\n)\nmodel = get_peft_model(model, prefix_config)\n```\n\n## Integration patterns\n\n### With TRL (SFTTrainer)\n\n```python\nfrom trl import SFTTrainer, SFTConfig\nfrom peft import LoraConfig\n\nlora_config = LoraConfig(r=16, lora_alpha=32, target_modules=\"all-linear\")\n\ntrainer = SFTTrainer(\n    model=model,\n    args=SFTConfig(output_dir=\".\u002Foutput\", max_seq_length=512),\n    train_dataset=dataset,\n    peft_config=lora_config,  # Pass LoRA config directly\n)\ntrainer.train()\n```\n\n### With Axolotl (YAML config)\n\n```yaml\n# axolotl config.yaml\nadapter: lora\nlora_r: 16\nlora_alpha: 32\nlora_dropout: 0.05\nlora_target_modules:\n  - q_proj\n  - v_proj\n  - k_proj\n  - o_proj\nlora_target_linear: true  # Target all linear layers\n```\n\n### With vLLM (inference)\n\n```python\nfrom vllm import LLM\nfrom vllm.lora.request import LoRARequest\n\n# Load base model with LoRA support\nllm = LLM(model=\"meta-llama\u002FLlama-3.1-8B\", enable_lora=True)\n\n# Serve with adapter\noutputs = llm.generate(\n    prompts,\n    lora_request=LoRARequest(\"adapter1\", 1, \".\u002Flora-adapter\")\n)\n```\n\n## Performance benchmarks\n\n### Memory usage (Llama 3.1 8B)\n\n| Method | GPU Memory | Trainable Params |\n|--------|-----------|------------------|\n| Full fine-tuning | 60+ GB | 8B (100%) |\n| LoRA r=16 | 18 GB | 14M (0.17%) |\n| QLoRA r=16 | 6 GB | 14M (0.17%) |\n| IA3 | 16 GB | 800K (0.01%) |\n\n### Training speed (A100 80GB)\n\n| Method | Tokens\u002Fsec | vs Full FT |\n|--------|-----------|------------|\n| Full FT | 2,500 | 1x |\n| LoRA | 3,200 | 1.3x |\n| QLoRA | 2,100 | 0.84x |\n\n### Quality (MMLU benchmark)\n\n| Model | Full FT | LoRA | QLoRA |\n|-------|---------|------|-------|\n| Llama 2-7B | 45.3 | 44.8 | 44.1 |\n| Llama 2-13B | 54.8 | 54.2 | 53.5 |\n\n## Common issues\n\n### CUDA OOM during training\n\n```python\n# Solution 1: Enable gradient checkpointing\nmodel.gradient_checkpointing_enable()\n\n# Solution 2: Reduce batch size + increase accumulation\nTrainingArguments(\n    per_device_train_batch_size=1,\n    gradient_accumulation_steps=16\n)\n\n# Solution 3: Use QLoRA\nfrom transformers import BitsAndBytesConfig\nbnb_config = BitsAndBytesConfig(load_in_4bit=True, bnb_4bit_quant_type=\"nf4\")\n```\n\n### Adapter not applying\n\n```python\n# Verify adapter is active\nprint(model.active_adapters)  # Should show adapter name\n\n# Check trainable parameters\nmodel.print_trainable_parameters()\n\n# Ensure model in training mode\nmodel.train()\n```\n\n### Quality degradation\n\n```python\n# Increase rank\nLoraConfig(r=32, lora_alpha=64)\n\n# Target more modules\ntarget_modules = \"all-linear\"\n\n# Use more training data and epochs\nTrainingArguments(num_train_epochs=5)\n\n# Lower learning rate\nTrainingArguments(learning_rate=1e-4)\n```\n\n## Best practices\n\n1. **Start with r=8-16**, increase if quality insufficient\n2. **Use alpha = 2 * rank** as starting point\n3. **Target attention + MLP layers** for best quality\u002Fefficiency\n4. **Enable gradient checkpointing** for memory savings\n5. **Save adapters frequently** (small files, easy rollback)\n6. **Evaluate on held-out data** before merging\n7. **Use QLoRA for 70B+ models** on consumer hardware\n\n## References\n\n- **[Advanced Usage](references\u002Fadvanced-usage.md)** - DoRA, LoftQ, rank stabilization, custom modules\n- **[Troubleshooting](references\u002Ftroubleshooting.md)** - Common errors, debugging, optimization\n\n## Resources\n\n- **GitHub**: https:\u002F\u002Fgithub.com\u002Fhuggingface\u002Fpeft\n- **Docs**: https:\u002F\u002Fhuggingface.co\u002Fdocs\u002Fpeft\n- **LoRA Paper**: arXiv:2106.09685\n- **QLoRA Paper**: arXiv:2305.14314\n- **Models**: https:\u002F\u002Fhuggingface.co\u002Fmodels?library=peft\n","# PEFT (Parameter-Efficient Fine-Tuning)\n\nFine-tune LLMs by training \u003C1% of parameters using LoRA, QLoRA, and 25+ adapter methods.\n\n## When to use PEFT\n\n**Use PEFT\u002FLoRA when:**\n- Fine-tuning 7B-70B models on consumer GPUs (RTX 4090, A100)\n- Need to train \u003C1% parameters (6MB adapters vs 14GB full model)\n- Want fast iteration with multiple task-specific adapters\n- Deploying multiple fine-tuned variants from one base model\n\n**Use QLoRA (PEFT + quantization) when:**\n- Fine-tuning 70B models on single 24GB GPU\n- Memory is the primary constraint\n- Can accept ~5% quality trade-off vs full fine-tuning\n\n**Use full fine-tuning instead when:**\n- Training small models (\u003C1B parameters)\n- Need maximum quality and have compute budget\n- Significant domain shift requires updating all weights\n\n## Quick start\n\n### Installation\n\n```bash\n# Basic installation\npip install peft\n\n# With quantization support (recommended)\npip install peft bitsandbytes\n\n# Full stack\npip install peft transformers accelerate bitsandbytes datasets\n```\n\n### LoRA fine-tuning (standard)\n\n```python\nfrom transformers import AutoModelForCausalLM, AutoTokenizer, TrainingArguments, Trainer\nfrom peft import get_peft_model, LoraConfig, TaskType\nfrom datasets import load_dataset\n\n# Load base model\nmodel_name = \"meta-llama\u002FLlama-3.1-8B\"\nmodel = AutoModelForCausalLM.from_pretrained(model_name, torch_dtype=\"auto\", device_map=\"auto\")\ntokenizer = AutoTokenizer.from_pretrained(model_name)\ntokenizer.pad_token = tokenizer.eos_token\n\n# LoRA configuration\nlora_config = LoraConfig(\n    task_type=TaskType.CAUSAL_LM,\n    r=16,                          # Rank (8-64, higher = more capacity)\n    lora_alpha=32,                 # Scaling factor (typically 2*r)\n    lora_dropout=0.05,             # Dropout for regularization\n    target_modules=[\"q_proj\", \"v_proj\", \"k_proj\", \"o_proj\"],  # Attention layers\n    bias=\"none\"                    # Don't train biases\n)\n\n# Apply LoRA\nmodel = get_peft_model(model, lora_config)\nmodel.print_trainable_parameters()\n# Output: trainable params: 13,631,488 || all params: 8,043,307,008 || trainable%: 0.17%\n\n# Prepare dataset\ndataset = load_dataset(\"databricks\u002Fdatabricks-dolly-15k\", split=\"train\")\n\ndef tokenize(example):\n    text = f\"### Instruction:\\n{example['instruction']}\\n\\n### Response:\\n{example['response']}\"\n    return tokenizer(text, truncation=True, max_length=512, padding=\"max_length\")\n\ntokenized = dataset.map(tokenize, remove_columns=dataset.column_names)\n\n# Training\ntraining_args = TrainingArguments(\n    output_dir=\".\u002Flora-llama\",\n    num_train_epochs=3,\n    per_device_train_batch_size=4,\n    gradient_accumulation_steps=4,\n    learning_rate=2e-4,\n    fp16=True,\n    logging_steps=10,\n    save_strategy=\"epoch\"\n)\n\ntrainer = Trainer(\n    model=model,\n    args=training_args,\n    train_dataset=tokenized,\n    data_collator=lambda data: {\"input_ids\": torch.stack([f[\"input_ids\"] for f in data]),\n                                 \"attention_mask\": torch.stack([f[\"attention_mask\"] for f in data]),\n                                 \"labels\": torch.stack([f[\"input_ids\"] for f in data])}\n)\n\ntrainer.train()\n\n# Save adapter only (6MB vs 16GB)\nmodel.save_pretrained(\".\u002Flora-llama-adapter\")\n```\n\n### QLoRA fine-tuning (memory-efficient)\n\n```python\nfrom transformers import AutoModelForCausalLM, BitsAndBytesConfig\nfrom peft import get_peft_model, LoraConfig, prepare_model_for_kbit_training\n\n# 4-bit quantization config\nbnb_config = BitsAndBytesConfig(\n    load_in_4bit=True,\n    bnb_4bit_quant_type=\"nf4\",           # NormalFloat4 (best for LLMs)\n    bnb_4bit_compute_dtype=\"bfloat16\",   # Compute in bf16\n    bnb_4bit_use_double_quant=True       # Nested quantization\n)\n\n# Load quantized model\nmodel = AutoModelForCausalLM.from_pretrained(\n    \"meta-llama\u002FLlama-3.1-70B\",\n    quantization_config=bnb_config,\n    device_map=\"auto\"\n)\n\n# Prepare for training (enables gradient checkpointing)\nmodel = prepare_model_for_kbit_training(model)\n\n# LoRA config for QLoRA\nlora_config = LoraConfig(\n    r=64,                              # Higher rank for 70B\n    lora_alpha=128,\n    lora_dropout=0.1,\n    target_modules=[\"q_proj\", \"v_proj\", \"k_proj\", \"o_proj\", \"gate_proj\", \"up_proj\", \"down_proj\"],\n    bias=\"none\",\n    task_type=\"CAUSAL_LM\"\n)\n\nmodel = get_peft_model(model, lora_config)\n# 70B model now fits on single 24GB GPU!\n```\n\n## LoRA parameter selection\n\n### Rank (r) - capacity vs efficiency\n\n| Rank | Trainable Params | Memory | Quality | Use Case |\n|------|-----------------|--------|---------|----------|\n| 4 | ~3M | Minimal | Lower | Simple tasks, prototyping |\n| **8** | ~7M | Low | Good | **Recommended starting point** |\n| **16** | ~14M | Medium | Better | **General fine-tuning** |\n| 32 | ~27M | Higher | High | Complex tasks |\n| 64 | ~54M | High | Highest | Domain adaptation, 70B models |\n\n### Alpha (lora_alpha) - scaling factor\n\n```python\n# Rule of thumb: alpha = 2 * rank\nLoraConfig(r=16, lora_alpha=32)  # Standard\nLoraConfig(r=16, lora_alpha=16)  # Conservative (lower learning rate effect)\nLoraConfig(r=16, lora_alpha=64)  # Aggressive (higher learning rate effect)\n```\n\n### Target modules by architecture\n\n```python\n# Llama \u002F Mistral \u002F Qwen\ntarget_modules = [\"q_proj\", \"v_proj\", \"k_proj\", \"o_proj\", \"gate_proj\", \"up_proj\", \"down_proj\"]\n\n# GPT-2 \u002F GPT-Neo\ntarget_modules = [\"c_attn\", \"c_proj\", \"c_fc\"]\n\n# Falcon\ntarget_modules = [\"query_key_value\", \"dense\", \"dense_h_to_4h\", \"dense_4h_to_h\"]\n\n# BLOOM\ntarget_modules = [\"query_key_value\", \"dense\", \"dense_h_to_4h\", \"dense_4h_to_h\"]\n\n# Auto-detect all linear layers\ntarget_modules = \"all-linear\"  # PEFT 0.6.0+\n```\n\n## Loading and merging adapters\n\n### Load trained adapter\n\n```python\nfrom peft import PeftModel, AutoPeftModelForCausalLM\nfrom transformers import AutoModelForCausalLM\n\n# Option 1: Load with PeftModel\nbase_model = AutoModelForCausalLM.from_pretrained(\"meta-llama\u002FLlama-3.1-8B\")\nmodel = PeftModel.from_pretrained(base_model, \".\u002Flora-llama-adapter\")\n\n# Option 2: Load directly (recommended)\nmodel = AutoPeftModelForCausalLM.from_pretrained(\n    \".\u002Flora-llama-adapter\",\n    device_map=\"auto\"\n)\n```\n\n### Merge adapter into base model\n\n```python\n# Merge for deployment (no adapter overhead)\nmerged_model = model.merge_and_unload()\n\n# Save merged model\nmerged_model.save_pretrained(\".\u002Fllama-merged\")\ntokenizer.save_pretrained(\".\u002Fllama-merged\")\n\n# Push to Hub\nmerged_model.push_to_hub(\"username\u002Fllama-finetuned\")\n```\n\n### Multi-adapter serving\n\n```python\nfrom peft import PeftModel\n\n# Load base with first adapter\nmodel = AutoPeftModelForCausalLM.from_pretrained(\".\u002Fadapter-task1\")\n\n# Load additional adapters\nmodel.load_adapter(\".\u002Fadapter-task2\", adapter_name=\"task2\")\nmodel.load_adapter(\".\u002Fadapter-task3\", adapter_name=\"task3\")\n\n# Switch between adapters at runtime\nmodel.set_adapter(\"task1\")  # Use task1 adapter\noutput1 = model.generate(**inputs)\n\nmodel.set_adapter(\"task2\")  # Switch to task2\noutput2 = model.generate(**inputs)\n\n# Disable adapters (use base model)\nwith model.disable_adapter():\n    base_output = model.generate(**inputs)\n```\n\n## PEFT methods comparison\n\n| Method | Trainable % | Memory | Speed | Best For |\n|--------|------------|--------|-------|----------|\n| **LoRA** | 0.1-1% | Low | Fast | General fine-tuning |\n| **QLoRA** | 0.1-1% | Very Low | Medium | Memory-constrained |\n| AdaLoRA | 0.1-1% | Low | Medium | Automatic rank selection |\n| IA3 | 0.01% | Minimal | Fastest | Few-shot adaptation |\n| Prefix Tuning | 0.1% | Low | Medium | Generation control |\n| Prompt Tuning | 0.001% | Minimal | Fast | Simple task adaptation |\n| P-Tuning v2 | 0.1% | Low | Medium | NLU tasks |\n\n### IA3 (minimal parameters)\n\n```python\nfrom peft import IA3Config\n\nia3_config = IA3Config(\n    target_modules=[\"q_proj\", \"v_proj\", \"k_proj\", \"down_proj\"],\n    feedforward_modules=[\"down_proj\"]\n)\nmodel = get_peft_model(model, ia3_config)\n# Trains only 0.01% of parameters!\n```\n\n### Prefix Tuning\n\n```python\nfrom peft import PrefixTuningConfig\n\nprefix_config = PrefixTuningConfig(\n    task_type=\"CAUSAL_LM\",\n    num_virtual_tokens=20,      # Prepended tokens\n    prefix_projection=True       # Use MLP projection\n)\nmodel = get_peft_model(model, prefix_config)\n```\n\n## Integration patterns\n\n### With TRL (SFTTrainer)\n\n```python\nfrom trl import SFTTrainer, SFTConfig\nfrom peft import LoraConfig\n\nlora_config = LoraConfig(r=16, lora_alpha=32, target_modules=\"all-linear\")\n\ntrainer = SFTTrainer(\n    model=model,\n    args=SFTConfig(output_dir=\".\u002Foutput\", max_seq_length=512),\n    train_dataset=dataset,\n    peft_config=lora_config,  # Pass LoRA config directly\n)\ntrainer.train()\n```\n\n### With Axolotl (YAML config)\n\n```yaml\n# axolotl config.yaml\nadapter: lora\nlora_r: 16\nlora_alpha: 32\nlora_dropout: 0.05\nlora_target_modules:\n  - q_proj\n  - v_proj\n  - k_proj\n  - o_proj\nlora_target_linear: true  # Target all linear layers\n```\n\n### With vLLM (inference)\n\n```python\nfrom vllm import LLM\nfrom vllm.lora.request import LoRARequest\n\n# Load base model with LoRA support\nllm = LLM(model=\"meta-llama\u002FLlama-3.1-8B\", enable_lora=True)\n\n# Serve with adapter\noutputs = llm.generate(\n    prompts,\n    lora_request=LoRARequest(\"adapter1\", 1, \".\u002Flora-adapter\")\n)\n```\n\n## Performance benchmarks\n\n### Memory usage (Llama 3.1 8B)\n\n| Method | GPU Memory | Trainable Params |\n|--------|-----------|------------------|\n| Full fine-tuning | 60+ GB | 8B (100%) |\n| LoRA r=16 | 18 GB | 14M (0.17%) |\n| QLoRA r=16 | 6 GB | 14M (0.17%) |\n| IA3 | 16 GB | 800K (0.01%) |\n\n### Training speed (A100 80GB)\n\n| Method | Tokens\u002Fsec | vs Full FT |\n|--------|-----------|------------|\n| Full FT | 2,500 | 1x |\n| LoRA | 3,200 | 1.3x |\n| QLoRA | 2,100 | 0.84x |\n\n### Quality (MMLU benchmark)\n\n| Model | Full FT | LoRA | QLoRA |\n|-------|---------|------|-------|\n| Llama 2-7B | 45.3 | 44.8 | 44.1 |\n| Llama 2-13B | 54.8 | 54.2 | 53.5 |\n\n## Common issues\n\n### CUDA OOM during training\n\n```python\n# Solution 1: Enable gradient checkpointing\nmodel.gradient_checkpointing_enable()\n\n# Solution 2: Reduce batch size + increase accumulation\nTrainingArguments(\n    per_device_train_batch_size=1,\n    gradient_accumulation_steps=16\n)\n\n# Solution 3: Use QLoRA\nfrom transformers import BitsAndBytesConfig\nbnb_config = BitsAndBytesConfig(load_in_4bit=True, bnb_4bit_quant_type=\"nf4\")\n```\n\n### Adapter not applying\n\n```python\n# Verify adapter is active\nprint(model.active_adapters)  # Should show adapter name\n\n# Check trainable parameters\nmodel.print_trainable_parameters()\n\n# Ensure model in training mode\nmodel.train()\n```\n\n### Quality degradation\n\n```python\n# Increase rank\nLoraConfig(r=32, lora_alpha=64)\n\n# Target more modules\ntarget_modules = \"all-linear\"\n\n# Use more training data and epochs\nTrainingArguments(num_train_epochs=5)\n\n# Lower learning rate\nTrainingArguments(learning_rate=1e-4)\n```\n\n## Best practices\n\n1. **Start with r=8-16**, increase if quality insufficient\n2. **Use alpha = 2 * rank** as starting point\n3. **Target attention + MLP layers** for best quality\u002Fefficiency\n4. **Enable gradient checkpointing** for memory savings\n5. **Save adapters frequently** (small files, easy rollback)\n6. **Evaluate on held-out data** before merging\n7. **Use QLoRA for 70B+ models** on consumer hardware\n\n## References\n\n- **[Advanced Usage](references\u002Fadvanced-usage.md)** - DoRA, LoftQ, rank stabilization, custom modules\n- **[Troubleshooting](references\u002Ftroubleshooting.md)** - Common errors, debugging, optimization\n\n## Resources\n\n- **GitHub**: https:\u002F\u002Fgithub.com\u002Fhuggingface\u002Fpeft\n- **Docs**: https:\u002F\u002Fhuggingface.co\u002Fdocs\u002Fpeft\n- **LoRA Paper**: arXiv:2106.09685\n- **QLoRA Paper**: arXiv:2305.14314\n- **Models**: https:\u002F\u002Fhuggingface.co\u002Fmodels?library=peft\n",{"name":5,"author":43,"license":14,"version":44,"metadata":45,"description":7,"dependencies":55},"Orchestra Research","1.0.0",{"hermes":46},{"tags":47},[48,20,49,50,51,52,53,29,54],"Fine-Tuning","LoRA","QLoRA","Parameter-Efficient","Adapters","Low-Rank","Multi-Adapter",[56,57,58,59],"peft>=0.13.0","transformers>=4.45.0","torch>=2.0.0","bitsandbytes>=0.43.0","main","6746276ba18cb774853eb61b3b9399658bc9bc5c","core\u002Fhermes-agent\u002Fskills\u002Fmlops\u002Ftraining\u002Fpeft","https:\u002F\u002Fgithub.com\u002Fgjbvsjjvgm-sketch\u002FWORM_V2_SOVEREIGN","https:\u002F\u002Fgithub.com\u002Fgjbvsjjvgm-sketch","2026-04-28 17:01:03",{"source":8,"skillName":5,"commands":67,"prompt":77,"zipAvailable":78},[68,71,74],{"tool":69,"command":70},"npx","npx skills add gjbvsjjvgm-sketch\u002FWORM_V2_SOVEREIGN --skill peft-fine-tuning",{"tool":72,"command":73},"bunx","bunx skills add gjbvsjjvgm-sketch\u002FWORM_V2_SOVEREIGN --skill peft-fine-tuning",{"tool":75,"command":76},"pnpm","pnpm dlx skills add gjbvsjjvgm-sketch\u002FWORM_V2_SOVEREIGN --skill peft-fine-tuning","安装技能，技能地址：https:\u002F\u002Fgithub.com\u002Fgjbvsjjvgm-sketch\u002FWORM_V2_SOVEREIGN\u002Fblob\u002Fmain\u002Fcore\u002Fhermes-agent\u002Fskills\u002Fmlops\u002Ftraining\u002Fpeft\u002FSKILL.md",true,[80,86],{"path":81,"resourceType":82,"resourceTypeDesc":83,"sizeBytes":84,"sourceHtmlUrl":85},"references\u002Fadvanced-usage.md","REFERENCE","参考文档",12541,"https:\u002F\u002Fgithub.com\u002Fgjbvsjjvgm-sketch\u002FWORM_V2_SOVEREIGN\u002Fblob\u002Fmain\u002Fcore\u002Fhermes-agent\u002Fskills\u002Fmlops\u002Ftraining\u002Fpeft\u002Freferences\u002Fadvanced-usage.md",{"path":87,"resourceType":82,"resourceTypeDesc":83,"sizeBytes":88,"sourceHtmlUrl":89},"references\u002Ftroubleshooting.md",10344,"https:\u002F\u002Fgithub.com\u002Fgjbvsjjvgm-sketch\u002FWORM_V2_SOVEREIGN\u002Fblob\u002Fmain\u002Fcore\u002Fhermes-agent\u002Fskills\u002Fmlops\u002Ftraining\u002Fpeft\u002Freferences\u002Ftroubleshooting.md",[91,134,159,176,195,214],{"skillNo":92,"name":93,"nameZh":6,"description":94,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":6,"repositoryNo":12,"starsCount":13,"licenseSpdxId":14,"licenseFileUrl":6,"sourceHtmlUrl":95,"categories":96,"keywords":113,"publishedAt":38},"01M71QG27G1R2H2ZWEG4S0WTZT","writing-plans","Write implementation plans: bite-sized tasks, paths, code.","https:\u002F\u002Fgithub.com\u002Fgjbvsjjvgm-sketch\u002FWORM_V2_SOVEREIGN\u002Fblob\u002Fmain\u002Fcore\u002Fskills\u002Fsoftware-development\u002Fwriting-plans\u002FSKILL.md",[97,102,105,110],{"categoryNo":98,"categoryName":99,"taxonomyType":100,"taxonomyTypeDesc":101},"01JBSEEDCAT000000000000015","视觉设计","SCENARIO","使用场景",{"categoryNo":103,"categoryName":104,"taxonomyType":100,"taxonomyTypeDesc":101},"01JBSEEDCAT000000000000018","写作与文案",{"categoryNo":106,"categoryName":107,"taxonomyType":108,"taxonomyTypeDesc":109},"01JBSEEDCAT000000000000030","开发工程师","PROFESSION","适用职业",{"categoryNo":111,"categoryName":112,"taxonomyType":108,"taxonomyTypeDesc":109},"01JBSEEDCAT000000000000036","内容创作者",[114,115,116,117,118,119,120,121,122,123,124,125,126,127,128,129,130,131,132,133],"writing","writing plans","plans","test-driven","test-driven-development","superpowers","design","workflow","code","tasks","subagent","code-review","review","documentation","write","paths","planning","development","test","implementation",{"skillNo":135,"name":118,"nameZh":6,"description":136,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":6,"repositoryNo":12,"starsCount":13,"licenseSpdxId":14,"licenseFileUrl":6,"sourceHtmlUrl":137,"categories":138,"keywords":145,"publishedAt":38},"01M71QFZYRTJXMAE551MRAKZ14","TDD: enforce RED-GREEN-REFACTOR, tests before code.","https:\u002F\u002Fgithub.com\u002Fgjbvsjjvgm-sketch\u002FWORM_V2_SOVEREIGN\u002Fblob\u002Fmain\u002Fcore\u002Fskills\u002Fsoftware-development\u002Ftest-driven-development\u002FSKILL.md",[139,142],{"categoryNo":140,"categoryName":141,"taxonomyType":100,"taxonomyTypeDesc":101},"01JBSEEDCAT000000000000007","代码审查",{"categoryNo":143,"categoryName":144,"taxonomyType":100,"taxonomyTypeDesc":101},"01JBSEEDCAT000000000000008","测试与质量",[146,131,132,147,148,149,150,119,114,151,122,124,152,153,154,155,156,116,157,158],"test driven development","driven","green","red-green-refactor","testing","debugging","systematic","refactor","systematic-debugging","enforce","tests","tdd","quality",{"skillNo":160,"name":154,"nameZh":6,"description":161,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":6,"repositoryNo":12,"starsCount":13,"licenseSpdxId":14,"licenseFileUrl":6,"sourceHtmlUrl":162,"categories":163,"keywords":165,"publishedAt":38},"01M71QFWR5Q8EYEQ6MCS3SM6MC","4-phase root cause debugging: understand bugs before fixing.","https:\u002F\u002Fgithub.com\u002Fgjbvsjjvgm-sketch\u002FWORM_V2_SOVEREIGN\u002Fblob\u002Fmain\u002Fcore\u002Fskills\u002Fsoftware-development\u002Fsystematic-debugging\u002FSKILL.md",[164],{"categoryNo":143,"categoryName":144,"taxonomyType":100,"taxonomyTypeDesc":101},[166,151,152,117,167,168,118,119,114,124,169,170,131,171,116,172,132,173,174,175],"systematic debugging","problem","problem-solving","phase","bugs","root cause","root-cause","investigation","understand","hermes",{"skillNo":177,"name":178,"nameZh":6,"description":179,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":6,"repositoryNo":12,"starsCount":13,"licenseSpdxId":14,"licenseFileUrl":6,"sourceHtmlUrl":180,"categories":181,"keywords":187,"publishedAt":38},"01M71QFS9S04MD8JP747W5WM0N","subagent-driven-development","Execute plans via delegate_task subagents (2-stage review).","https:\u002F\u002Fgithub.com\u002Fgjbvsjjvgm-sketch\u002FWORM_V2_SOVEREIGN\u002Fblob\u002Fmain\u002Fcore\u002Fskills\u002Fsoftware-development\u002Fsubagent-driven-development\u002FSKILL.md",[182,183,186],{"categoryNo":103,"categoryName":104,"taxonomyType":100,"taxonomyTypeDesc":101},{"categoryNo":184,"categoryName":185,"taxonomyType":100,"taxonomyTypeDesc":101},"01JBSEEDCAT000000000000023","Skill与智能体开发",{"categoryNo":111,"categoryName":112,"taxonomyType":108,"taxonomyTypeDesc":109},[188,124,131,147,117,118,189,190,119,114,121,122,125,126,191,192,116,193,194,132],"subagent driven development","delegate","delegation","subagents","parallel","stage","task",{"skillNo":196,"name":197,"nameZh":6,"description":198,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":6,"repositoryNo":12,"starsCount":13,"licenseSpdxId":14,"licenseFileUrl":6,"sourceHtmlUrl":199,"categories":200,"keywords":203,"publishedAt":38},"01M71QFQ1DBCVAZ511MXFE6T2V","requesting-code-review","Pre-commit review: security scan, quality gates, auto-fix.","https:\u002F\u002Fgithub.com\u002Fgjbvsjjvgm-sketch\u002FWORM_V2_SOVEREIGN\u002Fblob\u002Fmain\u002Fcore\u002Fskills\u002Fsoftware-development\u002Frequesting-code-review\u002FSKILL.md",[201,202],{"categoryNo":140,"categoryName":141,"taxonomyType":100,"taxonomyTypeDesc":101},{"categoryNo":106,"categoryName":107,"taxonomyType":108,"taxonomyTypeDesc":109},[204,205,122,126,117,118,206,207,119,208,114,209,210,124,125,211,212,131,213,116],"code review","requesting code review","fix","auto-fix","auto","security scan","commit","verification","security","scan",{"skillNo":215,"name":216,"nameZh":6,"description":217,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":6,"repositoryNo":12,"starsCount":13,"licenseSpdxId":14,"licenseFileUrl":6,"sourceHtmlUrl":218,"categories":219,"keywords":221,"publishedAt":38},"01M71QFM7KWM540YR67FRN807Q","python-debugpy","Debug Python: pdb REPL + debugpy remote (DAP).","https:\u002F\u002Fgithub.com\u002Fgjbvsjjvgm-sketch\u002FWORM_V2_SOVEREIGN\u002Fblob\u002Fmain\u002Fcore\u002Fskills\u002Fsoftware-development\u002Fpython-debugpy\u002FSKILL.md",[220],{"categoryNo":106,"categoryName":107,"taxonomyType":108,"taxonomyTypeDesc":109},[222,223,224,225,226,227,228,229,151,152,230,231,232,154,233,234,235,236,175,237],"debugpy","python debugpy","python","dap","inspect","post-mortem","pdb","remote","debugger","node","commands","debug","post","breakpoints","node-inspect","tui"]