Braith ar Neamhghnáthachtaí agus ar Dhúblaigh
Ar an leathanach seo
Cuspóirí
- Neamhghnáthachtaí téacs a bhrath laistigh de chorpas
- Dúblaigh shéimeantacha a aithint
- Píblíne dídhúblála a thógáil
Brath ar Neamhghnáthachtaí
Tá an intuición chéanna ag an dá fheidhmchlár sa cheacht seo, ach curtha i bhfeidhm ar fhoircinn urchomhaireacha na scála cosúlachta. Tá téacs “neamhghnách” má tá sé scartha go séimeantach ó gach rud eile sa chorpas; tá téacs ina dhúblach má tá sé ró-ghar. Ligeann leabuithe (embeddings) duit an t-achar seo a thomhas i ngach cás. Is é an chuid is mó den obair ná na tairseacha a chalabrú.
Tógann an chéad cur chuige lárphointe (centroid) an chorpuis—meán gach veicteora, a léiríonn “gnáthábhar an chorpuis seo”—agus tomhaiseann sé cé chomh fada is a imíonn gach téacs uaidh. Ní luach absalóideach é an tairseach d’aon ghnó, ach céatadán: ní féidir leat a fhios roimh ré cé chomh fada is atá neamhghnáthacht, ach tá a fhios agat gur mhaith leat scrúdú a dhéanamh ar an 5% is neamhghnáthaí.
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]}...")
Inseoidh an corpas samplach an scéal duit: cúig shainráiteas faoi bheartas acmhainní daonna agus iarracht insteallta SQL amháin. Ní bheadh aon scagaire eochairfhocal tar éis an t-instealladh a ghabháil gan riail réamhscríofa; brathfaidh an t-achar ón lárphointe é gan aon réamh-mheastachán. Seo an príomhargóint chun an modh a úsáid chun sruth doiciméad isteach a mhonatóireacht.
Tá laige ag an lárphointe, áfach: glacann sé leis go rothlaíonn an corpas timpeall ar ábhar amháin. Má chlúdaíonn do dhoiciméid trí fhearann an-éagsúil, titfidh an pointe meánach isteach i bhfolús séimeantach, agus dealróidh gach téacs chomh cianda céanna. Seachnaíonn an cur chuige k-nearest neighbors (k-NN) é seo trí gach téacs a mheas bunaithe ar a chomharsanacht láithreach seachas an tacar iomlán: fanfaidh doiciméad a bhaineann le grúpa mionlaigh gnáth fad is atá comharsana aige.
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
Brath ar Dhúblaigh Shéimeantacha
Ag foirceann eile na scála tá téacsanna atá ró-ghar. Is féidir le dhá iontráil a bheith ina ndúblaigh fiú le focail éagsúla—“Conas a athshocraím mo phasfhocal?” agus “Pasfhocal dearmadta, cad a dhéanaim?”—níl ach trí fhocal coiteann acu—agus sin díreach an rud nach ngabhfaidh haiseáil nó comparáid teaghráin riamh. Brathfaidh leabuithe iad.
Ríomhann an fheidhm an mhatrís cosúlachta iomlán agus filleann sí gach péire os cionn na tairsí. Bí ar an airdeall maidir leis an gcostas: tá an chomparáid seo cearnach, rud a fhanann tobann do roinnt mílte téacs ach a éiríonn dodhéanta do mhilliún—caithfidh tú innéacs garbh a úsáid ansin cosúil leo siúd a chlúdaítear le bunachair shonraí veicteora.
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']}")
Úsáideann an glao anseo tairseach 0.85 seachas an réamhshocrú 0.90 toisc go mbíonn athfhoirmliúcháin ar an gceist tacaíochta chéanna go minic i bhfad faoi 0.90. Seo an socrú a chaithfidh tú an t-am is mó a chaitheamh ag tiúnadh: má shocraíonn tú ró-ard é, ligfidh tú do dhúblaigh teacht tríd; má shocraíonn tú ró-íseal é, cumascfaidh tú “conas a athraím mo phasfhocal” le “conas a athraím mo sheoladh ríomhphoist”, dhá cheist ar leith atá an-chosúil le chéile.
Píblíne Dídhúblála
Ní leor péirí a bhrath chun corpas a ghlanadh. Má tá A cosúil le B agus má tá B cosúil le C, baineann an triúr leis an ngrúpa céanna, fiú nár comparáideadh A agus C go díreach os cionn na tairsí riamh. Is é an grúpáil thras-tharchurach an obiar iarbhír, agus láimhseálann an struchtúr Union-Find é i bpas amháin: cumaisc gach péire a braitheadh dhá thacar, rud a thugann grúpaí dúblach atá críochnaithe go hiomlán ag an deireadh.
Caithfidh tú fós a roghnú cé an ball a mhaireann. Oibríonn an riail a úsáidtear anseo—an téacs is giorra—go maith do cheisteanna tacaíochta, áit arb é an fhoirmliú is giorra minic an ceann is canónúla. Do chorpas doiciméad, is dócha gur mhaith leat an contrárthacht, nó an ceann is déanaí: is cinneadh gnó é seo, ní mionsonra teicniúil. Coinníonn an foclóir a fhilltear liosta na dtéacsanna a scriosadh ionas gur féidir le duine na cásanna imeallacha a fhíorú sula ndéantar formheas orthu.
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']}")
Nuair a chuirtear an dídhúbláil seo i bhfeidhm os comhair innéacs RAG, bíonn tionchar díreach aici ar cháilíocht: coscaíonn sí nach mbeidh na cúig thoradh a fhilltear do cheist ina gcúig leagan den alt céanna, rud a bhainfeadh aon fhaisnéis bhreise ón ngineadóir.
Príomhphointí
- Brathann an t-achar ón lárphointe nó k-NN téacsanna neamhghnácha
- Aithníonn cosúlacht chomhshínigh os cionn tairsí dúblaigh
- Grúpálann Union-Find dúblaigh thras-tharchuracha go héifeachtúil
- Calabraigh tairseacha ar do chuid sonraí (de ghnáth 0.85–0.95 do dhúblaigh)