Phi 4 Multimodaal: een gids met demoproject

Phi-4-multimodal is een lichtgewicht multimodaal foundationmodel ontwikkeld door Microsoft. Het maakt deel uit van Microsofts Phi-familie van small language models (SLM's).

In deze tutorial leg ik stap voor stap uit hoe je met Phi-4-multimodal een multimodale taalleraar bouwt die met tekst, afbeeldingen en audio kan werken. De belangrijkste features van deze applicatie zijn:

• Tekstgebaseerd leren: biedt realtime grammaticacorrectie, vertaling, herformuleren van zinnen en contextbewuste woordenschatvoorstellen.
• Afbeeldingsgebaseerd leren: extraheert en vertaalt tekst uit afbeeldingen en vat visuele content samen voor beter begrip.
• Audiogebaseerd leren: zet spraak om naar tekst, beoordeelt uitspraaknauwkeurigheid en maakt realtime spraakvertaling naar meerdere talen mogelijk. 

Laten we eerst heel kort het Phi-4-multimodal-model voorstellen en daarna beginnen we met het bouwen van de app.

Wat is Phi-4-Multimodaal?

Phi-4-multimodal is een geavanceerd AI-model voor tekst-, beeld- en spraakverwerking. Het maakt naadloze integratie van meerdere modaliteiten mogelijk en is daardoor ideaal voor taalleerapplicaties. Enkele kernmogelijkheden zijn:

• Tekstverwerking: waaronder grammaticacorrectie, vertaling en zinsopbouw.
• Beeldverwerking: Phi 4 kan optische tekenherkenning (OCR), beeldsamenvatting en multimodale interacties uitvoeren.
• Spraakverwerking: ondersteunt automatische spraakherkenning (ASR), uitspraakfeedback en spraak-naar-tekstvertaling.

Met een contextlengte van 128K tokens is het Phi-4-multimodal-model geoptimaliseerd voor efficiënt redeneren en omgevingen met beperkte geheugenruimte, waardoor het perfect past bij realtime AI-gestuurd taalleren.

Stap 1: Vereisten

De multimodale taalleraar die we gaan bouwen is een interactieve, door AI aangedreven tool die gebruikers helpt bij het leren van nieuwe talen via een combinatie van tekst-, beeld- en audio-interacties.

Voordat we beginnen, zorgen we ervoor dat we de volgende tools en libraries hebben geïnstalleerd:

• Python 3.8+
• torch
• Transformers
• PIL
• Soundfile
• Gradio

Voer de volgende commando's uit om de benodigde dependencies te installeren:

pip install gradio transformers torch soundfile pillowMogelijk gemaakt door

We moeten ook controleren of FlashAttention2 is geïnstalleerd voor betere prestaties:

pip install flash-attn --no-build-isolationMogelijk gemaakt door

Opmerking: dit project gebruikt een A100-GPU in een Google Colab-notebook. Als je een oudere GPU gebruikt (bijv. NVIDIA V100), moet je mogelijk FlashAttention2 uitschakelen door _attn_implementation="eager" in te stellen bij het initialiseren van het model.

Zodra bovenstaande dependencies zijn geïnstalleerd, voer je de volgende import-commando's uit:

import gradio as gr
import torch
import requests
import io
import os
import soundfile as sf
from PIL import Image
from transformers import AutoModelForCausalLM, AutoProcessor, GenerationConfigMogelijk gemaakt door

Stap 2: Phi-4-Multimodaal laden

Om te profiteren van Phi-4's multimodale mogelijkheden laden we eerst zowel het model als de processor. Het modelpad komt van Hugging Face, terwijl de processor zorgt voor het tokenizen van tekst, het resizen en normaliseren van afbeeldingen en het omzetten van audiowaveforms naar een formaat dat compatibel is met het model voor naadloze multimodale verwerking.

# Load model and processor
model_path = "microsoft/Phi-4-multimodal-instruct"
processor = AutoProcessor.from_pretrained(model_path, trust_remote_code=True)
model = AutoModelForCausalLM.from_pretrained(
    model_path, 
    device_map="cuda", 
    torch_dtype="auto", 
    trust_remote_code=True,
    _attn_implementation='flash_attention_2',
).cuda()
generation_config = GenerationConfig.from_pretrained(model_path)Mogelijk gemaakt door

De modelinitialisatie gebruikt de functie 'AutoModelForCausalLM.from_pretrained() om het voorgetrainde Phi-4-model voor causal language modeling (CLM) te laden en zet het model op de GPU met device_map="cuda".

Een belangrijke parameter in deze stap is _attn_implementation='flash_attention_2'`, waarmee FlashAttention2 wordt gebruikt voor een snellere en geheugen-efficiëntere attentionmechaniek, vooral bij verwerking met lange context.

Stap 3: Belangrijkste functionaliteiten bouwen

Nu we het model hebben geladen, gaan we de kernfunctionaliteiten bouwen.

1. De response opschonen

Een belangrijk aspect van elk op LLM of VLM gebaseerd project is ervoor zorgen dat het model nauwkeurige en relevante antwoorden genereert. Dit houdt ook in dat je alle prompttekst uit de output verwijdert, zodat gebruikers een schone en directe reactie krijgen zonder dat de initiële instructie aan het begin verschijnt.

def clean_response(response, instruction_keywords):
    """Removes the prompt text dynamically based on instruction keywords."""
    for keyword in instruction_keywords:
        if response.lower().startswith(keyword.lower()):
            response = response[len(keyword):].strip()
    return responseMogelijk gemaakt door

We gebruiken eenvoudig de functie strip() om de prompttekst te verwijderen op basis van instructiesleutelwoorden.

2. Inputverwerking

Laten we nu onze invoer verwerken, die tekst, beeld of audio kan zijn, afhankelijk van de gebruikersinvoer of -situatie.

def process_input(file, input_type, question):
    user_prompt = "<|user|>"
    assistant_prompt = "<|assistant|>"
    prompt_suffix = "<|end|>"
    
    if input_type == "Image":
	prompt= f'{user_prompt}<|image_1|>{question}{prompt_suffix}{assistant_prompt}'
        image = Image.open(file)
	inputs = processor(text=prompt, images=image, return_tensors='pt').to(model.device)
    elif input_type == "Audio":
 	prompt= f'{user_prompt}<|audio_1|>{question}{prompt_suffix}{assistant_prompt}'
        audio, samplerate = sf.read(file)
        inputs = processor(text=prompt, audios=[(audio, samplerate)], return_tensors='pt').to(model.device)
    elif input_type == "Text":
        prompt = f'{user_prompt}{question} "{file}"{prompt_suffix}{assistant_prompt}'
        inputs = processor(text=prompt, return_tensors='pt').to(model.device)
    else:
        return "Invalid input type"    
    
    generate_ids = model.generate(**inputs, max_new_tokens=1000, generation_config=generation_config)
    response = processor.batch_decode(generate_ids, skip_special_tokens=True)[0]
    return clean_response(response, [question])Mogelijk gemaakt door

Bovenstaande functie verwerkt tekst-, beeld- en audio-invoer en genereert een antwoord met het Phi-4-multimodal-model. Hier is een technische uitsplitsing van deze workflow:

1. Verwerking van beeldinvoer: als het invoertype "Image" is, wordt de prompt opgemaakt met een plaatshouder voor een afbeelding (<|image_1|>). De afbeelding wordt vervolgens geladen en de processor tokenizeert de begeleidende tekst terwijl visuele features worden geëxtraheerd. De verwerkte input wordt naar de GPU verplaatst voor geoptimaliseerde berekening.
2. Verwerking van audio-invoer: als het invoertype "Audio" is, wordt de prompt opgebouwd met een plaatshouder voor audio (<|audio_1|>). Het audiobestand wordt gelezen met de functie sf.read(), waarbij de ruwe waveform en samplerate worden opgehaald. De processor encodeert vervolgens zowel audio als tekst, zodat multimodaal begrip naadloos mogelijk is.
3. Verwerking van tekstinvoer: als het invoertype "Text" is, wordt de tekst rechtstreeks in de prompt geplaatst. De processor tokenizeert en encodeert de input en bereidt deze voor op verdere verwerking door het model.

3. Vertaling en grammaticacorrecties

Vervolgens verwerken we de tekst voor vertaling en grammaticacorrectie met het Phi-4-multimodal-model. 

def process_text_translate(text, target_language):
    prompt = f'Translate the following text to {target_language}: "{text}"'
    return process_input(text, "Text", prompt)
def process_text_grammar(text):
    prompt = f'Check the grammar and provide corrections if needed for the following text: "{text}"'
    return process_input(text, "Text", prompt)Mogelijk gemaakt door

De functie process_text_translate() bouwt dynamisch een vertaalprompt door de doeltaal te specificeren en geeft de invoertekst en de gestructureerde prompt door aan de functie process_input(), die de vertaalde tekst retourneert. 

Op dezelfde manier bouwt de functie process_text_grammar() een prompt voor grammaticacontrole, roept de functie process_input() aan met de invoertekst en het type, en retourneert een grammaticaal gecorrigeerde versie van de tekst. Beide functies stroomlijnen taalverwerking door de modelmogelijkheden voor vertaling en grammaticacorrectie te benutten.

Stap 4: De multimodale demo bouwen met Gradio

Nu we alle kernfuncties hebben, bouwen we een interactieve UI met Gradio.

def gradio_interface():
    with gr.Blocks() as demo:
        gr.Markdown("# Phi 4 Powered - Multimodal Language Tutor")        
        with gr.Tab("Text-Based Learning"):
            text_input = gr.Textbox(label="Enter Text")
            language_input = gr.Textbox(label="Target Language", value="French")
            text_output = gr.Textbox(label="Response")
            text_translate_btn = gr.Button("Translate")
            text_grammar_btn = gr.Button("Check Grammar")
            text_clear_btn = gr.Button("Clear")
            text_translate_btn.click(process_text_translate, inputs=[text_input, language_input], outputs=text_output)
            text_grammar_btn.click(process_text_grammar, inputs=[text_input], outputs=text_output)
            text_clear_btn.click(lambda: ("", "", ""), outputs=[text_input, language_input, text_output])        
        with gr.Tab("Image-Based Learning"):
            image_input = gr.Image(type="filepath", label="Upload Image")
            language_input_image = gr.Textbox(label="Target Language for Translation", value="English")
            image_output = gr.Textbox(label="Response")
            image_clear_btn = gr.Button("Clear")
            image_translate_btn = gr.Button("Translate Text in Image")
            image_summarize_btn = gr.Button("Summarize Image")
            image_translate_btn.click(process_input, inputs=[image_input, gr.Textbox(value="Image", visible=False), gr.Textbox(value="Extract and translate text", visible=False)], outputs=image_output)
            image_summarize_btn.click(process_input, inputs=[image_input, gr.Textbox(value="Image", visible=False), gr.Textbox(value="Summarize this image", visible=False)], outputs=image_output)
            image_clear_btn.click(lambda: (None, "", ""), outputs=[image_input, language_input_image, image_output])
        with gr.Tab("Audio-Based Learning"):
            audio_input = gr.Audio(type="filepath", label="Upload Audio")
            language_input_audio = gr.Textbox(label="Target Language for Translation", value="English")
            transcript_output = gr.Textbox(label="Transcribed Text")
            translated_output = gr.Textbox(label="Translated Text")
            audio_clear_btn = gr.Button("Clear")
            audio_transcribe_btn = gr.Button("Transcribe & Translate")
            audio_transcribe_btn.click(process_input, inputs=[audio_input, gr.Textbox(value="Audio", visible=False), gr.Textbox(value="Transcribe this audio", visible=False)], outputs=transcript_output)
            audio_transcribe_btn.click(process_input, inputs=[audio_input, gr.Textbox(value="Audio", visible=False), language_input_audio], outputs=translated_output)
            audio_clear_btn.click(lambda: (None, "", "", ""), outputs=[audio_input, language_input_audio, transcript_output, translated_output])        
        demo.launch(debug=True)

if __name__ == "__main__":
    gradio_interface()Mogelijk gemaakt door

Bovenstaande code organiseert de Gradio-interface in drie interactieve tabbladen: tekstgebaseerd leren, afbeeldingsgebaseerd leren en audiogebaseerd leren, elk ontworpen voor verschillende taalleerfuncties.

Gebruikers kunnen tekst invoeren voor vertaling of grammaticacontrole, afbeeldingen uploaden voor tekstadaptie en samenvatting, of audio aanleveren voor spraaktranscriptie en vertaling. 

Elke functie wordt gestart met de click()-methode van Gradio, die verwerkingsfuncties aanroept zoals process_text_translate(), process_text_grammar() en process_input() zoals hierboven besproken, door de vereiste inputs door te geven en de outputs dynamisch bij te werken.

Clear-knoppen zijn op elk tabblad aanwezig om inputs en outputs te resetten, voor een soepele gebruikerservaring. Tot slot wordt de interface gestart met demo.launch(debug=True), zodat ontwikkelaars fouten in de applicatie eenvoudig kunnen debuggen.

Stap 5: De app testen

Hier zijn een paar van mijn experimenten met deze applicatie.

Vertaling en grammaticacontrole

Voor de taken vertaling en grammaticacontrole gaf ik de tekst "Hello world" op en instrueerde ik het model om die naar het Frans te vertalen en de grammatica te controleren (let op de verschillende knoppen voor vertaling en grammaticacontrole).

Tekst in een afbeelding vertalen

In dit voorbeeld gaf ik een afbeelding van een Spaans stopbord dat voetgangers instrueert niet over een bepaald pad te lopen. Het model interpreteerde de betekenis van het bord correct en genereerde de reactie: "Niet op het spoor lopen."

Audiotranscriptie en vertaling

Voor audiotranscriptie gebruikte ik een Engelstalig audiobestand en vroeg ik het model de spraak te transcriberen en de transcriptie naar het Frans te vertalen.

Conclusie

In deze tutorial hebben we een multimodale taalleraar gebouwd met het Phi-4-multimodal-model, waarmee taal leren via tekst, afbeeldingen en audio mogelijk is. We hebben de geavanceerde beeld-, spraak- en tekstmogelijkheden van Phi-4 gebruikt om realtime vertalingen, grammaticacorrecties, spraaktranscriptie en inzichten op basis van afbeeldingen te bieden. Dit project laat zien hoe multimodale AI taalonderwijs en toegankelijkheid kan verbeteren.