# MeloTTS

MeloTTS est une bibliothèque de synthèse vocale multilingue et de haute qualité développée par **MyShell AI**. Elle offre une synthèse vocale rapide et à l'apparence naturelle dans plusieurs langues et variantes d'accent 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 la parole significativement plus vite que le temps réel même sur CPU — tout en conservant une qualité audio élevée 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 que le temps réel sur CPU, fulgurant sur GPU
* 🌍 **Multilingue** — 6 langues avec variantes d'accent pour l'anglais
* 🐳 **Prêt pour Docker** — image Docker officielle disponible
* 🔌 **API REST** — API HTTP pour l'intégration dans n'importe quelle application
* 📱 **De niveau 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 [CLORE.AI Marketplace](https://clore.ai/marketplace).
{% endhint %}

***

## Exigences 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                   |
| OS        | 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 particulièrement efficace — il fonctionne bien sur CPU pour les requêtes individuelles et profite grandement 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 n'a pas d'image Docker préconstruite officielle sur Docker Hub (`myshell-ai/melotts` n'existe pas). L'approche recommandée est d'utiliser une image de base NVIDIA CUDA et d'installer MeloTTS via pip depuis le dépôt GitHub officiel.
{% endhint %}

### 1. Trouvez un serveur adapté

Aller à [CLORE.AI Marketplace](https://clore.ai/marketplace) et filtrez par :

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

### 2. Configurez votre déploiement

**Image Docker :**

```
nvidia/cuda:12.1.0-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 SSH sur le 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édez à l'API

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

Tester avec :

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

***

## Configuration étape par étape

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

```bash
ssh root@<votre-ip-serveur-clore> -p <port-ssh>
```

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

Étant donné que MeloTTS n'a pas d'image préconstruite sur Docker Hub, utilisez une base NVIDIA CUDA et installez MeloTTS depuis les sources :

```bash
# Exécuter un conteneur CUDA et installer MeloTTS à l'intérieur
docker run -d \
  --name melotts \
  --gpus all \
  -p 8888:8888 \
  -v /workspace/melotts/outputs:/app/outputs \
  -e NVIDIA_VISIBLE_DEVICES=all \
  nvidia/cuda:12.1.0-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 depuis les 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 fonctionne

```bash
# Vérifiez les logs 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.1.0-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 depuis 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 basique (Python)

```python
from melo.api import TTS

# Initialiser la TTS anglaise
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 locuteurs 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="Welcome to Clore.ai, your GPU cloud marketplace for AI workloads. Rent powerful GPUs in 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', "GPU computing has transformed artificial intelligence research and development."),
    ('EN', 'EN-GB', "The United Kingdom leads Europe in AI investment and innovation."),
    ('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://<votre-ip-serveur-clore> :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 échantillons
samples = [
    ("Hello, this is MeloTTS running on Clore.ai GPU servers.", "EN", "EN-US"),
    ("This is the British English accent variant.", "EN", "EN-GB"),
    ("Let me demonstrate the Indian English accent.", "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 à grande 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"This is sentence number {i}. It demonstrates fast batch processing with MeloTTS on Clore.ai GPU infrastructure."
    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 | Taux : {(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 mixte chinois-anglais

```python
from melo.api import TTS

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

# Texte en langue 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 la clarté
    )
    print(f"Généré : {output_file}")
    print(f"  Texte : {text[:60]}...")
```

***

## Configuration

### Configuration Docker Compose

Étant donné que MeloTTS n'a pas d'image officielle sur Docker Hub, utilisez l'image de base NVIDIA CUDA et installez MeloTTS depuis les sources au démarrage :

```yaml
version: '3.8'

services:
  melotts :
    image : nvidia/cuda:12.1.0-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"]
      intervalle : 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 (utiliser `0.0.0.0` pour public) |
| `--port`    | `8888`      | Port du serveur API                                 |
| `--workers` | `1`         | Nombre de processus workers                         |
| `--device`  | `auto`      | `cuda`, `cpu`, ou `auto`                            |

### Langues et locuteurs pris en charge

| Langue   | Code | Identifiants des locuteurs                                              |
| -------- | ---- | ----------------------------------------------------------------------- |
| 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

Performance de MeloTTS (RTF = Facteur temps réel, plus bas est meilleur) :

| Périphérique   | RTF     | Remarques                          |
| -------------- | ------- | ---------------------------------- |
| CPU (8 coeurs) | \~0.3x  | Rapide, idéal pour 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 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 d'échauffement pour charger les kernels 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 vs 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 par défaut le port 8888, qui entre en conflit avec Jupyter Notebook. Solutions :

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

# Option 2 : Exécuter Jupyter sur un port différent
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 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 de faibles volumes et évolue linéairement avec la puissance 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 req/min   |
| RTX 3090       | 24 Go | \~0,12 $/h    | \~0.02× (50× temps réel)   | \~100 req/min |
| RTX 4090       | 24 Go | \~0,70 $/h    | \~0.01× (100× temps réel)  | \~200 req/min |
| A100 40GB      | 40 Go | \~1,20 $/h    | \~0.005× (200× temps réel) | \~400 req/min |

{% hint style="info" %}
**Meilleur rapport qualité/prix pour les charges TTS :** RTX 3090 à \~\~0,12 $/h offre une vitesse TTS de 50× temps réel. Pour une API de production servant des centaines d'utilisateurs, cela est plus que suffisant. Les instances sans GPU (\~\~0,02 $/h) conviennent pour le développement et les 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 compromis. Mettez à l'échelle horizontalement (plus d'instances) plutôt que d'upgrader vers des GPU coûteux A100 — MeloTTS n'en bénéficie pas proportionnellement.

***

## Liens

* **GitHub**: <https://github.com/myshell-ai/MeloTTS>
* **Docker**: Pas d'image Docker Hub officielle — installer depuis [Source GitHub](https://github.com/myshell-ai/MeloTTS) en utilisant `nvidia/cuda:12.1.0-devel-ubuntu22.04` image de base
* **Article**: <https://arxiv.org/abs/2406.06753>
* **Hugging Face**: <https://huggingface.co/myshell-ai/MeloTTS-English>
* **MyShell AI**: <https://myshell.ai>
* **CLORE.AI Marketplace**: <https://clore.ai/marketplace>