在实际的大模型应用开发中，RAG（检索增强生成）技术因其能有效结合外部知识、缓解大模型幻觉而备受青睐。然而，许多开发者在实践中发现，RAG系统并非一劳永逸，它依然可能“胡说八道”——给出与检索内容不符、甚至凭空捏造的答案。这背后的问题往往不是单一环节的失误，而是从数据准备、检索到生成的全链路都存在优化空间。本文将聚焦于如何通过“微调”这一关键手段，系统性地提升RAG的准确性与可靠性，并提供一个从零到一的实战指南，帮助开发者构建更可信的智能问答系统。

本文适合有一定大模型和RAG基础，希望深入优化系统效果的中高级开发者。我们将从RAG的典型问题切入，分析微调的必要性，然后分步讲解如何对Embedding模型、重排序模型乃至大语言模型本身进行针对性微调，最后整合成一个完整的、可验证的增强型RAG系统。你将了解到每个环节微调的具体目标、数据准备方法、训练技巧以及效果评估方式。

1. 理解RAG“胡说八道”的根源与微调的价值

RAG系统通常由三个核心组件构成：检索器（Retriever）、重排序器（Reranker，可选）和生成器（Generator）。信息流从用户问题开始，经过Embedding模型转化为向量，在向量数据库中检索出相关文档片段，可能经过重排序模型筛选出最相关的几条，最后连同问题和文档一起送入大语言模型生成最终答案。任何一个环节的短板都可能导致最终输出偏离事实。

1.1 RAG失效的常见场景分析

“胡说八道”并非大模型的专利，在RAG系统中，它可能源于以下几种典型情况：

1. 检索无关 ：用户问题“如何配置Spring Security的OAuth2客户端？”，但系统检索出的却是关于OAuth2协议原理的通用介绍，缺少具体的配置步骤和代码示例。这是因为Embedding模型未能充分理解领域术语的语义关联。
2. 检索遗漏 ：答案的关键信息分散在多个文档片段中，但检索系统只返回了其中一个，导致生成答案不完整。这可能是由于检索策略（如Top-K设置）或文档切分粒度不合理。
3. 生成无视检索内容 ：尽管检索到了高度相关的文档，但大模型在生成时过度依赖自身预训练知识，忽略了提供的上下文，甚至产生与上下文矛盾的表述。这通常是因为提示词（Prompt）设计不佳或模型本身在“忠实于上下文”方面能力不足。
4. 上下文过长或噪声大 ：检索返回的片段包含大量无关信息（如广告、导航栏、重复内容），挤占了有效上下文的篇幅，干扰了模型的判断。

1.2 为什么微调是治本之策？

面对上述问题，常见的工程优化包括调整提示词、优化文档分块（Chunking）策略、引入重排序模型等。这些方法见效快，但存在天花板。微调则更进一步，它通过使用领域特定的数据对模型参数进行更新，让模型从根本上“学会”你的领域知识、术语体系和任务格式。

• 微调Embedding模型 ：目标是让相似的问题和答案在向量空间里靠得更近。例如，让“OAuth2客户端配置”和具体的 application.yml 配置代码片段具有更高的相似度得分，从而提升检索相关性。
• 微调重排序模型 ：在初步检索出大量候选文档后，重排序模型能进行更精细的语义相关度打分。微调可以使其更适应领域内的评判标准，比如更看重代码示例、参数表格还是原理描述。
• 微调大语言模型（生成器） ：这是最直接提升答案忠实度的方法。通过微调，可以强化模型遵循指令、严格依据给定上下文生成答案的能力，并学会你期望的答案格式和风格。

全链路微调意味着根据你的数据，定制化每一个关键组件，使其协同工作达到最佳状态。

2. 环境准备与核心工具选型

在开始微调实战前，需要搭建一个稳定且高效的基础环境。我们选择当前社区活跃、文档齐全的工具链。

2.1 基础环境与硬件要求

微调，尤其是大语言模型的微调，对计算资源有较高要求。以下是不同场景下的建议配置：

组件	学习/实验环境	生产微调环境	说明
CPU	8核以上	16核以上	影响数据预处理和训练速度。
内存	32 GB	64 GB 或更高	确保能加载模型和大型数据集。
GPU	单卡 RTX 3090/4090 (24GB)	多卡 A100/H100 (80GB)	核心资源 。Embedding模型微调对显存要求相对较低（~10GB），而7B参数的LLM全量微调可能需要40GB+显存。
存储	100 GB SSD	1 TB NVMe SSD	用于存放模型、数据集和检查点。
软件	Python 3.9+, CUDA 11.8, Docker	Python 3.9+, CUDA 12.x, Kubernetes	确保CUDA版本与PyTorch等深度学习框架匹配。

对于大多数开发者，从单卡RTX 3090/4090开始进行 LoRA微调 是性价比最高的选择。LoRA（Low-Rank Adaptation）是一种参数高效的微调方法，能大幅减少可训练参数量和显存消耗。

2.2 核心工具与框架安装

我们将使用以下工具链，请通过pip或conda进行安装。

# 创建并激活Python虚拟环境（推荐）
conda create -n rag_finetune python=3.10
conda activate rag_finetune

# 安装PyTorch（请根据你的CUDA版本访问PyTorch官网获取对应命令）
# 例如，对于CUDA 11.8：
pip install torch torchvision torchaudio --index-url https://download.pytorch.org/whl/cu118

# 安装深度学习训练框架和工具
pip install transformers datasets accelerate peft bitsandbytes scikit-learn

# 安装向量数据库与RAG框架（以Chroma和LangChain为例）
pip install chromadb langchain langchain-community

# 安装评估与可视化工具
pip install rouge-score bert-score matplotlib jupyter

关键解释 ：

• transformers ：Hugging Face核心库，用于加载和训练模型。
• datasets ：方便地加载和处理数据集。
• accelerate ：简化分布式训练。
• peft ：实现LoRA等参数高效微调方法。
• bitsandbytes ：支持QLoRA（量化LoRA），进一步降低显存需求。
• scikit-learn ：用于评估指标计算。

3. 实战一：微调Embedding模型提升检索精度

我们选择 BGE-M3 作为基础Embedding模型，因为它支持多语言、密集检索等多种模式，且性能优秀。微调的目标是让模型对我们特定领域（如“Java后端开发”）的文本对产生更准确的向量表示。

3.1 准备领域特定的训练数据

微调Embedding模型通常需要 文本对数据 ，格式为 (query, positive_document, negative_document) 。

• query ：用户可能提出的问题。
• positive_document ：能正确回答该问题的文档片段。
• negative_document ：与问题相关但不足以正确回答，或完全不相关的文档片段（用于对比学习）。

你可以从现有问答日志、技术文档中构造，或使用大模型合成。

// 示例：finetune_embedding_data.jsonl
{"query": "Spring Boot如何集成Redis缓存？", "pos": "在Spring Boot中集成Redis，首先需添加`spring-boot-starter-data-redis`依赖。然后在`application.yml`中配置Redis连接信息：`spring.redis.host=localhost`。最后，使用`@Cacheable`注解即可实现方法缓存。", "neg": "Redis是一个开源的内存数据结构存储，常用作数据库、缓存和消息代理。它支持字符串、哈希、列表等多种数据结构。"}
{"query": "MyBatis的#{}和${}有什么区别？", "pos": "MyBatis中，#{}是预编译处理，会将SQL中的#{}替换为?，能有效防止SQL注入。${}是字符串替换，直接将参数值填入SQL，有注入风险，一般用于动态传入表名或列名。", "neg": "MyBatis是一款优秀的持久层框架，它支持自定义SQL、存储过程以及高级映射。可以通过XML或注解来配置和映射原生信息。"}

3.2 使用对比学习进行微调

我们使用 MultipleNegativesRankingLoss 损失函数，它鼓励正样本对的相似度远高于负样本对。

from transformers import AutoTokenizer, AutoModel
from datasets import Dataset
import torch
from torch.utils.data import DataLoader
from transformers import Trainer, TrainingArguments
import torch.nn.functional as F

# 1. 加载模型和分词器
model_name = "BAAI/bge-m3"
tokenizer = AutoTokenizer.from_pretrained(model_name)
model = AutoModel.from_pretrained(model_name)

# 2. 数据预处理函数
def encode_batch(batch):
    """将query和documents编码为模型输入"""
    queries = batch['query']
    pos_docs = batch['pos']
    neg_docs = batch['neg']
    
    # 对query和doc分别编码。注意：BGE模型需要在输入文本前添加指令。
    query_encodings = tokenizer([f"为这个句子生成表示以用于检索相关文章：{q}" for q in queries], padding=True, truncation=True, return_tensors='pt', max_length=512)
    pos_encodings = tokenizer([f"为这个句子生成表示以用于检索相关文章：{d}" for d in pos_docs], padding=True, truncation=True, return_tensors='pt', max_length=512)
    neg_encodings = tokenizer([f"为这个句子生成表示以用于检索相关文章：{d}" for d in neg_docs], padding=True, truncation=True, return_tensors='pt', max_length=512)
    
    return {'query_input': query_encodings, 'pos_input': pos_encodings, 'neg_input': neg_encodings}

# 3. 加载数据集
dataset = Dataset.from_json("finetune_embedding_data.jsonl")
encoded_dataset = dataset.map(encode_batch, batched=True, remove_columns=dataset.column_names)

# 4. 自定义数据整理器
def collate_fn(features):
    query_input = {k: torch.stack([f['query_input'][k] for f in features]) for k in features[0]['query_input']}
    pos_input = {k: torch.stack([f['pos_input'][k] for f in features]) for k in features[0]['pos_input']}
    neg_input = {k: torch.stack([f['neg_input'][k] for f in features]) for k in features[0]['neg_input']}
    return {'query_input': query_input, 'pos_input': pos_input, 'neg_input': neg_input}

# 5. 定义训练逻辑（核心：对比损失计算）
class EmbeddingTrainer(Trainer):
    def compute_loss(self, model, inputs, return_outputs=False):
        query_inputs = inputs['query_input']
        pos_inputs = inputs['pos_input']
        neg_inputs = inputs['neg_input']
        
        # 获取向量表示（取[CLS] token的向量或做mean pooling）
        query_emb = model(**query_inputs).last_hidden_state[:, 0, :] # [batch, dim]
        pos_emb = model(**pos_inputs).last_hidden_state[:, 0, :]
        neg_emb = model(**neg_inputs).last_hidden_state[:, 0, :]
        
        # 计算余弦相似度
        pos_sim = F.cosine_similarity(query_emb, pos_emb) # [batch]
        neg_sim = F.cosine_similarity(query_emb, neg_emb) # [batch]
        
        # 使用Multiple Negatives Ranking Loss
        # 目标：让pos_sim远大于neg_sim
        loss = -torch.log(torch.exp(pos_sim) / (torch.exp(pos_sim) + torch.exp(neg_sim))).mean()
        
        return (loss, {'query_emb': query_emb}) if return_outputs else loss

# 6. 配置训练参数
training_args = TrainingArguments(
    output_dir="./bge-m3-finetuned",
    per_device_train_batch_size=8, # 根据GPU显存调整
    num_train_epochs=3,
    learning_rate=2e-5,
    logging_dir='./logs',
    save_strategy="epoch",
    remove_unused_columns=False,
)

# 7. 创建Trainer并开始训练
trainer = EmbeddingTrainer(
    model=model,
    args=training_args,
    train_dataset=encoded_dataset,
    data_collator=collate_fn,
)
trainer.train()

# 8. 保存微调后的模型
model.save_pretrained("./my_finetuned_bge_m3")
tokenizer.save_pretrained("./my_finetuned_bge_m3")

关键点与常见坑 ：

• 指令模板 ：像BGE这类现代Embedding模型，需要在输入文本前添加特定的指令（如“为这个句子生成表示以用于检索相关文章：”），微调时必须保持一致，否则效果会下降。
• 池化策略 ：获取句子向量的方式（如取 [CLS] token、平均池化）需要与模型设计一致。 BGE-M3 通常取 [CLS] token的向量。
• 批量大小 ：对比学习需要足够的负样本，增大 per_device_train_batch_size 能在一个批次内提供更多负样本（其他样本的 pos 和 neg ），可能提升效果。但受显存限制。
• 数据质量 ： negative_document 的选择至关重要。太容易区分的负样本（如完全无关）对模型提升有限，应选择“困难负样本”（语义相关但非答案）。

训练完成后，你可以用微调后的模型替换RAG管道中的原始Embedding模型，并观察检索结果的相关性提升。

4. 实战二：使用LoRA微调大语言模型提升答案忠实度

接下来，我们微调生成器（大语言模型），使其更严格地依据检索到的上下文生成答案。我们选择Qwen1.5-7B作为基座模型，并使用LoRA进行高效微调。

4.1 准备指令微调数据

数据格式需要包含 instruction （指令/问题）、 input （检索到的上下文）和 output （期望的答案）。

// 示例：finetune_llm_data.jsonl
{
  "instruction": "根据给定的上下文，回答问题。",
  "input": "上下文：在Spring Boot中集成Redis，首先需添加`spring-boot-starter-data-redis`依赖。然后在`application.yml`中配置Redis连接信息：`spring.redis.host=localhost`。最后，使用`@Cacheable`注解即可实现方法缓存。\n问题：Spring Boot如何集成Redis缓存？",
  "output": "集成Redis缓存需要三步：1. 在pom.xml中添加`spring-boot-starter-data-redis`依赖。2. 在application.yml中配置Redis主机地址，例如`spring.redis.host=localhost`。3. 在需要缓存的方法上添加`@Cacheable`注解。"
}
{
  "instruction": "严格根据以下技术文档片段回答。",
  "input": "上下文：MyBatis中，#{}是预编译处理，会将SQL中的#{}替换为?，能有效防止SQL注入。${}是字符串替换，直接将参数值填入SQL，有注入风险，一般用于动态传入表名或列名。\n问题：MyBatis的#{}和${}有什么区别？",
  "output": "#{}采用预编译方式，能防止SQL注入，安全。${}是字符串直接替换，有SQL注入风险，通常用于动态指定表名或列名等非参数场景。"
}

4.2 使用PEFT（LoRA）进行微调

from transformers import AutoTokenizer, AutoModelForCausalLM, TrainingArguments, Trainer
from peft import LoraConfig, get_peft_model, TaskType
from datasets import Dataset
import torch

# 1. 加载模型和分词器
model_name = "Qwen/Qwen1.5-7B"
tokenizer = AutoTokenizer.from_pretrained(model_name, trust_remote_code=True)
# 设置padding token（如果模型没有）
if tokenizer.pad_token is None:
    tokenizer.pad_token = tokenizer.eos_token

model = AutoModelForCausalLM.from_pretrained(
    model_name,
    torch_dtype=torch.bfloat16, # 使用BF16节省显存
    device_map="auto", # 自动分配模型层到GPU/CPU
    trust_remote_code=True
)

# 2. 配置LoRA
lora_config = LoraConfig(
    task_type=TaskType.CAUSAL_LM, # 因果语言模型任务
    r=8, # LoRA秩（rank），影响参数量，通常8-32
    lora_alpha=32, # 缩放因子
    lora_dropout=0.1,
    target_modules=["q_proj", "k_proj", "v_proj", "o_proj"], # 针对Qwen的注意力模块
    bias="none"
)
model = get_peft_model(model, lora_config)
model.print_trainable_parameters() # 查看可训练参数占比，通常<1%

# 3. 数据预处理
def preprocess_function(examples):
    # 构造模型输入的文本格式
    texts = []
    for i in range(len(examples['instruction'])):
        # 使用ChatML格式（Qwen推荐）
        message = [
            {"role": "system", "content": "你是一个严谨的技术助手，必须严格根据提供的上下文回答问题。"},
            {"role": "user", "content": examples['input'][i]},
            {"role": "assistant", "content": examples['output'][i]}
        ]
        text = tokenizer.apply_chat_template(message, tokenize=False, add_generation_prompt=False)
        texts.append(text)
    # 对文本进行分词
    model_inputs = tokenizer(texts, max_length=1024, truncation=True, padding="max_length")
    # 将输入部分的标签设置为-100（计算损失时忽略）
    labels = model_inputs["input_ids"].copy()
    # 假设我们只对assistant的回复部分计算损失
    # 这里简化处理：在实际中，需要更精确地掩码掉非assistant部分
    model_inputs["labels"] = labels
    return model_inputs

dataset = Dataset.from_json("finetune_llm_data.jsonl")
tokenized_dataset = dataset.map(preprocess_function, batched=True, remove_columns=dataset.column_names)

# 4. 配置训练参数
training_args = TrainingArguments(
    output_dir="./qwen-7b-lora-rag",
    per_device_train_batch_size=2, # LoRA微调可适当增大批次
    gradient_accumulation_steps=4, # 模拟更大批次
    num_train_epochs=3,
    learning_rate=1e-4, # LoRA学习率可以稍高
    logging_dir='./logs',
    save_strategy="epoch",
    fp16=True, # 使用混合精度训练，进一步节省显存
    remove_unused_columns=False,
)

# 5. 创建Trainer
trainer = Trainer(
    model=model,
    args=training_args,
    train_dataset=tokenized_dataset,
    tokenizer=tokenizer,
)
trainer.train()

# 6. 保存LoRA权重和适配器配置
model.save_pretrained("./qwen-7b-lora-rag-adapter")

关键点与常见坑 ：

• 模型量化 ：如果显存紧张，可以使用 bitsandbytes 库进行4位或8位量化加载模型，实现QLoRA训练。
• 目标模块 ： target_modules 需要根据模型架构指定。对于Qwen、LLaMA等Transformer模型，通常是注意力层的 q_proj, k_proj, v_proj, o_proj 。选错模块可能无法有效微调。
• 数据格式 ：必须使用与模型对齐的对话模板（如ChatML for Qwen）。错误的数据格式会导致模型无法理解指令。
• 损失计算 ：在指令微调中，通常只对模型生成的答案部分（即 assistant 部分）计算损失。上述示例做了简化，生产代码中需要精确掩码。
• 提示词工程 ：微调数据中的 instruction 和 input 字段，本质上构成了一个强约束的提示词。这比在推理时动态拼接提示词更有效，因为它直接改变了模型的行为模式。

5. 整合与评估：构建增强型RAG管道

微调完成后，需要将优化后的组件整合回RAG管道，并进行系统性的评估。

5.1 构建整合管道

from langchain.vectorstores import Chroma
from langchain.embeddings import HuggingFaceEmbeddings
from langchain.llms import HuggingFacePipeline
from transformers import pipeline, AutoTokenizer, AutoModelForCausalLM
from peft import PeftModel
import torch

# 1. 加载微调后的Embedding模型
embedding_model = HuggingFaceEmbeddings(
    model_name="./my_finetuned_bge_m3", # 本地微调模型路径
    model_kwargs={'device': 'cuda'},
    encode_kwargs={'normalize_embeddings': True} # BGE模型建议归一化
)

# 2. 加载向量数据库（假设已用微调后的Embedding模型构建索引）
vectorstore = Chroma(
    persist_directory="./my_chroma_db",
    embedding_function=embedding_model
)
retriever = vectorstore.as_retriever(search_kwargs={"k": 5}) # 检索5个片段

# 3. 加载基础LLM并合并LoRA权重
base_model_name = "Qwen/Qwen1.5-7B"
tokenizer = AutoTokenizer.from_pretrained(base_model_name, trust_remote_code=True)
base_model = AutoModelForCausalLM.from_pretrained(
    base_model_name,
    torch_dtype=torch.bfloat16,
    device_map="auto",
    trust_remote_code=True
)
# 加载并合并LoRA适配器
lora_model = PeftModel.from_pretrained(base_model, "./qwen-7b-lora-rag-adapter")
merged_model = lora_model.merge_and_unload() # 合并权重以便推理加速

# 4. 创建文本生成管道
text_generation_pipeline = pipeline(
    "text-generation",
    model=merged_model,
    tokenizer=tokenizer,
    device_map="auto",
    max_new_tokens=512,
    do_sample=True,
    temperature=0.2, # 较低温度使输出更确定、更忠实
    top_p=0.9,
)

llm = HuggingFacePipeline(pipeline=text_generation_pipeline)

# 5. 定义RAG提示词模板
from langchain.prompts import PromptTemplate
prompt_template = """你是一个技术专家。请严格根据以下上下文来回答问题。如果上下文不包含答案，请直接说“根据提供的资料，我无法回答这个问题。”，不要编造信息。

上下文：
{context}

问题：{question}
请根据上下文回答："""
PROMPT = PromptTemplate(template=prompt_template, input_variables=["context", "question"])

# 6. 构建RAG链
from langchain.chains import RetrievalQA
qa_chain = RetrievalQA.from_chain_type(
    llm=llm,
    chain_type="stuff", # 简单地将所有上下文拼接
    retriever=retriever,
    chain_type_kwargs={"prompt": PROMPT},
    return_source_documents=True # 返回检索到的源文档，便于评估
)

# 7. 进行问答
result = qa_chain.invoke("Spring Boot如何集成Redis缓存？")
print("答案：", result['result'])
print("\n检索到的源文档：")
for doc in result['source_documents']:
    print(f"- {doc.page_content[:200]}...")

5.2 评估微调效果

评估不能只靠感觉，需要量化指标。可以从检索和生成两个层面评估。

检索层评估 ：

• 命中率（Hit Rate） ：在Top-K个检索结果中，至少包含一个正确答案文档的比例。
• 平均倒数排名（MRR） ：正确答案在检索结果中排名的倒数的平均值。

生成层评估 ：

• 忠实度（Faithfulness） ：生成的答案在多大程度上源自提供的上下文，而非模型本身的知识。可以使用基于NLI（自然语言推理）的评估模型，或通过规则检查答案中的关键实体/事实是否出现在上下文中。
• 答案相关性（Answer Relevance） ：生成的答案是否直接回答了问题。
• ROUGE/L/BERTScore ：与人工标注的标准答案在词重叠或语义上的相似度。

你可以构建一个包含 (问题， 上下文， 标准答案) 的测试集，编写脚本自动计算这些指标，对比微调前后的系统表现。

6. 常见问题排查与生产环境建议

6.1 微调过程中的典型问题

问题现象	可能原因	检查与解决方案
Loss不下降或波动大	学习率设置不当；数据质量差（如噪声大、标注错误）；批次大小太小。	1. 尝试降低学习率（如从 2e-5 调到 5e-6 ）。 2. 检查数据，确保 (query, pos, neg) 三元组构建正确。 3. 在资源允许下增大 per_device_train_batch_size ，或使用 gradient_accumulation_steps 。
训练后模型输出乱码或胡言乱语	数据格式与模型预训练格式不匹配；分词器设置错误；微调步数过多导致过拟合。	1. 确保指令模板与模型对齐（如ChatML）。 2. 检查 tokenizer 的 padding 、 truncation 设置。 3. 减少训练轮次 num_train_epochs ，或在验证集上早停。
显存不足（OOM）	模型太大；批次太大；未使用内存优化技术。	1. 使用LoRA/QLoRA，而非全参数微调。 2. 减小 per_device_train_batch_size 。 3. 开启梯度检查点 gradient_checkpointing=True 。 4. 使用 torch.bfloat16 或 fp16 混合精度。
检索效果提升不明显	Embedding微调数据不足或质量不高；负样本太简单；模型容量已达上限。	1. 增加高质量的训练数据，特别是“困难负样本”。 2. 尝试不同的损失函数，如 TripletLoss 。 3. 考虑更换更强的基础Embedding模型。

6.2 生产环境部署与优化建议

1. 模型服务化 ：不要直接加载完整模型进行推理。使用专门的推理服务器如 vLLM 、 TGI （Text Generation Inference）或 OpenAI兼容的API服务 （如FastChat），它们支持动态批处理、连续批处理等优化，能极大提高吞吐量。
2. 缓存机制 ：对频繁出现的相同或相似查询，缓存其Embedding向量和最终答案，减少重复计算。
3. 检索优化 ：
   • 混合检索 ：结合密集向量检索和传统关键词检索（如BM25），提升召回率。
   • 重排序 ：在初步检索（如返回100条）后，使用一个更精细的交叉编码器模型（如 bge-reranker ）对结果重排序，选出Top-5再生成。
   • 元数据过滤 ：为文档片段添加来源、章节、更新时间等元数据，检索时进行过滤，提升精度。
4. 监控与评估 ：
   • 日志记录 ：记录每次问答的用户问题、检索到的文档ID、生成答案、耗时和反馈（如有）。
   • 指标监控 ：监控API的响应延迟、错误率、Token消耗。
   • A/B测试 ：将微调后的新模型与旧版本进行线上A/B测试，用真实用户反馈评估效果。
5. 持续迭代 ：RAG系统不是一次性的。应建立数据飞轮，收集用户反馈和bad cases，持续补充到微调训练集中，让系统越用越聪明。

全链路微调是提升RAG系统可靠性的深度手段。它要求开发者深入理解数据、模型和任务，其回报是一个更精准、更可控、更专业的智能问答系统。从最关键的业务问题出发，从小规模高质量数据开始，先完成一个环节（如Embedding）的微调并验证收益，再逐步扩展到其他环节，是稳妥且有效的推进策略。