opensportslib 0.3.0.dev3__tar.gz → 0.3.0.dev5__tar.gz

{opensportslib-0.3.0.dev3/opensportslib.egg-info → opensportslib-0.3.0.dev5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: opensportslib
-Version: 0.3.0.dev3
+Version: 0.3.0.dev5
 Summary: OpenSportsLib is the professional library, designed for advanced video understanding in sports. It provides state-of-the-art tools for action recognition, spotting, retrieval, and captioning, making it ideal for researchers, analysts, and developers working with sports video data.
 Author: Jeet Vora
 Requires-Python: >=3.12

{opensportslib-0.3.0.dev3 → opensportslib-0.3.0.dev5}/opensportslib/apis/localization.py

@@ -19,6 +19,7 @@ from opensportslib.core.config.accessors import (
     get_model_family,
 )
 from opensportslib.core.utils.config import expand
+from opensportslib.core.config.loader import _dali_available
 
 
 class LocalizationModel(BaseTaskModel):
@@ -126,7 +127,7 @@ class LocalizationModel(BaseTaskModel):
         from opensportslib.core.utils.config import select_device
 
         device = select_device(self.config.SYSTEM)
-        backend = "dali" if self._device_type(device) == "cuda" else "opencv"
+        backend = "dali" if self._device_type(device) == "cuda" and _dali_available() else "opencv"
         current_backend = get_loader_backend(self.config)
         set_loader_backend(self.config, backend)
 

opensportslib-0.3.0.dev5/opensportslib/configs/localization/h5_header_skeleton.yaml

@@ -0,0 +1,65 @@
+TASK: localization
+VERSION: 2
+
+SYSTEM:
+  paths:
+    work_dir: ./outputs/header_spotting_skeleton
+  device: cpu
+  gpu:
+    count: 0
+
+DATA:
+  common:
+    dataset_name: h5_headers
+    data_root: /home/giancos/FIFA_data/128083
+    classes:
+      - header
+    splits:
+      test:
+        type: H5OSLJsonSpotting
+        # Manifest listing the joints/ball h5 pair and the scan window; the
+        # eval scripts generate one per run under their own work dir.
+        annotation_path: ./outputs/header_wc22/manifest.json
+        source_path: /home/giancos/FIFA_data/128083
+        dataloader:
+          batch_size: 1
+          shuffle: false
+          num_workers: 0
+          pin_memory: false
+  inputs:
+    tracking:
+      modality: player_joints_h5
+      representation: raw
+      source:
+        format: h5
+      sampling: {}
+      transform: {}
+      augmentations: {}
+      params: {}
+
+MODEL:
+  metadata:
+    family: RuleBased
+    runner:
+      type: runner_h5_header_rule
+  components:
+    rule:
+      kind: algorithm
+      source:
+        provider: opensportslib
+        registry: rule_based
+        name: h5_header_skeleton
+      # Thresholds default to DEFAULT_SKELETON_RULE_PARAMS in
+      # opensportslib/models/base/rule_based.py. Override here only what this
+      # run needs to differ — restating a default pins it, so later tuning of
+      # the defaults would silently not reach this config.
+      params:
+        label: header
+        head_name: action
+  topology: []
+
+TRAIN:
+  trainer:
+    type: trainer_rule_based
+  execution:
+    enabled: false

{opensportslib-0.3.0.dev3 → opensportslib-0.3.0.dev5}/opensportslib/core/config/loader.py

@@ -2,6 +2,7 @@
 
 from __future__ import annotations
 
+import importlib.util
 import json
 from copy import deepcopy
 from pathlib import Path
@@ -135,12 +136,36 @@ def load_raw_config(path: str | Path) -> dict[str, Any]:
     raise ValueError("Unsupported config format. Use YAML or JSON.")
 
 
-def _normalize_cpu_loader_backend(payload: dict[str, Any]) -> dict[str, Any]:
+def _torch_cuda_available() -> bool:
+    try:
+        import torch
+    except Exception:
+        return False
+    return bool(torch.cuda.is_available())
+
+
+def _dali_available() -> bool:
+    return importlib.util.find_spec("nvidia.dali") is not None
+
+
+def _preferred_loader_backend(payload: dict[str, Any]) -> str | None:
     system = payload.get("SYSTEM", {})
     if not isinstance(system, dict):
-        return payload
+        return None
 
-    if str(system.get("device", "auto")).lower() != "cpu":
+    mode = str(system.get("device", "auto")).lower()
+    if mode == "cpu":
+        return "opencv"
+    if mode == "cuda":
+        return "dali" if _dali_available() else "opencv"
+    if mode == "auto":
+        return "dali" if (_torch_cuda_available() and _dali_available()) else "opencv"
+    return None
+
+
+def _normalize_cpu_loader_backend(payload: dict[str, Any]) -> dict[str, Any]:
+    preferred_backend = _preferred_loader_backend(payload)
+    if preferred_backend is None:
         return payload
 
     data = payload.get("DATA", {})
@@ -155,18 +180,19 @@ def _normalize_cpu_loader_backend(payload: dict[str, Any]) -> dict[str, Any]:
     if not isinstance(runtime, dict):
         runtime = {}
         common["runtime"] = runtime
-    runtime["loader_backend"] = "opencv"
+    runtime["loader_backend"] = preferred_backend
 
     splits = common.get("splits", {})
     if not isinstance(splits, dict):
         return payload
 
-    for split_cfg in splits.values():
-        if not isinstance(split_cfg, dict):
-            continue
-        split_type = split_cfg.get("type")
-        if split_type in _CPU_OPENCV_SPLIT_TYPES:
-            split_cfg["type"] = _CPU_OPENCV_SPLIT_TYPES[split_type]
+    if preferred_backend == "opencv":
+        for split_cfg in splits.values():
+            if not isinstance(split_cfg, dict):
+                continue
+            split_type = split_cfg.get("type")
+            if split_type in _CPU_OPENCV_SPLIT_TYPES:
+                split_cfg["type"] = _CPU_OPENCV_SPLIT_TYPES[split_type]
 
     return payload
 

{opensportslib-0.3.0.dev3 → opensportslib-0.3.0.dev5}/opensportslib/core/utils/data.py

@@ -83,6 +83,73 @@ def tracking_collate_fn(batch):
         'id': [item['id'] for item in batch],
     }
 
+
+def _flatten_graphs_to_batch(list_of_graph_lists):
+    """Flatten a batch of per-sample per-frame graph lists into one PyG Batch.
+
+    Args:
+        list_of_graph_lists: list of length B, each a list of T
+            torch_geometric.data.Data objects (one per frame in the clip).
+
+    Returns:
+        A torch_geometric.data.Batch of all B*T graphs, with a plain int
+        `.seq_len` attribute (T) attached so a graph_conv_seq backbone can
+        reshape the pooled per-frame embeddings back to (B, T, H). Plain
+        int attributes survive Batch.to(device).
+    """
+    try:
+        from torch_geometric.data import Batch
+    except ImportError as exc:
+        raise ImportError(
+            "torch-geometric is required for tracking spotting collate functions. "
+            "Run: `opensportslib setup --pyg` to install the correct version "
+            "based on your system (PyTorch & CUDA compatible)."
+        ) from exc
+
+    seq_len = len(list_of_graph_lists[0])
+    all_graphs = [g for graphs in list_of_graph_lists for g in graphs]
+    batched = Batch.from_data_list(all_graphs)
+    batched.seq_len = seq_len
+    return batched
+
+
+def tracking_spotting_collate_fn(batch):
+    """
+    Collate function for tracking-based action-spotting training clips.
+    Flattens the B*T per-frame graphs of a batch into one PyG Batch (see
+    _flatten_graphs_to_batch) and stacks the dense per-frame labels into
+    (B, T).
+    """
+    frame = _flatten_graphs_to_batch([item["graphs"] for item in batch])
+    labels = torch.as_tensor(
+        np.stack([item["label"] for item in batch]), dtype=torch.long
+    )
+    return {
+        "frame": frame,
+        "label": labels,
+        "contains_event": torch.tensor(
+            [item["contains_event"] for item in batch], dtype=torch.long
+        ),
+    }
+
+
+def tracking_spotting_eval_collate_fn(batch):
+    """
+    Collate function for tracking-based action-spotting sliding-window eval
+    clips. Requires dataloader batch_size=1 (mirrors how the E2E inferer
+    reads clip["frame"][0] for RGB datasets): wraps the single clip's
+    flattened PyG Batch in a 1-element list under "frame" so that indexing
+    keeps working unmodified.
+    """
+    assert len(batch) == 1, "tracking spotting eval requires dataloader batch_size=1"
+    item = batch[0]
+    frame = _flatten_graphs_to_batch([item["graphs"]])
+    return {
+        "video": [item["video"]],
+        "start": torch.tensor([item["start"]]),
+        "frame": [frame],
+    }
+
 def mixup_data(x, y, alpha=0.2):
     """blend pairs of samples and their labels for mixup augmentation."""
     lam = np.random.beta(alpha, alpha) if alpha > 0 else 1.0

{opensportslib-0.3.0.dev3 → opensportslib-0.3.0.dev5}/opensportslib/core/utils/load_annotations.py

@@ -4,6 +4,7 @@ import tqdm
 import logging
 import cv2
 import math
+import numpy as np
 import torch
 from opensportslib.core.utils.video_processing import get_stride, read_fps, get_num_frames
 from opensportslib.core.utils.config import load_json
@@ -302,6 +303,116 @@ def annotationstoe2eformat(
 
     return labels_e2e, task_name_list[0]
 
+
+def annotationstoe2eformat_tracking(label_files, video_dirs, extract_fps):
+    """
+    Adapt tracking-parquet action-spotting annotations to E2E format.
+
+    Mirrors annotationstoe2eformat's output schema, but reads a whole-match
+    tracking parquet (via the per-game cache built by
+    opensportslib.datasets.utils.tracking.load_or_build_game_cache) instead
+    of a video file. Each event's position_ms is mapped to a native frame
+    index via a searchsorted lookup on the cached videoTimeMs column (the
+    absolute match clock, which lines up directly with position_ms) rather
+    than the from-scratch fps computation the video path uses, then
+    converted to a decimated (extract_fps) frame index the same way
+    FrameReader converts native video frames.
+
+    Args:
+        label_files (str | list[str]): Annotation JSON files.
+        video_dirs (str | list[str]): Root directories containing the
+            tracking parquets referenced by each annotation file.
+        extract_fps (float): Target fps to decimate the native tracking
+            stream to. A non-positive value keeps every native frame.
+
+    Returns:
+        (labels_e2e, task_name): labels_e2e is a list of dicts with the
+        same keys as annotationstoe2eformat's output (events/fps/
+        num_frames/num_frames_base/video/path/num_events), plus a
+        "stride" field (native rows per decimated frame) that dataset
+        classes use to slice windows out of the cached native features.
+    """
+    from opensportslib.datasets.utils.tracking import load_or_build_game_cache
+
+    if not isinstance(label_files, list):
+        label_files = [label_files]
+    if not isinstance(video_dirs, list):
+        video_dirs = [video_dirs]
+    assert len(label_files) == len(video_dirs)
+
+    labels_e2e = []
+    classes_by_label_dir = []
+    task_name_list = []
+
+    for label_path, video_dir in zip(label_files, video_dirs):
+        logging.info(f"Processing {label_path} to e2e format (tracking)")
+
+        annotations = load_json(label_path)
+
+        for task_name, task_data in annotations["labels"].items():
+            labels = task_data.get("labels", {})
+            task_name_list.append(task_name)
+        classes_by_label_dir.append(labels)
+
+        videos = annotations["data"]
+
+        for video in tqdm.tqdm(videos):
+            video_input = video["inputs"][0]
+            video_path = video_input["path"]
+            full_video_path = os.path.join(video_dir, video_path)
+            assert os.path.isfile(full_video_path), full_video_path
+
+            _, times, _ = load_or_build_game_cache(full_video_path)
+            num_frames = len(times)
+
+            native_fps = video_input.get("fps")
+            if not native_fps:
+                native_fps = 1000.0 / float(np.median(np.diff(times)))
+
+            target_fps = (
+                extract_fps if (extract_fps and extract_fps < native_fps) else native_fps
+            )
+            sample_fps = read_fps(native_fps, target_fps)
+            stride = get_stride(native_fps, target_fps)
+            num_frames_after = get_num_frames(num_frames, native_fps, target_fps)
+
+            events = []
+            for ann in video.get("events", []):
+                position_ms = float(ann["position_ms"])
+                native_idx = int(np.searchsorted(times, position_ms))
+                native_idx = min(max(native_idx, 0), num_frames - 1)
+                adj_frame = native_idx // stride
+
+                if adj_frame == 0:
+                    adj_frame = 1
+
+                events.append({
+                    "frame": int(adj_frame),
+                    "label": ann["label"],
+                })
+
+            events.sort(key=lambda x: x["frame"])
+
+            labels_e2e.append({
+                "events": events,
+                "fps": sample_fps,
+                "num_frames": num_frames_after,
+                "num_frames_base": num_frames,
+                "num_events": len(events),
+                "video": full_video_path,
+                "path": video_path,
+                "stride": stride,
+            })
+
+    base_classes = classes_by_label_dir[0]
+    for c in classes_by_label_dir:
+        assert c == base_classes
+
+    labels_e2e.sort(key=lambda x: x["video"])
+
+    return labels_e2e, task_name_list[0]
+
+
 # def annotationstoe2eformat(label_files, video_dirs, input_fps, extract_fps, dali):
 #     """Adapt annotations jsons to e2e format.
 
@@ -496,7 +607,7 @@ def check_config(cfg, split="train"):
         if get_loader_backend(cfg) == "dali":
             cfg.TRAIN.execution.repartitions = get_repartition_gpu(cfg.SYSTEM.gpu.count)
         primary_modality = get_data_modality(cfg)
-        assert primary_modality in ["rgb", "video"]
+        assert primary_modality in ["rgb", "video", "tracking_parquet"]
         backbone_type = get_component_name_by_kind(cfg, "encoder")
         assert backbone_type in [
             # From torchvision
@@ -513,6 +624,8 @@ def check_config(cfg, split="train"):
             "rny008",
             "rny008_tsm",
             "rny008_gsm",
+            # tracking graph encoder, sequence output (see models/backbones/builder.py)
+            "graph_conv_seq",
             # From timm
             "convnextt",
             "convnextt_tsm",
@@ -588,7 +701,11 @@ def whether_infer_split(cfg):
             return True
         else:
             return False
-    elif split_type == "VideoGameWithOpencvVideo" or split_type == "VideoGameWithDaliVideo":
+    elif split_type in (
+        "VideoGameWithOpencvVideo",
+        "VideoGameWithDaliVideo",
+        "TrackingActionSpotVideo",
+    ):
         if annotation_path and annotation_path.endswith(".json"):
             return True
         else: