Detecția anomaliilor și a duplicatelor
Pe această pagină
Obiective
- Detectarea textelor anormale într-un corpus
- Identificarea duplicatelor semantice
- Construirea unui flux de deduplicare
Detecția anomaliilor
Cele două aplicații din această lecție se bazează pe aceeași intuiție, aplicată la capetele opuse ale scalei de similaritate. Un text este „anormal“ dacă este semantic distant de tot restul din corpus; un text este un duplicat dacă este prea apropiat. Embedding-urile vă permit să măsurați această distanță în ambele cazuri. Majoritatea efortului constă în calibrarea pragurilor.
Prima abordare construiește centroidul corpusului—media tuturor vectorilor, care reprezintă „subiectul obișnuit al acestui corpus“—apoi măsoară cât de mult se abate fiecare text de la acesta. Pragul nu este intenționat o valoare absolută, ci o percentilă: nu puteți ști în prealabil cât de departe se află o anomalie, dar știți că doriți să examinați cele mai atipice 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]}...")
Exemplul de corpus spune totul: cinci propoziții despre politica de resurse umane și o încercare de injecție SQL. Niciun filtru bazat pe cuvinte-cheie nu ar fi prins injecția fără o regulă predefinită; distanța față de centroid o semnalează fără nicio anticipare prealabilă. Acesta este principalul argument pentru utilizarea metodei în monitorizarea unui flux de documente primite.
Centroidul are totuși o slăbiciune: presupune că corpusul se învârte în jurul unei singure teme. Dacă documentele dumneavoastră acoperă trei domenii foarte diferite, punctul mediu cade într-un vid semantic, iar toate textele par la fel de distante. Abordarea k-nearest neighbors (k-NN) ocolește această problemă judecând fiecare text pe baza vecinătății sale imediate, nu a întregului set: un document care aparține unui grup minoritar rămâne normal atâta timp cât are vecini.
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
Detecția duplicatelor semantice
La celălalt capăt al scalei se află textele care sunt prea apropiate. Două intrări pot fi duplicat chiar și cu cuvinte diferite—„Cum îmi resetez parola?“ și „Am uitat parola, ce fac?“ au doar trei cuvinte comune—și exact asta este ceea ce hash-ul sau compararea șirurilor de caractere nu vor prinde niciodată. Embedding-urile le detectează.
Funcția calculează matricea completă de similaritate și returnează toate perechile de peste prag. Atenție la cost: această comparație este pătratică, ceea ce rămâne instantaneu pentru câteva mii de texte, dar devine impracticabil pentru un milion—trebuie să utilizați atunci un index aproximativ, cum sunt cele prezentate la bazele de date vectoriale.
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']}")
Apelul de aici folosește un prag de 0,85 în loc de implicitul 0,90 deoarece reformulările aceleiași întrebări de suport cad adesea mult sub 0,90. Aceasta este setarea pe care veți petrece cel mai mult timp ajustând-o: dacă o setați prea sus, lăsați duplicatele să scape; dacă o setați prea jos, uniți „cum îmi schimb parola“ cu „cum îmi schimb adresa de e-mail“, două întrebări distincte care arată foarte similar.
Flux de deduplicare
Detectarea perechilor nu este suficientă pentru a curăța un corpus. Dacă A seamănă cu B și B seamănă cu C, toate trei aparțin aceluiași grup, chiar dacă A și C nu au fost comparate direct peste prag. Gruparea tranzitivă este adevărata muncă, iar structura Union-Find o gestionează într-o singură trecere: fiecare pereche detectată îmbină două seturi, rezultând grupuri de duplicate complet formate la final.
Trebuie totuși să alegeți care membru supraviețuiește. Regula folosită aici—cel mai scurt text—funcționează bine pentru întrebările de suport, unde formularea cea mai concisă este adesea cea mai canonică. Pentru un corpus de documente, veți dori probabil opusul, sau pe cel mai recent: aceasta este o decizie de business, nu un detaliu tehnic. Dicționarul returnat păstrează lista textelor șterse, astfel încât un om să poată verifica cazurile limită înainte de aprobare.
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']}")
Aplicată în amonte de un index RAG, această deduplicare are un efect direct asupra calității: împiedică cele cinci rezultate returnate pentru o întrebare să fie cinci versiuni ale aceluiași pasaj, ceea ce ar priva generatorul de orice informație suplimentară.
Puncte cheie
- Distanța față de centroid sau k-NN detectează textele anormale
- Similaritatea cosinusică peste un prag identifică duplicatele
- Union-Find grupează eficient duplicatele tranzitive
- Calibrați pragurile pe datele dumneavoastră (de obicei 0,85–0,95 pentru duplicate)