yolov8s-1024-int8-tflite

YOLOv8s 1024 INT8 TFLite

Fully integer post-training quantized YOLOv8s for 1024×1024 object detection. The artifact was calibrated with COCO images and validated on the complete 5,000-image COCO val2017 split using the Qualcomm QNN HTP delegate.

Authorship and Scope

The YOLOv8s architecture and COCO-trained weights originate from Ultralytics. Andrew Chiao performed the 1024×1024 export, representative-dataset calibration, full-integer quantization, TensorFlow Lite packaging, Android QNN HTP integration, and device-level accuracy and latency validation.

Artifact

Output tensor shape: [1, 84, 21504]. Non-maximum suppression is performed outside the model.

Quantization

• Method: full-integer post-training quantization (PTQ)
• Converter: TensorFlow Lite
• Optimization: tf.lite.Optimize.DEFAULT
• Supported ops: TFLITE_BUILTINS_INT8
• Representative set: 128 deterministically shuffled COCO val2017 images
• Preprocessing during calibration: aspect-ratio-preserving letterbox to 1024×1024, padding value 114, RGB, normalized to [0, 1]
• Inference input type: INT8
• Inference output type: INT8

Validation results

Evaluation used COCO val2017 (5,000 images, 80 classes).

Timing environment:

• Device: Qualcomm Kalama / QCS8550 class, arm64
• OS: Android 13
• Backend: Qualcomm QNN HTP
• TensorFlow Lite: 2.16.1
• QNN LiteRT delegate: 2.44.0
• QNN runtime package: 2.47
• Warm-up runs: 5

The inference-only number measures Interpreter.run. Source image decoding, preprocessing, output decoding, and NMS are outside that boundary. Host/device transfers performed inside the delegate cannot be isolated through the TFLite Java API.

Accuracy and speed trade-off

The matching FP16 baseline reached mAP50 0.593022 and mAP50–95 0.411226. The INT8 model is the speed-first deployment option; FP16 remains the accuracy-first baseline.

Python usage

The example below runs the model and converts the INT8 output back to real values. Letterbox metadata must be retained to map boxes back to the source image.

import numpy as np
from PIL import Image
import tensorflow as tf

interpreter = tf.lite.Interpreter("yolov8s_1024_int8.tflite")
interpreter.allocate_tensors()
inp = interpreter.get_input_details()[0]
out = interpreter.get_output_details()[0]

image = Image.open("image.jpg").convert("RGB")
# Production code should preserve aspect ratio and letterbox with RGB 114.
image = image.resize((1024, 1024), Image.Resampling.BILINEAR)
real = np.asarray(image, dtype=np.float32)[None] / 255.0

in_scale, in_zero = inp["quantization"]
input_int8 = np.clip(np.rint(real / in_scale + in_zero), -128, 127).astype(np.int8)
interpreter.set_tensor(inp["index"], input_int8)
interpreter.invoke()

raw_int8 = interpreter.get_tensor(out["index"])
out_scale, out_zero = out["quantization"]
prediction = (raw_int8.astype(np.float32) - out_zero) * out_scale
print(prediction.shape)  # (1, 84, 21504)

prediction[:, 0:4, :] contains box channels and prediction[:, 4:84, :] contains the 80 class-score channels. Apply the same score threshold, coordinate transform, and NMS used during validation.

Android + Qualcomm QNN HTP

The Qualcomm QNN LiteRT delegate and matching QNN runtime must come from an authorized, version-compatible Qualcomm SDK package. A minimal Java setup is:

QnnDelegate.Options qnn = new QnnDelegate.Options();
qnn.setSkelLibraryDir(context.getApplicationInfo().nativeLibraryDir);
qnn.setCacheDir(context.getCacheDir().getAbsolutePath());
qnn.setModelToken("yolov8s_1024_int8");
qnn.setBackendType(QnnDelegate.Options.BackendType.HTP_BACKEND);
qnn.setHtpUseConvHmx(QnnDelegate.Options.HtpUseConvHmx.HTP_CONV_HMX_ON);
qnn.setHtpPerformanceMode(
    QnnDelegate.Options.HtpPerformanceMode.HTP_PERFORMANCE_BURST);

if (!QnnDelegate.checkCapability(
        QnnDelegate.Capability.HTP_RUNTIME_QUANTIZED)) {
    throw new IllegalStateException("Quantized QNN HTP runtime unavailable");
}
qnn.setHtpPrecision(QnnDelegate.Options.HtpPrecision.HTP_PRECISION_QUANTIZED);

QnnDelegate delegate = new QnnDelegate(qnn);
Interpreter.Options options = new Interpreter.Options();
options.setUseNNAPI(false);
options.setUseXNNPACK(false);
options.addDelegate(delegate);
Interpreter interpreter = new Interpreter(modelBuffer, options);

Keep the QnnDelegate alive for at least as long as the interpreter and close both when the runtime is replaced. Verify in device logs that the graph is delegated to HTP and that CPU fallback is not masking an integration failure.

Intended use

• Android edge object detection
• Qualcomm QNN / Hexagon HTP validation
• Camera and multi-stream inference prototypes
• Reproducible FP16-versus-INT8 benchmarking

Limitations

• Results apply to the documented preprocessing, thresholds, delegate, and device class.
• The model is trained on COCO categories and inherits the dataset's coverage and limitations.
• Performance on other delegates or SoCs should be measured independently.
• NMS is not embedded in the TFLite graph.

License

The exported model derives from Ultralytics YOLOv8. The local export metadata identifies the upstream license as AGPL-3.0. Review the upstream Ultralytics license and your intended deployment obligations before use.