Upload folder using huggingface_hub

README.md

@@ -1,3 +1,92 @@
----
-license: mit
----
+# 🚀 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:
+
+![](../images/miner.png)
+
+## 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 file `scorevision/chute_tmeplate/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
+curl -X POST http://localhost:8000/health -d '{}'
+curl -X POST http://localhost:8000/predict -d '{"url": "https://scoredata.me/2025_03_14/35ae7a/h1_0f2ca0.mp4","meta": {}}'
+```
+
+## Live Testing
+1. If you have any chute with the same name (ie from a previous deployment), ensure you delete that first (or you will get an error when trying to build).
+```bash
+chutes chutes list
+```
+Take note of the chute id that you wish to delete (if any)
+```bash
+chutes chutes delete <chute-id>
+```
+
+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>
+```
+
+2. Use Turbovision's CLI to build, deploy and commit on-chain (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`)
+```bash
+sv -vv push
+```
+
+3. 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>
+```
+
+4. Test the chute's endpoints
+```bash
+curl -X POST https://<YOUR-CHUTE-SLUG>.chutes.ai/health -d '{}' -H "Authorization: Bearer $CHUTES_API_KEY"
+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"
+```
+
+5. 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
+```

miner.py

@@ -166,26 +166,44 @@ class Miner:
                     torch.cuda.synchronize()
 
                 bbox_model_results, _, _, _ = player_detection_result(batch_images, player_batch_size, self.bbox_model)
-                if bbox_model_results is not None:
+                if bbox_model_results is not None and len(bbox_model_results) > 0:
                     for frame_number_in_batch, detections in enumerate(bbox_model_results):
+                        # Ensure frame_number_in_batch is within batch_images bounds
+                        if frame_number_in_batch >= len(batch_images):
+                            print(f"⚠️  Warning: bbox_model_results has more frames ({len(bbox_model_results)}) than batch_images ({len(batch_images)}). Skipping extra frames.")
+                            break
+                        
                         boxes = []
-                        for detection in detections:
-                            # Detection format from player.py: {"id": int, "bbox": [x1, y1, x2, y2], "class_id": int}
-                            x1, y1, x2, y2 = detection["bbox"]
-                            cls_id = detection["class_id"]
-                            # Use a default confidence since it's not provided in the processed results
-                            conf = detection["conf"]  # Default confidence value
-                            
-                            boxes.append(
-                                BoundingBox(
-                                    x1=int(x1),
-                                    y1=int(y1),
-                                    x2=int(x2),
-                                    y2=int(y2),
-                                    cls_id=int(cls_id),
-                                    conf=float(conf),
-                                )
-                            )
+                        if detections is not None and isinstance(detections, (list, tuple)):
+                            for detection in detections:
+                                try:
+                                    # Detection format from player.py: {"id": int, "bbox": [x1, y1, x2, y2], "class_id": int}
+                                    if isinstance(detection, dict):
+                                        x1, y1, x2, y2 = detection.get("bbox", [0, 0, 0, 0])
+                                        cls_id = detection.get("class_id", 0)
+                                        conf = detection.get("conf", 0.0)
+                                    else:
+                                        # Handle tuple/array format: (box, score, cls)
+                                        if len(detection) >= 3:
+                                            x1, y1, x2, y2 = detection[0] if hasattr(detection[0], '__iter__') else [0, 0, 0, 0]
+                                            conf = detection[1] if len(detection) > 1 else 0.0
+                                            cls_id = detection[2] if len(detection) > 2 else 0
+                                        else:
+                                            continue
+                                    
+                                    boxes.append(
+                                        BoundingBox(
+                                            x1=int(x1),
+                                            y1=int(y1),
+                                            x2=int(x2),
+                                            y2=int(y2),
+                                            cls_id=int(cls_id),
+                                            conf=float(conf),
+                                        )
+                                    )
+                                except (KeyError, TypeError, ValueError, IndexError) as det_err:
+                                    print(f"⚠️  Warning: Could not parse detection: {det_err}")
+                                    continue
                         bboxes[offset + frame_number_in_batch] = boxes
                 print("✅ BBoxes predicted")
                 break
@@ -220,23 +238,37 @@ class Miner:
                     batch_size=pitch_batch_size
                 )
 
-                if keypoints_result is not None:
+                if keypoints_result is not None and len(keypoints_result) > 0:
                     for frame_number_in_batch, kp_dict in enumerate(keypoints_result):
+                        # Ensure frame_number_in_batch is within batch_images bounds
+                        if frame_number_in_batch >= len(batch_images):
+                            print(f"⚠️  Warning: keypoints_result has more frames ({len(keypoints_result)}) than batch_images ({len(batch_images)}). Skipping extra frames.")
+                            break
+                        
                         frame_keypoints: list[tuple[int, int]] = []
                         
                         # Get image dimensions for conversion from normalized to pixel coordinates
-                        if frame_number_in_batch < len(batch_images):
+                        try:
                             height, width = batch_images[frame_number_in_batch].shape[:2]
                             
-                            for idx in range(32):
-                                x, y = 0, 0
-                                idx = idx + 1
-                                if idx in kp_dict.keys():
-                                    kp_data = kp_dict[idx]
-                                    # Convert normalized coordinates to pixel coordinates
-                                    x = int(kp_data['x'] * width)
-                                    y = int(kp_data['y'] * height)
-                                frame_keypoints.append((x, y))
+                            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:
+                                                # Convert normalized coordinates to pixel coordinates
+                                                x = int(kp_data['x'] * width)
+                                                y = int(kp_data['y'] * height)
+                                        except (KeyError, TypeError, ValueError) as kp_err:
+                                            print(f"⚠️  Warning: Could not parse keypoint {kp_idx}: {kp_err}")
+                                    frame_keypoints.append((x, y))
+                        except (IndexError, ValueError, AttributeError) as img_err:
+                            print(f"⚠️  Warning: Could not process frame {frame_number_in_batch}: {img_err}")
+                            # Create default keypoints if processing fails
+                            frame_keypoints = [(0, 0)] * 32
                         
                         # Pad or truncate to match expected number of keypoints
                         if len(frame_keypoints) < n_keypoints:
@@ -264,10 +296,6 @@ class Miner:
         # Combine results
         results: list[TVFrameResult] = []
         for i, frame_number in enumerate(range(offset, offset + len(batch_images))):
-            # Get the current frame
-            frame = batch_images[i]  # Use index i for batch_images
-            
-            # Get detection results for this frame
             frame_boxes = bboxes.get(frame_number, [])
             frame_keypoints = keypoints.get(frame_number, [(0, 0) for _ in range(n_keypoints)])
             

player.py

@@ -240,7 +240,8 @@ def process_team_identification_batch(frames, results, kits_clf, left_team_label
                 final_label = 3  # Referee
                 
             else:
-                final_label = int(label)  # Keep original label, ensure it's int
+                continue
+                # final_label = int(label)  # Keep original label, ensure it's int
             
             frame_results.append({
                 "id": int(id),