Siirry pääsisältöön
Suomi— Valitse kieli
Valikko

Poikkeavuuksien ja kaksoiskappaleiden havaitseminen

Oppitunti 20 / 22 Päivitetty 29. heinäkuuta 2026 Kehittäjä
Tällä sivulla
  1. Tavoitteet
  2. Poikkeavuuksien havaitseminen
  3. Semanttinen kaksoiskappaleiden havaitseminen
  4. Deduplikaatioputki
  5. Keskeiset asiat

Tavoitteet

  • Havaitse poikkeavia tekstejä tekstikorpuksesta
  • Tunnista semanttiset kaksoiskappaleet
  • Rakenna deduplikaatioputki

Poikkeavuuksien havaitseminen

Tämän oppitunnin kahdella sovelluksella on sama perusajatus, jota sovelletaan samankaltaisuusasteikon vastakkaisiin päihin. Teksti on “poikkeava”, jos se on semanttisesti etäällä kaikesta muusta korpuksesta; teksti on kaksoiskappale, jos se on liian lähellä. Upotukset (embeddings) mahdollistavat tämän etäisyyden mittaamisen molemmissa tapauksissa. Suurin osa työstä liittyy kynnysarvojen kalibrointiin.

Ensimmäinen lähestymistapa rakentaa korpuksen sentroidin – kaikkien vektorien keskiarvon, joka edustaa “tämän korpuksen yleistä aihetta” – ja mittaa sitten, kuinka kaukana kukin teksti on siitä. Kynnysarvo ei tarkoituksella ole absoluuttinen luku, vaan persentiili: et voi etukäteen tietää, kuinka kaukana poikkeavuus sijaitsee, mutta tiedät haluavasi tarkastella epätyypillisintä 5 %:a.

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

Esimerkkikorpus kertoo kaiken: viisi henkilöstöpolitiikkaa koskevaa lausetta ja yksi SQL-injektioyritys. Mikään avainsanasuodatin ei olisi havainnut injektiota ilman ennalta kirjoitettua sääntöä; etäisyys sentroidiin paljastaa sen ilman ennakkoon tehtyjä oletuksia. Tämä on pääasiallinen peruste menetelmän käytölle saapuvien asiakirjavirtojen valvonnassa.

Sentroidilla on kuitenkin heikkous: se olettaa korpuksen pyörivän yhden teeman ympärillä. Jos asiakirjasi kattavat kolme hyvin erilaista aluetta, keskipiste putoaa semanttiseen tyhjiöön, ja kaikki tekstit näyttävät yhtä etäisiltä. K-lähimmän naapurin (k-NN) lähestymistapa kiertää tämän arvioimalla jokaisen tekstin sen välittömän ympäristön perusteella koko joukon sijaan: vähemmistöryhmään kuuluva asiakirja pysyy normaalina, niin kauan kuin sillä on naapureita.

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

Semanttinen kaksoiskappaleiden havaitseminen

Asteikon toisessa päässä ovat tekstit, jotka ovat liian lähellä toisiaan. Kaksi merkintää voivat olla kaksoiskappaleita vaikka niissä olisi eri sanoja – “How do I reset my password?” ja “Forgot password, what do I do?” jakavat vain kolme yhteistä sanaa – ja juuri tämän hashing tai merkkijonovertailu ei koskaan havaitse. Upotukset tunnistavat ne.

Funktio laskee koko samankaltaisuusmatriisin ja palauttaa kaikki kynnysarvon ylittävät parit. Huomioi kustannukset: tämä vertailu on neliöllistä, mikä pysyy hetkellisenä muutaman tuhannen tekstin kohdalla, mutta muuttuu käytännöllisesti mahdottomaksi miljoonan tekstin kohdalla – tällöin sinun on käytettävä likimääräistä indeksiä, kuten vektoritietokantojen yhteydessä käsiteltyjä.

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

Tässä kutsussa käytetään kynnysarvoa 0,85 oletusarvon 0,90 sijaan, koska saman tukikysymyksen uudelleenmuotoilut jäävät usein hyvin alle arvon 0,90. Tämä on asetus, jonka säätämiseen käytät eniten aikaa: jos asetat sen liian korkealle, päästät kaksoiskappaleet läpi; jos asetat sen liian matalalle, yhdistät kysymykset “kuinka vaihdan salasanani” ja “kuinka vaihdan sähköpostiosoitettani”, jotka ovat kaksi erillistä kysymystä vaikka näyttävätkin hyvin samankaltaisilta.

Deduplikaatioputki

Parin havaitseminen ei riitä korpuksen siivoamiseen. Jos A muistuttaa B:tä ja B muistuttaa C:tä, kaikki kolme kuuluvat samaan ryhmään, vaikka A:ta ja C:tä ei olisi koskaan verrattu suoraan toisiinsa kynnysarvon yli. Transitiivinen ryhmittely on varsinainen työ, ja Union-Find-rakenne hoitaa sen yhdellä läpikäynnillä: jokainen havaittu pari yhdistää kaksi joukkoa, jolloin lopputuloksena ovat täysin muodostuneet kaksoiskappaleryhmät.

Sinun on silti valittava, mikä jäsen säilytetään. Tässä käytetty sääntö – lyhin teksti – toimii hyvin tukikysymyksissä, joissa tiiviin muotoilu on usein kanonisin. Asiakirjakorpuksen kohdalla haluat todennäköisesti päinvastoin, tai uusimman version: tämä on liiketoimintapäätös, ei tekninen yksityiskohta. Palautettu sanakirja pitää luetteloa poistetuista teksteistä, jotta ihminen voi tarkistaa rajatapaukset ennen hyväksymistä.

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

Kun tämä deduplikaatio suoritetaan ennen RAG-indeksiä, sillä on suora vaikutus laatuun: se estää tilanteen, jossa kysymykselle palautetut viisi tulosta olisivat viittä versiota samasta kohdasta, mikä veisi generaattorilta kaiken lisäinformaation.

Keskeiset asiat

  • Etäisyys sentroidiin tai k-NN havaitsee poikkeavat tekstit
  • Kosinussamankaltaisuus kynnysarvon yli tunnistaa kaksoiskappaleet
  • Union-Find ryhmittelee transitiiviset kaksoiskappaleet tehokkaasti
  • Kalibroi kynnysarvot omalle datallesi (tyypillisesti 0,85–0,95 kaksoiskappaleille)