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

Tous les exemples peuvent être exécutés sur des serveurs GPU loués via la place de marché CLORE.AI.

---

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

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.

---

Déploiement rapide sur CLORE.AI

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.

1. Trouvez un serveur adapté

Accédez à la place de marché CLORE.AI 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) :

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 :

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

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 :

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

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

# 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

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)

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

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

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

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

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

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 :

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

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

# 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 le port 8888 par défaut, ce qui entre en conflit avec Jupyter Notebook. Solutions :

# 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

# 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 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	~0,005× (200× temps réel)	~400 requêtes/min

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.

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