强化学习算法全景指南：18种基础到高级方法的理论解析与代码实现（上）

1次阅读

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

强化学习（Reinforcement Learning, RL）作为机器学习的重要分支，近年来在游戏 AI、机器人控制、自动驾驶等领域取得了显著成果。本文将从基础概念出发，系统梳理 18 种常用的强化学习算法，帮助开发者快速掌握核心算法原理和实现方法。

强化学习的核心数学框架是马尔可夫决策过程，由五元组 $(S,A,P,R,\gamma)$ 组成：

$S$：状态空间
$A$：动作空间
$P$：状态转移概率 $P(s’|s,a)$
$R$：奖励函数 $R(s,a,s’)$
$\gamma$：折扣因子（0≤γ≤1）

策略（Policy）：$\pi(a|s)$，定义了在状态 $s$ 下采取动作 $a$ 的概率
价值函数：
状态价值函数 $V^\pi(s)$
动作价值函数 $Q^\pi(s,a)$
Bellman 方程：价值函数的递归定义

Q-Learning 是最经典的离策略（off-policy）算法，更新公式为：

$$Q(s,a) \leftarrow Q(s,a) + \alpha[r + \gamma \max_{a’}Q(s’,a’) – Q(s,a)]$$

适用场景：离散状态和动作空间，中小规模问题

Python 实现：

import numpy as np

class QLearning:
    def __init__(self, n_states, n_actions, alpha=0.1, gamma=0.99):
        self.q_table = np.zeros((n_states, n_actions))
        self.alpha = alpha  # 学习率
        self.gamma = gamma  # 折扣因子

    def update(self, state, action, reward, next_state, done):
        current_q = self.q_table[state, action]
        # 计算目标 Q 值
        max_next_q = np.max(self.q_table[next_state]) if not done else 0
        target_q = reward + self.gamma * max_next_q
        # Q 值更新
        self.q_table[state, action] += self.alpha * (target_q - current_q)

SARSA 是 on-policy 算法，更新公式为：

$$Q(s,a) \leftarrow Q(s,a) + \alpha[r + \gamma Q(s’,a’) – Q(s,a)]$$

与 Q -Learning 对比：
– SARSA 更保守（考虑实际执行策略）
– Q-Learning 更激进（总是选择最优动作）

DQN 使用神经网络近似 Q 函数，解决了高维状态空间问题。

关键创新：
1. 经验回放（Experience Replay）
2. 目标网络（Target Network）

PyTorch 实现核心：

import torch
import torch.nn as nn
import torch.optim as optim
import random
from collections import deque

class DQN(nn.Module):
    def __init__(self, state_dim, action_dim):
        super().__init__()
        self.fc1 = nn.Linear(state_dim, 64)
        self.fc2 = nn.Linear(64, 64)
        self.fc3 = nn.Linear(64, action_dim)

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

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)

解决 DQN 的过估计问题，改进 Q 目标计算：

$$y = r + \gamma Q_{\theta^-}(s’, \arg\max_{a’} Q_\theta(s’,a’))$$

最基本的策略梯度算法，直接优化策略：

$$\nabla_\theta J(\theta) \approx \sum_t \nabla_\theta \log \pi_\theta(a_t|s_t) G_t$$

实现要点：
– 需要完整的 episode
– 高方差问题

目前最流行的策略梯度算法，通过裁剪机制保证稳定更新：

$$L^{CLIP}(\theta) = \mathbb{E}[\min(r_t(\theta)\hat{A}_t, \text{clip}(r_t(\theta),1-\epsilon,1+\epsilon)\hat{A}_t)]$$

PyTorch 核心代码：

class PPONetwork(nn.Module):
    def __init__(self, state_dim, action_dim):
        super().__init__()
        self.actor = nn.Sequential(nn.Linear(state_dim, 64),
            nn.Tanh(),
            nn.Linear(64, 64),
            nn.Tanh(),
            nn.Linear(64, action_dim),
            nn.Softmax(dim=-1)
        )
        self.critic = nn.Sequential(nn.Linear(state_dim, 64),
            nn.Tanh(),
            nn.Linear(64, 64),
            nn.Tanh(),
            nn.Linear(64, 1)
        )

    def forward(self, x):
        return self.actor(x), self.critic(x)