CNN端到端2D路径规划：从地图热力图到可执行路径

1. 项目概述：当CNN开始“看地图”找路

你有没有试过让一个图像识别模型去干一件它本不该干的事——比如，给机器人在一张二维栅格地图上规划出一条从起点到终点的可行路径？这不是在教它认猫狗，而是在逼它理解空间关系、障碍规避、起止约束，甚至隐含的“安全距离”逻辑。Davide Caffagni 这个实验，就是把卷积神经网络（CNN）从它最熟悉的图像分类战场，硬生生拉进了机器人路径规划的实战沙盘里。关键词很直白：“2D Path Planning With CNN”，核心就一句话：用纯监督学习的方式，让CNN直接输出一张“路径热力图”，而不是调用A或DLite这类经典搜索算法。它不生成代码，不展开搜索树，它只“画”一张图——图上每个像素的亮度，代表这个位置属于最优路径的概率。你拿到这张图，再用一个极简的贪心搜索（比如8邻域选最高分），就能走出一条路来。

这背后藏着一个非常现实的工程矛盾：传统算法（如D* Lite）保证最优性、可解释、鲁棒性强，但计算开销大，难以实时嵌入资源受限的嵌入式系统；而端到端的深度学习模型，推理快、可部署、能泛化，但黑盒、难调试、结果不可控。Caffagni 的尝试，不是为了立刻取代D* Lite，而是想验证一个朴素想法：CNN能否学会从海量“地图-起点-终点-真值路径”的样本中，自动归纳出路径规划的底层几何与拓扑规则？他没用强化学习那种试错反馈，也没用图神经网络（GNN）这种更贴合图结构的模型，就用最基础的CNN，靠数据“喂”出空间直觉。这个思路对刚入门机器人感知与决策交叉领域的工程师特别有启发——它告诉你，有时候最“笨”的方法，反而最能暴露问题的本质。你不需要是算法专家，只要懂PyTorch和OpenCV，就能复现、调试、甚至改进它。它解决的不是一个工业级难题，而是一个认知门槛：如何让AI真正“看见”空间中的约束与连接。

2. 整体设计思路与方案选型解析

2.1 为什么是CNN？又为什么不能只是CNN？

初看这个标题，很多人会本能质疑：CNN天生是为图像设计的，而路径规划是典型的图搜索问题，两者范式完全不同。这质疑非常合理，也正是整个项目设计的起点。Caffagni 没有回避这个根本矛盾，而是把它拆解成了两个层面：表征层和决策层。

在表征层，CNN是无可争议的王者。一张100×100的占用栅格地图，本质上就是一张二值灰度图——障碍物是白色（1），自由空间是黑色（0）。CNN的卷积核天然擅长提取局部模式：一条直线障碍的边缘、一个L形拐角、一片开阔区域的纹理。这些模式，恰恰是路径规划者需要关注的“地形特征”。所以，用CNN处理输入地图，在数据表征上是高效且合理的。问题出在决策层：标准CNN的输出是一个分类标签（猫/狗）或一个分割掩码（哪些像素属于目标），而路径是一条有序的、连通的、具有方向性的点序列。直接让CNN输出一个100×100的“是否属于路径”的二值图，会丢失路径的连通性约束——模型可能高亮了所有“看起来像路径”的孤立点，却无法保证它们首尾相接。

Caffagni 的破局点，是把“决策”任务降维成“打分”任务。他不要求CNN输出一条精确的路径，只要求它输出一张连续的、概率化的分数图（score map）。这张图上，越靠近真实路径的位置，分数越高；越远离或位于障碍物上的位置，分数越低。最终的路径，由一个轻量级的、确定性的后处理算法（双向搜索）从这张图上“读取”出来。这就巧妙地绕开了CNN在序列建模上的短板，把最棘手的“连通性保证”交给了一个可控、可验证的传统算法，而把最耗时的“空间关系理解”交给了CNN。这是一种典型的“混合架构”思想：用深度学习做感知（Perception），用经典算法做规划（Planning），各司其职。这比强行训练一个RNN或Transformer去输出坐标序列要稳健得多，也更符合实际机器人系统的模块化设计哲学。

2.2 为什么放弃A*，坚持用D* Lite作为真值生成器？

数据是模型的粮食，而真值（Ground Truth）就是这粮食的“营养标准”。Caffagni 选择D* Lite而非更常见的A*，绝非偶然，而是源于一个非常具体的工程痛点：机器人物理尺寸带来的安全裕度（Safety Margin）。他在原文中坦率提到，自己之前的机器人项目里，A规划出的路径紧贴墙壁，导致机器人频繁碰撞。A追求的是数学意义上的最短路径，它把机器人抽象成一个质点，完全忽略了机器人的实际体积和运动学约束。

D* Lite是一种增量式重规划算法，它在动态环境中表现更优，但Caffagni 真正看重的是它的可定制性。他写了一个“魔改版”D* Lite，强制要求路径必须与所有障碍物保持至少1个栅格单元的距离。这个看似微小的修改，彻底改变了数据的语义：模型学到的不再是“穿过缝隙”的极限操作，而是“绕行缓冲区”的安全行为。这使得训练出的CNN，其内在的“空间直觉”天然包含了安全意识。如果你直接拿A*的真值去训练，模型可能会学会一种危险的、紧贴障碍的“走钢丝”策略，这在真实世界中是灾难性的。这个选择深刻体现了从业者的务实精神：算法选型永远服务于最终落地场景，而不是论文指标。一个为实验室仿真优化的模型，和一个为真实机器人底盘服务的模型，其数据生成逻辑必须有本质区别。

2.3 为什么是U-Net式编码器-解码器，而不是简单的分类网络？

当你决定用CNN输出一张“分数图”时，网络架构的选择就至关重要。一个最简单的思路，是把地图、起点、终点拼成一个三通道输入，然后接一堆全连接层，最后输出100×100个分数。但这会带来两个致命问题：一是参数爆炸（100×100×100×100），二是完全丢失了空间局部性。Caffagni 选择了经典的编码器-解码器（Encoder-Decoder）结构，这并非跟风，而是有坚实的工程依据。

编码器（Encoder）的作用，是把高分辨率、低语义的原始地图，逐步压缩成一个低分辨率、高语义的“空间摘要向量”。它通过多层卷积和池化，丢弃掉无关的细节（比如单个障碍物像素的精确位置），保留住关键的拓扑信息（比如“这是一个被障碍物包围的环形区域”）。解码器（Decoder）则相反，它把这个浓缩的摘要，一步步“展开”回原始分辨率，同时注入被编码器丢弃的精细空间信息，最终生成一张细节丰富的分数图。这个过程，就像一个经验丰富的老司机，先在脑海中构建一个城市的宏观路网骨架（编码），再根据具体目的地，回忆起每条小巷的宽度和转弯半径（解码），从而规划出一条既高效又安全的路线。

而U-Net的核心创新——跳跃连接（Skip Connection），则是解决“细节丢失”问题的神来之笔。在标准编码器-解码器中，解码器在上采样时，会不可避免地模糊掉一些关键的精确定位信息，比如起点和终点的精确坐标。跳跃连接直接把编码器某一层的特征图（例如，经过第一次下采样后的50×50特征图），原封不动地“嫁接”到解码器对应尺度的特征图上。这就相当于给解码器提供了一份“高清地图副本”，让它在重建分数图时，能精准地锚定s和g的位置。Caffagni 在实验中发现，没有跳跃连接时，模型训练缓慢且效果差；加上之后，收敛速度和最终精度都有显著提升。这再次印证了一个朴素真理：在空间任务中，位置信息就是一切。任何能精确传递位置信息的设计，都是值得投入的。

3. 核心细节解析与实操要点

3.1 数据集构建：从随机噪声到“有难度”的地图

数据是这个项目的基石，也是最耗时、最考验工程耐心的部分。Caffagni 面临的第一个难题是：去哪里找23万张带标注的路径规划地图？答案是：没有现成的，那就自己造。他的造数据流程，堪称一个小型的“地图生成工厂”，其精妙之处在于对“难度”的可控调节。

整个流程始于一个100×100的全零矩阵。核心参数是diff，它不是一个简单的障碍物密度，而是一个障碍生成阈值。对矩阵中每一个像素，生成一个[0,1]间的均匀随机数r，如果r >diff，则设为障碍（1）；否则为自由空间（0）。这里的关键洞察是：diff越小，障碍物越多，地图越“稠密”，路径规划的难度自然越大。但仅仅靠随机点，生成的地图会像一锅撒了盐的粥，全是噪点，缺乏真实感。于是，他引入了形态学开运算（Morphological Opening）。开运算是先腐蚀后膨胀，其效果是“消除小的亮点（孤立障碍）”和“平滑大的障碍物轮廓”。通过调整开运算的结构元素（Structuring Element）大小，可以控制障碍物的“块状感”。一个3×3的方块结构元，会让障碍物边缘变得圆润；一个7×7的，则会产生大片的、连贯的墙体。这一步，把随机噪声转化成了具有真实感的、可变复杂度的“城市街区”或“迷宫”。

生成地图后，起点s和终点g的选取同样有讲究。不能随便点两个位置，因为如果它们离得太近，D* Lite几乎瞬间就能找到一条直线路径，这样的样本对模型毫无学习价值。因此，他设定了一个欧氏距离阈值，只有当s和g的距离大于该阈值时，才认为这是一个“有挑战性”的样本。这确保了数据集的“信息熵”足够高，模型必须学会绕过障碍，而不是简单地走直线。

最后，真值路径的生成，是整个数据流水线的“质检站”。Caffagni 的自定义D* Lite不仅加入了1栅格的安全距离，还处理了一个棘手的边界情况：当g恰好落在障碍物上时，算法不会报错，而是自动将真值路径的终点，设置为距离g最近的、可达的自由空间点。这个细节非常重要，它让模型学会了处理“目标不可达”的现实场景，而不是在一个理想化的、所有目标都必然可达的假设下训练。这种对现实世界不确定性的包容，是区分一个玩具项目和一个可用原型的关键。

3.2 输入特征工程：从1通道到3通道的“空间意识”注入

这是整个项目最具原创性和启发性的技术点。Caffagni 发现，直接把100×100的二值地图（1通道）喂给CNN，效果惨不忍睹。原因正如他所分析的：CNN的卷积核是“位置不变”的，它只关心“是什么图案”，不关心“这个图案在哪儿”。对于路径规划，s和g的绝对坐标就是一切。一个在左上角的起点和一个在右下角的起点，对CNN来说，是完全不同的输入，它必须为每一种可能的位置组合都学习一套独立的权重，这在计算上是不可行的。

他的解决方案，是抛弃全局的、绝对的位置编码（如Transformer里的正弦波编码），转而采用一种相对的、任务驱动的高斯编码（Gaussian Encoding）。他为输入地图增加了两个额外的通道，使输入从[1, 100, 100]变成了[3, 100, 100]：

• 通道0（原始地图）：[100, 100]的二值图，障碍=1，自由=0。
• 通道1（起点高斯图）：一个[100, 100]的浮点图，其中心位于起点s的坐标(sx, sy)，其值由二维高斯函数计算：exp(-((x-sx)^2 + (y-sy)^2) / (2 * sigma^2))。sigma被设为20，这意味着距离s越近，值越高，形成一个以s为中心的“热力山丘”。
• 通道2（终点高斯图）：同理，中心位于g，使用相同的高斯函数。

这种设计的智慧在于，它把一个关于“绝对位置”的问题，转化为了一个关于“相对距离”的问题。CNN的卷积核现在学习的，不再是“在(45,89)处有一个障碍”，而是“在距离起点约34个像素、距离终点约15个像素的地方，有一个障碍”。这个模式是位置不变的：无论s和g在地图的哪个角落，只要一个像素满足同样的相对距离关系，它就会触发卷积核同样的响应。这完美地兼容了CNN的固有特性，同时又注入了最关键的路径规划先验知识。你可以把它想象成给CNN配了一副“空间导航眼镜”，眼镜上刻着两圈同心圆，一圈以s为圆心，一圈以g为圆心，CNN看到的，永远是这两圈圆的交叠区域。

3.3 模型架构详解：20层卷积的“空间压缩-解压”引擎

Caffagni 的模型是一个高度定制化的U-Net变体，其设计处处体现着对任务的理解。整个网络共20层卷积，分为清晰的三段：编码器（3个block）、瓶颈（2层）、解码器（3个block），最后是输出层。

每个编码器block包含3个3×3卷积层，中间夹着批归一化（BatchNorm）和ReLU激活。卷积层负责特征提取，BatchNorm稳定训练，ReLU引入非线性。最关键的是，每个block之后都跟着一个2×2的最大池化（MaxPooling）层，它将特征图的宽高各减半，实现空间维度的压缩。例如，输入是[100, 100]，经过第一个block和池化后，变成[50, 50]；第二个后是[25, 25]；第三个后是[12, 12]（由于100/2/2/2=12.5，实际会向下取整）。这个过程，就是将一张“高清地图”逐步提炼成一个“城市交通概览图”。

瓶颈层（Bottleneck）是整个网络的“大脑”，它接收来自编码器的[12, 12]特征图，并对其进行两次3×3卷积。这里没有池化，也没有上采样，它纯粹是在这个高度压缩的空间里，进行最深层次的语义融合，试图理解“起点”、“终点”和“障碍物分布”三者之间最本质的几何关系。

解码器则执行逆向操作。每个解码器block也包含3个3×3卷积层，但其前导操作是转置卷积（Transposed Convolution），也叫反卷积。它不是像池化那样缩小，而是像“放大镜”一样，将[12, 12]的特征图逐步恢复到[25, 25]、[50, 50]，最终回到[100, 100]。在每次转置卷积之前，它会将对应编码器block的特征图（例如，[50, 50]的那个）通过跳跃连接“拼接”（Concatenate）进来。这个拼接操作，是U-Net的灵魂。它把被压缩丢弃的、关于s和g精确坐标的“高清细节”，重新注入到正在被“脑补”的解码过程中，确保最终输出的分数图，其峰值能精准地落在s和g附近，并沿着一条合理的轨迹连接起来。

最后的输出层，是一个1×1的卷积，它把解码器输出的多通道特征图，压缩成一个单通道的[100, 100]分数图。紧接着是一个Sigmoid激活函数，将所有分数强制映射到[0, 1]区间，使其具备概率解释性。这个设计，让整个网络成为一个端到端的、可微分的“空间关系理解器”。

4. 实操过程与核心环节实现

4.1 环境搭建与依赖安装：从零开始的Python环境

要复现这个项目，第一步是搭建一个干净、可复现的Python环境。Caffagni 使用的是PyTorch生态，因此我们推荐使用conda来管理环境，因为它能更好地处理CUDA等底层依赖。

# 创建一个名为'pathplanning'的新环境，指定Python版本 conda create -n pathplanning python=3.8 # 激活环境 conda activate pathplanning # 安装核心库：PyTorch（请根据你的CUDA版本选择合适的命令） # 例如，对于CUDA 11.3，运行： pip install torch==1.10.2+cu113 torchvision==0.11.3+cu113 torchaudio==0.10.2+cu113 -f https://download.pytorch.org/whl/torch_stable.html # 安装其他必需库 pip install numpy opencv-python matplotlib scikit-image tqdm # 如果你想使用作者提供的Kaggle数据集，还需要安装kaggle API pip install kaggle

提示：务必检查你的GPU驱动和CUDA版本。在终端输入nvidia-smi可以查看驱动版本，nvcc --version可以查看CUDA编译器版本。PyTorch官网的安装页面提供了针对不同组合的精确安装命令，切勿盲目复制粘贴。

4.2 数据集加载与预处理：将Kaggle数据变为PyTorch张量

Caffagni 将数据集上传到了Kaggle，我们可以直接下载。假设你已经通过Kaggle API配置好了认证，下载并解压后，数据目录结构大致如下：

dataset/ ├── train/ │ ├── maps/ │ ├── starts.npy │ └── goals.npy ├── val/ │ └── ... └── test/ └── ...

我们需要编写一个自定义的Dataset类，来优雅地加载这些数据。核心在于__getitem__方法，它需要完成以下几步：

1. 读取地图：使用cv2.imread或np.load读取.npy格式的地图文件，得到一个[100, 100]的numpy数组。
2. 构建三通道输入：创建一个形状为(3, 100, 100)的空numpy数组。将原始地图填入第0通道。然后，根据该样本对应的起点坐标s（从starts.npy中读取），用scipy.ndimage.gaussian_filter或手动计算，生成一个以s为中心的高斯图，填入第1通道。同理，用终点g生成高斯图，填入第2通道。
3. 构建真值标签：读取该地图对应的D* Lite真值路径（通常存储为一系列坐标点的列表）。创建一个全零的[100, 100]数组，将路径上每一个点的坐标位置设为1。这就是我们的监督信号。
4. 类型转换与归一化：将numpy数组转换为torch.Tensor，并将输入地图的值从[0, 1]归一化到[0, 1]（如果是uint8，需除以255），真值标签保持为float32。

import torch import numpy as np from torch.utils.data import Dataset from scipy.ndimage import gaussian_filter class PathPlanningDataset(Dataset): def __init__(self, map_dir, start_file, goal_file, path_file, transform=None): self.map_dir = map_dir self.starts = np.load(start_file) self.goals = np.load(goal_file) self.paths = np.load(path_file) # 假设paths.npy是一个list of lists self.transform = transform def __len__(self): return len(self.starts) def __getitem__(self, idx): # 1. Load map map_path = f"{self.map_dir}/map_{idx:06d}.npy" map_data = np.load(map_path).astype(np.float32) # [100, 100] # 2. Build 3-channel input input_tensor = np.zeros((3, 100, 100), dtype=np.float32) input_tensor[0] = map_data # Get start and goal coordinates s_x, s_y = int(self.starts[idx][0]), int(self.starts[idx][1]) g_x, g_y = int(self.goals[idx][0]), int(self.goals[idx][1]) # Create Gaussian for start start_gauss = np.zeros((100, 100)) start_gauss[s_y, s_x] = 1.0 # Center point start_gauss = gaussian_filter(start_gauss, sigma=20.0) input_tensor[1] = start_gauss # Create Gaussian for goal (same process) goal_gauss = np.zeros((100, 100)) goal_gauss[g_y, g_x] = 1.0 goal_gauss = gaussian_filter(goal_gauss, sigma=20.0) input_tensor[2] = goal_gauss # 3. Build ground truth label gt_map = np.zeros((100, 100), dtype=np.float32) for (x, y) in self.paths[idx]: if 0 <= x < 100 and 0 <= y < 100: gt_map[y, x] = 1.0 # 注意OpenCV坐标系：y是行，x是列 # 4. Convert to tensors input_tensor = torch.from_numpy(input_tensor) gt_map = torch.from_numpy(gt_map) return input_tensor, gt_map

注意：这段代码只是一个骨架，实际使用时需要根据你数据集的具体格式进行调整。关键点在于gaussian_filter的sigma参数必须严格设为20，以匹配原文设定。坐标索引时要注意[y, x]的顺序，这是图像处理的标准。

4.3 模型训练循环：损失、优化与调度的艺术

训练的核心在于定义一个稳健的训练循环。Caffagni 使用了均方误差（MSE）损失，这是一个合理的选择，因为它直接惩罚了预测分数图与真值二值图之间的像素级差异。

import torch import torch.nn as nn import torch.optim as optim from torch.optim.lr_scheduler import CosineAnnealingWarmRestarts # 初始化模型、损失函数和优化器 model = UNetPathPlanner() # 你的U-Net模型实例 criterion = nn.MSELoss() optimizer = optim.Adam(model.parameters(), lr=0.001) scheduler = CosineAnnealingWarmRestarts(optimizer, T_0=5, T_mult=2, eta_min=1e-6) # 训练循环 num_epochs = 23 for epoch in range(num_epochs): model.train() total_loss = 0.0 for batch_idx, (data, target) in enumerate(train_loader): # Move data to GPU if available data, target = data.cuda(), target.cuda() # Forward pass output = model(data) # output shape: [batch, 1, 100, 100] loss = criterion(output.squeeze(1), target) # squeeze to match target's [batch, 100, 100] # Backward pass optimizer.zero_grad() loss.backward() optimizer.step() total_loss += loss.item() # Update learning rate scheduler.step() # Print epoch summary avg_loss = total_loss / len(train_loader) print(f"Epoch {epoch+1}/{num_epochs}, Average Loss: {avg_loss:.6f}")

这里有几个关键的实操心得：

• 学习率调度：CosineAnnealingWarmRestarts是一个非常强大的调度器。它让学习率在一个周期内从初始值平滑下降到最小值，然后“热重启”回一个稍低的初始值，开始下一个周期。这有助于模型跳出局部最优，探索更优的解空间。T_0=5表示第一个周期是5个epoch，T_mult=2表示后续周期长度翻倍（5, 10, 20...）。
• 梯度裁剪（Gradient Clipping）：在训练深度网络时，梯度爆炸是一个常见问题。虽然原文未提及，但在实践中，强烈建议在optimizer.step()之前加入torch.nn.utils.clip_grad_norm_(model.parameters(), max_norm=1.0)，这能极大提升训练的稳定性。
• 混合精度训练（AMP）：如果你的GPU支持（如RTX 30系列及以上），使用torch.cuda.amp可以将训练速度提升近一倍，同时减少显存占用。只需在forward和backward部分包裹autocast和GradScaler即可。

4.4 路径解码与可视化：从分数图到可行走的轨迹

模型的输出是一张[100, 100]的分数图，但这还不是一条路径。Caffagni 使用了双向搜索（Bidirectional Search）来解码它。这是一种极其高效的贪心算法，其思想是：从起点s出发，向周围8个邻居中分数最高的那个移动；同时，从终点g出发，也向周围8个邻居中分数最高的那个移动；当两个搜索前沿相遇时，路径即告完成。

def decode_path(score_map, start, goal, max_steps=1000): """ score_map: [100, 100] numpy array of scores start, goal: (x, y) tuples """ # Initialize paths forward_path = [start] backward_path = [goal] current_forward = start current_backward = goal # 8-directional neighbors directions = [(-1,-1), (-1,0), (-1,1), (0,-1), (0,1), (1,-1), (1,0), (1,1)] for step in range(max_steps): # Expand forward best_score = -1 best_next = None for dx, dy in directions: nx, ny = current_forward[0] + dx, current_forward[1] + dy if 0 <= nx < 100 and 0 <= ny < 100: if score_map[ny, nx] > best_score: # 注意y,x顺序 best_score = score_map[ny, nx] best_next = (nx, ny) if best_next is None or best_next in backward_path: break forward_path.append(best_next) current_forward = best_next # Expand backward (same logic) best_score = -1 best_next = None for dx, dy in directions: nx, ny = current_backward[0] + dx, current_backward[1] + dy if 0 <= nx < 100 and 0 <= ny < 100: if score_map[ny, nx] > best_score: best_score = score_map[ny, nx] best_next = (nx, ny) if best_next is None or best_next in forward_path: break backward_path.append(best_next) current_backward = best_next # Combine paths backward_path.reverse() full_path = forward_path + backward_path return full_path # Visualization import matplotlib.pyplot as plt def plot_comparison(original_map, pred_path, gt_path, title=""): fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(12, 5)) ax1.imshow(original_map, cmap='gray') ax1.plot([p[0] for p in pred_path], [p[1] for p in pred_path], 'r-', linewidth=2, label='CNN Path') ax1.scatter([pred_path[0][0]], [pred_path[0][1]], c='green', s=100, label='Start') ax1.scatter([pred_path[-1][0]], [pred_path[-1][1]], c='red', s=100, label='Goal') ax1.set_title('CNN Prediction') ax1.legend() ax2.imshow(original_map, cmap='gray') ax2.plot([p[0] for p in gt_path], [p[1] for p in gt_path], 'b-', linewidth=2, label='D* Lite GT') ax2.scatter([gt_path[0][0]], [gt_path[0][1]], c='green', s=100, label='Start') ax2.scatter([gt_path[-1][0]], [gt_path[-1][1]], c='red', s=100, label='Goal') ax2.set_title('Ground Truth') ax2.legend() plt.suptitle(title) plt.show()

注意：decode_path函数中的坐标索引score_map[ny, nx]必须遵循图像坐标系（行，列），这与数学坐标系（x, y）是相反的。这是新手最容易踩的坑之一，会导致路径完全错乱。可视化函数plot_comparison能让你一眼看出CNN预测路径与真值路径的差异，是调试过程中不可或缺的工具。

5. 常见问题与排查技巧实录

5.1 训练不收敛：损失曲线“躺平”或剧烈震荡

这是复现过程中最常遇到的问题，其根源往往不在模型本身，而在数据或训练配置上。

5.2 预测路径“穿墙”：模型无视障碍物

这是路径规划任务中最危险的失败模式。模型输出的分数图，其高分区域竟然大面积覆盖在障碍物上。

5.3 推理速度慢：单张地图解码耗时超过1秒

在实时机器人应用中，路径规划必须在毫秒级完成。如果解码一张地图需要几秒，那这个模型就失去了实用价值。

|