Upload folder using huggingface_hub

.gitattributes

@@ -1,35 +1,44 @@
-*.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
+__pycache__/keypoint_helper_v2.cpython-312.pyc filter=lfs diff=lfs merge=lfs -text
+__pycache__/keypoint_helper_v2_optimized.cpython-312.pyc filter=lfs diff=lfs merge=lfs -text
+__pycache__/keypoint_helper_v2_optimized.cpython-312.pyc.1837368399824 filter=lfs diff=lfs merge=lfs -text
+__pycache__/keypoint_helper_v2_optimized.cpython-312.pyc.2364780042192 filter=lfs diff=lfs merge=lfs -text
+__pycache__/keypoint_helper_v2_optimized.cpython-312.pyc.2618992613328 filter=lfs diff=lfs merge=lfs -text
+best.engine filter=lfs diff=lfs merge=lfs -text
+keypoint filter=lfs diff=lfs merge=lfs -text

.gitignore

@@ -0,0 +1,5 @@
+venv
+outputs
+outputs-keypoints
+outputs-detections
+*.mp4

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

__pycache__/keypoint_helper_v2.cpython-312.pyc

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

__pycache__/keypoint_helper_v2_optimized.cpython-312.pyc

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

__pycache__/keypoint_helper_v2_optimized.cpython-312.pyc.1837368399824

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

__pycache__/keypoint_helper_v2_optimized.cpython-312.pyc.2364780042192

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

__pycache__/keypoint_helper_v2_optimized.cpython-312.pyc.2618992613328

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

best.engine

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

best.onnx

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

best.pt

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

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

evaluate_from_url.py

@@ -0,0 +1,286 @@
+import argparse
+import json
+import tempfile
+from pathlib import Path
+from typing import List, Tuple, Dict
+import urllib.request
+import urllib.parse
+import urllib.error
+
+import cv2
+import numpy as np
+
+from miner1 import TVFrameResult, BoundingBox
+from keypoint_evaluation import (
+    load_template_from_file,
+)
+from test_predict_batch import (
+    evaluate_keypoints_batch,
+    visualize_keypoint_evaluation,
+)
+
+
+def fetch_json_data(url: str) -> dict:
+    """Fetch JSON data from URL."""
+    print(f"Fetching data from {url}...")
+    
+    # Create a request with headers to avoid 403 errors
+    req = urllib.request.Request(url)
+    req.add_header('User-Agent', 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/91.0.4472.124 Safari/537.36')
+    req.add_header('Accept', 'application/json, text/plain, */*')
+    req.add_header('Accept-Language', 'en-US,en;q=0.9')
+    
+    try:
+        with urllib.request.urlopen(req) as response:
+            data = json.loads(response.read().decode('utf-8'))
+        predictions = data.get('predictions', {})
+        frames_list = predictions.get('frames', [])
+        print(f"Successfully fetched data with {len(frames_list)} frames")
+        return data
+    except urllib.error.HTTPError as e:
+        print(f"HTTP Error {e.code}: {e.reason}")
+        if e.code == 403:
+            print("403 Forbidden: The server is blocking the request. This might require authentication or different headers.")
+        raise
+    except urllib.error.URLError as e:
+        print(f"URL Error: {e.reason}")
+        raise
+
+
+def download_video(video_url: str, output_path: Path) -> Path:
+    """Download video from URL to local file."""
+    print(f"Downloading video from {video_url}...")
+    output_path.parent.mkdir(parents=True, exist_ok=True)
+    urllib.request.urlretrieve(video_url, str(output_path))
+    print(f"Video downloaded to {output_path}")
+    return output_path
+
+
+def extract_frames_from_video(video_path: Path, frame_ids: List[int] = None) -> Dict[int, np.ndarray]:
+    """Extract frames from video, optionally only specific frame IDs."""
+    print(f"Extracting frames from {video_path}...")
+    cap = cv2.VideoCapture(str(video_path))
+    if not cap.isOpened():
+        raise RuntimeError(f"Unable to open video: {video_path}")
+    
+    frames = {}
+    frame_count = 0
+    
+    while True:
+        ret, frame = cap.read()
+        if not ret:
+            break
+        
+        if frame_ids is None or frame_count in frame_ids:
+            frames[frame_count] = frame
+        
+        frame_count += 1
+    
+    cap.release()
+    print(f"Extracted {len(frames)} frames from video")
+    return frames
+
+
+def convert_keypoints_format(json_keypoints: List[List[int]]) -> List[Tuple[int, int]]:
+    """Convert keypoints from JSON format [[x,y], [x,y], ...] to List[Tuple[int, int]]."""
+    return [(int(kp[0]), int(kp[1])) for kp in json_keypoints]
+
+
+def convert_json_to_tvframe_results(
+    json_data: dict,
+    frames: Dict[int, np.ndarray],
+) -> List[TVFrameResult]:
+    """
+    Convert JSON data to TVFrameResult objects.
+    
+    Args:
+        json_data: JSON data containing predictions with frames, boxes, and keypoints
+        frames: Dictionary mapping frame_id to frame image
+    
+    Returns:
+        List of TVFrameResult objects
+    """
+    predictions = json_data.get('predictions', {})
+    frames_data = predictions.get('frames', [])
+    
+    results = []
+    for frame_data in frames_data:
+        frame_id = frame_data.get('frame_id')
+        if frame_id not in frames:
+            print(f"Warning: Frame {frame_id} not found in extracted frames, skipping")
+            continue
+        
+        # Convert boxes
+        json_boxes = frame_data.get('boxes', [])
+        boxes = []
+        for box_data in json_boxes:
+            box = BoundingBox(
+                x1=int(box_data.get('x1', 0)),
+                y1=int(box_data.get('y1', 0)),
+                x2=int(box_data.get('x2', 0)),
+                y2=int(box_data.get('y2', 0)),
+                cls_id=int(box_data.get('cls_id', 0)),
+                conf=float(box_data.get('conf', 0.0)),
+            )
+            boxes.append(box)
+        
+        # Convert keypoints
+        json_keypoints = frame_data.get('keypoints', [])
+        keypoints = convert_keypoints_format(json_keypoints)
+        
+        result = TVFrameResult(
+            frame_id=frame_id,
+            boxes=boxes,
+            keypoints=keypoints,
+        )
+        results.append(result)
+    
+    return results
+
+
+def evaluate_keypoints_from_json(
+    json_data: dict,
+    frames: Dict[int, np.ndarray],
+    template_image: np.ndarray,
+    template_keypoints: List[Tuple[int, int]],
+    visualization_output_dir: Path = None,
+) -> Dict[str, float]:
+    """
+    Evaluate keypoint accuracy from JSON data using the same function as test_predict_batch.py.
+    
+    Args:
+        json_data: JSON data containing predictions with frames and keypoints
+        frames: Dictionary mapping frame_id to frame image
+        template_image: Template image for evaluation
+        template_keypoints: Template keypoints
+        visualization_output_dir: Optional directory to save visualization images
+    
+    Returns:
+        Dictionary with keypoint evaluation statistics
+    """
+    # Convert JSON data to TVFrameResult objects
+    results = convert_json_to_tvframe_results(json_data, frames)
+    
+    if len(results) == 0:
+        print("No valid frames found in JSON data")
+        return {
+            "keypoint_avg_score": 0.0,
+            "keypoint_valid_frames": 0,
+            "keypoint_total_frames": 0,
+        }
+    
+    print(f"Evaluating {len(results)} frames using evaluate_keypoints_batch...")
+    
+    # Use the same evaluation function as test_predict_batch.py
+    stats = evaluate_keypoints_batch(
+        results=results,
+        original_frames=frames,
+        template_image=template_image,
+        template_keypoints=template_keypoints,
+        visualization_output_dir=visualization_output_dir,
+    )
+    
+    print("\n=== Keypoint Evaluation Results ===")
+    print(f"Total frames: {stats['keypoint_total_frames']}")
+    print(f"Valid frames: {stats['keypoint_valid_frames']}")
+    print(f"Average score: {stats['keypoint_avg_score']:.3f}")
+    print(f"Max score: {stats['keypoint_max_score']:.3f}")
+    print(f"Min score: {stats['keypoint_min_score']:.3f}")
+    print(f"Frames with score > 0.5: {stats['keypoint_frames_above_0.5']}")
+    print(f"Frames with score > 0.7: {stats['keypoint_frames_above_0.7']}")
+    
+    return stats
+
+
+def parse_args() -> argparse.Namespace:
+    parser = argparse.ArgumentParser(
+        description="Fetch video and keypoint data from URL, evaluate keypoints, and visualize results."
+    )
+    parser.add_argument(
+        "--url",
+        type=str,
+        default="https://pub-7b4130b6af75472f800371248bca15b6.r2.dev/scorevision/results_soccer/5Fnhz5fDihvno4DfssfRogL84VFvdDRRsgu19grbqEDPbJGv/responses/007115302-f9bd4226d1f4248c782a3179764e3203ce2fc520642eed4f7b02c40e61db55eb.json",
+        help="URL to fetch JSON data containing video_url and predictions.",
+    )
+    parser.add_argument(
+        "--template-image",
+        type=Path,
+        default='football_pitch_template.png',
+        help="Path to football pitch template image.",
+    )
+    parser.add_argument(
+        "--output-dir",
+        type=Path,
+        default='outputs/url_evaluation',
+        help="Directory to save visualizations and downloaded video.",
+    )
+    parser.add_argument(
+        "--delete-video",
+        action="store_true",
+        help="Delete downloaded video file after processing (default: keep video).",
+    )
+    return parser.parse_args()
+
+
+def main() -> None:
+    args = parse_args()
+    
+    # Create output directory
+    args.output_dir.mkdir(parents=True, exist_ok=True)
+    
+    # Fetch JSON data
+    json_data = fetch_json_data(args.url)
+    
+    # Get video URL
+    video_url = json_data.get('video_url')
+    if not video_url:
+        raise ValueError("No video_url found in JSON data")
+    
+    # Download video
+    video_filename = Path(urllib.parse.urlparse(video_url).path).name
+    if not video_filename:
+        video_filename = "video.mp4"
+    video_path = args.output_dir / video_filename
+    
+    download_video(video_url, video_path)
+    
+    # Get video filename without extension for folder naming
+    video_name_without_ext = Path(video_filename).stem
+    
+    # Get frame IDs from JSON
+    predictions = json_data.get('predictions', {})
+    frames_data = predictions.get('frames', [])
+    frame_ids = [frame_data.get('frame_id') for frame_data in frames_data]
+    
+    # Extract frames from video
+    frames = extract_frames_from_video(video_path, frame_ids=frame_ids if frame_ids else None)
+    
+    # Load template
+    template_image, template_keypoints = load_template_from_file(str(args.template_image))
+    
+    # Create visualization directory with video filename
+    visualization_dir = args.output_dir / f"visualizations_{video_name_without_ext}"
+    
+    # Evaluate keypoints
+    stats = evaluate_keypoints_from_json(
+        json_data=json_data,
+        frames=frames,
+        template_image=template_image,
+        template_keypoints=template_keypoints,
+        visualization_output_dir=visualization_dir,
+    )
+    
+    # Clean up video if requested
+    if args.delete_video:
+        video_path.unlink()
+        print(f"Deleted video file: {video_path}")
+    else:
+        print(f"Video saved at: {video_path}")
+    
+    print(f"\nResults saved to: {args.output_dir}")
+    print(f"Visualizations saved to: {visualization_dir}")
+
+
+if __name__ == "__main__":
+    main()
+

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
+

inspect_yolo_model.py

@@ -0,0 +1,155 @@
+"""
+Script to inspect a YOLO .pt model and determine its variant (nano, small, medium, large, xlarge).
+"""
+import argparse
+from pathlib import Path
+import torch
+from ultralytics import YOLO
+
+
+def inspect_yolo_model(model_path: Path):
+    """Inspect YOLO model to determine variant and architecture details."""
+    print(f"Inspecting model: {model_path}")
+    print("=" * 60)
+    
+    # Method 1: Load with Ultralytics and check metadata
+    try:
+        model = YOLO(str(model_path))
+        
+        # Check model info
+        print("\n--- Model Information ---")
+        print(f"Model type: {type(model.model)}")
+        
+        # Try to get model name from metadata
+        if hasattr(model, 'model') and hasattr(model.model, 'yaml'):
+            yaml_path = model.model.yaml
+            print(f"YAML config: {yaml_path}")
+            if yaml_path:
+                # Extract variant from yaml path
+                yaml_name = Path(yaml_path).stem if isinstance(yaml_path, (str, Path)) else str(yaml_path)
+                print(f"YAML name: {yaml_name}")
+                # Common patterns: yolo11n.yaml, yolo11s.yaml, yolo11m.yaml, yolo11l.yaml, yolo11x.yaml
+                # or yolov8n.yaml, yolov8s.yaml, etc.
+                if 'n' in yaml_name.lower():
+                    variant = "Nano (n)"
+                elif 's' in yaml_name.lower():
+                    variant = "Small (s)"
+                elif 'm' in yaml_name.lower():
+                    variant = "Medium (m)"
+                elif 'l' in yaml_name.lower():
+                    variant = "Large (l)"
+                elif 'x' in yaml_name.lower():
+                    variant = "XLarge (x)"
+                else:
+                    variant = "Unknown"
+                print(f"Detected variant: {variant}")
+        
+        # Check model metadata if available
+        if hasattr(model.model, 'names'):
+            print(f"Number of classes: {len(model.model.names)}")
+            print(f"Class names: {list(model.model.names.values())[:5]}...")  # Show first 5
+        
+        # Get model info summary
+        print("\n--- Model Summary ---")
+        try:
+            info = model.info(verbose=False)
+            print(info)
+        except:
+            pass
+        
+        # Count parameters
+        if hasattr(model.model, 'parameters'):
+            total_params = sum(p.numel() for p in model.model.parameters())
+            trainable_params = sum(p.numel() for p in model.model.parameters() if p.requires_grad)
+            print(f"\n--- Parameter Count ---")
+            print(f"Total parameters: {total_params:,}")
+            print(f"Trainable parameters: {trainable_params:,}")
+            
+            # Rough estimates for YOLO variants (these vary by version but give a ballpark)
+            if total_params < 3_000_000:
+                size_estimate = "Nano (n) - typically < 3M params"
+            elif total_params < 12_000_000:
+                size_estimate = "Small (s) - typically 3-12M params"
+            elif total_params < 26_000_000:
+                size_estimate = "Medium (m) - typically 12-26M params"
+            elif total_params < 44_000_000:
+                size_estimate = "Large (l) - typically 26-44M params"
+            else:
+                size_estimate = "XLarge (x) - typically > 44M params"
+            print(f"Size estimate: {size_estimate}")
+        
+    except Exception as e:
+        print(f"Error loading with Ultralytics: {e}")
+        print("\nTrying alternative method...")
+    
+    # Method 2: Direct PyTorch inspection
+    print("\n" + "=" * 60)
+    print("--- Direct PyTorch Inspection ---")
+    try:
+        checkpoint = torch.load(str(model_path), map_location='cpu')
+        
+        # Check for metadata
+        if 'model' in checkpoint:
+            model_dict = checkpoint['model']
+            if isinstance(model_dict, dict):
+                # Look for architecture hints in state dict keys
+                print("Checking state dict keys for architecture hints...")
+                keys = list(model_dict.keys())[:10]  # First 10 keys
+                for key in keys:
+                    print(f"  {key}")
+                
+                # Count layers
+                layer_count = len([k for k in model_dict.keys() if 'weight' in k or 'bias' in k])
+                print(f"\nTotal weight/bias tensors: {layer_count}")
+        
+        # Check checkpoint metadata
+        if 'epoch' in checkpoint:
+            print(f"Training epoch: {checkpoint.get('epoch', 'N/A')}")
+        if 'best_fitness' in checkpoint:
+            print(f"Best fitness: {checkpoint.get('best_fitness', 'N/A')}")
+        
+        # File size
+        file_size_mb = model_path.stat().st_size / (1024 * 1024)
+        print(f"\nModel file size: {file_size_mb:.2f} MB")
+        
+        # Rough size estimates based on file size (very approximate)
+        if file_size_mb < 6:
+            size_estimate = "Likely Nano (n) - file < 6MB"
+        elif file_size_mb < 22:
+            size_estimate = "Likely Small (s) - file 6-22MB"
+        elif file_size_mb < 50:
+            size_estimate = "Likely Medium (m) - file 22-50MB"
+        elif file_size_mb < 85:
+            size_estimate = "Likely Large (l) - file 50-85MB"
+        else:
+            size_estimate = "Likely XLarge (x) - file > 85MB"
+        print(f"Size estimate from file: {size_estimate}")
+        
+    except Exception as e:
+        print(f"Error with direct PyTorch inspection: {e}")
+    
+    print("\n" + "=" * 60)
+    print("Inspection complete!")
+
+
+def main():
+    parser = argparse.ArgumentParser(
+        description="Inspect YOLO .pt model to determine variant"
+    )
+    parser.add_argument(
+        "--model_path",
+        type=Path,
+        help="Path to YOLO .pt model file"
+    )
+    args = parser.parse_args()
+    
+    if not args.model_path.exists():
+        print(f"Error: Model file not found: {args.model_path}")
+        return
+    
+    inspect_yolo_model(args.model_path)
+
+
+if __name__ == "__main__":
+    main()
+

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,956 @@
+from __future__ import absolute_import
+from __future__ import division
+from __future__ import print_function
+
+import logging
+from typing import List, Tuple, Optional
+from pathlib import Path
+import numpy as np
+from numpy import extract, ndarray, array, float32, uint8
+import copy
+
+import cv2
+
+# Try to import PyTorch for GPU-accelerated warping
+try:
+    import torch
+    import torch.nn.functional as F
+    TORCH_AVAILABLE = True
+except ImportError:
+    TORCH_AVAILABLE = False
+    torch = None
+    F = None
+
+# 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)
+        # print(f"Aspect ratio: {aspect_ratio}, width: {w}, height: {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:
+        result = findHomography(destination_points, source_points)
+        if result is None:
+            raise ValueError("Failed to compute inverse homography.")
+        H_inv, _ = result
+        return warpPerspective(image, H_inv, (destination_width, destination_height))
+
+    result = findHomography(source_points, destination_points)
+    if result is None:
+        raise ValueError("Failed to compute homography.")
+    H, _ = result
+    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_masks_for_ground_and_lines_no_validation(
+    image: ndarray,
+) -> Tuple[ndarray, ndarray]:
+    """
+    Extract masks for ground (gray) and lines (white) from template image WITHOUT validation.
+    This is useful for line distribution analysis where exact fitting might create invalid masks
+    but we still want to analyze where lines are located.
+    """
+    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)
+    # No validation - return masks as-is
+    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:
+        print(f'InvalidMask or ValueError in keypoint evaluation: {e}')
+        return 0.0
+    except Exception as e:
+        print(f'Unexpected error in keypoint evaluation: {e}')
+        return 0.0
+
+def warp_image_pytorch(
+    image: ndarray,
+    homography_matrix: ndarray,
+    output_width: int,
+    output_height: int,
+    device: str = "cuda",
+) -> ndarray:
+    """
+    Warp image using PyTorch (GPU-accelerated) instead of cv2.warpPerspective.
+    
+    Args:
+        image: Input image to warp (H, W, C) numpy array
+        homography_matrix: 3x3 homography matrix
+        output_width: Output image width
+        output_height: Output image height
+        device: "cuda" or "cpu"
+    
+    Returns:
+        Warped image as numpy array
+    """
+    if not TORCH_AVAILABLE:
+        # Fallback to OpenCV if PyTorch not available
+        return warpPerspective(image, homography_matrix, (output_width, output_height))
+    
+    # Auto-detect device
+    if device == "cuda" and (not torch.cuda.is_available()):
+        device = "cpu"
+    
+    try:
+        # Convert to tensor and move to device
+        image_tensor = torch.from_numpy(image).to(device).float()
+        H = torch.from_numpy(homography_matrix).to(device).float()
+        
+        # Get image dimensions
+        h, w = image.shape[:2]
+        if len(image.shape) == 2:
+            # Grayscale
+            image_tensor = image_tensor.unsqueeze(2)  # Add channel dimension
+            channels = 1
+        else:
+            channels = image.shape[2]
+        
+        # Create coordinate grid for output image
+        y_coords, x_coords = torch.meshgrid(
+            torch.arange(0, output_height, device=device, dtype=torch.float32),
+            torch.arange(0, output_width, device=device, dtype=torch.float32),
+            indexing='ij'
+        )
+        
+        # Apply inverse homography to get source coordinates
+        ones = torch.ones_like(x_coords)
+        coords = torch.stack([x_coords.flatten(), y_coords.flatten(), ones.flatten()], dim=0)
+        H_inv = torch.inverse(H)
+        src_coords = H_inv @ coords
+        src_coords = src_coords[:2] / (src_coords[2:3] + 1e-8)
+        
+        # Reshape and normalize to [-1, 1] for grid_sample
+        src_x = src_coords[0].reshape(output_height, output_width)
+        src_y = src_coords[1].reshape(output_height, output_width)
+        
+        # Normalize coordinates to [-1, 1] for grid_sample
+        src_x_norm = 2.0 * src_x / (w - 1) - 1.0
+        src_y_norm = 2.0 * src_y / (h - 1) - 1.0
+        grid = torch.stack([src_x_norm, src_y_norm], dim=-1).unsqueeze(0)  # [1, H, W, 2]
+        
+        # Prepare image tensor: [1, C, H, W]
+        image_batch = image_tensor.permute(2, 0, 1).unsqueeze(0)
+        
+        # Warp using grid_sample
+        warped = F.grid_sample(
+            image_batch, grid, mode='bilinear', padding_mode='zeros', align_corners=True
+        )
+        
+        # Convert back to numpy: [H, W, C]
+        warped = warped.squeeze(0).permute(1, 2, 0)
+        
+        # Remove channel dimension if grayscale
+        if channels == 1:
+            warped = warped.squeeze(2)
+        
+        # Convert to uint8 and return as numpy
+        warped_np = warped.cpu().numpy().clip(0, 255).astype(np.uint8)
+        return warped_np
+        
+    except Exception as e:
+        logger.error(f"PyTorch warping failed: {e}, falling back to OpenCV")
+        return warpPerspective(image, homography_matrix, (output_width, output_height))
+
+
+def evaluate_keypoints_for_frame_gpu(
+    template_keypoints: List[Tuple[int, int]],
+    frame_keypoints: List[Tuple[int, int]],
+    frame: ndarray,
+    floor_markings_template: ndarray,
+    device: str = "cuda",
+) -> float:
+    """
+    GPU-accelerated keypoint evaluation using PyTorch for warping.
+    
+    This function uses PyTorch's grid_sample for GPU-accelerated image warping
+    instead of cv2.warpPerspective, making it compatible with PyTorch CUDA.
+    
+    Args:
+        template_keypoints: Template keypoint coordinates
+        frame_keypoints: Frame keypoint coordinates
+        frame: Input frame image
+        floor_markings_template: Template image
+        device: "cuda" or "cpu" (auto-detects if CUDA available)
+    
+    Returns:
+        Score between 0.0 and 1.0
+    """
+    if not TORCH_AVAILABLE:
+        # Fallback to CPU version if PyTorch not available
+        return evaluate_keypoints_for_frame(
+            template_keypoints, frame_keypoints, frame, floor_markings_template
+        )
+    
+    # Auto-detect device
+    if device == "cuda" and not torch.cuda.is_available():
+        device = "cpu"
+    
+    try:
+        # Step 1: Compute homography (CPU - small operation)
+        filtered_src = []
+        filtered_dst = []
+        for src_pt, dst_pt in zip(template_keypoints, frame_keypoints):
+            if dst_pt[0] == 0.0 and dst_pt[1] == 0.0:
+                continue
+            filtered_src.append(src_pt)
+            filtered_dst.append(dst_pt)
+        
+        if len(filtered_src) < 4:
+            return 0.0
+        
+        source_points = array(filtered_src, dtype=float32)
+        destination_points = array(filtered_dst, dtype=float32)
+        result = findHomography(source_points, destination_points)
+        if result is None:
+            return 0.0
+        H, _ = result
+        
+        # Validate corners
+        src_corners = array([
+            template_keypoints[INDEX_KEYPOINT_CORNER_BOTTOM_LEFT],
+            template_keypoints[INDEX_KEYPOINT_CORNER_BOTTOM_RIGHT],
+            template_keypoints[INDEX_KEYPOINT_CORNER_TOP_RIGHT],
+            template_keypoints[INDEX_KEYPOINT_CORNER_TOP_LEFT],
+        ], dtype=float32)[None, :, :]
+        warped_corners = perspectiveTransform(src_corners, H)[0]
+        if is_bowtie(warped_corners):
+            return 0.0
+        
+        # Step 2: Warp template using PyTorch (GPU-accelerated)
+        h, w = frame.shape[:2]
+        warped_template = warp_image_pytorch(
+            floor_markings_template,
+            H,
+            w,
+            h,
+            device=device
+        )
+        
+        # Step 3: Extract masks (CPU - OpenCV operations)
+        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
+        )
+        
+        # Step 4: Compute overlap
+        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))
+        
+    except (InvalidMask, ValueError) as e:
+        logger.debug(f"Keypoint evaluation failed: {e}")
+        return 0.0
+    except Exception as e:
+        logger.error(f"GPU evaluation failed: {e}, falling back to CPU")
+        return evaluate_keypoints_for_frame(
+            template_keypoints, frame_keypoints, frame, floor_markings_template
+        )
+
+
+# Cache for template GpuMat to avoid re-uploading on every frame
+_template_gpumat_cache = None
+_template_cache_key = None
+_cuda_available_cache = None
+_cuda_module_cache = None
+_frame_gpumat_reusable = None  # Reusable GpuMat for frames (same size)
+_frame_gpumat_size = None  # Size of the reusable frame GpuMat
+
+def evaluate_keypoints_for_frame_opencv_cuda(
+    template_keypoints: List[Tuple[int, int]],
+    frame_keypoints: List[Tuple[int, int]],
+    frame: ndarray,
+    floor_markings_template: ndarray,
+    device: str = "cuda",
+) -> float:
+    """
+    GPU-accelerated version using OpenCV CUDA (if available).
+    Falls back to CPU if CUDA not available.
+    
+    Note: opencv-python-headless doesn't include CUDA support, so this will
+    always fall back to CPU. Use evaluate_keypoints_for_frame_gpu for PyTorch GPU acceleration.
+    
+    Optimizations:
+    - Template GpuMat is cached to avoid re-uploading
+    - CUDA availability check is cached
+    - Frame GpuMat is reused when frame size matches
+    - Keypoint filtering optimized with list comprehension
+    
+    Args:
+        device: Ignored (kept for compatibility). OpenCV CUDA check is automatic.
+    """
+    global _template_gpumat_cache, _template_cache_key
+    global _cuda_available_cache, _cuda_module_cache, _frame_gpumat_reusable, _frame_gpumat_size
+    
+    # Cache CUDA availability check (only check once)
+    if _cuda_available_cache is None:
+        cuda_available = False
+        cuda = None
+        try:
+            import cv2.cuda as cuda
+            # Check if cv2.cuda actually has CUDA functions (not just a stub)
+            if hasattr(cuda, 'warpPerspective'):
+                # Try to create a GpuMat to verify CUDA is actually working
+                try:
+                    test_mat = cuda.GpuMat()
+                    test_mat.upload(np.zeros((10, 10, 3), dtype=np.uint8))
+                    cuda_available = True
+                except (AttributeError, Exception):
+                    # GpuMat exists but doesn't work (stub module)
+                    cuda_available = False
+        except (ImportError, AttributeError):
+            cuda_available = False
+        
+        _cuda_available_cache = cuda_available
+        _cuda_module_cache = cuda
+    else:
+        cuda_available = _cuda_available_cache
+        cuda = _cuda_module_cache
+    
+    # Always use CPU version since opencv-python-headless doesn't have CUDA
+    # The check above will fail, so we fall back to CPU
+    if not cuda_available:
+        # Use CPU version (this is what will happen with opencv-python-headless)
+        return evaluate_keypoints_for_frame(
+            template_keypoints, frame_keypoints, frame, floor_markings_template
+        )
+    
+    # If we get here, OpenCV CUDA is actually available (unlikely with opencv-python-headless)
+    try:
+        # Create cache key based on template image shape and a fast checksum
+        # Using shape + sum of corner pixels for fast comparison (much faster than full hash)
+        template_shape = floor_markings_template.shape
+        # Quick checksum: sum of corner pixels (fast to compute)
+        checksum = (
+            int(floor_markings_template[0, 0].sum()) +
+            int(floor_markings_template[0, -1].sum()) +
+            int(floor_markings_template[-1, 0].sum()) +
+            int(floor_markings_template[-1, -1].sum())
+        )
+        current_cache_key = (template_shape, checksum)
+        
+        # Check if we need to update the cached GpuMat
+        if _template_gpumat_cache is None or _template_cache_key != current_cache_key:
+            # Upload template to GPU (only once or when template changes)
+            _template_gpumat_cache = cuda.GpuMat()
+            _template_gpumat_cache.upload(floor_markings_template)
+            _template_cache_key = current_cache_key
+        
+        # Optimize frame upload: reuse GpuMat if frame size matches
+        h, w = frame.shape[:2]
+        frame_shape = (h, w)
+        if _frame_gpumat_reusable is None or _frame_gpumat_size != frame_shape:
+            _frame_gpumat_reusable = cuda.GpuMat()
+            _frame_gpumat_size = frame_shape
+        gpu_frame = _frame_gpumat_reusable
+        gpu_frame.upload(frame)
+        
+        # Use cached template GpuMat
+        gpu_template = _template_gpumat_cache
+        
+        # Optimize keypoint filtering with list comprehension (faster than loop)
+        filtered_pairs = [(src_pt, dst_pt) for src_pt, dst_pt in zip(template_keypoints, frame_keypoints) 
+                          if not (dst_pt[0] == 0.0 and dst_pt[1] == 0.0)]
+        
+        if len(filtered_pairs) < 4:
+            return 0.0
+        
+        # Unpack filtered pairs
+        filtered_src, filtered_dst = zip(*filtered_pairs)
+        
+        # Compute homography (CPU - small operation, fast)
+        source_points = array(filtered_src, dtype=float32)
+        destination_points = array(filtered_dst, dtype=float32)
+        result = findHomography(source_points, destination_points)
+        if result is None:
+            return 0.0
+        H, _ = result
+        
+        # Warp on GPU
+        gpu_warped = cuda.warpPerspective(gpu_template, H, (w, h))
+        
+        # Download for mask extraction (unavoidable - mask extraction uses CPU OpenCV)
+        warped_template = gpu_warped.download()
+        
+        # Rest of the pipeline (CPU operations - these are fast)
+        mask_ground, mask_lines_expected = extract_masks_for_ground_and_lines(warped_template)
+        mask_lines_predicted = extract_mask_of_ground_lines_in_image(frame, mask_ground)
+        
+        # Overlap computation (using cv2.bitwise_and for consistency)
+        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))
+        
+    except Exception as e:
+        logger.error(f"OpenCV CUDA evaluation failed: {e}, falling back to CPU")
+        return evaluate_keypoints_for_frame(
+            template_keypoints, frame_keypoints, frame, floor_markings_template
+        )
+
+def evaluate_keypoints_batch_gpu(
+    template_keypoints: List[Tuple[int, int]],
+    frame_keypoints_list: List[List[Tuple[int, int]]],
+    frames: List[ndarray],
+    floor_markings_template: ndarray,
+    device: str = "cuda",
+) -> List[float]:
+    """
+    Batch GPU-accelerated keypoint evaluation for multiple frames simultaneously.
+    
+    This function processes multiple frames in parallel using PyTorch batch operations,
+    which is much faster than evaluating frames one-by-one.
+    
+    Args:
+        template_keypoints: Template keypoint coordinates (same for all frames)
+        frame_keypoints_list: List of frame keypoint coordinates (one per frame)
+        frames: List of frame images (numpy arrays)
+        floor_markings_template: Template image
+        device: "cuda" or "cpu"
+    
+    Returns:
+        List of scores (one per frame) between 0.0 and 1.0
+    """
+    if not TORCH_AVAILABLE:
+        # Fallback to sequential CPU evaluation
+        return [
+            evaluate_keypoints_for_frame(
+                template_keypoints, kp, frame, floor_markings_template
+            )
+            for kp, frame in zip(frame_keypoints_list, frames)
+        ]
+    
+    # Auto-detect device
+    if device == "cuda" and not torch.cuda.is_available():
+        device = "cpu"
+    
+    batch_size = len(frames)
+    if batch_size == 0:
+        return []
+    
+    # Get frame dimensions (assuming all frames have same size)
+    h, w = frames[0].shape[:2]
+    
+    try:
+        # Step 1: Compute homographies for all frames (CPU - vectorized where possible)
+        homographies = []
+        valid_indices = []
+        
+        for idx, (frame_keypoints, frame) in enumerate(zip(frame_keypoints_list, frames)):
+            # Filter keypoints
+            filtered_pairs = [(src_pt, dst_pt) for src_pt, dst_pt in zip(template_keypoints, frame_keypoints) 
+                            if not (dst_pt[0] == 0.0 and dst_pt[1] == 0.0)]
+            
+            if len(filtered_pairs) < 4:
+                continue
+            
+            filtered_src, filtered_dst = zip(*filtered_pairs)
+            source_points = array(filtered_src, dtype=float32)
+            destination_points = array(filtered_dst, dtype=float32)
+            result = findHomography(source_points, destination_points)
+            if result is None:
+                continue
+            H, _ = result
+            
+            # Validate corners
+            src_corners = array([
+                template_keypoints[INDEX_KEYPOINT_CORNER_BOTTOM_LEFT],
+                template_keypoints[INDEX_KEYPOINT_CORNER_BOTTOM_RIGHT],
+                template_keypoints[INDEX_KEYPOINT_CORNER_TOP_RIGHT],
+                template_keypoints[INDEX_KEYPOINT_CORNER_TOP_LEFT],
+            ], dtype=float32)[None, :, :]
+            warped_corners = perspectiveTransform(src_corners, H)[0]
+            if not is_bowtie(warped_corners):
+                homographies.append(H)
+                valid_indices.append(idx)
+        
+        if len(homographies) == 0:
+            return [0.0] * batch_size
+        
+        # Step 2: Batch warp using PyTorch (much faster than sequential)
+        template_tensor = torch.from_numpy(floor_markings_template).to(device).float()
+        t_h, t_w = floor_markings_template.shape[:2]
+        
+        if len(floor_markings_template.shape) == 2:
+            template_tensor = template_tensor.unsqueeze(2)
+            t_channels = 1
+        else:
+            t_channels = floor_markings_template.shape[2]
+        
+        # Prepare template batch: [B, C, H, W]
+        template_batch = template_tensor.permute(2, 0, 1).unsqueeze(0).repeat(len(homographies), 1, 1, 1)
+        
+        # Create coordinate grids for all frames
+        y_coords, x_coords = torch.meshgrid(
+            torch.arange(0, h, device=device, dtype=torch.float32),
+            torch.arange(0, w, device=device, dtype=torch.float32),
+            indexing='ij'
+        )
+        ones = torch.ones_like(x_coords)
+        coords = torch.stack([x_coords.flatten(), y_coords.flatten(), ones.flatten()], dim=0)  # [3, H*W]
+        
+        # Batch process homographies
+        H_tensors = torch.from_numpy(np.stack(homographies)).to(device).float()  # [B, 3, 3]
+        H_inv_batch = torch.inverse(H_tensors)  # [B, 3, 3]
+        
+        # Apply inverse homography for each frame: [B, 3, 3] @ [3, H*W] -> [B, 3, H*W]
+        coords_expanded = coords.unsqueeze(0).expand(len(homographies), -1, -1)  # [B, 3, H*W]
+        src_coords_batch = torch.bmm(H_inv_batch, coords_expanded)  # [B, 3, H*W]
+        src_coords_batch = src_coords_batch[:, :2] / (src_coords_batch[:, 2:3] + 1e-8)  # [B, 2, H*W]
+        
+        # Reshape and normalize to [-1, 1] for grid_sample
+        src_x_batch = src_coords_batch[:, 0].reshape(len(homographies), h, w)
+        src_y_batch = src_coords_batch[:, 1].reshape(len(homographies), h, w)
+        src_x_norm = 2.0 * src_x_batch / (t_w - 1) - 1.0
+        src_y_norm = 2.0 * src_y_batch / (t_h - 1) - 1.0
+        grid_batch = torch.stack([src_x_norm, src_y_norm], dim=-1)  # [B, H, W, 2]
+        
+        # Batch warp using grid_sample (all frames at once!)
+        warped_batch = F.grid_sample(
+            template_batch, grid_batch, mode='bilinear', padding_mode='zeros', align_corners=True
+        )  # [B, C, H, W]
+        
+        # Convert back to numpy: [B, H, W, C]
+        warped_batch = warped_batch.permute(0, 2, 3, 1)
+        if t_channels == 1:
+            warped_batch = warped_batch.squeeze(3)
+        warped_templates = warped_batch.cpu().numpy().clip(0, 255).astype(np.uint8)
+        
+        # Step 3: Batch mask extraction and evaluation on GPU
+        scores = [0.0] * batch_size
+        
+        # Convert to tensors for batch processing
+        warped_templates_tensor = torch.from_numpy(warped_templates).to(device).float()
+        frames_tensor = torch.from_numpy(np.stack([frames[i] for i in valid_indices])).to(device).float()
+        
+        # Batch extract masks for warped templates (GPU)
+        # Convert to grayscale
+        if len(warped_templates_tensor.shape) == 4:  # [B, H, W, C]
+            gray_templates = (warped_templates_tensor[:, :, :, 0] * 0.299 + 
+                            warped_templates_tensor[:, :, :, 1] * 0.587 + 
+                            warped_templates_tensor[:, :, :, 2] * 0.114)
+        else:
+            gray_templates = warped_templates_tensor
+        
+        # Threshold for ground and lines (batch operation)
+        mask_ground_batch = (gray_templates > 10.0).float()  # [B, H, W]
+        mask_lines_expected_batch = (gray_templates > 200.0).float()  # [B, H, W]
+        
+        # Batch extract predicted lines from frames (GPU)
+        if len(frames_tensor.shape) == 4:  # [B, H, W, C]
+            gray_frames = (frames_tensor[:, :, :, 0] * 0.299 + 
+                          frames_tensor[:, :, :, 1] * 0.587 + 
+                          frames_tensor[:, :, :, 2] * 0.114)
+        else:
+            gray_frames = frames_tensor
+        
+        # Simplified edge detection (batch Sobel)
+        # Sobel kernels
+        sobel_x = torch.tensor([[-1, 0, 1], [-2, 0, 2], [-1, 0, 1]], 
+                              device=device, dtype=torch.float32).unsqueeze(0).unsqueeze(0)
+        sobel_y = torch.tensor([[-1, -2, -1], [0, 0, 0], [1, 2, 1]], 
+                              device=device, dtype=torch.float32).unsqueeze(0).unsqueeze(0)
+        
+        # Apply Sobel to batch
+        gray_frames_batch = gray_frames.unsqueeze(1)  # [B, 1, H, W]
+        grad_x_batch = F.conv2d(gray_frames_batch, sobel_x, padding=1)
+        grad_y_batch = F.conv2d(gray_frames_batch, sobel_y, padding=1)
+        magnitude_batch = torch.sqrt(grad_x_batch.squeeze(1) ** 2 + grad_y_batch.squeeze(1) ** 2 + 1e-8)
+        edges_batch = (magnitude_batch > 30.0).float()  # [B, H, W]
+        
+        # Apply ground mask
+        mask_lines_predicted_batch = edges_batch * mask_ground_batch
+        
+        # Batch overlap computation (all on GPU!)
+        pixels_overlapping_batch = (mask_lines_expected_batch * mask_lines_predicted_batch).sum(dim=(1, 2))  # [B]
+        pixels_on_lines_batch = mask_lines_expected_batch.sum(dim=(1, 2))  # [B]
+        scores_batch = (pixels_overlapping_batch / (pixels_on_lines_batch + 1e-8)).cpu().numpy()
+        
+        # Fill in scores for valid indices
+        for batch_idx, valid_idx in enumerate(valid_indices):
+            scores[valid_idx] = min(1.0, max(0.0, float(scores_batch[batch_idx])))
+        
+        return scores
+        
+    except Exception as e:
+        logger.error(f"Batch GPU evaluation failed: {e}, falling back to sequential CPU")
+        return [
+            evaluate_keypoints_for_frame(
+                template_keypoints, kp, frame, floor_markings_template
+            )
+            for kp, frame in zip(frame_keypoints_list, frames)
+        ]
+
+
+def evaluate_keypoints_batch_for_frame(
+    template_keypoints: List[Tuple[int, int]],
+    frame_keypoints_list: List[List[Tuple[int, int]]],
+    frame: ndarray,
+    floor_markings_template: ndarray,
+    device: str = "cuda",
+    batch_size: int = 32,
+) -> List[float]:
+    """
+    Fast batch GPU evaluation of multiple keypoint sets for a single frame.
+    
+    This function evaluates multiple keypoint sets (e.g., from different models)
+    for the same frame using batch GPU processing, which is much faster than
+    evaluating them sequentially.
+    
+    Args:
+        template_keypoints: Template keypoint coordinates
+        frame_keypoints_list: List of frame keypoint coordinate sets to evaluate
+        frame: Single frame image (same for all keypoint sets)
+        floor_markings_template: Template image
+        device: "cuda" or "cpu"
+        batch_size: Number of keypoint sets to process in each GPU batch
+    
+    Returns:
+        List of scores (one per keypoint set) between 0.0 and 1.0
+    """
+    if len(frame_keypoints_list) == 0:
+        return []
+    
+    if len(frame_keypoints_list) == 1:
+        # Single evaluation - use regular function
+        return [evaluate_keypoints_for_frame_opencv_cuda(
+            template_keypoints=template_keypoints,
+            frame_keypoints=frame_keypoints_list[0],
+            frame=frame,
+            floor_markings_template=floor_markings_template,
+            device=device
+        )]
+    
+    # For multiple keypoint sets, use batch processing
+    # Create list of frames (same frame repeated)
+    frames_list = [frame] * len(frame_keypoints_list)
+    
+    # Use batch GPU evaluation
+    try:
+        scores = evaluate_keypoints_batch_gpu(
+            template_keypoints=template_keypoints,
+            frame_keypoints_list=frame_keypoints_list,
+            frames=frames_list,
+            floor_markings_template=floor_markings_template,
+            device=device,
+        )
+        return scores
+    except Exception as e:
+        logger.warning(f"Batch GPU evaluation failed: {e}, falling back to sequential")
+        # Fallback to sequential evaluation
+        scores = []
+        for frame_keypoints in frame_keypoints_list:
+            try:
+                score = evaluate_keypoints_for_frame_opencv_cuda(
+                    template_keypoints=template_keypoints,
+                    frame_keypoints=frame_keypoints,
+                    frame=frame,
+                    floor_markings_template=floor_markings_template,
+                    device=device
+                )
+                scores.append(score)
+            except Exception as e2:
+                logger.debug(f"Error evaluating keypoints: {e2}")
+                scores.append(0.0)
+        return scores
+
+
+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
+
+

keypoint_helper.py

@@ -0,0 +1,115 @@
+
+import numpy as np
+from typing import List, Tuple, Sequence, Any
+
+FOOTBALL_KEYPOINTS: list[tuple[int, int]] = [
+    (0, 0),  # 1
+    (0, 0),  # 2
+    (0, 0),  # 3
+    (0, 0),  # 4
+    (0, 0),  # 5
+    (0, 0),  # 6
+    
+    (0, 0),  # 7
+    (0, 0),  # 8
+    (0, 0),  # 9
+
+    (0, 0),  # 10
+    (0, 0),  # 11
+    (0, 0),  # 12
+    (0, 0),  # 13
+
+    (0, 0),  # 14
+    (527, 283),  # 15
+    (527, 403),  # 16
+    (0, 0),  # 17
+
+    (0, 0),  # 18
+    (0, 0),  # 19
+    (0, 0),  # 20
+    (0, 0),  # 21
+
+    (0, 0),  # 22
+
+    (0, 0),  # 23
+    (0, 0),  # 24
+
+    (0, 0),  # 25
+    (0, 0),  # 26
+    (0, 0),  # 27
+    (0, 0),  # 28
+    (0, 0),  # 29
+    (0, 0),  # 30
+
+    (405, 340),  # 31
+    (645, 340),  # 32
+]
+
+def convert_keypoints_to_val_format(keypoints):
+    return [tuple(int(x) for x in pair) for pair in keypoints]
+
+def predict_failed_indices(results_frames: Sequence[Any]) -> list[int]:
+
+    max_frames = len(results_frames)
+    if max_frames == 0:
+        return []
+
+    failed_indices: list[int] = []
+    for frame_index, frame_result in enumerate(results_frames):
+        frame_keypoints = getattr(frame_result, "keypoints", []) or []
+        non_zero_count = sum(1 for (x, y) in frame_keypoints if int(x) != 0 and int(y) != 0)
+        if non_zero_count <= 4:
+            failed_indices.append(frame_index)
+    return failed_indices
+
+def _generate_sparse_template_keypoints(frame_width: int, frame_height: int) -> list[tuple[int, int]]:
+    template_max_x, template_max_y = (1045, 675)
+    sx = float(frame_width) / float(template_max_x if template_max_x != 0 else 1)
+    sy = float(frame_height) / float(template_max_y if template_max_y != 0 else 1)
+    scaled: list[tuple[int, int]] = []
+    for i in range(32):
+        tx, ty = FOOTBALL_KEYPOINTS[i]
+        x_scaled = int(round(tx * sx))
+        y_scaled = int(round(ty * sy))
+        scaled.append((x_scaled, y_scaled))
+    return scaled
+
+def fix_keypoints(
+    results_frames: Sequence[Any],
+    failed_indices: Sequence[int],
+    frame_width: int,
+    frame_height: int,
+) -> list[Any]:
+    max_frames = len(results_frames)
+    if max_frames == 0:
+        return list(results_frames)
+
+    failed_set = set(int(i) for i in failed_indices)
+    all_indices = list(range(max_frames))
+    successful_indices = [i for i in all_indices if i not in failed_set]
+
+    if len(successful_indices) == 0:
+        sparse_template = _generate_sparse_template_keypoints(frame_width, frame_height)
+        for frame_result in results_frames:
+            setattr(frame_result, "keypoints", list(convert_keypoints_to_val_format(sparse_template)))
+        return list(results_frames)
+
+    seed_index = successful_indices[0]
+    seed_kps_raw = getattr(results_frames[seed_index], "keypoints", []) or []
+    last_success_kps = convert_keypoints_to_val_format(seed_kps_raw)
+
+    for frame_index in range(max_frames):
+        frame_result = results_frames[frame_index]
+        if frame_index in failed_set:
+            setattr(frame_result, "keypoints", list(last_success_kps))
+        else:
+            current_kps_raw = getattr(frame_result, "keypoints", []) or []
+            current_kps = convert_keypoints_to_val_format(current_kps_raw)
+            setattr(frame_result, "keypoints", list(current_kps))
+            last_success_kps = current_kps
+
+    return list(results_frames)
+
+def run_keypoints_post_processing(results_frames: Sequence[Any], frame_width: int, frame_height: int) -> list[Any]:
+    failed_indices = predict_failed_indices(results_frames)
+    return fix_keypoints(results_frames, failed_indices, frame_width, frame_height)

miner.py

@@ -0,0 +1,881 @@
+from pathlib import Path
+from typing import List, Tuple, Dict, Optional
+import sys
+import os
+
+from numpy import ndarray
+from pydantic import BaseModel
+
+sys.path.append(os.path.dirname(os.path.abspath(__file__)))
+from keypoint_helper import run_keypoints_post_processing
+from keypoint_helper_v2 import run_keypoints_post_processing as run_keypoints_post_processing_v2
+
+from ultralytics import YOLO
+from team_cluster import TeamClassifier
+from utils import (
+    BoundingBox, 
+    Constants,
+)
+
+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
+from keypoint_evaluation import (
+    evaluate_keypoints_for_frame,
+    evaluate_keypoints_for_frame_gpu, 
+    load_template_from_file, 
+    evaluate_keypoints_for_frame_opencv_cuda,
+    evaluate_keypoints_batch_for_frame,
+)
+
+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):
+        self.team_classifier_fitted = False
+        start = time.time()
+        # Collect player crops from first batch for fitting
+        fit_sample_size = 600
+        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
+            # Collect player boxes for team classification fitting (first batch only)
+            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:
+                        continue
+                    mapped_cls_id = str(int(cls_id))
+                    # Only collect player crops (cls_id = 2)
+                    if mapped_cls_id == '2':
+                        crop = frame_image[int(y1):int(y2), int(x1):int(x2)]
+                        if crop.size > 0:
+                            player_crops_for_fit.append(crop)
+
+            # Fit team classifier after collecting samples
+            if self.team_classifier and not self.team_classifier_fitted and len(player_crops_for_fit) >= fit_sample_size:
+                print(f"Fitting TeamClassifier 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) >= 16:
+            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
+        end = time.time()
+        print(f"Fitting Kmeans time: {end - start}")
+
+        # Second pass: predict teams with configurable frame skipping optimization
+        start = time.time()
+
+        # Get configuration for frame skipping
+        prediction_interval = 1  # Default: predict every 2 frames
+        iou_threshold = 0.3
+
+        print(f"Team classification - prediction_interval: {prediction_interval}, iou_threshold: {iou_threshold}")
+
+        # Storage for predicted frame results: {frame_id: {box_idx: (bbox, team_id)}}
+        predicted_frame_data = {}
+
+        # Step 1: Predict for frames at prediction_interval only
+        frames_to_predict = []
+        for frame_id in range(len(detection_results)):
+            if frame_id % prediction_interval == 0:
+                frames_to_predict.append(frame_id)
+
+        print(f"Predicting teams for {len(frames_to_predict)}/{len(detection_results)} frames "
+                    f"(saving {100 - (len(frames_to_predict) * 100 // len(detection_results))}% compute)")
+
+        for frame_id in frames_to_predict:
+            detection_box = detection_results[frame_id].boxes.data
+            frame_image = decoded_images[frame_id]
+
+            # Collect player crops for this frame
+            frame_player_crops = []
+            frame_player_indices = []
+            frame_player_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
+                mapped_cls_id = str(int(cls_id))
+
+                # Collect player crops for prediction
+                if self.team_classifier and self.team_classifier_fitted and mapped_cls_id == '2':
+                    crop = frame_image[int(y1):int(y2), int(x1):int(x2)]
+                    if crop.size > 0:
+                        frame_player_crops.append(crop)
+                        frame_player_indices.append(idx)
+                        frame_player_boxes.append((x1, y1, x2, y2))
+
+            # Predict teams for all players in this frame
+            if len(frame_player_crops) > 0:
+                team_ids = self.team_classifier.predict(frame_player_crops)
+                predicted_frame_data[frame_id] = {}
+                for idx, bbox, team_id in zip(frame_player_indices, frame_player_boxes, team_ids):
+                    # Map team_id (0,1) to cls_id (6,7)
+                    team_cls_id = str(6 + int(team_id))
+                    predicted_frame_data[frame_id][idx] = (bbox, team_cls_id)
+
+        # Step 2: Process all frames (interpolate skipped frames)
+        fallback_count = 0
+        interpolated_count = 0
+        bboxes: dict[int, list[BoundingBox]] = {}
+        for frame_id in range(len(detection_results)):
+            detection_box = detection_results[frame_id].boxes.data
+            frame_image = decoded_images[frame_id]
+            boxes = []
+
+            team_predictions = {}
+
+            if frame_id % prediction_interval == 0:
+                # Predicted frame: use pre-computed predictions
+                if frame_id in predicted_frame_data:
+                    for idx, (bbox, team_cls_id) in predicted_frame_data[frame_id].items():
+                        team_predictions[idx] = team_cls_id
+            else:
+                # Skipped frame: interpolate from neighboring predicted frames
+                # Find nearest predicted frames
+                prev_predicted_frame = (frame_id // prediction_interval) * prediction_interval
+                next_predicted_frame = prev_predicted_frame + prediction_interval
+
+                # Collect current frame player 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
+                    mapped_cls_id = str(int(cls_id))
+
+                    if self.team_classifier and self.team_classifier_fitted and mapped_cls_id == '2':
+                        target_box = (x1, y1, x2, y2)
+
+                        # Try to match with previous predicted frame
+                        best_team_id = None
+                        best_iou = 0.0
+
+                        if prev_predicted_frame in predicted_frame_data:
+                            team_id, iou = self._find_best_match(
+                                target_box,
+                                predicted_frame_data[prev_predicted_frame],
+                                iou_threshold
+                            )
+                            if team_id is not None:
+                                best_team_id = team_id
+                                best_iou = iou
+
+                        # Try to match with next predicted frame if available and no good match yet
+                        if best_team_id is None and next_predicted_frame < len(detection_results):
+                            if next_predicted_frame in predicted_frame_data:
+                                team_id, iou = self._find_best_match(
+                                    target_box,
+                                    predicted_frame_data[next_predicted_frame],
+                                    iou_threshold
+                                )
+                                if team_id is not None and iou > best_iou:
+                                    best_team_id = team_id
+                                    best_iou = iou
+
+                        # Track interpolation success
+                        if best_team_id is not None:
+                            interpolated_count += 1
+                        else:
+                            # Fallback: if no match found, predict individually
+                            crop = frame_image[int(y1):int(y2), int(x1):int(x2)]
+                            if crop.size > 0:
+                                team_id = self.team_classifier.predict([crop])[0]
+                                best_team_id = str(6 + int(team_id))
+                                fallback_count += 1
+
+                        if best_team_id is not None:
+                            team_predictions[idx] = best_team_id
+
+            # Parse boxes with team classification
+            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 box
+                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 cls_id for players with team prediction
+                if idx in team_predictions:
+                    mapped_cls_id = team_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
+        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
+        start = time.time()
+        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()
+        last_score = 0
+        last_valid_keypoints = None
+        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]
+
+                    time1 = time.time()
+                    frame_keypoints_yolo = keypoints_yolo.get(offset + frame_number_in_batch, frame_keypoints)
+                    
+                    valid_keypoints_count = 0
+                    valid_keypoints_yolo_count = 0
+                    for kp in frame_keypoints:
+                        if kp[0] != 0.0 or kp[1] != 0.0:
+                            valid_keypoints_count += 1
+                            if valid_keypoints_count > 3:
+                                break
+
+                    for kp in frame_keypoints_yolo:
+                        if kp[0] != 0.0 or kp[1] != 0.0:
+                            valid_keypoints_yolo_count += 1
+                            if valid_keypoints_yolo_count > 3:
+                                break
+
+                    # Evaluate and select best keypoints (using batch evaluation for speed)
+                    if valid_keypoints_count > 3 and valid_keypoints_yolo_count > 3:
+                        try:
+                            last_valid_keypoints = keypoints.get(offset + frame_number_in_batch - 1, frame_keypoints)
+                            # Evaluate both keypoint sets in batch (much faster!)
+                            scores = evaluate_keypoints_batch_for_frame(
+                                template_keypoints=self.template_keypoints,
+                                frame_keypoints_list=[frame_keypoints, frame_keypoints_yolo, last_valid_keypoints],
+                                frame=batch_images[frame_number_in_batch],
+                                floor_markings_template=self.template_image,
+                                device="cuda"
+                            )
+                            score = scores[0]
+                            score_yolo = scores[1]
+                            last_score = scores[2]
+                            
+                            if last_score > score and last_score > score_yolo:
+                                frame_keypoints = last_valid_keypoints
+                            elif score_yolo > score:
+                                frame_keypoints = frame_keypoints_yolo
+                                last_score = score_yolo
+                            else:
+                                last_score = score
+
+                            last_valid_keypoints = frame_keypoints
+                            
+                        except Exception as e:
+                            # Fallback: use YOLO if available, otherwise use pitch model
+                            if valid_keypoints_yolo_count > 3:
+                                frame_keypoints = frame_keypoints_yolo
+                    elif valid_keypoints_yolo_count > 3:
+                        # Only YOLO has valid keypoints
+                        frame_keypoints = frame_keypoints_yolo
+                    else:
+                        if last_valid_keypoints is not None:
+                            frame_keypoints = last_valid_keypoints
+
+                    time2 = time.time()
+                    print(f"Keypoint evaluation time: {time2 - time1}")
+                    
+                    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)
+
+        start = time.time()
+        if len(batch_images) > 0:
+            h, w = batch_images[0].shape[:2]
+            results = run_keypoints_post_processing_v2(
+                results, w, h,
+                frames=batch_images,
+                template_keypoints=self.template_keypoints,
+                floor_markings_template=self.template_image,
+                offset=offset
+            )
+        end = time.time()
+        print(f"Keypoint post processing time: {end - start}")
+
+        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
+
+    def predict_keypoints(
+        self, 
+        images: List[ndarray], 
+        n_keypoints: int = 32,
+        batch_size: Optional[int] = None,
+        conf_threshold: float = 0.5,
+        corner_conf_threshold: float = 0.3,
+        verbose: bool = False
+    ) -> Dict[int, List[Tuple[int, int]]]:
+        """
+        Standalone function for keypoint detection on a list of images.
+        Optimized for maximum prediction speed.
+        
+        Args:
+            images: List of images (numpy arrays) to process
+            n_keypoints: Number of keypoints expected per frame (default: 32)
+            batch_size: Batch size for YOLO prediction (None = auto, uses all images)
+            conf_threshold: Confidence threshold for regular keypoints (default: 0.5)
+            corner_conf_threshold: Confidence threshold for corner keypoints (default: 0.3)
+            verbose: Whether to print progress information
+            
+        Returns:
+            Dictionary mapping frame index to list of keypoint coordinates (x, y)
+            Frame indices start from 0
+        """
+        if not images:
+            return {}
+        
+        keypoints: Dict[int, List[Tuple[int, int]]] = {}
+        
+        # Use provided batch_size or process all at once for maximum speed
+        if batch_size is None:
+            batch_size = len(images)
+        
+        # Process in batches for optimal GPU utilization
+        for batch_start in range(0, len(images), batch_size):
+            batch_end = min(batch_start + batch_size, len(images))
+            batch_images = images[batch_start:batch_end]
+            
+            if verbose:
+                print(f"Processing keypoints batch {batch_start}-{batch_end-1} ({len(batch_images)} images)")
+            
+            # YOLO keypoint prediction (optimized batch processing)
+            keypoints_model_results = self.keypoints_model_yolo.predict(
+                batch_images, 
+                verbose=False,
+                save=False,
+                conf=0.1,  # Lower conf for detection, we filter later
+            )
+            
+            if keypoints_model_results is None:
+                # Fill with empty keypoints for this batch
+                for frame_idx in range(batch_start, batch_end):
+                    keypoints[frame_idx] = [(0, 0)] * n_keypoints
+                continue
+            
+            # Process each frame in the batch
+            for batch_idx, detection in enumerate(keypoints_model_results):
+                frame_idx = batch_start + batch_idx
+                
+                if not hasattr(detection, "keypoints") or detection.keypoints is None:
+                    keypoints[frame_idx] = [(0, 0)] * n_keypoints
+                    continue
+                
+                # Extract keypoints with confidence
+                frame_keypoints_with_conf: List[Tuple[int, int, float]] = []
+                try:
+                    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))
+                except (AttributeError, IndexError, TypeError):
+                    keypoints[frame_idx] = [(0, 0)] * n_keypoints
+                    continue
+                
+                # 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 < corner_conf_threshold:
+                            filtered_keypoints.append((0, 0))
+                        else:
+                            filtered_keypoints.append((int(x), int(y)))
+                    else:
+                        # Regular keypoints
+                        if confidence < conf_threshold:
+                            filtered_keypoints.append((0, 0))
+                        else:
+                            filtered_keypoints.append((int(x), int(y)))
+                
+                keypoints[frame_idx] = filtered_keypoints
+        
+        return keypoints
+
+    def predict_objects(
+        self,
+        images: List[ndarray],
+        batch_size: Optional[int] = 16,
+        conf_threshold: float = 0.5,
+        iou_threshold: float = 0.45,
+        classes: Optional[List[int]] = None,
+        verbose: bool = False,
+    ) -> Dict[int, List[BoundingBox]]:
+        """
+        Standalone high-throughput object detection function.
+        Runs the YOLO detector directly on raw images while skipping
+        any team-classification or keypoint stages for maximum FPS.
+
+        Args:
+            images: List of frames (BGR numpy arrays).
+            batch_size: Number of frames per inference pass. Use None to process
+                all frames at once (fastest but highest memory usage).
+            conf_threshold: Detection confidence threshold.
+            iou_threshold: IoU threshold for NMS within YOLO.
+            classes: Optional list of class IDs to keep (None = all classes).
+            verbose: Whether to print per-batch progress from YOLO.
+
+        Returns:
+            Dict mapping frame index -> list of BoundingBox predictions.
+        """
+        if not images:
+            return {}
+
+        detections: Dict[int, List[BoundingBox]] = {}
+        effective_batch = len(images) if batch_size is None else max(1, batch_size)
+
+        for batch_start in range(0, len(images), effective_batch):
+            batch_end = min(batch_start + effective_batch, len(images))
+            batch_images = images[batch_start:batch_end]
+
+            start = time.time()
+            yolo_results = self.bbox_model(
+                batch_images,
+                conf=conf_threshold,
+                iou=iou_threshold,
+                classes=classes,
+                verbose=verbose,
+                save=False,
+            )
+            end = time.time()
+            print(f"YOLO time: {end - start}")
+
+            for local_idx, result in enumerate(yolo_results):
+                frame_idx = batch_start + local_idx
+                frame_boxes: List[BoundingBox] = []
+
+                if not hasattr(result, "boxes") or result.boxes is None:
+                    detections[frame_idx] = frame_boxes
+                    continue
+
+                boxes_tensor = result.boxes.data
+                if boxes_tensor is None:
+                    detections[frame_idx] = frame_boxes
+                    continue
+
+                for box in boxes_tensor:
+                    try:
+                        x1, y1, x2, y2, conf, cls_id = box.tolist()
+                        frame_boxes.append(
+                            BoundingBox(
+                                x1=int(x1),
+                                y1=int(y1),
+                                x2=int(x2),
+                                y2=int(y2),
+                                cls_id=int(cls_id),
+                                conf=float(conf),
+                            )
+                        )
+                    except (ValueError, TypeError):
+                        continue
+
+                detections[frame_idx] = frame_boxes
+
+        return detections
+    

miner1.py

@@ -0,0 +1,685 @@
+from pathlib import Path
+from typing import List, Tuple, Dict, Optional
+import sys
+import os
+
+from numpy import ndarray
+from pydantic import BaseModel
+
+sys.path.append(os.path.dirname(os.path.abspath(__file__)))
+from keypoint_helper import run_keypoints_post_processing
+from keypoint_helper_v2 import run_keypoints_post_processing as run_keypoints_post_processing_v2
+
+from ultralytics import YOLO
+from team_cluster import TeamClassifier
+from utils import (
+    BoundingBox, 
+    Constants,
+)
+
+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
+from keypoint_evaluation import (
+    evaluate_keypoints_for_frame,
+    evaluate_keypoints_for_frame_gpu, 
+    load_template_from_file, 
+    evaluate_keypoints_for_frame_opencv_cuda,
+    evaluate_keypoints_batch_for_frame,
+)
+
+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):
+        self.team_classifier_fitted = False
+        start = time.time()
+        # Collect player crops from first batch for fitting
+        fit_sample_size = 600
+        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
+            # Collect player boxes for team classification fitting (first batch only)
+            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:
+                        continue
+                    mapped_cls_id = str(int(cls_id))
+                    # Only collect player crops (cls_id = 2)
+                    if mapped_cls_id == '2':
+                        crop = frame_image[int(y1):int(y2), int(x1):int(x2)]
+                        if crop.size > 0:
+                            player_crops_for_fit.append(crop)
+
+            # Fit team classifier after collecting samples
+            if self.team_classifier and not self.team_classifier_fitted and len(player_crops_for_fit) >= fit_sample_size:
+                print(f"Fitting TeamClassifier 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) >= 16:
+            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
+        end = time.time()
+        print(f"Fitting Kmeans time: {end - start}")
+
+        # Second pass: predict teams with configurable frame skipping optimization
+        start = time.time()
+
+        # Get configuration for frame skipping
+        prediction_interval = 1  # Default: predict every 2 frames
+        iou_threshold = 0.3
+
+        print(f"Team classification - prediction_interval: {prediction_interval}, iou_threshold: {iou_threshold}")
+
+        # Storage for predicted frame results: {frame_id: {box_idx: (bbox, team_id)}}
+        predicted_frame_data = {}
+
+        # Step 1: Predict for frames at prediction_interval only
+        frames_to_predict = []
+        for frame_id in range(len(detection_results)):
+            if frame_id % prediction_interval == 0:
+                frames_to_predict.append(frame_id)
+
+        print(f"Predicting teams for {len(frames_to_predict)}/{len(detection_results)} frames "
+                    f"(saving {100 - (len(frames_to_predict) * 100 // len(detection_results))}% compute)")
+
+        for frame_id in frames_to_predict:
+            detection_box = detection_results[frame_id].boxes.data
+            frame_image = decoded_images[frame_id]
+
+            # Collect player crops for this frame
+            frame_player_crops = []
+            frame_player_indices = []
+            frame_player_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
+                mapped_cls_id = str(int(cls_id))
+
+                # Collect player crops for prediction
+                if self.team_classifier and self.team_classifier_fitted and mapped_cls_id == '2':
+                    crop = frame_image[int(y1):int(y2), int(x1):int(x2)]
+                    if crop.size > 0:
+                        frame_player_crops.append(crop)
+                        frame_player_indices.append(idx)
+                        frame_player_boxes.append((x1, y1, x2, y2))
+
+            # Predict teams for all players in this frame
+            if len(frame_player_crops) > 0:
+                team_ids = self.team_classifier.predict(frame_player_crops)
+                predicted_frame_data[frame_id] = {}
+                for idx, bbox, team_id in zip(frame_player_indices, frame_player_boxes, team_ids):
+                    # Map team_id (0,1) to cls_id (6,7)
+                    team_cls_id = str(6 + int(team_id))
+                    predicted_frame_data[frame_id][idx] = (bbox, team_cls_id)
+
+        # Step 2: Process all frames (interpolate skipped frames)
+        fallback_count = 0
+        interpolated_count = 0
+        bboxes: dict[int, list[BoundingBox]] = {}
+        for frame_id in range(len(detection_results)):
+            detection_box = detection_results[frame_id].boxes.data
+            frame_image = decoded_images[frame_id]
+            boxes = []
+
+            team_predictions = {}
+
+            if frame_id % prediction_interval == 0:
+                # Predicted frame: use pre-computed predictions
+                if frame_id in predicted_frame_data:
+                    for idx, (bbox, team_cls_id) in predicted_frame_data[frame_id].items():
+                        team_predictions[idx] = team_cls_id
+            else:
+                # Skipped frame: interpolate from neighboring predicted frames
+                # Find nearest predicted frames
+                prev_predicted_frame = (frame_id // prediction_interval) * prediction_interval
+                next_predicted_frame = prev_predicted_frame + prediction_interval
+
+                # Collect current frame player 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
+                    mapped_cls_id = str(int(cls_id))
+
+                    if self.team_classifier and self.team_classifier_fitted and mapped_cls_id == '2':
+                        target_box = (x1, y1, x2, y2)
+
+                        # Try to match with previous predicted frame
+                        best_team_id = None
+                        best_iou = 0.0
+
+                        if prev_predicted_frame in predicted_frame_data:
+                            team_id, iou = self._find_best_match(
+                                target_box,
+                                predicted_frame_data[prev_predicted_frame],
+                                iou_threshold
+                            )
+                            if team_id is not None:
+                                best_team_id = team_id
+                                best_iou = iou
+
+                        # Try to match with next predicted frame if available and no good match yet
+                        if best_team_id is None and next_predicted_frame < len(detection_results):
+                            if next_predicted_frame in predicted_frame_data:
+                                team_id, iou = self._find_best_match(
+                                    target_box,
+                                    predicted_frame_data[next_predicted_frame],
+                                    iou_threshold
+                                )
+                                if team_id is not None and iou > best_iou:
+                                    best_team_id = team_id
+                                    best_iou = iou
+
+                        # Track interpolation success
+                        if best_team_id is not None:
+                            interpolated_count += 1
+                        else:
+                            # Fallback: if no match found, predict individually
+                            crop = frame_image[int(y1):int(y2), int(x1):int(x2)]
+                            if crop.size > 0:
+                                team_id = self.team_classifier.predict([crop])[0]
+                                best_team_id = str(6 + int(team_id))
+                                fallback_count += 1
+
+                        if best_team_id is not None:
+                            team_predictions[idx] = best_team_id
+
+            # Parse boxes with team classification
+            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 box
+                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 cls_id for players with team prediction
+                if idx in team_predictions:
+                    mapped_cls_id = team_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
+        return bboxes
+
+
+    def predict_batch(self, batch_images: List[ndarray], offset: int, n_keypoints: int) -> List[TVFrameResult]:     
+        print('=' * 10)
+        print(f"Offset: {offset}, Batch size: {len(batch_images)}")
+        print('=' * 10)   
+
+        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]
+
+        #             # time1 = time.time()
+        #             # frame_keypoints_yolo = keypoints_yolo.get(offset + frame_number_in_batch, frame_keypoints)
+                    
+        #             # valid_keypoints_count = 0
+        #             # valid_keypoints_yolo_count = 0
+        #             # for kp in frame_keypoints:
+        #             #     if kp[0] != 0.0 or kp[1] != 0.0:
+        #             #         valid_keypoints_count += 1
+        #             #         if valid_keypoints_count > 3:
+        #             #             break
+
+        #             # for kp in frame_keypoints_yolo:
+        #             #     if kp[0] != 0.0 or kp[1] != 0.0:
+        #             #         valid_keypoints_yolo_count += 1
+        #             #         if valid_keypoints_yolo_count > 3:
+        #             #             break
+
+        #             # # Evaluate and select best keypoints (using batch evaluation for speed)
+        #             # if valid_keypoints_count > 3 and valid_keypoints_yolo_count > 3:
+        #             #     try:
+        #             #         # Evaluate both keypoint sets in batch (much faster!)
+        #             #         scores = evaluate_keypoints_batch_for_frame(
+        #             #             template_keypoints=self.template_keypoints,
+        #             #             frame_keypoints_list=[frame_keypoints, frame_keypoints_yolo],
+        #             #             frame=batch_images[frame_number_in_batch],
+        #             #             floor_markings_template=self.template_image,
+        #             #             device="cuda"
+        #             #         )
+        #             #         score = scores[0]
+        #             #         score_yolo = scores[1]
+                            
+        #             #         # Select the one with higher score
+        #             #         if score_yolo > score:
+        #             #             frame_keypoints = frame_keypoints_yolo
+        #             #     except Exception as e:
+        #             #         # Fallback: use YOLO if available, otherwise use pitch model
+        #             #         if valid_keypoints_yolo_count > 3:
+        #             #             frame_keypoints = frame_keypoints_yolo
+        #             # elif valid_keypoints_yolo_count > 3:
+        #             #     # Only YOLO has valid keypoints
+        #             #     frame_keypoints = frame_keypoints_yolo
+        #             # time2 = time.time()
+        #             # print(f"Keypoint evaluation time: {time2 - time1}")
+                    
+        #             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_yolo.get(
+                        frame_number,
+                        [(0, 0) for _ in range(n_keypoints)],
+                    ),
+            )
+            results.append(result)
+
+        start = time.time()
+        if len(batch_images) > 0:
+            h, w = batch_images[0].shape[:2]
+            results = run_keypoints_post_processing_v2(
+                results, w, h,
+                frames=batch_images,
+                template_keypoints=self.template_keypoints,
+                floor_markings_template=self.template_image,
+                offset=offset
+            )
+        end = time.time()
+        print(f"Keypoint post processing time: {end - start}")
+
+        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
+    

miner2.py

@@ -0,0 +1,953 @@
+from pathlib import Path
+from typing import List, Tuple, Dict, Optional
+import sys
+import os
+
+from numpy import ndarray
+from pydantic import BaseModel
+
+sys.path.append(os.path.dirname(os.path.abspath(__file__)))
+from keypoint_helper import run_keypoints_post_processing
+from keypoint_helper_v2 import run_keypoints_post_processing as run_keypoints_post_processing_v2
+
+from ultralytics import YOLO
+from team_cluster import TeamClassifier
+from utils import (
+    BoundingBox, 
+    Constants,
+)
+
+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
+from keypoint_evaluation import (
+    evaluate_keypoints_for_frame,
+    evaluate_keypoints_for_frame_gpu, 
+    load_template_from_file, 
+    evaluate_keypoints_for_frame_opencv_cuda,
+    evaluate_keypoints_batch_for_frame,
+)
+
+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")
+            
+            self.last_score = 0
+            self.last_valid_keypoints = None
+            # 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):
+        self.team_classifier_fitted = False
+        start = time.time()
+        # Collect player crops from first batch for fitting
+        fit_sample_size = 600
+        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
+            # Collect player boxes for team classification fitting (first batch only)
+            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:
+                        continue
+                    mapped_cls_id = str(int(cls_id))
+                    # Only collect player crops (cls_id = 2)
+                    if mapped_cls_id == '2':
+                        crop = frame_image[int(y1):int(y2), int(x1):int(x2)]
+                        if crop.size > 0:
+                            player_crops_for_fit.append(crop)
+
+            # Fit team classifier after collecting samples
+            if self.team_classifier and not self.team_classifier_fitted and len(player_crops_for_fit) >= fit_sample_size:
+                print(f"Fitting TeamClassifier 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) >= 16:
+            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
+        end = time.time()
+        print(f"Fitting Kmeans time: {end - start}")
+
+        # Second pass: predict teams with configurable frame skipping optimization
+        start = time.time()
+
+        # Get configuration for frame skipping
+        prediction_interval = 1  # Default: predict every 2 frames
+        iou_threshold = 0.3
+
+        print(f"Team classification - prediction_interval: {prediction_interval}, iou_threshold: {iou_threshold}")
+
+        # Storage for predicted frame results: {frame_id: {box_idx: (bbox, team_id)}}
+        predicted_frame_data = {}
+
+        # Step 1: Predict for frames at prediction_interval only
+        frames_to_predict = []
+        for frame_id in range(len(detection_results)):
+            if frame_id % prediction_interval == 0:
+                frames_to_predict.append(frame_id)
+
+        print(f"Predicting teams for {len(frames_to_predict)}/{len(detection_results)} frames "
+                    f"(saving {100 - (len(frames_to_predict) * 100 // len(detection_results))}% compute)")
+
+        for frame_id in frames_to_predict:
+            detection_box = detection_results[frame_id].boxes.data
+            frame_image = decoded_images[frame_id]
+
+            # Collect player crops for this frame
+            frame_player_crops = []
+            frame_player_indices = []
+            frame_player_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
+                mapped_cls_id = str(int(cls_id))
+
+                # Collect player crops for prediction
+                if self.team_classifier and self.team_classifier_fitted and mapped_cls_id == '2':
+                    crop = frame_image[int(y1):int(y2), int(x1):int(x2)]
+                    if crop.size > 0:
+                        frame_player_crops.append(crop)
+                        frame_player_indices.append(idx)
+                        frame_player_boxes.append((x1, y1, x2, y2))
+
+            # Predict teams for all players in this frame
+            if len(frame_player_crops) > 0:
+                team_ids = self.team_classifier.predict(frame_player_crops)
+                predicted_frame_data[frame_id] = {}
+                for idx, bbox, team_id in zip(frame_player_indices, frame_player_boxes, team_ids):
+                    # Map team_id (0,1) to cls_id (6,7)
+                    team_cls_id = str(6 + int(team_id))
+                    predicted_frame_data[frame_id][idx] = (bbox, team_cls_id)
+
+        # Step 2: Process all frames (interpolate skipped frames)
+        fallback_count = 0
+        interpolated_count = 0
+        bboxes: dict[int, list[BoundingBox]] = {}
+        for frame_id in range(len(detection_results)):
+            detection_box = detection_results[frame_id].boxes.data
+            frame_image = decoded_images[frame_id]
+            boxes = []
+
+            team_predictions = {}
+
+            if frame_id % prediction_interval == 0:
+                # Predicted frame: use pre-computed predictions
+                if frame_id in predicted_frame_data:
+                    for idx, (bbox, team_cls_id) in predicted_frame_data[frame_id].items():
+                        team_predictions[idx] = team_cls_id
+            else:
+                # Skipped frame: interpolate from neighboring predicted frames
+                # Find nearest predicted frames
+                prev_predicted_frame = (frame_id // prediction_interval) * prediction_interval
+                next_predicted_frame = prev_predicted_frame + prediction_interval
+
+                # Collect current frame player 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
+                    mapped_cls_id = str(int(cls_id))
+
+                    if self.team_classifier and self.team_classifier_fitted and mapped_cls_id == '2':
+                        target_box = (x1, y1, x2, y2)
+
+                        # Try to match with previous predicted frame
+                        best_team_id = None
+                        best_iou = 0.0
+
+                        if prev_predicted_frame in predicted_frame_data:
+                            team_id, iou = self._find_best_match(
+                                target_box,
+                                predicted_frame_data[prev_predicted_frame],
+                                iou_threshold
+                            )
+                            if team_id is not None:
+                                best_team_id = team_id
+                                best_iou = iou
+
+                        # Try to match with next predicted frame if available and no good match yet
+                        if best_team_id is None and next_predicted_frame < len(detection_results):
+                            if next_predicted_frame in predicted_frame_data:
+                                team_id, iou = self._find_best_match(
+                                    target_box,
+                                    predicted_frame_data[next_predicted_frame],
+                                    iou_threshold
+                                )
+                                if team_id is not None and iou > best_iou:
+                                    best_team_id = team_id
+                                    best_iou = iou
+
+                        # Track interpolation success
+                        if best_team_id is not None:
+                            interpolated_count += 1
+                        else:
+                            # Fallback: if no match found, predict individually
+                            crop = frame_image[int(y1):int(y2), int(x1):int(x2)]
+                            if crop.size > 0:
+                                team_id = self.team_classifier.predict([crop])[0]
+                                best_team_id = str(6 + int(team_id))
+                                fallback_count += 1
+
+                        if best_team_id is not None:
+                            team_predictions[idx] = best_team_id
+
+            # Parse boxes with team classification
+            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 box
+                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 cls_id for players with team prediction
+                if idx in team_predictions:
+                    mapped_cls_id = team_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
+        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
+        start = time.time()
+        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]
+
+                    # time1 = time.time()
+                    # frame_keypoints_yolo = keypoints_yolo.get(offset + frame_number_in_batch, frame_keypoints)
+                    
+                    # valid_keypoints_count = 0
+                    # valid_keypoints_yolo_count = 0
+                    # for kp in frame_keypoints:
+                    #     if kp[0] != 0.0 or kp[1] != 0.0:
+                    #         valid_keypoints_count += 1
+                    #         if valid_keypoints_count > 3:
+                    #             break
+
+                    # for kp in frame_keypoints_yolo:
+                    #     if kp[0] != 0.0 or kp[1] != 0.0:
+                    #         valid_keypoints_yolo_count += 1
+                    #         if valid_keypoints_yolo_count > 3:
+                    #             break
+
+                    # # Evaluate and select best keypoints (using batch evaluation for speed)
+                    # if valid_keypoints_count > 3 and valid_keypoints_yolo_count > 3:
+                    #     try:
+                    #         last_valid_keypoints = keypoints.get(offset + frame_number_in_batch - 1, frame_keypoints)
+                    #         # Evaluate both keypoint sets in batch (much faster!)
+                    #         scores = evaluate_keypoints_batch_for_frame(
+                    #             template_keypoints=self.template_keypoints,
+                    #             frame_keypoints_list=[frame_keypoints, frame_keypoints_yolo, last_valid_keypoints],
+                    #             frame=batch_images[frame_number_in_batch],
+                    #             floor_markings_template=self.template_image,
+                    #             device="cuda"
+                    #         )
+                    #         score = scores[0]
+                    #         score_yolo = scores[1]
+                    #         last_score = scores[2]
+                            
+                    #         if last_score > score and last_score > score_yolo:
+                    #             frame_keypoints = last_valid_keypoints
+                    #         if score_yolo > score:
+                    #             frame_keypoints = frame_keypoints_yolo
+                    #             last_score = score_yolo
+                    #         else:
+                    #             last_score = score
+
+                    #         last_valid_keypoints = frame_keypoints
+                            
+                    #     except Exception as e:
+                    #         # Fallback: use YOLO if available, otherwise use pitch model
+                    #         if valid_keypoints_yolo_count > 3:
+                    #             frame_keypoints = frame_keypoints_yolo
+                    # elif valid_keypoints_yolo_count > 3:
+                    #     # Only YOLO has valid keypoints
+                    #     frame_keypoints = frame_keypoints_yolo
+                    # else:
+                    #     if last_valid_keypoints is not None:
+                    #         frame_keypoints = last_valid_keypoints
+
+                    # time2 = time.time()
+                    # print(f"Keypoint evaluation time: {time2 - time1}")
+                    
+                    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)
+
+        results_yolo: 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_yolo.get(
+                        frame_number,
+                        [(0, 0) for _ in range(n_keypoints)],
+                    ),
+            )
+            results_yolo.append(result)
+
+        start = time.time()
+        if len(batch_images) > 0:
+            h, w = batch_images[0].shape[:2]
+            results = run_keypoints_post_processing_v2(
+                results, w, h,
+                frames=batch_images,
+                template_keypoints=self.template_keypoints,
+                floor_markings_template=self.template_image,
+                offset=offset
+            )
+            results_yolo = run_keypoints_post_processing_v2(
+                results_yolo, w, h,
+                frames=batch_images,
+                template_keypoints=self.template_keypoints,
+                floor_markings_template=self.template_image,
+                offset=offset
+            )
+        end = time.time()
+        print(f"Keypoint post processing time: {end - start}")
+
+        final_keypoints: Dict[int, List[Tuple[int, int]]] = {}
+
+        for frame_number_in_batch, (result, result_yolo) in enumerate(zip(results, results_yolo)):
+            frame_keypoints = result.keypoints
+            try:
+                if self.last_valid_keypoints is None:
+                    self.last_valid_keypoints = final_keypoints.get(offset + frame_number_in_batch - 1, self.last_valid_keypoints)
+                # Evaluate both keypoint sets in batch (much faster!)
+                scores = evaluate_keypoints_batch_for_frame(
+                    template_keypoints=self.template_keypoints,
+                    frame_keypoints_list=[result.keypoints, result_yolo.keypoints, self.last_valid_keypoints],
+                    frame=batch_images[frame_number_in_batch],
+                    floor_markings_template=self.template_image,
+                    device="cuda"
+                )
+                score = scores[0]
+                score_yolo = scores[1]
+                self.last_score = scores[2]
+                
+                if self.last_score > score and self.last_score > score_yolo:
+                    frame_keypoints = self.last_valid_keypoints
+                elif score_yolo > score:
+                    frame_keypoints = result_yolo.keypoints
+                    self.last_score = score_yolo
+                else:
+                    self.last_score = score
+
+                
+            except Exception as e:
+                # Fallback: use YOLO if available, otherwise use pitch model
+                print('Error: ', e)
+            
+            self.last_valid_keypoints = frame_keypoints
+
+            final_keypoints[offset + frame_number_in_batch] = frame_keypoints
+        
+
+        final_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=final_keypoints.get(
+                        frame_number,
+                        [(0, 0) for _ in range(n_keypoints)],
+                    ),
+            )
+            final_results.append(result)
+
+            
+        gc.collect()
+        if torch.cuda.is_available():
+            torch.cuda.empty_cache()
+            torch.cuda.synchronize()
+
+        return final_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
+
+    def predict_keypoints(
+        self, 
+        images: List[ndarray], 
+        n_keypoints: int = 32,
+        batch_size: Optional[int] = None,
+        conf_threshold: float = 0.5,
+        corner_conf_threshold: float = 0.3,
+        verbose: bool = False
+    ) -> Dict[int, List[Tuple[int, int]]]:
+        """
+        Standalone function for keypoint detection on a list of images.
+        Optimized for maximum prediction speed.
+        
+        Args:
+            images: List of images (numpy arrays) to process
+            n_keypoints: Number of keypoints expected per frame (default: 32)
+            batch_size: Batch size for YOLO prediction (None = auto, uses all images)
+            conf_threshold: Confidence threshold for regular keypoints (default: 0.5)
+            corner_conf_threshold: Confidence threshold for corner keypoints (default: 0.3)
+            verbose: Whether to print progress information
+            
+        Returns:
+            Dictionary mapping frame index to list of keypoint coordinates (x, y)
+            Frame indices start from 0
+        """
+        if not images:
+            return {}
+        
+        keypoints: Dict[int, List[Tuple[int, int]]] = {}
+        
+        # Use provided batch_size or process all at once for maximum speed
+        if batch_size is None:
+            batch_size = len(images)
+        
+        # Process in batches for optimal GPU utilization
+        for batch_start in range(0, len(images), batch_size):
+            batch_end = min(batch_start + batch_size, len(images))
+            batch_images = images[batch_start:batch_end]
+            
+            if verbose:
+                print(f"Processing keypoints batch {batch_start}-{batch_end-1} ({len(batch_images)} images)")
+            
+            # YOLO keypoint prediction (optimized batch processing)
+            keypoints_model_results = self.keypoints_model_yolo.predict(
+                batch_images, 
+                verbose=False,
+                save=False,
+                conf=0.1,  # Lower conf for detection, we filter later
+            )
+            
+            if keypoints_model_results is None:
+                # Fill with empty keypoints for this batch
+                for frame_idx in range(batch_start, batch_end):
+                    keypoints[frame_idx] = [(0, 0)] * n_keypoints
+                continue
+            
+            # Process each frame in the batch
+            for batch_idx, detection in enumerate(keypoints_model_results):
+                frame_idx = batch_start + batch_idx
+                
+                if not hasattr(detection, "keypoints") or detection.keypoints is None:
+                    keypoints[frame_idx] = [(0, 0)] * n_keypoints
+                    continue
+                
+                # Extract keypoints with confidence
+                frame_keypoints_with_conf: List[Tuple[int, int, float]] = []
+                try:
+                    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))
+                except (AttributeError, IndexError, TypeError):
+                    keypoints[frame_idx] = [(0, 0)] * n_keypoints
+                    continue
+                
+                # 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 < corner_conf_threshold:
+                            filtered_keypoints.append((0, 0))
+                        else:
+                            filtered_keypoints.append((int(x), int(y)))
+                    else:
+                        # Regular keypoints
+                        if confidence < conf_threshold:
+                            filtered_keypoints.append((0, 0))
+                        else:
+                            filtered_keypoints.append((int(x), int(y)))
+                
+                keypoints[frame_idx] = filtered_keypoints
+        
+        return keypoints
+
+    def predict_objects(
+        self,
+        images: List[ndarray],
+        batch_size: Optional[int] = 16,
+        conf_threshold: float = 0.5,
+        iou_threshold: float = 0.45,
+        classes: Optional[List[int]] = None,
+        verbose: bool = False,
+    ) -> Dict[int, List[BoundingBox]]:
+        """
+        Standalone high-throughput object detection function.
+        Runs the YOLO detector directly on raw images while skipping
+        any team-classification or keypoint stages for maximum FPS.
+
+        Args:
+            images: List of frames (BGR numpy arrays).
+            batch_size: Number of frames per inference pass. Use None to process
+                all frames at once (fastest but highest memory usage).
+            conf_threshold: Detection confidence threshold.
+            iou_threshold: IoU threshold for NMS within YOLO.
+            classes: Optional list of class IDs to keep (None = all classes).
+            verbose: Whether to print per-batch progress from YOLO.
+
+        Returns:
+            Dict mapping frame index -> list of BoundingBox predictions.
+        """
+        if not images:
+            return {}
+
+        detections: Dict[int, List[BoundingBox]] = {}
+        effective_batch = len(images) if batch_size is None else max(1, batch_size)
+
+        for batch_start in range(0, len(images), effective_batch):
+            batch_end = min(batch_start + effective_batch, len(images))
+            batch_images = images[batch_start:batch_end]
+
+            start = time.time()
+            yolo_results = self.bbox_model(
+                batch_images,
+                conf=conf_threshold,
+                iou=iou_threshold,
+                classes=classes,
+                verbose=verbose,
+                save=False,
+            )
+            end = time.time()
+            print(f"YOLO time: {end - start}")
+
+            for local_idx, result in enumerate(yolo_results):
+                frame_idx = batch_start + local_idx
+                frame_boxes: List[BoundingBox] = []
+
+                if not hasattr(result, "boxes") or result.boxes is None:
+                    detections[frame_idx] = frame_boxes
+                    continue
+
+                boxes_tensor = result.boxes.data
+                if boxes_tensor is None:
+                    detections[frame_idx] = frame_boxes
+                    continue
+
+                for box in boxes_tensor:
+                    try:
+                        x1, y1, x2, y2, conf, cls_id = box.tolist()
+                        frame_boxes.append(
+                            BoundingBox(
+                                x1=int(x1),
+                                y1=int(y1),
+                                x2=int(x2),
+                                y2=int(y2),
+                                cls_id=int(cls_id),
+                                conf=float(conf),
+                            )
+                        )
+                    except (ValueError, TypeError):
+                        continue
+
+                detections[frame_idx] = frame_boxes
+
+        return detections
+    

miner3.py

@@ -0,0 +1,952 @@
+from pathlib import Path
+from typing import List, Tuple, Dict, Optional
+import sys
+import os
+import psutil
+
+from numpy import ndarray
+from pydantic import BaseModel
+from multiprocessing import cpu_count
+
+sys.path.append(os.path.dirname(os.path.abspath(__file__)))
+from keypoint_helper_v2_optimized import run_keypoints_post_processing
+
+from ultralytics import YOLO
+from team_cluster import TeamClassifier
+from utils import (
+    BoundingBox, 
+    Constants,
+)
+
+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
+from keypoint_evaluation import (
+    evaluate_keypoints_for_frame,
+    evaluate_keypoints_for_frame_gpu, 
+    load_template_from_file, 
+    evaluate_keypoints_for_frame_opencv_cuda,
+    evaluate_keypoints_batch_for_frame,
+)
+
+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 + 0.3
+    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 = 1000  # 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")
+            
+            self.last_score = 0
+            self.last_valid_keypoints = None
+            # 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.3
+            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__}"
+                f"CPU Count: {cpu_count()}\n"
+                f"CPU Speed: {psutil.cpu_freq().current/1000:.2f} GHz"
+            )
+        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.
+        Optimized with vectorized calculations when possible.
+        """
+        if len(predicted_frame_data) == 0:
+            return (None, 0.0)
+        
+        # Vectorized IoU calculation for better performance
+        target_array = np.array(target_box, dtype=np.float32)
+        bboxes_array = np.array([bbox for bbox, _ in predicted_frame_data.values()], dtype=np.float32)
+        team_ids = [team_cls_id for _, team_cls_id in predicted_frame_data.values()]
+        
+        # Calculate IoU for all boxes at once using vectorization
+        # Extract coordinates
+        t_x1, t_y1, t_x2, t_y2 = target_array
+        b_x1 = bboxes_array[:, 0]
+        b_y1 = bboxes_array[:, 1]
+        b_x2 = bboxes_array[:, 2]
+        b_y2 = bboxes_array[:, 3]
+        
+        # Calculate intersection
+        x_left = np.maximum(t_x1, b_x1)
+        y_top = np.maximum(t_y1, b_y1)
+        x_right = np.minimum(t_x2, b_x2)
+        y_bottom = np.minimum(t_y2, b_y2)
+        
+        # Intersection area
+        intersection = np.maximum(0, x_right - x_left) * np.maximum(0, y_bottom - y_top)
+        
+        # Union area
+        target_area = (t_x2 - t_x1) * (t_y2 - t_y1)
+        bbox_areas = (b_x2 - b_x1) * (b_y2 - b_y1)
+        union = target_area + bbox_areas - intersection
+        
+        # IoU (avoid division by zero)
+        ious = np.where(union > 0, intersection / union, 0.0)
+        
+        # Find best match above threshold
+        valid_mask = ious >= iou_threshold
+        if np.any(valid_mask):
+            best_idx = np.argmax(ious)
+            if ious[best_idx] >= iou_threshold:
+                return (team_ids[best_idx], float(ious[best_idx]))
+        
+        return (None, 0.0)
+
+    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):
+        self.team_classifier_fitted = False
+        start = time.time()
+        # Collect player crops from first batch for fitting
+        fit_sample_size = 1000
+        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
+            # Collect player boxes for team classification fitting (first batch only)
+            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:
+                        continue
+                    mapped_cls_id = str(int(cls_id))
+                    # Only collect player crops (cls_id = 2)
+                    if mapped_cls_id == '2':
+                        crop = frame_image[int(y1):int(y2), int(x1):int(x2)]
+                        if crop.size > 0:
+                            player_crops_for_fit.append(crop)
+
+            # Fit team classifier after collecting samples
+            if self.team_classifier and not self.team_classifier_fitted and len(player_crops_for_fit) >= fit_sample_size:
+                print(f"Fitting TeamClassifier 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) >= 16:
+            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
+        end = time.time()
+        print(f"Fitting Kmeans time: {end - start}")
+
+        # Second pass: predict teams with configurable frame skipping optimization
+        start = time.time()
+
+        # Get configuration for frame skipping
+        prediction_interval = 1  # Default: predict every 2 frames
+        iou_threshold = 0.3
+
+        print(f"Team classification - prediction_interval: {prediction_interval}, iou_threshold: {iou_threshold}")
+
+        # Storage for predicted frame results: {frame_id: {box_idx: (bbox, team_id)}}
+        predicted_frame_data = {}
+
+        # Step 1: Predict for frames at prediction_interval only
+        frames_to_predict = []
+        for frame_id in range(len(detection_results)):
+            if frame_id % prediction_interval == 0:
+                frames_to_predict.append(frame_id)
+
+        print(f"Predicting teams for {len(frames_to_predict)}/{len(detection_results)} frames "
+                    f"(saving {100 - (len(frames_to_predict) * 100 // len(detection_results))}% compute)")
+
+        for frame_id in frames_to_predict:
+            detection_box = detection_results[frame_id].boxes.data
+            frame_image = decoded_images[frame_id]
+
+            # Collect player crops for this frame
+            frame_player_crops = []
+            frame_player_indices = []
+            frame_player_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
+                mapped_cls_id = str(int(cls_id))
+
+                # Collect player crops for prediction
+                if self.team_classifier and self.team_classifier_fitted and mapped_cls_id == '2':
+                    crop = frame_image[int(y1):int(y2), int(x1):int(x2)]
+                    if crop.size > 0:
+                        frame_player_crops.append(crop)
+                        frame_player_indices.append(idx)
+                        frame_player_boxes.append((x1, y1, x2, y2))
+
+            # Predict teams for all players in this frame
+            if len(frame_player_crops) > 0:
+                team_ids = self.team_classifier.predict(frame_player_crops)
+                predicted_frame_data[frame_id] = {}
+                for idx, bbox, team_id in zip(frame_player_indices, frame_player_boxes, team_ids):
+                    # Map team_id (0,1) to cls_id (6,7)
+                    team_cls_id = str(6 + int(team_id))
+                    predicted_frame_data[frame_id][idx] = (bbox, team_cls_id)
+
+        # Step 2: Process all frames (interpolate skipped frames)
+        fallback_count = 0
+        interpolated_count = 0
+        bboxes: dict[int, list[BoundingBox]] = {}
+        for frame_id in range(len(detection_results)):
+            detection_box = detection_results[frame_id].boxes.data
+            frame_image = decoded_images[frame_id]
+            boxes = []
+
+            team_predictions = {}
+
+            if frame_id % prediction_interval == 0:
+                # Predicted frame: use pre-computed predictions
+                if frame_id in predicted_frame_data:
+                    for idx, (bbox, team_cls_id) in predicted_frame_data[frame_id].items():
+                        team_predictions[idx] = team_cls_id
+            else:
+                # Skipped frame: interpolate from neighboring predicted frames
+                # Find nearest predicted frames
+                prev_predicted_frame = (frame_id // prediction_interval) * prediction_interval
+                next_predicted_frame = prev_predicted_frame + prediction_interval
+
+                # Collect current frame player boxes and fallback crops for batch prediction
+                fallback_crops = []
+                fallback_indices = []
+                
+                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
+                    mapped_cls_id = str(int(cls_id))
+
+                    if self.team_classifier and self.team_classifier_fitted and mapped_cls_id == '2':
+                        target_box = (x1, y1, x2, y2)
+
+                        # Try to match with previous predicted frame
+                        best_team_id = None
+                        best_iou = 0.0
+
+                        if prev_predicted_frame in predicted_frame_data:
+                            team_id, iou = self._find_best_match(
+                                target_box,
+                                predicted_frame_data[prev_predicted_frame],
+                                iou_threshold
+                            )
+                            if team_id is not None:
+                                best_team_id = team_id
+                                best_iou = iou
+
+                        # Try to match with next predicted frame if available and no good match yet
+                        if best_team_id is None and next_predicted_frame < len(detection_results):
+                            if next_predicted_frame in predicted_frame_data:
+                                team_id, iou = self._find_best_match(
+                                    target_box,
+                                    predicted_frame_data[next_predicted_frame],
+                                    iou_threshold
+                                )
+                                if team_id is not None and iou > best_iou:
+                                    best_team_id = team_id
+                                    best_iou = iou
+
+                        # Track interpolation success
+                        if best_team_id is not None:
+                            interpolated_count += 1
+                            team_predictions[idx] = best_team_id
+                        else:
+                            # Collect fallback crops for batch prediction
+                            crop = frame_image[int(y1):int(y2), int(x1):int(x2)]
+                            if crop.size > 0:
+                                fallback_crops.append(crop)
+                                fallback_indices.append(idx)
+                
+                # Batch predict all fallback crops at once (much faster than individual calls)
+                if len(fallback_crops) > 0:
+                    fallback_team_ids = self.team_classifier.predict(fallback_crops)
+                    for idx, team_id in zip(fallback_indices, fallback_team_ids):
+                        team_predictions[idx] = str(6 + int(team_id))
+                        fallback_count += 1
+
+            # Pre-filter staff boxes once per frame (optimization)
+            staff_boxes = []
+            for idy, boxy in enumerate(detection_box):
+                s_x1, s_y1, s_x2, s_y2, s_conf, s_cls_id = boxy.tolist()
+                if s_cls_id == 4:
+                    staff_boxes.append((s_x1, s_y1, s_x2, s_y2))
+            
+            # Pre-compute player boxes for vectorized staff overlap check (if many players)
+            player_boxes_for_staff_check = []
+            player_indices_for_staff_check = []
+            if len(staff_boxes) > 0:
+                for idx, box in enumerate(detection_box):
+                    x1, y1, x2, y2, conf, cls_id = box.tolist()
+                    if cls_id == 2 and conf >= 0.6:
+                        player_boxes_for_staff_check.append((x1, y1, x2, y2))
+                        player_indices_for_staff_check.append(idx)
+            
+            # Vectorized staff overlap check if we have players and staff
+            staff_overlap_mask = set()
+            if len(staff_boxes) > 0 and len(player_boxes_for_staff_check) > 0:
+                # Use vectorized IoU calculation for all player-staff pairs
+                staff_array = np.array(staff_boxes, dtype=np.float32)
+                player_array = np.array(player_boxes_for_staff_check, dtype=np.float32)
+                
+                # Broadcast to compute all pairwise IoUs
+                for player_idx, player_box in enumerate(player_boxes_for_staff_check):
+                    p_x1, p_y1, p_x2, p_y2 = player_box
+                    s_x1 = staff_array[:, 0]
+                    s_y1 = staff_array[:, 1]
+                    s_x2 = staff_array[:, 2]
+                    s_y2 = staff_array[:, 3]
+                    
+                    # Vectorized IoU calculation
+                    x_left = np.maximum(p_x1, s_x1)
+                    y_top = np.maximum(p_y1, s_y1)
+                    x_right = np.minimum(p_x2, s_x2)
+                    y_bottom = np.minimum(p_y2, s_y2)
+                    
+                    intersection = np.maximum(0, x_right - x_left) * np.maximum(0, y_bottom - y_top)
+                    player_area = (p_x2 - p_x1) * (p_y2 - p_y1)
+                    staff_areas = (s_x2 - s_x1) * (s_y2 - s_y1)
+                    union = player_area + staff_areas - intersection
+                    
+                    ious = np.where(union > 0, intersection / union, 0.0)
+                    if np.any(ious >= 0.8):
+                        staff_overlap_mask.add(player_indices_for_staff_check[player_idx])
+            
+            # Parse boxes with team classification
+            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 box (using pre-computed mask)
+                if idx in staff_overlap_mask:
+                    continue
+
+                mapped_cls_id = str(int(cls_id))
+
+                # Override cls_id for players with team prediction
+                if idx in team_predictions:
+                    mapped_cls_id = team_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
+        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
+        start = time.time()
+
+
+        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]
+
+                    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)
+
+        start = time.time()
+        if len(batch_images) > 0:
+            h, w = batch_images[0].shape[:2]
+            results = run_keypoints_post_processing(
+                results, w, h,
+                frames=batch_images,
+                offset=offset,
+                template_keypoints=self.template_keypoints,
+                template_image=self.template_image,
+            )
+        end = time.time()
+        print(f"Keypoint post processing time: {end - start}")
+
+        final_keypoints: Dict[int, List[Tuple[int, int]]] = {}
+
+        for frame_number_in_batch, result in enumerate(results):
+            frame_keypoints = result.keypoints
+            try:
+                if self.last_valid_keypoints is None:
+                    self.last_valid_keypoints = final_keypoints.get(offset + frame_number_in_batch - 1, self.last_valid_keypoints)
+                # Evaluate both keypoint sets in batch (much faster!)
+                scores = evaluate_keypoints_batch_for_frame(
+                    template_keypoints=self.template_keypoints,
+                    frame_keypoints_list=[result.keypoints, self.last_valid_keypoints],
+                    frame=batch_images[frame_number_in_batch],
+                    floor_markings_template=self.template_image,
+                    device="cuda"
+                )
+                score = scores[0]
+                self.last_score = scores[1]
+                
+                if self.last_score > score:
+                    frame_keypoints = self.last_valid_keypoints
+                else:
+                    self.last_score = score
+
+                
+            except Exception as e:
+                # Fallback: use YOLO if available, otherwise use pitch model
+                print('Error: ', e)
+            
+            self.last_valid_keypoints = frame_keypoints
+
+            final_keypoints[offset + frame_number_in_batch] = frame_keypoints
+        
+
+        final_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=final_keypoints.get(
+                        frame_number,
+                        [(0, 0) for _ in range(n_keypoints)],
+                    ),
+            )
+            final_results.append(result)
+
+            
+        gc.collect()
+        if torch.cuda.is_available():
+            torch.cuda.empty_cache()
+            torch.cuda.synchronize()
+
+        return final_results
+        # 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
+
+    def predict_keypoints(
+        self, 
+        images: List[ndarray], 
+        n_keypoints: int = 32,
+        batch_size: Optional[int] = None,
+        conf_threshold: float = 0.5,
+        corner_conf_threshold: float = 0.3,
+        verbose: bool = False
+    ) -> Dict[int, List[Tuple[int, int]]]:
+        """
+        Standalone function for keypoint detection on a list of images.
+        Optimized for maximum prediction speed.
+        
+        Args:
+            images: List of images (numpy arrays) to process
+            n_keypoints: Number of keypoints expected per frame (default: 32)
+            batch_size: Batch size for YOLO prediction (None = auto, uses all images)
+            conf_threshold: Confidence threshold for regular keypoints (default: 0.5)
+            corner_conf_threshold: Confidence threshold for corner keypoints (default: 0.3)
+            verbose: Whether to print progress information
+            
+        Returns:
+            Dictionary mapping frame index to list of keypoint coordinates (x, y)
+            Frame indices start from 0
+        """
+        if not images:
+            return {}
+        
+        keypoints: Dict[int, List[Tuple[int, int]]] = {}
+        
+        # Use provided batch_size or process all at once for maximum speed
+        if batch_size is None:
+            batch_size = len(images)
+        
+        # Process in batches for optimal GPU utilization
+        for batch_start in range(0, len(images), batch_size):
+            batch_end = min(batch_start + batch_size, len(images))
+            batch_images = images[batch_start:batch_end]
+            
+            if verbose:
+                print(f"Processing keypoints batch {batch_start}-{batch_end-1} ({len(batch_images)} images)")
+            
+            # YOLO keypoint prediction (optimized batch processing)
+            keypoints_model_results = self.keypoints_model_yolo.predict(
+                batch_images, 
+                verbose=False,
+                save=False,
+                conf=0.1,  # Lower conf for detection, we filter later
+            )
+            
+            if keypoints_model_results is None:
+                # Fill with empty keypoints for this batch
+                for frame_idx in range(batch_start, batch_end):
+                    keypoints[frame_idx] = [(0, 0)] * n_keypoints
+                continue
+            
+            # Process each frame in the batch
+            for batch_idx, detection in enumerate(keypoints_model_results):
+                frame_idx = batch_start + batch_idx
+                
+                if not hasattr(detection, "keypoints") or detection.keypoints is None:
+                    keypoints[frame_idx] = [(0, 0)] * n_keypoints
+                    continue
+                
+                # Extract keypoints with confidence
+                frame_keypoints_with_conf: List[Tuple[int, int, float]] = []
+                try:
+                    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))
+                except (AttributeError, IndexError, TypeError):
+                    keypoints[frame_idx] = [(0, 0)] * n_keypoints
+                    continue
+                
+                # 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 < corner_conf_threshold:
+                            filtered_keypoints.append((0, 0))
+                        else:
+                            filtered_keypoints.append((int(x), int(y)))
+                    else:
+                        # Regular keypoints
+                        if confidence < conf_threshold:
+                            filtered_keypoints.append((0, 0))
+                        else:
+                            filtered_keypoints.append((int(x), int(y)))
+                
+                keypoints[frame_idx] = filtered_keypoints
+        
+        return keypoints
+
+    def predict_objects(
+        self,
+        images: List[ndarray],
+        batch_size: Optional[int] = 16,
+        conf_threshold: float = 0.5,
+        iou_threshold: float = 0.45,
+        classes: Optional[List[int]] = None,
+        verbose: bool = False,
+    ) -> Dict[int, List[BoundingBox]]:
+        """
+        Standalone high-throughput object detection function.
+        Runs the YOLO detector directly on raw images while skipping
+        any team-classification or keypoint stages for maximum FPS.
+
+        Args:
+            images: List of frames (BGR numpy arrays).
+            batch_size: Number of frames per inference pass. Use None to process
+                all frames at once (fastest but highest memory usage).
+            conf_threshold: Detection confidence threshold.
+            iou_threshold: IoU threshold for NMS within YOLO.
+            classes: Optional list of class IDs to keep (None = all classes).
+            verbose: Whether to print per-batch progress from YOLO.
+
+        Returns:
+            Dict mapping frame index -> list of BoundingBox predictions.
+        """
+        if not images:
+            return {}
+
+        detections: Dict[int, List[BoundingBox]] = {}
+        effective_batch = len(images) if batch_size is None else max(1, batch_size)
+
+        for batch_start in range(0, len(images), effective_batch):
+            batch_end = min(batch_start + effective_batch, len(images))
+            batch_images = images[batch_start:batch_end]
+
+            start = time.time()
+            yolo_results = self.bbox_model(
+                batch_images,
+                conf=conf_threshold,
+                iou=iou_threshold,
+                classes=classes,
+                verbose=verbose,
+                save=False,
+            )
+            end = time.time()
+            print(f"YOLO time: {end - start}")
+
+            for local_idx, result in enumerate(yolo_results):
+                frame_idx = batch_start + local_idx
+                frame_boxes: List[BoundingBox] = []
+
+                if not hasattr(result, "boxes") or result.boxes is None:
+                    detections[frame_idx] = frame_boxes
+                    continue
+
+                boxes_tensor = result.boxes.data
+                if boxes_tensor is None:
+                    detections[frame_idx] = frame_boxes
+                    continue
+
+                for box in boxes_tensor:
+                    try:
+                        x1, y1, x2, y2, conf, cls_id = box.tolist()
+                        frame_boxes.append(
+                            BoundingBox(
+                                x1=int(x1),
+                                y1=int(y1),
+                                x2=int(x2),
+                                y2=int(y2),
+                                cls_id=int(cls_id),
+                                conf=float(conf),
+                            )
+                        )
+                    except (ValueError, TypeError):
+                        continue
+
+                detections[frame_idx] = frame_boxes
+
+        return detections
+    

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