Upload folder using huggingface_hub

.gitattributes

@@ -1,35 +1,38 @@
-*.7z filter=lfs diff=lfs merge=lfs -text
-*.arrow filter=lfs diff=lfs merge=lfs -text
-*.bin filter=lfs diff=lfs merge=lfs -text
-*.bz2 filter=lfs diff=lfs merge=lfs -text
-*.ckpt filter=lfs diff=lfs merge=lfs -text
-*.ftz filter=lfs diff=lfs merge=lfs -text
-*.gz filter=lfs diff=lfs merge=lfs -text
-*.h5 filter=lfs diff=lfs merge=lfs -text
-*.joblib filter=lfs diff=lfs merge=lfs -text
-*.lfs.* filter=lfs diff=lfs merge=lfs -text
-*.mlmodel filter=lfs diff=lfs merge=lfs -text
-*.model filter=lfs diff=lfs merge=lfs -text
-*.msgpack filter=lfs diff=lfs merge=lfs -text
-*.npy filter=lfs diff=lfs merge=lfs -text
-*.npz filter=lfs diff=lfs merge=lfs -text
-*.onnx filter=lfs diff=lfs merge=lfs -text
-*.ot filter=lfs diff=lfs merge=lfs -text
-*.parquet filter=lfs diff=lfs merge=lfs -text
-*.pb filter=lfs diff=lfs merge=lfs -text
-*.pickle filter=lfs diff=lfs merge=lfs -text
-*.pkl filter=lfs diff=lfs merge=lfs -text
-*.pt filter=lfs diff=lfs merge=lfs -text
-*.pth filter=lfs diff=lfs merge=lfs -text
-*.rar filter=lfs diff=lfs merge=lfs -text
-*.safetensors filter=lfs diff=lfs merge=lfs -text
-saved_model/**/* filter=lfs diff=lfs merge=lfs -text
-*.tar.* filter=lfs diff=lfs merge=lfs -text
-*.tar filter=lfs diff=lfs merge=lfs -text
-*.tflite filter=lfs diff=lfs merge=lfs -text
-*.tgz filter=lfs diff=lfs merge=lfs -text
-*.wasm filter=lfs diff=lfs merge=lfs -text
-*.xz filter=lfs diff=lfs merge=lfs -text
-*.zip filter=lfs diff=lfs merge=lfs -text
-*.zst filter=lfs diff=lfs merge=lfs -text
-*tfevents* filter=lfs diff=lfs merge=lfs -text
+*.7z filter=lfs diff=lfs merge=lfs -text
+*.arrow filter=lfs diff=lfs merge=lfs -text
+*.bin filter=lfs diff=lfs merge=lfs -text
+*.bz2 filter=lfs diff=lfs merge=lfs -text
+*.ckpt filter=lfs diff=lfs merge=lfs -text
+*.ftz filter=lfs diff=lfs merge=lfs -text
+*.gz filter=lfs diff=lfs merge=lfs -text
+*.h5 filter=lfs diff=lfs merge=lfs -text
+*.joblib filter=lfs diff=lfs merge=lfs -text
+*.lfs.* filter=lfs diff=lfs merge=lfs -text
+*.mlmodel filter=lfs diff=lfs merge=lfs -text
+*.model filter=lfs diff=lfs merge=lfs -text
+*.msgpack filter=lfs diff=lfs merge=lfs -text
+*.npy filter=lfs diff=lfs merge=lfs -text
+*.npz filter=lfs diff=lfs merge=lfs -text
+*.onnx filter=lfs diff=lfs merge=lfs -text
+*.ot filter=lfs diff=lfs merge=lfs -text
+*.parquet filter=lfs diff=lfs merge=lfs -text
+*.pb filter=lfs diff=lfs merge=lfs -text
+*.pickle filter=lfs diff=lfs merge=lfs -text
+*.pkl filter=lfs diff=lfs merge=lfs -text
+*.pt filter=lfs diff=lfs merge=lfs -text
+*.pth filter=lfs diff=lfs merge=lfs -text
+*.rar filter=lfs diff=lfs merge=lfs -text
+*.safetensors filter=lfs diff=lfs merge=lfs -text
+saved_model/**/* filter=lfs diff=lfs merge=lfs -text
+*.tar.* filter=lfs diff=lfs merge=lfs -text
+*.tar filter=lfs diff=lfs merge=lfs -text
+*.tflite filter=lfs diff=lfs merge=lfs -text
+*.tgz filter=lfs diff=lfs merge=lfs -text
+*.wasm filter=lfs diff=lfs merge=lfs -text
+*.xz filter=lfs diff=lfs merge=lfs -text
+*.zip filter=lfs diff=lfs merge=lfs -text
+*.zst filter=lfs diff=lfs merge=lfs -text
+*tfevents* filter=lfs diff=lfs merge=lfs -text
+SV_kp.engine filter=lfs diff=lfs merge=lfs -text
+osnet_model.pth.tar-100 filter=lfs diff=lfs merge=lfs -text
+keypoint filter=lfs diff=lfs merge=lfs -text

.gitignore

@@ -0,0 +1,5 @@
+venv
+outputs
+test_predict_batch.py
+*.mp4
+inspect_yolo_model.py

20251029-detection.pt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:8bbacfcb38e38b1b8816788e9e6e845160533719a0b87b693d58b932380d0d28
+size 152961687

20251029-keypoint.pt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:6dd10dba85895c92760cdb5a99c5cfca899c68f361a66c5448f38a187280ee1f
+size 6849672

README.md

@@ -0,0 +1,132 @@
+🚀 Example Chute for Turbovision 🪂
+
+This repository demonstrates how to deploy a Chute via the Turbovision CLI, hosted on Hugging Face Hub. It serves as a minimal example showcasing the required structure and workflow for integrating machine learning models, preprocessing, and orchestration into a reproducible Chute environment.
+
+## Repository Structure
+
+The following two files must be present (in their current locations) for a successful deployment — their content can be modified as needed:
+
+| File | Purpose |
+|------|---------|
+| `miner.py` | Defines the ML model type(s), orchestration, and all pre/postprocessing logic. |
+| `config.yml` | Specifies machine configuration (e.g., GPU type, memory, environment variables). |
+
+Other files — e.g., model weights, utility scripts, or dependencies — are optional and can be included as needed for your model. 
+
+> **Note**: Any required assets must be defined or contained within this repo, which is fully open-source, since all network-related operations (downloading challenge data, weights, etc.) are disabled inside the Chute.
+
+## Overview
+
+Below is a high-level diagram showing the interaction between Huggingface, Chutes and Turbovision:
+
+```
+┌─────────────┐      ┌──────────┐      ┌──────────────┐
+│ HuggingFace │ ───> │  Chutes   │ ───> │ Turbovision │
+│     Hub     │      │    .ai    │      │   Validator │
+└─────────────┘      └──────────┘      └──────────────┘
+```
+
+## Local Testing
+
+After editing the `config.yml` and `miner.py` and saving it into your Huggingface Repo, you will want to test it works locally.
+
+1. **Copy the template file** `scorevision/chute_template/turbovision_chute.py.j2` as a python file called `my_chute.py` and fill in the missing variables:
+
+```python
+HF_REPO_NAME = "{{ huggingface_repository_name }}"
+HF_REPO_REVISION = "{{ huggingface_repository_revision }}"
+CHUTES_USERNAME = "{{ chute_username }}"
+CHUTE_NAME = "{{ chute_name }}"
+```
+
+2. **Run the following command to build the chute locally** (Caution: there are known issues with the docker location when running this on a mac):
+
+```bash
+chutes build my_chute:chute --local --public
+```
+
+3. **Run the name of the docker image just built** (i.e. `CHUTE_NAME`) and enter it:
+
+```bash
+docker run -p 8000:8000 -e CHUTES_EXECUTION_CONTEXT=REMOTE -it <image-name> /bin/bash
+```
+
+4. **Run the file from within the container**:
+
+```bash
+chutes run my_chute:chute --dev --debug
+```
+
+5. **In another terminal, test the local endpoints** to ensure there are no bugs:
+
+```bash
+# Health check
+curl -X POST http://localhost:8000/health -d '{}'
+
+# Prediction test
+curl -X POST http://localhost:8000/predict -d '{"url": "https://scoredata.me/2025_03_14/35ae7a/h1_0f2ca0.mp4","meta": {}}'
+```
+
+## Live Testing
+
+If you have any chute with the same name (i.e. from a previous deployment), ensure you delete that first (or you will get an error when trying to build).
+
+1. **List existing chutes**:
+
+```bash
+chutes chutes list
+```
+
+Take note of the chute id that you wish to delete (if any):
+
+```bash
+chutes chutes delete <chute-id>
+```
+
+2. **You should also delete its associated image**:
+
+```bash
+chutes images list
+```
+
+Take note of the chute image id:
+
+```bash
+chutes images delete <chute-image-id>
+```
+
+3. **Use Turbovision's CLI to build, deploy and commit on-chain**:
+
+```bash
+sv -vv push
+```
+
+> **Note**: You can skip the on-chain commit using `--no-commit`. You can also specify a past huggingface revision to point to using `--revision` and/or the local files you want to upload to your huggingface repo using `--model-path`.
+
+4. **When completed, warm up the chute** (if its cold 🧊):
+
+You can confirm its status using `chutes chutes list` or `chutes chutes get <chute-id>` if you already know its id.
+
+> **Note**: Warming up can sometimes take a while but if the chute runs without errors (should be if you've tested locally first) and there are sufficient nodes (i.e. machines) available matching the `config.yml` you specified, the chute should become hot 🔥!
+
+```bash
+chutes warmup <chute-id>
+```
+
+5. **Test the chute's endpoints**:
+
+```bash
+# Health check
+curl -X POST https://<YOUR-CHUTE-SLUG>.chutes.ai/health -d '{}' -H "Authorization: Bearer $CHUTES_API_KEY"
+
+# Prediction
+curl -X POST https://<YOUR-CHUTE-SLUG>.chutes.ai/predict -d '{"url": "https://scoredata.me/2025_03_14/35ae7a/h1_0f2ca0.mp4","meta": {}}' -H "Authorization: Bearer $CHUTES_API_KEY"
+```
+
+6. **Test what your chute would get on a validator**:
+
+This also applies any validation/integrity checks which may fail if you did not use the Turbovision CLI above to deploy the chute:
+
+```bash
+sv -vv run-once
+```

SV_kp.engine

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:f99452eb79e064189e2758abd20a78845a5b639fc8b9c4bc650519c83e13e8db
+size 368289641

config.yml

@@ -0,0 +1,24 @@
+Image:
+  from_base: parachutes/python:3.12
+  run_command:
+    - pip install --upgrade setuptools wheel
+    - pip install ultralytics==8.3.222 opencv-python-headless numpy pydantic
+    - pip install scikit-learn
+    - pip install onnxruntime-gpu
+  set_workdir: /app
+
+NodeSelector:
+  gpu_count: 1
+  min_vram_gb_per_gpu: 16
+  exclude:
+    - "5090"
+    - b200
+    - h200
+    - mi300x
+
+Chute:
+  timeout_seconds: 900
+  concurrency: 4
+  max_instances: 5
+  scaling_threshold: 0.5
+  shutdown_after_seconds: 3600

detection.onnx

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:7b51470cb703f5a9a789df38674b67d4bbe7f8f31846d69dbc97ce484f790cf9
+size 10245169

detection.pt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:2ad3e89b658d2626c34174f6799d240ffd37cfe45752c0ce6ef73b05935042e0
+size 52014742

football_object_detection.pt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:8bbacfcb38e38b1b8816788e9e6e845160533719a0b87b693d58b932380d0d28
+size 152961687

hrnetv2_w48.yaml

@@ -0,0 +1,35 @@
+MODEL:
+  IMAGE_SIZE: [960, 540]
+  NUM_JOINTS: 58
+  PRETRAIN: ''
+  EXTRA:
+    FINAL_CONV_KERNEL: 1
+    STAGE1:
+      NUM_MODULES: 1
+      NUM_BRANCHES: 1
+      BLOCK: BOTTLENECK
+      NUM_BLOCKS: [4]
+      NUM_CHANNELS: [64]
+      FUSE_METHOD: SUM
+    STAGE2:
+      NUM_MODULES: 1
+      NUM_BRANCHES: 2
+      BLOCK: BASIC
+      NUM_BLOCKS: [4, 4]
+      NUM_CHANNELS: [48, 96]
+      FUSE_METHOD: SUM
+    STAGE3:
+      NUM_MODULES: 4
+      NUM_BRANCHES: 3
+      BLOCK: BASIC
+      NUM_BLOCKS: [4, 4, 4]
+      NUM_CHANNELS: [48, 96, 192]
+      FUSE_METHOD: SUM
+    STAGE4:
+      NUM_MODULES: 3
+      NUM_BRANCHES: 4
+      BLOCK: BASIC
+      NUM_BLOCKS: [4, 4, 4, 4]
+      NUM_CHANNELS: [48, 96, 192, 384]
+      FUSE_METHOD: SUM
+

keypoint

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:7ea78fa76aaf94976a8eca428d6e3c59697a93430cba1a4603e20284b61f5113
+size 264964645

keypoint.pt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:6dd10dba85895c92760cdb5a99c5cfca899c68f361a66c5448f38a187280ee1f
+size 6849672

keypoint_evaluation.py

@@ -0,0 +1,321 @@
+"""
+Keypoint evaluation module for football pitch keypoint detection.
+Evaluates keypoint accuracy by comparing projected template lines with detected lines.
+"""
+import logging
+from typing import List, Tuple, Optional
+from pathlib import Path
+import numpy as np
+from numpy import ndarray, array, float32, uint8
+
+import cv2
+
+# Import cv2 functions
+bitwise_and = cv2.bitwise_and
+findHomography = cv2.findHomography
+warpPerspective = cv2.warpPerspective
+cvtColor = cv2.cvtColor
+COLOR_BGR2GRAY = cv2.COLOR_BGR2GRAY
+threshold = cv2.threshold
+THRESH_BINARY = cv2.THRESH_BINARY
+getStructuringElement = cv2.getStructuringElement
+MORPH_RECT = cv2.MORPH_RECT
+MORPH_TOPHAT = cv2.MORPH_TOPHAT
+GaussianBlur = cv2.GaussianBlur
+morphologyEx = cv2.morphologyEx
+Canny = cv2.Canny
+connectedComponents = cv2.connectedComponents
+perspectiveTransform = cv2.perspectiveTransform
+RETR_EXTERNAL = cv2.RETR_EXTERNAL
+CHAIN_APPROX_SIMPLE = cv2.CHAIN_APPROX_SIMPLE
+findContours = cv2.findContours
+boundingRect = cv2.boundingRect
+dilate = cv2.dilate
+
+logger = logging.getLogger(__name__)
+
+# Template keypoints constant - define your keypoints here
+# Format: List of (x, y) tuples representing keypoint coordinates on the template image
+TEMPLATE_KEYPOINTS: list[tuple[int, int]] = [
+    (5, 5),  # 1
+    (5, 140),  # 2
+    (5, 250),  # 3
+    (5, 430),  # 4
+    (5, 540),  # 5
+    (5, 675),  # 6
+    # -------------
+    (55, 250),  # 7
+    (55, 430),  # 8
+    # -------------
+    (110, 340),  # 9
+    # -------------
+    (165, 140),  # 10
+    (165, 270),  # 11
+    (165, 410),  # 12
+    (165, 540),  # 13
+    # -------------
+    (527, 5),  # 14
+    (527, 253),  # 15
+    (527, 433),  # 16
+    (527, 675),  # 17
+    # -------------
+    (888, 140),  # 18
+    (888, 270),  # 19
+    (888, 410),  # 20
+    (888, 540),  # 21
+    # -------------
+    (940, 340),  # 22
+    # -------------
+    (998, 250),  # 23
+    (998, 430),  # 24
+    # -------------
+    (1045, 5),  # 25
+    (1045, 140),  # 26
+    (1045, 250),  # 27
+    (1045, 430),  # 28
+    (1045, 540),  # 29
+    (1045, 675),  # 30
+    # -------------
+    (435, 340),  # 31
+    (615, 340),  # 32
+]
+
+INDEX_KEYPOINT_CORNER_BOTTOM_LEFT = 5
+INDEX_KEYPOINT_CORNER_BOTTOM_RIGHT = 29
+INDEX_KEYPOINT_CORNER_TOP_LEFT = 0
+INDEX_KEYPOINT_CORNER_TOP_RIGHT = 24
+
+
+class InvalidMask(Exception):
+    """Exception raised when mask validation fails."""
+    pass
+
+
+def has_a_wide_line(mask: ndarray, max_aspect_ratio: float = 1.0) -> bool:
+    contours, _ = findContours(mask, RETR_EXTERNAL, CHAIN_APPROX_SIMPLE)
+    for cnt in contours:
+        x, y, w, h = boundingRect(cnt)
+        aspect_ratio = min(w, h) / max(w, h)
+        if aspect_ratio >= max_aspect_ratio:
+            return True
+    return False
+
+
+def is_bowtie(points: ndarray) -> bool:
+    def segments_intersect(p1: int, p2: int, q1: int, q2: int) -> bool:
+        def ccw(a: int, b: int, c: int):
+            return (c[1] - a[1]) * (b[0] - a[0]) > (b[1] - a[1]) * (c[0] - a[0])
+
+        return (ccw(p1, q1, q2) != ccw(p2, q1, q2)) and (
+            ccw(p1, p2, q1) != ccw(p1, p2, q2)
+        )
+
+    pts = points.reshape(-1, 2)
+    edges = [(pts[0], pts[1]), (pts[1], pts[2]), (pts[2], pts[3]), (pts[3], pts[0])]
+    return segments_intersect(*edges[0], *edges[2]) or segments_intersect(
+        *edges[1], *edges[3]
+    )
+
+def validate_mask_lines(mask: ndarray) -> None:
+    if mask.sum() == 0:
+        raise InvalidMask("No projected lines")
+    if mask.sum() == mask.size:
+        raise InvalidMask("Projected lines cover the entire image surface")
+    if has_a_wide_line(mask=mask):
+        raise InvalidMask("A projected line is too wide")
+
+
+def validate_mask_ground(mask: ndarray) -> None:
+    num_labels, _ = connectedComponents(mask)
+    num_distinct_regions = num_labels - 1
+    if num_distinct_regions > 1:
+        raise InvalidMask(
+            f"Projected ground should be a single object, detected {num_distinct_regions}"
+        )
+    area_covered = mask.sum() / mask.size
+    if area_covered >= 0.9:
+        raise InvalidMask(
+            f"Projected ground covers more than {area_covered:.2f}% of the image surface which is unrealistic"
+        )
+
+
+def validate_projected_corners(
+    source_keypoints: list[tuple[int, int]], homography_matrix: ndarray
+) -> None:
+    src_corners = array(
+        [
+            source_keypoints[INDEX_KEYPOINT_CORNER_BOTTOM_LEFT],
+            source_keypoints[INDEX_KEYPOINT_CORNER_BOTTOM_RIGHT],
+            source_keypoints[INDEX_KEYPOINT_CORNER_TOP_RIGHT],
+            source_keypoints[INDEX_KEYPOINT_CORNER_TOP_LEFT],
+        ],
+        dtype="float32",
+    )[None, :, :]
+
+    warped_corners = perspectiveTransform(src_corners, homography_matrix)[0]
+
+    if is_bowtie(warped_corners):
+        raise InvalidMask("Projection twisted!")
+
+
+def project_image_using_keypoints(
+    image: ndarray,
+    source_keypoints: List[Tuple[int, int]],
+    destination_keypoints: List[Tuple[int, int]],
+    destination_width: int,
+    destination_height: int,
+    inverse: bool = False,
+) -> ndarray:
+    """Project image using homography from source to destination keypoints."""
+    filtered_src = []
+    filtered_dst = []
+
+    for src_pt, dst_pt in zip(source_keypoints, destination_keypoints):
+        if dst_pt[0] == 0.0 and dst_pt[1] == 0.0:  # ignore default / missing points
+            continue
+        filtered_src.append(src_pt)
+        filtered_dst.append(dst_pt)
+
+    if len(filtered_src) < 4:
+        raise ValueError("At least 4 valid keypoints are required for homography.")
+
+    source_points = array(filtered_src, dtype=float32)
+    destination_points = array(filtered_dst, dtype=float32)
+
+    if inverse:
+        H_inv, _ = findHomography(destination_points, source_points)
+        return warpPerspective(image, H_inv, (destination_width, destination_height))
+
+    H, _ = findHomography(source_points, destination_points)
+    projected_image = warpPerspective(image, H, (destination_width, destination_height))
+
+    validate_projected_corners(source_keypoints=source_keypoints, homography_matrix=H)
+    return projected_image
+
+
+def extract_masks_for_ground_and_lines(
+    image: ndarray,
+) -> Tuple[ndarray, ndarray]:
+    """Extract masks for ground (gray) and lines (white) from template image."""
+    gray = cvtColor(image, COLOR_BGR2GRAY)
+    _, mask_ground = threshold(gray, 10, 255, THRESH_BINARY)
+    _, mask_lines = threshold(gray, 200, 255, THRESH_BINARY)
+    mask_ground_binary = (mask_ground > 0).astype(uint8)
+    mask_lines_binary = (mask_lines > 0).astype(uint8)
+    validate_mask_ground(mask=mask_ground_binary)
+    validate_mask_lines(mask=mask_lines_binary)
+    return mask_ground_binary, mask_lines_binary
+
+
+def extract_mask_of_ground_lines_in_image(
+    image: ndarray,
+    ground_mask: ndarray,
+    blur_ksize: int = 5,
+    canny_low: int = 30,
+    canny_high: int = 100,
+    use_tophat: bool = True,
+    dilate_kernel_size: int = 3,
+    dilate_iterations: int = 3,
+) -> ndarray:
+    """Extract line mask from image using edge detection on ground region."""
+    gray = cvtColor(image, COLOR_BGR2GRAY)
+
+    if use_tophat:
+        kernel = getStructuringElement(MORPH_RECT, (31, 31))
+        gray = morphologyEx(gray, MORPH_TOPHAT, kernel)
+
+    if blur_ksize and blur_ksize % 2 == 1:
+        gray = GaussianBlur(gray, (blur_ksize, blur_ksize), 0)
+
+    image_edges = Canny(gray, canny_low, canny_high)
+    image_edges_on_ground = bitwise_and(image_edges, image_edges, mask=ground_mask)
+
+    if dilate_kernel_size > 1:
+        dilate_kernel = getStructuringElement(
+            MORPH_RECT, (dilate_kernel_size, dilate_kernel_size)
+        )
+        image_edges_on_ground = dilate(
+            image_edges_on_ground, dilate_kernel, iterations=dilate_iterations
+        )
+
+    return (image_edges_on_ground > 0).astype(uint8)
+
+
+def evaluate_keypoints_for_frame(
+    template_keypoints: List[Tuple[int, int]],
+    frame_keypoints: List[Tuple[int, int]],
+    frame: ndarray,
+    floor_markings_template: ndarray,
+) -> float:
+    """
+    Evaluate keypoint accuracy for a single frame.
+    
+    Returns score between 0.0 and 1.0 based on overlap between
+    projected template lines and detected lines in frame.
+    """
+    try:
+        warped_template = project_image_using_keypoints(
+            image=floor_markings_template,
+            source_keypoints=template_keypoints,
+            destination_keypoints=frame_keypoints,
+            destination_width=frame.shape[1],
+            destination_height=frame.shape[0],
+        )
+
+        mask_ground, mask_lines_expected = extract_masks_for_ground_and_lines(
+            image=warped_template
+        )
+
+        mask_lines_predicted = extract_mask_of_ground_lines_in_image(
+            image=frame, ground_mask=mask_ground
+        )
+
+        pixels_overlapping = bitwise_and(
+            mask_lines_expected, mask_lines_predicted
+        ).sum()
+
+        pixels_on_lines = mask_lines_expected.sum()
+
+        score = pixels_overlapping / (pixels_on_lines + 1e-8)
+        return min(1.0, max(0.0, score))  # Clamp to [0, 1]
+
+    except (InvalidMask, ValueError) as e:
+        logger.debug(f"Keypoint evaluation failed: {e}")
+        return 0.0
+    except Exception as e:
+        logger.error(f"Unexpected error in keypoint evaluation: {e}")
+        return 0.0
+
+
+def load_template_from_file(
+    template_image_path: str,
+) -> Tuple[ndarray, List[Tuple[int, int]]]:
+    """
+    Load template image and use TEMPLATE_KEYPOINTS constant for keypoints.
+    
+    Args:
+        template_image_path: Path to template image file
+    
+    Returns:
+        template_image: Loaded template image
+        template_keypoints: List of (x, y) keypoint coordinates from TEMPLATE_KEYPOINTS constant
+    """
+    # Load template image
+    template_image = cv2.imread(template_image_path)
+    if template_image is None:
+        raise ValueError(f"Could not load template image from {template_image_path}")
+    
+    # Use TEMPLATE_KEYPOINTS constant
+    if len(TEMPLATE_KEYPOINTS) == 0:
+        raise ValueError(
+            "TEMPLATE_KEYPOINTS constant is empty. Please define keypoints in keypoint_evaluation.py"
+        )
+    
+    if len(TEMPLATE_KEYPOINTS) < 4:
+        raise ValueError(f"TEMPLATE_KEYPOINTS must have at least 4 keypoints, found {len(TEMPLATE_KEYPOINTS)}")
+    
+    logger.info(f"Loaded template image: {template_image_path}")
+    logger.info(f"Using TEMPLATE_KEYPOINTS constant with {len(TEMPLATE_KEYPOINTS)} keypoints")
+    
+    return template_image, TEMPLATE_KEYPOINTS
+

miner.py

@@ -0,0 +1,675 @@
+from pathlib import Path
+from typing import List, Tuple, Dict, Optional
+import sys
+import os
+
+from numpy import ndarray
+from pydantic import BaseModel
+
+from keypoint_evaluation import evaluate_keypoints_for_frame, load_template_from_file
+sys.path.append(os.path.dirname(os.path.abspath(__file__)))
+
+from ultralytics import YOLO
+from team_cluster import TeamClassifier
+from utils import (
+    BoundingBox, 
+    Constants,
+    classify_teams_batch,
+)
+
+import time
+import torch
+import gc
+import cv2
+import numpy as np
+from collections import defaultdict
+from pitch import process_batch_input, get_cls_net
+import yaml
+
+
+class BoundingBox(BaseModel):
+    x1: int
+    y1: int
+    x2: int
+    y2: int
+    cls_id: int
+    conf: float
+
+
+class TVFrameResult(BaseModel):
+    frame_id: int
+    boxes: List[BoundingBox]
+    keypoints: List[Tuple[int, int]]
+
+
+class Miner:
+    SMALL_CONTAINED_IOA = Constants.SMALL_CONTAINED_IOA
+    SMALL_RATIO_MAX = Constants.SMALL_RATIO_MAX
+    SINGLE_PLAYER_HUE_PIVOT = Constants.SINGLE_PLAYER_HUE_PIVOT
+    CORNER_INDICES = Constants.CORNER_INDICES
+    KEYPOINTS_CONFIDENCE = Constants.KEYPOINTS_CONFIDENCE
+    CORNER_CONFIDENCE = Constants.CORNER_CONFIDENCE
+    GOALKEEPER_POSITION_MARGIN = Constants.GOALKEEPER_POSITION_MARGIN
+    MIN_SAMPLES_FOR_FIT = 16  # Minimum player crops needed before fitting TeamClassifier
+    MAX_SAMPLES_FOR_FIT = 600  # Maximum samples to avoid overfitting
+
+    def __init__(self, path_hf_repo: Path) -> None:
+        try:
+            device = "cuda" if torch.cuda.is_available() else "cpu"
+            model_path = path_hf_repo / "detection.onnx"
+            self.bbox_model = YOLO(model_path)
+            
+            print(f"BBox Model Loaded: class name {self.bbox_model.names}")
+
+            team_model_path = path_hf_repo / "osnet_model.pth.tar-100"
+            self.team_classifier = TeamClassifier(
+                device=device,
+                batch_size=32,
+                model_name=str(team_model_path)
+            )
+            print("Team Classifier Loaded")
+            
+            # Team classification state
+            self.team_classifier_fitted = False
+            self.player_crops_for_fit = [] 
+
+            self.keypoints_model_yolo = YOLO(path_hf_repo / "keypoint.pt")
+
+            model_kp_path = path_hf_repo / 'keypoint'
+            config_kp_path = path_hf_repo / 'hrnetv2_w48.yaml'
+            cfg_kp = yaml.safe_load(open(config_kp_path, 'r'))
+            
+            loaded_state_kp = torch.load(model_kp_path, map_location=device)
+            model = get_cls_net(cfg_kp)
+            model.load_state_dict(loaded_state_kp)
+            model.to(device)
+            model.eval()
+
+            self.keypoints_model = model
+            print("Keypoints Model (keypoint.pt) Loaded")
+
+            template_image_path = path_hf_repo / "football_pitch_template.png"
+            self.template_image, self.template_keypoints = load_template_from_file(str(template_image_path))
+
+            self.kp_threshold = 0.1
+            self.pitch_batch_size = 4
+            self.health = "healthy"
+            print("✅ Keypoints Model Loaded")
+        except Exception as e:
+            self.health = "❌ Miner initialization failed: " + str(e)
+            print(self.health)
+
+    def __repr__(self) -> str:
+        if self.health == 'healthy':
+            return (
+                f"health: {self.health}\n"
+                f"BBox Model: {type(self.bbox_model).__name__}\n"
+                f"Keypoints Model: {type(self.keypoints_model).__name__}"
+            )
+        else:
+            return self.health
+
+    def _calculate_iou(self, box1: Tuple[float, float, float, float],
+                       box2: Tuple[float, float, float, float]) -> float:
+        """
+        Calculate Intersection over Union (IoU) between two bounding boxes.
+        Args:
+            box1: (x1, y1, x2, y2)
+            box2: (x1, y1, x2, y2)
+        Returns:
+            IoU score (0-1)
+        """
+        x1_1, y1_1, x2_1, y2_1 = box1
+        x1_2, y1_2, x2_2, y2_2 = box2
+
+        # Calculate intersection area
+        x_left = max(x1_1, x1_2)
+        y_top = max(y1_1, y1_2)
+        x_right = min(x2_1, x2_2)
+        y_bottom = min(y2_1, y2_2)
+
+        if x_right < x_left or y_bottom < y_top:
+            return 0.0
+
+        intersection_area = (x_right - x_left) * (y_bottom - y_top)
+
+        # Calculate union area
+        box1_area = (x2_1 - x1_1) * (y2_1 - y1_1)
+        box2_area = (x2_2 - x1_2) * (y2_2 - y1_2)
+        union_area = box1_area + box2_area - intersection_area
+
+        if union_area == 0:
+            return 0.0
+
+        return intersection_area / union_area
+
+    def _extract_jersey_region(self, crop: ndarray) -> ndarray:
+        """
+        Extract jersey region (upper body) from player crop.
+        For close-ups, focuses on upper 60%, for distant shots uses full crop.
+        """
+        if crop is None or crop.size == 0:
+            return crop
+        
+        h, w = crop.shape[:2]
+        if h < 10 or w < 10:
+            return crop
+        
+        # For close-up shots, extract upper body (jersey region)
+        is_closeup = h > 100 or (h * w) > 12000
+        if is_closeup:
+            # Upper 60% of the crop (jersey area, avoiding shorts)
+            jersey_top = 0
+            jersey_bottom = int(h * 0.60)
+            jersey_left = max(0, int(w * 0.05))
+            jersey_right = min(w, int(w * 0.95))
+            return crop[jersey_top:jersey_bottom, jersey_left:jersey_right]
+        return crop
+
+    def _extract_color_signature(self, crop: ndarray) -> Optional[np.ndarray]:
+        """
+        Extract color signature from jersey region using HSV and LAB color spaces.
+        Returns a feature vector with dominant colors and color statistics.
+        """
+        if crop is None or crop.size == 0:
+            return None
+        
+        jersey_region = self._extract_jersey_region(crop)
+        if jersey_region.size == 0:
+            return None
+        
+        try:
+            # Convert to HSV and LAB color spaces
+            hsv = cv2.cvtColor(jersey_region, cv2.COLOR_BGR2HSV)
+            lab = cv2.cvtColor(jersey_region, cv2.COLOR_BGR2LAB)
+            
+            # Reshape for processing
+            hsv_flat = hsv.reshape(-1, 3).astype(np.float32)
+            lab_flat = lab.reshape(-1, 3).astype(np.float32)
+            
+            # Compute statistics for HSV
+            hsv_mean = np.mean(hsv_flat, axis=0) / 255.0
+            hsv_std = np.std(hsv_flat, axis=0) / 255.0
+            
+            # Compute statistics for LAB
+            lab_mean = np.mean(lab_flat, axis=0) / 255.0
+            lab_std = np.std(lab_flat, axis=0) / 255.0
+            
+            # Dominant color (most frequent hue)
+            hue_hist, _ = np.histogram(hsv_flat[:, 0], bins=36, range=(0, 180))
+            dominant_hue = np.argmax(hue_hist) * 5  # Convert to hue value
+            
+            # Combine features
+            color_features = np.concatenate([
+                hsv_mean,
+                hsv_std,
+                lab_mean[:2],  # L and A channels (B is less informative)
+                lab_std[:2],
+                [dominant_hue / 180.0]  # Normalized dominant hue
+            ])
+            
+            return color_features
+        except Exception as e:
+            print(f"Error extracting color signature: {e}")
+            return None
+
+    def _get_spatial_position(self, bbox: Tuple[float, float, float, float], 
+                              frame_width: int, frame_height: int) -> Tuple[float, float]:
+        """
+        Get normalized spatial position of player on the pitch.
+        Returns (x_normalized, y_normalized) where 0,0 is top-left.
+        """
+        x1, y1, x2, y2 = bbox
+        center_x = (x1 + x2) / 2.0
+        center_y = (y1 + y2) / 2.0
+        
+        # Normalize to [0, 1]
+        x_norm = center_x / frame_width if frame_width > 0 else 0.5
+        y_norm = center_y / frame_height if frame_height > 0 else 0.5
+        
+        return (x_norm, y_norm)
+
+    def _find_best_match(self, target_box: Tuple[float, float, float, float],
+                        predicted_frame_data: Dict[int, Tuple[Tuple, str]],
+                        iou_threshold: float) -> Tuple[Optional[str], float]:
+        """
+        Find best matching box in predicted frame data using IoU.
+        """
+        best_iou = 0.0
+        best_team_id = None
+        
+        for idx, (bbox, team_cls_id) in predicted_frame_data.items():
+            iou = self._calculate_iou(target_box, bbox)
+            if iou > best_iou and iou >= iou_threshold:
+                best_iou = iou
+                best_team_id = team_cls_id
+        
+        return (best_team_id, best_iou)
+
+    def _detect_objects_batch(self, decoded_images: List[ndarray]) -> Dict[int, List[BoundingBox]]:
+        batch_size = 16
+        detection_results = []
+        n_frames = len(decoded_images)
+        for frame_number in range(0, n_frames, batch_size):
+            batch_images = decoded_images[frame_number: frame_number + batch_size]
+            detections = self.bbox_model(batch_images, verbose=False, save=False)
+            detection_results.extend(detections)
+        
+        return detection_results
+
+    def _team_classify(self, detection_results, decoded_images, offset):
+        """
+        Hybrid team classification combining:
+        1. Appearance features (OSNet)
+        2. Color signatures (HSV/LAB)
+        3. Spatial priors (left/right side of pitch)
+        4. Temporal tracking (same player = same team)
+        """
+        start = time.time()
+        
+        # Phase 1: Collect samples and fit appearance-based classifier
+        fit_sample_size = min(self.MAX_SAMPLES_FOR_FIT, len(detection_results) * 10)
+        player_crops_for_fit = []
+        
+        for frame_id in range(len(detection_results)):
+            detection_box = detection_results[frame_id].boxes.data
+            if len(detection_box) < 4:
+                continue
+            
+            if len(player_crops_for_fit) < fit_sample_size:
+                frame_image = decoded_images[frame_id]
+                for box in detection_box:
+                    x1, y1, x2, y2, conf, cls_id = box.tolist()
+                    if conf < 0.5 or cls_id != 2:
+                        continue
+                    crop = frame_image[int(y1):int(y2), int(x1):int(x2)]
+                    if crop.size > 0:
+                        player_crops_for_fit.append(crop)
+            
+            if self.team_classifier and not self.team_classifier_fitted and len(player_crops_for_fit) >= fit_sample_size:
+                print(f"Fitting TeamClassifier (OSNet) with {len(player_crops_for_fit)} player crops")
+                self.team_classifier.fit(player_crops_for_fit)
+                self.team_classifier_fitted = True
+                break
+        
+        if not self.team_classifier_fitted and len(player_crops_for_fit) >= self.MIN_SAMPLES_FOR_FIT:
+            print(f"Fallback: Fitting TeamClassifier with {len(player_crops_for_fit)} player crops")
+            self.team_classifier.fit(player_crops_for_fit)
+            self.team_classifier_fitted = True
+        
+        print(f"Fitting time: {time.time() - start:.2f}s")
+        
+        # Phase 2: Hybrid classification for all frames
+        start = time.time()
+        bboxes: dict[int, list[BoundingBox]] = {}
+        
+        # Temporal tracking: {track_id: (team_id, confidence, last_frame)}
+        player_tracks: Dict[Tuple, Tuple[int, float, int]] = {}
+        
+        # Spatial team assignment: track which team is on which side
+        left_side_team = None
+        right_side_team = None
+        
+        for frame_id in range(len(detection_results)):
+            detection_box = detection_results[frame_id].boxes.data
+            frame_image = decoded_images[frame_id]
+            frame_h, frame_w = frame_image.shape[:2]
+            boxes = []
+            
+            # Collect all players in this frame
+            player_data = []  # (idx, crop, bbox, spatial_pos, color_sig)
+            
+            for idx, box in enumerate(detection_box):
+                x1, y1, x2, y2, conf, cls_id = box.tolist()
+                if cls_id != 2 or conf < 0.6:
+                    continue
+                
+                crop = frame_image[int(y1):int(y2), int(x1):int(x2)]
+                if crop.size == 0:
+                    continue
+                
+                bbox = (x1, y1, x2, y2)
+                spatial_pos = self._get_spatial_position(bbox, frame_w, frame_h)
+                color_sig = self._extract_color_signature(crop)
+                
+                player_data.append((idx, crop, bbox, spatial_pos, color_sig))
+            
+            if len(player_data) == 0:
+                bboxes[offset + frame_id] = []
+                continue
+            
+            # Step 1: Get appearance-based predictions (OSNet)
+            appearance_predictions = {}
+            if self.team_classifier and self.team_classifier_fitted:
+                crops = [data[1] for data in player_data]
+                appearance_team_ids = self.team_classifier.predict(crops)
+                for (idx, _, _, _, _), team_id in zip(player_data, appearance_team_ids):
+                    appearance_predictions[idx] = team_id
+            
+            # Step 2: Extract color signatures and cluster
+            color_signatures = []
+            color_indices = []
+            for idx, _, _, _, color_sig in player_data:
+                if color_sig is not None:
+                    color_signatures.append(color_sig)
+                    color_indices.append(idx)
+            
+            color_predictions = {}
+            if len(color_signatures) >= 4:
+                try:
+                    from sklearn.cluster import KMeans
+                    color_kmeans = KMeans(n_clusters=2, random_state=42, n_init=10)
+                    color_clusters = color_kmeans.fit_predict(color_signatures)
+                    for idx, cluster_id in zip(color_indices, color_clusters):
+                        color_predictions[idx] = cluster_id
+                except Exception as e:
+                    print(f"Color clustering failed: {e}")
+            
+            # Step 3: Apply spatial priors
+            # Determine which team is on which side based on majority
+            if left_side_team is None or right_side_team is None:
+                left_side_players = [p for p in player_data if p[3][0] < 0.5]  # x < 0.5
+                right_side_players = [p for p in player_data if p[3][0] >= 0.5]  # x >= 0.5
+                
+                if len(left_side_players) >= 2 and len(right_side_players) >= 2:
+                    # Use appearance predictions to determine sides
+                    left_teams = [appearance_predictions.get(p[0]) for p in left_side_players 
+                                 if p[0] in appearance_predictions]
+                    right_teams = [appearance_predictions.get(p[0]) for p in right_side_players 
+                                  if p[0] in appearance_predictions]
+                    
+                    if left_teams and right_teams:
+                        left_team_mode = max(set(left_teams), key=left_teams.count)
+                        right_team_mode = max(set(right_teams), key=right_teams.count)
+                        
+                        if left_team_mode != right_team_mode:
+                            left_side_team = left_team_mode
+                            right_side_team = right_team_mode
+            
+            # Step 4: Combine predictions with voting
+            final_predictions = {}
+            for idx, _, bbox, spatial_pos, _ in player_data:
+                votes = []
+                weights = []
+                
+                # Appearance vote (weight: 0.4)
+                if idx in appearance_predictions:
+                    votes.append(appearance_predictions[idx])
+                    weights.append(0.4)
+                
+                # Color vote (weight: 0.3)
+                if idx in color_predictions:
+                    votes.append(color_predictions[idx])
+                    weights.append(0.3)
+                
+                # Spatial vote (weight: 0.3)
+                if left_side_team is not None and right_side_team is not None:
+                    x_pos, _ = spatial_pos
+                    if x_pos < 0.5:
+                        spatial_team = left_side_team
+                    else:
+                        spatial_team = right_side_team
+                    votes.append(spatial_team)
+                    weights.append(0.3)
+                
+                # Temporal vote (weight: 0.2) - match with previous frames
+                if len(votes) > 0:
+                    # Simple temporal matching: find similar bbox in previous frames
+                    best_track_match = None
+                    best_track_iou = 0.0
+                    for track_key, (track_team, track_conf, track_frame) in player_tracks.items():
+                        if abs(track_frame - frame_id) <= 5:  # Within 5 frames
+                            track_bbox = track_key
+                            iou = self._calculate_iou(bbox, track_bbox)
+                            if iou > best_track_iou and iou > 0.3:
+                                best_track_iou = iou
+                                best_track_match = track_team
+                    
+                    if best_track_match is not None:
+                        votes.append(best_track_match)
+                        weights.append(0.2)
+                
+                # Weighted voting
+                if len(votes) > 0:
+                    team_0_score = sum(w for v, w in zip(votes, weights) if v == 0)
+                    team_1_score = sum(w for v, w in zip(votes, weights) if v == 1)
+                    
+                    if team_0_score > team_1_score:
+                        final_team = 0
+                    elif team_1_score > team_0_score:
+                        final_team = 1
+                    else:
+                        # Tie: use appearance prediction or first vote
+                        final_team = votes[0] if votes else 0
+                    
+                    final_predictions[idx] = final_team
+                    
+                    # Update tracking
+                    track_key = bbox
+                    player_tracks[track_key] = (final_team, max(team_0_score, team_1_score), frame_id)
+            
+            # Step 5: Generate output boxes
+            for idx, box in enumerate(detection_box):
+                x1, y1, x2, y2, conf, cls_id = box.tolist()
+                if cls_id == 2 and conf < 0.6:
+                    continue
+                
+                # Check overlap with staff
+                overlap_staff = False
+                for idy, boxy in enumerate(detection_box):
+                    s_x1, s_y1, s_x2, s_y2, s_conf, s_cls_id = boxy.tolist()
+                    if cls_id == 2 and s_cls_id == 4:
+                        staff_iou = self._calculate_iou(box[:4], boxy[:4])
+                        if staff_iou >= 0.8:
+                            overlap_staff = True
+                            break
+                if overlap_staff:
+                    continue
+                
+                mapped_cls_id = str(int(cls_id))
+                
+                # Override with team prediction
+                if idx in final_predictions:
+                    mapped_cls_id = str(6 + int(final_predictions[idx]))
+                
+                if mapped_cls_id != '4':
+                    if int(mapped_cls_id) == 3 and conf < 0.5:
+                        continue
+                    boxes.append(
+                        BoundingBox(
+                            x1=int(x1),
+                            y1=int(y1),
+                            x2=int(x2),
+                            y2=int(y2),
+                            cls_id=int(mapped_cls_id),
+                            conf=float(conf),
+                        )
+                    )
+            
+            # Handle footballs - keep only the best one
+            footballs = [bb for bb in boxes if int(bb.cls_id) == 0]
+            if len(footballs) > 1:
+                best_ball = max(footballs, key=lambda b: b.conf)
+                boxes = [bb for bb in boxes if int(bb.cls_id) != 0]
+                boxes.append(best_ball)
+            
+            bboxes[offset + frame_id] = boxes
+        
+        print(f"Hybrid team classification time: {time.time() - start:.2f}s")
+        return bboxes
+
+
+    def predict_batch(self, batch_images: List[ndarray], offset: int, n_keypoints: int) -> List[TVFrameResult]:        
+        start = time.time()
+        detection_results = self._detect_objects_batch(batch_images)
+        end = time.time()
+        print(f"Detection time: {end - start}")
+        
+        # Use hybrid team classification
+        start = time.time()
+        bboxes = self._team_classify(detection_results, batch_images, offset)
+        end = time.time()
+        print(f"Team classify time: {end - start}")
+
+        # Phase 3: Keypoint Detection
+        keypoints_yolo: Dict[int, List[Tuple[int, int]]] = {}
+
+        keypoints_yolo = self._detect_keypoints_batch(batch_images, offset, n_keypoints)
+
+
+        pitch_batch_size = min(self.pitch_batch_size, len(batch_images))
+        keypoints: Dict[int, List[Tuple[int, int]]] = {}
+
+        start = time.time()
+        while True:
+            gc.collect()
+            if torch.cuda.is_available():
+                torch.cuda.empty_cache()
+                torch.cuda.synchronize()
+            device_str = "cuda"
+            keypoints_result = process_batch_input(
+                batch_images,
+                self.keypoints_model,
+                self.kp_threshold,
+                device_str,
+                batch_size=pitch_batch_size,
+            )
+            if keypoints_result is not None and len(keypoints_result) > 0:
+                for frame_number_in_batch, kp_dict in enumerate(keypoints_result):
+                    if frame_number_in_batch >= len(batch_images):
+                        break
+                    frame_keypoints: List[Tuple[int, int]] = []
+                    try:
+                        height, width = batch_images[frame_number_in_batch].shape[:2]
+                        if kp_dict is not None and isinstance(kp_dict, dict):
+                            for idx in range(32):
+                                x, y = 0, 0
+                                kp_idx = idx + 1
+                                if kp_idx in kp_dict:
+                                    try:
+                                        kp_data = kp_dict[kp_idx]
+                                        if isinstance(kp_data, dict) and "x" in kp_data and "y" in kp_data:
+                                            x = int(kp_data["x"] * width)
+                                            y = int(kp_data["y"] * height)
+                                    except (KeyError, TypeError, ValueError):
+                                        pass
+                                frame_keypoints.append((x, y))
+                    except (IndexError, ValueError, AttributeError):
+                        frame_keypoints = [(0, 0)] * 32
+                    if len(frame_keypoints) < n_keypoints:
+                        frame_keypoints.extend([(0, 0)] * (n_keypoints - len(frame_keypoints)))
+                    else:
+                        frame_keypoints = frame_keypoints[:n_keypoints]
+
+                    valid_keypoints = [kp for kp in frame_keypoints if kp[0] != 0.0 or kp[1] != 0.0]
+
+                    frame_keypoints_yolo = keypoints_yolo.get(offset + frame_number_in_batch, frame_keypoints)
+                    valid_keypoints_yolo = [kp for kp in frame_keypoints_yolo if kp[0] != 0.0 or kp[1] != 0.0]
+                    
+                    if len(valid_keypoints_yolo) > 3 and len(valid_keypoints) > 3:
+                        try:
+                            score = evaluate_keypoints_for_frame(
+                                template_keypoints=self.template_keypoints,
+                                frame_keypoints=frame_keypoints,
+                                frame=batch_images[frame_number_in_batch],
+                                floor_markings_template=self.template_image.copy(),
+                            )
+                
+                            score_yolo = evaluate_keypoints_for_frame(
+                                template_keypoints=self.template_keypoints,
+                                frame_keypoints=frame_keypoints_yolo,
+                                frame=batch_images[frame_number_in_batch],
+                                floor_markings_template=self.template_image.copy(),
+                            )
+
+                            if score_yolo > score:
+                                frame_keypoints = frame_keypoints_yolo
+                        except Exception as e:
+                            pass
+                    elif len(valid_keypoints_yolo) > 3:
+                        frame_keypoints = frame_keypoints_yolo
+ 
+
+                    keypoints[offset + frame_number_in_batch] = frame_keypoints
+            break
+        end = time.time()
+        print(f"Keypoint time: {end - start}")
+
+        results: List[TVFrameResult] = []
+        for frame_number in range(offset, offset + len(batch_images)):
+            frame_boxes = bboxes.get(frame_number, [])
+            result = TVFrameResult(
+                frame_id=frame_number,
+                boxes=frame_boxes,
+                keypoints=keypoints.get(
+                        frame_number,
+                        [(0, 0) for _ in range(n_keypoints)],
+                    ),
+            )
+            results.append(result)
+
+        gc.collect()
+        if torch.cuda.is_available():
+            torch.cuda.empty_cache()
+            torch.cuda.synchronize()
+
+        return results
+
+    def _detect_keypoints_batch(self, batch_images: List[ndarray], 
+                               offset: int, n_keypoints: int) -> Dict[int, List[Tuple[int, int]]]:
+        """
+        Phase 3: Keypoint detection for all frames in batch.
+        
+        Args:
+            batch_images: List of images to process
+            offset: Frame offset for numbering  
+            n_keypoints: Number of keypoints expected
+            
+        Returns:
+            Dictionary mapping frame_id to list of keypoint coordinates
+        """
+        keypoints: Dict[int, List[Tuple[int, int]]] = {}
+        keypoints_model_results = self.keypoints_model_yolo.predict(batch_images)
+        
+        if keypoints_model_results is None:
+            return keypoints
+            
+        for frame_idx_in_batch, detection in enumerate(keypoints_model_results):
+            if not hasattr(detection, "keypoints") or detection.keypoints is None:
+                continue
+                
+            # Extract keypoints with confidence
+            frame_keypoints_with_conf: List[Tuple[int, int, float]] = []
+            for i, part_points in enumerate(detection.keypoints.data):
+                for k_id, (x, y, _) in enumerate(part_points):
+                    confidence = float(detection.keypoints.conf[i][k_id])
+                    frame_keypoints_with_conf.append((int(x), int(y), confidence))
+            
+            # Pad or truncate to expected number of keypoints
+            if len(frame_keypoints_with_conf) < n_keypoints:
+                frame_keypoints_with_conf.extend(
+                    [(0, 0, 0.0)] * (n_keypoints - len(frame_keypoints_with_conf))
+                )
+            else:
+                frame_keypoints_with_conf = frame_keypoints_with_conf[:n_keypoints]
+            
+            # Filter keypoints based on confidence thresholds
+            filtered_keypoints: List[Tuple[int, int]] = []
+            for idx, (x, y, confidence) in enumerate(frame_keypoints_with_conf):
+                if idx in self.CORNER_INDICES:
+                    # Corner keypoints have lower confidence threshold
+                    if confidence < 0.3:
+                        filtered_keypoints.append((0, 0))
+                    else:
+                        filtered_keypoints.append((int(x), int(y)))
+                else:
+                    # Regular keypoints  
+                    if confidence < 0.5:
+                        filtered_keypoints.append((0, 0))
+                    else:
+                        filtered_keypoints.append((int(x), int(y)))
+            
+            frame_id = offset + frame_idx_in_batch
+            keypoints[frame_id] = filtered_keypoints
+            
+        return keypoints

miner1.py

@@ -0,0 +1,509 @@
+from pathlib import Path
+from typing import List, Tuple, Dict, Optional
+import sys, os
+sys.path.append(os.path.dirname(os.path.abspath(__file__)))
+import onnxruntime as ort
+import numpy as np
+import cv2
+from torchvision.ops import batched_nms
+import torch
+from ultralytics import YOLO
+from numpy import ndarray
+from pydantic import BaseModel
+from team_cluster import TeamClassifier
+from utils import (
+    BoundingBox, 
+    Constants,
+    suppress_small_contained_boxes,
+    classify_teams_batch,
+)
+
+
+class TVFrameResult(BaseModel):
+    frame_id: int
+    boxes: List[BoundingBox]
+    keypoints: List[Tuple[int, int]]
+
+
+class Miner:
+    """
+    Football video analysis system for object detection and team classification.
+    """
+    # Use constants from utils
+    SMALL_CONTAINED_IOA = Constants.SMALL_CONTAINED_IOA
+    SMALL_RATIO_MAX = Constants.SMALL_RATIO_MAX
+    SINGLE_PLAYER_HUE_PIVOT = Constants.SINGLE_PLAYER_HUE_PIVOT
+    CORNER_INDICES = Constants.CORNER_INDICES
+    KEYPOINTS_CONFIDENCE = Constants.KEYPOINTS_CONFIDENCE
+    CORNER_CONFIDENCE = Constants.CORNER_CONFIDENCE
+    GOALKEEPER_POSITION_MARGIN = Constants.GOALKEEPER_POSITION_MARGIN
+    MIN_SAMPLES_FOR_FIT = 16  # Minimum player crops needed before fitting TeamClassifier
+    MAX_SAMPLES_FOR_FIT = 500  # Maximum samples to avoid overfitting
+
+    def __init__(self, path_hf_repo: Path) -> None:
+        providers = [
+            'CUDAExecutionProvider',
+            'CPUExecutionProvider'
+        ]
+        model_path = path_hf_repo / "detection.onnx"
+        session = ort.InferenceSession(model_path, providers=providers)
+
+        input_name = session.get_inputs()[0].name
+        height = width = 640
+        dummy = np.zeros((1, 3, height, width), dtype=np.float32)
+        session.run(None, {input_name: dummy})
+        model = session
+        self.bbox_model = model
+        
+        print("BBox Model Loaded")
+        self.keypoints_model = YOLO(path_hf_repo / "keypoint.pt")
+        print("Keypoints Model (keypoint.pt) Loaded")
+        # Initialize team classifier with OSNet model
+        team_model_path = path_hf_repo / "osnet_model.pth.tar-100"
+        device = 'cuda'
+        self.team_classifier = TeamClassifier(
+            device=device,
+            batch_size=32,
+            model_name=str(team_model_path)
+        )
+        print("Team Classifier Loaded")
+        
+        # Team classification state
+        self.team_classifier_fitted = False
+        self.player_crops_for_fit = []  # Collect samples across frames
+
+    def __repr__(self) -> str:
+        return (
+            f"BBox Model: {type(self.bbox_model).__name__}\n"
+            f"Keypoints Model: {type(self.keypoints_model).__name__}"
+        )
+
+
+
+    def _handle_multiple_goalkeepers(self, boxes: List[BoundingBox]) -> List[BoundingBox]:
+        """
+        Handle goalkeeper detection issues:
+        1. Fix misplaced goalkeepers (standing in middle of field)
+        2. Limit to maximum 2 goalkeepers (one from each team)
+        
+        Returns:
+            Filtered list of boxes with corrected goalkeepers
+        """
+        # Step 1: Fix misplaced goalkeepers first
+        # Convert goalkeepers in middle of field to regular players
+        boxes = self._fix_misplaced_goalkeepers(boxes)
+        
+        # Step 2: Handle multiple goalkeepers (after fixing misplaced ones)
+        gk_idxs = [i for i, bb in enumerate(boxes) if int(bb.cls_id) == 1]
+        if len(gk_idxs) <= 2:
+            return boxes
+            
+        # Sort goalkeepers by confidence (highest first)
+        gk_idxs_sorted = sorted(gk_idxs, key=lambda i: boxes[i].conf, reverse=True)
+        keep_gk_idxs = set(gk_idxs_sorted[:2])  # Keep top 2 goalkeepers
+        
+        # Create new list keeping only top 2 goalkeepers
+        filtered_boxes = []
+        for i, box in enumerate(boxes):
+            if int(box.cls_id) == 1:
+                # Only keep the top 2 goalkeepers by confidence
+                if i in keep_gk_idxs:
+                    filtered_boxes.append(box)
+                # Skip extra goalkeepers
+            else:
+                # Keep all non-goalkeeper boxes
+                filtered_boxes.append(box)
+        
+        return filtered_boxes
+
+    def _fix_misplaced_goalkeepers(self, boxes: List[BoundingBox]) -> List[BoundingBox]:
+        """
+        """
+        gk_idxs = [i for i, bb in enumerate(boxes) if int(bb.cls_id) == 1]
+        player_idxs = [i for i, bb in enumerate(boxes) if int(bb.cls_id) == 2]
+        
+        if len(gk_idxs) == 0 or len(player_idxs) < 2:
+            return boxes
+            
+        updated_boxes = boxes.copy()
+        
+        for gk_idx in gk_idxs:
+            if boxes[gk_idx].conf < 0.3:
+                updated_boxes[gk_idx].cls_id = 2
+                
+        return updated_boxes
+
+
+    def _pre_process_img(self, frames: List[np.ndarray], scale: float = 640.0) -> np.ndarray:
+        """
+        Preprocess images for ONNX inference.
+        
+        Args:
+            frames: List of BGR frames
+            scale: Target scale for resizing
+            
+        Returns:
+            Preprocessed numpy array ready for ONNX inference
+        """
+        imgs = np.stack([cv2.resize(frame, (int(scale), int(scale))) for frame in frames])
+        imgs = imgs.transpose(0, 3, 1, 2)  # BHWC to BCHW
+        imgs = imgs.astype(np.float32) / 255.0  # Normalize to [0, 1]
+        return imgs
+
+    def _post_process_output(self, outputs: np.ndarray, x_scale: float, y_scale: float, 
+                            conf_thresh: float = 0.6, nms_thresh: float = 0.55) -> List[List[Tuple]]:
+        """
+        Post-process ONNX model outputs to get detections.
+        
+        Args:
+            outputs: Raw ONNX model outputs
+            x_scale: X-axis scaling factor 
+            y_scale: Y-axis scaling factor
+            conf_thresh: Confidence threshold
+            nms_thresh: NMS threshold
+            
+        Returns:
+            List of detections for each frame: [(box, conf, class_id), ...]
+        """
+        B, C, N = outputs.shape
+        outputs = torch.from_numpy(outputs)
+        outputs = outputs.permute(0, 2, 1)  # B,C,N -> B,N,C
+        
+        boxes = outputs[..., :4]
+        class_scores = 1 / (1 + torch.exp(-outputs[..., 4:]))  # Sigmoid activation
+        conf, class_id = class_scores.max(dim=2)
+
+        mask = conf > conf_thresh
+        
+        # Special handling for balls - keep best one even with lower confidence
+        for i in range(class_id.shape[0]):  # loop over batch
+            # Find detections that are balls
+            ball_mask = class_id[i] == 0
+            ball_idx = ball_mask.nonzero(as_tuple=True)[0]
+            if ball_idx.numel() > 0:
+                # Pick the one with the highest confidence
+                best_ball_idx = ball_idx[conf[i, ball_idx].argmax()]
+                if conf[i, best_ball_idx] >= 0.55:  # apply confidence threshold
+                    mask[i, best_ball_idx] = True
+        
+        batch_idx, pred_idx = mask.nonzero(as_tuple=True)
+
+        if len(batch_idx) == 0:
+            return [[] for _ in range(B)]
+        
+        boxes = boxes[batch_idx, pred_idx]
+        conf = conf[batch_idx, pred_idx]
+        class_id = class_id[batch_idx, pred_idx]
+
+        # Convert from center format to xyxy format
+        x, y, w, h = boxes[:, 0], boxes[:, 1], boxes[:, 2], boxes[:, 3]
+        x1 = (x - w / 2) * x_scale
+        y1 = (y - h / 2) * y_scale
+        x2 = (x + w / 2) * x_scale
+        y2 = (y + h / 2) * y_scale
+        boxes_xyxy = torch.stack([x1, y1, x2, y2], dim=1)
+
+        # Apply batched NMS
+        max_coord = 1e4
+        offset = batch_idx.to(boxes_xyxy) * max_coord
+        boxes_for_nms = boxes_xyxy + offset[:, None]
+
+        keep = batched_nms(boxes_for_nms, conf, batch_idx, nms_thresh)
+
+        boxes_final = boxes_xyxy[keep]
+        conf_final = conf[keep]
+        class_final = class_id[keep]
+        batch_final = batch_idx[keep]
+
+        # Group results by batch
+        results = [[] for _ in range(B)]
+        for b in range(B):
+            mask_b = batch_final == b
+            if mask_b.sum() == 0:
+                continue
+            results[b] = list(zip(boxes_final[mask_b].numpy(),
+                                  conf_final[mask_b].numpy(),
+                                  class_final[mask_b].numpy()))
+        return results
+
+    def _ioa(self, a: BoundingBox, b: BoundingBox) -> float:
+        inter = self._intersect_area(a, b)
+        aa = self._area(a)
+        if aa <= 0:
+            return 0.0
+        return inter / aa
+
+    def suppress_small_contained(self, boxes: List[BoundingBox]) -> List[BoundingBox]:
+        if len(boxes) <= 1:
+            return boxes
+        keep = [True] * len(boxes)
+        areas = [self._area(bb) for bb in boxes]
+        for i in range(len(boxes)):
+            if not keep[i]:
+                continue
+            for j in range(len(boxes)):
+                if i == j or not keep[j]:
+                    continue
+                ai, aj = areas[i], areas[j]
+                if ai == 0 or aj == 0:
+                    continue
+                if ai <= aj:
+                    ratio = ai / aj
+                    if ratio <= self.SMALL_RATIO_MAX:
+                        ioa_i_in_j = self._ioa(boxes[i], boxes[j])
+                        if ioa_i_in_j >= self.SMALL_CONTAINED_IOA:
+                            keep[i] = False
+                            break
+                else:
+                    ratio = aj / ai
+                    if ratio <= self.SMALL_RATIO_MAX:
+                        ioa_j_in_i = self._ioa(boxes[j], boxes[i])
+                        if ioa_j_in_i >= self.SMALL_CONTAINED_IOA:
+                            keep[j] = False
+        return [bb for bb, k in zip(boxes, keep) if k]
+
+    def _detect_objects_batch(self, batch_images: List[ndarray], offset: int) -> Dict[int, List[BoundingBox]]:
+        """
+        Phase 1: Object detection for all frames in batch.
+        Returns detected objects with players still having class_id=2 (before team classification).
+        
+        Args:
+            batch_images: List of images to process
+            offset: Frame offset for numbering
+            
+        Returns:
+            Dictionary mapping frame_id to list of detected boxes
+        """
+        bboxes: Dict[int, List[BoundingBox]] = {}
+
+        if len(batch_images) == 0:
+            return bboxes
+            
+        print(f"Processing batch of {len(batch_images)} images")
+        
+        # Get original image dimensions for scaling
+        height, width = batch_images[0].shape[:2]
+        scale = 640.0
+        x_scale = width / scale
+        y_scale = height / scale
+        
+        # Memory optimization: Process smaller batches if needed
+        max_batch_size = 32  # Reduce batch size further to prevent memory issues
+        if len(batch_images) > max_batch_size:
+            print(f"Large batch detected ({len(batch_images)} images), splitting into smaller batches of {max_batch_size}")
+            # Process in smaller chunks
+            all_bboxes = {}
+            for chunk_start in range(0, len(batch_images), max_batch_size):
+                chunk_end = min(chunk_start + max_batch_size, len(batch_images))
+                chunk_images = batch_images[chunk_start:chunk_end]
+                chunk_offset = offset + chunk_start
+                print(f"Processing chunk {chunk_start//max_batch_size + 1}: images {chunk_start}-{chunk_end-1}")
+                chunk_bboxes = self._detect_objects_batch(chunk_images, chunk_offset)
+                all_bboxes.update(chunk_bboxes)
+            return all_bboxes
+        
+        # Preprocess images for ONNX inference
+        imgs = self._pre_process_img(batch_images, scale)
+        actual_batch_size = len(batch_images)
+        
+        # Handle batch size mismatch - pad if needed
+        model_batch_size = self.bbox_model.get_inputs()[0].shape[0]
+        print(f"Model input shape: {self.bbox_model.get_inputs()[0].shape}, batch_size: {model_batch_size}")
+        
+        if model_batch_size is not None:
+            try:
+                # Handle dynamic batch size (None, -1, 'None')
+                if str(model_batch_size) in ['None', '-1'] or model_batch_size == -1:
+                    model_batch_size = None
+                else:
+                    model_batch_size = int(model_batch_size)
+            except (ValueError, TypeError):
+                model_batch_size = None
+        
+        print(f"Processed model_batch_size: {model_batch_size}, actual_batch_size: {actual_batch_size}")
+                
+        if model_batch_size and actual_batch_size < model_batch_size:
+            padding_size = model_batch_size - actual_batch_size
+            dummy_img = np.zeros((1, 3, int(scale), int(scale)), dtype=np.float32)
+            padding = np.repeat(dummy_img, padding_size, axis=0)
+            imgs = np.vstack([imgs, padding])
+        
+        # ONNX inference with error handling
+        try:
+            input_name = self.bbox_model.get_inputs()[0].name
+            import time
+            start_time = time.time()
+            outputs = self.bbox_model.run(None, {input_name: imgs})[0]
+            inference_time = time.time() - start_time
+            print(f"Inference time: {inference_time:.3f}s for {actual_batch_size} images")
+            
+            # Remove padded results if we added padding
+            if model_batch_size and isinstance(model_batch_size, int) and actual_batch_size < model_batch_size:
+                outputs = outputs[:actual_batch_size]
+            
+            # Post-process outputs to get detections
+            raw_results = self._post_process_output(np.array(outputs), x_scale, y_scale)
+            
+        except Exception as e:
+            print(f"Error during ONNX inference: {e}")
+            return bboxes
+        
+        if not raw_results:
+            return bboxes
+            
+        # Convert raw results to BoundingBox objects and apply processing
+        for frame_idx_in_batch, frame_detections in enumerate(raw_results):
+            if not frame_detections:
+                continue
+                
+            # Convert to BoundingBox objects
+            boxes: List[BoundingBox] = []
+            for box, conf, cls_id in frame_detections:
+                x1, y1, x2, y2 = box
+                if int(cls_id) < 4:
+                    boxes.append(
+                        BoundingBox(
+                            x1=int(x1),
+                            y1=int(y1),
+                            x2=int(x2),
+                            y2=int(y2),
+                            cls_id=int(cls_id),
+                            conf=float(conf),
+                        )
+                    )
+            
+            # Handle footballs - keep only the best one
+            footballs = [bb for bb in boxes if int(bb.cls_id) == 0]
+            if len(footballs) > 1:
+                best_ball = max(footballs, key=lambda b: b.conf)
+                boxes = [bb for bb in boxes if int(bb.cls_id) != 0]
+                boxes.append(best_ball)
+
+            # Remove overlapping small boxes
+            boxes = suppress_small_contained_boxes(boxes, self.SMALL_CONTAINED_IOA, self.SMALL_RATIO_MAX)
+            
+            # Handle goalkeeper detection issues:
+            # 1. Fix misplaced goalkeepers (convert to players if standing in middle)
+            # 2. Allow up to 2 goalkeepers maximum (one from each team)
+            # Goalkeepers remain class_id = 1 (no team assignment)
+            boxes = self._handle_multiple_goalkeepers(boxes)
+            
+            # Store results (players still have class_id=2, will be classified in phase 2)
+            frame_id = offset + frame_idx_in_batch
+            bboxes[frame_id] = boxes
+            
+        return bboxes
+
+
+    def predict_batch(
+        self,
+        batch_images: List[ndarray],
+        offset: int,
+        n_keypoints: int,
+        task_type: Optional[str] = None,
+    ) -> List[TVFrameResult]:
+        process_objects = task_type is None or task_type == "object"
+        process_keypoints = task_type is None or task_type == "keypoint"
+        
+        # Phase 1: Object Detection for all frames
+        bboxes: Dict[int, List[BoundingBox]] = {}
+        if process_objects:
+            bboxes = self._detect_objects_batch(batch_images, offset)
+        
+        import time
+        time_start = time.time()
+        # Phase 2: Team Classification for all detected players
+        if process_objects and bboxes:
+            bboxes, self.team_classifier_fitted, self.player_crops_for_fit = classify_teams_batch(
+                self.team_classifier, 
+                self.team_classifier_fitted,
+                self.player_crops_for_fit,
+                batch_images, 
+                bboxes, 
+                offset,
+                self.MIN_SAMPLES_FOR_FIT,
+                self.MAX_SAMPLES_FOR_FIT,
+                self.SINGLE_PLAYER_HUE_PIVOT
+            )
+        self.team_classifier_fitted = False
+        self.player_crops_for_fit = []
+        print(f"Time Team Classification: {time.time() - time_start} s")
+
+        # Phase 3: Keypoint Detection
+        keypoints: Dict[int, List[Tuple[int, int]]] = {}
+        if process_keypoints:
+            keypoints = self._detect_keypoints_batch(batch_images, offset, n_keypoints)
+        
+        # Phase 4: Combine results
+        results: List[TVFrameResult] = []
+        for frame_number in range(offset, offset + len(batch_images)):
+            results.append(
+                TVFrameResult(
+                    frame_id=frame_number,
+                    boxes=bboxes.get(frame_number, []),
+                    keypoints=keypoints.get(
+                        frame_number,
+                        [(0, 0) for _ in range(n_keypoints)],
+                    ),
+                )
+            )
+        return results
+
+    def _detect_keypoints_batch(self, batch_images: List[ndarray], 
+                               offset: int, n_keypoints: int) -> Dict[int, List[Tuple[int, int]]]:
+        """
+        Phase 3: Keypoint detection for all frames in batch.
+        
+        Args:
+            batch_images: List of images to process
+            offset: Frame offset for numbering  
+            n_keypoints: Number of keypoints expected
+            
+        Returns:
+            Dictionary mapping frame_id to list of keypoint coordinates
+        """
+        keypoints: Dict[int, List[Tuple[int, int]]] = {}
+        keypoints_model_results = self.keypoints_model.predict(batch_images)
+        
+        if keypoints_model_results is None:
+            return keypoints
+            
+        for frame_idx_in_batch, detection in enumerate(keypoints_model_results):
+            if not hasattr(detection, "keypoints") or detection.keypoints is None:
+                continue
+                
+            # Extract keypoints with confidence
+            frame_keypoints_with_conf: List[Tuple[int, int, float]] = []
+            for i, part_points in enumerate(detection.keypoints.data):
+                for k_id, (x, y, _) in enumerate(part_points):
+                    confidence = float(detection.keypoints.conf[i][k_id])
+                    frame_keypoints_with_conf.append((int(x), int(y), confidence))
+            
+            # Pad or truncate to expected number of keypoints
+            if len(frame_keypoints_with_conf) < n_keypoints:
+                frame_keypoints_with_conf.extend(
+                    [(0, 0, 0.0)] * (n_keypoints - len(frame_keypoints_with_conf))
+                )
+            else:
+                frame_keypoints_with_conf = frame_keypoints_with_conf[:n_keypoints]
+            
+            # Filter keypoints based on confidence thresholds
+            filtered_keypoints: List[Tuple[int, int]] = []
+            for idx, (x, y, confidence) in enumerate(frame_keypoints_with_conf):
+                if idx in self.CORNER_INDICES:
+                    # Corner keypoints have lower confidence threshold
+                    if confidence < 0.3:
+                        filtered_keypoints.append((0, 0))
+                    else:
+                        filtered_keypoints.append((int(x), int(y)))
+                else:
+                    # Regular keypoints  
+                    if confidence < 0.5:
+                        filtered_keypoints.append((0, 0))
+                    else:
+                        filtered_keypoints.append((int(x), int(y)))
+            
+            frame_id = offset + frame_idx_in_batch
+            keypoints[frame_id] = filtered_keypoints
+            
+        return keypoints

object-detection.onnx

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:05112479be8cb59494e9ae23a57af43becd5aa1f448b0e5ed33fcb6b4c2bbbc3
+size 273322667

osnet_model.pth.tar-100

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:64873ef0e8abf28df31facd113f27634e2d085a2dcf8d19123409b1d0e2566c8
+size 36189526

pitch.py

@@ -0,0 +1,687 @@
+from __future__ import absolute_import
+from __future__ import division
+from __future__ import print_function
+
+import os
+import sys
+import time
+from typing import List, Optional, Tuple
+
+import cv2
+import numpy as np
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+import torchvision.transforms as T
+import torchvision.transforms.functional as f
+from pydantic import BaseModel
+
+import logging
+logger = logging.getLogger(__name__)
+
+
+class BoundingBox(BaseModel):
+    x1: int
+    y1: int
+    x2: int
+    y2: int
+    cls_id: int
+    conf: float
+
+
+class TVFrameResult(BaseModel):
+    frame_id: int
+    boxes: list[BoundingBox]
+    keypoints: list[tuple[int, int]]
+
+BatchNorm2d = nn.BatchNorm2d
+BN_MOMENTUM = 0.1
+
+def conv3x3(in_planes, out_planes, stride=1):
+    """3x3 convolution with padding"""
+    return nn.Conv2d(in_planes, out_planes, kernel_size=3,
+                     stride=stride, padding=1, bias=False)
+
+
+class BasicBlock(nn.Module):
+    expansion = 1
+
+    def __init__(self, inplanes, planes, stride=1, downsample=None):
+        super(BasicBlock, self).__init__()
+        self.conv1 = conv3x3(inplanes, planes, stride)
+        self.bn1 = BatchNorm2d(planes, momentum=BN_MOMENTUM)
+        self.relu = nn.ReLU(inplace=True)
+        self.conv2 = conv3x3(planes, planes)
+        self.bn2 = BatchNorm2d(planes, momentum=BN_MOMENTUM)
+        self.downsample = downsample
+        self.stride = stride
+
+    def forward(self, x):
+        residual = x
+
+        out = self.conv1(x)
+        out = self.bn1(out)
+        out = self.relu(out)
+
+        out = self.conv2(out)
+        out = self.bn2(out)
+
+        if self.downsample is not None:
+            residual = self.downsample(x)
+
+        out += residual
+        out = self.relu(out)
+
+        return out
+
+
+class Bottleneck(nn.Module):
+    expansion = 4
+
+    def __init__(self, inplanes, planes, stride=1, downsample=None):
+        super(Bottleneck, self).__init__()
+        self.conv1 = nn.Conv2d(inplanes, planes, kernel_size=1, bias=False)
+        self.bn1 = BatchNorm2d(planes, momentum=BN_MOMENTUM)
+        self.conv2 = nn.Conv2d(planes, planes, kernel_size=3, stride=stride,
+                               padding=1, bias=False)
+        self.bn2 = BatchNorm2d(planes, momentum=BN_MOMENTUM)
+        self.conv3 = nn.Conv2d(planes, planes * self.expansion, kernel_size=1,
+                               bias=False)
+        self.bn3 = BatchNorm2d(planes * self.expansion,
+                               momentum=BN_MOMENTUM)
+        self.relu = nn.ReLU(inplace=True)
+        self.downsample = downsample
+        self.stride = stride
+
+    def forward(self, x):
+        residual = x
+
+        out = self.conv1(x)
+        out = self.bn1(out)
+        out = self.relu(out)
+
+        out = self.conv2(out)
+        out = self.bn2(out)
+        out = self.relu(out)
+
+        out = self.conv3(out)
+        out = self.bn3(out)
+
+        if self.downsample is not None:
+            residual = self.downsample(x)
+
+        out += residual
+        out = self.relu(out)
+
+        return out
+
+
+class HighResolutionModule(nn.Module):
+    def __init__(self, num_branches, blocks, num_blocks, num_inchannels,
+                 num_channels, fuse_method, multi_scale_output=True):
+        super(HighResolutionModule, self).__init__()
+        self._check_branches(
+            num_branches, blocks, num_blocks, num_inchannels, num_channels)
+
+        self.num_inchannels = num_inchannels
+        self.fuse_method = fuse_method
+        self.num_branches = num_branches
+
+        self.multi_scale_output = multi_scale_output
+
+        self.branches = self._make_branches(
+            num_branches, blocks, num_blocks, num_channels)
+        self.fuse_layers = self._make_fuse_layers()
+        self.relu = nn.ReLU(inplace=True)
+
+    def _check_branches(self, num_branches, blocks, num_blocks,
+                        num_inchannels, num_channels):
+        if num_branches != len(num_blocks):
+            error_msg = 'NUM_BRANCHES({}) <> NUM_BLOCKS({})'.format(
+                num_branches, len(num_blocks))
+            logger.error(error_msg)
+            raise ValueError(error_msg)
+
+        if num_branches != len(num_channels):
+            error_msg = 'NUM_BRANCHES({}) <> NUM_CHANNELS({})'.format(
+                num_branches, len(num_channels))
+            logger.error(error_msg)
+            raise ValueError(error_msg)
+
+        if num_branches != len(num_inchannels):
+            error_msg = 'NUM_BRANCHES({}) <> NUM_INCHANNELS({})'.format(
+                num_branches, len(num_inchannels))
+            logger.error(error_msg)
+            raise ValueError(error_msg)
+
+    def _make_one_branch(self, branch_index, block, num_blocks, num_channels,
+                         stride=1):
+        downsample = None
+        if stride != 1 or \
+                self.num_inchannels[branch_index] != num_channels[branch_index] * block.expansion:
+            downsample = nn.Sequential(
+                nn.Conv2d(self.num_inchannels[branch_index],
+                          num_channels[branch_index] * block.expansion,
+                          kernel_size=1, stride=stride, bias=False),
+                BatchNorm2d(num_channels[branch_index] * block.expansion,
+                            momentum=BN_MOMENTUM),
+            )
+
+        layers = []
+        layers.append(block(self.num_inchannels[branch_index],
+                            num_channels[branch_index], stride, downsample))
+        self.num_inchannels[branch_index] = \
+            num_channels[branch_index] * block.expansion
+        for i in range(1, num_blocks[branch_index]):
+            layers.append(block(self.num_inchannels[branch_index],
+                                num_channels[branch_index]))
+
+        return nn.Sequential(*layers)
+
+    def _make_branches(self, num_branches, block, num_blocks, num_channels):
+        branches = []
+
+        for i in range(num_branches):
+            branches.append(
+                self._make_one_branch(i, block, num_blocks, num_channels))
+
+        return nn.ModuleList(branches)
+
+    def _make_fuse_layers(self):
+        if self.num_branches == 1:
+            return None
+
+        num_branches = self.num_branches
+        num_inchannels = self.num_inchannels
+        fuse_layers = []
+        for i in range(num_branches if self.multi_scale_output else 1):
+            fuse_layer = []
+            for j in range(num_branches):
+                if j > i:
+                    fuse_layer.append(nn.Sequential(
+                        nn.Conv2d(num_inchannels[j],
+                                  num_inchannels[i],
+                                  1,
+                                  1,
+                                  0,
+                                  bias=False),
+                        BatchNorm2d(num_inchannels[i], momentum=BN_MOMENTUM)))
+                    # nn.Upsample(scale_factor=2**(j-i), mode='nearest')))
+                elif j == i:
+                    fuse_layer.append(None)
+                else:
+                    conv3x3s = []
+                    for k in range(i - j):
+                        if k == i - j - 1:
+                            num_outchannels_conv3x3 = num_inchannels[i]
+                            conv3x3s.append(nn.Sequential(
+                                nn.Conv2d(num_inchannels[j],
+                                          num_outchannels_conv3x3,
+                                          3, 2, 1, bias=False),
+                                BatchNorm2d(num_outchannels_conv3x3, momentum=BN_MOMENTUM)))
+                        else:
+                            num_outchannels_conv3x3 = num_inchannels[j]
+                            conv3x3s.append(nn.Sequential(
+                                nn.Conv2d(num_inchannels[j],
+                                          num_outchannels_conv3x3,
+                                          3, 2, 1, bias=False),
+                                BatchNorm2d(num_outchannels_conv3x3,
+                                            momentum=BN_MOMENTUM),
+                                nn.ReLU(inplace=True)))
+                    fuse_layer.append(nn.Sequential(*conv3x3s))
+            fuse_layers.append(nn.ModuleList(fuse_layer))
+
+        return nn.ModuleList(fuse_layers)
+
+    def get_num_inchannels(self):
+        return self.num_inchannels
+
+    def forward(self, x):
+        if self.num_branches == 1:
+            return [self.branches[0](x[0])]
+
+        for i in range(self.num_branches):
+            x[i] = self.branches[i](x[i])
+
+        x_fuse = []
+        for i in range(len(self.fuse_layers)):
+            y = x[0] if i == 0 else self.fuse_layers[i][0](x[0])
+            for j in range(1, self.num_branches):
+                if i == j:
+                    y = y + x[j]
+                elif j > i:
+                    y = y + F.interpolate(
+                        self.fuse_layers[i][j](x[j]),
+                        size=[x[i].shape[2], x[i].shape[3]],
+                        mode='bilinear')
+                else:
+                    y = y + self.fuse_layers[i][j](x[j])
+            x_fuse.append(self.relu(y))
+
+        return x_fuse
+
+
+blocks_dict = {
+    'BASIC': BasicBlock,
+    'BOTTLENECK': Bottleneck
+}
+
+
+class HighResolutionNet(nn.Module):
+
+    def __init__(self, config, **kwargs):
+        self.inplanes = 64
+        extra = config['MODEL']['EXTRA']
+        super(HighResolutionNet, self).__init__()
+
+        # stem net
+        self.conv1 = nn.Conv2d(3, self.inplanes, kernel_size=3, stride=2, padding=1,
+                               bias=False)
+        self.bn1 = BatchNorm2d(self.inplanes, momentum=BN_MOMENTUM)
+        self.conv2 = nn.Conv2d(self.inplanes, self.inplanes, kernel_size=3, stride=2, padding=1,
+                               bias=False)
+        self.bn2 = BatchNorm2d(self.inplanes, momentum=BN_MOMENTUM)
+        self.relu = nn.ReLU(inplace=True)
+        self.sf = nn.Softmax(dim=1)
+        self.layer1 = self._make_layer(Bottleneck, 64, 64, 4)
+
+        self.stage2_cfg = extra['STAGE2']
+        num_channels = self.stage2_cfg['NUM_CHANNELS']
+        block = blocks_dict[self.stage2_cfg['BLOCK']]
+        num_channels = [
+            num_channels[i] * block.expansion for i in range(len(num_channels))]
+        self.transition1 = self._make_transition_layer(
+            [256], num_channels)
+        self.stage2, pre_stage_channels = self._make_stage(
+            self.stage2_cfg, num_channels)
+
+        self.stage3_cfg = extra['STAGE3']
+        num_channels = self.stage3_cfg['NUM_CHANNELS']
+        block = blocks_dict[self.stage3_cfg['BLOCK']]
+        num_channels = [
+            num_channels[i] * block.expansion for i in range(len(num_channels))]
+        self.transition2 = self._make_transition_layer(
+            pre_stage_channels, num_channels)
+        self.stage3, pre_stage_channels = self._make_stage(
+            self.stage3_cfg, num_channels)
+
+        self.stage4_cfg = extra['STAGE4']
+        num_channels = self.stage4_cfg['NUM_CHANNELS']
+        block = blocks_dict[self.stage4_cfg['BLOCK']]
+        num_channels = [
+            num_channels[i] * block.expansion for i in range(len(num_channels))]
+        self.transition3 = self._make_transition_layer(
+            pre_stage_channels, num_channels)
+        self.stage4, pre_stage_channels = self._make_stage(
+            self.stage4_cfg, num_channels, multi_scale_output=True)
+
+        self.upsample = nn.Upsample(scale_factor=2, mode='nearest')
+        final_inp_channels = sum(pre_stage_channels) + self.inplanes
+
+        self.head = nn.Sequential(nn.Sequential(
+            nn.Conv2d(
+                in_channels=final_inp_channels,
+                out_channels=final_inp_channels,
+                kernel_size=1),
+            BatchNorm2d(final_inp_channels, momentum=BN_MOMENTUM),
+            nn.ReLU(inplace=True),
+            nn.Conv2d(
+                in_channels=final_inp_channels,
+                out_channels=config['MODEL']['NUM_JOINTS'],
+                kernel_size=extra['FINAL_CONV_KERNEL']),
+            nn.Softmax(dim=1)))
+
+
+
+    def _make_head(self, x, x_skip):
+        x = self.upsample(x)
+        x = torch.cat([x, x_skip], dim=1)
+        x = self.head(x)
+
+        return x
+
+    def _make_transition_layer(
+            self, num_channels_pre_layer, num_channels_cur_layer):
+        num_branches_cur = len(num_channels_cur_layer)
+        num_branches_pre = len(num_channels_pre_layer)
+
+        transition_layers = []
+        for i in range(num_branches_cur):
+            if i < num_branches_pre:
+                if num_channels_cur_layer[i] != num_channels_pre_layer[i]:
+                    transition_layers.append(nn.Sequential(
+                        nn.Conv2d(num_channels_pre_layer[i],
+                                  num_channels_cur_layer[i],
+                                  3,
+                                  1,
+                                  1,
+                                  bias=False),
+                        BatchNorm2d(
+                            num_channels_cur_layer[i], momentum=BN_MOMENTUM),
+                        nn.ReLU(inplace=True)))
+                else:
+                    transition_layers.append(None)
+            else:
+                conv3x3s = []
+                for j in range(i + 1 - num_branches_pre):
+                    inchannels = num_channels_pre_layer[-1]
+                    outchannels = num_channels_cur_layer[i] \
+                        if j == i - num_branches_pre else inchannels
+                    conv3x3s.append(nn.Sequential(
+                        nn.Conv2d(
+                            inchannels, outchannels, 3, 2, 1, bias=False),
+                        BatchNorm2d(outchannels, momentum=BN_MOMENTUM),
+                        nn.ReLU(inplace=True)))
+                transition_layers.append(nn.Sequential(*conv3x3s))
+
+        return nn.ModuleList(transition_layers)
+
+    def _make_layer(self, block, inplanes, planes, blocks, stride=1):
+        downsample = None
+        if stride != 1 or inplanes != planes * block.expansion:
+            downsample = nn.Sequential(
+                nn.Conv2d(inplanes, planes * block.expansion,
+                          kernel_size=1, stride=stride, bias=False),
+                BatchNorm2d(planes * block.expansion, momentum=BN_MOMENTUM),
+            )
+
+        layers = []
+        layers.append(block(inplanes, planes, stride, downsample))
+        inplanes = planes * block.expansion
+        for i in range(1, blocks):
+            layers.append(block(inplanes, planes))
+
+        return nn.Sequential(*layers)
+
+    def _make_stage(self, layer_config, num_inchannels,
+                    multi_scale_output=True):
+        num_modules = layer_config['NUM_MODULES']
+        num_branches = layer_config['NUM_BRANCHES']
+        num_blocks = layer_config['NUM_BLOCKS']
+        num_channels = layer_config['NUM_CHANNELS']
+        block = blocks_dict[layer_config['BLOCK']]
+        fuse_method = layer_config['FUSE_METHOD']
+
+        modules = []
+        for i in range(num_modules):
+            # multi_scale_output is only used last module
+            if not multi_scale_output and i == num_modules - 1:
+                reset_multi_scale_output = False
+            else:
+                reset_multi_scale_output = True
+            modules.append(
+                HighResolutionModule(num_branches,
+                                     block,
+                                     num_blocks,
+                                     num_inchannels,
+                                     num_channels,
+                                     fuse_method,
+                                     reset_multi_scale_output)
+            )
+            num_inchannels = modules[-1].get_num_inchannels()
+
+        return nn.Sequential(*modules), num_inchannels
+
+    def forward(self, x):
+        # h, w = x.size(2), x.size(3)
+        x = self.conv1(x)
+        x_skip = x.clone()
+        x = self.bn1(x)
+        x = self.relu(x)
+        x = self.conv2(x)
+        x = self.bn2(x)
+        x = self.relu(x)
+        x = self.layer1(x)
+
+        x_list = []
+        for i in range(self.stage2_cfg['NUM_BRANCHES']):
+            if self.transition1[i] is not None:
+                x_list.append(self.transition1[i](x))
+            else:
+                x_list.append(x)
+        y_list = self.stage2(x_list)
+
+        x_list = []
+        for i in range(self.stage3_cfg['NUM_BRANCHES']):
+            if self.transition2[i] is not None:
+                x_list.append(self.transition2[i](y_list[-1]))
+            else:
+                x_list.append(y_list[i])
+        y_list = self.stage3(x_list)
+
+        x_list = []
+        for i in range(self.stage4_cfg['NUM_BRANCHES']):
+            if self.transition3[i] is not None:
+                x_list.append(self.transition3[i](y_list[-1]))
+            else:
+                x_list.append(y_list[i])
+        x = self.stage4(x_list)
+
+        # Head Part
+        height, width = x[0].size(2), x[0].size(3)
+        x1 = F.interpolate(x[1], size=(height, width), mode='bilinear', align_corners=False)
+        x2 = F.interpolate(x[2], size=(height, width), mode='bilinear', align_corners=False)
+        x3 = F.interpolate(x[3], size=(height, width), mode='bilinear', align_corners=False)
+        x = torch.cat([x[0], x1, x2, x3], 1)
+        x = self._make_head(x, x_skip)
+
+        return x
+
+    def init_weights(self, pretrained=''):
+        for m in self.modules():
+            if isinstance(m, nn.Conv2d):
+                nn.init.kaiming_normal_(m.weight, mode='fan_out', nonlinearity='relu')
+                #nn.init.normal_(m.weight, std=0.001)
+                #nn.init.constant_(m.bias, 0)
+            elif isinstance(m, nn.BatchNorm2d):
+                nn.init.constant_(m.weight, 1)
+                nn.init.constant_(m.bias, 0)
+        if pretrained != '':
+            if os.path.isfile(pretrained):
+                pretrained_dict = torch.load(pretrained)
+                model_dict = self.state_dict()
+                pretrained_dict = {k: v for k, v in pretrained_dict.items()
+                                   if k in model_dict.keys()}
+                model_dict.update(pretrained_dict)
+                self.load_state_dict(model_dict)
+            else:
+                sys.exit(f'Weights {pretrained} not found.')
+
+
+def get_cls_net(config, pretrained='', **kwargs):
+    """Create keypoint detection model with softmax activation"""
+    model = HighResolutionNet(config, **kwargs)
+    model.init_weights(pretrained)
+    return model
+
+
+def get_cls_net_l(config, pretrained='', **kwargs):
+    """Create line detection model with sigmoid activation"""
+    model = HighResolutionNet(config, **kwargs)
+    model.init_weights(pretrained)
+    
+    # After loading weights, replace just the activation function
+    # The saved model expects the nested Sequential structure
+    inner_seq = model.head[0]
+    # Replace softmax (index 4) with sigmoid
+    model.head[0][4] = nn.Sigmoid()
+    
+    return model
+
+# Simplified utility functions - removed complex Gaussian generation functions
+# These were mainly used for training data generation, not inference
+
+
+
+# generate_gaussian_array_vectorized_dist_l function removed - not used in current implementation
+@torch.inference_mode()
+def run_inference(model, input_tensor: torch.Tensor, device):
+    input_tensor = input_tensor.to(device).to(memory_format=torch.channels_last)
+    output = model.module().forward(input_tensor)
+    return output
+
+def preprocess_batch_fast(frames):
+    """Ultra-fast batch preprocessing using optimized tensor operations"""
+    target_size = (540, 960)  # H, W format for model input
+    batch = []
+    for i, frame in enumerate(frames):
+        frame_rgb = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
+        img = cv2.resize(frame_rgb, (target_size[1], target_size[0]))
+        img = img.astype(np.float32) / 255.0
+        img = np.transpose(img, (2, 0, 1))  # HWC -> CHW
+        batch.append(img)
+    batch = torch.from_numpy(np.stack(batch)).float()
+
+    return batch
+
+def extract_keypoints_from_heatmap(heatmap: torch.Tensor, scale: int = 2, max_keypoints: int = 1):
+    """Optimized keypoint extraction from heatmaps"""
+    batch_size, n_channels, height, width = heatmap.shape
+    
+    # Find local maxima using max pooling (keep on GPU)
+    kernel = 3
+    pad = 1
+    max_pooled = F.max_pool2d(heatmap, kernel, stride=1, padding=pad)
+    local_maxima = (max_pooled == heatmap)
+    heatmap = heatmap * local_maxima
+    
+    # Get top keypoints (keep on GPU longer)
+    scores, indices = torch.topk(heatmap.view(batch_size, n_channels, -1), max_keypoints, sorted=False)
+    y_coords = torch.div(indices, width, rounding_mode="floor")
+    x_coords = indices % width
+    
+    # Optimized tensor operations
+    x_coords = x_coords * scale
+    y_coords = y_coords * scale
+    
+    # Create result tensor directly on GPU
+    results = torch.stack([x_coords.float(), y_coords.float(), scores], dim=-1)
+    
+    return results
+
+
+def extract_keypoints_from_heatmap_fast(heatmap: torch.Tensor, scale: int = 2, max_keypoints: int = 1):
+    """Ultra-fast keypoint extraction optimized for speed"""
+    batch_size, n_channels, height, width = heatmap.shape
+    
+    # Simplified local maxima detection (faster but slightly less accurate)
+    max_pooled = F.max_pool2d(heatmap, 3, stride=1, padding=1)
+    local_maxima = (max_pooled == heatmap)
+    
+    # Apply mask and get top keypoints in one go
+    masked_heatmap = heatmap * local_maxima
+    flat_heatmap = masked_heatmap.view(batch_size, n_channels, -1)
+    scores, indices = torch.topk(flat_heatmap, max_keypoints, dim=-1, sorted=False)
+    
+    # Vectorized coordinate calculation
+    y_coords = torch.div(indices, width, rounding_mode="floor") * scale
+    x_coords = (indices % width) * scale
+    
+    # Stack results efficiently
+    results = torch.stack([x_coords.float(), y_coords.float(), scores], dim=-1)
+    return results
+
+
+def process_keypoints_vectorized(kp_coords, kp_threshold, w, h, batch_size):
+    """Ultra-fast vectorized keypoint processing"""
+    batch_results = []
+    
+    # Convert to numpy once for faster CPU operations
+    kp_np = kp_coords.cpu().numpy()
+    
+    for batch_idx in range(batch_size):
+        kp_dict = {}
+        # Vectorized threshold check
+        valid_kps = kp_np[batch_idx, :, 0, 2] > kp_threshold
+        valid_indices = np.where(valid_kps)[0]
+        
+        for ch_idx in valid_indices:
+            x = float(kp_np[batch_idx, ch_idx, 0, 0]) / w
+            y = float(kp_np[batch_idx, ch_idx, 0, 1]) / h
+            p = float(kp_np[batch_idx, ch_idx, 0, 2])
+            kp_dict[ch_idx + 1] = {'x': x, 'y': y, 'p': p}
+        
+        batch_results.append(kp_dict)
+    
+    return batch_results
+
+def inference_batch(frames, model, kp_threshold, device, batch_size=8):
+    """Optimized batch inference for multiple frames"""
+    results = []
+    num_frames = len(frames)
+    
+    # Get the device from the model itself
+    model_device = next(model.parameters()).device
+    
+    # Process all frames in optimally-sized batches
+    for i in range(0, num_frames, batch_size):
+        current_batch_size = min(batch_size, num_frames - i)
+        batch_frames = frames[i:i + current_batch_size]
+        
+        # Fast preprocessing - create on CPU first
+        batch = preprocess_batch_fast(batch_frames)
+        b, c, h, w = batch.size()
+        
+        # Move batch to model device
+        batch = batch.to(model_device)
+
+        with torch.no_grad():
+            heatmaps = model(batch)
+
+        # Ultra-fast keypoint extraction
+        kp_coords = extract_keypoints_from_heatmap_fast(heatmaps[:,:-1,:,:], scale=2, max_keypoints=1)
+        
+        # Vectorized batch processing - no loops
+        batch_results = process_keypoints_vectorized(kp_coords, kp_threshold, 960, 540, current_batch_size)
+        results.extend(batch_results)
+        
+        # Minimal cleanup
+        del heatmaps, kp_coords, batch
+    
+    return results
+
+# Keypoint mapping from detection indices to standard football pitch keypoint IDs
+map_keypoints = {
+    1: 1, 2: 14, 3: 25, 4: 2, 5: 10, 6: 18, 7: 26, 8: 3, 9: 7, 10: 23, 
+    11: 27, 20: 4, 21: 8, 22: 24, 23: 28, 24: 5, 25: 13, 26: 21, 27: 29, 
+    28: 6, 29: 17, 30: 30, 31: 11, 32: 15, 33: 19, 34: 12, 35: 16, 36: 20, 
+    45: 9, 50: 31, 52: 32, 57: 22
+}
+
+def get_mapped_keypoints(kp_points):
+    """Apply keypoint mapping to detection results"""
+    mapped_points = {}
+    for key, value in kp_points.items():
+        if key in map_keypoints:
+            mapped_key = map_keypoints[key]
+            mapped_points[mapped_key] = value
+        # else:
+            # Keep unmapped keypoints with original key
+            # mapped_points[key] = value
+    return mapped_points
+
+def process_batch_input(frames, model, kp_threshold, device, batch_size=8):
+    """Process multiple input images in batch"""
+    # Batch inference
+    kp_results = inference_batch(frames, model, kp_threshold, device, batch_size)
+    kp_results = [get_mapped_keypoints(kp) for kp in kp_results]
+    # Draw results and save
+    # for i, (frame, kp_points, input_path) in enumerate(zip(frames, kp_results, valid_paths)):
+    #     height, width = frame.shape[:2]
+        
+    #     # Apply mapping to get standard keypoint IDs
+    #     mapped_kp_points = get_mapped_keypoints(kp_points)
+        
+    #     for key, value in mapped_kp_points.items():
+    #         x = int(value['x'] * width)
+    #         y = int(value['y'] * height)
+    #         cv2.circle(frame, (x, y), 5, (0, 255, 0), -1)  # Green circles
+    #         cv2.putText(frame, str(key), (x+10, y), cv2.FONT_HERSHEY_SIMPLEX, 0.5, (255, 255, 255), 2)
+        
+    #     # Save result
+    #     output_path = input_path.replace('.png', '_result.png').replace('.jpg', '_result.jpg')
+    #     cv2.imwrite(output_path, frame)
+        
+    # print(f"Batch processing complete. Processed {len(frames)} images.")
+
+    return kp_results

player.pt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:ce9fc31f61e6f156f786077abb8eef36b0836bda1ef07d1d0ba82d43ae0ecd0b
+size 22540152

player.py

@@ -0,0 +1,389 @@
+import cv2
+import numpy as np
+from sklearn.cluster import KMeans
+import warnings
+import time
+
+import torch
+from torchvision.ops import batched_nms
+from numpy import ndarray
+# Suppress ALL runtime and sklearn warnings
+warnings.filterwarnings('ignore', category=RuntimeWarning)
+warnings.filterwarnings('ignore', category=FutureWarning) 
+warnings.filterwarnings('ignore', category=UserWarning)
+
+# Suppress sklearn warnings specifically
+import logging
+logging.getLogger('sklearn').setLevel(logging.ERROR)
+
+def get_grass_color(img):
+    # Convert image to HSV color space
+    hsv = cv2.cvtColor(img, cv2.COLOR_BGR2HSV)
+
+    # Define range of green color in HSV
+    lower_green = np.array([30, 40, 40])
+    upper_green = np.array([80, 255, 255])
+
+    # Threshold the HSV image to get only green colors
+    mask = cv2.inRange(hsv, lower_green, upper_green)
+
+    # Calculate the mean value of the pixels that are not masked
+    masked_img = cv2.bitwise_and(img, img, mask=mask)
+    grass_color = cv2.mean(img, mask=mask)
+    return grass_color[:3]
+
+def get_players_boxes(frame, result):
+    players_imgs = []
+    players_boxes = []
+    for (box, score, cls) in result:
+        label = int(cls)
+        if label == 0:
+            x1, y1, x2, y2 = box.astype(int)
+            player_img = frame[y1: y2, x1: x2]
+            players_imgs.append(player_img)
+            players_boxes.append([box, score, cls])
+    return players_imgs, players_boxes
+
+def get_kits_colors(players, grass_hsv=None, frame=None):
+    kits_colors = []
+    if grass_hsv is None:
+        grass_color = get_grass_color(frame)
+        grass_hsv = cv2.cvtColor(np.uint8([[list(grass_color)]]), cv2.COLOR_BGR2HSV)
+
+    for player_img in players:
+        # Skip empty or invalid images
+        if player_img is None or player_img.size == 0 or len(player_img.shape) != 3:
+            continue
+            
+        # Convert image to HSV color space
+        hsv = cv2.cvtColor(player_img, cv2.COLOR_BGR2HSV)
+
+        # Define range of green color in HSV
+        lower_green = np.array([grass_hsv[0, 0, 0] - 10, 40, 40])
+        upper_green = np.array([grass_hsv[0, 0, 0] + 10, 255, 255])
+
+        # Threshold the HSV image to get only green colors
+        mask = cv2.inRange(hsv, lower_green, upper_green)
+
+        # Bitwise-AND mask and original image
+        mask = cv2.bitwise_not(mask)
+        upper_mask = np.zeros(player_img.shape[:2], np.uint8)
+        upper_mask[0:player_img.shape[0]//2, 0:player_img.shape[1]] = 255
+        mask = cv2.bitwise_and(mask, upper_mask)
+
+        kit_color = np.array(cv2.mean(player_img, mask=mask)[:3])
+
+        kits_colors.append(kit_color)
+    return kits_colors
+
+def get_kits_classifier(kits_colors):
+    if len(kits_colors) == 0:
+        return None
+    if len(kits_colors) == 1:
+        # Only one kit color, create a dummy classifier
+        return None
+    kits_kmeans = KMeans(n_clusters=2)
+    kits_kmeans.fit(kits_colors)
+    return kits_kmeans
+
+def classify_kits(kits_classifer, kits_colors):
+    if kits_classifer is None or len(kits_colors) == 0:
+        return np.array([0])  # Default to team 0
+    team = kits_classifer.predict(kits_colors)
+    return team
+
+def get_left_team_label(players_boxes, kits_colors, kits_clf):
+    left_team_label = 0
+    team_0 = []
+    team_1 = []
+
+    for i in range(len(players_boxes)):
+        x1, y1, x2, y2 = players_boxes[i][0].astype(int)
+        team = classify_kits(kits_clf, [kits_colors[i]]).item()
+        if team == 0:
+            team_0.append(np.array([x1]))
+        else:
+            team_1.append(np.array([x1]))
+
+    team_0 = np.array(team_0)
+    team_1 = np.array(team_1)
+
+    # Safely calculate averages with fallback for empty arrays
+    avg_team_0 = np.average(team_0) if len(team_0) > 0 else 0
+    avg_team_1 = np.average(team_1) if len(team_1) > 0 else 0
+    
+    if avg_team_0 - avg_team_1 > 0:
+        left_team_label = 1
+
+    return left_team_label
+
+def check_box_boundaries(boxes, img_height, img_width):
+    """
+    Check if bounding boxes are within image boundaries and clip them if necessary.
+    
+    Args:
+        boxes: numpy array of shape (N, 4) with [x1, y1, x2, y2] format
+        img_height: height of the image
+        img_width: width of the image
+    
+    Returns:
+        valid_boxes: numpy array of valid boxes within boundaries
+        valid_indices: indices of valid boxes
+    """
+    x1, y1, x2, y2 = boxes[:, 0], boxes[:, 1], boxes[:, 2], boxes[:, 3]
+    
+    # Check if boxes are within boundaries
+    valid_mask = (x1 >= 0) & (y1 >= 0) & (x2 < img_width) & (y2 < img_height) & (x1 < x2) & (y1 < y2)
+    
+    if not np.any(valid_mask):
+        return np.array([]), np.array([])
+    
+    valid_boxes = boxes[valid_mask]
+    valid_indices = np.where(valid_mask)[0]
+    
+    # Clip boxes to image boundaries
+    valid_boxes[:, 0] = np.clip(valid_boxes[:, 0], 0, img_width - 1)   # x1
+    valid_boxes[:, 1] = np.clip(valid_boxes[:, 1], 0, img_height - 1)  # y1
+    valid_boxes[:, 2] = np.clip(valid_boxes[:, 2], 0, img_width - 1)   # x2
+    valid_boxes[:, 3] = np.clip(valid_boxes[:, 3], 0, img_height - 1)  # y2
+    
+    return valid_boxes, valid_indices
+
+def process_team_identification_batch(frames, results, kits_clf, left_team_label, grass_hsv):
+    """
+    Process team identification and label formatting for batch results.
+    
+    Args:
+        frames: list of frames
+        results: list of detection results for each frame
+        kits_clf: trained kit classifier
+        left_team_label: label for left team
+        grass_hsv: grass color in HSV format
+    
+    Returns:
+        processed_results: list of processed results with team identification
+    """
+    processed_results = []
+    
+    for frame_idx, frame in enumerate(frames):
+        frame_results = []
+        frame_detections = results[frame_idx]
+        
+        if not frame_detections:
+            processed_results.append([])
+            continue
+            
+        # Extract player boxes and images
+        players_imgs = []
+        players_boxes = []
+        player_indices = []
+        
+        for idx, (box, score, cls) in enumerate(frame_detections):
+            label = int(cls)
+            if label == 0:  # Player detection
+                x1, y1, x2, y2 = box.astype(int)
+                
+                # Check boundaries
+                if (x1 >= 0 and y1 >= 0 and x2 < frame.shape[1] and y2 < frame.shape[0] and x1 < x2 and y1 < y2):
+                    player_img = frame[y1:y2, x1:x2]
+                    if player_img.size > 0:  # Ensure valid image
+                        players_imgs.append(player_img)
+                        players_boxes.append([box, score, cls])
+                        player_indices.append(idx)
+        
+        # Initialize player team mapping
+        player_team_map = {}
+        
+        # Process team identification if we have players
+        if players_imgs and kits_clf is not None:
+            kits_colors = get_kits_colors(players_imgs, grass_hsv)
+            teams = classify_kits(kits_clf, kits_colors)
+            
+            # Create mapping from player index to team
+            for i, team in enumerate(teams):
+                player_team_map[player_indices[i]] = team.item()
+        
+        id = 0
+        # Process all detections with team identification
+        for idx, (box, score, cls) in enumerate(frame_detections):
+            label = int(cls)
+            x1, y1, x2, y2 = box.astype(int)
+            
+            # Check boundaries
+            valid_boxes, valid_indices = check_box_boundaries(
+                np.array([[x1, y1, x2, y2]]), frame.shape[0], frame.shape[1]
+            )
+            
+            if len(valid_boxes) == 0:
+                continue
+                
+            x1, y1, x2, y2 = valid_boxes[0].astype(int)
+            
+            # Apply team identification logic
+            if label == 0:  # Player
+                if players_imgs and kits_clf is not None and idx in player_team_map:
+                    team = player_team_map[idx]
+                    if team == left_team_label:
+                        final_label = 6  # Player-L (Left team)
+                    else:
+                        final_label = 7  # Player-R (Right team)
+                else:
+                    final_label = 6  # Default player label
+                    
+            elif label == 1:  # Goalkeeper
+                final_label = 1  # GK
+                
+            elif label == 2:  # Ball
+                final_label = 0  # Ball
+                
+            elif label == 3 or label == 4:  # Referee or other
+                final_label = 3  # Referee
+                
+            else:
+                continue
+                # final_label = int(label)  # Keep original label, ensure it's int
+            
+            frame_results.append({
+                "id": int(id),
+                "bbox": [int(x1), int(y1), int(x2), int(y2)],
+                "class_id": int(final_label),
+                "conf": float(score)
+            })
+            id = id + 1
+        
+        processed_results.append(frame_results)
+    
+    return processed_results
+
+def convert_numpy_types(obj):
+    """Convert numpy types to native Python types for JSON serialization."""
+    if isinstance(obj, np.integer):
+        return int(obj)
+    elif isinstance(obj, np.floating):
+        return float(obj)
+    elif isinstance(obj, np.ndarray):
+        return obj.tolist()
+    elif isinstance(obj, dict):
+        return {key: convert_numpy_types(value) for key, value in obj.items()}
+    elif isinstance(obj, list):
+        return [convert_numpy_types(item) for item in obj]
+    else:
+        return obj
+
+def pre_process_img(frames, scale):
+    imgs = np.stack([cv2.resize(frame, (int(scale), int(scale))) for frame in frames])
+    imgs = imgs.transpose(0, 3, 1, 2)
+    imgs = imgs.astype(np.float32) / 255.0  # Normalize
+    return imgs
+
+def post_process_output(outputs, x_scale, y_scale, conf_thresh=0.6, nms_thresh=0.75):
+    B, C, N = outputs.shape
+    outputs = torch.from_numpy(outputs)
+    outputs = outputs.permute(0, 2, 1)
+    boxes = outputs[..., :4]
+    class_scores = 1 / (1 + torch.exp(-outputs[..., 4:]))
+    conf, class_id = class_scores.max(dim=2)
+
+    mask = conf > conf_thresh
+    
+    for i in range(class_id.shape[0]):  # loop over batch
+    # Find detections that are balls
+        ball_idx = np.where(class_id[i] == 2)[0]
+        if ball_idx.size > 0:
+            # Pick the one with the highest confidence
+            top = ball_idx[np.argmax(conf[i, ball_idx])]
+            if conf[i, top] > 0.55:  # apply confidence threshold
+                mask[i, top] = True
+                
+    # ball_mask = (class_id == 2) & (conf > 0.51)
+    # mask = mask | ball_mask
+    
+    batch_idx, pred_idx = mask.nonzero(as_tuple=True)
+
+    if len(batch_idx) == 0:
+        return [[] for _ in range(B)]
+    
+    boxes = boxes[batch_idx, pred_idx]
+    conf = conf[batch_idx, pred_idx]
+    class_id = class_id[batch_idx, pred_idx]
+
+    x, y, w, h = boxes[:, 0], boxes[:, 1], boxes[:, 2], boxes[:, 3]
+    x1 = (x - w / 2) * x_scale
+    y1 = (y - h / 2) * y_scale
+    x2 = (x + w / 2) * x_scale
+    y2 = (y + h / 2) * y_scale
+    boxes_xyxy = torch.stack([x1, y1, x2, y2], dim=1)
+
+    max_coord = 1e4
+    offset = batch_idx.to(boxes_xyxy) * max_coord
+    boxes_for_nms = boxes_xyxy + offset[:, None]
+
+    keep = batched_nms(boxes_for_nms, conf, batch_idx, nms_thresh)
+
+    boxes_final = boxes_xyxy[keep]
+    conf_final = conf[keep]
+    class_final = class_id[keep]
+    batch_final = batch_idx[keep]
+
+    results = [[] for _ in range(B)]
+    for b in range(B):
+        mask_b = batch_final == b
+        if mask_b.sum() == 0:
+            continue
+        results[b] = list(zip(boxes_final[mask_b].numpy(),
+                              conf_final[mask_b].numpy(),
+                              class_final[mask_b].numpy()))
+    return results
+
+def player_detection_result(frames: list[ndarray], batch_size, model, kits_clf=None, left_team_label=None, grass_hsv=None):
+    start_time = time.time()
+    # input_layer = model.input(0)
+    # output_layer = model.output(0)
+    height, width = frames[0].shape[:2]
+    scale = 640.0
+    x_scale = width / scale
+    y_scale = height / scale
+
+    # infer_queue = AsyncInferQueue(model, len(frames))
+    
+    infer_time = time.time()
+    kits_clf = kits_clf
+    left_team_label = left_team_label
+    grass_hsv = grass_hsv
+    results = []
+    for i in range(0, len(frames), batch_size):
+        if i + batch_size > len(frames):
+            batch_size = len(frames) - i
+        batch_frames = frames[i:i + batch_size]
+        imgs = pre_process_img(batch_frames, scale)
+
+        input_name = model.get_inputs()[0].name
+        outputs = model.run(None, {input_name: imgs})[0]
+        raw_results = post_process_output(np.array(outputs), x_scale, y_scale)
+
+        if kits_clf is None or left_team_label is None or grass_hsv is None:
+            # Use first frame to initialize team classification
+            first_frame = batch_frames[0]
+            first_frame_results = raw_results[0] if raw_results else []
+            
+            if first_frame_results:
+                players_imgs, players_boxes = get_players_boxes(first_frame, first_frame_results)
+                if players_imgs:
+                    grass_color = get_grass_color(first_frame)
+                    grass_hsv = cv2.cvtColor(np.uint8([[list(grass_color)]]), cv2.COLOR_BGR2HSV)
+                    kits_colors = get_kits_colors(players_imgs, grass_hsv)
+                    if kits_colors:  # Only proceed if we have valid kit colors
+                        kits_clf = get_kits_classifier(kits_colors)
+                        if kits_clf is not None:
+                            left_team_label = int(get_left_team_label(players_boxes, kits_colors, kits_clf))
+
+        # Process team identification and boundary checking
+        processed_results = process_team_identification_batch(
+            batch_frames, raw_results, kits_clf, left_team_label, grass_hsv
+        )
+    
+        processed_results = convert_numpy_types(processed_results)
+        results.extend(processed_results)
+
+    # Return the same format as before for compatibility
+    return results, kits_clf, left_team_label, grass_hsv