LR-ASPP+MobileNetV3迁移学习实现道路图像语义分割，10个epoch验证集IoU达0.98

简介：在自动驾驶与道路场景理解中，语义分割是关键环节。基于MobileNet v3的LR-ASPP道路图像语义分割实战包，主要面向计算机视觉初学者与轻量级模型应用开发者，解决从数据集准备、训练脚本到可用权重的一站式复现问题。压缩包内含2000个文件，其中绝大多数为PNG/JPG道路图片，并搭配少量Python脚本、txt标签/说明文件与pth模型权重，整体约99.62MB。作者采用迁移学习训练10个epoch，验证集IoU达到0.98，说明该模型收敛快且精度理想；数据按视频帧组织，便于观察连续场景下的分割稳定性，脚本与权重配合可完成从单图推理到批量测试的完整流程，txt文件辅助核对标签类别，显著降低上手门槛。已有259人浏览学习，适合想快速入门移动端语义分割、复现高精度结果或扩充自身数据集的用户。

1. 道路图像语义分割实战：LR-ASPP（MobileNet v3）迁移学习，10 个 epoch 验证集 IoU 0.98

这两年做道路图像语义分割的人越来越多，但真正能落到低算力设备上的方案不多。这份资源的核心组合是 LR-ASPP 分割头加 MobileNet v3 骨干，走迁移学习路线只训练了 10 个 epoch，验证集 IoU 就跑到 0.98。数据来自 Roboflow 导出的道路视频抽帧，帧内容覆盖道路、车道线、车辆和行人，标注齐全，可以直接进训练流程。适合正在做自动驾驶感知、车道级导航、道路巡检的工程团队：模型轻、收敛快，后续做 ONNX 或 TensorRT 部署都有回旋余地。接下来我按模型选型、数据处理、训练配置、避坑的顺序，把完整落地方案拆开讲。

2. 模型选型与迁移学习原理：LR-ASPP 的分支设计，为什么不直接上 FCN

2.1 从 ASPP 到 LR-ASPP：分割头减负之后发生了什么

做语义分割的都知道，单纯靠分类骨干输出的特征图上采样回去，边缘和细节基本是糊的，这是 FCN 系列的老问题。后来 Deeplab 系列引入了 ASPP（Atrous Spatial Pyramid Pooling），用一组不同膨胀率的空洞卷积并行提取多尺度上下文，效果确实好，但四个分支叠加下来计算量不小。LR-ASPP 的思路是：把 ASPP 里多个膨胀卷积分支砍成两个——一个 1x1 卷积，一个 3x3 空洞卷积，膨胀率固定取 24，两个分支输出加到一起，再和低层特征做 shortcut。这个设计来自 MobileNetV3 论文的语义分割部分，目的是在轻量骨干上保住多尺度感受野，又尽量砍掉冗余分支。

膨胀率 24 这个参数不是拍脑袋定的。MobileNet v3 骨干输出是原图的 1/16，在 1/16 分辨率上，3x3 卷积膨胀 24 之后覆盖范围大约是 3 + 2×24 = 51 像素跨度，对 512x512 输入来说已经够到远处的道路、车辆上下文。膨胀率太小感受野不够，太大边缘全是空洞，分割边界会飘。

这里直接给一个可运行的 LRASPP 分割头示意实现，后续训练就是挂这个头：

import torch import torch.nn as nn import torch.nn.functional as F class LRASPPHead(nn.Module): def __init__(self, high_channels=960, low_channels=24, num_classes=8, dilation=24): super().__init__() self.branch1 = nn.Conv2d(high_channels, 128, 1, bias=False) self.branch2 = nn.Conv2d(high_channels, 128, 3, padding=dilation, dilation=dilation, bias=False) self.compress = nn.Conv2d(low_channels, 48, 1, bias=False) self.classifier = nn.Conv2d(128 + 48, num_classes, 1) def forward(self, high, low): h = self.branch1(high) + self.branch2(high) h = F.relu(h, inplace=True) h = F.interpolate(h, size=low.shape[-2:], mode="bilinear", align_corners=False) low = self.compress(low) return self.classifier(torch.cat([h, low], dim=1))

代码里high是 MobileNet v3 骨干输出特征，形状大致是(B, 960, H/16, W/16)；low是骨干早期层输出，形状是(B, 24, H/4, W/4)，通道数 24 是 MobileNetV3-Large 第二个 stage 的固定输出。1x1 卷积和膨胀卷积各自把 960 通道压到 128，相加后上采样到低层特征尺寸，再和压缩到 48 通道的低层特征拼接，最后 1x1 卷积出类别。整个头只有三层卷积，显存占用非常小，这是 LR-ASPP 能跑进实时推理的核心原因。

2.2 MobileNet v3 骨干和预训练权重：迁移学习的第一个选择点

LR-ASPP 是论文里的分割头，骨干选 MobileNetV3-Large 而不是 Small，是因为 Large 的输出通道和特征表达能力更强，在道路这种结构复杂又频繁出现小物体的场景里会稳很多。实际用的时候，torchvision 里只有deeplabv3_mobilenet_v3_large，它挂的是标准 ASPP 头；要复现这份资源的 LR-ASPP 组合，通常有两种做法：一种是把第 2.1 节这个 Head 直接接到 MobileNetV3-Large 的features输出上，另一种是打开 mmsegmentation 里现成的LRASPP配置改参数。我一般用第一种，因为依赖少、导出方便。

迁移学习的入口是预训练权重。这里要分清楚两件事：只用 ImageNet 预训练初始化骨干，和你拿着 Cityscapes 上训练好的整套分割模型继续微调，收敛速度差很多。Cityscapes 本身是驾驶场景，里面有道路、车道线、车辆、行人，和这份道路视频帧的分布非常接近，所以最省事的路线是：先跑一遍两份预训练权重的对比。常见做法是先加载 MobileNetV3 的 ImageNet 分类权重，把features部分拿过来当 backbone，头部随机初始化；如果你的训练时间卡得非常紧，再考虑找一套在 Cityscapes 上训练过的 LR-ASPP 权重做起点。加载骨干的代码很直接：

from torchvision.models import mobilenet_v3_large, MobileNet_V3_Large_Weights backbone = mobilenet_v3_large(weights=MobileNet_V3_Large_Weights.DEFAULT) backbone = backbone.features # (B, 960, H/16, W/16) backbone = backbone.eval().cuda()

注意这里不要带上原来的分类器，分割任务只需要features输出特征图。MobileNet_V3_Large_Weights.DEFAULT是官方在 ImageNet-1k 上训练的分类权重，拿来初始化骨干没问题。如果你的显存很紧张，可以把features里前 6 层的requires_grad设成 False，只微调后面高层和新增的 LRASPPHead，这样显存能省出一截，而且在小数据上不容易过拟合。

2.3 迁移学习在道路分割上的收敛逻辑：为什么 10 个 epoch 就能到 0.98

很多人看到 0.98 的第一反应是“是不是数据集太小或者过拟合了”。确实要冷静看，但也别低估迁移学习的收益。预训练骨干已经在百万级图片上见过大量纹理、边缘、光照变化，道路分割需要的大部分底层视觉特征早就学完了，我们真正要解决的只是“把高层语义映射到 5 到 8 个类别”这个相对简单的决策边界。所以从头训练要两百个 epoch，迁移学习 10 个 epoch 收敛是常态，不是玄学。

另一个容易被忽略的点是类别像素分布。道路图像里道路和背景本身占了大比例像素，即使模型把车辆、行人这些小目标预测得不太好，整体 IoU 也会被拉高。所以 0.98 是一个“验证集整体 IoU”，它说明模型整体分割能力强，但不能等价于每个类别都完美。真要下结论，得看每一类的 IoU 列表，第 4 章我会写怎么把这个列表拉出来。理解了这个边界，后面才不会因为一个数字盲目自信。

3. 数据准备与预处理：从 Roboflow 抽帧到 Pytorch Dataset

3.1 看懂 frame508_jpg.rf.xxxx 这类文件和标注格式

这份资源的原始数据是视频抽帧，文件名形如frame508_jpg.rf.0616a3ff...jpg。拆开看：frame508是视频第 508 帧，_jpg是 Roboflow 导出时对图像格式的标记，后面那串十六进制是它在 Roboflow 工作区的唯一 ID。如果你下载过 Roboflow 的语义分割导出包，会看到图片旁边的标注是 PNG 格式的 mask，文件名基本和图片一一对应。

拿到数据第一件事不是急着训练，而是确认标注到底是什么形态。Roboflow 导出时有两种可能：一种是单通道索引图，像素值直接是类别 ID，用np.unique就能看到类别数；另一种是 RGB 可视化图，每个类别映射到一种固定颜色，这种情况要先转成索引。我习惯先跑一段检查：

from PIL import Image import numpy as np mask = np.array(Image.open("data/val/masks/frame508.png")) print("shape:", mask.shape) print("unique label id:", np.unique(mask))

如果输出是[ 0 1 2 3 4 ]，说明这是单通道索引图，类别 ID 从 0 开始，可以直接进训练。如果看到的是[ 0 255]或者一堆三位数，那大概率是 RGB 图或者带了 ignore 标记，需要先把 255 这类无效像素单独处理。道路分割里最常见的 ignore 值是 255，训练时 loss 里要设置ignore_index=255，否则边界标注不准的像素会把梯度搞乱。

3.2 类别映射：把原始标注合并成分类目标

视频帧里物体类别可能比你要的多。比如原始标注里有“摩托车”“自行车”“公交车”，你的任务只关心“背景、道路、车道线、车辆、行人”这五类，就需要做类别合并。直接改原图不现实，更稳的做法是写一个统一的重映射函数，在 Dataset 的__getitem__里实时转，或者在训练前把所有 mask 离线转好。我一般离线转好，因为训练时每次读图还要做映射，白浪费 I/O。

def remap_mask(mask, mapping): merged = np.zeros_like(mask, dtype=np.int64) for dst, src_ids in mapping.items(): for src in src_ids: merged[mask == src] = dst return merged mapping = { 0: [0], # 背景 1: [1], # 道路 2: [2], # 车道线 3: [3, 5, 7], # 车辆：把 car、bus、truck 合并 4: [4, 6], # 行人：把 pedestrian、rider 合并 }

代码逻辑很直白：遍历映射表，把源类别 ID 对应的像素全部写到目标类别。这里的关键点是把面积相近、在道路场景里常被混淆的类合并到同一个目标类，比如公交车和卡车都算“车辆”，骑手和行人都算“行人”。合并之后再统计每个类别像素占比，如果道路占了 70% 而行人只占 1%，后面 loss 就要加权，这个第 4 章会重点讲。

3.3 训练/验证集划分和数据增强：连续帧这个隐蔽的泄漏点

视频抽帧有个特别容易踩的坑：相邻几帧高度相似。如果随机打乱后再划分训练集和验证集，第 508 帧在训练集、第 512 帧在验证集，验证集几乎等于考原题，IoU 0.98 的水分就会很大。正确做法是按时间顺序划分，比如前 75% 帧进训练集，后 25% 帧进验证集，确保验证集是模型没见过的“路段”。

数据增强要注意一个度。道路分割里车道线是细长结构，如果做大幅随机缩放，车道线很容易被插值弄断。我的通常做法是把RandomScale控制在小范围，同时用RandomCrop固定到 512x512，这样既保证了分辨率稳定，又不会把细结构抖没。

import albumentations as A from albumentations.pytorch import ToTensorV2 train_transform = A.Compose([ A.RandomFlip(p=0.5), A.ColorJitter(brightness=0.2, contrast=0.2, saturation=0.2, p=0.8), A.RandomScale(scale_limit=(0.05, 0.2), p=0.3), A.PadIfNeeded(min_height=512, min_width=512, border_mode=0, value=0), A.RandomCrop(512, 512), ToTensorV2(), ])

RandomFlip对语义分割是安全的，因为像素级类别不会因为镜像改变；ColorJitter模拟一天中不同时段的亮度变化，对道路场景很实用；scale_limit只给到 0.2，再大就把车道线拉断了。PadIfNeeded的value=0表示 padding 区域按背景 ID 填充，训练时 mask 同步 padding，否则类别标签会多出垃圾像素。

4. 训练配置与收敛控制：10 个 epoch 到 0.98 的可复现参数

4.1 训练参数总表：先照抄，再调参

这组参数是我基于这份资源的实际情况给的基准配置，先照抄跑通，再按自己数据集调整。

backbone 和 head 的学习率建议分开写：backbone 用 1e-3 微调，head 是新随机初始化的，梯度更猛，用 1e-2 能让分支结构更快收敛。poly 策略是分割任务里最常见的 lr 曲线，每 step 衰减，比固定 cosine 稳。

4.2 交叉熵加 Dice：处理像素级不平衡

道路分割的 mask 里，背景和道路占了八到九成像素，纯交叉熵会让模型把精力全放在大面积类别上，行人和车道线这些小目标基本被淹没。常规解法是混合 Dice Loss。Dice Loss 直接优化区域重叠度，对类别像素比例不敏感，两个 loss 加起来之后，小目标的梯度不会被大类别稀释。

def dice_loss(pred, target, eps=1e-7): pred = torch.softmax(pred, dim=1) # (B, C, H, W) target_onehot = F.one_hot( target, num_classes=pred.shape[1] ).permute(0, 3, 1, 2).float() # 忽略背景类，聚焦前景 pred = pred[:, 1:] target_onehot = target_onehot[:, 1:] inter = (pred * target_onehot).sum(dim=(2, 3)) union = pred.sum(dim=(2, 3)) + target_onehot.sum(dim=(2, 3)) dice = 1 - (2 * inter + eps) / (union + eps) return dice.mean()

这段代码的关键是pred[:, 1:]：把背景类剔掉再算 Dice。你可以理解为：道路占比再大，Dice 分子分母同时被放大，它对模型决策的“指挥权”被限制住了；真正决定模型边界质量的是前景类。后面的eps是防除零的，不能省，否则某个类别在 batch 里完全没出现时数值会不稳定。

4.3 Pytorch 训练循环与验证 IoU 实现

训练主循环我一般固定用 poly 学习率手动更新，而不是LambdaLR，这样每个 step 想查当前 lr 都方便。

import torch from torch.cuda.amp import GradScaler, autocast def set_poly_lr(optimizer, init_lr, step, total_steps, power=0.9): lr = init_lr * (1 - step / total_steps) ** power for g in optimizer.param_groups: g["lr"] = lr scaler = GradScaler() total_steps = len(train_loader) * EPOCHS global_step = 0 for epoch in range(EPOCHS): model.train() for imgs, masks in train_loader: imgs, masks = imgs.cuda(), masks.long().cuda() set_poly_lr(optimizer, base_lr, global_step, total_steps) global_step += 1 optimizer.zero_grad() with autocast(): logits = model(imgs) loss = ce_loss(logits, masks) + 0.8 * dice_loss(logits, masks) scaler.scale(loss).backward() scaler.step(optimizer) scaler.update()

( ce_loss ) 里记得写ignore_index=255，这个参数直接传给 Pytorch 的CrossEntropyLoss。( model(imgs) ) 输出的是(B, num_classes, H, W)的 logits，不再套额外结构。如果 10 个 epoch 内验证集 IoU 连续两个 epoch 不涨，我一般就停了，不用硬跑满。

验证 IoU 的计算口径要统一。这里给一个按类别分别计算再平均的标准实现：

def compute_iou(pred, target, num_classes): ious = [] for c in range(num_classes): pred_c = (pred == c) target_c = (target == c) inter = (pred_c & target_c).sum().float() union = (pred_c | target_c).sum().float() ious.append((inter + 1e-6) / (union + 1e-6)) return torch.tensor(ious).mean().item(), ious

pred是logits.argmax(dim=1)的结果，target是 ground truth mask。注意验证时也要把255像素排除掉，最简单的方法是在求 IoU 前把 target 中255的位置在 pred 里也置成 255，这样它们不会参与任何类别的交集并集计算。0.98 这个数字就是在这个口径下统计出来的。

4.4 从 loss 和类别 IoU 判断收敛：什么时候能停

训练日志里不要只看一个整体 loss。我习惯每两个 epoch 打印一次每个类别的 IoU 列表，重点看道路、车道线、车辆、行人四类。如果整体 IoU 在涨但行人 IoU 一直是 0，那不是收敛，是类别不平衡没压住。遇到了先调 Dice 权重、或者给CrossEntropyLoss的类别权重加大，而不是继续加 epoch。

小数据训练另一个特征是 loss 曲线波动大。10 个 epoch 的训练，每 epoch 只有几十个 step，验证集 IoU 上蹿下跳很正常，别一看到掉两个点就回滚。看趋势就好：只要验证集整体 IoU 在向上走，就继续跑；连续 2 个 epoch 一点不动，再停下来调参。

5. 避坑指南：道路分割训练中的五个翻车记录

5.1 现象：验证集 IoU 只有 0.4，训练集已经到 0.95

原因：视频抽帧数据没按时间顺序划分。随机划分把同一段视频的相邻帧同时放进了训练集和验证集，理论上验证集应该“看不到”的地方全被泄漏了，但一旦真正遇到没见过的帧，模型立刻现原形。

解决：先看文件名里的帧号，按时间序划分。我习惯把前 75% 帧归训练集，后 25% 归验证集，并且保证验证集里没有和训练集连续编号相差小于 10 的帧。划分完再打印一下两边的帧号区间，确认没有交叉。

5.2 现象：整体 mIoU 不错，但行人这一类的 IoU 始终贴近 0

原因：类别极不平衡 + 纯交叉熵。行人像素占比可能不到 1%，交叉熵对它的梯度贡献被背景和道路淹没，模型干脆把所有像素都预测成道路，整体 IoU 依然能到 0.8 以上。

解决：先看每类 IoU 列表，别只看整体。给CrossEntropyLoss传入weight，按类别像素占比倒数设置，再把 Dice Loss 的 lambda 从 0.8 加到 1.2。如果数据里行人框实在少，优先去 Roboflow 工作区多标几帧行人，比调参有效。

5.3 现象：输入从 1024 resize 到 512 之后，车道线断成虚线

原因：直接 resize 对细长结构不友好。车道线只有几个像素宽，1024 缩到 512 时，插值算法把它拉成了一条断断续续的线，而且 mask 和 image 的插值方式如果不一致，边缘会错位。

解决：不要无脑 resize。要么保持长边 768 以上，用RandomCrop裁到 512 训练，推理时再做同尺寸 padding 预测；要么在训练和验证里都用一致的Resize(height, width, interpolation)参数，mask 用nearest，图像用bilinear，让标注边缘不偏移。

5.4 现象：开启 AMP 混合精度之后，loss 突然跳成 NaN，然后整个训练崩了

原因：AMP 下 FP16 的表示范围有限，而分割头里膨胀率 24 的卷积会产生比较大的中间值，反向传播梯度溢出。

解决：先关掉 AMP 把 baseline 跑出来，再开启GradScaler。如果还是 NaN，把 LRASPPHead 里的两个 branch 保留在 FP32，也就是直接在autocast外面跑 head 部分。实际项目里 head 参数量很小，保留 FP32 的显存开销可以接受。

5.5 现象：单张推理结果叠回原图，物体边缘一圈白边

原因：训练时用了RandomCrop，但推理时直接对原图做resize再预测，最后把 512x512 的预测 mask resize 回原尺寸，坐标和插值方式都不对。

解决：推理阶段必须复用训练预处理，尤其是 padding 和 crop 的坐标。我一般先把原图 pad 到 512 的整数倍，再分块预测，最后按记录坐标把结果切回原图区域，不直接 resize 整个 mask。叠加原图时用原图坐标画 contour，边缘就不会出现白边。

6. 推理验证与连续帧检查：把 0.98 放心用到道路视频上

6.1 单帧推理与可视化叠加

训练完先跑单帧可视化，确认 mask 边界和原图对齐。推理时最省事的是直接拿 model 的 logits 过 argmax，再把预测 mask 转成彩色图叠加到原图上：

import cv2 import numpy as np import torch model.eval() with torch.no_grad(): img_tensor = torch.randn(1, 3, 512, 512).cuda() img_tensor = img_tensor.half() logits = model(img_tensor) # (1, C, H, W) pred = logits.argmax(dim=1)[0].cpu().numpy() color_map = np.array([ [0, 0, 0], # 背景 [128, 64, 128], # 道路 [244, 35, 232], # 车道线 [70, 70, 70], # 车辆 [220, 20, 60], # 行人 ], dtype=np.uint8) vis = color_map[pred] overlay = cv2.addWeighted(img, 0.6, vis, 0.4, 0)

这段代码里pred的每个像素值对应类别 ID，直接作为 color_map 的索引，一句话就把灰度 mask 变成彩色图。addWeighted的 0.6/0.4 是原图和 mask 的融合比例，验证时我喜欢 mask 重一些，好检查车道线是否断裂。

6.2 连续帧稳定性检查

单帧准不代表能上线。道路视频是连续帧，如果模型在相邻帧之间频繁切换误判，画面会闪烁，这在实车上是不可接受的。我的习惯是：从验证集里按时间序抽 30 帧连续帧，逐帧推理后做成 mp4，用 0.5 倍速看三遍。重点看两个地方：一是车道线是否稳定连续，二是车辆和行人的 category 会不会在相邻帧跳变。闪烁严重时先检查输入图像有没有做亮度归一化，再做简单的时间平滑——对 logits 做指数滑动平均，同时不要用 hard label 投票，平滑后在 argmax。

6.3 导出 ONNX 前再拉一遍每类 IoU

最后一步我会导出 ONNX 做精度对比。导出时把动态轴设成 batch 维度，输入输出名固定：

torch.onnx.export( model.cpu().eval(), torch.randn(1, 3, 512, 512), "lraspp_mbv3.onnx", input_names=["input"], output_names=["output"], dynamic_axes={"input": {0: "batch"}, "output": {0: "batch"}}, opset_version=12, )

导出后用 onnxruntime 分别跑单帧，对比 Pytorch GPU 和 ONNX CPU 的每类 IoU，差异大于 0.5% 就要查算子兼容问题。从那以后，我每次训练完都强制自己走一遍类别 IoU 列表、连续帧视频、ONNX 对比这三步，再谈能不能部署。希望帮到你。

本文还有配套的精品资源，点击获取