Microsoft-MAI-Modelle: MAI-Transcribe-1, MAI-Voice-1 und MAI-Image-2 mit Streamlit testen

Was sind die Microsoft-MAI-Modelle?

Die MAI-Modellfamilie stammt vom Microsoft AI Superintelligence Team. Es sind vollständig interne Modelle, auf Microsofts eigener Infrastruktur trainiert, für Microsofts Serving-Stack optimiert und direkt über Azure bereitgestellt. MAI-Transcribe-1 und MAI-Voice-1 laufen auf derselben Azure-Speech-Infrastruktur, die bereits Enterprise-Kunden im großen Maßstab bedient, während MAI-Image-2 eine Flow-Matching-Diffusionsarchitektur mit demselben Trainingsziel wie Stable Diffusion 3 nutzt – mit zwischen 10 und 50 Milliarden Nicht-Embedding-Parametern. 

Hier ist die Kurzübersicht zu allen drei:

Schauen wir uns jedes Modell im Detail an, bevor wir bauen.

MAI-Transcribe-1

MAI-Transcribe-1 ist ein Speech-to-Text-Modell mit Unterstützung für 25 Sprachen. Das Highlight ist eine durchschnittliche Word Error Rate (WER) von 3,88% auf dem FLEURS-Benchmark – je niedriger, desto besser. Damit liegt es vor GPT-Transcribe (4,17%), Scribe v2 (4,32%), Gemini 3.1 Flash-Lite (4,89%) und Whisper-large-v3 (7,60%).

Das Modell ist speziell für unaufgeräumtes Audio aus der Praxis gebaut – inklusive lauter Umgebungen, gemischter Akzente und natürlicher Sprechweise. Microsoft gibt außerdem an, dass MAI-Transcribe-1 bei rund 50% geringeren GPU-Kosten als führende Alternativen gute Genauigkeit liefert – ein echter Vorteil für Unternehmen mit Transkription im großen Maßstab.

Allerdings fehlen noch Echtzeit-Transkription, Sprechertrennung (Diarization) und Kontext-Biasing – alle als "Coming soon" gelistet. 

MAI-Voice-1

MAI-Voice-1 ist Microsofts hochqualitatives TTS-Modell. Die Schlüssel-Fähigkeit ist Voice Prompting: Du gibst eine 10-Sekunden-Audioprobe vor, und das Modell klont die Stimme ohne Fine-Tuning. Voice-Cloning erfordert jedoch eine Freigabe durch Microsoft, aber die kuratierte Stimmenbibliothek (Namen wie en-us-Jasper:MAI-Voice-1, en-us-June:MAI-Voice-1) ist sofort nutzbar.

Das Modell erzeugt 60 Sekunden Audio in einer Sekunde auf einer einzelnen GPU, unterstützt pro Turn Emotion-Control via SSML und ist für Longform-Inhalte wie Hörbücher und Podcasts gedacht. Es treibt bereits Copilots Audio Expressions und Podcast-Features in Microsoft-Produkten an.

Ein Nachteil: Es ist derzeit „nur Englisch“, weitere 10+ Sprachen folgen bald.

MAI-Image-2

MAI-Image-2 nutzt eine Flow-Matching-Diffusionsarchitektur mit 10–50 Milliarden Parametern. Es zählt zu den Top-3-Modellen auf der Arena.ai-Bildrangliste und ist in der Produktion doppelt so schnell wie MAI-Image-1. Entwickelt in Zusammenarbeit mit Fotograf:innen, Designer:innen und Visual Storytellers, ist es bereits in Copilot, Bing Image Creator und PowerPoint im Einsatz. Der Fokus liegt auf Fotorealismus, akkuraten Hauttönen und gut lesbarem In-Image-Text.

Die Elo-Scores nach Kategorie beinhalten u. a. Fotorealismus (1201) und Porträts (1201) – dort glänzt es –, während Textrendering (1186) besser als zuvor ist, aber weiterhin die schwächste Kategorie darstellt.

Azure-Einrichtung für alle Modelle

Alle drei MAI-Modelle sind auf Microsoft Azure verfügbar. MAI-Transcribe-1 und MAI-Voice-1 teilen sich die Azure-Speech-Ressource, während MAI-Image-2 über Microsoft Foundry läuft. Wir richten beides nacheinander ein.

Voraussetzungen

• Registriere dich oder melde dich in deinem Azure-Konto an und erhalte $200 Startguthaben
• Python 3.9+

Schritt 1: Azure-Speech-Ressource anlegen 

Sowohl MAI-Transcribe-1 als auch MAI-Voice-1 werden über den Azure AI Speech Service genutzt, eine Ressource reicht also für beide.

• Gehe zu portal.azure.com

• Gib in der Suche Speech ein und wähle Speech services

• Klicke auf + Create

• Fülle das Formular aus:

• Resource group: Neue Resource Group anlegen und mai-demo-rg nennen

• Region: Wähle East US, da MAI-Modelle aktuell nur für East US und West US unterstützt werden

• Name: mai-speech-demo

• Pricing tier: Standard S0

• Hinweis: Free F0 hat Ratenlimits, die die Demo stören können

• Klicke zum Schluss auf Review and create, und nach dem Laden auf Create.

Nach der Bereitstellung gehst du in der linken Seitenleiste zu Keys and Endpoint und kopierst Key 1 sowie den Region-Wert (eastus).

Schritt 2: Foundry-Ressource erstellen und MAI-Image-2 deployen

MAI-Image-2 wird über Microsoft Foundry angesprochen – separat vom regulären Azure-Portal.

• Klicke auf der Azure-Portal-Startseite oben in den Services auf Foundry 

• Klicke auf Create a resource

• Fülle anschließend folgende Details aus:

• Resource group: Wähle dieselbe mai-demo-rg aus Schritt 1

• Region: East US

• Name: mai-image-demo

• Default project name: proj-default

• Klicke dann auf Review and create, und anschließend auf Create

• Sobald die Ressource aktiv ist, klicke auf Go to Foundry portal. 

• Gehe im Foundry-Interface in der linken Seitenleiste auf Model catalog

• Suche nach MAI und du siehst alle vier MAI-Modelle gelistet

• Wähle MAI-Image-2 und klicke Use this model

• Lege im Deploy-Dialog fest:

• Deployment name: MAI-Image-2 

• Deployment type: Global Standard

• Zum Schluss auf deploy klicken

Nach dem Deployment landest du auf der Detailseite. Kopiere die Target URI (z. B. https://mai-image-demo.services.ai.azure.com/models) und den Key.

Schritt 3: Die .env-Datei konfigurieren

Erstelle eine .env-Datei in deinem lokalen Projektverzeichnis und füge die Daten aus den vorherigen Schritten ein:

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

Wichtiger Hinweis: AZURE_IMAGE_DEPLOYMENT ist case-sensitiv. Verwende exakt MAI-Image-2, wie es in Foundry erscheint. Kleinschreibung wie mai-image-2 führt zum Fehler unknown_model.

MAI-Modelle in Aktion: Speech-, Voice- und Image-App mit Streamlit bauen

In diesem Abschnitt bauen wir eine Streamlit-App mit drei Tabs, die alle MAI-Modelle über Live-Azure-APIs aufruft. Auf hoher Ebene macht die App Folgendes:

• Tab 1: Nimmt WAV, MP3 oder andere Audio-Dateien an, schickt sie via Azure Speech REST API an MAI-Transcribe-1 und liefert ein komplettes Transkript plus Latenz- und Kostenschätzung
• Tab 2: Nimmt Texteingaben mit Stimm- und Emotionswahl, baut eine SSML-Anfrage und ruft MAI-Voice-1 auf, um eine abspielbare MP3-Datei zu erzeugen
• Tab 3: Nimmt einen Textprompt und eine Auflösung, ruft MAI-Image-2 über den Azure-Foundry-Endpunkt auf und rendert das generierte Bild inline mit Download-Option
• Die App zeigt außerdem in Echtzeit Kostenschätzungen je Modell an, während du die Eingaben konfigurierst

So ist das Projekt aufgebaut:

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

Die App ist in zwei Dateien aufgeteilt: mai_clients.py übernimmt alle Azure-API-Calls und gibt strukturierte Ergebnis-Dicts zurück, app.py kümmert sich um die Streamlit-Oberfläche. Gehen wir Schritt für Schritt vor.

Schritt 1: Abhängigkeiten installieren

Anders als bei einem lokalen Modell-Setup verbindet sich diese App mit Live-Azure-Cloud-APIs. Daher umfasst die Abhängigkeitsliste das Azure Speech SDK sowie HTTP- und Bildbibliotheken.

pip install -r requirements.txt

Die Datei requirements.txt enthält:

.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 diesem Projekt nutzen wir:

• streamlit für die Drei-Tab-UI, Datei-Uploads, Audioplayer und Inline-Bildanzeige

• azure-cognitiveservices-speech für das Azure Speech SDK zur Kommunikation mit MAI-Transcribe-1 und MAI-Voice-1

• requests für direkte REST-API-Calls an alle drei Azure-Endpunkte

• pillow zum Dekodieren und Anzeigen der von MAI-Image-2 zurückgegebenen Bildbytes

• python-dotenv zum Laden der Azure-Keys und Endpunkt-URLs aus der .env-Datei zur Laufzeit

• openai für das Azure-OpenAI-kompatible SDK, das Foundry-Bildendpunkte unterstützt

Stelle sicher, dass sich die .env-Datei im selben Verzeichnis wie app.py befindet, bevor du die App startest. Das Laden der Zugangsdaten passiert automatisch beim Start über python-dotenv.

Schritt 2: Die API-Client-Schicht bauen (mai_clients.py)

Alle Azure-API-Aufrufe liegen in mai_clients.py. Jede Funktion gibt ein einfaches {"success": bool, ...}-Dictionary zurück, damit die UI-Schicht bei Fehlern nicht abstürzt.

MAI-Transcribe-1: Speech-to-Text

MAI-Transcribe-1 wird über das LLM-Speech-Endpunkt der Azure Speech REST API genutzt. Wichtig: Der Request ist Multipart-Form mit einer Audiodatei und einem JSON-Definitionsobjekt.

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, ...}

Die Antwort kommt als JSON mit combinedPhrases – ein Array aus Textsegmenten. Wir fügen sie zu einem Transkript zusammen. Unterstützte Audioformate sind WAV, MP3 und FLAC. Die API ist aktuell auf East US und West US beschränkt.

MAI-Voice-1: Text-to-Speech

MAI-Voice-1 nutzt Standard-Azure-Speech-TTS via SSML. Entscheidend ist der <mstts:express-as>-Block zur Emotionssteuerung und das richtige Stimmnamensformat (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>"""

Die verfügbaren Stimmnamen für MAI-Voice-1 folgen dem Muster en-us-{Name}:MAI-Voice-1. Aktuell sind u. a. Jasper, June, Grant, Iris, Reed und Joy verfügbar.

MAI-Image-2: Text-to-Image

MAI-Image-2 nutzt einen Foundry-spezifischen Endpunkt, nicht den üblichen Azure-OpenAI-Pfad /openai/deployments/. Das korrekte Format ist:

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

Hier ist base_endpoint die Wurzel deiner Foundry-Ressourcen-URL (z. B. https://your-resource.services.ai.azure.com), wobei ein etwaiges /models vor dem Request entfernt werden muss. Der Request-Body hat zwei Besonderheiten: Erstens musst du das Feld model explizit auf deinen Deployment-Namen setzen – anders als bei Standard-OpenAI-Endpunkten, wo das Modell aus dem URL-Pfad abgeleitet wird:

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

Zweitens gelten harte Grenzen für Bildmaße: width und height müssen jeweils mindestens 768 Pixel betragen, und ihr Produkt darf 1.048.576 nicht überschreiten – quadratisch also maximal 1024×1024. 512×512 oder fehlende Maße führen zu 400 Bad Request.

Die Antwort folgt der gängigen OpenAI-Form. Jedes Element im data-Array enthält entweder eine gehostete url oder b64_json mit Base64-Bytes. Der Client unterstützt beides:

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

Beachte: url-Antworten sind zeitlich begrenzt. Lade und cache die Bytes daher sofort, statt die URL für später zu speichern.

Schritt 3: Die Streamlit-UI bauen (app.py)

Die App ist in drei Tabs organisiert – je ein Tab pro Modell. So sieht die Struktur aus:

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

Jeder Tab folgt demselben Ablauf: Eingaben → Button → Spinner → Ergebnisanzeige → Kostenmetriken.

Tab 1: MAI-Transcribe-1

Der erste Tab übernimmt Upload und Transkription. Er akzeptiert WAV, MP3 und FLAC, spielt das Audio inline ab, damit du den Test prüfen kannst, und sendet die Bytes beim Klick direkt an transcribe_audio().

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}")

Bei Erfolg erscheint das Transkript in einem editierbaren Textfeld, gefolgt von drei Metriken: API-Latenz in Sekunden, die Audiodauer aus dem Feld durationMilliseconds und eine Kostenschätzung berechnet als duration_in_hours × $0,36.

Ein 7-Sekunden-Clip kostet grob $0,0000007 – du kannst also dutzende Tests fahren, ohne dein Azure-Guthaben spürbar anzutasten.

Tab 2: MAI-Voice-1

Der zweite Tab übernimmt Text-to-Speech. Er bietet die drei wichtigsten Regler für Tests mit MAI-Voice-1: Texteingabe, Emotionsstil und Stimmwahl – alles wird direkt an die Funktion synthesize_speech() übergeben.

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

Der Emotionswähler mappt unter der Haube auf SSML-<mstts:express-as>-Styles; neutral lässt das Tag weg für eine saubere Basis, joy, excitement und empathy liefern deutlich andere Tempo- und Tonhöhenprofile. Die Dropdown-Liste deckt die sechs aktuell verfügbaren MAI-Voice-1-Stimmen ab: Jasper, June, Grant, Iris, Reed und Joy.

Bei Erfolg werden die zurückgegebenen MP3-Bytes direkt an st.audio() für die Inline-Wiedergabe übergeben. Bei 113 Zeichen liegt die Kostenschätzung bei $0,000002 – genug Spielraum für mehrere Tests.

Tab 3: MAI-Image-2

Der dritte Tab übernimmt Text-zu-Bild. Die aktuelle API von MAI-Image-2 bietet zwei Eingaben: Prompt und Auflösung. Es gibt keine Qualitätsstufen oder Stilregler – das übernimmt das Modell intern.

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)

Die drei Auflösungen decken die gängigen Seitenverhältnisse ab: quadratisch (1024×1024), Querformat (1365×768) und Hochformat (768×1365). Der Größenstring wird vor dem API-Call in Breite und Höhe geparst, da der Foundry-Endpunkt getrennte Felder erwartet.

Bei Erfolg werden die rohen Bildbytes aus der API in einen BytesIO-Puffer gelegt, mit Pillow geöffnet und in voller Containerbreite gerendert. Die Bildgenerierung dauert typischerweise 2–4 Sekunden – spürbar schneller als MAI-Image-1 in derselben Umgebung.

Schritt 4: Die App starten

Mit konfigurierter .env und installierten Abhängigkeiten kannst du die App starten.

streamlit run app.py

Streamlit startet einen lokalen Server und öffnet die App automatisch unter http://localhost:8501 im Browser. Du siehst die Drei-Tab-Oberfläche mit MAI-Transcribe-1 als Standard.

Modelle testen

So sahen die Ergebnisse unserer Läufe aus.

Test 1: Transkription bei Störgeräuschen

Ich habe MAI-Transcribe-1 mit einem 7-Sekunden-Clip in bewusst lauter Umgebung und indischem Akzent getestet. Das Modell lieferte in unter 2 Sekunden ein sauberes, akkurates Transkript.

Fazit: Das Ergebnis war bei akzentuierter Sprache überzeugend – genau hier tut sich Whisper-large-v3 oft schwer. Allerdings zeigen per-Sprache-Werte ein anderes Bild: Arabisch liegt z. B. bei 10,1%, Dänisch bei 13,2% – deutlich über dem Spitzenwert. Wenn dein Use Case bestimmte Sprachen oder Akzentverteilungen umfasst, teste mit deinem echten Audio, bevor du das Modell produktiv einsetzt.

Test 2: Emotionssteuerung

Ich habe einen Satz mit 113 Zeichen im Stil „excitement“ mit der Stimme en-us-Jasper:MAI-Voice-1 synthetisiert. Zurück kam eine 6-Sekunden-MP3 in unter 1 Sekunde. Die Emotion war klar hörbar – mit energischerem Tempo und höherer Tonhöhenvarianz.

Fazit: 6 Sekunden Audio in unter 1 Sekunde ist stark. Die SSML-Emotionssteuerung funktioniert, ist aber auf vier Stile begrenzt: neutral, joy, excitement und empathy. Erwarte daher nicht die ganze Bandbreite wie bei der Style-Bibliothek von ElevenLabs.

Test 3: Fotorealismus und Textrendering

Das ist der spannendste Test, weil ich bewusst einen Prompt gewählt habe, der zwei Dinge kombiniert: fotorealistische Szenenkomposition und In-Image-Text. Die meisten Diffusionsmodelle scheitern an mindestens einem davon.

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

Fazit: Der Fotorealismus ist wirklich überzeugend – natürliches Fensterlicht, glaubwürdiger Dampf und realistische Texturen auf Buch und Tasse. Der Text „INFERENCE AT SCALE" wurde korrekt und lesbar gerendert.

Allerdings ist das Textrendering über mehrere Läufe inkonsistent. Bei mehreren ähnlichen Prompts gab es gelegentlich falsch geschriebene oder verstümmelte Wörter. Das ist eine bekannte Schwäche aller aktuellen Diffusionsmodelle – MAI-Image-2 ist besser als die meisten, aber nicht immun. Außerdem liegt die maximale Auflösung derzeit bei 1024×1024 Pixeln. Für die meisten Web- und Content-Zwecke reicht das, aber für Druckqualität oder große Formate brauchst du einen Upscaling-Schritt. Wenn dir Textgenauigkeit im Bild wichtig ist, plane immer einen menschlichen Review ein.

Fazit

Microsofts MAI-Modellfamilie macht insgesamt einen sehr starken Eindruck. Die FLEURS-Werte von MAI-Transcribe-1 sind am objektivsten prüfbar und mit 3,88% durchschnittlicher WER aktuell erstklassig.

MAI-Voice-1 überzeugt bei Tempo und Stimmqualität, ist aber durch Englisch-only und eine begrenzte Emotionspalette eingeschränkt. MAI-Image-2 liefert starke fotorealistische Ergebnisse – mit dem wichtigen Hinweis, dass Texthalluzinationen weiterhin auftreten und im Produktivbetrieb einen menschlichen Check erfordern.

Den vollständigen Code zu diesem Tutorial findest du auf GitHub.