Batchaus ja paloitteleminen
Tällä sivulla
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