LeoJulieta

Posted on Oct 3

Crea tu filtro anti‑deepfake en tiempo real sin ser experto

#deepfake #detector #desinformación #espanol

Detecta y bloquea deepfakes en tiempo real: guía práctica para crear tu propio filtro anti‑desinformación en 2026

Introducción

¿Te preocupa que en las próximas elecciones aparezcan videos falsos de los candidatos? No estás solo: la búsqueda “detector de deepfake gratis” ha explotado en los últimos meses. En este artículo te muestro, paso a paso y sin necesidad de ser experto en IA, cómo montar un filtro local que identifique deepfakes en tiempo real, lo integre en tu navegador y lo pueda usar cualquier medio o creador de contenido.

1. ¿Por qué necesitas tu propio detector ahora?

Motivo	Datos recientes (2026)
Manipulación electoral	Más de 1 200 videos falsos detectados 48 h antes de votaciones en tres democracias emergentes (Berkman Klein Center).
Aumento en redes sociales	TikTok, Instagram y YouTube registran +73 % de contenido sospechoso desde enero (Meta Trust & Safety).
Límites de las APIs oficiales	Meta Deepfake Detector API → 500 peticiones/día y suscripción premium.
Calidad de los deepfakes	Modelos como Stable Diffusion 3‑Video generan videos indistinguibles a simple vista.

Con estos números, depender de herramientas gratuitas de terceros es arriesgado. Un detector propio te da control total, sin cuotas ni restricciones.

2. Arquitectura mínima del filtro

┌─────────────────┐      ┌───────────────────────┐
│  Entrada video │──►│  Extracción de frames │──►│  Modelo de detección  │
└─────────────────┘      └───────────────────────┘
                                   │
                                   ▼
                        ┌─────────────────────┐
                        │  Resultado (real/fake)│
                        └─────────────────────┘

Extracción de frames: ffmpeg o la API Canvas del navegador.
Modelo de detección: un modelo ligero basado en XceptionNet fine‑tuned para deepfakes (≈ 30 MB).
Post‑procesado: suavizado temporal para evitar falsos positivos en clips cortos.

3. Preparar el entorno (Linux/macOS/WSL)

# 1. Crear entorno virtual
python3 -m venv venv
source venv/bin/activate

# 2. Instalar dependencias
pip install torch torchvision torchaudio --extra-index-url https://download.pytorch.org/whl/cpu
pip install opencv-python tqdm transformers

# 3. Descargar modelo pre‑entrenado (Xception‑DeepFake 2026)
wget -O model.pt https://huggingface.co/anti-deepfake/xception-2026/resolve/main/model.pt

Tip: Si dispones de GPU, añade pip install torch==2.*+cu118 -f https://download.pytorch.org/whl/torch_stable.html para acelerar la inferencia.

4. Código práctico: detector en Python (CLI)

import cv2, torch, argparse, numpy as np
from torchvision import transforms
from tqdm import tqdm

# Cargar modelo
model = torch.load('model.pt', map_location='cpu')
model.eval()

# Pre‑procesado que usó el entrenamiento
preprocess = transforms.Compose([
    transforms.ToPILImage(),
    transforms.Resize((299, 299)),
    transforms.ToTensor(),
    transforms.Normalize(mean=[0.5]*3, std=[0.5]*3)
])

def frame_score(frame):
    with torch.no_grad():
        inp = preprocess(frame).unsqueeze(0)
        prob = torch.nn.functional.softmax(model(inp), dim=1)[0,1].item()
    return prob      # >0.5 → fake

def detect_video(path, out):
    cap = cv2.VideoCapture(path)
    fps = cap.get(cv2.CAP_PROP_FPS)
    width  = int(cap.get(cv2.CAP_PROP_FRAME_WIDTH))
    height = int(cap.get(cv2.CAP_PROP_FRAME_HEIGHT))
    writer = cv2.VideoWriter(out,
            cv2.VideoWriter_fourcc(*'mp4v'), fps, (width, height))

    scores = []
    while True:
        ret, frame = cap.read()
        if not ret: break
        prob = frame_score(frame)
        scores.append(prob)

        # Marca visual
        label = f'FAKE {prob:.2f}' if prob>0.5 else f'REAL {prob:.2f}'
        cv2.putText(frame, label, (10,30),
                    cv2.FONT_HERSHEY_SIMPLEX, 1,
                    (0,0,255) if prob>0.5 else (0,255,0), 2)
        writer.write(frame)

    cap.release()
    writer.release()
    print(f'Video procesado → {out}')
    print(f'Promedio de probabilidad fake: {np.mean(scores):.3f}')

if __name__ == '__main__':
    p = argparse.ArgumentParser()
    p.add_argument('input', help='Video de entrada')
    p.add_argument('output', help='Video con anotaciones')
    args = p.parse_args()
    detect_video(args.input, args.output)

Cómo usarlo

python detect.py elecciones_2026.mp4 salida_analizada.mp4

El script muestra en cada frame una etiqueta verde (real) o roja (fake) y guarda un nuevo video con esas marcas.

5. Extenderlo al navegador (Chrome/Edge)

Crear una extensión mínima (manifest.json)

{
  "manifest_version": 3,
  "name": "Filtro anti‑deepfake",
  "version": "1.0",
  "permissions": ["activeTab", "scripting"],
  "background": { "service_worker": "bg.js" },
  "content_scripts": [{
    "matches": ["<all_urls>"],
    "js": ["content.js"]
  }]
}

bg.js – Inyecta el modelo vía WebAssembly (ONNX)

chrome.runtime.onInstalled.addListener(() => {
  chrome.scripting.registerContentScripts([{
    id: "inject-detector",
    matches: ["<all_urls>"],
    js: ["detector.js"],
    runAt: "document_idle"
  }]);
});

detector.js – Usa tfjs para inferencia en cada frame de <video>

(async () => {
  const model = await tf.loadGraphModel('model.onnx'); // modelo convertido a ONNX
  const videos = document.querySelectorAll('video');

  videos.forEach(v => {
    const canvas = document.createElement('canvas');
    const ctx = canvas.getContext('2d');

    v.addEventListener('play', () => {
      const loop = async () => {
        if (v.paused || v.ended) return;
        canvas.width = v.videoWidth;
        canvas.height = v.videoHeight;
        ctx.drawImage(v, 0, 0, canvas.width, canvas.height);
        const img = tf.browser.fromPixels(canvas).resizeBilinear([299,299]).div(255).expandDims(0);
        const pred = await model.predict(img).data();
        const prob = pred[1]; // probabilidad de fake
        // Dibujar overlay
        const overlay = document.createElement('div');
        overlay.style.position = 'absolute';
        overlay.style.left = `${v.offsetLeft}px`;
        overlay.style.top = `${v.offsetTop}px`;
        overlay.style.color = prob>0.5 ? 'red' : 'lime';
        overlay.textContent = prob>0.5 ? `FAKE (${prob.toFixed(2)})` : `REAL (${prob.toFixed(2)})`;
        document.body.appendChild(overlay);
        setTimeout(loop, 500); // cada 0.5 s
      };
      loop();
    });
  });
})();

Instalación rápida

Abre chrome://extensions/ → Modo desarrollador → Cargar sin empaquetar.
Selecciona la carpeta con los tres archivos (manifest.json, bg.js, detector.js).
Recarga cualquier página con videos y observa la etiqueta en tiempo real.

6. Mejores prácticas y limitaciones

Tema	Recomendación
Actualización del modelo	Cada 3‑4 meses descarga la última versión de HuggingFace (`model.pt` o `model.onnx`).
Privacidad	El detector funciona localmente; nunca subas los frames a servidores externos.
Umbral	Ajusta el `0.5` a `0.65` si notas muchos falsos positivos en videos con baja calidad.
Hardware	En móviles, usa la versión TensorFlow Lite del modelo (≈ 8 MB) para mantener la fluidez.
Falsos negativos	Los deepfakes basados

DEV Community