Pereiti prie pagrindinio turinio
Lietuvių— Pasirinkite kalbą
Meniu

Grupavimas ir skaidymas į dalis

Paskaita 4 iš 18 Atnaujinta 2026 m. lapkričio 2 d. Kūrėjas
Šiame puslapyje
  1. Didelių duomenų apimčių iššūkis
  2. Grupavimas: apdorojimas grupėmis
  3. Skaidymas į dalis: teksto dalijimas
  4. Persidengimas
  5. Pilna grandinė: skaidymas + grupavimas + įterpimas
  6. Svarbiausi punktai

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