机器学习（Python+sklearn+TensorFlow 2.0）-第2版 微课视频版 课件 -10-强化学习

机器学习第十章强化学习第十章强化学习强化学习（ReinforcementLearning,RL）是学习主体（Agent）以“尝试”的方式探索世界、获取知识的学习机制。强化学习起源于心理学中的行为主义理论，即有机体如何在环境给予的奖励或惩罚的刺激下，逐步形成对刺激的预期，产生能获得最大利益的习惯性行为。与前述的聚类、回归、分类和标注任务不同，强化学习面向的是所谓的序列决策（SequentialDecisionMaking）任务：主体根据环境的状态和反馈连续选择行为，力图收获最大收益。10.1强化学习基础10.2值函数可计算的强化学习10.3深度强化学习第十章强化学习仿真工具强化学习需要不断地尝试，因此研究强化学习，离不开仿真。OpenAI的gym仿真工具提供了对强化学习问题求解仿真的支持。gym采用Python语言，可以和本书使用的编程环境无缝衔接。可通过“condainstallgym=0.18.0”命令安装本书使用的gym仿真环境。在gym中仿真强化学习问题，先要在gym中构建相应的仿真环境（具体构建方法可参考相应网站和书籍）。gym内部预先集成了很多已经构建好的强化学习问题仿真环境供初学者使用，如冰湖问题仿真环境。10.1.1冰湖问题与强化学习基本概念4冰湖问题v0版的冰湖问题（FrozenLake-v0）的情景是agent要自主穿过有窟窿的冰面拿到飞盘。冰面由4×4的方格表示，标记为S的方格为agent的出发点，标记为G的方格为飞盘所在的位置，即agent要到达的终点。空白方格表示可以行动的安全区域，灰色方格表示有窟窿的冰面，是会掉入水中的危险区域。为了简化表示，在gym的FrozenLake-v0环境中，用由S、F、H、G四个字母组成的表格来表示冰面。10.1.1冰湖问题与强化学习基本概念5

10.1.1冰湖问题与强化学习基本概念6importgym#loadingtheGymlibraryenv=gym.make("FrozenLake-v0")#看一下动作空间print("Actionspace:",env.action_space)>>>Actionspace:Discrete(4)#看一下观察空间，以及它的取值大小print("Observationspace:",env.observation_space)>>>Observationspace:Discrete(16)

10.1.1冰湖问题与强化学习基本概念7策略示例主体的策略是从状态到动作的映射，也就是说，对一个具体的状态，策略要给出明确的动作指示来确定主体的下一步行动。在冰湖问题中，可以用如下的列表来表示一个策略：[1,3,2,2,0,0,0,1,3,0,1,2,0,3,2,3]列表最左侧的1表示在0号状态时执行编号为1的动作，即在起始点S执行向下的动作。左侧第2个位置上的3表示在1号状态时执行编号为3的动作，即在位置1执行向上的动作。以此类推。10.1.1冰湖问题与强化学习基本概念8rand_pi=[]for_inrange(16):rand_pi.append(env.action_space.sample())print("随机策略：",rand_pi)>>>随机策略：[1,3,2,2,0,0,0,1,3,0,1,2,0,3,2,3]

10.1.1冰湖问题与强化学习基本概念9回报在仿真实验中，主体的每进入到下一状态都有一个回报（reward）。如果当前动作使主体到达了终点G，则能得到一个回报值1，否则回报值为0。10.1.1冰湖问题与强化学习基本概念10尝试10.1.1冰湖问题与强化学习基本概念11defepisode(env,pi,gamma=1.0,render=False):

s=env.reset()#初始状态

sum_reward=0n=0#折扣的幂

whileTrue:ifrender:env.render()s,reward,done,_=env.step(int(pi[s]))sum_reward+=(gamma**n*reward)#累积折扣回报函数

n+=1ifdone:env.render()break#print(sum_reward)returnsum_rewardepisode(env,rand_pi,1.0,True)尝试10.1.1冰湖问题与强化学习基本概念12#多次尝试取累积折扣回报函数的均值deftest_policy(env,pi,gamma=1.0,n_episodes=10000):scores=[episode(env,pi,gamma,False)for_inrange(n_episodes)]returnnp.mean(scores)importnumpyasnpgamma=1.0#折扣系数n_episodes=10000#尝试次数print(n_episodes,"次尝试的平均得分：",test_policy(env,rand_pi,gamma,n_episodes))>>>10000次尝试的平均得分：0.0778强化学习中，主体（策略）、动作、环境、状态和回报之间的关系：主体依据策略来决定下一步动作，主体的动作又会改变环境，主体能够观察到环境状态的变化，并得到环境的立即回报。然后，主体根据新的状态并依据策略来决定新的动作。可见，强化学习是一个持续决策的过程。10.1.1冰湖问题与强化学习基本概念13

10.1.1冰湖问题与强化学习基本概念14

10.1.1冰湖问题与强化学习基本概念15

10.1.1冰湖问题与强化学习基本概念16

10.1.2马尔可夫决策过程17

10.1.2马尔可夫决策过程18

10.1.2马尔可夫决策过程19

10.1.2马尔可夫决策过程20

10.1.2马尔可夫决策过程21

10.1.2马尔可夫决策过程22

10.1.2马尔可夫决策过程23

10.1.2马尔可夫决策过程24

10.1.2马尔可夫决策过程25

10.1.2马尔可夫决策过程26随机近似方法的基本思想是通过大量的随机样本去探索系统，得到有关系统的近似模型。10.1.3蒙特卡罗近似27

10.1.3蒙特卡罗近似28

10.1.3蒙特卡罗近似29利用与探索（Exploitation&Exploration）是强化学习中非常重要的概念。利用是指从已知信息中得到最大回报。探索是指要开拓眼界、尽可能地发掘环境中更多的信息。人们在作选择时，经常会用到利用与探索的思想。比如，在选择饭店时，一般会利用自己的经验选择自己满意的饭店，以确保大概率得到理想的服务，但是也会偶尔探索一下新店，看看是否有更好的服务。常用两种策略来实现利用与探索，分别是贪心策略（greedystrategy）和ε-贪心策略（ε-greedystrategy）。10.1.4利用与探索30

10.1.4利用与探索31

10.1.4利用与探索321.从算法优化过程分类基于值函数优化策略的算法，是先求得状态值函数或动作值函数，然后依据它们来得到最优策略，主要有动态规划法、蒙特卡罗法、时序差分法（又包括Sarsa和Qlearning）和DQN等。直接优化策略的算法，是直接从候选策略中选择最优策略，主要有策略梯度法、Actor-Critic和DDPG等。构建环境模型辅助优化策略的算法，是在环境模型未知的情况下，先对环境进行建模，再用构建的模型来辅助优化值函数，最终求得最优策略。构建的环境模型一般不能完全刻画实际的环境，因此，算法不能完全依赖构建的环境模型，而是将对构建模型的利用和对实际环境的探索结合起来进行优化。构建环境模型辅助优化策略的算法主要有Dyna、Dyna-2、基于模拟的搜索等系列算法。10.1.5强化学习算法分类332.环境模型是否已知的分类如果已知环境模型，则强化学习问题的求解显然要容易的多。此时，称为有模型强化学习算法。在不知道环境模型时，一般要通过蒙特卡罗法来试探环境，得到与环境模型相关的知识用于优化策略。相应地，这类算法也称为无模型强化学习算法。在无模型强化学习算法中，有的算法需要一次对环境的完整尝试才能进行迭代优化，称为回合制算法。有的算法不需要完整的尝试，只需要一步试探即可进行迭代优化，称为单步制算法。10.1.5强化学习算法分类343.值函数求解的分类在状态空间和动作空间是小型的离散空间时，值函数可以用一个小型的表格来表示。一个状态值或者一个状态-动作值对对应表格中的一格。此时，值函数的迭代优化就表现为对表格中数据的迭代计算，该类算法称为值函数可计算的强化学习算法，也称为表格型强化学习算法。如果状态空间和（或）动作空间是连续的，那么就无法用一个表格来表示值函数。此时，一般是采用映射来描述从状态值或状态-动作值对到一个实数值的对应关系，该类算法称为值函数逼近的强化学习算法。值函数逼近的方法还被应用到大型离散空间中值函数的求解。因为当空间过于庞大时，直接计算值函数实际上已经不可行。10.1.5强化学习算法分类3510.1强化学习基础10.2值函数可计算的强化学习10.3深度强化学习第十章强化学习基于值函数优化策略的方法是先求得值函数，然后通过值函数来求得最优策略。相应地，该类算法的迭代过程可分为策略评估阶段和策略改进阶段。在策略评估阶段，算法基于当前策略来求得值函数；在策略改进阶段，算法利用当前值函数来更新策略。10.2值函数可计算的强化学习方法37

10.2.1动态规划法38

10.2.1动态规划法39

10.2.1动态规划法40

10.2.1动态规划法41

10.2.1动态规划法42

10.2.1动态规划法43

10.2.1动态规划法44

10.2.1动态规划法451.策略迭代算法10.2.1动态规划法46defpolicy_evaluation(pi,gamma=1.0):V_table=np.zeros(n_states)#状态值函数表

threshold=1e-10#收敛判断阈值

whileTrue:pre_V_table=np.copy(V_table)forsinrange(n_states):a=pi[s]

V_table[s]=sum([trans_prob*(r+gamma*pre_V_table[next_s])

fortrans_prob,next_s,r,doneinenv.P[s][a]])if(np.sum((np.fabs(pre_V_table-V_table)))<=threshold):#是否收敛

breakreturnV_table1.策略迭代算法10.2.1动态规划法47#基于新的状态值函数对策略进行改进defpolice_improvement(v_table,gamma=1.0):pi=np.zeros(n_states)forsinrange(n_states):Q_table=np.zeros(n_actions)#每个状态的动作值函数表

forainrange(n_actions):fornext_srinenv.P[s][a]:#环境模型，存储状态s下采取动作a得到的状态转移概率，下一步状态，回报，完成标志

trans_prob,next_s,r,done=next_srQ_table[a]+=(trans_prob*(r+gamma*v_table[next_s]))pi[s]=np.argmax(Q_table)#贪心策略

returnpi1.策略迭代算法10.2.1动态规划法48#策略迭代defpolicy_iteration(gamma=1.0):

pi=np.zeros(n_states)#0初始化策略

i=0whileTrue:V_table=policy_evaluation(pi,gamma)new_pi=police_improvement(V_table,gamma)i+=1#print("迭代次数：",i,"\n\tV_table:",V_table,"\n\tpi:",new_pi)if(np.all(pi==new_pi)):break

pi=new_pi

returnpigamma=1.0#折扣系数pi=policy_iteration(gamma)print("策略迭代算法计算最优策略:",pi)n_episodes=10000#尝试次数print(n_episodes,"次尝试的平均得分：",test_policy(env,pi,gamma,n_episodes))策略迭代算法计算最优策略:[0.3.3.3.0.0.0.0.3.1.0.0.0.2.1.0.]10000次尝试的平均得分：0.7356

10.2.1动态规划法492.值迭代算法10.2.1动态规划法50#值迭代defvalue_itration(env,gamma=1.0):

V_table=np.zeros(n_states)n_iterations=10000threshold=1e-10foriinrange(n_iterations):pre_V_table=np.copy(V_table)forsinrange(n_states):Q=[]#状态s的Q值

forainrange(n_actions):next_s_prob_rewards=[]

fornext_srinenv.P[s][a]:trans_prob,next_s,r,done=next_sr

next_s_prob_rewards.append((trans_prob*(r+gamma*pre_V_table[next_s])))Q.append(np.sum(next_s_prob_rewards))V_table[s]=max(Q)if(np.sum(np.fabs(pre_V_table-V_table))<=threshold):break

returnV_table2.值迭代算法10.2.1动态规划法51best_V_table=value_itration(env=env,gamma=1.0)print("最优状态值函数：",best_V_table)best_pi=police_improvement(best_V_table,gamma=1.0)print("值迭代算法计算最优策略:",best_pi)>>>最优状态值函数：[0.823529410.823529410.823529410.823529410.823529410.0.529411760.0.823529410.823529410.764705880.0.0.882352940.941176470.]值迭代算法计算最优策略:[0.3.3.3.0.0.0.0.3.1.0.0.0.2.1.0.]

10.2.1动态规划法52随机性策略生成一个随机初始化的随机性策略10.2.2蒙特卡罗法53defcreate_random_policy(env):

pi=np.ones([env.observation_space.n,env.action_space.n])#用数组来存储策略

p=1/env.action_space.n

returnpi*ppi=create_random_policy(env)print(pi)[[0.250.250.250.25][0.250.250.250.25][0.250.250.250.25][0.250.250.250.25][0.250.250.250.25][0.250.250.250.25][0.250.250.250.25][0.250.250.250.25][0.250.250.250.25][0.250.250.250.25][0.250.250.250.25][0.250.250.250.25][0.250.250.250.25][0.250.250.250.25][0.250.250.250.25][0.250.250.250.25]]随机性策略按随机性策略进行尝试10.2.2蒙特卡罗法54defepisode_random(env,pi,render=False):

env.reset()ifrender:env.render()

episode=[]done=Falsewhilenotdone:s=env.env.s#读取环境状态

timestep=[]timestep.append(s)action=np.random.choice(env.action_space.n,p=pi[s])

#执行动作并记录

next_s,r,done,info=env.step(action)timestep.append(action)timestep.append(r)episode.append(timestep)ifrender:env.render()returnepisodetau=episode_random(env,pi,False)print(tau)[[0,3,0.0],[0,3,0.0],[1,1,0.0],[2,2,0.0],[6,1,0.0],[10,0,0.0],[14,2,1.0]]随机性策略测试随机性策略10.2.2蒙特卡罗法55#测试随机性策略deftest_random_policy(env,pi,gamma=1.0,n_episodes=1000):sum_reward=0.0for_inrange(n_episodes):tau=episode_random(env,pi,render=False)sum_reward+=G(tau,gamma)returnsum_reward/n_episodesprint("输入策略的得分：",test_random_policy(env,pi,1.0,1000))>>>输入策略的得分：0.016#计算一条轨迹的累积折扣回报defG(tau,gamma=1.0):i=0sum_r=0.0foreintau:#print(e[-1])sum_r+=gamma**i*e[-1]i+=1returnsum_rprint(G(tau,1.0))>>>1.0

10.2.2蒙特卡罗法56蒙特卡罗法求解过程一次尝试的轨迹：[[0,3,0.0],[0,3,0.0],[1,1,0.0],[2,2,0.0],[6,1,0.0],[10,0,0.0],[14,2,1.0]]10.2.2蒙特卡罗法57蒙特卡罗法求解过程轨迹分解为采样：[[0,3,1.0],[0,3,1.0],[1,1,1.0],[2,2,1.0],[6,1,1.0],[10,0,1.0],[14,2,1.0]]更新动作值函数：对所有s和a对应的动作值函数重新求均值10.2.2蒙特卡罗法58

10.2.2蒙特卡罗法59

10.2.2蒙特卡罗法60蒙特卡罗法求解冰湖问题10.2.2蒙特卡罗法61defmc_on_policy(env,epsilon=0.01,n_episodes=100):pi=create_random_policy(env)#产生随机策略，数组形式

Q_value=np.zeros([env.observation_space.n,env.action_space.n])

N_s_a=np.zeros([env.observation_space.n,env.action_space.n])

forkinrange(n_episodes):

G=0#累积回报

tau=episode_random(env,pi,False)#采样得到轨迹τ

foriinreversed(range(0,len(tau))):s_t,a_t,r_t=tau[i]G+=r_tifnot(s_t,a_t)in[(x[0],x[1])forxintau[0:i]]:#初次访问统计

N_s_a[s_t,a_t]+=1Q_value[s_t,a_t]=Q_value[s_t,a_t]+(G-Q_value[s_t,a_t])/N_s_a[s_t,a_t]

forsinrange(env.observation_space.n):pi[s]=epsilon/env.action_space.nindices=np.where(Q_value[s]==np.max(Q_value[s]))

tag_max_Q=random.choice(indices[0])pi[s][tag_max_Q]+=1-epsilon#最优动作的增加概率

returnpi蒙特卡罗法求解冰湖问题10.2.2蒙特卡罗法62pi_mc=mc_on_policy(env,n_episodes=30000)print(pi_mc)print(test_random_policy(env,pi_mc,1.0,1000))>>>[[0.99250.00250.00250.0025][0.00250.00250.00250.9925][0.00250.99250.00250.0025][0.00250.00250.00250.9925][0.99250.00250.00250.0025][0.00250.99250.00250.0025][0.00250.00250.99250.0025][0.00250.00250.00250.9925][0.00250.00250.00250.9925][0.00250.99250.00250.0025][0.99250.00250.00250.0025][0.00250.99250.00250.0025][0.00250.00250.00250.9925][0.00250.00250.99250.0025][0.00250.99250.00250.0025][0.99250.00250.00250.0025]]0.699

10.2.3时序差分法63

10.2.3时序差分法64Sarsa算法与Qlearning算法10.2.3时序差分法65defgreedy_sample(Q_s):max_Q=np.max(Q_s)action_list=np.where(max_Q==Q_s)[0]

a=np.random.choice(action_list)returnadefepsilon_greedy_sample(Q_s,n_actions,epsilon):

ifnp.random.uniform(0,1)<=1-epsilon:a=greedy_sample(Q_s)else:a=np.random.choice(n_actions)returna66defTD(env,gamma=1.0,alpha=0.01,epsilon=0.1,n_episodes=10000,algorithm="Qlearning"):Q=np.zeros([env.observation_space.n,env.action_space.n])

n_actions=env.action_space.nforiinrange(n_episodes):

sum_rewards=0steps=0

s=env.reset()a=epsilon_greedy_sample(Q[s],n_actions,epsilon)

while(True):next_s,r,done,_=env.step(a)next_a=epsilon_greedy_sample(Q[next_s],n_actions,epsilon)

if(done):Q[s,a]=Q[s,a]+alpha*(r-Q[s,a])else:ifalgorithm=="Qlearning":Q[s,a]=Q[s,a]+alpha*(r+gamma*np.max(Q[next_s])-Q[s,a])else:Q[s,a]=Q[s,a]+alpha*(r+gamma*Q[next_s,next_a]-Q[s,a])s=next_sa=next_asum_rewards+=r*gamma**stepssteps+=1if(done):break时序差分法求解冰湖问题10.2.3时序差分法67gamma=1.0#折扣系数n_episodes=30000#训练次数n_test_episodes=10000#测试次数algorithm="sarsa"sarsa_pi=TD(env,gamma=1.0,alpha=0.01,epsilon=0.1,n_episodes=n_episodes,algorithm=algorithm)print(algorithm,"算法计算最优策略:",sarsa_pi)print(n_test_episodes,"次尝试的平均得分：",test_policy(env,sarsa_pi,gamma,n_test_episodes))>>>sarsa算法计算最优策略:[0,3,0,1,0,1,2,2,3,1,0,2,1,2,2,3]10000次尝试的平均得分：0.6372algorithm="Qlearning"Qlearning_pi=TD(env,gamma=1.0,alpha=0.01,epsilon=0.1,n_episodes=n_episodes,algorithm=algorithm)print(algorithm,"算法计算最优策略:",Qlearning_pi)print(n_test_episodes,"次尝试的平均得分：",test_policy(env,Qlearning_pi,gamma,n_test_episodes))>>>Qlearning算法计算最优策略:[0,3,0,1,0,2,0,0,3,1,0,1,0,2,1,0]10000次尝试的平均得分：0.729110.1强化学习基础10.2值函数可计算的强化学习10.3深度强化学习第十章强化学习

10.3.1值函数逼近69

10.3.1值函数逼近70

10.3.1值函数逼近71

10.3.1值函数逼近72

10.3.1值函数逼近73

10.3.1值函数逼近74

10.3.1值函数逼近75

10.3.1值函数逼近76神经网络来逼近值函数三种形式10.3.2DQN与倒立摆控制问题77DQN在Q-Learning算法的基础上：1、用深度神经网络Q来逼近值函数。2、经验回放是将每步采样都保存起来，用来成批训练Q网络。3、目标网络Q_进一步降低样本之间的关联性。10.3.2DQN与倒立摆控制问题78倒立摆问题倒立摆控制是控制系统理论教学中的典型物理模型，它也是学习强化学习的一个经典的基础实验。主体只能对小车施加向左或向右的大小为10N的力F。主体能够观察到4项环境状态，分别是小车的位置，小车速度，标偏离垂直线的角度，杆顶的速度。在某一步动作之后，如果杆还没倒下，主体就能得到一个值为1的回报，否则就会得到一个值为0的回报。10.3.2DQN与倒立摆控制问题79倒立摆问题10.3.2DQN与倒立摆控制问题80importtimeimportnumpyasnpimportgymenv=gym.make('CartPole-v0')env.reset()for_inrange(100):env.render()s,r,done,info=env.step(env.action_space.sample())print(s,r)time.sleep(0.05)env.close()>>>[-0.01126047-0.944121410.119619881.64563352]1.0[-0.0301429-0.750585050.152532551.3924879]1.0[-0.0451546-0.557655330.180382311.15112424]1.0[-0.05630771-0.36528570.203404790.9199968]1.0[-0.06361342-0.173407180.221804730.69750204]1.0[-0.067081560.018063470.235754770.48200924]0.0[-0.066720290.209218090.245394950.27188042]0.0[-0.062535930.400153280.250832560.06548205]0.0DQN求解倒立摆问题-经验回放池10.3.2DQN与倒立摆控制问题81classReplayMemory():def__init__(self,N=2000,size_batch=32):

self.N=Nself.size_batch=size_batchself.memory=collections.deque(maxlen=self.N)#采用双向队列作为存储结构

defsize(self):returnlen(self.memory)defpush(self,transition):self.memory.append(transition)defsample(self):#从D中采样size_batch大小的样本集

transitions=random.sample(self.memory,self.size_batch)s_list,a_list,r_list,next_s_list,done_list=[],[],[],[],[]fortransitionintransitions:s,a,r,next_s,done=transitions_list.append(s)a_list.append([a])r_list.append([r])next_s_list.append(next_s)done_list.append([done])returns_list,a_list,r_list,next_s_list,done_listDQN求解倒立摆问题-采用第三种结构的神经网络10.3.2DQN与倒立摆控制问题82classQ_net(keras.Model):def__init__(self,Q_net_structure=[128,128,2]):

super(Q_net,self).__init__()self.Q_net_structure=Q_net_structureself.fc=[]self.n_actions=Q_net_structure[-1]foriinrange(len(self.Q_net_structure)):self.fc.append(layers.Dense(self.Q_net_structure[i]))

defcall(self,x,training=None):foriinrange(len(self.Q_net_structure)-1):x=tf.nn.relu(self.fc[i](x))x=self.fc[len(self.Q_net_structure)-1](x)returnxdefepsilon_greedy_sample(self,s,epsilon):rand=random.random()ifrand<epsilon:#探索

returnrandom.randint(0,self.n_actions-1)else:#利用，将s经过网络前向预测，得到输出

s=tf.constant(s,dtype=tf.float32)#转换成Tensors=tf.expand_dims(s,axis=0)out=self(s)[0]#前向预测

returnint(tf.argmax(out))#更新ε贪心策略中的εdefupdate_epsilon(epsilon,epsilon_decay=0.995,epsilon_min=0.01):ifepsilon>=epsilon_min:epsilon*=epsilon_decayreturnepsilonDQN求解倒立摆问题-主函数10.3.2DQN与倒立摆控制问题83defDQN(env,M=2000,learning_rate=0.0002,epsilon=1.0,gamma=0.99):

D=ReplayMemory(N=N_of_D,size_batch=size_batch)#经验回放池

q=Q_net()#预测网络，Q网络

q.build(input_shape=(2,4))q_=Q_net()#目标网络

q_.build(input_shape=(2,4))

forsv,dvinzip(q.variables,q_.variables):dv.assign(sv)#将目标网络系数设置为预测网络系数

C=10#C次采样后，更新目标网络为预测网络

score=0.0optimizer=optimizers.Adam(lr=learning_rate)foriinrange(M):#训练次数

#逐步减小ε

epsilon=update_epsilon(epsilon,epsilon_decay,epsilon_min)

s=env.reset()episode_score=0.0DQN求解倒立摆问题-主函数10.3.2DQN与倒立摆控制问题84fortinrange(600):#开始尝试，每次尝试最多走600步

a=q.epsilon_greedy_sample(s,epsilon)next_s,r,done,_=env.step(a)D.push((s,a,r,next_s,done))#样本存入经验回放池

s=next_s#更新状态

episode_score+=rifdone:#尝试结束

score+=episode_score#记录最近C次的总回报

episode_score_list.append(episode_score)episode_score=0.0

breakifD.size()>500:#开始更新Q网络

huber=losses.Huber()#从经验回放池中随机提取一批训练样本,并转换成Tensors_list,a_list,r_list,next_s_list,done_list=D.sample()s_=tf.constant(s_list,dtype=tf.float32)a_=tf.constant(a_list,dtype=32)r_=tf.constant(r_list,dtype=tf.float32)next_s_=tf.constant(next_s_list,dtype=tf.float32)done_=tf.constant(done_list,dtype=tf.float32)DQN求解倒立摆问题-主函数10.3.2DQN与倒立摆控制问题85withtf.GradientTape()astape:q_predict=q(s_)#得到预测值Q(s_,*)indices=tf.expand_dims(tf.range(a_.shape[0]),axis=1)#reshapeindices=tf.concat([indices,a_],axis=1)#对应的动作

q_a=tf.gather_nd(q_predict,indices)#对应动作的Q预测值

q_a=tf.expand_dims(q_a,axis=1)#reshapemax_next_q=tf.reduce_max(q_(next_s_),axis=1,keepdims=True)labels=r_+gamma*max_next_q*(1-done_)#done_等1

#计算预测值与标签值的误差

loss=huber(q_a,labels)

#计算梯度，并优化网络

grads=tape.gradient(loss,q.trainable_variables)optimizer.apply_gradients(zip(grads,q.trainable_variables))#C次采样后，更新目标网络为预测网络，并输出中间信息

if(i+1)%C==0:forsv,dvinzip(q.variables,q_.variables):dv.assign(sv)#将目标网络系数设置为预测网络系数

print("尝试次数:{},最近{}次平均得分:{:.1f},经验回放池大小:{},ε:{:.3f}"\.format(i+1,C,score/C,D.size(),epsilon))score=0.0DQN求解倒立摆问题-主函数10.3.2DQN与倒立摆控制问题86DQN(env,M=2000,learning_rate=0.0002,epsilon=1.0,gamma=0.99)>>>尝试次数:10,最近10次平均得分:37.1,经验回放池大小:371,ε:0.946尝试次数:20,最近10次平均得分:20.1,经验回放池大小:572,ε:0.900尝试次数:30,最近10次平均得分:17.6,经验回放池大小:748,ε:0.856importmatplotlib.pyplotaspltdefplot_score(episode_score_list):plt.plot(episode_score_list)x=np.array(range(len(episode_score_list)))smooth_func=np.poly1d(np.polyfit(x,episode_score_list,3))plt.plot(x,smooth_func(x),label='Mean',linestyle='--')plt.show()plot_score(episode_score_list)

10.3.3参数化策略并直接优化示例87

10.3.3参数化策略并直接优化示例88神经元随机控制倒立摆10.3.3参数化策略并直接优化示例89#神经元模型defneuron(s,paras):value=np.dot(paras[:4],s)+paras[4]ifvalue>=0:return1else:return0score=0paras=np.random.rand(5)#随机产生神经元的连接系数和阈值s=env.reset()print(s)fortinrange(200):env.render()a=neuron(s,paras)s,r,done,info=env.step(a)ifdone:breakprint(s,r)score+=rtime.sleep(0.1)print('Paras：',paras)print('Scores：',score)[0.039316860.62284669-0.14993695-1.04921949]1.0[0.051773790.4299974-0.17092134-0.80710755]1.0[0.060373740.23757848-0.18706349-0.57269148]1.0[0.065125310.43476252-0.19851732-0.91798409]1.0Paras：[0.167685470.539910990.404523590.842231350.44027076]Scores：12.0爬山法优化神经元控制倒立摆10.3.3参数化策略并直接优化示例90defrewards_by_paras(env,paras):s=env.reset()r=0rewards=0fortinrange(1000):a=neuron(s,paras)s,r,done,info=env.step(a)rewards+=r#print(sum_reward,action,observation,reward,done,info)ifdone:#本次仿真结束

breakreturnrewardsdelta=0.01#爬山法中试探的步长top_rewards=0top_paras=Nonefor_inrange(100):

score=0paras=np.random.rand(5)most_rewards=rewards_by_paras(env,paras)foriinrange(200):best_paras=parascur_rewards=most_rewardsrewards=rewards_by_paras(env,paras+[delta,0,0,0,0])ifrewards>most_rewards:most_rewards=rewardsbest_paras=paras+[delta,0,0,0,0]rewards=rewards_by_paras(env,paras+[-delta,0,0,0,0])ifmost_rewards>top_rewards:top_rewards=most_rewardstop_paras=parasprint(top_rewards,top_paras)>>>200.0[0.270461760.565784970.855927910.632449040.29078443]爬山法优化神经元控制倒立摆10.3.3参数化策略并直接优化示例91#用优化后的神经元作为策略paras=top_paras#用爬山法得到的连接系数和阈值ave_score=[]for_in