深度强化学习入门实践：从Q-Learning到PPO的代码实现与算法对比

这次我们来看一个面向新手的深度强化学习入门教程。这个教程的核心目标不是堆砌复杂的数学公式，而是帮你快速理解强化学习到底能做什么，以及如何用代码跑通几个最经典的算法。如果你对AI如何通过“试错”来学习决策感兴趣，但又觉得理论门槛太高，这篇文章会是一个不错的起点。

教程内容覆盖了强化学习的核心脉络，从基础概念到经典算法，包括PPO、DQN、A3C、Q-Learning和SARSA。重点不在于推导，而在于理解每个算法的思想、适用场景以及如何动手实践。对于初学者来说，最关心的问题往往是：我需要什么环境？代码从哪里开始写？跑一个简单的例子需要多少计算资源？本文将围绕这些实际问题展开，提供一个从零开始的、可操作的入门路径。

我们将按照“环境搭建 -> 核心概念理解 -> 算法代码实践 -> 效果观察”的顺序进行。整个过程可以在个人电脑（包括仅使用CPU）上完成，主要依赖Python和几个主流的强化学习库。显存和GPU不是必须的，这对于入门学习者非常友好。文章后半部分会提供完整的代码示例、运行命令以及常见错误的排查方法，确保你能亲手复现一个智能体从“一无所知”到“学会任务”的过程。

1. 核心能力速览

本教程聚焦于深度强化学习（Deep Reinforcement Learning, DRL）的入门与实践，旨在降低学习门槛。

2. 适用场景与使用边界

强化学习是机器学习的一个重要分支，它研究的是智能体（Agent）如何在一个环境中通过采取行动（Action）来最大化累积奖励（Reward）。与监督学习需要大量标注数据不同，强化学习通过“试错”进行学习。

这个教程适合谁？

• 初学者 ：对AI决策感兴趣，但被理论吓退的开发者或学生。
• 实践者 ：学过理论，但不知道如何用代码实现第一个强化学习智能体的人。
• 探索者 ：想快速了解PPO、DQN等主流算法区别和适用场景的研究者。

它能解决什么问题？ 本教程提供的知识和代码能帮助你：

1. 建立直觉 ：理解状态、动作、奖励、策略、价值函数这些核心概念。
2. 跑通流程 ：完成从安装环境、定义问题、选择算法、训练模型到评估性能的完整闭环。
3. 对比算法 ：在相同的简单环境（如CartPole）上，直观感受不同算法（如DQN vs PPO）的学习速度和稳定性差异。
4. 打下基础 ：获得足以阅读更高级论文和复现更复杂实验的代码能力。

使用边界与注意事项：

• 仿真环境 ：教程主要在Gymnasium提供的标准仿真环境中进行，与真实物理世界存在差距。将算法迁移到真实机器人等场景需要大量额外工作（如仿真到真实的技术）。
• 计算成本 ：虽然入门环境需求低，但训练一个能在复杂环境（如《星际争霸II》）中达到人类水平的智能体，需要巨大的计算资源和时间。
• 算法选择 ：没有“银弹”算法。Q-Learning系列适合离散动作空间（如上下左右），PPO等策略梯度方法更适合连续动作空间（如方向盘转角、电机扭矩）。教程会帮你建立选择依据。
• 安全与伦理 ：强化学习智能体以最大化奖励为目标，可能产生意想不到的、甚至有害的行为（“奖励黑客”）。在设计奖励函数和部署系统时，必须考虑安全性和伦理性约束。

3. 环境准备与前置条件

在开始写代码之前，需要配置好开发环境。以下是基于Python的推荐配置，这是目前强化学习社区最主流的生态。

1. 操作系统

• Windows 10/11, macOS, 或 Linux (如Ubuntu 20.04+)。Linux在深度学习开发中兼容性最好，但Windows和macOS对于入门教程也完全足够。

2. Python 环境

• 推荐版本 ：Python 3.8 或 3.9。这是大多数深度学习库稳定性兼容较好的版本。
• 环境管理 ：强烈建议使用 conda 或 venv 创建独立的虚拟环境，避免包冲突。

  # 使用 conda 创建环境
  conda create -n rl_tutorial python=3.9
  conda activate rl_tutorial
  
  # 或者使用 venv
  python -m venv rl_tutorial
  # Windows
  .\rl_tutorial\Scripts\activate
  # Linux/macOS
  source rl_tutorial/bin/activate
  

3. 核心依赖库 我们将安装以下几个核心库，它们构成了现代深度强化学习实践的基础框架：

• gymnasium : OpenAI Gym的维护分支，提供了大量标准化的强化学习环境。
• torch 或 tensorflow : 深度学习框架，用于构建神经网络。本教程示例将优先使用PyTorch，因其在研究中更流行。
• stable-baselines3 : 一个基于PyTorch的强化学习算法高质量实现库，封装了PPO、DQN、A2C等算法，让我们能专注于应用而非底层实现。
• 其他工具库：如 numpy , matplotlib (用于绘图)， opencv-python (用于图像环境预处理)等。

4. 安装部署与启动方式

环境准备好后，通过pip一键安装所需库。以下命令在激活的虚拟环境中执行。

1. 基础安装

# 安装 Gymnasium 和经典控制环境
pip install gymnasium[classic_control]
# 如果需要Atari游戏环境，还需安装以下（需要较多依赖）
# pip install gymnasium[atari]
# pip install gymnasium[accept-rom-license]
# pip install ale-py

# 安装 PyTorch (请根据你的CUDA版本前往 https://pytorch.org/ 获取最新命令)
# 例如，对于CPU版本或没有NVIDIA显卡的用户：
pip install torch torchvision torchaudio --index-url https://download.pytorch.org/whl/cpu

# 安装 Stable-Baselines3 及其额外依赖
pip install stable-baselines3[extra]

# 安装常用工具
pip install numpy matplotlib ipython jupyter

2. 验证安装 创建一个简单的Python脚本 test_env.py 来测试环境是否正常。

import gymnasium as gym

# 创建“倒立摆”（CartPole）环境，这是最经典的入门环境
env = gym.make('CartPole-v1', render_mode='human')
# 重置环境，获取初始状态
observation, info = env.reset()

for _ in range(1000):
    # 随机选择一个动作（0:向左推车，1:向右推车）
    action = env.action_space.sample()
    # 执行动作，获取下一步状态、奖励、是否终止等信息
    observation, reward, terminated, truncated, info = env.step(action)

    # 如果游戏结束（杆子倒下或小车出界），重置环境
    if terminated or truncated:
        observation, info = env.reset()

env.close()
print("环境测试成功！你看到一个小车和摆杆在随机运动。")

运行这个脚本：

python test_env.py

如果弹出一个窗口，显示一个小车带着一根杆子在做随机运动，说明Gymnasium环境安装成功。这是强化学习世界的“Hello World”。

3. 启动学习流程 真正的“启动”是开始训练一个智能体。我们将使用Stable-Baselines3库，它提供了“定义环境 -> 选择算法 -> 训练 -> 保存 -> 测试”的一站式接口。下面以PPO算法训练CartPole为例：

import gymnasium as gym
from stable_baselines3 import PPO
from stable_baselines3.common.env_util import make_vec_env

# 1. 创建并行化环境（加速训练）
env = make_vec_env('CartPole-v1', n_envs=4)

# 2. 实例化PPO算法模型
model = PPO('MlpPolicy', env, verbose=1)
# ‘MlpPolicy’表示使用多层感知机作为策略网络，适用于CartPole这种状态是向量的环境。

# 3. 训练模型 (训练10,000步)
model.learn(total_timesteps=10000)

# 4. 保存模型
model.save("ppo_cartpole")

# 5. 加载模型并测试
del model # 删除现有模型以演示加载
model = PPO.load("ppo_cartpole")

# 创建用于渲染的测试环境
test_env = gym.make('CartPole-v1', render_mode='human')
obs, info = test_env.reset()
for i in range(1000):
    action, _states = model.predict(obs, deterministic=True)
    obs, reward, terminated, truncated, info = test_env.step(action)
    if terminated or truncated:
        obs, info = test_env.reset()
test_env.close()

将上述代码保存为 train_ppo.py 并运行。控制台会输出训练日志，训练完成后，你会看到智能体能够完美地平衡杆子，这标志着你的第一个强化学习智能体训练成功。

5. 功能测试与效果验证

仅仅跑通代码不够，我们需要理解每个算法在做什么，并学会如何评估它们。下面我们针对几个核心算法进行功能测试和效果对比。

5.1 算法一：Q-Learning (表格法)

测试目的 ：理解基于价值迭代的思想，适用于小型离散状态空间。 环境 ： FrozenLake-v1 （一个网格世界，智能体要避开冰窟走到终点）。 核心思想 ：维护一个Q表格，记录每个状态-动作对的预期收益，通过不断更新来学习最优策略。

import gymnasium as gym
import numpy as np
import matplotlib.pyplot as plt

env = gym.make('FrozenLake-v1', map_name="4x4", is_slippery=False, render_mode=None)
# 初始化Q表，大小为 (状态数，动作数)
q_table = np.zeros([env.observation_space.n, env.action_space.n])

# 超参数
learning_rate = 0.1
discount_factor = 0.99
episodes = 5000

rewards = []
for episode in range(episodes):
    state, _ = env.reset()
    total_reward = 0
    terminated = False

    while not terminated:
        # ϵ-贪婪策略选择动作
        if np.random.uniform(0, 1) < 0.1:
            action = env.action_space.sample() # 探索
        else:
            action = np.argmax(q_table[state]) # 利用

        next_state, reward, terminated, truncated, _ = env.step(action)
        # Q-Learning更新公式
        old_value = q_table[state, action]
        next_max = np.max(q_table[next_state])
        new_value = old_value + learning_rate * (reward + discount_factor * next_max - old_value)
        q_table[state, action] = new_value

        total_reward += reward
        state = next_state
    rewards.append(total_reward)

# 评估学到的策略
success_rate = np.mean([1 if r > 0 else 0 for r in rewards[-100:]]) # 最后100局成功率
print(f"训练后成功率（最后100局）: {success_rate:.2%}")

# 可视化奖励曲线
plt.plot(rewards)
plt.xlabel('Episode')
plt.ylabel('Total Reward')
plt.title('Q-Learning on FrozenLake')
plt.show()

预期结果与判断 ：在 is_slippery=False （不打滑）的设置下，Q-Learning应能快速学习到100%的成功率。奖励曲线会从0（一直掉进冰窟）逐渐上升到1（到达终点）。如果曲线没有上升，检查学习率或探索率(ϵ)的设置。

5.2 算法二：DQN (深度Q网络)

测试目的 ：理解如何用神经网络近似Q表格，从而处理高维状态（如图像）。 环境 ： CartPole-v1 （状态是4维向量）。 核心思想 ：用深度神经网络代替Q表格，输入状态，输出每个动作的Q值。引入经验回放和目标网络来稳定训练。

import gymnasium as gym
import torch
import torch.nn as nn
import random
from collections import deque
import numpy as np

class DQN(nn.Module):
    def __init__(self, state_dim, action_dim):
        super(DQN, self).__init__()
        self.net = nn.Sequential(
            nn.Linear(state_dim, 64),
            nn.ReLU(),
            nn.Linear(64, 64),
            nn.ReLU(),
            nn.Linear(64, action_dim)
        )
    def forward(self, x):
        return self.net(x)

env = gym.make('CartPole-v1')
state_dim = env.observation_space.shape[0]
action_dim = env.action_space.n

model = DQN(state_dim, action_dim)
target_model = DQN(state_dim, action_dim)
target_model.load_state_dict(model.state_dict())

optimizer = torch.optim.Adam(model.parameters(), lr=1e-3)
replay_buffer = deque(maxlen=10000)
batch_size = 64
gamma = 0.99
epsilon = 1.0
epsilon_min = 0.01
epsilon_decay = 0.995

def train_step():
    if len(replay_buffer) < batch_size:
        return
    batch = random.sample(replay_buffer, batch_size)
    states, actions, rewards, next_states, dones = zip(*batch)

    states = torch.FloatTensor(states)
    actions = torch.LongTensor(actions).unsqueeze(1)
    rewards = torch.FloatTensor(rewards).unsqueeze(1)
    next_states = torch.FloatTensor(next_states)
    dones = torch.FloatTensor(dones).unsqueeze(1)

    # 计算当前Q值
    current_q = model(states).gather(1, actions)
    # 计算目标Q值
    with torch.no_grad():
        next_q = target_model(next_states).max(1, keepdim=True)[0]
        target_q = rewards + gamma * next_q * (1 - dones)
    # 计算损失并更新
    loss = nn.MSELoss()(current_q, target_q)
    optimizer.zero_grad()
    loss.backward()
    optimizer.step()

episode_rewards = []
for episode in range(200):
    state, _ = env.reset()
    total_reward = 0
    for t in range(500): # CartPole最多500步
        # ϵ-贪婪策略
        if np.random.rand() <= epsilon:
            action = env.action_space.sample()
        else:
            with torch.no_grad():
                state_tensor = torch.FloatTensor(state).unsqueeze(0)
                q_values = model(state_tensor)
                action = q_values.argmax().item()

        next_state, reward, terminated, truncated, _ = env.step(action)
        done = terminated or truncated
        replay_buffer.append((state, action, reward, next_state, done))

        state = next_state
        total_reward += reward
        train_step()

        if done:
            break

    # 更新目标网络和探索率
    if episode % 10 == 0:
        target_model.load_state_dict(model.state_dict())
    epsilon = max(epsilon_min, epsilon * epsilon_decay)
    episode_rewards.append(total_reward)
    print(f"Episode {episode}, Reward: {total_reward:.1f}, Epsilon: {epsilon:.3f}")

env.close()
print("DQN训练完成。")

预期结果与判断 ：随着训练进行， episode_rewards 应逐渐增加并稳定在接近500（最高分）。探索率 epsilon 会逐渐衰减。如果奖励不增长，可能是网络结构太简单、学习率不合适或经验回放缓冲区太小。

5.3 算法三：PPO (近端策略优化)

测试目的 ：理解现代策略梯度算法的稳定性和高效性，适用于连续和离散动作空间。 环境 ： Pendulum-v1 （连续动作空间，控制单摆使其直立）。 核心思想 ：通过限制每次策略更新的幅度，避免训练崩溃，提高样本效率。Stable-Baselines3已完美封装。

import gymnasium as gym
from stable_baselines3 import PPO
from stable_baselines3.common.evaluation import evaluate_policy

# 创建环境
env = gym.make('Pendulum-v1')

# 使用PPO算法
model = PPO("MlpPolicy", env, verbose=1, learning_rate=3e-4, n_steps=2048, batch_size=64)
# 训练
model.learn(total_timesteps=100000)
# 保存模型
model.save("ppo_pendulum")

# 评估模型
mean_reward, std_reward = evaluate_policy(model, env, n_eval_episodes=10)
print(f"平均奖励: {mean_reward:.2f} +/- {std_reward:.2f}")

# 可视化结果
obs, _ = env.reset()
for _ in range(200):
    action, _states = model.predict(obs, deterministic=True)
    obs, rewards, terminated, truncated, info = env.step(action)
    env.render() # 需要安装必要的图形后端
    if terminated or truncated:
        obs, _ = env.reset()
env.close()

预期结果与判断 ：在 Pendulum-v1 中，奖励范围是[-16.27, 0]，0表示摆锤直立且静止。训练后， mean_reward 应接近0（例如-200到-50之间，数值越大越好）。PPO通常比DQN在连续控制任务上更稳定、效果更好。如果奖励一直很低，可以尝试增加 total_timesteps 或调整网络结构（在 policy_kwargs 中设置）。

6. 接口API与批量任务

在实际应用中，我们训练好的模型需要被其他系统调用，或者需要进行超参数批量搜索。Stable-Baselines3的模型提供了清晰的预测接口。

6.1 模型预测API

训练好的模型本质上是一个 predict 函数，输入当前状态，输出推荐动作。

import gymnasium as gym
from stable_baselines3 import PPO

# 加载训练好的模型
model = PPO.load("ppo_cartpole")
env = gym.make('CartPole-v1', render_mode='human')

obs, info = env.reset()
for i in range(1000):
    # 核心API调用：model.predict(observation, ...)
    # deterministic=True 表示选择概率最高的动作（测试时用）
    # deterministic=False 表示按概率分布采样动作（探索时用）
    action, _state = model.predict(obs, deterministic=True)
    obs, reward, terminated, truncated, info = env.step(action)
    env.render()
    if terminated or truncated:
        obs, info = env.reset()
env.close()

6.2 构建简单的推理服务

你可以将模型封装成一个简单的Web服务（例如使用Flask），供其他程序远程调用。

# app.py
from flask import Flask, request, jsonify
import gymnasium as gym
import numpy as np
from stable_baselines3 import PPO

app = Flask(__name__)
model = PPO.load("ppo_cartpole")
env = gym.make('CartPole-v1', render_mode='rgb_array') # 无需图形界面

@app.route('/predict', methods=['POST'])
def predict():
    data = request.json
    observation = np.array(data['observation'])
    action, _ = model.predict(observation, deterministic=True)
    return jsonify({'action': int(action)})

@app.route('/reset', methods=['GET'])
def reset_env():
    obs, info = env.reset()
    return jsonify({'observation': obs.tolist(), 'info': info})

if __name__ == '__main__':
    app.run(host='0.0.0.0', port=5000)

启动服务后，可以通过curl或Python requests库调用：

# 启动服务
python app.py

# test_client.py
import requests
import json

reset_resp = requests.get('http://127.0.0.1:5000/reset')
obs = reset_resp.json()['observation']

for _ in range(10):
    predict_resp = requests.post('http://127.0.0.1:5000/predict',
                                 json={'observation': obs})
    action = predict_resp.json()['action']
    print(f"Observation: {obs}, Predicted Action: {action}")
    # 这里需要模拟或真实执行一步环境步骤，获取新的obs
    # 为简化示例，我们假设obs不变

6.3 超参数批量搜索

寻找最优超参数是强化学习中的重要环节。可以使用 optuna 或 ray[tune] 库进行自动化搜索。

import optuna
from stable_baselines3 import PPO
from stable_baselines3.common.evaluation import evaluate_policy
import gymnasium as gym

def objective(trial):
    # 定义超参数搜索空间
    learning_rate = trial.suggest_loguniform('learning_rate', 1e-5, 1e-2)
    n_steps = trial.suggest_categorical('n_steps', [64, 128, 256, 512, 1024, 2048])
    gamma = trial.suggest_uniform('gamma', 0.9, 0.9999)

    env = gym.make('CartPole-v1')
    model = PPO('MlpPolicy', env, verbose=0,
                learning_rate=learning_rate,
                n_steps=n_steps,
                gamma=gamma)
    model.learn(total_timesteps=10000)
    mean_reward, _ = evaluate_policy(model, env, n_eval_episodes=10)
    env.close()
    return mean_reward

study = optuna.create_study(direction='maximize')
study.optimize(objective, n_trials=50)

print('最佳超参数:', study.best_params)
print('最佳奖励值:', study.best_value)

这个脚本会自动尝试50组不同的超参数组合，并找出在CartPole环境上平均奖励最高的那一组。

7. 资源占用与性能观察

强化学习训练的性能开销主要来自两部分： 环境模拟 和 神经网络训练/推理 。对于入门级环境，资源占用很低。

1. CPU vs GPU

• 环境模拟 ：Gymnasium的经典控制环境（CartPole, Pendulum）计算量极小，完全在CPU上运行。
• 神经网络 ：对于小型网络（如CartPole用的MLP），在CPU和GPU上训练速度差异不大。GPU的优势在于处理大批量数据或大型网络（如用于Atari游戏的CNN）。 对于入门学习，CPU完全足够。

2. 内存与显存占用

• 内存 ：训练过程中，经验回放缓冲区（DQN）或轨迹缓冲区（PPO）会占用主要内存。对于CartPole，10万个样本的回放缓冲区大约占用几十MB内存。
• 显存 ：只有在使用GPU训练时才会占用显存。训练一个用于CartPole的简单MLP，显存占用通常小于500MB。如果使用CPU模式，显存占用为0。

3. 如何观察资源占用 在Python中，可以使用 psutil 和 torch 库来监控资源。

import psutil
import torch
import time

process = psutil.Process()
def monitor_resources(interval=1.0):
    while True:
        cpu_percent = process.cpu_percent(interval=None)
        memory_mb = process.memory_info().rss / 1024 / 1024
        if torch.cuda.is_available():
            gpu_memory = torch.cuda.memory_allocated() / 1024 / 1024
            print(f"CPU: {cpu_percent:.1f}%, Mem: {memory_mb:.1f} MB, GPU Mem: {gpu_memory:.1f} MB")
        else:
            print(f"CPU: {cpu_percent:.1f}%, Mem: {memory_mb:.1f} MB")
        time.sleep(interval)

# 在另一个线程中启动监控
import threading
monitor_thread = threading.Thread(target=monitor_resources, daemon=True)
monitor_thread.start()

在训练脚本开始时调用 monitor_resources() ，就能在控制台看到实时的资源消耗。

4. 性能优化建议

• 向量化环境 ：使用 make_vec_env 创建多个环境并行运行，可以显著提高数据采集效率，这是Stable-Baselines3的默认做法。
• 调整缓冲区大小 ：对于DQN， replay_buffer 大小影响学习稳定性，通常设为1万到100万。太小会导致过拟合，太大会占用过多内存。
• 批量大小 ： batch_size 影响每次参数更新的数据量。太小不稳定，太大计算慢且可能陷入局部最优。从32、64、128等值开始尝试。
• 总训练步数 ： total_timesteps 是决定训练效果的关键。简单任务（CartPole）可能只需几万步，复杂任务需要数百万甚至数十亿步。观察奖励曲线，当曲线平稳且达到预期性能时即可停止。

8. 常见问题与排查方法

在实践过程中，你可能会遇到以下典型问题。这里提供排查思路。

9. 最佳实践与使用建议

为了更高效、更稳定地开展强化学习实验，遵循以下最佳实践可以少走很多弯路。

1. 实验记录与版本控制 强化学习实验可复现性至关重要。

• 固定随机种子 ：在代码开头设置随机种子，确保每次运行结果一致。

  import random
  import numpy as np
  import torch
  import gymnasium as gym
  
  seed = 42
  random.seed(seed)
  np.random.seed(seed)
  torch.manual_seed(seed)
  env = gym.make('CartPole-v1')
  env.reset(seed=seed)
  

• 使用实验管理工具 ：如 Weights & Biases (wandb) 、 TensorBoard 来记录超参数、奖励曲线、模型权重等。
• 代码版本控制 ：使用Git管理代码，每次实验对应一个分支或标签。

2. 从简单到复杂

• 环境 ：先从 CartPole-v1 、 MountainCar-v0 这类低维状态环境开始，再挑战 Pendulum-v1 （连续动作），最后尝试 Atari 游戏（图像输入）。
• 算法 ：先理解并实现表格法Q-Learning，再学习DQN（价值学习代表），最后掌握PPO（策略学习代表）。这个顺序有助于建立直观理解。
• 自定义环境 ：在熟悉标准环境后，再尝试用Gymnasium接口封装自己的业务环境。

3. 超参数调优策略

• 学习率 ：是最重要的超参数之一。从 3e-4 （PPO常用）或 1e-3 （DQN常用）开始尝试，观察训练稳定性。
• 折扣因子 (gamma) ：通常设置在 0.99 左右。越接近1，智能体越考虑长远奖励。
• 探索与利用 ：初期高探索（ϵ大），后期高利用（ϵ小）。使用衰减策略（如指数衰减）。
• 批量大小与步数 ： batch_size 通常为32、64、128。 n_steps （PPO中）表示每次更新前收集的步数，通常为128、256、512、2048。

4. 模型评估与部署

• 独立评估集 ：使用训练中未见过的环境实例（不同随机种子）来评估模型泛化能力。
• 谨慎部署 ：强化学习智能体在训练环境外可能行为不可预测。在关键应用（如机器人、自动驾驶）中部署前，必须进行大量安全测试和模拟。
• 持续监控 ：部署后，持续监控其性能，并设置安全护栏（如动作限制、紧急停止机制）。

10. 总结与下一步

通过本教程，你应该已经完成了深度强化学习从概念到实践的第一次闭环。我们重点拆解了Q-Learning、DQN、PPO这几个核心算法的思想与代码实现，并在CartPole、FrozenLake、Pendulum等经典环境中验证了它们的效果。整个过程强调可操作性，所有代码都可以在普通电脑的CPU上运行起来。

最值得尝试的下一步：

1. 更换环境 ：尝试在 MountainCar-v0 （需要学习“蓄力”技巧）或 LunarLander-v2 （更复杂的控制任务）上运行PPO或DQN，观察算法在不同任务上的表现差异。
2. 算法对比 ：在同一个环境（如CartPole）中，用相同的训练步数，系统性地比较DQN、A2C、PPO的收敛速度、最终性能和稳定性。这是理解算法特性的最好方式。
3. 自定义环境 ：使用Gymnasium的接口，将你熟悉的一个简单问题（例如，一个自定义的小游戏）封装成强化学习环境，并尝试用学到的算法去解决它。这是通向实际应用的关键一步。
4. 阅读经典论文 ：动手实践后，再回去阅读DQN、PPO等算法的原始论文，你会对其中的设计细节有更深刻的理解。

最容易踩的坑：

• 忽略随机种子 ：导致实验结果无法复现。
• 超参数设置不当 ：直接使用默认参数可能在某些环境上不工作，需要耐心调整。
• 训练步数不足 ：看到奖励曲线不上升就放弃，可能只是训练还不够。
• 混淆离散与连续动作空间 ：DQN通常用于离散动作，PPO/A2C等可用于连续动作，选择错误的算法会导致代码无法运行。

强化学习是一个实验性很强的领域，理论理解固然重要，但真正的进步来自于大量的编码、调试和实验。建议你把本文提供的代码作为起点，不断修改参数、更换环境、尝试新的算法，并在过程中记录下你的观察和思考。当你成功让智能体在一个新环境中学会任务时，获得的成就感将是巨大的。