smartcore 0.6.5

Machine Learning in Rust.
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

//! Stage 3: edge-case & known-answer parity tests for src/decomposition.
//!
//! Covers: PCA, SVD.
//! Tracking issue: #394 / #391.

#[cfg(test)]
mod decomposition_edge_cases {
    use crate::linalg::basic::matrix::DenseMatrix;
    use crate::decomposition::pca::{PCA, PCAParameters};
    use crate::decomposition::svd::{SVD, SVDParameters};

    // ── PCA ───────────────────────────────────────────────────────────────────

    /// n_components=1 on 2D data: output must be 1D.
    #[test]
    fn pca_n_components_one() {
        let x = DenseMatrix::from_2d_array(&[
            &[1.0_f64, 2.0],
            &[3.0, 4.0],
            &[5.0, 6.0],
            &[7.0, 8.0],
        ]).unwrap();
        let model = PCA::fit(&x, PCAParameters::default().with_n_components(1)).unwrap();
        let transformed = model.transform(&x).unwrap();
        let (_, ncols) = transformed.shape();
        assert_eq!(ncols, 1, "n_components=1 should produce 1-column output");
    }

    /// n_components = rank: reconstruction error should be near zero.
    #[test]
    fn pca_full_rank_reconstruction() {
        let x = DenseMatrix::from_2d_array(&[
            &[1.0_f64, 0.0],
            &[0.0, 1.0],
            &[1.0, 1.0],
            &[2.0, 1.0],
        ]).unwrap();
        let model = PCA::fit(&x, PCAParameters::default().with_n_components(2)).unwrap();
        let t = model.transform(&x).unwrap();
        let reconstructed = model.inverse_transform(&t).unwrap();
        let (nrows, ncols) = x.shape();
        let mut mse = 0.0_f64;
        for i in 0..nrows {
            for j in 0..ncols {
                let diff = x.get((i, j)) - reconstructed.get((i, j));
                mse += diff * diff;
            }
        }
        mse /= (nrows * ncols) as f64;
        assert!(mse < 1e-6, "full-rank PCA reconstruction MSE={mse} should be ~0");
    }

    /// Rank-deficient input: PCA must not panic.
    #[test]
    fn pca_rank_deficient_input() {
        // Column 2 = column 1: rank = 1.
        let x = DenseMatrix::from_2d_array(&[
            &[1.0_f64, 1.0],
            &[2.0, 2.0],
            &[3.0, 3.0],
            &[4.0, 4.0],
        ]).unwrap();
        let result = PCA::fit(&x, PCAParameters::default().with_n_components(1));
        assert!(result.is_ok(), "PCA must not fail on rank-deficient input");
    }

    /// Determinism: same data always gives same projection.
    #[test]
    fn pca_deterministic() {
        let x = DenseMatrix::from_2d_array(&[
            &[2.0_f64, 3.0],
            &[1.0, 5.0],
            &[4.0, 2.0],
            &[6.0, 1.0],
        ]).unwrap();
        let t1 = PCA::fit(&x, PCAParameters::default().with_n_components(1)).unwrap().transform(&x).unwrap();
        let t2 = PCA::fit(&x, PCAParameters::default().with_n_components(1)).unwrap().transform(&x).unwrap();
        let (nrows, _) = t1.shape();
        for i in 0..nrows {
            // Components may flip sign; compare abs values.
            assert!((t1.get((i, 0)).abs() - t2.get((i, 0)).abs()).abs() < 1e-6);
        }
    }

    // ── SVD ───────────────────────────────────────────────────────────────────

    /// n_components=1 on 3-column data: output must be 1-column.
    #[test]
    fn svd_decomp_n_components_one() {
        let x = DenseMatrix::from_2d_array(&[
            &[1.0_f64, 2.0, 3.0],
            &[4.0, 5.0, 6.0],
            &[7.0, 8.0, 9.0],
            &[10.0, 11.0, 12.0],
        ]).unwrap();
        let model = SVD::fit(&x, SVDParameters::default().with_n_components(1)).unwrap();
        let transformed = model.transform(&x).unwrap();
        let (_, ncols) = transformed.shape();
        assert_eq!(ncols, 1);
    }

    /// Reconstruction error for full-rank SVD should be near zero.
    #[test]
    fn svd_decomp_full_reconstruction() {
        let x = DenseMatrix::from_2d_array(&[
            &[1.0_f64, 0.0],
            &[0.0, 2.0],
            &[1.0, 2.0],
            &[3.0, 1.0],
        ]).unwrap();
        let model = SVD::fit(&x, SVDParameters::default().with_n_components(2)).unwrap();
        let t = model.transform(&x).unwrap();
        let reconstructed = model.inverse_transform(&t).unwrap();
        let (nrows, ncols) = x.shape();
        let mut mse = 0.0_f64;
        for i in 0..nrows {
            for j in 0..ncols {
                let diff = x.get((i, j)) - reconstructed.get((i, j));
                mse += diff * diff;
            }
        }
        mse /= (nrows * ncols) as f64;
        assert!(mse < 1e-6, "full-rank SVD reconstruction MSE={mse} should be ~0");
    }

    /// Rank-deficient input must not panic.
    #[test]
    fn svd_decomp_rank_deficient_no_panic() {
        let x = DenseMatrix::from_2d_array(&[
            &[1.0_f64, 1.0],
            &[2.0, 2.0],
            &[3.0, 3.0],
        ]).unwrap();
        assert!(SVD::fit(&x, SVDParameters::default().with_n_components(1)).is_ok());
    }
}