faiss 0.5.3 → 0.6.1

data/vendor/faiss/faiss/utils/approx_topk/avx2-inl.h

@@ -1,196 +0,0 @@
-/*
- * 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.
- */
-
-#pragma once
-
-#include <immintrin.h>
-
-#include <limits>
-
-#include <faiss/impl/FaissAssert.h>
-#include <faiss/utils/Heap.h>
-
-namespace faiss {
-
-template <typename C, uint32_t NBUCKETS, uint32_t N>
-struct HeapWithBuckets {
-    // this case was not implemented yet.
-};
-
-template <uint32_t NBUCKETS, uint32_t N>
-struct HeapWithBuckets<CMax<float, int>, NBUCKETS, N> {
-    static constexpr uint32_t NBUCKETS_8 = NBUCKETS / 8;
-    static_assert(
-            (NBUCKETS) > 0 && ((NBUCKETS % 8) == 0),
-            "Number of buckets needs to be 8, 16, 24, ...");
-
-    static void addn(
-            // number of elements
-            const uint32_t n,
-            // distances. It is assumed to have n elements.
-            const float* const __restrict distances,
-            // number of best elements to keep
-            const uint32_t k,
-            // output distances
-            float* const __restrict bh_val,
-            // output indices, each being within [0, n) range
-            int32_t* const __restrict bh_ids) {
-        // forward a call to bs_addn with 1 beam
-        bs_addn(1, n, distances, k, bh_val, bh_ids);
-    }
-
-    static void bs_addn(
-            // beam_size parameter of Beam Search algorithm
-            const uint32_t beam_size,
-            // number of elements per beam
-            const uint32_t n_per_beam,
-            // distances. It is assumed to have (n_per_beam * beam_size)
-            // elements.
-            const float* const __restrict distances,
-            // number of best elements to keep
-            const uint32_t k,
-            // output distances
-            float* const __restrict bh_val,
-            // output indices, each being within [0, n_per_beam * beam_size)
-            // range
-            int32_t* const __restrict bh_ids) {
-        // // Basically, the function runs beam_size iterations.
-        // // Every iteration NBUCKETS * N elements are added to a regular heap.
-        // // So, maximum number of added elements is beam_size * NBUCKETS * N.
-        // // This number is expected to be less or equal than k.
-        // FAISS_THROW_IF_NOT_FMT(
-        //         beam_size * NBUCKETS * N >= k,
-        //         "Cannot pick %d elements, only %d. "
-        //         "Check the function and template arguments values.",
-        //         k,
-        //         beam_size * NBUCKETS * N);
-
-        using C = CMax<float, int>;
-
-        // main loop
-        for (uint32_t beam_index = 0; beam_index < beam_size; beam_index++) {
-            __m256 min_distances_i[NBUCKETS_8][N];
-            __m256i min_indices_i[NBUCKETS_8][N];
-
-            for (uint32_t j = 0; j < NBUCKETS_8; j++) {
-                for (uint32_t p = 0; p < N; p++) {
-                    min_distances_i[j][p] =
-                            _mm256_set1_ps(std::numeric_limits<float>::max());
-                    min_indices_i[j][p] =
-                            _mm256_setr_epi32(0, 1, 2, 3, 4, 5, 6, 7);
-                }
-            }
-
-            __m256i current_indices = _mm256_setr_epi32(0, 1, 2, 3, 4, 5, 6, 7);
-            __m256i indices_delta = _mm256_set1_epi32(NBUCKETS);
-
-            const uint32_t nb = (n_per_beam / NBUCKETS) * NBUCKETS;
-
-            // put the data into buckets
-            for (uint32_t ip = 0; ip < nb; ip += NBUCKETS) {
-                for (uint32_t j = 0; j < NBUCKETS_8; j++) {
-                    const __m256 distances_reg = _mm256_loadu_ps(
-                            distances + j * 8 + ip + n_per_beam * beam_index);
-
-                    // loop. Compiler should get rid of unneeded ops
-                    __m256 distance_candidate = distances_reg;
-                    __m256i indices_candidate = current_indices;
-
-                    for (uint32_t p = 0; p < N; p++) {
-                        const __m256 comparison = _mm256_cmp_ps(
-                                min_distances_i[j][p],
-                                distance_candidate,
-                                _CMP_LE_OS);
-
-                        // // blend seems to be slower than min
-                        // const __m256 min_distances_new = _mm256_blendv_ps(
-                        //         distance_candidate,
-                        //         min_distances_i[j][p],
-                        //         comparison);
-                        const __m256 min_distances_new = _mm256_min_ps(
-                                distance_candidate, min_distances_i[j][p]);
-                        const __m256i min_indices_new =
-                                _mm256_castps_si256(_mm256_blendv_ps(
-                                        _mm256_castsi256_ps(indices_candidate),
-                                        _mm256_castsi256_ps(
-                                                min_indices_i[j][p]),
-                                        comparison));
-
-                        // // blend seems to be slower than min
-                        // const __m256 max_distances_new = _mm256_blendv_ps(
-                        //         min_distances_i[j][p],
-                        //         distance_candidate,
-                        //         comparison);
-                        const __m256 max_distances_new = _mm256_max_ps(
-                                min_distances_i[j][p], distances_reg);
-                        const __m256i max_indices_new =
-                                _mm256_castps_si256(_mm256_blendv_ps(
-                                        _mm256_castsi256_ps(
-                                                min_indices_i[j][p]),
-                                        _mm256_castsi256_ps(indices_candidate),
-                                        comparison));
-
-                        distance_candidate = max_distances_new;
-                        indices_candidate = max_indices_new;
-
-                        min_distances_i[j][p] = min_distances_new;
-                        min_indices_i[j][p] = min_indices_new;
-                    }
-                }
-
-                current_indices =
-                        _mm256_add_epi32(current_indices, indices_delta);
-            }
-
-            // fix the indices
-            for (uint32_t j = 0; j < NBUCKETS_8; j++) {
-                const __m256i offset =
-                        _mm256_set1_epi32(n_per_beam * beam_index + j * 8);
-                for (uint32_t p = 0; p < N; p++) {
-                    min_indices_i[j][p] =
-                            _mm256_add_epi32(min_indices_i[j][p], offset);
-                }
-            }
-
-            // merge every bucket into the regular heap
-            for (uint32_t p = 0; p < N; p++) {
-                for (uint32_t j = 0; j < NBUCKETS_8; j++) {
-                    int32_t min_indices_scalar[8];
-                    float min_distances_scalar[8];
-
-                    _mm256_storeu_si256(
-                            (__m256i*)min_indices_scalar, min_indices_i[j][p]);
-                    _mm256_storeu_ps(
-                            min_distances_scalar, min_distances_i[j][p]);
-
-                    // this exact way is needed to maintain the order as if the
-                    // input elements were pushed to the heap sequentially
-                    for (size_t j8 = 0; j8 < 8; j8++) {
-                        const auto value = min_distances_scalar[j8];
-                        const auto index = min_indices_scalar[j8];
-                        if (C::cmp2(bh_val[0], value, bh_ids[0], index)) {
-                            heap_replace_top<C>(
-                                    k, bh_val, bh_ids, value, index);
-                        }
-                    }
-                }
-            }
-
-            // process leftovers
-            for (uint32_t ip = nb; ip < n_per_beam; ip++) {
-                const int32_t index = ip + n_per_beam * beam_index;
-                const float value = distances[index];
-
-                if (C::cmp(bh_val[0], value)) {
-                    heap_replace_top<C>(k, bh_val, bh_ids, value, index);
-                }
-            }
-        }
-    }
-};
-
-} // namespace faiss

data/vendor/faiss/faiss/utils/approx_topk/mode.h

@@ -1,34 +0,0 @@
-/*
- * 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.
- */
-
-#pragma once
-
-/// Represents the mode of use of approximate top-k computations
-/// that allows to trade accuracy vs speed. So, every options
-/// besides EXACT_TOPK increases the speed.
-///
-/// B represents the number of buckets.
-/// D is the number of min-k elements to track within every bucket.
-///
-/// Default option is EXACT_TOPK.
-/// APPROX_TOPK_BUCKETS_B16_D2 is worth starting from, if you'd like
-/// to experiment a bit.
-///
-/// It seems that only the limited number of combinations are
-/// meaningful, because of the limited supply of SIMD registers.
-/// Also, certain combinations, such as B32_D1 and B16_D1, were concluded
-/// to be not very precise in benchmarks, so they were not introduced.
-///
-/// TODO: Consider d-ary SIMD heap.
-
-enum ApproxTopK_mode_t : int {
-    EXACT_TOPK = 0,
-    APPROX_TOPK_BUCKETS_B32_D2 = 1,
-    APPROX_TOPK_BUCKETS_B8_D3 = 2,
-    APPROX_TOPK_BUCKETS_B16_D2 = 3,
-    APPROX_TOPK_BUCKETS_B8_D2 = 4,
-};

data/vendor/faiss/faiss/utils/distances_fused/avx512.h

@@ -1,36 +0,0 @@
-/*
- * 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.
- */
-
-// AVX512 might be not used, but this version provides ~2x speedup
-// over AVX2 kernel, say, for training PQx10 or PQx12, and speeds up
-// additional cases with larger dimensionalities.
-
-#pragma once
-
-#include <faiss/impl/ResultHandler.h>
-#include <faiss/impl/platform_macros.h>
-
-#include <faiss/utils/Heap.h>
-
-#ifdef __AVX512F__
-
-namespace faiss {
-
-// Returns true if the fused kernel is available and the data was processed.
-// Returns false if the fused kernel is not available.
-bool exhaustive_L2sqr_fused_cmax_AVX512(
-        const float* x,
-        const float* y,
-        size_t d,
-        size_t nx,
-        size_t ny,
-        Top1BlockResultHandler<CMax<float, int64_t>>& res,
-        const float* y_norms);
-
-} // namespace faiss
-
-#endif

data/vendor/faiss/faiss/utils/extra_distances-inl.h

@@ -1,228 +0,0 @@
-/*
- * 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.
- */
-
-#pragma once
-
-/** In this file are the implementations of extra metrics beyond L2
- *  and inner product */
-
-#include <faiss/MetricType.h>
-#include <faiss/impl/FaissAssert.h>
-#include <faiss/utils/distances.h>
-#include <cmath>
-#include <type_traits>
-
-namespace faiss {
-
-template <MetricType mt>
-struct VectorDistance {
-    size_t d;
-    float metric_arg;
-    static constexpr bool is_similarity = is_similarity_metric(mt);
-
-    inline float operator()(const float* x, const float* y) const;
-
-    // heap template to use for this type of metric
-    using C = typename std::conditional<
-            is_similarity_metric(mt),
-            CMin<float, int64_t>,
-            CMax<float, int64_t>>::type;
-};
-
-template <>
-inline float VectorDistance<METRIC_L2>::operator()(
-        const float* x,
-        const float* y) const {
-    return fvec_L2sqr(x, y, d);
-}
-
-template <>
-inline float VectorDistance<METRIC_INNER_PRODUCT>::operator()(
-        const float* x,
-        const float* y) const {
-    return fvec_inner_product(x, y, d);
-}
-
-template <>
-inline float VectorDistance<METRIC_L1>::operator()(
-        const float* x,
-        const float* y) const {
-    return fvec_L1(x, y, d);
-}
-
-template <>
-inline float VectorDistance<METRIC_Linf>::operator()(
-        const float* x,
-        const float* y) const {
-    return fvec_Linf(x, y, d);
-    /*
-        float vmax = 0;
-        for (size_t i = 0; i < d; i++) {
-            float diff = fabs (x[i] - y[i]);
-            if (diff > vmax) vmax = diff;
-        }
-     return vmax;*/
-}
-
-template <>
-inline float VectorDistance<METRIC_Lp>::operator()(
-        const float* x,
-        const float* y) const {
-    float accu = 0;
-    for (size_t i = 0; i < d; i++) {
-        float diff = fabs(x[i] - y[i]);
-        accu += powf(diff, metric_arg);
-    }
-    return accu;
-}
-
-template <>
-inline float VectorDistance<METRIC_Canberra>::operator()(
-        const float* x,
-        const float* y) const {
-    float accu = 0;
-    for (size_t i = 0; i < d; i++) {
-        float xi = x[i], yi = y[i];
-        accu += fabs(xi - yi) / (fabs(xi) + fabs(yi));
-    }
-    return accu;
-}
-
-template <>
-inline float VectorDistance<METRIC_BrayCurtis>::operator()(
-        const float* x,
-        const float* y) const {
-    float accu_num = 0, accu_den = 0;
-    for (size_t i = 0; i < d; i++) {
-        float xi = x[i], yi = y[i];
-        accu_num += fabs(xi - yi);
-        accu_den += fabs(xi + yi);
-    }
-    return accu_num / accu_den;
-}
-
-template <>
-inline float VectorDistance<METRIC_JensenShannon>::operator()(
-        const float* x,
-        const float* y) const {
-    float accu = 0;
-    for (size_t i = 0; i < d; i++) {
-        float xi = x[i], yi = y[i];
-        float mi = 0.5 * (xi + yi);
-        float kl1 = -xi * log(mi / xi);
-        float kl2 = -yi * log(mi / yi);
-        accu += kl1 + kl2;
-    }
-    return 0.5 * accu;
-}
-
-template <>
-inline float VectorDistance<METRIC_Jaccard>::operator()(
-        const float* x,
-        const float* y) const {
-    // WARNING: this distance is defined only for positive input vectors.
-    // Providing vectors with negative values would lead to incorrect results.
-    float accu_num = 0, accu_den = 0;
-    for (size_t i = 0; i < d; i++) {
-        accu_num += fmin(x[i], y[i]);
-        accu_den += fmax(x[i], y[i]);
-    }
-    return accu_num / accu_den;
-}
-
-template <>
-inline float VectorDistance<METRIC_NaNEuclidean>::operator()(
-        const float* x,
-        const float* y) const {
-    // https://scikit-learn.org/stable/modules/generated/sklearn.metrics.pairwise.nan_euclidean_distances.html
-    float accu = 0;
-    size_t present = 0;
-    for (size_t i = 0; i < d; i++) {
-        if (!std::isnan(x[i]) && !std::isnan(y[i])) {
-            float diff = x[i] - y[i];
-            accu += diff * diff;
-            present++;
-        }
-    }
-    if (present == 0) {
-        return NAN;
-    }
-    return float(d) / float(present) * accu;
-}
-
-template <>
-inline float VectorDistance<METRIC_GOWER>::operator()(
-        const float* x,
-        const float* y) const {
-    float accu = 0;
-    size_t valid_dims = 0;
-
-    for (size_t i = 0; i < d; i++) {
-        if (std::isnan(x[i]) || std::isnan(y[i])) {
-            continue;
-        }
-
-        if (x[i] >= 0 && y[i] >= 0) {
-            if (x[i] > 1 || y[i] > 1) {
-                return std::numeric_limits<float>::quiet_NaN();
-            }
-            // Numeric dimensions are in [0,1]
-            accu += fabs(x[i] - y[i]);
-        } else if (x[i] < 0 && y[i] < 0) {
-            // Categorical dimensions are negative values
-            accu += float(int(x[i] != y[i]));
-        } else {
-            // Invalid representation
-            return std::numeric_limits<float>::quiet_NaN();
-        }
-        valid_dims++;
-    }
-
-    if (valid_dims == 0) {
-        return std::numeric_limits<float>::quiet_NaN();
-    }
-    return accu / valid_dims;
-}
-
-/***************************************************************************
- * Dispatching function that takes a metric type and a consumer object
- * the consumer object should contain a return type T and a operation template
- * function f() that is called to perform the operation. The first argument
- * of the function is the VectorDistance object. The rest are passed in as is.
- **************************************************************************/
-
-template <class Consumer, class... Types>
-typename Consumer::T dispatch_VectorDistance(
-        size_t d,
-        MetricType metric,
-        float metric_arg,
-        Consumer& consumer,
-        Types... args) {
-    switch (metric) {
-#define DISPATCH_VD(mt)                                              \
-    case mt: {                                                       \
-        VectorDistance<mt> vd = {d, metric_arg};                     \
-        return consumer.template f<VectorDistance<mt>>(vd, args...); \
-    }
-        DISPATCH_VD(METRIC_INNER_PRODUCT);
-        DISPATCH_VD(METRIC_L2);
-        DISPATCH_VD(METRIC_L1);
-        DISPATCH_VD(METRIC_Linf);
-        DISPATCH_VD(METRIC_Lp);
-        DISPATCH_VD(METRIC_Canberra);
-        DISPATCH_VD(METRIC_BrayCurtis);
-        DISPATCH_VD(METRIC_JensenShannon);
-        DISPATCH_VD(METRIC_Jaccard);
-        DISPATCH_VD(METRIC_NaNEuclidean);
-        DISPATCH_VD(METRIC_GOWER);
-        default:
-            FAISS_THROW_FMT("Invalid metric %d", metric);
-    }
-#undef DISPATCH_VD
-}
-
-} // namespace faiss