YOLO-NB-M — an 80-class detector trained from scratch on COCO 2017 by CloudKites AI Lab

YOLO-NB-M is a single-stage, anchor-free object detector, trained entirely from scratch — every weight initialized randomly and optimized end-to-end on COCO 2017 — by CloudKites AI Lab using numbat, CloudKites' own in-house machine-learning framework. Architecturally it is an 8th-generation, YOLOv8m-class network (CSP backbone · PAN-FPN neck · decoupled detection head with distribution-focal box regression), implemented from scratch in numbat.

Name. YOLO-NB-M = YOLO (the real-time detector family) · NB (Numbat, the framework it was built and trained with) · M (medium scale). It sits at the 8th-generation / v8-equivalent tier of the YOLO family by architecture, while the weights, implementation, and name are CloudKites'.

Provenance. These weights are an original work of CloudKites AI Lab. They were produced from random initialization with numbat's own optimizer, data pipeline, and loss, on CloudKites hardware. No pretrained weights of any kind were used, and no third-party training-framework source code was copied, ported, or linked to produce them. The model, its weights, and the training pipeline are proprietary to CloudKites Pty Ltd. Released here under a Research-Use-Only (non-commercial) license; commercial use requires a separate license from CloudKites (contact@cloudkites.com).

Results

Evaluated on COCO val2017 (5,000 images) with the standard COCO mean-Average-Precision protocol (pycocotools), single-model, no test-time augmentation, at imgsz=640.

Metric	Value
mAP@0.50:0.95	0.4956
mAP@0.50	0.6610
Best mAP@0.50:0.95 during training	0.4970 (epoch 469 — see `metrics/coco_val_trend.csv`)
Parameters	25.9M
Input size	640 × 640
Classes	80 (COCO)
Final epoch	500 / 500

Training curves

Model

Name: YOLO-NB-M (medium scale).
Architecture: a YOLOv8m-class one-stage anchor-free detector — CSP backbone + PAN-FPN neck + decoupled detection head with DFL box regression. ~25.9M parameters.
Framework: numbat (CloudKites AI Lab) — a self-contained Zig ML toolkit (tensors, autograd, layers, losses, optimizers, data pipeline, multi-GPU training). The framework is proprietary and is not distributed with this release.

Training procedure (for reproducibility)

Trained from scratch for 500 epochs on the full COCO 2017 train2017 split (118,287 images), from random weight initialization.

Optimization


Optimizer	SGD (Nesterov), momentum 0.937
Learning rate	lr0 = 0.01 → lrf × lr0 (0.01), linear one-cycle decay
Warmup	3 epochs (per-iteration; momentum 0.8→0.937, bias-group LR 0.1→lr)
Weight decay	base 5e-4, scaled to the effective batch (`wd · batch·world / nbs`, nbs = 64)
Nominal batch (nbs)	64
Gradient clipping	global L2 norm = 10.0, every optimizer step
Precision	Mixed precision (AMP): f16 compute, f32 BatchNorm + loss, f32 master weights, loss scaling
EMA	Model exponential moving average (decay 0.9999, ramped), incl. BatchNorm buffers

Data & augmentation


Image size	640 × 640 (letterbox)
Mosaic	1.0 (disabled for the final 10 epochs — `close_mosaic`)
MixUp	0.1
Copy-paste	0.1
HSV jitter	h 0.015, s 0.7, v 0.4
Geometric	scale 0.9, translate 0.1, horizontal flip 0.5 (degrees 0, shear 0, perspective 0)
Random erasing	0.4

Hardware & scale


GPUs	3 × NVIDIA RTX 3090 (24 GB)
Power cap	200 W per GPU (graphics clock capped ≤ 1500 MHz)
Parallelism	Data-parallel (DDP), one process per GPU
Per-GPU batch	16 → effective batch 48 (global)
Seed	0 (deterministic sampler + per-rank augmentation seeding)
Run style	Segmented (≈8 h/segment with cool-downs), fully resumable checkpoints

A per-epoch validation (mAP) ran on rank 0 with EMA weights and eval-mode (running-stat) BatchNorm; the final reported metric is the EMA checkpoint scored on COCO val2017 with the standard protocol.

Files in this release

weights/yolo_nb_m_coco.safetensors — the trained YOLO-NB-M weights (safetensors export of the final EMA checkpoint; the exact file scored in Results above).
metrics/ — per-epoch training/validation metrics (metrics.csv, metrics.jsonl, summary.json) and the final evaluation summary.
monitoring/ — training-curve figures exported from the live dashboard.
manifest.json — the exact run manifest (hyperparameters, seed, dataset version, environment) for reproduction.
README.md, LICENSE.

Intended use & limitations

Intended for non-commercial research and evaluation of general 80-class object detection on natural images. As with any COCO-trained detector, performance degrades on out-of-distribution domains (medical, aerial, industrial, heavy occlusion, tiny objects) and it should not be used for safety-critical decisions without domain-specific validation.

Citation

@misc{cloudkites_yolo_nb_m_coco_2026,
  title  = {YOLO-NB-M: an 80-class detector trained from scratch on COCO 2017},
  author = {CloudKites AI Lab},
  year   = {2026},
  note   = {Trained from random initialization with the numbat framework. Research-Use-Only license.},
  howpublished = {HuggingFace, \url{https://huggingface.co/cloudkites/yolo-nb-m}}
}

These weights are the case study of the numbat framework paper — please also cite it:

@misc{tran2026numbat,
  title  = {Numbat: A Self-Contained Machine-Learning Framework and SDK, Validated
            by Training a YOLOv8m-Class Detector from Scratch on COCO},
  author = {Tran, Thang and Dang, Lan},
  year   = {2026},
  note   = {arXiv preprint (arXiv ID to be added upon announcement)}
}

Downloads last month: -; Downloads are not tracked for this model. How to track

cloudkites
/

yolo-nb-m