0
0

开启深度强化学习之路：Deep Q-Networks简介和代码示例

强化学习是机器学习领域的热门子项。由于 OpenAI 和 AlphaGo 等公司的最新突破，强化学习引起了游戏行业许多人的注意。我们今天以Hill Climb Racing这款经典的游戏来介绍DQN的整个概念，Hill Climb Racing需要玩家在不同的地形上驾驶不同的车辆，驾驶距离越长得分越高。

在本篇文章中将通过这个游戏的示例来介绍 Deep Q-Networks 的整个概念，但是因为没有环境所以我们会将其分解成2个独立目标分别实现。如果曾经接触过此类游戏，你可能已经观察到游戏的两个主要目标：1、不要碰撞，2、保持前进。

我们将这两个目标分解成我们的需要的做动作：1、保持平衡，2、爬坡，当然还有一些附加项，例如吃分获取奖励，但是这个并不是我们的主要目标。

在我们深入解决这些问题之前，首先介绍一下解强化学习和DQN的基础知识。

我们先快速介绍一下什么是强化学习，在这种学习中行为主体对环境所做的行动会根据其结果得到奖励。奖励会影响主体（代理、智能体）未来的行为。

  • 有利的行动，更多的奖励（积极的）。
  • 不利的行动，较少的奖励或者惩罚（在某些情况下是负面的）。

Deep Q-Learning 算法是深度强化学习的核心概念之一。神经网络将输入状态映射到（动作，Q 值）对。

  • 动作Action：代理执行的对环境进行后续更改的活动。
  • 环境Environment：模型工作的整个状态空间。
  • 奖励Rewards：为模型提供的每个动作的反馈。
  • Q 值Q-value：估计的最优未来值。

Q-Learning 和 Deep Q-Networks 是无模型算法，因为它们不创建环境转换函数的模型。

由于 DQN 是一种无模型算法，我们将构建一个与问题中提到的环境兼容的代理。

  1. class Agent:
  2.     def __init__(self, state_size, action_size):
  3.         self.state_size = state_size
  4.         self.action_size = action_size
  5.         self.memory = deque(maxlen=2000)
  6.         self.gamma = 0.95
  7.         self.epsilon = 1.0
  8.         self.epsilon_decay = 0.995
  9.         self.epsilon_min = 0.01
  10.         self.learning_rate = 0.001
  11.         self.model = self._create_model()
  13.     def _create_model(self):
  14.         model = Sequential()
  15.         model.add(Dense(24, input_dim=self.state_size, activation='relu'))
  16.         model.add(Dense(24, activation='relu'))
  17.         model.add(Dense(self.action_size, activation='linear'))
  18.         model.compile(loss='mse', optimizer=Adam(lr=self.learning_rate))
  19.         return model
  20.     
  21.     def remember(self, state, action, reward, next_state, done):
  22.         self.memory.append((state, action, reward, next_state, done))
  24.     def act(self, state):
  25.         if np.random.rand() <= self.epsilon:
  26.             return random.randrange(self.action_size)
  27.         act_values = self.model.predict(state)
  28.         return np.argmax(act_values[0])
  30.     def train(self, batch_size= 32):
  31.         minibatch = random.sample(self.memory, batch_size)
  32.         for state, action, reward, next_state, done in minibatch:
  33.             if not done:
  34.                 target = reward + self.gamma*np.amax(self.model.predict(next_state)[0])
  35.             else:
  36.                 target = reward
  37.             target_f = self.model.predict(state)
  38.             target_f[0][action] = target
  39.             self.model.fit(state, target_f, epochs=1, verbose=0)
  40.         if self.epsilon > self.epsilon_min:
  41.             self.epsilon *= self.epsilon_decay
  42.     
  43.     def load(self, name):
  44.         self.model.load_weights(name)
  45.     def save(self, name):
  46.         self.model.save_weights(name)

在这里我们使用了一个小型网络（带有两个隐藏层）。输入大小是指状态的数量，输出大小对应于动作空间的数量。

Cartpole 平衡

CartPole 或通常称为反摆/倒立摆，它是一种简单的训练环境，目标是向左或向右移动推车以平衡直立杆。在这篇文章中，我们将使用 OpenAI 的gym库提供的模拟环境。

在这个环境中，我们有离散的动作空间和连续的状态空间，如下所示：

动作空间（离散）

  • 1 单位力向左。
  • 1 单位力向右。

状态空间（连续）

  • 小车位置。
  • 小车速度。
  • 车杆角度
  • 极点速度 （pole velocity）。

我们的代理必须尽可能长时间地平衡极点以获取最大化奖励。对于每个成功的时间步，模型都会获得 +1 奖励。我们设定停止的规则：如果车杆远离中心 2.4 个单位或垂直偏离超过 15 度，则本次迭代结束。通过模拟 1000 次更新并在每 50 次迭代后保存最佳权重进行代理的训练。

  1. agent = Agent(state_size, action_size) # initialise agent
  2. done = False
  3. for e in range(n_episodes):
  4.     state = env.reset()
  5.     state = np.reshape(state,[1,state_size])
  6.     
  7.     for time in range(5000):
  8.         env.render()
  9.         action = agent.act(state) #action is 0 or 1
  10.         next_state,reward,done,other_info = env.step(action) 
  11.         reward = reward if not done else -10
  12.         next_state = np.reshape(next_state,[1,state_size])
  13.         agent.remember(state,action,reward,next_state,done)
  14.         state = next_state
  15.         
  16.         if done:
  17.             print("Game Episode :{}/{}, High Score:{},Exploration Rate:{:.2}".format(e,n_episodes,time,agent.epsilon))
  18.             break
  19.             
  20.     if len(agent.memory)>batch_size:
  21.         agent.train(batch_size)
  22.     
  23.     if e%50==0:
  24.         agent.save(output_dir+"weights_"+'{:04d}'.format(e)+".hdf5")
  25.         
  26. env.close()

代理在前 250 次迭代内解决了问题，在第199次迭代中取得了稳定高分。我们已经解决了平衡问题。现在需要学习学习如何前进并爬上山坡的时候了。

爬坡

一辆动力不足的车如果想要登上陡峭的山顶，应该使用对面的另一座山，来回行驶以建立所需的动力。

与CartPole相似，该环境也包括离散的动作空间和连续的状态空间。

动作空间（离散）

  • 在汽车的左方向施加 1 个单位的力。
  • 什么都不做。
  • 在汽车的右方向施加 1 个单位的力。

状态空间（连续）

  • 汽车位置
  • 汽车速度

一般情况下汽车在达到目标（由旗帜标记）时会获得 +100 的奖励。如果在汽车达到成功状态之前，不给予奖励积分，汽车随机到达目标的可能性很小。

所以我们将用另一个奖励条件来激励汽车。山谷最底部的坐标为 -0.4（OpenAI 提供的标准），而目标的坐标为 +0.5，我们将使用汽车垂直高度按比例进行奖励。高度越高，奖励越多。（注：在山谷的两侧高度都进行奖励）

让我们看一下我们将在环境中使用的奖励机制和训练函数。

  1. def get_reward(state):
  3.     if state[0] >= 0.5:
  4.         print("Car has reached the goal")
  5.         return 10
  6.     if state[0] > -0.4:
  7.         return (1+state[0])**2
  8.     return 0
  9.   
  10.   #--------------------------------------------------------------------------#
  11.   
  12.   def train_dqn(episode):
  14.     loss = []
  15.     agent = DQN(env.action_space.n, env.observation_space.shape[0])
  16.     for e in range(episode):
  17.         state = env.reset()
  18.         state = np.reshape(state, (1, 2))
  19.         score = 0
  20.         max_steps = 3000
  21.         for i in range(max_steps):
  22.             action = agent.act(state)
  23.             env.render()
  24.             next_state, reward, done, _ = env.step(action)
  25.             reward = get_reward(next_state)
  26.             score += reward
  27.             next_state = np.reshape(next_state, (1, 2))
  28.             agent.remember(state, action, reward, next_state, done)
  29.             state = next_state
  30.             agent.replay()
  31.             if done:
  32.                 print("episode: {}/{}, score: {}".format(e, episode, score))
  33.                 break
  34.         loss.append(score)
  35.     return loss

在我们的环境中，汽车能够多次达到目标！汽车在训练的过程中第 60、71、74 和 79 次迭代达到了成功状态。

我们还可以使用得分图上的峰值来验证它。

我们已经解决了上面提到的两个问题。虽然将其集成到实际游戏中目前看还是不可能的（因为Hill Climb Racing并没有为我们提供环境），但是如果你有什么好的方案可以尝试一下。

总结

经典的控制问题奠定了当今大多数顶级游戏的强化学习的基础。而OpenAI 的GYM库也为我们提供了更多环境。如果你对其他的环境感兴趣，可以参考GYM的文档，或者看看本文提供的两个例子的源代码。

https://github.com/DSCVITBHOPAL/ML-Reserve/tree/main/CartPole%20Balancing

https://github.com/DSCVITBHOPAL/ML-Reserve/tree/main/Mountain%20Climbing

作者：Sidhved Warik

标签： 深度学习 强化学习 DQN
登录后发布评论

“开启深度强化学习之路：Deep Q-Networks简介和代码示例”的评论:

还没有评论
关于作者
...
Deephub
更多文章请关注公众号：Deephub-IMBA
相关阅读

标签噪声下的模型评估：如何准确评估AI模型的真实性能，提高模型性能测量的可信度

VideoMind：Chain-of-LoRA突破时间盲区让AI真正看懂长视频

9个主流GAN损失函数的数学原理和Pytorch代码实现：从经典模型到现代变体

DAPO: 面向开源大语言模型的解耦裁剪与动态采样策略优化系统

多模态AI核心技术：CLIP与SigLIP技术原理与应用进展

SWEET-RL：基于训练时信息的多轮LLM代理强化学习框架

时间序列异常检测：MSET-SPRT组合方法的原理和Python代码实现