Streaming en temps réel avec Whisper : guide pour une transcription vocale à faible latence (2026)

Streaming en temps réel avec Whisper : guide pour une transcription vocale à faible latence

OpenAI Whisper est un modèle de reconnaissance vocale open source offrant une grande précision et un support multilingue étendu. Même si Whisper n’a pas été conçu à l’origine pour le streaming, avec la bonne pipeline vous pouvez construire des systèmes de transcription voix-vers-texte en temps réel et à faible latence – idéals pour les sous-titres en direct, la transcription de réunions, les livestreams et les assistants vocaux.

Ce guide explique comment faire fonctionner Whisper en temps réel, en couvrant l’architecture, les techniques, les compromis et du code de référence.

Pourquoi le streaming est difficile

Whisper classique fonctionne sur des segments audio complets, pas sur des flux continus. Les défis incluent notamment :

Décodage incrémental – gestion de l’audio partiel
Faible latence – fournir les résultats rapidement
Artefacts aux frontières des chunks
Utilisation du GPU vs réactivité

Pour surmonter ces difficultés, vous utilisez des fenêtres glissantes + recouvrement et un buffering incrémental.

Vue d’ensemble de l’architecture

Le streaming en temps réel avec Whisper utilise généralement les composants suivants :

Audio Source → Audio Buffer → Segmenter → Whisper Inference → Post-processing → Consumer

Audio Source – microphone / navigateur / téléphonie
Segmenter – crée des chunks qui se recouvrent
Whisper Inference – modèles sur GPU/CPU
Post-processing – fusionner le texte avec les timestamps

Segmentation pour une faible latence

Vous recevez en continu de l’audio côté client. Pour éviter d’envoyer des blocs de données trop longs :

Longueur de fenêtre : 1–5 secondes
Recouvrement : 0,5–1 seconde
Taille du buffer : dépend des exigences de latence

Une fenêtre plus petite signifie une latence plus faible mais plus de surcharge.

Choisir les modèles pour le streaming

Model	VRAM	Latency	Accuracy
tiny	1–2 GB	⭐⭐⭐⭐	❌
base	2–4 GB	⭐⭐⭐	⭐⭐
small	4–8 GB	⭐⭐	⭐⭐⭐
medium	8–12 GB+	⭐	⭐⭐⭐⭐

Meilleur compromis pour le streaming : base ou small

Workflow de streaming de base (Pseudo Code)

import whisper
import sounddevice as sd
import numpy as np

model = whisper.load_model("small").to("cuda")

BUFFER = []
WINDOW = 3  # seconds
OVERLAP = 1  # seconds
RATE = 16000

def callback(indata, frames, time, status):
    global BUFFER
    BUFFER.extend(indata.flatten().tolist())
    # When buffer length > window, process
    if len(BUFFER) >= RATE * WINDOW:
        segment = BUFFER[:RATE * WINDOW]
        BUFFER = BUFFER[int(RATE * (WINDOW - OVERLAP)):]
        audio = np.array(segment)
        result = model.transcribe(audio, fp16=True)
        print("--- partial →", result["text"])

Ce flux affiche en continu des transcriptions partielles en réutilisant le recouvrement.

Gérer les recouvrements et l’assemblage (stitching)

Le recouvrement réduit les mots perdus aux frontières des segments.

Par exemple :

Segments :

0–3 s
2–5 s
4–7 s

Ensuite :

Supprimer les doublons de texte dans les zones de recouvrement
Ajuster les timestamps
Produire un flux continu

Temps réel dans le navigateur

Vous pouvez streamer l’audio depuis le navigateur à l’aide de WebRTC ou de la Web Audio API :

const stream = await navigator.mediaDevices.getUserMedia({ audio: true });
const processor = audioContext.createScriptProcessor(4096, 1, 1);
source.connect(processor);
processor.connect(audioContext.destination);

processor.onaudioprocess = (e) => {
  const chunk = e.inputBuffer.getChannelData(0);
  sendToServer(chunk); // WebSocket/Socket.io
};

Modèles de déploiement

☁️ Serverless (Cloud)

Les clients envoient l’audio via WebSockets
AWS Lambda (audio court) / serveur GPU
Whisper s’exécute sur une instance GPU
Scalabilité via auto-scaling

🖥️ Serveur GPU dédié

GPU persistant
Latence plus faible
Idéal pour des services 24/7

🌀 Hybride

L’edge capture l’audio + petit modèle de préfiltrage
Transfert vers la GPU pour la transcription complète

Réduction de la latence

🟡 1. Utiliser des fenêtres plus petites

Moins de batching → résultats partiels plus rapides

🔵 2. Recouvrir les buffers

Moins de mots perdus

🟢 3. Utiliser FP16 / BF16

Inférence plus rapide

🔴 4. Regrouper plusieurs utilisateurs

Si le serveur gère de nombreux flux, le batching améliore le débit global

Monitoring et métriques

Suivez :

Latence par segment
Word Error Rate (WER)
Utilisation du GPU
Précision partielle vs finale

Utilisez Prometheus / Grafana pour les tableaux de bord.

Compromis (trade-offs)

Goal	Tradeoff
Faible latence	Moins de contexte → précision réduite
Haute précision	Fenêtres plus grandes → latence plus élevée
Petit modèle	Plus rapide, moins précis
Grand modèle	Plus lent, plus précis

Exemples de cas d’usage

Sous-titres en direct pour les livestreams
Transcription de réunions ou de cours
Applications vocales interactives
Services pour conférences et webinars

Conclusion

Le streaming en temps réel avec Whisper est tout à fait possible – mais vous devez trouver le bon équilibre entre :

Taille de la fenêtre
Recouvrement
Taille du modèle
Performances du hardware

Avec le bon design, vous pouvez obtenir une transcription en streaming à faible latence et haute précision, adaptée aux environnements de production.