KittenTTS : Synthèse vocale de pointe en moins de 25 Mo fonctionnant sur CPU

La synthèse vocale (TTS) a toujours été une tâche lourde. La plupart des modèles de qualité professionnelle nécessitent un GPU, des centaines de mégaoctets de poids, et des pipelines d'inférence complexes. C'est pourquoi KittenTTS est une bouffée d'air frais : c'est une bibliothèque TTS open-source basée sur ONNX qui produit une synthèse vocale de haute qualité avec des modèles aussi petits que 25 Mo (quantifiés en int8) et fonctionne entièrement sur CPU. Aucun GPU requis.

Avec 15,3k étoiles sur GitHub et une communauté grandissante, KittenTTS prouve que la TTS déployable en périphérie est non seulement possible mais pratique. Dans cet article, nous allons explorer ce qui la rend spéciale, comment commencer, et comment l'intégrer dans vos propres projets.

Pourquoi la taille compte en TTS

La plupart des modèles TTS actuels sont massifs. Par exemple, certains systèmes TTS neuronaux populaires dépassent 1 Go et exigent un GPU compatible CUDA pour une inférence en temps réel. Cela les rend impraticables pour :

Les appareils périphériques comme le Raspberry Pi, les passerelles IoT ou les téléphones mobiles
Les fonctions sans serveur avec des limites de mémoire strictes
Les applications de bureau qui doivent être légères
Les applications en temps réel où la latence et l'utilisation des ressources comptent

KittenTTS renverse cela en offrant des modèles de 15M à 80M de paramètres, avec des tailles sur disque allant de 25 Mo à 80 Mo. La variante la plus petite, kitten-tts-nano int8, ne pèse que 25 Mo — assez petite pour être intégrée dans presque n'importe quelle application.

Construit sur ONNX pour l'efficacité CPU

KittenTTS est construit sur ONNX (Open Neural Network Exchange), ce qui signifie que les modèles sont optimisés pour l'inférence sur une variété de matériels. La bibliothèque utilise ONNX Runtime, qui est hautement optimisé pour l'exécution sur CPU. C'est un choix de conception clé : cela permet à KittenTTS de fonctionner efficacement sur des machines sans GPU, le rendant accessible à un public beaucoup plus large.

Vous pouvez même l'exécuter sur un GPU si vous le souhaitez, en installant les exigences GPU et en spécifiant backend="cuda". Mais le chemin CPU par défaut est impressionnant de rapidité.

Modèles disponibles

KittenTTS v0.8 propose quatre variantes de modèles :

Modèle	Paramètres	Taille	ID Hugging Face
`kitten-tts-mini`	80M	80 Mo	`KittenML/kitten-tts-mini-0.8`
`kitten-tts-micro`	40M	41 Mo	`KittenML/kitten-tts-micro-0.8`
`kitten-tts-nano`	15M	56 Mo	`KittenML/kitten-tts-nano-0.8`
`kitten-tts-nano` (int8)	15M	25 Mo	`KittenML/kitten-tts-nano-0.8-int8`

Note : Certains utilisateurs ont signalé des problèmes avec la variante int8. Si vous rencontrez des problèmes, les mainteneurs vous demandent d'ouvrir un problème sur GitHub.

Démarrage rapide

Commencer est simple. Tout d'abord, installez la bibliothèque via pip :

pip install https://github.com/KittenML/KittenTTS/releases/download/0.8.1/kittentts-0.8.1-py3-none-any.whl

Ensuite, générez votre premier échantillon vocal :

from kittentts import KittenTTS

model = KittenTTS("KittenML/kitten-tts-mini-0.8")
audio = model.generate("Ce modèle TTS de haute qualité fonctionne sans GPU.", voice="Jasper")

import soundfile as sf
sf.write("output.wav", audio, 24000)

C'est tout. Vous avez maintenant un fichier WAV avec une parole naturelle, générée entièrement sur CPU.

Utilisation avancée

KittenTTS vous donne un contrôle fin sur la synthèse :

# Ajuster la vitesse de parole (défaut : 1.0)
audio = model.generate("Bonjour le monde.", voice="Luna", speed=1.2)

# Enregistrer directement dans un fichier
model.generate_to_file("Bonjour le monde.", "output.wav", voice="Bruno", speed=0.9)

# Lister les voix disponibles
print(model.available_voices)
# ['Bella', 'Jasper', 'Luna', 'Bruno', 'Rosie', 'Hugo', 'Kiki', 'Leo']

Vous pouvez également utiliser un GPU si vous en avez un :

pip install -r requirements_gpu.txt

m = KittenTTS("KittenML/kitten-tts-mini-0.8", backend="cuda")

Normalisation du texte : un joyau caché

L'une des fonctionnalités les plus sous-estimées est le pipeline de normalisation du texte intégré. Il gère les nombres, les devises, les unités, les dates, les heures, et plus encore. C'est crucial pour produire une parole naturelle à partir de texte brut.

from kittentts import normalize_text

normalized = normalize_text("Dr. Rivera a payé 12,50 $ à 15h05.")
# "Docteur Rivera a payé douze dollars et cinquante cents à quinze heures cinq."

Vous pouvez également obtenir les étendues de caractères pour les segments normalisés, ce qui est utile pour l'alignement ou la mise en évidence :

result = normalize_text("Fig. 2", return_spans=True)
print(result.text)
print(result.spans)

C'est un énorme gain de temps, car la normalisation du texte est souvent un point douloureux dans les pipelines TTS.

Référence de l'API

`KittenTTS(model_name, cache_dir=None)`

Charge un modèle depuis le Hub Hugging Face.

model_name (str) : ID du dépôt Hugging Face. Défaut : "KittenML/kitten-tts-nano-0.8"
cache_dir (str, optionnel) : Répertoire local pour mettre en cache les fichiers de modèle téléchargés.

`model.generate(text, voice, speed, clean_text)`

Synthétise la parole à partir du texte, renvoyant un tableau NumPy d'échantillons audio à 24 kHz.

text (str) : Texte d'entrée à synthétiser
voice (str) : Nom de la voix (défaut : "expr-voice-5-m")
speed (float) : Multiplicateur de vitesse de parole (défaut : 1.0)
clean_text (bool) : Prétraiter le texte (développer les nombres, devises, etc.) (défaut : False)

`model.generate_to_file(text, output_path, voice, speed, sample_rate, clean_text)`

Synthétise la parole et écrit directement dans un fichier audio.

text (str) : Texte d'entrée à synthétiser
output_path (str) : Chemin pour enregistrer le fichier audio
voice (str) : Nom de la voix
speed (float) : Multiplicateur de vitesse de parole (défaut : 1.0)
sample_rate (int) : Taux d'échantillonnage audio en Hz (défaut : 24000)
clean_text (bool) : Prétraiter le texte (défaut : True)

`normalize_text(text, locale="en-US", return_spans=False)`

Normalise le texte pour TTS sans générer d'audio.

`model.available_voices`

Renvoie une liste des noms de voix disponibles : ['Bella', 'Jasper', 'Luna', 'Bruno', 'Rosie', 'Hugo', 'Kiki', 'Leo']

Configuration système requise

Système d'exploitation : Linux, macOS ou Windows
Python : 3.8 ou version ultérieure
Matériel : CPU uniquement (GPU optionnel)
Espace disque : 25-80 Mo selon la variante du modèle

Un environnement virtuel est recommandé pour éviter les conflits de dépendances.

Feuille de route et communauté

Le projet est activement développé. La feuille de route comprend :

Publication d'un moteur d'inférence optimisé
Publication d'un SDK mobile
Publication de modèles TTS de meilleure qualité
Publication de TTS multilingue
Publication de KittenASR (reconnaissance automatique de la parole)

Vous pouvez rejoindre la communauté sur Discord ou visiter kittenml.com. Pour un support commercial, y compris des voix personnalisées et des licences d'entreprise, contactez [email protected].

Licence

KittenTTS est sous licence Apache License 2.0, qui est permissive pour un usage personnel et commercial.

Réflexions finales

KittenTTS est une réalisation remarquable dans le domaine de la TTS. Elle prouve que vous n'avez pas besoin d'un cluster GPU pour générer une parole naturelle. Avec sa petite empreinte, son inférence conviviale sur CPU et son API propre, c'est un excellent choix pour les applications périphériques, les logiciels de bureau et tout projet où les ressources sont limitées.

Si vous construisez un assistant vocal, un outil d'accessibilité, ou si vous voulez simplement ajouter de la parole à votre application sans surcharge, essayez KittenTTS. Le modèle de 25 Mo change la donne.

Essayez la démo en direct sur Hugging Face Spaces et écoutez par vous-même.

Source

KittenML/KittenTTS : Modèle TTS de pointe en moins de 25 Mo 😻