Detektering av anomalier och dubbletter
På denna sida
Mål
- Upptäcka onormala texter inom ett korpus
- Identifiera semantiska dubbletter
- Bygga en pipeline för avduplicering
Detektering av anomalier
De två tillämpningarna i denna lektion delar samma intuition, men applicerad på motsatta ändar av likhetsskalan. En text är “onormal” om den är semantiskt avlägsen från allt annat i korpuset; en text är en dubblett om den är för lik. Inbäddningar låter dig mäta detta avstånd i båda fallen. Det mesta arbetet handlar om att kalibrera tröskelvärdena.
Den första metoden bygger korpusets centroid – genomsnittet av alla vektorer, vilket representerar “korpusets vanliga ämne” – och mäter sedan hur mycket varje text avviker från den. Tröskelvärdet är avsiktligt inte ett absolut värde utan en percentil: du kan inte i förväg veta hur långt bort en anomali ligger, men du vet att du vill granska de 5 % mest atypiska texterna.
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]}...")
Exempelkorpust berättar historien: fem meningar om HR-policy och ett SQL-injektionsförsök. Inget nyckelordsfilter skulle ha fångat injektionen utan en förskriven regel; avståndet till centroiden flaggar den utan någon som helst förhandskunskap. Detta är huvudargumentet för att använda metoden för att övervaka ett flöde av inkommande dokument.
Centroiden har dock en svaghet: den förutsätter att korpuset kretsar kring ett enda tema. Om dina dokument täcker tre mycket olika domäner hamnar medelpunkten i ett semantiskt tomrum, och alla texter verkar lika avlägsna. Metoden med k närmaste grannar (k-NN) kringgår detta genom att bedöma varje text baserat på dess omedelbara omgivning snarare än hela mängden: ett dokument som tillhör en minoritetsgrupp förblir normalt så länge det har grannar.
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
Semantisk detektering av dubbletter
I den andra änden av skalan finns texter som är för lika. Två poster kan vara dubbletter även med olika ord – “Hur återställer jag mitt lösenord?” och “Glömt lösenord, vad gör jag?” delar bara tre gemensamma ord – och det är precis vad hashning eller strängjämförelse aldrig kommer att fånga. Inbäddningar upptäcker dem.
Funktionen beräknar hela likhetsmatrisen och returnerar alla par över tröskelvärdet. Akta dig för kostnaden: denna jämförelse är kvadratisk, vilket går blixtsnabbt för några tusen texter men blir opraktiskt för en miljon – då måste du använda ett approximativt index som de som behandlas tillsammans med vektordatabaser.
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']}")
Anropet här använder ett tröskelvärde på 0,85 istället för standardvärdet 0,90 eftersom omformuleringar av samma supportfråga ofta hamnar väl under 0,90. Detta är den inställning du kommer att spendera mest tid på att finjustera: sätter du den för högt släpper du igenom dubbletter; sätter du den för lågt slår du ihop “hur ändrar jag mitt lösenord” med “hur ändrar jag min e-postadress”, två distinkta frågor som ser väldigt lika ut.
Pipeline för avduplicering
Att upptäcka par räcker inte för att rensa ett korpus. Om A liknar B och B liknar C, tillhör alla tre samma grupp, även om A och C aldrig jämfördes direkt över tröskelvärdet. Transitiv gruppering är det egentliga arbetet, och strukturen Union-Find hanterar detta i ett enda svep: varje upptäckt par slår samman två mängder, vilket ger färdiga dubblettgrupper i slutet.
Du måste fortfarande välja vilken medlem som ska överleva. Regeln som används här – den kortaste texten – fungerar bra för supportfrågor, där den mest koncisa formuleringen ofta är den mest kanoniska. För ett dokumentkorpus vill du sannolikt ha motsatsen, eller den senaste: detta är ett affärsmässigt beslut, inte en teknisk detalj. Den returnerade ordboken behåller listan över raderade texter så att en människa kan verifiera kantfallen innan de godkänns.
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']}")
När denna avduplicering tillämpas uppströms ett RAG-index får den en direkt effekt på kvaliteten: den förhindrar att de fem resultaten som returneras för en fråga är fem versioner av samma passage, vilket skulle beröva generatorn all ytterligare information.
Viktiga punkter
- Avstånd till centroiden eller k-NN upptäcker onormala texter
- Cosinuslikhet över ett tröskelvärde identifierar dubbletter
- Union-Find grupperar transitiva dubbletter effektivt
- Kalibrera tröskelvärdena på dina data (vanligtvis 0,85–0,95 för dubbletter)