Μετάβαση στο κύριο περιεχόμενο
Ελληνικά— Επιλέξτε γλώσσα
Μενού

Δημιουργία Ενσωματώσεων (Embeddings)

Μάθημα 11 / 18 Ενημερώθηκε 2 Νοεμβρίου 2026 Για developers
Σε αυτήν τη σελίδα
  1. Κωδικοποίηση Τμημάτων σε Διανύσματα
  2. Κωδικοποίηση κατά Παρτίδες (Batch Encoding)
  3. Αντιμετώπιση Σφαλμάτων Δικτύου
  4. Αποθήκευση του Ευρετηρίου στον Δίσκο
  5. Επαλήθευση Πριν τη Συνέχεια
  6. Βασικά σημεία

Κωδικοποίηση Τμημάτων σε Διανύσματα

Τα έγγραφά σας είναι πλέον χωρισμένα σε καθαρά τμήματα. Το επόμενο βήμα είναι να τα μετατρέψετε σε ενσωματώσεις (embeddings) χρησιμοποιώντας το API mistral-embed και στη συνέχεια να αποθηκεύσετε αυτά τα διανύσματα σε μια αποθήκη διανυσμάτων που θα λειτουργήσει ως μηχανή αναζήτησής σας. Αυτή είναι η στιγμή που το σώμα κειμένων σας παύει να είναι απλό κείμενο και μετατρέπεται σε ερωτήσιμη γεωμετρία. Μερικές προφυλάξεις μηχανικού—ομαδοποίηση (batching), επαναλήψεις (retries) και επιμονή δεδομένων—κάνουν τη διαφορά μεταξύ ενός εύθραυστου πρωτοτύπου και ενός αξιόπιστου ευρετηρίου.

Για ένα μικρό σώμα κειμένων, ας πούμε λιγότερα από εκατό τμήματα, αρκεί μια απλή άμεση κλήση. Εξάγετε το κείμενο από τα λεξικά των τμημάτων σας, τα περνάτε ως έχουν στο API και ανακτάτε τον πλήρη πίνακα. Το σχήμα (87, 1024) που εμφανίζεται στο τέλος της εκτέλεσης είναι ο πρώτος σας έλεγχος ορθότητας: τόσες σειρές όσα και τα τμήματα, και 1024 στήλες επειδή αυτή είναι η διάσταση του mistral-embed. Αν ο αριθμός των σειρών δεν ταιριάζει, κάποιο κενό τμήμα γλίστρησε στην παρτίδα.

import numpy as np
from mistralai.client import Mistral

client = Mistral(api_key=api_key)

# Assume chunks is the list of our prepared chunks
chunk_texts = [c["text"] for c in chunks]

# Encode in a single call
response = client.embeddings.create(
    model="mistral-embed",
    inputs=chunk_texts,
)

embeddings = np.array([d.embedding for d in response.data])
print(f"Embeddings: {embeddings.shape}")
# Embeddings: (87, 1024) for example

Κωδικοποίηση κατά Παρτίδες (Batch Encoding)

Πέρα από μερικές δεκάδες τμήματα, μια απλή κλήση χτυπά τα όρια του API. Η λύση είναι να χωρίσετε τη λίστα σε παρτίδες και να συνενώσετε τα αποτελέσματα. Η παρακάτω συνάρτηση επεξεργάζεται τμήματα των 25 και εμφανίζει την πρόοδο. Αυτό δεν είναι απλώς αισθητικό: σε ένα σώμα κειμένων αρκετών χιλιάδων τμημάτων, η κωδικοποίηση διαρκεί αρκετά λεπτά και θα θέλετε να ξέρετε πού βρίσκεται η διαδικασία αντί να κοιτάζετε ένα σιωπηλό τερματικό. Η σειρά διατηρείται, ώστε κάθε διάνυσμα να παραμένει ευθυγραμμισμένο με το αντίστοιχο τμήμα του στην αρχική σας λίστα.

def encode_chunks(chunks, batch_size=25, model="mistral-embed"):
    """Encode a list of chunks in batches."""
    texts = [c["text"] for c in chunks]
    all_embeddings = []

    for i in range(0, len(texts), batch_size):
        batch = texts[i:i + batch_size]
        print(f"  Encoding batch {i // batch_size + 1}/{(len(texts) - 1) // batch_size + 1} "
              f"({len(batch)} chunks)...")

        response = client.embeddings.create(
            model=model,
            inputs=batch,
        )
        all_embeddings.extend([d.embedding for d in response.data])

    return np.array(all_embeddings)

# Encode all chunks
embeddings = encode_chunks(chunks, batch_size=25)
print(f"Total: {embeddings.shape[0]} vectors of {embeddings.shape[1]} dimensions")

Αντιμετώπιση Σφαλμάτων Δικτύου

Σε περιβάλλον παραγωγής, μια κλήση API θα αποτύχει τελικά: πτώση δικτύου, επίτευξη ορίου ρυθμού (rate limit) ή προσωρινή διακοπή λειτουργίας. Χωρίς προστασία, η ευρετηρίασή σας σταματά στην παρτίδα 180 από τις 400 και επιστρέφετε στο μηδέν. Η robust έκδοση τυλίγει κάθε παρτίδα σε έναν βρόχο επανάληψης με εκθετική καθυστέρηση (exponential backoff)—ένα δευτερόλεπτο, μετά δύο, μετά τέσσερα. Αυτή η αυξανόμενη απόσταση έχει σημασία: η άμεση επανάληψη μετά από απόρριψη λόγω ορίου επιδεινώνει μόνο την κατάσταση. Μετά από τρεις διαδοχικές αποτυχίες, η συνάρτηση εγείρει μια ρητή εξαίρεση που ονομάζει την ελαττωματική παρτίδα, αντί να επιστρέψει έναν περικομμένο πίνακα όπου θα ανακαλύπτατε το κενό μόνο κατά την αναζήτηση.

import time

def encode_chunks_robust(chunks, batch_size=25, max_retries=3):
    """Robust encoding with error handling."""
    texts = [c["text"] for c in chunks]
    all_embeddings = []

    for i in range(0, len(texts), batch_size):
        batch = texts[i:i + batch_size]

        for attempt in range(max_retries):
            try:
                response = client.embeddings.create(
                    model="mistral-embed",
                    inputs=batch,
                )
                all_embeddings.extend([d.embedding for d in response.data])
                break  # Success, exit retry loop

            except Exception as e:
                wait_time = 2 ** attempt  # Exponential backoff: 1s, 2s, 4s
                print(f"  Error in batch {i // batch_size + 1}, "
                      f"attempt {attempt + 1}/{max_retries}: {e}")
                if attempt < max_retries - 1:
                    print(f"  Waiting {wait_time}s before retry...")
                    time.sleep(wait_time)
                else:
                    raise RuntimeError(
                        f"Failed after {max_retries} attempts for batch {i // batch_size + 1}"
                    )

    return np.array(all_embeddings)

Αποθήκευση του Ευρετηρίου στον Δίσκο

Κάθε εκτέλεση κωδικοποίησης κοστίζει χρόνο και χρεώσιμες κλήσεις API. Ο επανυπολογισμός των διανυσμάτων κάθε φορά που ξεκινά η εφαρμογή σας είναι καθαρή σπατάλη, ειδικά αφού το ίδιο το σώμα κειμένων δεν έχει αλλάξει. Η αποθήκευση γίνεται σε δύο συμπληρωματικά αρχεία: τα διανύσματα πηγαίνουν στο NumPy, μια συμπαγή δυαδική μορφή που φορτώνει ακαριαία, ενώ τα μεταδεδομένα—κείμενο, πηγή, θέση—πηγαίνουν σε αναγνώσιμο JSON που μπορείτε να ανοίξετε για να επιθεωρήσετε ένα ύποπτο τμήμα. Τα δύο αρχεία είναι αλληλοεξαρτώμενα, συνδεδεμένα μέσω της σειράς των γραμμών: μην αναπαράγετε ποτέ το ένα χωρίς το άλλο, ή τα αποτελέσματα αναζήτησής σας θα δείχνουν στα λάθος κείμενα.

import json

def save_index(chunks, embeddings, filepath="rag_index"):
    """Save chunks and embeddings."""
    # Save embeddings (NumPy)
    np.save(f"{filepath}_embeddings.npy", embeddings)

    # Save metadata (JSON)
    metadata = []
    for c in chunks:
        metadata.append({
            "text": c["text"],
            "source": c.get("source", ""),
            "chunk_index": c.get("chunk_index", 0),
        })
    with open(f"{filepath}_metadata.json", "w", encoding="utf-8") as f:
        json.dump(metadata, f, ensure_ascii=False, indent=2)

    print(f"Index saved: {len(chunks)} chunks, {embeddings.shape}")


def load_index(filepath="rag_index"):
    """Load chunks and embeddings from disk."""
    embeddings = np.load(f"{filepath}_embeddings.npy")

    with open(f"{filepath}_metadata.json", "r", encoding="utf-8") as f:
        metadata = json.load(f)

    print(f"Index loaded: {len(metadata)} chunks, {embeddings.shape}")
    return metadata, embeddings

# Save
save_index(chunks, embeddings)

# Load (on next startup)
chunks_loaded, embeddings_loaded = load_index()

Επαλήθευση Πριν τη Συνέχεια

Ένα σιωπηλά κατεστραμμένο ευρετήριο εμφανίζεται αργά, συνήθως όταν ένας χρήστης αναφέρει μια παράλογη απάντηση. Μερικοί έλεγχοι εκτός σύνδεσης παίρνουν τριάντα δευτερόλεπτα και σας γλιτώνουν από αυτή την ανακάλυψη. Η συνάρτηση επαλήθευσης εμφανίζει πρώτα βασικές μετρικές—αριθμός τμημάτων, διάσταση, μέσος όρος νόρμας—και στη συνέχεια μετρά την ομοιότητα μεταξύ γειτονικών τμημάτων: καθώς προέρχονται από το ίδιο έγγραφο, θα πρέπει να εμφανίζουν σημαντικά υψηλότερες τιμές από δύο τυχαία αποσπάσματα. Η τελευταία δοκιμή είναι η απλούστερη και η πιο αποκαλυπτική: ένα τμήμα συγκρινόμενο με τον εαυτό του πρέπει να δίνει ακριβώς 1.0. Οποιαδήποτε άλλη τιμή σηματοδοτεί πρόβλημα ευθυγράμμισης ή αριθμητικής μετατροπής.

from sklearn.metrics.pairwise import cosine_similarity

def verify_embeddings(chunks, embeddings, n_tests=5):
    """Verify embedding quality with simple tests."""
    print("=== Verifying embeddings ===")
    print(f"Number of chunks: {len(chunks)}")
    print(f"Dimensions: {embeddings.shape[1]}")
    print(f"Average norm: {np.linalg.norm(embeddings, axis=1).mean():.4f}")

    # Test: chunks from the same document should be closer
    for i in range(min(n_tests, len(chunks) - 1)):
        sim = cosine_similarity([embeddings[i]], [embeddings[i + 1]])[0][0]
        print(f"  Similarity chunk {i} <-> {i+1}: {sim:.4f}")

    # Test: a chunk compared to itself = 1.0
    self_sim = cosine_similarity([embeddings[0]], [embeddings[0]])[0][0]
    print(f"  Self-similarity (must be 1.0): {self_sim:.6f}")

verify_embeddings(chunks, embeddings)

Συνδυασμένα, η ροή εργασίας συμπυκνώνεται σε τέσσερις χρήσιμες γραμμές. Προετοιμάζετε τα τμήματα με τη διαδικασία του προηγούμενου μαθήματος, κωδικοποιείτε σε robust λειτουργία, επαληθεύετε και αποθηκεύετε. Αυτό είναι το σενάριο που θα εκτελείτε ξανά κάθε φορά που ενημερώνεται το σώμα κειμένων.

# 1. Prepare chunks (previous lesson)
chunks = prepare_documents(raw_docs)

# 2. Encode
embeddings = encode_chunks_robust(chunks, batch_size=25)

# 3. Verify
verify_embeddings(chunks, embeddings)

# 4. Save
save_index(chunks, embeddings)

print("Index ready for search!")

Βασικά σημεία

  • Χρησιμοποιήστε ομαδοποίηση (batching) για την κωδικοποίηση μεγάλων σωμάτων κειμένων (παρτίδες 25–50 τμημάτων)
  • Προσθέστε λογική επανάληψης με εκθετική καθυστέρηση (exponential backoff) για ευρωστία
  • Αποθηκεύστε τις ενσωματώσεις στον δίσκο (NumPy) για να αποφύγετε τον επανυπολογισμό
  • Διατηρήστε τα μεταδεδομένα (κείμενο, πηγή, θέση) σε ξεχωριστό αρχείο JSON
  • Επαληθεύστε την ποιότητα των ενσωματώσεων πριν τις χρησιμοποιήσετε σε παραγωγή