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
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87

use super::*;
use crate::registry::Backend;
use crate::registry::CellException;
use crate::registry::DtypeSupport;
use crate::registry::rerank::entry::RerankEntry;
use crate::registry::rerank::qwen3_reranker::QWEN3_RERANKER_0_6B;
use crate::registry::rerank::qwen3_reranker::QWEN3_RERANKER_4B;

const METAL_F32_UNRUN: CellException = CellException {
  dtype: DType::F32,
  backend: Backend::Metal,
  status: Support::Untested,
  reason: "the Metal F32 load did not fit the machine",
};

const METAL_F32_MISSED: CellException = CellException {
  dtype: DType::F32,
  backend: Backend::Metal,
  status: Support::Unsupported,
  reason: "the Metal F32 run crossed the 1e-4 ceiling",
};

fn row(cpu: Support, metal: Support, cuda: Support) -> BackendSupport {
  BackendSupport { cpu, metal, cuda }
}

#[test]
fn both_states_the_4b_runs_can_leave_reach_its_descriptor() {
  let (verified, pending, untested, unsupported) = (
    Support::Verified,
    Support::Pending,
    Support::Untested,
    Support::Unsupported,
  );
  let registered = QWEN3_RERANKER_4B.descriptor().dtype_backends;
  let cpu_passed = RerankEntry {
    cpu: verified,
    dtypes: DtypeSupport {
      f32: verified,
      ..QWEN3_RERANKER_4B.dtypes
    },
    cell_exceptions: &[METAL_F32_UNRUN],
    ..QWEN3_RERANKER_4B
  };
  assert_eq!(cpu_passed.cells().exception_violation(), None);
  let rows = cpu_passed.descriptor().dtype_backends;
  assert_eq!(rows.f32, row(verified, untested, untested));
  assert_eq!((rows.f16, rows.bf16), (registered.f16, registered.bf16));
  let metal_missed = RerankEntry {
    cell_exceptions: &[METAL_F32_MISSED],
    ..QWEN3_RERANKER_4B
  };
  assert_eq!(metal_missed.cells().exception_violation(), None);
  let rows = metal_missed.descriptor().dtype_backends;
  assert_eq!(rows.f32, row(pending, unsupported, untested));
  assert_eq!((rows.f16, rows.bf16), (registered.f16, registered.bf16));
}

#[test]
fn dtype_needs_accelerator_reads_the_rows_the_builder_refuses_from() {
  for descriptor in all() {
    let id = descriptor.id.as_str();
    assert!(!dtype_needs_accelerator(id, DType::F32), "{id} f32");
    assert_eq!(
      dtype_needs_accelerator(id, DType::F16),
      id != QWEN3_RERANKER_4B.id,
      "{id} f16"
    );
    assert!(dtype_needs_accelerator(id, DType::BF16), "{id} bf16");
  }
}

#[test]
fn an_exception_moves_the_answer_with_its_row() {
  let metal_f16_missed = RerankEntry {
    cell_exceptions: &[CellException {
      dtype: DType::F16,
      backend: Backend::Metal,
      status: Support::Unsupported,
      reason: "a Metal F16 run past the checkpoint's ceiling",
    }],
    ..QWEN3_RERANKER_0_6B
  };
  assert_eq!(metal_f16_missed.cells().exception_violation(), None);
  assert!(QWEN3_RERANKER_0_6B.needs_accelerator(DType::F16));
  assert!(!metal_f16_missed.needs_accelerator(DType::F16));
}