本文聚焦强化学习（RL）在检索增强生成（RAG）系统中的落地应用，避开复杂理论堆砌，重点拆解RL增强RAG的三大核心组件搭建思路、完整实现流程，搭配可直接运行的代码片段，兼顾小白入门理解与程序员实操复用，助力快速掌握RL对RAG系统的性能优化技巧。

强化学习与RAG的结合，核心是通过“智能体决策+反馈优化”解决传统RAG检索不精准、生成质量不稳定的痛点，其三大核心组件的搭建与升级路径如下：

• 状态表征与动作空间构建：精准捕捉智能体所处的实时状态，涵盖用户原始查询、已检索上下文信息及历史交互记录，同时设计查询重构、上下文拓展、噪声过滤、直接生成回答等多元化动作集合，为智能体决策提供支撑。
• 反馈激励机制：借助语义相似性算法（搭配大模型辅助评估），对RAG系统的输出回答进行量化打分，为智能体提供明确的奖励/惩罚信号，引导系统持续优化输出内容的精准度与可信度。
• 决策网络与训练机制：融合领域启发式规则与epsilon-greedy探索策略，平衡“已知有效动作复用”与“新动作探索”，通过多轮闭环迭代优化动作选择逻辑，让RAG系统在处理复杂、模糊查询时，展现更强的稳定性与鲁棒性。

引入强化学习后，RAG流程将摆脱“检索-生成”的固定链路，能够依据模型实时反馈动态调整检索策略——不仅支持查询改写优化，还能智能实现上下文块的扩展与精简，通过多轮迭代逐步逼近全局最优解，大幅提升复杂场景下的问答质量。

一、强化学习增强型RAG技术框架

在智能问答与知识增强生成（RAG）领域，传统流程通常是先从海量文档中检索相关信息，再由生成模型产出答案。为便于理解，我们通过对比图示来解析两种技术路径——传统RAG与强化学习增强型RAG的核心差异。

（一）传统RAG方法

传统RAG方法工作流程图

传统RAG方法遵循简洁的三段式流程：

1. 文档预处理：将原始文档切割为若干语义完整的内容块（Chunk）；
2. 相似性检索：利用向量嵌入技术，基于用户查询定位最相关的内容片段；
3. 答案生成：将Top K匹配片段作为背景知识输入大语言模型，生成最终回复。

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

强化学习增强型RAG工作流程图

为实现RAG系统的智能化升级，我们引入强化学习智能体，构建了闭环优化的RAG处理框架：

1. 策略动态调适：智能体依据语言模型的输出结果持续优化检索策略，使每轮查询更贴合用户真实需求。
2. 智能检索增强：支持查询重写、相关内容扩展、冗余信息剔除等操作，全方位提升上下文质量。
3. 多轮进化机制：通过多轮交互迭代，智能体不断修正决策方向，使生成结果逐步接近最优解，显著提升答案的准确性与语义相关性。

与传统RAG相比，这种增强方案更注重决策过程的智能化和输出质量的持续进化，使问答系统在复杂场景下的表现更可靠、更具适应性。

二、基础RAG流程构建

（一）系统环境配置

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

import os
import sys
import json
import math
import random
import hashlib
import time
import numpy as np
from typing import List, Dict, Tuple, Optional, Any
from dotenv import find_dotenv, load_dotenv

from langchain_chroma import Chroma
from langchain_community.chat_models.tongyi import ChatTongyi
from langchain_community.document_loaders import DirectoryLoader
from langchain_community.embeddings import HuggingFaceBgeEmbeddings
from langchain.vectorstores.base import VectorStoreRetriever
from chinese_recursive_text_splitter import ChineseRecursiveTextSplitter
from 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.5000
Best RL-enhanced reward: 0.7500
Improvement: 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 ？

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

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

“最先掌握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%免费】