Andmete ettevalmistamine
Sellel lehel
RAG-i kvaliteet sõltub sinu andmetest
RAG-i torustik on ainult nii hea, kui head on selle indekseeritavad andmed. Sa võid koostada täiusliku vihje (prompt) ja valida parima genereerimismudeli, kuid kui hangitud tekstilõik jätab definitsiooni pooleli või toob kasuliku teksti asemel kaasa korduva jaluse, kannatab sinu vastus. Ettevalmistus koosneb kolmest etapist: too andmed nende asukohast, eemalda kõik tähendusetu ja jaga need indekseerimiseks optimeeritud tükkideks.
Andmete hankimine
Reaalsed tekstikogumid on harva homogeensed. Tavaliselt on sul repositooriumis Markdown-dokumentatsioon, mõned lehed avalikust veebisaidist ja peotäis regulatiivseid PDF-faile. Iga allikas vajab oma laadijat, kuid kõik peavad tootma sama struktuuri – sisu, allikas ja tüüp –, et ülejäänud torustik jääks teksti päritolu suhtes sõltumatuks.
Tekstifailide puhul piisab rekursiivsest kataloogis läbikäimisest ja laiendi järgi filtreerimisest, et vältida juhuslikult binaarfailide laadimist.
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")
Veebilehed saadetakse üle HTTP protokolli, kuid see, mida saad, on HTML. Allpool toodud ekstraheerimine eemaldab sildid regulaaravaldiste abil ja koondab mitmiktühikud. Prototüübi jaoks piisab sellest, kuid kommentaar tuletab meelde, et tootmises teeb BeautifulSoup tabelite ja pesastatud loenditega palju paremat tööd.
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")
PDF-failid väärivad erikohtlemist. Kogu dokumendi liitmise asemel hoia iga lehe kohta üks kirje ja kodeeri lehenumber allikasse kujul file.pdf#page=12. Kui sinu assistent viitab sellele lõigule, teab kasutaja täpselt, kust seda kontrollida.
# 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
Andmete puhastamine
Puhastamine on otsingu kvaliteedi jaoks kriitiline, sest iga võõras märk tarbib tüki ruumi ja hägustab tulemusvektorit. Järgnev funktsioon aheldab neli töötlust: see eemaldab vormingu teisendustest jäänud juhtmärgid, normaliseerib rea- ja tühikujärjestusi, kustutab PDF-idele tüüpilised leheküljemärgistused ja asendab lõputud URL-id lihtsa kohahoidjaga, et need ei neelaks tervet tükki.
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"])
Tükkideks jagamise strateegiad
Tükkideks jagamine on ettevalmistuse kõige olulisem samm: tüki suurus ja meetod mõjutavad otsingu kvaliteeti otseselt. Eksisteerib kolm lähenemist, alates mehaanilisest kuni struktuuri arvestavani.
Fikseeritud suurusega tükkideks jagamine liigub tekstis regulaarsete lõikude kaupa. See eirab tähendust täielikult, muutes selle kohaldatavaks igale allikale, kuid sageli lõikab see laused pooleli. Ülekate (overlap) parandab seda viga osaliselt: väärtusega overlap=200 kordub iga tüki lõpp järgmise alguses, tagades, et poolitatud idee jääb vähemalt ühes kahest tükist tervikuks.
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
Lõikudel põhinev tükkideks jagamine, mida soovitatakse dokumentatsiooni jaoks, tugineb teksti loomulikele piiridele. See kogub lõike seni, kuni need jäävad alla max_size, ja avab seejärel uue tüki. Lävi min_size hoiab ära üksiku pealkirja või isoleeritud rea indekseerimise, mis tooks kaasa vektori ilma kasuliku sisuta.
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
Markdowni sektsioonidel põhinev tükkideks jagamine kasutab teavet, mille autor on juba esitanud: nende pealkirju. Iga sektsioon muutub iseseisvaks tükiks, tagades, et küsimus „autentimise“ kohta toob esile kogu sektsiooni, mitte ainult fragmendi. Liiga pikad sektsioonid lähevad üle lõikudel põhinevale jagamisele, tagades, et ükski tükk ei ületa limiiti.
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
Täielik ettevalmistustorustik
Lõpuks ahelda need kolm operatsiooni kokku ja vali tükkideks jagamise strateegia vastavalt failitüübile: .md failid läbivad sektsioonipõhise jagamise, kõik muu läbib lõigupõhise jagamise. Iga tükk kannab seejärel oma metaandmeid – allikas, positsioon dokumendis ja sellest dokumendist pärit tükkide koguarv. Ilma selleta ei saa sa vastust allikastada. Viimased kaks rida kuvavad laienemismäära ja keskmist suurust: kui see keskmine langeb oluliselt alla sinu chunk_size, on dokument oodatust killustatum ja pead oma tükkideks jagamise strateegia üle vaatama.
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")
Peamised punktid
- RAG-i kvaliteet sõltub otseselt andmete kvaliteedist ja tükkideks jagamise strateegiast
- Puhasta andmed enne indekseerimist (eemalda võõrad märgid, pikad URL-id, dublikaadid)
- Lõikudel või Markdowni sektsioonidel põhinev tükkideks jagamine säilitab semantilise sidususe
- 10–15% ülekatet tükkide vahel hoiab ära ideede poolitamise
- Säilita metaandmed (allikas, lehekülg, positsioon) vastuste jälgitavuse tagamiseks