Initial commit

.gitattributes

@@ -0,0 +1,5 @@
+# Auto detect text files and perform LF normalization
+* text=auto
+*.bin filter=lfs diff=lfs merge=lfs -text
+*.png filter=lfs diff=lfs merge=lfs -text
+*.pkl filter=lfs diff=lfs merge=lfs -text

.gitignore

@@ -0,0 +1,27 @@
+# Rust
+target/
+debug/
+release/
+
+# IDEs
+.vscode/
+.idea/
+*.swp
+*.swo
+*~
+.DS_Store
+
+# Data & Model Weights
+model_weights.bin
+model_weights/
+dataset/images/
+dataset/cropped_images/
+dataset/800/
+dataset/__pycache__/
+
+# Logs & Temp
+*.log
+logs/
+tmp/
+temp/
+*.tmp

Cargo.toml

@@ -0,0 +1,15 @@
+[package]
+name = "rust_auto_score_engine"
+version = "0.1.0"
+edition = "2021"
+
+[dependencies]
+burn = { version = "0.16.0", features = ["train", "wgpu"] }
+serde = { version = "1.0", features = ["derive"] }
+serde_json = "1.0"
+image = "0.25"
+ndarray = "0.16"
+axum = { version = "0.7", features = ["multipart"] }
+tower-http = { version = "0.5", features = ["fs", "cors"] }
+tokio = { version = "1.0", features = ["full"] }
+base64 = "0.22"

dataset/annotate.py

@@ -0,0 +1,410 @@
+import os
+import os.path as osp
+import cv2
+import pandas as pd
+import numpy as np
+from yacs.config import CfgNode as CN
+import argparse
+
+# used to convert dart angle to board number
+BOARD_DICT = {
+    0: '13', 1: '4', 2: '18', 3: '1', 4: '20', 5: '5', 6: '12', 7: '9', 8: '14', 9: '11',
+    10: '8', 11: '16', 12: '7', 13: '19', 14: '3', 15: '17', 16: '2', 17: '15', 18: '10', 19: '6'
+}
+
+
+def crop_board(img_path, bbox=None, crop_info=(0, 0, 0), crop_pad=1.1):
+    img = cv2.imread(img_path)
+    if bbox is None:
+        x, y, r = crop_info
+        r = int(r * crop_pad)
+        bbox = [y-r, y+r, x-r, x+r]
+    crop = img[bbox[0]:bbox[1], bbox[2]:bbox[3]]
+    return crop, bbox
+
+
+def on_click(event, x, y, flags, param):
+    global xy, img_copy
+    h, w = img_copy.shape[:2]
+    if event == cv2.EVENT_LBUTTONDOWN:
+        if len(xy) < 7:
+            xy.append([x/w, y/h])
+            print_xy()
+        else:
+            print('Already annotated 7 points.')
+
+
+def print_xy():
+    global xy
+    names = {
+        0: 'cal_1', 1: 'cal_2', 2: 'cal_3', 3: 'cal_4',
+        4: 'dart_1', 5: 'dart_2', 6: 'dart_3'}
+    print('{}: {}'.format(names[len(xy)-1], xy[-1]))
+
+
+def get_ellipses(xy, r_double=0.17, r_treble=0.1074):
+    c = np.mean(xy[:4], axis=0)
+    a1_double = ((xy[2][0] - xy[3][0]) ** 2 + (xy[2][1] - xy[3][1]) ** 2) ** 0.5 / 2
+    a2_double = ((xy[0][0] - xy[1][0]) ** 2 + (xy[0][1] - xy[1][1]) ** 2) ** 0.5 / 2
+    a1_treble = a1_double * (r_treble / r_double)
+    a2_treble = a2_double * (r_treble / r_double)
+    angle = np.arctan((xy[3, 1] - c[1]) / (xy[3, 0] - c[0])) / np.pi * 180
+    return c, [a1_double, a2_double], [a1_treble, a2_treble], angle
+
+
+def draw_ellipses(img, xy, num_pts=7):
+    # img must be uint8
+    xy = np.array(xy)
+    if xy.shape[0] > num_pts:
+        xy = xy.reshape((-1, 2))
+    if np.mean(xy) < 1:
+        h, w = img.shape[:2]
+        xy[:, 0] *= w
+        xy[:, 1] *= h
+    c, a_double, a_treble, angle = get_ellipses(xy)
+    angle = np.arctan((xy[3,1]-c[1])/(xy[3,0]-c[0]))/np.pi*180
+    cv2.ellipse(img, (int(round(c[0])), int(round(c[1]))),
+                (int(round(a_double[0])), int(round(a_double[1]))),
+                int(round(angle)), 0, 360, (255, 255, 255))
+    cv2.ellipse(img, (int(round(c[0])), int(round(c[1]))),
+                (int(round(a_treble[0])), int(round(a_treble[1]))),
+                int(round(angle)), 0, 360, (255, 255, 255))
+    return img
+
+
+def get_circle(xy):
+    c = np.mean(xy[:4], axis=0)
+    r = np.mean(np.linalg.norm(xy[:4] - c, axis=-1))
+    return c, r
+
+
+def board_radii(r_d, cfg):
+    r_t = r_d * (cfg.board.r_treble / cfg.board.r_double)  # treble radius, in px
+    r_ib = r_d * (cfg.board.r_inner_bull / cfg.board.r_double)  # inner bull radius, in px
+    r_ob = r_d * (cfg.board.r_outer_bull / cfg.board.r_double) # outer bull radius, in px
+    w_dt = cfg.board.w_double_treble * (r_d / cfg.board.r_double)  # width of double and treble
+    return r_t, r_ob, r_ib, w_dt
+
+
+def draw_circles(img, xy, cfg, color=(255, 255, 255)):
+    c, r_d = get_circle(xy)  # double radius
+    r_t, r_ob, r_ib, w_dt = board_radii(r_d, cfg)
+    for r in [r_d, r_d - w_dt, r_t, r_t - w_dt, r_ib, r_ob]:
+        cv2.circle(img, (round(c[0]), round(c[1])), round(r), color)
+    return img
+
+
+def transform(xy, img=None, angle=9, M=None):
+
+    if xy.shape[-1] == 3:
+        has_vis = True
+        vis = xy[:, 2:]
+        xy = xy[:, :2]
+    else:
+        has_vis = False
+
+    if img is not None and np.mean(xy[:4]) < 1:
+        h, w = img.shape[:2]
+        xy *= [[w, h]]
+
+    if M is None:
+        c, r = get_circle(xy)  # not necessarily a circle
+        # c is center of 4 calibration points, r is mean distance from center to calibration points
+
+        src_pts = xy[:4].astype(np.float32)
+        dst_pts = np.array([
+            [c[0] - r * np.sin(np.deg2rad(angle)), c[1] - r * np.cos(np.deg2rad(angle))],
+            [c[0] + r * np.sin(np.deg2rad(angle)), c[1] + r * np.cos(np.deg2rad(angle))],
+            [c[0] - r * np.cos(np.deg2rad(angle)), c[1] + r * np.sin(np.deg2rad(angle))],
+            [c[0] + r * np.cos(np.deg2rad(angle)), c[1] - r * np.sin(np.deg2rad(angle))]
+        ]).astype(np.float32)
+        M = cv2.getPerspectiveTransform(src_pts, dst_pts)
+
+    xyz = np.concatenate((xy, np.ones((xy.shape[0], 1))), axis=-1).astype(np.float32)
+    xyz_dst = np.matmul(M, xyz.T).T
+    xy_dst = xyz_dst[:, :2] / xyz_dst[:, 2:]
+
+    if img is not None:
+        img = cv2.warpPerspective(img.copy(), M, (img.shape[1], img.shape[0]))
+        xy_dst /= [[w, h]]
+
+    if has_vis:
+        xy_dst = np.concatenate([xy_dst, vis], axis=-1)
+
+    return xy_dst, img, M
+
+
+def get_dart_scores(xy, cfg, numeric=False):
+    valid_cal_pts = xy[:4][(xy[:4, 0] > 0) & (xy[:4, 1] > 0)]
+    if xy.shape[0] <= 4 or valid_cal_pts.shape[0] < 4:  # missing calibration point
+        return []
+    xy, _, _ = transform(xy.copy(), angle=0)
+    c, r_d = get_circle(xy)
+    r_t, r_ob, r_ib, w_dt = board_radii(r_d, cfg)
+    xy -= c
+    angles = np.arctan2(-xy[4:, 1], xy[4:, 0]) / np.pi * 180
+    angles = [a + 360 if a < 0 else a for a in angles]  # map to 0-360
+    distances = np.linalg.norm(xy[4:], axis=-1)
+    scores = []
+    for angle, dist in zip(angles, distances):
+        if dist > r_d:
+            scores.append('0')
+        elif dist <= r_ib:
+            scores.append('DB')
+        elif dist <= r_ob:
+            scores.append('B')
+        else:
+            number = BOARD_DICT[int(angle / 18)]
+            if dist <= r_d and dist > r_d - w_dt:
+                scores.append('D' + number)
+            elif dist <= r_t and dist > r_t - w_dt:
+                scores.append('T' + number)
+            else:
+                scores.append(number)
+    if numeric:
+        for i, s in enumerate(scores):
+            if 'B' in s:
+                if 'D' in s:
+                    scores[i] = 50
+                else:
+                    scores[i] = 25
+            else:
+                if 'D' in s or 'T' in s:
+                    scores[i] = int(s[1:])
+                    scores[i] = scores[i] * 2 if 'D' in s else scores[i] * 3
+                else:
+                    scores[i] = int(s)
+    return scores
+
+
+def draw(img, xy, cfg, circles, score, color=(255, 255, 0)):
+    xy = np.array(xy)
+    if xy.shape[0] > 7:
+        xy = xy.reshape((-1, 2))
+    if np.mean(xy) < 1:
+        h, w = img.shape[:2]
+        xy[:, 0] *= w
+        xy[:, 1] *= h
+    if xy.shape[0] >= 4 and circles:
+        img = draw_circles(img, xy, cfg)
+    if xy.shape[0] > 4 and score:
+        scores = get_dart_scores(xy, cfg)
+    font = cv2.FONT_HERSHEY_SIMPLEX
+    font_scale = 0.5
+    line_type = 1
+    for i, [x, y] in enumerate(xy):
+        if i < 4:
+            c = (0, 255, 0)  # green
+        else:
+            c = color  # cyan
+        x = int(round(x))
+        y = int(round(y))
+        if i >= 4:
+            cv2.circle(img, (x, y), 1, c, 1)
+            if score:
+                txt = str(scores[i - 4])
+            else:
+                txt = str(i + 1)
+            cv2.putText(img, txt, (x + 8, y), font,
+                    font_scale, c, line_type)
+        else:
+            cv2.circle(img, (x, y), 1, c, 1)
+            cv2.putText(img, str(i + 1), (x + 8, y), font,
+                        font_scale, c, line_type)
+    return img
+
+
+def adjust_xy(idx):
+    global xy, img_copy
+    key = cv2.waitKey(0) & 0xFF
+    xy = np.array(xy)
+    h, w = img_copy.shape[:2]
+    xy[:, 0] *= w; xy[:, 1] *= h
+    if key == 52:  # one pixel left
+        if idx == -1:
+            xy[:, 0] -= 1
+        else:
+            xy[idx, 0] -= 1
+    if key == 56:  # one pixel up
+        if idx == -1:
+            xy[:, 1] -= 1
+        else:
+            xy[idx, 1] -= 1
+    if key == 54:  # one pixel right
+        if idx == -1:
+            xy[:, 0] += 1
+        else:
+            xy[idx, 0] += 1
+    if key == 50:  # one pixel down
+        if idx == -1:
+            xy[:, 1] += 1
+        else:
+            xy[idx, 1] += 1
+    xy[:, 0] /= w; xy[:, 1] /= h
+    xy = xy.tolist()
+
+
+def add_last_dart(annot, data_path, folder):
+    csv_path = osp.join(data_path, 'annotations', folder + '.csv')
+    if osp.isfile(csv_path):
+        dart_labels = []
+        csv = pd.read_csv(csv_path)
+        for idx in csv.index.values:
+            for c in csv.columns:
+                dart_labels.append(str(csv.loc[idx, c]))
+        annot['last_dart'] = dart_labels
+    return annot
+
+
+def get_bounding_box(img_path, scale=0.2):
+    img = cv2.imread(img_path)
+    img_resized = cv2.resize(img, None, fx=scale, fy=scale)
+    h, w = img_resized.shape[:2]
+    xy_bbox = []
+
+    def on_click_bbox(event, x, y, flags, param):
+        if event == cv2.EVENT_LBUTTONDOWN:
+            if len(xy_bbox) < 2:
+                xy_bbox.append([
+                    round((x / w) * img.shape[1]),
+                    round((y / h) * img.shape[0])])
+
+    window = 'get bbox'
+    cv2.namedWindow(window)
+    cv2.setMouseCallback(window, on_click_bbox)
+    while len(xy_bbox) < 2:
+        # print(xy_bbox)
+        cv2.imshow(window, img_resized)
+        key = cv2.waitKey(100)
+        if key == ord('q'):  # quit
+            cv2.destroyAllWindows()
+            break
+    cv2.destroyAllWindows()
+    assert len(xy_bbox) == 2, 'click 2 points to get bounding box'
+    xy_bbox = np.array(xy_bbox)
+    # bbox = [y1 y2 x1 x2]
+    bbox = [min(xy_bbox[:, 1]), max(xy_bbox[:, 1]), min(xy_bbox[:, 0]), max(xy_bbox[:, 0])]
+    return bbox
+
+
+def main(cfg, folder, scale, draw_circles, dart_score=True):
+    global xy, img_copy
+    img_dir = osp.join(cfg.data.path, 'images', folder)
+    imgs = sorted(os.listdir(img_dir))
+    annot_path = osp.join(cfg.data.path, 'annotations', folder + '.pkl')
+    if osp.isfile(annot_path):
+        annot = pd.read_pickle(annot_path)
+    else:
+        annot = pd.DataFrame(columns=['img_name', 'bbox', 'xy'])
+        annot['img_name'] = imgs
+        annot['bbox'] = None
+        annot['xy'] = None
+        annot = add_last_dart(annot, cfg.data.path, folder)
+
+    i = 0
+    for j in range(len(annot)):
+        a = annot.iloc[j,:]
+        if a['bbox'] is not None:
+            i = j
+
+    while i < len(imgs):
+        xy = []
+        a = annot.iloc[i,:]
+        print('Annotating {}'.format(a['img_name']))
+        if a['bbox'] is None:
+            if i == 0:
+                bbox = get_bounding_box(osp.join(img_dir, a['img_name']))
+            if i > 0:
+                last_a = annot.iloc[i-1,:]
+                if last_a['xy'] is not None:
+                    xy = last_a['xy'].copy()
+            else:
+                xy = []
+        else:
+            bbox, xy = a['bbox'], a['xy']
+
+        crop, _ = crop_board(osp.join(img_dir, a['img_name']), bbox=bbox)
+        crop = cv2.resize(crop, (int(crop.shape[1] * scale), int(crop.shape[0] * scale)))
+        cv2.putText(crop, '{}/{} {}'.format(i+1, len(annot), a['img_name']), (0, 12), cv2.FONT_HERSHEY_SIMPLEX, 0.5, (255, 255, 255), 1)
+        img_copy = crop.copy()
+
+        cv2.namedWindow(folder)
+        cv2.setMouseCallback(folder, on_click)
+        while True:
+            img_copy = draw(img_copy, xy, cfg, draw_circles, dart_score)
+            cv2.imshow(folder, img_copy)
+            key = cv2.waitKey(100) & 0xFF  # update every 100 ms
+
+            if key == ord('q'):  # quit
+                cv2.destroyAllWindows()
+                i = len(imgs)
+                break
+
+            if key == ord('b'):  # draw new bounding box
+                idx = annot[(annot['img_name'] == a['img_name'])].index.values[0]
+                annot.at[idx, 'bbox'] = get_bounding_box(osp.join(img_dir, a['img_name']), scale)
+                break
+
+            if key == ord('.'):
+                i += 1
+                img_copy = crop.copy()
+                break
+
+            if key == ord(','):
+                if i > 0:
+                    i += -1
+                    img_copy = crop.copy()
+                    break
+
+            if key == ord('z'):  # undo keypoint
+                xy = xy[:-1]
+                img_copy = crop.copy()
+
+            if key == ord('x'):  # reset annotation
+                idx = annot[(annot['img_name'] == a['img_name'])].index.values[0]
+                annot.at[idx, 'xy'] = None,
+                annot.at[idx, 'bbox'] = None
+                annot.to_pickle(annot_path)
+                break
+
+            if key == ord('d'):  # delete img
+                print('Are you sure you want to delete this image? (y/n)')
+                key = cv2.waitKey(0) & 0xFF
+                if key == ord('y'):
+                    idx = annot[(annot['img_name'] == a['img_name'])].index.values[0]
+                    annot = annot.drop([idx])
+                    annot.to_pickle(annot_path)
+                    os.remove(osp.join(img_dir, a['img_name']))
+                    print('Deleted image {}'.format(a['img_name']))
+                    break
+                else:
+                    print('Image not deleted.')
+                    continue
+
+            if key == ord('a'):  # accept keypoints
+                idx = annot[(annot['img_name'] == a['img_name'])].index.values[0]
+                annot.at[idx, 'xy'] = xy
+                annot.at[idx, 'bbox'] = bbox
+                annot.to_pickle(annot_path)
+                i += 1
+                break
+
+            if key in [ord('1'), ord('2'), ord('3'), ord('4'), ord('5'), ord('6'), ord('7'), ord('0')]:
+                adjust_xy(idx=key - 49)  # ord('1') = 49
+                img_copy = crop.copy()
+                continue
+
+
+if __name__ == '__main__':
+    import sys
+    sys.path.append('../../')
+    parser = argparse.ArgumentParser()
+    parser.add_argument('-f', '--img-folder', default='d2_04_05_2020')
+    parser.add_argument('-s', '--scale', type=float, default=0.5)
+    parser.add_argument('-d', '--draw-circles', action='store_true')
+    args = parser.parse_args()
+
+    cfg = CN(new_allowed=True)
+    cfg.merge_from_file('../configs/tiny480_20e.yaml')
+
+    main(cfg, args.img_folder, args.scale, args.draw_circles)

dataset/labels.pkl

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

src/data.rs

@@ -0,0 +1,118 @@
+use burn::prelude::*;
+use serde::{Deserialize, Serialize};
+use std::collections::HashMap;
+use std::fs::File;
+use std::io::BufReader;
+
+#[derive(Serialize, Deserialize, Debug, Clone)]
+pub struct Annotation {
+    pub img_folder: String,
+    pub img_name: String,
+    pub bbox: Vec<i32>,
+    pub xy: Vec<Vec<f32>>,
+}
+
+pub struct DartDataset {
+    pub annotations: Vec<Annotation>,
+    pub base_path: String,
+}
+
+impl DartDataset {
+    pub fn load(json_path: &str, base_path: &str) -> Self {
+        let file = File::open(json_path).expect("Labels JSON not found");
+        let reader = BufReader::new(file);
+        let raw_data: HashMap<String, Annotation> = serde_json::from_reader(reader).expect("JSON parse error");
+        
+        let mut annotations: Vec<Annotation> = raw_data.into_values().collect();
+        annotations.sort_by(|a, b| a.img_name.cmp(&b.img_name));
+
+        Self {
+            annotations,
+            base_path: base_path.to_string(),
+        }
+    }
+}
+
+impl burn::data::dataset::Dataset<Annotation> for DartDataset {
+    fn get(&self, index: usize) -> Option<Annotation> {
+        self.annotations.get(index).cloned()
+    }
+
+    fn len(&self) -> usize {
+        self.annotations.len()
+    }
+}
+
+#[derive(Clone, Debug)]
+pub struct DartBatch<B: Backend> {
+    pub images: Tensor<B, 4>,
+    pub targets: Tensor<B, 4>,
+}
+
+#[derive(Clone, Debug)]
+pub struct DartBatcher<B: Backend> {
+    device: Device<B>,
+}
+
+use burn::data::dataloader::batcher::Batcher;
+
+impl<B: Backend> Batcher<Annotation, DartBatch<B>> for DartBatcher<B> {
+    fn batch(&self, items: Vec<Annotation>) -> DartBatch<B> {
+        self.batch_manual(items)
+    }
+}
+
+impl<B: Backend> DartBatcher<B> {
+    pub fn new(device: Device<B>) -> Self {
+        Self { device }
+    }
+
+    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)
+        
+        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 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])
+                .collect();
+            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;
+
+                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 + 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
+            }
+        }
+
+        let images = Tensor::stack(
+            images_list.into_iter().map(|d| Tensor::<B, 3>::from_data(d, &self.device)).collect(),
+            0
+        ).permute([0, 3, 1, 2]);
+
+        let targets = Tensor::from_data(
+            TensorData::new(target_raw, [batch_size, num_channels, grid_size, grid_size]),
+            &self.device
+        );
+
+        DartBatch { images, targets }
+    }
+}

src/inference.rs

@@ -0,0 +1,49 @@
+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};
+
+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.");
+    let model = model.load_record(record);
+
+    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])
+        .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]);
+
+    println!("🚀 Running MODEL Prediction...");
+    let (out16, _out32) = model.forward(input);
+
+    // 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];
+    
+    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);
+    } else {
+        println!("⚠️ Model confidence is too low. Training incomplete?");
+    }
+    println!("--------------------------------------------------");
+}

src/loss.rs

@@ -0,0 +1,44 @@
+use burn::tensor::backend::Backend;
+use burn::tensor::Tensor;
+
+pub fn diou_loss<B: Backend>(
+    bboxes_pred: Tensor<B, 4>,
+    target: Tensor<B, 4>,
+) -> Tensor<B, 1> {
+    // 1. Reshape to separate anchors: [Batch, 3, 10, H, W]
+    let [batch, _channels, h, w] = bboxes_pred.dims();
+    let bp = bboxes_pred.reshape([batch, 3, 10, h, w]);
+    let t = target.reshape([batch, 3, 10, h, w]);
+    
+    // 2. Objectness (Channel 4)
+    let obj_pred = burn::tensor::activation::sigmoid(bp.clone().narrow(2, 4, 1));
+    let obj_target = t.clone().narrow(2, 4, 1);
+    
+    let eps = 1e-7;
+    // Positive loss (where an object exists)
+    let pos_loss = obj_target.clone().mul(obj_pred.clone().add_scalar(eps).log()).neg();
+    // Negative loss (where no object exists)
+    let neg_loss = obj_target.clone().neg().add_scalar(1.0).mul(obj_pred.clone().neg().add_scalar(1.0 + eps).log()).neg();
+    
+    // Weight positive samples 10x more to fight imbalance (typical YOLO trick)
+    let obj_loss = pos_loss.mul_scalar(20.0).add(neg_loss).mean();
+
+    // 3. Class (Channels 5-9) - Only learn when object exists
+    let cls_pred = burn::tensor::activation::sigmoid(bp.clone().narrow(2, 5, 5));
+    let cls_target = t.clone().narrow(2, 5, 5);
+    let class_loss = cls_target.clone().mul(cls_pred.clone().add_scalar(eps).log()).neg()
+        .mul(obj_target.clone()) // Only count where object exists
+        .mean()
+        .mul_scalar(5.0); // Boost class learning
+
+    // 4. Coordinates (Channels 0-3) - Only learn when object exists
+    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 b_wh_pred = burn::tensor::activation::sigmoid(bp.clone().narrow(2, 2, 2));
+    let b_wh_target = t.clone().narrow(2, 2, 2);
+    let wh_loss = b_wh_pred.sub(b_wh_target).powf_scalar(2.0).mul(obj_target).mean().mul_scalar(5.0);
+
+    obj_loss.add(class_loss).add(xy_loss).add(wh_loss)
+}

src/main.rs

@@ -0,0 +1,88 @@
+use crate::model::DartVisionModel;
+use crate::server::start_gui;
+use crate::train::{train, TrainingConfig};
+use burn::backend::wgpu::WgpuDevice;
+use burn::backend::Wgpu;
+use burn::prelude::*;
+use burn::record::{BinFileRecorder, FullPrecisionSettings, Recorder};
+
+pub mod data;
+pub mod loss;
+pub mod model;
+pub mod scoring;
+pub mod server;
+pub mod train;
+
+fn main() {
+    let device = WgpuDevice::default();
+    let args: Vec<String> = std::env::args().collect();
+
+    if args.len() > 1 && args[1] == "gui" {
+        println!("🌐 [Burn-DartVision] Starting Professional Dashboard...");
+        tokio::runtime::Builder::new_multi_thread()
+            .enable_all()
+            .build()
+            .unwrap()
+            .block_on(start_gui(device));
+    } else if args.len() > 1 && args[1] == "test" {
+        let img_path = if args.len() > 2 { &args[2] } else { "test.jpg" };
+        test_model(device, img_path);
+    } else {
+        println!("🚀 [Burn-DartVision] Starting Full Project Training...");
+        let dataset_path = "dataset/labels.json";
+
+        let config = TrainingConfig {
+            num_epochs: 10,
+            batch_size: 1,
+            lr: 1e-3,
+        };
+
+        train::<burn::backend::Autodiff<Wgpu>>(device, dataset_path, config);
+    }
+}
+
+fn test_model(device: WgpuDevice, img_path: &str) {
+    println!("🔍 Testing model on: {}", img_path);
+    let recorder = BinFileRecorder::<FullPrecisionSettings>::default();
+    let model = DartVisionModel::<Wgpu>::new(&device);
+
+    let record = match recorder.load("model_weights".into(), &device) {
+        Ok(r) => r,
+        Err(_) => {
+            println!("⚠️ Weights not found, using initial model.");
+            model.clone().into_record()
+        }
+    };
+    let model = model.load_record(record);
+
+    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)
+    });
+    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,
+            ]
+        })
+        .collect();
+
+    let tensor_data = TensorData::new(pixels, [1, 416, 416, 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 score = max_val
+        .to_data()
+        .convert::<f32>()
+        .as_slice::<f32>()
+        .unwrap()[0];
+    println!("📊 Max Objectness Score: {:.6}", score);
+}

src/model.rs

@@ -0,0 +1,88 @@
+use burn::nn::conv::{Conv2d, Conv2dConfig};
+use burn::nn::{BatchNorm, BatchNormConfig};
+use burn::module::Module;
+use burn::tensor::backend::Backend;
+use burn::tensor::Tensor;
+use burn::nn::PaddingConfig2d;
+use burn::nn::pool::{MaxPool2d, MaxPool2dConfig};
+
+#[derive(Module, Debug)]
+pub struct ConvBlock<B: Backend> {
+    conv: Conv2d<B>,
+    bn: BatchNorm<B, 2>,
+}
+
+impl<B: Backend> ConvBlock<B> {
+    pub fn new(in_channels: usize, out_channels: usize, kernel_size: [usize; 2], device: &B::Device) -> Self {
+        let config = Conv2dConfig::new([in_channels, out_channels], kernel_size)
+            .with_padding(PaddingConfig2d::Same);
+        let conv = config.init(device);
+        let bn = BatchNormConfig::new(out_channels).init(device);
+        Self { conv, bn }
+    }
+
+    pub fn forward(&self, x: Tensor<B, 4>) -> Tensor<B, 4> {
+        let x = self.conv.forward(x);
+        let x = self.bn.forward(x);
+        burn::tensor::activation::leaky_relu(x, 0.1)
+    }
+}
+
+#[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
+    p1: MaxPool2d,
+    l2: ConvBlock<B>, // 16 -> 16
+    p2: MaxPool2d,
+    l3: ConvBlock<B>, // 16 -> 32
+    p3: MaxPool2d,
+    l4: ConvBlock<B>, // 32 -> 32
+    p4: MaxPool2d,
+    l5: ConvBlock<B>, // 32 -> 64
+    l6: ConvBlock<B>, // 64 -> 64
+
+    head_32: Conv2d<B>, // Final detection head
+}
+
+impl<B: Backend> DartVisionModel<B> {
+    pub fn new(device: &B::Device) -> Self {
+        let l1 = ConvBlock::new(3, 16, [3, 3], device);
+        let p1 = MaxPool2dConfig::new([2, 2]).with_strides([2, 2]).init();
+        
+        let l2 = ConvBlock::new(16, 16, [3, 3], device);
+        let p2 = MaxPool2dConfig::new([2, 2]).with_strides([2, 2]).init();
+        
+        let l3 = ConvBlock::new(16, 32, [3, 3], device);
+        let p3 = MaxPool2dConfig::new([2, 2]).with_strides([2, 2]).init();
+        
+        let l4 = ConvBlock::new(32, 32, [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);
+
+        // 30 channels = 3 anchors * (x,y,w,h,obj,p0...p4)
+        let head_32 = Conv2dConfig::new([64, 30], [1, 1]).init(device);
+
+        Self { l1, p1, l2, p2, l3, p3, l4, p4, l5, l6, head_32 }
+    }
+
+    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)
+    }
+}

src/scoring.rs

@@ -0,0 +1,89 @@
+use std::collections::HashMap;
+
+pub struct ScoringConfig {
+    pub r_double: f32,
+    pub r_treble: f32,
+    pub r_outer_bull: f32,
+    pub r_inner_bull: f32,
+    pub w_double_treble: f32,
+}
+
+impl Default for ScoringConfig {
+    fn default() -> Self {
+        Self {
+            r_double: 0.170,
+            r_treble: 0.1074,
+            r_outer_bull: 0.0159,
+            r_inner_bull: 0.00635,
+            w_double_treble: 0.01,
+        }
+    }
+}
+
+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"];
+    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) {
+    // 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()
+        .map(|p| ((p[0] - cx).powi(2) + (p[1] - cy).powi(2)).sqrt())
+        .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.
+    let board_dict = get_board_dict();
+    let sector_idx = ((angle_deg / 18.0).floor() as i32) % 20;
+    let sector_num = board_dict.get(&sector_idx).unwrap_or(&"0");
+
+    // 5. Determine multipliers based on scaled distance
+    let r_t = config.r_treble;
+    let r_d = config.r_double;
+    let w = config.w_double_treble;
+    let r_ib = config.r_inner_bull;
+    let r_ob = config.r_outer_bull;
+
+    if dist_scaled > r_d {
+        (0, "Miss".to_string())
+    } else if dist_scaled <= r_ib {
+        (50, "DB".to_string())
+    } else if dist_scaled <= r_ob {
+        (25, "B".to_string())
+    } else if dist_scaled <= r_d && dist_scaled > (r_d - w) {
+        let val = sector_num.parse::<i32>().unwrap_or(0);
+        (val * 2, format!("D{}", sector_num))
+    } else if dist_scaled <= r_t && dist_scaled > (r_t - w) {
+        let val = sector_num.parse::<i32>().unwrap_or(0);
+        (val * 3, format!("T{}", sector_num))
+    } else {
+        let val = sector_num.parse::<i32>().unwrap_or(0);
+        (val, sector_num.to_string())
+    }
+}

src/server.rs

@@ -0,0 +1,185 @@
+use axum::{
+    extract::{DefaultBodyLimit, Multipart, State},
+    response::{Html, Json},
+    routing::{get, post},
+    Router,
+};
+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;
+use tokio::sync::{mpsc, oneshot};
+use tower_http::cors::CorsLayer;
+
+#[derive(Debug)]
+struct PredictResult {
+    confidence: f32,
+    keypoints: Vec<f32>,
+    scores: Vec<String>,
+}
+
+struct PredictRequest {
+    image_bytes: Vec<u8>,
+    response_tx: oneshot::Sender<PredictResult>,
+}
+
+pub async fn start_gui(device: WgpuDevice) {
+    let addr = SocketAddr::from(([127, 0, 0, 1], 8080));
+    println!("🚀 [DartVision-GUI] Starting on http://127.0.0.1:8080",);
+
+    let (tx, mut rx) = mpsc::channel::<PredictRequest>(10);
+
+    let worker_device = device.clone();
+    std::thread::spawn(move || {
+        let recorder = BinFileRecorder::<FullPrecisionSettings>::default();
+        let model = DartVisionModel::<Wgpu>::new(&worker_device);
+        let record = match recorder.load("model_weights".into(), &worker_device) {
+            Ok(r) => r,
+            Err(_) => {
+                println!("⚠️ [DartVision] No 'model_weights.bin' yet. Using initial weights...");
+                model.clone().into_record()
+            }
+        };
+        let model = model.load_record(record);
+
+        while let Some(req) = rx.blocking_recv() {
+            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])
+                .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 (out16, _) = model.forward(input);
+            
+            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)
+            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 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;
+
+                // 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];
+
+                final_points[(cls_idx-1)*2] = px;
+                final_points[(cls_idx-1)*2+1] = py;
+                if s > max_conf { max_conf = s; }
+            }
+
+            // 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);
+            }
+
+            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};
+                let config = ScoringConfig::default();
+                let cal_pts = [
+                    [final_points[0], final_points[1]],
+                    [final_points[2], final_points[3]],
+                    [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);
+                    }
+                }
+            }
+
+            println!("🎯 [Detection Result] 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 _ = req.response_tx.send(PredictResult {
+                confidence: max_conf,
+                keypoints: final_points,
+                scores: final_scores,
+            });
+        }
+    });
+
+    let state = Arc::new(tx);
+
+    let app = Router::new()
+        .route("/", get(|| async { Html(include_str!("../static/index.html")) }))
+        .route("/api/predict", post(predict_handler))
+        .with_state(state)
+        .layer(DefaultBodyLimit::max(10 * 1024 * 1024))
+        .layer(CorsLayer::permissive());
+
+    let listener = tokio::net::TcpListener::bind(addr).await.unwrap();
+    axum::serve(listener, app).await.unwrap();
+}
+
+async fn predict_handler(
+    State(tx): State<Arc<mpsc::Sender<PredictRequest>>>,
+    mut multipart: Multipart,
+) -> Json<serde_json::Value> {
+    while let Ok(Some(field)) = multipart.next_field().await {
+        if field.name() == Some("image") {
+            let bytes = match field.bytes().await {
+                Ok(b) => b.to_vec(),
+                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![] });
+
+            return Json(json!({
+                "status": "success",
+                "confidence": result.confidence,
+                "keypoints": result.keypoints,
+                "scores": result.scores,
+                "message": if result.confidence > 0.1 { 
+                    format!("✅ Found {} darts! High confidence: {:.1}%", result.scores.len(), result.confidence * 100.0)
+                } else { 
+                    "⚠️ Low confidence detection - no dart score could be verified.".to_string()
+                }
+            }));
+        }
+    }
+    Json(json!({"status": "error", "message": "No image field found"}))
+}

src/train.rs

@@ -0,0 +1,106 @@
+use crate::data::{DartBatcher, DartDataset};
+use crate::loss::diou_loss;
+use crate::model::DartVisionModel;
+use burn::data::dataset::Dataset; // Add this trait to scope
+use burn::module::Module;
+use burn::optim::{AdamConfig, GradientsParams, Optimizer};
+use burn::prelude::*;
+use burn::record::{BinFileRecorder, FullPrecisionSettings, Recorder};
+use burn::tensor::backend::AutodiffBackend;
+
+pub struct TrainingConfig {
+    pub num_epochs: usize,
+    pub batch_size: usize,
+    pub lr: f64,
+}
+
+pub fn train<B: AutodiffBackend>(device: Device<B>, dataset_path: &str, config: TrainingConfig) {
+    // 1. Create Model
+    let mut model: DartVisionModel<B> = DartVisionModel::new(&device);
+
+    // 1.5 Load existing weights if they exist (RESUME)
+    let recorder = BinFileRecorder::<FullPrecisionSettings>::default();
+    let weights_path = "model_weights.bin";
+    if std::path::Path::new(weights_path).exists() {
+        println!("🚀 Loading existing weights from {}...", weights_path);
+        let record = Recorder::load(&recorder, "model_weights".into(), &device)
+            .expect("Failed to load weights");
+        model = model.load_record(record);
+    }
+
+    // 2. Setup Optimizer
+    let mut optim = AdamConfig::new().init();
+
+    // 3. Create Dataset
+    println!("🔍 Mapping annotations from {}...", dataset_path);
+    let dataset = DartDataset::load(dataset_path, "dataset/800");
+    println!("📊 Dataset loaded with {} examples.", dataset.len());
+    let batcher = DartBatcher::new(device.clone());
+
+    // 4. Create DataLoader
+    println!("📦 Initializing DataLoader (Workers: 4)...");
+    let dataloader = burn::data::dataloader::DataLoaderBuilder::new(batcher)
+        .batch_size(config.batch_size)
+        .shuffle(42)
+        .num_workers(4)
+        .build(dataset);
+
+    // 5. Training Loop
+    println!(
+        "📈 Running FULL Training Loop (Epochs: {})...",
+        config.num_epochs
+    );
+
+    // Using a simple loop state for ownership safety
+    let mut current_model = model;
+
+    for epoch in 1..=config.num_epochs {
+        let mut model_inner = current_model; // Move into epoch
+        let mut batch_count = 0;
+
+        for batch in dataloader.iter() {
+            // Forward Pass
+            let (out16, _) = model_inner.forward(batch.images);
+
+            // Calculate Loss
+            let loss = diou_loss(out16, batch.targets);
+            batch_count += 1;
+
+            // Print every 10 batches to keep terminal clean and avoid stdout sync lag
+            if batch_count % 20 == 0 || batch_count == 1 {
+                println!(
+                    "   [Epoch {}] Batch {: >3} | Loss: {:.6}",
+                    epoch,
+                    batch_count,
+                    loss.clone().into_scalar()
+                );
+            }
+
+            // Backward & Optimization step
+            let grads = loss.backward();
+            let grads_params = GradientsParams::from_grads(grads, &model_inner);
+            model_inner = optim.step(config.lr, model_inner, grads_params);
+
+            // 5.5 Periodic Save (every 100 batches and Batch 1)
+            if batch_count % 100 == 0 || batch_count == 1 {
+                model_inner.clone()
+                    .save_file("model_weights", &recorder)
+                    .ok();
+                if batch_count == 1 {
+                    println!("🚀 [Checkpoint] Initial weights saved at Batch 1.");
+                } else {
+                    println!("🚀 [Checkpoint] Saved at Batch {}.", batch_count);
+                }
+            }
+        }
+
+        // 6. SAVE after EACH Epoch
+        model_inner
+            .clone()
+            .save_file("model_weights", &recorder)
+            .expect("Failed to save weights");
+        println!("✅ Checkpoint saved: Epoch {} complete.", epoch);
+
+        current_model = model_inner; // Move back out for next epoch
+    }
+}

static/index.html

@@ -0,0 +1,350 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>DartVision AI - Smart Scoring 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">
+    <style>
+        :root {
+            --primary: #00ff88;
+            --secondary: #00d4ff;
+            --accent: #ff4d4d;
+            --bg: #0a0e14;
+            --card-bg: rgba(255, 255, 255, 0.05);
+            --glass-border: rgba(255, 255, 255, 0.1);
+        }
+
+        * {
+            margin: 0;
+            padding: 0;
+            box-sizing: border-box;
+            font-family: 'Outfit', sans-serif;
+        }
+
+        body {
+            background: var(--bg);
+            color: #fff;
+            min-height: 100vh;
+            display: flex;
+            flex-direction: column;
+            align-items: center;
+            overflow-x: hidden;
+        }
+
+        .bg-glow {
+            position: fixed;
+            top: 0;
+            left: 0;
+            right: 0;
+            bottom: 0;
+            background: radial-gradient(circle at 50% 50%, #00ff8811 0%, transparent 50%),
+                        radial-gradient(circle at 80% 20%, #00d4ff11 0%, transparent 40%);
+            z-index: -1;
+            pointer-events: none;
+        }
+
+        header {
+            padding: 2rem;
+            text-align: center;
+        }
+
+        h1 {
+            font-size: 3.5rem;
+            font-weight: 800;
+            background: linear-gradient(to right, var(--primary), var(--secondary));
+            -webkit-background-clip: text;
+            background-clip: text;
+            -webkit-text-fill-color: transparent;
+            margin-bottom: 0.5rem;
+            letter-spacing: -1px;
+        }
+
+        p.subtitle {
+            color: #8892b0;
+            font-size: 1.1rem;
+            letter-spacing: 2px;
+            text-transform: uppercase;
+        }
+
+        main {
+            width: 90%;
+            max-width: 1200px;
+            display: grid;
+            grid-template-columns: 1fr 380px;
+            gap: 2rem;
+            padding: 2rem 0;
+        }
+
+        .visual-area {
+            display: flex;
+            flex-direction: column;
+            gap: 1rem;
+        }
+
+        .upload-container {
+            background: var(--card-bg);
+            backdrop-filter: blur(20px);
+            border: 1px solid var(--glass-border);
+            border-radius: 24px;
+            padding: 1rem;
+            display: flex;
+            flex-direction: column;
+            align-items: center;
+            justify-content: center;
+            cursor: pointer;
+            transition: all 0.4s;
+            min-height: 600px;
+            position: relative;
+            overflow: hidden;
+        }
+
+        .upload-container:hover, .upload-container.drag-over {
+            border-color: var(--primary);
+            box-shadow: 0 0 40px rgba(0, 255, 136, 0.1);
+        }
+
+        .preview-wrapper {
+            position: relative;
+            width: 100%;
+            height: 100%;
+            display: none;
+            justify-content: center;
+            align-items: center;
+        }
+
+        #preview-img {
+            max-width: 100%;
+            max-height: 550px;
+            border-radius: 12px;
+            display: block;
+            object-fit: contain;
+        }
+
+        #overlay-svg {
+            position: absolute;
+            top: 0;
+            left: 0;
+            width: 100%;
+            height: 100%;
+            pointer-events: none;
+        }
+
+        .upload-icon { font-size: 4rem; margin-bottom: 1rem; }
+        .upload-text { font-size: 1.5rem; color: #ccd6f6; }
+        .upload-subtext { color: #8892b0; margin-top: 1rem; }
+
+        .stats-panel {
+            display: flex;
+            flex-direction: column;
+            gap: 1.5rem;
+        }
+
+        .stat-card {
+            background: rgba(255, 255, 255, 0.03);
+            border: 1px solid var(--glass-border);
+            border-radius: 20px;
+            padding: 1.5rem;
+        }
+
+        .stat-label { color: #8892b0; font-size: 0.9rem; margin-bottom: 0.5rem; text-transform: uppercase; }
+        .stat-value { font-size: 2rem; font-weight: 600; }
+        .conf-bar { height: 8px; background: rgba(255,255,255,0.1); border-radius: 4px; margin-top: 1rem; overflow: hidden; }
+        .conf-fill { height: 100%; width: 0%; background: linear-gradient(to right, var(--primary), var(--secondary)); transition: 1s; }
+
+        .loading-spinner {
+            width: 40px; height: 40px;
+            border: 3px solid rgba(0, 255, 136, 0.1);
+            border-top: 3px solid var(--primary);
+            border-radius: 50%;
+            animation: spin 1s linear infinite;
+            display: none;
+            position: absolute;
+        }
+
+        @keyframes spin { 100% { transform: rotate(360deg); } }
+
+        .keypoint-marker {
+            fill: var(--primary);
+            stroke: #fff;
+            stroke-width: 2px;
+            filter: drop-shadow(0 0 5px var(--primary));
+            animation: pulse 1.5s infinite;
+        }
+
+        @keyframes pulse {
+            0% { r: 5; opacity: 1; }
+            50% { r: 8; opacity: 0.7; }
+            100% { r: 5; opacity: 1; }
+        }
+    </style>
+</head>
+<body>
+    <div class="bg-glow"></div>
+    <header>
+        <h1>DARTVISION <span style="font-weight: 300; opacity: 0.5;">AI</span></h1>
+        <p class="subtitle">Intelligent Labelling & Scoring Dashboard</p>
+    </header>
+
+    <main>
+        <section class="visual-area">
+            <div class="upload-container" id="drop-zone">
+                <div id="initial-state">
+                    <div class="upload-icon">🎯</div>
+                    <div class="upload-text">Drag & Drop Image</div>
+                    <div class="upload-subtext">calibration and scoring results will appear here</div>
+                </div>
+                <div class="preview-wrapper" id="preview-wrapper">
+                    <img id="preview-img">
+                    <svg id="overlay-svg"></svg>
+                </div>
+                <div class="loading-spinner" id="spinner"></div>
+            </div>
+            <input type="file" id="file-input" style="display: none;" accept="image/*">
+        </section>
+
+        <aside class="stats-panel">
+            <div class="stat-card">
+                <div class="stat-label">Model Status</div>
+                <div class="stat-value" id="status-text" style="font-size: 1.2rem; color: var(--primary);">System Ready</div>
+            </div>
+            <div class="stat-card">
+                <div class="stat-label">AI Confidence</div>
+                <div class="stat-value" id="conf-val">0.0%</div>
+                <div class="conf-bar"><div class="conf-fill" id="conf-fill"></div></div>
+            </div>
+            <div class="stat-card">
+                <div class="stat-label">Detection Result</div>
+                <div class="stat-value" id="result-text" style="font-size: 1.1rem; opacity: 0.8;">No Image Uploaded</div>
+            </div>
+        </aside>
+    </main>
+
+    <script>
+        const dropZone = document.getElementById('drop-zone');
+        const fileInput = document.getElementById('file-input');
+        const previewImg = document.getElementById('preview-img');
+        const previewWrapper = document.getElementById('preview-wrapper');
+        const initialState = document.getElementById('initial-state');
+        const svgOverlay = document.getElementById('overlay-svg');
+        const spinner = document.getElementById('spinner');
+
+        dropZone.onclick = () => fileInput.click();
+        fileInput.onchange = (e) => handleFile(e.target.files[0]);
+
+        dropZone.ondragover = (e) => { e.preventDefault(); dropZone.classList.add('drag-over'); };
+        dropZone.ondragleave = () => dropZone.classList.remove('drag-over');
+        dropZone.ondrop = (e) => { e.preventDefault(); dropZone.classList.remove('drag-over'); handleFile(e.dataTransfer.files[0]); };
+
+        async function handleFile(file) {
+            if (!file || !file.type.startsWith('image/')) return;
+            
+            const reader = new FileReader();
+            reader.onload = (e) => {
+                previewImg.src = e.target.result;
+                previewWrapper.style.display = 'flex';
+                initialState.style.display = 'none';
+                clearKeypoints();
+            };
+            reader.readAsDataURL(file);
+
+            spinner.style.display = 'block';
+            const formData = new FormData();
+            formData.append('image', file);
+
+            try {
+                const response = await fetch('/api/predict', { method: 'POST', body: formData });
+                const data = await response.json();
+                spinner.style.display = 'none';
+                
+                if (data.status === 'success') {
+                    updateUI(data);
+                    drawKeypoints(data.keypoints);
+                }
+            } catch (err) {
+                spinner.style.display = 'none';
+                document.getElementById('status-text').innerText = 'Error';
+            }
+        }
+
+        function updateUI(data) {
+            const conf = (data.confidence * 100).toFixed(1);
+            document.getElementById('conf-val').innerText = `${conf}%`;
+            document.getElementById('conf-fill').style.width = `${conf}%`;
+            
+            let resultHtml = `<div style="margin-top: 1rem; font-size: 0.9rem; line-height: 1.5;">${data.message}</div>`;
+            if (data.keypoints && data.keypoints.length >= 8) {
+                const names = ["Cal 1", "Cal 2", "Cal 3", "Cal 4", "Dart"];
+                resultHtml += `<div style="font-size: 0.8rem; opacity: 0.6; margin-top: 5px;">Results & Mapping:</div>`;
+                for (let i = 0; i < data.keypoints.length; i += 2) {
+                    const classIdx = i / 2;
+                    const name = names[classIdx] || `Dart ${Math.floor(classIdx - 3)}`;
+                    const x = data.keypoints[i].toFixed(3);
+                    const y = data.keypoints[i+1].toFixed(3);
+                    
+                    // Get score label if it's a dart
+                    let scoreLabel = "";
+                    if (classIdx >= 4 && data.scores && data.scores[classIdx - 4]) {
+                        scoreLabel = ` <span style="background: #ff4d4d; color: white; padding: 2px 6px; border-radius: 4px; font-weight: 800; margin-left: 10px;">${data.scores[classIdx - 4]}</span>`;
+                    }
+
+                    resultHtml += `<div style="font-size: 0.85rem; padding: 6px 0; border-bottom: 1px solid rgba(255,255,255,0.05); display: flex; align-items: center; justify-content: space-between;">
+                        <span><span style="color: ${i < 8 ? '#00ff88' : '#ff4d4d'}">${name}</span>: [${x}, ${y}]</span>
+                        ${scoreLabel}
+                    </div>`;
+                }
+            }
+            document.getElementById('result-text').innerHTML = resultHtml;
+        }
+
+        function clearKeypoints() {
+            while (svgOverlay.firstChild) svgOverlay.removeChild(svgOverlay.firstChild);
+        }
+
+        function drawKeypoints(pts) {
+            clearKeypoints();
+            if (!pts || pts.length === 0) return;
+
+            // Wait for image to render to get actual display dimensions
+            setTimeout(() => {
+                const rect = previewImg.getBoundingClientRect();
+                const wrapperRect = previewWrapper.getBoundingClientRect();
+                
+                // Offset calculation relative to wrapper
+                const offsetX = rect.left - wrapperRect.left;
+                const offsetY = rect.top - wrapperRect.top;
+                const width = rect.width;
+                const height = rect.height;
+
+                const classNames = ["Cal 1", "Cal 2", "Cal 3", "Cal 4", "Dart"];
+                for (let i = 0; i < pts.length; i += 2) {
+                    const x = pts[i] * width + offsetX;
+                    const y = pts[i+1] * height + offsetY;
+                    const classIdx = i / 2;
+                    const name = classNames[classIdx] || `Dart ${Math.floor(classIdx - 3)}`;
+
+                    const circle = document.createElementNS("http://www.w3.org/2000/svg", "circle");
+                    circle.setAttribute("cx", x);
+                    circle.setAttribute("cy", y);
+                    circle.setAttribute("r", 6);
+                    circle.setAttribute("class", "keypoint-marker");
+                    if (classIdx >= 4) circle.style.fill = "#ff4d4d"; // Red for dart
+                    
+                    const label = document.createElementNS("http://www.w3.org/2000/svg", "text");
+                    label.setAttribute("x", x + 10);
+                    label.setAttribute("y", y - 10);
+                    label.setAttribute("fill", classIdx < 4 ? "#00ff88" : "#ff4d4d");
+                    label.setAttribute("font-size", "14px");
+                    label.setAttribute("font-weight", "600");
+                    label.textContent = name;
+                    
+                    svgOverlay.appendChild(circle);
+                    svgOverlay.appendChild(label);
+                }
+            }, 50);
+        }
+    </script>
+</body>
+</html>