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

A Generalized Low-Rank Adaptation (GLoRA) é um método PEFT que generaliza o LoRA e abordagens relacionadas. A GLoRA decompõe as atualizações em caminhos configuráveis (A, B, C, D, E), nos quais cada caminho pode usar parametrização de baixo posto, vetorial, constante ou desabilitada, dependendo do caminho.

Cada caminho suporta um dos quatro modos de parametrização. Eles equilibram a quantidade de parâmetros em relação à expressividade (o quão rica a atualização pode ser):

"lora": decomposição de baixo posto (como o LoRA padrão). Usa r * (out + in) parâmetros e pode expressar correções de posto r. A mais expressiva, com mais parâmetros.
"vector": Um único vetor (por exemplo, forma (out, 1)), transmitido para toda a matriz. Usa O(out) parâmetros; apenas escalonamento ou deslocamento por canal.
"constant": Um único escalar compartilhado entre todos os elementos. Usa 1 parâmetro; a opção menos expressiva entre as treináveis.
"none": Zeros sem parâmetros treináveis; desativa completamente esse caminho.

Nem todo caminho aceita todos os modos (por exemplo, config_D_E não suporta "lora"). Escolher "lora" em mais caminhos aumenta a capacidade e os parâmetros treináveis; "vector", "constant" ou "none" reduzem ambos.

O GLoRA é especialmente útil para pesquisa e aplicações avançadas em que você deseja experimentar padrões de atualização estruturados e combinar múltiplos mecanismos de adaptação em uma única camada.

Em alto nível, o GLoRA modifica uma camada linear congelada com: $W_{\mathrm{eff}} = W_0 + W_0 \odot A + B$ $b_{\mathrm{eff}} = b_0 + b_0 \odot D + E + W_0 C$

onde cada caminho é parametrizado de forma independente.

GloraConfig

classe 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) — Rank da decomposição de baixo rank usada quando uma configuração é definida como lora.
target_modules (Optional[Union[List[str], str]]) — Os nomes dos módulos aos quais aplicar a Glora.
config_A_B (str) — Parametrização para as matrizes A e B (correções multiplicativas e aditivas de peso). Valores válidos: lora, vector, constant, none.
config_C (str) — Parametrização para a matriz C (acoplamento peso-para-bias: b += W0 @ C). Valores válidos: lora, vector, none.
config_D_E (str) — Parametrização para os escalares D e E (correções multiplicativas e aditivas de viés). Não suporta lora, pois D e E são vetores do tamanho do viés, não matrizes. Valores válidos: vector, constant, none.
init_weights (bool) — Se True (padrão), inicializa o GLoRA como uma operação nula (zeros). Se False, usa inicialização kaiming para que o adaptador não seja uma operação nula.

Esta é a classe de configuração para armazenar a configuração de um GloraModel.

Glora modifica uma camada linear congelada W0 como: W_eff = W0 + W0 * A + B e b_eff = b0 + b0 * D + E + W0 @ C.

Cada matriz (A, B, C, D, E) pode ser parametrizada de forma independente. Os valores de configuração controlam quantos parâmetros são usados e quais formas eles podem expressar:

lora: decomposição de baixo posto Xd @ Xu com formas (out, r) e (r, in). Usa r * (out + in) parâmetros e pode expressar qualquer correção de posto r. Assim como o LoRA padrão.
vector: Um vetor de coluna único de forma (out, 1), transmitido para toda a matriz. Usa out parâmetros; apenas escalonamento ou deslocamento por canal de saída.
constant: Um único escalar compartilhado entre todos os elementos. Usa 1 parâmetro; mais restrito.
none: Zeros, sem parâmetros treináveis. Desativa efetivamente este caminho.

Principais Opções de Configuração

r: Rank usado quando um caminho é configurado como "lora" (padrão: 8).
target_modules: Lista ou regex dos nomes dos módulos a adaptar (por exemplo, ["q_proj", "v_proj"]).
config_A_B: Tipo de caminho para A e B (“lora”, “vector”, “constant”, “none”).
config_C: Tipo de caminho para C (“lora”, “vector”, “none”).
config_D_E: Tipo de caminho para D e E (“constant”, “vector”, “none”).
bias: Tratamento de viés ("none", "all" ou "glora_only").
init_weights: Se True (padrão), o GLoRA é inicializado como uma operação nula. Se False, usa inicialização kaiming.

Observações:

config_D_E não suporta "lora".
target_modules pode ser omitido para os tipos de modelo suportados (os mapeamentos padrão do PEFT são usados).

GloraModel

classe 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 )

Cria um modelo Generalized Low Rank Adapter (GLoRA) a partir de um modelo transformers pré-treinado.

Envolve um modelo base e injeta adaptadores GLoRA nos módulos especificados.
Suporta múltiplos adaptadores, troca de adaptadores, mesclagem/desmesclagem e inferência em lotes mistos.
Use set_adapter, merge_and_unload e métodos relacionados para gerenciar adaptadores.

GloraLayer e GloraLinear

classe peft.tuners.glora.GloraLayer

< source >

( base_layer: nn.Module**kwargs )

classe peft.tuners.glora.GloraLinear

< source >

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

Adaptador GLoRA envolvendo uma camada base base_layer densa ~torch.nn.Linear.

GloraLayer é a lógica central para a adaptação de baixo posto generalizada, suportando múltiplos adaptadores e configurações de caminho flexíveis.
GloraLinear é uma substituição direta para nn.Linear com suporte a GLoRA.
O GLoRA atualmente suporta camadas base torch.nn.Linear simples.

Exemplo 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()

Observações

GLoRA é um superconjunto do LoRA: definir todos os caminhos como “lora” recupera o LoRA padrão.
Você pode usar diferentes tipos de caminho para A/B/C/D/E para experimentar novas estratégias de adaptação.
O GLoRA suporta todos os recursos padrão de gerenciamento de adaptadores PEFT (adicionar, excluir, alternar, mesclar, etc.).

Veja também

Update on GitHub

←FRoD GraLoRA→