Ipprepara d-Data
F'din il-paġna
Il-Kwalità tar-RAG Tiddependi mid-Data Tiegħek
Pipeline ta’ RAG hija tajba biss daqs id-data li tindiċja. Tista’ tifforma l-prompt perfett u tagħżel l-aħjar mudell ta’ ġenerazzjoni, iżda jekk il-biċċa data rkuprata taqta’ definizzjoni f’nofsha jew tiġbed footer ripetittiv minflok test utli, it-tweġiba tiegħek se tbati. Il-preparazzjoni sseħħ fi tliet stadji: iġbed id-data minn fejn tinsab, neħħi kull ħaġa bla sens, u aqsmiha f’biċċiet (chunks) ottimizzati għall-indiċjar.
Niġbu d-Data
Korpora tad-dinja reali rari huma omoġenji. Tipikament ikollok dokumentazzjoni Markdown f’repożitorju, ftit paġni minn sit web pubbliku, u għadd żgħir ta’ PDFs regolatorji. Kull sors jeħtieġ il-loader tiegħu stess, iżda dawk kollha jridu jipproduċu l-istess struttura—kontenut, sors, u tip—sabiex il-bqija tal-pipeline jibqa’ newtrali għall-oriġini tat-test.
Għal fajls tat-test, mixi rikorsiv fid-direttorju huwa biżżejjed, u l-iffiltrar skont l-estensjoni jipprevjeni li tħaddem fajls binarji bi żball.
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")
Il-paġni web jiġu permezz ta’ HTTP, iżda dak li tikseb huwa HTML. L-estrazzjoni hawn taħt tneħħi t-tags bl-użu ta’ espressjonijiet regolari u tgħaqqad spazji multipli. Dan huwa biżżejjed għal prototip, iżda l-kumment ifakkrek li fil-produzzjoni, BeautifulSoup se tagħmel xogħol ferm aħjar mat-tabelli u l-listi mbejjna.
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")
Il-PDFs jistħoqqilhom trattament speċjali. Minflok tgħaqqad id-dokument kollu, żomm entrata waħda għal kull paġna u kkodifika n-numru tal-paġna fis-sors bħala file.pdf#page=12. Meta l-assistent tiegħek jikkita din il-passaġġ, l-utent ikun jaf eżattament fejn jivverifikaha.
# 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
Tindif tad-Data
It-tindif huwa kritiku għall-kwalità tal-irkupru għax kull karattru stray jikkonsma spazju fil-biċċa data u jħawwad il-vettur li jirriżulta. Il-funzjoni li ġejja tgħaqqad erba’ trattamenti: tneħħi karattri ta’ kontroll li jifdal minn konverżjonijiet ta’ format, tinnormalizza sekwenzi ta’ newlines u spazji, tħassar markaturi ta’ paġnar tipiċi tal-PDFs, u tissostitwixxi URLs bla tmiem b’placeholder sempliċi sabiex ma jikkunsmawx biċċa data sħiħa.
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"])
Strateġiji ta’ Qsim (Chunking)
Il-qsim huwa l-pass l-aktar importanti fil-preparazzjoni: id-daqs tal-biċċa u l-metodu jaffettwaw direttament il-kwalità tal-irkupru. Jeżistu tliet approċċi, li jvarjaw minn mekkaniku għal wieħed li jħares lejn l-istruttura.
Il-qsim b’daqs fiss jimxi mat-test f’qatgħat regolari. Jinjora s-sinifikat kompletament, u jagħmlu applikabbli għal kwalunkwe sors, iżda spiss jaqta’ s-sentenzi f’nofsuhom. Is-sovrappożizzjoni (overlap) tikkoreġi parzjalment dan id-difett: b’overlap=200, it-tmiem ta’ kull biċċa jirrepeti ruħu fil-bidu tal-oħra, u jiżgura li idea maqsuma tibqa’ sħiħa mill-inqas f’waħda miż-żewġ biċċiet.
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
Il-qsim ibbażat fuq il-paragrafi, rakkomandat għad-dokumentazzjoni, jiddependi minflok fuq il-fruntieri naturali tat-test. Jakkumula paragrafi sakemm jibqgħu taħt max_size, imbagħad jiftaħ biċċa ġdida. Il-limitu min_size jipprevjeni l-indiċjar ta’ heading orphan jew linja iżolata, li tipproduċi vettur mingħajr kontenut użabbli.
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
Il-qsim ta’ sezzjonijiet Markdown jisfrutta l-informazzjoni li l-awtur diġà pprovda: l-headings tiegħu. Kull sezzjoni ssir biċċa data awtonoma, li tiggarantixxi li mistoqsija dwar “awtentikazzjoni” tirrikupra s-sezzjoni kollha minflok framment. Sezzjonijiet li huma twal wisq jerġgħu lura għall-qsim tal-paragrafi, u jiżguraw li l-ebda biċċa ma taqbeż il-limitu.
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
Pipeline Sħiħa ta’ Preparazzjoni
Fl-aħħar nett, agħqad it-tliet operazzjonijiet flimkien u agħżel l-istrateġija tal-qsim ibbażata fuq it-tip ta’ fajl: fajls .md jgħaddu mis-sezzjonijiet, kull ħaġa oħra mill-paragrafi. Kull biċċa data mbagħad iġġorr il-metadata tagħha—sors, pożizzjoni fid-dokument, u n-numru totali ta’ biċċiet minn dak id-dokument. Mingħajr dan, ma tkunx tista’ tissorvelja tweġiba. Iż-żewġ linji tal-aħħar juru r-rata ta’ espansjoni u d-daqs medju: jekk dan il-medju jinżel ferm taħt il-chunk_size tiegħek, id-dokument huwa aktar frammentat milli mistenni, u għandek terġa’ tara l-istrateġija tal-qsim tiegħek.
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")
Punti Ewlenin
- Il-kwalità tar-RAG tiddependi direttament fuq il-kwalità tad-data u l-istrateġija tal-qsim
- Naddaf id-data qabel l-indiċjar (neħħi karattri stray, URLs twal, duplikati)
- Il-qsim skont il-paragrafi jew is-sezzjonijiet Markdown jippreserva l-koeżjoni semantika
- Sovrappożizzjoni ta’ 10–15% bejn il-biċċiet tipprevjeni l-qsim tal-ideat
- Żomm il-metadata (sors, paġna, pożizzjoni) għat-traċċabbiltà tat-tweġibiet