Présentation détaillée du projet Microsoft LoRA

Aperçu du projet

Microsoft LoRA est une bibliothèque Python open source de Microsoft qui implémente la technique "LoRA : Low-Rank Adaptation of Large Language Models" (Adaptation de faible rang des grands modèles de langage). Ce projet offre une solution révolutionnaire pour le fine-tuning efficace des grands modèles de langage.

Adresse du projet : https://github.com/microsoft/LoRA

Adresse de l'article : https://arxiv.org/abs/2106.09685

Principe technique fondamental

Introduction à la technologie LoRA

LoRA (Low-Rank Adaptation) est une méthode de fine-tuning efficace en termes de paramètres, dont l'idée centrale est la suivante :

• Geler les poids pré-entraînés originaux : ne pas modifier les paramètres du modèle original
• Ajouter des matrices de décomposition de faible rang : réaliser l'adaptation du modèle en apprenant une paire de matrices de faible rang
• Réduire considérablement le nombre de paramètres d'entraînement : entraîner uniquement les paramètres des matrices de faible rang nouvellement ajoutées

Avantages techniques

1. Efficacité des paramètres extrêmement élevée

• Par rapport au fine-tuning complet de GPT-3 175B, LoRA peut réduire de 10 000 fois le nombre de paramètres d'entraînement
• Réduction de 3 fois des besoins en mémoire GPU

2. Maintien d'excellentes performances

• Performances équivalentes ou supérieures au fine-tuning complet sur RoBERTa, DeBERTa, GPT-2, GPT-3
• Obtention d'excellents résultats dans le benchmark GLUE

3. Déploiement convivial

• Pas de latence d'inférence supplémentaire
• Prise en charge de la commutation de tâches efficace
• Réduction significative des besoins de stockage

Performances

Résultats du benchmark GLUE

Dans le benchmark GLUE, LoRA a démontré d'excellentes performances :

Modèle	Nombre de paramètres d'entraînement	Précision MNLI	Précision SST-2	Précision MRPC
RoBERTa Base Fine-tuning complet	125M	87.6	94.8	90.2
RoBERTa Base LoRA	0.8M	87.6±.1	95.1±.2	89.7±.7
DeBERTa XXL Fine-tuning complet	1.5B	91.1	96.8	92.9
DeBERTa XXL LoRA	4.7M	91.9±.1	96.9±.2	92.6±.6

Tâche de génération de texte GPT-2

LoRA a également obtenu d'excellentes performances dans les tâches de génération de texte E2E, DART, WebNLG, etc. :

Méthode	Paramètres d'entraînement	E2E (BLEU)	DART (BLEU)	WebNLG (BLEU)
GPT-2 M Fine-tuning complet	354.92M	68.2	46.0	47.6
GPT-2 M LoRA	0.35M	70.4±.1	47.1±.2	55.3±.2

Structure du projet

microsoft/LoRA/
├── loralib/           # Code source de la bibliothèque principale
├── examples/
│   ├── NLG/          # Exemple de génération de langage naturel GPT-2
│   └── NLU/          # Exemple de compréhension du langage naturel RoBERTa/DeBERTa
├── README.md
└── setup.py

Installation et utilisation

Méthode d'installation

pip install loralib

# Ou installer à partir du code source
pip install git+https://github.com/microsoft/LoRA

Exemple d'utilisation de base

1. Remplacer la couche linéaire

# ===== Avant modification =====
# layer = nn.Linear(in_features, out_features)

# ===== Après modification =====
import loralib as lora
layer = lora.Linear(in_features, out_features, r=16)

2. Marquer les paramètres entraînables

import loralib as lora

model = BigModel()
# Définir uniquement les paramètres contenant "lora_" comme entraînables
lora.mark_only_lora_as_trainable(model)

# Boucle d'entraînement
for batch in dataloader:
    # Flux d'entraînement normal
    pass

3. Enregistrer et charger les points de contrôle

# Enregistrer les paramètres LoRA
torch.save(lora.lora_state_dict(model), 'lora_checkpoint.pt')

# Charger le modèle pré-entraîné
model.load_state_dict(torch.load('pretrained.pt'), strict=False)
# Charger les paramètres LoRA
model.load_state_dict(torch.load('lora_checkpoint.pt'), strict=False)

Types de couches pris en charge

Actuellement, la bibliothèque LoRA prend en charge les types de couches suivants :

• nn.Linear → lora.Linear
• nn.Embedding → lora.Embedding
• nn.Conv2d → lora.Conv2d
• lora.MergedLinear (pour les couches linéaires fusionnées telles que la projection QKV)

Fonctionnalités avancées

1. Prise en charge des couches linéaires fusionnées

# Pour les scénarios tels que la projection QKV
qkv_proj = lora.MergedLinear(
    d_model, 3*d_model, 
    r=8, 
    enable_lora=[True, False, True]  # Appliquer LoRA uniquement à Q et V
)

2. Entraînement du vecteur de biais

# Entraîner le biais associé à LoRA
lora.mark_only_lora_as_trainable(model, bias='lora_only')

# Entraîner tous les biais
lora.mark_only_lora_as_trainable(model, bias='all')

3. Fusion des poids lors de l'inférence

# Mode d'évaluation : fusionner les poids, éliminer la latence d'inférence
model.eval()

# Mode d'entraînement : restaurer l'état de séparation
model.train()

Scénarios d'application

1. Fine-tuning de grands modèles : réduire considérablement les coûts de fine-tuning
2. Apprentissage multi-tâches : commutation de tâches efficace
3. Environnements à ressources limitées : réduire les besoins en mémoire et en stockage
4. Développement rapide de prototypes : accélérer le processus d'adaptation du modèle

Intégration de l'écosystème

• Hugging Face PEFT : désormais intégré à la bibliothèque PEFT de HF
• Écosystème PyTorch : entièrement compatible avec le framework PyTorch
• Modèles pré-entraînés : prend en charge divers modèles pré-entraînés courants

Conclusion

Le projet Microsoft LoRA offre une solution révolutionnaire pour le fine-tuning efficace des grands modèles de langage. Grâce à une technique astucieuse d'adaptation de faible rang, il maintient d'excellentes performances du modèle tout en réduisant considérablement les coûts de calcul et de stockage. Ce projet a non seulement une valeur académique importante, mais fournit également une voie technologique viable pour les applications industrielles pratiques, et constitue une étape importante dans le domaine du fine-tuning efficace en termes de paramètres.