人形机器人运控部署框架解析：RSL-RL 与 Unitree RL Gym 源码解读

这里需要注意 KL 散度惩罚项的设置，用于自适应调整学习率，防止策略更新过大导致训练不稳定。

环境交互与数据收集

智能体与环境交互是训练的基础。act 方法负责根据当前观察计算动作，process_env_step 处理环境反馈。

def act(self, obs, critic_obs):
    if self.actor_critic.is_recurrent:
        self.transition.hidden_states = self.actor_critic.get_hidden_states()
    
    # 计算动作分布
    self.transition.actions = self.actor_critic.act(obs).detach()
    self.transition.values = self.actor_critic.evaluate(critic_obs).detach()
    self.transition.actions_log_prob = self.actor_critic.get_actions_log_prob(self.transition.actions).detach()
    return self.transition.actions

def process_env_step(self, rewards, dones, infos):
    self.transition.rewards = rewards.clone()
    self.transition.dones = dones
    
    # 超时引导 (Bootstrapping on time outs)
    if 'time_outs' in infos:
        self.transition.rewards += self.gamma * torch.squeeze(
            self.transition.values * infos['time_outs'].unsqueeze(1).to(self.device), 1
        )
    
    self.storage.add_transitions(self.transition)
    self.transition.clear()

这里的'超时引导'非常关键。如果一个 episode 因达到时间限制而非失败状态结束，会将最后一步的估计价值加到奖励中，避免智能体受到不公平的惩罚。

回报计算与优势估计

收集足够数据后，调用 compute_returns 计算回报和 GAE 优势。

def compute_returns(self, last_critic_obs):
    last_values = self.actor_critic.evaluate(last_critic_obs).detach()
    self.storage.compute_returns(last_values, self.gamma, self.lam)

GAE（广义优势估计）结合了不同时间步长的价值估计，有效减少了方差。对于全长为 T 的轨迹，优势函数通常基于 TD-error 并结合 MC 方法。

策略更新

这是训练的核心循环。遍历 mini-batch，计算损失并更新参数。

def update(self):
    mean_value_loss = 0
    mean_surrogate_loss = 0
    
    # 选择生成器
    if self.actor_critic.is_recurrent:
        generator = self.storage.reccurent_mini_batch_generator(...)
    else:
        generator = self.storage.mini_batch_generator(...)

    for (obs_batch, actions_batch, advantages_batch, ...) in generator:
        # 计算重要性采样比率
        ratio = torch.exp(actions_log_prob_batch - torch.squeeze(old_actions_log_prob_batch))
        
        # 代理损失 (Surrogate Loss)
        surrogate = -torch.squeeze(advantages_batch) * ratio
        surrogate_clipped = -torch.squeeze(advantages_batch) * torch.clamp(
            ratio, 1.0 - self.clip_param, 1.0 + self.clip_param
        )
        surrogate_loss = torch.max(surrogate, surrogate_clipped).mean()
        
        # 价值损失 (Value Function Loss)
        if self.use_clipped_value_loss:
            value_clipped = target_values_batch + (value_batch - target_values_batch).clamp(
                -self.clip_param, self.clip_param
            )
            value_loss = torch.max(
                (value_batch - returns_batch).pow(2),
                (value_clipped - returns_batch).pow(2)
            ).mean()
        else:
            value_loss = (returns_batch - value_batch).pow(2).mean()
        
        # 总损失与梯度更新
        loss = surrogate_loss + self.value_loss_coef * value_loss - self.entropy_coef * entropy_batch.mean()
        
        self.optimizer.zero_grad()
        loss.backward()
        nn.utils.clip_grad_norm_(self.actor_critic.parameters(), self.max_grad_norm)
        self.optimizer.step()

自适应学习率机制

如果启用了自适应学习率 (schedule == "adaptive")，会根据 KL 散度动态调整。

if self.desired_kl is not None and self.schedule == "adaptive":
    with torch.inference_mode():
        kl = torch.sum(torch.log(sigma_batch / old_sigma_batch + 1.0e-5) + ...
    kl_mean = torch.mean(kl)
    
    if kl_mean > self.desired_kl * 2.0:
        self.learning_rate = max(1e-5, self.learning_rate / 1.5)
    elif kl_mean < self.desired_kl / 2.0 and kl_mean > 0.0:
        self.learning_rate = min(1e-2, self.learning_rate * 1.5)

当策略变化过大（KL 散度高）时降低学习率，反之则提高，这是一种典型的自适应 KL 惩罚过程。

网络架构变体

RSL-RL 支持多种 Actor-Critic 网络实现，以适应不同的观测空间。

Transformer 架构

针对序列数据，可以使用基于 BERT 风格的 Transformer 模型。

class Transformer(nn.Module):
    def __init__(self, input_dim, output_dim, context_len, latent_dim=128, num_head=4, num_layer=4):
        super().__init__()
        self.input_layer = nn.Sequential(nn.Linear(input_dim, latent_dim), nn.Dropout(0.1))
        self.weight_pos_embed = nn.Embedding(context_len, latent_dim)
        self.attention_blocks = nn.Sequential(*[
            Transformer_Block(latent_dim, num_head, 0.1) for _ in range(num_layer)
        ])
        self.output_layer = nn.Sequential(nn.LayerNorm(latent_dim), nn.Linear(latent_dim, output_dim))

    def forward(self, x):
        x = self.input_layer(x)
        x = x + self.weight_pos_embed(torch.arange(x.shape[1], device=x.device))
        x = self.attention_blocks(x)
        x = x[:, -1, :]
        return self.output_layer(x)

基础 MLP 架构

对于常规状态输入，标准的 MLP 依然高效。

class ActorCritic(nn.Module):
    def __init__(self, num_actor_obs, num_critic_obs, num_actions, ...):
        super().__init__()
        activation = get_activation('elu')
        
        # Policy Network
        actor_layers = []
        actor_layers.append(nn.Linear(mlp_input_dim_a, actor_hidden_dims[0]))
        actor_layers.append(activation)
        # ... 构建多层感知机 ...
        self.actor = nn.Sequential(*actor_layers)
        
        # Value Network
        critic_layers = []
        critic_layers.append(nn.Linear(mlp_input_dim_c, critic_hidden_dims[0]))
        critic_layers.append(activation)
        # ... 构建价值网络 ...
        self.critic = nn.Sequential(*critic_layers)

总结

RSL-RL 通过清晰的模块化设计，降低了强化学习在机器人控制领域的部署门槛。从 PPO 算法的稳定性保障（如裁剪、KL 惩罚），到网络结构的灵活性（Transformer、CNN、RNN），都为开发者提供了坚实的工程基础。在实际应用中，结合 Unitree SDK 等硬件接口，可快速完成从仿真到真机的闭环验证。