[{"data":1,"prerenderedAt":-1},["ShallowReactive",2],{"skill:01M7CKE5F16R2FWT00WH99SWC1":3,"skill-same:01M7CKE5F16R2FWT00WH99SWC1":73},{"skillNo":4,"name":5,"nameZh":6,"description":7,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":12,"repositoryNo":13,"starsCount":14,"licenseSpdxId":15,"licenseFileUrl":6,"sourceHtmlUrl":16,"categories":17,"keywords":18,"publishedAt":19,"linkOnly":20,"markdownContent":21,"markdownBody":22,"frontMatter":23,"refName":41,"commitSha":42,"skillDirectory":43,"forksCount":44,"repositoryHtmlUrl":45,"repositoryHomepageUrl":6,"ownerHtmlUrl":46,"ownerBlogUrl":6,"ownerDescription":47,"updatedAt":48,"install":49,"resources":62},"01M7CKE5F16R2FWT00WH99SWC1","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.","Carchaloneo22\u002FClaude-Code-template","Carchaloneo22","https:\u002F\u002Favatars.githubusercontent.com\u002Fu\u002F159488757?v=4","01M7CK5MQXAFZE3W7SAP69KNYR","Carlos Chaparro","01M7CK5MRFE26CDPEQDN5RSQPK",2,"MIT","https:\u002F\u002Fgithub.com\u002FCarchaloneo22\u002FClaude-Code-template\u002Fblob\u002Fadd-x-twitter-scraper-skill\u002Fcli-tool\u002Fcomponents\u002Fskills\u002Fai-research\u002Ffine-tuning-peft\u002FSKILL.md",[],[],"2026-11-15 14:19:17",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\ntags: [Fine-Tuning, PEFT, LoRA, QLoRA, Parameter-Efficient, Adapters, Low-Rank, Memory Optimization, Multi-Adapter]\ndependencies: [peft>=0.13.0, transformers>=4.45.0, torch>=2.0.0, bitsandbytes>=0.43.0]\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,"tags":24,"author":34,"license":15,"version":35,"description":7,"dependencies":36},[25,26,27,28,29,30,31,32,33],"Fine-Tuning","PEFT","LoRA","QLoRA","Parameter-Efficient","Adapters","Low-Rank","Memory Optimization","Multi-Adapter","Orchestra Research","1.0.0",[37,38,39,40],"peft>=0.13.0","transformers>=4.45.0","torch>=2.0.0","bitsandbytes>=0.43.0","add-x-twitter-scraper-skill","7bc347b2f7dc2dde2761a965585925e0d0171748","cli-tool\u002Fcomponents\u002Fskills\u002Fai-research\u002Ffine-tuning-peft",0,"https:\u002F\u002Fgithub.com\u002FCarchaloneo22\u002FClaude-Code-template","https:\u002F\u002Fgithub.com\u002FCarchaloneo22","Ingeniero Informático | Ingeniero en Desarrollo de Software | Consultor TIC en Gestión Publica | Docente Análisis y Desarrollo de Software. ","2026-09-12 11:10:56",{"source":8,"skillName":5,"commands":50,"prompt":60,"zipAvailable":61},[51,54,57],{"tool":52,"command":53},"npx","npx skills add Carchaloneo22\u002FClaude-Code-template --skill peft-fine-tuning",{"tool":55,"command":56},"bunx","bunx skills add Carchaloneo22\u002FClaude-Code-template --skill peft-fine-tuning",{"tool":58,"command":59},"pnpm","pnpm dlx skills add Carchaloneo22\u002FClaude-Code-template --skill peft-fine-tuning","安装技能，技能地址：https:\u002F\u002Fgithub.com\u002FCarchaloneo22\u002FClaude-Code-template\u002Fblob\u002Fadd-x-twitter-scraper-skill\u002Fcli-tool\u002Fcomponents\u002Fskills\u002Fai-research\u002Ffine-tuning-peft\u002FSKILL.md",true,[63,69],{"path":64,"resourceType":65,"resourceTypeDesc":66,"sizeBytes":67,"sourceHtmlUrl":68},"references\u002Fadvanced-usage.md","REFERENCE","参考文档",12541,"https:\u002F\u002Fgithub.com\u002FCarchaloneo22\u002FClaude-Code-template\u002Fblob\u002Fadd-x-twitter-scraper-skill\u002Fcli-tool\u002Fcomponents\u002Fskills\u002Fai-research\u002Ffine-tuning-peft\u002Freferences\u002Fadvanced-usage.md",{"path":70,"resourceType":65,"resourceTypeDesc":66,"sizeBytes":71,"sourceHtmlUrl":72},"references\u002Ftroubleshooting.md",10344,"https:\u002F\u002Fgithub.com\u002FCarchaloneo22\u002FClaude-Code-template\u002Fblob\u002Fadd-x-twitter-scraper-skill\u002Fcli-tool\u002Fcomponents\u002Fskills\u002Fai-research\u002Ffine-tuning-peft\u002Freferences\u002Ftroubleshooting.md",[74,81,90,97,104,111],{"skillNo":75,"name":76,"nameZh":6,"description":77,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":12,"repositoryNo":13,"starsCount":14,"licenseSpdxId":15,"licenseFileUrl":6,"sourceHtmlUrl":78,"categories":79,"keywords":80,"publishedAt":19},"01M7CPQFVGKX7H3Q5Y9CN0XAZN","zapier-make-patterns","No-code automation democratizes workflow building. Zapier and Make (formerly Integromat) let non-developers automate business processes without writing code. But no-code doesn't mean no-complexity - these platforms have their own patterns, pitfalls, and breaking points.  This skill covers when to use which platform, how to build reliable automations, and when to graduate to code-based solutions. Key insight: Zapier optimizes for simplicity and integrations (7000+ apps), Make optimizes for power","https:\u002F\u002Fgithub.com\u002FCarchaloneo22\u002FClaude-Code-template\u002Fblob\u002Fadd-x-twitter-scraper-skill\u002Fcli-tool\u002Fcomponents\u002Fskills\u002Fworkflow-automation\u002Fzapier-make-patterns\u002FSKILL.md",[],[],{"skillNo":82,"name":83,"nameZh":6,"description":84,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":12,"repositoryNo":13,"starsCount":14,"licenseSpdxId":85,"licenseFileUrl":86,"sourceHtmlUrl":87,"categories":88,"keywords":89,"publishedAt":19},"01M7CPQDR2HMKAYHAAY99EA4B2","yeet","Use only when the user explicitly asks to stage, commit, push, and open a GitHub pull request in one flow using the GitHub CLI (`gh`).","Apache-2.0","https:\u002F\u002Fgithub.com\u002FCarchaloneo22\u002FClaude-Code-template\u002Fblob\u002Fadd-x-twitter-scraper-skill\u002Fcli-tool\u002Fcomponents\u002Fskills\u002Fworkflow-automation\u002Fyeet\u002FLICENSE.txt","https:\u002F\u002Fgithub.com\u002FCarchaloneo22\u002FClaude-Code-template\u002Fblob\u002Fadd-x-twitter-scraper-skill\u002Fcli-tool\u002Fcomponents\u002Fskills\u002Fworkflow-automation\u002Fyeet\u002FSKILL.md",[],[],{"skillNo":91,"name":92,"nameZh":6,"description":93,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":12,"repositoryNo":13,"starsCount":14,"licenseSpdxId":15,"licenseFileUrl":6,"sourceHtmlUrl":94,"categories":95,"keywords":96,"publishedAt":19},"01M7CPQ7K5MAQSXEB027HZFM2G","workflow-automation","Workflow automation is the infrastructure that makes AI agents reliable. Without durable execution, a network hiccup during a 10-step payment flow means lost money and angry customers. With it, workflows resume exactly where they left off.  This skill covers the platforms (n8n, Temporal, Inngest) and patterns (sequential, parallel, orchestrator-worker) that turn brittle scripts into production-grade automation.  Key insight: The platforms make different tradeoffs. n8n optimizes for accessibility","https:\u002F\u002Fgithub.com\u002FCarchaloneo22\u002FClaude-Code-template\u002Fblob\u002Fadd-x-twitter-scraper-skill\u002Fcli-tool\u002Fcomponents\u002Fskills\u002Fworkflow-automation\u002Fworkflow-automation\u002FSKILL.md",[],[],{"skillNo":98,"name":99,"nameZh":6,"description":100,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":12,"repositoryNo":13,"starsCount":14,"licenseSpdxId":15,"licenseFileUrl":6,"sourceHtmlUrl":101,"categories":102,"keywords":103,"publishedAt":19},"01M7CPQ34F18JHMEM8NHQS1N7K","trigger-dev","Trigger.dev expert for background jobs, AI workflows, and reliable async execution with excellent developer experience and TypeScript-first design. Use when: trigger.dev, trigger dev, background task, ai background job, long running task.","https:\u002F\u002Fgithub.com\u002FCarchaloneo22\u002FClaude-Code-template\u002Fblob\u002Fadd-x-twitter-scraper-skill\u002Fcli-tool\u002Fcomponents\u002Fskills\u002Fworkflow-automation\u002Ftrigger-dev\u002FSKILL.md",[],[],{"skillNo":105,"name":106,"nameZh":6,"description":107,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":12,"repositoryNo":13,"starsCount":14,"licenseSpdxId":15,"licenseFileUrl":6,"sourceHtmlUrl":108,"categories":109,"keywords":110,"publishedAt":19},"01M7CPPZSXXDB1SAWT5N63ACZT","planning-with-files","Transforms workflow to use Manus-style persistent markdown files for planning, progress tracking, and knowledge storage. Use when starting complex tasks, multi-step projects, research tasks, or when the user mentions planning, organizing work, tracking progress, or wants structured output.","https:\u002F\u002Fgithub.com\u002FCarchaloneo22\u002FClaude-Code-template\u002Fblob\u002Fadd-x-twitter-scraper-skill\u002Fcli-tool\u002Fcomponents\u002Fskills\u002Fworkflow-automation\u002Fplanning-with-files\u002FSKILL.md",[],[],{"skillNo":112,"name":113,"nameZh":6,"description":114,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":12,"repositoryNo":13,"starsCount":14,"licenseSpdxId":15,"licenseFileUrl":6,"sourceHtmlUrl":115,"categories":116,"keywords":117,"publishedAt":19},"01M7CPPTQSBVWSK0R10FJNMP0F","n8n-workflow-patterns","Proven workflow architectural patterns from real n8n workflows. Use when building new workflows, designing workflow structure, choosing workflow patterns, planning workflow architecture, or asking about webhook processing, HTTP API integration, database operations, AI agent workflows, or scheduled tasks.","https:\u002F\u002Fgithub.com\u002FCarchaloneo22\u002FClaude-Code-template\u002Fblob\u002Fadd-x-twitter-scraper-skill\u002Fcli-tool\u002Fcomponents\u002Fskills\u002Fworkflow-automation\u002Fn8n\u002Fn8n-workflow-patterns\u002FSKILL.md",[],[]]