Omranking med inbäddningsmodeller

En pythonkod för RAG-omrankning

Sidinnehåll

Reranking är ett andra steg i Retrieval Augmented Generation (RAG) system, precis mellan hämtning (Retrieving) och generering (Generating).

Elektriska kuber i digitalt utrymme

Detta ovan är hur Flux-1 dev föreställer sig Elektriska kuber i digitalt utrymme.

För en komplett guide om hur man bygger RAG-system, se Retrieval-Augmented Generation (RAG) Tutorial: Arkitektur, Implementering och Produktionsguide.

Den här artikeln täcker reranking med inbäddningsmodeller (embedding models). För alternativa metoder kan du också kolla in Reranking texter med Ollama och Qwen3 Embedding LLM - i Go och Reranking dokument med Ollama och Qwen3 Reranker-modell - i Go.

Hämtning med reranking

Om vi lagrar dokumenten som inbäddningar (embeddings) i vektordatabasen från början, får vi direkt en lista över liknande dokument vid hämtning.

Standalone reranking

Men om vi först laddar ner dokumenten från internet, kan söksystemets svar påverkas av sökleverantörens preferenser/algoritmer, sponsrat innehåll, SEO-optimering med mera, så vi behöver göra en post-sök-reranking.

Det jag gjorde var:

  • hämta inbäddningar för sökfrågan
  • hämta inbäddningar för varje dokument. Dokumentet förväntades inte vara mer än 8k tokens ändå
  • beräkna likhet mellan frågan och varje dokumentets inbäddning
  • sortera dokumenten efter denna likhet.

Ingen vektordatabas här, så kör på.

Exempel på kod

Användning av Langchain för att ansluta till Ollama och Langchains funktion cosine_similarity. Du kan filtrera efter likhetsmått, men tänk på att tröskeln kan vara olika för olika domäner och inbäddnings-LLM:ar.

Jag blir glad om denna bit av kod är till nytta för dig på något sätt. Copy/Paste/AnvändSomDuVill-licens. Hej hej.

from langchain_core.documents import Document
from langchain_community.embeddings import OllamaEmbeddings
from langchain_community.utils.math import cosine_similarity
import numpy as np


def cosine_distance(a: np.ndarray, b: np.ndarray) -> np.ndarray:
    return 1.0 - cosine_similarity(a, b)

def compute_score(vectors: np.ndarray) -> float:
    score = cosine_distance(vectors[0].reshape(1, -1), vectors[1].reshape(1, -1)).item()
    return score

def list_to_array(lst):
    return np.array(lst, dtype=float)   

def compute_scorel(lists) -> float:
    v1 = list_to_array(lists[0])
    v2 = list_to_array(lists[1])
    return compute_score([v1, v2])

def filter_docs(emb_model_name, docs, query, num_docs):
    content_arr = [doc.page_content for doc in docs]

    ollama_emb = OllamaEmbeddings(
        model=emb_model_name
    )

    docs_embs = ollama_emb.embed_documents(content_arr)
    query_embs = ollama_emb.embed_query(query)
    sims = []
    for i, emb in enumerate(docs_embs):
        idx = docs[i].id
        s = compute_scorel([query_embs, docs_embs[i]])
        simstr = str(round(s, 4))
        docs[i].metadata["sim"] = simstr
        sim = {
            "idx": idx,
            "i": i,
            "sim": s,
        }
        sims.append(sim)

    sims.sort(key=sortFn)

    sorted_docs = [docs[x["i"]] for x in sims]
    filtered_docs = sorted_docs[:num_docs]
    return filtered_docs

Bästa inbäddningsmodeller (Embedding Models)

För mina uppgifter är den bästa inbäddningsmodellen för närvarande bge-large:335m-en-v1.5-fp16.

Andra platsen delades av nomic-embed-text:137m-v1.5-fp16 och jina/jina-embeddings-v2-base-en:latest.

Men gör egna tester för din egen domän och dina egna frågor.

Användbara länkar