强化学习_03_表格方法总结

一、monta carlo

迭代时间：一个回合结束后, 对每个动作进行迭代
回合内行动策略：探索+利用
迭代公式：当前状态行动带来的收益($Q_{(<s,a>,t)}$)加一定比例的行动收益($G_t$);行动收益等于后续所有动作的奖励乘折扣系数(${\gamma }^t$)之和减去当前状态行动带来的收益($Q_{(<s,a>,t)}$)
$$\begin{gathered} Q_{(<s,a>,t+1)}=Q_{(<s,a>,t)}+\alpha \ast (G_t-Q_{(<s,a>,t)}) \\ {G}_t=\sum _t^T{\gamma }^t\ast R_t \end{gathered}$$
脚本实现：

s = env.reset()
done = False
# 进行游戏，直到回合结束
experience = []
while not done:
    if render:
        env.render()
    a = self.policy(s, actions)
    n_state, reward, done, info = env.step(a)
    experience.append({"state": s, "action": a, "reward": reward})
    s = n_state
else:
    self.log(reward)

# 估计各种状态、行动
for i, x in enumerate(experience):
    s, a = x["state"], x["action"]

    # 计算状态s对应的折现值
    G, t = 0, 0
    for j in range(i, len(experience)):
        G += math.pow(gamma, t) * experience[j]["reward"]
        t += 1

    N[s][a] += 1  # s, a 对的数量
    alpha = 1 / N[s][a]
    self.Q[s][a] += alpha * (G - self.Q[s][a])

monte calo每次都是针对行动轨迹进行迭代学习，为同策略学习。反应会相对较慢，相对保守。

二、Qlearning

迭代时间：每个动作之后就进行迭代
回合内行动策略：探索+利用
迭代公式：当前状态行动带来的收益($Q_{(<s,a>,t)}$)加一定比例的行动收益($G_t$);
行动收益等于当前行动奖励($R_{(<s,a>,t)}$)加折扣系数($\gamma$)乘以下一状态最大行动价值($max(Q_{(<s>,t+1)})$)减去当前状态行动带来的收益($Q_{(<s,a>,t)}$)
$$\begin{gathered} Q_{(<s,a>,t)}=Q_{(<s,a>,t)}+\alpha \ast (G_t-Q_{(<s,a>,t)}) \\ {G}_t=R_{(<s,a>,t)}+\gamma \ast max(Q_{(<s>,t+1)}) \end{gathered}$$

脚本实现:

s = env.reset()
done = False
while not done:
    if render:
        env.render()
    a = self.policy(s, actions)
    n_state, reward, done, info = env.step(a)

    gain = reward + gamma * max(self.Q[n_state])
    estimated = self.Q[s][a]
    self.Q[s][a] += learning_rate * (gain - estimated)
    s = n_state

else:
    self.log(reward)

Q学习每次都用改状态下个最大奖励动作(不一定是当前动作)来进行更新，是异策略。表现的会更加的莽撞、激进。

三、SARSA

迭代时间：每个动作之后就进行迭代
回合内行动策略：探索+利用
迭代公式：当前状态行动带来的收益($Q_{(<s,a>,t)}$)加一定比例的行动收益($G_t$);
行动收益等于当前行动奖励($R_{(<s,a>,t)}$)加折扣系数($\gamma$)乘以下一状态行动价值($max(Q_{(<s>,t+1)})$)减去当前状态行动带来的收益($Q_{(<s,a>,t)}$)

$$\begin{gathered} Q_{(<s,a>,t)}=Q_{(<s,a>,t)}+\alpha \ast (G_t-Q_{(<s,a>,t)}) \\ {G}_t=R_{(<s,a>,t)}+\gamma \ast Q_{(<s>,t+1)} \end{gathered}$$
和Qlearn的唯一区别就是学习的是下一状态的行动价值，是同策略的迭代学习

多步SARSA

迭代时间：每个动作之后n步就进行迭代
回合内行动策略：探索+利用
迭代公式：当前状态行动带来的收益($Q_{(<s,a>,t)}$)加一定比例的n步行动收益($G_t$);
$$\begin{gathered} Q_{(<s,a>,t)}=Q_{(<s,a>,t)}+\alpha \ast (G_t-Q_{(<s,a>,t)}) \\ {G}_t=R_{(<s,a>,t)}+\gamma \ast R_{(<s,a>,t+1)}+{\gamma }^2\ast R_{(<s,a>,t+2)}+...+{\gamma }^n{Q}_{(<s>,t+n)} \end{gathered}$$

简单迭代实现

 if len(self.state_list) == self.n:  # 若保存的数据可以进行n步更新
     G = self.Q_table[s1, a1]  # 得到Q(s_{t+n}, a_{t+n})
     for i in reversed(range(self.n)):
         G = self.gamma * G + self.reward_list[i]  # 不断向前计算每一步的回报
         # 如果到达终止状态,最后几步虽然长度不够n步,也将其进行更新
         if done and i > 0:
             s = self.state_list[i]
             a = self.action_list[i]
             self.Q_table[s, a] += self.alpha * (G - self.Q_table[s, a])
     # n步Sarsa的主要更新步骤
     self.Q_table[s, a] += self.alpha * (G - self.Q_table[s, a])

四、ActorCritic

迭代时间：每个动作之后就进行迭代
回合内行动策略：探索+利用
特殊构造：Actor负责探索($Q_{(<s,a>,t)}$), Critic负责评估状态价值($V_{s,t}$)。
迭代公式：
当前状态行动带来的收益($Q_{(<s,a>,t)}$)加一定比例的行动收益(td_t);
行为收益等于当前行动奖励($R_t$)加上一定比例($\gamma$)的下一状态的价值($V_{s,t+1}$)减去当前状态的价值($V_{s,t}$)

$$\begin{gathered} Actor:Q_{(<s,a>,t)}=Q_{(<s,a>,t)}+\alpha \ast t{d}_t \\ Critic:V_{s,t}=V_{s,t}+\alpha \ast t{d}_t \\ t{d}_t=R_t+\gamma \ast V_{s,t+1}-V_{s,t} \end{gathered}$$

脚本实现:

s = env.reset()
done = False
while not done:
    if render:
        env.render()
    a = actor.policy(s)
    n_state, reward, done, info = env.step(a)

    gain = reward + gamma * critic.V[n_state]
    estimated = critic.V[s]
    td = gain - estimated
    actor.Q[s][a] += learning_rate * td
    critic.V[s] += learning_rate * td
    s = n_state

else:
    actor.log(reward)