机器学习之强化学习---《机器学习-周志华》学习笔记

---

强化学习

        强化学习又称再励学习、评价学习或增强学习。我们在执行一个任务时，不知道这个任务对结果能否造成好的影响，只能得到一个当前反馈，需要不断尝试，才能得出较好的策略。这个过程称为”强化学习”。

1.分析强化学习与监督学习的联系与差别

        监督学习：利用一组已知类别的样本调整分类器的参数，使其达到所要求性能的过程，也称为监督训练或有教师学习。
         监督学习是从标记的训练数据来推断一个功能的机器学习任务。
         强化学习中的“策略”实际上就相当于监督学习中的“分类器”（当动作是离散的）或“回归器”（当动作是连续的），模型的形式并无差别。但不同的是，没有人直接告诉机器在什么状态下应该做什么动作，只有等到最终结果揭晓，才能通过“反思”之前的动作是否正确来进行学习。因此，强化学习在某种意义上可看作具有“延迟标记信息”的监督学习问题。

2.ε -贪心法如何实现探索与利用的平衡

2·1 k摇臂赌博机

        k摇臂赌博机有k个摇臂，赌徒投入一个硬币后可选择按下其中一个摇臂，每个摇臂以一定概率吐出硬币，但是赌徒不知道这个概率。
         若仅为获知每个摇臂期望奖赏，则可“仅探索”（即估计摇臂优劣），若按目前最优的摇臂，则为“仅利用”’。“仅探索”会失去很多选择最优摇臂的机会，“仅利用”可能经常选不到最优摇臂。
所以“探索”与“利用”是矛盾的，因为投币次数有限，加强一方则会削弱另一方。因此必须在探索与利用之间达成较好的折中。

2.2 ε -贪心法

         ε -贪心法基于一个概率来对探索和利用进行折中:每次尝试时，以ε的概率进行探索，即以均匀概率随机选取一个摇臂；以1-ε的概率进行利用，即选择当前平均奖赏最高的摇臂（若有多个，则随机选取一个）。
令Q(k)记录摇臂k平均奖赏，若摇臂k被尝试了n次，得到的奖赏为$v_1$,$v_2$,$v_3$,…,$v_n$,则平均奖赏为
$$Q(k)=\frac{1}{n}\sum _{i=1}^n{v}_i（2.1）$$
        由于（2.1）需要记录n个奖赏值，用增量式更高效。初始时$Q_0$（k）=0,若第n-1次尝试后的平均奖赏为$Q_{n-1}$（k）,则经过第n次尝试获得奖赏$v_n$后，平均奖赏更新为
$$Q_n（k）=\frac{1}{n}((n-1)\times Q_{n-1}（k）+v_n)(2.2)$$
$$=Q_{n-1}（k）+\frac{1}{n}(v_n-Q_{n-1}（k）)(2.3)$$
        若摇臂奖赏的不确定性较大，例如概率分布较宽时，则需更多的探索，此时需要较大的ε值；若摇臂的不确定性较小，例如概率分布较集中时，则少量的尝试就能很好地近似真实奖赏，此时需要的较小.通常令ε取一个较小的常数，如0.1或0.01。然而，若尝试次数非常大，那么在一段时间后，摇臂的奖赏都能很好地近似出来，不再需要探索，这种情形下可让ε随着尝试次数的增加而逐渐减小，例如令ε＝1/$\sqrt{t}$。

3.如何用赌博机算法实现强化学习任务

        对于离散状态空间、离散动作空间上的多步强化学习任务，一种直接的办法是将每个状态上动作的选择看作一个K摇臂赌博机问题，用强化学习任务的累积奖赏来代替K摇臂赌博机算法中的奖赏函数，即可将赌博机算法用于每个状态:对每个状态分别记录各动作的尝试次数、当前平均累积奖赏等信息，基于赌博机算法选择要尝试的动作。

图3.1不同算法在2摇臂赌博机上的性能比较

4.试推导折扣累积奖赏的全概率展开式

$$V_{\gamma }^{\pi }(x)=\sum _{a\in A}\pi (x,a)\sum _{x{}^{\prime }\in X}{P}_{x\to x{}^{\prime }}^a(R_{x\to x{}^{\prime }}^a+\gamma V_{\gamma }^{\pi }(x{}^{\prime }))(4.1)$$
公式()中$V_{\gamma }^{\pi }(x)$表示从状态x出发，使用策略π所带来的折扣累积奖赏。
$P_{x\to x{}^{\prime }}^a$表示对于任意状态x,$x{}^{\prime }$和动作a，在x状态下执行动作a转移到,$x{}^{\prime }$状态的概率。
$R_{x\to x{}^{\prime }}^a$表示该转移所带来的奖赏。
暂定E=<X,A,P,R>均为已知，这样的情形称为“模型已知”。
推导过程如下：
$$\begin{array}{rl}{V}_{\gamma }^{\pi }(x)& =E_{\pi }[\sum _{t=0}^{\infty }{\gamma }^t{r}_{t+1}|x_0=x]\\ & =E_{\pi }[r_1+\sum _{t=1}^{\infty }{\gamma }^t{r}_{t+1}|x_0=x]\\ & =E_{\pi }[r_1+\gamma \sum _{t=1}^{\infty }{\gamma }^{t-1}{r}_{t+1}|x_0=x]\\ & =\sum _{a\in A}\pi (x,a)\sum _{x{}^{\prime }\in X}{P}_{x\to x{}^{\prime }}^a(R_{x\to x{}^{\prime }}^a+\gamma E_{\pi }[\sum _{t=0}^{\infty }{\gamma }^t{r}_{t+1}|x_0=x{}^{\prime }])\\ & =\sum _{a\in A}\pi (x,a)\sum _{x{}^{\prime }\in X}{P}_{x\to x{}^{\prime }}^a(R_{x\to x{}^{\prime }}^a+\gamma V_{\gamma }^{\pi }(x{}^{\prime }))\end{array}$$

5.什么是动态规划中的最优性原理，与强化学习中的策略更新有什么关系

5.1最优性原理

        最优性原理是指“多阶段决策过程的最优决策序列具有这样的性质：不论初始状态和初始决策如何，对于前面决策所造成的某一状态而言，其后各阶段的决策序列必须构成最优策略”。

5.2策略更新

        对某个策略的累积奖赏进行评估后，若发现它并非最优策略，则需要进行策略更新。理想的策略应能最大化累积奖赏，如公式5.1
$${\pi }^{\ast }=ar{g}_{\pi }^{max}\sum _{x\in X}{V}^{\pi }(x)(5.1)$$

        不妨令动作改变后对应的策略为$\pi {}^{\prime }$，$Q^{\pi }(x,a)$表示从状态x出发，执行动作a后再使用动作策略π带来的累积奖赏，改变动作的条件为$Q^{\pi }(x,\pi {}^{\prime }（x）)\ge V^{\pi }(X)$,则递推不等式如下：

因此，两者都是后面的策略相对于前面的策略是更优化的。

6.完成时序差分学习中式(6.1)的推导

$$Q_{t+1}^{\pi }\left(x,a\right)=Q_t^{\pi }\left(x,a\right)+\alpha \left(R_{x\to x^{\prime }}^a+\gamma Q_t^{\pi }\left(x^{\prime },a^{\prime }\right)-Q_t^{\pi }\left(x,a\right)\right)（6.1）$$
根据式 $Q_{t+1}^{\pi }\left(x,a\right)=Q_t^{\pi }\left(x,a\right)+\frac{1}{t+1}\left(r_{t+1}-Q_t^{\pi }\left(x,a\right)\right)$
并且$\frac{1}{t+1}=\alpha$
可得$r_{t+1}=R_{x\to x^{\prime }}^a+\gamma Q_t^{\pi }\left(x^{\prime },a^{\prime }\right)$
于是可以推出式（6.1）

7.对于目标驱动的强化学习任务，目标是到达某一状态，例如机器人走到预定的位置，假设机器人只能在一维空间运动，即只能向左或者向右运动，机器人起始位置在最左侧，预定的位置在最右侧，试为这样的任务设置奖赏规则，并编程实现。

import numpy as np
import pandas as pd
import time

np.random.seed(2)  # reproducible


N_STATES = 6   # the length of the 1 dimensional world
ACTIONS = ['left', 'right']     # available actions
EPSILON = 0.9   # greedy police
ALPHA = 0.1     # learning rate
GAMMA = 0.9    # discount factor
MAX_EPISODES = 13   # maximum episodes
FRESH_TIME = 0.3    # fresh time for one move


def build_q_table(n_states, actions):
    table = pd.DataFrame(
        np.zeros((n_states, len(actions))),     # q_table initial values
        columns=actions,    # actions's name
    )
    # print(table)    # show table
    return table


def choose_action(state, q_table):
    # This is how to choose an action
    state_actions = q_table.iloc[state, :]
    if (np.random.uniform() > EPSILON) or ((state_actions == 0).all()):  # act non-greedy or state-action have no value
        action_name = np.random.choice(ACTIONS)
    else:   # act greedy
        action_name = state_actions.idxmax()    # replace argmax to idxmax as argmax means a different function in newer version of pandas
    return action_name


def get_env_feedback(S, A):
    # This is how agent will interact with the environment
    if A == 'right':    # move right
        if S == N_STATES - 2:   # terminate
            S_ = 'terminal'
            R = 1
        else:
            S_ = S + 1
            R = 0
    else:   # move left
        R = 0
        if S == 0:
            S_ = S  # reach the wall
        else:
            S_ = S - 1
    return S_, R


def update_env(S, episode, step_counter):
    # This is how environment be updated
    env_list = ['-']*(N_STATES-1) + ['T']   # '---------T' our environment
    if S == 'terminal':
        interaction = 'Episode %s: total_steps = %s' % (episode+1, step_counter)
        print('\r{}'.format(interaction), end='')
        time.sleep(2)
        print('\r                                ', end='')
    else:
        env_list[S] = 'o'
        interaction = ''.join(env_list)
        print('\r{}'.format(interaction), end='')
        time.sleep(FRESH_TIME)


def rl():
    # main part of RL loop
    q_table = build_q_table(N_STATES, ACTIONS)
    for episode in range(MAX_EPISODES):
        step_counter = 0
        S = 0
        is_terminated = False
        update_env(S, episode, step_counter)
        while not is_terminated:

            A = choose_action(S, q_table)
            S_, R = get_env_feedback(S, A)  # take action & get next state and reward
            q_predict = q_table.loc[S, A]
            if S_ != 'terminal':
                q_target = R + GAMMA * q_table.iloc[S_, :].max()   # next state is not terminal
            else:
                q_target = R     # next state is terminal
                is_terminated = True    # terminate this episode

            q_table.loc[S, A] += ALPHA * (q_target - q_predict)  # update
            S = S_  # move to next state

            update_env(S, episode, step_counter+1)
            step_counter += 1
    return q_table


if __name__ == "__main__":
    q_table = rl()
    print('\r\nQ-table:\n')
    print(q_table)