Preskok na glavno vsebino
Slovenščina— Izberite jezik
Meni

Ustvarjanje vdelav (Embeddings)

Lekcija 11 od 18 Posodobljeno 2. november 2026 Razvijalec
Na tej strani
  1. Kodiranje razdelkov v vektorje
  2. Kodiranje v paketih (Batch Encoding)
  3. Preživetje omrežnih napak
  4. Shranjevanje indeksa na disk
  5. Preverjanje pred nadaljevanjem
  6. Ključne ugotovitve

Kodiranje razdelkov v vektorje

Tvoji dokumenti so zdaj razdeljeni na čiste razdelke. Naslednji korak je njihova pretvorba v vdelave (embeddings) z uporabo API-ja mistral-embed, nato pa shranjevanje teh vektorjev v vektorsko bazo, ki bo delovala kot tvoj iskalnik. V tem trenutku tvoj korpus preneha biti navadno besedilo in postane poizvedljiva geometrija. Nekaj inženirskih previdnostnih ukrepov – združevanje v pakete (batching), ponovni poskusi in trajnost shranjevanja – odloča med krhkim prototipom in zanesljivim indeksom.

Za majhen korpus, recimo manj kot sto razdelkov, zadošča en sam neposreden klic. Izluščite besedilo iz svojih slovarjev razdelkov, ga takšnega, kot je, posredujte API-ju in pridobite celotno matriko. Oblika (87, 1024), prikazana ob koncu izvajanja, je tvoja prva preverba smiselnosti: toliko vrstic, kolikor je razdelkov, in 1024 stolpcev, ker je to dimenzija modela mistral-embed. Če se število vrstic ne ujema, se je v paket prikradel prazen razdelek.

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

Kodiranje v paketih (Batch Encoding)

Pri več kot nekaj ducatih razdelkih en sam klic trči ob omejitve API-ja. Rešitev je razdelitev seznama na pakete in združevanje rezultatov. Spodnja funkcija obdeluje rezine po 25 elementov in prikazuje napredek. To ni le kozmetika: pri korpusu z več tisoč razdelki kodiranje traja več minut in želel boš vedeti, kje se proces nahaja, namesto da bi strmel v tiho terminalsko okno. Vrstni red je ohranjen, tako da vsak vektor ostane usklajen s svojim ustreznim razdelkom v izvirnem seznamu.

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

Preživetje omrežnih napak

V produkcijskem okolju bo klic API-ja slej ko prej spodletel: izpad omrežja, dosežena omejitev hitrosti ali začasna nedostopnost storitve. Brez zaščite se tvoje indeksiranje ustavi pri 180. paketu od 400 in si spet na začetku. Robustna različica ovije vsak paket v zanko za ponovne poskuse z eksponentnim zamikom (exponential backoff) – ena sekunda, nato dve, nato štiri. To povečevanje časovnih presledkov je ključno: takojšnji ponovni poskus po zavrnitvi zaradi kvote stvari le poslabša. Po treh zaporednih neuspehih funkcija sproži izrecno izjemo, ki imenuje okvarjeni paket, namesto da bi vrnila okrnjeno matriko, kjer bi vrzel odkril šele med iskanjem.

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)

Shranjevanje indeksa na disk

Vsako kodiranje stane čas in plačljive klice API-ja. Ponovno izračunavanje vektorjev ob vsakem zagonu aplikacije je čista izguba, še posebej, ker se sam korpus ni spremenil. Shranjevanje poteka v dveh dopolnjujočih se datotekah: vektorji gredo v NumPy, kompaktno binarno obliko, ki se naloži takoj, metapodatki – besedilo, vir, položaj – pa v berljiv JSON, ki ga lahko odpreš za pregled sumljivega razdelka. Obe datoteki sta medsebojno odvisni in povezani z vrstnim redom vrstic: nikoli ne regeneriraj ene brez druge, sicer bodo tvoji rezultati iskanja kazali na napačna besedila.

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

Preverjanje pred nadaljevanjem

Tiho pokvarjen indeks se pokaže pozno, običajno ko uporabnik poroča o absurdnem odgovoru. Nekaj preverb brez povezave traja trideset sekund in te reši pred takšnim odkritjem. Funkcija za preverjanje najprej prikaže osnovne metrike – število razdelkov, dimenzijo, povprečno normo – nato pa izmeri podobnost med sosednjimi razdelki: ker izhajajo iz istega dokumenta, bi morali kazati bistveno višje vrednosti kot dva naključna odlomka. Zadnji test je najpreprostejši in najbolj razkrivalen: razdelek, primerjan sam s seboj, mora dati točno 1,0. Vsaka druga vrednost signalizira težavo z usklajenostjo ali napako pri numerični pretvorbi.

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)

Če vse skupaj povežemo, se delovni tok skrči na štiri uporabne vrstice. Pripraviš razdelke s cevovodom iz prejšnje lekcije, kodiraš v robustnem načinu, preveriš in shraniš. To je skripta, ki jo boš ponovno zagnal vsakič, ko se korpus posodobi.

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

Ključne ugotovitve

  • Za kodiranje velikih korpusov uporabi pakete (paketi po 25–50 razdelkov)
  • Dodaj logiko za ponovne poskuse z eksponentnim zamikom za večjo robustnost
  • Shrani vdelave na disk (NumPy), da se izogneš ponovnemu izračunu
  • Metapodatke (besedilo, vir, položaj) hrani v ločeni datoteki JSON
  • Pred uporabo v produkciji preveri kakovost vdelav