强化学习实战：DQN、PPO、SAC算法在CartPole中的应用

1. 强化学习实战项目概述

最近在完成一个基于大模型的强化学习(RL)实战项目，主要目标是构建一个能够自主学习的智能体(agent)，并在经典控制问题CartPole上进行训练和测试。这个项目涉及多种主流RL算法(DQN、PPO、SAC等)的实现与比较，特别关注如何将这些算法与大模型结合应用。

强化学习作为机器学习的重要分支，通过智能体与环境的交互学习最优策略。在CartPole这个经典问题中，智能体需要控制一个小车左右移动，以保持其上的杆子竖直不倒。虽然看似简单，但这个问题包含了RL的核心要素：状态空间、动作空间、奖励函数和策略学习。

2. 核心算法选择与比较

2.1 DQN算法实现

深度Q网络(DQN)是最早将深度学习与强化学习结合的算法之一。在项目中，我实现了以下关键组件：

1. 经验回放(Experience Replay)：存储智能体的经验(s,a,r,s')在回放缓冲区中，训练时随机采样打破数据相关性
2. 目标网络(Target Network)：使用独立的目标网络计算目标Q值，提高训练稳定性
3. ε-贪婪策略：平衡探索与利用，初始ε=1.0，线性衰减到0.1

class DQNAgent: def __init__(self, state_size, action_size): self.state_size = state_size self.action_size = action_size self.memory = deque(maxlen=2000) self.gamma = 0.95 # discount rate self.epsilon = 1.0 # exploration rate self.epsilon_min = 0.01 self.epsilon_decay = 0.995 self.learning_rate = 0.001 self.model = self._build_model() self.target_model = self._build_model() def _build_model(self): # Neural Net for Deep-Q learning Model model = Sequential() model.add(Dense(24, input_dim=self.state_size, activation='relu')) model.add(Dense(24, activation='relu')) model.add(Dense(self.action_size, activation='linear')) model.compile(loss='mse', optimizer=Adam(lr=self.learning_rate)) return model

注意事项：DQN对超参数非常敏感，特别是学习率和ε衰减率。建议从小学习率(如0.0001)开始尝试，观察训练曲线调整。

2.2 PPO算法实现

近端策略优化(PPO)是目前最流行的策略梯度算法之一，相比DQN有更好的样本效率和稳定性。关键实现点包括：

1. Clipped Surrogate Objective：限制策略更新幅度，防止训练不稳定
2. Generalized Advantage Estimation(GAE)：更高效地估计优势函数
3. 多步更新：每个episode收集一定步数数据后，进行多次小批量更新

class PPOTrainer: def __init__(self, policy, optimizer, clip_param=0.2): self.policy = policy self.optimizer = optimizer self.clip_param = clip_param def update(self, samples): states, actions, old_log_probs, returns, advantages = samples # 计算新策略的概率 dist = self.policy(states) new_log_probs = dist.log_prob(actions) # 概率比 ratio = (new_log_probs - old_log_probs).exp() # 裁剪目标函数 surr1 = ratio * advantages surr2 = torch.clamp(ratio, 1.0 - self.clip_param, 1.0 + self.clip_param) * advantages policy_loss = -torch.min(surr1, surr2).mean() # 价值函数损失 value_loss = (returns - self.policy.value(states)).pow(2).mean() # 总损失 loss = policy_loss + 0.5 * value_loss self.optimizer.zero_grad() loss.backward() self.optimizer.step()

实操心得：PPO的clip_param参数很关键，通常设置在0.1-0.3之间。训练初期可以使用较大值，后期逐渐减小。

2.3 SAC算法实现

Soft Actor-Critic(SAC)是一种基于最大熵的强化学习算法，相比PPO有更好的探索能力。核心特点包括：

1. 熵正则化：在奖励函数中加入策略熵，鼓励探索
2. 双Q网络：使用两个Q函数取最小值作为目标，减少过高估计
3. 自动调整温度参数：动态调整熵正则项的权重

class SACAgent: def __init__(self, state_dim, action_dim): self.actor = Actor(state_dim, action_dim) self.critic1 = Critic(state_dim, action_dim) self.critic2 = Critic(state_dim, action_dim) self.target_critic1 = Critic(state_dim, action_dim) self.target_critic2 = Critic(state_dim, action_dim) self.log_alpha = torch.zeros(1, requires_grad=True) self.alpha = self.log_alpha.exp() def update(self, batch): state, action, reward, next_state, done = batch # 计算目标Q值 with torch.no_grad(): next_action, log_prob = self.actor.sample(next_state) q1_next = self.target_critic1(next_state, next_action) q2_next = self.target_critic2(next_state, next_action) q_next = torch.min(q1_next, q2_next) - self.alpha * log_prob target_q = reward + (1 - done) * self.gamma * q_next # 更新Critic current_q1 = self.critic1(state, action) current_q2 = self.critic2(state, action) critic_loss = F.mse_loss(current_q1, target_q) + F.mse_loss(current_q2, target_q) # 更新Actor new_action, log_prob = self.actor.sample(state) q1_new = self.critic1(state, new_action) q2_new = self.critic2(state, new_action) q_new = torch.min(q1_new, q2_new) actor_loss = (self.alpha * log_prob - q_new).mean() # 更新alpha alpha_loss = -(self.log_alpha * (log_prob + self.target_entropy).detach()).mean() # 执行梯度下降 self.critic_optimizer.zero_grad() critic_loss.backward() self.critic_optimizer.step() self.actor_optimizer.zero_grad() actor_loss.backward() self.actor_optimizer.step() self.alpha_optimizer.zero_grad() alpha_loss.backward() self.alpha_optimizer.step()

常见问题：SAC训练初期可能表现不佳，因为熵正则化鼓励探索。建议设置合理的target_entropy值，通常为-action_dim/2。

3. 训练流程与参数调整

3.1 环境设置与预处理

CartPole环境的状态空间包含4个连续值：小车位置、小车速度、杆角度和杆角速度。预处理步骤包括：

1. 状态归一化：将各维度值缩放到[-1,1]范围
2. 帧堆叠：将连续几帧状态堆叠作为网络输入
3. 奖励塑形：调整原始奖励函数，如加入角度惩罚项

class NormalizedEnv(gym.Wrapper): def __init__(self, env): super().__init__(env) self.state_mean = np.zeros(env.observation_space.shape) self.state_std = np.ones(env.observation_space.shape) def step(self, action): state, reward, done, info = self.env.step(action) # 自定义奖励塑形 reward = 1.0 - abs(state[2])/0.2095 # 杆角度归一化奖励 return (state - self.state_mean) / self.state_std, reward, done, info

3.2 分阶段训练策略

根据训练进度动态调整参数可以显著提高效率：

1. 探索阶段(前20%训练步数)：

   • 设置较高的探索率(ε=1.0→0.5)
   • 使用较大的学习率(如3e-4)
   • 收集更多样化的经验

2. 开发阶段(中间60%训练步数)：

   • 逐步降低探索率(ε=0.5→0.1)
   • 减小学习率(如1e-4)
   • 开始微调策略

3. 微调阶段(最后20%训练步数)：

   • 最小化探索(ε=0.1→0.01)
   • 使用更小的学习率(如3e-5)
   • 专注于策略优化

3.3 监控与评估

建立完善的训练监控系统至关重要：

1. 训练指标：

   • 每episode的累计奖励
   • 策略熵(对SAC很重要)
   • 价值函数损失
   • 探索率变化

2. 评估策略：

   • 每1000步运行10次测试episode
   • 记录平均奖励和标准差
   • 保存最佳模型检查点

def evaluate(env, agent, n_episodes=10): total_rewards = [] for _ in range(n_episodes): state = env.reset() episode_reward = 0 done = False while not done: action = agent.select_action(state, eval_mode=True) state, reward, done, _ = env.step(action) episode_reward += reward total_rewards.append(episode_reward) return np.mean(total_rewards), np.std(total_rewards)

4. 大模型与RL的结合实践

4.1 使用预训练模型作为特征提取器

将大模型(如BERT、CLIP)作为状态编码器，提取高级特征：

1. 冻结大模型的底层参数
2. 仅训练顶层适配器网络
3. 将视觉或文本输入转换为紧凑表示

class VisualEncoder(nn.Module): def __init__(self, pretrained_model): super().__init__() self.backbone = pretrained_model # 冻结预训练参数 for param in self.backbone.parameters(): param.requires_grad = False self.projection = nn.Linear(pretrained_model.output_dim, 128) def forward(self, x): features = self.backbone(x) return F.relu(self.projection(features))

4.2 基于Prompt的RL策略

利用大模型的生成能力构建动态策略：

1. 将状态信息转换为自然语言描述
2. 使用LLM生成动作建议
3. 将建议转换为实际动作

def generate_action_prompt(state): cart_pos, cart_vel, pole_ang, pole_vel = state prompt = f"""CartPole控制建议： 当前状态： - 小车位置：{'左' if cart_pos < 0 else '右'} {abs(cart_pos):.2f}米 - 小车速度：{abs(cart_vel):.2f} 方向{'左' if cart_vel < 0 else '右'} - 杆角度：{abs(pole_ang):.2f}度 {'向左倒' if pole_ang < 0 else '向右倒'} - 杆角速度：{abs(pole_vel):.2f} {'加速倒下' if pole_vel*pole_ang > 0 else '减速倒下'} 建议采取的动作(左/右)：""" return prompt def llm_based_policy(state, llm): prompt = generate_action_prompt(state) response = llm.generate(prompt, max_length=10) action = 0 if "左" in response else 1 return action

4.3 多智能体RL协同训练

使用大模型协调多个智能体的行为：

1. 每个智能体独立学习基础技能
2. 大模型作为中央协调器
3. 通过自然语言指令分配任务

class MultiAgentController: def __init__(self, agents, llm): self.agents = agents # 多个专业智能体 self.llm = llm # 大语言模型协调器 def coordinate(self, state): # 生成任务分配指令 situation = self._describe_state(state) prompt = f"""当前环境状态：{situation} 请为以下专业智能体分配任务： 1. 平衡控制专家 2. 位置调节专家 3. 紧急恢复专家 最佳任务分配方案：""" plan = self.llm.generate(prompt) # 解析并执行计划 tasks = self._parse_plan(plan) actions = [] for agent, task in zip(self.agents, tasks): agent.set_task(task) actions.append(agent.act(state)) return self._fuse_actions(actions)

5. 实战问题排查与优化

5.1 常见训练问题及解决方案

5.2 超参数调优经验

基于数百次实验总结的关键参数范围：

1. 学习率：

   • DQN: 1e-5 ~ 1e-3
   • PPO: 3e-5 ~ 3e-4
   • SAC: 1e-4 ~ 1e-3 (critic可以比actor大)

2. 折扣因子γ：

   • CartPole这类episodic任务：0.95~0.99
   • 连续任务：0.99~0.999

3. 批次大小：

   • DQN: 32~128
   • PPO: 64~512
   • SAC: 256~1024

4. 网络结构：

   • 隐藏层：1~3层
   • 神经元数：32~256
   • 激活函数：ReLU/Tanh

5.3 高级优化技巧

1. 课程学习：从简单任务开始，逐步增加难度

   • 初始杆角度限制在±10°
   • 随训练进度逐步放宽到±30°

2. 集成学习：训练多个策略网络，选择最优动作

   • 并行训练3个DQN，投票决定动作
   • 减少单一网络的不确定性

3. 数据增强：对状态添加噪声，提高鲁棒性

   • 训练时添加高斯噪声(σ=0.1)
   • 测试时不使用噪声

class DataAugmentationWrapper: def __init__(self, env, noise_std=0.1): self.env = env self.noise_std = noise_std def step(self, action): state, reward, done, info = self.env.step(action) # 添加随机噪声 noisy_state = state + np.random.normal(0, self.noise_std, size=state.shape) return noisy_state, reward, done, info

在完成这个项目的过程中，我发现RL算法的性能很大程度上取决于参数调整和训练策略。对于CartPole这类相对简单的环境，DQN通常能在1000episode内达到不错的效果，而PPO和SAC则需要更精细的调参。将大模型引入RL系统确实能带来新的可能性，但也显著增加了计算成本和调试难度。建议初学者先从传统RL算法入手，掌握基本规律后再尝试与大模型结合。