强化学习之DQN（deep Q-network）算法

已于 2023-07-18 16:17:12 修改
阅读量2.3k 收藏 9
点赞数 2
分类专栏： 强化学习 文章标签： 算法
于 2023-07-18 10:36:49 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/niulinbiao/article/details/131779134
版权

一、简介

DQN算法是深度学习领域首次广泛应用于强化学习的算法模型之一。它于2013年由DeepMind公司的研究团队提出，通过将深度神经网络与经典的强化学习算法Q-learning结合，实现了对高维、连续状态空间的处理，具备了学习与规划的能力。

二、发展史

在DQN算法提出之前，强化学习中的经典算法主要是基于表格的Q学习算法。这些算法在处理简单的低维问题时表现出色，但随着状态和动作空间的增加，表格表示的存储和计算复杂度呈指数级增长。为了解决这个问题，研究人员开始探索使用函数逼近的方法，即使用参数化的函数代替表格。

之后，逐步发展出了一系列将深度学习应用于强化学习的算法。DQN算法是其中的一种。它是由Alex Krizhevsky等人在2013年提出的，是首个将深度学习与强化学习相结合的算法。DQN算法引入了经验回放和固定Q目标网络等技术，极大地提升了深度神经网络在强化学习中的性能。随后，DQN算法在Atari游戏中取得了比人类玩家更好的成绩，引起了广泛的关注和研究。

Q-learning：Q-learning是强化学习中的经典算法，由Watkins等人在1989年提出。它使用一个Q表格来存储状态和动作的价值，通过不断更新和探索来学习最优策略。然而，Q-learning算法在面对大规模状态空间时，无法扩展。

Deep Q-Network(DQN)：DQN算法在2013年由DeepMind团队提出，通过使用深度神经网络来逼近Q函数的值，解决了状态空间规模大的问题。该算法采用了两个关键技术：经验回放和固定Q目标网络。

经验回放：经验回放是DQN算法的核心思想之一，它的基本原理是将智能体的经验存储在一个回放记忆库中，然后随机从中抽样，利用这些经验进行模型更新。这样做的好处是避免了样本间的相关性，提高了模型的稳定性和收敛速度。

固定Q目标网络：DQN算法使用两个神经网络，一个是主网络(online network)，用于选择动作，并进行模型更新；另一个是目标网络(target network)，用于计算目标Q值。目标网络的参数固定一段时间，这样可以减少目标的波动，提高模型的稳定性。

三、算法公式

本质：Q-learning+深度神经网络 = DQN

3.1 Q-learning算法公式

在这里插入图片描述

Q-learning算法通过不断更新Q值来学习最优策略，其更新公式如下：

在这里插入图片描述

3.2 DQN算法公式：

在这里插入图片描述
在这里插入图片描述

DQN算法通过最小化Q函数的均方差损失来进行模型更新。其更新公式如下：
在这里插入图片描述

四、算法原理

DQN算法的原理是通过利用深度神经网络逼近Q函数的值，实现对高维、连续状态空间的处理。其核心思想是通过不断更新神经网络的参数，使其的输出Q值逼近真实的Q值，从而学习最优策略。

DQN算法的工作原理如下：

初始化：初始化主网络和目标网络的参数。

选择动作：根据当前状态s，使用ε-greedy策略选择动作a。

执行动作并观察回报：采取动作a，与环境交互，观察下一个状态s’和立即回报r。

存储经验：将(s, a, r, s’)存储到经验回放记忆库中。

从经验回放记忆库中随机抽样：从记忆库中随机抽样一批经验。

计算目标Q值：使用目标网络计算目标Q值，即max(Q(s’, a, θ-))。

更新主网络：根据损失函数L(θ)进行模型参数更新。

更新目标网络：定期更新目标网络的参数。

重复步骤2-8，直到达到终止条件。

五、算法功能

DQN算法具有以下功能：

处理高维、连续状态空间：通过深度神经网络的逼近能力，可以处理高维、连续状态空间的问题。

学习和规划能力：通过与环境的交互和不断试错，DQN算法可以学习到最优策略，并具备一定的规划能力。

稳定性和收敛速度高：DQN算法通过经验回放和固定Q目标网络等技术，提高了模型的稳定性和收敛速度。

六、示例代码

以下是一个使用DQN算法解决经典的CartPole问题的示例代码：

# -*- coding: utf-8 -*-
import gym
import numpy as np
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Dense
from tensorflow.keras.optimizers import Adam

env = gym.make('CartPole-v0')
n_actions = env.action_space.n
n_states = env.observation_space.shape[0]

def create_dqn_model():
    model = Sequential()
    model.add(Dense(32, input_shape=(n_states,), activation='relu'))
    model.add(Dense(32, activation='relu'))
    model.add(Dense(n_actions, activation='linear'))
    model.compile(loss='mse', optimizer=Adam(lr=0.001))
    return model

def choose_action(state, epsilon):
    if np.random.rand() < epsilon:
        return np.random.choice(n_actions)
    else:
        q_values = model.predict(state)
        return np.argmax(q_values[0])

def train_dqn():
    epsilon = 1.0
    epsilon_min = 0.01
    epsilon_decay = 0.995
    batch_size = 32
    replay_memory = []
    for episode in range(500):
        state = env.reset()
        state = np.reshape(state, [1, n_states])
        done = False
        steps = 0

        while not done:
            env.render()
            action = choose_action(state, epsilon)
            next_state, reward, done, _ = env.step(action)
            next_state = np.reshape(next_state, [1, n_states])
            replay_memory.append((state, action, reward, next_state, done))
            state = next_state
            steps += 1

            if done:
                print("Episode: %d, Steps: %d" % (episode, steps))
                break
            if len(replay_memory) > batch_size:
                minibatch = np.random.choice(replay_memory, batch_size, replace=False)
                states_mb = np.concatenate([mb[0] for mb in minibatch])
                actions_mb = np.array([mb[1] for mb in minibatch])
                rewards_mb = np.array([mb[2] for mb in minibatch])
                next_states_mb = np.concatenate([mb[3] for mb in minibatch])
                dones_mb = np.array([mb[4] for mb in minibatch])

                targets = rewards_mb + 0.99 * (np.amax(model.predict_on_batch(next_states_mb), axis=1)) * (1 - dones_mb)
                targets_full = model.predict_on_batch(states_mb)
                ind = np.array([i for i in range(batch_size)])
                targets_full[[ind], [actions_mb]] = targets

                model.fit(states_mb, targets_full, epochs=1, verbose=0)

            if epsilon > epsilon_min:
                epsilon *= epsilon_decay

    env.close()

if __name__ == '__main__':

    model = create_dqn_model()

    train_dqn()

参考：

https://www.ngui.cc/el/2433927.html?action=onClick
https://blog.csdn.net/Zhang_0702_China/article/details/123423637
https://www.jb51.net/article/231665.htm
http://lihuaxi.xjx100.cn/news/1290031.html?action=onClick

韭菜盖饭
关注
  • 2
    点赞
  • 踩
  • 9
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
基于 CartPole-v0 环境的强化学习算法实现
01-18
Cart Pole 在 OpenAI 的 gym 模拟器里面是相对比较简单的一个游戏。游戏里面有一个小车，上有 一根杆子。小车需要左右移动来保持杆子竖直。如果杆子倾斜的角度大于 15°，那么游戏结束。小车也不 能移动出一个范围（中间到两边各 4.8 个单位长度）。详细设计见md文件。
深度强化学习DQN算法实现小车平衡杆(CartPole)问题
02-07
DQN（Deep Q-Network）算法是一种基于深度神经网络的强化学习算法，旨在解决Q-learning算法在高维状态空间中面临的问题。 本代码借鉴学习《深度强化学习专栏 —— 2.手撕DQN算法实现CartPole控制》，对每一行代码进行注释说明，并修改部分内容，完成在本设备上的正常运行。
DQN代码实战，gym经典CartPole（小车倒立摆）模型，纯PyTorch框架，代码中包含4种DQN变体，注释清晰。
05-27
亲身实践的DQN学习资料，环境是gym里的经典CartPole（小车倒立摆）模型，目标是使倒立摆不倒且小车位置不出界。纯PyTorch框架，不像Tensorflow有各种兼容性警告。做了很好的可视化，可直观感受强化学习DQN的学习效果。是入门强化学习的很好的途径。
强化学习-----DQN（Deep Q-network）
最新发布
qq_74722169的博客
04-07 1133
DQN（Deep Q-Network）是一种基于深度学习和强化学习的算法，由DeepMind提出，用于解决离散动作空间下的马尔科夫决策过程（MDP）问题。它是首个成功将深度学习应用于解决强化学习任务的算法之一。DQN，即深度Q网络（Deep Q-network），是指基于深度学习的Q-Learing算法。那什么是Q-leaning？可以看上一篇文章Q-learning是一种经典的强化学习算法，用于解决马尔可夫决策过程（Markov Decision Process，MDP）中的控制问题。
深度强化学习——DQN算法原理
weixin_44732379的博客
11-14 5万+
深度Q网络与Q学习的目标价值以及价值的更新方式都非常相似。主要的不同在于：深度Q网络将Q学习与深度学习结合，用深度网络来近似动作价值函数，而Q学习则是采用表格存储；深度Q网络采用经验回放的训练方式，从历史数据中随机采样，而Q学习直接采用下一个状态的数据进行学习。
DQN算法详解
Sweeping_Robot的博客
04-17 4340
强化学习算法可以分为三大类：value based, policy based 和 actor critic。常见的是以DQN为代表的value based算法，这种算法中只有一个值函数网络，没有policy网络，以及以DDPG,TRPO为代表的actor-critic算法，这种算法中既有值函数网络，又有policy网络。说到DQN中有值函数网络，这里简单介绍一下强化学习中的一个概念，叫值函数近似。一个state action pair 对应一个值函数。
dqn走迷宫matlab-深度强化学习DQN（DeepQNetwork）原理及例子：如何解。。。 深度学习原理.pdf
04-13
dqn走迷宫matlab-深度强化学习DQN（DeepQNetwork）原理及例子：如何解。。。 深度学习原理.pdf
DQN（deep Q-network）算法简述
星海浮生
03-11 4万+
基本概念；进阶技巧；连续动作的场景
DQN：深度Q-网络
weixin_49346755的博客
04-21 5093
基本概念 DQN DQN全名叫Deep Q-Leaning Network，DQN算法的基本思路来源于Q-Learning，不同于Q-learning，DQN的Q值不是直接通过状态值s和动作a来计算的，而是通过神经网络来计算的。 DQN的输入是状态s对应的状态向量ϕ\phiϕ(s)，输出是所有动作在该状态下的动作价值函数Q。 DQN使用经验回放将数据进行保存，比如说个体在状态StS_tSt​执行动作AtA_tAt​得到了RtR_tRt​的奖励，然后状态转移到了St+1S_{t+1}St+1​，则经验池就会将
DQN简介
yf_programmer的博客
10-09 2万+
DQN可以视为Q-learning的进阶版，DQN与Q-learning十分相似，DQN解决了Q-learning解决不了的问题。 DQN解决的问题 Q-learning的核心在于Q表格，通过建立Q表格来为行动提供指引，但这适用于状态和动作空间是离散且维数不高时，当状态和动作空间是高维连续时Q表格将变得十分巨大，对于维护Q表格和查找都是不现实的。设想一下如果AlphaGo使用Q-learning将会是什么样的场景，围棋的可能性量级为10^170，如此巨大的Q表格已经丧失了的它的价值。 Q表格无法解决，人们开
强化学习—DQN算法原理详解
热门推荐
binbigdata的博客
01-23 17万+
强化学习—DQN算法原理详解 一、 概述 强化学习算法可以分为三大类：value based, policy based 和 actor critic。常见的是以DQN为代表的value based算法，这种算法中只有一个值函数网络，没有policy网络，以及以DDPG,TRPO为代表的actor-critic算法，这种算法中既有值函数网络，又有policy网络。 说到DQN中有值函数网络，...
DQN基本概念和算法流程（附Pytorch代码）
ningmengzhihe的博客
04-14 7916
DQN，Deep Q Network本质上还是Q learning算法，它的算法精髓还是让Q估计​尽可能接近Q现实​，或者说是让当前状态下预测的Q值跟基于过去经验的Q值尽可能接近。在后面的介绍中Q现实​也被称为TD Target相比于Q Table形式，DQN算法用神经网络学习Q值，我们可以理解为神经网络是一种估计方法，神经网络本身不是DQN的精髓，神经网络可以设计成MLP也可以设计成CNN等等，DQN的巧妙之处在于两个网络、经验回放等trick。
breakout-Deep-Q-Network:强化学习| 在Atari Breakout上执行DQN，对决DQN和Double DQN的tensorflow实现
05-11
:person_running: [强化学习]在Atari Breakout游戏上执行的Deep Q Network（DQN），决斗DQN和Double DQN的张量流实现 安装 键入以下命令以安装OpenAI Gym Atari环境。 $ pip3 install opencv-python gym gym[atari...
深度强化学习+DQN+Pytorch+CartPole-v0
07-14
DQN算法的大体框架是传统强化学习中的Q-Learning，只不过是Q-learning的深度学习版本。DQN的改进主要有三个： 1. DQN的行为值函数利用神经网络逼近； 2. DQN维护一个回放缓冲区，将每次从环境中采样得到的四元组数据...
Deep-Q-Network:在OpenAI健身房中使用DQN玩游戏
04-30
深度Q网络在OpenAI健身房中使用DQN玩游戏深度强化学习受到越来越多的关注。 深度q网络是DRL的开始。 因此，对于那些想进入深度强化学习领域的人，希望我的代码可以帮助您更好地了解DQN算法和openai-gym环境。 我使用...
强化学习——DQN算法
qq_62965644的博客
07-31 783
这个原因在于假如在一个游戏中，我们的目标状态并不是固定，可能是一直变换的，就如这个游戏中，平衡的状态是多种多样的，那么我们一直跟踪这个目标就会变得困难，这时我们不妨固定住某一个曾经是目标的状态，让机器先尝试去达到这种状态，再去跟踪下一个固定目标状态，这样的方式会使得机器更容易找到目标状态。接下来我们需要创建一个样本池，神经网络会在这个样本池中进行学习，随后需要不断更新我们的样本池，当我们有一个新的行动时，我们应该添加新的样本，删除旧的样本，保持样本池最大数量不变。接着是价值函数（直接交给神经网络就可以了）
【详解+推导！！】DQN
志远的博客
04-16 2130
DQN，Deep Q-Network 是Q-Learning和深度网络结合的一种算法，在很多强化学习问题中表现优异。在看DQN之前建议先了解一下Q-Learning的基本原理：https://blog.csdn.net/qq_33302004/article/details/114871232 也可以看一下value-based 和 policy-based 方法的基本介绍:https://blog.csdn.net/qq_33302004/article/details/115189857 文章目录1.
动手学强化学习第七章（DQN算法）
qq_47997583的博客
04-27 4394
文章目录DQN算法1.理论部分1.1 简介1.2 经验回放1.3 目标网络2.实践部分 DQN算法 1.理论部分 1.1 简介 简而言之，DQN就是解决Q-learning只能应用于离散obs，离散act的状况，当obs连续时再用一个Q表格来记录Q值不再可能，于是引入神经网络来近似表示从连续输入到离散输出之间的函数关系。 Q-learning中的更新公式是： Q(s,a)←Q(s,a)+α[r+γmax⁡a′∈AQ(s′,a′)−Q(s,a)] Q(s, a) \leftarrow Q(s, a)+\al
强化学习 DQN算法
weixin_45193103的博客
06-01 2603
强化学习算法可以分为三大类：（1）value based,（2） policy based 和 （3）actor critic。常见的是以DQN为代表的value based算法，这种算法中只有一个值函数网络，没有policy网络，以及以DDPG,TRPO为代表的actor-critic算法，这种算法中既有值函数网络，又有policy网络。说到DQN中有值函数网络，这里简单介绍一下强化学习中的一个概念，叫值函数近似。在基本概念这篇中有讲过，一个state action pair (s,a)对应一个值函数Q(
pytorch实现DQN强化学习
06-01
DQN（Deep Q-Network）是一种使用深度神经网络实现的强化学习算法，用于解决离散动作空间的问题。在PyTorch中实现DQN可以分为以下几个步骤： 1. 定义神经网络：使用PyTorch定义一个包含多个全连接层的神经网络，输入为状态空间的维度，输出为动作空间的维度。 ```python import torch.nn as nn import torch.nn.functional as F class QNet(nn.Module): def __init__(self, state_dim, action_dim): super(QNet, self).__init__() self.fc1 = nn.Linear(state_dim, 64) self.fc2 = nn.Linear(64, 64) self.fc3 = nn.Linear(64, action_dim) def forward(self, x): x = F.relu(self.fc1(x)) x = F.relu(self.fc2(x)) x = self.fc3(x) return x ``` 2. 定义经验回放缓存：包含多条经验，每条经验包含一个状态、一个动作、一个奖励和下一个状态。 ```python import random class ReplayBuffer(object): def __init__(self, max_size): self.buffer = [] self.max_size = max_size def push(self, state, action, reward, next_state): if len(self.buffer) < self.max_size: self.buffer.append((state, action, reward, next_state)) else: self.buffer.pop(0) self.buffer.append((state, action, reward, next_state)) def sample(self, batch_size): state, action, reward, next_state = zip(*random.sample(self.buffer, batch_size)) return torch.stack(state), torch.tensor(action), torch.tensor(reward), torch.stack(next_state) ``` 3. 定义DQN算法：使用PyTorch定义DQN算法，包含训练和预测两个方法。 ```python class DQN(object): def __init__(self, state_dim, action_dim, gamma, epsilon, lr): self.qnet = QNet(state_dim, action_dim) self.target_qnet = QNet(state_dim, action_dim) self.gamma = gamma self.epsilon = epsilon self.lr = lr self.optimizer = torch.optim.Adam(self.qnet.parameters(), lr=self.lr) self.buffer = ReplayBuffer(100000) self.loss_fn = nn.MSELoss() def act(self, state): if random.random() < self.epsilon: return random.randint(0, action_dim - 1) else: with torch.no_grad(): q_values = self.qnet(state) return q_values.argmax().item() def train(self, batch_size): state, action, reward, next_state = self.buffer.sample(batch_size) q_values = self.qnet(state).gather(1, action.unsqueeze(1)).squeeze(1) target_q_values = self.target_qnet(next_state).max(1)[0].detach() expected_q_values = reward + self.gamma * target_q_values loss = self.loss_fn(q_values, expected_q_values) self.optimizer.zero_grad() loss.backward() self.optimizer.step() def update_target_qnet(self): self.target_qnet.load_state_dict(self.qnet.state_dict()) ``` 4. 训练模型：使用DQN算法进行训练，并更新目标Q网络。 ```python dqn = DQN(state_dim, action_dim, gamma=0.99, epsilon=1.0, lr=0.001) for episode in range(num_episodes): state = env.reset() total_reward = 0 for step in range(max_steps): action = dqn.act(torch.tensor(state, dtype=torch.float32)) next_state, reward, done, _ = env.step(action) dqn.buffer.push(torch.tensor(state, dtype=torch.float32), action, reward, torch.tensor(next_state, dtype=torch.float32)) state = next_state total_reward += reward if len(dqn.buffer.buffer) > batch_size: dqn.train(batch_size) if step % target_update == 0: dqn.update_target_qnet() if done: break dqn.epsilon = max(0.01, dqn.epsilon * 0.995) ``` 5. 测试模型：使用训练好的模型进行测试。 ```python total_reward = 0 state = env.reset() while True: action = dqn.act(torch.tensor(state, dtype=torch.float32)) next_state, reward, done, _ = env.step(action) state = next_state total_reward += reward if done: break print("Total reward: {}".format(total_reward)) ``` 以上就是在PyTorch中实现DQN强化学习的基本步骤。需要注意的是，DQN算法中还有很多细节和超参数需要调整，具体实现过程需要根据具体问题进行调整。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

韭菜盖饭

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值