Ga naar hoofdinhoud
Nederlands— Kies een taal
Menu

Detectie van anomalieën en duplicaten

Les 20 van 22 Bijgewerkt op 29 juli 2026 Ontwikkelaar
Op deze pagina
  1. Doelstellingen
  2. Detectie van anomalieën
  3. Semantische duplicaatdetectie
  4. Deduplicatie-pipeline
  5. Belangrijkste punten

Doelstellingen

  • Abnormale teksten binnen een corpus detecteren
  • Semantische duplicaten identificeren
  • Een deduplicatie-pipeline bouwen

Detectie van anomalieën

De twee toepassingen in deze les delen dezelfde intuïtie, toegepast op de tegenovergestelde uiteinden van de gelijkenisschaal. Een tekst is “abnormaal” als deze semantisch ver verwijderd is van al het andere in het corpus; een tekst is een duplicaat als deze te dichtbij komt. Met embeddings kunt u deze afstand in beide gevallen meten. Het meeste werk bestaat uit het kalibreren van de drempelwaarden.

De eerste aanpak bouwt het zwaartepunt van het corpus—het gemiddelde van alle vectoren, wat “het gebruikelijke onderwerp van dit corpus” vertegenwoordigt—en meet vervolgens hoe ver elke tekst daarvan afwijkt. De drempelwaarde is bewust geen absolute waarde, maar een percentiel: u kunt van tevoren niet weten hoe ver een anomalie verwijderd ligt, maar u weet wel dat u de meest atypische 5% wilt onderzoeken.

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]:
    """Detects abnormal texts by distance to the centroid."""
    response = client.embeddings.create(
        input=texts, model=model
    )
    embeddings = np.array(
        [d.embedding for d in sorted(response.data, key=lambda x: x.index)]
    )

    # Corpus centroid
    centroid = embeddings.mean(axis=0)
    centroid /= np.linalg.norm(centroid)

    # Distance of each text to the centroid
    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

# Example
corpus = [
    "Our leave policy provides 25 days per year",
    "Leave must be requested 2 weeks in advance",
    "Leave balances are visible on the HR portal",
    "Exceptional leave is granted with supporting documentation",
    "SELECT * FROM users WHERE admin=1; DROP TABLE users;--",  # Anomaly!
    "The remote work policy allows 3 days per week",
]

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

Het voorbeeldcorpus vertelt het verhaal: vijf zinnen over HR-beleid en één SQL-injectiepoging. Geen enkel trefwoordfilter zou de injectie hebben opgemerkt zonder een vooraf geschreven regel; de afstand tot het zwaartepunt signaleert deze zonder enige voorafgaande anticipatie. Dit is het hoofdargument voor het gebruik van de methode om een stroom binnenkomende documenten te monitoren.

Het zwaartepunt heeft wel een zwakte: het gaat ervan uit dat het corpus rond één thema draait. Als uw documenten drie zeer verschillende domeinen bestrijken, valt het gemiddelde punt in een semantisch vacuüm en lijken alle teksten even ver verwijderd. De k-nearest neighbors-benadering omzeilt dit door elke tekst te beoordelen op basis van zijn directe omgeving in plaats van de hele set: een document dat tot een minderheidsgroep behoort, blijft normaal zolang het buren heeft.

def detect_anomalies_knn(
    texts: list[str],
    k: int = 3,
    percentile_threshold: float = 90,
    model: str = "text-embedding-3-large"
) -> list[dict]:
    """Detects anomalies by distance to the k nearest neighbors."""
    response = client.embeddings.create(
        input=texts, model=model
    )
    embeddings = np.array(
        [d.embedding for d in sorted(response.data, key=lambda x: x.index)]
    )

    # Similarity matrix
    sim_matrix = embeddings @ embeddings.T

    # For each text, average of the k nearest neighbors
    isolation_scores = []
    for i in range(len(texts)):
        sims = sim_matrix[i].copy()
        sims[i] = -1  # Exclude self
        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

Semantische duplicaatdetectie

Aan het andere uiteinde van de schaal bevinden zich teksten die te dicht bij elkaar liggen. Twee invoeren kunnen duplicaten zijn, zelfs met verschillende woorden—“How do I reset my password?” en “Forgot password, what do I do?” delen slechts drie gemeenschappelijke woorden—en dat is precies wat hashing of stringvergelijking nooit zullen opmerken. Embeddings detecteren ze wel.

De functie berekent de volledige gelijkenismatrix en retourneert alle paren boven de drempelwaarde. Let op de kosten: deze vergelijking is kwadratisch, wat voor een paar duizend teksten nog steeds direct verloopt, maar voor een miljoen onpraktisch wordt—u moet dan een benaderende index gebruiken, zoals die behandeld bij vector databases.

def find_duplicates(
    texts: list[str],
    threshold: float = 0.90,
    model: str = "text-embedding-3-large"
) -> list[dict]:
    """Finds pairs of semantically identical texts."""
    response = client.embeddings.create(
        input=texts, model=model
    )
    embeddings = np.array(
        [d.embedding for d in sorted(response.data, key=lambda x: x.index)]
    )

    # Similarity matrix
    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)

# Example
texts = [
    "How do I reset my password?",
    "I cannot log in to my account",
    "Forgot password, what do I do?",           # Duplicate of [0]
    "What is the refund policy?",
    "Unable to access my personal space",       # Duplicate of [1]
    "How do I get a refund?",                   # Duplicate of [3]
]

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

De aanroep hier gebruikt een drempelwaarde van 0,85 in plaats van de standaard 0,90, omdat herformuleringen van dezelfde supportvraag vaak ruim onder de 0,90 liggen. Dit is de instelling waar u het meeste tijd aan zult besteden: stelt u deze te hoog in, dan laat u duplicaten door de mazen van het net glippen; stelt u deze te laag in, dan voegt u “hoe verander ik mijn wachtwoord” samen met “hoe verander ik mijn e-mailadres”, twee verschillende vragen die er zeer vergelijkbaar uitzien.

Deduplicatie-pipeline

Het detecteren van paren is niet genoeg om een corpus op te schonen. Als A op B lijkt en B op C, behoren alle drie tot dezelfde groep, zelfs als A en C nooit direct met elkaar zijn vergeleken boven de drempelwaarde. Transitieve groepering is het echte werk, en de Union-Find-structuur handelt dit af in één enkele doorgang: elk gedetecteerd paar voegt twee sets samen, wat aan het einde volledig gevormde duplicaatgroepen oplevert.

U moet nog steeds kiezen welk lid overleeft. De hier gebruikte regel—de kortste tekst—werkt goed voor supportvragen, waarbij de meest beknopte formulering vaak de meest canonieke is. Voor een documentcorpus wilt u waarschijnlijk het tegenovergestelde, of het meest recente: dit is een zakelijke beslissing, geen technisch detail. Het geretourneerde dictionary houdt de lijst van verwijderde teksten bij, zodat een mens de randgevallen kan verifiëren voordat ze worden goedgekeurd.

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

    def deduplicate(self, texts: list[str]) -> dict:
        """Removes semantic duplicates."""
        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 to group duplicates
        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

        # Find similar pairs
        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)

        # Keep one representative per group
        groups = {}
        for i in range(len(texts)):
            root = find(i)
            if root not in groups:
                groups[root] = []
            groups[root].append(i)

        # Select unique texts (shortest in each group)
        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)
        }

# Usage
dedup = Deduplicator(threshold=0.85)
result = dedup.deduplicate(texts)
print(f"Before: {result['n_original']} texts")
print(f"After: {result['n_deduplicated']} texts")
print(f"Deleted: {result['n_deleted']}")

Toegepast stroomopwaarts van een RAG-index, heeft deze deduplicatie een direct effect op de kwaliteit: het voorkomt dat de vijf resultaten die voor een vraag worden teruggegeven, vijf versies van dezelfde passage zijn, wat de generator zou beroven van enige aanvullende informatie.

Belangrijkste punten

  • Afstand tot het zwaartepunt of k-NN detecteert abnormale teksten
  • Cosinusgelijkenis boven een drempelwaarde identificeert duplicaten
  • Union-Find groepeert transitieve duplicaten efficiënt
  • Kalibreer drempelwaarden op uw gegevens (doorgaans 0,85–0,95 voor duplicaten)