Pourquoi les cross-encoders ?

Les bi-encodeurs (embeddings standards) encodent la requête et le document séparément. Les cross-encoders les traitent ensemble - beaucoup plus précis mais plus lent.

Bi-encodeur : sim(encode(query), encode(doc)) Cross-encodeur : score(query + doc ensemble)

Implémentation

DEVELOPERpython
from sentence_transformers import CrossEncoder

model = CrossEncoder('cross-encoder/ms-marco-MiniLM-L-6-v2')

def rerank(query, documents, top_k=5):
    # Créer des paires requête-document
    pairs = [[query, doc] for doc in documents]

    # Scorer toutes les paires
    scores = model.predict(pairs)

    # Trier par score
    ranked = sorted(zip(documents, scores), key=lambda x: x[1], reverse=True)

    return [doc for doc, score in ranked[:top_k]]

# Utilisation
initial_results = vector_search(query, k=100)
final_results = rerank(query, initial_results, top_k=10)

Meilleurs modèles (Novembre 2025)

1. ms-marco-MiniLM-L-12-v2

• Rapide, précis
• Meilleur pour usage général

2. bge-reranker-v2-m3

• Multilingue
• Précision à l'état de l'art

3. jina-reranker-v2-base-multilingual

• 89 langues
• Prêt pour la production

Récupération à deux étapes

DEVELOPERpython
def two_stage_rag(query, vector_db):
    # Étape 1 : Récupération rapide avec bi-encodeur (100 candidats)
    candidates = vector_db.search(
        query_embedding=embed(query),
        k=100
    )

    # Étape 2 : Reranking lent mais précis avec cross-encodeur
    cross_encoder = CrossEncoder('cross-encoder/ms-marco-MiniLM-L-12-v2')
    pairs = [[query, doc['content']] for doc in candidates]
    scores = cross_encoder.predict(pairs)

    # Retourner le top 10
    ranked = sorted(zip(candidates, scores), key=lambda x: x[1], reverse=True)
    return [doc for doc, _ in ranked[:10]]

Optimisation des performances

Les cross-encoders sont lents - optimisez :

DEVELOPERpython
# Traitement par batch
def batch_rerank(query, documents, batch_size=32):
    pairs = [[query, doc] for doc in documents]
    all_scores = []

    for i in range(0, len(pairs), batch_size):
        batch = pairs[i:i+batch_size]
        scores = model.predict(batch)
        all_scores.extend(scores)

    return sorted(zip(documents, all_scores), key=lambda x: x[1], reverse=True)

Quand reranker

Toujours reranker quand :

• La précision est critique
• Le coût des faux positifs est élevé
• Vous avez un budget de calcul

Ignorer le reranking quand :

• Latence < 100ms requise
• QPS élevé (> 1000/sec)
• Budget contraint