Spring til hovedindhold
Dansk— Vælg et sprog
Menu

Detektion af anomalier og dubletter

Lektion 20 af 22 Opdateret 29. juli 2026 Udvikler
På denne side
  1. Mål
  2. Detektion af anomalier
  3. Semantisk detektion af dubletter
  4. Pipeline til fjernelse af dubletter
  5. Vigtige pointer

Mål

  • Registrer unormale tekster i et korpus
  • Identificer semantiske dubletter
  • Byg en pipeline til fjernelse af dubletter

Detektion af anomalier

De to anvendelser i denne lektion deler samme intuition, men anvendt på hver sin ende af lighedsskalaen. En tekst er „unormal”, hvis den er semantisk fjern fra alt andet i korpussen; en tekst er en dublet, hvis den er for tæt på. Embeddings giver dig mulighed for at måle denne afstand i begge tilfælde. Det meste af arbejdet består i at kalibrere tærskelværdierne.

Den første tilgang beregner korpussens centroid – gennemsnittet af alle vektorer, hvilket repræsenterer „det sædvanlige emne i dette korpus” – og måler derefter, hvor meget hver tekst afviger fra den. Tærsklen er bevidst ikke en absolut værdi, men en percentil: Du kan ikke på forhånd vide, hvor langt væk en anomali ligger, men du ved, at du ønsker at undersøge de mest atypiske 5 %.

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]}...")

Eksempelkorpussen fortæller historien: fem sætninger om HR-politik og ét SQL-injektionsforsøg. Intet nøgleordsfilter ville have fanget injektionen uden en forudskrevet regel; afstanden til centroiden flagger den uden nogen form for forhåndsviden. Dette er hovedargumentet for at bruge metoden til at overvåge en strøm af indkommende dokumenter.

Centroiden har dog en svaghed: Den antager, at korpussen kredser om ét enkelt tema. Hvis dine dokumenter dækker tre meget forskellige domæner, havner gennemsnitspunktet i et semantisk tomrum, og alle tekster fremstår lige langt væk. Tilgangen med k-nærmeste naboer (k-NN) omgår dette ved at bedømme hver tekst ud fra dens umiddelbare nabolag frem for hele sættet: Et dokument, der tilhører en minoritetsgruppe, forbliver normalt, så længe det har naboer.

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

Semantisk detektion af dubletter

I den anden ende af skalaen finder vi tekster, der er for tæt på hinanden. To poster kan være dubletter, selv med forskellige ord – „Hvordan nulstiller jeg min adgangskode?” og „Har glemt adgangskode, hvad gør jeg?” deler kun tre fælles ord – og det er præcis det, hashing eller strengsammenligning aldrig vil fange. Embeddings registrerer dem.

Funktionen beregner den fulde lighedsmatrix og returnerer alle par over tærsklen. Pas på omkostningerne: Denne sammenligning er kvadratisk, hvilket er øjeblikkeligt for nogle få tusinde tekster, men bliver upraktisk for en million – her skal du bruge et approksimativt indeks som dem, der behandles sammen med vektordatabaser.

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']}")

Kaldet her bruger en tærskel på 0,85 i stedet for standarden 0,90, fordi omformuleringer af det samme supportspørgsmål ofte falder langt under 0,90. Dette er den indstilling, du vil bruge mest tid på at finjustere: Sætter du den for højt, slipper dubletter igennem; sætter du den for lavt, slår du „hvordan ændrer jeg min adgangskode” sammen med „hvordan ændrer jeg min e-mail-adresse”, to forskellige spørgsmål, der ser meget ens ud.

Pipeline til fjernelse af dubletter

Det er ikke nok at registrere par for at rense et korpus. Hvis A ligner B, og B ligner C, hører alle tre til samme gruppe, selv hvis A og C aldrig blev sammenlignet direkte over tærsklen. Transitiv gruppering er det egentlige arbejde, og Union-Find-strukturen håndterer dette i et enkelt gennemløb: Hvert registreret par slår to sæt sammen, hvilket resulterer i fuldt dannede dubletgrupper til sidst.

Du skal stadig vælge, hvilket medlem der overlever. Reglen, der bruges her – den korteste tekst – virker godt til supportspørgsmål, hvor den mest koncise formulering ofte er den mest kanoniske. Til et dokumentkorpus vil du sandsynligvis ønske det modsatte, eller den nyeste: Dette er en forretningsmæssig beslutning, ikke en teknisk detalje. Den returnerede ordbog beholder listen over slettede tekster, så et menneske kan verificere kanttilfælde, før de godkendes.

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']}")

Anvendt upstream for et RAG-indeks har denne fjernelse af dubletter en direkte effekt på kvaliteten: Den forhindrer, at de fem resultater, der returneres for et spørgsmål, er fem versioner af det samme afsnit, hvilket ville fratage generatoren enhver yderligere information.

Vigtige pointer

  • Afstand til centroiden eller k-NN registrerer unormale tekster
  • Cosinus-lished over en tærskel identificerer dubletter
  • Union-Find grupperer transitive dubletter effektivt
  • Kalibrer tærskler på dine data (typisk 0,85–0,95 for dubletter)