opensportslib 0.0.1.dev2__py3-none-any.whl

opensportslib/config/localization.yaml

@@ -0,0 +1,132 @@
+TASK: localization
+
+dali: True
+
+DATA:
+  dataset_name: SoccerNet
+  data_dir: /home/vorajv/opensportslib/SoccerNet/annotations/
+  classes:
+    - PASS
+    - DRIVE
+    - HEADER
+    - HIGH PASS
+    - OUT
+    - CROSS
+    - THROW IN
+    - SHOT
+    - BALL PLAYER BLOCK
+    - PLAYER SUCCESSFUL TACKLE
+    - FREE KICK
+    - GOAL
+    
+  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: VideoGameWithDali
+    classes: ${DATA.classes}
+    output_map: [data, label]
+    video_path: ${DATA.data_dir}/train/
+    path: ${DATA.train.video_path}/annotations-2024-224p-train.json
+    dataloader:
+      batch_size: 8
+      shuffle: true
+      num_workers: 4
+      pin_memory: true
+
+  valid:
+    type: VideoGameWithDali
+    classes: ${DATA.classes}
+    output_map: [data, label]
+    video_path: ${DATA.data_dir}/valid/
+    path: ${DATA.valid.video_path}/annotations-2024-224p-valid.json
+    dataloader:
+      batch_size: 8
+      shuffle: true
+
+  valid_data_frames:
+    type: VideoGameWithDaliVideo
+    classes: ${DATA.classes}
+    output_map: [data, label]
+    video_path: ${DATA.valid.video_path}
+    path: ${DATA.valid.path}
+    overlap_len: 0
+    dataloader:
+      batch_size: 4
+      shuffle: false
+
+  test:
+    type: VideoGameWithDaliVideo
+    classes: ${DATA.classes}
+    output_map: [data, label]
+    video_path: ${DATA.data_dir}/test/
+    path: ${DATA.test.video_path}/annotations-2024-224p-test.json
+    results: results_spotting_test
+    nms_window: 2 
+    metric: tight
+    overlap_len: 50
+    dataloader:
+      batch_size: 4
+      shuffle: false
+
+  challenge:
+    type: VideoGameWithDaliVideo
+    overlap_len: 50
+    output_map: [data, label]
+    path: ${DATA.data_dir}/challenge/annotations.json
+    dataloader:
+      batch_size: 4
+      shuffle: false
+
+MODEL:
+    type: E2E
+    runner:
+      type: runner_e2e
+    backbone:
+      type: rny008_gsm
+    head:
+      type: gru
+    multi_gpu: true
+    load_weights: null
+
+TRAIN:
+  type: trainer_e2e
+  num_epochs: 10
+  acc_grad_iter: 1
+  base_num_valid_epochs: 30
+  start_valid_epoch: 4
+  valid_map_every: 1
+  criterion_valid: map
+
+  criterion:
+    type: CrossEntropyLoss
+
+  optimizer:
+    type: AdamWithScaler
+    lr: 0.01
+
+  scheduler:
+    type: ChainedSchedulerE2E
+    acc_grad_iter: 1
+    num_epochs: ${TRAIN.num_epochs}
+    warm_up_epochs: 3
+
+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/config/sngar_frames.yaml

@@ -0,0 +1,98 @@
+TASK: classification
+
+DATA:
+  dataset_name: sngar
+  data_dir: /home/spark_user1/opensportslib/sngar-frames
+  data_modality: frames_npy
+  max_samples: 100
+  num_frames: 16
+  frame_size: [224, 224]
+  train:
+    path: ${DATA.data_dir}/annotations_train.json
+    dataloader:
+      batch_size: 64
+      shuffle: true
+      num_workers: 8
+      pin_memory: true
+  valid:
+    path: ${DATA.data_dir}/annotations_valid.json
+    dataloader:
+      batch_size: 64
+      num_workers: 8
+      shuffle: false
+  test:
+    path: ${DATA.data_dir}/annotations_test.json
+    dataloader:
+      batch_size: 64
+      num_workers: 8
+      shuffle: false
+  augmentations:
+    random_horizontal_flip: true
+    flip_prob: 0.5
+    color_jitter: true
+    jitter_prob: 0.5
+    jitter_params: [0.2, 0.2, 0.2, 0.1]
+
+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
+    hidden_dim: 768
+    freeze: true
+    unfreeze_last_n_layers: 0     # 0 = frozen backbone, >0 = unfreeze last N layers
+  neck:
+    type: TemporalAggregation
+    agr_type: maxpool             # avgpool | maxpool | bilstm | tcn | attention
+    hidden_dim: 768
+    dropout: 0.1
+    lstm_dropout: 0.3             # only used when agr_type is bilstm
+    num_attention_heads: 8        # only used when agr_type is attention (8 for video, 4 for tracking)
+  head:
+    type: TrackingClassifier
+    hidden_dim: 64
+    num_classes: 10               # must match the number of action classes in the dataset
+    dropout: 0.1
+
+TRAIN:
+  monitor: balanced_accuracy
+  mode: max
+  enabled: true
+  use_amp: true
+  mixup_alpha: 0.2
+  use_weighted_sampler: false
+  samples_per_class: 4000
+  use_weighted_loss: false
+  epochs: 100
+  patience: 5
+  log_interval: 10
+  save_every: 5
+  detailed_results: true
+
+  criterion:
+    type: CrossEntropyLoss
+
+  optimizer:
+    type: AdamW
+    lr: 0.0001
+    betas: [0.9, 0.999]
+    eps: 0.0000001
+    weight_decay: 0.0001
+    amsgrad: false
+
+  scheduler:
+    type: ReduceLROnPlateau
+    mode: min
+    patience: 5
+    factor: 0.1
+    min_lr: 1e-8
+
+SYSTEM:
+  log_dir: ./logs
+  save_dir: ./checkpoints_video
+  use_seed: true
+  seed: 42
+  GPU: 1
+  device: cuda
+  gpu_id: 0

opensportslib/core/loss/builder.py

@@ -0,0 +1,40 @@
+from opensportslib.core.loss.ce import CELoss
+from .nll import NLLLoss
+from .calf import ContextAwareLoss, SpottingLoss
+from .combine import Combined2x
+
+
+def build_criterion(cfg, default_args=None):
+    """Build a criterion from config dict.
+
+    Args:
+        cfg (dict): Config dict. It should at least contain the key "type".
+        default_args (dict | None, optional): Default initialization arguments.
+            Default: None.
+
+    Returns:
+        criterion: The constructed criterion.
+    """
+    if cfg.type == "NLLLoss":
+        criterion = NLLLoss()
+    elif cfg.type == "ContextAwareLoss":
+        criterion = ContextAwareLoss(
+            K=cfg.K,
+            framerate=cfg.framerate,
+            hit_radius=cfg.hit_radius,
+            miss_radius=cfg.miss_radius,
+        )
+    elif cfg.type == "SpottingLoss":
+        criterion = SpottingLoss(
+            lambda_coord=cfg.lambda_coord, lambda_noobj=cfg.lambda_noobj
+        )
+    elif cfg.type == "Combined2x":
+        c_1 = build_criterion(cfg.loss_1)
+        c_2 = build_criterion(cfg.loss_2)
+        criterion = Combined2x(c_1, c_2, cfg.w_1, cfg.w_2)
+
+    elif cfg.type == "CrossEntropyLoss":
+        criterion = CELoss()
+    else:
+        criterion = None
+    return criterion

opensportslib/core/loss/calf.py

@@ -0,0 +1,258 @@
+import torch
+
+
+####################################################################################################################################################
+
+# Context-aware loss function
+
+####################################################################################################################################################
+
+
+class ContextAwareLoss(torch.nn.Module):
+    """Context Aware Loss.
+
+    Args:
+        K (list[list[int]]): Config dict. It should at least contain the key "type".
+        framerate (int): Framerate at which the features have been extracted.
+            Default: 2.
+        hit_radius (float): The hit radius.
+            Default: 0.1.
+        miss_radius (float): The miss radius.
+            Default: 0.9.
+
+    """
+
+    def __init__(self, K, framerate=2, hit_radius=0.1, miss_radius=0.9):
+
+        super(ContextAwareLoss, self).__init__()
+
+        self.K = torch.FloatTensor(K * framerate).cuda()
+        self.hit_radius = float(hit_radius)
+        self.miss_radius = float(miss_radius)
+
+    def forward(self, labels, output):
+        """Forward function.
+
+        Args:
+            labels (torch.Tensor): The ground truth labels.
+            output (torch.Tensor): The predictions.
+
+        Returns:
+            torch.Tensor: The returned loss.
+        """
+        K = self.K
+        hit_radius = self.hit_radius
+        miss_radius = self.miss_radius
+
+        zeros = torch.zeros(output.size()).to(output.device).type(torch.float)
+        output = 1.0 - output
+
+        case1 = self.DownStep(labels, K[0]) * torch.max(
+            zeros, -torch.log(output) + torch.log(zeros + miss_radius)
+        )
+        case2 = self.Interval(labels, K[0], K[1]) * torch.max(
+            zeros,
+            -torch.log(
+                output
+                + (1.0 - output)
+                * (self.PartialIdentity(labels, K[0], K[1]) - K[0])
+                / (K[1] - K[0])
+            )
+            + torch.log(zeros + miss_radius),
+        )
+        case3 = self.Interval(labels, K[1], 0.0) * zeros
+        case4 = self.Interval(labels, 0.0, K[2]) * torch.max(
+            zeros,
+            -torch.log(
+                1.0
+                - output
+                + output
+                * (self.PartialIdentity(labels, 0.0, K[2]) - 0.0)
+                / (K[2] - 0.0)
+            )
+            + torch.log(zeros + 1.0 - hit_radius),
+        )
+        case5 = self.Interval(labels, K[2], K[3]) * torch.max(
+            zeros,
+            -torch.log(
+                output
+                + (1.0 - output)
+                * (self.PartialIdentity(labels, K[2], K[3]) - K[3])
+                / (K[2] - K[3])
+            )
+            + torch.log(zeros + miss_radius),
+        )
+        case6 = self.UpStep(labels, K[3]) * torch.max(
+            zeros, -torch.log(output) + torch.log(zeros + miss_radius)
+        )
+
+        L = case1 + case2 + case3 + case4 + case5 + case6
+
+        return torch.sum(L)
+
+    def UpStep(self, x, a):
+        """
+        Args :
+            x (torch.Tensor).
+            a (torch.Tensor).
+
+        Returns:
+            0 if x<a, 1 if x >= a
+        """
+
+        return 1.0 - torch.max(0.0 * x, torch.sign(a - x))
+
+    def DownStep(self, x, a):
+        """
+        Args :
+            x (torch.Tensor).
+            a (torch.Tensor).
+
+        Returns:
+            1 if x < a, 0 if x >=a
+        """
+
+        return torch.max(0.0 * x, torch.sign(a - x))
+
+    def Interval(self, x, a, b):
+        """
+        Args :
+            x (torch.Tensor).
+            a (torch.Tensor).
+            b (torch.Tensor).
+
+        Returns:
+            1 if a<= x < b, 0 otherwise
+        """
+
+        return self.UpStep(x, a) * self.DownStep(x, b)
+
+    def PartialIdentity(self, x, a, b):
+        """
+        Args :
+            x (torch.Tensor).
+            a (torch.Tensor).
+            b (torch.Tensor).
+
+        Returns:
+            a if x<a, x if a<= x <b, b if x >= b
+        """
+
+        return torch.min(torch.max(x, 0.0 * x + a), 0.0 * x + b)
+
+
+####################################################################################################################################################
+
+# Spotting loss
+
+####################################################################################################################################################
+
+
+class SpottingLoss(torch.nn.Module):
+    """Spotting loss.
+
+    Args:
+        lambda_coord (float).
+        lambda_noobj (float).
+
+    """
+
+    def __init__(self, lambda_coord, lambda_noobj):
+        super(SpottingLoss, self).__init__()
+
+        self.lambda_coord = lambda_coord
+        self.lambda_noobj = lambda_noobj
+
+    def forward(self, labels, output):
+        """Forward function.
+
+        Args:
+            labels (torch.Tensor): The ground truth labels.
+            output (torch.Tensor): The predictions.
+
+        Returns:
+            torch.Tensor: The returned spotting loss.
+        """
+        output = self.permute_output_for_matching(labels, output)
+        loss = torch.sum(
+            labels[:, :, 0]
+            * self.lambda_coord
+            * torch.square(labels[:, :, 1] - output[:, :, 1])
+            + labels[:, :, 0] * torch.square(labels[:, :, 0] - output[:, :, 0])
+            + (1 - labels[:, :, 0])
+            * self.lambda_noobj
+            * torch.square(labels[:, :, 0] - output[:, :, 0])
+            + labels[:, :, 0]
+            * torch.sum(torch.square(labels[:, :, 2:] - output[:, :, 2:]), axis=-1)
+        )  # -labels[:,:,0]*torch.sum(labels[:,:,2:]*torch.log(output[:,:,2:]),axis=-1)
+        return loss
+
+    def permute_output_for_matching(self, labels, output):
+        """
+        Args:
+            labels (torch.Tensor): The ground truth labels.
+            output (torch.Tensor): The predictions.
+
+        Returns:
+            torch.Tensor: The permuted pred.
+        """
+        alpha = labels[:, :, 0]
+        x = labels[:, :, 1]
+        p = output[:, :, 1]
+        nb_pred = x.shape[-1]
+
+        D = torch.abs(
+            x.unsqueeze(-1).repeat(1, 1, nb_pred)
+            - p.unsqueeze(-2).repeat(1, nb_pred, 1)
+        )
+        D1 = 1 - D
+        Permut = 0 * D
+
+        alpha_filter = alpha.unsqueeze(-1).repeat(1, 1, nb_pred)
+
+        v_filter = alpha_filter
+        h_filter = 0 * v_filter + 1
+        D2 = v_filter * D1
+
+        for i in range(nb_pred):
+            D2 = v_filter * D2
+            D2 = h_filter * D2
+            A = torch.nn.functional.one_hot(torch.argmax(D2, axis=-1), nb_pred)
+            B = v_filter * A * D2
+            C = torch.nn.functional.one_hot(torch.argmax(B, axis=-2), nb_pred).permute(
+                0, 2, 1
+            )
+            E = v_filter * A * C
+            Permut = Permut + E
+            v_filter = (1 - torch.sum(Permut, axis=-1)) * alpha
+            v_filter = v_filter.unsqueeze(-1).repeat(1, 1, nb_pred)
+            h_filter = 1 - torch.sum(Permut, axis=-2)
+            h_filter = h_filter.unsqueeze(-2).repeat(1, nb_pred, 1)
+
+        v_filter = 1 - alpha_filter
+        D2 = v_filter * D1
+        D2 = h_filter * D2
+
+        for i in range(nb_pred):
+            D2 = v_filter * D2
+            D2 = h_filter * D2
+            A = torch.nn.functional.one_hot(torch.argmax(D2, axis=-1), nb_pred)
+            B = v_filter * A * D2
+            C = torch.nn.functional.one_hot(torch.argmax(B, axis=-2), nb_pred).permute(
+                0, 2, 1
+            )
+            E = v_filter * A * C
+            Permut = Permut + E
+            v_filter = (1 - torch.sum(Permut, axis=-1)) * (
+                1 - alpha
+            )  # here comes the change
+            v_filter = v_filter.unsqueeze(-1).repeat(1, 1, nb_pred)
+            h_filter = 1 - torch.sum(Permut, axis=-2)
+            h_filter = h_filter.unsqueeze(-2).repeat(1, nb_pred, 1)
+
+        permutation = torch.argmax(Permut, axis=-1)
+        permuted = torch.gather(
+            output, 1, permutation.unsqueeze(-1).repeat(1, 1, labels.shape[-1])
+        )
+
+        return permuted

opensportslib/core/loss/ce.py

@@ -0,0 +1,23 @@
+import torch
+import torch.nn.functional as F
+
+
+class CELoss(torch.nn.Module):
+    """Cross Entropy Loss."""
+
+    def __init__(self):
+        super(CELoss, self).__init__()
+
+    def forward(self, output, labels, **ce_kwargs):
+        """Forward function.
+
+        Args:
+            labels (torch.Tensor): The ground truth labels.
+            output (torch.Tensor): The predictions.
+            ce_kwargs: Any keyword argument to be used to calculate
+                CrossEntropy loss.
+
+        Returns:
+            torch.Tensor: The returned CrossEntropy loss.
+        """
+        return F.cross_entropy(output, labels, **ce_kwargs)

opensportslib/core/loss/combine.py

@@ -0,0 +1,42 @@
+import torch
+
+
+####################################################################################################################################################
+
+# Combined loss function
+
+####################################################################################################################################################
+
+
+class Combined2x(torch.nn.Module):
+    """Combination of two losses.
+
+    Args:
+        c_1 : The first criterion.
+        c_2 : The second criterion.
+        w_1 (float): Weight for the first criterion.
+        w_2 (float): Weight for the second criterion.
+    """
+
+    def __init__(self, c_1, c_2, w_1, w_2):
+
+        super(Combined2x, self).__init__()
+
+        self.c_1 = c_1
+        self.c_2 = c_2
+        self.w_1 = w_1
+        self.w_2 = w_2
+
+    def forward(self, labels, output):
+        """Forward function.
+
+        Args:
+            labels (torch.Tensor): The ground truth labels.
+            output (torch.Tensor): The predictions.
+
+        Returns:
+            torch.Tensor: The returned combined loss.
+        """
+        return self.w_1 * self.c_1(labels[0], output[0]) + self.w_2 * self.c_2(
+            labels[1], output[1]
+        )

opensportslib/core/loss/nll.py

@@ -0,0 +1,25 @@
+
+import torch
+
+
+class NLLLoss(torch.nn.Module):
+    """Negative Log LikeLihood Loss."""
+
+    def __init__(self):
+        super(NLLLoss, self).__init__()
+
+    def forward(self, labels, output):
+        """Forward function.
+
+        Args:
+            labels (torch.Tensor): The ground truth labels.
+            output (torch.Tensor): The predictions.
+
+        Returns:
+            torch.Tensor: The returned negative log likelihood loss.
+        """
+        return torch.mean(
+            torch.mean(
+                labels * -torch.log(output) + (1 - labels) * -torch.log(1 - output)
+            )
+        )

opensportslib/core/optimizer/builder.py

@@ -0,0 +1,38 @@
+import torch
+
+
+def build_optimizer(parameters, cfg, default_args=None):
+    """Build a optimizer from config dict.
+
+    Args:
+        cfg (dict): Config dict. It should at least contain the key "type".
+        default_args (dict | None, optional): Default initialization arguments.
+            Default: None.
+
+    Returns:
+        optimizer: The constructed optimizer.
+    """
+    if cfg.type == "Adam":
+        optimizer = torch.optim.Adam(
+            parameters,
+            lr=cfg.lr,
+            betas=tuple(getattr(cfg, 'betas', (0.9, 0.999))),
+            eps=getattr(cfg, 'eps', 1e-8),
+            weight_decay=getattr(cfg, 'weight_decay', 1e-4),
+            amsgrad=getattr(cfg, 'amsgrad', False),
+        )
+    elif cfg.type == "AdamWithScaler":
+        optimizer = (
+            torch.optim.AdamW(parameters, lr=cfg.lr),
+            torch.cuda.amp.GradScaler(),
+        )
+    elif cfg.type == "AdamW":
+        optimizer = torch.optim.AdamW(
+            parameters,
+            lr=cfg.lr,
+            betas=tuple(cfg.betas),
+            eps=cfg.eps,
+            weight_decay=cfg.weight_decay,
+            amsgrad=cfg.amsgrad,
+        )
+    return optimizer