Siirry pääsisältöön
Suomi— Valitse kieli
Valikko

Batchaus ja paloitteleminen

Oppitunti 4 / 18 Päivitetty 2. marraskuuta 2026 Kehittäjä
Tällä sivulla
  1. Suurten datamäärien haaste
  2. Batchaus: käsittely ryhmissä
  3. Palastelu: tekstin jakaminen
  4. Päällekkäisyys
  5. Täydellinen putki: Palastelu + Batchaus + Upotus
  6. Keskeiset asiat

Suurten datamäärien haaste

Kun käsittelet tuhansia dokumentteja, et voi koodata kaikkea yhdellä API-kutsulla. Sinun on hallittava batchaus (käsittely ryhmissä) ja palastelu (tekstin jakaminen). Nämä kaksi tekniikkaa ovat välttämättömiä semanttisten hakujärjestelmien rakentamisessa laajassa mittakaavassa.

Käsitteet kuulostavat samankaltaisilta, mutta ne ratkaisevat vastakkaisia ongelmia. Palastelu käsittelee yksittäistä dokumenttia, joka on liian suuri koodattavaksi tehokkaasti kokonaisuutena; batchaus puolestaan käsittelee liian suurta määrää dokumentteja mahtuakseen yhteen pyyntöön. Kolmensadan sivun tekninen ohjekirja kuuluu ensimmäiseen kategoriaan, kahdenkymmenen tuhannen tukipyyntöjen vienti toiseen, ja todellinen projekti sisältää lähes aina molempia.

Batchaus: käsittely ryhmissä

mistral-embed-API hyväksyy syötelistan, mutta käytännön rajoituksia on olemassa (pyynnön koko, token-määrä). Ratkaisu on jakaa tietokantasi batcheihin ja käydä ne läpi silmukassa. Alla oleva funktio tekee juuri tämän ja näyttää edistymisen – kriittinen yksityiskohta, kun koko tietokannan koodaaminen vie useita minuutteja ja sinun on tiedettävä, eteneekö prosessi vai onko se jumissa.

import numpy as np
from mistralai.client import Mistral

client = Mistral(api_key=api_key)

def get_embeddings_by_chunks(data, chunk_size=25):
    """Koodaa suuri lista tekstejä batcheina."""
    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

# Esimerkki 1000 dokumentilla
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")

extend-metodin käyttäminen append:n sijaan varmistaa, että vektorien järjestys vastaa täsmälleen syötetekstien järjestystä. Tämä mahdollistaa alkuperäisen dokumentin hakemisen myöhemmin yksinkertaisen indeksin avulla.

Batch-koon optimointi

Optimaalinen batch-koko riippuu tekstiesi keskipituudesta: viisikymmentä artikkelin otsikkoa ja viisikymmentä koko raporttia eivät paina yhtä paljon tokeneina. Sen sijaan, että valitsisit vakion satunnaisesti, arvioi se suoraan tietokannasta.

def optimal_batch_size(documents, max_tokens_per_batch=16000):
    """Arvioi optimaalinen batch-koko."""
    # Karkea arvio: 1 token ~ 4 merkkiä englanniksi
    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)  # Katto 100:ssa

# Säädä tietokantasi perusteella
batch_size = optimal_batch_size(documents)
print(f"Recommended batch size: {batch_size}")

Katto 100:ssa ei ole kosmeettinen: sen ylittäminen tarkoittaa, että yhden batchin epäonnistuminen aiheuttaa merkittävän työmäärän menetyksen, ja vastauksen kuluttama muisti kasvaa huomattavaksi.

Palastelu: tekstin jakaminen

Pitkät tekstit on jaettava paloihin ennen koodausta. Useita strategioita on olemassa, joilla kullakin on omat etunsa, ja valinta vaikuttaa suoraan vastauksen laatuun: pala, joka alkaa keskeltä lausetta, tuottaa sumean vektorin, mikä johtaa sumeisiin hakutuloksiin.

Merkkiperusteinen jakaminen (yksinkertainen)

Suoraviivaisin menetelmä leikkaa joka N:s merkki sisällöstä välittämättä. Sen ansio on ennustettavuus ja nopeus, mikä tekee siitä hyväksyttävän prototyyppiä varten tai tekstille, jossa ei ole selkeää rakennetta.

def chunk_by_chars(text, chunk_size=2048, overlap=200):
    """Jaa teksti päällekkäisiin paloihin."""
    chunks = []
    start = 0
    while start < len(text):
        end = start + chunk_size
        chunk = text[start:end]
        chunks.append(chunk)
        start = end - overlap  # Päällekkäisyys kontekstin vuoksi
    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")

Kappaleperusteinen jakaminen (suositeltu)

Kappaleperusteinen jakaminen kunnioittaa kirjoittajan tarkoittamaa merkitysyksikköä. Tuotedokumentaatioissa jokainen kappale käsittelee yleensä tiettyä asiaa; sen pitäminen ehjänä tuottaa palan, joka pystyy vastaamaan kysymykseen itsenäisesti. Funktio kerää kappaleita, kunnes enimmäiskoko ylittyy, ja sulkee sitten nykyisen palan.

def chunk_by_paragraphs(text, max_chunk_size=2048):
    """Jaa kunnioittaen kappalerajoja."""
    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

Lauseperusteinen jakaminen

Kun tekstistä puuttuvat käyttökelpoiset kappaleet – kuten puhelun litterointi tai lokitiedosto – lauseesta tulee pienin käytettävissä oleva merkitysyksikkö. Jakaminen noudattaa tällöin samaa kerrytyslogiikkaa luottaen lauseen lopetusvälimerkkeihin.

import re

def chunk_by_sentences(text, max_chunk_size=1500):
    """Jaa kunnioittaen lauserajoja."""
    # Jaa lauseen lopetusvälimerkkien perusteella
    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

Päällekkäisyys

Palojen välinen päällekkäisyys estää ajatuksen leikkaamisen kahtia. Lisäämällä päällekkäisyyttä 10–20 % palan koosta säilytät kontekstin vierekkäisten osien välillä. Kuvittele toimenpide, jossa vaihe 4 päättyy merkkiin 2040 ja seuraus selitetään heti sen jälkeen: ilman päällekkäisyyttä mikään pala ei sisällä molempia puoliskoja päättelystä, eikä haku koskaan löydä täydellistä vastausta.

Alla olevat arvot toimivat todistettuina lähtökohtina sisältötyypistä riippuen:

# Suositellut parametrit sisältötyypin mukaan
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},
}

Keskustelut putoavat 500 merkkiin, koska puheenvuoro on lyhyt, ja suurempi pala sekoittaisi useita aiheita; koodi nousee 2000:een anteliaalla päällekkäisyydellä, koska funktio menettää merkityksensä, jos sen allekirjoitus erotetaan rungosta.

Täydellinen putki: Palastelu + Batchaus + Upotus

Näin yhdistät palastelun ja batchauksen tuotantoputkessa. Asia, jota et saa laiminlyödä, on chunk_metadata: ilman sitä saat orpovektoreita, jotka eivät pysty osoittamaan, mistä dokumentista ne ovat peräisin, etkä koskaan pysty viittaamaan lähteisiisi lopullisessa vastauksessa.

def pipeline_embed(documents, chunk_size=1500, overlap=200, batch_size=50):
    """Täydellinen putki: palastele, batchaa, upota."""
    # 1. Palastele kaikki dokumentit
    all_chunks = []
    chunk_metadata = []  # Seuraa lähdedokumenttia

    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. Koodaa batcheina
    embeddings = get_embeddings_by_chunks(all_chunks, chunk_size=batch_size)

    # 3. Palauta jäsennellyt tulokset
    return {
        "chunks": all_chunks,
        "embeddings": np.array(embeddings),
        "metadata": chunk_metadata,
    }

# Käyttö
result = pipeline_embed(documents)
print(f"Embeddings: {result['embeddings'].shape}")

Suorita tämä putki tusinalla omia dokumenttejasi ja tarkastele all_chunks silmämääräisesti ennen kuin koodaat mitään laajassa mittakaavassa. Huono jako näkyy välittömästi luettaessa, kun taas se ei koskaan ilmene matriisin muodossa.

Keskeiset asiat

  • Batchaus mahdollistaa tuhansien dokumenttien koodaamisen ylittämättä API-rajoituksia
  • Palastelu jakaa pitkät tekstit paremman semanttisen rakeisuuden saavuttamiseksi
  • 10–20 % päällekkäisyys palojen välillä säilyttää kontekstin
  • Kappale- tai lauseperusteinen jakaminen on suositeltavampaa kuin merkkiperusteinen
  • Säilytä metadata (lähdedokumentti, sijainti) jokaiselle palalle