Přejít na hlavní obsah
Čeština— Vyberte jazyk
Menu

Cas d'usage de la transcription en temps réel

Lekce 13 z 16 Aktualizováno 3. listopadu 2026 Vývojář
Na této stránce
  1. Quatre applications de streaming concrètes
  2. Sous-titrage en direct
  3. Assistant vocal interactif
  4. Dictée vocale avec sauvegarde automatique
  5. Transcription de conférence avec métadonnées
  6. Klíčové poznatky

Cours mis à jour le 3 novembre 2026 pour Voxtral 3, basé sur le guide Migrate from Voxtral 2 de Mistral : les modèles Voxtral 2 (voxtral-mini-2602, voxtral-mini-transcribe-realtime-2602, voxtral-mini-tts-2603), dépréciés le 31 octobre 2026 et retirés le 30 avril 2027, sont remplacés dans les exemples par voxtral-mini-transcribe-3, voxtral-mini-transcribe-realtime-3 et voxtral-mini-tts-3-0. Changements clés : les horodatages sont uniquement par segment (word renvoie une erreur 400), la diarisation en temps réel est prise en charge, les paramètres de session en temps réel sont verrouillés après le premier fragment audio, et les entrées context_bias sont en texte libre (phrases avec espaces). Sources : Migrate from Voxtral 2 · Speech to Text.

Quatre applications de streaming concrètes

Tu disposes désormais de tous les éléments constitutifs : le flux, le microphone et le réglage de la latence. Cette leçon les assemble en quatre applications complètes — sous-titrage en direct, assistant vocal, dictée et transcription de conférence — que tu peux utiliser telles quelles comme point de départ. Chacune illustre un problème que le mode hors ligne ne peut résoudre, et chacune utilise un réglage de latence différent, te donnant une idée concrète du réglage abordé précédemment.

Sous-titrage en direct

Le sous-titrage est le cas d’usage en temps réel le plus visible, et aussi le plus exigeant en termes de présentation. Transcrire ne suffit pas : tu dois découper le texte en lignes courtes, n’en afficher que deux à la fois, et faire défiler l’ensemble sans jamais couper un mot en deux. C’est exactement ce que fait la classe suivante. Lorsque la ligne actuelle atteint la longueur maximale, elle trouve le dernier espace avant cette limite et coupe à cet endroit ; si aucun espace n’est trouvé — un mot très long, une URL dictée — elle coupe à la longueur maximale plutôt que de laisser la ligne déborder. Le réglage de 800 millisecondes reflète la priorité de ce cas d’usage : un texte lisible vaut mieux qu’un texte instantané mais cassé, et le public ne remarquera pas ce léger délai.

import asyncio
import os
from mistralai.client import Mistral
from mistralai.client.models import (
    AudioFormat,
    TranscriptionStreamTextDelta,
    TranscriptionStreamDone
)

class LiveCaptioning:
    """Système de sous-titrage en direct avec gestion des lignes."""

    def __init__(self, max_chars_per_line=50, max_lines=2):
        self.max_chars = max_chars_per_line
        self.max_lines = max_lines
        self.current_line = ""
        self.lines = []

    async def run(self, audio_source):
        client = Mistral(api_key=os.environ["MISTRAL_API_KEY"])
        audio_format = AudioFormat(encoding="pcm_s16le", sample_rate=16000)

        async for event in client.audio.realtime.transcribe_stream(
            audio_stream=audio_source,
            model="voxtral-mini-transcribe-realtime-3",
            audio_format=audio_format,
            target_streaming_delay_ms=800,
        ):
            if isinstance(event, TranscriptionStreamTextDelta):
                self._add_text(event.text)
            elif isinstance(event, TranscriptionStreamDone):
                self._afficher_final()

    def _add_text(self, texte):
        self.current_line += texte

        if len(self.current_line) >= self.max_chars:
            pos = self.current_line.rfind(" ", 0, self.max_chars)
            if pos > 0:
                self.lines.append(self.current_line[:pos])
                self.current_line = self.current_line[pos + 1:]
            else:
                self.lines.append(self.current_line[:self.max_chars])
                self.current_line = self.current_line[self.max_chars:]

            if len(self.lines) > self.max_lines:
                self.lines = self.lines[-self.max_lines:]

        self._afficher()

    def _afficher(self):
        for ligne in self.lines:
            print(f"  {ligne}")
        print(f"  {self.current_line}", end="", flush=True)

    def _afficher_final(self):
        print("\n\n[Sous-titrage terminé]")

Assistant vocal interactif

Un assistant vocal ne peut pas se permettre le silence. Il doit comprendre l’utilisateur pendant qu’il parle, sinon il laisse un blanc après chaque question qui trahit immédiatement la machine. La transcription en temps réel est le premier maillon d’une chaîne en trois étapes : Speech-to-Text, puis LLM, puis Text-to-Speech. Ici, la latence chute à 300 millisecondes, la valeur la plus agressive de toute la leçon, et le texte s’affiche en écrasant la ligne actuelle grâce à un retour chariot, créant l’impression d’une phrase qui se complète sous tes yeux.

La seconde moitié de la fonction bascule vers le LLM. La réponse est elle-même demandée en flux, de sorte que les premiers mots arrivent avant que le modèle n’ait terminé sa phrase : la réactivité gagnée à l’étape de la transcription n’est pas gaspillée à l’étape suivante. L’instruction système impose la concision, un détail décisif dans l’interaction orale où une réponse de dix lignes devient inaudible.

async def assistant_vocal(audio_source):
    """Transcrit puis répond via un LLM."""
    client = Mistral(api_key=os.environ["MISTRAL_API_KEY"])
    audio_format = AudioFormat(encoding="pcm_s16le", sample_rate=16000)

    # Étape 1 : Transcrire la question
    question_parts = []

    async for event in client.audio.realtime.transcribe_stream(
        audio_stream=audio_source,
        model="voxtral-mini-transcribe-realtime-3",
        audio_format=audio_format,
        target_streaming_delay_ms=300,
    ):
        if isinstance(event, TranscriptionStreamTextDelta):
            question_parts.append(event.text)
            texte_en_cours = "".join(question_parts)
            print(f"\rToi : {texte_en_cours}", end="", flush=True)
        elif isinstance(event, TranscriptionStreamDone):
            break

    question = "".join(question_parts).strip()
    print()

    if not question:
        print("Aucune question détectée.")
        return

    # Étape 2 : Envoyer au LLM pour obtenir une réponse
    print("Assistant : ", end="", flush=True)

    reponse_stream = client.chat.stream(
        model="mistral-large-latest",
        messages=[
            {
                "role": "system",
                "content": "Tu es un assistant vocal concis. "
                           "Réponds en 2 à 3 phrases maximum."
            },
            {"role": "user", "content": question}
        ]
    )

    for chunk in reponse_stream:
        texte = chunk.data.choices[0].delta.content
        if texte:
            print(texte, end="", flush=True)

    print("\n")

Dictée vocale avec sauvegarde automatique

La dictée pose un problème que les deux cas précédents ignorent : la durée. Une session peut s’étendre sur plus d’une heure, et perdre le texte à cause d’un plantage ou d’une coupure serait inacceptable. D’où la sauvegarde automatique, déclenchée environ tous les cent mots, qui réécrit le fichier de sortie à la volée. Le compteur nb_mots sert également de retour d’information pour l’utilisateur : il t’indique combien tu as produit, une information que quiconque dicte un rapport attend. La latence de 600 millisecondes place le curseur du côté de la précision, car quelqu’un qui dicte relit son texte et préfère un mot exact à un mot instantané.

class DicteeVocale:
    """Dictée vocale avec sauvegarde automatique."""

    def __init__(self, fichier_sortie="dictee.txt"):
        self.fichier_sortie = fichier_sortie
        self.texte = []
        self.nb_mots = 0

    async def run(self, audio_source):
        client = Mistral(api_key=os.environ["MISTRAL_API_KEY"])
        audio_format = AudioFormat(encoding="pcm_s16le", sample_rate=16000)

        print("Dictée en cours... (Ctrl+C pour arrêter)\n")

        async for event in client.audio.realtime.transcribe_stream(
            audio_stream=audio_source,
            model="voxtral-mini-transcribe-realtime-3",
            audio_format=audio_format,
            target_streaming_delay_ms=600,
        ):
            if isinstance(event, TranscriptionStreamTextDelta):
                self.texte.append(event.text)
                self.nb_mots += len(event.text.split())
                print(event.text, end="", flush=True)

                # Sauvegarde automatique tous les 100 mots
                if self.nb_mots % 100 < 5:
                    self._sauvegarder()

            elif isinstance(event, TranscriptionStreamDone):
                break

        self._sauvegarder()
        print(f"\n\nDictée terminée : {self.nb_mots} mots")
        print(f"Fichier : {self.fichier_sortie}")

    def _sauvegarder(self):
        contenu = "".join(self.texte)
        with open(self.fichier_sortie, "w", encoding="utf-8") as f:
            f.write(contenu)

Transcription de conférence avec métadonnées

Pour une longue conférence, le texte brut ne vaut pas grand-chose s’il n’est pas identifiable. Six mois plus tard, personne ne saura de quelle session ou de quel intervenant provient un fichier nommé transcription.txt. La fonction suivante enveloppe donc la transcription dans une structure documentée — nom de la conférence, intervenant, horodatages de début et de fin, nombre de mots — et l’exporte en JSON sous un nom horodaté, immédiatement utilisable par un moteur de recherche interne ou un pipeline d’archivage. La latence de 1 200 millisecondes est parfaitement confortable ici : le public écoute l’intervenant, l’affichage n’est qu’un supplément, et la précision prend le pas sur la vitesse.

import json
from datetime import datetime

async def transcribe_conference(
    audio_source,
    conference_name: str,
    speaker: str = "Inconnu"
):
    """Transcrit une session de conférence avec métadonnées."""
    client = Mistral(api_key=os.environ["MISTRAL_API_KEY"])
    audio_format = AudioFormat(encoding="pcm_s16le", sample_rate=16000)

    session = {
        "conference": conference_name,
        "speaker": speaker,
        "debut": datetime.now().isoformat(),
        "texte": [],
    }

    print(f"Transcription : {conference_name}")
    print(f"Intervenant : {speaker}")
    print("-" * 50)

    async for event in client.audio.realtime.transcribe_stream(
        audio_stream=audio_source,
        model="voxtral-mini-transcribe-realtime-3",
        audio_format=audio_format,
        target_streaming_delay_ms=1200,
    ):
        if isinstance(event, TranscriptionStreamTextDelta):
            session["texte"].append(event.text)
            print(event.text, end="", flush=True)
        elif isinstance(event, TranscriptionStreamDone):
            break

    session["fin"] = datetime.now().isoformat()
    session["texte"] = "".join(session["texte"])
    session["nb_mots"] = len(session["texte"].split())

    filename = f"session_{datetime.now().strftime('%Y%m%d_%H%M%S')}.json"
    with open(filename, "w", encoding="utf-8") as f:
        json.dump(session, f, ensure_ascii=False, indent=2)

    print(f"\n\nSession enregistrée : {filename}")
    return session

Passe en revue les quatre latences dans l’ordre — 300, 600, 800, puis 1 200 millisecondes — et note qu’elles suivent une seule logique : plus l’utilisateur attend une réaction de la machine, plus le délai doit être court ; plus il attend un document exploitable, plus il peut être long. Prends l’une de ces applications et branche-la sur le générateur de microphone de la leçon précédente : tu auras un outil véritablement utilisable en quelques minutes seulement.

Klíčové poznatky

  • Le sous-titrage en direct utilise une latence de 800 ms et gère l’affichage ligne par ligne
  • L’assistant vocal enchaîne transcription en temps réel et LLM pour répondre aux questions
  • La dictée vocale sauvegarde automatiquement le texte à la volée
  • La transcription de conférence ajoute des métadonnées et exporte en JSON
  • Chaque cas d’usage a sa latence optimale : de 300 ms (assistant) à 1 200 ms (conférence), dans la plage acceptée de 80 à 1 200 ms ou 2 400 ms