Transkriptionsqualität optimieren

Update vom 2. November 2026 — Audio-Modelle. Mehrere Modelle in diesem Kurs sind veraltet: tts-1, tts-1-hd und gpt-4o-mini-tts werden am 6. Januar 2027 nicht mehr funktionieren (der angegebene Ersatz ist gpt-realtime-2.1-mini, der laut OpenAI-TTS-Leitfaden nicht durch /v1/audio/speech unterstützt wird: die Migration der Sprachsynthese erfolgt über die Realtime API); gpt-realtime, gpt-4o-realtime und veraltete Audio-Modelle am 20. Januar 2027 (gpt-realtime-2.1, gpt-realtime-2.1-mini, gpt-audio-1.5); whisper-1, gpt-4o-transcribe und /v1/audio/translations am 26. Februar 2027 (gpt-transcribe, gpt-live-transcribe, v1/realtime/translations). Für Voll-Duplex-Stimmen war GPT-Live 1 seit dem 10. September 2026 in der API verfügbar. Lektion aktualisiert am 3. November 2026: Beispiele wurden auf gpt-transcribe (prompt, keywords, languages) umgestellt, das von OpenAI empfohlene Modell; Temperatur 0 ist keine „immer wahrscheinlichste”-Wahl: laut API-Referenz passt das Modell die Temperatur selbst in Schritten an. Quellen: Transkription von Dateien · Transkription erstellen.

Whisper erstellt standardmäßig hervorragende Transkripte, aber mehrere Techniken können die Qualität in schwierigen Fällen erheblich verbessern: Hintergrundgeräusche, regionale Akzente, Fachvokabular und Eigennamen. In dieser Lektion werden fortgeschrittene Parameter und Strategien zur Nachbearbeitung behandelt.

Der prompt-Parameter

Kontext ist Ihr primärer Hebel zur Qualitätssteigerung. Bei gpt-transcribe, dem von OpenAI empfohlenen Modell, werden Kontextinformationen über drei Parameter übermittelt: prompt (ein Kontextsatz in der Sprache des Audios), keywords (zu erkennende Begriffe) und languages (erwartete Sprachen).

# Ohne Kontext besteht die Gefahr, dass Produktnamen falsch transkribiert werden
result = client.audio.transcriptions.create(
    model="gpt-transcribe",
    file=audio_file,
    languages=["fr"],
)

# Mit Kontext und Keywords
result = client.audio.transcriptions.create(
    model="gpt-transcribe",
    file=audio_file,
    languages=["fr"],
    prompt="Technisches Meeting von Corsen AI zu Sprachagenten.",
    keywords=["GPT-6.1 Sol", "Responses API", "Realtime API", "Corsen AI", "Mordehai Attia"],
)

Best Practices für den prompt

Eigennamen auflisten: Personen, Unternehmen, Produkte
Fachjargon einschließen: Akronyme, domänenspezifische Begriffe
Erwarteten Stil angeben: Zeichensetzung, Groß-/Kleinschreibung
Bei whisper-1 erfolgt alles über den einzelnen prompt, begrenzt auf 224 Token: Der Leitfaden gibt an, dass Whisper Anweisungen nicht wie ein Textmodell befolgt, weshalb hier der Vorteil besteht, einfach korrekte Schreibweisen aufzulisten
Bei gpt-transcribe Begriffe in keywords einfügen, einzeln pro Eintrag, ohne <, > oder Zeilenumbrüche, sonst lehnt die API die Anfrage ab

def build_transcription_prompt(context: dict) -> str:
    """Erstellt einen Kontextprompt für die Transkription."""
    parts = []

    if context.get("speakers"):
        parts.append(", ".join(context["speakers"]))

    if context.get("technical_terms"):
        parts.append(", ".join(context["technical_terms"]))

    if context.get("topic"):
        parts.append(context["topic"])

    return ". ".join(parts)

prompt = build_transcription_prompt({
    "speakers": ["Mordehai Attia", "Yoram Halberstam"],
    "technical_terms": ["Realtime API", "WebSocket", "VAD", "PCM16"],
    "topic": "Technisches Meeting zu Sprachagenten"
})

Der temperature-Parameter

Das Endpunkt akzeptiert einen temperature-Wert zwischen 0 und 1, standardmäßig 0. Im Gegensatz zu einem weit verbreiteten Missverständnis bedeutet der Wert 0 nicht „immer das wahrscheinlichste Wort”: laut API-Referenz stützt sich das Modell auf seine Token-Wahrscheinlichkeiten, um die Temperatur selbst in Schritten bis zu bestimmten Schwellenwerten anzupassen.

In der Praxis den Standardwert belassen. Die Dokumentation für gpt-transcribe betont Kontext (prompt, keywords, languages) und nicht die Temperatur; bei whisper-1 kann bei degradiertem Audio im Einzelfall eine leicht höhere Temperatur (z. B. 0,2) getestet werden.

Audio-Vorverarbeitung

Die Qualität des Eingabeaudios ist der entscheidendste Faktor. Investieren Sie in die Vorverarbeitung:

from pydub import AudioSegment
from pydub.effects import normalize, compress_dynamic_range

def preprocess_audio(input_path: str, output_path: str) -> str:
    """Vorbereitet Audio für eine optimale Transkription."""
    audio = AudioSegment.from_file(input_path)

    # 1. In Mono umwandeln (Stereo bringt für Sprache nichts)
    audio = audio.set_channels(1)

    # 2. Auf 16 kHz abtasten (ausreichend für Whisper)
    audio = audio.set_frame_rate(16000)

    # 3. Lautstärke normalisieren
    audio = normalize(audio)

    # 4. Dynamikbereich komprimieren (verringert die Laut-/Leise-Lücke)
    audio = compress_dynamic_range(audio)

    # 5. Als 64 kbps MP3 exportieren
    audio.export(output_path, format="mp3", bitrate="64k")
    return output_path

Rauschunterdrückung

Bei lauten Aufnahmen verbessert die Vorverarbeitung mit noisereduce die Ergebnisse erheblich:

import noisereduce as nr
import soundfile as sf
import numpy as np

def reduce_noise(input_path: str, output_path: str) -> str:
    """Reduziert Hintergrundgeräusche vor der Transkription."""
    data, rate = sf.read(input_path)

    # Adaptive Rauschunterdrückung
    reduced = nr.reduce_noise(
        y=data,
        sr=rate,
        prop_decrease=0.8,  # 80% Rauschreduktion
        stationary=False     # Nicht-stationäres Rauschen (z. B. Café)
    )

    sf.write(output_path, reduced, rate)
    return output_path

Nachbearbeitung der Transkription

Selbst bei guter Vorverarbeitung kann eine rohe Transkription Korrekturen erfordern. Nutzen Sie GPT für die Nachbearbeitung:

async def post_process_transcription(raw_text: str, context: str) -> str:
    """Korrigiert und formatiert eine Whisper-Transkription."""
    response = client.responses.create(
        model="gpt-5.6-luna",
        input=[
            {"role": "system", "content": (
                "Sie sind ein Transkriptionskorrektor. "
                "Korrigieren Sie offensichtliche Whisper-Fehler, ohne die Bedeutung zu ändern. "
                "Fügen Sie fehlende Zeichensetzung hinzu. "
                "Korrigieren Sie die Groß-/Kleinschreibung für Eigennamen und Akronyme. "
                "Fassen Sie nicht zusammen oder formulieren Sie neu."
            )},
            {"role": "user", "content": (
                f"Kontext: {context}\n\n"
                f"Roh-Transkription:\n{raw_text}"
            )}
        ]
    )

    return response.output_text

Komplett-Transkriptions-Pipeline

Fassen Sie alle Schritte zu einer robusten Pipeline zusammen:

async def transcribe_high_quality(
    file_path: str,
    language: str = "fr",
    speakers: list[str] = None,
    technical_terms: list[str] = None
) -> dict:
    """Komplette Pipeline für hochwertige Transkription."""
    # 1. Vorverarbeitung
    processed_path = preprocess_audio(file_path, "/tmp/processed.mp3")

    # 2. Kontext aufbauen: nur besetzte Parameter
    options = {}
    terms = (speakers or []) + (technical_terms or [])
    if terms:
        options["keywords"] = terms

    # 3. Transkribieren
    with open(processed_path, "rb") as f:
        result = client.audio.transcriptions.create(
            model="gpt-transcribe",
            file=f,
            languages=[language],
            **options,
        )

    # 4. Nachbearbeitung
    context = f"Sprache: {language}, Sprecher: {speakers}"
    corrected = await post_process_transcription(result.text, context)

    return {
        "raw_text": result.text,
        "corrected_text": corrected,
        "languages": result.languages,
    }

Kernaussagen

Kontext ist der effektivste Hebel: prompt, keywords und languages bei gpt-transcribe; der einzelne prompt, begrenzt auf 224 Token, bei whisper-1
temperature standardmäßig 0, und bei 0 passt das Modell die Temperatur selbst an, falls nötig: Standardwert belassen
Audio-Vorverarbeitung (Mono, 16 kHz, Normalisierung, Rauschunterdrückung) verbessert die Qualität mehr als jeder API-Parameter
GPT-Nachbearbeitung korrigiert Zeichensetzung, Groß-/Kleinschreibung und verbleibende Fehler
Eine komplette Pipeline kombiniert Vorverarbeitung, kontextbezogenes Prompting und Nachbearbeitung für maximale Qualität