PEFT documentation
PVeRA: Adaptação de Matriz Aleatória Baseada em Vetores Probabilísticos
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.Linearsã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
< 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 = 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ão256) — 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ão0.1) — Valor inicial para o vetorpvera_lambda_dusado 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 usaConv1D, que armazena os pesos como (fan_in, fan_out), e portanto este parâmetro deve ser definido comoTrue. - 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 selayers_to_transformfor diferente deNone. Isso deve apontar para onn.ModuleListdo modelo, que frequentemente é chamado de'layers'ou'h'. - sample_at_inference (
bool, padrãoFalse) — 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
< source >( 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 toFalse) — 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:
- model (PreTrainedModel) — O modelo a ser adaptado.
- peft_config (PveraConfig): A configuração do modelo PVeRA.