yolo26n-int8w-litert

YOLO26n INT8 Weight-only — LiteRT

YOLO26n INT8 Weight-only is a LiteRT object-detection model with per-channel INT8 Conv2D weights and float activations and biases.

✨ Key Highlights

• Lower latency — Delivers 1.57× faster p50 end-to-end inference than the FP32 baseline on Android™ Vivo X300 on one Arm® CPU core.
• Higher throughput — On Android™ Vivo X300, processes 47.48 frames per second on one Arm® CPU core.
• Smaller model — The 3.349 MB model is 3.09× smaller than the 10.364 MB FP16 source bundle.
• Comparable quality — Achieves 39.90% mAP50–95 on COCO 2017 val, within 0.35 percentage points of the FP32 baseline.

📦 Model Details

Model Description

This package contains the YOLO26n object detector converted to LiteRT with weight-only INT8 quantization for Conv2D weights. It keeps float activations and biases, accepts 640 × 640 images, and returns up to 300 detections per image.

• Developed by: Ultralytics
• Model type: Object detector
• License: AGPL-3.0
• Base model: Ultralytics/YOLO26
• Packaged variant: LiteRT model with symmetric, per-channel INT8 Conv2D weights

Model Sources

• Base model: yolo26n.pt at revision 070ac3c51435984d992ba92eb3f234daf4e4500d
• Upstream repository: Ultralytics

🚀 Get Started with the Model

Run with Compute Flow

Follow these steps to run YOLO26n INT8 Weight-only — LiteRT on macOS® with Apple Silicon or on Linux® with an Arm®-based CPU, such as a Raspberry Pi® 5.

Step 1: Clone Compute Flow and set up the virtual environment

git clone https://github.com/ARM-software/ComputeFlow.git && cd ComputeFlow

uv sync && source .venv/bin/activate

Step 2: Install the brick and model

compute-flow update
compute-flow model install object_detection:yolo yolo-v26n-litert-f16-int8w
compute-flow build native

Step 3: Run the Python CLI example

python -m cli_examples.object_detection_cli \
  -m @manifest/yolo/yolo-v26n-litert-f16-int8w/yolo_manifest.json \
  -i @sample/sample.jpg \
  -t 1

The example detects objects in the bundled samples/sample.jpg image. Replace -i with a path to your own image.

📊 Quality evaluation

Quality was evaluated on all 5,000 images in the COCO 2017 val2017 split at 640 × 640 input resolution with batch size 1. Higher mAP values are better.

🎯 Performance evaluation

Performance was measured under the following conditions:

• Target: Android™ Vivo X300.
• Runtime: One Arm® CPU core.
• Runs: 100 warmups followed by 100 measured runs.

The following methodology and definitions were used:

• The input was a batch of one 640 × 640 image from COCO 2017 val2017.
• End-to-end latency is the elapsed time from supplying the input image until final detections are available, including preprocessing, model inference, and post-processing.
• Average memory is the mean sampled resident memory of the benchmark process across measured runs.
• Peak memory is the maximum high-water-mark resident memory of the benchmark process across measured runs.
• Lower latency and memory values are better; higher frames-per-second values are better.

Compared with the FP32 baseline under the same protocol, the INT8 weight-only profile provides the following results.

🛠️ Technical Specifications

Objective

The package provides YOLO26n for object detection with weight-only INT8 LiteRT execution.

Runtime Architecture

Precision and Quantization

Conv2D weights use symmetric, per-output-channel INT8 quantization. Activations, biases, and depthwise Conv2D layers remain float32. The source graph has no Fully Connected operations, but the conversion path applies the same INT8 weight-only conversion when they are present. The model also preserves the unused dummy_fp16_constant tensor used by runtime code to detect whether FP16 execution can be forced through XNNPACK. The input and output tensors use float32.

The model contains 2,434,133 parameters and occupies 3.349 MB.

Input Specification

Output Specification

The manifest specifies external non-maximum suppression with a confidence threshold of 0.25, an NMS threshold of 0.4, a maximum of 300 detections per image, and non-normalized coordinates.

Repository Contents

• assets/class_names.json — COCO class-name mapping referenced by the manifest.
• benchmarks/yolo26n-int8w-litert-vivo-x300-fp32.yaml — FP32 baseline quality and performance report for Android™ Vivo X300.
• benchmarks/yolo26n-int8w-litert-vivo-x300-int8.yaml — INT8 weight-only quality and performance report for Android™ Vivo X300.
• metadata.yaml — model and benchmark metadata.
• samples/sample.jpg — sample image for object_detection_cli smoke tests.
• yolo26n_conv_fc_f16_int8w.tflite — LiteRT object-detection model referenced by the manifest.
• yolo_manifest.json — object-detection manifest.
• SHA256SUMS — model-package checksums for reproducibility.

🗂️ Model and Asset Origin

• Model: Starting from the YOLO26n LiteRT FP16-trigger bundle, Conv2D weights were converted to symmetric, per-output-channel INT8 tensors while float activations and biases were preserved. The source graph has no Fully Connected operations; the conversion path checks for them and applies the same INT8 weight-only conversion when present.
• Class names: assets/class_names.json contains COCO class labels from coco.names.
• Sample: samples/sample.jpg is an image provided for testing the model.

🔐 Checksums

SHA256SUMS was generated by recursively hashing every regular file in the model bundle, including files in subdirectories, except the generated root SHA256SUMS and paths with a dotfile component.

From the model bundle root, verify the checked-out files with:

shasum -a 256 -c SHA256SUMS

Use of Ultralytics models

Ultralytics provides Ultralytics YOLO software and models available through the Arm AI Portal and/or Arm's Hugging Face Organization under the GNU Affero General Public License v3.0 ("AGPL-3.0"), unless you have entered into a separate written license agreement with Ultralytics. Accessing, downloading, or retraining these materials through Arm AI Portal does not grant you an Ultralytics Enterprise License or any other proprietary Ultralytics license.

AGPL-3.0 requires you to release the complete source code of any application that uses Ultralytics YOLO, including applications made available over a network, under the same license. If you are embedding YOLO in a commercial product, internal tool, or production deployment and cannot open-source your code, you need an Ultralytics Enterprise License.

You are responsible for determining which applies to your use. Terms and enterprise licensing options are available at ultralytics.com.