1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
|
/*
* Copyright (c) Meta Platforms, Inc. and affiliates.
*
* This source code is licensed under the MIT license found in the
* LICENSE file in the root directory of this source tree.
*/
// -*- c -*-
#ifndef FAISS_VECTOR_TRANSFORM_C_H
#define FAISS_VECTOR_TRANSFORM_C_H
/** Defines a few objects that apply transformations to a set of
* vectors Often these are pre-processing steps.
*/
#include "faiss_c.h"
#ifdef __cplusplus
extern "C" {
#endif
/// Opaque type for referencing to a VectorTransform object
FAISS_DECLARE_CLASS(VectorTransform)
FAISS_DECLARE_DESTRUCTOR(VectorTransform)
/// Getter for is_trained
FAISS_DECLARE_GETTER(VectorTransform, int, is_trained)
/// Getter for input dimension
FAISS_DECLARE_GETTER(VectorTransform, int, d_in)
/// Getter for output dimension
FAISS_DECLARE_GETTER(VectorTransform, int, d_out)
/** Perform training on a representative set of vectors
*
* @param vt opaque pointer to VectorTransform object
* @param n nb of training vectors
* @param x training vectors, size n * d
*/
int faiss_VectorTransform_train(
FaissVectorTransform* vt,
idx_t n,
const float* x);
/** apply the random rotation, return new allocated matrix
* @param x size n * d_in
* @return size n * d_out
*/
float* faiss_VectorTransform_apply(
const FaissVectorTransform* vt,
idx_t n,
const float* x);
/** apply transformation and result is pre-allocated
* @param x size n * d_in
* @param xt size n * d_out
*/
void faiss_VectorTransform_apply_noalloc(
const FaissVectorTransform* vt,
idx_t n,
const float* x,
float* xt);
/// reverse transformation. May not be implemented or may return
/// approximate result
void faiss_VectorTransform_reverse_transform(
const FaissVectorTransform* vt,
idx_t n,
const float* xt,
float* x);
/// Opaque type for referencing to a LinearTransform object
FAISS_DECLARE_CLASS_INHERITED(LinearTransform, VectorTransform)
FAISS_DECLARE_DESTRUCTOR(LinearTransform)
/// compute x = A^T * (x - b)
/// is reverse transform if A has orthonormal lines
void faiss_LinearTransform_transform_transpose(
const FaissLinearTransform* vt,
idx_t n,
const float* y,
float* x);
/// compute A^T * A to set the is_orthonormal flag
void faiss_LinearTransform_set_is_orthonormal(FaissLinearTransform* vt);
/// Getter for have_bias
FAISS_DECLARE_GETTER(LinearTransform, int, have_bias)
/// Getter for is_orthonormal
FAISS_DECLARE_GETTER(LinearTransform, int, is_orthonormal)
FAISS_DECLARE_CLASS_INHERITED(RandomRotationMatrix, VectorTransform)
FAISS_DECLARE_DESTRUCTOR(RandomRotationMatrix)
int faiss_RandomRotationMatrix_new_with(
FaissRandomRotationMatrix** p_vt,
int d_in,
int d_out);
FAISS_DECLARE_CLASS_INHERITED(PCAMatrix, VectorTransform)
FAISS_DECLARE_DESTRUCTOR(PCAMatrix)
int faiss_PCAMatrix_new_with(
FaissPCAMatrix** p_vt,
int d_in,
int d_out,
float eigen_power,
int random_rotation);
/// Getter for eigen_power
FAISS_DECLARE_GETTER(PCAMatrix, float, eigen_power)
/// Getter for random_rotation
FAISS_DECLARE_GETTER(PCAMatrix, int, random_rotation)
FAISS_DECLARE_CLASS_INHERITED(ITQMatrix, VectorTransform)
FAISS_DECLARE_DESTRUCTOR(ITQMatrix)
int faiss_ITQMatrix_new_with(FaissITQMatrix** p_vt, int d);
FAISS_DECLARE_CLASS_INHERITED(ITQTransform, VectorTransform)
FAISS_DECLARE_DESTRUCTOR(ITQTransform)
int faiss_ITQTransform_new_with(
FaissITQTransform** p_vt,
int d_in,
int d_out,
int do_pca);
/// Getter for do_pca
FAISS_DECLARE_GETTER(ITQTransform, int, do_pca)
FAISS_DECLARE_CLASS_INHERITED(OPQMatrix, VectorTransform)
FAISS_DECLARE_DESTRUCTOR(OPQMatrix)
int faiss_OPQMatrix_new_with(FaissOPQMatrix** p_vt, int d, int M, int d2);
FAISS_DECLARE_GETTER_SETTER(OPQMatrix, int, verbose)
FAISS_DECLARE_GETTER_SETTER(OPQMatrix, int, niter)
FAISS_DECLARE_GETTER_SETTER(OPQMatrix, int, niter_pq)
FAISS_DECLARE_CLASS_INHERITED(RemapDimensionsTransform, VectorTransform)
FAISS_DECLARE_DESTRUCTOR(RemapDimensionsTransform)
int faiss_RemapDimensionsTransform_new_with(
FaissRemapDimensionsTransform** p_vt,
int d_in,
int d_out,
int uniform);
FAISS_DECLARE_CLASS_INHERITED(NormalizationTransform, VectorTransform)
FAISS_DECLARE_DESTRUCTOR(NormalizationTransform)
int faiss_NormalizationTransform_new_with(
FaissNormalizationTransform** p_vt,
int d,
float norm);
FAISS_DECLARE_GETTER(NormalizationTransform, float, norm)
FAISS_DECLARE_CLASS_INHERITED(CenteringTransform, VectorTransform)
FAISS_DECLARE_DESTRUCTOR(CenteringTransform)
int faiss_CenteringTransform_new_with(FaissCenteringTransform** p_vt, int d);
#ifdef __cplusplus
}
#endif
#endif
|
