Upload folder using huggingface_hub

.gitattributes

@@ -33,3 +33,9 @@ saved_model/**/* 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
+template_caches_0 filter=lfs diff=lfs merge=lfs -text
+template_caches_1 filter=lfs diff=lfs merge=lfs -text
+keypoint filter=lfs diff=lfs merge=lfs -text
+inference.cpython-312-x86_64-linux-gnu.so filter=lfs diff=lfs merge=lfs -text
+keypoint_helper.cpython-312-x86_64-linux-gnu.so filter=lfs diff=lfs merge=lfs -text
+osnet_model.pth.tar-100 filter=lfs diff=lfs merge=lfs -text

chute_config.yml

@@ -0,0 +1,28 @@
+Image:
+  from_base: parachutes/python:3.12
+  run_command:
+    - pip install --upgrade setuptools wheel
+    - pip install --index-url https://download.pytorch.org/whl/cu128 torch torchvision
+    - pip install "ultralytics==8.3.222" "opencv-python-headless" "numpy" "pydantic"
+    - pip install scikit-learn cryptography
+    - pip install onnxruntime-gpu numba scipy joblib psutil lz4
+  set_workdir: /app
+  readme: "Image for chutes"
+
+NodeSelector:
+  gpu_count: 1
+  min_vram_gb_per_gpu: 24
+  min_memory_gb: 32
+  min_cpu_count: 16
+  exclude:
+    - "5090"
+    - b200
+    - h200
+    - mi300x
+
+Chute:
+  timeout_seconds: 900
+  concurrency: 4
+  max_instances: 5
+  scaling_threshold: 0.5
+  shutdown_after_seconds: 96000

football_object_detection.onnx

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

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
+

inference.cpython-312-x86_64-linux-gnu.so

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

keypoint

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

keypoint_helper.cpython-312-x86_64-linux-gnu.so

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

keypoint_utils.py

@@ -0,0 +1,49 @@
+from numba import njit, prange
+
+@njit(fastmath=True, cache=True)
+def score_mask_numba_fast(pred, expected, ground, pixels_on_lines):
+    h, w = pred.shape
+    pp = 0
+    po = 0
+    
+    for y in prange(h):
+        for x in range(w):
+            p_val = pred[y, x]
+            g_val = ground[y, x]
+            e_val = expected[y, x]
+            p = (p_val != 0) & (g_val != 0)
+            e = e_val != 0
+            pp += p
+            po += p & e
+    if pp == 0:
+        return 0.0
+    pr = pp - po
+    total = pixels_on_lines + pp - po
+    if total == 0 or pr * 10 > total * 9:
+        return 0.0
+    return po / (pixels_on_lines + 1e-8)
+
+@njit(parallel=True, fastmath=True, cache=True, boundscheck=False)
+def spmm_csc_optimized(data, indices, indptr, frames_T, out):
+    # frames_T is (P, F) -> C-contiguous (Row Major)
+    # out is (F, T)      -> F-contiguous (Column Major)
+    
+    F = frames_T.shape[1]
+    T = indptr.shape[0] - 1
+
+    # schedule='dynamic' handles uneven workloads (sparse matrices are rarely uniform)
+    for j in prange(T):
+        start = indptr[j]
+        end = indptr[j + 1]
+
+        # Inner loop: Iterate over non-zero pixels for this template
+        for k in range(start, end):
+            p = indices[k]
+            val_w = float(data[k]) # Cast uint8 to float once per pixel
+            
+            # VECTORIZED LOOP:
+            # We are reading a contiguous row from frames_T (frames_T[p, :])
+            # and adding it to a contiguous column in out (out[:, j]).
+            # This allows the compiler to use AVX/SIMD instructions.
+            for i in range(F):
+                out[i, j] += frames_T[p, i] * val_w

miner.py

@@ -0,0 +1,82 @@
+import os
+import sys
+from pathlib import Path
+from typing import List, Tuple, Dict
+import sys
+import os
+
+from numpy import ndarray
+from pydantic import BaseModel
+sys.path.append(os.path.dirname(os.path.abspath(__file__)))
+
+# from inference import predict_batch, load_model
+import importlib.util
+from pathlib import Path
+
+def manual_import(name, filename):
+    """
+    Manually loads a module (.so, .pyc, or .py) from a specific file path, 
+    bypassing sys.meta_path import hooks.
+    """
+    # Locate the file relative to the current miner.py
+    curr_dir = Path(__file__).parent
+    file_path = curr_dir / filename
+    
+    if not file_path.exists():
+        raise FileNotFoundError(f"Could not find {file_path}")
+
+    # Load the spec directly from the file path
+    spec = importlib.util.spec_from_file_location(name, file_path)
+    if spec is None:
+        raise ImportError(f"Could not load spec for {name} from {file_path}")
+        
+    # Create the module and register it in sys.modules
+    module = importlib.util.module_from_spec(spec)
+    sys.modules[name] = module
+    
+    # Execute the module
+    spec.loader.exec_module(module)
+    return module
+
+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:
+    def __init__(self, path_hf_repo: Path) -> None:
+        print("model laoding")
+        self.health = 'Okay'
+        self.inference = None
+        self.path_hf_repo = path_hf_repo
+        self.is_start = False
+
+    def __repr__(self) -> str:
+        if self.inference is not None:
+            self.health = self.inference.gethealth()
+        return self.health
+
+    def predict_batch(self, batch_images: List[ndarray], offset: int, n_keypoints: int) -> List[TVFrameResult]:
+        if self.is_start == False:
+            self.is_start = True
+            return None
+        if self.inference is None:
+            self.inference = manual_import("inference", "inference.cpython-312-x86_64-linux-gnu.so")
+            self.inference.load_model(self.path_hf_repo)
+            
+        results = self.inference.predict_batch(
+            batch_images,
+            offset,
+            n_keypoints,
+        )
+        return results

osnet_model.pth.tar-100

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

template_caches_0

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

template_caches_1

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