MeloTTS

Exécuter MeloTTS 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 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

Tous les exemples peuvent être exécutés sur des serveurs GPU loués via CLORE.AI Marketplace.

---

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

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.

---

Déploiement rapide sur CLORE.AI

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.

1. Trouvez un serveur adapté

Aller à 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) :

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 :

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

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 :

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

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

# 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

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)

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

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

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

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

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

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 :

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

# 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

# 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

# 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

# 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

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

Problème : données NLTK manquantes

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 :

# 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

# 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

# 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

# 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

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.

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