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


---

# Agent Instructions: Querying This Documentation

If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter:

```
GET https://docs.clore.ai/guides/guides_v2-de/audio-and-stimme/whisper-transcription.md?ask=<question>
```

The question should be specific, self-contained, and written in natural language.
The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.