Umfassender Guide zu Zephyr-7B: Features, Anwendung und Feintuning

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 Aufmerksamkeit bekommen hat, ist Zephyr-7B.

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

Wenn du neu in der Künstlichen Intelligenz bist, wirf einen Blick auf den Skill-Lernpfad AI Fundamentals. Er macht dich fit und bringt dich auf Kurs, um die KI-Engineer-Rolle der Zukunft anzusteuern.

Zephyr-7B verstehen

Zephyr-7B ist ein modernes Sprachmodell, entwickelt von WebPilot.AI. Es gehört zur Zephyr-Reihe von Sprachmodellen, die darauf trainiert sind, als hilfreiche Assistenten zu agieren. Zephyr-7B ist für vielfältige Sprachaufgaben ausgelegt: von der Generierung kohärenter Texte ü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 des Mistral-7B-Modells, trainiert auf einer Kombination aus öffentlichen und synthetischen Datensätzen mittels Direct Preference Optimization (DPO). Dadurch meistert Zephyr-7B-β Aufgaben von der Interpretation komplexer Fragen bis zur Zusammenfassung langer Texte.

Zum Zeitpunkt der Veröffentlichung ist Zephyr-7B-β das höchstplatzierte 7B-Chat-Modell in den Benchmarks MT-Bench und AlpacaEval. Es nutzt die neuesten Fortschritte im Natural Language Processing und setzt Maßstäbe bei Verständnis und Generierung natürlich klingender Texte.

Du kannst die verbesserte Performance in der kostenlosen Demo auf Zephyr Chat selbst testen.

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 ziemlich unkompliziert.

Hinweis: Wenn beim Laden des Modells Probleme auftreten, schau dir das Inference-Kaggle-Notebook an.

Installiere zuerst alle benötigten Bibliotheken. Stelle sicher, dass du die neueste Version verwendest, sonst funktioniert es nicht.

!pip install -q -U transformers\n!pip install -q -U accelerate\n!pip install -q -U bitsandbytes

Lade dann die Pytorch-Bibliothek und das Pipeline-Modul aus transformers.

import torch\nfrom transformers import pipeline

Wir bauen die Textgenerierungspipeline mit dem Modelnamen sowie den Argumenten torch_dtype und device_map.

Das \„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 reduzierter Mantisse. Das ermöglicht schnellere Berechnungen und geringeren Speicherbedarf, jedoch mit etwas geringerer Präzision.

model_name = \"HuggingFaceH4/zephyr-7b-beta\"\n\npipe = pipeline(\n    \"text-generation\",\n    model=model_name,\n    torch_dtype=torch.bfloat16,\n    device_map=\"auto\",\n)

Wir übergeben der Pipeline den Prompt und weitere Parameter und geben die Antwort aus.

prompt = \"Write a Python function that can clean the HTML tags from the file:\"\n\noutputs = pipe(\n    prompt,\n    max_new_tokens=300,\n    do_sample=True,\n    temperature=0.7,\n    top_k=50,\n    top_p=0.95,\n)\nprint(outputs[0][\"generated_text\"])

Die Antwort ist beeindruckend. Das Modell liefert Python-Code inklusive Kommentaren.

Wir können die Modellantwort sogar anpassen, indem wir einen System-Prompt im Zephyr-7B-Stil verwenden.

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

messages = [\n    {\n        \"role\": \"system\",\n        \"content\": \"You are a skilled software engineer who consistently produces high-quality Python code.\",\n    },\n    {\n        \"role\": \"user\",\n        \"content\": \"Write a Python code to display text in a star pattern.\",\n    },\n]\n\nprompt = pipe.tokenizer.apply_chat_template(\n    messages, tokenize=False, add_generation_prompt=True\n)

Zum Schluss übergeben wir der Pipeline den Prompt samt weiterer Argumente, um die Antwort zu generieren.

outputs = pipe(\n    prompt,\n    max_new_tokens=300,\n    do_sample=True,\n    temperature=0.7,\n    top_k=50,\n    top_p=0.95,\n)\nprint(outputs[0][\"generated_text\"])\n

Zephyr-7B liefert eine sehr effiziente Lösung, inklusive Erklärung und Funktionsausgabe. Ziemlich stark. Man kann es sehr gut zur Generierung von Python-Code einsetzen.

Zephyr-7B feinabstimmen

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

Hinweis: Wenn beim Training Probleme auftreten, schau dir das Fine-Tuning-Kaggle-Notebook an.

Setup

Zuerst installieren wir die nötigen Python-Bibliotheken, um Datensatz und Modell zu laden und zu verfeinern.

%%capture\n%pip install -U bitsandbytes\n%pip install -U transformers\n%pip install -U peft\n%pip install -U accelerate\n%pip install -U trl

Anschließend laden wir die Module, die uns das Training mit begrenztem Speicher vereinfachen.

from transformers import (\n    AutoModelForCausalLM,\n    AutoTokenizer,\n    BitsAndBytesConfig,\n    HfArgumentParser,\n    TrainingArguments,\n    pipeline,\n    logging,\n)\nfrom peft import (\n    LoraConfig,\n    PeftModel,\n    prepare_model_for_kbit_training,\n    get_peft_model,\n)\nimport os, torch, wandb\nfrom datasets import load_dataset\nfrom trl import SFTTrainer

Dieser Abschnitt ist spezifisch für Kaggle-Notebooks. Wir haben die API-Keys für Hugging Face und Weights & Biases (wandb) in den Kaggle-Secrets hinterlegt. Wir nutzen sie sicher, um das Modell auf den Hugging Face Hub hochzuladen und das Training live auf Weights & Biases zu monitoren.

from kaggle_secrets import UserSecretsClient\nuser_secrets = UserSecretsClient()\nsecret_hf = user_secrets.get_secret(\"HUGGINGFACE_TOKEN\")\nsecret_wandb = user_secrets.get_secret(\"wandb\")

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

!huggingface-cli login --token $secret_hf

Melde dich ebenso bei wandb an und starte das Projekt.

# Monitoring the LLM\nwandb.login(key = secret_wandb)\nrun = wandb.init(\n    project='Fine tuning Zephyr 7B', \n    job_type=\"training\", \n    anonymous=\"allow\"\n)

Lege die Namen für Basismodell, Datensatz und neues Modell fest, um zu feinabstimmen, zu speichern und auf den Hugging Face Hub zu pushen.

base_model = \"HuggingFaceH4/zephyr-7b-beta\"\ndataset_name = \"THUDM/AgentInstruct\"\nnew_model = \"zephyr-7b-beta-Agent-Instruct\"

AgentInstruct-Datensatz

Wir laden den Datensatz und wandeln ihn mit der Funktion format_prompt in den Zephyr-7B-Promptstil um. Die Funktion extrahiert Rolle und Inhalt aus dem Datensatz und erzeugt daraus lange Strings, die mit einem System-Prompt beginnen und mit einer Standardinstruktion enden.

#Importing the dataset\ndataset = load_dataset(\"THUDM/AgentInstruct\", split=\"train\")\ndef format_prompt(sample):\n    intro = \"Below is a conversation between a user and you.\"\n    end = \"Instruction: Write a response appropriate to the conversation.\"\n\n    try:\n        formatted_conversations = \"\\n\".join(\n            f\"<{resp['from']}>: {resp['value']}\"\n            for resp in sample[\"conversations\"]\n        )\n\n        sample[\"text\"] = f\"{intro}\\n\\n{formatted_conversations}\\n\\n{end}\"\n    except (TypeError, KeyError):\n        raise ValueError(\"Invalid format of the input sample.\")\n    return sample\n\n\n(dataset = dataset.map(\n    format_prompt,\n    remove_columns=[\"conversations\"]\n))\ndataset[\"text\"][100]

Modell und Tokenizer laden

Wir laden ein 4-Bit-Quantisierungsmodell von Hugging Face, um schneller trainieren zu können. Das ist notwendig, wenn GPUs nur wenig VRAM haben. Danach laden wir den Tokenizer und konfigurieren ihn, um ein Problem mit fp16 zu umgehen.

bnb_config = BitsAndBytesConfig(  \n    load_in_4bit= True,\n    bnb_4bit_quant_type= \"nf4\",\n    bnb_4bit_compute_dtype= torch.bfloat16,\n    bnb_4bit_use_double_quant= False,\n)\nmodel = AutoModelForCausalLM.from_pretrained(\n        base_model,\n        load_in_4bit=True,\n        quantization_config=bnb_config,\n        torch_dtype=torch.bfloat16,\n        device_map=\"auto\",\n        trust_remote_code=True,\n)\nmodel.config.use_cache = False\nmodel.config.pretraining_tp = 1\nmodel.gradient_checkpointing_enable()\n\n# Load tokenizer\ntokenizer = AutoTokenizer.from_pretrained(base_model, trust_remote_code=True)\ntokenizer.padding_side = 'right'\ntokenizer.pad_token = tokenizer.eos_token\ntokenizer.add_eos_token = True\ntokenizer.add_bos_token, tokenizer.add_eos_token

Das Modell aufbauen

Wir fügen nun eine Adapter-Schicht hinzu, um effizienter feinabzustimmen. Statt das komplette Modell zu trainieren, aktualisieren wir nur die Parameter in der Adapter-Schicht und beschleunigen so das Training.

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

Training

Es ist wichtig, die richtigen Hyperparameter in den Trainingsargumenten zu setzen. Details zu den einzelnen Parametern 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\ntraining_arguments = TrainingArguments(\n    output_dir=\"./results\",\n    num_train_epochs=1,\n    per_device_train_batch_size=4,\n    gradient_accumulation_steps=1,\n    optim=\"paged_adamw_32bit\",\n    save_steps=25,\n    logging_steps=25,\n    learning_rate=2e-4,\n    weight_decay=0.001,\n    fp16=False,\n    bf16=False,\n    max_grad_norm=0.3,\n    max_steps=-1,\n    warmup_ratio=0.03,\n    group_by_length=True,\n    lr_scheduler_type=\"constant\",\n    report_to=\"wandb\"\n)\n\n\n# Setting sft parameters\ntrainer = SFTTrainer(\n    model=model,\n    train_dataset=dataset,\n    peft_config=peft_config,\n    max_seq_length= 512,\n    dataset_text_field=\"text\",\n    tokenizer=tokenizer,\n    args=training_arguments,\n    packing= False,\n)\n\n\ntrainer.train()

Nach rund 1 Stunde und 40 Minuten war das Training abgeschlossen, und der Trainingsverlust sank stetig.

Hier ist eine detailliertere Auswertung auf Weights & Biases.

Jetzt speichern wir das Modell, beenden die wandb-Session und pushen das Modell zum Hugging Face Hub. Dadurch entsteht ein Modell-Repository mit gespeicherter Adapter-Datei.

# Save the fine-tuned model\ntrainer.model.save_pretrained(new_model)\nwandb.finish()\n\ntrainer.model.push_to_hub(new_model, use_temp_dir=False)

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)\n\nprompt = \"How to use Python online with DataCamp?\"\npipe = pipeline(task=\"text-generation\", model=model, tokenizer=tokenizer, max_length=200)\nresult = pipe(prompt)\nprint(result[0]['generated_text'])

Die Antwort ähnelt der von AgentGPT, einem automatischen KI-Agenten, der mehrere Aufgaben mithilfe verschiedener Erweiterungen ausführt und Ergebnisse auf dem Niveau fortgeschrittener KI-Systeme erzielt. Diese Systeme können ähnlich wie Menschen Aufgaben erledigen, etwa im Web recherchieren, Code aktualisieren und testen.

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

prompt = \"What is Datacamp Career track?\"\nresult = pipe(prompt)\nprint(result[0]['generated_text'])

Wir haben eine Antwort erhalten, die aber zu weiteren Fragen und Antworten führte (nicht alle sind korrekt) – durchaus spannend.

Der nächste Schritt ist, dieses Modell zu nutzen, um deine eigene KI-Anwendung zu bauen. Dafür brauchst du Tools, die dir die Arbeit erleichtern. Hier findest du 7 unverzichtbare Generative-AI-Tools, mit denen du herausragende KI-Anwendungen entwickeln kannst.

Fazit

Das große Sprachmodell Zephyr-7B-beta zeigt beeindruckende Fähigkeiten beim Verstehen und beim präzisen Antworten. In diesem Tutorial hast du Zephyr-7B kennengelernt und erfahren, wie du über die Transformers-Pipeline darauf zugreifst. Außerdem hast du gesehen, wie du es mit einem Agent-Datensatz feinabstimmst, wodurch es besser schlussfolgert und instruktionsartige Antworten ähnlich wie AgentGPT liefert.

Dieser Guide ist eine umfassende Ressource für Machine-Learning-Enthusiasten auf jedem Niveau, die mit großen Sprachmodellen auf GPUs mit begrenztem Speicher experimentieren und sie feinabstimmen möchten.

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