LoRA Torch

Lora-Torch

Diese Codebasis neuImplementes lora: niedrige Anpassung von großer Sprachmodellen (ICLR 2022) und basierend auf Loralib rekonstruiert.

Merkmale

Die Implementierungen von loratorch und loralib sind sehr unterschiedlich. Wir nehmen das nn.Linear wie folgt wie folgt.

1. Für loralib , $ H = X W_0^ TOP + FRAC { alpha} {r} x (ba)^ top, $

Wo $ x in mathbb {r}^{k Times n} $ ist die Eingangsmatrix, $ W_0 in mathbb {r}^{m Times n} $ ist die vorgebrachte Gewichtsmatrix, $ r $ ist der vordefinierte Lora -Rang, $ B in mathbb {r}^{m Times r} $ Und $ A in mathbb {r}^{r Times n} $ sind die lora matrixes und $ alpha $ ist ein Hyperparameter.

2. Für loratorch , $ H = X (W_0 + Frac { alpha} {r} ba)^ top. $

loralib berechnet $ xw_0^ top $ Und $ x (ba)^ top $ und verschmelzen dann die Ergebnisse. Während loratorch vor dem Abgebildeten Gewicht verschmilzt $ W_0 $ und sein Lora -Gewicht $ Ba $ und berechnet dann die Ergebnisse, indem sie einfach nn.Linear.forward() verwendet. Es gibt keinen Unterschied zwischen loralib und loratorch in den linearen Schichten. Aber in einigen nichtlinearen oder komplexen Schichten sind wir uns nicht sicher, ob diese Schicht erfüllt $ L (x, w_0)+l (x, ba) = l (x, w_0+ba) $ . Daher ist es schwierig, Lora durch Verwendung von loralib auf einige komplexe Schichten auszudehnen. Im Gegenteil, die Idee, zuerst Gewichte in loratorch zu verschmelzen, ist allgemeiner und erweiterbarer. Sie rufen nur merge_lora_param() in loratorch an, um Gewichte zusammenzuführen, und rufen dann in der ursprünglichen Ebene forward() um die Ergebnisse zu berechnen. Mit Hilfe von loratorch können Sie Lora problemlos auf jede Art von torch.nn implementieren.

Unterstützte Schichten

	loralib	loratorch
nn.Linear	✓	✓	linear.ipynb
nn.Embedding	✓	✓	Einbettung.IPynb
nn.Conv1d	✓	✓
nn.Conv2d	✓	✓
nn.Conv3d	✓	✓
nn.MultiheadAttention	✘	✓
MergedLinear	✓ (Fehler)	✓	mergedlinear.ipynb
$ cdots $	schwer zu verlängern	leicht zu verlängern

Wir vergleichen die Ergebnisse von loralib und loratorch in Beispielen, um die Richtigkeit der Implementierung in loratorch zu demonstrieren.

Schneller Start

Die Verwendung von loratorch ist der gleiche wie loralib .

1. loratorch einbauen.

   pip install git+https://github.com/Baijiong-Lin/LoRA-Torch
   # Alternatively for developers
   # git clone https://github.com/Baijiong-Lin/LoRA-Torch
   # cd LoRA-Torch
   # pip install -e .

2. Ersetzen Sie die Schichten, in denen Sie Lora mit loratorch verwenden möchten.

    # ===== Before =====
   # layer = nn.Linear(in_features, out_features)
   
   # ===== After ======
   import loratorch as lora
   # Add a pair of low-rank adaptation matrices with rank r=16 and alpha=32
   layer = lora . Linear ( in_features , out_features , r = 16 , lora_alpha = 32 )

3. Markieren Sie nur LORA -Parameter als trainierbar vor der Trainingsschleife.

    model = Model ()
   # (!!!) This sets requires_grad to False for all parameters without the string "lora_" in their names
   lora . mark_only_lora_as_trainable ( model )
   
   optimizer = torch . optim . SGD ( model . parameters (), lr = 0.1 )
   # Training loop
   for batch in dataloader :
       model . train ()
       # forward process
       loss = forward_fun ( model , batch )
       # backward process
       optimizer . zero_grad ()
       loss . backward ()
       optimizer . step ()
       # (!!!) reregister model param to ensure they are in model.state_dict() and model.parameters()
       # (!!!) Without this line, the performance does not be affected but you will find that some weights are missing in model.state_dict() and model.parameters()
       lora . register_model_param_after_backward ( model )

4. Speichern Sie das LORA -Modell (nur die Lora -Matrixes werden gespeichert).

    # ===== Before =====
   # torch.save(model.state_dict(), checkpoint_path)
   # ===== After =====
   torch . save ( lora . lora_state_dict ( model ), checkpoint_path )

5. Laden Sie das LORA-Modell (müssen zuerst das vorgebildete Modell laden).

    # Load the pre-trained checkpoint first
   model . load_state_dict ( torch . load ( 'ckpt_pretrained.pt' ), strict = False )
   # Then load the LoRA checkpoint
   model . load_state_dict ( torch . load ( 'ckpt_lora.pt' ), strict = False )

Mitwirkender

loratorch wird von Baijiong Lin entwickelt und gepflegt.

Kontaktieren Sie uns

Wenn Sie Fragen oder Vorschläge haben, kontaktieren Sie uns bitte, indem Sie ein Problem ansprechen oder eine E -Mail an [email protected] senden.

Anerkennung

loratorch basiert stark auf loralib . Wir danken seinen Autoren für ihre wundervolle und Open-Source-Codebasis.

Zitat

Wenn Sie loratorch für Ihre Forschung oder Entwicklung nützlich finden, geben Sie Folgendes an:

 @inproceedings { hu2022lora ,
title = { Lo{RA}: Low-Rank Adaptation of Large Language Models } ,
author = { Edward J Hu and Yelong Shen and Phillip Wallis and Zeyuan Allen-Zhu and Yuanzhi Li and Shean Wang and Lu Wang and Weizhu Chen } ,
booktitle = { International Conference on Learning Representations } ,
year = { 2022 } ,
}

@software { lin2023loratorch ,
  author = { Baijiong Lin } ,
  title = { {LoRA-Torch}: {PyTorch} Reimplementation of {LoRA} } ,
  url = { https://github.com/Baijiong-Lin/LoRA-Torch } ,
  year = { 2023 }
}

Lizenz

loratorch wird unter der MIT -Lizenz veröffentlicht.