easy-rl notebooks全解析：手把手复现强化学习经典算法

easy-rl notebooks全解析：手把手复现强化学习经典算法

【免费下载链接】easy-rl 强化学习中文教程（蘑菇书🍄），在线阅读地址：https://datawhalechina.github.io/easy-rl/ 项目地址: https://gitcode.com/gh_mirrors/ea/easy-rl

引言：从理论到代码的强化学习实践痛点

你是否还在为强化学习算法的理论与代码实现之间的鸿沟而苦恼？面对复杂的公式推导和零散的代码片段，如何快速上手并复现经典算法？本文将系统解析easy-rl项目的notebooks代码库，通过15+经典算法实现、5大核心模块拆解和3个实战案例，带你从零开始掌握强化学习的编程范式。读完本文，你将获得：

• 一套完整的强化学习算法代码模板
• 10+环境的配置与调试技巧
• 多进程训练与性能优化方案
• 算法选择与超参数调优指南

项目架构与环境准备

1. 项目结构解析

easy-rl的notebooks目录采用模块化设计，将算法实现、环境定义和工具函数分离，形成清晰的学习路径：

notebooks/
├── 基础算法/          # Q-Learning、Value Iteration等基础算法
│   ├── Q-learning/
│   └── Value Iteration/
├── 深度强化学习/       # DQN、PPO、A2C等深度算法
│   ├── DQN.ipynb
│   ├── PPO.ipynb
│   └── ...
├── 环境定义/          # 自定义网格环境与工具
│   ├── envs/
│   └── common/
└── 辅助工具/          # 经验回放、多进程训练等组件
    ├── ReplayBuffer.py
    └── multiprocessing_env.py

2. 环境配置指南

通过以下命令快速搭建开发环境：

# 克隆仓库
git clone https://gitcode.com/gh_mirrors/ea/easy-rl
cd easy-rl/notebooks

# 创建虚拟环境
conda create -n easy-rl python=3.7
conda activate easy-rl

# 安装依赖
pip install -r requirements.txt

核心依赖库版本：

• PyTorch 1.10.0+cu113（GPU加速推荐）
• Gym 0.25.2（环境管理）
• Matplotlib 3.5.3（结果可视化）
• NumPy 1.21.6（数值计算）

⚠️ 注意：若使用CPU训练，需修改配置文件中的device='cpu'，部分算法（如SAC）可能需要调整batch_size以避免内存溢出

核心算法实现全解析

1. 表格型方法：Q-Learning与价值迭代

Q-Learning算法框架

Q-Learning作为无模型强化学习的入门算法，其核心是通过时序差分（TD）学习更新动作价值函数：

class QLearning:
    def __init__(self, n_states, n_actions, cfg):
        self.Q_table = defaultdict(lambda: np.zeros(n_actions))  # 状态-动作价值表
        self.lr = cfg.lr  # 学习率
        self.gamma = cfg.gamma  # 折扣因子
        self.epsilon = cfg.epsilon_start  # 探索率
        
    def sample_action(self, state):
        # ε-贪婪策略平衡探索与利用
        if np.random.uniform(0, 1) > self.epsilon:
            return np.argmax(self.Q_table[str(state)])  # 利用：选择最优动作
        else:
            return np.random.choice(self.n_actions)  # 探索：随机选择动作
            
    def update(self, state, action, reward, next_state, terminated):
        # TD目标计算
        Q_predict = self.Q_table[str(state)][action]
        Q_target = reward + self.gamma * np.max(self.Q_table[str(next_state)]) * (1-terminated)
        # 更新Q表
        self.Q_table[str(state)][action] += self.lr * (Q_target - Q_predict)

价值迭代算法流程

价值迭代通过迭代更新状态价值函数直至收敛，适用于小规模MDP问题：

def value_iteration(env, theta=0.005, discount_factor=0.9):
    Q = np.zeros((env.nS, env.nA))  # 初始化Q表
    while True:
        delta = 0.0
        Q_tmp = np.zeros_like(Q)
        for state in range(env.nS):
            for a in range(env.nA):
                # 计算所有可能转移的期望价值
                for prob, next_state, reward, done in env.P[state][a]:
                    Q_tmp[state,a] += prob * (reward + discount_factor * np.max(Q[next_state]))
                delta = max(delta, abs(Q_tmp[state,a] - Q[state,a]))
        Q = Q_tmp
        if delta < theta:  # 收敛判断
            break
    return Q

2. 深度强化学习：从DQN到PPO

DQN及其变体

DQN引入深度神经网络近似Q函数，并通过经验回放和目标网络提升稳定性：

class DQN:
    def __init__(self, n_states, n_actions, hidden_dim=256):
        self.policy_net = nn.Sequential(  # 策略网络
            nn.Linear(n_states, hidden_dim),
            nn.ReLU(),
            nn.Linear(hidden_dim, n_actions)
        )
        self.target_net = copy.deepcopy(self.policy_net)  # 目标网络
        self.memory = ReplayBuffer(10000)  # 经验回放池
        self.optimizer = optim.Adam(self.policy_net.parameters(), lr=1e-3)
        
    def update(self, batch_size=64, gamma=0.99):
        if len(self.memory) < batch_size:
            return
        # 采样与预处理
        state, action, reward, next_state, done = self.memory.sample(batch_size)
        # 计算目标Q值
        with torch.no_grad():
            target_q = reward + gamma * self.target_net(next_state).max(1)[0] * (1-done)
        # 计算当前Q值
        current_q = self.policy_net(state).gather(1, action).squeeze()
        # 损失计算与优化
        loss = F.mse_loss(current_q, target_q)
        self.optimizer.zero_grad()
        loss.backward()
        self.optimizer.step()

PER-DQN通过优先级经验回放进一步优化样本利用效率，其核心是SumTree数据结构：

class SumTree:
    def __init__(self, capacity):
        self.capacity = capacity
        self.tree = np.zeros(2*capacity - 1)  # 树结构
        self.data = np.zeros(capacity, dtype=object)  # 存储样本
        
    def add(self, priority, data):
        # 添加样本并更新优先级
        idx = self.data_pointer + self.capacity - 1
        self.data[self.data_pointer] = data
        self.update(idx, priority)
        self.data_pointer = (self.data_pointer + 1) % self.capacity
        
    def update(self, idx, priority):
        # 更新树节点优先级
        change = priority - self.tree[idx]
        self.tree[idx] = priority
        while idx > 0:
            idx = (idx - 1) // 2
            self.tree[idx] += change

PPO： proximal policy optimization

PPO通过Clipped Surrogate目标函数解决策略更新中的稳定性问题：

class PPO:
    def __init__(self, n_states, n_actions):
        self.actor = Actor(n_states, n_actions)  # 策略网络
        self.critic = Critic(n_states, 1)  # 价值网络
        self.actor_optimizer = optim.Adam(self.actor.parameters(), lr=3e-4)
        self.critic_optimizer = optim.Adam(self.critic.parameters(), lr=1e-3)
        
    def update(self, states, actions, old_log_probs, returns, advantages, clip_ratio=0.2):
        # 计算新策略的log概率
        log_probs = self.actor.get_log_prob(states, actions)
        # 计算概率比值
        ratio = torch.exp(log_probs - old_log_probs.detach())
        # Clipped Surrogate目标
        surr1 = ratio * advantages
        surr2 = torch.clamp(ratio, 1-clip_ratio, 1+clip_ratio) * advantages
        actor_loss = -torch.min(surr1, surr2).mean()
        
        # 价值函数损失
        values = self.critic(states)
        critic_loss = F.mse_loss(values.squeeze(), returns)
        
        # 联合优化
        self.actor_optimizer.zero_grad()
        self.critic_optimizer.zero_grad()
        actor_loss.backward()
        critic_loss.backward()
        self.actor_optimizer.step()
        self.critic_optimizer.step()

3. 连续动作空间：DDPG与SAC

DDPG算法

DDPG通过 Actor-Critic 架构和目标网络软更新处理连续动作空间：

class DDPG:
    def __init__(self, state_dim, action_dim):
        # 策略网络（Actor）
        self.actor = nn.Sequential(
            nn.Linear(state_dim, 256),
            nn.ReLU(),
            nn.Linear(256, action_dim),
            nn.Tanh()  # 输出范围[-1,1]
        )
        # Q网络（Critic）
        self.critic = nn.Sequential(
            nn.Linear(state_dim + action_dim, 256),
            nn.ReLU(),
            nn.Linear(256, 1)
        )
        # 目标网络
        self.target_actor = copy.deepcopy(self.actor)
        self.target_critic = copy.deepcopy(self.critic)
        # 动作噪声
        self.noise = OUNoise(action_dim)
        
    def select_action(self, state, explore=True):
        action = self.actor(state).detach().numpy()
        if explore:
            action += self.noise.sample()
        return np.clip(action, -1, 1)  # 动作裁剪

SAC算法

SAC引入最大熵原则，通过双Q网络和自动温度调整提升探索效率：

class SAC:
    def __init__(self, state_dim, action_dim):
        # 双Q网络
        self.q1_net = SoftQNet(state_dim, action_dim)
        self.q2_net = SoftQNet(state_dim, action_dim)
        # 策略网络
        self.policy_net = PolicyNet(state_dim, action_dim)
        # 温度参数（自动调整探索强度）
        self.alpha = torch.tensor([1.0], requires_grad=True)
        self.alpha_optimizer = optim.Adam([self.alpha], lr=3e-4)
        
    def update(self, batch):
        state, action, reward, next_state, done = batch
        # 计算目标Q值
        with torch.no_grad():
            next_action, next_log_prob, _, _, _ = self.policy_net.evaluate(next_state)
            target_q1 = self.target_q1_net(next_state, next_action)
            target_q2 = self.target_q2_net(next_state, next_action)
            target_q = torch.min(target_q1, target_q2) - self.alpha * next_log_prob
            target_q = reward + (1 - done) * 0.99 * target_q
        # 更新Q网络
        current_q1 = self.q1_net(state, action)
        current_q2 = self.q2_net(state, action)
        q1_loss = F.mse_loss(current_q1, target_q)
        q2_loss = F.mse_loss(current_q2, target_q)
        # 更新策略网络和温度参数
        new_action, log_prob, _, _, _ = self.policy_net.evaluate(state)
        q1_new = self.q1_net(state, new_action)
        q2_new = self.q2_net(state, new_action)
        q_new = torch.min(q1_new, q2_new)
        policy_loss = (self.alpha * log_prob - q_new).mean()
        # 温度自动调整
        alpha_loss = -(self.alpha * (log_prob + self.target_entropy).detach()).mean()

实战案例：从网格世界到机器人控制

案例1：悬崖行走（CliffWalking-v0）

问题描述：在12×4的网格中，智能体需从起点(S)到达终点(G)，避开悬崖区域，每步移动有-1奖励，坠入悬崖得-100奖励并结束回合。

算法选择：Q-Learning（适合离散状态空间小的场景）

核心代码：

# 环境初始化
env = gym.make('CliffWalking-v0')
env = CliffWalkingWapper(env)  # 添加可视化包装器
agent = QLearning(
    n_states=env.observation_space.n,
    n_actions=env.action_space.n,
    lr=0.1,
    gamma=0.9,
    epsilon_start=0.95,
    epsilon_decay=300
)

# 训练过程
for i_ep in range(400):
    state = env.reset()
    ep_reward = 0
    while True:
        action = agent.sample_action(state)
        next_state, reward, done, _ = env.step(action)
        agent.update(state, action, reward, next_state, done)
        state = next_state
        ep_reward += reward
        if done:
            break
    if (i_ep+1) % 20 == 0:
        print(f"回合：{i_ep+1}，奖励：{ep_reward:.1f}，Epsilon：{agent.epsilon:.3f}")

训练结果：经过约200回合训练，智能体可稳定获得-13奖励（最优路径长度），Q表收敛后动作选择如下：

• 前11步：右移（→）
• 最后1步：下移（↓）

案例2：倒立摆（CartPole-v1）

问题描述：控制小车移动使杆保持垂直，每保持一步得+1奖励，最大回合长度500。

算法选择：PPO（样本效率高，适合中等复杂度连续控制）

关键配置：

• 策略网络：2层256维全连接+Softmax输出
• 价值网络：2层256维全连接+线性输出
• 超参数：gamma=0.99，lr=3e-4，clip_ratio=0.2，k_epochs=4

训练曲线：

回合：10/200，奖励：29.20，评估奖励：29.20
回合：50/200，奖励：60.60，评估奖励：60.60
回合：100/200，奖励：173.60，评估奖励：173.60
回合：200/200，奖励：200.00，评估奖励：200.00

案例3： Pendulum-v1

问题描述：控制单摆从任意角度摆动到竖直向上位置，奖励是角度和角速度的负平方和。

算法选择：DDPG（专为连续动作空间设计）

关键技巧：

1. 动作空间归一化：将输出压缩至[-1,1]后映射到环境动作范围
2. OU噪声参数调整：theta=0.15，sigma=0.2（初期大探索，后期衰减）
3. 经验回放池大小：1e6（存储足够多的探索样本）

高级技巧与性能优化

1. 多进程训练加速

使用SubprocVecEnv实现环境并行，提升采样效率：

from common.multiprocessing_env import SubprocVecEnv

def make_env(env_name):
    def _thunk():
        env = gym.make(env_name)
        return env
    return _thunk

# 创建8个并行环境
envs = SubprocVecEnv([make_env('CartPole-v1') for _ in range(8)])

性能对比：在8核CPU上，PPO训练CartPole-v1的速度提升约6倍，每回合采样时间从0.8s降至0.13s（batch_size=2048）。

2. 超参数调优指南

不同算法关键超参数敏感性分析：

算法	敏感参数	推荐范围	影响
DQN	epsilon_decay	1000-5000	小值探索少，易过拟合
PPO	clip_ratio	0.1-0.3	大值允许更大策略更新
DDPG	tau	1e-3-1e-2	小值目标网络更稳定
SAC	alpha	0.1-0.3	大值更倾向探索

调优工具：Optuna或Weights & Biases，建议采用贝叶斯优化方法，采样次数不少于20次。

3. 常见问题排查

Q1: 训练奖励波动大？ A1: 尝试：①增加经验回放池大小 ②降低学习率 ③使用回报标准化（如PPO中的returns = (returns - returns.mean()) / (returns.std() + 1e-5)）

Q2: 连续控制任务不收敛？ A2: 检查：①动作空间是否归一化 ②探索噪声是否合适 ③目标网络更新频率（建议每100步更新一次）

Q3: GPU利用率低？ A3: 优化：①增大batch_size ②启用梯度累积 ③使用混合精度训练（torch.cuda.amp）

总结与进阶路线

核心收获

本文系统解析了easy-rl notebooks的15+强化学习算法实现，涵盖从基础表格方法到深度强化学习的完整技术栈。通过模块化代码结构和实战案例，你已掌握：

• 强化学习算法的通用实现框架
• 环境建模与问题抽象技巧
• 训练过程优化与性能调优方法
• 算法选择与场景匹配策略

进阶方向

1. 分布式训练：

【免费下载链接】easy-rl 强化学习中文教程（蘑菇书🍄），在线阅读地址：https://datawhalechina.github.io/easy-rl/ 项目地址: https://gitcode.com/gh_mirrors/ea/easy-rl