This is one of a pair of datasets built in a single pass from the same raw source. SNGAR-Action-Spotting-Tracking ships tracking tables, SNGAR-Action-Spotting-Video ships the broadcast video, and both carry byte-identical ground truth - the same games, the same splits, the same event lists in the same order. A tracking-vs-video comparison run on this pair measures the modality and nothing else. The companion repo is the tracking one.

Layout

annotations_train.json      45 games
annotations_valid.json       9 games
annotations_test.json       10 games
train/videos/<game_id>.mp4
valid/videos/<game_id>.mp4
test/videos/<game_id>.mp4
README.md
MANIFEST.sha256             sha256 of every shipped file

Payload: 28.2 GB across 64 games.

Splits

split	games	game ids	events
`train`	45	3812-3840, 10502-10517	62,159
`valid`	9	3841-3849	12,091
`test`	10	3850-3859	13,689

Splits are assigned by string-sorted game id, so the 105xx games sort before the 38xx ones. This is not random and not stratified - it is the original SN-GAR contract, preserved so results stay comparable with prior work.

Labels

label	train	valid	test	total
PASS	40,745	7,762	9,009	57,516
PLAYER SUCCESSFUL TACKLE	7,716	1,537	1,690	10,943
OUT	4,184	810	884	5,878
HEADER	3,986	870	867	5,723
THROW IN	1,834	372	392	2,598
CROSS	1,514	314	347	2,175
FREE KICK	1,261	255	272	1,788
SHOT	720	135	186	1,041
GOAL	135	23	30	188
HIGH PASS	64	13	12	89
all	62,159	12,091	13,689	87,939

One label per instant

The task is single-label: each position_ms in a game carries exactly one event. The source stream does not come that way - a throw-in is also a high pass, a headed shot is both a header and a shot - so where several labels land on the same millisecond, LABEL_PRIORITY selects the intended one.

Worth knowing when reading per-class results, because it is lossy across labels rather than uniformly. Least-preserved: HIGH PASS keeps 89 of 2,697 (3%); SHOT keeps 1,041 of 1,559 (67%). Those classes are sparse by construction rather than by data quality, so a model scoring badly on them is not necessarily doing badly.

Source

64 games: the 2022 FIFA World Cup (3812-3859) plus 16 further matches (10502-10517). Two raw inputs per game:

input	content
`RawEventsData/<game>.json`	hand-annotated event stream, ~2,000 events per game, each with `gameEvents` / `possessionEvents` / `initialTouch` sub-objects
`PlayerPoseTracking/<game>.jsonl.bz2`	bz2 line-delimited JSON, one line per tracked frame at ~29.97 Hz, ~186k lines per game (11.9M total)

How it was built

1. Tracking to table. Each .jsonl.bz2 is decoded line by line and flattened. The non-obvious part is player roles: the source exposes position_group_type only inside game_event, which appears on roughly 1% of frames. The builder therefore makes a first full pass to construct a team_id -> jersey -> position map plus the game-static home/away team ids, then a second pass stamping position and positionGroup onto every player on every frame. This tags 99.98% of player-frames; the original converter resolved team ids per frame and so tagged only the sparse event frames.

Rows are then sorted by (videoTimeMs, frameNum) and deduplicated on videoTimeMs keeping the first, which removes 42,950 rows corpus-wide and leaves a strictly monotone clock.

2. Events to labels. Each source event maps to zero or more of the 10 SN-GAR labels:

possessionEventType == "PA"  (pass)       bodyType == "HE"          -> HEADER
                                          ballHeightType == "A"     -> HIGH PASS
                                          passType == "H"           -> THROW IN
                                          otherwise                 -> PASS
                    == "CR"  (cross)                                -> CROSS
                    == "SH"  (shot)       bodyType == "HE"          -> HEADER   |
                                          always                    -> SHOT     | all that
                                          shotOutcomeType == "G"    -> GOAL     | apply
                    == "CH"  (challenge)  challengeWinnerPlayerId   -> PLAYER SUCCESSFUL TACKLE
                    == "CL"  (clearance)  bodyType == "HE"          -> HEADER

gameEventType       == "OUT"                                        -> OUT
setpieceType        == "T"                                          -> THROW IN
                    == "F"                                          -> FREE KICK

Every rule that matches fires, so one event can emit several labels, each becoming its own annotation at the same position_ms. A headed goal produces three: HEADER, SHOT and GOAL. position_ms is int(eventTime * 1000), and eventTime is on the same video clock as videoTimeMs - which is what makes step 3 possible.

3. Alignment. For each event, find the tracking row with the nearest videoTimeMs. If it is further than tolerance_ms (10.0 ms) away, drop the event: there is no tracking against which to localise it.

Note. At 10.0 ms this window is narrower than half a native frame period (16.69 ms). Because the tracking clock ticks every ~33.4 ms, an event timestamped at an arbitrary millisecond can be up to 16.69 ms from the nearest row and still be perfectly aligned. This build therefore also drops 441 such events, chosen deliberately to reproduce the historical event count. A tolerance of 34.0 ms (one full frame period) keeps them.

 94,285   extracted
 -4,963   removed by priority dedup
 -1,383   dropped as unalignable
=======
 87,939   final

Most dropped events are post-match, where the source keeps annotating tracking has stopped; at this tolerance the rest are the mid-frame events described above.

4. Write. Both modalities' annotation files are written from the same in-memory event lists - identical ground truth by construction rather than by a follow-up sync - followed by the sha256 manifest and this card.

Annotation format

OpenSportsLib v2, one file per split:

{
  "version": "2.0",
  "task": "action_spotting",
  "dataset_name": "action_spotting_video_valid",
  "metadata": {"modality": "video", "aligned": true,
               "tolerance_ms": 10.0,
               "deduplicated_events": true,
               "events_identical_across_modalities": true},
  "labels": {"action": {"type": "single_label", "labels": ["PASS", "HEADER", ...]}},
  "data": [{
    "game_id": "3841",
    "split": "valid",
    "inputs": [{"type": "video_mp4", "path": "valid/videos/3841.mp4", "fps": 30.0}],
    "events": [{"head": "action", "label": "PASS", "position_ms": 190256,
                "gameTime": "1 - 00:00", "team": "home", "visibility": "visible"}]
  }]
}

position_ms is the only field you need to localise an event. gameTime is the period - MM:SS match clock, useful for display but not for indexing.

Payload format

`{split}/videos/<game_id>.mp4`

Whole-match broadcast video, 398x224 at 29.97 fps (30000/1001), H.264. Durations run 98.9-157.6 minutes (median 104.4); files are 359-685 MB (median 431).

The video and the tracking clock start at different points: videoTimeMs in the tracking modality is time on this video's timeline, so position_ms addresses both modalities identically. Note that annotations declare "fps": 30.0 while the true rate is 29.97 - the OpenSportsLib video loader reads the real rate from the container with OpenCV and ignores that field.

No tracking parquets are shipped here; the companion repo holds those.

Loading

import json, cv2

ann = json.load(open("annotations_test.json"))
game = ann["data"][0]
cap = cv2.VideoCapture(game["inputs"][0]["path"])
fps = cap.get(cv2.CAP_PROP_FPS)               # 29.97, not the declared 30.0

for event in game["events"][:5]:
    cap.set(cv2.CAP_PROP_POS_MSEC, event["position_ms"])
    ok, frame = cap.read()
    print(event["label"], event["position_ms"], ok, frame.shape)

Time, and how to index it

The mp4 timeline is continuous, so unlike the tracking modality a frame index here is linear in time - but two things still catch people out:

The video starts before kickoff. The first event in a game sits 40-211 seconds in, and the video runs through half-time and stoppages with no annotations. Long unlabelled stretches are expected, not missing data.

The rate is 29.97 fps, not 30. Over a 100-minute match, indexing with 30.0 drifts by roughly 6 seconds by the final whistle - far beyond the 1-second tight-mAP tolerance. Seek by milliseconds (CAP_PROP_POS_MSEC) or read the real rate from the container; do not multiply position_ms by a hardcoded 30.

The companion tracking modality carries the same events on the same clock, but its rows are not evenly spaced - see that repo's card before comparing the two frame-by-frame.

Other known properties

Real characteristics of the source, not defects to be cleaned:

Events do not cover the whole video. Between the pre-kickoff head, the post-match tail and stretches over a minute with no events, an unannotated 6.1-67.4 minutes per game (median 15.0) is expected, not missing data. The long tail of that range is tracking outages, since events with no tracking coverage were dropped from both modalities alike.
Three games have extra time (10506, 10508, 10517).
Broadcast footage, so it carries replays, cutaways and graphics. The tracking modality has none of these - a point in its favour when comparing the two.

Build contract

setting	value	why
label resolution	one label per instant, resolved by priority	see above
`tolerance_ms`	`10.0`	tighter than half a native frame period (16.69 ms), so it also rejects events that sit correctly on the clock between two rows
`dedupe_video_time_ms`	`True`	the source emits repeated `videoTimeMs`; removing them makes the clock strictly monotone
`aligned`	`True`	tracking cannot localise events outside its coverage
splits	45 / 9 / 10	alphabetical by game id, the original contract

Integrity

MANIFEST.sha256 lists a sha256 for every shipped file:

sha256sum -c MANIFEST.sha256

Access

Access is gated. Approval covers internal research use; check with the dataset owners before redistributing.

Built by build_sngar_spotting.py on 2026-08-28.

Downloads last month: -

Total file size:

28.2 GB