opensportslib 0.0.1.dev16__tar.gz → 0.0.1.dev18__tar.gz

{opensportslib-0.0.1.dev16/opensportslib.egg-info → opensportslib-0.0.1.dev18}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: opensportslib
-Version: 0.0.1.dev16
+Version: 0.0.1.dev18
 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.0.1.dev16 → opensportslib-0.0.1.dev18}/opensportslib/apis/localization.py

@@ -101,7 +101,7 @@ class LocalizationAPI:
 
         device = select_device(self.config.SYSTEM)
         self.model = build_model(self.config, device=device)
-        print(self.model)
+        print(f"model: {self.model}")
 
 
         # Datasets
@@ -155,7 +155,7 @@ class LocalizationAPI:
         from opensportslib.core.trainer.localization_trainer import build_inferer, build_evaluator
         from opensportslib.core.utils.config import select_device, resolve_config_omega, is_local_path
         from opensportslib.core.utils.checkpoint import load_checkpoint, localization_remap
-        from opensportslib.core.utils.load_annotations import check_config, has_localization_events
+        from opensportslib.core.utils.load_annotations import check_config, has_localization_events, whether_infer_split
         from opensportslib.core.utils.wandb import init_wandb
         import time
 
@@ -163,6 +163,7 @@ class LocalizationAPI:
         self.config.MODEL.multi_gpu = False
         self.config = resolve_config_omega(self.config)
         check_config(self.config, split="test")
+        self.config.infer_split = whether_infer_split(self.config.DATA.test)
         init_wandb(self.config, run_id=os.environ["RUN_ID"], use_wandb=use_wandb)
         logging.info("Configuration:")
         logging.info(self.config)
@@ -179,19 +180,29 @@ class LocalizationAPI:
             logging.info("No predictions provided, running inference.")
             device = select_device(self.config.SYSTEM)
             self.model = build_model(self.config, device=device)
+            inner_model = getattr(self.model, "_model", None)
+            if inner_model is None:
+                inner_model = getattr(self.model, "model", self.model)
             print("Model type:", type(self.model))
-            print("Torch model type:", type(self.model._model))
+            print("Torch model type:", type(inner_model))
             # Load model
             if pretrained:
                 #pretrained = expand(pretrained)
                 if is_local_path(pretrained):
                     self.config.SYSTEM.work_dir = os.path.dirname(os.path.abspath(pretrained))
                 
-                self.model._model, _, _, epoch = load_checkpoint(model=self.model._model,
+                inner_model, _, _, epoch = load_checkpoint(model=inner_model,
                                             path=pretrained,
                                             device=device,
                                             key_remap_fn=localization_remap)
 
+                if hasattr(self.model, "_model"):
+                    self.model._model = inner_model
+                elif hasattr(self.model, "model"):
+                    self.model.model = inner_model
+                else:
+                    self.model = inner_model
+
             # Datasets
             # Test
             data_obj_test = build_dataset(self.config, split="test")
@@ -206,7 +217,7 @@ class LocalizationAPI:
             # # Inference
             inferer = build_inferer(cfg=self.config.MODEL,
                                     model=self.model)
-            json_gz_file = inferer.infer(cfg=self.config, data=dataset_Test)
+            json_gz_file = inferer.infer(cfg=self.config, data=dataset_Test, dataloader=test_loader)
 
         #json_gz_file = self.config.DATA.test.results + ".recall.json.gz"
         json_gz_file = predictions if predictions else json_gz_file
@@ -219,7 +230,7 @@ class LocalizationAPI:
             evaluator = build_evaluator(cfg=self.config)
             metrics = evaluator.evaluate(
                 cfg_testset=self.config.DATA.test,
-                json_gz_file=json_gz_file
+                json_gz_file=self.config.DATA.test.results if isinstance(json_gz_file, dict) else json_gz_file
             )
         else:
             logging.info("No labels found in annotation file → skipping evaluation")

opensportslib-0.0.1.dev18/opensportslib/config/localization-json_netvlad++_resnetpca512.yaml

@@ -0,0 +1,145 @@
+TASK: localization
+
+dali: false
+
+DATA:
+  dataset_name: SoccerNet
+  data_dir: /home/vorajv/opensportslib/SoccerNet/
+  classes:
+    - Penalty
+    - Kick-off
+    - Goal
+    - Substitution
+    - Offside
+    - Shots on target
+    - Shots off target
+    - Clearance
+    - Ball out of play
+    - Throw-in
+    - Foul
+    - Indirect free-kick
+    - Direct free-kick
+    - Corner
+    - Yellow card
+    - Red card
+    - Yellow->red card
+    
+  epoch_num_frames: 500000
+  mixup: true
+  modality: rgb
+  crop_dim: -1
+  dilate_len: 0        # Dilate ground truth labels
+  clip_len: 100
+  input_fps: 25
+  extract_fps: 2
+  imagenet_mean: [0.485, 0.456, 0.406]
+  imagenet_std: [0.229, 0.224, 0.225]
+  target_height: 224
+  target_width: 398
+
+  train:
+    type: FeatureClipsfromJSON
+    classes: ${DATA.classes}
+    output_map: [data, label]
+    video_path: ${DATA.data_dir}
+    path: ${DATA.train.video_path}/annotations-2024-224p-train.json
+    framerate: 2
+    window_size: 20
+    dataloader:
+      batch_size: 256
+      shuffle: true
+      num_workers: 4
+      pin_memory: true
+
+  valid:
+    type: FeatureClipsfromJSON
+    classes: ${DATA.classes}
+    output_map: [data, label]
+    video_path: ${DATA.data_dir}
+    path: ${DATA.valid.video_path}/annotations-2024-224p-valid.json
+    framerate: 2
+    window_size: 20
+    dataloader:
+      batch_size: 256
+      shuffle: true
+      num_workers: 4
+      pin_memory: true
+
+  test:
+    type: FeatureVideosfromJSON
+    classes: ${DATA.classes}
+    output_map: [data, label]
+    video_path: ${DATA.data_dir}
+    path: ${DATA.test.video_path}/annotations-2024-224p-test.json
+    results: results_spotting_test_netvlad++_resnetpca512
+    framerate: 2
+    window_size: 20
+    metric: tight
+    dataloader:
+      batch_size: 1
+      shuffle: false
+      num_workers: 1
+      pin_memory: true
+
+MODEL:
+    type: LearnablePooling
+    runner:
+      type: runner_JSON
+    backbone:
+      type: PreExtactedFeatures
+      encoder: ResNET_TF2_PCA512
+      feature_dim: 512
+      output_dim: 512
+      framerate: 2
+      window_size: 20
+    neck:
+      type: NetVLAD++
+      input_dim: 512
+      output_dim: 32768 # 512 clusters * 64 vocab size
+      vocab_size: 64
+    head:
+      type: LinearLayer
+      input_dim: 32768
+      num_classes: 17
+    post_proc:
+      type: NMS
+      NMS_window: 30
+      NMS_threshold: 0.0
+    load_weights: null
+
+TRAIN:
+  type: trainer_pooling
+  max_epochs: 200
+  evaluation_frequency: 200
+  framerate: 2
+  batch_size: 256
+
+  criterion:
+    type: NLLLoss
+
+  optimizer:
+    type: Adam
+    lr: 0.001
+    betas: [0.9, 0.999]
+    eps: 1e-08
+    weight_decay: 0
+    amsgrad: false
+
+  scheduler:
+    type: ReduceLROnPlateau
+    mode: min
+    factor: 1e-03
+    min_lr: 1e-06
+    patience: 10
+    verbose: true
+
+
+SYSTEM:
+  log_dir: ./logs
+  save_dir: ./checkpoints
+  work_dir: ${SYSTEM.save_dir}
+  seed: 42
+  GPU: 4        # number of gpus to use
+  device: cuda   # auto | cuda | cpu
+  gpu_id: 0      # device id for single gpu training
+

{opensportslib-0.0.1.dev16 → opensportslib-0.0.1.dev18}/opensportslib/core/trainer/localization_trainer.py

@@ -160,15 +160,23 @@ class Trainer_pl(Trainer):
     def __init__(self, cfg, work_dir):
         from opensportslib.core.utils.lightning import CustomProgressBar, MyCallback
         import pytorch_lightning as pl
+        from pytorch_lightning.loggers import WandbLogger
+        import wandb
+
+        wandb_logger = None
+        if wandb.run is not None:  # means init_wandb already ran
+            wandb_logger = WandbLogger(experiment=wandb.run)
 
         self.work_dir = work_dir
         call = MyCallback()
         self.trainer = pl.Trainer(
-            max_epochs=cfg.max_epochs,
-            devices=[cfg.GPU],
+            logger=wandb_logger,
+            max_epochs=cfg.TRAIN.max_epochs,
+            devices=cfg.SYSTEM.GPU,
             callbacks=[call, CustomProgressBar(refresh_rate=1)],
             num_sanity_val_steps=0,
         )
+        self.best_checkpoint_path = None
 
     def train(self, **kwargs):
         self.trainer.fit(**kwargs)
@@ -177,10 +185,12 @@ class Trainer_pl(Trainer):
 
         logging.info("Done training")
         logging.info("Best epoch: {}".format(best_model.get("epoch")))
-        torch.save(best_model, os.path.join(self.work_dir, "model.pth.tar"))
+        best_path = os.path.join(self.work_dir, "model.pth.tar")
+        self.best_checkpoint_path = best_path
+        torch.save(best_model, best_path)
 
         logging.info("Model saved")
-        logging.info(os.path.join(self.work_dir, "model.pth.tar"))
+        logging.info(best_path)
 
 
 class Trainer_e2e(Trainer):
@@ -496,24 +506,25 @@ class Inferer:
         self.model = model
         self.infer_Spotting=infer_Spotting
 
-    def infer(self, cfg, data):
+    def infer(self, cfg, data, dataloader=None):
         """Infer actions from data.
 
         Args:
             data : The data from which we will infer.
+            dataloader : The dataloader for the test data.
 
         Returns:
             Dict containing predictions
         """
         if self.infer_Spotting=="infer_JSON":
-            return self.infer_JSON(cfg, self.model, data)
+            return self.infer_JSON(cfg, self.model, data, dataloader)
         elif self.infer_Spotting=="infer_SN":    
-            return self.infer_SN(cfg, self.model, data)
+            return self.infer_SN(cfg, self.model, data, dataloader)
         elif self.infer_Spotting=="infer_E2E":
-            return self.infer_E2E(cfg, self.model, data)
+            return self.infer_E2E(cfg, self.model, data, dataloader)
 
 
-    def infer_common(self, cfg, model, data):
+    def infer_common(self, cfg, model, data, dataloader=None):
         """Infer actions from data using a given model.
 
         Args:
@@ -525,10 +536,21 @@ class Inferer:
             Dict containing predictions
         """
         # Run Inference on Dataset
-        pass
+        from opensportslib.core.utils.lightning import CustomProgressBar, MyCallback
+        import pytorch_lightning as pl
+
+        if cfg.SYSTEM.work_dir is not None and dataloader is not None:
+            
+            evaluator = pl.Trainer(
+                callbacks=[CustomProgressBar()],
+                devices=cfg.SYSTEM.GPU,
+                num_sanity_val_steps=0,
+            )
+            evaluator.predict(model, dataloader)
+            return model.json_data
 
 
-    def infer_JSON(self, cfg, model, data):
+    def infer_JSON(self, cfg, model, data, dataloader=None):
         """Infer actions from data using a given model for NetVlad/CALF methods
 
         Args:
@@ -539,10 +561,10 @@ class Inferer:
         Returns:
             Dict containing predictions
         """
-        return self.infer_common(cfg, model, data)
+        return self.infer_common(cfg, model, data, dataloader)
 
 
-    def infer_SN(self, cfg, model, data):
+    def infer_SN(self, cfg, model, data, dataloader=None):
         """Infer actions from data using a given model for the SNV2 data
 
         Args:
@@ -553,10 +575,10 @@ class Inferer:
         Returns:
             Dict containing predictions
         """
-        return self.infer_common(cfg, model, data)
+        return self.infer_common(cfg, model, data, dataloader)
 
 
-    def infer_E2E(self, cfg, model, data):
+    def infer_E2E(self, cfg, model, data, dataloader=None):
         """Infer actions from data using a given model for the e2espot method.
 
         Args:
@@ -735,7 +757,6 @@ class Evaluator:
     
       
     def evaluate_common_JSON(self, cfg, results, metric):
-
         if cfg.path is None:
             return
 
@@ -756,6 +777,7 @@ class Evaluator:
 
         # detect v2 prediction
         pred_is_v2 = isinstance(pred_data, dict) and pred_data is not None and "data" in pred_data
+        print("PRED V2 :", pred_is_v2)
         # --------------------------------------------------
         # CLASSES
         # --------------------------------------------------
@@ -803,7 +825,7 @@ class Evaluator:
                 video_path = game["inputs"][0]["path"]
                 labels = [{"label": e.get("label"),  
                            "gameTime": e.get("gameTime"),
-                           "position": int(e.get("position_ms")),
+                           "position": int(e.get("position_ms", e.get("position"))),
                           } for e in game.get("events", [])]
             else:
                 video_path = game["path"]
@@ -825,7 +847,7 @@ class Evaluator:
                            "label": e.get("label"),  
                            "gameTime": e.get("gameTime"),
                            "confidence": e.get("confidence"),
-                           "position": int(e.get("position_ms")),
+                           "position": int(e.get("position_ms", e.get("position"))),
                            "frame": e.get("frame")
                         }
                         for e in item.get("events", [])
@@ -859,7 +881,7 @@ class Evaluator:
                            "label": e.get("label"),  
                            "gameTime": e.get("gameTime"),
                            "confidence": e.get("confidence"),
-                           "position": int(e.get("position_ms")),
+                           "position": int(e.get("position_ms", e.get("position"))),
                            "frame": e.get("frame")
                         }
                         for e in item.get("events", [])
@@ -997,7 +1019,8 @@ class Evaluator:
         Returns
             The different mAPs computed.
         """
-
+        from SoccerNet.Evaluation.utils import INVERSE_EVENT_DICTIONARY_V2
+        from SoccerNet.Evaluation.ActionSpotting import evaluate
         # challenge sets to be tested on EvalAI
         if "challenge" in cfg.split:
             print("Visit eval.ai to evaluate performances on Challenge set")

{opensportslib-0.0.1.dev16 → opensportslib-0.0.1.dev18}/opensportslib/core/utils/load_annotations.py

@@ -536,4 +536,34 @@ def check_config(cfg, split="train"):
             classes = cfg.DATA.classes
         
         #print(classes)
-        cfg.DATA.classes = load_classes(classes)
+        cfg.DATA.classes = load_classes(classes)
+
+
+def whether_infer_split(cfg):
+    """Given a config dict, check whether we want to infer a split or a single element (can be a game, video or feature file)/
+
+    Args:
+        cfg (dict): Config dict.
+
+    Returns:
+        bool : True if we infer split, false otherwise. Raises an error if the input is not expected.
+    """
+    if cfg.type == "SoccerNetGames" or cfg.type == "SoccerNetClipsTestingCALF":
+        if cfg.split == None:
+            return False
+        else:
+            return True
+    elif (
+        cfg.type == "FeatureVideosfromJSON" or cfg.type == "FeatureVideosChunksfromJson"
+    ):
+        if cfg.path.endswith(".json"):
+            return True
+        else:
+            return False
+    elif cfg.type == "VideoGameWithOpencvVideo" or cfg.type == "VideoGameWithDaliVideo":
+        if cfg.path.endswith(".json"):
+            return True
+        else:
+            return False
+    else:
+        raise ValueError(f"Unknown dataset type {cfg.type}")

{opensportslib-0.0.1.dev16 → opensportslib-0.0.1.dev18}/opensportslib/core/utils/wandb.py

@@ -2,6 +2,7 @@ import wandb
 import matplotlib.pyplot as plt
 import numpy as np
 import logging
+import os
 
 def init_wandb(cfg, run_id, use_wandb=False):
     """
@@ -24,6 +25,15 @@ def init_wandb(cfg, run_id, use_wandb=False):
         logging.warning("wandb not installed. Install with `pip install wandb`.")
         return None
 
+    # Prevent multiple processes from initializing wandb
+    rank = int(os.environ.get("RANK", os.environ.get("LOCAL_RANK", 0)))
+    if rank != 0:
+        return None
+
+    # Prevent re-initialization
+    if wandb.run is not None:
+        return wandb
+
     if getattr(cfg.DATA, "data_modality", None):
         run_name = f"{cfg.MODEL.backbone.type}_{cfg.DATA.data_modality}"
     else:

{opensportslib-0.0.1.dev16 → opensportslib-0.0.1.dev18}/opensportslib/datasets/localization_dataset.py

@@ -29,7 +29,6 @@ try:
     DALI_AVAILABLE = True
 
 except ImportError:
-    print("NO DALI")
     DALI_AVAILABLE = False
     # Optional: placeholders (prevents NameError)
     pipeline_def = None
@@ -67,7 +66,6 @@ class LocalizationDataset(Dataset):
 
     
     def building_dataset(self, cfg, gpu=None, default_args=None):
-        print(cfg)
         if cfg.type == "SoccerNetClips" or cfg.type == "SoccerNetGames":
             if cfg.split == None:
                 dataset = SoccerNetGameClips(
@@ -1576,7 +1574,8 @@ class FeaturefromJson(Dataset):
                 with open(single_path) as f:
                     tmp = json.load(f)
                     self.data_json.append(tmp)
-                    self.classes.append(tmp["labels"])
+                    for task_name, task_data in tmp["labels"].items():
+                        self.classes.append(task_data.get("labels", {}))
             assert all(x == self.classes[0] for x in self.classes) == True
             self.classes = self.classes[0]
 
@@ -1588,15 +1587,19 @@ class FeaturefromJson(Dataset):
                 with open(path) as f:
                     tmp = json.load(f)
                     self.data_json = [tmp]
-                self.classes = tmp["labels"]
+                
+                for task_name, task_data in tmp["labels"].items():
+                    self.classes = task_data.get("labels", {})
             else:
                 self.is_json = False
                 self.data_json = [
                     {
-                        "videos": [
+                        "data": [
                             {
-                                "path": path,
-                                "annotations": [],
+                                "inputs": [{
+                                    "path": path
+                                }],
+                                "events": [],
                             }
                         ]
                     }
@@ -1608,6 +1611,7 @@ class FeaturefromJson(Dataset):
                     self.classes = load_text(self.classes)
 
         self.num_classes = len(self.classes)
+        print(self.num_classes)
         self.event_dictionary = {cls: i_cls for i_cls, cls in enumerate(self.classes)}
         self.inverse_event_dictionary = {
             i_cls: cls for i_cls, cls in enumerate(self.classes)
@@ -1633,8 +1637,8 @@ class FeaturefromJson(Dataset):
         # time = annotation["gameTime"]
         event = annotation["label"]
 
-        if "position" in annotation.keys():
-            frame = int(self.framerate * (int(annotation["position"]) / 1000))
+        if "position_ms" in annotation.keys():
+            frame = int(self.framerate * (int(annotation["position_ms"]) / 1000))
         else:
             time = annotation["gameTime"]
 
@@ -1685,11 +1689,11 @@ class FeatureClipsfromJSON(FeaturefromJson):
                 else:
                     logging.info("Processing " + path)
                 # loop over videos
-                for video in tqdm.tqdm(single_data_json["videos"]):
+                for video in tqdm.tqdm(single_data_json["data"]):
                     # for video in tqdm(self.data_json["videos"]):
                     # Load features
                     features = np.load(
-                        os.path.join(self.features_dir[i], video["path"])
+                        os.path.join(self.features_dir[i], video["inputs"][0]["path"])
                     )
                     features = features.reshape(-1, features.shape[-1])
 
@@ -1705,7 +1709,7 @@ class FeatureClipsfromJSON(FeaturefromJson):
                     labels[:, 0] = 1  # those are BG classes
 
                     # loop annotation for that video
-                    for annotation in video["annotations"]:
+                    for annotation in video.get("events", []):
 
                         label, frame, cont = self.annotation(annotation)
 
@@ -1743,20 +1747,20 @@ class FeatureClipsfromJSON(FeaturefromJson):
         if self.train:
             return self.features_clips[index, :, :], self.labels_clips[index, :]
         else:
-            video = self.data_json[0]["videos"][index]
-
+            video = self.data_json[0]["data"][index]
+            video_path = video["inputs"][0]["path"]
             # Load features
             if self.is_json:
-                features = np.load(os.path.join(self.features_dir[0], video["path"]))
+                features = np.load(os.path.join(self.features_dir[0], video_path))
             else:
-                features = np.load(os.path.join(video["path"]))
+                features = np.load(os.path.join(video_path))
             features = features.reshape(-1, features.shape[-1])
 
             # Load labels
             labels = np.zeros((features.shape[0], self.num_classes))
 
-            if "annotations" in video.keys():
-                for annotation in video["annotations"]:
+            if "events" in video.keys():
+                for annotation in video.get("events", []):
 
                     label, frame, cont = self.annotation(annotation)
 
@@ -1773,13 +1777,13 @@ class FeatureClipsfromJSON(FeaturefromJson):
                 clip_length=self.window_size_frame,
             )
 
-            return video["path"], features, labels
+            return video_path, features, labels
 
     def __len__(self):
         if self.train:
             return len(self.features_clips)
         else:
-            return len(self.data_json[0]["videos"])
+            return len(self.data_json[0]["data"])
 
 
 class FeatureClipChunksfromJson(FeaturefromJson):
@@ -1844,18 +1848,18 @@ class FeatureClipChunksfromJson(FeaturefromJson):
                 else:
                     logging.info("Processing " + path)
                 # loop over videos
-                for video in tqdm.tqdm(single_data_json["videos"]):
+                for video in tqdm.tqdm(single_data_json["data"]):
                     # for video in tqdm(self.data_json["videos"]):
                     # Load features
                     features = np.load(
-                        os.path.join(self.features_dir[i], video["path"])
+                        os.path.join(self.features_dir[i], video["inputs"][0]["path"])
                     )
 
                     # Load labels
                     labels = np.zeros((features.shape[0], self.num_classes))
 
                     # loop annotation for that video
-                    for annotation in video["annotations"]:
+                    for annotation in video.get("events", []):
 
                         label, frame, cont = self.annotation(annotation)
 
@@ -1938,19 +1942,19 @@ class FeatureClipChunksfromJson(FeaturefromJson):
                 torch.from_numpy(clip_targets),
             )
         else:
-            video = self.data_json[0]["videos"][index]
-
+            video = self.data_json[0]["data"][index]
+            video_path = video["inputs"][0]["path"]
             # Load features
             if self.is_json:
-                features = np.load(os.path.join(self.features_dir[0], video["path"]))
+                features = np.load(os.path.join(self.features_dir[0], video_path))
             else:
-                features = np.load(os.path.join(video["path"]))
+                features = np.load(os.path.join(video_path))
 
             # Load labels
             labels = np.zeros((features.shape[0], self.num_classes))
 
             if "annotations" in video.keys():
-                for annotation in video["annotations"]:
+                for annotation in video.get("events",[]):
 
                     label, frame, cont = self.annotation(annotation)
                     if cont:
@@ -1977,7 +1981,7 @@ class FeatureClipChunksfromJson(FeaturefromJson):
         if self.train:
             return self.chunks_per_epoch
         else:
-            return len(self.data_json[0]["videos"])
+            return len(self.data_json[0]["data"])
 
 
 

{opensportslib-0.0.1.dev16 → opensportslib-0.0.1.dev18}/opensportslib/metrics/localization_metric.py

@@ -880,9 +880,9 @@ def label2vector(
 
         else:
             time = annotation["gameTime"]
-
-            minutes = int(time[-5:-3])
-            seconds = int(time[-2::])
+            if time is not None:
+                minutes = int(time[-5:-3])
+                seconds = int(time[-2::])
             # annotation at millisecond precision
             if "position" in annotation:
                 frame = int(framerate * (int(annotation["position"]) / 1000))
@@ -931,7 +931,7 @@ def predictions2vector(
 
         event = annotation["label"]
 
-        if "frame" in annotation:
+        if "frame" in annotation and annotation["frame"] is not None:
             frame = int(annotation["frame"])
         else:
             time = int(annotation["position"])