LoLDU

Loldu: adaptação de baixo rank via decomposição mais baixa-dia-dia

O Loldu é uma técnica de ajuste fino (PEFT) eficiente em termos de ponta projetado para reduzir drasticamente o número de parâmetros treináveis, enquanto atinge os níveis de desempenho comparáveis ​​ao ajuste fino total. Este documento descreve as etapas necessárias para integrar o Loldu em seus projetos de maneira eficaz.

Para mais detalhes, consulte o artigo: https://arxiv.org/pdf/2410.13618

Índice

1. Instalação
2. Principais recursos
3. Início rápido
4. Referência da API
5. Exemplos de uso
6. Práticas recomendadas

Instalação

Para instalar o Loldu, basta usar o PIP:

git clone https://github.com/SKDDJ/LoLDU
cd LoLDU
pip install -e . 

Principais recursos

• Reduz significativamente o número de parâmetros treináveis ​​(até 2600 vezes menos que os métodos regulares de PEFT)
• Mantém o desempenho comparável ao ajuste fino completo
• Aproveita a decomposição de menor dia-dia (LDU) para uma convergência e ortogonalidade mais rápidas
• Concentra -se em otimizar a matriz diagonal para escalar transformações
• Compatível com várias arquiteturas modelo (por exemplo, llama2, roberta, vit, difusão estável)

Início rápido

Aqui está um exemplo rápido de como usar o Loldu:

 import torch
import torch . nn as nn
from functools import partial
from minloldu import LoLDUParametrization , add_loldu , get_loldu_params

# Define your model
model = YourModel ()

# Define LoLDU configuration
loldu_config = {
    nn . Linear : {
        "weight" : partial ( LoLDUParametrization . from_linear , rank = 15 ),
    },
}

# Add LoLDU to the model
add_loldu ( model , loldu_config = loldu_config )

# Freeze all parameters
for param in model . parameters ():
    param . requires_grad = False

# Enable gradients for LoLDU parameters
for param in get_loldu_params ( model ):
    param . requires_grad = True

# Now your model is ready for fine-tuning with LoLDU 

Referência da API

Funções principais

1. add_loldu(model, loldu_config)

   • Adiciona parametrização LOLDU ao modelo especificado.
   • model : o modelo Pytorch para modificar.
   • loldu_config : dicionário de configuração para loldu.

2. get_loldu_params(model, print_shapes=False)

   • Retorna os parâmetros Loldu do modelo.
   • model : O modelo Pytorch com Loldu.
   • print_shapes : se true, imprime as formas dos parâmetros LOLDU.

3. disable_loldu(model)

   • Desativa temporariamente Loldu no modelo.

4. enable_loldu(model)

   • Reinscitam Loldu no modelo após desativar.

5. remove_loldu(model)

   • Remove completamente Loldu do modelo.

6. merge_loldu(model)

   • Mescla os parâmetros LOLDU nos pesos do modelo original para inferência eficiente.

7. get_loldu_state_dict(model)

   • Retorna o dicionário estadual de parâmetros de Loldu para salvar.

Classe de Lolduparametrização

• LoLDUParametrization.from_linear(layer, rank)
  • Cria a parametrização Loldu para uma camada linear.
  • layer : a camada linear para parametrizar.
  • rank : a classificação da aproximação de baixa classificação.

Exemplos de uso

Adicionando Loldu a um modelo

 from minloldu import LoLDUParametrization , add_loldu
from functools import partial

class MyModel ( nn . Module ):
    def __init__ ( self ):
        super (). __init__ ()
        self . model = nn . Sequential (
            nn . Linear ( in_features = 15 , out_features = 15 ),
        )
    def forward ( self , x ):
        return self . model ( x )

model = MyModel ()

loldu_config = {
    nn . Linear : {
        "weight" : partial ( LoLDUParametrization . from_linear , rank = 15 ),
    },
}

add_loldu ( model , loldu_config = loldu_config )

Treinamento com Loldu

 from minloldu import get_loldu_params

# Freeze all parameters
for param in model . parameters ():
    param . requires_grad = False

# Enable gradients for LoLDU parameters
for param in get_loldu_params ( model ):
    param . requires_grad = True

# Your training loop here

Salvando e carregando o estado de Loldu

 from minloldu import get_loldu_state_dict

# Save LoLDU state
state_dict_to_save = get_loldu_state_dict ( model )
torch . save ( state_dict_to_save , "loldu_state.pth" )

# Load LoLDU state
loaded_state = torch . load ( "loldu_state.pth" )
model . load_state_dict ( loaded_state , strict = False )

Mesclando loldu para inferência

 from minloldu import merge_loldu

# After training, merge LoLDU for efficient inference
merge_loldu ( model )

Práticas recomendadas

1. Escolha a classificação apropriada : o parâmetro de classificação na LolduparameTration afeta o trade-off entre a eficiência dos parâmetros e o desempenho do modelo. Experimente diferentes classificações para encontrar o equilíbrio ideal para sua tarefa.

2. Hiperparâmetros de ajuste fino : o Loldu pode exigir taxas de aprendizado diferentes em comparação com o ajuste completo. Ajuste sua taxa de aprendizado e outros hiperparâmetros de acordo.

3. Monitore Treinamento : Fique de olho no processo de treinamento para garantir que o Loldu esteja efetivamente adaptando o modelo. Use conjuntos de validação para evitar o excesso de ajuste.

4. Mesclar para inferência : sempre use merge_loldu() antes de implantar seu modelo para inferência para eliminar qualquer sobrecarga computacional.

5. Combine com outras técnicas : o Loldu pode ser combinado com outras técnicas de otimização, como quantização, para uma eficiência ainda maior.

Para obter informações mais detalhadas e uso avançado, consulte o artigo original e o repositório de código -fonte.

---

Observação:
Esteja ciente de que esse código pode não replicar completamente os resultados apresentados no artigo devido a possíveis erros humanos que ocorreram durante a preparação e limpeza do código antes de sua liberação. Se você tiver algum desafio na reprodução de nossas descobertas, não hesite em alcançar conosco. Além disso, estamos comprometidos em realizar experimentos de verificação de sanidade em um futuro próximo.

Reconhecimento
Nossa implementação de Loldu foi bastante aprimorada pela Minlora CodeBase.

Bibtex

 @misc { shi2024loldulowrankadaptationlowerdiagupper ,
  title = { LoLDU: Low-Rank Adaptation via Lower-Diag-Upper Decomposition for Parameter-Efficient Fine-Tuning } , 
  author = { Yiming Shi and Jiwei Wei and Yujia Wu and Ran Ran and Chengwei Sun and Shiyuan He and Yang Yang } ,
  year = { 2024 } ,
  eprint = { 2410.13618 } ,
  archivePrefix = { arXiv } ,
  primaryClass = { cs.CV } ,
  url = { https://arxiv.org/abs/2410.13618 } ,
}