Modèles Microsoft MAI : tester MAI-Transcribe-1, MAI-Voice-1 et MAI-Image-2 avec Streamlit

Que sont les modèles Microsoft MAI ?

La famille de modèles MAI est développée par l'équipe Microsoft AI Superintelligence. Ce sont des modèles entièrement internes, entraînés sur l'infrastructure de Microsoft, optimisés pour sa pile de service et déployés directement via Azure. MAI-Transcribe-1 et MAI-Voice-1 fonctionnent sur la même infrastructure Azure Speech qui sert déjà des clients entreprise à grande échelle, tandis que MAI-Image-2 utilise une architecture de diffusion flow-matching avec le même objectif d'entraînement que Stable Diffusion 3, avec entre 10 et 50 milliards de paramètres hors embeddings. 

Voici un récapitulatif rapide des trois :

Allons plus loin pour chacun avant de passer au build.

MAI-Transcribe-1

MAI-Transcribe-1 est un modèle de speech-to-text prenant en charge 25 langues. Son chiffre phare est un Word Error Rate (WER) moyen de 3,88 % sur le benchmark FLEURS : plus c'est bas, mieux c'est. Il devance ainsi GPT-Transcribe (4,17 %), Scribe v2 (4,32 %), Gemini 3.1 Flash-Lite (4,89 %) et Whisper-large-v3 (7,60 %).

Le modèle est conçu pour gérer l'audio imparfait du monde réel : environnements bruyants, accents mélangés, élocution naturelle. Microsoft indique également que MAI-Transcribe-1 offre une bonne précision avec un coût GPU environ 50 % plus faible que les alternatives de référence : un atout clé pour les entreprises qui transcrivent à grande échelle.

En revanche, il ne propose pas encore la transcription temps réel, la diariséation des locuteurs ni le biais de contexte, annoncés comme « bientôt disponibles ».

MAI-Voice-1

MAI-Voice-1 est le modèle TTS haute fidélité de Microsoft. Sa capacité phare est le voice prompting : vous fournissez un échantillon audio de 10 secondes et le modèle clone la voix sans fine-tuning. Le clonage de voix nécessite toutefois une approbation contrôlée par Microsoft, mais la bibliothèque de voix présélectionnées (noms comme en-us-Jasper:MAI-Voice-1, en-us-June:MAI-Voice-1) est immédiatement accessible.

Le modèle génère 60 secondes d'audio en une seule seconde sur un seul GPU, prend en charge le contrôle des émotions par tour via SSML et vise les contenus longs comme les livres audio et les podcasts. Il alimente déjà les fonctionnalités Audio Expressions et podcast de Copilot dans les produits Microsoft.

Un point faible : il est pour l'instant « English-only », avec plus de 10 langues attendues prochainement.

MAI-Image-2

MAI-Image-2 s'appuie sur une architecture de diffusion flow-matching avec 10–50 milliards de paramètres. Il figure dans le top 3 du classement image d'Arena.ai et est deux fois plus rapide que MAI-Image-1 en production. Développé en collaboration avec des photographes, designers et conteurs visuels, il est déjà intégré dans Copilot, Bing Image Creator et PowerPoint. Il excelle en photoréalisme, en tons de peau fidèles et en texte lisible dans l'image.

Ses scores Elo par catégorie incluent photoréalisme (1201) et portraits (1201), où il brille, tandis que le rendu de texte (1186) s'améliore mais reste le point le plus faible.

Configuration d'Azure pour tous les modèles

Les trois modèles MAI sont disponibles sur Microsoft Azure. MAI-Transcribe-1 et MAI-Voice-1 partagent la même ressource Azure Speech, tandis que MAI-Image-2 fonctionne via Microsoft Foundry. Configurons-les l'un après l'autre.

Prérequis

• Inscrivez-vous ou connectez-vous à votre compte Azure pour obtenir $200 de crédit offert
• Python 3.9+

Étape 1 : créer une ressource Azure Speech 

MAI-Transcribe-1 et MAI-Voice-1 s'utilisent via le service Azure AI Speech : une seule ressource couvre donc les deux.

• Allez sur portal.azure.com

• Dans la barre de recherche, tapez Speech et sélectionnez Speech services

• Cliquez sur + Create

• Renseignez le formulaire :

• Groupe de ressources : créez un nouveau groupe et nommez-le mai-demo-rg

• Région : sélectionnez East US car les modèles MAI ne sont actuellement pris en charge qu'en East US et West US

• Nom : mai-speech-demo

• Offre tarifaire : Standard S0

• Remarque : la formule gratuite F0 a des limites de débit qui peuvent interrompre la démo

• Enfin, cliquez sur Review and create, puis sur Create.

Une fois le déploiement terminé, allez dans Keys and Endpoint dans le menu de gauche, copiez la Key 1 et notez la Region (eastus).

Étape 2 : créer une ressource Foundry et déployer MAI-Image-2

MAI-Image-2 est accessible via Microsoft Foundry, distinct du portail Azure classique.

• Depuis la page d'accueil du portail Azure, cliquez sur Foundry dans la rangée des services en haut 

• Cliquez sur Create a resource

• Renseignez ensuite les informations suivantes :

• Groupe de ressources : sélectionnez le même mai-demo-rg que à l'étape 1

• Région : East US

• Nom : mai-image-demo

• Nom du projet par défaut : proj-default

• Puis cliquez sur Review and create, puis sur Create

• Une fois la ressource active, cliquez sur Go to Foundry portal. 

• Dans l'interface Foundry, cliquez ensuite sur Model catalog dans le menu de gauche

• Recherchez MAI dans la barre de recherche : vous verrez les quatre modèles MAI listés

• Sélectionnez MAI-Image-2 et cliquez sur Use this model

• Dans la boîte de déploiement, définissez :

• Nom du déploiement : MAI-Image-2 

• Type de déploiement : Global Standard

• Enfin, cliquez sur deploy

Après le déploiement, vous arrivez sur la page de détails du déploiement. Copiez le Target URI (de type https://mai-image-demo.services.ai.azure.com/models) et la Key.

Étape 3 : configurer le fichier .env

Créez un fichier .env dans le répertoire local de votre projet et ajoutez les informations récupérées aux deux étapes précédentes :

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-2Propulsé par

Note importante : AZURE_IMAGE_DEPLOYMENT est sensible à la casse. Utilisez MAI-Image-2 exactement comme dans Foundry ; en minuscules mai-image-2 renverra une erreur unknown_model.

Démo des modèles MAI : créer une app voix, parole et image avec Streamlit

Dans cette section, nous allons construire une app Streamlit à trois onglets qui appelle les trois modèles MAI via des appels API Azure en direct. En bref, l'app fait ceci :

• Onglet 1 : accepte un fichier audio WAV, MP3 ou autre et l'envoie à MAI-Transcribe-1 via l'API REST Azure Speech, pour renvoyer une transcription complète avec latence et coûts estimés
• Onglet 2 : prend un texte avec choix de voix et d'émotion, construit une requête SSML et appelle MAI-Voice-1 pour renvoyer un MP3 lisible
• Onglet 3 : accepte un prompt texte et une résolution, appelle MAI-Image-2 via l'endpoint Azure Foundry et affiche l'image générée avec option de téléchargement
• L'app affiche aussi en direct une estimation des coûts pour chaque modèle selon vos paramètres

Voici l'organisation des fichiers :

mai_demo/
├── app.py            # UI Streamlit 
├── mai_clients.py    # Wrappers d'API Azure 
├── requirements.txt
└── .envPropulsé par

L'app est scindée en deux fichiers : mai_clients.py, qui gère tous les appels d'API Azure et renvoie des dictionnaires de résultats structurés, et app.py, qui gère l'interface Streamlit. Construisons-la étape par étape.

Étape 1 : installer les dépendances

Contrairement à un setup local de modèle, cette app se connecte à des APIs cloud Azure en direct : la liste comprend donc le SDK Azure Speech et des bibliothèques HTTP et image.

pip install -r requirements.txtPropulsé par

Le fichier requirements.txt contient :

.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.0Propulsé par

Dans ce projet, nous allons utiliser :

• streamlit pour l'UI à trois onglets, l'upload de fichiers, les lecteurs audio et l'affichage inline des images

• azure-cognitiveservices-speech pour le SDK Azure Speech, utilisé avec MAI-Transcribe-1 et MAI-Voice-1

• requests pour effectuer des appels REST directs vers les trois endpoints Azure

• pillow pour décoder et afficher les octets d'image renvoyés par MAI-Image-2

• python-dotenv pour charger les clés Azure et URLs d'endpoint depuis le fichier .env au démarrage

• openai pour le SDK compatible Azure OpenAI, qui prend en charge les endpoints de génération d'images de Foundry

Une fois l'installation terminée, vérifiez que le fichier .env se trouve dans le même répertoire que app.py avant de lancer l'app. Le chargement des secrets se fait automatiquement au démarrage via python-dotenv.

Étape 2 : construire la couche client API (mai_clients.py)

Tous les appels Azure vivent dans mai_clients.py, chaque fonction renvoyant un simple dictionnaire {"success": bool, ...} afin que l'UI ne plante jamais en cas d'erreur.

MAI-Transcribe-1 : speech-to-text

MAI-Transcribe-1 s'utilise via l'endpoint LLM Speech de l'API REST Azure Speech. Détail clé : il attend une requête multipart contenant le fichier audio et un objet de définition 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, ...}Propulsé par

La réponse arrive en JSON avec combinedPhrases, un tableau de segments de texte. Nous les joignons en une seule transcription. Les formats audio pris en charge incluent WAV, MP3 et FLAC. L'API est pour l'instant limitée aux régions East US et West US.

MAI-Voice-1 : text-to-speech

MAI-Voice-1 utilise le TTS Azure Speech standard via SSML. L'essentiel est de construire le bloc <mstts:express-as> pour le contrôle des émotions et de référencer le bon format de nom de voix (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>"""Propulsé par

Les noms de voix disponibles pour MAI-Voice-1 suivent le motif en-us-{Name}:MAI-Voice-1. La liste actuelle comprend Jasper, June, Grant, Iris, Reed et Joy.

MAI-Image-2 : text-to-image

MAI-Image-2 utilise un endpoint spécifique Foundry, différent du chemin Azure OpenAI standard /openai/deployments/. Le format correct est :

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

Ici, base_endpoint est la racine de l'URL de votre ressource Foundry (par ex. https://your-resource.services.ai.azure.com), en retirant tout /models final avant de construire la requête. Le corps de requête a deux exigences : il faut d'abord passer explicitement le champ model avec le nom de votre déploiement, contrairement aux endpoints OpenAI standards où le modèle est inféré depuis l'URL :

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

Ensuite, les dimensions de l'image sont contraintes : width et height doivent faire au minimum 768 pixels, et leur produit ne peut pas dépasser 1 48 576 (soit 1024×1024 maximum pour un carré). Passer 512×512 ou omettre les dimensions renverra un 400 Bad Request.

La réponse suit la structure standard de génération d'images OpenAI. Chaque élément du tableau data contient soit une url vers une image hébergée, soit un champ b64_json avec les octets bruts en base64. Le client gère les deux :

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.contentPropulsé par

Notez que les réponses url sont limitées dans le temps : il faut donc récupérer et mettre en cache les octets immédiatement, plutôt que de stocker l'URL pour plus tard.

Étape 3 : construire l'UI Streamlit (app.py)

L'app est organisée en trois onglets, un par modèle. Voici la structure :

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",
])Propulsé par

Chaque onglet suit le même schéma : entrées → bouton → spinner → résultats → coûts.

Onglet 1 : MAI-Transcribe-1

Le premier onglet gère l'upload et la transcription audio. Il accepte WAV, MP3 et FLAC, lit l'audio en ligne pour vérifier le test, puis envoie les octets à transcribe_audio() au clic.

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}")Propulsé par

En cas de succès, la transcription apparaît dans une zone de texte éditable, suivie de trois indicateurs : la latence API en secondes, la durée audio extraite du champ durationMilliseconds de la réponse, et un coût estimé calculé comme durée_en_heures × $0,36.

Un extrait de 7 secondes coûte environ $0,0000007 ; vous pouvez donc lancer des dizaines de tests sans entamer votre crédit Azure.

Onglet 2 : MAI-Voice-1

Le deuxième onglet gère la synthèse vocale. Il expose les trois contrôles essentiels pour tester MAI-Voice-1 : le texte, le style d'émotion et la sélection de voix, passés tels quels à la fonction 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")Propulsé par

Le sélecteur d'émotions correspond aux styles SSML <mstts:express-as> en interne ; neutral omet la balise pour une base propre, tandis que joy, excitement et empathy produisent des variations nettes de débit et de hauteur. La liste des voix couvre les six voix MAI-Voice-1 disponibles : Jasper, June, Grant, Iris, Reed et Joy.

En cas de succès, les octets MP3 renvoyés sont passés directement à st.audio() pour une lecture inline. Pour 113 caractères, le coût estimé est de $0,000002 : vous pouvez donc tester plusieurs fois sans épuiser vos crédits.

Onglet 3 : MAI-Image-2

Le troisième onglet gère la génération d'images à partir de texte. L'API actuelle de MAI-Image-2 expose deux paramètres : le prompt et la résolution. Pas de paliers de qualité ni de contrôles de style : le modèle gère cela en interne.

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)Propulsé par

Les trois résolutions couvrent les principaux ratios : carré (1024×1024), paysage (1365×768) et portrait (768×1365). La chaîne de taille est analysée en largeur et hauteur avant l'appel, car l'endpoint Foundry attend des champs distincts.

En cas de succès, les octets d'image sont enveloppés dans un buffer BytesIO, ouverts avec Pillow et affichés en largeur de conteneur. La génération prend généralement 2–4 secondes, nettement plus rapide que MAI-Image-1 dans le même environnement.

Étape 4 : lancer l'app

Avec votre fichier .env configuré et les dépendances installées, vous pouvez lancer l'app.

streamlit run app.pyPropulsé par

Streamlit démarre un serveur local et ouvre automatiquement l'app dans votre navigateur à l'adresse http://localhost:8501. Vous devriez voir l'interface à trois onglets avec MAI-Transcribe-1 actif par défaut.

Tester les modèles

Voici ce que les modèles ont produit lors de nos essais.

Test 1 : transcription d'un audio bruyant

J'ai testé MAI-Transcribe-1 avec un extrait de 7 secondes enregistré dans un environnement volontairement bruyant, avec un accent indien. Le modèle a renvoyé une transcription nette et précise en moins de 2 secondes.

À retenir : le résultat tient bien sur de la parole accentuée, là où Whisper-large-v3 peine généralement le plus. Cela dit, les chiffres par langue racontent une autre histoire : par exemple l'arabe à 10,1 % et le danois à 13,2 %, bien au-dessus de la moyenne globale. Si votre cas d'usage concerne une langue ou des accents régionaux précis, testez sur votre audio réel avant un engagement en production.

Test 2 : contrôle de l'émotion

J'ai synthétisé une phrase de 113 caractères avec le style excitement en utilisant la voix en-us-Jasper:MAI-Voice-1. Le modèle a renvoyé un MP3 de 6 secondes en moins d'une seconde. L'émotion est bien perceptible avec un débit plus énergique et une plus grande variation de hauteur.

À retenir : générer 6 secondes en moins d'une seconde est remarquable. Le contrôle SSML des émotions fonctionne mais se limite à quatre styles : neutral, joy, excitement et empathy. N'attendez donc pas la palette exhaustive de styles d'ElevenLabs.

Test 3 : photoréalisme et rendu de texte

C'est le test le plus intéressant : j'ai volontairement choisi un prompt qui combine deux éléments : composition photoréaliste et texte dans l'image. La plupart des modèles de diffusion échouent sur au moins l'un des deux.

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."

À retenir : le photoréalisme est vraiment solide : lumière naturelle, vapeur convaincante, texture crédible sur le livre et la tasse. Le texte "INFERENCE AT SCALE" est également correctement rendu et lisible.

En revanche, le rendu de texte reste inconstant d'une génération à l'autre. Lors de plusieurs essais similaires, le modèle a parfois produit des mots mal orthographiés ou déformés. C'est une limite connue de tous les modèles de diffusion actuels : MAI-Image-2 fait mieux que la plupart, mais n'y échappe pas. De plus, la résolution max actuelle est 1024×1024 : suffisant pour le web et le contenu, mais trop juste pour l'impression ou les grands formats sans étape d'upscaling. Si la fidélité du texte est critique, prévoyez systématiquement une relecture humaine.

Conclusion

La famille de modèles MAI de Microsoft est vraiment impressionnante. Les chiffres FLEURS de MAI-Transcribe-1 sont les plus objectivement vérifiables des trois : un WER moyen de 3,88 %, le meilleur de sa catégorie à la date de rédaction.

MAI-Voice-1 séduit par sa vitesse et la qualité des voix, mais reste limité à l'anglais et à une palette émotionnelle restreinte. MAI-Image-2 produit un très bon photoréalisme, avec toutefois une mise en garde importante : les hallucinations de texte persistent et requièrent une validation humaine en production.

Le code complet de ce tutoriel est disponible sur GitHub.