Q-Learning和epsilon-greedy算法

 

（事先有一个Q表，在实际代码中到一个新状态，要检查是否在Q表中，如果state不存在就新建一行）

根据Q表的估计，因为在s1中，a2的值比较大，通过之前的决策方法，我们在s1采取了a2，并到达s2，此时开始更新用于决策的Q表，接着我们并没有在实际中采取任何行为，而是再想象自己在s2上采取了每种行为，分别看看几种行为哪一个的Q值大，比如说Q(s2,a2)的值比Q(s2,a1)的大，所以我们把大的Q(s2,a2)乘上一个衰减值γ（如0.9）并加上到达s2时所获取的奖励R（这里我们还没有获取到棒棒糖，所以奖励为0）因为会获取实实在在的奖励R，我们将这个作为我现实中Q(s1,a2)的值，但是我们之前是根据Q表估计Q(s1,a2)的值。所以有了现实和估计值，我们就能更新Q(s1,a2)，根据估计与现实的差距，将这个差距乘以一个学习效率α累加上老的Q(s1,a2)的值变成新的值。

 上面将的整个算法就是一直不断的更新Q-table里的值，然后再根据新的值来判断要在某个state采取怎样的action。

Q-Learning一般是一个off-policy的算法，因为里面的max action让Q-table的更新可以不基于正在经历的经验（也可以是现在学习着很久以前的经验，甚至是学习他人的经验）。不过本例子我们没有运用到 off-policy，而是把Q-Learning用在了on-policy上，也就是现学现卖，将现在经历的直接当场学习并运用。

整个 Q-Learning 最重要的迭代更新部分：

def update():
    # 学习 100 回合
    for episode in range(100):
        # 初始化 state 的观测值
        observation = env.reset()

        while True:
            # 更新可视化环境
            env.render()

            # RL 大脑根据 state 的观测值挑选 action
            action = RL.choose_action(str(observation))

            # 在环境中实施这个 action, 得到环境返回的下一个 state 观测值, reward 和 done （是否结束）
            observation_, reward, done = env.step(action)

            # RL 从这个序列 (state, action, reward, state_) 中学习
            RL.learn(str(observation), action, reward, str(observation_))

            # 将下一个 state 的值传到下一次循环
            observation = observation_

            # 如果达到结束条件, 这回合就结束了
            if done:
                break

    # 关闭环境
    print('game over')
    env.destroy()

if __name__ == "__main__":
    # 定义环境 env 和 RL 方式
    env = Maze()
    RL = QLearningTable(actions=list(range(env.n_actions)))

    # 开始可视化环境 env
    env.after(100, update)
    env.mainloop()

主结构：

class QLearningTable:
    
    def __init__(self, actions, learning_rate=0.01, reward_decay=0.9, e_greedy=0.9):

    # 选行为
    def choose_action(self, observation):

    # 学习更新参数
    def learn(self, s, a, r, s_):

    # 检测 state 是否存在
    def check_state_exist(self, state):

__init__ 预设值：

import numpy as np
import pandas as pd


class QLearningTable:
    def __init__(self, actions, learning_rate=0.01, reward_decay=0.9, e_greedy=0.9):
        self.actions = actions  # a list
        self.lr = learning_rate # 学习率
        self.gamma = reward_decay   # 奖励衰减
        self.epsilon = e_greedy     # 贪婪度
        self.q_table = pd.DataFrame(columns=self.actions, dtype=np.float64) 

（注意）检测state是否存在

这个功能就是检测Q-table中有没有当前state的步骤了，如果还没有当前的state，那么我们就插入一组全0数据，当做这个state的所有action初始values。

    def check_state_exist(self, state):
        if state not in self.q_table.index:
            # append new state to q table
            self.q_table = self.q_table.append(
                pd.Series(
                    [0]*len(self.actions),
                    index=self.q_table.columns,
                    name=state,
                )
            )

决定行为 choose_action：

    def choose_action(self, observation):
        self.check_state_exist(observation) # 检测本 state 是否在 q_table 中

        # 选择 action
        if np.random.uniform() < self.epsilon:  # 选择 Q value 最高的 action
            state_action = self.q_table.loc[observation, :]

            # 同一个 state, 可能会有多个相同的 Q action value, 所以我们乱序一下
            action = np.random.choice(state_action[state_action == np.max(state_action)].index)

        else:   # 随机选择 action
            action = np.random.choice(self.actions)

        return action

学习

我们根据是否是terminal state（回合终止符）来判断应该如何更新Q-table。更新的方式：update = self.lr * (q_target - q_predict)
这可以理解成神经网络中的更新方式，学习率 ×(真实值 - 预测值)。将判断的误差传递回去，有着和神经网络更新的异曲同工之妙。

    def learn(self, s, a, r, s_):
        self.check_state_exist(s_)  # 检测 q_table 中是否存在 s_
        q_predict = self.q_table.loc[s, a]
        if s_ != 'terminal':
            q_target = r + self.gamma * self.q_table.loc[s_, :].max()  # 下个 state 不是 终止符
        else:
            q_target = r  # 下个 state 是终止符
        self.q_table.loc[s, a] += self.lr * (q_target - q_predict)  # 更新对应的 state-action 值