Struct ProductQuantizer 

pub struct ProductQuantizer {
    pub config: PQConfig,
    pub codebooks: Vec<Vec<Vec<f32>>>,
    pub dimension: usize,
    pub subvector_dim: usize,
}

A trained Product Quantizer

Fields

config: PQConfig

Configuration

codebooks: Vec<Vec<Vec<f32>>>

Codebooks: [num_subquantizers][num_centroids][subvector_dim]

dimension: usize

Dimension of full vector

subvector_dim: usize

Dimension of each subvector

Implementations

impl ProductQuantizer

pub fn new(config: PQConfig, dimension: usize) -> Result<Self, String>

Create a new untrained quantizer

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

Train the quantizer on a set of vectors

pub fn is_trained(&self) -> bool

Check if the quantizer is trained

pub fn encode(&self, vector: &[f32]) -> Result<Vec<u8>, String>

Encode a vector into PQ codes

pub fn decode(&self, codes: &[u8]) -> Result<Vec<f32>, String>

Decode PQ codes back to approximate vector

pub fn compute_distance_table( &self, query: &[f32], ) -> Result<Vec<Vec<f32>>, String>

Compute distance lookup table for a query vector Returns [num_subquantizers][num_centroids] distances

pub fn compute_distance_adc(&self, table: &[Vec<f32>], codes: &[u8]) -> f32

Compute distance using precomputed table (ADC - Asymmetric Distance Computation)

Trait Implementations

impl Clone for ProductQuantizer

fn clone(&self) -> ProductQuantizer

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for ProductQuantizer

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for ProductQuantizer

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Persistable for ProductQuantizer

type Snapshot = PQSnapshot

The snapshot type for this index

fn to_snapshot(&self) -> PQSnapshot

Create a snapshot of the current state

fn from_snapshot(snapshot: PQSnapshot) -> Result<Self, String>

Restore from a snapshot

fn to_bytes(&self) -> Result<Vec<u8>, String>

Serialize to bytes (JSON format)

fn from_bytes(data: &[u8]) -> Result<Self, String>

Deserialize from bytes (JSON format)

impl Serialize for ProductQuantizer

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.