Struct ProductQuantizer 

pub struct ProductQuantizer { /* private fields */ }

Product Quantizer for vector compression.

The quantizer stores codebooks (centroids) for each subspace and provides methods for encoding vectors and computing approximate distances.

Implementations

impl ProductQuantizer

pub fn train( config: &PQConfig, training_data: &[&[f32]], ) -> Result<Self, VectorError>

Train a Product Quantizer on training data.

Arguments

• config: PQ configuration
• training_data: Training vectors (must all have dimension == config.dimension)

Errors

Returns an error if:

• Configuration is invalid
• Training data is empty
• Training vectors have wrong dimension

pub fn from_codebooks( config: &PQConfig, codebooks: Vec<Vec<Vec<f32>>>, ) -> Result<Self, VectorError>

Create a Product Quantizer from pre-trained codebooks.

Arguments

• config: PQ configuration
• codebooks: Pre-trained codebooks, shape [num_segments][num_centroids][subspace_dim]

Errors

Returns an error if codebooks don’t match the configuration.

pub fn config(&self) -> &PQConfig

Get the configuration.

pub fn codebooks(&self) -> &[Vec<Vec<f32>>]

Get the codebooks.

pub fn encode(&self, vector: &[f32]) -> PQCode

Encode a vector into a PQ code.

Arguments

• vector: Input vector with dimension == config.dimension

Panics

Panics if the vector has wrong dimension.

pub fn decode(&self, code: &PQCode) -> Vec<f32>

Decode a PQ code back to an approximate vector.

The reconstructed vector is the concatenation of the centroids indicated by the code.

pub fn compute_distance_table(&self, query: &[f32]) -> DistanceTable

Compute a distance lookup table for asymmetric distance computation (ADC).

The table contains precomputed distances from each subvector of the query to all centroids in the corresponding codebook.

Shape: table[segment][centroid_idx] = distance

Arguments

• query: Query vector with dimension == config.dimension

pub fn asymmetric_distance(&self, table: &DistanceTable, code: &PQCode) -> f32

Compute asymmetric distance from a precomputed distance table to a PQ code.

This is the primary method for fast approximate nearest neighbor search. The query vector is exact, while the database vector is compressed.

Arguments

• table: Distance table from compute_distance_table
• code: PQ code of a database vector

pub fn asymmetric_distance_squared( &self, table: &DistanceTable, code: &PQCode, ) -> f32

Compute asymmetric squared distance (faster, no sqrt).

For Euclidean distance, returns the squared distance. For other metrics, returns the same as asymmetric_distance.

pub fn symmetric_distance(&self, code_a: &PQCode, code_b: &PQCode) -> f32

Compute symmetric distance between two PQ codes.

This is faster but less accurate than asymmetric distance. Both vectors are compressed.

pub fn to_bytes(&self) -> Vec<u8>

Serialize the quantizer to bytes.

pub fn from_bytes(bytes: &[u8]) -> Result<Self, VectorError>

Deserialize a quantizer from bytes.

Errors

Returns an error if the bytes are malformed.

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.