candle-mi 0.1.7

Mechanistic interpretability for language models in Rust, built on candle
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

// SPDX-License-Identifier: MIT OR Apache-2.0

//! Error types for candle-mi.

/// Errors that can occur during MI operations.
///
/// This enum is `#[non_exhaustive]`: new variants will be added in future
/// releases as new backends and capabilities are added.
#[non_exhaustive]
#[derive(Debug, thiserror::Error)]
pub enum MIError {
    /// Model loading or forward pass error (wraps candle).
    #[error("model error: {0}")]
    Model(#[from] candle_core::Error),

    /// Hook capture or lookup error.
    #[error("hook error: {0}")]
    Hook(String),

    /// Intervention validation or application error.
    #[error("intervention error: {0}")]
    Intervention(String),

    /// Model configuration parsing error.
    #[error("config error: {0}")]
    Config(String),

    /// Tokenizer error.
    #[error("tokenizer error: {0}")]
    Tokenizer(String),

    /// I/O error.
    #[error(transparent)]
    Io(#[from] std::io::Error),

    /// Model download error.
    ///
    /// Returned when downloading a model from the `HuggingFace` Hub fails.
    #[error("download error: {0}")]
    Download(String),

    /// Memory measurement error.
    ///
    /// Returned when a platform API for RAM or VRAM measurement fails.
    #[error("memory error: {0}")]
    Memory(String),
}

/// Bridge anamnesis errors into [`MIError`] when the `sae` feature is enabled.
///
/// [`AnamnesisError`](anamnesis::AnamnesisError) is `#[non_exhaustive]`, so the
/// catch-all arm ensures forward compatibility with future variants.
#[cfg(feature = "sae")]
impl From<anamnesis::AnamnesisError> for MIError {
    fn from(e: anamnesis::AnamnesisError) -> Self {
        match e {
            anamnesis::AnamnesisError::Parse { reason } => Self::Config(reason),
            anamnesis::AnamnesisError::Unsupported { format, detail } => {
                Self::Config(format!("unsupported {format}: {detail}"))
            }
            anamnesis::AnamnesisError::Io(io_err) => Self::Io(io_err),
            // AnamnesisError is #[non_exhaustive] — forward-compatible catch-all
            _ => Self::Config(e.to_string()),
        }
    }
}

/// Result type alias for candle-mi operations.
pub type Result<T> = std::result::Result<T, MIError>;