Ir para o conteúdo principal
Português— Escolher um idioma
Menu

Carimbos de data/hora e segmentação temporal

Aula 6 de 16 Atualizada a 3 de novembro de 2026 Programador
Nesta página
  1. Estruturar a transcrição ao longo do tempo
  2. Granularidade por segmento: o bloco de fala
  3. E a granularidade por palavra?
  4. Gerar legendas em formato SRT
  5. Navegar em gravações longas
  6. Pontos-chave

Curso atualizado a 3 de novembro de 2026 para o Voxtral 3, com base no guia Migrate from Voxtral 2 da Mistral: os modelos Voxtral 2 (voxtral-mini-2602, voxtral-mini-transcribe-realtime-2602, voxtral-mini-tts-2603), preteridos a 31 de outubro de 2026 e desativados a 30 de abril de 2027, são substituídos nos exemplos por voxtral-mini-transcribe-3, voxtral-mini-transcribe-realtime-3 e voxtral-mini-tts-3-0. Alterações principais: os carimbos de data/hora são apenas por segmento (word devolve um erro 400), a diarização é possível em tempo real, as definições da sessão em tempo real ficam bloqueadas após o primeiro bloco de áudio e as entradas context_bias são de formato livre (frases com espaços). Fontes: Migrate from Voxtral 2 · Speech to Text.

Estruturar a transcrição ao longo do tempo

Uma transcrição bruta é útil, mas uma transcrição com carimbos de data/hora abre possibilidades muito mais ricas: legendagem, navegação temporal, sincronização de vídeo e extração de passagens específicas. Sem carimbos de data/hora, encontrar o momento em que se discutiu um orçamento numa gravação de duas horas exige adivinhação; com eles, basta uma pesquisa de texto seguida de um clique. O parâmetro timestamp_granularities do Voxtral dá-lhe este poder.

Granularidade por segmento: o bloco de fala

Um segmento é um bloco contínuo de fala — tipicamente uma frase ou um grupo de frases ditas sem uma pausa significativa. Esta é a granularidade que deve escolher por predefinição, pois corresponde à unidade natural de leitura.

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

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

O resultado tem este aspeto:

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

Esta decomposição suporta a navegação em gravações longas, a exibição de blocos de legendas e a indexação de passagens: cada segmento torna-se uma entrada pesquisável com o seu ponto de entrada no áudio.

E a granularidade por palavra?

O Voxtral 2 também conseguia atribuir carimbos de data/hora a cada palavra (timestamp_granularities=["word"]). O Voxtral 3 já não oferece esta funcionalidade: a granularidade word devolve um erro 400 e o guia de migração da Mistral instrui os utilizadores a mudarem para segmentos. Os casos de uso que exigiam alinhamento palavra por palavra — legendas estilo karaoké, realce da palavra atual, análise fina da velocidade da fala — devem agora recorrer a segmentos, distribuindo potencialmente o tempo de um segmento pelas suas palavras através de uma estimativa no lado do cliente.

def estimer_mots(segment):
    """Distribui a duração de um segmento pelas suas palavras, proporcionalmente ao seu comprimento (estimativa)."""
    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

Trata-se de uma aproximação, útil para exibição progressiva, mas não para análise prosódica: se o alinhamento exato por palavra for essencial, a solução continua a ser uma ferramenta de alinhamento forçado dedicada aplicada após a transcrição.

Gerar legendas em formato SRT

O formato SRT não tem nada de misterioso: um número de sequência, um intervalo de tempo no formato HH:MM:SS,mmm, o texto e uma linha em branco. A função abaixo itera pelos segmentos e divide aqueles que excederiam uma largura de exibição confortável, definida aqui em sessenta caracteres.

def generate_srt_from_segments(segments, max_chars=60):
    """Gera um ficheiro SRT a partir de segmentos do Voxtral."""
    srt_lines = []
    counter = 1

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

        # Dividir segmentos que são demasiado longos
        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):
    """Converte segundos para o formato 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}"

# Utilização
srt_contenu = generate_srt_from_segments(response.segments)
with open("sous_titres.srt", "w", encoding="utf-8") as f:
    f.write(srt_contenu)

print("Ficheiro SRT gerado com sucesso")

Outra aplicação direta dos segmentos é a construção de um resumo temporal. O script seguinte marca um ponto de controlo a cada cinco minutos e exibe as primeiras palavras, oferecendo ao leitor um mapa da gravação antes mesmo de a ouvir.

def create_temporal_index(segments, interval_minutes=5):
    """Cria um índice a cada N minutos."""
    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

# Utilização
for entry in create_temporal_index(response.segments, interval_minutes=5):
    print(entry)

Com o Voxtral 2, timestamp_granularities era incompatível com o parâmetro language. A documentação do Voxtral 3 já não menciona esta restrição: verifique-a com um teste antes de combinar os dois num processamento de produção.

Pontos-chave

  • Apenas uma granularidade com o Voxtral 3: "segment" ("word" devolve um erro 400)
  • O alinhamento palavra por palavra, se necessário, é estimado a partir de segmentos ou tratado por uma ferramenta de alinhamento
  • Os carimbos de data/hora estão em segundos (números decimais), com start e end para cada segmento
  • Ideal para legendagem SRT/VTT, navegação temporal e indexação
  • A incompatibilidade com language do Voxtral 2 já não está documentada: verifique-a com um teste