深度强化学习与AI Agent实战入门：从零构建你的第一个智能体

1次阅读

共计 2904 个字符，预计需要花费 8 分钟才能阅读完成。

当你第一次接触机器学习时，可能会遇到监督学习和无监督学习。监督学习就像有一个老师告诉你每道题的答案，而无监督学习则是让你自己发现数据中的模式。而强化学习（Reinforcement Learning, RL）则完全不同——它更像是一种试错学习，通过与环境的互动来学习最佳策略。

让我们用一个简单的迷宫寻路案例来解释 RL 的核心概念：

状态（State）：就像你在迷宫中的当前位置。
动作（Action）：你可以选择向上、下、左、右移动。
奖励（Reward）：找到出口获得 +100，撞墙获得 -10，每走一步获得 -1（鼓励尽快找到出口）。

与监督学习不同，RL 没有 ” 正确答案 ”，Agent 需要通过尝试来发现哪些动作在特定状态下能带来最大长期回报。

在深度强化学习中，有几种常见算法：

Q-Learning：经典的表格方法，适用于状态空间小的问题
DQN（Deep Q-Network）：结合神经网络和 Q -Learning，能处理高维状态空间
PPO（Proximal Policy Optimization）：策略梯度方法，适用于连续动作空间

对于初学者来说，DQN 是一个理想的起点，因为：

相对简单，易于理解和实现
能展示深度学习和 RL 的结合
许多高级算法（如 Double DQN、Dueling DQN）都是其变体

import torch
import torch.nn as nn
import torch.nn.functional as F

class DQN(nn.Module):
    def __init__(self, state_size, action_size):
        super(DQN, self).__init__()
        # 输入层：接收状态向量
        self.fc1 = nn.Linear(state_size, 64)  
        # 隐藏层：提取特征
        self.fc2 = nn.Linear(64, 64)          
        # 输出层：输出每个动作的 Q 值
        self.fc3 = nn.Linear(64, action_size) 

    def forward(self, x):
        x = F.relu(self.fc1(x))
        x = F.relu(self.fc2(x))
        return self.fc3(x)

经验回放（Experience Replay）是 DQN 的关键组件，它通过存储和随机采样过去的经验来打破数据相关性：

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, done):
        self.buffer.append((state, action, reward, next_state, done))

    def sample(self, batch_size):
        return random.sample(self.buffer, batch_size)

    def __len__(self):
        return len(self.buffer)

在训练初期，我们希望 Agent 多探索；随着训练进行，逐渐依赖学到的策略：

def select_action(state, epsilon):
    if random.random() > epsilon:
        with torch.no_grad():
            return policy_net(state).max(1)[1].view(1,1)
    else:
        return torch.tensor([[random.randrange(n_actions)]], device=device)

for episode in range(num_episodes):
    state = env.reset()
    for t in count():
        action = select_action(state, epsilon)
        next_state, reward, done, _ = env.step(action.item())
        memory.push(state, action, next_state, reward, done)

        # 经验回放采样
        if len(memory) > batch_size:
            transitions = memory.sample(batch_size)
            batch = Transition(*zip(*transitions))

            # 计算当前 Q 值和目标 Q 值
            current_q = policy_net(batch.state).gather(1, batch.action)
            next_q = target_net(batch.next_state).max(1)[0].detach()
            expected_q = batch.reward + (gamma * next_q * (1 - batch.done))

            # 计算损失并更新
            loss = F.mse_loss(current_q, expected_q.unsqueeze(1))
            optimizer.zero_grad()
            loss.backward()
            optimizer.step()

学习率：通常从 1e- 3 到 1e- 5 尝试
折扣因子 γ ：短期任务用 0.9，长期任务用 0.99
ε 衰减：从 1.0 线性衰减到 0.01 或 0.1

保持奖励尺度合理（不宜过大或过小）
稀疏奖励问题可以通过 ” 奖励塑形 ” 缓解
避免奖励函数出现局部最优陷阱

检查 Q 值是否爆炸（可能是学习率太高）
观察 Agent 是否陷入单一行为模式
可视化学习曲线和探索率变化

# 保存
torch.save({'model_state_dict': model.state_dict(),
    'optimizer_state_dict': optimizer.state_dict(),}, 'model.pth')

# 加载
checkpoint = torch.load('model.pth')
model.load_state_dict(checkpoint['model_state_dict'])