HNSW

1
cdef class AceParams

1
def __init__(self, *, npartitions=0, build_dir="/tmp/hnsw_ace_build", use_disk=False, max_host_memory_gb=0, max_gpu_memory_gb=0)

1
def npartitions(self)

1
def build_dir(self)

1
def use_disk(self)

1
def max_host_memory_gb(self)

1
def max_gpu_memory_gb(self)

1
cdef class IndexParams

1
def __init__(self, *, hierarchy="gpu", ef_construction=200, num_threads=0, M=32, metric="sqeuclidean", ace_params=None)

1
def hierarchy(self)

1
def ef_construction(self)

1
def num_threads(self)

1
def m(self)

1
def ace_params(self)

1
cdef class Index

1
def trained(self)

1
cdef class ExtendParams

1
def __init__(self, *, num_threads=0)

1
def num_threads(self)

1
def build(IndexParams index_params, dataset, resources=None)

1
>>> import numpy as np
2
>>> from cuvs.neighbors import hnsw
3
>>>
4
>>> n_samples = 50000
5
>>> n_features = 50
6
>>> dataset = np.random.random_sample((n_samples, n_features),
7
...                                   dtype=np.float32)
8
>>>
9
>>> # Create ACE parameters
10
>>> ace_params = hnsw.AceParams(
11
...     npartitions=4,
12
...     use_disk=True,
13
...     build_dir="/tmp/hnsw_ace_build"
14
... )
15
>>>
16
>>> # Create index parameters with ACE
17
>>> index_params = hnsw.IndexParams(
18
...     hierarchy="gpu",
19
...     ace_params=ace_params,
20
...     ef_construction=120,
21
...     M=32,
22
...     metric="sqeuclidean"
23
... )
24
>>>
25
>>> # Build the index
26
>>> index = hnsw.build(index_params, dataset)
27
>>>
28
>>> # Search the index
29
>>> queries = np.random.random_sample((10, n_features), dtype=np.float32)
30
>>> distances, neighbors = hnsw.search(
31
...     hnsw.SearchParams(ef=200),
32
...     index,
33
...     queries,
34
...     k=10
35
... )

1
def extend(ExtendParams extend_params, Index index, data, resources=None)

1
>>> import numpy as np
2
>>> from cuvs.neighbors import hnsw, cagra
3
>>>
4
>>> n_samples = 50000
5
>>> n_features = 50
6
>>> dataset = np.random.random_sample((n_samples, n_features))
7
>>>
8
>>> # Build index
9
>>> index = cagra.build(hnsw.IndexParams(), dataset)
10
>>> # Load index
11
>>> hnsw_index = hnsw.from_cagra(hnsw.IndexParams(hierarchy="cpu"), index)
12
>>> # Extend the index with new data
13
>>> new_data = np.random.random_sample((n_samples, n_features))
14
>>> hnsw.extend(hnsw.ExtendParams(), hnsw_index, new_data)

1
cdef class SearchParams

1
def __init__(self, *, ef=200, num_threads=0)

1
def ef(self)

1
def num_threads(self)

1
def load(IndexParams index_params, filename, dim, dtype, metric="sqeuclidean", resources=None)

1
>>> import cupy as cp
2
>>> from cuvs.neighbors import cagra
3
>>> from cuvs.neighbors import hnsw
4
>>> n_samples = 50000
5
>>> n_features = 50
6
>>> dataset = cp.random.random_sample((n_samples, n_features),
7
...                                   dtype=cp.float32)
8
>>> # Build index
9
>>> index = cagra.build(cagra.IndexParams(), dataset)
10
>>> # Serialize the CAGRA index to hnswlib base layer only index format
11
>>> hnsw.save("my_index.bin", index)
12
>>> index = hnsw.load("my_index.bin", n_features, np.float32,
13
...                   "sqeuclidean")

1
def save(filename, Index index, resources=None)

1
>>> import cupy as cp
2
>>> from cuvs.neighbors import cagra
3
>>> n_samples = 50000
4
>>> n_features = 50
5
>>> dataset = cp.random.random_sample((n_samples, n_features),
6
...                                   dtype=cp.float32)
7
>>> # Build index
8
>>> cagra_index = cagra.build(cagra.IndexParams(), dataset)
9
>>> # Serialize and deserialize the cagra index built
10
>>> hnsw_index = hnsw.from_cagra(hnsw.IndexParams(), cagra_index)
11
>>> hnsw.save("my_index.bin", hnsw_index)

1
def search(SearchParams search_params, Index index, queries, k, neighbors=None, distances=None, resources=None)

1
>>> import cupy as cp
2
>>> from cuvs.neighbors import cagra, hnsw
3
>>> n_samples = 50000
4
>>> n_features = 50
5
>>> n_queries = 1000
6
>>> dataset = cp.random.random_sample((n_samples, n_features),
7
...                                   dtype=cp.float32)
8
>>> # Build index
9
>>> index = cagra.build(cagra.IndexParams(), dataset)
10
>>> # Search using the built index
11
>>> queries = cp.random.random_sample((n_queries, n_features),
12
...                                   dtype=cp.float32)
13
>>> k = 10
14
>>> search_params = hnsw.SearchParams(
15
...     ef=200,
16
...     num_threads=0
17
... )
18
>>> # Convert CAGRA index to HNSW
19
>>> hnsw_index = hnsw.from_cagra(hnsw.IndexParams(), index)
20
>>> # Using a pooling allocator reduces overhead of temporary array
21
>>> # creation during search. This is useful if multiple searches
22
>>> # are performed with same query size.
23
>>> distances, neighbors = hnsw.search(search_params, index, queries,
24
...                                     k)
25
>>> neighbors = cp.asarray(neighbors)
26
>>> distances = cp.asarray(distances)

1
def from_cagra(IndexParams index_params, cagra.Index cagra_index, temporary_index_path=None, resources=None)

1
>>> import cupy as cp
2
>>> from cuvs.neighbors import cagra
3
>>> from cuvs.neighbors import hnsw
4
>>> n_samples = 50000
5
>>> n_features = 50
6
>>> dataset = cp.random.random_sample((n_samples, n_features),
7
...                                   dtype=cp.float32)
8
>>> # Build index
9
>>> index = cagra.build(cagra.IndexParams(), dataset)
10
>>> # Serialize the CAGRA index to hnswlib base layer only index format
11
>>> hnsw_index = hnsw.from_cagra(hnsw.IndexParams(), index)