Batching en Chunking
Op deze pagina
De uitdaging van grote volumes
Wanneer u met duizenden documenten werkt, kunt u niet alles in één enkele API-aanroep coderen. U moet batching (verwerken in groepen) en chunking (splitsen van tekst) beheren. Deze twee technieken zijn essentieel voor het bouwen van semantische zoeksystemen op schaal.
De twee concepten klinken vergelijkbaar, maar lossen tegenovergestelde problemen op. Chunking handelt een enkel document af dat te groot is om effectief als geheel te worden gecodeerd; batching handelt te veel documenten af om in één verzoek te passen. Een technisch handboek van driehonderd pagina’s valt in de eerste categorie, een export van twintigduizend tickets in de tweede, en een realistisch project omvat bijna altijd beide.
Batching: Verwerken in groepen
De mistral-embed API accepteert een lijst met invoeren, maar er bestaan praktische limieten (verzoeksgrootte, aantal tokens). De oplossing is om uw corpus in batches op te splitsen en deze te doorlopen. De onderstaande functie doet precies dat en toont de voortgang – een cruciaal detail wanneer het coderen van een volledig corpus enkele minuten duurt en u moet weten of het proces vordert of vastloopt.
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")
Het gebruik van extend in plaats van append zorgt ervoor dat de volgorde van de vectoren exact overeenkomt met de volgorde van de invoertekst. Hierdoor kunt u later via een eenvoudige index het oorspronkelijke document ophalen.
Batchgrootte optimaliseren
De optimale batchgrootte hangt af van de gemiddelde lengte van uw teksten: vijftig artikeltitels en vijftig volledige rapporten wegen niet even zwaar in tokens. Kies niet willekeurig een constante, maar schat deze op basis van het corpus zelf.
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}")
De begrenzing op 100 is niet louter cosmetisch: daarboven veroorzaakt één mislukte batch aanzienlijk werkverlies en wordt het geheugengebruik door het antwoord substantieel.
Chunking: Tekst splitsen
Lange teksten moeten vóór het coderen worden opgesplitst in chunks. Er bestaan verschillende strategieën, elk met zijn eigen voordelen, en de keuze heeft directe invloed op de kwaliteit van het antwoord: een chunk die midden in een zin begint, produceert een vaag vector, wat leidt tot vage zoekresultaten.
Splitsen op basis van tekens (Eenvoudig)
De meest directe methode knipt elke N tekens, ongeacht de inhoud. De verdienste hiervan is voorspelbaarheid en snelheid, waardoor het acceptabel is voor een prototype of voor tekst zonder duidelijke structuur.
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")
Splitsen op basis van alinea’s (Aanbevolen)
Splitsen op basis van alinea’s respecteert de eenheid van betekenis zoals bedoeld door de auteur. In productdocumentatie behandelt elke alinea doorgaans een specifiek punt; dit intact laten levert een chunk op dat zelfstandig een vraag kan beantwoorden. De functie accumuleert alinea’s totdat de maximale grootte wordt overschreden en sluit vervolgens de huidige chunk af.
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
Splitsen op basis van zinnen
Wanneer tekst geen bruikbare alinea’s bevat – zoals een gespreksopname of een logboek – wordt de zin de kleinste beschikbare eenheid van betekenis. Het splitsen volgt dan dezelfde accumulatielogica, waarbij wordt vertrouwd op leestekens aan het einde van zinnen.
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
Overlap
Overlap tussen chunks voorkomt dat een idee doormidden wordt gesneden. Door een overlap van 10% tot 20% van de chunkgrootte toe te voegen, behoudt u context tussen aangrenzende stukken. Stel u een procedure voor waarbij stap 4 eindigt bij teken 2040 en het gevolg direct daarna wordt uitgelegd: zonder overlap bevat geen enkele chunk beide helften van de redenering en zal zoekopdracht nooit het volledige antwoord ophalen.
De onderstaande waarden dienen als bewezen startpunten, afhankelijk van het contenttype:
# 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},
}
Gesprekken dalen naar 500 tekens omdat een spurt kort is en een grotere chunk meerdere onderwerpen zou vermengen; code stijgt naar 2000 met royale overlap omdat een functie zijn betekenis verliest als de signatuur gescheiden wordt van de body.
Volledige pipeline: Chunk + Batch + Embed
Hier ziet u hoe u chunking en batching combineert in een productie-pipeline. Het element dat u niet mag verwaarlozen is chunk_metadata: zonder dit krijgt u weesvectoren die niet kunnen aangeven uit welk document ze komen, en zult u nooit uw bronnen kunnen citeren in het uiteindelijke antwoord.
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}")
Voer deze pipeline uit op een dozijn van uw daadwerkelijke documenten en inspecteer all_chunks visueel voordat u op schaal gaat coderen. Een slechte splitsing is direct zichtbaar bij het lezen, terwijl deze nooit naar voren komt in de matrixvorm.
Belangrijkste punten
- Met batching kunt u duizenden documenten coderen zonder de API-limieten te overschrijden
- Chunking splitst lange teksten voor betere semantische granulariteit
- Een overlap van 10–20% tussen chunks behoudt de context
- Splitsen op alinea’s of zinnen heeft de voorkeur boven splitsen op tekens
- Bewaar metadata (brondocument, positie) voor elke chunk