> 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/f5-tts.md).

# F5-TTS

Schnelles und flüssiges Text-to-Speech mit F5-TTS auf Clore.ai-GPUs

Generieren Sie natürliche Sprache mit F5-TTS – einem schnellen und flüssigen TTS-System.

{% 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 %}

## Mieten auf CLORE.AI

1. Besuchen [CLORE.AI-Marktplatz](https://clore.ai/marketplace)
2. Filtern nach GPU-Typ, VRAM und Preis
3. Wähle **On-Demand** (Festpreis) oder **Spot** (Gebotspreis)
4. Konfiguriere deine Bestellung:
   * Docker-Image auswählen
   * Ports festlegen (TCP für SSH, HTTP für Web-UIs)
   * Bei Bedarf Umgebungsvariablen hinzufügen
   * Startbefehl eingeben
5. Zahlung auswählen: **CLORE**, **BTC**, oder **USDT/USDC**
6. Bestellung erstellen und auf die Bereitstellung warten

### Greife auf deinen Server zu

* Verbindungsdetails finden in **Meine Bestellungen**
* Web-Oberflächen: Verwende die HTTP-Port-URL
* SSH: `ssh -p <port> root@<proxy-address>`

## Was ist F5-TTS?

F5-TTS bietet:

* Schnelle Inferenz (schneller als Echtzeit)
* Natürliche Prosodie und Intonation
* Zero-Shot-Stimmenklonierung
* Unterstützung für mehrere Sprachen

## Ressourcen

* **GitHub:** [SWivid/F5-TTS](https://github.com/SWivid/F5-TTS)
* **HuggingFace:** [SWivid/F5-TTS](https://huggingface.co/SWivid/F5-TTS)
* **Paper:** [F5-TTS-Paper](https://arxiv.org/abs/2410.06885)
* **Demo:** [HuggingFace Space](https://huggingface.co/spaces/mrfakename/E2-F5-TTS)

## Empfohlene Hardware

| Komponente | Minimum        | Empfohlen      | Optimal       |
| ---------- | -------------- | -------------- | ------------- |
| GPU        | RTX 3060 12 GB | RTX 4080 16 GB | RTX 4090 24GB |
| VRAM       | 6 GB           | 12 GB          | 16 GB         |
| CPU        | 4 Kerne        | 8 Kerne        | 16 Kerne      |
| RAM        | 16 GB          | 32 GB          | 64 GB         |
| Speicher   | 20GB SSD       | 50 GB NVMe     | 100 GB NVMe   |
| Internet   | 100 Mbit/s     | 500 Mbit/s     | 1 Gbit/s      |

## Schnellbereitstellung auf CLORE.AI

**Docker-Image:**

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

**Ports:**

```
22/tcp
7860/http
```

**Befehl:**

```bash
pip install f5-tts && \
f5-tts-webui
```

## Auf deinen Dienst zugreifen

Nach der Bereitstellung findest du deine `http_pub` URL in **Meine Bestellungen**:

1. Gehe zu **Meine Bestellungen** Seite
2. Klicke auf deine Bestellung
3. Finde die `http_pub` URL (z. B. `abc123.clorecloud.net`)

Verwende `https://YOUR_HTTP_PUB_URL` anstelle von `localhost` in den folgenden Beispielen.

## Installation

```bash
pip install f5-tts

# Oder aus dem Quellcode
git clone https://github.com/SWivid/F5-TTS.git
cd F5-TTS
pip install -e .
```

## Was du erstellen kannst

### Sprachinhalte

* Podcast-Produktion
* Hörbuch-Narration
* Sprachübertragung für Videos

### Barrierefreiheit

* Bildschirmleser
* Dokumentenleser
* Lernmaterialien

### Interaktive Anwendungen

* Sprachassistenten
* NPCs im Spiel
* Kundendienst-Bots

### Kreative Projekte

* Charakterstimmen
* Hörspielproduktionen
* Gesangsstimmen

## Grundlegende Verwendung

### Einfaches TTS

```python
from f5_tts import F5TTS

# Initialisieren
tts = F5TTS(device="cuda")

# Sprache erzeugen
audio = tts.generate(
    text="Hallo! Dies ist F5-TTS, das natürliche Sprache erzeugt.",
    output_path="output.wav"
)
```

### Stimmenklonierung

```python
from f5_tts import F5TTS

tts = F5TTS(device="cuda")

# Stimme aus Referenzaudio klonen
audio = tts.generate(
    text="Dies ist meine geklonte Stimme, die neuen Text spricht.",
    ref_audio="reference_voice.wav",
    ref_text="Dies ist der Referenztext, der im Audio gesprochen wird.",
    output_path="cloned_output.wav"
)
```

## Unterstützung für mehrere Sprachen

```python
from f5_tts import F5TTS

tts = F5TTS(device="cuda")

# Englisch
tts.generate(
    text="Hallo, wie geht es Ihnen heute?",
    ref_audio="english_speaker.wav",
    output_path="english.wav"
)

# Chinesisch
tts.generate(
    你好，今天怎么样？
    ref_audio="chinese_speaker.wav",
    output_path="chinese.wav"
)

# Französisch
tts.generate(
    text="Bonjour, comment allez-vous?",
    ref_audio="french_speaker.wav",
    output_path="french.wav"
)
```

## Batch-Verarbeitung

```python
from f5_tts import F5TTS
import os

tts = F5TTS(device="cuda")

texts = [
    "Willkommen zu unserer Produktdemo.",
    "Heute zeigen wir Ihnen die wichtigsten Funktionen.",
    "Beginnen wir mit dem Haupt-Dashboard.",
    "Wie Sie sehen können, ist die Benutzeroberfläche intuitiv.",
    "Vielen Dank fürs Zuschauen!"
]

ref_audio = "narrator_voice.wav"
ref_text = "Beispieltext aus dem Referenzaudio."
output_dir = "./narration"
os.makedirs(output_dir, exist_ok=True)

for i, text in enumerate(texts):
    print(f"Generiere {i+1}/{len(texts)}: {text[:50]}...")

    tts.generate(
        text=text,
        ref_audio=ref_audio,
        ref_text=ref_text,
        output_path=f"{output_dir}/segment_{i:03d}.wav"
    )
```

## Langform-Audio

```python
from f5_tts import F5TTS

tts = F5TTS(device="cuda")

long_text = """
Willkommen zu diesem umfassenden Leitfaden zum maschinellen Lernen.
In diesem Kapitel werden wir die Grundlagen neuronaler Netze erkunden.
Neuronale Netze sind Computersysteme, die von biologischen neuronalen Netzen inspiriert sind.
Sie bestehen aus miteinander verbundenen Knoten, die Informationen verarbeiten.
Beginnen wir mit den Grundkonzepten.
"""

# F5-TTS behandelt langen Text, indem er in Sätze aufgeteilt wird
audio = tts.generate(
    text=long_text,
    ref_audio="narrator.wav",
    output_path="long_narration.wav",
    chunk_size=200  # Zeichen pro Abschnitt
)
```

## Gradio-Oberfläche

```python
import gradio as gr
from f5_tts import F5TTS
import tempfile

tts = F5TTS(device="cuda")

def generate_speech(text, ref_audio, ref_text):
    with tempfile.NamedTemporaryFile(suffix=".wav", delete=False) as f:
        tts.generate(
            text=text,
            ref_audio=ref_audio,
            ref_text=ref_text,
            output_path=f.name
        )
        return f.name

demo = gr.Interface(
    fn=generate_speech,
    inputs=[
        gr.Textbox(label="Text zum Sprechen", lines=5),
        gr.Audio(type="filepath", label="Referenzstimme"),
        gr.Textbox(label="Referenztext", lines=2)
    ],
    outputs=gr.Audio(label="Generierte Sprache"),
    title="F5-TTS-Stimmenklonierung",
    description="Beliebige Stimme mit F5-TTS auf CLORE.AI-Servern klonen"
)

demo.launch(server_name="0.0.0.0", server_port=7860)
```

## API-Server

```python
from fastapi import FastAPI, UploadFile, File, Form
from fastapi.responses import FileResponse
from f5_tts import F5TTS
import tempfile

app = FastAPI()
tts = F5TTS(device="cuda")

@app.post("/synthesize")
async def synthesize(
    text: str = Form(...),
    ref_audio: UploadFile = File(...),
    ref_text: str = Form(...)
):
    with tempfile.NamedTemporaryFile(suffix=".wav", delete=False) as ref_file:
        ref_file.write(await ref_audio.read())
        ref_path = ref_file.name

    with tempfile.NamedTemporaryFile(suffix=".wav", delete=False) as out_file:
        tts.generate(
            text=text,
            ref_audio=ref_path,
            ref_text=ref_text,
            output_path=out_file.name
        )
        return FileResponse(out_file.name, media_type="audio/wav")

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

## Leistung

| Textlänge    | GPU      | Erzeugungszeit | Echtzeitfaktor |
| ------------ | -------- | -------------- | -------------- |
| 100 Zeichen  | RTX 3090 | 0.5s           | 5x             |
| 100 Zeichen  | RTX 4090 | 0.3s           | 8x             |
| 500 Zeichen  | RTX 4090 | 1.2s           | 10x            |
| 1000 Zeichen | A100     | 2,0 s          | 12x            |

## Häufige Probleme & Lösungen

### Schlechte Übereinstimmung der Stimme

**Problem:** Generierte Stimme stimmt nicht mit der Referenz überein

**Lösungen:**

* Verwenden Sie 5–15 Sekunden klares Referenzaudio
* Geben Sie eine genaue Transkription des Referenztexts an
* Vermeiden Sie Hintergrundgeräusche in der Referenz
* Stimmen Sie die Sprache des Textes und der Referenz ab

### Aussprachprobleme

**Problem:** Spricht Wörter oder Namen falsch aus

**Lösungen:**

```python

# Verwenden Sie phonetische Hinweise für schwierige Wörter
text = "Willkommen auf der CLORE-(ausgesprochen KLOR)-KI-Plattform."

# Oder verwenden Sie eine SSML-ähnliche Formatierung
text = "Der CEO, John Smith (SMIHTH), wird sprechen."
```

### Probleme mit der Audioqualität

**Problem:** Ausgabe klingt roboterhaft oder verzerrt

**Lösungen:**

* Verwenden Sie hochwertiges Referenzaudio (24 kHz+)
* Referenz von Rauschen bereinigen
* Versuchen Sie verschiedene Referenzsamples
* Erhöhen Sie die Einstellungen für die Generierungsqualität

### Speicherprobleme

**Problem:** Nicht genügend Speicher für lange Texte

**Lösungen:**

```python

# In kleinere Abschnitte aufteilen
tts.generate(
    text=long_text,
    chunk_size=100,  # Kleinere Abschnitte
    overlap=20  # Sanfte Übergänge
)
```

### Langsame Generierung

**Problem:** Die Generierung dauert zu lange

**Lösungen:**

* GPU-Inferenz verwenden (CUDA)
* chunk\_size reduzieren für schnellere Verarbeitung
* RTX 4090 oder besser verwenden
* Halbpräzision aktivieren (fp16)

## Fehlerbehebung

### Stimme stimmt nicht mit der Referenz überein

* Verwenden Sie 5–15 Sekunden klares Referenzaudio
* Referenztext genau transkribieren
* Vermeiden Sie Hintergrundgeräusche in der Referenz

### Probleme mit der Audioqualität

* Referenz mit hoher Abtastrate verwenden (24 kHz+)
* Referenz von Rauschen bereinigen
* Versuchen Sie verschiedene Referenzsamples

### Langsame Generierung

* CUDA verwenden (nicht CPU)
* Textlänge reduzieren oder in Abschnitte aufteilen
* Kleinere Batchgrößen verwenden

### Sprachmismatch

* Sprache des Textes an die Sprache des Referenzaudios anpassen
* Einige Sprachen benötigen spezielle Modelle

## Kostenschätzung

Übliche CLORE.AI-Marktplatzpreise (Stand 2024):

| GPU       | Stundensatz | Tagessatz | 4-Stunden-Sitzung |
| --------- | ----------- | --------- | ----------------- |
| RTX 3060  | \~$0.03     | \~$0.70   | \~$0.12           |
| RTX 3090  | \~$0.06     | \~$1.50   | \~$0.25           |
| RTX 4090  | \~$0.10     | \~$2.30   | \~$0.40           |
| A100 40GB | \~$0.17     | \~$4.00   | \~$0.70           |
| A100 80GB | \~$0.25     | \~$6.00   | \~$1.00           |

*Die Preise variieren je nach Anbieter und Nachfrage. Prüfen Sie* [*CLORE.AI-Marktplatz*](https://clore.ai/marketplace) *für aktuelle Preise.*

**Geld sparen:**

* Nutzen Sie den **Spot** Markt für unterbrechbare Arbeit — etwa ein Drittel der Server bietet Spot-Preise unter dem On-Demand-Preis (Median ca. 13 % Rabatt), der Rest ist gleichauf
* Bezahlen Sie mit **CLORE** Tokens
* Vergleichen Sie Preise zwischen verschiedenen Anbietern

## Nächste Schritte

* [XTTS](/guides/guides_v2-de/audio-and-stimme/xtts-coqui.md) - Alternative TTS
* [Bark TTS](/guides/guides_v2-de/audio-and-stimme/bark-tts.md) - Expressives TTS
* [SadTalker](/guides/guides_v2-de/sprechende-kopfe/sadtalker.md) - Sprechende Köpfe


---

# 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/f5-tts.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.