You can deploy this model and start earning money today!

yujiepan/
kimi-k3-bf16-tiny-random

Name: kimi-k3-bf16-tiny-random
Availability: InStock

Views

No views yet

This tiny model is intended for debugging. It is randomly initialized using the configuration adapted from moonshotai/Kimi-K3.

Note:

This is the BF16 (no quantization) sibling of kimi-k3-tiny-random. Routed expert w1/w2/w3 stay plain BF16 weights; there is no MXFP4 packing and no quantization_config.
Structural comparison with the original moonshotai/Kimi-K3:

Structural feature	Original K3	This tiny model
Attention cycle	3 KDA + 1 MLA per group	Same
Ending	Final layer is MLA	Same
KDA : MLA ratio	69:24 (~3:1)	12:5 (~3:1)
Total layers	93	17 (4 groups + final MLA)
FFN layout	Layer 0 Dense MLP, others MoE	Same
MoE routing	top-16, 2 shared experts, group=1	Same
Routed experts	896	64
AttnRes checkpoint	Every 12 layers (3 groups)	Every 8 layers (2 groups), proportionally scaled
KDA kernel params	num_heads=96, head_dim=128, conv=4, gate_lower_bound=-5	heads 96 -> 8; per-head dims same
MLA kernel params	96 heads, q/kv LoRA ranks 1536/512, nope/rope/v head dims	heads 96 -> 8, q rank 1536 -> 256, kv rank stays 512; kernel dims same
MoE quantization	Only routed expert w1/w2/w3 MXFP4	None (full BF16)
Expert linear dims	moe_intermediate=3072, routed_hidden=3584	moe_intermediate=32, routed_hidden=32
Vision head_dim	32	Same
MTP	None	None

What is shrunk: layer count (93 -> 17), residual width (hidden_size=8), attention heads (96 -> 8) and MLA q LoRA rank (1536 -> 256). The kv_lora_rank stays 512 because vLLM's Kimi fused MLA decode kernel requires cache/query head size 512 + 64 = 576. Expert FFN widths are further reduced vs the MXFP4 tiny variant (256 -> 32) so the unquantized BF16 checkpoint stays <= ~150MB.
The creation of this model was assisted by Cursor Grok 4.5.

File path	Size
model.safetensors	31.9MB

Example usage:

python

import numpy as np
import torch
from PIL import Image
from transformers import AutoModel, AutoProcessor

model_id = "yujiepan/kimi-k3-bf16-tiny-random"
processor = AutoProcessor.from_pretrained(model_id, trust_remote_code=True)
model = AutoModel.from_pretrained(
    model_id,
    dtype=torch.bfloat16,
    device_map='cuda',
    trust_remote_code=True,
    attn_implementation='eager',
).eval()
image = Image.fromarray(np.random.default_rng(42).integers(0, 256, (56, 56, 3), dtype=np.uint8))
tools = [{
    'type': 'function',
    'function': {
        'name': 'get_image_size',
        'description': 'Return the width and height of an image.',
        'parameters': {
            'type': 'object',
            'properties': {
                'image_index': {'type': 'integer', 'description': 'Zero-based image index.'},
            },
            'required': ['image_index'],
        },
    },
}]
messages = [{
    'role': 'user',
    'content': [
        {'type': 'image', 'image': image},
        {'type': 'text', 'text': 'Use the available tool to get this image size.'},
    ],
}]
inputs = processor(
    messages=messages,
    tools=tools,
    tool_choice='required',
    return_tensors='pt',
).to(model.device)
with torch.no_grad():
    outputs = model.generate(**inputs, max_new_tokens=32)
generated_ids = outputs.sequences if hasattr(outputs, 'sequences') else outputs
print(processor.decode(generated_ids[0].detach().cpu().tolist()))

Codes to create this repo:

Click to expand

python

import json
from pathlib import Path

import accelerate
import torch
from huggingface_hub import file_exists, hf_hub_download, list_repo_files
from safetensors.torch import load_file, save_file
from transformers import AutoConfig, AutoModel, GenerationConfig, set_seed

source_model_id = "moonshotai/Kimi-K3"
save_folder = "/tmp/yujiepan/kimi-k3-bf16-tiny-random"  # pyright: ignore[reportUnusedExpression]  # codegen marker

Path(save_folder).mkdir(parents=True, exist_ok=True)
suffixes = ['.json', '.py', '.model', '.jinja']
for filename in list_repo_files(
    source_model_id,
    repo_type='model',
    revision=source_revision,
):
    if any(filename.endswith(suffix) for suffix in suffixes) and not filename.endswith('.index.json'):
        hf_hub_download(
            repo_id=source_model_id,
            filename=filename,
            repo_type='model',
            revision=source_revision,
            local_dir=save_folder,
        )

def replace_file(filepath, replacements):
    with open(filepath, 'r', encoding='utf-8') as f:
        code = f.read()
    for old_string, new_string in replacements:
        if old_string not in code:
            if new_string in code:
                continue
            raise ValueError(f'Expected code was not found in {filepath}: {old_string}')
        code = code.replace(old_string, new_string)
    with open(filepath, 'w', encoding='utf-8') as f:
        f.write(code)

# The upstream reference implementation forces FlashAttention for MLA even
# when eager attention is requested. Allow the tiny MLA layer to use eager
# attention without requiring the separate flash-attn package.
force_flash_code = '''        if getattr(config, "_attn_implementation", None) is not None:
        if config._attn_implementation != "flash_attention_2":
            logger.warning_once(
                f"Ignoring the provided attention implementation {config._attn_implementation}")
            logger.warning_once("Using flash_attention_2 backend instead.")
            config._attn_implementation = "flash_attention_2"
    else:
        config._attn_implementation = "flash_attention_2"'''
per_channel_gate_code = '''        g = self.f_b_proj(self.f_a_proj(hidden_states))
    g = rearrange(g, '... (h d) -> ... h d', d=self.head_dim)
    beta = self.b_proj(hidden_states).float()'''
per_channel_gate_compat_code = '''        g = self.f_b_proj(self.f_a_proj(hidden_states))
    g = rearrange(g, '... (h d) -> ... h d', d=self.head_dim)
    # The released K3 checkpoint stores per-channel decay shared by all heads.
    g = self.gate_lower_bound * torch.sigmoid(
        self.A_log.float().exp().view(1, 1, 1, self.head_dim)
        * (g.float() + self.dt_bias.float().view(1, 1, self.num_heads, self.head_dim))
    ).to(g.dtype)
    beta = self.b_proj(hidden_states).float()'''
causal_mask_code = '''        causal_mask = create_causal_mask(
        config=self.config,
        input_embeds=inputs_embeds,
        attention_mask=attention_mask,
        cache_position=cache_position,
        past_key_values=past_key_values,
        position_ids=position_ids,
    )'''
causal_mask_compat_code = '''        if version.parse(transformers.__version__) >= version.parse("5.0.0"):
        causal_mask = create_causal_mask(
            config=self.config,
            inputs_embeds=inputs_embeds,
            attention_mask=attention_mask,
            past_key_values=past_key_values,
            position_ids=position_ids,
        )
    else:
        causal_mask = create_causal_mask(
            config=self.config,
            input_embeds=inputs_embeds,
            attention_mask=attention_mask,
            cache_position=cache_position,
            past_key_values=past_key_values,
            position_ids=position_ids,
        )'''
cache_api_code = '''    def get_mask_sizes(self, cache_position: torch.Tensor, layer_idx: int) -> tuple[int, int]:
    """
    Return a tuple (kv_length, kv_offset) corresponding to the length and offset that will be returned for
    the given layer at `layer_idx`.
    The masks are then prepared according to the given lengths (kv_length, kv_offset) and patterns for each layer.
    """
    kv_offset = 0
    query_length = cache_position.shape[0]'''
cache_api_compat_code = '''    def get_query_offset(self, layer_idx: int) -> int:
    return self.get_seq_length(layer_idx)

def get_mask_sizes(self, cache_position: torch.Tensor | int, layer_idx: int) -> tuple[int, int]:
    """
    Return a tuple (kv_length, kv_offset) corresponding to the length and offset that will be returned for
    the given layer at `layer_idx`.
    The masks are then prepared according to the given lengths (kv_length, kv_offset) and patterns for each layer.
    """
    kv_offset = 0
    query_length = cache_position if isinstance(cache_position, int) else cache_position.shape[0]'''

replace_file(f'{save_folder}/modeling_kimi_linear.py', [
    # Transformers 5 compatibility.
    (
        'from transformers.modeling_utils import ALL_ATTENTION_FUNCTIONS, PreTrainedModel',
        'from transformers.modeling_utils import ALL_ATTENTION_FUNCTIONS, OutputRecorder, PreTrainedModel',
    ),
    (
        'from transformers.utils.generic import OutputRecorder, check_model_inputs',
        'from transformers.utils.generic import check_model_inputs',
    ),
    (
        '    _tied_weights_keys = ["lm_head.weight"]',
        '''    _tied_weights_keys = (
    {"lm_head.weight": "model.embed_tokens.weight"}
    if version.parse(transformers.__version__) >= version.parse("5.0.0")
    else ["lm_head.weight"]
)''',
    ),
    (causal_mask_code, causal_mask_compat_code),
    (cache_api_code, cache_api_compat_code),
    # Allow eager MLA instead of forcing the optional flash-attn package.
    (
        force_flash_code,
        '        config._attn_implementation = getattr(config, "_attn_implementation", "eager")',
    ),
    # Fix stale K3 reference code: released shards store A_log as
    # [head_dim], and the decay is applied per channel across all heads.
    (
        '            self.num_heads, dtype=torch.float32).uniform_(1, 16)))',
        '            self.head_dim, dtype=torch.float32).uniform_(1, 16)))',
    ),
    (per_channel_gate_code, per_channel_gate_compat_code),
    (
        '''                use_qk_l2norm_in_kernel=True,
            use_gate_in_kernel=True,
            use_beta_sigmoid_in_kernel=True,''',
        '''                use_qk_l2norm_in_kernel=True,
            use_gate_in_kernel=False,
            use_beta_sigmoid_in_kernel=True,''',
    ),
    (
        '                safe_gate=self.gate_lower_bound is not None,',
        '                safe_gate=False,',
    ),
])
replace_file(f'{save_folder}/modeling_kimi_k3.py', [
    ('    def tie_weights(self):', '    def tie_weights(self, *args, **kwargs):'),
    ("    _supports_sdpa = True", "    _supports_sdpa = False"),
    (
        '                first_layer_past_key_value = past_key_values[0][0][:, :, :, 0]',
        '''                if hasattr(past_key_values, "key_cache"):
                first_key_cache = next(
                    key_cache for key_cache in past_key_values.key_cache if key_cache is not None
                )
                first_layer_past_key_value = first_key_cache[:, :, :, 0]
            else:
                first_layer_past_key_value = past_key_values[0][0][:, :, :, 0]''',
    ),
])

with open(f'{save_folder}/config.json', encoding='utf-8') as f:
    config_json = json.load(f)

# Pure BF16: drop all quantization metadata (no MXFP4 / no quant_method).
config_json['text_config'].pop('quantization_config', None)
config_json.pop('quantization_config', None)

# Preserve the kernel-sensitive dims from upstream: KDA head_dim=128,
# MLA kv_lora_rank=512, qk_nope=128, qk_rope=64, v=128, conv kernel=4.
# vLLM's Kimi fused MLA decode kernel requires latent KV rank 512 and
# cache/query head size 512 + 64 = 576, so only shrink head count and
# q_lora_rank; q_b_proj still drops 54MB->0.75MB.
# Keep the upstream cadence: four 4-layer groups plus the final MLA layer.
# One attention-residual checkpoint every two groups (block_size=8), so
# block boundaries land on layers 0, 8, 16 (0-based).
# Without MXFP4, expert linear dims no longer need group_size=32 / TP
# padding floors; shrink moe_intermediate_size and routed_expert_hidden_size
# so BF16 experts stay small (target total checkpoint <= ~150MB).
config_json['text_config'].update({
    'attn_res_block_size': 8,
    'first_k_dense_replace': 1,
    'hidden_size': 8,
    'intermediate_size': 32,
    'kv_lora_rank': 512,
    'moe_intermediate_size': 32,
    'num_attention_heads': 8,
    'num_experts': 64,
    'num_hidden_layers': 17,
    'num_key_value_heads': 8,
    'q_lora_rank': 256,
    'routed_expert_hidden_size': 32,
    '_attn_implementation': 'eager',
})
config_json['text_config']['linear_attn_config'].update({
    'full_attn_layers': [4, 8, 12, 16, 17],
    'kda_layers': [1, 2, 3, 5, 6, 7, 9, 10, 11, 13, 14, 15],
    'num_heads': 8,
})
config_json['vision_config'].update({
    '_attn_implementation': 'eager',
    'init_pos_emb_height': 8,
    'init_pos_emb_width': 8,
    'mm_hidden_size': 64,
    'qkv_hidden_size': 64,
    'text_hidden_size': 8,
    'vt_hidden_size': 64,
    'vt_intermediate_size': 128,
    # Vision attention head size = qkv_hidden_size / heads = 64 / 2 = 32.
    'vt_num_attention_heads': 2,
    'vt_num_hidden_layers': 2,
})
with open(f'{save_folder}/config.json', 'w', encoding='utf-8') as f:
    json.dump(config_json, f, indent=2)

config = AutoConfig.from_pretrained(save_folder, trust_remote_code=True)
print(config)
torch.set_default_dtype(torch.bfloat16)
model = AutoModel.from_config(
    config,
    trust_remote_code=True,
    attn_implementation='eager',
)
torch.set_default_dtype(torch.float32)
if file_exists(
    filename='generation_config.json',
    repo_id=source_model_id,
    repo_type='model',
    revision=source_revision,
):
    model.generation_config = GenerationConfig.from_pretrained(
        source_model_id,
        trust_remote_code=True,
        revision=source_revision,
    )
set_seed(42)
model = model.cpu()
num_params = sum(p.numel() for p in model.parameters())
with torch.no_grad():
    for name, parameter in sorted(model.named_parameters()):
        torch.nn.init.normal_(parameter, 0, 0.1)
        print(name, parameter.shape, parameter.dtype, f'{parameter.numel() / num_params:.2%}')
model.save_pretrained(save_folder)

# Match the official checkpoint schema for non-quantized tensors: keep
# KDA / MoE gate bias buffers in float32.
model_path = Path(save_folder) / 'model.safetensors'
state_dict = load_file(str(model_path))
for name in list(state_dict):
    if name.endswith((
        '.block_sparse_moe.gate.e_score_correction_bias',
        '.self_attn.A_log',
        '.self_attn.dt_bias',
        '.self_attn.k_conv1d.weight',
        '.self_attn.o_norm.weight',
        '.self_attn.q_conv1d.weight',
        '.self_attn.v_conv1d.weight',
    )):
        state_dict[name] = state_dict[name].float()
dtype_counts = {
    dtype: sum(tensor.dtype == dtype for tensor in state_dict.values())
    for dtype in (torch.bfloat16, torch.float32, torch.uint8)
}
text_cfg = config_json['text_config']
num_moe_layers = text_cfg['num_hidden_layers'] - text_cfg['first_k_dense_replace']
num_kda_layers = len(text_cfg['linear_attn_config']['kda_layers'])
expected_f32 = num_moe_layers + num_kda_layers * 6
assert dtype_counts == {
    torch.bfloat16: len(state_dict) - expected_f32,
    torch.float32: expected_f32,
    torch.uint8: 0,
}, dtype_counts
assert not any('mtp' in name.lower() for name in state_dict)
total_bytes = sum(t.numel() * t.element_size() for t in state_dict.values())
print(f'Total checkpoint size: {total_bytes / 1024**2:.2f} MB')
assert total_bytes / 1024**2 <= 150, total_bytes / 1024**2
print('Top 20 keys with largest storage size:')
for name, tensor in sorted(state_dict.items(), key=lambda x: x[1].numel() * x[1].element_size(), reverse=True)[:20]:
    print(f'{name}: {tensor.numel()} elements, {tensor.numel() * tensor.element_size() / 1024**2:.2f} MB')
save_file(state_dict, str(model_path), metadata={'format': 'pt'})

Printing the model:

Click to expand

text

KimiK3ForConditionalGeneration(
  (vision_tower): MoonViT3dPretrainedModel(
    (patch_embed): MoonVision3dPatchEmbed(
      (proj): Conv2d(3, 64, kernel_size=(14, 14), stride=(14, 14), bias=False)
      (pos_emb): Learnable2DInterpPosEmbDivided_fixed()
    )
    (encoder): MoonViT3dEncoder(
      (rope_2d): Rope2DPosEmbRepeated(dim=32, max_height=512, max_width=512, theta_base=10000)
      (blocks): ModuleList(
        (0-1): 2 x MoonViTEncoderLayer(
          (norm0): RMSNorm((64,), eps=None, elementwise_affine=True)
          (norm1): RMSNorm((64,), eps=None, elementwise_affine=True)
          (mlp): MLP2(
            (fc0): Linear(in_features=64, out_features=128, bias=False)
            (fc1): Linear(in_features=128, out_features=64, bias=False)
            (activation): GELUTanh()
          )
          (wqkv): Linear(in_features=64, out_features=192, bias=False)
          (wo): Linear(in_features=64, out_features=64, bias=False)
        )
      )
      (final_layernorm): RMSNorm((64,), eps=None, elementwise_affine=True)
    )
  )
  (mm_projector): PatchMergerMLPV2(
    (proj): Sequential(
      (0): Linear(in_features=256, out_features=256, bias=False)
      (1): GELU(approximate='none')
      (2): Linear(in_features=256, out_features=8, bias=False)
    )
    (post_norm): RMSNorm((8,), eps=1e-05, elementwise_affine=True)
  )
  (language_model): KimiLinearForCausalLM(
    (model): KimiLinearModel(
      (embed_tokens): Embedding(163840, 8, padding_idx=163839)
      (layers): ModuleList(
        (0): KimiDecoderLayer(
          (self_attn): KimiDeltaAttention(
            (q_proj): Linear(in_features=8, out_features=1024, bias=False)
            (k_proj): Linear(in_features=8, out_features=1024, bias=False)
            (v_proj): Linear(in_features=8, out_features=1024, bias=False)
            (q_conv1d): ShortConvolution(1024, 1024, kernel_size=(4,), stride=(1,), padding=(3,), groups=1024, bias=False, activation=silu, backend=triton)
            (k_conv1d): ShortConvolution(1024, 1024, kernel_size=(4,), stride=(1,), padding=(3,), groups=1024, bias=False, activation=silu, backend=triton)
            (v_conv1d): ShortConvolution(1024, 1024, kernel_size=(4,), stride=(1,), padding=(3,), groups=1024, bias=False, activation=silu, backend=triton)
            (f_a_proj): Linear(in_features=8, out_features=128, bias=False)
            (f_b_proj): Linear(in_features=128, out_features=1024, bias=False)
            (b_proj): Linear(in_features=8, out_features=8, bias=False)
            (g_proj): Linear(in_features=8, out_features=1024, bias=False)
            (o_norm): FusedRMSNormGated(128, eps=1e-05, activation=sigmoid)
            (o_proj): Linear(in_features=1024, out_features=8, bias=False)
          )
          (mlp): KimiMLP(
            (gate_proj): Linear(in_features=8, out_features=32, bias=False)
            (up_proj): Linear(in_features=8, out_features=32, bias=False)
            (down_proj): Linear(in_features=32, out_features=8, bias=False)
            (act_fn): SituAndMul()
          )
          (input_layernorm): KimiRMSNorm()
          (post_attention_layernorm): KimiRMSNorm()
          (self_attention_res_norm): KimiRMSNorm()
          (mlp_res_norm): KimiRMSNorm()
          (self_attention_res_proj): Linear(in_features=8, out_features=1, bias=False)
          (mlp_res_proj): Linear(in_features=8, out_features=1, bias=False)
        )
        (1-2): 2 x KimiDecoderLayer(
          (self_attn): KimiDeltaAttention(
            (q_proj): Linear(in_features=8, out_features=1024, bias=False)
            (k_proj): Linear(in_features=8, out_features=1024, bias=False)
            (v_proj): Linear(in_features=8, out_features=1024, bias=False)
            (q_conv1d): ShortConvolution(1024, 1024, kernel_size=(4,), stride=(1,), padding=(3,), groups=1024, bias=False, activation=silu, backend=triton)
            (k_conv1d): ShortConvolution(1024, 1024, kernel_size=(4,), stride=(1,), padding=(3,), groups=1024, bias=False, activation=silu, backend=triton)
            (v_conv1d): ShortConvolution(1024, 1024, kernel_size=(4,), stride=(1,), padding=(3,), groups=1024, bias=False, activation=silu, backend=triton)
            (f_a_proj): Linear(in_features=8, out_features=128, bias=False)
            (f_b_proj): Linear(in_features=128, out_features=1024, bias=False)
            (b_proj): Linear(in_features=8, out_features=8, bias=False)
            (g_proj): Linear(in_features=8, out_features=1024, bias=False)
            (o_norm): FusedRMSNormGated(128, eps=1e-05, activation=sigmoid)
            (o_proj): Linear(in_features=1024, out_features=8, bias=False)
          )
          (block_sparse_moe): KimiSparseMoeBlock(
            (experts): ModuleList(
              (0-63): 64 x KimiBlockSparseMLP(
                (w1): Linear(in_features=32, out_features=32, bias=False)
                (w2): Linear(in_features=32, out_features=32, bias=False)
                (w3): Linear(in_features=32, out_features=32, bias=False)
                (act_fn): SituAndMul()
              )
            )
            (gate): KimiMoEGate()
            (shared_experts): KimiMLP(
              (gate_proj): Linear(in_features=8, out_features=64, bias=False)
              (up_proj): Linear(in_features=8, out_features=64, bias=False)
              (down_proj): Linear(in_features=64, out_features=8, bias=False)
              (act_fn): SituAndMul()
            )
            (routed_expert_down_proj): Linear(in_features=8, out_features=32, bias=False)
            (routed_expert_up_proj): Linear(in_features=32, out_features=8, bias=False)
            (routed_expert_norm): KimiRMSNorm()
          )
          (input_layernorm): KimiRMSNorm()
          (post_attention_layernorm): KimiRMSNorm()
          (self_attention_res_norm): KimiRMSNorm()
          (mlp_res_norm): KimiRMSNorm()
          (self_attention_res_proj): Linear(in_features=8, out_features=1, bias=False)
          (mlp_res_proj): Linear(in_features=8, out_features=1, bias=False)
        )
        (3): KimiDecoderLayer(
          (self_attn): KimiMLAAttention(
            (q_a_proj): Linear(in_features=8, out_features=256, bias=False)
            (q_a_layernorm): KimiRMSNorm()
            (q_b_proj): Linear(in_features=256, out_features=1536, bias=False)
            (kv_a_proj_with_mqa): Linear(in_features=8, out_features=576, bias=False)
            (kv_a_layernorm): KimiRMSNorm()
            (kv_b_proj): Linear(in_features=512, out_features=2048, bias=False)
            (o_proj): Linear(in_features=1024, out_features=8, bias=False)
            (g_proj): Linear(in_features=8, out_features=1024, bias=False)
          )
          (block_sparse_moe): KimiSparseMoeBlock(
            (experts): ModuleList(
              (0-63): 64 x KimiBlockSparseMLP(
                (w1): Linear(in_features=32, out_features=32, bias=False)
                (w2): Linear(in_features=32, out_features=32, bias=False)
                (w3): Linear(in_features=32, out_features=32, bias=False)
                (act_fn): SituAndMul()
              )
            )
            (gate): KimiMoEGate()
            (shared_experts): KimiMLP(
              (gate_proj): Linear(in_features=8, out_features=64, bias=False)
              (up_proj): Linear(in_features=8, out_features=64, bias=False)
              (down_proj): Linear(in_features=64, out_features=8, bias=False)
              (act_fn): SituAndMul()
            )
            (routed_expert_down_proj): Linear(in_features=8, out_features=32, bias=False)
            (routed_expert_up_proj): Linear(in_features=32, out_features=8, bias=False)
            (routed_expert_norm): KimiRMSNorm()
          )
          (input_layernorm): KimiRMSNorm()
          (post_attention_layernorm): KimiRMSNorm()
          (self_attention_res_norm): KimiRMSNorm()
          (mlp_res_norm): KimiRMSNorm()
          (self_attention_res_proj): Linear(in_features=8, out_features=1, bias=False)
          (mlp_res_proj): Linear(in_features=8, out_features=1, bias=False)
        )
        (4-6): 3 x KimiDecoderLayer(
          (self_attn): KimiDeltaAttention(
            (q_proj): Linear(in_features=8, out_features=1024, bias=False)
            (k_proj): Linear(in_features=8, out_features=1024, bias=False)
            (v_proj): Linear(in_features=8, out_features=1024, bias=False)
            (q_conv1d): ShortConvolution(1024, 1024, kernel_size=(4,), stride=(1,), padding=(3,), groups=1024, bias=False, activation=silu, backend=triton)
            (k_conv1d): ShortConvolution(1024, 1024, kernel_size=(4,), stride=(1,), padding=(3,), groups=1024, bias=False, activation=silu, backend=triton)
            (v_conv1d): ShortConvolution(1024, 1024, kernel_size=(4,), stride=(1,), padding=(3,), groups=1024, bias=False, activation=silu, backend=triton)
            (f_a_proj): Linear(in_features=8, out_features=128, bias=False)
            (f_b_proj): Linear(in_features=128, out_features=1024, bias=False)
            (b_proj): Linear(in_features=8, out_features=8, bias=False)
            (g_proj): Linear(in_features=8, out_features=1024, bias=False)
            (o_norm): FusedRMSNormGated(128, eps=1e-05, activation=sigmoid)
            (o_proj): Linear(in_features=1024, out_features=8, bias=False)
          )
          (block_sparse_moe): KimiSparseMoeBlock(
            (experts): ModuleList(
              (0-63): 64 x KimiBlockSparseMLP(
                (w1): Linear(in_features=32, out_features=32, bias=False)
                (w2): Linear(in_features=32, out_features=32, bias=False)
                (w3): Linear(in_features=32, out_features=32, bias=False)
                (act_fn): SituAndMul()
              )
            )
            (gate): KimiMoEGate()
            (shared_experts): KimiMLP(
              (gate_proj): Linear(in_features=8, out_features=64, bias=False)
              (up_proj): Linear(in_features=8, out_features=64, bias=False)
              (down_proj): Linear(in_features=64, out_features=8, bias=False)
              (act_fn): SituAndMul()
            )
            (routed_expert_down_proj): Linear(in_features=8, out_features=32, bias=False)
            (routed_expert_up_proj): Linear(in_features=32, out_features=8, bias=False)
            (routed_expert_norm): KimiRMSNorm()
          )
          (input_layernorm): KimiRMSNorm()
          (post_attention_layernorm): KimiRMSNorm()
          (self_attention_res_norm): KimiRMSNorm()
          (mlp_res_norm): KimiRMSNorm()
          (self_attention_res_proj): Linear(in_features=8, out_features=1, bias=False)
          (mlp_res_proj): Linear(in_features=8, out_features=1, bias=False)
        )
        (7): KimiDecoderLayer(
          (self_attn): KimiMLAAttention(
            (q_a_proj): Linear(in_features=8, out_features=256, bias=False)
            (q_a_layernorm): KimiRMSNorm()
            (q_b_proj): Linear(in_features=256, out_features=1536, bias=False)
            (kv_a_proj_with_mqa): Linear(in_features=8, out_features=576, bias=False)
            (kv_a_layernorm): KimiRMSNorm()
            (kv_b_proj): Linear(in_features=512, out_features=2048, bias=False)
            (o_proj): Linear(in_features=1024, out_features=8, bias=False)
            (g_proj): Linear(in_features=8, out_features=1024, bias=False)
          )
          (block_sparse_moe): KimiSparseMoeBlock(
            (experts): ModuleList(
              (0-63): 64 x KimiBlockSparseMLP(
                (w1): Linear(in_features=32, out_features=32, bias=False)
                (w2): Linear(in_features=32, out_features=32, bias=False)
                (w3): Linear(in_features=32, out_features=32, bias=False)
                (act_fn): SituAndMul()
              )
            )
            (gate): KimiMoEGate()
            (shared_experts): KimiMLP(
              (gate_proj): Linear(in_features=8, out_features=64, bias=False)
              (up_proj): Linear(in_features=8, out_features=64, bias=False)
              (down_proj): Linear(in_features=64, out_features=8, bias=False)
              (act_fn): SituAndMul()
            )
            (routed_expert_down_proj): Linear(in_features=8, out_features=32, bias=False)
            (routed_expert_up_proj): Linear(in_features=32, out_features=8, bias=False)
            (routed_expert_norm): KimiRMSNorm()
          )
          (input_layernorm): KimiRMSNorm()
          (post_attention_layernorm): KimiRMSNorm()
          (self_attention_res_norm): KimiRMSNorm()
          (mlp_res_norm): KimiRMSNorm()
          (self_attention_res_proj): Linear(in_features=8, out_features=1, bias=False)
          (mlp_res_proj): Linear(in_features=8, out_features=1, bias=False)
        )
        (8-10): 3 x KimiDecoderLayer(
          (self_attn): KimiDeltaAttention(
            (q_proj): Linear(in_features=8, out_features=1024, bias=False)
            (k_proj): Linear(in_features=8, out_features=1024, bias=False)
            (v_proj): Linear(in_features=8, out_features=1024, bias=False)
            (q_conv1d): ShortConvolution(1024, 1024, kernel_size=(4,), stride=(1,), padding=(3,), groups=1024, bias=False, activation=silu, backend=triton)
            (k_conv1d): ShortConvolution(1024, 1024, kernel_size=(4,), stride=(1,), padding=(3,), groups=1024, bias=False, activation=silu, backend=triton)
            (v_conv1d): ShortConvolution(1024, 1024, kernel_size=(4,), stride=(1,), padding=(3,), groups=1024, bias=False, activation=silu, backend=triton)
            (f_a_proj): Linear(in_features=8, out_features=128, bias=False)
            (f_b_proj): Linear(in_features=128, out_features=1024, bias=False)
            (b_proj): Linear(in_features=8, out_features=8, bias=False)
            (g_proj): Linear(in_features=8, out_features=1024, bias=False)
            (o_norm): FusedRMSNormGated(128, eps=1e-05, activation=sigmoid)
            (o_proj): Linear(in_features=1024, out_features=8, bias=False)
          )
          (block_sparse_moe): KimiSparseMoeBlock(
            (experts): ModuleList(
              (0-63): 64 x KimiBlockSparseMLP(
                (w1): Linear(in_features=32, out_features=32, bias=False)
                (w2): Linear(in_features=32, out_features=32, bias=False)
                (w3): Linear(in_features=32, out_features=32, bias=False)
                (act_fn): SituAndMul()
              )
            )
            (gate): KimiMoEGate()
            (shared_experts): KimiMLP(
              (gate_proj): Linear(in_features=8, out_features=64, bias=False)
              (up_proj): Linear(in_features=8, out_features=64, bias=False)
              (down_proj): Linear(in_features=64, out_features=8, bias=False)
              (act_fn): SituAndMul()
            )
            (routed_expert_down_proj): Linear(in_features=8, out_features=32, bias=False)
            (routed_expert_up_proj): Linear(in_features=32, out_features=8, bias=False)
            (routed_expert_norm): KimiRMSNorm()
          )
          (input_layernorm): KimiRMSNorm()
          (post_attention_layernorm): KimiRMSNorm()
          (self_attention_res_norm): KimiRMSNorm()
          (mlp_res_norm): KimiRMSNorm()
          (self_attention_res_proj): Linear(in_features=8, out_features=1, bias=False)
          (mlp_res_proj): Linear(in_features=8, out_features=1, bias=False)
        )
        (11): KimiDecoderLayer(
          (self_attn): KimiMLAAttention(
            (q_a_proj): Linear(in_features=8, out_features=256, bias=False)
            (q_a_layernorm): KimiRMSNorm()
            (q_b_proj): Linear(in_features=256, out_features=1536, bias=False)
            (kv_a_proj_with_mqa): Linear(in_features=8, out_features=576, bias=False)
            (kv_a_layernorm): KimiRMSNorm()
            (kv_b_proj): Linear(in_features=512, out_features=2048, bias=False)
            (o_proj): Linear(in_features=1024, out_features=8, bias=False)
            (g_proj): Linear(in_features=8, out_features=1024, bias=False)
          )
          (block_sparse_moe): KimiSparseMoeBlock(
            (experts): ModuleList(
              (0-63): 64 x KimiBlockSparseMLP(
                (w1): Linear(in_features=32, out_features=32, bias=False)
                (w2): Linear(in_features=32, out_features=32, bias=False)
                (w3): Linear(in_features=32, out_features=32, bias=False)
                (act_fn): SituAndMul()
              )
            )
            (gate): KimiMoEGate()
            (shared_experts): KimiMLP(
              (gate_proj): Linear(in_features=8, out_features=64, bias=False)
              (up_proj): Linear(in_features=8, out_features=64, bias=False)
              (down_proj): Linear(in_features=64, out_features=8, bias=False)
              (act_fn): SituAndMul()
            )
            (routed_expert_down_proj): Linear(in_features=8, out_features=32, bias=False)
            (routed_expert_up_proj): Linear(in_features=32, out_features=8, bias=False)
            (routed_expert_norm): KimiRMSNorm()
          )
          (input_layernorm): KimiRMSNorm()
          (post_attention_layernorm): KimiRMSNorm()
          (self_attention_res_norm): KimiRMSNorm()
          (mlp_res_norm): KimiRMSNorm()
          (self_attention_res_proj): Linear(in_features=8, out_features=1, bias=False)
          (mlp_res_proj): Linear(in_features=8, out_features=1, bias=False)
        )
        (12-14): 3 x KimiDecoderLayer(
          (self_attn): KimiDeltaAttention(
            (q_proj): Linear(in_features=8, out_features=1024, bias=False)
            (k_proj): Linear(in_features=8, out_features=1024, bias=False)
            (v_proj): Linear(in_features=8, out_features=1024, bias=False)
            (q_conv1d): ShortConvolution(1024, 1024, kernel_size=(4,), stride=(1,), padding=(3,), groups=1024, bias=False, activation=silu, backend=triton)
            (k_conv1d): ShortConvolution(1024, 1024, kernel_size=(4,), stride=(1,), padding=(3,), groups=1024, bias=False, activation=silu, backend=triton)
            (v_conv1d): ShortConvolution(1024, 1024, kernel_size=(4,), stride=(1,), padding=(3,), groups=1024, bias=False, activation=silu, backend=triton)
            (f_a_proj): Linear(in_features=8, out_features=128, bias=False)
            (f_b_proj): Linear(in_features=128, out_features=1024, bias=False)
            (b_proj): Linear(in_features=8, out_features=8, bias=False)
            (g_proj): Linear(in_features=8, out_features=1024, bias=False)
            (o_norm): FusedRMSNormGated(128, eps=1e-05, activation=sigmoid)
            (o_proj): Linear(in_features=1024, out_features=8, bias=False)
          )
          (block_sparse_moe): KimiSparseMoeBlock(
            (experts): ModuleList(
              (0-63): 64 x KimiBlockSparseMLP(
                (w1): Linear(in_features=32, out_features=32, bias=False)
                (w2): Linear(in_features=32, out_features=32, bias=False)
                (w3): Linear(in_features=32, out_features=32, bias=False)
                (act_fn): SituAndMul()
              )
            )
            (gate): KimiMoEGate()
            (shared_experts): KimiMLP(
              (gate_proj): Linear(in_features=8, out_features=64, bias=False)
              (up_proj): Linear(in_features=8, out_features=64, bias=False)
              (down_proj): Linear(in_features=64, out_features=8, bias=False)
              (act_fn): SituAndMul()
            )
            (routed_expert_down_proj): Linear(in_features=8, out_features=32, bias=False)
            (routed_expert_up_proj): Linear(in_features=32, out_features=8, bias=False)
            (routed_expert_norm): KimiRMSNorm()
          )
          (input_layernorm): KimiRMSNorm()
          (post_attention_layernorm): KimiRMSNorm()
          (self_attention_res_norm): KimiRMSNorm()
          (mlp_res_norm): KimiRMSNorm()
          (self_attention_res_proj): Linear(in_features=8, out_features=1, bias=False)
          (mlp_res_proj): Linear(in_features=8, out_features=1, bias=False)
        )
        (15-16): 2 x KimiDecoderLayer(
          (self_attn): KimiMLAAttention(
            (q_a_proj): Linear(in_features=8, out_features=256, bias=False)
            (q_a_layernorm): KimiRMSNorm()
            (q_b_proj): Linear(in_features=256, out_features=1536, bias=False)
            (kv_a_proj_with_mqa): Linear(in_features=8, out_features=576, bias=False)
            (kv_a_layernorm): KimiRMSNorm()
            (kv_b_proj): Linear(in_features=512, out_features=2048, bias=False)
            (o_proj): Linear(in_features=1024, out_features=8, bias=False)
            (g_proj): Linear(in_features=8, out_features=1024, bias=False)
          )
          (block_sparse_moe): KimiSparseMoeBlock(
            (experts): ModuleList(
              (0-63): 64 x KimiBlockSparseMLP(
                (w1): Linear(in_features=32, out_features=32, bias=False)
                (w2): Linear(in_features=32, out_features=32, bias=False)
                (w3): Linear(in_features=32, out_features=32, bias=False)
                (act_fn): SituAndMul()
              )
            )
            (gate): KimiMoEGate()
            (shared_experts): KimiMLP(
              (gate_proj): Linear(in_features=8, out_features=64, bias=False)
              (up_proj): Linear(in_features=8, out_features=64, bias=False)
              (down_proj): Linear(in_features=64, out_features=8, bias=False)
              (act_fn): SituAndMul()
            )
            (routed_expert_down_proj): Linear(in_features=8, out_features=32, bias=False)
            (routed_expert_up_proj): Linear(in_features=32, out_features=8, bias=False)
            (routed_expert_norm): KimiRMSNorm()
          )
          (input_layernorm): KimiRMSNorm()
          (post_attention_layernorm): KimiRMSNorm()
          (self_attention_res_norm): KimiRMSNorm()
          (mlp_res_norm): KimiRMSNorm()
          (self_attention_res_proj): Linear(in_features=8, out_features=1, bias=False)
          (mlp_res_proj): Linear(in_features=8, out_features=1, bias=False)
        )
      )
      (norm): KimiRMSNorm()
      (output_attn_res_norm): KimiRMSNorm()
      (output_attn_res_proj): Linear(in_features=8, out_features=1, bias=False)
    )
    (lm_head): Linear(in_features=8, out_features=163840, bias=False)
  )
)

Test environment:

einops: 0.9.0.dev0
fla-core: 0.5.2
safetensors: 0.8.0
torch: 2.13.0+cu126
transformers: 5.15.0.dev0
triton: 3.7.1
vllm: 0.1.dev1+g5a3eba034.d20260730.cu126