Pāriet uz galveno saturu
Latviešu— Izvēlēties valodu
Izvēlne

Anomāliju un dublikātu noteikšana

Nodarbība 20 no 22 Atjaunota 2026. gada 29. jūlijs Programmētājs
Šajā lapā
  1. Mērķi
  2. Anomāliju noteikšana
  3. Semantisko dublikātu noteikšana
  4. Deduplikācijas process
  5. Galvenās atziņas

Mērķi

  • Atklāt neparastus tekstus korpusā
  • Identificēt semantiskos dublikātus
  • Izveidot deduplikācijas procesu

Anomāliju noteikšana

Abiem šīs nodarbības lietojumiem ir kopīga intuīcija, kas pielietota pretējos līdzības skalas galos. Teksts ir „neparasts”, ja tas semantiski atšķiras no visa pārējā korpusā; teksts ir dublikāts, ja tas ir pārāk līdzīgs. Iegulšanas (embeddings) ļauj izmērīt šo attālumu abos gadījumos. Lielākā daļa darba saistīta ar sliekšņu kalibrēšanu.

Pirmā pieeja veido korpusa centroidu — visu vektoru vidējo vērtību, kas pārstāv „šo korpusu parasto tēmu” — un pēc tam mēra, cik tālu katrs teksts no tā atšķiras. Slieksnis apzināti nav absolūta vērtība, bet gan percentils: tu nevari iepriekš zināt, cik tālu atrodas anomālija, bet tu zini, ka vēlies pārbaudīt netipiskākos 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]}...")

Piemēra korpuss stāsta visu: pieci HR politikas teikumi un viens SQL injicēšanas mēģinājums. Neviens atslēgvārdu filtrs nebūtu atklājis injicēšanu bez iepriekš uzrakstīta noteikuma; attālums līdz centroidam to atzīmē bez jebkādas iepriekšējas paredzēšanas. Tas ir galvenais arguments šīs metodes izmantošanai, lai uzraudzītu ienākošo dokumentu plūsmu.

Centroidam tomēr ir vājā vieta: tas pieņem, ka korpuss riņķo ap vienu tēmu. Ja tavi dokumenti aptver trīs ļoti dažādas jomas, vidējais punkts nonāk semantiskā tukšumā, un visi teksti šķiet vienlīdz tāli. K-tuvāko kaimiņu (k-nearest neighbors) pieeja to apej, vērtējot katru tekstu, balstoties uz tā tiešo apkārtni, nevis visu kopu: dokuments, kas pieder minoritātes grupai, paliek normāls, kamēr tam ir kaimiņi.

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

Semantisko dublikātu noteikšana

Skalas otrā galā atrodas teksti, kas ir pārāk līdzīgi. Divi ieraksti var būt dublikāti pat ar dažādiem vārdiem — „Kā es varu atiestatīt savu paroli?” un „Aizmirsu paroli, ko darīt?” koplieto tikai trīs kopīgus vārdus — un tieši to nekad neatklās hašošana vai virkņu salīdzināšana. Iegulšanas tos atklāj.

Funkcija aprēķina pilnu līdzības matricu un atgriež visus pārus virs sliekšņa. Uzmanies ar izmaksām: šī salīdzināšana ir kvadrātiska, kas paliek acumirklīga dažiem tūkstošiem tekstu, bet kļūst nepraktiska miljonam — tad tev jāizmanto aptuvenais indekss, piemēram, tie, kas apskatīti saistībā ar vektoru datubāzēm.

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

Šeit izsaukums izmanto slieksni 0,85, nevis noklusējuma 0,90, jo viena un tā paša atbalsta jautājuma pārfrazējumi bieži vien ir ievērojami zem 0,90. Šis ir iestatījums, kura pielāgošanai tu veltīsi visvairāk laika: ja to iestatīsi pārāk augstu, lai cauri izslīdēs dublikāti; ja pārāk zemu, apvienosi „kā mainīt paroli” ar „kā mainīt e-pasta adresi” — divus atšķirīgus jautājumus, kas izskatās ļoti līdzīgi.

Deduplikācijas process

Pāru noteikšana nepietiek, lai attīrītu korpusu. Ja A līdzinās B un B līdzinās C, visi trīs pieder vienai grupai, pat ja A un C nekad nav tieši salīdzināti virs sliekšņa. Transitīvā grupēšana ir īstais darbs, un struktūra Union-Find to paveic vienā piegājienā: katrs atklātais pāris apvieno divas kopas, beigās iegūstot pilnībā izveidotas dublikātu grupas.

Tev joprojām jāizvēlas, kurš dalībnieks paliek. Šeit izmantotais noteikums — īsākais teksts — labi strādā atbalsta jautājumiem, kur kodolīgākā formulējums bieži vien ir viskanoniskākais. Dokumentu korpusam tu, visticamāk, vēlēsies pretējo vai visjaunāko: tas ir biznesa lēmums, nevis tehniska detaļa. Atgrieztā vārdnīca saglabā dzēsto tekstu sarakstu, lai cilvēks varētu pārbaudīt robežgadījumus pirms apstiprināšanas.

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

Pielietota pirms RAG indeksa, šī deduplikācija tieši ietekmē kvalitāti: tā novērš situāciju, kurā pieci jautājumam atgrieztie rezultāti ir piecas viena un tā paša fragmenta versijas, kas generatoram atņemtu jebkādu papildu informāciju.

Galvenās atziņas

  • Attālums līdz centroidam vai k-NN atklāj neparastus tekstus
  • Kosinus līdzība virs sliekšņa identificē dublikātus
  • Union-Find efektīvi grupē transitīvos dublikātus
  • Kalibrē sliekšņus uz saviem datiem (parasti 0,85–0,95 dublikātiem)