前一节课讲了表格法,这一节课主要讲用神经网络的方法来求解,这里科老师也把神经网络讲的很透彻,让我对神经网络有了新的认识
这是上节课的悬崖问题:
这些宫格都是可数的,用一个Q表格就能装下来
可是在实际生活中,有很多问题都是数量庞大,甚至不可数的:
这些状态肯定是不能被Q表格装下的,这时就要用到值函数的近似
值函数近似(函数逼近)
值函数就是Q函数,Q表格的作用就是可以根据输入状态的动作来查表并输出Q值
表格方法的缺点:
- 表格可能占用极大内存
- 当表格极大时，查表效率低下
那么实际上,我们就可以用带参数的Q函数来近似Q表格,比如可以用多项式函数或者神经网络
使用值函数近似的优点:
- 仅需存储有限的参数
- 状态泛化，相似的状态可以输出一样
神经网络
神经网络其实就像一个巨大的函数,它可以把输入的x转换成我们想要的输出y
如果输入、输出是向量的话,那么可以把多个输入转换成多个输出
如果输入一张数字3的图片,那么它会输出3;如果输入一张猫的图片,它会输出猫这一分类;如果输入的是房屋位置、面积,它会输出预测的房价。
只要你给它足够多的数据,神经网络就能帮你拟合你需要的连续函数
神经网络其实就是由一层一层的函数搭建起来的,它可以逼近任意连续函数:
这是一个用神经网络求解四元一次方程的例子:
上面看似密密麻麻的代码,其实它的的流程不是很复杂:
使用神经网络求解RL问题的经典算法DQN
DQN使用神经网络来近似替代Q表格,但本质上DQN还是一个Q-learning算法，更新方式一致。
原先Q-learning用的是一个Q表格:
DQN做的改进就是把Q表格换成了神经网络:
输入状态state,输出所有状态对应的动作action
- 如果状态是一张图片,神经网络就可以加入像CNN这样的结构来提取特征;
- 如果状态是一组向量,比如四轴飞行器的状态(高度、旋转角度、速度等),可以用几层全连接层做拟合
DQN≈Q-learning +神经网络
这里可以类比一下监督学习是怎么做训练的:
在监督学习中,输入x后,网络的输出的预测值y要尽可能地趋近于y的真实值label,这时直接求他们的均方差,也就是loss,并将loss送进优化函数里面,就可以对这个网络做自动的更新和优化
DQN的训练过程也非常地类似,它输入的是一批状态,输出的是对应的Q值,这个Q值其实是一个向量,假设动作维度是5的话,每个动作都会对应一个Q值,根据实际的动作action来取对应的Q值,同样也需要让取出来的Q值逼近我的目标值Target Q,要更新这个神经网络的话,也是一样,计算出均方差,再带进优化函数里,这样就可以自动地更新网络参数
DQN算法解析
在Q-learning的基础上，DQN提出了两个技巧使得Q网络的更新迭代更稳定:
- 经验回放 Experience Replay：主要解决样本关联性和利用效率的问题。使用一个经验池存储多条经验s,a,r,s’，再从中随机抽取一批数据送去训练。
- 固定Q目标 Fixed-Q-Target：主要解决算法训练不稳定的问题。复制一个和原来Q网络结构一样的Target Q网络，用于计算Q目标值。
经验回放: 充分利用off-policy的优势
在原来的基础上增加了一个缓冲区,用来存储行为策略的经验,当经验到达一定量时,目标策略将经验打乱时间顺序,再按一个batch的量取出来,然后更新Q表格
这样做的好处是:
- 打乱样本关联性
- 提高样本利用率
它的实现代码如下:
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)
# 分成 5个 数组
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)
固定Q目标
固定Q目标可以解决算法更新不平稳的问题
这里也拿监督学习做对比,它输入x后输出预测的值y,目的是让预测值毕竟真实值,这个真实值在监督学习中其实是稳定的:
而DQN输出的预测值也是要逼近Q_target的:
但是这里的Q实际上也要过一遍网络,导致这个Q也是不断变化的,这就好像在练习射箭时,拿一只会动的兔子当靶子:
固定Q目标做的就是让这个Q在一段时间内保持不变,隔一段时间再去拷贝这个参数即可
下面是DQN算法的流程图:
在PARL里实现的DQN,把嵌套的部分拆开了:
model部分用来定义有神经网络的网络结构,可以是Q网络,也可以是策略网络等
下面是PARL的框架:
PARL DQN代码解析
Agent把产生的数据传给algorithm，algorithm根据model的模型结构计算出Loss，使用SGD或者其他优化器不断的优化，PARL这种架构可以很方便的应用在各类深度强化学习问题中。
model
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
这是一个非常简单的只有三层的全连接网络,前两层的激活函数是relu
algorithm
Algorithm 定义了具体的算法来更新前向网络(Model)，也就是通过定义损失函数来更新Model，和算法相关的计算都放在algorithm中。
这里要把刚刚定义好的model输入进来
# from parl.algorithms import DQN # 也可以直接从parl库中导入DQN算法
class DQN(parl.Algorithm):
def __init__(self, model, act_dim=None, gamma=None, lr=None):
""" DQN algorithm
Args:
model (parl.Model): 定义Q函数的前向网络结构
act_dim (int): action空间的维度，即有几个action
gamma (float): reward的衰减因子
lr (float): learning rate 学习率.
"""
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
用deepcopy()就可以快速地把model复制过来
定义完DQN这个类以后还要实现sync_target()这个方法 :
def sync_target(self):
""" 把 self.model 的模型参数值同步到 self.target_model
"""
self.model.sync_weights_to(self.target_model)
这里直接调用api就可以了,PARL已经班用户实现了
这个方法的作用是定期地把target_model的参数同步到model里
同样的,实现predict()方法也很简单:
def predict(self, obs):
""" 使用self.model的value网络来获取 [Q(s,a1),Q(s,a2),...]
"""
return self.model.value(obs)
直接返回model输出的值就好了
接下来,最核心的方法就是learn()方法:
def learn(self, obs, action, reward, next_obs, terminal):
""" 使用DQN算法更新self.model的value网络
"""
# 从target_model中获取 max Q' 的值，用于计算target_Q
next_pred_value = self.target_model.value(next_obs)
best_v = layers.reduce_max(next_pred_value, dim=1)
best_v.stop_gradient = True # 阻止梯度传递
terminal = layers.cast(terminal, dtype='float32')
target = reward + (1.0 - terminal) * self.gamma * best_v
pred_value = self.model.value(obs) # 获取Q预测值
# 将action转onehot向量，比如：3 => [0,0,0,1,0]
action_onehot = layers.one_hot(action, self.act_dim)
action_onehot = layers.cast(action_onehot, dtype='float32')
# 下面一行是逐元素相乘，拿到action对应的 Q(s,a)
# 比如：pred_value = [[2.3, 5.7, 1.2, 3.9, 1.4]], action_onehot = [[0,0,0,1,0]]
# ==> pred_action_value = [[3.9]]
pred_action_value = layers.reduce_sum(
layers.elementwise_mul(action_onehot, pred_value), dim=1)
# 计算 Q(s,a) 与 target_Q的均方差，得到loss
cost = layers.square_error_cost(pred_action_value, target)
cost = layers.reduce_mean(cost)
optimizer = fluid.optimizer.Adam(learning_rate=self.lr) # 使用Adam优化器
optimizer.minimize(cost)
return cost
虽然是最核心的部分,但其实也不难,可以分成3块去理解:
第一块,计算目标值; 第二块,计算预测值; 第三块,得到loss
原来在计算target-Q的时候,要用到if条件判断,但是这里用了一个非常巧妙的办法:
terminal = layers.cast(terminal, dtype='float32')
target = reward + (1.0 - terminal) * self.gamma * best_v
这里输入的terminal其实是原来的用于判断是不是最后一条数据done
巧妙的地方就在于可以把这个done转换成浮点数,也就是说True为1、False为0
然后再用1减去它,那么当terminal为True时, 1 - 1 = 0 ,那一部分就消去了:
target = reward
当terminal为False时,因为1 - 0 = 1,所以不影响
agent
Agent 负责算法与环境的交互，在交互过程中把生成的数据提供给Algorithm来更新模型(Model)，数据的预处理流程也一般定义在这里。
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
feed存放的是输入;fetch_list存放的是build_program()方法的输出
在计算loss时,会执行一次run(),即完成一次网络的更新
在build_program()方法里定义好每个变量的shape
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
总的来说就是3个类,8个方法:
DQN训练展示 CartPole
这部分的代码在PARL的lesson3下:
运行一下:
可以看到它的分数是时好时坏的,甚至于拿训练好的模型去做测试,也有可能比原来好或者坏
这其实跟人一样,难免也会失手,每次的环境都是随机的,所以每次运行可能都会有不同,下面是动图展示
刚开始训练时,会因为倾角太大而结束:
一千多个episode时,杆子基本掌握了游戏规则,但容易滑出去:
训练到差不多2000个episode时,基本不会滑出去:
