HelloAgents实战：从零搭建DQN强化学习训练流程

想上手强化学习的人，十有八九会卡在同一个地方：教程里的公式都认识，代码也能照抄，但真要自己训练一个智能体，让它从“乱动”变成“会做决策”，中间那几百个回合到底发生了什么，完全没人跟你讲清楚。我之前就被这个问题折磨了很久，后来把整个流程重新捋了一遍，用一套叫 HelloAgents 的最小实战项目，把环境配置、奖励设计、模型搭建、训练调参这条路完整跑通了。这篇就把这个过程原原本本拆给你看，面向刚入门的小白，也适合想快速落地一个训练Demo的程序员，跟着操作就能拿到一个能稳定训练出智能体的小项目。

1. 项目概述：HelloAgents 到底在做一件什么事

1.1 一个最小但完整的强化学习闭环

HelloAgents 不是我发明的某个框架，而是我给这套训练智能体的实战Demo起的代号。它的核心目标不是炫技，而是用最短的代码，把强化学习中“环境交互 → 策略决策 → 奖励反馈 → 参数更新”这条链路完整跑起来。很多人觉得强化学习难，是因为概念太多：状态、动作、奖励、价值函数、策略、经验回放……一旦概念之间没有通过代码串联，就会变成一团浆糊。

这个项目选的入门任务是经典倒立摆问题，CartPole。环境里有一根竖在推车上的杆子，智能体的动作只有两个：往左推或者往右推。每坚持一个时间步不倒，就获得1分，杆子倒了一定角度或者滑出边界就算失败。任务非常直观，状态只有四个数字，动作只有两条路，特别适合第一只“宠物”智能体。

解决的核心问题是：怎么从完全不会，利用试错一步步学会“保持平衡”这个决策技能。适合的人群也很清晰：有Python基础但没系统练过强化学习的程序员，正在做课程设计想快速出结果的同学，以及想搞懂DQN内部原理而不是只会调用接口的人。HelloAgents 的完整流程，就是你们最需要的那块敲门砖。

1.2 为什么选择“先跑通，再深挖”的路线

我见过很多学习路线，上来就要求刷完所有理论，或者直接用高级开源库跑一个大型游戏。这两种方式都不是最适合初学者的。理论先行的最大问题是：你背了一堆贝尔曼方程，但不知道训练崩溃时该改哪里；直接用高级库则相反，你写出了三行代码训练成功，但仍然不知道为什么成功，出了问题更是无从下手。

HelloAgents 采用的是折中方案：算法流程自己写，环境接口用现成的。也就是说，不重复造环境的轮子，但训练循环、经验回放、目标网络、探索策略这些核心逻辑全部手写。这样代码量不大，却保留了完整的“可调试性”。我可以在每一行关键逻辑处打断点，看奖励怎么回流、Q值怎么变化，这种掌控感是用黑盒框架完全体会不到的。

从成本上看，这套方案只需要一个CPU机器就能跑，单次训练只要几分钟到十几分钟，非常适合反复试错。等你跑通了DQN，再去看PPO、A2C这些算法，会发现很多概念是相通的，后面对复杂框架的理解会轻松很多。

2. 环境准备与工具选型：先把地基打稳

2.1 技术栈和版本建议

工欲善其事，必先利其器。选型时我优先考虑三点：上手难度低、调试方便、社区资料多。最终选定的组合是 Python + 一个主流的开源深度强化学习环境库 + 一个主流的深度学习框架。

• Python 3.10 或 3.11，不要用太老的版本，很多新库已经放弃旧版支持。
• 环境交互库用 Gymnasium 1.x，它就是以前那个经典环境库的维护分支，CartPole、Atari、Mujoco 这些标准测试环境都包含在内。
• 深度学习框架，我选的是 PyTorch，因为它的动态图和Python风格高度一致，打印张量形状、断点调试都非常顺手。
• 辅助库只需要 NumPy 和 Matplotlib，一个做数据处理，一个画训练曲线。

为什么不选 TensorFlow？也不是不行，但它的计算图风格在调试体验上相对绕一点，尤其是对需要频繁修改网络结构的学习阶段，PyTorch 会更直接。为什么不直接用一个现成的增强学习算法库？因为它的调用方式高度封装，你只能看到“传入环境，得到训练好的模型”，中间过程完全黑盒。对实战学习来说，亲手写一次训练循环的价值，比用十个库都要大。

2.2 虚拟环境创建和安装步骤

永远不要在全局Python环境里直接装依赖，这是我在各种项目里踩过无数次坑换来的教训。不同项目对库版本要求不同，用虚拟环境可以彻底隔离。第一步，用 conda 创建一个干净的虚拟环境：

conda create -n helloagents python=3.11 conda activate helloagents

第二步，安装依赖：

pip install gymnasium torch numpy matplotlib

安装完成后，强烈建议先做一个环境自检，确认环境库能正常创建和交互：

python -c "import gymnasium as gym; env = gym.make('CartPole-v1'); print(env.observation_space); print(env.action_space); state = env.reset(); print(state)"

如果输出类似Box([-4.8 ...], (4,), float32)和Discrete(2)，说明环境一切正常。这一步只花几秒钟，但能帮你过滤掉大量“装了库但版本不兼容”的后续问题。

2.3 训练资源怎么规划：CPU其实够用

很多初学者第一反应是“训练智能体总得需要一张好显卡吧”，其实分情况。像 CartPole 这种状态维度只有4、动作只有2的小任务，模型是一个很小的全连接网络，一分钟在CPU上就能跑几千步交互，完全不需要GPU。

我给过朋友的建议配置是：4核CPU，8GB内存，就能非常流畅地跑完HelloAgents全部训练流程。如果后续你想挑战图像输入的任务，比如Atari游戏，或者连续控制任务，比如机械臂，那才需要认真考虑GPU。到那时候，你的重心也不应该是“我有多少张卡”，而是怎么把单步交互耗时降下来，因为强化学习里每一步都要同时经历环境模拟、推理、存储和训练，瓶颈往往在数据管线上，而不只是计算设备。

2.4 项目目录结构设计：一开始就分层

一个常见的反面教材是所有人把代码堆在一个main.py里，跑通后想加功能简直是一场灾难。HelloAgents 的项目结构从第一天就按职责分层：

helloagents/ ├── envs/ │ └── make_env.py # 环境创建与配置 ├── models/ │ └── q_network.py # 神经网络定义 ├── agents/ │ └── dqn_agent.py # 智能体逻辑：探索、更新、同步 ├── trainers/ │ └── train_cartpole.py # 训练主循环 ├── utils/ │ ├── buffer.py # 经验回放缓冲区 │ └── logger.py # 日志记录 └── config.py # 所有超参数集中管理

我自己的体会是：环境放在一个文件里，后续换成其他任务时只动envs目录；模型放在一个文件里，想从全连接网络换成卷积网络时只改models；训练循环放在trainers里，实验逻辑和业务模块分离。这样任何一个环节出问题，定位范围都能缩到很小，调试效率会高出非常多。

3. 环境与奖励设计：训练前最值得花心思的地方

3.1 为什么要先用内置环境，而不是自己写环境

很多人在入门时犯的一个错误，是觉得“CartPole太简单、没意思”，一上来就自定义一个复杂的寻路任务或者游戏环境。结果整天被环境代码的Bug折磨，真假奖励混在一起，智能体学不会也分不清是自己的策略问题还是环境问题。写环境本身是一个高级技能，不应该在入门阶段同时叠加两个难点。

所以 HelloAgents 第一阶段就用 Gymnasium 自带的 CartPole-v1。这个环境经过无数项目验证，接口稳定，奖励逻辑明确，你不需要怀疑“是不是环境本身有Bug”。等整个训练流程都跑通了，再去写自己的环境，那时候你已经知道怎么判断问题归属，才能高效排查。

3.2 观察空间和动作空间：其实就是在跟环境谈判

每次env.reset()和env.step(action)返回的数据，是智能体唯一能利用的信息。理解观察和动作空间，等于搞清楚智能体“能看到什么”和“能做什么”。CartPole 的观察空间是一个长度为4的向量：

• 小车位置
• 小车速度
• 杆子角度
• 杆子角速度

动作空间是Discrete(2)，也就是两个离散值：0代表向左推，1代表向右推。把这两个空间打印出来，可以直观看到：

import gymnasium as gym env = gym.make("CartPole-v1") print("观察空间:", env.observation_space) print("动作空间:", env.action_space)

输出大概是：

观察空间: Box([-4.8...], [4.8...], (4,), float32) 动作空间: Discrete(2)

这里 Box 表示连续向量空间，Discrete 表示有限离散动作集合。对智能体来说，观察就是“眼睛”，动作就是“手”。后续无论换什么任务，第一件事永远是搞清楚这两个空间的形状和取值范围，因为神经网络输入输出层的维度都依赖它们。

3.3 奖励塑形：给智能体设立明确的“好/坏”信号

CartPole 的默认奖励非常稀疏但足够有效：每坚持一个时间步，奖励 +1；倒下，回合结束。这个设计让智能体只需要最大化累积回报，就能学到“保持平衡”这个行为。对入门来说，先用默认奖励跑通流程，不要一开始就魔改奖励。

但真实问题往往是稀疏奖励难学的，比如一个导航任务，地图上只有到达终点才有 +1，其他步骤全是0，智能体很难在成千上万次尝试中偶然撞到终点。这时就需要做奖励塑形，也就是给中间过程增加辅助反馈。比如走迷宫时，可以按“到终点的距离”给一个负奖励，越靠近终点奖励越大；但要注意，奖励塑形是把双刃剑。

一个常见坑是奖励值设得太大，把原始目标信号淹没了。比如你会习惯性地给“前进一小步” +0.5，给“到终点” +10，结果智能体发现原地来回试探也能累计一堆小奖励，反而忽略了真正的目标。奖励塑形要遵循一个原则：辅助奖励只能引导，不能替代原始目标。为了看效果，可以给CartPole加一个“杆子越正奖励越高”的密集奖励版本对比一下：

def custom_reward(obs): # obs: [x, x_dot, theta, theta_dot] angle_penalty = abs(obs[2]) # 角度越接近0越好 return 1.0 - angle_penalty * 2.0

这种改写会让奖励更密集，但你会发现训练结果反而不一定比默认奖励更稳，因为智能体可能学会“以极小幅度来回摆”来维持一个不错的局部角度，而不是真正平衡。所以，不要觉得奖励越复杂越好，能用简单奖励完成的任务，就别给自己挖坑。

3.4 终止和截断：两个新手最容易忽略的概念

新版环境接口里，env.step()返回的不再是简单的state, reward, done，而是五个值：next_state, reward, terminated, truncated, info。很多初学代码还抱着旧的done概念，直接把terminated or truncated当作结束，这在大部分情况下能跑，但涉及价值计算时会有隐患。

terminated表示“这个回合真正完结了”：杆子倒了、游戏输了，这是一个符合任务逻辑的结束。truncated表示“这个回合被截断了”：不是智能体的失败，而是达到了步数上限、或者人为干预了。两者性质不同，在计算目标值时要区分对待：只有terminated才意味着未来没有后续回报，truncated后面理论上还能继续。

我用一个例子解释：假设打折因子 gamma 是0.99，在某个状态执行动作后，如果terminated=True，那么目标值就是当前奖励；如果只是truncated=True，目标值应该是当前奖励加上下一个状态的价值估计乘以0.99。如果混为一谈，会让价值函数的学习信号出现系统性偏差，训练曲线看起来一直不安定。

4. 智能体模型与算法选型：别一上来就追新

4.1 DQN还是PPO：怎么选最合理

现在强化学习算法多如牛毛，初学者最容易陷入“选哪个”的纠结。我的建议是：第一仗打最容易的。下面这张表可以帮你快速理解常见选择逻辑：

HelloAgents 选用DQN，原因是 CartPole 动作空间只有两个离散动作，DQN 的公式直观、调试简单；同时DQN是深度强化学习的奠基算法之一，后续理解 Double DQN、Dueling DQN 都会轻松很多。并不是说PPO不好，PPO在机器人控制里确实很主流，但它需要处理的细节更多，不适合作为第一个手写算法。

4.2 神经网络搭建：别一上来就堆层

DQN 的本质是用一个神经网络去拟合动作价值函数 Q(s,a)，也就是“在状态s下做动作a，未来预期能拿到多少累积奖励”。网络结构不需要复杂，一个简单的多层感知机就够了：

import torch import torch.nn as nn class QNetwork(nn.Module): def __init__(self, state_dim, action_dim, hidden_dim=64): super().__init__() self.net = nn.Sequential( nn.Linear(state_dim, hidden_dim), nn.ReLU(), nn.Linear(hidden_dim, hidden_dim), nn.ReLU(), nn.Linear(hidden_dim, action_dim) ) def forward(self, state): return self.net(state)

很多人喜欢堆几个 512 甚至 1024 维的隐藏层，觉得参数越多越强。其实在状态只有4维的小任务里，这是完全没必要的。更大的网络意味着需要更多样本来拟合，也更容易过拟合。何谓过拟合？智能体把“当前的训练环境”背下来了，换个初始状态就抓瞎。我实测下来，64×64 的全连接网络在 CartPole 上已经绰绰有余，训练速度快，效果稳定。

特别注意：输出层不要加 softmax。Q值是一个实数值，代表的是“期望的回报大小”，不是一个概率分布。加了 softmax 之后，不仅破坏了输出尺度，还会让你的梯度更新完全变味。

4.3 经验回放和目标网络：DQN稳定训练的两个保险丝

原始Q学习的一个致命问题是：连续交互的数据高度相关，前一步刚把杆子往左推，下一步的状态和这一步几乎一模一样，如果直接用这些连续样本来更新网络，参数会在某个局部区域反复震荡，学不快也学不稳。经验回放就是来解决这个问题的——像学生做错题集，先把大量交互样本存进一个缓冲区，训练时随机抽取一小批，打破样本间的时间相关性。

目标网络是第二个保险丝。训练过程中，我们的标签值（目标Q值）也来自同一个网络，这就像“自己出题自己改卷”，标准一直在动，网络很难收敛。所以DQN会维护一份“定期更新”的参数副本，用它来生成目标Q值。更新主网络几百步后，再把主网络的参数复制给目标网络。这样标签值在短期内是固定的，学习信号相对稳定。

简单实现一个经验回放缓冲区：

from collections import deque import random class ReplayBuffer: def __init__(self, capacity): self.buffer = deque(maxlen=capacity) def push(self, state, action, reward, next_state, terminated, truncated): self.buffer.append((state, action, reward, next_state, terminated, truncated)) def sample(self, batch_size): batch = random.sample(self.buffer, batch_size) states, actions, rewards, next_states, terminateds, truncateds = zip(*batch) return ( torch.FloatTensor(states), torch.LongTensor(actions).unsqueeze(1), torch.FloatTensor(rewards).unsqueeze(1), torch.FloatTensor(next_states), torch.FloatTensor(terminateds).unsqueeze(1), torch.FloatTensor(truncateds).unsqueeze(1), )

缓冲区大小也有讲究。太小，随机采样还是会采样到强相关数据；太大，旧的过时样本会占太多比例，智能体都学新策略了，还在用远古数据更新，效率一样低。

4.4 超参数初值推荐：先照抄，再调优

初学者调参最容易焦虑，怕设错了学不会。其实不用怕，业界积累了很多默认值，照抄就能拿到不错结果。HelloAgents 的初值如下：

这些初值不是金科玉律，但它们来自大量实验的“经验中位数”。我的习惯是：先原封不动跑通，拿到一个正常上升的曲线，再每次只调一个参数，观察效果。千万不要一次改三个参数，否则出了问题根本无法定位是谁的锅。

5. 完整训练流程与代码落地：从初始化到模型保存

5.1 初始化：固定随机种子才是第一件正事

强化学习充满随机性：环境初始状态随机、动作探索随机、网络参数随机。如果不固定随机种子，你这次训练成功，下次重跑可能彻底失败，既无法判断算法好坏，也无法和别人对比结果。所以 HelloAgents 在主程序里第一件事就是固定种子。

import random import numpy as np import torch def set_seed(seed=42): random.seed(seed) np.random.seed(seed) torch.manual_seed(seed) set_seed(42)

接下来初始化环境、网络、目标网络、优化器和缓冲区。注意这里只有一个主网络和一个目标网络，它们结构必须完全一致。初始化时让目标网络直接复制主网络参数。

from models.q_network import QNetwork from utils.buffer import ReplayBuffer import gymnasium as gym env = gym.make("CartPole-v1", render_mode=None) state_dim = env.observation_space.shape[0] action_dim = env.action_space.n q_net = QNetwork(state_dim, action_dim) target_net = QNetwork(state_dim, action_dim) target_net.load_state_dict(q_net.state_dict()) optimizer = torch.optim.Adam(q_net.parameters(), lr=1e-3) buffer = ReplayBuffer(capacity=50000) epsilon = 1.0 epsilon_min = 0.01 epsilon_decay = 0.995 gamma = 0.99 batch_size = 64 target_update_freq = 100 train_freq = 4 total_timesteps = 20000 log_freq = 1000

这些变量全部在config.py里更好，我在这里直接写成常量是为了演示清晰，但实际项目启动时建议从配置读取。

5.2 主训练循环：每一行代码都在干什么

训练主循环是整个项目的灵魂，我会拆开每一步解释，而不是只贴一段代码让你跑完就算。

global_step = 0 episode_reward = 0 state, _ = env.reset() state = state.astype(np.float32) episode = 0 episode_rewards = [] while global_step < total_timesteps: # 1. epsilon-greedy 探索与利用 if random.random() < epsilon: action = env.action_space.sample() else: with torch.no_grad(): q_values = q_net(torch.FloatTensor(state).unsqueeze(0)) action = q_values.argmax().item() # 2. 与环境交互 next_state, reward, terminated, truncated, info = env.step(action) next_state = next_state.astype(np.float32) # 3. 存入经验回放 buffer.push(state, action, reward, next_state, terminated, truncated) state = next_state episode_reward += reward global_step += 1 # 4. 隔一定步数做一次训练 if global_step % train_freq == 0 and len(buffer.buffer) >= batch_size: states, actions, rewards, next_states, terminateds, truncateds = buffer.sample(batch_size) with torch.no_grad(): next_q = target_net(next_states).max(1, keepdim=True).values target = rewards + gamma * (1 - terminateds) * next_q current_q = q_net(states).gather(1, actions) loss = torch.nn.functional.mse_loss(current_q, target) optimizer.zero_grad() loss.backward() optimizer.step() # 5. 定期同步目标网络 if global_step % target_update_freq == 0: target_net.load_state_dict(q_net.state_dict()) # 6. epsilon 衰减 if epsilon > epsilon_min: epsilon *= epsilon_decay # 7. 回合结束处理 if terminated or truncated: episode_rewards.append(episode_reward) episode += 1 if episode % 20 == 0: print(f"Episode {episode}, reward: {episode_reward:.1f}") state, _ = env.reset() state = state.astype(np.float32) episode_reward = 0

请注意第4步里的(1 - terminateds)，这一步就是处理前面说的终止和截断问题。只有真正结束terminated时，未来价值才归零；如果是truncated，我们仍保留下一步的价值估计。如果这里写成了(1 - done)且done是两者合并，就会导致截断回合学出错误的目标值。

5.3 评估与日志：不要只看训练过程中的奖励

很多人直接用“训练时每个回合的奖励”判断模型好坏，这是有误导性的。因为训练过程中有探索噪声，epsilon还在随机乱试，单回合奖励忽高忽低很正常。真正能反映智能体水平的是评估阶段的成绩，也就是关掉探索，用纯贪婪策略连续跑若干个回合，取平均奖励。

HelloAgents 的评估逻辑可以独立成一个函数：

def evaluate(env_name, q_net, episodes=10): eval_env = gym.make(env_name) rewards = [] for _ in range(episodes): state, _ = eval_env.reset() state = state.astype(np.float32) total = 0.0 done = False while not done: with torch.no_grad(): q_values = q_net(torch.FloatTensor(state).unsqueeze(0)) action = q_values.argmax().item() state, reward, terminated, truncated, _ = eval_env.step(action) state = state.astype(np.float32) total += reward done = terminated or truncated rewards.append(total) return float(np.mean(rewards))

最开始模型是随机策略，平均奖励可能只有十几；训练到中后期，你会发现评估平均奖励能冲到200甚至500。CartPole-v1 的回合上限是500步，所以到达500就代表环境截断，任务已经解决。把评估平均奖励和训练loss一起记录，能帮你更准确地判断什么时候可以停止训练。

5.4 模型保存与恢复：可复现实验的最后一环

训练出一个好模型只完成一半，另一半是把它好好存下来，并能在之后重新加载使用。我推荐保存完整的状态字典，而不只是模型参数：

torch.save({ "model": q_net.state_dict(), "optimizer": optimizer.state_dict(), "epsilon": epsilon, "global_step": global_step, }, "checkpoint.pth")

恢复训练时，不要忘了目标网络也要同步加载：

checkpoint = torch.load("checkpoint.pth", weights_only=True) q_net.load_state_dict(checkpoint["model"]) target_net.load_state_dict(checkpoint["model"]) optimizer.load_state_dict(checkpoint["optimizer"])

这里有一个常见的坑：恢复训练后，如果目标网络没有同步加载，或者优化器的学习率变了，会导致训练曲线出现一个明显的断裂点。另外，做推理评估时记得把网络切到eval()模式，虽然全连接网络没有Dropout和BatchNorm的影响，但养成习惯总是好的。

5.5 训练现场怎么看：哪些信号代表正常

能看懂训练曲线，才算真正入门。我第一次训练时对着一条剧烈震荡的loss曲线紧张了半天，后来才知道这在DQN训练里其实很正常。以下几个信号供你参考：

• Loss曲线整体震荡下行，说明预测Q值在逐步逼近目标Q值，正常。
• 训练回合平均奖励持续上升，说明策略在变好。
• 评估平均奖励呈阶梯式上涨，而不是直线拉升，说明智能体在学习，只是过程中会经历瓶颈。
• 如果你打印了Q值的均值，发现它突然涨到几千甚至几万，那一定有问题，多半是奖励尺度或者学习率设置不合理。

6. 常见问题与排查技巧实录

6.1 智能体完全学不会：按顺序排查这五个方向

如果你的智能体训练了几千步，评估平均奖励还在二十以下，不要慌。按这个顺序排查，大部分问题都能找到：

第一，检查奖励信号。如果奖励大部分时间都是零，智能体就得不到学习信号。可以把奖励值打印出来看分布，确认正负样本比例。第二，检查观察值尺度。CartPole的观察值范围不大，但很多自定义环境里的状态值可能跨几个数量级，比如位置是几百、速度是零点几，这对神经网络非常不友好，需要做归一化。第三，检查终止和截断是否用错。第四，检查探索率是否衰减太快，如果几百步后 epsilon 就变成了0，智能体可能过早停止探索，永远找不到最优路径。第五，检查loss是否出现NaN，如果出现，基本是学习率太大或者数据里有异常值。

我一直用一个排查口诀：先看奖励有没有信号，再看数据有没有归一化，然后看状态结束对不对，接着看探索还剩多少，最后看Loss是不是正常。

6.2 训练曲线大幅振荡或发散，怎么处理

训练中曲线有波动是正常的，但如果波动幅度夸张，甚至奖励越学越差，就说明参数更新出问题了。最常见原因是学习率太高。我自己就踩过一次坑：想把训练加速，把学习率从1e-3调到5e-3，结果几千步之后Q值突然爆掉，loss变成天文数字，整个模型报废。

遇到发散，第一选择不是改算法，而是调小学习率，比如降到3e-4，看看曲线是否趋于平稳。其次检查奖励尺度，如果奖励值范围在[-100, 100]，可以考虑做一次缩放，把它压到[-1, 1]，这会显著提高稳定性。还有一个技巧是增加目标网络同步间隔，比如从100改成200，让目标值变化更慢，也能缓解震荡。最后，固定随机种子定期重跑，很多偶发发散可能只是随机性太大，换一组种子可能就好了。

6.3 训练慢到怀疑人生：先优化数据管线

训练太慢往往不是因为显卡不够好，而是整个循环里每一步的Python开销太大。CartPole本身非常轻量，深度学习网络又小，如果你觉得慢，可以从这几个方面优化：

第一，不要在每个步骤都执行一次网络更新。HelloAgents里设置的训练频率是每4步一次，已经能显著减少开销。第二，确认日志打印和评估不要太频繁。有人每10步就打印一次，每50步就启动一次评估，评估会额外跑很多回合，这些时间全在空转。第三，如果用的是GPU，小网络在GPU上的推理延迟反而可能比CPU更高，因为数据在内存和设备之间拷贝也要时间。第四，尽量用批量交互而不是单步循环，比如用多个环境并行采样，但这属于进阶技巧，CartPole阶段不用急着上。

6.4 智能体每个动作都一样，训练彻底僵住

如果你的智能体从某个时刻起，输出永远是指向同一个动作，像一个偏执狂一样不停向左推，那多半是探索机制失效了。最常见的原因是 epsilon 衰减速度太快，比如每回合衰减0.9，几十个回合后探索率就快归零了。智能体早期学到一点点偏好，从此固步自封，再也接触不到其他动作可能带来的收益。

另一个可能是动作值和Q值在某个状态上出现偏差，网络陷入了一个错误的局部最优。这时候如果把 epsilon 临时调回一个较大的值，比如手动设置为0.3，强制让智能体重新探索，通常能打破僵局。要是打不破，就检查是不是奖励设计给了“某个动作永远更好”的错误信号，比如向左推本身有额外加分，那智能体当然不会学向右推。

6.5 常见问题速查表

7. 个人实战经验与后续扩展

7.1 新手最容易掉进的误区：追求复杂度

我在带朋友入门时发现一个规律：越是没有系统训练过的人，越喜欢一上来就挑战高难度任务。有人想直接训练自动驾驶小车，有人想直接做多智能体博弈，这些不是不可以，但你没有一套可靠的调试基线，出了问题根本不知道是自己写了Bug还是算法本身没收敛。

HelloAgents 存在的意义就是先提供一个简单、快速、能跑通的基线。在这个基线上，你能看到正常曲线长什么样，能在它身上反复调试而不心疼时间。等你的体感积累出来了，再换复杂环境，才有判断能力。我见过最快出成果的人，不是那些一开始就写数千行代码的，而是老老实实把CartPole训练到500分，再一点点往复杂任务迁移的人。

7.2 我的三条训练习惯，推荐直接抄

第一个习惯，每次实验固定随机种子，同时在日志里记录所有超参数和代码版本。不要觉得麻烦，很多训练结果你当时觉得理所当然，过两周回看完全不知道当初怎么跑出来的。第二个习惯，一次只改一个变量。调学习率就只动学习率，改网络结构就只动网络结构，千万不要“顺手把奖励也改了一下”。第三个习惯，先看曲线再动手。没有训练曲线就不要盲目调参，先积累足够数据，通过曲线定位问题，再用小步修改验证。

这三条习惯帮我节省了非常多的无效时间。强化学习的调参空间很大，没有纪律的实验，本质上是在碰运气。

7.3 后续扩展方向：从CartPole走向真实任务

HelloAgents 的框架是通用的，训练完CartPole后，你可以往几个方向扩展。最简单的是换环境，比如 LunarLander、FrozenLake，只需要改环境创建代码，其他训练逻辑基本不用动。其次是换算法，在DQN基础上加 Double DQN 和 Dueling DQN，改动很小但效果提升明显。再往后可以试 PPO，处理连续动作控制任务，比如用 Gymnasium 里的经典连续控制环境。如果你想做自定义任务，比如把智能体训练到网格世界里找宝藏，那就需要动手写环境，同时把状态归一化和奖励塑形真正用起来。

现在回头再看，训练智能体最值钱的不是那个最终的模型权重，而是把“为什么会失败”一点点定位出来的过程。很多看起来玄乎的概念，信息、奖励、探索、价值估计，在亲手调试过几百个训练步之后都会变得非常具体。希望这份 HelloAgents 实战指南，能让你少走一点弯路，早点体会到“程序自己学会做事”的乐趣。