Upload folder using huggingface_hub

chute_config.yml

@@ -0,0 +1,18 @@
+Image:
+  from_base: parachutes/python:3.12
+  run_command:
+    - pip install --upgrade setuptools wheel
+    - pip install 'numpy>=1.23' 'onnxruntime-gpu[cuda,cudnn]>=1.16' 'opencv-python>=4.7' 'pillow>=9.5' 'huggingface_hub>=0.19.4' 'pydantic>=2.0' 'pyyaml>=6.0' 'aiohttp>=3.9' 'torch<2.6'
+
+NodeSelector:
+  gpu_count: 1
+  min_vram_gb_per_gpu: 24
+  min_memory_gb: 32
+  min_cpu_count: 32
+
+Chute:
+  timeout_seconds: 900
+  concurrency: 4
+  max_instances: 5
+  scaling_threshold: 0.5
+  shutdown_after_seconds: 288000

miner.py

@@ -0,0 +1,598 @@
+from pathlib import Path
+import math
+
+import cv2
+import numpy as np
+import onnxruntime as ort
+from numpy import ndarray
+from pydantic import BaseModel
+
+
+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:
+        model_path = path_hf_repo / "person-detection.onnx"
+        self.class_names = ["person"]
+        print("ORT version:", ort.__version__)
+
+        try:
+            ort.preload_dlls()
+            print("✅ onnxruntime.preload_dlls() success")
+        except Exception as e:
+            print(f"⚠️ preload_dlls failed: {e}")
+
+        print("ORT available providers BEFORE session:", ort.get_available_providers())
+
+        sess_options = ort.SessionOptions()
+        sess_options.graph_optimization_level = ort.GraphOptimizationLevel.ORT_ENABLE_ALL
+
+        try:
+            self.session = ort.InferenceSession(
+                str(model_path),
+                sess_options=sess_options,
+                providers=["CUDAExecutionProvider", "CPUExecutionProvider"],
+            )
+            print("✅ Created ORT session with preferred CUDA provider list")
+        except Exception as e:
+            print(f"⚠️ CUDA session creation failed, falling back to CPU: {e}")
+            self.session = ort.InferenceSession(
+                str(model_path),
+                sess_options=sess_options,
+                providers=["CPUExecutionProvider"],
+            )
+
+        print("ORT session providers:", self.session.get_providers())
+
+        for inp in self.session.get_inputs():
+            print("INPUT:", inp.name, inp.shape, inp.type)
+
+        for out in self.session.get_outputs():
+            print("OUTPUT:", out.name, out.shape, out.type)
+
+        self.input_name = self.session.get_inputs()[0].name
+        self.output_names = [output.name for output in self.session.get_outputs()]
+        self.input_shape = self.session.get_inputs()[0].shape
+
+        self.input_height = self._safe_dim(self.input_shape[2], default=1280)
+        self.input_width = self._safe_dim(self.input_shape[3], default=1280)
+
+        # ---------- Scoring-oriented thresholds ----------
+        # Low threshold for candidate generation
+        self.conf_thres = 0.08
+
+        # High-confidence boxes can survive without TTA confirmation
+        self.conf_high = 0.18
+
+        # NMS threshold
+        self.iou_thres = 0.45
+
+        # TTA confirmation IoU
+        self.tta_match_iou = 0.55
+
+        self.max_det = 300
+        self.use_tta = True
+
+        # Box sanity filters
+        self.min_box_area = 16 * 16
+        self.min_w = 6
+        self.min_h = 6
+        self.max_aspect_ratio = 6.0
+        self.max_box_area_ratio = 0.95
+
+        print(f"✅ ONNX model loaded from: {model_path}")
+        print(f"✅ ONNX providers: {self.session.get_providers()}")
+        print(f"✅ ONNX input: name={self.input_name}, shape={self.input_shape}")
+
+    def __repr__(self) -> str:
+        return (
+            f"ONNXRuntime(session={type(self.session).__name__}, "
+            f"providers={self.session.get_providers()})"
+        )
+
+    @staticmethod
+    def _safe_dim(value, default: int) -> int:
+        return value if isinstance(value, int) and value > 0 else default
+
+    def _letterbox(
+        self,
+        image: ndarray,
+        new_shape: tuple[int, int],
+        color=(114, 114, 114),
+    ) -> tuple[ndarray, float, tuple[float, float]]:
+        h, w = image.shape[:2]
+        new_w, new_h = new_shape
+
+        ratio = min(new_w / w, new_h / h)
+        resized_w = int(round(w * ratio))
+        resized_h = int(round(h * ratio))
+
+        if (resized_w, resized_h) != (w, h):
+            interp = cv2.INTER_CUBIC if ratio > 1.0 else cv2.INTER_LINEAR
+            image = cv2.resize(image, (resized_w, resized_h), interpolation=interp)
+
+        dw = new_w - resized_w
+        dh = new_h - resized_h
+        dw /= 2.0
+        dh /= 2.0
+
+        left = int(round(dw - 0.1))
+        right = int(round(dw + 0.1))
+        top = int(round(dh - 0.1))
+        bottom = int(round(dh + 0.1))
+
+        padded = cv2.copyMakeBorder(
+            image,
+            top,
+            bottom,
+            left,
+            right,
+            borderType=cv2.BORDER_CONSTANT,
+            value=color,
+        )
+        return padded, ratio, (dw, dh)
+
+    def _preprocess(
+        self, image: ndarray
+    ) -> tuple[np.ndarray, float, tuple[float, float], tuple[int, int]]:
+        orig_h, orig_w = image.shape[:2]
+
+        img, ratio, pad = self._letterbox(
+            image, (self.input_width, self.input_height)
+        )
+        img = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)
+        img = img.astype(np.float32) / 255.0
+        img = np.transpose(img, (2, 0, 1))[None, ...]
+        img = np.ascontiguousarray(img, dtype=np.float32)
+
+        return img, ratio, pad, (orig_w, orig_h)
+
+    @staticmethod
+    def _clip_boxes(boxes: np.ndarray, image_size: tuple[int, int]) -> np.ndarray:
+        w, h = image_size
+        boxes[:, 0] = np.clip(boxes[:, 0], 0, w - 1)
+        boxes[:, 1] = np.clip(boxes[:, 1], 0, h - 1)
+        boxes[:, 2] = np.clip(boxes[:, 2], 0, w - 1)
+        boxes[:, 3] = np.clip(boxes[:, 3], 0, h - 1)
+        return boxes
+
+    @staticmethod
+    def _xywh_to_xyxy(boxes: np.ndarray) -> np.ndarray:
+        out = np.empty_like(boxes)
+        out[:, 0] = boxes[:, 0] - boxes[:, 2] / 2.0
+        out[:, 1] = boxes[:, 1] - boxes[:, 3] / 2.0
+        out[:, 2] = boxes[:, 0] + boxes[:, 2] / 2.0
+        out[:, 3] = boxes[:, 1] + boxes[:, 3] / 2.0
+        return out
+
+    @staticmethod
+    def _hard_nms(
+        boxes: np.ndarray,
+        scores: np.ndarray,
+        iou_thresh: float,
+    ) -> np.ndarray:
+        if len(boxes) == 0:
+            return np.array([], dtype=np.intp)
+
+        boxes = np.asarray(boxes, dtype=np.float32)
+        scores = np.asarray(scores, dtype=np.float32)
+        order = np.argsort(scores)[::-1]
+        keep = []
+
+        while len(order) > 0:
+            i = order[0]
+            keep.append(i)
+            if len(order) == 1:
+                break
+
+            rest = order[1:]
+
+            xx1 = np.maximum(boxes[i, 0], boxes[rest, 0])
+            yy1 = np.maximum(boxes[i, 1], boxes[rest, 1])
+            xx2 = np.minimum(boxes[i, 2], boxes[rest, 2])
+            yy2 = np.minimum(boxes[i, 3], boxes[rest, 3])
+
+            inter = np.maximum(0.0, xx2 - xx1) * np.maximum(0.0, yy2 - yy1)
+
+            area_i = np.maximum(0.0, (boxes[i, 2] - boxes[i, 0])) * np.maximum(0.0, (boxes[i, 3] - boxes[i, 1]))
+            area_r = np.maximum(0.0, (boxes[rest, 2] - boxes[rest, 0])) * np.maximum(0.0, (boxes[rest, 3] - boxes[rest, 1]))
+
+            iou = inter / (area_i + area_r - inter + 1e-7)
+            order = rest[iou <= iou_thresh]
+
+        return np.array(keep, dtype=np.intp)
+
+    @staticmethod
+    def _box_iou_one_to_many(box: np.ndarray, boxes: np.ndarray) -> np.ndarray:
+        xx1 = np.maximum(box[0], boxes[:, 0])
+        yy1 = np.maximum(box[1], boxes[:, 1])
+        xx2 = np.minimum(box[2], boxes[:, 2])
+        yy2 = np.minimum(box[3], boxes[:, 3])
+
+        inter = np.maximum(0.0, xx2 - xx1) * np.maximum(0.0, yy2 - yy1)
+
+        area_a = max(0.0, (box[2] - box[0]) * (box[3] - box[1]))
+        area_b = np.maximum(0.0, boxes[:, 2] - boxes[:, 0]) * np.maximum(0.0, boxes[:, 3] - boxes[:, 1])
+
+        return inter / (area_a + area_b - inter + 1e-7)
+
+    def _filter_sane_boxes(
+        self,
+        boxes: np.ndarray,
+        scores: np.ndarray,
+        cls_ids: np.ndarray,
+        orig_size: tuple[int, int],
+    ) -> tuple[np.ndarray, np.ndarray, np.ndarray]:
+        if len(boxes) == 0:
+            return boxes, scores, cls_ids
+
+        orig_w, orig_h = orig_size
+        image_area = float(orig_w * orig_h)
+
+        keep = []
+        for i, box in enumerate(boxes):
+            x1, y1, x2, y2 = box.tolist()
+            bw = x2 - x1
+            bh = y2 - y1
+
+            if bw <= 0 or bh <= 0:
+                continue
+            if bw < self.min_w or bh < self.min_h:
+                continue
+
+            area = bw * bh
+            if area < self.min_box_area:
+                continue
+            if area > self.max_box_area_ratio * image_area:
+                continue
+
+            ar = max(bw / max(bh, 1e-6), bh / max(bw, 1e-6))
+            if ar > self.max_aspect_ratio:
+                continue
+
+            keep.append(i)
+
+        if not keep:
+            return (
+                np.empty((0, 4), dtype=np.float32),
+                np.empty((0,), dtype=np.float32),
+                np.empty((0,), dtype=np.int32),
+            )
+
+        keep = np.array(keep, dtype=np.intp)
+        return boxes[keep], scores[keep], cls_ids[keep]
+
+    def _decode_final_dets(
+        self,
+        preds: np.ndarray,
+        ratio: float,
+        pad: tuple[float, float],
+        orig_size: tuple[int, int],
+    ) -> list[BoundingBox]:
+        if preds.ndim == 3 and preds.shape[0] == 1:
+            preds = preds[0]
+
+        if preds.ndim != 2 or preds.shape[1] < 6:
+            raise ValueError(f"Unexpected ONNX final-det output shape: {preds.shape}")
+
+        boxes = preds[:, :4].astype(np.float32)
+        scores = preds[:, 4].astype(np.float32)
+        cls_ids = preds[:, 5].astype(np.int32)
+
+        # person only
+        keep = cls_ids == 0
+        boxes = boxes[keep]
+        scores = scores[keep]
+        cls_ids = cls_ids[keep]
+
+        # candidate threshold
+        keep = scores >= self.conf_thres
+        boxes = boxes[keep]
+        scores = scores[keep]
+        cls_ids = cls_ids[keep]
+
+        if len(boxes) == 0:
+            return []
+
+        pad_w, pad_h = pad
+        orig_w, orig_h = orig_size
+
+        boxes[:, [0, 2]] -= pad_w
+        boxes[:, [1, 3]] -= pad_h
+        boxes /= ratio
+        boxes = self._clip_boxes(boxes, (orig_w, orig_h))
+
+        boxes, scores, cls_ids = self._filter_sane_boxes(boxes, scores, cls_ids, orig_size)
+        if len(boxes) == 0:
+            return []
+
+        keep_idx = self._hard_nms(boxes, scores, self.iou_thres)
+        keep_idx = keep_idx[: self.max_det]
+
+        boxes = boxes[keep_idx]
+        scores = scores[keep_idx]
+        cls_ids = cls_ids[keep_idx]
+
+        return [
+            BoundingBox(
+                x1=int(math.floor(box[0])),
+                y1=int(math.floor(box[1])),
+                x2=int(math.ceil(box[2])),
+                y2=int(math.ceil(box[3])),
+                cls_id=int(cls_id),
+                conf=float(conf),
+            )
+            for box, conf, cls_id in zip(boxes, scores, cls_ids)
+            if box[2] > box[0] and box[3] > box[1]
+        ]
+
+    def _decode_raw_yolo(
+        self,
+        preds: np.ndarray,
+        ratio: float,
+        pad: tuple[float, float],
+        orig_size: tuple[int, int],
+    ) -> list[BoundingBox]:
+        if preds.ndim != 3:
+            raise ValueError(f"Unexpected raw ONNX output shape: {preds.shape}")
+        if preds.shape[0] != 1:
+            raise ValueError(f"Unexpected batch dimension in raw output: {preds.shape}")
+
+        preds = preds[0]
+
+        # Normalize to [N, C]
+        if preds.shape[0] <= 16 and preds.shape[1] > preds.shape[0]:
+            preds = preds.T
+
+        if preds.ndim != 2 or preds.shape[1] < 5:
+            raise ValueError(f"Unexpected normalized raw output shape: {preds.shape}")
+
+        boxes_xywh = preds[:, :4].astype(np.float32)
+        tail = preds[:, 4:].astype(np.float32)
+
+        # Supports:
+        # [x,y,w,h,score]                 single-class
+        # [x,y,w,h,obj,cls]               YOLO standard single-class
+        # [x,y,w,h,obj,cls1,cls2,...]     multi-class
+        if tail.shape[1] == 1:
+            scores = tail[:, 0]
+            cls_ids = np.zeros(len(scores), dtype=np.int32)
+        elif tail.shape[1] == 2:
+            obj = tail[:, 0]
+            cls_prob = tail[:, 1]
+            scores = obj * cls_prob
+            cls_ids = np.zeros(len(scores), dtype=np.int32)
+        else:
+            obj = tail[:, 0]
+            class_probs = tail[:, 1:]
+            cls_ids = np.argmax(class_probs, axis=1).astype(np.int32)
+            cls_scores = class_probs[np.arange(len(class_probs)), cls_ids]
+            scores = obj * cls_scores
+
+        keep = cls_ids == 0
+        boxes_xywh = boxes_xywh[keep]
+        scores = scores[keep]
+        cls_ids = cls_ids[keep]
+
+        keep = scores >= self.conf_thres
+        boxes_xywh = boxes_xywh[keep]
+        scores = scores[keep]
+        cls_ids = cls_ids[keep]
+
+        if len(boxes_xywh) == 0:
+            return []
+
+        boxes = self._xywh_to_xyxy(boxes_xywh)
+
+        pad_w, pad_h = pad
+        orig_w, orig_h = orig_size
+
+        boxes[:, [0, 2]] -= pad_w
+        boxes[:, [1, 3]] -= pad_h
+        boxes /= ratio
+        boxes = self._clip_boxes(boxes, (orig_w, orig_h))
+
+        boxes, scores, cls_ids = self._filter_sane_boxes(boxes, scores, cls_ids, orig_size)
+        if len(boxes) == 0:
+            return []
+
+        keep_idx = self._hard_nms(boxes, scores, self.iou_thres)
+        keep_idx = keep_idx[: self.max_det]
+
+        boxes = boxes[keep_idx]
+        scores = scores[keep_idx]
+        cls_ids = cls_ids[keep_idx]
+
+        return [
+            BoundingBox(
+                x1=int(math.floor(box[0])),
+                y1=int(math.floor(box[1])),
+                x2=int(math.ceil(box[2])),
+                y2=int(math.ceil(box[3])),
+                cls_id=int(cls_id),
+                conf=float(conf),
+            )
+            for box, conf, cls_id in zip(boxes, scores, cls_ids)
+            if box[2] > box[0] and box[3] > box[1]
+        ]
+
+    def _postprocess(
+        self,
+        output: np.ndarray,
+        ratio: float,
+        pad: tuple[float, float],
+        orig_size: tuple[int, int],
+    ) -> list[BoundingBox]:
+        if output.ndim == 2 and output.shape[1] >= 6:
+            return self._decode_final_dets(output, ratio, pad, orig_size)
+
+        if output.ndim == 3 and output.shape[0] == 1 and output.shape[2] >= 6:
+            return self._decode_final_dets(output, ratio, pad, orig_size)
+
+        return self._decode_raw_yolo(output, ratio, pad, orig_size)
+
+    def _predict_single(self, image: np.ndarray) -> list[BoundingBox]:
+        if image is None:
+            raise ValueError("Input image is None")
+        if not isinstance(image, np.ndarray):
+            raise TypeError(f"Input is not numpy array: {type(image)}")
+        if image.ndim != 3:
+            raise ValueError(f"Expected HWC image, got shape={image.shape}")
+        if image.shape[0] <= 0 or image.shape[1] <= 0:
+            raise ValueError(f"Invalid image shape={image.shape}")
+        if image.shape[2] != 3:
+            raise ValueError(f"Expected 3 channels, got shape={image.shape}")
+
+        if image.dtype != np.uint8:
+            image = image.astype(np.uint8)
+
+        input_tensor, ratio, pad, orig_size = self._preprocess(image)
+
+        expected_shape = (1, 3, self.input_height, self.input_width)
+        if input_tensor.shape != expected_shape:
+            raise ValueError(
+                f"Bad input tensor shape={input_tensor.shape}, expected={expected_shape}"
+            )
+
+        outputs = self.session.run(self.output_names, {self.input_name: input_tensor})
+        det_output = outputs[0]
+        return self._postprocess(det_output, ratio, pad, orig_size)
+
+    def _merge_tta_consensus(
+        self,
+        boxes_orig: list[BoundingBox],
+        boxes_flip: list[BoundingBox],
+    ) -> list[BoundingBox]:
+        """
+        Keep:
+        - any box with conf >= conf_high
+        - low/medium-conf boxes only if confirmed across TTA views
+        Then run final hard NMS.
+        """
+        if not boxes_orig and not boxes_flip:
+            return []
+
+        coords_o = np.array([[b.x1, b.y1, b.x2, b.y2] for b in boxes_orig], dtype=np.float32) if boxes_orig else np.empty((0, 4), dtype=np.float32)
+        scores_o = np.array([b.conf for b in boxes_orig], dtype=np.float32) if boxes_orig else np.empty((0,), dtype=np.float32)
+
+        coords_f = np.array([[b.x1, b.y1, b.x2, b.y2] for b in boxes_flip], dtype=np.float32) if boxes_flip else np.empty((0, 4), dtype=np.float32)
+        scores_f = np.array([b.conf for b in boxes_flip], dtype=np.float32) if boxes_flip else np.empty((0,), dtype=np.float32)
+
+        accepted_boxes = []
+        accepted_scores = []
+
+        # Original view candidates
+        for i in range(len(coords_o)):
+            score = scores_o[i]
+            if score >= self.conf_high:
+                accepted_boxes.append(coords_o[i])
+                accepted_scores.append(score)
+            elif len(coords_f) > 0:
+                ious = self._box_iou_one_to_many(coords_o[i], coords_f)
+                j = int(np.argmax(ious))
+                if ious[j] >= self.tta_match_iou:
+                    fused_score = max(score, scores_f[j])
+                    accepted_boxes.append(coords_o[i])
+                    accepted_scores.append(fused_score)
+
+        # Flipped-view high-confidence boxes that original missed
+        for i in range(len(coords_f)):
+            score = scores_f[i]
+            if score < self.conf_high:
+                continue
+
+            if len(coords_o) == 0:
+                accepted_boxes.append(coords_f[i])
+                accepted_scores.append(score)
+                continue
+
+            ious = self._box_iou_one_to_many(coords_f[i], coords_o)
+            if np.max(ious) < self.tta_match_iou:
+                accepted_boxes.append(coords_f[i])
+                accepted_scores.append(score)
+
+        if not accepted_boxes:
+            return []
+
+        boxes = np.array(accepted_boxes, dtype=np.float32)
+        scores = np.array(accepted_scores, dtype=np.float32)
+
+        keep = self._hard_nms(boxes, scores, self.iou_thres)
+        keep = keep[: self.max_det]
+
+        out = []
+        for idx in keep:
+            x1, y1, x2, y2 = boxes[idx].tolist()
+            out.append(
+                BoundingBox(
+                    x1=int(math.floor(x1)),
+                    y1=int(math.floor(y1)),
+                    x2=int(math.ceil(x2)),
+                    y2=int(math.ceil(y2)),
+                    cls_id=0,
+                    conf=float(scores[idx]),
+                )
+            )
+        return out
+
+    def _predict_tta(self, image: np.ndarray) -> list[BoundingBox]:
+        boxes_orig = self._predict_single(image)
+
+        flipped = cv2.flip(image, 1)
+        boxes_flip_raw = self._predict_single(flipped)
+
+        w = image.shape[1]
+        boxes_flip = [
+            BoundingBox(
+                x1=w - b.x2,
+                y1=b.y1,
+                x2=w - b.x1,
+                y2=b.y2,
+                cls_id=b.cls_id,
+                conf=b.conf,
+            )
+            for b in boxes_flip_raw
+        ]
+
+        return self._merge_tta_consensus(boxes_orig, boxes_flip)
+
+    def predict_batch(
+        self,
+        batch_images: list[ndarray],
+        offset: int,
+        n_keypoints: int,
+    ) -> list[TVFrameResult]:
+        results: list[TVFrameResult] = []
+
+        for frame_number_in_batch, image in enumerate(batch_images):
+            try:
+                if self.use_tta:
+                    boxes = self._predict_tta(image)
+                else:
+                    boxes = self._predict_single(image)
+            except Exception as e:
+                print(f"⚠️ Inference failed for frame {offset + frame_number_in_batch}: {e}")
+                boxes = []
+
+            results.append(
+                TVFrameResult(
+                    frame_id=offset + frame_number_in_batch,
+                    boxes=boxes,
+                    keypoints=[(0, 0) for _ in range(max(0, int(n_keypoints)))],
+                )
+            )
+
+        return results

my_chute.py

@@ -0,0 +1,446 @@
+#!/usr/bin/env python3
+
+import sys
+from importlib.machinery import PathFinder
+from importlib.util import module_from_spec, spec_from_file_location
+from inspect import signature
+from pathlib import Path
+from site import getsitepackages, getusersitepackages
+from sysconfig import get_paths
+from tempfile import NamedTemporaryFile
+from typing import Any, Generator
+from urllib.parse import quote
+
+import torch
+from aiohttp import ClientSession
+from chutes.chute import Chute, NodeSelector
+from chutes.image import Image
+from base64 import b64decode
+from cv2 import CAP_PROP_FRAME_COUNT, VideoCapture, imdecode, IMREAD_COLOR
+from huggingface_hub import snapshot_download
+from numpy import ndarray, frombuffer, uint8
+from pydantic import BaseModel
+from yaml import safe_load
+
+##============VARIABLES=======================
+HF_REPO_NAME = "YRD526/ScoreVision"
+HF_REPO_REVISION = "main"
+CHUTES_USERNAME = "mango202"
+CHUTE_NAME = "person-detection-mango2"
+FILENAME = "miner.py"
+CLASSNAME = "Miner"
+CHUTE_CONFIG_FILENAME = "chute_config.yml"
+MAX_LOADED_MODEL_SIZE_GB = 5.0
+
+
+##=========DATA CLASSES================
+class TVFrame(BaseModel):
+    frame_id: int
+    url: str | None = None
+    data: str | None = None
+
+
+class TVPredictInput(BaseModel):
+    url: str | None = None
+    frames: list[TVFrame] | None = None
+    meta: dict[str, Any] = {}
+
+
+class TVPredictOutput(BaseModel):
+    success: bool
+    predictions: dict[str, list[dict]] | None = None
+    error: str | None = None
+
+
+##=========UTILITY FUNCTIONS=================
+def get_whitelisted_paths() -> set[Path]:
+    STDLIB_ROOT = Path(get_paths()["stdlib"]).resolve()
+    SITE_PACKAGES_ROOTS = {Path(p).resolve() for p in getsitepackages()} 
+    SITE_PACKAGES_ROOTS.add(Path(getusersitepackages()).resolve())
+
+    return {STDLIB_ROOT, *SITE_PACKAGES_ROOTS}
+
+def post_check_files_against_whitelist(*, before: set[str], miner_path: Path) -> None:
+    miner_path = miner_path.resolve()
+    WHITELIST = get_whitelisted_paths()
+    after = set(sys.modules.keys()) - before
+    offenders = []
+    for module_loaded_name in sorted(after):
+        module_loaded = sys.modules.get(module_loaded_name)
+        if module_loaded is None:
+            continue
+        module_loaded_file = getattr(module_loaded, "__file__", None)
+        if not module_loaded_file:
+            continue  
+        module_loaded_filepath = Path(module_loaded_file).resolve()
+        if module_loaded_filepath == miner_path:
+            continue
+        if any(module_loaded_filepath.is_relative_to(root) for root in WHITELIST):
+            continue
+        offenders.append(module_loaded_name)
+
+    if offenders:
+        raise ImportError(
+            f"Miner loaded modules outside the whitelist: {', '.join(offenders)}"
+        )
+
+
+def verify_cuda_version() -> str:
+    min_version = (12, 0)
+
+    if not torch.cuda.is_available():
+        return "❌ CUDA is not available. Make sure GPU runtime is attached correctly"
+
+    device_count = torch.cuda.device_count()
+    if device_count < 1:
+        return "❌ No CUDA devices detected"
+
+    cuda_version_str = torch.version.cuda
+    if cuda_version_str is None:
+        return "❌ PyTorch was not compiled with CUDA support"
+
+    try:
+        cuda_version = tuple(map(int, cuda_version_str.split(".")))
+    except Exception as e:
+        return f"❌ Unable to parse CUDA version string: {e}"
+
+    if cuda_version < min_version:
+        return f"❌ CUDA version {cuda_version_str} is too old. Requires >= {min_version[0]}.{min_version[1]}"
+
+    return f"CUDA {cuda_version_str} detected with {device_count} device(s)"
+
+
+def load_chute_config_from_hf_repo(config_path: Path) -> dict:
+    try:
+        if not config_path.exists():
+            raise ValueError("No config file found in repo")
+
+        with config_path.open() as configuration_file:
+            config = safe_load(configuration_file)
+            print("✅ Loaded Chutes Configuration")
+            return config or {}
+    except Exception as e:
+        print(f"⚠️ Failed to load Chutes Configuration. Using defaults: {e}")
+        return {}
+
+
+def safe_instantiate(cls, config: dict):
+    params = {k: v for k, v in config.items() if k in signature(cls).parameters}
+    print(
+        f"The following parameters will be applied when instantiating {cls.__name__}: {params}"
+    )
+    obj = cls(**params)
+    for function_name, value in config.items():
+        if not hasattr(obj, function_name) or not callable(getattr(obj, function_name)):
+            continue
+        print(f"applying .{function_name}({value})")
+        method = getattr(obj, function_name)
+        if isinstance(value, list):
+            for v in value:
+                if isinstance(v, (tuple, list)):
+                    method(*v)
+                else:
+                    method(v)
+        else:
+            method(value)
+    return obj
+
+
+def load_chute(
+    hf_repo: str,
+    hf_revision: str,
+    config_filename: str,
+    chutes_username: str,
+    chute_name: str,
+) -> Chute:
+    hf_repo_path = Path(snapshot_download(hf_repo, revision=hf_revision))
+    print("✅ Huggingface Hub repo downloaded")
+
+    config = load_chute_config_from_hf_repo(config_path=hf_repo_path / config_filename)
+    print("✅ Config file loaded")
+
+    image_config = config.get("Image", {})
+    image_config.update(
+        {
+            "username": chutes_username,
+            "name": chute_name,
+            "tag":"latest",
+            "readme": "README.md",
+        }
+    )
+    chute_image = safe_instantiate(cls=Image, config=image_config)
+    print("✅ Image instantiated")
+
+    machine_specs = safe_instantiate(
+        cls=NodeSelector, config=config.get("NodeSelector", {})
+    )
+    print("✅ NodeSelector instantiated")
+
+    chute_config = config.get("Chute", {})
+    chute_config.update(
+        {
+            "username": chutes_username,
+            "name": chute_name,
+            "image": chute_image,
+            "node_selector": machine_specs,
+            "allow_external_egress":False,
+            "readme": "README.md",
+        }
+    )
+    chute = safe_instantiate(cls=Chute, config=chute_config)
+    print("✅ Chute instantiated")
+    return chute
+
+
+def load_miner_from_hf_repo(path_hf_repo: Path, filename: str, classname: str):
+    path_hf_repo = path_hf_repo.resolve()
+    path_miner = path_hf_repo / filename
+    if not path_miner.is_file():
+        raise FileNotFoundError(
+            f"❌ Required file '{filename}' not in repo {path_hf_repo}"
+        )
+
+    WHITELIST = get_whitelisted_paths()
+
+    class HFRepoImportBlocker(PathFinder):
+        @classmethod
+        def find_spec(cls, fullname, path=None, target=None):
+            spec = super().find_spec(fullname, path, target)
+            if spec is None or spec.origin is None:
+                return spec
+            origin_path = Path(spec.origin).resolve()
+            if any(origin_path.is_relative_to(root) for root in WHITELIST):
+                return spec
+            raise ImportError(
+                f"❌ Import blocked: '{fullname}' (file: {origin_path}) is not in the whitelist. All code related to the miner MUST be inside {filename}"
+            )
+
+    try:
+        before_exec = set(sys.modules.keys())
+        sys.meta_path.insert(0, HFRepoImportBlocker)
+        spec = spec_from_file_location("miner", path_miner)
+        module = module_from_spec(spec)
+        sys.modules["miner"] = module
+        spec.loader.exec_module(module)
+        miner_object = getattr(module, classname)
+        miner = miner_object(path_hf_repo)
+        post_check_files_against_whitelist(before=before_exec, miner_path=path_miner)
+    except Exception as e:
+        raise e
+    finally:
+        sys.meta_path.remove(HFRepoImportBlocker)
+    return miner
+
+
+def object_size_in_bytes(current_obj: Any, seen_ids: set[int], limit: int) -> int:
+    obj_id = id(current_obj)
+    if obj_id in seen_ids or limit <= 0:
+        return 0
+    seen_ids.add(obj_id)
+    total_size = 0
+    if isinstance(current_obj, torch.Tensor):
+        return current_obj.numel() * current_obj.element_size()
+    if isinstance(current_obj, ndarray):
+        return current_obj.nbytes
+    try:
+        total_size += sys.getsizeof(current_obj)
+    except TypeError:
+        pass
+    if isinstance(current_obj, dict):
+        for key, value in current_obj.items():
+            total_size += object_size_in_bytes(key, seen_ids, limit - 1)
+            total_size += object_size_in_bytes(value, seen_ids, limit - 1)
+    elif isinstance(current_obj, (list, tuple, set)):
+        try:
+            for item in current_obj:
+                total_size += object_size_in_bytes(item, seen_ids, limit - 1)
+        except TypeError:
+            pass
+    elif hasattr(current_obj, "__dict__"):
+        for value in current_obj.__dict__.values():
+            total_size += object_size_in_bytes(value, seen_ids, limit - 1)
+    return total_size
+
+
+def get_miner_size_gb(miner) -> float:
+    total_size_bytes = object_size_in_bytes(
+        current_obj=miner, seen_ids=set(), limit=100
+    )
+    return total_size_bytes / (1024**3)
+
+
+def get_video_frames_in_batches(
+    video: VideoCapture, batch_size: int
+) -> Generator[list[ndarray], None, None]:
+    batch = []
+    while True:
+        ok, frame = video.read()
+        if not ok:
+            if batch:
+                yield batch
+            break
+
+        batch.append(frame)
+
+        if len(batch) >= batch_size:
+            yield batch
+            batch = []
+
+
+##=========ENDPOINTS================
+chute = load_chute(
+    hf_repo=HF_REPO_NAME,
+    hf_revision=HF_REPO_REVISION,
+    chutes_username=CHUTES_USERNAME,
+    chute_name=CHUTE_NAME,
+    config_filename=CHUTE_CONFIG_FILENAME,
+)
+
+
+@chute.on_startup()
+async def load_model(self) -> None:
+    try:
+        self.cuda_status = verify_cuda_version()
+    except Exception as e:
+        self.cuda_status = f"❌ Failed to check cuda status: {e}"
+    print(self.cuda_status)
+
+    self.miner_size = None
+    try:
+        hf_repo_path = Path(snapshot_download(HF_REPO_NAME, revision=HF_REPO_REVISION))
+        print("✅ Huggingface Hub repo downloaded")
+
+        self.miner = load_miner_from_hf_repo(
+            path_hf_repo=hf_repo_path, filename=FILENAME, classname=CLASSNAME
+        )
+        print(f"✅ Miner loaded {self.miner}")
+        self.miner_size = get_miner_size_gb(self.miner)
+        if self.miner_size > MAX_LOADED_MODEL_SIZE_GB:
+            raise ValueError(
+                f"Loaded Miner memory footprint {self.miner_size:.2f} GB exceeds the allowed limit of {MAX_LOADED_MODEL_SIZE_GB:.2f} GB. "
+            )
+        self.status = "healthy"
+    except Exception as e:
+        self.status = f"❌ Failed to load miner: {e}"
+        self.miner = None
+        print(self.status)
+
+
+@chute.cord(public_api_path="/health")
+async def health(self, *args, **kwargs) -> dict[str, Any]:
+    return {
+        "status": self.status,
+        "model_loaded": str(self.miner),
+        "memory_gb": self.miner_size,
+        "cuda": self.cuda_status,
+    }
+
+
+@chute.cord(
+    public_api_path="/predict",
+)
+async def predict(self, data: TVPredictInput) -> dict:
+    try:
+        if self.miner is None:
+            raise ValueError("Models were not properly loaded!")
+
+        metadata = data.meta
+        batch_size = metadata.get("batch_size", 64)
+        n_keypoints = metadata.get("n_keypoints", 32)
+
+        frame_results = []
+
+        if data.frames:
+            frame_entries = [(f.frame_id, f.url, f.data) for f in data.frames]
+            async with ClientSession() as session:
+                loaded_frames: list[tuple[int, ndarray]] = []
+                for frame_id, frame_url, frame_data in frame_entries:
+                    if frame_data:
+                        try:
+                            content = b64decode(frame_data)
+                        except Exception as e:
+                            raise ValueError(f"Failed to decode frame {frame_id}: {e}")
+                    elif frame_url:
+                        url = f"https://proxy.chutes.ai/misc/proxy?url={quote(frame_url, safe='')}"
+                        async with session.get(url) as response:
+                            response.raise_for_status()
+                            content = await response.read()
+                    else:
+                        raise ValueError(f"Frame {frame_id} missing url or data")
+
+                    arr = frombuffer(content, dtype=uint8)
+                    img = imdecode(arr, IMREAD_COLOR)
+                    if img is None:
+                        raise ValueError(f"Failed to decode frame {frame_id}")
+                    loaded_frames.append((frame_id, img))
+
+            for i in range(0, len(loaded_frames), batch_size):
+                batch = loaded_frames[i : i + batch_size]
+                batch_images = [img for _, img in batch]
+                batch_frame_ids = [fid for fid, _ in batch]
+                print(f"Predicting Batch: {i // batch_size + 1}")
+                batch_frame_results = self.miner.predict_batch(
+                    batch_images=batch_images,
+                    offset=0,
+                    n_keypoints=n_keypoints,
+                )
+                for frame_id, frame_result in zip(
+                    batch_frame_ids, batch_frame_results, strict=True
+                ):
+                    fr = frame_result.model_dump()
+                    fr["frame_id"] = frame_id
+                    frame_results.append(fr)
+        else:
+            if not data.url:
+                raise ValueError("Missing both video url and frames payload")
+
+            url = f"https://proxy.chutes.ai/misc/proxy?url={quote(data.url, safe='')}"
+            async with ClientSession() as session:
+                async with session.get(url) as response:
+                    response.raise_for_status()
+                    content = await response.read()
+                    print("✅ Challenge video downloaded. Saving video to temporary file.")
+
+                    with NamedTemporaryFile(prefix="sv_video_", suffix=".mp4") as f:
+                        f.write(content)
+                        cap = VideoCapture(f.name)
+                        if not cap.isOpened():
+                            raise ValueError(
+                                f"Problem accessing downloaded video {f.name}"
+                            )
+
+                        n_frames = int(cap.get(CAP_PROP_FRAME_COUNT))
+                        print(
+                            f"Processing video with {n_frames} frames in batches of {batch_size}"
+                        )
+
+                        for batch_number, images in enumerate(
+                            get_video_frames_in_batches(
+                                video=cap, batch_size=batch_size
+                            )
+                        ):
+                            frame_number = batch_size * batch_number
+                            print(f"Predicting Batch: {batch_number + 1}")
+                            batch_frame_results = self.miner.predict_batch(
+                                batch_images=images,
+                                offset=frame_number,
+                                n_keypoints=n_keypoints,
+                            )
+                            frame_results.extend(
+                                [
+                                    frame_result.model_dump()
+                                    for frame_result in batch_frame_results
+                                ]
+                            )
+
+                        cap.release()
+                        print("✅ Frame Predictions Completed")
+
+        result = TVPredictOutput(success=True, predictions={"frames": frame_results})
+
+    except Exception as e:
+        result = TVPredictOutput(
+            success=False,
+            error=f"❌ There was a problem during prediction: {e}",
+        )
+    return result.model_dump(mode="json")

person-detection.onnx

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