Struct linfa_reduction::DiffusionMap

pub struct DiffusionMap<F> { /* private fields */ }

Embedding of diffusion map technique

After transforming the dataset with diffusion map this structure store the embedding for further use. No straightforward prediction can be made from the embedding and the algorithm falls therefore in the class of transformers.

The diffusion map computes an embedding of the data by applying PCA on the diffusion operator of the data. It transforms the data along the direction of the largest diffusion flow and is therefore a non-linear dimensionality reduction technique. A normalized kernel describes the high dimensional diffusion graph with the (i, j) entry the probability that a diffusion happens from point i to j.

Example

use linfa::traits::Transformer;
use linfa_kernel::{Kernel, KernelType, KernelMethod};
use linfa_reduction::DiffusionMap;

let dataset = linfa_datasets::iris();

// generate sparse gaussian kernel with eps = 2 and 15 neighbors
let kernel = Kernel::params()
    .kind(KernelType::Sparse(15))
    .method(KernelMethod::Gaussian(2.0))
    .transform(dataset.records());

// create embedding from kernel matrix using diffusion maps
let mapped_kernel = DiffusionMap::<f64>::params(2)
    .steps(1)
    .transform(&kernel)
    .unwrap();

// get embedding from the transformed kernel matrix
let embedding = mapped_kernel.embedding();

Implementations

impl<F: Float> DiffusionMap<F>

pub fn estimate_clusters(&self) -> usize

Estimate the number of clusters in this embedding (very crude for now)

pub fn eigvals(&self) -> &Array1<F>

Return the eigenvalue of the diffusion operator

pub fn embedding(&self) -> &Array2<F>

Return the embedding

impl<F> DiffusionMap<F>

pub fn params(embedding_size: usize) -> DiffusionMapParams

Trait Implementations

impl<F: Clone> Clone for DiffusionMap<F>

fn clone(&self) -> DiffusionMap<F>

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<F: Debug> Debug for DiffusionMap<F>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<F: PartialEq> PartialEq for DiffusionMap<F>

fn eq(&self, other: &DiffusionMap<F>) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<'a, F: Float> Transformer<&'a KernelBase<ArrayBase<OwnedRepr<F>, Dim<[usize; 2]>>, CsMatBase<F, usize, Vec<usize>, Vec<usize>, Vec<F>>>, DiffusionMap<F>> for DiffusionMapValidParams

fn transform(&self, kernel: &'a Kernel<F>) -> DiffusionMap<F>

Project a kernel matrix to its embedding

Parameter

• kernel: Kernel matrix

Returns

Embedding for each observation in the kernel matrix

impl<F> StructuralPartialEq for DiffusionMap<F>