Horodatages et segmentation temporelle
Šiame puslapyje
Cours mis à jour le 3 novembre 2026 pour Voxtral 3, sur la base du 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 parvoxtral-mini-transcribe-3,voxtral-mini-transcribe-realtime-3etvoxtral-mini-tts-3-0. Changements clés : les horodatages sont uniquement par segment (wordrenvoie 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 chunk audio, et les entréescontext_biassont 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é segment : le bloc de parole
Un segment est un bloc continu de parole — 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é mot par mot ?
Voxtral 2 pouvait aussi 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 à passer aux 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 mot 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")
Naviguer dans les longs enregistrements
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 en production.
Svarbiausi punktai
- 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
startetendpour chaque segment - Idéal pour le sous-titrage SRT/VTT, la navigation temporelle et l’indexation
- L’incompatibilité avec
languagede Voxtral 2 n’est plus documentée : vérifie-la par un test