跳到正文
Hugging Face Blog·· 2026-05-19精選AI 評分66

Hugging Face 發佈 Ettin Reranker 系列六款模型,規模涵蓋 17.6M 至 1.00B

Introducing the Ettin Reranker Family

AI 導讀

Hugging Face 發佈六款基於 Ettin ModernBERT encoder 的 Sentence Transformers CrossEncoder reranker,參數規模由 17.6M 至 1.00B,並公開訓練數據及完整訓練方案。

推薦理由

文章以 MTEB(eng, v2) Retrieval、NanoBEIR 及多種硬件吞吐測試比較六種尺寸,呈現 Ettin Reranker 在排序品質與速度間的取捨。

正文 · 繁體中文

重點摘要

我今天發布六款全新的 Sentence Transformers CrossEncoder 重排序器,各自在相應模型規模下均達到最先進水平。它們建基於 Ettin ModernBERT 編碼器;我亦一併公開訓練資料及完整訓練配方:

這些模型採用知識蒸餾配方訓練:以 mixedbread-ai/mxbai-rerank-large-v2 的分數作逐點 MSE,套用於 cross-encoder/ettin-reranker-v1-data。此資料集是 lightonai/embeddings-pre-training 的子集,並混合了經重排序的 lightonai/embeddings-fine-tuning 子集。

Our six rerankers paired with embeddinggemma-300m on MTEB(eng, v2) Retrieval

六款重排序器與 google/embeddinggemma-300m 配對,在 MTEB(eng, v2) Retrieval 的結果。另有五種嵌入模型配對,請參閲結果。

如果你初次接觸重排序器,想先了解「為甚麼要用」,可跳到甚麼是重排序器,為甚麼要與嵌入模型配合?。如果只想直接使用模型,請看使用方法;如果想自行訓練,請看訓練。

以下訓練配方以新 train-sentence-transformers Agent Skill 起步建立;該技能隨 Sentence Transformers v5.5.0 發布。使用 hf skills add train-sentence-transformers [--global] [--claude] 安裝技能,再要求 AI 編碼代理(Claude Code、Codex、Cursor、Gemini CLI 等)以你的資料微調 SentenceTransformer、CrossEncoder 或 SparseEncoder 模型。

目錄

甚麼是重排序器,為甚麼要與嵌入模型配合?

重排序器(又稱逐點 cross-encoder)是一種神經網絡模型,輸入一組 (query, document) 配對,輸出單一相關性分數。嵌入模型會分別編碼查詢和文件,再根據兩個嵌入向量計算相似度;重排序器則讓兩段文字在每一層 Transformer 中互相注意。這種聯合編碼較準確,但成本也較高:每組 (query, document) 都要執行一次模型,而非每段文字各執行一次。

由於 cross-encoder 在整個語料庫上執行的成本太高,常見的正式環境做法是先檢索、再重排序:快速嵌入模型先低成本檢索排名最高的 K 個候選項,再由 cross-encoder 以高準確度重新排列這 K 項。如此可控制總成本,同時讓最終排名更接近對整個語料庫完整執行 cross-encoder 的結果。

Embedding vs Reranker Models

本文會交替使用「重排序器」和「cross-encoder」這兩個名稱。

使用方法

發布的模型都是標準的 Sentence Transformers CrossEncoder 模型,只需 3 行程式碼即可使用:

from sentence_transformers import CrossEncoder

model = CrossEncoder("cross-encoder/ettin-reranker-32m-v1")
scores = model.predict([
    ("Where was Apple founded?", "Apple Inc. was founded in Cupertino, California in 1976 by Steve Jobs, Steve Wozniak, and Ronald Wayne."),
    ("Where was Apple founded?", "The Fuji apple is an apple cultivar developed in the late 1930s and brought to market in 1962."),
])
print(scores)
# [11.393298  2.968891]   <- larger means more relevant

輸入查詢和候選清單後,也可使用 rank 取得排序後的索引及分數:

ranked = model.rank(
    query="Which planet is known as the Red Planet?",
    documents=[
        "Venus is often called Earth's twin because of its similar size and proximity.",
        "Mars, known for its reddish appearance, is often referred to as the Red Planet.",
        "Jupiter, the largest planet in our solar system, has a prominent red spot.",
        "Saturn, famous for its rings, is sometimes mistaken for the Red Planet.",
    ],
    top_k=4,
    return_documents=True,
)
for r in ranked:
    print(f"({r['score']:.2f}): {r['text']}")
# (10.82): Mars, known for its reddish appearance, is often referred to as the Red Planet.
# (9.86): Saturn, famous for its rings, is sometimes mistaken for the Red Planet.
# (8.55): Jupiter, the largest planet in our solar system, has a prominent red spot.
# (6.21): Venus is often called Earth's twin because of its similar size and proximity.

你可以把 cross-encoder/ettin-reranker-32m-v1 換成任何其他規模,以速度換取品質,或反之。受惠於 ModernBERT 的長上下文預訓練,六款模型的上下文長度均支援最多 8K tokens,適合長文件重排序。

建議安裝 kernels,並設定 model_kwargs={"dtype": "bfloat16", "attn_implementation": "flash_attention_2"},以取得最高吞吐量。詳情請參閲下方速度一節;一般而言,視乎模型規模及序列長度,速度可比預設載入方式快 1.7x–8.3x。

from sentence_transformers import CrossEncoder

model = CrossEncoder(
    "cross-encoder/ettin-reranker-32m-v1",
    model_kwargs={"dtype": "bfloat16", "attn_implementation": "flash_attention_2"},
)

端對端「先檢索、再重排序」流程

以下是結合快速嵌入模型作檢索,並以重排序器決定最終次序的完整範例:

from sentence_transformers import SentenceTransformer, CrossEncoder

# Fast retrieval with a static embedder (sub-millisecond on CPU per query)
embedder = SentenceTransformer("sentence-transformers/static-retrieval-mrl-en-v1")
reranker = CrossEncoder("cross-encoder/ettin-reranker-68m-v1")

corpus = [
    "Apple Inc. was founded in Cupertino, California in 1976 by Steve Jobs, Steve Wozniak, and Ronald Wayne.",
    "The Fuji apple is an apple cultivar developed in the late 1930s.",
    "Steve Jobs introduced the iPhone in 2007 at Macworld.",
    "Macintosh computers were sold by Apple from 1984 onward.",
    # ... thousands or millions more in production
]
query = "Where was Apple founded?"

# Step 1: encode + retrieve top-100
query_emb = embedder.encode_query(query, convert_to_tensor=True)
corpus_emb = embedder.encode_document(corpus, convert_to_tensor=True)
scores = embedder.similarity(query_emb, corpus_emb)[0]
top_k_idx = scores.topk(min(100, len(corpus))).indices.tolist()

# Step 2: rerank
top_k_docs = [corpus[i] for i in top_k_idx]
ranked = reranker.rank(query, top_k_docs, top_k=5, return_documents=True)
for r in ranked:
    print(f"({r['score']:.2f}): {r['text']}")
# (11.63): Apple Inc. was founded in Cupertino, California in 1976 by Steve Jobs, Steve Wozniak, and Ronald Wayne.
# (4.71): Steve Jobs introduced the iPhone in 2007 at Macworld.
# (1.96): The Fuji apple is an apple cultivar developed in the late 1930s.
# (1.49): Macintosh computers were sold by Apple from 1984 onward.

這與大部分現代搜尋系統採用的流程相同:檢索器決定哪些項目進入篩選流程,重排序器則決定哪些項目勝出。

架構詳情

六款重排序器共用相同架構,只有骨幹規模不同。骨幹是 Johns Hopkins University Ettin 系列中的六款 Ettin 編碼器之一。它們採用 ModernBERT 風格,具備無填充注意力、RoPE 位置編碼、GeGLU,以及以開放授權資料預訓練的 2T tokens,最多支援 8192 tokens 上下文。

每個編碼器上方的重排序器都使用 4 模組分類頭,設計仿照 ModernBertForSequenceClassification,但以 Sentence Transformers 的模組化元件構成。底層 Transformer 使用一般的 AutoModel,而非 AutoModelForSequenceClassification,因此可在 Flash Attention 2 中對可變長度輸入使用序列去填充。在中等文件長度下,視模型規模而定,速度比 fp32+SDPA 快 1.7x–8.3x(完整基準測試請參閲速度):

1. Transformer(FA2)
2. Pooling(cls)
3. Dense(H, H, bias=False, GELU)
4. LayerNorm(H)
5. Dense(H, 1, scores)

在消融實驗中,CLS pooling 的表現勝過 mean pooling,結果有點出乎意料。ModernBERT 只有每三層中的一層使用全域注意力,其餘兩層使用局部視窗注意力,無法從遠處位置連接至 CLS。實驗結果顯示,少數全域層所承載的訊號已足以令 CLS 成為較佳的 pooling 選擇。

模型 骨幹 隱藏維度 層數 參數量(包括分類頭)
cross-encoder/ettin-reranker-17m-v1 jhu-clsp/ettin-encoder-17m 256 7 17.6M
cross-encoder/ettin-reranker-32m-v1 jhu-clsp/ettin-encoder-32m 384 10 32.8M
cross-encoder/ettin-reranker-68m-v1 jhu-clsp/ettin-encoder-68m 512 19 68.6M
cross-encoder/ettin-reranker-150m-v1 jhu-clsp/ettin-encoder-150m 768 22 150.9M
cross-encoder/ettin-reranker-400m-v1 jhu-clsp/ettin-encoder-400m 1024 28 401.6M
cross-encoder/ettin-reranker-1b-v1 jhu-clsp/ettin-encoder-1b 1792 28 1.00B

六款模型均以 Apache 2.0 授權發布,與 Ettin 編碼器相同。

結果

MTEB(eng, v2) 檢索

我使用 MTEB 的MTEB(eng, v2) Retrieval 基準測試,讓每款已發布模型完整執行測試(10 項任務、重排排名最高的 100 項),並透過 MTEB 的兩階段重排序流程,為每款重排序器配對六種涵蓋速度與品質範圍的嵌入模型:

嵌入模型 啟用參數量 僅檢索器 NDCG@10
sentence-transformers/static-retrieval-mrl-en-v1 0M 0.3495
sentence-transformers/all-MiniLM-L6-v2 23M 0.4292
BAAI/bge-small-en-v1.5 33M 0.5149
nomic-ai/nomic-embed-text-v1.5 137M 0.5226
google/embeddinggemma-300m 308M 0.5463
jinaai/jina-embeddings-v5-text-small-retrieval 596M 0.5980

下方每張圖中的僅檢索器虛線代表要超越的基準分數。任何結果低於這條線,都表示重排序器平均而言反而損害整體流程:

MTEB(eng, v2) Retrieval with static-retrieval-mrl-en-v1 + reranker MTEB(eng, v2) Retrieval with all-MiniLM-L6-v2 + reranker
MTEB(eng, v2) Retrieval with bge-small-en-v1.5 + reranker MTEB(eng, v2) Retrieval with nomic-embed-text-v1.5 + reranker
MTEB(eng, v2) Retrieval with embeddinggemma-300m + reranker MTEB(eng, v2) Retrieval with jina-embeddings-v5-text-small-retrieval + reranker

完整結果表(點擊展開)

六種嵌入模型配對的平均 NDCG@10,按分數由高至低排列。我們的六款模型以粗體顯示,教師模型 mixedbread-ai/mxbai-rerank-large-v2 則加底線。

重排序器 參數量 MTEB(eng, v2) 檢索 NDCG@10
Qwen/Qwen3-Reranker-4B† 4.02B 0.6367
mixedbread-ai/mxbai-rerank-large-v2 1.54B 0.6115
cross-encoder/ettin-reranker-1b-v1 1.00B 0.6114
cross-encoder/ettin-reranker-400m-v1 401M 0.6091
cross-encoder/ettin-reranker-150m-v1 151M 0.5994
Qwen/Qwen3-Reranker-0.6B 596M 0.5940
mixedbread-ai/mxbai-rerank-base-v2 494M 0.5920
cross-encoder/ettin-reranker-68m-v1 68.6M 0.5915
jinaai/jina-reranker-m0 2.44B 0.5856
Alibaba-NLP/gte-reranker-modernbert-base 150M 0.5843
cross-encoder/ettin-reranker-32m-v1 32.8M 0.5779
ibm-granite/granite-embedding-reranker-english-r2 150M 0.5656
cross-encoder/ettin-reranker-17m-v1 17.6M 0.5576
BAAI/bge-reranker-v2-m3 568M 0.5526
zeroentropy/zerank-2-reranker† 4.02B 0.5300
BAAI/bge-reranker-large 560M 0.5098
cross-encoder/ms-marco-MiniLM-L6-v2 22.7M 0.5082
cross-encoder/ms-marco-MiniLM-L12-v2 33.4M 0.5066
mixedbread-ai/mxbai-rerank-large-v1 435M 0.5063
cross-encoder/ms-marco-MiniLM-L4-v2 19.2M 0.4979
mixedbread-ai/mxbai-rerank-xsmall-v1 70.8M 0.4968
BAAI/bge-reranker-base 278M 0.4890
mixedbread-ai/mxbai-rerank-base-v1 184M 0.4865

† 上限設為 max_seq_length=8192(4B 的 Qwen3 系列重排序器無法在單張 H100 80GB 上以原生上下文長度執行)。以原生上下文長度評估的分數可能更高。

完整 NanoBEIR 結果表(點擊展開)

NanoBEIR 是 BEIR 的快速子集,包含 13 個資料集;每個資料集以 50 個查詢對最多 5000 份文件進行測試。訓練時的 metric_for_best_model 設為 NanoBEIR(見評估一節),我亦用它指引實驗方向。

重排序器 參數量 NanoBEIR 平均 NDCG@10
mixedbread-ai/mxbai-rerank-large-v2 1.54B 0.7318
cross-encoder/ettin-reranker-1b-v1 1.00B 0.7237
jinaai/jina-reranker-m0 2.44B 0.7197
cross-encoder/ettin-reranker-400m-v1 401M 0.7193
mixedbread-ai/mxbai-rerank-base-v2 494M 0.7162
cross-encoder/ettin-reranker-150m-v1 151M 0.7086
Alibaba-NLP/gte-reranker-modernbert-base 150M 0.7017
BAAI/bge-reranker-v2-m3 568M 0.6971
cross-encoder/ettin-reranker-68m-v1 68.6M 0.6915
ibm-granite/granite-embedding-reranker-english-r2 150M 0.6909
cross-encoder/ettin-reranker-32m-v1 32.8M 0.6825
cross-encoder/ettin-reranker-17m-v1 17.6M 0.6746
mixedbread-ai/mxbai-rerank-large-v1 435M 0.6488
BAAI/bge-reranker-large 560M 0.6379
cross-encoder/ms-marco-MiniLM-L12-v2 33.4M 0.6369
cross-encoder/ms-marco-MiniLM-L6-v2 22.7M 0.6312
cross-encoder/ms-marco-MiniLM-L4-v2 19.2M 0.6298
mixedbread-ai/mxbai-rerank-base-v1 184M 0.6231
mixedbread-ai/mxbai-rerank-xsmall-v1 70.8M 0.6136
BAAI/bge-reranker-base 278M 0.6027

我發布的最小模型 17M,以約一半的參數量,在 MTEB 上以 +0.051 NDCG@10(0.5576 對 0.5066)勝過 33M 的 ms-marco-MiniLM-L12-v2;在 NanoBEIR 上則以 +0.038(0.6746 對 0.6369)領先。32M 模型在 MTEB 上以 +0.025(0.5779 對 0.5526)勝過 568M 的 BAAI/bge-reranker-v2-m3,參數量相差 17 倍。如果你目前把舊款 MiniLM 重排序器用作「先檢索、再重排序」流程的預設模型,換成我們的 17M(或 32M)是低風險的直接替代方案,兩項基準測試的品質都會明顯提升。

排名再往上看,我的 150M 模型是我測試過、規模低於 600M 的模型中,MTEB 表現最強的重排序器;它以 +0.005(0.5994 對 0.5940)略勝近期的 Qwen/Qwen3-Reranker-0.6B(596M),並領先所有 BAAI bge-reranker 變體 0.03 至 0.05。68M 也值得一提:其分數為 0.5915,幾乎追平 Qwen3-Reranker-0.6B(0.5940),但參數量只有九分之一。

在已發布模型的最高規模中,我們的 1B 模型與教師模型表現相當。在 MTEB 上,它與 1.54B 的 mxbai-rerank-large-v2 只差 0.0001(0.6114 對 0.6115),NanoBEIR 亦只差 0.008,儘管教師模型比學生模型大 54%。蒸餾有效縮窄了與教師模型的差距,正是我發布這批模型時希望看到的結果。

比較中整體最強的重排序器是 Qwen/Qwen3-Reranker-4B,在 MTEB 得分 0.6367,比我們的 1B 模型高 +0.025。要用現有配方縮窄差距,可能需要從更強的教師模型蒸餾(我們的教師模型本身也不及 Qwen3-Reranker-4B)。對大部分「先檢索、再重排序」工作負載而言,我們的 1B 模型參數量只有四分之一(見速度),實用得多。

速度

重排序器的品質分數只反映一半表現;另一半在於延遲是否符合你從檢索到向使用者顯示結果之間的時間預算。以下分享我量度到的結果。

我在單張 NVIDIA H100 80GB 上,以六款已發布模型對比 13 款公開重排序器(強力基線最高約 1B 參數)。查詢及文件來自 sentence-transformers/natural-questions,並保留其原生文件長度分佈:大部分 NQ 答案較短,部分則較長。為免令舊模型處於不利條件,文件長度截斷至 max_length=512。每款模型均使用其支援的最佳注意力實作:架構支援時用 Flash Attention 2(BERT、XLM-RoBERTa、ModernBERT、Qwen2),不支援時用 SDPA;DeBERTa-v2 則用 eager(目前 transformers 不支援其 FA2 或 SDPA)。

每款模型都會自動搜尋批次大小,從 8 開始逐次倍增,直至 GPU 記憶體不足。每個批次大小會計時執行三次,並取吞吐量中位數,避免單次偶發結果影響數字。報告的吞吐量來自表現最佳的批次大小。

表 1。每秒配對數,全部使用 bfloat16。我們的六款重排序器以粗體顯示。

模型 參數量 注意力 配對/秒
cross-encoder/ettin-reranker-17m-v1 17M FA2 7517
cross-encoder/ettin-reranker-32m-v1 32M FA2 6602
cross-encoder/ettin-reranker-68m-v1 68M FA2 4913
cross-encoder/ms-marco-MiniLM-L4-v2 19M FA2 4029
cross-encoder/ms-marco-MiniLM-L6-v2 22M FA2 3817
cross-encoder/ms-marco-MiniLM-L12-v2 33M FA2 3311
cross-encoder/ettin-reranker-150m-v1 150M FA2 3237
BAAI/bge-reranker-base 278M FA2 2858
mixedbread-ai/mxbai-rerank-xsmall-v1 70M eager 2636
mixedbread-ai/mxbai-rerank-base-v1 184M eager 1953
cross-encoder/ettin-reranker-400m-v1 400M FA2 1738
BAAI/bge-reranker-large 560M FA2 1659
BAAI/bge-reranker-v2-m3 568M FA2 1569
Alibaba-NLP/gte-reranker-modernbert-base 150M FA2 1418
ibm-granite/granite-embedding-reranker-english-r2 150M FA2 1404
cross-encoder/ettin-reranker-1b-v1 1B FA2 928
mixedbread-ai/mxbai-rerank-large-v1 435M eager 867
mixedbread-ai/mxbai-rerank-base-v2 494M FA2 809
mixedbread-ai/mxbai-rerank-large-v2 1.5B FA2 387

在整個比較中,我們的 17M 重排序器最快,每秒可處理 7517 組配對,吞吐量接近 ms-marco-MiniLM-L6-v2(3817)的兩倍,甚至快於規模較小的 ms-marco-MiniLM-L4-v2(4029)。如前面的 MTEB 表格所示,17M 的準確度亦高於所有 MiniLM 變體。如果你目前使用 MiniLM cross-encoder,只需改一行即可換成 17M,同時改善延遲和搜尋品質。

150M 模型的比較更有意思,因為有兩款架構相近、參數量同為 150M 的模型:Alibaba-NLP/gte-reranker-modernbert-base 及 ibm-granite/granite-embedding-reranker-english-r2。兩者都建基於相同的 ModernBERT-base 骨幹。我們的 150M 每秒處理 3237 組配對,兩款同類模型則分別為 1418 和 1404,速度相差 2.3 倍。

三款 150M 模型都使用 Flash Attention 2,但兩款同類模型透過 AutoModelForSequenceClassification 載入,輸入仍會填充至相同長度。因此,注意力部分雖然使用 FA2 kernel,模型其他部分仍會對沒有作用的填充 tokens 執行密集計算。我們的模組化 Transformer 元件(見上文架構詳情)會把未填充輸入一路傳遞至整個模型,讓每一層只需對實際 tokens 計算。這就是隻取得部分 FA2 效能優勢,與充分發揮其效能的分別。

排名表末段的 1B 模型每秒可處理 928 組配對,比 1.54B 教師模型 mxbai-rerank-large-v2(每秒 387 組)快 2.4 倍,同時 MTEB 分數相差只有 0.0001。教師模型建基於 Qwen2,每組配對都需承擔提示模板開銷;蒸餾後的學生模型保留教師的校準與判斷能力,卻省掉所有執行時額外負擔。這是整次發布中最令我滿意的一個數字。

有一點可惜:基於 DeBERTa-v2 的 mxbai-rerank-{xsmall,base,large}-v1 系列,比表中其他模型慢得多,因為 DeBERTa-v2 的 transformers 目前不支援 Flash Attention 2 或 SDPA。70M 的 mxbai-rerank-xsmall-v1 每秒處理 2636 組配對,吞吐量約為我們參數量相近的 68M 模型的一半。模型本身沒有問題,只是無法使用新式注意力 kernel。

消費級 GPU(RTX 3090,24 GB)上的相同基準測試

如果你在消費級顯示卡而非資料中心 GPU 上自行託管模型,以下是 RTX 3090 的相同吞吐量測試。基準測試設定與表 1 相同:bfloat16、各模型支援的最佳注意力方式,以及在可容納的最大批次下進行三次測試並取吞吐量中位數。

模型 參數量 最佳注意力 配對/秒
cross-encoder/ettin-reranker-17m-v1 17M FA2 9008
cross-encoder/ms-marco-MiniLM-L4-v2 19M FA2 5071
cross-encoder/ettin-reranker-32m-v1 32M FA2 4497
cross-encoder/ms-marco-MiniLM-L6-v2 22M FA2 4234
cross-encoder/ms-marco-MiniLM-L12-v2 33M FA2 2847
cross-encoder/ettin-reranker-68m-v1 68M FA2 1916
mixedbread-ai/mxbai-rerank-xsmall-v1 70M eager 1677
BAAI/bge-reranker-base 278M FA2 1329
cross-encoder/ettin-reranker-150m-v1 150M FA2 982
mixedbread-ai/mxbai-rerank-base-v1 184M eager 772
ibm-granite/granite-embedding-reranker-english-r2 150M FA2 598
Alibaba-NLP/gte-reranker-modernbert-base 150M FA2 586
BAAI/bge-reranker-large 560M FA2 448
BAAI/bge-reranker-v2-m3 568M FA2 436
cross-encoder/ettin-reranker-400m-v1 400M FA2 429
mixedbread-ai/mxbai-rerank-large-v1 435M eager 266
mixedbread-ai/mxbai-rerank-base-v2 494M FA2 221
cross-encoder/ettin-reranker-1b-v1 1B FA2 189
mixedbread-ai/mxbai-rerank-large-v2 1.5B FA2 69

我們的 17M 仍是表中最快模型,每秒處理 9008 組配對,甚至高於它在 H100 上的數字;這顯示極小模型的瓶頸並非原始計算能力,H100 額外的算力未必能轉化成效能。中段排名略有變化:MiniLM 重排序器超越了我們的 32M 和 68M,而 1B 落後於 mxbai-rerank-base-v2(每秒 189 對 221 組配對)。我們的 150M 仍明顯領先兩款以 ModernBERT 為基礎的 150M 同類模型;教師替代方案的優勢亦然:我們的 1B 吞吐量是 1.5B mxbai-rerank-large-v2 的 2.7 倍(每秒 189 對 69 組配對)。

相同基準測試,CPU(Intel Core i7-13700K)

模型 參數量 最佳注意力 配對/秒
cross-encoder/ettin-reranker-17m-v1 17M SDPA 267.4
cross-encoder/ms-marco-MiniLM-L4-v2 19M SDPA 206.2
cross-encoder/ms-marco-MiniLM-L6-v2 22M SDPA 143.9
cross-encoder/ettin-reranker-32m-v1 32M SDPA 92.5
cross-encoder/ms-marco-MiniLM-L12-v2 33M SDPA 75.9
mixedbread-ai/mxbai-rerank-xsmall-v1 70M eager 38.9
cross-encoder/ettin-reranker-68m-v1 68M SDPA 31.2
BAAI/bge-reranker-base 278M SDPA 19.2
Alibaba-NLP/gte-reranker-modernbert-base 150M SDPA 14.7
ibm-granite/granite-embedding-reranker-english-r2 150M SDPA 14.5
cross-encoder/ettin-reranker-150m-v1 150M SDPA 14.0
mixedbread-ai/mxbai-rerank-base-v1 184M eager 13.4
BAAI/bge-reranker-large 560M SDPA 6.2
BAAI/bge-reranker-v2-m3 568M SDPA 6.0
cross-encoder/ettin-reranker-400m-v1 400M SDPA 5.2
mixedbread-ai/mxbai-rerank-large-v1 435M eager 4.3
mixedbread-ai/mxbai-rerank-base-v2 494M SDPA 3.5
cross-encoder/ettin-reranker-1b-v1 1B SDPA 2.1

在 CPU 上,我們無法利用 bf16、Flash Attention 2 或去填充,因此延遲表現較簡單:參數越多,模型越慢。17M 模型明顯快於 ms-marco-MiniLM-L6-v2(每秒 267.4 對 143.9 組配對),也快於規模較小的 ms-marco-MiniLM-L4-v2(206.2)。如預期,當去填充不再適用時,我們的 150M 模型與兩款 150M 同類模型速度相若(每秒 14.0 對 14.5 和 14.7 組配對)。如果瓶頸在 CPU,17M 和 32M 會是較實用的選擇。

為説明速度提升的來源,下一個表格以相同基準設定,測試六款模型在 fp32+SDPA、bf16+SDPA 和 bf16+FA2 下的表現。FA2 欄分為兩種:輸入仍經填充(包裝模型會採用的形式),以及輸入未填充(我們的模組化 Transformer 實際採用的形式)。最右欄是啟用 FA2 時,我們的模型預設採用的設定。

表 2。六種已發布模型規模在自然 NQ 文件上進行的精度及注意力消融測試,max_length=512。每格首行為每秒配對數及相對於 fp32+SDPA 的倍數(括號內),第二行為 GPU 峯值記憶體。最右欄(以粗體顯示)是啟用 FA2 時模型預設採用的設定。

模型 參數量 fp32+SDPA bf16+SDPA bf16+FA2 w. padding bf16+FA2(不含填充)
ettin-reranker-17m-v1 17M 4402 (1.00x)
0.8 GB
4523 (1.03x)
2.2 GB
3744 (0.85x)
1.9 GB
7517 (1.71x)
1.4 GB
ettin-reranker-32m-v1 32M 3307 (1.00x)
1.2 GB
4357 (1.32x)
1.6 GB
3040 (0.92x)
2.9 GB
6602 (2.00x)
1.1 GB
ettin-reranker-68m-v1 68M 1364 (1.00x)
1.0 GB
2861 (2.10x)
2.2 GB
2003 (1.47x)
2.0 GB
4913 (3.60x)
1.5 GB
ettin-reranker-150m-v1 150M 671 (1.00x)
1.6 GB
1942 (2.90x)
1.8 GB
1396 (2.08x)
3.1 GB
3237 (4.83x)
1.4 GB
ettin-reranker-400m-v1 400M 266 (1.00x)
2.5 GB
1113 (4.18x)
1.8 GB
864 (3.25x)
2.7 GB
1738 (6.53x)
2.2 GB
ettin-reranker-1b-v1 1B 112 (1.00x)
4.6 GB
630 (5.60x)
2.8 GB
522 (4.64x)
3.6 GB
928 (8.26x)
4.5 GB

相較於 bf16+FA2 w.o. padding 的 fp32+SDPA 基線,整體加速幅度會隨模型規模大幅增加:17M 為 1.71x,1B 則達 8.26x。大部分增幅來自 bf16 本身:從 fp32+SDPA 切換至 bf16+SDPA,17M 只快 1.03x,1B 則快 5.60x;記憶體用量下降亦容許使用更大的批次。簡言之,bfloat16 是整體加速的最大單一來源。

出乎意料的是,輸入仍經填充時,所有已發布規模的 FA2 都比 bf16+SDPA 慢。FA2 kernel 偏好未填充格式;若輸入經填充,就要承擔格式轉換的額外處理,同時仍會對填充 tokens 消耗運算資源。因此,表中的 bf16+FA2 w. padding 欄,大致反映只把 sdpa 換成 flash_attention_2,並在 model_kwargs 設定,卻不改動模型載入方式時的效果。表 1 的 gte-reranker-modernbert-base 和 granite-embedding-reranker-english-r2 正是這種情況。

最後,由 bf16+FA2 w. padding 改為 bf16+FA2 w.o. padding,吞吐量可再提高 1.78x(1B)至 2.45x(68M),而且大幅降低峯值記憶體用量,容許提高批次大小。

因此我的建議很簡單:同時啟用 bf16 和 FA2。六款 Ettin 重排序器預設會使用未填充輸入,因為模組化 Transformer 元件(見架構詳情一節)正是如此設定。完整程式碼與上文使用方法一節相同:

from sentence_transformers import CrossEncoder

model = CrossEncoder(
    "cross-encoder/ettin-reranker-150m-v1",
    model_kwargs={
        "dtype": "bfloat16",
        "attn_implementation": "flash_attention_2",  # See tip below
    },
)

使用 pip install kernels 安裝 FA2。套件提供預先建置的 kernel,支援多種 GPU 架構、CUDA 版本及作業系統。

其他 CrossEncoder 要留意一點:只有採用 Ettin 重排序器這類模組化 Transformer 建構的模型,才能取得完整加速效果。若對透過 AutoModelForSequenceClassification 載入的 CrossEncoder 套用相同兩項設定,結果會落在表 2 中較慢的 bf16+FA2 w. padding 欄。

訓練

下方訓練指令碼最初是新 train-sentence-transformers Agent Skill 產生的結果,該技能隨 Sentence Transformers v5.5.0 發布。若你使用 AI 編碼代理(Claude Code、Codex、Cursor、Gemini CLI 等),可以安裝技能,並要求它以你的資料微調 SentenceTransformer、CrossEncoder 或 SparseEncoder。技能提供隨版本更新的指引,涵蓋基礎模型選擇、loss 與 evaluator 選擇、困難負例挖掘、蒸餾、LoRA、Matryoshka、多語言訓練及靜態嵌入,並為各模型類型提供範本指令碼。

hf skills add train-sentence-transformers --claude   # symlinks into .claude/skills/
hf skills add train-sentence-transformers --global   # under ~/.agents/skills/

例如輸入提示 「以我的資料集中的 (query, document) 配對微調 cross-encoder 重排序器、挖掘困難負例,並推送至我的 Hub repo」,即可產生可執行指令碼,再逐步調整。以下配方就是從這種方式開始建立。

六款重排序器均採用相同的單階段配方訓練;不同模型規模只會調整學習率及每裝置批次大小。完整訓練指令碼約 150 行,並使用一個已發布資料集。

這套配方只需對不同模型規模進行一輪掃描便收斂。我以最終訓練資料約 15% 的子集進行小型網格搜尋,為各規模調校學習率;所得學習率直接套用至完整資料訓練,無需重新調校。除學習率外,不需按模型規模另行調校。

蒸餾配方

大部分已發布的重排序器配方,都以人工標註的相關性三元組(查詢、正面文件,以及可選的困難負例)訓練,並使用對比式、逐點、成對或列表式損失,例如 MultipleNegativesRankingLoss、BinaryCrossEntropyLoss、RankNetLoss 或 LambdaLoss。例如可參閲我較早撰寫的網誌使用 Sentence Transformers 訓練及微調重排序器模型。

但這種做法在實務和理論上都有幾項缺點。第一,正面樣本需要人工標註,成本高,也難以快速擴展至多個領域。第二,模型只會看到有人逐一處理過的一小部分 (query, document) 配對標籤。尤其經過困難負例挖掘後,會產生大量假負例,例如困難負例,難以吸取的教訓一文所示。第三,二元標註無法反映現實:不同文件的相關程度本來就有高低。

我在這裡採用不同方法:以現有強力教師重排序器進行逐點 MSE 蒸餾。整個設定簡單到可用三行説明:

  • 教師模型:mixedbread-ai/mxbai-rerank-large-v2(1.54B 參數)。
  • 損失:直接對教師 logits 使用 MSELoss(範圍約為 [−12, 22]),不作重新縮放。
  • 訓練資料:約 143M 組 (query, document, teacher_score) 三元組。

資料集

我把訓練資料整合成一個 Hugging Face 資料集 cross-encoder/ettin-reranker-v1-data 並公開,資料由兩個來源組成。每個來源各自保留為一個 split,方便追溯資料來源:

  1. LightOn 預訓練資料(lightonai/embeddings-pre-training,未經整理):32 個 splits,涵蓋廣泛領域的文字相似度訊號(MTP、FW-EDU、Reddit、PAQ、S2ORC、Amazon、Wikipedia、MS MARCO 等)。我限制部分 splits 的樣本數,最終合共約 110M 組 (query, document, similarity) 三元組。
  2. 重新評分的檢索資料來自 lightonai/embeddings-fine-tuning:7 個 splits(msmarco、hotpotqa、trivia、nq、squadv2、fiqa、fever)。來源資料集每個查詢最多有 2048 份候選文件(最初由 Alibaba-NLP/gte-modernbert-base 評分);我再用 mixedbread-ai/mxbai-rerank-large-v2 重新評分,並上載為 cross-encoder/lightonai-embeddings-fine-tuning-reranked-v1。該資料集依 Jang 等人的 quantile-anchor 配方,把每個查詢的 2048 個候選項抽樣至 256 個(所有正例 + 排名最高的 16 個困難負例 + 約 239 個分位數錨點分層樣本)。訓練時,每個查詢會從這 256 個項目選取 64 個:32 個來自按分數排序的前段(正例及最困難的負例),另 32 個則從教師模型排名較後的一段抽樣,作為中等難度負例。確切排名位置請參閲資料集説明卡。

總計:約 143M 組 (query, document, score) 三元組,另有一個保留的 5K 行評估 split(取自 quora 的尾段),用以計算訓練期間的評估 loss。

訓練參數

大部分超參數在不同模型規模間保持不變:

CrossEncoderTrainingArguments(
    num_train_epochs=1,                    # I chose more data over more epochs
    per_device_train_batch_size=...,       # global_batch_size // world_size (see table below)
    gradient_accumulation_steps=1,
    learning_rate=...,                     # per-size, see table
    warmup_ratio=0.03,                     # ~3% linear warmup, then linear decay (default)
    bf16=True,                             # FA2 + bf16 throughout
    eval_strategy="steps",
    eval_steps=0.05,                       # NanoBEIR every 5% of training
    save_strategy="steps",
    save_steps=0.05,
    save_total_limit=5,
    load_best_model_at_end=True,
    metric_for_best_model="eval_NanoBEIR_R100_mean_ndcg@10",
    seed=12,
)

只有學習率和全域批次大小會按模型規模調整。

規模 學習率 全域批次大小
17m 2.4e-4 1024
32m 1.2e-4 512
68m 3e-5 256
150m 1.5e-5 192
400m 7e-6 256
1b 3e-6 512

global_batch_size = per_device_batch_size x world_size x gradient_accumulation_steps。在單一 8-GPU 節點上,17m 模型的全域批次 1024 代表 per_device=128;在 8 個節點上則代表 per_device=8。訓練指令碼會按 per_device_batch_size = global_batch_size // world_size 計算,因此任何節點數都可使用同一份指令碼。全域批次大小本可調得更一致,但我發現以上數值運作良好,不想只為了保持一致而重新調校。

評估

訓練期間,我會監察 NanoBEIR 平均 NDCG@10(每完成 5% steps 評估一次),並將它設為 metric_for_best_model,供 load_best_model_at_end 使用。NanoBEIR 執行速度快,因此每次訓練可評估 20 次。訓練完成後,我會在完整 MTEB(eng, v2) Retrieval 基準測試上評估最佳檢查點(按 NanoBEIR 判定)及最後檢查點。最終發布的是 MTEB 表現較佳的檢查點。除 68m 規模外,其餘均由 NanoBEIR 選出的檢查點勝出;只有該規模是最後檢查點略勝。

完整訓練指令碼

完整指令碼(每款已發布模型實際採用的訓練內容)只有一個檔案。每次執行只需更改 ENCODER_SIZE,其餘步驟全部自動處理:

from __future__ import annotations

import logging
import os
from pathlib import Path

import torch
import torch.nn as nn
from datasets import concatenate_datasets, get_dataset_config_names, load_dataset

from sentence_transformers import CrossEncoder
from sentence_transformers.base.modules import Dense
from sentence_transformers.cross_encoder import (
    CrossEncoderModelCardData,
    CrossEncoderTrainer,
    CrossEncoderTrainingArguments,
)
from sentence_transformers.cross_encoder.evaluation import CrossEncoderNanoBEIREvaluator
from sentence_transformers.cross_encoder.losses import MSELoss
from sentence_transformers.sentence_transformer.modules import LayerNorm, Pooling, Transformer

logging.basicConfig(level=logging.INFO, format="%(asctime)s %(message)s", datefmt="%H:%M:%S")
logging.getLogger("httpx").setLevel(logging.WARNING)

# Per-size config. I swept the learning rates with these global (effective) batch sizes,
# also by incorporating accum_steps
CONFIGS: dict[str, dict] = {
    "17m":  {"base_model_name": "jhu-clsp/ettin-encoder-17m",  "learning_rate": 2.4e-4, "global_batch_size": 1024},
    "32m":  {"base_model_name": "jhu-clsp/ettin-encoder-32m",  "learning_rate": 1.2e-4, "global_batch_size": 512},
    "68m":  {"base_model_name": "jhu-clsp/ettin-encoder-68m",  "learning_rate": 3e-5,   "global_batch_size": 256},
    "150m": {"base_model_name": "jhu-clsp/ettin-encoder-150m", "learning_rate": 1.5e-5, "global_batch_size": 192},
    "400m": {"base_model_name": "jhu-clsp/ettin-encoder-400m", "learning_rate": 7e-6,   "global_batch_size": 256},
    "1b":   {"base_model_name": "jhu-clsp/ettin-encoder-1b",   "learning_rate": 3e-6,   "global_batch_size": 512},
}
ENCODER_SIZE = "17m"

def main() -> None:
    config = CONFIGS[ENCODER_SIZE]
    encoder_id = config["base_model_name"]
    learning_rate = config["learning_rate"]
    global_batch_size = config["global_batch_size"]

    world_size = int(os.environ.get("WORLD_SIZE", 1))
    per_device_batch_size = global_batch_size // world_size
    dataloader_workers = 0 if world_size > 8 else 4
    run_name = f"ettin-reranker-{ENCODER_SIZE}-lr{learning_rate:.0e}"

    # 1. Load a model to finetune with model card data
    # The model mirrors ModernBertForSequenceClassification, but with a 'headless' Transformer that just loads
    # AutoModel. This allows for unpadding with FA2, which isn't possible with AutoModelForSequenceClassification.
    # This speeds up training considerably, while heavily reducing memory usage.
    torch.manual_seed(12)
    transformer = Transformer(encoder_id, model_kwargs={"attn_implementation": "flash_attention_2"})
    transformer.model.config.num_labels = 1
    embedding_dimension = transformer.get_embedding_dimension()
    pooling = Pooling(embedding_dimension=embedding_dimension, pooling_mode="cls")
    dense_inner = Dense(
        in_features=embedding_dimension, out_features=embedding_dimension, bias=False,
        activation_function=nn.GELU(),
        module_input_name="sentence_embedding", module_output_name="sentence_embedding",
    )
    norm = LayerNorm(dimension=embedding_dimension)
    dense_score = Dense(
        in_features=embedding_dimension, out_features=1, bias=True,
        activation_function=nn.Identity(),
        module_input_name="sentence_embedding", module_output_name="scores",
    )
    model = CrossEncoder(
        modules=[transformer, pooling, dense_inner, norm, dense_score],
        num_labels=1,
        activation_fn=nn.Identity(),
        model_card_data=CrossEncoderModelCardData(
            model_name=f"Ettin Reranker {ENCODER_SIZE} distilled from mxbai-rerank-large-v2",
            language="en",
            license="apache-2.0",
        ),
    )
    actual_attn = getattr(model[0].model.config, "_attn_implementation", None)
    if not (actual_attn and "flash" in actual_attn.lower()):
        logging.warning(f"FA2 may not be active (attn_impl={actual_attn!r}); training will be slower.")

    # 2. Load the dataset. Each config is one source subset (32 lighton + 7 rerank retrieval
    # domains). The held-out eval rows live as the 'validation' split of the 'quora' config.
    dataset_repo = "cross-encoder/ettin-reranker-v1-data"
    train_pieces = []
    eval_dataset = None
    for config_name in get_dataset_config_names(dataset_repo):
        dataset = load_dataset(dataset_repo, config_name)
        train_pieces.append(dataset["train"])
        if "validation" in dataset:
            eval_dataset = dataset["validation"]
    train_dataset = concatenate_datasets(train_pieces)
    print(train_dataset)

    # 3. Define a loss function
    loss = MSELoss(model)

    # 4. Specify training arguments
    args = CrossEncoderTrainingArguments(
        output_dir=f"models/{run_name}",
        num_train_epochs=1,
        per_device_train_batch_size=per_device_batch_size,
        per_device_eval_batch_size=per_device_batch_size,
        gradient_accumulation_steps=1,
        learning_rate=learning_rate,
        warmup_ratio=0.03,
        bf16=True,
        eval_strategy="steps",
        eval_steps=0.05,
        save_strategy="steps",
        save_steps=0.05,
        save_total_limit=5,
        logging_steps=0.025,
        logging_first_step=True,
        load_best_model_at_end=True,
        metric_for_best_model="eval_NanoBEIR_R100_mean_ndcg@10",
        dataloader_num_workers=dataloader_workers,
        run_name=run_name,
        seed=12,
    )

    # 5. Create an evaluator
    evaluator = CrossEncoderNanoBEIREvaluator(
        dataset_names=["msmarco", "nfcorpus", "nq", "fiqa2018", "touche2020", "scifact",
                       "hotpotqa", "arguana", "fever", "dbpedia", "climatefever", "scidocs",
                       "quoraretrieval"],
        batch_size=per_device_batch_size,
        always_rerank_positives=False,
        show_progress_bar=False,
    )

    # 6. Create a trainer
    trainer = CrossEncoderTrainer(
        model=model,
        args=args,
        train_dataset=train_dataset,
        eval_dataset=eval_dataset,
        loss=loss,
        evaluator=evaluator,
    )

    # 7. Evaluate before training
    if trainer.is_world_process_zero():
        with torch.autocast(device_type="cuda", dtype=torch.bfloat16):
            evaluator(model)

    # 8. Train
    trainer.train()

    # 9. Evaluate the final model
    if trainer.is_world_process_zero():
        with torch.autocast(device_type="cuda", dtype=torch.bfloat16):
            evaluator(model)

    # 10. Save the final model
    final_dir = f"models/{run_name}/final"
    model.save_pretrained(final_dir)


if __name__ == "__main__":
    main()

如要進行多節點訓練(模型規模高於 17m/32m),使用 torchrun 啟動相同指令碼:

# Single-node (17m, 32m): defaults work
python train.py

# Multi-node 4n setup for 150m, preserves global_batch_size=192:
torchrun --nproc_per_node=8 --nnodes=4 ... train.py

總結

ettin-reranker-v1 系列以簡單一致的配方訓練,在所有已發布、最高至 1B 參數的規模中均達到最先進水平。從強力教師模型向涵蓋廣泛領域及檢索任務的混合資料進行逐點 MSE 蒸餾,可順利擴展至 17M 至 1B 參數;不同規模只需調整學習率和每裝置批次大小。

每款 ettin-reranker-v1 模型在 MTEB 和 NanoBEIR 上都明顯勝過 ms-marco-MiniLM-L*-v2 系列。cross-encoder/ettin-reranker-150m-v1 是我測試過、低於 600M 規模中最強的中階重排序器;cross-encoder/ettin-reranker-400m-v1 的 MTEB 分數與 1.54B 教師模型相差僅 0.0024,而 cross-encoder/ettin-reranker-1b-v1 更只差 0.0001。

所有資源集中於此:

如果你以這些模型為基礎開發任何項目,請告訴我!我很想看到大家的成果;如果你利用公開資料訓練出更好的重排序器,那就更好了。這套配方刻意保持簡單,部分原因是希望留下充足改進空間。只要訓練出更強的教師模型,同一份指令碼就能繼續產生更好的學生模型。

鳴謝

感謝 Ettin 團隊(Orion Weller、Kathryn Ricci、Marc Marone、Antoine Chaffin、Dawn Lawrie 及 Benjamin Van Durme)建立基礎編碼器,讓這些重排序器得以建基其上;感謝 LightOn 團隊(Antoine Chaffin、Raphael Sourty、Paulo Moura 及 Amélie Chatelain)收集訓練資料;亦感謝 Mixedbread AI 團隊(Xianming Li、Aamir Shakir、Rui Huang、Tsz-fung Andrew Lee、Julius Lipp、Benjamin Clavié 及 Jing Li)建立教師模型。

引用

如你使用 ettin-reranker-v1 系列或任何已發布資源,請引用這篇網誌:

@misc{aarsen2026ettin-reranker,
    title = "Introducing the Ettin Reranker Family",
    author = "Aarsen, Tom",
    year = "2026",
    publisher = "Hugging Face",
    url = "https://huggingface.co/blog/ettin-reranker",
}

來源:Hugging Face Blog · huggingface.co