Reinforcement Learning cho Bipedal Walking: Paper đến thực hành

Tại sao Reinforcement Learning thay đổi cuộc chơi bipedal walking?

Reinforcement Learning (RL) cho bipedal walking đang trở thành phương pháp chủ đạo để dạy robot hình người đi lại tự nhiên. Nếu bạn từng xem video Unitree H1 chạy tốc độ 3.3 m/s hay robot Berkeley Humanoid leo dốc ở San Francisco, tất cả đều được huấn luyện bằng RL -- không phải lập trình tay từng bước chân.

Nhưng tại sao RL lại vượt trội so với các phương pháp truyền thống? Và làm sao để đi từ paper nghiên cứu đến robot thật đang đi trên mặt đất? Bài viết này sẽ đi sâu vào toàn bộ pipeline -- từ MDP formulation, reward shaping, huấn luyện trong simulation, đến sim-to-real transfer.

ZMP vs Reinforcement Learning: Hai triết lý khác nhau

Phương pháp truyền thống: ZMP và Model-Based Control

Trước khi RL phổ biến, robot humanoid đi bằng phương pháp Zero Moment Point (ZMP). Ý tưởng cốt lõi: giữ cho điểm áp lực (center of pressure) luôn nằm trong vùng tiếp xúc giữa chân robot và mặt đất (support polygon). Honda ASIMO -- robot humanoid huyền thoại của những năm 2000 -- đi theo cách này.

Vấn đề của ZMP:

Quá bảo thủ: Robot phải luôn giữ balance tĩnh, nên đi rất chậm và cứng nhắc. Con người thực tế đi bằng cách "ngã có kiểm soát" -- liên tục mất và lấy lại balance.
Không thích ứng: Gặp terrain không bằng phẳng hoặc bị đẩy bất ngờ thì dễ ngã. Mọi trajectory đều phải tính toán trước.
Cần mô hình chính xác: Bất kỳ sai lệch nào giữa mô hình toán học và robot thật đều gây lỗi.

Reinforcement Learning: Học từ trải nghiệm

RL tiếp cận vấn đề hoàn toàn khác: thay vì thiết kế controller bằng tay, để robot tự học thông qua trial-and-error trong simulation. Robot thử hàng triệu bước đi, nhận reward khi đi tốt, penalty khi ngã -- và dần dần tìm ra policy tối ưu.

Kết quả: robot đi tự nhiên hơn, phục hồi được khi bị đẩy, thích ứng với địa hình phức tạp, và thậm chí chạy nhanh -- điều mà ZMP-based controller gần như không làm được.

Paper survey toàn diện nhất về chủ đề này là Deep Reinforcement Learning for Robotic Bipedal Locomotion: A Brief Survey (Li et al., 2024), tổng hợp hầu hết các phương pháp RL cho bipedal từ 2019 đến nay.

MDP Formulation cho Bipedal Walking

Để áp dụng RL, bước đầu tiên là mô hình hóa bài toán dưới dạng Markov Decision Process (MDP). Đây là phần quan trọng nhất -- thiết kế MDP tốt quyết định 80% thành công.

Observation Space (State)

Robot cần "nhìn thấy" gì để quyết định hành động tiếp theo? Observation space thường bao gồm:

# Observation space cho bipedal walking policy
observation = {
    # Proprioception -- thông tin từ cảm biến nội tại
    "base_angular_velocity": (3,),    # gyroscope: roll, pitch, yaw rate
    "base_orientation": (3,),         # gravity vector trong body frame
    "joint_positions": (12,),         # góc khớp 12 joints (6 mỗi chân)
    "joint_velocities": (12,),        # vận tốc góc khớp
    "previous_actions": (12,),        # action ở timestep trước

    # Command -- mục tiêu di chuyển
    "velocity_command": (3,),         # vx, vy, yaw_rate mong muốn
}
# Total: ~45 dimensions

Lưu ý: hầu hết các paper thành công không dùng vision cho locomotion. Chỉ dùng proprioception (joint encoders + IMU). Lý do: proprioceptive feedback có tần số cao (1kHz), trong khi camera chỉ 30-60Hz -- quá chậm cho balance control.

Paper Berkeley Humanoid: A Research Platform for Learning-based Control (2024) chứng minh rằng với observation space đơn giản này cộng domain randomization nhẹ, robot có thể đi outdoor trên địa hình phức tạp.

Action Space

Action space quyết định robot điều khiển cái gì:

# Action space: target joint positions
action_space = {
    "target_joint_positions": (12,),  # PD target cho 12 joints
    # Thực tế: action = default_pose + policy_output * action_scale
}

# PD controller thực thi action
torque = kp * (target_position - current_position) - kd * current_velocity

Phổ biến nhất là position target qua PD controller (proportional-derivative). Policy output ra target joint angles, PD controller ở tầng thấp chuyển thành torque. Cách này ổn định hơn so với output torque trực tiếp.

Reward Shaping -- Nghệ thuật thiết kế phần thưởng

Đây là phần khó nhất và cũng là nơi kinh nghiệm của researcher thể hiện rõ nhất. Reward function quyết định robot học được behavior gì.

def compute_reward(state, action, next_state, command):
    rewards = {}

    # === Tracking rewards (khuyến khích) ===
    # Thưởng khi velocity khớp với command
    lin_vel_error = (command.vx - state.base_lin_vel[0])**2
    rewards["linear_velocity"] = math.exp(-lin_vel_error / 0.25) * 1.5

    ang_vel_error = (command.yaw_rate - state.base_ang_vel[2])**2
    rewards["angular_velocity"] = math.exp(-ang_vel_error / 0.25) * 0.5

    # === Regularization rewards (phạt) ===
    # Phạt tiêu tốn năng lượng (torque * velocity)
    rewards["energy"] = -0.0001 * torch.sum(
        torch.abs(action * state.joint_velocities)
    )

    # Phạt action quá lớn (tránh giật cục)
    rewards["action_rate"] = -0.01 * torch.sum(
        (action - state.previous_action)**2
    )

    # Phạt nếu thân robot nghiêng quá nhiều
    rewards["orientation"] = -5.0 * torch.sum(
        state.projected_gravity[:2]**2
    )

    # Thưởng nếu chân chạm đất đúng nhịp (gait reward)
    rewards["feet_air_time"] = 0.5 * air_time_reward(state)

    # Phạt nếu 2 chân chạm đất cùng lúc quá lâu (khuyến khích alternate)
    rewards["no_fly"] = -0.25 * both_feet_on_ground(state)

    # Bonus sống sót
    rewards["alive"] = 2.0

    return sum(rewards.values())

Một số insight quan trọng từ các paper:

Exponential reward (dạng exp(-error/sigma)) tốt hơn linear reward vì nó smooth và có bounded gradient
Feet air time reward rất quan trọng -- thiếu nó robot sẽ học cách "trượt" thay vì bước
Energy penalty phải đủ nhỏ để không triệt tiêu forward velocity reward, nhưng đủ lớn để tránh behavior lãng phí năng lượng

Paper Reinforcement Learning for Versatile, Dynamic, and Robust Bipedal Locomotion Control (2024) trình bày chi tiết về reward design cho nhiều loại gait khác nhau (đi, chạy, nhảy) trên cùng một framework.

Huấn luyện với PPO trong Isaac Gym / Isaac Lab

Tại sao PPO?

Proximal Policy Optimization (PPO) là thuật toán RL được dùng phổ biến nhất cho locomotion. Lý do:

Ổn định: Clipped objective ngăn policy update quá lớn, tránh "catastrophic forgetting"
Song song hóa tốt: Phù hợp với massive parallel simulation trên GPU
Đơn giản: Ít hyperparameter hơn SAC hay TD3, dễ tune hơn

Paper gốc của PPO: Proximal Policy Optimization Algorithms (Schulman et al., 2017).

Isaac Gym và Isaac Lab

NVIDIA Isaac Gym (và phiên bản kế nhiệm Isaac Lab) cho phép huấn luyện hàng nghìn robot song song trên GPU. Đây là game-changer vì:

Tốc độ: 4096 robot instances chạy đồng thời, thu thập experience nhanh gấp 1000x so với single simulation
GPU-native: Physics chạy hoàn toàn trên GPU, không có CPU bottleneck
Terrain generation: Tự động tạo địa hình phức tạp (bậc thang, dốc, đá) để robot học

Paper chính thức: Isaac Lab: A GPU-Accelerated Simulation Framework for Multi-Modal Robot Learning.

# Ví dụ cấu hình training environment (Isaac Lab style)
env:
  num_envs: 4096
  episode_length: 1000        # ~20 giây mỗi episode
  terrain:
    type: "trimesh"
    curriculum: true           # bắt đầu phẳng, tăng dần độ khó
    terrain_types:
      - flat: 0.2
      - rough: 0.2
      - slopes: 0.2
      - stairs_up: 0.2
      - stairs_down: 0.2

robot:
  asset: "unitree_h1.urdf"
  default_joint_positions:     # pose đứng thẳng
    hip_pitch: -0.1
    knee: 0.3
    ankle: -0.2
  pd_gains:
    kp: 100.0
    kd: 5.0

rewards:
  linear_velocity_tracking:
    weight: 1.5
    params: { sigma: 0.25 }
  angular_velocity_tracking:
    weight: 0.5
  energy:
    weight: -0.0001
  action_rate:
    weight: -0.01
  orientation:
    weight: -5.0
  feet_air_time:
    weight: 0.5
  alive:
    weight: 2.0

# Training script cơ bản với Isaac Lab + RSL-RL
from omni.isaac.lab.envs import ManagerBasedRLEnv
from rsl_rl.runners import OnPolicyRunner

# Khởi tạo environment
env = ManagerBasedRLEnv(cfg=HumanoidFlatEnvCfg())

# Cấu hình PPO
ppo_cfg = {
    "algorithm": "PPO",
    "num_learning_epochs": 5,
    "num_mini_batches": 4,
    "clip_param": 0.2,          # epsilon trong clipped objective
    "entropy_coef": 0.01,        # khuyến khích exploration
    "learning_rate": 3e-4,
    "gamma": 0.99,               # discount factor
    "lam": 0.95,                 # GAE lambda
    "max_grad_norm": 1.0,
    "desired_kl": 0.01,          # adaptive learning rate
}

# Policy network: MLP [512, 256, 128]
policy_cfg = {
    "actor_hidden_dims": [512, 256, 128],
    "critic_hidden_dims": [512, 256, 128],
    "activation": "elu",
}

# Huấn luyện ~2-4 giờ trên RTX 4090
runner = OnPolicyRunner(env, ppo_cfg, policy_cfg)
runner.learn(num_learning_iterations=5000)

Framework mã nguồn mở đáng chú ý: legged_gym từ ETH Zurich (paper: Learning to Walk in Minutes Using Massively Parallel Deep RL) -- đây là nền tảng mà phần lớn research locomotion hiện tại xây dựng trên.

Terrain Curriculum

Một kỹ thuật quan trọng: curriculum learning cho terrain. Thay vì ném robot vào terrain khó ngay từ đầu (sẽ không học được gì), bắt đầu từ mặt phẳng rồi tăng dần độ khó.

# Terrain curriculum: robot giỏi hơn → terrain khó hơn
class TerrainCurriculum:
    def __init__(self):
        self.difficulty_levels = [
            "flat",              # Level 0: mặt phẳng
            "slight_slope",      # Level 1: dốc nhẹ 5°
            "rough_flat",        # Level 2: phẳng nhưng lồi lõm
            "moderate_slope",    # Level 3: dốc 15°
            "stairs_low",        # Level 4: bậc thang 5cm
            "stairs_high",       # Level 5: bậc thang 15cm
            "mixed_terrain",     # Level 6: kết hợp tất cả
        ]

    def update(self, success_rate):
        """Nâng level khi robot đạt >80% success rate"""
        if success_rate > 0.8:
            self.current_level = min(
                self.current_level + 1,
                len(self.difficulty_levels) - 1
            )

Sim-to-Real Transfer: Từ mô phỏng đến thực tế

Đây là phần khó nhất trong toàn bộ pipeline. Robot đi hoàn hảo trong simulation nhưng ngã ngay khi deploy lên hardware thật -- hiện tượng này gọi là reality gap.

Domain Randomization

Ý tưởng: nếu policy hoạt động tốt trên nhiều phiên bản khác nhau của simulation (friction khác nhau, mass khác nhau, delay khác nhau...), thì nó cũng sẽ robust trên hardware thật -- vì thực tế chỉ là "một phiên bản nữa" trong distribution.

# Domain randomization parameters
randomization:
  # Randomize vật lý
  friction_range: [0.3, 1.5]        # hệ số ma sát sàn
  restitution_range: [0.0, 0.5]     # độ nảy
  added_mass_range: [-1.0, 3.0]     # kg thêm vào thân robot

  # Randomize robot dynamics
  joint_friction_range: [0.01, 0.15]
  kp_factor_range: [0.8, 1.2]       # ±20% PD gains
  kd_factor_range: [0.8, 1.2]

  # Randomize communication delay
  action_delay_range: [0, 3]         # 0-3 timestep delay
  observation_noise: 0.05            # Gaussian noise σ

  # Randomize ngoại lực (mô phỏng bị đẩy)
  push_interval: 8.0                 # giây
  push_force_range: [0, 100]         # Newton

Paper Sim-to-Real Transfer in Deep Reinforcement Learning for Bipedal Locomotion (2025) trình bày chiến lược kết hợp domain randomization với curriculum learning và online adaptation -- đạt kết quả state-of-the-art cho bipedal sim-to-real.

Các kỹ thuật bổ sung

Ngoài domain randomization, còn một số kỹ thuật quan trọng:

Observation history: Thay vì chỉ dùng observation hiện tại, feed cả lịch sử 5-10 timestep gần nhất. Giúp policy ước lượng ngầm các tham số vật lý (terrain, friction) mà không cần đo trực tiếp.
Actuator network: Thay vì dùng PD controller lý tưởng trong sim, train một neural network mô phỏng actuator thật (có delay, friction, saturation). Giảm đáng kể reality gap.
Teacher-student training: Teacher policy có quyền truy cập privileged information (terrain heightmap, exact friction...). Student policy chỉ dùng observation có trên robot thật, được distill từ teacher.

Các paper và kết quả nổi bật

Berkeley Humanoid -- Leo dốc San Francisco

Learning Humanoid Locomotion over Challenging Terrain (Radosavovic et al., 2024) -- robot humanoid đi hơn 4 dặm trên đường mòn hiking ở Berkeley Hills và leo những con dốc dựng nhất San Francisco. Phương pháp: transformer model pre-train trên flat-ground trajectories, sau đó fine-tune bằng RL trên terrain khó.

Agility Robotics Digit -- RL trên robot thương mại

Robust Feedback Motion Policy Design Using RL on a 3D Digit Bipedal Robot -- framework RL hierarchical cho Digit, kết hợp RL policy với feedback regulation truyền thống. Đạt robust walking với state/action space giảm chiều.

Agile and Versatile Bipedal Robot Tracking Control through RL (2024) -- single small-scale neural network đạt ankle và body trajectory tracking trên nhiều loại gait khác nhau.

ETH Zurich -- Legged Gym Framework

Learning to Walk in Minutes (Rudin et al., 2022) -- framework mã nguồn mở cho phép train locomotion policy trong vài phút trên 1 GPU. Nền tảng mà hầu hết research hiện tại xây dựng trên.

Hướng dẫn bắt đầu thực hành

Nếu bạn muốn tự tay train một bipedal walking policy, đây là lộ trình đề xuất:

Bước 1: Bắt đầu với MuJoCo + Gymnasium

pip install gymnasium[mujoco]

Thử environment Humanoid-v4 trong Gymnasium. Đây là bài toán bipedal đơn giản nhất, đủ để hiểu pipeline RL cơ bản.

Bước 2: Chuyển sang Isaac Lab

# Clone Isaac Lab
git clone https://github.com/isaac-sim/IsaacLab.git
cd IsaacLab

# Cài đặt (cần NVIDIA GPU + Isaac Sim)
./isaaclab.sh --install

Isaac Lab cung cấp sẵn environment cho Unitree H1, G1, và nhiều humanoid khác.

Bước 3: Customize reward và domain randomization

Đây là nơi bạn sẽ dành phần lớn thời gian. Thử thay đổi reward weights, thêm/bỏ reward terms, điều chỉnh domain randomization ranges. Mỗi thay đổi nhỏ có thể tạo ra behavior rất khác.

Bước 4: Deploy lên hardware (nếu có)

Unitree G1 (giá từ $16,000) là platform rẻ nhất hỗ trợ RL deployment. Nếu chưa có hardware, nhiều lab cho phép remote access robot qua cloud.

Kết luận

Reinforcement Learning đã biến bipedal walking từ bài toán "gần như bất khả thi" thành "train trong vài giờ trên 1 GPU". Sự kết hợp giữa massive parallel simulation (Isaac Lab), thuật toán ổn định (PPO), và sim-to-real techniques (domain randomization, curriculum) tạo ra pipeline end-to-end mà bất kỳ ai có GPU và kiến thức RL cơ bản đều có thể tiếp cận.

Cuộc đua humanoid locomotion đang nóng hơn bao giờ hết -- và RL chính là nhiên liệu đẩy nó về phía trước.