Hugging Face PEFT Library

PEFT models are designed to be fully compatible with the Hugging Face transformers ecosystem. A model wrapped with PEFT remains a standard PreTrainedModel subclass. This means you can use it with familiar pipelines like:

• The Trainer API for training
• Standard model.save_pretrained() and from_pretrained() for serialization
• Existing tokenizers and data collators
• The generate() method for text generation This deep integration ensures that existing training loops, evaluation scripts, and deployment pipelines require almost no modification.

The library's core function is to drastically reduce GPU memory requirements during fine-tuning. It achieves this by freezing the pre-trained model's weights and only optimizing a small set of adapter parameters. For instance, applying LoRA to a 7B parameter model might train only 0.1% of the total parameters (e.g., 4-8 million). This enables fine-tuning of very large models (10B+ parameters) on consumer-grade GPUs (e.g., a single 24GB VRAM card) that would otherwise be impossible with full fine-tuning, which requires enough memory to hold optimizer states for all parameters.

PEFT offers granular control over where adapter modules are injected into the base model architecture. Using configuration objects, you can specify:

• Target Modules: Which layers to adapt (e.g., query, value, dense layers in transformers).
• Rank/Bottleneck Size: The intrinsic dimension of low-rank updates (e.g., LoRA's r).
• Alpha Scaling: The scaling factor for the adapter output (e.g., LoRA's lora_alpha).
• Dropout: Regularization rates for adapter layers. This allows for strategic adaptation, such as applying LoRA only to the attention modules of a transformer, which are often the most task-specific components.

The library enables extremely compact model storage. When saving a PEFT model, only the small adapter weights (often just a few MBs) are saved, not the entire multi-GB base model. The base model is referenced by its Hugging Face model ID. For production inference, PEFT supports weight merging, where the trained adapter weights are analytically merged back into the base model weights. This creates a standalone model that runs at the same speed as the original base model, with no additional latency from adapter layers.

The library stays current with state-of-the-art research, providing implementations for advanced PEFT variants and specialized use cases:

• QLoRA: For fine-tuning quantized 4-bit models.
• Multi-Task & Sequential Learning: Loading and switching between multiple adapters for a single base model.
• Broad Model Support: Works with encoder models (BERT), decoder models (GPT, LLaMA), and encoder-decoder models (T5) from the transformers library.
• Custom Integration: Offers lower-level APIs for integrating new PEFT methods or applying adapters to custom model architectures.

TaskType is an enumeration used in PEFTConfig to specify the downstream task, which influences model head initialization and adapter placement.

• Common Types: SEQ_CLS (Sequence Classification), SEQ_2_SEQ_LM (Sequence-to-Sequence, e.g., T5), CAUSAL_LM (Causal Language Modeling, e.g., GPT), TOKEN_CLS (Token Classification).
• Purpose: Ensures the PeftModel wrapper and any task-specific heads are correctly configured for the intended use case, maintaining compatibility with Hugging Face Trainer.