Struct MinMaxQuantizer 

pub struct MinMaxQuantizer { /* private fields */ }

Recall that from the module-level documentation, MinMaxQuantizer, quantizes X into n bit vectors as follows -

X' = round((X - s) * (2^n - 1) / c).clamp(0, 2^n - 1))

where s is a shift value and c is a scaling parameter computed from the range of values.

For most bit widths (>1), given a positive scaling parameter grid_scale : f32, these are computed as:

- m = (max_i X[i] + min_i X[i]) / 2.0
- w = max_i X[i] - min_i X[i]

- s = m - w * grid_scale
- c = 2 * w * grid_scale

where `grid_scale` is an input to the quantizer.

For 1-bit quantization, to avoid outliers, s and c are derived differently:

• Values are first split into two groups: those below and above the mean.
• s is the average of values below the mean.
• c is the difference between the average of values above the mean and s.

See MinMaxCompensation for notation. We have then that

X = X' * (c / (2^n - 1)) + s
         --------------    -
                |          |
               ax          bx

Implementations

impl MinMaxQuantizer

pub fn new( transform: Transform<GlobalAllocator>, grid_scale: Positive<f32>, ) -> Self

Instantiates a new quantizer with specific transform.

pub fn dim(&self) -> usize

Input dimension of vectors to quantizer.

pub fn output_dim(&self) -> usize

Output dimension of vectors after applying transform.

Output storage vectors should use this dimension instead of self.dim() because in general, the output dim may be different from the input dimension.

Trait Implementations

impl AsFunctor<MinMaxCosine> for MinMaxQuantizer

fn as_functor(&self) -> MinMaxCosine

impl AsFunctor<MinMaxCosineNormalized> for MinMaxQuantizer

fn as_functor(&self) -> MinMaxCosineNormalized

impl AsFunctor<MinMaxIP> for MinMaxQuantizer

fn as_functor(&self) -> MinMaxIP

impl AsFunctor<MinMaxL2Squared> for MinMaxQuantizer

fn as_functor(&self) -> MinMaxL2Squared

impl<'a, T> CompressInto<&[T], Slice<&'a mut [f32], Mut<'a, FullQueryMeta>>> for MinMaxQuantizer

where T: Copy + Into<f32>,

fn compress_into( &self, from: &[T], to: FullQueryMut<'a>, ) -> Result<(), Self::Error>

Compress the input vector from into a FullQueryMut to.

This method simply applies the transformation to the input without any compression.

Error

Returns an error if the input contains NaN.

Panics

Panics if:

• from.len() != self.dim(): Vector to be compressed must have the same dimensionality as the quantizer.
• to.len() != self.output_dim(): Compressed vector must have the same dimensionality as the quantizer.

type Error = InputContainsNaN

Errors that may occur during compression.

type Output = ()

An output type resulting from compression.

impl<const NBITS: usize, T> CompressInto<&[T], VectorBase<NBITS, Unsigned, MutSlicePtr<'_, u8>, Mut<'_, MinMaxCompensation>>> for MinMaxQuantizer

where T: Copy + Into<f32>, Unsigned: Representation<NBITS>,

fn compress_into( &self, from: &[T], to: DataMutRef<'_, NBITS>, ) -> Result<L2Loss, Self::Error>

Compress the input vector from into a mut ref of Data to.

This method computes and stores the compensation coefficients required for computing distances correctly.

Error

Returns an error if the input contains NaN.

Panics

Panics if:

• from.len() != self.dim(): Vector to be compressed must have the same dimensionality as the quantizer.
• to.vector().len() != self.output_dim(): Compressed vector must have the same dimensionality as the quantizer.

type Error = InputContainsNaN

Errors that may occur during compression.

type Output = L2Loss

An output type resulting from compression.

impl<'a, 'b, const NBITS: usize, T> CompressInto<MatRef<'a, Standard<T>>, MatMut<'b, MinMaxMeta<NBITS>>> for MinMaxQuantizer

where T: Copy + Into<f32>, Unsigned: Representation<NBITS>,

fn compress_into( &self, from: MatRef<'a, Standard<T>>, to: MatMut<'b, MinMaxMeta<NBITS>>, ) -> Result<(), Self::Error>

Compress a multi-vector of full-precision vectors into a multi-vector of MinMax quantized vectors.

This method iterates row by row over the input matrix, quantizing each full-precision vector into the corresponding row of the output MinMax matrix.

Error

Returns InputContainsNaN error if any input vector contains NaN.

Panics

Panics if:

• from.num_vectors() != to.num_vectors(): The input and output must have the same number of vectors.
• from.vector_dim() != self.dim(): Each input vector must have the same dimensionality as the quantizer.
• The output intrinsic dimension doesn’t match self.output_dim().

type Error = InputContainsNaN

Errors that may occur during compression.

type Output = ()

An output type resulting from compression.