Voxtral TTS

Mistral का ओपन-वेट टेक्स्ट-टू-स्पीच मॉडल: 4B पैरामीटर, 9 भाषाएँ, ज़ीरो-शॉट वॉइस क्लोनिंग, केवल 3 GB VRAM.

विशेष विवरण

मान

डेवलपर

Mistral AI

पैरामीटर

4 अरब

आर्किटेक्चर

केवल-डिकोडर TTS

भाषाएँ

9 (अंग्रेज़ी, फ़्रेंच, जर्मन, स्पेनिश, हिंदी, अरबी, पुर्तगाली, इतालवी, जापानी)

लाइसेंस

Apache 2.0 (ओपन वेट्स)

VRAM

लगभग 3 GB (FP16)

लेटेंसी

10-सेकंड के आउटपुट के लिए 70 ms

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

3-सेकंड के संदर्भ से ज़ीरो-शॉट

रिलीज़

26 मार्च, 2026

Voxtral TTS क्यों?

Voxtral TTS, ElevenLabs और OpenAI TTS के लिए Mistral का ओपन-वेट जवाब है। Clore.ai उपयोगकर्ताओं के लिए प्रमुख फायदे:

किसी भी GPU पर चलता है — केवल 3 GB VRAM का मतलब है कि RTX 3060 भी बिल्कुल ठीक चलता है
कोई API शुल्क नहीं — स्व-होस्टेड = शून्य सीमांत लागत पर असीमित सिंथेसिस
डेटा गोपनीयता — ऑडियो कभी भी आपके मशीन से बाहर नहीं जाता
ज़ीरो-शॉट क्लोनिंग — 3 सेकंड के संदर्भ ऑडियो से किसी भी आवाज़ को क्लोन करें
मूल रूप से 9 भाषाएँ — जिसमें हिंदी और अरबी शामिल हैं, जो अक्सर प्रतिस्पर्धियों में नहीं मिलतीं
रीयल-टाइम गति — RTX 4070+ पर RTF 0.1–0.2× (10-सेकंड क्लिप 1–2 सेकंड में)

Clore.ai पर GPU आवश्यकताएँ

GPU

VRAM

प्रदर्शन

Clore.ai मूल्य

RTX 3060 12GB

12 GB

✅ अच्छा — 3–4× रीयल-टाइम

$0.03–0.07/घंटा से

RTX 3090 24GB

24 GB

✅ बढ़िया — बैच प्रोसेसिंग

$0.07–0.21/घंटा से

RTX 4070 12GB

12 GB

✅ उत्कृष्ट — 5–10× रीयल-टाइम

$0.04–0.20/घंटा से

RTX 4090 24GB

24 GB

✅ अत्यधिक — सब-सेकंड लेटेंसी

$0.14–0.42/घंटा से

सिफारिश: एक RTX 3060 12GB (Clore.ai पर $0.03–0.07/घंटा) अधिकांश उपयोग मामलों के लिए सबसे उपयुक्त है। Voxtral को केवल 3 GB VRAM चाहिए, इसलिए आप इसे अन्य मॉडलों के साथ चला सकते हैं.

Clore.ai पर त्वरित शुरुआत

चरण 1: GPU सर्वर किराए पर लें

पर जाएँ Clore.ai मार्केटप्लेस
8+ GB VRAM वाले किसी भी GPU को फ़िल्टर करें
चुनें एक Docker डिप्लॉयमेंट
इमेज का उपयोग करें: pytorch/pytorch:2.11.0-cuda12.8-cudnn9-devel

चरण 2: निर्भरताएँ इंस्टॉल करें

# SSH या Jupyter टर्मिनल के माध्यम से कनेक्ट करें
pip install torch torchaudio transformers accelerate

# Voxtral TTS पैकेज इंस्टॉल करें
pip install voxtral-tts

# या सीधे HuggingFace का उपयोग करें
pip install huggingface_hub
huggingface-cli download mistralai/Voxtral-TTS --local-dir ./voxtral-tts

चरण 3: बुनियादी टेक्स्ट-टू-स्पीच

from voxtral import VoxtralTTS

# मॉडल आरंभ करें (वज़न अपने आप डाउनलोड होंगे ~6 GB)
model = VoxtralTTS.from_pretrained("mistralai/Voxtral-TTS")
model.to("cuda")

# बुनियादी सिंथेसिस
audio = model.synthesize(
    text="Clore.ai में आपका स्वागत है — विकेंद्रीकृत GPU मार्केटप्लेस।",
    language="en"
)
audio.save("output.wav")
print(f"{audio.duration:.1f}s ऑडियो उत्पन्न हुआ")

चरण 4: ज़ीरो-शॉट वॉइस क्लोनिंग

# 3-सेकंड के संदर्भ से आवाज़ क्लोन करें
audio = model.synthesize(
    text="यह मेरी क्लोन की हुई आवाज़ है, जो GPU कंप्यूटिंग के बारे में बोल रही है।",
    reference_audio="reference_speaker.wav",  # 3+ सेकंड
    language="en"
)
audio.save("cloned_output.wav")

चरण 5: बहुभाषी सिंथेसिस

# समर्थित 9 भाषाओं में सिंथेसाइज़ करें
languages = {
    "en": "नमस्ते, यह Voxtral अंग्रेज़ी में बोल रहा है।",
    "fr": "Bonjour, c'est Voxtral qui parle en français.",
    "de": "Hallo, hier spricht Voxtral auf Deutsch.",
    "es": "Hola, Voxtral hablando en español.",
    "hi": "नमस्ते, यह Voxtral हिंदी में बोल रहा है।",
    "ar": "مرحبا، هذا Voxtral يتحدث بالعربية.",
    "pt": "Olá, aqui é o Voxtral falando em português.",
    "it": "Ciao, qui parla Voxtral in italiano.",
    "ja": "こんにちは、Voxtralが日本語で話しています。",
}

for lang, text in languages.items():
    audio = model.synthesize(text=text, language=lang)
    audio.save(f"voxtral_{lang}.wav")
    print(f"[{lang}] {audio.duration:.1f}s उत्पन्न हुआ")

प्रोडक्शन API सर्वर

अपने अनुप्रयोगों में एकीकरण के लिए Voxtral को REST API के रूप में डिप्लॉय करें:

# server.py — Voxtral TTS के लिए FastAPI रैपर
from fastapi import FastAPI, UploadFile, File
from fastapi.responses import StreamingResponse
from voxtral import VoxtralTTS
import io
import soundfile as sf

app = FastAPI(title="Voxtral TTS API")
model = VoxtralTTS.from_pretrained("mistralai/Voxtral-TTS").to("cuda")

@app.post("/synthesize")
async def synthesize(
    text: str,
    language: str = "en",
    reference: UploadFile = File(None)
):
    kwargs = {"text": text, "language": language}
    if reference:
        ref_bytes = await reference.read()
        kwargs["reference_audio"] = ref_bytes
    
    audio = model.synthesize(**kwargs)
    
    # WAV स्ट्रीम के रूप में लौटाएँ
    buffer = io.BytesIO()
    sf.write(buffer, audio.numpy(), samplerate=24000, format="WAV")
    buffer.seek(0)
    
    return StreamingResponse(buffer, media_type="audio/wav")

@app.get("/health")
async def health():
    return {"status": "ठीक", "model": "voxtral-tts", "languages": 9}

# API सर्वर चलाएँ
pip install fastapi uvicorn python-multipart soundfile
uvicorn server:app --host 0.0.0.0 --port 8000

# इसे परीक्षण करें
curl -X POST "http://localhost:8000/synthesize?text=Hello%20world&language=en" \
  --output hello.wav

Docker डिप्लॉयमेंट

FROM pytorch/pytorch:2.11.0-cuda12.8-cudnn9-devel

WORKDIR /app
RUN pip install voxtral-tts fastapi uvicorn python-multipart soundfile

# मॉडल वज़न पहले से डाउनलोड करें
RUN python -c "from voxtral import VoxtralTTS; VoxtralTTS.from_pretrained('mistralai/Voxtral-TTS')"

COPY server.py .
EXPOSE 8000
CMD ["uvicorn", "server:app", "--host", "0.0.0.0", "--port", "8000"]

# बिल्ड और रन करें
docker build -t voxtral-tts-api .
docker run --gpus all -p 8000:8000 voxtral-tts-api

Voxtral बनाम अन्य TTS मॉडल

विशेषता

Voxtral TTS

ElevenLabs

Qwen3-TTS

Kokoro TTS

Fish Speech

ओपन वेट्स

✅ Apache 2.0

❌ केवल API

✅

VRAM

3 GB

लागू नहीं (क्लाउड)

8 GB

2 जीबी

4 GB

भाषाएँ

30+

50+

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

3 सेकंड संदर्भ

1 सेकंड संदर्भ

5 सेकंड संदर्भ

❌

10 सेकंड संदर्भ

लेटेंसी

70 ms

~200 मिलीसेकंड

~150 मिलीसेकंड

50 ms

100 ms

गुणवत्ता

⭐⭐⭐⭐⭐

⭐⭐⭐⭐

स्व-होस्टेड

✅

❌

✅

बड़े प्रोजेक्ट्स के लिए बैच प्रोसेसिंग

import concurrent.futures
from voxtral import VoxtralTTS

model = VoxtralTTS.from_pretrained("mistralai/Voxtral-TTS").to("cuda")

# एक पूरे ऑडियोबुक अध्याय को प्रोसेस करें
paragraphs = [
    "Chapter 1: The Beginning...",
    "It was a dark and stormy night...",
    "The protagonist stepped forward...",
    # ... सैकड़ों अनुच्छेद
]

def process_paragraph(idx_text):
    idx, text = idx_text
    audio = model.synthesize(text=text, language="en")
    audio.save(f"chapter1_part{idx:04d}.wav")
    return idx

# क्रमिक प्रोसेसिंग (GPU-निर्भर)
for i, text in enumerate(paragraphs):
    process_paragraph((i, text))
    
print(f"{len(paragraphs)} अनुच्छेद प्रोसेस किए गए")

रीयल-टाइम अनुप्रयोगों के लिए स्ट्रीमिंग मोड

# लाइव अनुप्रयोगों के लिए स्ट्रीमिंग सिंथेसिस
async def stream_synthesis(text: str, language: str = "en"):
    """कम-लेटेंसी प्लेबैक के लिए ऑडियो को स्ट्रीमिंग chunks में उत्पन्न करें."""
    model = VoxtralTTS.from_pretrained("mistralai/Voxtral-TTS").to("cuda")
    
    async for chunk in model.synthesize_stream(
        text=text,
        language=language,
        chunk_size=4096  # 24kHz पर प्रति chunk लगभग 170ms
    ):
        yield chunk.numpy().tobytes()

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

समस्या

समाधान

छोटे GPU पर OOM

उपयोग करें model.half() FP16 के लिए (VRAM को लगभग 1.5 GB तक आधा कर देता है)

धीमा पहला inference

सामान्य — मॉडल पहली बार चलने पर CUDA kernels कम्पाइल करता है (~30s)

भाषा X के लिए खराब गुणवत्ता

सही सुनिश्चित करें भाषा पैरामीटर; कुछ भाषाओं को लंबा संदर्भ ऑडियो चाहिए

ऑडियो आर्टिफैक्ट्स

बढ़ाएँ reference_audio बेहतर वॉइस क्लोनिंग के लिए लंबाई को 5–10s तक बढ़ाएँ

मॉडल डाउनलोड विफल हो जाता है

सेट करें HF_TOKEN gated मॉडल एक्सेस के लिए env variable

लागत विश्लेषण: Clore.ai पर Voxtral बनाम क्लाउड TTS

सेवा

प्रति माह 1M वर्ण

नोट्स

ElevenLabs Pro

$99/माह

500K वर्ण शामिल, अतिरिक्त शुल्क

OpenAI TTS

$15/माह

1M वर्ण पर $15

Google Cloud TTS

$16/माह

मानक आवाज़ें

Clore.ai पर Voxtral

$3–15/माह

RTX 3060 @ $0.03–0.07/घंटा, असीमित वर्ण

निष्कर्ष: Clore.ai पर Voxtral को स्व-होस्ट करना क्लाउड TTS APIs की तुलना में 6–30× सस्ता है, बिना किसी वर्ण सीमा और पूर्ण डेटा गोपनीयता के साथ.

अधिक पढ़ें

अंतिम अपडेट: 30 मार्च, 2026

पिछलाMeloTTS

अगलाMOSS-TTS (केवल CPU, 100M)

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

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