Giới thiệu dự án

Trong lĩnh vực trí tuệ nhân tạo hiện đại, bài toán điều khiển tối ưu (Optimal Control) trong các hệ thống động lực học phức tạp—từ robot tự hành, xe không người lái cho đến điều khiển nhân vật ảo (NPC) trong môi trường vật lý—đang đối mặt với rào cản lớn về tính bất định và độ phức tạp không gian trạng thái. Theo các khảo sát công nghiệp gần đây trong lĩnh vực tự động hóa và robotics, hơn 70% nỗ lực triển khai các thuật toán Học tăng cường sâu (Deep Reinforcement Learning - DRL) vào môi trường thực tế gặp trở ngại do tính kém ổn định, độ nhạy cảm quá cao với siêu tham số (hyperparameters), và hiện tượng rơi vào cực trị địa phương (local optima).

Vấn đề nghiên cứu và các điểm nghẽn kỹ thuật (Pain Points)

  1. Độ nhạy siêu tham số và tính bất ổn định của DRL: Các thuật toán policy gradient tiên tiến không gian hành động liên tục như TD3 (Twin Delayed Deep Deterministic Policy Gradient) và SAC (Soft Actor-Critic) phụ thuộc nặng nề vào việc khởi tạo trọng số mạng neural và cơ chế xấp xỉ gradient ngẫu nhiên. Khi môi trường có nhiều nhiễu (stochastic noise), gradient ước lượng từ Replay Buffer dễ bị chệch (overestimation bias), dẫn đến suy giảm chính sách đột ngột (catastrophic policy degradation).
  2. Kém hiệu quả mẫu của Tính toán tiến hóa thuần túy (Pure Evolutionary Computation - EC): Các phương pháp tối ưu hóa hộp đen như Cross-Entropy Method (CEM) hay Evolution Strategies (ES) có khả năng khám phá toàn cục và chống nhiễu vượt trội nhờ cơ chế quần thể (population-based). Tuy nhiên, do là phương pháp tối ưu bậc 0 (zeroth-order optimization), EC đòi hỏi hàng triệu tương tác môi trường (sample inefficiency) và gặp nghẽn bộ nhớ khi số chiều tham số mạng neural sâu lên đến hàng trăm nghìn trọng số $\mathcal{O}(d^2)$.
  3. Cơ chế lai ghép tĩnh trong các nghiên cứu ERL tiền nhiệm: Các kiến trúc ERL hiện hành như CEM-RL (Pourchot et al.) áp dụng một số lượng bước cập nhật gradient cố định cho các cá thể trong quần thể mà không đánh giá sự suy giảm hiệu năng tức thời, đồng thời lãng phí dữ liệu trải nghiệm thu thập từ các tập đánh giá.

Mục tiêu dự án

  1. Khảo sát & chuẩn hóa lý thuyết: Phân tích toàn diện nền tảng toán học của MDP (Markov Decision Process), Policy Gradient Theorem, DPG Theorem, Maximum Entropy RL và Estimation-of-Distribution Algorithms (EDA).
  2. Thiết kế cơ chế lai ghép thích ứng (Adaptive ERL Hybridization): Xây dựng cơ chế kiểm soát số bước cập nhật gradient động dựa trên ngưỡng cải thiện hiệu năng (early stopping baseline) và tận dụng triệt để bộ đệm kinh nghiệm $\mathcal{D}$.
  3. Hiện thực hóa 2 thuật toán đề xuất: Phát triển thuật toán eTD3 (enhanced CEM-TD3) và tiên phong kết hợp CEM với SAC tạo nên CEM-SAC.
  4. Kiểm nghiệm & Đánh giá thực nghiệm: Benchmark trên 6 tác vụ điều khiển liên tục chuẩn trong bộ công cụ vật lý MuJoCo (HalfCheetah-v3, Ant-v3, Walker2d-v3, Hopper-v3, Humanoid-v3, HumanoidStandup-v2) qua 10 lượt chạy độc lập (independent seeds).

Giải pháp kỹ thuật và kết quả kỳ vọng

Dự án đề xuất tích hợp giải thuật phân phối xác suất Gaussian đa biến đường chéo của CEM với các cập nhật gradient off-policy của TD3 và SAC. Bằng cách thiết lập bộ điều kiện dừng sớm (Early Termination) khi $f^{RL} > f^{CEM}$, thuật toán ngăn chặn cập nhật gradient quá mức (over-updating) và triệt tiêu độ lệch ước lượng giá trị $Q$. Kết quả kỳ vọng là gia tăng điểm số trung bình từ 15% đến 45% trên các môi trường phức tạp (như Humanoid-v3), giảm phương sai hiệu năng qua các lần chạy trên 50%, và duy trì tốc độ hội tụ nhanh.

Phạm vi và giới hạn

  • Phạm vi: Bài toán điều khiển chuyển động không gian hành động liên tục (Continuous Action Space), không sử dụng mô hình động lực học môi trường (Model-Free RL).
  • Giới hạn: Thử nghiệm trên môi trường giả lập vật lý chính xác MuJoCo Physics Engine; chưa tích hợp cơ chế Sim-to-Real trực tiếp lên phần cứng robot công nghiệp.

Phân tích và thiết kế giải pháp

Phân tích hiện trạng

Tiêu chí Pure DRL (TD3 / SAC) Pure EC (CEM / CMA-ES) Baseline ERL (CEM-RL / ESAC) Giải pháp đề xuất (eTD3 / CEM-SAC)
Hiệu quả mẫu (Sample Efficiency) Rất cao ($10^6$ steps) Rất thấp ($10^7 - 10^8$ steps) Trung bình Tối ưu hóa nhờ thu hoạch toàn bộ trajectory
Khả năng thoát cực tiểu địa phương Kém (Dễ bẫy local optima) Xuất sắc (Toàn cục) Khá tốt Xuất sắc (Nhờ phân phối Gaussian $\mathcal{N}(\mu, \Sigma)$)
Độ ổn định huấn luyện Thấp (Phương sai cao giữa các runs) Rất cao Trung bình Cực cao (Triệt tiêu hiện tượng sụt giảm điểm)
Cơ chế cập nhật Gradient Cố định trên mini-batch Không có (Bậc 0) Cố định số epoch Thích ứng (Adaptive stopping budget)
Tận dụng Replay Buffer Chỉ từ Actor chính Không sử dụng Chỉ từ cá thể đánh giá Toàn bộ trải nghiệm CEM & RL

Thiết kế hệ thống

Kiến trúc tổng thể của hệ thống lai ERL được xây dựng dưới dạng luồng dữ liệu hai chiều giữa bộ quản lý tiến hóa CEM và các mạng nơ-ron Actor-Critic:

Technology Stack

  • Ngôn ngữ lập trình: Python 3.8.10+
  • Deep Learning Framework: PyTorch 1.9.0 (CUDA 11.1)
  • Môi trường mô phỏng vật lý: MuJoCo 2.1.0 (mujoco-py 2.1.2.14)
  • Môi trường RL chuẩn: OpenAI Gym 0.21.0
  • Tính toán ma trận: NumPy 1.21.2, SciPy 1.7.1

Đặc tả toán học của mô hình

  1. Hàm mục tiêu Entropy cực đại (Soft Actor-Critic Objective): $$\pi^* = \arg\max_\pi \mathbb{E}{\tau \sim \pi} \left[ \sum{t=0}^\infty \gamma^t \left( r(s_t, a_t) + \alpha \mathcal{H}(\pi(\cdot|s_t)) \right) \right]$$
  2. Cập nhật Twin Critic Loss: $$L(\phi_i, \mathcal{D}) = \mathbb{E}{(s, a, r, s', d) \sim \mathcal{D}} \left[ \left( Q{\phi_i}(s, a) - y(r, s', d) \right)^2 \right], \quad i \in {1, 2}$$ $$y(r, s', d) = r + \gamma(1-d) \left( \min_{j=1,2} Q_{\phi_{j,\text{targ}}}(s', \tilde{a}') - \alpha \log \pi_\theta(\tilde{a}'|s') \right), \quad \tilde{a}' \sim \pi_\theta(\cdot|s')$$
  3. Cập nhật tham số phân phối CEM: $$\mu_{g+1} = \sum_{i=1}^{N_e} w_i \theta_{i:N}, \quad \Sigma_{g+1} = \sum_{i=1}^{N_e} w_i (\theta_{i:N} - \mu_g)(\theta_{i:N} - \mu_g)^T + \epsilon I$$ $$w_i = \frac{\ln(N_e + 1) - \ln(i)}{\sum_{j=1}^{N_e} (\ln(N_e + 1) - \ln(j))}$$

Methodology

Quy trình nghiên cứu áp dụng mô hình phân kỳ lặp (Iterative Agile Research Methodology) kéo dài 5 tháng (08/2021 - 12/2021):

  • Milestone 1 (Tháng 8 - 9/2021): Khảo sát lý thuyết ERL, tái lập môi trường MuJoCo và benchmark các giải thuật cơ sở (TD3, SAC, CEM-TD3).
  • Milestone 2 (Tháng 10 - 11/2021): Thiết kế giải thuật eTD3 với cơ chế dynamic loop, tích hợp CEM-SAC, tinh chỉnh cấu trúc bộ đệm $\mathcal{D}$.
  • Milestone 3 (Tháng 11 - 12/2021): Chạy thực nghiệm 10 seeds độc lập, phân tích thống kê T-test, viết báo cáo toàn văn khóa luận tốt nghiệp.

Implementation và kết quả

Development process & Core Algorithm Code

Hệ thống được module hóa thành các package độc lập: core/agents, core/distributions, core/buffers, và runners. Dưới đây là đoạn mã thực thi logic cốt lõi của giải thuật CEM-SAC:

import numpy as np
import torch
import copy

class CEM_SAC_Agent:
    def __init__(self, state_dim, action_dim, pop_size=10, elite_frac=0.5):
        self.pop_size = pop_size
        self.num_elites = int(pop_size * elite_frac)
        self.state_dim = state_dim
        self.action_dim = action_dim
        
        # Khởi tạo tham số phân phối Gaussian của CEM
        self.param_dim = self._calculate_actor_param_dim()
        self.mu = np.zeros(self.param_dim)
        self.sigma = np.ones(self.param_dim) * 1e-3
        self.epsilon_noise = 1e-4
        
        # Trọng số tính toán phân phối CEM
        weights = np.log(self.num_elites + 1) - np.log(np.arange(1, self.num_elites + 1))
        self.weights = weights / np.sum(weights)

    def train_generation(self, env, replay_buffer, sac_trainer, budget_per_actor=5):
        # 1. Lấy mẫu quần thể từ CEM: N(mu, Sigma)
        cem_actors = [self.sample_actor_params() for _ in range(self.pop_size // 2)]
        cem_fitness, rl_fitness = [], []
        rl_actors = []

        # 2. Đánh giá ban đầu các cá thể CEM & lưu buffer
        for params in cem_actors:
            fit, traj = self.evaluate(params, env)
            replay_buffer.add_trajectory(traj)
            cem_fitness.append(fit)

        # 3. Vòng lặp cập nhật RL thích ứng (Adaptive Early Stopping)
        for i, base_params in enumerate(cem_actors):
            current_params = copy.deepcopy(base_params)
            base_score = cem_fitness[i]
            best_score = base_score
            step_count = 0
            
            while step_count < budget_per_actor:
                # Cập nhật gradient SAC 1 episode
                update_step = 3 if replay_buffer.size > 0.1 * replay_buffer.capacity else 2
                current_params, train_traj = sac_trainer.train_one_episode(
                    current_params, replay_buffer, update_step=update_step
                )
                replay_buffer.add_trajectory(train_traj)
                
                # Đánh giá hiệu năng sau cập nhật
                eval_score, eval_traj = self.evaluate(current_params, env)
                replay_buffer.add_trajectory(eval_traj)
                step_count += 1
                
                if eval_score > base_score:
                    best_score = eval_score
                    break  # Dừng sớm nếu gradient cải thiện được policy ban đầu
                    
            rl_actors.append(current_params)
            rl_fitness.append(best_score)

        # 4. Hợp nhất quần thể và cập nhật CEM
        total_pop = cem_actors + rl_actors
        total_fit = np.array(cem_fitness + rl_fitness)
        elite_indices = np.argsort(total_fit)[::-1][:self.num_elites]
        
        # Cập nhật mean và covariance đa biến đường chéo
        old_mu = copy.deepcopy(self.mu)
        self.mu = np.sum([self.weights[idx] * total_pop[elite_indices[idx]] for idx in range(self.num_elites)], axis=0)
        self.sigma = np.sum([self.weights[idx] * ((total_pop[elite_indices[idx]] - old_mu) ** 2) 
                             for idx in range(self.num_elites)], axis=0) + self.epsilon_noise

Testing và validation

Quy trình đánh giá được thực hiện trên cụm máy chủ với vi xử lý Intel Core i9, GPU NVIDIA RTX 3090, 64GB RAM. Mỗi tác vụ được thực thi qua 10 runs độc lập, với ngân sách tương tác môi trường $1 \times 10^6$ steps (đối với các môi trường HalfCheetah, Hopper, Walker2d, Ant) và $2 \times 10^6$ steps đối với Humanoid.

Môi trường        Điểm số trung bình (Mean Cumulative Return ± Std Dev)
HalfCheetah-v3    CEM-SAC: 11,842 ± 320  ████████████████████████████ (Cao nhất)
                  CEM-TD3: 10,210 ± 640  ████████████████████
                  SAC:      9,850 ± 980  ██████████████████

Ant-v3            CEM-SAC:  5,890 ± 210  ████████████████████████████
                  CEM-TD3:  4,720 ± 450  ██████████████████
                  SAC:      4,310 ± 820  ███████████████

Humanoid-v3       CEM-SAC:  6,240 ± 380  ████████████████████████████
                  CEM-TD3:  5,110 ± 590  ████████████████████
                  SAC:      4,450 ± 1200 ██████████████

Kết quả đạt được

Môi trường Benchmark TD3 Baseline CEM-TD3 (Prior) eTD3 (Đề xuất) SAC Baseline CEM-SAC (Đề xuất) Mức tăng trưởng cao nhất (%)
HalfCheetah-v3 $9,630 \pm 850$ $10,210 \pm 640$ $10,890 \pm 410$ $9,850 \pm 980$ $11,842 \pm 320$ +20.2%
Hopper-v3 $3,350 \pm 420$ $3,560 \pm 310$ $3,680 \pm 190$ $3,420 \pm 390$ $3,790 \pm 140$ +10.8%
Walker2d-v3 $4,120 \pm 680$ $4,480 \pm 520$ $4,850 \pm 310$ $4,390 \pm 610$ $5,210 \pm 230$ +18.6%
Ant-v3 $4,180 \pm 790$ $4,720 \pm 450$ $5,120 \pm 280$ $4,310 \pm 820$ $5,890 \pm 210$ +36.6%
Humanoid-v3 $4,210 \pm 1150$ $5,110 \pm 590$ $5,430 \pm 410$ $4,450 \pm 1200$ $6,240 \pm 380$ +40.2%

Kiểm định thống kê Student's t-test giữa CEM-SAC và baseline thuần SAC trên môi trường Humanoid-v3 cho giá trị $p\text{-value} = 0.0021 < 0.01$, khẳng định sự vượt trội mang ý nghĩa thống kê rõ rệt, loại bỏ hoàn toàn yếu tố may rủi do khởi tạo ngẫu nhiên.

Đổi mới và đóng góp

  1. Cơ chế Dừng sớm Thích ứng (Adaptive RL Budgeting & Early Termination):
    • Bản chất: Thay vì ép buộc số bước cập nhật gradient cố định, thuật toán so sánh fitness $f^{RL}$ với ngưỡng khởi tạo $f^{CEM}$.
    • Bằng chứng: Triệt tiêu hiện tượng sụt giảm chính sách (performance collapse) thường gặp ở TD3/SAC khi gặp vùng không gian trạng thái có nhiễu cao.
  2. Khai thác dữ liệu bộ đệm đa nguồn (Full Experience Harvesting):
    • Bản chất: Lưu trữ toàn bộ các tương tác từ cả giai đoạn đánh giá cá thể CEM lẫn quá trình huấn luyện RL vào bộ đệm duy nhất $\mathcal{D}$.
    • Bằng chứng: Tăng mật độ mẫu hữu ích trong Replay Buffer lên 35%, cải thiện tốc độ hội tụ của Critic networks.
  3. Tiên phong kết hợp Phân phối CEM với Maximum Entropy DRL (CEM-SAC):
    • Bản chất: Lần đầu tiên tích hợp thành công mô hình ước lượng phân phối EDA (CEM) với cơ chế stochastic policy có điều hòa entropy của SAC.
    • Bằng chứng: Đạt điểm số kỷ lục $6,240 \pm 380$ trên môi trường Humanoid-v3 (vượt qua cả CEM-TD3 và ESAC).
  4. Lịch trình cập nhật Gradient động (Dynamic Update Scheduling):
    • Bản chất: Tăng hệ số $U$ từ 2 lên 3 bước gradient khi Replay Buffer đạt trên 10% sức chứa.
    • Bằng chứng: Giúp mạng Critic ổn định giá trị ước lượng hàm $Q$ trước khi Actor thực hiện các bước nhảy lớn trong không gian tham số.

Ứng dụng thực tế và triển khai

Tình huống ứng dụng công nghiệp

  • Điều khiển Robot sinh học (Legged / Bipedal Robotics): Ứng dụng điều khiển thăng bằng cho robot hai chân (Humanoid) và robot bốn chân trong điều kiện địa hình không bằng phẳng, chịu ngoại lực tác động ngẫu nhiên.
  • Hệ thống Xe tự hành (Autonomous Vehicles): Điều khiển góc lái và chân ga liên tục với độ phản hồi dưới $10\text{ms}$ khi di chuyển trong điều kiện trơn trượt hoặc mất ma sát đột ngột.
  • Hệ thống Tự động hóa Tòa nhà (Smart HVAC): Tối ưu hóa điều khiển van và lưu lượng gió liên tục nhằm giảm tiêu hao năng lượng trong khi vẫn đảm bảo tiện nghi nhiệt.

Hướng dẫn triển khai và Yêu cầu hệ thống

Quy trình cài đặt môi trường

# 1. Tạo môi trường ảo conda
conda create -n erl_control python=3.8 -y
conda activate erl_control

# 2. Cài đặt thư viện đồ họa và giả lập MuJoCo 2.1
sudo apt-get install -y libgl1-mesa-dev libgl1-mesa-glx libglew-dev libosmesa6-dev
pip install mujoco-py==2.1.2.14

# 3. Cài đặt PyTorch và các phụ thuộc
pip install torch==1.9.0+cu111 torchvision==0.10.0+cu111 -f https://download.pytorch.org/whl/torch_stable.html
pip install gym==0.21.0 scipy numpy matplotlib

Tối ưu hóa suy luận (Inference Deployment)

Sau khi hoàn tất huấn luyện, trọng số mạng Policy $\pi_\mu$ đại diện bởi vector trung bình $\mu$ của CEM được trích xuất và tối ưu hóa qua TorchScript/ONNX Runtime:

# Xuất mô hình phục vụ suy luận thời gian thực (Real-time latency < 2ms)
trained_actor = agent.get_mean_actor()
dummy_input = torch.randn(1, state_dim)
traced_model = torch.jit.trace(trained_actor, dummy_input)
traced_model.save("optimized_cem_sac_controller.pt")

Hạn chế và hướng phát triển

Hạn chế kỹ thuật hiện tại

  • Chi phí tính toán trong pha lấy mẫu: Việc đánh giá đồng thời $N/2$ cá thể trong mỗi thế hệ tạo áp lực tính toán lớn nếu không có hệ thống phân tán đa luồng (multi-processing/Ray).
  • Bộ nhớ Replay Buffer: Bộ đệm lưu trữ toàn bộ trajectory kích thước $10^6$ bước yêu cầu xấp xỉ 4-8 GB RAM cho các bài toán có chiều vector trạng thái lớn.
  • Giả định phân phối độc lập: Sử dụng ma trận hiệp phương sai đường chéo $\Sigma$ giúp giảm độ phức tạp từ $\mathcal{O}(d^2)$ xuống $\mathcal{O}(d)$ nhưng bỏ qua sự tương quan phụ thuộc giữa các trọng số trong cùng một lớp mạng nơ-ron.

Hướng phát triển trong tương lai

  • Tích hợp tính toán phân tán (Distributed Scalability): Mở rộng khung làm việc trên Ray/RLlib để song song hóa việc đánh giá hàng trăm cá thể trên cụm GPU Cluster.
  • Mô hình động lực học thế chỗ (Model-Based ERL): Tích hợp mạng World Models để tạo mẫu kinh nghiệm nhân tạo (imaginary rollouts), giảm thiểu 80% số lần tương tác vật lý thực tế.
  • Chuyển giao Sim-to-Real: Bổ sung cơ chế Domain Randomization vào môi trường giả lập để nạp trực tiếp controller lên phần cứng robot thực tế (như Unitree A1 / Boston Dynamics Spot).

Đối tượng hưởng lợi

  1. Sinh viên & Giảng viên ngành Khoa học Máy tính / AI: Tiếp cận tài liệu chuẩn mực về sự kết hợp giữa hai trường phái tính toán tiến hóa và học tăng cường; làm tài liệu tham khảo chất lượng cao cho các khóa luận chuyên sâu.
  2. Kỹ sư AI & Kỹ sư Robotics: Sở hữu bộ mã nguồn hoàn chỉnh, cấu trúc rõ ràng với các kỹ thuật tối ưu hóa Actor-Critic, giúp tiết kiệm hàng trăm giờ debug hiện tượng mất ổn định gradient.
  3. Doanh nghiệp Sản xuất & Tự động hóa: Thu nhận giải pháp điều khiển có tính ổn định cao, giảm thiểu rủi ro va đập hỏng hóc thiết bị phần cứng trong quá trình train-on-robot nhờ phương sai chính sách thấp.
  4. Cộng đồng Nghiên cứu Học máy (RL Researchers): Mở ra hướng nghiên cứu mới về việc kết hợp các giải thuật EDA tiên tiến (như CMA-ES, NES) với các biến thể DRL phân phối (Distributional RL / PPO).

Câu hỏi thường gặp

1. Cấu hình phần cứng tối thiểu để tái lập và huấn luyện mô hình là gì?

Hệ thống yêu cầu tối thiểu CPU 8 nhân (như Intel Core i7 Gen 10 hoặc AMD Ryzen 7), 16GB RAM và 01 card đồ họa NVIDIA GPU (tối thiểu 6GB VRAM như GTX 1660 Ti / RTX 2060). Để đạt tốc độ tối ưu trên môi trường phức tạp như Humanoid, khuyến nghị sử dụng GPU RTX 3080/3090 cùng RAM 32GB để hoàn thành 2 triệu steps trong khoảng 4-6 giờ.

2. Tại sao CEM-SAC lại vượt trội hơn hẳn so với SAC truyền thống trên môi trường Humanoid-v3?

Humanoid-v3 là môi trường có không gian trạng thái và hành động đa chiều (17 khớp nối liên tục), bề mặt hàm tối ưu chứa vô số điểm cực trị địa phương (như tư thế ngã hoặc co cụm). SAC truyền thống dễ bị mắc kẹt do gradient chỉ dẫn sai hướng khi bị nhiễu. CEM-SAC duy trì một quần thể phân phối Gaussian $\mathcal{N}(\mu, \Sigma)$ giúp rà quét không gian tham số trên diện rộng, kết hợp cùng cơ chế Maximum Entropy của SAC để liên tục kích thích khám phá trạng thái mới.

3. Làm thế nào để tích hợp thuật toán vào hệ thống điều khiển robot thực tế?

Sau khi huấn luyện thành công trong môi trường mô phỏng (đã áp dụng Domain Randomization cho ma sát và khối lượng), mạng Actor đại diện bởi vector trung bình $\mu$ của CEM được lưu lại. Sử dụng PyTorch C++ API (LibTorch) hoặc chuyển đổi sang ONNX để tích hợp vào hệ điều hành Robot (ROS/ROS2) với chu kỳ điều khiển vòng lặp kín (Closed-loop control cycle) tần số 100Hz - 500Hz.

4. Chi phí tính toán của việc cập nhật hiệp phương sai đường chéo trong CEM là bao nhiêu?

Việc sử dụng ma trận hiệp phương sai đường chéo $\Sigma = \text{diag}(\sigma_1^2, \dots, \sigma_d^2)$ giúp giảm độ phức tạp thời gian và không gian từ $\mathcal{O}(d^2)$ xuống tuyến tính $\mathcal{O}(d)$, trong đó $d$ là số lượng trọng số mạng nơ-ron (khoảng $5 \times 10^4$ đến $2 \times 10^5$ tham số). Thời gian cập nhật $\mu$ và $\Sigma$ cho mỗi thế hệ chỉ tốn dưới 0.05 giây trên CPU tiêu chuẩn.

5. Sự cố thường gặp nhất trong quá trình huấn luyện và cách khắc phục là gì?

  • Hiện tượng sụt giảm phần thưởng đột ngột: Nguyên nhân do giá trị $\alpha$ (entropy temperature) quá nhỏ hoặc ma trận hiệp phương sai $\Sigma$ suy biến về 0. Khắc phục bằng cách đặt chặn dưới cho ma trận hiệp phương sai với hằng số $\epsilon = 10^{-4}$ (line 11 trong Algorithm 3) và áp dụng cơ chế tự động điều chỉnh nhiệt độ entropy (Automatic Entropy Tuning) trong SAC.
  • Tràn bộ nhớ RAM: Khi chạy đa tiến trình môi trường MuJoCo, hãy đảm bảo đóng các render window và dọn dẹp các trajectory không còn sử dụng sau khi nạp vào Replay Buffer.

Kết luận

Khóa luận tốt nghiệp "Design and Application of Evolutionary Reinforcement Learning Methods for Continuous Control" của nhóm tác giả Nguyễn Trung Hiếu và Trần Đình Khang (dưới sự hướng dẫn của TS. Lương Ngọc Hoàng - Trường Đại học Công nghệ Thông tin, ĐHQG-HCM) đã giải quyết triệt để bài toán mất ổn định và rơi vào cực tiểu địa phương trong điều khiển liên tục. Thông qua việc đề xuất hai giải thuật đột phá eTD3 và CEM-SAC, công trình đã chứng minh tính khả thi và hiệu quả vượt bậc khi kết hợp giữa tối ưu hóa tiến hóa dựa trên phân phối (CEM) và học tăng cường actor-critic hiện đại. Với mức tăng trưởng hiệu năng lên tới 40.2% trên môi trường mô phỏng phức tạp Humanoid-v3 cùng sự suy giảm phương sai rõ rệt, nghiên cứu này đóng góp một nền tảng kỹ thuật vững chắc cho việc ứng dụng AI tự hành vào các hệ thống robotics và tự động hóa trong tương lai.