Reinforcement learning

Từ hành động tới một vòng tương tác

Ở thời điểm $t$, agent nhìn trạng thái $S_t$, chọn hành động $A_t$. Environment thực hiện hành động và trả về phần thưởng $R_{t+1}$ cùng trạng thái $S_{t+1}$. Chỉ số $t+1$ nhắc rằng phần thưởng là kết quả sau hành động; nó không phải nhãn đúng của hành động được đưa sẵn trước khi chọn.

Học từ thưởng qua tương tác như vậy là học tăng cường (reinforcement learning): chương trình tự chơi game, được cộng điểm khi thắng, hay hệ thống điều khiển đèn giao thông để xe chạy thông suốt.

Một policy, ký hiệu $\pi(a\mid s)$, cho xác suất chọn hành động $a$ khi ở trạng thái $s$. Policy có thể tất định, như luôn đi phải ở một ô; cũng có thể ngẫu nhiên, như đi phải với xác suất $0.7$. Phần thưởng nói mục tiêu cần đạt, còn policy nói cách thực hiện. Ta thường chưa biết hành động tốt nhất để đưa làm nhãn huấn luyện.

Muốn vị trí ô đủ mô tả trạng thái, kết quả bước tiếp theo chỉ được phụ thuộc vào vị trí và hành động hiện tại, không cần toàn bộ lịch sử. Đó là tính Markov.

Nếu robot còn pin và pin ảnh hưởng khả năng di chuyển, phải thêm mức pin vào trạng thái. Nếu nhiệm vụ bắt buộc kết thúc sau đúng 20 lượt, thời gian còn lại cũng có thể ảnh hưởng quyết định và phải được biểu diễn. Bỏ một biến cần thiết khiến cùng một “trạng thái” có hai cách diễn biến khác nhau.

Đặt một MDP đủ nhỏ để kiểm bằng tay

Markov decision process (MDP) gồm tập trạng thái $\mathcal S$, tập hành động $\mathcal A$, quy luật chuyển và thưởng $p(s',r\mid s,a)$, cùng hệ số chiết khấu $\gamma$. Ta dùng lưới 3 hàng, 4 cột; tọa độ viết (hàng, cột), bắt đầu từ 0 ở góc trên trái. Robot xuất phát ở $(2,0)$, đích ở $(0,3)$, ô $(1,1)$ bị chắn. Mỗi ô còn lại là một trạng thái, nên có 11 trạng thái.

Bốn hành động là lên, xuống, trái, phải. Va tường hoặc đi ra ngoài lưới thì giữ nguyên vị trí. Mỗi bước chưa vào đích nhận $-1$ điểm; bước vào đích nhận $10$ điểm và kết thúc episode, tức một lần thực hiện nhiệm vụ. Đích không còn hành động cần học.

Chuyển trạng thái ở đây tất định; xác suất của kết quả đúng bằng 1. Trong môi trường có trượt chân, cùng một hành động có thể dẫn tới nhiều kết quả và ta phải lấy kỳ vọng theo $p$.

Ta cài environment trước, rồi kiểm hai trường hợp dễ nhầm: va ô chắn và vào đích. Toàn bộ code trong bài chạy nối tiếp; chỉ cần NumPy.

import numpy as np

states = [(r, c) for r in range(3) for c in range(4) if (r, c) != (1, 1)]
state_id = {cell: i for i, cell in enumerate(states)}
start, goal = state_id[(2, 0)], state_id[(0, 3)]
moves = [(-1, 0), (1, 0), (0, -1), (0, 1)]
action_names = ["U", "D", "L", "R"]
gamma = 0.9

def step(state, action):
    assert state != goal, "Không bước tiếp sau khi đã tới đích."
    row, col = states[state]
    dr, dc = moves[action]
    next_cell = (row + dr, col + dc)
    next_state = state_id.get(next_cell, state)
    terminated = next_state == goal
    reward = 10.0 if terminated else -1.0
    return next_state, reward, terminated

wall_step = step(state_id[(1, 0)], 3)
goal_step = step(state_id[(0, 2)], 3)
assert wall_step == (state_id[(1, 0)], -1.0, False)
assert goal_step == (goal, 10.0, True)
print("Số trạng thái:", len(states))
print("Va ô chắn:", states[wall_step[0]], wall_step[1:])
print("Vào đích:", states[goal_step[0]], goal_step[1:])

Kết quảSố trạng thái: 11
Va ô chắn: (1, 0) (-1.0, False)
Vào đích: (0, 3) (10.0, True)

Dòng va ô chắn phải giữ vị trí cũ và vẫn trừ một điểm. Dòng vào đích phải có True; nếu quên điều kiện ấy, robot có thể tiếp tục thu thưởng hoặc bị phạt sau khi nhiệm vụ đã xong.

Vì sao nhìn thưởng một bước chưa đủ?

Một bước xa đích chỉ có thưởng $-1$, dù nó mở đường tới bàn trả sách. Ta cần đánh giá phần thưởng tương lai. Với episode kết thúc sau $T$ hành động, return từ thời điểm $t$ là

$\gamma=0.9$ làm một điểm ở bước kế tiếp chỉ còn giá trị $0.9$ khi nhìn từ hiện tại. Nó không phải xác suất thành công, cũng không phải learning rate. Với bài tiếp diễn vô hạn, thưởng bị chặn và $0\leq\gamma<1$ giúp tổng hội tụ; một episode hữu hạn có thể dùng $\gamma=1$ nếu mục tiêu là tổng thưởng không chiết khấu.

Đường 5 hành động trong hình có chuỗi thưởng $(-1,-1,-1,-1,10)$. Vì thưởng cuối đến sau bốn lần chiết khấu,

Tổng không chiết khấu là $6$. Hai số đo hai mục tiêu khác nhau, đều có đơn vị điểm thưởng. Đừng đọc 3.122 thành số bước.

rewards = np.array([-1, -1, -1, -1, 10], dtype=float)
return_hand = float(np.sum(rewards * gamma ** np.arange(len(rewards))))
print(f"Tổng thưởng: {rewards.sum():.3f}")
print(f"Return chiết khấu: {return_hand:.3f}")
assert np.isclose(return_hand, 3.122)

Kết quảTổng thưởng: 6.000
Return chiết khấu: 3.122

Phần thưởng và $\gamma$ cùng quyết định thế nào là “tốt nhất”. Ở lưới này, mỗi bước chưa tới đích bị trừ 1 nên đường dài mất thêm điểm; $\gamma<1$ còn làm thưởng 10 đến muộn có giá trị nhỏ hơn. Cả hai cơ chế đều đẩy robot đi đường ngắn. Ngược lại, cộng thưởng dương cho mỗi bước có thể khiến robot muốn kéo dài episode. Thiết kế thưởng là một phần của đề bài, không phải chi tiết cài đặt.

Bellman: tính việc xa bằng việc gần

$V^\pi(s)$ là kỳ vọng return khi bắt đầu ở $s$ và làm theo policy $\pi$. Còn $Q^\pi(s,a)$ là kỳ vọng khi bắt đầu bằng hành động $a$, sau đó làm theo $\pi$. Kỳ vọng cần thiết vì cả policy và environment có thể ngẫu nhiên. $V^*$ là giá trị tốt nhất có thể đạt.

Trong lưới tất định này, Bellman optimality viết thành

Với chuyển ngẫu nhiên, thay biểu thức trong ngoặc bằng $\sum_{s',r}p(s',r\mid s,a)[r+\gamma V^*(s')]$. Dấu max chọn hành động tốt nhất; dấu tổng tính kỳ vọng kết quả của một hành động. Hai thao tác có vai trò khác nhau.

Với một policy cố định, bỏ max và lấy trung bình theo chính policy đó:

Đây là hệ $|\mathcal S|$ phương trình tuyến tính với ẩn là các $V^\pi(s)$. Khi đồ thị có vòng, các ẩn phụ thuộc lẫn nhau, nên phải giải cả hệ hoặc lặp đến khi hội tụ.

Từ đích đi ngược: ô cách một bước có giá trị $10$; cách hai bước có $-1+0.9\cdot10=8$; cách ba bước có $6.2$, rồi $4.58$, rồi $3.122$. Giống dynamic programming, giá trị của bài toán lớn được viết qua bài toán nhỏ. Nhưng có vòng trong đồ thị nên không có thứ tự nào tính một lần là xong; ta lặp cập nhật trên mọi trạng thái, gọi là value iteration. Bắt đầu từ $V=0$, mỗi vòng đưa thông tin từ đích lùi thêm một bước.

Một vòng xét mọi trạng thái, mọi hành động và mọi trạng thái kế tiếp có thể: lưu $p$ thành bảng đầy đủ thì tốn $O(|\mathcal S|^2|\mathcal A|)$, còn lưới tất định chỉ có một trạng thái kế tiếp nên mỗi vòng là $O(|\mathcal S||\mathcal A|)$.

V = np.zeros(len(states))
for _ in range(200):
    old_V = V.copy()                # cập nhật đồng bộ từ vòng trước
    for state in range(len(states)):
        if state == goal:
            continue
        candidates = []
        for action in range(4):
            next_state, reward, terminated = step(state, action)
            future = 0.0 if terminated else old_V[next_state]
            candidates.append(reward + gamma * future)
        V[state] = max(candidates)
    if np.max(np.abs(V - old_V)) < 1e-12:
        break

print(f"Value iteration tại S: {V[start]:.3f}")
print(f"Giá trị terminal: {V[goal]:.3f}")
assert np.isclose(V[start], return_hand)

Kết quảValue iteration tại S: 3.122
Giá trị terminal: 0.000

Value iteration gọi step cho mọi cặp trạng thái–hành động tùy ý, tức dùng mô hình của environment: đây là planning với mô hình đã biết, chưa phải học từ trải nghiệm robot tự thu được. Đáp án $V^*$ của nó là mốc để kiểm phần học tiếp theo. Khi biết bản đồ và chỉ cần đường ngắn nhất, dùng BFS trực tiếp thường hợp lý hơn huấn luyện một agent.

Q-learning: cập nhật từ một trải nghiệm

Bây giờ agent chỉ gọi step cho hành động đã chọn. Nó lưu bảng $Q(s,a)$ shape (11, 4); mỗi hàng là một ô, mỗi cột là một hành động. Sau quan sát $(s,a,r,s')$, target là $r+\gamma\max_{a'}Q(s',a')$. Sai lệch giữa target và giá trị hiện tại gọi là TD error (sai lệch thời gian). Ta cập nhật

$\alpha$ là learning rate. Viết cách khác, $Q(s,a)\leftarrow(1-\alpha)Q(s,a)+\alpha\cdot\text{target}$: $\alpha=1$ ghi đè bằng target mới nhất, $\alpha$ nhỏ giữ lại phần lớn giá trị cũ và lấy trung bình có trọng số các target đã gặp. Nếu bước vừa đi kết thúc episode (terminal), target chỉ còn $r$.

Ví dụ $Q(s,a)=2$, $r=-1$, giá trị tốt nhất ở trạng thái kế tiếp là 5, $\gamma=0.9$, $\alpha=0.2$: target là $3.5$, TD error là $1.5$, giá trị mới là $2.3$. Nếu đó là bước terminal thưởng 10 thì giá trị mới là $2+0.2(10-2)=3.6$.

Policy lấy hành động có $Q$ lớn nhất có thể bỏ lỡ hướng chưa thử. Ta dùng epsilon-greedy: xác suất $\epsilon$ chọn đều trong cả bốn hành động, còn lại chọn một hành động đạt cực đại. Hành động tốt nhất cũng có thể được chọn trong nhánh ngẫu nhiên.

Việc thử hướng mới này gọi là khám phá (exploration), để thu thông tin về environment. Nó khác với tìm kiếm (search) ở bài 9.2, nơi trạng thái được mở rộng bằng quy tắc đã biết.

def td_target(reward, next_values, terminated):
    if terminated:
        return reward
    return reward + gamma * np.max(next_values)

assert np.isclose(td_target(-1.0, np.array([5.0, 2.0]), False), 3.5)
# Giá trị cố ý sai ở terminal cũng không được lọt vào target.
assert td_target(10.0, np.full(4, 999.0), True) == 10.0

rng = np.random.default_rng(7)
Q = np.zeros((len(states), 4))
alpha, epsilon = 0.3, 0.2
for episode in range(3000):
    state = start
    for turn in range(100):
        if rng.random() < epsilon:
            action = int(rng.integers(4))
        else:
            best = np.flatnonzero(Q[state] == Q[state].max())
            action = int(rng.choice(best))
        next_state, reward, terminated = step(state, action)
        target = td_target(reward, Q[next_state], terminated)
        Q[state, action] += alpha * (target - Q[state, action])
        state = next_state
        if terminated:
            break

print("Shape bảng Q:", Q.shape)
print(f"Q tốt nhất tại S: {Q[start].max():.3f}")
assert np.all(Q[goal] == 0)

Kết quảShape bảng Q: (11, 4)
Q tốt nhất tại S: 3.122

Giới hạn 100 lượt trong code là dừng thu mẫu để chương trình luôn chạy nhanh, không phải terminal của MDP. Ở lượt bị dừng ấy, ta vẫn dùng target có giá trị tương lai, rồi reset để thu một episode mới. Gymnasium trả riêng hai cờ terminated và truncated; chỉ terminal thật làm mất bootstrap.

Mỗi cập nhật chỉ nhìn trước một bước, nên tin tốt ở đích lan ngược về S chậm. Với $\alpha=1$ và $Q$ khởi tạo 0, trong episode đầu tiên tới đích chỉ cặp trạng thái–hành động cuối cùng nhận target có thưởng 10; các cặp trước đó đã được cập nhật khi giá trị phía sau còn bằng 0. Mỗi lần đi lại cùng đường, thông tin lùi thêm một bước.

Experience replay lưu các transition đã gặp vào bộ nhớ rồi cập nhật lại nhiều lần, nhờ đó dùng mỗi lần tương tác hiệu quả hơn; đây cũng là một thành phần của DQN, Q-learning với mạng neural.

Đọc policy, không chỉ đọc một ô Q

Con số ở S gần đáp án chuẩn chưa chứng minh robot đi được. Ta tắt exploration, chạy policy greedy và in cả đường đi. Evaluation không cập nhật $Q$; tránh việc kiểm tra cũng làm thay đổi agent.

state = start
path = [states[state]]
actions_taken, observed_rewards = [], []
for _ in range(30):
    action = int(np.argmax(Q[state]))
    state, reward, terminated = step(state, action)
    actions_taken.append(action_names[action])
    observed_rewards.append(reward)
    path.append(states[state])
    if terminated:
        break

discounted = sum(gamma ** t * r for t, r in enumerate(observed_rewards))
print("Hành động:", " ".join(actions_taken))
print("Đường đi:", path)
print(
    f"Số bước: {len(actions_taken)}, "
    f"return: {discounted:.3f}"
)
assert state == goal and len(actions_taken) == 5
assert np.isclose(discounted, V[start])

Kết quảHành động: R R U U R
Đường đi: [(2, 0), (2, 1), (2, 2), (1, 2), (0, 2), (0, 3)]
Số bước: 5, return: 3.122

Nhìn Số bước trước: đường ngắn nhất từ S dài 5 bước (đếm trên hình hoặc bằng BFS), nên từ S agent đã đạt mức tối ưu. Lưới có nhiều đường ngắn nhất, vì vậy chuỗi hành động có thể khác mũi tên trong hình mà return vẫn là 3.122. Một đường đi chỉ kiểm policy tại S; muốn kiểm cả policy, chạy evaluation từ mọi ô và so với $V^*$ của value iteration.

Định lý hội tụ của Q-learning dạng bảng cần mọi cặp trạng thái–hành động được thử vô số lần và learning rate giảm dần thích hợp. Ở lưới tất định của bài, $\alpha=0.3$ cố định đã cho đúng kết quả; khi chuyển trạng thái ngẫu nhiên, $\alpha$ cố định khiến $Q$ luôn dao động theo các mẫu gần nhất.

SARSA, Monte Carlo và TD

Target của Q-learning lấy $\max_{a'}Q(s',a')$, giá trị của hành động tốt nhất ở $s'$, dù lúc chạy epsilon-greedy có thể chọn hành động khác. Agent hành động theo một policy (epsilon-greedy) nhưng học giá trị của một policy khác (greedy). Kiểu học này gọi là off-policy.

SARSA chọn trước hành động kế tiếp $a'$ bằng chính policy đang chạy, rồi đưa nó vào target:

Tên gọi lấy từ năm thứ cần cho một lần cập nhật: $s, a, r, s', a'$. Target dùng hành động thật sự được chọn, kể cả bước khám phá, nên SARSA học giá trị của chính policy đang chạy. Kiểu học này gọi là on-policy.

Ví dụ: $r = 1$, ở $s'$ hai hành động có $Q$ là 6 và 2, policy chọn hành động có $Q = 2$, $\gamma = 0.5$. Target của Q-learning là $1 + 0.5\cdot 6 = 4$, của SARSA là $1 + 0.5\cdot 2 = 2$.

Khác biệt hiện rõ trên lưới vách đá (cliff walking): 4 hàng, 12 cột, xuất phát ở góc dưới trái, đích ở góc dưới phải, mười ô giữa hàng dưới là vách. Mỗi bước nhận $-1$; bước vào vách nhận $-100$ và bị đưa về ô xuất phát. Cả hai thuật toán học 500 episode với $\epsilon = 0.1$, $\alpha = 0.1$, $\gamma = 1$, cùng seed.

CLIFF_ROWS, CLIFF_COLS = 4, 12
CLIFF_START, CLIFF_GOAL = (3, 0), (3, 11)
CLIFF = {(3, c) for c in range(1, 11)}

def cliff_step(cell, action):
    r, c = cell
    dr, dc = moves[action]
    nxt = (min(max(r + dr, 0), CLIFF_ROWS - 1), min(max(c + dc, 0), CLIFF_COLS - 1))
    if nxt in CLIFF:
        return CLIFF_START, -100.0, False
    return nxt, -1.0, nxt == CLIFF_GOAL

def egreedy(values, gen, eps):
    if gen.random() < eps:
        return int(gen.integers(4))
    return int(gen.choice(np.flatnonzero(values == values.max())))

def train_cliff(method, episodes=500, alpha=0.1, eps=0.1, seed=0):
    gen = np.random.default_rng(seed)
    Qc = np.zeros((CLIFF_ROWS, CLIFF_COLS, 4))
    returns = []
    for _ in range(episodes):
        cell, total = CLIFF_START, 0.0
        action = egreedy(Qc[cell], gen, eps)
        for _ in range(500):
            nxt, reward, done = cliff_step(cell, action)
            total += reward
            next_action = egreedy(Qc[nxt], gen, eps)
            if done:
                target = reward
            elif method == "SARSA":
                target = reward + Qc[nxt][next_action]   # hành động sẽ làm thật
            else:
                target = reward + Qc[nxt].max()          # hành động tốt nhất
            Qc[cell][action] += alpha * (target - Qc[cell][action])
            cell, action = nxt, next_action
            if done:
                break
        returns.append(total)
    return Qc, returns

def cliff_greedy(Qc):
    cell, path = CLIFF_START, [CLIFF_START]
    for _ in range(60):
        cell, _, done = cliff_step(cell, int(np.argmax(Qc[cell])))
        path.append(cell)
        if done:
            break
    return path

for method in ["Q-learning", "SARSA"]:
    Qc, returns = train_cliff(method)
    path = cliff_greedy(Qc)
    rows_used = sorted({r for r, _ in path[1:-1]})
    print(f"{method:10s} greedy {len(path) - 1} bước, qua hàng {rows_used}; "
          f"return lúc học (100 episode cuối): {np.mean(returns[-100:]):.1f}")

Kết quảQ-learning greedy 13 bước, qua hàng [2]; return lúc học (100 episode cuối): -64.8
SARSA      greedy 15 bước, qua hàng [1, 2]; return lúc học (100 episode cuối): -25.1

Q-learning học đường ngắn nhất, 13 bước, sát ngay trên vách. Đó là đường tốt nhất cho policy greedy. Nhưng lúc học, cứ khoảng 10 bước lại có một bước ngẫu nhiên, và đứng sát vách thì một bước xuống là mất 100 điểm: return trung bình khi học chỉ $-64.8$. SARSA tính cả những bước ngẫu nhiên ấy vào giá trị, nên học đường cách vách thêm một hàng, dài 15 bước, và khi học đạt $-25.1$.

Cần điểm tốt ngay trong lúc còn khám phá, như robot thật không được phép ngã, thì chọn SARSA. Chỉ cần policy greedy cuối cùng tốt nhất thì Q-learning cho đường ngắn hơn. Khi $\epsilon$ giảm dần về 0, cả hai cùng tiến về đường tối ưu.

Q-learning và SARSA đều cập nhật ngay sau một bước, dựa vào giá trị đang ước lượng ở bước kế (bootstrapping). Đó là học temporal difference (TD). Dạng TD cho $V$ là

Monte Carlo làm khác: chạy hết episode, tính return thật $G_t$ cho từng trạng thái đã đi qua, rồi lấy trung bình các $G_t$ của mỗi trạng thái làm $V(s)$. Nó không dựa vào ước lượng nào, nên giá trị khởi tạo sai không làm lệch kết quả. Đổi lại, nó phải chờ episode kết thúc, và $G_t$ cộng nhiều bước ngẫu nhiên nên dao động mạnh. TD cập nhật được ngay, dùng được cả cho bài không có điểm kết thúc, nhưng target phụ thuộc vào chính giá trị đang học.

Policy gradient: học trực tiếp xác suất hành động

Q-learning học bảng giá trị rồi suy ra policy. Một cách khác là đặt tham số cho policy và tăng kỳ vọng return. Để thấy đúng phép toán, ta tạm dùng nhiệm vụ một bước: chọn trái nhận 1 điểm, chọn phải nhận 3 điểm, rồi episode kết thúc. Đây là một bandit, trường hợp đơn giản nhất của tương tác có thưởng; nó không minh họa khó khăn gán công lao qua nhiều bước.

Đặt xác suất đi phải $p=\sigma(\theta)=1/(1+e^{-\theta})$. Kỳ vọng thưởng là $J(\theta)=1(1-p)+3p=1+2p$. Do $\sigma'(\theta)=p(1-p)$,

Tại $\theta=0$, $p=0.5$, gradient bằng $0.5$. Gradient ascent với $\eta=0.1$ cho $\theta=0.05$, tăng xác suất phải lên khoảng $0.5125$. Dấu cộng khác với gradient descent của loss vì ta muốn tăng thưởng.

Nếu chưa biết thưởng của cả hai hướng, một mẫu REINFORCE dùng $(R-b)\nabla_\theta\log\pi_\theta(A)$ để ước lượng gradient. $b$ là baseline không phụ thuộc vào hành động đang chọn.

Với $A\in\{0,1\}$ và xác suất phải là $p$, đạo hàm log-policy là $A-p$. Lấy $b=2$: chọn phải cho $(3-2)(1-p)$; chọn trái cho $(1-2)(-p)$. Kỳ vọng hai trường hợp đúng bằng $2p(1-p)$.

Ta kiểm tính tay trước, rồi dùng 400 mẫu để cập nhật policy.

def sigmoid(theta):
    return 1.0 / (1.0 + np.exp(-theta))

p0 = sigmoid(0.0)
theta_hand = 0.1 * 2 * p0 * (1 - p0)
print(f"Một bước exact gradient: theta={theta_hand:.4f}, p={sigmoid(theta_hand):.4f}")

rng_policy = np.random.default_rng(11)
theta_policy = 0.0
for _ in range(400):
    probability = sigmoid(theta_policy)
    action = int(rng_policy.random() < probability)
    reward = 3.0 if action else 1.0
    sample_gradient = (reward - 2.0) * (action - probability)
    theta_policy += 0.05 * sample_gradient

p_final = sigmoid(theta_policy)
print(f"Policy sau 400 mẫu: p(phải)={p_final:.4f}, E[R]={1 + 2 * p_final:.4f}")
assert p_final > 0.9

Kết quảMột bước exact gradient: theta=0.0500, p=0.5125
Policy sau 400 mẫu: p(phải)=0.9641, E[R]=2.9282

E[R] ở dòng cuối tính bằng công thức $1+2p$ của bài toán, không phải trung bình các thưởng đã nhận khi huấn luyện. Sau 400 mẫu, $p$ mới tới khoảng $0.96$ vì kỳ vọng gradient $2p(1-p)$ nhỏ dần khi $p$ gần 1: policy càng chắc chắn thì càng học chậm.

Trong môi trường lớn, policy là một mạng neural nhận trạng thái và trả xác suất hành động; ít tham số hơn một bảng khổng lồ, nhưng không còn đáp án chính xác để đối chiếu.

Với episode nhiều bước, mỗi thời điểm $t$ dùng return tính từ chính thời điểm đó:

Hành động ở bước $t$ không ảnh hưởng tới các thưởng đã nhận trước nó, nên dùng $G_t$ thay cho tổng thưởng cả episode.

Baseline không làm lệch kỳ vọng, vì $\mathbb E_{A\sim\pi_\theta}[\nabla_\theta\log\pi_\theta(A\mid s)]=\nabla_\theta\sum_a\pi_\theta(a\mid s)=0$, nhưng làm các mẫu bớt dao động; lựa chọn thường gặp là một ước lượng của $V(S_t)$.

Nếu thay $G_t$ bằng $R_{t+1}+\gamma V_\phi(S_{t+1})$, với $V_\phi$ do một mạng thứ hai học, ta được actor-critic: actor là policy, critic là hàm giá trị.