knn.hpp

Go to the documentation of this file.

/*
 * SPDX-FileCopyrightText: Copyright (c) 2019-2025, NVIDIA CORPORATION.
 * SPDX-License-Identifier: Apache-2.0
 */
 
#pragma once
 
#include <cuml/common/distance_type.hpp>
 
#include <raft/spatial/knn/detail/processing.hpp>  // MetricProcessor
 
#include <cstdint>
#include <memory>
#include <vector>
 
namespace raft {
class handle_t;
}
 
namespace ML {
 
void brute_force_knn(const raft::handle_t& handle,
                     std::vector<float*>& input,
                     std::vector<int>& sizes,
                     int D,
                     float* search_items,
                     int n,
                     int64_t* res_I,
                     float* res_D,
                     int k,
                     bool rowMajorIndex                 = false,
                     bool rowMajorQuery                 = false,
                     ML::distance::DistanceType metric  = ML::distance::DistanceType::L2Expanded,
                     float metric_arg                   = 2.0f,
                     std::vector<int64_t>* translations = nullptr);
 
void rbc_build_index(const raft::handle_t& handle,
                     std::uintptr_t& rbc_index,
                     float* X,
                     int64_t n_rows,
                     int64_t n_cols,
                     ML::distance::DistanceType metric);
 
void rbc_knn_query(const raft::handle_t& handle,
                   const std::uintptr_t& rbc_index,
                   uint32_t k,
                   const float* search_items,
                   uint32_t n_search_items,
                   int64_t dim,
                   int64_t* out_inds,
                   float* out_dists);
 
void rbc_free_index(std::uintptr_t rbc_index);
 
struct knnIndexImpl;
 
struct knnIndex {
  knnIndex();
  ~knnIndex();
 
  ML::distance::DistanceType metric;
  float metricArg;
  int nprobe;
  std::unique_ptr<raft::spatial::knn::MetricProcessor<float>> metric_processor;
  int device;
 
  std::unique_ptr<knnIndexImpl> pimpl;
};
 
struct knnIndexParam {
  virtual ~knnIndexParam() {}
};
 
struct IVFParam : knnIndexParam {
  int nlist;
  int nprobe;
};
 
struct IVFFlatParam : IVFParam {};
 
struct IVFPQParam : IVFParam {
  int M;
  int n_bits;
  bool usePrecomputedTables;
};
 
void approx_knn_build_index(raft::handle_t& handle,
                            knnIndex* index,
                            knnIndexParam* params,
                            ML::distance::DistanceType metric,
                            float metricArg,
                            float* index_array,
                            int n,
                            int D);
 
void approx_knn_search(raft::handle_t& handle,
                       float* distances,
                       int64_t* indices,
                       knnIndex* index,
                       int k,
                       float* query_array,
                       int n);
 
void knn_classify(raft::handle_t& handle,
                  int* out,
                  int64_t* knn_indices,
                  std::vector<int*>& y,
                  size_t n_index_rows,
                  size_t n_query_rows,
                  int k,
                  float* sample_weight = nullptr);
 
void knn_regress(raft::handle_t& handle,
                 float* out,
                 int64_t* knn_indices,
                 std::vector<float*>& y,
                 size_t n_index_rows,
                 size_t n_query_rows,
                 int k,
                 float* sample_weight = nullptr);
 
void knn_class_proba(raft::handle_t& handle,
                     std::vector<float*>& out,
                     int64_t* knn_indices,
                     std::vector<int*>& y,
                     size_t n_index_rows,
                     size_t n_query_rows,
                     int k,
                     float* sample_weight = nullptr);
};  // namespace ML