update the code and md file

README.md

@@ -0,0 +1,119 @@
+# RustAutoScoreEngine
+### High-Performance AI Dart Scoring Powered by Rust & Burn
+
+<div align="center">
+
+[![Rust](https://img.shields.io/badge/Rust-1.75%2B-orange?style=for-the-badge&logo=rust)](https://www.rust-lang.org/)
+[![Burn](https://img.shields.io/badge/Burn-AI--Framework-red?style=for-the-badge)](https://burn.dev/)
+[![WGPU](https://img.shields.io/badge/Backend-WGPU%20/%20Cuda-blue?style=for-the-badge)](https://github.com/gfx-rs/wgpu)
+[![License](https://img.shields.io/badge/License-MIT-purple?style=for-the-badge)](LICENSE)
+
+**A professional-grade, real-time dart scoring engine built entirely in Rust.**
+
+Using the **Burn Deep Learning Framework**, this project achieves sub-millisecond inference and high-precision keypoint detection for automatic dart game tracking. The model optimization pipeline is built using modern Rust patterns for maximum safety and performance.
+
+</div>
+
+---
+
+## Features
+
+- **Optimized Inference**: Powered by Rust & WGPU for hardware-accelerated performance on Windows, Linux, and macOS.
+- **Multi-Scale Keypoint Detection**: Enhanced YOLO-style heads for detecting dart tips and calibration corners.
+- **BDO Logic Integrated**: Real-time sector calculation based on official board geometry and calibration symmetry.
+- **Modern Web Dashboard**: Axum-based visual interface to monitor detections, scores, and latency in real-time.
+- **Robust Calibration**: Automatic symmetry estimation to recover missing calibration points.
+
+---
+
+## Dataset and Preparation
+The model is trained on the primary dataset used for high-precision dart detection.
+
+- **Download Link**: [Dataset Resources (Google Drive)](https://drive.google.com/file/d/1ZEvuzg9zYbPd1FdZgV6v1aT4sqbqmLqp/view?usp=sharing)
+- **Resolution**: 800x800 pre-cropped high-resolution images.
+- **Structure**: Organize your data in the `dataset/800/` directory following the provided `labels.json` schema.
+
+---
+
+## Installation
+
+### 1. Install Rust
+If you do not have Rust installed, use the official installation script:
+
+```bash
+# Official Installation
+curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh
+```
+
+### 2. Clone and Build
+```bash
+git clone https://github.com/iambhabha/RustAutoScoreEngine.git
+cd RustAutoScoreEngine
+cargo build --release
+```
+
+---
+
+## Quick Start Guide
+
+### Step 1: Training the AI Model
+To optimize the neural network for your local environment, run the training mode:
+```bash
+# Starts the training cycle (Configured for 50 Epochs)
+cargo run
+```
+*Tip: Allow the loss to converge below 0.05 for optimal results.*
+
+### Step 2: Running the Dashboard
+After training is complete (generating the `model_weights.bin` file), launch the testing interface:
+```bash
+# Starts the Axum web server
+cargo run -- gui
+```
+**Features:**
+- **Image Upload**: Test local image samples via the dashboard.
+- **Point Visualization**: Inspect detected calibration points and dart locations.
+- **Automatic Scoring**: Instant sector calculation and latency reporting.
+
+---
+
+## Mobile Deployment
+
+This engine is built on Burn, supporting multiple paths for Android and iOS integration:
+
+### Path A: Native Rust
+Package the engine as a library for direct hardware-accelerated execution on mobile targets.
+- **Backend**: burn-wgpu with Vulkan (Android) or Metal (iOS).
+- **Integration**: JNI (Android) or FFI (iOS) calls from native code.
+
+### Path B: Weight Migration to TFLite/ONNX
+- **TFLite**: Use the companion export scripts to generate a TensorFlow Lite bundle.
+- **ONNX**: Utilize ONNX Runtime (ORT) for high-performance cross-platform execution.
+
+---
+
+## Technical Status and Contributing
+
+> [!IMPORTANT]
+> This project is currently in the experimental phase. We are actively refining the coordinate regression logic to ensure maximum precision across diverse board angles.
+
+**Current Priorities:**
+- Enhancing offset regression stability.
+- Memory optimization for low-VRAM devices.
+
+**Contribution Guidelines:**
+If you encounter a bug or wish to provide performance optimizations, please submit a Pull Request.
+
+---
+
+## Resources
+
+- **Original Inspiration**: [Paper: Keypoints as Objects for Automatic Scorekeeping](https://arxiv.org/abs/2105.09880)
+- **Model Training Resources**: [Download from Google Drive](https://drive.google.com/file/d/1ZEvuzg9zYbPd1FdZgV6v1aT4sqbqmLqp/view?usp=sharing)
+- **Official Documentation Reference**: [IEEE Dataport Dataset](https://ieee-dataport.org/open-access/deepdarts-dataset)
+
+---
+
+<div align="center">
+Made by the Rust AI Community
+</div>

src/data.rs

@@ -90,12 +90,16 @@ impl<B: Backend> DartBatcher<B> {
                 let gx = (p[0] * grid_size as f32).floor().clamp(0.0, (grid_size - 1) as f32) as usize;
                 let gy = (p[1] * grid_size as f32).floor().clamp(0.0, (grid_size - 1) as f32) as usize;
 
+                // Use Grid-Relative Coordinates (Relative to cell top-left)
+                let tx = p[0] * grid_size as f32 - gx as f32;
+                let ty = p[1] * grid_size as f32 - gy as f32;
+
                 let cls = if i < 4 { i + 1 } else { 0 };
                 let base_idx = (b_idx * num_channels * grid_size * grid_size) + (gy * grid_size) + gx;
 
                 // TF order: [x,y,w,h,obj,p0..p4]
-                target_raw[base_idx + 0 * grid_size * grid_size] = p[0];    // X
-                target_raw[base_idx + 1 * grid_size * grid_size] = p[1];    // Y
+                target_raw[base_idx + 0 * grid_size * grid_size] = tx; // X (offset in cell)
+                target_raw[base_idx + 1 * grid_size * grid_size] = ty; // Y (offset in cell)
                 target_raw[base_idx + 2 * grid_size * grid_size] = 0.05;    // W
                 target_raw[base_idx + 3 * grid_size * grid_size] = 0.05;    // H
                 target_raw[base_idx + 4 * grid_size * grid_size] = 1.0;     // Objectness (conf)

src/inference.rs

@@ -1,15 +1,15 @@
+use crate::model::DartVisionModel;
 use burn::module::Module;
 use burn::record::{BinFileRecorder, FullPrecisionSettings, Recorder};
 use burn::tensor::backend::Backend;
 use burn::tensor::{Tensor, TensorData};
-use crate::model::DartVisionModel;
-use image::{GenericImageView, DynamicImage};
+use image::{DynamicImage, GenericImageView};
 
 pub fn run_inference<B: Backend>(device: &B::Device, image_path: &str) {
     println!("🔍 Loading model for inference...");
     let recorder = BinFileRecorder::<FullPrecisionSettings>::default();
     let model: DartVisionModel<B> = DartVisionModel::new(device);
-    
+
     // Load weights
     let record = Recorder::load(&recorder, "model_weights".into(), device)
         .expect("Failed to load weights. Make sure model_weights.bin exists.");
@@ -18,12 +18,22 @@ pub fn run_inference<B: Backend>(device: &B::Device, image_path: &str) {
     println!("🖼️ Processing image: {}...", image_path);
     let img = image::open(image_path).expect("Failed to open image");
     let resized = img.resize_exact(800, 800, image::imageops::FilterType::Triangle);
-    let pixels: Vec<f32> = resized.to_rgb8().pixels()
-        .flat_map(|p| vec![p[0] as f32 / 255.0, p[1] as f32 / 255.0, p[2] as f32 / 255.0])
+    let pixels: Vec<f32> = resized
+        .to_rgb8()
+        .pixels()
+        .flat_map(|p| {
+            vec![
+                p[0] as f32 / 255.0,
+                p[1] as f32 / 255.0,
+                p[2] as f32 / 255.0,
+            ]
+        })
         .collect();
 
     let data = TensorData::new(pixels, [800, 800, 3]);
-    let input = Tensor::<B, 3>::from_data(data, device).unsqueeze::<4>().permute([0, 3, 1, 2]);
+    let input = Tensor::<B, 3>::from_data(data, device)
+        .unsqueeze::<4>()
+        .permute([0, 3, 1, 2]);
 
     println!("🚀 Running MODEL Prediction...");
     let (out16, _out32) = model.forward(input);
@@ -31,17 +41,24 @@ pub fn run_inference<B: Backend>(device: &B::Device, image_path: &str) {
     // Post-process out16 (size [1, 30, 100, 100])
     // Decode objectness part (Channel 4 for Anchor 0)
     let obj = burn::tensor::activation::sigmoid(out16.clone().narrow(1, 4, 1));
-    
+
     // Find highest confidence cell
     let (max_val, _) = obj.reshape([1, 10000]).max_dim_with_indices(1);
-    let confidence: f32 = max_val.to_data().convert::<f32>().as_slice::<f32>().unwrap()[0];
-    
+    let confidence: f32 = max_val
+        .to_data()
+        .convert::<f32>()
+        .as_slice::<f32>()
+        .unwrap()[0];
+
     println!("--------------------------------------------------");
     println!("📊 RESULTS FOR: {}", image_path);
     println!("✨ Max Objectness: {:.2}%", confidence * 100.0);
-    
+
     if confidence > 0.05 {
-        println!("✅ Model found something! Confidence Score: {:.4}", confidence);
+        println!(
+            "✅ Model found something! Confidence Score: {:.4}",
+            confidence
+        );
     } else {
         println!("⚠️ Model confidence is too low. Training incomplete?");
     }

src/loss.rs

@@ -32,9 +32,10 @@ pub fn diou_loss<B: Backend>(
         .mul_scalar(5.0); // Boost class learning
 
     // 4. Coordinates (Channels 0-3) - Only learn when object exists
+    // 2. Coordinate Loss (MSE on relative offsets) - Weighted x10 for precision
     let b_xy_pred = burn::tensor::activation::sigmoid(bp.clone().narrow(2, 0, 2));
     let b_xy_target = t.clone().narrow(2, 0, 2);
-    let xy_loss = b_xy_pred.sub(b_xy_target).powf_scalar(2.0).mul(obj_target.clone()).mean().mul_scalar(5.0);
+    let xy_loss = b_xy_pred.sub(b_xy_target).powf_scalar(2.0).mul(obj_target.clone()).mean().mul_scalar(10.0);
 
     let b_wh_pred = burn::tensor::activation::sigmoid(bp.clone().narrow(2, 2, 2));
     let b_wh_target = t.clone().narrow(2, 2, 2);

src/main.rs

@@ -32,7 +32,7 @@ fn main() {
         let dataset_path = "dataset/labels.json";
 
         let config = TrainingConfig {
-            num_epochs: 10,
+            num_epochs: 50,
             batch_size: 1,
             lr: 1e-3,
         };

src/model.rs

@@ -30,40 +30,40 @@ impl<B: Backend> ConvBlock<B> {
 
 #[derive(Module, Debug)]
 pub struct DartVisionModel<B: Backend> {
-    // Lean architecture: High resolution (800x800) but low channel count to fix GPU OOM
-    l1: ConvBlock<B>, // 3 -> 16
+    // Increased capacity: High resolution but enough width to map complex features
+    l1: ConvBlock<B>, // 3 -> 32
     p1: MaxPool2d,
-    l2: ConvBlock<B>, // 16 -> 16
+    l2: ConvBlock<B>, // 32 -> 32
     p2: MaxPool2d,
-    l3: ConvBlock<B>, // 16 -> 32
+    l3: ConvBlock<B>, // 32 -> 64
     p3: MaxPool2d,
-    l4: ConvBlock<B>, // 32 -> 32
+    l4: ConvBlock<B>, // 64 -> 64
     p4: MaxPool2d,
-    l5: ConvBlock<B>, // 32 -> 64
-    l6: ConvBlock<B>, // 64 -> 64
+    l5: ConvBlock<B>, // 64 -> 128
+    l6: ConvBlock<B>, // 128 -> 128
 
-    head_32: Conv2d<B>, // Final detection head
+    head_32: Conv2d<B>, // Final detection head (30 channels for 3 anchors)
 }
 
 impl<B: Backend> DartVisionModel<B> {
     pub fn new(device: &B::Device) -> Self {
-        let l1 = ConvBlock::new(3, 16, [3, 3], device);
+        let l1 = ConvBlock::new(3, 32, [3, 3], device);
         let p1 = MaxPool2dConfig::new([2, 2]).with_strides([2, 2]).init();
         
-        let l2 = ConvBlock::new(16, 16, [3, 3], device);
+        let l2 = ConvBlock::new(32, 32, [3, 3], device);
         let p2 = MaxPool2dConfig::new([2, 2]).with_strides([2, 2]).init();
         
-        let l3 = ConvBlock::new(16, 32, [3, 3], device);
+        let l3 = ConvBlock::new(32, 64, [3, 3], device);
         let p3 = MaxPool2dConfig::new([2, 2]).with_strides([2, 2]).init();
         
-        let l4 = ConvBlock::new(32, 32, [3, 3], device);
+        let l4 = ConvBlock::new(64, 64, [3, 3], device);
         let p4 = MaxPool2dConfig::new([2, 2]).with_strides([2, 2]).init();
         
-        let l5 = ConvBlock::new(32, 64, [3, 3], device);
-        let l6 = ConvBlock::new(64, 64, [3, 3], device);
+        let l5 = ConvBlock::new(64, 128, [3, 3], device);
+        let l6 = ConvBlock::new(128, 128, [3, 3], device);
 
-        // 30 channels = 3 anchors * (x,y,w,h,obj,p0...p4)
-        let head_32 = Conv2dConfig::new([64, 30], [1, 1]).init(device);
+        // 30 channels = 3 anchors * (x,y,w,h,obj,dart,cal1,cal2,cal3,cal4)
+        let head_32 = Conv2dConfig::new([128, 30], [1, 1]).init(device);
 
         Self { l1, p1, l2, p2, l3, p3, l4, p4, l5, l6, head_32 }
     }

src/scoring.rs

@@ -23,44 +23,49 @@ impl Default for ScoringConfig {
 pub fn get_board_dict() -> HashMap<i32, &'static str> {
     let mut m = HashMap::new();
     // BDO standard mapping based on degrees
-    let slices = ["13", "4", "18", "1", "20", "5", "12", "9", "14", "11", "8", "16", "7", "19", "3", "17", "2", "15", "10", "6"];
+    let slices = [
+        "6", "13", "4", "18", "1", "20", "5", "12", "9", "14", "11", "8", "16", "7", "19", "3",
+        "17", "2", "15", "10",
+    ];
     for (i, &s) in slices.iter().enumerate() {
         m.insert(i as i32, s);
     }
     m
 }
 
-pub fn calculate_dart_score(cal_pts: &[[f32; 2]], dart_pt: &[f32; 2], config: &ScoringConfig) -> (i32, String) {
+pub fn calculate_dart_score(
+    cal_pts: &[[f32; 2]],
+    dart_pt: &[f32; 2],
+    config: &ScoringConfig,
+) -> (i32, String) {
     // 1. Calculate Center (Average of 4 calibration points)
     let cx = cal_pts.iter().map(|p| p[0]).sum::<f32>() / 4.0;
     let cy = cal_pts.iter().map(|p| p[1]).sum::<f32>() / 4.0;
 
     // 2. Calculate average radius to boundary (doubles wire)
-    let avg_r_px = cal_pts.iter()
+    let avg_r_px = cal_pts
+        .iter()
         .map(|p| ((p[0] - cx).powi(2) + (p[1] - cy).powi(2)).sqrt())
-        .sum::<f32>() / 4.0;
+        .sum::<f32>()
+        / 4.0;
 
     // 3. Relative distance of dart from center
     let dx = dart_pt[0] - cx;
     let dy = dart_pt[1] - cy;
     let dist_px = (dx.powi(2) + dy.powi(2)).sqrt();
-    
+
     // Scale distance relative to BDO double radius
     let dist_scaled = (dist_px / avg_r_px) * config.r_double;
 
     // 4. Calculate Angle (0 is 3 o'clock, CCW)
     let mut angle_deg = (-dy).atan2(dx).to_degrees();
-    if angle_deg < 0.0 { angle_deg += 360.0; }
-    
-    // Board is rotated such that 20 is at top (90 deg)
-    // Sector width is 18 deg. Sector 20 is centered at 90 deg.
-    // 90 deg is index 4 in slices (13, 4, 18, 1, 20...)
-    // Each index is 18 deg. Offset = 4 * 18 = 72? No.
-    // Let's use the standard mapping: (angle / 18)
-    // Wait, the BOARD_DICT in Python uses int(angle / 18) where angle is 0-360.
-    // We need to match the slice orientation.
+    if angle_deg < 0.0 {
+        angle_deg += 360.0;
+    }
+
+    // Center sectors by adding 9 degrees (half-sector width)
     let board_dict = get_board_dict();
-    let sector_idx = ((angle_deg / 18.0).floor() as i32) % 20;
+    let sector_idx = (((angle_deg + 9.0) / 18.0).floor() as i32) % 20;
     let sector_num = board_dict.get(&sector_idx).unwrap_or(&"0");
 
     // 5. Determine multipliers based on scaled distance

src/server.rs

@@ -1,14 +1,14 @@
+use crate::model::DartVisionModel;
 use axum::{
     extract::{DefaultBodyLimit, Multipart, State},
     response::{Html, Json},
     routing::{get, post},
     Router,
 };
+use burn::backend::wgpu::WgpuDevice;
+use burn::backend::Wgpu;
 use burn::prelude::*;
 use burn::record::{BinFileRecorder, FullPrecisionSettings, Recorder};
-use burn::backend::Wgpu;
-use burn::backend::wgpu::WgpuDevice;
-use crate::model::DartVisionModel;
 use serde_json::json;
 use std::net::SocketAddr;
 use std::sync::Arc;
@@ -47,64 +47,235 @@ pub async fn start_gui(device: WgpuDevice) {
         let model = model.load_record(record);
 
         while let Some(req) = rx.blocking_recv() {
+            let start_time = std::time::Instant::now();
+            
             let img = image::load_from_memory(&req.image_bytes).unwrap();
             let resized = img.resize_exact(416, 416, image::imageops::FilterType::Triangle);
-            let pixels: Vec<f32> = resized.to_rgb8().pixels()
-                .flat_map(|p| vec![p[0] as f32 / 255.0, p[1] as f32 / 255.0, p[2] as f32 / 255.0])
+            let pixels: Vec<f32> = resized
+                .to_rgb8()
+                .pixels()
+                .flat_map(|p| {
+                    vec![
+                        p[0] as f32 / 255.0,
+                        p[1] as f32 / 255.0,
+                        p[2] as f32 / 255.0,
+                    ]
+                })
                 .collect();
 
             let tensor_data = TensorData::new(pixels, [1, 416, 416, 3]);
-            let input = Tensor::<Wgpu, 4>::from_data(tensor_data, &worker_device).permute([0, 3, 1, 2]);
+            let input =
+                Tensor::<Wgpu, 4>::from_data(tensor_data, &worker_device).permute([0, 3, 1, 2]);
 
             let (out16, _) = model.forward(input);
-            
+
+            // 1. Reshape to separate anchors: [1, 3, 10, 26, 26]
+            let out_reshaped = out16.reshape([1, 3, 10, 26, 26]);
+
+            // 1.5 Debug: Raw Statistics
+            println!(
+                "🔍 [Model Stats] Raw Min: {:.4}, Max: {:.4}",
+                out_reshaped.clone().min().into_scalar(),
+                out_reshaped.clone().max().into_scalar()
+            );
+
             let mut final_points = vec![0.0f32; 8]; // 4 corners
             let mut max_conf = 0.0f32;
 
-            // 1. Extract Objectness with Sigmoid
-            let obj = burn::tensor::activation::sigmoid(out16.clone().narrow(1, 4, 1));
-            
-            // 2. Extract best calibration corner for each class 1 to 4 (Grid 26x26 = 676)
+            // 2. Extract best calibration corner for each class 1 to 4
             for cls_idx in 1..=4 {
-                let prob = burn::tensor::activation::sigmoid(out16.clone().narrow(1, 5 + cls_idx, 1));
-                let score = obj.clone().mul(prob);
-                let (val, idx) = score.reshape([1, 676]).max_dim_with_indices(1);
-                
+                let mut best_s = -1.0f32;
+                let mut best_pt = [0.0f32; 2];
+                let mut best_anchor = 0;
+                let mut best_grid = (0, 0);
+
+                for anchor in 0..3 {
+                    let obj = burn::tensor::activation::sigmoid(
+                        out_reshaped.clone().narrow(1, anchor, 1).narrow(2, 4, 1),
+                    );
+                    let prob = burn::tensor::activation::sigmoid(
+                        out_reshaped
+                            .clone()
+                            .narrow(1, anchor, 1)
+                            .narrow(2, 5 + cls_idx, 1),
+                    );
+                    let score = obj.mul(prob);
+
+                    let (val, idx) = score.reshape([1, 676]).max_dim_with_indices(1);
+                    let s = val.to_data().convert::<f32>().as_slice::<f32>().unwrap()[0];
+                    if s > best_s {
+                        best_s = s;
+                        best_anchor = anchor;
+                        let f_idx =
+                            idx.to_data().convert::<i32>().as_slice::<i32>().unwrap()[0] as usize;
+                        best_grid = (f_idx % 26, f_idx / 26);
+
+                        let sx = burn::tensor::activation::sigmoid(
+                            out_reshaped
+                                .clone()
+                                .narrow(1, anchor, 1)
+                                .narrow(2, 0, 1)
+                                .slice([
+                                    0..1,
+                                    0..1,
+                                    0..1,
+                                    best_grid.1..best_grid.1 + 1,
+                                    best_grid.0..best_grid.0 + 1,
+                                ]),
+                        )
+                        .to_data()
+                        .convert::<f32>()
+                        .as_slice::<f32>()
+                        .unwrap()[0];
+                        let sy = burn::tensor::activation::sigmoid(
+                            out_reshaped
+                                .clone()
+                                .narrow(1, anchor, 1)
+                                .narrow(2, 1, 1)
+                                .slice([
+                                    0..1,
+                                    0..1,
+                                    0..1,
+                                    best_grid.1..best_grid.1 + 1,
+                                    best_grid.0..best_grid.0 + 1,
+                                ]),
+                        )
+                        .to_data()
+                        .convert::<f32>()
+                        .as_slice::<f32>()
+                        .unwrap()[0];
+                        
+                        // Reconstruct Absolute Normalized Coord (0-1)
+                        best_pt = [
+                            (best_grid.0 as f32 + sx) / 26.0,
+                            (best_grid.1 as f32 + sy) / 26.0,
+                        ];
+                    }
+                }
+
+                final_points[(cls_idx - 1) * 2] = best_pt[0];
+                final_points[(cls_idx - 1) * 2 + 1] = best_pt[1];
+                if best_s > max_conf {
+                    max_conf = best_s;
+                }
+                println!(
+                    "   [Debug Cal{}] Anchor: {}, Conf: {:.4}, Cell: {:?}, Coord: [{:.3}, {:.3}]",
+                    cls_idx, best_anchor, best_s, best_grid, best_pt[0], best_pt[1]
+                );
+            }
+
+            // 3. Calibration Estimation (Python logic: est_cal_pts)
+            // If one calibration point is missing, estimate it using symmetry
+            let mut valid_cal_count = 0;
+            let mut missing_idx = -1;
+            for i in 0..4 {
+                if final_points[i*2] > 0.01 || final_points[i*2+1] > 0.01 {
+                    valid_cal_count += 1;
+                } else {
+                    missing_idx = i as i32;
+                }
+            }
+
+            if valid_cal_count == 3 {
+                println!("⚠️ [Calibration Recovery] Estimating missing point Cal{}...", missing_idx + 1);
+                match missing_idx {
+                    0 | 1 => { // Top points missing, use bottom points center
+                        let cx = (final_points[4] + final_points[6]) / 2.0;
+                        let cy = (final_points[5] + final_points[7]) / 2.0;
+                        if missing_idx == 0 {
+                            final_points[0] = 2.0 * cx - final_points[2];
+                            final_points[1] = 2.0 * cy - final_points[3];
+                        } else {
+                            final_points[2] = 2.0 * cx - final_points[0];
+                            final_points[3] = 2.0 * cy - final_points[1];
+                        }
+                    },
+                    2 | 3 => { // Bottom points missing, use top points center
+                        let cx = (final_points[0] + final_points[2]) / 2.0;
+                        let cy = (final_points[1] + final_points[3]) / 2.0;
+                        if missing_idx == 2 {
+                            final_points[4] = 2.0 * cx - final_points[6];
+                            final_points[5] = 2.0 * cy - final_points[7];
+                        } else {
+                            final_points[6] = 2.0 * cx - final_points[4];
+                            final_points[7] = 2.0 * cy - final_points[5];
+                        }
+                    },
+                    _ => {}
+                }
+            }
+
+            // 4. Extract best dart (Class 0) - Find candidates across all anchors
+            println!("   [Debug Dart] Searching for Candidates...");
+            let mut dart_candidates = vec![];
+            for anchor in 0..3 {
+                let obj = burn::tensor::activation::sigmoid(
+                    out_reshaped.clone().narrow(1, anchor, 1).narrow(2, 4, 1),
+                );
+                let prob = burn::tensor::activation::sigmoid(
+                    out_reshaped.clone().narrow(1, anchor, 1).narrow(2, 5, 1),
+                );
+                let score = obj.mul(prob).reshape([1, 676]);
+
+                let (val, idx) = score.max_dim_with_indices(1);
                 let s = val.to_data().convert::<f32>().as_slice::<f32>().unwrap()[0];
                 let f_idx = idx.to_data().convert::<i32>().as_slice::<i32>().unwrap()[0] as usize;
-                let gy = f_idx / 26;
+
                 let gx = f_idx % 26;
+                let gy = f_idx / 26;
 
-                // Use Sigmoid for Coordinates (matching new loss logic)
-                let px = burn::tensor::activation::sigmoid(out16.clone().narrow(1, 0, 1).slice([0..1, 0..1, gy..gy+1, gx..gx+1]))
-                    .to_data().convert::<f32>().as_slice::<f32>().unwrap()[0];
-                let py = burn::tensor::activation::sigmoid(out16.clone().narrow(1, 1, 1).slice([0..1, 0..1, gy..gy+1, gx..gx+1]))
-                    .to_data().convert::<f32>().as_slice::<f32>().unwrap()[0];
+                let dsx = burn::tensor::activation::sigmoid(
+                    out_reshaped
+                        .clone()
+                        .narrow(1, anchor, 1)
+                        .narrow(2, 0, 1)
+                        .slice([0..1, 0..1, 0..1, gy..gy + 1, gx..gx + 1]),
+                )
+                .to_data()
+                .convert::<f32>()
+                .as_slice::<f32>()
+                .unwrap()[0];
+                let dsy = burn::tensor::activation::sigmoid(
+                    out_reshaped
+                        .clone()
+                        .narrow(1, anchor, 1)
+                        .narrow(2, 1, 1)
+                        .slice([0..1, 0..1, 0..1, gy..gy + 1, gx..gx + 1]),
+                )
+                .to_data()
+                .convert::<f32>()
+                .as_slice::<f32>()
+                .unwrap()[0];
 
-                final_points[(cls_idx-1)*2] = px;
-                final_points[(cls_idx-1)*2+1] = py;
-                if s > max_conf { max_conf = s; }
+                let dx = (gx as f32 + dsx) / 26.0;
+                let dy = (gy as f32 + dsy) / 26.0;
+
+                if s > 0.005 {
+                    println!(
+                        "     - A{} Best Cell: ({},{}), Conf: {:.4}, Coord: [{:.3}, {:.3}]",
+                        anchor, gx, gy, s, dx, dy
+                    );
+                    dart_candidates.push((s, [dx, dy]));
+                }
             }
 
-            // 3. Extract best dart (Class 0)
-            let d_prob = burn::tensor::activation::sigmoid(out16.clone().narrow(1, 5, 1));
-            let d_score = obj.clone().mul(d_prob);
-            let (d_val, d_idx) = d_score.reshape([1, 676]).max_dim_with_indices(1);
-            let ds = d_val.to_data().convert::<f32>().as_slice::<f32>().unwrap()[0];
-            if ds > 0.1 {
-                let f_idx = d_idx.to_data().convert::<i32>().as_slice::<i32>().unwrap()[0] as usize;
-                let gy = f_idx / 26;
-                let gx = f_idx % 26;
-                let dx = burn::tensor::activation::sigmoid(out16.clone().narrow(1, 0, 1).slice([0..1, 0..1, gy..gy+1, gx..gx+1]))
-                    .to_data().convert::<f32>().as_slice::<f32>().unwrap()[0];
-                let dy = burn::tensor::activation::sigmoid(out16.clone().narrow(1, 1, 1).slice([0..1, 0..1, gy..gy+1, gx..gx+1]))
-                    .to_data().convert::<f32>().as_slice::<f32>().unwrap()[0];
-                final_points.push(dx);
-                final_points.push(dy);
+            // Pick the best dart candidate among all anchors
+            dart_candidates
+                .sort_by(|a, b| b.0.partial_cmp(&a.0).unwrap_or(std::cmp::Ordering::Equal));
+            if let Some((s, pt)) = dart_candidates.first() {
+                if *s > 0.05 {
+                    final_points.push(pt[0]);
+                    final_points.push(pt[1]);
+                    println!(
+                        "   ✅ Best Dart Picked: Conf: {:.2}%, Coord: {:?}",
+                        s * 100.0,
+                        pt
+                    );
+                }
             }
 
             let mut final_scores = vec![];
-            
+
             // Calculate scores if we have calibration points and at least one dart
             if final_points.len() >= 10 {
                 use crate::scoring::{calculate_dart_score, ScoringConfig};
@@ -115,22 +286,32 @@ pub async fn start_gui(device: WgpuDevice) {
                     [final_points[4], final_points[5]],
                     [final_points[6], final_points[7]],
                 ];
-                
+
                 for dart_chunk in final_points[8..].chunks(2) {
                     if dart_chunk.len() == 2 {
                         let dart_pt = [dart_chunk[0], dart_chunk[1]];
-                        let (_val, label) = calculate_dart_score(&cal_pts, &dart_pt, &config);
-                        final_scores.push(label);
+                        let (s_val, label) = calculate_dart_score(&cal_pts, &dart_pt, &config);
+                        final_scores.push(label.clone());
+                        println!("   [Debug Score] Label: {} (Val: {})", label, s_val);
                     }
                 }
             }
 
-            println!("🎯 [Detection Result] Confidence: {:.2}%", max_conf * 100.0);
+            let duration = start_time.elapsed();
+            println!("⚡ [Inference Performance] Total Latency: {:.2?}", duration);
+
+            println!("🎯 [Final Result] Top Confidence: {:.2}%", max_conf * 100.0);
             let class_names = ["Cal1", "Cal2", "Cal3", "Cal4", "Dart"];
             for (i, pts) in final_points.chunks(2).enumerate() {
                 let name = class_names.get(i).unwrap_or(&"Dart");
-                let label = final_scores.get(i.saturating_sub(4)).cloned().unwrap_or_default();
-                println!("   - {}: [x: {:.3}, y: {:.3}] {}", name, pts[0], pts[1], label);
+                let label = final_scores
+                    .get(i.saturating_sub(4))
+                    .cloned()
+                    .unwrap_or_default();
+                println!(
+                    "   - {}: [x: {:.3}, y: {:.3}] {}",
+                    name, pts[0], pts[1], label
+                );
             }
 
             let _ = req.response_tx.send(PredictResult {
@@ -144,7 +325,10 @@ pub async fn start_gui(device: WgpuDevice) {
     let state = Arc::new(tx);
 
     let app = Router::new()
-        .route("/", get(|| async { Html(include_str!("../static/index.html")) }))
+        .route(
+            "/",
+            get(|| async { Html(include_str!("../static/index.html")) }),
+        )
         .route("/api/predict", post(predict_handler))
         .with_state(state)
         .layer(DefaultBodyLimit::max(10 * 1024 * 1024))
@@ -165,17 +349,26 @@ async fn predict_handler(
                 Err(_) => continue,
             };
             let (res_tx, res_rx) = oneshot::channel();
-            let _ = tx.send(PredictRequest { image_bytes: bytes, response_tx: res_tx }).await;
-            let result = res_rx.await.unwrap_or(PredictResult { confidence: 0.0, keypoints: vec![] });
+            let _ = tx
+                .send(PredictRequest {
+                    image_bytes: bytes,
+                    response_tx: res_tx,
+                })
+                .await;
+            let result = res_rx.await.unwrap_or(PredictResult {
+                confidence: 0.0,
+                keypoints: vec![],
+                scores: vec![],
+            });
 
             return Json(json!({
                 "status": "success",
                 "confidence": result.confidence,
                 "keypoints": result.keypoints,
                 "scores": result.scores,
-                "message": if result.confidence > 0.1 { 
+                "message": if result.confidence > 0.1 {
                     format!("✅ Found {} darts! High confidence: {:.1}%", result.scores.len(), result.confidence * 100.0)
-                } else { 
+                } else {
                     "⚠️ Low confidence detection - no dart score could be verified.".to_string()
                 }
             }));