> For the complete documentation index, see [llms.txt](https://docs.clore.ai/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://docs.clore.ai/guides/guides_v2-fr/audio-et-voix/melotts.md).

# MeloTTS

Exécutez MeloTTS, une synthèse vocale multilingue de haute qualité avec inférence rapide sur les GPU Clore.ai

MeloTTS est une bibliothèque de synthèse vocale multilingue de haute qualité développée par **MyShell AI**. Elle offre une synthèse vocale rapide et naturelle dans plusieurs langues et avec des accents anglais, conçue à la fois pour la recherche et le déploiement en production. MeloTTS est optimisé pour la vitesse — il peut générer de la parole nettement plus vite qu'en temps réel, même sur CPU — tout en conservant une haute qualité audio adaptée à un usage commercial.

MeloTTS prend actuellement en charge :

* **Anglais** (américain, britannique, indien, australien, par défaut)
* **Chinois (simplifié et chinois-anglais mixte)**
* **Japonais**
* **Coréen**
* **Espagnol**
* **Français**

Points forts :

* ⚡ **Inférence rapide** — plus rapide qu'en temps réel sur CPU, extrêmement rapide sur GPU
* 🌍 **Multilingue** — 6 langues avec variantes d'accent pour l'anglais
* 🐳 **Compatible Docker** — image Docker officielle disponible
* 🔌 **API REST** — API HTTP pour intégrer dans n'importe quelle application
* 📱 **Prêt pour la production** — utilisé dans les produits grand public de MyShell

{% hint style="success" %}
Tous les exemples peuvent être exécutés sur des serveurs GPU loués via [la place de marché CLORE.AI](https://clore.ai/marketplace).
{% endhint %}

***

## Exigences du serveur

| Paramètre              | Minimum                | Recommandé              |
| ---------------------- | ---------------------- | ----------------------- |
| GPU                    | NVIDIA GTX 1080 (8 Go) | NVIDIA RTX 3090 (24 Go) |
| VRAM                   | 4 Go                   | 8–16 Go                 |
| RAM                    | 8 Go                   | 16 Go                   |
| CPU                    | 4 cœurs                | 8 cœurs                 |
| Disque                 | 10 Go                  | 20 Go                   |
| Système d'exploitation | Ubuntu 20.04+          | Ubuntu 22.04            |
| CUDA                   | 11.7+ (optionnel)      | 12.1+                   |
| Python                 | 3.8+                   | 3.10                    |
| Ports                  | 22, 8888               | 22, 8888                |

{% hint style="info" %}
MeloTTS est remarquablement efficace — il fonctionne bien sur CPU pour les requêtes individuelles et bénéficie énormément du GPU pour le traitement par lots. Même un GPU d'entrée de gamme double considérablement le débit.
{% endhint %}

***

## Déploiement rapide sur CLORE.AI

{% hint style="warning" %}
**Remarque :** MeloTTS ne dispose pas d'une image Docker officielle préconstruite sur Docker Hub (`myshell-ai/melotts` n'existe pas). L'approche recommandée consiste à utiliser une image de base NVIDIA CUDA et à installer MeloTTS via pip depuis le dépôt GitHub officiel.
{% endhint %}

### 1. Trouvez un serveur adapté

Accédez à [la place de marché CLORE.AI](https://clore.ai/marketplace) et filtrez par :

* **VRAM**: ≥ 4 Go (ou CPU uniquement pour un faible volume)
* **GPU**: N'importe quel GPU NVIDIA (GTX 1080+, série RTX, A100)
* **Disque**: ≥ 10 Go

### 2. Configurez votre déploiement

**Image Docker :**

```
nvidia/cuda:12.8.1-devel-ubuntu22.04
```

**Mappages de ports :**

```
22 → accès SSH
8888 → serveur API MeloTTS
```

**Variables d'environnement :**

```
NVIDIA_VISIBLE_DEVICES=all
```

**Commande de démarrage** (à exécuter après la connexion SSH au serveur) :

```bash
apt-get update && apt-get install -y python3-pip ffmpeg espeak-ng git && \
git clone https://github.com/myshell-ai/MeloTTS.git && \
cd MeloTTS && pip install -e . && \
python -m unidic download && \
python3 -c "import nltk; nltk.download('averaged_perceptron_tagger_eng')" && \
python -m melo.api_server --host 0.0.0.0 --port 8888
```

### 3. Accéder à l'API

```
http://<ip-de-votre-serveur-clore>:8888
```

Tester avec :

```bash
curl -X POST http://<server-ip>:8888/synthesize \
  -H "Content-Type: application/json" \
  -d '{"text": "Bonjour depuis Clore.ai !", "language": "EN", "speaker_id": "EN-Default"}'
```

***

## Configuration étape par étape

### Étape 1 : connectez-vous en SSH à votre serveur

```bash
ssh root@<your-clore-server-ip> -p <ssh-port>
```

### Étape 2 : construire et exécuter le conteneur

Comme MeloTTS n'a pas d'image Docker Hub préconstruite, utilisez une base NVIDIA CUDA et installez MeloTTS à partir des sources :

```bash
# Exécuter un conteneur CUDA et y installer MeloTTS
docker run -d \
  --name melotts \
  --gpus all \
  -p 8888:8888 \
  -v /workspace/melotts/outputs:/app/outputs \
  -e NVIDIA_VISIBLE_DEVICES=all \
  nvidia/cuda:12.8.1-devel-ubuntu22.04 \
  bash -c "apt-get update && apt-get install -y python3-pip ffmpeg espeak-ng git && \
    git clone https://github.com/myshell-ai/MeloTTS.git /app/MeloTTS && \
    cd /app/MeloTTS && pip install -e . && \
    python -m unidic download && \
    python3 -c "import nltk; nltk.download('averaged_perceptron_tagger_eng')" && \
    python -m melo.api_server --host 0.0.0.0 --port 8888"
```

Sinon, construisez une image Docker personnalisée à partir des sources :

```bash
git clone https://github.com/myshell-ai/MeloTTS.git
cd MeloTTS
docker build -t melotts:local .
docker run -d \
  --name melotts \
  --gpus all \
  -p 8888:8888 \
  melotts:local
```

### Étape 3 : vérifier que le service est en cours d'exécution

```bash
# Vérifier les journaux du conteneur
docker logs -f melotts

# Attendre le démarrage, puis tester
curl http://localhost:8888/health
```

### Étape 4 : alternative — interface Jupyter Notebook

```bash
docker run -d \
  --name melotts-jupyter \
  --gpus all \
  -p 8888:8888 \
  nvidia/cuda:12.8.1-devel-ubuntu22.04 \
  bash -c "pip install jupyter melo-tts && \
    jupyter notebook --ip=0.0.0.0 --port=8888 --no-browser --allow-root"
```

Accéder à : `http://<server-ip>:8888`

### Étape 5 : installer via pip (sans Docker)

```bash
# Installer les dépendances système
apt-get install -y python3-pip ffmpeg espeak-ng

# Installer MeloTTS
pip install melo-tts

# Télécharger les données NLTK requises
python3 -c "import nltk; nltk.download('averaged_perceptron_tagger_eng')"
```

***

## Exemples d'utilisation

### Exemple 1 : TTS anglais de base (Python)

```python
from melo.api import TTS

# Initialiser le TTS anglais
speed = 1.0  # Ajuster la vitesse de parole (0.5 = lent, 2.0 = rapide)
device = 'cuda'  # Utiliser 'cpu' si aucun GPU n'est disponible

tts = TTS(language='EN', device=device)

# Obtenir les identifiants de locuteur disponibles
speakers = tts.hps.data.spk2id
print("Locuteurs disponibles :", list(speakers.keys()))
# Sortie : ['EN-Default', 'EN-US', 'EN-GB', 'EN-India', 'EN-Australia', 'EN-Brazil']

# Générer la parole
speaker_ids = tts.hps.data.spk2id
output_path = "output_english.wav"

tts.tts_to_file(
    text="Bienvenue sur Clore.ai, votre place de marché cloud GPU pour les charges de travail IA. Louez de puissants GPU en quelques minutes.",
    speaker_id=speaker_ids['EN-Default'],
    output_path=output_path,
    speed=speed
)

print(f"Enregistré dans : {output_path}")
```

***

### Exemple 2 : TTS multilingue

```python
from melo.api import TTS

device = 'cuda'

# Définir les paires langue-texte
language_texts = [
    ('EN', 'EN-US', "Le calcul GPU a transformé la recherche et le développement en intelligence artificielle."),
    ('EN', 'EN-GB', "Le Royaume-Uni mène l'Europe en matière d'investissement et d'innovation dans l'IA."),
    ('ZH', 'ZH', "Clore.ai是一个去中心化的GPU云计算市场，为AI开发者提供算力服务。"),
    ('JP', 'JP', "人工知能の発展には大規模な計算資源が必要です。"),
    ('KR', 'KR', "Clore.ai는 AI 연구자를 위한 GPU 클라우드 마켓플레이스입니다."),
    ('SP', 'SP', "La inteligencia artificial está transformando todas las industrias del mundo."),
    ('FR', 'FR', "L'intelligence artificielle révolutionne la façon dont nous travaillons et vivons."),
]

for lang, speaker, text in language_texts:
    try:
        tts = TTS(language=lang, device=device)
        speaker_id = tts.hps.data.spk2id[speaker]

        output_file = f"output_{lang}_{speaker}.wav"
        tts.tts_to_file(text=text, speaker_id=speaker_id, output_path=output_file)
        print(f"✓ Généré [{lang}] : {output_file}")
    except Exception as e:
        print(f"✗ Erreur [{lang}] : {e}")
```

***

### Exemple 3 : utilisation de l'API REST

```python
import requests
import json

API_BASE = "http://<your-clore-server-ip>:8888"

# Vérifier les voix disponibles
response = requests.get(f"{API_BASE}/voices")
print("Voix disponibles :", json.dumps(response.json(), indent=2))

# Synthétiser la parole
def synthesize(text, language="EN", speaker="EN-Default", speed=1.0):
    payload = {
        "text": text,
        "language": language,
        "speaker_id": speaker,
        "speed": speed,
        "format": "wav"
    }

    response = requests.post(
        f"{API_BASE}/synthesize",
        json=payload,
        timeout=30
    )

    if response.status_code == 200:
        return response.content
    else:
        raise Exception(f"Erreur API : {response.status_code} - {response.text}")

# Générer des exemples
samples = [
    ("Bonjour, ceci est MeloTTS exécuté sur les serveurs GPU de Clore.ai.", "EN", "EN-US"),
    ("Voici la variante d'accent anglais britannique.", "EN", "EN-GB"),
    ("Permettez-moi de démontrer l'accent anglais indien.", "EN", "EN-India"),
]

for text, lang, speaker in samples:
    audio_bytes = synthesize(text, lang, speaker)
    filename = f"api_output_{speaker.replace('-', '_')}.wav"
    with open(filename, "wb") as f:
        f.write(audio_bytes)
    print(f"Enregistré : {filename}")
```

***

### Exemple 4 : traitement par lots à haute vitesse

```python
from melo.api import TTS
from concurrent.futures import ThreadPoolExecutor
import soundfile as sf
import time
import numpy as np
from pathlib import Path

device = 'cuda'
tts = TTS(language='EN', device=device)
speaker_id = tts.hps.data.spk2id['EN-US']

# Grand lot de textes
texts = [
    f"Ceci est la phrase numéro {i}. Elle démontre un traitement par lots rapide avec MeloTTS sur l'infrastructure GPU de Clore.ai."
    for i in range(1, 51)  # 50 phrases
]

output_dir = Path("batch_output")
output_dir.mkdir(exist_ok=True)

start_time = time.time()

# Traiter le lot
for i, text in enumerate(texts):
    output_path = str(output_dir / f"batch_{i+1:03d}.wav")
    tts.tts_to_file(
        text=text,
        speaker_id=speaker_id,
        output_path=output_path,
        speed=1.0,
        quiet=True
    )
    if (i + 1) % 10 == 0:
        elapsed = time.time() - start_time
        print(f"Progression : {i+1}/50 | Temps : {elapsed:.1f}s | Débit : {(i+1)/elapsed:.1f} phrases/s")

total_time = time.time() - start_time
print(f"\nLot terminé : {len(texts)} phrases en {total_time:.1f}s")
print(f"Moyenne : {total_time/len(texts)*1000:.0f} ms par phrase")
```

***

### Exemple 5 : TTS chinois-anglais mixte

```python
from melo.api import TTS

device = 'cuda'
tts = TTS(language='ZH', device=device)
speaker_id = tts.hps.data.spk2id['ZH']

# Texte multilingue mixte (chinois + anglais)
mixed_texts = [
    "我们使用Clore.ai的GPU服务器来运行machine learning workloads。",
    "今天的AI conference讨论了large language models和speech synthesis技术。",
    "我的startup需要GPU资源来训练我们的deep learning模型。",
    "Clore.ai提供了非常competitive的价格，比AWS和GCP便宜很多。",
]

for i, text in enumerate(mixed_texts):
    output_file = f"mixed_zh_en_{i+1}.wav"
    tts.tts_to_file(
        text=text,
        speaker_id=speaker_id,
        output_path=output_file,
        speed=0.9  # Légèrement plus lent pour plus de clarté
    )
    print(f"Généré : {output_file}")
    print(f"  Texte : {text[:60]}...")
```

***

## Configuration

### Configuration Docker Compose

Comme MeloTTS n'a pas d'image Docker Hub officielle, utilisez l'image de base NVIDIA CUDA et installez MeloTTS à partir des sources au démarrage :

```yaml
version: '3.8'

services:
  melotts:
    image: nvidia/cuda:12.8.1-devel-ubuntu22.04
    container_name: melotts
    runtime: nvidia
    environment :
      - NVIDIA_VISIBLE_DEVICES=all
      - PYTHONDONTWRITEBYTECODE=1
    ports:
      - "8888:8888"
    volumes:
      - ./outputs:/app/outputs
      - ./cache:/root/.cache
    command: >
      bash -c "apt-get update && apt-get install -y python3-pip ffmpeg espeak-ng git &&
      git clone https://github.com/myshell-ai/MeloTTS.git /app/MeloTTS &&
      cd /app/MeloTTS && pip install -e . &&
      python -m unidic download &&
      python3 -c 'import nltk; nltk.download("averaged_perceptron_tagger_eng")' &&
      python -m melo.api_server --host 0.0.0.0 --port 8888"
    restart: unless-stopped
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:8888/health"]
      interval: 30s
      timeout: 10s
      retries: 3
    deploy:
      resources:
        reservations:
          devices:
            - driver: nvidia
              count: 1
              capabilities: [gpu]
```

### Options de configuration de l'API

| Paramètre   | Par défaut  | Description                                                    |
| ----------- | ----------- | -------------------------------------------------------------- |
| `--host`    | `127.0.0.1` | Adresse de liaison (utilisez `0.0.0.0` pour la mise en public) |
| `--port`    | `8888`      | Port du serveur API                                            |
| `--workers` | `1`         | Nombre de processus travailleurs                               |
| `--device`  | `auto`      | `cuda`, `cpu`, ou `auto`                                       |

### Langues et locuteurs pris en charge

| Langue   | Code | Identifiants de locuteur                                                |
| -------- | ---- | ----------------------------------------------------------------------- |
| Anglais  | `EN` | `EN-Default`, `EN-US`, `EN-GB`, `EN-India`, `EN-Australia`, `EN-Brazil` |
| Chinois  | `ZH` | `ZH`                                                                    |
| Japonais | `JP` | `JP`                                                                    |
| Coréen   | `KR` | `KR`                                                                    |
| Espagnol | `SP` | `SP`                                                                    |
| Français | `FR` | `FR`                                                                    |

***

## Conseils de performance

### 1. Benchmark GPU vs CPU

Performances de MeloTTS (RTF = facteur temps réel, plus bas = mieux) :

| Appareil      | RTF     | Remarques                            |
| ------------- | ------- | ------------------------------------ |
| CPU (8 cœurs) | \~0.3x  | Rapide, idéal pour une faible charge |
| RTX 3080      | \~0.05x | 20x plus rapide que le temps réel    |
| RTX 4090      | \~0.02x | 50x plus rapide que le temps réel    |
| A100          | \~0.01x | 100x plus rapide que le temps réel   |

### 2. Optimiser pour le débit

```python
# Désactiver le calcul des gradients pour l'inférence
import torch

with torch.no_grad():
    tts.tts_to_file(text, speaker_id, output_path)
```

### 3. Préchauffer le modèle

```python
# Exécuter une inférence de préchauffage pour charger les noyaux CUDA
tts.tts_to_file(
    text="warmup",
    speaker_id=speaker_id,
    output_path="/dev/null"
)
print("Modèle préchauffé, prêt pour une inférence rapide")
```

### 4. Ajuster la qualité audio par rapport à la vitesse

```python
# Plus rapide (qualité légèrement inférieure)
tts.tts_to_file(text, speaker_id, output_path, speed=1.2)

# Parole plus lente (meilleure articulation)
tts.tts_to_file(text, speaker_id, output_path, speed=0.8)
```

### 5. Efficacité mémoire

```python
# Libérer la mémoire GPU entre de grands lots
import gc
import torch

gc.collect()
torch.cuda.empty_cache()
```

***

## Dépannage

### Problème : `espeak-ng` introuvable

```bash
apt-get install -y espeak-ng
python3 -c "import phonemizer; print('phonemizer OK')"
```

### Problème : données NLTK manquantes

```bash
python3 -c "
import nltk
nltk.download('averaged_perceptron_tagger_eng')
nltk.download('punkt')
"
```

### Problème : le port 8888 entre en conflit avec Jupyter

MeloTTS utilise le port 8888 par défaut, ce qui entre en conflit avec Jupyter Notebook. Solutions :

```bash
# Option 1 : exécuter MeloTTS sur un autre port
python -m melo.api_server --host 0.0.0.0 --port 8889

# Option 2 : exécuter Jupyter sur un autre port
jupyter notebook --port 8890
```

### Problème : le texte chinois ne s'affiche pas correctement

```bash
# Installer la prise en charge de la langue chinoise
pip install jieba
apt-get install -y python3-opencc

# Test
python3 -c "from melo.api import TTS; t = TTS('ZH'); print('ZH OK')"
```

### Problème : l'extraction de l'image Docker échoue

```bash
# Construire depuis les sources à la place
git clone https://github.com/myshell-ai/MeloTTS.git
cd MeloTTS
pip install -e .
python3 -c "import nltk; nltk.download('averaged_perceptron_tagger_eng')"
```

### Problème : inférence lente sur GPU

```bash
# Vérifier que le GPU est bien utilisé
python3 -c "
import torch
from melo.api import TTS
tts = TTS('EN', device='cuda')
print(f'Device : {next(tts.model.parameters()).device}')
print(f'CUDA disponible : {torch.cuda.is_available()}')
"
```

***

## Recommandations GPU Clore.ai

MeloTTS est léger — il fonctionne bien sur CPU pour un faible volume et se met à l'échelle linéairement avec le calcul GPU. Vous n'avez pas besoin de matériel coûteux.

| GPU            | VRAM  | Prix Clore.ai                             | RTF (facteur temps réel)   | Capacité           |
| -------------- | ----- | ----------------------------------------- | -------------------------- | ------------------ |
| CPU uniquement | —     | \~0,02 $/h                                | \~0,3×                     | \~3 requêtes/min   |
| RTX 3090       | 24 Go | 0,07–0,21 $/h                             | \~0,02× (50× temps réel)   | \~100 requêtes/min |
| RTX 4090       | 24 Go | 0,14–0,42 $/h                             | \~0,01× (100× temps réel)  | \~200 requêtes/min |
| A100 40 Go     | 40 Go | [bare metal](https://clore.ai/bare-metal) | \~0,005× (200× temps réel) | \~400 requêtes/min |

{% hint style="info" %}
**Meilleur rapport qualité-prix pour les charges de travail TTS :** Une RTX 3090 à 0,07–0,21 $/h offre une vitesse TTS 50× temps réel. Pour une API de production servant des centaines d'utilisateurs, c'est amplement suffisant. Les instances CPU uniquement (0,07–0,21 $/h) conviennent très bien au développement et aux déploiements à faible trafic.
{% endhint %}

**Recommandation pour la production :** Pour une API TTS multilingue servant 10 à 50 utilisateurs simultanés, la RTX 3090 est le meilleur choix. Mieux vaut évoluer horizontalement (plusieurs instances) plutôt que de passer à une coûteuse A100 — MeloTTS ne bénéficie pas proportionnellement des GPU haut de gamme.

***

## Liens

* **GitHub**: <https://github.com/myshell-ai/MeloTTS>
* **Docker**: aucune image Docker Hub officielle — installez depuis [les sources GitHub](https://github.com/myshell-ai/MeloTTS) en utilisant `nvidia/cuda:12.8.1-devel-ubuntu22.04` image de base
* **Document**: <https://arxiv.org/abs/2406.06753>
* **Hugging Face**: <https://huggingface.co/myshell-ai/MeloTTS-English>
* **MyShell AI**: <https://myshell.ai>
* **la place de marché CLORE.AI**: <https://clore.ai/marketplace>


---

# Agent Instructions
This documentation is published with GitBook. GitBook is the documentation platform designed so that both humans and AI agents can read, navigate, and reason over technical content effectively. Learn more at gitbook.com.

## 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, and the optional `goal` query parameter:

```
GET https://docs.clore.ai/guides/guides_v2-fr/audio-et-voix/melotts.md?ask=<question>&goal=<endgoal>
```

`ask` is the immediate question: it should be specific, self-contained, and written in natural language.
`goal` is optional and describes the broader end goal you are ultimately trying to accomplish on behalf of the user. GitBook uses it to tailor the answer towards what is most useful for that goal.

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.