本篇文章是博主强化学习RL领域学习时，用于个人学习、研究或者欣赏使用，并基于博主对相关等领域的一些理解而记录的学习摘录和笔记，若有不当和侵权之处，指出后将会立即改正，还望谅解。文章强化学习：

       强化学习（2）---《【DRL】深度强化学习介绍》

【DRL】深度强化学习介绍

目录

1 深度Q网络（DQN）

DQN的更新步骤

2 策略梯度方法

REINFORCE算法

演员-评论家（Actor-Critic）

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

[Python] 深度Q网络（DQN）实现

[Python] REINFORCE算法实现

[Results] 运行结果

[Notice]  注意事项

        随着深度学习的迅猛发展，深度强化学习（Deep Reinforcement Learning, DRL）将深度学习与强化学习相结合，使得处理高维状态空间成为可能。

1 深度Q网络（DQN）

        深度Q网络使用神经网络来近似Q值函数。DQN引入了经验重放（Experience Replay）和目标网络（Target Network）来提高学习稳定性和效率。

DQN的更新步骤

从经验池中随机抽取一个小批量的经验。更新Q值函数，使用最小化均方误差（MSE）的方法。

其中

，

是目标网络的参数。

2 策略梯度方法

REINFORCE算法

REINFORCE是一种基于蒙特卡罗方法的策略梯度算法，它通过直接对策略进行参数化来优化期望回报。对于给定状态 ( s ) 和动作 ( a )，更新规则如下：

其中：

是目标函数，表示期望累计奖励。

是从时间步 ( t ) 开始的回报。

是在状态 ( s ) 下选择动作 ( a ) 的策略。

这种方法的优势在于它可以处理高维的动作空间，但通常收敛速度较慢。

演员-评论家（Actor-Critic）

        演员-评论家方法结合了值函数和策略优化。演员负责生成动作，而评论家则评估这些动作的质量。更新过程同时优化策略和价值估计。

演员更新：通过策略梯度法来调整策略。评论家更新：使用时序差分方法更新值函数。

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

        深度强化学习的优势在于能有效处理复杂、高维的状态空间，如图像和语音等。然而，它也面临着一些挑战，例如：

样本效率低：需要大量的交互样本来训练模型。收敛性问题：在某些情况下，可能会出现不稳定或不收敛的问题。超参数调优：需要仔细设置学习率、折扣因子等超参数。

[Python] 深度Q网络（DQN）实现

<code>""" 深度Q网络（DQN）实现

时间：2024.07.27

环境：gym-CartPole-v1

作者：不去幼儿园

"""

import gym

import torch

import torch.nn as nn

import torch.optim as optim

import random

import numpy as np

from collections import deque

# 定义Q网络

class QNetwork(nn.Module):

def __init__(self, state_size, action_size):

super(QNetwork, self).__init__()

# 第一层全连接层，将输入状态映射到64个隐藏单元

self.fc1 = nn.Linear(state_size, 64)

# 第二层全连接层，将64个隐藏单元映射到另一个64个隐藏单元

self.fc2 = nn.Linear(64, 64)

# 输出层，将隐藏单元映射到动作空间的大小

self.fc3 = nn.Linear(64, action_size)

def forward(self, x):

# 前向传播：使用ReLU激活函数

x = torch.relu(self.fc1(x))

x = torch.relu(self.fc2(x))

return self.fc3(x)

# DQN代理

class DQNAgent:

def __init__(self, state_size, action_size):

self.state_size = state_size # 状态空间的大小

self.action_size = action_size # 动作空间的大小

# 初始化Q网络和目标Q网络

self.qnetwork = QNetwork(state_size, action_size)

self.target_qnetwork = QNetwork(state_size, action_size)

# 优化器使用Adam

self.optimizer = optim.Adam(self.qnetwork.parameters(), lr=0.001)

# 经验回放缓冲区，最大长度为2000

self.memory = deque(maxlen=2000)

self.gamma = 0.99 # 折扣因子

self.epsilon = 1.0 # 探索率

self.epsilon_decay = 0.995 # 探索率衰减

self.epsilon_min = 0.01 # 最小探索率

self.batch_size = 64 # 批次大小

self.update_target_every = 5 # 每5次更新目标网络

self.update_count = 0 # 更新计数器

def remember(self, state, action, reward, next_state, done):

# 将经验存储到记忆中

state = np.array(state, dtype=np.float32)

next_state = np.array(next_state, dtype=np.float32)

self.memory.append((state, action, reward, next_state, done))

def act(self, state):

# 使用epsilon-greedy策略选择动作

if np.random.rand() <= self.epsilon:

return random.choice(range(self.action_size)) # 随机选择动作

state = torch.FloatTensor(state).unsqueeze(0)

with torch.no_grad():

q_values = self.qnetwork(state)

return np.argmax(q_values.numpy()) # 选择Q值最大的动作

def replay(self):

# 经验回放

if len(self.memory) < self.batch_size:

return

batch = random.sample(self.memory, self.batch_size)

states, actions, rewards, next_states, dones = zip(*batch)

states = np.array(states, dtype=np.float32)

actions = np.array(actions)

rewards = np.array(rewards, dtype=np.float32)

next_states = np.array(next_states, dtype=np.float32)

dones = np.array(dones, dtype=np.float32)

states = torch.FloatTensor(states)

actions = torch.LongTensor(actions).unsqueeze(1)

rewards = torch.FloatTensor(rewards)

next_states = torch.FloatTensor(next_states)

dones = torch.FloatTensor(dones)

# 计算当前Q值

q_values = self.qnetwork(states).gather(1, actions).squeeze()

# 计算目标Q值

with torch.no_grad():

next_q_values = self.target_qnetwork(next_states).max(1)[0]

targets = rewards + (self.gamma * next_q_values * (1 - dones))

# 计算损失并进行反向传播

loss = nn.MSELoss()(q_values, targets)

self.optimizer.zero_grad()

loss.backward()

self.optimizer.step()

# 更新epsilon

if self.epsilon > self.epsilon_min:

self.epsilon *= self.epsilon_decay

self.update_count += 1

# 更新目标网络

if self.update_count % self.update_target_every == 0:

self.target_qnetwork.load_state_dict(self.qnetwork.state_dict())

# 训练DQN的主函数

def train_dqn(env_name, n_episodes=1000):

env = gym.make(env_name, render_mode="human") # 创建环境并设置渲染模式code>

agent = DQNAgent(env.observation_space.shape[0], env.action_space.n) # 初始化代理

for episode in range(n_episodes):

state, _ = env.reset() # 重置环境并获取初始状态

total_reward = 0

done = False

while not done:

action = agent.act(state) # 根据策略选择动作

step_result = env.step(action) # 执行动作

if len(step_result) == 5: # 如果返回5个值

next_state, reward, done, truncated, _ = step_result

else:

next_state, reward, done, _ = step_result

agent.remember(state, action, reward, next_state, done) # 存储经验

agent.replay() # 经验回放

state = next_state # 更新状态

total_reward += reward

# 每训练100轮显示一次运行界面

if (episode + 1) % 100 == 0:

env.render()

print(f"第 {episode + 1} 轮，总奖励: {total_reward}")

env.close() # 关闭环境

train_dqn('CartPole-v1') # 开始训练

[Python] REINFORCE算法实现