Spring til hovedindhold
Dansk— Vælg et sprog
Menu

Batching og Chunking

Lektion 4 af 18 Opdateret 2. november 2026 Udvikler
På denne side
  1. Udfordringen ved store mængder data
  2. Batching: Behandling i grupper
  3. Chunking: Opdeling af tekst
  4. Overlap
  5. Komplet pipeline: Chunk + Batch + Embed
  6. Vigtige pointer

Udfordringen ved store mængder data

Når du arbejder med tusindvis af dokumenter, kan du ikke kode alt i et enkelt API-kald. Du skal håndtere batching (behandling i grupper) og chunking (opdeling af tekst). Disse to teknikker er afgørende for at bygge semantiske søgesystemer i stor skala.

De to begreber lyder ens, men løser modsatte problemer. Chunking håndterer et enkelt dokument, der er for stort til effektivt at blive kodet som helhed; batching håndterer for mange dokumenter til at passe i en enkelt anmodning. En teknisk manual på tre hundrede sider falder ind under den første kategori, en eksport af tyve tusinde sager under den anden, og et projekt i den virkelige verden involverer næsten altid begge dele.

Batching: Behandling i grupper

mistral-embed-API’et accepterer en liste over input, men der findes praktiske grænser (størrelse på anmodning, antal tokens). Løsningen er at opdele dit korpus i batches og løkke igennem dem. Funktionen nedenfor gør præcis dette og viser fremskridt – en kritisk detalje, når kodning af et helt korpus tager flere minutter, og du har brug for at vide, om processen skrider frem eller hænger fast.

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

Brug af extend i stedet for append sikrer, at vektorrækkefølgen matcher inputtekstens rækkefølge nøjagtigt. Dette giver dig mulighed for senere at hente det oprindelige dokument ud fra et simpelt indeks.

Optimering af batch-størrelse

Den optimale batch-størrelse afhænger af den gennemsnitlige længde af dine tekster: halvtreds artikeloverskrifter og halvtreds fulde rapporter vejer ikke det samme i tokens. I stedet for at vælge en konstant tilfældigt, bør du estimere den ud fra selve korpussen.

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

Loftet på 100 er ikke kosmetisk: ud over dette punkt vil en enkelt mislykket batch medføre betydeligt tab af arbejde, og hukommelsen, der forbruges af svaret, bliver væsentlig.

Chunking: Opdeling af tekst

Lange tekster skal opdeles i chunks før kodning. Der findes flere strategier, som hver har sine fordele, og valget påvirker direkte svarkvaliteten: en chunk, der starter midt i en sætning, producerer en uskarpt vektor, hvilket fører til uskarpe søgeresultater.

Tegnbaseret opdeling (Enkel)

Den mest direkte metode skærer hver N-tegn uanset indhold. Dens fortjeneste er forudsigelighed og hastighed, hvilket gør den acceptabel til en prototype eller til tekst uden klar 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")

Afsnitsbaseret opdeling (Anbefalet)

Afsnitsbaseret opdeling respekterer den meningsenhed, forfatteren har tiltænkt. I produktdokumentation dækker hvert afsnit generelt et specifikt punkt; at holde det intakt giver en chunk, der alene kan besvare et spørgsmål. Funktionen akkumulerer afsnit, indden maksimale størrelse overskrides, og lukker derefter den aktuelle chunk.

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

Sætningsbaseret opdeling

Når tekst mangler brugbare afsnit – f.eks. en transskription af et opkald eller en logbog – bliver sætningen den mindste tilgængelige meningsenhed. Opdelingen følger derefter samme akkumuleringslogik og baserer sig på tegnsætning, der markerer slutningen af en sætning.

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 mellem chunks forhindrer, at en idé bliver skåret over. Ved at tilføje et overlap på 10 % til 20 % af chunk-størrelsen bevarer du konteksten mellem tilstødende dele. Forestil dig en procedure, hvor trin 4 slutter ved tegn 2040, og konsekvensen forklares umiddelbart efter: uden overlap indeholder ingen chunk begge halvdele af ræsonnementet, og søgningen vil aldrig kunne finde det komplette svar.

Værdierne nedenfor tjener som beviste udgangspunkter afhængigt af indholdstype:

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

Samtaler falder til 500 tegn, fordi en talevending er kort, og en større chunk ville blande flere emner; kode stiger til 2000 med generøst overlap, fordi en funktion mister sin betydning, hvis dens signatur adskilles fra dens krop.

Komplet pipeline: Chunk + Batch + Embed

Her er hvordan du kombinerer chunking og batching i en produktions-pipeline. Det element, du ikke må forsømme, er chunk_metadata: uden det får du forældreløse vektorer, der ikke kan indikere, hvilket dokument de stammer fra, og du vil aldrig kunne citere dine kilder i det endelige svar.

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 denne pipeline på et dusin af dine faktiske dokumenter, og inspicer all_chunks visuelt, før du koder noget i stor skala. En dårlig opdeling er straks synlig, når man læser, hvorimod den aldrig viser sig i matrixformen.

Vigtige pointer

  • Batching lader dig kode tusindvis af dokumenter uden at overskride API-grænser
  • Chunking opdeler lange tekster for bedre semantisk granularitet
  • Et overlap på 10–20 % mellem chunks bevarer konteksten
  • Opdeling efter afsnit eller sætninger er at foretrække frem for tegnbaseret opdeling
  • Behold metadata (kildedokument, position) for hver chunk