Poikkeavuuksien ja kaksoiskappaleiden havaitseminen
Tällä sivulla
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)