Hoppa till huvudinnehåll
Svenska— Välj ett språk
Meny

Batchning och chunking

Lektion 4 av 18 Uppdaterad 2 november 2026 Utvecklare
På denna sida
  1. Utmaningen med stora volymer
  2. Batchning: Bearbetning i grupper
  3. Chunking: Uppdelning av text
  4. Överlappning
  5. Kompletta pipelinen: Chunk + Batch + Embed
  6. Viktiga punkter

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