opensportslib 0.0.1.dev15__tar.gz → 0.0.1.dev16__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: opensportslib
-Version: 0.0.1.dev15
+Version: 0.0.1.dev16
 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
@@ -21,6 +21,7 @@ Requires-Dist: wandb
 Requires-Dist: opencv-python
 Requires-Dist: omegaconf
 Requires-Dist: timm
+Requires-Dist: seaborn
 Provides-Extra: localization
 Requires-Dist: nvidia-dali-cuda120; extra == "localization"
 Requires-Dist: cupy-cuda12x; extra == "localization"

opensportslib-0.0.1.dev15/opensportslib/config/sngar_frames.yaml → opensportslib-0.0.1.dev16/opensportslib/config/sngar-frames.yaml

@@ -1,29 +1,36 @@
 TASK: classification
+# this is the config for classification task on sngar-frames dataset.
+# this config is used for the main experiments reported in the paper:
+# "Pixels or Positions? Benchmarking Modalities in Group Activity Recognition"
+# https://arxiv.org/abs/2511.12606
+# videomaev2 - fully finetuned on the sngar-frames dataset.
+# it has all the hyperparameters value used to reproduce the results reported in the paper.
 
 DATA:
   dataset_name: sngar
   data_dir: /home/spark_user1/opensportslib/sngar-frames
   data_modality: frames_npy
-  max_samples: 100
+  # max_samples: 100 # only used for quick testing
   num_frames: 16
   frame_size: [224, 224]
   train:
     path: ${DATA.data_dir}/annotations_train.json
     dataloader:
-      batch_size: 64
+      batch_size: 8 # for frozen backbone, use 64
+      # for unfrozen backbone, use 32-16-8 depending on the memory available
       shuffle: true
       num_workers: 8
       pin_memory: true
   valid:
     path: ${DATA.data_dir}/annotations_valid.json
     dataloader:
-      batch_size: 64
+      batch_size: 8
       num_workers: 8
       shuffle: false
   test:
     path: ${DATA.data_dir}/annotations_test.json
     dataloader:
-      batch_size: 64
+      batch_size: 8
       num_workers: 8
       shuffle: false
   augmentations:
@@ -32,15 +39,18 @@ DATA:
     color_jitter: true
     jitter_prob: 0.5
     jitter_params: [0.2, 0.2, 0.2, 0.1]
+  data_slicing: # only used for data scaling experiments
+    enabled: false
+    training_matches: 45  # default: all 45 training matches
 
 MODEL:
   type: custom
   backbone:
-    type: dinov3                  # dinov3 | clip | videomae | videomae2
-    pretrained_model: facebook/dinov3-vitb16-pretrain-lvd1689m
-    # facebook/dinov3-vitb16-pretrain-lvd1689m | openai/clip-vit-base-patch16 | MCG-NJU/videomae-base | OpenGVLab/VideoMAEv2-Base
+    type: videomae2                  # dinov3 | videomae | videomae2
+    pretrained_model: OpenGVLab/VideoMAEv2-Base
+    # facebook/dinov3-vitb16-pretrain-lvd1689m | MCG-NJU/videomae-base | OpenGVLab/VideoMAEv2-Base
     hidden_dim: 768
-    freeze: true
+    freeze: false # true for frozen backbone, false for unfrozen backbone i.e. full-finetuning
     unfreeze_last_n_layers: 0     # 0 = frozen backbone, >0 = unfreeze last N layers
   neck:
     type: TemporalAggregation
@@ -56,12 +66,12 @@ MODEL:
     dropout: 0.1
 
 TRAIN:
-  monitor: balanced_accuracy
-  mode: max
+  monitor: loss # balanced_accuracy, loss
+  mode: min # max or min
   enabled: true
   use_amp: true
   mixup_alpha: 0.2
-  use_weighted_sampler: false
+  use_weighted_sampler: true
   samples_per_class: 4000
   use_weighted_loss: false
   epochs: 100
@@ -75,7 +85,7 @@ TRAIN:
 
   optimizer:
     type: AdamW
-    lr: 0.0001
+    lr: 0.00005 # tune lr based on the backbone
     betas: [0.9, 0.999]
     eps: 0.0000001
     weight_decay: 0.0001

opensportslib-0.0.1.dev15/opensportslib/config/classification_tracking.yaml → opensportslib-0.0.1.dev16/opensportslib/config/sngar-tracking.yaml

@@ -1,9 +1,15 @@
 TASK: classification
+# this is the config for classification task on sngar-tracking dataset.
+# this config is used for the main experiments reported in the paper:
+# "Pixels or Positions? Benchmarking Modalities in Group Activity Recognition"
+# https://arxiv.org/abs/2511.12606
+# this is used to train our baseline model that is GIN backbone + Maxpool temporal aggregation + positional edges.
+# it has all the hyperparameters value used to reproduce the results reported in the paper.
 
 DATA:
   dataset_name: sngar
   data_modality: tracking_parquet
-  data_dir: /home/karkid/opensportslib/sngar-tracking
+  data_dir: /home/karkid/opensportslib/tracking-dataset
   preload_data: false
   train: 
     type: annotations_train.json
@@ -43,12 +49,15 @@ DATA:
   pitch_half_width: 50.0
   max_displacement: 110.0
   max_ball_height: 30.0
+  data_slicing: # only used for data scaling experiments
+    enabled: false
+    training_matches: 45  # default: all 45 training matches
 
 MODEL:
   type: custom
   backbone:
     type: graph_conv
-    encoder: graphconv
+    encoder: gin
     hidden_dim: 64
     num_layers: 20
     dropout: 0.1
@@ -74,7 +83,7 @@ TRAIN:
   use_weighted_sampler: true
   use_weighted_loss: false
   samples_per_class: 4000
-  epochs: 10
+  epochs: 100
   patience: 10
   save_every: 20
   detailed_results: true

{opensportslib-0.0.1.dev15 → opensportslib-0.0.1.dev16}/opensportslib/core/trainer/classification_trainer.py

@@ -685,7 +685,7 @@ class FramesTrainerClassification(BaseTrainerClassification):
                 self.scaler.step(self.optimizer)
                 self.scaler.update()
 
-        return logits, labels, loss
+        return logits, labels, loss, True
 
 # --------------------------------------------------------------
 # unified trainer dispatcher 

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

@@ -9,11 +9,51 @@ from opensportslib.core.utils.video_processing import get_stride, read_fps, get_
 from opensportslib.core.utils.config import load_json
 from collections import defaultdict
 
-def load_annotations(annotations_path, task_key="action", exclude_labels=[""], multiview=False, input_type="video", allow_missing_labels=False):
+def load_annotations(
+    annotations_path,
+    task_key="action",
+    exclude_labels=None,
+    multiview=False,
+    input_type="video",
+    allow_missing_labels=False,
+    max_games=None
+):
 
     with open(annotations_path, "r") as f:
         data = json.load(f)
 
+    # this is used for data slicing experiments.
+    # and doesn't affect the validation and test sets.
+    # if you haven't added "data_scaling" to the config, this will be ignored.
+    if max_games is not None:
+        all_game_ids = sorted(set(
+            item.get("metadata", {}).get("game_id", "")
+            for item in data["data"]
+        )) 
+
+        # remove empty string if any items lack game_id
+        all_game_ids = [g for g in all_game_ids if g]
+
+        # warn if any items lack game_id
+        items_without_game_id = sum(
+            1 for item in data["data"]
+            if not item.get("metadata", {}).get("game_id", "")
+        )
+        if items_without_game_id > 0:
+            print(f"warning: {items_without_game_id}/{len(data['data'])} items have "
+                  f"no game_id, these will not be affected by data slicing")
+
+        if max_games < len(all_game_ids):
+            keep_ids = set(all_game_ids[:max_games])
+            original_count = len(data["data"])
+            data["data"] = [
+                item for item in data["data"]
+                if item.get("metadata", {}).get("game_id", "") in keep_ids
+            ]
+            print(f"data slicing: {max_games}/{len(all_game_ids)} games, "
+                  f"{len(data['data'])}/{original_count} samples retained")
+    # ----- data slicing ends here -----
+
     exclude_labels = set(exclude_labels or [""])
 
     # Label list for the selected task

{opensportslib-0.0.1.dev15 → opensportslib-0.0.1.dev16}/opensportslib/datasets/classification_dataset.py

@@ -81,14 +81,35 @@ class ClassificationDataset(Dataset):
 
         allow_missing_labels = split in ["test", "infer"]
 
+        # these lines of code are used for data scaling experiments.
+        # if you want to check how the model performance changes with different 
+        # number of games in the training set, you can use this code.
+        # to use this, you need to add the following to the config:
+        # DATA:
+        #   data_slicing:
+        #     enabled: true
+        #     training_matches: <number of games to include in the training set>
+        # we will refer to this as "data slicing" in the rest of the code.
+        max_games = None
+        slicing_cfg = getattr(config.DATA, "data_slicing", None)
+        if slicing_cfg and getattr(slicing_cfg, "enabled", False) and split == "train":
+            max_games = getattr(slicing_cfg, "training_matches", None)
+
         self.samples, self.label_map = load_annotations(
             annotations_path, 
             exclude_labels=self.exclude_labels, 
             multiview=is_multiview,
             input_type=config.DATA.data_modality,
-            allow_missing_labels=allow_missing_labels
+            allow_missing_labels=allow_missing_labels,
+            max_games=max_games
         )
 
+        # this is used for quick testing of the model.
+        # we can only use a small subset of data (ideally 100 samples) to 
+        # test the overall integration quickly.
+        # to use this, you need to add the following to the config:
+        # DATA:
+        #   max_samples: <number of samples to include in the training set>
         max_samples = getattr(config.DATA, 'max_samples', None)
         if max_samples:
             self.samples = self.samples[:max_samples]
@@ -320,7 +341,7 @@ class TrackingDataset(ClassificationDataset):
     """
         
     def __init__(self, config, annotations_path, split="train"):
-        super().__init__(config, annotations_path, split)
+        super().__init__(config, annotations_path, processor=None, split=split)
 
         from opensportslib.datasets.utils.tracking import (
             FEATURE_DIM,
@@ -576,7 +597,7 @@ class TrackingDataset(ClassificationDataset):
             "seq_len": len(graphs),
             "id": item["id"]
         }
-        if "label" in label:
+        if label is not None:
             out["label"] = label
         return out
         

{opensportslib-0.0.1.dev15 → opensportslib-0.0.1.dev16}/opensportslib/metrics/classification_metric.py

@@ -82,14 +82,26 @@ def compute_detailed_classification_metrics(all_logits, all_labels, class_names,
 
     preds = np.argmax(all_logits, axis=-1)
 
-    sorted_class_names = sorted(class_names.values())
-    name_to_sorted_idx = {name: i for i, name in enumerate(sorted_class_names)}
     idx_to_name = class_names
 
-    sorted_labels = np.array([name_to_sorted_idx[idx_to_name[l]] for l in all_labels])
-    sorted_preds = np.array([name_to_sorted_idx[idx_to_name[p]] for p in preds])
+    # count samples per class from true labels to order by frequency
+    from collections import Counter
+    label_counts = Counter(all_labels)
+    # map from class index to name, then sort by count descending
+    all_class_names = list(class_names.values())
+    name_to_original_idx = {v: k for k, v in class_names.items()}
+    ordered_class_names = sorted(
+        all_class_names,
+        key=lambda name: label_counts.get(name_to_original_idx[name], 0),
+        reverse=True
+    )
 
-    all_class_labels = list(range(len(sorted_class_names)))
+    name_to_ordered_idx = {name: i for i, name in enumerate(ordered_class_names)}
+
+    sorted_labels = np.array([name_to_ordered_idx[idx_to_name[l]] for l in all_labels])
+    sorted_preds = np.array([name_to_ordered_idx[idx_to_name[p]] for p in preds])
+
+    all_class_labels = list(range(len(ordered_class_names)))
 
     cm = confusion_matrix(sorted_labels, sorted_preds, labels=all_class_labels)
     per_class_accuracy = np.diag(cm) / np.maximum(cm.sum(axis=1), 1) * 100
@@ -104,14 +116,14 @@ def compute_detailed_classification_metrics(all_logits, all_labels, class_names,
     import os
 
     plt.figure(figsize=(12, 10))
-    sns.heatmap(cm, annot=True, fmt="d", cmap="Blues", 
-                xticklabels=sorted_class_names, yticklabels=sorted_class_names)
+    sns.heatmap(cm, annot=True, fmt="d", cmap="Blues",
+                xticklabels=ordered_class_names, yticklabels=ordered_class_names)
     plt.title(f'Confusion Matrix ({set_name})')
     plt.ylabel('True Label')
     plt.xlabel('Predicted Label')
     plt.xticks(rotation=45, ha='right')
     plt.tight_layout()
-    
+
     plots_dir = os.path.join(save_dir, 'plots')
     os.makedirs(plots_dir, exist_ok=True)
     plt.savefig(os.path.join(plots_dir, f'confusion_matrix_{set_name}.png'), dpi=300, bbox_inches='tight')
@@ -119,14 +131,14 @@ def compute_detailed_classification_metrics(all_logits, all_labels, class_names,
 
     results_dir = os.path.join(save_dir, 'results')
     os.makedirs(results_dir, exist_ok=True)
-    
+
     report_path = os.path.join(results_dir, f'{set_name}_detailed_metrics.txt')
     with open(report_path, 'w') as f:
         f.write(f"Balanced Accuracy: {balanced_acc:.2f}%\n")
         f.write(f"Macro F1:          {macro_f1:.2f}%\n\n")
         f.write(f"{'Class':<30} {'Accuracy':>10} {'F1':>10} {'Samples':>10}\n")
         f.write("-" * 65 + "\n")
-        for i, class_name in enumerate(sorted_class_names):
+        for i, class_name in enumerate(ordered_class_names):
             num_samples = int(cm[i].sum())
             f.write(f"{class_name:<30} {per_class_accuracy[i]:>9.2f}% {per_class_f1[i]:>9.2f}% {num_samples:>10}\n")
         f.write("-" * 65 + "\n\n")
@@ -134,43 +146,48 @@ def compute_detailed_classification_metrics(all_logits, all_labels, class_names,
         f.write(classification_report(
             sorted_labels, sorted_preds,
             labels=all_class_labels,
-            target_names=sorted_class_names,
+            target_names=ordered_class_names,
             zero_division=0
         ))
         f.write("\n" + "-" * 65 + "\n\n")
         f.write("Confusion Matrix:\n\n")
         f.write(f"{cm}\n")
-    
+
     tsv_path = os.path.join(results_dir, f'{set_name}_results.tsv')
     with open(tsv_path, 'w') as f:
-        header = "metric\t" + "\t".join(sorted_class_names) + "\toverall"
+        header = "metric\toverall\t" + "\t".join(ordered_class_names)
         f.write(header + "\n")
 
-        acc_row = "accuracy\t" + "\t".join(f"{per_class_accuracy[i]:.2f}" for i in range(len(sorted_class_names))) + f"\t{balanced_acc:.2f}"
+        acc_row = "accuracy\t" + f"{balanced_acc:.2f}\t" + "\t".join(f"{per_class_accuracy[i]:.2f}" for i in range(len(ordered_class_names)))
         f.write(acc_row + "\n")
 
-        f1_row = "f1\t" + "\t".join(f"{per_class_f1[i]:.2f}" for i in range(len(sorted_class_names))) + f"\t{macro_f1:.2f}"
+        f1_row = "f1\t" + f"{macro_f1:.2f}\t" + "\t".join(f"{per_class_f1[i]:.2f}" for i in range(len(ordered_class_names)))
         f.write(f1_row + "\n")
 
-        samples_row = "samples\t" + "\t".join(str(int(cm[i].sum())) for i in range(len(sorted_class_names))) + f"\t{int(cm.sum())}"
+        samples_row = "samples\t" + f"{int(cm.sum())}\t" + "\t".join(str(int(cm[i].sum())) for i in range(len(ordered_class_names)))
         f.write(samples_row + "\n")
 
+        f.write("\n\nConfusion Matrix\n")
+        f.write("True \\ Predicted\t" + "\t".join(ordered_class_names) + "\n")
+        for i, name in enumerate(ordered_class_names):
+            row = name + "\t" + "\t".join(str(cm[i][j]) for j in range(len(ordered_class_names)))
+            f.write(row + "\n")
+
     print(f"Saved TSV to {tsv_path}")
-    
+
     print(f"\nSaved detailed metrics to {report_path}")
     print(f"\nBalanced Accuracy: {balanced_acc:.2f}%")
     print(f"Macro F1:          {macro_f1:.2f}%\n")
     print(f"{'Class':<30} {'Accuracy':>10} {'F1':>10} {'Samples':>10}")
     print("-" * 65)
-    for i, class_name in enumerate(sorted_class_names):
+    for i, class_name in enumerate(ordered_class_names):
         num_samples = int(cm[i].sum())
         print(f"{class_name:<30} {per_class_accuracy[i]:>9.2f}% {per_class_f1[i]:>9.2f}% {num_samples:>10}")
     print("-" * 65)
-    
+
     return {
         "balanced_accuracy": balanced_acc,
         "macro_f1": macro_f1,
-        "per_class_accuracy": {name: per_class_accuracy[i] for i, name in enumerate(sorted_class_names)},
-        "per_class_f1": {name: per_class_f1[i] for i, name in enumerate(sorted_class_names)},
-    }
-    
+        "per_class_accuracy": {name: per_class_accuracy[i] for i, name in enumerate(ordered_class_names)},
+        "per_class_f1": {name: per_class_f1[i] for i, name in enumerate(ordered_class_names)},
+    }    

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: opensportslib
-Version: 0.0.1.dev15
+Version: 0.0.1.dev16
 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
@@ -21,6 +21,7 @@ Requires-Dist: wandb
 Requires-Dist: opencv-python
 Requires-Dist: omegaconf
 Requires-Dist: timm
+Requires-Dist: seaborn
 Provides-Extra: localization
 Requires-Dist: nvidia-dali-cuda120; extra == "localization"
 Requires-Dist: cupy-cuda12x; extra == "localization"

{opensportslib-0.0.1.dev15 → opensportslib-0.0.1.dev16}/opensportslib.egg-info/SOURCES.txt

@@ -15,16 +15,10 @@ opensportslib/apis/__init__.py
 opensportslib/apis/classification.py
 opensportslib/apis/localization.py
 opensportslib/config/classification.yaml
-opensportslib/config/classification_tracking.yaml
 opensportslib/config/localization-e2e-ocv.yaml
 opensportslib/config/localization.yaml
-opensportslib/config/sngar_frames.yaml
-opensportslib/config/graph_tracking_classification/avgpool.yaml
-opensportslib/config/graph_tracking_classification/gin.yaml
-opensportslib/config/graph_tracking_classification/graphconv.yaml
-opensportslib/config/graph_tracking_classification/graphsage.yaml
-opensportslib/config/graph_tracking_classification/maxpool.yaml
-opensportslib/config/graph_tracking_classification/noedges.yaml
+opensportslib/config/sngar-frames.yaml
+opensportslib/config/sngar-tracking.yaml
 opensportslib/core/__init__.py
 opensportslib/core/loss/__init__.py
 opensportslib/core/loss/builder.py

{opensportslib-0.0.1.dev15 → opensportslib-0.0.1.dev16}/opensportslib.egg-info/requires.txt

@@ -11,6 +11,7 @@ wandb
 opencv-python
 omegaconf
 timm
+seaborn
 
 [:platform_system != "Darwin" and platform_machine != "arm64"]
 decord

{opensportslib-0.0.1.dev15 → opensportslib-0.0.1.dev16}/pyproject.toml

@@ -4,11 +4,11 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "opensportslib"
-version = "0.0.1.dev15"
+version = "0.0.1.dev16"
 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"
-dependencies = [ "SoccerNet", "av", "decord; platform_system != 'Darwin' and platform_machine != 'arm64'", "evaluate", "scikit-learn", "torch", "torchvision", "transformers==4.57.3", "tokenizers==0.22.1", "accelerate", "wandb", "opencv-python", "omegaconf", "timm",]
+dependencies = [ "SoccerNet", "av", "decord; platform_system != 'Darwin' and platform_machine != 'arm64'", "evaluate", "scikit-learn", "torch", "torchvision", "transformers==4.57.3", "tokenizers==0.22.1", "accelerate", "wandb", "opencv-python", "omegaconf", "timm", "seaborn",]
 [[project.authors]]
 name = "Jeet Vora"
 

opensportslib-0.0.1.dev15/opensportslib/config/graph_tracking_classification/avgpool.yaml

@@ -1,79 +0,0 @@
-TASK: classification
-
-DATA:
-  dataset_name: sngar
-  data_modality: tracking_parquet
-  data_dir: /home/karkid/temporal-localization/data/tracking_dataset
-  preload_data: false
-  annotations:
-    train: /home/karkid/temporal-localization/data/tracking_dataset/train/train.json
-    valid: /home/karkid/temporal-localization/data/tracking_dataset/valid/valid.json
-    test: /home/karkid/temporal-localization/data/tracking_dataset/test/test.json
-  num_frames: 16
-  frame_interval: 9
-  augmentations:
-    vertical_flip: true
-    horizontal_flip: true
-    team_flip: true
-  normalize: true
-  num_workers: 20
-  train_batch_size: 32
-  valid_batch_size: 32
-  num_objects: 23
-  feature_dim: 8
-  pitch_half_length: 85.0
-  pitch_half_width: 50.0
-  max_displacement: 110.0
-  max_ball_height: 30.0
-
-MODEL:
-  type: custom
-  backbone:
-    type: graph_conv
-    encoder: gin
-    hidden_dim: 64
-    num_layers: 20
-    dropout: 0.1
-  neck:
-    type: TemporalAggregation
-    agr_type: avgpool
-    hidden_dim: 64
-    dropout: 0.1
-  head:
-    type: TrackingClassifier
-    hidden_dim: 64
-    dropout: 0.1
-    num_classes: 10
-  edge: positional
-  k: 8
-
-TRAIN:
-  enabled: true
-  use_weighted_sampler: true
-  use_weighted_loss: false
-  samples_per_class: 4000
-  epochs: 100
-  patience: 10
-  save_every: 20
-
-  optimizer:
-    type: Adam
-    lr: 0.001
-
-  scheduler:
-    type: ReduceLROnPlateau
-    mode: min
-    patience: 10
-    factor: 0.1
-    min_lr: 1e-8
-  
-  criterion:
-    type: CrossEntropyLoss
-
-  save_dir: ./checkpoints_tracking
-
-SYSTEM:
-  log_dir: ./logs
-  seed: 42
-  device: cuda
-  gpu_id: 0

opensportslib-0.0.1.dev15/opensportslib/config/graph_tracking_classification/gin.yaml

@@ -1,79 +0,0 @@
-TASK: classification
-
-DATA:
-  dataset_name: sngar
-  data_modality: tracking_parquet
-  data_dir: /home/karkid/temporal-localization/data/tracking_dataset
-  preload_data: false
-  annotations:
-    train: /home/karkid/temporal-localization/data/tracking_dataset/train/train.json
-    valid: /home/karkid/temporal-localization/data/tracking_dataset/valid/valid.json
-    test: /home/karkid/temporal-localization/data/tracking_dataset/test/test.json
-  num_frames: 16
-  frame_interval: 9
-  augmentations:
-    vertical_flip: true
-    horizontal_flip: true
-    team_flip: true
-  normalize: true
-  num_workers: 20
-  train_batch_size: 32
-  valid_batch_size: 32
-  num_objects: 23
-  feature_dim: 8
-  pitch_half_length: 85.0
-  pitch_half_width: 50.0
-  max_displacement: 110.0
-  max_ball_height: 30.0
-
-MODEL:
-  type: custom
-  backbone:
-    type: graph_conv
-    encoder: gin
-    hidden_dim: 64
-    num_layers: 20
-    dropout: 0.1
-  neck:
-    type: TemporalAggregation
-    agr_type: maxpool
-    hidden_dim: 64
-    dropout: 0.1
-  head:
-    type: TrackingClassifier
-    hidden_dim: 64
-    dropout: 0.1
-    num_classes: 10
-  edge: positional
-  k: 8
-
-TRAIN:
-  enabled: true
-  use_weighted_sampler: true
-  use_weighted_loss: false
-  samples_per_class: 4000
-  epochs: 100
-  patience: 10
-  save_every: 20
-
-  optimizer:
-    type: Adam
-    lr: 0.001
-
-  scheduler:
-    type: ReduceLROnPlateau
-    mode: min
-    patience: 10
-    factor: 0.1
-    min_lr: 1e-8
-  
-  criterion:
-    type: CrossEntropyLoss
-
-  save_dir: ./checkpoints_tracking
-
-SYSTEM:
-  log_dir: ./logs
-  seed: 42
-  device: cuda
-  gpu_id: 0

opensportslib-0.0.1.dev15/opensportslib/config/graph_tracking_classification/graphconv.yaml

@@ -1,79 +0,0 @@
-TASK: classification
-
-DATA:
-  dataset_name: sngar
-  data_modality: tracking_parquet
-  data_dir: /home/karkid/temporal-localization/data/tracking_dataset
-  preload_data: false
-  annotations:
-    train: /home/karkid/temporal-localization/data/tracking_dataset/train/train.json
-    valid: /home/karkid/temporal-localization/data/tracking_dataset/valid/valid.json
-    test: /home/karkid/temporal-localization/data/tracking_dataset/test/test.json
-  num_frames: 16
-  frame_interval: 9
-  augmentations:
-    vertical_flip: true
-    horizontal_flip: true
-    team_flip: true
-  normalize: true
-  num_workers: 20
-  train_batch_size: 32
-  valid_batch_size: 32
-  num_objects: 23
-  feature_dim: 8
-  pitch_half_length: 85.0
-  pitch_half_width: 50.0
-  max_displacement: 110.0
-  max_ball_height: 30.0
-
-MODEL:
-  type: custom
-  backbone:
-    type: graph_conv
-    encoder: graphconv
-    hidden_dim: 64
-    num_layers: 20
-    dropout: 0.1
-  neck:
-    type: TemporalAggregation
-    agr_type: maxpool
-    hidden_dim: 64
-    dropout: 0.1
-  head:
-    type: TrackingClassifier
-    hidden_dim: 64
-    dropout: 0.1
-    num_classes: 10
-  edge: positional
-  k: 8
-
-TRAIN:
-  enabled: true
-  use_weighted_sampler: true
-  use_weighted_loss: false
-  samples_per_class: 4000
-  epochs: 100
-  patience: 10
-  save_every: 20
-
-  optimizer:
-    type: Adam
-    lr: 0.001
-
-  scheduler:
-    type: ReduceLROnPlateau
-    mode: min
-    patience: 10
-    factor: 0.1
-    min_lr: 1e-8
-  
-  criterion:
-    type: CrossEntropyLoss
-
-  save_dir: ./checkpoints_tracking
-
-SYSTEM:
-  log_dir: ./logs
-  seed: 42
-  device: cuda
-  gpu_id: 0

opensportslib-0.0.1.dev15/opensportslib/config/graph_tracking_classification/graphsage.yaml

@@ -1,79 +0,0 @@
-TASK: classification
-
-DATA:
-  dataset_name: sngar
-  data_modality: tracking_parquet
-  data_dir: /home/karkid/temporal-localization/data/tracking_dataset
-  preload_data: false
-  annotations:
-    train: /home/karkid/temporal-localization/data/tracking_dataset/train/train.json
-    valid: /home/karkid/temporal-localization/data/tracking_dataset/valid/valid.json
-    test: /home/karkid/temporal-localization/data/tracking_dataset/test/test.json
-  num_frames: 16
-  frame_interval: 9
-  augmentations:
-    vertical_flip: true
-    horizontal_flip: true
-    team_flip: true
-  normalize: true
-  num_workers: 20
-  train_batch_size: 32
-  valid_batch_size: 32
-  num_objects: 23
-  feature_dim: 8
-  pitch_half_length: 85.0
-  pitch_half_width: 50.0
-  max_displacement: 110.0
-  max_ball_height: 30.0
-
-MODEL:
-  type: custom
-  backbone:
-    type: graph_conv
-    encoder: sageconv
-    hidden_dim: 64
-    num_layers: 20
-    dropout: 0.1
-  neck:
-    type: TemporalAggregation
-    agr_type: maxpool
-    hidden_dim: 64
-    dropout: 0.1
-  head:
-    type: TrackingClassifier
-    hidden_dim: 64
-    dropout: 0.1
-    num_classes: 10
-  edge: positional
-  k: 8
-
-TRAIN:
-  enabled: true
-  use_weighted_sampler: true
-  use_weighted_loss: false
-  samples_per_class: 4000
-  epochs: 100
-  patience: 10
-  save_every: 20
-
-  optimizer:
-    type: Adam
-    lr: 0.001
-
-  scheduler:
-    type: ReduceLROnPlateau
-    mode: min
-    patience: 10
-    factor: 0.1
-    min_lr: 1e-8
-  
-  criterion:
-    type: CrossEntropyLoss
-
-  save_dir: ./checkpoints_tracking
-
-SYSTEM:
-  log_dir: ./logs
-  seed: 42
-  device: cuda
-  gpu_id: 0

opensportslib-0.0.1.dev15/opensportslib/config/graph_tracking_classification/maxpool.yaml

@@ -1,79 +0,0 @@
-TASK: classification
-
-DATA:
-  dataset_name: sngar
-  data_modality: tracking_parquet
-  data_dir: /home/karkid/temporal-localization/data/tracking_dataset
-  preload_data: false
-  annotations:
-    train: /home/karkid/temporal-localization/data/tracking_dataset/train/train.json
-    valid: /home/karkid/temporal-localization/data/tracking_dataset/valid/valid.json
-    test: /home/karkid/temporal-localization/data/tracking_dataset/test/test.json
-  num_frames: 16
-  frame_interval: 9
-  augmentations:
-    vertical_flip: true
-    horizontal_flip: true
-    team_flip: true
-  normalize: true
-  num_workers: 20
-  train_batch_size: 32
-  valid_batch_size: 32
-  num_objects: 23
-  feature_dim: 8
-  pitch_half_length: 85.0
-  pitch_half_width: 50.0
-  max_displacement: 110.0
-  max_ball_height: 30.0
-
-MODEL:
-  type: custom
-  backbone:
-    type: graph_conv
-    encoder: gin
-    hidden_dim: 64
-    num_layers: 20
-    dropout: 0.1
-  neck:
-    type: TemporalAggregation
-    agr_type: maxpool
-    hidden_dim: 64
-    dropout: 0.1
-  head:
-    type: TrackingClassifier
-    hidden_dim: 64
-    dropout: 0.1
-    num_classes: 10
-  edge: positional
-  k: 8
-
-TRAIN:
-  enabled: true
-  use_weighted_sampler: true
-  use_weighted_loss: false
-  samples_per_class: 4000
-  epochs: 100
-  patience: 10
-  save_every: 20
-
-  optimizer:
-    type: Adam
-    lr: 0.001
-
-  scheduler:
-    type: ReduceLROnPlateau
-    mode: min
-    patience: 10
-    factor: 0.1
-    min_lr: 1e-8
-  
-  criterion:
-    type: CrossEntropyLoss
-
-  save_dir: ./checkpoints_tracking
-
-SYSTEM:
-  log_dir: ./logs
-  seed: 42
-  device: cuda
-  gpu_id: 0

opensportslib-0.0.1.dev15/opensportslib/config/graph_tracking_classification/noedges.yaml

@@ -1,79 +0,0 @@
-TASK: classification
-
-DATA:
-  dataset_name: sngar
-  data_modality: tracking_parquet
-  data_dir: /home/karkid/temporal-localization/data/tracking_dataset
-  preload_data: false
-  annotations:
-    train: /home/karkid/temporal-localization/data/tracking_dataset/train/train.json
-    valid: /home/karkid/temporal-localization/data/tracking_dataset/valid/valid.json
-    test: /home/karkid/temporal-localization/data/tracking_dataset/test/test.json
-  num_frames: 16
-  frame_interval: 9
-  augmentations:
-    vertical_flip: true
-    horizontal_flip: true
-    team_flip: true
-  normalize: true
-  num_workers: 20
-  train_batch_size: 32
-  valid_batch_size: 32
-  num_objects: 23
-  feature_dim: 8
-  pitch_half_length: 85.0
-  pitch_half_width: 50.0
-  max_displacement: 110.0
-  max_ball_height: 30.0
-
-MODEL:
-  type: custom
-  backbone:
-    type: graph_conv
-    encoder: gin
-    hidden_dim: 64
-    num_layers: 20
-    dropout: 0.1
-  neck:
-    type: TemporalAggregation
-    agr_type: maxpool
-    hidden_dim: 64
-    dropout: 0.1
-  head:
-    type: TrackingClassifier
-    hidden_dim: 64
-    dropout: 0.1
-    num_classes: 10
-  edge: none
-  k: 8
-
-TRAIN:
-  enabled: true
-  use_weighted_sampler: true
-  use_weighted_loss: false
-  samples_per_class: 4000
-  epochs: 100
-  patience: 10
-  save_every: 20
-
-  optimizer:
-    type: Adam
-    lr: 0.001
-
-  scheduler:
-    type: ReduceLROnPlateau
-    mode: min
-    patience: 10
-    factor: 0.1
-    min_lr: 1e-8
-  
-  criterion:
-    type: CrossEntropyLoss
-
-  save_dir: ./checkpoints_tracking
-
-SYSTEM:
-  log_dir: ./logs
-  seed: 42
-  device: cuda
-  gpu_id: 0