Lähe põhisisu juurde
Eesti— Vali keel
Menüü

Ajatemplid ja ajaline segmenteerimine

Õppetund 6 / 16 Värskendatud 3. november 2026 Arendajatele
Sellel lehel
  1. Transkriptsiooni struktureerimine ajas
  2. Segmendi granulaarsus: kõneplokk
  3. Kuidas on lood sõna granulaarsusega?
  4. SRT-subtiitrite genereerimine
  5. Pikkade salvestiste navigeerimine
  6. Peamised punktid

Kursust uuendati 3. novembril 2026 Voxtral 3 jaoks, tuginedes Mistrali juhendile Migrate from Voxtral 2: Voxtral 2 mudelid (voxtral-mini-2602, voxtral-mini-transcribe-realtime-2602, voxtral-mini-tts-2603), mis tunnistati aegunuks 31. oktoobril 2026 ja eemaldatakse kasutusest 30. aprillil 2027, on näidetes asendatud mudelitega voxtral-mini-transcribe-3, voxtral-mini-transcribe-realtime-3 ja voxtral-mini-tts-3-0. Peamised muudatused: ajatemplid on ainult segmendi tasemel (word tagastab vea 400), diaariseerimine on reaalajas võimalik, reaalaja seansi seaded lukustuvad pärast esimest helilõiku ja context_bias sisendid on vabas vormingus (fraasid tühikutega). Allikad: Migrate from Voxtral 2 · Speech to Text.

Transkriptsiooni struktureerimine ajas

Toores transkriptsioon on kasulik, kuid ajatemplitega transkriptsioon avab palju rikkalikumaid võimalusi: subtiitrite loomine, ajaline navigeerimine, video sünkroniseerimine ja konkreetsete lõikude eraldamine. Ilma ajatemplideta nõuab kahe tunni pikkuse salvestise hetke leidmine, kus arutati eelarvet, arvamist; nendega on see lihtsalt tekstiotsing, millele järgneb klõps. Voxtrali parameeter timestamp_granularities annab sulle selle võimekuse.

Segmendi granulaarsus: kõneplokk

Segment on pidev kõneplokk – tüüpiliselt lause või lauserühm, mis on öeldud ilma olulise pausita. See on granulaarsus, mille valid vaikimisi, kuna see vastab lugemise loomulikule ühikule.

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

# Itereeri läbi segmentide
for seg in response.segments:
    start = f"{seg.start:.1f}s"
    end = f"{seg.end:.1f}s"
    print(f"[{start} → {end}] {seg.text}")

Väljund näeb välja selline:

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

See jaotus toetab pikkade salvestiste navigeerimist, subtiitriplokkide kuvamist ja lõikude indekseerimist: igast segmendist saab otsitav kirje koos selle alguspunktiga helifailis.

Kuidas on lood sõna granulaarsusega?

Voxtral 2 suutis ajatempliga varustada ka iga sõna (timestamp_granularities=["word"]). Voxtral 3 seda enam ei paku: granulaarsus word tagastab vea 400 ja Mistrali migratsioonijuhend käsib kasutajatel üle minna segmentidele. Juhtumeid, mis nõudsid sõna-sõnalist joondamist – karaoke-stiilis subtiitrid, praeguse sõna esiletõstmine, peeneteraline kõnekiiruse analüüs – tuleb nüüd lahendada segmentide abil, jaotades segmendi aja selle sõnade vahel kliendipoolse hinnangu kaudu.

def estimer_mots(segment):
    """Jagab segmendi kestuse selle sõnade vahel, proportsionaalselt nende pikkusega (hinnang)."""
    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

See on ligikaudne hinnang, mis sobib progressiivseks kuvamiseks, kuid mitte prosoodia analüüsiks: kui täpne sõnade joondamine on hädavajalik, jääb lahenduseks spetsiaalne sunnitud joondamise tööriist, mida rakendatakse pärast transkriptsiooni.

SRT-subtiitrite genereerimine

SRT-vorming pole midagi müstilist: järjekorranumber, ajavahemik formaadis HH:MM:SS,mmm, tekst ja tühi rida. Allpool olev funktsioon iterreerib läbi segmentide ja jagab need, mis ületaksid mugava kuva laiuse, mis on siin seatud kuuekümnele märgile.

def generate_srt_from_segments(segments, max_chars=60):
    """Genereerib Voxtrali segmentidest SRT-faili."""
    srt_lines = []
    counter = 1

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

        # Jagada liiga pikad segmendid
        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):
    """Teisendab sekundid SRT-vormingusse (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}"

# Kasutamine
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 file generated successfully")

Pikkade salvestiste navigeerimine

Teine segmentide otsene rakendus on ajalise kokkuvõtte loomine. Järgnev skript märgib kontrollpunkti iga viie minuti tagant ja kuvab esimesed mõned sõnad, andes lugejale salvestise kaardi juba enne selle kuulamist.

def create_temporal_index(segments, interval_minutes=5):
    """Loo indeks iga N minuti tagant."""
    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

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

Voxtral 2 puhul oli timestamp_granularities kokkusobimatu parameetriga language. Voxtral 3 dokumentatsioon seda piirangut enam ei maini: enne kahe koos kasutamist tootmises veendu selles testiga.

Peamised punktid

  • Ainult üks granulaarsus Voxtral 3 puhul: "segment" ("word" tagastab vea 400)
  • Sõna-sõnaline joondamine on vajadusel hinnanguline, lähtudes segmentidest, või lahendatakse joondamistööriistaga
  • Ajatemplid on sekundites (kümnendmurrud), iga segmendi jaoks on olemas start ja end
  • Ideaalne SRT/VTT subtiitrite, ajalise navigeerimise ja indekseerimise jaoks
  • Voxtral 2-st pärit kokkusobimatus parameetriga language pole enam dokumenteeritud: veendu selles testiga