Fish Speech

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

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

Fish Speech एक transformer-आधारित आर्किटेक्चर और VQGAN vocoder का उपयोग करता है, और मानक 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 Hub से सीधे आधिकारिक Docker इमेज के माध्यम से है।

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

Environment Variables:

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. में टेक्स्ट दर्ज करें "टेक्स्ट" फ़ील्ड में:

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

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

4. क्लिक करें "जनरेट करें"

5. परिणामस्वरूप प्राप्त .wav फ़ाइल

---

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

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

1. WebUI में, जाएँ "वॉइस क्लोन" टैब

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

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

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

5. क्लिक करें "क्लोन करें और जनरेट करें"

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

---

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

import requests
import base64

# Fish Speech API एंडपॉइंट
API_URL = "http://<your-clore-server-ip>:8080/v1/tts"

payload = {
    "text": "नमस्ते, यह Clore.ai GPU इंफ्रास्ट्रक्चर पर चल रहे Fish Speech का एक परीक्षण है।",
    "reference_id": None,  # डिफ़ॉल्ट आवाज़ का उपयोग करें
    "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("ऑडियो output.wav में सहेजा गया")
else:
    print(f"त्रुटि: {response.status_code} - {response.text}")

---

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

import requests

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

texts = {
    "en": "Clore.ai AI शोधकर्ताओं के लिए किफायती GPU क्लाउड कंप्यूटिंग प्रदान करता है।",
    "zh": "Clore.ai AI शोधकर्ताओं के लिए किफायती GPU क्लाउड कंप्यूटिंग प्रदान करता है।",
    "ja": "Clore.ai AI शोधकर्ताओं के लिए किफायती GPU क्लाउड कंप्यूटिंग प्रदान करता है।",
    "ko": "Clore.ai AI शोधकर्ताओं के लिए किफायती GPU क्लाउड कंप्यूटिंग प्रदान करता है।",
    "fr": "Clore.ai AI शोधकर्ताओं के लिए किफायती GPU क्लाउड कंप्यूटिंग प्रदान करता है।",
}

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"सहेजा गया {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 = [
    "अध्याय एक: कृत्रिम बुद्धिमत्ता में एक नए युग की शुरुआत।",
    "अध्याय दो: GPU कंप्यूटिंग ने मशीन लर्निंग को कैसे बदल दिया।",
    "अध्याय तीन: वॉइस सिंथेसिस तकनीकों का उदय।",
    "अध्याय चार: Clore.ai इंफ्रास्ट्रक्चर के साथ भविष्य का निर्माण।",
    "अध्याय पाँच: निष्कर्ष और अगले कदम।",
]

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"✓ उत्पन्न: {output_path}")
    else:
        print(f"✗ अध्याय {i+1} विफल: {response.status_code}")

print(f"\nसभी फ़ाइलें {OUTPUT_DIR} में सहेजी गईं")

---

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

Docker Compose (उत्पादन सेटअप)

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. तेज़ इन्फ़रेंस के लिए 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. संदर्भ आवाज़ों को पहले से लोड करें

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

# संदर्भ ऑडियो को कंटेनर में कॉपी करें
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

समस्या: Out of Memory (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

• डॉकर हब: https://hub.docker.com/r/fishaudio/fish-speech

• आधिकारिक दस्तावेज़: 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.07–0.21/gpu/hr
उत्पादन TTS	RTX 4090 (24GB)	$0.14–0.42/gpu/hr
उच्च-थ्रूपुट इन्फ़रेंस	A100 80GB	bare metal

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