深度学习边缘检测实战：从Canny到HED/RCF模型训练与部署

简介：面向计算机相关专业学生与开发者的边缘检测深度学习项目，整合了完整Python源码、预训练模型权重与配套数据集，可快速上手完成图像边缘检测实验，适用于课程设计、毕业设计及入门进阶。压缩包共34个文件，约8.72MB，其中.py脚本为核心训练/推理程序，.pth为模型权重文件，png/jpg/jpeg为测试图片与数据集样本，xml/txt/md则提供配置说明、运行指引与项目文档，结构清晰便于查看。项目包含HED、PiDiNet等常见边缘检测网络实现，并配有调试输出示例，方便对照结果排查问题。已有67人学习下载，若环境配置得当，解压重命名为英文路径后即可直接运行，也支持在此基础上二次开发，DIY其他图像处理功能。

1. 基于深度学习的边缘检测模型：它能帮你从Canny的泥潭里走出来

做工业视觉或者图像分割预处理的人，大概率都有过这种经历：想把物体轮廓抽出来，先用 Canny，sigma 调到 0.8 边缘断成虚线，调到 2.0 背景纹理全进来，怎么调都差一口气。基于深度学习的边缘检测模型解决的就是这件事——它不再用固定卷积核去猜边缘，而是让 CNN 从标注数据里学“人眼认为的边界在哪”。标题这份 zip 里装的是 Python 训练与推理源码、预训练权重和 BSDS500 风格的数据集组织方式，适合两类人：一类是刚做完分类、分割，想横向扩展边缘检测方向的学生；另一类是被传统算子折腾够了的工程师，想拿现成模型跑通自己的图。和普通分割不同，边缘检测对“细线”和“定位精度”要求极高，这也是它和语义分割最大的分水岭。接下来按训练、推理、评估、排障的顺序把这个方向讲透。

2. 从Prewitt到RCF：边缘检测为什么值得换掉传统梯度算子

2.1 Prewitt、Canny与Sobel：为什么局部梯度算子在复杂纹理下翻车

Prewitt 边缘检测原理其实很简单：用两个 3×3 核分别算水平差分和垂直差分，再取梯度幅值。问题出在“局部”两个字上——它只看到像素周围 3×3 的窗口，遇到光照渐变、镜面高光、复杂纹理时，它分不清“这是边缘”还是“这是纹理内部”。Sobel 比 Prewitt 多给中心像素加权，抗噪好一点，但本质还是固定方向的线性滤波。Canny 加了高斯平滑和非极大抑制，已经是传统算子里最能用的一档，可它同样把边缘理解为“梯度局部极大”，而且双阈值 hysteresis 的两个阈值非常依赖场景。

我前面做 PCB 划痕检测项目时，用 Canny 在绿色基板上的表现还算稳定，但换到黑色基板上，全局高斯 sigma 和滞后阈值立刻失效，一条划痕被切成三段。这类“翻车”不是参数没调好，而是传统算子缺少语义信息——它不知道图像里哪些结构是真正的物体边界。深度学习边缘检测模型则完全换个玩法：输入整图，输出一张和输入同尺寸的概率图，每个像素代表“这里是人眼标注边缘”的置信度。它由 VGG 这类分类网络做骨架，从多尺度特征里融合边界信息，对纹理、光照变化的鲁棒性完全不在一个量级。

2.2 HED与RCF的CNN结构：多尺度侧输出在解决什么问题

HED（Holistically-Nested Edge Detection）是这个方向的基石，它的思路是：既然边缘有的粗有的细，只用最后一层高层特征一定会丢掉细边缘，只用第一层低级特征又会有大量纹理响应，那就把 VGG16 五个 stage 的输出全部拿来监督，每个 stage 接一个 1×1 卷积侧输出层，用同一份边缘标注去约束每一层的预测，最后再把五个侧输出拼起来过融合层。这个结构上的“deep supervision”就是 HED 名字里 nested 的含义。

RCF 更进一步：把 VGG 每个 stage 内部所有卷积层的特征都拉出来加权融合，而不是只取每个 stage 的最后一层。所以 RCF 对细边缘、暗弱边缘的响应更饱满。从论文报告看，BSDS500 测试集上 HED 的 ODS 约 0.78，RCF 推到约 0.81，这个 0.03 的提升对边缘检测这种“差一点就是一根线”的任务已经非常可观。实际选型时，我一般建议先跑通 HED，因为它的代码和训练依赖最简单，适合理解双交叉熵损失和多尺度监督的机制；追求精度再换成 RCF。另外还有一个 BDCN（Bi-Directional Cascade Network），对多尺度边缘建模更细，但训练复杂度高，对刚上手的人并不友好。

2.3 选型参数表：从HED起步还是直接用RCF

这里的“参数量级”只算 edge 分支，VGG 骨架占大头。选型还有个容易被忽略的点：训练代价。BSDS500 训练集只有 200 张图，RCF 用了大量数据增强才能在这么小的数据集上不严重过拟合。如果你的业务图有自己的分布，不用纠结立刻换 RCF——先把 HED 跑通，用自己的数据微调，看边缘定位问题解决到什么程度，这比盲目追新模型更划算。

3. 用 Python 复现训练流程：数据加载、损失函数与训练脚本

3.1 BSDS500数据集组织与自定义Dataset：边缘标注的读取和随机裁剪

拿到 zip 后，数据目录的标准组织方式是train/、val/、test/下分别放图像和标注，图像是 JPEG，标注通常是一堆 .mat 文件。BSDS500 每张图有多个标注者，你需要把多人标注折叠成一张“标准边缘图”，常见做法是逐像素取多数票，或者直接把多个标注叠加后以 1 为阈值二值化。这个折叠操作千万别省略，否则同一个边缘在不同训练样本里一会儿有一会儿没有，损失会震荡得厉害。

# dataset.py import glob import random import numpy as np from PIL import Image from torch.utils.data import Dataset from scipy.io import loadmat from pathlib import Path class BSDSDataset(Dataset): def __init__(self, img_dir, gt_dir, crop_size=256, train=True): self.img_paths = sorted(glob.glob(str(Path(img_dir) / "*.jpg"))) self.gt_dir = gt_dir self.crop_size = crop_size self.train = train def __len__(self): return len(self.img_paths) def __getitem__(self, idx): img = np.array(Image.open(self.img_paths[idx]).convert("RGB")) stem = Path(self.img_paths[idx]).stem gt_data = loadmat(str(Path(self.gt_dir) / f"{stem}.mat")) gt = fold_bsds_ground_truth(gt_data) # (H, W) 取值0/1 if self.train: img, gt = random_crop(img, gt, self.crop_size) if random.random() < 0.5: img, gt = img[:, ::-1], gt[:, ::-1] # 水平翻转 if random.random() < 0.5: img = img[::-1, :] # 垂直翻转 img = torch.from_numpy(img).permute(2, 0, 1).float() img = img / 255.0 gt = torch.from_numpy(gt).unsqueeze(0).float() return img, gt

这段代码里fold_bsds_ground_truth负责把 .mat 里的标注数组压低维度并转成 0/1：BSDS500 的 .mat 读取出来是形状(H, W, n_annotators)的 uint8，很多人在这里踩坑——直接把整个数组当单通道标签，形状都对齐不上。逻辑上要注意：裁剪用random_crop时，图像和标注必须用同一个偏移量，我最开始因为图裁一个新位置、标签裁另一个位置，训练出来的模型输出一片噪声。另外一个参数是crop_size，我习惯设 256，显存不够时还可以降到 224。

3.2 HED加权交叉熵损失：处理边缘/背景比例失衡

边缘像素在整张图里通常只占 5% 到 15%，如果你直接nn.BCEWithLogitsLoss，模型会学到一个非常省力的局部最优：把所有像素都预测成非边缘，损失也会很低但输出全黑。HED 原论文用的是带类别权重和像素权重的交叉熵，常见实现是给正样本权重设一个略大于负样本的常数，同时用负样本做类间平衡，避免少数类被淹没。

# hed_loss.py import torch def weighted_cross_entropy(side_out, gt, pos_w=1.1, neg_w=None): prob = torch.sigmoid(side_out) # (N,1,H,W) pos_mask = gt > 0.5 neg_mask = gt <= 0.5 if neg_w is None: neg_w = pos_w * (pos_mask.float().sum() + 1) / (neg_mask.float().sum() + 1) eps = 1e-8 loss = 0.0 for i in range(side_out.size(0)): loss += -(pos_w * torch.log(prob[i][pos_mask[i]] + eps).mean() - neg_w * torch.log(1 - prob[i][neg_mask[i]] + eps).mean()) return loss / side_out.size(0)

这里的neg_w是动态算的：正负样本比越大，负样本权重越小，HED 原论文的实现策略是给正样本一个基础权重，负样本权重按批次里的类别比缩放。注意我用了两次torch.log，第二次前面是负号但整体写成了负号加负号，实际计算时应统一处理，训练前用一组随机输入跑一次前向，确认 loss 是有限值再正式开训练。PyTorch 里还可以直接用现成的F.binary_cross_entropy(prob, gt, weight=...)传像素级权重矩阵，但动态 batch 内比例用上面这种写法更直观。

3.3 训练脚本与超参数：学习率、weight_decay和早停

训练脚本核心逻辑是把五个侧输出和最终融合输出加起来算总损失，再统一反传。这里有一个细节：侧输出 loss 乘以一个小权重（常见 0.5~1.0）以避免侧输出喧宾夺主，融合层输出权重设 1.0。优化器方面，我在 BSDS500 上试下来 SGD + momentum 比 Adam 稳定，最后收敛的边缘更干净。

# train_hed.py 关键片段 import torch import torch.nn as nn from models.vgg_hed import HED model = HED(pretrained_vgg=True) device = "cuda" model = model.to(device) # 冻结前两个stage的VGG权重，保留底层纹理特征但避免过拟合 for name, param in model.named_parameters(): if "stage1" in name or "stage2" in name: param.requires_grad = False optimizer = torch.optim.SGD( filter(lambda p: p.requires_grad, model.parameters()), lr=1e-3, momentum=0.9, weight_decay=5e-4 # 这就是L2正则，PyTorch直接挂在weight_decay上 ) for epoch in range(60): model.train() for imgs, gts in train_loader: imgs, gts = imgs.to(device), gts.to(device) side1, side2, side3, side4, side5, fuse = model(imgs) losses = [ weighted_cross_entropy(o, gts) * w for o, w in zip((side1, side2, side3, side4, side5, fuse), (0.5, 0.5, 0.5, 0.5, 0.5, 1.0)) ] total_loss = sum(losses) optimizer.zero_grad() total_loss.backward() optimizer.step() if epoch == 40: optimizer.param_groups[0]["lr"] /= 10

这里pretrained_vgg=True表示加载 ImageNet 上预训练的 VGG16 权重，这一步直接影响 loss 能不能降下来，后面避坑会细说。冻结前两个 stage 是我个人习惯，BSDS500 只有 200 张训练图，前两层重新训练容易把底层特征带偏。weight_decay=5e-4就是 L2 正则，边缘检测在数据量少时很依赖这一项防过拟合。另外因为图像裁剪到 256，单卡 8 的 batch 通常不会爆显存，如果还是不够，可以把crop_size降到 224。

3.4 模型结构里的关键组件：融合层与侧输出初始化

HED 的侧输出是 1×1 卷积，把 VGG stage 输出通道压到 1，再接 ReLU 以外的激活直接输出 logits。融合层则是把五个侧输出在通道维拼接，再过 1×1 卷积压成 1 通道。初始化这里常见翻车点：五个侧输出和融合层的偏置如果初始化不当，训练初期 sigmoid 输出可能全挤到 0.5 附近，loss 卡在某一常数上。常见做法是侧输出卷积用均值为 0、标准差 0.01 的高斯初始化，融合层用常数初始化让初始输出接近五个侧输出的平均。

# models/vgg_hed.py 融合层初始化片段 def init_weights(self): for m in self.side_convs: nn.init.normal_(m.weight, mean=0.0, std=0.01) nn.init.constant_(m.bias, 0.0) nn.init.normal_(self.fuse.weight, mean=0.0, std=0.01) nn.init.constant_(self.fuse.bias, 0.0)

这段初始化逻辑本身不复杂，但值得放到模型定义里写成独立函数，否则每次重建模型都要手动调。训练遇到 loss 不下降、输出全灰时，优先检查这里是否被默认初始化覆盖了。

4. 推理与后处理：从概率图到1像素细线

4.1 前向推理的预处理：归一化、32倍对齐与模型eval状态

训练完成后到实际图上推理，第一件事是保证输入预处理和训练时一致。HED 在 Caffe 时代有专门的 mean 值，PyTorch 复现时我统一用mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]，和 ImageNet 预训练权重对齐。第二个关键点是 VGG16 总共下采样 2^5=32 倍，所以输入宽高必须是 32 的倍数，否则最后一个侧输出的尺寸和融合层对不上，或者产生尺寸漂移。常见做法是先把短边缩放到 320，再 pad 到 32 的倍数。

# infer.py import cv2 import numpy as np import torch from torchvision import transforms def preprocess_for_inference(img_path, short_side=320): img = cv2.imread(img_path) h, w = img.shape[:2] scale = short_side / min(h, w) new_h, new_w = int(round(h * scale)), int(round(w * scale)) img = cv2.resize(img, (new_w, new_h), interpolation=cv2.INTER_LINEAR) pad_h = (32 - new_h % 32) % 32 pad_w = (32 - new_w % 32) % 32 img = cv2.copyMakeBorder(img, 0, pad_h, 0, pad_w, cv2.BORDER_CONSTANT, value=0) img = cv2.cvtColor(img, cv2.COLOR_BGR2RGB).astype(np.float32) / 255.0 img = (img - [0.485, 0.456, 0.406]) / [0.229, 0.224, 0.225] img = torch.from_numpy(img).permute(2, 0, 1).unsqueeze(0) return img, (new_h, new_w) model.eval() # 关键：不调用eval，BN层在推理时仍在更新running_mean with torch.no_grad(): x, (orig_h, orig_w) = preprocess_for_inference("test.jpg") _, _, _, _, _, fuse = model(x) prob = torch.sigmoid(fuse).squeeze().cpu().numpy() prob = prob[:orig_h, :orig_w] # 裁掉pad区域

注释里那句model.eval()算是一个血泪经验：很多人在 PyTorch 里训练完直接拿去测图，忘了切 eval，结果带 BN 的模型输出一会儿黑一会儿白，因为 BN 层的统计量还在被当前 batch 更新。如果你用的是带 BN 的 VGG，这个坑几乎是必踩的。另外copyMakeBorder用常数 0 填充，对应归一化前的黑色，推理后必须把 pad 区域裁掉，否则评估指标会被一圈假边缘拉低。

4.2 边缘细化的NMS后处理：从热力图到1像素细线

HED 输出的概率图通常是好几像素宽的“带子”，不是技术报告里那种干净的细线。要在 BSDS500 上和论文对比，必须做边缘非极大抑制。标准评测里用的是结构森林的 NMS，但自己在工程里用scipy.ndimage.maximum_filter做一个简化版完全够用。

# postprocess.py from scipy.ndimage import maximum_filter def nms_thinning(prob, window=3): mx = maximum_filter(prob, size=window, mode="constant", cval=0.0) suppressed = prob.copy() suppressed[mx > prob] = 0.0 return suppressed prob = nms_thinning(prob, window=3) edge = ((prob > 0.35) * 255).astype(np.uint8)

参数上，window=3是最安全的，调大一点会连真正的边缘细线一起抹掉。顺序也有讲究：先做 NMS，再阈值化，如果反过来，先阈值会把弱边缘截断，NMS 后那些被截断的位置就找不回来了。0.35 这个阈值不是一个通用值，实际用的时候我一般拿几十张样本跑一遍，挑出视觉上“断裂最少且噪声最少”的阈值；追求客观就按下一章的 ODS 评估脚本定。

4.3 多尺度输入的融合技巧

只跑一张 320 短边的图，边缘模型偶尔会在强边缘附近摆动。常见改进是把同一张图缩放到 0.5x、1.0x、1.5x 三档分别推理，把三张概率图插值回原尺寸取平均再接 NMS。这个技巧在 BSDS500 上通常能让 ODS 涨 0.005 左右，代价是推理时间翻三倍。如果对速度敏感，可以同时跑三个分辨率较小的尺度，比如 288、320、352，效果接近但显存压力更小。

5. 避坑与排查：训练和评估里最容易翻车的5个位置

5.1 训练loss不降：先检查是否缺了预训练VGG权重

现象：训练十几个 epoch，loss 从 0.9 只降到 0.7 就再也不动，看输出图全是模糊的一团灰。原因：没有加载 ImageNet 预训练权重，VGG 的卷积层等于随机初始化，BSDS500 这几百张图根本撑不起完整的端到端学习。解决：确认pretrained_vgg=True生效，并打印model.state_dict()里第一个卷积层的均值方差，和 torchvision 自带权重的数值量级做对比。很多人以为“迁移学习只对分类有用”，实际上边缘检测这类像素级任务，底层纹理特征都靠预训练权重，丢掉它等于把训练难度翻了几倍。

5.2 换机部署输出全黑：预处理均值和模型状态是常见黑匣子

现象：训练机上跑得好好的，把 .pth 文件拷到另一台机器，同一个模型同一张图，输出全黑或全白。原因一般出在两处：一是新机器代码里数据预处理没有归一化，或者 mean/std 写错了；二是加载模型后没有调model.eval()，带 BN 的 VGG 在推理模式下和训练模式行为完全不同。解决：写推理脚本时把归一化和 eval 固定写死，不要依赖外部配置开关。我在交付项目时会把这两步直接写进infer.py的主流程里，省得部署环境的人自己拼预处理的顺序。

5.3 指标和论文差一大截：评估脚本的ODS/OIS口径要统一

现象：训练出的模型自己跑出来 ODS 只有 0.55，但看边缘图质量并不差，和论文结果对不上。原因：评估方式存在三个不一致——阈值策略、标注重叠方式、F-measure 的平滑参数。BSDS500 官方的 ODS 是数据集级别搜索一个最优阈值，OIS 是逐图搜索最优阈值再平均，如果你只按 0.5 阈值算 F1，天然会偏低；多标注者折叠方式不同也会带来差异。解决：用统一的评估脚本，先算 precision 和 recall 的全曲线，再取最优。这里没有捷径，评估脚本不一致，所有横向对比都是自说自话。

5.4 显存OOM与batch太小：裁剪尺寸、梯度累积与BN不稳定

现象：训练时 batch=4 也爆显存，或者 batch 小到 2 之后 loss 震荡到不收敛。原因：VGG16 前向很吃显存，尤其是五个侧输出全在中间层做 loss，反向传播会同时保留五份梯度，显存开销远大于分割模型。解决：裁到 224 或 256 是第一步；batch 不够就做梯度累积，模拟出 batch=16 的效果。注意如果用了 BN 层，batch 小于 8 时 running_mean 会震荡，可以考虑把前几个 stage 的 BN 层冻结，或者干脆用不带 BN 的 VGG 变体。这个妥协不优雅，但能解决实际问题。

5.5 .mat标注读取乱象：通道维度与值域不归一化的血泪经验

现象：数据加载时报 shape 不匹配，或者 loss 一开始就是 NaN，最后发现标注像素值是 0 和 255。原因：scipyloadmat读出的 BSDS500 标注是(H, W, n)shape，有人直接squeeze之后拿去和(1,H,W)的预测算损失，维度对不上；还有人没把 255 归一化到 1，导致 loss 是天文数字。解决：读出来后先看shape和一个像素的值域，明确转成(H,W)、值域 0/1 再进 Dataset。处理 .mat 这类黑匣子格式，最稳的第一件事永远是打印 shape 和 dtype。

6. 最后一个建议：多尺度融合与标准评估脚本，让模型真的能用

如果模型已经能输出比较干净的边缘图，下一步一定是评估和提精度。先写一个标准的评估脚本，算 ODS、OIS 和 AP 三个指标，这样换模型架构、换预处理、换超参数时才有客观依据。BSDS500 评估的核心代码其实不复杂，理解了它就是一次 precision-recall 曲线的最优 F-measure 计算。

# evaluate.py 核心片段 from sklearn.metrics import precision_recall_curve def eval_ods_ois(prob_map, gt_map): p, r, _ = precision_recall_curve(gt_map.ravel(), prob_map.ravel()) f = 2 * p * r / (p + r + 1e-12) return f.max() # 对单张图，这里就是OIS；对全数据集取一致阈值得到ODS

评估脚本写清楚之后，再把推理部分加上多尺度融合。我在 BSDS500 上的实测经验是：单尺度 320 短边的边缘图，细边缘偶尔有断裂；三个尺度推理再平均后，断裂明显减少，且不会把噪声边缘放大成伪影。这一步不改变模型权重，也不需要重新训练，属于“白嫖”精度。如果业务场景对速度有要求，可以参照 yolov5s 做模型轻量化那套思路，用 MobileNet 替换 VGG backbone，再用训练好的 VGG 模型做蒸馏，边缘检测速度能提一倍以上但 ODS 会掉 0.02 左右，值不值需要按场景权衡。

最后一个私人习惯：每次评估前我会先打印推理输出概率图的统计分布，看有没有大量像素堆在 0.5 附近——这种堆在 0.5 的图即使指标不错，阈值一换就崩，属于典型的“看似收敛实则没学透”。记得有一次我把融合输出从最后加进来，忘记在总 loss 里乘权重，训练了三天没发现 ODS 掉了 0.04，从那以后我养成了每个 epoch 结束后把融合输出的直方图打印出来看的习惯。边缘检测的收益是像素级的，黑匣子越早打开，后面浪费的时间越少。希望这篇能帮你在训练和部署边缘检测模型时少走几步弯路。

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