Evalúa transcripciones de IA con la tasa de error por palabra

Una transcripción fluida puede omitir una fecha límite o inventar una instrucción adicional. Antes de confiar en un flujo de transcripción automática de reuniones, compara su resultado con palabras que alguien haya contrastado con la grabación.

Este tutorial crea un evaluador local de la tasa de error por palabra con la biblioteca estándar de Python. No necesitas clave de API, descargar un modelo ni disponer de GPU. Los ejemplos son sintéticos: comprueban el evaluador, no un producto de transcripción.

1. Prepara transcripciones de referencia

Elige grabaciones parecidas a tu trabajo real: salas silenciosas y ruidosas, acentos pertinentes y voces superpuestas. La guía de precisión del reconocimiento de voz de Google recomienda audio representativo y textos de referencia revisados por personas.

Empieza con una prueba piloto pequeña; no constituye una comparación fiable entre productos. Obtén permiso para usar las grabaciones y evita exponer conversaciones privadas. Asigna un identificador estable a cada fragmento, escribe su referencia mientras lo escuchas y pide a otra persona que revise las palabras ambiguas. Fija estas referencias antes de examinar los resultados de las herramientas que compares.

Como contexto, nuestra introducción al reconocimiento de voz explica cómo el audio se convierte en texto. Aquí evaluamos la transcripción resultante en lugar de ejecutar un reconocedor.

2. Define las reglas de puntuación

La tasa de error por palabra, o WER, divide el número mínimo de sustituciones, eliminaciones e inserciones de palabras entre el número de palabras de referencia. Un valor menor es mejor; cero indica que no hay errores de palabras según tus reglas. Consulta la explicación de métricas de reconocimiento de voz de Hugging Face.

Decide la normalización antes de comparar sistemas. Este ejemplo ignora las mayúsculas y la mayor parte de la puntuación, conserva las letras acentuadas y trata de forma uniforme los apóstrofos internos. No equipara 9 con nine, no desarrolla contracciones ni evalúa la calidad de la puntuación. Aplica reglas idénticas a ambos textos; la explicación de normalización de Google describe por qué importan las convenciones de formato.

3. Ejecuta un evaluador pequeño

Guarda el siguiente código como evaluate_transcripts.py. Usa Python 3.10 o posterior. Mantén las frases de prueba en inglés sin cambios al seguir cualquiera de las dos versiones del artículo.

import re
import unicodedata


def words(text):
    text = unicodedata.normalize("NFC", text).casefold().replace("’", "'")
    return re.findall(r"[^\W_]+(?:'[^\W_]+)*", text)


def score(reference, hypothesis):
    ref, hyp = words(reference), words(hypothesis)
    if not ref:
        raise ValueError("reference has no words")
    previous = list(range(len(hyp) + 1))
    for i, expected in enumerate(ref, 1):
        current = [i]
        for j, actual in enumerate(hyp, 1):
            current.append(min(
                previous[j] + 1,
                current[j - 1] + 1,
                previous[j - 1] + (expected != actual),
            ))
        previous = current
    return previous[-1], len(ref)


CLIPS = [
    ("clean", "Send the draft today", "Send the draft today"),
    ("missing", "Meet at nine tomorrow", "Meet at tomorrow"),
    ("changed", "Email the final report", "Email a final report please"),
]

if __name__ == "__main__":
    total_errors = total_words = 0
    for clip_id, reference, hypothesis in CLIPS:
        errors, count = score(reference, hypothesis)
        total_errors += errors
        total_words += count
        print(f"{clip_id}: {errors}/{count} WER={errors / count:.1%}")
    print(f"corpus: {total_errors}/{total_words} "
          f"WER={total_errors / total_words:.1%}")

El bucle de programación dinámica encuentra la secuencia de cambios de palabras de menor coste. Devuelve el total de errores, no sus categorías individuales. Cuando quieras usar tus datos, sustituye las tres filas de prueba por tus identificadores, referencias y predicciones.

python3 evaluate_transcripts.py

4. Valida los resultados

Salida esperada, comprobada también localmente:

clean: 0/4 WER=0.0%
missing: 1/4 WER=25.0%
changed: 2/4 WER=50.0%
corpus: 3/12 WER=25.0%

El segundo fragmento omite nine; el tercero sustituye the por a y añade please. Son tres cambios en doce palabras de referencia.

Para obtener la puntuación del conjunto, suma los errores y las palabras de referencia y después divide. No promedies los porcentajes de los fragmentos: uno de dos palabras no debería pesar igual que otro de doscientas. Por ejemplo, un error en dos palabras más cero en ocho da un 10% global, no un 25%.

Ejecuta estas comprobaciones desde el directorio del script:

python3 - <<'PYTEST'
from evaluate_transcripts import score

assert score("Ready, NOW!", "ready now") == (0, 2)
assert score("send the draft", "send draft") == (1, 3)
assert score("send the draft", "") == (3, 3)
assert score("yes", "yes yes yes") == (2, 1)
assert score("reunio\u0301n", "REUNIÓN") == (0, 1)
try:
    score("...", "hello")
except ValueError as error:
    assert str(error) == "reference has no words"
else:
    raise AssertionError("empty reference accepted")
print("checks passed")
PYTEST

La salida esperada es checks passed, con código de salida 0. Estas comprobaciones cubren el formato, una eliminación, una predicción vacía, inserciones repetidas, acentos Unicode y el rechazo de una referencia vacía.

5. Resuelve problemas antes de comparar herramientas

• La WER supera el 100%: las palabras añadidas pueden superar en número a las de referencia. La comprobación de inserciones anterior produce un 200%; es válido, no un fallo de formato del porcentaje. Hugging Face explica este caso.
• Falla una referencia vacía: este evaluador la rechaza deliberadamente. Prueba por separado los fragmentos silenciosos contando las palabras de salida no deseadas; no descartes esos fallos sin registrarlos.
• Los números concentran los errores: acuerda las convenciones para transcribir números antes de puntuar. Mantén una comprobación exacta independiente para cantidades, fechas y nombres; eliminar la puntuación puede ocultar diferencias importantes.
• Cuesta localizar un error: vuelve a escuchar el audio e inspecciona las palabras alineadas. Para proyectos mayores, las herramientas de alineación de JiWER muestran sustituciones, eliminaciones e inserciones.

Compara las herramientas con los mismos fragmentos reservados y las mismas reglas de normalización. Presenta las puntuaciones de las condiciones difíciles por separado, además del resultado global. La WER por sí sola no evalúa etiquetas de hablantes, marcas de tiempo, puntuación ni si una negación ausente cambia una decisión.

Conclusión práctica

Conserva un conjunto de referencias revisadas, ejecuta el evaluador e inspecciona los errores importantes antes de elegir un flujo de transcripción. Si usas nuestra guía de notas de reuniones con Fireflies, aplica esta comprobación a las transcripciones exportadas antes de confiar en los resúmenes posteriores. Una transcripción legible también necesita verificación.