diff --git a/rust-port/wifi-densepose-rs/crates/wifi-densepose-desktop/ui/src/App.tsx b/rust-port/wifi-densepose-rs/crates/wifi-densepose-desktop/ui/src/App.tsx index 51c5fe93..6e618c43 100644 --- a/rust-port/wifi-densepose-rs/crates/wifi-densepose-desktop/ui/src/App.tsx +++ b/rust-port/wifi-densepose-rs/crates/wifi-densepose-desktop/ui/src/App.tsx @@ -8,6 +8,7 @@ import { OtaUpdate } from "./pages/OtaUpdate"; import { EdgeModules } from "./pages/EdgeModules"; import { Sensing } from "./pages/Sensing"; import { MeshView } from "./pages/MeshView"; +import Training from "./pages/Training"; import { Settings } from "./pages/Settings"; type Page = @@ -19,6 +20,7 @@ type Page = | "wasm" | "sensing" | "mesh" + | "training" | "settings"; interface NavItem { @@ -36,6 +38,7 @@ const NAV_ITEMS: NavItem[] = [ { id: "wasm", label: "Edge Modules", icon: "\u2B21" }, { id: "sensing", label: "Sensing", icon: "\u2248" }, { id: "mesh", label: "Mesh View", icon: "\u2B2F" }, + { id: "training", label: "Training", icon: "\u2B50" }, { id: "settings", label: "Settings", icon: "\u2699" }, ]; @@ -99,6 +102,7 @@ const App: React.FC = () => { case "wasm": return ; case "sensing": return ; case "mesh": return ; + case "training": return ; case "settings": return ; } }; diff --git a/rust-port/wifi-densepose-rs/crates/wifi-densepose-desktop/ui/src/pages/Training/DatasetsTab.tsx b/rust-port/wifi-densepose-rs/crates/wifi-densepose-desktop/ui/src/pages/Training/DatasetsTab.tsx new file mode 100644 index 00000000..b5c2c7c0 --- /dev/null +++ b/rust-port/wifi-densepose-rs/crates/wifi-densepose-desktop/ui/src/pages/Training/DatasetsTab.tsx @@ -0,0 +1,369 @@ +import React, { useState, useEffect } from "react"; +import { invoke } from "@tauri-apps/api/core"; + +interface Dataset { + id: string; + name: string; + description: string; + size_mb: number; + samples: number; + downloaded: boolean; + path: string | null; +} + +const STANDARD_DATASETS: Omit[] = [ + { + id: "mmfi", + name: "MM-Fi Dataset", + description: "Multi-modal WiFi sensing dataset with 40 subjects, 27 activities", + size_mb: 2400, + samples: 320000, + }, + { + id: "wipose", + name: "Wi-Pose Dataset", + description: "WiFi-based pose estimation with 3D skeleton annotations", + size_mb: 1800, + samples: 150000, + }, + { + id: "wiar", + name: "WiAR Dataset", + description: "WiFi activity recognition with CSI data", + size_mb: 500, + samples: 45000, + }, +]; + +const DatasetsTab: React.FC = () => { + const [datasets, setDatasets] = useState([]); + const [downloading, setDownloading] = useState(null); + const [downloadProgress, setDownloadProgress] = useState(0); + const [error, setError] = useState(null); + + useEffect(() => { + loadDatasets(); + }, []); + + const loadDatasets = async () => { + try { + const downloaded = await invoke("list_datasets"); + const ds = STANDARD_DATASETS.map((d) => ({ + ...d, + downloaded: downloaded.includes(d.id), + path: downloaded.includes(d.id) ? `~/.ruview/datasets/${d.id}` : null, + })); + setDatasets(ds); + } catch (err) { + // If command not implemented yet, show placeholders + setDatasets( + STANDARD_DATASETS.map((d) => ({ + ...d, + downloaded: false, + path: null, + })) + ); + } + }; + + const handleDownload = async (datasetId: string) => { + setDownloading(datasetId); + setDownloadProgress(0); + setError(null); + + try { + // Simulate download progress for now + for (let i = 0; i <= 100; i += 10) { + setDownloadProgress(i); + await new Promise((r) => setTimeout(r, 500)); + } + + // TODO: Call actual download command + // await invoke("download_dataset", { datasetId }); + + setDatasets((prev) => + prev.map((d) => + d.id === datasetId + ? { ...d, downloaded: true, path: `~/.ruview/datasets/${d.id}` } + : d + ) + ); + } catch (err) { + setError(`Download failed: ${err}`); + } finally { + setDownloading(null); + } + }; + + return ( +
+ {/* Stats Row */} +
+ + d.downloaded).length} + color="var(--status-online)" + /> + acc + (d.downloaded ? d.samples : 0), 0) / 1000).toFixed(0)}K`} + /> +
+ + {error && ( +
+ {error} +
+ )} + + {/* Dataset Cards */} +
+ {datasets.map((dataset) => ( +
+
+
+

+ {dataset.name} +

+

+ {dataset.description} +

+
+ {dataset.downloaded && ( + + DOWNLOADED + + )} +
+ +
+ 📦 {(dataset.size_mb / 1024).toFixed(1)} GB + 📊 {(dataset.samples / 1000).toFixed(0)}K samples +
+ + {downloading === dataset.id ? ( +
+
+
+
+
+ Downloading... {downloadProgress}% +
+
+ ) : ( +
+ {dataset.downloaded ? ( + <> + + + + ) : ( + + )} +
+ )} +
+ ))} +
+ + {/* Import Custom Dataset */} +
+
📁
+

+ Import Custom Dataset +

+

+ Import CSI recordings in CSV, NPZ, or HDF5 format +

+ +
+
+ ); +}; + +function StatCard({ + label, + value, + color, +}: { + label: string; + value: number | string; + color?: string; +}) { + return ( +
+
+ {label} +
+
+ {value} +
+
+ ); +} + +export default DatasetsTab; diff --git a/rust-port/wifi-densepose-rs/crates/wifi-densepose-desktop/ui/src/pages/Training/MetricsTab.tsx b/rust-port/wifi-densepose-rs/crates/wifi-densepose-desktop/ui/src/pages/Training/MetricsTab.tsx new file mode 100644 index 00000000..977b2abd --- /dev/null +++ b/rust-port/wifi-densepose-rs/crates/wifi-densepose-desktop/ui/src/pages/Training/MetricsTab.tsx @@ -0,0 +1,609 @@ +import React, { useState, useEffect } from "react"; +import { invoke } from "@tauri-apps/api/core"; + +interface TrainingMetrics { + epoch: number; + train_loss: number; + val_loss: number; + train_acc: number; + val_acc: number; + learning_rate: number; + timestamp: string; +} + +interface EvaluationMetrics { + pck_05: number; + pck_10: number; + pck_20: number; + map_50: number; + map_75: number; + iou: number; +} + +interface JointAccuracy { + joint: string; + accuracy: number; +} + +const JOINT_NAMES = [ + "nose", + "left_eye", + "right_eye", + "left_ear", + "right_ear", + "left_shoulder", + "right_shoulder", + "left_elbow", + "right_elbow", + "left_wrist", + "right_wrist", + "left_hip", + "right_hip", + "left_knee", + "right_knee", + "left_ankle", + "right_ankle", +]; + +const MetricsTab: React.FC = () => { + const [trainingHistory, setTrainingHistory] = useState([]); + const [evaluation, setEvaluation] = useState(null); + const [jointAccuracies, setJointAccuracies] = useState([]); + const [selectedMetric, setSelectedMetric] = useState<"loss" | "accuracy">("loss"); + const [exporting, setExporting] = useState(false); + + useEffect(() => { + loadMetrics(); + }, []); + + const loadMetrics = async () => { + try { + const metrics = await invoke("get_training_history"); + setTrainingHistory(metrics); + const evalMetrics = await invoke("get_evaluation_metrics"); + setEvaluation(evalMetrics); + const joints = await invoke("get_joint_accuracies"); + setJointAccuracies(joints); + } catch (err) { + // Generate mock data for demonstration + const mockHistory: TrainingMetrics[] = []; + for (let i = 1; i <= 50; i++) { + mockHistory.push({ + epoch: i, + train_loss: 0.5 * Math.exp(-i / 20) + 0.02 + Math.random() * 0.01, + val_loss: 0.55 * Math.exp(-i / 18) + 0.025 + Math.random() * 0.015, + train_acc: 1 - 0.5 * Math.exp(-i / 15) - Math.random() * 0.02, + val_acc: 1 - 0.55 * Math.exp(-i / 15) - Math.random() * 0.025, + learning_rate: 0.001 * Math.pow(0.95, Math.floor(i / 10)), + timestamp: new Date(Date.now() - (50 - i) * 60000).toISOString(), + }); + } + setTrainingHistory(mockHistory); + + setEvaluation({ + pck_05: 0.72, + pck_10: 0.89, + pck_20: 0.96, + map_50: 0.84, + map_75: 0.71, + iou: 0.78, + }); + + setJointAccuracies( + JOINT_NAMES.map((joint) => ({ + joint, + accuracy: 0.7 + Math.random() * 0.25, + })) + ); + } + }; + + const exportMetrics = async (format: "csv" | "json" | "tensorboard") => { + setExporting(true); + try { + if (format === "json") { + const data = { + training: trainingHistory, + evaluation, + joints: jointAccuracies, + }; + const blob = new Blob([JSON.stringify(data, null, 2)], { type: "application/json" }); + downloadBlob(blob, "metrics.json"); + } else if (format === "csv") { + const headers = "epoch,train_loss,val_loss,train_acc,val_acc,learning_rate\n"; + const rows = trainingHistory + .map( + (m) => + `${m.epoch},${m.train_loss.toFixed(6)},${m.val_loss.toFixed(6)},${m.train_acc.toFixed(4)},${m.val_acc.toFixed(4)},${m.learning_rate.toExponential(2)}` + ) + .join("\n"); + const blob = new Blob([headers + rows], { type: "text/csv" }); + downloadBlob(blob, "training_history.csv"); + } else { + // TensorBoard format would require server-side handling + alert("TensorBoard export requires running the backend server"); + } + } finally { + setExporting(false); + } + }; + + const downloadBlob = (blob: Blob, filename: string) => { + const url = URL.createObjectURL(blob); + const a = document.createElement("a"); + a.href = url; + a.download = filename; + a.click(); + URL.revokeObjectURL(url); + }; + + const maxLoss = Math.max( + ...trainingHistory.map((m) => Math.max(m.train_loss, m.val_loss)), + 0.1 + ); + + return ( +
+ {/* Summary Stats */} +
+ + 0 + ? Math.min(...trainingHistory.map((m) => m.val_loss)).toFixed(4) + : "—" + } + color="var(--status-online)" + /> + 0 + ? `${(Math.max(...trainingHistory.map((m) => m.val_acc)) * 100).toFixed(1)}%` + : "—" + } + color="var(--accent)" + /> + +
+ +
+ {/* Loss/Accuracy Charts */} +
+
+

Training Curves

+
+ + +
+
+ + {/* Chart Area */} +
+ {trainingHistory.length === 0 ? ( +
+ 📊 +

+ No training data yet +

+
+ ) : ( + + {/* Grid lines */} + {[0, 0.25, 0.5, 0.75, 1].map((y) => ( + + ))} + + {/* Train line */} + { + const x = (i / (trainingHistory.length - 1)) * 500; + const value = selectedMetric === "loss" ? m.train_loss : m.train_acc; + const y = + selectedMetric === "loss" + ? (value / maxLoss) * 180 + : (1 - value) * 180; + return `${x},${y}`; + }) + .join(" ")} + /> + + {/* Val line */} + { + const x = (i / (trainingHistory.length - 1)) * 500; + const value = selectedMetric === "loss" ? m.val_loss : m.val_acc; + const y = + selectedMetric === "loss" + ? (value / maxLoss) * 180 + : (1 - value) * 180; + return `${x},${y}`; + }) + .join(" ")} + /> + + )} + + {/* Legend */} +
+ + + Train + + + + Validation + +
+
+
+ + {/* Evaluation Metrics */} +
+

+ Evaluation Metrics +

+ + {!evaluation ? ( +
+ 📏 +

+ Run evaluation to see metrics +

+
+ ) : ( +
+ + + +
+ + + +
+ )} +
+
+ + {/* Joint-wise Accuracy */} +
+

+ Per-Joint Accuracy +

+ + {jointAccuracies.length === 0 ? ( +
+ No joint accuracy data available +
+ ) : ( +
+ {jointAccuracies.map((ja) => ( +
+
+ {ja.joint.replace("_", " ")} +
+
0.9 + ? "var(--status-online)" + : ja.accuracy > 0.8 + ? "var(--accent)" + : ja.accuracy > 0.7 + ? "#f59e0b" + : "var(--status-error)", + }} + > + {(ja.accuracy * 100).toFixed(1)}% +
+
+ ))} +
+ )} +
+ + {/* Export Section */} +
+
+

Export Metrics

+

+ Download training history and evaluation results +

+
+
+ + + +
+
+
+ ); +}; + +function StatCard({ + label, + value, + color, +}: { + label: string; + value: number | string; + color?: string; +}) { + return ( +
+
+ {label} +
+
+ {value} +
+
+ ); +} + +function MetricBar({ + label, + value, + color, +}: { + label: string; + value: number; + color: string; +}) { + return ( +
+
+ {label} + + {(value * 100).toFixed(1)}% + +
+
+
+
+
+ ); +} + +export default MetricsTab; diff --git a/rust-port/wifi-densepose-rs/crates/wifi-densepose-desktop/ui/src/pages/Training/ModelsTab.tsx b/rust-port/wifi-densepose-rs/crates/wifi-densepose-desktop/ui/src/pages/Training/ModelsTab.tsx new file mode 100644 index 00000000..3ee54d7d --- /dev/null +++ b/rust-port/wifi-densepose-rs/crates/wifi-densepose-desktop/ui/src/pages/Training/ModelsTab.tsx @@ -0,0 +1,405 @@ +import React, { useState, useEffect } from "react"; +import { invoke } from "@tauri-apps/api/core"; + +interface ModelArchitecture { + id: string; + name: string; + type: "encoder" | "decoder" | "embedding" | "adaptor"; + description: string; + params_m: number; + memory_mb: number; + paper?: string; +} + +interface Checkpoint { + id: string; + model_id: string; + name: string; + epoch: number; + val_loss: number; + created_at: string; + path: string; + size_mb: number; +} + +const MODEL_ARCHITECTURES: ModelArchitecture[] = [ + { + id: "csi-encoder-cnn", + name: "CSI Encoder (CNN)", + type: "encoder", + description: "Convolutional encoder for CSI amplitude/phase features", + params_m: 2.3, + memory_mb: 128, + }, + { + id: "csi-encoder-transformer", + name: "CSI Encoder (Transformer)", + type: "encoder", + description: "Self-attention based CSI feature extraction", + params_m: 8.5, + memory_mb: 384, + paper: "WiFi-ViT 2024", + }, + { + id: "pose-decoder-lstm", + name: "Pose Decoder (LSTM)", + type: "decoder", + description: "Recurrent decoder for temporal pose estimation", + params_m: 1.8, + memory_mb: 96, + }, + { + id: "pose-decoder-gru", + name: "Pose Decoder (GRU)", + type: "decoder", + description: "Gated recurrent unit pose decoder (faster)", + params_m: 1.2, + memory_mb: 64, + }, + { + id: "aether-embedding", + name: "AETHER Embedding", + type: "embedding", + description: "Contrastive CSI embedding for person re-identification (ADR-024)", + params_m: 4.2, + memory_mb: 192, + paper: "AETHER 2025", + }, + { + id: "meridian-adaptor", + name: "MERIDIAN Adaptor", + type: "adaptor", + description: "Cross-environment domain generalization module (ADR-027)", + params_m: 3.1, + memory_mb: 144, + paper: "MERIDIAN 2025", + }, +]; + +const ModelsTab: React.FC = () => { + const [checkpoints, setCheckpoints] = useState([]); + const [selectedModel, setSelectedModel] = useState(null); + const [exporting, setExporting] = useState(null); + const [error, setError] = useState(null); + + useEffect(() => { + loadCheckpoints(); + }, []); + + const loadCheckpoints = async () => { + try { + const loaded = await invoke("list_checkpoints"); + setCheckpoints(loaded); + } catch (err) { + // Mock data if command not implemented + setCheckpoints([ + { + id: "ckpt-001", + model_id: "csi-encoder-cnn", + name: "CSI-CNN v1.2", + epoch: 50, + val_loss: 0.0234, + created_at: "2026-03-08T14:30:00Z", + path: "~/.ruview/models/csi-cnn-v1.2.pt", + size_mb: 12.4, + }, + { + id: "ckpt-002", + model_id: "pose-decoder-gru", + name: "Pose-GRU v2.0", + epoch: 100, + val_loss: 0.0189, + created_at: "2026-03-09T09:15:00Z", + path: "~/.ruview/models/pose-gru-v2.pt", + size_mb: 8.2, + }, + ]); + } + }; + + const handleExport = async (checkpointId: string, format: "onnx" | "torchscript") => { + setExporting(checkpointId); + setError(null); + try { + await invoke("export_model", { checkpointId, format }); + // Success notification would go here + } catch (err) { + setError(`Export failed: ${err}`); + } finally { + setExporting(null); + } + }; + + const getTypeColor = (type: ModelArchitecture["type"]) => { + switch (type) { + case "encoder": + return "var(--accent)"; + case "decoder": + return "var(--status-online)"; + case "embedding": + return "#a855f7"; + case "adaptor": + return "#f59e0b"; + } + }; + + return ( +
+ {/* Stats Row */} +
+ + + acc + m.params_m, 0).toFixed(1)}M`} + /> + acc + c.size_mb, 0).toFixed(1)} MB`} + /> +
+ + {error && ( +
+ {error} +
+ )} + + {/* Model Architectures */} +

+ Available Architectures +

+
+ {MODEL_ARCHITECTURES.map((model) => ( +
setSelectedModel(model.id)} + > +
+
+

+ {model.name} +

+ + {model.type} + +
+ {model.paper && ( + + {model.paper} + + )} +
+

+ {model.description} +

+
+ 🧮 {model.params_m}M params + 💾 {model.memory_mb} MB +
+
+ ))} +
+ + {/* Checkpoints */} +

+ Saved Checkpoints +

+ {checkpoints.length === 0 ? ( +
+
📦
+

No checkpoints saved yet

+

Train a model to create checkpoints

+
+ ) : ( +
+ {checkpoints.map((ckpt) => ( +
+
+
{ckpt.name}
+
+ Epoch {ckpt.epoch} • Val Loss: {ckpt.val_loss.toFixed(4)} •{" "} + {ckpt.size_mb.toFixed(1)} MB +
+
+
+ + +
+
+ ))} +
+ )} +
+ ); +}; + +function StatCard({ + label, + value, + color, +}: { + label: string; + value: number | string; + color?: string; +}) { + return ( +
+
+ {label} +
+
+ {value} +
+
+ ); +} + +export default ModelsTab; diff --git a/rust-port/wifi-densepose-rs/crates/wifi-densepose-desktop/ui/src/pages/Training/RuVectorTab.tsx b/rust-port/wifi-densepose-rs/crates/wifi-densepose-desktop/ui/src/pages/Training/RuVectorTab.tsx new file mode 100644 index 00000000..a18ffcdc --- /dev/null +++ b/rust-port/wifi-densepose-rs/crates/wifi-densepose-desktop/ui/src/pages/Training/RuVectorTab.tsx @@ -0,0 +1,767 @@ +import React, { useState, useEffect } from "react"; +import { invoke } from "@tauri-apps/api/core"; + +interface RuVectorConfig { + // MinCut Parameters + mincut_enabled: boolean; + mincut_threshold: number; + mincut_max_persons: number; + + // Attention Parameters + attention_enabled: boolean; + attention_heads: number; + attention_dropout: number; + + // Temporal Parameters + temporal_enabled: boolean; + temporal_window_ms: number; + temporal_compression_ratio: number; + + // Solver Parameters + solver_enabled: boolean; + solver_interpolation: "linear" | "cubic" | "sparse"; + solver_subcarrier_count: number; + + // BVP Parameters + bvp_enabled: boolean; + bvp_filter_hz: [number, number]; +} + +const DEFAULT_CONFIG: RuVectorConfig = { + mincut_enabled: true, + mincut_threshold: 0.5, + mincut_max_persons: 5, + attention_enabled: true, + attention_heads: 4, + attention_dropout: 0.1, + temporal_enabled: true, + temporal_window_ms: 500, + temporal_compression_ratio: 4, + solver_enabled: true, + solver_interpolation: "sparse", + solver_subcarrier_count: 56, + bvp_enabled: false, + bvp_filter_hz: [0.7, 4.0], +}; + +const MODULES = [ + { + id: "mincut", + name: "MinCut Segmentation", + crate: "ruvector-mincut", + description: "Graph-based person segmentation using DynamicPersonMatcher", + icon: "✂️", + }, + { + id: "attention", + name: "Spatial Attention", + crate: "ruvector-attention", + description: "Attention-weighted antenna selection and BVP extraction", + icon: "🎯", + }, + { + id: "temporal", + name: "Temporal Tensor", + crate: "ruvector-temporal-tensor", + description: "Temporal CSI compression and breathing detection", + icon: "⏱️", + }, + { + id: "solver", + name: "Sparse Solver", + crate: "ruvector-solver", + description: "Sparse interpolation (114→56 subcarriers) and triangulation", + icon: "🧮", + }, + { + id: "attn-mincut", + name: "Attention MinCut", + crate: "ruvector-attn-mincut", + description: "Combined attention-weighted graph segmentation", + icon: "🔀", + }, +]; + +const RuVectorTab: React.FC = () => { + const [config, setConfig] = useState(DEFAULT_CONFIG); + const [testingLive, setTestingLive] = useState(false); + const [liveMetrics, setLiveMetrics] = useState<{ + fps: number; + latency_ms: number; + persons_detected: number; + } | null>(null); + const [saved, setSaved] = useState(true); + const [error, setError] = useState(null); + + useEffect(() => { + loadConfig(); + }, []); + + const loadConfig = async () => { + try { + const loaded = await invoke("get_ruvector_config"); + setConfig(loaded); + } catch (err) { + // Use defaults if not implemented + } + }; + + const saveConfig = async () => { + setError(null); + try { + await invoke("set_ruvector_config", { config }); + setSaved(true); + } catch (err) { + setError(`Failed to save: ${err}`); + } + }; + + const handleChange = ( + key: K, + value: RuVectorConfig[K] + ) => { + setConfig((prev) => ({ ...prev, [key]: value })); + setSaved(false); + }; + + const startLiveTest = async () => { + setTestingLive(true); + setError(null); + try { + // Simulate live testing metrics + const interval = setInterval(() => { + setLiveMetrics({ + fps: 25 + Math.random() * 10, + latency_ms: 15 + Math.random() * 10, + persons_detected: Math.floor(Math.random() * 3) + 1, + }); + }, 500); + + // Stop after 10 seconds for demo + setTimeout(() => { + clearInterval(interval); + setTestingLive(false); + setLiveMetrics(null); + }, 10000); + } catch (err) { + setError(`Live test failed: ${err}`); + setTestingLive(false); + } + }; + + const exportConfig = () => { + const blob = new Blob([JSON.stringify(config, null, 2)], { + type: "application/json", + }); + const url = URL.createObjectURL(blob); + const a = document.createElement("a"); + a.href = url; + a.download = "ruvector-config.json"; + a.click(); + URL.revokeObjectURL(url); + }; + + return ( +
+ {/* Module Cards */} +
+ {MODULES.map((mod) => { + const isEnabled = + config[`${mod.id.replace("-", "_")}_enabled` as keyof RuVectorConfig] ?? true; + return ( +
+
+ {mod.icon} + + {isEnabled ? "ON" : "OFF"} + +
+

+ {mod.name} +

+

+ {mod.description} +

+
+ {mod.crate} +
+
+ ); + })} +
+ + {error && ( +
+ {error} +
+ )} + +
+ {/* Configuration Panel */} +
+

+ Module Configuration +

+ + {/* MinCut Section */} + + handleChange("mincut_enabled", v)} + /> + handleChange("mincut_threshold", v)} + disabled={!config.mincut_enabled} + /> + handleChange("mincut_max_persons", v)} + disabled={!config.mincut_enabled} + /> + + + {/* Attention Section */} + + handleChange("attention_enabled", v)} + /> + handleChange("attention_heads", v)} + disabled={!config.attention_enabled} + /> + handleChange("attention_dropout", v)} + disabled={!config.attention_enabled} + /> + + + {/* Temporal Section */} + + handleChange("temporal_enabled", v)} + /> + handleChange("temporal_window_ms", v)} + disabled={!config.temporal_enabled} + /> + handleChange("temporal_compression_ratio", v)} + disabled={!config.temporal_enabled} + /> + + + {/* Solver Section */} + + handleChange("solver_enabled", v)} + /> +
+ + +
+ handleChange("solver_subcarrier_count", v)} + disabled={!config.solver_enabled} + /> + + + {/* Action Buttons */} +
+ + +
+
+ + {/* Live Testing Panel */} +
+

+ Live Testing +

+ +
+ {testingLive ? ( + <> +
+ 📡 +
+

+ Processing live CSI stream... +

+ + ) : ( + <> +
📡
+

+ Start live test to apply config to real CSI data +

+ + )} +
+ + {liveMetrics && ( +
+ + + +
+ )} + + + + {/* Presets */} +
+

+ Quick Presets +

+
+ { + setConfig({ + ...DEFAULT_CONFIG, + attention_heads: 2, + temporal_compression_ratio: 8, + solver_subcarrier_count: 28, + }); + setSaved(false); + }} + /> + { + setConfig({ + ...DEFAULT_CONFIG, + attention_heads: 8, + temporal_compression_ratio: 2, + solver_subcarrier_count: 114, + solver_interpolation: "cubic", + }); + setSaved(false); + }} + /> + { + setConfig(DEFAULT_CONFIG); + setSaved(false); + }} + /> +
+
+
+
+ + +
+ ); +}; + +// Helper Components +function ConfigSection({ title, children }: { title: string; children: React.ReactNode }) { + return ( +
+

+ {title} +

+ {children} +
+ ); +} + +function ToggleRow({ + label, + checked, + onChange, +}: { + label: string; + checked: boolean; + onChange: (v: boolean) => void; +}) { + return ( +
+ {label} + +
+ ); +} + +function SliderRow({ + label, + value, + min, + max, + step, + onChange, + disabled, +}: { + label: string; + value: number; + min: number; + max: number; + step: number; + onChange: (v: number) => void; + disabled?: boolean; +}) { + return ( +
+
+ {label} + + {value.toFixed(2)} + +
+ onChange(parseFloat(e.target.value))} + disabled={disabled} + style={{ width: "100%", cursor: disabled ? "not-allowed" : "pointer" }} + /> +
+ ); +} + +function NumberRow({ + label, + value, + min, + max, + step = 1, + onChange, + disabled, +}: { + label: string; + value: number; + min: number; + max: number; + step?: number; + onChange: (v: number) => void; + disabled?: boolean; +}) { + return ( +
+ {label} + onChange(parseInt(e.target.value) || min)} + disabled={disabled} + style={{ + width: 70, + padding: "4px 8px", + background: "var(--bg-secondary)", + border: "1px solid var(--border)", + borderRadius: 4, + color: "var(--text-primary)", + fontSize: 12, + textAlign: "right", + cursor: disabled ? "not-allowed" : "text", + }} + /> +
+ ); +} + +function MetricCard({ label, value }: { label: string; value: string }) { + return ( +
+
{label}
+
{value}
+
+ ); +} + +function PresetButton({ + label, + description, + onClick, +}: { + label: string; + description: string; + onClick: () => void; +}) { + return ( + + ); +} + +const labelStyle: React.CSSProperties = { + display: "block", + fontSize: 11, + fontWeight: 600, + color: "var(--text-muted)", + marginBottom: 4, +}; + +const inputStyle: React.CSSProperties = { + width: "100%", + padding: "8px 12px", + background: "var(--bg-secondary)", + border: "1px solid var(--border)", + borderRadius: 6, + color: "var(--text-primary)", + fontSize: 13, +}; + +export default RuVectorTab; diff --git a/rust-port/wifi-densepose-rs/crates/wifi-densepose-desktop/ui/src/pages/Training/TrainingTab.tsx b/rust-port/wifi-densepose-rs/crates/wifi-densepose-desktop/ui/src/pages/Training/TrainingTab.tsx new file mode 100644 index 00000000..252cbe4c --- /dev/null +++ b/rust-port/wifi-densepose-rs/crates/wifi-densepose-desktop/ui/src/pages/Training/TrainingTab.tsx @@ -0,0 +1,601 @@ +import React, { useState, useEffect } from "react"; +import { invoke } from "@tauri-apps/api/core"; +import { listen, UnlistenFn } from "@tauri-apps/api/event"; + +interface TrainingConfig { + dataset_id: string; + model_id: string; + epochs: number; + batch_size: number; + learning_rate: number; + optimizer: "adam" | "sgd" | "adamw"; + weight_decay: number; + use_augmentation: boolean; + checkpoint_every: number; +} + +interface TrainingProgress { + epoch: number; + total_epochs: number; + batch: number; + total_batches: number; + train_loss: number; + val_loss: number | null; + learning_rate: number; + eta_secs: number; + gpu_memory_mb: number | null; +} + +interface TrainingJob { + id: string; + status: "running" | "paused" | "completed" | "failed"; + started_at: string; + progress: TrainingProgress; +} + +const DEFAULT_CONFIG: TrainingConfig = { + dataset_id: "mmfi", + model_id: "csi-encoder-cnn", + epochs: 100, + batch_size: 32, + learning_rate: 0.001, + optimizer: "adam", + weight_decay: 0.0001, + use_augmentation: true, + checkpoint_every: 10, +}; + +interface TrainingTabProps { + gpuAvailable: boolean; +} + +const TrainingTab: React.FC = ({ gpuAvailable }) => { + const [config, setConfig] = useState(DEFAULT_CONFIG); + const [currentJob, setCurrentJob] = useState(null); + const [lossHistory, setLossHistory] = useState<{ epoch: number; train: number; val: number }[]>( + [] + ); + const [error, setError] = useState(null); + + useEffect(() => { + let unlisten: UnlistenFn | undefined; + + const setupListener = async () => { + try { + unlisten = await listen("training:progress", (event) => { + const progress = event.payload; + setCurrentJob((prev) => + prev + ? { ...prev, progress } + : { + id: "job-1", + status: "running", + started_at: new Date().toISOString(), + progress, + } + ); + + if (progress.val_loss !== null && progress.batch === progress.total_batches) { + setLossHistory((prev) => [ + ...prev, + { + epoch: progress.epoch, + train: progress.train_loss, + val: progress.val_loss!, + }, + ]); + } + }); + } catch (err) { + console.error("Failed to setup training listener:", err); + } + }; + + setupListener(); + + return () => { + if (unlisten) unlisten(); + }; + }, []); + + const handleStartTraining = async () => { + setError(null); + try { + await invoke("start_training", { config }); + setCurrentJob({ + id: `job-${Date.now()}`, + status: "running", + started_at: new Date().toISOString(), + progress: { + epoch: 0, + total_epochs: config.epochs, + batch: 0, + total_batches: 0, + train_loss: 0, + val_loss: null, + learning_rate: config.learning_rate, + eta_secs: 0, + gpu_memory_mb: null, + }, + }); + } catch (err) { + setError(`Failed to start training: ${err}`); + } + }; + + const handleStopTraining = async () => { + try { + await invoke("stop_training"); + setCurrentJob((prev) => (prev ? { ...prev, status: "paused" } : null)); + } catch (err) { + setError(`Failed to stop training: ${err}`); + } + }; + + const formatEta = (seconds: number) => { + if (seconds < 60) return `${seconds}s`; + if (seconds < 3600) return `${Math.floor(seconds / 60)}m ${seconds % 60}s`; + const hours = Math.floor(seconds / 3600); + const mins = Math.floor((seconds % 3600) / 60); + return `${hours}h ${mins}m`; + }; + + const progress = currentJob?.progress; + const epochProgress = progress ? (progress.epoch / progress.total_epochs) * 100 : 0; + const batchProgress = progress && progress.total_batches > 0 + ? (progress.batch / progress.total_batches) * 100 + : 0; + + return ( +
+ {/* GPU Warning */} + {!gpuAvailable && ( +
+ ⚠️ +
+
+ GPU Not Available +
+
+ Training will use CPU, which is significantly slower. Consider using a + machine with CUDA or Metal support. +
+
+
+ )} + + {error && ( +
+ {error} +
+ )} + +
+ {/* Configuration Panel */} +
+

+ Training Configuration +

+ +
+
+ + +
+ +
+ + +
+ +
+
+ + setConfig({ ...config, epochs: parseInt(e.target.value) || 1 })} + min={1} + max={1000} + style={inputStyle} + /> +
+
+ + + setConfig({ ...config, batch_size: parseInt(e.target.value) || 1 }) + } + min={1} + max={512} + style={inputStyle} + /> +
+
+ +
+
+ + + setConfig({ ...config, learning_rate: parseFloat(e.target.value) || 0.001 }) + } + step={0.0001} + min={0.00001} + max={1} + style={inputStyle} + /> +
+
+ + +
+
+ +
+
+ + + setConfig({ ...config, weight_decay: parseFloat(e.target.value) || 0 }) + } + step={0.0001} + min={0} + max={1} + style={inputStyle} + /> +
+
+ + + setConfig({ ...config, checkpoint_every: parseInt(e.target.value) || 1 }) + } + min={1} + max={100} + style={inputStyle} + /> +
+
+ +
+ setConfig({ ...config, use_augmentation: e.target.checked })} + style={{ width: 16, height: 16 }} + /> + +
+ +
+ {currentJob?.status === "running" ? ( + + ) : ( + + )} +
+
+
+ + {/* Progress Panel */} +
+

+ Training Progress +

+ + {!currentJob ? ( +
+
🎯
+

No training job running

+

Configure and start training to begin

+
+ ) : ( +
+ {/* Status */} +
+
+ + + {currentJob.status} + +
+ + ETA: {formatEta(progress?.eta_secs ?? 0)} + +
+ + {/* Epoch Progress */} +
+
+ Epoch + + {progress?.epoch ?? 0} / {progress?.total_epochs ?? config.epochs} + +
+
+
+
+
+ + {/* Batch Progress */} +
+
+ Batch + + {progress?.batch ?? 0} / {progress?.total_batches ?? 0} + +
+
+
+
+
+ + {/* Stats Grid */} +
+
+
+ Train Loss +
+
+ {progress?.train_loss.toFixed(4) ?? "—"} +
+
+
+
+ Val Loss +
+
+ {progress?.val_loss?.toFixed(4) ?? "—"} +
+
+
+
+ Learning Rate +
+
+ {progress?.learning_rate.toExponential(2) ?? "—"} +
+
+
+
+ GPU Memory +
+
+ {progress?.gpu_memory_mb ? `${progress.gpu_memory_mb} MB` : "N/A"} +
+
+
+ + {/* Mini Loss Chart */} + {lossHistory.length > 0 && ( +
+
+ Loss History +
+
+ {lossHistory.slice(-20).map((h, i) => ( +
+ ))} +
+
+ )} +
+ )} +
+
+ + +
+ ); +}; + +const labelStyle: React.CSSProperties = { + display: "block", + fontSize: 11, + fontWeight: 600, + color: "var(--text-muted)", + marginBottom: 4, + textTransform: "uppercase", + letterSpacing: "0.04em", +}; + +const inputStyle: React.CSSProperties = { + width: "100%", + padding: "8px 12px", + background: "var(--bg-secondary)", + border: "1px solid var(--border)", + borderRadius: 6, + color: "var(--text-primary)", + fontSize: 13, +}; + +export default TrainingTab; diff --git a/rust-port/wifi-densepose-rs/crates/wifi-densepose-desktop/ui/src/pages/Training/index.tsx b/rust-port/wifi-densepose-rs/crates/wifi-densepose-desktop/ui/src/pages/Training/index.tsx new file mode 100644 index 00000000..fcd02480 --- /dev/null +++ b/rust-port/wifi-densepose-rs/crates/wifi-densepose-desktop/ui/src/pages/Training/index.tsx @@ -0,0 +1,165 @@ +import React, { useState, useEffect } from "react"; +import { invoke } from "@tauri-apps/api/core"; +import DatasetsTab from "./DatasetsTab"; +import ModelsTab from "./ModelsTab"; +import TrainingTab from "./TrainingTab"; +import RuVectorTab from "./RuVectorTab"; +import MetricsTab from "./MetricsTab"; + +type TrainingTabType = "datasets" | "models" | "training" | "ruvector" | "metrics"; + +interface GpuInfo { + available: boolean; + name: string | null; + memory_mb: number | null; + cuda_version: string | null; + metal_supported: boolean; +} + +const Training: React.FC = () => { + const [activeTab, setActiveTab] = useState("datasets"); + const [gpuInfo, setGpuInfo] = useState(null); + const [loading, setLoading] = useState(true); + + useEffect(() => { + detectGpu(); + }, []); + + const detectGpu = async () => { + try { + const info = await invoke("detect_gpu"); + setGpuInfo(info); + } catch (err) { + console.error("GPU detection failed:", err); + setGpuInfo({ + available: false, + name: null, + memory_mb: null, + cuda_version: null, + metal_supported: false, + }); + } finally { + setLoading(false); + } + }; + + const tabs: { id: TrainingTabType; label: string; icon: string }[] = [ + { id: "datasets", label: "Datasets", icon: "📊" }, + { id: "models", label: "Models", icon: "🧠" }, + { id: "training", label: "Training", icon: "⚡" }, + { id: "ruvector", label: "RuVector", icon: "📡" }, + { id: "metrics", label: "Metrics", icon: "📈" }, + ]; + + return ( +
+ {/* Header */} +
+
+

+ Training & Models +

+

+ Train pose estimation models and configure RuVector signal processing +

+
+ + {/* GPU Status */} +
+ {gpuInfo?.available ? "🎮" : "💻"} +
+
+ {loading + ? "Detecting GPU..." + : gpuInfo?.available + ? gpuInfo.name || "GPU Available" + : "CPU Mode"} +
+
+ {gpuInfo?.cuda_version + ? `CUDA ${gpuInfo.cuda_version}` + : gpuInfo?.metal_supported + ? "Metal Supported" + : "No GPU acceleration"} + {gpuInfo?.memory_mb && ` • ${Math.round(gpuInfo.memory_mb / 1024)}GB`} +
+
+
+
+ + {/* Tabs */} +
+ {tabs.map((tab) => ( + + ))} +
+ + {/* Tab Content */} +
+ {activeTab === "datasets" && } + {activeTab === "models" && } + {activeTab === "training" && } + {activeTab === "ruvector" && } + {activeTab === "metrics" && } +
+
+ ); +}; + +export default Training;