RL學習路線

記錄強化學習入門的相關算法及實現。

DP Policy Evaluation

通過以下步驟進行同步backup，從而評估一個給定的 policy ：

1. 在第 $k+1$ 輪，
2. 對於所有狀態 $s\in S$，
3. 更新
   $v_{k+1}(s)=\sum_{a\in\mathcal{A}}\pi(a|s)(\mathcal{R}s^a+\gamma\sum{s‘\in\mathcal{S}}\mathcal{P}_{ss‘}^a v_k(s‘))$
4. 其中， $s‘$ is a successor state of $s$

## 代碼實現
def policy_eval(policy, env, discount_factor=
 
1.0, theta=0.00001):
    # value function初始化為全0/隨機數
    V = np.zeros(env.nS)
    
    while True:
        delta = 0
        
        # 對每個狀態進行backup
        for s in range(env.nS):
            v = 0
            
            # 查找有可能的下一狀態
            for a, action_prob in enumerate(policy[s]):
                # 對於每個動作，查找可能的下一狀態
 

                for  prob, next_state, reward, done in env.P[s][a]:
                    # 計算預測值v
                    v += action_prob * prob * (reward + discount_factor * V[next_state])
                    
            # 獲得所有狀態下，最大的value function更新程度
            delta = max(delta, np.abs(v - V[s]))
            V[s] =
 
 v
            
        # 更新程度小於閾值時停止評估
        if delta < theta:
            break
            
    return np.array(V)

DP Policy Iteration

策略叠代的目標是獲得最優策略，其步驟如下：

1. 給定一個策略 $\pi$，
2. 評估 $\pi$： $v_\pi(s)=\mathbb{E}[R_{t+1}+\gamma R_{t+2}+...|S_t=s]$
3. 貪心地改善 $\pi$： $\pi ‘=greedy(v_\pi)$

其中，改善策略 $\pi$ 的步驟如下：

1. 給定一個策略 $\pi$，且 $a=\pi(s)$
2. 首先改善策略： $\pi ‘(s)=\arg\max_{a\in\mathcal{A}}q_\pi(s,a)$
3. 再改善值 from any state $s$ over one step:
   $$
   q_\pi(s,\pi ‘(s))=\max_{a\in\mathcal{A}}q_\pi(s,a)\geq q_\pi(s,\pi(s))=v_\pi(s)
   $$
4. 因此改善了value function，有 $v_{\pi‘}(s)\geq v_\pi(s)$（證明過程如下）
   $$
   \begin{align}
   v_\pi(s)&\leq q_\pi(s,\pi‘(s))=\mathbb{E}{\pi‘}[R_{t+1}+\gamma v_\pi(S_{t+1})|S_t=s]\
   &\leq\mathbb{E}{\pi‘}[R_{t+1}+\gamma q_\pi(S_{t+1},\pi‘(S_{t+1}))|S_t=s]\
   &\leq\mathbb{E}{\pi‘}[R_{t+1}+\gamma R_{t+2}+\gamma^2 q_\pi(S_{t+2},\pi‘(S_{t+2}))|S_t=s]\
   &\leq\mathbb{E}{\pi‘}[R_{t+1}+\gamma R_{t+2}+...|S_t=s]=v_{\pi‘}(s)
   \end{align}
   $$

[理論上]當滿足條件$q_\pi(s,\pi ‘(s))=\max_{a\in\mathcal{A}}q_\pi(s,a)= q_\pi(s,\pi(s))=v_\pi(s)$（此時對任意狀態s，都有$v_\pi(s)=v_(s)$）時，停止improvement。
[實際中]定義一個閾值$\epsilon$，當value function的更新程度 $\leq\epsilon$時，停止improvement*；或者，直接設定在k輪之後停止。

## 代碼實現（policy_eval是前面的策略評估函數）
def policy_improvement(env, policy_eval_fn=policy_eval, discount_factor=1.0):
    # 初始化策略
    policy = np.ones([env.nS, env.nA]) / env.nA
    
    while True:
        # 評估當前策略
        V = policy_eval_fn(env, policy, discount_factor)
        # 若對策略進行了變動，則policy_stable為False
        policy_stable = True
        
        # 對每個狀態
        for s in range(env.nS):
            # 選擇在當前策略下可采取的最佳動作
            chosen_a = np.argmax(policy[s])
            
            # 向前一步尋找最佳動作
            action_values = np.zeros(env.nA)
            for a in range(env.nA):
                for prob, next_state, reward, done in env.P[s][a]:
                    action_values[a] += prob * (reward + discount_factor * V[next_state])
            best_a = np.argmax(action_values)
            
            # 貪心更新策略
            if chosen_a != best_a:
                policy_stable = False
            policy[s] = np.eye(env.nA)[best_a]
        
        # 找到了最優策略
        if policy_stable:
            return policy, V

DP Value Iteration

值叠代的目標也是獲得最優策略，其步驟如下：

1. 在第 $k+1$ 輪，
2. 對於所有狀態 $s\in S$，
3. 更新
   $v_{k+1}(s)=\max_{a\in\mathcal{A}}(\mathcal{R}s^a+\gamma\sum{s‘\in\mathcal{S}}\mathcal{P}_{ss‘}^a v_k(s‘))$
4. 其中， $s‘$ is a successor state of $s$

Value Iteration (VI) 逆向地（從狀態s‘到s）循環處理整個狀態空間，直到找到最優路徑（即 a set of optimal actions）

Value更新在VI 中和在PE (Policy Evaluation) 中的區別在於：

• 根據上一段描述的VI過程，在VI中更新value不需要知道當前策略是什麽，僅僅直接作用於value空間，所以貪心地用$\max_{a\in\mathcal{A}}$；
• 而在PE中，因為目的是評估策略，value的更新是基於給定策略$\pi$的，所以用$\sum_{a\in\mathcal{A}}\pi(a|s)$。

## 代碼實現
def value_iteration(env, theta=0.0001, discount_factor=1.0):
    def one_step_lookahead(state, V):
        A = np.zeros(env.nA)
        for a in range(env.nA):
            for prob, next_state, reward, done in env.P[state][a]:
                A[a] += prob * (reward + discount_factor * V[next_state])
        return A
    
    V = np.zeros(env.nS)
    while True:
        # 停止更新的條件
        delta = 0
        # 對每個狀態
        for s in range(env.nS):
            # 向前一步尋找最優動作的值（！註意這裏是值，要和策略叠代區分開來）
            A = one_step_lookahead(s, V)
            best_action_value = np.max(A)
            
            # 獲得所有狀態下，最大的value function更新程度
            delta = max(delta, np.abs(best_action_value - V[s]))
            # 更新value function
            V[s] = best_action_value
        # 更新程度小於閾值時停止更新
        if delta < theta:
            break
    
    # 根據最優的value function得到policy
    policy = np.zeros([env.nS, env.nA])
    for s in range(env.nS):
        # 向前一步尋找最優動作
        A = one_step_lookahead(s, V)
        best_action = np.argmax(A)
        # 總是選擇最優動作
        policy[s, best_action] = 1.0
    
    return policy, V

馬爾可夫決策過程中的動規