Přejít na hlavní obsah
Čeština— Vyberte jazyk
Menu

Detekce anomálií a duplicit

Lekce 20 z 22 Aktualizováno 29. července 2026 Vývojář
Na této stránce
  1. Cíle
  2. Detekce anomálií
  3. Detekce sémantických duplicit
  4. Pipeline pro odstraňování duplicit
  5. Klíčové poznatky

Cíle

  • Detekovat abnormální texty v rámci korpusu
  • Identifikovat sémantické duplicity
  • Vytvořit pipeline pro odstraňování duplicit

Detekce anomálií

Obě aplikace v této lekci sdílejí stejnou intuici, aplikovanou na opačné konce stupnice podobnosti. Text je „abnormální“, pokud je sémanticky vzdálený všemu ostatnímu v korpusu; text je duplicitní, pokud je příliš blízký. Vnoření (embeddings) ti umožňují tuto vzdálenost v obou případech změřit. Většina práce spočívá v kalibraci prahových hodnot.

První přístup sestaví centroid korpusu – průměr všech vektorů, který reprezentuje „obvyklé téma tohoto korpusu“ – a následně změří, jak moc se od něj každý text odchyluje. Prahová hodnota záměrně není absolutní hodnotou, ale percentilem: předem nemůžeš vědět, jak daleko se anomálie nachází, ale víš, že chceš prozkoumat těch nejatypičtějších 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]}...")

Příkladový korpus mluví sám za sebe: pět vět o zásadách lidských zdrojů a jeden pokus o SQL injekci. Žádný filtr klíčových slov by tento útok bez předem napsaného pravidla neodhalil; vzdálenost od centroidu jej však označí bez jakékoli předchozí anticipace. To je hlavní argument pro použití této metody při monitorování proudu příchozích dokumentů.

Centroid má však jednu slabinu: předpokládá, že se korpus točí kolem jediného tématu. Pokud tvoje dokumenty pokrývají tři velmi odlišné domény, průměrný bod spadne do sémantického vakua a všechny texty se zdají stejně vzdálené. Přístup k-nearest neighbors (k-NN) se tomuto problému vyhýbá tím, že každý text posuzuje na základě jeho bezprostředního okolí, nikoli celé množiny: dokument patřící do menšinové skupiny zůstává normální, dokud má své sousedy.

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

Detekce sémantických duplicit

Na druhém konci stupnice leží texty, které jsou příliš blízké. Dva záznamy mohou být duplicity i při použití různých slov – „Jak si resetuji heslo?“ a „Zapomněl jsem heslo, co mám dělat?“ mají společná pouze tři slova – a to je přesně to, co hašování nebo porovnávání řetězců nikdy neodhalí. Vnoření je detekují.

Funkce vypočítá úplnou matici podobnosti a vrátí všechny páry nad prahovou hodnotou. Pozor na náklady: toto porovnání je kvadratické, což zůstává okamžité pro několik tisíc textů, ale pro milion se stává nepraktickým – tehdy musíš použít přibližný index, jako jsou ty probírané u vektorových databází.

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

Volání zde používá prahovou hodnotu 0,85 místo výchozí 0,90, protože přeformulování stejné otázky podpory často klesají hluboko pod 0,90. Toto je nastavení, na kterém strávíš nejvíce času laděním: pokud jej nastavíš příliš vysoko, necháš duplicity proklouznout; pokud příliš nízko, sloučíš „jak změním heslo“ s „jak změním e-mailovou adresu“, což jsou dvě odlišné otázky, které vypadají velmi podobně.

Pipeline pro odstraňování duplicit

Detekce párů nestačí k vyčištění korpusu. Pokud se A podobá B a B se podobá C, všechny tři patří do stejné skupiny, i když A a C nebyly nikdy přímo porovnány nad prahovou hodnotou. Tranzitivní seskupování je skutečná práce a struktura Union-Find ji zvládne v jediném průchodu: každý detekovaný pár sloučí dvě množiny, čímž na konci vzniknou plně utvořené skupiny duplicit.

Stále si musíš vybrat, který člen přežije. Zde použité pravidlo – nejkratší text – funguje dobře pro dotazy podpory, kde je nejstručnější formulace často tou nejkanoničtější. Pro korpus dokumentů pravděpodobně budeš chtít opak, nebo ten nejnovější: toto je obchodní rozhodnutí, nikoli technický detail. Vrácený slovník uchovává seznam smazaných textů, aby je člověk mohl ověřit v hraničních případech před schválením.

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

Aplikováno upstream před RAG indexem má toto odstraňování duplicit přímý dopad na kvalitu: zabraňuje tomu, aby pět výsledků vrácených pro otázku bylo pěti verzemi téhož úryvku, což by generátor připravilo o jakékoli další informace.

Klíčové poznatky

  • Vzdálenost od centroidu nebo k-NN detekuje abnormální texty
  • Kosinová podobnost nad prahovou hodnotou identifikuje duplicity
  • Union-Find efektivně seskupuje tranzitivní duplicity
  • Kalibruj prahové hodnoty na svých datech (typicky 0,85–0,95 pro duplicity)