sklears-decomposition 0.2.0

Matrix decomposition algorithms for sklears: PCA, ICA, NMF, SVD
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
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150

//! Evaluation and metrics for dictionary learning

use scirs2_core::ndarray::Array2;
#[cfg(feature = "serde")]
use serde::{Deserialize, Serialize};
use sklears_core::{error::Result, types::Float};

/// Reconstruction error metrics
#[derive(Debug, Clone)]
#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
pub struct ReconstructionError {
    pub mse: Float,
    pub rmse: Float,
    pub mae: Float,
    pub relative_error: Float,
}

/// Sparsity metrics
#[derive(Debug, Clone)]
#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
pub struct SparsityMetrics {
    pub l0_norm: Float,
    pub l1_norm: Float,
    pub sparsity_ratio: Float,
    pub gini_coefficient: Float,
}

/// Coherence metrics for dictionary quality
#[derive(Debug, Clone)]
#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
pub struct CoherenceMetrics {
    pub mutual_coherence: Float,
    pub spark: usize,
    pub condition_number: Float,
}

/// Dictionary quality assessment
#[derive(Debug, Clone)]
#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
pub struct DictionaryQuality {
    pub reconstruction_error: ReconstructionError,
    pub sparsity_metrics: SparsityMetrics,
    pub coherence_metrics: CoherenceMetrics,
}

/// Dictionary metrics calculator
#[derive(Debug, Clone)]
#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
pub struct DictionaryMetrics;

impl DictionaryMetrics {
    pub fn new() -> Self {
        Self
    }

    pub fn compute_reconstruction_error(
        &self,
        original: &Array2<Float>,
        reconstructed: &Array2<Float>,
    ) -> Result<ReconstructionError> {
        let diff = original - reconstructed;
        let squared_diff = diff.mapv(|x| x * x);
        let mse = squared_diff.mean().unwrap_or(0.0);
        let rmse = mse.sqrt();

        let abs_diff = diff.mapv(|x| x.abs());
        let mae = abs_diff.mean().unwrap_or(0.0);

        let original_norm = original.mapv(|x| x * x).sum().sqrt();
        let relative_error = if original_norm > 0.0 {
            diff.mapv(|x| x * x).sum().sqrt() / original_norm
        } else {
            0.0
        };

        Ok(ReconstructionError {
            mse,
            rmse,
            mae,
            relative_error,
        })
    }

    pub fn compute_sparsity_metrics(&self, codes: &Array2<Float>) -> Result<SparsityMetrics> {
        let total_elements = codes.len() as Float;
        let non_zero_count = codes.iter().filter(|&&x| x.abs() > 1e-10).count() as Float;

        let l0_norm = non_zero_count;
        let l1_norm = codes.mapv(|x| x.abs()).sum();
        let sparsity_ratio = 1.0 - (non_zero_count / total_elements);
        let gini_coefficient = 0.0; // Simplified placeholder

        Ok(SparsityMetrics {
            l0_norm,
            l1_norm,
            sparsity_ratio,
            gini_coefficient,
        })
    }

    pub fn compute_coherence_metrics(
        &self,
        dictionary: &Array2<Float>,
    ) -> Result<CoherenceMetrics> {
        let n_atoms = dictionary.nrows();

        // Compute mutual coherence (simplified)
        let mut max_coherence: Float = 0.0;
        for i in 0..n_atoms {
            for j in (i + 1)..n_atoms {
                let atom_i = dictionary.row(i);
                let atom_j = dictionary.row(j);
                let coherence = atom_i.dot(&atom_j).abs();
                max_coherence = max_coherence.max(coherence);
            }
        }

        Ok(CoherenceMetrics {
            mutual_coherence: max_coherence,
            spark: n_atoms,        // Simplified
            condition_number: 1.0, // Placeholder
        })
    }

    pub fn compute_quality(
        &self,
        original: &Array2<Float>,
        dictionary: &Array2<Float>,
        codes: &Array2<Float>,
    ) -> Result<DictionaryQuality> {
        // Reconstruct data
        let reconstructed = codes.dot(dictionary);

        let reconstruction_error = self.compute_reconstruction_error(original, &reconstructed)?;
        let sparsity_metrics = self.compute_sparsity_metrics(codes)?;
        let coherence_metrics = self.compute_coherence_metrics(dictionary)?;

        Ok(DictionaryQuality {
            reconstruction_error,
            sparsity_metrics,
            coherence_metrics,
        })
    }
}

impl Default for DictionaryMetrics {
    fn default() -> Self {
        Self::new()
    }
}