Paruoškite duomenis
Šiame puslapyje
RAG kokybė priklauso nuo jūsų duomenų
RAG sistema yra tokia gera, kokie yra jos indeksuojami duomenys. Galite sukurti tobulą užklausą (prompt) ir pasirinkti geriausią generavimo modelį, tačiau jei gautas teksto fragmentas nutraukia apibrėžimą pusiaujyje arba įtraukia pasikartojančią poraštę vietoj naudingo teksto, jūsų atsakymas bus prastas. Paruošimas vyksta trimis etapais: duomenų gavimas iš jų šaltinių, beprasmės informacijos pašalinimas ir skaidymas į indeksavimui optimizuotus fragmentus.
Duomenų gavimas
Realūs tekstynai retai būna vienalyčiai. Paprastai turite Markdown dokumentaciją saugykloje, kelis puslapius iš viešos svetainės ir keletą norminių PDF failų. Kiekvienam šaltiniui reikia savo įkeltuvo (loader), tačiau visi jie turi grąžinti tą pačią struktūrą – turinį, šaltinį ir tipą, kad likusi sistemos dalis būtų nepriklausoma nuo teksto kilmės.
Tekstiniams failams pakanka rekursyviai apeiti katalogus, o filtravimas pagal plėtinį apsaugo nuo atsitiktinio binarinių failų įkėlimo.
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")
Tinklalapiai pasiekiami per HTTP, tačiau gaunate HTML kodą. Toliau pateiktas ištraukimas pašalina žymas naudodamas reguliariuosius reiškinius ir suglaudina daugybę tarpų. Prototipui to pakanka, tačiau komentaras primena, kad gamybinėje aplinkoje „BeautifulSoup“ daug geriau tvarkysis su lentelėmis ir įdėtiniais sąrašais.
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 failai nusipelno ypatingo dėmesio. Vietoj to, kad sujungtumėte visą dokumentą, sukurkite vieną įrašą kiekvienam puslapiui ir į šaltinį įtraukite puslapio numerį formatu file.pdf#page=12. Kai jūsų asistentas cituos šią ištrauką, vartotojas tiksliai žinos, kur ją patikrinti.
# 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
Duomenų valymas
Valymas yra kritiškai svarbus paieškos kokybei, nes kiekvienas pašalinis simbolis eikvoja vietą fragmente ir teršia gaunamą vektorių. Toliau pateikta funkcija sujungia keturis veiksmus: pašalina valdymo simbolius, likusius po formato konvertavimo, normalizuoja naujų eilučių ir tarpų sekas, ištrina PDF failams būdingus puslapių žymeklius ir pakeičia begalines URL nuorodas paprastu rezervuotu ženklu, kad jos neužimtų viso fragmento.
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"])
Skaidymo strategijos
Skaidymas į fragmentus yra svarbiausias paruošimo etapas: fragmento dydis ir metodas tiesiogiai veikia paieškos kokybę. Egzistuoja trys požiūriai – nuo mechaninio iki struktūrą atsižvelgiančio.
Fiksuoto dydžio skaidymas juda tekstu reguliariais pjūviais. Jis visiškai ignoruoja prasmę, todėl tinka bet kokiam šaltiniui, tačiau dažnai nutraukia sakinius pusiaujyje. Persidengimas iš dalies ištaiso šią klaidą: nustatžius overlap=200, kiekvieno fragmento pabaiga kartojasi kito pradžioje, užtikrinant, kad padalinta mintis bent viename iš dviejų gabalų išliktų vientisa.
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
Skaidymas pagal pastraipas, rekomenduojamas dokumentacijai, remiasi natūraliomis teksto ribomis. Jis kaupia pastraipas, kol jos neviršija max_size, tada atveria naują fragmentą. min_size slenkstis neleidžia indeksuoti vienišų antraščių ar izoliuotų eilučių, kurios sukurtų vektorių be naudingo turinio.
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
Skaidymas pagal Markdown skyrius naudoja autoriaus jau pateiktą informaciją – antraštes. Kiekvienas skyrius tampa savarankišku fragmentu, garantuojant, kad užklausa apie „autentifikavimą“ gaus visą skyrių, o ne jo fragmentą. Per ilgi skyriai grįžta prie skaidymo pastraipomis, užtikrinant, kad joks fragmentas neviršytų ribos.
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
Pilna paruošimo grandinė
Galiausiai sujunkite tris operacijas ir pasirinkite skaidymo strategiją pagal failo tipą: .md failai skaidomi pagal skyrius, visi kiti – pagal pastraipas. Kiekvienas fragmentas tada gauna savo metaduomenis – šaltinį, poziciją dokumente ir bendrą to dokumento fragmentų skaičių. Be to negalėsite nustatyti atsakymo šaltinio. Paskutinės dvi eilutės rodo išplėtimo koeficientą ir vidutinį dydį: jei šis vidurkis gerokai mažesnis už jūsų chunk_size, dokumentas yra labiau suskaidytas nei tikėtasi, ir turite peržiūrėti savo skaidymo strategiją.
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")
Svarbiausi punktai
- RAG kokybė tiesiogiai priklauso nuo duomenų kokybės ir skaidymo strategijos
- Prieš indeksuodami išvalykite duomenis (pašalinkite pašalinius simbolius, ilgas URL nuorodas, dublikatus)
- Skaidymas pagal pastraipas arba Markdown skyrius išlaiko semantinį vientisumą
- 10–15 % fragmentų persidengimas neleidžia nutraukti minčių
- Išsaugokite metaduomenis (šaltinį, puslapį, poziciją), kad būtų galima atsekti atsakymų kilmę