Przejdź do głównej treści
Polski— Wybierz język
Menu

Znaczniki czasu i segmentacja temporalna

Lekcja 6 z 16 Zaktualizowano 3 listopada 2026 Programista
Na tej stronie
  1. Strukturyzacja transkrypcji w czasie
  2. Granularność segmentu: blok mowy
  3. A co z granularnością na poziomie słowa?
  4. Generowanie napisów w formacie SRT
  5. Nawigacja po długich nagraniach
  6. Kluczowe wnioski

Kurs zaktualizowany 3 listopada 2026 r. dla Voxtral 3, na podstawie przewodnika Mistral Migrate from Voxtral 2: modele Voxtral 2 (voxtral-mini-2602, voxtral-mini-transcribe-realtime-2602, voxtral-mini-tts-2603), wycofane 31 października 2026 r. i całkowicie usunięte 30 kwietnia 2027 r., zostały zastąpione w przykładach modelami voxtral-mini-transcribe-3, voxtral-mini-transcribe-realtime-3 oraz voxtral-mini-tts-3-0. Kluczowe zmiany: znaczniki czasu dotyczą wyłącznie segmentów (word zwraca błąd 400), diarization jest możliwy w czasie rzeczywistym, ustawienia sesji czasu rzeczywistego są blokowane po pierwszym fragmencie audio, a dane wejściowe context_bias mają dowolną formę (frazy ze spacjami). Źródła: Migrate from Voxtral 2 · Speech to Text.

Strukturyzacja transkrypcji w czasie

Surowy tekst transkrypcji jest użyteczny, ale transkrypcja ze znacznikami czasu otwiera znacznie bogatsze możliwości: tworzenie napisów, nawigację temporalną, synchronizację z wideo oraz ekstrakcję konkretnych fragmentów. Bez znaczników czasu odnalezienie momentu, w którym dyskutowano o budżecie w dwugodzinnym nagraniu, wymaga zgadywania; z nimi jest to po prostu wyszukiwanie tekstowe i jedno kliknięcie. Parametr timestamp_granularities w Voxtral daje Ci tę moc.

Granularność segmentu: blok mowy

Segment to ciągły blok mowy – zazwyczaj zdanie lub grupa zdań wypowiedzianych bez znaczącej pauzy. Jest to granularność, którą wybierzesz domyślnie, ponieważ odpowiada naturalnej jednostce czytania.

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

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

Wynik wygląda następująco:

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

Taki podział wspiera nawigację w długich nagraniach, wyświetlanie bloków napisów i indeksowanie fragmentów: każdy segment staje się wyszukiwalnym wpisem z określonym punktem wejścia w audio.

A co z granularnością na poziomie słowa?

Voxtral 2 potrafił również oznaczać czasowo każde słowo (timestamp_granularities=["word"]). Voxtral 3 tego już nie oferuje: granularność word zwraca błąd 400, a przewodnik migracyjny Mistral instruuje użytkowników, by przeszli na segmenty. Przypadki użycia wymagające wyrównania słowo po słowie – napisy w stylu karaoke, podświetlanie bieżącego słowa, szczegółowa analiza tempa mowy – muszą teraz opierać się na segmentach, potencjalnie rozdzielając czas trwania segmentu między jego słowa za pomocą estymacji po stronie klienta.

def estimer_mots(segment):
    """Rozdziela czas trwania segmentu między jego słowa, proporcjonalnie do ich długości (szacunek)."""
    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

Jest to przybliżenie, przydatne do wyświetlania progresywnego, ale nie do analizy prozodyjnej: jeśli dokładne wyrównanie słów jest kluczowe, rozwiązaniem pozostaje dedykowane narzędzie do wymuszonego wyrównania (forced alignment) zastosowane po transkrypcji.

Generowanie napisów w formacie SRT

Format SRT nie jest niczym tajemniczym: numer sekwencyjny, zakres czasu w formacie HH:MM:SS,mmm, tekst i pusta linia. Poniższa funkcja iteruje przez segmenty i dzieli te, które przekroczyłyby komfortową szerokość wyświetlania, ustawioną tutaj na sześćdziesiąt znaków.

def generate_srt_from_segments(segments, max_chars=60):
    """Generuje plik SRT z segmentów Voxtral."""
    srt_lines = []
    counter = 1

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

        # Podział zbyt długich segmentów
        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):
    """Konwertuje sekundy na 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}"

# Użycie
srt_contenu = generate_srt_from_segments(response.segments)
with open("sous_titres.srt", "w", encoding="utf-8") as f:
    f.write(srt_contenu)

print("Plik SRT wygenerowany pomyślnie")

Nawigacja po długich nagraniach

Kolejnym bezpośrednim zastosowaniem segmentów jest budowanie podsumowania temporalnego. Poniższy skrypt oznacza punkt kontrolny co pięć minut i wyświetla kilka pierwszych słów, dając czytelnikowi mapę nagrania jeszcze przed jego odsłuchaniem.

def create_temporal_index(segments, interval_minutes=5):
    """Tworzy indeks co 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

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

W Voxtral 2 parametr timestamp_granularities był niekompatybilny z parametrem language. Dokumentacja Voxtral 3 nie wspomina już o tym ograniczeniu: zweryfikuj to testem przed połączeniem obu parametrów w przetwarzaniu produkcyjnym.

Kluczowe wnioski

  • Tylko jedna granularność w Voxtral 3: "segment" ("word" zwraca błąd 400)
  • Wyrównanie słowo po słowie, jeśli konieczne, jest szacowane na podstawie segmentów lub obsługiwane przez narzędzie do wyrównania
  • Znaczniki czasu są w sekundach (liczby dziesiętne), z polami start i end dla każdego segmentu
  • Idealne do tworzenia napisów SRT/VTT, nawigacji temporalnej i indeksowania
  • Niekompatybilność z language znana z Voxtral 2 nie jest już udokumentowana: zweryfikuj to testem