Salt la conținutul principal
Română— Alege o limbă
Meniu

Pregătirea datelor

Lecția 10 din 18 Actualizată 29 iulie 2026 Dezvoltator
Pe această pagină
  1. Calitatea RAG depinde de datele dumneavoastră
  2. Preluarea datelor
  3. Curățarea datelor
  4. Strategii de fragmentare (Chunking)
  5. Pipeline complet de pregătire
  6. Puncte cheie

Calitatea RAG depinde de datele dumneavoastră

O pipeline RAG este la fel de bună precum datele pe care le indexează. Puteți crea promptul perfect și să selectați cel mai bun model de generare, dar dacă fragmentul recuperat taie o definiție în două sau include un subsol repetitiv în loc de text util, răspunsul dumneavoastră va avea de suferit. Pregătirea se desfășoară în trei etape: preluarea datelor de la sursă, eliminarea oricărui element fără sens și divizarea lor în fragmente optimizate pentru indexare.

Preluarea datelor

Corpurile de texte din lumea reală sunt rareori omogene. Veți avea, de obicei, documentație Markdown într-un depozit, câteva pagini de pe un site web public și un număr redus de PDF-uri cu reglementări. Fiecare sursă necesită propriul loader, dar toate trebuie să producă aceeași structură—conținut, sursă și tip—astfel încât restul pipeline-ului să rămână independent de originea textului.

Pentru fișierele text, o parcurgere recursivă a directorului este suficientă, iar filtrarea după extensie previne încărcarea accidentală a fișierelor binare.

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")

Paginile web sunt accesate prin HTTP, dar ceea ce obțineți este HTML. Extracția de mai jos elimină tag-urile folosind expresii regulate și colapsează spațiile multiple. Acest lucru este suficient pentru un prototip, dar comentariul vă reamintește că, în producție, BeautifulSoup va face o treabă mult mai bună cu tabelele și listele imbricate.

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-urile merită un tratament special. În loc să concatenați întregul document, păstrați o intrare per pagină și codificați numărul paginii în sursă sub forma file.pdf#page=12. Când asistentul dumneavoastră citează acest pasaj, utilizatorul va ști exact unde să îl verifice.

# 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

Curățarea datelor

Curățarea este critică pentru calitatea recuperării, deoarece fiecare caracter stray consumă spațiu în fragment și tulbură vectorul rezultat. Funcția următoare înlănțuie patru tratamente: elimină caracterele de control rămase de la conversiile de format, normalizează secvențele de newline-uri și spații, șterge markerii de paginare tipici PDF-urilor și înlocuiește URL-urile interminabile cu un placeholder simplu, astfel încât să nu consume un întreg fragment.

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"])

Strategii de fragmentare (Chunking)

Fragmentarea este cel mai important pas în pregătire: dimensiunea fragmentului și metoda aleasă impactează direct calitatea recuperării. Există trei abordări, de la cele mecanice la cele conștiente de structură.

Fragmentarea la dimensiune fixă parcurge textul în felii regulate. Ignoră complet sensul, ceea ce o face aplicabilă oricărei surse, dar deseori taie propozițiile în două. Suprapunerea corectează parțial acest defect: cu overlap=200, sfârșitul fiecărui fragment se repetă la începutul următorului, asigurând că o idee divizată rămâne intactă în cel puțin una dintre cele două piese.

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

Fragmentarea bazată pe paragrafe, recomandată pentru documentație, se bazează în schimb pe limitele naturale ale textului. Acumulează paragrafele atâta timp cât rămân sub max_size, apoi deschide un nou fragment. Pragul min_size previne indexarea unui titlu orfan sau a unei linii izolate, care ar produce un vector fără conținut utilizabil.

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

Fragmentarea pe secțiuni Markdown valorifică informațiile oferite deja de autor: titlurile sale. Fiecare secțiune devine un fragment de sine stătător, garantând că o întrebare despre „autentificare“ va recupera întreaga secțiune, nu un fragment. Secțiunile care sunt prea lungi revin la fragmentarea pe paragrafe, asigurând că niciun fragment nu depășește limita.

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 complet de pregătire

În final, înlănțuiți cele trei operațiuni și alegeți strategia de fragmentare în funcție de tipul fișierului: fișierele .md trec prin secțiuni, restul prin paragrafe. Fiecare fragment poartă apoi metadatele sale—sursă, poziția în document și numărul total de fragmente din acel document. Fără acestea, nu veți putea atribui o sursă răspunsului. Ultimele două linii afișează rata de expansiune și dimensiunea medie: dacă această medie scade mult sub chunk_size-ul dumneavoastră, documentul este mai fragmentat decât se aștepta și trebuie să revizuiți strategia de fragmentare.

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")

Puncte cheie

  • Calitatea RAG depinde direct de calitatea datelor și de strategia de fragmentare
  • Curățați datele înainte de indexare (eliminați caracterele stray, URL-urile lungi, duplicatele)
  • Fragmentarea pe paragrafe sau pe secțiuni Markdown păstrează coerența semantică
  • O suprapunere de 10–15% între fragmente previne divizarea ideilor
  • Păstrați metadatele (sursă, pagină, poziție) pentru trasabilitatea răspunsurilor