策略梯度PG
PG学习中的理解–PG算法去夺-主要来源了莫烦大神
1.怎么进行神经网络的误差反向传递：
policy Gradients是没有误差，他进行的一种反向传递的目的是让这次被选中的行为更有可能在下次发生。但是我们要怎么确定这个行为应被增加被选的概率，这时也是需要使用reward奖罚制度。
整个流程就是：观测的信息通过神经网络分析，选出一个行为，然后进行反向传递增加这个行为下次被选择的可能性。如果奖罚信息告诉我们，这个行为不好，那么这个动作可能增加的幅度会逐渐降低，也就是选择这个行为动作的可能性减少（因为通过奖罚制度认为它不好），选择别的行为可能会增加。如果这次观测信息让神经网络选择了另一个行为，这个行为进行反向传递增加这个行为下次被选择的可能性；然后奖惩信息会通知我们，如果通知我们是好行为 ，那在会增加这次反向传递的力度，它下次被选择的幅度会猛烈。大致流程如下：
PG也需要接受环境信息（observation）（我认为任何算法在使用/训练过程中必不可少），但它与Value-based方法不同的是不是输出action的value，而是会具体到那一个action，这样PG就跳过了value这个阶段。value-based方法输出的都是不连续的值然后选择值最大的action。PG是输出的action可以是一个连续的值，可以在一个连续分布的值上选择action。（V-输出的值不连续，选择值最大的行为动作；PG-值是连续，选择action）
算法部分理解RL_brain部分
'''
基础PG的主要框架定义
class PolicyGradient:
# 初始化 (有改变) 动作行为、特征、学习效率、回报衰减 是否输出网络图
def __init__(self, n_actions, n_features, learning_rate=0.01, reward_decay=0.95, output_graph=False):
# 建立 policy gradient 神经网络 (有改变)
def _build_net(self):
# 选行为 (有改变) 根据观察值选行为
def choose_action(self, observation):
# 存储回合 transition (有改变) 状态 动作 回报 三要素
def store_transition(self, s, a, r):
# 学习更新参数 (有改变) 当前状态 动作 回报 下一个状态
def learn(self, s, a, r, s_):
# 衰减回合的 reward (新内容)
def _discount_and_norm_rewards(self):
'''
import numpy as np
import tensorflow as tf
# 确定随机种子，使得以后的随机结果相同
'''
random.seed()、numpy.random.seed()、tf.set_random_seed()三种随机种子。
在深度学习中，先确定好随机种子，以后每次随机的结果相同。
在每次执行代码时，使每次切分后的训练集、验证集输入结果相同，便于验证学习参数的有效性和查找问题。
'''
np.random.seed(1)
tf.set_random_seed(1)
class PolicyGradient:
def __init__(
self,
n_actions, #动作
n_features,#样本特征数
learning_rate=0.01,#学习效率
reward_decay=0.95, #reward递减率
output_graph=False, #不输出神经网络图
):
self.n_actions=n_actions
self.n_features=n_features
self.lr=learning_rate
self.gamma=reward_decay
#设置存储回合信息的列表 ---- 观测 动作 回报 三剑客
self.ep_obs,self.ep_as,self.ep_rs =[],[],[]
#建立policy神经网络
self._build_net()
# 启动 --初始化
self.sess = tf.Session()
# 输出tensorboard文件
if output_graph:
# $ tensorboard --logdir=logs
# http://0.0.0.0:6006/
# tf.train.SummaryWriter soon be deprecated, use following
# 文件保存到logs包中 使用命令打开 谷歌浏览器输出上述的网址即可查看
tf.summary.FileWriter("logs/",self.sess.graph)
self.sess.run(tf.global_variables_initializer())
# 开始创建神经网络
def _build_net(self):
#名字为输出 --输出层创建
with tf.name_scope("inputs"):
self.tf_obs = tf.placeholder(tf.float32,[None,self.n_features],name="observations") #接收 观测
self.tf_acts = tf.placeholder(tf.float32,[None,],name="actions_num") #接收在这个回合中选的action
self.tf_vt = tf.placeholder(tf.float32,[None,],name="actions_value") # 接收每个 state-action 所对应的 value (通过 reward 计算)
# f1---第一层神经网络 ------obs在此进入
layer=tf.layers.dense(
inputs=self.tf_obs, #输入观测
units=10, #输出个数
activation=tf.nn.tanh, #激励函数
kernel_initializer=tf.random_normal_initializer(mean=0,stddev=0.3), #权重初始化
bias_initializer=tf.constant_initializer(0.1),
name='fc1'
)
# 强化学习神经网络中并没有我们熟知的监督学习中的y_label.取而代之的是我们选的action.
# fc2层神经网络
all_act = tf.layers.dense(
inputs=layer,
units=self.n_actions, #输出个数
activation=None, #在之后在加softmax 就在下面
kernel_initializer=tf.random_normal_initializer(mean=0,stddev=0.3),#参数设置 权重初始化
bias_initializer=tf.constant_initializer(0.1),
name='fc2'
)
self.all_act_prob = tf.nn.softmax(all_act,name='act_prob') # 激励函数 softmax 出概率
# 定义损失函数 ------------------act vt在此
with tf.name_scope('loss'):
# 最大化 总体 reward (log_p * R) 就是在最小化 -(log_p * R), 而 tf 的功能里只有最小化 loss
neg_log_prob = tf.nn.sparse_softmax_cross_entropy_with_logits(logits=all_act,labels=self.tf_acts) # 所选 action 的概率 -log 值
# 下面的方式是一样的:
# neg_log_prob = tf.reduce_sum(-tf.log(self.all_act_prob)*tf.one_hot(self.tf_acts, self.n_actions), axis=1)
loss = tf.reduce_mean(neg_log_prob * self.tf_vt) # (vt = 本reward + 衰减的未来reward) 引导参数的梯度下降
# 进行训练
with tf.name_scope('train'):
self.train_op =tf.train.AdamOptimizer(self.lr).minimize(loss)
# 选择行为动作
def choose_action(self,observation):
prob_weights = self.sess.run(self.all_act_prob, feed_dict={self.tf_obs: observation[np.newaxis, :]}) #所以的action概率
action = np.random.choice(range(prob_weights.shape[1]),
p=prob_weights.ravel()) # select action w.r.t the actions prob
return action
#存储模块------将本回合的美每一步的 observation action reward 加到列表中
#本回合完毕后清空列表 然后存储下一个回合的数据：所以在lrean模块中加入清除操作
def store_transition(self,s,a,r):
self.ep_obs.append(s)
self.ep_as.append(a)
self.ep_rs.append(r)
# 学习模块
'''
对本次回合的reward（回报）进行调整，使得他更适合学习
---------------------------------------
1.随着时间推进，gamma衰减未来的reward
2.为了一定程度减少pg回合variance 标准化回合 state-action value
'''
def learn(self):
# 衰减，并标准化这个回和的reward
discounted_ep_rs_norm =self._discount_and_norm_rewards() #功能再面
#每个回合里的数据 进行训练
self.sess.run(self.train_op,feed_dict={
self.tf_obs: np.vstack(self.ep_obs), # shape=[None, n_obs]
self.tf_acts: np.array(self.ep_as), # shape=[None, ]
self.tf_vt: discounted_ep_rs_norm, # shape=[None, ]
})
self.ep_obs,self.ep_as,self.ep_rs=[],[],[] #这个回合训练学完了 清空存储的数据
return discounted_ep_rs_norm #返回这一回合的state-action value
# 对正常的回合rewards进行打折扣----也就是使用算法实现对未来reward 衰减
def _discount_and_norm_rewards(self):
#回合rewards衰减
discounted_ep_rs = np.zeros_like(self.ep_rs)
running_add = 0
for t in reversed(range(0,len(self.ep_rs))):
running_add = running_add * self.gamma +self.ep_rs[t]
discounted_ep_rs[t] = running_add
# 规范化 回合rewards
discounted_ep_rs -= np.mean(discounted_ep_rs)
discounted_ep_rs /=np.std(discounted_ep_rs)
return discounted_ep_rs
RUN部分
import gym
from RL_brain import PolicyGradient
import matplotlib.pyplot as plt
DISPLAY_REWARD_THRESHOLD = 400 # 当 回合总 reward 大于 400 时显示模拟窗口
RENDER = False # 在屏幕上显示模拟窗口会拖慢运行速度, 我们等计算机学得差不多了再显示模拟
env = gym.make('CartPole-v0') # CartPole 这个模拟
env.seed(1) # 普通的 Policy gradient 方法, 使得回合的 variance 比较大, 所以我们选了一个好点的随机种子
env = env.unwrapped # 取消限制
print(env.action_space) # 显示可用 action
print(env.observation_space) # 显示可用 state 的 observation
print(env.observation_space.high) # 显示 observation 最高值
print(env.observation_space.low) # 显示 observation 最低值
#定义
RL = PolicyGradient(
n_actions=env.action_space.n,
n_features=env.observation_space.shape[0],
learning_rate=0.02,
reward_decay=0.99,
# output_graph=True,
)
for i_episode in range(3000):
observation = env.reset()
while True:
if RENDER: env.render()
action = RL.choose_action(observation)
observation_, reward, done, info = env.step(action)
RL.store_transition(observation, action, reward)
if done:
ep_rs_sum = sum(RL.ep_rs)
if 'running_reward' not in globals():
running_reward = ep_rs_sum
else:
running_reward = running_reward * 0.99 + ep_rs_sum * 0.01
if running_reward > DISPLAY_REWARD_THRESHOLD: RENDER = True # 判断是否显示模拟
print("episode:", i_episode, " reward:", int(running_reward))
vt = RL.learn() # 学习, 输出 vt,
if i_episode == 0:
plt.plot(vt) # plot the episode vt
plt.xlabel('episode steps')
plt.ylabel('normalized state-action value')
plt.show()
break
observation = observation_
摆锤实例 环境采用的是gym
RUN2 小车夺旗
```python
import gym
from RL_brain import PolicyGradient
import matplotlib.pyplot as plt
DISPLAY_REWARD_THRESHOLD = -2000 # renders environment if total episode reward is greater then this threshold
# episode: 154 reward: -10667
# episode: 387 reward: -2009
# episode: 489 reward: -1006
# episode: 628 reward: -502
RENDER = False # rendering wastes time
env = gym.make('MountainCar-v0')
env.seed(1) # reproducible, general Policy gradient has high variance
env = env.unwrapped
print(env.action_space)
print(env.observation_space)
print(env.observation_space.high)
print(env.observation_space.low)
RL = PolicyGradient(
n_actions=env.action_space.n,
n_features=env.observation_space.shape[0],
learning_rate=0.02,
reward_decay=0.995,
# output_graph=True,
)
for i_episode in range(1000):
observation = env.reset()
while True:
if RENDER: env.render()
action = RL.choose_action(observation)
observation_, reward, done, info = env.step(action) # reward = -1 in all cases
RL.store_transition(observation, action, reward)
if done:
# calculate running reward
ep_rs_sum = sum(RL.ep_rs)
if 'running_reward' not in globals():
running_reward = ep_rs_sum
else:
running_reward = running_reward * 0.99 + ep_rs_sum * 0.01
if running_reward > DISPLAY_REWARD_THRESHOLD: RENDER = True # rendering
print("episode:", i_episode, " reward:", int(running_reward))
vt = RL.learn() # train
if i_episode == 30:
plt.plot(vt) # plot the episode vt
plt.xlabel('episode steps')
plt.ylabel('normalized state-action value')
plt.show()
break
observation = observation_
小车夺旗
主要学校来源是莫烦python--该学习直达连接 https://mofanpy.com/tutorials/machine-learning/reinforcement-learning/policy-gradient-softmax1/
