Fish Speech

Clore.ai GPUs पर Fish Speech बहुभाषी TTS और शून्य-शॉट वॉइस क्लोनिंग चलाएँ

Fish Speech एक अत्याधुनिक बहुभाषी टेक्स्ट-टू-स्पीच (TTS) सिस्टम है जिसमें जीरो-शॉट वॉइस क्लोनिंग क्षमताएँ हैं। 15,000 से अधिक GitHub स्टार्स के साथ, यह एक ही मॉडल से अंग्रेजी, चीनी, जापानी, कोरियाई, फ्रेंच, जर्मन, अरबी, स्पेनिश और अधिक का समर्थन करता है। केवल 10–15 सेकंड के संदर्भ ऑडियो का उपयोग करके, Fish Speech किसी भी आवाज़ को असाधारण निष्ठा के साथ क्लोन कर सकता है, जिससे यह ऑडियोबुक उत्पादन, डबिंग, वर्चुअल असिस्टेंट और बड़े पैमाने पर कंटेंट क्रिएशन के लिए आदर्श है।

Fish Speech एक ट्रांसफॉर्मर-आधारित आर्किटेक्चर और VQGAN वोकोडर का उपयोग करता है, जिससे मानक TTS बेंचमार्क्स पर लगभग मानव-समान प्राकृतिकता स्कोर प्राप्त होते हैं। WebUI (Gradio) इसे बिना एक भी कोड लाइन लिखे सुलभ बनाता है, जबकि REST API उत्पादन पाइपलाइनों में सहज एकीकरण सक्षम करता है।

सभी उदाहरण GPU सर्वरों पर चलाए जा सकते हैं जिन्हें के माध्यम से किराये पर लिया जा सकता है CLORE.AI मार्केटप्लेस.

---

सर्वर आवश्यकताएँ

पैरामीटर	न्यूनतम	अनुशंसित
GPU	NVIDIA RTX 3080 (10 GB)	NVIDIA RTX 4090 (24 GB)
VRAM	8 GB	16–24 GB
RAM	16 GB	32 GB
CPU	4 कोर	8+ कोर
डिस्क	20 GB	40 GB
ऑपरेटिंग सिस्टम	Ubuntu 20.04+	Ubuntu 22.04
CUDA	11.8+	12.1+
पोर्ट्स	22, 7860	22, 7860

Fish Speech मध्यम-श्रेणी के GPUs (RTX 3080/3090) पर कुशलतापूर्वक चलता है। बैच इन्फरेंस या कई समवर्ती उपयोगकर्ताओं की सेवा के लिए, RTX 4090 या A100 की सिफारिश की जाती है।

---

CLORE.AI पर त्वरित तैनाती

Fish Speech चलाने का सबसे तेज़ तरीका आधिकारिक Docker इमेज को सीधे Docker Hub से प्राप्त करना है।

1. एक उपयुक्त सर्वर खोजें

जाएँ CLORE.AI मार्केटप्लेस और फ़िल्टर करें:

• VRAM: ≥ 8 GB

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

• डिस्क: ≥ 20 GB

2. अपनी तैनाती कॉन्फ़िगर करें

CLORE.AI ऑर्डर फॉर्म में निम्न सेट करें:

Docker इमेज:

fishaudio/fish-speech:latest

पोर्ट मैपिंग्स:

22   → SSH एक्सेस
7860 → Gradio वेब UI

पर्यावरण चर:

NVIDIA_VISIBLE_DEVICES=all
CUDA_VISIBLE_DEVICES=0

स्टार्टअप कमांड (वैकल्पिक — WebUI ऑटो-स्टार्ट करता है):

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

3. इंटरफ़ेस तक पहुँचें

एक बार डिप्लॉय होने के बाद, अपना ब्राउज़र खोलें और निम्न पर नेविगेट करें:

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

Gradio WebUI लोड होगा और पूरा Fish Speech इंटरफ़ेस उपयोग के लिए तैयार होगा।

---

चरण-दर-चरण सेटअप

चरण 1: अपने सर्वर में SSH करें

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

चरण 2: Docker कंटेनर पुल और चलाएँ

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

चरण 3: GPU एक्सेस सत्यापित करें

docker exec fish-speech nvidia-smi

आपको अपनी GPU सूचीबद्ध दिखाई देनी चाहिए जिसमें उपलब्ध VRAM हो।

चरण 4: मॉडल डाउनलोड जाँचें

Fish Speech पहले रन पर मॉडल वेट्स स्वचालित रूप से डाउनलोड करता है (~3–5 GB)। प्रगति की निगरानी करें:

docker logs -f fish-speech

इंतजार करें जब तक आप नहीं देखते:

Running on local URL:  http://0.0.0.0:7860

चरण 5: WebUI तक पहुँच

अपने ब्राउज़र में नेविगेट करें http://<server-ip>:7860 ।

चरण 6: (वैकल्पिक) API सर्वर सक्षम करें

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

---

उपयोग के उदाहरण

उदाहरण 1: WebUI के माध्यम से बुनियादी टेक्स्ट-टू-स्पीच

1. WebUI पर खोलें http://<server-ip>:7860

2. में टेक्स्ट दर्ज करें "Text" फ़ील्ड:

   Clore.ai में आपका स्वागत है, AI वर्कलोड्स के लिए GPU क्लाउड मार्केटप्लेस।

3. भाषा चुनें: अंग्रेज़ी

4. पर क्लिक करें "Generate"

5. निष्पन्न .wav फ़ाइल

---

उदाहरण 2: ज़ीरो-शॉट वॉइस क्लोनिंग

सिर्फ 10–15 सेकंड के संदर्भ ऑडियो से किसी भी आवाज़ को क्लोन करें:

1. WebUI में, पर जाएँ "Voice Clone" टैब

2. अपनी संदर्भ ऑडियो फ़ाइल अपलोड करें (.wav इमेज जेनरेट करें .mp3, 10–30 सेकंड)

3. संदर्भ ऑडियो का ट्रांसक्रिप्ट दर्ज करें (वैकल्पिक लेकिन गुणवत्ता में सुधार करता है)

4. सिंथेसाइज़ करने के लिए लक्षित टेक्स्ट दर्ज करें

5. पर क्लिक करें "Clone & Generate"

मॉडल आवाज़ लक्षणों का विश्लेषण करेगा और उसी आवाज़ में स्पीच सिंथेसाइज़ करेगा।

---

उदाहरण 3: API-आधारित TTS (Python)

import requests
import base64

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

payload = {
    "text": "Hello, this is a test of Fish Speech running on Clore.ai GPU infrastructure.",
    "reference_id": None,  # Use default voice
    "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 saved to output.wav")
else:
    print(f"Error: {response.status_code} - {response.text}")

---

उदाहरण 4: बहुभाषी TTS

import requests

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

texts = {
    "en": "Clore.ai provides affordable GPU cloud computing for AI researchers.",
    "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"Saved {filename}")

---

उदाहरण 5: ऑडियो फ़ाइलों का बैच प्रोसेसिंग

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)

# रूपांतरित करने के लिए टेक्स्ट का बैच
texts = [
    "Chapter one: The beginning of a new era in artificial intelligence.",
    "Chapter two: How GPU computing transformed machine learning.",
    "Chapter three: The rise of voice synthesis technologies.",
    "Chapter four: Building the future with Clore.ai infrastructure.",
    "Chapter five: Conclusion and next steps.",
]

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"✓ Generated: {output_path}")
    else:
        print(f"✗ Failed chapter {i+1}: {response.status_code}")

print(f"\nAll files saved to {OUTPUT_DIR}")

---

कॉन्फ़िगरेशन

Docker Compose (Production 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]

मुख्य कॉन्फ़िगरेशन विकल्प

विकल्प	डिफ़ॉल्ट	विवरण
--listen	0.0.0.0	सर्वर को बाइंड करने के लिए इंटरफ़ेस
--port	7860	Gradio WebUI के लिए पोर्ट
--compile	false	तेज़ इन्फरेंस के लिए torch.compile सक्षम करें
--device	cuda	उपयोग करने के लिए डिवाइस (cuda, cpu, mps)
--half	true	FP16 हाफ-प्रेसिशन का उपयोग करें (VRAM बचाता है)
--num_samples	1	जेनरेट करने के लिए ऑडियो सैंपल्स की संख्या
--max_new_tokens	1024	जनरेशन के लिए अधिकतम नए टोकन

मॉडल वैरिएंट्स

मॉडल	आकार	भाषाएँ	नोट्स
fish-speech-1.4	~3 GB	8 भाषाएँ	नवीनतम स्थिर रिलीज
fish-speech-1.2-sft	~2.5 GB	8 भाषाएँ	फाइन-ट्यून किया गया संस्करण
fish-speech-1.2	~2.5 GB	8 भाषाएँ	बेस मॉडल

---

प्रदर्शन सुझाव

1. Faster Inference के लिए torch.compile सक्षम करें

# शुरू करते समय --compile फ्लैग जोड़ें
python -m tools.webui --listen 0.0.0.0 --port 7860 --compile

पहला रन धीमा होगा (कम्पाइलेशन में 2–5 मिनट लगते हैं), लेकिन बाद का इन्फरेंस 20–40% तेज़ होगा।

2. हाफ-प्रेसिशन (FP16) का उपयोग करें

FP16 VRAM उपयोग ~50% तक घटाता है न्यूनतम गुणवत्ता हानि के साथ:

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

3. संदर्भ आवाज़ें प्री-लोड करें

बार-बार उपयोग की जाने वाली संदर्भ आवाज़ों को कंटेनर की references निर्देशिका में स्टोर करें ताकि पुन:प्रोसेसिंग से बचा जा सके:

# संदर्भ ऑडियो को कंटेनर में कॉपी करें
docker cp my_voice.wav fish-speech:/workspace/references/my_voice.wav

4. GPU मेमोरी अनुकूलन

# अनुकूल CUDA मेमोरी फ्रैक्शन सेट करें
export PYTORCH_CUDA_ALLOC_CONF=max_split_size_mb:512

# बड़े बैच के बीच GPU कैश साफ़ करें
docker exec fish-speech python -c "import torch; torch.cuda.empty_cache()"

5. बैच साइज ट्यूनिंग

बैच API अनुरोधों के लिए, अनुकूल बैच साइज:

• 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

---

समस्या निवारण

समस्या: कंटेनर शुरू नहीं होगा — CUDA नहीं मिला

# कंटेनर के अंदर NVIDIA ड्राइवर सत्यापित करें
docker exec fish-speech nvidia-smi

# यदि विफल होता है, तो होस्ट ड्राइवर जाँचें
nvidia-smi

# स्पष्ट GPU फ़्लैग के साथ फिर से चलाएँ
docker run --gpus all --rm fishaudio/fish-speech:latest nvidia-smi

समस्या: मेमोरी समाप्त (OOM) त्रुटि

# VRAM उपयोग जाँचें
docker exec fish-speech nvidia-smi

# VRAM उपयोग आधा करने के लिए FP16 का उपयोग करें
# --half फ्लैग के साथ कंटेनर पुनः आरंभ करें
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

समस्या: पोर्ट 7860 सुलभ नहीं है

# जाँचें कि कंटेनर चल रहा है
docker ps | grep fish-speech

# पोर्ट बाइंडिंग जाँचें
docker port fish-speech

# फ़ायरवॉल सत्यापित करें (Clore सर्वर पर)
# सुनिश्चित करें कि पोर्ट 7860 आपके CLORE.AI ऑर्डर कॉन्फ़िगरेशन में मैप किया गया है

समस्या: मॉडल डाउनलोड विफल / धीमा डाउनलोड

# कंटेनर से इंटरनेट कनेक्टिविटी जाँचें
docker exec fish-speech curl -I https://huggingface.co

# मैन्युअली मॉडल प्री-डाउनलोड करें
docker exec fish-speech python -c "
from huggingface_hub import snapshot_download
snapshot_download('fishaudio/fish-speech-1.4')
"

समस्या: ऑडियो गुणवत्ता खराब है

• सुनिश्चित करें कि संदर्भ ऑडियो साफ़ हो (कोई पृष्ठभूमि शोर नहीं, 16kHz+ सैम्पल रेट)

• संदर्भ ऑडियो को 10–30 सेकंड के बीच रखें

• बेहतर संरेखण के लिए संदर्भ ऑडियो का ट्रांसक्रिप्ट प्रदान करें

• को बढ़ाने का प्रयास करें --num_samples कई विकल्प जेनरेट करने के लिए और सबसे अच्छा चुनने के लिए

समस्या: WebUI लोड होता है लेकिन जेनरेशन अटक जाता है

# जेनरेशन के दौरान GPU उपयोगिता जाँचें
docker exec fish-speech watch -n1 nvidia-smi

# त्रुटियों के लिए लॉग जांचें
docker logs fish-speech --tail 50

---

लिंक

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

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

• Official Docs: https://speech.fish.audio

• Hugging Face मॉडल्स: https://huggingface.co/fishaudio/fish-speech-1.4

• CLORE.AI मार्केटप्लेस: https://clore.ai/marketplace

• Discord समुदाय: https://discord.gg/Es5qTB9BcN

---

Clore.ai GPU सिफारिशें

उपयोग केस	सिफारिश की गई GPU	Clore.ai पर अनुमानित लागत
डेवलपमेंट/टेस्टिंग	RTX 3090 (24GB)	~$0.12/gpu/hr
उत्पादन TTS	RTX 4090 (24GB)	~$0.70/gpu/hr
उच्च-थ्रूपुट इन्फरेंस	A100 80GB	~$1.20/gpu/hr

💡 इस गाइड के सभी उदाहरण तैनात किए जा सकते हैं Clore.ai GPU सर्वरों पर। उपलब्ध GPUs ब्राउज़ करें और घंटे के हिसाब से किराए पर लें — कोई प्रतिबद्धता नहीं, पूर्ण रूट एक्सेस।