tqk2811/AutoDLS-facts-fact1-raw

AutoDLS — fact1-raw

Tier-1 (raw) recordings of an RL agent playing Dream League Soccer 2026 on Android emulators, collected by the AutoDreamLeagueSoccer2026 project. This is the untouched observation/action log — no reward function has been applied to it, so the whole dataset can be re-labelled from scratch when the reward design changes.

Episodes with video	1,949
Episode dirs that are empty (aborted recording, 0-byte .jsonl)	31
Steps (one step = one frame @ 12 Hz)	5,995,726 (≈ 139 hours of play)
Size of video/	≈ 47 GB
Legacy JPEG archives at the repo root	5 × .7z, 25.19 GB (498 episodes, 1,234,477 JPEGs)
Recorded	2026-06 → 2026-08

Repository layout

video/ep_<id>/frames.mkv          x265 yuv444p crf14, 300×255, 12 fps  — one frame per step
video/ep_<id>/!ep_<id>.jsonl      one JSON object per step (action / reward / done / HUD)
video/ep_<id>/!meta_<id>.json     episode metadata (checkpoint, reward config, frame count)
video/DATA-NOTE-vi.md             the project's own note about this tier (Vietnamese)

fact1-raw-part01..05.7z           LEGACY: the same tier-1 data from before 2026-07-28, when frames
lists/part01..05.lst              were stored as individual q95 JPEGs. `lists/` maps episode → archive.

yolo/                             the YOLO detection datasets (ball / players / controller marker /
yolo/README-vi.md                 possession button) used to build the perception layer. Zip-store.

Episode id suffix: _<adb_port>_<n> = agent self-play recorded on the emulator listening on that adb port (n = n-th match of the recording cycle); _AutoGenius = demonstration matches played by the AutoGenius auto-play script (these are named _demo inside the legacy .7z archives).

Frames are an atlas, not the game screen

To keep 139 hours of play under 50 GB, each recorded frame is not the 1280×720 game screen. The recorder crops the three regions the perception layer actually reads and packs them into one 300×255 image:

Region	Source rect on the 1280×720 frame (x, y, w, h)	Position in the atlas (x, y)
minimap (ball + player detection)	(572, 475, 135, 197)	(0, 0)
possession / B-button indicator	(996, 564, 160, 156)	(135, 0)
HUD — score, team abbreviations, red cards	(128, 2, 300, 58)	(0, 197)

raw_atlas.unpack_to_frame() pastes those regions back at their original coordinates on a black 1280×720 canvas, so the project's perception code runs on the atlas unchanged, pixel-for-pixel.

⚠️ Two atlas layouts exist. Recordings before 2026-07-27 are 300×257 (minimap (570,475,137,199)), after that 300×255. The image size is the only thing that distinguishes them, and reading one with the other's table misplaces every region silently — detection keeps running and just returns garbage. Always dispatch on the frame size (raw_atlas.regions_for).

!ep_<id>.jsonl — one line per step

{"step": 500, "ts": 1785311820.87,
 "action":     {"move": [0.633, 0.799], "button": 2},
 "action_raw": {"move": [0.633, 0.799], "button": 1},
 "reward": 0.0, "done": false,
 "info": {"state": "PLAYING"},
 "hud": {"us": 0, "them": 0, "hold": 0, "lost": 1, "red": 0},
 "valid": true}

• move — virtual joystick, each axis in [-1, 1], clamped to the unit circle. +y points up, i.e. toward the opponent's goal (the minimap never swaps ends; the agent's own goal is always at the bottom).
• button — one-hot over 0 = none, 1 = A (tackle / through-ball), 2 = B (shoot / pass).
• action is what was actually sent to the game; action_raw is what the policy asked for before the forced-action layer, and is null on frames where nothing was forced. The forcing rules changed over time and include: A is masked to no-op while the agent does not have the ball; a B press while the ball is lost is held for a randomised 9–12 frame burst; a no-op while the ball is lost is turned into a B press; and the joystick's y is mirrored up when the actor points at its own goal from far out. Train on action — it is what the game received and what the downstream reward is computed from; action_raw only tells you what the policy wanted.
• enf_free (present from 2026-08-06 onward) — bitmask of which forcing rules were deliberately released on that frame; 20 % of interventions are skipped at random so the data keeps some unforced counter-examples.
• reward in this tier is always 0 — reward is computed downstream (tier 2/3) from the recorded facts, which is what makes the reward function re-designable without re-recording.
• hud — score (us/them), possession (hold/lost) and red cards, as read live by the perception layer. It is a detector output, not ground truth.
• info.state — the navigation state machine's screen classification (PLAYING, FULL_TIME, UNKNOWN, …). Steps outside PLAYING are still recorded.
• first line of every episode has action: null and info.reset: true.

Frame i of frames.mkv is step i. There is no mapping table — the position in the stream is the only thing tying a frame to its jsonl line. Never drop or insert a single frame.

!meta_<id>.json

Contains the agent checkpoint that produced the episode, whether it was an eval or an exploration run, the adb device, the full reward config that was live at record time, wall-clock start/end, n_steps, and a frames block (format, n_fed, w, h, blank, incomplete). Episodes recorded before cycle 26 have no meta file.

⚠️ Do not trust n_steps/n_fed (or CAP_PROP_FRAME_COUNT) for the real frame count: a recorder crash truncates the mkv while the metadata still claims the full length, and seeking in a truncated file returns True while landing on a different frame. Count frames by decoding.

Reading an episode

import json, cv2
from pathlib import Path

ep = Path("video/ep_1785311768_5564_2")
steps = [json.loads(l) for l in (ep / f"!ep_{ep.name[3:]}.jsonl").read_text().splitlines()]

cap = cv2.VideoCapture(str(ep / "frames.mkv"))
i = 0
while True:
    ok, atlas = cap.read()      # (255, 300, 3) BGR — see the atlas table above
    if not ok:
        break
    step = steps[i]             # frame i <-> step i, positionally
    i += 1

The project's own readers — raw_video.open_episode() (handles both the mkv and the legacy JPEG layout, and cross-checks the frame count against the jsonl) and raw_atlas.unpack_to_frame() — live in python/dreamer_dls/.

Known caveats

• The dataset is not clean, by design. It is the raw output of a long-running training loop, so it contains stalled matches, ad screens, navigation dead-ends and episodes where the agent was under a forced-action regime. Filter with info.state and !meta_*.json rather than assuming uniformity.
• 31 episode directories hold only a 0-byte .jsonl (recording aborted before the first frame).
• hud fields come from a detector and do contain errors; the project keeps a separate parsed tier (tier 2) that is not published here.
• Episodes recorded before 2026-07-27 use the legacy 300×257 atlas (see above).
• Reward values inside !meta_*.json → reward_config changed many times across the collection window; they describe what the recording agent was optimising, not a label on the data.

Legacy .7z archives

fact1-raw-part01..05.7z are the pre-video form of the first 498 episodes: individual q95 JPEG atlas frames, 1,234,477 files, 32.39 GB → 25.19 GB with 7-Zip PPMd (-m0=PPMd -mx=9 -mo=32 -mmem=2g -ms=on). They are kept because they are the only remaining copy of the original JPEGs — those frames now exist elsewhere only as x265. Decompression needs ~2 GB RAM per archive and runs at ~1.8 MB/s, so expect it to be slow. lists/partNN.lst tells you which archive holds a given episode without downloading 25 GB.

Licence / provenance

The frames are cropped screen captures of Dream League Soccer 2026, a commercial game; all rights to the game imagery belong to First Touch Games. This dataset is published for research and educational use (offline RL, world models, imitation learning) and carries no licence over the underlying game content. The action/reward logs and the packaging are released by the repository owner for the same use.