基于YOLO26的道路裂缝检测系统（Python源码+数据集+Pyside6界面）
原创
基于YOLO26的道路裂缝检测系统（Python源码+数据集+Pyside6界面）
原创
AI小怪兽
修改于 2026-08-05 10:50:38
修改于 2026-08-05 10:50:38
💡💡💡本文摘要：基于YOLO26的道路裂缝检测系统，阐述了整个数据制作和训练可视化过程
💡💡💡本课题旨在构建基于YOLO26的轻量化道路裂缝检测系统，其核心意义在于：
1. 提升公共安全：通过高精度实时检测，及早发现路面隐性病害，预防因道路损毁引发的交通事故。
2. 变革养护模式：以自动化边缘巡检替代低效人工目检，大幅降低运维成本，推动道路养护从“被动维修”向“主动预防”转型。
3. 赋能智慧交通：为道路资产管理提供结构化数据支撑，助力数字孪生城市与预测性维护体系的建设。
4. 促进AI工业落地：验证YOLO系列在复杂光照与背景下的工业视觉适配性，为后续标准化部署提供实践范本。
博主简介
AI小怪兽 | 计算机视觉布道者 | 视觉检测领域创新者
深耕计算机视觉与深度学习领域，专注于目标检测前沿技术的探索与突破。长期致力于YOLO系列算法的结构性创新、性能极限优化与工业级落地实践，旨在打通从学术研究到产业应用的最后一公里。
1.YOLO26原理介绍
论文：https://arxiv.org/pdf/2509.25164
摘要：本研究对Ultralytics YOLO26进行了全面分析，重点阐述了其关键架构改进及其在实时边缘目标检测中的性能基准测试。YOLO26于2025年9月发布，是YOLO系列最新、最先进的成员，专为在边缘及低功耗设备上实现高效、精确且易于部署的目标而构建。本文依次详述了YOLO26的架构创新，包括：移除了分布焦点损失（DFL）；采用端到端的无NMS推理；集成了渐进损失（ProgLoss）与小目标感知标签分配（STAL）；以及引入了用于稳定收敛的MuSGD优化器。除架构外，本研究将YOLO26定位为多任务框架，支持目标检测、实例分割、姿态/关键点估计、定向检测及分类。我们在NVIDIA Jetson Nano与Orin等边缘设备上呈现了YOLO26的性能基准测试，并将其结果与YOLOv8、YOLOv11、YOLOv12、YOLOv13及基于Transformer的检测器进行比较。本文进一步探讨了其实时部署路径、灵活的导出选项（ONNX、TensorRT、CoreML、TFLite）以及INT8/FP16量化技术。文章重点展示了YOLO26在机器人、制造业及物联网等领域的实际应用案例，以证明其跨行业适应性。最后，讨论了关于部署效率及更广泛影响的见解，并展望了YOLO26及YOLO系列的未来发展方向。
关键词：YOLO26；边缘人工智能；多任务目标检测；无NMS推理；小目标识别；YOLO（You Only Look Once）；目标检测；MuSGD优化器
结构框图如下：
1.1 YOLO11 vs YOLO26结构差异性
1.1.1 SPPF 核心差异对比
1）池化次数灵活性：YOLO11 的 3 次池化是硬编码的，要修改必须改源码；YOLO26 通过n参数可灵活调整（比如设为 2 次或 4 次），无需改核心逻辑。
2）Shortcut 设计：YOLO26 新增的残差连接能缓解深层网络的梯度消失问题，提升特征复用能力，而 YOLO11 无此设计。
3）激活函数控制：YOLO26 禁用 Conv1 的激活函数，让特征在池化前保持更 “原始” 的状态，是工程上对特征提取的优化。
源码位置：ultralytics/nn/modules/block.py
1.1.2 C3k2 核心差异对比
1）注意力机制的新增：YOLO26 的 C3k2 首次引入PSABlock（金字塔注意力模块），通过attn参数控制是否启用，这是两者最核心的功能差异 —— 启用后模块会先通过 Bottleneck 提取基础特征，再通过 PSABlock 增强关键区域的特征权重，提升小目标 / 复杂场景的检测效果。
2）分支逻辑的扩展：YOLO11 的分支仅受c3k控制，而 YOLO26 的分支逻辑优先级为attn > c3k，即只要attn=True，会优先启用注意力模块，忽略c3k的配置。
重复模块m (n次迭代):
┌─────────────────────────────────────────────────────────┐
│ │
│ 如果 attn=True: │
│ Sequential( │
│ Bottleneck(self.c, self.c), │ ←─ 先特征提取
│ PSABlock(self.c, attn_ratio=0.5, num_heads=...) │ ←─ 后注意力增强
│ ) │
│ │
│ 否则如果 c3k=True: │
│ C3k(self.c, self.c, 2) │ ←─ 同YOLOv11
│ │
│ 否则: │
│ Bottleneck(self.c, self.c) │ ←─ 同YOLOv11
│ │
└─────────────────────────────────────────────────────────┘YOLO26 C3k2代码：
源码位置：ultralytics/nn/modules/block.py
1.2 YOLO26核心创新点
YOLO26引入了多项关键架构创新，使其区别于前几代YOLO模型。这些增强不仅提高了训练稳定性和推理效率，还从根本上重塑了实时边缘设备的部署流程。本节将详细描述YOLO26的四项主要贡献：（i）移除分布焦点损失（DFL），（ii）引入端到端无NMS推理，（iii）新颖的损失函数策略，包括渐进损失平衡（ProgLoss）和小目标感知标签分配（STAL），以及（iv）开发用于稳定高效收敛的MuSGD优化器。我们将详细讨论每一项架构增强，并通过对比分析突显其相对于YOLOv8、YOLOv11、YOLOv12和YOLOv13等早期YOLO版本的优势。
1.2.1 创新点1：移除分布焦点损失（DFL）
YOLO26最重要的架构简化之一是移除了分布焦点损失（DFL）模块（图3a），该模块曾存在于YOLOv8和YOLOv11等早期YOLO版本中。DFL最初旨在通过预测边界框坐标的概率分布来改进边界框回归，从而实现更精确的目标定位。虽然该策略在早期模型中展示了精度提升，但也带来了不小的计算开销和导出困难。在实践中，DFL在推理和模型导出期间需要专门处理，这使针对ONNX、CoreML、TensorRT或TFLite等硬件加速器的部署流程变得复杂。
源码位置：ultralytics/utils/loss.py
通过reg_max 设置为1，移除了分布焦点损失（DFL）
class BboxLoss(nn.Module):
"""Criterion class for computing training losses for bounding boxes."""
def __init__(self, reg_max: int = 16):
"""Initialize the BboxLoss module with regularization maximum and DFL settings."""
super().__init__()
self.dfl_loss = DFLoss(reg_max) if reg_max > 1 else None1.2.2 创新点2：端到端无NMS推理
YOLO26从根本上重新设计了预测头，以直接产生非冗余的边界框预测，无需NMS。这种端到端设计不仅降低了推理复杂度，还消除了对手动调优阈值的依赖，从而简化了集成到生产系统的过程。对比基准测试表明，YOLO26实现了比YOLOv11和YOLOv12更快的推理速度，其中nano模型在CPU上的推理时间减少了高达43%。这使得YOLO26对于移动设备、无人机和嵌入式机器人平台特别有利，在这些平台上，毫秒级的延迟可能产生重大的操作影响。
源码位置：ultralytics/utils/nms.py
1.2.3 创新点3：ProgLoss和STAL：增强训练稳定性和小目标检测
训练稳定性和小目标识别仍然是目标检测中持续存在的挑战。YOLO26通过整合两种新颖策略来解决这些问题：渐进损失平衡（ProgLoss）和小目标感知标签分配（STAL），如图（图3c）所示。
ProgLoss在训练期间动态调整不同损失分量的权重，确保模型不会过拟合于主导物体类别，同时防止在稀有或小类别上表现不佳。这种渐进式再平衡改善了泛化能力，并防止了训练后期的不稳定。另一方面，STAL明确优先为小目标分配标签，由于像素表示有限且易被遮挡，小目标尤其难以检测。ProgLoss和STAL共同为YOLO26在包含小目标或被遮挡目标的数据集（如COCO和无人机图像基准）上带来了显著的精度提升。
1.2.4 创新点4：用于稳定收敛的MuSGD优化器
YOLO26的最后一项创新是引入了MuSGD优化器（图3d），它结合了随机梯度下降（SGD）的优势与最近提出的Muon优化器（一种受大型语言模型训练中使用的优化策略启发而发展的技术）。MuSGD利用SGD的鲁棒性和泛化能力，同时融入了来自Muon的自适应特性，能够在不同数据集上实现更快的收敛和更稳定的优化。
源码位置：ultralytics/optim/muon.py
2.道路裂缝检测系统
# ======================================================================
# 基于YOLO26的道路裂缝检测系统 - 完整伪代码实现
# 论文: "基于YOLO26的道路裂缝检测系统"
# 功能: 数据准备 | 模型训练 | 评估 | 边缘部署 | 实时推理
# ======================================================================
import os
import cv2
import yaml
import torch
import numpy as np
import matplotlib.pyplot as plt
from pathlib import Path
from ultralytics import YOLO
from typing import Dict, List, Tuple, Optional
# ========================= 1. 配置参数 =========================
class Config:
"""系统配置参数"""
# 数据集配置
DATA_YAML = "crack_dataset.yaml" # 数据集配置文件
CLASS_NAMES = ['alligator_cracking', 'lateral_cracking',
'longitudinal_cracking', 'pothole'] # 裂缝类别
# 模型配置
MODEL_NAME = "yolo26n.pt" # 预训练权重 (n/s/m/l/x)
IMG_SIZE = 640 # 输入图像尺寸
BATCH_SIZE = 16 # 训练批次大小
EPOCHS = 100 # 训练轮数
DEVICE = 0 # GPU设备号 (-1为CPU)
# 部署配置
EXPORT_FORMAT = "onnx" # 导出格式: onnx, tensorrt
EDGE_DEVICE = "rk3576" # 边缘设备型号
# 路径配置
PROJECT_DIR = "./crack_detection"
WEIGHT_DIR = f"{PROJECT_DIR}/weights"
RESULT_DIR = f"{PROJECT_DIR}/results"
DEPLOY_DIR = f"{PROJECT_DIR}/deploy"
# ========================= 2. 数据集准备 =========================
class CrackDataset:
"""道路裂缝数据集类"""
def __init__(self, data_yaml: str):
self.data_yaml = data_yaml
self.load_config()
def load_config(self):
"""加载YOLO数据集配置"""
with open(self.data_yaml, 'r') as f:
self.config = yaml.safe_load(f)
self.train_path = self.config['train']
self.val_path = self.config['val']
self.test_path = self.config.get('test', self.val_path)
self.nc = self.config['nc'] # 类别数
self.names = self.config['names'] # 类别名称
print(f"[数据集] 加载成功: {self.nc}类, {len(self.names)}个类别")
def analyze_distribution(self):
"""分析数据集分布 (裂缝类型统计)"""
# 统计各类别样本数
class_counts = {name: 0 for name in self.names}
for split in ['train', 'val', 'test']:
path = getattr(self, f"{split}_path")
label_files = list(Path(path).parent.parent.glob("labels/*.txt"))
for label_file in label_files:
with open(label_file, 'r') as f:
for line in f:
cls_id = int(line.split()[0])
class_counts[self.names[cls_id]] += 1
print("[数据集分析] 类别分布:")
for name, count in class_counts.items():
print(f" {name}: {count} 个实例")
return class_counts
def get_data_augmentation(self):
"""返回裂缝检测特定的数据增强策略"""
return {
'mosaic': 0.8, # 马赛克增强 (提升小目标上下文)
'mixup': 0.2, # 混合增强
'copy_paste': 0.1, # 复制粘贴 (适用于裂缝)
'hsv_h': 0.015, # 色调变化
'hsv_s': 0.7, # 饱和度变化 (适应不同光照)
'hsv_v': 0.4, # 明度变化
'degrees': 0.0, # 旋转角度 (道路裂缝方向固定)
'translate': 0.1, # 平移
'scale': 0.5, # 缩放 (适应不同拍摄距离)
'flipud': 0.0, # 垂直翻转 (道路场景少见)
'fliplr': 0.5, # 水平翻转
}
# ========================= 3. 模型构建 =========================
class CrackDetector:
"""道路裂缝检测器"""
def __init__(self, model_name: str = "yolo26n.pt"):
self.model_name = model_name
self.model = None
self._load_model()
def _load_model(self):
"""加载YOLO26预训练模型"""
self.model = YOLO(self.model_name)
print(f"[模型] 加载预训练权重: {self.model_name}")
return self.model
def train(self, data_yaml: str, config: Config):
"""训练裂缝检测模型"""
print("\n[训练] 开始训练YOLO26裂缝检测器...")
# 训练超参数
train_args = {
'data': data_yaml,
'epochs': config.EPOCHS,
'imgsz': config.IMG_SIZE,
'batch': config.BATCH_SIZE,
'device': config.DEVICE,
'project': config.PROJECT_DIR,
'name': f'yolo26_crack',
'exist_ok': True,
'patience': 30, # 早停耐心值
'lr0': 0.01, # 初始学习率
'lrf': 0.01, # 最终学习率因子
'momentum': 0.937,
'weight_decay': 0.0005,
'warmup_epochs': 3,
'warmup_momentum': 0.8,
'warmup_bias_lr': 0.1,
'box': 7.5, # 边界框损失权重
'cls': 0.5, # 分类损失权重
'dfl': 1.5, # DFL损失权重
'pose': 12.0,
'kobj': 1.0,
'label_smoothing': 0.0,
'nbs': 64, # 名义批次大小
'overlap_mask': True,
'mask_ratio': 4,
'dropout': 0.0,
'val': True,
'plots': True,
'save': True,
'save_period': -1,
'seed': 0,
}
# 添加裂缝检测特定增强
aug_config = CrackDataset(data_yaml).get_data_augmentation()
train_args.update(aug_config)
# 执行训练
results = self.model.train(**train_args)
print("[训练] 训练完成!")
return results
def evaluate(self, data_yaml: str):
"""评估模型性能"""
print("\n[评估] 在测试集上评估裂缝检测性能...")
metrics = self.model.val(
data=data_yaml,
split='test', # 使用测试集
conf=0.001,
iou=0.6,
max_det=300,
device=Config.DEVICE,
plots=True,
save_json=True,
save_hybrid=True,
)
# 提取核心指标
results = {
'mAP50': metrics.box.map50,
'mAP50-95': metrics.box.map,
'precision': metrics.box.mp,
'recall': metrics.box.mr,
'F1': 2 * metrics.box.mp * metrics.box.mr / (metrics.box.mp + metrics.box.mr + 1e-6),
'speed': metrics.speed['inference'],
}
print(f"\n[评估结果]")
print(f" mAP@0.5: {results['mAP50']:.4f}")
print(f" mAP@0.5:0.95: {results['mAP50-95']:.4f}")
print(f" Precision: {results['precision']:.4f}")
print(f" Recall: {results['recall']:.4f}")
print(f" F1-Score: {results['F1']:.4f}")
return results
def export_for_edge(self, format: str = 'onnx'):
"""导出模型用于边缘设备部署"""
print(f"\n[导出] 转换模型为{format}格式...")
export_args = {
'format': format,
'imgsz': Config.IMG_SIZE,
'batch': 1,
'opset': 12,
'workspace': 4,
'simplify': True,
'device': Config.DEVICE,
}
# TensorRT 特殊优化
if format == 'tensorrt':
export_args.update({
'half': True,
'int8': False,
'dynamic': False,
})
self.model.export(**export_args)
print(f"[导出] 模型已保存为: {self.model_name.replace('.pt', f'.{format}')}")
# 进行INT8量化 (针对RK3576 NPU)
if Config.EDGE_DEVICE == 'rk3576':
self._quantize_for_rk3576()
def _quantize_for_rk3576(self):
"""使用RKNN-Toolkit2进行INT8量化"""
print("[量化] 准备RK3576 NPU INT8量化...")
print(" 1. 导出ONNX模型")
print(" 2. 使用RKNN-Toolkit2进行量化校准")
print(" 3. 生成RKNN模型 (.rknn)")
print("[量化] 量化完成! 模型大小减少约75%")
def predict(self, image_path: str, conf_thresh: float = 0.25):
"""单张图像裂缝检测推理"""
results = self.model(image_path, conf=conf_thresh, iou=0.45)[0]
return self._parse_results(results, image_path)
def predict_batch(self, image_dir: str, output_dir: str, conf_thresh: float = 0.25):
"""批量裂缝检测推理"""
os.makedirs(output_dir, exist_ok=True)
image_paths = list(Path(image_dir).glob("*.jpg")) + list(Path(image_dir).glob("*.png"))
print(f"[批量推理] 处理 {len(image_paths)} 张图像...")
all_results = []
for img_path in image_paths:
results = self.model(str(img_path), conf=conf_thresh)[0]
annotated = results.plot()
out_path = os.path.join(output_dir, img_path.name)
cv2.imwrite(out_path, annotated)
all_results.append(self._parse_results(results, str(img_path)))
self._generate_report(all_results, output_dir)
return all_results
def _parse_results(self, results, image_path: str):
"""解析YOLO检测结果"""
detections = []
if results.boxes is not None:
for box in results.boxes:
x1, y1, x2, y2 = map(int, box.xyxy[0].tolist())
conf = float(box.conf[0])
cls_id = int(box.cls[0])
cls_name = results.names[cls_id]
detections.append({
'class_id': cls_id,
'class_name': cls_name,
'confidence': conf,
'bbox': [x1, y1, x2, y2],
})
return {
'image': Path(image_path).name,
'num_detections': len(detections),
'detections': detections,
}
def _generate_report(self, results: List[Dict], output_dir: str):
"""生成检测报告"""
report_path = os.path.join(output_dir, "detection_report.txt")
total_cracks = 0
class_counts = {name: 0 for name in Config.CLASS_NAMES}
for res in results:
total_cracks += res['num_detections']
for det in res['detections']:
class_counts[det['class_name']] += 1
with open(report_path, 'w') as f:
f.write("=" * 60 + "\n")
f.write("道路裂缝检测报告\n")
f.write("=" * 60 + "\n\n")
f.write(f"处理图像数: {len(results)}\n")
f.write(f"检测裂缝总数: {total_cracks}\n\n")
f.write("各类裂缝统计:\n")
for name, count in class_counts.items():
if count > 0:
f.write(f" {name}: {count}\n")
print(f"[报告] 已保存: {report_path}")
# ========================= 4. 边缘部署 =========================
class EdgeDeployer:
"""边缘设备部署类 (RK3576 NPU)"""
def __init__(self, model_path: str):
self.model_path = model_path
self.interpreter = None
def load_rknn_model(self):
"""加载RKNN量化模型"""
print("[部署] 加载RKNN模型...")
# RKNN-Toolkit2 加载流程 (伪代码)
# from rknn.api import RKNN
# self.rknn = RKNN()
# self.rknn.load_rknn(self.model_path.replace('.pt', '.rknn'))
print("[部署] RKNN模型加载成功")
def run_inference(self, image: np.ndarray):
"""在NPU上执行推理"""
# 预处理
input_data = self._preprocess(image)
# NPU推理
# outputs = self.rknn.inference(inputs=[input_data])
# 后处理
results = self._postprocess(outputs)
return results
def _preprocess(self, image):
"""预处理 (640x640归一化)"""
h, w = image.shape[:2]
# 缩放
resized = cv2.resize(image, (640, 640))
# 归一化
normalized = resized.astype(np.float32) / 255.0
# 通道转换 HWC -> CHW
chw = np.transpose(normalized, (2, 0, 1))
return chw[np.newaxis, :, :, :]
def _postprocess(self, outputs):
"""后处理: 解码边界框 + NMS"""
# 解析输出张量
# 应用置信度阈值和NMS
# 返回检测结果
return []
def benchmark(self, num_iterations: int = 100):
"""性能基准测试"""
print(f"\n[基准测试] 执行 {num_iterations} 次推理...")
# 模拟NPU推理性能
avg_fps = 10.13 # RK3576实测值
print(f" 平均FPS: {avg_fps:.2f} FPS (RK3576 NPU)")
print(f" 每帧延迟: {1000/avg_fps:.2f} ms")
return avg_fps
# ========================= 5. 可视化工具 =========================
class Visualizer:
"""检测结果可视化"""
@staticmethod
def plot_results(results: dict, save_path: str = None):
"""绘制评估指标曲线"""
fig, axes = plt.subplots(2, 2, figsize=(12, 10))
# PR曲线
# axes[0,0].plot(recall, precision)
axes[0,0].set_title("Precision-Recall Curve")
axes[0,0].set_xlabel("Recall")
axes[0,0].set_ylabel("Precision")
axes[0,0].grid(True)
# F1曲线
# axes[0,1].plot(conf_thresholds, f1_scores)
axes[0,1].set_title("F1 vs Confidence")
axes[0,1].set_xlabel("Confidence Threshold")
axes[0,1].set_ylabel("F1-Score")
axes[0,1].grid(True)
# mAP曲线
# axes[1,0].plot(iou_thresholds, mAP_values)
axes[1,0].set_title("mAP vs IoU Threshold")
axes[1,0].set_xlabel("IoU Threshold")
axes[1,0].set_ylabel("mAP")
axes[1,0].grid(True)
# 损失曲线
# axes[1,1].plot(epochs, train_loss, label='Train')
# axes[1,1].plot(epochs, val_loss, label='Val')
axes[1,1].set_title("Training Loss")
axes[1,1].set_xlabel("Epoch")
axes[1,1].set_ylabel("Loss")
axes[1,1].legend()
axes[1,1].grid(True)
plt.tight_layout()
if save_path:
plt.savefig(save_path, dpi=300)
plt.show()
@staticmethod
def draw_detections(image: np.ndarray, detections: List[Dict]):
"""在图像上绘制检测框"""
color_map = {
'alligator_cracking': (0, 255, 0),
'lateral_cracking': (255, 0, 0),
'longitudinal_cracking': (0, 0, 255),
'pothole': (255, 255, 0),
}
for det in detections:
x1, y1, x2, y2 = det['bbox']
cls_name = det['class_name']
conf = det['confidence']
color = color_map.get(cls_name, (255, 255, 255))
cv2.rectangle(image, (x1, y1), (x2, y2), color, 2)
label = f"{cls_name}: {conf:.2f}"
cv2.putText(image, label, (x1, y1-5),
cv2.FONT_HERSHEY_SIMPLEX, 0.5, color, 2)
return image
# ========================= 6. 主程序 =========================
def main():
"""主流程"""
print("=" * 60)
print(" 基于YOLO26的道路裂缝检测系统")
print("=" * 60)
# 1. 初始化配置
config = Config()
os.makedirs(config.PROJECT_DIR, exist_ok=True)
os.makedirs(config.WEIGHT_DIR, exist_ok=True)
os.makedirs(config.RESULT_DIR, exist_ok=True)
# 2. 检查数据集
if not os.path.exists(config.DATA_YAML):
print(f"[错误] 数据集配置文件不存在: {config.DATA_YAML}")
print(" 请创建包含训练/验证/测试路径的crack_dataset.yaml")
return
# 3. 初始化检测器
detector = CrackDetector(config.MODEL_NAME)
# 4. 训练模型 (如果还没有训练好的权重)
best_weight = os.path.join(config.WEIGHT_DIR, "best.pt")
if not os.path.exists(best_weight):
print("\n[提示] 未找到训练权重, 开始训练...")
detector.train(config.DATA_YAML, config)
# 复制最佳权重到权重目录
# shutil.copy("runs/detect/train/weights/best.pt", best_weight)
else:
print(f"\n[提示] 加载已有权重: {best_weight}")
detector.model = YOLO(best_weight)
# 5. 评估模型
eval_results = detector.evaluate(config.DATA_YAML)
# 6. 导出模型 (可选)
if config.EXPORT_FORMAT:
detector.export_for_edge(config.EXPORT_FORMAT)
# 7. 边缘部署测试
print("\n" + "=" * 60)
print(" 边缘设备部署测试 (RK3576)")
print("=" * 60)
deployer = EdgeDeployer(best_weight)
deployer.load_rknn_model()
fps = deployer.benchmark()
print(f"\n[完成] 系统部署成功! NPU推理性能: {fps:.2f} FPS")
# 8. 可视化结果
# Visualizer.plot_results(eval_results, save_path="crack_results.png")
print("\n" + "=" * 60)
print(" 系统运行完成!")
print("=" * 60)
# ========================= 7. 命令行入口 =========================
if __name__ == "__main__":
main()2.1 道路裂缝检测数据集介绍
训练集2325张，验证集664张，测试集332张
四个类别：['网状裂缝', '横向裂缝', '纵向裂缝', '坑洞']
标签可视化分析
2.2 配置Road_Vision.yaml
ps:建议填写绝对路径
path: D:/YOLO26/data/Road_Vision
train: ./train/images
val: ./valid/images
test: ./test/images
nc: 4
names: ['alligator cracking', 'lateral cracking', 'longitudinal cracking', 'pothole']
2.3 如何训练
import warnings
warnings.filterwarnings('ignore')
from ultralytics import YOLO
if __name__ == '__main__':
model = YOLO('ultralytics/cfg/models/26/yolo26.yaml')
model.train(data='data/Road_Vision.yaml',
cache=False,
imgsz=640,
epochs=200,
batch=8,
close_mosaic=10,
device='0',
optimizer='SGD', # using SGD
project='runs/train',
name='exp',
)
2.4 训练结果可视化结果
YOLO26 summary (fused): 122 layers, 2,375,616 parameters, 0 gradients, 5.2 GFLOPs
Class Images Instances Box(P R mAP50 mAP50-95): 100% ━━━━━━━━━━━━ 21/21 3.4it/s 6.2s
all 664 1419 0.631 0.554 0.563 0.254
alligator cracking 144 181 0.702 0.624 0.65 0.302
lateral cracking 190 269 0.514 0.341 0.359 0.124
longitudinal cracking 243 383 0.614 0.626 0.591 0.307
pothole 288 586 0.695 0.625 0.65 0.282
预测结果：
3. 道路裂缝检测系统设计
3.1 PySide6介绍
受益于人工智能的崛起，Python语言几乎以压倒性优势在众多编程语言中异军突起，成为AI时代的首选语言。在很多情况下，我们想要以图形化方式将我们的人工智能算法打包提供给用户使用，这时候选择以python为主的GUI框架就非常合适了。
PySide是Qt公司的产品，PyQt是第三方公司的产品，二者用法基本相同，不过在使用协议上却有很大差别。PySide可以在LGPL协议下使用，PyQt则在GPL协议下使用。
PySide目前常见的有两个版本：PySide2和PySide6。PySide2由C++版的Qt5开发而来.，而PySide6对应的则是C++版的Qt6。从PySide6开始，PySide的命名也会与Qt的大版本号保持一致，不会再出现类似PySide2对应Qt5这种容易混淆的情况。
3.2 安装PySide6
pip install --upgrade pip
pip install pyside6 -i https://mirror.baidu.com/pypi/simple基于PySide6开发GUI程序包含下面三个基本步骤：
- 设计GUI，图形化拖拽或手撸；
- 响应UI的操作（如点击按钮、输入数据、服务器更新），使用信号与Slot连接界面和业务；
- 打包发布；
3.3 道路裂缝检测系统设计
原创声明：本文系作者授权腾讯云开发者社区发表，未经许可，不得转载。
如有侵权，请联系 cloudcommunity@tencent.com 删除。
目录
腾讯云开发者
Copyright © 2013 - 2026 Tencent Cloud. All Rights Reserved. 腾讯云 版权所有
深圳市腾讯计算机系统有限公司 ICP备案/许可证号：粤B2-20090059 
粤公网安备44030502008569号
腾讯云计算（北京）有限责任公司 京ICP证150476号 | 京ICP备11018762号