AI Agents · Leçon

LoRA et QLoRA pour un ajustement économique

Entraînez uniquement des adaptateurs de faible rang sur une base quantifiée : un ajustement fin 70B tient ainsi sur un seul GPU.

Leçon 3 sur 415 étapes

LoRA et QLoRA pour un ajustement économique est une leçon AI Agents gratuite sur CoddyKit. Ceci est la leçon 3 sur 4. Tu peux lire la leçon complète ci-dessous gratuitement — puis la pratiquer en direct dans le navigateur avec un éditeur de code intégré et un tuteur IA 24/7. Elle fait partie du parcours d'apprentissage AI Agents, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours AI Agents comprend 4 leçons au total.

Certaines parties de cette leçon n'ont pas encore été traduites et s'affichent en anglais.

Pourquoi PEFT ?

L’affinage complet de Llama 70B nécessite au moins 8 H100 et met à jour 70 milliards de paramètres. PEFT (affinage efficace en paramètres) met à jour < 1 % des paramètres pour une qualité similaire. Les économies sont considérables.

LoRA : adaptation de faible rang

LoRA (Hu et al. 2021) entraîne de petites matrices « adaptateur » parallèlement aux poids de base gelés :

Ajoutez des matrices A x B où A est dxr et B est rxd, avec r petit (8, 16, 64)
Propagation avant : y = Wx + (BA)x
Entraînez uniquement A et B : le nombre de paramètres est considérablement réduit

QLoRA : LoRA quantifié

QLoRA (Dettmers et al. 2023) réduit encore les coûts en quantifiant le modèle de base sur 4 bits pendant l’entraînement :

Modèle de base en NF4 (4 bits)
Adaptateurs LoRA avec une précision supérieure
Un affinage d’un modèle 70B tient sur un seul A100/H100

Setup with peft + transformers

# pip install peft transformers bitsandbytes
from peft import LoraConfig, get_peft_model
from transformers import AutoModelForCausalLM

model = AutoModelForCausalLM.from_pretrained(
    'meta-llama/Llama-3.1-8B-Instruct',
    load_in_4bit=True,        # QLoRA
    device_map='auto'
)

lora_config = LoraConfig(
    r=16,                     # rank
    lora_alpha=32,
    target_modules=['q_proj', 'v_proj'],
    lora_dropout=0.05,
    bias='none'
)
model = get_peft_model(model, lora_config)
model.print_trainable_parameters()
# trainable params: ~0.5% of total

Training Loop with TRL

from trl import SFTTrainer

trainer = SFTTrainer(
    model=model,
    train_dataset=dataset,
    tokenizer=tokenizer,
    args=TrainingArguments(
        per_device_train_batch_size=4,
        gradient_accumulation_steps=4,
        learning_rate=2e-4,
        num_train_epochs=3,
        output_dir='./lora-out'
    )
)
trainer.train()
model.save_pretrained('./adapter')

Utilisation d’Unsloth

Unsloth est la bibliothèque LoRA la plus rapide : deux fois plus rapide que peft sans optimisation. Son interface s’intègre directement :

from unsloth import FastLanguageModel

model, tokenizer = FastLanguageModel.from_pretrained(
    model_name='meta-llama/Llama-3.1-8B-Instruct',
    load_in_4bit=True
)
model = FastLanguageModel.get_peft_model(
    model,
    r=16,
    target_modules=['q_proj', 'k_proj', 'v_proj', 'o_proj', 'gate_proj', 'up_proj', 'down_proj']
)

Estimation des coûts

QLoRA sur Llama 3.1 8B avec 10k exemples :

~4 heures sur un seul H100
~$5-10 de coût de GPU dans le nuage
Fichier d’adaptateur : 100-300 MB

Choix du rang r

r = 8 — minimal, pour les changements de format ou de style
r = 16-32 — la plupart des cas
r = 64+ — nouveau comportement substantiel, capacité accrue

Modules ciblés

Par défaut, ciblez les projections d’attention (q, v). Pour davantage de capacité, incluez toutes les couches linéaires : la qualité est meilleure, mais le nombre de paramètres augmente.

Hyperparamètres importants

Taux d’apprentissage — 1e-4 à 5e-4 est une valeur courante
Époques — 2-5 pour SFT
Taille de lot — dépend de la VRAM ; utilisez l’accumulation des gradients pour simuler un lot plus grand

Fusion de l’adaptateur dans le modèle de base

Pour l’inférence, vous pouvez refusionner LoRA dans les poids de base :

merged = model.merge_and_unload()
merged.save_pretrained('./full-model')

Fourniture de plusieurs LoRAs

vLLM prend en charge le remplacement à chaud des LoRAs au moment de l’inférence. C’est utile pour les affinages propres à chaque client sur un modèle de base partagé :

llm = LLM(model='base', enable_lora=True, max_lora_rank=64)
response = llm.generate(prompt, lora_request=LoRARequest('customer-a', 1, './customer-a-adapter'))

Évaluation de l’adaptateur

Exécutez toujours YOUR ensemble d’évaluation sur le modèle affiné. Parfois, l’affinage donne de moins bons résultats dans les cas limites : soyez honnête au sujet des régressions.

Avantage de LoRA

Quel est l’avantage pratique principal de LoRA par rapport à l’affinage complet ?

Réponds-y dans la leçon interactive

Récapitulatif

LoRA + QLoRA permettent un affinage économique. Utilisez Unsloth pour la vitesse, et peft/TRL pour une prise en charge étendue. Le rang 16-32 convient à la plupart des cas. Évaluez par rapport à votre jeu de référence.

Gratuit pour commencer

Apprends AI Agents avec un tuteur IA — gratuit

Écris et exécute du vrai code dans ton navigateur, obtiens de l'aide instantanée d'un tuteur IA disponible 24h/24, et reprends là où tu t'es arrêté sur le web ou dans l'app.

Cours: 60
Leçons: 239

Commencer gratuitement Voir le cours complet

Questions Fréquemment Posées

La leçon « LoRA et QLoRA pour un ajustement économique » est-elle gratuite ?

Oui — le texte complet de « LoRA et QLoRA pour un ajustement économique » est gratuit à lire ici sur le web. Pour la pratiquer de manière interactive (un éditeur de code intégré et un tuteur IA 24/7) et déverrouiller le reste du cours AI Agents, passe à CoddyKit PRO. Le cours AI Agents comprend 4 leçons au total.

Qu'est-ce que j'apprendrai dans « LoRA et QLoRA pour un ajustement économique » ?

Entraînez uniquement des adaptateurs de faible rang sur une base quantifiée : un ajustement fin 70B tient ainsi sur un seul GPU. Tu pratiques AI Agents avec du code pratique que tu exécutes directement dans le navigateur, et un tuteur IA 24/7 répond à tes questions au fur et à mesure que tu avances dans la leçon.

Dois-je avoir de l'expérience pour commencer AI Agents ?

Aucune expérience préalable n'est requise. AI Agents sur CoddyKit est structuré pour les débutants jusqu'aux apprenants avancés, donc tu peux commencer ici ou depuis le début et avancer à ton rythme. Ceci est la leçon 3 sur 4.

Combien de temps prend la leçon « LoRA et QLoRA pour un ajustement économique » ?

La plupart des leçons CoddyKit prennent environ 5–10 minutes. Chacune est courte et interactive, tu progresses régulièrement et tu repiques exactement où tu t'es arrêté sur le web et l'app.

Peux-tu écrire et exécuter du code dans cette leçon AI Agents ?

Oui. Chaque leçon AI Agents inclut un éditeur de code intégré, tu écris et exécutes du vrai code directement dans ton navigateur et tu reçois des retours IA instantanés — aucune configuration locale requise.

Toutes les leçons de ce cours

Quand l’ajustement fin est préférable aux invites
Collecte de données : trajectoires et rejeu des traces
LoRA et QLoRA pour un ajustement économique
Évaluer les modèles ajustés par rapport au modèle de base

← Retour à AI Agents