Modelli Microsoft MAI: test di MAI-Transcribe-1, MAI-Voice-1 e MAI-Image-2 con Streamlit

Cosa sono i modelli Microsoft MAI?

La famiglia di modelli MAI di Microsoft è sviluppata dal team Microsoft AI Superintelligence. Sono modelli interni al 100%, addestrati sull'infrastruttura Microsoft, ottimizzati per lo stack di serving Microsoft e distribuiti direttamente tramite Azure. I modelli MAI-Transcribe-1 e MAI-Voice-1 girano sulla stessa infrastruttura Azure Speech che già serve clienti enterprise su larga scala, mentre MAI-Image-2 utilizza un'architettura di diffusione flow-matching con lo stesso obiettivo di training dietro Stable Diffusion 3, con tra 10 e 50 miliardi di parametri non di embedding. 

Ecco un riepilogo veloce di tutti e tre:

Approfondiamo ognuno prima di costruire.

MAI-Transcribe-1

MAI-Transcribe-1 è un modello speech-to-text che supporta 25 lingue. Il dato di punta è un Word Error Rate (WER) medio del 3,88% sul benchmark FLEURS, dove più basso è meglio, e questo lo pone davanti a GPT-Transcribe (4,17%), Scribe v2 (4,32%), Gemini 3.1 Flash-Lite (4,89%) e Whisper-large-v3 (7,60%).

Il modello è specificamente costruito per audio reali e disordinati, inclusi ambienti rumorosi, accenti misti e stili di parlato naturali. Microsoft afferma inoltre che MAI-Transcribe-1 offre una buona accuratezza a un costo GPU circa del 50% inferiore rispetto alle principali alternative, un vantaggio significativo per le aziende che eseguono trascrizioni su larga scala.

Tuttavia, mancano ancora trascrizione in tempo reale, diarizzazione dei parlanti e context biasing, tutte indicate come "in arrivo". 

MAI-Voice-1

MAI-Voice-1 è il modello TTS ad alta fedeltà di Microsoft. La sua capacità principale è il voice prompting: fornisci un campione audio di 10 secondi e il modello clona quella voce senza alcun fine-tuning. Tuttavia, il voice cloning richiede un'approvazione soggetta a controllo da parte di Microsoft, ma la libreria di voci curate (nomi come en-us-Jasper:MAI-Voice-1, en-us-June:MAI-Voice-1) è disponibile subito.

Il modello genera 60 secondi di audio in un solo secondo su una singola GPU, supporta il controllo delle emozioni per turno via SSML ed è pensato per contenuti long-form come audiolibri e podcast. Alimenta già le funzionalità Audio Expressions e podcast di Copilot nei prodotti Microsoft.

Uno svantaggio di questo modello è che è “solo in inglese”, con oltre 10 lingue in arrivo a breve.

MAI-Image-2

MAI-Image-2 utilizza un'architettura di diffusione flow-matching con 10–50 miliardi di parametri. È tra i primi 3 modelli nella classifica immagini di Arena.ai ed è 2 volte più veloce di MAI-Image-1 in produzione. Il modello è stato sviluppato in collaborazione con fotografi, designer e visual storyteller, ed è già distribuito in Copilot, Bing Image Creator e PowerPoint. È particolarmente pensato per fotorealismo, toni della pelle accurati e testo in immagine leggibile.

I suoi punteggi Elo per categoria includono fotorealistico (1201) e ritratti (1201), dove eccelle, mentre il rendering del testo (1186) è migliorato rispetto a prima ma resta la categoria più debole.

Configurare Azure per tutti i modelli

Tutti e tre i modelli MAI sono disponibili su Microsoft Azure. MAI-Transcribe-1 e MAI-Voice-1 condividono la stessa risorsa Azure Speech, mentre MAI-Image-2 è eseguito tramite Microsoft Foundry. Configuriamoli entrambi uno alla volta.

Prerequisiti

• Registrati o accedi al tuo account Azure per ottenere $200 di credito gratuito
• Python 3.9+

Passo 1: Crea una risorsa Azure Speech 

Sia i modelli MAI-Transcribe-1 che MAI-Voice-1 sono accessibili tramite il servizio Azure AI Speech, quindi una sola risorsa copre entrambi.

• Vai su portal.azure.com

• Nella barra di ricerca, digita Speech e seleziona Speech services

• Clicca + Create

• Compila il modulo:

• Resource group: Crea un nuovo resource group e chiamalo mai-demo-rg

• Region: Seleziona East US perché i modelli MAI sono attualmente supportati solo per East US e West US

• Name: mai-speech-demo

• Pricing tier: Standard S0

• Nota: Free F0 ha limiti di rate che possono interrompere la demo

• Infine, clicca Review and create, e dopo un po' di caricamento clicca Create.

Una volta completata la distribuzione, vai su Keys and Endpoint nella barra laterale sinistra e copia Key 1 e annota il valore Region (eastus).

Passo 2: Crea una risorsa Foundry e distribuisci MAI-Image-2

MAI-Image-2 è accessibile tramite Microsoft Foundry, che è separato dal portale Azure tradizionale.

• Dalla homepage del portale Azure, clicca Foundry nella riga dei servizi principali 

• Clicca Create a resource

• Poi compila i seguenti dettagli:

• Resource group: Seleziona lo stesso mai-demo-rg dal Passo 1

• Region: East US

• Name: mai-image-demo

• Default project name: proj-default

• Poi clicca su Review and create, e premi Create

• Una volta attiva la risorsa, clicca Go to Foundry portal. 

• Poi, nell'interfaccia Foundry, clicca Model catalog nella barra laterale sinistra

• Cerca MAI nella barra di ricerca e vedrai elencati tutti e quattro i modelli MAI

• Seleziona MAI-Image-2 e clicca Use this model

• Nella finestra di deploy, imposta:

• Deployment name: MAI-Image-2 

• Deployment type: Global Standard

• Infine, clicca deploy

Dopo la distribuzione, arriverai alla pagina dei dettagli della distribuzione. Copia il Target URI (qualcosa come https://mai-image-demo.services.ai.azure.com/models) e la Key.

Passo 3: Configura il file .env

Crea un file .env nella directory locale del progetto e aggiungi i dettagli ottenuti nei due passaggi precedenti:

AZURE_SPEECH_KEY=your_speech_key_1_here
AZURE_SPEECH_REGION=eastus
AZURE_IMAGE_ENDPOINT=https://your-resource-name.services.ai.azure.com/models
AZURE_IMAGE_KEY=your_foundry_key_here
AZURE_IMAGE_DEPLOYMENT=MAI-Image-2

Nota importante: AZURE_IMAGE_DEPLOYMENT è case-sensitive. Usa MAI-Image-2 esattamente come appare in Foundry, poiché mai-image-2 in minuscolo restituirà un errore unknown_model.

Demo dei modelli MAI: crea un'app Speech, Voice e Image con Streamlit

In questa sezione costruiremo un'app Streamlit a tre tab che chiama tutti e tre i modelli MAI tramite chiamate API Azure live. A grandi linee, ecco cosa fa l'app:

• Tab 1: Accetta un file audio WAV, MP3 o qualsiasi altro e lo invia a MAI-Transcribe-1 tramite l'API REST di Azure Speech, restituendo una trascrizione completa con metriche di latenza e costo
• Tab 2: Prende un input testuale con scelta di voce e stile emotivo, costruisce una richiesta SSML e chiama MAI-Voice-1 per restituire un file audio MP3 riproducibile
• Tab 3: Accetta un prompt testuale e un'impostazione di risoluzione, chiama MAI-Image-2 tramite l'endpoint Azure Foundry e visualizza l'immagine generata inline con opzione di download
• L'app mostra anche stime dei costi in tempo reale per ciascun modello mentre configuri gli input

Ecco la struttura dei file:

mai_demo/
├── app.py            # Streamlit UI 
├── mai_clients.py    # Azure API wrappers 
├── requirements.txt
└── .env

L'app è divisa in due file: mai_clients.py, che gestisce tutte le chiamate API Azure e restituisce dict di risultati strutturati, e app.py, che gestisce la UI di Streamlit. Costruiamola passo dopo passo.

Passo 1: Installa le dipendenze

A differenza di un setup con modello locale, quest'app si connette ad API cloud Azure live, quindi l'elenco delle dipendenze include sia l'SDK Azure Speech sia librerie di supporto per HTTP e immagini.

pip install -r requirements.txt

Il file requirements.txt contiene:

.txt
streamlit>=1.35.0
azure-cognitiveservices-speech>=1.38.0
requests>=2.31.0
pillow>=10.0.0
python-dotenv>=1.0.0
openai>=1.30.0

In questo progetto useremo:

• streamlit per la UI a tre tab, upload dei file, player audio e rendering delle immagini inline

• azure-cognitiveservices-speech per l'SDK Azure Speech, usato per comunicare con MAI-Transcribe-1 e MAI-Voice-1

• requests per effettuare chiamate REST dirette a tutti e tre gli endpoint Azure

• pillow per decodificare e mostrare i byte immagine restituiti da MAI-Image-2

• python-dotenv per caricare chiavi Azure e URL degli endpoint dal file .env a runtime

• openai per l'SDK compatibile con Azure OpenAI, che supporta gli endpoint di generazione immagini di Foundry

Una volta installato, assicurati che il file .env sia nella stessa directory di app.py prima di eseguire l'app. Tutto il caricamento delle credenziali avviene automaticamente all'avvio tramite python-dotenv.

Passo 2: Creare il livello client API (mai_clients.py)

Tutte le chiamate alle API Azure vivono in mai_clients. py , dove ogni funzione restituisce un semplice dizionario {"success": bool, ...} così che il livello UI non vada mai in crash in caso di errore.

MAI-Transcribe-1: Speech-to-Text

MAI-Transcribe-1 è accessibile tramite l'endpoint LLM Speech dell'API REST di Azure Speech. Il dettaglio chiave è che accetta una richiesta multipart form sotto forma di un file audio e un oggetto di definizione JSON.

def transcribe_audio(audio_bytes: bytes, filename: str = "audio.wav") -> dict:
    url = (
        f"https://{speech_region}.api.cognitive.microsoft.com"
        f"/speechtotext/transcriptions:transcribe?api-version=2024-11-15"
    )
    headers = {"Ocp-Apim-Subscription-Key": speech_key}
    definition = '{"locales":["en-US"],"profanityFilterMode":"None"}'
    files = {
        "audio": (filename, audio_bytes, _mime_type(filename)),
        "definition": (None, definition, "application/json"),
    }
    resp = requests.post(url, headers=headers, files=files, timeout=60)
    data = resp.json()
    combined = " ".join(
        p.get("text", "") for p in data.get("combinedPhrases", [])
    ).strip()
    return {"success": True, "transcript": combined, "raw": data, ...}

La risposta dallo snippet di codice sopra arriva come oggetto JSON con combinedPhrases, che è un array di segmenti di testo. Li uniamo in una singola stringa di trascrizione. I formati audio supportati includono WAV, MP3 e FLAC. L'API è al momento vincolata alle regioni East US e West US.

MAI-Voice-1: Text-to-Speech

MAI-Voice-1 utilizza il TTS standard di Azure Speech via SSML. La chiave è costruire il blocco <mstts:express-as> per il controllo delle emozioni e fare riferimento al formato corretto del nome della voce (en-us-Jasper:MAI-Voice-1).

def _build_ssml(text: str, emotion: str, voice_name: str) -> str:
    style_map = {
        "neutral": None,
        "joy": "joy",
        "excitement": "excitement",
        "empathy": "empathy",
    }
    style = style_map.get(emotion)
    text_block = (
        text if style is None
        else f"<mstts:express-as style='{style}'>{text}</mstts:express-as>"
    )
    return f"""<speak version='1.0' xml:lang='en-US'
        xmlns='http://www.w3.org/2001/10/synthesis'
        xmlns:mstts='http://www.w3.org/2001/mstts'>
      <voice name='{voice_name}'>
        {text_block}
      </voice>
    </speak>"""

I nomi delle voci disponibili per MAI-Voice-1 seguono lo schema en-us-{Name}:MAI-Voice-1. L'elenco attuale include Jasper, June, Grant, Iris, Reed e Joy.

MAI-Image-2: Text-to-Image

MAI-Image-2 usa un endpoint specifico di Foundry, che non è il percorso standard Azure OpenAI /openai/deployments/. Il formato corretto dell'endpoint è:

url = f"{base_endpoint}/mai/v1/images/generations"

Qui, il base_endpoint è la radice dell'URL della nostra risorsa Foundry (es. https://your-resource.services.ai.azure.com), con l'eventuale path finale /models rimosso prima di costruire la richiesta. Il body della richiesta ha due requisiti: primo, devi passare esplicitamente il campo model impostato sul nome della tua distribuzione, a differenza degli endpoint OpenAI standard dove il modello è dedotto dal percorso URL:

payload = { "model": deployment, # "MAI-Image-2" "prompt": prompt, "width": width, "height": height, }

Secondo, le dimensioni dell'immagine hanno vincoli rigidi: sia width che height devono essere almeno 768 pixel e il loro prodotto non può superare 1.048.576, che corrisponde a un massimo di 1024×1024 per le immagini quadrate. Passare 512×512 o omettere del tutto le dimensioni restituirà un 400 Bad Request.

La risposta segue la struttura standard della generazione immagini di OpenAI. Ogni elemento nell'array data conterrà o un url che punta a un'immagine hostata oppure un campo b64_json con i byte grezzi codificati in base64. Il client gestisce entrambi i casi:

image_url = row.get("url")
b64 = row.get("b64_json")
if b64:
    img_bytes = base64.b64decode(b64)
elif image_url:
    img_resp = requests.get(image_url, timeout=30)
    img_bytes = img_resp.content

Nota che le risposte url sono a tempo limitato, il che significa che dobbiamo recuperare e memorizzare in cache i byte immediatamente invece di conservare l'URL per un uso successivo.

Passo 3: Costruire la UI Streamlit (app.py)

L'app è organizzata in tre tab, una per modello. Ecco la struttura:

import streamlit as st
from mai_clients import transcribe_audio, synthesize_speech, generate_image
tab1, tab2, tab3 = st.tabs([
    "🎙 MAI-Transcribe-1",
    "🔊 MAI-Voice-1",
    "🖼 MAI-Image-2",
])

Ogni tab segue lo stesso schema: input → pulsante → spinner → visualizzazione del risultato → metriche di costo.

Tab 1: MAI-Transcribe-1

La prima tab gestisce l'upload e la trascrizione dell'audio. Accetta file WAV, MP3 e FLAC, riproduce l'audio inline per verificare cosa stai testando e invia i byte direttamente a transcribe_audio() al click del pulsante.

with tab1:
    audio_file = st.file_uploader("Upload audio file", type=["wav", "mp3", "flac"])
    if audio_file:
        st.audio(audio_file)
        if st.button("Transcribe", type="primary"):
            with st.spinner("Calling MAI-Transcribe-1..."):
                result = transcribe_audio(audio_file.read(), audio_file.name)
            if result["success"]:
                st.text_area("Transcript", value=result["transcript"], height=140)
                m1, m2, m3 = st.columns(3)
                m1.metric("Latency", f"{result['latency_s']}s")
                m2.metric("Audio duration", f"{result['duration_ms']/1000:.1f}s")
                m3.metric("Est. cost", f"${result['duration_ms']/3_600_000 * 0.36:.5f}")

In caso di risposta corretta, la trascrizione appare in un'area di testo modificabile seguita da tre metriche: la latenza API in secondi, la durata dell'audio estratta dal campo durationMilliseconds della risposta e un costo stimato calcolato come duration_in_hours × $0,36.

Una clip di 7 secondi costa circa $0,0000007, quindi puoi eseguire dozzine di file di test senza incidere significativamente sul credito Azure.

Tab 2: MAI-Voice-1

La seconda tab gestisce la sintesi text-to-speech. Espone i tre controlli che contano di più per testare MAI-Voice-1: l'input di testo, lo stile emotivo e la selezione della voce, che sono passati direttamente alla funzione synthesize_speech().

with tab2:
    text_input = st.text_area("Text to synthesize", value="The quarterly results exceeded...")
    emotion = st.selectbox("Emotion / style", ["neutral", "joy", "excitement", "empathy"])
    voice_name = st.selectbox("Voice", ["en-us-Jasper:MAI-Voice-1", "en-us-June:MAI-Voice-1", ...])
    if st.button("Synthesize", type="primary"):
        with st.spinner("Calling MAI-Voice-1..."):
            result = synthesize_speech(text_input, emotion=emotion, voice_name=voice_name)
        if result["success"]:
            st.audio(result["audio_bytes"], format="audio/mp3")

L'opzione per le emozioni mappa agli stili SSML <mstts:express-as> sotto il cofano; neutral omette completamente il tag per un output base pulito, mentre i selettori joy, excitement ed empathy producono profili di ritmo e intonazione visibilmente diversi. Il menu a discesa delle voci copre le sei voci MAI-Voice-1 attualmente disponibili: Jasper, June, Grant, Iris, Reed e Joy.

In caso di successo, i byte MP3 restituiti vengono passati direttamente a st.audio() per la riproduzione inline. Con 113 caratteri, il costo stimato è di $0,000002, il che significa che puoi eseguire più test senza consumare troppi crediti.

Tab 3: MAI-Image-2

La terza tab gestisce la generazione di immagini da testo. L'API attuale di MAI-Image-2 espone due parametri di input, ovvero prompt e risoluzione. Non ci sono livelli di qualità o controlli di stile: il modello li gestisce internamente.

with tab3:
    prompt = st.text_area("Image prompt", value="A worn paperback book on a café table...")
    size = st.selectbox("Resolution", ["1024x1024", "1365x768", "768x1365"])
    if st.button("Generate", type="primary"):
        with st.spinner("Calling MAI-Image-2..."):
            result = generate_image(prompt, size=size)
        if result["success"]:
            img = Image.open(io.BytesIO(result["image_bytes"]))
            st.image(img, use_container_width=True)

Le tre opzioni di risoluzione coprono i principali rapporti d'aspetto: quadrato (1024×1024), orizzontale (1365×768) e verticale (768×1365). La stringa size viene analizzata in larghezza e altezza come interi separati prima dell'invio all'API, poiché l'endpoint Foundry li accetta come campi individuali e non come stringa combinata.

In caso di successo, i byte grezzi dell'immagine dalla risposta API sono incapsulati in un buffer BytesIO, aperti con Pillow e renderizzati inline alla larghezza completa del contenitore. La generazione dell'immagine richiede in genere 2–4 secondi, sensibilmente più veloce di MAI-Image-1 nello stesso ambiente.

Passo 4: Esecuzione dell'app

Con il file .env configurato e le dipendenze installate, sei pronto per eseguire l'app.

streamlit run app.py

Streamlit avvierà un server locale e aprirà automaticamente l'app nel browser all'indirizzo http://localhost:8501. Dovresti vedere l'interfaccia a tre tab con MAI-Transcribe-1 attiva per impostazione predefinita.

Test dei modelli

Ecco cosa hanno prodotto i modelli quando li abbiamo eseguiti.

Test 1: Trascrizione di audio rumoroso

Ho testato MAI-Transcribe-1 con una clip audio di 7 secondi registrata in un ambiente rumoroso ma ottimale con accento indiano. Il modello ha restituito una trascrizione pulita e accurata in meno di 2 secondi.

Conclusione: Il risultato ha retto bene su parlato con accento, che è l'ambito in cui Whisper-large-v3 di solito fatica di più. Detto ciò, i numeri per lingua raccontano una storia diversa: ad esempio l'arabo è al 10,1% e il danese al 13,2%, entrambi ben al di sopra del dato di punta. Se il tuo caso d'uso coinvolge una lingua specifica o una distribuzione di accenti regionali, testalo sul tuo audio reale prima di impegnarti al modello in produzione.

Test 2: Controllo delle emozioni

Ho sintetizzato una frase da 113 caratteri con lo stile excitement usando la voce en-us-Jasper:MAI-Voice-1, e ha restituito un MP3 di 6 secondi in meno di 1 secondo. L'emozione era chiaramente presente nell'output con un ritmo più energico e una maggiore variazione dell'intonazione.

Conclusione: Una clip di 6 secondi generata in meno di 1 secondo è notevole. Il controllo delle emozioni via SSML funziona ma è limitato a quattro stili: neutral, joy, excitement ed empathy. Quindi, non aspettarti l'intera gamma espressiva che otterresti dalla libreria di stili di ElevenLabs.

Test 3: Fotorealismo e rendering del testo

Questo è il test più interessante perché ho scelto deliberatamente un prompt che combina due cose: composizione di scena fotorealistica e testo all'interno dell'immagine. La maggior parte dei modelli di diffusione fallisce almeno uno di questi aspetti.

Prompt: "A worn paperback book on a café table, natural window light, steam rising from an espresso cup beside it. The book cover reads: INFERENCE AT SCALE — text clearly legible, not warped."

Conclusione: Il fotorealismo è davvero forte, con luce naturale dalla finestra, vapore convincente e texture credibili su libro e tazza. Anche il testo "INFERENCE AT SCALE" è stato reso correttamente e in modo leggibile.

Tuttavia, il rendering del testo è incoerente tra le esecuzioni. In più generazioni di test con prompt simili, il modello ha occasionalmente prodotto testo scritto male o confuso. Questo è un difetto noto di tutti gli attuali modelli di diffusione, e MAI-Image-2 è migliore della maggior parte ma non immune. Inoltre, la risoluzione massima attuale è 1024×1024 pixel che, per la maggior parte dei casi d'uso web e content, è sufficiente, ma esclude output da stampa o lavori creativi in grande formato senza un passaggio di upscaling.  Se generi immagini in cui l'accuratezza del testo è critica, assicurati di aggiungere sempre un passaggio di revisione umana.

Conclusione

La famiglia di modelli MAI di Microsoft è davvero notevole, e i numeri FLEURS di MAI-Transcribe-1 sono i più oggettivamente verificabili dei tre, dato che mantengono un WER medio del 3,88%, il migliore della categoria al momento in cui scriviamo.

MAI-Voice-1 colpisce per velocità e qualità della voce ma è limitato dal supporto solo inglese e da una palette di emozioni ridotta. MAI-Image-2 produce output fotorealistici di qualità, ma con l'importante avvertenza che le allucinazioni di testo accadono ancora e richiedono revisione umana in produzione.

Il codice completo per questo tutorial è disponibile su GitHub.