从理论到实践：一揽子5777张路面积水分割数据集，YOLO道路积水检测算法实战教程

文章前瞻：优质数据集与检测系统精选

点击链接：

目录

一、数据集介绍

【数据集】路面积水分割数据集 5777 张 ，目标检测， 包含COCO的json格式、Labelme的json格式、yolo的txt格式标注 。

数据集中包含 1 种分类 ，具体分类为：names = ['puddle']，对应 ['路面积水']。

数据集图片来自国内外网站、网络爬虫等；

可用于 路面积水分割识别 。

检测场景为 城区道路、乡镇道路、园区、工厂等 ，可以应用于 交通动态管控、市政排水调度，行人安全保障，内涝隐患排查 等 。

文章底部名片或主页私信获取数据集~

1、数据概述

路面积水分割识别的重要性

路面积水是雨天及城市内涝高发期的典型隐患：轻则导致车辆打滑（雨天积水路段刹车距离显著增加）、行人滑倒，重则引发车辆熄火、道路塌陷，甚至因积水掩盖窨井、坑洼造成致命事故，多数城市雨天道路事故中，有相当比例与路面积水直接相关。​

传统路面积水检测存在明显短板：人工巡查受雨天视野、安全条件限制，单名巡检员日均覆盖路段有限，漏检情况较多；固定水位传感器仅能监测特定点位，无法覆盖全域路面，且难以有效区分 “积水区域” 与 “潮湿路面”。​

YOLO 算法通过 “实时分割 + 精准定位” 破解上述痛点：其一，依托城市道路监控摄像头，可实现高帧率实时检测，对积水区域的分割准确率较高，能快速区分明显积水与普通潮湿路面；其二，可同步输出积水位置（精确到车道）、面积及估算深度，无需额外大规模布设传感器，显著降低覆盖成本；其三，检测延迟极短，能在积水刚形成时触发预警，避免隐患扩大，为道路安全与城市内涝防控提供关键技术支撑。

基于YOLO的道路积水分割算法

1. 交通动态管控：YOLO 实时识别积水路段后，联动交通诱导屏推送 “积水预警 + 绕行建议”，并通知交管部门临时限流，应用后雨天积水路段交通事故率明显下降，通行效率得到有效提升。​

2. 市政排水调度：根据 YOLO 输出的积水位置、面积及深度数据，系统自动匹配就近排水泵站，调节抽排功率，优先处理主干道、下穿隧道等关键区域积水，试点区域内涝消退时间大幅缩短。​

3. 行人安全保障：在人行道、学校门口等区域，YOLO 检测到积水后，触发路边声光提醒（如 “前方积水，注意绕行”），并通过城市 APP 推送至周边行人，显著减少滑倒事故，相关投诉量大幅降低。​

4. 内涝隐患排查：通过 YOLO 长期积累的积水数据，可分析高频积水点（如低洼路段、排水口堵塞区域），指导市政部门针对性改造（如垫高路面、扩容排水管道），从源头减少积水隐患，城区高频积水点数量明显减少。

该数据集含有 5777 张图片， Labelme 的 JSON 格式、 COCO JSON 格式、 YOLO 的 txt 格式，用于训练和测试 城区道路、乡镇道路、园区、工厂等场景进行道路积水检测 。

图片格式为jpg格式，标注格式分别为：

coco：Json

labelme：Json

YOLO：TXT

数据集为 labelme 标注，保证标注精确度。

2、数据集文件结构

puddle_seg /

——test/

————Annotations/

————images/

————labels/

————test_coco.json

——train/

————Annotations/

————images/

————labels/

————train_coco.json

——valid/

————Annotations/

————images/

————labels/

————valid_coco.json

——data.yaml

• 该数据集已划分训练集样本，分别是： test 目录（测试集）、 train 目录（训练集）、 valid 目录（验证集）；
• Annotations文件夹为 TXT格式 的标注文件
• images文件夹为 jpg格式 的数据样本；
• labels文件夹是 labelme格式 的 JSON文件；(txt格式可通过脚本转换，yolo分割模型需要txt格式)
• coco.json是coco格式的分割标注文件
• data.yaml是数据集配置文件，包含 道路积水识别 的目标分类和加载路径。

json格式的标注文件 内容如下：

{
  "version": "5.8.1",
  "flags": {},
  "shapes": [
    {
      "label": "puddle",
      "points": [
        [
          2.5,
          0.0
        ],
        [
          0.0,
          450.0
        ],
        [
          30.0,
          485.0
        ],
        [
          77.5,
          512.5
        ],
        [
          132.5,
          532.5
        ],
        [
          337.5,
          637.5
        ],
        [
          637.5,
          635.0
        ],
        [
          637.5,
          0.0
        ],
        [
          2.5,
          0.0
        ]
      ],
      "group_id": null,
      "description": null,
      "shape_type": "polygon",
      "flags": {},
      "mask": null
    }
  ],
  "imagePath": "image31_jpeg_jpg.rf.1dd36f1ed8aa32142cf4e720d5bee895.jpg",
  "imageData": null,
  "imageHeight": 640,
  "imageWidth": 640
}

3、数据集适用范围

• 实例分割识别 场景， 监控摄像头识别，无人机识别
• yolo训练模型或其他模型
• 城区道路、乡镇道路、园区、工厂等场景
• 可以用于 交通动态管控、市政排水调度，行人安全保障，内涝隐患排查 等。

4、数据集标注结果

​  ​​​​​​ ​  ​​​​

​  ​​​​  ​​​​​​​​​​​​​​​​​​​​​ ​ ​​​​​

4.1、数据集内容

1. 多角度场景： 监控摄像头 视角，行人视角；
2. 标注内容： 1个 分类；
3. 图片总量： 5777 张图片数据；
4. 标注类型： labelme Json 格式、 coco Json 格式、 YOLO txt 格式；

5、训练过程

5.1、数据标注文件格式转换（如果需要json转txt）

新建json2Txt.py文件，将数据集的标签名称以及输入输出路径在main函数里修改，转换之后的txt文件作文模型的训练标签文件。

import json
import os
from pathlib import Path
def labelme_to_yolo(json_path, output_dir, class_list):
    """
    将LabelMe的JSON文件转换为YOLO格式的TXT文件
    参数:
        json_path: LabelMe JSON文件路径
        output_dir: 输出目录路径
        class_list: 类别名称列表
    """
    # 确保输出目录存在
    Path(output_dir).mkdir(parents=True, exist_ok=True)
    # 读取JSON文件
    with open(json_path, 'r', encoding='utf-8') as f:
        data = json.load(f)
    # 获取图像尺寸
    img_width = data['imageWidth']
    img_height = data['imageHeight']
    # 准备输出TXT文件路径
    txt_filename = Path(json_path).stem + '.txt'
    txt_path = os.path.join(output_dir, txt_filename)
    with open(txt_path, 'w', encoding='utf-8') as f:
        for shape in data['shapes']:
            # 获取类别名称和索引
            label = shape['label']
            class_index = class_list.index(label)
            # 获取多边形或矩形点
            points = shape['points']
            # 处理不同形状
            if shape['shape_type'] == 'rectangle':
                # 矩形转换为YOLO格式 (x_center, y_center, width, height)
                x_min = min(points[0][0], points[1][0])
                x_max = max(points[0][0], points[1][0])
                y_min = min(points[0][1], points[1][1])
                y_max = max(points[0][1], points[1][1])
                x_center = (x_min + x_max) / 2 / img_width
                y_center = (y_min + y_max) / 2 / img_height
                width = (x_max - x_min) / img_width
                height = (y_max - y_min) / img_height
                f.write(f"{class_index} {x_center:.6f} {y_center:.6f} {width:.6f} {height:.6f}\n")
            elif shape['shape_type'] == 'polygon':
                # 多边形转换为YOLO格式 (class_index x1 y1 x2 y2 ...)
                normalized_points = []
                for point in points:
                    normalized_x = point[0] / img_width
                    normalized_y = point[1] / img_height
                    normalized_points.extend([normalized_x, normalized_y])
                points_str = ' '.join([f"{p:.6f}" for p in normalized_points])
                f.write(f"{class_index} {points_str}\n")
            elif shape['shape_type'] == 'circle':
                # 圆转换为YOLO格式 (近似为矩形)
                center_x, center_y = points[0]
                radius_x = abs(points[1][0] - center_x)
                radius_y = abs(points[1][1] - center_y)
                x_min = (center_x - radius_x) / img_width
                y_min = (center_y - radius_y) / img_height
                x_max = (center_x + radius_x) / img_width
                y_max = (center_y + radius_y) / img_height
                x_center = (x_min + x_max) / 2
                y_center = (y_min + y_max) / 2
                width = x_max - x_min
                height = y_max - y_min
                f.write(f"{class_index} {x_center:.6f} {y_center:.6f} {width:.6f} {height:.6f}\n")
def batch_convert_labelme_to_yolo(json_dir, output_dir, class_list):
    """
    批量转换LabelMe JSON文件为YOLO格式
    参数:
        json_dir: 包含LabelMe JSON文件的目录
        output_dir: 输出目录路径
        class_list: 类别名称列表
    """
    json_files = [f for f in os.listdir(json_dir) if f.endswith('.json')]
    for json_file in json_files:
        json_path = os.path.join(json_dir, json_file)
        labelme_to_yolo(json_path, output_dir, class_list)
    print(f"转换完成! 共转换了 {len(json_files)} 个文件。")
if __name__ == '__main__':
    # 示例用法
    JSON_DIR = 'test/labels'  # LabelMe JSON文件所在目录
    OUTPUT_DIR = 'test/txt'  # 输出TXT文件目录
    CLASS_LIST = ['puddle']  # 类别列表，顺序对应YOLO的类别索引
    batch_convert_labelme_to_yolo(JSON_DIR, OUTPUT_DIR, CLASS_LIST)

5.2、导入训练数据

下载 项目压缩包，解压在任意本地workspace文件夹中。

下载 ，导入到 ultralytics-main 项目根目录下。

​​

在 ultralytics-main 项目根目录下，创建data文件夹，并在data文件夹下创建子文件夹： images、labels， 其中，将 YOLO格式的TXT文件 手动导入到Annotations文件夹中，将 JPG格式的图像数据 导入到images文件夹中。

（注：数据集文件包中train、test、valid三个文件夹的images和labels合并）

data目录结构如下：

​​​​​​

5.3、数据划分

首先在ultralytics-main目录下创建一个split.py文件，运行文件之后会在ultralytics-main目录下生成datasets文件夹，具体目录如下：

训练集、验证集、测试集已经完成划分。

import shutil
import random
import os
# 原始路径
image_original_path = "data/images/"
label_original_path = "data/labels/"
# 数据集划分比例（可以自定义）
train_percent = 0.8
val_percent = 0.1
test_percent = 0.1
cur_path = os.getcwd()
# 训练集路径
train_image_path = os.path.join(cur_path, "datasets/images/train/")
train_label_path = os.path.join(cur_path, "datasets/labels/train/")
# 验证集路径
val_image_path = os.path.join(cur_path, "datasets/images/val/")
val_label_path = os.path.join(cur_path, "datasets/labels/val/")
# 测试集路径
test_image_path = os.path.join(cur_path, "datasets/images/test/")
test_label_path = os.path.join(cur_path, "datasets/labels/test/")
# 训练集目录
list_train = os.path.join(cur_path, "datasets/train.txt")
list_val = os.path.join(cur_path, "datasets/val.txt")
list_test = os.path.join(cur_path, "datasets/test.txt")
def del_file(path):
    for i in os.listdir(path):
        file_data = path + "\\" + i
        os.remove(file_data)
def mkdir():
    if not os.path.exists(train_image_path):
        os.makedirs(train_image_path)
    else:
        del_file(train_image_path)
    if not os.path.exists(train_label_path):
        os.makedirs(train_label_path)
    else:
        del_file(train_label_path)
    if not os.path.exists(val_image_path):
        os.makedirs(val_image_path)
    else:
        del_file(val_image_path)
    if not os.path.exists(val_label_path):
        os.makedirs(val_label_path)
    else:
        del_file(val_label_path)
    if not os.path.exists(test_image_path):
        os.makedirs(test_image_path)
    else:
        del_file(test_image_path)
    if not os.path.exists(test_label_path):
        os.makedirs(test_label_path)
    else:
        del_file(test_label_path)
def clearfile():
    if os.path.exists(list_train):
        os.remove(list_train)
    if os.path.exists(list_val):
        os.remove(list_val)
    if os.path.exists(list_test):
        os.remove(list_test)
def main():
    mkdir()
    clearfile()
    file_train = open(list_train, 'w')
    file_val = open(list_val, 'w')
    file_test = open(list_test, 'w')
    total_txt = os.listdir(label_original_path)
    num_txt = len(total_txt)
    list_all_txt = range(num_txt)
    num_train = int(num_txt * train_percent)
    num_val = int(num_txt * val_percent)
    num_test = num_txt - num_train - num_val
    train = random.sample(list_all_txt, num_train)
    # train从list_all_txt取出num_train个元素
    # 所以list_all_txt列表只剩下了这些元素
    val_test = [i for i in list_all_txt if not i in train]
    # 再从val_test取出num_val个元素，val_test剩下的元素就是test
    val = random.sample(val_test, num_val)
    print("训练集：{}, 验证集：{}, 测试集：{}".format(len(train), len(val), len(val_test) - len(val)))
    for i in list_all_txt:
        name = total_txt[i][:-4]
        srcImage = image_original_path + name + '.jpg'
        srcLabel = label_original_path + name + ".txt"
        if i in train:
            dst_train_Image = train_image_path + name + '.jpg'
            dst_train_Label = train_label_path + name + '.txt'
            shutil.copyfile(srcImage, dst_train_Image)
            shutil.copyfile(srcLabel, dst_train_Label)
            file_train.write(dst_train_Image + '\n')
        elif i in val:
            dst_val_Image = val_image_path + name + '.jpg'
            dst_val_Label = val_label_path + name + '.txt'
            shutil.copyfile(srcImage, dst_val_Image)
            shutil.copyfile(srcLabel, dst_val_Label)
            file_val.write(dst_val_Image + '\n')
        else:
            dst_test_Image = test_image_path + name + '.jpg'
            dst_test_Label = test_label_path + name + '.txt'
            shutil.copyfile(srcImage, dst_test_Image)
            shutil.copyfile(srcLabel, dst_test_Label)
            file_test.write(dst_test_Image + '\n')
    file_train.close()
    file_val.close()
    file_test.close()
if __name__ == "__main__":
    main()

5.4、修改数据集配置文件

在ultralytics-main目录下创建一个data.yaml文件

path: ../datasets/images
train: train  # 数据集路径下的train
val: val  # 数据集路径下的val
test: test  # 数据集路径下的test
# 标签个数
nc: 1
# Classes标签名称
names: ['puddle']

5.5、执行命令

在ultralytics-main目录下创建一个train.py文件，运行

from ultralytics import YOLO
if __name__ == '__main__':
    model = YOLO("yolo11s-seg.pt")
    model.train(data=r'data.yaml',
                imgsz=640,
                epochs=100,
                batch=16,
                workers=0,
                device='0'
                )

也可以在终端执行下述命令：

yolo segment train data=data.yaml model=yolo11s-seg.pt epochs=200 imgsz=640 batch=16 workers=0 device=0

5.6、模型预测

在ultralytics-main目录下创建一个test_pic文件夹，导入测试集图片，在ultralytics-main目录下新建predict.py预测脚本文件，运行后会在 run/segment/predict 文件夹下生成推理图片。

代码如下：

import warnings
warnings.filterwarnings('ignore')
from ultralytics import YOLO
if __name__ == '__main__':
    model = YOLO('runs/segment/train/weights/best.pt')
    model.predict(source='test_pic',
                  imgsz=640,
                  device='0',
                  save=True
                  )

6、获取数据集

文章底部名片或主页私信获取数据集~

——————————————————————————

更多数据集请查看