Struct BinaryQuantizer 

pub struct BinaryQuantizer { /* private fields */ }

Binary quantizer (BQ): one bit per dimension, 32× compression.

Build one with BinaryQuantizer::new (or Default), train it once with a representative sample, then quantize and compare. BQ supports DistanceMetric::Hamming only; other metrics return IqdbError::InvalidMetric.

Examples

use iqdb_quantize::{BinaryQuantizer, Quantizer};
use iqdb_types::DistanceMetric;

let mut bq = BinaryQuantizer::new();
bq.train(&[&[0.0_f32, 1.0, 2.0][..], &[2.0_f32, 1.0, 0.0][..]])
    .expect("two non-empty, finite vectors of equal dim");

let code = bq.quantize(&[0.5_f32, 1.5, 2.5]).expect("dim matches");
let d = bq
    .distance(&[0.5_f32, 1.5, 2.5], &code, DistanceMetric::Hamming)
    .expect("dim matches");
// Self-distance is zero.
assert_eq!(d, 0.0);

Implementations

impl BinaryQuantizer

pub fn new() -> Self

Build an untrained binary quantizer.

Every hot method returns IqdbError::InvalidConfig until Quantizer::train succeeds.

Examples

use iqdb_quantize::BinaryQuantizer;
let _bq = BinaryQuantizer::new();

pub fn dim(&self) -> Option<usize>

The trained dimension, if any.

Examples

use iqdb_quantize::{BinaryQuantizer, Quantizer};

let mut bq = BinaryQuantizer::new();
assert_eq!(bq.dim(), None);
bq.train(&[&[0.0_f32, 1.0][..]]).expect("ok");
assert_eq!(bq.dim(), Some(2));

Trait Implementations

impl Clone for BinaryQuantizer

fn clone(&self) -> BinaryQuantizer

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for BinaryQuantizer

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

Formats the value using the given formatter.

impl Default for BinaryQuantizer

fn default() -> BinaryQuantizer

Returns the “default value” for a type.

impl PartialEq for BinaryQuantizer

fn eq(&self, other: &BinaryQuantizer) -> bool

Tests for self and other values to be equal, and is used by ==.

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

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

impl Quantizer for BinaryQuantizer

type Quantized = BqCode

The compact code produced by Quantizer::quantize.

fn train(&mut self, vectors: &[&[f32]]) -> Result<()>

Train the quantizer from a sample of representative vectors.

fn quantize(&self, vector: &[f32]) -> Result<Self::Quantized>

Encode vector as a compact code.

fn dequantize(&self, quantized: &Self::Quantized) -> Result<Vec<f32>>

Decode quantized back to an f32 vector.

fn distance( &self, query: &[f32], quantized: &Self::Quantized, metric: DistanceMetric, ) -> Result<f32>

Compute the asymmetric distance between a raw f32 query and a stored code under metric.

impl StructuralPartialEq for BinaryQuantizer