Spring til hovedindhold
Dansk— Vælg et sprog
Menu

Tidsstempler og temporal segmentering

Lektion 6 af 16 Opdateret 3. november 2026 Udvikler
På denne side
  1. Strukturering af transskription over tid
  2. Segmentgranularitet: Taleblokken
  3. Hvad med ordgranularitet?
  4. Generering af SRT-undertekster
  5. Navigation i lange optagelser
  6. Vigtige pointer

Kurset opdateret 3. november 2026 til Voxtral 3, baseret på Mistrals guide Migrate from Voxtral 2: Voxtral 2-modellerne (voxtral-mini-2602, voxtral-mini-transcribe-realtime-2602, voxtral-mini-tts-2603), der blev afskrevet 31. oktober 2026 og udfases 30. april 2027, erstattes i eksemplerne af voxtral-mini-transcribe-3, voxtral-mini-transcribe-realtime-3 og voxtral-mini-tts-3-0. Vigtige ændringer: Tidsstempler er kun tilgængelige på segmentniveau (word giver en 400-fejl), diarisering er mulig i realtid, indstillinger for realtidssessioner låses efter det første lydstykke, og context_bias-input er frit format (sætninger med mellemrum). Kilder: Migrate from Voxtral 2 · Speech to Text.

Strukturering af transskription over tid

En rå transskription er nyttig, men en transskription med tidsstempler åbner for langt rigere muligheder: undertekster, temporal navigation, videosynkronisering og udtræk af specifikke passager. Uden tidsstempler kræver det gætterier at finde det øjeblik, hvor et budget blev diskuteret i en to timers optagelse; med dem er det blot en tekstsøgning efterfulgt af et klik. Voxtrals parameter timestamp_granularities giver dig denne mulighed.

Segmentgranularitet: Taleblokken

Et segment er en sammenhængende blok af tale – typisk en sætning eller en gruppe af sætninger talt uden væsentlige pauser. Dette er den granularitet, du vil vælge som standard, da den svarer til den naturlige læseenhed.

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"]
    )

# Iterér gennem segmenter
for seg in response.segments:
    start = f"{seg.start:.1f}s"
    end = f"{seg.end:.1f}s"
    print(f"[{start} → {end}] {seg.text}")

Outputtet ser sådan ud:

[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.

Denne opdeling understøtter navigation i lange optagelser, visning af undertekstblokke og indeksering af passager: hvert segment bliver en søgbar post med sit startpunkt i lydfilen.

Hvad med ordgranularitet?

Voxtral 2 kunne også tildele tidsstempler til hvert enkelt ord (timestamp_granularities=["word"]). Voxtral 3 tilbyder ikke længere dette: granulariteten word returnerer en 400-fejl, og Mistrals migrationsguide instruerer brugere i at skifte til segmenter. Use cases, der krævede ord-for-ord-synkronisering – såsom karaoke-undertekster, fremhævning af det aktuelle ord eller finmasket analyse af talehastighed – må nu basere sig på segmenter og eventuelt fordele et segments varighed på dets ord via estimering på klientsiden.

def estimer_mots(segment):
    """Fordeler et segments varighed på dets ord proportionalt med deres længde (estimat)."""
    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

Dette er en tilnærmelse, der er nyttig til progressiv visning, men ikke til prosodisk analyse: Hvis nøjagtig ordjustering er afgørende, forbliver et dedikeret værktøj til tvungen justering (forced alignment) anvendt efter transskriptionen løsningen.

Generering af SRT-undertekster

SRT-formatet er ikke noget mysterium: et sekvensnummer, et tidsinterval i formatet HH:MM:SS,mmm, teksten og en tom linje. Funktionen nedenfor itererer gennem segmenterne og opdeler dem, der ville overskride en behagelig visningsbredde, her sat til 60 tegn.

def generate_srt_from_segments(segments, max_chars=60):
    """Genererer en SRT-fil fra Voxtral-segmenter."""
    srt_lines = []
    counter = 1

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

        # Opdel segmenter, der er for lange
        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):
    """Konverterer sekunder til 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}"

# Brug
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-fil genereret succesfuldt")

En anden direkte anvendelse af segmenter er opbygning af et temporalt overblik. Følgende script markerer et kontrolpunkt hvert femte minut og viser de første få ord, hvilket giver læseren et kort over optagelsen, før man overhovedet lytter til den.

def create_temporal_index(segments, interval_minutes=5):
    """Opretter et indeks hvert N. minut."""
    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

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

Med Voxtral 2 var timestamp_granularities inkompatibel med parameteren language. Voxtral 3-dokumentationen nævner ikke længere denne begrænsning: verificér det med en test, før du kombinerer de to i produktionsmiljøer.

Vigtige pointer

  • Kun én granularitet med Voxtral 3: "segment" ("word" returnerer en 400-fejl)
  • Ord-for-ord-justering estimeres om nødvendigt ud fra segmenter eller håndteres af et justeringsværktøj
  • Tidsstempler er i sekunder (decimaltal) med start og end for hvert segment
  • Ideelt til SRT/VTT-undertekster, temporal navigation og indeksering
  • Inkompatibiliteten med language fra Voxtral 2 er ikke længere dokumenteret: verificér det med en test