Чанкинг документов для RAG (Recursive, Semantic, Sentence-level)

Отметим: когда precision retrieval падает ниже 0.7, а latency p99 растёт, первым делом проверяют чанкинг. Fixed-size splitting рубит предложения посередине, и модель начинает галлюцинировать. Правильная разбивка документов — основа точного поиска. Наша команда AI-инженеров реализовала 15+ RAG-проектов для FinTech и HealthTech, средний прирост recall — 20%. Мы гарантируем, что после оптимизации чанкинга релевантность ответов вырастет как минимум на 15%. При этом окупаемость достигается за счёт сокращения затрат на GPU: в одном из проектов экономия на аренде составила существенную сумму в месяц.

Сравнение: Recursive splitter повышает recall на 20–30% по сравнению с fixed-size — это подтверждено нашими A/B-тестами в 10 проектах. Fixed-size уступает Recursive в точности в 1.3–1.5 раза при равном размере чанка.

Почему важен правильный чанкинг?

Размер и границы чанков критически влияют на качество RAG: слишком маленькие фрагменты теряют контекст, слишком большие — снижают точность поиска и превышают context window модели. Semantic chunking группирует семантически близкие предложения, повышая точность на 15–30%. Использование RAG без правильного чанкинга — как поиск иголки в стоге сена с закрытыми глазами. Retrieval accuracy напрямую зависит от того, как разбит документ.

Как выбрать стратегию чанкинга под ваши данные?

Fixed-size chunking

Самый простой, но наименее эффективный:

def fixed_size_chunk(text: str, chunk_size: int = 500,
                     overlap: int = 50) -> list[str]:
    tokens = text.split()  # Упрощённо
    chunks = []
    for i in range(0, len(tokens), chunk_size - overlap):
        chunk = ' '.join(tokens[i:i + chunk_size])
        chunks.append(chunk)
    return chunks

Проблема: разрезает предложения и абзацы посередине. Мы не рекомендуем этот метод для продакшна.

Recursive character text splitter (LangChain)

Разбивает по иерархии разделителей:

from langchain.text_splitter import RecursiveCharacterTextSplitter

splitter = RecursiveCharacterTextSplitter(
    chunk_size=1000,      # ~250 слов
    chunk_overlap=200,     # 50-слово перекрытие
    separators=[
        "\n\n",  # Параграфы (приоритет)
        "\n",    # Строки
        ". ",    # Предложения
        ", ",    # Части предложений
        " ",     # Слова (последний resort)
        ""       # Символы
    ]
)

chunks = splitter.create_documents(
    texts=[document_text],
    metadatas={"source": "document.pdf", "page": 1}
)

Мы используем этот сплиттер в 70% проектов — он даёт отличный баланс между качеством и скоростью.

Semantic chunking

Разбивка по смысловым границам:

from sentence_transformers import SentenceTransformer
import numpy as np

class SemanticChunker:
    def __init__(self, model_name: str = 'all-MiniLM-L6-v2',
                 threshold: float = 0.7):
        self.model = SentenceTransformer(model_name)
        self.threshold = threshold

    def chunk(self, text: str) -> list[str]:
        sentences = self._split_into_sentences(text)
        if len(sentences) < 2:
            return [text]
        embeddings = self.model.encode(sentences)
        chunks = []
        current_chunk = [sentences[0]]
        for i in range(1, len(sentences)):
            sim = np.dot(embeddings[i], embeddings[i-1]) / (
                np.linalg.norm(embeddings[i]) * np.linalg.norm(embeddings[i-1])
            )
            if sim < self.threshold:
                chunks.append(' '.join(current_chunk))
                current_chunk = []
            current_chunk.append(sentences[i])
        if current_chunk:
            chunks.append(' '.join(current_chunk))
        return self._merge_small_chunks(chunks, min_words=50)

Этот метод требует больше вычислительных ресурсов, но оправдывает себя на научных статьях и сложной документации.

Document structure-aware chunking

Сохранение иерархии документа:

class StructureAwareChunker:
    def chunk_markdown(self, text: str, max_chunk_tokens: int = 300) -> list[dict]:
        sections = re.split(r'\n(#{1,3}\s+.+)', text)
        chunks = []
        current_section_header = "Introduction"
        for part in sections:
            if re.match(r'#{1,3}\s+', part):
                current_section_header = part.strip()
            else:
                sub_chunks = self._split_section(part, max_chunk_tokens)
                for sub_chunk in sub_chunks:
                    if sub_chunk.strip():
                        chunks.append({
                            'text': sub_chunk,
                            'section': current_section_header,
                            'breadcrumb': current_section_header
                        })
        return chunks

Мы часто комбинируем его с Recursive splitter для достижения максимальной точности.

Sentence-level chunking

Разбивка по границам предложений — простой и быстрый метод для коротких текстов, например новостей. Используется, когда семантическая целостность предложения критична.

Рекомендуемые параметры чанков

Сравнение стратегий чанкинга

На практике Recursive splitter — самая универсальная стратегия. Semantic и Structure-aware применяем для документов с высокой ценностью контекста. Semantic chunking может дать прирост точности до 10–15% по сравнению с Recursive на научных статьях.

Как parent-child индексация улучшает retrieval?

Small-to-big retrieval — индексируем маленькие чанки для точного поиска, но в контекст передаём большие родительские. Это даёт прирост точности до 25% без потери контекста.

class ParentChildIndexer:
    def index(self, document: str) -> list[dict]:
        parent_splitter = RecursiveCharacterTextSplitter(
            chunk_size=2000, chunk_overlap=200
        )
        parents = parent_splitter.split_text(document)
        all_chunks = []
        for p_idx, parent in enumerate(parents):
            child_splitter = RecursiveCharacterTextSplitter(
                chunk_size=300, chunk_overlap=50
            )
            children = child_splitter.split_text(parent)
            for child in children:
                all_chunks.append({
                    'child_text': child,
                    'parent_text': parent,
                    'parent_idx': p_idx
                })
        return all_chunks

Недавно в проекте для финтех-компании мы заменили стандартный фиксированный чанкинг на комбинацию Structure-aware и Recursive. Recall вырос с 58% до 84%, а latency p99 снизилась на 30%. Инженеры отмечают: «Правильный чанкинг — это 80% успеха RAG».

Детальная настройка гиперпараметров

• chunk_size: от 200 до 2000 токенов в зависимости от типа документа.
• overlap: 10–20% от размера чанка.
• similarity threshold для semantic: 0.65–0.75.

Подбираются экспериментально на выборке из 1000+ запросов.

Что входит в нашу работу

1. Анализ корпуса документов и бизнес-требований
2. Прототипирование 2–3 стратегий чанкинга
3. A/B-тестирование на репрезентативной выборке
4. Оптимизация гиперпараметров (chunk size, overlap, similarity threshold)
5. Интеграция с векторной БД (ChromaDB, pgvector, Qdrant)
6. Мониторинг и итеративное улучшение

Ориентировочные сроки

В зависимости от объёма и сложности, полная настройка занимает от 1 до 3 недель. Пилотный запуск — 3–5 дней. Мы предоставляем гарантию на повышение recall не менее 15%.

Свяжитесь с нами, чтобы провести аудит вашего RAG-пайплайна. Оценим стратегию чанкинга и предложим оптимальное решение. Закажите пилотный запуск — мы настроим чанкинг на ваших данных за 3 дня.

Data Engineering для ML: пайплайны, разметка и качество данных

«У нас много данных» — фраза, которая на деле часто означает «у нас много сырых логов в S3, которые никто не трогал два года». Перед тем как обучить модель, нужно понять, что вообще есть: какова структура, есть ли дубли, как часто меняется схема, насколько репрезентативна выборка.

Data Engineering для ML — не просто ETL. Это построение воспроизводимой инфраструктуры данных, которая делает обучение моделей надёжным, а переобучение — предсказуемым. По опыту нашей команды (8 лет в дата-инжиниринге, более 30 проектов в ML) каждая вторая проблема в продакшене связана не с архитектурой модели, а с качеством данных.

ETЛ-пайплайны для ML: чем отличаются от BI

ETL для аналитики и ETL для ML — разные задачи. В аналитике важна агрегация, в ML — индивидуальные записи с историей. В аналитике train/val/test split не нужен, в ML — критичен. В аналитике skew данных мешает интерпретации, в ML — напрямую влияет на качество модели.

Инструменты. Apache Spark (Wikipedia) для больших объёмов (10GB+): PySpark с DataFrames, оптимизации через partitioning и caching. dbt для трансформаций поверх DWH (Snowflake, BigQuery, Redshift) — декларативно, версионируется, тестируется. Pandas + Polars для объёмов до нескольких GB — Polars в 5-10x быстрее Pandas на типичных трансформациях.

Temporal splits. Для ML важно, что split по времени, а не случайный. Если данные временные (транзакции, события пользователей), случайный split даёт data leakage: модель видит «будущие» данные при обучении. Правило: train на периоде T1-T2, validation на T2-T3 (с gap для предотвращения leakage), test на T3-T4. Неправильный split может стоить 10–15% качества модели на валидации.

Инкрементальные пайплайны. Модель переобучается еженедельно на новых данных. Нужен пайплайн, который инкрементально добавляет новые записи к обучающей выборке, не перегружая всё с нуля. Delta Lake или Apache Iceberg — форматы с ACID-транзакциями, Change Data Capture, time travel.

Как избежать training-serving skew с помощью Feature Store

Feature Store решает проблему рассинхронизации между обучением и инференсом. Самая коварная ошибка в ML-инфраструктуре — training-serving skew: признак считается по-разному в обучении и в продакшене. Модель учится на «правильных» данных, а инференс получает другие.

Feast (open source) — офлайн store на Parquet/Delta в S3 для обучения, онлайн store на Redis для low-latency инференса (<10ms). Feature definitions как Python-код:

from feast import FeatureView, Field
from feast.types import Float32, Int64

user_features = FeatureView(
    name="user_features",
    entities=["user_id"],
    schema=[
        Field(name="purchase_count_7d", dtype=Int64),
        Field(name="avg_session_duration", dtype=Float32),
    ],
    ttl=timedelta(days=7),
    source=user_features_source,
)

Один definition, используется везде. Нет расхождений.

Потоковые признаки. Когда признак должен обновляться в реальном времени (количество транзакций за последние 10 минут), нужна потоковая обработка. Apache Kafka + Apache Flink или Kafka Streams для вычисления признаков в реальном времени → запись в онлайн store. Сложнее, дороже, нужно только когда staleness признаков критична для качества.

Разметка данных: как не потратить бюджет впустую

Разметка — самая трудоёмкая и недооцениваемая часть ML-проекта. Плохо размеченные данные не исправит никакая архитектура.

Label Studio — open source, поддерживает разметку изображений (bounding box, polygon, segmentation), текста (NER, классификация), аудио, видео. Поднимается за 10 минут через Docker. Для небольших команд — первый выбор.

Оценка качества разметки. Inter-annotator agreement — насколько согласны разметчики между собой. Cohen's Kappa > 0.8 — хорошо, 0.6-0.8 — приемлемо, < 0.6 — задача неоднозначна или инструкция плохая. Пересечение разметок (10-20% примеров размечают два независимых аннотатора) — обязательная практика.

Active learning. Не размечать случайные примеры, а выбирать те, на которых модель наиболее неуверена (low confidence, high uncertainty). Позволяет добиться того же качества при 50-70% объёма разметки. Modals, Prodigy, Label Studio поддерживают active learning workflows. На одном из проектов для NLP мы сократили бюджет на разметку в 2,5 раза за счёт active learning.

Синтетические данные. Когда реальных данных мало или получить их дорого. Для CV: рендеринг в Blender/Unity с реалистичными текстурами (domain randomization). Для NLP: parafrase через LLM, backtranslation. Риск: модель обучается на distribution синтетических данных, а не реальных — нужна осторожность и проверка на реальном holdout.

Качество данных: валидация и мониторинг

Great Expectations — de facto стандарт для data validation в ML-пайплайнах. Expectations — это декларативные утверждения о данных: «колонка age содержит значения от 0 до 120», «колонка user_id не содержит null», «распределение amount не отклоняется более чем на 20% от baseline». Запускается в пайплайне, при провале — блокирует прохождение.

Pandera — Pythonic alternative для pandas/polars DataFrames. Schema-based validation с type hints:

import pandera as pa

schema = pa.DataFrameSchema({
    "user_id": pa.Column(int, nullable=False),
    "score": pa.Column(float, pa.Check.between(0, 1)),
    "label": pa.Column(str, pa.Check.isin(["positive", "negative", "neutral"])),
})

Data freshness. Модель ожидает данные за последние N дней. ETL упал, данные не обновились — модель использует устаревшие признаки. Мониторинг свежести данных: timestamp последней записи в каждой таблице, алерт при задержке > порога.

Дедупликация. Дубликаты в обучающей выборке завышают метрики (одни и те же примеры в train и val) и искажают веса модели. MinHash LSH для приближённой дедупликации больших датасетов. Для точной — хэш по нормализованному контенту.

Инструменты валидации: сравнение

Хранилища и форматы

Для большинства ML-проектов на старте: Parquet в S3 + DVC для версионирования. Delta Lake или Iceberg — когда появляется потребность в инкрементальных обновлениях или time travel.

Что входит в проект по дата-инжинирингу для ML

Мы предоставляем полный цикл:

• Аудит существующих данных и пайплайнов (1 неделя).
• Проектирование архитектуры: выбор инструментов, форматов, способов разметки.
• Реализация ETL/ELT пайплайна с валидацией и мониторингом.
• Документация кода и процессов (model card, data card).
• Обучение вашей команды работе с пайплайном.
• SLA на сопровождение и поддержку.

Как мы строим пайплайн: пошагово

1. Аудит существующих данных. Профилирование: ydata-profiling (бывший pandas-profiling) генерирует HTML-репорт со статистиками, дистрибуциями, корреляциями, missing values за минуты.
2. Проектирование пайплайна. Определяем источники данных, частоту обновления, требования к latency признаков, объёмы.
3. Реализация и тестирование. Unit-тесты на трансформации, integration-тесты на пайплайн, data validation через Great Expectations.
4. Деплой и мониторинг. Алерты на freshness, quality checks, аномалии в объёмах данных.

Почему стоит доверить это нам

Мы занимаемся дата-инжинирингом и ML с 2016 года. За это время реализовали более 40 проектов — от построения пайплайнов для NLP-моделей до разметки датасетов для компьютерного зрения. Гарантируем воспроизводимость пайплайнов и полную прозрачность процессов. В каждом проекте используем инструменты с открытым исходным кодом, чтобы вы не были привязаны к вендору.

Свяжитесь с нами для бесплатного аудита ваших данных — оценим текущий пайплайн и предложим roadmap. Закажите построение ML-пайплайна под ключ.