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

Пакетиране и разделяне на части

Урок 4 от 18 Обновен 2 ноември 2026 г. Програмист
На тази страница
  1. Предизвикателството при големи обеми
  2. Пакетиране: Обработка на групи
  3. Разделяне на части: Разцепване на текста
  4. Припокриване
  5. Пълен конвейер: Разделяне + Пакетиране + Вграждане
  6. Ключови изводи

Предизвикателството при големи обеми

Когато работите с хиляди документи, не можете да кодирате всичко в едно единствено API обаждане. Трябва да управлявате пакетирането (обработка на групи) и разделянето на части (разцепване на текста). Тези две техники са от съществено значение за изграждането на системи за семантично търсене в мащаб.

Двете концепции звучат подобно, но решават противоположни проблеми. Разделянето на части се занимава с един документ, който е твърде голям, за да бъде кодиран ефективно като цяло; пакетирането се занимава с твърде много документи, които не се събират в една заявка. Техническо ръководство от триста страници попада в първата категория, експорт от двадесет хиляди билета – във втората, а реален проект почти винаги включва и двете.

Пакетиране: Обработка на групи

API на mistral-embed приема списък с входни данни, но съществуват практически ограничения (размер на заявката, брой токени). Решението е да разделите вашия корпус на пакети и да ги обработвате в цикъл. Функцията по-долу прави точно това, показвайки прогреса – критичен детайл, когато кодирането на пълен корпус отнема няколко минути и трябва да знаете дали процесът напредва или е заседнал.

import numpy as np
from mistralai.client import Mistral

client = Mistral(api_key=api_key)

def get_embeddings_by_chunks(data, chunk_size=25):
    """Encode a large list of texts in batches."""
    chunks = [data[x:x + chunk_size] for x in range(0, len(data), chunk_size)]
    embeddings = []

    for i, chunk in enumerate(chunks):
        print(f"Batch {i+1}/{len(chunks)} ({len(chunk)} texts)...")
        response = client.embeddings.create(
            model="mistral-embed",
            inputs=chunk,
        )
        embeddings.extend([d.embedding for d in response.data])

    return embeddings

# Example with 1000 documents
documents = [f"Document number {i} with varied content." for i in range(1000)]
all_embeddings = get_embeddings_by_chunks(documents, chunk_size=50)

print(f"Total: {len(all_embeddings)} embeddings of {len(all_embeddings[0])} dimensions")

Използването на extend вместо append гарантира, че редът на векторите съвпада точно с реда на входния текст. Това Ви позволява по-късно да извлечете оригиналния документ чрез прост индекс.

Оптимизиране на размера на пакета

Оптималният размер на пакета зависи от средната дължина на Вашите текстове: петдесет заглавия на статии и петдесет пълни доклада не тежат еднакво в токени. Вместо да избирате константа на случаен принцип, оценете я въз основа на самия корпус.

def optimal_batch_size(documents, max_tokens_per_batch=16000):
    """Estimate the optimal batch size."""
    # Rough estimate: 1 token ~ 4 characters in English
    avg_chars = sum(len(d) for d in documents) / len(documents)
    avg_tokens = avg_chars / 4

    batch_size = max(1, int(max_tokens_per_batch / avg_tokens))
    return min(batch_size, 100)  # Cap at 100

# Adjust based on your corpus
batch_size = optimal_batch_size(documents)
print(f"Recommended batch size: {batch_size}")

Ограничението до 100 не е козметично: отвъд тази граница един неуспешен пакет причинява значителна загуба на работа, а паметта, консумирана от отговора, става съществена.

Разделяне на части: Разцепване на текста

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

Разделяне базирано на символи (Просто)

Най-директният метод отрязва всеки N символа, независимо от съдържанието. Неговото предимство е предвидимостта и скоростта, което го прави приемлив за прототип или за текст без ясна структура.

def chunk_by_chars(text, chunk_size=2048, overlap=200):
    """Split text into chunks with overlap."""
    chunks = []
    start = 0
    while start < len(text):
        end = start + chunk_size
        chunk = text[start:end]
        chunks.append(chunk)
        start = end - overlap  # Overlap for context
    return chunks

long_text = "A very long document..." * 500
chunks = chunk_by_chars(long_text, chunk_size=2048, overlap=200)
print(f"{len(chunks)} chunks created")

Разделяне базирано на абзаци (Препоръчително)

Разделянето базирано на абзаци tônува единицата на смисъл, замислена от автора. В продуктовата документация всеки абзац обикновено обхваща конкретен пункт; запазването му непокътнат води до част, която може да отговори на въпрос самостоятелно. Функцията натрупва абзаци, докато максималният размер не бъде надвишен, след което затваря текущата част.

def chunk_by_paragraphs(text, max_chunk_size=2048):
    """Split while respecting paragraph boundaries."""
    paragraphs = text.split("\n\n")
    chunks = []
    current_chunk = ""

    for para in paragraphs:
        if len(current_chunk) + len(para) + 2 > max_chunk_size:
            if current_chunk:
                chunks.append(current_chunk.strip())
            current_chunk = para
        else:
            current_chunk += "\n\n" + para if current_chunk else para

    if current_chunk:
        chunks.append(current_chunk.strip())

    return chunks

Разделяне базирано на изречения

Когато текстът липсва използваеми абзаци – транскрипция на разговор, дневник на изпълнение – изречението става най-малката налична единица на смисъл. Разделянето тогава следва същата логика на натрупване, разчитайки на пунктуацията за край на изречението.

import re

def chunk_by_sentences(text, max_chunk_size=1500):
    """Split while respecting sentence boundaries."""
    # Split on end-of-sentence punctuation
    sentence_pattern = r'(?<=[.!?])\s+'
    sentences = re.split(sentence_pattern, text)
    chunks = []
    current_chunk = ""

    for sentence in sentences:
        if len(current_chunk) + len(sentence) + 1 > max_chunk_size:
            if current_chunk:
                chunks.append(current_chunk.strip())
            current_chunk = sentence
        else:
            current_chunk += " " + sentence if current_chunk else sentence

    if current_chunk:
        chunks.append(current_chunk.strip())

    return chunks

Припокриване

Припокриването между частите предотвратява разрязването на една идея наполовина. Чрез добавяне на припокриване от 10% до 20% от размера на частта, Вие запазвате контекста между съседните парчета. Представете си процедура, при която стъпка 4 завършва на символ 2040, а последствието е обяснено веднага след това: без припокриване никоя част не съдържа и двете половини на разсъждението и търсенето никога няма да извлече пълния отговор.

Стойностите по-долу служат като доказани отправни точки в зависимост от типа съдържание:

# Recommended parameters by content type
PARAMS = {
    "articles":     {"chunk_size": 1500, "overlap": 200},
    "documentation": {"chunk_size": 1000, "overlap": 150},
    "conversations": {"chunk_size": 500,  "overlap": 50},
    "code":          {"chunk_size": 2000, "overlap": 300},
}

Разговорите падат до 500 символа, защото един завой на речта е кратък, а по-голяма част би смесила множество теми; кодът се повишава до 2000 с щедро припокриване, защото една функция губи смисъл, ако нейният подпис бъде отделен от тялото ѝ.

Пълен конвейер: Разделяне + Пакетиране + Вграждане

Ето как да комбинирате разделянето на части и пакетирането в производствен конвейер. Елементът, който не трябва да пренебрегвате, е chunk_metadata: без него получавате осиротели вектори, които не могат да посочат от кой документ произлизат, и никога няма да можете да цитирате източниците си в крайния отговор.

def pipeline_embed(documents, chunk_size=1500, overlap=200, batch_size=50):
    """Complete pipeline: chunk, batch, embed."""
    # 1. Chunk all documents
    all_chunks = []
    chunk_metadata = []  # Track source document

    for doc_idx, doc in enumerate(documents):
        chunks = chunk_by_paragraphs(doc, max_chunk_size=chunk_size)
        for chunk_idx, chunk in enumerate(chunks):
            all_chunks.append(chunk)
            chunk_metadata.append({
                "doc_index": doc_idx,
                "chunk_index": chunk_idx,
            })

    print(f"{len(documents)} documents -> {len(all_chunks)} chunks")

    # 2. Encode in batches
    embeddings = get_embeddings_by_chunks(all_chunks, chunk_size=batch_size)

    # 3. Return structured results
    return {
        "chunks": all_chunks,
        "embeddings": np.array(embeddings),
        "metadata": chunk_metadata,
    }

# Usage
result = pipeline_embed(documents)
print(f"Embeddings: {result['embeddings'].shape}")

Стартирайте този конвейер с дузина от Вашите действителни документи и проверете all_chunks на око, преди да кодирате каквото и да е в мащаб. Лошото разделяне се вижда веднага при четене, докато то никога не се проявява във формата на матрицата.

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

  • Пакетирането Ви позволява да кодирате хиляди документи, без да надвишавате лимитите на API
  • Разделянето на части разцепва дългите текстове за по-добра семантична гранулярност
  • Припокриване от 10–20% между частите запазва контекста
  • Разделянето по абзаци или изречения е за предпочитане пред разделянето по символи
  • Запазете метаданните (изходен документ, позиция) за всяка част