Home
Login
KoljaB/RealtimeTTSPlease refer to the latest official releases for information GitHub Homepage

Une bibliothèque Python avancée de synthèse vocale en temps réel, prenant en charge plusieurs moteurs TTS, avec une faible latence et une sortie audio de haute qualité.

MITPython 3.2kKoljaBRealtimeTTS Last Updated: 2025-06-17

Présentation détaillée du projet RealtimeTTS

Aperçu du projet

RealtimeTTS est une bibliothèque Python avancée de synthèse vocale (TTS) en temps réel, conçue spécifiquement pour les applications en temps réel nécessitant une faible latence et une sortie audio de haute qualité. Cette bibliothèque est capable de convertir rapidement des flux de texte en une sortie audio de haute qualité avec une latence minimale, ce qui la rend idéale pour la construction d'assistants vocaux, de systèmes de dialogue IA et d'outils d'accessibilité.

Adresse du projet: https://github.com/KoljaB/RealtimeTTS

Caractéristiques principales

1. Traitement à faible latence

  • Conversion texte-parole quasi instantanée : Un flux de traitement optimisé assure une latence minimale.
  • Compatible avec les sorties LLM : Peut traiter directement les sorties en flux des grands modèles de langage.
  • Traitement en flux en temps réel : Prend en charge le traitement en temps réel au niveau des caractères et des phrases.

2. Sortie audio de haute qualité

  • Voix claire et naturelle : Génère une voix naturelle proche de la voix humaine.
  • Prise en charge de plusieurs formats audio : Prend en charge plusieurs formats de sortie audio.
  • Paramètres audio configurables : Fréquence d'échantillonnage, débit binaire, etc. réglables.

3. Prise en charge de plusieurs moteurs

RealtimeTTS prend en charge plusieurs moteurs TTS, offrant un large éventail de choix :

Moteurs cloud 🌐

  • OpenAIEngine: Service TTS d'OpenAI, offrant 6 voix de haute qualité.
  • AzureEngine: Service vocal Microsoft Azure, avec 500 000 caractères gratuits par mois.
  • ElevenlabsEngine: Qualité vocale haut de gamme, offrant de nombreuses options vocales.
  • GTTSEngine: TTS gratuit de Google Translate, ne nécessitant pas de GPU.
  • EdgeEngine: Service TTS gratuit de Microsoft Edge.

Moteurs locaux 🏠

  • CoquiEngine: TTS neuronal de haute qualité, prenant en charge le traitement local et le clonage vocal.
  • ParlerEngine: TTS neuronal local, adapté aux GPU haut de gamme.
  • SystemEngine: TTS système intégré, configuration rapide.
  • PiperEngine: Système TTS extrêmement rapide, pouvant même fonctionner sur un Raspberry Pi.
  • StyleTTS2Engine: Synthèse vocale stylisée.
  • KokoroEngine: Nouveau moteur prenant en charge plusieurs langues.
  • OrpheusEngine: Dernière option de moteur ajoutée.

4. Prise en charge multilingue

  • Prend en charge la synthèse vocale dans plusieurs langues.
  • Segmentation intelligente des phrases et détection de la langue.
  • Paramètres spécifiques à la langue configurables.

5. Robustesse et fiabilité

  • Mécanisme de basculement : Bascule automatiquement vers un moteur de secours lorsqu'un moteur rencontre un problème.
  • Garantie de fonctionnement continu : Assure une performance et une fiabilité constantes pour les cas d'utilisation critiques et professionnels.
  • Gestion des erreurs : Gestion des erreurs et mécanismes de récupération complets.

Installation

Installation recommandée (version complète)

pip install -U realtimetts[all]

Installation personnalisée

Vous pouvez choisir des supports de moteur spécifiques selon vos besoins :

# TTS système uniquement
pip install realtimetts[system]

# Support Azure
pip install realtimetts[azure]

# Combinaison de plusieurs moteurs
pip install realtimetts[azure,elevenlabs,openai]

Options d'installation disponibles

  • all: Installation complète, prend en charge tous les moteurs.
  • system: TTS système local (pyttsx3).
  • azure: Prise en charge du service vocal Azure.
  • elevenlabs: Intégration de l'API ElevenLabs.
  • openai: Service TTS d'OpenAI.
  • gtts: Google Text-to-Speech.
  • edge: Microsoft Edge TTS.
  • coqui: Moteur Coqui TTS.
  • minimal: Paquet de base uniquement (pour le développement de moteurs personnalisés).

Composants principaux

1. Traitement du flux de texte

  • Détection des limites de phrases : Prend en charge les tokenizer NLTK et Stanza.
  • Segmentation intelligente : Segmente le texte en fonction de la ponctuation et des règles linguistiques.
  • Traitement en flux : Prend en charge les itérateurs et les générateurs de caractères.

2. Gestion du flux audio

  • Lecture asynchrone : La méthode play_async() prend en charge la lecture non bloquante.
  • Lecture synchrone : La méthode play() est utilisée pour la lecture bloquante.
  • Contrôle du flux : Prend en charge les opérations de pause, de reprise et d'arrêt.

3. Système de rappel

Fournit de riches fonctions de rappel pour la surveillance et le contrôle :

  • on_text_stream_start(): Déclenché au début du flux de texte.
  • on_text_stream_stop(): Déclenché à la fin du flux de texte.
  • on_audio_stream_start(): Déclenché au début de la lecture audio.
  • on_audio_stream_stop(): Déclenché à la fin de la lecture audio.
  • on_character(): Déclenché lors du traitement de chaque caractère.
  • on_word(): Synchronisation temporelle au niveau du mot (prise en charge des moteurs Azure et Kokoro).

Exemples d'utilisation de base

Utilisation simple

from RealtimeTTS import TextToAudioStream, SystemEngine

# Créer un moteur et un flux
engine = SystemEngine()
stream = TextToAudioStream(engine)

# Entrer du texte et lire
stream.feed("Hello world! How are you today?")
stream.play_async()

Traitement de texte en flux

# Traiter une chaîne de caractères
stream.feed("Hello, this is a sentence.")

# Traiter un générateur (adapté aux sorties LLM)
def write(prompt: str):
    for chunk in openai.ChatCompletion.create(
        model="gpt-3.5-turbo",
        messages=[{"role": "user", "content": prompt}],
        stream=True
    ):
        if (text_chunk := chunk["choices"][0]["delta"].get("content")) is not None:
            yield text_chunk

text_stream = write("A three-sentence relaxing speech.")
stream.feed(text_stream)

# Traiter un itérateur de caractères
char_iterator = iter("Streaming this character by character.")
stream.feed(char_iterator)

Contrôle de la lecture

# Lecture asynchrone
stream.play_async()
while stream.is_playing():
    time.sleep(0.1)

# Lecture synchrone
stream.play()

# Opérations de contrôle
stream.pause()   # Pause
stream.resume()  # Reprise
stream.stop()    # Arrêt

Configuration avancée

Paramètres TextToAudioStream

stream = TextToAudioStream(
    engine=engine,                    # Moteur TTS
    on_text_stream_start=callback,    # Rappel au début du flux de texte
    on_audio_stream_start=callback,   # Rappel au début du flux audio
    output_device_index=None,         # Périphérique de sortie audio
    tokenizer="nltk",                # Sélection du tokenizer
    language="en",                   # Code de langue
    muted=False,                     # Muet ou non
    level=logging.WARNING            # Niveau de journalisation
)

Paramètres de lecture

stream.play(
    fast_sentence_fragment=True,      # Traitement rapide des fragments de phrases
    buffer_threshold_seconds=0.0,     # Seuil de mise en mémoire tampon
    minimum_sentence_length=10,       # Longueur minimale de la phrase
    log_synthesized_text=False,       # Enregistrer le texte synthétisé
    reset_generated_text=True,        # Réinitialiser le texte généré
    output_wavfile=None,             # Enregistrer dans un fichier WAV
    on_sentence_synthesized=callback, # Rappel à la fin de la synthèse de la phrase
    before_sentence_synthesized=callback, # Rappel avant la synthèse de la phrase
    on_audio_chunk=callback          # Rappel lorsqu'un bloc audio est prêt
)

Configuration spécifique au moteur

Moteur OpenAI

from RealtimeTTS import OpenAIEngine

engine = OpenAIEngine(
    api_key="your-api-key",  # Ou définir la variable d'environnement OPENAI_API_KEY
    voice="alloy",           # Facultatif: alloy, echo, fable, onyx, nova, shimmer
    model="tts-1"           # Ou tts-1-hd
)

Moteur Azure

from RealtimeTTS import AzureEngine

engine = AzureEngine(
    speech_key="your-speech-key",    # Ou définir la variable d'environnement AZURE_SPEECH_KEY
    service_region="your-region",    # Par exemple: "eastus"
    voice_name="en-US-AriaNeural"   # Nom de la voix Azure
)

Moteur Coqui (clonage vocal)

from RealtimeTTS import CoquiEngine

engine = CoquiEngine(
    voice="path/to/voice/sample.wav",  # Fichier source de clonage vocal
    language="en"                      # Code de langue
)

Fichiers de test

Le projet fournit de nombreux exemples de test :

  • simple_test.py: Démonstration basique "Hello World".
  • complex_test.py: Démonstration complète des fonctionnalités.
  • coqui_test.py: Test du moteur Coqui TTS local.
  • translator.py: Traduction multilingue en temps réel (nécessite l'installation de openai realtimestt).
  • openai_voice_interface.py: Interface API OpenAI à activation vocale.
  • advanced_talk.py: Système de dialogue avancé.
  • minimalistic_talkbot.py: Chatbot simple en 20 lignes de code.
  • test_callbacks.py: Fonctionnalités de rappel et tests de latence.

Support CUDA

Pour de meilleures performances, en particulier lors de l'utilisation de moteurs neuronaux locaux, il est recommandé d'installer le support CUDA :

Étapes d'installation

  1. Installer NVIDIA CUDA Toolkit (version 11.8 ou 12.X).
  2. Installer NVIDIA cuDNN.
  3. Installer ffmpeg.
  4. Installer PyTorch avec le support CUDA :
# CUDA 11.8
pip install torch==2.5.1+cu118 torchaudio==2.5.1 --index-url https://download.pytorch.org/whl/cu118

# CUDA 12.X
pip install torch==2.5.1+cu121 torchaudio==2.5.1 --index-url https://download.pytorch.org/whl/cu121

Cas d'utilisation

1. Assistants IA et chatbots

  • Réponse en temps réel aux requêtes des utilisateurs.
  • Expérience de conversation naturelle.
  • Prise en charge multilingue.

2. Outils d'accessibilité

  • Lecteurs d'écran.
  • Assistance aux personnes malvoyantes.
  • Outils d'aide à l'apprentissage.

3. Création de contenu

  • Production de podcasts.
  • Livres audio.
  • Contenu éducatif.

4. Service client

  • Systèmes de service client automatisés.
  • Robots téléphoniques.
  • Services de traduction en temps réel.

5. Jeux et divertissement

  • Voix dans le jeu.
  • Doublage de personnages virtuels.
  • Applications de divertissement interactives.

Écosystème du projet

RealtimeTTS fait partie d'un écosystème plus vaste :

  • RealtimeSTT: Bibliothèque de transcription vocale associée, dont la combinaison permet de créer un système complet de traitement audio en temps réel.
  • Linguflex: Projet original, un assistant IA open source puissant.
  • LocalAIVoiceChat: Système de dialogue vocal IA local basé sur le modèle Zephyr 7B.

Informations sur la licence

Le projet lui-même est open source, mais il est important de noter les restrictions de licence de chaque moteur :

  • Moteurs open source: SystemEngine, GTTSEngine (licence MIT).
  • Moteurs à restrictions commerciales: CoquiEngine, ElevenlabsEngine, AzureEngine (gratuit pour une utilisation non commerciale).
  • Services payants: OpenAI nécessite une clé API et un plan payant.

Configuration système requise

  • Version de Python: >= 3.9, < 3.13
  • Système d'exploitation: Windows, macOS, Linux
  • Dépendances: PyAudio, pyttsx3, pydub, etc.
  • Support GPU: Carte NVIDIA recommandée pour les moteurs neuronaux locaux.

Conclusion

RealtimeTTS est une bibliothèque de synthèse vocale en temps réel puissante et bien conçue, adaptée aux applications modernes nécessitant une synthèse vocale de haute qualité et à faible latence. Sa prise en charge de plusieurs moteurs, ses mécanismes robustes de gestion des erreurs et ses nombreuses options de configuration en font un choix idéal pour la construction d'applications vocales de qualité professionnelle. Que ce soit pour des projets personnels ou des applications d'entreprise, RealtimeTTS peut fournir une solution fiable et efficace.

Star History Chart