> For the complete documentation index, see [llms.txt](https://docs.clore.ai/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://docs.clore.ai/guides/guides_v2-hi/audio-and-voice/bark-tts.md).

# Bark TTS

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

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)
   * यदि आवश्यक हो तो 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
```

**कमांड:**

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

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

## आवाज़ चयन

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

```python

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

```python

# हँसी
audio = generate_audio("नमस्ते! [laughs] यह तो बहुत मज़ेदार है!")

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

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

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

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

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

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

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

## एपीआई सर्वर

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

### FP16 सक्षम करें

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

from bark import generate_audio
audio = generate_audio("नमस्ते!", 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("शो में आपका स्वागत है!")
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   |

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

### मेमोरी समाप्त

```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) *वर्तमान दरों के लिए।*

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

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

## अगले चरण

* [RVC आवाज़ क्लोनिंग](/guides/guides_v2-hi/audio-and-voice/rvc-voice-clone.md)
* [Whisper प्रतिलेखन](/guides/guides_v2-hi/audio-and-voice/whisper-transcription.md)
* [AudioCraft संगीत](/guides/guides_v2-hi/audio-and-voice/audiocraft-music.md)


---

# Agent Instructions
This documentation is published with GitBook. GitBook is the documentation platform designed so that both humans and AI agents can read, navigate, and reason over technical content effectively. Learn more at gitbook.com.

## Querying This Documentation
If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter, and the optional `goal` query parameter:

```
GET https://docs.clore.ai/guides/guides_v2-hi/audio-and-voice/bark-tts.md?ask=<question>&goal=<endgoal>
```

`ask` is the immediate question: it should be specific, self-contained, and written in natural language.
`goal` is optional and describes the broader end goal you are ultimately trying to accomplish on behalf of the user. GitBook uses it to tailor the answer towards what is most useful for that goal.

The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.