AI Hub Icon
AIBit Découvrez des projets open source
Accueil / Projets Open Source Pratiques

Pocket‑TTS : Bibliothèque de synthèse vocale légère à usage CPU uniquement

January 19, 2026
Catégorie: Projets Open Source Pratiques
Étiquettes:
Open Source Python tts Voice Cloning CPU

Pocket‑TTS : Bibliothèque de synthèse vocale légère à usage CPU uniquement

La synthèse vocale (TTS) est devenue un composant essentiel dans des applications allant des assistants numériques aux outils d'accessibilité. Les solutions typiques exigent des GPU puissants ou reposent sur des API web payantes, ce qui les rend impraticables pour les dispositifs périphériques ou les déploiements soucieux de la vie privée. Pocket‑TTS résout ce problème en offrant une expérience TTS de haute qualité et faible latence qui s'exécute entièrement sur le processeur.

TL;DR – Pocket‑TTS est un modèle de 100 M paramètres qui effectue la synthèse vocale sur 2 cœurs CPU, atteignant une latence de ~200 ms pour le premier segment et une vitesse ~6× en temps réel sur un MacBook Air M4. Installez avec pip install pocket-tts ou uv add pocket-tts et appelez pocket-tts generate depuis la ligne de commande ou TTSModel.load_model() depuis Python.

Table des matières

Pourquoi Pocket‑TTS ?

Fonctionnalité Pocket‑TTS Concurrent (Typique)
Taille du modèle 100 M paramètres 700 M–1 B+
Temps d'exécution 2 cœurs CPU GPU ou TPU
Latence ~200 ms 1–2 s
Déploiement pip/uv install Docker + GPU, API web
Bibliothèque vocale 8 voix préconstruites + entrée wav Limitée ou inexistante
Langage Anglais uniquement (bientôt multi‑langue) Multi‑langue

Pocket‑TTS a été conçu autour de l’idée d’une TTS qui tient dans votre poche. Les aspects suivants le distinguent :

  1. CPU‑unique – Il fonctionne sur tout processeur moderne, sans nécessiter CUDA ou GPU.
  2. Empreinte réduite – Un modèle transformer de 100 M paramètres (~30 MB) garde le dépôt léger.
  3. Streaming audio – Vous pouvez diffuser l’audio en temps réel pendant que le modèle continue de générer.
  4. Support du clonage vocal – Fournir un fichier wav pour générer un état vocal adapté à cet audio.
  5. CLI & API HTTP – Des commandes en ligne de commande simples et un serveur local rapide pour l’intégration.

Le résultat est une bibliothèque prête à l’emploi qui fonctionne dès le départ sur ordinateurs portables, SBCs de type Raspberry Pi et puces d’inférence edge.

Commencer

Pocket‑TTS est un paquet pure‑Python qui nécessite PyTorch 2.5+. Le moyen le plus simple de l’obtenir est via uv (recommandé pour des environnements isolés) ou pip.

Installation avec uv

uv add pocket-tts
uvx pocket-tts generate \"Hello World!\"

uvx exécute des commandes dans un environnement temporaire ; c’est idéal pour des tests rapides.

Installation avec pip

pip install --upgrade pocket-tts
pocket-tts generate \"Hello World!\"

Le exemple ci‑dessus téléchargera la voix par défaut (alba) et écrira un fichier tts_output.wav.

Exemple Colab

!pip install pocket-tts

from pocket_tts import TTSModel
import scipy.io.wavfile as wav

model = TTSModel.load_model()
voice_state = model.get_state_for_audio_prompt("alba")
audio = model.generate_audio(voice_state, "Hello from Colab!")
wav.write("output.wav", model.sample_rate, audio.cpu().numpy())

Le premier chargement du modèle peut prendre ~30 s, mais les appels suivants restent en mémoire.

Clonage vocal

Pocket‑TTS prend en charge le clonage vocal en acceptant un fichier wav local ou un wav hébergé par Hugging Face.

pocket-tts generate "This is my cloned voice" --voice ./my_voice.wav

Vous pouvez également fournir une URL Hugging Face :

pocket-tts generate "I love Hugging Face" \
  --voice "hf://kyutai/tts-voices/expresso/ex01-ex02_default_001_channel2_198s.wav"

Le fichier vocal doit être ~16 kHz, 16‑bit PCM. Dans le dépôt, vous trouverez une liste d’exemples de voix dans le fichier voice_catalog.md.

Gestion des états vocaux

Si vous avez besoin d’utiliser plusieurs voix sur une courte période, gardez les états vocaux en mémoire :

model = TTSModel.load_model()
voice_alba = model.get_state_for_audio_prompt("alba")
voice_marius = model.get_state_for_audio_prompt("marius")
# Reutiliser sans réinitialiser le modèle

CLI & Serveur HTTP

CLI

Pocket‑TTS embarque deux commandes de haut niveau :

  • generate – Génère un fichier wav à partir de texte.
  • serve – Lance un serveur local FastAPI HTTP.

Lancez le serveur et visitez l’interface web :

uvx pocket-tts serve  # ou pocket-tts serve si pip

Ouvrez http://localhost:8000 – l’interface intégrée au navigateur est réactive et conserve le modèle en mémoire pour une vitesse ~6× en temps réel.

API HTTP

L’API expose un point d’accès /generate acceptant une charge utile JSON POST :

{ "text": "Hello, world!", "voice": "alba" }

Vous pouvez l’appeler avec curl :

curl -X POST http://localhost:8000/generate \
  -H "Content-Type: application/json" \
  -d '{"text":"Hello","voice":"alba"}' \
  --output out.wav

Le serveur diffuse également l’audio en morceaux si vous définissez stream=true dans la requête.

Intégration de l'API Python

Lorsqu’on intègre du TTS dans un service, on utilise généralement la bibliothèque directement.

from pocket_tts import TTSModel
import torch

model = TTSModel.load_model()
voice_state = model.get_state_for_audio_prompt("alba")
text = "Complex sentence that may be very long ..."

# Audio est un tenseur torch 1‑D
audio = model.generate_audio(voice_state, text)
# Sauvegarder ou diffuser
torch.save(audio, "demo.pt")

L'API est intentionnellement légère : le modèle et les états vocaux sont des objets PyTorch normaux. Conservez-les en cache si vous rejouez les mêmes voix ou l’exécutez dans un environnement asynchrone.

Performances & Évaluations

Le fichier docs/tech_report.md du dépôt fournit une analyse approfondie, mais les points clés sont :

  • Latence – Premier segment ~200 ms sur un Apple M4 ; ~350 ms sur Intel i7‑12700K.
  • Vitesse – Génère 6× en temps réel sur les mêmes processeurs.
  • Utilisation CPU – Utilise seulement 2 cœurs ; la mémoire reste sous 2 GB.
  • Taille du modèle – 100 M paramètres ; 30 MB sur le disque, ~120 MB VRAM lorsqu’il est chargé.

La nature de streaming audio signifie que vous pouvez commencer la lecture avant que la synthèse ne soit terminée, ce qui est crucial pour les applications interactives.

Étendre & Contribuer

Pocket‑TTS est open‑source sous licence MIT. Les contributions sont bienvenues dans plusieurs domaines :

  1. Nouvelles voix – Clonez le modèle, ajustez le voice_catalog.md et poussez une PR.
  2. Support multilingue – Portez le point de contrôle anglais actuel.
  3. Quantification – Ajoutez des variantes int8 ou float16 pour un temps de fonctionnement encore plus réduit.
  4. WebAssembly – Intégrez la version Rust Candle pour exécuter dans les navigateurs.

Lignes directrices de développement : - Lancer les tests : pytest. - Générer les docs : mkdocs build. - Le CI utilise uv pour installer les dépendances.

Pour des instructions détaillées, lisez CONTRIBUTING.md.

Licence & Notes d'utilisation

Pocket‑TTS est publié sous licence MIT. Les actifs vocaux sont soumis à des licences individuelles (voir voice_catalog.md).

Avertissement – Le dépôt interdit explicitement tout abus tel qu'une usurpation, désinformation ou contenu abusif. Veillez toujours à une utilisation légale et éthique.

TL;DR

Pocket‑TTS est une bibliothèque TTS légère et adaptée au CPU qui fonctionne sur tout processeur moderne. Installez, générez de l’audio ou servez via HTTP en quelques minutes. Pour les développeurs recherchant un TTS rapide, open‑source et sans dépendances GPU, Pocket‑TTS est un excellent choix.

Ressources complémentaires

Original Article: Voir l’original

Partager cet article