Voix et IA : Synthèse Vocale et Reconnaissance dans Vos Apps

Avez-vous remarqué que 27 % des recherches mobiles sont aujourd’hui vocales, et que ce chiffre double tous les deux ans ? La voix n’est plus une interface futuriste — c’est une attente des utilisateurs. Pourtant, la grande majorité des applications métier françaises n’intègrent aucune capacité vocale. Un technicien qui inspecte une pièce les mains occupées, un logisticien qui dicte un bon de livraison sans quitter des yeux le chariot, un opérateur de centre d’appels assisté en temps réel : la voix change radicalement l’ergonomie des applications professionnelles.

Ce guide technique vous explique comment construire des pipelines voix complets dans vos applications, avec des exemples Python fonctionnels.

Les Deux Piliers de la Voix IA

STT — Speech-to-Text : La Voix vers le Texte

Le STT transforme un signal audio en texte. Les usages professionnels sont nombreux : dictée de rapports, commandes vocales, transcription de réunions, sous-titrage automatique.

TTS — Text-to-Speech : Le Texte vers la Voix

Le TTS transforme du texte en parole synthétique. Applications : assistants vocaux, lecture de notifications, interfaces accessibles, voix de robots industriels.

Whisper — Le STT Open-Source de Référence

OpenAI Whisper est devenu le standard de facto pour la reconnaissance vocale. Ses avantages : multilingue (99 langues), précision excellente même sur le français avec accent, fonctionne complètement en local.

Installation et Usage de Base

pip install openai-whisper
# Ou la version optimisée faster-whisper (3-5x plus rapide)
pip install faster-whisper

from faster_whisper import WhisperModel

# Charger le modèle (small = bon compromis vitesse/précision pour le français)
model = WhisperModel("small", device="cpu", compute_type="int8")

# Transcrire un fichier audio
segments, info = model.transcribe(
    "reunion_comite.mp3",
    language="fr",
    beam_size=5,
    word_timestamps=True  # Timestamps par mot
)

print(f"Langue détectée : {info.language} ({info.language_probability:.0%})")
for segment in segments:
    print(f"[{segment.start:.1f}s → {segment.end:.1f}s] {segment.text}")

Transcription en Temps Réel

Pour les applications interactives (dictée, assistant vocal), il faut traiter le flux audio par chunks :

import pyaudio
import numpy as np
from faster_whisper import WhisperModel
import queue
import threading

class TranscripteurTempsReel:
    def __init__(self, modele="small"):
        self.model = WhisperModel(modele, device="cpu", compute_type="int8")
        self.audio_queue = queue.Queue()
        self.RATE = 16000
        self.CHUNK = 1024
        self.buffer = []
        self.silence_frames = 0
        self.SILENCE_SEUIL = 30  # ~2 secondes de silence

    def capturer_audio(self):
        p = pyaudio.PyAudio()
        stream = p.open(
            format=pyaudio.paInt16,
            channels=1,
            rate=self.RATE,
            input=True,
            frames_per_buffer=self.CHUNK
        )
        print("Écoute en cours... (Ctrl+C pour arrêter)")

        while True:
            data = stream.read(self.CHUNK, exception_on_overflow=False)
            audio_int16 = np.frombuffer(data, dtype=np.int16)
            self.audio_queue.put(audio_int16)

    def traiter_audio(self):
        while True:
            chunk = self.audio_queue.get()
            rms = np.sqrt(np.mean(chunk.astype(float)**2))

            if rms > 500:  # Présence de voix
                self.buffer.extend(chunk)
                self.silence_frames = 0
            else:
                self.silence_frames += 1

            # Transcrire après 2 secondes de silence
            if self.silence_frames >= self.SILENCE_SEUIL and len(self.buffer) > 0:
                audio_np = np.array(self.buffer, dtype=np.float32) / 32768.0
                segments, _ = self.model.transcribe(audio_np, language="fr")
                texte = " ".join(s.text for s in segments).strip()
                if texte:
                    print(f"Transcrit : {texte}")
                    self.on_texte(texte)
                self.buffer = []
                self.silence_frames = 0

    def on_texte(self, texte):
        # Surcharger cette méthode pour traiter le texte transcrit
        pass

    def demarrer(self):
        t_capture = threading.Thread(target=self.capturer_audio, daemon=True)
        t_traitement = threading.Thread(target=self.traiter_audio, daemon=True)
        t_capture.start()
        t_traitement.start()

TTS — Synthèse Vocale Haute Qualité

ElevenLabs — La Référence Commerciale

ElevenLabs produit des voix indiscernables du naturel, avec clonage de voix et contrôle émotionnel. Idéal pour les applications grand public ou les contenus marketing.

from elevenlabs import ElevenLabs, VoiceSettings

client = ElevenLabs(api_key="votre_clé_api")

audio = client.text_to_speech.convert(
    voice_id="pNInz6obpgDQGcFmaJgB",  # Adam - voix masculine française
    text="Bonjour, votre commande a bien été prise en compte.",
    model_id="eleven_multilingual_v2",
    voice_settings=VoiceSettings(
        stability=0.7,        # Stabilité de la voix (0-1)
        similarity_boost=0.8, # Fidélité au timbre original
        style=0.3,            # Expressivité
        use_speaker_boost=True
    )
)

with open("reponse.mp3", "wb") as f:
    for chunk in audio:
        f.write(chunk)

Edge-TTS — Gratuit et Multilingue

Microsoft Edge-TTS utilise les voix neurales de Azure, accessibles gratuitement via l’API non officielle. Qualité très correcte pour des usages internes.

import asyncio
import edge_tts

async def synthese_vocale(texte: str, fichier_sortie: str = "sortie.mp3"):
    # Voix française disponibles : fr-FR-HenriNeural, fr-FR-DeniseNeural
    communicate = edge_tts.Communicate(
        texte,
        voice="fr-FR-HenriNeural",
        rate="+10%",    # Vitesse (+/- pourcentage)
        volume="+0%"
    )
    await communicate.save(fichier_sortie)
    print(f"Audio généré : {fichier_sortie}")

asyncio.run(synthese_vocale(
    "La maintenance de la machine A3 est prévue demain à 14h30.",
    "notification_maintenance.mp3"
))

Coqui TTS — Open-Source, 100 % Local

Pour les environnements sans accès internet ou les données sensibles :

pip install TTS

from TTS.api import TTS

# Modèle français de qualité
tts = TTS("tts_models/fr/mai/tacotron2-DDC")
tts.tts_to_file(
    text="Anomalie détectée sur le convoyeur numéro deux.",
    file_path="alerte.wav"
)

VAD — Détection d’Activité Vocale

Le VAD (Voice Activity Detection) est le composant qui distingue la voix du silence et du bruit. Silero-VAD est aujourd’hui la référence open-source.

import torch
import torchaudio

# Charger Silero-VAD
model, utils = torch.hub.load(
    repo_or_dir='snakers4/silero-vad',
    model='silero_vad',
    force_reload=False
)
(get_speech_timestamps, _, read_audio, *_) = utils

audio = read_audio("enregistrement.wav", sampling_rate=16000)
timestamps = get_speech_timestamps(
    audio,
    model,
    threshold=0.5,        # Seuil de confiance
    sampling_rate=16000,
    min_speech_duration_ms=300,   # Ignorer les segments < 300ms
    min_silence_duration_ms=500   # Fusionner si silence < 500ms
)

for ts in timestamps:
    debut = ts['start'] / 16000  # Convertir en secondes
    fin = ts['end'] / 16000
    print(f"Voix détectée : {debut:.2f}s → {fin:.2f}s")

Détection de Mot-Clé (Wake Word)

Pour un assistant vocal activé par commande (type “OK Google”), openWakeWord est une solution légère et open-source :

import openwakeword
import pyaudio
import numpy as np

# Télécharger un modèle de mot-clé pré-entraîné ou créer le vôtre
oww_model = openwakeword.Model(
    wakeword_models=["hey_jarvis"],  # Modèle pré-entraîné
    inference_framework="onnx"
)

p = pyaudio.PyAudio()
mic = p.open(format=pyaudio.paInt16, channels=1, rate=16000, input=True)

print("En attente du mot-clé...")
while True:
    audio = np.frombuffer(mic.read(1280), dtype=np.int16)
    prediction = oww_model.predict(audio)

    for wake_word, score in prediction.items():
        if score > 0.5:
            print(f"Mot-clé détecté : {wake_word} (score: {score:.2f})")
            # Déclencher la capture et la transcription
            demarrer_ecoute_active()

Construire un Assistant Vocal Complet

Voici l’architecture d’un assistant vocal pour une application métier (ex: assistant de gestion de stock) :

import asyncio
from dataclasses import dataclass
from typing import Callable

@dataclass
class AssistantVocal:
    transcripteur: TranscripteurTempsReel
    llm_client: any  # Client OpenAI/Anthropic
    tts_func: Callable

    async def traiter_commande(self, texte_brut: str) -> str:
        # Appel LLM pour comprendre l'intention
        response = await self.llm_client.messages.create(
            model="claude-3-5-haiku-20241022",
            max_tokens=256,
            system="""Tu es un assistant de gestion de stock dans un entrepôt.
            Réponds de façon concise (1-2 phrases maximum) car ta réponse sera lue à voix haute.
            Commandes disponibles : vérifier stock, créer commande, localiser article.""",
            messages=[{"role": "user", "content": texte_brut}]
        )
        return response.content[0].text

    async def run(self):
        self.transcripteur.on_texte = self._on_texte_recu
        self.transcripteur.demarrer()
        print("Assistant vocal prêt.")
        await asyncio.sleep(float('inf'))  # Boucle principale

    async def _on_texte_recu(self, texte: str):
        print(f"Question : {texte}")
        reponse = await self.traiter_commande(texte)
        print(f"Réponse : {reponse}")
        await self.tts_func(reponse, "reponse_temp.mp3")
        jouer_audio("reponse_temp.mp3")

Considérations Pratiques pour un Déploiement PME

Traitement Local vs Cloud

Pour les données métier sensibles (conversations clients, données de production), le traitement local est souvent incontournable.

Optimiser pour le Français

Whisper gère très bien le français standard, mais quelques ajustements améliorent les performances :

segments, _ = model.transcribe(
    audio,
    language="fr",
    initial_prompt="Voici une transcription en français. Vocabulaire technique : GMAO, convoyeur, SKU, bon de livraison.",
    # Le prompt guide le modèle vers le vocabulaire métier attendu
    temperature=0.0,  # Déterministe = plus stable
    no_speech_threshold=0.6
)

Conclusion

La voix IA n’est plus complexe à intégrer. Whisper pour le STT, Edge-TTS ou ElevenLabs pour le TTS, Silero-VAD pour détecter la parole — la combinaison de ces outils open-source et APIs permet de construire un pipeline vocal professionnel en quelques journées de développement.

Les PME les plus agiles intègrent déjà la voix dans leurs applications métier : formulaires dictés, commandes vocales en atelier, notifications audio intelligentes. C’est une interface naturelle qui réduit la friction et augmente la productivité, particulièrement dans les environnements où les mains sont occupées.

Vous souhaitez intégrer la voix dans votre application métier ? Contactez-nous à contact@brio-novia.eu pour évaluer le potentiel d’un assistant vocal dans votre contexte spécifique.