跳到正文
Hugging Face Blog·· 2025-07-01精選AI 評分64

使用 Sentence Transformers 訓練及微調稀疏嵌入模型

Training and Finetuning Sparse Embedding Models with Sentence Transformers

AI 導讀

Hugging Face Blog 示範如何使用 Sentence Transformers 訓練及微調稀疏嵌入模型,介紹 SPLADE、Inference-free SPLADE、CSR 架構,以及資料、損失函數、評估器和訓練器的配置。

推薦理由

文章按 SPLADE、Inference-free SPLADE 與 CSR 的適用情境梳理架構選擇,並以實作例子串連資料、損失函數和評估器配置。

正文 · 繁體中文

Sentence Transformers 是一個 Python 程式庫,可用於使用及訓練密集嵌入、重排序(交叉編碼器)和稀疏嵌入模型,適用於檢索增強生成、語義搜尋、語義文本相似度、近似語句挖掘等各種應用。本文會示範如何使用它微調稀疏編碼器/嵌入模型,並解釋箇中原因。成果是 sparse-encoder/example-inference-free-splade-distilbert-base-uncased-nq,這個低成本模型尤其適合混合搜尋或先檢索後重排序的情境。

微調稀疏嵌入模型涉及多個部分:模型、資料集、損失函式、訓練參數、評估器及 trainer 類別。我會逐一介紹這些部分,並提供實例,示範如何運用它們微調高效能稀疏嵌入模型。

除了自行訓練模型,你亦可從 Hugging Face Hub 提供的大量預訓練稀疏編碼器中選擇。為方便瀏覽日益增多的模型,我們整理了SPLADE 模型系列,列出部分較重要的模型。
文件中的預訓練模型頁面則列出主要模型及其基準測試結果。

Table of Contents

甚麼是稀疏嵌入模型?

「嵌入模型」是一個較廣泛的統稱,指把輸入(通常是文字)轉換成向量表徵(嵌入),以捕捉其語義。與原始輸入不同,你可以對這些嵌入進行數學運算,得出相似度分數,並用於搜尋、分羣或分類等任務。

密集嵌入模型是較常見的類型,其嵌入通常是低維向量(例如 384、768 或 1024 維),大部分數值都非零。相反,稀疏嵌入模型會產生高維向量(例如超過 30,000 維),大部分數值為零。稀疏嵌入中的每個活躍維度(即數值非零的維度)通常對應模型詞彙表中的特定 token,因此具備可解釋性。

以下以最先進的稀疏嵌入模型 naver/splade-v3 為例:

from sentence_transformers import SparseEncoder

# Download from the 🤗 Hub
model = SparseEncoder("naver/splade-v3")

# Run inference
sentences = [
    "The weather is lovely today.",
    "It's so sunny outside!",
    "He drove to the stadium.",
]
embeddings = model.encode(sentences)
print(embeddings.shape)
# (3, 30522)

# Get the similarity scores for the embeddings
similarities = model.similarity(embeddings, embeddings)
print(similarities)
# tensor([[   32.4323,     5.8528,     0.0258],
#         [    5.8528,    26.6649,     0.0302],
#         [    0.0258,     0.0302,    24.0839]])

# Let's decode our embeddings to be able to interpret them
decoded = model.decode(embeddings, top_k=10)
for decoded, sentence in zip(decoded, sentences):
    print(f"Sentence: {sentence}")
    print(f"Decoded: {decoded}")
    print()
Sentence: The weather is lovely today.
Decoded: [('weather', 2.754288673400879), ('today', 2.610959529876709), ('lovely', 2.431990623474121), ('currently', 1.5520408153533936), ('beautiful', 1.5046082735061646), ('cool', 1.4664798974990845), ('pretty', 0.8986214995384216), ('yesterday', 0.8603134155273438), ('nice', 0.8322536945343018), ('summer', 0.7702118158340454)]

Sentence: It's so sunny outside!
Decoded: [('outside', 2.6939032077789307), ('sunny', 2.535827398300171), ('so', 2.0600898265838623), ('out', 1.5397940874099731), ('weather', 1.1198079586029053), ('very', 0.9873268604278564), ('cool', 0.9406591057777405), ('it', 0.9026399254798889), ('summer', 0.684999406337738), ('sun', 0.6520509123802185)]

Sentence: He drove to the stadium.
Decoded: [('stadium', 2.7872302532196045), ('drove', 1.8208855390548706), ('driving', 1.6665740013122559), ('drive', 1.5565159320831299), ('he', 1.4721972942352295), ('stadiums', 1.449463129043579), ('to', 1.0441515445709229), ('car', 0.7002660632133484), ('visit', 0.5118278861045837), ('football', 0.502326250076294)]

在此例中,嵌入是 30,522 維向量,每個維度都對應模型詞彙表中的一個 token。decode 方法會回傳嵌入中數值最高的前 10 個 token,讓我們可以瞭解哪些 token 對嵌入貢獻最大。

我們甚至可以找出嵌入之間的交集或重疊部分,有助判斷兩段文字為何被視為相似或不相似:

# Let's also compute the intersection/overlap of the first two embeddings
intersection_embedding = model.intersection(embeddings[0], embeddings[1])
decoded_intersection = model.decode(intersection_embedding)
print(decoded_intersection)
Decoded: [('weather', 3.0842742919921875), ('cool', 1.379457712173462), ('summer', 0.5275946259498596), ('comfort', 0.3239051103591919), ('sally', 0.22571465373039246), ('julian', 0.14787325263023376), ('nature', 0.08582140505313873), ('beauty', 0.0588383711874485), ('mood', 0.018594780936837196), ('nathan', 0.000752730411477387)]

查詢與文件擴展

神經稀疏嵌入模型的一個關鍵部分是查詢/文件擴展。傳統詞法方法(例如 BM25)只會配對完全相同的 token;神經稀疏模型通常會自動以語義相關詞彙擴展原文:

  • 傳統詞法方法(例如 BM25):只配對文字中完全相同的 token
  • 神經稀疏模型:自動加入相關詞彙進行擴展

例如,在上方程式輸出中,句子「今天天氣很好」會擴展加入「美麗」、「涼爽」、「漂亮」和「不錯」等原文沒有的詞。同樣,「外面陽光真充沛!」會擴展加入「天氣」、「夏天」和「太陽」。

這種擴展讓神經稀疏模型即使找不到完全相同的 token,也能配對語義相關內容或同義詞、處理拼字錯誤,以及克服詞彙不匹配問題。因此,SPLADE 等神經稀疏模型往往比傳統詞法搜尋更有效,同時保留稀疏表徵的效率優勢。

不過,擴展亦有風險。例如,「星期二的天氣如何?」可能會擴展至「星期一」、「星期三」等詞,這未必符合預期。

為何使用稀疏嵌入模型?

簡言之,神經稀疏嵌入模型位於 BM25 等傳統詞法方法與 Sentence Transformers 等密集嵌入模型之間,佔據一個重要位置。它們有以下優點:

  • 適合混合搜尋:可與密集模型有效結合;密集模型在重視詞法配對的搜尋中可能表現較弱
  • 可解釋性:可清楚查看哪些 token 對配對結果有貢獻
  • 效能:在許多檢索任務中可媲美或勝過密集模型

本文會交替使用「稀疏嵌入模型」和「稀疏編碼器模型」兩個名稱,兩者指同一類模型。

為何要微調?

大部分(神經)稀疏嵌入模型都會採用上述查詢/文件擴展,讓你即使面對沒有任何共同詞語、但意思幾乎相同的文字,也能成功配對。簡單來説,模型必須辨識同義詞,才能把相關 token 放進最終嵌入。

大部分開箱即用的稀疏嵌入模型都能輕易識別,「超市」、「食物」和「市場」是包含「雜貨」文字的有用擴展詞;但例如:

  • 「病人表示患有嚴重的 cephalalgia(頭痛)。」

會擴展為:

'##lal', 'severe', '##pha', 'ce', '##gia', 'patient', 'complaint', 'patients', 'complained', 'warning', 'suffered', 'had', 'disease', 'complain', 'diagnosis', 'syndrome', 'mild', 'pain', 'hospital', 'injury'

但我們希望它擴展為「headache」,即「cephalalgia」較常見的説法。這類問題會出現在許多領域,例如模型未能識別「Java」是一種程式語言、「Audi」生產汽車,或「NVIDIA」是一家顯示卡公司。

透過微調,模型可以學會只專注於對你重要的領域及/或語言。

訓練組成部分

訓練 Sentence Transformer 模型涉及以下部分:

  1. 模型:要訓練或微調的模型,可以是預訓練稀疏編碼器模型或基礎模型。
  2. 資料集:用於訓練和評估的資料。
  3. 損失函式:量化模型表現並引導最佳化過程的函式。
  4. 訓練參數(可選):影響訓練效能、追蹤及除錯的參數。
  5. 評估器(可選):在訓練前、訓練期間或訓練後評估模型的工具。
  6. Trainer:整合模型、資料集、損失函式及其他訓練組件。

現在,讓我們逐一深入瞭解這些組成部分。

模型

Sparse Encoder 模型由一連串模組、稀疏編碼器專用模組或自訂模組組成,提供高度彈性。如果你想進一步微調稀疏編碼器模型(例如模型含有 modules.json 檔案),便毋須擔心它使用哪些模組:

from sentence_transformers import SparseEncoder

model = SparseEncoder("naver/splade-cocondenser-ensembledistil")

但如果你想從另一個 checkpoint 或從零開始訓練,以下是最常用的架構:

SPLADE

SPLADE 模型先使用 MLMTransformer,再接上 SpladePooling 模組。前者會載入預訓練的遮罩語言模型 Transformer(例如 BERT、RoBERTa、DistilBERT、ModernBERT 等),後者則會池化 MLMHead 的輸出,產生一個維度與詞彙表大小相同的稀疏嵌入。

from sentence_transformers import models, SparseEncoder
from sentence_transformers.sparse_encoder.models import MLMTransformer, SpladePooling

# Initialize MLM Transformer (use a fill-mask model)
mlm_transformer = MLMTransformer("google-bert/bert-base-uncased")

# Initialize SpladePooling module
splade_pooling = SpladePooling(pooling_strategy="max")

# Create the Splade model
model = SparseEncoder(modules=[mlm_transformer, splade_pooling])

如果你向 SparseEncoder 提供 fill-mask 模型架構,這就是預設架構,因此直接使用捷徑會更簡單:

from sentence_transformers import SparseEncoder

model = SparseEncoder("google-bert/bert-base-uncased")
# SparseEncoder(
#   (0): MLMTransformer({'max_seq_length': 512, 'do_lower_case': False, 'architecture': 'BertForMaskedLM'})
#   (1): SpladePooling({'pooling_strategy': 'max', 'activation_function': 'relu', 'word_embedding_dimension': None})
# )

免推論 SPLADE

免推論 SPLADE 使用 Router 模組,分別為查詢和文件配置不同模組。通常,文件部分採用傳統 SPLADE 架構(先使用 MLMTransformer,再接上 SpladePooling 模組),查詢部分則使用 SparseStaticEmbedding 模組,直接回傳查詢中每個 token 的預先計算分數。

from sentence_transformers import SparseEncoder
from sentence_transformers.models import Router
from sentence_transformers.sparse_encoder.models import SparseStaticEmbedding, MLMTransformer, SpladePooling

# Initialize MLM Transformer for document encoding
doc_encoder = MLMTransformer("google-bert/bert-base-uncased")

# Create a router model with different paths for queries and documents
router = Router.for_query_document(
    query_modules=[SparseStaticEmbedding(tokenizer=doc_encoder.tokenizer, frozen=False)],
    # Document path: full MLM transformer + pooling
    document_modules=[doc_encoder, SpladePooling("max")],
)

# Create the inference-free model
model = SparseEncoder(modules=[router], similarity_fn_name="dot")
# SparseEncoder(
#   (0): Router(
#     (query_0_SparseStaticEmbedding): SparseStaticEmbedding ({'frozen': False}, dim:30522, tokenizer: BertTokenizerFast)
#     (document_0_MLMTransformer): MLMTransformer({'max_seq_length': 512, 'do_lower_case': False, 'architecture': 'BertForMaskedLM'})
#     (document_1_SpladePooling): SpladePooling({'pooling_strategy': 'max', 'activation_function': 'relu', 'word_embedding_dimension': None})
#   )
# )

這種架構採用輕量的 SparseStaticEmbedding 方法,可快速處理查詢;它可以訓練,並可視為一組線性權重,而文件則交由完整的 MLM Transformer 和 SpladePooling 處理。

免推論 SPLADE 特別適合查詢延遲至關重要的搜尋應用,因為它把計算複雜度轉移至可離線執行的文件索引階段。

使用 Router 模組訓練模型時,必須透過 router_mapping 參數,在 SparseEncoderTrainingArguments 中將訓練資料集欄位對應至正確路由(「query」或「document」)。例如,如果資料集包含 ["question", "answer"] 欄位,可以使用以下對應方式:

args = SparseEncoderTrainingArguments(
    ...,
    router_mapping={
        "question": "query",
        "answer": "document",
    }
)

此外,建議為 SparseStaticEmbedding 模組設定遠高於模型其餘部分的學習率。你可使用 learning_rate_mapping 參數,在 SparseEncoderTrainingArguments 中將參數模式對應至學習率。例如,若想為 SparseStaticEmbedding 模組使用 1e-3,並為模型其餘部分使用 2e-5,可按以下方式設定:

args = SparseEncoderTrainingArguments(
    ...,
    learning_rate=2e-5,
    learning_rate_mapping={
        r"SparseStaticEmbedding\.*": 1e-3,
    }
)

對比式稀疏表徵(CSR)

對比式稀疏表徵(CSR)模型由論文超越 Matryoshka:重新探討自適應表徵的稀疏編碼提出,會在密集 Sentence Transformer 模型上方套用 SparseAutoEncoder 模組。密集模型通常由 Transformer 和其後的 Pooling 模組組成。你可以像這樣從零初始化:

from sentence_transformers import models, SparseEncoder
from sentence_transformers.sparse_encoder.models import SparseAutoEncoder

# Initialize transformer (can be any dense encoder model)
transformer = models.Transformer("google-bert/bert-base-uncased")

# Initialize pooling
pooling = models.Pooling(transformer.get_word_embedding_dimension(), pooling_mode="mean")

# Initialize SparseAutoEncoder module
sparse_auto_encoder = SparseAutoEncoder(
    input_dim=transformer.get_word_embedding_dimension(),
    hidden_dim=4 * transformer.get_word_embedding_dimension(),
    k=256,  # Number of top values to keep
    k_aux=512,  # Number of top values for auxiliary loss
)
# Create the CSR model
model = SparseEncoder(modules=[transformer, pooling, sparse_auto_encoder])

如果你的基礎模型是 1)密集 Sentence Transformer 模型,或 2)非 MLM Transformer 模型(預設會以 SPLADE 模型載入),則可使用以下捷徑自動初始化 CSR 模型:

from sentence_transformers import SparseEncoder

model = SparseEncoder("mixedbread-ai/mxbai-embed-large-v1")
# SparseEncoder(
#   (0): Transformer({'max_seq_length': 512, 'do_lower_case': False, 'architecture': 'BertModel'})
#   (1): Pooling({'word_embedding_dimension': 1024, 'pooling_mode_cls_token': True, 'pooling_mode_mean_tokens': False, 'pooling_mode_max_tokens': False, 'pooling_mode_mean_sqrt_len_tokens': False, 'pooling_mode_weightedmean_tokens': False, 'pooling_mode_lasttoken': False, 'include_prompt': True})
#   (2): SparseAutoEncoder({'input_dim': 1024, 'hidden_dim': 4096, 'k': 256, 'k_aux': 512, 'normalize': False, 'dead_threshold': 30})
# )

與(免推論)SPLADE 模型不同,CSR 模型的稀疏嵌入維度不會等於基礎模型的詞彙表大小。這表示你無法像 SPLADE 模型那樣直接解讀嵌入中哪些詞被啟用;在 SPLADE 中,每個維度都對應詞彙表中的特定 token。

除此以外,CSR 模型最適合套用於使用高維表徵(例如 1024–4096 維)的密集編碼器模型。

架構選擇指南

如果你不確定應使用哪種架構,可參考以下簡易指南:

  • 你想把現有密集嵌入模型稀疏化嗎?如果是,請使用 CSR。
  • 你想讓查詢推論近乎即時,並願意接受輕微的效能代價嗎?如果是,請使用免推論 SPLADE。
  • 否則,請使用 SPLADE。

資料集

SparseEncoderTrainer 使用 datasets.Dataset 或 datasets.DatasetDict 實例進行訓練及評估。你可以從 Hugging Face Datasets Hub 載入資料,亦可使用 CSV、JSON、Parquet、Arrow 或 SQL 等格式的本機資料。

注意:許多可直接配合 Sentence Transformers 使用的公開資料集,已在 Hugging Face Hub 加上 sentence-transformers 標籤,因此可在 https://huggingface.co/datasets?other=sentence-transformers 輕鬆找到。你可以瀏覽這些資料集,尋找適用於任務、領域或語言的現成資料。

Hugging Face Hub 上的資料

你可以使用 load_dataset 函式,從 Hugging Face Hub 的資料集中載入資料。

from datasets import load_dataset

train_dataset = load_dataset("sentence-transformers/natural-questions", split="train")

print(train_dataset)
"""
Dataset({
    features: ['query', 'answer'],
    num_rows: 100231
})
"""

部分資料集(例如 nthakur/swim-ir-monolingual)包含多個資料格式各異的子集。載入時須同時指定資料集名稱和子集名稱,例如 dataset = load_dataset("nthakur/swim-ir-monolingual", "de", split="train")。

本機資料(CSV、JSON、Parquet、Arrow、SQL)

你亦可使用 load_dataset 載入特定檔案格式的本機資料:

from datasets import load_dataset

dataset = load_dataset("csv", data_files="my_file.csv")
# or
dataset = load_dataset("json", data_files="my_file.json")

需要預處理的本機資料

如果本機資料需要預處理,可使用 datasets.Dataset.from_dict。這樣便可以用由多個清單組成的字典初始化資料集:

from datasets import Dataset

queries = []
documents = []
# Open a file, perform preprocessing, filtering, cleaning, etc.
# and append to the lists

dataset = Dataset.from_dict({
    "query": queries,
    "document": documents,
})

字典中的每個 key 都會成為結果資料集中的一個欄位。

資料集格式

確保資料集格式符合所選損失函式十分重要。你需要檢查兩項內容:

  1. 如果所選損失函式需要標籤(見損失函式概覽表),資料集必須包含名為 "label" 或 "score" 的欄位。
  2. 除 "label" 或 "score" 以外的欄位都會被視為輸入(見損失函式概覽表)。這些欄位的數目必須符合所選損失函式所需的有效輸入數目。欄位名稱並不重要,只有次序重要。

例如,如果損失函式接受 (anchor, positive, negative) triplets,資料集的第一、第二和第三欄便分別對應 anchor、positive 和 negative。因此,第一和第二欄必須包含應該嵌入得較接近的文字,而第一和第三欄則必須包含應該嵌入得較遠的文字。這就是為何資料集欄位次序取決於你選用的損失函式。

假設資料集包含 ["text1", "text2", "label"] 欄位,而 "label" 欄存放浮點數相似度分數。這個資料集可用於 SparseCoSENTLoss、SparseAnglELoss 和 SparseCosineSimilarityLoss,原因如下:

  1. 資料集包含這些損失函式所需的 "label" 欄位。
  2. 資料集有 2 個非標籤欄位,符合這些損失函式所需的輸入數目。

如果資料集欄位次序不正確,請使用 Dataset.select_columns 重新排序。此外,亦要移除多餘欄位(例如 sample_id、metadata、source、type),否則它們也會被當作輸入;可使用 Dataset.remove_columns。

損失函式

損失函式會量度模型在指定資料批次上的表現,並引導最佳化過程。應按你可用的資料及目標任務選擇損失函式。完整選項清單請參閲損失函式概覽。

訓練 SparseEncoder 時,須按架構選擇 SpladeLoss 或 CSRLoss。這兩者是包裝損失函式,會在主要損失函式上加入稀疏正則化;主要損失函式必須以參數形式提供。唯一可獨立使用的損失函式是 SparseMSELoss,它會進行嵌入層級蒸餾,直接複製教師模型的稀疏嵌入以確保稀疏性。

大部分損失函式只需傳入正在訓練的 SparseEncoder 即可初始化,亦可選擇提供其他參數,例如:

from datasets import load_dataset
from sentence_transformers import SparseEncoder
from sentence_transformers.sparse_encoder.losses import SpladeLoss, SparseMultipleNegativesRankingLoss

# Load a model to train/finetune
model = SparseEncoder("distilbert/distilbert-base-uncased")

# Initialize the SpladeLoss with a SparseMultipleNegativesRankingLoss
# This loss requires pairs of related texts or triplets
loss = SpladeLoss(
    model=model,
    loss=SparseMultipleNegativesRankingLoss(model=model),
    query_regularizer_weight=5e-5,  # Weight for query loss
    document_regularizer_weight=3e-5,
) 

# Load an example training dataset that works with our loss function:
train_dataset = load_dataset("sentence-transformers/natural-questions", split="train")
print(train_dataset)
"""
Dataset({
    features: ['query', 'answer'],
    num_rows: 100231
})
"""

文件

訓練參數

SparseEncoderTrainingArguments 類別可讓你指定影響訓練效能、追蹤和除錯的參數。雖然這些參數是可選的,但嘗試不同設定有助提升訓練效率,並瞭解訓練過程。

我在 Sentence Transformers 文件中整理了一些最實用的訓練參數,建議閲讀訓練概覽 > 訓練參數。

以下是初始化 SparseEncoderTrainingArguments 的範例:

from sentence_transformers import SparseEncoderTrainingArguments

args = SparseEncoderTrainingArguments(
    # Required parameter:
    output_dir="models/splade-distilbert-base-uncased-nq",
    # Optional training parameters:
    num_train_epochs=1,
    per_device_train_batch_size=16,
    per_device_eval_batch_size=16,
    learning_rate=2e-5,
    warmup_ratio=0.1,
    fp16=True,  # Set to False if your GPU can't handle FP16
    bf16=False,  # Set to True if your GPU supports BF16
    batch_sampler=BatchSamplers.NO_DUPLICATES,  # Losses using "in-batch negatives" benefit from no duplicates
    # Optional tracking/debugging parameters:
    eval_strategy="steps",
    eval_steps=100,
    save_strategy="steps",
    save_steps=100,
    save_total_limit=2,
    logging_steps=100,
    run_name="splade-distilbert-base-uncased-nq",  # Used in W&B if `wandb` is installed
)

請注意,eval_strategy 是從 transformers 4.41.0 版開始引入。較舊版本應改用 evaluation_strategy。

評估器

你可以向 SparseEncoderTrainer 提供 eval_dataset,以取得訓練期間的評估損失;同時取得更具體的訓練指標也可能很有用。你可使用評估器,在訓練前、訓練期間或訓練後以實用指標評估模型表現。你可以同時使用 eval_dataset 和評估器、只使用其中一種,或兩者皆不使用。評估會根據 eval_strategy 和 eval_steps 執行,詳情請參閲訓練參數。

以下是 Sentence Transformers 為 Sparse Encoder 模型提供的評估器:

評估器 所需資料
SparseBinaryClassificationEvaluator 包含類別標籤的配對。
SparseEmbeddingSimilarityEvaluator 包含相似度分數的配對。
SparseInformationRetrievalEvaluator 查詢(qid => question)、語料庫(cid => document)及相關文件(qid => set[cid])。
SparseNanoBEIREvaluator 毋須提供資料。
SparseMSEEvaluator 由教師模型嵌入的來源句子,以及由學生模型嵌入的目標句子;兩者可以是相同文字。
SparseRerankingEvaluator 由 {'query': '...', 'positive': [...], 'negative': [...]} 字典組成的清單。
SparseTranslationEvaluator 以兩種不同語言撰寫的句子配對。
SparseTripletEvaluator (anchor, positive, negative) 配對。

此外,應使用 SequentialEvaluator 把多個評估器合併成單一評估器,再傳入 SparseEncoderTrainer。

有時你可能沒有所需評估資料,無法自行準備這些評估器,但仍想追蹤模型在常見基準測試上的表現。此時可使用 Hugging Face 的資料搭配這些評估器。

SparseNanoBEIREvaluator

文件

from sentence_transformers.sparse_encoder.evaluation import SparseNanoBEIREvaluator

# Initialize the evaluator. Unlike most other evaluators, this one loads the relevant datasets
# directly from Hugging Face, so there's no mandatory arguments
dev_evaluator = SparseNanoBEIREvaluator()
# You can run evaluation like so:
# results = dev_evaluator(model)

使用 STSb 的 SparseEmbeddingSimilarityEvaluator

文件

from datasets import load_dataset
from sentence_transformers.evaluation import SimilarityFunction
from sentence_transformers.sparse_encoder.evaluation import SparseEmbeddingSimilarityEvaluator

# Load the STSB dataset (https://huggingface.co/datasets/sentence-transformers/stsb)
eval_dataset = load_dataset("sentence-transformers/stsb", split="validation")

# Initialize the evaluator
dev_evaluator = SparseEmbeddingSimilarityEvaluator(
    sentences1=eval_dataset["sentence1"],
    sentences2=eval_dataset["sentence2"],
    scores=eval_dataset["score"],
    main_similarity=SimilarityFunction.COSINE,
    name="sts-dev",
)
# You can run evaluation like so:
# results = dev_evaluator(model)

使用 AllNLI 的 SparseTripletEvaluator

文件

from datasets import load_dataset
from sentence_transformers.evaluation import SimilarityFunction
from sentence_transformers.sparse_encoder.evaluation import SparseTripletEvaluator

# Load triplets from the AllNLI dataset (https://huggingface.co/datasets/sentence-transformers/all-nli)
max_samples = 1000
eval_dataset = load_dataset("sentence-transformers/all-nli", "triplet", split=f"dev[:{max_samples}]")

# Initialize the evaluator
dev_evaluator = SparseTripletEvaluator(
    anchors=eval_dataset["anchor"],
    positives=eval_dataset["positive"],
    negatives=eval_dataset["negative"],
    main_distance_function=SimilarityFunction.DOT,
    name="all-nli-dev",
)
# You can run evaluation like so:
# results = dev_evaluator(model)

如果訓練期間以較小的 eval_steps 頻繁評估,可考慮使用較小的 eval_dataset,以減少評估開銷。如果擔心評估集大小,可採用 90-1-9 的訓練、評估和測試資料切分比例,在最終評估時保留規模合理的測試集。訓練後,可使用 trainer.evaluate(test_dataset) 評估測試損失,或初始化測試評估器 test_evaluator(model) 以取得詳細測試指標。

如果在訓練後、儲存模型前執行評估,自動產生的模型卡仍會包含測試結果。

使用分散式訓練時,評估器只會在第一個裝置上執行;訓練和評估資料集則會在所有裝置間共享。

Trainer

SparseEncoderTrainer 會整合以上所有組件。只需向 trainer 指定模型、訓練參數(可選)、訓練資料集、評估資料集(可選)、損失函式及評估器(可選),便可開始訓練。以下看看如何在腳本中組合這些部分:

import logging

from datasets import load_dataset

from sentence_transformers import (
    SparseEncoder,
    SparseEncoderModelCardData,
    SparseEncoderTrainer,
    SparseEncoderTrainingArguments,
)
from sentence_transformers.models import Router
from sentence_transformers.sparse_encoder.evaluation import SparseNanoBEIREvaluator
from sentence_transformers.sparse_encoder.losses import SparseMultipleNegativesRankingLoss, SpladeLoss
from sentence_transformers.sparse_encoder.models import SparseStaticEmbedding, MLMTransformer, SpladePooling
from sentence_transformers.training_args import BatchSamplers

logging.basicConfig(format="%(asctime)s - %(message)s", datefmt="%Y-%m-%d %H:%M:%S", level=logging.INFO)

# 1. Load a model to finetune with 2. (Optional) model card data
mlm_transformer = MLMTransformer("distilbert/distilbert-base-uncased", tokenizer_args={"model_max_length": 512})
splade_pooling = SpladePooling(
    pooling_strategy="max", word_embedding_dimension=mlm_transformer.get_sentence_embedding_dimension()
)
router = Router.for_query_document(
    query_modules=[SparseStaticEmbedding(tokenizer=mlm_transformer.tokenizer, frozen=False)],
    document_modules=[mlm_transformer, splade_pooling],
)

model = SparseEncoder(
    modules=[router],
    model_card_data=SparseEncoderModelCardData(
        language="en",
        license="apache-2.0",
        model_name="Inference-free SPLADE distilbert-base-uncased trained on Natural-Questions tuples",
    ),
)

# 3. Load a dataset to finetune on
full_dataset = load_dataset("sentence-transformers/natural-questions", split="train").select(range(100_000))
dataset_dict = full_dataset.train_test_split(test_size=1_000, seed=12)
train_dataset = dataset_dict["train"]
eval_dataset = dataset_dict["test"]
print(train_dataset)
print(train_dataset[0])

# 4. Define a loss function
loss = SpladeLoss(
    model=model,
    loss=SparseMultipleNegativesRankingLoss(model=model),
    query_regularizer_weight=0,
    document_regularizer_weight=3e-3,
)

# 5. (Optional) Specify training arguments
run_name = "inference-free-splade-distilbert-base-uncased-nq"
args = SparseEncoderTrainingArguments(
    # Required parameter:
    output_dir=f"models/{run_name}",
    # Optional training parameters:
    num_train_epochs=1,
    per_device_train_batch_size=16,
    per_device_eval_batch_size=16,
    learning_rate=2e-5,
    learning_rate_mapping={r"SparseStaticEmbedding\.weight": 1e-3},  # Set a higher learning rate for the SparseStaticEmbedding module
    warmup_ratio=0.1,
    fp16=True,  # Set to False if you get an error that your GPU can't run on FP16
    bf16=False,  # Set to True if you have a GPU that supports BF16
    batch_sampler=BatchSamplers.NO_DUPLICATES,  # MultipleNegativesRankingLoss benefits from no duplicate samples in a batch
    router_mapping={"query": "query", "answer": "document"},  # Map the column names to the routes
    # Optional tracking/debugging parameters:
    eval_strategy="steps",
    eval_steps=1000,
    save_strategy="steps",
    save_steps=1000,
    save_total_limit=2,
    logging_steps=200,
    run_name=run_name,  # Will be used in W&B if `wandb` is installed
)

# 6. (Optional) Create an evaluator & evaluate the base model
dev_evaluator = SparseNanoBEIREvaluator(dataset_names=["msmarco", "nfcorpus", "nq"], batch_size=16)

# 7. Create a trainer & train
trainer = SparseEncoderTrainer(
    model=model,
    args=args,
    train_dataset=train_dataset,
    eval_dataset=eval_dataset,
    loss=loss,
    evaluator=dev_evaluator,
)
trainer.train()

# 8. Evaluate the model performance again after training
dev_evaluator(model)

# 9. Save the trained model
model.save_pretrained(f"models/{run_name}/final")

# 10. (Optional) Push it to the Hugging Face Hub
model.push_to_hub(run_name)

此例會從 distilbert/distilbert-base-uncased 微調;這是一個尚未成為 Sparse Encoder 的基礎模型。與微調現有 Sparse Encoder 模型(例如 naver/splade-cocondenser-ensembledistil)相比,這種方式需要更多訓練資料。

執行此腳本後,模型 sparse-encoder/example-inference-free-splade-distilbert-base-uncased-nq 便會上傳至我的帳戶。它在 NanoMSMARCO 的 NDCG@10 為 0.5241、在 NanoNFCorpus 的 NDCG@10 為 0.3299、在 NanoNQ 的 NDCG@10 為 0.5357。對一個只使用 Natural Questions 資料集中的 100k 對資料訓練、以 DistilBERT 為基礎的免推論模型而言,這是很不錯的結果。

此模型的文件稀疏嵌入平均使用 184 個活躍維度;查詢則平均使用 7.7 個(即查詢的平均 token 數目)。兩者的稀疏度分別為 99.39% 和 99.97%。

所有資訊都會儲存在自動產生的模型卡中,包括基礎模型、語言、授權、評估結果、訓練及評估資料集資訊、超參數、訓練記錄等。你上傳的模型毋須額外處理,便會包含潛在使用者判斷模型是否適合自己的所需資訊。

回呼函式

Sentence Transformers trainer 支援多種 transformers.TrainerCallback 子類別,包括:

  • 可使用 WandbCallback 將訓練指標記錄到 W&B(須已安裝 wandb)
  • 可使用 TensorBoardCallback 將訓練指標記錄到 TensorBoard(須可使用 tensorboard)
  • 可使用 CodeCarbonCallback 追蹤訓練期間的碳排放(須已安裝 codecarbon)

只要安裝了所需依賴,這些回呼便會自動使用,毋須額外指定。

有關這些回呼及自訂回呼的詳情,請參閲 Transformers 回呼文件。

多資料集訓練

表現出色的模型往往會同時使用多個資料集訓練。SparseEncoderTrainer 可讓你使用多個格式不同的資料集進行訓練,簡化整個流程;你甚至可以為每個資料集套用不同損失函式。多資料集訓練步驟如下:

  1. 使用由 datasets.Dataset 實例(或 datasets.DatasetDict)組成的字典,作為 train_dataset 和 eval_dataset。
  2. (可選)如果想為不同資料集使用不同損失函式,可使用把資料集名稱對應至損失函式的字典。

每個訓練/評估批次只會包含其中一個資料集的樣本。多個資料集的批次抽取次序由 MultiDatasetBatchSamplers enum 決定;可將該設定透過 SparseEncoderTrainingArguments 的 multi_dataset_batch_sampler 傳入。有效選項如下:

  • MultiDatasetBatchSamplers.ROUND_ROBIN:以循環方式逐一從各資料集抽取樣本,直至其中一個用盡。此策略可能不會用盡每個資料集的所有樣本,但可確保各資料集的抽樣量相同。
  • MultiDatasetBatchSamplers.PROPORTIONAL(預設):按各資料集的大小比例抽樣。此策略會使用每個資料集的所有樣本,較大的資料集抽樣次數亦較多。

評估

讓我們使用 NanoMSMARCO 資料集評估剛訓練完成的免推論 SPLADE 模型,並與密集檢索方法比較。我們亦會探討結合稀疏與密集向量的混合檢索方法,以及如何透過重排序進一步提升搜尋品質。

執行稍作修改的 hybrid_search.py 腳本後,使用以下模型可在 NanoMSMARCO 資料集取得這些結果:

稀疏 密集 重排序器 NDCG@10 MRR@10 MAP
x 52.41 43.06 44.20
x 55.40 47.96 49.08
x x 62.22 53.02 53.44
x x 66.31 59.45 60.36
x x 66.28 59.43 60.34
x x x 66.28 59.43 60.34

稀疏和密集排名可透過倒數排名融合(Reciprocal Rank Fusion,RRF)合併,這是結合多個排名結果的簡單方法。如果使用重排序器,它會重新排列前一個檢索階段的結果。

結果顯示,在此資料集上結合密集和稀疏排名的表現非常出色,分別比密集和稀疏基準提升 12.3% 和 18.7%。簡言之,結合稀疏和密集檢索是提升搜尋表現的有效方法。

此外,對任何一種排名套用重排序器,都能把表現提升至約 66.3 NDCG@10。這表示稀疏、密集或混合(密集+稀疏)方法都能在前 100 名中找出相關文件,再由重排序器把它們提升至前 10 名。因此,以「稀疏 → 重排序器」流程取代「密集 → 重排序器」,可能同時降低延遲和成本:

  • 稀疏嵌入的儲存成本可能較低;例如,我們的模型處理 MS MARCO 文件時只使用約 180 個活躍維度,而密集模型通常使用 1024 維。
  • 部分 Sparse Encoder 支援免推論查詢處理,可像 BM25 等詞法方法一樣,幾乎即時完成第一階段檢索。

訓練提示

訓練 Sparse Encoder 模型時,有幾點特性需要留意:

  1. 評估 Sparse Encoder 模型時,不應只看評估分數,也要考慮嵌入的稀疏度。畢竟,稀疏度低代表模型嵌入的儲存成本較高,檢索速度亦較慢。
  2. 效能較好的 Sparse Encoder 模型幾乎都透過較強教師模型(例如CrossEncoder 模型)蒸餾訓練,而非直接使用文字配對或三元組訓練。例如,SPLADE-v3 論文使用 SparseDistillKLDivLoss 和 SparseMarginMSELoss 進行蒸餾。由於這需要更多資料準備,本文不會詳細介紹,但應認真考慮採用蒸餾流程。

向量資料庫整合

訓練稀疏嵌入模型後,下一個重要步驟是在正式環境中有效部署。向量資料庫提供必要基礎設施,讓你大規模儲存、建立索引及檢索稀疏嵌入。常見選項包括 Qdrant、OpenSearch、Elasticsearch 和 Seismic 等。

以上向量資料庫的完整範例,請參閲使用向量資料庫進行語義搜尋的文件;下方亦有 Qdrant 範例。

Qdrant 整合範例

Qdrant 對稀疏向量提供出色支援,具備高效儲存和快速檢索能力。以下是完整實作範例:

先決條件:

  • 在本機運行或可連線至 Qdrant;詳情請參閲 Qdrant 快速入門。
  • 已安裝 Python Qdrant Client:
    pip install qdrant-client
    

此範例示範如何設定 Qdrant 進行稀疏向量搜尋,包括使用稀疏編碼器高效編碼文件並建立索引、以稀疏向量撰寫搜尋查詢,以及提供互動式查詢介面。請看下方:

import time

from datasets import load_dataset
from sentence_transformers import SparseEncoder
from sentence_transformers.sparse_encoder.search_engines import semantic_search_qdrant

# 1. Load the natural-questions dataset with 100K answers
dataset = load_dataset("sentence-transformers/natural-questions", split="train")
num_docs = 10_000
corpus = dataset["answer"][:num_docs]

# 2. Come up with some queries
queries = dataset["query"][:2]

# 3. Load the model
sparse_model = SparseEncoder("naver/splade-cocondenser-ensembledistil")

# 4. Encode the corpus
corpus_embeddings = sparse_model.encode_document(
    corpus, convert_to_sparse_tensor=True, batch_size=16, show_progress_bar=True
)

# Initially, we don't have a qdrant index yet
corpus_index = None
while True:
    # 5. Encode the queries using the full precision
    start_time = time.time()
    query_embeddings = sparse_model.encode_query(queries, convert_to_sparse_tensor=True)
    print(f"Encoding time: {time.time() - start_time:.6f} seconds")

    # 6. Perform semantic search using qdrant
    results, search_time, corpus_index = semantic_search_qdrant(
        query_embeddings,
        corpus_index=corpus_index,
        corpus_embeddings=corpus_embeddings if corpus_index is None else None,
        top_k=5,
        output_index=True,
    )

    # 7. Output the results
    print(f"Search time: {search_time:.6f} seconds")
    for query, result in zip(queries, results):
        print(f"Query: {query}")
        for entry in result:
            print(f"(Score: {entry['score']:.4f}) {corpus[entry['corpus_id']]}, corpus_id: {entry['corpus_id']}")
        print("")

    # 8. Prompt for more queries
    queries = [input("Please enter a question: ")]

延伸資源

訓練範例

以下頁麪包含附有説明的訓練範例及程式碼連結。建議瀏覽這些內容,熟悉訓練循環:

  • 模型蒸餾:縮小模型、提升速度及減輕模型負擔的範例。
  • MS MARCO:使用 MS MARCO 資訊檢索資料集訓練的範例腳本。
  • 檢索器:使用一般資訊檢索資料集訓練的範例腳本。
  • 自然語言推論:自然語言推論(NLI)資料有助預訓練和微調模型,產生具意義的稀疏嵌入。
  • Quora 重複問題:包含 Quora 社羣重複問題的大型語料庫。資料夾內有訓練模型以挖掘重複問題和進行語義搜尋的範例。
  • STS:最基本的模型訓練方法是使用語義文本相似度(STS)資料,即句子配對及表示語義相似程度的分數。

文件

此外,以下頁面有助深入瞭解 Sentence Transformers:

最後,以下進階頁面或許也會令你感興趣:

配套網誌

如要訓練其他類型的 Sentence Transformers 模型,或瞭解可補足稀疏檢索的技術:

來源:Hugging Face Blog · huggingface.co