scirs2-cluster 0.3.4

Clustering algorithms module for SciRS2 (scirs2-cluster)
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

//! Unit tests for clustering algorithms

#[cfg(test)]
mod test {
    use crate::metrics::silhouette_score;
    use crate::vq::{kmeans2, whiten, MinitMethod, MissingMethod};
    use scirs2_core::ndarray::{array, Array2};

    #[test]
    fn test_whiten() {
        let data: Array2<f64> =
            Array2::from_shape_vec((4, 2), vec![1.0, 2.0, 1.5, 2.5, 0.5, 1.5, 2.0, 3.0])
                .expect("Operation failed");

        let whitened = whiten(&data).expect("Operation failed");

        // Check that whitened data has unit variance
        let n_features = whitened.shape()[1];
        for j in 0..n_features {
            let column = whitened.column(j);
            let mean: f64 = column.mean().expect("Operation failed");
            let var: f64 = column.var(1.0);

            assert!((mean.abs()) < 1e-6, "Mean should be close to 0");
            assert!((var - 1.0).abs() < 1e-6, "Variance should be close to 1");
        }
    }

    #[test]
    fn test_kmeans2_all_init_methods() {
        let data = Array2::from_shape_vec((20, 2), (0..40).map(|i| i as f64 / 10.0).collect())
            .expect("Operation failed");

        let init_methods = vec![
            MinitMethod::Random,
            MinitMethod::Points,
            MinitMethod::PlusPlus,
        ];

        for method in init_methods {
            let (centroids, labels) = kmeans2(
                data.view(),
                3,
                Some(10),
                Some(1e-4),
                Some(method),
                Some(MissingMethod::Warn),
                Some(true),
                Some(42),
            )
            .expect("Operation failed");

            assert_eq!(centroids.shape()[0], 3);
            assert_eq!(centroids.shape()[1], 2);
            assert_eq!(labels.len(), 20);
        }
    }

    #[test]
    fn test_kmeans2_empty_cluster_handling() {
        // Create data that will likely result in empty clusters
        let data = Array2::from_shape_vec(
            (6, 2),
            vec![
                0.0, 0.0, 0.1, 0.1, 0.2, 0.2, 10.0, 10.0, 10.1, 10.1, 10.2, 10.2,
            ],
        )
        .expect("Operation failed");

        // Test with warning on empty clusters
        let result1 = kmeans2(
            data.view(),
            3,
            Some(5),
            Some(1e-4),
            Some(MinitMethod::Random),
            Some(MissingMethod::Warn),
            Some(true),
            Some(123),
        );

        // Should succeed with warning
        assert!(result1.is_ok());

        // Test with raising on empty clusters
        let result2 = kmeans2(
            data.view(),
            4, // More clusters than natural groups
            Some(5),
            Some(1e-4),
            Some(MinitMethod::Random),
            Some(MissingMethod::Raise),
            Some(true),
            Some(456),
        );

        // Might fail if empty cluster is created
        match result2 {
            Ok(_) => println!("Succeeded without empty clusters"),
            Err(e) => println!("Failed as expected: {e}"),
        }
    }

    #[test]
    fn test_silhouette_score() {
        // Create two well-separated clusters
        let data = array![
            [1.0, 1.0],
            [1.5, 1.5],
            [1.2, 1.3],
            [10.0, 10.0],
            [10.5, 10.5],
            [10.2, 10.3],
        ];

        let labels = array![0, 0, 0, 1, 1, 1];

        let score = silhouette_score(data.view(), labels.view()).expect("Operation failed");

        // Well-separated clusters should have high silhouette score
        assert!(
            score > 0.8,
            "Silhouette score should be high for well-separated clusters"
        );
    }

    #[test]
    fn test_silhouette_with_noise() {
        // Create data with noise points (label -1)
        let data = array![
            [1.0, 1.0],
            [1.5, 1.5],
            [10.0, 10.0],
            [10.5, 10.5],
            [50.0, 50.0], // noise
        ];

        let labels = array![0, 0, 1, 1, -1];

        let score = silhouette_score(data.view(), labels.view()).expect("Operation failed");

        // Should handle noise points correctly
        assert!(score > 0.0);
    }
}