LoLDU

Loldu: Anpassung mit niedriger Rang über die Zerlegung von niedrigerer Diag-Upper

Loldu ist eine hochmoderne Parameter-effizientes Fine-Tuning-Technik (PEFT), mit der die Anzahl der trainierbaren Parameter drastisch reduziert und die mit vollständigen Feinabstimmungen vergleichbaren Leistungsstufen erreicht werden. In diesem Dokument werden die Schritte beschrieben, die erforderlich sind, um Loldu effektiv in Ihre Projekte zu integrieren.

Weitere Informationen finden Sie im Papier: https://arxiv.org/pdf/2410.13618

Inhaltsverzeichnis

1. Installation
2. Schlüsselmerkmale
3. Schneller Start
4. API -Referenz
5. Nutzungsbeispiele
6. Best Practices

Installation

Um Loldu zu installieren, verwenden Sie einfach PIP:

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

Schlüsselmerkmale

• Reduziert die Anzahl der trainierbaren Parameter erheblich (bis zu 2600 Mal weniger als normale PEFT -Methoden).
• Behält die Leistung vergleichbar mit vollem Feinabstimmung
• Nutzung der Deckung mit niedrigerer Diag-Upper (LDU) für schnellere Konvergenz und Orthogonalität
• Konzentriert sich auf die Optimierung der diagonalen Matrix für die Skalierung von Transformationen
• Kompatibel mit verschiedenen Modellarchitekturen (EG, LLAMA2, Roberta, Vit, stabile Diffusion)

Schneller Start

Hier ist ein kurzes Beispiel für die Verwendung von 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 

API -Referenz

Hauptfunktionen

1. add_loldu(model, loldu_config)

   • Fügt dem angegebenen Modell die Parametrisierung von Loldu hinzu.
   • model : Das zu ändernde Pytorch -Modell.
   • loldu_config : Konfigurationswörterbuch für Loldu.

2. get_loldu_params(model, print_shapes=False)

   • Gibt die Loldu -Parameter des Modells zurück.
   • model : Das Pytorch -Modell mit Loldu.
   • print_shapes : Wenn wahr, druckt die Formen der Loldu -Parameter.

3. disable_loldu(model)

   • Deaktiviert Loldu im Modell vorübergehend.

4. enable_loldu(model)

   • Wiederer auf Loldu im Modell nach der Deaktivierung.

5. remove_loldu(model)

   • Entfernt Loldu vollständig aus dem Modell.

6. merge_loldu(model)

   • Fungiert die Loldu -Parameter in die ursprünglichen Modellgewichte für eine effiziente Inferenz.

7. get_loldu_state_dict(model)

   • Gibt das staatliche Wörterbuch von Loldu -Parametern zum Speichern zurück.

Lolduparametrization Klasse

• LoLDUParametrization.from_linear(layer, rank)
  • Erstellt eine Loldu -Parametrisierung für eine lineare Schicht.
  • layer : Die lineare zu parametrisierende Ebene.
  • rank : Der Rang für die Niedrigrangnäherung.

Nutzungsbeispiele

Hinzufügen von Loldu zu einem Modell

 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 )

Training mit 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

Speichern und Laden des Bundesstaates 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 )

Loldu für Inferenz verschmelzen

 from minloldu import merge_loldu

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

Best Practices

1. Wählen Sie einen geeigneten Rang : Der Rangparameter in Lolduparametrisierung beeinflusst den Kompromiss zwischen Parametereffizienz und Modellleistung. Experimentieren Sie mit verschiedenen Rängen, um die optimale Balance für Ihre Aufgabe zu finden.

2. Fein-Tune-Hyperparameter : Loldu erfordert möglicherweise unterschiedliche Lernraten im Vergleich zur vollständigen Feinabstimmung. Passen Sie Ihre Lernrate und andere Hyperparameter entsprechend an.

3. Überwachen Sie das Training : Beobachten Sie den Trainingsprozess, um sicherzustellen, dass Loldu das Modell effektiv anpasst. Verwenden Sie Validierungssätze, um eine Überanpassung zu verhindern.

4. Merge for Inference : Verwenden Sie immer merge_loldu() bevor Sie Ihr Modell für Inferenz bereitstellen, um einen Rechenaufwand zu beseitigen.

5. Kombinieren mit anderen Techniken : Loldu kann mit anderen Optimierungstechniken wie der Quantisierung für noch größere Effizienz kombiniert werden.

Weitere detailliertere Informationen und fortgeschrittene Verwendung finden Sie im Originalpapier und im Quellcode -Repository.

---

Notiz:
Bitte beachten Sie, dass dieser Code die im Papier angegebenen Ergebnisse aufgrund möglicher menschlicher Fehler, die während der Vorbereitung und Reinigung des Codes vor seiner Freigabe aufgetreten sind, nicht vollständig replizieren. Wenn Sie Herausforderungen bei der Reproduktion unserer Erkenntnisse haben, zögern Sie nicht, uns an uns zu wenden. Darüber hinaus sind wir bestrebt, in naher Zukunft Experimente für Vernunftprüfungen durchzuführen.

Anerkennung
Unsere Loldu -Implementierung wurde durch die Minlora -Codebasis erheblich verbessert.

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