Microsofts Phi-4: Schritt-für-Schritt-Anleitung mit Demo-Projekt

Microsoft hat kürzlich Phi-4vorgestellt , das neueste Mitglied der Phi-Familie von kleinen Sprachmodellen. Da Phi-4 besonders gut in Mathematik ist, habe ich mich entschlossen, einen in Gradio integrierten Hausaufgabenkontrolleur zu bauen.

In diesem Tutorial führe ich dich Schritt für Schritt durch den Aufbau einer funktionalen Web-App, mit der du Lösungen validieren, Fehler korrigieren und alternative Ansätze anbieten kannst - genau wie ein virtueller Lehrassistent!

Was ist das Phi-4-Modell von Microsoft?

Phi-4 zeichnet sich durch komplexes logisches Denken aus, insbesondere in Mathematik, und beherrscht gleichzeitig die herkömmliche Sprachverarbeitung. Seine wichtigsten Merkmale sind:

• Fortgeschrittene Argumentationsfähigkeiten: Phi-4 wird auf hochwertigen synthetischen Datensätzen und nutzt innovative Nachtrainingsverfahren, um größere Modelle bei mathematischen Denkaufgaben zu übertreffen.
• Effizienz und Zugänglichkeit: Mit 14 Milliarden Parametern bietet Phi-4 qualitativ hochwertige Ergebnisse ohne große Rechenressourcen, was es für eine größere Bandbreite von Anwendungen zugänglich macht.
• Verfügbarkeit: Phi-4 ist derzeit zugänglich über Azure AI Foundry unter einem Microsoft Research License Agreement (MSRLA) und Hugging Face.

Der Phi-4 hat bei mathematischen Aufgaben eine großartige Leistung gezeigt und sogar größere Modelle wie den Gemini Pro 1.5 bei Mathematikwettbewerben übertroffen. Das macht ihn zu einer guten Wahl für Anwendungen, die fortgeschrittene mathematische Problemlösungsfähigkeiten erfordern.

Quelle: Microsoft

Phi-4 Hausaufgabenkontrolleur: Überblick über die Umsetzung

Die App, die wir mit Phi-4 bauen werden, ist ein KI-gestützter Hausaufgabenkontrolleur. Hier ist der Arbeitsablauf, den der Benutzer durchlaufen wird:

1. Der/die Nutzer/in reicht seine/ihre fertige Hausaufgabe ein (sowohl die Übungsanweisungen als auch die Lösung des/der Nutzers/in).
2. Wenn die Lösung falscherklärt das Modell die richtige Lösung mit detaillierten Schritten, wie ein Lehrer.
3. Wenn die Lösung richtig ist richtigbestätigt das Modell die Lösung oder schlägt eine sauberere, effizientere Alternative vor, wenn die Antwort unklar ist.

Um eine Weboberfläche bereitzustellen, über die die Nutzer/innen mit dem Hausaufgabenprüfer interagieren können, verwenden wir Gradio.

Schritt 1: Voraussetzungen

Bevor wir beginnen, solltest du sicherstellen, dass du Folgendes installiert hast:

• Python 3.8+
• PyTorch: Zum Ausführen von Deep Learning-Modellen.
• HuggingFace Transformers Bibliothek: Zum Laden des Phi-4-Modells von HuggingFace.
• Gradio: Um eine benutzerfreundliche Weboberfläche zu schaffen.

Installiere diese Abhängigkeiten, indem du sie ausführst:

!pip install torch transformers gradio -q

Jetzt haben wir alle Abhängigkeiten installiert. Als Nächstes stellen wir das Phi-4-Modell auf.

Schritt 2: Einrichten des Modells

Wir laden das Phi-4-Modell aus der Transformers-Bibliothek von HuggingFace. Dann verarbeitet der Tokenizer die Eingabe (die Aufgabe und die Lösung) vor und bereitet sie für die Inferenz vor.

# Imports
from transformers import AutoModelForCausalLM, AutoTokenizer
import torch
import gradio as gr

# Load the Phi-4 model and tokenizer
model_name = "NyxKrage/Microsoft_Phi-4"
model=AutoModelForCausalLM.from_pretrained(model_name, torch_dtype=torch.float16, device_map="auto")
tokenizer = AutoTokenizer.from_pretrained(model_name)

# Set tokenizer padding token if not set
if tokenizer.pad_token_id is None:
    tokenizer.pad_token_id = tokenizer.eos_token_id

Der obige Codeschnipsel richtet das Phi-4-Modell und den Tokenizer ein und integriert sie mit PyTorch für Berechnungen. Schauen wir uns den obigen Code genauer an:

• Die Klassen AutoModelForCausalLM und AutoTokenizer werden importiert, um mit dem Modell und der Tokenisierung zu arbeiten.
• Das Modell wird mit der Methode from_pretrained() aus dem Hugging Face Repository geladen und so konfiguriert, dass es mit FP16-Präzision arbeitet, um die Speichernutzung und die Berechnungsgeschwindigkeit zu optimieren.
• Der Parameter device_map="auto" sorgt dafür, dass das Modell automatisch auf die verfügbare Hardware abgebildet wird.
• Außerdem wird der Tokenizer geladen, der den eingegebenen Text in für das Modell geeignete Token verarbeitet.
• Eine Prüfung stellt sicher, dass der Tokenizer ein definiertes Auffüllungs-Token hat; falls nicht, wird das eos_token_id (End-of-Sequence-Token) als Auffüllungs-Token zugewiesen.

Schritt 3: Kernfunktionen entwerfen 

Sobald das Modell eingerichtet ist, definieren wir drei wichtige Funktionen für die App:

1. Lösungsvalidierung: Das Modell bewertet die Lösung des Nutzers und gibt Korrekturen, wenn sie falsch ist.
2. Alternative Vorschläge: Es schlägt sauberere Lösungen vor, wenn die Lösung des Nutzers unordentlich ist.
3. Klares Feedback: Das Modell strukturiert auch die Ausgabe mit klaren Abschnitten.

Die folgende Funktion check_homework() erstellt eine Eingabeaufforderung, die die Übung, die Lösung des Benutzers und spezifische Anweisungen für das Modell enthält, um die Richtigkeit zu bestätigen, Probleme zu erkennen oder eine Schritt-für-Schritt-Anleitung zu geben, wenn die Lösung falsch ist.

# Function to validate the solution and provide feedback
def check_homework(exercise, solution):
    prompt = f"""
    Exercise: {exercise}
    Solution: {solution}
Task: Validate the solution to the math problem, provided by the user. If the user's solution is correct, confirm else provide an alternative if the solution is messy. If it is incorrect, provide the correct solution with step-by-step reasoning.
    """
    # Tokenize and generate response
    inputs = tokenizer(prompt, return_tensors="pt").to(model.device)
    print(f"Tokenized input length: {len(inputs['input_ids'][0])}")
    outputs = model.generate(**inputs, max_new_tokens=1024)
    print(f"Generated output length: {len(outputs[0])}")
    response = tokenizer.decode(outputs[0], skip_special_tokens=True)
    # response = response.replace(prompt, "").strip()
    prompt_len = len(prompt)
    response = response[prompt_len:].strip()
    print(f"Raw Response: {response}")
    return response

Die Funktion check_homework() tokenisiert die Eingabeaufforderung mithilfe des Tokenizers des Modells. Es bereitet sie für die Verarbeitung vor, indem es die Eingabe in PyTorch-Tensoren umwandelt, die auf das Gerät abgebildet werden, auf dem das Modell läuft.

Es erzeugt dann eine Antwort des Modells mit einer Grenze von max_new_tokens=1024, um die Ausgangslänge zu kontrollieren. Diese Tokenlänge kann nach Bedarf variiert werden.

Zum Schluss wird die bearbeitete Antwort, die ein Feedback oder eine korrigierte Lösung enthält, zurückgegeben. 

Schritt 4: Erstellen einer benutzerfreundlichen Oberfläche mit Gradio

Gradio vereinfacht den Einsatz des Hausaufgabenkontrolleurs, indem es den Nutzern ermöglicht, ihre Übungen und Lösungen interaktiv einzugeben. Der folgende Codeschnipsel erstellt ein benutzerfreundliches Gradio-Webinterface für die Funktion check_homework(). Die Gradio-Schnittstelle nimmt die Eingaben des Nutzers (die Aufgabe und die Lösung) auf und leitet sie zur Validierung an das Modell weiter. 

# Define the function that integrates with the Gradio app
def homework_checker_ui(exercise, solution):
    return check_homework(exercise, solution)

# Create the Gradio interface using the new syntax
interface = gr.Interface(
    fn=homework_checker_ui,
    inputs=[
        gr.Textbox(lines=2, label="Exercise (e.g., Solve for x in 2x + 3 = 7)"),
        gr.Textbox(lines=1, label="Your Solution (e.g., x = 1)")
    ],
    outputs=gr.Textbox(label="Feedback"),
    title="AI Homework Checker",
    description="Validate your homework solutions, get corrections, and receive cleaner alternatives.",
)

# Launch the app
interface.launch(debug=True)

Wir haben mit gr.Textbox zwei Eingabefelder erstellt: eines für die Matheaufgabe (Übung) und ein weiteres für die Lösung des Nutzers. Die Ausgabe wird in einem einzigen gr.Textbox mit der Bezeichnung "Feedback" angezeigt. Der Befehl interface.launch() startet die Gradio-App in einem Browser, und das Flag debug=True ermöglicht detaillierte Protokolle, die bei der Fehlersuche helfen. 

Schritt 5: Testen und Validieren

Es ist Zeit, unsere KI-Hausaufgabenkontroll-App zu testen. Hier sind einige Tests, die ich durchgeführt habe:

1. Ein einfaches mathematisches Problem: Ich habe versucht, einfache Wahrscheinlichkeitsprobleme zu lösen, und die App lieferte eine gut strukturierte und klare Lösung für das Problem.

2. Komplexes Ableitungsproblem: Das Lösen von Ableitungen kann bei einigen Modellen eine Herausforderung sein. Hier habe ich versucht, die erste Ableitung einer natürlichen Logarithmusfunktion mit dem Hausaufgabenkontrolleur zu finden und er hat die Lösung Schritt für Schritt korrekt begründet.

Fazit

In diesem Tutorial haben wir einen KI-gestützten Hausaufgabenkontrolleur mit dem Phi-4-Modell erstellt. Diese App prüft Lösungen, gibt detaillierte Korrekturen und schlägt elegante Alternativen vor und ist damit ein idealer virtueller Lehrer für Schüler.

Bist du bereit, die App zu erweitern? Experimentiere mit komplexeren Problemen oder integriere sie in Bildungsplattformen für eine breitere Nutzung!