Was macht Whisper?
Übersicht
Transkribiere Audio mit OpenAIs Whisper – dem hochmodernen Spracherkennungsmodell. Diese Fähigkeit umfasst lokales Whisper (Python), faster-whisper (CTranslate2, 4x schneller), whisper.cpp (CPU-optimiertes C++) und die OpenAI Whisper API. Inklusive Untertitelgenerierung (SRT/VTT/JSON), mehrsprachiger Transkription, Übersetzung ins Englische, Sprecherdiarisierung, Wort-Zeitstempeln und Produktions-Pipeline-Mustern für Podcasts, Meetings und Video-Untertitel.
Anleitung
Schritt 1: Wähle deine Laufzeitumgebung
Option A – OpenAI Whisper (originales Python):
pip install openai-whisper
# Modelle: tiny (39M), base (74M), small (244M), medium (769M), large-v3 (1.5G)
Option B – faster-whisper (empfohlen für lokal, 4x schneller):
pip install faster-whisper
# Verwendet CTranslate2 – INT8-Quantisierung, läuft gut auf der CPU
Option C – whisper.cpp (am besten für CPU, minimale Abhängigkeiten):
git clone https://github.com/ggerganov/whisper.cpp
cd whisper.cpp && make
# Modell herunterladen
bash models/download-ggml-model.sh base.en
Option D – OpenAI API (keine lokale GPU nötig):
pip install openai
export OPENAI_API_KEY="sk-..."
Schritt 2: Basistranskription
faster-whisper (empfohlen):
from faster_whisper import WhisperModel
model = WhisperModel("base", device="cpu", compute_type="int8")
# GPU: model = WhisperModel("large-v3", device="cuda", compute_type="float16")
segments, info = model.transcribe("episode.mp3", beam_size=5)
print(f"Sprache: {info.language} (Wahrscheinlichkeit: {info.language_probability:.2f})")
for segment in segments:
print(f"[{segment.start:.2f}s → {segment.end:.2f}s] {segment.text}")
OpenAI Whisper (original):
import whisper
model = whisper.load_model("base") # tiny, base, small, medium, large-v3
result = model.transcribe("episode.mp3")
print(result["text"])
for segment in result["segments"]:
print(f"[{segment['start']:.1f}s - {segment['end']:.1f}s] {segment['text']}")
whisper.cpp (CLI):
./main -m models/ggml-base.en.bin -f episode.wav -otxt -osrt -ovtt
# Ausgaben: episode.txt, episode.srt, episode.vtt
OpenAI API:
from openai import OpenAI
client = OpenAI()
with open("episode.mp3", "rb") as f:
transcript = client.audio.transcriptions.create(
model="whisper-1",
file=f,
response_format="verbose_json",
timestamp_granularities=["segment", "word"],
)
print(transcript.text)
for segment in transcript.segments:
print(f"[{segment.start:.1f}s] {segment.text}")
Schritt 3: Untertitelgenerierung (SRT/VTT)
SRT mit faster-whisper generieren:
from faster_whisper import WhisperModel
model = WhisperModel("small", device="cpu", compute_type="int8")
segments, info = model.transcribe("episode.mp3", beam_size=5)
def format_timestamp(seconds):
h = int(seconds // 3600)
m = int((seconds % 3600) // 60)
s = int(seconds % 60)
ms = int((seconds % 1) * 1000)
return f"{h:02d}:{m:02d}:{s:02d},{ms:03d}"
with open("episode.srt", "w") as f:
for i, seg in enumerate(segments, 1):
f.write(f"{i}\n")
f.write(f"{format_timestamp(seg.start)} --> {format_timestamp(seg.end)}\n")
f.write(f"{seg.text.strip()}\n\n")
print("episode.srt generiert")
VTT generieren (für HTML5-Video):
with open("episode.vtt", "w") as f:
f.write("WEBVTT\n\n")
for i, seg in enumerate(segments, 1):
start = format_timestamp(seg.start).replace(",", ".")
end = format_timestamp(seg.end).replace(",", ".")
f.write(f"{start} --> {end}\n")
f.write(f"{seg.text.strip()}\n\n")
Wort-Zeitstempel (für Karaoke-ähnliche Untertitel):
segments, info = model.transcribe("episode.mp3", word_timestamps=True)
for segment in segments:
for word in segment.words:
print(f" [{word.start:.2f}s → {word.end:.2f}s] {word.word}")
Schritt 4: Spracherkennung & Übersetzung
# Automatische Spracherkennung
segments, info = model.transcribe("foreign_audio.mp3")
print(f"Erkannt: {info.language} ({info.language_probability:.0%})")
# Bestimmte Sprache erzwingen
segments, info = model.transcribe("german.mp3", language="de")
# Ins Englische übersetzen (beliebige Sprache → Englisch)
segments, info = model.transcribe("german.mp3", task="translate")
for seg in segments:
print(seg.text) # Englische Übersetzung
Unterstützte Sprachen: 99 Sprachen, darunter en, zh, de, es, ru, ko, fr, ja, pt, tr, pl, nl, ar, sv, it, hi und viele mehr.
Schritt 5: Sprecherdiarisierung
Kombiniere Whisper mit pyannote-audio für „Wer hat was gesagt?":
from faster_whisper import WhisperModel
from pyannote.audio import Pipeline
import torch
# Transkribieren
model = WhisperModel("small", device="cpu", compute_type="int8")
segments, info = model.transcribe("meeting.wav", beam_size=5)
whisper_segments = list(segments)
# Diarisieren (erfordert HuggingFace-Token mit pyannote-Zugriff)
diarization = Pipeline.from_pretrained(
"pyannote/speaker-diarization-3.1",
use_auth_token="hf_YOUR_TOKEN"
)
diarization_result = diarization("meeting.wav")
# Zusammenführen: Jedem Whisper-Segment einen Sprecher zuweisen
def get_speaker(start, end, diarization_result):
"""Finde den dominanten Sprecher in einem Zeitbereich."""
speakers = {}
for turn, _, speaker in diarization_result.itertracks(yield_label=True):
overlap_start = max(start, turn.start)
overlap_end = min(end, turn.end)
if overlap_start < overlap_end:
duration = overlap_end - overlap_start
speakers[speaker] = speakers.get(speaker, 0) + duration
return max(speakers, key=speakers.get) if speakers else "Unbekannt"
for seg in whisper_segments:
speaker = get_speaker(seg.start, seg.end, diarization_result)
print(f"[{speaker}] [{seg.start:.1f}s → {seg.end:.1f}s] {seg.text}")
Schritt 6: Batch-Verarbeitung & Pipelines
Alle Episoden in einem Verzeichnis transkribieren:
import os
from pathlib import Path
from faster_whisper import WhisperModel
model = WhisperModel("small", device="cpu", compute_type="int8")
episodes_dir = Path("episodes")
output_dir = Path("transcripts")
output_dir.mkdir(exist_ok=True)
for audio_file in sorted(episodes_dir.glob("*.mp3")):
print(f"Transkribiere: {audio_file.name}")
segments, info = model.transcribe(str(audio_file), beam_size=5)
# Nur Text
txt_path = output_dir / f"{audio_file.stem}.txt"
with open(txt_path, "w") as f:
for seg in segments:
f.write(seg.text.strip() + "\n")
# SRT
srt_path = output_dir / f"{audio_file.stem}.srt"
segments2, _ = model.transcribe(str(audio_file), beam_size=5) # Erneut iterieren
with open(srt_path, "w") as f:
for i, seg in enumerate(segments2, 1):
h, m = divmod(int(seg.start), 3600)
m, s = divmod(m, 60)
ms = int((seg.start % 1) * 1000)
start_ts = f"{h:02d}:{m:02d}:{s:02d},{ms:03d}"
h2, m2 = divmod(int(seg.end), 3600)
m2, s2 = divmod(m2, 60)
ms2 = int((seg.end % 1) * 1000)
end_ts = f"{h2:02d}:{m2:02d}:{s2:02d},{ms2:03d}"
f.write(f"{i}\n{start_ts} --> {end_ts}\n{seg.text.strip()}\n\n")
print(f" → {txt_path}, {srt_path}")
Schritt 7: Modellauswahl-Leitfaden
| Modell | Größe | VRAM | Geschwindigkeit (CPU) | Genauigkeit | Am besten geeignet für |
|---|---|---|---|---|---|
| tiny | 39M | ~1GB | Sehr schnell | Niedrig | Schnelle Entwürfe, Echtzeit |
| base | 74M | ~1GB | Schnell | Mittel | Gute Balance für CPU |
| small | 244M | ~2GB | Mäßig | Gut | Podcasts, klare Audioaufnahmen |
| medium | 769M | ~5GB | Langsam | Sehr gut | Verrauschte Audiodaten, Akzente |
| large-v3 | 1.5G | ~10GB | Sehr langsam | Am besten | Produktionsqualität |
Empfehlungen:
- Nur CPU, Geschwindigkeit zählt:
tinyoderbasemit faster-whisper - Nur CPU, Genauigkeit zählt:
smallmit faster-whisper - GPU verfügbar:
large-v3mit faster-whisper (float16) - Keine lokale Rechenleistung: OpenAI API (
whisper-1)
Beispiele
Beispiel 1: Eine Podcast-Staffel transkribieren und SRT-Untertitel generieren
Benutzereingabe: „Transkribiere alle 20 MP3-Episoden in ./episodes/ und generiere sowohl Nur-Text-Transkripte als auch SRT-Untertiteldateien. Ich habe eine GPU mit 10 GB VRAM."
Der Agent wird:
- faster-whisper per
pip install faster-whisperinstallieren. - Das
large-v3-Modell mitdevice="cuda"undcompute_type="float16"laden, um die GPU zu nutzen. - Ein Ausgabeverzeichnis
./transcripts/erstellen. - Alle
.mp3-Dateien in./episodes/durchlaufen und jede mitbeam_size=5transkribieren. - Für jede Episode sowohl eine
.txt-Datei (Nur-Text) als auch eine.srt-Datei (mit korrekt formatierten Zeitstempeln) schreiben. - Die erkannte Sprache und die gesamte Verarbeitungszeit pro Episode melden.
Beispiel 2: Ein deutsches Interview mit Sprecherlabels ins Englische übersetzen
Benutzereingabe: „Ich habe eine 45-minütige deutsche Interviewaufnahme unter meeting.wav mit zwei Sprechern. Transkribiere sie auf Englisch und markiere, wer was gesagt hat."
Der Agent wird:
- faster-whisper und pyannote-audio installieren (
pip install faster-whisper pyannote.audio). meeting.wavmittask="translate"transkribieren, um englischen Text aus der deutschen Audiodatei zu erhalten.- Die pyannote-Sprecherdiarisierung ausführen, um Sprechersegmente zu identifizieren (erfordert einen HuggingFace-Token mit Zugriff auf das pyannote-Modell).
- Whisper-Segmente mit Diarisierungsergebnissen zusammenführen, indem Zeitbereiche abgeglichen werden, um Sprecherlabels zuzuweisen.
- Ein formatiertes Transkript mit
[Sprecher 1]- und[Sprecher 2]-Labels vor jedem Segment ausgeben.
Richtlinien
- Verwende faster-whisper anstelle des originalen OpenAI Whisper für lokale Transkription; es ist 4x schneller und verbraucht weniger Speicher durch INT8-Quantisierung über CTranslate2.
- Wähle die Modellgröße basierend auf deiner Hardware:
tiny/basefür CPU-Geschwindigkeit,smallfür CPU-Genauigkeit,large-v3für GPU-Produktionsqualität. - Konvertiere Audio immer in WAV oder stelle sicher, dass ffmpeg installiert ist, wenn du mit MP3-/M4A-Eingaben arbeitest; Whisper benötigt ffmpeg zur Dekodierung von Nicht-WAV-Formaten.
- Für die Sprecherdiarisierung erfordert die pyannote-Pipeline ein HuggingFace-Zugriffstoken mit akzeptierten Modellbedingungen; richte dies ein, bevor du eine Transkription mit mehreren Sprechern versuchst.
- Verwende beim Generieren von SRT-Dateien
beam_size=5für genauere Segmentgrenzen; die standardmäßige Greedy-Decodierung kann schlecht getimte Untertitelbrüche erzeugen.