大语言模型原理与工程实践：DQN 训练：完整算法

最新推荐文章于 2024-07-19 16:50:04 发布

AI大模型应用之禅

最新推荐文章于 2024-07-19 16:50:04 发布

阅读量393

点赞数 4

分类专栏：一切皆是映射:AI人工智能与大数据原理与应用实战一切皆是映射:深度强化学习原理与应用实战一切皆是映射:人工智能数学基础原理与应用实战文章标签：计算科学神经计算深度学习神经网络大数据人工智能大型语言模型 AI AGI LLM Java Python 架构设计 Agent RPA

本文链接：https://blog.csdn.net/2401_85133351/article/details/139187966

版权

一切皆是映射:人工智能数学基础原理与应用实战同时被 3 个专栏收录

934 篇文章 2 订阅

订阅专栏

一切皆是映射:AI人工智能与大数据原理与应用实战

926 篇文章 5 订阅

订阅专栏

一切皆是映射:深度强化学习原理与应用实战

918 篇文章 2 订阅

订阅专栏

大语言模型原理与工程实践：DQN 训练：完整算法

作者：禅与计算机程序设计艺术

1. 背景介绍

1.1 深度强化学习概述

1.1.1 强化学习基本概念

1.1.2 深度强化学习的兴起

1.1.3 深度强化学习的优势与挑战

1.2 DQN 的诞生

1.2.1 DQN 的历史沿革

1.2.2 DQN 相对于传统 Q-learning 的改进

1.2.3 DQN 在 Atari 游戏中的突破性表现

1.3 DQN 的应用现状

1.3.1 DQN 在游戏领域的应用

1.3.2 DQN 在机器人控制领域的应用

1.3.3 DQN 在其他领域的拓展应用

2. 核心概念与联系

2.1 马尔可夫决策过程(MDP)

2.1.1 MDP 的定义与组成要素

2.1.2 MDP 的贝尔曼方程

2.1.3 MDP 与强化学习的关系

2.2 Q-learning

2.2.1 Q-learning 的核心思想

2.2.2 Q-learning 的更新公式

2.2.3 Q-learning 的收敛性证明

2.3 DQN 中的核心概念

2.3.1 经验回放(Experience Replay)

2.3.2 目标网络(Target Network)

2.3.3 ε-贪婪探索(ε-Greedy Exploration)

2.4 DQN 与 Q-learning 的联系与区别

2.4.1 相同点：均基于 Q-learning 框架

2.4.2 不同点：DQN 引入了深度神经网络逼近 Q 函数

2.4.3 不同点：DQN 引入了经验回放与目标网络稳定训练

3. 核心算法原理具体操作步骤

3.1 DQN 的整体架构

3.1.1 DQN 的网络结构设计

3.1.2 DQN 的前向传播过程

3.1.3 DQN 的训练流程概述

3.2 DQN 算法步骤详解

3.2.1 初始化经验回放缓存 D

3.2.2 随机初始化动作值函数 Q 的参数 θ

3.2.3 初始化状态 s

3.2.4 在每个时间步 t 执行以下操作：

3.2.4.1 ε-贪婪策略选择动作 a

3.2.4.2 执行动作 a，观察奖励 r 和下一状态 s'

3.2.4.3 将转移(s,a,r,s') 存储到 D 中

3.2.4.4 从 D 中随机采样一个小批量的转移

3.2.4.5 对于终止状态，令 y = r

3.2.4.6 对于非终止状态，令 y = r + γ max_{a'} Q(s', a'; θ^-)

3.2.4.7 通过梯度下降法更新参数 θ

3.2.4.8 每隔 C 个步骤将 θ 的值复制给 θ^-

3.2.5 重复 3.2.4 直至收敛

3.3 DQN 算法的伪代码

4. 数学模型和公式详细讲解举例说明

4.1 状态-动作值函数的定义

$Q(s,a) = \mathbb{E}[R_t|s_t=s, a_t=a, π]$

其中 $R_t$ 是从时刻 t 到终止状态获得的累计奖励，$π$ 是当前的策略。

4.2 Q-learning 的策略迭代过程

Q-learning 使用如下公式迭代地更新状态-动作值函数： $$ Q(s_t,a_t) \leftarrow Q(s_t,a_t) + \alpha [r_{t+1} + \gamma \max_{a} Q(s_{t+1}, a) - Q(s_t,a_t)] $$ 其中 $\alpha$ 是学习率，$\gamma$ 是折扣因子。

4.3 DQN 的损失函数

DQN 网络的损失函数为均方误差损失： $$ L(\theta_i) = \mathbb{E}{(s,a,s',r) \sim D} [(r+ \gamma \max{a'} Q(s', a'; \theta_i^-) - Q(s,a;\theta_i))^2] $$ 其中 $\theta_i$ 是当前时刻 Q 网络的参数，$\theta_i^-$ 是目标网络的参数。

4.4 DQN 的经验回放过程

经验回放通过缓存转移(s,a,r,s')并从中随机抽样来训练网络，形式化表示为： $$ D \leftarrow D \cup {(s_t, a_t, r_t, s_{t+1})} $$ $$ {(s_i, a_i, r_i, s_{i+1})}_{i=1}^{batch_size} \sim U(D) $$

4.5 DQN 的目标网络更新

DQN 每隔 C 个步骤将当前 Q 网络的参数 $\theta$ 复制给目标网络的参数 $\theta^-$： $$ \theta^- \leftarrow \theta \quad \text{every C steps} $$

5. 项目实践：代码实例和详细解释说明

5.1 DQN 的 PyTorch 实现

5.1.1 导入依赖库

import torch
import torch.nn as nn
import torch.optim as optim
import numpy as np
import collections

5.1.2 定义 Q 网络

class DQN(nn.Module):
    def __init__(self, state_size, action_size):
        super(DQN, self).__init__()
        self.fc1 = nn.Linear(state_size, 64)
        self.relu = nn.ReLU()
        self.fc2 = nn.Linear(64, 64)
        self.fc3 = nn.Linear(64, action_size)

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

5.1.3 定义经验回放缓存

Transition = collections.namedtuple('Transition', 
                                    ('state', 'action', 'reward', 'next_state'))

class ReplayBuffer:
    def __init__(self, capacity):
        self.buffer = collections.deque(maxlen=capacity)

    def push(self, *args):
        self.buffer.append(Transition(*args))

    def sample(self, batch_size):
        indices = np.random.choice(len(self.buffer), batch_size, replace=False)
        states, actions, rewards, next_states = zip(*[self.buffer[idx] for idx in indices])
        return np.array(states), np.array(actions), np.array(rewards), np.array(next_states)

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

5.1.4 定义 DQN Agent

class DQNAgent:
    def __init__(self, state_size, action_size):
        self.state_size = state_size
        self.action_size = action_size
        self.gamma = 0.95
        self.epsilon = 1.0
        self.epsilon_min = 0.01
        self.epsilon_decay = 0.995
        self.learning_rate = 0.001
        self.memory = ReplayBuffer(10000)
        self.batch_size = 64
        self.device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
        self.model = DQN(state_size, action_size).to(self.device)
        self.target_model = DQN(state_size, action_size).to(self.device)
        self.optimizer = optim.Adam(self.model.parameters())
        self.update_target_model()

    def update_target_model(self):
        self.target_model.load_state_dict(self.model.state_dict())

    def select_action(self, state):
        if np.random.rand() <= self.epsilon:
            return np.random.choice(self.action_size)
        else:
            state = torch.FloatTensor(state).unsqueeze(0).to(self.device) 
            q_value = self.model(state)
            action = q_value.max(1)[1].item()
            return action

    def train_model(self):
        if len(self.memory) < self.batch_size:
            return
        states, actions, rewards, next_states = self.memory.sample(self.batch_size)
        states = torch.FloatTensor(states).to(self.device)
        actions = torch.LongTensor(actions).unsqueeze(1).to(self.device)
        rewards = torch.FloatTensor(rewards).unsqueeze(1).to(self.device)
        next_states = torch.FloatTensor(next_states).to(self.device)

        q_values = self.model(states).gather(1, actions)
        next_q_values = self.target_model(next_states).max(1)[0].unsqueeze(1)
        expected_q_values = rewards + self.gamma * next_q_values

        loss = nn.MSELoss()(q_values, expected_q_values)
        self.optimizer.zero_grad()
        loss.backward()
        self.optimizer.step()

        if self.epsilon > self.epsilon_min:
            self.epsilon *= self.epsilon_decay

5.1.5 完整训练流程

def train_dqn(env, agent, num_episodes):
    for episode in range(num_episodes):
        state = env.reset()
        episode_reward = 0

        while True:
            action = agent.select_action(state)
            next_state, reward, done, _ = env.step(action)
            agent.memory.push(state, action, reward, next_state)
            episode_reward += reward

            if done:
                print("Episode: {}, Reward: {}".format(episode + 1, episode_reward))
                break

            agent.train_model()

            state = next_state

        if episode % 10 == 0:
            agent.update_target_model()

5.2 完整训练过程解释

初始化 DQN Agent，包括 Q 网络和目标网络，以及经验回放缓存。
对于每个 episode：
- 重置环境，获得初始状态。
- 使用 ε-贪婪策略选择动作，执行动作并观察奖励和下一状态。
- 将(state, action, reward, next_state)存储到经验回放缓存中。
- 从经验回放缓存中随机采样一个批量的转移数据。
- 通过 Q 网络和目标网络计算 TD 误差，并最小化均方误差损失来更新 Q 网络的参数。
- 每隔一定的 episode 数量更新目标网络的参数。
重复步骤 2，直至训练完所有的 episode。