Batchning och chunking
På denna sida
Utmaningen med stora volymer
När du arbetar med tusentals dokument kan du inte koda allt i ett enda API-anrop. Du måste hantera batchning (bearbetning i grupper) och chunking (uppdelning av text). Dessa två tekniker är avgörande för att bygga semantiska söksystem i stor skala.
De två begreppen låter lika men löser motsatta problem. Chunking hanterar ett enskilt dokument som är för stort för att kodas effektivt som en helhet; batchning hanterar för många dokument för att få plats i en enda begäran. En teknisk manual på trehundra sidor faller i den första kategorin, en export av tjugo tusen ärenden i den andra, och ett verkligt projekt involverar nästan alltid båda.
Batchning: Bearbetning i grupper
API:t för mistral-embed accepterar en lista med indata, men det finns praktiska gränser (begärandestorlek, antal token). Lösningen är att dela upp din korpus i batchar och loopa igenom dem. Funktionen nedan gör exakt detta och visar framsteg – en kritisk detalj när kodning av en hel korpus tar flera minuter och du behöver veta om processen framskrider eller har fastnat.
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")
Att använda extend istället för append säkerställer att vektorordningen matchar ordningen på inputtexten exakt. Detta gör att du senare kan hämta originaldokumentet från ett enkelt index.
Optimering av batchstorlek
Den optimala batchstorleken beror på den genomsnittliga längden på dina texter: femtio artikelrubriker och femtio hela rapporter väger inte lika mycket i token. Istället för att slumpmässigt välja en konstant, uppskatta den från själva korpusen.
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}")
Taket på 100 är inte kosmetiskt: bortom det leder ett enda misslyckat batch till betydande förlust av arbete, och minnet som konsumeras av svaret blir betydande.
Chunking: Uppdelning av text
Långa texter måste delas upp i chunkar innan kodning. Det finns flera strategier, var och en med sina fördelar, och valet påverkar svarskvaliteten direkt: en chunk som börjar mitt i en mening producerar en otydlig vektor, vilket leder till otydliga sökresultat.
Uppdelning baserad på tecken (enkelt)
Den mest direkta metoden klipper var N:e tecken, oavsett innehåll. Dess förtjänst är förutsägbarhet och hastighet, vilket gör den acceptabel för en prototyp eller för text utan tydlig struktur.
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")
Uppdelning baserad på stycken (rekommenderas)
Uppdelning baserad på stycken respekterar den meningsenhet som författaren avsett. I produkt Dokumentation täcker varje stycke generellt en specifik punkt; att hålla det intakt ger en chunk som kan svara på en fråga på egen hand. Funktionen ackumulerar stycken tills maximal storlek överskrids, och stänger sedan den aktuella chunken.
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
Uppdelning baserad på meningar
När texten saknar användbara stycken – en transkribering av ett samtal, en löpande logg – blir meningen den minsta tillgängliga meningsenheten. Uppdelningen följer då samma ackumuleringslogik och förlitar sig på skiljetecken vid menings slut.
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
Överlappning
Överlappning mellan chunkar förhindrar att en idé kapas mitt itu. Genom att lägga till en överlappning på 10 % till 20 % av chunkstorleken bevarar du kontexten mellan angränsande delar. Tänk dig en procedur där steg 4 slutar vid tecken 2040 och konsekvensen förklaras omedelbart efter: utan överlappning innehåller ingen chunk båda halvorna av resonemanget, och sökningen kommer aldrig att hämta det kompletta svaret.
Värdena nedan fungerar som beprövade utgångspunkter beroende på innehållstyp:
# 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},
}
Samtal sjunker till 500 tecken eftersom en talvända är kort, och en större chunk skulle blanda flera ämnen; kod stiger till 2000 med generös överlappning eftersom en funktion förlorar sin mening om dess signatur separeras från dess kropp.
Kompletta pipelinen: Chunk + Batch + Embed
Så här kombinerar du chunking och batchning i en produktionspipeline. Det element du inte får försumma är chunk_metadata: utan det får du föräldralösa vektorer som inte kan indikera vilket dokument de kommer från, och du kommer aldrig att kunna citera dina källor i det slutgiltiga svaret.
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}")
Kör denna pipeline på ett dussin av dina faktiska dokument och inspektera all_chunks visuellt innan du kodar något i stor skala. En dålig uppdelning syns omedelbart vid läsning, medan den aldrig visar sig i matrisens form.
Viktiga punkter
- Batchning låter dig koda tusentals dokument utan att överskrida API-gränser
- Chunking delar upp långa texter för bättre semantisk granularitet
- En överlappning på 10–20 % mellan chunkar bevarar kontexten
- Uppdelning baserad på stycken eller meningar är att föredra framför uppdelning baserad på tecken
- Behåll metadata (källdokument, position) för varje chunk