feat: implement core RustAutoScoreEngine framework including data loading, model architecture, training loop, inference, and GUI server

.gitignore

@@ -1,27 +1,17 @@
 # Rust
-target/
-debug/
-release/
+/target/
+**/*.rs.bk
+Cargo.lock
 
-# IDEs
-.vscode/
-.idea/
-*.swp
-*.swo
-*~
-.DS_Store
+# Dataset (DONT COMMIT Large 16K+ Images)
+/dataset/
+/dataset/*/
+!/dataset/labels.json
 
-# Data & Model Weights
-model_weights.bin
-model_weights/
-dataset/images/
-dataset/cropped_images/
-dataset/800/
-dataset/__pycache__/
+# Operating System
+.DS_Store
+Thumbs.db
 
-# Logs & Temp
-*.log
-logs/
-tmp/
-temp/
-*.tmp
+# Optional: You can keep model_weights.bin if it's small (~1.1 MB)
+# to let others use the GUI immediately.
+# model_weights.bin

README.md

@@ -1,144 +1,43 @@
-# RustAutoScoreEngine
-### High-Performance AI Dart Scoring Powered by Rust & Burn
+# 🎯 DartVision AI - Rust AutoScore Engine
 
-<div align="center">
+A high-performance dart scoring system built with **Rust** and the **Burn** Deep Learning framework. This project is a port of the original YOLOv4-tiny based DartVision, optimized for speed and safety.
 
-[![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)
+![DartVision Dashboard](https://raw.githubusercontent.com/iambhabha/RustAutoScoreEngine/main/docs/dashboard.png)
 
-**A professional-grade, real-time dart scoring engine built entirely in Rust.**
+## 🚀 Quick Start (GUI Dashboard)
+The project comes with pre-trained weights (`model_weights.bin`). You can start the professional dashboard immediately:
 
-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.
-
-- **Model Weights Link**: [Neural Weights & TFLite (Google Drive)](https://drive.google.com/file/d/1ZEvuzg9zYbPd1FdZgV6v1aT4sqbqmLqp/view?usp=sharing)
-- **Dataset Source**: [DeepDarts (IEEE Dataport)](https://ieee-dataport.org/open-access/deepdarts-dataset)
-- **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
+cargo run --release -- gui
 ```
+Then open: **[http://127.0.0.1:8080](http://127.0.0.1:8080)**
 
----
-
-## Quick Start Guide
+## 📈 Training
+To train the model on your own dataset (requires `dataset/labels.json` and images):
 
-### Step 1: Training the AI Model
-To optimize the neural network for your local environment, run the training mode:
 ```bash
-# Starts the training cycle
-cargo run -- train
+cargo run --release -- train
 ```
+*Note: The model saves checkpoints every 100 batches. You can stop and resume training anytime.*
 
-### Step 2: Running the Professional Dashboard
-Launch the visual testing interface to see real-time detections and scores:
-```bash
-# Starts the modular Axum web server
-cargo run -- gui
-```
-**Features:**
-- **Dynamic Image Upload**: Test board imagery via the premium glassmorphism dashboard.
-- **Neural Point Mapping**: Inspect detected calibration corners and dart locations with hover effects.
-- **Real-time Scoring**: Instant sector calculation based on official BDO geometry.
+## 🔬 Testing
+To run a single image inference and see the neural mapping results:
 
-### Step 3: CLI Model Testing
-Test individual images directly from the terminal:
 ```bash
-# Test a specific image
-cargo run -- test path/to/image.jpg
+cargo run --release -- test <path_to_image>
 ```
 
----
-
-## Mobile Deployment
-
-This engine is built on Burn, supporting multiple paths for Android and iOS integration:
+## ✨ Features
+- **Neural Mapping:** Real-time detection of darts and 4 calibration corners.
+- **Smart Scoring:** Automatic coordinate reconstruction and BDO standard scoring.
+- **Reliability Checks:** GUI displays per-point confidence percentages (CAL Sync) to ensure accuracy.
+- **GPU Accelerated:** Powered by `WGPUDevice` and `Burn` for ultra-fast inference.
 
-### 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.
+## 🛠 Project Structure
+- `src/model.rs`: YOLOv4-tiny architecture in Burn.
+- `src/loss.rs`: DIOU Loss + Objectness + Class entropy implementation.
+- `src/server.rs`: Axum-based web server for the GUI.
+- `static/index.html`: Premium Glassmorphism interface with SVG overlays.
 
 ---
-
-## Hardware Optimization
-
-This engine is optimized for GPU execution using the WGPU backend. Depending on your specific hardware, you may need to adjust the training intensity:
-
-### GPU VRAM Management
-If you encounter **Out-of-Memory (OOM)** errors during training, you should reduce the **Batch Size**.
-
-- **Where to change**: Open `src/main.rs` and modify the `batch_size` parameter.
-- **Recommendations**:
-  - **4GB VRAM**: Batch Size 1 (Safe default)
-  - **8GB VRAM**: Batch Size 4
-  - **12GB+ VRAM**: Batch Size 8
-  - **RTX 5080 High-End**: Batch Size 16 (Optimal for ultra-fast convergence)
-- **Impact**: Larger batch sizes provide more stable gradients but require exponentially more VRAM.
-
----
-
-## 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
-
-- **Core AI Framework**: [Burn - A Flexible & Comprehensive Deep Learning Framework](https://burn.dev/)
-- **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>
+*Created by [iambhabha](https://github.com/iambhabha)*

model_weights.bin

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

src/data.rs

@@ -69,17 +69,24 @@ impl<B: Backend> DartBatcher<B> {
 
     pub fn batch_manual(&self, items: Vec<Annotation>) -> DartBatch<B> {
         let batch_size = items.len();
-        let input_res: usize = 416; // Standard YOLO 416 resolution for GPU stability
-        let grid_size: usize = 26;  // 416 / 16 (stride accumulation) = 26
-        let num_channels: usize = 30; // 3 anchors * (x,y,w,h,obj,p0...p4)
-        
+        // Use 800 to match original Python training config (configs/deepdarts_d1.yaml: input_size: 800)
+        let input_res: usize = 800;
+        // For tiny YOLO: grid = input_res / 16. 800/16 = 50
+        let grid_size: usize = 50;
+        let num_anchors: usize = 3;
+        let num_attrs: usize = 10; // x, y, w, h, obj, cls0..cls4
+        let num_channels: usize = num_anchors * num_attrs; // = 30
+
         let mut images_list = Vec::with_capacity(batch_size);
         let mut target_raw = vec![0.0f32; batch_size * num_channels * grid_size * grid_size];
 
         for (b_idx, item) in items.iter().enumerate() {
             // 1. Process Image
             let path = format!("dataset/800/{}/{}", item.img_folder, item.img_name);
-            let img = image::open(&path).unwrap_or_else(|_| image::DynamicImage::new_rgb8(input_res as u32, input_res as u32));
+            let img = image::open(&path).unwrap_or_else(|_| {
+                println!("⚠️ [Data] Image not found: {}", path);
+                image::DynamicImage::new_rgb8(input_res as u32, input_res as u32)
+            });
             let resized = img.resize_exact(input_res as u32, input_res as u32, 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])
@@ -87,23 +94,36 @@ impl<B: Backend> DartBatcher<B> {
             images_list.push(TensorData::new(pixels, [input_res, input_res, 3]));
 
             for (i, p) in item.xy.iter().enumerate() {
-                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;
+                // Clamp coordinates to valid grid range
+                let norm_x = p[0].clamp(0.0, 1.0 - 1e-5);
+                let norm_y = p[1].clamp(0.0, 1.0 - 1e-5);
 
-                // 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 gx = (norm_x * grid_size as f32).floor() as usize;
+                let gy = (norm_y * grid_size as f32).floor() as usize;
 
+                // Grid-relative offset (0..1 within cell)
+                let tx = norm_x * grid_size as f32 - gx as f32;
+                let ty = norm_y * grid_size as f32 - gy as f32;
+
+                // Python convention: cal points i=0..3 -> cls=1..4, dart i>=4 -> cls=0
                 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] = 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)
-                target_raw[base_idx + (5 + cls) * grid_size * grid_size] = 1.0; // Class prob
+
+                // Assign this keypoint to anchor (cls % num_anchors) so all 3 anchors get used
+                let anchor_idx = cls % num_anchors;
+
+                // Flat index layout: [batch, anchor, attr, gy, gx]
+                // => flat = b * (3*10*G*G) + anchor * (10*G*G) + attr * (G*G) + gy*G + gx
+                let cell_base = b_idx * num_channels * grid_size * grid_size
+                    + anchor_idx * num_attrs * grid_size * grid_size
+                    + gy * grid_size
+                    + gx;
+
+                target_raw[cell_base + 0 * grid_size * grid_size] = tx;   // x offset
+                target_raw[cell_base + 1 * grid_size * grid_size] = ty;   // y offset
+                target_raw[cell_base + 2 * grid_size * grid_size] = 0.025; // w (bbox_size from config)
+                target_raw[cell_base + 3 * grid_size * grid_size] = 0.025; // h
+                target_raw[cell_base + 4 * grid_size * grid_size] = 1.0;   // objectness
+                target_raw[cell_base + (5 + cls) * grid_size * grid_size] = 1.0; // class prob
             }
         }
 

src/inference.rs

@@ -17,7 +17,7 @@ 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(416, 416, image::imageops::FilterType::Triangle);
+    let resized = img.resize_exact(800, 800, image::imageops::FilterType::Triangle);
     let pixels: Vec<f32> = resized
         .to_rgb8()
         .pixels()
@@ -30,7 +30,7 @@ pub fn run_inference<B: Backend>(device: &B::Device, image_path: &str) {
         })
         .collect();
 
-    let data = TensorData::new(pixels, [416, 416, 3]);
+    let data = TensorData::new(pixels, [800, 800, 3]);
     let input = Tensor::<B, 3>::from_data(data, device)
         .unsqueeze::<4>()
         .permute([0, 3, 1, 2]);
@@ -38,12 +38,12 @@ pub fn run_inference<B: Backend>(device: &B::Device, image_path: &str) {
     println!("🚀 Running MODEL Prediction...");
     let (out16, _out32) = model.forward(input);
 
-    // out16 shape: [1, 30, 26, 26]
-    // 1. Extract Objectness (Channel 4 of first anchor)
+    // out16 shape: [1, 30, 50, 50] — 800/16 = 50
+    // Extract Objectness (Channel 4 of first anchor)
     let obj = burn::tensor::activation::sigmoid(out16.clone().narrow(1, 4, 1));
 
-    // 2. Find highest confidence cell in 26x26 grid
-    let (max_val, _) = obj.reshape([1, 676]).max_dim_with_indices(1);
+    // Find highest confidence cell in 50x50 grid
+    let (max_val, _) = obj.reshape([1_usize, 2500]).max_dim_with_indices(1);
     let confidence: f32 = max_val
         .to_data()
         .convert::<f32>()

src/main.rs

@@ -1,9 +1,9 @@
+use burn::backend::wgpu::WgpuDevice;
+use burn::backend::Wgpu;
 use rust_auto_score_engine::args::{AppArgs, Command};
 use rust_auto_score_engine::server::start_gui;
-use rust_auto_score_engine::train::{train, TrainingConfig};
 use rust_auto_score_engine::tests::test_model;
-use burn::backend::wgpu::WgpuDevice;
-use burn::backend::Wgpu;
+use rust_auto_score_engine::train::{train, TrainingConfig};
 
 fn main() {
     let app_args = AppArgs::parse();

src/model.rs

@@ -28,61 +28,64 @@ impl<B: Backend> ConvBlock<B> {
     }
 }
 
+/// DartVision model ported from YOLOv4-tiny.
+/// Input: [B, 3, 800, 800] (matching Python config: input_size=800)
+/// Output grid: [B, 30, 50, 50] — 800 / 2^4 = 50
+/// 30 channels = 3 anchors × 10 attrs (x, y, w, h, obj, cls0..cls4)
 #[derive(Module, Debug)]
 pub struct DartVisionModel<B: Backend> {
-    // Increased capacity: High resolution but enough width to map complex features
-    l1: ConvBlock<B>, // 3 -> 32
-    p1: MaxPool2d,
-    l2: ConvBlock<B>, // 32 -> 32
-    p2: MaxPool2d,
-    l3: ConvBlock<B>, // 32 -> 64
-    p3: MaxPool2d,
-    l4: ConvBlock<B>, // 64 -> 64
-    p4: MaxPool2d,
-    l5: ConvBlock<B>, // 64 -> 128
-    l6: ConvBlock<B>, // 128 -> 128
-
-    head_32: Conv2d<B>, // Final detection head (30 channels for 3 anchors)
+    l1: ConvBlock<B>,  // 3   -> 32
+    p1: MaxPool2d,     // /2 -> 400
+    l2: ConvBlock<B>,  // 32  -> 32
+    p2: MaxPool2d,     // /2 -> 200
+    l3: ConvBlock<B>,  // 32  -> 64
+    p3: MaxPool2d,     // /2 -> 100
+    l4: ConvBlock<B>,  // 64  -> 64
+    p4: MaxPool2d,     // /2 ->  50
+    l5: ConvBlock<B>,  // 64  -> 128
+    l6: ConvBlock<B>,  // 128 -> 128
+    head: Conv2d<B>,   // 128 -> 30  (detection head)
 }
 
 impl<B: Backend> DartVisionModel<B> {
     pub fn new(device: &B::Device) -> Self {
-        let l1 = ConvBlock::new(3, 32, [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(32, 32, [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(32, 64, [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(64, 64, [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(64, 128, [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,dart,cal1,cal2,cal3,cal4)
-        let head_32 = Conv2dConfig::new([128, 30], [1, 1]).init(device);
+        // 30 = 3 anchors × (x, y, w, h, obj, dart, cal1, cal2, cal3, cal4)
+        let head = Conv2dConfig::new([128, 30], [1, 1]).init(device);
 
-        Self { l1, p1, l2, p2, l3, p3, l4, p4, l5, l6, head_32 }
+        Self { l1, p1, l2, p2, l3, p3, l4, p4, l5, l6, head }
     }
 
+    /// Returns (output_50, output_50) — second is a clone kept for API compat.
     pub fn forward(&self, x: Tensor<B, 4>) -> (Tensor<B, 4>, Tensor<B, 4>) {
-        let x = self.l1.forward(x); // 800
-        let x = self.p1.forward(x); // 400
-        let x = self.l2.forward(x); // 400
-        let x = self.p2.forward(x); // 200
-        let x = self.l3.forward(x); // 200
-        let x = self.p3.forward(x); // 100
-        let x = self.l4.forward(x); // 100
-        let x = self.p4.forward(x); // 50
-        
-        let x50 = self.l5.forward(x); // 50
-        let x50 = self.l6.forward(x50); // 50
-
-        let out50 = self.head_32.forward(x50);
-        
-        (out50.clone(), out50)
+        let x = self.l1.forward(x);  // [B, 32, 800, 800]
+        let x = self.p1.forward(x);  // [B, 32, 400, 400]
+        let x = self.l2.forward(x);  // [B, 32, 400, 400]
+        let x = self.p2.forward(x);  // [B, 32, 200, 200]
+        let x = self.l3.forward(x);  // [B, 64, 200, 200]
+        let x = self.p3.forward(x);  // [B, 64, 100, 100]
+        let x = self.l4.forward(x);  // [B, 64, 100, 100]
+        let x = self.p4.forward(x);  // [B, 64,  50,  50]
+        let x = self.l5.forward(x);  // [B, 128, 50,  50]
+        let x = self.l6.forward(x);  // [B, 128, 50,  50]
+        // NOTE: Do NOT clone here — cloning an autodiff tensor duplicates the full
+        // computation graph in memory. train.rs only uses the first output.
+        let out = self.head.forward(x);  // [B, 30, 50, 50]
+        let out2 = out.clone().detach(); // detached copy for API compat (no grad graph)
+        (out, out2)
     }
 }

src/server.rs

@@ -19,6 +19,7 @@ use tower_http::cors::CorsLayer;
 struct PredictResult {
     confidence: f32,
     keypoints: Vec<f32>,
+    confidences: Vec<f32>, // Individual confidence for each point
     scores: Vec<String>,
 }
 
@@ -50,7 +51,7 @@ pub async fn start_gui(device: WgpuDevice) {
             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 resized = img.resize_exact(800, 800, image::imageops::FilterType::Triangle);
             let pixels: Vec<f32> = resized
                 .to_rgb8()
                 .pixels()
@@ -63,14 +64,17 @@ pub async fn start_gui(device: WgpuDevice) {
                 })
                 .collect();
 
-            let tensor_data = TensorData::new(pixels, [1, 416, 416, 3]);
+            let tensor_data = TensorData::new(pixels, [1, 800, 800, 3]);
             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]);
+            // out16 shape: [1, 30, 50, 50] — 800/16 = 50
+            // Reshape to separate anchors: [1, 3, 10, 50, 50]
+            let out_reshaped = out16.reshape([1, 3, 10, 50, 50]);
+            let grid_size: usize = 50;
+            let num_cells: usize = grid_size * grid_size; // 2500
 
             // 1.5 Debug: Raw Statistics
             println!(
@@ -80,6 +84,7 @@ pub async fn start_gui(device: WgpuDevice) {
             );
 
             let mut final_points = vec![0.0f32; 8]; // 4 corners
+            let mut final_confs = vec![0.0f32; 4];  // 4 corner confs
             let mut max_conf = 0.0f32;
 
             // 2. Extract best calibration corner for each class 1 to 4
@@ -101,14 +106,14 @@ pub async fn start_gui(device: WgpuDevice) {
                     );
                     let score = obj.mul(prob);
 
-                    let (val, idx) = score.reshape([1, 676]).max_dim_with_indices(1);
+                    let (val, idx) = score.reshape([1_usize, num_cells]).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);
+                        best_grid = (f_idx % grid_size, f_idx / grid_size);
 
                         let sx = burn::tensor::activation::sigmoid(
                             out_reshaped
@@ -147,14 +152,16 @@ pub async fn start_gui(device: WgpuDevice) {
                         
                         // Reconstruct Absolute Normalized Coord (0-1)
                         best_pt = [
-                            (best_grid.0 as f32 + sx) / 26.0,
-                            (best_grid.1 as f32 + sy) / 26.0,
+                            (best_grid.0 as f32 + sx) / grid_size as f32,
+                            (best_grid.1 as f32 + sy) / grid_size as f32,
                         ];
                     }
                 }
 
                 final_points[(cls_idx - 1) * 2] = best_pt[0];
                 final_points[(cls_idx - 1) * 2 + 1] = best_pt[1];
+                final_confs[cls_idx - 1] = best_s;
+
                 if best_s > max_conf {
                     max_conf = best_s;
                 }
@@ -215,14 +222,14 @@ pub async fn start_gui(device: WgpuDevice) {
                 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 score = obj.mul(prob).reshape([1_usize, num_cells]);
 
                 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 gx = f_idx % 26;
-                let gy = f_idx / 26;
+                let gx = f_idx % grid_size;
+                let gy = f_idx / grid_size;
 
                 let dsx = burn::tensor::activation::sigmoid(
                     out_reshaped
@@ -247,8 +254,8 @@ pub async fn start_gui(device: WgpuDevice) {
                 .as_slice::<f32>()
                 .unwrap()[0];
 
-                let dx = (gx as f32 + dsx) / 26.0;
-                let dy = (gy as f32 + dsy) / 26.0;
+                let dx = (gx as f32 + dsx) / grid_size as f32;
+                let dy = (gy as f32 + dsy) / grid_size as f32;
 
                 if s > 0.005 {
                     println!(
@@ -266,6 +273,7 @@ pub async fn start_gui(device: WgpuDevice) {
                 if *s > 0.05 {
                     final_points.push(pt[0]);
                     final_points.push(pt[1]);
+                    final_confs.push(*s);
                     println!(
                         "   ✅ Best Dart Picked: Conf: {:.2}%, Coord: {:?}",
                         s * 100.0,
@@ -317,6 +325,7 @@ pub async fn start_gui(device: WgpuDevice) {
             let _ = req.response_tx.send(PredictResult {
                 confidence: max_conf,
                 keypoints: final_points,
+                confidences: final_confs,
                 scores: final_scores,
             });
         }
@@ -358,6 +367,7 @@ async fn predict_handler(
             let result = res_rx.await.unwrap_or(PredictResult {
                 confidence: 0.0,
                 keypoints: vec![],
+                confidences: vec![],
                 scores: vec![],
             });
 
@@ -365,7 +375,9 @@ async fn predict_handler(
                 "status": "success",
                 "confidence": result.confidence,
                 "keypoints": result.keypoints,
+                "confidences": result.confidences,
                 "scores": result.scores,
+                "is_calibrated": result.confidences.iter().take(4).all(|&c| c > 0.05),
                 "message": if result.confidence > 0.1 {
                     format!("✅ Found {} darts! High confidence: {:.1}%", result.scores.len(), result.confidence * 100.0)
                 } else {

src/tests.rs

@@ -20,9 +20,9 @@ pub fn test_model(device: WgpuDevice, img_path: &str) {
 
     let img = image::open(img_path).unwrap_or_else(|_| {
         println!("❌ Image not found at {}. Using random tensor.", img_path);
-        image::DynamicImage::new_rgb8(416, 416)
+        image::DynamicImage::new_rgb8(800, 800)
     });
-    let resized = img.resize_exact(416, 416, image::imageops::FilterType::Triangle);
+    let resized = img.resize_exact(800, 800, image::imageops::FilterType::Triangle);
     let pixels: Vec<f32> = resized
         .to_rgb8()
         .pixels()
@@ -35,12 +35,12 @@ pub fn test_model(device: WgpuDevice, img_path: &str) {
         })
         .collect();
 
-    let tensor_data = TensorData::new(pixels, [1, 416, 416, 3]);
+    let tensor_data = TensorData::new(pixels, [1, 800, 800, 3]);
     let input = Tensor::<Wgpu, 4>::from_data(tensor_data, &device).permute([0, 3, 1, 2]);
     let (out, _): (Tensor<Wgpu, 4>, _) = model.forward(input);
 
     let obj = burn::tensor::activation::sigmoid(out.clone().narrow(1, 4, 1));
-    let (max_val, _) = obj.reshape([1, 676]).max_dim_with_indices(1);
+    let (max_val, _) = obj.reshape([1_usize, 2500]).max_dim_with_indices(1);
 
     let score = max_val
         .to_data()

src/train.rs

@@ -66,13 +66,14 @@ pub fn train<B: AutodiffBackend>(device: Device<B>, dataset_path: &str, config:
             let loss = diou_loss(out16, batch.targets);
             batch_count += 1;
 
-            // Print every 10 batches to keep terminal clean and avoid stdout sync lag
+            // Print every 20 batches — use detach() to avoid cloning the full autodiff graph
             if batch_count % 20 == 0 || batch_count == 1 {
+                let loss_val = loss.clone().detach().into_scalar();
                 println!(
                     "   [Epoch {}] Batch {: >3} | Loss: {:.6}",
                     epoch,
                     batch_count,
-                    loss.clone().into_scalar()
+                    loss_val
                 );
             }
 

static/index.html

@@ -3,7 +3,7 @@
 <head>
     <meta charset="UTF-8">
     <meta name="viewport" content="width=device-width, initial-scale=1.0">
-    <title>DartVision AI - Smart Scoring Dashboard</title>
+    <title>Rust AutoScore Engine - Smart Dashboard</title>
     <link rel="preconnect" href="https://fonts.googleapis.com">
     <link rel="preconnect" href="https://fonts.gstatic.com" crossorigin>
     <link href="https://fonts.googleapis.com/css2?family=Outfit:wght@300;400;600;800&display=swap" rel="stylesheet">
@@ -235,8 +235,8 @@
         }
 
         @keyframes pulse-marker {
-            0%, 100% { r: 6; opacity: 1; }
-            50% { r: 10; opacity: 0.6; }
+            0%, 100% { r: 8; opacity: 1; }
+            50% { r: 8; opacity: 0.8; }
         }
 
         .result-item {
@@ -269,7 +269,7 @@
 <body>
     <div class="bg-grid"></div>
     <header>
-        <h1>DARTVISION <span style="font-weight: 200; opacity: 0.4;">CORE</span></h1>
+        <h1>RUST AUTO SCORE <span style="font-weight: 200; opacity: 0.4;">ENGINE</span></h1>
         <p class="subtitle">Neural Scoring & Board Analytics</p>
     </header>
 
@@ -296,6 +296,10 @@
                 <div class="stat-label">Model Status</div>
                 <div class="stat-value" id="status-text" style="font-size: 1.4rem; color: var(--primary);">System Ready</div>
             </div>
+            <div class="stat-card" id="cal-card">
+                <div class="stat-label">Calibration Sync</div>
+                <div class="stat-value" id="cal-status" style="font-size: 1.2rem; color: #8892b0;">Pending...</div>
+            </div>
             <div class="stat-card">
                 <div class="stat-label">AI Confidence</div>
                 <div class="stat-value" id="conf-val">0.0%</div>
@@ -358,7 +362,7 @@
                     document.getElementById('status-text').innerText = 'Analysis Complete';
                     document.getElementById('status-text').style.color = 'var(--primary)';
                     updateUI(data);
-                    drawKeypoints(data.keypoints);
+                    drawKeypoints(data.keypoints, data.confidences);
                 } else {
                     document.getElementById('status-text').innerText = 'Analysis Failed';
                     document.getElementById('status-text').style.color = 'var(--accent)';
@@ -375,6 +379,15 @@
             const conf = (data.confidence * 100).toFixed(1);
             document.getElementById('conf-val').innerText = `${conf}%`;
             document.getElementById('conf-fill').style.width = `${conf}%`;
+
+            const calStatus = document.getElementById('cal-status');
+            if (data.is_calibrated) {
+                calStatus.innerText = "VERIFIED ✅";
+                calStatus.style.color = "var(--primary)";
+            } else {
+                calStatus.innerText = "FAILED ❌";
+                calStatus.style.color = "var(--accent)";
+            }
             
             let resultHtml = `<div style="margin: 1.5rem 0 1rem 0; font-size: 0.95rem; line-height: 1.6; color: rgba(255,255,255,0.9);">${data.message}</div>`;
             if (data.keypoints && data.keypoints.length >= 8) {
@@ -387,12 +400,17 @@
                     const name = names[classIdx] || `Dart ${Math.floor(classIdx - 3)}`;
                     const x = data.keypoints[i].toFixed(3);
                     const y = data.keypoints[i+1].toFixed(3);
+                    const ptConf = ((data.confidences[classIdx] || 0) * 100).toFixed(0);
+                    const isReliable = ptConf > 10;
                     
                     let scoreHtml = "";
                     if (classIdx >= 4 && data.scores && data.scores[classIdx - 4]) {
-                        scoreHtml = `<span class="badge badge-dart">${data.scores[classIdx - 4]}</span>`;
+                        scoreHtml = `<div style="display: flex; flex-direction: column; align-items: flex-end; gap: 4px;">
+                                        <span class="badge badge-dart">${data.scores[classIdx - 4]}</span>
+                                        <span style="font-size: 0.65rem; color: #8892b0; font-weight: 600;">CONF: ${ptConf}%</span>
+                                     </div>`;
                     } else if (isCal) {
-                        scoreHtml = `<span class="badge badge-cal" style="font-size: 0.6rem;">LOCKED</span>`;
+                        scoreHtml = `<span class="badge" style="background: ${isReliable ? 'rgba(0,255,136,0.1)' : 'rgba(255,77,77,0.1)'}; color: ${isReliable ? 'var(--primary)' : 'var(--accent)'}; font-size: 0.6rem; border: 1px solid">${isReliable ? ptConf+'% OK' : ptConf+'% ERR'}</span>`;
                     }
 
                     resultHtml += `
@@ -412,7 +430,7 @@
             while (svgOverlay.firstChild) svgOverlay.removeChild(svgOverlay.firstChild);
         }
 
-        function drawKeypoints(pts) {
+        function drawKeypoints(pts, confs) {
             clearKeypoints();
             if (!pts || pts.length === 0) return;
 
@@ -425,20 +443,21 @@
                 const width = rect.width;
                 const height = rect.height;
 
-                const classNames = ["CALIBRATION CORNER 1", "CALIBRATION CORNER 2", "CALIBRATION CORNER 3", "CALIBRATION CORNER 4", "DART POINT"];
                 for (let i = 0; i < pts.length; i += 2) {
                     const classIdx = i / 2;
                     const isCal = classIdx < 4;
                     const x = pts[i] * width + offsetX;
                     const y = pts[i+1] * height + offsetY;
-                    const name = classNames[classIdx] || `DART POINT`;
+                    
+                    const ptConf = ((confs[classIdx] || 0) * 100).toFixed(0);
+                    const name = isCal ? `CAL ${classIdx+1} (${ptConf}%)` : `DART (${ptConf}%)`;
 
                     const group = document.createElementNS("http://www.w3.org/2000/svg", "g");
                     
                     const circle = document.createElementNS("http://www.w3.org/2000/svg", "circle");
                     circle.setAttribute("cx", x);
                     circle.setAttribute("cy", y);
-                    circle.setAttribute("r", 7);
+                    circle.setAttribute("r", 8);
                     circle.setAttribute("class", "keypoint-marker");
                     if (!isCal) {
                         circle.style.fill = "#ff4d4d";
@@ -448,7 +467,7 @@
                     const labelBg = document.createElementNS("http://www.w3.org/2000/svg", "rect");
                     labelBg.setAttribute("x", x + 15);
                     labelBg.setAttribute("y", y - 25);
-                    labelBg.setAttribute("width", name.length * 7 + 12);
+                    labelBg.setAttribute("width", name.length * 7 + 15);
                     labelBg.setAttribute("height", "22");
                     labelBg.setAttribute("rx", "11");
                     labelBg.setAttribute("fill", "rgba(0,0,0,0.7)");