Ir al contenido principal
Español— Elegir un idioma
Menú

Marcas de tiempo y segmentación temporal

Lección 6 de 16 Actualizado el 3 de noviembre de 2026 Desarrollador
En esta página
  1. Estructuración de la transcripción en el tiempo
  2. Granularidad de segmento: el bloque de habla
  3. ¿Y la granularidad por palabra?
  4. Generación de subtítulos en formato SRT
  5. Navegación en grabaciones largas
  6. Puntos clave

Curso actualizado el 3 de noviembre de 2026 para Voxtral 3, basado en la guía Migrate from Voxtral 2 de Mistral: los modelos de Voxtral 2 (voxtral-mini-2602, voxtral-mini-transcribe-realtime-2602, voxtral-mini-tts-2603), obsoletos desde el 31 de octubre de 2026 y retirados el 30 de abril de 2027, se sustituyen en los ejemplos por voxtral-mini-transcribe-3, voxtral-mini-transcribe-realtime-3 y voxtral-mini-tts-3-0. Cambios clave: las marcas de tiempo son solo por segmento (word devuelve un error 400), la diarización es posible en tiempo real, la configuración de la sesión en tiempo real se bloquea tras el primer fragmento de audio y las entradas de context_bias son de texto libre (frases con espacios). Fuentes: Migrate from Voxtral 2 · Speech to Text.

Estructuración de la transcripción en el tiempo

Una transcripción en bruto es útil, pero una transcripción con marcas de tiempo abre posibilidades mucho más ricas: subtitulado, navegación temporal, sincronización de vídeo y extracción de pasajes concretos. Sin marcas de tiempo, localizar el momento en que se habló del presupuesto en una grabación de dos horas requiere especular; con ellas, basta una búsqueda de texto seguida de un clic. El parámetro timestamp_granularities de Voxtral te da este poder.

Granularidad de segmento: el bloque de habla

Un segmento es un bloque continuo de habla, normalmente una frase o un grupo de frases pronunciadas sin una pausa significativa. Esta es la granularidad que elegirás por defecto, ya que corresponde a la unidad natural de lectura.

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 sobre los segmentos
for seg in response.segments:
    start = f"{seg.start:.1f}s"
    end = f"{seg.end:.1f}s"
    print(f"[{start} → {end}] {seg.text}")

La salida tiene este aspecto:

[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 desglose facilita la navegación en grabaciones largas, la visualización de bloques de subtítulos y la indexación de pasajes: cada segmento se convierte en una entrada buscable con su punto de entrada en el audio.

¿Y la granularidad por palabra?

Voxtral 2 también podía asignar marcas de tiempo a cada palabra (timestamp_granularities=["word"]). Voxtral 3 ya no ofrece esto: la granularidad word devuelve un error 400 y la guía de migración de Mistral indica a los usuarios que cambien a segmentos. Los casos de uso que requerían alineación palabra por palabra, como subtítulos estilo karaoke, el resaltado de la palabra actual o el análisis fino de la velocidad del habla, deben basarse ahora en segmentos, distribuyendo potencialmente el tiempo de un segmento entre sus palabras mediante una estimación del lado del cliente.

def estimer_mots(segment):
    """Distribuye la duración de un segmento entre sus palabras, proporcional a su longitud (estimación)."""
    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

Se trata de una aproximación, útil para la visualización progresiva pero no para el análisis prosódico: si la alineación exacta por palabra es esencial, la solución sigue siendo aplicar una herramienta de alineación forzada dedicada tras la transcripción.

Generación de subtítulos en formato SRT

El formato SRT no tiene misterio: un número de secuencia, un rango de tiempo en formato HH:MM:SS,mmm, el texto y una línea en blanco. La siguiente función itera sobre los segmentos y divide aquellos que superarían un ancho de visualización cómodo, establecido aquí en sesenta caracteres.

def generate_srt_from_segments(segments, max_chars=60):
    """Genera un archivo SRT a partir de segmentos de Voxtral."""
    srt_lines = []
    counter = 1

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

        # Dividir segmentos demasiado largos
        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):
    """Convierte segundos al 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}"

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

print("Archivo SRT generado correctamente")

Otra aplicación directa de los segmentos es la creación de un resumen temporal. El siguiente script marca un punto de control cada cinco minutos y muestra las primeras palabras, ofreciendo al lector un mapa de la grabación antes incluso de escucharla.

def create_temporal_index(segments, interval_minutes=5):
    """Crea un índice 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

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

Con Voxtral 2, timestamp_granularities era incompatible con el parámetro language. La documentación de Voxtral 3 ya no menciona esta restricción: verifícalo con una prueba antes de combinar ambos en el procesamiento de producción.

Puntos clave

  • Solo una granularidad con Voxtral 3: "segment" ("word" devuelve un error 400)
  • La alineación palabra por palabra, si es necesaria, se estima a partir de segmentos o se gestiona con una herramienta de alineación
  • Las marcas de tiempo están en segundos (números decimales), con start y end para cada segmento
  • Ideal para subtitulado SRT/VTT, navegación temporal e indexación
  • La incompatibilidad con language de Voxtral 2 ya no está documentada: verifícalo con una prueba