Pāriet uz galveno saturu
Latviešu— Izvēlēties valodu
Izvēlne

Grupēšana un sadalīšana fragmentos

Nodarbība 4 no 18 Atjaunota 2026. gada 2. novembris Programmētājs
Šajā lapā
  1. Liela apjoma datu radītie izaicinājumi
  2. Grupēšana: apstrāde pa grupām
  3. Sadalīšana fragmentos: teksta dalīšana
  4. Pārklāšanās
  5. Pilna cauruļvada darbība: sadalīšana + grupēšana + iegulēšana
  6. Galvenās atziņas

Liela apjoma datu radītie izaicinājumi

Strādājot ar tūkstošiem dokumentu, tu nevari visu kodēt vienā API izsaukumā. Tev ir jāpārvalda grupēšana (apstrāde pa grupām) un sadalīšana fragmentos (teksta dalīšana). Šīs divas tehnikas ir būtiskas, lai mērogojamā līmenī izveidotu semantiskās meklēšanas sistēmas.

Abi jēdzieni skan līdzīgi, bet risina pretējas problēmas. Sadalīšana fragmentos attiecas uz vienu dokumentu, kas ir pārāk liels, lai to efektīvi kodētu kā veselu; grupēšana attiecas uz pārāk daudziem dokumentiem, lai tie ietilptu vienā pieprasījumā. Trīs simtu lappušu biezs tehniskais rokasgrāmata ietilpst pirmajā kategorijā, divdesmit tūkstošu biļešu eksports — otrajā, un reāls projekts gandrīz vienmēr ietver abus aspektus.

Grupēšana: apstrāde pa grupām

mistral-embed API pieņem ievades sarakstu, taču pastāv praktiski ierobežojumi (pieprasījuma lielums, tokena skaits). Risinājums ir sadalīt savu korpusu grupās un iterēt caur tām. Zemāk esošā funkcija dara tieši to, parādot progresu — kritiski svarīga detaļa, kad visa korpusa kodēšana aizņem vairākas minūtes un tev ir jāzina, vai process virzās uz priekšu vai ir iestrēdzis.

import numpy as np
from mistralai.client import Mistral

client = Mistral(api_key=api_key)

def get_embeddings_by_chunks(data, chunk_size=25):
    """Kodē lielu tekstu sarakstu pa grupām."""
    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

# Piemērs ar 1000 dokumentiem
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")

Izmantojot extend append vietā, tu nodrocini, ka vektoru secība precīzi atbilst ievades teksta secībai. Tas ļauj vēlāk no vienkārša indeksa izgūt oriģinālo dokumentu.

Grupas lieluma optimizēšana

Optimālais grupas lielums ir atkarīgs no tava teksta vidējā garuma: piecdesmit rakstu virsraksti un piecdesmit pilni ziņojumi tokenos nesver vienādi. Tā vietā, lai nejauši izvēlētos konstanti, aprēķini to, balstoties uz pašu korpusu.

def optimal_batch_size(documents, max_tokens_per_batch=16000):
    """Aprēķina optimālo grupas lielumu."""
    # Aptuvens aprēķins: 1 tokens ~ 4 rakstzīmes angļu valodā
    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)  # Ierobežojums līdz 100

# Pielāgo atbilstoši savam korpusam
batch_size = optimal_batch_size(documents)
print(f"Recommended batch size: {batch_size}")

Ierobežojums līdz 100 nav tikai kosmetisks: pārsniedzot to, viena neizdevusies grupa rada ievērojamu darba zudumu, un atbildes patērētā atmiņa kļūst būtiska.

Sadalīšana fragmentos: teksta dalīšana

Gari teksti pirms kodēšanas ir jāsadaļ fragmentos. Pastāv vairākas stratēģijas, katrai ir savas priekšrocības, un izvēle tieši ietekmē atbildes kvalitāti: fragments, kas sākas teikuma vidū, rada „miglainu” vektoru, kas noved pie neprecīziem meklēšanas rezultātiem.

Dalīšana pēc rakstzīmēm (vienkārša)

Visdirektākā metode nogriež ik pēc N rakstzīmēm, neatkarīgi no satura. Tās vērtība ir paredzamība un ātrums, padarot to pieņemamu prototipam vai tekstam bez skaidras struktūras.

def chunk_by_chars(text, chunk_size=2048, overlap=200):
    """Sadaļa tekstu fragmentos ar pārklāšanos."""
    chunks = []
    start = 0
    while start < len(text):
        end = start + chunk_size
        chunk = text[start:end]
        chunks.append(chunk)
        start = end - overlap  # Pārklāšanās konteksta nodrošināšanai
    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")

Dalīšana pēc rindkopām (ieteicama)

Dalīšana pēc rindkopām ievēro autora domāto nozīmes vienību. Produkta dokumentācijā katra rindkopa parasti aptver konkrētu punktu; saglabājot to neskartu, iegūst fragmentu, kas spēj patstāvīgi atbildēt uz jautājumu. Funkcija uzkrāj rindkopas, līdz tiek pārsniegts maksimālais lielums, pēc tam noslēdz pašreizējo fragmentu.

def chunk_by_paragraphs(text, max_chunk_size=2048):
    """Sadaļa, ievērojot rindkopu robežas."""
    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

Dalīšana pēc teikumiem

Kad tekstā trūkst izmantojamu rindkopu — piemēram, sarunas transkripts vai darbības žurnāls — teikums kļūst par mazāko pieejamo nozīmes vienību. Sadalīšana tad seko tai pašai uzkrāšanas loģikai, paļaujoties uz teikuma beigu interpunkciju.

import re

def chunk_by_sentences(text, max_chunk_size=1500):
    """Sadaļa, ievērojot teikumu robežas."""
    # Sadalīšana pie teikuma beigu interpunkcijas zīmēm
    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ārklāšanās

Pārklāšanās starp fragmentiem novērš idejas pārgriešanu uz pusēm. Pievienojot pārklāšanos 10–20% apjomā no fragmenta lieluma, tu saglabā kontekstu starp blakus esošajiem gabaliem. Iedomājies procedūru, kur 4. solis beidzas pie 2040. rakstzīmes, bet sekas tiek skaidrotas tūlīt pēc tam: bez pārklāšanās neviens fragments nesatur abas sprieduma puses, un meklēšana nekad neatradīs pilnu atbildi.

Zemāk redzamās vērtības kalpo kā pierādīti sākumpunkti atkarībā no satura veida:

# Ieteicamie parametri pēc satura veida
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},
}

Sarunām lielums samazinās līdz 500 rakstzīmēm, jo runas pagrieziens ir īss, un lielāks fragments sajauktu vairākas tēmas; kodam tas pieaug līdz 2000 ar щеdru pārklāšanos, jo funkcija zaudē jēgu, ja tās signatūra tiek atdalīta no ķermeņa.

Pilna cauruļvada darbība: sadalīšana + grupēšana + iegulēšana

Lūk, kā apvienot sadalīšanu fragmentos un grupēšanu ražošanas cauruļvadā. Elements, ko nedrīkst aizmirst, ir chunk_metadata: bez tā tu iegūsti „bāreņu” vektorus, kas nespēj norādīt, no kura dokumenta tie nāk, un tu nekad nevarēsi citēt savus avotus galīgajā atbildē.

def pipeline_embed(documents, chunk_size=1500, overlap=200, batch_size=50):
    """Pilns cauruļvads: sadalīšana, grupēšana, iegulēšana."""
    # 1. Sadaļa visus dokumentus fragmentos
    all_chunks = []
    chunk_metadata = []  # Izseko avota dokumentu

    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. Kodē pa grupām
    embeddings = get_embeddings_by_chunks(all_chunks, chunk_size=batch_size)

    # 3. Atgriež strukturētus rezultātus
    return {
        "chunks": all_chunks,
        "embeddings": np.array(embeddings),
        "metadata": chunk_metadata,
    }

# Lietošana
result = pipeline_embed(documents)
print(f"Embeddings: {result['embeddings'].shape}")

Palaid šo cauruļvadu ar duci savu reālo dokumentu un vizuāli pārbaudi all_chunks pirms jebkādas kodēšanas lielos apjomos. Slikta sadalīšana ir uzreiz redzama, lasot tekstu, turpretī matricas formā tā nekad neparādās.

Galvenās atziņas

  • Grupēšana ļauj kodēt tūkstošiem dokumentu, nepārsniedzot API limitus
  • Sadalīšana fragmentos sadala garus tekstus labākai semantiskai granularitātei
  • 10–20% pārklāšanās starp fragmentiem saglabā kontekstu
  • Dalīšana pēc rindkopām vai teikumiem ir vēlamāka nekā dalīšana pēc rakstzīmēm
  • Katram fragmentam saglabā metadatus (avota dokuments, pozīcija)