Rühmitamine ja tükeldamine
Sellel lehel
Suurte mahtude väljakutse
Kui töötled tuhandeid dokumente, ei saa kõike ühe API väljakutsega kodeerida. Pead haldama rühmitamist (töötlemine gruppides) ja tükeldamist (teksti lõikamine). Need kaks tehnikat on hädavajalikud mastaapsete semantiliste otsingusüsteemide loomisel.
Need kaks mõistet kõlavad sarnaselt, kuid lahendavad vastupidiseid probleeme. Tükeldamine tegeleb üksiku dokumendiga, mis on liiga suur, et seda tervikuna efektiivselt kodeerida; rühmitamine tegeleb liiga paljude dokumentidega, et need ühte päringusse mahutada. Kolmesajaleheküljeline tehniline juhend kuulub esimesse kategooriasse, kakskümmend tuhat piletit sisaldav eksport teise ja reaalne projekt hõlmab peaaegu alati mõlemat.
Rühmitamine: töötlemine gruppides
mistral-embed API aktsepteerib sisendite loendit, kuid praktilised piirangud on olemas (päringu suurus, tokenite arv). Lahenduseks on oma korpuse jagamine rühmadeks ja nende läbikäimine tsüklis. Allpool olev funktsioon teebki just seda, kuvades edenemist – kriitiline detail, kui terve korpuse kodeerimine võtab mitu minutit ja pead teadma, kas protsess edeneb või on kinni jäänud.
import numpy as np
from mistralai.client import Mistral
client = Mistral(api_key=api_key)
def get_embeddings_by_chunks(data, chunk_size=25):
"""Kodeeri suur tekstide loend rühmades."""
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
# Näide 1000 dokumendiga
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 kasutamine append asemel tagab, et vektorite järjekord vastab täpselt sisendtekstide järjekorrale. See võimaldab hiljem lihtsa indeksi abil algse dokumendi kätte saada.
Rühma suuruse optimeerimine
Optimaalne rühma suurus sõltub sinu tekstide keskmisest pikkusest: viiskümmend artikli pealkirja ja viiskümmend täispikka raportit ei kaalu tokenites sama palju. Suvalise konstandi valimise asemel hinda seda otse korpuse põhjal.
def optimal_batch_size(documents, max_tokens_per_batch=16000):
"""Hinda optimaalset rühma suurust."""
# Ligikaudne hinnang: 1 token ~ 4 tähemärki inglise keeles
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) # Piira 100-ga
# Kohanda vastavalt oma korpusele
batch_size = optimal_batch_size(documents)
print(f"Recommended batch size: {batch_size}")
Piirang 100-le ei ole kosmeetiline: sellest suurema rühma korral põhjustab üks ebaõnnestunud partii märkimisväärset töökaotust ja vastuse tarbitav mälu muutub oluliseks.
Tükeldamine: teksti lõikamine
Pikad tekstid tuleb enne kodeerimist jagada tükkideks. Eksisteerib mitu strateegiat, millest ühel on oma eelised, ja valik mõjutab otseselt vastuse kvaliteeti: tükk, mis algab lause keskelt, tekitab hägusa vektori, mis viib hägusate otsingutulemusteni.
Tähemärgipõhine lõikamine (lihtne)
Kõige otsesem meetod lõikab iga N tähemärgi järel, sõltumata sisust. Selle voorus on ennustatavus ja kiirus, muutes selle vastuvõetavaks prototüübi jaoks või teksti puhul, millel puudub selge struktuur.
def chunk_by_chars(text, chunk_size=2048, overlap=200):
"""Jaga tekst tükkideks koos kattumisega."""
chunks = []
start = 0
while start < len(text):
end = start + chunk_size
chunk = text[start:end]
chunks.append(chunk)
start = end - overlap # Konteksti jaoks kattumine
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")
Lõigupõhine lõikamine (soovitatav)
Lõigupõhine lõikamine austab autori mõeldud tähendusüksust. Toote dokumentatsioonis käsitleb iga lõik üldjuhul kindlat punkti; selle tervikuna säilitamine annab tüki, mis suudab iseseisvalt küsimusele vastata. Funktsioon kogub lõike, kuni maksimaalne suurus ületatakse, ja sulgeb seejärel jooksva tüki.
def chunk_by_paragraphs(text, max_chunk_size=2048):
"""Jaga, austades lõigu piire."""
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
Lausepõhine lõikamine
Kui tekstis puuduvad kasutatavad lõigud – näiteks kõne transkript või jooksev logi – saab lausest väikseim olemasolev tähendusüksus. Lõikamine järgib siis sama kogumisloogikat, tuginedes lauselõpumärkidele.
import re
def chunk_by_sentences(text, max_chunk_size=1500):
"""Jaga, austades lause piire."""
# Lõika lauselõpumärkide järgi
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
Kattumine
Tükkide vaheline kattumine hoiab ära idee poolitamise. Lisades kattumist 10–20% tüki suurusest, säilitad konteksti kõrvutiasuvate osade vahel. Kujuta ette protseduuri, kus samm 4 lõpeb tähemärgil 2040 ja selle tagajärgi selgitatakse kohe pärast: ilma kattumiseta ei sisalda ükski tükk mõlemat arutluskäigu poolt ja otsing ei leia kunagi täielikku vastust.
Allpool toodud väärtused on tõestatud lähtepunktid sõltuvalt sisutüübist:
# Soovitatud parameetrid sisutüübi järgi
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},
}
Vestluste puhul langeb suurus 500 tähemärgini, sest kõnevoor on lühike ja suurem tükk segaks mitut teemat; koodi puhul tõuseb see 2000-ni koos helde kattumisega, sest funktsioon kaotab tähenduse, kui selle signatuur eraldatakse kehast.
Täielik torustik: tükelda + rühmita + loo manused
Siin on näide, kuidas kombineerida tükeldamist ja rühmitamist tootmises kasutatavas torustikus. Element, mida ei tohi unustada, on chunk_metadata: ilma selleta saad orbudeks jäänud vektorid, mis ei suuda näidata, millisest dokumendist need pärinevad, ja sa ei saa kunagi oma allikaid lõplikus vastuses tsiteerida.
def pipeline_embed(documents, chunk_size=1500, overlap=200, batch_size=50):
"""Täielik torustik: tükelda, rühmita, loo manused."""
# 1. Tükelda kõik dokumendid
all_chunks = []
chunk_metadata = [] # Jälgi lähtedokumenti
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. Kodeeri rühmades
embeddings = get_embeddings_by_chunks(all_chunks, chunk_size=batch_size)
# 3. Tagasta struktureeritud tulemused
return {
"chunks": all_chunks,
"embeddings": np.array(embeddings),
"metadata": chunk_metadata,
}
# Kasutamine
result = pipeline_embed(documents)
print(f"Embeddings: {result['embeddings'].shape}")
Käivita see torustik tosinale oma tegelikule dokumendile ja kontrolli all_chunks silmadega enne midagi suuremas mastaabis kodeerimist. Halb lõige on lugedes kohe nähtav, samas kui maatriksi kujus see kunagi ei ilmne.
Peamised punktid
- Rühmitamine võimaldab kodeerida tuhandeid dokumente, ületamata API piiranguid
- Tükeldamine jagab pikad tekstid parema semantilise granulaarsuse saavutamiseks
- 10–20% kattumine tükkide vahel säilitab konteksti
- Lõigu- või lausepõhine lõikamine on eelistatav tähemärgipõhisele
- Säilita iga tüki kohta metaandmed (lähtedokument, asukoht)