EdgeFirst/yolo26-seg

YOLO26 Segmentation — EdgeFirst Edge AI

NXP i.MX 8M Plus | NXP i.MX 93 | NXP i.MX 95 | NXP Ara240 | RPi5 + Hailo-8/8L | NVIDIA Jetson YOLO26 Segmentation models optimized for edge AI deployment across multiple hardware platforms. All sizes from Nano to XLarge, in ONNX FP32 and TFLite INT8 formats, with platform-specific compiled models for NPU acceleration.

Trained on COCO 2017 (80 classes). Part of the EdgeFirst Model Zoo.

[!TIP] Training session: View on EdgeFirst Studio — dataset, training config, metrics, and exported artifacts.

[!NOTE] end2end=False required for INT8. Fastest architecture.

Size Comparison

All models validated on COCO val2017 (5000 images, 80 classes).

On-Target Performance

Full pipeline timing: pre-processing + inference + post-processing.

Measured with EdgeFirst Perception stack. Timing includes full GStreamer pipeline overhead.

Downloads

ONNX FP32 — Any platform with ONNX Runtime.

TFLite INT8 — CPU or NPU via runtime delegate (i.MX 8M Plus VX Delegate).

Deploy with EdgeFirst Perception

Copy-paste GStreamer pipeline examples for each platform.

NXP i.MX 8M Plus — Camera to Detection with Vivante NPU

gst-launch-1.0 \
  v4l2src device=/dev/video0 ! video/x-raw,width=640,height=480 ! \
  edgefirstcameraadaptor ! \
  tensor_filter framework=tensorflow-lite \
    model=yolo26n-seg-coco.tflite \
    custom=Delegate:External,ExtDelegateLib:libvx_delegate.so ! \
  edgefirstsegdecoder ! edgefirstoverlay ! waylandsink

RPi5 + Hailo-8L

gst-launch-1.0 \
  v4l2src device=/dev/video0 ! video/x-raw,width=640,height=480 ! \
  hailonet hef-path=yolo26n-seg-coco.hailo8l.hef ! \
  hailofilter function-name=yolo26_nms ! \
  hailooverlay ! videoconvert ! autovideosink

NVIDIA Jetson (TensorRT)

gst-launch-1.0 \
  v4l2src device=/dev/video0 ! video/x-raw,width=640,height=480 ! \
  edgefirstcameraadaptor ! \
  nvinfer config-file-path=yolo26n-seg-coco-config.txt ! \
  edgefirstsegdecoder ! edgefirstoverlay ! nveglglessink

Full pipeline documentation: EdgeFirst GStreamer Plugins

Foundation (HAL) Python Integration

from edgefirst.hal import Model, TensorImage

# Load model — metadata (labels, decoder config) is embedded in the file
model = Model("yolo26n-seg-coco.tflite")

# Run inference on an image
image = TensorImage.from_file("image.jpg")
results = model.predict(image)

# Access detections
for det in results.detections:
    print(f"{det.label}: {det.confidence:.2f} at {det.bbox}")

EdgeFirst HAL — Hardware abstraction layer with accelerated inference delegates.

CameraAdaptor

EdgeFirst CameraAdaptor enables training and inference directly on native sensor formats (GREY, YUYV, etc.) — skipping the ISP color conversion pipeline entirely. This reduces latency and power consumption on edge devices.

CameraAdaptor variants are included alongside baseline RGB models:

Train CameraAdaptor models with EdgeFirst Studio — the CameraAdaptor layer is automatically inserted during training.

Train Your Own with EdgeFirst Studio

Train on your own dataset with EdgeFirst Studio:

• Free tier includes YOLO training with automatic INT8 quantization and edge deployment
• Upload datasets via EdgeFirst Recorder or COCO/YOLO format
• AI-assisted annotation with auto-labeling
• CameraAdaptor integration for native sensor format training
• Deploy trained models to edge devices via EdgeFirst Client

See Also

Other models in the EdgeFirst Model Zoo:

Technical Details

Quantization Pipeline

All TFLite INT8 models are produced by EdgeFirst's custom quantization pipeline (details):

1. ONNX Export — Standard Ultralytics export with simplify=True
2. TF-Wrapped ONNX — Box coordinates normalized to [0,1] inside DFL decode via tf_wrapper (~1.2% better mAP than post-hoc normalization)
3. Split Decoder — Boxes, scores, and mask coefficients split into separate output tensors for independent INT8 quantization scales
4. Smart Calibration — 500 images selected via greedy coverage maximization from COCO val2017
5. Full INT8 — uint8 input (raw pixels), int8 output (per-tensor scales), MLIR quantizer

Split Decoder Output Format

Segmentation (e.g., yolo26n-seg):

• Boxes: (1, 4, 8400) — normalized [0,1] coordinates
• Scores: (1, 80, 8400) — class probabilities
• Mask coefficients: (1, 32, 8400) — per-anchor mask coefs
• Protos: (1, 160, 160, 32) — prototype masks

Each tensor has independent quantization scale and zero-point. EdgeFirst HAL handles dequantization and reassembly automatically.

Metadata

• TFLite: edgefirst.json, labels.txt, and edgefirst.yaml embedded via ZIP (no tflite-support dependency)
• ONNX: edgefirst.json embedded via model.metadata_props

No standalone metadata files — models are self-contained.

Limitations

• COCO bias — Models trained on COCO (80 classes) inherit its biases: Western-centric scenes, specific object distributions, limited weather/lighting diversity
• INT8 accuracy loss — Full-integer quantization typically degrades mAP by 6-12% relative to FP32; actual loss depends on model architecture and dataset
• Thermal variation — On-target performance varies with device temperature; sustained inference may throttle on passively-cooled devices
• Input resolution — All models expect 640×640 input; other resolutions require letterboxing or may reduce accuracy
• CameraAdaptor variants — GREY/YUYV models trade color information for latency; accuracy may differ from RGB baseline depending on the task

Citation

@software{edgefirst_yolo26_seg,
  title = { {YOLO26 Segmentation — EdgeFirst Edge AI} },
  author = {Au-Zone Technologies},
  url = {https://huggingface.co/EdgeFirst/yolo26-seg},
  year = {2026},
  license = {Apache-2.0},
}

[EdgeFirst Studio](https://edgefirst.studio) · [GitHub](https://github.com/EdgeFirstAI) · [Docs](https://doc.edgefirst.ai) · [Au-Zone Technologies](https://www.au-zone.com)  

Apache 2.0 · © Au-Zone Technologies Inc.