首页
学习
活动
专区
圈层
工具
发布
首页
学习
活动
专区
圈层
工具
MCP广场
社区首页 >专栏 >【八】强化学习之DDPG---PaddlePaddlle【PARL】框架{飞桨}

【八】强化学习之DDPG---PaddlePaddlle【PARL】框架{飞桨}

作者头像
汀丶人工智能
发布于 2022-12-01 08:01:56
发布于 2022-12-01 08:01:56
50000
代码可运行
举报
文章被收录于专栏:NLP/KGNLP/KG
运行总次数:0
代码可运行

相关文章:

【一】飞桨paddle【GPU、CPU】安装以及环境配置+python入门教学

【二】-Parl基础命令

【三】-Notebook、&pdb、ipdb 调试

【四】-强化学习入门简介

【五】-Sarsa&Qlearing详细讲解

【六】-DQN

【七】-Policy Gradient

【八】-DDPG

【九】-四轴飞行器仿真

代码链接:码云:https://gitee.com/dingding962285595/parl_work  ;github:https://github.com/PaddlePaddle/PARL


一、AI Studio 项目详解【VisualDL工具】

二、AI Studio 项目详解【环境使用说明、脚本任务】

三、AI Studio 项目详解【分布式训练-单机多机】

四、AI Studio 项目详解【图形化任务】

五、AI Studio 项目详解【在线部署及预测】


1. 连续动作空间

离散动作&连续动作

2.DDPG讲解Deep Deterministic Policy Gradient

  • deep-神经网络--DNQ扩展 

目标网络 target work

经验回放 replay memory

  • Deterministic Policy Gradient  

·Deterministic    直接输出确定的动作

·Policy Gradient  单步更新的policy网络

 DDPG是DQN的扩展版本,可以扩展到连续控制动作空间

2.1 策略网络:

actor对外输出动作;critic会对每个输出的网络进行评估。刚开始随机参数初始化,然后根据reward不断地反馈。

目标网络target network +经验回放ReplayMemory

两个target_Q/P网络的作用是稳定Q网络里的Q_target 复制原网络一段时间不变。

2.2 经验回放ReplayMemory

用到数据:

  • Agent把产生的数据传给algorithmalgorithm根据model的模型结构计算出Loss,使用SGD或者其他优化器不断的优化,PARL这种架构可以很方便的应用在各类深度强化学习问题中。

(1)Model

Model用来定义前向(Forward)网络,用户可以自由的定制自己的网络结构

代码语言:javascript
代码运行次数:0
运行
AI代码解释
复制
class Model(parl.Model):
    def __init__(self, act_dim):
        self.actor_model = ActorModel(act_dim)
        self.critic_model = CriticModel()
 
    def policy(self, obs):
        return self.actor_model.policy(obs)
 
    def value(self, obs, act):
        return self.critic_model.value(obs, act)
 
    def get_actor_params(self):
        return self.actor_model.parameters()
代码语言:javascript
代码运行次数:0
运行
AI代码解释
复制
class ActorModel(parl.Model):
    def __init__(self, act_dim):
        hid_size = 100
 
        self.fc1 = layers.fc(size=hid_size, act='relu')
        self.fc2 = layers.fc(size=act_dim, act='tanh')
 
    def policy(self, obs):
        hid = self.fc1(obs)
        means = self.fc2(hid)
        return means
代码语言:javascript
代码运行次数:0
运行
AI代码解释
复制
class CriticModel(parl.Model):
    def __init__(self):
        hid_size = 100
 
        self.fc1 = layers.fc(size=hid_size, act='relu')
        self.fc2 = layers.fc(size=1, act=None)
 
    def value(self, obs, act):
        concat = layers.concat([obs, act], axis=1)
        hid = self.fc1(concat)
        Q = self.fc2(hid)
        Q = layers.squeeze(Q, axes=[1])
        return Q

(2)Algorithm

  • Algorithm 定义了具体的算法来更新前向网络(Model),也就是通过定义损失函数来更新Model,和算法相关的计算都放在algorithm中。
代码语言:javascript
代码运行次数:0
运行
AI代码解释
复制
    def _critic_learn(self, obs, action, reward, next_obs, terminal):
        next_action = self.target_model.policy(next_obs)
        next_Q = self.target_model.value(next_obs, next_action)
 
        terminal = layers.cast(terminal, dtype='float32')
        target_Q = reward + (1.0 - terminal) * self.gamma * next_Q
        target_Q.stop_gradient = True
 
        Q = self.model.value(obs, action)
        cost = layers.square_error_cost(Q, target_Q)
        cost = layers.reduce_mean(cost)
        optimizer = fluid.optimizer.AdamOptimizer(self.critic_lr)
        optimizer.minimize(cost)
        return cost
 

代码语言:javascript
代码运行次数:0
运行
AI代码解释
复制
    def _actor_learn(self, obs):
        action = self.model.policy(obs)
        Q = self.model.value(obs, action)
        cost = layers.reduce_mean(-1.0 * Q)
        optimizer = fluid.optimizer.AdamOptimizer(self.actor_lr)
        optimizer.minimize(cost, parameter_list=self.model.get_actor_params())
        return cost
 

软更新:每次更新一点参数,用\tau控制,按比例更新

硬更新:是每隔一段时间全部参数都更新

代码语言:javascript
代码运行次数:0
运行
AI代码解释
复制
    def sync_target(self, decay=None, share_vars_parallel_executor=None):
        """ self.target_model从self.model复制参数过来,若decay不为None,则是软更新
        """
        if decay is None:
            decay = 1.0 - self.tau
        self.model.sync_weights_to(
            self.target_model,
            decay=decay,
            share_vars_parallel_executor=share_vars_parallel_executor)

(3)Agent

  • Agent负责算法与环境的交互,在交互过程中把生成的数据提供给Algorithm来更新模型(Model),数据的预处理流程也一般定义在这里。
代码语言:javascript
代码运行次数:0
运行
AI代码解释
复制
class Agent(parl.Agent):
    def __init__(self, algorithm, obs_dim, act_dim):
        assert isinstance(obs_dim, int)
        assert isinstance(act_dim, int)
        self.obs_dim = obs_dim
        self.act_dim = act_dim
        super(Agent, self).__init__(algorithm)
 
        # 注意:最开始先同步self.model和self.target_model的参数.
        self.alg.sync_target(decay=0)
 
    def build_program(self):
        self.pred_program = fluid.Program()
        self.learn_program = fluid.Program()
 
        with fluid.program_guard(self.pred_program):
            obs = layers.data(
                name='obs', shape=[self.obs_dim], dtype='float32')
            self.pred_act = self.alg.predict(obs)
 
        with fluid.program_guard(self.learn_program):
            obs = layers.data(
                name='obs', shape=[self.obs_dim], dtype='float32')
            act = layers.data(
                name='act', shape=[self.act_dim], dtype='float32')
            reward = layers.data(name='reward', shape=[], dtype='float32')
            next_obs = layers.data(
                name='next_obs', shape=[self.obs_dim], dtype='float32')
            terminal = layers.data(name='terminal', shape=[], dtype='bool')
            _, self.critic_cost = self.alg.learn(obs, act, reward, next_obs,
                                                 terminal)
 
    def predict(self, obs):
        obs = np.expand_dims(obs, axis=0)
        act = self.fluid_executor.run(
            self.pred_program, feed={'obs': obs},
            fetch_list=[self.pred_act])[0]
        act = np.squeeze(act)
        return act
 
    def learn(self, obs, act, reward, next_obs, terminal):
        feed = {
            'obs': obs,
            'act': act,
            'reward': reward,
            'next_obs': next_obs,
            'terminal': terminal
        }
        critic_cost = self.fluid_executor.run(
            self.learn_program, feed=feed, fetch_list=[self.critic_cost])[0]
        self.alg.sync_target()
        return critic_cost
 

(4)env.py

连续控制版本的CartPole环境

  • 该环境代码与算法无关,可忽略不看,参考gym

(5)经验池 ReplayMemory

DQNreplay_mamory.py代码一致

代码语言:javascript
代码运行次数:0
运行
AI代码解释
复制
class ReplayMemory(object):
    def __init__(self, max_size):
        self.buffer = collections.deque(maxlen=max_size)
 
    def append(self, exp):
        self.buffer.append(exp)
 
    def sample(self, batch_size):
        mini_batch = random.sample(self.buffer, batch_size)
        obs_batch, action_batch, reward_batch, next_obs_batch, done_batch = [], [], [], [], []
 
        for experience in mini_batch:
            s, a, r, s_p, done = experience
            obs_batch.append(s)
            action_batch.append(a)
            reward_batch.append(r)
            next_obs_batch.append(s_p)
            done_batch.append(done)
 
        return np.array(obs_batch).astype('float32'), \
            np.array(action_batch).astype('float32'), np.array(reward_batch).astype('float32'),\
            np.array(next_obs_batch).astype('float32'), np.array(done_batch).astype('float32')
 
    def __len__(self):
        return len(self.buffer)
 
 

(6)train

代码语言:javascript
代码运行次数:0
运行
AI代码解释
复制
# 训练一个episode
def run_episode(agent, env, rpm):
    obs = env.reset()
    total_reward = 0
    steps = 0
    while True:
        steps += 1
        batch_obs = np.expand_dims(obs, axis=0)
        action = agent.predict(batch_obs.astype('float32'))
 
        # 增加探索扰动, 输出限制在 [-1.0, 1.0] 范围内
        action = np.clip(np.random.normal(action, NOISE), -1.0, 1.0)
 
        next_obs, reward, done, info = env.step(action)
 
        action = [action]  # 方便存入replaymemory
        rpm.append((obs, action, REWARD_SCALE * reward, next_obs, done))
 
        if len(rpm) > MEMORY_WARMUP_SIZE and (steps % 5) == 0:
            (batch_obs, batch_action, batch_reward, batch_next_obs,
             batch_done) = rpm.sample(BATCH_SIZE)
            agent.learn(batch_obs, batch_action, batch_reward, batch_next_obs,
                        batch_done)
 
        obs = next_obs
        total_reward += reward
 
        if done or steps >= 200:
            break
    return total_reward

增加扰动保持探索,添加一个高斯噪声。np.clip做一下裁剪,确保在合适的范围内。

总结

本文参与 腾讯云自媒体同步曝光计划,分享自作者个人站点/博客。
原始发表:2021-03-22,如有侵权请联系 cloudcommunity@tencent.com 删除

本文分享自 作者个人站点/博客 前往查看

如有侵权,请联系 cloudcommunity@tencent.com 删除。

本文参与 腾讯云自媒体同步曝光计划  ,欢迎热爱写作的你一起参与!

评论
登录后参与评论
暂无评论
推荐阅读
编辑精选文章
换一批
亿级流量客户端缓存之Http缓存与本地缓存对比
客户端缓存分为Http缓存和本地缓存,使用缓存好处很多,例如减少相同数据的重复传输,节省网络带宽资源缓解网络瓶颈,降低了对原始服务器的要求,避免出现过载,这样服务器可以更快响应其他的请求
架构之家
2022/09/01
1.9K0
亿级流量客户端缓存之Http缓存与本地缓存对比
一文读懂什么是http的强缓存以及协商缓存?简单易懂
浏览器首次请求资源后,需要再次请求时,浏览器会首先获取该资源缓存的header信息,然后根据Cache-Control和expires来判断该资源在本地缓存否过期。若没过期则直接从本地缓存中获取资源信息,浏览器就不再向服务器重新请求资源,如过期则需重新发送请求,重新缓存资源,更新缓存时间。
inline705
2021/12/09
3.2K0
一文读懂什么是http的强缓存以及协商缓存?简单易懂
如何通过Nginx配置来优化你的网络请求
为什么需要优化 缓存可以减少冗余的数据传输。节省了网络带宽,从而更快的加载页面。 缓存降低了服务器的要求,从而服务器更快的响应。 那么我们使用缓存,缓存的资源文件到什么地方去了呢?首先来看下有哪几种缓
兔云小新LM
2019/12/05
1.6K0
如何让浏览器不缓存文件
最近在项目开发中遇到一个需求:项目打包后,可以根据修改配置文件,进而动态替换页面上的文本。由于项目基本不涉及到后端,因此不考虑通过接口来修改。这就需要前端项目打包后需要暴露一个配置文件,每次页面刷新时会获取到最新的配置,达到动态替换页面文本的目的。
chuckQu
2022/08/19
3K0
浏览器 & HTTP 缓存策略
强缓存是指在缓存期间,请求不会发送到服务器,浏览器直接返回缓存结果,需要设置 Header:
leocoder
2020/03/27
6260
图解 HTTP 缓存
本文首发于政采云前端团队博客:图解 HTTP 缓存 https://www.zoo.team/article/http-cache
前端劝退师
2020/05/20
6640
强缓存与协商缓存
浏览器缓存是浏览器在本地磁盘对用户最近请求过的资源进行存储,当访问者再次访问同一资源时,浏览器就可以直接从本地磁盘加载资源,通过缓存的方式就可以减少与服务器的数据传输,减少服务器的负担,加快页面响应速度等。
WindRunnerMax
2020/08/27
1K0
HTTP 缓存机制
完整高频题库仓库地址:https://github.com/hzfe/awesome-interview
HZFEStudio
2021/09/28
1K0
【Http原理】请问 HTTP 是怎么进行缓存的?
HTTP 缓存是一块重要的内容,这是作为一个前端工程师必须要掌握的优化技能,也能让自己明白自己的工作,此次主要分了几个点进行总结
神仙朱
2019/08/02
6100
【Http原理】请问 HTTP 是怎么进行缓存的?
Web 性能优化-缓存-HTTP 缓存
HTTP 缓存通常要配合客户端(浏览器)使用才能发挥效果,所以又被称之为浏览器缓存,是 Web 性能优化的一大利器。
李振
2021/11/26
5880
HTTP缓存策略
缓存的作用就是提升网页加载速度。浏览器加载一个完整的网页势必会引用外部资源(图片,js,css)。若每次加载网页都要去加载这些外部资源则会引起不必要的时间和资源浪费,且会影响用户体验。而解决上述问题需要一个优秀的缓存策略。除此之外,web缓存的优点还有很多,例如:减轻服务器压力
ruochen
2021/11/25
6440
强制缓存和协商缓存的区别
浏览器缓存(Brower Caching)是浏览器在本地磁盘对用户最近请求过的文档进行存储,当访问者再次访问同一页面时,浏览器就可以直接从本地磁盘加载文档。
用户9914333
2022/12/14
1.1K0
强制缓存和协商缓存的区别
浏览器缓存机制剖析
“缓存一直是前端优化的主战场,利用好缓存就成功了一半。本篇从HTTP请求和响应的头域入手,让你对浏览器缓存有个整体的概念。最终你会发现强缓存,协商缓存 和 启发式缓存是如此的简单。 ” 导读 浏览器对
CSDN技术头条
2018/02/12
1.4K0
浏览器缓存机制剖析
设计一个完美的HTTP缓存策略
作为一个前端,了解http缓存是非常必要,它不仅是面试的必要环节,也更是实战开发中必不可少需要了解的知识点,本文作者将从缓存的概念讲到如何在业务中设计一个合理的缓存架构,带你一步一步解开http缓存的神秘面纱。
星哥玩云
2022/07/28
6430
设计一个完美的HTTP缓存策略
HTTP缓存和浏览器的本地存储
http请求做为影响前端性能极为重要的一环,因为请求受网络影响很大,如果网络很慢的情况下,页面很可能会空白很久。对于首次进入网站的用户可能要通过优化接口性能和接口数量来解决。但是,对于重复进入页面的用户,除了浏览器缓存,http缓存可以很大程度对已经加载过的页面进行优化。
用户5807183
2019/10/20
2K0
一文彻底搞懂前端缓存机制_2023-03-15
1)浏览器在加载资源时,先根据这个资源的一些http header判断它是否命中强缓存,强缓存如果命中,浏览器直接从自己的缓存中读取资源,不会发请求到服务器。比如某个css文件,如果浏览器在加载它所在的网页时,这个css文件的缓存配置命中了强缓存,浏览器就直接从缓存中加载这个css,连请求都不会发送到网页所在服务器;
用户10377405
2023/03/15
8340
详解web缓存(转)
缓存分为服务端侧(server side,比如 Nginx、Apache)和客户端侧(client side,比如 web browser)。常用的服务端缓存有CDN缓存,客户端缓存就是指浏览器缓存。
山河木马
2019/03/05
6200
详解web缓存(转)
HTTP缓存,浏览器缓存
可分为两大类:http缓存和浏览器缓存。我们今天重点讲的是http缓存,所以关于浏览器缓存大家自行去查阅。下面这张图是前端缓存的一个大致知识点:
回忆大大
2023/03/19
1.1K0
HTTP缓存,浏览器缓存
相关推荐
亿级流量客户端缓存之Http缓存与本地缓存对比
更多 >
LV.1
这个人很懒,什么都没有留下~
交个朋友
加入腾讯云官网粉丝站
蹲全网底价单品 享第一手活动信息
领券
问题归档专栏文章快讯文章归档关键词归档开发者手册归档开发者手册 Section 归档
本文部分代码块支持一键运行,欢迎体验
本文部分代码块支持一键运行,欢迎体验