Ir al contenido principal
Español— Elegir un idioma
Menú

Detección de anomalías y duplicados

Lección 20 de 22 Actualizado el 29 de julio de 2026 Desarrollador
En esta página
  1. Objetivos
  2. Detección de anomalías
  3. Detección de duplicados semánticos
  4. Canalización de deduplicación
  5. Resumen

Objetivos

  • Detectar textos anómalos dentro de un corpus
  • Identificar duplicados semánticos
  • Construir una canalización de deduplicación

Detección de anomalías

Las dos aplicaciones de esta lección comparten la misma intuición, aplicada a los extremos opuestos de la escala de similitud. Un texto es «anómalo» si está semánticamente alejado de todo lo demás en el corpus; un texto es un duplicado si está demasiado cerca. Los embeddings te permiten medir esta distancia en ambos casos. La mayor parte del trabajo consiste en calibrar los umbrales.

El primer enfoque construye el centroide del corpus —la media de todos los vectores, que representa «el tema habitual de este corpus»— y luego mide cuánto se desvía cada texto de él. El umbral no es intencionadamente un valor absoluto, sino un percentil: no puedes saber de antemano cuán lejos se encuentra una anomalía, pero sí sabes que quieres examinar el 5 % más atípico.

from openai import OpenAI
import numpy as np

client = OpenAI()

def detect_anomalies(
    texts: list[str],
    percentile_threshold: float = 95,
    model: str = "text-embedding-3-large"
) -> list[dict]:
    """Detecta textos anómalos por distancia al centroide."""
    response = client.embeddings.create(
        input=texts, model=model
    )
    embeddings = np.array(
        [d.embedding for d in sorted(response.data, key=lambda x: x.index)]
    )

    # Centroide del corpus
    centroid = embeddings.mean(axis=0)
    centroid /= np.linalg.norm(centroid)

    # Distancia de cada texto al centroide
    similarities = embeddings @ centroid
    threshold = np.percentile(similarities, 100 - percentile_threshold)

    anomalies = []
    for i, sim in enumerate(similarities):
        if sim < threshold:
            anomalies.append({
                "index": i,
                "text": texts[i],
                "similarity": float(sim),
                "is_anomaly": True
            })

    return anomalies

# Ejemplo
corpus = [
    "Nuestra política de vacaciones ofrece 25 días al año",
    "Las vacaciones deben solicitarse con 2 semanas de antelación",
    "Los saldos de vacaciones son visibles en el portal de RR. HH.",
    "Se conceden vacaciones excepcionales con documentación justificativa",
    "SELECT * FROM users WHERE admin=1; DROP TABLE users;--",  # ¡Anomalía!
    "La política de trabajo remoto permite 3 días por semana",
]

anomalies = detect_anomalies(corpus)
for a in anomalies:
    print(f"  ANOMALÍA [{a['similarity']:.3f}] : {a['text'][:60]}...")

El corpus de ejemplo cuenta la historia por sí solo: cinco frases sobre políticas de RR. HH. y un intento de inyección SQL. Ningún filtro de palabras clave habría detectado la inyección sin una regla preescrita; la distancia al centroide la señala sin necesidad de anticipación alguna. Este es el argumento principal para usar el método al monitorizar un flujo de documentos entrantes.

El centroide tiene una debilidad: asume que el corpus gira en torno a un único tema. Si tus documentos cubren tres dominios muy diferentes, el punto medio cae en un vacío semántico y todos los textos parecen igualmente distantes. El enfoque de los k vecinos más cercanos (k-NN) evita esto juzgando cada texto basándose en su vecindad inmediata en lugar de en el conjunto completo: un documento que pertenece a un grupo minoritario sigue siendo normal mientras tenga vecinos.

def detect_anomalies_knn(
    texts: list[str],
    k: int = 3,
    percentile_threshold: float = 90,
    model: str = "text-embedding-3-large"
) -> list[dict]:
    """Detecta anomalías por distancia a los k vecinos más cercanos."""
    response = client.embeddings.create(
        input=texts, model=model
    )
    embeddings = np.array(
        [d.embedding for d in sorted(response.data, key=lambda x: x.index)]
    )

    # Matriz de similitud
    sim_matrix = embeddings @ embeddings.T

    # Para cada texto, media de los k vecinos más cercanos
    isolation_scores = []
    for i in range(len(texts)):
        sims = sim_matrix[i].copy()
        sims[i] = -1  # Excluir uno mismo
        top_k_sims = np.sort(sims)[-k:]
        isolation_scores.append(top_k_sims.mean())

    threshold = np.percentile(isolation_scores, 100 - percentile_threshold)

    anomalies = []
    for i, score in enumerate(isolation_scores):
        if score < threshold:
            anomalies.append({
                "index": i,
                "text": texts[i],
                "isolation_score": float(score)
            })

    return anomalies

Detección de duplicados semánticos

En el otro extremo de la escala se encuentran los textos que están demasiado cerca. Dos entradas pueden ser duplicados incluso con palabras diferentes: «¿Cómo restablezco mi contraseña?» y «He olvidado la contraseña, ¿qué hago?» solo comparten tres palabras comunes, y eso es exactamente lo que el hashing o la comparación de cadenas nunca detectarán. Los embeddings sí lo hacen.

La función calcula la matriz de similitud completa y devuelve todos los pares por encima del umbral. Vigila el coste: esta comparación es cuadrática, lo cual sigue siendo instantáneo para unos pocos miles de textos, pero se vuelve impracticable para un millón; en ese caso debes usar un índice aproximado como los que se cubren con las bases de datos vectoriales.

def find_duplicates(
    texts: list[str],
    threshold: float = 0.90,
    model: str = "text-embedding-3-large"
) -> list[dict]:
    """Encuentra pares de textos semánticamente idénticos."""
    response = client.embeddings.create(
        input=texts, model=model
    )
    embeddings = np.array(
        [d.embedding for d in sorted(response.data, key=lambda x: x.index)]
    )

    # Matriz de similitud
    sim_matrix = embeddings @ embeddings.T

    duplicates = []
    for i in range(len(texts)):
        for j in range(i + 1, len(texts)):
            if sim_matrix[i][j] >= threshold:
                duplicates.append({
                    "text_a": texts[i],
                    "text_b": texts[j],
                    "index_a": i,
                    "index_b": j,
                    "similarity": float(sim_matrix[i][j])
                })

    return sorted(duplicates, key=lambda x: x["similarity"], reverse=True)

# Ejemplo
texts = [
    "¿Cómo restablezco mi contraseña?",
    "No puedo iniciar sesión en mi cuenta",
    "He olvidado la contraseña, ¿qué hago?",           # Duplicado de [0]
    "¿Cuál es la política de reembolsos?",
    "No puedo acceder a mi espacio personal",       # Duplicado de [1]
    "¿Cómo solicito un reembolso?",                   # Duplicado de [3]
]

dupes = find_duplicates(texts, threshold=0.85)
print(f"{len(dupes)} pares duplicados encontrados:")
for d in dupes:
    print(f"  [{d['similarity']:.3f}]")
    print(f"    A: {d['text_a']}")
    print(f"    B: {d['text_b']}")

La llamada aquí usa un umbral de 0,85 en lugar del valor predeterminado de 0,90 porque las reformulaciones de la misma pregunta de soporte suelen caer muy por debajo de 0,90. Este es el ajuste en el que pasarás más tiempo: si lo pones demasiado alto, dejarás pasar duplicados; si lo pones demasiado bajo, fusionarás «¿cómo cambio mi contraseña?» con «¿cómo cambio mi dirección de correo electrónico?», dos preguntas distintas que parecen muy similares.

Canalización de deduplicación

Detectar pares no basta para limpiar un corpus. Si A se parece a B y B se parece a C, los tres pertenecen al mismo grupo, incluso si A y C nunca se compararon directamente por encima del umbral. La agrupación transitiva es el trabajo real, y la estructura Union-Find (unión-búsqueda) la gestiona en una sola pasada: cada par detectado fusiona dos conjuntos, obteniendo al final grupos de duplicados totalmente formados.

Aún necesitas elegir qué miembro sobrevive. La regla usada aquí —el texto más corto— funciona bien para preguntas de soporte, donde la formulación más concisa suele ser la más canónica. Para un corpus de documentos, probablemente querrás lo contrario, o el más reciente: esto es una decisión de negocio, no un detalle técnico. El diccionario devuelto mantiene la lista de textos eliminados para que un humano pueda verificar los casos límite antes de aprobarlos.

class Deduplicator:
    def __init__(self, threshold: float = 0.90):
        self.client = OpenAI()
        self.threshold = threshold

    def deduplicate(self, texts: list[str]) -> dict:
        """Elimina duplicados semánticos."""
        response = self.client.embeddings.create(
            input=texts, model="text-embedding-3-large"
        )
        embeddings = np.array(
            [d.embedding for d in sorted(response.data, key=lambda x: x.index)]
        )

        # Union-Find para agrupar duplicados
        parent = list(range(len(texts)))

        def find(x):
            while parent[x] != x:
                parent[x] = parent[parent[x]]
                x = parent[x]
            return x

        def union(a, b):
            pa, pb = find(a), find(b)
            if pa != pb:
                parent[pb] = pa

        # Encontrar pares similares
        sim_matrix = embeddings @ embeddings.T
        for i in range(len(texts)):
            for j in range(i + 1, len(texts)):
                if sim_matrix[i][j] >= self.threshold:
                    union(i, j)

        # Mantener un representante por grupo
        groups = {}
        for i in range(len(texts)):
            root = find(i)
            if root not in groups:
                groups[root] = []
            groups[root].append(i)

        # Seleccionar textos únicos (el más corto de cada grupo)
        uniques = []
        deleted = []
        for root, members in groups.items():
            representative = min(members, key=lambda i: len(texts[i]))
            uniques.append(texts[representative])
            for m in members:
                if m != representative:
                    deleted.append(texts[m])

        return {
            "uniques": uniques,
            "deleted": deleted,
            "n_original": len(texts),
            "n_deduplicated": len(uniques),
            "n_deleted": len(deleted)
        }

# Uso
dedup = Deduplicator(threshold=0.85)
result = dedup.deduplicate(texts)
print(f"Antes: {result['n_original']} textos")
print(f"Después: {result['n_deduplicated']} textos")
print(f"Eliminados: {result['n_deleted']}")

Aplicada aguas arriba de un índice RAG, esta deduplicación tiene un efecto directo en la calidad: evita que los cinco resultados devueltos para una pregunta sean cinco versiones del mismo pasaje, lo cual privaría al generador de cualquier información adicional.

Resumen

  • La distancia al centroide o k-NN detecta textos anómalos
  • La similitud del coseno por encima de un umbral identifica duplicados
  • Union-Find agrupa eficientemente los duplicados transitivos
  • Calibra los umbrales con tus datos (típicamente 0,85–0,95 para duplicados)