# Whisper-Transkription

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

{% hint style="success" %}
Alle Beispiele können auf GPU-Servern ausgeführt werden, die über [CLORE.AI Marketplace](https://clore.ai/marketplace).
{% endhint %}

## 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

```python
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:

```python
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](https://docs.clore.ai/guides/guides_v2-de/audio-and-stimme/whisperx):

```bash
pip install whisperx
```

```python
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](https://docs.clore.ai/guides/guides_v2-de/audio-and-stimme/whisperx) 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:

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

# Erwartet: JSON-Antwort mit Serverinformationen
```

{% hint style="warning" %}
Wenn du HTTP 502 erhältst, warte 1–2 Minuten - der Dienst startet noch.
{% endhint %}

### Transkribieren über API

```bash
# 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

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

Antwort:

```json
{
  "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):**

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

**Ausführliches JSON:**

```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:**

```bash
pip install openai-whisper faster-whisper
```

{% hint style="info" %}
Manuelle Installation dauert 3–5 Minuten. Das oben genannte vorgefertigte Image wird für schnelleren Start empfohlen.
{% endhint %}

## Grundlegende Nutzung (SSH)

```bash
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

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

## Audiodateien hochladen

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

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

## Python-API

```python
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:

```bash
pip install faster-whisper
```

```python
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

```python
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

```python
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:

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

## Untertitelgenerierung

### SRT-Format

```python
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

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

## Wortgenaue Zeitstempel

```python
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):

```bash
pip install pyannote.audio
```

```python
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:

```python
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:

```python
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

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

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

## Fehlerbehebung

{% hint style="danger" %}
**CUDA out of memory**
{% endhint %}

* 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:

```bash
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*](https://clore.ai/marketplace) *auf aktuelle Preise.*