Whisper Transkription

Transkribiere Audio und Video mit OpenAI Whisper auf Clore.ai-GPUs

Transkribiere Audio- und Videodateien mit OpenAIs Whisper auf CLORE.AI-GPUs.

Alle Beispiele können auf GPU-Servern ausgeführt werden, die über CLORE.AI Marketplace.

Serveranforderungen

Parameter	Minimum	Empfohlen
RAM	8GB	16GB+
VRAM	4GB (klein)	10GB+ (large-v3)
Netzwerk	200Mbps	500Mbps+
Startzeit	~1–2 Minuten	-

Was ist Whisper?

OpenAI Whisper ist ein Spracherkennungsmodell, das:

• Audio in 99 Sprachen transkribieren kann

• ins Englische übersetzen kann

• Zeitstempel erzeugen kann

• mit lauter/rauschender Audioaufnahme umgehen kann

Modellgrößen

Modell	VRAM	Geschwindigkeit	Qualität	Hinweise
tiny	1GB	~32x Echtzeit	Basic	Am schnellsten, geringste Genauigkeit
base	1GB	~16x Echtzeit	Gut	Guter Kompromiss für schnelle Aufgaben
small	2GB	~6x Echtzeit	Besser	Empfohlen für die meisten Anwendungsfälle
medium	5GB	~2x Echtzeit	Großartig	Hohe Genauigkeit, moderate Geschwindigkeit
large-v3	10GB	~1x Echtzeit	Am besten	Höchste Genauigkeit
large-v3-turbo	6GB	~8x Echtzeit	Am besten	8x schneller als large-v3, vergleichbare Qualität

💡 Empfehlung: Verwenden Sie large-v3-turbo für das beste Geschwindigkeits-/Qualitätsverhältnis. Es liefert vergleichbare Genauigkeit zu large-v3 bei 8x der Geschwindigkeit mit geringeren VRAM-Anforderungen.

Verwendung von large-v3-turbo

import whisper

# Lade large-v3-turbo (8x schneller als large-v3, vergleichbare Qualität)
model = whisper.load_model("large-v3-turbo", device="cuda")

result = model.transcribe("audio.mp3")
print(result["text"])

Mit Faster-Whisper:

from faster_whisper import WhisperModel

# large-v3-turbo via faster-whisper
model = WhisperModel("deepdml/faster-whisper-large-v3-turbo-ct2", device="cuda", compute_type="float16")
segments, info = model.transcribe("audio.mp3")

for segment in segments:
    print(f"[{segment.start:.2f}s -> {segment.end:.2f}s] {segment.text}")

---

WhisperX: Verbesserte Alternative

Für Wortgenaue Zeitstempel, Sprecher-Diarisation, und bis zu 70x schnellere Verarbeitung, ziehe in Betracht WhisperX:

pip install whisperx

import whisperx

model = whisperx.load_model("large-v3-turbo", device="cuda", compute_type="float16")
audio = whisperx.load_audio("audio.mp3")
result = model.transcribe(audio, batch_size=16)

# Wortgenaue Ausrichtung
model_a, metadata = whisperx.load_align_model(language_code=result["language"], device="cuda")
result = whisperx.align(result["segments"], model_a, metadata, audio, device="cuda")

# result["word_segments"] enthält wortgenaue Zeitstempel

➡️ Siehe das vollständige WhisperX-Handbuch für Sprecher-Diarisation und erweiterte Funktionen.

Schnelle Bereitstellung (empfohlen)

Verwende den vorgefertigten Faster-Whisper-Server für sofortige Bereitstellung:

Docker-Image:

fedirz/faster-whisper-server:latest-cuda

Ports:

22/tcp
8000/http

Kein Befehl erforderlich - Server startet automatisch.

Überprüfen, ob es funktioniert

Nach der Bereitstellung finden Sie Ihre http_pub URL in Meine Bestellungen und testen:

curl https://your-http-pub.clorecloud.net/

# Erwartet: JSON-Antwort mit Serverinformationen

Wenn du HTTP 502 erhältst, warte 1–2 Minuten - der Dienst startet noch.

Transkribieren über API

# Audiodatei transkribieren
curl -X POST https://your-http-pub.clorecloud.net/v1/audio/transcriptions \
  -F "[email protected]" \
  -F "model=Systran/faster-whisper-large-v3" \
  -F "response_format=json"

# Mit Zeitstempeln
curl -X POST https://your-http-pub.clorecloud.net/v1/audio/transcriptions \
  -F "[email protected]" \
  -F "model=Systran/faster-whisper-large-v3" \
  -F "response_format=verbose_json" \
  -F "timestamp_granularities[]=word"

Vollständige API-Referenz (Faster-Whisper-Server)

Endpunkte

Endpunkt	Methode	Beschreibung
/v1/audio/transcriptions	POST	Audio transkribieren (OpenAI-kompatibel)
/v1/audio/translations	POST	Audio ins Englische übersetzen
/v1/models	GET	Alle verfügbaren Modelle auflisten
/v1/models/{model_name}	GET	Spezifische Modellinformationen abrufen
/api/ps	GET	Derzeit geladene Modelle auflisten
/api/ps/{model_name}	GET	Prüfen, ob ein bestimmtes Modell geladen ist
/api/pull/{model_name}	POST	Ein Modell herunterladen und laden
/health	GET	Health-Check-Endpunkt
/docs	GET	Swagger-UI-Dokumentation
/openapi.json	GET	OpenAPI-Spezifikation

Verfügbare Modelle auflisten

curl https://your-http-pub.clorecloud.net/v1/models

Antwort:

{
  "data": [
    {"id": "Systran/faster-whisper-large-v3", "object": "model"},
    {"id": "Systran/faster-whisper-medium", "object": "model"}
  ]
}

Swagger-Dokumentation

Im Browser öffnen für interaktives API-Testen:

https://your-http-pub.clorecloud.net/docs

Transkriptionsoptionen

Parameter	Typ	Beschreibung
file	Datei	Audiodatei zur Transkription
model	String	Zu verwendendes Modell (Standard: Systran/faster-whisper-large-v3)
language	String	Erzwinge eine spezifische Sprache (z. B., en, ja, ru)
response_format	String	json, text, srt, vtt, verbose_json
temperature	Float	Sampling-Temperatur (0.0–1.0)
timestamp_granularities[]	Array	word oder segment für Zeitstempel

Antwortformate

JSON (Standard):

{"text": "Hier transkribierter Text..."}

Ausführliches JSON:

{
  "text": "Vollständige Transkription...",
  "segments": [
    {"start": 0.0, "end": 2.5, "text": "Erstes Segment"},
    {"start": 2.5, "end": 5.0, "text": "Zweites Segment"}
  ],
  "language": "en"
}

SRT:

1
00:00:00,000 --> 00:00:02,500
Erstes Segment

2
00:00:02,500 --> 00:00:05,000
Zweites Segment

Alternative: Manuelle Installation

Wenn du mehr Kontrolle benötigst, setze mit manueller Installation bereit:

Docker-Image:

pytorch/pytorch:2.5.1-cuda12.4-cudnn9-runtime

Ports:

22/tcp

Befehl:

pip install openai-whisper faster-whisper

Manuelle Installation dauert 3–5 Minuten. Das oben genannte vorgefertigte Image wird für schnelleren Start empfohlen.

Grundlegende Nutzung (SSH)

ssh -p <port> root@<proxy>

# Audiodatei transkribieren
whisper audio.mp3 --model large-v3 --device cuda

# Ausgabe in bestimmtes Format
whisper audio.mp3 --model large-v3 --output_format txt

# Sprache angeben
whisper audio.mp3 --model large-v3 --language Japanese

Mit Zeitstempeln transkribieren

whisper audio.mp3 --model large-v3 --word_timestamps True

Audiodateien hochladen

# Einzelne Datei hochladen
scp -P <port> interview.mp3 root@<proxy>:/workspace/

# Ordner hochladen
scp -P <port> -r ./audio_files/ root@<proxy>:/workspace/

Python-API

import whisper

# Modell laden (wird beim ersten Gebrauch heruntergeladen)
model = whisper.load_model("large-v3", device="cuda")

# Transkribieren
result = model.transcribe("audio.mp3")

# Text ausgeben
print(result["text"])

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

Faster-Whisper (empfohlen)

Faster-Whisper ist 4x schneller mit geringerem VRAM-Verbrauch:

pip install faster-whisper

from faster_whisper import WhisperModel

# Modell mit Optimierungen laden
model = WhisperModel("large-v3", device="cuda", compute_type="float16")

# Transkribieren
segments, info = model.transcribe("audio.mp3")

print(f"Erkannte Sprache: {info.language}")
for segment in segments:
    print(f"[{segment.start:.2f}s -> {segment.end:.2f}s] {segment.text}")

Sprachoptionen

from faster_whisper import WhisperModel

model = WhisperModel("large-v3", device="cuda")

# Sprache automatisch erkennen
segments, info = model.transcribe("audio.mp3")
print(f"Sprache: {info.language} ({info.language_probability:.0%})")

# Bestimmte Sprache erzwingen
segments, _ = model.transcribe("audio.mp3", language="ja")

Übersetzung ins Englische

from faster_whisper import WhisperModel

model = WhisperModel("large-v3", device="cuda")
segments, _ = model.transcribe("japanese.mp3", task="translate")

for segment in segments:
    print(segment.text)

CLI:

whisper japanese.mp3 --model large-v3 --task translate

Untertitelgenerierung

SRT-Format

from faster_whisper import WhisperModel

def format_timestamp(seconds):
    hours = int(seconds // 3600)
    minutes = int((seconds % 3600) // 60)
    secs = int(seconds % 60)
    millis = int((seconds - int(seconds)) * 1000)
    return f"{hours:02d}:{minutes:02d}:{secs:02d},{millis:03d}"

model = WhisperModel("large-v3", device="cuda")
segments, _ = model.transcribe("video.mp4")

with open("subtitles.srt", "w") as f:
    for i, segment in enumerate(segments, 1):
        f.write(f"{i}\n")
        f.write(f"{format_timestamp(segment.start)} --> {format_timestamp(segment.end)}\n")
        f.write(f"{segment.text.strip()}\n\n")

VTT-Format

whisper video.mp4 --model large-v3 --output_format vtt

Wortgenaue Zeitstempel

from faster_whisper import WhisperModel

model = WhisperModel("large-v3", device="cuda")

segments, _ = model.transcribe("audio.mp3", word_timestamps=True)

for segment in segments:
    for word in segment.words:
        print(f"[{word.start:.2f}s] {word.word}")

Sprecher-Diarisation

Wer hat was gesagt (erfordert pyannote):

pip install pyannote.audio

from faster_whisper import WhisperModel
from pyannote.audio import Pipeline

# Diarisation
diarization = Pipeline.from_pretrained(
    "pyannote/speaker-diarization-3.1",
    use_auth_token="YOUR_HF_TOKEN"
)
diarization_result = diarization("audio.mp3")

# Transkription
whisper = WhisperModel("large-v3", device="cuda")
segments, _ = whisper.transcribe("audio.mp3")

# Kombinieren
for segment in segments:
    # Finde Sprecher zur Segmentzeit
    speaker = None
    for turn, _, spk in diarization_result.itertracks(yield_label=True):
        if turn.start <= segment.start <= turn.end:
            speaker = spk
            break
    print(f"[{speaker}] {segment.text}")

REST-API-Server

Erstelle eine Transkriptions-API:

from fastapi import FastAPI, UploadFile
from faster_whisper import WhisperModel
import tempfile

app = FastAPI()
model = WhisperModel("large-v3", device="cuda", compute_type="float16")

@app.post("/transcribe")
async def transcribe(file: UploadFile):
    with tempfile.NamedTemporaryFile(delete=False) as tmp:
        tmp.write(await file.read())
        tmp_path = tmp.name

    segments, info = model.transcribe(tmp_path)

    return {
        "language": info.language,
        "text": " ".join([s.text for s in segments]),
        "segments": [
            {"start": s.start, "end": s.end, "text": s.text}
            for s in segments
        ]
    }

# Ausführen: uvicorn server:app --host 0.0.0.0 --port 8000

Leistungsbenchmarks

Modell	GPU	1 Stunde Audio
large-v3	RTX 3090	~5 Min
large-v3	RTX 4090	~3 Min
large-v3	A100	~2 Min
medium	RTX 3090	~2 Min

Speicherplatzsparende Verarbeitung

Für sehr lange Audiodateien:

from faster_whisper import WhisperModel

model = WhisperModel("large-v3", device="cuda", compute_type="int8")

# In Abschnitten verarbeiten
segments, _ = model.transcribe(
    "long_audio.mp3",
    vad_filter=True,  # Stille überspringen
    vad_parameters=dict(min_silence_duration_ms=500)
)

Ergebnisse herunterladen

# Transkripte herunterladen
scp -P <port> -r root@<proxy>:/workspace/transcripts/ ./

# Untertitel herunterladen
scp -P <port> root@<proxy>:/workspace/subtitles.srt ./

Fehlerbehebung

CUDA out of memory

• Verwende ein kleineres Modell (medium statt large)

• Verwenden Sie compute_type="int8" für faster-whisper

• Verarbeite kürzere Audioabschnitte

HTTP 502 auf http_pub-URL

Der Dienst startet noch. Warte 1–2 Minuten und versuche es erneut:

curl https://your-http-pub.clorecloud.net/

Schlechte Genauigkeit

• Verwende ein größeres Modell

• Sprache angeben: --language English

• Erhöhe beam_size für faster-whisper

Langsame Verarbeitung

• Stelle sicher, dass die GPU verwendet wird: nvidia-smi

• Verwende faster-whisper statt des Originals

• Aktiviere VAD, um Stille zu überspringen

Kostenabschätzung

Typische CLORE.AI-Marktplatzpreise:

GPU	VRAM	Preis/Tag	Geeignet für
RTX 3060	12GB	$0.15–0.30	kleine/medium-Modelle
RTX 3090	24GB	$0.30–1.00	large-v3
RTX 4090	24GB	$0.50–2.00	large-v3, schnell
A100	40GB	$1.50–3.00	Batch-Verarbeitung

Preise in USD/Tag. Die Tarife variieren je nach Anbieter — prüfen Sie CLORE.AI Marketplace auf aktuelle Preise.