Struct EmbedderParams 

pub struct EmbedderParams {
    pub asked_dim: usize,
    pub dmap_init: bool,
    pub beta: f64,
    pub b: f64,
    pub scale_rho: f64,
    pub grad_step: f64,
    pub nb_sampling_by_edge: usize,
    pub nb_grad_batch: usize,
    pub grad_factor: usize,
    pub hierarchy_layer: usize,
    pub hubness_weighting: bool,
}

It is necessary to describe briefly the model used in the embedding:

Definition of the weight of an edge of the graph to embed

First we define the local scale $\rho$ around a point.
It is defined as the mean of distances of points to their nearest neighbour. The points taken into account to define $\rho$ are the node we consider and all its knbn neighbours. So we compute the mean of distances to nearest neighbours on knbn + 1 points around current point.

let ($d_{i}$) be the sorted distances in increasing order of neighbours for i=0..k of a node n, $$w_{i} = \exp\left(- \left(\frac{d_{i} - d_{0}}{S * \rho}\right)^{\beta} \right)$$

S is a scale factor modulating $\rho$. After that weights are normalized to a probability distribution.

So before normalization $w_{0}$ is always equal to 1. Augmenting β to 2. makes the weight $w_{i}$ decrease faster. The least weight of an edge must not go under $10^{-5}$ to limit the range of weight and avoid Svd numeric difficulties. The code stops with an error in this case. So after normalization the range of weights from $w_{0}$ to $w_{k}$ is larger. Reducing S as similar effect but playing with both $\beta$ and the scale adjustment must not violate the range constraint on weights.

It must be noted that setting the scale as described before and renormalizing to get a probability distribution gives a perplexity nearly equal to the number of neighbours.
This can be verified by using the logging (implemented using the crates env_logger and log) and setting RUST_LOG=annembed=INFO in your environment. Then quantile summaries are given for the distributions of edge distances, edge weights, and perplexity of nodes. This helps adjusting parameters β, Scale and show their impact on these quantiles.

Default value :

$\beta = 1$ so that we have exponential weights similar to Umap.

$S = 0.5$

But it is possible to set β to 2. to get more gaussian weight or reduce to 0.5 and adjust S to respect the constraints on edge weights.

Definition of the weight of an edge of the embedded graph

The embedded edge has the usual expression : $$ w(x,y) = \frac{1}{1+ || \left((x - y)/a_{x} \right)||^{2*b} } $$

by default b = 1. The coefficient $a_{x}$ is deduced from the scale coefficient in the original space with some restriction to avoid too large fluctuations.

• Initial step of the gradient and number of batches

A number of batch for the Mnist digits data around 10-20 seems sufficient. The initial gradient step $\gamma_{0}$ can be chosen around 1. (in the range 1/5 … 5.).
Reasonably it should satisfy nb_batch $ * \gamma_{0} < 1 $

• asked_dimension : default is set to 2.

The optimization of the embedding

The embedding is optimized by minimizing the (Shannon at present time) cross entropy between distribution of original and embedded weight of edges. This minimization is done by a standard (multithreaded) stochastic gradient with negative sampling for the unobserved edges (see Mnih-Teh or Mikolov)

The number of negative edge sampling is set to a fixed value 5.

• expression of the gradient

here are the main parameters driving Embeding

Fields

asked_dim: usize

embedding dimension : default to 2

dmap_init: bool

defines if embedder is initialized by a diffusion map step. default to true

beta: f64

exponent used in defining edge weight in original graph. 0.5 or 1.

b: f64

exponenent used in embedded space, default 1.

scale_rho: f64

embedded scale factor. default to 1.

grad_step: f64

initial gradient step , default to 2.

nb_sampling_by_edge: usize

nb sampling by edge in gradient step. default = 10

nb_grad_batch: usize

number of gradient batch. default to 15

grad_factor: usize

the number of gradient batch in hierarchical case is nb_grad_batch multiplied by grad_factor. As the first iterations run on few points we can do more iterations. Default is 4.

hierarchy_layer: usize

if layer > 0 means we have hierarchical initialization

hubness_weighting: bool

To do negative sampling of nodes using hubness weights as node distribution, set it to true.
Default is false.
It improves slightly the quality estimated by quality estimator

Implementations

impl EmbedderParams

pub fn default() -> Self

pub fn log(&self)

pub fn set_dmap_init(&mut self, val: bool)

set to false if random initialization is preferred

pub fn set_nb_gradient_batch(&mut self, nb_batch: usize)

set the number of gradient batch. At each batch each edge is sampled nb_sampling_by_edge times. default to 20

pub fn set_dim(&mut self, dim: usize)

sets the dimension for data embedding. Default to 2

pub fn set_nb_edge_sampling(&mut self, nb_sample_by_edge: usize)

sets the number of time each edge should be sampled in a gradient batch. Default to 10

pub fn get_dimension(&self) -> usize

get asked embedding dimension

pub fn set_hierarchy_layer(&mut self, layer: usize)

pub fn get_hierarchy_layer(&self) -> usize

Trait Implementations

impl Clone for EmbedderParams

fn clone(&self) -> EmbedderParams

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Copy for EmbedderParams