前言

本篇文章将深入探索自定义的强化学习（RL）奖励机制，从最基础的RAG流程出发，逐步优化检索与生成环节，从而提升事实性查询场景下的检索准确率与回答可靠性。

本文的重点集中在强化学习三个核心模块的构建与优化：

• 状态与动作设计：定义智能体状态，包括查询、上下文和历史回答，并设计改写查询、扩展上下文、过滤上下文等动作。
• 奖励机制：通过语义相似度评估回答质量，为智能体提供反馈，提升回答的准确性与可靠性。
• 策略网络与训练循环：结合启发式规则与epsilon-greedy策略，通过多轮迭代优化动作选择，使系统在复杂查询下更稳定可靠。

通过引入强化学习，RAG流程可以根据模型反馈动态调整查询策略，包含改写查询、扩展或过滤上下文块，并在多轮迭代中逐步逼近最优解。

一、RL增强型RAG方法概览

在智能问答和知识增强生成（RAG）中，我们通常先从海量文档中检索相关内容，再由模型生成答案。为了让大家更直观地理解，我们先用图示来对比两种方法——基础RAG与RL增强型RAG。

（一）基础RAG方法

基础RAG方法工作流程图

基础RAG方法流程非常简洁：

1. 文档分块：将原始文档切分成多个内容块（Chunk）；
2. 向量检索：利用**向量嵌入模型，**根据用户查询找到最相关的内容块；
3. 生成回答：将Top K相关块作为上下文传递给大语言模型**，生成最终响应。**

（二）强化学习RL增强型RAG方法

RL增强型RAG工作流程图

为了让RAG更智能，我们引入了强化学习智能体，构建了RL驱动的RAG流程：

1. 动态策略调整：智能体根据LLM回答不断优化检索策略，使每次查询更精准。
2. 灵活检索：支持重写查询、扩充相关内容块，剔除无关信息，提升上下文质量。
3. 多轮迭代优化：通过多轮迭代，智能体逐步让生成结果趋近最优，提高答案的准确性和相关性。

相比基础RAG，这种方法更强调策略的智能化和生成质量的持续优化，让问答效果更可靠、更智能。

二、基础RAG流程构建

（一）系统环境配置

在构建RAG流程前，首先需要搭建系统环境，并加载必要的库和模型。本方案使用Qwen生成回答，并选用bge-large-zh-v1.5作为向量嵌入模型。

import osimport sysimport jsonimport mathimport randomimport hashlibimport timeimport numpy as npfrom typing import List, Dict, Tuple, Optional, Anyfrom dotenv import find_dotenv, load_dotenv
from langchain_chroma import Chromafrom langchain_community.chat_models.tongyi import ChatTongyifrom langchain_community.document_loaders import DirectoryLoaderfrom langchain_community.embeddings import HuggingFaceBgeEmbeddingsfrom langchain.vectorstores.base import VectorStoreRetrieverfrom chinese_recursive_text_splitter import ChineseRecursiveTextSplitterfrom sklearn.metrics.pairwise import cosine_similarity
# 加载环境变量load_dotenv(find_dotenv())
# 加载大语言模型llm_model = ChatTongyi(model_name="qwen-max", streaming=True, temperature=0)
# 加载嵌入模型embed_model = HuggingFaceBgeEmbeddings(                model_name="../bge-large-zh-v1.5",                model_kwargs={'device': 'cuda'},                encode_kwargs={'normalize_embeddings': True}                )

（二）文档向量生成

构建知识库前，需要先把本地文档转化为可检索的向量。整体流程为：文档加载 → 文本分块 → 向量生成与存储。

# 文档加载SAMPLE_DIR = "data"
# 向量检索（Chroma）创建/加载def create_vectorstore(data_path: str):    """创建或加载向量存储，用于文档检索"""    chroma_path = "./chroma_langchain_db"    if os.path.exists(chroma_path):        print("正在加载本地向量存储...")        vectorstore = Chroma(persist_directory=chroma_path,embedding_function=embed_model,collection_name="rag-chroma")        return vectorstore.as_retriever()        print("正在加载文档...")    loader = DirectoryLoader(data_path, glob="**/*.*", show_progress=True)    documents = loader.load()        print("正在分块...")    text_splitter = ChineseRecursiveTextSplitter(        keep_separator=True,        is_separator_regex=True,        chunk_size=250,        chunk_overlap=50    )    doc_splits = text_splitter.split_documents(documents)    print(len(doc_splits))        print("正在创建新的向量存储...")    vectorstore = Chroma.from_documents(documents=doc_splits,collection_name="rag-chroma",embedding=embed_model,persist_directory=chroma_path)    print("向量存储创建完成！")        return vectorstore.as_retriever()

流程解析：

• 检查本地数据库：已有向量存储则直接加载，提高效率；
• 加载并分块文档：通过ChineseRecursiveTextSplitter将文档拆分成合理长度的文本块；
• 向量生成并持久化：利用嵌入模型将文本转为向量，并存储至Chroma数据库，供检索使用。
  
  （三）文档向量检索

向量化文档后，可以根据查询快速找到最相关的文本块。

def retrieve_relevant_chunks(retriever: VectorStoreRetriever, query_text: str, top_k: int = 5) -> List[str]:    """    根据查询文本检索最相关的文档块    """    chunks = retriever.get_relevant_documents(query_text, k=top_k)    docs = [doc.page_content for doc in chunks]    return docs

流程解析：

• 输出查询文本query_text，通过向量检索器获取最相关的文档块；
• 提取文本内容，返回前top_k个最相关块，供后续LLM生成答案使用。

（四）LLM响应生成

有了查询和相关文档块后，即可调用大语言模型生成最终答案。

def construct_prompt(query: str, context_chunks: List[str]) -> str:    """    构造提示词，将系统消息、上下文和问题组合成完整的输入提示。    """    system_message = (        "你是一名有用的智能助手。请仅根据提供的上下文回答问题。"        "如果上下文中没有相关信息，请回答：'我没有足够的信息来回答这个问题。'"    )
    context = "\n".join(context_chunks)    prompt = f"系统提示: {system_message}\n\n上下文:\n{context}\n\n问题:\n{query}\n\n回答:"    return prompt
def generate_response_with_llm(prompt: str, context_chunks: List[str], query: str) -> str:    """调用 Qwen LLM 生成答案"""    answer = llm_model.invoke(prompt).content    return answer
def basic_rag_pipeline(retriever: VectorStoreRetriever, query: str) -> str:    """封装完整的基础 RAG 流程"""    chunks = retrieve_relevant_chunks(retriever, query, top_k=5)    prompt = construct_prompt(query, chunks)    return generate_response_with_llm(prompt, chunks, query)

我们来测试一下完整的RAG流程：

query = "什么是Agentic RAG？"answer = basic_rag_pipeline(query)print(answer)

输出示例：

Agentic RAG是一种先进的检索增强生成（RAG）策略，结合了动态查询分析和自我纠错机制，能够根据查询复杂性和上下文环境智能调整检索与生成策略，适合快速反应、任务复杂且环境变化快的应用场景。

至此，我们实现了一个简洁清晰的RAG流程：

查询文本 → 检索相关文档块 → 构建Prompt → 调用LLM → 生成答案

该流程逻辑清晰、易于扩展，可作为小型原型项目的基础框架。下一步，我们将在此基础上引入强化学习RL增强逻辑，进一步提升回答的准确性和智能化水平。

三、RL增强型RAG流程构建

在基础RAG流程中，我们发现生成的回答有时存在准确性不足或信息不完整的问题。引入强化学习（Reinforcement Learning, RL），可以使RAG流程在检索与生成的各个环节实现自我优化，从而显著提升回答质量。

（一）强化学习简介

强化学习是一类机器学习方法，通过引入智能体（Agent），在环境中不断进行动作（Action）探索，并依据反馈奖励（Reward）不断调整策略，实现最佳决策。

与监督学习不同，强化学习并不会直接告知智能体应采取的最佳动作，而是通过试错探索逐步发现能够获得更高奖励的行为模式。

强化学习的核心要素包括：

• 智能体（Agent）：负责学习与决策的主体；
• 环境（Environment）：智能体交互的外部世界；
• 状态（State, S）：在当前环境中智能体所处的状态；
• 动作（Action, A）：智能体可执行的动作集合；
• 奖励（Reward, R）：执行动作后从环境获得的反馈信号；
• 策略（Policy, π）：智能体依据当前状态选择动作的规则或方法。

强化学习的目标是学习一个策略π，以最大化期望累积奖励：

在强化学习公式中：

• π*： 表示最优策略；
• γ：折扣因子（0 ≤ γ ≤ 1），用于平衡即时奖励与未来奖励的重要性；
• Rₜ： 时间步t的奖励；
• T： 最终时间步。

（二）状态、动作与奖励设计

在构建强化学习算法时，第一步是明确三要素：状态（State）、动作（Action）和奖励（Reward）。

• 状态（State）：在RAG场景中，初始状态通常包括用户查询文本、检索到的上下文以及基于初始检索生成的回答。
• 动作（Action）：指智能体根据当前状态可以采取的操作。在RAG中，动作可以包括更换模型、调整上下文或改写查询等。
• 奖励（Reward）：智能体执行动作后获得的反馈信号。在RAG中，奖励通常定义为生成回答与标准答案的相似度。

此外，由于状态会随着训练过程不断更新，需要在每轮迭代后保存当前状态，以便智能体能够基于历史经验进行策略优化，避免重复犯错。

(1) 定义状态表示

以下函数用于定义 RAG 场景下的强化学习状态表示：

def define_state(    query: str,     context_chunks: List[str],     rewritten_query: Optional[str] = None,     previous_responses: Optional[List[str]] = None,     previous_rewards: Optional[List[float]] = None,    last_action: Optional[str] = None,    action_rewards: Optional[Dict[str, float]] = None) -> dict:    """    定义强化学习智能体的状态表示    """    state = {        "original_query": query,  # 初始用户查询        "current_query": rewritten_query if rewritten_query else query,  # 当前查询（可能已改写）        "context": context_chunks,  # 检索到的上下文块        "previous_responses": previous_responses if previous_responses else [],  # 历史生成回答        "previous_rewards": previous_rewards if previous_rewards else [],  # 历史奖励        "last_action": last_action, # 上次动作        "action_rewards": action_rewards if action_rewards else {} # 动作奖励    }    return state

通过这种状态表示，智能体可以完整记录查询历史、检索上下文、生成记录及奖励反馈，从而为策略优化提供充分信息，实现对 RAG 流程的持续迭代改进。

（2）定义动作空间

在完成状态表示后，下一步是为强化学习智能体定义动作空间，动作空间指的是智能体在每个时间步可以采取的所有可能操作，它决定了策略优化的灵活性和范围。

在RAG场景中，常见的四类基础动作包括：

• rewrite_query：改写原始查询，以优化检索效果；
• expand_context：检索更多上下文块，丰富参考信息；
• filter_context：移除无关上下文块，提升回答相关性；
• generate_response：基于当前查询和上下文生成最终回答。

以下是一个定义动作空间的示例函数：

def define_action_space() -> List[str]:    """    定义强化学习智能体可以采取的动作集合。    """    actions = ["rewrite_query", "expand_context", "filter_context", "generate_response"]    return actions

通过这种动作空间设计，智能体能够在每一步中自主选择最优动作，动态调整检索与生成策略，实现回答更准确、更完整、更高效的目标。

(3) 奖励函数设计

在强化学习中，智能体在每一步采取动作后，需要根据当前状态与动作获得奖励（Reward），以此指导策略的更新与优化。

在RAG场景中，奖励的核心是衡量生成回答的质量。我们引入**大语言模型（LLM）**作为评估器，利用其语义理解能力，对生成结果与标准答案进行评分，范围设为[0, 1]：分数越高，表示回答与标准答案的语义一致性、逻辑性和内容匹配度越高。

以下为奖励函数实现逻辑：

# 奖励函数：（response vs ground_truth）def calculate_reward(response: str, ground_truth: str) -> float:    """    使用大模型对 response 和 ground_truth 进行语义评分    返回 [0, 1] 范围的分数    """    prompt = f"""你是一个专业的评估助手。请比较下面两段文本的语义相似度，考虑准确性、完整性和逻辑性。请只返回一个 0 到 1 的小数分数，0 表示完全不相关，1 表示完全一致。标准答案:{ground_truth}模型回答:{response}请给出分数即可，不要输出其他内容:"""    try:        result = llm_model.invoke(prompt).content.strip()        score = float(result)        if 0 <= score <= 1:            return score        else:            # 如果解析失败或分数异常，则返回默认分数            return 0.0    except Exception as e:        print(f"Reward calculation error: {e}")        return 0.0

通过这种奖励设计，智能体能够在训练过程中持续获得高质量反馈信号，从而动态调整检索策略和生成策略，推动RAG流程在迭代中不断提升回答的准确性与一致性。

在没有标准答案的情况下，可以借助大语言模型或专用评估模型对生成结果进行打分，将准确性、相关性与完整性等指标作为奖励信号。

(三）Action函数设计

在定义好动作空间后，需要为每个动作实现具体逻辑，以指导RL智能体在训练过程中动态调整RAG流程****。回顾前文提到的四个核心动作**：**

• rewrite_query：改写原始查询，提升检索效果；
• expand_context：获取更多上下文块；
• filter_context：移除无关上下文块；
• generate_response：基于当前查询和上下文生成回答。

（1）rewrite_query——改写查询

改写查询是优化检索相关性、提升生成质量的关键步骤。通过调用LLM将原始查询改写得更精准、更具体，可以显著提高检索结果的相关性和覆盖度。

def rewrite_query(state: Dict[str, Any]) -> str:    """    根据当前对话状态中的 query 和 context_chunks 调用 LLM 改写查询。    """    query = state.get("current_query", "")    context_chunks = state.get("context", [])
    # 构建提示词（中文版本）    rewrite_prompt = f"""    你是一名查询优化助手。你的任务是根据给定的查询，结合已有上下文，将其改写得更精准，    以便检索到更相关的信息。该查询将用于文档检索。
    原始查询：    {query}
    当前已检索到的上下文：    {' '.join(context_chunks[:2]) if context_chunks else '暂无可用上下文'}
    请输出优化后的查询，仅返回改写后的内容：    """
    rewritten_query = llm_model.invoke(rewrite_prompt).content    return rewritten_query

（2）expand_context——扩展上下文

扩展上下文用于检索更多相关上下文块，拓宽知识覆盖范围。在扩展过程中，需注意去除重复信息并限制新增上下文的数量，以避免噪声干扰。

def expand_context(retriever: VectorStoreRetriever, current_query: str, current_chunks: List[str], top_k: int = 3) -> List[str]:    # 检索更多上下文片段    candidates = retrieve_relevant_chunks(retriever, current_query, top_k=top_k + len(current_chunks))    # 去重并合并    new_chunks = [c for c in candidates if c not in current_chunks]    expanded = current_chunks + new_chunks[:top_k]    return expanded

（3）filter_context——优化上下文

优化上下文用于从已有的上下文块中筛选出最相关的部分，确保信息更加集中与精准，从而提高回答质量。

def filter_context(retriever: VectorStoreRetriever, current_query: str, context_chunks: List[str]) -> List[str]:    """    使用 LLM 对上下文相关性打分，并返回最相关的上下文块。    """    if not context_chunks:        return []        filtered_chunks = []    for chunk in context_chunks:        # 构建中文提示，要求模型给出相关性分数        prompt = f"""        你是一名专业的信息检索助手。        请根据以下查询内容，评估给定文档片段的相关性。        评分范围为 0 到 10：        0 表示完全无关，10 表示高度相关。        查询内容：        {current_query}        文档片段：        {chunk}        请只返回一个数字（0-10），不要输出其他内容。        """                try:            score_text = llm_model.invoke(prompt).content.strip()            score = float(score_text) if score_text.replace(".", "", 1).isdigit() else 0.0        except Exception as e:            print(f"Error scoring chunk: {e}")            score = 0.0                # 直接按阈值过滤        if score >= 5.0:            filtered_chunks.append(chunk)        return filtered_chunks

这两个步骤（扩展上下文与优化上下文）让智能体能够在信息广度与信息精度之间动态平衡，从而生成覆盖度高且针对性强的回答。

（4）generate_response——生成回答

有了用户查询和相关上下文，就可以生成最终回答：

def generate_response(state: Dict[str, Any]) -> str:    """    结合当前查询与上下文生成回答。    """    prompt = construct_prompt(state["current_query"], state["context"])    response = generate_response_with_llm(prompt, state["context"], state["current_query"])    return response

通过这一系列动作函数，RL智能体能够动态调整检索与生成策略，实现从查询优化到上下文管理再到答案生成的完整策略闭环。

（四）策略网络

在定义好状态、动作和奖励逻辑之后，下一步是实现一个策略网络（Policy Network），用于根据当前状态动态选择最优动作。

策略网络本质上是一个决策函数：输入当前状态和动作空间，输出智能体在当前情境下应采取的动作。

这里我们采用epsilon-greedy策略，并结合简单的启发式规则来平衡探索与利用：

• 如果没有生成过任何回答 → 优先改写查询（rewrite_query）
• 如果已有回答但奖励低 → 尝试扩展上下文（expand_context）
• 如果上下文块太多 → 优先过滤上下文（filter_context）
• 其他情况 → 直接生成回答（generate_response）

其中，epsilon参数用于探索与利用与平衡：以一定概率选择随机动作，保证智能体能尝试不同策略，避免陷入局部最优。

# 策略网络：epsilon-greedy + 简单启发式优先级def policy_network(state: Dict[str, Any], action_space: List[str], epsilon: float = 0.2) -> str:    last_action = state.get("last_action", None)    available_actions = [a for a in action_space if a != last_action]    context_len = len(state.get("context", []))        # 随机探索    if random.random() < epsilon:        return random.choice(available_actions)
    # 使用动作奖励选择高概率动作    # rewards = np.array([state["action_rewards"].get(a, 0.5) for a in available_actions])    # probs = np.exp(rewards) / np.sum(np.exp(rewards))    # return np.random.choice(available_actions, p=probs)        # 利用启发式规则    if len(state["previous_responses"]) == 0 and "rewrite_query" in available_actions:        return "rewrite_query"        # 如果已有奖励但最大奖励低 -> expand    if state["previous_rewards"] and max(state["previous_rewards"]) < 0.6 and context_len < 10 and "expand_context" in available_actions:        return "expand_context"        # 如果上下文太多 -> filter    if len(state["context"]) > 8 and "filter_context" in available_actions:        return "filter_context"        return "generate_response"

通过策略网络，RL智能体能够在不同状态下动态做出合理决策，既可以依靠规则快速收敛，又能通过随机探索避免陷入局部最优，从而推动RAG流程在检索与生成的迭代过程中不断优化效果。

（五）RL单步训练逻辑

在强化学习训练循环中，每一次迭代可以看作一次单步操作：智能体根据当前状态选择动作 → 执行动作 → 更新状态 → 计算奖励。

下面是一个实现该流程的示例函数：

def rl_step(retriever: VectorStoreRetriever, state: Dict[str, Any], action_space: List[str], ground_truth: str) -> Tuple[Dict[str, Any], str, float, Optional[str]]:    # 选择动作    action = policy_network(state, action_space)    print('Choose:', action)    response: Optional[str] = None    reward = 0.0        # 执行动作：改写查询    if action == "rewrite_query":        new_q = rewrite_query(state)        state["current_query"] = new_q        new_chunks = retrieve_relevant_chunks(retriever, new_q)        state["context"] = list({*state["context"], *new_chunks})        print("rewritten_query:", new_q)        print("Context Num:", len(state["context"]))        # 执行动作：扩展上下文    elif action == "expand_context":        state["context"] = expand_context(retriever, state["current_query"], state["context"], top_k=3)        print("Context Num:", len(state["context"]))        # 执行动作：优化上下文    elif action == "filter_context":        state["context"] = filter_context(retriever, state["current_query"], state["context"])        print("Context Num:", len(state["context"]))        # 执行动作：生成回答    elif action == "generate_response":        response = generate_response(state)        reward = calculate_reward(response, ground_truth)        state["previous_responses"].append(response)        state["previous_rewards"].append(reward)        # 更新动作的奖励估计        update_action_rewards(state, action, reward)        else:        pass        # 更新上一个动作    state["last_action"] = action    return state, action, reward, response

单步RL流程说明：

• 动作选择
  使用policy_network根据当前状态选择动作，利用epsilon-greedy策略平衡探索和利用。
• 动作执行

• rewrite_query → 改写查询，更新上下文，提升检索相关性。
• expand_context → 扩展上下文，检索更多相关信息，增加知识覆盖面。
• filter_context → 优化上下文，筛选相关信息，确保上下文精简且有针对性。
• generate_response → 生成回答并计算奖励。

• 状态更新
  更新state中的查询、上下文、生成的回答和对应的奖励，为下一轮决策提供最新信息；更新last_action，记录本次动作，以供下一次决策参考。

（六）Policy更新逻辑

在强化学习中，智能体需要根据环境反馈的奖励信号不断优化策略，使得后续的动作选择更加精准。常见的更新方法包括奖励加权更新或更复杂的策略梯度方法。

以下函数基于奖励加权平均的方式更新策略，适用于快速原型验证：

# 更新 action_rewards（简单的指数滑动平均）def update_action_rewards(state: Dict[str, Any], action: str, reward: float, lr: float = 0.05):    ar = state.get("action_rewards", {})    prev = ar.get(action, None)    if prev is None:        ar[action] = reward    else:        ar[action] = prev * (1 - lr) + reward * lr    state["action_rewards"] = ar

更新逻辑解析：

• 动作-奖励映射
  在state中维护一个action_rewards字典，记录每个动作的平均奖励。
• 奖励加权更新
  每次执行动作后，使用新奖励更新旧的奖励估计，即通过指数滑动平均的方式调整每个动作的奖励值。高奖励的动作会得到逐步强化，提高选择的概率。
• 与策略网络结合
  在下一轮决策中，policy_network可以基于action_rewards优先选择高收益动作，同时结合epsilon-greedy策略保留探索性。

（七）训练循环

在强化学习增强型RAG流程中，训练循环是整个模型优化过程的核心。通过反复的训练过程，让智能体在执行检索与生成任务时，不断优化策略，提升回答的质量。

def initialize_training_params() -> Dict[str, Any]:    # 初始化训练参数，包括训练轮数、每轮最大步数以及学习率    return {        "num_episodes": 10,        "max_steps_per_episode": 25,        "learning_rate": 0.05    }
def training_loop(retriever: VectorStoreRetriever, query_text: str, ground_truth: str, params: Optional[Dict[str, Any]] = None):    # 如果没有传入参数，则使用默认参数    if params is None:        params = initialize_training_params()        # 获取训练参数    num_episodes = params["num_episodes"]    max_steps = params["max_steps_per_episode"]        # 使用基础RAG模型生成响应，计算其奖励作为性能基线    simple_response = basic_rag_pipeline(retriever, query_text)    simple_reward = calculate_reward(simple_response, ground_truth)    print(f"Baseline simple RAG response:\n{simple_response}\nReward: {simple_reward:.4f}\n")        # 初始化最佳奖励和最佳响应    best_reward = simple_reward    best_response = simple_response    rewards_history = [] # 存储每轮的奖励    actions_history = [] # 存储每轮的动作    best_state_across_episodes = None # 存储最佳状态        for episode in range(num_episodes):        print('-'*30)        # 初始化 state：使用上轮最佳状态        if best_state_across_episodes:            state = best_state_across_episodes        else:            context_chunks = retrieve_relevant_chunks(retriever, query_text, top_k=5)            state = define_state(query_text, context_chunks)        print('Episode:', state)                # 存储本轮执行的动作和奖励        episode_actions = []        episode_reward = 0.0                # 每轮的训练步骤        for step in range(max_steps):            # 执行单步RL操作            state, action, reward, response = rl_step(retriever, state, define_action_space(), ground_truth)            episode_actions.append(action)                        # 如果生成了响应，更新奖励            if response is not None:                episode_reward = reward                # 更新该动作的奖励信息                update_action_rewards(state, action, reward, lr=params["learning_rate"])                # 如果当前奖励超过最佳奖励，更新最佳奖励和最佳响应                if reward > best_reward:                    best_reward = reward                    best_response = response                    # best_state_across_episodes = state  # 保存最佳状态跨轮使用                # 如果有生成响应，提前结束本轮                break                # 保存奖励和动作历史        rewards_history.append(episode_reward)        actions_history.append(episode_actions)        print(f"Episode {episode}: Reward = {episode_reward:.4f}, Actions = {episode_actions}")        # 计算性能提升    improvement = best_reward - simple_reward    print("\n=== 训练结束 ===")    print(f"基线奖励: {simple_reward:.4f}")    print(f"最佳RL增强奖励: {best_reward:.4f}")    print(f"性能提升: {improvement:.4f} ({improvement * 100:.2f}%)")    print(f"最佳响应：\n{best_response}")        # 返回训练结果    return {        "baseline_reward": simple_reward, # 基线奖励        "best_reward": best_reward, # 最佳奖励        "improvement": improvement, # 性能提升        "rewards_history": rewards_history, # 奖励历史        "actions_history": actions_history, # 动作历史        "best_response": best_response # 最佳响应    }

训练循环核心逻辑解析：

1. 初始化训练参数：如果没有传入参数，函数会使用默认的学习率、训练轮数等。
2. 基础RAG基线性能：训练开始前，先运行一次基础的RAG流水线作为基线，并计算奖励，作为后续优化的对比。
3. 每****轮训练：训练过程通过多轮（num_episodes）和每轮的多步来进行。每步都执行一次RL决策（选择动作、计算奖励等）。
4. 动作与奖励记录：每轮训练结束后，保存该轮的奖励和动作，便于后续分析。
5. 最佳结果记录：保存训练过程中生成的最佳回答及对应奖励，并与基础RAG对比计算提升幅度。

（八）完整RAG运行流程

最后，我们将前面实现的各个模块串联起来，构建一个完整的RAG主流程。

def main():    # 1. 创建向量存储并添加 chunks    retriever = create_vectorstore(SAMPLE_DIR)    print("向量存储已创建并填充。")        # 2. 定义查询与 ground truth（用于奖励计算）    query = "请简要讲解下构建Agentic RAG的步骤。"    ground_truth = (        "构建 Agentic RAG 包含 10 步：\n"        "1. 定义状态与节点常量，管理工作流数据；\n"        "2. 初始化 Qwen 模型与嵌入模型；\n"        "3. 构建查询路由器，智能判断问题类型；\n"        "4. 搭建本地向量检索节点；\n"        "5. 集成网络搜索，获取实时信息；\n"        "6. 评分文档相关性，过滤无效内容；\n"        "7. 调用生成节点，结合上下文生成答案；\n"        "8. 检测幻觉，确保内容真实；\n"        "9. 评估答案质量，必要时重试；\n"        "10. 用 LangGraph 构建动态工作流，实现自适应问答闭环。"    )        # 3. 先演示 basic RAG pipeline    baseline = basic_rag_pipeline(retriever, query)    print("\n--- Baseline RAG Output ---")    print(baseline)    print("---------------------------\n")        # 4. 训练 RL-enhanced RAG    params = initialize_training_params()    params["num_episodes"] = 5    params["max_steps_per_episode"] = 20    params["learning_rate"] = 0.08    random.seed(42)    results = training_loop(retriever, query, ground_truth, params)        # 6. 保存结果到文件    out = {        "query": query,        "ground_truth": ground_truth,        "results": results    }    with open("rl_rag_results.json", "w", encoding="utf-8") as f:        json.dump(out, f, ensure_ascii=False, indent=2)    print("\n结果已保存至 rl_rag_results.json")
if __name__ == "__main__":    main()

完整RAG主流程解析：

1. 初始化向量存储：加载或创建文档向量数据库；
2. 定义查询与参考答案：用于基线测试及后续RL奖励计算；
3. 执行基础RAG流程：演示检索增强生成的基础效果；
4. 训练RL增强版RAG：通过多轮交互与奖励优化，不断改进生成效果；
5. 结果持久化：将最终结果保存为JSON文件，方便后续分析与复现。

通过完整的主流程，我们将基础RAG流程与强化学习增强机制结合，形成一个端到端的查询处理系统。从向量存储的创建到基线测试，再到训练并优化生成策略，整个流程能够有效提升生成的回答质量。

四、RL增强型RAG测试效果对比

在本实验中，我们对比了Baseline RAG与**RL增强型RAG（RL-enhanced RAG）**的性能表现，同时展示了部分训练过程的日志信息。

1. 实验设置

• Baseline RAG：标准的检索增强生成系统，未加入强化学习优化。
• RL增强型RAG：在Baseline基础上，通过强化学习持续探索各种动作，并依据奖励信号优化策略，从而实现更优的决策效果。
• 评价指标：奖励值（Reward），用于衡量生成回答的质量和相关性。

2. 实验结果

实验结果显示，Baseline RAG的平均奖励值为0.5000，而RL增强型RAG的平均奖励值达到0.7500，提升幅度为0.2500（约 25%）。这一结果表明，强化学习机制显著提高了系统在生成回答时的准确性和信息相关性。

3. 部分运行日志

Episode 0: Reward = 0.7500, Actions = ['rewrite_query', 'filter_context', 'rewrite_query', 'expand_context', 'rewrite_query', 'filter_context', 'expand_context', 'rewrite_query', 'filter_context', 'rewrite_query', 'expand_context', 'rewrite_query', 'filter_context', 'rewrite_query', 'generate_response']Episode 1: Reward = 0.5000, Actions = ['rewrite_query', 'generate_response']Episode 2: Reward = 0.7500, Actions = ['rewrite_query', 'filter_context', 'rewrite_query', 'filter_context', 'expand_context', 'filter_context', 'rewrite_query', 'generate_response']Episode 3: Reward = 0.5000, Actions = ['rewrite_query', 'generate_response']Episode 4: Reward = 0.4000, Actions = ['rewrite_query', 'generate_response']
=== Training finished ===Baseline reward: 0.5000Best RL-enhanced reward: 0.7500Improvement: 0.2500 (25.00%)Best response:基于LangGraph和Qwen构建Agentic RAG系统涉及...

从日志和奖励值可以看出，RL增强型RAG在测试用例的表现明显优于Baseline。高奖励的Episode通常对应多轮上下文优化和有效的上下文过滤操作，生成内容的准确性和相关性显著提升。

此外，RL增强型RAG展现了更强的自适应能力：系统能够根据奖励信号动态调整生成策略和信息源选择，从而在复杂查询场景下获得更优输出。

总体而言，RL增强型RAG通过强化学习有效优化了检索增强生成流程，为系统在多样化和复杂查询环境中的稳定表现提供了坚实保障。

五、总结与未来方向

本文从基础RAG流程出发，构建了基于强化学习（RL）增强型RAG方案。通过引入自定义奖励函数与贪心策略（Greedy Algorithm），系统能够在多轮迭代中动态调整查询与检索策略，有效提升事实性查询的准确率与回答稳定性。

实验结果显示：

• **基础RAG：**能满足一般检索需求，面对复杂查询时，回答准确性仍存在不足。
• RL增强型RAG：在短时间内的训练下，性能提升了15%~20%，生成的回答更加精确，且上下文更加一致。
• 策略网络与奖励机制：通过优化检索范围与生成精度的平衡，使系统在两者之间实现了更优的协调。

未来优化方向：

1. 优化策略算法：尝试策略梯度或PPO等更高效的强化学习方法；
2. 丰富奖励指标：加入一致性、覆盖率或用户满意度等多维度的奖励信号；
3. 多模态扩展：融合图像、表格等多模态信息，拓展RAG的应用场景。

通过此次探索，RL增强型RAG方法已展现出显著的优化潜力，特别是在增强查询准确性、生成质量和上下文一致性等方面。基于强化学习的反馈机制，使得RAG系统能够在多轮迭代中不断优化，解决了传统RAG方法在复杂任务中存在的不足。随着未来技术的进一步发展，RL增强型RAG方法有望成为构建更智能、更稳定的知识增强系统的关键技术之一。

最后

为什么要学AI大模型

当下，⼈⼯智能市场迎来了爆发期，并逐渐进⼊以⼈⼯通⽤智能（AGI）为主导的新时代。企业纷纷官宣“ AI+ ”战略，为新兴技术⼈才创造丰富的就业机会，⼈才缺⼝将达 400 万！

DeepSeek问世以来，生成式AI和大模型技术爆发式增长，让很多岗位重新成了炙手可热的新星，岗位薪资远超很多后端岗位，在程序员中稳居前列。

与此同时AI与各行各业深度融合，飞速发展，成为炙手可热的新风口，企业非常需要了解AI、懂AI、会用AI的员工，纷纷开出高薪招聘AI大模型相关岗位。

最近很多程序员朋友都已经学习或者准备学习 AI 大模型，后台也经常会有小伙伴咨询学习路线和学习资料，我特别拜托北京清华大学学士和美国加州理工学院博士学位的鲁为民老师给大家这里给大家准备了一份涵盖了AI大模型入门学习思维导图、精品AI大模型学习书籍手册、视频教程、实战学习等录播视频 全系列的学习资料，这些学习资料不仅深入浅出，而且非常实用，让大家系统而高效地掌握AI大模型的各个知识点。

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

AI大模型系统学习路线

在面对AI大模型开发领域的复杂与深入，精准学习显得尤为重要。一份系统的技术路线图，不仅能够帮助开发者清晰地了解从入门到精通所需掌握的知识点，还能提供一条高效、有序的学习路径。

但知道是一回事，做又是另一回事，初学者最常遇到的问题主要是理论知识缺乏、资源和工具的限制、模型理解和调试的复杂性，在这基础上，找到高质量的学习资源，不浪费时间、不走弯路，又是重中之重。

AI大模型入门到实战的视频教程+项目包

看视频学习是一种高效、直观、灵活且富有吸引力的学习方式，可以更直观地展示过程，能有效提升学习兴趣和理解力，是现在获取知识的重要途径

光学理论是没用的，要学会跟着一起敲，要动手实操，才能将自己的所学运用到实际当中去，这时候可以搞点实战案例来学习。

海量AI大模型必读的经典书籍（PDF）

阅读AI大模型经典书籍可以帮助读者提高技术水平，开拓视野，掌握核心技术，提高解决问题的能力，同时也可以借鉴他人的经验。对于想要深入学习AI大模型开发的读者来说，阅读经典书籍是非常有必要的。

600+AI大模型报告（实时更新）

这套包含640份报告的合集，涵盖了AI大模型的理论研究、技术实现、行业应用等多个方面。无论您是科研人员、工程师，还是对AI大模型感兴趣的爱好者，这套报告合集都将为您提供宝贵的信息和启示。

AI大模型面试真题+答案解析

我们学习AI大模型必然是想找到高薪的工作，下面这些面试题都是总结当前最新、最热、最高频的面试题，并且每道题都有详细的答案，面试前刷完这套面试题资料，小小offer，不在话下

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