机器人数据集实战：用 KITTI/ROS 数据集练手 CV+SLAM

大家好，我是百晓黑！上一篇咱们用 PyTorch 搭建了轻量化目标检测模型，实现了机器人障碍物识别，但用的是模拟数据集------而工业级机器人开发，必须搞定「真实数据集」的处理。今天就聚焦机器人领域的两大核心工具：KITTI 数据集 （自动驾驶/移动机器人标杆数据集）和 ROS 工具链（机器人开发标准框架），手把手带你完成「真实数据加载→多传感器对齐→SLAM 特征提取」全流程，为后续机器人导航、定位任务打基础！

一、为什么必须掌握 KITTI/ROS 数据集？

1. 数据集定位：机器人领域的「实战教科书」

• KITTI 数据集：由德国卡尔斯鲁厄理工学院发布，是自动驾驶和移动机器人的「行业标杆数据集」------包含激光雷达、摄像头、IMU、GPS 等多传感器数据，覆盖城市道路、乡村道路等真实场景，数据标注精准（障碍物边界框、车道线、3D 点云），直接适配 SLAM、目标检测、路径规划等核心任务。
• ROS 数据集 ：ROS（机器人操作系统）是工业机器人开发的「标准工具链」，其录制的 .bag 格式数据集包含机器人各传感器的实时数据流（激光雷达、摄像头、关节状态），是机器人算法落地前的「必经练手素材」。

2. 核心应用场景

• 自动驾驶机器人：用 KITTI 数据训练 SLAM 定位模型、3D 目标检测模型；
• 工业移动机器人：用 ROS 数据集调试激光雷达-摄像头融合避障算法；
• 协作机器人：用 ROS 关节数据训练机械臂运动控制模型。

3. 学习价值

• 摆脱模拟数据的「理想场景」，适应真实数据的「噪声、异构、不同步」问题；
• 掌握多传感器数据对齐（激光雷达+摄像头），这是 SLAM 和多模态融合的核心前提；
• 熟悉 ROS 工具链，为后续机器人算法部署到真实硬件铺路。

二、实战前准备：环境搭建（5 分钟搞定）

1. 核心依赖库安装

# 基础数据处理库
pip install numpy pandas matplotlib opencv-python open3d scikit-image -i https://pypi.tuna.tsinghua.edu.cn/simple
# ROS 相关库（用于读取 .bag 文件）
pip install rospy rosbag sensor_msgs cv_bridge -i https://pypi.tuna.tsinghua.edu.cn/simple

2. 数据集准备

方案 1：KITTI 数据集（简化版，新手推荐）

KITTI 完整数据集较大（约 500GB），新手可下载「精简版目标检测数据集」（仅含图像和激光雷达数据，约 15GB）：

• 下载地址：KITTI Object Detection Dataset

• 核心文件结构：

  kitti/
  ├── training/
  │   ├── image_2/  # 彩色摄像头图像（左目）
  │   ├── velodyne/ # 激光雷达点云数据（.bin 格式）
  │   └── calib/    # 标定文件（传感器外参，用于数据对齐）
  └── testing/
      ├── image_2/
      └── velodyne/

方案 2：ROS .bag 数据集（模拟工业场景）

如果没有 KITTI 数据，可使用公开 ROS 数据集（含激光雷达+摄像头数据）：

• 下载地址：ROS 工业机器人数据集
• 或用本文提供的「ROS 数据集生成脚本」（模拟录制机器人数据）。

3. 环境验证

• 验证 ROS 库：运行 python -c "import rosbag; print('ROS bag 库安装成功')"；
• 验证 Open3D：运行 python -c "import open3d; print('Open3D 安装成功')"。

三、全流程实战：KITTI/ROS 数据集处理（代码+原理双解析）

模块 1：导入库&配置参数

import numpy as np
import cv2
import open3d as o3d
import matplotlib.pyplot as plt
import os
import rosbag
from sensor_msgs.msg import PointCloud2, Image
from cv_bridge import CvBridge
import scipy.io as sio

# 数据集路径配置（替换为你的数据集路径）
KITTI_ROOT = "kitti/training"  # KITTI 训练集路径
ROS_BAG_PATH = "robot_sensor.bag"  # ROS .bag 文件路径
CALIB_PATH = os.path.join(KITTI_ROOT, "calib/000000.txt")  # KITTI 标定文件
IMAGE_PATH = os.path.join(KITTI_ROOT, "image_2/000000.png")  # KITTI 图像文件
VELODYNE_PATH = os.path.join(KITTI_ROOT, "velodyne/000000.bin")  # KITTI 激光雷达文件

# 可视化参数
POINT_CLOUD_COLOR = [0, 0, 1]  # 激光点云颜色（蓝色）
IMAGE_POINT_COLOR = [255, 0, 0]  # 投影后点颜色（红色）

模块 2：KITTI 数据集解析（激光雷达+图像+标定文件）

KITTI 数据的核心是「多传感器标定」------需要用标定文件将激光雷达点云投影到摄像头图像上，实现数据对齐：

2.1 读取 KITTI 激光雷达数据（.bin 格式）

def read_kitti_velodyne(bin_path):
    """
    读取 KITTI 激光雷达 .bin 文件
    输出：(N, 4) NumPy 数组 → x, y, z, 反射强度
    """
    # KITTI 激光雷达数据为 float32 格式，每个点占 16 字节（4 个 float32）
    velo_data = np.fromfile(bin_path, dtype=np.float32).reshape(-1, 4)
    print(f"✅ KITTI 激光雷达数据读取完成：{velo_data.shape[0]} 个点")
    print(f"激光雷达数据样例：\n{velo_data[:5]}")
    return velo_data

# 读取激光雷达数据
velo_data = read_kitti_velodyne(VELODYNE_PATH)

2.2 读取 KITTI 摄像头图像

def read_kitti_image(img_path):
    """读取 KITTI 彩色摄像头图像（左目）"""
    img = cv2.imread(img_path)
    img_rgb = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)  # 转换为 RGB 格式（适配 matplotlib 可视化）
    print(f"✅ KITTI 图像读取完成：{img_rgb.shape}（高×宽×通道）")
    return img_rgb

# 读取图像数据
img_rgb = read_kitti_image(IMAGE_PATH)

2.3 解析 KITTI 标定文件（传感器外参）

标定文件包含「相机内参」和「激光雷达→相机的变换矩阵」，是数据对齐的关键：

def read_kitti_calib(calib_path):
    """
    解析 KITTI 标定文件，提取核心参数：
    - P2：左目相机内参矩阵（3×4）
    - Tr_velo_to_cam：激光雷达→相机的变换矩阵（3×4）
    """
    calib_dict = {}
    with open(calib_path, "r") as f:
        lines = f.readlines()
        for line in lines:
            line = line.strip().split()
            if len(line) == 0:
                continue
            key = line[0]
            value = np.array(line[1:], dtype=np.float32).reshape(-1, 4)
            calib_dict[key] = value
    
    # 提取核心参数
    P2 = calib_dict["P2"][:3, :3]  # 相机内参（3×3）
    Tr_velo_to_cam = calib_dict["Tr_velo_to_cam"][:3, :]  # 激光雷达→相机变换矩阵（3×4）
    print(f"✅ KITTI 标定文件解析完成")
    print(f"相机内参 P2：\n{P2}")
    print(f"激光雷达→相机变换矩阵 Tr_velo_to_cam：\n{Tr_velo_to_cam}")
    return P2, Tr_velo_to_cam

# 解析标定文件
P2, Tr_velo_to_cam = read_kitti_calib(CALIB_PATH)

2.4 激光雷达点云投影到摄像头图像（核心对齐操作）

利用标定矩阵，将 3D 激光点云投影到 2D 图像上，实现多传感器数据融合：

def project_velo_to_image(velo_data, P2, Tr_velo_to_cam, img_shape):
    """
    将激光雷达点云投影到摄像头图像上
    :param velo_data: 激光雷达数据 (N,4) → x,y,z,intensity
    :param P2: 相机内参（3×3）
    :param Tr_velo_to_cam: 激光雷达→相机变换矩阵（3×4）
    :param img_shape: 图像尺寸（高×宽）
    :return: 投影到图像上的点坐标 (M,2)、对应的激光点深度
    """
    # 1. 提取激光雷达 3D 坐标（x,y,z），并添加齐次坐标（1）→ (N,4)
    velo_3d = velo_data[:, :3]  # (N,3)
    velo_hom = np.hstack((velo_3d, np.ones((velo_3d.shape[0], 1), dtype=np.float32)))  # (N,4)
    
    # 2. 激光雷达→相机坐标系变换：Tr_velo_to_cam @ velo_hom.T → (3,N)
    cam_3d = Tr_velo_to_cam @ velo_hom.T  # (3,N)
    cam_3d = cam_3d.T  # (N,3)
    
    # 3. 过滤相机坐标系下 z<0 的点（在相机后方，无意义）
    valid_mask = cam_3d[:, 2] > 0
    cam_3d_valid = cam_3d[valid_mask]
    velo_intensity = velo_data[valid_mask, 3]  # 保留有效点的反射强度
    
    # 4. 相机坐标系→图像像素坐标系：P2 @ cam_3d_valid.T → (3,N)
    img_2d_hom = P2 @ cam_3d_valid.T  # (3,N)
    img_2d = img_2d_hom[:2, :] / img_2d_hom[2, :]  # 归一化，得到 (x,y) 像素坐标
    img_2d = img_2d.T.astype(np.int32)  # (N,2)
    
    # 5. 过滤超出图像范围的点
    img_h, img_w = img_shape[:2]
    img_mask = (img_2d[:, 0] >= 0) & (img_2d[:, 0] < img_w) & (img_2d[:, 1] >= 0) & (img_2d[:, 1] < img_h)
    img_2d_valid = img_2d[img_mask]
    cam_depth = cam_3d_valid[img_mask, 2]  # 有效点的深度（相机坐标系下 z 值）
    
    print(f"✅ 激光点云投影完成：{img_2d_valid.shape[0]} 个点落在图像内")
    return img_2d_valid, cam_depth

# 执行投影
img_2d_valid, cam_depth = project_velo_to_image(velo_data, P2, Tr_velo_to_cam, img_rgb.shape)

2.5 可视化 KITTI 多传感器融合结果

def visualize_kitti_fusion(img_rgb, img_2d_valid, cam_depth):
    """可视化激光雷达点云投影到图像的融合结果"""
    # 复制图像，避免修改原始数据
    img_fusion = img_rgb.copy()
    
    # 绘制投影点（用深度区分颜色深浅：越近越亮）
    for i, (x, y) in enumerate(img_2d_valid):
        depth = cam_depth[i]
        # 深度归一化到 0-255（用于调整颜色亮度）
        depth_norm = int(255 * (1 - min(depth, 50) / 50))  # 50米内的点用亮度区分
        cv2.circle(img_fusion, (x, y), 2, (0, depth_norm, 255 - depth_norm), -1)
    
    # 显示融合结果
    plt.figure(figsize=(12, 8))
    plt.subplot(1, 2, 1)
    plt.imshow(img_rgb)
    plt.title("KITTI 原始图像")
    plt.axis("off")
    
    plt.subplot(1, 2, 2)
    plt.imshow(img_fusion)
    plt.title("激光雷达点云-图像融合结果")
    plt.axis("off")
    
    plt.tight_layout()
    plt.show()

# 可视化融合结果
visualize_kitti_fusion(img_rgb, img_2d_valid, cam_depth)

模块 3：ROS .bag 数据集处理（工业机器人场景）

ROS .bag 文件是机器人传感器数据的「录像文件」，包含多话题数据流，下面教你提取激光雷达和摄像头数据：

3.1 读取 ROS .bag 文件（提取激光雷达+图像话题）

def read_ros_bag(bag_path, lidar_topic="/velodyne_points", img_topic="/camera/rgb/image_raw"):
    """
    读取 ROS .bag 文件，提取激光雷达和摄像头数据
    :return: lidar_list（激光雷达点云列表）、img_list（图像列表）
    """
    bag = rosbag.Bag(bag_path)
    lidar_list = []
    img_list = []
    bridge = CvBridge()
    
    print(f"✅ ROS .bag 文件打开成功：{bag.get_message_count()} 条消息")
    
    # 遍历所有消息
    for topic, msg, t in bag.read_messages(topics=[lidar_topic, img_topic]):
        if topic == lidar_topic:
            # 提取激光雷达点云数据（PointCloud2 → NumPy 数组）
            pc_data = np.frombuffer(msg.data, dtype=np.float32).reshape(-1, 4)
            lidar_list.append((t, pc_data))
        elif topic == img_topic:
            # 提取图像数据（Image → OpenCV 图像）
            img = bridge.imgmsg_to_cv2(msg, desired_encoding="bgr8")
            img_rgb = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)
            img_list.append((t, img_rgb))
    
    bag.close()
    print(f"✅ 提取完成：{len(lidar_list)} 帧激光雷达数据，{len(img_list)} 帧图像数据")
    return lidar_list, img_list

# 读取 ROS .bag 数据（替换为你的 .bag 文件路径）
# lidar_list, img_list = read_ros_bag(ROS_BAG_PATH)

3.2 模拟 ROS .bag 数据集（无真实文件可直接用）

def generate_sim_ros_bag(save_path="robot_sensor.bag"):
    """生成模拟 ROS .bag 数据集（含激光雷达+图像话题）"""
    import rospy
    from std_msgs.msg import Header
    from sensor_msgs.msg import PointCloud2, PointField
    import struct
    
    # 创建 .bag 文件
    bag = rosbag.Bag(save_path, "w")
    header = Header()
    header.frame_id = "base_link"
    
    # 生成 10 帧数据
    for i in range(10):
        header.stamp = rospy.Time.now()
        
        # 1. 生成模拟激光雷达数据（PointCloud2 格式）
        velo_data = np.random.randn(2000, 4) * 2  # x,y,z,intensity
        # 构造 PointCloud2 消息
        fields = [
            PointField("x", 0, PointField.FLOAT32, 1),
            PointField("y", 4, PointField.FLOAT32, 1),
            PointField("z", 8, PointField.FLOAT32, 1),
            PointField("intensity", 12, PointField.FLOAT32, 1)
        ]
        pc_msg = PointCloud2(
            header=header,
            height=1,
            width=velo_data.shape[0],
            is_dense=False,
            is_bigendian=False,
            fields=fields,
            point_step=16,
            row_step=16 * velo_data.shape[0],
            data=velo_data.tobytes()
        )
        bag.write("/velodyne_points", pc_msg, header.stamp)
        
        # 2. 生成模拟图像数据（Image 格式）
        img = np.random.randint(0, 255, (480, 640, 3), dtype=np.uint8)
        img_msg = CvBridge().cv2_to_imgmsg(img, encoding="bgr8")
        img_msg.header = header
        bag.write("/camera/rgb/image_raw", img_msg, header.stamp)
        
        print(f"生成第 {i+1}/10 帧数据")
    
    bag.close()
    print(f"✅ 模拟 ROS .bag 数据集生成完成：{save_path}")
    return save_path

# 生成模拟 ROS .bag 数据（无需真实文件）
sim_bag_path = generate_sim_ros_bag()
lidar_list, img_list = read_ros_bag(sim_bag_path)

3.3 ROS 数据对齐与可视化（按时间戳匹配）

def align_ros_data(lidar_list, img_list):
    """按时间戳对齐激光雷达和图像数据（找到时间最接近的帧对）"""
    aligned_data = []
    # 提取时间戳和数据
    lidar_timestamps = [t.to_sec() for t, pc in lidar_list]
    img_timestamps = [t.to_sec() for t, img in img_list]
    
    # 为每帧图像匹配最近的激光雷达帧
    for img_idx, (img_t, img_rgb) in enumerate(img_list):
        img_ts = img_t.to_sec()
        # 找到时间差最小的激光雷达帧
        lidar_ts_diff = np.abs(np.array(lidar_timestamps) - img_ts)
        best_lidar_idx = np.argmin(lidar_ts_diff)
        lidar_t, lidar_pc = lidar_list[best_lidar_idx]
        
        aligned_data.append((img_rgb, lidar_pc))
        print(f"对齐第 {img_idx+1} 帧：图像时间戳 {img_ts:.6f}，激光雷达时间戳 {lidar_t.to_sec():.6f}")
    
    return aligned_data

# 数据对齐
aligned_data = align_ros_data(lidar_list, img_list)

# 可视化对齐结果（第一帧）
def visualize_ros_align(aligned_data):
    """可视化 ROS 对齐后的激光雷达和图像数据"""
    img_rgb, lidar_pc = aligned_data[0]
    
    # 可视化图像
    plt.figure(figsize=(15, 6))
    plt.subplot(1, 2, 1)
    plt.imshow(img_rgb)
    plt.title("ROS 图像数据")
    plt.axis("off")
    
    # 可视化激光雷达点云（3D 视图）
    ax2 = plt.subplot(1, 2, 2, projection="3d")
    ax2.scatter(lidar_pc[:, 0], lidar_pc[:, 1], lidar_pc[:, 2], s=1, c="blue", alpha=0.5)
    ax2.set_xlabel("X (m)")
    ax2.set_ylabel("Y (m)")
    ax2.set_zlabel("Z (m)")
    ax2.set_title("ROS 激光雷达点云数据")
    
    plt.tight_layout()
    plt.show()

# 执行可视化
visualize_ros_align(aligned_data)

模块 4：SLAM 特征提取实战（基于 KITTI 数据）

SLAM（同时定位与地图构建）的核心是「提取环境特征点」，下面用 OpenCV 提取图像特征，用激光雷达提取空间特征：

4.1 图像特征提取（SIFT 算法）

def extract_image_features(img_rgb):
    """用 SIFT 算法提取图像特征点（SLAM 常用特征）"""
    # 转换为灰度图
    img_gray = cv2.cvtColor(img_rgb, cv2.COLOR_RGB2GRAY)
    # 初始化 SIFT 检测器
    sift = cv2.SIFT_create()
    # 检测特征点和描述子
    keypoints, descriptors = sift.detectAndCompute(img_gray, None)
    
    # 绘制特征点
    img_with_kp = cv2.drawKeypoints(img_rgb, keypoints, None, color=(0, 255, 0), flags=cv2.DRAW_MATCHES_FLAGS_DRAW_RICH_KEYPOINTS)
    print(f"✅ 图像特征提取完成：{len(keypoints)} 个 SIFT 特征点")
    
    return img_with_kp, keypoints, descriptors

# 提取图像特征
img_with_kp, keypoints, descriptors = extract_image_features(img_rgb)

# 可视化特征点
plt.figure(figsize=(10, 6))
plt.imshow(img_with_kp)
plt.title("KITTI 图像 SIFT 特征点")
plt.axis("off")
plt.show()

4.2 激光雷达点云特征提取（平面特征）

def extract_lidar_plane(velo_data):
    """从激光雷达点云中提取平面特征（如地面、墙面，SLAM 地图构建常用）"""
    # 转换为 Open3D 点云格式
    pcd = o3d.geometry.PointCloud()
    pcd.points = o3d.utility.Vector3dVector(velo_data[:, :3])
    
    # 平面分割（RANSAC 算法）
    plane_model, inliers = pcd.segment_plane(
        distance_threshold=0.3,  # 距离阈值
        ransac_n=3,  # 随机采样点数
        num_iterations=1000  # 迭代次数
    )
    [a, b, c, d] = plane_model
    print(f"✅ 激光雷达平面特征提取完成：平面方程 ax+by+cz+d=0 → {a:.2f}x + {b:.2f}y + {c:.2f}z + {d:.2f}=0")
    
    # 分离平面点和非平面点
    plane_pcd = pcd.select_by_index(inliers)
    non_plane_pcd = pcd.select_by_index(inliers, invert=True)
    
    # 可视化平面特征
    plane_pcd.paint_uniform_color([0, 1, 0])  # 平面点：绿色
    non_plane_pcd.paint_uniform_color([1, 0, 0])  # 非平面点：红色
    o3d.visualization.draw_geometries([plane_pcd, non_plane_pcd], window_name="激光雷达平面特征提取结果")
    
    return plane_model, plane_pcd, non_plane_pcd

# 提取激光雷达平面特征
plane_model, plane_pcd, non_plane_pcd = extract_lidar_plane(velo_data)

模块 5：工程化封装（批量处理数据集）

def batch_process_kitti(kitti_root, start_idx=0, end_idx=10):
    """批量处理 KITTI 数据集（多帧）"""
    batch_results = []
    for idx in range(start_idx, end_idx):
        # 构造文件路径（KITTI 文件名格式：000000.txt/png/bin）
        idx_str = f"{idx:06d}"
        calib_path = os.path.join(kitti_root, f"calib/{idx_str}.txt")
        img_path = os.path.join(kitti_root, f"image_2/{idx_str}.png")
        velo_path = os.path.join(kitti_root, f"velodyne/{idx_str}.bin")
        
        # 跳过不存在的文件
        if not (os.path.exists(calib_path) and os.path.exists(img_path) and os.path.exists(velo_path)):
            continue
        
        # 处理单帧数据
        velo_data = read_kitti_velodyne(velo_path)
        img_rgb = read_kitti_image(img_path)
        P2, Tr_velo_to_cam = read_kitti_calib(calib_path)
        img_2d_valid, cam_depth = project_velo_to_image(velo_data, P2, Tr_velo_to_cam, img_rgb.shape)
        
        batch_results.append({
            "idx": idx,
            "img_rgb": img_rgb,
            "velo_data": velo_data,
            "projected_points": img_2d_valid,
            "depth": cam_depth
        })
        print(f"✅ 批量处理完成第 {idx} 帧\n")
    
    return batch_results

# 批量处理 10 帧 KITTI 数据
# batch_results = batch_process_kitti(KITTI_ROOT, start_idx=0, end_idx=10)

四、运行效果预览（复制代码即可看到）

1. KITTI 数据融合效果

• 左图：KITTI 原始彩色图像；
• 右图：激光雷达点云投影后的融合图像，点的颜色随深度变化（越近越亮），清晰看到障碍物的激光点覆盖。

2. ROS 数据对齐效果

• 左图：ROS 模拟图像数据；
• 右图：3D 激光雷达点云，可旋转视角查看空间分布。

3. SLAM 特征提取效果

• 图像特征：绿色圆点标记 SIFT 特征点，覆盖图像中的角点、边缘等关键区域；
• 激光雷达平面特征：绿色点为提取的平面（如地面），红色点为非平面障碍物，可通过 Open3D 交互窗口旋转查看。

五、核心亮点（贴合机器人 SLAM 场景）

1. 真实数据适配

• 基于 KITTI/ROS 真实数据集，覆盖机器人多传感器数据处理的核心痛点（标定、对齐、噪声）；
• 代码直接适配工业级数据集格式，无需修改即可迁移到真实机器人项目。

2. 核心技术落地

• 详解激光雷达-摄像头数据对齐的数学原理（标定矩阵、投影变换），而非单纯调用工具；
• 集成 SLAM 常用特征提取算法（SIFT、RANSAC 平面分割），为后续 SLAM 建模打基础。

3. 新手友好

• 提供模拟 ROS .bag 数据集生成脚本，无需下载超大 KITTI 完整数据集；
• 代码模块化拆分，每个功能独立成函数，可按需复用（如单独提取图像特征、单独投影点云）。

4. 知识闭环

• 衔接前序知识点：NumPy 处理点云、OpenCV 处理图像、线性代数（矩阵变换）；
• 为后续文章（模型部署、SLAM 建模）铺垫核心数据处理能力。

六、高频问题解答（新手必看）

1. Q：KITTI 数据集下载太慢怎么办？

   A：

   • 用迅雷或百度网盘下载（搜索「KITTI 精简版数据集」）；
   • 只下载 training 文件夹中的 image_2、velodyne、calib 三个子文件夹（核心数据，约 15GB）。

2. Q：ROS .bag 文件读取报错「No module named 'rospy'」？

   A：

   • 确保安装了 ROS 核心库：sudo apt-get install ros-noetic-ros-base（Ubuntu 20.04 对应 Noetic 版本）；
   • 配置 ROS 环境变量：source /opt/ros/noetic/setup.bash（添加到 .bashrc 中永久生效）。

3. Q：激光雷达点云投影到图像上没有点？

   A：

   • 检查标定文件路径是否正确（确保 Tr_velo_to_cam 和 P2 矩阵非空）；
   • 过滤条件是否过严：可调整 valid_mask = cam_3d[:, 2] > 0 为 cam_3d[:, 2] > -1（允许近后方的点）。

4. Q：如何将这些数据用于 SLAM 建模？

   A：

   • 图像特征点用于「视觉里程计」（估计机器人运动轨迹）；
   • 激光雷达平面特征用于「地图构建」（生成环境三维地图）；
   • 融合后的多传感器数据可提升 SLAM 模型的定位精度和鲁棒性。

七、下一篇预告：模型部署到机器人端侧（ONNX+TensorRT）

本文我们搞定了真实机器人数据集的处理和 SLAM 特征提取，这是算法落地的「数据基础」。下一篇《模型部署：把 ML 模型装进机器人端侧（ONNX+TensorRT）》，我们会聚焦「工程化落地」，将之前训练的目标检测模型导出为 ONNX 格式，用 TensorRT 优化加速，部署到 Jetson Nano 等机器人端侧硬件，实现实时推理------核心知识点：ONNX 模型导出、TensorRT 量化压缩、端侧推理速度测试，敬请期待！

如果这篇文章对你有帮助，欢迎点赞、收藏、关注百晓黑，后续会持续输出机器人 ML 从入门到精通的实战内容！有任何问题，评论区留言交流～