LoLDU

Loldu: Adaptation de faible rang via une décomposition de la diagramme inférieur

Loldu est une technique de réglage des paramètres de paramètres de pointe (PEFT) conçue pour réduire considérablement le nombre de paramètres formables tout en atteignant des niveaux de performance comparables à un réglage fin complet. Ce document décrit les étapes nécessaires pour intégrer efficacement Loldu dans vos projets.

Pour plus de détails, veuillez consulter le document: https://arxiv.org/pdf/2410.13618

Table des matières

1. Installation
2. Caractéristiques clés
3. Démarrage rapide
4. Référence de l'API
5. Exemples d'utilisation
6. Meilleures pratiques

Installation

Pour installer Loldu, utilisez simplement PIP:

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

Caractéristiques clés

• Réduit considérablement le nombre de paramètres formables (jusqu'à 2600 fois moins que les méthodes PEFT régulières)
• Maintient des performances comparables à la réglage fin complet
• Exploite la décomposition de la baisse du diagle (LDU) pour une convergence et une orthogonalité plus rapides
• Se concentre sur l'optimisation de la matrice diagonale pour la mise à l'échelle des transformations
• Compatible avec diverses architectures de modèle (par exemple, Llama2, Roberta, Vit, diffusion stable)

Démarrage rapide

Voici un exemple rapide de la façon d'utiliser 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 

Référence de l'API

Fonctions principales

1. add_loldu(model, loldu_config)

   • Ajoute un paramétrage de Loldu au modèle spécifié.
   • model : le modèle Pytorch à modifier.
   • loldu_config : Dictionnaire de configuration pour Loldu.

2. get_loldu_params(model, print_shapes=False)

   • Renvoie les paramètres Loldu du modèle.
   • model : Le modèle Pytorch avec Loldu.
   • print_shapes : si vrai, imprime les formes des paramètres de Loldu.

3. disable_loldu(model)

   • Désactive temporairement Loldu dans le modèle.

4. enable_loldu(model)

   • Réactivité Loldu dans le modèle après désactivation.

5. remove_loldu(model)

   • Supprime complètement Loldu du modèle.

6. merge_loldu(model)

   • Merges les paramètres de Loldu dans les poids du modèle d'origine pour une inférence efficace.

7. get_loldu_state_dict(model)

   • Renvoie le dictionnaire d'État des paramètres de Loldu pour la sauvegarde.

Classe de lolduparamétrisation

• LoLDUParametrization.from_linear(layer, rank)
  • Crée un paramétrage de Loldu pour une couche linéaire.
  • layer : la couche linéaire à paramétrer.
  • rank : le rang pour l'approximation de bas rang.

Exemples d'utilisation

Ajout de Loldu à un modèle

 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 )

Formation avec 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

Économie et chargement de l'État 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 )

Fusion de Loldu pour l'inférence

 from minloldu import merge_loldu

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

Meilleures pratiques

1. Choisissez un rang approprié : Le paramètre de rang dans la lolduroamétrisation affecte le compromis entre l'efficacité des paramètres et les performances du modèle. Expérimentez avec différents rangs pour trouver l'équilibre optimal pour votre tâche.

2. Hyperparamètres à réglage fin : Loldu peut nécessiter des taux d'apprentissage différents par rapport au réglage fin complet. Ajustez votre taux d'apprentissage et autres hyperparamètres en conséquence.

3. Surveillez la formation : gardez un œil sur le processus de formation pour vous assurer que Loldu adapte efficacement le modèle. Utilisez des ensembles de validation pour empêcher le sur-ajustement.

4. Merge pour l'inférence : utilisez toujours merge_loldu() avant de déployer votre modèle pour l'inférence pour éliminer toute surcharge de calcul.

5. Combinez avec d'autres techniques : Loldu peut être combiné avec d'autres techniques d'optimisation comme la quantification pour une efficacité encore plus grande.

Pour des informations plus détaillées et une utilisation avancée, veuillez vous référer à l'article d'origine et au référentiel de code source.

---

Note:
Veuillez noter que ce code peut ne pas reproduire entièrement les résultats présentés dans le document en raison des éventuelles erreurs humaines qui se sont produites lors de la préparation et du nettoyage du code avant sa libération. Si vous rencontrez des défis dans la reproduction de nos résultats, n'hésitez pas à nous contacter. En outre, nous nous engageons à mener des expériences de vérification de la raison dans un avenir proche.

Reconnaissance
Notre implémentation Loldu a été considérablement améliorée par la base de code Minlora.

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 } ,
}