Kelp-RGBI: Kelp Segmentation Model for RGB+NIR Drone Imagery

Model Type: ONNX Semantic Segmentation
Application: Kelp forest detection in 4-band RGB+NIR aerial imagery
Input: 4-band imagery (Red, Green, Blue, Near-Infrared)
Output: Binary segmentation mask (kelp vs. non-kelp)

Model Description

The Kelp-RGBI model is a deep learning semantic segmentation model specifically trained for detecting kelp forests in 4-band RGB+NIR drone imagery. This model leverages the additional Near-Infrared band to improve kelp detection accuracy, particularly in challenging water conditions and for submerged kelp detection.

Key Features:

Optimized for 4-band RGB+NIR imagery from multispectral drones
Min-max normalization for robust performance across different sensors
Efficient ONNX format for cross-platform deployment
Enhanced accuracy through NIR spectral information

Model Details

Version: 20231214
Input Channels: 4 (RGB + Near-Infrared)
Input Size: Dynamic tiling (recommended: 2048x2048 tiles)
Normalization: Min-max normalization
Output: Multi-class segmentation (0: background, 1: giant kelp, 2: bull kelp)
Format: ONNX

Normalization Parameters

The model uses min-max normalization applied per image:

This means each input image is normalized to [0, 1] range using: (pixel - band_min_value) / (band_max_value - band_min_value)

Usage

1. Using kelp-o-matic CLI (recommended)

For command-line usage:

# Install kelp-o-matic
pip install git+https://github.com/HakaiInstitute/kelp-o-matic@dev

# List available models
kom list-models

# Run kelp species segmentation on RGB+NIR drone imagery
kom segment \
    --model kelp-rgbi \
    --input /path/to/rgbi_drone_image.tif \
    --output /path/to/kelp_species_segmentation.tif \
    --batch-size 6 \
    --crop-size 2048 \
    --blur-kernel 5 \
    --morph-kernel 3 \
    -b 1 \  # Specify -b flags to rearrange bands to Red, Green, Blue, NIR order
    -b 2 \
    -b 3 \
    -b 4

# Use specific model version
kom segment \
    --model kelp-rgbi \
    --version 20231214 \
    --input image.tif \
    --output result.tif

# For high-resolution multispectral imagery
kom segment \
    --model kelp-rgbi \
    --input high_res_multispectral.tif \
    --output result.tif \
    --batch-size 4 \
    --crop-size 1024 ]
    -b 3 \  # BGRI -> RGBI
    -b 2 \
    -b 1 \
    -b 4

2. Using kelp-o-matic Python API

The easiest way to use this model is through the kelp-o-matic package:

from kelp_o_matic import model_registry

# Load the model (automatically downloads if needed)
model = model_registry["kelp-rgbi"]

# Process a large multispectral image with automatic tiling
model.process(
    input_path="path/to/your/rgbi_drone_image.tif",
    output_path="path/to/output/kelp_species_segmentation.tif",
    batch_size=6,  # Moderate batch size for 4-band
    crop_size=2048,
    blur_kernel_size=5,  # Post-processing median blur
    morph_kernel_size=3,  # Morphological operations
    band_order=[1, 2, 3, 4],  # Ensure RGBI order
)

# For more control, use the predict method directly
import rasterio
import numpy as np

with rasterio.open("multispectral_image.tif") as src:
    # Read a 2048x2048 tile (4 bands: RGBI)
    tile = src.read(window=((0, 2048), (0, 2048)))  # Shape: (4, 2048, 2048)
    tile = np.transpose(tile, (1, 2, 0))  # Convert to HWC
    
    # Add batch dimension and predict
    batch = np.expand_dims(tile, axis=0)  # Shape: (1, 2048, 2048, 4)
    batch = np.transpose(batch, (0, 3, 1, 2))  # Convert to BCHW
    
    # Run inference (preprocessing handled automatically)
    predictions = model.predict(batch)
    
    # Post-process to get final segmentation
    segmentation = model.postprocess(predictions)
    # Result: 0=background, 1=giant kelp, 2=bull kelp

3. Direct ONNX Runtime Usage

import numpy as np
import onnxruntime as ort
from huggingface_hub import hf_hub_download

# Download the model
model_path = hf_hub_download(repo_id="HakaiInstitute/kelp-rgbi", filename="model.onnx")

# Load the model
session = ort.InferenceSession(model_path)

# Preprocess your 4-band image
def preprocess(image):
    """
    Preprocess 4-band RGBI image for model input
    image: numpy array of shape [height, width, 4] with any pixel value range
    """
    # Normalize to 0-1 first
    image = image.astype(np.float32) / 1.0
    
    # Apply min-max normalization per image
    img_min = image.min()
    img_max = image.max()
    image = (image - img_min) / (img_max - img_min + 1e-8)
    
    # Reshape to model input format [batch, channels, height, width]
    image = np.transpose(image, (2, 0, 1))  # HWC to CHW
    image = np.expand_dims(image, axis=0)  # Add batch dimension
    
    return image

# Run inference
preprocessed = preprocess(your_4band_image)
input_name = session.get_inputs()[0].name
output = session.run(None, {input_name: preprocessed})

# Postprocess to get class predictions
logits = output[0]  # Raw probabilities for each class
prediction = np.argmax(logits, axis=1).squeeze(0).astype(np.uint8)
# Result: 0=background, 1=giant kelp, 2=bull kelp

4. Using HuggingFace Hub Integration

from huggingface_hub import hf_hub_download
import onnxruntime as ort

# Download and load model
model_path = hf_hub_download(
    repo_id="HakaiInstitute/kelp-rgbi",
    filename="model.onnx",
    cache_dir="./models"
)

session = ort.InferenceSession(model_path)
# ... continue with preprocessing and inference as above

Installation

For kelp-o-matic usage:

# Via pip
pip install git+https://github.com/HakaiInstitute/kelp-o-matic@dev

For direct ONNX usage:

pip install onnxruntime huggingface-hub numpy
# For GPU support:
pip install onnxruntime-gpu

Input Requirements

Image Format: 4-band raster (GeoTIFF recommended)
Band Order: Red, Green, Blue, Near-Infrared
Pixel Values: Any range (model uses min-max normalization)
Spatial Resolution: Optimized for high-resolution drone imagery (cm-level)

Output Format

Type: Single-band raster with class labels
Values:
- 0: Background (water, other features)
- 1: Macrocystis pyrifera (Giant kelp)
- 2: Nereocystis luetkeana (Bull kelp)
Format: Matches input raster format and projection
Spatial Resolution: Same as input

Note: The model outputs class probabilities, but kelp-o-matic automatically applies argmax to convert these to discrete class labels.

Performance Notes

Dynamic Tile Size: Supports flexible tile sizes (recommended: 2048x2048 or 1024x1024)
Batch Size: Start with 4, adjust based on available GPU memory

Large Image Processing

For processing large geospatial images, the kelp-o-matic package handles:

Automatic Tiling: Splits large images into manageable tiles
Overlap Handling: Uses overlapping tiles to avoid edge artifacts
Memory Management: Processes tiles in batches to manage memory usage
Geospatial Metadata: Preserves coordinate reference system and geotransforms
Post-processing: Optional median filtering and morphological operations

Citation

If you use this model in your research, please cite:

@software{Denouden_Kelp-O-Matic,
  author = {Denouden, Taylor and Reshitnyk, Luba},
  doi = {10.5281/zenodo.7672166},
  title = {{Kelp-O-Matic}},
  url = {https://github.com/HakaiInstitute/kelp-o-matic}
}

License

MIT License - see the kelp-o-matic repository for details.

Related Resources

Documentation: kelp-o-matic.readthedocs.io
Source Code: github.com/HakaiInstitute/kelp-o-matic
Other Models: Check the Hakai Institute HuggingFace organization for additional kelp segmentation models

Contact

For questions or issues:

Open an issue on the GitHub repository
Contact: Hakai Institute

Downloads last month: -; Downloads are not tracked for this model. How to track