PEFT

You are viewing main version, which requires installation from source. If you'd like regular pip install, checkout the latest stable version (v0.21.0).

Join the Hugging Face community

and get access to the augmented documentation experience

Collaborate on models, datasets and Spaces

Faster examples with accelerated inference

Switch between documentation themes

to get started

GLoRA

La Adaptación de Bajo Rango Generalizada (GLoRA) es un método PEFT que generaliza LoRA y enfoques relacionados. GLoRA descompone las actualizaciones en rutas configurables (A, B, C, D, E), donde cada ruta puede utilizar una parametrización de bajo rango, vectorial, constante o deshabilitada, según la ruta.

Cada ruta admite uno de los cuatro modos de parametrización. Estos equilibran el número de parámetros frente a la expresividad (qué tan rica puede ser la actualización):

"lora": Descomposición de bajo rango (como LoRA estándar). Utiliza r * (out + in) parámetros y puede expresar correcciones de rango r. Es la más expresiva y la que más parámetros utiliza.
"vector": Un vector único (p. ej., forma (out, 1)), transmitido a lo largo de la matriz. Utiliza O(out) parámetros; solo escalado o desplazamiento por canal.
"constant": Un único escalar compartido entre todos los elementos. Utiliza 1 parámetro; es la opción menos expresiva entre las opciones entrenables.
"none": Ceros sin parámetros entrenables; deshabilita esa ruta por completo.

No todos los caminos aceptan todos los modos (por ejemplo, config_D_E no admite "lora"). Elegir "lora" en más caminos aumenta la capacidad y los parámetros entrenables; "vector", "constant" o "none" reducen ambos.

GLoRA es especialmente útil para investigación y aplicaciones avanzadas en las que se desea experimentar con patrones de actualización estructurados y combinar múltiples mecanismos de adaptación en una sola capa.

A alto nivel, GLoRA modifica una capa lineal congelada con: $W_{\mathrm{eff}} = W_0 + W_0 \odot A + B$ $b_{\mathrm{eff}} = b_0 + b_0 \odot D + E + W_0 C$

donde cada ruta se parametriza de forma independiente.

GloraConfig

clase peft.GloraConfig

< source >

( task_type: Optional[Union[str, TaskType]] = Nonepeft_type: Optional[Union[str, PeftType]] = Noneauto_mapping: Optional[dict] = Nonepeft_version: Optional[str] = Nonebase_model_name_or_path: Optional[str] = Nonerevision: Optional[str] = Noneinference_mode: bool = Falser: int = 8target_modules: list[str] | str | None = Nonebias: str = 'none'modules_to_save: list[str] | None = Noneconfig_A_B: typing.Literal['lora', 'vector', 'constant', 'none'] = 'lora'config_C: typing.Literal['lora', 'vector', 'none'] = 'lora'config_D_E: typing.Literal['vector', 'constant', 'none'] = 'constant'init_weights: bool = True )

Parámetros

r (int) — Rango de la descomposición de bajo rango utilizada cuando una configuración se establece en lora.
target_modules (Optional[Union[List[str], str]]) — Los nombres de los módulos a los que se aplicará Glora.
config_A_B (str) — Parametrización para las matrices A y B (correcciones multiplicativas y aditivas de peso). Valores válidos: lora, vector, constant, none.
config_C (str) — Parametrización para la matriz C (acoplamiento de peso a sesgo: b += W0 @ C). Valores válidos: lora, vector, none.
config_D_E (str) — Parametrización para los escalares D y E (correcciones multiplicativas y aditivas de sesgo). No admite lora ya que D y E son vectores del tamaño del sesgo, no matrices. Valores válidos: vector, constant, none.
init_weights (bool) — Si es True (por defecto), inicializa GLoRA como una operación nula (ceros). Si es False, usa la inicialización de kaiming para que el adaptador no sea una operación nula.

Esta es la clase de configuración para almacenar la configuración de un GloraModel.

Glora modifica una capa lineal congelada W0 de la siguiente manera: W_eff = W0 + W0 * A + B y b_eff = b0 + b0 * D + E + W0 @ C.

Cada matriz (A, B, C, D, E) puede parametrizarse de forma independiente. Los valores de la configuración controlan cuántos parámetros se utilizan y qué formas pueden expresar:

lora: Descomposición de bajo rango Xd @ Xu con formas (out, r) y (r, in). Utiliza r * (out + in) parámetros y puede expresar cualquier corrección de rango r. Igual que el LoRA estándar.
vector: un vector de columna de forma (out, 1), que se difunde en toda la matriz. Utiliza out parámetros; solo realiza escalado o desplazamiento por canal de salida.
constant: Un único escalar compartido entre todos los elementos. Utiliza 1 parámetro; es el más restrictivo.
none: Ceros, sin parámetros entrenables. Desactiva efectivamente esta ruta.

Opciones de configuración clave

r: Rango utilizado cuando una ruta se configura como "lora" (predeterminado: 8).
target_modules: Lista o expresión regular de nombres de módulos para adaptar (p. ej., ["q_proj", "v_proj"]).
config_A_B: Tipo de ruta para A y B (“lora”, “vector”, “constant”, “none”).
config_C: Tipo de ruta para C (“lora”, “vector”, “none”).
config_D_E: Tipo de ruta para D y E (“constant”, “vector”, “none”).
bias: Manejo del sesgo ("none", "all" o "glora_only").
init_weights: Si es True (valor predeterminado), GLoRA se inicializa como una operación sin efecto. Si es False, se utiliza la inicialización de kaiming.

Notas:

config_D_E no admite "lora".
target_modules se puede omitir para los tipos de modelo compatibles (se usan las mapeaciones predeterminadas de PEFT).

GloraModel

clase peft.GloraModel

< source >

( modelpeft_config: Union[PeftConfig, dict[str, PeftConfig]]adapter_name: strlow_cpu_mem_usage: bool = Falsestate_dict: Optional[dict[str, torch.Tensor]] = None )

Crea un modelo Generalized Low Rank Adapter (GLoRA) a partir de un modelo de transformers preentrenado.

Envuelve un modelo base e inyecta adaptadores GLoRA en los módulos especificados.
Admite múltiples adaptadores, cambio de adaptadores, fusión/desfusión e inferencia con lotes mixtos.
Use set_adapter, merge_and_unload y métodos relacionados para la gestión de adaptadores.

GloraLayer y GloraLinear

clase peft.tuners.glora.GloraLayer

< source >

( base_layer: nn.Module**kwargs )

clase peft.tuners.glora.GloraLinear

< source >

( base_layer: nn.Moduleadapter_name: strconfig**kwargs )

Adaptador GLoRA que envuelve una base_layer densa ~torch.nn.Linear.

GloraLayer es la lógica central para la adaptación de bajo rango generalizada, con soporte para múltiples adaptadores y configuraciones de ruta flexibles.
GloraLinear es un reemplazo directo para nn.Linear con soporte para GLoRA.
GLoRA actualmente admite capas base torch.nn.Linear simples.

Ejemplo de uso

from transformers import AutoModelForCausalLM
from peft import GloraConfig, get_peft_model

model = AutoModelForCausalLM.from_pretrained("your-model-id")
glora_config = GloraConfig(
    r=8,
    target_modules=["q_proj", "v_proj"],
    config_A_B="lora",
    config_C="vector",
    config_D_E="constant",
    task_type="CAUSAL_LM",
)
model = get_peft_model(model, glora_config)
model.print_healthcheck()

# Switch adapters, merge, etc.
model.set_adapter("default")
model.merge_and_unload()

Notas

GLoRA es un superconjunto de LoRA: si se establecen todas las rutas en “lora”, se recupera el LoRA estándar.
Puede usar diferentes tipos de ruta para A/B/C/D/E para experimentar con nuevas estrategias de adaptación.
GLoRA admite todas las funciones estándar de gestión de adaptadores PEFT (agregar, eliminar, cambiar, fusionar, etc.).

Véase también

Update on GitHub

←FRoD GraLoRA→