Rerank（重排序）模型作为RAG（检索增强生成）系统的核心精排组件，直接决定了检索结果的精准度，是提升RAG系统性能的关键抓手。本文专为CSDN平台的小白开发者和程序员打造，全程基于LlamaIndex框架，详细拆解Cross-Encoder类型Rerank模型的微调流程，附完整代码、数据准备技巧与部署方案，帮你快速掌握这一高性价比的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 ORTModelForSequenceClassificationmodel = ORTModelForSequenceClassification.from_pretrained("./rerank_model_finetuned",    export=True,)

API服务：

# 使用FastAPI部署from fastapi import FastAPIfrom pydantic import BaseModelapp = 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样本即可）

✅ 关键步骤：

1. 1. 数据准备：收集高质量的查询-文档对，标注相关性
2. 2. 模型选择：根据场景选择合适的基础模型
3. 3. 微调训练：使用LlamaIndex的CrossEncoderFinetuneEngine
4. 4. 评估验证：使用Hit Rate、MRR等指标评估性能
5. 5. 部署优化：使用FP16、批量处理等优化推理速度

✅ 最佳实践：

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

✅ 适用场景：

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

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

如何学习大模型 AI ？

由于新岗位的生产效率，要优于被取代岗位的生产效率，所以实际上整个社会的生产效率是提升的。

但是具体到个人，只能说是：

“最先掌握AI的人，将会比较晚掌握AI的人有竞争优势”。

这句话，放在计算机、互联网、移动互联网的开局时期，都是一样的道理。

我在一线互联网企业工作十余年里，指导过不少同行后辈。帮助很多人得到了学习和成长。

我意识到有很多经验和知识值得分享给大家，也可以通过我们的能力和经验解答大家在人工智能学习中的很多困惑，所以在工作繁忙的情况下还是坚持各种整理和分享。但苦于知识传播途径有限，很多互联网行业朋友无法获得正确的资料得到学习提升，故此将并将重要的AI大模型资料包括AI大模型入门学习思维导图、精品AI大模型学习书籍手册、视频教程、实战学习等录播视频免费分享出来。

这份完整版的大模型 AI 学习资料已经上传CSDN，朋友们如果需要可以微信扫描下方CSDN官方认证二维码免费领取【保证100%免费】

为什么要学习大模型？

我国在A大模型领域面临人才短缺,数量与质量均落后于发达国家。2023年，人才缺口已超百万，凸显培养不足。随着AI技术飞速发展，预计到2025年,这一缺口将急剧扩大至400万,严重制约我国AI产业的创新步伐。加强人才培养,优化教育体系,国际合作并进是破解困局、推动AI发展的关键。

大模型入门到实战全套学习大礼包

1、大模型系统化学习路线

作为学习AI大模型技术的新手，方向至关重要。 正确的学习路线可以为你节省时间，少走弯路；方向不对，努力白费。这里我给大家准备了一份最科学最系统的学习成长路线图和学习规划，带你从零基础入门到精通！

---

2、大模型学习书籍&文档

学习AI大模型离不开书籍文档，我精选了一系列大模型技术的书籍和学习文档（电子版），它们由领域内的顶尖专家撰写，内容全面、深入、详尽，为你学习大模型提供坚实的理论基础。

3、AI大模型最新行业报告

2025最新行业报告，针对不同行业的现状、趋势、问题、机会等进行系统地调研和评估，以了解哪些行业更适合引入大模型的技术和应用，以及在哪些方面可以发挥大模型的优势。

4、大模型项目实战&配套源码

学以致用，在项目实战中检验和巩固你所学到的知识，同时为你找工作就业和职业发展打下坚实的基础。

5、大模型大厂面试真题

面试不仅是技术的较量，更需要充分的准备。在你已经掌握了大模型技术之后，就需要开始准备面试，我精心整理了一份大模型面试题库，涵盖当前面试中可能遇到的各种技术问题，让你在面试中游刃有余。

适用人群

第一阶段（10天）：初阶应用

该阶段让大家对大模型 AI有一个最前沿的认识，对大模型 AI 的理解超过 95% 的人，可以在相关讨论时发表高级、不跟风、又接地气的见解，别人只会和 AI 聊天，而你能调教 AI，并能用代码将大模型和业务衔接。

• 大模型 AI 能干什么？
• 大模型是怎样获得「智能」的？
• 用好 AI 的核心心法
• 大模型应用业务架构
• 大模型应用技术架构
• 代码示例：向 GPT-3.5 灌入新知识
• 提示工程的意义和核心思想
• Prompt 典型构成
• 指令调优方法论
• 思维链和思维树
• Prompt 攻击和防范
• …

第二阶段（30天）：高阶应用

该阶段我们正式进入大模型 AI 进阶实战学习，学会构造私有知识库，扩展 AI 的能力。快速开发一个完整的基于 agent 对话机器人。掌握功能最强的大模型开发框架，抓住最新的技术进展，适合 Python 和 JavaScript 程序员。

• 为什么要做 RAG
• 搭建一个简单的 ChatPDF
• 检索的基础概念
• 什么是向量表示（Embeddings）
• 向量数据库与向量检索
• 基于向量检索的 RAG
• 搭建 RAG 系统的扩展知识
• 混合检索与 RAG-Fusion 简介
• 向量模型本地部署
• …

第三阶段（30天）：模型训练

恭喜你，如果学到这里，你基本可以找到一份大模型 AI相关的工作，自己也能训练 GPT 了！通过微调，训练自己的垂直大模型，能独立训练开源多模态大模型，掌握更多技术方案。

到此为止，大概2个月的时间。你已经成为了一名“AI小子”。那么你还想往下探索吗？

• 为什么要做 RAG
• 什么是模型
• 什么是模型训练
• 求解器 & 损失函数简介
• 小实验2：手写一个简单的神经网络并训练它
• 什么是训练/预训练/微调/轻量化微调
• Transformer结构简介
• 轻量化微调
• 实验数据集的构建
• …

第四阶段（20天）：商业闭环

对全球大模型从性能、吞吐量、成本等方面有一定的认知，可以在云端和本地等多种环境下部署大模型，找到适合自己的项目/创业方向，做一名被 AI 武装的产品经理。

• 硬件选型
• 带你了解全球大模型
• 使用国产大模型服务
• 搭建 OpenAI 代理
• 热身：基于阿里云 PAI 部署 Stable Diffusion
• 在本地计算机运行大模型
• 大模型的私有化部署
• 基于 vLLM 部署大模型
• 案例：如何优雅地在阿里云私有部署开源大模型
• 部署一套开源 LLM 项目
• 内容安全
• 互联网信息服务算法备案
• …

学习是一个过程，只要学习就会有挑战。天道酬勤，你越努力，就会成为越优秀的自己。

如果你能在15天内完成所有的任务，那你堪称天才。然而，如果你能完成 60-70% 的内容，你就已经开始具备成为一名大模型 AI 的正确特征了。

这份完整版的大模型 AI 学习资料已经上传CSDN，朋友们如果需要可以微信扫描下方CSDN官方认证二维码免费领取【保证100%免费】