遥感道路提取数据集，约10万张图像，512*512尺寸，分辨率从0.5米到2.5米不等，涵盖国内外众多城市（武汉北京澳门香港深圳巴黎芝加哥上海东京喀土穆）等遥感道路数据集

qq767172261

于 2024-09-29 06:26:50 发布

阅读量276

点赞数 5

分类专栏：数据集文章标签：获取QQ767172261 数据集遥感道路提取数据集

本文链接：https://blog.csdn.net/2301_78240361/article/details/142625571

版权

数据集专栏收录该内容

240 篇文章 10 订阅

订阅专栏

遥感道路提取数据集，约10万张图像，512*512尺寸，分辨率从0.5米到2.5米不等，涵盖国内外众多城市（武汉北京澳门香港深圳巴黎芝加哥上海东京喀土穆）等

遥感道路提取数据集介绍

数据集概览

总图像数量: 约100,000张
图像尺寸: 512x512像素
分辨率范围: 0.5米到2.5米不等
涵盖城市:
- 国内: 武汉、北京、澳门、香港、深圳、上海
- 国外: 巴黎、芝加哥、东京、喀土穆
任务类型: 语义分割（道路提取）
标注情况: 每张图像都有对应的像素级标注，用于区分道路和其他地物
数据集大小: 根据图像数量和尺寸，估计在几十GB到几百GB之间

数据集结构

假设数据集文件夹结构如下：

remote_sensing_road_extraction_dataset/
├── images/
│   ├── train/
│   ├── val/
│   └── test/
├── masks/
│   ├── train/  # 像素级标注
│   ├── val/
│   └── test/
└── README.md

images/ 目录下存放原始遥感图像。
masks/ 目录下存放对应的像素级标注图像，其中道路用白色表示，非道路区域用黑色表示。
README.md 文件包含数据集的使用说明和字段解释。

使用场景

城市规划: 提供高精度的道路信息，辅助城市规划和基础设施建设。
交通管理: 用于实时交通监控和交通流量分析。
自动驾驶: 为自动驾驶车辆提供精确的道路信息，支持路径规划和导航。
灾害响应: 在自然灾害发生时，快速提取道路信息，支持救援和疏散路线规划。

数据特性

多城市覆盖: 数据集涵盖了国内外多个城市的遥感图像，具有广泛的地理代表性。
不同分辨率: 图像分辨率从0.5米到2.5米不等，适用于不同尺度的道路提取需求。
多样化环境: 包含城市、郊区和农村等多种环境，有助于模型在不同场景下的泛化能力。

Keras 训练代码示例

以下是一个使用Keras框架进行道路提取模型训练的代码示例。我们将使用U-Net架构，这是一种广泛应用于语义分割任务的网络结构。

首先，确保你已经安装了所需的依赖项。你可以通过以下命令安装Keras和其他必要的库：

pip install keras tensorflow opencv-python

然后，创建一个配置文件 config.yaml 来指定数据集路径和相关参数：

train_images_dir: /path/to/remote_sensing_road_extraction_dataset/images/train
train_masks_dir: /path/to/remote_sensing_road_extraction_dataset/masks/train
val_images_dir: /path/to/remote_sensing_road_extraction_dataset/images/val
val_masks_dir: /path/to/remote_sensing_road_extraction_dataset/masks/val
test_images_dir: /path/to/remote_sensing_road_extraction_dataset/images/test
test_masks_dir: /path/to/remote_sensing_road_extraction_dataset/masks/test

image_size: [512, 512]
batch_size: 32
epochs: 50

接下来，使用以下脚本进行训练：

import os
import yaml
import numpy as np
import cv2
from tensorflow.keras.models import Model
from tensorflow.keras.layers import Input, Conv2D, MaxPooling2D, UpSampling2D, Concatenate, BatchNormalization, Activation
from tensorflow.keras.optimizers import Adam
from tensorflow.keras.callbacks import EarlyStopping, ModelCheckpoint, ReduceLROnPlateau
from sklearn.model_selection import train_test_split
from tensorflow.keras.utils import to_categorical

# 读取配置文件
with open('config.yaml', 'r') as f:
    config = yaml.safe_load(f)

# 数据集路径
train_images_dir = config['train_images_dir']
train_masks_dir = config['train_masks_dir']
val_images_dir = config['val_images_dir']
val_masks_dir = config['val_masks_dir']

# 图像生成器
def data_generator(images_dir, masks_dir, batch_size=32):
    image_files = os.listdir(images_dir)
    while True:
        for i in range(0, len(image_files), batch_size):
            batch_image_files = image_files[i:i + batch_size]
            batch_images = []
            batch_masks = []
            for file_name in batch_image_files:
                image_path = os.path.join(images_dir, file_name)
                mask_path = os.path.join(masks_dir, file_name)
                
                image = cv2.imread(image_path)
                mask = cv2.imread(mask_path, cv2.IMREAD_GRAYSCALE)
                
                image = cv2.resize(image, (config['image_size'][0], config['image_size'][1]))
                mask = cv2.resize(mask, (config['image_size'][0], config['image_size'][1]))
                
                batch_images.append(image)
                batch_masks.append(mask)
            
            batch_images = np.array(batch_images) / 255.0
            batch_masks = np.array(batch_masks) / 255.0
            batch_masks = to_categorical(batch_masks, num_classes=2)  # 二分类：道路和非道路
            
            yield batch_images, batch_masks

# 定义U-Net模型
def create_unet(input_shape=(512, 512, 3)):
    inputs = Input(shape=input_shape)

    # 编码器
    conv1 = Conv2D(64, (3, 3), activation='relu', padding='same')(inputs)
    conv1 = Conv2D(64, (3, 3), activation='relu', padding='same')(conv1)
    pool1 = MaxPooling2D(pool_size=(2, 2))(conv1)

    conv2 = Conv2D(128, (3, 3), activation='relu', padding='same')(pool1)
    conv2 = Conv2D(128, (3, 3), activation='relu', padding='same')(conv2)
    pool2 = MaxPooling2D(pool_size=(2, 2))(conv2)

    conv3 = Conv2D(256, (3, 3), activation='relu', padding='same')(pool2)
    conv3 = Conv2D(256, (3, 3), activation='relu', padding='same')(conv3)
    pool3 = MaxPooling2D(pool_size=(2, 2))(conv3)

    conv4 = Conv2D(512, (3, 3), activation='relu', padding='same')(pool3)
    conv4 = Conv2D(512, (3, 3), activation='relu', padding='same')(conv4)
    drop4 = Dropout(0.5)(conv4)
    pool4 = MaxPooling2D(pool_size=(2, 2))(drop4)

    # 中间层
    conv5 = Conv2D(1024, (3, 3), activation='relu', padding='same')(pool4)
    conv5 = Conv2D(1024, (3, 3), activation='relu', padding='same')(conv5)
    drop5 = Dropout(0.5)(conv5)

    # 解码器
    up6 = Conv2D(512, (2, 2), activation='relu', padding='same')(UpSampling2D(size=(2, 2))(drop5))
    merge6 = concatenate([drop4, up6], axis=3)
    conv6 = Conv2D(512, (3, 3), activation='relu', padding='same')(merge6)
    conv6 = Conv2D(512, (3, 3), activation='relu', padding='same')(conv6)

    up7 = Conv2D(256, (2, 2), activation='relu', padding='same')(UpSampling2D(size=(2, 2))(conv6))
    merge7 = concatenate([conv3, up7], axis=3)
    conv7 = Conv2D(256, (3, 3), activation='relu', padding='same')(merge7)
    conv7 = Conv2D(256, (3, 3), activation='relu', padding='same')(conv7)

    up8 = Conv2D(128, (2, 2), activation='relu', padding='same')(UpSampling2D(size=(2, 2))(conv7))
    merge8 = concatenate([conv2, up8], axis=3)
    conv8 = Conv2D(128, (3, 3), activation='relu', padding='same')(merge8)
    conv8 = Conv2D(128, (3, 3), activation='relu', padding='same')(conv8)

    up9 = Conv2D(64, (2, 2), activation='relu', padding='same')(UpSampling2D(size=(2, 2))(conv8))
    merge9 = concatenate([conv1, up9], axis=3)
    conv9 = Conv2D(64, (3, 3), activation='relu', padding='same')(merge9)
    conv9 = Conv2D(64, (3, 3), activation='relu', padding='same')(conv9)
    conv9 = Conv2D(2, (3, 3), activation='relu', padding='same')(conv9)
    conv10 = Conv2D(1, (1, 1), activation='sigmoid')(conv9)

    model = Model(inputs, conv10)
    return model

# 创建模型
model = create_unet()

# 编译模型
model.compile(optimizer=Adam(lr=0.0001), loss='binary_crossentropy', metrics=['accuracy'])

# 打印模型概要
model.summary()

# 设置回调函数
early_stopping = EarlyStopping(monitor='val_loss', patience=10, restore_best_weights=True)
checkpoint = ModelCheckpoint('best_road_extraction_model.h5', save_best_only=True, monitor='val_loss', mode='min')
reduce_lr = ReduceLROnPlateau(monitor='val_loss', factor=0.1, patience=5, min_lr=1e-6)

# 训练模型
batch_size = config['batch_size']
epochs = config['epochs']

train_gen = data_generator(train_images_dir, train_masks_dir, batch_size)
val_gen = data_generator(val_images_dir, val_masks_dir, batch_size)

history = model.fit(
    train_gen,
    steps_per_epoch=len(os.listdir(train_images_dir)) // batch_size,
    epochs=epochs,
    validation_data=val_gen,
    validation_steps=len(os.listdir(val_images_dir)) // batch_size,
    callbacks=[early_stopping, checkpoint, reduce_lr]
)

# 保存模型
model.save('road_extraction_model.h5')

# 可视化训练过程
import matplotlib.pyplot as plt

plt.figure(figsize=(12, 4))
plt.subplot(1, 2, 1)
plt.plot(history.history['accuracy'], label='Training Accuracy')
plt.plot(history.history['val_accuracy'], label='Validation Accuracy')
plt.legend()
plt.title('Accuracy')

plt.subplot(1, 2, 2)
plt.plot(history.history['loss'], label='Training Loss')
plt.plot(history.history['val_loss'], label='Validation Loss')
plt.legend()
plt.title('Loss')

plt.show()

代码说明

数据生成器:
- 使用自定义的数据生成器data_generator来加载和预处理数据。
- 从指定目录中读取图像和对应的掩码，并进行缩放和归一化处理。
模型构建:
- 构建U-Net模型，包括编码器和解码器部分。
- 编码器部分逐步减少空间维度并增加特征维度。
- 解码器部分逐步恢复空间维度并减少特征维度。
- 使用跳跃连接将编码器和解码器对应层的信息结合起来。
模型编译:
- 使用Adam优化器，学习率为0.0001。
- 损失函数为二元交叉熵损失，评估指标为准确率。
模型训练:
- 使用fit方法进行训练，设置早停机制、最佳模型保存和学习率衰减。
- 训练过程中会记录训练集和验证集的准确率和损失。
可视化:
- 训练完成后，绘制训练集和验证集的准确率和损失曲线，帮助分析模型的训练效果。