NavAble/NeurIPS_2026_BLV

A Large-Scale Dataset and Synthetic Data Generation Pipeline for Blind Navigation
NeurIPS 2026 · Evaluations & Datasets Track

Hochul Hwang^1,† · Jahir Sadik Monon^1,† · Soowan Yang² · Shiven Umeshbhai Patel¹
Anh Nhat Hong Nguyen¹ · Kien Nguyen¹ · Keshav Garg¹ · Dylan Gage¹
Duretti Hordofaa¹ · Anshu Anjna¹ · Eshed Ohn-Bar³ · Donghyun Kim^1
1University of Massachusetts Amherst · ²DGIST · ³Boston University
^†Equal contribution

📄 Paper · 🦮 Project website · 🎬 Video · 🤗 Dataset & assets · 📦 Checkpoints · 📝 BibTeX

Welcome to NavAble! We build perception tools for the objects that support blind and low-vision (BLV) navigation: pedestrian signals, door buttons, handrails, and other accessibility infrastructure. NavAble helps vision models find the things blind and low-vision (BLV) travelers depend on: accessible pedestrian signal (APS) buttons, door buttons, pedestrian signals, handrails, elevators, escalators, bus stops and more. These objects are rare or inconsistently labelled in existing vision datasets. NavAble brings together:

• NavAble-Real: 5,681 collected image records, comprising 5,581 released records with dense class masks and 100 additional revolving_door images awaiting split assignment; the released benchmark test set contains 1,482 records;
• NavAble-Curated: 36,466 images from public datasets, curated and remapped to one 11-class taxonomy;
• NavAble-Synthetic: 450,860 photorealistic NVIDIA Isaac Sim frames with class masks, depth, surface normals and 2D/3D boxes;
• the 500 3D assets used to render them, and 28 trained segmentation checkpoints from the paper.

Contents: News · At a glance · Quick start · Dataset structure · How to use · Results · How the data was made · Tools · Dataset card · Citation

News

• 2026-11: Added 100 collected revolving_door images, not yet assigned to train, validation or test. Added per-class image-presence counts from the released segmentation masks; these differ from primary-class row counts.
• 2026-11: syn re-rendered and re-released with surface normals, depth and 3D bounding boxes (450,860 frames). Class 11 is now named revolving_door (same id and color; its 3D assets moved to synthetic_objects/revolving_door/). New tools/ for downloading, exploring, exporting and evaluating.
• 2026: The paper is accepted at NeurIPS 2026. Preprint: arXiv:2610.19330.

At a glance

Subset	Config / path	Splits (rows)	Size	Image size	Annotations
Real, collected	real_ours + unassigned addition	train 3,703 · validation 396 · test 1,482 · unassigned 100 (5,681 total records)	1.5 GB (released splits)	640×360 (a few 640×480; released splits)	class masks, capture location id (released splits)
Real, curated	real_curated	train 36,466	114 GB	mostly 640×640	class masks remapped from the source datasets
Synthetic	syn	train 450,860	816 GB	1280×720	class masks, depth, surface normals, 2D and 3D boxes, USD prim paths
3D assets	synthetic_objects/	500 assets in 9 classes	23 GB	–	.glb mesh, .ply Gaussian splat, .usdz
Checkpoints	navable_*.pth	7 models × 4 training-data mixes	28 GB	–	semantic segmentation models

• 11 classes, all with collected real-world examples when the 100 additional revolving_door images are included. These 100 images are not yet assigned to a split and are separate from the released Parquet files audited below.
• The collection was described as covering 113 physical locations with a location-disjoint test split. The released metadata contains 114 location IDs, including 32 test location IDs also present in train or validation; location disjointness therefore needs reconciliation for this release.
• Synthetic frames cover 37 environments (with day, sunset and night variants), 110 distinct assets and 25,350 rendered camera trajectories.

Quick start

Load with 🤗 Datasets

from datasets import load_dataset
import numpy as np

test = load_dataset("NavAble/NeurIPS_2026_BLV", "real_ours", split="test")  # fetches real_ours (1.5 GB)
row = test[0]
image = row["image"]                # PIL image, RGB
labels = np.array(row["mask"])      # (H, W) uint8; pixel value = class id, 0 = background
print(row["object_class"], row["location"], np.unique(labels))

# syn is 816 GB: stream it rather than downloading it
syn = load_dataset("NavAble/NeurIPS_2026_BLV", "syn", split="train", streaming=True)
frame = next(iter(syn))             # image, mask, normals, depth, boxes, ...

Loading any split of a config downloads that whole config. Streaming (streaming=True) reads rows on demand instead.

Get the tools

The tools/ folder has a small helper module and command-line scripts. They read only the parquet shards they need.

pip install -U datasets huggingface_hub pyarrow pillow numpy
hf download NavAble/NeurIPS_2026_BLV --repo-type dataset --include "tools/*" --local-dir navable
cd navable

python tools/explore.py --config syn --classes escalator handrail --num 4 --out syn.png   # look at samples
python tools/download.py --real --syn escalator --dry-run                                 # plan a partial download

import sys; sys.path.insert(0, "tools")
import navable as nv

escalators = nv.load_syn(["escalator"])              # streams only the 8 escalator shards (12 GB, not 816 GB)
row = next(iter(escalators))
depth = nv.decode_depth(row["depth"])                 # float16 (720, 1280), metres
nv.overlay(row["image"], nv.mask_array(row["mask"])).save("overlay.png")

Dataset structure

Repository layout

NavAble/NeurIPS_2026_BLV
├── README.md                       this card (configs and features in the YAML header)
├── class_index.json                class name -> id and color
├── docs/                           datasheet and figures
├── real_ours/{train,validation,test}/data-*.parquet
├── real_curated/train/data-*.parquet
├── syn/train/data-000NN-of-00451.parquet
├── syn/shard_index.json            rows per class and environments in each syn shard
├── synthetic_objects/<class>/<asset>/<asset>.{glb,ply,usdz}
├──├── checkpoints/
│   └── navable_<model>-<training data>.pth   28 checkpoints
└── tools/                          helpers and scripts

syn rows are sorted by class, then environment, asset and trajectory. That is why one class lives in a contiguous run of shards, listed in syn/shard_index.json.

Classes

Pixel values in every mask follow this table (also in class_index.json). The syn and released real_ours row counts group records by their primary class (object_class). Masks also label other classes visible in the image. The 100 additional revolving_door images are listed as unassigned.

real_curated has no object_class column; its counts are by the classes present in each mask.

ID	Class	Color (RGB)	syn	real_ours train / val / test (or unassigned)	real_curated	3D assets
0	background	(0, 0, 0)
1	aps_button	(220, 20, 60)	62,690	206 / 23 / 66	0	15
2	bus_stop	(255, 140, 0)	60,770	205 / 23 / 62	0	61
3	bus_stop_sign	(255, 215, 0)	60,450	140 / 16 / 54	0	–
4	crosswalk	(50, 205, 50)	53,970	9 / 1 / 3	27,786	–
5	door_button	(0, 191, 255)	45,360	1,327 / 148 / 622	0	91
6	elevator	(138, 43, 226)	23,350	1,065 / 119 / 479	15	111
7	elevator_button	(255, 105, 180)	23,350	378 / 23 / 86	4,401	74
8	escalator	(0, 128, 128)	6,420	135 / 15 / 40	1,296	5
9	handrail	(165, 42, 42)	44,840	21 / 3 / 8	1,197	29
10	pedestrian_signal	(75, 0, 130)	44,650	217 / 25 / 62	6,650	66
11	revolving_door	(255, 20, 147)	25,010	100 unassigned	0	48

Images containing each class

The following counts use class presence in segmentation masks, regardless of the image's primary class. An image contributes once to a class if its mask contains at least one pixel with that class ID. These are image counts, not individual object-instance counts.

ID	Class	Released mask rows: train / val / test	Released mask rows: total	Distinct released images	Additional unassigned images	Figure 1 image count
0	background	3,695 / 396 / 1,481	5,572	5,470	—	—
1	aps_button	206 / 23 / 66	295	295	—	295
2	bus_stop	293 / 33 / 109	435	435	—	435
3	bus_stop_sign	140 / 16 / 54	210	210	—	210
4	crosswalk	304 / 37 / 93	434	434	—	434
5	door_button	1,327 / 148 / 647	2,122	2,072	—	2,072
6	elevator	1,065 / 119 / 479	1,663	1,658	—	1,658
7	elevator_button	1,314 / 120 / 511	1,945	1,894	—	1,894
8	escalator	135 / 15 / 40	190	190	—	190
9	handrail	142 / 16 / 48	206	206	—	206
10	pedestrian_signal	314 / 36 / 106	456	456	—	456
11	revolving_door	0 / 0 / 0	0	0	100	100

Counting and provenance. All 5,581 released records were scanned across train, validation and test. The released files contain 5,479 distinct photos and 102 repeated records. Distinct-image counts deduplicate identical decoded RGB photos and combine class presence across their masks. There are 24 duplicate-photo groups spanning splits. Split columns count records, whereas Figure 1 uses globally deduplicated image counts. Classes overlap, so summing class counts does not give the dataset size. Background is included for completeness and is not plotted.

Unassigned addition. The 100 additional revolving_door images are included in the collection total and Figure 1, but not in the released train/validation/test counts. Their masks were not part of this audit. A dash in the additional-images column means no additional count was supplied for that class; it does not rule out other classes appearing in those 100 images. The released files still contain zero ID 11 masks.

Source. Mask counts were computed from real_ours at revision 7f7d58f40c884183b6a8a479bdea5595ffe9db8e on 2026-11-05. All seven Parquet file hashes also match revision 40573984718b2e77d0bd11b25458b501634ff324. For example, crosswalk appears in 434 distinct images, although only 13 records assign it as the primary class.

Columns

real_ours: collected real-world photos

Column	Type	Content
image	image	RGB photo
mask	image	palettized PNG; pixel value = class id
source	string	real_world
object_class	string	the class the image was collected for
class_id	int32	id of object_class
location	string	anonymized capture location (location_00000083); intended for location-based splitting (see the release audit above)
width, height	int32	image size

real_curated: curated public images

Column	Type	Content
image	image	RGB image
mask	image	palettized PNG; pixel value = class id
source	string	real_curated
source_dataset	string	curation or mapillary
split_origin	string	the image's split in its source dataset
width, height	int32	image size

syn: Isaac Sim renders

Column	Type	Content
image	image	RGBA render, 1280×720
mask	image	palettized PNG; pixel value = class id
normals	image	world-space surface normals (Z up), RGBA PNG as written by Isaac Sim Replicator (components mapped from [-1, 1] to [0, 255])
depth	binary	distance to the image plane, float16 .npy bytes (720×1280), metres; inf where nothing was hit
source	string	synthetic
object_class, class_id	string, int32	the class of the placed asset
environment, sublocation	string	scene (e.g. downtown_west_sunset) and the spot within it
asset	string	the placed 3D asset
trajectory, frame_index	string, int32	camera trajectory and frame number
bbox	list of [x_min, y_min, x_max, y_max]	tight 2D boxes in pixels
bbox_class_ids, occlusion_ratio, bbox_prim_paths	lists	class id, occluded fraction and USD prim path of each 2D box
bbox_3d	list of [x_min, y_min, z_min, x_max, y_max, z_max]	3D box extents in each object's local frame
bbox_3d_transform	list of 16 floats	row-major 4×4 local-to-world transform; translation in the last row, world units are centimetres
bbox_3d_class_ids, bbox_3d_occlusion_ratio, bbox_3d_prim_paths	lists	class id, occluded fraction and USD prim path of each 3D box
width, height	int32	1280, 720

Decoding the synthetic modalities

import io, numpy as np

depth = np.load(io.BytesIO(row["depth"]))      # float16 (720, 1280), metres (or nv.decode_depth)
normals = np.asarray(row["normals"])[..., :3] / 127.5 - 1.0   # approximate unit normals, world frame

# 3D box corners in world coordinates (centimetres)
ext = np.array(row["bbox_3d"][0]); T = np.array(row["bbox_3d_transform"][0]).reshape(4, 4)
corners = np.array([[x, y, z, 1] for x in ext[[0, 3]] for y in ext[[1, 4]] for z in ext[[2, 5]]])
corners_world = (corners @ T)[:, :3]

Camera intrinsics and poses are not included, so the 3D boxes can't be projected into the image.

How to use

Train a segmentation model (paper protocol)

The paper trains on real_ours/train, optionally adding real_curated (+Cur) and/or syn (+Syn). It picks the checkpoint with the best foreground mIoU on real_ours/validation and reports on real_ours/test. Models predict 12 labels (background + 11 classes). The paper's real-world scores cover background and the 10 classes with real examples in its original benchmark, before the 100-image revolving_door addition.

Most training code reads image folders, so export the splits once:

python tools/export.py --config real_ours --split train      --out data/navable
python tools/export.py --config real_ours --split validation --out data/navable
python tools/export.py --config real_ours --split test       --out data/navable
python tools/export.py --config syn --classes escalator --max-rows 5000 --out data/navable_syn   # a synthetic subset

This writes img_dir/<split>/*.png and ann_dir/<split>/*.png (label value = class id), the mmsegmentation layout. A matching mmseg 1.x dataset class:

from mmseg.datasets import BaseSegDataset
from mmseg.registry import DATASETS

@DATASETS.register_module()
class NavAbleDataset(BaseSegDataset):
    METAINFO = dict(
        classes=("background", "aps_button", "bus_stop", "bus_stop_sign", "crosswalk", "door_button", "elevator",
                 "elevator_button", "escalator", "handrail", "pedestrian_signal", "revolving_door"),
        palette=[[0, 0, 0], [220, 20, 60], [255, 140, 0], [255, 215, 0], [50, 205, 50], [0, 191, 255],
                 [138, 43, 226], [255, 105, 180], [0, 128, 128], [165, 42, 42], [75, 0, 130], [255, 20, 147]])

    def __init__(self, **kwargs):
        super().__init__(img_suffix=".png", seg_map_suffix=".png", reduce_zero_label=False, **kwargs)

Training settings used in the paper (Appendix A)

All models share one augmentation pipeline: random resize 0.5–2.0×, category-balanced random crop (cat_max_ratio=0.75), horizontal flip (p = 0.5) and photometric distortion. They use a linear warm-up then polynomial learning-rate decay, with class weights of 0.1 for background and 1.0 for each other class. Iteration budgets grow with the training set; they are listed per model and data mix in the paper.

Model	Backbone	Crop	Optimizer (base lr)	Weight decay	Batch
DeepLabv3+	ResNet-101	512	SGD 5e-3, momentum 0.9	5e-4	8
EncNet	ResNet-101	512	SGD 5e-3, momentum 0.9	5e-4	8
SegFormer	MiT-B5	640	AdamW 1e-5 (head 10×)	0.01	8
Mask2Former	Swin-L	640	AdamW (backbone 0.1×)	0.05	4–8
SAN	CLIP ViT-B/16	640	AdamW 1e-4 (encoder 0.1×)	1e-4	24

The full training code and configs are in the GitHub repository.

For a plain PyTorch loop, nv.NavAbleSegmentation wraps a split as a Dataset of tensors:

from torch.utils.data import DataLoader
train = nv.NavAbleSegmentation(nv.load("real_ours", "train"), size=(360, 640))
loader = DataLoader(train, batch_size=8, shuffle=True, num_workers=4)
batch = next(iter(loader))    # {"image": (8, 3, 360, 640) float, "mask": (8, 360, 640) int64}

Evaluate on the real-world test set

Save one label PNG per test image, named like the image (row["image"]["path"], e.g. 0f4eab9c-frame_003200.png), with dataset class ids. Then run:

python tools/evaluate.py --pred-dir preds/ --out results.json

It prints per-class IoU, precision and recall, and the means the paper reports. mIoU, mPrecision and mRecall average over background plus the 10 classes with real-world examples in the original paper benchmark. It also prints the means over the 10 classes alone. In code, the same metric is nv.SegmentationMetrics.

Comparing with the paper. The real_ours masks here were rasterized from the annotation polygons with pycocotools. The paper's masks also include the polygon edge pixels, which differ on about 0.2% of pixels. On these masks, the released checkpoints score about 0.7–0.9 mIoU below the paper. Examples: SegFormer (Real) 60.20 vs 61.06, DeepLabv3+ (Real) 62.99 vs 63.84, Mask2Former (Real) 67.93 vs 68.84. Compare methods on the same masks.

Use the released checkpoints

The checkpoints/ directory contains 28 checkpoints: seven models, each trained on four data mixes. The table gives their paper mIoU on real_ours/test, with the best mix per model in bold.

Model (backbone)	Real	Real+Cur	Real+Syn	Real+Cur+Syn	File name
Mask2Former (Swin-L)	68.84	71.29	72.67	70.75	navable_mask2former-<mix>.pth
SAN (CLIP ViT-B/16)	62.07	62.52	66.96	68.12	navable_san-vit-b16_<mix>.pth (mix written with -)
SegFormer (MiT-B5)	61.06	62.16	65.54	65.96	navable_segformer-<mix>.pth
DeepLabv3+ (ResNet-101)	63.84	59.49	52.63	59.84	navable_deeplabv3plus-<mix>.pth
EncNet (ResNet-101)	60.56	52.77	57.50	56.50	navable_encnet-<mix>.pth
SegMAN-B (full fine-tuning)	65.03	71.97	71.56	73.77	navable_segman-<mix>.pth
SAM 3 (full fine-tuning)	72.64	69.91	70.01	68.11	navable_sam3-<mix>.pth

<mix> is real, real+cur, real+syn or real+cur+syn. The +Syn checkpoints were trained on the earlier render of syn (452,704 frames, before the 2026-11 re-release).

python tools/download.py --checkpoints segformer --train-data real real+syn      # or --checkpoints all --dry-run
python tools/eval_checkpoint.py --checkpoint navable/checkpoints/navable_segformer-real.pth  # needs mmsegmentation 1.x

Label order. The checkpoints were trained with a different class order from the dataset masks: background, elevator, elevator_button, door_button, crosswalk, pedestrian_signal, aps_button, bus_stop, bus_stop_sign, handrail, escalator, revolving_door. SAN uses the same order without background. Map predictions with nv.checkpoint_to_dataset_labels(pred) (has_background=False for SAN), or pass --label-order checkpoint to evaluate.py. eval_checkpoint.py does this for you. It runs DeepLabv3+, EncNet, SegFormer and Mask2Former; SAN, SegMAN and SAM 3 need their own code (GitHub, evaluation-code/). The checkpoint metadata predates the rename of class 11 and still uses its old name.

Work with the synthetic data

• One class or a sample, not 816 GB: nv.load_syn(["handrail"]) streams only that class's shards. python tools/download.py --syn handrail saves them locally, and --syn all --max-shards 5 gives a quick 10 GB sample.
• Depth and normals: the frames work for depth or normal estimation and multi-task learning. Depth is float16 in metres (at most 0.05% relative error from the float32 render).
• Detection: bbox / bbox_class_ids give tight 2D boxes for every labelled object, and occlusion_ratio lets you drop heavily occluded ones. bbox_3d and bbox_3d_transform give 3D boxes in the Isaac Sim world frame.
• Sim-to-real: environment names include lighting variants (_sunset, _night), and asset identifies the 3D asset, so you can hold out environments, lighting or assets.

Use the 3D assets

synthetic_objects/<class>/<asset>/ holds each asset as a .glb mesh, a .ply Gaussian splat and a .usdz bundle that Isaac Sim, Omniverse or AR viewers can load directly. The assets were reconstructed from web images with SAM 3D Objects (see How the data was made).

python tools/download.py --assets door_button elevator_button

Results from the paper

Segmentation on the real-world test set (mIoU, %). Adding synthetic data helps the transformer and mask-classification models most. Zero-shot SAN without NavAble training reaches only 14.94 mIoU.

Model	Real	Real+Cur	Real+Syn	Real+Cur+Syn	Best vs. Real
SAN	62.07	62.52	66.96	68.12	+6.05
Mask2Former	68.84	71.29	72.67	70.75	+3.83
SegFormer	61.06	62.16	65.54	65.96	+4.90
DeepLabv3+	63.84	59.49	52.63	59.84	−4.00
EncNet	60.56	52.77	57.50	56.50	−3.06

Vision-language models, zero-shot (363 test images, 10 classes)

Model	Box AP	AP50	Point in mask	PCK@0.05	PCK@0.10
Gemini Robotics-ER 1.6	33.8	48.9	69.0	68.7	85.5
Gemini 3 Pro	31.5	45.9	68.6	61.2	79.4
Qwen3-VL-32B	20.0	29.7	59.0	59.7	79.2
MolmoPoint-8B	–	–	74.2	55.0	73.6

On assistive robots. On egocentric footage from a cane-shaped mobility device and a quadruped guide-dog robot, SegFormer trained with synthetic data beats real-only training. mIoU rises from 11.94 to 16.17 on the cane and from 21.56 to 23.08 on the quadruped, with the largest gains on pedestrian signals, APS buttons and handrails.

How the data was made

Real data. Public segmentation datasets have noisy, inconsistent or missing labels for these objects. We curated 36,466 images from them for consistent masks and remapped them to one taxonomy (real_curated). The released real_ours contains 5,581 annotated image records collected indoors and outdoors, with COCO polygon annotations. The collection now includes 100 additional revolving_door images awaiting split assignment (5,681 records including the addition). The original split design aimed to reserve test locations; the overlap found in the released metadata is noted above.

Synthetic data. The generator turns web images into simulation-ready assets. A vision-language model filters candidate images, and Grounding DINO and SAM isolate the object. SAM 3D Objects reconstructs a textured 3D asset, which is placed in Isaac Sim scenes and rendered along configurable camera trajectories under day, sunset and night lighting. Replicator writes RGB, class masks, depth, surface normals and 2D/3D boxes for every frame.

Tools

Script	What it does
tools/navable.py	Helpers: class names and palette, loaders (load, load_syn), depth / mask / box decoding and drawing, the paper's metrics, checkpoint label remapping, a PyTorch Dataset.
tools/download.py	Download only what you need (real data, syn shards by class, 3D assets, checkpoints); prints sizes first.
tools/explore.py	Save a grid of random samples with masks and, for syn, depth, normals and boxes.
tools/export.py	Write a config/split as image + label folders (mmsegmentation layout), optionally with depth and normals.
tools/evaluate.py	Score prediction PNGs on real_ours with the paper's metrics.
tools/eval_checkpoint.py	Run a released checkpoint on real_ours/test.

They need only datasets, huggingface_hub, pyarrow, numpy and Pillow; PyTorch and mmsegmentation are needed only for training and checkpoint evaluation. Training code for the paper's models is in the GitHub repository.

Dataset card

Intended uses. Training and evaluating perception for assistive navigation, such as segmentation and detection of accessibility-critical infrastructure; sim-to-real transfer; depth and normal estimation on synthetic data; and asset-based synthetic data generation.

Out-of-scope uses. Surveillance or identifying people. Models trained on NavAble are not validated for unsupervised safety-critical deployment; BLV navigation aids need further testing with their users.

Personal and sensitive information. The synthetic data contains no real people. Real photos were taken in public spaces for accessibility research; capture locations are anonymized ids.

Known limitations.

• Real images are 640×360 while synthetic frames are 1280×720; resize to a common input size.
• Some classes have few real examples (for example crosswalk and handrail in real_ours); report per-class scores.
• The 100 collected revolving_door images are awaiting split assignment and are not included in the audited Parquet files. The paper's reported real-world metrics use the original 10-class benchmark and do not include this addition.
• Synthetic textures and lighting do not match the real world exactly.

License. CC BY 4.0.

More. Datasheet for Datasets · Class index · Croissant metadata (the Croissant button on the dataset page). Questions and issues: open a discussion on this page or an issue on GitHub.

Citation

@inproceedings{hwang2026navable,
  title     = {{NavAble}: A Large-Scale Dataset and Synthetic Data Generation Pipeline for Blind Navigation},
  author    = {Hwang, Hochul and Monon, Jahir Sadik and Yang, Soowan and
               Patel, Shiven Umeshbhai and Nguyen, Anh Nhat Hong and Nguyen, Kien and
               Garg, Keshav and Gage, Dylan and Hordofaa, Duretti and
               Anjna, Anshu and Ohn-Bar, Eshed and Kim, Donghyun},
  booktitle = {Advances in Neural Information Processing Systems},
  year      = {2026},
  url       = {https://neurips.cc/virtual/2026/loc/sydney/poster/138983}
}

Changelog

• 2026-11: syn re-rendered with surface normals, depth and 3D bounding boxes (450,860 frames). Class 11 renamed to revolving_door (same id and color; 3D assets moved to synthetic_objects/revolving_door/). Added tools/, syn/shard_index.json and this card. Added 100 collected revolving_door images awaiting split assignment, plus mask-based per-class image counts and notes on duplicate records and location overlap. The released real_ours Parquet files remain unchanged at the audited revisions; real_curated is unchanged.
• 2026-05: first release.