Struct faiss::LinearTransformΒΆ

struct LinearTransform : public faiss::VectorTransform

Generic linear transformation, with bias term applied on output y = A * x + b

Subclassed by faiss::ITQMatrix, faiss::OPQMatrix, faiss::PCAMatrix, faiss::RandomRotationMatrix

Public Types

typedef Index::idx_t idx_t

Public Functions

explicit LinearTransform(int d_in = 0, int d_out = 0, bool have_bias = false)

both d_in > d_out and d_out < d_in are supported

virtual void apply_noalloc(idx_t n, const float *x, float *xt) const override

same as apply, but result is pre-allocated

void transform_transpose(idx_t n, const float *y, float *x) const

compute x = A^T * (x - b) is reverse transform if A has orthonormal lines

virtual void reverse_transform(idx_t n, const float *xt, float *x) const override

works only if is_orthonormal

void set_is_orthonormal()

compute A^T * A to set the is_orthonormal flag

void print_if_verbose(const char *name, const std::vector<double> &mat, int n, int d) const
inline ~LinearTransform() override
virtual void train(idx_t n, const float *x)

Perform training on a representative set of vectors. Does nothing by default.

  • n – nb of training vectors

  • x – training vecors, size n * d

float *apply(idx_t n, const float *x) const

apply the random rotation, return new allocated matrix


x – size n * d_in


size n * d_out

Public Members

bool have_bias
bool is_orthonormal

! whether to use the bias term

check if matrix A is orthonormal (enables reverse_transform)

std::vector<float> A

Transformation matrix, size d_out * d_in.

std::vector<float> b

bias vector, size d_out

bool verbose
int d_in
int d_out

! input dimension

bool is_trained

set if the VectorTransform does not require training, or if training is done already