Preskok na glavno vsebino
Slovenščina— Izberite jezik
Meni

Združevanje v serije in razdeljevanje na dele

Lekcija 4 od 18 Posodobljeno 2. november 2026 Razvijalec
Na tej strani
  1. Izziv velikih količin podatkov
  2. Združevanje v serije: Obdelava v skupinah
  3. Razdeljevanje na dele: Cepljenje besedila
  4. Prekrivanje
  5. Celoten potek dela: Razdeli + Združi v serije + Vgradi
  6. Ključne ugotovitve

Izziv velikih količin podatkov

Ko delaš s tisoči dokumentov, ne moreš vsega kodirati v enem samem klicu API-ja. Upravljati moraš združevanje v serije (obdelava v skupinah) in razdeljevanje na dele (cepljenje besedila). Ti dve tehniki sta ključni za gradnjo semantičnih iskalnih sistemov v velikem obsegu.

Oba koncepta zvenita podobno, a rešujeta nasprotna problema. Razdeljevanje na dele obravnava posamezen dokument, ki je prevelik, da bi ga učinkovito kodirali kot celoto; združevanje v serije pa obravnava preveč dokumentov, da bi jih spravili v eno samo zahtevo. Tristostranski tehnični priročnik spada v prvo kategorijo, izvoz dvajset tisoč vstopnic v drugo, realni projekti pa skoraj vedno vključujejo oboje.

Združevanje v serije: Obdelava v skupinah

API mistral-embed sprejme seznam vhodnih podatkov, vendar obstajajo praktične omejitve (velikost zahteve, število žetonov). Rešitev je razdelitev tvoje zbirke podatkov v serije in iteracija skozi njih. Spodnja funkcija počne natanko to in prikazuje napredek – kar je ključna podrobnost, ko kodiranje celotne zbirke traja več minut in moraš vedeti, ali proces napreduje ali se je zatikal.

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

Uporaba extend namesto append zagotavlja, da se vrstni red vektorjev popolnoma ujema z vrstnim redom vhodnega besedila. To ti omogoča, da kasneje preprosto preko indeksa pridobiš izvirni dokument.

Optimizacija velikosti serije

Optimalna velikost serije je odvisna od povprečne dolžine tvojih besedil: petdeset naslovov člankov in petdeset celotnih poročil ne tehtata enako v žetonih. Namesto da bi naključno izbral konstanto, jo oceni neposredno iz zbirke podatkov.

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

Omejitev na 100 ni kozmetična: preko te meje ena sama neuspešna serija povzroči znatno izgubo dela, pomnilnik, ki ga porabi odgovor, pa postane substančen.

Razdeljevanje na dele: Cepljenje besedila

Dolga besedila je treba pred kodiranjem razdeliti na dele. Na voljo je več strategij, vsaka ima svoje prednosti, izbira pa neposredno vpliva na kakovost odgovora: del, ki se začne sredi stavka, proizvede nejasen vektor, kar vodi do nejasnih rezultatov iskanja.

Razdeljevanje na podlagi znakov (preprosto)

Najbolj neposredna metoda odreže vsakih N znakov, ne glede na vsebino. Njena prednost je predvidljivost in hitrost, zaradi česar je sprejemljiva za prototipe ali za besedila brez jasne strukture.

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

Razdeljevanje na podlagi odstavkov (priporočeno)

Razdeljevanje na podlagi odstavkov spoštuje enoto pomena, ki jo je avtor namenil. V produktni dokumentaciji vsak odstavek običajno pokriva specifično točko; če ga ohraniš nedotaknjenega, dobiš del, ki lahko samostojno odgovori na vprašanje. Funkcija kopiči odstavke, dokler ne preseže največje velikosti, nato pa zaključi trenutni del.

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

Razdeljevanje na podlagi stavkov

Ko besedilu manjkajo uporabni odstavki – na primer prepis klica ali dnevnik teka – postane stavek najmanjša razpoložljiva enota pomena. Razdeljevanje nato sledi isti logiki kopičenja in se zanaša na ločila ob koncu stavka.

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

Prekrivanje

Prekrivanje med deli preprečuje prerezanje ideje na pol. Z dodajanjem prekrivanja v višini 10 % do 20 % velikosti dela ohraniš kontekst med sosednjimi kosi. Predstavljaj si postopek, kjer se 4. korak konča pri znaku 2040, posledica pa je razložena takoj zatem: brez prekrivanja noben del ne vsebuje obeh polovic razmišljanja in iskanje nikoli ne bo vrnilo popolnega odgovora.

Spodnje vrednosti služijo kot preizkušene izhodiščne točke glede na vrsto vsebine:

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

Pri pogovorih vrednost pade na 500 znakov, ker je govorni obrat kratek in bi večji del zmešal več tem; pri kodi naraste na 2000 z velikodušnim prekrivanjem, ker funkcija izgubi pomen, če je njen podpis ločen od telesa.

Celoten potek dela: Razdeli + Združi v serije + Vgradi

Tako združiš razdeljevanje na dele in združevanje v serije v produkcijskem poteku dela. Element, ki ga ne smeš zanemariti, je chunk_metadata: brez njega dobiš osirotele vektorje, ki ne morejo indicirati, iz katerega dokumenta izvirajo, in nikoli ne boš mogel navesti svojih virov v končnem odgovoru.

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

Zaženi ta potek dela na ducatu svojih dejanskih dokumentov in vizualno pregledaj all_chunks, preden začneš kodirati v velikem obsegu. Slabo razdeljevanje je takoj vidno ob branju, medtem ko se v obliki matrike nikoli ne pokaže.

Ključne ugotovitve

  • Združevanje v serije ti omogoča kodiranje tisočev dokumentov brez preseženih omejitev API-ja
  • Razdeljevanje na dele cepi dolga besedila za boljšo semantično zrnatost
  • Prekrivanje med deli v višini 10–20 % ohranja kontekst
  • Razdeljevanje na podlagi odstavkov ali stavkov je boljše od razdeljevanja na podlagi znakov
  • Za vsak del ohrani metapodatke (izvirni dokument, položaj)