• [PyTorch][chapter 61][强化学习-免模型学习1]

    前言：

          在现实的学习任务中，环境 E=<X,A,P,R>

        其中的转移概率P,奖赏函数R 是未知的，或者状态X也是未知的

        称为免模型学习（model-free learning）

    目录：

         1:  蒙特卡洛强化学习

         2：同策略-蒙特卡洛强化学习

         3： 异策略- 蒙特卡洛强化学习

    一  蒙特卡洛强化学习

       

       在免模型学习的情况下，策略迭代算法会遇到两个问题：

    　　1:  是策略无法评估
                因为无法做全概率展开。此时 只能通过在环境中执行相应的动作观察得到的奖赏和转移的状态、
           
           解决方案：一种直接的策略评估代替方法就是“采样”，然后求平均累积奖赏，作为期望累积奖赏的近似，这称为“蒙特卡罗强化学习”。

    　　2:  策略迭代算法估计的是 状态值函数（state value function） V，而最终的策略是通过 状态        动作值函数（state-action value function） Q 来获得。
            模型已知时，有很简单的从 V 到 Q 的转换方法，而模型未知 则会出现困难。
           
           解决方案：所以我们将估计对象从 V 转为 Q，即：估计每一对 “状态-动作”的值函数。

         模型未知的情况下，我们从起始状态出发，使用某种策略进行采样，执行该策略T步，

    并获得轨迹 < x_0,a_0,r_1,a_1,r_2,...x_{T-1},a_{T-1},r_T,x_T>,

     然后 对轨迹中出现的每一对 状态-动作,记录其后的奖赏之和,作为 状态-动作 对的一次

    累积奖赏采样值. 多次采样得到多条轨迹后，将每个状态-动作对的累积奖赏采样值进行平均。即得到 状态-动作值函数的估计.

    二  同策略蒙特卡洛强化学习

       target   Policy ： 要优化的策略，也称为原始策略

       behavior policy： 用来产生轨迹的策略

     在on-policy 方案里面，两个策略相同。

        要获得好的值函数估计,就需要不同的采样轨迹。 

       我们将确定性的策略\pi 称为原始策略

      原始策略上使用 \epsilon-贪心法的策略记为\pi^{\epsilon }(x)=

       以概率1-\epsilon 选择策略1:           策略1 ：\pi(x)

       以概率\epsilon    选择策略2：             策略2：均匀概率选取动作,

    对于最大化值函数的原始策略

    \pi= argmax_{a}Q(x,a)

    其中\epsilon-贪心策略\pi^{\epsilon }中:

    当前最优动作被选中的概率   1-\epsilon +\frac{\epsilon }{|A|}

     每个非最优动作选中的概率 \frac{\epsilon }{|A|}，多次采样后将产生不同的采样轨迹。

    因此对于最大值函数的原始策略\pi^{'},同样有

    算法中，每采样一条轨迹，就根据该轨迹涉及的所有"状态-动作"对值函数进行更新

    同策略蒙特卡罗强化学习算法最终产生的是E-贪心策略。然而，引入E-贪心策略是为了便于策略评估，而不是最终使用

    三  同策略蒙特卡洛算法 Python

      整个算法分为三部分：

    迭代

        1： 使用behavior policy 生成轨迹

        2： 根据轨迹的样本，进行策略评估

        3： 根据策略评估的结果Q(累积奖赏）,优化target policy(选择状态-动作 最大值）

    1. import numpy as ap
    2. # -*- coding: utf-8 -*-
    3. """
    4. Created on Fri Nov  3 09:37:32 2023
    6. @author: chengxf2
    7. """
    8.  
    9. # -*- coding: utf-8 -*-
    10. """
    11. Created on Thu Nov  2 19:38:39 2023
    13. @author: cxf
    14. """
    15.  
    16. import random
    17. from enum import Enum
    18.  
    19. class State(Enum):
    20.     #状态空间#
    21.     shortWater =1 #缺水
    22.     health = 2   #健康
    23.     overflow = 3 #溢水
    24.     apoptosis = 4 #凋亡
    25.  
    26. class Action(Enum):
    27.     #动作空间A#
    28.     water = 1 #浇水
    29.     noWater = 2 #不浇水
    30.     
    31. class Env():
    32.     
    33.     def getReward(self, nextState):
    34.         #针对转移到新的环境奖赏    
    35.         r = -100
    36.         if nextState is State.shortWater:
    37.              
    38.             r =-1
    39.             
    40.         elif nextState is State.health:
    41.             
    42.             r = 1
    43.             
    44.         elif nextState is State.overflow:
    45.             r= -1
    46.         else:
    47.             r = -100
    48.         return r
    49.             
    50.     
    51.     def action(self, state, action):
    52.          
    53.        
    54.          if state is State.shortWater:
    55.              #print("\n state--- ",state, "\t action---- ",action)
    56.              if action is Action.water :
    57.               
    58.                  S =[State.shortWater, State.health]
    59.                  proba =[0.4, 0.6]
    60.              else:
    61.                  S =[State.shortWater, State.apoptosis]
    62.                  proba =[0.5, 0.5]
    63.              
    64.             
    65.          elif state is State.health:
    66.              #健康
    67.              if action is Action.water :
    68.                  S =[State.health, State.overflow]
    69.                  proba =[0.6, 0.4]
    70.              else:
    71.                  S =[State.shortWater, State.health]
    72.                  proba =[0.6, 0.4]
    73.              
    74.          elif state is State.overflow:
    75.              #溢水
    76.              if action is Action.water :
    77.                  S =[State.overflow, State.apoptosis]
    78.                  proba =[0.6, 0.4]
    79.              else:
    80.                  S =[State.health, State.overflow]
    81.                  proba =[0.6, 0.4]
    82.              
    83.          else:  
    84.              #凋亡
    85.                  S =[State.apoptosis]
    86.                  proba =[1.0]
    87.          #print("\n S",S, "\t prob ",proba)
    88.          nextState = random.choices(S, proba)[0]
    89.          reward= self.getReward(nextState)
    90.          return nextState,reward
    91.          
    92.          
    93.          
    94.      
    95.     def __init__(self):
    96.          
    97.         self.name = "环境空间"
    98.          
    99.     
    100.      
    101.     
    102.     
    103.     
    104. class Agent():
    105.     
    106.     
    107.     def initPolicy(self):
    108.         
    109.         self.Q ={} #累积奖赏
    110.         self.count ={} #[state,action] 出现的次数
    111.  
    112.         for state in self.S:
    113.             for action in self.A:
    114.                 self. Q[state, action] = 0
    115.                 self.count[state,action]= 0
    116.          
    117.                 
    118.     
    119.     
    120.     
    121.     def behavior(self,state):
    122.         #使用行为策略 behavior-policy
    123.         r = random.random()
    124.         
    125.         if r<self.epsi:
    126.             #使用随机策略
    127.             A= self.A
    128.             randProb =[0.5,0.5]
    129.             action = random.choices(A, randProb)[0]
    130.             
    131.         else:#使用target policy >1-epsi
    132.         
    133.             action = self.policy[state]
    134.         
    135.         return action
    136.     
    137.                 
    138.  
    139.     
    140.     def generate(self,T):
    141.         #使用行为策略(e贪心策略),产生轨迹
    142.         #轨迹[s0,a0,r0],[s1,a1,r1]......[rT-1,aT-1,rT-1]
    143.         env = Env()
    144.         state = State.shortWater #从缺水开始
    145.         trajectory ={}
    146.         
    147.         for t in range(T):
    148.                  action = self.behavior(state)
    149.                  nextState,reward = env.action(state, action)
    150.                  trajectory[t] =[state, action, reward]
    151.                  state = nextState
    152.         return trajectory
    153.     
    154.        
    155.     def evaluate(self,T ,trajectory):
    156.         #策略评估
    157.         
    158.         denominator =0
    159.  
    160.         for t in range(0,T):
    161.             
    162.             denominator =T-t
    163.             
    164.             R_t = 0
    165.             acc = 0
    166.             for i in range(t,T):
    167.                 r = trajectory[i][-1]
    168.                 acc = acc+r
    169.             R_t = acc/denominator #t时刻的累积奖赏
    170.             state_t  = trajectory[t][0]
    171.             action_t = trajectory[t][1]
    172.             
    173.             count = self.count[state_t, action_t]
    174.             self.Q[state_t, action_t] = (self.Q[state_t, action_t]*count+R_t)/(count+1)
    175.             self.count[state_t, action_t] +=1
    176.             
    177.  
    178.        
    179.               
    180.     def improve(self):
    181.            #策略提升
    182.            
    183.            for state in self.S:
    184.                
    185.                maxReward = self.Q[state,Action.water]
    186.            
    187.                for action in self.A:
    188.                    
    189.                    reward = self.Q[state,action]
    190.                    
    191.                    if reward>=maxReward:
    192.                        maxReward = reward
    193.                        self.policy[state] = action
    194.                #print("\n state ",state, "\t maxReward ",maxReward)
    195.                        
    196.            
    197.            
    198.            
    199.         
    200.         
    201.         
    202.     def learn(self):
    203.         
    204.         self.initPolicy()
    205.         #target policy 最终要优化的策略
    206.         self.policy ={}
    207.         T =15
    208.         
    209.         for state in self.S:
    210.             self.policy[state] = Action.noWater
    211.         
    212.         for s in range(1,self.epsidode): #采样第S 条轨迹
    213.             
    214.                #使用e 贪心策略生成轨迹
    215.                trajectory = self.generate(T)
    216.                #策略评估
    217.                self.evaluate(T, trajectory)
    218.               
    219.                print("\n 迭代次数 %d"%s ,"\t 缺水：",self.policy[State.shortWater].name,
    220.                                           "\t 健康：",self.policy[State.health].name,
    221.                                          "\t 溢水：",self.policy[State.overflow].name,
    222.                                          "\t 凋亡：",self.policy[State.apoptosis].name)
    223.                 
    224.                 
    225.                #策略improve
    226.                self.improve()
    227.            
    228.                
    229.                         
    230.  
    231.                 
    232.  
    233.     
    234.     def __init__(self):
    235.         
    236.         self.S = [State.shortWater, State.health, State.overflow, State.apoptosis]
    237.         self.A = [Action.water, Action.noWater]
    238.         self.Q ={} #累积奖赏
    239.         self.count ={}
    240.         self.policy ={}
    241.         self.epsidode =1000
    242.         self.epsi = 0.2
    243.  
    244.  
    245.     
    246. if  __name__ == "__main__":
    247.     
    248.      agent = Agent()
    249.      agent.learn()

  • 相关阅读:
    【Java面试】MongoDB
    【JavaWeb】Servlet属性设置
    EVE111
    原始资料的收集方法———定性资料的收集
    oracle在Windows正常使用需要启动哪些服务
    普中51-独立按键实验
    Spring MVC 的核心组件有哪些？
    java计算机毕业设计springboot+vue社区养老管理系统(源码+系统+mysql数据库+Lw文档）
    百日刷题计划 ———— DAY2
    基于JAVA医院预约挂号系统计算机毕业设计源码+系统+mysql数据库+lw文档+部署
  • 原文地址：https://blog.csdn.net/chengxf2/article/details/134183448