Microsofts Phi-4: stapsgewijze tutorial met demoproject

Microsoft introduceerde onlangs Phi-4, de nieuwste toevoeging aan de Phi-familie van kleine taalmodellen. Omdat het uitblinkt in wiskunde, besloot ik Phi-4 te gebruiken om een huiswerkchecker te bouwen die is geïntegreerd met Gradio.

In deze tutorial neem ik je stap voor stap mee bij het bouwen van een functionele webapp die oplossingen kan valideren, fouten kan corrigeren en alternatieve aanpakken kan bieden—net als een virtuele onderwijsassistent!

Wat is Microsofts Phi-4-model?

Phi-4 blinkt uit in complexe redeneertaken, vooral in de wiskunde, terwijl het ook vaardig blijft in conventionele taalverwerking. De belangrijkste kenmerken zijn:

• Geavanceerde redeneercapaciteiten: Phi-4 is getraind op hoogwaardige synthetische datasets en gebruikt innovatieve post-trainings­technieken om grotere modellen te overtreffen bij wiskundige redeneertaken.
• Efficiëntie en toegankelijkheid: Met 14 miljard parameters levert Phi-4 resultaten van hoge kwaliteit zonder enorme rekenbronnen, waardoor het bruikbaar is voor een breder scala aan toepassingen.
• Beschikbaarheid: Phi-4 is momenteel toegankelijk via Azure AI Foundry onder een Microsoft Research License Agreement (MSRLA) en Hugging Face.

Phi-4 heeft sterke prestaties laten zien op wiskundige redeneertaken, en overtreft zelfs grotere modellen zoals Gemini Pro 1.5 bij wiskundewedstrijdproblemen. Dit maakt het een goede keuze voor toepassingen die geavanceerde wiskundige probleemoplossing vereisen.

Bron: Microsoft

Phi-4 Huiswerkchecker: implementatie-overzicht

De app die we met Phi-4 gaan bouwen is een AI-aangedreven huiswerkchecker. Dit is de workflow waar de gebruiker doorheen gaat:

1. De gebruiker dient het gemaakte huiswerk in (zowel de opgave-instructies als de oplossing van de gebruiker).
2. Als de oplossing onjuist is, legt het model de juiste oplossing uit met gedetailleerde stappen, zoals een docent.
3. Als de oplossing juist is, bevestigt het model de oplossing of stelt het een nettere, efficiëntere aanpak voor als het antwoord rommelig is.

Om een webinterface te bieden waar gebruikers met de huiswerkchecker kunnen werken, gebruiken we Gradio.

Stap 1: Vereisten

Zorg voordat we beginnen dat je het volgende hebt geïnstalleerd:

• Python 3.8+
• PyTorch: Voor het draaien van deep learning-modellen.
• HuggingFace Transformers-bibliotheek: Voor het laden van het Phi-4-model van HuggingFace.
• Gradio: Om een gebruiksvriendelijke webinterface te maken.

Installeer deze dependencies met:

!pip install torch transformers gradio -q

Nu hebben we alle dependencies geïnstalleerd. Vervolgens zetten we het Phi-4-model op.

Stap 2: Het model instellen

We laden het Phi-4-model vanuit de Transformers-bibliotheek van HuggingFace. Daarna verwerkt de tokenizer de invoer (de opgave en de oplossing) en maakt deze klaar voor inferentie.

# 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

De bovenstaande code zet het Phi-4-model en de tokenizer op en integreert ze met PyTorch voor berekeningen. Laten we de code hierboven in meer detail doornemen:

• De klassen AutoModelForCausalLM en AutoTokenizer worden geïmporteerd om met het model en de tokenisatie te werken.
• Het model wordt geladen uit de Hugging Face-repository met de methode from_pretrained() en geconfigureerd om FP16-precisie te gebruiken voor geoptimaliseerd geheugengebruik en reken­snelheid.
• De parameter device_map="auto" zorgt ervoor dat het model automatisch aan de beschikbare hardware wordt toegewezen.
• Ook de tokenizer wordt geladen, die invoertekst omzet in tokens die geschikt zijn voor het model.
• Er wordt gecontroleerd of de tokenizer een paddingtoken heeft; zo niet, dan wordt eos_token_id (end-of-sequence-token) toegewezen als paddingtoken.

Stap 3: Kernfuncties ontwerpen 

Zodra het model is ingesteld, definiëren we drie kernfuncties voor de app:

1. Validatie van de oplossing: Het model beoordeelt de oplossing van de gebruiker en geeft correcties als die onjuist is.
2. Alternatieve suggesties: Het stelt nettere oplossingen voor als de oplossing van de gebruiker rommelig is.
3. Duidelijke feedback: Het model structureert de output ook met duidelijke secties.

De volgende functie, check_homework(), bouwt een prompt op met de opgave, de oplossing van de gebruiker en specifieke instructies voor het model om de juistheid te bevestigen, problemen te identificeren of stapsgewijze begeleiding te geven als de oplossing onjuist is.

# 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

De functie check_homework() tokeniseert de prompt met de tokenizer van het model. Het maakt deze klaar voor verwerking door de invoer om te zetten naar PyTorch-tensors, die worden toegewezen aan het apparaat waarop het model draait.

Vervolgens wordt er een respons gegenereerd door het model met een limiet van max_new_tokens=1024 om de outputlengte te beheersen. Deze tokenlengte kun je naar wens aanpassen.

Tot slot wordt de verwerkte respons, die feedback of een gecorrigeerde oplossing geeft, geretourneerd. 

Stap 4: Een gebruiksvriendelijke interface maken met Gradio

Gradio vereenvoudigt het uitrollen van de huiswerkchecker doordat gebruikers hun opgaven en oplossingen interactief kunnen invoeren. De volgende code maakt een gebruiksvriendelijke Gradio-webinterface voor de functie check_homework(). De Gradio-interface neemt de invoer van de gebruiker (de opgave en de oplossing) en geeft die door aan het model voor validatie. 

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

We hebben twee invoervelden gemaakt met gr.Textbox: één voor het wiskundeprobleem (opgave) en één voor de oplossing van de gebruiker. De output wordt weergegeven in één gr.Textbox met het label "Feedback". Met het commando interface.launch() start je de Gradio-app in een browser, en de vlag debug=True schakelt gedetailleerde logs in om fouten op te sporen. 

Stap 5: Testen en valideren

Tijd om onze AI Huiswerkchecker te testen. Dit zijn enkele tests die ik heb uitgevoerd:

1. Eenvoudig wiskundeprobleem: Ik probeerde basis­kansrekening op te lossen, en de app gaf een goed gestructureerde en duidelijke oplossing voor het probleem.

2. Complex afgeleideprobleem: Afgeleiden oplossen kan lastig zijn voor sommige modellen. Hier heb ik met de huiswerkchecker de eerste afgeleide van een natuurlijke logaritmefunctie gezocht en die gaf correcte, stapsgewijze redenering voor de oplossing.

Conclusie

In deze tutorial hebben we een AI-aangedreven huiswerkchecker gemaakt met het Phi-4-model. Deze app valideert oplossingen, geeft gedetailleerde correcties en stelt elegante alternatieven voor, waardoor het een ideale virtuele docent is voor studenten.

Klaar om de app uit te breiden? Experimenteer met complexere problemen of integreer hem in onderwijsplatforms voor breder gebruik!