tessl/pypi-peft

State-of-the-art Parameter-Efficient Fine-Tuning (PEFT) methods for efficiently adapting large pretrained models

—

Pending

Overview

Eval results

Files

Core Models

Name: tessl/pypi-peft
Author: tessl

Core PEFT model classes and the primary function for creating PEFT models. These provide the foundation for all parameter-efficient fine-tuning operations in the library.

Capabilities

Main PEFT Model Creation

The primary entry point for creating PEFT models by wrapping base transformers models with parameter-efficient adapters.

def get_peft_model(
    model: PreTrainedModel,
    peft_config: PeftConfig,
    adapter_name: str = "default",
    mixed: bool = False,
    autocast_adapter_dtype: bool = True,
    revision: Optional[str] = None,
    low_cpu_mem_usage: bool = False
) -> PeftModel | PeftMixedModel:
    """
    Returns a PEFT model object from a model and a config.
    
    Args:
        model: Base transformer model to be wrapped
        peft_config: Configuration object containing PEFT parameters
        adapter_name: Name of the adapter to be injected
        mixed: Whether to allow mixing different adapter types
        autocast_adapter_dtype: Whether to autocast adapter dtype
        revision: Revision of the base model
        low_cpu_mem_usage: Create empty adapter weights on meta device
    
    Returns:
        PEFT model with adapter capabilities
    """

Base PEFT Model

The foundational PEFT model class that wraps transformer models and provides adapter functionality.

class PeftModel(torch.nn.Module):
    """
    Base model encompassing various PEFT methods.
    
    Args:
        model: The base transformer model used for PEFT
        peft_config: The configuration of the PEFT model
        adapter_name: The name of the adapter
        autocast_adapter_dtype: Whether to autocast the adapter dtype
        low_cpu_mem_usage: Create empty adapter weights on meta device
    """
    def __init__(
        self,
        model,
        peft_config: PeftConfig,
        adapter_name: str = "default",
        autocast_adapter_dtype: bool = True,
        low_cpu_mem_usage: bool = False
    ): ...
    
    def forward(self, *args, **kwargs): ...
    
    def generate(self, **kwargs): ...
    
    def save_pretrained(
        self,
        save_directory: str,
        safe_serialization: bool = True,
        selected_adapters: Optional[List[str]] = None,
        **kwargs
    ): ...
    
    def load_adapter(
        self,
        model_id: str,
        adapter_name: str = "default",
        is_trainable: bool = True,
        **kwargs
    ): ...
    
    def set_adapter(self, adapter_name: str): ...
    
    def disable_adapter(self): ...
    
    def enable_adapter(self): ...
    
    def add_adapter(self, adapter_name: str, peft_config: PeftConfig): ...
    
    def delete_adapter(self, adapter_name: str): ...
    
    def merge_and_unload(self, progressbar: bool = False, safe_merge: bool = False): ...
    
    def unload(self): ...
    
    def print_trainable_parameters(self): ...

Task-Specific Model Classes

Specialized PEFT model classes for different NLP tasks, providing task-specific forward methods and outputs.

class PeftModelForCausalLM(PeftModel):
    """PEFT model for causal language modeling tasks."""
    def forward(
        self,
        input_ids=None,
        attention_mask=None,
        inputs_embeds=None,
        labels=None,
        output_attentions=None,
        output_hidden_states=None,
        return_dict=None,
        **kwargs
    ): ...

class PeftModelForSequenceClassification(PeftModel):
    """PEFT model for sequence classification tasks."""
    def forward(
        self,
        input_ids=None,
        attention_mask=None,
        inputs_embeds=None,
        labels=None,
        output_attentions=None,
        output_hidden_states=None,
        return_dict=None,
        **kwargs
    ) -> SequenceClassifierOutput: ...

class PeftModelForTokenClassification(PeftModel):
    """PEFT model for token classification tasks."""
    def forward(
        self,
        input_ids=None,
        attention_mask=None,
        inputs_embeds=None,
        labels=None,
        output_attentions=None,
        output_hidden_states=None,
        return_dict=None,
        **kwargs
    ) -> TokenClassifierOutput: ...

class PeftModelForQuestionAnswering(PeftModel):
    """PEFT model for question answering tasks."""
    def forward(
        self,
        input_ids=None,
        attention_mask=None,
        inputs_embeds=None,
        start_positions=None,
        end_positions=None,
        output_attentions=None,
        output_hidden_states=None,
        return_dict=None,
        **kwargs
    ) -> QuestionAnsweringModelOutput: ...

class PeftModelForSeq2SeqLM(PeftModel):
    """PEFT model for sequence-to-sequence language modeling tasks."""
    def forward(
        self,
        input_ids=None,
        attention_mask=None,
        inputs_embeds=None,
        decoder_input_ids=None,
        decoder_attention_mask=None,
        decoder_inputs_embeds=None,
        labels=None,
        output_attentions=None,
        output_hidden_states=None,
        return_dict=None,
        **kwargs
    ): ...

class PeftModelForFeatureExtraction(PeftModel):
    """PEFT model for feature extraction tasks."""
    def forward(
        self,
        input_ids=None,
        attention_mask=None,
        inputs_embeds=None,
        output_attentions=None,
        output_hidden_states=None,
        return_dict=None,
        **kwargs
    ): ...

Mixed Model Support

Support for combining multiple PEFT methods in a single model.

class PeftMixedModel(torch.nn.Module):
    """
    Model for combining multiple PEFT methods.
    
    Allows mixing different adapter types (e.g., LoRA + IA3) for enhanced
    parameter efficiency and task performance.
    """
    def __init__(
        self,
        model: PreTrainedModel,
        peft_config: dict,
        adapter_name: str = "default"
    ): ...
    
    def add_adapter(
        self,
        peft_config: PeftConfig,
        adapter_name: str
    ): ...
    
    def set_adapter(self, adapter_name: str): ...

Model State Management

Functions for managing model state, adapters, and layers.

def get_layer_status(model) -> dict:
    """
    Get the status of each layer in the model.
    
    Returns:
        Dictionary mapping layer names to their status information
    """

def get_model_status(model) -> dict:
    """
    Get comprehensive status information about the PEFT model.
    
    Returns:
        Model status including adapter information and layer states
    """

class PeftModelForFeatureExtraction(PeftModel): """PEFT model for feature extraction tasks.""" def forward( self, input_ids=None, attention_mask=None, inputs_embeds=None, output_attentions=None, output_hidden_states=None, return_dict=None, **kwargs ): ...

### Mixed Model Support

Support for combining multiple PEFT methods in a single model.

```python { .api }
class PeftMixedModel:
    """Model that supports mixing different PEFT methods."""
    def __init__(
        self,
        model,
        peft_config: PeftConfig,
        adapter_name: str = "default"
    ): ...
    
    def add_adapter(self, adapter_name: str, peft_config: PeftConfig): ...
    
    def set_adapter(self, adapter_name: str): ...

Model Status Functions

Utility functions for inspecting model and layer status.

def get_model_status(model) -> dict:
    """
    Get the status of the model including active adapters.
    
    Args:
        model: The PEFT model to inspect
        
    Returns:
        Dictionary containing model status information
    """

def get_layer_status(model, layer_name: str) -> dict:
    """
    Get the status of a specific layer.
    
    Args:
        model: The PEFT model to inspect
        layer_name: Name of the layer to inspect
        
    Returns:
        Dictionary containing layer status information
    """

Usage Examples

Basic Model Creation

from transformers import AutoModelForCausalLM
from peft import get_peft_model, LoraConfig

# Load base model
model = AutoModelForCausalLM.from_pretrained("gpt2")

# Create PEFT config
config = LoraConfig(
    task_type="CAUSAL_LM",
    r=16,
    lora_alpha=32,
    lora_dropout=0.1,
    target_modules=["c_attn", "c_proj"]
)

# Get PEFT model
peft_model = get_peft_model(model, config)

Adapter Management

# Save adapter
peft_model.save_pretrained("./my-adapter")

# Load additional adapter
peft_model.load_adapter("./another-adapter", adapter_name="task2")

# Switch between adapters
peft_model.set_adapter("task2")

# Disable all adapters
peft_model.disable_adapter()

# Enable adapters
peft_model.enable_adapter()

# Delete adapter
peft_model.delete_adapter("task2")

Model Merging and Unloading

# Merge adapter weights into base model and unload
merged_model = peft_model.merge_and_unload()

# Just unload adapters without merging
base_model = peft_model.unload()

Install with Tessl CLI