Upload folder using huggingface_hub

chute_config.yml

@@ -0,0 +1,27 @@
+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 'numpy>=1.23' 'onnxruntime>=1.16' 'opencv-python>=4.7' 'pillow>=9.5' 'huggingface_hub>=0.19.4' 'pydantic>=2.0' 'pyyaml>=6.0' 'aiohttp>=3.9'
+    - pip install onnxruntime-gpu
+  set_workdir: /app
+  readme: "Image for chutes"
+  
+NodeSelector:
+  gpu_count: 1
+  min_vram_gb_per_gpu: 24
+  min_memory_gb: 32
+  min_cpu_count: 32
+  
+  exclude:
+    - b200
+    - h200
+    - mi300x
+
+Chute:
+  timeout_seconds: 900
+  concurrency: 4
+  max_instances: 5
+  scaling_threshold: 0.5
+  shutdown_after_seconds: 288000

miner.py

@@ -0,0 +1,217 @@
+from pathlib import Path
+import math
+
+import cv2
+import numpy as np
+import onnxruntime as ort
+from numpy import ndarray
+from pydantic import BaseModel
+import torch
+from torchvision.ops import nms
+from time import time
+
+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:
+    """
+    Auto-generated by subnet_bridge from a Manako element repo.
+    This miner is intentionally self-contained for chute import restrictions.
+    """
+
+    def __init__(self, path_hf_repo: Path) -> None:
+        self.path_hf_repo = path_hf_repo
+        self.class_names = ['person']
+
+        onnx_path = path_hf_repo / "weights.onnx"
+        providers = ["CPUExecutionProvider"]
+        try:
+            # request CUDA first, fallback to CPU if not available
+            self.sess = ort.InferenceSession(onnx_path, providers=["CUDAExecutionProvider","CPUExecutionProvider"])
+        except Exception:
+            self.sess = ort.InferenceSession(onnx_path, providers=["CPUExecutionProvider"])
+        
+        model_input = self.sess.get_inputs()[0]
+        self.input_name = model_input.name
+        self.input_size = model_input.shape[2]  # expected H (and W) from the model
+        self.conf_threshold = 0.3
+        self.iou_threshold = 0.3
+
+    def __repr__(self) -> str:
+        return f"ONNX Miner session={type(self.sess).__name__} classes={len(self.class_names)}"
+
+    def _preprocess(self, image_bgr: ndarray) -> tuple[np.ndarray, tuple[int, int]]:
+        image = image_bgr.copy()
+        shape = image.shape[:2]  # (H, W)
+
+        sz = self.input_size
+        r = sz / max(shape[0], shape[1])
+        if r != 1:
+            resample = cv2.INTER_LINEAR if r > 1 else cv2.INTER_AREA
+            image = cv2.resize(image, dsize=(int(shape[1] * r), int(shape[0] * r)), interpolation=resample)
+        height, width = image.shape[:2]
+
+        r2 = min(1.0, sz / height, sz / width)
+
+        pad_w = int(round(width * r2))
+        pad_h = int(round(height * r2))
+        w = (sz - pad_w) / 2.0
+        h = (sz - pad_h) / 2.0
+
+        # resize to pad if different
+        if (width, height) != (pad_w, pad_h):
+            image = cv2.resize(image, (pad_w, pad_h), interpolation=cv2.INTER_LINEAR)
+
+        top = int(round(h - 0.1)); bottom = int(round(h + 0.1))
+        left = int(round(w - 0.1)); right = int(round(w + 0.1))
+        image = cv2.copyMakeBorder(image, top, bottom, left, right, cv2.BORDER_CONSTANT)  # add border
+        # Convert HWC->CHW and BGR->RGB (via [::-1]) then make contiguous and normalize
+        x = image.transpose((2, 0, 1))[::-1]             # -> (C, H, W), BGR->RGB
+        x = np.ascontiguousarray(x)
+        x = x.astype(np.float32)
+        x = x[np.newaxis, ...]                           # (1, C, H, W)
+        x = x / 255.0
+        return x, (shape[0], shape[1]), (height, width), (h, w)
+
+    def wh2xy(self, x):
+        y = x.clone() if isinstance(x, torch.Tensor) else numpy.copy(x)
+        y[:, 0] = x[:, 0] - x[:, 2] / 2  # top left x
+        y[:, 1] = x[:, 1] - x[:, 3] / 2  # top left y
+        y[:, 2] = x[:, 0] + x[:, 2] / 2  # bottom right x
+        y[:, 3] = x[:, 1] + x[:, 3] / 2  # bottom right y
+        return y
+
+    def non_max_suppression(self, outputs, conf_threshold, iou_threshold):
+        max_wh = 7680
+        max_det = 300
+        max_nms = 30000
+
+        bs = outputs.shape[0]  # batch size
+        nc = outputs.shape[1] - 4  # number of classes
+        xc = outputs[:, 4:4 + nc].amax(1) > conf_threshold  # candidates
+
+        start = time()
+        limit = 0.5 + 0.05 * bs  # seconds to quit after
+
+        output = [torch.zeros((0, 6), device=outputs.device)] * bs
+        for index, x in enumerate(outputs):  # image index, image inference
+            x = x.transpose(0, -1)[xc[index]]  # confidence
+
+            # If none remain process next image
+            if not x.shape[0]:
+                continue
+
+            box, cls = x.split((4, nc), 1)
+            box = self.wh2xy(box)  # (cx, cy, w, h) to (x1, y1, x2, y2)
+            if nc > 1:
+                i, j = (cls > conf_threshold).nonzero(as_tuple=False).T
+                x = torch.cat((box[i], x[i, 4 + j, None], j[:, None].float()), 1)
+            else:  # best class only
+                conf, j = cls.max(1, keepdim=True)
+                x = torch.cat((box, conf, j.float()), 1)[conf.view(-1) > conf_threshold]
+
+            if not x.shape[0]:  # no boxes
+                continue
+            x = x[x[:, 4].argsort(descending=True)[:max_nms]]  # sort by confidence and remove excess boxes
+
+            # Batched NMS
+            c = x[:, 5:6] * max_wh  # classes
+            boxes, scores = x[:, :4] + c, x[:, 4]  # boxes (offset by class), scores
+            i = nms(boxes, scores, iou_threshold)  # NMS
+            i = i[:max_det]  # limit detections
+
+            output[index] = x[i]
+            if (time() - start) > limit:
+                break  # time limit exceeded
+
+        return output
+
+    def _postprocess(self, outputs, orig_w, orig_h, resized_w, resized_h, proc_h, proc_w):
+        outputs = torch.from_numpy(np.asarray(outputs)).float()
+        nms_results = self.non_max_suppression(outputs, self.conf_threshold, self.iou_threshold)
+        detections = []
+        scale_back_div = min(resized_h / orig_h, resized_w / orig_w)  # same as your code
+        # iterate outputs (list of tensors)
+
+        for output in nms_results:
+            if output is None or output.numel() == 0:
+                continue
+            # ensure CPU float tensor
+            output = output.cpu().float()
+
+            # replicate original adjustments:
+            # subtract padding (x padding uses w, y uses h)
+            output[:, [0, 2]] -= proc_w   # x padding
+            output[:, [1, 3]] -= proc_h   # y padding
+
+            # scale back to original image coords
+            output[:, :4] /= float(scale_back_div)
+
+            # clamp to original image size
+            output[:, 0].clamp_(0, orig_w)  # x1 (width)
+            output[:, 1].clamp_(0, orig_h)  # y1 (height)
+            output[:, 2].clamp_(0, orig_w)  # x2
+            output[:, 3].clamp_(0, orig_h)  # y2
+
+            for box in output:
+                box_np = box.cpu().numpy()
+                x1, y1, x2, y2, score, index = box_np[:6]  # matches your unpack
+                detections.append((float(x1), float(y1), float(x2), float(y2), float(score), int(index)))
+
+        return detections
+
+    def _infer_single(self, image_bgr: ndarray) -> list[BoundingBox]:
+        x, (orig_h, orig_w), (resized_h, resized_w), (proc_h, proc_w) = self._preprocess(image_bgr)
+    
+        outputs = self.sess.run(None, {self.input_name: x})[0]
+        outputs = self._postprocess(outputs, orig_w, orig_h, resized_w, resized_h, proc_h, proc_w)
+
+        out_boxes: list[BoundingBox] = []
+        for x1, y1, x2, y2, conf, cls_id in outputs:
+            ix1 = max(0, min(orig_w, math.floor(x1)))
+            iy1 = max(0, min(orig_h, math.floor(y1)))
+            ix2 = max(0, min(orig_w, math.ceil(x2)))
+            iy2 = max(0, min(orig_h, math.ceil(y2)))
+            out_boxes.append(
+                BoundingBox(
+                    x1=ix1,
+                    y1=iy1,
+                    x2=ix2,
+                    y2=iy2,
+                    cls_id=cls_id,
+                    conf=max(0.0, min(1.0, conf)),
+                )
+            )
+
+        return out_boxes
+
+    def predict_batch(
+        self,
+        batch_images: list[ndarray],
+        offset: int,
+        n_keypoints: int,
+    ) -> list[TVFrameResult]:
+        results: list[TVFrameResult] = []
+        for idx, image in enumerate(batch_images):
+            boxes = self._infer_single(image)
+            keypoints = [(0, 0) for _ in range(max(0, int(n_keypoints)))]
+            results.append(
+                TVFrameResult(
+                    frame_id=offset + idx,
+                    boxes=boxes,
+                    keypoints=keypoints,
+                )
+            )
+        return results

weights.onnx

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