Přejít na hlavní obsah
Čeština— Vyberte jazyk
Menu

Časové značky a temporální segmentace

Lekce 6 z 16 Aktualizováno 3. listopadu 2026 Vývojář
Na této stránce
  1. Strukturování přepisu v čase
  2. Granularita segmentu: Blok řeči
  3. Co s granularitou na úrovni slov?
  4. Generování titulků ve formátu SRT
  5. Navigace v dlouhých záznamech
  6. Klíčové poznatky

Kurz aktualizován 3. listopadu 2026 pro Voxtral 3 na základě průvodce Mistralu Migrate from Voxtral 2: Modely Voxtral 2 (voxtral-mini-2602, voxtral-mini-transcribe-realtime-2602, voxtral-mini-tts-2603), které byly zastaralé k 31. říjnu 2026 a vyřazené k 30. dubnu 2027, jsou v příkladech nahrazeny modely voxtral-mini-transcribe-3, voxtral-mini-transcribe-realtime-3 a voxtral-mini-tts-3-0. Klíčové změny: časové značky jsou pouze na úrovni segmentů (word vrací chybu 400), diarizace je možná v reálném čase, nastavení relace v reálném čase jsou uzamčena po prvním zvukovém úseku a vstupy context_bias jsou volného formátu (fráze s mezerami). Zdroje: Migrate from Voxtral 2 · Speech to Text.

Strukturování přepisu v čase

Surový přepis je užitečný, ale přepis s časovými značkami otevírá mnohem bohatší možnosti: titulky, temporální navigaci, synchronizaci videa a extrakci konkrétních pasáží. Bez časových značek vyžaduje nalezení okamžiku, kdy se ve dvouhodinovém záznamu diskutovalo o rozpočtu, hádání; s nimi je to prosté vyhledání textu následované kliknutím. Parametr timestamp_granularities ve Voxtralu ti dává tuto moc.

Granularita segmentu: Blok řeči

Segment je souvislý blok řeči – typicky věta nebo skupina vět vyslovených bez významné pauzy. Toto je granularita, kterou zvolíš ve výchozím nastavení, protože odpovídá přirozené jednotce čtení.

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

# Iterace přes segmenty
for seg in response.segments:
    start = f"{seg.start:.1f}s"
    end = f"{seg.end:.1f}s"
    print(f"[{start} → {end}] {seg.text}")

Výstup vypadá takto:

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

Toto rozdělení podporuje navigaci v dlouhých záznamech, zobrazování bloků titulků a indexování pasáží: každý segment se stává vyhledatelným záznamem se svým vstupním bodem v audiu.

Co s granularitou na úrovni slov?

Voxtral 2 uměl také označovat časem každé slovo (timestamp_granularities=["word"]). Voxtral 3 to již nenabízí: granularita word vrací chybu 400 a migrační průvodce Mistralu instruuje uživatele k přechodu na segmenty. Případy použití, které vyžadovaly zarovnání slovo od slova – titulky ve stylu karaoke, zvýrazňování aktuálního slova, jemná analýza rychlosti řeči – se nyní musí spoléhat na segmenty, případně rozdělením času segmentu mezi jeho slova pomocí odhadu na straně klienta.

def estimer_mots(segment):
    """Rozdělí délku trvání segmentu mezi jeho slova úměrně jejich délce (odhad)."""
    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

Jedná se o aproximaci, užitečnou pro progresivní zobrazení, ale ne pro prozodickou analýzu: pokud je přesné zarovnání slov zásadní, řešením zůstává specializovaný nástroj pro vynucené zarovnání aplikovaný po přepisu.

Generování titulků ve formátu SRT

Formát SRT není žádná záhada: pořadové číslo, časový rozsah ve formátu HH:MM:SS,mmm, text a prázdný řádek. Níže uvedená funkce iteruje přes segmenty a rozděluje ty, které by překročily komfortní šířku zobrazení, zde nastavenou na šedesát znaků.

def generate_srt_from_segments(segments, max_chars=60):
    """Generuje soubor SRT ze segmentů Voxtral."""
    srt_lines = []
    counter = 1

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

        # Rozdělení příliš dlouhých segmentů
        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):
    """Převede sekundy na formát 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}"

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

print("Soubor SRT byl úspěšně vygenerován")

Další přímou aplikací segmentů je vytváření temporálního souhrnu. Následující skript označí kontrolní bod každých pět minut a zobrazí první několik slov, čímž poskytne čtenáři mapu záznamu ještě před tím, než si ho vůbec poslechne.

def create_temporal_index(segments, interval_minutes=5):
    """Vytvoří index každých 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

# Použití
for entry in create_temporal_index(response.segments, interval_minutes=5):
    print(entry)

U Voxtralu 2 byl parametr timestamp_granularities nekompatibilní s parametrem language. Dokumentace Voxtralu 3 tuto restrikci již nezmiňuje: před kombinací obou parametrů v produkčním zpracování si to ověř testem.

Klíčové poznatky

  • Pouze jedna granularita s Voxtral 3: "segment" ("word" vrací chybu 400)
  • Zarovnání slovo od slova, pokud je nutné, se odhaduje ze segmentů nebo řeší nástrojem pro zarovnání
  • Časové značky jsou v sekundách (desetinná čísla), s start a end pro každý segment
  • Ideální pro titulky SRT/VTT, temporální navigaci a indexování
  • Nekompatibilita s language z Voxtralu 2 již není zdokumentována: ověř si to testem