# XTTS (Coqui)

Coqui XTTS का उपयोग करके आवाज़ क्लोनिंग के साथ प्राकृतिक भाषण उत्पन्न करें।

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

## XTTS क्या है?

XTTS (Coqui द्वारा) प्रदान करता है:

* उच्च गुणवत्ता पाठ-से-वॉक
* 6 सेकंड के ऑडियो से आवाज़ क्लोनिंग
* 17 भाषाएँ समर्थित
* भावनात्मक नियंत्रण
* स्ट्रीमिंग समर्थन

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

| मोड            | VRAM | अनुशंसित |
| -------------- | ---- | -------- |
| इनफेरेन्स      | 4GB  | RTX 3060 |
| तेज़ निष्कर्षण | 6GB  | RTX 3080 |
| स्ट्रीमिंग     | 4GB  | RTX 3060 |

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

**Docker इमेज:**

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

**पोर्ट:**

```
22/tcp
8000/http
```

**कमांड:**

```bash
pip install TTS && \
tts-server --model_name tts_models/multilingual/multi-dataset/xtts_v2
```

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

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

1. जाएँ **मेरे ऑर्डर** पृष्ठ
2. अपने ऑर्डर पर क्लिक करें
3. खोजें `http_pub` URL (उदा., `abc123.clorecloud.net`)

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

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

```bash
pip install TTS
```

## मूल उपयोग

### सरल TTS

```python
from TTS.api import TTS

# XTTS v2 लोड करें
tts = TTS("tts_models/multilingual/multi-dataset/xtts_v2").to("cuda")

# स्पीच जेनरेट करें
tts.tts_to_file(
    text="Hello, this is a test of the XTTS text to speech system.",
    file_path="output.wav",
    language="en"
)
```

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

```python
from TTS.api import TTS

tts = TTS("tts_models/multilingual/multi-dataset/xtts_v2").to("cuda")

# संदर्भ ऑडियो से आवाज़ क्लोन करें (6+ सेकंड)
tts.tts_to_file(
    text="This is my cloned voice speaking new text.",
    file_path="cloned_output.wav",
    speaker_wav="reference_voice.wav",
    language="en"
)
```

## एकाधिक भाषाएँ

```python
from TTS.api import TTS

tts = TTS("tts_models/multilingual/multi-dataset/xtts_v2").to("cuda")

# अंग्रेज़ी
tts.tts_to_file(
    text="Hello, how are you today?",
    file_path="english.wav",
    speaker_wav="voice.wav",
    language="en"
)

# स्पेनिश
tts.tts_to_file(
    text="Hola, ¿cómo estás hoy?",
    file_path="spanish.wav",
    speaker_wav="voice.wav",
    language="es"
)

# जर्मन
tts.tts_to_file(
    text="Hallo, wie geht es dir heute?",
    file_path="german.wav",
    speaker_wav="voice.wav",
    language="de"
)

# रूसी
tts.tts_to_file(
    text="Привет, как дела?",
    file_path="russian.wav",
    speaker_wav="voice.wav",
    language="ru"
)
```

### समर्थित भाषाएँ

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

## स्ट्रीमिंग TTS

```python
from TTS.tts.configs.xtts_config import XttsConfig
from TTS.tts.models.xtts import Xtts
import torch
import sounddevice as sd

# मॉडल लोड करें
config = XttsConfig()
config.load_json("path/to/config.json")
model = Xtts.init_from_config(config)
model.load_checkpoint(config, checkpoint_dir="path/to/model")
model.cuda()

# स्पीकर एम्बेडिंग प्राप्त करें
gpt_cond_latent, speaker_embedding = model.get_conditioning_latents(
    audio_path="reference.wav"
)

# स्ट्रीम जनरेशन
chunks = model.inference_stream(
    text="This is a streaming test of the XTTS system.",
    language="en",
    gpt_cond_latent=gpt_cond_latent,
    speaker_embedding=speaker_embedding,
    stream_chunk_size=20
)

# रीयल-टाइम में चलाएँ
for chunk in chunks:
    audio = chunk.cpu().numpy()
    sd.play(audio, samplerate=24000)
    sd.wait()
```

## Gradio इंटरफ़ेस

```python
import gradio as gr
from TTS.api import TTS
import tempfile

tts = TTS("tts_models/multilingual/multi-dataset/xtts_v2").to("cuda")

def generate_speech(text, reference_audio, language):
    with tempfile.NamedTemporaryFile(suffix=".wav", delete=False) as f:
        if reference_audio:
            tts.tts_to_file(
                text=text,
                file_path=f.name,
                speaker_wav=reference_audio,
                language=language
            )
        else:
            tts.tts_to_file(
                text=text,
                file_path=f.name,
                language=language
            )
        return f.name

demo = gr.Interface(
    fn=generate_speech,
    inputs=[
        gr.Textbox(label="Text to speak", lines=5),
        gr.Audio(type="filepath", label="Reference Voice (optional)"),
        gr.Dropdown(
            ["en", "es", "fr", "de", "it", "pt", "ru", "zh-cn", "ja"],
            value="en",
            label="Language"
        )
    ],
    outputs=gr.Audio(label="Generated Speech"),
    title="XTTS Voice Cloning"
)

demo.launch(server_name="0.0.0.0", server_port=7860)
```

## API सर्वर

```python
from fastapi import FastAPI, UploadFile, File, Form
from fastapi.responses import FileResponse
from TTS.api import TTS
import tempfile
import os

app = FastAPI()
tts = TTS("tts_models/multilingual/multi-dataset/xtts_v2").to("cuda")

@app.post("/synthesize")
async def synthesize(
    text: str = Form(...),
    language: str = Form(default="en"),
    speaker: UploadFile = File(default=None)
):
    with tempfile.NamedTemporaryFile(suffix=".wav", delete=False) as out_file:
        if speaker:
            # अपलोड किया गया संदर्भ सहेजें
            with tempfile.NamedTemporaryFile(suffix=".wav", delete=False) as ref_file:
                ref_file.write(await speaker.read())
                ref_path = ref_file.name

            tts.tts_to_file(
                text=text,
                file_path=out_file.name,
                speaker_wav=ref_path,
                language=language
            )
            os.unlink(ref_path)
        else:
            tts.tts_to_file(
                text=text,
                file_path=out_file.name,
                language=language
            )

        return FileResponse(out_file.name, media_type="audio/wav")

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

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

```python
from TTS.api import TTS
import os

tts = TTS("tts_models/multilingual/multi-dataset/xtts_v2").to("cuda")

texts = [
    "हमारे प्लेटफ़ॉर्म में आपका स्वागत है।",
    "कृपया निम्न जानकारी की समीक्षा करें।",
    "आपके ध्यान के लिए धन्यवाद।",
    "आपका दिन शुभ हो!"
]

reference_voice = "speaker.wav"
output_dir = "./audio_files"
os.makedirs(output_dir, exist_ok=True)

for i, text in enumerate(texts):
    output_path = f"{output_dir}/audio_{i:03d}.wav"

    tts.tts_to_file(
        text=text,
        file_path=output_path,
        speaker_wav=reference_voice,
        language="en"
    )

    print(f"Generated: {output_path}")
```

## वॉइस फाइन-ट्यूनिंग

बेहतर आवाज़ क्लोनिंग के लिए:

```python
from TTS.tts.configs.xtts_config import XttsConfig
from TTS.tts.models.xtts import Xtts

config = XttsConfig()
model = Xtts.init_from_config(config)

# बेहतर गुणवत्ता के लिए कई संदर्भ नमूने उपयोग करें
reference_files = [
    "sample1.wav",
    "sample2.wav",
    "sample3.wav"
]

# कई नमूनों से स्पीकर एम्बेडिंग निकालें
gpt_cond_latent, speaker_embedding = model.get_conditioning_latents(
    audio_path=reference_files
)

# औसत एम्बेडिंग के साथ जनरेट करें
output = model.inference(
    text="High quality cloned speech.",
    language="en",
    gpt_cond_latent=gpt_cond_latent,
    speaker_embedding=speaker_embedding
)
```

## ऑडियो प्रीप्रोसेसिंग

```python
import librosa
import soundfile as sf

def prepare_reference(input_path, output_path, target_sr=22050):
    # लोड और रिसैम्पल करें
    audio, sr = librosa.load(input_path, sr=target_sr)

    # मौन को ट्रिम करें
    audio, _ = librosa.effects.trim(audio, top_db=20)

    # सामान्यीकरण
    audio = librosa.util.normalize(audio)

    # सहेजें
    sf.write(output_path, audio, target_sr)

# संदर्भ ऑडियो तैयार करें
prepare_reference("raw_voice.wav", "clean_voice.wav")
```

## प्रदर्शन

| मोड        | GPU      | स्पीड               |
| ---------- | -------- | ------------------- |
| मानक       | RTX 3060 | \~0.5x वास्तविक समय |
| मानक       | RTX 4090 | \~2x वास्तविक समय   |
| स्ट्रीमिंग | RTX 3060 | \~1x वास्तविक समय   |
| स्ट्रीमिंग | RTX 4090 | \~3x वास्तविक समय   |

## गुणवत्ता सुझाव

* 6-15 सेकंड का साफ़ संदर्भ ऑडियो उपयोग करें
* संदर्भ में पृष्ठभूमि शोर से बचें
* टेक्स्ट और संदर्भ की भाषा मिलाएँ
* बेहतर परिणामों के लिए कई संदर्भ नमूने उपयोग करें

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

### खराब आवाज़ गुणवत्ता

* साफ़ संदर्भ ऑडियो
* लंबा संदर्भ (10+ सेकंड)
* बोलने की शैली मिलाएँ

### भाषा उच्चारण गलत

* सही भाषा कोड सुनिश्चित करें
* देशी वक्ता का संदर्भ उपयोग करें

### धीमा जनरेशन

* GPU निष्कर्षण सक्षम करें
* स्ट्रीमिंग मोड उपयोग करें
* प्रति कॉल टेक्स्ट की लंबाई कम करें

## लागत अनुमान

सामान्य 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** टोकन के साथ
* विभिन्न प्रदाताओं के बीच कीमतों की तुलना करें

## अगले कदम

* [Bark TTS](https://docs.clore.ai/guides/guides_v2-hi/audio-and-voice/bark-tts) - भावनात्मक TTS
* [SadTalker](https://docs.clore.ai/guides/guides_v2-hi/talking-heads/sadtalker) - टॉकिंग हेड्स
* [RVC वॉयस क्लोन](https://docs.clore.ai/guides/guides_v2-hi/audio-and-voice/rvc-voice-clone) - वॉयस कन्वर्शन