# Comparaison des moteurs TTS

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

{% hint style="info" %}
**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.
{% endhint %}

***

## 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.

```python
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.

```python
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.

```python
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.

```python
# 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.

```python
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)

{% hint style="info" %}
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.
{% endhint %}

| 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** |

{% hint style="success" %}
**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.
{% endhint %}

***

## 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      |

{% hint style="info" %}
**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.
{% endhint %}

***

## 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

```python
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

```bash
# 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

```python
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

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

### Déploiement Docker

```dockerfile
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"]
```

```python
# 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")
```

```bash
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

```python
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

```bash
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

```python
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

```python
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

```bash
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

```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

```python
# 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

```python
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)

```python
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

```yaml
# 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)

```python
# 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

```python
# 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

{% hint style="warning" %}
**La licence compte pour l'utilisation commerciale !** Vérifiez toujours avant de déployer en production.
{% endhint %}

| 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)](https://github.com/coqui-ai/TTS) — 35K+ étoiles
* [Bark GitHub](https://github.com/suno-ai/bark) — 38K+ étoiles
* [Kokoro GitHub](https://github.com/hexgrad/kokoro) — 12K+ étoiles
* [Fish Speech GitHub](https://github.com/fishaudio/fish-speech) — 14K+ étoiles
* [MeloTTS GitHub](https://github.com/myshell-ai/MeloTTS) — 15K+ étoiles
* [Classement TTS Arena](https://huggingface.co/spaces/TTS-AGI/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](https://clore.ai/marketplace) serveurs GPU. Parcourez les GPU disponibles et louez à l’heure — sans engagement, avec accès root complet.


---

# Agent Instructions: Querying This Documentation

If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter:

```
GET https://docs.clore.ai/guides/guides_v2-fr/comparaisons/tts-comparison.md?ask=<question>
```

The question should be specific, self-contained, and written in natural language.
The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.