微调Rerank模型完整指南

Rerank（重排序）模型是RAG系统中的关键组件，能够显著提升检索精度。本文将详细介绍如何使用LlamaIndex微调Cross-Encoder类型的Rerank模型，让你的RAG系统更精准、更智能。

🎯 核心价值 ：通过微调Rerank模型，可以在不改变Embedding模型的情况下，将检索准确率提升10-30%，是优化RAG系统性价比最高的方法之一。

一、Rerank模型基础概念

1. 什么是Rerank模型？

Rerank（重排序）模型是RAG系统中的"精排"组件，用于对初步检索到的文档进行二次排序，选出最相关的文档。

工作流程：

  
用户查询 → Embedding模型检索Top-K文档（如Top-100） → Rerank模型精排 → 返回Top-N最相关文档（如Top-3）  

2. Cross-Encoder vs Bi-Encoder

| 特性 | Bi-Encoder（Embedding模型） | Cross-Encoder（Rerank模型） | | --- | --- | --- | | 输入方式 | 分别编码查询和文档 | 同时编码查询+文档对 | | 计算方式 | 独立编码后计算相似度 | 联合编码，全注意力机制 | | 精度 | 较低 | 更高

（10-30%提升） | | 速度 | 快（可预计算文档向量） | 较慢（需实时计算） | | 适用场景 | 大规模检索（百万级文档） | 精排（Top-K文档） | | 典型模型 | BGE、M3E、Qwen3-Embedding | BGE-Reranker、Cross-Encoder |

为什么Cross-Encoder更精准？

• • Cross-Encoder可以对查询和文档进行 联合编码 ，使用全注意力机制捕获细粒度的语义交互
• • Bi-Encoder只能计算预编码向量的相似度，无法捕获查询-文档之间的深层语义关系

3. 为什么需要微调Rerank模型？

通用模型的局限性：

• • 通用Rerank模型（如 bge-reranker-base ）在通用领域表现良好
• • 但在 垂直领域 （法律、医疗、金融等）可能表现不佳
• • 无法理解领域特定的术语、表达方式和语义关系

微调的优势：

• • ✅ 领域适配 ：针对特定领域优化，理解领域术语
• • ✅ 任务适配 ：针对特定任务（如QA、文档检索）优化
• • ✅ 数据适配 ：学习你的数据分布和标注偏好
• • ✅ 性能提升 ：通常能带来10-30%的准确率提升

二、数据准备

1. 数据格式要求

Rerank模型微调需要三元组数据 格式：

  
{  
"query":"问题文本",  
"passage":"文档/上下文文本",  
"score":1// 1表示相关，0表示不相关  
}  

数据示例：

  
[  {  "query":"什么是证券法？",  "passage":"证券法是为了规范证券发行和交易行为，保护投资者的合法权益，维护社会经济秩序和社会公共利益，促进社会主义市场经济的发展而制定的法律。",  "score":1  },  {  "query":"什么是证券法？",  "passage":"民法典是调整平等主体的自然人、法人和非法人组织之间的人身关系和财产关系的法律规范的总称。",  "score":0  }  ]  

2. 数据收集策略

方法1：人工标注

• • 从实际业务场景中收集查询-文档对
• • 人工标注相关性（0或1）
• • 优点：质量高，准确
• • 缺点：成本高，耗时长

方法2：从现有数据集提取

• • 使用QASPER、MS MARCO等公开数据集
• • 从问答对中提取查询和上下文
• • 优点：成本低，速度快
• • 缺点：可能不完全匹配你的领域

方法3：负样本挖掘（Hard Negatives）

• • 使用Embedding模型检索Top-K文档
• • 选择相关性较低的文档作为负样本（score=0）
• • 选择相关性较高的文档作为正样本（score=1）
• • 优点：数据质量好，训练效果好

3. 数据集规模建议

| 场景 | 训练样本数 | 验证样本数 | 正负样本比例 | | --- | --- | --- | --- | | 快速验证 | 100-500 | 50-100 | 1:1 或 1:2 | | 小规模应用 | 500-2000 | 100-200 | 1:1 或 1:2 | | 生产环境 | 2000-10000 | 200-500 | 1:1 或 1:3 | | 大规模应用 | 10000+ | 1000+ | 1:1 或 1:4 |

正负样本比例建议：

• • 保持 1:1到1:4 之间的比例
• • 负样本过多可能导致模型过于保守
• • 正样本过多可能导致模型过于激进

三、使用LlamaIndex微调Cross-Encoder

1. 环境准备

  
# 安装LlamaIndex相关包  
pip install llama-index-finetuning-cross-encoders  
pip install llama-index-llms-openai  
pip install llama-index  
  
# 安装其他依赖  
pip install datasets  
pip install sentence-transformers  
pip install torch  

2. 数据加载与处理

  
from llama\_index.finetuning.cross\_encoders import (  
    CrossEncoderFinetuneEngine,  
    CrossEncoderDataModule,  
)  
from datasets import load\_dataset  
import pandas as pd  
  
# 方法1：从JSON文件加载  
defload\_data\_from\_json(json\_path):  
"""从JSON文件加载训练数据"""  
import json  
  
withopen(json\_path, 'r', encoding='utf-8') as f:  
        data = json.load(f)  
  
# 转换为LlamaIndex格式  
    train\_data = []  
for item in data:  
        train\_data.append({  
"query": item["query"],  
"passage": item["passage"],  
"score": item["score"]  
        })  
  
return train\_data  
  
# 方法2：从HuggingFace数据集加载（以QASPER为例）  
defload\_data\_from\_hf():  
"""从HuggingFace加载QASPER数据集"""  
    dataset = load\_dataset("allenai/qasper")  
  
    train\_data = []  
# 从训练集中提取800个样本  
for sample in dataset["train"].select(range(800)):  
        paper\_text = sample["full\_text"]["paragraphs"]  
        questions = sample["qas"]["question"]  
        answers = sample["qas"]["answers"]  
  
# 构建查询-文档对  
for q\_idx, question inenumerate(questions):  
# 正样本：问题和相关上下文  
if answers[q\_idx] andlen(answers[q\_idx]) > 0:  
                relevant\_context = extract\_relevant\_context(  
                    paper\_text, answers[q\_idx]  
                )  
                train\_data.append({  
"query": question,  
"passage": relevant\_context,  
"score": 1  
                })  
  
# 负样本：问题和无关上下文  
                irrelevant\_context = extract\_irrelevant\_context(  
                    paper\_text, answers[q\_idx]  
                )  
                train\_data.append({  
"query": question,  
"passage": irrelevant\_context,  
"score": 0  
                })  
  
return train\_data  
  
# 加载数据  
train\_data = load\_data\_from\_json("train\_rerank.json")  
val\_data = load\_data\_from\_json("val\_rerank.json")  

3. 创建微调引擎

  
from llama\_index.finetuning.cross\_encoders import CrossEncoderFinetuneEngine  
  
# 初始化微调引擎  
finetune\_engine = CrossEncoderFinetuneEngine(  
    train\_dataset=train\_data,  # 训练数据  
    val\_dataset=val\_data,      # 验证数据（可选）  
    model\_id="cross-encoder/ms-marco-MiniLM-L-12-v2",  # 基础模型  
    model\_output\_path="./rerank\_model\_finetuned",      # 输出路径  
    batch\_size=16,              # 批次大小  
    epochs=3,                   # 训练轮数  
    learning\_rate=2e-5,         # 学习率  
    warmup\_steps=100,           # 预热步数  
)  
  
# 开始微调  
finetune\_engine.finetune()  
  
# 获取微调后的模型  
finetuned\_model = finetune\_engine.get\_finetuned\_model()  

4. 完整微调示例

  
import os  
from llama\_index.finetuning.cross\_encoders import CrossEncoderFinetuneEngine  
from llama\_index.postprocessor import CohereRerank, SentenceTransformerRerank  
import json  
  
deffinetune\_rerank\_model():  
"""微调Rerank模型的完整流程"""  
  
# 1. 加载数据  
    BASE\_DIR = "./data"  
    TRAIN\_DATA\_PATH = os.path.join(BASE\_DIR, "train\_rerank.json")  
    VAL\_DATA\_PATH = os.path.join(BASE\_DIR, "val\_rerank.json")  
  
withopen(TRAIN\_DATA\_PATH, 'r', encoding='utf-8') as f:  
        train\_data = json.load(f)  
  
withopen(VAL\_DATA\_PATH, 'r', encoding='utf-8') as f:  
        val\_data = json.load(f)  
  
# 2. 配置微调参数  
    finetune\_engine = CrossEncoderFinetuneEngine(  
        train\_dataset=train\_data,  
        val\_dataset=val\_data,  
        model\_id="cross-encoder/ms-marco-MiniLM-L-12-v2",  # 或使用 "BAAI/bge-reranker-base"  
        model\_output\_path="./rerank\_model\_finetuned",  
        batch\_size=16,  
        epochs=3,  
        learning\_rate=2e-5,  
        warmup\_steps=100,  
        show\_progress=True,  
    )  
  
# 3. 执行微调  
print("开始微调Rerank模型...")  
    finetune\_engine.finetune()  
print("微调完成！")  
  
# 4. 保存模型（可选：推送到HuggingFace Hub）  
# finetune\_engine.push\_to\_hub(  
#     repo\_id="your-username/your-rerank-model",  
#     token="your-hf-token"  
# )  
  
return finetune\_engine  
  
if \_\_name\_\_ == "\_\_main\_\_":  
    finetune\_engine = finetune\_rerank\_model()  

四、使用微调后的Rerank模型

1. 在LlamaIndex中使用

  
from llama\_index.postprocessor import SentenceTransformerRerank  
from llama\_index.core import VectorStoreIndex, Document  
from llama\_index.embeddings.openai import OpenAIEmbedding  
  
# 1. 加载微调后的Rerank模型  
reranker = SentenceTransformerRerank(  
    model="./rerank\_model\_finetuned",  # 或使用HuggingFace路径  
    top\_n=3,  # 返回Top-3文档  
)  
  
# 2. 创建向量索引  
embed\_model = OpenAIEmbedding(model="text-embedding-3-small")  
documents = [Document(text="文档内容1"), Document(text="文档内容2")]  
vector\_index = VectorStoreIndex.from\_documents(  
    documents,   
    embed\_model=embed\_model  
)  
  
# 3. 创建查询引擎（带Rerank）  
query\_engine = vector\_index.as\_query\_engine(  
    similarity\_top\_k=10,  # 先用Embedding检索Top-10  
    node\_postprocessors=[reranker],  # 再用Rerank精排到Top-3  
)  
  
# 4. 查询  
response = query\_engine.query("你的问题")  
print(response)  

2. 直接使用微调后的模型

  
from sentence\_transformers import CrossEncoder  
  
# 加载微调后的模型  
model = CrossEncoder("./rerank\_model\_finetuned")  
  
# 计算查询-文档相关性分数  
query = "什么是证券法？"  
passages = [  
"证券法是为了规范证券发行和交易行为...",  
"民法典是调整平等主体的自然人...",  
"公司法是为了规范公司的组织和行为...",  
]  
  
# 计算分数  
scores = model.predict([  
    [query, passage] for passage in passages  
])  
  
# 排序  
ranked\_indices = sorted(  
range(len(scores)),   
    key=lambda i: scores[i],   
    reverse=True  
)  
  
print("排序结果：")  
for idx in ranked\_indices:  
print(f"分数: {scores[idx]:.4f}, 文档: {passages[idx][:50]}...")  

五、评估方法

1. Reranking评估指标

Hit Rate（命中率）：

• • 衡量Top-K结果中是否包含正确答案
• • 公式： Hit@K = (包含正确答案的查询数) / (总查询数)

MRR（Mean Reciprocal Rank）：

• • 衡量正确答案的平均排名倒数
• • 公式： MRR = (1/rank\_1 + 1/rank\_2 + ...) / N

NDCG（Normalized Discounted Cumulative Gain）：

• • 考虑排序位置的评估指标
• • 更关注Top结果的准确性

2. 评估脚本示例

  
from llama\_index.core.evaluation import (  
    RetrieverEvaluator,  
    generate\_question\_context\_pairs,  
)  
from llama\_index.postprocessor import SentenceTransformerRerank  
from llama\_index.core import VectorStoreIndex  
  
defevaluate\_reranker(  
    index: VectorStoreIndex,  
    reranker: SentenceTransformerRerank,  
    eval\_dataset,  
):  
"""评估Rerank模型性能"""  
  
# 创建带Rerank的查询引擎  
    query\_engine = index.as\_query\_engine(  
        similarity\_top\_k=10,  
        node\_postprocessors=[reranker],  
    )  
  
# 评估指标  
    hit\_rate\_1 = 0  
    hit\_rate\_3 = 0  
    hit\_rate\_5 = 0  
    mrr = 0  
  
for item in eval\_dataset:  
        query = item["query"]  
        ground\_truth = item["ground\_truth\_passages"]  # 正确答案列表  
  
# 获取检索结果  
        response = query\_engine.retrieve(query)  
        retrieved\_passages = [node.text for node in response]  
  
# 计算Hit@K  
        hit\_1 = any(gt in retrieved\_passages[:1] for gt in ground\_truth)  
        hit\_3 = any(gt in retrieved\_passages[:3] for gt in ground\_truth)  
        hit\_5 = any(gt in retrieved\_passages[:5] for gt in ground\_truth)  
  
        hit\_rate\_1 += hit\_1  
        hit\_rate\_3 += hit\_3  
        hit\_rate\_5 += hit\_5  
  
# 计算MRR  
for rank, passage inenumerate(retrieved\_passages, 1):  
if passage in ground\_truth:  
                mrr += 1.0 / rank  
break  
  
    n = len(eval\_dataset)  
return {  
"Hit@1": hit\_rate\_1 / n,  
"Hit@3": hit\_rate\_3 / n,  
"Hit@5": hit\_rate\_5 / n,  
"MRR": mrr / n,  
    }  
  
# 使用示例  
results = evaluate\_reranker(  
    index=vector\_index,  
    reranker=reranker,  
    eval\_dataset=val\_dataset,  
)  
print(f"评估结果: {results}")  

3. 对比评估：微调前后

  
from llama\_index.postprocessor import SentenceTransformerRerank  
  
# 原始模型  
original\_reranker = SentenceTransformerRerank(  
    model="cross-encoder/ms-marco-MiniLM-L-12-v2",  
    top\_n=3,  
)  
  
# 微调后的模型  
finetuned\_reranker = SentenceTransformerRerank(  
    model="./rerank\_model\_finetuned",  
    top\_n=3,  
)  
  
# 评估原始模型  
original\_results = evaluate\_reranker(  
    index=vector\_index,  
    reranker=original\_reranker,  
    eval\_dataset=val\_dataset,  
)  
  
# 评估微调后的模型  
finetuned\_results = evaluate\_reranker(  
    index=vector\_index,  
    reranker=finetuned\_reranker,  
    eval\_dataset=val\_dataset,  
)  
  
# 对比结果  
print("=" * 50)  
print("原始模型性能:")  
print(original\_results)  
print("=" * 50)  
print("微调后模型性能:")  
print(finetuned\_results)  
print("=" * 50)  
print("性能提升:")  
for key in original\_results:  
    improvement = finetuned\_results[key] - original\_results[key]  
print(f"{key}: {improvement:+.4f} ({improvement/original\_results[key]*100:+.2f}%)")  

六、实战案例：基于QASPER数据集的微调

完整流程示例

  
from datasets import load\_dataset  
from llama\_index.finetuning.cross\_encoders import CrossEncoderFinetuneEngine  
import json  
  
defprepare\_qasper\_dataset():  
"""从QASPER数据集准备训练数据"""  
  
# 1. 加载数据集  
    dataset = load\_dataset("allenai/qasper")  
  
# 2. 从训练集提取800个样本  
    train\_samples = []  
for sample in dataset["train"].select(range(800)):  
        paper\_text = " ".join(sample["full\_text"]["paragraphs"])  
        questions = sample["qas"]["question"]  
        answers = sample["qas"]["answers"]  
  
for q\_idx, question inenumerate(questions):  
if answers[q\_idx] andlen(answers[q\_idx]) > 0:  
# 提取相关上下文作为正样本  
                answer\_text = answers[q\_idx][0]["answer"]["unanswerable"]  
ifnot answer\_text:  # 只保留有答案的问题  
# 构建正样本  
                    relevant\_context = extract\_context\_from\_paper(  
                        paper\_text, answers[q\_idx]  
                    )  
                    train\_samples.append({  
"query": question,  
"passage": relevant\_context,  
"score": 1  
                    })  
  
# 构建负样本（随机选择不相关的段落）  
                    irrelevant\_context = extract\_random\_context(  
                        paper\_text, answers[q\_idx]  
                    )  
                    train\_samples.append({  
"query": question,  
"passage": irrelevant\_context,  
"score": 0  
                    })  
  
# 3. 从测试集提取80个样本作为验证集  
    val\_samples = []  
for sample in dataset["test"].select(range(80)):  
# 类似处理...  
pass  
  
return train\_samples, val\_samples  
  
defextract\_context\_from\_paper(paper\_text, answers):  
"""从论文中提取相关上下文"""  
# 简化实现：根据答案位置提取上下文  
# 实际应用中需要更复杂的逻辑  
return paper\_text[:500]  # 示例  
  
defextract\_random\_context(paper\_text, answers):  
"""提取随机不相关的上下文"""  
# 简化实现  
return paper\_text[1000:1500]  # 示例  
  
# 主流程  
if \_\_name\_\_ == "\_\_main\_\_":  
# 1. 准备数据  
print("准备训练数据...")  
    train\_data, val\_data = prepare\_qasper\_dataset()  
  
# 保存数据  
withopen("train\_rerank.json", "w", encoding="utf-8") as f:  
        json.dump(train\_data, f, ensure\_ascii=False, indent=2)  
  
withopen("val\_rerank.json", "w", encoding="utf-8") as f:  
        json.dump(val\_data, f, ensure\_ascii=False, indent=2)  
  
# 2. 微调模型  
print("开始微调...")  
    finetune\_engine = CrossEncoderFinetuneEngine(  
        train\_dataset=train\_data,  
        val\_dataset=val\_data,  
        model\_id="cross-encoder/ms-marco-MiniLM-L-12-v2",  
        model\_output\_path="./qasper\_rerank\_model",  
        batch\_size=16,  
        epochs=3,  
        learning\_rate=2e-5,  
    )  
  
    finetune\_engine.finetune()  
print("微调完成！模型保存在: ./qasper\_rerank\_model")  

七、最佳实践与优化建议

1. 数据质量优化

✅ 正样本质量：

• • 确保正样本的文档确实与查询相关
• • 避免标注错误，这会严重影响模型性能
• • 正样本应该覆盖各种查询类型和文档类型

✅ 负样本策略：

• • 使用 Hard Negatives （难以区分的负样本）
• • 避免使用完全无关的负样本（太容易区分）
• • 负样本应该与正样本在语义上相似但实际不相关

✅ 数据平衡：

• • 保持正负样本比例在1:1到1:4之间
• • 确保不同查询类型的数据分布均匀

2. 模型选择建议

| 基础模型 | 参数量 | 速度 | 精度 | 适用场景 | | --- | --- | --- | --- | --- | | cross-encoder/ms-marco-MiniLM-L-6-v2 | 22M | 快 | 中 | 快速原型、资源受限 | | cross-encoder/ms-marco-MiniLM-L-12-v2 | 117M | 中 | 高 | 推荐：平衡性能 | | BAAI/bge-reranker-base | 278M | 中 | 高 | 中文场景、生产环境 | | BAAI/bge-reranker-large | 560M | 慢 | 很高 | 高精度需求 |

推荐策略：

• • 开发测试 ：使用 ms-marco-MiniLM-L-6-v2 快速验证
• • 生产环境 ：使用 ms-marco-MiniLM-L-12-v2 或 bge-reranker-base
• • 中文场景 ：优先使用 bge-reranker-base

3. 训练参数调优

  
# 推荐配置  
training\_config = {  
"batch\_size": 16,        # 根据GPU显存调整：8GB显存用8，16GB用16  
"epochs": 3,             # 通常3-5轮足够，避免过拟合  
"learning\_rate": 2e-5,    # 推荐范围：1e-5到5e-5  
"warmup\_steps": 100,      # 预热步数：总步数的10%  
"max\_length": 512,        # 最大序列长度：根据数据调整  
"weight\_decay": 0.01,     # 权重衰减：防止过拟合  
}  

调优建议：

• • 学习率 ：从2e-5开始，如果loss不下降，尝试1e-5
• • 批次大小 ：在显存允许的情况下，越大越好
• • 训练轮数 ：监控验证集性能，早停防止过拟合

4. 性能优化

推理加速：

  
# 使用FP16加速（性能损失<1%）  
reranker = SentenceTransformerRerank(  
    model="./rerank\_model\_finetuned",  
    top\_n=3,  
    use\_fp16=True,  # 启用FP16  
)  
  
# 批量处理  
scores = model.predict(  
    [[query, passage] for passage in passages],  
    batch\_size=32,  # 批量处理提高效率  
    show\_progress\_bar=True,  
)  

缓存优化：

• • 对于相同的查询，可以缓存Rerank结果
• • 使用Redis等缓存系统存储Top-K结果

5. 部署建议

本地部署：

  
# 使用ONNX加速（可选）  
from optimum.onnxruntime import ORTModelForSequenceClassification  
  
model = ORTModelForSequenceClassification.from\_pretrained(  
"./rerank\_model\_finetuned",  
    export=True,  
)  

API服务：

  
# 使用FastAPI部署  
from fastapi import FastAPI  
from pydantic import BaseModel  
  
app = FastAPI()  
reranker = SentenceTransformerRerank(model="./rerank\_model\_finetuned")  
  
classRerankRequest(BaseModel):  
    query: str  
    passages: list[str]  
    top\_n: int = 3  
  
@app.post("/rerank")  
defrerank(request: RerankRequest):  
    scores = reranker.postprocess\_nodes(  
        query=request.query,  
        nodes=request.passages,  
        top\_n=request.top\_n,  
    )  
return {"results": scores}  

八、常见问题与解决方案

Q1: 微调后性能没有提升？

可能原因：

• • 数据质量差（标注错误、正负样本不平衡）
• • 训练数据量太少（<500样本）
• • 学习率设置不当
• • 过拟合（训练轮数过多）

解决方案：

• • 检查数据质量，重新标注
• • 增加训练数据量
• • 调整学习率（尝试1e-5到5e-5）
• • 使用早停机制，监控验证集性能

Q2: 训练速度太慢？

优化方案：

• • 使用更小的模型（如 ms-marco-MiniLM-L-6-v2 ）
• • 减少 max\_length （如从512降到256）
• • 使用更大的 batch\_size （在显存允许的情况下）
• • 使用FP16训练： model.half()

Q3: 显存不足（OOM）？

解决方案：

• • 减小 batch\_size （如从16降到8或4）
• • 减小 max\_length （如从512降到256）
• • 使用梯度累积： gradient\_accumulation\_steps=2
• • 使用更小的模型

Q4: 如何选择Top-K值？

建议：

• • Embedding检索Top-K ：通常选择50-100（取决于文档库大小）
• • Rerank后Top-N ：通常选择3-10（最终返回给用户的数量）
• • 平衡点 ：Top-K太大→Rerank计算慢，Top-K太小→可能漏掉正确答案

Q5: 中文场景如何选择模型？

推荐：

• • 基础模型： BAAI/bge-reranker-base （中文优化）
• • 如果数据量足够，可以在此基础上微调
• • 确保训练数据包含足够的中文样本

九、总结

微调Rerank模型是提升RAG系统检索精度的高性价比 方法：

✅ 核心优势：

• • 无需改变Embedding模型，只需微调Rerank模型
• • 通常能带来10-30%的准确率提升
• • 训练成本低，数据需求相对较少（1000-5000样本即可）

✅ 关键步骤：

数据准备 ：收集高质量的查询-文档对，标注相关性

模型选择 ：根据场景选择合适的基础模型

微调训练 ：使用LlamaIndex的 CrossEncoderFinetuneEngine

评估验证 ：使用Hit Rate、MRR等指标评估性能

部署优化 ：使用FP16、批量处理等优化推理速度

✅ 最佳实践：

• • 使用Hard Negatives提高训练效果
• • 保持正负样本比例在1:1到1:4之间
• • 监控验证集性能，防止过拟合
• • 在生产环境中使用FP16加速推理

✅ 适用场景：

• • 垂直领域RAG系统（法律、医疗、金融等）
• • 需要高精度检索的场景
• • 有领域特定数据可以用于微调

记住：微调Rerank模型是RAG系统优化的"最后一步"，应该在优化Embedding模型之后进行 。通过合理的微调，可以让你的RAG系统在特定领域达到更高的检索精度！

---

相关资源：

• • [LlamaIndex Cross-Encoder微调文档]
• https://github.com/run-llama/llama\_index/blob/main/docs/examples/finetuning/cross\_encoder\_finetuning/cross\_encoder\_finetuning.ipynb
• • [BGE-Reranker模型]
• https://huggingface.co/BAAI/bge-reranker-base
• • [Sentence Transformers文档]
• https://www.sbert.net/docs/pretrained\_cross-encoders.html
• • [QASPER数据集]
• https://huggingface.co/datasets/allenai/qasper

从零开始：手把手教你微调Embedding模型，让检索效果提升10倍！

如何微调任何Embedding模型？适配器微调让通用模型秒变领域专家