强化学习代码实践1.DDQN:在CartPole游戏中实现 Double DQN

在 CartPole 游戏中实现 Double DQN（DDQN）训练网络时，我们必要构建一个使用两个 Q 网络（一个用于选择动作，另一个用于更新目标）的方法。Double DQN 通过引入目标网络来减少 Q-learning 中太过估计的偏差。
下面是一个基于 PyTorch 的 Double DQN 实现：
1. 导入依靠

1. import random
2. import torch
3. import torch.nn as nn
4. import torch.optim as optim
5. import numpy as np
6. import gym
7. from collections import deque

复制代码

2. 定义 Q 网络

我们必要定义一个 Q 网络，用于盘算 Q 值。这里使用简单的全毗连网络。

1. class QNetwork(nn.Module):
2.     def __init__(self, state_dim, action_dim):
3.         super(QNetwork, self).__init__()
4.         self.fc1 = nn.Linear(state_dim, 128)
5.         self.fc2 = nn.Linear(128, 128)
6.         self.fc3 = nn.Linear(128, action_dim)
8.     def forward(self, x):
9.         x = torch.relu(self.fc1(x))
10.         x = torch.relu(self.fc2(x))
11.         return self.fc3(x)

复制代码

3. 创建 Agent

1. class DoubleDQNAgent:
2.     def __init__(self, state_dim, action_dim, gamma=0.99, epsilon=0.1, epsilon_decay=0.995, epsilon_min=0.01, lr=0.0005):
3.         self.state_dim = state_dim
4.         self.action_dim = action_dim
5.         self.gamma = gamma
6.         self.epsilon = epsilon
7.         self.epsilon_decay = epsilon_decay
8.         self.epsilon_min = epsilon_min
9.         self.lr = lr
11.         self.q_network = QNetwork(state_dim, action_dim)
12.         self.target_network = QNetwork(state_dim, action_dim)
13.         self.target_network.load_state_dict(self.q_network.state_dict())
14.         self.optimizer = optim.Adam(self.q_network.parameters(), lr=self.lr)
16.         self.memory = deque(maxlen=10000)
17.         self.batch_size = 64
19.     def select_action(self, state):
20.         if random.random() < self.epsilon:
21.             return random.choice(range(self.action_dim))  # Explore
22.         else:
23.             state = torch.FloatTensor(state).unsqueeze(0)
24.             with torch.no_grad():
25.                 q_values = self.q_network(state)
26.             return torch.argmax(q_values).item()  # Exploit
28.     def store_experience(self, state, action, reward, next_state, done):
29.         self.memory.append((state, action, reward, next_state, done))
31.     def sample_batch(self):
32.         return random.sample(self.memory, self.batch_size)
34.     def update_target_network(self):
35.         self.target_network.load_state_dict(self.q_network.state_dict())
37.     def train(self):
38.         if len(self.memory) < self.batch_size:
39.             return
41.         batch = self.sample_batch()
42.         states, actions, rewards, next_states, dones = zip(*batch)
44.         states = torch.FloatTensor(states)
45.         actions = torch.LongTensor(actions)
46.         rewards = torch.FloatTensor(rewards)
47.         next_states = torch.FloatTensor(next_states)
48.         dones = torch.FloatTensor(dones)
50.         # Q values for current states
51.         q_values = self.q_network(states)
52.         q_values = q_values.gather(1, actions.unsqueeze(1)).squeeze(1)
54.         # Next Q values using target network
55.         next_q_values = self.target_network(next_states)
56.         next_actions = self.q_network(next_states).argmax(1)
57.         next_q_values = next_q_values.gather(1, next_actions.unsqueeze(1)).squeeze(1)
59.         # Double DQN update
60.         target = rewards + (1 - dones) * self.gamma * next_q_values
62.         # Compute loss
63.         loss = nn.MSELoss()(q_values, target)
65.         # Optimize the Q-network
66.         self.optimizer.zero_grad()
67.         loss.backward()
68.         self.optimizer.step()
70.         if self.epsilon > self.epsilon_min:
71.             self.epsilon *= self.epsilon_decay

复制代码

4. 训练过程

1. def train_cartpole():
2.     env = gym.make('CartPole-v1')
3.     agent = DoubleDQNAgent(state_dim=env.observation_space.shape[0], action_dim=env.action_space.n)
5.     episodes = 1000
6.     for episode in range(episodes):
7.         state, info = env.reset()
8.         done = False
9.         total_reward = 0
11.         while not done:
12.             action = agent.select_action(state)
13.             next_state, reward, done, truncated, info = env.step(action)
14.             agent.store_experience(state, action, reward, next_state, done)
15.             state = next_state
17.             agent.train()
18.             total_reward += reward
20.         agent.update_target_network()
22.         print(f"Episode {episode}, Total Reward: {total_reward}, Epsilon: {agent.epsilon:.4f}")
24.     env.close()
26. if __name__ == '__main__':
27.     train_cartpole()

复制代码

5. 表明

• QNetwork: 使用一个简单的 3 层全毗连神经网络来近似 Q 函数。
  
• DoubleDQNAgent:
  
  
  
  • select_action: 根据 ε-greedy 策略选择动作。
    
  • store_experience: 存储履历回放。
    
  • sample_batch: 从记忆中随机采样批次。
    
  • train: 更新 Q 网络的权重，使用 Double DQN 的目标盘算方法。
    
  • update_target_network: 每一定步数更新目标网络。
    
  
  
• 训练过程: 在每一回合中，署理与情况互动并更新 Q 网络，通过履历回放机制逐步学习。
  

6. 调整超参数

• gamma: 扣头因子，控制未来嘉奖的影响。
  
• epsilon: 初始的探索率，随着训练的举行逐渐减小。
  
• lr: 学习率，控制权重更新的步伐。
  
• batch_size: 每次更新时，从记忆库中采样的批量巨细。
  

这个代码可以直接用于训练一个 CartPole 的 Double DQN 署理，逐步优化 Q 网络来完成游戏使命。假如你有更复杂的需求，像更深的网络结构或其他改进，可以在此基础上进一步扩展。

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。