> For the complete documentation index, see [llms.txt](https://docs.clore.ai/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://docs.clore.ai/guides/guides_v2-de/audio-and-stimme/whisper-transcription.md).

# Whisper-Transkription

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

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 gemietet wurden über [CLORE.AI-Marktplatz](https://clore.ai/marketplace).
{% endhint %}

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

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

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

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

# 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](/guides/guides_v2-de/audio-and-stimme/whisperx.md) 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:

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

# Erwartet: JSON-Antwort mit Serverinformationen
```

{% hint style="warning" %}
Wenn Sie HTTP 502 erhalten, warten Sie 1-2 Minuten - der Dienst startet noch.
{% endhint %}

### Per API transkribieren

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

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

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

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

{% hint style="info" %}
Die manuelle Installation dauert 3-5 Minuten. Das oben vorgestellte vorgefertigte Image wird für einen schnelleren Start empfohlen.
{% endhint %}

## Grundlegende Verwendung (SSH)

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

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

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

## Zeitstempel auf Wortebene

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

## Sprecherdiarisierung

Wer was gesagt hat (erfordert pyannote):

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

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

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

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

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

```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-Speicher erschöpft**
{% endhint %}

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

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


---

# Agent Instructions
This documentation is published with GitBook. GitBook is the documentation platform designed so that both humans and AI agents can read, navigate, and reason over technical content effectively. Learn more at gitbook.com.

## 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, and the optional `goal` query parameter:

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

`ask` is the immediate question: it should be specific, self-contained, and written in natural language.
`goal` is optional and describes the broader end goal you are ultimately trying to accomplish on behalf of the user. GitBook uses it to tailor the answer towards what is most useful for that goal.

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.