Fine-Tuning Llama 2: un guide étape par étape pour personnaliser le modèle de grande langue

Meta's Llama a déclenché une vague de développement du modèle de grande langue (LLM), visant à rivaliser avec des modèles comme GPT-3.5. La communauté open source a rapidement produit des modèles de plus en plus puissants, mais ces progrès n'étaient pas sans défis. De nombreux LLMS open source avaient des licences restrictives (utilisation de la recherche uniquement), nécessitaient des budgets substantiels pour le réglage des amende et étaient coûteux à déployer.

La nouvelle itération de

LLAMA aborde ces problèmes avec une licence commerciale et de nouvelles méthodes permettant un réglage fin sur les GPU de qualité grand public avec une mémoire limitée. Cela démocratise l'IA, permettant aux organisations encore plus petites de créer des modèles sur mesure.

Ce guide démontre le LLAMA-2 à réglage fin sur Google Colab, en utilisant des techniques efficaces pour surmonter les contraintes de ressources. Nous explorerons les méthodologies qui minimisent l'utilisation de la mémoire et accélèrent la formation.

Image générée par l'auteur à l'aide de DALL-E 3

Fine-tuning Llama-2: un guide étape par étape

Ce didacticiel afflige le modèle LLAMA-2 de 7 milliards de paramètres sur un GPU T4 (disponible sur Google Colab ou Kaggle). Le VRAM 16 Go du T4 nécessite un réglage fin et efficace par les paramètres, en utilisant spécifiquement QLORA (précision 4 bits). Nous utiliserons l'écosystème des étreintes (Transformers, Accélérer, PEFT, TRL, BITSANDBYTES).

1. Configuration:

Installez les bibliothèques nécessaires:

<code>%%capture
%pip install accelerate peft bitsandbytes transformers trl</code>

Modules d'importation:

<code>import os
import torch
from datasets import load_dataset
from transformers import (
    AutoModelForCausalLM,
    AutoTokenizer,
    BitsAndBytesConfig,
    TrainingArguments,
    pipeline,
    logging,
)
from peft import LoraConfig
from trl import SFTTrainer</code>

2. Sélection du modèle et de l'ensemble de données:

Nous utiliserons NousResearch/Llama-2-7b-chat-hf (un équivalent facilement accessible au LLAMA-2 officiel) comme modèle de base et mlabonne/guanaco-llama2-1k comme ensemble de données de formation plus petit.

<code>base_model = "NousResearch/Llama-2-7b-chat-hf"
guanaco_dataset = "mlabonne/guanaco-llama2-1k"
new_model = "llama-2-7b-chat-guanaco"</code>

Les images illustrant le modèle de visage étreint et l'ensemble de données sont incluses ici, identiques à l'original.

3. Chargement des données et modèle:

Chargez l'ensemble de données:

<code>dataset = load_dataset(guanaco_dataset, split="train")</code>

Configurer la quantification 4 bits à l'aide de Qlora:

<code>compute_dtype = getattr(torch, "float16")
quant_config = BitsAndBytesConfig(
    load_in_4bit=True,
    bnb_4bit_quant_type="nf4",
    bnb_4bit_compute_dtype=compute_dtype,
    bnb_4bit_use_double_quant=False,
)</code>

Chargez le modèle LLAMA-2 avec une quantification 4 bits:

<code>model = AutoModelForCausalLM.from_pretrained(
    base_model,
    quantization_config=quant_config,
    device_map={"": 0}
)
model.config.use_cache = False
model.config.pretraining_tp = 1</code>

Chargez le tokenzer:

<code>tokenizer = AutoTokenizer.from_pretrained(base_model, trust_remote_code=True)
tokenizer.pad_token = tokenizer.eos_token
tokenizer.padding_side = "right"</code>

L'image illustrant Qlora est incluse ici, identique à l'original.

4. Configuration de PEFT:

Définir les paramètres PEFT pour un réglage d'adaptation efficace:

<code>peft_params = LoraConfig(
    lora_alpha=16,
    lora_dropout=0.1,
    r=64,
    bias="none",
    task_type="CAUSAL_LM",
)</code>

5. Paramètres de formation:

Définir des hyperparamètres de formation (répertoire de sortie, époques, tailles de lots, taux d'apprentissage, etc.). Les détails sont les mêmes que l'original.

6. Affligeant avec SFT:

Utilisez le SFTTrainer de la bibliothèque TRL pour un réglage fin supervisé:

<code>trainer = SFTTrainer(
    model=model,
    train_dataset=dataset,
    peft_config=peft_params,
    dataset_text_field="text",
    max_seq_length=None,
    tokenizer=tokenizer,
    args=training_params,
    packing=False,
)

trainer.train()
trainer.model.save_pretrained(new_model)
trainer.tokenizer.save_pretrained(new_model)</code>

Des captures d'écran montrant les progrès de la formation et la sauvegarde du modèle sont incluses ici, identiques à l'original.

7. Évaluation:

Utilisez le pipeline transformers pour tester le modèle affiné. Des exemples sont fournis, identiques à l'original.

8. Visualisation du tensorboard:

Lancez Tensorboard pour surveiller les mesures de formation.

<code>%%capture
%pip install accelerate peft bitsandbytes transformers trl</code>

La capture d'écran de Tensorboard est incluse ici, identique à l'original.

Conclusion:

Ce guide met en valeur un amende efficace LLAMA-2 sur le matériel limité. L'utilisation de Qlora et d'autres techniques rend les LLM avancés accessibles à un public plus large. D'autres ressources et des chemins d'apprentissage sont mentionnés à la fin, similaires à l'original, mais sans les appels marketing à l'action.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!