强化学习 学习记录（3）

Dynamic Programming

动态规划：指的是给MDP一个完美环境模型来获取最优策略的一系列算法，其实也就是上一章中提到的利用最优bellman方程来获取最优策略。
为了得到最优bellman方程，首先就得计算对于任意策略的state-value function。在动态规划中这种操作也被称为policy evaluation,利用bellman方程就能得到，也就是下式。
$$v_{\pi }(s)=\sum _a\pi (a|s)\sum _{s^{\prime },r}p(s^{\prime },r|s,a)(r+\delta v_{\pi }(s^{\prime }))$$
如果环境模型是完全已知的，那这个方程就变为一个可计算的线性方程，设置初始状态为任意值，进行迭代。
$$v_{k+1}(s)=\sum _a\pi (a|s)\sum _{s^{\prime },r}p(s^{\prime },r|s,a)(r+\delta v_k(s^{\prime }))$$
当k趋向于无穷时，式子收敛，$v_k=v_{\pi }$，上面这个式子被称为 iterative policy evaluation。
注意状态的更新是发生在所有状态都被计算完一遍之后才发生。

单单这样讲挺难理解的，来看这个例子就懂了

这个表格中带有数字的是普通状态，灰色的是最终状态，普通状态可以执行的行动是任意方向移动（上下左右），当行动会移出表格时，行动变为呆在原地不动，任意方向的行动都是等概率的，且获得奖励都为-1。初始各状态都设置为0，最终状态保持不变始终为0，discount始终为1。那么利用上面的更新式就可以得到policy evaluation。

import numpy as np

class ITV():
    def __init__(self):
        self.grid = np.zeros([4,4])
        self.reward = -1
    def action(self,direction,grid_state):
        #### direction 0 up 1right 2 down 3 left 
        if direction == 0:
           if grid_state[0] > 0:
            grid_state[0] -= 1
        elif direction ==1 :
             if grid_state[1] <3:
                grid_state[1] += 1
        elif direction ==2 :
             if grid_state[0] <3:
                 grid_state[0] +=1
        elif direction ==3 :
            if grid_state[1] > 0:
                grid_state[1] -= 1

        return grid_state
    def policy(self,new_state,old_state):
        if abs(new_state[0]-old_state[0])+abs(new_state[1]-old_state[1]) <= 1:
            p = 0.25
        else:
            p = 0 
        return p
    def update(self):
        grid_old = self.grid.copy()
        for i in range(self.grid.shape[0]):
            for j in range(self.grid.shape[1]):
             #print(f"grid({i},{j})={self.grid[i][j]}")
                if [i,j] !=[0,0] and [i,j] != [3,3]:
                 value = 0
                 for k in range(4):
                    new_state = self.action(grid_state=[i,j],direction=k)
                    policy = self.policy(new_state,[i,j])
                    value +=  policy*(self.reward+grid_old[new_state[0]][new_state[1]])
                 self.grid[i][j] = value
        print(self.grid)
        


if __name__ =="__main__":
    a = ITV()
    for i in range(100):
     a.update()

配合代码就很好理解这个迭代过程了，我们也可以看到当policy evaluation确定下来后，贪婪行动策略也就被确定下来了，就是沿着state-value 最大的方向走。

Policy improvement

那么如何通过policy evaluation来找到更加好的policy？在某一state下可以选择与原策略不同的行动之后的action仍保持原来的policy，也就是说仅对于${\pi }^{\prime }(s)=a\ne \pi (s)$，对于除了s以外的状态式子两边等号成立。计算value并与原来的value比较。
$$q_{\pi }(s,{\pi }^{\prime }(s))>=v_{\pi }(s)$$
如果式子成立则说明${\pi }^{\prime }$优于或相等于$\pi$也就有
$$v_{{\pi }^{\prime }}(s)>=v_{\pi }(s)$$
这个理论被称为policy improvement theorem。

在原策略上对于value function进行greedy action的策略改善叫做policy improvement。

Policy iteration

原策略 $\pi$ 在进行policy improvement后可得到 ${\pi }^{\prime }$ ，在对${\pi }^{\prime }$ 进行policy evaluation 得到$v_{{\pi }^{\prime }}(s)$，在对其进行policy improvement 得到${\pi }^{\prime \prime }$ ，由于有限MDP只有有限数量的确定策略所以通过有限次迭代 就能收敛到最优策略。这种迭代寻找最优策略的方法叫做policy iteration