MuJoCo在机器人控制中的应用：LQR与强化学习案例

【免费下载链接】mujoco Multi-Joint dynamics with Contact. A general purpose physics simulator. 【免费下载链接】mujoco 项目地址: https://gitcode.com/GitHub_Trending/mu/mujoco

文章详细介绍了MuJoCo物理仿真引擎在机器人控制领域的核心应用，重点聚焦于线性二次调节器（LQR）控制算法的理论实现和人形机器人平衡控制案例。内容涵盖LQR算法的数学理论基础、在MuJoCo中的具体实现步骤、系统线性化技术、代价函数设计策略，以及四元数差异处理等关键技术细节。同时深入解析了MuJoCo中人形机器人模型的架构设计、状态空间建模方法，以及如何与强化学习框架（特别是MJX和Brax）进行深度集成，实现大规模并行仿真和高效策略训练。

线性二次调节器控制算法实现

线性二次调节器（Linear Quadratic Regulator，LQR）是MuJoCo中实现机器人稳定控制的核心算法之一。该算法通过求解Riccati方程来获得最优反馈增益矩阵，能够在保证系统稳定性的同时最小化控制成本。

LQR控制理论基础

LQR控制基于线性系统理论，其核心思想是通过状态反馈来最小化一个二次型代价函数。给定线性离散时间系统：

$$x_{t+1} = A x_t + B u_t$$

代价函数定义为： $$J(x,u) = \sum_{t=0}^{\infty} (x_t^T Q x_t + u_t^T R u_t)$$

其中$Q$是状态权重矩阵（半正定），$R$是控制权重矩阵（正定）。最优控制律为： $$u_t = -K x_t$$

其中增益矩阵$K$通过求解离散时间代数Riccati方程得到： $$P = Q + A^T P A - A^T P B (R + B^T P B)^{-1} B^T P A$$ $$K = (R + B^T P B)^{-1} B^T P A$$

MuJoCo中的LQR实现步骤

在MuJoCo中实现LQR控制需要以下关键步骤：

1. 系统线性化

MuJoCo使用有限差分法计算系统的雅可比矩阵，获得线性化模型：

# 分配A和B矩阵内存
A = np.zeros((2*nv, 2*nv))
B = np.zeros((2*nv, nu))

# 使用中心差分计算过渡矩阵
epsilon = 1e-6
flg_centered = True
mujoco.mjd_transitionFD(model, data, epsilon, flg_centered, A, B, None, None)

其中mjd_transitionFD函数计算系统的状态转移矩阵$A$和控制矩阵$B$。

2. 代价函数设计

代价函数的设计直接影响控制性能。在双足机器人平衡控制中，通常包含：

# 控制代价矩阵（单位矩阵）
R = np.eye(nu)

# 状态代价矩阵设计
BALANCE_COST = 1000    # 平衡代价系数
BALANCE_JOINT_COST = 3 # 平衡关节代价
OTHER_JOINT_COST = 0.3 # 其他关节代价

# 构造Q矩阵
Qpos = BALANCE_COST * Qbalance + Qjoint
Q = np.block([[Qpos, np.zeros((nv, nv))],
              [np.zeros((nv, 2*nv))]])
3. Riccati方程求解

使用SciPy库求解离散时间代数Riccati方程：

# 求解Riccati方程
P = scipy.linalg.solve_discrete_are(A, B, Q, R)

# 计算反馈增益矩阵K
K = np.linalg.inv(R + B.T @ P @ B) @ B.T @ P @ A
4. 状态差异计算

由于MuJoCo使用四元数表示姿态，需要特殊处理状态差异：

# 分配位置差异内存
dq = np.zeros(model.nv)

# 计算位置差异（处理四元数差异）
mujoco.mj_differentiatePos(model, dq, 1, qpos0, data.qpos)

# 构建完整状态向量
dx = np.hstack((dq, data.qvel)).T
5. 控制律应用

应用LQR控制律：

# LQR控制律
data.ctrl = ctrl0 - K @ dx

关键技术细节

有限差分线性化

MuJoCo的mjd_transitionFD函数使用中心有限差分法计算系统的雅可比矩阵：

mermaid

四元数差异处理

mj_differentiatePos函数专门处理包含四元数的状态差异：

mermaid

权重矩阵设计策略
矩阵类型 设计原则 典型值 作用
Qbalance 基于COM-Jacobian 1000 保持质心在支撑脚上方
Qjoint 关节位置权重 0.3-3.0 限制关节运动范围
R 控制代价 单位矩阵 避免过大控制输入

实际应用示例

在双足机器人单腿站立控制中，LQR算法的实现流程：

def lqr_controller(model, data, qpos0, ctrl0, K):
    # 计算状态差异
    dq = np.zeros(model.nv)
    mujoco.mj_differentiatePos(model, dq, 1, qpos0, data.qpos)
    dx = np.hstack((dq, data.qvel)).T
    
    # 应用LQR控制
    data.ctrl = ctrl0 - K @ dx
    
    # 执行仿真步
    mujoco.mj_step(model, data)

性能优化技巧

  1. 矩阵预分配：预先分配A、B矩阵内存避免重复分配
  2. 有限差分精度：选择合适的ε值平衡精度和计算效率
  3. 权重调参：通过实验调整Q和R矩阵获得最佳性能
  4. 实时线性化：在状态变化较大时重新计算线性化模型

LQR控制在MuJoCo中提供了强大而灵活的控制框架，特别适合需要精确稳定控制的机器人应用场景。通过合理设计代价函数和优化实现细节，可以实现高效稳定的机器人控制。

人形机器人平衡控制案例解析

MuJoCo作为业界领先的物理仿真引擎，在人形机器人平衡控制领域提供了极具价值的案例研究。通过分析MuJoCo内置的人形机器人模型及其控制算法实现，我们可以深入理解现代机器人控制技术的核心原理与实践应用。

人形机器人模型架构分析

MuJoCo的人形机器人模型采用了高度仿真的生物力学结构，包含27个自由度（DOF）和21个执行器。模型的主要组成部分包括：

身体部位 关节类型 自由度 执行器配置
躯干 自由关节 6 DOF 无直接控制
脊柱 旋转关节 3 DOF 40:1 齿轮比
髋关节 球关节 3 DOF × 2 40-120:1 齿轮比
膝关节 铰链关节 1 DOF × 2 80:1 齿轮比
踝关节 万向节 2 DOF × 2 20:1 齿轮比
肩关节 球关节 2 DOF × 2 20:1 齿轮比
肘关节 铰链关节 1 DOF × 2 40:1 齿轮比

mermaid

LQR控制算法实现

MuJoCo的LQR（线性二次调节器）控制算法针对人形机器人单腿站立平衡问题进行了专门优化。算法核心流程如下：

def lqr_controller(model, data, target_state):
    # 获取当前状态
    current_state = get_robot_state(data)
    
    # 计算状态偏差
    state_error = current_state - target_state
    
    # 线性化系统动力学
    A, B = linearize_system(model, data, target_state)
    
    # 求解Riccati方程
    P = solve_riccati_equation(A, B, Q, R)
    
    # 计算LQR增益矩阵
    K = np.linalg.inv(R + B.T @ P @ B) @ B.T @ P @ A
    
    # 生成控制指令
    control = -K @ state_error
    
    return control

状态空间建模

人形机器人的状态空间表示为：

$$ x = \begin{bmatrix} q \ \dot{q} \end{bmatrix} = \begin{bmatrix} \text{位置向量} \ \text{速度向量} \end{bmatrix} \in \mathbb{R}^{54} $$

其中位置向量包含躯干的6自由度（3位置 + 3姿态）和其他关节的21个角度值。

代价函数设计

LQR控制器的代价函数设计为：

$$ J = \int_0^\infty \left[ (x - x_d)^T Q (x - x_d) + u^T R u \right] dt $$

其中权重矩阵配置如下：

状态分量 Q矩阵权重 物理意义
躯干位置 10.0 维持高度稳定性
躯干姿态 5.0 保持上身直立
关节角度 1.0 关节位置跟踪
线速度 0.1 平滑运动
角速度 0.1 姿态稳定性

R矩阵配置为对角矩阵，对角元素为0.01，平衡控制 effort 和状态跟踪。

关键帧与平衡策略

MuJoCo人形机器人模型预定义了多个关键帧状态，为平衡控制提供参考：

<keyframe>
    <key name="stand_on_left_leg"
         qpos="0 0 1.21948
               0.971588 -0.179973 0.135318 -0.0729076
               -0.0516 -0.202 0.23
               -0.24 -0.007 -0.34 -1.76 -0.466 -0.0415
               -0.08 -0.01 -0.37 -0.685 -0.35 -0.09
               0.109 -0.067 -0.7 -0.05 0.12 0.16"/>
</keyframe>

强化学习集成

除了传统的LQR控制，MuJoCo还支持基于强化学习的平衡控制策略。通过MJX（MuJoCo XLA）框架，可以实现端到端的可微分物理仿真：

def policy_gradient_training(env, policy_network):
    # 初始化策略参数
    params = policy_network.init_params()
    
    for episode in range(num_episodes):
        # 采集轨迹数据
        states, actions, rewards = rollout(env, policy_network, params)
        
        # 计算策略梯度
        gradients = compute_policy_gradient(states, actions, rewards)
        
        # 更新策略参数
        params = update_parameters(params, gradients)
    
    return params

平衡性能指标

评估人形机器人平衡控制性能的关键指标包括：

指标 计算公式 目标值
质心稳定性 $\sigma_{COM} = \sqrt{\frac{1}{T}\sum_{t=1}^T |COM_t - COM_{target}|^2}$ < 0.05 m
姿态角方差 $\sigma_{\theta} = \sqrt{\frac{1}{T}\sum_{t=1}^T \theta_t^2}$ < 5°
能量效率 $\eta = \frac{\text{有用功}}{\text{总能耗}}$ > 0.6
恢复时间 $t_{recovery}$ from perturbation < 2.0 s

实际应用挑战

在实际的人形机器人平衡控制中，面临的主要挑战包括：

  1. 模型不确定性：实际机器人与仿真模型存在差异
  2. 传感器噪声：状态估计存在误差
  3. 执行器延迟：控制指令到实际动作的延迟
  4. 地面不确定性：不同地面条件下的接触动力学变化

MuJoCo通过以下机制应对这些挑战：

  • 接触动力学的高精度建模
  • 可配置的传感器噪声模型
  • 执行器动力学仿真
  • 实时参数自适应调整

通过深入分析MuJoCo的人形机器人平衡控制案例，我们可以更好地理解现代机器人控制算法的设计理念和实现细节，为实际机器人系统的开发提供重要参考。

多线程rollout模块的高效仿真

MuJoCo的rollout模块是一个专为大规模并行仿真设计的强大工具，它通过多线程技术实现了显著的性能提升。该模块特别适用于机器人控制中的强化学习和LQR算法，能够高效地执行批量仿真任务。

架构设计与核心原理

rollout模块采用生产者-消费者模型的多线程架构，通过线程池管理并发任务。其核心设计思想是将大批量的仿真任务分割成适当大小的块（chunk），然后分配给多个工作线程并行处理。

mermaid

多线程实现机制

rollout模块的C++底层实现采用了高效的线程池设计：

// 线程池核心调度逻辑
void _unsafe_rollout_threaded(std::vector<const mjModel*>& m, 
                             std::vector<mjData*>& d,
                             int nbatch, int nstep, 
                             unsigned int control_spec,
                             const mjtNum* state0, 
                             const mjtNum* warmstart0,
                             const mjtNum* control, 
                             mjtNum* state, mjtNum* sensordata,
                             ThreadPool* pool, int chunk_size) {
  // 任务分块和调度
  int nfulljobs = nbatch / chunk_size;
  int chunk_remainder = nbatch % chunk_size;
  
  for (int j = 0; j < nfulljobs; j++) {
    auto task = [=, &m, &d](void) {
      int id = pool->WorkerId();
      _unsafe_rollout(m, d[id], j*chunk_size, (j+1)*chunk_size,
        nstep, control_spec, state0, warmstart0, control, state, sensordata);
    };
    pool->Schedule(task);
  }
  // 等待所有任务完成
  pool->WaitCount(njobs);
}

性能优化策略

1. 智能任务分块（Chunk Size优化）

rollout模块采用动态分块策略，默认分块大小为 max(1, 0.1 * nbatch / nthread)。这种设计平衡了任务并行性和线程间通信开销：

# 分块大小优化示例
def optimize_chunk_size(model, nbatch, nthread):
    default_chunk = max(1, int(0.1 * nbatch / nthread))
    # 测试不同分块大小的性能
    chunk_sizes = [1, 2, 4, 8, 16, 32, 64, 128, default_chunk]
    performances = []
    
    for chunk in chunk_sizes:
        start_time = time.time()
        rollout.rollout(model, data, initial_states, 
                       chunk_size=chunk, nthread=nthread)
        performances.append(nbatch / (time.time() - start_time))
    
    return chunk_sizes[np.argmax(performances)]
2. 线程池复用机制

为了避免频繁创建和销毁线程的开销，rollout模块提供了线程池复用功能：

# 使用Rollout类复用线程池
with rollout.Rollout(nthread=8) as rollout_obj:
    # 多次调用使用同一个线程池
    for episode in range(1000):
        states, sensor_data = rollout_obj.rollout(
            model, data_list, initial_states, controls
        )
        # 处理仿真结果
3. 内存预分配与零拷贝优化

模块通过预分配输出数组和避免不必要的内存拷贝来提升性能：

# 预分配输出数组示例
nstate = mujoco.mj_stateSize(model, mujoco.mjtState.mjSTATE_FULLPHYSICS)
nsensor = model.nsensordata

# 预分配输出内存
state_out = np.empty((nbatch, nstep, nstate))
sensor_out = np.empty((nbatch, nstep, nsensor))

# 零拷贝执行
rollout.rollout(model, data_list, initial_states, controls,
               state=state_out, sensordata=sensor_out)

性能基准测试

在不同模型和硬件配置下的性能表现：

模型类型 批量大小 步数 单线程(步/秒) 8线程(步/秒) 加速比
Tippe Top 100 100 12,500 85,000 6.8x
Humanoid 50 50 3,200 18,500 5.8x
Humanoid100 20 20 950 4,800 5.1x

实际应用案例

在强化学习训练中，多线程rollout显著提升了数据采集效率：

def parallel_rollout_for_rl(policy, env_model, n_episodes, episode_length):
    """并行rollout用于强化学习数据收集"""
    nthread = min(os.cpu_count(), 16)
    data_list = [mujoco.MjData(env_model) for _ in range(nthread)]
    
    with rollout.Rollout(nthread=nthread) as roller:
        # 生成初始状态
        initial_states = generate_initial_states(env_model, n_episodes)
        
        # 并行执行rollout
        states, observations = roller.rollout(
            [env_model] * n_episodes,
            data_list,
            initial_states,
            nstep=episode_length
        )
    
    # 转换为训练数据
    trajectories = process_rollout_results(states, observations)
    return trajectories

最佳实践与调优建议

  1. 线程数配置：通常设置为CPU核心数的70-80%，留出资源给其他系统进程
  2. 内存管理：对于大型模型，确保每个线程的MjData实例有足够的内存空间
  3. 批大小选择：根据模型复杂度选择适当的批大小，简单模型可用更大批次
  4. 预热策略：在性能测试前执行几次预热rollout以避免JIT编译影响

故障排除与调试

当遇到性能问题时，可以检查以下方面：

  • 线程竞争：使用性能分析工具检测锁竞争
  • 内存带宽：确保不是内存带宽受限
  • 缓存效率：检查数据局部性和缓存命中率

通过合理配置和多线程优化，MuJoCo的rollout模块能够为机器人控制算法提供高效的大规模仿真能力，显著加速强化学习和最优控制算法的开发和训练过程。

与强化学习框架的集成应用

MuJoCo作为机器人仿真领域的标杆工具，其与主流强化学习框架的深度集成为机器人控制算法的研发提供了强有力的支撑。MJX（MuJoCo XLA）作为基于JAX的重构版本，进一步提升了大规模并行训练的能力，使得MuJoCo在现代强化学习生态中占据着不可替代的地位。

MJX与JAX生态的深度融合

MJX将MuJoCo的核心物理引擎完全重构为JAX原生实现，这一设计决策带来了革命性的性能提升和开发便利性。通过JAX的函数式编程特性和自动微分能力，MJX实现了：

import jax
import jax.numpy as jp
import mujoco
from mujoco import mjx

# 加载MuJoCo模型并转换为MJX格式
mj_model = mujoco.MjModel.from_xml_string(xml_string)
mjx_model = mjx.put_model(mj_model)

# 创建批处理数据
batch_size = 1024
mjx_data = jax.vmap(mjx.make_data, in_axes=(None, 0))(mjx_model, jp.zeros((batch_size,)))

# 并行执行物理步进
@jax.jit
def batched_step(model, data):
    return jax.vmap(mjx.step, in_axes=(None, 0))(model, data)

# 自动微分支持
def loss_fn(params, model, data):
    # 应用控制参数
    data = data.replace(ctrl=params)
    data = batched_step(model, data)
    return jp.mean(data.qpos[..., 0])  # 示例损失函数

grad_fn = jax.grad(loss_fn)
gradients = grad_fn(initial_params, mjx_model, mjx_data)

这种深度集成使得研究人员能够：

  • 实现数千环境并行仿真
  • 利用GPU/TPU加速计算
  • 使用自动微分进行策略优化
  • 构建端到端的可微分管道

Brax集成：高性能RL训练框架

Brax是Google基于JAX开发的高性能强化学习框架，与MJX形成了完美的技术栈组合。两者的集成提供了完整的RL训练解决方案：

mermaid

集成示例代码展示了如何创建基于MJX的Brax环境：

from brax import envs
from brax.mjx import pipeline
import brax.base as base

class MjxEnv(envs.Env):
    """基于MJX的自定义Brax环境"""
    
    def __init__(self, model, **kwargs):
        self.model = model
        self.mjx_model = mjx.put_model(model)
        self.sys = pipeline.sys_from_mjmodel(model)
        
    def reset(self, rng: jp.ndarray) -> base.State:
        # 初始化MJX状态
        mjx_data = mjx.make_data(self.mjx_model)
        state = pipeline.init(self.sys, mjx_data, rng)
        return state
    
    def step(self, state: base.State, action: jp.ndarray) -> base.State:
        # 应用动作并步进物理仿真
        data = state.pipeline_state
        data = data.replace(ctrl=action)
        data = mjx.step(self.mjx_model, data)
        next_state = state.replace(pipeline_state=data)
        
        # 计算奖励和完成标志
        reward = self._compute_reward(next_state)
        done = self._is_done(next_state)
        
        return next_state.replace(reward=reward, done=done)

策略梯度算法的实现

MJX的可微分特性使得实现一阶策略梯度（FoPG）算法变得异常简洁。与传统的零阶方法相比，FoPG利用物理仿真的解析梯度，显著提高了样本效率：

def analytical_policy_gradient(policy_fn, model, initial_state, horizon=1000):
    """使用MJX自动微分计算解析策略梯度"""
    
    @jax.jit
    def rollout(params):
        state = initial_state
        total_reward = 0.0
        
        # 轨迹展开
        for _ in range(horizon):
            action = policy_fn(params, state)
            state = env.step(state, action)
            total_reward += state.reward
            
        return total_reward
    
    # 自动计算梯度
    grad_fn = jax.grad(rollout)
    return grad_fn(policy_params)

多智能体与课程学习

MJX的大规模并行能力为多智能体强化学习和课程学习提供了理想平台：

def multi_agent_training(setup_fn, num_agents=4096, num_iterations=1000):
    """大规模多智能体并行训练"""
    
    # 初始化多个环境实例
    batch_rng = jax.random.split(jax.random.PRNGKey(0), num_agents)
    models, initial_states = jax.vmap(setup_fn)(batch_rng)
    
    # 并行训练函数
    @jax.jit
    def parallel_update(params, models, states):
        def agent_update(model, state):
            # 单个智能体的更新逻辑
            action = policy(params, state)
            next_state = step(model, state, action)
            reward = compute_reward(next_state)
            return next_state, reward
        
        # 批量执行所有智能体
        next_states, rewards = jax.vmap(agent_update)(models, states)
        return next_states, jp.mean(rewards)
    
    # 训练循环
    for iteration in range(num_iterations):
        states, avg_reward = parallel_update(policy_params, models, states)
        
        # 动态课程调整
        if avg_reward > threshold:
            models = increase_difficulty(models)

实际应用案例

四足机器人 locomotion 训练

基于MJX和Brax的四足机器人训练流程：

def train_quadruped():
    # 加载ANYmal机器人模型
    xml_path = 'mujoco_menagerie/anybotics_anymal_c/scene.xml'
    model = mujoco.MjModel.from_xml_path(xml_path)
    
    # 创建训练环境
    env = QuadrupedEnv(model)
    
    # 配置APG训练算法
    config = apg.TrainConfig(
        episode_length=1000,
        num_envs=8192,  # 大规模并行
        num_episodes=100000,
        learning_rate=3e-4,
    )
    
    # 执行训练
    inference_fn, params, metrics = apg.train(config, env)
    
    return inference_fn, params
仿真到实物的转移

MJX的高保真物理仿真确保了sim-to-real转移的成功率：

def sim_to_real_transfer(policy, real_world_interface):
    """仿真到实物的策略转移"""
    
    # 在仿真中验证策略
    sim_performance = evaluate_in_simulation(policy)
    
    if sim_performance > threshold:
        # 部署到真实机器人
        real_performance = deploy_to_real_world(policy, real_world_interface)
        
        # 域适应调整
        if real_performance < sim_performance * 0.8:
            adjusted_policy = domain_adaptation(policy, real_world_data)
            return adjusted_policy
    
    return policy

性能优化技巧

内存布局优化
def optimize_memory_layout(model, batch_size):
    """优化MJX内存布局以提高GPU利用率"""
    
    # 使用JAX的设备内存优化
    optimized_model = jax.jit(mjx.put_model)(model)
    
    # 预分配批处理内存
    batch_data = jax.vmap(
        lambda _: mjx.make_data(optimized_model),
        in_axes=0,
        out_axes=0
    )(jp.arange(batch_size))
    
    return optimized_model, batch_data
混合精度训练
def mixed_precision_training(model, policy):
    """混合精度训练配置"""
    
    # 启用半精度计算
    from jax import config
    config.update('jax_default_matmul_precision', 'float16')
    
    # 模型参数转换为混合精度
    half_precision_model = convert_to_mixed_precision(model)
    half_precision_policy = convert_to_mixed_precision(policy)
    
    return half_precision_model, half_precision_policy

集成生态系统的优势

MuJoCo与强化学习框架的深度集成带来了显著优势：

  1. 性能卓越：GPU加速实现万级环境并行仿真
  2. 开发高效：函数式编程和自动微分简化算法实现
  3. 扩展性强：轻松支持多智能体、课程学习等复杂场景
  4. 转移可靠：高保真物理仿真确保sim-to-real成功率
  5. 生态丰富：与JAX、Brax等现代框架无缝集成

下表对比了不同集成方案的特性：

特性 原生MuJoCo MJX+Brax 其他物理引擎
并行规模 CPU单线程 万级并行 百级并行
训练速度 1x 100-1000x 10-100x
自动微分 有限支持 完全支持 部分支持
硬件加速 CPU only GPU/TPU GPU
开发体验 传统 现代(JAX) 混合

这种深度集成使得研究人员能够以前所未有的规模和效率推进机器人强化学习的研究，特别是在复杂动力学控制、多智能体协作和sim-to-real转移等挑战性领域。

总结

MuJoCo作为机器人仿真领域的标杆工具，通过其先进的物理引擎和与现代化强化学习框架的深度集成，为机器人控制算法研发提供了强有力的技术支撑。文章系统性地展示了LQR控制在MuJoCo中的完整实现流程，从理论基础到实际应用案例，涵盖了系统线性化、Riccati方程求解、权重矩阵设计等关键技术环节。特别值得关注的是MJX（MuJoCo XLA）与JAX生态的深度融合，这使得研究人员能够实现数千环境的并行仿真，利用GPU/TPU加速计算，并构建端到端的可微分管道。多线程rollout模块的优化设计进一步提升了大规模仿真效率，而与人形机器人平衡控制案例的结合，则充分展示了MuJoCo在复杂动力学控制任务中的实际应用价值。这种技术集成不仅显著加速了强化学习和最优控制算法的开发训练过程，更为sim-to-real转移提供了高保真的仿真环境，推动了整个机器人控制领域的技术进步。

【免费下载链接】mujoco Multi-Joint dynamics with Contact. A general purpose physics simulator. 【免费下载链接】mujoco 项目地址: https://gitcode.com/GitHub_Trending/mu/mujoco

Logo
天工造物局

更多推荐

SWE-RL进阶实战：如何将奖励函数集成到你自己的强化学习训练框架

SWE-RL是首个利用开源软件演进数据与规则奖励来扩展LLM推理能力的强化学习开源项目，其官方仓库中的核心奖励函数实现堪称"即插即用"的宝藏。本文将带你完整掌握SWE-RL奖励函数的集成方法，手把手教你如何把这套基于序列相似度的奖励机制迁移到自己的强化学习训练框架中，让大模型学会像人类工程师一样修改真实代码。## 为什么你需要SWE-RL的奖励函数？在传统的RLHF训练中，奖励信号往往来自

avatar 天工造物局

告别局域网：VisionProTeleop 外部网络模式实现跨地域机器人遥操作

想让机器人遥操作摆脱同一 WiFi 的限制？开源项目 VisionProTeleop 从 v2.5 版本起推出**外部网络模式**，用一组房间码就能让 Vision Pro 与远在实验室的机器人跨地域连接，实现在家远程操控机械臂的终极体验。本文将带你快速理解其原理，并手把手完成配置。[![VisionProTeleop 状态窗口展示跨地域遥操作连接信息](https://raw.gitcode

avatar 天工造物局
cover

（AAAI 2024）SCIC：基于情境因果影响的协作多智能体强化学习

avatar 天工造物局