Umfassender Guide zu Zephyr-7B: Features, Nutzung und Fine-Tuning

Alle schauen auf das OpenAI LLM Leaderboard und die neuen Open-Source-Modelle, die an die Leistung von GPT-4 heranreichen wollen. Ein Modell, das zuletzt viel Aufsehen erregt hat, ist Zephyr-7B.

In diesem Tutorial lernst du das Sprachmodell Zephyr-7B kennen. Wir greifen über die Transformers-Pipeline darauf zu und verfeinern das Modell mit einem Agent-Instruct-Datensatz.

Wenn du neu in der Künstlichen Intelligenz bist, sieh dir den Skill-Lernpfad AI Fundamentals an. Er macht dich fit und bringt dich auf den Weg zur KI-Engineer-Rolle der Zukunft.

Zephyr-7B verstehen

Zephyr-7B ist ein modernes Sprachmodell von WebPilot.AI. Es gehört zur Zephyr-Reihe von Modellen, die darauf trainiert sind, als hilfreiche Assistenten zu agieren. Zephyr-7B wurde für vielfältige Sprachaufgaben entwickelt – von kohärenter Textgenerierung über Übersetzungen, Zusammenfassungen und Stimmungsanalysen bis hin zu kontextbasierten Antworten.

Zephyr-7B-β

Zephyr-7B-β ist das zweite Modell der Reihe. Es ist eine feinabgestimmte Version von Mistral-7B, trainiert auf einer Kombination aus öffentlichen und synthetischen Datensätzen mittels Direct Preference Optimization (DPO). Dadurch bewältigt Zephyr-7B-β Aufgaben von der Interpretation komplexer Fragen bis zum Zusammenfassen langer Texte.

Zum Veröffentlichungszeitpunkt ist Zephyr-7B-β das bestplatzierte 7B-Chatmodell auf den Benchmarks MT-Bench und AlpacaEval. Es nutzt die neuesten Fortschritte in der Sprachverarbeitung, um ein noch besseres Verständnis und natürlichere Textgenerierung zu erreichen.

Du kannst die verbesserte Performance in einer kostenlosen Demo auf Zephyr Chat ausprobieren.

Bildquelle: Zephyr Chat

Zugriff auf Zephyr-7B

Ähnlich wie im Mistral 7B Tutorial laden und nutzen wir Zephyr-7B-beta mit Hugging Face transformers. Das ist recht unkompliziert.

Hinweis: Wenn du Probleme beim Laden des Modells hast, sieh dir das Inference-Kaggle-Notebook an.

Installiere zuerst alle benötigten Bibliotheken. Achte darauf, die neueste Version zu verwenden, sonst funktioniert es nicht.

!pip install -q -U transformers
!pip install -q -U accelerate
!pip install -q -U bitsandbytesBereitgestellt von

Lade dann PyTorch und das Pipeline-Modul aus transformers.

import torch
from transformers import pipelineBereitgestellt von

Wir bauen die Textgenerierungs-Pipeline mit Modellname sowie den Argumenten torch_dtype und device_map.

„auto“ in device_map bedeutet, dass mehrere GPUs genutzt werden können, um die Antwort schneller zu erzeugen.

torch.bfloat16 (brain float) ist ein 16-Bit-Gleitkomma-Datentyp mit derselben Exponentengröße wie torch.float32, aber geringerer Mantissenlänge. Das ermöglicht schnellere Berechnungen und geringeren Speicherbedarf – bei etwas geringerer Präzision.

model_name = "HuggingFaceH4/zephyr-7b-beta"

pipe = pipeline(
    "text-generation",
    model=model_name,
    torch_dtype=torch.bfloat16,
    device_map="auto",
)Bereitgestellt von

Wir geben der Pipeline den Prompt und weitere Parameter mit und drucken die Antwort aus.

prompt = "Write a Python function that can clean the HTML tags from the file:"

outputs = pipe(
    prompt,
    max_new_tokens=300,
    do_sample=True,
    temperature=0.7,
    top_k=50,
    top_p=0.95,
)
print(outputs[0]["generated_text"])Bereitgestellt von

Die Antwort ist beeindruckend: Es wird Python-Code inklusive Kommentaren geliefert.

Wir können die Modellantwort sogar anpassen, indem wir einen Systemprompt im Zephyr-7B-Stil mitgeben.

Dafür nutzen wir pipe.tokenizer.apply_chat_template, um aus einer Liste von Dictionaries einen Prompt zu erzeugen. Die Dictionaries enthalten die Rollen- und Verhaltensbeschreibung des Chat-Assistenten sowie den Nutzerprompt.

messages = [
    {
        "role": "system",
        "content": "You are a skilled software engineer who consistently produces high-quality Python code.",
    },
    {
        "role": "user",
        "content": "Write a Python code to display text in a star pattern.",
    },
]

prompt = pipe.tokenizer.apply_chat_template(
    messages, tokenize=False, add_generation_prompt=True
)Bereitgestellt von

Zum Schluss übergeben wir den Prompt an die Pipeline und generieren die Antwort mit zusätzlichen Parametern.

outputs = pipe(
    prompt,
    max_new_tokens=300,
    do_sample=True,
    temperature=0.7,
    top_k=50,
    top_p=0.95,
)
print(outputs[0]["generated_text"])
Bereitgestellt von

Zephyr-7B liefert eine sehr effiziente Lösung – inklusive Erklärung und Ausgabe der Funktion. Stark. Ideal, um Python-Code zu generieren.

Zephyr-7B feinabstimmen

In diesem Abschnitt zeigen wir, wie du das Modell Zephyr-7B-beta mit kostenlosen GPUs von Kaggle auf einem eigenen Datensatz feinabstimmst. Wenn du den Schritten folgst, ist dein Modell in rund zwei Stunden einsatzbereit.

Hinweis: Wenn du beim Training auf Probleme stößt, sieh dir das Fine-Tuning-Kaggle-Notebook an.

Setup

Installiere zuerst die nötigen Python-Bibliotheken, um den Datensatz und das Modell zu laden und zu finetunen.

%%capture
%pip install -U bitsandbytes
%pip install -U transformers
%pip install -U peft
%pip install -U accelerate
%pip install -U trlBereitgestellt von

Anschließend laden wir die Module, die das Training mit wenig Speicher erleichtern.

from transformers import (
    AutoModelForCausalLM,
    AutoTokenizer,
    BitsAndBytesConfig,
    HfArgumentParser,
    TrainingArguments,
    pipeline,
    logging,
)
from peft import (
    LoraConfig,
    PeftModel,
    prepare_model_for_kbit_training,
    get_peft_model,
)
import os, torch, wandb
from datasets import load_dataset
from trl import SFTTrainerBereitgestellt von

Dieser Teil bezieht sich speziell auf Kaggle-Notebooks. Wir haben die API-Keys für Hugging Face und Weights & Biases (wandb) in den Kaggle Secrets hinterlegt. Damit laden wir das Modell sicher in den Hugging Face Hub hoch und verfolgen das Training live auf den Weights-&-Biases-Servern.

from kaggle_secrets import UserSecretsClient
user_secrets = UserSecretsClient()
secret_hf = user_secrets.get_secret("HUGGINGFACE_TOKEN")
secret_wandb = user_secrets.get_secret("wandb")Bereitgestellt von

Melde dich bei Hugging Face per CLI und API-Token an.

!huggingface-cli login --token $secret_hfBereitgestellt von

Melde dich ebenso bei wandb an und starte das Projekt.

# Monitoring the LLM
wandb.login(key = secret_wandb)
run = wandb.init(
    project='Fine tuning Zephyr 7B', 
    job_type="training", 
    anonymous="allow"
)Bereitgestellt von

Lege die Namen für Basismodell, Datensatz und das neue Modell fest – für Fine-Tuning, Speichern und Push in den Hugging Face Hub.

base_model = "HuggingFaceH4/zephyr-7b-beta"
dataset_name = "THUDM/AgentInstruct"
new_model = "zephyr-7b-beta-Agent-Instruct"Bereitgestellt von

AgentInstruct-Datensatz

Wir laden den Datensatz und bringen ihn mit der Funktion format_prompt in den Zephyr-7B-Promptstil. Die Funktion extrahiert Rolle und Inhalt aus dem Datensatz und baut daraus einen langen String, der mit einem Systemprompt beginnt und mit einer Standardinstruktion endet.

#Importing the dataset
dataset = load_dataset("THUDM/AgentInstruct", split="train")
def format_prompt(sample):
    intro = "Below is a conversation between a user and you."
    end = "Instruction: Write a response appropriate to the conversation."

    try:
        formatted_conversations = "\n".join(
            f"<{resp['from']}>: {resp['value']}"
            for resp in sample["conversations"]
        )

        sample["text"] = f"{intro}\n\n{formatted_conversations}\n\n{end}"
    except (TypeError, KeyError):
        raise ValueError("Invalid format of the input sample.")
    return sample


dataset = dataset.map(
    format_prompt,
    remove_columns=["conversations"]
)
dataset["text"][100]Bereitgestellt von

Modell und Tokenizer laden

Wir laden ein 4-Bit-Modell von Hugging Face, um schneller zu trainieren. Das ist bei GPUs mit begrenztem VRAM sinnvoll. Danach laden wir den Tokenizer und konfigurieren ihn, um ein fp16-Problem zu umgehen.

bnb_config = BitsAndBytesConfig(  
    load_in_4bit= True,
    bnb_4bit_quant_type= "nf4",
    bnb_4bit_compute_dtype= torch.bfloat16,
    bnb_4bit_use_double_quant= False,
)
model = AutoModelForCausalLM.from_pretrained(
        base_model,
        load_in_4bit=True,
        quantization_config=bnb_config,
        torch_dtype=torch.bfloat16,
        device_map="auto",
        trust_remote_code=True,
)
model.config.use_cache = False
model.config.pretraining_tp = 1
model.gradient_checkpointing_enable()

# Load tokenizer
tokenizer = AutoTokenizer.from_pretrained(base_model, trust_remote_code=True)
tokenizer.padding_side = 'right'
tokenizer.pad_token = tokenizer.eos_token
tokenizer.add_eos_token = True
tokenizer.add_bos_token, tokenizer.add_eos_tokenBereitgestellt von

Modell aufbauen

Wir fügen nun eine Adapter-Schicht hinzu, um effizienter zu finetunen. Statt das gesamte Modell zu aktualisieren, passen wir nur die Adapter-Parameter an – das beschleunigt das Training deutlich.

model = prepare_model_for_kbit_training(model)
peft_config = LoraConfig(
    lora_alpha=16,
    lora_dropout=0.1,
    r=64,
    bias="none",
    task_type="CAUSAL_LM",
    target_modules=['up_proj', 'base_layer', 'down_proj']
)
model = get_peft_model(model, peft_config)Bereitgestellt von

Modell trainieren

Es ist wichtig, die richtigen Hyperparameter in den Trainingsargumenten zu setzen. Details dazu findest du im Tutorial Fine-Tuning LLaMA 2.

Anschließend nutzen wir die TRL-Bibliothek von Hugging Face, um den SFT Trainer mit Modell, Datensatz, Lora-Konfiguration, Tokenizer und Trainingsparametern aufzubauen.

Zum Schluss starten wir das Training.

#Hyperparamter
training_arguments = TrainingArguments(
    output_dir="./results",
    num_train_epochs=1,
    per_device_train_batch_size=4,
    gradient_accumulation_steps=1,
    optim="paged_adamw_32bit",
    save_steps=25,
    logging_steps=25,
    learning_rate=2e-4,
    weight_decay=0.001,
    fp16=False,
    bf16=False,
    max_grad_norm=0.3,
    max_steps=-1,
    warmup_ratio=0.03,
    group_by_length=True,
    lr_scheduler_type="constant",
    report_to="wandb"
)


# Setting sft parameters
trainer = SFTTrainer(
    model=model,
    train_dataset=dataset,
    peft_config=peft_config,
    max_seq_length= 512,
    dataset_text_field="text",
    tokenizer=tokenizer,
    args=training_arguments,
    packing= False,
)


trainer.train()Bereitgestellt von

Nach etwa 1 Stunde und 40 Minuten war das Training abgeschlossen – mit einer stetigen Reduktion des Training Loss.

Hier siehst du eine detailliertere Auswertung in Weights & Biases.

Jetzt speichern wir das Modell, beenden die wandb-Session und pushen das Modell in den Hugging Face Hub. Dadurch entsteht ein Modell-Repository mit gespeicherten Adapter-Dateien.

# Save the fine-tuned model
trainer.model.save_pretrained(new_model)
wandb.finish()

trainer.model.push_to_hub(new_model, use_temp_dir=False)Bereitgestellt von

Hier ist das feinabgestimmte Modell-Repository, auf das du so zugreifen kannst: hf.co/kingabzpro/zephyr-7b-beta-Agent-Instruct

Jetzt ist es Zeit, unser feinabgestimmtes Modell mit verschiedenen Prompts zu testen.

Wir haben das Modell gefragt, wie man Python online mit DataCamp nutzt.

logging.set_verbosity(logging.CRITICAL)

prompt = "How to use Python online with DataCamp?"
pipe = pipeline(task="text-generation", model=model, tokenizer=tokenizer, max_length=200)
result = pipe(prompt)
print(result[0]['generated_text'])Bereitgestellt von

Die Antwort erinnert an AgentGPT, einen automatischen KI-Agenten, der mithilfe von Erweiterungen mehrere Aufgaben übernimmt und Ergebnisse ähnlich fortgeschrittener KI-Systeme erzielt. Diese Systeme können Aufgaben wie Websuche, Codeänderungen und Tests übernehmen.

Statt nach Schrittlisten zu fragen, stellen wir unserem Modell jetzt eine einfache Frage zum DataCamp Career Track.

prompt = "What is Datacamp Career track?"
result = pipe(prompt)
print(result[0]['generated_text'])Bereitgestellt von

Wir haben eine Antwort erhalten, die weitere Fragen und Antworten nach sich zog (nicht alle sind korrekt) – durchaus spannend.

Der nächste Schritt ist, mit diesem Modell eine eigene KI-Anwendung zu bauen. Dafür brauchst du Tools, die dir die Arbeit erleichtern. Hier sind 7 unverzichtbare Generative-AI-Tools, mit denen du erstklassige KI-Anwendungen entwickelst.

Fazit

Das große Sprachmodell Zephyr-7B-beta zeigt beeindruckende Fähigkeiten im Verstehen und in präzisen Antworten. In diesem Tutorial hast du Zephyr-7B kennengelernt und erfahren, wie du es über die Transformers-Pipeline nutzt. Außerdem haben wir gezeigt, wie du es auf einem Agent-Datensatz feinabstimmst – für bessere Argumentation und instruktionale Antworten ähnlich zu AgentGPT.

Dieser Guide ist eine umfassende Ressource für ML-Enthusiast:innen aller Erfahrungsstufen, die mit großen Sprachmodellen auf GPUs mit wenig Speicher experimentieren und sie feinabstimmen wollen.

Melde dich für den Kurs Master Large Language Models (LLMs) Concepts an und lerne die Bausteine, Trainingsmethoden und Techniken hinter Modellen wie Zephyr-7B kennen.