24/8/15算法笔记 DQN算法

最新推荐文章于 2024-09-13 16:27:15 发布
最新推荐文章于 2024-09-13 16:27:15 发布
阅读量548 收藏 9
点赞数 14
文章标签： 算法 笔记
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/yyyy2711/article/details/141232034
版权

DQN（Deep Q-Network）算法是一种结合了深度学习和强化学习的技术，用于解决具有高维观测空间的强化学习问题。DQN算法通过使用深度神经网络来近似Q函数（也称为动作价值函数），在许多领域取得了突破性的成果，特别是在游戏和机器人控制方面。以下是DQN算法的关键特点：

  1. 深度Q网络：DQN使用一个深度神经网络来学习状态-动作对的价值函数，即 Q(s,a)Q(s,a)。

  2. 经验回放：DQN算法使用一个经验回放缓冲区来存储过去的转换（状态、动作、奖励、下一个状态），这有助于提高数据的利用率并减少训练过程中的方差。

  3. 目标网络：DQN使用两个相同的神经网络，一个用于预测 QQ 值（主网络），另一个作为目标网络。目标网络的参数定期从主网络复制过来，以稳定训练过程。

  4. Bellman方程：DQN算法通过最小化Bellman方程的误差来更新网络权重。

  5. 损失函数：DQN的损失函数通常使用均方误差（MSE）来衡量预测的 QQ 值和目标 QQ 值之间的差异。

  6. 探索与利用：DQN通常使用ε-贪心策略来平衡探索和利用。

  7. 训练过程：

    • 从环境中获取状态 ss 并选择动作 aa。
    • 执行动作并观察奖励 rr 和下一个状态 s′s′。
    • 使用 s,a,r,s′s,a,r,s′ 更新经验回放缓冲区。
    • 从缓冲区中随机采样一批数据来计算损失并更新网络。

  8. 稳定性：DQN算法通过目标网络和经验回放来提高训练过程的稳定性。

  9. 应用：DQN算法已被成功应用于各种游戏和模拟环境中，例如Atari 2600游戏和一些3D游戏。

  10. 变体：DQN算法有多种变体，如Double DQN、Dueling DQN和Prioritized Experience Replay，这些变体在不同方面改进了原始DQN算法的性能。

import gym
from matplotlib import pyplot as plt


#创建环境
env = gym.make('CartPole-v0')
env.reset()
#打印游戏
def show():
    plt.imshow(env.render(mode='rgb_array'))
    plt.show()
    
show()
#测试游戏环境
def test_env():
    state = env.reset()
    print('state=',state)

    print('env.action_space=',env.action_space)

    print('随机一个动作')
    action = env.action_space.sample()
    print('action',action)

    print('执行一个动作，得到下一个状态，奖励，是否结束')
    state,reward,over,_=env.step(action)
    print('state=',state)

    print('reward',reward)
    print('over',over)
test_env()
#创建神经网络模型，动作模型，经验模型
import torch
#计算动作的模型，也是真正要用的模型
model = torch.nn.Sequential(
    torch.nn.Linear(4,128),
    torch.nn.ReLu(),
    torch.nn.Linear(128,2),
)
#经验网络，用于评估一个状态的分数
next_model = torch.nn.Sequential(
    torch.nn.Linear(4,128),
    torch.nn.ReLU(),
    torch.nn.Linear(128,2),
)

#把model的参数复制给next_model
next_model.load_state_dict(model.state_dict())#load_state_dict() 方法用于加载模型的参数。当你想要将一个模型的参数复制给另一个模型时，可以使用这个方法。

model,next_model
import random
#得到一个动作
def get_action(state):
    if random.random()<0.01:
        return random.choice([0,1])
    
    #走神经网络，得到一个动作
    state = torch.FloatTensor(state).reshape(1,4)

    return model(state).argmax().item()
get_action([0.0012=3847,-0.01194451,0.04260966,0.00688801])

  1. 探索概率：

    • if random.random() < 0.01：这行代码检查一个随机数是否小于0.01，如果是，智能体将进行探索。0.01是探索的概率阈值。

  2. 随机选择动作：

    • return random.choice([0, 1])：如果智能体选择探索，它将随机选择一个动作，这里的动作集合是 [0, 1]。这意味着动作空间被限制为两个可能的动作。

  3. 利用策略：

    • 如果随机数大于或等于0.01，智能体将利用其当前的知识来选择最佳动作。

  4. 状态转换：

    • state = torch.FloatTensor(state).reshape(1, 4)：将当前状态转换为一个 PyTorch 浮点张量，并重塑为尺寸为 (1, 4) 的张量。这通常是为了匹配神经网络的输入尺寸。

  5. 神经网络预测：

    • return model(state).argmax().item()：将状态输入到神经网络 model 中，获取每个可能动作的预测值，然后选择具有最高预测值的动作。argmax().item() 返回具有最大值的动作索引。
#更新数据样本池函数，责备离线学习
#样本池
datas=[]

#向样本池添加N条数据，删除M条最古老的数据
def update_date():
    old_count = len(datas)

    #玩到新增了N个数据为止
    while len(datas) - old_count<200:
        #初始化游戏
        state = env.reset()

        #玩到游戏结束为止
        over = False
        while not over:
            #根据当前状态得到一个动作
            action = get_action(state)

            #执行动作，得到反馈
            next_state,reward,over,_=env.step(action)

            #记录数据样本
            datas.append((state,action,reward,next_state,over))

            #更新游戏状态，开始下一个动作
            state = next_state
    update_count = len(datas)-old_count
    drop_count = max(len(datas)-10000,0)

    #数据上限，超出时从最古老的开始删除
    while len(datas)>10000:
        datas.pop(0)
    return update_count,drop_count
#数据采样函数
#获取一批数据样本
#get_sample 函数是一个用于从数据集 datas 中随机抽取样本的函数，并将这些样本转换成适合深度学习模型输入的 PyTorch 张量格式
def get_sample():
    samples = random.sample(datas,64)
    #[b,4]
    state = torch.FloatTensor([i[0]for i in samples]).reshape(-1,4)
    #[b,1]
    action = torch.LongTensor([i[1]for i in samples]).reshape(-1,1)
    #[b,1]
    reward = torch.FloatTensor([i[2]for i in samples]).reshape(-1,1)
    #[b,4]
    next_state = torch.FloatTensor([i[3]for i in samples]).reshape(-1,4)
    #[b,1]
    over = torch.LongTensor([i[4]for i in samples]).reshape(-1,1)

    return state,action,reward,next_state,over

state,action,reward,next_state,over=get_sample()

state,action,reward,next_state,over
#计算value函数
def get_value(state,action):
    #使用状态计算出动作的logits
    #[b,4]->[b,2]
    value = model(state)

    #根据实际使用的action取出每一个值
    #这个值就是模型评估的在该状态下，执行动作的分数
    #在执行动作前，显然并不知道会得到的反馈和next_state
    #所以这里不能也不需要考虑next_state和reward
    #[b,2]->[b,1]
    value = value.gather(dim = 1,index=action)

    return value
get_value(state,action).shape

  1. 模型预测：

    • value = model(state)：使用模型对状态 state 进行预测，得到一个包含每个可能动作的值的张量。假设模型输出的尺寸是 [b, 2]，其中 b 是批量大小，2 是动作的数量。

  2. 索引选择：

    • value = value.gather(dim=1, index=action)：使用 gather 方法根据 action 索引从模型输出中选择对应的值。这里假设 action 是一个长整型张量，其尺寸为 [b, 1]。
#计算target函数
def get_target(reward,next_state,over):
    #上面已经把模型认为的状态下执行动作的分数给评估出来了
    #下面使用next_state和reward计算真实的分数
    #针对一个状态，它到底应该多少分，可以使用以往模型积累的经验评估
    #这也是没办法的办法，因为显然没有精确解，这里使用延迟更新的next_model评估

    #使用next_state计算下一个状态的分数
    #[b,4}->[b,2]
    with torch.no_grad():
        target = next_model(next_state)

    #取所有动作中分数最大的
    #[b,2]-[b,1]
    target = target.max(dim=1)[0]
    target = target.reshape(-1,1)

    #下一个状态的分数乘以一个系数，相当于权重
    target*=0.98

    #如果next_state已经游戏结束，则next_state分数是0
    #因为如果下一步已经游戏结束，显然不需要再继续下去，也就不需要考虑next_state了
    #[b,1]*[b,1]->[b,1]
    target *=(1-over)

    #加上reward就是最终的分数
    #[b,1]+[b,1]->[b,1]
    target+=reward 
    return target

  1. 使用 next_model 预测下一个状态的值：

    • target = next_model(next_state)：使用 next_model 对下一个状态 next_state 进行预测，得到每个可能动作的值。

  2. 选择最佳动作的值：

    • target = target.max(dim=1)[0]：从预测的值中选择每个状态的最大动作值。max(dim=1) 返回最大值和索引，[0] 选择最大值。

  3. 重塑目标张量：

    • target = target.reshape(-1, 1)：将目标张量重塑为二维张量，每行一个值。

  4. 应用折扣因子：

    • target *= 0.98：将目标值乘以折扣因子 0.98，这是强化学习中的常见做法，用于计算未来奖励的当前价值。

  5. 处理游戏结束的情况：

    • target *= (1 - over)：如果 over 是一个表示游戏是否结束的二进制张量（1 表示结束，0 表示未结束），这行代码将结束状态的目标值设置为 0。

  6. 计算最终的目标值：

    • target += reward：将即时奖励加到目标值上，得到最终的TD目标。

  7. 返回值：

    • 函数返回 target，这是每个样本的TD目标值。

测试函数

from IPython import display
def test(play):
    #初始化游戏
    state = env.reset()

    #记录反馈值的和，这个值越大越好
    reward_sum = 0

    #玩到游戏结束为止
    over = False
    while not over:
        #根据当前状态得到一个动作
        action = get_action(state)

        #执行动作，得到反馈
        state,reward,over,_ env.step(action)
        reward_sum+=reward

        #打印动画
        if play and random.random()<0.1:#跳帧
            display.clear_output(wait = True)
            show()
    return reward_sum

训练函数

def train():
    model.train()
    optimizer = torch.optim.Adam(model.parameters(),lr = 2e-3)
    loss_fn = torch.nn.MSELoss()

    #训练N次
    for epoch in range(500):
        #更新N条数据
        update_count,drop_count = update_data()

        #每次更新过数据后，学习N次
        for i in range(200):
            #采样一批数据
            state, action,reward,next_state,over = get_sample()

            #计算一批样本的value和target
            value = get_value(state,action)
            target = get_target(reward,next_state,over)

            #更新参数
            loss = loss_fn(value,target)
            optimizer.zero_grad()
            loss.backward()
            optimizer.step()

            #把model参数复制给next_model
            if(i+1)%10==0:
                next_model.load_state_dict(model.state_dict())

        if epoch % 50==0:
            test_result =sum([test(play = False)for _ in range(20)])/20
            print(spoch.len(datas),update_count,drop_count,test_result)

DQN改进算法doubleDQN

def get_target(reward,next_state,over):
    #上面已经把模型认为的状态下执行动作的分数给评估出来了
    #下面使用next_state和reward计算真实的分数
    #针对一个状态，它到底应该多少分，可以使用以往模型积累的经验评估
    #这也是没办法的办法，因为显然没有精确解，这里使用延迟更新的next_model评估

    #使用next_state计算下一个状态的分数
    #[b,4}->[b,2]
    with torch.no_grad():
        target = next_model(next_state)
    """以下是主要的DoubleDQN和DQN的区别"""
    #取所有动作中分数最大的
    #[b,11]-[b]
    #target = target.max(dim=1)[0]
    #使用model计算下一个状态的分数
    #[b,3]->[b,11]
    with torch.no_grad():
        model_target = model(next_state)
    
    #取分数最高的下标
    #[b,11]->[b,1]
    model_target = model_target.max(dim=1)[1]
    model_target = model_target.reshape(-1,1)

    #以这个下标取next_value当中的值
    #[b,11]->[b]
    target = target.gather(dim=1,index=model_target)
    """以上是区别"""
    #下一个状态的分数乘以一个系数，相当于权重
    target*=0.98

    #如果next_state已经游戏结束，则next_state分数是0
    #因为如果下一步已经游戏结束，显然不需要再继续下去，也就不需要考虑next_state了
    #[b,1]*[b,1]->[b,1]
    target *=(1-over)

    #加上reward就是最终的分数
    #[b,1]+[b,1]->[b,1]
    target+=reward 
    return target

DuelingDQN改进

class Vent(torch.nn.Model):
    def __init__(self):
        super().__init__()

        self.fc = torch.nn.Sequential(
            torch.nn.Linear(3,128),
            torch.nn.ReLU(),
        )

        self.fc_A = torch.nn.Linear(128,11)
        self.fc_V = torch.nn.Linear(128,1)

    def forward(self,x):
        #[5,11]->[5,128]->[5,11]
        A = self.fc_A(self.fc(x))

        #[5,11]->[5,128]->[5,1]
        V = self.fc_V(self.fc(x))
        
        #[5,11]->[5]->[5,1]
        A_mean = A.mean(dim=1).reshape(-1,1)

        #[5,11]->[5,128]->[5,11]
        A -=A_mean

        #Q值由V值计算得到
        #[5,11]+[5,1]=[5,11]
        Q = A+V
        return Q

  1. 初始化 (__init__ 方法)：

    • 调用基类的初始化方法。
    • 定义一个顺序模型 self.fc，包含一个线性层和ReLU激活函数，用于特征提取。

  2. 动作价值层 (self.fc_A)：

    • 一个线性层，将输入特征从128维映射到11维，对应每个动作的价值。

  3. 状态价值层 (self.fc_V)：

    • 一个线性层，将输入特征从128维映射到1维，对应当前状态的全局价值。

  4. 前向传播 (forward 方法)：

    • 输入 x 通过 self.fc 进行特征提取，然后分别通过 self.fc_A 和 self.fc_V 得到动作价值和状态价值。

  5. 动作价值的均值 (A_mean)：

    • 计算 self.fc_A 输出的均值，并重塑以匹配原始形状。

  6. 中心化动作价值：

    • 从原始动作价值中减去均值，进行中心化处理。

  7. 计算Q值：

    • 将中心化后的动作价值与状态价值相加，得到最终的Q值。
青椒大仙KI11
关注
如何选择深度强化学习算法：MuZero/SAC/PPO/TD3/DDPG/DQN/等算法
丨汀、的博客
07-14 2998
如何选择深度强化学习算法：MuZero/SAC/PPO/TD3/DDPG/DQN/等算法
24/8/17算法笔记 DDPG算法
yyyy2711的博客
08-17 606
深度确定性策略梯度（DDPG）算法是一种用于解决连续动作空间强化学习问题的算法。它结合了确定性策略梯度（DPG）和深度学习技术的优点，通过Actor-Critic框架进行策略和价值函数的近似表示。DDPG算法的关键组成部分包括经验回放缓冲区、Actor-Critic神经网络、探索噪声、目标网络以及软目标更新。DDPG算法使用两个神经网络，分别作为Actor和Critic。Actor网络负责生成策略，即在给定状态下选择最佳动作，而Critic网络评估当前策略的表现，通过Q值来衡量。
DQN（deep Q-network）算法简述
热门推荐
星海浮生
03-11 5万+
基本概念；进阶技巧；连续动作的场景
Datawhale 强化学习笔记(二）马尔可夫过程，DQN 算法
RessCris的博客
01-17 1247
其次，每次迭代的样本都是从环境中实时交互得到的，这样的样本是有关联的，而梯度下降法是基于一个假设的，即训练集中的样本是独立同分布的。在 DQN 算法中，大臣是不管好的还是坏的情报都会汇报给皇帝的，而在 Double DQN 算法中大臣会根据自己的判断将自己认为最优的情报汇报给皇帝，即先在策略网络中找出最大 Q 值对应的动作。目标网络和当前网络结构都是相同的，都用于近似 Q 值，在实践中每隔若干步才把每步更新的当前网络参数复制给目标网络，这样做的好处是保证训练的稳定，避免 Q 值的估计发散。
强化学习DQN算法
weixin_49269330的博客
10-16 1万+
DQN概述 DQN简述 DQN算法主要的算法流程是将神经网络与Q-learning算法结合。利用神经网络强大的表征能力，将高维的输入数据作为强化学习中的state，作为神经网络模型(Agent)的输入; 随后神经网络模型输出每个动作对应的价值(Q值),得到将要执行的动作。强化学习的目标是通过学习从而获得最大的奖励。 接下来将分成神经网络近似价值函数、求解价值网络以及DQN算法效果3个方面简要概述 1. 神经网络近似价值函数 当状态空间和动作空间低维离散时，可以采用基于表格的方法进行求解；当状态空间和动作空间
DQN算法实战
JohnJim的博客
11-28 3857
知识预习 本文不赘述DQN的原理，可先看Q-learning以及DQN其他相关文章，参考比如datawhale李宏毅笔记-Q学习。 实战的意思就是撸出代码来，在简单了解原理的基础上，根据论文分析 Human-level control through deep reinforcement learning Playing Atari with Deep Reinforcement Learning ...
【学习笔记】RL算法 Q learning+SARSA+DQN
qq_46248455的博客
10-15 122
【学习笔记】RL算法 Q learning +SARSA + DQN
强化学习 HER算法笔记
weixin_51183324的博客
06-23 606
，原本样本**(st||g, at, rt, st+1||g)** ,新样本** (st||g’, at, r’, st+1||g’)**，新旧样本都塞回经验缓冲区存储，用于智能体学习。在最优策略的探索中，智能体与环境交互，通过不断观察环境的状态(state)，采取行动（action），依据环境给予的反馈信息，奖励信号（reward）不断。文献展示的上图为实验结果，可以明显的看出，HER算法在强化学习解决稀疏奖励和二元奖励问题方面性能的改进，作为一个。本文仅为个人笔记分享，如有侵权，即刻删除。
强化学习之Double DQN算法与DQN算法对比学习——以倒立摆（Inverted Pendulum）环境为例
佚名
08-07 1084
在此介绍DQN算法改进算法之一Double DQN，其在DQN算法基础上稍加修改实现在一定程度上改善DQN效果。训练过程中会记录每个状态下的最大Q值，训练后可结果可进行可视化，观测这些Q值存在的过高估计的情况，以此对比DQN与Double DQN差异。我们发现DQN算法在倒立摆环境中能取得不错的回报，最后的期望回报在-200左右，但是不少Q值超过了0，有些还超过10，这一现象表明了DQN算法会对Q值过高估计。显然DQN 与Double DQN差别在于计算状态s'下的Q值如何选择动作。4.设置相应的超参数。
强化学习DQN笔记.md
08-21
### 强化学习DQN笔记知识点详述 ...综上所述，强化学习特别是DQN算法为解决具有挑战性的任务提供了一种有效的途径。通过理论学习和实践操作相结合，可以更好地理解这些算法背后的原理，并将其应用于实际问题中。
DE.zip_数值算法/人工智能_C/C++_
08-11
3. 强化学习：在C/C++中，可以利用OpenAI Gym接口与其他语言交互，进行强化学习环境的模拟，如Q-learning、DQN(深度Q网络)等算法。 三、C/C++在数值算法与人工智能的应用优势 1. 性能：C/C++的运行速度远超解释型...
算法刷题：300. 最长递增子序列、674. 最长连续递增序列、718. 最长重复子数组、1143. 最长公共子序列
qq_61936886的博客
09-12 519
如果text1[i - 1] 与 text2[j - 1]不相同，那就看看text1[0, i - 2]与text2[0, j - 1]的最长公共子序列 和 text1[0, i - 1]与text2[0, j - 2]的最长公共子序列，取最大的。但dp[i][0] 和dp[0][j]要初始值，因为 为了方便递归公式dp[i][j] = dp[i - 1][j - 1] + 1;2.递推公式：当A[i - 1] 和B[j - 1]相等的时候，dp[i][j] = dp[i - 1][j - 1] + 1;
算法知识点——常用输入输出数据的方式
5233的博客
09-12 311
除了换行之外，还会清空缓存区，而清空缓存区这件事情会耗时很久，因此为了提高速度，一般直接：cout << “\n”;2、n组输入输出(n不确定）1、n组输入输出(n确定）3、 复杂的输入输出。
输出一个三位数
最新发布
2301_77501988的博客
09-13 424
本题要求编写程序，输入一个三位数，输出其个位数字、十位数字和百位数字。
Java数据结构（十）——冒泡排序、快速排序
xiaokuer_的博客
09-11 1205
文章介绍了冒泡排序和快速排序，快速排序的内容包括：划分方式、优化策略以及非递归实现
【Hot100】LeetCode—64. 最小路径和
weixin_44382896的博客
09-12 498
64. 最小路径和。
算法练习题24——查找杨辉三角中的组合数
hello77的blogggg 祝你得偿所愿
09-12 607
逐项递推法适合处理较小的数据量，计算较为直观，但当杨辉三角行数较大时，效率较低。 二分查找法利用组合数的单调性，显著提高查找效率，适合处理较大的数据范围。这两种解法在不同场景下都可以使用，二分查找法尤其适合大规模数据下的查找问题。
dqn算法与double DQN算法的区别
11-01
DQN算法是一种深度强化学习算法，它使用神经网络来估计Q值函数，通过不断地更新神经网络参数来优化策略。而Double DQN算法是在DQN算法的基础上进行的改进，主要是解决了DQN算法中过高估计Q值的问题。具体来说，Double DQN算法使用一个神经网络来选择动作，另一个神经网络来评估这个动作的价值，这样可以减少过高估计Q值的情况。因此，Double DQN算法相对于DQN算法来说，更加准确和稳定。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值