candding 0.1.0

Pure candle embeddings for Rust with no ONNX: dense, sparse, multi-vector and rerank models today, image models on the roadmap
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72

//! Entries land proven: every registered entry needs a run that verified at least one cell.

use super::*;
use crate::registry::multi_vector;
use crate::registry::rerank;
use crate::registry::sparse::SparseComputation;
use crate::registry::sparse::all as sparse_entries;

fn cells(rows: &DtypeBackendSupport) -> Vec<Support> {
  [rows.f32, rows.f16, rows.bf16]
    .iter()
    .flat_map(|row| [row.cpu, row.metal, row.cuda])
    .collect()
}

/// `Qdrant/bm25` computes with no device or dtype, so all nine of its cells are `NotApplicable` instead.
#[test]
fn every_registered_entry_in_every_catalog_carries_a_verified_cell() {
  let computed: Vec<String> = sparse_entries()
    .into_iter()
    .filter(|d| d.computation == SparseComputation::Computed)
    .map(|d| d.id)
    .collect();
  assert_eq!(computed, ["Qdrant/bm25"]);
  let catalogs: [(&str, Vec<(String, DtypeBackendSupport)>); 4] = [
    (
      "dense",
      all()
        .into_iter()
        .map(|d| (d.id, d.dtype_backends))
        .collect(),
    ),
    (
      "sparse",
      sparse_entries()
        .into_iter()
        .map(|d| (d.id, d.dtype_backends))
        .collect(),
    ),
    (
      "multi-vector",
      multi_vector::all()
        .into_iter()
        .map(|d| (d.id, d.dtype_backends))
        .collect(),
    ),
    (
      "rerank",
      rerank::all()
        .into_iter()
        .map(|d| (d.id, d.dtype_backends))
        .collect(),
    ),
  ];
  for (catalog, entries) in catalogs {
    assert!(!entries.is_empty(), "the {catalog} catalog is empty");
    for (id, rows) in entries {
      let cells = cells(&rows);
      if computed.contains(&id) {
        assert!(
          cells.iter().all(|&cell| cell == Support::NotApplicable),
          "{catalog} {id}: a computed entry has no device or dtype axis, so every cell is not_applicable: {rows:?}"
        );
        continue;
      }
      assert!(
        cells.contains(&Support::Verified),
        "{catalog} {id}: registered with no verified cell; an entry lands only once a golden run verifies one: {rows:?}"
      );
    }
  }
}