Ullmhaigh na Sonraí
Ar an leathanach seo
Braitheann Cáilíocht RAG ar do Chuid Sonraí
Níl píblíne RAG ach chomh maith leis na sonraí a innéacsann sí. Is féidir leat an leid fhoirfe a chruthú agus an tsamhail ghiniúna is fearr a roghnú, ach má ghearrann an blúire a fhaightear sainmhíniú ina dhá leath nó má tharraingíonn sé buntásc athfhillteach isteach in ionad téacs úsáideach, beidh do fhreagairt faoi mhíbhuntáiste. Tarlaíonn an t-ullmhúchán i dtrí chéim: faigh na sonraí san áit a bhfuil siad, bain aon rud gan bhrí, agus roinn iad ina mblúirí atá optamaithe don innéacsú.
Na Sonraí a Fháil
Is annamh a bhíonn corpais sa saol mór aonchineálach. De ghnáth, beidh doiciméadú Markdown i stór, cúpla leathanach ó shuíomh gréasáin poiblí, agus roinnt PDFanna rialála agat. Teastaíonn lódóir ar leith ó gach foinse, ach caithfidh siad go léir an struchtúr céanna a tháirgeadh—ábhar, foinse, agus cineál—ionas go mbeidh an chuid eile den phíblíne neamhspleách ar thionscnamh an téacs.
I gcás comhaid téacs, tá siúlóid athfhillteach treorach leordhóthanach, agus coscaíonn scagadh de réir foirceannadh luchtú comhaid dhénártha de thaisme.
import os
def load_text_files(directory, extensions=(".txt", ".md", ".rst")):
"""Load all text files from a directory."""
documents = []
for root, dirs, files in os.walk(directory):
for f in files:
if any(f.endswith(ext) for ext in extensions):
filepath = os.path.join(root, f)
with open(filepath, "r", encoding="utf-8") as fh:
content = fh.read()
documents.append({
"content": content,
"source": filepath,
"type": "text",
})
return documents
docs = load_text_files("./data/")
print(f"{len(docs)} documents loaded")
Tagann leathanaigh ghréasáin isteach trí HTTP, ach is HTML a fhaigheann tú. Bainíonn an eastóscadh thíos clibeanna ag baint úsáide as slonnrialta agus laghdaíonn sé spásanna iolracha. Tá sé seo leordhóthanach do phrótaitíopa, ach cuimhníonn an nóta go ndéanfaidh BeautifulSoup i bhfad níos fearr le táblaí agus liostanna neadaithe i dtimpeallacht táirgeachta.
import requests
def fetch_web_page(url):
"""Fetch the text content of a web page."""
response = requests.get(url)
response.raise_for_status()
# Basic text extraction (use BeautifulSoup for production)
text = response.text
# Remove HTML tags
import re
text = re.sub(r'<[^>]+>', ' ', text)
text = re.sub(r'\s+', ' ', text).strip()
return {
"content": text,
"source": url,
"type": "web",
}
# Example
page = fetch_web_page("https://raw.githubusercontent.com/run-llama/llama_index/main/docs/docs/examples/data/paul_graham/paul_graham_essay.txt")
print(f"Content: {len(page['content'])} characters")
Tuilleann PDFanna cóireáil speisialta. In ionad an doiciméad iomlán a chumasc, coinnigh iontráil amháin in aghaidh an leathanaigh agus ionchódaigh uimhir an leathanaigh sa fhoinse mar file.pdf#page=12. Nuair a luaíonn do chúntóir an pasáiste seo, beidh a fhios ag an úsáideoir go díreach cá háit le fíorú a dhéanamh air.
# pip install PyPDF2
from PyPDF2 import PdfReader
def load_pdf(filepath):
"""Extract text from a PDF."""
reader = PdfReader(filepath)
pages = []
for i, page in enumerate(reader.pages):
text = page.extract_text()
if text.strip():
pages.append({
"content": text,
"source": f"{filepath}#page={i+1}",
"type": "pdf",
"page": i + 1,
})
return pages
Na Sonraí a Ghlanadh
Tá glanadh ríthábhachtach do cháilíocht an aisghabhála toisc go n-itheann gach carachtar eachtrannach spás sa bhlúire agus go gcuireann sé isteach ar an veicteoir a eascraíonn as. Déanann an fheidhm seo a leanas ceithre chóireáil a shlabhrú: bainíonn sí carachtair rialaithe atá fágtha ó thiontuithe formáide, normalaíonn sí seichimh de línte nua agus spásanna, scriosann sí marcóirí leathanaithe atá tipiciúil do PDFanna, agus cuireann sí ionadaitheoir simplí in ionad URLanna gan deireadh ionas nach n-itheann siad blúire iomlán.
import re
def clean_text(text):
"""Clean text for RAG indexing."""
# Remove control characters
text = re.sub(r'[\x00-\x08\x0b\x0c\x0e-\x1f\x7f]', '', text)
# Normalize spaces and newlines
text = re.sub(r'\n{3,}', '\n\n', text)
text = re.sub(r' {2,}', ' ', text)
# Remove repetitive headers/footers (PDF)
text = re.sub(r'Page \d+ of \d+', '', text)
# Remove very long URLs
text = re.sub(r'https?://\S{100,}', '[URL]', text)
return text.strip()
# Apply cleaning
for doc in docs:
doc["content"] = clean_text(doc["content"])
Straitéisí Blúireachta
Is é an blúireacht an chéim is tábhachtaí san ullmhúchán: bíonn tionchar díreach ag méid agus modh na blúireachta ar cháilíocht an aisghabhála. Tá trí chur chuige ann, ó mheicniúil go dtí struchtúr-chomhfhiosach.
Bogann blúireacht de mhéid seasta tríd an téacs i slisní rialta. Déanann sí neamhaird ar bhrí go hiomlán, rud a fhágann go bhfuil sí infheidhme ar aon fhoinse, ach go minic gearrann sí abairtí ina dhá leath. Ceartaíonn forluí an locht seo go páirteach: le overlap=200, déantar deireadh gach blúire a athrá ag tús an chinn eile, ag cinntiú go bhfanann smaoineamh scoilte slán in ceann amháin ar a laghad den dá phíosa.
def chunk_fixed_size(text, chunk_size=2048, overlap=200):
"""Fixed-size chunking with overlap."""
chunks = []
start = 0
while start < len(text):
end = min(start + chunk_size, len(text))
chunk = text[start:end]
if chunk.strip():
chunks.append(chunk.strip())
start += chunk_size - overlap
return chunks
Braitheann blúireacht bunaithe ar mhíreanna, a mholtar do dhoiciméadú, ar theorainneacha nádúrtha an téacs ina ionad sin. Carnann sí míreanna fad is a fhanann siad faoi max_size, ansin osclaíonn sí blúire nua. Coscaíonn an tairseach min_size innéacsú ceanntáisc díthreabhaithe nó líne aonair, rud a chruthódh veicteoir gan ábhar inúsáidte.
def chunk_by_paragraphs(text, max_size=1500, min_size=100):
"""Intelligent paragraph-based chunking."""
paragraphs = text.split("\n\n")
chunks = []
current = ""
for para in paragraphs:
para = para.strip()
if not para:
continue
if len(current) + len(para) + 2 <= max_size:
current = current + "\n\n" + para if current else para
else:
if len(current) >= min_size:
chunks.append(current)
current = para
if current and len(current) >= min_size:
chunks.append(current)
return chunks
Baineann blúireacht rannán Markdown leas as an eolas a thug an t-údar cheana féin: a gceanntáisc. Déantar blúire neamhspleách de gach rannán, ag ráthú go n-aisghabhfaidh ceist faoi “fíordheimhniú” an rannán iomlán seachas blúire. Téann rannáin atá ró-fhada ar ais chuig blúireacht mhíreanna, ag cinntiú nach sáraíonn aon bhlúire an teorainn.
def chunk_by_markdown_sections(text, max_size=2000):
"""Chunking by Markdown headings (## and ###)."""
sections = re.split(r'\n(?=##\s)', text)
chunks = []
for section in sections:
section = section.strip()
if not section:
continue
if len(section) <= max_size:
chunks.append(section)
else:
# Sub-chunk overly long sections
sub_chunks = chunk_by_paragraphs(section, max_size=max_size)
chunks.extend(sub_chunks)
return chunks
Píblíne Ullmhúcháin Iomlán
Ar deireadh, slabhraigh na trí oibríocht le chéile agus roghnaigh an straitéis blúireachta bunaithe ar chineál an chomhaid: téann comhaid .md trí rannáin, agus téann gach rud eile trí mhíreanna. Iompraíonn gach blúire a chuid meiteashonraí ansin—foinse, suíomh sa doiciméad, agus líon iomlán na mblúirí ón doiciméad sin. Gan é seo, ní bheidh tú in ann foinse a chur le freagairt. Taispeánann an dá líne dheireanacha an ráta leathnaithe agus an meánmhéid: má thiteann an meán seo i bhfad faoi do chunk_size, tá an doiciméad níos ilroinnte ná mar a bhíothas ag súil leis, agus ní mór duit do straitéis blúireachta a athbhreithniú.
def prepare_documents(raw_docs, chunk_size=1500, overlap=200):
"""Complete pipeline: clean, chunk, enrich with metadata."""
all_chunks = []
for doc in raw_docs:
# 1. Clean
clean = clean_text(doc["content"])
# 2. Chunk based on type
if doc.get("source", "").endswith(".md"):
chunks = chunk_by_markdown_sections(clean, max_size=chunk_size)
else:
chunks = chunk_by_paragraphs(clean, max_size=chunk_size)
# 3. Enrich with metadata
for i, chunk in enumerate(chunks):
all_chunks.append({
"text": chunk,
"source": doc["source"],
"chunk_index": i,
"total_chunks": len(chunks),
})
return all_chunks
# Execution
chunks = prepare_documents(docs)
print(f"{len(docs)} documents -> {len(chunks)} chunks")
print(f"Average size: {sum(len(c['text']) for c in chunks) / len(chunks):.0f} characters")
Príomhphointí
- Braitheann cáilíocht RAG go díreach ar cháilíocht na sonraí agus ar an straitéis blúireachta
- Glan na sonraí sula ndéantar iad a innéacsú (bain carachtair eachtrannacha, URLanna fada, dúbailtí)
- Coimeádann blúireacht mhíreanna nó rannán Markdown comhleanúnachas shéimeantach
- Coscaíonn forluí 10–15% idir blúirí scoilt smaoineamh
- Coinnigh meiteashonraí (foinse, leathanach, suíomh) chun inrianaitheacht na freagartha a chinntiú