深度强化学习算法（三）（附带MATLAB程序）

leon625

已于 2024-08-26 10:04:01 修改

阅读量904

点赞数 24

分类专栏：算法类文章标签：算法 matlab

于 2024-08-26 09:59:05 首次发布

本文链接：https://blog.csdn.net/qq_35623594/article/details/141552813

版权

算法类专栏收录该内容

21 篇文章 1 订阅

订阅专栏

深度强化学习（Deep Reinforcement Learning, DRL）结合了深度学习和强化学习的优点，能够处理具有高维状态和动作空间的复杂任务。它的核心思想是利用深度神经网络来逼近强化学习中的策略函数和价值函数，从而提高学习能力和决策效率。

一、关键算法分类

1.1 深度 Q 网络（Deep Q-Network, DQN）

概念：将 Q 学习（一个值函数方法）与深度神经网络结合，用于近似 Q 值函数。
特点：使用经验回放和固定 Q 目标网络来稳定训练过程。
应用：成功应用于 Atari 游戏等环境。

1.2 双重 Q 学习（Double Q-Learning）

概念：解决 DQN 中 Q 值过估计的问题，通过引入两个 Q 网络来减少过估计。
特点：使用两个独立的 Q 网络交替更新，以减少 Q 值的过高估计。

1.3 优先经验回放（Prioritized Experience Replay）

概念：对经验回放进行优先级排序，以更频繁地训练那些“重要”的样本。
特点：提高了训练的效率和稳定性。

1.4 深度确定性策略梯度（Deep Deterministic Policy Gradient, DDPG）

概念：适用于连续动作空间的策略梯度算法。
特点：使用策略网络和价值网络来逼近策略和价值函数，并利用经验回放和目标网络来稳定训练。

1.5策略梯度方法（Policy Gradient Methods）

概念：直接优化策略函数，通过梯度上升来最大化预期累积回报。
特点：适合处理大规模或连续动作空间。

1.6近端策略优化（Proximal Policy Optimization, PPO）

概念：通过引入一个“剪切”操作来限制每次策略更新的幅度，确保训练稳定。
特点：简单且有效，广泛应用于各种任务。

1.7演员-评论家方法（Actor-Critic Methods）

概念：结合了策略优化（演员）和价值函数（评论家）的方法。
特点：演员负责更新策略，而评论家负责估计价值函数，用于指导演员更新策略。

二、优先经验回放（Prioritized Experience Replay）算法推导

优先经验回放（Prioritized Experience Replay, PER）是一种用于强化学习中经验回放的技术，旨在改进Q-learning或深度Q网络（DQN）的学习效率。PER的核心思想是根据经验的“重要性”来优先选择回放中的经验，从而加速学习过程并提高学习效率。以下是PER的算法推导过程：

2.1经验回放基础

在经典的经验回放（Experience Replay）中，智能体将经历过的转移（状态、动作、奖励、下一个状态）存储在经验池中，然后从中随机抽取一小批样本来更新Q值。随机抽样的主要目的是打破经验之间的相关性，以提高学习的稳定性。

2.2经验的优先级

在PER中，不同的经验在回放时的重要性是不同的。优先级较高的经验通常能提供更多的学习信号，从而能更快地改进策略。为了实现这种优先级的排序，我们需要定义经验的优先级。

2.3优先级的定义

PER使用一个优先级函数来评估每条经验的重要性。一般而言，优先级可以通过经验的“TD误差”（Temporal Difference Error）来衡量。TD误差反映了当前Q值估计与实际回报之间的差异。公式如下：

$TD Error=\left | r+\gamma max_{{a}'} Q\left ( {s}' ,{a}'\right )-Q\left ( s,a \right )\right |$

其中：

$r$ 是即时奖励。
$\gamma$ 是折扣因子。
$Q\left ( {s}',{a}' \right )$ 是下一个状态-动作对的Q值。
$Q\left ( s,a \right )$ 是当前状态-动作对的Q值。

2.4经验优先级的计算

经验的优先级通常与TD误差成正比。为了避免TD误差为零导致的优先级为零的情况，通常对TD误差进行平滑处理：
$p_{i}=\left | \delta _{i} \right |+\varepsilon$

其中：

$\delta _{i}$ 是第 $i$ 个经验的TD误差。
$\varepsilon$ 是一个小常数，用于保证每个经验都有一定的优先级。

2.5优先级经验回放机制

为了高效地实现优先级经验回放，使用了一个优先级队列或树状数据结构来维护经验的优先级。常用的数据结构是优先级队列（Priority Queue）或Segment Tree（段树）。

2.5.1Segment Tree 实现

使用Segment Tree可以高效地管理和查询优先级。Segment Tree 的叶子节点存储每条经验的优先级，内部节点存储子节点的优先级之和。这样可以快速更新优先级和采样经验。

2.5.2采样和更新

采样时，根据优先级分布来选择经验。在每次更新时，利用当前的TD误差来更新经验的优先级。

2.6重要性采样（Importance Sampling）

由于采用了优先级采样，样本的分布和实际的经验池分布可能会有所不同。为了纠正这种偏差，PER引入了重要性采样（Importance Sampling）权重。具体来说，对于每条经验 iii，计算其重要性采样权重：

$\omega _{i}=\left (\frac{1}{N\cdot p_{i}} \right )^{\beta }$

其中：

$N$ 是经验池的总大小。
$\beta$ 是重要性采样的调整参数，用于平衡偏差和方差，通常在训练过程中逐渐增加。

2.7算法流程整理

（1）存储经验：将每个经验存储到经验池中，并根据其TD误差计算优先级

（2）采样经验：根据优先级分布采样经验。

（3）更新Q值：使用采样的经验更新Q值，并计算新的TD误差。

（4）更新优先级：根据新的TD误差更新每条经验的优先级。

（5）调整重要性采样权重：更新重要性采样权重 wiw_iwi。

三、MATLAB程序仿真

编写优先经验回放（Prioritized Experience Replay, PER）算法的 MATLAB 仿真程序涉及几个主要步骤：构建经验池、维护优先级队列、采样经验、更新优先级和训练模型。以下是一个 MATLAB 仿真程序的示例，它实现了 PER 算法的基本功能。

3.1数据结构与初始化

首先，我们需要定义用于存储经验和优先级的结构。这里，我们使用一个简单的优先级队列来存储经验。

3.1.1优先级队列类

classdef PriorityQueue < handle
    properties
        tree
        capacity
        size
        data
    end
    
    methods
        function obj = PriorityQueue(capacity)
            obj.capacity = capacity;
            obj.tree = zeros(2 * capacity - 1, 1);
            obj.size = 0;
            obj.data = cell(capacity, 1);
        end
        
        function index = add(obj, experience, priority)
            index = mod(obj.size, obj.capacity) + 1;
            obj.data{index} = experience;
            obj.update(index, priority);
            obj.size = obj.size + 1;
        end
        
        function update(obj, index, priority)
            treeIndex = index + obj.capacity - 1;
            obj.tree(treeIndex) = priority;
            while treeIndex > 1
                treeIndex = floor(treeIndex / 2);
                obj.tree(treeIndex) = max(obj.tree(2 * treeIndex), obj.tree(2 * treeIndex + 1));
            end
        end
        
        function [experience, priority] = sample(obj, beta)
            [priority, index] = obj.sampleTree();
            experienceIndex = mod(index, obj.capacity) + 1;
            experience = obj.data{experienceIndex};
            priorityWeight = (1 / (obj.capacity * priority)) ^ beta;
        end
        
        function [priority, index] = sampleTree(obj)
            treeIndex = 1;
            while treeIndex < obj.capacity
                leftChild = 2 * treeIndex;
                rightChild = 2 * treeIndex + 1;
                if rand < obj.tree(leftChild) / (obj.tree(leftChild) + obj.tree(rightChild))
                    treeIndex = leftChild;
                else
                    treeIndex = rightChild;
                end
            end
            index = treeIndex - obj.capacity + 1;
            priority = obj.tree(treeIndex);
        end
    end
end

3.1.2初始化优先级队列

capacity = 10000; % 经验池的容量
alpha = 0.6; % 优先级的功率因子
beta = 0.4; % 重要性采样的权重
priorityQueue = PriorityQueue(capacity);

3.2存储和更新经验

存储经验和更新优先级的函数：

function storeExperience(priorityQueue, experience, priority)
    priorityQueue.add(experience, priority);
end

function updateExperience(priorityQueue, index, priority)
    priorityQueue.update(index, priority);
end

3.3采样经验

采样经验并计算重要性采样权重的函数：

function [batch, idxs, weights] = sampleExperience(priorityQueue, batchSize, beta)
    batch = cell(batchSize, 1);
    idxs = zeros(batchSize, 1);
    weights = zeros(batchSize, 1);
    for i = 1:batchSize
        [experience, priority] = priorityQueue.sample(beta);
        idxs(i) = experience{end}; % 这里假设经验的最后一个元素是索引
        batch{i} = experience;
        weights(i) = (1 / (priority * batchSize)) ^ beta;
    end
end

3.4更新模型

function updateModel(batch, weights, model)
    % 使用 batch 和 weights 更新模型
    % 这是一个简化的占位符，需要根据具体的模型实现进行更新
end

3.5主循环

最后，整合这些功能来进行训练：

numEpisodes = 1000; % 总的训练回合数
batchSize = 32; % 批量大小
for episode = 1:numEpisodes
    % 交互与存储经验的过程
    % experience = [s, a, r, s']
    % priority = abs(TD_error) + epsilon
    % storeExperience(priorityQueue, experience, priority);

    if priorityQueue.size >= batchSize
        [batch, idxs, weights] = sampleExperience(priorityQueue, batchSize, beta);
        % TD误差计算和优先级更新
        % 更新模型
        % updateModel(batch, weights, model);
    end
end