Giống như trong gradient descent hay gradient ascent, nếu bước đi quá nhỏ, mô hình sẽ học rất chậm; còn nếu bước đi quá lớn, nó có thể đi sai hướng và mất ổn định.

Natural policy gradients

Nói chung, ta muốn chính sách được cập nhật sao cho \(\underbrace{\text{hàm mục tiêu thì vừa tăng}}_{1}\), vừa đảm bảo \(\underbrace{\text{chính sách mới và cũ không quá khác biệt}}_{2}\).

1 - \(\mathcal{L}_{\theta}(\theta’)\)

Gọi \(\mathcal{L}_{\theta}(\theta')\) là hàm mục tiêu ước tính sự cải thiện trong phần thưởng kỳ vọng khi chuyển từ \(\pi_\theta\) sang \(\pi_{\theta’}\). Với \(A(s_t,a_t)\) là hàm lợi thế thì

2 - \(\mathcal{\bar{D}}_{KL}\)

Vấn đề ở bước đi quá nhỏ hay quá lớn là vì ta lấy đạo hàm bậc nhất, nó chỉ cho chúng ta biết nên bước theo hướng nào, nhưng không cho biết bước đi đó phải lớn bao nhiêu \(\Rightarrow\) Nếu đang ở một đường cong, đạo hàm bậc nhất đưa ta đi rất xa \(\Rightarrow\) Để khắc phục vấn đề đó, Natural policy gradients tính luôn đạo hàm bậc hai.

Để làm điều này, chúng ta tính toán sự khác biệt giữa chính sách trước và sau khi cập nhật, mà chính sách là phân phối xác suất, nên sự khác biệt này chính là KL-divergence. Như đã nói, ta không muốn bước cập nhật khiến cho chính sách trở nên quá khác biệt, nên ta giới hạn KL-divergence lại bằng \(\delta\).

Để giải quyết phương trình này, ta có thể sử dụng chuỗi Taylor để mở rộng cả hai hạng tử trên đến bậc hai.

Dưới đây ta quy ước \(f(x) \mid _{x_0}\) là \(f(x_0)\)

Bài toán trên trở thành

Giải phương trình trên, ta thu được

Về mặt tính toán, tính \(H\) đã khó, tính \(H^{-1}\) còn khó hơn, \(\mathcal{O}(n^3)\), nên người ta dùng Truncated Natural Policy Gradient để ước tính \(x = H^{-1}g\). Cụ thể hơn, ta giải phương trình \(Hx = g\) với thuật toán Conjugate Gradient.

Khi đó,

Tổng kết lại

Natural policy gradients chạy vòng lặp với \(k=0,1,\dots\):

1. Thu thập tập các quỹ đạo \(\mathcal{D}_k\) theo chính sách \(\pi_{\theta_k}\)
2. Ước lượng hàm lợi thế \(A_t^{\pi_{\theta_k}}\)
3. Tính các ước lượng mẫu cho \(g_k\)
4. Sử dụng Conjugate Gradient để tìm \(x_k \approx H_k^{-1} g_k\)
5. Cập nhật tham số chính sách \(\theta_{k+1} = \theta_k + \sqrt{\dfrac{2\delta}{x_k^T H_k x_k}} x_k\)

Trust Region Policy Optimization (TRPO)

Vấn đề là, do các sai số xấp xỉ được tạo ra bởi khai triển Taylor, điều này có thể không thỏa mãn được ràng buộc KL. TRPO thêm một sửa đổi vào quy tắc cập nhật này: line search.

Tức là, giảm dần kích thước của cập nhật theo từng bước cho đến khi tìm được cập nhật đầu tiên không vi phạm ràng buộc. Quy trình này có thể được xem như là thu nhỏ vùng tin cậy, tức là vùng mà trong đó chúng ta tin rằng cập nhật thực sự sẽ cải thiện mục tiêu.

Với thuật toán trên, ở bước tính \(\Delta_k = \sqrt{\dfrac{2\delta}{x_k^T H_k x_k}} x_k\). Để giảm dần vùng tin cậy, ta dùng một \(0 < \alpha < 1\). Với \(j = 0,1,\dots,L\)

1. Tính \(\theta = \theta_k + \alpha^j \Delta_k\)
2. Nếu \(\mathcal{L}_{\theta_k}(\theta) \ge 0\) và \(\mathcal{\bar{D}}_{KL}(\theta \mid \mid \theta_k) \le \delta\) thì dừng vòng lặp, chọn \(\theta_{k+1} = \theta_k + \alpha^j \Delta_k\).

Nhận xét

• TRPO rất nặng về toán và lý thuyết. Bài viết này cũng đã lượt bỏ khá nhiều phần chứng minh đằng sau các công thức.

• Tuy nhiên, chính điều đó đóng góp nền tảng lớn cho các phương pháp sau, tiêu biểu là Proximal Policy Optimization - PPO.

• Việc triển khai TRPO yêu cầu tính toán phức tạp và tốn kém về thời gian và tài nguyên. Các thuật toán yêu cầu việc tính toán Hessian và giải hệ phương trình tuyến tính với độ phức tạp tính toán cao, điều này khiến TRPO ít được áp dụng trong các bài toán quy mô lớn hoặc trong môi trường không có tài nguyên tính toán mạnh.

• Dựa trên chính sách (Policy-Based): như REINFORCE
• Dựa trên giá trị (Value-Based): như Q-learning, Deep Q-learning

Value-based có vài vấn đề, Policy-based giải quyết được vấn đề đó, nhưng lại gặp vấn đề khác về phương sai, vậy ta giải quyết như thế nào? Kết hợp chúng lại!

Hàm cơ sở - Baseline function

Trước hết, ta tìm hiểu một cách cơ bản để giảm phương sai: chèn một hàm cơ sở \(b\) vào trong kỳ vọng

Với \(R(\tau) = \sum_{t=0}^{T} \gamma^t r_t \) và chèn hàm cơ sở \(b\) vào, ta thu được

Hàm cơ sở không gây sai lệch (unbiased)

Ta có

Biểu thức này chứng minh rằng việc thêm một hàm cơ sở không gây sai lệch cho ước lượng đạo hàm, tức là không thay đổi giá trị kỳ vọng của biểu thức.

Hàm cơ sở làm giảm phương sai

Nhắc lại

Ta suy ra

Ta muốn tìm giá trị nhỏ nhất của phương sai này, nên ta tính

Giải phương trình

Vậy hàm cơ sở làm tối thiểu hóa phương sai chính là kỳ vọng của lợi nhuận trên các quỹ đạo được trọng số bởi độ lớn gradient. Tuy nhiên, chi phí tính toán độ lớn gradient lớn nên việc giảm phương sai không hiệu quả.

Do đó, người ta thường dùng một hàm cơ sở khác, là giá trị trạng thái.

Actor-Critic

Một cách khác để giảm phương sai là dùng Actor-Critic.

Ý tưởng chính là kết hợp hai mạng: Actor - học chính sách trực tiếp để quyết định hành động và Critic - đánh giá chất lượng hành động của Actor. Qua phản hồi từ Critic, Actor cải thiện chính sách. Cả hai mạng đều học song song, cải thiện lẫn nhau qua thời gian.

Rất giống với Generative Adversarial Network (GAN): Generator ra tạo ra các hình ảnh giả, còn discriminator đánh giá mức độ tốt của hình ảnh giả so với hình ảnh thực. Theo thời gian, generator có thể tạo ra những hình ảnh giả mà discriminator không thể phân biệt được.

Điều này giúp giảm phương sai và đồng thời tạo ra một chút độ lệch trong ước tính đạo hàm.

Các bước thực hiện của Actor-Critic là

1. Tại mỗi \(t\), đưa trạng thái hiện tại \(s_t\) làm đầu vào cho cả Actor và Critic.

2. Actor nhận trạng thái \(s_t\) và xuất ra một hành động \(a_t\)

3. Critic lấy trạng thái \(s_t\) và hành động \(a_t\) đấy làm đầu vào, tính giá trị của việc thực hiện hành động đó tại trạng thái đó \(\hat{q}_{\omega} (s_t, a_t)\).

   \(\Rightarrow\) Trạng thái mới \(s_{t+1}\) và một phần thưởng \(r_{t+1}\)

4. Cập nhật Actor theo công thức

   \[\theta \leftarrow \theta + \alpha \cdot \nabla_\theta \log \pi_\theta (a_t \mid s_t) \cdot \hat{q}_{\omega} (s_t, a_t)\]

5. Dựa trên tham số đã được cập nhật, Actor tạo ra hành động tiếp theo cần thực hiện \(a_{t+1}\) dựa trên trạng thái mới \(s_{t+1}\).

6. Cập nhật Critic dựa trên MSE và semi-gradient

   \[\omega \leftarrow \textcolor{lightgray}{\omega - \dfrac{\beta}{2} \cdot \nabla_\omega \left(r_{t+1} + \gamma \hat{q}_{\omega} (s_{t+1}, a_{t+1}) - \hat{q}_{\omega} (s_t, a_t) \right)^2}\] \[= \omega + \beta \cdot \left(r_{t+1} + \gamma \hat{q}_{\omega} (s_{t+1}, a_{t+1}) - \hat{q}_{\omega} (s_t, a_t) \right) \cdot \nabla_\omega \hat{q}_{\omega} (s_t, a_t)\]

Advantage Actor-Critic (A2C)

Ta có thể “nâng cấp” Actor-Critic để làm ổn định quá trình học, bằng cách dùng hàm lợi thế (Advantage function) làm Critic thay vì hàm giá trị hành động đơn giản. Hàm lợi thế này sẽ có dạng như baseline \(A(s_t,a_t) = R(\tau) - b(s_t)\)

Câu hỏi tiếp theo là, làm thế nào để ước tính lợi thế khi thực hiện một hành động cụ thể trong một trạng thái cụ thể.

• \(A(s_t,a_t) = Q(s_t,a_t) - V(s_t)\): Hàm lợi thế sẽ tính toán lợi thế tương đối của một hành động so với các hành động khác có thể thực hiện tại một trạng thái

• Tuy nhiên, cách trên yêu cầu tính hai hàm giá trị \(Q(s_t, a_t)\) và \(V(s_t)\). Do đó, ta dùng một cách khác, chỉ dùng một mạng \(\hat{V}_{\omega}(s_t)\) là \(A(s_t, a_t) = r_{t+1} + \gamma \hat{V}_{\omega}(s_{t+1}) - \hat{V}_{\omega}(s_t)\)

Các bước thực hiện cũng tương tự như Actor-Critic, chỉ có sự khác biệt về cách cập nhật tham số

và

Nhận xét

• Actor-Critic kết hợp policy-based và value-based để giải quyết các vấn đề của riêng chúng. Điều này cũng có nghĩa là nó cải thiện được hiệu quả mẫu (sample efficiency).

• Advantage Actor-Critic (A2C) là bản nâng cấp của Actor-Critic, giúp nó ổn định hơn. Do giảm phương sai và hiệu quả mẫu tốt hơn, A2C thường hội tụ đến chính sách tối ưu nhanh hơn REINFORCE.

• Hiển nhiên, Actor-Critic và A2C có độ phức tạp cao hơn so với các thuật toán đơn giản như REINFORCE.

Có thể thấy, việc tối ưu hóa hàm giá trị Q không trực tiếp tối ưu chính sách hành động (gọi là off-policy). Hơn nữa, đôi khi phần thưởng không xuất hiện liên tục, nên việc điều chỉnh giá trị Q trở nên rất khó khăn.

Và quan trọng nhất, chúng chỉ hoạt động tốt trong không gian hành động rời rạc.

Policy Gradient

Đầu tiên, ta tham số hóa một chính sách ngẫu nhiên (stochastic policy). Cũng có nghĩa là, một mạng nơ-ron đưa ra một phân phối xác suất các hành động. Vậy thì mục tiêu là: tìm các tham số \(\theta\) để điều chỉnh phân phối các hành động này sao cho hành động đem lại nhiều phần thưởng nhất thì có xác suất chọn cao nhất \(\rightarrow\) tối đa hóa phần thưởng mong đợi.

Ta tối ưu hóa chính sách trực tiếp nên gọi là on-policy.

Ý tưởng là: Trong một tập (episode), nếu thắng thì mỗi hành động đã thực hiện là tốt, tăng xác suất xảy ra của chúng; nếu thua thì mỗi hành động đã thực hiện là không tốt, giảm xác suất xảy ra của chúng.

Do đó, hàm phần thưởng hay hàm mục tiêu được viết như là: phần thưởng tích lũy kỳ vọng trên một quỹ đạo (trajectory - dãy trạng thái và hành động).

• \(P(\tau;\theta)\): Xác suất mỗi quỹ đạo có thể xảy ra (xác suất này phụ thuộc vào \(\theta\))

  Có thể hiểu rằng, nếu \(\theta\) thay đổi \(\rightarrow\) chính sách thay đổi \(\rightarrow\) cách tác nhân chọn hành động trong từng bước sẽ khác \(\rightarrow\) các trạng thái được ghé thăm sẽ khác \(\rightarrow\) các hành động được chọn tiếp theo cũng sẽ khác \(\rightarrow\) xác suất của quỹ đạo \(\tau\) cũng sẽ thay đổi.

  \[\textcolor{blue}{P(\tau;\theta)} = \mu(s_0) \prod_{t=0}^{T} P(s_{t+1} \mid s_t, a_t) \pi_\theta (a_t \mid s_t)\]

  trong đó \(\mu(s_0)\) là phân phối trạng thái ban đầu, \(\pi_\theta(a_t \mid s_t)\) là xác suất chính sách chọn hành động \(a_t\) từ trạng thái \(s_t\).

• \(R(\tau)\): Phần thưởng tích lũy từ một quỹ đạo bất kỳ.

  \[\textcolor{purple}{R(\tau)} = \sum_{t=0}^{T} \gamma^t r_t\]

Để tối đa hóa \(J(\theta)\) thì rất tự nhiên, ta dùng gradient ascent,

Tuy nhiên, có hai vấn đề khi tính đạo hàm của \(J(\theta)\):

1. Để đạo hàm, ta cũng cần biết đạo hàm của hàm phân phối trạng thái \(P(s_{t+1} \mid s_t, a_t)\), gọi là MDP dynamics. Điều này gắn liền với môi trường. Ta không lấy đạo hàm được vì ta có thể không biết về nó.

   Ở Policy Gradient, ta tối ưu hóa chính sách trực tiếp, nên không thể bỏ qua hàm phân phối trạng thái như Q-learning được.

   \(\Rightarrow\) Người ta chứng minh được rằng đạo hàm của hàm mục tiêu không liên quan đến đạo hàm của hàm phân phối trạng thái, gọi là Policy Gradient Theorem.

   \[\nabla_\theta J(\theta) = \mathbb{E}_{\tau \sim \pi_\theta} \left[\sum_{t=0}^T \left[ \textcolor{darkorange}{\nabla_\theta \log \pi_\theta (a_t \mid s_t) R(\tau)}\right]\right]\]

2. Không thể tính toán chính xác đạo hàm của hàm mục tiêu vì nó yêu cầu tính xác suất của mỗi quỹ đạo có thể xảy ra \(\rightarrow\) rất tốn kém về mặt tính toán.

   \(\Rightarrow\) Ta ước lượng đạo hàm bằng cách sử dụng một tập quỹ đạo \(\mathcal{D} = \{\tau\}_{i=1,2,\dots,N}\), gọi là phương pháp Monte-Carlo.

   \[\nabla_\theta J(\theta) \approx \dfrac{1}{N} \sum_{i=1}^{N} \sum_{t=0}^{T} \left[ \textcolor{darkorange}{\nabla_\theta \log \pi_\theta \left(a_t^{(i)} \mid s_t^{(i)}\right) R\left(\tau^{(i)}\right)} \right]\]

Đến đây, ta nhận thấy có một vấn đề khác: Môi trường có tính ngẫu nhiên (các hàm phân phối trạng thái \(P(s_{t+1} \mid s_t, a_t)\)) và chính sách cũng mang tính ngẫu nhiên \(\Rightarrow\) cùng một trạng thái bắt đầu có thể dẫn đến các giá trị phần thưởng rất khác nhau \(\Rightarrow\) phần thưởng bắt đầu từ cùng một trạng thái có thể thay đổi đáng kể giữa các tập (episode) \(\Rightarrow\) phương sai giữa các tập cao.

Giải pháp để giảm phương sai là sử dụng một số lượng lớn các quỹ đạo, tuy nhiên việc tăng kích thước (batch size) một cách đáng kể sẽ làm giảm hiệu quả sử dụng mẫu (sample efficiency).

Hiệu quả sử dụng mẫu có thể hiểu là mức độ hiệu quả mà một mô hình học được từ một số lượng mẫu (dữ liệu) nhất định.

Thuật toán REINFORCE

Kết hợp tất cả những thứ trên lại một cách đơn giản nhất, ta được thuật toán REINFORCE - là một dạng cụ thể của Policy Gradient.

1. Khởi tạo bộ tham số \(\theta\) bất kỳ

2. Sử dụng chính sách \(\pi_\theta\) để thu thập một tập (episode) \(\tau\).

3. Sử dụng tập này để ước tính gradient \(\nabla_\theta J(\theta)\).

4. Cập nhật trọng số của chính sách: \(\theta \leftarrow \theta + \alpha \cdot \nabla_\theta J(\theta)\)

Policy Gradient Theorem

Giờ ta quay lại chứng minh Policy Gradient Theorem nào!

Ta tiếp tục rút gọn \(\nabla_\theta \log \textcolor{blue}{P(\tau; \theta)}\).

Với \(\mu(s_0)\) là phân phối trạng thái ban đầu và \(P\left(s_{t+1}^{(i)} \mid s_{t}^{(i)}, a_{t}^{(i)}\right)\) là MDP dynamics của một quỹ đạo \(\tau^{(i)}\) nào đó,

Vậy

Nhận xét

• Policy gradient đã giải quyết được vấn đề về không gian hành động liên tục mà Q-learning hay Deep Q-learning không làm được.
• Policy gradient có thể học một chính sách ngẫu nhiên. Ta không cần phải thực hiện đánh đổi khám phá/khai thác. Vì ta có một phân phối xác suất trên các hành động, nên tác nhân khám phá không gian trạng thái mà không phải lúc nào cũng đi theo cùng một quỹ đạo.
• Tuy nhiên, Policy gradient rất hay hội tụ đến tối ưu cục bộ thay vì tối ưu toàn cục.
• Có thể mất nhiều thời gian hơn để huấn luyện Policy gradient.
• Có thể có phương sai cao.

Các giá trị trạng thái trong trò chơi CartPoleBalance là liên tục, thực ra là không phù hợp với Q-learning.

Deep Learning + Q-learning = Deep Q-learning ra đời để giải quyết vấn đề này!

Deep Q-learning

Deep Q-Learning sử dụng một mạng nơ-ron (Neural network) để ước tính các giá trị Q, giúp mô hình có thể xử lý được các không gian trạng thái phức tạp và liên tục mà không cần phải lưu trữ tất cả các giá trị Q. Những gì cần làm chỉ là bỏ đi bảng Q(s,a) và thay thế bằng một mạng thần kinh đơn giản.

Trong mạng nơ-ron thì hàm mất mát là vô cùng quan trọng! Tất nhiên, hàm mất mát phải tính được sai số giữa giá trị Q dự đoán và giá trị Q mục tiêu (Q-target). Vậy thì đơn giản thôi, kết hợp TD và MSE lại. Với \(Q(s,a;\theta)\) là mạng cần học, hàm mất mát chính là

Trong đó, \(\max_{a’} Q(s’, a’; \theta)\) là dự đoán về giá trị tối ưu cho hành động tiếp theo sau khi chuyển sang trạng thái mới (chính là Q-target).

Mặc dù \(Q(s’, a’; \theta)\) phụ thuộc vào \(\theta\), người ta coi đây là một giá trị hằng số khi tính hàm mất mát, tức là không có đạo hàm ở đại lượng này.

Đây gọi là semi-gradient. Có thể hiểu rằng, tính luôn đạo hàm cho \(Q(s’, a’; \theta)\) sẽ làm thay đổi chính mục tiêu mà ta đang cố gắng học theo. Điều này dẫn đến học không ổn định, vì mục tiêu luôn “di chuyển”.

Khi đó,

Experience Replay

Trong Deep Q-Learning, Experience Replay là một kỹ thuật thường được dùng giúp cải thiện sự ổn định của quá trình huấn luyện.

Tác dụng

• Tránh quên đi những trải nghiệm trước đây (hiện tượng catastrophic forgetting).

  Catastrophic forgetting: Vấn đề gặp phải nếu ta cung cấp các mẫu trải nghiệm tuần tự cho mạng nơ-ron thì mạng có xu hướng quên các kinh nghiệm trước đó khi có được các kinh nghiệm mới.

• Giảm mối tương quan giữa các trải nghiệm

Cách hiện thực

Ta dùng một bộ đệm (replay buffer) chứa các tuple (trạng thái, hành động, phần thưởng, trạng thái tiếp theo) để lưu các mẫu trải nghiệm mà ta có thể sử dụng lại trong quá trình huấn luyện. Bộ đệm này có giới hạn về kích thước. Khi bộ nhớ đầy, các trải nghiệm cũ nhất sẽ bị loại bỏ.

Trong mỗi bước huấn luyện, một nhóm trải nghiệm ngẫu nhiên (mini-batch) sẽ được lấy từ bộ nhớ để huấn luyện mô hình. Điều này giúp mô hình không học theo thứ tự các trải nghiệm, mà là từ một tập hợp các trải nghiệm đa dạng và không có sự phụ thuộc thời gian. Nếu tác nhân chỉ học từ các trải nghiệm liên tiếp, chúng có thể rất giống nhau và không cung cấp thông tin phong phú. Điều này cũng cho phép tác nhân học hỏi từ cùng một trải nghiệm nhiều lần.

Trong Q-learning, quá trình huấn luyện diễn ra theo các bước liên tiếp, nghĩa là mô hình học từ các trạng thái liên tiếp mà không có cơ chế lưu trữ hoặc trộn lẫn các trải nghiệm như Deep Q-learning.

Code

Code để dễ hình dung nhé!

class CartPoleEnv:
    def __init__(self):
        # Trạng thái: [x, x_velocity, theta, theta_velocity]
        # Hành động: 0 di chuyển sang trái, 1 di chuyển sang phải
        self.state = np.random.uniform(low=-0.05, high=0.05, size=(4,))
        self.g = 9.8
        self.m = 0.1
        self.M = 1.0
        self.L = 0.5
        self.dt = 0.02
        
    def step(self, action):
        # Hàm dùng để mô phỏng
        x, x_velocity, theta, theta_velocity = self.state
        
        force = 20.0 if action == 1 else -20.0
        
        cos_theta = np.cos(theta)
        sin_theta = np.sin(theta)
        total_mass = self.M + self.m
        pole_mass_length = self.m * self.L
        
        temp = (force + pole_mass_length * theta_velocity ** 2 * sin_theta) / total_mass
        theta_acc = (self.g * sin_theta - cos_theta * temp) / (self.L * (4 / 3 - self.m * cos_theta ** 2 / total_mass))
        x_acc = temp - pole_mass_length * theta_acc * cos_theta / total_mass
        
        x += x_velocity * self.dt
        x_velocity += x_acc * self.dt
        theta += theta_velocity * self.dt
        theta_velocity += theta_acc * self.dt
        
        lose = x < -2.4 or x > 2.4 or theta < -np.pi / 15 or theta > np.pi / 15
        reward = 1.0 if not lose else 0.0
        
        self.state = np.array([x, x_velocity, theta, theta_velocity])
        
        return self.state, reward, lose

    def reset(self):
        self.state = np.random.uniform(low=-0.05, high=0.05, size=(4,))
        return self.state

class DQN(nn.Module):
    def __init__(self, state_dim, action_dim):
        super(DQN, self).__init__()
        self.fc1 = nn.Linear(state_dim, 24)
        self.fc2 = nn.Linear(24, 24)
        self.fc3 = nn.Linear(24, action_dim)
        
    def forward(self, x):
        x = torch.relu(self.fc1(x))
        x = torch.relu(self.fc2(x))
        return self.fc3(x)

class DQNAgent:
    def __init__(self, state_dim, action_dim):
        self.state_dim = state_dim
        self.action_dim = action_dim
        self.memory = deque(maxlen=2000)
        self.gamma = 0.95
        self.epsilon = 1.0
        self.epsilon_min = 0.01
        self.epsilon_decay = 0.995
        self.batch_size = 32
        self.model = DQN(state_dim, action_dim)
        self.optimizer = optim.Adam(self.model.parameters(), lr=0.001)
        self.criterion = nn.MSELoss()
    
    def remember(self, state, action, reward, next_state, done):
        self.memory.append((state, action, reward, next_state, done))
    
    def act(self, state):
        if np.random.rand() <= self.epsilon:
            return random.randrange(self.action_dim)
        state = torch.FloatTensor(state).unsqueeze(0)
        with torch.no_grad():
            q_values = self.model(state)
        return torch.argmax(q_values).item()
    
    def replay(self):
        if len(self.memory) < self.batch_size:
            return
        minibatch = random.sample(self.memory, self.batch_size)
        for state, action, reward, next_state, done in minibatch:
            target = reward
            if not done:
                next_state = torch.FloatTensor(next_state).unsqueeze(0)
                target += self.gamma * torch.max(self.model(next_state)).item()
            state = torch.FloatTensor(state).unsqueeze(0)
            target_f = self.model(state).clone().detach()
            target_f[0][action] = target
            self.optimizer.zero_grad()
            output = self.model(state)
            loss = self.criterion(output, target_f)
            loss.backward()
            self.optimizer.step()
        if self.epsilon > self.epsilon_min:
            self.epsilon *= self.epsilon_decay

for e in range(episodes):
    state = env.reset()
    total_reward = 0
    for time in range(200):
        action = agent.act(state)
        next_state, reward, done = env.step(action)
        agent.remember(state, action, reward, next_state, done)
        state = next_state
        total_reward += reward
        if done: break
    agent.replay()
    if (e+1)%50 == 0: print(f"Episode {e+1}/{episodes}, Reward: {total_reward}, Epsilon: {agent.epsilon:.4f}")

def evaluate(agent, env, episodes=10):
    total_rewards = []
    for i in range(episodes):
        state = env.reset()
        total_reward = 0
        lose = False
        while not lose:
            action = agent.act(state)
            state, reward, lose = env.step(action)
            total_reward += reward
        print(f'Episode {i}: {total_reward}')

Fixed Q-Target

Trong hàm mất mát, mặc dù đã dùng semi-gradient, ta vẫn đang sử dụng cùng một tập tham số để ước lượng cả giá trị Q-Target lẫn giá trị Q. Do đó, tồn tại một mối tương quan nào đó giữa Q-Target và các tham số mà chúng ta đang thay đổi. Cho nên, ở mỗi bước huấn luyện, cả giá trị Q và Q-Target đều thay đổi.

Vì vậy, người ta thường

1. Sử dụng một mạng riêng biệt với các tham số cố định để ước lượng giá trị Q-target. Khi đó hàm mất mát thường được viết lại là \(L(\theta) = \left( r + \gamma \cdot \max_{a'} \hat{Q}(s', a'; \theta^{-}) - Q(s,a;\theta) \right)^2\)
2. Sao chép các tham số từ mạng Deep Q-Network sau mỗi \(C\) bước để cập nhật mạng này.

Nhận xét

• Với mạng nơ-ron, ta có thể xử lý đầu vào phức tạp hơn.

  Với hình ảnh, ta có thể áp dụng CNN

• Deep Q-Learning đã giải quyết phần nào được vấn đề của Q-learning là xử lý được trạng thái liên tục hoặc lượng trạng thái lớn. Tuy nhiên, hành động vẫn đang là rời rạc (như di chuyển trái phải), còn liên tục (như di chuyển sang trái bao nhiêu đơn vị) thì sao?

Khác với các phương pháp học có giám sát và không giám sát, học tăng cường không có tập dữ liệu đã được gán nhãn.

• Tác nhân (Agent): Là người đưa ra quyết định.

• Môi trường (Environment): Môi trường có thể thay đổi theo các hành động của tác nhân.

• Hành động (Action): Những hành động mà tác nhân có thể thực hiện để tương tác với môi trường.

• Trạng thái (State): Đại diện cho tình trạng hiện tại của môi trường tại một thời điểm cụ thể, bao gồm tất cả thông tin mà tác nhân cần để quyết định hành động tiếp theo.

• Phần thưởng (Reward): Mỗi hành động của tác nhân trong môi trường sẽ nhận một phần thưởng hoặc hình phạt.

• Chính sách (Policy): Chiến lược cho phép tác nhân chọn hành động ở mỗi trạng thái.

Ví dụ: Trong trò chơi CartPoleBalance, tác nhân là người điều khiển chiếc xe; môi trường là chiếc xe và cột; các hành động là di chuyển xe sang trái hoặc di chuyển xe sang phải; trạng thái bao gồm vị trí của xe, vận tốc của xe, góc của cột, vận tốc góc của cột; phần thưởng có thể được định nghĩa là +1 mỗi lần tác nhân giữ cột đứng trong một bước và +0 nếu cột ngã quá 15 độ.

Mục tiêu của học tăng cường là giúp tác nhân học được một chính sách tối ưu, tức là một chiến lược cho phép tác nhân chọn hành động tốt nhất ở mỗi trạng thái để tối đa hóa tổng phần thưởng tích lũy theo thời gian. Tức là

1. Tác nhân bắt đầu ở một trạng thái cụ thể.
2. Dựa trên trạng thái hiện tại, tác nhân chọn một hành động để thực hiện.
   • Khám phá (exploration): Tác nhân thử những hành động mới.
   • Khai thác (exploitation): Tác nhân tận dụng những hành động đã biết để đạt được phần thưởng cao nhất.
3. Môi trường thay đổi trạng thái theo hành động của tác nhân và trả về phần thưởng.
4. Tác nhân nhận phần thưởng và cập nhật chiến lược hành động của mình.

Q - learning

Một vấn đề quan trọng trong học tăng cường là cập nhật chiến lược như thế nào. Q-learning là một cách để giải quyết câu hỏi này.

• Q-value (Q-value table): Giá trị dự đoán của tác nhân về phần thưởng mà nó sẽ nhận được khi thực hiện một hành động trong một trạng thái cụ thể. Mỗi cặp trạng thái và hành động có một giá trị Q được lưu trong bảng.

Với bài toán CartPoleBalance trên, Q-table được viết như thế nào? Giả sử ta chia mỗi thành phần của trạng thái thành 6 khoảng, tổng số trạng thái rời rạc là 6 (vị trí xe) × 6 (vận tốc xe) × 6 (góc của cột) × 6 (vận tốc góc của cột) = 1296 trạng thái.

Nghĩa là, ví dụ khi gặp trạng thái (0,0,0,1), hành động được chọn là di chuyển sang phải bởi vì nó cho phần thưởng trung bình cao nhất.

Vậy cập nhật như thế nào để có các số như 0.01, 0.04,… trong bảng? Các giá trị ban đầu của Q-table thường được gán là 0 hoặc một giá trị ngẫu nhiên. Sau đó, công thức cập nhật Q-value là:

Trong đó:

• \(Q(s, a)\): Giá trị Q hiện tại của cặp trạng thái \(s\) và hành động \(a\).
• \(\alpha\): Tốc độ học (learning rate), giúp điều chỉnh mức độ cập nhật Q-value.
• \(r\): Phần thưởng nhận được sau khi thực hiện hành động \(a\) tại trạng thái \(s\).
• \(\gamma\): Hệ số chiết khấu (discount factor), dùng để điều chỉnh sự quan trọng của các phần thưởng trong tương lai.
• \(\max_{a’} Q(s’, a’)\): Giá trị Q tối đa của các hành động có thể thực hiện tại trạng thái tiếp theo \(s’\).

Trong học tăng cường, có hai khái niệm là khám phá (exploration) và khai thác (exploitation), là cách mà tác nhân chọn một hành động để thực hiện. Để chọn hành động, thuật toán sử dụng chính sách epsilon-greedy. Nghĩa là, với Q-learning, với xác suất \(1−\epsilon\), tác nhân chọn hành động có giá trị Q cao nhất (khai thác); với xác suất \(\epsilon\), tác nhân chọn hành động ngẫu nhiên (khám phá) để khám phá môi trường.

Tóm lại, để bắt đầu học tăng cường, khởi đầu từ một trạng thái \(\rightarrow\) ta mô phỏng môi trường và hành động của tác nhân \(\rightarrow\) cập nhật bảng Q \(\rightarrow\) tiếp tục mô phỏng và cập nhật cho đến khi kết thúc trò chơi, hoặc đến số bước nhất định.

Code

Code để dễ hình dung nhé!

class CartPoleEnv:
    def __init__(self):
        # Trạng thái: [x, x_velocity, theta, theta_velocity]
        # Hành động: 0 di chuyển sang trái, 1 di chuyển sang phải
        self.state = np.random.uniform(low=-0.05, high=0.05, size=(4,))
        self.g = 9.8
        self.m = 0.1
        self.M = 1.0
        self.L = 0.5
        self.dt = 0.02
        
    def step(self, action):
        # Hàm dùng để mô phỏng
        x, x_velocity, theta, theta_velocity = self.state
        
        force = 20.0 if action == 1 else -20.0
        
        cos_theta = np.cos(theta)
        sin_theta = np.sin(theta)
        total_mass = self.M + self.m
        pole_mass_length = self.m * self.L
        
        temp = (force + pole_mass_length * theta_velocity ** 2 * sin_theta) / total_mass
        theta_acc = (self.g * sin_theta - cos_theta * temp) / (self.L * (4 / 3 - self.m * cos_theta ** 2 / total_mass))
        x_acc = temp - pole_mass_length * theta_acc * cos_theta / total_mass
        
        x += x_velocity * self.dt
        x_velocity += x_acc * self.dt
        theta += theta_velocity * self.dt
        theta_velocity += theta_acc * self.dt
        
        lose = x < -2.4 or x > 2.4 or theta < -np.pi / 15 or theta > np.pi / 15
        reward = 1.0 if not lose else 0.0
        
        self.state = np.array([x, x_velocity, theta, theta_velocity])
        
        return self.state, reward, lose

    def reset(self):
        self.state = np.random.uniform(low=-0.05, high=0.05, size=(4,))
        return self.state
        
class QLearningAgent:
    def __init__(self, action_space, state_space, alpha=0.1, gamma=0.99, epsilon=0.1):
        self.action_space = action_space
        self.state_space = state_space
        self.alpha = alpha
        self.gamma = gamma
        self.epsilon = epsilon
        self.q_table = np.zeros(state_space + (action_space,))
        self.state_bins = [
            np.linspace(-2.4, 2.4, 10), # vị trí của xe
            np.linspace(-3.0, 3.0, 10), # vận tốc của xe
            np.linspace(-np.pi / 15, np.pi / 15, 10), # góc của cột
            np.linspace(-3.0, 3.0, 10), # vận tốc góc của cột
        ]

    def discretize_state(self, state):
        # Chia trạng thái (hiện là giá trị liên tục) thành các khoảng rời rạc
        discretized = []
        for i in range(len(state)):
            discretized.append(np.digitize(state[i], self.state_bins[i]) - 1)
        
        return tuple(discretized)

    def choose_action(self, state):
        if np.random.rand() < self.epsilon: # Khám phá
            return np.random.choice(self.action_space)
        else: # Khai thác
            return np.argmax(self.q_table[state])

    def update_q_table(self, state, action, reward, next_state):
        # Cập nhật theo công thức
        best_next_action = np.argmax(self.q_table[next_state])
        td_target = reward + self.gamma * self.q_table[next_state + (best_next_action,)]
        td_error = td_target - self.q_table[state + (action,)]
        self.q_table[state + (action,)] += self.alpha * td_error

def train(agent, env, episodes, max_timesteps=200):
    rewards = []
    for episode in range(episodes):
        state = env.reset()
        state = agent.discretize_state(state)
        total_reward = 0
        
        for t in range(max_timesteps):
            action = agent.choose_action(state)
            next_state, reward, lose = env.step(action)
            next_state = agent.discretize_state(next_state)
            
            agent.update_q_table(state, action, reward, next_state)
            
            state = next_state
            total_reward += reward
            
            if lose: break
        
        rewards.append(total_reward)
        if episode % 500 == 0 or episode == episodes-1:
            print(f"Episode {episode}, Total Reward: {total_reward}")
    
    return rewards

def evaluate(agent, env, episodes, is_render):
    for episode in range(episodes):
        state = env.reset()
        state = agent.discretize_state(state)
        lose = False
        total_reward = 0
        
        while not lose:
            # Với kiểm thử, chỉ dùng Khai thác chứ không dùng Khám phá
            action = np.argmax(agent.q_table[state])
            state, reward, lose = env.step(action)
            state = agent.discretize_state(state)
            total_reward += reward
            
            if is_render: render(env)
        
        print(f"Episode {episode}, Total Reward: {total_reward}")

Tại sao?

Ta đã biết công thức cập nhật của Q: lấy giá trị Q cũ, cộng thêm một phần nhỏ của chênh lệch giữa phần thưởng tương lai dự kiến và giá trị Q cũ. Nhưng tại sao người ta lại dùng công thức này?

Quy trình ra quyết định Markov (Markov Decision Process - MDP)

Trong trí tuệ nhân tạo, người ta dùng thuật ngữ Quy trình ra quyết định Markov (Markov Decision Process - MDP) để mô hình hóa các tình huống mà trong đó các quyết định được đưa ra liên tiếp và kết quả của các hành động là không chắc chắn.

Tính chất Markov là tính chất mà tức là tương lai chỉ phụ thuộc vào hiện tại, và không phụ thuộc vào quá khứ.

• \(S\): Tập trạng thái.
• \(A\): Tập hành động.
• \(P(s’ \mid s, a)\): Xác suất chuyển từ trạng thái \(s\) sang trạng thái \(s’\) khi thực hiện hành động \(a\).
• \(R(s, a)\): Phần thưởng nhận được khi thực hiện hành động \(a\) tại trạng thái \(s\).
• \(\gamma\): Hệ số chiết khấu.

Để giải được MDP, người ta thường dùng Quy hoạch động (Dynamic Programming - DP) dựa trên Phương trình Bellman.

Trong Q-learning, ta không cần phải biết mô hình môi trường (bao gồm các xác suất chuyển trạng thái \(P(s’ \mid s, a)\)) khi cập nhật Q-values. Thay vào đó, Q-learning chỉ cần quan sát trạng thái, hành động, phần thưởng và trạng thái tiếp theo trong quá trình tương tác với môi trường là được. Do đó, ta có thể “tạm quên đi” \(P(s’ \mid s, a)\).

Phương trình Bellman cho Giá trị Trạng thái (Value Function)

Phương trình Bellman cho giá trị trạng thái \(V(s)\) được viết như sau:

Phương trình Bellman cho Giá trị Hành động (Q-value Function)

Trong phương trình Bellman cho giá trị trạng thái, chúng ta quan tâm đến tất cả các trạng thái và tất cả các hành động khả thi. Vậy khi bỏ hàm \(\max\), chúng ta sẽ được công thức như là giá trị của một trạng thái được tạo ra cho chỉ một hành động khả thi.

Dựa trên ý tưởng đó, phương trình Bellman áp dụng cho giá trị hành động được viết như sau:

Để tạo nên sự đồng nhất, ta viết lại \(V(s’)\) bằng \(\max_{a’} Q(s’, a’)\) vì chúng ta coi giá trị của một trạng thái được tính bằng giá trị lớn nhất có thể của hành động \(Q(s, a)\).

Chênh lệch thời gian (Temporal Difference - TD)

Môi trường không phải bất biến, vậy phải làm như nào để nắm bắt được sự thay đổi của môi trường? Rất đơn giản, lấy giá trị Q mới trừ giá trị Q cũ!

Vậy

Sự hội tụ

Một điều đặc biệt, Q-learning là thuật toán đầu tiên được chứng minh hội tụ đến chính sách tối ưu (optimal policy) dưới một số điều kiện nhất định. Nó được đề xuất ban đầu bởi Watkins 1989 và được chứng minh hội tụ bởi Watkins & Dayan 1992.

Nói chung, phải đáp ứng hai điều kiện để đảm bảo sự hội tụ (chính sách sẽ trở nên gần với chính sách tối ưu một cách tùy ý sau một khoảng thời gian dài tùy ý):

• Tốc độ học phải tiến tới 0, nhưng không quá nhanh.

  Về mặt hình thức, điều này đòi hỏi tổng tỷ lệ học phải phân kỳ, nhưng tổng bình phương của chúng phải hội tụ.

  \[\sum_{t}^{\infty} \alpha_t = \infty \quad \quad\sum_{t}^{\infty} \alpha^2_t < \infty\]

  Ví dụ: 1/1, 1/2, 1/3, 1/4, ...

• Mỗi cặp trạng thái - hành động phải được truy cập vô hạn lần.

  Nghĩa là, về mặt toán học, mỗi hành động trong mọi trạng thái phải có xác suất được chính sách chọn > 0. Trong thực tế, sử dụng chính sách epsilon-greedy (\(\epsilon > 0\)) đảm bảo rằng điều kiện này được đáp ứng.

Dưới các điều kiện này, Q-learning sẽ hội tụ tới giá trị tối ưu trong thời gian vô hạn, nhưng trong thực tế, thường có một số yếu tố như độ chính xác của mô phỏng, việc dừng quá sớm, hoặc tốc độ học không phù hợp có thể ảnh hưởng đến quá trình hội tụ.

Nhận xét

• Về mặt lý thuyết, Q-Learning có thể hội tụ về giải pháp tối ưu nhưng thường không rõ ràng về cách điều chỉnh các siêu tham số như \(\epsilon\) và \(\alpha\).

• Khi số lượng trạng thái và hành động tăng lên, số lượng giá trị Q cần lưu trữ và cập nhật cũng tăng theo cấp số nhân, làm cho Q-learning gặp phải vấn đề về hiệu suất và bộ nhớ.

  Ví dụ trong bài toán CartPoleBalance, thật ra các yếu tố về góc hay vị trí là liên tục, nhưng để giảm bộ nhớ, ta đã chia giá trị liên tục thành rời rạc.

Hãy nhớ rằng Q-learning là một thuật toán cũ và hơi lỗi thời, đây là một cách cơ bản và sơ khai để tìm hiểu về học tăng cường, nhưng có những cách tốt hơn để giải quyết một vấn đề thực tế!