How to Verify a Voice with Open-Source Tools Cómo Verificar una Voz con Herramientas de Código Abierto

Actualización — 23 de mayo de 2026

Una nota práctica sobre calidad de audio que surgió durante el trabajo forense de Hondurasgate: analizar siempre el audio lo más cerca posible de la grabación original. Cada plataforma que toca un archivo de audio lo recodifica — YouTube convierte a OGG/Opus a 8.000 Hz; WhatsApp y Telegram aplican sus propios codecs; las plataformas de streaming remuestrean y comprimen. Cada recodificación introduce artefactos sistemáticos — irregularidades espectrales periódicas, discontinuidades de fase, cambios de ganancia en los límites del codec — que los detectores de ENF y flux espectral de esta guía marcarán como anomalías. En audio muy recodificado pueden acumularse decenas de falsos positivos que son, a nivel de señal, indistinguibles de un corte de edición real.

La regla es simple: trabajar siempre desde el archivo más cercano a la grabación original. Para Hondurasgate específicamente, los archivos OGG originales están disponibles para descarga directa en hondurasgate.ch — usar esos, no las copias de YouTube. Para otras investigaciones: si la publicación pone los originales a disposición bajo solicitud, hay que pedirlos. Si solo se tiene acceso a una copia recodificada por una plataforma, documentarlo explícitamente e interpretar los resultados de ENF y flux espectral con precaución adicional: el comportamiento base de estos métodos cambia significativamente con audio comprimido por codec. En caso de duda, comparar el SHA-256 del archivo con cualquier hash publicado para confirmar exactamente qué versión se está usando.

Esta es una guía práctica de los métodos utilizados en la verificación forense independiente de las grabaciones de audio de Hondurasgate. Todo funciona con herramientas gratuitas de código abierto. Sin software comercial, sin licencias propietarias. Cualquier periodista, investigador o persona curiosa con un portátil puede replicarlo.

La guía cubre dos preguntas separadas:

1. ¿Esta voz es la persona que se dice? — verificación de hablante con WavLM-Base+
2. ¿Fue editado el audio o ensamblado de grabaciones separadas? — detección de edición con tres métodos independientes

Son preguntas distintas con métodos distintos. Ninguna respuesta depende de la otra.

Qué se necesita

Python 3.8+ y ffmpeg instalados en tu sistema.

pip install torch torchaudio transformers soundfile scipy librosa numpy

Instalación de ffmpeg:

• Linux: sudo apt install ffmpeg
• Mac: brew install ffmpeg
• Windows: descargar desde ffmpeg.org y agregar al PATH

El modelo WavLM (~400 MB) se descarga automáticamente desde HuggingFace al primer uso.

Parte 1 — Verificación de Hablante

El modelo: WavLM-Base+

microsoft/wavlm-base-plus-sv es un modelo de 101 millones de parámetros desarrollado por Microsoft Research, preentrenado con predicción de habla enmascarada y ajustado para verificación de hablante en el benchmark SUPERB. Está revisado por pares, documentado públicamente y es gratuito. Convierte un segmento de audio en un embedding de 256 dimensiones — una huella numérica del tracto vocal del hablante — y compara dos embeddings mediante similitud coseno. Los scores van de 0 a 1. Valores próximos a 1 indican el mismo hablante.

Paso 1 — Convertir todo el audio a WAV 16kHz mono

Hacer esto antes de cualquier otra cosa elimina variación irrelevante de distintos micrófonos y codecs.

ffmpeg -y -i entrada.mp3 -ar 16000 -ac 1 salida.wav

Para OGG, M4A u otros formatos, reemplazar entrada.mp3. Los flags son siempre los mismos: -ar 16000 (frecuencia de muestreo) y -ac 1 (mono).

Paso 2 — Cargar el modelo

from transformers import Wav2Vec2FeatureExtractor, WavLMForXVector
import torch
import soundfile as sf
import numpy as np

MODEL_ID = "microsoft/wavlm-base-plus-sv"
feature_extractor = Wav2Vec2FeatureExtractor.from_pretrained(MODEL_ID)
model = WavLMForXVector.from_pretrained(MODEL_ID)
model.eval()

TARGET_SR = 16000

def get_embedding(wav_path):
    audio, sr = sf.read(wav_path)
    if sr != TARGET_SR:
        raise ValueError(f"Frecuencia incorrecta: {sr}, esperada {TARGET_SR}")
    if audio.ndim > 1:
        audio = audio.mean(axis=1)
    inputs = feature_extractor(
        audio,
        sampling_rate=TARGET_SR,
        return_tensors="pt",
        padding=True
    )
    with torch.no_grad():
        output = model(**inputs)
    emb = output.embeddings
    emb = torch.nn.functional.normalize(emb, dim=-1)
    return emb.squeeze()

def cosine_similarity(emb1, emb2):
    return torch.nn.functional.cosine_similarity(
        emb1.unsqueeze(0), emb2.unsqueeze(0)
    ).item()

Paso 3 — Construir un embedding de referencia

Se necesitan grabaciones de referencia conocidas de la persona que se quiere identificar. Deben ser de apariciones públicas documentadas — entrevistas, discursos, conferencias de prensa — donde no haya duda sobre quién habla. Más referencias es mejor; usar al menos dos.

ref_files = [
    "referencia_1.wav",
    "referencia_2.wav",
    "referencia_3.wav",
]

ref_embeddings = []
for f in ref_files:
    emb = get_embedding(f)
    ref_embeddings.append(emb)

# Promedio y re-normalización — reduce el efecto de variación
# acústica en una sola muestra
avg_ref = torch.stack(ref_embeddings).mean(dim=0)
avg_ref = torch.nn.functional.normalize(avg_ref, dim=0)

Paso 4 — Calibrar (el paso que más se omite, y no debería)

Un score de 0,80 no significa nada sin contexto. Hay que saber cómo se ve “mismo hablante” y “hablante distinto” para este modelo, con estas condiciones de audio, para esta persona concreta.

Antes de analizar ningún audio desconocido, ejecutar el modelo contra identidades conocidas:

# Controles positivos — misma persona, grabaciones distintas
# Deben dar scores altos (mismo hablante)
for i in range(len(ref_embeddings)):
    for j in range(i + 1, len(ref_embeddings)):
        s = cosine_similarity(ref_embeddings[i], ref_embeddings[j])
        print(f"Ref {i+1} vs Ref {j+1}: {s:.4f}  [mismo hablante — debe ser alto]")

# Control negativo — una persona distinta conocida
# Debe dar score claramente más bajo
neg_emb = get_embedding("hablante_distinto_conocido.wav")
neg_score = cosine_similarity(avg_ref, neg_emb)
print(f"Control negativo: {neg_score:.4f}  [hablante distinto — debe ser bajo]")

Lo que se busca es una brecha clara entre los dos rangos. En el análisis de Hondurasgate:

• Mismo hablante (Cossette vs referencias de Cossette): 0,95–0,98
• Hablante distinto (Cossette vs control negativo JOH): 0,66–0,72
• Brecha: ~0,23 puntos

El umbral de decisión se establece sobre esta brecha — no desde un manual. Un umbral conservador se sitúa bien por encima del extremo superior del control negativo. En este análisis se usó 0,88.

Paso 5 — Analizar el audio desconocido

THRESHOLD = 0.88  # Establecer según TU calibración, no este ejemplo

test_files = [
    "audio_desconocido_1.wav",
    "audio_desconocido_2.wav",
]

for audio_file in test_files:
    test_emb = get_embedding(audio_file)
    score = cosine_similarity(avg_ref, test_emb)
    result = "MISMO HABLANTE" if score >= THRESHOLD else "HABLANTE DISTINTO"
    print(f"{audio_file}: {score:.4f} → {result}")

Interpretación de scores

Estos rangos solo aplican si la calibración muestra una brecha similar. Si los controles positivos y negativos están cerca, el modelo no discrimina bien para esa combinación de hablante/audio — y los resultados no deben reportarse como concluyentes.

Qué prueba este método y qué no

Parte 2 — Detección de Edición

Una grabación puede contener la voz real de alguien diciendo cosas reales en momentos reales — editadas para crear una conversación que nunca ocurrió como se presenta. Esta es una pregunta distinta a la de identidad del hablante, y requiere métodos distintos.

Se aplican tres métodos independientes en paralelo. Los tres deben ejecutarse también sobre una grabación de referencia no editada para establecer el comportamiento base — hay que saber cuántos “falsos positivos” produce el detector sobre audio limpio antes de poder interpretar resultados sobre audio desconocido.

Método 1 — ENF (Frecuencia de la Red Eléctrica)

Qué detecta: Las redes eléctricas operan a una frecuencia nominal (50 Hz en Europa, 60 Hz en América) que fluctúa ligeramente y de forma única en el tiempo. Los dispositivos de grabación capturan esto como una señal tenue. Un corte entre grabaciones realizadas en momentos distintos produce una discontinuidad de fase que no corresponde a la variación natural continua.

Qué buscar: hits concentrados en uno o dos momentos específicos (empalme real) vs. hits distribuidos uniformemente (artefactos de compresión).

import numpy as np
from scipy import signal

def analyze_enf(wav_path, grid_freq=60, sr=16000):
    audio, _ = sf.read(wav_path)
    
    window_size = sr       # ventanas de 1 segundo
    hop_size = sr // 2     # salto de 0,5s
    harmonics = [grid_freq, grid_freq*2, grid_freq*3, grid_freq*4]
    
    # Rastrear cada armónico por separado a lo largo del tiempo
    phases = {h: [] for h in harmonics}
    
    for start in range(0, len(audio) - window_size, hop_size):
        segment = audio[start:start + window_size]
        for h in harmonics:
            sos = signal.butter(4, [h - 0.5, h + 0.5],
                                btype='band', fs=sr, output='sos')
            filtered = signal.sosfilt(sos, segment)
            analytic = signal.hilbert(filtered)
            phase = np.angle(np.mean(analytic))  # media circular — correcto para ángulos
            phases[h].append(phase)
    
    # Detectar discontinuidades — comparar el mismo armónico en el tiempo
    hits = []
    for h in harmonics:
        for i in range(1, len(phases[h])):
            delta = abs(phases[h][i] - phases[h][i-1])
            if delta > 0.8:  # umbral en radianes
                hits.append(i)
    
    hits_per_second = len(hits) / (len(audio) / sr)
    print(f"Hits ENF: {len(hits)} ({hits_per_second:.2f}/s)")
    return hits

Método 2 — Perfil de ruido de fondo

Qué detecta: Cada entorno de grabación tiene una huella espectral de ruido característica. Empalmar grabaciones de entornos distintos cambia ese perfil en el punto de unión.

Qué buscar: cambios abruptos en el perfil de ruido de fondo (empalme real) vs. perfil estable a lo largo de toda la grabación (grabación continua).

from scipy.signal import welch

def analyze_noise_profile(wav_path, sr=16000):
    audio, _ = sf.read(wav_path)
    
    segment_len = sr * 2  # segmentos de 2 segundos
    profiles = []
    
    for start in range(0, len(audio) - segment_len, segment_len):
        segment = audio[start:start + segment_len]
        freqs, psd = welch(segment, fs=sr, nperseg=sr//2)
        # Ruido de fondo = percentil 10 de la PSD
        noise_floor = np.percentile(psd, 10)
        profiles.append(psd / (noise_floor + 1e-10))
    
    # Detectar cambios entre perfiles consecutivos
    dists = [np.linalg.norm(profiles[i] - profiles[i-1])
             for i in range(1, len(profiles))]
    if len(dists) < 2:
        return []
    mean_d = np.mean(dists)
    std_d = np.std(dists) + 1e-10
    changes = [i + 1 for i, d in enumerate(dists)
               if (d - mean_d) / std_d > 2.5]
    
    print(f"Cambios en perfil de ruido: {len(changes)}")
    return changes

Cero cambios es el indicador más robusto de que la grabación es continua. Es más difícil de falsificar que el ENF, porque preservar un perfil de ruido consistente a través de grabaciones empalmadas requiere un cuidado extraordinario.

Método 3 — Flux espectral

Qué detecta: La voz natural produce cambios espectrales graduales entre frames. Un corte de edición produce un pico abrupto.

Qué buscar: picos aislados de flux alto (empalme real) vs. flux distribuido uniformemente (variación natural del habla).

import librosa

def analyze_spectral_flux(wav_path, sr=16000):
    audio, _ = sf.read(wav_path)
    
    # Parámetros STFT
    n_fft = int(0.030 * sr)      # frames de 30ms
    hop_length = int(0.010 * sr)  # salto de 10ms
    
    stft = np.abs(librosa.stft(audio, n_fft=n_fft, hop_length=hop_length,
                                window='hann'))
    
    # Flux = suma de incrementos positivos del espectro entre frames
    flux = np.sum(np.maximum(0, np.diff(stft, axis=1)), axis=0)
    
    # Excluir primeros y últimos 0,5s (artefactos de borde)
    margin = int(0.5 * sr / hop_length)
    flux_trimmed = flux[margin:-margin]
    
    # Detectar picos
    mean_flux = np.mean(flux_trimmed)
    std_flux = np.std(flux_trimmed)
    hits = np.where(flux_trimmed > mean_flux + 4.0 * std_flux)[0]
    
    hits_per_second = len(hits) / (len(audio) / sr)
    print(f"Picos de flux espectral: {len(hits)} ({hits_per_second:.2f}/s)")
    return hits

Interpretación de resultados de detección de edición

Ejecutar los tres métodos primero sobre la referencia no editada. Anotar los números base. Luego ejecutar sobre el audio desconocido.

En el análisis de Hondurasgate, ambas grabaciones desconocidas mostraron tasas de hits estadísticamente idénticas al baseline no editado y cero cambios en el perfil de ruido. Conclusión: no se detectaron indicadores de edición.

Lo que la detección de edición no puede descartar

Un editor experto que preserve cuidadosamente la continuidad de fase ENF y el perfil de ruido podría evadir estos métodos. Para un análisis de mayor confianza, correlacionar la señal ENF con la base de datos histórica de frecuencia de la red eléctrica del período de grabación — esto también puede establecer la fecha y ubicación de la grabación. En Honduras, esa base de datos la tiene la ENEE y no es pública.

Ejecutarlo todo junto

# Pipeline completo
reference_file = "referencia_no_editada.wav"  # grabación limpia conocida
audio_file = "desconocido.wav"

# Convertir primero si hace falta:
# subprocess.run(["ffmpeg", "-y", "-i", "desconocido.mp3",
#                 "-ar", "16000", "-ac", "1", audio_file], check=True)

# Establecer baseline sobre referencia no editada
ref_audio, _ = sf.read(reference_file)
ref_duration = len(ref_audio) / 16000
ref_flux_hits = analyze_spectral_flux(reference_file)
ref_noise_changes = analyze_noise_profile(reference_file)
baseline_hits_per_sec = len(ref_flux_hits) / ref_duration
baseline_noise_changes = len(ref_noise_changes)

# Analizar audio desconocido
unknown_audio, _ = sf.read(audio_file)
unknown_duration = len(unknown_audio) / 16000

print("=== VERIFICACIÓN DE HABLANTE ===")
test_emb = get_embedding(audio_file)
score = cosine_similarity(avg_ref, test_emb)
print(f"Score: {score:.4f} | Umbral: {THRESHOLD}")
print(f"Resultado: {'MISMO HABLANTE' if score >= THRESHOLD else 'HABLANTE DISTINTO'}")

print("\n=== DETECCIÓN DE EDICIÓN ===")
enf_hits = analyze_enf(audio_file)
noise_changes = analyze_noise_profile(audio_file)
flux_hits = analyze_spectral_flux(audio_file)

print(f"\nBaseline (referencia no editada): {baseline_hits_per_sec:.2f} hits flux/s, "
      f"{baseline_noise_changes} cambios de ruido")
print(f"Audio desconocido: {len(flux_hits)/unknown_duration:.2f} hits flux/s, "
      f"{len(noise_changes)} cambios de ruido")

El código es mecánico. El juicio es tuyo — reporta qué dicen los números, cuál fue la calibración y cuáles son los límites del método. Eso es lo que distingue un análisis forense de un número disfrazado de conclusión.