[强化学习总结4] DQN

目录

0 网络

0.1 输入输出

1 损失函数：

1.1 回顾：最优策略、贝尔曼最优方程

1.2 label

2 训练方式

3 具体流程

3.1 为什么训练的时候只需要（状态、动作、奖励、下一状态）？

3.2 探索的时候是epsilon-greedy

代码

---

图出处：Double DQN原理是什么，怎样实现？（附代码） - 知乎

0 网络

0.1 输入输出

输入是s，输出是每个a的概率。s是连续的，a是离散（可遍历的）的。

1 损失函数：

• q-learning的更新：
  • 可以看到更新的是q(s,a)的值，因为我们就是要估计当前的value啊。所以下面q网络的预测是q(s,a),label是r+gammaQ(s'|a').

• • 其实根据贝尔曼最优公式，就可以得到：
    • 所以这里的预测值是q(s,a)

1.1 回顾：最优策略、贝尔曼最优方程

• 强化学习的目标通常是找到一个策略，使得智能体从初始状态出发能获得最多的期望回报。这个策略就是最优策略（optimal policy）。
• 最优状态价值是选择此时使最优动作价值最大的那一个动作时的状态价值：
  • 注意，这个时候v就等于q了。
  • 其实，最优的策略，就是return最大的那个trajectory（路径），。

• • 所以：

1.2 label

其实根据贝尔曼最优方程也可以知道，label是

因为，这个在公式右边，因为他是在变的。

2 训练方式

• 交替训练的方式，两个一模一样的网络（不是孪生网络，因为进行多步以后才会更新目标网络），一个用于计算label值(r+lammbda*q(s'|a'))，一个用于预测，然后将两个网络的输出值计算MSE loss（并梯度下降）。

3 具体流程

• 其实不难，可以看到其实和q-learning是一样的，只是将原来的q(s,a)更新方式，改成了基于贝尔曼最优公式得到的loss。让q(s,a)拟合i+1步得到的r+gamma*q(s',a')
• 可以发现其实有两个步骤，先把数据存起来，然后再进行计算loss：
  • 在原来的 Q-learning 算法中，每一个数据只会用来更新一次值。为了更好地将 Q-learning 和深度神经网络结合，DQN 算法采用了经验回放（experience replay）方法，具体做法为维护一个回放缓冲区，将每次从环境中采样得到的四元组数据（状态、动作、奖励、下一状态）存储到回放缓冲区中，训练 Q 网络的时候再从回放缓冲区中随机采样若干数据来进行训练。

3.1 为什么训练的时候只需要（状态、动作、奖励、下一状态）？

因为，q-learning计算最优价值的时候，只选择（greedy贪心的选）最优的action（基于贝尔曼最优方程），所以不需要下一个状态的动作，因为最大action是哪个是已知的，。

3.2 探索的时候是epsilon-greedy

而行动时候时候是需要一定概率的探索。

代码

出自：《动手学强化学习》：DQN 算法

import random
import gym
import numpy as np
import collections
from tqdm import tqdm
import torch
import torch.nn.functional as F
import matplotlib.pyplot as plt
import rl_utils

class ReplayBuffer:
    ''' 经验回放池 '''
    def __init__(self, capacity):
        self.buffer = collections.deque(maxlen=capacity)  # 队列,先进先出

    def add(self, state, action, reward, next_state, done):  # 将数据加入buffer
        self.buffer.append((state, action, reward, next_state, done))

    def sample(self, batch_size):  # 从buffer中采样数据,数量为batch_size
        transitions = random.sample(self.buffer, batch_size)
        state, action, reward, next_state, done = zip(*transitions)
        return np.array(state), action, reward, np.array(next_state), done

    def size(self):  # 目前buffer中数据的数量
        return len(self.buffer)

class Qnet(torch.nn.Module):
    ''' 只有一层隐藏层的Q网络 '''

    def __init__(self, state_dim, hidden_dim, action_dim):
        super(Qnet, self).__init__()
        self.fc1 = torch.nn.Linear(state_dim, hidden_dim)
        self.fc2 = torch.nn.Linear(hidden_dim, action_dim)

    def forward(self, x):
        x = F.relu(self.fc1(x))  # 隐藏层使用ReLU激活函数
        return self.fc2(x)

class DQN:
    ''' DQN算法 '''
    def __init__(self, state_dim, hidden_dim, action_dim, learning_rate, gamma,
                 epsilon, target_update, device):
        self.action_dim = action_dim
        self.q_net = Qnet(state_dim, hidden_dim,
                          self.action_dim).to(device)  # Q网络
        # 目标网络，label
        self.target_q_net = Qnet(state_dim, hidden_dim,
                                 self.action_dim).to(device)
        # 使用Adam优化器
        self.optimizer = torch.optim.Adam(self.q_net.parameters(),
                                          lr=learning_rate)
        self.gamma = gamma  # 折扣因子
        self.epsilon = epsilon  # epsilon-贪婪策略
        self.target_update = target_update  # 目标网络更新频率
        self.count = 0  # 计数器,记录更新次数
        self.device = device

    def take_action(self, state):  # epsilon-贪婪策略采取动作
        if np.random.random() < self.epsilon:
            action = np.random.randint(self.action_dim)
        else:
            state = torch.tensor([state], dtype=torch.float).to(self.device)
            action = self.q_net(state).argmax().item()
        return action

    def update(self, transition_dict):
        states = torch.tensor(transition_dict['states'],
                              dtype=torch.float).to(self.device)
        actions = torch.tensor(transition_dict['actions']).view(-1, 1).to(
            self.device)
        rewards = torch.tensor(transition_dict['rewards'],
                               dtype=torch.float).view(-1, 1).to(self.device)
        next_states = torch.tensor(transition_dict['next_states'],
                                   dtype=torch.float).to(self.device)
        dones = torch.tensor(transition_dict['dones'],
                             dtype=torch.float).view(-1, 1).to(self.device)

        q_values = self.q_net(states).gather(1, actions)  # Q值
        # 下个状态的最大Q值
        max_next_q_values = self.target_q_net(next_states).max(1)[0].view(
            -1, 1)
        q_targets = rewards + self.gamma * max_next_q_values * (1 - dones
                                                                )  # TD误差目标
        dqn_loss = torch.mean(F.mse_loss(q_values, q_targets))  # 均方误差损失函数
        self.optimizer.zero_grad()  # PyTorch中默认梯度会累积,这里需要显式将梯度置为0
        dqn_loss.backward()  # 反向传播更新参数
        self.optimizer.step()

        if self.count % self.target_update == 0:
            self.target_q_net.load_state_dict(
                self.q_net.state_dict())  # 更新目标网络
        self.count += 1

lr = 0.001
num_episodes = 500
hidden_dim = 128
gamma = 0.99 ## 要远视一点
epsilon = 0.1 ## 探索需要充分，不然后期有可能会出现错误的策略，所以最好的策略是前期多探索，后期少探索（这样可以更快的找到最优的路线）。
target_update = 10
buffer_size = 10000
minimal_size = 500
batch_size = 64
device = torch.device("cuda") if torch.cuda.is_available() else torch.device(
    "cpu")

env_name = 'CartPole-v0'
env = gym.make(env_name)
random.seed(0)
np.random.seed(0)
env.seed(0)
torch.manual_seed(0)
replay_buffer = ReplayBuffer(buffer_size)
state_dim = env.observation_space.shape[0]
action_dim = env.action_space.n
agent = DQN(state_dim, hidden_dim, action_dim, lr, gamma, epsilon,
            target_update, device)

return_list = []
for i in range(10):
    with tqdm(total=int(num_episodes / 10), desc='Iteration %d' % i) as pbar:
        for i_episode in range(int(num_episodes / 10)):
            episode_return = 0
            state = env.reset()
            done = False
            while not done:
                action = agent.take_action(state)
                next_state, reward, done, _ = env.step(action)
                replay_buffer.add(state, action, reward, next_state, done)
                state = next_state
                episode_return += reward
                # 当buffer数据的数量超过一定值后,才进行Q网络训练
                if replay_buffer.size() > minimal_size:
                    b_s, b_a, b_r, b_ns, b_d = replay_buffer.sample(batch_size)
                    transition_dict = {
                        'states': b_s,
                        'actions': b_a,
                        'next_states': b_ns,
                        'rewards': b_r,
                        'dones': b_d
                    }
                    agent.update(transition_dict)
            return_list.append(episode_return)
            if (i_episode + 1) % 10 == 0:
                pbar.set_postfix({
                    'episode':
                    '%d' % (num_episodes / 10 * i + i_episode + 1),
                    'return':
                    '%.3f' % np.mean(return_list[-10:])
                })
            pbar.update(1)

episodes_list = list(range(len(return_list)))
plt.plot(episodes_list, return_list)
plt.xlabel('Episodes')
plt.ylabel('Returns')
plt.title('DQN on {}'.format(env_name))
plt.show()

mv_return = rl_utils.moving_average(return_list, 9)
plt.plot(episodes_list, mv_return)
plt.xlabel('Episodes')
plt.ylabel('Returns')
plt.title('DQN on {}'.format(env_name))
plt.show()