Sagatavo datus
Šajā lapā
RAG kvalitāte ir atkarīga no taviem datiem
RAG konveijers ir tikpat labs, cik dati, ko tas indeksē. Tu vari izveidot ideālu uzvedni un izvēlēties labāko ģenerēšanas modeli, taču, ja izgūtā daļa pārgriež definīciju uz pusēm vai iekļauj atkārtojošu kājeni lietderīga teksta vietā, tava atbilde būs nekvalitatīva. Sagatavošana notiek trīs posmos: iegūst datus no to atrašanās vietas, izsvītro visu bezjēdzīgo un sadala tos fragmentos, kas optimizēti indeksēšanai.
Datu iegūšana
Reālas pasaules korpusi reti ir viendabīgi. Parasti tev būs Markdown dokumentācija repozitorijā, dažas lapas no publiskas vietnes un nedaudz normatīvo PDF failu. Katram avotam ir nepieciešams savs ielādētājs, taču visiem ir jāražo viena un tā pati struktūra — saturs, avots un tips —, lai pārējā konveijera daļa paliktu neatkarīga no teksta izcelsmes.
Teksta failiem pietiek ar rekursīvu direktoriju apgājienu, un filtrēšana pēc paplašinājuma novērš nejaušu bināro failu ielādi.
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")
Tīmekļa lapas tiek saņemtas, izmantojot HTTP, taču tas, ko tu iegūsti, ir HTML. Tālāk redzamā ekstrakcija noņem tagus, izmantojot regulārās izteiksmes, un sapludina vairākas atstarpes. Prototipam tas ir pietiekami, taču komentārs tev atgādina, ka ražošanas vidē BeautifulSoup tiks galā daudz labāk ar tabulām un ligzdotiem sarakstiem.
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 faili ir pelnījuši īpašu attieksmi. Visa dokumenta sapludināšanas vietā saglabā vienu ierakstu uz lapu un iekodē lapas numuru avotā kā file.pdf#page=12. Kad tavs asistents citēs šo fragmentu, lietotājs precīzi zinās, kur to pārbaudīt.
# 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
Datu attīrīšana
Attīrīšana ir kritiska izgūšanas kvalitātei, jo katrs lieks simbols aizņem vietu fragmentā un piesārņo iegūto vektoru. Tālāk redzamā funkcija ķēdē četras apstrādes darbības: tā noņem vadības simbolus, kas palikuši pāri no formātu konvertēšanas, normalizē jaunu rindu un atstarpu virknes, dzēš PDF failiem raksturīgus lappušu numurēšanas marķierus un aizstāj bezgalīgus URL ar vienkāršu vieturi, lai tie neaizņemtu visu fragmentu.
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"])
Fragmentēšanas stratēģijas
Fragmentēšana ir vissvarīgākais sagatavošanas solis: fragmenta izmērs un metode tieši ietekmē izgūšanas kvalitāti. Pastāv trīs pieejas, sākot no mehāniskām līdz struktūru ņemošām vērā.
Fiksēta izmēra fragmentēšana pārvietojas caur tekstu regulāros griezumos. Tā pilnībā ignorē nozīmi, padarot to piemērotu jebkuram avotam, taču tā bieži pārgriež teikumus uz pusēm. Pārklāšanās daļēji labo šo trūkumu: ar overlap=200 katra fragmenta beigas atkārtojas nākamā sākumā, nodrošinot, ka sadalīta ideja vismaz vienā no abiem gabaliem paliek vesela.
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
Uz rindkopām balstīta fragmentēšana, kas ieteicama dokumentācijai, paļaujas uz teksta dabiskajām robežām. Tā uzkrāj rindkopas, kamēr tās nepārsniedz max_size, un pēc tam atver jaunu fragmentu. Slieksnis min_size novērš vientuļa virsraksta vai izolētas rindas indeksēšanu, kas radītu vektoru bez izmantojama satura.
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
Markdown sadaļu fragmentēšana izmanto informāciju, ko autors jau ir sniedzis: savus virsrakstus. Katra sadaļa kļūst par atsevišķu fragmentu, garantējot, ka jautājums par „autentifikāciju” izgūs visu sadaļu, nevis fragmentu. Sadaļas, kas ir pārāk garas, atgriežas pie rindkopu fragmentēšanas, nodrošinot, ka neviens fragments nepārsniedz 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
Pilns sagatavošanas konveijers
Visbeidzot, sasaisti trīs darbības kopā un izvēlies fragmentēšanas stratēģiju, pamatojoties uz faila tipu: .md faili iziet cauri sadaļām, viss pārējais — cauri rindkopām. Katrs fragments tad nes savu metadatus — avotu, pozīciju dokumentā un kopējo fragmentu skaitu no šī dokumenta. Bez tā tu nevarēsi izsekot atbildes avotam. Pēdējās divas rindas parāda izvēršanās koeficientu un vidējo izmēru: ja šis vidējais rādītājs krītas ievērojami zem tava chunk_size, dokuments ir vairāk sadrumstalots, nekā gaidīts, un tev ir jāpārskata sava fragmentēšanas stratēģija.
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")
Galvenās atziņas
- RAG kvalitāte ir tieši atkarīga no datu kvalitātes un fragmentēšanas stratēģijas
- Attīri datus pirms indeksēšanas (noņem liekos simbolus, garos URL, dublikātus)
- Fragmentēšana pa rindkopām vai Markdown sadaļām saglabā semantisko sakarību
- 10–15% pārklāšanās starp fragmentiem novērš ideju sadalīšanu
- Saglabā metadatus (avots, lapa, pozīcija), lai nodrošinātu atbilžu izsekojamību