Ein Deep Dive in das Phi-2-Modell

In diesem Blog tauchen wir tief in das Phi-2-Modell ein, vergleichen seine Leistung mit anderen Modellen und schauen uns sein Training an. Außerdem zeigen wir, wie du über die Transformers-Bibliothek auf das Modell zugreifst und es mit einem Rollenspiel-Datensatz von Hugging Face feinabstimmst.

Was ist Phi-2?

Phi-2 ist ein Sprachmodell mit 2,7 Milliarden Parametern, entwickelt von Microsoft Research. Es gehört zur "Phi"-Reihe kleiner Sprachmodelle von Microsoft, die mit deutlich größeren Modellen leistungsmäßig mithalten sollen.

Phi-2 basiert auf einer Transformer-Architektur. Es wurde mit 1,4 Billionen Tokens aus einer Kombination aus synthetischen und Web-Datensätzen für Natural Language Processing und Coding trainiert. Es handelt sich um ein Basismodell, das weder instruktionsbasiert feinabgestimmt noch über Reinforcement Learning from Human Feedback (RLHF) ausgerichtet wurde.

Die Entwicklung von Phi-2 fußte auf zwei zentralen Erkenntnissen:

• Qualität der Trainingsdaten: Der Fokus auf "Lehrbuch-Qualität" nutzt synthetische Datensätze und hochwertige Webinhalte und vermittelt dem Modell Alltagswissen, Common-Sense-Reasoning, Allgemeinwissen, Naturwissenschaften, typische Tätigkeiten und mehr.
• Skalierter Wissenstransfer: Wissen aus dem 1,3-Milliarden-Parameter-Modell Phi-1.5 wird in das 2,7-Milliarden-Parameter-Modell Phi-2 übertragen, was das Training beschleunigt und die Benchmarks von Phi-2 verbessert.

Lerne die Bausteine, Trainingsmethoden und Techniken für die Entwicklung großer Sprachmodelle wie Phi-2 im Kurs Master LLM Concepts kennen.

Phi-2 im Vergleich zu anderen Sprachmodellen

Phi-2 übertrifft Modelle mit 7–13 Milliarden Parametern wie Llama-2 und Mistral in mehreren Benchmarks zu Common-Sense-Reasoning, Sprachverständnis, Mathematik und Coding. Bei Aufgaben mit mehrstufigem Schlussfolgern, etwa beim Programmieren und in der Mathematik, liegt es sogar vor dem 25-mal größeren Llama-2-70B.

Bild Quelle

Wir bewegen uns in Richtung kleinerer Modelle, die sich leicht feinabstimmen und bereitstellen lassen. Solche Modelle können direkt auf mobilen Geräten laufen und Leistungen ähnlich den großen Sprachmodellen erreichen. Trotz seiner geringeren Größe übertrifft Phi-2 Google Gemini Nano 2 in den Benchmarks Big Bench Hard, BoolQ und MBPP.

Bild Quelle

Zugriff auf das Phi-2-Modell

Die Leistung von Phi-2 kannst du direkt in der Phi 2 Streaming on GPU-Demo auf Hugging Face Spaces erleben. Die Demo bietet eine einfache Möglichkeit, einen Prompt einzugeben und schnell eine Antwort zu generieren.

Wenn du neu in der KI bist und eine eigene Anwendung entwickeln willst, starte mit dem Skill-Lernpfad AI Fundamentals.

Im nächsten Schritt laden wir Phi-2 mit der Transformers-Pipeline und führen Inferenz durch. Stelle sicher, dass du die neueste Version von Transformers und Accelerate installiert hast, damit die Pipeline fehlerfrei läuft.

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

Wir übergeben der Pipeline den Aufgabentyp, den Modellnamen und den Gerätezuordnungs-Typ und vertrauen dem Remote-Code, um Warnungen zu vermeiden. Mit device_map auf "auto" nutzen wir mehrere GPUs auf der Kaggle-Plattform.

from transformers import pipeline

model_name = "microsoft/phi-2"

pipe = pipeline(
    "text-generation",
    model=model_name,
    device_map="auto",
    trust_remote_code=True,
)

Gib dem Pipeline-Objekt Prompt, maximale Tokenanzahl, Temperatur und weitere Einstellungen mit, um eine Antwort zu erzeugen. Anschließend wandeln wir die Markdown-Antwort in HTML um, inklusive Überschriften, Codeblöcken und weiteren Elementen.

from IPython.display import Markdown

prompt = "Please create a Python application that can change wallpapers automatically."

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

Die Ergebnisse sind beeindruckend. Phi-2 generiert den Code zusammen mit Erklärungen und einer Setup-Anleitung. Erhöhe die maximale Tokenanzahl auf 1000, um die vollständige Lösung zu erhalten.

Grundlegende Anwendungen

Das Modell ist klein genug, um auf deinem Laptop oder mobilen Geräten zu laufen. Du kannst damit Fragen stellen, Code generieren und dich vernünftig unterhalten. Schauen wir uns Beispiele an, wie wir das Potenzial des Modells voll ausschöpfen.

Q&A

Wir können Phi-2 einfache, direkte Fragen stellen, und es versucht, präzise zu antworten.

outputs = pipe( "Who is the richest person in the world?",max_new_tokens=70)
print(outputs[0]["generated_text"])

Jeff Bezos liegt aktuell auf Platz drei—offenbar wurde das Modell auf älteren Daten trainiert.

Who is the richest person in the world?
The richest person in the world is Jeff Bezos, the founder of Amazon. He is worth $137 billion.

Code

Code-Autovervollständigung ist in allen Technikbereichen entscheidend und ein Kernfeature moderner IDEs. Wir können das Modell bitten, Code zu vervollständigen, indem wir Funktionsnamen und Aufgabe vorgeben.

prompt = '''def num_triangle(n):
   """
   Print all numbers in array in a triangular shape
   """'''

outputs = pipe(prompt,max_new_tokens=120)

print(outputs[0]["generated_text"])

Auch hier ist das Ergebnis korrekt.

def num_triangle(n):
   """
   Print all numbers in array in a triangular shape
   """
   for i in range(1, n+1):
      for j in range(1, i+1):
         print(j, end=" ")
      print()

Chat

Phi-2 verfügt nicht über eine Konversationsvorlage und wurde nicht auf Dialogdaten trainiert. Wir können es dennoch als Chatbot nutzen, indem wir die Pipeline für Konversationsaufgaben verwenden.

Dafür übergeben wir der Pipeline einfach Gespräche. Sie nutzt dann den Kontext der vorangegangenen Nachrichten, um eine Antwort zu generieren.

from transformers import pipeline, Conversation

model_name = "microsoft/phi-2"

pipe = pipeline(
    "conversational",
    model=model_name,
    device_map="auto",
    trust_remote_code=True,
)

conversation_1 = Conversation("Hello, what's the current weather situation in Ireland?")
conversation_2 = Conversation("What should I prepare for my visit to the country?")
chat = pipe([conversation_1, conversation_2])

for i in range(len(chat)):
    print("user: ",chat[i].messages[0]["content"].split("<|im_end|>")[0])
    print("assistant: ",chat[i].messages[1]["content"].split("<|im_end|>")[0],"\n")

Die Originalausgabe enthielt mehrstufige Dialoge mit dem Assistant, aber wir betrachten hier nur die erste Antwort je Konversation.

user: Hello, what's the current weather situation in Ireland?
assistant: The current weather in Ireland is sunny with a high of 25....
user: What should I prepare for my visit to the country?
assistant: You should prepare your passport, visa, and any necessary.....

Den Inferenz-Code für Phi-2 findest du im Kaggle-Notebook des Autors.

Phi-2 feinabstimmen

In diesem Abschnitt laden wir das Modell microsoft/phi-2 vom Hugging Face Hub und stimmen es auf dem Datensatz hieunguyenminh/roleplay fein ab. Der Datensatz soll Konversations-KI auf eine Vielzahl fiktionaler Charaktere trainieren.

Setup

Installieren wir die aktuellen Python-Pakete für dieses Tutorial. Wir nutzen die kostenlosen GPUs von Kaggle, die schneller sind und mehr VRAM bieten als Google Colab.

%%capture
%pip install -U bitsandbytes
%pip install -U transformers
%pip install -U peft
%pip install -U accelerate
%pip install -U datasets
%pip install -U trl

Importiere alle benötigten Module und Bibliotheken für Laden, Vorverarbeitung und Training des Modells.

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
from datasets import load_dataset
from trl import SFTTrainer

Jetzt definieren wir Variablen für Basismodell, Datensatz und Namen des feinabgestimmten Modells. Wir verwenden sie mehrfach zum Laden von Datensatz, Modell und Tokenizer sowie für Training und Speichern.

base_model = "microsoft/phi-2"
dataset_name = "hieunguyenminh/roleplay"
new_model = "phi-2-role-play"

Login bei der Hugging Face CLI

Wir laden das Basismodell herunter und laden das feinabgestimmte Modell in den Hugging Face Hub hoch. Dafür melden wir uns mit einem API-Token bei der Hugging Face CLI an.

Lade den API-Schlüssel sicher über die Kaggle-Bibliothek.

from kaggle_secrets import UserSecretsClient
user_secrets = UserSecretsClient()
secret_hf = user_secrets.get_secret("HUGGINGFACE_TOKEN")

Verwende den API-Token für den Login bei der Hugging Face CLI.

!huggingface-cli login --token $secret_hf

Den Datensatz laden

Wir laden nur die ersten 1000 Zeilen des Datensatzes. So verkürzen wir die Trainingszeit und erhalten schnell Basisresultate.

#Importing the dataset
dataset = load_dataset(dataset_name, split="train[0:1000]")
dataset["text"][100]

Die Prompt-Struktur hat drei Teile: System, User und die Antwort des Assistants.

Modell und Tokenizer laden

Obwohl das Modell klein ist, braucht die Feinabstimmung viel Speicher. Wir vermeiden Engpässe, indem wir ein 4-Bit-Quantisierungsmodell vom Hugging Face Hub laden. Das beschleunigt das Training. Anschließend laden wir den Tokenizer und setzen das Pad-Token.

# Load base model(Phi-2)
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,
    quantization_config=bnb_config,
    device_map="auto",
    trust_remote_code=True,
)

model.config.use_cache = False
model.config.pretraining_tp = 1


# Load tokenizer
tokenizer = AutoTokenizer.from_pretrained(base_model, trust_remote_code=True)
tokenizer.pad_token = tokenizer.eos_token

Adapter-Layer hinzufügen

Mit einem Adapter-Layer lässt sich das Modell effizienter feinabstimmen. Anstatt das gesamte Modell zu trainieren, aktualisieren wir nur die Parameter der Adapter-Layer—das beschleunigt das Training deutlich.

Wichtig: Dies ist die aktuellste Modellausführung. Achte darauf, die richtigen Zielmodule auszuwählen.

model = prepare_model_for_kbit_training(model)
peft_config = LoraConfig(
    r=16,
    lora_alpha=16,
    lora_dropout=0.05,
    bias="none",
    task_type="CAUSAL_LM",
    target_modules=[
        'q_proj',
        'k_proj',
        'v_proj',
        'dense',
        'fc1',
        'fc2',
    ]
)
model = get_peft_model(model, peft_config)

Das Modell trainieren

Setze die Hyperparameter passend zu deiner Hardware und dem Datensatz. Um GPU-Speicherprobleme zu vermeiden, folge einfach den Trainingsargumenten aus dem Tutorial. Wenn du die Hyperparameter im Detail verstehen willst, lies das Tutorial Fine-Tuning LLaMA 2.

training_arguments = TrainingArguments(
    output_dir="./phi-2-role-play",
    num_train_epochs=1,
    per_device_train_batch_size=2,
    gradient_accumulation_steps=1,
    optim="paged_adamw_32bit",
    save_strategy="epoch",
    logging_steps=100,
    logging_strategy="steps",
    learning_rate=2e-4,
    fp16=False,
    bf16=False,
    group_by_length=True,
    disable_tqdm=False,
    report_to="none",
)

Nun konfigurieren wir den Supervised-Fine-Tuning-(SFT)-Trainer. Wir übergeben Modell, Datensatz, LoRA-Konfiguration, Tokenizer und Trainingsparameter.

trainer = SFTTrainer(
    model=model,
    train_dataset=dataset,
    peft_config=peft_config,
    max_seq_length= 2048,
    dataset_text_field="text",
    tokenizer=tokenizer,
    args=training_arguments,
    packing= False,
)

Ist alles konfiguriert, starten wir das Training. Der Loss sinkt Schritt für Schritt. Trainiere länger als eine Epoche, um die Leistung weiter zu steigern.

trainer.train()

Modell speichern

Speichere das Modell lokal und lade es in den Hugging Face Hub hoch, um schnell eine Web-App zu bauen oder das Modell zu teilen.

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

Bild Quelle

Modellevaluierung

Wir laden das feinabgestimmte Modell und den Tokenizer in die Transformers-Pipeline. Den Prompt übergeben wir im gleichen Format wie im Datensatz.

logging.set_verbosity(logging.CRITICAL)

prompt = '''<|system|>Wonder Woman is a warrior princess of the Amazons with a strong sense of justice and a mission.
<|user|> What motivates you to fight for peace and love? 
<|assistant|>'''
pipe = pipeline(task="text-generation", model=model, tokenizer=tokenizer, max_length=200)
result = pipe(prompt)
print(result[0]['generated_text'])

Die Antwort wurde im Stil von Wonder Woman erzeugt. Damit kannst du im Handumdrehen einen individuellen Chatbot bauen, der Fragen an verschiedene fiktive Charaktere beantwortet.

Fragen wir Yoda nach der Bedeutung von Liebe.

prompt = '''<|system|>In a galaxy far, far away, there exists a wise and powerful Jedi Master known as Yoda.
<|user|> What is the meaning of love? 
<|assistant|>'''
result = pipe(prompt)
print(result[0]['generated_text'])

Yodas Worte sind weise. Liebe ist die Kraft, die alles zusammenhält.

Sieh dir das Kaggle-Notebook Fine-Tuning Phi-2 an, um Code und Ausgaben nachzuvollziehen. So kannst du die Ergebnisse aus dem Tutorial reproduzieren.

Fazit

In diesem Tutorial haben wir Microsofts neues Sprachmodell Phi-2 umfassend beleuchtet—von Architektur über Trainingsdaten bis zu Benchmarks.

Dank hochwertiger Daten und skaliertem Wissenstransfer aus Phi-1.5 erreicht Phi-2 Spitzenresultate und ist dabei 25-mal kleiner als Modelle wie LLaMA-70B.

Außerdem haben wir das Modell über die Transformers-Pipeline genutzt und verschiedene Anwendungsfälle erkundet. Abschließend haben wir Phi-2 auf einem Rollenspiel-Datensatz feinabgestimmt, um maßgeschneiderte Chatbots mit unterschiedlichen Personas zu erstellen.

Als nächsten Schritt baust du deine eigene Anwendung. Folge dem Tutorial How to Build LLM Applications with LangChain und lerne, wie du ein Open-Source-Python-Framework für fortgeschrittene KI-Anwendungen einsetzt.