kannolo 0.3.5

kANNolo is designed for easy prototyping of ANN Search algorithms while ensuring high effectiveness and efficiency over both dense and sparse vectors.
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
70

use crate::topk_selectors::OnlineTopKSelector;
use crate::{Dataset, DistanceType, Float, Vector1D};
use crate::{DotProduct, EuclideanDistance};

pub trait IdentityQuantizer: Quantizer<InputItem = Self::T, OutputItem = Self::T> {
    type T: Float + EuclideanDistance<Self::T> + DotProduct<Self::T>;
}

impl<T, Q> IdentityQuantizer for Q
where
    Q: Quantizer<InputItem = T, OutputItem = T>,
    T: Float + EuclideanDistance<T> + DotProduct<T>,
{
    type T = T;
}

pub trait Quantizer: Sized {
    type InputItem;
    type OutputItem;
    type DatasetType: Dataset<Self>;

    type Evaluator<'a>: QueryEvaluator<'a, Q = Self>
    where
        Self::InputItem:
            Float + EuclideanDistance<Self::InputItem> + DotProduct<Self::InputItem> + 'a;

    fn encode(&self, input_vectors: &[Self::InputItem], output_vectors: &mut [Self::OutputItem]);

    fn m(&self) -> usize;

    fn distance(&self) -> DistanceType;

    fn get_space_usage_bytes(&self) -> usize;
}

pub trait QueryEvaluator<'a> {
    type Q: Quantizer;
    type QueryType: Vector1D;

    fn new(query: Self::QueryType, dataset: &<Self::Q as Quantizer>::DatasetType) -> Self;

    fn compute_distance(&self, dataset: &<Self::Q as Quantizer>::DatasetType, index: usize) -> f32;

    #[inline]
    fn compute_distances(
        &self,
        dataset: &<Self::Q as Quantizer>::DatasetType,
        indexes: impl IntoIterator<Item = usize>,
    ) -> impl Iterator<Item = f32> {
        indexes
            .into_iter()
            .map(|index| self.compute_distance(dataset, index))
    }

    #[inline]
    fn compute_four_distances(
        &self,
        dataset: &<Self::Q as Quantizer>::DatasetType,
        indexes: impl IntoIterator<Item = usize>,
    ) -> impl Iterator<Item = f32> {
        indexes
            .into_iter()
            .map(|index| self.compute_distance(dataset, index))
    }

    fn topk_retrieval<I, H>(&self, distances: I, heap: &mut H) -> Vec<(f32, usize)>
    where
        I: Iterator<Item = f32>,
        H: OnlineTopKSelector;
}