Bark TTS

Clore.ai पर Bark AI के साथ यथार्थवादी speech और audio उत्पन्न करें

Bark AI के साथ यथार्थवादी भाषण और ऑडियो उत्पन्न करें।

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

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

पैरामीटर	न्यूनतम	अनुशंसित
RAM	8GB	16GB+
VRAM	4GB (छोटा)	8GB+ (सामान्य)
नेटवर्क	200Mbps	500Mbps+
स्टार्टअप समय	3-5 मिनट	-

स्टार्टअप समय: पहली बार लॉन्च पर Bark मॉडल डाउनलोड होंगे (नेटवर्क स्पीड के अनुसार 3-5 मिनट). इस समय HTTP 502 सामान्य है।

CLORE.AI पर किराये पर लेना

1. पर जाएँ CLORE.AI मार्केटप्लेस

2. GPU प्रकार, VRAM, और मूल्य के अनुसार फ़िल्टर करें

3. चुनें ऑन-डिमांड (निश्चित दर) या स्पॉट (बिड प्राइस)

4. अपना ऑर्डर कॉन्फ़िगर करें:

   • Docker इमेज चुनें

   • पोर्ट सेट करें (SSH के लिए TCP, वेब UI के लिए HTTP)

   • यदि आवश्यक हो तो एनवायरनमेंट वेरिएबल जोड़ें

   • स्टार्टअप कमांड दर्ज करें

5. भुगतान चुनें: CLORE, BTC, या USDT/USDC

6. ऑर्डर बनाएं और डिप्लॉयमेंट का इंतज़ार करें

अपने सर्वर तक पहुँचें

• कनेक्शन विवरण में खोजें मेरे ऑर्डर

• वेब इंटरफेस: HTTP पोर्ट URL का उपयोग करें

• SSH: ssh -p <port> root@<proxy-address>

Bark क्या है?

Suno AI का Bark उत्पन्न कर सकता है:

• कई भाषाओं में यथार्थवादी भाषण

• विभिन्न वक्ताओं की आवाज़ें

• गैर-शाब्दिक ध्वनियाँ (हँसी, आह आदि)

• संगीत और ध्वनि प्रभाव

• बहु-भाषी भाषण

आवश्यकताएँ

गुणवत्ता	VRAM	अनुशंसित
छोटी	4GB	RTX 3060
सामान्य	8GB	RTX 3070
उच्च	12GB	RTX 3090

त्वरित तैनाती

Docker इमेज:

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

पोर्ट:

22/tcp
7860/http

कमांड:

pip install git+https://github.com/suno-ai/bark.git gradio scipy && \
python -c "
import gradio as gr
from bark import SAMPLE_RATE, generate_audio, preload_models
import scipy.io.wavfile as wav
import numpy as np
import tempfile

preload_models()

def generate(text, voice):
    audio = generate_audio(text, history_prompt=voice)
    with tempfile.NamedTemporaryFile(suffix='.wav', delete=False) as f:
        wav.write(f.name, SAMPLE_RATE, (audio * 32767).astype(np.int16))
        return f.name

voices = ['v2/en_speaker_0', 'v2/en_speaker_1', 'v2/en_speaker_2', 'v2/en_speaker_3',
          'v2/en_speaker_4', 'v2/en_speaker_5', 'v2/en_speaker_6', 'v2/en_speaker_7',
          'v2/en_speaker_8', 'v2/en_speaker_9']

demo = gr.Interface(fn=generate, inputs=[gr.Textbox(lines=5), gr.Dropdown(voices)],
                   outputs=gr.Audio(), title='Bark TTS')
demo.launch(server_name='0.0.0.0', server_port=7860)
"

अपनी सेवा तक पहुँचना

डिप्लॉयमेंट के बाद, अपना खोजें http_pub URL में मेरे ऑर्डर:

1. जाएँ मेरे ऑर्डर पृष्ठ

2. अपने ऑर्डर पर क्लिक करें

3. खोजें http_pub URL (उदा., abc123.clorecloud.net)

उपयोग करें https://YOUR_HTTP_PUB_URL की बजाय localhost नीचे दिए उदाहरणों में।

जांचें कि यह काम कर रहा है

# जांचें कि Gradio UI सुलभ है या नहीं
curl https://your-http-pub.clorecloud.net/

यदि आपको HTTP 502 मिलता है, तो 3-5 मिनट प्रतीक्षा करें - सेवा मॉडल डाउनलोड कर रही है।

इंस्टॉलेशन

pip install git+https://github.com/suno-ai/bark.git
pip install scipy

मूल उपयोग

from bark import SAMPLE_RATE, generate_audio, preload_models
import scipy.io.wavfile as wav
import numpy as np

# मॉडल पहले रन पर प्रीलोड होते हैं (डाउनलोड)
preload_models()

# ऑडियो उत्पन्न करें
text = "Hello, this is a test of Bark text to speech."
audio = generate_audio(text)

# WAV के रूप में सहेजें
wav.write("output.wav", SAMPLE_RATE, (audio * 32767).astype(np.int16))

वॉइस चयन

इन-बिल्ट आवाज़ें

# अंग्रेज़ी वक्ता (0-9)
audio = generate_audio("Hello!", history_prompt="v2/en_speaker_0")
audio = generate_audio("Hello!", history_prompt="v2/en_speaker_3")
audio = generate_audio("Hello!", history_prompt="v2/en_speaker_9")

# अन्य भाषाएँ
audio = generate_audio("Bonjour!", history_prompt="v2/fr_speaker_0")  # फ़्रेंच
audio = generate_audio("Hallo!", history_prompt="v2/de_speaker_0")    # जर्मन
audio = generate_audio("Hola!", history_prompt="v2/es_speaker_0")     # स्पेनिश
audio = generate_audio("Ciao!", history_prompt="v2/it_speaker_0")     # इतालवी
audio = generate_audio("Olá!", history_prompt="v2/pt_speaker_0")      # पुर्तगाली
audio = generate_audio("Привет!", history_prompt="v2/ru_speaker_0")   # रूसी
audio = generate_audio("こんにちは!", history_prompt="v2/ja_speaker_0") # जापानी
audio = generate_audio("你好!", history_prompt="v2/zh_speaker_0")      # चीनी

उपलब्ध भाषाएँ

भाषा	कोड	वक्ता
अंग्रेज़ी	en	0-9
जर्मन	de	0-9
स्पेनिश	es	0-9
फ़्रेंच	fr	0-9
हिन्दी	hi	0-9
इतालवी	it	0-9
जापानी	ja	0-9
कोरियाई	ko	0-9
पोलिश	pl	0-9
पुर्तगाली	pt	0-9
रूसी	ru	0-9
तुर्की	tr	0-9
चीनी	zh	0-9

गैर-शाब्दिक ध्वनियाँ

Bark गैर-शाब्दिक ऑडियो उत्पन्न कर सकता है:

# हँसी
audio = generate_audio("Hello! [laughs] That's so funny!")

# आह
audio = generate_audio("[sighs] I'm so tired today.")

# साँस फूलना
audio = generate_audio("[gasps] Oh my god!")

# कंठ साफ़ करना
audio = generate_audio("[clears throat] Ahem, attention please.")

# संगीत नोट्स
audio = generate_audio("♪ La la la ♪")

लॉन्ग-फॉर्म ऑडियो

13 सेकंड से लंबे टेक्स्ट के लिए:

from bark import generate_audio
from bark.generation import SAMPLE_RATE
import numpy as np

def generate_long_audio(text, voice="v2/en_speaker_6"):
    # वाक्यों में विभाजित करें
    sentences = text.replace(".", ".|").replace("?", "?|").replace("!", "!|").split("|")
    sentences = [s.strip() for s in sentences if s.strip()]

    audio_segments = []
    for sentence in sentences:
        audio = generate_audio(sentence, history_prompt=voice)
        audio_segments.append(audio)
        # वाक्यों के बीच छोटा विराम जोड़ें
        audio_segments.append(np.zeros(int(0.25 * SAMPLE_RATE)))

    return np.concatenate(audio_segments)

long_text = """
यह एक लंबा टेक्स्ट है जिसे कई खंडों में विभाजित किया जाएगा।
प्रत्येक खंड अलग से उत्पन्न किया जाएगा। फिर उन्हें एक साथ जोड़ा जाएगा।
यह किसी भी लंबाई का ऑडियो उत्पन्न करने की अनुमति देता है।
"""

audio = generate_long_audio(long_text)

वॉइस क्लोनिंग

कस्टम वॉइस प्रॉम्प्ट बनाएं:

from bark.generation import preload_models, generate_text_semantic
from bark.api import semantic_to_waveform
from bark import generate_audio, SAMPLE_RATE
import numpy as np

# विशिष्ट विशेषताओं के साथ जेनरेट करें

# प्रॉम्प्ट में वक्ता का विवरण शामिल हो सकता है

# पहले, एक संदर्भ उत्पन्न करें
voice_prompt = "v2/en_speaker_6"
text = "This is how I sound when I speak normally."
audio = generate_audio(text, history_prompt=voice_prompt)

# कस्टम वॉइस के रूप में सहेजें (सरल उदाहरण)
np.savez("custom_voice.npz", audio=audio)

बैच प्रोसेसिंग

import os
from bark import generate_audio, SAMPLE_RATE
import scipy.io.wavfile as wav
import numpy as np

texts = [
    "Welcome to our podcast.",
    "Today we'll discuss artificial intelligence.",
    "Let's get started with the introduction.",
]

output_dir = "./audio_clips"
os.makedirs(output_dir, exist_ok=True)

voice = "v2/en_speaker_6"

for i, text in enumerate(texts):
    print(f"Generating {i+1}/{len(texts)}")
    audio = generate_audio(text, history_prompt=voice)
    wav.write(
        os.path.join(output_dir, f"clip_{i:03d}.wav"),
        SAMPLE_RATE,
        (audio * 32767).astype(np.int16)
    )

API सर्वर

from fastapi import FastAPI
from fastapi.responses import FileResponse
from bark import generate_audio, preload_models, SAMPLE_RATE
import scipy.io.wavfile as wav
import numpy as np
import tempfile
import os

app = FastAPI()
preload_models()

@app.post("/generate")
async def generate_speech(text: str, voice: str = "v2/en_speaker_6"):
    audio = generate_audio(text, history_prompt=voice)

    with tempfile.NamedTemporaryFile(suffix=".wav", delete=False) as f:
        wav.write(f.name, SAMPLE_RATE, (audio * 32767).astype(np.int16))
        return FileResponse(f.name, media_type="audio/wav")

# चलाएँ: uvicorn server:app --host 0.0.0.0 --port 8000

उपयोग

curl -X POST "http://localhost:8000/generate?text=Hello%20world&voice=v2/en_speaker_6" \
    --output speech.wav

मेमोरी अनुकूलन

सीमित VRAM के लिए

import os

# छोटे मॉडल का उपयोग करें
os.environ["SUNO_USE_SMALL_MODELS"] = "1"

# CPU पर ऑफलोड करें
os.environ["SUNO_OFFLOAD_CPU"] = "1"

from bark import generate_audio
audio = generate_audio("Hello world")

FP16 सक्षम करें

os.environ["SUNO_ENABLE_MPS"] = "0"

from bark import generate_audio
audio = generate_audio("Hello!", history_prompt="v2/en_speaker_6")

अन्य ऑडियो के साथ संयोजन

from pydub import AudioSegment
import numpy as np
from bark import generate_audio, SAMPLE_RATE
import scipy.io.wavfile as wav
import tempfile

def bark_to_pydub(audio_array):
    with tempfile.NamedTemporaryFile(suffix=".wav", delete=False) as f:
        wav.write(f.name, SAMPLE_RATE, (audio_array * 32767).astype(np.int16))
        return AudioSegment.from_wav(f.name)

# स्पीच जेनरेट करें
speech = generate_audio("Welcome to the show!")
speech_audio = bark_to_pydub(speech)

# बैकग्राउंड संगीत लोड करें
music = AudioSegment.from_mp3("background.mp3")

# साथ मिलाएँ
music = music - 20  # संगीत की आवाज़ घटाएँ
combined = speech_audio.overlay(music)
combined.export("output.mp3", format="mp3")

प्रदर्शन

मोड	GPU	समय (10 शब्द)
सामान्य	RTX 3090	~5s
सामान्य	RTX 4090	~3s
छोटी	RTX 3060	~8s
CPU	-	~60s

अन्य TTS के साथ तुलना

फ़ीचर	Bark	Coqui	Piper
गुणवत्ता	सर्वोत्तम	बहुत अच्छा	अच्छा
स्पीड	धीमा	मध्यम	तेज़
भाषाएँ	13+	20+	30+
गैर-शाब्दिक	हां	नहीं	नहीं
VRAM	8GB+	4GB	1GB

समस्याओं का निवारण

आउट ऑफ़ मेमोरी

# छोटे मॉडल का उपयोग करें
os.environ["SUNO_USE_SMALL_MODELS"] = "1"
os.environ["SUNO_OFFLOAD_CPU"] = "1"

धीमा जनरेशन

• GPU का उपयोग करें (CPU नहीं)

• पीढ़ियों के बीच मॉडल लोड रखें

• छोटे सेगमेंट उत्पन्न करें

ऑडियो गुणवत्ता समस्याएँ

• विभिन्न वक्ताओं को आज़माएँ

• लंबे टेक्स्ट को वाक्यों में विभाजित करें

• विशेष वर्णों से बचें

लागत अनुमान

सामान्य CLORE.AI मार्केटप्लेस दरें (2024 के अनुसार):

GPU	घंटात्मक दर	दैनिक दर	4-घंटे सत्र
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

कीमतें प्रदाता और मांग के अनुसार बदलती हैं। जाँच करें CLORE.AI मार्केटप्लेस वर्तमान दरों के लिए।

पैसे बचाएँ:

• उपयोग करें स्पॉट लचीले वर्कलोड के लिए मार्केट (अक्सर 30-50% सस्ता)

• भुगतान करें CLORE टोकन के साथ

• विभिन्न प्रदाताओं के बीच कीमतों की तुलना करें

अगले कदम

• RVC वॉइस क्लोनिंग

• Whisper ट्रांसक्रिप्शन

• AudioCraft म्यूजिक