Fish Speech

Führe mehrsprachiges Fish Speech TTS und Zero-Shot-Stimmklonung auf Clore.ai-GPUs aus

Fish Speech ist ein hochmodernes mehrsprachiges Text-to-Speech-(TTS)-System mit Zero-Shot-Stimmenklon-Fähigkeiten. Mit über 15.000 GitHub-Sternen unterstützt es Englisch, Chinesisch, Japanisch, Koreanisch, Französisch, Deutsch, Arabisch, Spanisch und mehr — alles mit einem einzigen Modell. Mit nur 10–15 Sekunden Referenz-Audio kann Fish Speech jede Stimme mit bemerkenswerter Genauigkeit klonen, was es ideal für die Produktion von Hörbüchern, das Dubbing, virtuelle Assistenten und die Erstellung von Inhalten im großen Maßstab macht.

Fish Speech verwendet eine auf Transformern basierende Architektur mit einem VQGAN-Vocoder und erreicht auf standardisierten TTS-Benchmarks Natürlichkeitswerte, die nahezu menschlich sind. Die WebUI (Gradio) macht es ohne eine einzige Zeile Code zugänglich, während die REST-API eine nahtlose Integration in Produktionspipelines ermöglicht.

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

---

Serveranforderungen

Parameter	Minimum	Empfohlen
GPU	NVIDIA RTX 3080 (10 GB)	NVIDIA RTX 4090 (24 GB)
VRAM	8 GB	16–24 GB
RAM	16 GB	32 GB
CPU	4 Kerne	8+ Kerne
Festplatte	20 GB	40 GB
Betriebssystem	Ubuntu 20.04+	Ubuntu 22.04
CUDA	11.8+	12.1+
Ports	22, 7860	22, 7860

Fish Speech läuft effizient auf mittelklasse GPUs (RTX 3080/3090). Für Batch-Inferenz oder die Bereitstellung für mehrere gleichzeitige Nutzer wird eine RTX 4090 oder A100 empfohlen.

---

Schnellbereitstellung auf CLORE.AI

Der schnellste Weg, Fish Speech zum Laufen zu bringen, ist über das offizielle Docker-Image direkt von Docker Hub.

1. Finden Sie einen geeigneten Server

Gehe zu CLORE.AI-Marktplatz und filtern nach:

• VRAM: ≥ 8 GB

• GPU: RTX 3080, 3090, 4080, 4090, A100, H100

• Festplatte: ≥ 20 GB

2. Konfigurieren Sie Ihre Bereitstellung

Im CLORE.AI-Bestellformular legen Sie Folgendes fest:

Docker-Image:

fishaudio/fish-speech:latest

Port-Zuordnungen:

22 → SSH-Zugriff
7860 → Gradio-Weboberfläche

Umgebungsvariablen:

NVIDIA_VISIBLE_DEVICES=all
CUDA_VISIBLE_DEVICES=0

Startbefehl (optional — startet die WebUI automatisch):

python -m tools.webui --listen 0.0.0.0 --port 7860

3. Greifen Sie auf die Oberfläche zu

Sobald die Bereitstellung abgeschlossen ist, öffnen Sie Ihren Browser und navigieren Sie zu:

http://<your-clore-server-ip>:7860

Die Gradio-WebUI wird mit der vollständigen Fish-Speech-Oberfläche geladen und ist einsatzbereit.

---

Schritt-für-Schritt-Einrichtung

Schritt 1: Per SSH auf Ihren Server verbinden

ssh root@<your-clore-server-ip> -p <ssh-port>

Schritt 2: Docker-Container abrufen und starten

docker pull fishaudio/fish-speech:latest

docker run -d \
  --name fish-speech \\
  --gpus all \
  -p 7860:7860 \
  -p 22:22 \\
  -v /workspace/fish-speech:/workspace \\
  -e NVIDIA_VISIBLE_DEVICES=all \\
  fishaudio/fish-speech:latest \\
  python -m tools.webui --listen 0.0.0.0 --port 7860

Schritt 3: GPU-Zugriff überprüfen

docker exec fish-speech nvidia-smi

Sie sollten Ihre GPU mit dem verfügbaren VRAM aufgelistet sehen.

Schritt 4: Modell-Download prüfen

Fish Speech lädt Modellgewichte beim ersten Start automatisch herunter (~3–5 GB). Überwachen Sie den Fortschritt:

docker logs -f fish-speech

Warten Sie, bis Sie Folgendes sehen:

Wird unter lokaler URL ausgeführt:  http://0.0.0.0:7860

Schritt 5: Auf die WebUI zugreifen

Navigieren Sie zu http://<server-ip>:7860 in Ihrem Browser.

Schritt 6: (Optional) API-Server aktivieren

docker exec -d fish-speech \\
  python -m tools.api_server --listen 0.0.0.0 --port 8080

---

Anwendungsbeispiele

Beispiel 1: Einfache Text-to-Speech-Ausgabe über die WebUI

1. Öffnen Sie die WebUI unter http://<server-ip>:7860

2. Geben Sie Text in das "Text" Feld ein:

   Willkommen bei Clore.ai, dem GPU-Cloud-Marktplatz für KI-Workloads.

3. Sprache auswählen: Englisch

4. Klicken Sie auf "Generieren"

5. Laden Sie die resultierende .wav Datei

---

Beispiel 2: Zero-Shot-Stimmenklonung

Klonen Sie jede Stimme mit nur 10–15 Sekunden Referenz-Audio:

1. Navigieren Sie in der WebUI zum "Voice Clone" Tab

2. Laden Sie Ihre Referenz-Audiodatei hoch (.wav oder .mp3, 10–30 Sekunden)

3. Geben Sie das Transkript des Referenz-Audios ein (optional, verbessert aber die Qualität)

4. Geben Sie den Zieltext ein, der synthetisiert werden soll

5. Klicken Sie auf "Klonen & Generieren"

Das Modell analysiert die Stimmeigenschaften und synthetisiert Sprache in dieser Stimme.

---

Beispiel 3: TTS über API (Python)

import requests
import base64

# Fish-Speech-API-Endpunkt
API_URL = "http://<your-clore-server-ip>:8080/v1/tts"

payload = {
    "text": "Hallo, dies ist ein Test von Fish Speech, das auf der GPU-Infrastruktur von Clore.ai läuft.",
    "reference_id": None,  # Standardstimme verwenden
    "format": "wav",
    "streaming": False
}

response = requests.post(API_URL, json=payload)

if response.status_code == 200:
    with open("output.wav", "wb") as f:
        f.write(response.content)
    print("Audio in output.wav gespeichert")
else:
    print(f"Fehler: {response.status_code} - {response.text}")

---

Beispiel 4: Mehrsprachige TTS

import requests

API_URL = "http://<your-clore-server-ip>:8080/v1/tts"

texts = {
    "en": "Clore.ai bietet erschwingliches GPU-Cloud-Computing für KI-Forscher.",
    "zh": "Clore.ai 为 AI 研究人员提供经济实惠的 GPU 云计算服务。",
    "ja": "Clore.aiはAI研究者向けの手頃なGPUクラウドコンピューティングを提供します。",
    "ko": "Clore.ai는 AI 연구자들을 위한 저렴한 GPU 클라우드 컴퓨팅을 제공합니다.",
    "fr": "Clore.ai fournit un calcul GPU cloud abordable pour les chercheurs en IA.",
}

for lang, text in texts.items():
    payload = {"text": text, "format": "wav"}
    response = requests.post(API_URL, json=payload)
    if response.status_code == 200:
        filename = f"output_{lang}.wav"
        with open(filename, "wb") as f:
            f.write(response.content)
        print(f"Gespeichert: {filename}")

---

Beispiel 5: Stapelverarbeitung von Audiodateien

import requests
import os
from pathlib import Path

API_URL = "http://<your-clore-server-ip>:8080/v1/tts"
OUTPUT_DIR = Path("./tts_outputs")
OUTPUT_DIR.mkdir(exist_ok=True)

# Stapel von Texten zum Konvertieren
texts = [
    "Kapitel eins: Der Beginn einer neuen Ära der künstlichen Intelligenz.",
    "Kapitel zwei: Wie GPU-Computing maschinelles Lernen verändert hat.",
    "Kapitel drei: Der Aufstieg von Sprachsynthesetechnologien.",
    "Kapitel vier: Die Zukunft mit der Infrastruktur von Clore.ai aufbauen.",
    "Kapitel fünf: Fazit und nächste Schritte.",
]

for i, text in enumerate(texts):
    payload = {
        "text": text,
        "format": "wav",
        "streaming": False
    }
    response = requests.post(API_URL, json=payload, timeout=60)
    if response.status_code == 200:
        output_path = OUTPUT_DIR / f"chapter_{i+1:02d}.wav"
        with open(output_path, "wb") as f:
            f.write(response.content)
        print(f"✓ Generiert: {output_path}")
    else:
        print(f"✗ Kapitel {i+1} fehlgeschlagen: {response.status_code}")

print(f"\nAlle Dateien wurden in {OUTPUT_DIR} gespeichert")

---

Konfiguration

Docker Compose (Produktions-Setup)

version: '3.8'

services:
  fish-speech:
    image: fishaudio/fish-speech:latest
    container_name: fish-speech
    runtime: nvidia
    environment:
      - NVIDIA_VISIBLE_DEVICES=all
      - CUDA_VISIBLE_DEVICES=0
    ports:
      - "7860:7860"
      - "8080:8080"
    volumes:
      - ./models:/workspace/models
      - ./outputs:/workspace/outputs
      - ./references:/workspace/references
    command: >
      bash -c "python -m tools.webui --listen 0.0.0.0 --port 7860 &
               python -m tools.api_server --listen 0.0.0.0 --port 8080 &
               wait"
    restart: unless-stopped
    deploy:
      resources:
        reservations:
          devices:
            - driver: nvidia
              count: 1
              capabilities: [gpu]

Wichtige Konfigurationsoptionen

Option	Standard	Beschreibung
--listen	0.0.0.0	Schnittstelle, an die der Server gebunden wird
--port	7860	Port für die Gradio-WebUI
--compile	false	torch.compile für schnellere Inferenz aktivieren
--device	cuda	Zu verwendendes Gerät (cuda, cpu, mps)
--half	true	FP16-Halbpräzision verwenden (spart VRAM)
--num_samples	1	Anzahl der zu erzeugenden Audio-Samples
--max_new_tokens	1024	Maximale Anzahl neuer Tokens für die Generierung

Modellvarianten

Modell	Größe	Sprachen	Hinweise
fish-speech-1.4	~3 GB	8 Sprachen	Neueste stabile Version
fish-speech-1.2-sft	~2.5 GB	8 Sprachen	Feinabgestimmte Variante
fish-speech-1.2	~2.5 GB	8 Sprachen	Basismodell

---

Leistungstipps

1. torch.compile für schnellere Inferenz aktivieren

# --compile-Flag beim Start hinzufügen
python -m tools.webui --listen 0.0.0.0 --port 7860 --compile

Der erste Durchlauf wird langsamer sein (die Kompilierung dauert 2–5 Minuten), aber die nachfolgenden Inferenzläufe werden 20–40 % schneller sein.

2. Halbpräzision (FP16) verwenden

FP16 reduziert den VRAM-Verbrauch um ~50 % bei minimalem Qualitätsverlust:

python -m tools.webui --listen 0.0.0.0 --port 7860 --half

3. Referenzstimmen vorladen

Speichern Sie häufig verwendete Referenzstimmen im Referenzverzeichnis des Containers, um eine erneute Verarbeitung zu vermeiden:

# Referenz-Audio in den Container kopieren
docker cp my_voice.wav fish-speech:/workspace/references/my_voice.wav

4. GPU-Speicheroptimierung

# Optimale CUDA-Speicherfraktion festlegen
export PYTORCH_CUDA_ALLOC_CONF=max_split_size_mb:512

# GPU-Cache zwischen großen Batches leeren
docker exec fish-speech python -c "import torch; torch.cuda.empty_cache()"

5. Batch-Größe anpassen

Für Batch-API-Anfragen sind optimale Batch-Größen:

• RTX 3080 (10 GB): batch_size = 1–2

• RTX 3090/4090 (24 GB): batch_size = 4–8

• A100 (40/80 GB): batch_size = 16–32

---

Fehlerbehebung

Problem: Container startet nicht — CUDA nicht gefunden

# NVIDIA-Treiber im Container überprüfen
docker exec fish-speech nvidia-smi

# Wenn es fehlschlägt, Host-Treiber prüfen
nvidia-smi

# Mit expliziten GPU-Flags erneut starten
docker run --gpus all --rm fishaudio/fish-speech:latest nvidia-smi

Problem: Out-of-Memory-(OOM)-Fehler

# VRAM-Nutzung prüfen
docker exec fish-speech nvidia-smi

# FP16 verwenden, um die VRAM-Nutzung zu halbieren
# Container mit --half-Flag neu starten
docker stop fish-speech
docker run -d --name fish-speech --gpus all -p 7860:7860 \\
  fishaudio/fish-speech:latest \\
  python -m tools.webui --listen 0.0.0.0 --port 7860 --half

Problem: Port 7860 nicht erreichbar

# Prüfen, ob der Container läuft
docker ps | grep fish-speech

# Port-Zuordnung prüfen
docker port fish-speech

# Firewall überprüfen (auf dem Clore-Server)
# Stellen Sie sicher, dass Port 7860 in Ihrer CLORE.AI-Bestellkonfiguration zugeordnet ist

Problem: Modell-Download schlägt fehl / langsamer Download

# Internetverbindung vom Container aus prüfen
docker exec fish-speech curl -I https://huggingface.co

# Modelle manuell vorab herunterladen
docker exec fish-speech python -c "
from huggingface_hub import snapshot_download
snapshot_download('fishaudio/fish-speech-1.4')
"

Problem: Die Audioqualität ist schlecht

• Stellen Sie sicher, dass das Referenz-Audio sauber ist (kein Hintergrundrauschen, Abtastrate 16 kHz+)",

• Halten Sie das Referenz-Audio zwischen 10–30 Sekunden

• Geben Sie das Transkript des Referenz-Audios für eine bessere Ausrichtung an

• Versuchen Sie, zu erhöhen --num_samples um mehrere Optionen zu erzeugen und die beste auszuwählen

Problem: WebUI lädt, aber die Generierung hängt

# GPU-Auslastung während der Generierung prüfen
docker exec fish-speech watch -n1 nvidia-smi

# Protokolle auf Fehler prüfen
docker logs fish-speech --tail 50

---

Links

• GitHub: https://github.com/fishaudio/fish-speech

• Docker Hub: https://hub.docker.com/r/fishaudio/fish-speech

• Offizielle Dokumentation: https://speech.fish.audio

• Hugging Face-Modelle: https://huggingface.co/fishaudio/fish-speech-1.4

• CLORE.AI-Marktplatz: https://clore.ai/marketplace

• Discord-Community: https://discord.gg/Es5qTB9BcN

---

GPU-Empfehlungen für Clore.ai

Anwendungsfall	Empfohlene GPU	Geschätzte Kosten bei Clore.ai
Entwicklung/Testen	RTX 3090 (24 GB)	0,07–0,21 $/GPU/Stunde
Produktions-TTS	RTX 4090 (24 GB)	0,14–0,42 $/GPU/Stunde
Hochdurchsatz-Inferenz	A100 80GB	Bare Metal

💡 Alle Beispiele in diesem Leitfaden können bereitgestellt werden auf Clore.ai GPU-Servern. Durchsuchen Sie verfügbare GPUs und mieten Sie stundenweise — keine Verpflichtungen, voller Root-Zugriff.