Ομαδοποίηση και Τμηματοποίηση
Σε αυτήν τη σελίδα
Η πρόκληση των μεγάλων όγκων δεδομένων
Όταν εργάζεστε με χιλιάδες έγγραφα, δεν μπορείτε να κωδικοποιήσετε τα πάντα σε μία μόνο κλήση API. Πρέπει να διαχειριστείτε την ομαδοποίηση (επεξεργασία σε ομάδες) και την τμηματοποίηση (διαίρεση κειμένου). Αυτές οι δύο τεχνικές είναι απαραίτητες για τη δημιουργία συστημάτων σημασιολογικής αναζήτησης σε μεγάλη κλίμακα.
Οι δύο έννοιες ακούγονται παρόμοιες, αλλά λύνουν αντίθετα προβλήματα. Η τμηματοποίηση διαχειρίζεται ένα μεμονωμένο έγγραφο που είναι πολύ μεγάλο για να κωδικοποιηθεί αποτελεσματικά ως σύνολο· η ομαδοποίηση διαχειρίζεται πάρα πολλά έγγραφα για να χωρέσουν σε ένα μόνο αίτημα. Ένα τεχνικό εγχειρίδιο τριακοσίων σελίδων εμπίπτει στην πρώτη κατηγορία, μια εξαγωγή είκοσι χιλιάδων εισιτηρίων στη δεύτερη, και ένα πραγματικό έργο σχεδόν πάντα περιλαμβάνει και τα δύο.
Ομαδοποίηση: Επεξεργασία σε ομάδες
Το API mistral-embed δέχεται μια λίστα εισόδων, αλλά υπάρχουν πρακτικά όρια (μέγεθος αιτήματος, αριθμός tokens). Η λύση είναι να διαιρέσετε το σώμα κειμένου σας σε ομάδες και να τις επεξεργαστείτε με επανάληψη. Η παρακάτω συνάρτηση κάνει ακριβώς αυτό, εμφανίζοντας την πρόοδο — μια κρίσιμη λεπτομέρεια όταν η κωδικοποίηση ενός πλήρους σώματος κειμένου διαρκεί αρκετά λεπτά και χρειάζεται να ξέρετε αν η διαδικασία προχωρά ή έχει κολλήσει.
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")
Η χρήση της extend αντί της append διασφαλίζει ότι η σειρά των διανυσμάτων ταιριάζει ακριβώς με τη σειρά του κειμένου εισόδου. Αυτό σας επιτρέπει να ανακτήσετε το αρχικό έγγραφο από έναν απλό δείκτη αργότερα.
Βελτιστοποίηση του μεγέθους της ομάδας
Το βέλτιστο μέγεθος ομάδας εξαρτάται από το μέσο μήκος των κειμένων σας: πενήντα τίτλοι άρθρων και πενήντα πλήρεις αναφορές δεν έχουν το ίδιο βάρος σε tokens. Αντί να επιλέξετε μια σταθερά τυχαία, εκτιμήστε την από το ίδιο το σώμα κειμένου.
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}")
Το όριο στο 100 δεν είναι διακοσμητικό: πέρα από αυτό, μια αποτυχημένη ομάδα προκαλεί σημαντική απώλεια εργασίας και η μνήμη που καταναλώνεται από την απόκριση γίνεται ουσιαστική.
Τμηματοποίηση: Διαίρεση κειμένου
Τα μεγάλα κείμενα πρέπει να χωρίζονται σε τμήματα πριν από την κωδικοποίηση. Υπάρχουν διάφορες στρατηγικές, η καθεμία με τα πλεονεκτήματά της, και η επιλογή επηρεάζει άμεσα την ποιότητα της απόκρισης: ένα τμήμα που ξεκινά στη μέση μιας πρότασης παράγει ένα θολό διάνυσμα, οδηγώντας σε θολά αποτελέσματα αναζήτησης.
Διαίρεση βάσει χαρακτήρων (Απλή)
Η πιο άμεση μέθοδος κόβει κάθε N χαρακτήρες, ανεξάρτητα από το περιεχόμενο. Το πλεονέκτημά της είναι η προβλεψιμότητα και η ταχύτητα, καθιστώντας την αποδεκτή για ένα πρωτότυπο ή για κείμενο χωρίς σαφή δομή.
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")
Διαίρεση βάσει παραγράφων (Συνιστώμενη)
Η διαίρεση βάσει παραγράφων σέβεται τη μονάδα νοήματος που προορίζεται από τον συγγραφέα. Στην τεκμηρίωση προϊόντων, κάθε παράγραφος καλύπτει γενικά ένα συγκεκριμένο σημείο· η διατήρησή της άθικτη αποδίδει ένα τμήμα που μπορεί να απαντήσει σε μια ερώτηση από μόνο του. Η συνάρτηση συσσωρεύει παραγράφους μέχρι να ξεπεραστεί το μέγιστο μέγεθος και στη συνέχεια κλείνει το τρέχον τμήμα.
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
Διαίρεση βάσει προτάσεων
Όταν το κείμενο στερείται χρήσιμων παραγράφων —όπως μια μεταγραφή κλήσης ή ένα ημερολόγιο εκτέλεσης— η πρόταση γίνεται η μικρότερη διαθέσιμη μονάδα νοήματος. Η διαίρεση ακολουθεί τότε την ίδια λογική συσσώρευσης, βασιζόμενη στη στίξη τέλους πρότασης.
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
Επικάλυψη
Η επικάλυψη μεταξύ των τμημάτων αποτρέπει τη διακοπή μιας ιδέας στη μέση. Προσθέτοντας μια επικάλυψη 10% έως 20% του μεγέθους του τμήματος, διατηρείτε το πλαίσιο μεταξύ γειτονικών κομματιών. Φανταστείτε μια διαδικασία όπου το βήμα 4 τελειώνει στον χαρακτήρα 2040 και η συνέπεια εξηγείται αμέσως μετά: χωρίς επικάλυψη, κανένα τμήμα δεν περιέχει και τα δύο μισά του συλλογισμού και η αναζήτηση δεν θα ανακτήσει ποτέ την πλήρη απάντηση.
Οι παρακάτω τιμές χρησιμεύουν ως αποδεδειγμένα σημεία εκκίνησης ανάλογα με τον τύπο του περιεχομένου:
# 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},
}
Οι συνομιλίες μειώνονται στους 500 χαρακτήρες επειδή μια στροφή ομιλίας είναι σύντομη και ένα μεγαλύτερο τμήμα θα ανάμειγε πολλαπλά θέματα· ο κώδικας αυξάνεται στους 2000 με γενναιόδωρη επικάλυψη επειδή μια συνάρτηση χάνει το νόημά της αν η υπογραφή της διαχωριστεί από το σώμα της.
Πλήρης ροή εργασίας: Τμηματοποίηση + Ομαδοποίηση + Ενσωμάτωση
Ιδού πώς συνδυάζετε την τμηματοποίηση και την ομαδοποίηση σε μια ροή εργασίας παραγωγής. Το στοιχείο που δεν πρέπει να παραλείψετε είναι τα chunk_metadata: χωρίς αυτά, λαμβάνετε ορφανά διανύσματα ανίκανα να υποδείξουν από ποιο έγγραφο προέρχονται και δεν θα μπορέσετε ποτέ να αναφέρετε τις πηγές σας στην τελική απόκριση.
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}")
Εκτελέστε αυτή τη ροή εργασίας σε μια δωδεκάδα από τα πραγματικά σας έγγραφα και επιθεωρήστε οπτικά τα all_chunks πριν κωδικοποιήσετε οτιδήποτε σε μεγάλη κλίμακα. Μια κακή διαίρεση είναι άμεσα ορατή κατά την ανάγνωση, ενώ δεν εμφανίζεται ποτέ στο σχήμα του πίνακα.
Βασικά σημεία
- Η ομαδοποίηση σας επιτρέπει να κωδικοποιήσετε χιλιάδες έγγραφα χωρίς να υπερβείτε τα όρια του API
- Η τμηματοποίηση διαιρεί τα μεγάλα κείμενα για καλύτερη σημασιολογική κοκκοποίηση
- Μια επικάλυψη 10–20% μεταξύ των τμημάτων διατηρεί το πλαίσιο
- Η διαίρεση βάσει παραγράφων ή προτάσεων είναι προτιμότερη από τη διαίρεση βάσει χαρακτήρων
- Διατηρήστε μεταδεδομένα (πηγαίο έγγραφο, θέση) για κάθε τμήμα