Ugrás a főtartalomra
Magyar— Nyelv kiválasztása
Menü

Beágyazások létrehozása

11. lecke 18 közül Frissítve 2026. november 2. Fejlesztő
Ezen az oldalon
  1. Chunkok vektorrá alakítása
  2. Köteges kódolás
  3. Hálózati hibák túlélése
  4. Az index mentése lemezre
  5. Ellenőrzés a folytatás előtt
  6. Főbb megállapítások

Chunkok vektorrá alakítása

A dokumentumaidat most már tiszta chunkokra bontottad. A következő lépés ezek beágyazásokká (embeddings) alakítása a mistral-embed API segítségével, majd ezeknek a vektoroknak az elhelyezése egy vektortárban, amely keresőmotorként fog működni. Ebben a pillanatban a korpuszod megszűnik egyszerű szöveg lenni, és lekérdezhető geometriává válik. Néhány mérnöki óvintézkedés – kötegelés, újrapróbálkozások és tartósság – teszi a különbséget a törékeny prototípus és a megbízható index között.

Kisebb korpusz esetén, mondjuk száznál kevesebb chunkkal, egyetlen közvetlen hívás is elegendő. Kinyered a szöveget a chunk szótáraidból, változatlanul továbbítod az API-nak, és lekérdezed a teljes mátrixot. A végrehajtás végén megjelenő (87, 1024) alak az első sanity check-ed: annyi sor, ahány chunk, és 1024 oszlop, mert ez a mistral-embed dimenziója. Ha a sorok száma nem egyezik, akkor egy üres chunk csúszott be a kötegbe.

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

Köteges kódolás

Néhány tucat chunkon túl egyetlen hívás eléri az API korlátait. A megoldás a lista kötegekre bontása és az eredmények összefűzése. Az alábbi függvény 25-ös szeleteket dolgoz fel, és megjeleníti az előrehaladást. Ez nem csak kozmetika: több ezer chunkból álló korpusz esetén a kódolás több percig is eltarthat, és tudni szeretnéd, hol tart a folyamat, ahelyett, hogy egy néma terminált bámulnál. A sorrend megmarad, így minden vektor továbbra is igazodik a megfelelő chunkhoz az eredeti listádban.

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

Hálózati hibák túlélése

Éles környezetben előbb-utóbb meghiúsul egy API-hívás: hálózati kimaradás, sebességkorlát túllépése vagy ideiglenes leállás. Védelem nélkül az indexelésed a 400-ból a 180. kötegnél megáll, és kezdheted elölről. A robusztus verzió minden köteget egy újrapróbálkozó ciklusba csomagol exponenciális háttéridővel – először egy másodperc, majd kettő, majd négy. Ez a növekvő időköz fontos: ha a kvóta elutasítása után azonnal próbálkozol újra, csak rontasz a helyzeten. Három egymást követő hiba után a függvény egy explicit kivételt dob, megnevezve a hibás köteget, ahelyett, hogy egy csonka mátrixot adna vissza, ahol a hiányosságot csak keresés közben vennéd észre.

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)

Az index mentése lemezre

Minden kódolási futtatás időbe és számlázott API-hívásokba kerül. A vektorok újraszámolása minden alkalmazásindításkor tiszta pazarlás, különösen, mivel maga a korpusz nem változott. A mentés két kiegészítő fájlban történik: a vektorok a NumPy tömör bináris formátumába kerülnek, amely azonnal betöltődik, míg a metaadatok – szöveg, forrás, pozíció – egy olvasható JSON fájlba, amelyet megnyithatsz egy gyanús chunk ellenőrzéséhez. A két fájl egymástól függ, a sorsrend köti őket össze: soha ne generáld újra az egyiket a másik nélkül, különben a keresési eredményeid rossz szövegekre mutatnak.

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

Ellenőrzés a folytatás előtt

Egy csendben megsérült index későn derül ki, általában akkor, amikor egy felhasználó abszurd választ jelent. Néhány offline ellenőrzés harminc másodpercet vesz igénybe, és megóv ettől a felfedezéstől. Az ellenőrző függvény először alapvető metrikákat jelenít meg – chunkok száma, dimenzió, átlagos norma –, majd méri a szomszédos chunkok közötti hasonlóságot: mivel ugyanabból a dokumentumból származnak, jelentősen magasabb értékeket kell mutatniuk, mint két véletlenszerű szakasznak. Az utolsó teszt a legegyszerűbb és a legárulkodóbb: egy chunk önmagával való összehasonlításának pontosan 1,0-nak kell lennie. Bármilyen más érték igazítási problémára vagy numerikus konverziós hibára utal.

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)

Összefűzve a munkafolyamat négy hasznos sorra redukálódik. Előkészíted a chunkokat az előző lecke pipeline-jával, robusztus módban kódolod, ellenőrzöd, majd elmented. Ez az a szkript, amelyet minden alkalommal újra lefuttatsz, amikor a korpusz frissül.

# 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!")

Főbb megállapítások

  • Használj kötegelést nagy korpuszok kódolásához (25–50 chunkos kötegek)
  • Adj hozzá újrapróbálkozó logikát exponenciális háttéridővel a robusztusság érdekében
  • Mentsd el a beágyazásokat lemezre (NumPy), hogy elkerüld az újraszámolást
  • Tartsd a metaadatokat (szöveg, forrás, pozíció) egy külön JSON fájlban
  • Ellenőrizd a beágyazások minőségét, mielőtt éles környezetben használnád őket