PEFT documentation

PVeRA: Adaptação de Matriz Aleatória Baseada em Vetores Probabilísticos

Hugging Face's logo
Join the Hugging Face community

and get access to the augmented documentation experience

to get started

PVeRA: Adaptação de Matriz Aleatória Baseada em Vetores Probabilísticos

PVeRA é uma técnica de ajuste fino eficiente em parâmetros baseada no VeRA, pertencente à família de adaptadores baseados em LoRA. Ela mantém o orçamento de parâmetros muito baixo do VeRA, mas aumenta o desempenho ao aprender uma distribuição de adaptações latentes. Isso também permite que modelos adaptados com PVeRA gerem estimativas de intervalos de confiança de Monte Carlo, amostrando da distribuição aprendida durante a inferência.

Ao salvar os parâmetros do adaptador, é possível evitar o armazenamento das matrizes de baixo rank definindo save_projection=False no PveraConfig. Nesse caso, essas matrizes serão restauradas com base na semente aleatória fixa do argumento projection_prng_key. Isso reduz o tamanho do checkpoint, mas não podemos garantir a reprodutibilidade em todos os dispositivos e para todas as versões futuras do PyTorch. Se você deseja garantir a reprodutibilidade, defina save_projection=True (que é o padrão).

Para lidar com diferentes formas das camadas adaptadas, o PVeRA inicializa as matrizes compartilhadas A e B com o maior tamanho necessário para cada dimensão. Durante a passagem para frente, as submatrizes A e B para uma camada dada são extraídas dessas matrizes compartilhadas e usadas conforme descrito no artigo. Por exemplo, adaptar duas camadas lineares de formas (100, 20) e (80, 50) criará matrizes A e B de formas (rank, 50) e (100, rank), respectivamente. Em seguida, para adaptar uma camada de forma (100, 20), submatrizes A e B de formas (rank, 20) e (100, rank) serão extraídas.

Atualmente, o PVeRA possui a seguinte restrição:

  • Apenas camadas nn.Linear são suportadas.
  • A representação latente não é facilmente acessível para o treinamento usando a divergência de KL.

O resumo do artigo é:

Grandes modelos de fundação surgiram nos últimos anos e estão expandindo os limites de desempenho para uma variedade de tarefas. Treinar ou até mesmo fazer o ajuste fino (finetuning) desses modelos exige grandes conjuntos de dados e recursos computacionais, que frequentemente são escassos e caros. Métodos de adaptação oferecem uma solução computacionalmente eficiente para lidar com essas limitações, permitindo que esses modelos sejam ajustados com pequenas quantidades de dados e poder computacional. Isso é alcançado ao adicionar novos módulos treináveis a espinhas dorsais (backbones) congeladas, contendo apenas uma fração dos parâmetros treináveis, e ajustando apenas esses módulos em novas tarefas. Recentemente, demonstrou-se que o adaptador VeRA se destaca em adaptações eficientes em parâmetros ao utilizar um par de matrizes aleatórias de baixo posto (low-rank) congeladas, compartilhadas entre todas as camadas. Neste artigo, propomos o PVeRA, uma versão probabilística do adaptador VeRA, que modifica as matrizes de baixo posto do VeRA de maneira probabilística. Essa modificação permite naturalmente lidar com ambiguidades inerentes na entrada e possibilita diferentes configurações de amostragem durante o treinamento e o teste. Uma avaliação abrangente foi realizada no benchmark VTAB-1k com sete adaptadores, e o PVeRA superou o VeRA e outros adaptadores.

Visão geral do benchmark

API

PveraConfig

classe peft.PveraConfig

< >

( 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 = 256target_modules: Optional[Union[list[str], str]] = Noneprojection_prng_key: int = 0save_projection: bool = Truepvera_dropout: float = 0.0d_initial: float = 0.1fan_in_fan_out: bool = Falsebias: str = 'none'modules_to_save: Optional[list[str]] = Noneinit_weights: bool = Truelayers_to_transform: Optional[Union[list[int], int]] = Nonelayers_pattern: Optional[Union[list[str], str]] = Nonesample_at_inference: bool = Falsegenerator_seed: Optional[int] = None )

Parâmetros

  • r (int, opcional, padrão 256) — Dimensão do parâmetro do PVeRA (“rank”). Escolha valores maiores que os ranks do LoRA aqui, pois o PVeRA compartilha parâmetros entre camadas e, portanto, usa muito menos parâmetros que o LoRA.
  • target_modules (Union[List[str], str]) — Os nomes dos módulos aos quais o PVeRA será aplicado. Somente camadas lineares são suportadas. Ao passar uma string, uma correspondência de regex será realizada. Se especificado como ‘all-linear’, todos os módulos lineares/Conv1D serão selecionados. Se não for especificado, os módulos serão escolhidos de acordo com a arquitetura do modelo. Se a arquitetura não for conhecida, um erro será lançado.
  • projection_prng_key (int) — Chave de inicialização do PRNG do PVeRA. Usada para inicializar pvera_A e pvera_B para novos modelos ou ao carregar um checkpoint que não incluía essas projeções. O valor padrão é 0.
  • save_projection (bool) — Se as projeções pvera_A / pvera_B devem ser salvas no state dict junto com os pesos lambda_b / lambda_d por camada. Isso aumentará o tamanho do checkpoint, mas garantirá que o checkpoint possa ser recarregado em todas as configurações de sistema. O valor padrão é True.
  • pvera_dropout (float) — A probabilidade de dropout para as camadas PVeRA.
  • d_initial (float, opcional, padrão 0.1) — Valor inicial para o vetor pvera_lambda_d usado na inicialização dos parâmetros do PVeRA. Valores pequenos (<=0.1) são recomendados.
  • fan_in_fan_out (bool) — Defina como True se a camada a ser substituída armazenar os pesos como (fan_in, fan_out). Por exemplo, o gpt-2 usa Conv1D, que armazena os pesos como (fan_in, fan_out), e portanto este parâmetro deve ser definido como True.
  • bias (str) — Tipo de viés para PVeRA. Pode ser ‘none’, ‘all’ ou ‘pvera_only’. Se for ‘all’ ou ‘pvera_only’, os vieses correspondentes serão atualizados durante o treinamento. Tenha em mente que isso significa que, mesmo ao desativar os adaptadores, o modelo não produzirá a mesma saída que o modelo base teria sem adaptação.
  • modules_to_save (List[str]) — Lista de módulos, além das camadas PVeRA, que devem ser configurados como treináveis e salvos no checkpoint final.
  • init_weights (bool) — Se as camadas PVeRA devem ter seus pesos inicializados com a inicialização padrão. Não altere esta configuração, a menos que saiba exatamente o que está fazendo.
  • layers_to_transform (Union[List[int],int]) — Os índices das camadas a serem transformadas. Se este argumento for especificado, as transformações PVeRA serão aplicadas aos índices das camadas especificados nesta lista. Se um único inteiro for passado, as transformações PVeRA serão aplicadas à camada neste índice.
  • layers_pattern (Optional[Union[List[str], str]]) — O nome do padrão de camadas, usado apenas se layers_to_transform for diferente de None. Isso deve apontar para o nn.ModuleList do modelo, que frequentemente é chamado de 'layers' ou 'h'.
  • sample_at_inference (bool, padrão False) — Se deve amostrar da distribuição PVeRA aprendida durante a inferência. Se False, a média aprendida é utilizada.
  • generator_seed (int, padrão None) — Semente aleatória para o gerador usado para amostrar da distribuição aprendida.

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

Artigo: https://www.arxiv.org/abs/2512.07703.

PveraModel

classe peft.PveraModel

< >

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

Parâmetros

  • model (PreTrainedModel) — O modelo a ser adaptado.
  • config (PveraConfig) — A configuração do modelo PVeRA.
  • adapter_name (str) — O nome do adaptador, padrão é "default".
  • low_cpu_mem_usage (bool, optional, defaults to False) — Cria pesos de adaptador vazios no dispositivo meta. Útil para acelerar o processo de carregamento.

Retorna

torch.nn.Module

O modelo PVeRA.

Cria um modelo de Probabilistic Vector-based Random Matrix Adaptation (PVeRA) a partir de um modelo de transformers pré-treinado.

Exemplo:

>>> from transformers import AutoModel
>>> from peft import PveraConfig, get_peft_model

>>> base_model = AutoModel.from_pretrained("facebook/dinov2-base")
>>> config = PveraConfig(r=128, sample_at_inference=False)
>>> model = get_peft_model(base_model, config)

Atributos:

Update on GitHub