Zeitstempel und temporale Segmentierung
Auf dieser Seite
Kurs aktualisiert am 3. November 2026 für Voxtral 3, basierend auf Mistrals Leitfaden Migrate from Voxtral 2: Die Voxtral 2-Modelle (
voxtral-mini-2602,voxtral-mini-transcribe-realtime-2602,voxtral-mini-tts-2603), die am 31. Oktober 2026 veraltet und am 30. April 2027 eingestellt wurden, werden in den Beispielen durchvoxtral-mini-transcribe-3,voxtral-mini-transcribe-realtime-3undvoxtral-mini-tts-3-0ersetzt. Wesentliche Änderungen: Zeitstempel beziehen sich nur auf Segmente (wordführt zu einem 400-Fehler), Diarisation ist in Echtzeit möglich, Einstellungen für Echtzeit-Sitzungen werden nach dem ersten Audio-Chunk gesperrt, undcontext_bias-Eingaben sind frei formatiert (Phrasen mit Leerzeichen). Quellen: Migrate from Voxtral 2 · Speech to Text.
Strukturierung der Transkription über die Zeit
Ein rohes Transkript ist nützlich, aber ein zeitgestempeltes Transkript eröffnet weit reichere Möglichkeiten: Untertitelung, temporale Navigation, Videosynchronisation und das Extrahieren spezifischer Passagen. Ohne Zeitstempel erfordert das Auffinden des Moments, in dem ein Budget in einer zweistündigen Aufnahme diskutiert wurde, Vermutungen; mit ihnen ist es eine Textsuche gefolgt von einem Klick. Der Parameter timestamp_granularities von Voxtral gibt Ihnen diese Macht.
Segment-Granularität: Der Sprechblock
Ein Segment ist ein kontinuierlicher Block von Sprache – typischerweise ein Satz oder eine Gruppe von Sätzen, die ohne signifikante Pause gesprochen werden. Dies ist die Granularität, die Sie standardmäßig wählen werden, da sie der natürlichen Leseeinheit entspricht.
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"]
)
# Iteration durch Segmente
for seg in response.segments:
start = f"{seg.start:.1f}s"
end = f"{seg.end:.1f}s"
print(f"[{start} → {end}] {seg.text}")
Die Ausgabe sieht wie folgt aus:
[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.
Diese Aufschlüsselung unterstützt die Navigation in langen Aufnahmen, die Anzeige von Untertitelblöcken und die Indexierung von Passagen: Jedes Segment wird zu einer durchsuchbaren Eintragung mit seinem Einstiegspunkt im Audio.
Was ist mit der Wortgranularität?
Voxtral 2 konnte auch jedes Wort zeitstempeln (timestamp_granularities=["word"]). Voxtral 3 bietet dies nicht mehr: Die Granularität word führt zu einem 400-Fehler, und Mistrals Migrationsleitfaden instruiert Benutzer, zu Segmenten zu wechseln. Anwendungsfälle, die eine wortgenaue Ausrichtung erforderten – karaokeartige Untertitel, Hervorheben des aktuellen Wortes, feingranuläre Analyse der Sprechgeschwindigkeit – müssen sich nun auf Segmente stützen und die Zeit eines Segments möglicherweise über clientseitige Schätzung auf seine Wörter verteilen.
def estimer_mots(segment):
"""Verteilt die Dauer eines Segments auf seine Wörter proportional zu ihrer Länge (Schätzung)."""
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
Dies ist eine Näherung, nützlich für die progressive Anzeige, aber nicht für prosodische Analysen: Wenn eine exakte wortgenaue Ausrichtung unerlässlich ist, bleibt die Lösung ein spezielles Forced-Alignment-Tool, das nach der Transkription angewendet wird.
Generierung von SRT-Untertiteln
Das SRT-Format ist nichts Mysteriöses: Eine Sequenznummer, ein Zeitbereich im Format HH:MM:SS,mmm, der Text und eine leere Zeile. Die folgende Funktion iteriert durch Segmente und spaltet solche, die eine angenehme Anzeigebreite von hier festgelegten 60 Zeichen überschreiten würden.
def generate_srt_from_segments(segments, max_chars=60):
"""Generiert eine SRT-Datei aus Voxtral-Segmenten."""
srt_lines = []
counter = 1
for seg in segments:
words = seg.text.strip()
if not words:
continue
# Spalten von Segmenten, die zu lang sind
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):
"""Konvertiert Sekunden in SRT-Format (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}"
# Nutzung
srt_contenu = generate_srt_from_segments(response.segments)
with open("sous_titres.srt", "w", encoding="utf-8") as f:
f.write(srt_contenu)
print("SRT-Datei erfolgreich generiert")
Navigation in langen Aufnahmen
Eine weitere direkte Anwendung von Segmenten ist die Erstellung einer temporalen Zusammenfassung. Der folgende Skript markiert jeden fünf Minuten einen Checkpoint und zeigt die ersten paar Wörter an, was dem Leser eine Landkarte der Aufnahme liefert, noch bevor er sie anhört.
def create_temporal_index(segments, interval_minutes=5):
"""Erstellt einen Index alle N Minuten."""
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
# Nutzung
for entry in create_temporal_index(response.segments, interval_minutes=5):
print(entry)
Bei Voxtral 2 war timestamp_granularities mit dem Parameter language inkompatibel. Die Dokumentation von Voxtral 3 erwähnt diese Einschränkung nicht mehr: Überprüfen Sie dies mit einem Test, bevor Sie beide in der Produktionsverarbeitung kombinieren.
Kernaussagen
- Nur eine Granularität bei Voxtral 3:
"segment"("word"führt zu einem 400-Fehler) - Wortgenaue Ausrichtung, falls erforderlich, wird aus Segmenten geschätzt oder von einem Alignment-Tool behandelt
- Zeitstempel sind in Sekunden (dezimale Zahlen), mit
startundendfür jedes Segment - Ideal für SRT/VTT-Untertitelung, temporale Navigation und Indexierung
- Die Inkompatibilität mit
languageaus Voxtral 2 wird nicht mehr dokumentiert: Überprüfen Sie dies mit einem Test