Przejdź do głównej treści
Polski— Wybierz język
Menu

Grupowanie i dzielenie na fragmenty

Lekcja 4 z 18 Zaktualizowano 2 listopada 2026 Programista
Na tej stronie
  1. Wyzwanie dużych zbiorów danych
  2. Grupowanie: Przetwarzanie w partiach
  3. Dzielenie na fragmenty: Podział tekstu
  4. Nakładanie się (Overlap)
  5. Kompletny potok: Fragmentuj + Grupuj + Osadzaj
  6. Kluczowe wnioski

Wyzwanie dużych zbiorów danych

Gdy pracujesz z tysiącami dokumentów, nie możesz zakodować wszystkiego w jednym wywołaniu API. Musisz zarządzać grupowaniem (przetwarzanie w partiach) i dzieleniem na fragmenty (podział tekstu). Te dwie techniki są kluczowe dla budowy systemów wyszukiwania semantycznego na dużą skalę.

Oba pojęcia brzmią podobnie, ale rozwiązują przeciwstawne problemy. Dzielenie na fragmenty dotyczy pojedynczego dokumentu, który jest zbyt duży, by skutecznie zakodować go w całości; grupowanie dotyczy zbyt wielu dokumentów, by zmieściły się w jednym żądaniu. Trzystustroniczny podręcznik techniczny wpada do pierwszej kategorii, eksport dwudziestu tysięcy zgłoszeń do drugiej, a realny projekt prawie zawsze obejmuje obie.

Grupowanie: Przetwarzanie w partiach

API mistral-embed akceptuje listę danych wejściowych, ale istnieją praktyczne limity (rozmiar żądania, liczba tokenów). Rozwiązaniem jest podział korpusu na partie i iteracja po nich. Poniższa funkcja robi dokładnie to, wyświetlając postęp – co jest kluczowe, gdy kodowanie pełnego korpusu zajmuje kilka minut i musisz wiedzieć, czy proces postępuje, czy utknął.

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

Użycie extend zamiast append zapewnia, że kolejność wektorów dokładnie odpowiada kolejności tekstów wejściowych. Pozwala to później odzyskać oryginalny dokument na podstawie prostego indeksu.

Optymalizacja rozmiaru partii

Optymalny rozmiar partii zależy od średniej długości Twoich tekstów: pięćdziesiąt tytułów artykułów i pięćdziesiąt pełnych raportów nie waży tyle samo w tokenach. Zamiast wybierać stałą wartość losowo, oszacuj ją na podstawie samego korpusu.

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

Ograniczenie do 100 nie jest kosmetyczne: powyżej tej wartości jedna nieudana partia powoduje znaczną utratę pracy, a pamięć zużywana przez odpowiedź staje się istotna.

Dzielenie na fragmenty: Podział tekstu

Długie teksty muszą zostać podzielone na fragmenty przed zakodowaniem. Istnieje kilka strategii, z których każda ma swoje zalety, a wybór bezpośrednio wpływa na jakość odpowiedzi: fragment zaczynający się w środku zdania produkuje nieostry wektor, co prowadzi do nieprecyzyjnych wyników wyszukiwania.

Podział oparty na znakach (prosty)

Najbardziej bezpośrednia metoda tnie co N znaków, niezależnie od treści. Jej zaletą jest przewidywalność i szybkość, co czyni ją akceptowalną dla prototypu lub tekstu bez wyraźnej struktury.

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

Podział oparty na akapitach (zalecany)

Podział oparty na akapitach szanuje jednostkę znaczeniową zamierzoną przez autora. W dokumentacji produktu każdy akapit zazwyczaj obejmuje konkretny punkt; utrzymanie go w nienaruszonym stanie daje fragment, który może samodzielnie odpowiedzieć na pytanie. Funkcja akumuluję akapity, dopóki nie zostanie przekroczony maksymalny rozmiar, a następnie zamyka bieżący fragment.

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

Podział oparty na zdaniach

Gdy tekst nie zawiera użytecznych akapitów – transkrypcja rozmowy, dziennik zdarzeń – zdanie staje się najmniejszą dostępną jednostką znaczeniową. Podział podąża wtedy za tą samą logiką akumulacji, opierając się na interpunkcji kończącej zdanie.

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

Nakładanie się (Overlap)

Nakładanie się między fragmentami zapobiega przecinaniu idei na pół. Dodając nakładanie się rzędu 10% do 20% rozmiaru fragmentu, zachowujesz kontekst między sąsiadującymi częściami. Wyobraź sobie procedurę, w której krok 4 kończy się na znaku 2040, a konsekwencja jest wyjaśniona natychmiast potem: bez nakładania się żaden fragment nie zawiera obu połów rozumowania, a wyszukiwanie nigdy nie zwróci kompletnej odpowiedzi.

Poniższe wartości służą jako sprawdzone punkty startowe w zależności od typu treści:

# 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},
}

Rozmowy spadają do 500 znaków, ponieważ tura wypowiedzi jest krótka, a większy fragment mieszałby wiele tematów; kod rośnie do 2000 z hojnym nakładaniem się, ponieważ funkcja traci sens, jeśli jej sygnatura zostanie oddzielona od ciała.

Kompletny potok: Fragmentuj + Grupuj + Osadzaj

Oto jak połączyć dzielenie na fragmenty i grupowanie w potoku produkcyjnym. Elementem, którego nie wolno zaniedbać, jest chunk_metadata: bez niego otrzymujesz osierocone wektory, które nie mogą wskazać, z którego dokumentu pochodzą, i nigdy nie będziesz w stanie cytować swoich źródeł w końcowej odpowiedzi.

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

Uruchom ten potok na tuzinie swoich rzeczywistych dokumentów i obejrzyj all_chunks gołym okiem przed zakodowaniem czegokolwiek na dużą skalę. Zły podział jest natychmiast widoczny podczas czytania, podczas gdy nigdy nie pojawi się w kształcie macierzy.

Kluczowe wnioski

  • Grupowanie pozwala kodować tysiące dokumentów bez przekraczania limitów API
  • Dzielenie na fragmenty rozbija długie teksty dla lepszej granulacji semantycznej
  • Nakładanie się rzędu 10–20% między fragmentami zachowuje kontekst
  • Podział na akapity lub zdania jest preferowany względem podziału na znaki
  • Zachowuj metadane (dokument źródłowy, pozycja) dla każdego fragmentu