乐聚机器人一面面经

面试流程

自我介绍
项目深入提问
技术细节探讨
团队协作经验

面试题及详细解答

1. CNN历史状态编码相关问题

Q1: 为什么选择CNN做历史状态编码？

回答： 选择CNN做历史状态编码的原因：

空间特征提取能力：
- CNN能够有效提取时序数据中的局部空间特征
- 对于机器人关节角度序列，可以捕捉相邻关节、相邻时间步的相关性
平移不变性：
- 对时序模式的位置变化具有鲁棒性
- 能够识别不同时间点出现的相似动作模式
参数共享：
- 减少模型参数数量，提高训练效率
- 避免过拟合，特别适合数据量有限的机器人任务
多层特征学习：
- 底层学习基本运动模式
- 高层学习复杂的时序依赖关系

Q2: 历史编码的帧数是怎么确定的？

回答： 历史帧数的确定考虑以下因素：

任务需求分析：
- 机器人运动的基本周期：如步态周期通常为0.5-1秒
- 控制延迟补偿：考虑传感器和执行器的延迟
- 预测需求：根据任务需要预测的时间范围

实验验证：

# 典型的帧数选择过程
frame_candidates = [5, 10, 20, 30, 50]  # 对应100ms到1秒的历史
performance_metrics = []

for frames in frame_candidates:
    model = CNNHistoryEncoder(history_frames=frames)
    performance = evaluate_model(model, test_data)
    performance_metrics.append(performance)

# 选择性能-效率平衡点
optimal_frames = select_optimal_frames(performance_metrics)

计算资源约束：
- 内存限制：历史帧数影响内存占用
- 实时性要求：更多历史信息增加计算延迟
经验值：
- 步态控制：通常10-20帧（200-400ms）
- 操作任务：通常5-10帧（100-200ms）
- 平衡控制：可能需要20-30帧

Q3: 历史编码能为机器人提供什么额外信息？

回答： 历史编码提供的额外信息：

运动趋势信息：
- 速度和加速度信息：通过差分获得
- 运动方向：当前运动状态的变化趋势
- 动量信息：连续运动的累积效应
上下文信息：
- 动作阶段：识别当前处于动作的哪个阶段
- 周期性模式：识别重复性的运动模式
- 状态转移：预测下一个可能的状态
稳定性增强：
- 噪声滤波：通过历史平均减少传感器噪声
- 异常检测：识别异常的运动模式
- 连续性保证：确保动作的平滑过渡
环境交互信息：
- 接触状态：通过运动变化推断与环境接触
- 外力干扰：检测外部扰动的影响
- 地形适应：根据历史调整适应不同地形

Q4: 隐变量对强化学习的意义

回答： 隐变量在强化学习中的意义：

状态表示学习：
- 将高维原始观测映射到低维隐空间
- 学习紧凑、有效的状态表示
- 提高样本效率
部分可观测性处理：
- 隐变量可以包含历史信息
- 缓解POMDP问题
- 提供更好的状态估计
知识迁移：
- 学习到的隐表示可以迁移到相关任务
- 加速新任务的学习
- 实现多任务学习
探索策略优化：
- 基于隐变量的内在激励
- 更好的探索-利用平衡
- 引导智能体探索有前途的状态区域

Q5: AMP和PPO的区别

回答： AMP (Adversarial Motion Priors) 和 PPO 的区别：

特性	PPO	AMP
目标函数	任务奖励最大化	任务奖励 + 参考动作相似性
学习方式	纯强化学习	强化学习 + 对抗学习
数据需求	需要大量探索	利用参考运动数据
动作质量	可能产生不自然的动作	生成类似人类的自然动作
收敛速度	较慢	较快（有先验知识）
应用场景	通用任务控制	动作质量要求高的任务

AMP的核心改进：

引入参考运动数据：
- 使用动作捕获数据作为先验
- 通过discriminator判断动作是否自然

对抗训练机制：

# AMP的损失函数
def amp_loss(policy_output, discriminator, reference_motion):
    # 任务奖励
    task_reward = compute_task_reward(policy_output)

    # discriminator损失
    disc_loss = -torch.log(discriminator(policy_output))  # 欺骗discriminator

    # 总损失
    total_loss = task_reward + λ * disc_loss
    return total_loss

两阶段训练：
- 第一阶段：学习参考运动的风格
- 第二阶段：在保持风格的同时优化任务性能

Q6: AMP的discriminator设计

回答： Discriminator使用的额外状态信息：

运动学特征：
- 关节位置和速度
- 末端执行器位置
- 质心位置和速度
动力学特征：
- 接触力信息
- 脚步接触状态
- 地面反作用力
上下文信息：
- 相位信息（动作周期中的位置）
- 运动风格标签
- 环境状态信息
设计原因：
- 提高判别准确性：更多信息有助于区分真实和生成动作
- 确保物理合理性：考虑物理约束和可行性
- 处理多模态：不同情况下的不同合理动作

噪声添加策略：

# 典型的噪声添加方案
def add_noise_to_discriminator_input(states, actions):
    # 对状态添加噪声
    noisy_states = states + torch.randn_like(states) * 0.01

    # 对动作添加噪声
    noisy_actions = actions + torch.randn_like(actions) * 0.02

    # 选择性噪声：只对部分维度添加
    noise_mask = torch.tensor([1, 1, 0, 0, 1])  # 示例
    noisy_actions += torch.randn_like(actions) * 0.01 * noise_mask

    return noisy_states, noisy_actions

添加噪声的目的：
- 提高模型鲁棒性
- 防止过拟合
- 平滑决策边界

2. 运动学逆解相关问题

Q1: 代码是自己写的吗？Pinocchio库使用流程

回答： Pinocchio库做逆解的典型流程：

初始化机器人模型：

import pinocchio as pin

# 加载URDF模型
model = pin.buildModelFromUrdf("robot.urdf")
data = model.createData()

# 创建几何模型（用于碰撞检测）
geom_model = pin.buildGeomFromUrdf(model, "robot.urdf")
geom_data = geom_model.createData()

正向运动学计算：

def forward_kinematics(model, data, joint_positions):
    pin.forwardKinematics(model, data, joint_positions)
    pin.updateFramePlacements(model, data)
    return data.oMf  # 所有关节的变换矩阵

逆运动学优化求解：

def inverse_kinematics(model, data, target_pose, init_q):
    # 配置优化问题
    q = init_q.copy()
    dt = 1e-1
    max_iter = 1000
    eps = 1e-6

    for i in range(max_iter):
        # 计算当前末端位姿
        pin.forwardKinematics(model, data, q)
        pin.updateFramePlacements(model, data)

        current_pose = data.oMf[target_frame]

        # 计算位姿误差
        error = pin.log6(current_pose.actInv(target_pose)).vector

        # 检查收敛
        if np.linalg.norm(error) < eps:
            break

        # 计算雅可比矩阵
        J = pin.computeFrameJacobian(model, data, q, target_frame)

        # 更新关节角度
        v = -np.linalg.pinv(J) @ error
        q = pin.integrate(model, q, v * dt)

        # 处理关节限制
        q = np.clip(q, model.lowerPositionLimit, model.upperPositionLimit)

    return q, success

Q2: 优化方法分类

回答： 运动学逆解的优化方法属于非线性优化：

问题性质：
- 目标函数：非线性（位姿误差）
- 约束：非线性（关节限制、自碰撞）
- 变量：关节角度（在李群SE(3)上）
与二次优化的对比：

二次优化（QP）：
- 目标函数：二次型
- 约束：线性
- 求解：多项式时间
非线性优化（NLP）：
- 目标函数：任意非线性
- 约束：非线性
- 求解：迭代法，局部最优

常用算法：

# 梯度下降法
def gradient_descent_ik(model, target, init_q):
    q = init_q.copy()
    lr = 0.1

    for _ in range(1000):
        # 计算当前位姿和误差
        current = compute_forward_kinematics(q)
        error = compute_pose_error(current, target)

        # 计算雅可比和梯度
        J = compute_jacobian(q)
        grad = J.T @ error

        # 更新
        q = q - lr * grad

        if np.linalg.norm(error) < 1e-6:
            break

    return q

Q3: 优化方法vs雅可比矩阵法对比

回答：

雅可比矩阵法（解析法）：

优点：
- 计算速度快
- 解的精确性高
- 实时性好
缺点：
- 需要解析求导
- 奇异性问题
- 适用范围有限

优化方法（数值法）：

优点：
- 通用性强
- 可处理复杂约束
- 避免奇异性
缺点：
- 计算量大
- 可能陷入局部最优
- 参数调节困难

异同点：

相同点：
- 都使用雅可比矩阵
- 都是迭代求解
- 都基于局部线性化

不同点：

# 雅可比矩阵法
def jacobian_method(J, error):
    # 直接求伪逆
    q_dot = np.linalg.pinv(J) @ error
    return q_dot

# 优化方法
def optimization_method(J, error, q):
    # 构建优化问题
    # min ||J·Δq + error||² + λ||Δq||²
    H = J.T @ J + λ * np.eye(J.shape[1])  # Hessian
    g = J.T @ error  # Gradient
    Δq = np.linalg.solve(H, -g)
    return Δq

3. ROS相关问题

Q1: ROS自定义消息

回答： ROS自定义消息的创建流程：

创建msg文件：

# 在package中创建msg目录
mkdir -p my_package/msg

# 创建自定义消息文件
cd my_package/msg
touch CustomMessage.msg

定义消息格式：

// CustomMessage.msg
# 标准数据类型
int32 id
float64 timestamp
string name

# 数组类型
float64[] joint_positions
uint8[10] sensor_data

# 自定义类型（需要先定义）
geometry_msgs/PoseStamped pose

# 常量
uint8 STATUS_OK = 1
uint8 STATUS_ERROR = 0

修改CMakeLists.txt：

find_package(catkin REQUIRED COMPONENTS
  roscpp
  rospy
  std_msgs
  message_generation  # 添加消息生成
)

add_message_files(
  FILES
  CustomMessage.msg
)

generate_messages(
  DEPENDENCIES
  std_msgs
  geometry_msgs
)

修改package.xml：

<build_depend>message_generation</build_depend>
<exec_depend>message_runtime</exec_depend>

编译和使用：
```
catkin_make
source devel/setup.bash
```

使用自定义消息：

#include <my_package/CustomMessage.h>

my_package::CustomMessage msg;
msg.id = 1;
msg.timestamp = ros::Time::now().toSec();
msg.joint_positions.resize(6, 0.0);

Q2: 创建ROS功能包流程

回答： 创建ROS功能包的完整流程：

创建功能包：

cd ~/catkin_ws/src
catkin_create_pkg my_package roscpp rospy std_msgs geometry_msgs

目录结构：

my_package/
├── CMakeLists.txt
├── package.xml
├── src/
├── include/
├── msg/
├── srv/
├── launch/
└── scripts/

实现节点：

// src/node.cpp
#include <ros/ros.h>

int main(int argc, char** argv) {
  ros::init(argc, argv, "my_node");
  ros::NodeHandle nh;

  // 发布者
  ros::Publisher pub = nh.advertise<sensor_msgs::JointState>("joint_states", 10);

  // 订阅者
  ros::Subscriber sub = nh.subscribe("command", 10, commandCallback);

  // 服务端
  ros::ServiceServer service = nh.advertiseService("my_service", serviceCallback);

  ros::Rate rate(100);
  while (ros::ok()) {
    // 主循环
    ros::spinOnce();
    rate.sleep();
  }

  return 0;
}

Q3: 定义的节点示例

回答： 典型的机器人控制节点设计：

状态发布节点：

class StatePublisher {
private:
  ros::Publisher state_pub_;
  ros::Timer timer_;

public:
  StatePublisher(ros::NodeHandle& nh) {
    state_pub_ = nh.advertise<sensor_msgs::JointState>("robot_state", 10);
    timer_ = nh.createTimer(ros::Duration(0.01), &StatePublisher::publishState, this);
  }

  void publishState(const ros::TimerEvent& e) {
    sensor_msgs::JointState msg;
    msg.header.stamp = ros::Time::now();
    msg.name = {"joint1", "joint2", "joint3"};
    msg.position = getCurrentJointPositions();
    msg.velocity = getCurrentJointVelocities();
    state_pub_.publish(msg);
  }
};

命令接收节点：

class CommandReceiver {
private:
  ros::Subscriber cmd_sub_;
  ros::Publisher ctrl_pub_;

public:
  CommandReceiver(ros::NodeHandle& nh) {
    cmd_sub_ = nh.subscribe("joint_commands", 10,
                           &CommandReceiver::commandCallback, this);
    ctrl_pub_ = nh.advertise<std_msgs::Float64MultiArray>("control_inputs", 10);
  }

  void commandCallback(const trajectory_msgs::JointTrajectory::ConstPtr& msg) {
    // 处理轨迹命令
    for (const auto& point : msg->points) {
      std_msgs::Float64MultiArray ctrl_msg;
      ctrl_msg.data = point.positions;
      ctrl_pub_.publish(ctrl_msg);
    }
  }
};

4. 镜像环境相关问题

Q1: 状态变量的镜像流程

回答： 机器人状态的镜像处理详细流程：

位姿镜像：

def mirror_pose(pose, axis='x'):
    """
    镜像机器人位姿
    pose: [x, y, z, qx, qy, qz, qw]
    """
    mirrored = pose.copy()

    # 位置镜像
    if axis == 'x':
        mirrored[1] *= -1  # y轴反向
    elif axis == 'y':
        mirrored[0] *= -1  # x轴反向

    # 姿态镜像（四元数）
    q = pose[3:7]  # [x, y, z, w]
    if axis == 'x':
        # 绕x轴旋转180度的四元数 [1, 0, 0, 0]
        mirror_quat = quaternion_multiply([1, 0, 0, 0], q)
    elif axis == 'y':
        # 绕y轴旋转180度的四元数 [0, 1, 0, 0]
        mirror_quat = quaternion_multiply([0, 1, 0, 0], q)

    mirrored[3:7] = mirror_quat
    return mirrored

关节角度镜像：

def mirror_joint_angles(joint_angles, joint_info):
    """
    镜像关节角度
    joint_info: 包含关节类型、对称映射等信息
    """
    mirrored = np.zeros_like(joint_angles)

    for i, (angle, info) in enumerate(zip(joint_angles, joint_info)):
        joint_type = info['type']
        symmetry_axis = info['symmetry_axis']

        if joint_type == 'hinge':
            # 转动关节：根据对称轴决定是否反向
            if symmetry_axis in ['x', 'roll']:
                mirrored[i] = angle
            else:
                mirrored[i] = -angle

        elif joint_type == 'spherical':
            # 球形关节：需要特殊处理
            mirrored[i:i+3] = mirror_spherical_joint(
                angle[i:i+3], symmetry_axis
            )

        elif joint_type == 'prismatic':
            # 移动关节：根据对称轴决定是否反向
            if symmetry_axis in ['x']:
                mirrored[i] = angle
            else:
                mirrored[i] = -angle

    return mirrored

速度镜像：

def mirror_velocity(linear_vel, angular_vel, axis='x'):
    """
    镜像速度
    linear_vel: [vx, vy, vz]
    angular_vel: [wx, wy, wz]
    """
    mirrored_linear = linear_vel.copy()
    mirrored_angular = angular_vel.copy()

    if axis == 'x':
        # 垂直于镜像轴的速度分量反向
        mirrored_linear[1] *= -1  # vy
        mirrored_linear[2] *= -1  # vz
        mirrored_angular[0] *= -1  # wx

    elif axis == 'y':
        mirrored_linear[0] *= -1  # vx
        mirrored_linear[2] *= -1  # vz
        mirrored_angular[1] *= -1  # wy

    return mirrored_linear, mirrored_angular

Q2: 加速度镜像处理

回答： 加速度的镜像处理方法：

线性加速度镜像：

def mirror_linear_acceleration(acc, axis='x'):
    """
    镜像线性加速度
    acc: [ax, ay, az]
    """
    mirrored = acc.copy()

    if axis == 'x':
        # 保持x方向，反转垂直方向
        mirrored[1] *= -1  # ay
        mirrored[2] *= -1  # az
    elif axis == 'y':
        mirrored[0] *= -1  # ax
        mirrored[2] *= -1  # az

    return mirrored

角加速度镜像：

def mirror_angular_acceleration(angular_acc, axis='x'):
    """
    镜像角加速度
    angular_acc: [αx, αy, αz]
    """
    mirrored = angular_acc.copy()

    # 角加速度遵循右手定则
    if axis == 'x':
        # 绕x轴的加速度保持不变
        # 垂直于x轴的加速度反向
        mirrored[1] *= -1  # αy
        mirrored[2] *= -1  # αz
    elif axis == 'y':
        mirrored[0] *= -1  # αx
        mirrored[2] *= -1  # αz

    return mirrored

考虑物理约束的加速度镜像：

def mirror_acceleration_with_constraints(acc, constraints, axis='x'):
    """
    考虑物理约束的加速度镜像
    """
    # 基础镜像
    mirrored = mirror_linear_acceleration(acc, axis)

    # 应用重力补偿
    if 'gravity' in constraints:
        gravity_compensation = constraints['gravity']
        mirrored = apply_gravity_compensation(mirrored, gravity_compensation)

    # 应用摩擦力模型
    if 'friction' in constraints:
        friction_model = constraints['friction']
        mirrored = apply_friction_model(mirrored, friction_model)

    # 确保加速度在合理范围内
    max_acc = constraints.get('max_acceleration', 10.0)
    mirrored = np.clip(mirrored, -max_acc, max_acc)

    return mirrored

5. Sim2Real相关问题

Q1: 主要困难

回答： Sim2Real的主要困难：

动力学差异：
- 摩擦力建模不准
- 齿轮间隙和弹性
- 执行器动力学延迟
- 能量损耗差异
感知差异：
- 传感器噪声模式不同
- 相机畸变和光照影响
- 触觉传感器响应差异
- 时间同步问题
环境不确定性：
- 地面摩擦系数变化
- 负载变化
- 温度影响
- 机械磨损
控制系统差异：
- 控制频率限制
- 量化误差
- 通信延迟
- 安全限制

Q2: 克服方法

回答： 克服Sim2Real差距的策略：

领域随机化（Domain Randomization）：

def apply_domain_randomization(simulation_params):
    # 物理参数随机化
    simulation_params['friction'] = np.random.uniform(0.3, 0.9)
    simulation_params['mass'] = np.random.uniform(0.9, 1.1) * nominal_mass
    simulation_params['damping'] = np.random.uniform(0.8, 1.2)

    # 视觉参数随机化
    simulation_params['light_intensity'] = np.random.uniform(0.5, 2.0)
    simulation_params['texture_randomization'] = True
    simulation_params['camera_noise'] = np.random.uniform(0, 0.1)

    # 控制系统随机化
    simulation_params['control_delay'] = np.random.uniform(0, 0.02)
    simulation_params['actuator_noise'] = np.random.uniform(0, 0.05)

    return simulation_params

系统识别与自适应：

class SystemIdentification:
    def __init__(self):
        self.param_history = []

    def identify_parameters(self, real_data, sim_params):
        # 使用真实数据调整仿真参数
        optimizer = ParameterOptimizer()
        adapted_params = optimizer.optimize(
            real_data, sim_params
        )
        return adapted_params

    def online_adaptation(self, current_performance):
        # 在线调整策略
        if current_performance < threshold:
            self.adapt_policy()

渐进式学习：

def progressive_training():
    # 阶段1：理想仿真环境
    train_in_perfect_simulation()

    # 阶段2：添加扰动
    train_with_mild_disturbances()

    # 阶段3：高随机性
    train_with_high_randomization()

    # 阶段4：真实世界微调
    fine_tune_in_real_world()

迁移学习：

# 预训练在仿真中
sim_model = train_policy_in_simulation()

# 迁移到真实机器人
real_model = transfer_learn(
    sim_model,
    real_world_data,
    freeze_layers=['feature_extractor']
)

6. 实习经验相关问题

回答模板：

团队规模与结构：

团队共X人，其中算法工程师Y人，机械工程师Z人，软件工程师W人
采用敏捷开发模式，每2周一个sprint

项目时间线：

第1-2周：需求分析和技术调研
- 文献调研和竞品分析
- 技术方案可行性验证
- 初步系统设计
第3-4周：算法设计和仿真验证
- 核心算法原型开发
- 仿真环境搭建
- 初步性能测试
第5-6周：系统集成和测试
- 硬件系统集成
- 软硬件联调
- 单元测试和集成测试
第7-8周：优化和部署
- 性能优化
- 鲁棒性测试
- 现场部署和验收

团队分工：

算法工程师：负责核心算法设计和优化
机械工程师：负责机械结构设计和优化
软件工程师：负责系统架构和软件开发
测试工程师：负责测试方案设计和执行

个人贡献：

技术贡献：
- 设计并实现了基于深度学习的感知算法
- 优化了运动控制算法，提高了30%的跟踪精度
- 解决了多传感器融合中的时间同步问题
团队协作：
- 主导了技术方案讨论和决策
- 协助解决跨模块集成问题
- 编写了详细的技术文档和用户手册
创新点：
- 提出了一种新的自适应控制策略
- 设计了模块化的系统架构
- 实现了快速原型验证流程

面试准备建议

项目准备：
- 深入理解每个技术细节
- 准备具体的性能数据和对比
- 思考项目的挑战和解决方案
技术原理：
- 掌握基础理论（控制理论、机器学习、机器人学）
- 理解常用算法的优缺点和适用场景
- 了解最新的研究进展
实践经验：
- 总结调试和优化经验
- 准备失败案例和教训
- 思考可改进之处
团队协作：
- 准备具体的项目协作案例
- 展示沟通和解决问题的能力
- 体现领导力和责任感

总结

乐聚机器人的面试注重：

扎实的理论基础
丰富的实践经验
深入的项目理解
良好的团队协作能力

准备时要注重细节，能够从原理到实现全面阐述自己的工作。

面试题

乐聚机器人一面面经

众擎机器人具身VLA算法面经

面试题

乐聚机器人一面面经

众擎机器人具身VLA算法面经