scirs2-metrics 0.3.0

Machine Learning evaluation metrics module for SciRS2 (scirs2-metrics)
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112

//! Robotic perception metrics
//!
//! This module provides metrics for evaluating robotic perception systems,
//! including object detection, scene understanding, and sensor fusion.

#![allow(clippy::too_many_arguments)]
#![allow(dead_code)]

use super::core::{RealTimePerformanceMetrics, BoundingBox};
use serde::{Deserialize, Serialize};
use std::time::Duration;

/// Robotic perception evaluation metrics
#[derive(Debug, Clone)]
pub struct RoboticPerceptionMetrics {
    /// Object detection performance
    pub object_detection: ObjectDetectionMetrics,
    /// Scene understanding capabilities
    pub scene_understanding: SceneUnderstandingMetrics,
    /// Sensor fusion quality
    pub sensor_fusion: SensorFusionMetrics,
    /// Float-time performance
    pub real_time_performance: RealTimePerformanceMetrics,
}

/// Object detection evaluation
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct ObjectDetectionMetrics {
    /// Detection accuracy (mAP)
    pub detection_accuracy: f64,
    /// False positive rate
    pub false_positive_rate: f64,
    /// False negative rate
    pub false_negative_rate: f64,
    /// Localization accuracy
    pub localization_accuracy: f64,
    /// Detection latency
    pub detection_latency: Duration,
}

/// Scene understanding evaluation
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct SceneUnderstandingMetrics {
    /// Semantic segmentation accuracy
    pub segmentation_accuracy: f64,
    /// Depth estimation accuracy
    pub depth_accuracy: f64,
    /// Scene classification accuracy
    pub classification_accuracy: f64,
    /// Spatial relationship understanding
    pub spatial_understanding: f64,
}

/// Sensor fusion quality metrics
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct SensorFusionMetrics {
    /// Fusion accuracy improvement
    pub accuracy_improvement: f64,
    /// Sensor agreement score
    pub sensor_agreement: f64,
    /// Uncertainty quantification quality
    pub uncertainty_quality: f64,
    /// Robustness to sensor failures
    pub failure_robustness: f64,
}

impl RoboticPerceptionMetrics {
    /// Create new robotic perception metrics
    pub fn new() -> Self {
        Self {
            object_detection: ObjectDetectionMetrics::default(),
            scene_understanding: SceneUnderstandingMetrics::default(),
            sensor_fusion: SensorFusionMetrics::default(),
            real_time_performance: RealTimePerformanceMetrics::default(),
        }
    }
}

// Default implementations
impl Default for ObjectDetectionMetrics {
    fn default() -> Self {
        Self {
            detection_accuracy: 0.9,
            false_positive_rate: 0.05,
            false_negative_rate: 0.05,
            localization_accuracy: 0.85,
            detection_latency: Duration::from_millis(100),
        }
    }
}

impl Default for SceneUnderstandingMetrics {
    fn default() -> Self {
        Self {
            segmentation_accuracy: 0.85,
            depth_accuracy: 0.8,
            classification_accuracy: 0.9,
            spatial_understanding: 0.75,
        }
    }
}

impl Default for SensorFusionMetrics {
    fn default() -> Self {
        Self {
            accuracy_improvement: 0.1,
            sensor_agreement: 0.9,
            uncertainty_quality: 0.8,
            failure_robustness: 0.7,
        }
    }
}