强化学习使用的是bellmen方程，即当前奖励值 = max(当前位置的及时奖励 + discout_factor * 下一个方向的奖励值)   discount_factor表示奖励的衰减因子

使用的是预先制造好的九宫格的类

代码说明：

     env.nA,即每个位置的下一个方向的个数为4 

     env.nS 表示九宫格的大小为16

     env.P[state][a] 表示九宫格对应位置的方向，返回的是prob概率， next_state下一个位置，reward及时奖励, done是够到达出口

     env.shape 表示九宫格的形状，4*4

 

代码：

     第一步：定义总的函数valueiteration, 输入参数为env, theta=0.0001变化的阈值， discout_factor=1.0奖励的衰减值 

     第二步：定义one_step_look_head() 用于计算当前位置的往四个方向的奖励值， 输入为当前位置state， v奖励值矩阵

                    第一步：初始化A, A的大小为np.zeros(env.nA)

                    第二步：循环range(4), for prob, next_state, reward, done in env.P[state][a] 来获得对应的概率值，下一个方向的位置，reward及时奖励值，done是否到达终点

                    第三步：使用A[a] += prob * (reward + discount_factor * v[next_state]) 来获得四个方向的奖励值，返回奖励值

      第三步：进行循环操作，不断更新V，直到V的变化小于theta，即跳出循环

                     第一步：使用np.zeros(env.nS) 初始化V矩阵

                     第二步：不断循环env.nS,即循环16次 s，delta = 0

                     第三步： 调用one_step_look_head(s, V) 获得当前位置的各方向奖励值A 

                     第四步： 使用np.max获得最大的奖励值，将最大奖励值 - 当前位置V的奖励值，使用max取较大值

                     第五步：循环16次后， 如果max获得的较大值比theta要小，即V已经不发生改变，跳出循环 

      第四步：构造policy判断当前位置的移动方向

                    第一步：初始化policy矩阵，矩阵的大小为16, 4 

                     第二步：循环16次，调用one_step_look_head(s, V) V 已经训练好，获得A，四个方向的奖励值

                     第三步：使用np.argmax()获得最大位置的索引值

                     第四步：将最大位置的索引值赋值为1

                      第五步：返回policy

       第五步：调用valueiteration(env), 获得policy， 使用np.reshape(np.argmax(policy, axis=1), env.shpae)  将policy转换为数字类型的

from Nine_Bouding抄写.gridworld import GridworldEnv
import numpy as np

# 获得GridwordEnv()的类
env = GridworldEnv()

# 第一步：定义valueiteration函数,输入为env,theta迭代结束的阈值，discount_factor表示奖励的惩罚值
def valueiteration(env, theta=0.001, discount_factor=1.0):

    # 第二步：构建one_step_look_head用于计算当前位置四个方向的奖励值
    def one_step_look_head(state, v):
        # 初始化四个方向的奖励值
        A = np.zeros(env.nA)
        # 循环a = 0, 1, 2, 3 
        for a in range(env.nA):
            # 获得当前位置对应方向的prob概率，next_state，下一个方向的位置，reward及时奖励，done是否到达出口
            for prob, next_state, reward, done in env.P[state][a]:
                # 使用prob * (及时奖励 + 下一个位置的奖励)获得当前位置方向的奖励值
                A[a] += prob * (reward + discount_factor * v[next_state])
        # 返回当前位置四个方向的奖励值
        return A
    # 第三步：不断循环获得奖励值矩阵V 
    
    # 初始化奖励值V 
    V = np.zeros(env.nS)
    # 循环
    while True:
        # 初始化差值
        delta = 0
        # 循环16次，即一圈
        for s in range(env.nS):
            # 调用one_step_look_head获得当前位置4个方向的奖励值
            A = one_step_look_head(s, V)
            # 使用np.max获得最大的奖励值
            max_action = np.max(A)
            # 使用当前方向最大的奖励值 - 当前的奖励值
            delta = max(delta, np.abs(max_action - V[s]))
            # 把当前方向最大的奖励值赋值给当前的奖励值
            V[s] = max_action
        # 循环16次以后, 如果差值小于theta，就跳出循环    
        if delta < theta:
            break
    # 第四步：定义位置的策略值，用于获得每个位置的方向
    policy = np.zeros((env.nS, env.nA))
    # 循环16次
    for s in range(env.nS):
        # 获得当前位置每个方向的奖励值
        A = one_step_look_head(s, V)
        # 获得最大方向的奖励值的索引
        max_action = np.argmax(A)
        # 将决策的最大索引赋值为1 
        policy[s, max_action] = 1
    # 返回决策值
    return policy

# 第五步：调用valueiteration获得policy
policy = valueiteration(env)
print(policy)
# 将policy使用索引值来替换
policy_to_index = np.reshape(np.argmax(policy, axis=1), env.shape)
print(policy_to_index)

深度学习实战-强化学习-九宫格 当前奖励值 = max(及时奖励 + 下一个位置的奖励值 * 奖励衰减)