Detezzjoni ta' Anomaliji u Duplikati
F'din il-paġna
Għanijiet
- Tiskopri testi anormali fi ħdan korp ta’ testi
- Tidentifika duplikati semantiċi
- Tibni pipeline għad-deduplikazzjoni
Detezzjoni ta’ Anomaliji
Iż-żewġ applikazzjonijiet f’din il-lezzjoni jaqsmu l-istess intuizzjoni, applikata għat-truf opposti tal-iskala tas-similarità. Test huwa “anormali” jekk huwa semantikament ‘il bogħod minn kull ħaġa oħra fil-korp; test huwa duplikat jekk huwa qrib wisq. L-embeddings jħalluk tkejjel din id-distanza fiż-żewġ każijiet. Il-biċċa l-kbira tax-xogħol tinvolvi l-kalibrazzjoni tal-limiti (thresholds).
L-ewwel approċċ jibni ċ-ċentrojde tal-korp—il-medja tal-vetturi kollha, li tirrappreżenta “is-suġġett tas-soltu ta’ dan il-korp”—imbagħad ikejjel kemm jiddevja kull test minnu. Il-limitu intenzjonalment mhuwiex valur assolut iżda perċentil: ma tistax tkun taf minn qabel kemm ‘il bogħod tinsab anomalija, iżda taf li trid teżamina l-5% l-aktar atipiċi.
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]}...")
Il-korp ta’ eżempju jirrakkonta l-istorja: ħames sentenzi dwar il-politika tar-riżorsi umani u tentattiv wieħed ta’ injezzjoni SQL. L-ebda filtru ta’ kliem ma kien jaqbad l-injezzjoni mingħajr regola miktuba minn qabel; id-distanza miċ-ċentrojde tiffaċċjah mingħajr l-ebda antiċipazzjoni minn qabel. Dan huwa l-argument ewlieni biex tuża l-metodu biex timmonitorja fluss ta’ dokumenti li qed jaslu.
Iċ-ċentrojde għandu dgħufija: jassumi li l-korp idur madwar tema waħda. Jekk id-dokumenti tiegħek ikopru tliet oqsma differenti ħafna, il-punt medju jaqa’ f’vojt semantiku, u t-testi kollha jidhru ekwidistanti. L-approċċ tal-ġirien l-aktar qrib (k-nearest neighbors) jevita dan billi jiġġudika kull test ibbażat fuq il-viċinat immedjat tiegħu minflok is-sett kollu: dokument li jappartjeni għal grupp minoritarju jibqa’ normali sakemm ikollu ġirien.
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
Detezzjoni Semantika ta’ Duplikati
Fit-tarf l-ieħor tal-iskala hemm testi li huma qrib wisq. Żewġ entrati jistgħu jkunu duplikati anke b’kliem differenti—“Kif nirriżettja l-password tiegħi?” u “Insejt il-password, x’għandi nagħmel?” jaqsmu tliet kliem komuni biss—u dan huwa eżattament dak li l-hash jew it-tqabbil ta’ strings qatt ma jaqbdu. L-embeddings jiskopruhom.
Il-funzjoni tikkalkula l-matriċi sħiħa tas-similarità u tirritorna l-pari kollha fuq il-limitu. Ara l-ispiża: dan it-tqabbil huwa kwadratiku, li jibqa’ istantanju għal ftit eluf ta’ testi iżda jsir imprattikabbli għal miljun—mbagħad trid tuża indiċi approssimattiv bħal dawk koperti mal-bażijiet tad-data vettorjali.
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']}")
Is-sejħa hawnhekk tuża limitu ta’ 0.85 minflok id-default ta’ 0.90 għax ir-riformulazzjonijiet tal-istess mistoqsija ta’ appoġġ spiss jaqgħu ferm taħt 0.90. Din hija l-issettjar li se tqatta’ l-aktar ħin tikkalibra: jekk tpoġġih għoli wisq, tħalli d-duplikati jgħaddu; jekk tpoġġih baxx wisq, tgħaqqad “kif nibdel il-password tiegħi” ma’ “kif nibdel l-indirizz tal-email tiegħi”, żewġ mistoqsijiet distinti li jidhru simili ħafna.
Pipeline tad-Deduplikazzjoni
L-iskoperta ta’ pari mhix biżżejjed biex tnaddaf korp ta’ testi. Jekk A jixbah lil B u B jixbah lil C, it-tlieta jappartjenu għall-istess grupp, anke jekk A u C qatt ma tqabblu direttament fuq il-limitu. Il-gruppjar transitiv huwa x-xogħol reali, u l-istruttura Union-Find tittrattah f’daqqa waħda: kull par skopert jgħaqqad żewġ settijiet, u jipproduċi gruppi ta’ duplikati ffurmati kompletament fl-aħħar.
Għadek trid tagħżel liema membru jibqa’ ħaj. Ir-regola użata hawn—hekk l-iqsar test—taħdem tajjeb għal mistoqsijiet ta’ appoġġ, fejn il-formulazzjoni l-aktar konċiża spiss hija l-aktar kanonika. Għal korp ta’ dokumenti, x’aktarx li trid l-oppost, jew l-aktar riċenti: din hija deċiżjoni tan-negozju, mhux dettall tekniku. Id-dizzjunarju rritornat iżomm il-lista ta’ testi mħassra biex bniedem ikun jista’ jivverifika l-każijiet marġinali qabel ma japprovahom.
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']}")
Meta tiġi applikata qabel indiċi RAG, din id-deduplikazzjoni għandha effett dirett fuq il-kwalità: tipprevjeni li l-ħames riżultati rritornati għal mistoqsija jkunu ħames verżjonijiet tal-istess passagg, li kieku jċaħħad il-ġeneratur minn kwalunkwe informazzjoni addizzjonali.
Punti Ewlenin
- Id-distanza miċ-ċentrojde jew k-NN tiskopri testi anormali
- Is-similarità tal-kosinu fuq limitu tidentifika d-duplikati
- Union-Find tiggruppa b’mod effiċjenti d-duplikati transitivi
- Ikkalibra l-limiti fuq id-data tiegħek (tipikament 0.85–0.95 għad-duplikati)