Comparaison des moteurs TTS

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

Synthèse vocale (TTS) convertit le texte écrit en audio au son naturel. Ce guide compare cinq principaux moteurs TTS open source : XTTS v2, Bark, Kokoro, Fish Speech et MeloTTS — en 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	✅ (clip de 3 s)	✅ (préréglages de voix)	✅ (limité)	✅ (clip de 10 s)	❌
Langues	17	10+	Anglais	8+	8
VRAM minimale	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 absolue pour le clonage vocal TTS open source. Il peut cloner n'importe quelle voix à partir d'un clip 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 vocal zero-shot à partir d'une référence de 3 s
tts.tts_to_file(
    text="Bonjour, voici 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 un transformer qui génère une parole très expressive, y compris 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(
    "[rires] Bonjour ! [se racle la gorge] Voici Bark TTS. [soupirs]"
)
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 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(
    "Le renard brun rapide saute par-dessus le chien paresseux.",
    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 niveau production avec un clonage vocal exceptionnel à partir de courts extraits. Il utilise une architecture innovante codec + modèle de langage.

Philosophie: qualité de production, inférence rapide, excellent clonage.

# Fish Speech via l'API HTTP
import requests

response = requests.post(
    "http://localhost:8080/v1/tts",
    json={
        "text": "Bonjour, voici Fish Speech qui génère de l'audio.",
        "reference_id": "your-voice-id",
        "format": "wav",
    }
)

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

MeloTTS

MeloTTS de MyShell est un TTS ultra-rapide, multiaccent, 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 en 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(
    "Bonjour le monde ! MeloTTS est très rapide.",
    speaker_ids['EN-Default'],
    output_path,
    speed=speed
)

---

Comparaison de la qualité

Scores de naturalité (MOS — score d'opinion moyen, 1-5)

Les scores MOS sont des valeurs approximatives basées sur des articles publiés et des évaluations de la communauté. La qualité réelle dépend fortement du contenu du texte et de la configuration vocale.

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

Ce que chaque modèle fait le mieux

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

---

Benchmarks de vitesse

Caractères par seconde (CPU vs GPU)

Test : "Le renard brun rapide saute par-dessus le chien paresseux. Comment allez-vous aujourd'hui ?" (60 caractères)

Modèle	Vitesse sur CPU	Vitesse sur 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 nécessaire pour générer 1 minute d'audio

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

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

---

Prise en charge des langues

Langues prises en charge

Modèle	Langues	Remarque
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

Notes sur la qualité linguistique

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

Pour la synthèse vocale chinoise: Fish Speech et MeloTTS sont les meilleures options open source. Tous 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é constante dans chacune d'elles.

---

Comparaison du clonage vocal

Capacités de clonage

Modèle	Longueur de la référence	Qualité du clonage	Zéro-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 à partir d'une référence (minimum 3 secondes, idéalement 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 animateur, et je suis ravi de 
    partager avec vous quelques idées 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 à partir de l'audio de référence
fish_speech_cli tts \\
  --text "C'est ma voix clonée qui prononce 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 de voix Bark

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

# Bark utilise des codes de locuteur 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 ! [rires] 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 plus de 16K heures dans 17 langues

• Minimum de 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.8.1-cudnn-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 autorisation), plus lent que Kokoro/MeloTTS

---

Bark : analyse approfondie

Architecture

• Transformer de type GPT pour la génération de jetons audio

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

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

Ce qui rend Bark unique

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

• 🎵 Musique de fond dans la parole

• 😂 Rires, soupirs, raclements de gorge

• 🎭 Plusieurs locuteurs en une seule génération

• 🌍 Énoncés multilingues mélangés

Langage de balisage

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

# Jetons spéciaux pour l'expressivité
text = """
[se racle la gorge] Bonjour à tous. [rires] 
La présentation d'aujourd'hui couvrira... 
[soupire profondément] ...en fait, pas mal de sujets.
[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 d'une exécution à l'autre, pas de véritable clonage vocal

---

Kokoro : analyse approfondie

Architecture

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

• Extrêmement petit mais étonnamment de haute qualité

• 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("Bonjour, ceci est un test.", voice=voice_name)
    for _, _, audio in gen:
        print(f"Généré avec {description}")

Prise en charge 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 sa génération
text = "Ceci est un texte très long qui sera diffusé au fur et à mesure de sa génération, fournissant une sortie audio à faible latence."

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

Faiblesses: uniquement en anglais (principalement), pas de clonage vocal, expressivité limitée

---

Fish Speech : analyse approfondie

Architecture

• VQGAN + modèle de langage architecture

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

• Fort en multilingue avec prise en charge 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 l'API HTTP
with httpx.Client() as client:
    response = client.post(
        "http://localhost:8080/v1/tts",
        json={
            "text": "Bonjour de Fish Speech ! Cela semble 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éverser la référence, récupérer 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": "Parole en cours dans la voix clonée.",
        "reference_id": voice_id,
    }
)

Faiblesses: licence CC BY-NC-SA (non commerciale), plus de VRAM pour une qualité optimale

---

MeloTTS : analyse approfondie

Architecture

• basé sur VITS2 architecture

• Entraînement anglais multiaccent

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

Accents et langues

from melo.api import TTS

# Codes de langue 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 un accent britannique
model.tts_to_file(
    "Salut ! Envie d'une petite tasse de thé ?",
    speaker_ids['EN-BR'],
    'british.wav'
)

# Générer avec un accent indien
model.tts_to_file(
    "Namasté ! Bienvenue dans notre entreprise.",
    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 = [
    "Première phrase à synthétiser.",
    "Deuxième phrase ici.",
    "Troisième et dernière phrase.",
]

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"Généré {len(texts)} fichiers en {elapsed:.2f}s")

Faiblesses: Pas de clonage de voix, 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 besoin de GPU !

  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 direct)

# De nombreux serveurs TTS offrent des points de terminaison compatibles OpenAI
# Utiliser 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! Ceci utilise le format de l’API TTS d’OpenAI.",
)
response.stream_to_file("output.mp3")

Intégration LangChain

# Utiliser 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 de synthèse vocale"
)

---

Quand utiliser quoi

Guide de décision

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

Besoin d’une génération en temps réel / la plus rapide ?
  → MeloTTS (compatible CPU) ou Kokoro

Besoin d’un discours expressif (rires, émotions) ?
  → Bark (sons non vocaux uniques) ou XTTS v2

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

Anglais uniquement, 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	Évolutif, rapide
Outils d’accessibilité	Kokoro	Léger, gratuit
Doublage vocal	Fish Speech	Meilleure qualité de clonage
Narration longue	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	Licence de modèle public Coqui	❌ 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 peu coûteux) :
  Serveur le moins cher à ~0,05 $/h → ~36 $/mois
  Peut gérer plus de 100 requêtes simultanées sur CPU

XTTS v2 (RTX 3080) :
  ~0,30 $/h → ~220 $/mois
  Capacité d’environ 500 requêtes/h

Fish Speech (RTX 4090) :
  ~0,60 $/h → ~440 $/mois  
  Capacité d’environ 1000 requêtes/h

---

Liens utiles

• Coqui TTS (XTTS) — plus de 35K étoiles

• Bark GitHub — plus de 38K étoiles

• Kokoro GitHub — plus de 12K étoiles

• Fish Speech GitHub — plus de 14K étoiles

• MeloTTS GitHub — plus de 15K étoiles

• Classement TTS Arena

---

Résumé

Modèle	À utiliser quand
XTTS v2	Meilleur clonage vocal (réf. 3 s), 17 langues, non commercial
Bark	Expressif, rires/effets, licence MIT
Kokoro	Anglais rapide, de haute qualité, licence Apache
Fish Speech	Meilleur pour les langues CJK, clonage en production, non commercial
MeloTTS	Le plus rapide, temps réel, anglais multiaccent, licence MIT

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

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

• Service de clonage vocal → XTTS v2 ou Fish Speech (vérifier 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 (24 Go)	0,07–0,21 $/gpu/h
Production	RTX 4090 (24 Go)	0,14–0,42 $/gpu/h
Grande échelle	A100 80 Go	bare metal

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