Upload README.md with huggingface_hub

README.md

@@ -0,0 +1,294 @@
+---
+license: cc-by-nc-4.0
+pretty_name: StarCraftMotion
+language:
+- en
+size_categories:
+- 100K<n<1M
+task_categories:
+- time-series-forecasting
+- other
+tags:
+- starcraft
+- multi-agent
+- agent-simulation
+- partial-observability
+- benchmark
+configs:
+- config_name: default
+  data_files:
+  - split: train
+    path: train/*.parquet
+  - split: validation
+    path: validation/*.parquet
+  - split: test
+    path: test/*.parquet
+---
+
+# StarCraftMotion
+
+StarCraftMotion is a large-scale benchmark for agent simulation
+under adversarial and partial observability scenarios (built from StarCraft replays). Each example is a fixed-length scenario window (`145` frames at `16 FPS`, ~9 seconds) containing all unit 
+states, dynamic map layers, and per-player economy time series.
+
+The released split is **adversarial**: scenarios are subsampled to
+overweight interaction-heavy windows (mutual-visibility and inter-player
+transitions), making it a stress test for multi-agent prediction under
+partial observability.
+
+- **Total scenarios:** 469,187
+- **Train / Val / Test:** 362,075 / 45,121 / 61,991
+- **Source replays:** 64,327 replay-level HDF5 files (Blizzard `3.16.1-Pack_1-fix`)
+- **Maps (ID):** Abyssal_Reef_LE, Acolyte_LE, Ascension_to_Aiur_LE, Interloper_LE, Mech_Depot_LE
+- **Maps (OOD, test only):** Catallena_LE_(Void), Odyssey_LE
+- **Splits are replay-level** — windows from the same replay never cross splits.
+
+## Why parquet, and how to read
+
+Each row is one scenario. All per-frame / per-unit array columns are
+stored as **typed Arrow `large_list` arrays** (e.g. `LIST<float16>`,
+`LIST<bool>`). `n_timesteps = 145` and `n_units` varies per scenario (stored per row).
+The dynamic map layers (`map_creep`, `map_fow_p1`, `map_fow_p2`) are
+sampled every 16 frames, giving `map_T = 10` snapshots per scenario.
+Spatial dimensions `map_H` and `map_W` are stored as explicit scalar
+columns per row (map-dependent; e.g. Abyssal_Reef_LE is 176 × 200).
+
+```python
+import numpy as np
+from datasets import load_dataset
+
+ds = load_dataset("blind-review-data/StarCraftMotion", split="train", streaming=True)
+row = next(iter(ds))
+
+T, N = row["n_timesteps"], row["n_units"]
+map_T, map_H, map_W = row["map_T"], row["map_H"], row["map_W"]
+
+coord = np.asarray(row["coordinate"], dtype=np.float16).reshape(T, N, 3)
+alive = np.asarray(row["is_alive"],   dtype=bool    ).reshape(T, N)
+owner = np.asarray(row["unit_owner"], dtype=np.uint8 ).reshape(N)
+utype = np.asarray(row["unit_type"],  dtype=np.uint32).reshape(T, N)
+creep = np.asarray(row["map_creep"],  dtype=bool    ).reshape(map_T, map_H, map_W)
+```
+
+### Schema
+
+#### Scalar fields
+
+| Field         | Type   | Description                                                  |
+|---------------|--------|--------------------------------------------------------------|
+| `split`       | string | `train`, `val`, or `test`                                    |
+| `map_name`    | string | Map name (spaces replaced with `_`)                          |
+| `replay_hash` | string | Hash of the parent SC2Replay file                            |
+| `segment_idx` | int32  | Index of this 145-frame window inside the parent replay      |
+| `n_timesteps` | int32  | Number of frames per row (constant `145` in this release)    |
+| `n_units`     | int32  | Number of unique unit rows in this scenario (variable)       |
+| `map_T`       | int32  | Number of map snapshots per row (constant `10` in this release) |
+| `map_H`       | int32  | Map grid height in cells (map-dependent)                     |
+| `map_W`       | int32  | Map grid width in cells (map-dependent)                      |
+
+#### Map data — shape `(map_T, map_H, map_W)` where `map_T = 10`
+
+`map_H` and `map_W` are map-specific (each StarCraft II ladder map has
+its own native grid). All three layers below share the same shape per
+scenario.
+
+| Field         | dtype |
+|---------------|-------|
+| `map_creep`   | bool  |
+| `map_fow_p1`  | bool  |
+| `map_fow_p2`  | bool  |
+
+#### Player economy — shape `(145, 2)`, column 0 = Player 1, column 1 = Player 2
+
+| Field       | dtype  |
+|-------------|--------|
+| `food_cap`  | uint8  |
+| `food_used` | uint8  |
+| `minerals`  | uint16 |
+| `vespene`   | uint16 |
+
+#### Per-unit constants — shape `(n_units,)`
+
+| Field        | dtype  | Description                                  |
+|--------------|--------|----------------------------------------------|
+| `unit_owner` | uint8  | 1 = P1, 2 = P2, 16 = neutral                 |
+| `unit_tag`   | uint64 | Raw SC2 engine tag (unique per unit instance)|
+
+#### Per-frame, per-unit — shape `(145, n_units)` unless noted
+
+| Field             | dtype   | Shape                | Description                                     |
+|-------------------|---------|----------------------|-------------------------------------------------|
+| `coordinate`      | float16 | (145, n_units, 3)    | Native (x, y, z) map coordinates                |
+| `target_pos`      | float16 | (145, n_units, 2)    | Order target ground position                    |
+| `health`          | float16 |                      |                                                 |
+| `health_max`      | float16 |                      |                                                 |
+| `shield`          | float16 |                      | Protoss shield                                  |
+| `energy`          | float16 |                      |                                                 |
+| `heading`         | float16 |                      | Facing direction in radians (0 to 2π)           |
+| `radius`          | float16 |                      | Unit collision radius                           |
+| `build_progress`  | float16 |                      | 0.0–1.0                                         |
+| `unit_type`       | uint32  |                      | Raw SC2 unit type ID                            |
+| `ability_id`      | uint32  |                      | First order's ability ID                        |
+| `target_id`       | uint32  |                      | Target's row index (`0xFFFFFFFF` = no target)   |
+| `mineral_contents`| uint16  |                      | Remaining minerals (mineral fields)             |
+| `vespene_contents`| uint16  |                      | Remaining vespene (geysers)                     |
+| `is_alive`        | bool    |                      |                                                 |
+| `is_burrowed`     | bool    |                      | Zerg burrowed                                   |
+| `is_carried`      | bool    |                      | Inside a transport                              |
+| `is_flying`       | bool    |                      | Air unit / lifted building                      |
+| `visible_status`  | uint8   |                      | Combined P1/P2 visibility (see below)           |
+
+`visible_status = p1_state * 3 + p2_state`, with each state in
+`{0 = unseen, 1 = snapshot, 2 = visible}`. Examples: `8` = visible to both,
+`6` = visible to P1 only, `2` = visible to P2 only.
+
+### Action labels
+
+The `ability_id` column stores the **raw SC2 ability ID as `uint32`**
+(e.g. `MOVE = 16`, `ATTACK_ATTACK = 23`, `HARVEST_GATHER_DRONE = 1183`,
+`ability_id == 0` means the unit has no active order). It is **not**
+class-indexed.
+
+For action prediction tasks we provide an 11-class coarse mapping in the
+source repository at
+[`sc2sensor/utils/coarse_action_mapping.py`].
+
+| Label | Name      | Description                                                |
+|------:|-----------|------------------------------------------------------------|
+|   0   | NO_OP     | `ability_id == 0`; unit idle                               |
+|   1   | MOVE      | move, patrol, hold position, stop, smart (right-click)     |
+|   2   | ATTACK    | attack, attack-move, attack building                       |
+|   3   | HARVEST   | gather resources, return cargo                             |
+|   4   | TRAIN     | produce units from buildings / larvae / warp-in            |
+|   5   | BUILD     | construct structures, add-ons, creep tumors                |
+|   6   | RESEARCH  | upgrades and tech research                                 |
+|   7   | MORPH     | unit/structure transformation (siege, archon, lair, etc.)  |
+|   8   | EFFECT    | combat abilities, spells, auto-cast effects                |
+|   9   | TRANSPORT | load, unload, lift off, land                               |
+|  10   | BURROW    | burrow down / burrow up (Zerg)                             |
+|  255  | UNKNOWN   | unmapped or cosmetic                                       |
+
+Sources for the mapping:
+- Blizzard `s2client-api` `ABILITY_ID` enum:
+  https://blizzard.github.io/s2client-api/sc2__typeenums_8h.html
+- Blizzard `s2client-proto` `stableid.json`:
+  https://github.com/Blizzard/s2client-proto/blob/master/stableid.json
+
+Coverage on the released split is 100% of all action occurrences
+(every `ability_id` either matches a Blizzard enum prefix, is one of 10
+explicit `stableid.json` overrides, or is `0` / falls into `UNKNOWN`).
+
+#### Applying the mapping
+
+```python
+import numpy as np
+from sc2sensor.utils.coarse_action_mapping import ABILITY_ID_TO_COARSE_ACTION
+
+T, N = row["n_timesteps"], row["n_units"]
+ability_id = np.frombuffer(row["ability_id"], dtype=np.uint32).reshape(T, N)
+
+# Vectorized lookup via a dense uint8 table.
+max_id = max(ABILITY_ID_TO_COARSE_ACTION) + 1
+lut = np.full(max_id, 255, dtype=np.uint8)
+for aid, label in ABILITY_ID_TO_COARSE_ACTION.items():
+    lut[aid] = label
+
+coarse = np.where(ability_id < max_id, lut[np.clip(ability_id, 0, max_id - 1)], 255)
+```
+
+## Pipeline summary
+
+1. **Replay extraction** (`extract_replay_level.py`): three SC2 engine passes
+   (omniscient + per-player FOW) into one HDF5 per replay, preserving native
+   coordinates, raw SC2 unit/ability IDs, and per-player visibility.
+2. **Scenario windowing** (`split_scenarios.py`): chunk into `145`-frame
+   windows at `16 FPS` (1 s history + current + 8 s future).
+   Drops replays with `duration < 120 s` or either player at `APM < 1`.
+3. **Replay-level split** (`create_dataset_split.py`): 80/10/10 train/val/test
+   over ID maps; OOD maps go to test only. Keeps `10%` of each replay's
+   windows.
+4. **Adversarial weighting**: window sampling weight is
+   `log(1 + mutual_unit_sum) + log(1 + transition_cnt)`; zero-score windows
+   are excluded.
+
+## Dataset statistics
+
+### Player-unit counts (units with `owner != 16`)
+
+| Split | Mean   | Std    | Min | P25 | Median | P75 | Max |
+|-------|-------:|-------:|----:|----:|-------:|----:|----:|
+| Train | 204.56 | 113.06 |  11 | 109 |    189 | 284 | 921 |
+| Val   | 203.56 | 112.51 |  18 | 109 |    188 | 282 | 689 |
+| Test  | 202.78 | 111.70 |  13 | 107 |    189 | 281 | 779 |
+
+### Race matchups
+
+| Split | PvP    | PvT    | PvZ    | TvT    | TvZ     | ZvZ    |
+|-------|-------:|-------:|-------:|-------:|--------:|-------:|
+| Train | 23,322 | 82,819 | 66,139 | 54,819 | 104,780 | 30,196 |
+| Val   |  3,037 |  9,978 |  8,514 |  6,853 |  13,326 |  3,413 |
+| Test  |  4,112 | 13,927 | 10,883 |  9,536 |  18,531 |  5,002 |
+
+### Mutual visibility (units with `visible_status == 8` and `is_alive`)
+
+| Split | Mean mutually-visible units / frame |
+|-------|------------------------------------:|
+| Train |                               23.56 |
+| Val   |                               23.40 |
+| Test  |                               23.43 |
+
+## Intended use
+
+- Multi-agent simulation under adversarial partial observability.
+- Benchmarks for fog-of-war handling, ID vs OOD-map
+  generalization, and interaction-heavy scenes.
+
+## Limitations and ethical considerations
+
+- **Replay provenance:** raw replays come from Blizzard's
+  `3.16.1-Pack_1-fix` distribution. Per-replay curation, demographics of
+  players, and any prior filtering performed by Blizzard are not documented.
+- **MMR caveat:** raw MMR values include sentinel-like negatives (down to
+  `-36400`) for some replays. League-tier bucketing should be recomputed
+  rather than relied upon naively.
+- **Single game version:** all replays are SC2 build 3.16.1; balance and
+  meta-game differ from current ladder versions.
+- **No personally identifying content** is included beyond what Blizzard
+  publishes in replay packs. Player names are not surfaced as columns.
+- **Game-balance / strategic bias:** the corpus is whatever Blizzard
+  released in the pack and is not a uniform sample of competitive play.
+
+## License
+
+The released parquet artifacts are licensed under
+[**Creative Commons Attribution-NonCommercial 4.0 International (CC-BY-NC-4.0)**](https://spdx.org/licenses/CC-BY-NC-4.0.html)
+(SPDX: `CC-BY-NC-4.0`).
+
+The released parquet files are **derivative ML features** (float16 unit
+trajectories, fog-of-war and creep masks, per-player economy time series,
+and raw SC2 unit/ability identifiers) extracted from StarCraft II
+replays. The dataset does **not** redistribute raw `.SC2Replay` files,
+SC2 game maps, or any portion of the StarCraft II Software. Use of the
+underlying StarCraft II replays and the SC2 engine is separately
+governed by Blizzard's
+[AI and Machine Learning License](https://blzdistsc2-a.akamaihd.net/AI_AND_MACHINE_LEARNING_LICENSE.html);
+that license explicitly permits use of derived ML data for personal or
+internal research and development.
+
+
+## Citation
+
+Underlying replays:
+
+```bibtex
+@misc{blizzard_sc2_replaypacks,
+  title  = {StarCraft II Replay Packs (3.16.1-Pack\_1-fix)},
+  author = {{Blizzard Entertainment}},
+  howpublished = {\url{https://blzdistsc2-a.akamaihd.net/ReplayPacks/3.16.1-Pack_1-fix.zip}}
+}
+```
+
+## Acknowledgments
+
+Built on top of DeepMind's `pysc2` and Blizzard's StarCraft II AI/ML
+infrastructure.