Премини към основното съдържание
Български— Изберете език
Меню

Откриване на аномалии и дубликати

Урок 20 от 22 Обновен 29 юли 2026 г. Програмист
На тази страница
  1. Цели
  2. Откриване на аномалии
  3. Откриване на семантични дубликати
  4. Конвейер за дедупликация
  5. Ключови изводи

Цели

  • Откриване на необичайни текстове в корпус
  • Идентифициране на семантични дубликати
  • Изграждане на конвейер за дедупликация

Откриване на аномалии

Двете приложения в този урок споделят една и съща интуиция, приложена към противоположните краища на скалата за сходство. Един текст е „необичаен“, ако е семантично отдалечен от всичко останало в корпуса; текстът е дубликат, ако е твърде близък. Вгражданията (embeddings) Ви позволяват да измерите това разстояние и в двата случая. По-голямата част от работата се състои в калибрирането на праговете.

Първият подход изгражда центроида на корпуса – средната стойност на всички вектори, която представлява „обичайната тема на този корпус“ – и след това измерва колко далеч се отклонява всеки текст от него. Прагът умишлено не е абсолютна стойност, а перцентил: не можете да знаете предварително колко далеч се намира една аномалия, но знаете, че искате да разгледате най-нетипичните 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]}...")

Примерният корпус разказва историята: пет изречения относно политиката за отпуски и един опит за SQL инжекция. Никакъв филтър по ключови думи не би хванал инжекцията без предварително написано правило; разстоянието до центроида я открива без никакво предварително очакване. Това е основният аргумент за използването на метода за мониторинг на поток от входящи документи.

Центроидът обаче има слабост: той приема, че корпусът се върти около една единствена тема. Ако документите Ви обхващат три много различни области, средната точка попада в семантична пустота и всички текстове изглеждат еднакво отдалечени. Подходът с k-най-близки съседи (k-nearest neighbors) заобикаля това, като оценява всеки текст въз основа на непосредственото му обкръжение, а не на целия набор: документ, принадлежащ към малцинствена група, остава нормален, стига да има съседи.

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

Откриване на семантични дубликати

В другия край на скалата са текстовете, които са твърде близки. Два записа могат да бъдат дубликати дори с различни думи – „Как да нулирам паролата си?“ и „Забравих паролата, какво да правя?“ споделят само три общи думи – и точно това е нещо, което хеширането или сравняването на низове никога няма да улови. Вгражданията ги откриват.

Функцията изчислява пълната матрица на сходство и връща всички двойки над прага. Внимавайте за разходите: това сравнение е квадратично, което остава мигновено за няколко хиляди текста, но става непрактично за един милион – тогава трябва да използвате приблизителен индекс като тези, разгледани при векторните бази данни.

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

Извикването тук използва праг от 0.85, а не стандартния 0.90, защото преформулировките на един и същи въпрос за поддръжка често падат значително под 0.90. Това е настройката, върху която ще отделите най-много време за прецизиране: ако го зададете твърде високо, ще пропуснете дубликати; ако го зададете твърде ниско, ще обедините „как да променя паролата си“ с „как да променя имейл адреса си“ – два различни въпроса, които изглеждат много сходни.

Конвейер за дедупликация

Откриването на двойки не е достатъчно, за да почистите един корпус. Ако А прилича на Б и Б прилича на В, и трите принадлежат към една и съща група, дори ако А и В никога не са били директно сравнявани над прага. Транзитивното групиране е истинската работа и структурата Union-Find (Обедини-Намери) се справя с нея в един проход: всяка открита двойка обединява два множества, което в крайна сметка води до напълно формирани групи дубликати.

Все още трябва да изберете кой член да остане. Правилото, използвано тук – най-краткият текст – работи добре за въпроси към поддръжката, където най-кратката формулировка често е най-каноничната. За корпус от документи вероятно ще искате обратното или най-скорошния: това е бизнес решение, а не технически детайл. Върнатият речник запазва списъка с изтритите текстове, така че човек да може да провери граничните случаи, преди да ги одобри.

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

Приложена преди изграждането на RAG индекс, тази дедупликация има директен ефект върху качеството: тя предотвратява ситуацията, в която петте резултата, върнати за даден въпрос, са пет версии на един и същи пасаж, което би лишило генератора от всякаква допълнителна информация.

Ключови изводи

  • Разстоянието до центроида или k-NN открива необичайни текстове
  • Косинусното сходство над даден праг идентифицира дубликати
  • Union-Find ефективно групира транзитивни дубликати
  • Калибрирайте праговете спрямо Вашите данни (обикновено 0.85–0.95 за дубликати)