Phi 4 Multimodal: una guida con progetto demo

Phi-4-multimodal è un modello di base multimodale multimodale leggero sviluppato da Microsoft. Fa parte della famiglia Phi di small language models (SLM) di Microsoft.

In questo tutorial ti spiegherò passo dopo passo come usare Phi-4-multimodal per creare un tutor linguistico multimodale che può lavorare con testo, immagini e audio. Le funzionalità principali di questa applicazione sono:

• Apprendimento basato sul testo: fornisce correzione grammaticale in tempo reale, traduzione, ristrutturazione delle frasi e suggerimenti di vocabolario basati sul contesto.
• Apprendimento basato sulle immagini: estrae e traduce il testo dalle immagini e riassume i contenuti visivi per una migliore comprensione.
• Apprendimento basato sull’audio: converte il parlato in testo, valuta l’accuratezza della pronuncia e abilita la traduzione vocale in tempo reale in più lingue. 

Facciamo prima una rapidissima presentazione del modello Phi-4-multimodal e poi inizieremo a costruire l’app.

Che cos’è Phi-4-Multimodal?

Phi-4-multimodal è un modello di AI avanzato progettato per l’elaborazione di testo, visione e parlato. Consente l’integrazione fluida di più modalità, rendendolo ideale per applicazioni di apprendimento linguistico. Alcune delle sue capacità chiave includono:

• Elaborazione del testo: include correzione grammaticale, traduzione e costruzione di frasi.
• Elaborazione della visione: Phi 4 può eseguire riconoscimento ottico dei caratteri (OCR), sintesi di immagini e interazioni multimodali.
• Elaborazione del parlato: può anche eseguire il riconoscimento automatico del parlato (ASR), oltre a feedback sulla pronuncia e traduzione da voce a testo.

Con un contesto di 128K token, il modello Phi-4 multimodale è ottimizzato per il ragionamento efficiente e ambienti con memoria limitata, il che lo rende perfetto per l’apprendimento linguistico in tempo reale basato sull’AI.

Passo 1: Prerequisiti

L’app tutor linguistico multimodale che andremo a costruire è uno strumento interattivo basato su AI progettato per aiutare gli utenti a imparare nuove lingue tramite una combinazione di interazioni basate su testo, immagini e audio.

Prima di iniziare, assicuriamoci di avere installati i seguenti strumenti e librerie:

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

Esegui i seguenti comandi per installare le dipendenze necessarie:

pip install gradio transformers torch soundfile pillowOfferto da

Dobbiamo anche assicurarci che FlashAttention2 sia installato per prestazioni migliori:

pip install flash-attn --no-build-isolationOfferto da

Nota: questo progetto usa una GPU A100 su un notebook Google Colab. Se usi una GPU più vecchia (ad esempio NVIDIA V100), potresti dover disabilitare FlashAttention2 impostando _attn_implementation="eager" nella fase di inizializzazione del modello.

Una volta installate le dipendenze di cui sopra, esegui i seguenti comandi di import:

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, GenerationConfigOfferto da

Passo 2: Caricare Phi-4-Multimodal

Per sfruttare le capacità multimodali di Phi-4, carichiamo prima sia il modello sia il suo processor. Il percorso del modello è impostato da Hugging Face, mentre il processor gestisce la tokenizzazione del testo, il ridimensionamento e la normalizzazione delle immagini e la conversione delle forme d’onda audio in un formato compatibile con il modello per un’elaborazione multimodale senza soluzione di continuità.

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

La fase di inizializzazione del modello usa la funzione 'AutoModelForCausalLM.from_pretrained() per caricare il modello Phi-4 preaddestrato per il causal language modeling (CLM) e carica il modello sulla GPU usando device_map="cuda".

Un parametro chiave in questa fase è _attn_implementation='flash_attention_2'`, che utilizza FlashAttention2 per un meccanismo di attenzione più veloce ed efficiente in termini di memoria, soprattutto per l’elaborazione di contesti lunghi.

Passo 3: Creare le funzionalità chiave

Ora che abbiamo caricato il modello, costruiamo le funzionalità principali.

1. Pulizia della risposta

Un aspetto importante di qualsiasi progetto basato su LLM o VLM è assicurarsi che il modello generi risposte accurate e pertinenti. Ciò comporta anche la rimozione di eventuali testi di prompt dall’output, così che gli utenti ricevano una risposta pulita e diretta senza che l’istruzione iniziale appaia all’inizio.

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 responseOfferto da

Usiamo semplicemente la funzione strip() per rimuovere il testo del prompt in base alle parole chiave dell’istruzione.

2. Elaborazione dell’input

Ora elaboriamo i nostri input, che possono essere testo, immagine o audio, a seconda dell’input o dello scenario dell’utente.

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])Offerto da

La funzione sopra è responsabile della gestione degli input di testo, immagine e audio e della generazione di una risposta utilizzando il modello Phi-4-multimodale. Ecco un’analisi tecnica di questo flusso di lavoro:

1. Elaborazione dell’input immagine: se il tipo di input è "Image", il prompt è formattato con un segnaposto per l’immagine (<|image_1|>). L’immagine viene quindi caricata e il processor tokenizza il testo di accompagnamento mentre estrae le caratteristiche visive. Gli input elaborati vengono trasferiti alla GPU per un calcolo ottimizzato.
2. Elaborazione dell’input audio: se il tipo di input è "Audio", il prompt è strutturato con un segnaposto per l’audio (<|audio_1|>). Il file audio viene letto con la funzione sf.read(), estraendo la forma d’onda grezza e la frequenza di campionamento. Il processor quindi codifica sia l’audio sia il testo, garantendo un’integrazione fluida per la comprensione multimodale.
3. Elaborazione dell’input di testo: se il tipo di input è "Text", il testo è incorporato direttamente nel prompt. Il processor tokenizza e codifica l’input, preparandolo per l’elaborazione successiva da parte del modello.

3. Traduzione e correzioni grammaticali

Successivamente, elaboriamo il testo per traduzione e correzione grammaticale utilizzando il modello Phi-4-multimodal. 

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)Offerto da

La funzione process_text_translate() costruisce dinamicamente un prompt di traduzione specificando la lingua di destinazione e passa il testo in input e il prompt strutturato alla funzione process_input(), restituendo il testo tradotto. 

Allo stesso modo, la funzione process_text_grammar() crea un prompt per la correzione grammaticale, chiama la funzione process_input() con il testo e il tipo di input e restituisce una versione grammaticalmente corretta del testo. Entrambe le funzioni semplificano l’elaborazione del linguaggio sfruttando le capacità del modello per traduzione e correzione grammaticale.

Passo 4: Creare la demo multimodale con Gradio

Ora abbiamo tutte le funzioni logiche chiave. Passiamo a costruire un’interfaccia interattiva con 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()Offerto da

Il codice sopra organizza l’interfaccia Gradio in tre schede interattive, ovvero apprendimento basato sul testo, apprendimento basato sulle immagini e apprendimento basato sull’audio, ognuna progettata per diverse funzionalità di apprendimento linguistico.

Gli utenti possono inserire testo per la traduzione o la correzione grammaticale, caricare immagini per l’estrazione del testo e la sintesi, oppure fornire audio per la trascrizione del parlato e la traduzione. 

Ogni funzione è attivata usando il metodo click() di Gradio, che richiama funzioni di elaborazione come process_text_translate(), process_text_grammar() e process_input() come discusso sopra, passando gli input richiesti e aggiornando gli output in modo dinamico.

Clear è incluso un pulsante in ogni scheda per azzerare input e output, assicurando un’esperienza d’uso fluida. Infine, l’interfaccia viene avviata con demo.launch(debug=True), che consente agli sviluppatori di eseguire facilmente il debug di eventuali errori nell’applicazione.

Passo 5: Test dell’app

Ecco alcuni dei miei esperimenti con questa applicazione.

Traduzione e controllo grammaticale

Per i compiti di traduzione e controllo grammaticale, ho fornito il testo "Hello world" e ho istruito il modello a tradurlo in francese e a verificarne la grammatica (nota i diversi pulsanti per traduzione e controllo grammaticale).

Tradurre il testo all’interno di un’immagine

In questo esempio, ho fornito un’immagine di un cartello di stop in spagnolo che istruisce i pedoni a non camminare su un determinato percorso. Il modello ha interpretato accuratamente il significato del cartello e ha generato la risposta: "Do not walk on the track."

Trascrizione e traduzione dell’audio

Per la trascrizione audio, ho fornito un file audio in inglese e ho istruito il modello a trascrivere il parlato e a tradurre la trascrizione in francese.

Conclusione

In questo tutorial, abbiamo costruito un tutor linguistico multimodale utilizzando il modello Phi-4 multimodale, abilitando l’apprendimento linguistico basato su testo, immagini e audio. Abbiamo utilizzato le capacità avanzate di visione, parlato e testo di Phi-4 per fornire traduzioni in tempo reale, correzioni grammaticali, trascrizione del parlato e approfondimenti basati sulle immagini. Questo progetto dimostra come l’AI multimodale possa migliorare l’educazione linguistica e l’accessibilità.