README.md

---
license: mit
tags:
  - object-detection
  - yolox
  - onnx
  - int8
  - coco
  - fpga
language: en
library_name: onnxruntime
pipeline_tag: object-detection
---

# YOLOX-Nano ReLU (MIT) — work-in-progress training

A YOLOX-Nano variant with **ReLU activations and no depthwise convolutions**,
**trained from random initialisation on COCO 2017 by Pablo Mendoza
(`@thefalley`)** on his own server (NVIDIA GTX 1050 Ti, 4 GB VRAM). The
weights, the ONNX export pipeline, the INT8 quantization, the decoder and
all inference scripts in this repository are original work, released under
the MIT License.

The training architecture is `yolox_nano_ti_lite` from TexasInstruments'
`edgeai-yolox` repository — used as a build tool only, **not redistributed**
here. See `NOTICE.md` for the full provenance chain.

## Training status (live)

| | |
|---|---|
| Current epoch | **1 / 300** |
| AP @ IoU=0.5:0.95 | *** (will be measured at validation milestones) |
| Hardware | GTX 1050 Ti, 4 GB VRAM (own server, no cloud) |
| Started | 2026-05-10 |
| Last update | 2026-05-11 |
| Status | 🔄 Training in progress |
| Target | epoch 300, target mAP@0.5:0.95 ≈ 0.26 (TI baseline for the same architecture) |

> **This is an early-checkpoint release** intended to validate the full
> pipeline (PTH → ONNX → INT8 → inference) end-to-end. Detection quality
> will improve substantially as training progresses; the repository will
> be updated incrementally with later checkpoints.

## Files

| File | Size | SHA-256 |
|---|---:|---|
| `yolox_nano_relu_float.onnx`     | *** | *** |
| `yolox_nano_relu_int8_qop.onnx`  | *** | *** |

## Architecture

| | |
|---|---|
| Family | YOLOX-Nano (Megvii, 2021) with the TI ti-lite modifications |
| Depth multiplier | 0.33 |
| Width multiplier | 0.25 |
| Parameters | ~1.9 M |
| Activation | **ReLU** (every Conv block; no SiLU) |
| Convolutions | **Regular Conv2D only** (no depthwise separable) |
| Input | 1×3×416×416, RGB, NCHW |
| Output (when exported with `--no-onnxsim`) | single tensor `(1, N, 85)` with `[cx, cy, w, h, obj, class_0..class_79]` already in input-pixel coords, anchor-free YOLOX-style |
| Quantization | Per-tensor INT8 (W symmetric, A asymmetric); bias INT32 |

These design choices are deliberate to match the operator set of an
INT8 FPGA DPU (Xilinx ZedBoard XC7Z020) that supports Conv2D + ReLU/Leaky
+ Add + Concat + MaxPool + Resize + Transpose only.

## Performance

| Metric | FP32 | INT8 | Reference (TI baseline) |
|---|---|---|---|
| AP @ IoU=0.5:0.95 | *** | *** | 0.261 |
| AP @ IoU=0.5      | *** | *** | 0.418 |

Reference numbers are TI's published metrics for the fully-trained
yolox_nano_ti_lite (300 epochs). Our weights are still being trained;
intermediate metrics will appear here as checkpoints are released.

## Visual inference samples

Sample detections produced by the current published checkpoint of this
model on classic test images (epoch 1 / 300 — detection quality will
improve as training advances).

| | |
|---|---|
| ![dog](images/float_dog.png) | ![traffic](images/float_traffic.png) |
| ![parking](images/float_parking.png) | ![dining](images/float_dining.png) |

## Reproducibility

This release is a snapshot of an ongoing training run. The pipeline:

```
1.  Train         (TI edgeai-yolox, GTX 1050 Ti, COCO train2017)
       → yolox_nano_relu.pth

2.  Export ONNX   (tools/export_onnx.py from edgeai-yolox, --opset 13)
       → yolox_nano_relu_float.onnx

3.  Quantize INT8 (onnxruntime.quantize_static, 1000 random COCO val2017
                   images for calibration, seed = 42, per-tensor)
       → yolox_nano_relu_int8_qop.onnx
```

Calibration was performed once on the float ONNX of the published
checkpoint and will be re-run for each later checkpoint to keep INT8
in sync with the trained float weights.

## Provenance summary

```
TI yolox_nano_ti_lite exp file   (BSD-3 + Apache-2.0, build tool only)
        │
        │  Train from scratch, COCO train2017, own hardware
        ▼
yolox_nano_relu.pth                MIT (original training output)
        │
        │  TI export_onnx.py (build tool)
        ▼
yolox_nano_relu_float.onnx         MIT (this repository)
        │
        │  onnxruntime.quantize_static (MIT, tool)  +  COCO val2017 (CC BY 4.0)
        ▼
yolox_nano_relu_int8_qop.onnx      MIT (this repository)
```

The TI source code is used only as a build-time tool and is **not**
redistributed here. The weights themselves are an original training
output of the author. See `NOTICE.md` for full attribution.

## Detector size collection by the same author

| Repository | INT8 size | mAP@0.5:0.95 |
|---|---|---|
| [yolov4-leaky-416-int8-qop](https://huggingface.co/Thefalley/yolov4-leaky-416-int8-qop) | 61.66 MiB | 0.345 |
| [yolov4-tiny-416-int8-qop](https://huggingface.co/Thefalley/yolov4-tiny-416-int8-qop) | 5.83 MiB | 0.163 |
| [yolo-fastest-1.1-320-int8-qop](https://huggingface.co/Thefalley/yolo-fastest-1.1-320-int8-qop) | 0.47 MiB | (pending) |
| **yolox-nano-relu-mit** (this) | *** | *** (training in progress) |

## Citation

```bibtex
@article{ge2021yolox,
  author  = {Ge, Zheng and Liu, Songtao and Wang, Feng and Li, Zeming and Sun, Jian},
  title   = {YOLOX: Exceeding YOLO Series in 2021},
  journal = {arXiv:2107.08430},
  year    = {2021}
}
```

Author of the trained weights and INT8 derivative: **Pablo Mendoza**
(`@thefalley`), 2026.