[PyTorch][chapter 58][强化学习-2-有模型学习2]

这篇具有很好参考价值的文章主要介绍了[PyTorch][chapter 58][强化学习-2-有模型学习2]。希望对大家有所帮助。如果存在错误或未考虑完全的地方,请大家不吝赐教,您也可以点击"举报违法"按钮提交疑问。

前言:

   前面我们讲了一下策略评估的原理,以及例子.

   强化学习核心是找到最优的策略,这里

   重点讲解两个知识点:

    策略改进

   策略迭代与值迭代

   最后以下面环境E 为例,给出Python 代码

[PyTorch][chapter 58][强化学习-2-有模型学习2],学习

目录:

     1:  策略改进

      2:  策略迭代与值迭代

      3: 策略迭代代码实现  Python 代码


一  策略改进

[PyTorch][chapter 58][强化学习-2-有模型学习2],学习

      理想的策略应该能够最大化累积奖赏:

       

     最优策略对应的值函数称为最优值函数

      

状态值函数(Bellman 等式):

 动作求和

 [PyTorch][chapter 58][强化学习-2-有模型学习2],学习......16.9

 [PyTorch][chapter 58][强化学习-2-有模型学习2],学习......16.9

状态-动作值函数

状态值函数(Bellman 等式): 动作求和

 [PyTorch][chapter 58][强化学习-2-有模型学习2],学习...16.10

 [PyTorch][chapter 58][强化学习-2-有模型学习2],学习...16.10

   由于最优值的累计奖赏已经最大,可以对前面的Bellman 等式做改动,

 即使对动作求和  改为取最优

    最优

 [PyTorch][chapter 58][强化学习-2-有模型学习2],学习....16.13

 [PyTorch][chapter 58][强化学习-2-有模型学习2],学习...16.13

则....16.14  带入16.10

[PyTorch][chapter 58][强化学习-2-有模型学习2],学习...16.10

 [PyTorch][chapter 58][强化学习-2-有模型学习2],学习...16.10

      最优Bellman 等式揭示了非最优策略的改进方式:

      将策略选择的动作改变为当前的最优动作。这样改进能使策略更好

   策略为,改变动作的条件为: 

带入16.10,可以得到递推不等式

    

             [PyTorch][chapter 58][强化学习-2-有模型学习2],学习

             [PyTorch][chapter 58][强化学习-2-有模型学习2],学习

                 16.16


二  策略迭代与值迭代

[PyTorch][chapter 58][强化学习-2-有模型学习2],学习

[PyTorch][chapter 58][强化学习-2-有模型学习2],学习

可以看出:策略迭代法在每次改进策略后都要对策略进行重新评估,因此比较耗时。

由公式16.16   策略改进 与值函数的改进是一致的

由公式16.13可得  

[PyTorch][chapter 58][强化学习-2-有模型学习2],学习

 [PyTorch][chapter 58][强化学习-2-有模型学习2],学习

于是可得值迭代(value iteration)算法.

[PyTorch][chapter 58][强化学习-2-有模型学习2],学习


三  策略迭代代码实现


[PyTorch][chapter 58][强化学习-2-有模型学习2],学习

# -*- coding: utf-8 -*-
"""
Created on Wed Nov  1 19:34:00 2023

@author: cxf
"""

# -*- coding: utf-8 -*-
"""
Created on Mon Oct 30 15:38:17 2023

@author: chengxf2
"""
import numpy as np
from enum import Enum
import copy



class State(Enum):
    #状态空间X    
    shortWater =1 #缺水
    health = 2   #健康
    overflow = 3 #凋亡
    apoptosis = 4 #溢水

class Action(Enum):
    
    #动作空间A
    water = 1 #浇水
    noWater = 2 #不浇水
    
class Env():
    
    def __init__(self):
        
        #状态空间
        self.X = [State.shortWater, State.health,State.overflow, State.apoptosis]   
        #动作空间
        self.A = [Action.water,Action.noWater]   
        
        #从状态x出发,执行动作a,转移到新的状态x',得到的奖赏 r为已知道
        self.Q ={}
        self.Q[State.shortWater] =          [[Action.water,0.5,   State.shortWater,-1],
                                             [Action.water,0.5,   State.health,1],
                                             [Action.noWater,0.4, State.shortWater,-1],
                                             [Action.noWater,0.6, State.overflow,-100]]


        self.Q[State.health] =                [[Action.water,0.6,  State.health,1],
                                              [Action.water,0.4,   State.overflow,-1],
                                              [Action.noWater,0.6, State.shortWater,-1],
                                              [Action.noWater,0.4, State.health,1]]


        self.Q[State.overflow] =                [[Action.water,0.6,   State.overflow,-1],
                                                 [Action.water,0.4,   State.apoptosis,-100],
                                                 [Action.noWater,0.6, State.health,1],
                                                 [Action.noWater,0.4, State.overflow,-1]]


        self.Q[State.apoptosis] =[[Action.water,1, State.apoptosis,-100],
                                [Action.noWater,1, State.apoptosis,-100]]
        
        self.curV ={} #前面的累积奖赏,t时刻的累积奖赏
        self.V ={} #累积奖赏,t-1时刻的累积奖赏
        for x in self.X:    
             self.V[x] =0
             self.curV[x]=0
             
        
    def GetX(self):
        #获取状态空间
        return self.X

    def GetAction(self):
        #获取动作空间
        return self.A
    
    def GetQTabel(self):
        #获取状态转移概率
        return self.Q
    
    

class LearningAgent():
    
    def initStrategy(self):   
        #初始化策略
        stragegy ={}
        stragegy[State.shortWater] = Action.water
        stragegy[State.health] =    Action.water
        stragegy[State.overflow] = Action.water
        stragegy[State.apoptosis] = Action.water
        
        self.stragegy = stragegy
    
    def __init__(self):
          
          env = Env()
          self.X = env.GetX()
          self.A = env.GetAction()
          self.QTabel = env.GetQTabel()
          
          self.curV ={} #前面的累积奖赏
          self.V ={} #累积奖赏
          for x in self.X:    
              self.V[x] =0
              self.curV[x]=0
              
    def  evaluation(self,T):
         #策略评估
         
         for t in range(1,T):
             #当前策略下面的累积奖赏
             
             
             for  state in self.X: #状态空间
                     reward = 0.0
                     action = self.stragegy[state]
                     QTabel= self.QTabel[state]
                     
                     for Q in QTabel:
                         if action == Q[0]:#在状态x 下面执行了动作a,转移到了新的状态,得到的r
                             newstate = Q[2] 
                             p_a_ss =   Q[1]
                             r_a_ss =   Q[-1]
                             #print("\n p_a_ss",p_a_ss, "\t r_a_ss ",r_a_ss)
                             reward += p_a_ss*((1.0/t)*r_a_ss + (1.0-1/t)*self.V[newstate])
                             
                     self.curV[state] = reward               
             if (T+1)== t:
                 break
             else:
                 self.V = self.curV
         
              
         
     
     
    def  improve(self,T):
         #策略改进
         stragegy ={}
         for  state in self.X:
             
             QTabel= self.QTabel[state]
             max_reward = -float('inf') 
             
             #计算每种Q(state, action)
             for action in self.A:
                 
                     reward = 0.0
                     for Q in QTabel:
                         if action == Q[0]:#在状态x 下面执行了动作a,转移到了新的状态,得到的r
                             newstate = Q[2] 
                             p_a_ss =   Q[1]
                             r_a_ss =   Q[-1]
                             #print("\n p_a_ss",p_a_ss, "\t r_a_ss ",r_a_ss)
                             reward += p_a_ss*((1.0/T)*r_a_ss + (1.0-1/T)*self.V[newstate])
                             
                     if reward> max_reward:
                         max_reward = reward
                         stragegy[state] = action
                         #print("\n state ",state, "\t action ",action, "\t reward %4.2f"%reward)
         return stragegy
                     
                     
             
         
        


              
 
    
    def compare(self,dict1, dict2):
        #策略比较
        
        for key in dict1:
            if dict1[key] != dict2.get(key):
               return False
         
        return True
                     

    def learn(self,T):
        
        #随机初始化策略
        self.initStrategy()
     
        n = 0
        while True:
              self.evaluation(T-1) #策略评估
              n = n+1
         
              
             
                  
              print("\n 迭代次数 %d"%n ,State.shortWater.name, "\t 奖赏: %4.2f "%self.V[State.shortWater],
                    State.health.name, "\t 奖赏: %4.2f "%self.V[State.health],
                    State.overflow.name, "\t 奖赏: %4.2f "%self.V[State.overflow],
                    State.apoptosis.name, "\t 奖赏: %4.2f "%self.V[State.apoptosis],)
              
              
              
              strategyN =self.improve(T) #策略改进
              #print("\n ---cur---\n",self.stragegy,"\n ---new-- \n ",strategyN )
              if self.compare(self.stragegy,strategyN):
                  
               
                  print("\n ----- 最终策略 -----\n ")
                  
                  for state in self.X:
                      print("\n state ",state, "\t action: ",self.stragegy[state])
                  
                  break
              else:
                 
                  for state in self.X:
                      self.stragegy[state] = strategyN[state]
              
              
              

    
    



if __name__ == "__main__":
    T =10
    agent = LearningAgent()
    agent.learn(T)

参考:

机器学习.周志华《16 强化学习 》_51CTO博客_机器学习 周志华

CSDN文章来源地址https://www.toymoban.com/news/detail-740973.html

到了这里,关于[PyTorch][chapter 58][强化学习-2-有模型学习2]的文章就介绍完了。如果您还想了解更多内容,请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章,希望大家以后多多支持TOY模板网!

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处: 如若内容造成侵权/违法违规/事实不符,请点击违法举报进行投诉反馈,一经查实,立即删除!

领支付宝红包 赞助服务器费用

相关文章

  • 强化学习Chapter2——优化目标(1)

    上节涉及强化学习基本思路以及利用数学方式表征强化学习,但对强化学习的目标并没有进行详尽的定义。本节的目标旨在介绍 algorithm-free 的优化目标,即本文将不涉及算法地详述强化学习的目标。 上文提到,强化学习的目标可以解释为:在一个 Trajectories (tau) 中积累的

    2024年02月15日
    浏览(45)
  • 【深度强化学习】(4) Actor-Critic 模型解析,附Pytorch完整代码

    大家好,今天和各位分享一下深度强化学习中的 Actor-Critic 演员评论家算法, Actor-Critic 算法是一种综合了策略迭代和价值迭代的集成算法 。我将使用该模型结合 OpenAI 中的 Gym 环境完成一个小游戏,完整代码可以从我的 GitHub 中获得: https://github.com/LiSir-HIT/Reinforcement-Learning

    2024年02月03日
    浏览(48)
  • Pytorch深度强化学习(3):详解K摇臂赌博机模型和ϵ-贪心算法

    本专栏重点介绍强化学习技术的数学原理,并且 采用Pytorch框架对常见的强化学习算法、案例进行实现 ,帮助读者理解并快速上手开发。同时,辅以各种机器学习、数据处理技术,扩充人工智能的底层知识。 🚀详情:

    2024年02月11日
    浏览(39)
  • Pytorch深度强化学习1-2:详解K摇臂赌博机模型和ϵ-贪心算法

    本专栏重点介绍强化学习技术的数学原理,并且 采用Pytorch框架对常见的强化学习算法、案例进行实现 ,帮助读者理解并快速上手开发。同时,辅以各种机器学习、数据处理技术,扩充人工智能的底层知识。 🚀详情:

    2024年02月11日
    浏览(69)
  • [PyTorch][chapter 52][迁移学习]

    前言:      迁移学习(Transfer Learning)是一种机器学习方法,它通过将一个领域中的知识和经验迁移到另一个相关领域中,来加速和改进新领域的学习和解决问题的能力。       这里面主要结合前面ResNet18 例子,详细讲解一下迁移学习的流程 一  简介      迁移学习可以通

    2024年02月12日
    浏览(40)
  • 【chapter30】【PyTorch】[动量与学习率衰减】

    前言:     SGD的不足 :  ①呈“之”字型,迂回前进,损失函数值在一些维度的改变得快(更新速度快),在一些维度改变得慢(速度慢)- 在高维空间更加普遍 ②容易陷入局部极小值和鞍点  ③对于凸优化而言,SGD不会收敛,只会在最优点附近跳来跳去         这里面主

    2024年02月01日
    浏览(37)
  • [PyTorch][chapter 9][李宏毅深度学习][Why Deep]

    前言:        我们知道深度学习一个重要特征是网络堆叠,深。 为什么需要深度, 本篇主要简单介绍一下该原因 目录:    1: 简介    2: 模块化分析    3:  语音识别例子 一  简介           有人通过实验,使用相同的网络参数,深度越深的网络相当于浅层网络效果

    2024年01月25日
    浏览(41)
  • 【强化学习】——Q-learning算法为例入门Pytorch强化学习

    🤵‍♂️ 个人主页:@Lingxw_w的个人主页 ✍🏻作者简介:计算机研究生在读,研究方向复杂网络和数据挖掘,阿里云专家博主,华为云云享专家,CSDN专家博主、人工智能领域优质创作者,安徽省优秀毕业生 🐋 希望大家多多支持,我们一起进步!😄 如果文章对你有帮助的话

    2024年02月10日
    浏览(72)
  • 使用Pytorch实现强化学习——DQN算法

    目录 一、强化学习的主要构成 二、基于python的强化学习框架 三、gym 四、DQN算法 1.DQN算法两个特点 (1)经验回放 (2)目标网络 2.DQN算法的流程 五、使用pytorch实现DQN算法 1.replay memory 2.神经网络部分 3.Agent 4.模型训练函数 5.训练模型 6.实验结果 六、补充说明 强化学习主要由

    2023年04月20日
    浏览(44)

觉得文章有用就打赏一下文章作者

支付宝扫一扫打赏

博客赞助

微信扫一扫打赏

请作者喝杯咖啡吧~博客赞助

支付宝扫一扫领取红包,优惠每天领

二维码1

领取红包

二维码2

领红包