Skip to content

WIP: DeepSeek-V4-Flash architecture port (BF16 reference, accuracy-first MVP) #14

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Draft
danielhanchen wants to merge 10 commits into
base: master
Choose a base branch
from
Draft

WIP: DeepSeek-V4-Flash architecture port (BF16 reference, accuracy-first MVP) #14

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
10 commits
Select commit Hold shift + click to select a range
ec06da2
deepseek-v4: register architecture enum, KV keys, and tensor schema
shimmyshimmer Apr 29, 2026
5e7536a
deepseek-v4: hparams loading, minimal tensor loader, stub graph
shimmyshimmer Apr 29, 2026
6d68f31
deepseek-v4: gguf-py constants, KVs, tensor names, writer helpers
shimmyshimmer Apr 29, 2026
d3860f8
deepseek-v4: converter (DeepseekV4Model) for FP8/FP4 → BF16 dequant
shimmyshimmer Apr 29, 2026
c9af2cc
deepseek-v4: chat template port (encoding_dsv4 chat-mode subset)
shimmyshimmer Apr 29, 2026
9de3ce0
deepseek-v4: full per-layer tensor declaration in load_tensors
shimmyshimmer Apr 29, 2026
c947016
deepseek-v4 converter: only buffer FP8-packed weights for dequant
shimmyshimmer Apr 29, 2026
6fbceb0
deepseek-v4 converter: emit F32 (writer downcasts) and tid2eid as I32
shimmyshimmer Apr 29, 2026
f2c6c9d
deepseek-v4 graph: SQRT_SOFTPLUS gating + LLM_FFN_SWIGLU_CLAMPED_PRE …
shimmyshimmer Apr 29, 2026
54a37d5
deepseek-v4 converter: F8_E8M0 dtype + I32 numpy + tid2eid materialize
shimmyshimmer Apr 29, 2026
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
479 changes: 479 additions & 0 deletions convert_hf_to_gguf.py
View file
Open in desktop

Large diffs are not rendered by default.

138 changes: 136 additions & 2 deletions gguf-py/gguf/constants.py
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -152,6 +152,11 @@ class LLM:
SWIGLU_CLAMP_SHEXP = "{arch}.swiglu_clamp_shexp"
DENSE_FEAT_IN_SIZE = "{arch}.{dense}_feat_in"
DENSE_FEAT_OUT_SIZE = "{arch}.{dense}_feat_out"
# DeepSeek-V4 mHC + hash routing
N_HASH_LAYERS = "{arch}.n_hash_layers"
HC_MULT = "{arch}.hyperconnections.mult"
HC_SINKHORN_ITERS = "{arch}.hyperconnections.sinkhorn_iters"
HC_EPS = "{arch}.hyperconnections.eps"

class Attention:
HEAD_COUNT = "{arch}.attention.head_count"
Expand Down Expand Up @@ -183,6 +188,11 @@ class Attention:
SHARED_KV_LAYERS = "{arch}.attention.shared_kv_layers"
SLIDING_WINDOW_PATTERN = "{arch}.attention.sliding_window_pattern"
TEMPERATURE_SCALE = "{arch}.attention.temperature_scale"
# DeepSeek-V4
O_LORA_RANK = "{arch}.attention.o_lora_rank"
O_GROUPS = "{arch}.attention.o_groups"
COMPRESS_RATIOS = "{arch}.attention.compress_ratios"
COMPRESS_ROPE_FREQ_BASE = "{arch}.attention.compress_rope_freq_base"

class Indexer:
HEAD_COUNT = "{arch}.attention.indexer.head_count"
Expand Down Expand Up @@ -442,6 +452,7 @@ class MODEL_ARCH(IntEnum):
DEEPSEEK = auto()
DEEPSEEK2 = auto()
DEEPSEEK2OCR = auto()
DEEPSEEK_V4 = auto()
CHATGLM = auto()
GLM4 = auto()
GLM4_MOE = auto()
Expand Down Expand Up @@ -844,6 +855,37 @@ class MODEL_TENSOR(IntEnum):
NEXTN_HNORM = auto()
NEXTN_SHARED_HEAD_HEAD = auto()
NEXTN_SHARED_HEAD_NORM = auto()
# DeepSeek-V4-Flash specific
ATTN_KV = auto() # single shared K=V projection (MQA)
ATTN_KV_NORM = auto() # RMSNorm on shared KV
ATTN_O_A = auto() # grouped low-rank wo_a [n_groups, o_lora_rank, ...]
ATTN_O_B = auto() # wo_b
COMPRESSOR_WKV = auto()
COMPRESSOR_WGATE = auto()
COMPRESSOR_APE = auto()
COMPRESSOR_NORM = auto()
INDEXER_COMPRESSOR_WKV = auto()
INDEXER_COMPRESSOR_WGATE = auto()
INDEXER_COMPRESSOR_APE = auto()
INDEXER_COMPRESSOR_NORM = auto()
HC_ATTN_FN = auto()
HC_ATTN_BASE = auto()
HC_ATTN_SCALE = auto()
HC_FFN_FN = auto()
HC_FFN_BASE = auto()
HC_FFN_SCALE = auto()
HC_HEAD_FN = auto()
HC_HEAD_BASE = auto()
HC_HEAD_SCALE = auto()
FFN_GATE_TID2EID = auto()
MTP_E_PROJ = auto()
MTP_H_PROJ = auto()
MTP_ENORM = auto()
MTP_HNORM = auto()
MTP_NORM = auto()
MTP_HC_HEAD_FN = auto()
MTP_HC_HEAD_BASE = auto()
MTP_HC_HEAD_SCALE = auto()
# lfm2 audio
A_ENC_NORM_CONV = auto()
A_ENC_LINEAR_POS = auto()
Expand Down Expand Up @@ -928,6 +970,7 @@ class MODEL_TENSOR(IntEnum):
MODEL_ARCH.DEEPSEEK: "deepseek",
MODEL_ARCH.DEEPSEEK2: "deepseek2",
MODEL_ARCH.DEEPSEEK2OCR: "deepseek2-ocr",
MODEL_ARCH.DEEPSEEK_V4: "deepseek-v4",
MODEL_ARCH.CHATGLM: "chatglm",
MODEL_ARCH.GLM4: "glm4",
MODEL_ARCH.GLM4_MOE: "glm4moe",
Expand Down Expand Up @@ -1340,6 +1383,37 @@ class MODEL_TENSOR(IntEnum):
MODEL_TENSOR.NEXTN_HNORM: "blk.{bid}.nextn.hnorm",
MODEL_TENSOR.NEXTN_SHARED_HEAD_HEAD: "blk.{bid}.nextn.shared_head_head",
MODEL_TENSOR.NEXTN_SHARED_HEAD_NORM: "blk.{bid}.nextn.shared_head_norm",
# DeepSeek-V4-Flash
MODEL_TENSOR.ATTN_KV: "blk.{bid}.attn_kv",
MODEL_TENSOR.ATTN_KV_NORM: "blk.{bid}.attn_kv_norm",
MODEL_TENSOR.ATTN_O_A: "blk.{bid}.attn_o_a",
MODEL_TENSOR.ATTN_O_B: "blk.{bid}.attn_o_b",
MODEL_TENSOR.COMPRESSOR_WKV: "blk.{bid}.compressor.wkv",
MODEL_TENSOR.COMPRESSOR_WGATE: "blk.{bid}.compressor.wgate",
MODEL_TENSOR.COMPRESSOR_APE: "blk.{bid}.compressor.ape",
MODEL_TENSOR.COMPRESSOR_NORM: "blk.{bid}.compressor.norm",
MODEL_TENSOR.INDEXER_COMPRESSOR_WKV: "blk.{bid}.indexer.compressor.wkv",
MODEL_TENSOR.INDEXER_COMPRESSOR_WGATE: "blk.{bid}.indexer.compressor.wgate",
MODEL_TENSOR.INDEXER_COMPRESSOR_APE: "blk.{bid}.indexer.compressor.ape",
MODEL_TENSOR.INDEXER_COMPRESSOR_NORM: "blk.{bid}.indexer.compressor.norm",
MODEL_TENSOR.HC_ATTN_FN: "blk.{bid}.hc_attn.fn",
MODEL_TENSOR.HC_ATTN_BASE: "blk.{bid}.hc_attn.base",
MODEL_TENSOR.HC_ATTN_SCALE: "blk.{bid}.hc_attn.scale",
MODEL_TENSOR.HC_FFN_FN: "blk.{bid}.hc_ffn.fn",
MODEL_TENSOR.HC_FFN_BASE: "blk.{bid}.hc_ffn.base",
MODEL_TENSOR.HC_FFN_SCALE: "blk.{bid}.hc_ffn.scale",
MODEL_TENSOR.HC_HEAD_FN: "output.hc_head.fn",
MODEL_TENSOR.HC_HEAD_BASE: "output.hc_head.base",
MODEL_TENSOR.HC_HEAD_SCALE: "output.hc_head.scale",
MODEL_TENSOR.FFN_GATE_TID2EID: "blk.{bid}.ffn_gate_tid2eid",
MODEL_TENSOR.MTP_E_PROJ: "blk.{bid}.mtp.e_proj",
MODEL_TENSOR.MTP_H_PROJ: "blk.{bid}.mtp.h_proj",
MODEL_TENSOR.MTP_ENORM: "blk.{bid}.mtp.enorm",
MODEL_TENSOR.MTP_HNORM: "blk.{bid}.mtp.hnorm",
MODEL_TENSOR.MTP_NORM: "blk.{bid}.mtp.norm",
MODEL_TENSOR.MTP_HC_HEAD_FN: "blk.{bid}.mtp.hc_head.fn",
MODEL_TENSOR.MTP_HC_HEAD_BASE: "blk.{bid}.mtp.hc_head.base",
MODEL_TENSOR.MTP_HC_HEAD_SCALE: "blk.{bid}.mtp.hc_head.scale",
}

MODEL_TENSORS: dict[MODEL_ARCH, list[MODEL_TENSOR]] = {
Expand Down Expand Up @@ -2816,6 +2890,64 @@ class MODEL_TENSOR(IntEnum):
MODEL_TENSOR.FFN_UP_SHEXP,
MODEL_TENSOR.FFN_EXP_PROBS_B,
],
MODEL_ARCH.DEEPSEEK_V4: [
# Top-level
MODEL_TENSOR.TOKEN_EMBD,
MODEL_TENSOR.OUTPUT_NORM,
MODEL_TENSOR.OUTPUT,
MODEL_TENSOR.HC_HEAD_FN,
MODEL_TENSOR.HC_HEAD_BASE,
MODEL_TENSOR.HC_HEAD_SCALE,
# Per-block (43 main + 1 MTP)
MODEL_TENSOR.ATTN_NORM,
MODEL_TENSOR.ATTN_Q_A,
MODEL_TENSOR.ATTN_Q_A_NORM,
MODEL_TENSOR.ATTN_Q_B,
MODEL_TENSOR.ATTN_KV,
MODEL_TENSOR.ATTN_KV_NORM,
MODEL_TENSOR.ATTN_O_A,
MODEL_TENSOR.ATTN_O_B,
MODEL_TENSOR.ATTN_SINKS,
# Compressor (CSA + HCA layers only; declared globally, loader skips on SWA layers)
MODEL_TENSOR.COMPRESSOR_WKV,
MODEL_TENSOR.COMPRESSOR_WGATE,
MODEL_TENSOR.COMPRESSOR_APE,
MODEL_TENSOR.COMPRESSOR_NORM,
# Indexer (CSA layers only; loaded but unused in MVP graph - dense fallback)
MODEL_TENSOR.INDEXER_ATTN_Q_B,
MODEL_TENSOR.INDEXER_PROJ,
MODEL_TENSOR.INDEXER_COMPRESSOR_WKV,
MODEL_TENSOR.INDEXER_COMPRESSOR_WGATE,
MODEL_TENSOR.INDEXER_COMPRESSOR_APE,
MODEL_TENSOR.INDEXER_COMPRESSOR_NORM,
# mHC per-block residual mapping
MODEL_TENSOR.HC_ATTN_FN,
MODEL_TENSOR.HC_ATTN_BASE,
MODEL_TENSOR.HC_ATTN_SCALE,
MODEL_TENSOR.HC_FFN_FN,
MODEL_TENSOR.HC_FFN_BASE,
MODEL_TENSOR.HC_FFN_SCALE,
# MoE
MODEL_TENSOR.FFN_NORM,
MODEL_TENSOR.FFN_GATE_INP,
MODEL_TENSOR.FFN_EXP_PROBS_B, # router bias on layers 3+
MODEL_TENSOR.FFN_GATE_TID2EID, # hash routing LUT on first n_hash_layers
MODEL_TENSOR.FFN_GATE_EXP,
MODEL_TENSOR.FFN_DOWN_EXP,
MODEL_TENSOR.FFN_UP_EXP,
MODEL_TENSOR.FFN_GATE_SHEXP,
MODEL_TENSOR.FFN_DOWN_SHEXP,
MODEL_TENSOR.FFN_UP_SHEXP,
# MTP (last block only; loaded but unused in MVP graph)
MODEL_TENSOR.MTP_E_PROJ,
MODEL_TENSOR.MTP_H_PROJ,
MODEL_TENSOR.MTP_ENORM,
MODEL_TENSOR.MTP_HNORM,
MODEL_TENSOR.MTP_NORM,
MODEL_TENSOR.MTP_HC_HEAD_FN,
MODEL_TENSOR.MTP_HC_HEAD_BASE,
MODEL_TENSOR.MTP_HC_HEAD_SCALE,
],
MODEL_ARCH.ERNIE4_5_MOE: [
MODEL_TENSOR.TOKEN_EMBD,
MODEL_TENSOR.OUTPUT_NORM,
Expand Down Expand Up @@ -4028,8 +4160,10 @@ class GGMLQuantizationType(IntEnum):


class ExpertGatingFuncType(IntEnum):
SOFTMAX = 1
SIGMOID = 2
SOFTMAX = 1
SIGMOID = 2
SOFTMAX_WEIGHT = 3 # applied to the router weights instead of the logits
SQRT_SOFTPLUS = 4 # DeepSeek-V4-Flash: probs = sqrt(softplus(logits))


# TODO: add GGMLFileType from ggml_ftype in ggml.h
Expand Down
25 changes: 25 additions & 0 deletions gguf-py/gguf/gguf_writer.py
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -913,6 +913,31 @@ def add_causal_attention(self, value: bool) -> None:
def add_q_lora_rank(self, length: int) -> None:
self.add_uint32(Keys.Attention.Q_LORA_RANK.format(arch=self.arch), length)

# DeepSeek-V4-Flash specific
def add_o_lora_rank(self, length: int) -> None:
self.add_uint32(Keys.Attention.O_LORA_RANK.format(arch=self.arch), length)

def add_o_groups(self, count: int) -> None:
self.add_uint32(Keys.Attention.O_GROUPS.format(arch=self.arch), count)

def add_compress_ratios(self, ratios: Sequence[int]) -> None:
self.add_array(Keys.Attention.COMPRESS_RATIOS.format(arch=self.arch), list(ratios))

def add_compress_rope_freq_base(self, base: float) -> None:
self.add_float32(Keys.Attention.COMPRESS_ROPE_FREQ_BASE.format(arch=self.arch), base)

def add_n_hash_layers(self, n: int) -> None:
self.add_uint32(Keys.LLM.N_HASH_LAYERS.format(arch=self.arch), n)

def add_hc_mult(self, n: int) -> None:
self.add_uint32(Keys.LLM.HC_MULT.format(arch=self.arch), n)

def add_hc_sinkhorn_iters(self, n: int) -> None:
self.add_uint32(Keys.LLM.HC_SINKHORN_ITERS.format(arch=self.arch), n)

def add_hc_eps(self, eps: float) -> None:
self.add_float32(Keys.LLM.HC_EPS.format(arch=self.arch), eps)

def add_kv_lora_rank(self, length: int) -> None:
self.add_uint32(Keys.Attention.KV_LORA_RANK.format(arch=self.arch), length)

Expand Down
72 changes: 72 additions & 0 deletions src/llama-arch.cpp
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -75,6 +75,7 @@ static const std::map<llm_arch, const char *> LLM_ARCH_NAMES = {
{ LLM_ARCH_DEEPSEEK, "deepseek" },
{ LLM_ARCH_DEEPSEEK2, "deepseek2" },
{ LLM_ARCH_DEEPSEEK2OCR, "deepseek2-ocr" },
{ LLM_ARCH_DEEPSEEK_V4, "deepseek-v4" },
{ LLM_ARCH_CHATGLM, "chatglm" },
{ LLM_ARCH_GLM4, "glm4" },
{ LLM_ARCH_GLM4_MOE, "glm4moe" },
Expand Down Expand Up @@ -241,6 +242,14 @@ static const std::map<llm_kv, const char *> LLM_KV_NAMES = {
{ LLM_KV_ATTENTION_INDEXER_HEAD_COUNT, "%s.attention.indexer.head_count" },
{ LLM_KV_ATTENTION_INDEXER_KEY_LENGTH, "%s.attention.indexer.key_length" },
{ LLM_KV_ATTENTION_INDEXER_TOP_K, "%s.attention.indexer.top_k" },
{ LLM_KV_ATTENTION_O_LORA_RANK, "%s.attention.o_lora_rank" },
{ LLM_KV_ATTENTION_O_GROUPS, "%s.attention.o_groups" },
{ LLM_KV_ATTENTION_COMPRESS_RATIOS, "%s.attention.compress_ratios" },
{ LLM_KV_ATTENTION_COMPRESS_ROPE_FREQ_BASE, "%s.attention.compress_rope_freq_base" },
{ LLM_KV_HC_MULT, "%s.hyperconnections.mult" },
{ LLM_KV_HC_SINKHORN_ITERS, "%s.hyperconnections.sinkhorn_iters" },
{ LLM_KV_HC_EPS, "%s.hyperconnections.eps" },
{ LLM_KV_N_HASH_LAYERS, "%s.n_hash_layers" },
{ LLM_KV_ATTENTION_SHARED_KV_LAYERS, "%s.attention.shared_kv_layers" },

{ LLM_KV_ROPE_DIMENSION_COUNT, "%s.rope.dimension_count" },
Expand Down Expand Up @@ -547,6 +556,37 @@ static const std::map<llm_tensor, const char *> LLM_TENSOR_NAMES = {
{ LLM_TENSOR_INDEXER_PROJ, "blk.%d.indexer.proj" },
{ LLM_TENSOR_INDEXER_ATTN_K, "blk.%d.indexer.attn_k" },
{ LLM_TENSOR_INDEXER_ATTN_Q_B, "blk.%d.indexer.attn_q_b" },
// DeepSeek-V4-Flash specific tensors
{ LLM_TENSOR_ATTN_KV, "blk.%d.attn_kv" },
{ LLM_TENSOR_ATTN_KV_NORM, "blk.%d.attn_kv_norm" },
{ LLM_TENSOR_ATTN_O_A, "blk.%d.attn_o_a" },
{ LLM_TENSOR_ATTN_O_B, "blk.%d.attn_o_b" },
{ LLM_TENSOR_COMPRESSOR_WKV, "blk.%d.compressor.wkv" },
{ LLM_TENSOR_COMPRESSOR_WGATE, "blk.%d.compressor.wgate" },
{ LLM_TENSOR_COMPRESSOR_APE, "blk.%d.compressor.ape" },
{ LLM_TENSOR_COMPRESSOR_NORM, "blk.%d.compressor.norm" },
{ LLM_TENSOR_INDEXER_COMPRESSOR_WKV, "blk.%d.indexer.compressor.wkv" },
{ LLM_TENSOR_INDEXER_COMPRESSOR_WGATE, "blk.%d.indexer.compressor.wgate" },
{ LLM_TENSOR_INDEXER_COMPRESSOR_APE, "blk.%d.indexer.compressor.ape" },
{ LLM_TENSOR_INDEXER_COMPRESSOR_NORM, "blk.%d.indexer.compressor.norm" },
{ LLM_TENSOR_HC_ATTN_FN, "blk.%d.hc_attn.fn" },
{ LLM_TENSOR_HC_ATTN_BASE, "blk.%d.hc_attn.base" },
{ LLM_TENSOR_HC_ATTN_SCALE, "blk.%d.hc_attn.scale" },
{ LLM_TENSOR_HC_FFN_FN, "blk.%d.hc_ffn.fn" },
{ LLM_TENSOR_HC_FFN_BASE, "blk.%d.hc_ffn.base" },
{ LLM_TENSOR_HC_FFN_SCALE, "blk.%d.hc_ffn.scale" },
{ LLM_TENSOR_HC_HEAD_FN, "output.hc_head.fn" },
{ LLM_TENSOR_HC_HEAD_BASE, "output.hc_head.base" },
{ LLM_TENSOR_HC_HEAD_SCALE, "output.hc_head.scale" },
{ LLM_TENSOR_FFN_GATE_TID2EID, "blk.%d.ffn_gate_tid2eid" },
{ LLM_TENSOR_MTP_E_PROJ, "blk.%d.mtp.e_proj" },
{ LLM_TENSOR_MTP_H_PROJ, "blk.%d.mtp.h_proj" },
{ LLM_TENSOR_MTP_ENORM, "blk.%d.mtp.enorm" },
{ LLM_TENSOR_MTP_HNORM, "blk.%d.mtp.hnorm" },
{ LLM_TENSOR_MTP_NORM, "blk.%d.mtp.norm" },
{ LLM_TENSOR_MTP_HC_HEAD_FN, "blk.%d.mtp.hc_head.fn" },
{ LLM_TENSOR_MTP_HC_HEAD_BASE, "blk.%d.mtp.hc_head.base" },
{ LLM_TENSOR_MTP_HC_HEAD_SCALE, "blk.%d.mtp.hc_head.scale" },
};

// declare information about the model weight tensors:
Expand Down Expand Up @@ -767,6 +807,37 @@ static const std::map<llm_tensor, llm_tensor_info> LLM_TENSOR_INFOS = {
// Nemotron 3 Super
{LLM_TENSOR_FFN_LATENT_DOWN, {LLM_TENSOR_LAYER_REPEATING, GGML_OP_MUL}},
{LLM_TENSOR_FFN_LATENT_UP, {LLM_TENSOR_LAYER_REPEATING, GGML_OP_MUL}},
// DeepSeek-V4-Flash
{LLM_TENSOR_ATTN_KV, {LLM_TENSOR_LAYER_REPEATING, GGML_OP_MUL_MAT}},
{LLM_TENSOR_ATTN_KV_NORM, {LLM_TENSOR_LAYER_REPEATING, GGML_OP_MUL}},
{LLM_TENSOR_ATTN_O_A, {LLM_TENSOR_LAYER_REPEATING, GGML_OP_MUL_MAT}},
{LLM_TENSOR_ATTN_O_B, {LLM_TENSOR_LAYER_REPEATING, GGML_OP_MUL_MAT}},
{LLM_TENSOR_COMPRESSOR_WKV, {LLM_TENSOR_LAYER_REPEATING, GGML_OP_MUL_MAT}},
{LLM_TENSOR_COMPRESSOR_WGATE, {LLM_TENSOR_LAYER_REPEATING, GGML_OP_MUL_MAT}},
{LLM_TENSOR_COMPRESSOR_APE, {LLM_TENSOR_LAYER_REPEATING, GGML_OP_ADD}},
{LLM_TENSOR_COMPRESSOR_NORM, {LLM_TENSOR_LAYER_REPEATING, GGML_OP_MUL}},
{LLM_TENSOR_INDEXER_COMPRESSOR_WKV, {LLM_TENSOR_LAYER_REPEATING, GGML_OP_MUL_MAT}},
{LLM_TENSOR_INDEXER_COMPRESSOR_WGATE, {LLM_TENSOR_LAYER_REPEATING, GGML_OP_MUL_MAT}},
{LLM_TENSOR_INDEXER_COMPRESSOR_APE, {LLM_TENSOR_LAYER_REPEATING, GGML_OP_ADD}},
{LLM_TENSOR_INDEXER_COMPRESSOR_NORM, {LLM_TENSOR_LAYER_REPEATING, GGML_OP_MUL}},
{LLM_TENSOR_HC_ATTN_FN, {LLM_TENSOR_LAYER_REPEATING, GGML_OP_MUL_MAT}},
{LLM_TENSOR_HC_ATTN_BASE, {LLM_TENSOR_LAYER_REPEATING, GGML_OP_ADD}},
{LLM_TENSOR_HC_ATTN_SCALE, {LLM_TENSOR_LAYER_REPEATING, GGML_OP_MUL}},
{LLM_TENSOR_HC_FFN_FN, {LLM_TENSOR_LAYER_REPEATING, GGML_OP_MUL_MAT}},
{LLM_TENSOR_HC_FFN_BASE, {LLM_TENSOR_LAYER_REPEATING, GGML_OP_ADD}},
{LLM_TENSOR_HC_FFN_SCALE, {LLM_TENSOR_LAYER_REPEATING, GGML_OP_MUL}},
{LLM_TENSOR_HC_HEAD_FN, {LLM_TENSOR_LAYER_OUTPUT, GGML_OP_MUL_MAT}},
{LLM_TENSOR_HC_HEAD_BASE, {LLM_TENSOR_LAYER_OUTPUT, GGML_OP_ADD}},
{LLM_TENSOR_HC_HEAD_SCALE, {LLM_TENSOR_LAYER_OUTPUT, GGML_OP_MUL}},
{LLM_TENSOR_FFN_GATE_TID2EID, {LLM_TENSOR_LAYER_REPEATING, GGML_OP_GET_ROWS}},
{LLM_TENSOR_MTP_E_PROJ, {LLM_TENSOR_LAYER_OUTPUT, GGML_OP_MUL_MAT}},
{LLM_TENSOR_MTP_H_PROJ, {LLM_TENSOR_LAYER_OUTPUT, GGML_OP_MUL_MAT}},
{LLM_TENSOR_MTP_ENORM, {LLM_TENSOR_LAYER_OUTPUT, GGML_OP_MUL}},
{LLM_TENSOR_MTP_HNORM, {LLM_TENSOR_LAYER_OUTPUT, GGML_OP_MUL}},
{LLM_TENSOR_MTP_NORM, {LLM_TENSOR_LAYER_OUTPUT, GGML_OP_MUL}},
{LLM_TENSOR_MTP_HC_HEAD_FN, {LLM_TENSOR_LAYER_OUTPUT, GGML_OP_MUL_MAT}},
{LLM_TENSOR_MTP_HC_HEAD_BASE, {LLM_TENSOR_LAYER_OUTPUT, GGML_OP_ADD}},
{LLM_TENSOR_MTP_HC_HEAD_SCALE, {LLM_TENSOR_LAYER_OUTPUT, GGML_OP_MUL}},
};

LLM_KV::LLM_KV(llm_arch arch, const char * suffix) : arch(arch), suffix(suffix) {}
Expand Down Expand Up @@ -890,6 +961,7 @@ bool llm_arch_supports_sm_tensor(const llm_arch & arch) {
case LLM_ARCH_OLMO2:
case LLM_ARCH_OLMOE:
case LLM_ARCH_DEEPSEEK2:
case LLM_ARCH_DEEPSEEK_V4:
case LLM_ARCH_GLM_DSA:
case LLM_ARCH_BITNET:
case LLM_ARCH_T5:
Expand Down
Loading