Pāriet uz galveno saturu
Latviešu— Izvēlēties valodu
Izvēlne

Horodatages et segmentation temporelle

Nodarbība 6 no 16 Atjaunota 2026. gada 3. novembris Programmētājs
Šajā lapā
  1. Structurer la transcription dans le temps
  2. Granularité par segment : le bloc de parole
  3. Et la granularité par mot ?
  4. Générer des sous-titres SRT
  5. Naviguer dans les longs enregistrements
  6. Galvenās atziņas

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 est possible en temps réel, les paramètres de session en temps réel sont verrouillés après le premier bloc audio, et les entrées context_bias sont en texte libre (phrases avec espaces). Sources : Migrate from Voxtral 2 · Speech to Text.

Structurer la transcription dans le temps

Une transcription brute est utile, mais une transcription horodatée ouvre des possibilités bien plus riches : sous-titrage, navigation temporelle, synchronisation vidéo et extraction de passages spécifiques. Sans horodatages, trouver le moment où un budget a été évoqué dans un enregistrement de deux heures relève de la devinette ; avec eux, il suffit d’une recherche textuelle suivie d’un clic. Le paramètre timestamp_granularities de Voxtral te donne ce pouvoir.

Granularité par segment : le bloc de parole

Un segment est un bloc de parole continu — typiquement une phrase ou un groupe de phrases prononcées sans pause significative. C’est la granularité que tu choisiras par défaut, car elle correspond à l’unité naturelle de lecture.

import os
from mistralai.client import Mistral

client = Mistral(api_key=os.environ["MISTRAL_API_KEY"])

with open("conference.mp3", "rb") as f:
    response = client.audio.transcriptions.complete(
        model="voxtral-mini-transcribe-3",
        file={"content": f, "file_name": "conference.mp3"},
        timestamp_granularities=["segment"]
    )

# Itérer sur les segments
for seg in response.segments:
    start = f"{seg.start:.1f}s"
    end = f"{seg.end:.1f}s"
    print(f"[{start} → {end}] {seg.text}")

Le résultat ressemble à ceci :

[0.0s → 4.2s] Hello everyone, thank you for being here today.
[4.5s → 11.8s] We will cover the quarter's results and the outlook for the future.
[12.1s → 18.3s] Let's start with revenue, which has grown by twelve percent.

Cette décomposition permet la navigation dans les longs enregistrements, l’affichage par blocs de sous-titres et l’indexation des passages : chaque segment devient une entrée consultable avec son point d’entrée dans l’audio.

Et la granularité par mot ?

Voxtral 2 pouvait également horodater chaque mot (timestamp_granularities=["word"]). Voxtral 3 n’offre plus cette option : la granularité word renvoie une erreur 400, et le guide de migration de Mistral invite les utilisateurs à basculer vers les segments. Les cas d’usage nécessitant un alignement mot par mot — sous-titres style karaoké, mise en surbrillance du mot actuel, analyse fine du débit de parole — doivent désormais s’appuyer sur les segments, en répartissant potentiellement la durée d’un segment entre ses mots via une estimation côté client.

def estimer_mots(segment):
    """Répartit la durée d'un segment entre ses mots, proportionnellement à leur longueur (estimation)."""
    mots = segment.text.split()
    if not mots or segment.start is None or segment.end is None:
        return []
    total = sum(len(m) for m in mots)
    debut, duree = segment.start, segment.end - segment.start
    resultat = []
    for mot in mots:
        fin = debut + duree * len(mot) / total
        resultat.append((round(debut, 2), round(fin, 2), mot))
        debut = fin
    return resultat

Il s’agit d’une approximation, utile pour un affichage progressif mais pas pour une analyse prosodique : si un alignement exact par mot est essentiel, un outil d’alignement forcé dédié appliqué après la transcription reste la solution.

Générer des sous-titres SRT

Le format SRT n’a rien de mystérieux : un numéro de séquence, une plage horaire au format HH:MM:SS,mmm, le texte et une ligne vide. La fonction ci-dessous itère sur les segments et divise ceux qui dépasseraient une largeur d’affichage confortable, fixée ici à soixante caractères.

def generate_srt_from_segments(segments, max_chars=60):
    """Génère un fichier SRT à partir des segments Voxtral."""
    srt_lines = []
    counter = 1

    for seg in segments:
        words = seg.text.strip()
        if not words:
            continue

        # Diviser les segments trop longs
        sub_text = words.split()
        word = ""
        for format_srt_time in sub_text:
            if len(word) + len(format_srt_time) + 1 > max_chars and word:
                srt_lines.append(str(counter))
                srt_lines.append(
                    f"{seconds(seg.start)} --> "
                    f"{seconds(seg.end)}"
                )
                srt_lines.append(word.strip())
                srt_lines.append("")
                counter += 1
                word = format_srt_time
            else:
                word += " " + format_srt_time

        if word.strip():
            srt_lines.append(str(counter))
            srt_lines.append(
                f"{seconds(seg.start)} --> "
                f"{seconds(seg.end)}"
            )
            srt_lines.append(word.strip())
            srt_lines.append("")
            counter += 1

    return "\n".join(srt_lines)

def seconds(secondes):
    """Convertit les secondes au format SRT (HH:MM:SS,mmm)."""
    h = int(secondes // 3600)
    m = int((secondes % 3600) // 60)
    s = int(secondes % 60)
    ms = int((secondes % 1) * 1000)
    return f"{h:02d}:{m:02d}:{s:02d},{ms:03d}"

# Utilisation
srt_contenu = generate_srt_from_segments(response.segments)
with open("sous_titres.srt", "w", encoding="utf-8") as f:
    f.write(srt_contenu)

print("Fichier SRT généré avec succès")

Une autre application directe des segments est la création d’un résumé temporel. Le script suivant marque un point de contrôle toutes les cinq minutes et affiche les premiers mots, offrant au lecteur une carte de l’enregistrement avant même de l’écouter.

def create_temporal_index(segments, interval_minutes=5):
    """Crée un index toutes les N minutes."""
    index = []
    next_milestone = 0

    for seg in segments:
        if seg.debut >= next_milestone * 60:
            minutes = int(seg.debut // 60)
            seconds = int(seg.debut % 60)
            preview = seg.text[:80] + "..." if len(seg.text) > 80 else seg.text
            index.append(f"[{minutes:02d}:{seconds:02d}] {preview}")
            next_milestone = minutes + interval_minutes

    return index

# Utilisation
for entry in create_temporal_index(response.segments, interval_minutes=5):
    print(entry)

Avec Voxtral 2, timestamp_granularities était incompatible avec le paramètre language. La documentation de Voxtral 3 ne mentionne plus cette restriction : vérifie-la par un test avant de combiner les deux dans un traitement de production.

Galvenās atziņas

  • Une seule granularité avec Voxtral 3 : "segment" ("word" renvoie une erreur 400)
  • L’alignement mot par mot, si nécessaire, est estimé à partir des segments ou géré par un outil d’alignement
  • Les horodatages sont en secondes (nombres décimaux), avec start et end pour chaque segment
  • Idéal pour le sous-titrage SRT/VTT, la navigation temporelle et l’indexation
  • L’incompatibilité avec language de Voxtral 2 n’est plus documentée : vérifie-la par un test