Feinabstimmungslama 2: Eine Schritt-für-Schritt-Anleitung zum Anpassen des großen Sprachmodells

Das Lama von

Meta löste einen Anstieg der LLM-Entwicklung (Langual Language Model) aus und zielte darauf ab, Modelle wie GPT-3.5 zu konkurrieren. Die Open-Source-Community produzierte schnell zunehmend leistungsstarke Modelle, aber diese Fortschritte waren nicht ohne Herausforderungen. Viele Open-Source-LLMs hatten restriktive Lizenzen (nur Forschungsnutzung), erforderte erhebliche Budgets für die Feinabstimmung und waren teuer für den Einsatz.

Die neue Iteration von

llama befasst sich mit diesen Problemen mit einer kommerziellen Lizenz und neuen Methoden, die eine Feinabstimmung von GPUs der Verbraucherqualität mit begrenztem Speicher ermöglichen. Diese demokratisierte KI und ermöglicht es auch kleinere Organisationen, maßgeschneiderte Modelle zu erstellen.

Dieser Leitfaden demonstriert in Google Colab Fine-Tuning LLAMA-2, wobei effiziente Techniken zur Überwindung von Ressourcenbeschränkungen verwendet werden. Wir werden Methoden untersuchen, die den Speicherverbrauch minimieren und das Training beschleunigen.

Bild erzeugt vom Autor mit Dall-e 3

Feinabstimmungslama-2: Eine Schritt-für-Schritt-Anleitung

Dieses Tutorial-Finanzunternehmen Das 7-Milliarden-Parameter-LLAMA-2-Modell auf einer T4-GPU (verfügbar auf Google Colab oder Kaggle). Das 16-GB-VRAM des T4 erfordert eine parametereffiziente Feinabstimmung, insbesondere unter Verwendung von Qlora (4-Bit-Genauigkeit). Wir werden das umarmende Gesichtsökosystem verwenden (Transformers, Accelerate, PEFT, TRL, BitsandBytes).

1. Setup:

Installieren Sie die erforderlichen Bibliotheken:

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

Module importieren:

<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. Modell- und Datensatzauswahl:

Wir werden NousResearch/Llama-2-7b-chat-hf (ein leicht zugängliches Äquivalent zum offiziellen LAMA-2) als Basismodell und mlabonne/guanaco-llama2-1k als unser kleineres Trainingsdatensatz verwenden.

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

Bilder, die das Umarmungsgesichtsmodell und den Datensatz veranschaulichen, sind hier enthalten, wie original.

3. Datenladen & Modell:

Laden Sie den Datensatz:

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

4-Bit-Quantisierung mit Qlora konfigurieren:

<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>

Laden Sie das LLAMA-2-Modell mit 4-Bit-Quantisierung:

<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>

Laden Sie den Tokenizer:

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

Bild veranschaulichen Qlora hier, genau wie Original.

4. PEFT -Konfiguration:

PEFT-Parameter für eine effiziente Feinabstimmung definieren:

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

5. Trainingsparameter:

Trainingshyperparameter (Ausgabeverzeichnis, Epochen, Chargengrößen, Lernrate usw.) festlegen. Details entsprechen dem Original.

6. Feinabstimmung mit SFT:

Verwenden Sie die SFTTrainer aus der TRL-Bibliothek für überwachte Feinabstimmungen:

<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>

Screenshots, die den Trainingsfortschritt und die Modelleinsparung zeigen, sind hier enthalten, wie Original.

7. Bewertung:

Verwenden Sie die transformers -Pipeline, um das fein abgestimmte Modell zu testen. Beispiele werden vorgesehen, wie original.

8. Tensorboard -Visualisierung:

Tensorboard für die Überwachung von Trainingsmetriken starten.

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

Screenshot von Tensorboard ist hier enthalten, wie original.

Schlussfolgerung:

Diese Anleitung zeigt eine effiziente Lama-2-Feinabstimmung mit begrenzter Hardware. Die Verwendung von Qlora und anderen Techniken macht erweiterte LLMs für ein breiteres Publikum zugänglich. Weitere Ressourcen und Lernwege werden am Ende erwähnt, ähnlich wie das Original, jedoch ohne die Handlungsaufrufe.

Das obige ist der detaillierte Inhalt vonFeinabstimmungslama 2: Eine Schritt-für-Schritt-Anleitung zum Anpassen des großen Sprachmodells. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!