基于深度学习的裂缝检测：从数据标注到部署的完整方案

简介：这份资源是面向计算机、人工智能及土木工程相关专业学生的深度学习裂缝检测项目源码，适合用作毕业设计、期末大作业或课程设计参考。项目以Python实现，围绕裂缝图像识别任务构建了完整的训练与预测流程，包含数据加载、网络模型定义、训练工具与预测工具等模块，代码附有注释，便于新手理解整体结构与关键实现。压缩包共14个文件，以11个py脚本为核心，另含1个md说明文档、1个gitignore配置及1个damdataset数据文件，整体约18KB，体积轻量，部署门槛较低。目前已有130人学习下载。读者可从中获得一套可直接运行的裂缝检测方案，涵盖数据集组织、模型搭建、训练调参与预测推理等环节，便于快速复现实验并在此基础上进行二次开发或功能扩展。

1. 裂缝检测为什么值得用深度学习重做一遍

桥梁、隧道、大坝、路面这些混凝土结构，定期巡检是硬性要求。传统做法是人工拿裂缝观测仪贴着墙面量宽度、画草图，一条几百米的隧道走下来，两个人一整天，回来还要把照片和记录对号入座。问题不在于累，而在于一致性差：同一个裂缝，上午测是 0.18 mm，下午换个人测可能变成 0.22 mm，而规范里 0.2 mm 往往就是要不要处理的临界线。

深度学习裂缝检测要解决的就是这件事：把巡检拍到的图像喂给模型，自动框出裂缝位置、分割出像素级轮廓，再换算成物理宽度。它适合三类人——做结构健康监测的工程团队、想把手持巡检设备升级成自动识别的硬件厂商、以及手里已经攒了几万张病害图但不知道怎么用起来的运维单位。Python 源码在这个方向里几乎是默认载体，因为从数据标注、训练到部署推理，整条链路都有成熟库可用，不用自己造轮子。

这一篇不讲空洞概念，按「数据怎么准备 → 模型怎么选 → 训练怎么调 → 部署怎么落地 → 坑在哪」的顺序，把一套能跑起来的裂缝检测方案拆开讲。你照着做，至少能在一台带显卡的机器上跑出可用的分割结果。

2. 裂缝数据从哪来、怎么标、怎么增强

2.1 公开数据集与自采图像的取舍

裂缝检测最尴尬的一点是：公开数据集不少，但和你实际场景往往对不上。常见的几类来源，我按适用性排一下。

我的习惯是：先用公开数据把训练流程跑通，确认模型结构没问题，再逐步替换成自采数据做微调。直接上自采数据，一旦训练不收敛，你分不清是数据问题还是代码问题，这是血泪经验。

自采时有个硬要求：拍摄距离、镜头焦距、补光方式尽量固定。裂缝宽度是靠像素当量换算的，你今天 30 cm 拍、明天 50 cm 拍，同一个裂缝在图像里占的像素数差一倍，模型学到的「宽度」概念就乱了。

2.2 标注格式：分割掩码比边界框更值得投入

裂缝检测有两种标注粒度：边界框和像素级掩码。边界框标注快，但裂缝是细长目标，框里绝大部分是背景，模型很容易学偏。要做宽度测量，必须用分割掩码。

标注工具用 LabelMe 或 CVAT 都行，导出成 COCO 格式的 polygon，再转成训练用的掩码图。转换脚本大概长这样：

import json import numpy as np from PIL import Image, ImageDraw def coco_polygon_to_mask(json_path, img_dir, out_dir): """把 LabelMe/CVAT 导出的 COCO polygon 转成二值掩码图""" with open(json_path, 'r', encoding='utf-8') as f: data = json.load(f) # 建立 image_id -> 文件名的映射 img_map = {img['id']: img for img in data['images']} for ann in data['annotations']: img_info = img_map[ann['image_id']] w, h = img_info['width'], img_info['height'] mask = Image.new('L', (w, h), 0) draw = ImageDraw.Draw(mask) # segmentation 是 polygon 点列表，可能有多段 for seg in ann['segmentation']: # 点坐标是 [x1,y1,x2,y2,...]，要成对拆开 pts = [(seg[i], seg[i+1]) for i in range(0, len(seg), 2)] if len(pts) >= 3: draw.polygon(pts, fill=255) name = img_info['file_name'].rsplit('.', 1)[0] + '.png' mask.save(f'{out_dir}/{name}') if __name__ == '__main__': coco_polygon_to_mask('annotations.json', 'images', 'masks')

这段代码的关键点有三个。第一，segmentation字段可能是多段 polygon，一条裂缝被遮挡分成两截时就会出现多段，必须循环处理，只取第一段是常见翻车点。第二，draw.polygon要求至少三个点，标注时手抖点成两个点的脏数据要过滤掉，否则会抛异常。第三，掩码存成单通道 PNG，像素值 0 和 255，训练时再除以 255 归一化，不要在这里就转成 0/1 浮点，存图会丢精度。

2.3 数据增强：别把裂缝「增强」没了

裂缝检测的增强和通用目标检测不一样。水平翻转、垂直翻转基本安全，因为裂缝方向没有语义。但旋转要小心：旋转 90 度没问题，任意角度旋转会引入黑色填充边，如果填充边被当成背景学进去，模型在图像边缘的预测会变差。

亮度对比度扰动是必须的，因为现场补光条件千变万化。但别用太激进的色彩抖动，裂缝是灰度特征，色调变化对它没意义，反而增加无关方差。

我一般用 Albumentations 配一套保守增强：

import albumentations as A train_transform = A.Compose([ A.HorizontalFlip(p=0.5), A.VerticalFlip(p=0.5), A.RandomRotate90(p=0.5), A.RandomBrightnessContrast( brightness_limit=0.2, # 亮度扰动幅度，别超过 0.3 contrast_limit=0.2, p=0.5 ), A.GaussNoise(var_limit=(5.0, 20.0), p=0.3), # 模拟传感器噪声 A.Resize(512, 512), # 统一到训练分辨率 ])

brightness_limit和contrast_limit控制在 0.2 左右，是因为现场曝光差异再大，也不至于让裂缝完全看不见，扰动过头会让模型学到「看不见裂缝就预测全背景」的偷懒策略。GaussNoise的方差上限 20 是经验值，再高裂缝边缘就被噪声糊掉了。

3. 模型选型：U-Net、DeepLab 还是轻量分割网络

3.1 裂缝分割为什么偏爱编码器-解码器结构

裂缝分割本质是二分类的密集预测：每个像素判断是不是裂缝。这类任务要求输出和输入同分辨率，编码器-解码器结构天然合适——编码器逐层下采样提特征，解码器逐层上采样恢复分辨率，中间用跳跃连接把浅层的高频边缘信息传过去。

裂缝恰恰是极度依赖边缘细节的目标。一条 0.2 mm 的裂缝在 4000 像素宽的图上可能只占 2 到 3 个像素，如果解码器只靠深层语义特征恢复，边缘会糊成一团，宽度测量直接失真。所以跳跃连接不是可选项，是刚需。

U-Net 是最经典的起点，结构简单、代码好懂、在小数据集上不容易过拟合。DeepLab 系列引入了空洞卷积和多尺度池化，对大裂缝和小裂缝同时存在的场景更友好，但参数量大，训练数据少了容易崩。我的建议是：数据量低于 2000 张，先上 U-Net；超过 5000 张且裂缝尺度跨度大，再考虑 DeepLabV3+。

3.2 用 segmentation_models_pytorch 搭一个 U-Net

自己从零写 U-Net 不是不行，但没必要。segmentation_models_pytorch这个库把主流分割网络和预训练编码器都封装好了，几行就能搭起来：

import segmentation_models_pytorch as smp model = smp.Unet( encoder_name='resnet34', # 编码器骨干，轻量且够用 encoder_weights='imagenet', # 用 ImageNet 预训练权重初始化 in_channels=3, # 输入 RGB 三通道 classes=1, # 二分类：裂缝/背景，输出 1 通道 activation=None, # 训练时输出 logits，推理时再 sigmoid )

encoder_name选resnet34是权衡结果：resnet18太浅，裂缝细粒度特征提不够；resnet50参数量翻倍，在几千张图上收益不明显还容易过拟合。encoder_weights='imagenet'很重要，预训练权重能让模型在少量裂缝数据上快速收敛，不用预训练的话，你可能要三倍数据量才能达到同样效果。

activation=None是个容易踩的点。训练时损失函数用BCEWithLogitsLoss，它内部自带 sigmoid，如果你在模型里又加了 sigmoid，等于做了两次，梯度会变得很小，训练极慢。推理时再手动加 sigmoid 或 argmax。

3.3 损失函数：Dice 和 BCE 怎么配

裂缝分割有个严重的类别不平衡问题：一张图里裂缝像素可能只占 1% 到 5%，剩下全是背景。纯 BCE 会让模型倾向于全预测背景，因为这样 loss 也很低。

常见做法是 BCE 和 Dice 按权重相加：

import torch import torch.nn as nn bce_loss = nn.BCEWithLogitsLoss() dice_loss = smp.losses.DiceLoss(mode='binary') def combined_loss(pred, target): # pred 是 logits，target 是 0/1 掩码 return 0.5 * bce_loss(pred, target) + 0.5 * dice_loss(pred, target)

BCE 负责像素级稳定梯度，Dice 直接优化重叠度，对不平衡更鲁棒。权重 0.5/0.5 是起点，如果发现模型召回率低（漏检多），把 Dice 权重提到 0.7；如果误检多（把阴影当裂缝），把 BCE 权重提上去。

提示：Dice loss 在预测全空时会出现除零，smp.losses.DiceLoss内部加了平滑项，自己实现的话记得在分母加个 1e-6。

4. 训练流程与关键参数怎么设

4.1 从零跑通一次训练的最小命令

假设数据已经按images/和masks/分好，写一个最小训练脚本：

import torch from torch.utils.data import DataLoader, Dataset from PIL import Image import numpy as np import albumentations as A from albumentations.pytorch import ToTensorV2 import segmentation_models_pytorch as smp class CrackDataset(Dataset): def __init__(self, img_paths, mask_paths, transform): self.img_paths = img_paths self.mask_paths = mask_paths self.transform = transform def __len__(self): return len(self.img_paths) def __getitem__(self, idx): img = np.array(Image.open(self.img_paths[idx]).convert('RGB')) mask = np.array(Image.open(self.mask_paths[idx]).convert('L')) mask = (mask > 127).astype(np.float32) # 二值化 aug = self.transform(image=img, mask=mask) return aug['image'], aug['mask'].unsqueeze(0) # 加通道维 transform = A.Compose([ A.Resize(512, 512), A.HorizontalFlip(p=0.5), A.Normalize(mean=(0.485, 0.456, 0.406), std=(0.229, 0.224, 0.225)), ToTensorV2(), ]) dataset = CrackDataset(img_list, mask_list, transform) loader = DataLoader(dataset, batch_size=8, shuffle=True, num_workers=4) device = torch.device('cuda' if torch.cuda.is_available() else 'cpu') model = smp.Unet('resnet34', encoder_weights='imagenet', classes=1).to(device) optimizer = torch.optim.AdamW(model.parameters(), lr=1e-4, weight_decay=1e-4) scheduler = torch.optim.lr_scheduler.CosineAnnealingLR(optimizer, T_max=50) for epoch in range(50): model.train() epoch_loss = 0 for imgs, masks in loader: imgs, masks = imgs.to(device), masks.to(device) pred = model(imgs) loss = combined_loss(pred, masks) optimizer.zero_grad() loss.backward() optimizer.step() epoch_loss += loss.item() scheduler.step() print(f'epoch {epoch}, loss {epoch_loss / len(loader):.4f}')

batch_size=8是 512×512 输入、8 GB 显存下的稳妥值，显存够可以提到 16。lr=1e-4配 AdamW 是分割任务的常用起点，太大容易在早期震荡，太小收敛慢。CosineAnnealingLR让学习率从 1e-4 余弦衰减到接近 0，比阶梯衰减更平滑，后期微调更稳。

num_workers=4在 Linux 上没问题，Windows 上如果报错就改成 0，这是 DataLoader 多进程在 Windows 下的老毛病。

4.2 学习率和 batch size 的联动关系

很多人调参时把学习率和 batch size 独立看，其实两者是联动的。经验规则是：batch size 翻倍，学习率也大致翻倍。原因是更大的 batch 梯度估计更准，可以承受更大的步长。

如果你从 batch_size=8、lr=1e-4 改成 batch_size=32，学习率可以提到 3e-4 到 4e-4。但别线性放大到 4e-4 以上，分割任务对学习率比分类敏感，太大容易让模型在裂缝边缘反复横跳，loss 曲线剧烈抖动。

判断学习率是否合适，看训练前几个 epoch 的 loss：如果 loss 几乎不降，学习率太小；如果 loss 变成 nan 或者剧烈震荡，学习率太大。正常情况应该是前 5 个 epoch 快速下降，之后平缓。

4.3 验证指标：IoU 不够，还要看宽度误差

分割任务常用 IoU 和 Dice 系数，但裂缝检测有个特殊需求：宽度测量精度。IoU 高不代表宽度准，因为裂缝很细，边缘差一两个像素，IoU 可能还行，但宽度误差已经超过 10%。

我的做法是验证时同时算三个指标：IoU、Dice、以及骨架化后的平均宽度误差。骨架化用skimage.morphology.skeletonize，把预测掩码和真值掩码都细化成单像素线，再统计每条裂缝的平均宽度，对比两者的相对误差。

from skimage.morphology import skeletonize import numpy as np def width_error(pred_mask, gt_mask): """基于距离变换估算平均宽度误差""" from scipy.ndimage import distance_transform_edt pred_skel = skeletonize(pred_mask > 0) gt_skel = skeletonize(gt_mask > 0) # 距离变换：每个前景像素到最近背景的距离，骨架处乘 2 即宽度 pred_dist = distance_transform_edt(pred_mask > 0) gt_dist = distance_transform_edt(gt_mask > 0) pred_width = pred_dist[pred_skel].mean() * 2 gt_width = gt_dist[gt_skel].mean() * 2 return abs(pred_width - gt_width) / (gt_width + 1e-6)

这个指标比 IoU 更贴近工程需求。如果 IoU 0.75 但宽度误差 15%，说明模型轮廓大致对，但边缘系统性偏胖或偏瘦，需要检查标注质量和损失权重。

5. 推理部署与工程化落地

5.1 从 PyTorch 模型到可调用接口

训练完的模型要落地，第一步是导出成推理友好的格式。直接拿 PyTorch 模型跑也行，但推理速度慢、依赖重。常见做法是导出 ONNX：

import torch model.eval() dummy = torch.randn(1, 3, 512, 512).to(device) torch.onnx.export( model, dummy, 'crack_unet.onnx', input_names=['input'], output_names=['output'], dynamic_axes={'input': {0: 'batch'}, 'output': {0: 'batch'}}, opset_version=11, )

dynamic_axes让 batch 维可变，部署时能一次处理多张图。opset_version=11兼容性好，别盲目追新版本，有些推理引擎对高版本算子支持不全。

导出后一定要验证 ONNX 和 PyTorch 输出一致：

import onnxruntime as ort import numpy as np sess = ort.InferenceSession('crack_unet.onnx') onnx_out = sess.run(None, {'input': dummy.cpu().numpy()})[0] torch_out = model(dummy).cpu().detach().numpy() print('max diff:', np.abs(onnx_out - torch_out).max())

差值应该在 1e-4 以内。如果差很多，多半是某个算子导出时行为变了，比如插值方式，这时候要回去检查模型里的上采样实现。

5.2 后处理：把掩码变成可测量的裂缝

模型输出的是概率图，要变成工程可用的结果，还需要后处理：

1. 阈值化：sigmoid 后大于 0.5 判为裂缝，这个阈值可以按验证集 F1 最优点调。
2. 连通域过滤：去掉面积小于 50 像素的碎块，这些多半是噪声。
3. 骨架化：细化成单像素线，用于宽度和长度测量。
4. 像素当量换算：根据拍摄距离和镜头参数，把像素宽度换算成毫米。

第 4 步是工程落地的关键。如果你拍摄时固定了工作距离，可以事先标定：在同样距离下拍一个已知尺寸的标定板，算出每像素对应多少毫米。这个系数一旦确定，所有同条件拍摄的图都能直接换算。

5.3 推理速度优化：别让模型成为瓶颈

在巡检设备上跑推理，速度往往比精度更卡脖子。几个实用优化：

• 输入分辨率降到 384×384，精度掉 1 到 2 个点，速度提升近一倍。
• 用 TensorRT 或 OpenVINO 做图优化，在对应硬件上能再快 2 到 3 倍。
• 批处理：一次推理多张图，GPU 利用率更高。

但要注意，分辨率降低会让细裂缝丢失。如果规范要求测 0.2 mm 裂缝，先算清楚 0.2 mm 在你的拍摄条件下占几个像素，如果降到 384 后不足 2 个像素，那就不能降。

6. 裂缝检测避坑清单：五个真实翻车现场

6.1 掩码全黑却显示 loss 很低

现象：训练几个 epoch 后 loss 降到 0.05 以下，但推理出来全是黑图。

原因：类别极度不平衡，模型学会了全预测背景。BCE 在这种情况下 loss 本来就低，如果你只用 BCE 没加 Dice，很容易掉进去。

解决：损失函数必须包含 Dice 或 Focal 这类对不平衡鲁棒的项。同时监控验证集的召回率，召回率接近 0 就是这个问题。

6.2 训练集指标很好，现场图一塌糊涂

现象：验证集 IoU 0.8，拿到现场拍的新图，模型几乎检不出裂缝。

原因：训练数据和现场数据分布不一致。公开数据集多是近距离、均匀光照，现场是远距离、阴影、水渍、接缝干扰。

解决：做域适应。最简单的办法是把现场图裁一小部分人工标注，加入训练集微调。更系统的做法是用风格迁移把公开数据转成现场风格，但工程量更大。我的经验是，哪怕只加 200 张现场标注图，效果提升都比调参明显。

6.3 裂缝断裂成好几段

现象：一条连续裂缝被预测成断续的几段。

原因：裂缝中间有阴影或污渍遮挡，模型在这些位置置信度低，阈值化后断开。

解决：后处理时做形态学闭运算，把邻近的段连起来。或者降低阈值到 0.3，但会引入更多误检，要权衡。更好的办法是训练时加入遮挡增强，让模型学会跨遮挡推断。

6.4 宽度测量系统性偏大

现象：模型测出的裂缝宽度普遍比人工测量大 20%。

原因：标注时掩码画得比实际裂缝宽，模型学到的是「偏胖」的裂缝。或者后处理时阈值太低，把裂缝边缘的过渡像素也算进去了。

解决：检查标注规范，要求标注人员贴着裂缝边缘画。同时把二值化阈值从 0.5 提到 0.6，让边缘更收紧。这两个动作做完，宽度误差通常能压到 5% 以内。

6.5 换台机器推理结果就变了

现象：同一张图，在训练机器上推理正常，部署到另一台机器结果完全不同。

原因：预处理不一致。训练时用了 ImageNet 均值方差归一化，部署时忘了做，或者用了不同的插值方式。

解决：把预处理和后处理封装成一个类，训练和推理共用同一份代码。别在两处各写一遍，迟早会不一致。这是最隐蔽的坑，因为模型本身没问题，错在数据管道。

7. 把裂缝宽度测准的一个关键技巧

前面讲了训练、部署、避坑，最后落到一个具体技巧上：怎么让像素宽度换算成物理宽度时更准。

大多数人做法是拿一个全局系数乘一下，但镜头有畸变，图像中心和边缘的像素当量不一样。边缘区域的裂缝，用中心系数换算会偏大。我的做法是分区域标定：把图像划成 3×3 九宫格，每个格子单独标定像素当量，换算时按裂缝所在格子取系数。这样能把边缘区域的宽度误差从 10% 压到 3% 以内。

标定流程用一张棋盘格标定板，在每个格子区域各拍一张，用 OpenCV 的calibrateCamera算畸变系数，再反推每个区域的像素当量。代码不复杂，但这一步做了和没做，测量精度是两个档次。

import cv2 import numpy as np # 棋盘格内角点数，按你的标定板改 pattern_size = (9, 6) objp = np.zeros((pattern_size[0] * pattern_size[1], 3), np.float32) objp[:, :2] = np.mgrid[0:pattern_size[0], 0:pattern_size[1]].T.reshape(-1, 2) objpoints, imgpoints = [], [] for fname in calib_images: img = cv2.imread(fname) gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY) ret, corners = cv2.findChessboardCorners(gray, pattern_size, None) if ret: objpoints.append(objp) imgpoints.append(corners) # 标定，得到内参和畸变系数 ret, mtx, dist, rvecs, tvecs = cv2.calibrateCamera( objpoints, imgpoints, gray.shape[::-1], None, None ) # 用畸变系数去畸变后再做像素当量换算 undistorted = cv2.undistort(img, mtx, dist, None, mtx)

mtx是内参矩阵，dist是畸变系数。去畸变之后，图像各处的像素当量才基本一致，这时候再用统一系数换算才合理。如果不去畸变直接分区域标定，等于用错误去补偿错误，精度提升有限。

我自己做这个方向踩过最大的坑，就是早期太相信「模型精度决定一切」，花大量时间调网络结构，后来发现现场测量误差主要来自标定和预处理，模型本身早就够用了。现在我的习惯是：模型 IoU 到 0.75 以上就不再折腾结构，把精力全放在数据质量和标定精度上。希望帮到你。

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