Downloads · 30 days
40
37% of all-time downloads
ubr-physical-ai/rescue-target-yolo26n
rescue-target-yolo26n is a object detection model from ubr-physical-ai. Use it when you need objects located in an image. It is set up for ultralytics. The card lists the license as agpl-3.0.
A YOLO26n detector for a single search-and-rescue cue: a person lying on the ground wearing a hi-vis vest. It is trained entirely on synthetic NVIDIA Isaac Sim renders and is intended for bench and research work on re…
Downloads · 30 days
40
37% of all-time downloads
All-time downloads
107
Public
Repo size
33.3 MB
Likes
0
Public
Click a slice to open those files.
.onnx20.1 MB · 60%
From the Hugging Face model README
A YOLO26n detector for a single search-and-rescue cue: a person lying on the ground wearing a hi-vis vest. It is trained entirely on synthetic NVIDIA Isaac Sim renders and is intended for bench and research work on rescue robots — not for deployment as a safety component.
<video controls muted playsinline src="https://huggingface.co/ubr-physical-ai/rescue-target-yolo26n/resolve/main/media/detections_unseen_orbits.mp4"></video>
best_1280_1cls.onnx on five camera orbits from isaac-sdg-rescue-target's clips/ (1280×720 renders made after
this model was trained, so none of these frames were seen in training). Green: detections at conf ≥ 0.25 (NMS 0.45);
white: ground truth. Only frames with the person in view are shown and counted; the far orbits face walls for much of
the circle.
| Orbit | Result |
|---|---|
| hospital, prone, 5 m | found in 49 of 77 frames where the person is visible: 48 of 53 with the camera in the room, 1 of 24 with the camera outside looking in through a window |
| warehouse, prone, 10 m | found in 91 of 93 |
| warehouse, supine, 15 m | found in 31 of 31 |
| warehouse, supine, 17.5 m | found in 17 of 18; one false box on a cart, in a frame where the person is out of view (not shown) |
| warehouse, standing person in a vest, 10 m | fires on the upright person in 71 of 93 frames (should be 0) |
"Found" = a detection with IoU ≥ 0.3 with the lying person; "fires on the upright person" = at least half of a detection box inside that person. One orbit per row: an illustration, not a benchmark.
Three more hospital orbits, same counting (the camera leaves the room for about half of each orbit and looks in through a window; those frames are counted separately):
| Orbit | camera in the room | through a window |
|---|---|---|
| hospital, prone, 5 m (the orbit above) | 48 / 53 | 1 / 24 |
| hospital, supine, 6.5 m | 36 / 41 | 1 / 28 |
| hospital, prone, 10 m | 2 / 22 | 0 / 29 |
| hospital, supine, 10 m | 15 / 24 | 0 / 29 |
What it shows: within these single-orbit tests the detector holds lying people out to 17.5 m in the warehouse, but in the hospital a prone person at 10 m is found in only 2 of 22 frames, behind glass it almost never finds anyone (2 of 110), and it fires on
an upright person wearing a vest, usually with a small box on part of the body (confidence 0.33-0.71). The validation
numbers below do not measure this, because their false-alarm check used empty frames only. Pair this model with a
posture check, or retrain with upright-person hard negatives, before trusting a single detection as a casualty. The
script that made the video is media/det_video.py.
Read the saturation finding before quoting any number from this card. The headline metrics are at the validation set's ceiling, and the far-range slice in particular cannot distinguish between these models.
AGPL-3.0. These weights are fine-tuned from Ultralytics yolo26n.pt, which is distributed under AGPL-3.0, so the fine-tuned weights and everything in this repository inherit that licence. In practice this means:
The training data, ubr-physical-ai/isaac-sdg-rescue-target, is CC-BY-4.0 and is credited accordingly. The data licence and the weight licence are separate; the weights are the AGPL-3.0 part.
| id | class | meaning |
|---|---|---|
| 0 | person_lying_vest | a person prone or supine on the floor, wearing a hi-vis vest (orange or yellow) |
| 1 | distractor | random clutter primitives, present only in the 2-class variant |
The distractor class exists to give the model negative shapes to reject; it is not a useful output on its own. Every metric in this card is reported for class 0 alone.
| file | what it is | imgsz | classes | opset |
|---|---|---|---|---|
v0_640_2cls.pt | v0 PyTorch weights — the default checkpoint | 640 | 2 | — |
v0_640_2cls.onnx | v0 exported to ONNX | 640 | 2 | 17 |
best_1280_1cls.onnx | best sweep arm (B_1280_1cls_s0) exported to ONNX | 1280 | 1 | 17 |
B_summary.csv | the full 13-run sweep table | |||
v0_results.csv | per-epoch training curve for v0 | |||
configs/ | args.yaml and run.json for v0 and for B_1280_1cls_s0 |
Both ONNX files are exported with nms=False / end2end=False, so the network does not do NMS — you must run it yourself. Output tensor is output0 with shape (1, 4 + num_classes, N): (1, 6, 8400) for the 640 2-class model, (1, 5, 33600) for the 1280 1-class model. Boxes are cx, cy, w, h in input-resolution pixels; class scores follow, already sigmoid-activated.
One caveat about v0_results.csv: its metrics/ columns are Ultralytics' all-class validation metrics, so the final-epoch row reads [email protected] = 0.94565 because it averages person_lying_vest with the much harder distractor class. The 0.9949 quoted below is class 0 only, computed by a separate per-slice evaluation. The two are not in conflict.
YOLO26n fine-tuned from yolo26n.pt, imgsz 640, 2 classes, seed 0, 60 epochs, batch 64, patience=0 (no early stopping — all 60 epochs always run), deterministic=False, default Ultralytics augmentation (mosaic 1.0, close_mosaic=10, fliplr 0.5, HSV, randaugment, erasing 0.4), optimizer=auto, lr0 0.01. Stack: ultralytics 8.4.145, torch 2.13.0+cu130, Python 3.12.3, one NVIDIA B300. Full hyperparameters are in configs/v0_args.yaml.
Data: ubr-physical-ai/isaac-sdg-rescue-target, 3960 train / 440 validation images at 1024×768, rendered in three synthetic indoor environments (warehouse, hospital, office) across three camera views (orbit, roverview, roverview_far).
On the choice of hyperparameters, honestly: the team's original training recipe was not available when this model was trained. These values are a documented, reproducible default rather than a tuned configuration. They have not been searched over beyond the imgsz × class-count sweep below, and there is no reason to believe they are optimal.
Class person_lying_vest only, on the 440-image validation split.
| metric | value |
|---|---|
| [email protected] | 0.9949 |
| [email protected]:0.95 | 0.9358 |
| false alarms on 8 real empty frames (conf 0.25) | 0 |
Recall by camera view:
| view | recall | images | class-0 boxes |
|---|---|---|---|
orbit | 1.0000 | 240 | 236 |
roverview (4–8.5 m) | 0.9900 | 100 | 100 |
roverview_far (10–17.5 m) | 0.9815 | 100 | 54 |
The 8 real empty frames are a smoke test for false positives on real imagery, nothing more. They contain no people, so they say nothing about whether the model finds real people.
Four arms — imgsz 640 or 1280, 1 or 2 classes — three seeds each, plus v0, for 13 runs total. Median of 3 seeds, class 0 only. The full per-run table, including per-slice recalls and false-alarm counts, is in B_summary.csv.
| arm | [email protected] | [email protected]:0.95 | recall roverview_far |
|---|---|---|---|
640_2cls | 0.9949 | 0.9358 | 0.9815 |
640_1cls | 0.9950 | 0.9442 | 0.9815 |
1280_2cls | 0.9950 | 0.9514 | 0.9815 |
1280_1cls | 0.9950 | 0.9580 | 0.9815 |
Training cost, on one B300 with 3 runs sharing the GPU: 19 min per run at imgsz 640, 59 min at 1280. (v0 itself ran alone on the GPU and took 16.3 min.)
best_1280_1cls.onnx is the B_1280_1cls_s0 checkpoint, the best single run in the sweep by [email protected]:0.95 (0.9583).
roverview_far recall is exactly 0.9815 in all four arms and all three seeds — thirteen runs, one number. You can verify this yourself: every row of the recall_roverview_far column in B_summary.csv is 0.9815.
That is not a coincidence and it is not evidence of robustness. The far slice contains 54 class-0 boxes across 100 images (the other 46 far images contain no visible target at all). 53/54 = 0.98148…, so 0.9815 means every one of these models misses the same single box, and the finest change this metric can express is one box — 1.85 percentage points. The slice has no resolution below that.
The consequence: this validation set cannot resolve a detection-range difference between these models. The far-range numbers are at ceiling. They should not be read as evidence that the detector works at range — only that this particular 54-box slice is too easy and too small to disagree with itself. The far targets are not actually small: median class-0 box area in the far bucket is 1111 px² (≈ 33 × 33 px at 1024×768, interquartile range 756–1540 px²), which is still comfortable at imgsz 640. For comparison, the median box is 4670 px² in roverview and 120333 px² in orbit.
So what does 1280 actually buy? A strict-IoU localisation gain, not a range gain: +0.0138 [email protected]:0.95 in the 1-class arms (0.9442 → 0.9580) and +0.0156 in the 2-class arms (0.9358 → 0.9514), for 3.1× the training time. [email protected] does not move at all. Whether that trade is worth it depends on whether you need tight boxes; it is not a reason to expect longer detection range.
If you are benchmarking against this model, build a harder far-range validation set first. More far images, many more far boxes, genuinely small targets, occlusion, and adverse lighting. Any comparison made on the slice used here will be measuring noise.
Bench and research use: robotics prototyping, synthetic-to-real transfer studies, and as a baseline for search-and-rescue perception work.
distractor class is not a general clutter detector. It was trained on procedural primitives, not real objects.from ultralytics import YOLO
model = YOLO("v0_640_2cls.pt")
results = model.predict("frame.jpg", imgsz=640, conf=0.25)
for r in results:
for box in r.boxes:
if int(box.cls) == 0: # person_lying_vest
print(box.xyxy[0].tolist(), float(box.conf))
cv2.dnnThis is the intended deployment path on a Jetson Orin Nano. Use imgsz=640 with v0_640_2cls.onnx and imgsz=1280 with best_1280_1cls.onnx — the inputs are fixed-size, so the wrong value will fail or silently degrade. NMS is not in the graph.
On a Jetson Orin Nano (4 GB or 8 GB). Both ONNX files are 17 MB, so weights fit either board with room to spare — unlike a VLM, this detector is not memory-bound. What differs is throughput, and the lever is imgsz, not the board:
v0_640_2cls.onnx decodes 8,400 anchors per frame; best_1280_1cls.onnx decodes 33,600 — 4× the input pixels and 4× the post-processing, for the strict-IoU gain described above and no range gain. On a 4 GB board, or any board sharing the GPU with other work, start at 640 and only move to 1280 if you have measured that you need tighter boxes.cv2.dnn with DNN_BACKEND_CUDA needs an OpenCV built with CUDA. The OpenCV that ships in JetPack's apt packages is not, so the commented-out backend lines silently fall back to CPU. Either build OpenCV with CUDA yourself or — better — convert to a TensorRT engine (trtexec --onnx=... --fp16) and skip cv2.dnn for inference. Orin supports FP16 and INT8; it does not support FP8.import cv2
import numpy as np
# --- pick one -------------------------------------------------------------
ONNX, IMGSZ, NC = "v0_640_2cls.onnx", 640, 2 # output (1, 6, 8400)
# ONNX, IMGSZ, NC = "best_1280_1cls.onnx", 1280, 1 # output (1, 5, 33600)
CONF, IOU = 0.25, 0.45
net = cv2.dnn.readNetFromONNX(ONNX)
# net.setPreferableBackend(cv2.dnn.DNN_BACKEND_CUDA) # on Jetson
# net.setPreferableTarget(cv2.dnn.DNN_TARGET_CUDA)
img = cv2.imread("frame.jpg")
h0, w0 = img.shape[:2]
# letterbox to IMGSZ x IMGSZ, preserving aspect ratio
scale = min(IMGSZ / w0, IMGSZ / h0)
nw, nh = round(w0 * scale), round(h0 * scale)
pad_x, pad_y = (IMGSZ - nw) // 2, (IMGSZ - nh) // 2
canvas = np.full((IMGSZ, IMGSZ, 3), 114, np.uint8)
canvas[pad_y:pad_y + nh, pad_x:pad_x + nw] = cv2.resize(img, (nw, nh))
net.setInput(cv2.dnn.blobFromImage(canvas, 1 / 255.0, (IMGSZ, IMGSZ), swapRB=True))
out = net.forward()[0].T # (N, 4 + NC): cx, cy, w, h, then class scores
scores = out[:, 4:4 + NC]
cls_id = scores.argmax(1)
conf = scores.max(1)
keep = conf >= CONF
out, cls_id, conf = out[keep], cls_id[keep], conf[keep]
# letterboxed pixels -> original image pixels
cx, cy, bw, bh = out[:, 0], out[:, 1], out[:, 2], out[:, 3]
x = (cx - bw / 2 - pad_x) / scale
y = (cy - bh / 2 - pad_y) / scale
boxes = np.stack([x, y, bw / scale, bh / scale], 1) # xywh, original scale
idx = cv2.dnn.NMSBoxes(boxes.tolist(), conf.tolist(), CONF, IOU)
for i in np.array(idx).flatten():
if cls_id[i] == 0: # person_lying_vest
bx, by, bwi, bhi = boxes[i]
print(f"person_lying_vest {conf[i]:.3f} at ({bx:.0f}, {by:.0f}, {bwi:.0f}, {bhi:.0f})")
ubr-physical-ai/isaac-sdg-rescue-target, CC-BY-4.0, generated with NVIDIA Isaac Sim / Replicator.