Премини към основното съдържание
Български— Изберете език
Меню

Подготовка на данните

Урок 10 от 18 Обновен 29 юли 2026 г. Програмист
На тази страница
  1. Качеството на RAG зависи от Вашите данни
  2. Извличане на данните
  3. Почистване на данните
  4. Стратегии за разделяне на фрагменти (Chunking)
  5. Пълен конвейер за подготовка
  6. Ключови изводи

Качеството на RAG зависи от Вашите данни

Един RAG конвейер е толкова добър, колкото са данните, които индексира. Можете да създадете перфектен промпт и да изберете най-добрия генеративен модел, но ако извлеченият фрагмент прекъсва дефиниция по средата или включва повтарящ се долен колонтитул вместо полезен текст, отговорът Ви ще пострада. Подготовката преминава през три етапа: извличане на данните от мястото, където се намират, премахване на всичко безсмислено и разделяне на оптимизирани за индексиране фрагменти.

Извличане на данните

Реалните корпуси рядко са хомогенни. Обикновено ще разполагате с Markdown документация в хранилище, няколко страници от публичен уебсайт и шепа регулаторни PDF файлове. Всеки източник изисква собствен зареждач, но всички те трябва да произвеждат една и съща структура – съдържание, източник и тип, – за да остане останалата част от конвейера независима от произхода на текста.

За текстови файлове е достатъчно рекурсивно обхождане на директорията, а филтрирането по разширение предотвратява случайното зареждане на двоични файлове.

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

Уеб страниците се доставят чрез HTTP, но това, което получавате, е HTML. Извлечението по-долу премахва таговете, използвайки регулярни изрази, и свива множеството интервали. Това е достатъчно за прототип, но коментарът Ви напомня, че в производствена среда BeautifulSoup ще свърши много по-добра работа с таблици и вложени списъци.

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 файловете заслужават специално отношение. Вместо да конкатенирате целия документ, запазете един запис на страница и кодирайте номера на страницата в източника като file.pdf#page=12. Когато Вашият асистент цитира този пасаж, потребителят ще знае точно къде да го провери.

# 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

Почистване на данните

Почистването е от критично значение за качеството на извличането, тъй като всеки излишен знак консумира място във фрагмента и замъглява получения вектор. Следната функция свързва четири обработки: премахва контролните знаци, останали от конвертирането на формати, нормализира последователностите от нови редове и интервали, изтрива маркерите за страници, типични за PDF файлове, и заменя безкрайните URL адреси с прост заместител, за да не изядат целия фрагмент.

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

Стратегии за разделяне на фрагменти (Chunking)

Разделянето на фрагменти е най-важната стъпка в подготовката: размерът на фрагмента и методът директно влияят върху качеството на извличане. Съществуват три подхода, вариращи от механични до такива, отчитащи структурата.

Разделянето с фиксиран размер преминава през текста в регулярни отрязъци. То напълно игнорира смисъла, което го прави приложимо за всеки източник, но често прекъсва изреченията по средата. Припокриването частично коригира този недостатък: с overlap=200, краят на всеки фрагмент се повтаря в началото на следващия, гарантирайки, че разделена идея остава цяла поне в една от двете части.

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

Разделянето на базата на абзаци, препоръчително за документация, разчита вместо това на естествените граници на текста. То натрупва абзаци, докато остават под max_size, след което отваря нов фрагмент. Прагът min_size предотвратява индексирането на изолирано заглавие или отделен ред, което би произвело вектор без полезно съдържание.

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 секции използва информация, която авторът вече е предоставил: техните заглавия. Всяка секция става самостоятелен фрагмент, гарантирайки, че въпрос относно „автентикация“ ще извлече цялата секция, а не фрагмент от нея. Секциите, които са твърде дълги, се връщат към разделяне по абзаци, осигурявайки, че никой фрагмент не надвишава лимита.

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

Пълен конвейер за подготовка

Накрая, свържете трите операции заедно и изберете стратегията за разделяне въз основа на типа файл: .md файловете преминават през секции, всичко останало – през абзаци. Всеки фрагмент след това носи своите метаданни – източник, позиция в документа и общ брой фрагменти от този документ. Без това няма да можете да проследите източника на отговора. Последните два реда показват коефициента на разширяване и средния размер: ако този среден размер спадне значително под Вашия chunk_size, документът е по-фрагментиран от очакваното и трябва да преразгледате стратегията си за разделяне.

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

Ключови изводи

  • Качеството на RAG зависи директно от качеството на данните и стратегията за разделяне на фрагменти
  • Почиствайте данните преди индексиране (премахване на излишни знаци, дълги URL адреси, дубликати)
  • Разделянето по абзаци или Markdown секции запазва семантичната свързаност
  • Припокриване от 10–15% между фрагментите предотвратява разделянето на идеи
  • Запазвайте метаданни (източник, страница, позиция) за проследимост на отговорите