# F5-TTS

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

## Mieten auf CLORE.AI

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

### Zugriff auf Ihren Server

* Verbindungsdetails finden Sie in **Meine Bestellungen**
* Webschnittstellen: Verwenden Sie 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 Stimmmodellierung (Voice Cloning)
* Mehrsprachige Unterstützung

## 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 12GB | RTX 4080 16GB | RTX 4090 24GB |
| VRAM       | 6GB           | 12GB          | 16GB          |
| CPU        | 4 Kerne       | 8 Kerne       | 16 Kerne      |
| RAM        | 16GB          | 32GB          | 64GB          |
| Speicher   | 20GB SSD      | 50GB NVMe     | 100GB NVMe    |
| Internet   | 100 Mbps      | 500 Mbps      | 1 Gbps        |

## Schnelle Bereitstellung auf CLORE.AI

**Docker-Image:**

```
pytorch/pytorch:2.5.1-cuda12.4-cudnn9-runtime
```

**Ports:**

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

**Befehl:**

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

## Zugriff auf Ihren Dienst

Nach der Bereitstellung finden Sie Ihre `http_pub` URL in **Meine Bestellungen**:

1. Gehen Sie zur **Meine Bestellungen** Seite
2. Klicken Sie auf Ihre Bestellung
3. Finden Sie die `http_pub` URL (z. B., `abc123.clorecloud.net`)

Verwenden Sie `https://IHRE_HTTP_PUB_URL` anstelle von `localhost` in den Beispielen unten.

## 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 Sie erstellen können

### Stimmeninhalte

* Podcast-Produktion
* Hörbucherzählung
* Voice-over für Videos

### Barrierefreiheit

* Screenreader
* Dokumentenleser
* Lernmaterialien

### Interaktive Anwendungen

* Sprachassistenten
* Spiel-NPCs
* Kundendienst-Bots

### Kreative Projekte

* Charakterstimmen
* Hörspiele
* Musikalische Gesangsstimmen

## Grundlegende Verwendung

### Einfaches TTS

```python
from f5_tts import F5TTS

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

# Sprache generieren
audio = tts.generate(
    text="Hello! This is F5-TTS generating natural speech.",
    output_path="output.wav"
)
```

### Stimmenklon

```python
from f5_tts import F5TTS

tts = F5TTS(device="cuda")

# Stimme aus Referenzaudio klonen
audio = tts.generate(
    text="This is my cloned voice speaking new text.",
    ref_audio="reference_voice.wav",
    ref_text="This is the reference text spoken in the audio.",
    output_path="cloned_output.wav"
)
```

## Mehrsprachige Unterstützung

```python
from f5_tts import F5TTS

tts = F5TTS(device="cuda")

# Englisch
tts.generate(
    text="Hello, how are you today?",
    ref_audio="english_speaker.wav",
    output_path="english.wav"
)

# Chinesisch
tts.generate(
    text="你好，今天怎么样？",
    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 = [
    "Welcome to our product demonstration.",
    "Today we'll show you the key features.",
    "Let's start with the main dashboard.",
    "As you can see, the interface is intuitive.",
    "Thank you for watching!"
]

ref_audio = "narrator_voice.wav"
ref_text = "Sample text from the reference audio."
output_dir = "./narration"
os.makedirs(output_dir, exist_ok=True)

for i, text in enumerate(texts):
    print(f"Generating {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 = """
Welcome to this comprehensive guide on machine learning.
In this chapter, we will explore the fundamentals of neural networks.
Neural networks are computing systems inspired by biological neural networks.
They consist of interconnected nodes that process information.
Let's begin with the basic concepts.
"""

# F5-TTS handles long text by splitting into sentences
audio = tts.generate(
    text=long_text,
    ref_audio="narrator.wav",
    output_path="long_narration.wav",
    chunk_size=200  # Characters per chunk
)
```

## 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 to Speak", lines=5),
        gr.Audio(type="filepath", label="Reference Voice"),
        gr.Textbox(label="Reference Text", lines=2)
    ],
    outputs=gr.Audio(label="Generated Speech"),
    title="F5-TTS Voice Cloning",
    description="Clone any voice with F5-TTS on CLORE.AI servers"
)

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      | Generierungszeit | 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.0s             | 12x            |

## Häufige Probleme & Lösungen

### Schlechte Stimmenübereinstimmung

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

**Lösungen:**

* Verwende 5–15 Sekunden klaren Referenzton
* Gib eine genaue Transkription des Referenztexts an
* Vermeide Hintergrundgeräusche in der Referenz
* Stimme und Text sollten dieselbe Sprache haben

### Ausspracheprobleme

**Problem:** Wörter oder Namen werden falsch ausgesprochen

**Lösungen:**

```python

# Verwende phonetische Hinweise für schwierige Wörter
text = "Welcome to CLORE (pronounced KLOR) AI platform."

# Oder verwende SSML-ähnliche Formatierung
text = "The CEO, John Smith (SMIHTH), will speak."
```

### Audioqualitätsprobleme

**Problem:** Ausgabe klingt robotisch oder verzerrt

**Lösungen:**

* Verwende hochwertige Referenzaufnahmen (24 kHz+)
* Reinige die Referenz von Störgeräuschen
* Probiere verschiedene Referenzbeispiele aus
* Erhöhe die Generierungsqualitäts-Einstellungen

### Speicherprobleme

**Problem:** Kein Speicher für lange Texte

**Lösungen:**

```python

# Verarbeite in kleineren Abschnitten
tts.generate(
    text=long_text,
    chunk_size=100,  # Kleinere Abschnitte
    overlap=20  # Sanfte Übergänge
)
```

### Langsame Generierung

**Problem:** Dauert zu lange zu generieren

**Lösungen:**

* Verwende GPU-Inferenz (CUDA)
* Reduziere chunk\_size für schnellere Verarbeitung
* Verwende eine RTX 4090 oder besser
* Aktiviere Halbfeld-Präzision (fp16)

## Fehlerbehebung

### Stimme stimmt nicht mit der Referenz überein

* Verwende 5–15 Sekunden klaren Referenzton
* Transkribiere den Referenztext genau
* Vermeide Hintergrundgeräusche in der Referenz

### Audioqualitätsprobleme

* Verwende Referenzen mit hoher Abtastrate (24 kHz+)
* Reinige die Referenz von Störgeräuschen
* Probiere verschiedene Referenzbeispiele aus

### Langsame Generierung

* Verwende CUDA (nicht CPU)
* Reduziere die Textlänge oder teile sie in Abschnitte
* Verwende kleinere Batch-Größen

### Sprachinkongruenz

* Stimme und Referenzaudio sollten dieselbe Sprache haben
* Einige Sprachen benötigen spezielle Modelle

## Kostenabschätzung

Typische CLORE.AI-Marktplatztarife (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           |

*Preise variieren je nach Anbieter und Nachfrage. Prüfen Sie* [*CLORE.AI Marketplace*](https://clore.ai/marketplace) *auf aktuelle Preise.*

**Geld sparen:**

* Verwenden Sie **Spot** Markt für flexible Workloads (oft 30–50% günstiger)
* Bezahlen mit **CLORE** Token
* Preise bei verschiedenen Anbietern vergleichen

## Nächste Schritte

* [XTTS](https://docs.clore.ai/guides/guides_v2-de/audio-and-stimme/xtts-coqui) - Alternative TTS
* [Bark TTS](https://docs.clore.ai/guides/guides_v2-de/audio-and-stimme/bark-tts) - Expressives TTS
* [SadTalker](https://docs.clore.ai/guides/guides_v2-de/sprechende-kopfe/sadtalker) - Talking Heads