Spring til hovedindhold
Dansk— Vælg et sprog
Menu

Opret indlejrede vektorer

Lektion 11 af 18 Opdateret 2. november 2026 Udvikler
På denne side
  1. Kodér chunks til vektorer
  2. Batch-kodning
  3. Overlev netværksfejl
  4. Gem indekset på disken
  5. Verificér før du fortsætter
  6. Vigtige pointer

Kodér chunks til vektorer

Dine dokumenter er nu opdelt i rene chunks. Næste skridt er at omdanne dem til indlejrede vektorer (embeddings) ved hjælp af mistral-embed-API’et og derefter gemme disse vektorer i et vektorlager, der fungerer som din søgemaskine. Det er her, dit korpus holder op med at være almindelig tekst og bliver til querybar geometri. Nogle få tekniske forholdsregler – batching, genforsøg og persistens – afgør forskellen mellem en skrøbelig prototype og et pålideligt indeks.

Til et lille korpus, f.eks. under hundrede chunks, er et enkelt direkte kald tilstrækkeligt. Uddrag teksten fra dine chunk-ordbøger, send dem uændret til API’et, og hent hele matricen. Formen (87, 1024), der vises ved afslutningen af kørslen, er din første sundhedstjek: lige så mange rækker som chunks og 1024 kolonner, fordi det er dimensionen for mistral-embed. Hvis antallet af rækker ikke stemmer overens, er en tom chunk sneget sig ind i batchen.

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-kodning

Ud over et par dusin chunks rammer et enkelt kald API-grænserne. Løsningen er at opdele listen i batches og sammenkæde resultaterne. Funktionen nedenfor behandler udsnit på 25 og viser fremskridt. Det er ikke kun kosmetik: På et korpus på flere tusinde chunks tager kodningen flere minutter, og du vil gerne vide, hvor processen befinder sig, i stedet for at stirre på en tavs terminal. Rækkefølgen bevares, så hver vektor forbliver justeret med sin tilsvarende chunk i din oprindelige liste.

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

Overlev netværksfejl

I produktion vil et API-kald før eller siden fejle: netværksudfald, ramt rate-limit eller midlertidigt udfald. Uden beskyttelse stopper dit indeksering ved batch 180 ud af 400, og du er tilbage ved start. Den robuste version pakker hver batch ind i en genforsøgsløkke med eksponentiel backoff – ét sekund, derefter to, derefter fire. Denne stigende afstand er vigtig: At forsøge igen umiddelbart efter en afvisning på grund af kvote gør kun tingene værre. Efter tre på hinanden følgende fejl kaster funktionen en eksplicit undtagelse, der navngiver den fejlbehæftede batch, i stedet for at returnere en trunkeret matrix, hvor du først ville opdage hullet under søgningen.

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)

Gem indekset på disken

Hver kodningskørsel koster tid og fakturerede API-kald. At genberegne vektorer hver gang dit program starter, er ren spild, især da selve korpussen ikke er ændret. Lagringen sker i to komplementære filer: vektorer gemmes i NumPy, et kompakt binært format, der indlæses øjeblikkeligt, mens metadata – tekst, kilde, position – gemmes i læsbar JSON, som du kan åbne for at inspicere en mistænkelig chunk. De to filer er indbyrdes afhængige og forbundet via linjerækkefølge: Generér aldrig den ene uden den anden, ellers vil dine søgeresultater pege på de forkerte tekster.

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

Verificér før du fortsætter

Et stille korrumperet indeks viser sig sent, typisk når en bruger rapporterer et absurd svar. Nogle få offline-tjek tager tredive sekunder og sparer dig for den opdagelse. Verificeringsfunktionen viser først grundlæggende målinger – antal chunks, dimension, gennemsnitlig norm – og måler derefter ligheden mellem nabochunks: Da de stammer fra samme dokument, bør de vise væsentligt højere værdier end to tilfældige passager. Den sidste test er den enkleste og mest afslørende: En chunk sammenlignet med sig selv skal give præcis 1,0. Enhver anden værdi signalerer et justeringsproblem eller et numerisk konverteringsproblem.

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)

Sat sammen koges arbejdsgangen ned til fire nyttige linjer. Du forbereder chunks med pipeline’en fra den forrige lektion, koder i robust tilstand, verificerer og gemmer. Dette er det script, du vil genkøre hver gang korpussen opdateres.

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

Vigtige pointer

  • Brug batching til at kode store korpusser (batches på 25–50 chunks)
  • Tilføj logik for genforsøg med eksponentiel backoff for robusthed
  • Gem indlejrede vektorer på disken (NumPy) for at undgå genberegning
  • Opbevar metadata (tekst, kilde, position) i en separat JSON-fil
  • Verificér kvaliteten af de indlejrede vektorer, før du bruger dem i produktion