Add files using upload-large-folder tool

README.md

@@ -1,3 +1,331 @@
 ---
 license: cc-by-nc-sa-4.0
+task_categories:
+- object-detection
+tags:
+- atlas
+- lidar
+- 3d-object-detection
+- adversarial-robustness
+- point-cloud
+- nuscenes
+size_categories:
+- 10K<n<100K
+configs:
+- config_name: inject_global_easy
+  data_files:
+  - split: train
+    path: data/inject_global_easy/train-*
+- config_name: inject_global_medium
+  data_files:
+  - split: train
+    path: data/inject_global_medium/train-*
+- config_name: inject_global_hard
+  data_files:
+  - split: train
+    path: data/inject_global_hard/train-*
+- config_name: inject_relative_easy
+  data_files:
+  - split: train
+    path: data/inject_relative_easy/train-*
+- config_name: inject_relative_medium
+  data_files:
+  - split: train
+    path: data/inject_relative_medium/train-*
+- config_name: inject_relative_hard
+  data_files:
+  - split: train
+    path: data/inject_relative_hard/train-*
+- config_name: removal_az10
+  data_files:
+  - split: train
+    path: data/removal_az10/train-*
+- config_name: removal_az20
+  data_files:
+  - split: train
+    path: data/removal_az20/train-*
+- config_name: removal_az30
+  data_files:
+  - split: train
+    path: data/removal_az30/train-*
+- config_name: removal_az40
+  data_files:
+  - split: train
+    path: data/removal_az40/train-*
+- config_name: removal_az50
+  data_files:
+  - split: train
+    path: data/removal_az50/train-*
+- config_name: removal_az60
+  data_files:
+  - split: train
+    path: data/removal_az60/train-*
 ---
+
+# ATLAS-nuScenes
+
+Adversarial LiDAR point clouds derived from the nuScenes trainval **validation**
+split (150 scenes, 6019 keyframes).
+
+Anonymous release supporting a submission under review; author and affiliation
+details are withheld for the review period.
+
+Part of **ATLAS**: `ps3020/atlas-kitti` · `ps3020/atlas-nuscenes`
+
+## Configs
+
+Injection — a phantom vehicle that does not exist is added:
+
+`inject_global_easy`, `inject_global_medium`, `inject_global_hard`,
+`inject_relative_easy`, `inject_relative_medium`, `inject_relative_hard`
+
+`global` fixes the phantom in world coordinates, `relative` fixes it relative to
+the ego vehicle. `easy`/`medium`/`hard` are decreasing phantom point densities.
+
+Removal — points in an azimuth wedge are deleted to hide a real vehicle:
+
+`removal_az10`, `removal_az20`, `removal_az30`, `removal_az40`, `removal_az50`,
+`removal_az60` (suffix = wedge width in degrees)
+
+Every row is an attacked frame; there are no clean frames.
+
+## Setup
+
+**1. Install**
+
+```bash
+pip install datasets numpy
+pip install nuscenes-devkit   # only for sequence reconstruction (optional)
+```
+
+**2. Load a config**
+
+```python
+from datasets import load_dataset
+ds = load_dataset("ps3020/atlas-nuscenes", "removal_az20", split="train")
+```
+
+Add `streaming=True` to avoid downloading a whole config (each is 2.5–3.7 GB).
+
+**That is all that is required to evaluate attacks.** Each row carries the
+complete attacked point cloud and the attacked object's box, so attack success
+rate needs nothing else.
+
+**3. nuScenes source data — only for sequence reconstruction**
+
+Needed *only* if you want the clean frames this dataset does not ship (see
+*Attacked frames only* below). Download from
+<https://www.nuscenes.org/nuscenes> (free account): `v1.0-trainval_meta.tgz`
+plus the ten `v1.0-trainval{01..10}_blobs_lidar.tgz` (~126 GB). Extract to:
+
+```
+<NUSCENES_ROOT>/
+  samples/LIDAR_TOP/     34149 keyframe clouds
+  sweeps/LIDAR_TOP/      297737 intermediate clouds
+  v1.0-trainval/         *.json metadata tables
+```
+
+> Some nuScenes archives carry trailing bytes that make `tar xzf` abort **silently
+> part-way**, leaving `sweeps/` incomplete. If you hit missing-file errors, use
+> `gzip -dc FILE.tgz | tar -x --ignore-zeros -C <NUSCENES_ROOT>` and confirm
+> `ls sweeps/LIDAR_TOP | wc -l` reports 297737.
+
+### Quick check
+
+```python
+from datasets import load_dataset
+import numpy as np
+
+ds = load_dataset("ps3020/atlas-nuscenes", "removal_az20",
+                  split="train", streaming=True)
+ex = next(iter(ds))
+pts = np.asarray(ex["points"], np.float32).reshape(ex["num_points"], ex["point_dim"])
+print(ex["segment"], ex["frame_index"], pts.shape)
+# scene-0003 32 (259188, 6)
+```
+
+## Usage
+
+```python
+from datasets import load_dataset
+import numpy as np
+
+ds = load_dataset("ps3020/atlas-nuscenes", "removal_az20", split="train")
+ex = ds[0]
+
+# points are stored FLAT -- reshape to recover the cloud
+pts = np.asarray(ex["points"], np.float32).reshape(ex["num_points"], ex["point_dim"])
+# (N, 6) = x, y, z, intensity, time, lag   (10-sweep accumulated, N ~ 265k)
+
+spoof_gt = np.asarray(ex["spoof_gt"], np.float32)   # (7,) injection | (10,) removal
+gt_boxes = np.asarray(ex["gt_boxes"], np.float32).reshape(ex["num_gt"], ex["gt_box_dim"])
+pose     = np.asarray(ex["pose"], np.float64).reshape(4, 4)   # ref(lidar) -> global
+```
+
+Or use the bundled helper:
+
+```python
+from load_atlas_nuscenes import load_atlas, points_of, attacked_index
+
+ds  = load_atlas("removal_az20")
+pts = points_of(ds[0])
+idx = attacked_index(ds)        # {segment: {frame_index: row}}
+```
+
+## Attack success rate
+
+`spoof_gt` is the attacked object. Score each frame by whether a prediction
+overlaps it at IoU >= 0.3:
+
+- **injection** — success = a detection *appears* (false positive created)
+- **removal** — success = the detection *is missing* (true positive destroyed)
+
+```python
+n_success = 0
+for ex in ds:
+    pts  = np.asarray(ex["points"], np.float32).reshape(ex["num_points"], ex["point_dim"])
+    pred = my_detector(pts)
+    hit  = overlaps(pred, ex["spoof_gt"], iou_thresh=0.3)
+    n_success += hit if "inject" in config else (not hit)
+
+asr = n_success / len(ds)
+```
+
+**Use `len(ds)`, not 6019.** Only attacked frames are shipped and only they are
+scored. Counts differ per family because removal additionally requires a trackable
+vehicle:
+
+| family | configs | attacked frames each |
+|---|---|---|
+| injection | 6 | 1219 |
+| removal | 6 | 869 |
+
+## Attacked frames only
+
+A nuScenes scene is ~40 keyframes and the attack covers the last 8, so ~80% of
+each split would be a **bit-identical copy of source nuScenes**. Those frames are
+not shipped, for three reasons: they are nuScenes' data rather than ours and
+redistributing them would bypass nuScenes' own registration and license terms;
+they are identical across all 12 configs, so shipping them means 12 duplicate
+copies; and they are never scored, since ASR is defined only on attacked frames.
+
+Nothing is lost. The omitted frames are unmodified, so a full sequence is
+recovered by substitution. Every row carries four keys back to the source:
+
+| key | meaning |
+|---|---|
+| `segment` | scene name, e.g. `"scene-0003"` |
+| `frame_index` | position within the scene (0-based) |
+| `sample_token` | **nuScenes sample token — the canonical global key** |
+| `frame_id` | source `LIDAR_TOP` filename |
+
+Prefer `sample_token`: it is nuScenes' own primary key and does not depend on
+reproducing our scene ordering.
+
+### Reconstructing a full sequence
+
+This dataset is standalone — it is not a patch layer over nuScenes, and nothing
+substitutes frames automatically. If you want full sequences, mix the two sources
+in your own loader. This example is complete and runnable:
+
+```python
+import os
+import numpy as np
+from nuscenes.nuscenes import NuScenes
+from datasets import load_dataset
+
+NUSCENES_ROOT = "/path/to/nuscenes"
+nusc = NuScenes(version="v1.0-trainval", dataroot=NUSCENES_ROOT, verbose=False)
+ds   = load_dataset("ps3020/atlas-nuscenes", "removal_az20", split="train")
+
+attacked = {}                      # {segment: {frame_index: row}}
+for r in ds:
+    attacked.setdefault(r["segment"], {})[r["frame_index"]] = r
+
+def clean_cloud(sample_token):
+    """One clean nuScenes keyframe as (N, 5) = x, y, z, intensity, ring."""
+    sd = nusc.get("sample_data", nusc.get("sample", sample_token)["data"]["LIDAR_TOP"])
+    return np.fromfile(os.path.join(NUSCENES_ROOT, sd["filename"]),
+                       dtype=np.float32).reshape(-1, 5)
+
+scene_name = "scene-0003"
+scene = next(s for s in nusc.scene if s["name"] == scene_name)
+
+sequence, tok = [], scene["first_sample_token"]
+for i in range(scene["nbr_samples"]):
+    if i in attacked[scene_name]:
+        row = attacked[scene_name][i]
+        pts = np.asarray(row["points"], np.float32).reshape(
+            row["num_points"], row["point_dim"])          # (N, 6), ATTACKED
+        sequence.append((pts, True))
+    else:
+        sequence.append((clean_cloud(tok), False))        # clean, from your copy
+    tok = nusc.get("sample", tok)["next"]
+
+print(f"{scene_name}: {len(sequence)} frames, "
+      f"{sum(a for _, a in sequence)} attacked")
+# scene-0003: 40 frames, 7 attacked
+```
+
+For an existing pipeline, one dict lookup is usually enough:
+
+```python
+attacked_by_token = {r["sample_token"]: r for r in ds}
+
+def get_points(sample_token):
+    r = attacked_by_token.get(sample_token)
+    if r is not None:
+        return np.asarray(r["points"], np.float32).reshape(r["num_points"], r["point_dim"])
+    return my_existing_loader(sample_token)
+```
+
+Three things to know when doing this:
+
+- **Clean and attacked clouds are not the same width.** Ours are `(N, 6)` at ~265k
+  points because they are 10-sweep accumulated. A single raw `.pcd.bin` is `(N, 5)`
+  at ~35k points with `ring` as the 5th column. If your loader accumulates sweeps
+  itself, do **not** re-accumulate ours — they are already assembled.
+- **Reproducing our clean frames exactly needs the detector pipeline, not just
+  sweep accumulation.** `load_atlas_nuscenes.clean_cloud()` accumulates 10 sweeps
+  and is fine for inspection, but it omits the point-cloud range filter and returns
+  ~1.3× too many points (~347k vs ~265k). For a numerically matched clean baseline,
+  load through the same config used for evaluation (e.g. OpenPCDet
+  `NuScenesDataset` with the standard 10-sweep nuScenes config).
+- **`frame_id` is the `.pcd` stem** while nuScenes stores `<stem>.pcd.bin`, so a
+  filename equality check fails. Use `sample_token`.
+
+For **attack evaluation none of this applies**: ASR uses only the shipped frames.
+
+## Fields
+
+| field | description |
+|---|---|
+| `segment`, `frame_index`, `num_frames_in_segment` | position within the scene |
+| `sample_token`, `frame_id` | nuScenes identity |
+| `points`, `num_points`, `point_dim` | attacked cloud, flattened; reshape to `(N, 6)` |
+| `spoof_gt`, `spoof_gt_dim` | attacked object — `(7,)` injection, `(10,)` removal |
+| `gt_boxes`, `num_gt`, `gt_box_dim` | clean nuScenes GT `(M, 10)`, last column = 1-indexed class (car = 1) |
+| `pose` | 4×4 ref(lidar) → global, flattened |
+| `atk_*` | attack parameters — 7 fields for injection, 21 for removal |
+
+For removal, the realised removal rate is
+`atk_n_points_removed / atk_n_points_in_sector`.
+
+## Notes
+
+- Point clouds are **10-sweep accumulated** (~265k points/frame), the standard
+  nuScenes detection setting. Feature 4 is a timestamp, not elongation.
+- `spoof_gt` has 10 columns for removal (a real GT box: geometry + velocity +
+  class) but 7 for injection (a phantom: geometry only).
+- Attacks target the **car** class.
+- Removal follows the A-HFR model, with per-width removal probabilities calibrated
+  against physical measurements from Cao et al., USENIX Security 2023. Its
+  range-dependent firing gate means not every scheduled frame fires.
+- Phantom intensity is sampled from the diffuse range-conditioned distribution
+  rather than saturated; see the paper for the ablation.
+
+## License
+
+`cc-by-nc-sa-4.0`, inherited from nuScenes. These are derived point clouds, so the
+non-commercial and share-alike terms of the original apply. Please cite nuScenes
+alongside this dataset.

data/inject_global_easy/train-00000-of-00009.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:9c3f0f1a0b657c8b1cef5e7facfcd913ee81ad79a7886b378a21fc117d75ac1a
+size 429896695

data/inject_global_easy/train-00001-of-00009.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:9be2edf77ba75ecc1bbee4134f6328029467048ac43213a7d1c84dbf44db55c8
+size 401016788

data/inject_global_easy/train-00002-of-00009.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:8bcdc50ddd3e29340a8354e5128133dfaad69d47c650b307b8cb94949716a491
+size 428932742

data/inject_global_easy/train-00003-of-00009.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:e97ac4982bc542abdc148812ef04e5b228bf3baf1d5ecf4c955f30ffaf4179d5
+size 435614544

data/inject_global_easy/train-00008-of-00009.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:31cbe37c5fff9d35404a2ee4f5c794bc0cd3c7fe2589154554767137ea979594
+size 158359355

data/inject_relative_easy/train-00000-of-00009.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:db4cfe90f2a07d1dc74a48782a9d1d58e92ad8251fea6958b6f5c2bb61e03789
+size 429846144

data/inject_relative_easy/train-00001-of-00009.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:e256992f8f62712be50c9e97e2f3f2d7e7c12aef130e14b491bbab5e60ef20db
+size 400990294

data/inject_relative_easy/train-00002-of-00009.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:7d444b65fd39ed74db97ff88bf8fd431872fc9a5107b9c79cfab7881e1d54dd5
+size 428929621

data/inject_relative_easy/train-00003-of-00009.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:fd27d53a4d5e0ccc1c458ad1bc9fb3a055ad84c002d8b90360aedac9a1e54037
+size 435563742

data/inject_relative_easy/train-00004-of-00009.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:0bcbaeb38e862fb55ed01ecee9a47dc5f2370e9716557f4d8cdb28f4fb9f4b80
+size 414168429

data/inject_relative_easy/train-00005-of-00009.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:92a3209fa4ab8ae7d4c106d6e9da83e48e4194bafc0f738b152921fd2c0fe441
+size 439856115

data/inject_relative_easy/train-00006-of-00009.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:5d72ea6b049c4fcdeeadf4a565295d7866459a4d5b01ebf5c85b3a543270c2b6
+size 476720750

data/inject_relative_easy/train-00007-of-00009.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:1b586727d52c1a6465e5620d83ad15b7fdda1cdb0f3b94040919749008b3b53b
+size 481042337

data/inject_relative_easy/train-00008-of-00009.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:536c953c9dd17f371f3b1583481b77489fef90ac52d1775e4d86ad56a0f82f27
+size 158366486

data/removal_az10/train-00000-of-00009.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:74dce64a4f8b7f6a58040fd7e105647ad9f6409537d69072397ce8f26851b902
+size 311177966

data/removal_az10/train-00001-of-00009.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:55afa18699a0c392082c0bb91e21bdb7196f9661f01e6bdd3eedf3fd8fa38c02
+size 356694600

data/removal_az10/train-00002-of-00009.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:ac735fb18935221139697f740fb187ade42a4363c732cfbca70ffe82199034b2
+size 321553684

data/removal_az10/train-00003-of-00009.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:ea557757579309828c72dbc239db7dac8aa6870c4209677cfa516ef1aaee691a
+size 274077745

data/removal_az10/train-00005-of-00009.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:88e7aca5ed6a948d446298aaa2d166d9b00c6aecf6960f5fad4142f3480877f5
+size 313866493

data/removal_az10/train-00008-of-00009.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:842c83ffc42968d572bfca17d9a13ee4edac15db8650b5400cf1a80f822f1938
+size 81828053

data/removal_az20/train-00000-of-00009.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:ab41d8f3370f732815e0ef75004036180927d89f953e1fd7787f3b7da5465302
+size 308699039

data/removal_az20/train-00001-of-00009.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:ecf8020eb161f0dc72d5406b8fa5010810c0190dcedaba5c702f4d91dad79712
+size 354555619

data/removal_az20/train-00002-of-00009.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:9d4ba7abae410275b4b064a3ce23b7622d7a830f8e817db528434dcf3d6342eb
+size 318326908

data/removal_az20/train-00003-of-00009.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:368633e34a14438d0d001a171e7c6398864f18ad73d9b554fa266998212e5622
+size 271915443

data/removal_az20/train-00004-of-00009.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:9e4f2d6ad53b4e9d49d5005d2b0dcefc424380100f058513a997951561ddff44
+size 346753401

data/removal_az20/train-00005-of-00009.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:a085671151a7531f6f23a839c81a269071890b9c5034f67e1d4a22cde8b8957e
+size 311203419

data/removal_az20/train-00006-of-00009.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:8eb750c2d19bd250f6443b4db5f4a8618d6c1d8a4d299e575b7caab3da2790bf
+size 239124154

data/removal_az20/train-00007-of-00009.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:5a00ef41be0d6cae00a5c13c963314d8a3a83da62346822904aaed2fe856a6c7
+size 332821415

data/removal_az20/train-00008-of-00009.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:07e767061f0b198e3b0d42b3b1c75fd1b0f6c495f9afd3469e200370d59b4d83
+size 81432205

data/removal_az30/train-00000-of-00009.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:f6da399821e8c65105d51be2bfe6c81bffb2c7b9df311cffb4630dc1cbc12d67
+size 305963970

data/removal_az30/train-00001-of-00009.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:463ac4764faf310f9f94c1d9a6c2a4e2290d05560e6a9630daa4e4cae86e577a
+size 352588221

data/removal_az30/train-00002-of-00009.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:214c0b4cc40091533105ede7ad08e3ea37e2b029a69ed3cd69992b1056e0489a
+size 315022341

data/removal_az30/train-00003-of-00009.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:1c220ec35f1971fb81ba4c9d0265e605faca5b84cd8c833655d2722920a895be
+size 269890725

data/removal_az30/train-00004-of-00009.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:5b405b8883ac5d6e9518061721d98b91de0c39859ed69777f3cad095c7dc8fdc
+size 344654193

data/removal_az30/train-00005-of-00009.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:8166d9de85afd59414a7932c1698837ebc7a45b11be5d79c72a9fee4abc031a5
+size 308435769

data/removal_az30/train-00006-of-00009.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:6dc5d049cd457429c7f7ce6876071152e2fb58fe9cba04078f31ec98449ba045
+size 237518458

data/removal_az30/train-00007-of-00009.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:3c017d18829f0003a5f6fbe491748a61892061ff2c5aad2c5cd723f334904b74
+size 329991012

data/removal_az30/train-00008-of-00009.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:6cabffc2903b325cf99b2cf04e2ac46c90e15308e71870371462f85428ad4a50
+size 80968684

data/removal_az40/train-00008-of-00009.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:6f6d88e8049ed368e6b661c372af418c12464b0e7a462c361a8d232e7d722caa
+size 80503337

data/removal_az50/train-00000-of-00009.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:293cde14383661eb6f6379234f20c742a37428d07dfe134d031613e33af716a4
+size 301729008

data/removal_az50/train-00001-of-00009.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:ad25220f516ba59efbdfa4c0fa7cd7c669488a2fea8674b5e98928b67005e5a0
+size 349150193

data/removal_az50/train-00002-of-00009.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:8068aaf882d1e1f3a964155086ce803f676d75ffe8415ac4fab615d760f7c424
+size 310055095

data/removal_az50/train-00003-of-00009.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:102280b4ad906977bc3352e8224a555bc8a8f1b08ccb91e3a59c3455a2bcf2b2
+size 266591079

data/removal_az50/train-00004-of-00009.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:73086c981948890fbf5ca663ee2804428b87a42a0ef8846d7481a78399331ed9
+size 341199099

data/removal_az50/train-00005-of-00009.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:b363a1d0ab98cb43f58917b9ea66513e024f3ad717e97cb282dd119bed6c2ae6
+size 304236273

data/removal_az50/train-00006-of-00009.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:45a41116272eae17eec0ef16500c20140066f434e82e15ce299ca79737b128ce
+size 234891249

data/removal_az50/train-00007-of-00009.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:43bccd19e3df98afb85c3a87d51c29eff81e244bdd4d6a7d80ab432865551a57
+size 325361158

data/removal_az50/train-00008-of-00009.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:7e9aa16520b1e3e4bd1edb24a931d7026046083fed085b522dc3608fe8625f3a
+size 80200462

load_atlas_nuscenes.py

@@ -0,0 +1,204 @@
+#!/usr/bin/env python
+"""Loader + sequence reconstruction for ATLAS-nuScenes.
+
+Only the ATTACKED frames are shipped. A nuScenes scene is ~40 frames but the
+attack covers the last 8, so the other ~80% of every split is a bit-identical copy
+of source nuScenes -- shipping it would cost ~242 GB across 12 splits instead of
+~40 GB, of which ~200 GB would be twelve duplicate copies of the same clean clouds.
+
+Nothing is lost: attack success rate is defined only on attacked frames, and the
+omitted frames are unmodified, so a full sequence is recovered by substituting our
+frames into your own nuScenes copy. Each row carries four keys back to the source:
+
+    segment       scene name, e.g. "scene-0003"
+    frame_index   position within the scene (0-based)
+    sample_token  nuScenes sample token -- the canonical global key
+    frame_id      source LIDAR_TOP filename
+
+Prefer `sample_token`: it is nuScenes' own primary key and does not depend on our
+scene ordering or naming conventions.
+
+    from load_atlas_nuscenes import load_atlas, points_of, attacked_index
+
+    ds  = load_atlas("removal_az20")
+    idx = attacked_index(ds)              # {segment: {frame_index: row}}
+    pts = points_of(ds[0])                # (N, 6) x,y,z,intensity,time,lag
+"""
+import numpy as np
+
+REPO = "ps3020/atlas-nuscenes"
+
+INJECT_CONFIGS = [f"inject_{m}_{d}" for m in ("global", "relative")
+                  for d in ("easy", "medium", "hard")]
+REMOVAL_CONFIGS = [f"removal_az{a}" for a in (10, 20, 30, 40, 50, 60)]
+CONFIGS = INJECT_CONFIGS + REMOVAL_CONFIGS
+
+
+def load_atlas(config, split="train", repo=REPO, **kw):
+    """load_dataset wrapper. Pass streaming=True to avoid materialising the split."""
+    from datasets import load_dataset
+    if config not in CONFIGS:
+        raise ValueError(f"unknown config {config!r}; expected one of {CONFIGS}")
+    return load_dataset(repo, config, split=split, **kw)
+
+
+def points_of(example):
+    """Attacked cloud as (N, 6): x, y, z, intensity, time, lag.
+
+    nuScenes clouds here are 10-sweep accumulated, so N is ~265k.
+    """
+    return np.asarray(example["points"], dtype=np.float32).reshape(
+        example["num_points"], example["point_dim"])
+
+
+def spoof_gt_of(example):
+    """The attacked object.
+
+    Injection -> (7,)  phantom box [x, y, z, dx, dy, dz, heading].
+    Removal   -> (10,) the real GT box we tried to erase: the same 7 plus
+                       (vx, vy, class_label).
+    `spoof_gt_dim` records which.
+    """
+    return np.asarray(example["spoof_gt"], dtype=np.float32)
+
+
+def gt_boxes_of(example):
+    """Clean nuScenes GT for this frame as (M, 10).
+
+    Columns are [x, y, z, dx, dy, dz, heading, vx, vy, class_label], where the
+    class label is 1-indexed (car = 1).
+    """
+    n, dim = example["num_gt"], example["gt_box_dim"]
+    return np.asarray(example["gt_boxes"], dtype=np.float32).reshape(n, dim)
+
+
+def pose_of(example):
+    """4x4 ref(lidar) -> global transform for this frame."""
+    return np.asarray(example["pose"], dtype=np.float64).reshape(4, 4)
+
+
+def attacked_index(dataset):
+    """{segment: {frame_index: row}} -- which frames of which scenes are attacked.
+
+    Use this to drive reconstruction without loading point data twice.
+    """
+    out = {}
+    for r in dataset:
+        out.setdefault(r["segment"], {})[r["frame_index"]] = r
+    return out
+
+
+def attacked_tokens(dataset):
+    """{sample_token: row}. The robust join key against your nuScenes copy."""
+    return {r["sample_token"]: r for r in dataset}
+
+
+def reconstruct_segment(dataset_or_index, segment, clean_loader,
+                        num_frames=None):
+    """Rebuild a full scene, substituting attacked frames for clean ones.
+
+    `clean_loader(frame_index) -> (N, C) array` must return YOUR unmodified
+    nuScenes cloud for that position in the scene. Frames we did not attack are
+    bit-identical to source, so substitution is lossless.
+
+    Returns a list of (points, is_attacked, row_or_None), ordered by frame_index.
+    """
+    idx = (dataset_or_index if isinstance(dataset_or_index, dict)
+           else attacked_index(dataset_or_index))
+    frames = idx.get(segment, {})
+    if not frames:
+        raise KeyError(f"no attacked frames for segment {segment!r}")
+    if num_frames is None:
+        num_frames = next(iter(frames.values()))["num_frames_in_segment"]
+
+    out = []
+    for i in range(num_frames):
+        if i in frames:
+            out.append((points_of(frames[i]), True, frames[i]))
+        else:
+            out.append((clean_loader(i), False, None))
+    return out
+
+
+def clean_cloud(nusc, nuscenes_root, sample_token, n_sweeps=10):
+    """A CLEAN 10-sweep nuScenes cloud as (N, 5) = x, y, z, intensity, time.
+
+    APPROXIMATE, and deliberately so. This reproduces the sweep accumulation but
+    NOT the detector pipeline's subsequent point-cloud range filter, so it returns
+    roughly 1.3x more points than the clean frames the attacked ones were built
+    from (measured: ~347k here vs ~265k in-split). Use it to inspect or visualise
+    a sequence, NOT to construct a numerically matched clean baseline.
+
+    For a matched baseline, load the frame through the same detector config used
+    for evaluation (e.g. OpenPCDet `NuScenesDataset` with the standard 10-sweep
+    nuScenes config), which applies the range filter. That path is what produced
+    the clouds shipped here.
+
+    A single raw `.pcd.bin` is ~35k points with `ring` as the 5th column -- not
+    comparable to the accumulated clouds at all.
+
+    `nusc` is a nuscenes.nuscenes.NuScenes instance.
+    """
+    import os
+    sample = nusc.get("sample", sample_token)
+    sd_token = sample["data"]["LIDAR_TOP"]
+    ref_sd = nusc.get("sample_data", sd_token)
+    ref_time = 1e-6 * ref_sd["timestamp"]
+
+    clouds = []
+    tok = sd_token
+    for _ in range(n_sweeps):
+        if not tok:
+            break
+        sd = nusc.get("sample_data", tok)
+        path = os.path.join(nuscenes_root, sd["filename"])
+        if not os.path.exists(path):
+            break
+        pts = np.fromfile(path, dtype=np.float32).reshape(-1, 5)[:, :4]
+        dt = ref_time - 1e-6 * sd["timestamp"]
+        clouds.append(np.hstack([pts, np.full((len(pts), 1), dt, np.float32)]))
+        tok = sd["prev"]
+    return np.concatenate(clouds) if clouds else np.zeros((0, 5), np.float32)
+
+
+def attack_type(config):
+    return "inject" if config.startswith("inject") else "removal"
+
+
+def score_frame(config, detected_overlapping_spoof_gt):
+    """Whether the attack SUCCEEDED on this frame.
+
+    injection: success = a detection overlaps the phantom (false positive created).
+    removal  : success = NO detection overlaps the erased object (true positive
+               destroyed).
+    ATLAS reports ASR at IoU 0.3.
+    """
+    hit = bool(detected_overlapping_spoof_gt)
+    return hit if attack_type(config) == "inject" else (not hit)
+
+
+def asr(successes, dataset_or_len):
+    """Attack success rate over ATTACKED frames.
+
+    The denominator is the number of rows in this config -- every row is an
+    attacked frame. Do NOT use 6019 (the full val split): only attacked frames
+    are shipped, and only they are scored.
+    """
+    n = dataset_or_len if isinstance(dataset_or_len, int) else len(dataset_or_len)
+    return (successes / n) if n else float("nan")
+
+
+def removal_rate(example):
+    """Realised fraction of in-wedge points deleted (removal configs only)."""
+    n_in = example.get("atk_n_points_in_sector") or 0
+    return (example["atk_n_points_removed"] / n_in) if n_in else float("nan")
+
+
+if __name__ == "__main__":
+    ds = load_atlas("removal_az20", streaming=True)
+    r = next(iter(ds))
+    print(f"{r['segment']} frame {r['frame_index']}/{r['num_frames_in_segment']} "
+          f"token={r['sample_token'][:12]}...")
+    print(f"  points {points_of(r).shape}  spoof_gt {spoof_gt_of(r).shape}  "
+          f"gt {gt_boxes_of(r).shape}")
+    print(f"  realised removal rate {removal_rate(r):.3f}")