Pereiti prie pagrindinio turinio
Lietuvių— Pasirinkite kalbą
Meniu

Anomalijų ir dublikatų aptikimas

Paskaita 20 iš 22 Atnaujinta 2026 m. liepos 29 d. Kūrėjas
Šiame puslapyje
  1. Tikslai
  2. Anomalijų aptikimas
  3. Semantinis dublikatų aptikimas
  4. Dedublikavimo procesas
  5. Svarbiausi punktai

Tikslai

  • Aptikti nenormalius tekstus teksto rinkinyje
  • Identifikuoti semantinius dublikatus
  • Sukurti dedublikavimo procesą

Anomalijų aptikimas

Šios pamokos dvi taikymo sritys remiasi ta pačia intuicija, taikoma priešingiems panašumo skalės galams. Tekstas yra „nenormalus“, jei jis semantiškai nutolęs nuo visų kitų rinkinio elementų; tekstas yra dublikatas, jei jis per artimas. Įterptiniai vektoriai (embeddings) leidžia išmatuoti šį atstumą abiem atvejais. Didžioji darbo dalis – tai slenksčių kalibravimas.

Pirmasis požiūris sukuria rinkinio centroidą – visų vektorių vidurkį, kuris reprezentuoja „įprastą šio rinkinio temą“, tada matuoja, kiek kiekvienas tekstas nuo jo nukrypsta. Slenkstis sąmoningai nėra absoliuti vertė, o percentilis: iš anksto negali žinoti, kaip toli yra anomalija, bet žinai, kad nori peržiūrėti netipiškiausius 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]}...")

Pavyzdinis rinkinys kalba pats už save: penki HR politikos sakiniai ir vienas SQL injekcijos bandymas. Joks raktinių žodžių filtras nebūtų pagavęs injekcijos be iš anksto parašytos taisyklės; atstumas iki centroide ją pažymi be jokio išankstinio numatymo. Tai pagrindinis argumentas naudoti šį metodą stebint gaunamų dokumentų srautą.

Centroidas turi vieną silpnybę: jis daro prielaidą, kad rinkinys sukasi apie vieną temą. Jei tavo dokumentai apima tris labai skirtingas sritis, vidurkio taškas atsiduria semantinėje tuštumoje, ir visi tekstai atrodo vienodai nutolę. K-artimiausių kaimynų (k-NN) požiūris tai apeina, vertindamas kiekvieną tekstą pagal jo tiesioginę kaimynystę, o ne visą aibę: dokumentas, priklausantis mažumai, lieka normalus, tol, kol turi kaimynų.

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

Semantinis dublikatų aptikimas

Kitame skalės gale yra tekstai, kurie yra per arti. Du įrašai gali būti dublikatai net ir naudojant skirtingus žodžius – „Kaip atkurti slaptažodį?“ ir „Pamiršau slaptažodį, ką daryti?“ turi tik tris bendrus žodžius – ir būtent to niekada nepagaus nei maišos funkcijos (hashing), nei eilučių palyginimas. Įterptiniai vektoriai juos aptinka.

Funkcija apskaičiuoja visą panašumo matricą ir grąžina visas poras, viršijančias slenkstį. Stebėk kainą: šis palyginimas yra kvadratinis, kas lieka akimirksniu atliekama keliems tūkstančiams tekstų, bet tampa nepraktiška milijonui – tuomet turi naudoti apytikslį indeksą, pavyzdžiui, tuos, kurie aptariami vektorių duomenų bazių skyriuje.

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

Čia kvietimas naudoja 0,85 slenkstį vietoj numatytojo 0,90, nes to paties pagalbos klausimo performuluojimai dažnai būna gerokai žemiau 0,90. Tai nustatymas, kuriam derinti sugaiši daugiausia laiko: nustatyk per aukštai – ir praleisi dublikatus; nustatyk per žemai – ir sujungsi „kaip pakeisti slaptažodį“ su „kaip pakeisti el. pašto adresą“, du skirtingus klausimus, kurie atrodo labai panašūs.

Dedublikavimo procesas

Porų aptikimo nepakanka rinkiniui išvalyti. Jei A panašus į B, o B panašus į C, visi trys priklauso tai pačiai grupei, net jei A ir C niekada nebuvo tiesiogiai palyginti viršijant slenkstį. Tikrasis darbas – tai tranzityvus grupavimas, kurį vienu praėjimu atlieka „Union-Find“ (susijungimo ir radimo) struktūra: kiekviena aptikta pora sujungia dvi aibes, galiausiai sudarydama pilnai suformuotas dublikatų grupes.

Vis tiek reikia pasirinkti, kuris narys išliks. Čia naudojama taisyklė – trumpiausias tekstas – gerai veikia pagalbos klausimams, kur glaustiausia formuliuotė dažnai yra kanoniškiausia. Dokumentų rinkiniui greičiausiai norėsi priešingai, arba naujausio: tai verslo sprendimas, o ne techninė detalė. Grąžinamas žodynas palieka ištrintų tekstų sąrašą, kad žmogus galėtų patikrinti ribinius atvejus prieš patvirtindamas.

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

Pritaikius tai prieš RAG indeksą, šis dedublikavimas daro tiesioginę įtaką kokybei: jis neleidžia, kad penki klausimui grąžinti rezultatai būtų penkios to paties ištraukos versijos, kas atimtų iš generatoriaus bet kokią papildomą informaciją.

Svarbiausi punktai

  • Atstumas iki centroide arba k-NN aptinka nenormalius tekstus
  • Kosinusinis panašumas virš slenksčio identifikuoja dublikatus
  • „Union-Find“ efektyviai sugrupuoja tranzityvius dublikatus
  • Kalibruok slenksčius pagal savo duomenis (paprastai 0,85–0,95 dublikatams)