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 gemietet wurden über CLORE.AI-Marktplatz.

Serveranforderungen

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

Was ist Whisper?

OpenAI Whisper ist ein Spracherkennungsmodell, das Folgendes kann:

• Audio in 99 Sprachen transkribieren

• Ins Englische übersetzen

• Zeitstempel erzeugen

• Mit verrauschtem Audio umgehen

Modellgrößen

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

💡 Empfehlung: Verwende large-v3-turbo für den besten Kompromiss zwischen Geschwindigkeit und Qualität. Es liefert eine vergleichbare Genauigkeit wie large-v3 bei 8-facher Geschwindigkeit mit geringeren VRAM-Anforderungen.

Verwendung von large-v3-turbo

import whisper

# large-v3-turbo laden (8x schneller als large-v3, ähnliche 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 über 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: Erweiterte Alternative

Für Zeitstempel auf Wortebene, Sprecherdiarisierung, und bis zu 70x schneller Verarbeitung sollten Sie 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)

# Ausrichtung auf Wortebene
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 Zeitstempel auf Wortebene

➡️ Siehe den vollständigen WhisperX-Leitfaden für Sprecherdiarisierung und erweiterte Funktionen.

Schnellbereitstellung (empfohlen)

Verwenden Sie den vorgefertigten Faster-Whisper-Server für eine sofortige Bereitstellung:

Docker-Image:

fedirz/faster-whisper-server:latest-cuda

Ports:

22/tcp
8000/http

Kein Befehl erforderlich - der Server startet automatisch.

Prüfen, ob es funktioniert

Nach der Bereitstellung findest du deine http_pub URL in Meine Bestellungen und testen:

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

# Erwartet: JSON-Antwort mit Serverinformationen

Wenn Sie HTTP 502 erhalten, warten Sie 1-2 Minuten - der Dienst startet noch.

Per API transkribieren

# Audiodatei transkribieren
curl -X POST https://your-http-pub.clorecloud.net/v1/audio/transcriptions \\
  -F "file=@audio.mp3" \\
  -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 "file=@audio.mp3" \\
  -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 für interaktives API-Testing öffnen:

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

Transkriptionsoptionen

Parameter	Typ	Beschreibung
file	Datei	Zu transkribierende Audiodatei
model	Zeichenkette	Zu verwendendes Modell (Standard: Systran/faster-whisper-large-v3)
language	Zeichenkette	Bestimmte Sprache erzwingen (z. B. en, ja, ru)
response_format	Zeichenkette	json, text, srt, vtt, verbose_json
temperature	Float	Abtasttemperatur (0.0-1.0)
timestamp_granularities[]	Array	word oder segment für Zeitstempel

Antwortformate

JSON (Standard):

{"text": "Transkribierter Text hier..."}

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 Sie mehr Kontrolle benötigen, stellen Sie per manueller Installation bereit:

Docker-Image:

pytorch/pytorch:2.11.0-cuda12.8-cudnn9-runtime

Ports:

22/tcp

Befehl:

pip install openai-whisper faster-whisper

Die manuelle Installation dauert 3-5 Minuten. Das oben vorgestellte vorgefertigte Image wird für einen schnelleren Start empfohlen.

Grundlegende Verwendung (SSH)

ssh -p <port> root@<proxy>

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

# Ausgabe in ein 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 bei der ersten Verwendung 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 und benötigt weniger VRAM:

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

Zeitstempel auf Wortebene

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

Sprecherdiarisierung

Wer was gesagt hat (erfordert pyannote):

pip install pyannote.audio

from faster_whisper import WhisperModel
from pyannote.audio import Pipeline

# Diarisierung
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:
    # Sprecher zur Segmentzeit finden
    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

Erstellen Sie 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

Leistungs-Benchmarks

Modell	GPU	1 Std. Audio
large-v3	RTX 3090	~5 min
large-v3	RTX 4090	~3 min
large-v3	A100	~2 min
medium	RTX 3090	~2 min

Speichereffiziente Verarbeitung

Für sehr lange Audiodateien:

from faster_whisper import WhisperModel

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

# In Chunks 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-Speicher erschöpft

• Kleineres Modell verwenden (medium statt large)

• Verwende compute_type="int8" für faster-whisper

• Kürzere Audiosegmente verarbeiten

HTTP 502 auf der http_pub-URL

Der Dienst startet noch. Warten Sie 1-2 Minuten und versuchen Sie es erneut:

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

Geringe Genauigkeit

• Größeres Modell verwenden

• Sprache angeben: --language English

• beam_size für faster-whisper erhöhen

Langsame Verarbeitung

• Sicherstellen, dass die GPU verwendet wird: nvidia-smi

• Verwenden Sie faster-whisper statt des Originals

• VAD aktivieren, um Stille zu überspringen

Kostenschätzung

Übliche CLORE.AI-Marktplatzpreise:

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

Preise in USD/Tag. Die Tarife variieren je nach Anbieter — prüfen Sie CLORE.AI-Marktplatz für aktuelle Preise.