Откриване на аномалии и дубликати
На тази страница
Цели
- Откриване на необичайни текстове в корпус
- Идентифициране на семантични дубликати
- Изграждане на конвейер за дедупликация
Откриване на аномалии
Двете приложения в този урок споделят една и съща интуиция, приложена към противоположните краища на скалата за сходство. Един текст е „необичаен“, ако е семантично отдалечен от всичко останало в корпуса; текстът е дубликат, ако е твърде близък. Вгражданията (embeddings) Ви позволяват да измерите това разстояние и в двата случая. По-голямата част от работата се състои в калибрирането на праговете.
Първият подход изгражда центроида на корпуса – средната стойност на всички вектори, която представлява „обичайната тема на този корпус“ – и след това измерва колко далеч се отклонява всеки текст от него. Прагът умишлено не е абсолютна стойност, а перцентил: не можете да знаете предварително колко далеч се намира една аномалия, но знаете, че искате да разгледате най-нетипичните 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]}...")
Примерният корпус разказва историята: пет изречения относно политиката за отпуски и един опит за SQL инжекция. Никакъв филтър по ключови думи не би хванал инжекцията без предварително написано правило; разстоянието до центроида я открива без никакво предварително очакване. Това е основният аргумент за използването на метода за мониторинг на поток от входящи документи.
Центроидът обаче има слабост: той приема, че корпусът се върти около една единствена тема. Ако документите Ви обхващат три много различни области, средната точка попада в семантична пустота и всички текстове изглеждат еднакво отдалечени. Подходът с k-най-близки съседи (k-nearest neighbors) заобикаля това, като оценява всеки текст въз основа на непосредственото му обкръжение, а не на целия набор: документ, принадлежащ към малцинствена група, остава нормален, стига да има съседи.
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
Откриване на семантични дубликати
В другия край на скалата са текстовете, които са твърде близки. Два записа могат да бъдат дубликати дори с различни думи – „Как да нулирам паролата си?“ и „Забравих паролата, какво да правя?“ споделят само три общи думи – и точно това е нещо, което хеширането или сравняването на низове никога няма да улови. Вгражданията ги откриват.
Функцията изчислява пълната матрица на сходство и връща всички двойки над прага. Внимавайте за разходите: това сравнение е квадратично, което остава мигновено за няколко хиляди текста, но става непрактично за един милион – тогава трябва да използвате приблизителен индекс като тези, разгледани при векторните бази данни.
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']}")
Извикването тук използва праг от 0.85, а не стандартния 0.90, защото преформулировките на един и същи въпрос за поддръжка често падат значително под 0.90. Това е настройката, върху която ще отделите най-много време за прецизиране: ако го зададете твърде високо, ще пропуснете дубликати; ако го зададете твърде ниско, ще обедините „как да променя паролата си“ с „как да променя имейл адреса си“ – два различни въпроса, които изглеждат много сходни.
Конвейер за дедупликация
Откриването на двойки не е достатъчно, за да почистите един корпус. Ако А прилича на Б и Б прилича на В, и трите принадлежат към една и съща група, дори ако А и В никога не са били директно сравнявани над прага. Транзитивното групиране е истинската работа и структурата Union-Find (Обедини-Намери) се справя с нея в един проход: всяка открита двойка обединява два множества, което в крайна сметка води до напълно формирани групи дубликати.
Все още трябва да изберете кой член да остане. Правилото, използвано тук – най-краткият текст – работи добре за въпроси към поддръжката, където най-кратката формулировка често е най-каноничната. За корпус от документи вероятно ще искате обратното или най-скорошния: това е бизнес решение, а не технически детайл. Върнатият речник запазва списъка с изтритите текстове, така че човек да може да провери граничните случаи, преди да ги одобри.
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']}")
Приложена преди изграждането на RAG индекс, тази дедупликация има директен ефект върху качеството: тя предотвратява ситуацията, в която петте резултата, върнати за даден въпрос, са пет версии на един и същи пасаж, което би лишило генератора от всякаква допълнителна информация.
Ключови изводи
- Разстоянието до центроида или k-NN открива необичайни текстове
- Косинусното сходство над даден праг идентифицира дубликати
- Union-Find ефективно групира транзитивни дубликати
- Калибрирайте праговете спрямо Вашите данни (обикновено 0.85–0.95 за дубликати)