精炼

最近邻搜索的候选精炼方法

#include <cuvs/neighbors/refine.hpp>

namespace cuvs::neighbors

索引

void refine(

raft::resources const &handle,

raft::device_matrix_view<const float, int64_t, raft::row_major> dataset,

raft::device_matrix_view<const float, int64_t, raft::row_major> queries,

raft::device_matrix_view<const int64_t, int64_t, raft::row_major> neighbor_candidates,

raft::device_matrix_view<int64_t, int64_t, raft::row_major> indices,

raft::device_matrix_view<float, int64_t, raft::row_major> distances,

cuvs::distance::DistanceType metric = cuvs::distance::DistanceType::L2Unexpanded

)

精炼最近邻搜索。

精炼是一种在近似最近邻 (NN) 搜索之后进行的操作。近似搜索已经为每个查询选择了 n_candidates 个候选邻居。我们将其缩小到 k 个邻居。对于每个查询，我们计算查询与其 n_candidates 个候选邻居之间的精确距离，并选择 k 个最近的邻居。

返回 k 个最近邻及其距离。

示例用法

using namespace cuvs::neighbors;
// use default index parameters
ivf_pq::index_params index_params;
// create and fill the index from a [N, D] dataset
auto index = ivf_pq::build(handle, index_params, dataset);
// use default search parameters
ivf_pq::search_params search_params;
// search m = 4 * k nearest neighbours for each of the N queries
ivf_pq::search(handle, search_params, index, queries, neighbor_candidates,
               out_dists_tmp);
// refine it to the k nearest one
refine(handle, dataset, queries, neighbor_candidates, out_indices, out_dists,
        index.metric());

参数:

• handle – [in] raft 句柄

• dataset – [in] 存储数据集的设备矩阵 [n_rows, dims]

• queries – [in] 查询向量的设备矩阵 [n_queris, dims]

• neighbor_candidates – [in] 候选向量的索引 [n_queries, n_candidates]，其中 n_candidates >= k

• indices – [out] 存储精炼后索引的设备矩阵 [n_queries, k]

• distances – [out] 存储精炼后距离的设备矩阵 [n_queries, k]

• metric – [in] 要使用的距离度量。默认为欧氏距离 (L2)

void refine(

raft::resources const &handle,

raft::device_matrix_view<const float, int64_t, raft::row_major> dataset,

raft::device_matrix_view<const float, int64_t, raft::row_major> queries,

raft::device_matrix_view<const uint32_t, int64_t, raft::row_major> neighbor_candidates,

raft::device_matrix_view<uint32_t, int64_t, raft::row_major> indices,

raft::device_matrix_view<float, int64_t, raft::row_major> distances,

cuvs::distance::DistanceType metric = cuvs::distance::DistanceType::L2Unexpanded

)

精炼最近邻搜索。

精炼是一种在近似最近邻 (NN) 搜索之后进行的操作。近似搜索已经为每个查询选择了 n_candidates 个候选邻居。我们将其缩小到 k 个邻居。对于每个查询，我们计算查询与其 n_candidates 个候选邻居之间的精确距离，并选择 k 个最近的邻居。

返回 k 个最近邻及其距离。

示例用法

using namespace cuvs::neighbors;
// use default index parameters
ivf_pq::index_params index_params;
// create and fill the index from a [N, D] dataset
auto index = ivf_pq::build(handle, index_params, dataset);
// use default search parameters
ivf_pq::search_params search_params;
// search m = 4 * k nearest neighbours for each of the N queries
ivf_pq::search(handle, search_params, index, queries, neighbor_candidates,
               out_dists_tmp);
// refine it to the k nearest one
refine(handle, dataset, queries, neighbor_candidates, out_indices, out_dists,
        index.metric());

参数:

• handle – [in] raft 句柄

• dataset – [in] 存储数据集的设备矩阵 [n_rows, dims]

• queries – [in] 查询向量的设备矩阵 [n_queris, dims]

• neighbor_candidates – [in] 候选向量的索引 [n_queries, n_candidates]，其中 n_candidates >= k

• indices – [out] 存储精炼后索引的设备矩阵 [n_queries, k]

• distances – [out] 存储精炼后距离的设备矩阵 [n_queries, k]

• metric – [in] 要使用的距离度量。默认为欧氏距离 (L2)

void refine(

raft::resources const &handle,

raft::device_matrix_view<const half, int64_t, raft::row_major> dataset,

raft::device_matrix_view<const half, int64_t, raft::row_major> queries,

raft::device_matrix_view<const int64_t, int64_t, raft::row_major> neighbor_candidates,

raft::device_matrix_view<int64_t, int64_t, raft::row_major> indices,

raft::device_matrix_view<float, int64_t, raft::row_major> distances,

cuvs::distance::DistanceType metric = cuvs::distance::DistanceType::L2Unexpanded

)

精炼最近邻搜索。

精炼是一种在近似最近邻 (NN) 搜索之后进行的操作。近似搜索已经为每个查询选择了 n_candidates 个候选邻居。我们将其缩小到 k 个邻居。对于每个查询，我们计算查询与其 n_candidates 个候选邻居之间的精确距离，并选择 k 个最近的邻居。

返回 k 个最近邻及其距离。

示例用法

using namespace cuvs::neighbors;
// use default index parameters
ivf_pq::index_params index_params;
// create and fill the index from a [N, D] dataset
auto index = ivf_pq::build(handle, index_params, dataset);
// use default search parameters
ivf_pq::search_params search_params;
// search m = 4 * k nearest neighbours for each of the N queries
ivf_pq::search(handle, search_params, index, queries, neighbor_candidates,
               out_dists_tmp);
// refine it to the k nearest one
refine(handle, dataset, queries, neighbor_candidates, out_indices, out_dists,
        index.metric());

参数:

• handle – [in] raft 句柄

• dataset – [in] 存储数据集的设备矩阵 [n_rows, dims]

• queries – [in] 查询向量的设备矩阵 [n_queris, dims]

• neighbor_candidates – [in] 候选向量的索引 [n_queries, n_candidates]，其中 n_candidates >= k

• indices – [out] 存储精炼后索引的设备矩阵 [n_queries, k]

• distances – [out] 存储精炼后距离的设备矩阵 [n_queries, k]

• metric – [in] 要使用的距离度量。默认为欧氏距离 (L2)

void refine(

raft::resources const &handle,

raft::device_matrix_view<const int8_t, int64_t, raft::row_major> dataset,

raft::device_matrix_view<const int8_t, int64_t, raft::row_major> queries,

raft::device_matrix_view<const int64_t, int64_t, raft::row_major> neighbor_candidates,

raft::device_matrix_view<int64_t, int64_t, raft::row_major> indices,

raft::device_matrix_view<float, int64_t, raft::row_major> distances,

cuvs::distance::DistanceType metric = cuvs::distance::DistanceType::L2Unexpanded

)

精炼最近邻搜索。

精炼是一种在近似最近邻 (NN) 搜索之后进行的操作。近似搜索已经为每个查询选择了 n_candidates 个候选邻居。我们将其缩小到 k 个邻居。对于每个查询，我们计算查询与其 n_candidates 个候选邻居之间的精确距离，并选择 k 个最近的邻居。

返回 k 个最近邻及其距离。

示例用法

using namespace cuvs::neighbors;
// use default index parameters
ivf_pq::index_params index_params;
// create and fill the index from a [N, D] dataset
auto index = ivf_pq::build(handle, index_params, dataset);
// use default search parameters
ivf_pq::search_params search_params;
// search m = 4 * k nearest neighbours for each of the N queries
ivf_pq::search(handle, search_params, index, queries, neighbor_candidates,
               out_dists_tmp);
// refine it to the k nearest one
refine(handle, dataset, queries, neighbor_candidates, out_indices, out_dists,
        index.metric());

参数:

• handle – [in] raft 句柄

• dataset – [in] 存储数据集的设备矩阵 [n_rows, dims]

• queries – [in] 查询向量的设备矩阵 [n_queris, dims]

• neighbor_candidates – [in] 候选向量的索引 [n_queries, n_candidates]，其中 n_candidates >= k

• indices – [out] 存储精炼后索引的设备矩阵 [n_queries, k]

• distances – [out] 存储精炼后距离的设备矩阵 [n_queries, k]

• metric – [in] 要使用的距离度量。默认为欧氏距离 (L2)

void refine(

raft::resources const &handle,

raft::device_matrix_view<const uint8_t, int64_t, raft::row_major> dataset,

raft::device_matrix_view<const uint8_t, int64_t, raft::row_major> queries,

raft::device_matrix_view<const int64_t, int64_t, raft::row_major> neighbor_candidates,

raft::device_matrix_view<int64_t, int64_t, raft::row_major> indices,

raft::device_matrix_view<float, int64_t, raft::row_major> distances,

cuvs::distance::DistanceType metric = cuvs::distance::DistanceType::L2Unexpanded

)

精炼最近邻搜索。

精炼是一种在近似最近邻 (NN) 搜索之后进行的操作。近似搜索已经为每个查询选择了 n_candidates 个候选邻居。我们将其缩小到 k 个邻居。对于每个查询，我们计算查询与其 n_candidates 个候选邻居之间的精确距离，并选择 k 个最近的邻居。

返回 k 个最近邻及其距离。

示例用法

using namespace cuvs::neighbors;
// use default index parameters
ivf_pq::index_params index_params;
// create and fill the index from a [N, D] dataset
auto index = ivf_pq::build(handle, index_params, dataset);
// use default search parameters
ivf_pq::search_params search_params;
// search m = 4 * k nearest neighbours for each of the N queries
ivf_pq::search(handle, search_params, index, queries, neighbor_candidates,
               out_dists_tmp);
// refine it to the k nearest one
refine(handle, dataset, queries, neighbor_candidates, out_indices, out_dists,
        index.metric());

参数:

• handle – [in] raft 句柄

• dataset – [in] 存储数据集的设备矩阵 [n_rows, dims]

• queries – [in] 查询向量的设备矩阵 [n_queris, dims]

• neighbor_candidates – [in] 候选向量的索引 [n_queries, n_candidates]，其中 n_candidates >= k

• indices – [out] 存储精炼后索引的设备矩阵 [n_queries, k]

• distances – [out] 存储精炼后距离的设备矩阵 [n_queries, k]

• metric – [in] 要使用的距离度量。默认为欧氏距离 (L2)

void refine(

raft::resources const &handle,

raft::host_matrix_view<const float, int64_t, raft::row_major> dataset,

raft::host_matrix_view<const float, int64_t, raft::row_major> queries,

raft::host_matrix_view<const int64_t, int64_t, raft::row_major> neighbor_candidates,

raft::host_matrix_view<int64_t, int64_t, raft::row_major> indices,

raft::host_matrix_view<float, int64_t, raft::row_major> distances,

cuvs::distance::DistanceType metric = cuvs::distance::DistanceType::L2Unexpanded

)

精炼最近邻搜索。

精炼是一种在近似最近邻 (NN) 搜索之后进行的操作。近似搜索已经为每个查询选择了 n_candidates 个候选邻居。我们将其缩小到 k 个邻居。对于每个查询，我们计算查询与其 n_candidates 个候选邻居之间的精确距离，并选择 k 个最近的邻居。

返回 k 个最近邻及其距离。

示例用法

using namespace cuvs::neighbors;
// use default index parameters
ivf_pq::index_params index_params;
// create and fill the index from a [N, D] dataset
auto index = ivf_pq::build(handle, index_params, dataset);
// use default search parameters
ivf_pq::search_params search_params;
// search m = 4 * k nearest neighbours for each of the N queries
ivf_pq::search(handle, search_params, index, queries, neighbor_candidates,
               out_dists_tmp);
// refine it to the k nearest one
refine(handle, dataset, queries, neighbor_candidates, out_indices, out_dists,
        index.metric());

参数:

• handle – [in] raft 句柄

• dataset – [in] 存储数据集的主机矩阵 [n_rows, dims]

• queries – [in] 查询向量的主机矩阵 [n_queris, dims]

• neighbor_candidates – [in] 包含候选向量索引的主机矩阵 [n_queries, n_candidates]，其中 n_candidates >= k

• indices – [out] 存储精炼后索引的主机矩阵 [n_queries, k]

• distances – [out] 存储精炼后距离的主机矩阵 [n_queries, k]

• metric – [in] 要使用的距离度量。默认为欧氏距离 (L2)

void refine(

raft::resources const &handle,

raft::host_matrix_view<const float, int64_t, raft::row_major> dataset,

raft::host_matrix_view<const float, int64_t, raft::row_major> queries,

neighbor_candidates – [in] 包含候选向量索引的主机矩阵 [n_queries, n_candidates]，其中 n_candidates >= k,

indices – [out] 存储精炼后索引的主机矩阵 [n_queries, k],

raft::host_matrix_view<float, int64_t, raft::row_major> distances,

cuvs::distance::DistanceType metric = cuvs::distance::DistanceType::L2Unexpanded

)

精炼最近邻搜索。

精炼是一种在近似最近邻 (NN) 搜索之后进行的操作。近似搜索已经为每个查询选择了 n_candidates 个候选邻居。我们将其缩小到 k 个邻居。对于每个查询，我们计算查询与其 n_candidates 个候选邻居之间的精确距离，并选择 k 个最近的邻居。

返回 k 个最近邻及其距离。

示例用法

using namespace cuvs::neighbors;
// use default index parameters
ivf_pq::index_params index_params;
// create and fill the index from a [N, D] dataset
auto index = ivf_pq::build(handle, index_params, dataset);
// use default search parameters
ivf_pq::search_params search_params;
// search m = 4 * k nearest neighbours for each of the N queries
ivf_pq::search(handle, search_params, index, queries, neighbor_candidates,
               out_dists_tmp);
// refine it to the k nearest one
refine(handle, dataset, queries, neighbor_candidates, out_indices, out_dists,
        index.metric());

参数:

• handle – [in] raft 句柄

• dataset – [in] 存储数据集的主机矩阵 [n_rows, dims]

• queries – [in] 查询向量的主机矩阵 [n_queris, dims]

• neighbor_candidates – [in] 包含候选向量索引的主机矩阵 [n_queries, n_candidates]，其中 n_candidates >= k

• indices – [out] 存储精炼后索引的主机矩阵 [n_queries, k]

• distances – [out] 存储精炼后距离的主机矩阵 [n_queries, k]

• metric – [in] 要使用的距离度量。默认为欧氏距离 (L2)

void refine(

raft::resources const &handle,

dataset – [in] 存储数据集的主机矩阵 [n_rows, dims],

queries – [in] 查询向量的主机矩阵 [n_queris, dims],

raft::host_matrix_view<const int64_t, int64_t, raft::row_major> neighbor_candidates,

raft::host_matrix_view<int64_t, int64_t, raft::row_major> indices,

raft::host_matrix_view<float, int64_t, raft::row_major> distances,

cuvs::distance::DistanceType metric = cuvs::distance::DistanceType::L2Unexpanded

)

精炼最近邻搜索。

精炼是一种在近似最近邻 (NN) 搜索之后进行的操作。近似搜索已经为每个查询选择了 n_candidates 个候选邻居。我们将其缩小到 k 个邻居。对于每个查询，我们计算查询与其 n_candidates 个候选邻居之间的精确距离，并选择 k 个最近的邻居。

返回 k 个最近邻及其距离。

示例用法

using namespace cuvs::neighbors;
// use default index parameters
ivf_pq::index_params index_params;
// create and fill the index from a [N, D] dataset
auto index = ivf_pq::build(handle, index_params, dataset);
// use default search parameters
ivf_pq::search_params search_params;
// search m = 4 * k nearest neighbours for each of the N queries
ivf_pq::search(handle, search_params, index, queries, neighbor_candidates,
               out_dists_tmp);
// refine it to the k nearest one
refine(handle, dataset, queries, neighbor_candidates, out_indices, out_dists,
        index.metric());

参数:

• handle – [in] raft 句柄

• dataset – [in] 存储数据集的主机矩阵 [n_rows, dims]

• queries – [in] 查询向量的主机矩阵 [n_queris, dims]

• neighbor_candidates – [in] 包含候选向量索引的主机矩阵 [n_queries, n_candidates]，其中 n_candidates >= k

• indices – [out] 存储精炼后索引的主机矩阵 [n_queries, k]

• distances – [out] 存储精炼后距离的主机矩阵 [n_queries, k]

• metric – [in] 要使用的距离度量。默认为欧氏距离 (L2)

void refine(

raft::resources const &handle,

dataset – [in] 存储数据集的主机矩阵 [n_rows, dims],

queries – [in] 查询向量的主机矩阵 [n_queris, dims],

raft::host_matrix_view<const int64_t, int64_t, raft::row_major> neighbor_candidates,

raft::host_matrix_view<int64_t, int64_t, raft::row_major> indices,

raft::host_matrix_view<float, int64_t, raft::row_major> distances,

cuvs::distance::DistanceType metric = cuvs::distance::DistanceType::L2Unexpanded

)

精炼最近邻搜索。

精炼是一种在近似最近邻 (NN) 搜索之后进行的操作。近似搜索已经为每个查询选择了 n_candidates 个候选邻居。我们将其缩小到 k 个邻居。对于每个查询，我们计算查询与其 n_candidates 个候选邻居之间的精确距离，并选择 k 个最近的邻居。

返回 k 个最近邻及其距离。

示例用法

using namespace cuvs::neighbors;
// use default index parameters
ivf_pq::index_params index_params;
// create and fill the index from a [N, D] dataset
auto index = ivf_pq::build(handle, index_params, dataset);
// use default search parameters
ivf_pq::search_params search_params;
// search m = 4 * k nearest neighbours for each of the N queries
ivf_pq::search(handle, search_params, index, queries, neighbor_candidates,
               out_dists_tmp);
// refine it to the k nearest one
refine(handle, dataset, queries, neighbor_candidates, out_indices, out_dists,
        index.metric());

参数:

• handle – [in] raft 句柄

• dataset – [in] 存储数据集的主机矩阵 [n_rows, dims]

• queries – [in] 查询向量的主机矩阵 [n_queris, dims]

• neighbor_candidates – [in] 包含候选向量索引的主机矩阵 [n_queries, n_candidates]，其中 n_candidates >= k

• indices – [out] 存储精炼后索引的主机矩阵 [n_queries, k]

• distances – [out] 存储精炼后距离的主机矩阵 [n_queries, k]

• metric – [in] 要使用的距离度量。默认为欧氏距离 (L2)

void refine(

raft::resources const &handle,

dataset – [in] 存储数据集的主机矩阵 [n_rows, dims],

queries – [in] 查询向量的主机矩阵 [n_queris, dims],

raft::host_matrix_view<const int64_t, int64_t, raft::row_major> neighbor_candidates,

raft::host_matrix_view<int64_t, int64_t, raft::row_major> indices,

raft::host_matrix_view<float, int64_t, raft::row_major> distances,

cuvs::distance::DistanceType metric = cuvs::distance::DistanceType::L2Unexpanded

)

精炼最近邻搜索。

精炼是一种在近似最近邻 (NN) 搜索之后进行的操作。近似搜索已经为每个查询选择了 n_candidates 个候选邻居。我们将其缩小到 k 个邻居。对于每个查询，我们计算查询与其 n_candidates 个候选邻居之间的精确距离，并选择 k 个最近的邻居。

返回 k 个最近邻及其距离。

示例用法

using namespace cuvs::neighbors;
// use default index parameters
ivf_pq::index_params index_params;
// create and fill the index from a [N, D] dataset
auto index = ivf_pq::build(handle, index_params, dataset);
// use default search parameters
ivf_pq::search_params search_params;
// search m = 4 * k nearest neighbours for each of the N queries
ivf_pq::search(handle, search_params, index, queries, neighbor_candidates,
               out_dists_tmp);
// refine it to the k nearest one
refine(handle, dataset, queries, neighbor_candidates, out_indices, out_dists,
        index.metric());

参数:

• handle – [in] raft 句柄

• dataset – [in] 存储数据集的主机矩阵 [n_rows, dims]

• queries – [in] 查询向量的主机矩阵 [n_queris, dims]

• neighbor_candidates – [in] 包含候选向量索引的主机矩阵 [n_queries, n_candidates]，其中 n_candidates >= k

• indices – [out] 存储精炼后索引的主机矩阵 [n_queries, k]

• distances – [out] 存储精炼后距离的主机矩阵 [n_queries, k]

• metric – [in] 要使用的距离度量。默认为欧氏距离 (L2)