Preskok na glavno vsebino
Slovenščina— Izberite jezik
Meni

Zaznavanje anomalij in duplikatov

Lekcija 20 od 22 Posodobljeno 29. julij 2026 Razvijalec
Na tej strani
  1. Cilji
  2. Zaznavanje anomalij
  3. Semantično zaznavanje duplikatov
  4. Cevovod za odstranjevanje duplikatov
  5. Ključne ugotovitve

Cilji

  • Zaznaj nenormalna besedila znotraj korpusa
  • Identificiraj semantične duplikate
  • Izgradi cevovod za odstranjevanje duplikatov

Zaznavanje anomalij

Dve uporabi v tej lekciji delita isto intuicijo, aplicirano na nasprotnih koncih lestvice podobnosti. Besedilo je „nenormalno”, če je semantično oddaljeno od vsega drugega v korpusu; besedilo je duplikat, če je preblizu. Vgradnje (embeddings) ti omogočajo merjenje te razdalje v obeh primerih. Večina dela zajema umerjanje pragov.

Prvi pristop gradi težišče korpusa – povprečje vseh vektorjev, kar predstavlja „običajno temo tega korpusa” – nato pa meri, kako daleč odstopa vsako besedilo od njega. Prag namerno ni absolutna vrednost, temveč percentil: vnaprej ne moreš vedeti, kako daleč stran leži anomalija, veš pa, da želiš pregledati najbolj atipičnih 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]}...")

Primer korpusa pripoveduje zgodbo: pet stavkov o kadrovski politiki in en poskus injiciranja SQL. Noben filter ključnih besed ne bi zaznal injiciranja brez vnaprej napisanega pravila; razdalja do težišča ga označi brez kakršnega koli predhodnega pričakovanja. To je glavni argument za uporabo metode pri nadzoru toka dohodnih dokumentov.

Težišče ima slabost: predpostavlja, da se korpus vrti okoli ene same teme. Če tvoji dokumenti pokrivajo tri zelo različna področja, povprečna točka pade v semantično praznino in vsa besedila se zdijo enako oddaljena. Pristop k-najbližjih sosedov (k-NN) to obide tako, da vsako besedilo ocenjuje glede na njegovo neposredno okolico namesto glede na celoten nabor: dokument, ki pripada manjšinski skupini, ostane normalen, dokler ima sosede.

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

Semantično zaznavanje duplikatov

Na drugem koncu lestvice so besedila, ki so preblizu. Dva vnosa sta lahko duplikata tudi z različnimi besedami – „Kako ponastavim geslo?” in „Pozabljeno geslo, kaj naj storim?” imata skupne le tri besede – in to je ravno tisto, česar zgoščevanje (hashing) ali primerjava nizov nikoli ne bosta zaznala. Vgradnje jih zaznajo.

Funkcija izračuna celotno matriko podobnosti in vrne vse pare nad pragom. Pozoren bodi na stroške: ta primerjava je kvadratna, kar ostane trenutno za nekaj tisoč besedil, a postane nepraktično za milijon – takrat moraš uporabiti približni indeks, kot so tisti, obravnavani pri vektorskih bazah podatkov.

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

Klic tukaj uporablja prag 0,85 namesto privzetega 0,90, ker preoblikovanja istega vprašanja za podporo pogosto padejo precej pod 0,90. To je nastavitev, ki ji boš namenil največ časa za umerjanje: če jo nastaviš previsoko, bodo duplikati ušli; če jo nastaviš prenizko, boš združil „kako spremenim geslo” s „kako spremenim e-poštni naslov”, dve različni vprašanji, ki si zelo podobni.

Cevovod za odstranjevanje duplikatov

Zaznavanje parov ni dovolj za čiščenje korpusa. Če A spominja na B in B na C, vsi trije spadajo v isto skupino, tudi če A in C nista bila nikoli neposredno primerjana nad pragom. Transitivno grupiranje je pravo delo in struktura Union-Find (združi-in-poišči) to opravi v enem prehodu: vsak zaznan par združi dva niza, kar na koncu da popolnoma oblikovane skupine duplikatov.

Še vedno se moraš odločiti, kateri član preživi. Pravilo, uporabljeno tukaj – najkrajše besedilo – dobro deluje za vprašanja podpore, kjer je najbolj jedrnata formulacija pogosto najbolj kanonična. Za korpus dokumentov boš verjetno želel nasprotno ali najnovejše: to je poslovna odločitev, ne tehnična podrobnost. Vrnjeni slovar hrani seznam izbrisanih besedil, tako da jih človek lahko preveri v mejnih primerih pred odobritvijo.

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

Če se to odstranjevanje duplikatov uporabi pred indeksiranjem RAG, ima neposreden učinek na kakovost: prepreči, da bi bilo pet rezultatov, vrnjenih za vprašanje, pet različic istega odlomka, kar bi generatorju odvzelo kakršne koli dodatne informacije.

Ključne ugotovitve

  • Razdalja do težišča ali k-NN zazna nenormalna besedila
  • Kosinusna podobnost nad pragom identificira duplikate
  • Union-Find učinkovito grupira transitivne duplikate
  • Pragi umerjaj na svojih podatkih (običajno 0,85–0,95 za duplikate)