Reclassement avec des modèles d'incorporation

Un code Python pour le reranking de RAG

Sommaire

Reranking est une deuxième étape dans les systèmes de Génération Augmentée par Récupération (RAG) systèmes, située juste entre la récupération et la génération.

Cubes électriques dans l’espace numérique

Voici comment Flux-1 dev imagine Cubes électriques dans l'espace numérique.

Pour un guide complet sur la construction de systèmes RAG, consultez le Tutoriel sur la Génération Augmentée par Récupération (RAG) : Architecture, Implémentation et Guide de Production.

Cet article couvre le reranking avec des modèles d’embedding. Pour des approches alternatives, vous pouvez également consulter Reranking de textes avec Ollama et le modèle d’embedding LLM Qwen3 - en Go et Reranking de documents avec Ollama et le modèle Reranker Qwen3 - en Go.

Récupération avec reranking

Si nous stockons les documents sous forme d’embeddings dans la base de données vectorielle dès le départ, la récupération nous donnera immédiatement la liste des documents similaires.

Reranking autonome

Mais si nous téléchargeons d’abord les documents depuis Internet, la réponse du système de recherche pourrait être affectée par les préférences/algorithmes du fournisseur de recherche, le contenu sponsorisé, l’optimisation SEO, etc. Nous avons donc besoin d’un reranking post-recherche.

Ce que je faisais :

  • obtenir les embeddings pour la requête de recherche
  • obtenir les embeddings pour chaque document. le document ne devait de toute façon pas dépasser 8k tokens
  • calculer la similarité entre la requête et les embeddings de chaque document
  • trier les documents selon cette similarité.

Pas de base de données vectorielle ici, c’est parti.

Exemple de code

Utilisation de Langchain pour se connecter à Ollama et de la fonction cosine_similarity de langchain. Vous pouvez filtrer par mesure de similarité, mais gardez à l’esprit que pour différents domaines et modèles d’embedding LLM, le seuil serait différent.

Je serais ravi si ce bout de code vous était utile d’une manière ou d’une autre. Licence Copier/Coller/UtiliserCommeVousVoulez. Santé.

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

Meilleurs modèles d’embedding

Pour mes tâches, le meilleur modèle d’embedding actuellement est bge-large:335m-en-v1.5-fp16.

La deuxième place a été prise par nomic-embed-text:137m-v1.5-fp16 et jina/jina-embeddings-v2-base-en:latest.

Mais faites vos propres tests pour votre propre domaine et vos propres requêtes.

Liens utiles