Anomāliju un dublikātu noteikšana
Šajā lapā
Mērķi
- Atklāt neparastus tekstus korpusā
- Identificēt semantiskos dublikātus
- Izveidot deduplikācijas procesu
Anomāliju noteikšana
Abiem šīs nodarbības lietojumiem ir kopīga intuīcija, kas pielietota pretējos līdzības skalas galos. Teksts ir „neparasts”, ja tas semantiski atšķiras no visa pārējā korpusā; teksts ir dublikāts, ja tas ir pārāk līdzīgs. Iegulšanas (embeddings) ļauj izmērīt šo attālumu abos gadījumos. Lielākā daļa darba saistīta ar sliekšņu kalibrēšanu.
Pirmā pieeja veido korpusa centroidu — visu vektoru vidējo vērtību, kas pārstāv „šo korpusu parasto tēmu” — un pēc tam mēra, cik tālu katrs teksts no tā atšķiras. Slieksnis apzināti nav absolūta vērtība, bet gan percentils: tu nevari iepriekš zināt, cik tālu atrodas anomālija, bet tu zini, ka vēlies pārbaudīt netipiskākos 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]}...")
Piemēra korpuss stāsta visu: pieci HR politikas teikumi un viens SQL injicēšanas mēģinājums. Neviens atslēgvārdu filtrs nebūtu atklājis injicēšanu bez iepriekš uzrakstīta noteikuma; attālums līdz centroidam to atzīmē bez jebkādas iepriekšējas paredzēšanas. Tas ir galvenais arguments šīs metodes izmantošanai, lai uzraudzītu ienākošo dokumentu plūsmu.
Centroidam tomēr ir vājā vieta: tas pieņem, ka korpuss riņķo ap vienu tēmu. Ja tavi dokumenti aptver trīs ļoti dažādas jomas, vidējais punkts nonāk semantiskā tukšumā, un visi teksti šķiet vienlīdz tāli. K-tuvāko kaimiņu (k-nearest neighbors) pieeja to apej, vērtējot katru tekstu, balstoties uz tā tiešo apkārtni, nevis visu kopu: dokuments, kas pieder minoritātes grupai, paliek normāls, kamēr tam ir kaimiņi.
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
Semantisko dublikātu noteikšana
Skalas otrā galā atrodas teksti, kas ir pārāk līdzīgi. Divi ieraksti var būt dublikāti pat ar dažādiem vārdiem — „Kā es varu atiestatīt savu paroli?” un „Aizmirsu paroli, ko darīt?” koplieto tikai trīs kopīgus vārdus — un tieši to nekad neatklās hašošana vai virkņu salīdzināšana. Iegulšanas tos atklāj.
Funkcija aprēķina pilnu līdzības matricu un atgriež visus pārus virs sliekšņa. Uzmanies ar izmaksām: šī salīdzināšana ir kvadrātiska, kas paliek acumirklīga dažiem tūkstošiem tekstu, bet kļūst nepraktiska miljonam — tad tev jāizmanto aptuvenais indekss, piemēram, tie, kas apskatīti saistībā ar vektoru datubāzēm.
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']}")
Šeit izsaukums izmanto slieksni 0,85, nevis noklusējuma 0,90, jo viena un tā paša atbalsta jautājuma pārfrazējumi bieži vien ir ievērojami zem 0,90. Šis ir iestatījums, kura pielāgošanai tu veltīsi visvairāk laika: ja to iestatīsi pārāk augstu, lai cauri izslīdēs dublikāti; ja pārāk zemu, apvienosi „kā mainīt paroli” ar „kā mainīt e-pasta adresi” — divus atšķirīgus jautājumus, kas izskatās ļoti līdzīgi.
Deduplikācijas process
Pāru noteikšana nepietiek, lai attīrītu korpusu. Ja A līdzinās B un B līdzinās C, visi trīs pieder vienai grupai, pat ja A un C nekad nav tieši salīdzināti virs sliekšņa. Transitīvā grupēšana ir īstais darbs, un struktūra Union-Find to paveic vienā piegājienā: katrs atklātais pāris apvieno divas kopas, beigās iegūstot pilnībā izveidotas dublikātu grupas.
Tev joprojām jāizvēlas, kurš dalībnieks paliek. Šeit izmantotais noteikums — īsākais teksts — labi strādā atbalsta jautājumiem, kur kodolīgākā formulējums bieži vien ir viskanoniskākais. Dokumentu korpusam tu, visticamāk, vēlēsies pretējo vai visjaunāko: tas ir biznesa lēmums, nevis tehniska detaļa. Atgrieztā vārdnīca saglabā dzēsto tekstu sarakstu, lai cilvēks varētu pārbaudīt robežgadījumus pirms apstiprināšanas.
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']}")
Pielietota pirms RAG indeksa, šī deduplikācija tieši ietekmē kvalitāti: tā novērš situāciju, kurā pieci jautājumam atgrieztie rezultāti ir piecas viena un tā paša fragmenta versijas, kas generatoram atņemtu jebkādu papildu informāciju.
Galvenās atziņas
- Attālums līdz centroidam vai k-NN atklāj neparastus tekstus
- Kosinus līdzība virs sliekšņa identificē dublikātus
- Union-Find efektīvi grupē transitīvos dublikātus
- Kalibrē sliekšņus uz saviem datiem (parasti 0,85–0,95 dublikātiem)