XTTS (Coqui)

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

Coqui XTTS का उपयोग करके वॉइस क्लोनिंग के साथ प्राकृतिक भाषण उत्पन्न करें.

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

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

विज़िट करें CLORE.AI मार्केटप्लेस
GPU प्रकार, VRAM और कीमत के अनुसार फ़िल्टर करें
चुनें ऑन-डिमांड (स्थिर दर) या स्पॉट (बोली मूल्य)
अपना ऑर्डर कॉन्फ़िगर करें:
- Docker इमेज चुनें
- पोर्ट सेट करें (SSH के लिए TCP, वेब UI के लिए HTTP)
- यदि आवश्यक हो तो environment variables जोड़ें
- स्टार्टअप कमांड दर्ज करें
भुगतान चुनें: CLORE, BTCया USDT/USDC
ऑर्डर बनाएं और डिप्लॉयमेंट की प्रतीक्षा करें

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

कनेक्शन विवरण यहाँ खोजें मेरे ऑर्डर
वेब इंटरफ़ेस: 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.11.0-cuda12.8-cudnn9-runtime

पोर्ट:

22/tcp
8000/http

कमांड:

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

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

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

पर जाएँ मेरे ऑर्डर पेज
अपने ऑर्डर पर क्लिक करें
खोजें http_pub URL (उदा., abc123.clorecloud.net)

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

इंस्टॉलेशन

pip install TTS

मूल उपयोग

सरल TTS

from TTS.api import TTS

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

# भाषण उत्पन्न करें
tts.tts_to_file(
    text="नमस्ते, यह XTTS टेक्स्ट-टू-स्पीच सिस्टम का एक परीक्षण है।",
    file_path="output.wav",
    language="en"
)

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

from TTS.api import TTS

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

# संदर्भ ऑडियो से वॉइस क्लोन करें (6+ सेकंड)
tts.tts_to_file(
    text="यह मेरी क्लोन की हुई आवाज़ नया पाठ बोल रही है।",
    file_path="cloned_output.wav",
    speaker_wav="reference_voice.wav",
    language="en"
)

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

from TTS.api import TTS

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

# अंग्रेज़ी
tts.tts_to_file(
    text="नमस्ते, आज आप कैसे हैं?",
    file_path="english.wav",
    speaker_wav="voice.wav",
    language="en"
)

# स्पैनिश
tts.tts_to_file(
    text="Hola, आप आज कैसे हैं?",
    file_path="spanish.wav",
    speaker_wav="voice.wav",
    language="es"
)

# जर्मन
tts.tts_to_file(
    text="Hallo, आज आप कैसे हैं?",
    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"
)

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

कोड

भाषा

अंग्रेज़ी

स्पेनिश

फ़्रेंच

जर्मन

इतालवी

पुर्तगाली

पोलिश

तुर्की

रूसी

डच

चेक

अरबी

zh-cn

चीनी

जापानी

हंगेरियन

कोरियाई

हिन्दी

स्ट्रीमिंग TTS

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="यह XTTS सिस्टम का एक स्ट्रीमिंग परीक्षण है।",
    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 इंटरफ़ेस

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="बोलने के लिए टेक्स्ट", lines=5),
        gr.Audio(type="filepath", label="संदर्भ आवाज़ (वैकल्पिक)"),
        gr.Dropdown(
            ["en", "es", "fr", "de", "it", "pt", "ru", "zh-cn", "ja"],
            value="en",
            label="भाषा"
        )
    ],
    outputs=gr.Audio(label="जनरेट किया गया भाषण"),
    title="XTTS वॉइस क्लोनिंग"
)

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

एपीआई सर्वर

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

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

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"उत्पन्न हुआ: {output_path}")

वॉइस को फाइन-ट्यून करना

बेहतर वॉइस क्लोनिंग के लिए:

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="उच्च-गुणवत्ता वाला क्लोन किया गया भाषण।",
    language="en",
    gpt_cond_latent=gpt_cond_latent,
    speaker_embedding=speaker_embedding
)

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

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

पैसे बचाएँ:

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

अगले चरण

Bark TTS - अभिव्यंजक TTS
SadTalker - बोलते चेहरे
RVC वॉइस क्लोन - वॉइस कन्वर्ज़न

पिछलाBark TTS

अगलाF5-TTS

अंतिम अपडेट 12 दिन पहले

क्या यह उपयोगी था?