Bark TTS

Clore.ai पर Bark AI के साथ यथार्थवादी भाषण और ऑडियो जनरेट करें

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)

   • यदि आवश्यक हो तो environment variables जोड़ें

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

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.11.0-cuda12.8-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 = "नमस्ते, यह Bark टेक्स्ट-टू-स्पीच का परीक्षण है।"
audio = generate_audio(text)

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

आवाज़ चयन

अंतर्निहित आवाज़ें

# अंग्रेज़ी वक्ता (0-9)
audio = generate_audio("नमस्ते!", history_prompt="v2/en_speaker_0")
audio = generate_audio("नमस्ते!", history_prompt="v2/en_speaker_3")
audio = generate_audio("नमस्ते!", 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("नमस्ते! [laughs] यह तो बहुत मज़ेदार है!")

# आह भरना
audio = generate_audio("[sighs] मैं आज बहुत थक गया हूँ।")

# हाँफना
audio = generate_audio("[gasps] ओह मेरे भगवान!")

# गला साफ़ करना
audio = generate_audio("[clears throat] अहेम, कृपया ध्यान दें।")

# संगीत के नोट्स
audio = generate_audio("♪ ला ला ला ♪")

लंबे-रूप का ऑडियो

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 = "मैं सामान्य रूप से बोलते समय ऐसा सुनाई देता हूँ।"
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 = [
    "हमारे पॉडकास्ट में आपका स्वागत है।",
    "आज हम कृत्रिम बुद्धिमत्ता पर चर्चा करेंगे।",
    "आइए परिचय से शुरू करें।",
]

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

voice = "v2/en_speaker_6"

for i, text in enumerate(texts):
    print(f"उत्पन्न किया जा रहा है {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)
    )

एपीआई सर्वर

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("नमस्ते दुनिया")

FP16 सक्षम करें

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

from bark import generate_audio
audio = generate_audio("नमस्ते!", 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("शो में आपका स्वागत है!")
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	~5 सेकंड
सामान्य	RTX 4090	~3s
छोटा	RTX 3060	~8s
CPU	-	~60 सेकंड

अन्य 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 मार्केटप्लेस वर्तमान दरों के लिए।

पैसे बचाएँ:

• का उपयोग करें स्पॉट बाधित किए जा सकने वाले कार्य के लिए मार्केट — लगभग एक-तिहाई सर्वरों की स्पॉट कीमत ऑन-डिमांड से कम होती है (मध्य ~13% छूट), बाकी उससे मेल खाते हैं

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

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

अगले चरण

• RVC आवाज़ क्लोनिंग

• Whisper प्रतिलेखन

• AudioCraft संगीत