强化学习实战：从DQN到PPO，用代码理解核心算法

想学强化学习，但一打开教程就被马尔可夫决策过程、贝尔曼方程、策略梯度这些术语劝退？看了半天理论，还是不知道怎么写第一行代码让智能体动起来？你不是一个人。

很多教程把强化学习讲成了一门数学课，却忽略了它本质上是一门“动手”的工程实践学科。本文的目标很明确：帮你绕开抽象理论的泥潭，直接抓住DQN、PPO、A3C这几个核心算法的工程骨架，用最直观的代码和比喻，让你在最短时间内建立起“能跑起来”的认知框架。我们不会陷入公式推导，而是聚焦于：这些算法到底解决了什么问题？它们的代码长什么样？你该如何修改它们来解决自己的任务？

读完本文，你将能清晰地回答：强化学习和监督学习有何本质不同？DQN为何要用两个网络？PPO中的“近端”到底在约束什么？A3C的“异步”优势在哪里？更重要的是，你将获得一套可以直接运行、修改的代码模板，开启你的第一个强化学习项目。

1. 强化学习：从“直觉”到“代码”的思维转换

在开始看任何算法之前，我们必须建立一个正确的思维模型。很多人学不会强化学习，是因为用错了“学习”的范式。

监督学习像是有一个无所不知的老师。你每做一道题（输入一张猫的图片），老师立刻告诉你标准答案（标签是“猫”）。你的目标是缩小你的答案和标准答案之间的差距。这是一个“模仿”和“拟合”的过程。

强化学习则像一个在陌生城市摸索的外卖员。没有地图，没有订单地址（至少开始时没有）。他唯一的反馈是：把餐送到后，顾客的满意程度（奖励）。他需要自己探索哪些路口可以走，哪些是死胡同，并逐渐总结出从餐厅到各小区的最快路径。这里没有“标准答案”，只有“好”与“更好”的策略。这是一个“试错”和“优化”的过程。

这个核心差异导致了强化学习独有的挑战：

1. 延迟奖励：一个错误的转弯可能几分钟后才导致超时差评，智能体需要能回溯并归因。
2. 探索与利用的权衡：是继续探索新小区以发现潜在捷径（探索），还是坚持走目前已知的最快路线（利用）？
3. 与环境的交互：智能体的每一个动作都会改变它所处的环境状态，从而影响后续的决策。

理解了这层“直觉”，我们再来看技术框架就清晰了。强化学习的核心交互闭环可以用下图表示，它描绘了智能体与环境持续对话的整个过程：

flowchart TD A[智能体 Agent] -->|执行动作 Action| B[环境 Environment] B -->|反馈新状态 State| A B -->|给予奖励 Reward| A subgraph 智能体学习循环 A --> C[观察状态<br>与奖励] C --> D[根据策略<br>选择动作] D --> A end subgraph 环境反馈循环 B --> E[状态转移] E --> F[计算奖励] F --> B end

这个循环持续进行，智能体的目标就是学习一个策略（Policy）——一个从状态映射到动作的函数——使得在整个交互过程中获得的**累计奖励（Return）**最大化。

接下来，我们将深入这个循环的内部，拆解构成这个框架的核心组件。

2. 核心组件拆解：智能体与环境的对话要素

要把直觉转化为代码，我们需要定义几个关键对象。它们就像剧本中的角色，共同演出了强化学习这出戏。

2.1 状态 (State)

环境当前情况的“快照”。在游戏中，可能是屏幕像素；在机器人控制中，可能是关节角度和速度。

• 代码表示：通常是一个数值向量、矩阵或张量（Tensor）。
• 示例：state = [x_position, y_position, velocity_x, velocity_y]

2.2 动作 (Action)

智能体可以做的事情。分为离散（如：上、下、左、右）和连续（如：方向盘转动角度-30°到+30°）。

• 代码表示：离散动作对应一个整数（如action = 2），连续动作对应一个浮点数或向量。
• 示例（离散）：action_space = [0, 1, 2, 3]分别代表上、下、左、右。

3.3 奖励 (Reward)

环境给智能体的即时反馈信号，是一个标量数值。设计一个好的奖励函数是强化学习项目的关键，甚至可以说是“玄学”。

• 正奖励：鼓励。如吃到金币+10。
• 负奖励：惩罚。如碰到敌人-10。
• 稀疏奖励：只在关键节点给予奖励（如围棋赢棋+1，输棋-1），这会使学习变得极其困难。

3.4 策略 (Policy)

智能体的“大脑”，一个函数π(a|s)，表示在状态s下选择动作a的概率。

• 确定性策略：a = μ(s)，状态直接映射到唯一动作。
• 随机性策略：输出动作的概率分布，如[上:0.7, 下:0.1, 左:0.1, 右:0.1]。探索就靠它。

3.5 价值函数 (Value Function)

评价一个状态或一个状态-动作对“有多好”的长期指标。

• 状态价值函数 V(s)：从状态s开始，遵循当前策略，预期能获得的总回报。
• 动作价值函数 Q(s, a)：在状态s下执行动作a，然后遵循当前策略，预期能获得的总回报。
• 核心思想：Q函数告诉我们哪个动作更有“钱”途，是许多算法的基石。

有了这些组件，智能体与环境的交互流程，就可以用如下代码框架来具象化：

# 伪代码：强化学习主循环框架 for episode in range(total_episodes): # 一场游戏/一个完整任务称为一个episode state = env.reset() # 环境初始化，获得初始状态 done = False # 标记任务是否结束 total_reward = 0 while not done: # 1. 智能体根据状态选择动作 action = agent.choose_action(state) # 2. 环境执行动作，返回反馈 next_state, reward, done, info = env.step(action) # 3. 智能体从经验中学习 (这是核心，不同算法在此不同) agent.learn(state, action, reward, next_state, done) # 4. 状态更新 state = next_state total_reward += reward print(f"Episode {episode}: Total Reward = {total_reward}")

这个框架适用于几乎所有的强化学习算法。不同算法的魔力，都隐藏在agent.learn()这个方法里。下面，我们就揭开经典算法的神秘面纱。

4. 经典算法实战：从Q-Learning到PPO

我们选择四条最具代表性的技术路线，它们分别代表了不同的思想演进。

4.1 基石：Q-Learning与SARSA (基于价值的算法)

这是理解深度强化学习的起点。它们的核心是学习一个完美的Q表格：行是所有状态，列是所有动作，表格内的值就是Q(s,a)。

核心思想：通过不断更新Q表格，让智能体学会估计在某个状态下，哪个动作能带来最大的长期回报。

更新公式（Q-Learning）：Q(s, a) = Q(s, a) + α * [r + γ * max(Q(s', a')) - Q(s, a)]

• α：学习率，控制更新幅度。
• γ：折扣因子，衡量未来奖励的当前价值（0.9表示看重近期，0.1表示非常短视）。
• max(Q(s', a'))：在下一个状态s'下，估计的最优动作价值。

SARSA vs Q-Learning：

• SARSA：更新时使用的是实际执行的下一个动作a'。它更“保守”，遵循已探索的策略。
• Q-Learning：更新时使用的是估计最优的下一个动作max(Q(s', a'))。它更“激进”，直接学习最优策略。

一个极简的Q-Learning代码示例（离散环境）：

import numpy as np # 假设环境有4个状态，2个动作 n_states = 4 n_actions = 2 q_table = np.zeros((n_states, n_actions)) # 超参数 learning_rate = 0.1 discount_factor = 0.99 epsilon = 0.1 # 探索概率 def choose_action(state): # epsilon-greedy策略：大部分时间利用，小部分时间探索 if np.random.uniform(0, 1) < epsilon: return np.random.choice(n_actions) # 探索：随机选动作 else: return np.argmax(q_table[state]) # 利用：选Q值最大的动作 def learn(state, action, reward, next_state): # Q-Learning更新公式 current_q = q_table[state, action] # 下一个状态的最大Q值 max_future_q = np.max(q_table[next_state]) # 目标Q值 target_q = reward + discount_factor * max_future_q # 更新当前Q值 q_table[state, action] = current_q + learning_rate * (target_q - current_q) # 在主循环中调用 learn 函数

Q-Learning的致命伤：状态和动作数量一旦巨大（比如Atari游戏的像素屏幕），Q表格就会大到内存无法容纳。这就是**深度Q网络（DQN）**要解决的问题。

4.2 第一次革命：深度Q网络 (DQN)

DQN用神经网络（称为Q网络）来代替巨大的Q表格。输入是状态（如图像），输出是每个动作对应的Q值。

DQN的核心创新与代码实现： DQN解决了两个让神经网络训练不稳定的关键问题：

1. 经验回放 (Experience Replay)：智能体的经验(s, a, r, s', done)被存储到一个“记忆库”中。学习时，随机从库中抽取一批（mini-batch）经验来训练。这打破了数据间的相关性，让训练更稳定。
2. 目标网络 (Target Network)：使用一个结构相同但更新缓慢的“目标网络”来计算max(Q(s', a'))。主网络每一步都更新，而目标网络每隔一定步数才用主网络的权重来更新。这固定了学习目标，避免了“追逐移动目标”的问题。

import torch import torch.nn as nn import torch.optim as optim import random from collections import deque 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 # 折扣因子 self.epsilon = 1.0 # 初始探索率 self.epsilon_min = 0.01 self.epsilon_decay = 0.995 self.learning_rate = 0.001 self.update_target_freq = 100 # 目标网络更新频率 # 主网络 self.model = self._build_model() # 目标网络 self.target_model = self._build_model() self.update_target_network() # 初始化时使权重一致 self.optimizer = optim.Adam(self.model.parameters(), lr=self.learning_rate) def _build_model(self): # 一个简单的全连接网络 model = nn.Sequential( nn.Linear(self.state_size, 24), nn.ReLU(), nn.Linear(24, 24), nn.ReLU(), nn.Linear(24, self.action_size) ) return model def update_target_network(self): # 将主网络的权重复制给目标网络 self.target_model.load_state_dict(self.model.state_dict()) def remember(self, state, action, reward, next_state, done): # 保存经验到记忆库 self.memory.append((state, action, reward, next_state, done)) def act(self, state): # epsilon-greedy 动作选择 if np.random.rand() <= self.epsilon: return random.randrange(self.action_size) state = torch.FloatTensor(state).unsqueeze(0) with torch.no_grad(): q_values = self.model(state) return torch.argmax(q_values).item() def replay(self, batch_size): if len(self.memory) < batch_size: return # 随机采样 minibatch = random.sample(self.memory, batch_size) for state, action, reward, next_state, done in minibatch: state = torch.FloatTensor(state).unsqueeze(0) next_state = torch.FloatTensor(next_state).unsqueeze(0) reward = torch.FloatTensor([reward]) # 计算当前Q值 current_q = self.model(state)[0][action] # 计算目标Q值 with torch.no_grad(): next_q = self.target_model(next_state).max() target_q = reward + (self.gamma * next_q * (1 - done)) # done为True时，没有未来奖励 # 计算损失 (MSE) loss = nn.MSELoss()(current_q, target_q) # 反向传播 self.optimizer.zero_grad() loss.backward() self.optimizer.step() # 衰减探索率 if self.epsilon > self.epsilon_min: self.epsilon *= self.epsilon_decay def step(self, state, action, reward, next_state, done): self.remember(state, action, reward, next_state, done) self.replay(32) # 每次交互后，用32个样本训练一次

DQN是深度强化学习的里程碑，但它本质仍是价值学习，其输出是动作的价值。对于连续动作空间（如需要输出一个精确的力或角度），Q-Learning系方法会变得非常低效。我们需要能直接输出动作概率分布的方法，这就是策略梯度。

4.3 直接优化策略：策略梯度 (Policy Gradient) 与 Actor-Critic

策略梯度方法直接参数化策略π(a|s; θ)，并通过梯度上升来优化参数θ，以最大化期望回报。

核心思想：如果某个动作序列带来了高回报，就增加这个序列中每个动作被选中的概率；反之则减少。

REINFORCE 算法（蒙特卡洛策略梯度）： 这是最简单的策略梯度算法。它要等到一个完整的episode结束，得到总回报G_t后，才对整个轨迹进行更新。

• 优点：无偏。
• 缺点：方差大，学习不稳定，且必须是回合制。

Actor-Critic 框架： 为了降低方差，引入了“评论家”（Critic）。它像一个裁判，评估演员（Actor）的表现。

• Actor (策略网络)：负责选择动作。输入状态，输出动作概率分布。
• Critic (价值网络)：负责评价状态或状态-动作对的好坏。输入状态，输出一个标量价值V(s)。
• 工作流程：Actor做出动作，环境给出奖励，Critic评估这个状态的价值。Actor根据Critic的评估（称为“优势函数”）来更新自己。优势函数A(s, a) = Q(s, a) - V(s)，衡量了在状态s下选择动作a比平均情况好多少。

Actor-Critic框架是PPO、A3C等现代算法的基石。它实现了单步更新，比REINFORCE更高效。

4.4 当前主流：近端策略优化 (PPO)

PPO是OpenAI默认的强化学习算法，因其在效果、实现复杂度和稳定性上的绝佳平衡而广受欢迎。

PPO要解决的核心问题：传统的策略梯度算法（如TRPO）在更新策略时，如果步长太大，新策略可能会急剧变差，导致训练崩溃。TRPO通过复杂的二阶优化来约束更新步长，计算成本高。

PPO的巧妙思路：用一个简单的裁剪（Clipping）函数来约束新旧策略的变化幅度，从而保证每次更新都是“近端”的、安全的。

关键概念：重要性采样比率r_t(θ) = π_θ(a_t | s_t) / π_θ_old(a_t | s_t)这个比率表示新策略相对于旧策略，选择同一个动作的概率变化。

PPO的裁剪目标函数（最常用形式）：

# 伪代码表示PPO损失计算核心 ratio = new_probs / old_probs # 重要性采样比率 surr1 = ratio * advantages # 传统的策略梯度目标 surr2 = torch.clamp(ratio, 1 - clip_epsilon, 1 + clip_epsilon) * advantages policy_loss = -torch.min(surr1, surr2).mean() # 取两者最小值，实现裁剪

• advantages：优势函数估计值，由Critic网络计算。
• clip_epsilon：一个超参数（如0.2），定义了裁剪的范围。

这个裁剪如何工作？

• 当advantages > 0（动作好），我们希望增加该动作的概率。但如果ratio太大（新策略选这个动作的概率远大于旧策略），surr2会被裁剪上限限制，防止更新过头。
• 当advantages < 0（动作差），我们希望减少该动作的概率。但如果ratio太小（新策略选这个动作的概率远小于旧策略），surr2会被裁剪下限限制，同样防止更新过头。

一个简化的PPO Actor-Critic网络结构示例：

import torch.nn as nn import torch.nn.functional as F class ActorCriticNetwork(nn.Module): def __init__(self, state_size, action_size): super(ActorCriticNetwork, self).__init__() # 共享的特征提取层 self.fc1 = nn.Linear(state_size, 128) self.fc2 = nn.Linear(128, 128) # Actor 头：输出动作概率分布 (均值) self.actor_mean = nn.Linear(128, action_size) # 对于连续动作，还需要一个标准差（可学习或固定） self.actor_logstd = nn.Parameter(torch.zeros(1, action_size)) # Critic 头：输出状态价值 V(s) self.critic = nn.Linear(128, 1) def forward(self, state): x = F.relu(self.fc1(state)) x = F.relu(self.fc2(x)) # Actor 输出 mean = self.actor_mean(x) log_std = self.actor_logstd.expand_as(mean) std = torch.exp(log_std) # Critic 输出 value = self.critic(x) return mean, std, value def act(self, state): # 用于交互时采样动作 mean, std, value = self.forward(state) normal_dist = torch.distributions.Normal(mean, std) action = normal_dist.sample() action_log_prob = normal_dist.log_prob(action).sum(-1) return action, action_log_prob, value

PPO的训练流程通常包含“收集数据-更新网络”的多个epoch，其伪代码如下：

# PPO 训练循环伪代码 for iteration in range(total_iterations): # 阶段1：用当前策略收集一批轨迹数据 states, actions, log_probs_old, rewards, dones, values = collect_trajectories(env, agent, num_steps) # 阶段2：计算优势函数估计和回报 advantages, returns = compute_gae_and_returns(rewards, values, dones, gamma, lambda) # 阶段3：用小批量数据对网络进行多次更新 (K个epoch) for epoch in range(K_epochs): # 随机打乱数据 indices = np.random.permutation(len(states)) # 小批量更新 for start in range(0, len(states), batch_size): batch_indices = indices[start:start+batch_size] batch_states = states[batch_indices] batch_actions = actions[batch_indices] batch_log_probs_old = log_probs_old[batch_indices] batch_advantages = advantages[batch_indices] batch_returns = returns[batch_indices] # 前向传播，计算新策略的动作概率和状态价值 mean, std, values_pred = agent(batch_states) dist = torch.distributions.Normal(mean, std) log_probs_new = dist.log_prob(batch_actions).sum(-1) entropy = dist.entropy().sum(-1).mean() # 熵，用于鼓励探索 # 计算重要性采样比率 ratio = torch.exp(log_probs_new - batch_log_probs_old) # PPO 裁剪目标函数 surr1 = ratio * batch_advantages surr2 = torch.clamp(ratio, 1.0 - clip_eps, 1.0 + clip_eps) * batch_advantages policy_loss = -torch.min(surr1, surr2).mean() # Critic 损失 (价值网络拟合回报) value_loss = F.mse_loss(values_pred.squeeze(), batch_returns) # 总损失 = 策略损失 + 价值损失系数 * 价值损失 - 熵系数 * 熵 (熵是加项，因为要最大化熵) loss = policy_loss + 0.5 * value_loss - 0.01 * entropy # 反向传播与优化 optimizer.zero_grad() loss.backward() torch.nn.utils.clip_grad_norm_(agent.parameters(), max_grad_norm) # 梯度裁剪 optimizer.step()

4.5 并行化探索：异步优势演员-评论家 (A3C)

在PPO之前，A3C因其高效的并行架构而风靡一时。其核心思想是异步。

A3C的工作原理：

1. 一个全局网络（参数服务器）。
2. 多个工作者（Worker）副本，每个副本拥有全局网络的本地拷贝，在独立的环境实例中运行。
3. 每个工作者独立地与环境交互若干步，计算梯度。
4. 工作者将计算出的梯度异步地推送到全局网络，并立即从全局网络拉取最新参数，继续交互。

A3C的优势：

• 数据多样性：多个工作者在不同环境状态下探索，打破了数据相关性，相当于一个动态的、分布式的经验回放。
• 训练加速：并行交互，大大提高了数据采集效率。
• 实现相对简单：比需要大内存经验回放的DQN更节省资源。

A3C的劣势：

• 策略不一致：工作者在推送梯度时，全局网络可能已被其他工作者更新，导致梯度基于过时的策略，产生一定噪声。
• 已被PPO等更稳定的算法超越：PPO通过同步采样、裁剪等机制，实现了更稳定、更高效的训练，成为当前主流。A3C更多是理解分布式RL的重要思想。

5. 环境搭建与第一个智能体实战 (以CartPole为例)

理论说了这么多，是时候动手了。我们选择OpenAI Gym（现为Gymnasium）中的经典控制问题CartPole-v1作为起点。目标是通过左右移动小车，保持杆子竖直不倒。

5.1 环境安装与介绍

# 安装核心环境库 (建议使用虚拟环境) pip install gymnasium pip install torch # 我们将使用PyTorch实现PPO

CartPole-v1环境：

• 状态 (State)：4维向量[车位置， 车速， 杆角度， 杆角速度]
• 动作 (Action)：离散，0（向左推），1（向右推）
• 奖励 (Reward)：每存活一步，+1。
• 终止条件：杆子倾斜角度超过±12°，或车位置超出±2.4，或步数超过500。

5.2 使用PPO算法训练CartPole智能体

我们将实现一个简化版的PPO。为了清晰，我们省略了GAE（广义优势估计）等高级技巧，专注于核心流程。

步骤1：定义网络结构 (Actor-Critic共享部分底层)

import gymnasium as gym import torch import torch.nn as nn import torch.optim as optim from torch.distributions import Categorical import numpy as np class ActorCritic(nn.Module): def __init__(self, state_dim, action_dim): super(ActorCritic, self).__init__() # 共享特征层 self.fc_shared = nn.Sequential( nn.Linear(state_dim, 64), nn.Tanh(), nn.Linear(64, 64), nn.Tanh(), ) # Actor 层：输出动作概率 self.fc_actor = nn.Linear(64, action_dim) # Critic 层：输出状态价值 self.fc_critic = nn.Linear(64, 1) def forward(self, state): shared_feat = self.fc_shared(state) action_probs = torch.softmax(self.fc_actor(shared_feat), dim=-1) state_value = self.fc_critic(shared_feat) return action_probs, state_value def act(self, state): state = torch.FloatTensor(state).unsqueeze(0) with torch.no_grad(): action_probs, state_value = self.forward(state) dist = Categorical(action_probs) action = dist.sample() action_log_prob = dist.log_prob(action) return action.item(), action_log_prob.item(), state_value.item()

步骤2：实现PPO主训练循环

def train_ppo(env_name="CartPole-v1", max_episodes=1000, gamma=0.99, clip_eps=0.2, update_epochs=4, lr=3e-4): env = gym.make(env_name) state_dim = env.observation_space.shape[0] action_dim = env.action_space.n policy = ActorCritic(state_dim, action_dim) optimizer = optim.Adam(policy.parameters(), lr=lr) episode_rewards = [] for episode in range(max_episodes): state, _ = env.reset() episode_reward = 0 states, actions, log_probs, rewards, dones, values = [], [], [], [], [], [] # 收集一条轨迹的数据 while True: action, log_prob, value = policy.act(state) next_state, reward, terminated, truncated, _ = env.step(action) done = terminated or truncated states.append(state) actions.append(action) log_probs.append(log_prob) rewards.append(reward) dones.append(done) values.append(value) state = next_state episode_reward += reward if done: episode_rewards.append(episode_reward) # 打印进度 if (episode + 1) % 50 == 0: avg_reward = np.mean(episode_rewards[-50:]) print(f"Episode {episode+1}, Avg Reward (last 50): {avg_reward:.2f}") break # --- PPO 更新阶段 --- # 计算回报和优势 (这里使用简单的蒙特卡洛回报，未用GAE) returns = [] R = 0 for r, done in zip(reversed(rewards), reversed(dones)): R = r + gamma * R * (not done) returns.insert(0, R) returns = torch.FloatTensor(returns) values = torch.FloatTensor(values) advantages = returns - values # 简单优势估计 # 将列表转换为Tensor states = torch.FloatTensor(np.array(states)) actions = torch.LongTensor(actions) old_log_probs = torch.FloatTensor(log_probs) # 更新多个epoch for _ in range(update_epochs): # 重新计算新策略下的动作概率和价值 action_probs, state_values = policy(states) dist = Categorical(action_probs) new_log_probs = dist.log_prob(actions) entropy = dist.entropy().mean() # 重要性采样比率 ratio = torch.exp(new_log_probs - old_log_probs) # PPO 裁剪目标 surr1 = ratio * advantages surr2 = torch.clamp(ratio, 1.0 - clip_eps, 1.0 + clip_eps) * advantages policy_loss = -torch.min(surr1, surr2).mean() # Critic 损失 value_loss = nn.MSELoss()(state_values.squeeze(), returns) # 总损失 loss = policy_loss + 0.5 * value_loss - 0.01 * entropy # 优化 optimizer.zero_grad() loss.backward() torch.nn.utils.clip_grad_norm_(policy.parameters(), max_norm=0.5) optimizer.step() env.close() return episode_rewards if __name__ == "__main__": rewards = train_ppo() # 你可以绘制 rewards 来看学习曲线

步骤3：运行与观察运行上述代码，你会看到控制台输出每50个episode的平均奖励。一个成功的训练，平均奖励会逐渐上升并稳定在接近500（最高分）。这意味着你的智能体已经学会了平衡杆子。

6. 常见问题与调试指南 (FAQ)

强化学习训练就像调教一只不听话的宠物，失败是常态。以下是新手最常遇到的坑和排查思路。

7. 工程最佳实践与进阶方向

当你跑通第一个例子后，想要解决更复杂的问题，以下实践能让你少走弯路。

7.1 最佳实践清单

• 从简单环境开始：务必在CartPole,Pendulum等经典环境验证算法实现无误，再迁移到复杂环境。
• 监控一切：不仅要看总奖励，还要记录策略熵、价值损失、梯度范数、重要性采样比率均值等，TensorBoard是你的好朋友。
• 超参数调优：学习率、折扣因子、裁剪范围、熵系数对PPO性能影响巨大。使用网格搜索或随机搜索，但每次只改变一个变量。
• 固定随机种子：在实验开始时固定np.random.seed(),torch.manual_seed(),env.seed()，确保结果可复现。
• 版本控制：代码、环境、依赖库版本都要记录。强化学习对版本极其敏感。
• 奖励缩放与归一化：对输入状态和奖励进行归一化（如减均值除标准差），能极大稳定训练。

7.2 下一步学什么？

1. 更高级的算法：
   • SAC (Soft Actor-Critic)：最大熵RL的典范，在连续控制任务中表现卓越，探索能力极强。
   • TD3 (Twin Delayed DDPG)：DDPG的改进版，通过“双Q网络”和“延迟更新”解决Q值过估计问题。
   • IMPALA / SEED：大规模分布式RL的工业级框架。
2. 关键技巧：
   • GAE (Generalized Advantage Estimation)：更高效、更低方差地估计优势函数，PPO的黄金搭档。
   • PPO-Clip 与 PPO-Penalty：了解PPO的另一种形式（用KL散度惩罚）。
   • 好奇心驱动探索：为智能体添加内在好奇心，解决稀疏奖励问题。
3. 转向应用：
   • 多智能体强化学习 (MARL)：研究智能体间的合作与竞争，如《星际争霸》、《DOTA》。
   • 机器人控制：在MuJoCo、PyBullet等物理仿真环境中训练机器人行走、抓取。
   • 资源调度与优化：将RL应用于芯片设计、物流调度、网络资源分配。

强化学习是一个在试错中前进的领域。最大的秘诀不是记住所有公式，而是动手实现，观察现象，大胆假设，小心验证。从修改CartPole的奖励函数开始，到训练一个玩《超级马里奥》的智能体，每一步突破带来的成就感，正是这个领域最迷人的地方。