PEFT documentation
TinyLoRA: Aprendendo a Raciocinar com 13 Parâmetros
TinyLoRA: Aprendendo a Raciocinar com 13 Parâmetros
TinyLoRA é uma técnica de ajuste fino extremamente eficiente em termos de parâmetros que se baseia na abordagem LoRA-XS, utilizando a decomposição SVD de pesos congelados e projetando um vetor treinável minúsculo através de tensores aleatórios fixos. Quando combinada com métodos de treinamento por aprendizado por reforço (RL), como o GRPO, o TinyLoRA pode alcançar um desempenho competitivo com apenas 1 a 13 parâmetros treináveis.
A principal inovação do TinyLoRA é substituir a matriz de baixo posto treinável R por uma soma ponderada de matrizes de projeção aleatória fixas: R = Σᵢ vᵢ Pᵢ, em que v ∈ R^u é um vetor treinável minúsculo de dimensão u e Pᵢ são matrizes aleatórias fixas. Isso reduz drasticamente o número de parâmetros treináveis, mantendo um desempenho competitivo.
TinyLoRA suporta a vinculação de pesos por meio do parâmetro weight_tying, uma proporção entre 0.0 e 1.0 que controla quantos módulos compartilham o mesmo vetor treinável v. Definir weight_tying=0.0 (o padrão) significa que não há compartilhamento, enquanto weight_tying=1.0 significa compartilhamento total entre todos os módulos-alvo — alcançando uma eficiência extrema de parâmetros com apenas um único vetor de u parâmetros treináveis para o modelo inteiro.
Ao salvar os parâmetros do adaptador, é possível evitar o armazenamento das matrizes de projeção aleatória definindo save_projection=False no TinyLoraConfig. Nesse caso, essas matrizes serão restauradas com base na semente aleatória fixa do argumento projection_seed. 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ê quiser garantir a reprodutibilidade, defina save_projection=True (que é o padrão).
O TinyLoRA possui atualmente as seguintes restrições:
- Somente as camadas
nn.Linear,nn.Embeddingetransformers.pytorch_utils.Conv1Dsão suportadas.
O resumo do artigo é:
Pesquisas recentes demonstraram que modelos de linguagem podem aprender a raciocinar, frequentemente por meio de aprendizado por reforço. Alguns trabalhos até treinam parametrizações de baixo posto para raciocínio, mas o LoRA convencional não consegue escalar abaixo da dimensão do modelo. Questionamos se mesmo o LoRA com rank=1 é necessário para aprender a raciocinar e propomos o TinyLoRA, um método para escalar adaptadores de baixo posto para tamanhos tão pequenos quanto um único parâmetro. Dentro da nossa nova parametrização, conseguimos treinar o tamanho de 8B parâmetros do Qwen2.5 até 91% de precisão no GSM8K com apenas 13 parâmetros treinados em bf16 (26 bytes no total). Descobrimos que essa tendência se mantém de forma geral: somos capazes de recuperar 90% das melhorias de desempenho enquanto treinamos 1000x menos parâmetros em uma suíte de benchmarks mais difíceis de aprendizado para raciocínio, como AIME, AMC e MATH500. Notavelmente, só conseguimos alcançar um desempenho tão forte com RL: modelos treinados usando SFT requerem atualizações 100-1000x maiores para atingir o mesmo desempenho.
Visão geral do benchmark
API
TinyLoraConfig
classe peft.TinyLoraConfig
< 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 = 2u: int = 64weight_tying: float = 0.0projection_seed: int = 42save_projection: bool = Trueinit_v_bound: float = 0.02target_modules: Optional[Union[list[str], str]] = Nonetinylora_dropout: float = 0.0fan_in_fan_out: bool = Falsebias: str = 'none'modules_to_save: Optional[list[str]] = Noneinit_weights: Union[bool, str] = Truelayers_to_transform: Optional[Union[list[int], int]] = Nonelayers_pattern: Optional[Union[list[str], str]] = None )
Parâmetros
- r (
int, opcional, padrão2) — Rango SVD para a decomposição congelada U, Sigma, V. O artigo recomenda r=2. - u (
int, opcional, padrão64) — Dimensão do vetor treinável por grupo. Isso controla a expressividade da adaptação. Pode ser tão baixo quanto 1-13 para eficiência extrema de parâmetros. - weight_tying (
float, opcional, padrão0.0) — Grau de vínculo de pesos entre os módulos de destino, como uma proporção entre 0.0 e 1.0. Controla quantos módulos compartilham o mesmo vetor treinável v. 0.0 significa nenhum compartilhamento (cada módulo tem seu próprio v). 1.0 significa compartilhamento total (todos os módulos compartilham um único v). Valores intermediários resultam em compartilhamento parcial. - projection_seed (
int, opcional, padrão42) — Semente aleatória para gerar as matrizes de projeção fixas P. - save_projection (
bool, opcional, padrãoTrue) — Se os tensores de projeção P devem ser salvos no state dict. Se False, eles serão regenerados a partir da seed ao carregar. - init_v_bound (
float, opcional, padrão0.02) — Limite de inicialização uniforme para o vetor treinável v. Os valores são inicializados em [-init_v_bound, init_v_bound]. - target_modules (
Union[List[str], str], opcional) — Os nomes dos módulos aos quais aplicar o TinyLoRA. Isso pode ser uma lista de nomes de módulos (por exemplo,['q_proj', 'v_proj']), um padrão de expressão regular (por exemplo,'.*decoder.*(q|v)_proj$') ou a palavra-chave especial"all-linear"para alvo todos os módulos lineares. Apenas camadasnn.Linear,nn.Embeddingetransformers.pytorch_utils.Conv1Dsão suportadas. - tinylora_dropout (
float, opcional, padrão0.0) — A probabilidade de dropout para as camadas TinyLoRA. - fan_in_fan_out (
bool, opcional, padrãoFalse) — 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). - bias (
str, opcional, padrão"none") — Tipo de viés para TinyLoRA. Pode ser ‘none’, ‘all’ ou ‘tinylora_only’. - modules_to_save (
List[str], opcional) — Lista de módulos, além das camadas TinyLoRA, que devem ser configurados como treináveis e salvos. - init_weights (
bool|Literal["uniform"], opcional, padrãoTrue) — Como inicializar o vetor treinável v. PassarTrue(padrão) inicializa v com zeros, tornando o adaptador uma operação nula (operação identidade). Passar"uniform"inicializa v com valores aleatórios uniformes em[-init_v_bound, init_v_bound]. PassarFalsedeixa v não inicializado (para casos de uso avançados). - layers_to_transform (
Union[List[int], int], opcional) — Os índices das camadas a serem transformadas. Se especificado, apenas essas camadas serão adaptadas. - layers_pattern (
Optional[Union[List[str], str]], opcional) — O nome do padrão de camada, usado apenas selayers_to_transformfor diferente deNone.
Esta é a classe de configuração para armazenar a configuração de um TinyLoraModel.
TinyLoRA é um método extremamente eficiente em termos de parâmetros para ajuste fino, baseado no artigo “Learning to Reason in 13 Parameters” (arXiv:2602.04118). Ele utiliza a decomposição SVD de pesos congelados e projeta um vetor treinável minúsculo através de tensores aleatórios fixos.
Artigo: https://arxiv.org/abs/2602.04118
Exemplo:
from peft import get_peft_model, TinyLoraConfig
config = TinyLoraConfig(
r=2, # SVD rank (paper recommends 2)
u=64, # Trainable vector dimension
weight_tying=0.0, # No weight tying (0.0 = none, 1.0 = full)
target_modules=["q_proj", "v_proj"],
projection_seed=42,
)
model = get_peft_model(base_model, config)TinyLoraModel
classe peft.TinyLoraModel
< source >( modelconfigadapter_namelow_cpu_mem_usage = False**kwargs ) → torch.nn.Module
Parâmetros
- model (PreTrainedModel) — O modelo a ser adaptado.
- config (TinyLoraConfig) — A configuração do modelo TinyLoRA.
- adapter_name (
str) — O nome do adaptador, padrão é"default". - low_cpu_mem_usage (
bool, opcional, padrãoFalse) — Cria pesos de adaptador vazios no dispositivo meta. Útil para acelerar o processo de carregamento.
Retorna
torch.nn.Module
O modelo TinyLoRA.
Cria um modelo TinyLoRA a partir de um modelo transformers pré-treinado.
TinyLoRA é um método extremamente eficiente em termos de parâmetros para ajuste fino que usa a decomposição SVD de pesos congelados e projeta um vetor treinável minúsculo através de tensores aleatórios fixos. Baseado no artigo “Learning to Reason in 13 Parameters” (arXiv:2602.04118).
Exemplo:
>>> from transformers import AutoModelForCausalLM
>>> from peft import TinyLoraConfig, get_peft_model
>>> base_model = AutoModelForCausalLM.from_pretrained("facebook/opt-125m")
>>> config = TinyLoraConfig(r=2, u=64, target_modules=["q_proj", "v_proj"])
>>> model = get_peft_model(base_model, config)Atributos:
- model (PreTrainedModel) — O modelo a ser adaptado.
- peft_config (TinyLoraConfig): A configuração do modelo TinyLoRA.
Excluir um adaptador e limpar os parâmetros compartilhados no nível do modelo.