DenseMetricHow a dense index scores two vectors.class DenseMetric(IntEnum)INNER | 1 | Sum of elementwise products, unnormalized; the one metric the linear-algebra verbs accept. |
|---|---|---|
ANGULAR | 2 | Cosine distance in [0, 2], zero for identical directions and blind to magnitude. |
EUCLIDEAN | 3 | L2 distance, non-negative and zero only for identical vectors. |
HAMMING | 4 | Count of differing bits, ranging up to the dimensionality. |
JACCARD | 5 | Differing bits over union bits in [0, 1], ignoring the zeros both vectors share. |
DenseIndexVector search over equidimensional dense embeddings; its verbs run on the calling thread.40class DenseIndexinit_ramStarts an empty, mutable graph in host memory.@classmethod
def init_ram(
dimensions: int,
metric: DenseMetric = ...,
quantization: Scalar = ...,
*,
connectivity: int = 0,
values_per_key: int = 0,
memory_domains: Sequence[int] | None = None,
cpu_class: CPUClass | None = None,
) -> DenseIndexinit_vramStarts an empty, mutable graph on CUDA devices.@classmethod
def init_vram(
dimensions: int,
metric: DenseMetric = ...,
quantization: Scalar = ...,
*,
connectivity: int = 0,
values_per_key: int = 0,
devices: Sequence[int] | None = None,
gpu_class: GPUClass | None = None,
) -> DenseIndexload_ramCopies a checkpoint into a new, mutable index in host memory.@classmethod
def load_ram(
path: _PathLike,
/,
*,
memory_domains: Sequence[int] | None = None,
executor: Executor | None = None,
values_per_key: int = 0,
progress: _Progress | None = None,
progress_steps: int = 0,
cpu_class: CPUClass | None = None,
) -> DenseIndexload_ram_bufferCopies a monolith out of a buffer into host memory.@classmethod
def load_ram_buffer(
buffer: Buffer,
/,
*,
memory_domains: Sequence[int] | None = None,
executor: Executor | None = None,
values_per_key: int = 0,
progress: _Progress | None = None,
progress_steps: int = 0,
cpu_class: CPUClass | None = None,
) -> DenseIndexload_vramCopies a checkpoint into a new, mutable index on CUDA devices.@classmethod
def load_vram(
path: _PathLike,
/,
*,
devices: Sequence[int] | None = None,
executor: Executor | None = None,
values_per_key: int = 0,
progress: _Progress | None = None,
progress_steps: int = 0,
gpu_class: GPUClass | None = None,
) -> DenseIndexload_vram_bufferCopies a monolith out of a buffer onto CUDA devices.@classmethod
def load_vram_buffer(
buffer: Buffer,
/,
*,
devices: Sequence[int] | None = None,
executor: Executor | None = None,
values_per_key: int = 0,
progress: _Progress | None = None,
progress_steps: int = 0,
gpu_class: GPUClass | None = None,
) -> DenseIndexview_ramServes a checkpoint in place through a memory mapping, read-only.@classmethod
def view_ram(path: _PathLike, /) -> DenseIndexview_nvmeServes a checkpoint in place from NVMe drives, read-only.@classmethod
def view_nvme(
path: _PathLike,
/,
*,
paths: Sequence[_PathLike] | None = None,
executor: Executor | None = None,
cpu_class: CPUClass | None = None,
) -> DenseIndexmetadata_readReads a checkpoint's geometry without loading it.@staticmethod
def metadata_read(
path: _PathLike,
/,
*,
executor: Executor | None = None,
) -> DenseMetadatametadata_read_bufferReads a monolith's geometry.@staticmethod
def metadata_read_buffer(
buffer: Buffer,
/,
*,
executor: Executor | None = None,
) -> DenseMetadataonA receiver whose verbs block on executor.deferredA receiver whose verbs submit to executor, each answering a Deferred.describeThe frozen metadata and current counters.def describe() -> DenseIndexDescriptionreserveGrows the index to host at least capacity entries, a hint, since insertions grow it on demand.def reserve(capacity: int, /) -> NoneclearDrops every entry, keeping the capacity and geometry.def clear() -> NoneinsertInserts a batch of vectors under their keys, all or nothing.def insert(
keys: Sequence[_KeyLike] | _Tensor,
vectors: _Tensor,
/,
*,
expansion_factor: int = 0,
dtype: Scalar | None = None,
progress: _Progress | None = None,
progress_steps: int = 0,
stats: DenseTraversalStats | None = None,
) -> NonerefineRe-selects every entry's neighbors, reporting what changed.def refine(
*,
expansion_factor: int = 0,
progress: _Progress | None = None,
progress_steps: int = 0,
stats: DenseTraversalStats | None = None,
) -> RefineReporthealthAudits how much of the graph a search reaches.def health() -> DenseReachabilitysearchFinds the wanted nearest entries for every query row.def search(
queries: _Tensor,
wanted: int,
arena: Arena,
/,
*,
expansion_factor: int = 0,
traversal: Traversal = ...,
dtype: Scalar | None = None,
predicate: Callable[[Key], bool] | None = None,
progress: _Progress | None = None,
progress_steps: int = 0,
stats: DenseTraversalStats | None = None,
) -> MatchescountHow many entries share key.def count(key: _KeyLike, /) -> intgetEvery vector stored under key, empty when it is absent.def get(
key: _KeyLike,
arena: Arena,
/,
*,
outputs_dtype: Scalar = ...,
) -> DenseVectorsmultiplyEvery pair the walk scored, an approximate sparse product.def multiply(
rows: _Tensor,
wanted: int,
arena: Arena,
/,
*,
expansion_factor: int = 0,
dtype: Scalar | None = None,
progress: _Progress | None = None,
progress_steps: int = 0,
stats: DenseTraversalStats | None = None,
) -> DenseProductsattendSoftmax attention folded into the walk, refused on VRAM with DeviceError.def attend(
queries: _Tensor,
values: _Tensor,
row_of: Callable[[Key], int | None],
arena: Arena,
/,
*,
head_count: int = 1,
expansion_factor: int = 0,
score_scale: float = 0.0,
dtype: Scalar | None = None,
values_dtype: Scalar | None = None,
outputs_dtype: Scalar | None = None,
carry: _Tensor | None = None,
progress: _Progress | None = None,
progress_steps: int = 0,
stats: DenseTraversalStats | None = None,
) -> DenseVectorsmaxsimLate interaction over multi-row queries.def maxsim(
queries: _Tensor,
rows_per_query: int,
wanted: int,
arena: Arena,
/,
*,
expansion_factor: int = 0,
traversal: Traversal = ...,
dtype: Scalar | None = None,
predicate: Callable[[Key], bool] | None = None,
progress: _Progress | None = None,
progress_steps: int = 0,
stats: DenseTraversalStats | None = None,
) -> DenseProductsabsorbAbsorbs and consumes every donor, one after another.def absorb(
*donors: DenseIndex = (),
progress: _Progress | None = None,
progress_steps: int = 0,
) -> RefineReportsplitSplits the entries into the empty receivers, leaving this index empty.def split(
*receivers: DenseIndex = (),
expansion_factor: int = 0,
seed: int = 0,
progress: _Progress | None = None,
progress_steps: int = 0,
stats: DenseTraversalStats | None = None,
) -> RefineReportsampleDraws keys around focus, placed beside the shown keys.def sample(
wanted: int,
arena: Arena,
/,
*,
shown: Sequence[_KeyLike] | _Tensor | None = None,
shown_coordinates: _Tensor | None = None,
focus: Sequence[_KeyLike] | _Tensor | None = None,
seed: int = 0,
expansion_factor: int = 0,
progress: _Progress | None = None,
progress_steps: int = 0,
stats: DenseTraversalStats | None = None,
) -> SamplesaveWrites a checkpoint in the layout the extension picks.def save(
path: _PathLike,
/,
*,
progress: _Progress | None = None,
progress_steps: int = 0,
) -> Nonesave_bufferSerializes one monolith into an arena.def save_buffer(
arena: Arena,
/,
*,
progress: _Progress | None = None,
progress_steps: int = 0,
) -> MonolithcursorA walk DenseCursor.next pulls in batches, from starts when given.def cursor(
starts: Sequence[_KeyLike] | _Tensor | None = None,
) -> DenseCursorsearch_streamA resumable stream of matches for one query.def search_stream(
query: _Tensor,
/,
*,
expansion_factor: int = 0,
dtype: Scalar | None = None,
) -> DenseSearchStream__len__Stored entries.__contains__Whether any entry holds key.capacityEntries hosted without growing again.capacity: intdimensionsScalars per vector.dimensions: intconnectivityConnections per node.connectivity: intmemory_usageBytes the handle holds.memory_usage: intcpu_classThe CPUClass dispatch picked on this machine, or None.cpu_class: CPUClass | Nonegpu_classThe GPUClass dispatch picked on the index's devices, or None.gpu_class: GPUClass | Noneshards_countLive shards.shards_count: int