Struct ModelConfig 

pub struct ModelConfig {

    pub vocab_size: usize,
    pub hidden_size: usize,
    pub intermediate_size: usize,
    pub num_layers: usize,
    pub num_heads: usize,
    pub num_kv_heads: usize,
    pub head_dim: usize,
    pub max_seq_len: usize,
    pub norm_eps: f32,
    pub rope_config: RopeConfig,
    pub use_parallel_residual: bool,
    pub hidden_act: ActivationType,
    pub attention_bias: bool,
    pub mlp_bias: bool,
    pub tie_word_embeddings: bool,
    pub num_experts: usize,
    pub num_experts_per_token: usize,
    pub expert_intermediate_size: usize,
    pub key_length: usize,
    pub value_length: usize,
    pub ssm_d_inner: usize,
    pub ssm_d_state: usize,
    pub ssm_n_group: usize,
    pub ssm_dt_rank: usize,
    pub ssm_conv_kernel: usize,
    pub attn_logit_softcap: f32,
    pub final_logit_softcap: f32,
    pub sliding_window: usize,
    pub has_combined_qkv: bool,
    pub uses_layer_norm: bool,
    pub uses_gelu: bool,
    pub has_ffn_gate: bool,
    pub attention_layer_configs: Option<Vec<AttentionLayerConfig>>,
    pub kv_source_layer: Option<Vec<usize>>,
}

Full model configuration

Fields

vocab_size: usize

Vocabulary size

hidden_size: usize

Hidden dimension (embedding size)

intermediate_size: usize

Intermediate size (FFN dimension, typically 4 * hidden_size or computed)

num_layers: usize

Number of transformer layers

num_heads: usize

Number of attention heads

num_kv_heads: usize

Number of key-value heads (for GQA/MQA)

head_dim: usize

Dimension per head

max_seq_len: usize

Maximum sequence length

norm_eps: f32

RMS normalization epsilon

rope_config: RopeConfig

RoPE configuration

use_parallel_residual: bool

Whether to use parallel attention (compute QKV in parallel)

hidden_act: ActivationType

Activation function type

attention_bias: bool

Whether there’s a bias in attention projections

mlp_bias: bool

Whether there’s a bias in MLP layers

tie_word_embeddings: bool

Tie word embeddings with output projection

num_experts: usize

Number of MoE experts (0 = dense model)

num_experts_per_token: usize

Number of experts activated per token

expert_intermediate_size: usize

Expert FFN intermediate dimension (may differ from dense intermediate_size)

key_length: usize

Per-head key dimension (defaults to head_dim if not specified)

value_length: usize

Per-head value dimension (defaults to head_dim if not specified)

ssm_d_inner: usize

SSM/DeltaNet inner dimension (0 = no SSM layers)

ssm_d_state: usize

SSM state dimension (per-head key dim for delta-net)

ssm_n_group: usize

SSM group count (number of key heads in delta-net)

ssm_dt_rank: usize

SSM time step rank (number of value heads in delta-net)

ssm_conv_kernel: usize

SSM convolution kernel size

attn_logit_softcap: f32

Attention logit soft-capping value (Gemma2: 50.0, 0.0 = disabled)

final_logit_softcap: f32

Final logit soft-capping value (Gemma2: 30.0, 0.0 = disabled)

sliding_window: usize

Sliding window attention size (0 = disabled)

has_combined_qkv: bool

Whether this architecture uses combined QKV tensor

uses_layer_norm: bool

Whether this architecture uses LayerNorm instead of RMSNorm

uses_gelu: bool

Whether this architecture uses GELU activation

has_ffn_gate: bool

Whether this architecture has a gate projection in FFN

attention_layer_configs: Option<Vec<AttentionLayerConfig>>

Per-layer attention configs for architectures with heterogeneous attention (e.g., Gemma 4). None means all layers use uniform config.

kv_source_layer: Option<Vec<usize>>

Maps layer index to physical KV cache slot. Identity by default. For KV shared layers, multiple indices map to the same slot.

Implementations

impl ModelConfig

pub fn has_ssm(&self) -> bool

Whether this model has SSM/delta-net recurrent layers

pub fn is_moe(&self) -> bool

Check if this is an MoE model

pub fn llama_7b() -> Self

Create config for LLaMA 7B

pub fn llama2_7b() -> Self

Create config for LLaMA 2 7B

pub fn llama3_8b() -> Self

Create config for LLaMA 3 8B

pub fn uses_gqa(&self) -> bool

Check if this model uses Grouped Query Attention

pub fn num_queries_per_kv(&self) -> usize

Get the number of query heads per KV head

pub fn build_attention_layer_configs( num_layers: usize, pattern_period: usize, sliding_head_dim: usize, sliding_kv_heads: usize, sliding_rope_freq_base: f32, sliding_window: usize, global_head_dim: usize, global_kv_heads: usize, global_rope_freq_base: f32, global_rope_dims: usize, ) -> Vec<AttentionLayerConfig>

Build attention layer configs for a sliding/global pattern.

pattern_period layers form one cycle, where the last layer is Global and the rest are Sliding. E.g., period=6 gives 5 sliding + 1 global.

pub fn build_attention_layer_configs_from_pattern( is_swa: &[bool], sliding_head_dim: usize, sliding_kv_heads: usize, sliding_rope_freq_base: f32, sliding_rope_dims: usize, sliding_window: usize, global_head_dim: usize, global_kv_heads: usize, global_rope_freq_base: f32, global_rope_dims: usize, ) -> Vec<AttentionLayerConfig>

Build attention layer configs from a per-layer boolean SWA pattern.

is_swa[i] is true if layer i uses sliding-window attention, false for global attention. This matches the sliding_window_pattern array stored in Gemma 4 GGUF files.

pub fn build_kv_source_mapping( num_layers: usize, shared_layers: usize, layer_configs: &[AttentionLayerConfig], ) -> Vec<usize>

Build KV source layer mapping for shared KV cache.

The last shared_layers layers reuse cached K/V from earlier layers instead of projecting their own. The mapping is TYPE-SPECIFIC: shared SWA layers map to the last KV-owning SWA layer, shared global layers map to the last KV-owning global layer.

Requires layer_configs to determine each layer’s type.

Trait Implementations

impl Clone for ModelConfig

fn clone(&self) -> ModelConfig

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for ModelConfig

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

Formats the value using the given formatter.

impl Default for ModelConfig

fn default() -> Self

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for ModelConfig

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Serialize for ModelConfig

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.