DQN算法

在Q-learning的学习过程中，我们需要维护一个 |S|x|A| 的Q表，当任务的状态空间和动作空间过大时，空间复杂度和时间复杂度都太高，为了解决这个问题，DQN采用神经网络来代替Q表，输入状态，预估该状态下采用不同动作的Q值
神经网络本身不是DQN的精髓，神经网络可以设计成MLP也可以设计成CNN等等，DQN的巧妙之处在于两个网络、经验回放等trick
 
Trick 1：两个网络

DQN算法采用了2个神经网络，分别是evaluate network（Q值网络）和target network（目标网络），两个网络结构完全相同：

• evaluate network用用来计算策略选择的Q值和Q值迭代更新，梯度下降、反向传播的也是evaluate network
  
• target network用来计算TD Target中下一状态的Q值，网络参数更新来自evaluate network网络参数复制
  

 设计target network目的是为了保持目标值稳定，防止过拟合，从而提高训练过程稳定和收敛速度
 
Trick 2：经验回放Experience Replay

DQN算法设计了一个固定大小的记忆库memory，用来记录经验，经验是一条一条的observation或者说是transition，它表示成 [s, a, r,s′] ，含义是当前状态→当前状态采取的动作→获得的奖励→转移到下一个状态
一开始记忆库memory中没有经验，也没有训练evaluate network，积累了一定数量的经验之后，再开始训练evaluate network。记忆库memory中的经验可以是自己历史的经验（epsilon-greedy得到的经验），也可以学习其他人的经验。训练evaluate network的时候，是从记忆库memory中随机选择batch size大小的经验，喂给evaluate network
设计记忆库memory并且随机选择经验喂给evaluate network的技巧打破了相邻训练样本之间相关性，试着想下，状态→动作→奖励→下一个状态的循环是具有关联的，用相邻的样本连续训练evaluate network会带来网络过拟合泛化能力差的问题，而经验回放技巧增强了训练样本之间的独立性
 

1. import gym
2. import numpy as np
3. import torch
4. import torch.nn as nn
5. import torch.optim as optim
6. import random
7. from collections import deque
9. # 定义DQN网络
10. class DQN(nn.Module):
11.     def __init__(self, input_dim, output_dim):
12.         super(DQN, self).__init__()
13.         self.fc1 = nn.Linear(input_dim, 64)
14.         self.fc2 = nn.Linear(64, output_dim)
16.     def forward(self, x):
17.         x = torch.relu(self.fc1(x))
18.         x = self.fc2(x)
19.         return x
21. # 定义DQN智能体
22. class DQNAgent:
23.     def __init__(self, state_dim, action_dim):
24.         self.state_dim = state_dim
25.         self.action_dim = action_dim
26.         self.gamma = 0.99  # 折扣因子
27.         self.epsilon = 1.0  # 探索率
28.         self.epsilon_min = 0.01
29.         self.epsilon_decay = 0.995
30.         self.learning_rate = 0.001
31.         self.memory = deque(maxlen=2000)
32.         self.model = DQN(state_dim, action_dim)
33.         self.optimizer = optim.Adam(self.model.parameters(), lr=self.learning_rate)
34.         self.criterion = nn.MSELoss()
36.     def remember(self, state, action, reward, next_state, done):
37.         self.memory.append((state, action, reward, next_state, done))
39.     def act(self, state):
40.         if np.random.rand() <= self.epsilon:
41.             return random.randrange(self.action_dim)
42.         state = torch.FloatTensor(state).unsqueeze(0)
43.         q_values = self.model(state)
44.         action = torch.argmax(q_values, dim=1).item()
45.         return action
47.     def replay(self, batch_size):
48.         if len(self.memory) < batch_size:
49.             return
50.         minibatch = random.sample(self.memory, batch_size)
51.         for state, action, reward, next_state, done in minibatch:
52.             state = torch.FloatTensor(state).unsqueeze(0)
53.             next_state = torch.FloatTensor(next_state).unsqueeze(0)
54.             target = reward
55.             if not done:
56.                 target = (reward + self.gamma * torch.max(self.model(next_state)).item())
57.             target_f = self.model(state)
58.             target_f[0][action] = target
59.             self.optimizer.zero_grad()
60.             output = self.model(state)
61.             loss = self.criterion(output, target_f)
62.             loss.backward()
63.             self.optimizer.step()
64.         if self.epsilon > self.epsilon_min:
65.             self.epsilon *= self.epsilon_decay
67. # 训练函数
68. def train_dqn(agent, env, episodes=500, batch_size=32):
69.     for episode in range(episodes):
70.         state = env.reset()
71.         if isinstance(state, tuple):
72.             state = state[0]
73.         state = np.eye(env.observation_space.n)[state]
74.         total_reward = 0
75.         done = False
76.         while not done:
77.             action = agent.act(state)
78.             next_state, reward, terminated, truncated, info = env.step(action)
79.             done = terminated or truncated
80.             next_state = np.eye(env.observation_space.n)[next_state]
81.             agent.remember(state, action, reward, next_state, done)
82.             agent.replay(batch_size)
83.             state = next_state
84.             total_reward += reward
85.         print(f"Episode {episode + 1}: Total Reward = {total_reward}")
87. # 主函数
88. if __name__ == "__main__":
89.     env = gym.make('CliffWalking-v0')
90.     state_dim = env.observation_space.n
91.     action_dim = env.action_space.n
92.     agent = DQNAgent(state_dim, action_dim)
93.     train_dqn(agent, env)
94.     env.close()

复制代码

DQN 
参考资料

DQN基本概念和算法流程（附Pytorch代码）
 

来源：程序园用户自行投稿发布，如果侵权，请联系站长删除
免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！