MOSS-TTS (CPU uniquement, 100M)

Exécutez MOSS-TTS — une synthèse vocale multilingue ultra-légère de 100M de paramètres, d'abord CPU, d'OpenMOSS (MOSI.AI + Fudan NLP) sur Clore.ai.

MOSS-TTS est une famille open source de génération vocale de OpenMOSS (Shanghai Innovation Institution, en collaboration avec Fudan NLP et MOSI.AI, dirigée par le professeur Xipeng Qiu). Le fleuron MOSS-TTS-Nano n’est que 100 M de paramètres, s’exécute en temps réel sur un CPU à 4 cœurs sans GPU, produit stéréo 48 kHz, et prend en charge 20 langues avec clonage de voix zero-shot. La famille complète monte jusqu’à 8B pour les dialogues multi-locuteurs, la conception de voix et la génération d’effets sonores.

Publié : 10 avril 2026 (Nano) · build ONNX CPU 17 avril 2026 · Licence : Apache 2.0

Si Kokoro détient la niche occidentale-anglaise de 82 M de paramètres, MOSS-TTS-Nano détient la niche multilingue orientée CPU : même philosophie de petit modèle, mais stéréo 48 kHz, 20 langues, clonage vocal et un chemin ONNX/GGUF sans Torch. Pour tous ceux qui veulent déployer la TTS sans payer pour un GPU — c’est le modèle qu’il faut.

Famille MOSS-TTS

Modèle

Taille

VRAM

Idéal pour

MOSS-TTS-Nano-100M

100 M

0 Go (CPU, 4 cœurs)

Temps réel, périphérie, IVR, sur l’appareil

MOSS-TTS-Nano-100M-ONNX

100 M

0 Go (CPU)

Service de production sans Torch

MOSS-TTS-GGUF

100 M (Q4_K_M)

0 Go (CPU)

déploiements de type llama.cpp

MOSS-TTS-Local-Transformer

1,7B

4 Go

GPU léger, forte qualité objective

MOSS-TTS-Realtime

1,7B

4 Go

Agents vocaux à plusieurs tours, TTFB de 180 ms

MOSS-VoiceGenerator

1,7B

4 Go

Conception de voix à partir d’invites textuelles

MOSS-TTSD-v1.0

8 Go

Dialogue multi-locuteurs, longs podcasts

MOSS-SoundEffect

8 Go

Génération d’effets sonores avec contrôle de la durée

Spécifications clés

Spécification

Valeur

Développeur

Équipe OpenMOSS · MOSI.AI · Fudan NLP Lab

Architecture

Autoregressif (Audio Tokenizer + LLM)

Taux d’échantillonnage

48 kHz, stéréo

Langues

20 (zh, en, de, es, fr, ja, it, hu, ko, ru, fa, ar, pl, pt, cs, da, sv, el, tr, +1)

Clonage de voix

Zero-shot à partir d’une référence d’environ 3 s

Flux continu

Oui — décodage par blocs sur CPU

Licence

Apache 2.0

HuggingFace

OpenMOSS-Team

GitHub

OpenMOSS/MOSS-TTS-Nano · OpenMOSS/MOSS-TTS

Pourquoi MOSS-TTS ?

Déploiement sans GPU — Nano s’exécute sur 4 cœurs CPU, sans CUDA ni Triton
Sortie stéréo 48 kHz — qualité de diffusion, rare dans les modèles de moins de 100 M
20 langues — couverture plus large que Kokoro (~5) à taille comparable
Clonage vocal zéro-shot à partir d’une référence audio d’environ 3 s
Chemins ONNX/GGUF sans Torch — déployez avec un binaire de 200 Mo
La famille passe à l’échelle — même tokenizer/API de Nano à 8B TTSD
Apache 2.0 — usage commercial, sans contraintes
Issu d’une vraie recherche — Fudan NLP + MOSI.AI, pas un projet amateur

Exigences

Composant

Minimum (Nano, CPU)

Recommandé (Nano, CPU)

Famille complète (GPU)

CPU

4 cœurs (x86_64 / ARM64)

8 cœurs

RAM

4 Go

8 Go

16 Go

GPU

— (non requis)

— (facultatif)

RTX 3060 12 Go+

VRAM

0 Go

4–8 Go

Disque

1 Go

2 Go

10 Go (8B + dépendances)

Python

3.12

Conseil Clore.ai : Nano n’a littéralement pas besoin de GPU. Si vous avez déjà une machine Clore pour d’autres tâches, la TTS est gratuite. Si vous voulez un GPU pour du traitement par lots ou pour exécuter les variantes 1.7B/8B, un RTX 3060 12 Go (0,03–0,07 $/h) est excessif.

Option A — installation Python + inférence rapide

conda create -n moss-tts-nano python=3.12 -y
conda activate moss-tts-nano

git clone https://github.com/OpenMOSS/MOSS-TTS-Nano.git
cd MOSS-TTS-Nano
pip install -r requirements.txt
pip install -e .

# Si pynini casse avec pip, utilisez conda-forge :
conda install -c conda-forge pynini=2.1.6.post1 -y

Inférence à partir de l’audio de référence + texte cible :

python infer.py \
  --prompt-audio-path assets/audio/en_1.wav \
  --text "Bienvenue sur Clore.ai — la place de marché GPU décentralisée."
# Sortie : generated_audio/infer_output.wav  (stéréo 48 kHz)

Ou via le point d’entrée CLI :

moss-tts-nano generate \
  --prompt-speech ref.wav \
  --text "Bonjour depuis MOSS-TTS Nano exécuté sur CPU."

Démo web (Gradio) :

python app.py
# → http://127.0.0.1:18083

Option B — Docker (CPU et GPU)

CPU uniquement (Nano, image d’environ 1 Go) :

FROM python:3.12-slim
RUN apt-get update && apt-get install -y git build-essential \
    && rm -rf /var/lib/apt/lists/*
WORKDIR /app
RUN git clone https://github.com/OpenMOSS/MOSS-TTS-Nano.git . \
    && pip install -r requirements.txt && pip install -e .
EXPOSE 18083
CMD ["python", "app.py"]

docker build -t moss-tts-nano-cpu .
docker run --rm -p 18083:18083 moss-tts-nano-cpu

Variante GPU (pour Realtime / TTSD / SoundEffect) :

docker run --gpus all -p 18083:18083 \
  pytorch/pytorch:2.11.0-cuda12.8-cudnn9-runtime \
  bash -c "git clone https://github.com/OpenMOSS/MOSS-TTS.git /app \
           && cd /app \
           && pip install --extra-index-url https://download.pytorch.org/whl/cu128 -e '.[torch-runtime]' \
           && python app.py"

Option C — clonage vocal zero-shot (référence de 3 s)

MOSS-TTS-Nano clone une voix à partir d’un court extrait de référence et gère la synthèse longue via un découpage automatique.

from moss_tts_nano import MossTTSNano
import soundfile as sf

model = MossTTSNano.from_pretrained("OpenMOSS-Team/MOSS-TTS-Nano-100M")

# Cloner la voix à partir de n’importe quel extrait propre de 3 à 10 s
audio, sr = model.synthesize(
    text="This is my cloned voice narrating a Clore.ai audiobook chapter.",
    prompt_audio_path="speaker_ref_3s.wav",
    language="en",
)
sf.write("cloned.wav", audio, sr)  # stéréo 48 kHz

Conseils de qualité (portés du guide XTTS — les mêmes principes s’appliquent) :

Utilisez 3 à 10 s de référence propre (pas de musique de fond, pas de réverbération de pièce)
Faites correspondre la langue de la référence et du texte cible lorsque c’est possible
Normalisez et coupez le silence avant l’entrée (librosa.effects.trim)
Pour une narration longue et cohérente, réutilisez la même référence à travers les appels

Option D — GGUF sur llama.cpp-audio / ONNX sans Torch

Pour les machines edge, les backends mobiles, ou partout où vous ne voulez pas de PyTorch :

# Cloner le dépôt principal avec les extras sans Torch
git clone https://github.com/OpenMOSS/MOSS-TTS.git
cd MOSS-TTS
pip install -e ".[llama-cpp-onnx]"

# Récupérer les poids quantifiés GGUF (Q4_K_M)
huggingface-cli download OpenMOSS-Team/MOSS-TTS-GGUF --local-dir weights/

# Ou build ONNX pur (sans Torch du tout)
huggingface-cli download OpenMOSS-Team/MOSS-TTS-Nano-100M-ONNX --local-dir weights-onnx/

Ce chemin fonctionne avec des outils compatibles llama.cpp — idéal pour Raspberry Pi, Android ou des fonctions serverless où un binaire de 200 Mo compte.

Recommandations GPU Clore.ai

Vous n’avez pas besoin d’un GPU pour Nano. C’est tout l’intérêt. Mais si vous voulez générer par lots ou exécuter les frères et sœurs plus grands :

GPU

VRAM

Convient à

Prix Clore (approx.)

Instance CPU uniquement

—

Nano, Nano-ONNX, GGUF

à partir de 0,01 $/h

RTX 3060 12 Go

12 Go

Nano + Local-Transformer + Realtime

à partir de 0,03–0,07 $/h

RTX 3090 24 Go

24 Go

TTSD-v1.0 complet (8B), service par lots

à partir de 0,07–0,21 $/h

RTX 4090 24 Go

24 Go

TTSD + SoundEffect en parallèle

à partir de 0,14–0,42 $/h

Pour 90 % des charges TTS de production — agents vocaux, IVR, narration — une machine Clore.ai CPU-only est littéralement le déploiement viable le moins cher. Louez-la, lancez MOSS-TTS-Nano, oubliez les factures GPU.

Cas d’usage

Livres audio — narration longue avec voix clonée cohérente, découpage automatique
Agents vocaux — TTFB inférieur à la seconde sur la variante Realtime pour l’IA conversationnelle
IVR / systèmes téléphoniques — déploiement CPU-only, stéréo 48 kHz, 20 langues
PNJ de jeu — assez léger pour être intégré dans un client de jeu, conception de voix par personnage
Doublage — clonage multilingue pour les pipelines de localisation
Génération de podcasts — MOSS-TTSD-v1.0 gère nativement les dialogues multi-locuteurs
Effets sonores — MOSS-SoundEffect ajoute des effets contrôlés par la durée au pipeline

Benchmarks / Qualité

MOSS-TTSD-v1.0 a surpassé Doubao et Gemini 2.5-pro sur des évaluations subjectives de dialogues multi-locuteurs
Nano atteint un facteur temps réel < 1,0 sur 4 cœurs CPU (c.-à-d. plus rapide que la lecture)
Realtime la variante rapporte un time-to-first-byte d’environ 180 ms pour un usage conversationnel
La sortie stéréo 48 kHz représente une nette amélioration par rapport aux concurrents mono 24 kHz à ce budget de paramètres

Dépannage

Problème

Solution

pynini l’installation échoue via pip

conda install -c conda-forge pynini=2.1.6.post1 -y puis réinstallez WeTextProcessing

Audio saccadé sur CPU

Assurez-vous d’avoir 4 cœurs physiques ou plus ; désactivez la sursouscription SMT/HT ; utilisez la build ONNX

La voix clonée sonne mal

La référence doit durer 3 à 10 s, être propre, à locuteur unique, et correspondre à la langue

OOM sur TTSD-v1.0

Utilisez FP16 (model.half()) ou passez au Local-Transformer 1,7B

Le téléchargement du modèle se bloque

Définissez HF_HUB_ENABLE_HF_TRANSFER=1 et réessayez

Premier lancement lent

La première inférence compile les kernels / télécharge ~400 Mo de poids — les exécutions suivantes sont rapides

Torch entre en conflit avec d’autres modèles

Utilisez le [llama-cpp-onnx] extras pour un environnement sans Torch

Étapes suivantes

Kokoro TTS — l’alternative anglophone de 82 M si vous n’avez pas besoin de multilingue
Voxtral TTS — modèle Mistral de 4B, 9 langues, nécessite un GPU mais a un plafond plus élevé
XTTS (Coqui) — clonage vocal sur 17 langues, GPU uniquement, plus volumineux
Whisper Transcription — associez MOSS-TTS à Whisper pour des pipelines vocaux complets
Louez un GPU (ou un CPU) sur la place de marché Clore.ai

Dernière mise à jour : 20 avril 2026

PrécédentVoxtral TTS

SuivantAperçu

Mis à jour il y a 1 mois

Ce contenu vous a-t-il été utile ?