opensportslib 0.1.2.dev9__tar.gz → 0.1.2.dev11__tar.gz

{opensportslib-0.1.2.dev9/opensportslib.egg-info → opensportslib-0.1.2.dev11}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: opensportslib
-Version: 0.1.2.dev9
+Version: 0.1.2.dev11
 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.1.2.dev9 → opensportslib-0.1.2.dev11}/opensportslib/config/classification.yaml

@@ -1,35 +1,44 @@
 TASK: classification
 DATA:
   dataset_name: mvfouls
-  data_dir: /home/vorajv/opensportslib/SoccerNet/mvfouls
+  data_dir: /home/giancos/datasets/OpenSportsLab/OSL-XFoul/224p
   data_modality: video
   view_type: multi  # multi or single
   num_classes: 8 # mvfoul
   train: 
     type: annotations_train.json
     video_path: ${DATA.data_dir}/train
-    path: ${DATA.train.video_path}/annotations-train.json
+    path: ${DATA.train.video_path}/train.json
     dataloader:
       batch_size: 8
       shuffle: true
       num_workers: 4
       pin_memory: true
+      mp_context: spawn
+      persistent_workers: true
+      prefetch_factor: 4  
   valid:
     type: annotations_valid.json
     video_path: ${DATA.data_dir}/valid
-    path: ${DATA.valid.video_path}/annotations-valid.json
+    path: ${DATA.valid.video_path}/valid.json
     dataloader:
       batch_size: 1
       num_workers: 1
       shuffle: false
+      mp_context: spawn
+      persistent_workers: true
+      prefetch_factor: 4  
   test:
     type: annotations_test.json
     video_path: ${DATA.data_dir}/test
-    path: ${DATA.test.video_path}/annotations-test.json
+    path: ${DATA.test.video_path}/test.json
     dataloader:
       batch_size: 1
-      num_workers: 1
+      num_workers: 0
       shuffle: false
+      mp_context: spawn
+      persistent_workers: true
+      prefetch_factor: 4  
   num_frames: 16               # 8 before + 8 after the foul
   input_fps: 25                # Original FPS of video
   target_fps: 17               # Temporal downsampling to 1s clip (approx)

{opensportslib-0.1.2.dev9 → opensportslib-0.1.2.dev11}/opensportslib/core/trainer/classification_trainer.py

@@ -14,6 +14,7 @@ import gc
 import json
 import time
 import logging
+import multiprocessing as mp
 
 import torch
 import tqdm
@@ -865,36 +866,53 @@ class Trainer_Classification:
         else:
             val_sampler = None
 
-        num_train_workers = self.config.DATA.train.dataloader.num_workers
-        num_val_workers = self.config.DATA.valid.dataloader.num_workers
+        train_num_workers = getattr(self.config.DATA.train.dataloader, "num_workers", 0)
+        train_pin_memory = getattr(self.config.DATA.train.dataloader, "pin_memory", self.device.type == "cuda")
+        train_mp_context = getattr(self.config.DATA.train.dataloader, "mp_context", None)
+        train_persistent_workers = getattr(self.config.DATA.train.dataloader, "persistent_workers", train_num_workers > 0)
+        train_prefetch_factor = getattr(self.config.DATA.train.dataloader, "prefetch_factor", 4 if train_num_workers > 0 else None)
+        
+        if train_mp_context is not None:
+            train_mp_context = mp.get_context(train_mp_context)
 
         train_loader = DataLoader(
             train_dataset,
             batch_size=self.config.DATA.train.dataloader.batch_size,
             shuffle=(train_sampler is None and shuffle),
             sampler=train_sampler,
-            num_workers=num_train_workers,
-            pin_memory=True,
+            num_workers=train_num_workers,
+            pin_memory=train_pin_memory,
             collate_fn=collate_fn,
             worker_init_fn=seed_worker,
             generator=g,
             drop_last=True,
-            persistent_workers=num_train_workers > 0,
-            prefetch_factor=4 if num_train_workers > 0 else None,
+            multiprocessing_context=train_mp_context,
+            persistent_workers=train_persistent_workers,
+            prefetch_factor=train_prefetch_factor,
         )
 
+        valid_num_workers = getattr(self.config.DATA.valid.dataloader, "num_workers", 0)
+        valid_pin_memory = getattr(self.config.DATA.valid.dataloader, "pin_memory", self.device.type == "cuda")
+        valid_mp_context = getattr(self.config.DATA.valid.dataloader, "mp_context", None)
+        valid_persistent_workers = getattr(self.config.DATA.valid.dataloader, "persistent_workers", valid_num_workers > 0)
+        valid_prefetch_factor = getattr(self.config.DATA.valid.dataloader, "prefetch_factor", 4 if valid_num_workers > 0 else None)
+
+        if valid_mp_context is not None:
+            valid_mp_context = mp.get_context(valid_mp_context)
+            
         val_loader = DataLoader(
             val_dataset,
             batch_size=self.config.DATA.valid.dataloader.batch_size,
             shuffle=False,
             sampler=val_sampler,   
-            num_workers=num_val_workers,
-            pin_memory=True,
+            num_workers=valid_num_workers,
+            pin_memory=valid_pin_memory,
             collate_fn=collate_fn,
             worker_init_fn=seed_worker,
             generator=g,
-            persistent_workers=num_val_workers > 0,
-            prefetch_factor=4 if num_val_workers > 0 else None,
+            multiprocessing_context=valid_mp_context,
+            persistent_workers=valid_persistent_workers,
+            prefetch_factor=valid_prefetch_factor,
         )
 
         # select the modality-specific trainer.

{opensportslib-0.1.2.dev9 → opensportslib-0.1.2.dev11}/opensportslib/datasets/classification_dataset.py

@@ -73,7 +73,7 @@ class ClassificationDataset(Dataset):
         self.config = config
         self.split = split
         self.exclude_labels = ["Unknown", "Dont know"]
-        self.data_dir = config.DATA.data_dir
+        self.video_path = getattr(config.DATA, split).video_path #config.DATA.data_dir
         self.processor = None
 
         # view_type is optional; only MVFoul uses it as of now
@@ -197,7 +197,7 @@ class VideoDataset(ClassificationDataset):
     """
 
     def __init__(self, config, annotations_path, processor, split="train"):
-        super().__init__(config, annotations_path, split)
+        super().__init__(config, annotations_path, processor, split=split)
 
         self.processor = processor
         self.view_type = getattr(config.DATA, "view_type", "single")
@@ -227,15 +227,13 @@ class VideoDataset(ClassificationDataset):
         """read a video file, temporally sub-sample, and apply transforms.
 
         Args:
-            path: realtive path (under data_dir) to the video file.
+            path: realtive path (under video_path) to the video file.
 
         Returns:
             numpy.ndarray of shape (T, H, W, C).
         """
-        full_path = os.path.join(self.config.DATA.data_dir, path)
-
-        if full_path.endswith(".npy"):
-            frames = np.load(full_path).astype(np.float32) / 255.0
+        if path.endswith(".npy"):
+            frames = np.load(path).astype(np.float32) / 255.0
             if self.transform is not None:
                 frames = self.transform(frames)
             mean = np.array([0.485, 0.456, 0.406], dtype=np.float32)
@@ -243,7 +241,7 @@ class VideoDataset(ClassificationDataset):
             frames = (frames - mean) / std
             return frames
 
-        v = read_video(os.path.join(self.config.DATA.data_dir, path))
+        v = read_video(os.path.join(self.video_path, path))
 
         v = process_frames(
             v,
@@ -473,7 +471,7 @@ class TrackingDataset(ClassificationDataset):
         """read a single parquet tracking clip.
         
         Args:
-            path: Relative path (under ``data_dir``) to the parquet
+            path: Relative path (under ``video_path``) to the parquet
                 file.
 
         Returns:
@@ -481,7 +479,7 @@ class TrackingDataset(ClassificationDataset):
         """
         import pandas as pd
 
-        full_path = os.path.join(self.data_dir, path)
+        full_path = os.path.join(self.video_path, path)
         return pd.read_parquet(full_path)
     
     def __getitem__(self, idx):

{opensportslib-0.1.2.dev9 → opensportslib-0.1.2.dev11}/opensportslib/setup/setup.py

@@ -31,6 +31,17 @@ def get_cpu_tag():
 def install_torch():
     python = sys.executable
     subprocess.call([python, "-m", "pip", "uninstall", "-y", "torch", "torchvision"])
+    
+    if CUDA_VERSION == "cu130":
+        cuda = "cu130"
+        subprocess.check_call([
+            python, "-m", "pip", "install",
+            "torch", "torchvision", "torchaudio",
+            "--index-url",
+            f"https://download.pytorch.org/whl/{cuda}"
+        ])
+        print(f"\nSuccess with {cuda}")
+        return cuda
     for cuda in CUDA_SUPPORT:
 
         print(f"\n Trying installation: {cuda}\n")
@@ -64,16 +75,29 @@ def install_dali():
 
     # DALI (only if GPU)
     if CUDA_VERSION:
-        subprocess.check_call([
-            python, "-m", "pip", "install",
-            "nvidia-dali-cuda120"
-        ])
-    
-        # CuPy (CUDA-aware but auto-resolves internally)
-        subprocess.check_call([
-            python, "-m", "pip", "install",
-            "cupy-cuda12x"
-        ])
+        
+        if CUDA_VERSION == "cu130":
+            subprocess.check_call([
+                python, "-m", "pip", "install",
+                "nvidia-dali-cuda130"
+            ])
+
+            # CuPy (CUDA-aware but auto-resolves internally)
+            subprocess.check_call([
+                python, "-m", "pip", "install",
+                "cupy-cuda130"
+            ])
+        else:
+            subprocess.check_call([
+                python, "-m", "pip", "install",
+                "nvidia-dali-cuda120"
+            ])
+
+            # CuPy (CUDA-aware but auto-resolves internally)
+            subprocess.check_call([
+                python, "-m", "pip", "install",
+                "cupy-cuda12x"
+            ])
 
 def install_pyg():
     import torch

{opensportslib-0.1.2.dev9 → opensportslib-0.1.2.dev11/opensportslib.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: opensportslib
-Version: 0.1.2.dev9
+Version: 0.1.2.dev11
 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.1.2.dev9 → opensportslib-0.1.2.dev11}/opensportslib.egg-info/SOURCES.txt

@@ -87,6 +87,8 @@ opensportslib/tools/hf_transfer.py
 opensportslib/tools/osl_json_to_parquet.py
 opensportslib/tools/parquet_to_osl_json.py
 tests/conftest.py
+tests/test_classification_dataset_paths.py
+tests/test_classification_trainer_dataloader.py
 tests/test_config_utils_smoke.py
 tests/test_conversion_tools.py
 tests/test_hf_transfer_tools.py

{opensportslib-0.1.2.dev9 → opensportslib-0.1.2.dev11}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "opensportslib"
-version = "0.1.2.dev9"
+version = "0.1.2.dev11"
 description = "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."
 readme = "README.md"
 requires-python = ">=3.12"

{opensportslib-0.1.2.dev9 → opensportslib-0.1.2.dev11}/tests/conftest.py

@@ -185,8 +185,11 @@ def localization_integration_assets(tmp_path: Path) -> dict:
                 "video_path": str(data_dir),
                 "dataloader": {
                     "batch_size": 1,
-                    "num_workers": 0,
+                    "num_workers": 4,
                     "pin_memory": False,
+                    "mp_context": "spawn",
+                    "persistent_workers": True,
+                    "prefetch_factor": 4
                 },
             },
             "valid": {
@@ -194,8 +197,11 @@ def localization_integration_assets(tmp_path: Path) -> dict:
                 "video_path": str(data_dir),
                 "dataloader": {
                     "batch_size": 1,
-                    "num_workers": 0,
+                    "num_workers": 1,
                     "pin_memory": False,
+                    "mp_context": "spawn",
+                    "persistent_workers": True,
+                    "prefetch_factor": 1
                 },
             },
             "test": {
@@ -204,8 +210,11 @@ def localization_integration_assets(tmp_path: Path) -> dict:
                 "results": str(result_path),
                 "dataloader": {
                     "batch_size": 1,
-                    "num_workers": 0,
+                    "num_workers": 1,
                     "pin_memory": False,
+                    "mp_context": "spawn",
+                    "persistent_workers": True,
+                    "prefetch_factor": 1
                 },
             },
         },
@@ -323,18 +332,27 @@ def localization_public_dataset_assets(tmp_path: Path) -> dict:
             "train": {
                 "path": train_path,
                 "video_path": str(data_dir / "train"),
-                "dataloader": {"batch_size": 1, "num_workers": 0, "pin_memory": False},
+                "dataloader": {"batch_size": 1, "num_workers": 0, "pin_memory": False,
+                    "mp_context": "spawn",
+                    "persistent_workers": True,
+                    "prefetch_factor": 4},
             },
             "valid": {
                 "path": valid_path,
                 "video_path": str(data_dir / "valid"),
-                "dataloader": {"batch_size": 1, "num_workers": 0, "pin_memory": False},
+                "dataloader": {"batch_size": 1, "num_workers": 0, "pin_memory": False,
+                    "mp_context": "spawn",
+                    "persistent_workers": True,
+                    "prefetch_factor": 1},
             },
             "test": {
                 "path": test_path,
                 "video_path": str(data_dir / "test"),
                 "results": str(result_path),
-                "dataloader": {"batch_size": 1, "num_workers": 0, "pin_memory": False},
+                "dataloader": {"batch_size": 1, "num_workers": 0, "pin_memory": False,
+                    "mp_context": "spawn",
+                    "persistent_workers": True,
+                    "prefetch_factor": 1},
             },
         },
         "MODEL": {"backbone": {"type": "smoke_backbone"}, "multi_gpu": False},

opensportslib-0.1.2.dev11/tests/test_classification_dataset_paths.py

@@ -0,0 +1,96 @@
+import json
+from pathlib import Path
+from types import SimpleNamespace
+
+import numpy as np
+
+import opensportslib.datasets.classification_dataset as classification_dataset
+
+
+def _write_classification_annotation(path: Path) -> str:
+    payload = {
+        "labels": {
+            "action": {"labels": ["PASS"]},
+        },
+        "data": [
+            {
+                "id": "sample_00000",
+                "inputs": [
+                    {
+                        "type": "video",
+                        "path": "clips/video_00000.mp4",
+                    }
+                ],
+                "labels": {
+                    "action": {"label": "PASS"},
+                },
+            }
+        ],
+    }
+    path.parent.mkdir(parents=True, exist_ok=True)
+    path.write_text(json.dumps(payload), encoding="utf-8")
+    return str(path)
+
+
+def _make_config(data_dir: Path, valid_video_root: Path) -> SimpleNamespace:
+    return SimpleNamespace(
+        DATA=SimpleNamespace(
+            data_dir=str(data_dir),
+            data_modality="video",
+            view_type="single",
+            num_frames=16,
+            input_fps=25,
+            target_fps=17,
+            start_frame=0,
+            end_frame=15,
+            train=SimpleNamespace(video_path=str(data_dir / "train_root")),
+            valid=SimpleNamespace(video_path=str(valid_video_root)),
+            test=SimpleNamespace(video_path=str(data_dir / "test_root")),
+        ),
+        MODEL=SimpleNamespace(type="custom", pretrained_model="smoke_backbone"),
+    )
+
+
+def test_video_dataset_resolves_relative_paths_from_selected_split_root(
+    tmp_path,
+    monkeypatch,
+):
+    annotation_path = _write_classification_annotation(tmp_path / "annotations" / "valid.json")
+    data_dir = tmp_path / "dataset_root"
+    valid_video_root = tmp_path / "separate_valid_root"
+    config = _make_config(data_dir, valid_video_root)
+    captured = {}
+
+    monkeypatch.setattr(classification_dataset, "build_transform", lambda config, mode: None)
+    monkeypatch.setattr(
+        classification_dataset,
+        "process_frames",
+        lambda *args, **kwargs: np.zeros((16, 4, 4, 3), dtype=np.uint8),
+    )
+    monkeypatch.setattr(
+        classification_dataset,
+        "get_transforms_model",
+        lambda model_name: (lambda tensor: tensor),
+    )
+
+    def fake_read_video(path):
+        captured["path"] = path
+        return []
+
+    monkeypatch.setattr(classification_dataset, "read_video", fake_read_video)
+
+    dataset = classification_dataset.VideoDataset(
+        config,
+        annotation_path,
+        processor=None,
+        split="valid",
+    )
+
+    sample = dataset[0]
+
+    resolved_path = Path(captured["path"])
+
+    assert dataset.split == "valid"
+    assert resolved_path.is_absolute()
+    assert resolved_path == valid_video_root / "clips" / "video_00000.mp4"
+    assert sample["id"] == "sample_00000"

opensportslib-0.1.2.dev11/tests/test_classification_trainer_dataloader.py

@@ -0,0 +1,127 @@
+from types import SimpleNamespace
+
+import torch
+from omegaconf import OmegaConf
+
+from opensportslib.core.trainer import classification_trainer
+
+
+class _FakeTrainer:
+    def __init__(self, **kwargs):
+        self.kwargs = kwargs
+
+    def train(self, epoch_start=0, save_every=1):
+        del epoch_start, save_every
+
+
+class _FakeDataset:
+    label_map = {0: "PASS"}
+
+    def __len__(self):
+        return 1
+
+    def num_classes(self):
+        return 1
+
+    def get_class_weights(self, num_classes=None, sqrt=False):
+        del num_classes, sqrt
+        return torch.ones(1)
+
+    def get_sample_weights(self):
+        return torch.ones(1)
+
+
+def _make_config(mp_context=None):
+    dataloader = {
+        "batch_size": 1,
+        "num_workers": 1,
+        "pin_memory": False,
+        "persistent_workers": True,
+        "prefetch_factor": 4,
+    }
+    if mp_context is not None:
+        dataloader["mp_context"] = mp_context
+
+    return OmegaConf.create(
+        {
+            "DATA": {
+                "data_modality": "video",
+                "train": {"dataloader": dict(dataloader)},
+                "valid": {"dataloader": dict(dataloader)},
+            },
+            "MODEL": {
+                "type": "custom",
+                "backbone": {"type": "smoke_backbone"},
+            },
+            "TRAIN": {
+                "use_weighted_loss": False,
+                "use_weighted_sampler": False,
+                "optimizer": {"type": "SGD", "lr": 0.1},
+                "scheduler": {"type": "StepLR", "step_size": 1, "gamma": 0.1},
+                "criterion": {"type": "CrossEntropyLoss"},
+                "epochs": 1,
+                "save_every": 1,
+            },
+            "SYSTEM": {
+                "seed": 0,
+                "device": "cpu",
+                "save_dir": ".",
+            },
+        }
+    )
+
+
+def _run_train(monkeypatch, config):
+    dataloader_calls = []
+
+    monkeypatch.setattr(
+        classification_trainer,
+        "select_device",
+        lambda system: torch.device("cpu"),
+    )
+    monkeypatch.setattr(
+        classification_trainer,
+        "DataLoader",
+        lambda dataset, **kwargs: dataloader_calls.append(kwargs) or SimpleNamespace(),
+    )
+    monkeypatch.setattr(
+        classification_trainer,
+        "MVTrainerClassification",
+        _FakeTrainer,
+    )
+    monkeypatch.setattr(
+        "opensportslib.core.optimizer.builder.build_optimizer",
+        lambda params, cfg: object(),
+    )
+    monkeypatch.setattr(
+        "opensportslib.core.scheduler.builder.build_scheduler",
+        lambda optimizer, cfg: object(),
+    )
+    monkeypatch.setattr(
+        "opensportslib.core.loss.builder.build_criterion",
+        lambda cfg: object(),
+    )
+
+    trainer = classification_trainer.Trainer_Classification(config)
+    trainer.train(torch.nn.Linear(1, 1), _FakeDataset(), _FakeDataset())
+
+    return dataloader_calls
+
+
+def test_video_train_loader_respects_explicit_spawn_context(monkeypatch):
+    dataloader_calls = _run_train(monkeypatch, _make_config("spawn"))
+
+    assert len(dataloader_calls) == 2
+    assert dataloader_calls[0]["num_workers"] == 1
+    assert dataloader_calls[0]["pin_memory"] is False
+    assert (dataloader_calls[0]["multiprocessing_context"].get_start_method() == "spawn")
+    assert (dataloader_calls[1]["multiprocessing_context"].get_start_method() == "spawn")
+    
+
+
+def test_video_train_loader_respects_explicit_context(monkeypatch):
+    dataloader_calls = _run_train(monkeypatch, _make_config("forkserver"))
+
+    assert len(dataloader_calls) == 2
+    assert (dataloader_calls[0]["multiprocessing_context"].get_start_method() == "forkserver")
+    assert (dataloader_calls[1]["multiprocessing_context"].get_start_method() == "forkserver")

{opensportslib-0.1.2.dev9 → opensportslib-0.1.2.dev11}/tests/test_task_model_api_contract.py

@@ -208,7 +208,7 @@ def test_localization_evaluate_uses_provided_predictions(
     )
     monkeypatch.setattr(
         "opensportslib.core.utils.config.resolve_config_omega",
-        lambda config: config,
+        lambda config, weights=None: config,
     )
     monkeypatch.setattr(
         "opensportslib.core.utils.load_annotations.check_config",
@@ -304,6 +304,7 @@ def test_localization_constructor_weights_are_default_for_train_and_infer(
         self.model = object()
         self.last_loaded_weights = weights
         self.best_checkpoint = weights
+        self._resume_state = {"source_weights": weights}
 
     def fake_build_trainer(cfg, model, default_args, resume_from=None):
         del cfg, model, default_args
@@ -329,7 +330,7 @@ def test_localization_constructor_weights_are_default_for_train_and_infer(
     )
     monkeypatch.setattr(
         "opensportslib.core.utils.config.resolve_config_omega",
-        lambda config: config,
+        lambda config, weights=None: config,
     )
     monkeypatch.setattr(
         "opensportslib.core.utils.config.select_device",
@@ -367,9 +368,9 @@ def test_localization_constructor_weights_are_default_for_train_and_infer(
     train_api = LocalizationModel(config=localization_config_path, weights="default")
     train_api.config = make_config()
     train_api.train(use_wandb=False)
-    assert trainer_resume_from[-1] == "default"
+    assert trainer_resume_from[-1]["source_weights"] == "default"
 
     train_api = LocalizationModel(config=localization_config_path, weights="default")
     train_api.config = make_config()
     train_api.train(weights="override", use_wandb=False)
-    assert trainer_resume_from[-1] == "override"
+    assert trainer_resume_from[-1]["source_weights"] == "override"