Comparaison des moteurs TTS

Comparez les principaux moteurs open-source de synthèse vocale pour un déploiement sur les serveurs GPU Clore.ai.

Synthèse vocale (TTS) convertit le texte écrit en audio à l'apparence naturelle. Ce guide compare cinq moteurs TTS open-source majeurs : XTTS v2, Bark, Kokoro, Fish Speech et MeloTTS — couvrant la qualité, la vitesse, la prise en charge des langues et les capacités de clonage vocal.

---

Matrice de décision rapide

	XTTS v2	Bark	Kokoro	Fish Speech	MeloTTS
Développeur	Coqui AI	Suno AI	Hexgrad	Fish Audio	MyShell AI
Qualité	⭐⭐⭐⭐⭐	⭐⭐⭐⭐	⭐⭐⭐⭐	⭐⭐⭐⭐⭐	⭐⭐⭐
Vitesse	Moyen	Lent	Rapide	Rapide	Le plus rapide
Clonage de voix	✅ (extrait 3s)	✅ (préréglages de voix)	✅ (limité)	✅ (extrait 10s)	❌
Langues	17	10+	Anglais	8+	8
VRAM min.	4 Go	8 Go	CPU ok	4 Go	CPU ok
Licence	CPML (non-commercial)	MIT	Apache 2.0	CC BY-NC-SA	MIT
Étoiles GitHub	35K+ (Coqui TTS)	38K+	12K+	14K+	15K+

---

Aperçu

XTTS v2

XTTS v2 de Coqui est la référence pour le clonage vocal open-source en TTS. Il peut cloner n'importe quelle voix à partir d'un extrait audio de 3 secondes avec une fidélité exceptionnelle.

Philosophie: Expressivité maximale et qualité de clonage vocal.

from TTS.api import TTS

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

# Clonage de voix zero-shot à partir d'une référence de 3s
tts.tts_to_file(
    text="Bonjour, ceci est une voix clonée qui parle naturellement.",
    speaker_wav="reference_voice.wav",
    language="en",
    file_path="output.wav"
)

Bark

Bark de Suno est un modèle TTS basé sur des transformeurs qui génère une parole très expressive, incluant des sons non vocaux : rires, soupirs, musique et effets sonores.

Philosophie: Pas seulement de la parole — génération audio complète.

from bark import SAMPLE_RATE, generate_audio, preload_models
from scipy.io.wavfile import write as write_wav

preload_models()

audio_array = generate_audio(
    "[rire] Bonjour ! [dégage la gorge] Ceci est Bark TTS. [soupire]"
)
write_wav("output.wav", SAMPLE_RATE, audio_array)

Kokoro

Kokoro est un modèle TTS léger et rapide optimisé pour l'anglais. Malgré sa petite taille (~82M de paramètres), il offre une qualité étonnamment élevée.

Philosophie: Petit modèle, grande qualité, fonctionne partout.

from kokoro import KPipeline
import soundfile as sf

pipeline = KPipeline(lang_code='a')  # 'a' = anglais américain

generator = pipeline(
    "The quick brown fox jumps over the lazy dog.",
    voice='af_heart',  # voix préconstruite
    speed=1.0,
)

for _, _, audio in generator:
    sf.write('output.wav', audio, 24000)

Fish Speech

Fish Speech de Fish Audio est un TTS de qualité production avec un clonage vocal exceptionnel à partir de courts extraits. Il utilise une architecture novel combinant codec + modèle de langage.

Philosophie: Qualité production, inférence rapide, excellent clonage.

# Fish Speech via HTTP API
import requests

response = requests.post(
    "http://localhost:8080/v1/tts",
    json={
        "text": "Bonjour, ceci est Fish Speech générant de l'audio.",
        "reference_id": "votre-id-voix",
        "format": "wav",
    }
)

with open("output.wav", "wb") as f:
    f.write(response.content)

MeloTTS

MeloTTS de MyShell est ultra-rapide, TTS multi-accentes optimisé pour les applications en temps réel. Il fonctionne efficacement sur CPU et prend en charge plusieurs accents anglais et langues asiatiques.

Philosophie: Vitesse temps réel à n'importe quelle échelle.

from melo.api import TTS

speed = 1.0
device = 'auto'

model = TTS(language='EN', device=device)
speaker_ids = model.hps.data.spk2id

output_path = 'output.wav'
model.tts_to_file(
    "Hello world! MeloTTS is very fast.",
    speaker_ids['EN-Default'],
    output_path,
    speed=speed
)

---

Comparaison de la qualité

Scores de naturalité (MOS — Mean Opinion Score, 1-5)

Les scores MOS sont des valeurs approximatives basées sur des publications et des évaluations communautaires. La qualité réelle dépend fortement du contenu du texte et de la configuration de la voix.

Modèle	MOS anglais	MOS multilingue	Expressivité
XTTS v2	4.3	4.1	⭐⭐⭐⭐⭐
Bark	3.9	3.7	⭐⭐⭐⭐⭐ (unique)
Kokoro	4.2	N/D (uniquement EN)	⭐⭐⭐
Fish Speech	4.4	4.2	⭐⭐⭐⭐
MeloTTS	3.8	3.6	⭐⭐

Ce que chaque modèle fait de mieux

Modèle	Atout qualitatif distinctif
XTTS v2	Clonage vocal quasi parfait, gamme émotionnelle
Bark	Sons non vocaux, rires, musique, effets
Kokoro	Meilleur rapport qualité/taille, cadence naturelle
Fish Speech	Meilleure naturalité globale + précision du clonage
MeloTTS	Sortie cohérente et propre pour les textes longs

---

Benchmarks de vitesse

Caractères par seconde (CPU vs GPU)

Test : "The quick brown fox jumps over the lazy dog. How are you today?" (60 caractères)

Modèle	Vitesse CPU	Vitesse GPU (RTX 3080)	Facteur temps réel
XTTS v2	~15 caractères/s	~150 caractères/s	0.3× (GPU)
Bark	~5 caractères/s	~40 caractères/s	0.1× (GPU)
Kokoro	~200 caractères/s	~800 caractères/s	5× (GPU)
Fish Speech	~80 caractères/s	~500 caractères/s	3× (GPU)
MeloTTS	~500 caractères/s	~2000 caractères/s	12× (GPU)

Un facteur temps réel > 1.0 signifie plus rapide que la vitesse de lecture

Temps pour générer 1 minute d'audio

Modèle	CPU	RTX 3080	A100
XTTS v2	~8 min	~30s	~10s
Bark	~20 min	~3 min	~45s
Kokoro	~20s	~5s	~2s
Fish Speech	~45s	~8s	~3s
MeloTTS	~8s	~2s	<1s

Pour les applications en temps réel: MeloTTS et Kokoro sont les gagnants évidents. Les deux peuvent générer de la parole plus rapidement que la vitesse de lecture même sur CPU.

---

Prise en charge des langues

Langues prises en charge

Modèle	Langues	Remarquable
XTTS v2	17	EN, ES, FR, DE, IT, PT, PL, TR, RU, NL, CS, AR, ZH, JA, HU, KO, HI
Bark	10+	EN, ZH, FR, DE, HI, IT, JA, KO, PL, PT, RU, ES, TR
Kokoro	2	Anglais (US/UK), Japonais (limité)
Fish Speech	8	EN, ZH, JA, KO, FR, DE, AR, ES
MeloTTS	8	EN (4 accents), ES, FR, ZH, JA, KO

Remarques sur la qualité des langues

Modèle	Anglais	Chinois	Japonais	Européen
XTTS v2	Excellente	Bonne	Bonne	Excellente
Bark	Bonne	Moyen	Moyen	Bonne
Kokoro	Excellente	❌	Limité	❌
Fish Speech	Excellente	Meilleur	Bonne	Bonne
MeloTTS	Bonne	Bonne	Bonne	Bonne

Pour la synthèse vocale chinoise: Fish Speech et MeloTTS sont les meilleures options open-source. Les deux gèrent naturellement les tons et les caractères.

Pour les applications multilingues: XTTS v2 prend en charge le plus grand nombre de langues avec une qualité cohérente sur l'ensemble.

---

Comparaison du clonage vocal

Capacités de clonage

Modèle	Durée de référence	Qualité du clonage	Zero-shot
XTTS v2	3 secondes	⭐⭐⭐⭐⭐	✅
Bark	Préréglages de voix uniquement	⭐⭐⭐	Partiel
Kokoro	Non pris en charge	❌	❌
Fish Speech	10 secondes	⭐⭐⭐⭐⭐	✅
MeloTTS	Non pris en charge	❌	❌

Clonage vocal XTTS v2

from TTS.api import TTS
import torch

# Charger le modèle
tts = TTS("tts_models/multilingual/multi-dataset/xtts_v2")
tts.to("cuda" if torch.cuda.is_available() else "cpu")

# Cloner la voix depuis la référence (minimum 3 secondes, idéal 10-30 secondes)
tts.tts_to_file(
    text="""
    Bienvenue dans notre podcast. Aujourd'hui nous discutons de l'avenir de l'IA 
    et de son impact sur la société. Je suis votre hôte, et je suis ravi de 
    partager avec vous quelques perspectives fascinantes.
    """,
    speaker_wav="speaker_sample.wav",  # Votre audio de référence
    language="en",
    file_path="cloned_voice_output.wav"
)

Clonage vocal Fish Speech

# Cloner depuis un audio de référence
fish_speech_cli tts \
  --text "Ceci est ma voix clonée parlant une nouvelle phrase." \
  --reference-audio speaker_sample.wav \
  --reference-text "Le texte original prononcé dans l'audio de référence." \
  --output cloned_output.wav

Préréglages vocaux Bark

from bark import generate_audio, SAMPLE_RATE
from scipy.io.wavfile import write

# Bark utilise des codes locuteurs prédéfinis
voice_presets = {
    "male_US": "v2/en_speaker_6",
    "female_US": "v2/en_speaker_9",
    "male_UK": "v2/en_speaker_0",
    "announcer": "v2/en_speaker_2",
}

audio = generate_audio(
    "Bienvenue ! [rire] C'est une technologie absolument fascinante.",
    history_prompt=voice_presets["female_US"]
)
write("bark_output.wav", SAMPLE_RATE, audio)

---

XTTS v2 : Analyse approfondie

Architecture

• VITS + GPT architecture hybride

• Entraîné sur 16K+ heures réparties sur 17 langues

• Minimum 3 secondes pour le clonage zero-shot

Installation sur Clore.ai

pip install TTS
# Version GPU
pip install TTS[all]

Déploiement Docker

FROM nvidia/cuda:12.1.0-cudnn8-runtime-ubuntu22.04

RUN apt-get update && apt-get install -y python3 python3-pip git ffmpeg
RUN pip3 install TTS fastapi uvicorn

WORKDIR /app
COPY server.py .

EXPOSE 5002
CMD ["uvicorn", "server:app", "--host", "0.0.0.0", "--port", "5002"]

# server.py — API REST XTTS v2
from fastapi import FastAPI, UploadFile, Form
from fastapi.responses import FileResponse
from TTS.api import TTS
import tempfile, os

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

@app.post("/tts")
async def synthesize(
    text: str = Form(...),
    language: str = Form("en"),
    speaker_file: UploadFile = None
):
    with tempfile.NamedTemporaryFile(suffix=".wav", delete=False) as out:
        output_path = out.name

    speaker_path = None
    if speaker_file:
        with tempfile.NamedTemporaryFile(suffix=".wav", delete=False) as ref:
            ref.write(await speaker_file.read())
            speaker_path = ref.name

    tts.tts_to_file(
        text=text,
        speaker_wav=speaker_path,
        language=language,
        file_path=output_path
    )
    return FileResponse(output_path, media_type="audio/wav")

docker build -t xtts-server .
docker run -d --gpus all -p 5002:5002 xtts-server

Faiblesses: Licence CPML (non-commerciale sans permission), plus lent que Kokoro/MeloTTS

---

Bark : Analyse approfondie

Architecture

• Transformeur de type GPT pour la génération de tokens audio

• Processus en trois étapes : texte → sémantique → tokens grossiers → tokens fins

• Génère de véritables tokens de codec audio (EnCodec)

Ce qui rend Bark unique

Bark est le seul TTS open-source qui génère nativement :

• 🎵 Musique de fond intégrée à la parole

• 😂 Rires, soupirs, déblayage de gorge

• 🎭 Multiples locuteurs dans une même génération

• 🌍 Énoncés en langues mixtes

Langage de balisage

from bark import generate_audio, SAMPLE_RATE
from scipy.io.wavfile import write

# Tokens spéciaux pour l'expressivité
text = """
[dégage la gorge] Bonjour à tous. [rire] 
La présentation d'aujourd'hui couvrira... 
[soupire profondément] ...en fait pas mal de choses.
[musique : jazz entraînant] Commençons !
"""

audio = generate_audio(text, history_prompt="v2/en_speaker_6")
write("output.wav", SAMPLE_RATE, audio)

Installation

pip install git+https://github.com/suno-ai/bark.git

Faiblesses: Lent (pipeline en 3 étapes), incohérent selon les exécutions, pas de vrai clonage vocal

---

Kokoro : Analyse approfondie

Architecture

• 82M de paramètres Modèle basé sur StyleTTS2

• Extrêmement petit mais de qualité étonnamment élevée

• Inférence rapide sur CPU et GPU

Voix disponibles

from kokoro import KPipeline

pipeline = KPipeline(lang_code='a')  # 'a' = anglais américain, 'b' = britannique

# Voix disponibles
voices = {
    'af_heart': 'Femme américaine (chaleureuse)',
    'af_bella': 'Femme américaine (bella)',
    'af_nicole': 'Femme américaine (nicole)',
    'am_michael': 'Homme américain (michael)',
    'am_fenrir': 'Homme américain (fenrir)',
    'bf_emma': 'Femme britannique (emma)',
    'bm_george': 'Homme britannique (george)',
}

# Générer avec différentes voix
for voice_name, description in voices.items():
    gen = pipeline("Hello, this is a test.", voice=voice_name)
    for _, _, audio in gen:
        print(f"Generated with {description}")

Support du streaming

import sounddevice as sd
from kokoro import KPipeline

pipeline = KPipeline(lang_code='a')

# Diffuser l'audio en temps réel au fur et à mesure de la génération
text = "This is a very long text that will be streamed as it generates, providing low-latency audio output."

for _, _, audio in pipeline(text, voice='af_heart'):
    sd.play(audio, samplerate=24000)
    sd.wait()

Faiblesses: Principalement anglais uniquement, pas de clonage vocal, expressivité limitée

---

Fish Speech : Analyse approfondie

Architecture

• VQGAN + modèle de langage architecture

• Entraîné sur 700K+ heures d'audio

• Forte prise en charge multilingue avec support des langues asiatiques

Installation

pip install fish-speech

# Ou via Docker
docker run -d \
  --gpus all \
  -p 8080:8080 \
  fishaudio/fish-speech:latest \
  +api_server.workers_count=1

API Python

import httpx
import base64

# Via API HTTP
with httpx.Client() as client:
    response = client.post(
        "http://localhost:8080/v1/tts",
        json={
            "text": "Bonjour de la part de Fish Speech ! Cela sonne très naturel.",
            "format": "wav",
            "mp3_bitrate": 128,
            "normalize": True,
        }
    )
    
    with open("fish_output.wav", "wb") as f:
        f.write(response.content)

Clonage vocal

# Téléversez la référence, récupérez l'ID de voix
with open("my_voice.wav", "rb") as f:
    response = httpx.post(
        "http://localhost:8080/v1/voices",
        files={"file": f},
        data={"text": "Le texte prononcé dans cet enregistrement."}
    )
    voice_id = response.json()["id"]

# Utiliser la voix clonée
response = httpx.post(
    "http://localhost:8080/v1/tts",
    json={
        "text": "Parle maintenant avec la voix clonée.",
        "reference_id": voice_id,
    }
)

Faiblesses: Licence CC BY-NC-SA (non-commerciale), plus de VRAM recommandée pour la meilleure qualité

---

MeloTTS : Analyse approfondie

Architecture

• Basé sur VITS2 architecture

• Entraînement multi-accents anglais

• Extrêmement optimisé pour la vitesse d'inférence

Accents et langues

from melo.api import TTS

# Codes de langues et accents pris en charge
configs = {
    'EN':    ['EN-Default', 'EN-US', 'EN-BR', 'EN-INDIA', 'EN-AU'],
    'ES':    ['ES'],
    'FR':    ['FR'],
    'ZH':    ['ZH'],
    'JP':    ['JP'],
    'KR':    ['KR'],
}

model = TTS(language='EN', device='cuda')
speaker_ids = model.hps.data.spk2id

# Générer avec accent britannique
model.tts_to_file(
    "Cheerio! Fancy a spot of tea?",
    speaker_ids['EN-BR'],
    'british.wav'
)

# Générer avec accent indien
model.tts_to_file(
    "Namaste! Welcome to our company.",
    speaker_ids['EN-INDIA'],
    'indian.wav'
)

Traitement par lots (très rapide)

from melo.api import TTS
import time

model = TTS(language='EN', device='cuda')
sid = model.hps.data.spk2id['EN-Default']

texts = [
    "First sentence to synthesize.",
    "Second sentence goes here.",
    "Third and final sentence.",
]

start = time.time()
for i, text in enumerate(texts):
    model.tts_to_file(text, sid, f'output_{i}.wav')
elapsed = time.time() - start
print(f"Generated {len(texts)} files in {elapsed:.2f}s")

Faiblesses: Pas de clonage vocal, rendu robotique à grande vitesse, expressivité limitée

---

Déploiement sur Clore.ai

Serveur TTS tout-en-un

# docker-compose.yml — Service TTS avec plusieurs backends
version: "3.8"

services:
  xtts:
    build:
      context: ./xtts
    ports:
      - "5002:5002"
    deploy:
      resources:
        reservations:
          devices:
            - driver: nvidia
              count: 1
              capabilities: [gpu]
    volumes:
      - ./voices:/app/voices

  kokoro:
    image: ghcr.io/remsky/kokoro-fastapi-cpu:latest
    ports:
      - "8880:8880"
    # Pas de GPU nécessaire !

  fish-speech:
    image: fishaudio/fish-speech:latest
    ports:
      - "8080:8080"
    command: +api_server.workers_count=2
    deploy:
      resources:
        reservations:
          devices:
            - driver: nvidia
              count: 1
              capabilities: [gpu]

Résumé des besoins en VRAM

Modèle	CPU	GPU 4 Go	GPU 8 Go	GPU 16 Go
XTTS v2	Lent	✅	✅	✅
Bark	Très lent	❌	✅	✅
Kokoro	Rapide	✅	✅	✅
Fish Speech	Moyen	✅	✅	✅
MeloTTS	Très rapide	✅	✅	✅

---

Exemples d'intégration

API compatible OpenAI (pour remplacement facile)

# De nombreux serveurs TTS offrent des endpoints compatibles OpenAI
# Utilisez Kokoro FastAPI ou similaire

from openai import OpenAI

client = OpenAI(
    base_url="http://localhost:8880/v1",  # Votre serveur TTS
    api_key="not-needed"
)

response = client.audio.speech.create(
    model="kokoro",
    voice="af_heart",
    input="Hello world! This uses the OpenAI TTS API format.",
)
response.stream_to_file("output.mp3")

Intégration LangChain

# Utiliser le TTS avec LangChain pour des agents vocaux
from langchain_community.tools import Tool
from TTS.api import TTS

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

def speak(text: str) -> str:
    tts.tts_to_file(text=text, language="en", file_path="/tmp/response.wav")
    return "/tmp/response.wav"

tts_tool = Tool(
    name="text_to_speech",
    func=speak,
    description="Convertir le texte en fichier audio"
)

---

Quand utiliser lequel

Guide de décision

Besoin de clonage vocal à partir d'un court extrait ?
  → XTTS v2 (référence 3s) ou Fish Speech (référence 10s)

Besoin de génération en temps réel / la plus rapide ?
  → MeloTTS (adapté au CPU) ou Kokoro

Besoin de voix expressive (rire, émotion) ?
  → Bark (sons non vocaux uniques) ou XTTS v2

Besoin de chinois/japonais/coréen ?
  → Fish Speech (meilleur pour CJK) ou MeloTTS

Uniquement anglais, qualité maximale ?
  → Kokoro (meilleur rapport taille/qualité)

Besoin de 17+ langues ?
  → XTTS v2

Utilisation commerciale autorisée ?
  → Kokoro (Apache) ou MeloTTS (MIT) ou Bark (MIT)

Recherche non commerciale ?
  → N'importe lequel (XTTS v2 CPML ou Fish Speech CC BY-NC-SA)

Par type d'application

Application	Meilleur choix	Pourquoi
Génération de livres audio	XTTS v2	Voix naturelle et cohérente
Chatbot en temps réel	MeloTTS ou Kokoro	Inférence la plus rapide
Automatisation de podcasts	XTTS v2 ou Fish Speech	Meilleur clonage
Personnages de jeu	Bark	Voix expressives et variées
Service client	MeloTTS	Extensible, rapide
Outils d'accessibilité	Kokoro	Léger, gratuit
Doublage vocal	Fish Speech	Meilleure qualité de clonage
Narration longue durée	XTTS v2	Qualité constante

---

Résumé des licences

La licence compte pour l'utilisation commerciale ! Vérifiez toujours avant de déployer en production.

Modèle	Licence	Commercial ?	Remarques
XTTS v2	Coqui Public Model License	❌ Gratuit	Nécessite une licence pour un usage commercial
Bark	MIT	✅	Gratuit pour toute utilisation
Kokoro	Apache 2.0	✅	Gratuit pour toute utilisation
Fish Speech	CC BY-NC-SA 4.0	❌	Usage non commercial uniquement
MeloTTS	MIT	✅	Gratuit pour toute utilisation

Entièrement ouvert pour un usage commercial : Bark, Kokoro, MeloTTS

---

Coût sur Clore.ai

Kokoro/MeloTTS (CPU ou GPU bon marché) :
  Serveur le moins cher à ~0,05 $/h → ~36 $/mois
  Peut gérer 100+ requêtes simultanées sur CPU

XTTS v2 (RTX 3080) :
  ~0,30 $/h → ~220 $/mois
  ~500 requêtes/heure de capacité

Fish Speech (RTX 4090) :
  ~0,60 $/h → ~440 $/mois  
  ~1000 requêtes/heure de capacité

---

Liens utiles

• Coqui TTS (XTTS) — 35K+ étoiles

• Bark GitHub — 38K+ étoiles

• Kokoro GitHub — 12K+ étoiles

• Fish Speech GitHub — 14K+ étoiles

• MeloTTS GitHub — 15K+ étoiles

• Classement TTS Arena

---

Résumé

Modèle	Utiliser quand
XTTS v2	Meilleur clonage de voix (réf. 3s), 17 langues, non commercial
Bark	Expressif, rires/effets, licence MIT
Kokoro	Rapide, voix anglaise de haute qualité, licence Apache
Fish Speech	Meilleur pour CJK, clonage en production, non commercial
MeloTTS	Le plus rapide, temps réel, anglais multi-accentué, licence MIT

Pour la plupart des déploiements en production sur Clore.ai :

• Applications vocales en temps réel → MeloTTS ou Kokoro (gratuit, rapide, MIT)

• Service de clonage vocal → XTTS v2 ou Fish Speech (vérifiez la licence)

• Narration expressive → Bark ou XTTS v2

---

Recommandations GPU Clore.ai

Cas d’utilisation	GPU recommandé	Coût estimé sur Clore.ai
Développement/Test	RTX 3090 (24GB)	~$0.12/gpu/hr
Production	RTX 4090 (24GB)	~$0.70/gpu/hr
Grande échelle	A100 80GB	~$1.20/gpu/hr

💡 Tous les exemples de ce guide peuvent être déployés sur Clore.ai serveurs GPU. Parcourez les GPU disponibles et louez à l’heure — sans engagement, avec accès root complet.