Fine-Tuning Llama 70b Utilisation de l’étreinte Face Accélérer et Deeppeed sur plusieurs nœuds / blogs / perficient

par Luis Pacheco, Uday Yallapragada et Cristian Muñoz

Les modèles de grandes langues (LLM) comme Meta’s Llama 70b révolutionnent les tâches de traitement du langage naturel, mais la formation ou les réglages fins nécessite des ressources de calcul et de mémoire massives. Pour relever ces défis, nous employons une formation distribuée sur plusieurs nœuds GPU en utilisant des vitesses profondes et des étreintes accélérées.

Ce blog vous guide à travers une configuration prête pour la production pour affiner le modèle LLAMA 70B sur deux nœuds, chacun équipé de GPU H100, en utilisant:

• Optimisation zéro de la vitesse profonde 3 Pour une formation économe en mémoire,

• Le visage étreint accélérer pour une orchestration multi-nœuds sans couture,

• Quantification 4 bits Pour réduire considérablement l’empreinte de la mémoire,

• PEFT (affineur final par les paramètres) via Lora pour une adaptation légère.

Que ce soit à l’échelle de votre modèle ou à l’optimisation des coûts de calcul, cette configuration permet à une échelle de flux de travail de réglage fin puissant.

Installation

L’architecture implique un nœud maître et un nœud de travailleur, tous deux exécutant des processus de réglage fin identiques. La communication est gérée via NCCL sur TCP, et l’accès partagé à l’ensemble de données / modèle est à travers NFS.

Panne du diagramme

Composants clés

• Stage de profondeur 3 (zéro-3):

• • Permet la rupture du modèle en partageant des états d’optimiseur, des gradients et des paramètres dans tous les GPU.

• • Critique pour les modèles de formation plus grands que ce qui correspond à la mémoire d’un seul GPU.

• Le visage étreint accélérer:

• • Fournit une interface légère pour gérer la formation distribuée, le modèle d’emballage, l’optimiseur, les chargeurs de données, etc.

• • Gandoues lancées à travers les nœuds en utilisant lancement accéléré avec des fichiers de configuration.

• Quantification 4 bits (via BitsandBytes):

• • Réduit la taille du modèle en mémoire, permettant aux modèles plus grands de s’adapter et de s’entraîner plus rapidement.

• • Usages NF4 quantification et bfloat16 (BF16) Calculez le type pour équilibrer les performances et la précision.

• Lora (adaptation de faible rang) via PEFT:

• • Finetune seulement un sous-ensemble de poids d’adaptateur de faible rang.

• • Réduit considérablement le nombre de paramètres formables, ce qui rend le réglage fin même sur les ensembles de données plus petits.

• • Des outils comme Grafana, Prometheus, Nvidia-SMI et DCGM Système de suivi et performances du GPU.

• • Modèle LLAMA 3.3 70b chargé via NFS.

• • Amazon examine l’ensemble de données (400 Mo) utilisé pour la classification des sentiments binaires.

Détails de la mise en œuvre

Accélérer les configurations

Deux fichiers YAML définissent la configuration multi-nœuds:

default_config_main.yaml

machine_rank: 0
num_machines: 2
distributed_type: DEEPSPEED
mixed_precision: fp8
deepspeed_config:
  zero_stage: 3

default_config_worker.yaml

machine_rank: 1
main_process_ip: <your ip address>

Ces configurations permettent une formation synchronisée sur deux nœuds, chacun exécutant 4 processus (1 par GPU).

Prix ​​Python Script

Le script de réglage fin llm_finetune_for_blog.py est modulaire et adapté à la production. Voici une ventilation de son flux de travail:

Chargement des données et prétraitement

df = pd.concat([...])
df["label"] = df["rating"].apply(convert_rating)
train_dataset = datasets.Dataset.from_pandas(train_df)

• Charges et prétraitements Amazon examine les fichiers CSV.

• Convertit les notes en étiquettes binaires.

• Tokenise à l’aide de tokenizage à visage étreint avec rembourrage et troncature.

Configuration du modèle et de la quantification

bnb_config = BitsAndBytesConfig(load_in_4bit=True, ...)
model = AutoModelForSequenceClassification.from_pretrained(..., quantization_config=bnb_config)

• Modèle de chargement de lama en 4 bits avec NF4 quantification.

• Applique le point de contrôle du gradient et permet des gradients d’entrée.

Appliquer Lora

lora_config = LoraConfig(...)
model = get_peft_model(model, lora_config)

• Lora réduit le nombre de paramètres formables, accélérant la formation tout en maintenant les performances.

Configuration de l’accélérateur

accelerator = Accelerator(mixed_precision='fp8')
model, optimizer, train_dataloader, ... = accelerator.prepare(...)

• Enveloppe les composants de formation avec accélération pour gérer la formation distribuée.

Boucle de formation

for epoch in range(num_epochs):
    for batch in train_dataloader:
        outputs = model(**batch)
        loss = outputs.loss
        accelerator.backward(loss)

• Structure de boucle simple avec rétropropagation de perte à l’aide d’accélération.

• Les étapes d’optimiseur et de planificateur sont exécutées par lot.

Évaluation

with torch.no_grad():
    outputs = model(**batch)
    total_eval_loss += outputs.loss.item()

• Calcule la perte de validation moyenne à la fin de la formation.

Conclusion

Dans ce blog, nous avons parcouru une configuration complète de bout en bout pour affiner Llama 70b en utilisant:

• Formation multi-nœuds distribués avec Deeppeed Zero-3,

• Quantification 4 bits avec bitsandbytes Pour optimiser l’utilisation de la mémoire,

• Le visage étreint accélérer pour l’orchestration de formation sans couture,

• PEFT via Lora pour affiner efficacement les parties critiques du modèle.

Cette architecture est robuste et évolutive, adaptée aux tâches de réglage fin de l’entreprise à grande échelle. En combinant la quantification, le PEFT et l’informatique distribuée, vous pouvez déverrouiller des flux de travail à affinage fin de haute performance sur des modèles à l’échelle des paramètres de milliards de milliards de dollars – tout en optimisant le coût et la vitesse de calcul.