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.

Alle Beispiele können auf GPU-Servern ausgeführt werden, die gemietet wurden über CLORE.AI-Marktplatz.

Mieten auf CLORE.AI

1. Besuchen CLORE.AI-Marktplatz

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

• HuggingFace: SWivid/F5-TTS

• Paper: F5-TTS-Paper

• Demo: HuggingFace Space

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:

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

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

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

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

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

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

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

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

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:

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

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

• Bark TTS - Expressives TTS

• SadTalker - Sprechende Köpfe