百度飞浆——强化学习笔记
强化学习笔记
- 概论和初印象
- 第一天学习
- 基础补充
- 迷宫游戏（SRASA）
- 迷宫游戏（Qlearning）
- 算法区别
- 第二天学习
- DQN知识点
- 经验回放
- 固定Q目标
- 算法流程
- MountainCar (DQN)
- 第三天学习
- Policy Gradient知识点
- 公式推导
- PG解决Pong
- 第四天学习
- DDPG
- 四轴飞行器悬停
首先我是小萌新一个，课程资料图片来自网络，最近在跟着百度飞浆学习强化学习和深度学习，欢迎大佬给我指出我写的不对的地方和解答一些我的疑惑。
概论和初印象
强化学习在游戏有广泛应用，下面提供一个游戏链接的实例：
https://www.bilibili.com/video/BV1nE411H7qJ/?spm_id_from=333.788.videocard.1
其实第一次看这个视屏我陷入了哲学哈哈，万一他学习到最后学习到他们只是在游戏中开始消极对待怎么办，或者再后来，一开始消极对待，然后他意识到你说的这一点又开始假装积极对待。
这是强化学习的一个实例，掉到坑里是负反馈，到达目的地给正反馈。（当时第一感觉是有点像DFS和BFS哎）
这是强化学习和监督学习的区别示例图，一般做预测的时候监督学习（比如深度学习的图像分类，前段时间刚入门）就会预测出图片中的物种是啥，但是强化学习则会告诉你决策，熊大熊二不是好惹的，赶紧撞死骗过去。
以下是我的一点小疑惑，请有系统学习过的同学或者老师可以解答下嘛：
就是遗传算法，粒子群算法等和强化学习的区别和联系
这个是强化学习的分类概况，以后学习的课程也是按这个分支来的
这是算法库和框架库
PARL有着优秀的并行能力
第一天学习
基础补充
强化学习四元组
s：state 状态
a：action 动作
r：reward 奖励
p：probability 状态转移概率
给个图方便理解
下面给出决策树更好地理解下
但是这样给了明确的概率和奖励对应函数，其实可以用动态规划做。但强化学习其实是一种P,R都未知的情况下的试错。
下面给出Q表格是如何存放内容的
怎么解读下面一个图呢，当前状态如果闯红灯会得到负反馈，但如果是一个抢救事件，那么把病人送到医院的奖励是巨大的，因此我们还要考虑未来收益，所以此种情况下闯红灯是可以的，因此算上未来总收益才能更好反应当前Q值。
但是，真的是考虑的越远越好吗？我们做一个事顶多考虑后面一段时间的影响，真的会把几年甚至几十年后的事也要想清楚吗？这样显然是不合理的。
因此计算未来总收益引入了折扣率（我喜欢把它理解叫做“目光短浅-目光长远”平衡因素）当趋向于0时，想当时只考虑当前回报，趋向于1时就很贪心，所有回报都去考虑了。
下面这个图解释得非常详细，Q是如何更新的，以及下一步的收益是如何影响当时收益的。不理解Q和G的同学可以把它们看成近似相等。下一步收益越大自然会导致当时的收益变大。
迷宫游戏（SRASA）
先把该导入的都导入了
!pip install gym
import gym
import numpy as np
import time
下面定义一个类，我会按各个模块贴出来方便讲解
class SarsaAgent(object):
首先定义变量
def __init__(self, obs_n, act_n, learning_rate=0.01, gamma=0.9, e_greed=0.1):
self.act_n = act_n # 动作维度，有几个动作可选
self.lr = learning_rate # 学习率
self.gamma = gamma # reward的衰减率
self.epsilon = e_greed # 按一定概率随机选动作
self.Q = np.zeros((obs_n, act_n))
根据输入观察值，采样输出的动作值，带探索，我们可以把这里的observation理解为局部的状态S，具体探索的概率可以自己设置合理的
def sample(self, obs):
if np.random.uniform(0,1)<(1-self.epsilon):
action=self.predict(obs)
else:
action=np.random.choice(self.act_n)#没学过我觉得这里应该是返回动作集的索引而不是具体的动作?
return action
根据输入观察值，预测输出的动作值
def predict(self, obs):
Q_list=self.Q[obs,:]
maxQ=np.max(Q_list)
action_list=np.where(maxQ==Q_list)[0]#这一行不懂，测试看看放在此cell的下面
action=np.random.choice(action_list)
return action
结合上面两个模块让我们测试一下我标注的到底是干嘛的
a=np.random.randn(4)
print(a)
maxtext=np.max(a)
print(maxtext)
b=np.where(maxtext==a)
print(b)
c=np.random.choice(b[0])
print(c)
[ 0.7306868 -1.70580094 1.15283074 -0.26736715]
1.152830743940724
(array([2]),)
2
根据输出结果我们可以看出返回的确实不是具体动作而是动作的索引，但是choice返回的不应该是值嘛？为什么也是索引呢，这是因为放进choice的列表本身保存的就是一系列索引。
下面给出SRASA的更新公式
def learn(self, obs, action, reward, next_obs, next_action, done):
""" on-policy
obs: 交互前的obs, s_t
action: 本次交互选择的action, a_t
reward: 本次动作获得的奖励r
next_obs: 本次交互后的obs, s_t+1
next_action: 根据当前Q表格, 针对next_obs会选择的动作, a_t+1
done: episode是否结束
"""
predict_Q=self.Q[obs,action]
if done:
target_Q = reward
else:
target_Q = reward + self.gamma * self.Q[next_obs, next_action]
self.Q[obs, action] += self.lr * (target_Q - predict_Q)
def run_episode(env, agent, render=False):
total_steps = 0 # 记录每个episode走了多少step
total_reward = 0
obs = env.reset() # 重置环境, 重新开一局（即开始新的一个episode）
action = agent.sample(obs) # 根据算法选择一个动作
while True:
next_obs, reward, done, _ = env.step(action) # 与环境进行一个交互
next_action = agent.sample(next_obs) # 根据算法选择一个动作
# 训练 Sarsa 算法
agent.learn(obs, action, reward, next_obs, next_action, done)
action = next_action
obs = next_obs # 存储上一个观察值
total_reward += reward
total_steps += 1 # 计算step数
if render:
env.render() #渲染新的一帧图形
if done:
break
return total_reward, total_steps
def test_episode(env, agent):
total_reward = 0
obs = env.reset()
while True:
action = agent.predict(obs) # greedy
next_obs, reward, done, _ = env.step(action)
total_reward += reward
obs = next_obs
# time.sleep(0.5)
# env.render()
if done:
break
return total_reward
# 使用gym创建迷宫环境，设置is_slippery为False降低环境难度
env = gym.make("FrozenLake-v0", is_slippery=False) # 0 left, 1 down, 2 right, 3 up
# 创建一个agent实例，输入超参数
agent = SarsaAgent(
obs_n=env.observation_space.n,
act_n=env.action_space.n,
learning_rate=0.1,
gamma=0.9,
e_greed=0.1)
# 训练500个episode，打印每个episode的分数
for episode in range(500):
ep_reward, ep_steps = run_episode(env, agent, False)
print('Episode %s: steps = %s , reward = %.1f' % (episode, ep_steps, ep_reward))
# 全部训练结束，查看算法效果
test_reward = test_episode(env, agent)
print('test reward = %.1f' % (test_reward))
迷宫游戏（Qlearning）
Qlearning和Sarsa算法唯一的区别是更新公式不一样因此我们只需要在sarsa基础上改一下更新公式就行
def learn(self, obs, action, reward, next_obs, done):
""" off-policy
obs: 交互前的obs, s_t
action: 本次交互选择的action, a_t
reward: 本次动作获得的奖励r
next_obs: 本次交互后的obs, s_t+1
done: episode是否结束
"""
predict_Q = self.Q[obs, action]
if done:
target_Q = reward # 没有下一个状态了
else:
target_Q = reward + self.gamma * np.max(self.Q[next_obs, :]) # Q-learning
self.Q[obs, action] += self.lr * (target_Q - predict_Q) # 修正q
一句话总结：SRASA怕死，Qlearning不怕死莽夫好吧
还有我觉得动态规划和强化学习的区别应该就是动态规划都是预先知道所有奖励和概率的，因此填表可以求得最优解，但是强化学习奖励需要算，概率也未知
算法区别
下面分析下两个算法的区别，引用来自
https://blog.csdn.net/weixin_37895339/article/details/74937023
Q-learning在每一步TD中贪心的获取下一步最优的状态动作值函数。而Sarsa则是e-greedy的选取TD中的下一个状态动作值函数。在这种情况下，Q-learning更倾向于找到一条最优policy，而Sarsa则会找到一条次优的policy。这是由于Sarsa在TD误差中随机的选取下一个状态动作值函数，这样可能会使整体的状态值函数降低。如下示例进一步说明这种情况
The cliff是一个悬崖，上面的小方格表示可以走的道路。S为起点，G为终点。悬崖的reward为-100，小方格的reward为-1。则Q-learning的结果为optimial path最优路径。Sarsa的结果为safe path次优路径。这是由于在Sarsa更新的过程中，如果在悬崖边缘处，下一个状态由于是随机选取可能会掉下悬崖，因此当前状态值函数会降低，使得智能体不愿意走靠近悬崖的路径。而Q-learning在悬崖边选取的下一步是最优路径，不会掉下悬崖，因此更偏向于走悬崖边的最优路径。
如果e-greedy的e逐渐衰减，则Sarsa与Q-learning的结果都近似收敛到最优解。
第二天学习
DQN知识点
Q表存储的缺点是当表格需求非常大时，占的空间非常大，这显然非常让费资源，因此引入了DQN，当初学数据结构写过迷宫程序的同学可能会有体会哈，如果计算机空间太小，但是你想设置的地图有特别大呢，可能会导致空间不足哦。
下面给出了解决方案，用值函数近似Q表格的方法
下面解释一下什么是神经网络，小白可以理解成黑盒，你只管输入，经过神经网络会给你一个输出（有点像是函数）
下面给出一些神经网络的栗子
类比Qlearning我们看下DQN是怎么实现的
类比监督学习的神经网络，我们一般是计算预测值和标签值的loss，然后反向传播利用优化器以最小化loss为目标不断更新参数。
DQN有两大创新点
经验回放
军师提供一个Q表格（战术）士兵根据Q表格去攻打堡垒，攻打完后会积累一定的经验作为经验池，但是如果经验池存满了，士兵继续放经验池就会替换最老的经验池里的一条经验（先进先出队列），军师从经验池中随机抽取batch条经验用来优化战术。
优点有
- 打乱样本关联性
- 提高样本利用率
固定Q目标
理解下，我们的目标是使预测逼近真实，监督学习中，真实是固定的，因此稳定性好，但是我们DQN的真实值事实上也是经过计算得出的，会有一定的变化，因此我们可以将它在一段时间内固定住来逼近调整参数。
算法流程
MountainCar (DQN)
库导入
import parl
from parl import layers
import paddle.fluid as fluid
import copy
import numpy as np
import os
import gym
from parl.utils import logger
设置超参数
LEARN_FREQ = 5 # 训练频率，不需要每一个step都learn，攒一些新增经验后再learn，提高效率
MEMORY_SIZE = 20000 # replay memory的大小，越大越占用内存
MEMORY_WARMUP_SIZE = 200 # replay_memory 里需要预存一些经验数据，再从里面sample一个batch的经验让agent去learn
BATCH_SIZE = 32 # 每次给agent learn的数据数量，从replay memory随机里sample一批数据出来
GAMMA = 0.99 # reward 的衰减因子，一般取 0.9 到 0.999 不等
######################################################################
######################################################################
#
# 1. 请设定 learning rate，可以从 0.001 起调，尝试增减
#
######################################################################
######################################################################
LEARNING_RATE = 0.001 # 学习率
Model用来定义前向(Forward)网络，用户可以自由的定制自己的网络结构
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):
# 定义网络
# 输入state，输出所有action对应的Q，[Q(s,a1), Q(s,a2), Q(s,a3)...]
h1 = self.fc1(obs)
h2 = self.fc2(h1)
Q = self.fc3(h2)
return Q
Algorithm定义了具体的算法来更新前向网络(Model)，也就是通过定义损失函数来更新Model，和算法相关的计算都放在algorithm中
from parl.algorithms import DQN # 直接从parl库中导入DQN算法，无需自己重写算法
Agent负责算法与环境的交互，在交互过程中把生成的数据提供给Algorithm来更新模型(Model)，数据的预处理流程也一般定义在这里。
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
super(Agent, self).__init__(algorithm)
self.global_step = 0
self.update_target_steps = 200 # 每隔200个training steps再把model的参数复制到target_model中
self.e_greed = e_greed # 有一定概率随机选取动作，探索
self.e_greed_decrement = e_greed_decrement # 随着训练逐步收敛，探索的程度慢慢降低
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): # 搭建计算图用于 更新Q网络，定义输入输出变量
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 sample(self, obs):
sample = np.random.rand() # 产生0~1之间的小数
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
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) # 选择Q最大的下标，即对应的动作
return act
def learn(self, obs, act, reward, next_obs, terminal):
# 每隔200个training steps同步一次model和target_model的参数
if self.global_step % self.update_target_steps == 0:
self.alg.sync_target()
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
经验池：用于存储多条经验，实现 经验回放。
# replay_memory.py
import random
import collections
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)
# 从经验池中选取N条经验出来
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)
# 训练一个episode
def run_episode(env, agent, rpm):
total_reward = 0
obs = env.reset()
step = 0
while True:
step += 1
action = agent.sample(obs) # 采样动作，所有动作都有概率被尝试到
next_obs, reward, done, _ = env.step(action)
rpm.append((obs, action, reward, next_obs, done))
# train model
if (len(rpm) > MEMORY_WARMUP_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) # s,a,r,s',done
total_reward += reward
obs = next_obs
if done:
break
return total_reward
# 评估 agent, 跑 5 个episode，总reward求平均
def evaluate(env, agent, render=False):
eval_reward = []
for i in range(5):
obs = env.reset()
episode_reward = 0
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)
return np.mean(eval_reward)
# 创建环境
env = gym.make('MountainCar-v0')
action_dim = env.action_space.n # MountainCar-v0: 3
obs_shape = env.observation_space.shape # MountainCar-v0: (2,)
# 创建经验池
rpm = ReplayMemory(MEMORY_SIZE) # DQN的经验回放池
# 根据parl框架构建agent
######################################################################
######################################################################
#
# 4. 请参考课堂Demo，嵌套Model, DQN, Agent构建 agent
#
######################################################################
######################################################################
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.5, # 有一定概率随机选取动作，探索
e_greed_decrement=1e-6) # 随着训练逐步收敛，探索的程度慢慢降低
# 加载模型
# save_path = './dqn_model.ckpt'
# agent.restore(save_path)
# 先往经验池里存一些数据，避免最开始训练的时候样本丰富度不够
while len(rpm) < MEMORY_WARMUP_SIZE:
run_episode(env, agent, rpm)
max_episode = 2000
# 开始训练
episode = 0
while episode < max_episode: # 训练max_episode个回合，test部分不计算入episode数量
# train part
for i in range(0, 50):
total_reward = run_episode(env, agent, rpm)
episode += 1
# test part
eval_reward = evaluate(env, agent, render=False) # 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)
第三天学习
Policy Gradient知识点
我们看下基于概率和价值的区别，概率是最终由softmax输出的
我们了解一下状态转移概率
期望回报的计算
我们看一下基于value和基于策略的优化目标的区别，基于value优化目标是让预测与真实值的差值减小，但是基于策略输出的是基于概率的动作，因此我们的优化目标可以是reward，使它上升
为了使reward上升，我们引入梯度上升概念。
我们来看下MC和TD的区别，MC需要在算完后学习，计算奖励，而TD是在训练中就可计算奖励。
公式推导
字有点丑，请见谅
PG解决Pong
环境依赖
!pip install gym
!pip install atari-py # 玩Gym的Atari游戏必装依赖，本次作业使用了Atari的Pong(乒乓球)环境
!pip install parl==1.3.1
库导入
import os
import gym
import numpy as np
import paddle.fluid as fluid
import parl
from parl import layers
from parl.utils import logger
Model用来定义前向(Forward)网络，用户可以自由的定制自己的网络结构。
class Model(parl.Model):
def __init__(self, act_dim):
######################################################################
######################################################################
#
# 2. 请参考课程Demo，配置model结构
#
######################################################################
######################################################################
act_dim = act_dim
hid1_size = act_dim * 10
self.fc1 = layers.fc(size=hid1_size, act='tanh')
self.fc2 = layers.fc(size=act_dim, act='softmax')
def forward(self, obs): # 可直接用 model = Model(5); model(obs)调用
######################################################################
######################################################################
#
# 3. 请参考课程Demo，组装policy网络
#
######################################################################
######################################################################
out = self.fc1(obs)
out = self.fc2(out)
return out
Algorithm 定义了具体的算法来更新前向网络(Model)，也就是通过定义损失函数来更新Model，和算法相关的计算都放在algorithm中。
from parl.algorithms import PolicyGradient # 直接从parl库中导入PolicyGradient算法，无需重复写算法
Agent负责算法与环境的交互，在交互过程中把生成的数据提供给Algorithm来更新模型(Model)，数据的预处理流程也一般定义在这里。
class Agent(parl.Agent):
def __init__(self, algorithm, obs_dim, act_dim):
self.obs_dim = obs_dim
self.act_dim = act_dim
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.act_prob = self.alg.predict(obs)
with fluid.program_guard(
self.learn_program): # 搭建计算图用于 更新policy网络，定义输入输出变量
obs = layers.data(
name='obs', shape=[self.obs_dim], dtype='float32')
act = layers.data(name='act', shape=[1], dtype='int64')
reward = layers.data(name='reward', shape=[], dtype='float32')
self.cost = self.alg.learn(obs, act, reward)
def sample(self, obs):
obs = np.expand_dims(obs, axis=0) # 增加一维维度
act_prob = self.fluid_executor.run(
self.pred_program,
feed={'obs': obs.astype('float32')},
fetch_list=[self.act_prob])[0]
act_prob = np.squeeze(act_prob, axis=0) # 减少一维维度
act = np.random.choice(range(self.act_dim), p=act_prob) # 根据动作概率选取动作
return act
def predict(self, obs):
obs = np.expand_dims(obs, axis=0)
act_prob = self.fluid_executor.run(
self.pred_program,
feed={'obs': obs.astype('float32')},
fetch_list=[self.act_prob])[0]
act_prob = np.squeeze(act_prob, axis=0)
act = np.argmax(act_prob) # 根据动作概率选择概率最高的动作
return act
def learn(self, obs, act, reward):
act = np.expand_dims(act, axis=-1)
feed = {
'obs': obs.astype('float32'),
'act': act.astype('int64'),
'reward': reward.astype('float32')
}
cost = self.fluid_executor.run(
self.learn_program, feed=feed, fetch_list=[self.cost])[0]
return cost
def run_episode(env, agent):
obs_list, action_list, reward_list = [], [], []
obs = env.reset()
while True:
obs = preprocess(obs) # from shape (210, 160, 3) to (100800,)
obs_list.append(obs)
action = agent.sample(obs) # 采样动作
action_list.append(action)
obs, reward, done, info = env.step(action)
reward_list.append(reward)
if done:
break
return obs_list, action_list, reward_list
# 评估 agent, 跑 5 个episode，求平均
def evaluate(env, agent, render=False):
eval_reward = []
for i in range(5):
obs = env.reset()
episode_reward = 0
while True:
obs = preprocess(obs) # from shape (210, 160, 3) to (100800,)
action = agent.predict(obs) # 选取最优动作
obs, reward, isOver, _ = env.step(action)
episode_reward += reward
if render:
env.render()
if isOver:
break
eval_reward.append(episode_reward)
return np.mean(eval_reward)
# Pong 图片预处理
def preprocess(image):
""" 预处理 210x160x3 uint8 frame into 6400 (80x80) 1维 float vector """
image = image[35:195] # 裁剪
image = image[::2,::2,0] # 下采样，缩放2倍
image[image == 144] = 0 # 擦除背景 (background type 1)
image[image == 109] = 0 # 擦除背景 (background type 2)
image[image != 0] = 1 # 转为灰度图，除了黑色外其他都是白色
return image.astype(np.float).ravel()
# 根据一个episode的每个step的reward列表，计算每一个Step的Gt
def calc_reward_to_go(reward_list, gamma=0.99):
"""calculate discounted reward"""
reward_arr = np.array(reward_list)
for i in range(len(reward_arr) - 2, -1, -1):
# G_t = r_t + γ·r_t+1 + ... = r_t + γ·G_t+1
reward_arr[i] += gamma * reward_arr[i + 1]
# normalize episode rewards
reward_arr -= np.mean(reward_arr)
reward_arr /= np.std(reward_arr)
return reward_arr
# 创建环境
env = gym.make('Pong-v0')
obs_dim = 80 * 80
act_dim = env.action_space.n
logger.info('obs_dim {}, act_dim {}'.format(obs_dim, act_dim))
# 根据parl框架构建agent
######################################################################
######################################################################
#
# 4. 请参考课堂Demo构建 agent，嵌套Model, PolicyGradient, Agent
#
######################################################################
######################################################################
model = Model(act_dim=act_dim)
alg = PolicyGradient(model, lr=LEARNING_RATE)
agent = Agent(alg, obs_dim=obs_dim, act_dim=act_dim)
# 加载模型
# if os.path.exists('./model.ckpt'):
# agent.restore('./model.ckpt')
for i in range(1000):
obs_list, action_list, reward_list = run_episode(env, agent)
# if i % 10 == 0:
# logger.info("Train Episode {}, Reward Sum {}.".format(i,
# sum(reward_list)))
batch_obs = np.array(obs_list)
batch_action = np.array(action_list)
batch_reward = calc_reward_to_go(reward_list)
agent.learn(batch_obs, batch_action, batch_reward)
if (i + 1) % 100 == 0:
total_reward = evaluate(env, agent, render=False)
logger.info('Episode {}, Test reward: {}'.format(i + 1,
total_reward))
# save the parameters to ./model.ckpt
agent.save('./model.ckpt')
第四天学习
DDPG
理解离散动作和确定动作的区别
你说要求的连续动作可以通过缩放求得
DQN的目标是选取动作以达到使Q最大化的目的，DDPG多了一个策略网络用来输出动作值，此动作以让Q最大化为目标。因此此策略网络的loss=-Q，即最小化-Q，相当于最大化Q值
深色的两个网络用来稳定真实值，浅色的网络用于计算Q值不断逼近真实值。
四轴飞行器悬停
环境依赖和库导入
!pip install paddlepaddle==1.6.3
!pip install parl==1.3.1
!pip install rlschool==0.3.1
# 检查依赖包版本是否正确
!pip list | grep paddlepaddle
!pip list | grep parl
!pip list | grep rlschool
import os
import numpy as np
import parl
from parl import layers
from paddle import fluid
from parl.utils import logger
from parl.utils import action_mapping # 将神经网络输出映射到对应的 实际动作取值范围 内
from parl.utils import ReplayMemory # 经验回放
from rlschool import make_env # 使用 RLSchool 创建飞行器环境
设置超多超多的超参数
######################################################################
######################################################################
#
# 1. 请设定 learning rate，尝试增减查看效果
#
######################################################################
######################################################################
ACTOR_LR = 0.0002 # Actor网络更新的 learning rate
CRITIC_LR = 0.001 # Critic网络更新的 learning rate
GAMMA = 0.99 # reward 的衰减因子，一般取 0.9 到 0.999 不等
TAU = 0.001 # target_model 跟 model 同步参数 的 软更新参数
MEMORY_SIZE = 1e6 # replay memory的大小，越大越占用内存
MEMORY_WARMUP_SIZE = 1e4 # replay_memory 里需要预存一些经验数据，再从里面sample一个batch的经验让agent去learn
REWARD_SCALE = 0.01 # reward 的缩放因子
BATCH_SIZE = 256 # 每次给agent learn的数据数量，从replay memory随机里sample一批数据出来
TRAIN_TOTAL_STEPS = 1e6 # 总训练步数
TEST_EVERY_STEPS = 1e4 # 每个N步评估一下算法效果，每次评估5个episode求平均reward
分别搭建Actor、Critic的Model结构，构建QuadrotorModel
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
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
class QuadrotorModel(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()
可以采用下面的方式从parl库中快速引入DDPG算法，无需自己重新写算法
from parl.algorithms import DDPG
class QuadrotorAgent(parl.Agent):
def __init__(self, algorithm, obs_dim, act_dim=4):
assert isinstance(obs_dim, int)
assert isinstance(act_dim, int)
self.obs_dim = obs_dim
self.act_dim = act_dim
super(QuadrotorAgent, self).__init__(algorithm)
# 注意，在最开始的时候，先完全同步target_model和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]
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
def run_episode(env, agent, rpm):
obs = env.reset()
total_reward, steps = 0, 0
while True:
steps += 1
batch_obs = np.expand_dims(obs, axis=0)
action = agent.predict(batch_obs.astype('float32'))
action = np.squeeze(action)
# 给输出动作增加探索扰动，输出限制在 [-1.0, 1.0] 范围内
action = np.clip(np.random.normal(action, 1.0), -1.0, 1.0)
# 动作映射到对应的 实际动作取值范围 内, action_mapping是从parl.utils那里import进来的函数
action = action_mapping(action, env.action_space.low[0],
env.action_space.high[0])
next_obs, reward, done, info = env.step(action)
rpm.append(obs, action, REWARD_SCALE * reward, next_obs, done)
if rpm.size() > MEMORY_WARMUP_SIZE:
batch_obs, batch_action, batch_reward, batch_next_obs, \
batch_terminal = rpm.sample_batch(BATCH_SIZE)
critic_cost = agent.learn(batch_obs, batch_action, batch_reward,
batch_next_obs, batch_terminal)
obs = next_obs
total_reward += reward
if done:
break
return total_reward, steps
# 评估 agent, 跑 5 个episode，总reward求平均
def evaluate(env, agent):
eval_reward = []
for i in range(5):
obs = env.reset()
total_reward, steps = 0, 0
while True:
batch_obs = np.expand_dims(obs, axis=0)
action = agent.predict(batch_obs.astype('float32'))
action = np.squeeze(action)
action = action_mapping(action, env.action_space.low[0],
env.action_space.high[0])
next_obs, reward, done, info = env.step(action)
obs = next_obs
total_reward += reward
steps += 1
if done:
break
eval_reward.append(total_reward)
return np.mean(eval_reward)
# 创建飞行器环境
env = make_env("Quadrotor", task="hovering_control")
env.reset()
obs_dim = env.observation_space.shape[0]
act_dim = env.action_space.shape[0]
# 根据parl框架构建agent
######################################################################
######################################################################
#
# 6. 请构建agent: QuadrotorModel, DDPG, QuadrotorAgent三者嵌套
#
######################################################################
######################################################################
model = QuadrotorModel(act_dim)
algorithm = DDPG(
model, gamma=GAMMA, tau=TAU, actor_lr=ACTOR_LR, critic_lr=CRITIC_LR)
agent = QuadrotorAgent(algorithm, obs_dim, act_dim)
# parl库也为DDPG算法内置了ReplayMemory，可直接从 parl.utils 引入使用
rpm = ReplayMemory(int(MEMORY_SIZE), obs_dim, act_dim)
# 启动训练
test_flag = 0
total_steps = 0
while total_steps < TRAIN_TOTAL_STEPS:
train_reward, steps = run_episode(env, agent, rpm)
total_steps += steps
#logger.info('Steps: {} Reward: {}'.format(total_steps, train_reward)) # 打印训练reward
if total_steps // TEST_EVERY_STEPS >= test_flag: # 每隔一定step数，评估一次模型
while total_steps // TEST_EVERY_STEPS >= test_flag:
test_flag += 1
evaluate_reward = evaluate(env, agent)
logger.info('Steps {}, Test reward: {}'.format(
total_steps, evaluate_reward)) # 打印评估的reward
# 每评估一次，就保存一次模型，以训练的step数命名
ckpt = 'model_dir/steps_{}.ckpt'.format(total_steps)
agent.save(ckpt)