强化深度学习中利用时序差分法确定扫地机器人问题的最优解（附源码超详细必看）

梦里梦外; 2023-09-30 17:03 21阅读 0赞

> **运行有问题或需要源码请点赞关注收藏后评论区留下QQ~~~**

## 一、时序差分预测 ##

时序差分法（TD）TD方法将DP的自举性和MC的采样性相结合，学习时间间隔产生的差分数据，并通过迭代更新来求解未知环境模型的MDP问题

在时序差分预测中，每前进一步或N步，就可以直接计算状态值函数，接下来我们讨论单步情况TD(0)下的时序差分算法

TD(0）算法适用于小批量状态的更新方法，其中0表示向前行动一步，它的核心思想是向前行动一步后，使用得到的立即奖赏和下一状态的状态值函数的估计值来进行更新，这也是TD0被称为单步TD算法的原因

表格型TD（0）算法如下

![b0dbca7f24924ea58f7aa1947ce96911.png][]

## 二、时序差分控制 ##

TD控制算法和MC控制算法一样，都遵循GPI，且评估的目标都是状态-动作对的最优动作值函数，为了平衡探索与利用，TD控制算法分为基于策略迭代的同策略Sarsa算法和基于值迭代的异策略Q-Learning算法，它们两个算法都属于TD（0）算法 它们的收敛性同样遵循MC增量式中的随机近似条件

## 三、扫地机器人实战 ##

使用Sarsa算法解决确定环境扫地机器人的问题，将动作值函数设置为24×4的二维数组，这样当Sarsa算法使用具有贪心性质的策略时也会逐渐变得贪心。

运行结果可以看到，当迭代到20000个情节时，迭代已经收敛。

扫地机器人环境的搭建以及背景条件可参考如下链接

[扫地机器人简介][Link 1]

开始迭代时

![45523848732b42a1b2bae16c5e976f1b.png][]

迭代完成后输出如下

![d85ac50cd70d4bc8b422717279e22417.png][]

代码如下

from 扫地机器人gym环境 import GridWorldEnv
    import numpy as np
    np.random.seed(1)
    env = GridWorldEnv()
    #有效动作空间
    def vilid_action_space(s):
        action_sacpe = []
        if s % 5 != 0:#左
            action_sacpe.append(0)
        if s % 5 != 4:#右
            action_sacpe.append(1)
        if s <= 19:#上
            action_sacpe.append(2)
        if s >= 5:#下
            action_sacpe.append(3)
        return action_sacpe
    
    def policy_epsilon_greedy(s, Q, epsilon):#ε贪心策略
        Q_s = Q[s]
        action = vilid_action_space(s)
        if np.random.rand() < epsilon:
            a = np.random.choice(action)
        else:
            index_a = np.argmax([Q_s[i] for i in action])
            a = action[index_a]
        return a
    
    def print_dd(s, a, next_s, next_a, print_len, episode_i, Q,e_k,a_k):
        for i in range(1):  
            if episode_i == int(print_len * (0.1 * i + 1)):
                if s == 21 and a == 1 and next_s == 22 and next_a == 1:
                    print("*********************************单步的计算过程**************************************")
                    print("alpha:"+str(a_k))
                    print("epsilon:"+str(e_k))
                    print("state:" + str(int(print_len * (0.1 * i + 1))))
                    print(Q[s][a])
                    print(Q[next_s][a])
                    print("update:"+str(Q[s, a] + a_k * (0.8 * Q[next_s, next_a] - Q[s, a])))
                    print("************************************************************************************")
    
    def trans(Q_S):#因为环境中动作顺序是左右上下，文章建模的动作顺序是上下左右，所以转换为文章中的顺序（上下左右）进行输出，并保存3位小数
        new_Q = []
        new_Q.append(round(Q_S[2],3))
        new_Q.append(round(Q_S[3],3))
        new_Q.append(round(Q_S[0],3))
        new_Q.append(round(Q_S[1],3))
        return new_Q
    
    def print_ff(list_q, Q, episode_i,epsilon_k,alpha_k):
        list_s = range(0,25)  
        for em in list_q:
            if em == episode_i:
                print("*******************************情节数:%s*******************************"%(str(em)))
                for state in list_s:
                    print("Q(%d,*) "%(state) + str(trans(Q[state])))
                    action = vilid_action_space(state)
                    len_a = len(action)
                    e_p = epsilon_k / float(len_a)
                    prob = []
                    index_a = np.argmax([Q[state][i] for i in action])
                    for i in range(4):#计算epsilon
                        if i not in action:
                            prob.append(0.0)
                        else:
                            if i == action[index_a]:
                                prob.append(1 - epsilon_k + e_p)
                            else:
                                prob.append(e_p)
                    print('概率值:' + str(trans(prob)))
                    print("epsilon_k: {}".format(epsilon_k))
                    print("alpha_k:{}".format(alpha_k))
    
    def Attenuation(epsilon,alpha,episode_sum,episode):#epsilon和alpha衰减函数
        epsilon = (float(episode_sum) - float(episode)) / float(episode_sum) * epsilon
        alpha = (float(episode_sum) - float(episode)) / float(episode_sum) * alpha
        return epsilon, alpha
    
    tate
            epsilon_k, alpha_k = Attenuation(epsilon,alpha,episode_num,episode_i)
            A = policy_epsilon_greedy(S, Q, epsilon_k)
            done = False
            print_ff(list_q,Q,episode_i,epsilon_k,alpha_k)
            while not done:
                next_S, R, done, _ = env.step(A)
                next_A = policy_epsilon_greedy(next_S, Q, epsilon_k)
                print_dd(S,A,next_S,next_A,3000,episode_i,Q,epsilon_k,alpha_k)
                Q[S, A] = Q[S,

**创作不易 觉得有帮助请点赞关注收藏~~~**

[b0dbca7f24924ea58f7aa1947ce96911.png]: https://img-blog.csdnimg.cn/b0dbca7f24924ea58f7aa1947ce96911.png
[Link 1]: https://blog.csdn.net/jiebaoshayebuhui/article/details/127436449
[45523848732b42a1b2bae16c5e976f1b.png]: https://img-blog.csdnimg.cn/45523848732b42a1b2bae16c5e976f1b.png
[d85ac50cd70d4bc8b422717279e22417.png]: https://img-blog.csdnimg.cn/d85ac50cd70d4bc8b422717279e22417.png