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
82
83
84
85

//! RLX-backed compute backends that delegate to the strict reference until GPU kernels land.

use super::{ComputeBackend, RlxBackend};
use crate::knn::KnnError;
use crate::numpy_rng::NumpyRandomState;
use crate::{EmbeddingData, KnnGraphOptions};
use ndarray::Array2;
use sprs::CsMat;

/// Runs the strict EVōC pipeline; tagged with an RLX [`ComputeBackend`] for routing/env.
pub struct DelegateBackend {
    pub kind: ComputeBackend,
}

impl RlxBackend for DelegateBackend {
    fn kind(&self) -> ComputeBackend {
        self.kind
    }

    fn knn_graph(
        &self,
        data: EmbeddingData,
        opts: KnnGraphOptions,
        rng: &mut NumpyRandomState,
        strict_precision: bool,
    ) -> Result<(Array2<i32>, Array2<f32>), KnnError> {
        super::strict::StrictBackend.knn_graph(data, opts, rng, strict_precision)
    }

    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> {
        super::strict::StrictBackend.label_propagation_init(
            graph,
            n_label_prop_iter,
            n_embedding_epochs,
            approx_n_parts,
            n_components,
            scaling,
            random_scale,
            noise_level,
            rng,
            data,
            strict_precision,
        )
    }

    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> {
        super::strict::StrictBackend.node_embedding(
            graph,
            n_components,
            n_epochs,
            initial_embedding,
            initial_alpha,
            negative_sample_rate,
            noise_level,
            rng,
            reproducible_flag,
            strict_precision,
        )
    }
}