Speech-to-Text

Einfach erklärt

Speech-to-Text (STT) wandelt gesprochene Sprache automatisch in geschriebenen Text um. Moderne KI-Modelle verstehen dabei Kontext, verschiedene Akzente und sogar Hintergrundgeräusche.

Der Prozess:

Audio Input
    │
    ▼
┌─────────────────┐
│ Preprocessing   │  Rauschunterdrückung, Normalisierung
└────────┬────────┘
         │
         ▼
┌─────────────────┐
│ Feature         │  Mel-Spektrogramm, Audio-Features
│ Extraction      │
└────────┬────────┘
         │
         ▼
┌─────────────────┐
│ Neural Network  │  Transformer (Whisper) oder RNN
│ (ASR Model)     │
└────────┬────────┘
         │
         ▼
┌─────────────────┐
│ Decoding        │  Beam Search, Language Model
└────────┬────────┘
         │
         ▼
    Text Output

Aktuelle Modelle (März 2026):

Modell	Stärken	Latenz	Kosten
Whisper large-v3	Genauigkeit, multilingual	Mittel	Kostenlos (lokal)
Deepgram Nova-2	Echtzeit, niedrige Latenz	Sehr niedrig	$0.0043/min
AssemblyAI	Features (Diarization, Summary)	Niedrig	$0.01/min
Google STT	Viele Sprachen, Streaming	Niedrig	$0.006/min

Technischer Deep Dive

Whisper lokal nutzen

import whisper

# Modell laden (tiny, base, small, medium, large-v3)
model = whisper.load_model("large-v3")

# Transkribieren
result = model.transcribe(
    "audio.mp3",
    language="de",  # Optional, auto-detect möglich
    task="transcribe",  # oder "translate" für Übersetzung
)

print(result["text"])

# Mit Timestamps
for segment in result["segments"]:
    print(f"[{segment['start']:.2f} - {segment['end']:.2f}] {segment['text']}")

Echtzeit-Transkription

import pyaudio
import numpy as np
from faster_whisper import WhisperModel

model = WhisperModel("base", device="cuda")

# Audio-Stream
p = pyaudio.PyAudio()
stream = p.open(
    format=pyaudio.paFloat32,
    channels=1,
    rate=16000,
    input=True,
    frames_per_buffer=1024
)

buffer = []
while True:
    data = stream.read(1024)
    buffer.append(np.frombuffer(data, dtype=np.float32))
    
    # Alle 3 Sekunden transkribieren
    if len(buffer) >= 48:  # 3s bei 16kHz
        audio = np.concatenate(buffer)
        segments, _ = model.transcribe(audio)
        
        for segment in segments:
            print(segment.text, end=" ", flush=True)
        
        buffer = []

Cloud-API (Deepgram)

from deepgram import Deepgram
import asyncio

async def transcribe_file(file_path):
    dg = Deepgram("YOUR_API_KEY")
    
    with open(file_path, "rb") as audio:
        source = {"buffer": audio, "mimetype": "audio/mp3"}
        
        response = await dg.transcription.prerecorded(
            source,
            {
                "model": "nova-2",
                "language": "de",
                "punctuate": True,
                "diarize": True,  # Sprecher unterscheiden
                "smart_format": True,
            }
        )
    
    return response["results"]["channels"][0]["alternatives"][0]["transcript"]

Word Error Rate (WER)

def word_error_rate(reference, hypothesis):
    """
    WER = (Substitutions + Deletions + Insertions) / Reference Words
    """
    import jiwer
    
    wer = jiwer.wer(reference, hypothesis)
    return wer

# Beispiel
reference = "Das ist ein Test für die Spracherkennung"
hypothesis = "Das ist ein Fest für die Spracherkennung"
# WER = 1/8 = 12.5% (ein Wort falsch)

Optimierung

Für bessere Ergebnisse:

Technik	Beschreibung
Preprocessing	Rauschunterdrückung, Normalisierung
Prompt/Hotwords	Erwartete Begriffe vorgeben
Language Hint	Sprache explizit angeben
VAD	Voice Activity Detection für Segmentierung
Post-Processing	Rechtschreibkorrektur, Formatierung

Whisper mit Prompt:

result = model.transcribe(
    "audio.mp3",
    initial_prompt="Transkript eines Meetings über Machine Learning, "
                   "TensorFlow, PyTorch und Transformer-Modelle."
)

Speaker Diarization

# Mit pyannote.audio
from pyannote.audio import Pipeline

pipeline = Pipeline.from_pretrained("pyannote/speaker-diarization-3.1")
diarization = pipeline("audio.wav")

for turn, _, speaker in diarization.itertracks(yield_label=True):
    print(f"[{turn.start:.1f}s - {turn.end:.1f}s] {speaker}")

# Output:
# [0.0s - 2.5s] SPEAKER_00
# [2.5s - 5.0s] SPEAKER_01
# [5.0s - 7.5s] SPEAKER_00