evoc 0.0.1

Embedding Vector Oriented Clustering — fast clustering of high-dimensional embedding vectors (Rust port of EVōC)
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

use super::{ComputeBackend, RlxBackend};
use crate::embed::node_embedding as strict_node_embedding;
use crate::knn::knn_graph as strict_knn_graph;
use crate::knn::KnnError;
use crate::label_prop::label_propagation_init as strict_label_propagation_init;
use crate::numpy_rng::NumpyRandomState;
use crate::{EmbeddingData, KnnGraphOptions};
use ndarray::Array2;
use sprs::CsMat;

pub struct StrictBackend;

impl RlxBackend for StrictBackend {
    fn kind(&self) -> ComputeBackend {
        ComputeBackend::Strict
    }

    fn knn_graph(
        &self,
        data: EmbeddingData,
        opts: KnnGraphOptions,
        rng: &mut NumpyRandomState,
        _strict_precision: bool,
    ) -> Result<(Array2<i32>, Array2<f32>), KnnError> {
        strict_knn_graph(data, opts, rng)
    }

    fn label_propagation_init(
        &self,
        graph: &CsMat<f32>,
        n_label_prop_iter: usize,
        n_embedding_epochs: usize,
        approx_n_parts: usize,
        n_components: usize,
        scaling: f32,
        random_scale: f32,
        noise_level: f32,
        rng: &mut NumpyRandomState,
        data: Option<&Array2<f32>>,
        _strict_precision: bool,
    ) -> Array2<f32> {
        strict_label_propagation_init(
            graph,
            n_label_prop_iter,
            n_embedding_epochs,
            approx_n_parts,
            n_components,
            scaling,
            random_scale,
            noise_level,
            rng,
            data,
        )
    }

    fn node_embedding(
        &self,
        graph: &CsMat<f32>,
        n_components: usize,
        n_epochs: usize,
        initial_embedding: Option<Array2<f32>>,
        initial_alpha: f32,
        negative_sample_rate: f32,
        noise_level: f32,
        rng: &mut NumpyRandomState,
        reproducible_flag: bool,
        _strict_precision: bool,
    ) -> Array2<f32> {
        strict_node_embedding(
            graph,
            n_components,
            n_epochs,
            initial_embedding,
            initial_alpha,
            negative_sample_rate,
            noise_level,
            rng,
            reproducible_flag,
        )
    }
}