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

//! Cells a run decided that `DtypeBackendSupport::derive` cannot state, such as one device's F32 verified while
//! another's stays unrun; entries list them as `CellException`s, written over the derived rows.

use candle_core::DType;
use candle_core::Device;

use super::BackendSupport;
use super::DtypeBackendSupport;
use super::Support;

#[cfg(test)]
pub(crate) mod rules;

/// A compute backend: the device axis of every support row, and the backend a device error or refusal names.
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
#[non_exhaustive]
pub enum Backend {
  Cpu,
  Metal,
  Cuda,
}

impl Backend {
  /// The backend a runtime device computes on: `BackendSupport::for_device` reads this field.
  pub(crate) fn of(device: &Device) -> Self {
    if device.is_cpu() {
      Backend::Cpu
    } else if device.is_metal() {
      Backend::Metal
    } else {
      Backend::Cuda
    }
  }

  /// The name errors and `describe` print for the backend.
  pub(crate) fn name(self) -> &'static str {
    match self {
      Backend::Cpu => "cpu",
      Backend::Metal => "metal",
      Backend::Cuda => "cuda",
    }
  }
}

impl BackendSupport {
  /// The cell of one backend.
  pub(crate) fn get(&self, backend: Backend) -> Support {
    match backend {
      Backend::Cpu => self.cpu,
      Backend::Metal => self.metal,
      Backend::Cuda => self.cuda,
    }
  }
}

/// One cell a run decided where the derivation cannot reach: `status` for `dtype` on `backend`, with `reason` naming
/// the run. Every catalog's entries carry them, and `rules` holds each to what a cell may take.
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub(crate) struct CellException {
  pub dtype: DType,
  pub backend: Backend,
  pub status: Support,
  pub reason: &'static str,
}

impl DtypeBackendSupport {
  /// The rows with each exception's cell replaced by its status, applied after `derive`, so an exception decides its
  /// one cell and nothing else. The last exception for a cell wins; the registry tests refuse two for one cell.
  pub(crate) fn with_exceptions(mut self, exceptions: &[CellException]) -> Self {
    for exception in exceptions {
      let row = match exception.dtype {
        DType::F16 => &mut self.f16,
        DType::BF16 => &mut self.bf16,
        _ => &mut self.f32,
      };
      let cell = match exception.backend {
        Backend::Cpu => &mut row.cpu,
        Backend::Metal => &mut row.metal,
        Backend::Cuda => &mut row.cuda,
      };
      *cell = exception.status;
    }
    self
  }
}