|
--- |
|
license: mit |
|
library_name: transformers |
|
tags: |
|
- Aerial Image Segmentation |
|
- Road Detection |
|
- Semantic Segmentation |
|
- U-Net-50 |
|
- Computer Vision |
|
- Remote Sensing |
|
- Urban Planning |
|
- Geographic Information Systems (GIS) |
|
- Deep Learning |
|
datasets: |
|
- balraj98/massachusetts-roads-dataset |
|
--- |
|
|
|
# Model Card for Model ID |
|
|
|
This model card provides an overview of a computer vision model designed for aerial image road segmentation using the U-Net-50 architecture. The model is intended to accurately identify and segment road networks from aerial imagery, crucial for applications in mapping and autonomous driving. |
|
|
|
## Model Details |
|
|
|
### Model Description |
|
|
|
- **Developed by:** [spectrewolf8](https://github.com/Spectrewolf8) |
|
- **Model type:** Computer-Vision/Semantic-segmentation |
|
- **License:** MIT |
|
|
|
### Model Sources |
|
|
|
- **Repository:** https://github.com/Spectrewolf8/aerial-image-road-segmentation-xp |
|
|
|
## Uses |
|
|
|
### Direct Use |
|
|
|
This model can be used to segment road networks from aerial images without additional fine-tuning. It is applicable in scenarios where detailed and accurate road mapping is required. |
|
|
|
### Downstream Use |
|
|
|
When fine-tuned on additional datasets, this model can be adapted for other types of semantic segmentation tasks, potentially enhancing applications in various remote sensing domains. |
|
|
|
## How to Get Started with the Model |
|
|
|
Use the code below to get started with the model. |
|
|
|
```python |
|
# Import necessary classes |
|
from tensorflow.keras.models import load_model |
|
from tensorflow.python.keras import layers |
|
from tensorflow.python.keras.models import Sequential |
|
|
|
import random |
|
import numpy as np |
|
import matplotlib.pyplot as plt |
|
from tensorflow.keras.preprocessing.image import ImageDataGenerator |
|
|
|
seed=24 |
|
batch_size= 8 |
|
|
|
# Load images for dataset generators from respective dataset libraries. The images and masks are returned as NumPy arrays |
|
|
|
# Images can be further resized by adding target_size=(150, 150) with any size for your network to flow_from_directory parameters |
|
# Our images are already cropped to 256x256 so traget_size parameter can be ignored |
|
|
|
def image_and_mask_generator(image_dir, label_dir): |
|
img_data_gen_args = dict(rescale = 1/255.) |
|
mask_data_gen_args = dict() |
|
|
|
image_data_generator = ImageDataGenerator(**img_data_gen_args) |
|
image_generator = image_data_generator.flow_from_directory(image_dir, |
|
seed=seed, |
|
batch_size=batch_size, |
|
classes = ["."], |
|
class_mode=None #Very important to set this otherwise it returns multiple numpy arrays thinking class mode is binary. |
|
) |
|
|
|
mask_data_generator = ImageDataGenerator(**mask_data_gen_args) |
|
mask_generator = mask_data_generator.flow_from_directory(label_dir, |
|
classes = ["."], |
|
seed=seed, |
|
batch_size=batch_size, |
|
color_mode = 'grayscale', #Read masks in grayscale |
|
class_mode=None |
|
) |
|
# print processed image paths for vanity |
|
print(image_generator.filenames[0:5]) |
|
print(mask_generator.filenames[0:5]) |
|
|
|
generator = zip(image_generator, mask_generator) |
|
return generator |
|
|
|
# Method to calculate Intersection over Union Accuracy Coefficient |
|
def iou_coef(y_true, y_pred, smooth=1e-6): |
|
intersection = tensorflow.reduce_sum(y_true * y_pred) |
|
union = tensorflow.reduce_sum(y_true) + tensorflow.reduce_sum(y_pred) - intersection |
|
|
|
return (intersection + smooth) / (union + smooth) |
|
|
|
# Method to calculate Dice Accuracy Coefficient |
|
def dice_coef(y_true, y_pred, smooth=1e-6): |
|
intersection = tensorflow.reduce_sum(y_true * y_pred) |
|
total = tensorflow.reduce_sum(y_true) + tensorflow.reduce_sum(y_pred) |
|
|
|
return (2. * intersection + smooth) / (total + smooth) |
|
|
|
# Method to calculate Dice Loss |
|
def soft_dice_loss(y_true, y_pred): |
|
return 1-dice_coef(y_true, y_pred) |
|
|
|
# Method to create generator |
|
def create_generator(zipped): |
|
for (img, mask) in zipped: |
|
yield (img, mask) |
|
|
|
model_path = "path" |
|
u_net_model = load_model(model_path, custom_objects={'soft_dice_loss': soft_dice_loss, 'dice_coef': dice_coef, "iou_coef": iou_coef}) |
|
|
|
test_generator = create_generator(image_and_mask_generator(output_test_image_dir,output_test_label_dir)) |
|
|
|
# Assuming create_generator is defined and provides images for prediction |
|
images, ground_truth_masks = next(test_generator) |
|
|
|
# Make predictions |
|
predictions = u_net_model.predict(images) |
|
|
|
# Apply threshold to predictions |
|
thresh_val = 0.8 |
|
prediction_threshold = (predictions > thresh_val).astype(np.uint8) |
|
|
|
# Visualize results |
|
num_samples = min(10, len(images)) # Use at most 10 samples or the total number of images available |
|
f = plt.figure(figsize=(15, 25)) |
|
for i in range(num_samples): |
|
ix = random.randint(0, len(images) - 1) # Ensure ix is within range |
|
|
|
f.add_subplot(num_samples, 4, i * 4 + 1) |
|
plt.imshow(images[ix]) |
|
plt.title("Image") |
|
plt.axis('off') |
|
|
|
f.add_subplot(num_samples, 4, i * 4 + 2) |
|
plt.imshow(np.squeeze(ground_truth_masks[ix])) |
|
plt.title("Ground Truth") |
|
plt.axis('off') |
|
|
|
f.add_subplot(num_samples, 4, i * 4 + 3) |
|
plt.imshow(np.squeeze(predictions[ix])) |
|
plt.title("Prediction") |
|
plt.axis('off') |
|
|
|
f.add_subplot(num_samples, 4, i * 4 + 4) |
|
plt.imshow(np.squeeze(prediction_threshold[ix])) |
|
plt.title(f"Thresholded at {thresh_val}") |
|
plt.axis('off') |
|
|
|
plt.show() |
|
|
|
``` |
|
|
|
|
|
## Training Details |
|
|
|
### Training Data |
|
|
|
The model was trained on the Massachusetts Roads Dataset, which includes high-resolution aerial images with corresponding road segmentation masks. The images were preprocessed by cropping into 256x256 patches and converting masks to binary format. |
|
|
|
### Training Procedure |
|
|
|
#### Preprocessing |
|
|
|
- Images were cropped into 256x256 patches to manage memory usage and improve training efficiency. |
|
- Masks were binarized to create clear road/non-road classifications. |
|
|
|
#### Training Hyperparameters |
|
|
|
- **Training regime:** FP32 precision |
|
- **Epochs:** 2 |
|
- **Batch Size:** 8 |
|
- **Learning Rate:** 0.0001 |
|
|
|
## Evaluation |
|
|
|
### Testing Data, Factors & Metrics |
|
|
|
#### Testing Data |
|
|
|
The model was evaluated using a separate set of aerial images and their corresponding ground truth masks from the dataset. |
|
|
|
#### Metrics |
|
|
|
- **Intersection over Union (IoU):** Measures the overlap between predicted and actual road areas. |
|
- **Dice Coefficient:** Evaluates the similarity between predicted and ground truth masks. |
|
|
|
### Results |
|
|
|
The model achieved 71% accuracy in segmenting road networks from aerial images, with evaluation metrics indicating good performance in distinguishing road features from non-road areas. |
|
|
|
#### Summary |
|
|
|
The U-Net-50 model effectively segments road networks, demonstrating its potential for practical applications in urban planning and autonomous systems. |
|
## Technical Specifications |
|
|
|
### Model Architecture and Objective |
|
|
|
- **Architecture:** U-Net-50 |
|
- **Objective:** Road segmentation in aerial images |
|
|
|
### Compute Infrastructure |
|
|
|
#### Software |
|
|
|
- **Framework:** TensorFlow 2.x |
|
- **Dependencies:** Keras, OpenCV, tifffile |
|
|
|
**BibTeX:** |
|
|
|
@misc{aerial-image-road-segmentation-with-U-NET-xp, |
|
author = {spectrewolf8}, |
|
title = {Aerial Image Road Segmentation Using U-Net-50}, |
|
year = {2024}, |
|
howpublished = {\url{https://github.com/Spectrewolf8/aerial-image-road-segmentation-xp}}, |
|
} |
