Grupowanie i dzielenie na fragmenty
Na tej stronie
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