Batching și Chunking
Pe această pagină
Provocarea volumelor mari
Când lucrați cu mii de documente, nu puteți codifica totul într-o singură apelare API. Trebuie să gestionați batching-ul (procesarea în grupuri) și chunking-ul (divizarea textului). Aceste două tehnici sunt esențiale pentru construirea sistemelor de căutare semantică la scară largă.
Cele două concepte sună similar, dar rezolvă probleme opuse. Chunking-ul gestionează un singur document care este prea mare pentru a fi codificat eficient în întregime; batching-ul gestionează prea multe documente pentru a încăpea într-o singură cerere. Un manual tehnic de trei sute de pagini se încadrează în prima categorie, un export de douăzeci de mii de tichete în a doua, iar un proiect din lumea reală implică aproape întotdeauna ambele.
Batching: Procesarea în grupuri
API-ul mistral-embed acceptă o listă de intrări, dar există limite practice (dimensiunea cererii, numărul de tokeni). Soluția este să divizați corpusul în loturi (batches) și să le parcurgeți iterativ. Funcția de mai jos face exact acest lucru, afișând progresul – un detaliu critic atunci când codificarea unui corpus complet durează câteva minute și trebuie să știți dacă procesul avansează sau este blocat.
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")
Utilizarea extend în loc de append asigură că ordinea vectorilor corespunde exact ordinii textelor de intrare. Acest lucru vă permite să recuperați documentul original pe baza unui index simplu mai târziu.
Optimizarea dimensiunii lotului (Batch Size)
Dimensiunea optimă a lotului depinde de lungimea medie a textelor dumneavoastră: cincizeci de titluri de articole și cincizeci de rapoarte complete nu au aceeași greutate în tokeni. În loc să alegeți o constantă la întâmplare, estimați-o direct din corpus.
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}")
Limitarea la 100 nu este cosmetică: dincolo de această valoare, un singur lot eșuat provoacă o pierdere semnificativă de muncă, iar memoria consumată de răspuns devine substanțială.
Chunking: Divizarea textului
Textele lungi trebuie divizate în chunk-uri înainte de codificare. Există mai multe strategii, fiecare cu avantajele sale, iar alegerea impactează direct calitatea răspunsului: un chunk care începe la mijlocul unei propoziții produce un vector neclar, ducând la rezultate de căutare imprecise.
Divizarea bazată pe caractere (Simplă)
Metoda cea mai directă taie la fiecare N caractere, indiferent de conținut. Meritul său este predictibilitatea și viteza, ceea ce o face acceptabilă pentru un prototip sau pentru texte fără o structură clară.
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")
Divizarea bazată pe paragrafe (Recomandată)
Divizarea bazată pe paragrafe respectă unitatea de sens intenționată de autor. În documentația de produs, fiecare paragraf acoperă, în general, un punct specific; menținerea intactă a acestuia produce un chunk capabil să răspundă singur la o întrebare. Funcția acumulează paragrafe până când dimensiunea maximă este depășită, apoi închide chunk-ul curent.
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
Divizarea bazată pe propoziții
Când textul nu conține paragrafe utilizabile – o transcriere a unui apel, un jurnal de activitate – propoziția devine cea mai mică unitate de sens disponibilă. Divizarea urmează apoi aceeași logică de acumulare, bazându-se pe semnele de punctuație de sfârșit de propoziție.
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
Suprapunerea (Overlap)
Suprapunerea dintre chunk-uri previne tăierea unei idei în două. Prin adăugarea unei suprapuneri de 10% până la 20% din dimensiunea chunk-ului, păstrați contextul între piesele adiacente. Imaginați-vă o procedură în care pasul 4 se termină la caracterul 2040, iar consecința este explicată imediat după: fără suprapunere, niciun chunk nu conține ambele jumătăți ale raționamentului, iar căutarea nu va recupera niciodată răspunsul complet.
Valorile de mai jos servesc drept puncte de plecare dovedite, în funcție de tipul de conținut:
# 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},
}
Conversațiile coboară la 500 de caractere deoarece o replică este scurtă, iar un chunk mai mare ar amesteca multiple subiecte; codul urcă la 2000 cu o suprapunere generoasă, deoarece o funcție își pierde sensul dacă semnătura sa este separată de corpul său.
Pipeline complet: Chunk + Batch + Embed
Iată cum să combinați chunking-ul și batching-ul într-un pipeline de producție. Elementul pe care nu trebuie să îl neglijați este chunk_metadata: fără acesta, obțineți vectori orfani incapabili să indice documentul din care provin, și nu veți putea niciodată să vă citați sursele în răspunsul final.
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}")
Rulați acest pipeline pe o duzină de documente reale și inspectați vizual all_chunks înainte de a codifica orice la scară largă. O divizare proastă este imediat vizibilă la citire, în timp ce nu apare niciodată în forma matricei.
Puncte cheie
- Batching-ul vă permite să codificați mii de documente fără a depăși limitele API
- Chunking-ul divizează textele lungi pentru o granularitate semantică mai bună
- O suprapunere de 10–20% între chunk-uri păstrează contextul
- Divizarea pe paragrafe sau propoziții este preferabilă divizării pe caractere
- Păstrați metadatele (document sursă, poziție) pentru fiecare chunk