Detecta y etiqueta deepfakes para cumplir con la Directiva UE 2024

Guía práctica, comparativa de herramientas y tutorial paso a paso

Introducción

En los últimos meses “Deepfake Detective 2024” se ha convertido en la frase más buscada en Google, Bing y YouTube. La nueva Directiva europea sobre contenidos sintéticos exige que cualquier plataforma, medio o anunciante identifique y etiquete los deepfakes con al menos un 90 % de precisión.

Si tu empresa publica videos, gestionas campañas publicitarias o simplemente quieres evitar sanciones de hasta el 6 % de tu facturación anual, este artículo es tu hoja de ruta: entender la normativa, elegir la herramienta adecuada y montar tu propio detector para YouTube, TikTok o cualquier otro canal.

1. ¿Qué obliga la Directiva UE y por qué es crítico actuar ahora?

Tip: Si tu contenido no está catalogado como “alto riesgo”, aún así conviene usar una herramienta fiable para no quedar expuesto a auditorías inesperadas.

2. Comparativa rápida de las mejores soluciones (2024)

Recomendación: Para cumplir con la Directiva, elige Sensity AI o Microsoft Video Indexer (plan pago), ya que ambos superan el 90 % y ofrecen registro de auditoría obligatorio.

3. Monta tu propio detector de deepfakes (ejemplo práctico)

A continuación, un tutorial paso a paso usando la librería DeepTrace y FFmpeg. Funciona en cualquier máquina con Python 3.9+ y permite procesar videos de YouTube o TikTok descargados localmente.

3.1 Instalación de dependencias

# Instala ffmpeg (para Linux/macOS)
sudo apt-get install ffmpeg   # Debian/Ubuntu
# o brew install ffmpeg      # macOS

# Crea un entorno virtual
python -m venv venv
source venv/bin/activate

# Instala la librería y sus requisitos
pip install deeptrace==0.2.1 opencv-python tqdm

3.2 Descarga del video (YouTube)

pip install yt-dlp
yt-dlp -f best -o "%(title)s.%(ext)s" "https://www.youtube.com/watch?v=EjemploID"

3.3 Script de detección

import cv2
import numpy as np
from deeptrace import DeepFakeDetector
from tqdm import tqdm
import os, sys

# Parámetros
VIDEO_PATH = sys.argv[1] if len(sys.argv) > 1 else "video.mp4"
OUTPUT_JSON = "resultado.json"

# Inicializa detector (modelo pre‑entrenado)
detector = DeepFakeDetector(model_name="xception", device="cpu")

# Abre video
cap = cv2.VideoCapture(VIDEO_PATH)
frame_count = int(cap.get(cv2.CAP_PROP_FRAME_COUNT))
fps = cap.get(cv2.CAP_PROP_FPS)

scores = []
for _ in tqdm(range(frame_count), desc="Analizando frames"):
    ret, frame = cap.read()
    if not ret:
        break
    # Redimensiona a 299×299 (requerido por Xception)
    frame_resized = cv2.resize(frame, (299, 299))
    score = detector.predict(frame_resized)   # devuelve probabilidad de deepfake
    scores.append(score)

cap.release()

# Agrega etiqueta al video (metadata)
average_score = np.mean(scores)
label = "deepfake" if average_score > 0.90 else "authentic"

# Guardamos resultados (para auditoría)
result = {
    "video": os.path.basename(VIDEO_PATH),
    "average_score": float(average_score),
    "label": label,
    "frames_analyzed": len(scores),
    "fps": fps
}
import json
with open(OUTPUT_JSON, "w", encoding="utf-8") as f:
    json.dump(result, f, ensure_ascii=False, indent=2)

print(f"\n✅ Resultado guardado en {OUTPUT_JSON}")
print(f"Etiqueta sugerida: {label.upper()} (score medio = {average_score:.3f})")

Cómo usarlo

python detect_deepfake.py "MiVideoDescargado.mp4"

El script genera resultado.json con la puntuación media y la etiqueta que puedes añadir a la descripción del video o a los metadatos de la plataforma (por ejemplo, usando la API de YouTube Data).

3.4 Automatiza el etiquetado en YouTube (API)

pip install google-api-python-client oauth2client

from googleapiclient.discovery import build
from oauth2client.service_account import ServiceAccountCredentials
import json

# Carga resultados
with open("resultado.json") as f:
    data = json.load(f)

# Credenciales de servicio (crear en Google Cloud Console)
SCOPES = ["https://www.googleapis.com/auth/youtube.force-ssl"]
creds = ServiceAccountCredentials.from_json_keyfile_name("service_account.json", SCOPES)
youtube = build("youtube", "v3", credentials=creds)

# Busca el video por ID (asume que el nombre del archivo incluye el ID)
video_id = "EjemploID"
request = youtube.videos().list(part="snippet", id=video_id)
response = request.execute()
snippet = response["items"][0]["snippet"]

# Añade etiqueta de cumplimiento
new_tags = snippet.get("tags", [])
if data["label"] == "deepfake":
    new_tags.append("deepfake")
else:
    new_tags.append("authentic")
snippet["tags"] = list(set(new_tags))

# Actualiza video
youtube.videos().update(
    part="snippet",
    body={"id": video_id, "snippet": snippet}
).execute()

print("✅ Etiqueta actualizada en YouTube")

Nota legal: Solo usa este flujo automático si la puntuación supera el 90 % y tienes la certificación correspondiente.

4. Buenas prácticas para mantener el cumplimiento

1. Registra cada análisis (fecha, archivo, puntuación, versión del modelo).
2. Re‑entrena tu modelo cada 6 meses con los últimos datasets de la European AI Observatory.
3. Implementa un proceso de revisión humana para los casos con score entre 0.85 – 0.90.
4. Mantén una política de retención: guarda logs de auditoría al menos 24 meses.
5. Comunica al usuario la presencia de contenido sintético mediante un banner o etiqueta visible (ej.: “⚠️ Este video contiene IA sintética”).

5. Conclusiones

• La Directiva UE sobre contenidos sintéticos ya está en vigor y exige una precisión mínima del 90 % para etiquetar deepfakes.
• Herramientas certificadas como Sensity AI o Microsoft Video Indexer (plan pago) cumplen con la normativa y facilitan el registro de auditoría.
• Con pocos comandos y un script Python puedes crear tu propio detector, validar la precisión y, mediante la API de YouTube, aplicar automáticamente la

Herramienta mencionada: Heroku