如何用 AI 在 Smart TV 上封鎖廣告：2024 年逐步教學

Bloqueador de anuncios con IA para Smart TV en 2024: guía práctica paso a paso

Introducción

¿Cansado de que tu serie favorita sea interrumpida cada 15 minutos por anuncios? En 2024 el bloqueador de anuncios con IA para Smart TV ha dejado de ser un experimento de hackers para convertirse en una herramienta al alcance de cualquier usuario que quiera recuperar ancho de banda y volver a disfrutar del contenido sin interrupciones.

Tras las detalladas guías publicadas en Hipertextual y Xataka, las búsquedas de “ad blocker smart tv” y “IA eliminar anuncios TV” han explotado en Google Trends, lo que confirma que miles de hogares están buscando una solución real y fácil de implementar. En este artículo encontrarás:

• Qué modelo publicitario hay en los televisores inteligentes.
• Cómo combinar un modelo de lenguaje ligero y visión por computadora para bloquear anuncios en tiempo real.
• Un tutorial completo con los comandos y scripts listos para ejecutarse en una Raspberry Pi, Intel NUC o NAS Synology.
• Benchmarks de latencia, consideraciones de seguridad y privacidad bajo GDPR, y una checklist de puesta en marcha.

1. ¿Qué necesitamos?

2. Arquitectura de la solución

[Smart TV] ──► [Router] ──► [Raspberry Pi / NAS] ──► Internet
                       │
                (iptables + DNS‑Masq)
                       │
        ┌──────────────┴───────────────┐
        │  Captura de paquetes (ffmpeg)│
        │  → extracción de frames      │
        │  → TinyYOLO (detección)      │
        │  → LLM (clasificación)      │
        │  → Drop / Forward            │
        └──────────────────────────────┘

• iptables redirige el tráfico HTTP/HTTPS del televisor al puerto local 8080.
• ffmpeg captura los flujos de vídeo y extrae un frame cada 0,5 s.
• TinyYOLO (modelo de 5 MB) detecta logotipos y banners en el frame.
• llama.cpp (LLM de 4 GB) confirma si el segmento corresponde a un anuncio.
• Si se detecta anuncio, el paquete se descarta; si no, se reenvía al router.

3. Instalación paso a paso

3.1. Preparar el dispositivo

# 1. Actualizar el SO
sudo apt update && sudo apt upgrade -y

# 2. Instalar dependencias
sudo apt install -y git build-essential cmake libssl-dev \
    libopencv-dev ffmpeg iptables-persistent python3-pip

# 3. Crear carpeta de trabajo
mkdir -p ~/adblock-ia && cd ~/adblock-ia

3.2. Descargar y compilar llama.cpp (LLM ligero)

git clone https://github.com/ggerganov/llama.cpp.git
cd llama.cpp
make -j$(nproc)
# Descargar un modelo quantizado (4 GB) – ejemplo: LLaMA‑7B‑Q4_K_M
wget https://huggingface.co/username/llama-7b-q4km/resolve/main/ggml-model-q4_0.bin

3.3. Obtener TinyYOLO y convertir a ONNX (solo una vez)

# Descargar pesos pre‑entrenados
wget https://github.com/ultralytics/yolov5/releases/download/v6.0/tinyyolo.pt
# Convertir a ONNX (requiere python y onnx)
pip install torch onnx onnxruntime
python - <<'PY'
import torch, onnx
model = torch.hub.load('ultralytics/yolov5', 'custom', path='tinyyolo.pt')
dummy = torch.randn(1,3,640,640)
torch.onnx.export(model, dummy, "tinyyolo.onnx", opset_version=12)
PY

3.4. Configurar iptables para redirigir tráfico

# Suponiendo que la IP del TV es 192.168.1.45
TV_IP=192.168.1.45
# Redirigir HTTP/HTTPS al puerto 8080 del Raspberry
sudo iptables -t nat -A PREROUTING -s $TV_IP -p tcp --dport 80 -j REDIRECT --to-port 8080
sudo iptables -t nat -A PREROUTING -s $TV_IP -p tcp --dport 443 -j REDIRECT --to-port 8080
# Guardar reglas
sudo netfilter-persistent save

3.5. Script principal (adblock_ia.py)

#!/usr/bin/env python3
import subprocess, time, os, json
import cv2
import onnxruntime as ort
from llama_cpp import Llama

# Cargar TinyYOLO
session = ort.InferenceSession("tinyyolo.onnx")
input_name = session.get_inputs()[0].name

# Cargar LLM
llm = Llama(model_path="ggml-model-q4_0.bin", n_ctx=512, n_threads=4)

def is_ad(frame):
    # Pre‑procesar frame para YOLO
    img = cv2.resize(frame, (640,640))
    img = img.astype('float32') / 255.0
    img = img.transpose(2,0,1)[None,...]
    # Inferencia YOLO
    preds = session.run(None, {input_name: img})[0]
    # Si se detecta logo/banner → posible anuncio
    if preds.max() > 0.5:
        # Preguntar al LLM (prompt corto)
        prompt = f"¿Este fragmento de vídeo contiene un anuncio? Responde sí o no."
        out = llm(prompt, max_tokens=4, temperature=0.0)
        return "sí" in out["choices"][0]["text"].lower()
    return False

def main():
    # Captura con ffmpeg (pipe a stdout)
    cmd = ["ffmpeg", "-i", "http://127.0.0.1:8080", "-vf", "fps=2", "-f", "image2pipe", "-vcodec", "png", "-"]
    proc = subprocess.Popen(cmd, stdout=subprocess.PIPE, bufsize=10**8)
    while True:
        # Leer un frame PNG
        raw = proc.stdout.read(1024*1024)  # tamaño máximo de un PNG
        if not raw:
            break
        np_arr = np.frombuffer(raw, np.uint8)
        frame = cv2.imdecode(np_arr, cv2.IMREAD_COLOR)
        if frame is None:
            continue
        if is_ad(frame):
            # Drop packet → no forward
            continue
        # Forward al router (simple tcpdump)
        subprocess.run(["tcpreplay", "--intf1=eth0", "--pps=1000"], input=raw)

if __name__ == "__main__":
    main()

Guarda el archivo, dale permisos y ejecútalo:

chmod +x adblock_ia.py
./adblock_ia.py &

4. Benchmarks de rendimiento

Los resultados se obtuvieron reproduciendo 2 h de contenido en Netflix (plan con anuncios) y midiendo la

Herramienta mencionada: Groq Cloud