Grupavimas ir skaidymas į dalis
Šiame puslapyje
Didelių duomenų apimčių iššūkis
Kai dirbi su tūkstančiais dokumentų, negali visko užkoduoti vienu API užklausimu. Turi valdyti grupavimą (apdorojimą grupėmis) ir skaidymą į dalis (teksto dalijimą). Šie du metodai yra būtini kuriant semantinės paieškos sistemas dideliu mastu.
Šios dvi sąvokos skamba panašiai, tačiau sprendžia priešingus uždavinius. Skaidymas į dalis tvarko vieną dokumentą, kuris per didelis, kad būtų veiksmingai užkoduotas visas; grupavimas tvarko per daug dokumentų, kad tilptų į vieną užklausą. Trijų šimtų puslapių techninis vadovas patenka į pirmąją kategoriją, dvidešimties tūkstančių bilietų eksportas – į antrąją, o realus projektas beveik visada apima abu.
Grupavimas: apdorojimas grupėmis
mistral-embed API priima įvesties sąrašą, tačiau egzistuoja praktiniai limitai (užklausos dydis, tokenų skaičius). Sprendimas – padalyti savo korpusą į grupes ir jas apdoroti cikle. Toliau pateikta funkcija tai ir daro, rodydama eigą – tai kritinė detalė, kai viso korpuso kodavimas trunka kelias minutes ir tau reikia žinoti, ar procesas vyksta, ar užstrigo.
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")
Naudojant extend vietoj append, užtikrinama, kad vektorių eilė tiksliai atitiktų įvesties teksto eilę. Tai leidžia vėliau iš paprasto indekso atkurti originalų dokumentą.
Grupės dydžio optimizavimas
Optimalus grupės dydis priklauso nuo vidutinio tavo tekstų ilgio: penkiasdešimt straipsnių pavadinimų ir penkiasdešimt pilnų ataskaitų sveria skirtingai tokenais. Vietoj to, kad atsitiktinai pasirinktum konstantą, įvertink ją iš paties korpuso.
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}")
Ribojimas iki 100 nėra kosmetinis: viršijus šią ribą, viena nepavykusi grupė sukelia didelį darbo nuostolį, o atsakymui sunaudojama atmintis tampa reikšminga.
Skaidymas į dalis: teksto dalijimas
Ilgi tekstai prieš koduojant turi būti suskaidyti į dalis. Egzistuoja kelios strategijos, kiekviena turi savo privalumų, o pasirinkimas tiesiogiai veikia atsakymų kokybę: dalis, prasidedanti sakinio viduryje, sukuria „neryškų“ vektorių, dėl ko paieškos rezultatai taip pat bus neryškūs.
Skaidymas pagal simbolius (paprastas)
Paprasčiausias metodas kerta kas N simbolių, neatsižvelgiant į turinį. Jo privalumas – nuspėjamumas ir greitis, todėl jis tinka prototipams arba tekstams be aiškios struktūros.
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")
Skaidymas pagal pastraipas (rekomenduojama)
Skaidymas pagal pastraipas gerbia autoriaus numatytą prasmės vienetą. Produkto dokumentacijoje kiekviena pastraipa paprastai apima konkretų punktą; palikus ją vientisą, gaunama dalis, kuri gali savarankiškai atsakyti į klausimą. Funkcija kaupia pastraipas, kol viršijamas maksimalus dydis, tada užbaigia esamą dalį.
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
Skaidymas pagal sakinius
Kai tekste nėra tinkamų pastraipų – pokalbio stenograma, veiksmų žurnalas – sakinys tampa mažiausiu prieinamu prasmės vienetu. Tuomet skaidymas laikosi tos pačios kaupimo logikos, remdamasis sakinio pabaigos skyrybos ženklais.
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
Persidengimas
Persidengimas tarp dalių neleidžia perkirsti minties pusiau. Pridėjus persidengimą, sudarantį 10–20 % dalies dydžio, išsaugomas kontekstas tarp gretimų dalių. Įsivaizduok procedūrą, kurioje 4 žingsnis baigiasi 2040-uoju simboliu, o pasekmė paaiškinama iškart po to: be persidengimo jokia dalis neturėtų abiejų samprotavimo pusių, ir paieška niekada neatrastų pilno atsakymo.
Toliau pateiktos vertės yra patikimi pradiniai taškai, priklausomai nuo turinio tipo:
# 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},
}
Pokalbiams sumažinama iki 500 simbolių, nes kalbos posakis trumpas, o didesnė dalis sumaišytų kelias temas; kodui didinama iki 2000 su dideliu persidengimu, nes funkcija praranda prasmę, jei jos parašas atskirtas nuo kūno.
Pilna grandinė: skaidymas + grupavimas + įterpimas
Štai kaip sujungti skaidymą į dalis ir grupavimą gamybinėje grandinėje. Elementas, kurio negali ignoruoti, yra chunk_metadata: be jo gausi „našlaičius“ vektorius, negalinčius nurodyti, iš kurio dokumento jie kilę, ir niekada negalėsi cituoti savo šaltinių galutiniame atsakyme.
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}")
Paleisk šią grandinę su keliolika savo realių dokumentų ir vizualiai patikrink all_chunks prieš koduodamas dideliu mastu. Blogas skaidymas iškart matomas skaitant, tuo tarpu matricos formoje jis niekada nepasirodo.
Svarbiausi punktai
- Grupavimas leidžia užkoduoti tūkstančius dokumentų neviršijant API limitų
- Skaidymas į dalis suskaido ilgus tekstus geresnei semantinei granuliarumui pasiekti
- 10–20 % persidengimas tarp dalių išsaugo kontekstą
- Skaidymas pagal pastraipas ar sakinius yra pageidautinesnis nei skaidymas pagal simbolius
- Kiekvienai daliai išsaugok metaduomenis (šaltinio dokumentą, poziciją)