# Bark TTS

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

{% hint style="success" %}
सभी उदाहरण GPU सर्वरों पर चलाए जा सकते हैं जिन्हें द्वारा किराए पर लिया गया है [CLORE.AI मार्केटप्लेस](https://clore.ai/marketplace).
{% endhint %}

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

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

{% hint style="warning" %}
**स्टार्टअप समय:** पहली बार लॉन्च पर Bark मॉडल डाउनलोड होंगे (नेटवर्क स्पीड के अनुसार 3-5 मिनट). इस समय HTTP 502 सामान्य है।
{% endhint %}

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

1. पर जाएँ [CLORE.AI मार्केटप्लेस](https://clore.ai/marketplace)
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
```

**कमांड:**

```bash
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` नीचे दिए उदाहरणों में।

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

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

{% hint style="warning" %}
यदि आपको HTTP 502 मिलता है, तो 3-5 मिनट प्रतीक्षा करें - सेवा मॉडल डाउनलोड कर रही है।
{% endhint %}

## इंस्टॉलेशन

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

## मूल उपयोग

```python
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))
```

## वॉइस चयन

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

```python

# अंग्रेज़ी वक्ता (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 गैर-शाब्दिक ऑडियो उत्पन्न कर सकता है:

```python

# हँसी
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 सेकंड से लंबे टेक्स्ट के लिए:

```python
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)
```

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

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

```python
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)
```

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

```python
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 सर्वर

```python
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
```

### उपयोग

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

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

### सीमित VRAM के लिए

```python
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 सक्षम करें

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

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

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

```python
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   |

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

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

```python

# छोटे मॉडल का उपयोग करें
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 मार्केटप्लेस*](https://clore.ai/marketplace) *वर्तमान दरों के लिए।*

**पैसे बचाएँ:**

* उपयोग करें **स्पॉट** लचीले वर्कलोड के लिए मार्केट (अक्सर 30-50% सस्ता)
* भुगतान करें **CLORE** टोकन के साथ
* विभिन्न प्रदाताओं के बीच कीमतों की तुलना करें

## अगले कदम

* [RVC वॉइस क्लोनिंग](https://docs.clore.ai/guides/guides_v2-hi/audio-and-voice/rvc-voice-clone)
* [Whisper ट्रांसक्रिप्शन](https://docs.clore.ai/guides/guides_v2-hi/audio-and-voice/whisper-transcription)
* [AudioCraft म्यूजिक](https://docs.clore.ai/guides/guides_v2-hi/audio-and-voice/audiocraft-music)