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

//! Dictionary initialization strategies

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

/// Initialization strategies
#[derive(Debug, Clone, Copy)]
#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
pub enum InitializationStrategy {
    Random,
    DataDriven,
    Orthogonal,
    SVD,
}

/// Initialization configuration
#[derive(Debug, Clone)]
#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
pub struct InitializationConfig {
    pub strategy: InitializationStrategy,
    pub scale: Float,
    pub normalize: bool,
}

impl Default for InitializationConfig {
    fn default() -> Self {
        Self {
            strategy: InitializationStrategy::Random,
            scale: 1.0,
            normalize: true,
        }
    }
}

/// Dictionary initializer
#[derive(Debug, Clone)]
#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
pub struct DictionaryInitializer {
    config: InitializationConfig,
}

/// Random initializer
#[derive(Debug, Clone)]
#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
pub struct RandomInitializer {
    scale: Float,
}

/// Data-driven initializer
#[derive(Debug, Clone)]
#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
pub struct DataDrivenInitializer {
    normalize: bool,
}

/// Orthogonal initializer
#[derive(Debug, Clone)]
#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
pub struct OrthogonalInitializer {
    scale: Float,
}

impl DictionaryInitializer {
    pub fn new(config: InitializationConfig) -> Self {
        Self { config }
    }

    pub fn initialize(
        &self,
        n_atoms: usize,
        n_features: usize,
        _data: Option<&Array2<Float>>,
    ) -> Result<Array2<Float>> {
        let mut rng = thread_rng();
        let mut dictionary = Array2::zeros((n_atoms, n_features));

        // Simple random initialization
        for i in 0..n_atoms {
            for j in 0..n_features {
                dictionary[[i, j]] = (rng.random::<Float>() - 0.5) * 2.0 * self.config.scale;
            }
        }

        if self.config.normalize {
            // Normalize atoms
            for mut row in dictionary.rows_mut() {
                let norm = row.mapv(|x| x * x).sum().sqrt();
                if norm > 0.0 {
                    row.mapv_inplace(|x| x / norm);
                }
            }
        }

        Ok(dictionary)
    }
}