Anomalijų ir dublikatų aptikimas
Šiame puslapyje
Tikslai
- Aptikti nenormalius tekstus teksto rinkinyje
- Identifikuoti semantinius dublikatus
- Sukurti dedublikavimo procesą
Anomalijų aptikimas
Šios pamokos dvi taikymo sritys remiasi ta pačia intuicija, taikoma priešingiems panašumo skalės galams. Tekstas yra „nenormalus“, jei jis semantiškai nutolęs nuo visų kitų rinkinio elementų; tekstas yra dublikatas, jei jis per artimas. Įterptiniai vektoriai (embeddings) leidžia išmatuoti šį atstumą abiem atvejais. Didžioji darbo dalis – tai slenksčių kalibravimas.
Pirmasis požiūris sukuria rinkinio centroidą – visų vektorių vidurkį, kuris reprezentuoja „įprastą šio rinkinio temą“, tada matuoja, kiek kiekvienas tekstas nuo jo nukrypsta. Slenkstis sąmoningai nėra absoliuti vertė, o percentilis: iš anksto negali žinoti, kaip toli yra anomalija, bet žinai, kad nori peržiūrėti netipiškiausius 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]}...")
Pavyzdinis rinkinys kalba pats už save: penki HR politikos sakiniai ir vienas SQL injekcijos bandymas. Joks raktinių žodžių filtras nebūtų pagavęs injekcijos be iš anksto parašytos taisyklės; atstumas iki centroide ją pažymi be jokio išankstinio numatymo. Tai pagrindinis argumentas naudoti šį metodą stebint gaunamų dokumentų srautą.
Centroidas turi vieną silpnybę: jis daro prielaidą, kad rinkinys sukasi apie vieną temą. Jei tavo dokumentai apima tris labai skirtingas sritis, vidurkio taškas atsiduria semantinėje tuštumoje, ir visi tekstai atrodo vienodai nutolę. K-artimiausių kaimynų (k-NN) požiūris tai apeina, vertindamas kiekvieną tekstą pagal jo tiesioginę kaimynystę, o ne visą aibę: dokumentas, priklausantis mažumai, lieka normalus, tol, kol turi kaimynų.
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
Semantinis dublikatų aptikimas
Kitame skalės gale yra tekstai, kurie yra per arti. Du įrašai gali būti dublikatai net ir naudojant skirtingus žodžius – „Kaip atkurti slaptažodį?“ ir „Pamiršau slaptažodį, ką daryti?“ turi tik tris bendrus žodžius – ir būtent to niekada nepagaus nei maišos funkcijos (hashing), nei eilučių palyginimas. Įterptiniai vektoriai juos aptinka.
Funkcija apskaičiuoja visą panašumo matricą ir grąžina visas poras, viršijančias slenkstį. Stebėk kainą: šis palyginimas yra kvadratinis, kas lieka akimirksniu atliekama keliems tūkstančiams tekstų, bet tampa nepraktiška milijonui – tuomet turi naudoti apytikslį indeksą, pavyzdžiui, tuos, kurie aptariami vektorių duomenų bazių skyriuje.
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']}")
Čia kvietimas naudoja 0,85 slenkstį vietoj numatytojo 0,90, nes to paties pagalbos klausimo performuluojimai dažnai būna gerokai žemiau 0,90. Tai nustatymas, kuriam derinti sugaiši daugiausia laiko: nustatyk per aukštai – ir praleisi dublikatus; nustatyk per žemai – ir sujungsi „kaip pakeisti slaptažodį“ su „kaip pakeisti el. pašto adresą“, du skirtingus klausimus, kurie atrodo labai panašūs.
Dedublikavimo procesas
Porų aptikimo nepakanka rinkiniui išvalyti. Jei A panašus į B, o B panašus į C, visi trys priklauso tai pačiai grupei, net jei A ir C niekada nebuvo tiesiogiai palyginti viršijant slenkstį. Tikrasis darbas – tai tranzityvus grupavimas, kurį vienu praėjimu atlieka „Union-Find“ (susijungimo ir radimo) struktūra: kiekviena aptikta pora sujungia dvi aibes, galiausiai sudarydama pilnai suformuotas dublikatų grupes.
Vis tiek reikia pasirinkti, kuris narys išliks. Čia naudojama taisyklė – trumpiausias tekstas – gerai veikia pagalbos klausimams, kur glaustiausia formuliuotė dažnai yra kanoniškiausia. Dokumentų rinkiniui greičiausiai norėsi priešingai, arba naujausio: tai verslo sprendimas, o ne techninė detalė. Grąžinamas žodynas palieka ištrintų tekstų sąrašą, kad žmogus galėtų patikrinti ribinius atvejus prieš patvirtindamas.
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']}")
Pritaikius tai prieš RAG indeksą, šis dedublikavimas daro tiesioginę įtaką kokybei: jis neleidžia, kad penki klausimui grąžinti rezultatai būtų penkios to paties ištraukos versijos, kas atimtų iš generatoriaus bet kokią papildomą informaciją.
Svarbiausi punktai
- Atstumas iki centroide arba k-NN aptinka nenormalius tekstus
- Kosinusinis panašumas virš slenksčio identifikuoja dublikatus
- „Union-Find“ efektyviai sugrupuoja tranzityvius dublikatus
- Kalibruok slenksčius pagal savo duomenis (paprastai 0,85–0,95 dublikatams)