Preskoči na glavni sadržaj
Hrvatski— Odaberite jezik
Izbornik

Grupiranje i dijeljenje na dijelove

Lekcija 4 od 18 Ažurirano 2. studenoga 2026. Programer
Na ovoj stranici
  1. Izazov velikih količina podataka
  2. Grupiranje: Obrada u skupinama
  3. Dijeljenje na dijelove: Cijepanje teksta
  4. Preklapanje
  5. Potpuni pipeline: Dijeljenje + Grupiranje + Ugradnja
  6. Ključne točke

Izazov velikih količina podataka

Kada radiš s tisućama dokumenata, ne možeš sve kodirati u jednom pozivu API-ja. Moraš upravljati grupiranjem (obrada u skupinama) i dijeljenjem na dijelove (cijepanje teksta). Ove dvije tehnike ključne su za izgradnju sustava semantičkog pretraživanja u velikom mjerilu.

Ta se dva pojma zvuče slično, ali rješavaju suprotne probleme. Dijeljenje na dijelove rješava problem jednog dokumenta koji je prevelik da bi se učinkovito kodirao u cijelosti; grupiranje rješava problem previše dokumenata koji ne staju u jedan zahtjev. Tehnički priručnik od tristo stranica spada u prvu kategoriju, izvoz od dvadeset tisuća tiketa u drugu, a stvarni projekt gotovo uvijek uključuje oboje.

Grupiranje: Obrada u skupinama

API mistral-embed prihvaća popis ulaza, ali postoje praktična ograničenja (veličina zahtjeva, broj tokena). Rješenje je podijeliti tvoj korpus na grupe (batcheve) i iterirati kroz njih. Donja funkcija radi upravo to, prikazujući napredak – što je ključan detalj kada kodiranje cijelog korpusa traje nekoliko minuta i trebaš znati napreduje li proces ili je zastao.

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

Korištenje extend umjesto append osigurava da redoslijed vektora točno odgovara redoslijedu ulaznog teksta. To ti omogućuje kasnije dohvaćanje izvornog dokumenta putem jednostavnog indeksa.

Optimizacija veličine grupe

Optimalna veličina grupe ovisi o prosječnoj duljini tvojih tekstova: pedeset naslova članaka i pedeset punih izvješća ne teže isto u tokenima. Umjesto nasumičnog odabira konstante, procijeni je iz samog korpusa.

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

Ograničenje na 100 nije kozmetičko: iznad te brojke, jedan neuspjeli batch uzrokuje značajan gubitak posla, a memorija koju zauzima odgovor postaje znatna.

Dijeljenje na dijelove: Cijepanje teksta

Dugi tekstovi moraju se podijeliti na dijelove prije kodiranja. Postoji nekoliko strategija, od kojih svaka ima svoje prednosti, a izbor izravno utječe na kvalitetu odgovora: dio koji počinje usred rečenice proizvodi nejasan vektor, što dovodi do nejasnih rezultata pretraživanja.

Dijeljenje temeljeno na znakovima (Jednostavno)

Najizravnija metoda reže svakih N znakova, bez obzira na sadržaj. Njezina je prednost predvidljivost i brzina, što je prihvatljivo za prototip ili za tekst bez 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")

Dijeljenje temeljeno na odlomcima (Preporučeno)

Dijeljenje temeljeno na odlomcima poštuje jedinicu značenja koju je autor namijenio. U dokumentaciji proizvoda, svaki odlomak obično pokriva specifičnu točku; njegovo očuvanje u cjelini daje dio koji može samostalno odgovoriti na pitanje. Funkcija akumulira odlomke dok se ne prijeđe maksimalna veličina, zatim zatvara trenutni dio.

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

Dijeljenje temeljeno na rečenicama

Kada tekstu nedostaju upotrebljivi odlomci – poput transkripta poziva ili dnevnika događaja – rečenica postaje najmanja dostupna jedinica značenja. Dijeljenje tada slijedi istu logiku akumulacije, oslanjajući se na interpunkciju koja označava kraj rečenice.

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

Preklapanje

Preklapanje između dijelova sprječava prepolavljanje ideje. Dodavanjem preklapanja od 10% do 20% veličine dijela, čuvaš kontekst između susjednih komada. Zamisli postupak gdje korak 4. završava na 2040. znaku, a posljedica je objašnjena odmah nakon toga: bez preklapanja, nijedan dio ne sadrži obje polovice razmišljanja i pretraživanje nikada neće dohvatiti potpun odgovor.

Vrijednosti u nastavku služe kao provjerene početne točke ovisno o vrsti sadržaja:

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

Razgovori se smanjuju na 500 znakova jer je govorni okret kratak, a veći dio bi miješao više tema; kod se povećava na 2000 s velikim preklapanjem jer funkcija gubi smisao ako joj se potpis odvoji od tijela.

Potpuni pipeline: Dijeljenje + Grupiranje + Ugradnja

Evo kako kombinirati dijeljenje na dijelove i grupiranje u produkcijskom pipelineu. Element koji ne smiješ zanemariti jest chunk_metadata: bez njega dobivaš osirotele vektore koji ne mogu ukazati iz kojeg dokumenta potječu i nikada nećeš moći citirati svoje izvore u konačnom 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}")

Pokreni ovaj pipeline na desetak svojih stvarnih dokumenata i vizualno pregledaj all_chunks prije nego što išta kodiraš u velikom mjerilu. Loše cijepanje odmah je vidljivo čitanjem, dok se nikada ne pojavljuje u obliku matrice.

Ključne točke

  • Grupiranje ti omogućuje kodiranje tisuća dokumenata bez prekoračenja ograničenja API-ja
  • Dijeljenje na dijelove cijepa duge tekstove za bolju semantičku granuliranost
  • Preklapanje od 10–20% između dijelova čuva kontekst
  • Dijeljenje po odlomcima ili rečenicama poželjnije je od dijeljenja po znakovima
  • Zadrži metapodatke (izvorni dokument, poziciju) za svaki dio