Skip to content

Commit 70eef77

Browse files
applenobapplenob
committed
update
1 parent daed49e commit 70eef77

File tree

4 files changed

+266
-23
lines changed

4 files changed

+266
-23
lines changed

‎notes/intro_note_04.md‎

Lines changed: 62 additions & 4 deletions
Original file line numberDiff line numberDiff line change
@@ -9,19 +9,47 @@
99
## Policy Evaluation
1010

1111
- **评估一个策略的好坏。**
12-
- 策略评估，**计算某个policy对应的价值函数**，也被称为prediction problem。
12+
- **策略评估**：**计算某个policy对应的价值函数**，也被称为prediction problem。
1313
- 更新方法：使用上一章讲的**Bellman Expectation Euqation for** $v_{\pi}$：$v_{\pi}(s) = \sum_a\pi(a|s)\sum_{s',r}p(s',r|s,a)[r+\gamma v_{\pi}(s')]\;\;\forall s \in S$
1414

1515
![iterative_policy_evaluation](../res/iterative_policy_evaluation.png)
1616

17+
核心代码：
18+
19+
```python
20+
src = new_state_values if in_place else state_values
21+
...
22+
value = 0
23+
for action in ACTIONS:
24+
(next_i, next_j), reward = step([i, j], action)
25+
value += ACTION_PROB * (reward + src[next_i, next_j])
26+
new_state_values[i, j] = value
27+
```
28+
29+
其中，`step`函数即MDP的模型，会根据当前状态和动作产生下一个状态和奖励。
30+
1731
## Policy Improvement
1832

1933
在当前的策略和相应的价值函数的基础上，使用价值函数贪婪地更新当前策略的过程。
2034

21-
policy improvement theorem：对所有的$s \in S$，有$q_{\pi}(s, \pi'(s)) \geq v_{\pi}(s)$，则$v_{\pi'}\geq v_{\pi}(s)$，即策略$\pi'$优于策略$\pi$。
35+
**policy improvement theorem**：对所有的$s \in S$，有$q_{\pi}(s, \pi'(s)) \geq v_{\pi}(s)$，则$v_{\pi'}\geq v_{\pi}(s)$，即策略$\pi'$优于策略$\pi$。
2236

2337
greedy policy：$\pi'(s)=\underset{a}{argmax}q_{\pi}(s,a)=\underset{a}{argmax}\sum_{s', r}p(s', r|s,a)[r+\gamma v_{\pi}(s')]$
2438

39+
核心代码：
40+
41+
```python
42+
policy = np.zeros(value.shape, dtype=np.int)
43+
...
44+
# policy improvement
45+
new_policy = np.copy(policy)
46+
for i in range(MAX_CARS + 1):
47+
for j in range(MAX_CARS + 1):
48+
action_returns = []
49+
...
50+
new_policy[i, j] = actions[np.argmax(action_returns)]
51+
```
52+
2553
## Policy Iteration
2654

2755
![policy_iteration_2](../res/policy_iteration_2.png)
@@ -30,9 +58,18 @@ greedy policy：$\pi'(s)=\underset{a}{argmax}q_{\pi}(s,a)=\underset{a}{argmax}\s
3058

3159
![policy_iteration](../res/policy_iteration.png)
3260

61+
核心代码：
62+
63+
```python
64+
policy_change = (new_policy != policy).sum()
65+
if policy_change == 0:
66+
...
67+
break
68+
```
69+
3370
## Value Iteration
3471

35-
Policy Iteration的缺点：每一次迭代都要评估策略，而每一次策略评估本身都是一个迭代过程。
72+
Policy Iteration的缺点：每一次迭代都要评估策略，而**每一次策略评估本身都是一个迭代过程**。
3673

3774
$v_{k+1}(s)=\underset{a}{max} E[R_{t+1}+\gamma v_k(S_{t+1})|S_t=s, A_t=a]$
3875

@@ -42,4 +79,25 @@ $=\underset{a}{max}\sum_{s',r}p(s',r|s,a)[r+\gamma v_k(s')]$
4279

4380
![value_iteration](../res/value_iteration.png)
4481

45-
Value Iteration简单地说就是每次评估价值的时候直接用可能的用最优价值函数更新价值函数（这样的每一步不涉及策略本身）；在确定已经获得比较准确的价值评估之后，再一次性确定策略。
82+
**Value Iteration**简单地说就是每次评估价值的时候直接用可能的用**最优价值函数更新价值函数**（这样的每一步不涉及策略本身）；在确定已经获得比较准确的价值评估之后，再一次性确定策略。
83+
84+
核心代码：
85+
86+
```python
87+
# value iteration
88+
while True:
89+
delta = 0.0
90+
for state in STATES[1:GOAL]:
91+
# get possilbe actions for current state
92+
actions = np.arange(min(state, GOAL - state) + 1)
93+
action_returns = []
94+
for action in actions:
95+
action_returns.append(
96+
HEAD_PROB * state_value[state + action] + (1 - HEAD_PROB) * state_value[state - action])
97+
new_value = np.max(action_returns)
98+
delta += np.abs(state_value[state] - new_value)
99+
# update state value
100+
state_value[state] = new_value
101+
if delta < 1e-9:
102+
break
103+
```

‎notes/intro_note_05.md‎

Lines changed: 102 additions & 15 deletions
Original file line numberDiff line numberDiff line change
@@ -2,13 +2,17 @@
22

33
## 蒙特卡洛方法简介
44

5-
- 使用蒙特卡洛方法不需要像DP一样，对环境要有完整的知识，而是通过**经验**去学习。所谓经验就是对状态、动作、奖励的采样（sample sequence）。
6-
- 用sample的均值去近似期望。
7-
- 使用蒙特卡洛通常需要完整的episode，因此蒙特卡洛的更新方式更像是**episode-by-episode**，而不是像DP的step-by-step。
8-
- 优点：
9-
- 1.可以从实际经验中学习；
10-
- 2.可以从模拟的经验中学习；
11-
- 3.可以直接从感兴趣的state开始采样episode。
5+
使用蒙特卡洛方法不需要像DP一样，对环境要有完整的知识，而是通过**经验**去学习。所谓经验就是对状态、动作、奖励的采样（sample sequence）。
6+
7+
用sample的均值去近似期望。
8+
9+
使用蒙特卡洛通常需要完整的**episode**，因此蒙特卡洛的更新方式更像是**episode-by-episode**，而不是像DP的**step-by-step**。
10+
11+
优点：
12+
13+
- 1.可以从实际经验中学习；
14+
- 2.可以从模拟的经验中学习；
15+
- 3.可以直接从感兴趣的state开始采样episode。
1216

1317
## 蒙特卡洛预测（评估）
1418

@@ -20,11 +24,25 @@
2024

2125
$V(s)\leftarrow average(Return(s))$
2226

27+
核心代码：
28+
29+
```python
30+
# Monte Carlo Sample with On-Policy
31+
def monte_carlo_on_policy(episodes):
32+
...
33+
for i in range(0, episodes):
34+
# play接受一个策略，然后模拟生成一个完整的轨迹和奖励
35+
_, reward, player_trajectory = play(target_policy_player)
36+
...
37+
# 返回价值函数的平均值
38+
return states_usable_ace / states_usable_ace_count, states_no_usable_ace / states_no_usable_ace_count
39+
```
40+
2341
## 蒙特卡洛评估动作价值函数（Action Values）
2442

2543
- **注意**：如果我们的问题中，没有对环境建模，那么单纯评估状态价值函数是不够的。我们必须要评估动作价值函数。
26-
- **主体思想**：从评估state到评估state-action对。
27-
- **可能存在的问题**：某些state-action对可能不会被访问（稀疏性问题）。
44+
- **主体思想**：从评估**state**到评估**state-action对**。
45+
- **可能存在的问题**：某些state-action对可能不会被访问（**稀疏性问题**）。
2846

2947
## 蒙特卡洛控制
3048

@@ -36,7 +54,35 @@ $V(s)\leftarrow average(Return(s))$
3654

3755
- **Exploring Starts**：所有的state-action对都有可能被选为episode的开始（start）。
3856

39-
![](../res/mces.png)
57+
![mces](../res/mces.png)
58+
59+
核心代码：
60+
61+
```python
62+
# Monte Carlo with Exploring Starts
63+
def monte_carlo_es(episodes):
64+
...
65+
# behavior policy is greedy
66+
def behavior_policy(usable_ace, player_sum, dealer_card):
67+
...
68+
# get argmax of the average returns(s, a)
69+
values_ = state_action_values[player_sum, dealer_card, usable_ace, :] / \
70+
state_action_pair_count[player_sum, dealer_card, usable_ace, :]
71+
return np.random.choice([action_ for action_, value_ in enumerate(values_) if value_ == np.max(values_)])
72+
73+
# play for several episodes
74+
for episode in range(episodes):
75+
# for each episode, use a randomly initialized state and action
76+
initial_state = [bool(np.random.choice([0, 1])),
77+
np.random.choice(range(12, 22)),
78+
np.random.choice(range(1, 11))]
79+
initial_action = np.random.choice(ACTIONS)
80+
current_policy = behavior_policy if episode else target_policy_player
81+
_, reward, trajectory = play(current_policy, initial_state, initial_action)
82+
...
83+
84+
return state_action_values / state_action_pair_count
85+
```
4086

4187
## 不使用Exploring Starts
4288

@@ -47,7 +93,7 @@ $V(s)\leftarrow average(Return(s))$
4793

4894
- on-policy只有**一套policy**，更简单，是首选。
4995
- off-policy使用**两套policy**，更复杂、更难收敛；但也更通用、更强大。
50-
- on-policy和off-policy本质依然是Exploit vs Explore的权衡。
96+
- on-policy和off-policy**本质**依然是**Exploit vs Explore**的权衡。
5197

5298
## on-policy
5399

@@ -56,19 +102,19 @@ $V(s)\leftarrow average(Return(s))$
56102
## off-policy
57103

58104
- 所有的MC控制方法都面临一个**困境**：它们都想找到一个最优的策略，但却**必须采用非最优的策略去尽可能多地探索**（explore）数据。
59-
- 直接使用**两套策略**：采样用的policy称为`behavior policy`，最终的目标policy：`target policy`。这就是off-policy。
105+
- 直接使用**两套策略**：采样用的policy称为`behavior policy`，即**行为策略**；最终的目标policy：`target policy`，即**目标策略**。这就是off-policy。
60106
- 假设目标策略是$\pi$，行为策略是$b$，那么对于所有的$\pi(a|s)>0$必然有$b(a|s)>0$，这称为“覆盖”（coverage）。一个常见的例子是：行为策略使用价值函数的greedy policy，而目标策略使用ε-greedy policy。
61107

62108
## 重要性采样（importance sampling）
63109

64110
几乎所有的off-policy都使用**重要性采样（importance sampling）**。
65111

66-
为什么要使用重要性采样？我们希望在使用目标策略$\pi$的情况下用均值估计价值的期望，但我们获得的是在使用行为策略$b$的情况下的均值，也就是：$\mathbb{E}[G_t \mid S_t =s] = v_b(s)$。这二者是有差距的。因此我们希望使用重要性采样去纠正。
112+
**为什么要使用重要性采样**？我们希望在使用**目标策略**$\pi$的情况下用均值估计价值的期望，但我们获得的是在使用**行为策略**$b$的情况下的均值，也就是：$\mathbb{E}[G_t \mid S_t =s] = v_b(s)$。这二者是有差距的。因此我们希望**使用重要性采样去纠正**。
67113

68-
给定初始状态$S_t$，后续的状态-动作轨迹在使用策略$\pi$的情况下的概率为：
114+
给定初始状态$S_t$，后续的状态-动作轨迹在使用目标策略$\pi$的情况下的概率为：
69115
$Pr\{At,S_{t+1}, A_{t+1}, ... S_T \mid S_t, A_{t:T −1} \sim \pi\}$ $=\prod_{k=t}^{T-1}\pi(A_k\mid S_k)p(S_{k+1}\mid S_k, A_k)$
70116

71-
引入**重要性采样比例（the importancesampling ratio）**：
117+
引入**重要性采样比例（the importance sampling ratio）**：
72118
$\rho_{t:T −1}=\frac{\prod_{k=t}^{T-1}\pi(A_k\mid S_k)p(S_{k+1}\mid S_k, A_k)}{\prod_{k=t}^{T-1}b(A_k\mid S_k)p(S_{k+1}\mid S_k, A_k)}$ $=\prod_{k=t}^{T-1}\frac{\pi(A_k\mid S_k)}{b(A_k\mid S_k)}$
73119
上面这个式子正好巧妙地把MDP中未知的状态转移概率约掉。
74120

@@ -94,3 +140,44 @@ odinary importance sampling vs. weighted importance sampling:
94140
控制：
95141

96142
![off_policy_mc_control](../res/off_policy_mc_control.png)
143+
144+
核心代码：
145+
146+
```python
147+
# Monte Carlo Sample with Off-Policy
148+
def monte_carlo_off_policy(episodes):
149+
initial_state = [True, 13, 2]
150+
151+
rhos = []
152+
returns = []
153+
154+
for i in range(0, episodes):
155+
_, reward, player_trajectory = play(behavior_policy_player, initial_state=initial_state)
156+
157+
# get the importance ratio
158+
numerator = 1.0
159+
denominator = 1.0
160+
for (usable_ace, player_sum, dealer_card), action in player_trajectory:
161+
if action == target_policy_player(usable_ace, player_sum, dealer_card):
162+
denominator *= 0.5
163+
else:
164+
numerator = 0.0
165+
break
166+
rho = numerator / denominator
167+
rhos.append(rho)
168+
returns.append(reward)
169+
170+
rhos = np.asarray(rhos)
171+
returns = np.asarray(returns)
172+
weighted_returns = rhos * returns
173+
174+
weighted_returns = np.add.accumulate(weighted_returns)
175+
rhos = np.add.accumulate(rhos)
176+
177+
ordinary_sampling = weighted_returns / np.arange(1, episodes + 1)
178+
179+
with np.errstate(divide='ignore',invalid='ignore'):
180+
weighted_sampling = np.where(rhos != 0, weighted_returns / rhos, 0)
181+
182+
return ordinary_sampling, weighted_sampling
183+
```

‎notes/intro_note_06.md‎

Lines changed: 46 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -4,8 +4,8 @@
44

55
- 时序差分是强化学习的核心观点。
66
- 时序差分是DP和MC方法的结合。
7-
- 时序差分不需要像MC一样，要等一个完整的序列结束；相反，每经历一步，都会更新价值函数。
8-
- TD往往比MC高效
7+
- MC**要等一个完整的序列结束**，比如玩21点扑克，直到玩完才能知道是胜是负；相反，时序差分**每经历一步，都会更新价值函数**，因为每一步都会观察到一个新的Reward，比如Grid World，每走一步都知道reward是什么。
8+
- TD往往比MC高效；TD和MC都使用**经验**（experience）来解决预测问题。
99
- 所谓差分就是下一个时刻的估计和当前时刻的估计的差。
1010

1111
## 什么是stationary？
@@ -25,6 +25,21 @@ $V(S_t)\leftarrow V(S_t)+\alpha[R_{t+1}+\gamma V(S_{t+1})-V(S_t)]$
2525

2626
![td_0](../res/td_0.png)
2727

28+
```python
29+
def temporal_difference(values, alpha=0.1, batch=False):
30+
state = 3
31+
trajectory = [state]
32+
rewards = [0]
33+
while True:
34+
...
35+
# TD update
36+
if not batch:
37+
values[old_state] += alpha * (reward + values[state] - values[old_state])
38+
...
39+
rewards.append(reward)
40+
return trajectory, rewards
41+
```
42+
2843
## Sarsa
2944

3045
- 一种on-policy的TD控制。
@@ -34,6 +49,16 @@ $V(S_t)\leftarrow V(S_t)+\alpha[R_{t+1}+\gamma V(S_{t+1})-V(S_t)]$
3449

3550
![](../res/sarsa_backup.png)
3651

52+
核心代码：
53+
54+
```python
55+
# Sarsa update
56+
q_value[state[0], state[1], action] += \
57+
ALPHA * (REWARD + q_value[next_state[0], next_state[1], next_action] - q_value[state[0], state[1], action])
58+
state = next_state
59+
action = next_action
60+
```
61+
3762
## Q-learning
3863

3964
- 一种off-policy的TD控制。
@@ -44,14 +69,32 @@ $V(S_t)\leftarrow V(S_t)+\alpha[R_{t+1}+\gamma V(S_{t+1})-V(S_t)]$
4469

4570
![q_learn_backup](../res/q_learn_backup.png)
4671

72+
核心代码：
73+
74+
```python
75+
def q_learning(q_value, step_size=ALPHA):
76+
state = START
77+
rewards = 0.0
78+
while state != GOAL:
79+
action = choose_action(state, q_value)
80+
next_state, reward = step(state, action)
81+
rewards += reward
82+
# Q-Learning update
83+
q_value[state[0], state[1], action] += step_size * (
84+
reward + GAMMA * np.max(q_value[next_state[0], next_state[1], :]) -
85+
q_value[state[0], state[1], action])
86+
state = next_state
87+
return rewards
88+
```
89+
4790
## Expected Sarsa
4891

4992
- 一种off-policy的TD控制。
5093
- $Q(S_t,A_t)\leftarrow Q(S_t,A_t) + \alpha[R_{t+1} + \gamma\sum_a\pi(a|S_{t+1})Q(S_{t+1}, a)-Q(S_t,A_t)]$
5194

5295
## Double Learning
5396

54-
- 解决Q-learning的**最大化偏差（maximization bias）**问题
97+
- 解决Q-learning的**最大化偏差**（maximization bias）问题
5598
- 2011年提出。
5699

57100
![double_q_learn](../res/double_q_learn.png)

0 commit comments

Comments
 (0)