Complete the information below to request access. The SoccerNet team will review your request and the information you provide. If your request is accepted, a personalized Non-Disclosure Agreement will be sent to the email address associated with your Hugging Face account.

By submitting this request, you confirm that the information supplied is accurate and that you have read and accept the SoccerNet Non-Disclosure Agreement available at https://drive.google.com/file/d/1Efz8yP-baa8CtcMB7SYIID7Bn5sH7sGTB4-u1YdVRf4/view.

SN-GAR Action Spotting — Multimodal Video + Tracking

64 whole-match 720p broadcast videos synchronized with player/ball tracking at ~29.97 Hz (11,849,815 tracked frames), with 87,939 action-spotting annotations across 10 labels.

Each game is represented as a single OpenSportsLib multimodal sample containing two synchronized modalities:

Video: whole-match 720p broadcast footage at 29.97 fps.
Tracking: whole-match player and ball tracking at ~29.97 Hz.

The two modalities are synchronized through absolute UTC timestamps. The UTC start time of each video was manually annotated with the OpenSportsLab VideoAnnotationTool, providing an absolute temporal anchor for every game. Events are stored with an authoritative timestamp_utc together with the corresponding modality-relative position_ms.

This dataset merges the former video-only and tracking-only versions of SN-GAR into a single multimodal representation. There is one shared event list per game, so video-only, tracking-only and multimodal experiments use exactly the same events and splits.

Layout

annotations_train.json      45 games
annotations_valid.json       9 games
annotations_test.json       10 games

train/videos/<game_id>.mp4
train/tracking/<game_id>.parquet

valid/videos/<game_id>.mp4
valid/tracking/<game_id>.parquet

test/videos/<game_id>.mp4
test/tracking/<game_id>.parquet

README.md

The two modalities contain the same 64 games.

modality	content	size
Video	64 whole-match 720p MP4 broadcasts	226 GB
Tracking	11,849,815 tracked frames	2.8 GB
Payload total	synchronized video + tracking	~228.8 GB

The complete Hugging Face dataset repository occupies approximately 245 GB.

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 annotated instant in a game carries exactly one event label.

The source event stream is not inherently single-label — a throw-in can also be a high pass, and a headed shot can simultaneously be a header and a shot. Where several labels resolve to the same instant, LABEL_PRIORITY selects the intended label.

This is important when interpreting per-class results because the reduction is lossy across labels rather than uniformly. The least-preserved classes are:

HIGH PASS: 89 of 2,697 retained (3%).
SHOT: 1,041 of 1,559 retained (67%).

Those classes are therefore sparse by construction rather than because of missing or low-quality data.

Source

The dataset contains all 64 matches of the 2022 FIFA World Cup. The internal game identifiers span 3812-3859 and 10502-10517; both ranges belong to the same 2022 FIFA World Cup dataset.

The original event and tracking data come from PFF FC (now Gradient Sports). PFF FC originally released its 2022 FIFA World Cup dataset publicly through:

PFF FC — 2022 World Cup Dataset:
https://www.blog.fc.pff.com/blog/pff-fc-release-2022-world-cup-data

That release provided broadcast-derived player tracking and event data for all 64 matches of the 2022 FIFA World Cup.

The SN-GAR construction uses:

input	content
Broadcast video	whole-match 720p broadcast footage
PFF FC event data	hand-annotated football event stream
PFF FC tracking data	line-delimited player/ball tracking at ~29.97 Hz

The raw PFF FC tracking release stores each game's tracking information separately in compressed JSONL files. The data are cleaned, converted to Parquet and aligned with the broadcast videos and event annotations in the OpenSportsLib representation.

How it was built

1. Start from the original PFF FC data

The original player tracking and event annotations come from the PFF FC 2022 World Cup dataset (PFF FC is now Gradient Sports):

https://www.blog.fc.pff.com/blog/pff-fc-release-2022-world-cup-data

PFF FC provided event annotations and broadcast-derived player/ball tracking for the complete 64-match tournament.

SN-GAR builds on this source by cleaning the tracking data, converting it into a compact table representation, resolving the event taxonomy, associating the original data with the 720p match broadcasts, and introducing a unified absolute UTC synchronization layer.

2. Tracking to table

Each source tracking stream 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 therefore tagged only the sparse event frames.

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

3. 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 initially fires, so one source event can emit several candidate labels at the same instant. A headed goal, for example, produces HEADER, SHOT and GOAL before priority resolution.

After priority resolution, the final dataset contains one label per annotated instant.

 94,285   extracted
 -4,963   removed by priority dedup
 -1,383   dropped during alignment / coverage filtering
=======
 87,939   final

4. Manual UTC anchoring of the videos

The 720p videos and the PFF FC data do not inherently share a reliable common file-relative origin.

To create an explicit absolute time reference, the UTC start time of every game video was manually annotated using the OpenSportsLab VideoAnnotationTool.

Each input is assigned a UTC_time_start value. This defines the absolute UTC instant corresponding to local time zero of that modality.

Conceptually:

absolute UTC time = UTC_time_start + modality-local time

The VideoAnnotationTool uses these UTC origins to synchronize multiple inputs belonging to the same sample. The alignment can therefore remain stable even when the local timeline or media representation of a modality changes.

5. UTC event annotations

Events are also associated with an absolute UTC timestamp:

timestamp_utc

This timestamp is the authoritative temporal identity of the event.

position_ms is retained as the convenient projected position on the current sample timeline, while timestamp_utc identifies the same physical instant independently of a particular video or tracking origin.

In other words:

                         timestamp_utc
                              │
              ┌───────────────┴───────────────┐
              │                               │
              ▼                               ▼
       720p broadcast                   tracking
        UTC_time_start                UTC-aligned clock
              │                               │
              └──── projected position_ms ────┘

This is the synchronization contract used by the multimodal dataset.

6. Multimodal assembly

After cleaning, label resolution and UTC synchronization, each game is written as one OpenSportsLib sample containing:

its 720p broadcast-video input,
its tracking input,
one shared UTC-anchored event list.

Synchronization is therefore part of the dataset representation itself rather than something users need to reconstruct after independently loading video and tracking datasets.

Annotation format

The dataset follows OpenSportsLib v2, with one annotation file per split.

A multimodal game follows this structure:

{
  "version": "2.0",
  "task": "action_spotting",
  "dataset_name": "sngar_action_spotting_valid",
  "metadata": {
    "modality": "multimodal",
    "modalities": ["video", "tracking"],
    "aligned": true,
    "deduplicated_events": 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,
          "UTC_time_start": "YYYY-MM-DD HH:MM:SS.ffffff"
        },
        {
          "type": "tracking_parquet",
          "path": "valid/tracking/3841.parquet",
          "fps": 30.0,
          "UTC_time_start": "YYYY-MM-DD HH:MM:SS.ffffff"
        }
      ],
      "events": [
        {
          "head": "action",
          "label": "PASS",
          "position_ms": 190256,
          "timestamp_utc": "YYYY-MM-DD HH:MM:SS.ffffff",
          "gameTime": "1 - 00:00",
          "team": "home",
          "visibility": "visible"
        }
      ]
    }
  ]
}

timestamp_utc is the authoritative cross-modal event time.

position_ms is the event's projected position on the current sample timeline and remains convenient for standard video seeking and OpenSportsLib localization workflows.

gameTime is the period - MM:SS football match clock. It is useful for display but should not be used as the synchronization primitive.

Video modality

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

Whole-match 720p broadcast video at approximately 29.97 fps (30000/1001), H.264.

The video modality represents approximately 226 GB across the 64 games.

The annotations may declare "fps": 30.0, while the exact video rate is approximately 29.97 fps. Loaders should read the actual rate from the media container rather than treating 30.0 as an exact physical clock.

Video timing

The MP4 timeline is continuous, but its local zero is not itself a reliable cross-modal reference.

Every video therefore carries an explicitly annotated UTC_time_start. A local media position can be mapped into absolute time using this UTC origin.

For example:

video UTC = video.UTC_time_start + video_position

For cross-modal synchronization, prefer the UTC information rather than assuming that frame numbers or media-relative timestamps from independent files have identical origins.

Tracking modality

`{split}/tracking/<game_id>.parquet`

One row per tracked frame, with 17 columns and approximately 178k-191k rows per game.

The tracking modality contains 11,849,815 frames and occupies approximately 2.8 GB.

column	type	meaning
`videoTimeMs`	float32	original video-relative tracking clock in milliseconds
`frameNum`	int32	source frame counter
`period`	int32	1-2, or 1-4 for the three extra-time games (`10506`, `10508`, `10517`)
`game_event_id`	int32	-1 when the frame carries no game event
`possession_event_id`	int32	-1 when the frame carries no possession event
`game_event_type`	string	`FIRSTKICKOFF`, `OTB`, `OUT`, ...; empty on non-event frames
`player_name`, `player_id`	string	event actor; empty on non-event frames
`team_id`, `home_team`	string	actor's team; `home_team` is `"1"`/`"0"`
`possession_event_type`	string	`PA`, `SH`, `CR`, `CH`, `CL`, ...
`homePlayers`, `awayPlayers`	string	JSON array of player objects
`homePlayersSmoothed`, `awayPlayersSmoothed`	string	same, from the smoothed track
`balls`	string	JSON array of `{"visibility", "x", "y", "z"}`
`ballsSmoothed`	string	JSON object — note, not an array

A player object:

{
  "jerseyNum": "4",
  "confidence": "LOW",
  "visibility": "ESTIMATED",
  "x": -16.286,
  "y": 5.821,
  "position": "RCB",
  "positionGroup": "DEF"
}

Coordinates are pitch metres with the origin at the centre circle.

position is the fine-grained player role and positionGroup collapses it to GK / DEF / MID / FWD.

Tracking format quirks

Two shape quirks are inherited from the source and deliberately preserved for compatibility:

The *Smoothed player columns carry no position/positionGroup keys. Only the raw homePlayers/awayPlayers columns are role-enriched.
ballsSmoothed is a JSON object, whereas balls is a JSON array.

The nested columns are JSON strings rather than Arrow structs. This preserves compatibility with the original SN-GAR conversion and existing loaders; zstd compression reduces the tracking representation from approximately 62 GB to 2.8 GB.

Multimodal synchronization

The key property of this release is that absolute UTC time is the synchronization primitive.

For an event:

event timestamp_utc
        │
        ├── video local position
        │      = timestamp_utc - video.UTC_time_start
        │
        └── tracking local position
               = timestamp_utc - tracking UTC origin

The VideoAnnotationTool maintains the authoritative UTC instant while projecting it back to the relative position_ms required by the current sample timeline.

This means that the modalities remain synchronized even when they have:

different local start times,
different frame/sample rates,
tracking gaps,
different media encodings,
or a different local timeline representation.

Do not synchronize the modalities by assuming that row index, frame index or nominal FPS uniquely determines physical time.

Multimodal loading

The two inputs can be accessed from the same game sample.

import json
import cv2
import pandas as pd

ann = json.load(open("annotations_test.json"))
game = ann["data"][0]

video_input = next(
    x for x in game["inputs"] if x["type"] == "video_mp4"
)
tracking_input = next(
    x for x in game["inputs"] if x["type"] == "tracking_parquet"
)

cap = cv2.VideoCapture(video_input["path"])
df = pd.read_parquet(tracking_input["path"])

for event in game["events"][:5]:
    # position_ms is the OpenSportsLib projected sample position.
    t = event["position_ms"]

    cap.set(cv2.CAP_PROP_POS_MSEC, t)
    ok, frame = cap.read()

    print(
        event["label"],
        event["timestamp_utc"],
        "position_ms:", t,
        "video:", ok
    )

For applications that explicitly combine modalities, use timestamp_utc and the inputs' UTC origins as the authoritative synchronization information rather than deriving absolute time from indices.

The common representation supports:

video-only models,
tracking-only models,
multimodal video + tracking models,
early-fusion approaches,
late-fusion approaches,

while keeping exactly the same samples, splits and ground truth.

Known properties

These are real characteristics of the source data, not defects to be cleaned.

Video

The videos are 720p whole-match broadcast footage.
Broadcast footage contains replays, cutaways and graphics that do not exist in the tracking representation.
The videos and tracking data can have different local temporal origins. Their alignment is explicitly represented through UTC timestamps.

Tracking

Ball coverage is 53-79% of frames (mean 68%). At event frames, coverage rises to 93%.
11-v-11 is available on 99.93% of team-frames.
positionGroup coverage is 99.98%.
There are zero out-of-bounds coordinates.
Tracking contains temporal gaps, so row indices must not be treated as a uniform absolute clock.

Both modalities

Three games have extra time: 10506, 10508, 10517, with period running 1-4 rather than 1-2.
Every retained event belongs to one shared multimodal annotation list.
The UTC start time of each game video was manually annotated.
Event timestamps are stored in absolute UTC so that video and tracking observations can be projected onto the same physical instant.

Build contract

setting	value	why
modalities	video + tracking	two synchronized inputs per game
video	720p, ~29.97 fps	whole-match broadcast footage
tracking	~29.97 Hz	player and ball tracking
source	PFF FC / Gradient Sports	original World Cup event + tracking data
ground truth	one shared event list	prevents modality-specific annotation differences
authoritative synchronization	UTC	independent of local media origins
video UTC origin	manually annotated	establishes absolute time for each broadcast
event absolute time	`timestamp_utc`	identifies the same physical instant across modalities
local projected time	`position_ms`	convenient OpenSportsLib/media-relative position
label resolution	one label per instant, resolved by priority	removes competing labels at identical instants
`dedupe_video_time_ms`	`True`	repeated tracking timestamps are removed
splits	45 / 9 / 10	preserves the original SN-GAR contract

Access

Access is gated.

The dataset contains copyrighted broadcast footage and is provided for research and non-commercial use under the associated SoccerNet Non-Disclosure Agreement.

Do not redistribute the dataset or any of its protected contents without authorization from the dataset owners.

References

Original PFF FC 2022 World Cup dataset:
https://www.blog.fc.pff.com/blog/pff-fc-release-2022-world-cup-data
VideoAnnotationTool:
https://github.com/OpenSportsLab/VideoAnnotationTool
OpenSportsLib:
https://github.com/OpenSportsLab/opensportslib

Downloads last month: 24

Total file size:

23.8 kB

Collection including OpenSportsLab/SNGAR-Action-Spotting

OSL-ready datasets

Collection

List of OpenSportsLib ready datasets • 5 items • Updated 2 days ago