Select Page

### 1. Faiss

Faiss is a library for efficient similarity search and clustering of dense vectors. It contains algorithms that search in sets of vectors of any size, up to ones that possibly do not fit in RAM. It also contains supporting code for evaluation and parameter tuning. Faiss is written in C++ with complete wrappers for Python/numpy. Some of the most useful algorithms are implemented on the GPU. It is developed by Facebook AI Research.

In this article, we will show how to use Faiss, on a GPU, for the KNN (K nearest neighbor) algorithm for a classification problem. While this is a small problem and the speedup factor versus Scikit-learn‘s CPU version is small, we want to show how to properly use Faiss and avoid some subtle errors.

Below are links to the Faiss documentation:

### 2. MNIST KNN

We modified the MNIST handwritten digits data set by passing the 2d data thru a CNN autoencoder to transform the 2d data into 1d vectors of length 20. This was not done for this specific project, as we could have used the flat 784 length vectors of the original data. The length 20 vectors were created for other projects, so we decided to use them here.

Calculations were performed on an AWS EC2 g3.4xlarge instance: 16 CPUs, NVIDIA Tesla M60 GPU,

The Faiss GPU implementation of the KNN algorithm:

```import numpy as np
import faiss
from sklearn.metrics import classification_report

gpu_resource = faiss.StandardGpuResources()  # use a single GPU
cpu_index = faiss.IndexFlatL2(num_dimensions)  # create a CPU index
gpu_index = faiss.index_cpu_to_gpu(gpu_resource, 0, cpu_index)  # transfer the index to GPU
_, array_knn_indices_gpu = gpu_index.search(x_prod, num_neighbors)  # _ = distances

# check dimensions
assert(array_knn_indices_gpu.shape[0] == num_prod_points)
assert(array_knn_indices_gpu.shape[1] == num_neighbors)

# get predicted y values for production data using majority voting
y_production_predicted_faiss_gpu = np.full(num_prod_points, -1)
for i in range(num_prod_points):
array_calib_classes = np.take(y_calib, array_knn_indices_gpu[i], axis=0)
array_unique, array_counts = np.unique(array_calib_classes, return_counts=True)
y_production_predicted_faiss_gpu[i] = array_unique[np.argmax(array_counts)]

# evaluate predictions
print('\n\n *** classification_report *** \n')
print(classification_report(y_prod, y_production_predicted_faiss_gpu,
labels=class_names_list, digits=3))

```

elapsed time = 0.003002 minutes
accuracy = 0.978

The Scikit-learn CPU version (nearest neighbors, ball tree):

```import numpy as np
from sklearn.metrics import classification_report
from sklearn.neighbors import NearestNeighbors

nn = NearestNeighbors(n_neighbors=neighbors, algorithm='ball_tree',
metric='minkowski', p=2, n_jobs=-1).fit(xcalib)
array_nn_indices_balltree = nn.kneighbors(X=xprod, return_distance=False)

# check dimensions
assert(array_nn_indices_balltree.shape[0] == num_prod_pts)
assert(array_nn_indices_balltree.shape[1] == neighbors)

# get predicted y values for production data using majority voting
y_prod_predicted_balltree = np.full(num_prod_pts, -1)
for i in range(num_prod_pts):
array_calib_classes = np.take(ycalib, array_nn_indices_balltree[i], axis=0)
array_unique, array_counts = np.unique(array_calib_classes, return_counts=True)
y_prod_predicted_balltree[i] = array_unique[np.argmax(array_counts)]

# evaluate predictions
print('\n\n *** sklearn ball tree classification_report *** \n')
print(classification_report(yprod, y_prod_predicted_balltree,
labels=list_class_names, digits=3))
```

elapsed time = 0.158966 minutes
accuracy = 0.978

While we do not show it here, the confusion matrices are identical.

### 3. Faiss Gotchas

1. When using Numpy arrays as input, they must be set to dtype = ‘float32’. If you are reading a saved Numpy array from a file:

```npy_array = np.load(directory + 'npy_array.npy', allow_pickle=True).astype('float32')
```

2. Faiss assumes that Numpy arrays are contiguous. Use:

```if not npy_array.flags['C_CONTIGUOUS']:
ny_array = np.ascontiguousarray(npy_array)
```