Enum LmError 

pub enum LmError {
    DimensionMismatch {
        expected: usize,
        got: usize,
    },
    InvalidConfig {
        msg: String,
    },
    EmptyInput {
        context: &'static str,
    },
    OutOfVocab {
        token: u32,
    },
    TokenizerUninitialized,
    Utf8Decode {
        token: u32,
    },
    WeightNotFound {
        name: String,
    },
    WeightShapeMismatch {
        name: String,
        expected: Vec<usize>,
        got: Vec<usize>,
    },
    LayerIndexOutOfRange {
        idx: usize,
        n_layers: usize,
    },
    HeadDimMismatch {
        hidden_dim: usize,
        n_heads: usize,
    },
    KvCacheLengthMismatch {
        past_len: usize,
        got: usize,
    },
    SequenceTooLong {
        total_len: usize,
        max_pos: usize,
    },
    InvalidMergePair {
        a: u32,
        b: u32,
    },
    VocabSizeMismatch {
        expected: usize,
        got: usize,
    },
    GqaHeadMismatch {
        n_heads: usize,
        n_kv_heads: usize,
    },
    WeightDataLengthMismatch {
        data_len: usize,
        shape: Vec<usize>,
        expected: usize,
    },
    Internal {
        msg: String,
    },
}

All errors that can arise from LLM inference operations.

Variants

DimensionMismatch

Tensor or slice dimension does not match expectation.

Fields

expected: usize

got: usize

InvalidConfig

Model or layer configuration is invalid.

Fields

msg: String

EmptyInput

An input that must be non-empty was empty.

Fields

context: &'static str

OutOfVocab

A token id is outside the vocabulary range.

Fields

token: u32

TokenizerUninitialized

Tokenizer was used before being properly initialised.

Utf8Decode

Token byte sequence is not valid UTF-8.

Fields

token: u32

WeightNotFound

A named weight entry is absent from ModelWeights.

Fields

name: String

WeightShapeMismatch

A named weight has an unexpected shape.

Fields

name: String

expected: Vec<usize>

got: Vec<usize>

LayerIndexOutOfRange

Transformer layer index is out of range.

Fields

idx: usize

n_layers: usize

HeadDimMismatch

Hidden dimension is not divisible by the number of attention heads.

Fields

hidden_dim: usize

n_heads: usize

KvCacheLengthMismatch

KV cache contains a different number of past tokens than expected.

Fields

past_len: usize

got: usize

SequenceTooLong

Input sequence length exceeds the model’s max_position_embeddings.

Fields

total_len: usize

max_pos: usize

InvalidMergePair

A BPE merge references tokens that are not in the vocabulary.

Fields

a: u32

b: u32

VocabSizeMismatch

Vocabulary size does not match model configuration.

Fields

expected: usize

got: usize

GqaHeadMismatch

n_kv_heads does not divide n_heads evenly (GQA requirement).

Fields

n_heads: usize

n_kv_heads: usize

WeightDataLengthMismatch

A weight tensor element count does not match its declared shape.

Fields

data_len: usize

shape: Vec<usize>

expected: usize

Internal

Catch-all for internal invariant violations.

Fields

msg: String

Trait Implementations

impl Clone for LmError

fn clone(&self) -> LmError

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for LmError

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Display for LmError

fn fmt(&self, __formatter: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Eq for LmError

impl Error for LmError

fn source(&self) -> Option<&(dyn Error + 'static)>

Returns the lower-level source of this error, if any.

fn description(&self) -> &str

👎Deprecated since 1.42.0:

use the Display impl or to_string()

fn cause(&self) -> Option<&dyn Error>

👎Deprecated since 1.33.0:

replaced by Error::source, which can support downcasting

fn provide<'a>(&'a self, request: &mut Request<'a>)

🔬This is a nightly-only experimental API. (error_generic_member_access)

Provides type-based access to context intended for error reports.

impl PartialEq for LmError

fn eq(&self, other: &LmError) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl StructuralPartialEq for LmError