Priprava podatkov
Na tej strani
Kakovost RAG je odvisna od tvojih podatkov
Cevovod RAG je dober toliko, kolikor so dobri podatki, ki jih indeksiraš. Lahko sestaviš popoln poziv in izbereš najboljši generativni model, a če pridobljeni delček prereže definicijo na pol ali povleče ponavljajočo se nogo namesto uporabnega besedila, bo tvoj odgovor trpel. Priprava poteka v treh fazah: pridobi podatke tam, kjer se nahajajo, odstrani vse brezvezno in jih razdeli na delčke, optimizirane za indeksiranje.
Pridobivanje podatkov
Zbirke podatkov iz resničnega sveta redko so homogene. Običajno imaš dokumentacijo Markdown v skladišču, nekaj strani z javnega spletnega mesta in peščico regulativnih dokumentov PDF. Vsak vir potrebuje svoj nalagalnik, vendar morajo vsi proizvesti enako strukturo – vsebina, vir in vrsta – da preostali del cevovoda ostane neodvisen od izvora besedila.
Za besedilne datoteke zadostuje rekurzivni sprehod po imeniku, filtriranje po končnicah pa prepreči nenamerno nalaganje binarnih datotek.
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")
Spletne strani prihajajo prek HTTP, vendar dobiš HTML. Spodnji postopek ekstrakcije odstrani oznake z uporabo regularnih izrazov in združi več presledkov. To zadostuje za prototip, vendar te opomnik spominja, da bo v produkcijskem okolju BeautifulSoup veliko bolje opravil delo s tabelami in gnezdenimi seznami.
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")
Datoteke PDF zaslužijo posebno obravnavo. Namesto združevanja celotnega dokumenta ohrani en vnos na stran in kodiraj številko strani v viru kot file.pdf#page=12. Ko tvoj asistent citira ta odlomek, bo uporabnik točno vedel, kje ga preveriti.
# 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
Čiščenje podatkov
Čiščenje je ključnega pomena za kakovost pridobivanja, saj vsak odvečni znak porabi prostor v delčku in onesnaži nastali vektor. Naslednja funkcija veriži štiri obdelave: odstrani nadzorne znake, ki so ostali po pretvorbi formatov, normalizira zaporedja novih vrstic in presledkov, izbriše označevalce strani, značilne za PDF, in nadomesti neskončne URL-je s preprostim nadomestkom, da ne požrejo celotnega delčka.
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"])
Strategije razdeljevanja na delčke
Razdeljevanje na delčke je najpomembnejši korak pri pripravi: velikost delčka in metoda neposredno vplivata na kakovost pridobivanja. Obstajajo trije pristopi, od mehanskih do tistih, ki upoštevajo strukturo.
Razdeljevanje na delčke fiksne velikosti poteka skozi besedilo v rednih kosih. Popolnoma ignorira pomen, zaradi česar je uporabno za kateri koli vir, vendar pogosto prereže stavke na pol. Prekrivanje delno popravi to napako: z overlap=200 se konec vsakega delčka ponovi na začetku naslednjega, kar zagotavlja, da razdeljena ideja ostane celovita vsaj v enem od obeh kosov.
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
Razdeljevanje na podlagi odstavkov, priporočljivo za dokumentacijo, namesto tega uporablja naravne meje besedila. Kopiči odstavke, dokler ostajajo pod max_size, nato odpre nov delček. Prag min_size preprečuje indeksiranje osamljenega naslova ali izolirane vrstice, kar bi proizvedlo vektor brez uporabne vsebine.
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
Razdeljevanje na odseke Markdown izkorišča informacije, ki jih je avtor že zagotovil: njihove naslove. Vsak odsek postane samostojen delček, kar zagotavlja, da vprašanje o „avtentikaciji” pridobi celoten odsek in ne le fragmenta. Odseki, ki so predolgi, se vrnejo na razdeljevanje po odstavkih, kar zagotavlja, da noben delček ne preseže omejitve.
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
Celoten cevovod za pripravo
Na koncu poveži tri operacije skupaj in izberi strategijo razdeljevanja glede na vrsto datoteke: datoteke .md gredo skozi odseke, vse ostalo skozi odstavke. Vsak delček nato nosi svoje metapodatke – vir, položaj v dokumentu in skupno število delčkov iz tega dokumenta. Brez tega ne boš mogel slediti viru odgovora. Zadnji dve vrstici prikažeta stopnjo razširitve in povprečno velikost: če ta povprečje močno pade pod tvoj chunk_size, je dokument bolj razdrobljen, kot si pričakoval, in moraš ponovno pregledati svojo strategijo razdeljevanja.
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")
Ključne ugotovitve
- Kakovost RAG je neposredno odvisna od kakovosti podatkov in strategije razdeljevanja na delčke
- Pred indeksiranjem očisti podatke (odstrani odvečne znake, dolge URL-je, dvojnice)
- Razdeljevanje na odstavke ali odseke Markdown ohranja semantično koherenco
- 10–15 % prekrivanje med delčki preprečuje razdeljevanje idej
- Ohrani metapodatke (vir, stran, položaj) za sledljivost odgovorov