Replay NVIDIA's public Aerial ISAC SRS I/Q recording through NVIDIA's production E3 Agent into a COSMOS sensing dApp on a GH200, and score its range-Doppler detections against the dataset's camera labels. No radio is involved.
Only the dataset replay works today. Live sensing on a COSMOS cell is not done yet. This page replays a recording NVIDIA made on its own testbed. Running the same dApp on live uplink SRS from a COSMOS cell is work in progress and is our next step. A first live recording exists, but it has no ground truth and a known artefact, so it is not a sensing result. See Live sensing on COSMOS: not done yet.
Integrated sensing and communication (ISAC) uses the signals a cellular network already sends to sense the space around it. Here the signal is the 5G NR uplink Sounding Reference Signal (SRS). A phone sends it so the base station can measure the uplink channel. People and cars moving between the phone and the radio unit change that channel, and a range-Doppler map of the change shows where they are and how fast they move.
The data is NVIDIA's. The Aerial ISAC SRS I/Q dataset (NVIDIA Corporation, version 1.0.0, CC BY 4.0) is one 85 s outdoor capture on NVIDIA's Aerial testbed:
The SRS I/Q was written by the E3 Agent, the component that exposes L1 data to dApps, in its replay-trace format. That format is what makes this tutorial possible: the same agent replays the trace exactly as it would deliver live data.
The pieces from NVIDIA (all open source, Apache-2.0):
The dApp framework and the testbed are described in Villa et al., arXiv:2512.06493.
What COSMOS adds is the isac-srs-python dApp. It is generated from NVIDIA's prb-power-python sample app, and it does:
COSMOS also adds the scorer that compares the dApp's detections with NVIDIA's labels, and the packaging as shared content on the GH200 servers.
On COSMOS the dataset sits unmodified, read-only, on the reference-dataset share (10.0.0.41:/datasets/nvidia/aerial-isac-srs-iq, Hugging Face revision 99b4afb). The containers, the dApp and the scorer are the shared-content project isac-replay.
Where the live work stands (November 2026), so nobody reads the replay numbers below as a COSMOS radio result:
srv9.rrail and the Foxconn O-RU delivers 200 SRS records per second from a COTS Quectel modem to the same dApp. That needed a periodic-SRS patch in OAI and an L2 setting: the Aerial L1 drops SRS in uplink slots without PUSCH on single-section O-RUs.isac-p2-20261117T1312Z-rec, 14 min, an empty room. It has no ground truth: no camera yet, no calibration walks.rrail room for ground truth, record calibration walks with people in the room, then score the live dApp the way this page scores the replay.This page will gain a live section only when that is done.
After completing this tutorial you will be able to:
| Difficulty | Intermediate |
|---|---|
| Estimated time | 20 min (most of it the first container load and the 3-minute replay) |
| Domain / sandbox | rrail (srv8.rrail or srv9.rrail) |
| Image | gpu-compute-gh200.ndz |
| Transmits? | no (replay only) |
| Last verified | 2026-11-17, gpu-compute-gh200-20261114b and content isac-replay 20261117 on srv8.rrail |
Background knowledge
Account & access
Devices / nodes
| Resource | Role | Qty | Notes |
|---|---|---|---|
srv8.rrail or srv9.rrail |
runs the E3 Agent, the dApp and the scorer | 1 | NVIDIA GH200 480GB (ARM Neoverse-V2, 72 cores); the replay runs on the CPU |
Disk images
| Image | Load onto | Provides |
|---|---|---|
gpu-compute-gh200.ndz |
the GH200 server | Docker, the NVIDIA container toolkit and cosmos-content |
Software components
| Component | Version | Source | Licence |
|---|---|---|---|
| Aerial ISAC SRS I/Q dataset | 1.0.0, revision 99b4afb |
Hugging Face; on COSMOS 10.0.0.41:/datasets/nvidia/aerial-isac-srs-iq |
CC BY 4.0 |
| E3 Agent Standalone | Aerial CUDA-Accelerated RAN 26-2 | GitHub | Apache-2.0 |
| Aerial Sample Apps (dApp framework) | v1.2.0 (718394f) |
GitHub | Apache-2.0 |
isac-srs-python dApp + scorer |
content isac-replay 20261117 |
COSMOS | Apache-2.0 |
| NVIDIA PyTorch container (the dApp's base) | 26.01 | NGC | NVIDIA's container terms |
The release carries an ATTRIBUTION.md and the Apache-2.0 text next to the code.
One server, no radio:
/mnt/datasets (NetApp, read-only) -- srs_iq.trace --> [ E3 Agent, replay mode ] --shared memory + ZMQ (E3AP)--> [ isac-srs-python dApp ]
|
ground_truth.json (camera labels) --> [ scorer ] <-- detections (JSON lines) ---+
The E3 Agent and the dApp are two containers on the same host. They share an IPC namespace, as they would beside a live Aerial L1. The trace is read in place from the network share; nothing from the dataset is copied.
cosmos-content enable isac-replay
cosmos-content sync isac-replay
enabled isac-replay
isac-replay nfs (nothing marked copy)
mkdir -p /mnt/datasets
mount -t nfs -o vers=3,ro 10.0.0.41:/datasets /mnt/datasets
ls /mnt/datasets/nvidia/aerial-isac-srs-iq/data/aerial-isac-srs-iq-001
ground_truth.json
ground_truth.jsonl
image_labels.json
metadata.json
srs_iq.trace
video.mp4
video_sync.json
The share also carries NVIDIA's README.md and LICENSE for the dataset. Read them; the licence asks you to cite the dataset (see References).source /opt/content/isac-replay/env.sh
echo $ISAC_WORK
/mnt/datadisk/work/root/isac-replay
Everything you run writes under $ISAC_WORK. The content itself is read-only.
isac-replay setup
loading e3agent-standalone:latest from /opt/content/isac-replay/images/e3agent-standalone.tar ...
loading dapp-isac-srs-python:latest from /opt/content/isac-replay/images/dapp-isac-srs-python.tar ...
SETUP-OK work=/mnt/datadisk/work/root/isac-replay data=/mnt/datasets/nvidia/aerial-isac-srs-iq/data/aerial-isac-srs-iq-001
The first setup on a node loads the two container images (9.8 GB) from the share. Later setups skip images that are already loaded.
isac-replay run
Container e3agent-standalone Creating
Container e3agent-standalone Created
Container e3agent-standalone Starting
Container e3agent-standalone Started
Container dapp-isac-srs-python Creating
Container dapp-isac-srs-python Created
Container dapp-isac-srs-python Starting
Container dapp-isac-srs-python Started
replay running for 185 s
RUN-END detections=1630
The agent plays the 85 s trace twice. The dApp subscribes while the first pass is running, so the second pass is the one it sees from start to end; that is the pass the scorer uses.
isac-replay score
metric this run reference
labelled objects detected (within 3 m) 50.6% 49.2%
range error RMS, m 1.32 1.31
range error median, m 1.01 1.00
range bias, m -0.69 -0.66
velocity error RMS, m/s 1.06 1.13
false peaks per window 5.39 5.41
windows scored: 472, objects 569, matched 288
isac-replay all runs the three steps in one go.
SRS and the channel. The trace holds one SRS record per 2.5 ms: 1632 pilot tones (comb 2 over 272 PRB) on 4 receive antennas. The dApp regenerates the Zadoff-Chu sequence from the cell's SRS parameters (sequence ID 40, C_SRS 61) and divides it out. That gives a least-squares channel estimate per record. With the right sequence ID, the impulse response peaks 58 dB above its median; with a wrong one, 6 dB.
Three steps that matter, measured on this dataset:
A range CFAR detector made things worse (47 % to 15 %): the targets spread over several range bins.
Range-Doppler. Static clutter is removed by subtracting a slow background. Every 40 records (100 ms), an FFT across delay and across the 40 records gives the map. Range is the bistatic excess path. The velocity limit at 2.5 ms is ±8.3 m/s. The six strongest peaks per window are reported, with no tracker.
The scorer maps each detection window to the camera-labelled 100 ms windows by the SRS records' TAI timestamps. A labelled object counts as detected if a reported peak is within 3 m of its range. The cached LS-channel file in the content (cache/h_ls.npz) supplies the record timestamps.
Through the production path. The dApp does not read the trace file. The E3 Agent puts each SRS record in shared memory and announces it over E3AP, exactly as it does next to a live Aerial L1. The same dApp container is what we attach to our live cell (see the status note above).
About 1630 detection windows from the two passes. Against the reference run (2026-11-10, srv9.rrail), about half of the labelled objects are detected, with a range error around 1.3 m RMS.
Detection varies by a percent or two between runs, because the 100 ms windows start at a different record each time.
Read the numbers honestly:
track_peak_range_m, 2.0 m RMS) covers 97 % of the objects, so the two RMS values are not like for like.cd /opt/aerial-data/isac-replay/20261117 && sha256sum -c --quiet SHA256SUMS && echo OK
OK
isac-replay score reports 472 windows and 569 objects, and the detection rate is within a few percent of the reference column.cp -a $ISAC_WORK/results ~/isac-results-$(date +%F) # or copy them off the server
rm -rf $ISAC_WORK
docker rmi e3agent-standalone:latest dapp-isac-srs-python:latest
umount /mnt/datasets
cosmos-content disable isac-replay
rm -f /opt/content/isac-replay
cosmos-content disable does not yet remove the /opt/content link (fixed in the next image); the rm does. The replay containers stop by themselves at the end of isac-replay run.
| Symptom | Cause | Fix |
|---|---|---|
dataset not found at /mnt/datasets/... |
the reference-dataset share is not mounted | Setup step 3 |
ISAC: source /opt/content/isac-replay/env.sh first |
the environment is not loaded | source /opt/content/isac-replay/env.sh |
permission denied ... docker.sock |
not root and not in the docker group |
run as root on your reserved server |
RUN-END detections=0 |
the dApp did not attach to the agent | docker logs dapp-isac-srs-python while it runs; check that nothing else uses ports 5555–5557 |
| Detection far below 45 % | windows from the first pass are being scored, or the run was cut short | let isac-replay run finish; do not change ISAC_RUN_S |
Please cite the dataset if you use it, as NVIDIA asks:
@misc{nvidia2026aerialisacsrsiq,
title = {{Aerial ISAC SRS I/Q}},
author = {{NVIDIA Corporation}},
year = {2026},
note = {Version 1.0.0},
howpublished = {\url{https://huggingface.co/datasets/nvidia/aerial-isac-srs-iq}}
}
prb-power-python app the COSMOS dApp is generated from).The dataset and the NVIDIA software are NVIDIA's work, used under their licences; COSMOS is not affiliated with or endorsed by NVIDIA for this tutorial.
Group: GPU computing · Image: gpu-compute-gh200.ndz · Content: isac-replay 20261117 · Last verified 2026-11-17 on srv8.rrail