强化学习算法实战指南：18个从基础到高级的模型解析与代码实现（上篇）

1次阅读

没有评论

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

强化学习（Reinforcement Learning, RL）是机器学习的一个重要分支，它关注的是智能体（Agent）如何通过与环境交互来学习最优策略。与监督学习和无监督学习不同，强化学习的核心在于通过试错来最大化累积奖励。

智能体与环境 ：智能体通过执行动作（Action）与环境交互，环境返回状态（State）和奖励（Reward）。
马尔可夫决策过程（MDP）：强化学习问题通常建模为 MDP，包含状态空间、动作空间、转移概率和奖励函数。
策略（Policy）：定义了智能体在给定状态下选择动作的方式，可以是确定性的或随机性的。
价值函数（Value Function）：评估状态或状态 - 动作对的长期收益，包括状态价值函数和动作价值函数。
探索与利用（Exploration vs. Exploitation）：智能体需要在探索新动作和利用已知高奖励动作之间平衡。

强化学习算法可以分为以下几类：

基于价值的算法 ：通过优化价值函数间接得到策略，如 Q -Learning、DQN。
适用场景：离散动作空间、中等规模状态空间。
基于策略的算法 ：直接优化策略函数，如 REINFORCE、PPO。
适用场景：连续动作空间、高维状态空间。
Actor-Critic 算法 ：结合价值函数和策略函数，如 A2C、A3C。
适用场景：需要平衡偏差和方差的场景。
模型基算法 ：学习环境模型后进行规划，如 Dyna-Q。
适用场景：环境模型已知或可学习。

Q-Learning 是一种无模型的基于价值的算法，通过更新 Q 表来学习最优策略。其更新公式为：

Q(s, a) ← Q(s, a) + α [r + γ max_a'Q(s', a') - Q(s, a)]

α：学习率
γ：折扣因子

DQN 通过神经网络近似 Q 函数，解决了 Q -Learning 在高维状态空间下的局限性。关键技术包括：

经验回放（Experience Replay）：减少样本相关性。
目标网络（Target Network）：稳定训练。

import numpy as np

# 初始化 Q 表
Q = np.zeros((state_space, action_space))

# Q-Learning 算法
for episode in range(episodes):
    state = env.reset()
    done = False
    while not done:
        # ε- 贪婪策略
        if np.random.rand() < epsilon:
            action = env.action_space.sample()
        else:
            action = np.argmax(Q[state, :])

        next_state, reward, done, _ = env.step(action)

        # Q 表更新
        Q[state, action] += alpha * (reward + gamma * np.max(Q[next_state, :]) - Q[state, action])
        state = next_state

import torch
import torch.nn as nn
import torch.optim as optim

class DQN(nn.Module):
    def __init__(self, state_dim, action_dim):
        super(DQN, self).__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)

# 初始化网络和目标网络
policy_net = DQN(state_dim, action_dim)
target_net = DQN(state_dim, action_dim)
target_net.load_state_dict(policy_net.state_dict())

# 定义优化器和损失函数
optimizer = optim.Adam(policy_net.parameters(), lr=0.001)
criterion = nn.MSELoss()

# 训练循环
for episode in range(episodes):
    state = env.reset()
    done = False
    while not done:
        # ε- 贪婪策略
        if np.random.rand() < epsilon:
            action = env.action_space.sample()
        else:
            with torch.no_grad():
                action = policy_net(torch.FloatTensor(state)).argmax().item()

        next_state, reward, done, _ = env.step(action)

        # 存储经验
        replay_buffer.push(state, action, reward, next_state, done)

        # 从回放缓冲区采样
        if len(replay_buffer) > batch_size:
            batch = replay_buffer.sample(batch_size)

            # 计算目标 Q 值
            with torch.no_grad():
                next_q_values = target_net(batch.next_states).max(1)[0]
                targets = batch.rewards + gamma * next_q_values * (1 - batch.dones)

            # 计算当前 Q 值
            current_q_values = policy_net(batch.states).gather(1, batch.actions.unsqueeze(1))

            # 计算损失并更新
            loss = criterion(current_q_values, targets.unsqueeze(1))
            optimizer.zero_grad()
            loss.backward()
            optimizer.step()

        # 更新目标网络
        if episode % target_update == 0:
            target_net.load_state_dict(policy_net.state_dict())

        state = next_state