annembed 0.1.6

a Rust implementation of a dimension reduction à la Umap
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

//! dimension estimation

use anyhow::anyhow;

use crate::tools::nodeparam::*;
use num_traits::Float;

/// We implement the method described in :  
///     Maximum likelyhood estimation of intrinsic dimension.
///     Levina E. and Bickel P.J NIPS 2004.  [Levina-Bickel](https://www.stat.berkeley.edu/~bickel/mldim.pdf)
///
#[allow(clippy::let_and_return)]
pub(crate) fn intrinsic_dimension_from_edges<F>(edges: &[OutEdge<F>]) -> Result<f64, anyhow::Error>
where
    F: Float,
{
    let k_first: usize;
    let k_last: usize;
    if edges.len() >= 20 {
        // bickel use 10..20 as default
        k_first = 8;
        k_last = 19;
    } else if edges.len() > 3 {
        k_last = edges.len() - 1;
        k_first = 2;
    } else {
        log::error!("intrinsic_dimension_from_edges not enough edges");
        return Err(anyhow!("not enough neighbours"));
    }
    //
    let mut density: f64 = 0.;
    let d_estimate = |k| {
        let mut aux = 0.;
        for j in 1..k {
            if edges[j].weight.to_f64().unwrap() <= 0. || edges[k].weight.to_f64().unwrap() <= 0. {
                log::error!(
                    "null distances {:.3e}, {:.3e}",
                    edges[j].weight.to_f64().unwrap(),
                    edges[k].weight.to_f64().unwrap()
                );
            }
            aux += (edges[k].weight.to_f64().unwrap() / edges[j].weight.to_f64().unwrap()).ln();
        }
        if aux <= 0. {
            // we must take care of case with equal distances that give 0!!
            //            log::debug!("density_k : aux {:.3e} , k = {}", aux, k);
            -1.
        } else {
            let density_k = (k as f64 - 1.) / aux;
            //   log::debug!("density_k : {:.3e}", density_k);
            density_k
        }
    };
    let mut nb_pos: u32 = 0;
    for k in k_first..=k_last {
        let d = d_estimate(k);
        if d > 0. {
            density += d_estimate(k);
            nb_pos += 1;
        }
    }
    if nb_pos > 0 {
        density /= nb_pos as f64;
        //        log::debug!("intrinsic_dimension_from_edges k_first : {}, k_last : {}, density : {:.3e}", k_first, k_last, density);
        Ok(density)
    } else {
        Err(anyhow!("not positive distances"))
    }
} // end of intrinsic_dimension_from_edges