scirs2-metrics 0.4.2

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

//! Bayesian uncertainty estimation methods
//!
//! This module provides Bayesian approaches to uncertainty quantification
//! including MCMC sampling and variational inference.

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

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

/// Bayesian uncertainty estimation
#[derive(Debug, Clone)]
pub struct BayesianUncertainty<F: Float> {
    /// Posterior mean
    pub posterior_mean: Array1<F>,
    /// Posterior variance
    pub posterior_variance: Array1<F>,
    /// Posterior samples
    pub posterior_samples: Array2<F>,
    /// Prior parameters
    pub prior_params: PriorParameters<F>,
    /// MCMC diagnostics
    pub mcmc_diagnostics: MCMCDiagnostics<F>,
}

/// Prior parameters for Bayesian inference
#[derive(Debug, Clone)]
pub struct PriorParameters<F: Float> {
    /// Prior mean
    pub mean: Array1<F>,
    /// Prior covariance
    pub covariance: Array2<F>,
    /// Prior precision
    pub precision: Array2<F>,
}

/// MCMC diagnostics
#[derive(Debug, Clone)]
pub struct MCMCDiagnostics<F: Float> {
    /// Effective sample size
    pub effective_sample_size: F,
    /// R-hat convergence statistic
    pub r_hat: F,
    /// Acceptance rate
    pub acceptance_rate: F,
    /// Autocorrelation function
    pub autocorrelation: Array1<F>,
}

/// Variational parameters for approximate inference
#[derive(Debug, Clone)]
pub struct VariationalParams<F: Float> {
    /// Variational mean
    pub mean: Array1<F>,
    /// Variational variance
    pub variance: Array1<F>,
    /// Lower bound (ELBO)
    pub elbo: F,
    /// KL divergence
    pub kl_divergence: F,
}

/// Variational uncertainty estimation
#[derive(Debug, Clone)]
pub struct VariationalUncertainty<F: Float> {
    /// Variational parameters
    pub params: VariationalParams<F>,
    /// Approximate posterior samples
    pub posterior_samples: Array2<F>,
    /// Evidence lower bound
    pub evidence_lower_bound: F,
}

impl<F: Float> BayesianUncertainty<F> {
    /// Create new Bayesian uncertainty with default parameters
    pub fn new(n_samples: usize, n_params: usize) -> Self {
        Self {
            posterior_mean: Array1::zeros(n_params),
            posterior_variance: Array1::zeros(n_params),
            posterior_samples: Array2::zeros((n_samples, n_params)),
            prior_params: PriorParameters::default(n_params),
            mcmc_diagnostics: MCMCDiagnostics::default(),
        }
    }
}

impl<F: Float> PriorParameters<F> {
    /// Create default prior parameters
    pub fn default(n_params: usize) -> Self {
        Self {
            mean: Array1::zeros(n_params),
            covariance: Array2::eye(n_params),
            precision: Array2::eye(n_params),
        }
    }
}

impl<F: Float> Default for MCMCDiagnostics<F> {
    fn default() -> Self {
        Self {
            effective_sample_size: F::zero(),
            r_hat: F::one(),
            acceptance_rate: F::zero(),
            autocorrelation: Array1::zeros(0),
        }
    }
}

impl<F: Float> VariationalUncertainty<F> {
    /// Create new variational uncertainty
    pub fn new(n_params: usize) -> Self {
        Self {
            params: VariationalParams {
                mean: Array1::zeros(n_params),
                variance: Array1::ones(n_params),
                elbo: F::neg_infinity(),
                kl_divergence: F::zero(),
            },
            posterior_samples: Array2::zeros((1000, n_params)),
            evidence_lower_bound: F::neg_infinity(),
        }
    }
}