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
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134

//! Advanced uncertainty quantification methods
//!
//! This module provides advanced uncertainty quantification techniques
//! including multi-scale uncertainty and specialized analysis methods.

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

use scirs2_core::ndarray::{Array1, Array2};
use scirs2_core::numeric::Float;

/// Advanced uncertainty analysis
#[derive(Debug, Clone)]
pub struct AdvancedUncertaintyAnalysis<F: Float> {
    /// Multi-scale uncertainty
    pub multi_scale: MultiscaleUncertainty<F>,
    /// Uncertainty decomposition
    pub decomposition: UncertaintyDecomposition<F>,
    /// Coverage analysis
    pub coverage: CoverageAnalysis<F>,
}

/// Multi-scale uncertainty quantification results
#[derive(Debug, Clone)]
pub struct MultiscaleUncertainty<F: Float> {
    /// Local uncertainty estimates
    pub local_uncertainty: Array1<F>,
    /// Global uncertainty estimates
    pub global_uncertainty: F,
    /// Scale-specific uncertainties
    pub scale_uncertainties: Vec<Array1<F>>,
    /// Uncertainty at different resolutions
    pub resolution_uncertainties: Vec<F>,
}

/// Uncertainty decomposition into different sources
#[derive(Debug, Clone)]
pub struct UncertaintyDecomposition<F: Float> {
    /// Model uncertainty
    pub model_uncertainty: F,
    /// Data uncertainty
    pub data_uncertainty: F,
    /// Parameter uncertainty
    pub parameter_uncertainty: F,
    /// Structural uncertainty
    pub structural_uncertainty: F,
    /// Total uncertainty
    pub total_uncertainty: F,
}

/// Coverage analysis for uncertainty estimates
#[derive(Debug, Clone)]
pub struct CoverageAnalysis<F: Float> {
    /// Empirical coverage
    pub empirical_coverage: F,
    /// Theoretical coverage
    pub theoretical_coverage: F,
    /// Coverage deviation
    pub coverage_deviation: F,
    /// Conditional coverage by groups
    pub conditional_coverage: Vec<F>,
}

impl<F: Float> AdvancedUncertaintyAnalysis<F> {
    /// Create new advanced uncertainty analysis
    pub fn new() -> Self {
        Self {
            multi_scale: MultiscaleUncertainty::new(),
            decomposition: UncertaintyDecomposition::new(),
            coverage: CoverageAnalysis::new(),
        }
    }
}

impl<F: Float> MultiscaleUncertainty<F> {
    /// Create new multi-scale uncertainty
    pub fn new() -> Self {
        Self {
            local_uncertainty: Array1::zeros(0),
            global_uncertainty: F::zero(),
            scale_uncertainties: Vec::new(),
            resolution_uncertainties: Vec::new(),
        }
    }
}

impl<F: Float> UncertaintyDecomposition<F> {
    /// Create new uncertainty decomposition
    pub fn new() -> Self {
        Self {
            model_uncertainty: F::zero(),
            data_uncertainty: F::zero(),
            parameter_uncertainty: F::zero(),
            structural_uncertainty: F::zero(),
            total_uncertainty: F::zero(),
        }
    }
}

impl<F: Float> CoverageAnalysis<F> {
    /// Create new coverage analysis
    pub fn new() -> Self {
        Self {
            empirical_coverage: F::zero(),
            theoretical_coverage: F::zero(),
            coverage_deviation: F::zero(),
            conditional_coverage: Vec::new(),
        }
    }
}

impl<F: Float> Default for AdvancedUncertaintyAnalysis<F> {
    fn default() -> Self {
        Self::new()
    }
}

impl<F: Float> Default for MultiscaleUncertainty<F> {
    fn default() -> Self {
        Self::new()
    }
}

impl<F: Float> Default for UncertaintyDecomposition<F> {
    fn default() -> Self {
        Self::new()
    }
}

impl<F: Float> Default for CoverageAnalysis<F> {
    fn default() -> Self {
        Self::new()
    }
}