sebastientaylor commited on
Commit
0e5291f
Β·
verified Β·
1 Parent(s): f0b6d53

Update model card for yolo11-det

Browse files
Files changed (1) hide show
  1. README.md +97 -144
README.md CHANGED
@@ -9,14 +9,11 @@ tags:
9
  - onnx
10
  - int8
11
  - yolo
12
- - gstreamer
13
  - edgefirst
14
  - nxp
15
  - hailo
16
  - jetson
17
- - real-time
18
  - embedded
19
- - multiplatform
20
  model-index:
21
  - name: yolo11-det
22
  results:
@@ -28,231 +25,187 @@ model-index:
28
  metrics:
29
  - name: "mAP@0.5 (Nano ONNX FP32)"
30
  type: map_50
31
- value: 53.4
32
  - name: "mAP@0.5-0.95 (Nano ONNX FP32)"
33
  type: map
34
- value: 37.9
35
- - name: "mAP@0.5 (Nano TFLite INT8)"
36
  type: map_50
37
- value: 50.1
38
- - name: "mAP@0.5-0.95 (Nano TFLite INT8)"
39
  type: map
40
- value: 34.5
 
 
 
 
 
 
41
  ---
42
 
43
- # YOLO11 Detection β€” EdgeFirst Edge AI
44
 
45
- **NXP i.MX 8M Plus** | **NXP i.MX 93** | **NXP i.MX 95** | **NXP Ara240** | **RPi5 + Hailo-8/8L** | **NVIDIA Jetson**
46
- YOLO11 Detection 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.
 
47
 
48
- Trained on [COCO 2017](https://test.edgefirst.studio/public/projects/2839/home) (80 classes). Part of the [EdgeFirst Model Zoo](https://huggingface.co/spaces/EdgeFirst/Models).
49
  > [!TIP]
50
- > **Training session**: [View on EdgeFirst Studio](https://test.edgefirst.studio/public/projects/2839/experiment/training/list?exp_id=4656) β€” dataset, training config, metrics, and exported artifacts.
51
 
52
  > [!NOTE]
53
- > Newer architecture with attention blocks.
54
 
55
  ---
56
 
57
- ## Size Comparison
58
 
59
- All models validated on COCO val2017 (5000 images, 80 classes).
60
 
61
- | Size | Params | GFLOPs | ONNX FP32 mAP@0.5 | ONNX FP32 mAP@0.5-0.95 | TFLite INT8 mAP@0.5 | TFLite INT8 mAP@0.5-0.95 |
62
- |------|--------|--------|--------------------|-------------------------|----------------------|--------------------------|
63
- | Nano | 2.6M | 6.5 | 53.4% | 37.9% | 50.1% | 34.5% |
64
- | Small | 9.4M | 21.5 | β€” | β€” | β€” | β€” |
65
- | Medium | 20.1M | 68.0 | β€” | β€” | β€” | β€” |
66
  | Large | 25.3M | 87.6 | β€” | β€” | β€” | β€” |
67
  | XLarge | 56.9M | 195.0 | β€” | β€” | β€” | β€” |
68
 
69
  ---
70
 
71
- ## On-Target Performance
72
-
73
- Full pipeline timing: pre-processing + inference + post-processing.
74
-
75
- | Size | Platform | Pre-proc (ms) | Inference (ms) | Post-proc (ms) | Total (ms) | FPS |
76
- |------|----------|---------------|----------------|-----------------|------------|-----|
77
- | β€” | β€” | β€” | β€” | β€” | β€” | β€” |
78
-
79
- *Measured with [EdgeFirst Perception](https://github.com/EdgeFirstAI) stack. Timing includes full GStreamer pipeline overhead.*
80
-
81
- ---
82
-
83
- ## Downloads
84
-
85
- <details open>
86
- <summary><strong>ONNX FP32</strong> β€” Any platform with ONNX Runtime.</summary>
87
-
88
- | Size | File | Status |
89
- |------|------|--------|
90
- | Nano | `yolo11n-det-coco.onnx` | [Download](https://huggingface.co/EdgeFirst/yolo11-det/resolve/main/onnx/yolo11n-det-coco.onnx) |
91
- | Small | `yolo11s-det-coco.onnx` | [Download](https://huggingface.co/EdgeFirst/yolo11-det/resolve/main/onnx/yolo11s-det-coco.onnx) |
92
- | Medium | `yolo11m-det-coco.onnx` | [Download](https://huggingface.co/EdgeFirst/yolo11-det/resolve/main/onnx/yolo11m-det-coco.onnx) |
93
- | Large | `yolo11l-det-coco.onnx` | [Download](https://huggingface.co/EdgeFirst/yolo11-det/resolve/main/onnx/yolo11l-det-coco.onnx) |
94
- | XLarge | `yolo11x-det-coco.onnx` | [Download](https://huggingface.co/EdgeFirst/yolo11-det/resolve/main/onnx/yolo11x-det-coco.onnx) |
95
-
96
- </details>
97
 
98
- <details>
99
- <summary><strong>TFLite INT8</strong> β€” CPU or NPU via runtime delegate (i.MX 8M Plus VX Delegate).</summary>
100
 
101
- | Size | File | Status |
102
- |------|------|--------|
103
- | Nano | `yolo11n-det-coco.tflite` | [Download](https://huggingface.co/EdgeFirst/yolo11-det/resolve/main/tflite/yolo11n-det-coco.tflite) |
104
- | Small | `yolo11s-det-coco.tflite` | [Download](https://huggingface.co/EdgeFirst/yolo11-det/resolve/main/tflite/yolo11s-det-coco.tflite) |
105
- | Medium | `yolo11m-det-coco.tflite` | [Download](https://huggingface.co/EdgeFirst/yolo11-det/resolve/main/tflite/yolo11m-det-coco.tflite) |
106
- | Large | `yolo11l-det-coco.tflite` | [Download](https://huggingface.co/EdgeFirst/yolo11-det/resolve/main/tflite/yolo11l-det-coco.tflite) |
107
- | XLarge | `yolo11x-det-coco.tflite` | [Download](https://huggingface.co/EdgeFirst/yolo11-det/resolve/main/tflite/yolo11x-det-coco.tflite) |
108
-
109
- </details>
110
 
 
 
 
 
 
 
 
 
111
 
112
 
113
  ---
114
 
115
- ## Deploy with EdgeFirst Perception
116
-
117
- Copy-paste [GStreamer](https://github.com/EdgeFirstAI/gstreamer) pipeline examples for each platform.
118
 
119
- ### NXP i.MX 8M Plus β€” Camera to Detection with Vivante NPU
120
 
121
- ```bash
122
- gst-launch-1.0 \
123
- v4l2src device=/dev/video0 ! video/x-raw,width=640,height=480 ! \
124
- edgefirstcameraadaptor ! \
125
- tensor_filter framework=tensorflow-lite \
126
- model=yolo11n-det-coco.tflite \
127
- custom=Delegate:External,ExtDelegateLib:libvx_delegate.so ! \
128
- edgefirstdetdecoder ! edgefirstoverlay ! waylandsink
129
- ```
130
 
131
- ### RPi5 + Hailo-8L
132
 
133
- ```bash
134
- gst-launch-1.0 \
135
- v4l2src device=/dev/video0 ! video/x-raw,width=640,height=480 ! \
136
- hailonet hef-path=yolo11n-det-coco.hailo8l.hef ! \
137
- hailofilter function-name=yolo11_nms ! \
138
- hailooverlay ! videoconvert ! autovideosink
139
- ```
140
 
141
- ### NVIDIA Jetson (TensorRT)
142
 
143
- ```bash
144
- gst-launch-1.0 \
145
- v4l2src device=/dev/video0 ! video/x-raw,width=640,height=480 ! \
146
- edgefirstcameraadaptor ! \
147
- nvinfer config-file-path=yolo11n-det-coco-config.txt ! \
148
- edgefirstdetdecoder ! edgefirstoverlay ! nveglglessink
149
- ```
150
 
 
151
 
152
- *Full pipeline documentation: [EdgeFirst GStreamer Plugins](https://github.com/EdgeFirstAI/gstreamer)*
153
 
154
  ---
155
 
156
- ## Foundation (HAL) Python Integration
157
 
158
  ```python
159
  from edgefirst.hal import Model, TensorImage
160
 
161
- # Load model β€” metadata (labels, decoder config) is embedded in the file
162
- model = Model("yolo11n-det-coco.tflite")
163
 
164
  # Run inference on an image
165
  image = TensorImage.from_file("image.jpg")
166
  results = model.predict(image)
167
 
168
- # Access detections
169
  for det in results.detections:
170
  print(f"{det.label}: {det.confidence:.2f} at {det.bbox}")
171
  ```
172
 
173
- *[EdgeFirst HAL](https://github.com/EdgeFirstAI/hal) β€” Hardware abstraction layer with accelerated inference delegates.*
174
 
175
  ---
176
 
177
- ## CameraAdaptor
178
 
179
- EdgeFirst [CameraAdaptor](https://github.com/EdgeFirstAI/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.
180
 
181
- CameraAdaptor variants are included alongside baseline RGB models:
182
-
183
- | Variant | Input Format | Use Case |
184
- |---------|-------------|----------|
185
- | `yolo11n-det-coco.onnx` | RGB (3ch) | Standard camera input |
186
- | `yolo11n-det-coco-grey.onnx` | GREY (1ch) | Monochrome / IR sensors |
187
- | `yolo11n-det-coco-yuyv.onnx` | YUYV (2ch) | Raw sensor bypass |
188
 
189
- *Train CameraAdaptor models with [EdgeFirst Studio](https://edgefirst.studio) β€” the CameraAdaptor layer is automatically inserted during training.*
190
 
191
  ---
192
 
193
- ## Train Your Own with EdgeFirst Studio
194
 
195
- Train on your own dataset with [**EdgeFirst Studio**](https://edgefirst.studio):
196
 
197
- - **Free tier** includes YOLO training with automatic INT8 quantization and edge deployment
198
- - Upload datasets via [EdgeFirst Recorder](https://github.com/EdgeFirstAI/recorder) or COCO/YOLO format
199
- - AI-assisted annotation with auto-labeling
200
- - CameraAdaptor integration for native sensor format training
201
- - Deploy trained models to edge devices via [EdgeFirst Client](https://github.com/EdgeFirstAI/client)
 
 
 
202
 
203
  ---
204
 
205
- ## See Also
206
 
207
- Other models in the [EdgeFirst Model Zoo](https://huggingface.co/spaces/EdgeFirst/Models):
208
 
209
- | Model | Task | Best Nano Metric | Link |
210
- |-------|------|-------------------|------|
211
- | YOLOv5 Detection | Detection | 49.6% mAP@0.5 (ONNX) | [EdgeFirst/yolov5-det](https://huggingface.co/EdgeFirst/yolov5-det) |
212
- | YOLOv8 Detection | Detection | 50.2% mAP@0.5 (ONNX) | [EdgeFirst/yolov8-det](https://huggingface.co/EdgeFirst/yolov8-det) |
213
- | YOLOv8 Segmentation | Segmentation | 34.1% Mask mAP@0.5-0.95 (ONNX) | [EdgeFirst/yolov8-seg](https://huggingface.co/EdgeFirst/yolov8-seg) |
214
- | YOLO11 Segmentation | Segmentation | 35.5% Mask mAP@0.5-0.95 (ONNX) | [EdgeFirst/yolo11-seg](https://huggingface.co/EdgeFirst/yolo11-seg) |
215
- | YOLO26 Detection | Detection | 54.9% mAP@0.5 (ONNX) | [EdgeFirst/yolo26-det](https://huggingface.co/EdgeFirst/yolo26-det) |
216
- | YOLO26 Segmentation | Segmentation | 37.0% Mask mAP@0.5-0.95 (ONNX) | [EdgeFirst/yolo26-seg](https://huggingface.co/EdgeFirst/yolo26-seg) |
217
 
218
  ---
219
 
220
- ## Technical Details
 
 
221
 
222
- ### Quantization Pipeline
223
 
224
- All TFLite INT8 models are produced by EdgeFirst's custom quantization pipeline ([details](https://github.com/EdgeFirstAI/studio-ultralytics)):
 
 
 
 
225
 
226
- 1. **ONNX Export** β€” Standard Ultralytics export with `simplify=True`
227
- 2. **TF-Wrapped ONNX** β€” Box coordinates normalized to [0,1] inside DFL decode via `tf_wrapper` (~1.2% better mAP than post-hoc normalization)
228
- 3. **Split Decoder** β€” Boxes, scores, and mask coefficients split into separate output tensors for independent INT8 quantization scales
229
- 4. **Smart Calibration** β€” 500 images selected via greedy coverage maximization from COCO val2017
230
- 5. **Full INT8** β€” `uint8` input (raw pixels), `int8` output (per-tensor scales), MLIR quantizer
231
 
232
- ### Split Decoder Output Format
233
 
234
- **Detection** (e.g., yolo11n):
235
- - Boxes: `(1, 4, 8400)` β€” normalized [0,1] coordinates
236
- - Scores: `(1, 80, 8400)` β€” class probabilities
237
 
238
- Each tensor has independent quantization scale and zero-point. EdgeFirst HAL handles dequantization and reassembly automatically.
239
 
240
- ### Metadata
241
 
242
- - **TFLite**: `edgefirst.json`, `labels.txt`, and `edgefirst.yaml` embedded via ZIP (no `tflite-support` dependency)
243
- - **ONNX**: `edgefirst.json` embedded via `model.metadata_props`
244
 
245
- No standalone metadata files β€” models are self-contained.
246
 
247
  ---
248
 
249
  ## Limitations
250
 
251
- - **COCO bias** β€” Models trained on COCO (80 classes) inherit its biases: Western-centric scenes, specific object distributions, limited weather/lighting diversity
252
- - **INT8 accuracy loss** β€” Full-integer quantization typically degrades mAP by 6-12% relative to FP32; actual loss depends on model architecture and dataset
253
- - **Thermal variation** β€” On-target performance varies with device temperature; sustained inference may throttle on passively-cooled devices
254
- - **Input resolution** β€” All models expect 640Γ—640 input; other resolutions require letterboxing or may reduce accuracy
255
- - **CameraAdaptor variants** β€” GREY/YUYV models trade color information for latency; accuracy may differ from RGB baseline depending on the task
256
 
257
  ---
258
 
@@ -260,7 +213,7 @@ No standalone metadata files β€” models are self-contained.
260
 
261
  ```bibtex
262
  @software{edgefirst_yolo11_det,
263
- title = { {YOLO11 Detection β€” EdgeFirst Edge AI} },
264
  author = {Au-Zone Technologies},
265
  url = {https://huggingface.co/EdgeFirst/yolo11-det},
266
  year = {2026},
 
9
  - onnx
10
  - int8
11
  - yolo
 
12
  - edgefirst
13
  - nxp
14
  - hailo
15
  - jetson
 
16
  - embedded
 
17
  model-index:
18
  - name: yolo11-det
19
  results:
 
25
  metrics:
26
  - name: "mAP@0.5 (Nano ONNX FP32)"
27
  type: map_50
28
+ value: 53.05
29
  - name: "mAP@0.5-0.95 (Nano ONNX FP32)"
30
  type: map
31
+ value: 37.83
32
+ - name: "mAP@0.5 (Small ONNX FP32)"
33
  type: map_50
34
+ value: 61.21
35
+ - name: "mAP@0.5-0.95 (Small ONNX FP32)"
36
  type: map
37
+ value: 44.91
38
+ - name: "mAP@0.5 (Medium ONNX FP32)"
39
+ type: map_50
40
+ value: 65.91
41
+ - name: "mAP@0.5-0.95 (Medium ONNX FP32)"
42
+ type: map
43
+ value: 49.59
44
  ---
45
 
46
+ # YOLO11 Detection β€” EdgeFirst Model Zoo
47
 
48
+ YOLO11 Detection models trained on [COCO 2017](https://test.edgefirst.studio/public/projects/2839/home) (80 classes) and validated on real edge hardware through the EdgeFirst Profiler + Validator pipeline. Each row in the tables below cites the EdgeFirst Studio validation session (`v-XXXX`) that produced the measurement.
49
+
50
+ Part of the [EdgeFirst Model Zoo](https://huggingface.co/spaces/EdgeFirst/Models).
51
 
 
52
  > [!TIP]
53
+ > **Training experiment**: [View on EdgeFirst Studio](https://test.edgefirst.studio/public/projects/2839/experiment/training/list?exp_id=4656) β€” dataset, training configuration, metrics, and exported artifacts.
54
 
55
  > [!NOTE]
56
+ > Architecture with C3k2 attention blocks.
57
 
58
  ---
59
 
60
+ ## Reference accuracy β€” ONNX FP32
61
 
62
+ Accuracy ceiling for each size, measured against COCO `val2017` (5,000 images) with `pycocotools`. Quantized and compiled artifacts (TFLite INT8, HEF, etc.) are graded against this reference per the EdgeFirst publication rule.
63
 
64
+ | Size | Params | GFLOPs | mAP@0.5 | mAP@0.5-0.95 | mAP@0.75 | Source |
65
+ |------|--------|--------|---------|--------------|----------|--------|
66
+ | Nano | 2.6M | 6.5 | 53.05% | 37.83% | 41.07% | [v-1d35](https://test.edgefirst.studio/public/validation/v-1d35/details?mode=metrics) |
67
+ | Small | 9.4M | 21.5 | 61.21% | 44.91% | 48.44% | [v-1d36](https://test.edgefirst.studio/public/validation/v-1d36/details?mode=metrics) |
68
+ | Medium | 20.1M | 68.0 | 65.91% | 49.59% | 53.80% | [v-1d37](https://test.edgefirst.studio/public/validation/v-1d37/details?mode=metrics) |
69
  | Large | 25.3M | 87.6 | β€” | β€” | β€” | β€” |
70
  | XLarge | 56.9M | 195.0 | β€” | β€” | β€” | β€” |
71
 
72
  ---
73
 
74
+ ## On-target validation results
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
75
 
76
+ Each row is one EdgeFirst Studio validation session. Click the **Source** link to inspect the full session β€” model artifact, dataset version, parameters, per-stage Perfetto trace, and the host hardware description (hostname, kernel version, SoC, NPU, profiler version).
 
77
 
78
+ Cells rendered as `β€”` are sessions that did not meet the EdgeFirst publication threshold; the underlying session is still linked in the Source column for inspection.
 
 
 
 
 
 
 
 
79
 
80
+ | Size | Platform | mAP@0.5 | Ξ” vs FP32 (pp) | mAP@0.5-0.95 | Inference (ms) | FPS (median) | Source |
81
+ |------|----------|---------|----------------|--------------|----------------|--------------|--------|
82
+ | Nano | NXP i.MX 8M Plus + VeriSilicon NPU | 49.91% | -3.14 | 35.22% | 88.33 | 9.2 | [v-1d4b](https://test.edgefirst.studio/public/validation/v-1d4b/details?mode=metrics) |
83
+ | Nano | NXP i.MX 95 + eIQ Neutron NPU | β€” | β€” | β€” | β€” | β€” | [v-1d51](https://test.edgefirst.studio/public/validation/v-1d51/details?mode=metrics) |
84
+ | Nano | Raspberry Pi 5 + Hailo-8L NPU | 51.28% | -1.77 | 36.37% | 18.92 | 51.1 | [v-1d3a](https://test.edgefirst.studio/public/validation/v-1d3a/details?mode=metrics) |
85
+ | Small | NXP i.MX 95 + eIQ Neutron NPU | β€” | β€” | β€” | β€” | β€” | [v-1d55](https://test.edgefirst.studio/public/validation/v-1d55/details?mode=metrics) |
86
+ | Small | Raspberry Pi 5 + Hailo-8L NPU | 59.92% | -1.29 | 43.71% | 38.93 | 25.2 | [v-1d3d](https://test.edgefirst.studio/public/validation/v-1d3d/details?mode=metrics) |
87
+ | Medium | Raspberry Pi 5 + Hailo-8L NPU | 64.56% | -1.35 | 48.30% | 72.74 | 13.6 | [v-1d40](https://test.edgefirst.studio/public/validation/v-1d40/details?mode=metrics) |
88
 
89
 
90
  ---
91
 
92
+ ## Validation pipeline
 
 
93
 
94
+ These results are produced by the EdgeFirst on-target validation pipeline:
95
 
96
+ 1. **EdgeFirst Profiler** runs on the target hardware, executes the full inference pipeline (preprocess β†’ inference β†’ postprocess), and emits per-image predictions in EdgeFirst Arrow/Parquet plus a Perfetto trace.
97
+ 2. **EdgeFirst Validator** consumes the predictions and trace, computes `pycocotools` accuracy metrics and per-stage timing summaries, and publishes the results to the Studio validation session.
98
+ 3. **EdgeFirst HAL** ([open source](https://github.com/EdgeFirstAI/hal)) provides the hardware-accelerated preprocessing and post-decoding primitives used at both validation and deployment time, so the timings measured here reflect the same accelerated paths a production runtime would take.
 
 
 
 
 
 
99
 
100
+ Inference latency is reported as the on-accelerator inference time. FPS is the measured end-to-end pipelined throughput from the Perfetto trace, which generally exceeds `1000 / (preprocess + inference + postprocess)` because the runtime overlaps stages across frames.
101
 
102
+ See [EdgeFirst Studio](https://edgefirst.studio) for the full validation pipeline.
 
 
 
 
 
 
103
 
104
+ ---
105
 
106
+ ## Downloads
 
 
 
 
 
 
107
 
108
+ Artifacts are organized by deployment target. Each model file embeds the EdgeFirst `edgefirst.json` metadata (training session, dataset version, calibration artifact, converter chain) so a single file is sufficient for deployment β€” no sidecar configuration required.
109
 
110
+ *Per-artifact download links are populated from the Studio artifact registry. To see the live download table, regenerate this card with `--studio` against an authenticated Studio session.*
111
 
112
  ---
113
 
114
+ ## Inference example (Python)
115
 
116
  ```python
117
  from edgefirst.hal import Model, TensorImage
118
 
119
+ # Load the model β€” embedded edgefirst.json carries labels and decoder config
120
+ model = Model("yolo11n-det-int8.tflite")
121
 
122
  # Run inference on an image
123
  image = TensorImage.from_file("image.jpg")
124
  results = model.predict(image)
125
 
126
+ # Iterate detections
127
  for det in results.detections:
128
  print(f"{det.label}: {det.confidence:.2f} at {det.bbox}")
129
  ```
130
 
131
+ [EdgeFirst HAL](https://github.com/EdgeFirstAI/hal) β€” Hardware abstraction layer with accelerated inference delegates.
132
 
133
  ---
134
 
135
+ ## Traceability
136
 
137
+ Every measurement in the tables above is reachable through the EdgeFirst Studio validation framework. The `v-XXXX` Source link on each row resolves to a public Studio URL of the form:
138
 
139
+ ```
140
+ https://test.edgefirst.studio/public/validation/v-XXXX/details?mode=metrics
141
+ ```
 
 
 
 
142
 
143
+ From there, the full provenance chain is one click deeper: training session ID, dataset version, calibration artifact, converter chain (e.g. TFLite quantizer + Neutron compile), validation parameters, and the host hardware description (hostname, kernel version, SoC, NPU, profiler version). The same model file you download from this repository embeds the same chain in its `edgefirst.json` metadata.
144
 
145
  ---
146
 
147
+ ## See also
148
 
149
+ Other model families in the [EdgeFirst Model Zoo](https://huggingface.co/spaces/EdgeFirst/Models):
150
 
151
+ | Model | Task | Link |
152
+ |-------|------|------|
153
+ | YOLOv5 Detection | Detection | [EdgeFirst/yolov5-det](https://huggingface.co/EdgeFirst/yolov5-det) |
154
+ | YOLOv8 Detection | Detection | [EdgeFirst/yolov8-det](https://huggingface.co/EdgeFirst/yolov8-det) |
155
+ | YOLOv8 Segmentation | Segmentation | [EdgeFirst/yolov8-seg](https://huggingface.co/EdgeFirst/yolov8-seg) |
156
+ | YOLO11 Segmentation | Segmentation | [EdgeFirst/yolo11-seg](https://huggingface.co/EdgeFirst/yolo11-seg) |
157
+ | YOLO26 Detection | Detection | [EdgeFirst/yolo26-det](https://huggingface.co/EdgeFirst/yolo26-det) |
158
+ | YOLO26 Segmentation | Segmentation | [EdgeFirst/yolo26-seg](https://huggingface.co/EdgeFirst/yolo26-seg) |
159
 
160
  ---
161
 
162
+ ## Train your own with EdgeFirst Studio
163
 
164
+ Train on your own dataset with [**EdgeFirst Studio**](https://edgefirst.studio):
165
 
166
+ - Free tier includes YOLO training with automatic INT8 quantization and edge deployment.
167
+ - Upload datasets via [EdgeFirst Recorder](https://github.com/EdgeFirstAI/recorder) or COCO/YOLO format.
168
+ - AI-assisted annotation with auto-labeling.
169
+ - CameraAdaptor integration for native sensor format training.
170
+ - Deploy trained models to edge devices via [EdgeFirst Client](https://github.com/EdgeFirstAI/client).
 
 
 
171
 
172
  ---
173
 
174
+ ## Technical notes
175
+
176
+ ### Quantization pipeline
177
 
178
+ All TFLite INT8 models are produced by EdgeFirst's quantization pipeline ([details](https://github.com/EdgeFirstAI/studio-ultralytics)):
179
 
180
+ 1. **ONNX export** β€” standard Ultralytics export with `simplify=True`
181
+ 2. **TF-wrapped ONNX** β€” box coordinates normalized to `[0, 1]` inside DFL decode
182
+ 3. **Split decoder** β€” boxes, scores, and mask coefficients split into separate output tensors so each receives an independent INT8 quantization scale
183
+ 4. **Smart calibration** β€” calibration samples selected via greedy coverage maximization; the artifact is content-addressed by parameter hash and cached in Studio for deterministic reuse
184
+ 5. **Full integer INT8** β€” `uint8` input, `int8` output, MLIR quantizer
185
 
186
+ ### Split decoder output format
 
 
 
 
187
 
188
+ **Detection** (e.g. yolo11n):
189
 
190
+ - `boxes` β€” `(1, 4, 8400)` normalized `[0, 1]` coordinates
191
+ - `scores` β€” `(1, 80, 8400)` per-class probabilities
 
192
 
193
+ Each tensor has its own quantization scale and zero point. The EdgeFirst HAL handles dequantization and reassembly automatically; no application code change is required across NPU targets.
194
 
195
+ ### Embedded metadata
196
 
197
+ - **TFLite**: `edgefirst.json` and `labels.txt` embedded in the ZIP-format model file
198
+ - **ONNX**: `edgefirst.json` embedded in `model.metadata_props`
199
 
200
+ No sidecar files required; the model artifact is self-contained.
201
 
202
  ---
203
 
204
  ## Limitations
205
 
206
+ - **COCO bias** β€” models trained on COCO (80 classes) inherit the dataset's biases (Western-centric scenes, particular object distributions, limited weather/lighting diversity).
207
+ - **INT8 quantization loss** β€” full-integer quantization introduces accuracy loss relative to FP32; the magnitude per platform is shown in the *Ξ” vs FP32* column above.
208
+ - **Input resolution** β€” all models expect 640Γ—640 input; other resolutions require letterboxing.
 
 
209
 
210
  ---
211
 
 
213
 
214
  ```bibtex
215
  @software{edgefirst_yolo11_det,
216
+ title = { {YOLO11 Detection β€” EdgeFirst Model Zoo} },
217
  author = {Au-Zone Technologies},
218
  url = {https://huggingface.co/EdgeFirst/yolo11-det},
219
  year = {2026},