R-learning DQN验证（CartPole）

最新推荐文章于 2022-08-06 19:08:27 发布
最新推荐文章于 2022-08-06 19:08:27 发布
阅读量325 收藏 1
点赞数
分类专栏： 强化学习 文章标签： 深度学习 神经网络
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_45875105/article/details/120525581
版权

在这里插入图片描述

环境：

pip install gym
pip install paddlepaddle==1.6.3
pip install parl==1.3.1

经验回放 固定目标

具体代码

replay_memory.py

import collections
import random

import numpy as np

# 经验回放类
class ReplayMemory(object):
    def __init__(self, max_size):
        self.buffer = collections.deque(maxlen=max_size)

    # 增加一条经验
    def append(self, exp):
        self.buffer.append(exp)

    # 经验池 随机抽取 batch_size条经验
    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 exp in mini_batch:
            obs, a, r, n_obs, done = exp
            obs_batch.append(obs)
            action_batch.append(a)
            reward_batch.append(r)
            next_obs_batch.append(n_obs)
            done_batch.append(done)

        sample_data = (self.get_data_np(obs_batch),
                       self.get_data_np(action_batch),
                       self.get_data_np(reward_batch),
                       self.get_data_np(next_obs_batch),
                       self.get_data_np(done_batch))
        return sample_data

    # 数据转换成 numpy
    @staticmethod
    def get_data_np(data):
        return np.array(data).astype('float32')

    # 重写长度 函数
    def __len__(self):
        return len(self.buffer)

神经网络

model.py

import parl
from parl import layers


# 全链接网络模型
class Model(parl.Model):
    def __init__(self, act_dim):
        # 隐藏层 大小
        hid1_size = 128
        hid2_size = 128
        # 3层全链接层
        self.fc1 = layers.fc(size=hid1_size, act='relu')
        self.fc2 = layers.fc(size=hid2_size, act='relu')
        self.fc3 = layers.fc(size=act_dim, act=None)  # 输出层

    # 前向传播
    def value(self, obs):
        # obs: 环境数据
        h1 = self.fc1(obs)  # 隐藏层1
        h2 = self.fc2(h1)  # 隐藏层2
        q_out = self.fc3(h2)  # 输出层
        return q_out

算法

algorithm.py

import copy

import paddle.fluid as fluid
import parl
from parl import layers


class DQN(parl.Algorithm):
    def __init__(self, model, act_dim=None, gamma=None, lr=None):
        self.model = model
        self.target_model = copy.deepcopy(model)

        assert isinstance(act_dim, int)
        assert isinstance(gamma, float)
        assert isinstance(lr, float)
        self.act_dim = act_dim
        self.gamma = gamma
        self.lr = lr

    # 同步网络权重 同步到 目标网络
    def sync_target(self):
        self.model.sync_weights_to(self.target_model)

    # 预测执行
    def predict(self, obs):
        return self.model.value(obs)

    # 学习并更新网络
    def learn(self, obs, action, reward, next_obs, terminal):
        # 目标网络 计算target_Q
        next_predict_value = self.target_model.value(next_obs)
        best_v = layers.reduce_max(next_predict_value, dim=1)
        best_v.stop_gradient = True  # 阻止target_model 更新

        terminal = layers.cast(terminal, dtype='float32')
        target = reward + (1.0 - terminal) * self.gamma * best_v

        # 当前网络 计算Q(s, a)
        predict_value = self.model.value(obs)
        action_one_hot = layers.one_hot(action, self.act_dim)
        action_one_hot = layers.cast(action_one_hot, dtype='float32')
        predict_action_value = layers.reduce_sum(layers.elementwise_mul(action_one_hot, predict_value),
                                                 dim=1)
        # 获取loss 计算Q(s, a)与target_q的均方差
        cost = layers.square_error_cost(predict_action_value, target)
        cost = layers.reduce_mean(cost)

        # 优化器
        optimizer = fluid.optimizer.Adam(learning_rate=self.lr)
        optimizer.minimize(cost)

        return cost

智能体

agent.py

import numpy as np
import paddle.fluid as fluid
import parl
from parl import layers


# 智能体
class Agent(parl.Agent):
    def __init__(self, algorithm, obs_dim, act_dim,
                 e_greed=0.1, e_greed_decrement=0):
        assert isinstance(obs_dim, int)
        assert isinstance(act_dim, int)
        self.obs_dim = obs_dim  # 环境维度
        self.act_dim = act_dim  # 动作维度

        self.alg = algorithm  # 算法
        self.global_step = 0
        self.update_target_steps = 200  # 同步网络的步数

        self.e_greed = e_greed  # 探索的概率
        self.e_greed_decrement = e_greed_decrement  # 探索概率下降

        super(Agent, self).__init__(algorithm)

    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.value = self.alg.predict(obs)

        # 执行 算法的学习
        with fluid.program_guard(self.learn_program):
            # 当前环境
            obs = layers.data(name='obs',
                              shape=[self.obs_dim],
                              dtype='float32')
            # 动作
            action = layers.data(name='act',
                                 shape=[1],
                                 dtype='int32')
            # 回馈
            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.cost = self.alg.learn(obs, action, reward, next_obs, terminal)

    # 学习
    def learn(self, obs, act, reward, next_obs, terminal):
        # 执行同步
        if self.global_step % self.update_target_steps == 0:
            self.alg.sync_target()
            # print('同步一下')

        # 准备数据
        self.global_step += 1
        act = np.expand_dims(act, -1)
        feed = {'obs': obs.astype('float32'),
                'act': act.astype('int32'),
                'reward': reward,
                'next_obs': next_obs.astype('float32'),
                'terminal': terminal}

        # 执行学习
        cost = self.fluid_executor.run(
            self.learn_program, feed=feed, fetch_list=[self.cost])[0]  # 静态程序

        return cost

    # 预测
    def predict(self, obs):
        obs = np.expand_dims(obs, axis=0)
        # 执行预测
        pred_q = self.fluid_executor.run(
            self.pred_program,  # 静态程序
            feed={'obs': obs.astype('float32')},  # 输入数据
            fetch_list=[self.value])[0]  # 输出反馈
        # 获取最优动作
        pred_q = np.squeeze(pred_q, axis=0)
        act = np.argmax(pred_q)
        return act

    # 随机+预测
    def sample(self, obs):
        sample = np.random.rand()
        if sample < self.e_greed:  # 探索随机
            act = np.random.randint(self.act_dim)  # 探索执行
        else:
            act = self.predict(obs)  # 预测执行

        self.e_greed = max(0.01, self.e_greed - self.e_greed_decrement)  # 更新探索概率
        return act

训练

train.py

import gym
import numpy as np
from parl.utils import logger

from agent import Agent
from algorithm import DQN
from model import Model
from replay_memory import ReplayMemory


# 执行 一轮
def run_episode(env, agent, rpm):
    # 初始化环境
    total_reward = 0
    obs = env.reset()
    step = 0

    # 循环执行
    while True:
        step += 1
        # 带探索的 动作
        action = agent.sample(obs)
        # print(agent.e_greed)
        next_obs, reward, done, _ = env.step(action)  # 执行一步
        rpm.append((obs, action, reward, next_obs, done))  # 加入缓存

        # 缓存 与 步数 执行学习
        if (len(rpm) > MEMORY_WAP_SIZE) and (step % LEARN_FREQ == 0):
            # 获取缓存数据
            (batch_obs, batch_action, batch_reward,
             batch_next_obs, batch_done) = rpm.sample(BATCH_SIZE)

            # 学习一次（更新权重）
            train_loss = agent.learn(batch_obs, batch_action,
                                     batch_reward, batch_next_obs,
                                     batch_done)
        # 统计总回馈
        total_reward += reward
        # 更新环境
        obs = next_obs
        if done:  # 结束
            break
    return total_reward


# 评估
def evaluate(env, agent, render=False):
    # 回馈列表
    eval_reward = []
    for i in range(5):
        # 初始化环境
        obs = env.reset()
        episode_reward = 0
        # 执行一个episode
        while True:
            # 预测动作
            action = agent.predict(obs)
            # 执行一步
            obs, reward, done, _ = env.step(action)
            # 统计反馈
            episode_reward += reward
            if render:
                env.render()
            if done:
                break
        # 总反馈加入回馈列表
        eval_reward.append(episode_reward)
    # 返回5次均值
    return np.mean(eval_reward)


def main():
    # 初始化环境
    env = gym.make('CartPole-v0')
    action_dim = env.action_space.n
    obs_shape = env.observation_space.shape

    # 初始化 缓存 模型 算法 智能体
    rpm = ReplayMemory(MEMORY_SIZE)

    model = Model(act_dim=action_dim)

    algorithm = DQN(model, act_dim=action_dim,
                    gamma=GAMMA, lr=LEARNING_RATE,
                    )
    agent = Agent(algorithm, obs_dim=obs_shape[0],
                  act_dim=action_dim,
                  e_greed=0.1,
                  e_greed_decrement=1e-6)

    # 增加 缓存数据
    while len(rpm) < MEMORY_WAP_SIZE:
        run_episode(env, agent, rpm)

    # 总次数
    max_episode = 2000

    episode = 0
    while episode < max_episode:
        # 训练学习 50
        for i in range(0, 50):
            total_reward = run_episode(env, agent, rpm)
            episode += 1
            # print(total_reward)

        # 评估模式
        eval_reward = evaluate(env, agent, render=True)
        # 打印结果
        logger.info('episode:{}    e_greed:{}   test_reward:{}'.format(
            episode, agent.e_greed, eval_reward))
     
	# 训练结束，保存模型
    save_path = './dqn_model.ckpt'
    agent.save(save_path)

if __name__ == '__main__':
    LEARN_FREQ = 5  # 学习频率
    MEMORY_SIZE = 2000  # 缓存大小
    MEMORY_WAP_SIZE = 200  # 启动学习 最小缓存
    BATCH_SIZE = 32

    LEARNING_RATE = 0.001  # 学习率
    GAMMA = 0.99  # 反馈衰减因子

    main()

预测

import gym
import numpy as np
from parl.utils import logger

from agent import Agent
from algorithm import DQN
from model import Model


# 评估
def evaluate(env, agent, render=False):
    # 回馈列表
    eval_reward = []
    for i in range(5):
        # 初始化环境
        obs = env.reset()
        episode_reward = 0
        # 执行一个episode
        while True:
            # 预测动作
            action = agent.predict(obs)
            # 执行一步
            obs, reward, done, _ = env.step(action)
            # 统计反馈
            episode_reward += reward
            if render:
                env.render()
            if done:
                break
        # 总反馈加入回馈列表
        eval_reward.append(episode_reward)
    # 返回5次均值
    return np.mean(eval_reward)


def main():
    # 初始化环境
    env = gym.make('CartPole-v0')
    action_dim = env.action_space.n
    obs_shape = env.observation_space.shape

    # 初始化 模型 算法 智能体

    model = Model(act_dim=action_dim)

    algorithm = DQN(model, act_dim=action_dim,
                    gamma=GAMMA, lr=LEARNING_RATE,
                    )
    agent = Agent(algorithm, obs_dim=obs_shape[0],
                  act_dim=action_dim,
                  e_greed=0.1,
                  e_greed_decrement=1e-6)

    # 加载模型
    save_path = './dqn_model.ckpt'
    agent.restore(save_path)

    # 总次数
    max_episode = 3

    episode = 0
    while episode < max_episode:

        # 评估模式
        eval_reward = evaluate(env, agent, render=True)
        # 打印结果
        logger.info('episode:{}    e_greed:{}   test_reward:{}'.format(
            episode, agent.e_greed, eval_reward))


if __name__ == '__main__':
    LEARNING_RATE = 0.001  # 学习率
    GAMMA = 0.99  # 反馈衰减因子

    main()
廷益--飞鸟
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
DQN实验经验
weixin_52293300的博客
12-20 262
学习DQN算法实验时的一些经验
【RL】基于神经网络（深度学习）的Q学习算法（DQN)
qq_42292095的博客
01-28 3127
文章目录DQN介绍DDQN介绍编程-基于Pytorch实现DQN求解PuckWorld问题PuckWorld环境介绍： DQN介绍 DQN（Deep Q-Learning）是将深度学习与强化学习相结合，当Q-table他过于庞大无法建立的话，使用DQN是一种很好的选择。 DQN算法主要使用经历回放（experience replay)(经验池）来实现价值函数的收敛。 使用Deep Q-learning方法，从每一episode中得到的奖励来迭代更新Q(s,a). DQN算法中，（具体方法后续更出）继将每一
DRQN和DARQN详解
02-27
深度强化学习DQN的两中改进方法的详细介绍，Deep recurrent Q-learning和Deep attention recurrent Q-learning
from parl import layers失败问题
wxyggggg的博客
07-30 1045
百度feijaing强化学习DDPG导入问题
RL | DQN
silence_iz的博客
09-04 316
CatalogueDQN FrameworkApplication1.1 Cartpole Introduction1.2 CodeReference DQN Framework The agent interacts with the environment to generate next state, reward and termination information, which will be stored in a replay buffer. Agent与环境交互，产生下一个状态、奖
RLcode：自我实现的强化学习算法
02-10
2. **Deep Q-Network (DQN)**：DQN是Q-Learning的扩展，使用深度神经网络（DNN）作为函数逼近器来估计Q值，解决了Q-Learning中的经验回放缓冲区和稳定性问题。 3. **SARSA (State-Action-Reward-State-Action)**：...
DQN+PyTorch+gym倒立摆登山车源码&模型
01-09
这两个都是经典的强化学习（Reinforcement Learning, RL）任务，用于测试和验证智能体的学习能力。 首先，我们来看倒立摆（CartPole）问题。这是一个连续状态和动作空间的环境，目标是通过控制推车左右移动来保持...
DeepRLexamples.jl：使用Julia的深度强化学习示例
02-04
在这个过程中，Q-learning、Deep Q-Network (DQN)、Proximal Policy Optimization (PPO)等算法可能被用于训练代理。 DQN是深度强化学习中的一个里程碑，它引入了一个经验回放缓冲区来稳定学习过程，并用神经网络...
Python-深度强化学习的异步方法实现
08-09
在1-step Q Learning的实现中，Gym环境用于模拟智能体与环境的交互，如Atari游戏或CartPole平衡任务。 6. **1-step Q Learning**： 1-step Q Learning算法基于贝尔曼方程，通过每次迭代更新一个动作的Q值来逼近...
LearningQ-源码.rar
10-10
1. **env**: 这个目录通常包含各种环境模拟器，例如经典的CartPole平衡问题或Atari游戏。这些环境模拟器提供了与外部世界互动的接口，允许智能体执行动作并接收反馈。 2. **agent**: 这里包含了强化学习算法的实现...
深度强化学习 ( DQN ) 初探
Qcloud_KID的博客
05-04 4115
1. Google的DQN论文 2015年2月，Google在Nature上发表了一篇论文(见附件)：Human-level control through deep reinforcement learning。文章描述了如何让电脑自己学会打Atari 2600电子游戏。 Atari 2600是80年代风靡美国的游戏机，总共包括49个独立的游戏，其中不乏我们熟悉的Breakout
强化学习算法 DQN 解决 CartPole 问题，代码逐条详解
AItrust的博客
06-19 6700
本文内容源自百度强化学习 7 日入门课程学习整理 感谢百度 PARL 团队李科浇老师的课程讲解 强化学习算法 DQN 解决 CartPole 问题，移动小车使得车上的摆杆保持直立。 这个游戏环境可以说是强化学习中的 “Hello World” 大部分的算法都可以先利用这个环境来测试下是否可以收敛 环境介绍： 小车在一个导轨上，无摩擦地来回移动，车上有一根杆子，可以绕着小车上的一个点旋转，所以我们要做的是，通过推动小车往左或者往右，来确保杆子不倒 终止条件： 杆子角度大于 +/-12度 车.
使用PARL实现基于DQN算法的AI Flappy-Bird
zbp_12138的博客
06-22 1657
用PARL的官方 DQN 算法，玩Flappy-Bird的案例其实在2019年4月份就有了,所以这里准确说,应该是复现。 但是如果用现在1.3.1版本的PARL框架运行,会有一些版本不兼容的问题,而且也不能直接在AI Studio里运行,所以我借着这个机会,完善一下,并且巩固一下最近学的内容。 我已在AI Studio公开这个项目: https://aistudio.baidu.com/aistudio/projectdetail/580622 首先在本地试着把这个项目项目跑起来 在本地可视化地展示Flap
Paddle强化学习从入门到实践 （Day1）
fan1102958151的博客
06-17 794
强化学习简介 定义：强化学习（英语：Reinforcement learning，简称RL）是机器学习中的一个领域，强调如何基于环境而行动，以取得最大化的预期利益。 核心思想：智能体agent在环境environment中学习，根据环境的状态state（或观测到的observation），执行动作action，并根据环境的反馈 reward（奖励）来指导更好的动作。简单归结为下图： 注意：从环境中获取的状态，有时候叫s...
百度深度强化学习框架PARL技术学习笔记
u011293656的博客
06-21 1097
这里写自定义目录标题百度深度强化学习框架技术笔记新的改变功能快捷键合理的创建标题，有助于目录的生成如何改变文本的样式插入链接与图片如何插入一段漂亮的代码片生成一个适合你的列表创建一个表格设定内容居中、居左、居右SmartyPants创建一个自定义列表如何创建一个注脚注释也是必不可少的KaTeX数学公式新的甘特图功能，丰富你的文章UML 图表FLowchart流程图导出与导入导出导入 百度深度强化学习框架技术笔记 你好！ 这是你第一次使用 Markdown编辑器 所展示的欢迎页。如果你想学习如何使用Markd
多智能体强化学习_多智能体强化学习的几种Best Practice
weixin_39812577的博客
11-30 1654
（草稿阶段，完成度40%）这里分享一下A Survey and Critique of Multiagent Deep Reinforcement Learning这篇综述里面介绍的多智能体强化学习Best Practice。这部分内容大部分来自第四章，但是我根据自己的理解加上了其他的内容。1.改良Experience replay buffer1.1 传统的Single-agent场景之下的Re...
RL强化学习总结（四）——DQN算法
Elon15的博客
08-06 1528
DQN算法
DQN解析
sunlight_meng的博客
04-24 2486
DQN使用神经网络来近似值函数，即神经网络的输入是state s,输出是Q(s,a)， 通过神经网络计算出值函数后，DQN使用ϵ−greedy策略来输出action。值函数网络与ϵ−greedy策略之间的联系是这样的：首先环境会给出一个obs，智能体根据值函数网络得到关于这个obs的所有Q(s,a)Q(s,a)，然后利用ϵ−greedy选择action并做出决策，环境接收到此action后会给出一个奖励Rew及下一个obs。这是一个step。此时我们根据Rew去更新值函数网络的参数。接着进入下一个step
dqn pytorch cartpole-v0
最新发布
07-18
在使用 PyTorch 实现 DQN 解决 CartPole-v0 问题时，需要首先定义一个深度神经网络模型作为 Q 函数的近似。这个模型通常包含若干隐藏层和一个输出层，用于预测在给定状态下采取各个动作的 Q 值。 然后，需要定义一...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

廷益--飞鸟

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

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

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

打赏作者

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

抵扣说明：

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

余额充值