Enum Refusal 

pub enum Refusal {
    Mixer {
        layer: usize,
        what: &'static str,
    },
    Ffn {
        layer: usize,
        what: &'static str,
    },
    Norm {
        layer: usize,
        what: &'static str,
    },
    Attention {
        layer: usize,
        what: &'static str,
    },
    EmbeddingScale,
    LogitSoftcap,
    MissingTensor(String),
    Format {
        tensor: String,
        format: &'static str,
    },
    Program(String),
}

One thing a checkpoint needs that the engine does not do.

Variants

Mixer

A block’s token mixer the engine has no unit for.

Fields

layer: usize

what: &'static str

Ffn

A feed-forward block other than the dense SwiGLU the lowering writes.

Fields

layer: usize

what: &'static str

Norm

A norm the lowering does not apply.

Fields

layer: usize

what: &'static str

Attention

An attention variant the attention unit does not compute.

Fields

layer: usize

what: &'static str

EmbeddingScale

A scale the token embedding is read with.

LogitSoftcap

Soft-capped logits.

MissingTensor(String)

A tensor the program reads that the checkpoint does not hold.

Format

A tensor the program reads in a format no unit reads.

Fields

tensor: String

format: &'static str

Program(String)

The model’s one program does not lower to the engine, for the reason given.

Implementations

impl Refusal

pub fn gap(&self) -> String

The refusal without its layer: the words the engine’s shim (super::shim::EngineShim) refuses the op that carries it in.

Trait Implementations

impl Clone for Refusal

fn clone(&self) -> Refusal

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Refusal

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

Formats the value using the given formatter.

impl Display for Refusal

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

Formats the value using the given formatter.

impl PartialEq for Refusal

fn eq(&self, other: &Refusal) -> 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 Eq for Refusal

impl StructuralPartialEq for Refusal