Dia TTS (Nari Labs)

Générez des dialogues multivoix avec émotion à l'aide de Dia TTS de Nari Labs

Dia de Nari Labs est un modèle avancé de synthèse vocale qui se spécialise dans le dialogue réaliste à plusieurs locuteurs. Contrairement à la synthèse vocale traditionnelle qui traite un seul locuteur à la fois, Dia génère des conversations naturelles entre plusieurs locuteurs avec des émotions, des rires, des hésitations et d'autres indices non verbaux. Avec 1,6 milliard de paramètres, il fonctionne sur n'importe quel GPU de 8 Go et plus.

Caractéristiques clés

• Dialogue multi-locuteurs: Générez des conversations entre 2 locuteurs ou plus en une seule passe

• Indices non verbaux: Rires (rit), hésitations (soupire), pauses — automatiquement intégrés

• Parole émotionnelle: Intonation naturelle sans balises d'émotion explicites

• 1,6 milliard de paramètres: Tient sur une RTX 3070/3080 (8–10 Go de VRAM)

• licence Apache 2.0: Utilisation commerciale complète

• Intégration à Hugging Face: Fonctionne avec la bibliothèque Transformers

Exigences

Composant	Minimum	Recommandé
GPU	RTX 3070 (8 Go)	RTX 3080 (10 Go)
VRAM	8 Go	10 Go+
RAM	16 Go	32 Go
Disque	10GB	15 Go
Python	3.9+	3.11

GPU Clore.ai recommandé: RTX 3080 10 Go (0,05–0,19 $/h)

Installation

# Option 1 : installation avec pip
pip install dia-tts

# Option 2 : depuis les sources
git clone https://github.com/nari-labs/dia.git
cd dia
pip install -e .

Démarrage rapide

Dialogue multi-locuteurs de base

from dia import Dia

# Charger le modèle
model = Dia.from_pretrained("nari-labs/Dia-1.6B")

# Générer une conversation à plusieurs locuteurs
# [S1] = Locuteur 1, [S2] = Locuteur 2
text = """[S1] Hé, as-tu essayé la nouvelle plateforme de location de GPU ?
[S2] Tu veux dire Clore ? Oui, j’ai loué une RTX 4090 hier.
[S1] Alors, c’était comment ?
[S2] (rit) Honnêtement ? Beaucoup moins cher que je ne l’avais imaginé. Genre deux dollars par jour.
[S1] Sans blague. C’est... c’est vraiment hallucinant."""

audio = model.generate(text)

# Enregistrer dans un fichier
import soundfile as sf
sf.write("dialog.wav", audio, samplerate=24000)

Avec émotion et indices non verbaux

# Dia gère automatiquement les schémas de parole naturels
text = """[S1] Je viens d’obtenir les résultats...
[S2] Et ? Ne me laisse pas dans le suspense !
[S1] (soupire) On a réussi. On a réellement réussi tous les tests.
[S2] (rit) Je te l’avais dit ! Je te l’avais dit qu’on y arriverait !
[S1] Je n’arrive pas à y croire... (rit) d’accord, d’accord, fêtons ça."""

audio = model.generate(text, temperature=0.8)
sf.write("emotional_dialog.wav", audio, samplerate=24000)

Un seul locuteur

# Fonctionne aussi pour un seul locuteur
text = "[S1] Bienvenue dans la documentation de Clore AI. Dans ce guide, nous allons parcourir la configuration de votre première location de GPU et le déploiement d’un modèle d’apprentissage automatique."

audio = model.generate(text)
sf.write("narration.wav", audio, samplerate=24000)

Interface web Gradio

# Lancer la démo interactive
python -m dia.app --port 7860 --share

# Ou manuellement :
import gradio as gr
from dia import Dia

model = Dia.from_pretrained("nari-labs/Dia-1.6B")

def generate_speech(text):
    audio = model.generate(text)
    return (24000, audio)

demo = gr.Interface(
    fn=generate_speech,
    inputs=gr.Textbox(label="Dialogue (utilisez les balises [S1], [S2])", lines=10),
    outputs=gr.Audio(label="Discours généré"),
    title="Dia TTS — Dialogue multi-locuteurs"
)
demo.launch(server_port=7860)

Cas d’usage

• Génération de podcasts: Créez des podcasts conversationnels à partir de scripts

• Dialogues pour livres audio: Générez des conversations de personnages avec des voix distinctes

• Dialogue de jeu: Conversations de PNJ avec des schémas de parole naturels

• Données d’entraînement: Générez des ensembles de données vocales variés pour l'entraînement ASR

• Voix de chatbot: Dialogue à plusieurs tours avec réponses émotionnelles

Conseils pour les utilisateurs de Clore.ai

• La RTX 3080 est idéale: 10 Go de VRAM suffisent largement à Dia, pour 0,05–0,19 $/h

• Génération par lots: Traitez plusieurs dialogues en boucle pour maximiser votre temps de location

• Enregistrer les modèles dans un stockage persistant: Si votre instance Clore dispose d’un disque persistant, mettez le modèle en cache pour éviter de le retélécharger

• Température 0,7–0,9: Plus bas = plus cohérent, plus haut = plus expressif/varié

• Anglais uniquement: Dia se concentre actuellement sur l’anglais — pour le multilingue, voir le guide Qwen3-TTS

Dépannage

Problème	Solution
Mémoire CUDA insuffisante	Utilisez model.to("cuda", torch_dtype=torch.float16) pour la demi-précision
Les locuteurs se ressemblent	Ajoutez plus de texte/contexte pour chaque locuteur ; essayez une température plus élevée
Indices non verbaux ignorés	Assurez-vous du bon format : (rit), (soupire) entre parenthèses
Qualité audio faible	Augmentez num_steps paramètre si disponible ; assurez-vous d’un taux d’échantillonnage de 24 kHz

Pour aller plus loin

• GitHub de Nari Labs

• Modèle Hugging Face

• Comparaison : Dia vs ElevenLabs — page de démonstration officielle